remove the source location arguments to various target query methods.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@47954 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/AST/ASTContext.cpp b/AST/ASTContext.cpp
index 2487aba..b5b28bc 100644
--- a/AST/ASTContext.cpp
+++ b/AST/ASTContext.cpp
@@ -133,7 +133,7 @@
// 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 @@
/// getTypeSize - Return the size of the specified type, in bits. This method
/// does not work on incomplete types.
std::pair<uint64_t, unsigned>
-ASTContext::getTypeInfo(QualType T, SourceLocation L) {
+ASTContext::getTypeInfo(QualType T) {
T = T.getCanonicalType();
uint64_t Size;
unsigned Align;
@@ -195,8 +195,7 @@
case Type::ConstantArray: {
ConstantArrayType *CAT = cast<ConstantArrayType>(T);
- std::pair<uint64_t, unsigned> EltInfo =
- getTypeInfo(CAT->getElementType(), L);
+ std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(CAT->getElementType());
Size = EltInfo.first*CAT->getSize().getZExtValue();
Align = EltInfo.second;
break;
@@ -204,7 +203,7 @@
case Type::OCUVector:
case Type::Vector: {
std::pair<uint64_t, unsigned> EltInfo =
- getTypeInfo(cast<VectorType>(T)->getElementType(), L);
+ getTypeInfo(cast<VectorType>(T)->getElementType());
Size = EltInfo.first*cast<VectorType>(T)->getNumElements();
// FIXME: Vector alignment is not the alignment of its elements.
Align = EltInfo.second;
@@ -220,62 +219,62 @@
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<ASQualType>(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<ASQualType>(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<ReferenceType>(T)->getReferenceeType(), L);
+ return getTypeInfo(cast<ReferenceType>(T)->getReferenceeType());
case Type::Complex: {
// Complex types have the same alignment as their elements, but twice the
// size.
std::pair<uint64_t, unsigned> EltInfo =
- getTypeInfo(cast<ComplexType>(T)->getElementType(), L);
+ getTypeInfo(cast<ComplexType>(T)->getElementType());
Size = EltInfo.first*2;
Align = EltInfo.second;
break;
@@ -283,11 +282,11 @@
case Type::Tagged:
TagType *TT = cast<TagType>(T);
if (RecordType *RT = dyn_cast<RecordType>(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<EnumDecl>(TT->getDecl())) {
- return getTypeInfo(ED->getIntegerType(), L);
+ return getTypeInfo(ED->getIntegerType());
} else {
assert(0 && "Unimplemented type sizes!");
}
@@ -301,8 +300,7 @@
/// 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 @@
assert (BitWidthIsICE && "Invalid BitField size expression");
FieldSize = I.getZExtValue();
- std::pair<uint64_t, unsigned> TypeInfo = getTypeInfo(FD->getType(), L);
+ std::pair<uint64_t, unsigned> TypeInfo = getTypeInfo(FD->getType());
uint64_t TypeSize = TypeInfo.first;
if (const AlignedAttr *AA = FD->getAttr<AlignedAttr>())
@@ -372,11 +370,11 @@
FieldAlign = 8;
else {
const ArrayType* ATy = FD->getType()->getAsArrayType();
- FieldAlign = getTypeAlign(ATy->getElementType(), L);
+ FieldAlign = getTypeAlign(ATy->getElementType());
}
FieldSize = 0;
} else {
- std::pair<uint64_t, unsigned> FieldInfo = getTypeInfo(FD->getType(), L);
+ std::pair<uint64_t, unsigned> FieldInfo = getTypeInfo(FD->getType());
FieldSize = FieldInfo.first;
if (const AlignedAttr *AA = FD->getAttr<AlignedAttr>())
@@ -408,7 +406,7 @@
// 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<uint64_t, unsigned> FieldInfo = getTypeInfo(FD->getType(), L);
+ std::pair<uint64_t, unsigned> FieldInfo = getTypeInfo(FD->getType());
uint64_t FieldSize = FieldInfo.first;
unsigned FieldAlign = FieldInfo.second;
@@ -1073,16 +1071,15 @@
/// 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 @@
// 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/AST/Expr.cpp b/AST/Expr.cpp
index 1c32d7c..11fcc41 100644
--- a/AST/Expr.cpp
+++ b/AST/Expr.cpp
@@ -510,8 +510,7 @@
case CallExprClass: {
const CallExpr *CE = cast<CallExpr>(this);
llvm::APSInt Result(32);
- Result.zextOrTrunc(
- static_cast<uint32_t>(Ctx.getTypeSize(getType(), CE->getLocStart())));
+ Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
if (CE->isBuiltinClassifyType(Result))
return true;
if (CE->isBuiltinConstantExpr())
@@ -673,23 +672,20 @@
break;
case CharacterLiteralClass: {
const CharacterLiteral *CL = cast<CharacterLiteral>(this);
- Result.zextOrTrunc(
- static_cast<uint32_t>(Ctx.getTypeSize(getType(), CL->getLoc())));
+ Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
Result = CL->getValue();
Result.setIsUnsigned(!getType()->isSignedIntegerType());
break;
}
case TypesCompatibleExprClass: {
const TypesCompatibleExpr *TCE = cast<TypesCompatibleExpr>(this);
- Result.zextOrTrunc(
- static_cast<uint32_t>(Ctx.getTypeSize(getType(), TCE->getLocStart())));
+ Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
Result = Ctx.typesAreCompatible(TCE->getArgType1(), TCE->getArgType2());
break;
}
case CallExprClass: {
const CallExpr *CE = cast<CallExpr>(this);
- Result.zextOrTrunc(
- static_cast<uint32_t>(Ctx.getTypeSize(getType(), CE->getLocStart())));
+ Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
if (CE->isBuiltinClassifyType(Result))
break;
if (Loc) *Loc = getLocStart();
@@ -723,9 +719,7 @@
case UnaryOperator::SizeOf:
case UnaryOperator::AlignOf:
// Return the result in the right width.
- Result.zextOrTrunc(
- static_cast<uint32_t>(Ctx.getTypeSize(getType(),
- Exp->getOperatorLoc())));
+ Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
// sizeof(void) and __alignof__(void) = 1 as a gcc extension.
if (Exp->getSubExpr()->getType()->isVoidType()) {
@@ -744,22 +738,16 @@
// 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<uint32_t>(Ctx.getTypeSize(getType(),
- Exp->getOperatorLoc())));
+ Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
Result = Val;
break;
}
@@ -780,8 +768,7 @@
const SizeOfAlignOfTypeExpr *Exp = cast<SizeOfAlignOfTypeExpr>(this);
// Return the result in the right width.
- Result.zextOrTrunc(
- static_cast<uint32_t>(Ctx.getTypeSize(getType(), Exp->getOperatorLoc())));
+ Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
// sizeof(void) and __alignof__(void) = 1 as a gcc extension.
if (Exp->getArgumentType()->isVoidType()) {
@@ -800,17 +787,12 @@
// 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 @@
return false;
}
- uint32_t DestWidth =
- static_cast<uint32_t>(Ctx.getTypeSize(getType(), CastLoc));
+ uint32_t DestWidth = static_cast<uint32_t>(Ctx.getTypeSize(getType()));
// Handle simple integer->integer casts.
if (SubExpr->getType()->isIntegerType()) {
@@ -1140,7 +1121,7 @@
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 @@
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 @@
{
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/Analysis/GRExprEngine.cpp b/Analysis/GRExprEngine.cpp
index 2481f56..4cd942b 100644
--- a/Analysis/GRExprEngine.cpp
+++ b/Analysis/GRExprEngine.cpp
@@ -277,8 +277,7 @@
// 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 @@
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 @@
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/Analysis/GRSimpleVals.cpp b/Analysis/GRSimpleVals.cpp
index d8a3112..c00800c 100644
--- a/Analysis/GRSimpleVals.cpp
+++ b/Analysis/GRSimpleVals.cpp
@@ -160,7 +160,7 @@
llvm::APSInt V = cast<nonlval::ConcreteInt>(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 @@
llvm::APSInt V = cast<lval::ConcreteInt>(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/Analysis/RValues.cpp b/Analysis/RValues.cpp
index 6369da4..36ea2df 100644
--- a/Analysis/RValues.cpp
+++ b/Analysis/RValues.cpp
@@ -207,10 +207,8 @@
// 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::MakeIntTruthVal(ValueManager& ValMgr, bool b) {
-
return nonlval::ConcreteInt(ValMgr.getTruthValue(b));
}
diff --git a/Analysis/ValueManager.cpp b/Analysis/ValueManager.cpp
index 2a8d23d..a02f3e4 100644
--- a/Analysis/ValueManager.cpp
+++ b/Analysis/ValueManager.cpp
@@ -48,10 +48,9 @@
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/Analysis/ValueState.cpp b/Analysis/ValueState.cpp
index 388dba6..f47e14b 100644
--- a/Analysis/ValueState.cpp
+++ b/Analysis/ValueState.cpp
@@ -258,8 +258,7 @@
case Stmt::CharacterLiteralClass: {
CharacterLiteral* C = cast<CharacterLiteral>(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 @@
// subexpression that has a value.
case Stmt::ImplicitCastExprClass: {
-
ImplicitCastExpr* C = cast<ImplicitCastExpr>(E);
QualType CT = C->getType();
@@ -341,8 +339,7 @@
switch (E->getStmtClass()) {
case Stmt::CharacterLiteralClass: {
CharacterLiteral* C = cast<CharacterLiteral>(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/Basic/TargetInfo.cpp b/Basic/TargetInfo.cpp
index 8701b38..1f0bece 100644
--- a/Basic/TargetInfo.cpp
+++ b/Basic/TargetInfo.cpp
@@ -28,22 +28,19 @@
// 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 @@
/// 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/Basic/Targets.cpp b/Basic/Targets.cpp
index d170fbe..89125b4 100644
--- a/Basic/Targets.cpp
+++ b/Basic/Targets.cpp
@@ -722,50 +722,6 @@
} // 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<char> &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 @@
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/CodeGen/CGExprAgg.cpp b/CodeGen/CGExprAgg.cpp
index 493d279..325ac21 100644
--- a/CodeGen/CGExprAgg.cpp
+++ b/CodeGen/CGExprAgg.cpp
@@ -103,8 +103,7 @@
DestPtr = Builder.CreateBitCast(DestPtr, BP, "tmp");
// Get size and alignment info for this aggregate.
- std::pair<uint64_t, unsigned> TypeInfo =
- CGF.getContext().getTypeInfo(Ty, SourceLocation());
+ std::pair<uint64_t, unsigned> TypeInfo = CGF.getContext().getTypeInfo(Ty);
// FIXME: Handle variable sized types.
const llvm::Type *IntPtr = llvm::IntegerType::get(CGF.LLVMPointerWidth);
@@ -132,8 +131,7 @@
SrcPtr = Builder.CreateBitCast(SrcPtr, BP, "tmp");
// Get size and alignment info for this aggregate.
- std::pair<uint64_t, unsigned> TypeInfo =
- CGF.getContext().getTypeInfo(Ty, SourceLocation());
+ std::pair<uint64_t, unsigned> TypeInfo = CGF.getContext().getTypeInfo(Ty);
// FIXME: Handle variable sized types.
const llvm::Type *IntPtr = llvm::IntegerType::get(CGF.LLVMPointerWidth);
diff --git a/CodeGen/CGExprConstant.cpp b/CodeGen/CGExprConstant.cpp
index 30180c1..e2405b8 100644
--- a/CodeGen/CGExprConstant.cpp
+++ b/CodeGen/CGExprConstant.cpp
@@ -37,7 +37,8 @@
llvm::Constant *VisitStmt(Stmt *S) {
CGM.WarnUnsupported(S, "constant expression");
- return llvm::UndefValue::get(CGM.getTypes().ConvertType(cast<Expr>(S)->getType()));
+ QualType T = cast<Expr>(S)->getType();
+ return llvm::UndefValue::get(CGM.getTypes().ConvertType(T));
}
llvm::Constant *VisitParenExpr(ParenExpr *PE) {
@@ -314,8 +315,8 @@
assert(E->getType()->isIntegerType() && "Result type must be an integer!");
- uint32_t ResultWidth = static_cast<uint32_t>(
- CGM.getContext().getTypeSize(E->getType(), SourceLocation()));
+ uint32_t ResultWidth =
+ static_cast<uint32_t>(CGM.getContext().getTypeSize(E->getType()));
return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val));
}
@@ -504,15 +505,15 @@
llvm::Constant *EmitSizeAlignOf(QualType TypeToSize,
QualType RetType, bool isSizeOf) {
std::pair<uint64_t, unsigned> 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<uint32_t>(
- CGM.getContext().getTypeSize(RetType, SourceLocation()));
+ uint32_t ResultWidth =
+ static_cast<uint32_t>(CGM.getContext().getTypeSize(RetType));
return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val));
}
@@ -616,8 +617,7 @@
QualType type = E->getType().getCanonicalType();
if (type->isIntegerType()) {
- llvm::APSInt
- Value(static_cast<uint32_t>(Context.getTypeSize(type, SourceLocation())));
+ llvm::APSInt Value(static_cast<uint32_t>(Context.getTypeSize(type)));
if (E->isIntegerConstantExpr(Value, Context)) {
return llvm::ConstantInt::get(Value);
}
diff --git a/CodeGen/CGExprScalar.cpp b/CodeGen/CGExprScalar.cpp
index 52b022b..892712a 100644
--- a/CodeGen/CGExprScalar.cpp
+++ b/CodeGen/CGExprScalar.cpp
@@ -656,16 +656,14 @@
QualType RetType,bool isSizeOf){
assert(RetType->isIntegerType() && "Result type must be an integer!");
uint32_t ResultWidth =
- static_cast<uint32_t>(CGF.getContext().getTypeSize(RetType,
- SourceLocation()));
+ static_cast<uint32_t>(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<uint64_t, unsigned> Info =
- CGF.getContext().getTypeInfo(TypeToSize, SourceLocation());
+ std::pair<uint64_t, unsigned> 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 @@
assert(E->getType()->isIntegerType() && "Result type must be an integer!");
- uint32_t ResultWidth = static_cast<uint32_t>(
- CGF.getContext().getTypeSize(E->getType(), SourceLocation()));
+ uint32_t ResultWidth =
+ static_cast<uint32_t>(CGF.getContext().getTypeSize(E->getType()));
return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val));
}
@@ -852,8 +850,7 @@
const QualType LHSType = E->getLHS()->getType().getCanonicalType();
const QualType LHSElementType = cast<PointerType>(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/CodeGen/CodeGenFunction.cpp b/CodeGen/CodeGenFunction.cpp
index adbb414..f48d093 100644
--- a/CodeGen/CodeGenFunction.cpp
+++ b/CodeGen/CodeGenFunction.cpp
@@ -59,8 +59,7 @@
void CodeGenFunction::GenerateCode(const FunctionDecl *FD) {
LLVMIntTy = ConvertType(getContext().IntTy);
LLVMPointerWidth = static_cast<unsigned>(
- getContext().getTypeSize(getContext().getPointerType(getContext().VoidTy),
- SourceLocation()));
+ getContext().getTypeSize(getContext().getPointerType(getContext().VoidTy)));
CurFuncDecl = FD;
CurFn = cast<llvm::Function>(CGM.GetAddrOfFunctionDecl(FD, true));
diff --git a/CodeGen/CodeGenModule.cpp b/CodeGen/CodeGenModule.cpp
index 1a69796..554fc3f 100644
--- a/CodeGen/CodeGenModule.cpp
+++ b/CodeGen/CodeGenModule.cpp
@@ -231,7 +231,7 @@
Init = llvm::Constant::getNullValue(GV->getType()->getElementType());
} else if (D->getType()->isIntegerType()) {
llvm::APSInt Value(static_cast<uint32_t>(
- 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 @@
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 @@
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/CodeGen/CodeGenTypes.cpp b/CodeGen/CodeGenTypes.cpp
index efdc0e8..9a669e8 100644
--- a/CodeGen/CodeGenTypes.cpp
+++ b/CodeGen/CodeGenTypes.cpp
@@ -118,8 +118,7 @@
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 @@
case BuiltinType::LongLong:
case BuiltinType::ULongLong:
return llvm::IntegerType::get(
- static_cast<unsigned>(Context.getTypeSize(T, SourceLocation())));
+ static_cast<unsigned>(Context.getTypeSize(T)));
case BuiltinType::Float: return llvm::Type::FloatTy;
case BuiltinType::Double: return llvm::Type::DoubleTy;
@@ -356,7 +355,7 @@
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 @@
unsigned PrimaryEltNo = 0;
std::pair<uint64_t, unsigned> 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 @@
const FieldDecl *FD = FieldDecls[i];
assert (!FD->isBitField() && "Bit fields are not yet supported");
std::pair<uint64_t, unsigned> 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/Driver/RewriteTest.cpp b/Driver/RewriteTest.cpp
index beabe92..097aa1b 100644
--- a/Driver/RewriteTest.cpp
+++ b/Driver/RewriteTest.cpp
@@ -2037,9 +2037,8 @@
// 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<unsigned>(
- Context->getTypeSize(Context->IntTy, SourceLocation()));
-
+ unsigned IntSize =
+ static_cast<unsigned>(Context->getTypeSize(Context->IntTy));
IntegerLiteral *limit = new IntegerLiteral(llvm::APInt(IntSize, 8),
Context->IntTy,
SourceLocation());
diff --git a/Lex/LiteralSupport.cpp b/Lex/LiteralSupport.cpp
index 34ddfba..aa0b831 100644
--- a/Lex/LiteralSupport.cpp
+++ b/Lex/LiteralSupport.cpp
@@ -93,9 +93,7 @@
}
// 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 @@
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 @@
// 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 @@
// 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 @@
// 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/Lex/PPExpressions.cpp b/Lex/PPExpressions.cpp
index c56692e..cca7628 100644
--- a/Lex/PPExpressions.cpp
+++ b/Lex/PPExpressions.cpp
@@ -195,25 +195,17 @@
// 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 @@
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/Sema/SemaDecl.cpp b/Sema/SemaDecl.cpp
index b45317a..bb26ce7 100644
--- a/Sema/SemaDecl.cpp
+++ b/Sema/SemaDecl.cpp
@@ -1561,8 +1561,7 @@
} else {
// First value, set to zero.
EltTy = Context.IntTy;
- EnumVal.zextOrTrunc(
- static_cast<uint32_t>(Context.getTypeSize(EltTy, IdLoc)));
+ EnumVal.zextOrTrunc(static_cast<uint32_t>(Context.getTypeSize(EltTy)));
}
}
@@ -1584,9 +1583,7 @@
// 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 @@
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 @@
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 @@
curType.getCanonicalType().getAsString());
return QualType();
}
- unsigned typeSize = static_cast<unsigned>(
- Context.getTypeSize(curType, rawAttr->getLoc()));
+ unsigned typeSize = static_cast<unsigned>(Context.getTypeSize(curType));
// vecSize is specified in bytes - convert to bits.
unsigned vectorSize = static_cast<unsigned>(vecSize.getZExtValue() * 8);
@@ -1970,7 +1960,7 @@
else if (FieldDecl *FD = dyn_cast<FieldDecl>(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/Sema/SemaExpr.cpp b/Sema/SemaExpr.cpp
index 72bedab..f1b6ea2 100644
--- a/Sema/SemaExpr.cpp
+++ b/Sema/SemaExpr.cpp
@@ -169,8 +169,7 @@
if (Tok.getLength() == 1) {
const char *t = PP.getSourceManager().getCharacterData(Tok.getLocation());
- unsigned IntSize = static_cast<unsigned>(
- Context.getTypeSize(Context.IntTy, Tok.getLocation()));
+ unsigned IntSize =static_cast<unsigned>(Context.getTypeSize(Context.IntTy));
return ExprResult(new IntegerLiteral(llvm::APInt(IntSize, *t-'0'),
Context.IntTy,
Tok.getLocation()));
@@ -195,17 +194,13 @@
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 @@
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 @@
// Check from smallest to largest, picking the smallest type we can.
if (!Literal.isLong && !Literal.isLongLong) {
// Are int/unsigned possibilities?
- unsigned IntSize = static_cast<unsigned>(
- Context.getTypeSize(Context.IntTy,Tok.getLocation()));
+ unsigned IntSize =
+ static_cast<unsigned>(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 @@
// Are long/unsigned long possibilities?
if (t.isNull() && !Literal.isLongLong) {
- unsigned LongSize = static_cast<unsigned>(
- Context.getTypeSize(Context.LongTy, Tok.getLocation()));
+ unsigned LongSize =
+ static_cast<unsigned>(Context.getTypeSize(Context.LongTy));
// Does it fit in a unsigned long?
if (ResultVal.isIntN(LongSize)) {
@@ -279,8 +273,8 @@
// Finally, check long long if needed.
if (t.isNull()) {
- unsigned LongLongSize = static_cast<unsigned>(
- Context.getTypeSize(Context.LongLongTy, Tok.getLocation()));
+ unsigned LongLongSize =
+ static_cast<unsigned>(Context.getTypeSize(Context.LongLongTy));
// Does it fit in a unsigned long long?
if (ResultVal.isIntN(LongLongSize)) {
@@ -718,8 +712,7 @@
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 @@
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/Sema/SemaStmt.cpp b/Sema/SemaStmt.cpp
index 1c84771..fe62c8a 100644
--- a/Sema/SemaStmt.cpp
+++ b/Sema/SemaStmt.cpp
@@ -307,8 +307,7 @@
// 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<unsigned>(Context.getTypeSize(CondType, SwitchLoc));
+ unsigned CondWidth = static_cast<unsigned>(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/include/clang/AST/ASTContext.h b/include/clang/AST/ASTContext.h
index d986b7e..66ac9fd 100644
--- a/include/clang/AST/ASTContext.h
+++ b/include/clang/AST/ASTContext.h
@@ -261,24 +261,24 @@
/// getTypeInfo - Get the size and alignment of the specified complete type in
/// bits.
- std::pair<uint64_t, unsigned> getTypeInfo(QualType T, SourceLocation L);
+ std::pair<uint64_t, unsigned> 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/include/clang/Analysis/PathSensitive/GRExprEngine.h b/include/clang/Analysis/PathSensitive/GRExprEngine.h
index c753249..6a7d243 100644
--- a/include/clang/Analysis/PathSensitive/GRExprEngine.h
+++ b/include/clang/Analysis/PathSensitive/GRExprEngine.h
@@ -286,7 +286,7 @@
}
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/include/clang/Analysis/PathSensitive/RValues.h b/include/clang/Analysis/PathSensitive/RValues.h
index e2d07c0..124d141 100644
--- a/include/clang/Analysis/PathSensitive/RValues.h
+++ b/include/clang/Analysis/PathSensitive/RValues.h
@@ -123,8 +123,7 @@
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/include/clang/Analysis/PathSensitive/ValueManager.h b/include/clang/Analysis/PathSensitive/ValueManager.h
index 0b463fb..fb5cd41 100644
--- a/include/clang/Analysis/PathSensitive/ValueManager.h
+++ b/include/clang/Analysis/PathSensitive/ValueManager.h
@@ -49,17 +49,14 @@
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/include/clang/Basic/TargetInfo.h b/include/clang/Basic/TargetInfo.h
index 16c959c..2febe6e 100644
--- a/include/clang/Basic/TargetInfo.h
+++ b/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 <vector>
#include <string>
@@ -66,79 +65,77 @@
/// 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 @@
///===---- Some helper methods ------------------------------------------===//
- unsigned getBoolWidth(FullSourceLoc Loc) {
+ unsigned getBoolWidth() {
uint64_t Size; unsigned Align;
- getBoolInfo(Size, Align, Loc);
+ getBoolInfo(Size, Align);
return static_cast<unsigned>(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<unsigned>(Size);
}
- unsigned getWCharWidth(FullSourceLoc Loc) {
+ unsigned getWCharWidth() {
uint64_t Size; unsigned Align;
- getWCharInfo(Size, Align, Loc);
+ getWCharInfo(Size, Align);
return static_cast<unsigned>(Size);
}
- unsigned getIntWidth(FullSourceLoc Loc) {
+ unsigned getIntWidth() {
uint64_t Size; unsigned Align;
- getIntInfo(Size, Align, Loc);
+ getIntInfo(Size, Align);
return static_cast<unsigned>(Size);
}
- unsigned getLongWidth(FullSourceLoc Loc) {
+ unsigned getLongWidth() {
uint64_t Size; unsigned Align;
- getLongInfo(Size, Align, Loc);
+ getLongInfo(Size, Align);
return static_cast<unsigned>(Size);
}
- unsigned getLongLongWidth(FullSourceLoc Loc) {
+ unsigned getLongLongWidth() {
uint64_t Size; unsigned Align;
- getLongLongInfo(Size, Align, Loc);
+ getLongLongInfo(Size, Align);
return static_cast<unsigned>(Size);
}
@@ -233,7 +233,7 @@
32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128";
}
private:
- void ComputeWCharInfo(FullSourceLoc Loc);
+ void ComputeWCharInfo();
};