From 37e058783948f450f26dc863a694d28146a06d78 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Wed, 5 Mar 2008 18:54:05 +0000 Subject: [PATCH] remove the source location arguments to various target query methods. llvm-svn: 47954 --- clang/AST/ASTContext.cpp | 65 +++++++++---------- clang/AST/Expr.cpp | 55 +++++----------- clang/Analysis/GRExprEngine.cpp | 14 ++-- clang/Analysis/GRSimpleVals.cpp | 4 +- clang/Analysis/RValues.cpp | 7 +- clang/Analysis/ValueManager.cpp | 5 +- clang/Analysis/ValueState.cpp | 7 +- clang/Basic/TargetInfo.cpp | 11 ++-- clang/Basic/Targets.cpp | 47 -------------- clang/CodeGen/CGExprAgg.cpp | 6 +- clang/CodeGen/CGExprConstant.cpp | 16 ++--- clang/CodeGen/CGExprScalar.cpp | 13 ++-- clang/CodeGen/CodeGenFunction.cpp | 3 +- clang/CodeGen/CodeGenModule.cpp | 6 +- clang/CodeGen/CodeGenTypes.cpp | 11 ++-- clang/Driver/RewriteTest.cpp | 5 +- clang/Lex/LiteralSupport.cpp | 20 ++---- clang/Lex/PPExpressions.cpp | 17 ++--- clang/Sema/SemaDecl.cpp | 28 +++----- clang/Sema/SemaExpr.cpp | 38 +++++------ clang/Sema/SemaStmt.cpp | 3 +- clang/include/clang/AST/ASTContext.h | 12 ++-- .../Analysis/PathSensitive/GRExprEngine.h | 2 +- .../clang/Analysis/PathSensitive/RValues.h | 3 +- .../Analysis/PathSensitive/ValueManager.h | 9 +-- clang/include/clang/Basic/TargetInfo.h | 60 ++++++++--------- 26 files changed, 168 insertions(+), 299 deletions(-) diff --git a/clang/AST/ASTContext.cpp b/clang/AST/ASTContext.cpp index 2487abaecdbd..b5b28bc390be 100644 --- a/clang/AST/ASTContext.cpp +++ b/clang/AST/ASTContext.cpp @@ -133,7 +133,7 @@ void ASTContext::InitBuiltinTypes() { // C99 6.2.5p2. InitBuiltinType(BoolTy, BuiltinType::Bool); // C99 6.2.5p3. - if (Target.isCharSigned(FullSourceLoc())) + if (Target.isCharSigned()) InitBuiltinType(CharTy, BuiltinType::Char_S); else InitBuiltinType(CharTy, BuiltinType::Char_U); @@ -180,7 +180,7 @@ void ASTContext::InitBuiltinTypes() { /// getTypeSize - Return the size of the specified type, in bits. This method /// does not work on incomplete types. std::pair -ASTContext::getTypeInfo(QualType T, SourceLocation L) { +ASTContext::getTypeInfo(QualType T) { T = T.getCanonicalType(); uint64_t Size; unsigned Align; @@ -195,8 +195,7 @@ ASTContext::getTypeInfo(QualType T, SourceLocation L) { case Type::ConstantArray: { ConstantArrayType *CAT = cast(T); - std::pair EltInfo = - getTypeInfo(CAT->getElementType(), L); + std::pair EltInfo = getTypeInfo(CAT->getElementType()); Size = EltInfo.first*CAT->getSize().getZExtValue(); Align = EltInfo.second; break; @@ -204,7 +203,7 @@ ASTContext::getTypeInfo(QualType T, SourceLocation L) { case Type::OCUVector: case Type::Vector: { std::pair EltInfo = - getTypeInfo(cast(T)->getElementType(), L); + getTypeInfo(cast(T)->getElementType()); Size = EltInfo.first*cast(T)->getNumElements(); // FIXME: Vector alignment is not the alignment of its elements. Align = EltInfo.second; @@ -220,62 +219,62 @@ ASTContext::getTypeInfo(QualType T, SourceLocation L) { case BuiltinType::Void: assert(0 && "Incomplete types have no size!"); case BuiltinType::Bool: - Target.getBoolInfo(Size, Align, getFullLoc(L)); + Target.getBoolInfo(Size, Align); break; case BuiltinType::Char_S: case BuiltinType::Char_U: case BuiltinType::UChar: case BuiltinType::SChar: - Target.getCharInfo(Size, Align, getFullLoc(L)); + Target.getCharInfo(Size, Align); break; case BuiltinType::UShort: case BuiltinType::Short: - Target.getShortInfo(Size, Align, getFullLoc(L)); + Target.getShortInfo(Size, Align); break; case BuiltinType::UInt: case BuiltinType::Int: - Target.getIntInfo(Size, Align, getFullLoc(L)); + Target.getIntInfo(Size, Align); break; case BuiltinType::ULong: case BuiltinType::Long: - Target.getLongInfo(Size, Align, getFullLoc(L)); + Target.getLongInfo(Size, Align); break; case BuiltinType::ULongLong: case BuiltinType::LongLong: - Target.getLongLongInfo(Size, Align, getFullLoc(L)); + Target.getLongLongInfo(Size, Align); break; case BuiltinType::Float: - Target.getFloatInfo(Size, Align, F, getFullLoc(L)); + Target.getFloatInfo(Size, Align, F); break; case BuiltinType::Double: - Target.getDoubleInfo(Size, Align, F, getFullLoc(L)); + Target.getDoubleInfo(Size, Align, F); break; case BuiltinType::LongDouble: - Target.getLongDoubleInfo(Size, Align, F, getFullLoc(L)); + Target.getLongDoubleInfo(Size, Align, F); break; } break; } case Type::ASQual: - return getTypeInfo(QualType(cast(T)->getBaseType(), 0), L); + // FIXME: Pointers into different addr spaces could have different sizes and + // alignment requirements: getPointerInfo should take an AddrSpace. + return getTypeInfo(QualType(cast(T)->getBaseType(), 0)); case Type::ObjCQualifiedId: - Target.getPointerInfo(Size, Align, getFullLoc(L)); - break; case Type::Pointer: - Target.getPointerInfo(Size, Align, getFullLoc(L)); + Target.getPointerInfo(Size, Align); break; case Type::Reference: // "When applied to a reference or a reference type, the result is the size // of the referenced type." C++98 5.3.3p2: expr.sizeof. // FIXME: This is wrong for struct layout: a reference in a struct has // pointer size. - return getTypeInfo(cast(T)->getReferenceeType(), L); + return getTypeInfo(cast(T)->getReferenceeType()); case Type::Complex: { // Complex types have the same alignment as their elements, but twice the // size. std::pair EltInfo = - getTypeInfo(cast(T)->getElementType(), L); + getTypeInfo(cast(T)->getElementType()); Size = EltInfo.first*2; Align = EltInfo.second; break; @@ -283,11 +282,11 @@ ASTContext::getTypeInfo(QualType T, SourceLocation L) { case Type::Tagged: TagType *TT = cast(T); if (RecordType *RT = dyn_cast(TT)) { - const ASTRecordLayout &Layout = getASTRecordLayout(RT->getDecl(), L); + const ASTRecordLayout &Layout = getASTRecordLayout(RT->getDecl()); Size = Layout.getSize(); Align = Layout.getAlignment(); } else if (EnumDecl *ED = dyn_cast(TT->getDecl())) { - return getTypeInfo(ED->getIntegerType(), L); + return getTypeInfo(ED->getIntegerType()); } else { assert(0 && "Unimplemented type sizes!"); } @@ -301,8 +300,7 @@ ASTContext::getTypeInfo(QualType T, SourceLocation L) { /// getASTRecordLayout - Get or compute information about the layout of the /// specified record (struct/union/class), which indicates its size and field /// position information. -const ASTRecordLayout &ASTContext::getASTRecordLayout(const RecordDecl *D, - SourceLocation L) { +const ASTRecordLayout &ASTContext::getASTRecordLayout(const RecordDecl *D) { assert(D->isDefinition() && "Cannot get layout of forward declarations!"); // Look up this layout, if already laid out, return what we have. @@ -339,7 +337,7 @@ const ASTRecordLayout &ASTContext::getASTRecordLayout(const RecordDecl *D, assert (BitWidthIsICE && "Invalid BitField size expression"); FieldSize = I.getZExtValue(); - std::pair TypeInfo = getTypeInfo(FD->getType(), L); + std::pair TypeInfo = getTypeInfo(FD->getType()); uint64_t TypeSize = TypeInfo.first; if (const AlignedAttr *AA = FD->getAttr()) @@ -372,11 +370,11 @@ const ASTRecordLayout &ASTContext::getASTRecordLayout(const RecordDecl *D, FieldAlign = 8; else { const ArrayType* ATy = FD->getType()->getAsArrayType(); - FieldAlign = getTypeAlign(ATy->getElementType(), L); + FieldAlign = getTypeAlign(ATy->getElementType()); } FieldSize = 0; } else { - std::pair FieldInfo = getTypeInfo(FD->getType(), L); + std::pair FieldInfo = getTypeInfo(FD->getType()); FieldSize = FieldInfo.first; if (const AlignedAttr *AA = FD->getAttr()) @@ -408,7 +406,7 @@ const ASTRecordLayout &ASTContext::getASTRecordLayout(const RecordDecl *D, // Union layout just puts each member at the start of the record. for (unsigned i = 0, e = D->getNumMembers(); i != e; ++i) { const FieldDecl *FD = D->getMember(i); - std::pair FieldInfo = getTypeInfo(FD->getType(), L); + std::pair FieldInfo = getTypeInfo(FD->getType()); uint64_t FieldSize = FieldInfo.first; unsigned FieldAlign = FieldInfo.second; @@ -1073,16 +1071,15 @@ static bool isTypeTypedefedAsBOOL(QualType T) { /// getObjCEncodingTypeSize returns size of type for objective-c encoding /// purpose. int ASTContext::getObjCEncodingTypeSize(QualType type) { - SourceLocation Loc; - uint64_t sz = getTypeSize(type, Loc); + uint64_t sz = getTypeSize(type); // Make all integer and enum types at least as large as an int if (sz > 0 && type->isIntegralType()) - sz = std::max(sz, getTypeSize(IntTy, Loc)); + sz = std::max(sz, getTypeSize(IntTy)); // Treat arrays as pointers, since that's how they're passed in. else if (type->isArrayType()) - sz = getTypeSize(VoidPtrTy, Loc); - return sz / getTypeSize(CharTy, Loc); + sz = getTypeSize(VoidPtrTy); + return sz / getTypeSize(CharTy); } /// getObjCEncodingForMethodDecl - Return the encoded type for this method @@ -1098,7 +1095,7 @@ void ASTContext::getObjCEncodingForMethodDecl(ObjCMethodDecl *Decl, // Start with computing size of a pointer in number of bytes. // FIXME: There might(should) be a better way of doing this computation! SourceLocation Loc; - int PtrSize = getTypeSize(VoidPtrTy, Loc) / getTypeSize(CharTy, Loc); + int PtrSize = getTypeSize(VoidPtrTy) / getTypeSize(CharTy); // The first two arguments (self and _cmd) are pointers; account for // their size. int ParmOffset = 2 * PtrSize; diff --git a/clang/AST/Expr.cpp b/clang/AST/Expr.cpp index 1c32d7cd77dd..11fcc419a514 100644 --- a/clang/AST/Expr.cpp +++ b/clang/AST/Expr.cpp @@ -510,8 +510,7 @@ bool Expr::isConstantExpr(ASTContext &Ctx, SourceLocation *Loc) const { case CallExprClass: { const CallExpr *CE = cast(this); llvm::APSInt Result(32); - Result.zextOrTrunc( - static_cast(Ctx.getTypeSize(getType(), CE->getLocStart()))); + Result.zextOrTrunc(static_cast(Ctx.getTypeSize(getType()))); if (CE->isBuiltinClassifyType(Result)) return true; if (CE->isBuiltinConstantExpr()) @@ -673,23 +672,20 @@ bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx, break; case CharacterLiteralClass: { const CharacterLiteral *CL = cast(this); - Result.zextOrTrunc( - static_cast(Ctx.getTypeSize(getType(), CL->getLoc()))); + Result.zextOrTrunc(static_cast(Ctx.getTypeSize(getType()))); Result = CL->getValue(); Result.setIsUnsigned(!getType()->isSignedIntegerType()); break; } case TypesCompatibleExprClass: { const TypesCompatibleExpr *TCE = cast(this); - Result.zextOrTrunc( - static_cast(Ctx.getTypeSize(getType(), TCE->getLocStart()))); + Result.zextOrTrunc(static_cast(Ctx.getTypeSize(getType()))); Result = Ctx.typesAreCompatible(TCE->getArgType1(), TCE->getArgType2()); break; } case CallExprClass: { const CallExpr *CE = cast(this); - Result.zextOrTrunc( - static_cast(Ctx.getTypeSize(getType(), CE->getLocStart()))); + Result.zextOrTrunc(static_cast(Ctx.getTypeSize(getType()))); if (CE->isBuiltinClassifyType(Result)) break; if (Loc) *Loc = getLocStart(); @@ -723,9 +719,7 @@ bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx, case UnaryOperator::SizeOf: case UnaryOperator::AlignOf: // Return the result in the right width. - Result.zextOrTrunc( - static_cast(Ctx.getTypeSize(getType(), - Exp->getOperatorLoc()))); + Result.zextOrTrunc(static_cast(Ctx.getTypeSize(getType()))); // sizeof(void) and __alignof__(void) = 1 as a gcc extension. if (Exp->getSubExpr()->getType()->isVoidType()) { @@ -744,22 +738,16 @@ bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx, // GCC extension: sizeof(function) = 1. Result = Exp->getOpcode() == UnaryOperator::AlignOf ? 4 : 1; } else { - unsigned CharSize = - Ctx.Target.getCharWidth(Ctx.getFullLoc(Exp->getOperatorLoc())); - + unsigned CharSize = Ctx.Target.getCharWidth(); if (Exp->getOpcode() == UnaryOperator::AlignOf) - Result = Ctx.getTypeAlign(Exp->getSubExpr()->getType(), - Exp->getOperatorLoc()) / CharSize; + Result = Ctx.getTypeAlign(Exp->getSubExpr()->getType()) / CharSize; else - Result = Ctx.getTypeSize(Exp->getSubExpr()->getType(), - Exp->getOperatorLoc()) / CharSize; + Result = Ctx.getTypeSize(Exp->getSubExpr()->getType()) / CharSize; } break; case UnaryOperator::LNot: { bool Val = Result == 0; - Result.zextOrTrunc( - static_cast(Ctx.getTypeSize(getType(), - Exp->getOperatorLoc()))); + Result.zextOrTrunc(static_cast(Ctx.getTypeSize(getType()))); Result = Val; break; } @@ -780,8 +768,7 @@ bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx, const SizeOfAlignOfTypeExpr *Exp = cast(this); // Return the result in the right width. - Result.zextOrTrunc( - static_cast(Ctx.getTypeSize(getType(), Exp->getOperatorLoc()))); + Result.zextOrTrunc(static_cast(Ctx.getTypeSize(getType()))); // sizeof(void) and __alignof__(void) = 1 as a gcc extension. if (Exp->getArgumentType()->isVoidType()) { @@ -800,17 +787,12 @@ bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx, // GCC extension: sizeof(function) = 1. Result = Exp->isSizeOf() ? 1 : 4; } else { - unsigned CharSize = - Ctx.Target.getCharWidth(Ctx.getFullLoc(Exp->getOperatorLoc())); - + unsigned CharSize = Ctx.Target.getCharWidth(); if (Exp->isSizeOf()) - Result = Ctx.getTypeSize(Exp->getArgumentType(), - Exp->getOperatorLoc()) / CharSize; + Result = Ctx.getTypeSize(Exp->getArgumentType()) / CharSize; else - Result = Ctx.getTypeAlign(Exp->getArgumentType(), - Exp->getOperatorLoc()) / CharSize; + Result = Ctx.getTypeAlign(Exp->getArgumentType()) / CharSize; } - break; } case BinaryOperatorClass: { @@ -927,8 +909,7 @@ bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx, return false; } - uint32_t DestWidth = - static_cast(Ctx.getTypeSize(getType(), CastLoc)); + uint32_t DestWidth = static_cast(Ctx.getTypeSize(getType())); // Handle simple integer->integer casts. if (SubExpr->getType()->isIntegerType()) { @@ -1140,7 +1121,7 @@ static int64_t evaluateOffsetOf(ASTContext& C, const Expr *E) QualType Ty = ME->getBase()->getType(); RecordDecl *RD = Ty->getAsRecordType()->getDecl(); - const ASTRecordLayout &RL = C.getASTRecordLayout(RD, SourceLocation()); + const ASTRecordLayout &RL = C.getASTRecordLayout(RD); FieldDecl *FD = ME->getMemberDecl(); // FIXME: This is linear time. @@ -1157,7 +1138,7 @@ static int64_t evaluateOffsetOf(ASTContext& C, const Expr *E) bool ICE = ASE->getIdx()->isIntegerConstantExpr(Idx, C); assert(ICE && "Array index is not a constant integer!"); - int64_t size = C.getTypeSize(ASE->getType(), SourceLocation()); + int64_t size = C.getTypeSize(ASE->getType()); size *= Idx.getSExtValue(); return size + evaluateOffsetOf(C, Base); @@ -1172,9 +1153,7 @@ int64_t UnaryOperator::evaluateOffsetOf(ASTContext& C) const { assert(Opc == OffsetOf && "Unary operator not offsetof!"); - unsigned CharSize = - C.Target.getCharWidth(C.getFullLoc(getOperatorLoc())); - + unsigned CharSize = C.Target.getCharWidth(); return ::evaluateOffsetOf(C, Val) / CharSize; } diff --git a/clang/Analysis/GRExprEngine.cpp b/clang/Analysis/GRExprEngine.cpp index 2481f568386a..4cd942b57e72 100644 --- a/clang/Analysis/GRExprEngine.cpp +++ b/clang/Analysis/GRExprEngine.cpp @@ -277,8 +277,7 @@ void GRExprEngine::ProcessSwitch(SwitchNodeBuilder& builder) { // While most of this can be assumed (such as the signedness), having it // just computed makes sure everything makes the same assumptions end-to-end. - unsigned bits = getContext().getTypeSize(CondE->getType(), - CondE->getExprLoc()); + unsigned bits = getContext().getTypeSize(CondE->getType()); APSInt V1(bits, false); APSInt V2 = V1; @@ -716,10 +715,8 @@ void GRExprEngine::VisitSizeOfAlignOfTypeExpr(SizeOfAlignOfTypeExpr* Ex, uint64_t size = 1; // Handle sizeof(void) - if (T != getContext().VoidTy) { - SourceLocation Loc = Ex->getExprLoc(); - size = getContext().getTypeSize(T, Loc) / 8; - } + if (T != getContext().VoidTy) + size = getContext().getTypeSize(T) / 8; Nodify(Dst, Ex, Pred, SetRVal(Pred->getState(), Ex, @@ -949,10 +946,9 @@ void GRExprEngine::VisitSizeOfExpr(UnaryOperator* U, NodeTy* Pred, if (!T.getTypePtr()->isConstantSizeType()) return; - SourceLocation Loc = U->getExprLoc(); - uint64_t size = getContext().getTypeSize(T, Loc) / 8; + uint64_t size = getContext().getTypeSize(T) / 8; ValueState* St = Pred->getState(); - St = SetRVal(St, U, NonLVal::MakeVal(ValMgr, size, U->getType(), Loc)); + St = SetRVal(St, U, NonLVal::MakeVal(ValMgr, size, U->getType())); Nodify(Dst, U, Pred, St); } diff --git a/clang/Analysis/GRSimpleVals.cpp b/clang/Analysis/GRSimpleVals.cpp index d8a3112b1a30..c00800c1416f 100644 --- a/clang/Analysis/GRSimpleVals.cpp +++ b/clang/Analysis/GRSimpleVals.cpp @@ -160,7 +160,7 @@ RVal GRSimpleVals::EvalCast(ValueManager& ValMgr, NonLVal X, QualType T) { llvm::APSInt V = cast(X).getValue(); V.setIsUnsigned(T->isUnsignedIntegerType() || T->isPointerType()); - V.extOrTrunc(ValMgr.getContext().getTypeSize(T, SourceLocation())); + V.extOrTrunc(ValMgr.getContext().getTypeSize(T)); if (T->isPointerType()) return lval::ConcreteInt(ValMgr.getValue(V)); @@ -182,7 +182,7 @@ RVal GRSimpleVals::EvalCast(ValueManager& ValMgr, LVal X, QualType T) { llvm::APSInt V = cast(X).getValue(); V.setIsUnsigned(T->isUnsignedIntegerType() || T->isPointerType()); - V.extOrTrunc(ValMgr.getContext().getTypeSize(T, SourceLocation())); + V.extOrTrunc(ValMgr.getContext().getTypeSize(T)); return nonlval::ConcreteInt(ValMgr.getValue(V)); } diff --git a/clang/Analysis/RValues.cpp b/clang/Analysis/RValues.cpp index 6369da4d7ffb..36ea2df0e8b8 100644 --- a/clang/Analysis/RValues.cpp +++ b/clang/Analysis/RValues.cpp @@ -207,10 +207,8 @@ NonLVal LVal::NE(ValueManager& ValMgr, const LVal& R) const { // Utility methods for constructing Non-LVals. //===----------------------------------------------------------------------===// -NonLVal NonLVal::MakeVal(ValueManager& ValMgr, uint64_t X, QualType T, - SourceLocation Loc) { - - return nonlval::ConcreteInt(ValMgr.getValue(X, T, Loc)); +NonLVal NonLVal::MakeVal(ValueManager& ValMgr, uint64_t X, QualType T) { + return nonlval::ConcreteInt(ValMgr.getValue(X, T)); } NonLVal NonLVal::MakeVal(ValueManager& ValMgr, IntegerLiteral* I) { @@ -220,7 +218,6 @@ NonLVal NonLVal::MakeVal(ValueManager& ValMgr, IntegerLiteral* I) { } NonLVal NonLVal::MakeIntTruthVal(ValueManager& ValMgr, bool b) { - return nonlval::ConcreteInt(ValMgr.getTruthValue(b)); } diff --git a/clang/Analysis/ValueManager.cpp b/clang/Analysis/ValueManager.cpp index 2a8d23d02ca2..a02f3e45efd3 100644 --- a/clang/Analysis/ValueManager.cpp +++ b/clang/Analysis/ValueManager.cpp @@ -48,10 +48,9 @@ const llvm::APSInt& ValueManager::getValue(uint64_t X, unsigned BitWidth, return getValue(V); } -const llvm::APSInt& ValueManager::getValue(uint64_t X, QualType T, - SourceLocation Loc) { +const llvm::APSInt& ValueManager::getValue(uint64_t X, QualType T) { - unsigned bits = Ctx.getTypeSize(T, Loc); + unsigned bits = Ctx.getTypeSize(T); llvm::APSInt V(bits, T->isUnsignedIntegerType()); V = X; return getValue(V); diff --git a/clang/Analysis/ValueState.cpp b/clang/Analysis/ValueState.cpp index 388dba67dae2..f47e14bb7087 100644 --- a/clang/Analysis/ValueState.cpp +++ b/clang/Analysis/ValueState.cpp @@ -258,8 +258,7 @@ RVal ValueStateManager::GetRVal(ValueState* St, Expr* E) { case Stmt::CharacterLiteralClass: { CharacterLiteral* C = cast(E); - return NonLVal::MakeVal(ValMgr, C->getValue(), C->getType(), - C->getLoc()); + return NonLVal::MakeVal(ValMgr, C->getValue(), C->getType()); } case Stmt::IntegerLiteralClass: { @@ -271,7 +270,6 @@ RVal ValueStateManager::GetRVal(ValueState* St, Expr* E) { // subexpression that has a value. case Stmt::ImplicitCastExprClass: { - ImplicitCastExpr* C = cast(E); QualType CT = C->getType(); @@ -341,8 +339,7 @@ RVal ValueStateManager::GetBlkExprRVal(ValueState* St, Expr* E) { switch (E->getStmtClass()) { case Stmt::CharacterLiteralClass: { CharacterLiteral* C = cast(E); - return NonLVal::MakeVal(ValMgr, C->getValue(), C->getType(), - C->getLoc()); + return NonLVal::MakeVal(ValMgr, C->getValue(), C->getType()); } case Stmt::IntegerLiteralClass: { diff --git a/clang/Basic/TargetInfo.cpp b/clang/Basic/TargetInfo.cpp index 8701b38a0f1d..1f0becee3413 100644 --- a/clang/Basic/TargetInfo.cpp +++ b/clang/Basic/TargetInfo.cpp @@ -28,22 +28,19 @@ void TargetInfoImpl::ANCHOR() {} // out-of-line virtual method for class. // TargetInfoImpl. void TargetInfo::getFloatInfo(uint64_t &Size, unsigned &Align, - const llvm::fltSemantics *&Format, - FullSourceLoc Loc) { + const llvm::fltSemantics *&Format) { Align = 32; // FIXME: implement correctly. Size = 32; Format = &llvm::APFloat::IEEEsingle; } void TargetInfo::getDoubleInfo(uint64_t &Size, unsigned &Align, - const llvm::fltSemantics *&Format, - FullSourceLoc Loc) { + const llvm::fltSemantics *&Format) { Size = 64; // FIXME: implement correctly. Align = 32; Format = &llvm::APFloat::IEEEdouble; } void TargetInfo::getLongDoubleInfo(uint64_t &Size, unsigned &Align, - const llvm::fltSemantics *&Format, - FullSourceLoc Loc) { + const llvm::fltSemantics *&Format) { Size = Align = 64; // FIXME: implement correctly. Format = &llvm::APFloat::IEEEdouble; //Size = 80; Align = 32; // FIXME: implement correctly. @@ -74,7 +71,7 @@ void TargetInfo::getTargetDefines(std::vector &Buffer) { /// ComputeWCharWidth - Determine the width of the wchar_t type for the primary /// target, diagnosing whether this is non-portable across the secondary /// targets. -void TargetInfo::ComputeWCharInfo(FullSourceLoc Loc) { +void TargetInfo::ComputeWCharInfo() { Target->getWCharInfo(WCharWidth, WCharAlign); } diff --git a/clang/Basic/Targets.cpp b/clang/Basic/Targets.cpp index d170fbefb65f..89125b42ebcd 100644 --- a/clang/Basic/Targets.cpp +++ b/clang/Basic/Targets.cpp @@ -722,50 +722,6 @@ public: } // end anonymous namespace. -namespace { -class LinuxTargetInfo : public DarwinTargetInfo { -public: - LinuxTargetInfo(const std::string& triple) : DarwinTargetInfo(triple) { - // Note: I have no idea if this is right, just for testing. - WCharWidth = 16; - WCharAlign = 16; - } - - virtual void getTargetDefines(std::vector &Defines) const { - // TODO: linux-specific stuff. - getX86Defines(Defines, false); - } - virtual void getTargetBuiltins(const Builtin::Info *&Records, - unsigned &NumRecords) const { - X86::getBuiltins(Records, NumRecords); - } - virtual const char *getVAListDeclaration() const { - return getI386VAListDeclaration(); - } - virtual const char *getTargetPrefix() const { - return X86::getTargetPrefix(); - } - virtual void getGCCRegNames(const char * const *&Names, - unsigned &NumNames) const { - X86::getGCCRegNames(Names, NumNames); - } - virtual void getGCCRegAliases(const GCCRegAlias *&Aliases, - unsigned &NumAliases) const { - X86::getGCCRegAliases(Aliases, NumAliases); - } - virtual bool validateAsmConstraint(char c, - TargetInfo::ConstraintInfo &info) const { - return X86::validateAsmConstraint(c, info); - } - virtual std::string convertConstraint(const char Constraint) const { - return X86::convertConstraint(Constraint); - } - virtual const char *getClobbers() const { - return X86::getClobbers(); - } -}; -} // end anonymous namespace. - //===----------------------------------------------------------------------===// // Driver code @@ -794,9 +750,6 @@ TargetInfo* TargetInfo::CreateTargetInfo(const std::string &T) { if (IsX86(T)) return new TargetInfo(new DarwinI386TargetInfo(T)); - if (T.find("bogusW16W16-") == 0) // For testing portability. - return new TargetInfo(new LinuxTargetInfo(T)); - return NULL; } diff --git a/clang/CodeGen/CGExprAgg.cpp b/clang/CodeGen/CGExprAgg.cpp index 493d2790085a..325ac2109ebc 100644 --- a/clang/CodeGen/CGExprAgg.cpp +++ b/clang/CodeGen/CGExprAgg.cpp @@ -103,8 +103,7 @@ void AggExprEmitter::EmitAggregateClear(llvm::Value *DestPtr, QualType Ty) { DestPtr = Builder.CreateBitCast(DestPtr, BP, "tmp"); // Get size and alignment info for this aggregate. - std::pair TypeInfo = - CGF.getContext().getTypeInfo(Ty, SourceLocation()); + std::pair TypeInfo = CGF.getContext().getTypeInfo(Ty); // FIXME: Handle variable sized types. const llvm::Type *IntPtr = llvm::IntegerType::get(CGF.LLVMPointerWidth); @@ -132,8 +131,7 @@ void AggExprEmitter::EmitAggregateCopy(llvm::Value *DestPtr, SrcPtr = Builder.CreateBitCast(SrcPtr, BP, "tmp"); // Get size and alignment info for this aggregate. - std::pair TypeInfo = - CGF.getContext().getTypeInfo(Ty, SourceLocation()); + std::pair TypeInfo = CGF.getContext().getTypeInfo(Ty); // FIXME: Handle variable sized types. const llvm::Type *IntPtr = llvm::IntegerType::get(CGF.LLVMPointerWidth); diff --git a/clang/CodeGen/CGExprConstant.cpp b/clang/CodeGen/CGExprConstant.cpp index 30180c17744a..e2405b88f37e 100644 --- a/clang/CodeGen/CGExprConstant.cpp +++ b/clang/CodeGen/CGExprConstant.cpp @@ -37,7 +37,8 @@ public: llvm::Constant *VisitStmt(Stmt *S) { CGM.WarnUnsupported(S, "constant expression"); - return llvm::UndefValue::get(CGM.getTypes().ConvertType(cast(S)->getType())); + QualType T = cast(S)->getType(); + return llvm::UndefValue::get(CGM.getTypes().ConvertType(T)); } llvm::Constant *VisitParenExpr(ParenExpr *PE) { @@ -314,8 +315,8 @@ public: assert(E->getType()->isIntegerType() && "Result type must be an integer!"); - uint32_t ResultWidth = static_cast( - CGM.getContext().getTypeSize(E->getType(), SourceLocation())); + uint32_t ResultWidth = + static_cast(CGM.getContext().getTypeSize(E->getType())); return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val)); } @@ -504,15 +505,15 @@ public: llvm::Constant *EmitSizeAlignOf(QualType TypeToSize, QualType RetType, bool isSizeOf) { std::pair Info = - CGM.getContext().getTypeInfo(TypeToSize, SourceLocation()); + CGM.getContext().getTypeInfo(TypeToSize); uint64_t Val = isSizeOf ? Info.first : Info.second; Val /= 8; // Return size in bytes, not bits. assert(RetType->isIntegerType() && "Result type must be an integer!"); - uint32_t ResultWidth = static_cast( - CGM.getContext().getTypeSize(RetType, SourceLocation())); + uint32_t ResultWidth = + static_cast(CGM.getContext().getTypeSize(RetType)); return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val)); } @@ -616,8 +617,7 @@ llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E, QualType type = E->getType().getCanonicalType(); if (type->isIntegerType()) { - llvm::APSInt - Value(static_cast(Context.getTypeSize(type, SourceLocation()))); + llvm::APSInt Value(static_cast(Context.getTypeSize(type))); if (E->isIntegerConstantExpr(Value, Context)) { return llvm::ConstantInt::get(Value); } diff --git a/clang/CodeGen/CGExprScalar.cpp b/clang/CodeGen/CGExprScalar.cpp index 52b022b6611e..892712a0d4ca 100644 --- a/clang/CodeGen/CGExprScalar.cpp +++ b/clang/CodeGen/CGExprScalar.cpp @@ -656,16 +656,14 @@ Value *ScalarExprEmitter::EmitSizeAlignOf(QualType TypeToSize, QualType RetType,bool isSizeOf){ assert(RetType->isIntegerType() && "Result type must be an integer!"); uint32_t ResultWidth = - static_cast(CGF.getContext().getTypeSize(RetType, - SourceLocation())); + static_cast(CGF.getContext().getTypeSize(RetType)); // sizeof(void) and __alignof__(void) = 1 as a gcc extension. if (TypeToSize->isVoidType()) return llvm::ConstantInt::get(llvm::APInt(ResultWidth, 1)); /// FIXME: This doesn't handle VLAs yet! - std::pair Info = - CGF.getContext().getTypeInfo(TypeToSize, SourceLocation()); + std::pair Info = CGF.getContext().getTypeInfo(TypeToSize); uint64_t Val = isSizeOf ? Info.first : Info.second; Val /= 8; // Return size in bytes, not bits. @@ -696,8 +694,8 @@ Value *ScalarExprEmitter::VisitUnaryOffsetOf(const UnaryOperator *E) assert(E->getType()->isIntegerType() && "Result type must be an integer!"); - uint32_t ResultWidth = static_cast( - CGF.getContext().getTypeSize(E->getType(), SourceLocation())); + uint32_t ResultWidth = + static_cast(CGF.getContext().getTypeSize(E->getType())); return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val)); } @@ -852,8 +850,7 @@ Value *ScalarExprEmitter::VisitBinSub(const BinaryOperator *E) { const QualType LHSType = E->getLHS()->getType().getCanonicalType(); const QualType LHSElementType = cast(LHSType)->getPointeeType(); - uint64_t ElementSize = CGF.getContext().getTypeSize(LHSElementType, - SourceLocation()) / 8; + uint64_t ElementSize = CGF.getContext().getTypeSize(LHSElementType) / 8; const llvm::Type *ResultType = ConvertType(E->getType()); LHS = Builder.CreatePtrToInt(LHS, ResultType, "sub.ptr.lhs.cast"); diff --git a/clang/CodeGen/CodeGenFunction.cpp b/clang/CodeGen/CodeGenFunction.cpp index adbb414cc099..f48d093b25e5 100644 --- a/clang/CodeGen/CodeGenFunction.cpp +++ b/clang/CodeGen/CodeGenFunction.cpp @@ -59,8 +59,7 @@ bool CodeGenFunction::hasAggregateLLVMType(QualType T) { void CodeGenFunction::GenerateCode(const FunctionDecl *FD) { LLVMIntTy = ConvertType(getContext().IntTy); LLVMPointerWidth = static_cast( - getContext().getTypeSize(getContext().getPointerType(getContext().VoidTy), - SourceLocation())); + getContext().getTypeSize(getContext().getPointerType(getContext().VoidTy))); CurFuncDecl = FD; CurFn = cast(CGM.GetAddrOfFunctionDecl(FD, true)); diff --git a/clang/CodeGen/CodeGenModule.cpp b/clang/CodeGen/CodeGenModule.cpp index 1a6979621468..554fc3fbebe9 100644 --- a/clang/CodeGen/CodeGenModule.cpp +++ b/clang/CodeGen/CodeGenModule.cpp @@ -231,7 +231,7 @@ void CodeGenModule::EmitGlobalVar(const FileVarDecl *D) { Init = llvm::Constant::getNullValue(GV->getType()->getElementType()); } else if (D->getType()->isIntegerType()) { llvm::APSInt Value(static_cast( - getContext().getTypeSize(D->getInit()->getType(), SourceLocation()))); + getContext().getTypeSize(D->getInit()->getType()))); if (D->getInit()->isIntegerConstantExpr(Value, Context)) Init = llvm::ConstantInt::get(Value); } @@ -340,7 +340,7 @@ llvm::Function *CodeGenModule::getMemCpyFn() { if (MemCpyFn) return MemCpyFn; llvm::Intrinsic::ID IID; uint64_t Size; unsigned Align; - Context.Target.getPointerInfo(Size, Align, FullSourceLoc()); + Context.Target.getPointerInfo(Size, Align); switch (Size) { default: assert(0 && "Unknown ptr width"); case 32: IID = llvm::Intrinsic::memcpy_i32; break; @@ -353,7 +353,7 @@ llvm::Function *CodeGenModule::getMemSetFn() { if (MemSetFn) return MemSetFn; llvm::Intrinsic::ID IID; uint64_t Size; unsigned Align; - Context.Target.getPointerInfo(Size, Align, FullSourceLoc()); + Context.Target.getPointerInfo(Size, Align); switch (Size) { default: assert(0 && "Unknown ptr width"); case 32: IID = llvm::Intrinsic::memset_i32; break; diff --git a/clang/CodeGen/CodeGenTypes.cpp b/clang/CodeGen/CodeGenTypes.cpp index efdc0e8e5bc0..9a669e87056f 100644 --- a/clang/CodeGen/CodeGenTypes.cpp +++ b/clang/CodeGen/CodeGenTypes.cpp @@ -118,8 +118,7 @@ const llvm::Type *CodeGenTypes::ConvertTypeForMem(QualType T) { return R; // Otherwise, return an integer of the target-specified size. - unsigned BoolWidth = (unsigned)Context.getTypeSize(T, SourceLocation()); - return llvm::IntegerType::get(BoolWidth); + return llvm::IntegerType::get((unsigned)Context.getTypeSize(T)); } @@ -179,7 +178,7 @@ const llvm::Type *CodeGenTypes::ConvertNewType(QualType T) { case BuiltinType::LongLong: case BuiltinType::ULongLong: return llvm::IntegerType::get( - static_cast(Context.getTypeSize(T, SourceLocation()))); + static_cast(Context.getTypeSize(T))); case BuiltinType::Float: return llvm::Type::FloatTy; case BuiltinType::Double: return llvm::Type::DoubleTy; @@ -356,7 +355,7 @@ const llvm::Type *CodeGenTypes::ConvertTagDeclType(const TagDecl *TD) { for (unsigned i = 0, e = RD->getNumMembers(); i != e; ++i) RO.addField(RD->getMember(i)); - RO.layoutStructFields(Context.getASTRecordLayout(RD, SourceLocation())); + RO.layoutStructFields(Context.getASTRecordLayout(RD)); // Get llvm::StructType. CGRecordLayouts[TD] = new CGRecordLayout(RO.getLLVMType(), @@ -514,7 +513,7 @@ void RecordOrganizer::layoutUnionFields() { unsigned PrimaryEltNo = 0; std::pair PrimaryElt = - CGT.getContext().getTypeInfo(FieldDecls[0]->getType(), SourceLocation()); + CGT.getContext().getTypeInfo(FieldDecls[0]->getType()); CGT.addFieldInfo(FieldDecls[0], 0); unsigned Size = FieldDecls.size(); @@ -522,7 +521,7 @@ void RecordOrganizer::layoutUnionFields() { const FieldDecl *FD = FieldDecls[i]; assert (!FD->isBitField() && "Bit fields are not yet supported"); std::pair EltInfo = - CGT.getContext().getTypeInfo(FD->getType(), SourceLocation()); + CGT.getContext().getTypeInfo(FD->getType()); // Use largest element, breaking ties with the hightest aligned member. if (EltInfo.first > PrimaryElt.first || diff --git a/clang/Driver/RewriteTest.cpp b/clang/Driver/RewriteTest.cpp index beabe92659ed..097aa1b3a598 100644 --- a/clang/Driver/RewriteTest.cpp +++ b/clang/Driver/RewriteTest.cpp @@ -2037,9 +2037,8 @@ Stmt *RewriteTest::SynthMessageExpr(ObjCMessageExpr *Exp) { // FIXME: Value of 8 is base on ppc32/x86 ABI for the most common cases. // For X86 it is more complicated and some kind of target specific routine // is needed to decide what to do. - unsigned IntSize = static_cast( - Context->getTypeSize(Context->IntTy, SourceLocation())); - + unsigned IntSize = + static_cast(Context->getTypeSize(Context->IntTy)); IntegerLiteral *limit = new IntegerLiteral(llvm::APInt(IntSize, 8), Context->IntTy, SourceLocation()); diff --git a/clang/Lex/LiteralSupport.cpp b/clang/Lex/LiteralSupport.cpp index 34ddfbac2de3..aa0b831af900 100644 --- a/clang/Lex/LiteralSupport.cpp +++ b/clang/Lex/LiteralSupport.cpp @@ -93,9 +93,7 @@ static unsigned ProcessCharEscape(const char *&ThisTokBuf, } // See if any bits will be truncated when evaluated as a character. - unsigned CharWidth = IsWide - ? PP.getTargetInfo().getWCharWidth(PP.getFullLoc(Loc)) - : PP.getTargetInfo().getCharWidth(PP.getFullLoc(Loc)); + unsigned CharWidth = PP.getTargetInfo().getCharWidth(IsWide); if (CharWidth != 32 && (ResultChar >> CharWidth) != 0) { Overflow = true; @@ -124,9 +122,7 @@ static unsigned ProcessCharEscape(const char *&ThisTokBuf, ThisTokBuf[0] >= '0' && ThisTokBuf[0] <= '7'); // Check for overflow. Reject '\777', but not L'\777'. - unsigned CharWidth = IsWide - ? PP.getTargetInfo().getWCharWidth(PP.getFullLoc(Loc)) - : PP.getTargetInfo().getCharWidth(PP.getFullLoc(Loc)); + unsigned CharWidth = PP.getTargetInfo().getCharWidth(IsWide); if (CharWidth != 32 && (ResultChar >> CharWidth) != 0) { PP.Diag(Loc, diag::warn_octal_escape_too_large); @@ -457,13 +453,13 @@ CharLiteralParser::CharLiteralParser(const char *begin, const char *end, // FIXME: This assumes that 'int' is 32-bits in overflow calculation, and the // size of "value". - assert(PP.getTargetInfo().getIntWidth(PP.getFullLoc(Loc)) == 32 && + assert(PP.getTargetInfo().getIntWidth() == 32 && "Assumes sizeof(int) == 4 for now"); // FIXME: This assumes that wchar_t is 32-bits for now. - assert(PP.getTargetInfo().getWCharWidth(PP.getFullLoc(Loc)) == 32 && + assert(PP.getTargetInfo().getWCharWidth() == 32 && "Assumes sizeof(wchar_t) == 4 for now"); // FIXME: This extensively assumes that 'char' is 8-bits. - assert(PP.getTargetInfo().getCharWidth(PP.getFullLoc(Loc)) == 8 && + assert(PP.getTargetInfo().getCharWidth() == 8 && "Assumes char is 8 bits"); bool isFirstChar = true; @@ -509,7 +505,7 @@ CharLiteralParser::CharLiteralParser(const char *begin, const char *end, // character constants are not sign extended in the this implementation: // '\xFF\xFF' = 65536 and '\x0\xFF' = 255, which matches GCC. if (!IsWide && !isMultiChar && (Value & 128) && - PP.getTargetInfo().isCharSigned(PP.getFullLoc(Loc))) + PP.getTargetInfo().isCharSigned()) Value = (signed char)Value; } @@ -587,9 +583,7 @@ StringLiteralParser(const Token *StringToks, unsigned NumStringToks, // query the target. As such, wchar_tByteWidth is only valid if AnyWide=true. wchar_tByteWidth = ~0U; if (AnyWide) { - wchar_tByteWidth = - Target.getWCharWidth(PP.getFullLoc(StringToks[0].getLocation())); - + wchar_tByteWidth = Target.getWCharWidth(); assert((wchar_tByteWidth & 7) == 0 && "Assumes wchar_t is byte multiple!"); wchar_tByteWidth /= 8; } diff --git a/clang/Lex/PPExpressions.cpp b/clang/Lex/PPExpressions.cpp index c56692e1f47b..cca76289176d 100644 --- a/clang/Lex/PPExpressions.cpp +++ b/clang/Lex/PPExpressions.cpp @@ -195,25 +195,17 @@ static bool EvaluateValue(llvm::APSInt &Result, Token &PeekTok, // Character literals are always int or wchar_t, expand to intmax_t. TargetInfo &TI = PP.getTargetInfo(); - unsigned NumBits; - if (Literal.isWide()) - NumBits = TI.getWCharWidth(PP.getFullLoc(PeekTok.getLocation())); - else - NumBits = TI.getCharWidth(PP.getFullLoc(PeekTok.getLocation())); + unsigned NumBits = TI.getCharWidth(Literal.isWide()); // Set the width. llvm::APSInt Val(NumBits); // Set the value. Val = Literal.getValue(); // Set the signedness. - Val.setIsUnsigned(!TI.isCharSigned(PP.getFullLoc(PeekTok.getLocation()))); + Val.setIsUnsigned(!TI.isCharSigned()); if (Result.getBitWidth() > Val.getBitWidth()) { - if (Val.isSigned()) - Result = Val.sext(Result.getBitWidth()); - else - Result = Val.zext(Result.getBitWidth()); - Result.setIsUnsigned(Val.isUnsigned()); + Result = Val.extend(Result.getBitWidth()); } else { assert(Result.getBitWidth() == Val.getBitWidth() && "intmax_t smaller than char/wchar_t?"); @@ -603,8 +595,7 @@ EvaluateDirectiveExpression(IdentifierInfo *&IfNDefMacro) { Lex(Tok); // C99 6.10.1p3 - All expressions are evaluated as intmax_t or uintmax_t. - unsigned BitWidth = - getTargetInfo().getIntMaxTWidth(getFullLoc(Tok.getLocation())); + unsigned BitWidth = getTargetInfo().getIntMaxTWidth(); llvm::APSInt ResVal(BitWidth); DefinedTracker DT; diff --git a/clang/Sema/SemaDecl.cpp b/clang/Sema/SemaDecl.cpp index b45317ac9c13..bb26ce70e767 100644 --- a/clang/Sema/SemaDecl.cpp +++ b/clang/Sema/SemaDecl.cpp @@ -1561,8 +1561,7 @@ Sema::DeclTy *Sema::ActOnEnumConstant(Scope *S, DeclTy *theEnumDecl, } else { // First value, set to zero. EltTy = Context.IntTy; - EnumVal.zextOrTrunc( - static_cast(Context.getTypeSize(EltTy, IdLoc))); + EnumVal.zextOrTrunc(static_cast(Context.getTypeSize(EltTy))); } } @@ -1584,9 +1583,7 @@ void Sema::ActOnEnumBody(SourceLocation EnumLoc, DeclTy *EnumDeclX, // TODO: If the result value doesn't fit in an int, it must be a long or long // long value. ISO C does not support this, but GCC does as an extension, // emit a warning. - unsigned IntWidth = - Context.Target.getIntWidth(Context.getFullLoc(Enum->getLocation())); - + unsigned IntWidth = Context.Target.getIntWidth(); // Verify that all the values are okay, compute the size of the values, and // reverse the list. @@ -1643,14 +1640,12 @@ void Sema::ActOnEnumBody(SourceLocation EnumLoc, DeclTy *EnumDeclX, BestType = Context.IntTy; BestWidth = IntWidth; } else { - BestWidth = - Context.Target.getLongWidth(Context.getFullLoc(Enum->getLocation())); + BestWidth = Context.Target.getLongWidth(); if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) BestType = Context.LongTy; else { - BestWidth = Context.Target.getLongLongWidth( - Context.getFullLoc(Enum->getLocation())); + BestWidth = Context.Target.getLongLongWidth(); if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth) Diag(Enum->getLocation(), diag::warn_enum_too_large); @@ -1664,14 +1659,10 @@ void Sema::ActOnEnumBody(SourceLocation EnumLoc, DeclTy *EnumDeclX, BestType = Context.UnsignedIntTy; BestWidth = IntWidth; } else if (NumPositiveBits <= - (BestWidth = Context.Target.getLongWidth( - Context.getFullLoc(Enum->getLocation())))) - + (BestWidth = Context.Target.getLongWidth())) { BestType = Context.UnsignedLongTy; - else { - BestWidth = - Context.Target.getLongLongWidth(Context.getFullLoc(Enum->getLocation())); - + } else { + BestWidth = Context.Target.getLongLongWidth(); assert(NumPositiveBits <= BestWidth && "How could an initializer get larger than ULL?"); BestType = Context.UnsignedLongLongTy; @@ -1936,8 +1927,7 @@ QualType Sema::HandleVectorTypeAttribute(QualType curType, curType.getCanonicalType().getAsString()); return QualType(); } - unsigned typeSize = static_cast( - Context.getTypeSize(curType, rawAttr->getLoc())); + unsigned typeSize = static_cast(Context.getTypeSize(curType)); // vecSize is specified in bytes - convert to bits. unsigned vectorSize = static_cast(vecSize.getZExtValue() * 8); @@ -1970,7 +1960,7 @@ void Sema::HandlePackedAttribute(Decl *d, AttributeList *rawAttr) { else if (FieldDecl *FD = dyn_cast(d)) { // If the alignment is less than or equal to 8 bits, the packed attribute // has no effect. - if (Context.getTypeAlign(FD->getType(), SourceLocation()) <= 8) + if (Context.getTypeAlign(FD->getType()) <= 8) Diag(rawAttr->getLoc(), diag::warn_attribute_ignored_for_field_of_type, rawAttr->getName()->getName(), FD->getType().getAsString()); diff --git a/clang/Sema/SemaExpr.cpp b/clang/Sema/SemaExpr.cpp index 72bedab464f9..f1b6ea222ce2 100644 --- a/clang/Sema/SemaExpr.cpp +++ b/clang/Sema/SemaExpr.cpp @@ -169,8 +169,7 @@ Action::ExprResult Sema::ActOnNumericConstant(const Token &Tok) { if (Tok.getLength() == 1) { const char *t = PP.getSourceManager().getCharacterData(Tok.getLocation()); - unsigned IntSize = static_cast( - Context.getTypeSize(Context.IntTy, Tok.getLocation())); + unsigned IntSize =static_cast(Context.getTypeSize(Context.IntTy)); return ExprResult(new IntegerLiteral(llvm::APInt(IntSize, *t-'0'), Context.IntTy, Tok.getLocation())); @@ -195,17 +194,13 @@ Action::ExprResult Sema::ActOnNumericConstant(const Token &Tok) { if (Literal.isFloat) { Ty = Context.FloatTy; - Context.Target.getFloatInfo(Size, Align, Format, - Context.getFullLoc(Tok.getLocation())); - + Context.Target.getFloatInfo(Size, Align, Format); } else if (Literal.isLong) { Ty = Context.LongDoubleTy; - Context.Target.getLongDoubleInfo(Size, Align, Format, - Context.getFullLoc(Tok.getLocation())); + Context.Target.getLongDoubleInfo(Size, Align, Format); } else { Ty = Context.DoubleTy; - Context.Target.getDoubleInfo(Size, Align, Format, - Context.getFullLoc(Tok.getLocation())); + Context.Target.getDoubleInfo(Size, Align, Format); } // isExact will be set by GetFloatValue(). @@ -225,15 +220,14 @@ Action::ExprResult Sema::ActOnNumericConstant(const Token &Tok) { Diag(Tok.getLocation(), diag::ext_longlong); // Get the value in the widest-possible width. - llvm::APInt ResultVal(Context.Target.getIntMaxTWidth( - Context.getFullLoc(Tok.getLocation())), 0); + llvm::APInt ResultVal(Context.Target.getIntMaxTWidth(), 0); if (Literal.GetIntegerValue(ResultVal)) { // If this value didn't fit into uintmax_t, warn and force to ull. Diag(Tok.getLocation(), diag::warn_integer_too_large); t = Context.UnsignedLongLongTy; - assert(Context.getTypeSize(t, Tok.getLocation()) == - ResultVal.getBitWidth() && "long long is not intmax_t?"); + assert(Context.getTypeSize(t) == ResultVal.getBitWidth() && + "long long is not intmax_t?"); } else { // If this value fits into a ULL, try to figure out what else it fits into // according to the rules of C99 6.4.4.1p5. @@ -245,8 +239,8 @@ Action::ExprResult Sema::ActOnNumericConstant(const Token &Tok) { // Check from smallest to largest, picking the smallest type we can. if (!Literal.isLong && !Literal.isLongLong) { // Are int/unsigned possibilities? - unsigned IntSize = static_cast( - Context.getTypeSize(Context.IntTy,Tok.getLocation())); + unsigned IntSize = + static_cast(Context.getTypeSize(Context.IntTy)); // Does it fit in a unsigned int? if (ResultVal.isIntN(IntSize)) { // Does it fit in a signed int? @@ -262,8 +256,8 @@ Action::ExprResult Sema::ActOnNumericConstant(const Token &Tok) { // Are long/unsigned long possibilities? if (t.isNull() && !Literal.isLongLong) { - unsigned LongSize = static_cast( - Context.getTypeSize(Context.LongTy, Tok.getLocation())); + unsigned LongSize = + static_cast(Context.getTypeSize(Context.LongTy)); // Does it fit in a unsigned long? if (ResultVal.isIntN(LongSize)) { @@ -279,8 +273,8 @@ Action::ExprResult Sema::ActOnNumericConstant(const Token &Tok) { // Finally, check long long if needed. if (t.isNull()) { - unsigned LongLongSize = static_cast( - Context.getTypeSize(Context.LongLongTy, Tok.getLocation())); + unsigned LongLongSize = + static_cast(Context.getTypeSize(Context.LongLongTy)); // Does it fit in a unsigned long long? if (ResultVal.isIntN(LongLongSize)) { @@ -718,8 +712,7 @@ bool Sema::CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty) { assert(VectorTy->isVectorType() && "Not a vector type!"); if (Ty->isVectorType() || Ty->isIntegerType()) { - if (Context.getTypeSize(VectorTy, SourceLocation()) != - Context.getTypeSize(Ty, SourceLocation())) + if (Context.getTypeSize(VectorTy) != Context.getTypeSize(Ty)) return Diag(R.getBegin(), Ty->isVectorType() ? diag::err_invalid_conversion_between_vectors : @@ -1210,8 +1203,7 @@ Sema::CheckAssignmentConstraints(QualType lhsType, QualType rhsType) { lhsType->isVectorType() && rhsType->isVectorType()) { if ((lhsType->isIntegerType() && rhsType->isIntegerType()) || (lhsType->isRealFloatingType() && rhsType->isRealFloatingType())) { - if (Context.getTypeSize(lhsType, SourceLocation()) == - Context.getTypeSize(rhsType, SourceLocation())) + if (Context.getTypeSize(lhsType) == Context.getTypeSize(rhsType)) return Compatible; } } diff --git a/clang/Sema/SemaStmt.cpp b/clang/Sema/SemaStmt.cpp index 1c847717621d..fe62c8ab0695 100644 --- a/clang/Sema/SemaStmt.cpp +++ b/clang/Sema/SemaStmt.cpp @@ -307,8 +307,7 @@ Sema::ActOnFinishSwitchStmt(SourceLocation SwitchLoc, StmtTy *Switch, // Get the bitwidth of the switched-on value before promotions. We must // convert the integer case values to this width before comparison. - unsigned CondWidth = - static_cast(Context.getTypeSize(CondType, SwitchLoc)); + unsigned CondWidth = static_cast(Context.getTypeSize(CondType)); bool CondIsSigned = CondType->isSignedIntegerType(); // Accumulate all of the case values in a vector so that we can sort them diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h index d986b7e887c8..66ac9fd08aeb 100644 --- a/clang/include/clang/AST/ASTContext.h +++ b/clang/include/clang/AST/ASTContext.h @@ -261,24 +261,24 @@ public: /// getTypeInfo - Get the size and alignment of the specified complete type in /// bits. - std::pair getTypeInfo(QualType T, SourceLocation L); + std::pair getTypeInfo(QualType T); /// getTypeSize - Return the size of the specified type, in bits. This method /// does not work on incomplete types. - uint64_t getTypeSize(QualType T, SourceLocation L) { - return getTypeInfo(T, L).first; + uint64_t getTypeSize(QualType T) { + return getTypeInfo(T).first; } /// getTypeAlign - Return the alignment of the specified type, in bits. This /// method does not work on incomplete types. - unsigned getTypeAlign(QualType T, SourceLocation L) { - return getTypeInfo(T, L).second; + unsigned getTypeAlign(QualType T) { + return getTypeInfo(T).second; } /// getASTRecordLayout - Get or compute information about the layout of the /// specified record (struct/union/class), which indicates its size and field /// position information. - const ASTRecordLayout &getASTRecordLayout(const RecordDecl *D, SourceLocation L); + const ASTRecordLayout &getASTRecordLayout(const RecordDecl *D); //===--------------------------------------------------------------------===// // Type Operators diff --git a/clang/include/clang/Analysis/PathSensitive/GRExprEngine.h b/clang/include/clang/Analysis/PathSensitive/GRExprEngine.h index c753249779e1..6a7d243add51 100644 --- a/clang/include/clang/Analysis/PathSensitive/GRExprEngine.h +++ b/clang/include/clang/Analysis/PathSensitive/GRExprEngine.h @@ -286,7 +286,7 @@ protected: } inline NonLVal MakeConstantVal(uint64_t X, Expr* Ex) { - return NonLVal::MakeVal(ValMgr, X, Ex->getType(), Ex->getLocStart()); + return NonLVal::MakeVal(ValMgr, X, Ex->getType()); } /// Assume - Create new state by assuming that a given expression diff --git a/clang/include/clang/Analysis/PathSensitive/RValues.h b/clang/include/clang/Analysis/PathSensitive/RValues.h index e2d07c0856e3..124d141bccce 100644 --- a/clang/include/clang/Analysis/PathSensitive/RValues.h +++ b/clang/include/clang/Analysis/PathSensitive/RValues.h @@ -123,8 +123,7 @@ public: void print(std::ostream& Out) const; // Utility methods to create NonLVals. - static NonLVal MakeVal(ValueManager& ValMgr, uint64_t X, QualType T, - SourceLocation Loc = SourceLocation()); + static NonLVal MakeVal(ValueManager& ValMgr, uint64_t X, QualType T); static NonLVal MakeVal(ValueManager& ValMgr, IntegerLiteral* I); diff --git a/clang/include/clang/Analysis/PathSensitive/ValueManager.h b/clang/include/clang/Analysis/PathSensitive/ValueManager.h index 0b463fba3b77..fb5cd418ed31 100644 --- a/clang/include/clang/Analysis/PathSensitive/ValueManager.h +++ b/clang/include/clang/Analysis/PathSensitive/ValueManager.h @@ -49,17 +49,14 @@ public: const llvm::APSInt& getValue(const llvm::APSInt& X); const llvm::APSInt& getValue(uint64_t X, unsigned BitWidth, bool isUnsigned); - const llvm::APSInt& getValue(uint64_t X, QualType T, - SourceLocation Loc = SourceLocation()); + const llvm::APSInt& getValue(uint64_t X, QualType T); inline const llvm::APSInt& getZeroWithPtrWidth() { - return getValue(0, Ctx.getTypeSize(Ctx.VoidPtrTy, SourceLocation()), true); + return getValue(0, Ctx.getTypeSize(Ctx.VoidPtrTy), true); } inline const llvm::APSInt& getTruthValue(bool b) { - return getValue(b ? 1 : 0, - Ctx.getTypeSize(Ctx.IntTy, SourceLocation()), - false); + return getValue(b ? 1 : 0, Ctx.getTypeSize(Ctx.IntTy), false); } const SymIntConstraint& getConstraint(SymbolID sym, BinaryOperator::Opcode Op, diff --git a/clang/include/clang/Basic/TargetInfo.h b/clang/include/clang/Basic/TargetInfo.h index 16c959c6d074..2febe6e7daf5 100644 --- a/clang/include/clang/Basic/TargetInfo.h +++ b/clang/include/clang/Basic/TargetInfo.h @@ -14,7 +14,6 @@ #ifndef LLVM_CLANG_BASIC_TARGETINFO_H #define LLVM_CLANG_BASIC_TARGETINFO_H -#include "clang/Basic/SourceLocation.h" #include "llvm/Support/DataTypes.h" #include #include @@ -66,79 +65,77 @@ public: /// isCharSigned - Return true if 'char' is 'signed char' or false if it is /// treated as 'unsigned char'. This is implementation defined according to /// C99 6.2.5p15. In our implementation, this is target-specific. - bool isCharSigned(FullSourceLoc Loc) { + bool isCharSigned() { // FIXME: implement correctly. return true; } /// getPointerWidth - Return the width of pointers on this target, we /// currently assume one pointer type. - void getPointerInfo(uint64_t &Size, unsigned &Align, FullSourceLoc Loc) { + void getPointerInfo(uint64_t &Size, unsigned &Align) { Size = 32; // FIXME: implement correctly. Align = 32; } /// getBoolInfo - Return the size of '_Bool' and C++ 'bool' for this target, /// in bits. - void getBoolInfo(uint64_t &Size, unsigned &Align, FullSourceLoc Loc) { + void getBoolInfo(uint64_t &Size, unsigned &Align) { Size = Align = 8; // FIXME: implement correctly: wrong for ppc32. } /// getCharInfo - Return the size of 'char', 'signed char' and /// 'unsigned char' for this target, in bits. - void getCharInfo(uint64_t &Size, unsigned &Align, FullSourceLoc Loc) { + void getCharInfo(uint64_t &Size, unsigned &Align) { Size = Align = 8; // FIXME: implement correctly. } /// getShortInfo - Return the size of 'signed short' and 'unsigned short' for /// this target, in bits. - void getShortInfo(uint64_t &Size, unsigned &Align, FullSourceLoc Loc) { + void getShortInfo(uint64_t &Size, unsigned &Align) { Size = Align = 16; // FIXME: implement correctly. } /// getIntInfo - Return the size of 'signed int' and 'unsigned int' for this /// target, in bits. - void getIntInfo(uint64_t &Size, unsigned &Align, FullSourceLoc Loc) { + void getIntInfo(uint64_t &Size, unsigned &Align) { Size = Align = 32; // FIXME: implement correctly. } /// getLongInfo - Return the size of 'signed long' and 'unsigned long' for /// this target, in bits. - void getLongInfo(uint64_t &Size, unsigned &Align, FullSourceLoc Loc) { + void getLongInfo(uint64_t &Size, unsigned &Align) { Size = Align = 32; // FIXME: implement correctly: wrong for ppc64/x86-64 } /// getLongLongInfo - Return the size of 'signed long long' and /// 'unsigned long long' for this target, in bits. - void getLongLongInfo(uint64_t &Size, unsigned &Align, - FullSourceLoc Loc) { + void getLongLongInfo(uint64_t &Size, unsigned &Align) { Size = Align = 64; // FIXME: implement correctly. } /// getFloatInfo - Characterize 'float' for this target. void getFloatInfo(uint64_t &Size, unsigned &Align, - const llvm::fltSemantics *&Format, FullSourceLoc Loc); + const llvm::fltSemantics *&Format); /// getDoubleInfo - Characterize 'double' for this target. void getDoubleInfo(uint64_t &Size, unsigned &Align, - const llvm::fltSemantics *&Format, FullSourceLoc Loc); + const llvm::fltSemantics *&Format); /// getLongDoubleInfo - Characterize 'long double' for this target. void getLongDoubleInfo(uint64_t &Size, unsigned &Align, - const llvm::fltSemantics *&Format, FullSourceLoc Loc); + const llvm::fltSemantics *&Format); /// getWCharInfo - Return the size of wchar_t in bits. /// - void getWCharInfo(uint64_t &Size, unsigned &Align, - FullSourceLoc Loc) { - if (!WCharWidth) ComputeWCharInfo(Loc); + void getWCharInfo(uint64_t &Size, unsigned &Align) { + if (!WCharWidth) ComputeWCharInfo(); Size = WCharWidth; Align = WCharAlign; } /// getIntMaxTWidth - Return the size of intmax_t and uintmax_t for this /// target, in bits. - unsigned getIntMaxTWidth(FullSourceLoc Loc) { + unsigned getIntMaxTWidth() { // FIXME: implement correctly. return 64; } @@ -183,39 +180,42 @@ public: ///===---- Some helper methods ------------------------------------------===// - unsigned getBoolWidth(FullSourceLoc Loc) { + unsigned getBoolWidth() { uint64_t Size; unsigned Align; - getBoolInfo(Size, Align, Loc); + getBoolInfo(Size, Align); return static_cast(Size); } - unsigned getCharWidth(FullSourceLoc Loc) { + unsigned getCharWidth(bool isWide = false) { uint64_t Size; unsigned Align; - getCharInfo(Size, Align, Loc); + if (isWide) + getWCharInfo(Size, Align); + else + getCharInfo(Size, Align); return static_cast(Size); } - unsigned getWCharWidth(FullSourceLoc Loc) { + unsigned getWCharWidth() { uint64_t Size; unsigned Align; - getWCharInfo(Size, Align, Loc); + getWCharInfo(Size, Align); return static_cast(Size); } - unsigned getIntWidth(FullSourceLoc Loc) { + unsigned getIntWidth() { uint64_t Size; unsigned Align; - getIntInfo(Size, Align, Loc); + getIntInfo(Size, Align); return static_cast(Size); } - unsigned getLongWidth(FullSourceLoc Loc) { + unsigned getLongWidth() { uint64_t Size; unsigned Align; - getLongInfo(Size, Align, Loc); + getLongInfo(Size, Align); return static_cast(Size); } - unsigned getLongLongWidth(FullSourceLoc Loc) { + unsigned getLongLongWidth() { uint64_t Size; unsigned Align; - getLongLongInfo(Size, Align, Loc); + getLongLongInfo(Size, Align); return static_cast(Size); } @@ -233,7 +233,7 @@ public: 32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"; } private: - void ComputeWCharInfo(FullSourceLoc Loc); + void ComputeWCharInfo(); };