microsoft
/
clang
зеркало из https://github.com/microsoft/clang.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

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
This commit is contained in:
Chris Lattner 2008-03-05 18:54:05 +00:00
Родитель 631bf6c325
Коммит 98be4943e8
26 изменённых файлов: 168 добавлений и 299 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

65
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<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 @@ ASTContext::getTypeInfo(QualType T, SourceLocation L) {
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 @@ ASTContext::getTypeInfo(QualType T, SourceLocation L) {
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 @@ 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<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 @@ ASTContext::getTypeInfo(QualType T, SourceLocation L) {
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 @@ 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<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 @@ 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<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 @@ 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<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 @@ 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;

55
AST/Expr.cpp
Просмотреть файл

@ -510,8 +510,7 @@ bool Expr::isConstantExpr(ASTContext &Ctx, SourceLocation *Loc) const {
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 @@ bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx,
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 @@ 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<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 @@ 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<uint32_t>(Ctx.getTypeSize(getType(),
Exp->getOperatorLoc())));
Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
Result = Val;
break;
}
@ -780,8 +768,7 @@ bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx,
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 @@ 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<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 @@ 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;
}

14
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);
}

4
Analysis/GRSimpleVals.cpp
Просмотреть файл

@ -160,7 +160,7 @@ RVal GRSimpleVals::EvalCast(ValueManager& ValMgr, NonLVal X, QualType T) {
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 @@ RVal GRSimpleVals::EvalCast(ValueManager& ValMgr, LVal X, QualType T) {
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));
}

7
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));
}

5
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);

7
Analysis/ValueState.cpp
Просмотреть файл

@ -258,8 +258,7 @@ RVal ValueStateManager::GetRVal(ValueState* St, Expr* E) {
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 @@ RVal ValueStateManager::GetRVal(ValueState* St, Expr* E) {
// subexpression that has a value.
case Stmt::ImplicitCastExprClass: {
ImplicitCastExpr* C = cast<ImplicitCastExpr>(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<CharacterLiteral>(E);
return NonLVal::MakeVal(ValMgr, C->getValue(), C->getType(),
C->getLoc());
return NonLVal::MakeVal(ValMgr, C->getValue(), C->getType());
}
case Stmt::IntegerLiteralClass: {

11
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<char> &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);
}

47
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<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 @@ 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;
}

6
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<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 @@ void AggExprEmitter::EmitAggregateCopy(llvm::Value *DestPtr,
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);

16
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<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 @@ public:
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 @@ public:
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 @@ llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E,
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);
}

13
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<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 @@ Value *ScalarExprEmitter::VisitUnaryOffsetOf(const UnaryOperator *E)
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 @@ Value *ScalarExprEmitter::VisitBinSub(const BinaryOperator *E) {
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");

3
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<unsigned>(
getContext().getTypeSize(getContext().getPointerType(getContext().VoidTy),
SourceLocation()));
getContext().getTypeSize(getContext().getPointerType(getContext().VoidTy)));
CurFuncDecl = FD;
CurFn = cast<llvm::Function>(CGM.GetAddrOfFunctionDecl(FD, true));

6
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<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 @@ 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;

11
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<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 @@ 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<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 @@ void RecordOrganizer::layoutUnionFields() {
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 ||

5
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<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());

20
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;
}

17
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;

28
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<uint32_t>(Context.getTypeSize(EltTy, IdLoc)));
EnumVal.zextOrTrunc(static_cast<uint32_t>(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<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 @@ void Sema::HandlePackedAttribute(Decl *d, AttributeList *rawAttr) {
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());

38
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<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 @@ 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<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 @@ Action::ExprResult Sema::ActOnNumericConstant(const Token &Tok) {
// 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 @@ Action::ExprResult Sema::ActOnNumericConstant(const Token &Tok) {
// 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 @@ 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;
}
}

3
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<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

12
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<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

2
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

3
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);

9
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,

60
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 @@ 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<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 @@ public:
32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128";
}
private:
void ComputeWCharInfo(FullSourceLoc Loc);
void ComputeWCharInfo();
};