Type.cpp revision 59d16d1402d76a298ab7fc5f362e9d3dfd744aa5
15f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===--- Type.cpp - Type representation and manipulation ------------------===// 25f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 35f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// The LLVM Compiler Infrastructure 45f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 50bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// This file is distributed under the University of Illinois Open Source 60bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// License. See LICENSE.TXT for details. 75f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 85f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 95f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// This file implements type-related functionality. 115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 14b381aac9bae6d608c72267dd0ed08ec6369e94e4Nuno Lopes#include "clang/AST/ASTContext.h" 155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/AST/Type.h" 1649aa7ff1245abd03e6e998e01302df31e4c6f8f6Argyrios Kyrtzidis#include "clang/AST/DeclCXX.h" 17980e508ca70d6de75d2abfd96b4681fc98bb2698Steve Naroff#include "clang/AST/DeclObjC.h" 18aaba5e346dffdbad5d1c42765a89e4a7afb0da67Douglas Gregor#include "clang/AST/DeclTemplate.h" 195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/AST/Expr.h" 205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "llvm/ADT/StringExtras.h" 217360fda1efd88fd28ca2882579676dbd8569c181Ted Kremenek 225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 244bbce9901f7296ab030c58f0877be0b042bd70d3Chris Lattnerbool QualType::isConstant(ASTContext &Ctx) const { 25b381aac9bae6d608c72267dd0ed08ec6369e94e4Nuno Lopes if (isConstQualified()) 26b381aac9bae6d608c72267dd0ed08ec6369e94e4Nuno Lopes return true; 27b381aac9bae6d608c72267dd0ed08ec6369e94e4Nuno Lopes 28b381aac9bae6d608c72267dd0ed08ec6369e94e4Nuno Lopes if (getTypePtr()->isArrayType()) 29b381aac9bae6d608c72267dd0ed08ec6369e94e4Nuno Lopes return Ctx.getAsArrayType(*this)->getElementType().isConstant(Ctx); 30b381aac9bae6d608c72267dd0ed08ec6369e94e4Nuno Lopes 31b381aac9bae6d608c72267dd0ed08ec6369e94e4Nuno Lopes return false; 32b381aac9bae6d608c72267dd0ed08ec6369e94e4Nuno Lopes} 33b381aac9bae6d608c72267dd0ed08ec6369e94e4Nuno Lopes 34566c2ba743065ec090f5154d5c30cf593aa12a6eTed Kremenekvoid Type::Destroy(ASTContext& C) { 35566c2ba743065ec090f5154d5c30cf593aa12a6eTed Kremenek this->~Type(); 363e9704981d7691fdd44913bf1786e8d760d8a627Steve Naroff C.Deallocate(this); 374b05b1dee6cc65ae61d93dab7edff72710f24589Ted Kremenek} 384b05b1dee6cc65ae61d93dab7edff72710f24589Ted Kremenek 394b05b1dee6cc65ae61d93dab7edff72710f24589Ted Kremenekvoid VariableArrayType::Destroy(ASTContext& C) { 404b05b1dee6cc65ae61d93dab7edff72710f24589Ted Kremenek SizeExpr->Destroy(C); 41566c2ba743065ec090f5154d5c30cf593aa12a6eTed Kremenek this->~VariableArrayType(); 423e9704981d7691fdd44913bf1786e8d760d8a627Steve Naroff C.Deallocate(this); 434b05b1dee6cc65ae61d93dab7edff72710f24589Ted Kremenek} 445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 45898574e7496ba8fd76290079d3a9d06954992734Douglas Gregorvoid DependentSizedArrayType::Destroy(ASTContext& C) { 46898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor SizeExpr->Destroy(C); 47566c2ba743065ec090f5154d5c30cf593aa12a6eTed Kremenek this->~DependentSizedArrayType(); 483e9704981d7691fdd44913bf1786e8d760d8a627Steve Naroff C.Deallocate(this); 49898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor} 50c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner 51c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner/// getArrayElementTypeNoTypeQual - If this is an array type, return the 52c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner/// element type of the array, potentially with type qualifiers missing. 53c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner/// This method should never be used when type qualifiers are meaningful. 54c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattnerconst Type *Type::getArrayElementTypeNoTypeQual() const { 55c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // If this is directly an array type, return it. 56c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const ArrayType *ATy = dyn_cast<ArrayType>(this)) 57c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return ATy->getElementType().getTypePtr(); 58c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner 59c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // If the canonical form of this type isn't the right kind, reject it. 60c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (!isa<ArrayType>(CanonicalType)) { 61c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // Look through type qualifiers 62c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (ArrayType *AT = dyn_cast<ArrayType>(CanonicalType.getUnqualifiedType())) 63c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return AT->getElementType().getTypePtr(); 64c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return 0; 65c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner } 66c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner 67c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // If this is a typedef for an array type, strip the typedef off without 68c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // losing all typedef information. 69c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return getDesugaredType()->getArrayElementTypeNoTypeQual(); 70c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner} 71c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner 72c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner/// getDesugaredType - Return the specified type with any "sugar" removed from 73c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner/// type type. This takes off typedefs, typeof's etc. If the outer level of 74c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner/// the type is already concrete, it returns it unmodified. This is similar 75c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner/// to getting the canonical type, but it doesn't remove *all* typedefs. For 76c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner/// example, it return "T*" as "T*", (not as "int*"), because the pointer is 77c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner/// concrete. 78c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris LattnerQualType Type::getDesugaredType() const { 79c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const TypedefType *TDT = dyn_cast<TypedefType>(this)) 80c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return TDT->LookThroughTypedefs(); 81c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const TypeOfExpr *TOE = dyn_cast<TypeOfExpr>(this)) 82c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return TOE->getUnderlyingExpr()->getType(); 83c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const TypeOfType *TOT = dyn_cast<TypeOfType>(this)) 84c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return TOT->getUnderlyingType(); 855cdf82164dd7c2b2320d6735c63ace4331e0716dDouglas Gregor if (const ClassTemplateSpecializationType *Spec 865cdf82164dd7c2b2320d6735c63ace4331e0716dDouglas Gregor = dyn_cast<ClassTemplateSpecializationType>(this)) 875cdf82164dd7c2b2320d6735c63ace4331e0716dDouglas Gregor return Spec->getCanonicalTypeInternal(); 885cdf82164dd7c2b2320d6735c63ace4331e0716dDouglas Gregor 89c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // FIXME: remove this cast. 90c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return QualType(const_cast<Type*>(this), 0); 91c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner} 92c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner 935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isVoidType - Helper method to determine if this is the 'void' type. 945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerbool Type::isVoidType() const { 955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return BT->getKind() == BuiltinType::Void; 97f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian if (const ExtQualType *AS = dyn_cast<ExtQualType>(CanonicalType)) 984bbce9901f7296ab030c58f0877be0b042bd70d3Chris Lattner return AS->getBaseType()->isVoidType(); 995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 1005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerbool Type::isObjectType() const { 10300e68e2cc5ce37cb95beb801cae73c0d1e9dda37Sebastian Redl if (isa<FunctionType>(CanonicalType) || isa<ReferenceType>(CanonicalType)) 1045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 105f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian if (const ExtQualType *AS = dyn_cast<ExtQualType>(CanonicalType)) 1064bbce9901f7296ab030c58f0877be0b042bd70d3Chris Lattner return AS->getBaseType()->isObjectType(); 1074bbce9901f7296ab030c58f0877be0b042bd70d3Chris Lattner return !CanonicalType->isIncompleteType(); 1085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerbool Type::isDerivedType() const { 1115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (CanonicalType->getTypeClass()) { 112f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian case ExtQual: 113f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian return cast<ExtQualType>(CanonicalType)->getBaseType()->isDerivedType(); 1145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Pointer: 115fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff case VariableArray: 116fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff case ConstantArray: 117c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman case IncompleteArray: 1185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case FunctionProto: 1195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case FunctionNoProto: 1205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Reference: 1215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return true; 1224bbce9901f7296ab030c58f0877be0b042bd70d3Chris Lattner case Tagged: 1234bbce9901f7296ab030c58f0877be0b042bd70d3Chris Lattner return !cast<TagType>(CanonicalType)->getDecl()->isEnum(); 1245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 1255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 1265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 12999dc91422144483c20d1c7381bc9ac634b646b04Chris Lattnerbool Type::isClassType() const { 130f728a4a05df2455e1c6e62173ab720a92cd4a074Chris Lattner if (const RecordType *RT = getAsRecordType()) 131f728a4a05df2455e1c6e62173ab720a92cd4a074Chris Lattner return RT->getDecl()->isClass(); 13299dc91422144483c20d1c7381bc9ac634b646b04Chris Lattner return false; 13399dc91422144483c20d1c7381bc9ac634b646b04Chris Lattner} 134c8629630ce3e7f0da231bf10a4b39240caaac68aChris Lattnerbool Type::isStructureType() const { 135f728a4a05df2455e1c6e62173ab720a92cd4a074Chris Lattner if (const RecordType *RT = getAsRecordType()) 136f728a4a05df2455e1c6e62173ab720a92cd4a074Chris Lattner return RT->getDecl()->isStruct(); 137c8629630ce3e7f0da231bf10a4b39240caaac68aChris Lattner return false; 138c8629630ce3e7f0da231bf10a4b39240caaac68aChris Lattner} 139c8629630ce3e7f0da231bf10a4b39240caaac68aChris Lattnerbool Type::isUnionType() const { 140f728a4a05df2455e1c6e62173ab720a92cd4a074Chris Lattner if (const RecordType *RT = getAsRecordType()) 141f728a4a05df2455e1c6e62173ab720a92cd4a074Chris Lattner return RT->getDecl()->isUnion(); 142c8629630ce3e7f0da231bf10a4b39240caaac68aChris Lattner return false; 143c8629630ce3e7f0da231bf10a4b39240caaac68aChris Lattner} 144c8629630ce3e7f0da231bf10a4b39240caaac68aChris Lattner 145c6fb90a7246c2d5d3233e70107bf9d8c7c9e535bChris Lattnerbool Type::isComplexType() const { 14602f62a9fedbc370fba081303399410a3afdde29fSteve Naroff if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType)) 14702f62a9fedbc370fba081303399410a3afdde29fSteve Naroff return CT->getElementType()->isFloatingType(); 148f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian if (const ExtQualType *AS = dyn_cast<ExtQualType>(CanonicalType)) 1494bbce9901f7296ab030c58f0877be0b042bd70d3Chris Lattner return AS->getBaseType()->isComplexType(); 15002f62a9fedbc370fba081303399410a3afdde29fSteve Naroff return false; 151c6fb90a7246c2d5d3233e70107bf9d8c7c9e535bChris Lattner} 152c6fb90a7246c2d5d3233e70107bf9d8c7c9e535bChris Lattner 1534cdec1c3ca80124024a787ce32833fd5b20cbb15Steve Naroffbool Type::isComplexIntegerType() const { 1544cdec1c3ca80124024a787ce32833fd5b20cbb15Steve Naroff // Check for GCC complex integer extension. 1554cdec1c3ca80124024a787ce32833fd5b20cbb15Steve Naroff if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType)) 1564cdec1c3ca80124024a787ce32833fd5b20cbb15Steve Naroff return CT->getElementType()->isIntegerType(); 157f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian if (const ExtQualType *AS = dyn_cast<ExtQualType>(CanonicalType)) 1584bbce9901f7296ab030c58f0877be0b042bd70d3Chris Lattner return AS->getBaseType()->isComplexIntegerType(); 1594cdec1c3ca80124024a787ce32833fd5b20cbb15Steve Naroff return false; 1604cdec1c3ca80124024a787ce32833fd5b20cbb15Steve Naroff} 1614cdec1c3ca80124024a787ce32833fd5b20cbb15Steve Naroff 1624cdec1c3ca80124024a787ce32833fd5b20cbb15Steve Naroffconst ComplexType *Type::getAsComplexIntegerType() const { 1634cdec1c3ca80124024a787ce32833fd5b20cbb15Steve Naroff // Are we directly a complex type? 1644cdec1c3ca80124024a787ce32833fd5b20cbb15Steve Naroff if (const ComplexType *CTy = dyn_cast<ComplexType>(this)) { 1654cdec1c3ca80124024a787ce32833fd5b20cbb15Steve Naroff if (CTy->getElementType()->isIntegerType()) 1664cdec1c3ca80124024a787ce32833fd5b20cbb15Steve Naroff return CTy; 1674bbce9901f7296ab030c58f0877be0b042bd70d3Chris Lattner return 0; 1684cdec1c3ca80124024a787ce32833fd5b20cbb15Steve Naroff } 1694bbce9901f7296ab030c58f0877be0b042bd70d3Chris Lattner 1702a18dfe292cf3c406a769c3672080970ac586345Chris Lattner // If the canonical form of this type isn't what we want, reject it. 1712a18dfe292cf3c406a769c3672080970ac586345Chris Lattner if (!isa<ComplexType>(CanonicalType)) { 172f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian // Look through type qualifiers (e.g. ExtQualType's). 1732a18dfe292cf3c406a769c3672080970ac586345Chris Lattner if (isa<ComplexType>(CanonicalType.getUnqualifiedType())) 1742a18dfe292cf3c406a769c3672080970ac586345Chris Lattner return CanonicalType.getUnqualifiedType()->getAsComplexIntegerType(); 1754cdec1c3ca80124024a787ce32833fd5b20cbb15Steve Naroff return 0; 1762a18dfe292cf3c406a769c3672080970ac586345Chris Lattner } 1772a18dfe292cf3c406a769c3672080970ac586345Chris Lattner 1784cdec1c3ca80124024a787ce32833fd5b20cbb15Steve Naroff // If this is a typedef for a complex type, strip the typedef off without 1794cdec1c3ca80124024a787ce32833fd5b20cbb15Steve Naroff // losing all typedef information. 1804cdec1c3ca80124024a787ce32833fd5b20cbb15Steve Naroff return getDesugaredType()->getAsComplexIntegerType(); 1814cdec1c3ca80124024a787ce32833fd5b20cbb15Steve Naroff} 1824cdec1c3ca80124024a787ce32833fd5b20cbb15Steve Naroff 18377878cc5aa6ad01fc0c91bac1a61819dbf3bf691Steve Naroffconst BuiltinType *Type::getAsBuiltinType() const { 18477878cc5aa6ad01fc0c91bac1a61819dbf3bf691Steve Naroff // If this is directly a builtin type, return it. 18577878cc5aa6ad01fc0c91bac1a61819dbf3bf691Steve Naroff if (const BuiltinType *BTy = dyn_cast<BuiltinType>(this)) 18677878cc5aa6ad01fc0c91bac1a61819dbf3bf691Steve Naroff return BTy; 187dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner 188dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner // If the canonical form of this type isn't a builtin type, reject it. 189ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb if (!isa<BuiltinType>(CanonicalType)) { 190f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian // Look through type qualifiers (e.g. ExtQualType's). 191ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb if (isa<BuiltinType>(CanonicalType.getUnqualifiedType())) 192ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb return CanonicalType.getUnqualifiedType()->getAsBuiltinType(); 193dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner return 0; 194ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb } 195dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner 19677878cc5aa6ad01fc0c91bac1a61819dbf3bf691Steve Naroff // If this is a typedef for a builtin type, strip the typedef off without 19777878cc5aa6ad01fc0c91bac1a61819dbf3bf691Steve Naroff // losing all typedef information. 198dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner return getDesugaredType()->getAsBuiltinType(); 19977878cc5aa6ad01fc0c91bac1a61819dbf3bf691Steve Naroff} 20077878cc5aa6ad01fc0c91bac1a61819dbf3bf691Steve Naroff 201c8629630ce3e7f0da231bf10a4b39240caaac68aChris Lattnerconst FunctionType *Type::getAsFunctionType() const { 2027064f5c95bbdb17680d0ea658d4090898c2592d3Steve Naroff // If this is directly a function type, return it. 2037064f5c95bbdb17680d0ea658d4090898c2592d3Steve Naroff if (const FunctionType *FTy = dyn_cast<FunctionType>(this)) 2047064f5c95bbdb17680d0ea658d4090898c2592d3Steve Naroff return FTy; 205ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb 206dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner // If the canonical form of this type isn't the right kind, reject it. 207ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb if (!isa<FunctionType>(CanonicalType)) { 208ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb // Look through type qualifiers 209ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb if (isa<FunctionType>(CanonicalType.getUnqualifiedType())) 210ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb return CanonicalType.getUnqualifiedType()->getAsFunctionType(); 211dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner return 0; 212ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb } 213dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner 2147064f5c95bbdb17680d0ea658d4090898c2592d3Steve Naroff // If this is a typedef for a function type, strip the typedef off without 2157064f5c95bbdb17680d0ea658d4090898c2592d3Steve Naroff // losing all typedef information. 216dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner return getDesugaredType()->getAsFunctionType(); 2175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 2185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 219b77792eabf5882cf9af8cc810599b20432fda6c2Chris Lattnerconst FunctionTypeProto *Type::getAsFunctionTypeProto() const { 220b77792eabf5882cf9af8cc810599b20432fda6c2Chris Lattner return dyn_cast_or_null<FunctionTypeProto>(getAsFunctionType()); 221b77792eabf5882cf9af8cc810599b20432fda6c2Chris Lattner} 222b77792eabf5882cf9af8cc810599b20432fda6c2Chris Lattner 223b77792eabf5882cf9af8cc810599b20432fda6c2Chris Lattner 224bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattnerconst PointerLikeType *Type::getAsPointerLikeType() const { 225bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner // If this is directly a pointer-like type, return it. 226bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner if (const PointerLikeType *PTy = dyn_cast<PointerLikeType>(this)) 227bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner return PTy; 228bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner 229bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner // If the canonical form of this type isn't the right kind, reject it. 230bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner if (!isa<PointerLikeType>(CanonicalType)) { 231bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner // Look through type qualifiers 232bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner if (isa<PointerLikeType>(CanonicalType.getUnqualifiedType())) 233bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner return CanonicalType.getUnqualifiedType()->getAsPointerLikeType(); 234bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner return 0; 235bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner } 236bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner 237bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner // If this is a typedef for a pointer type, strip the typedef off without 238bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner // losing all typedef information. 239bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner return getDesugaredType()->getAsPointerLikeType(); 240bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner} 241bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner 242befee48ff2a1dab236c5700f00ecca1cfdcd5837Chris Lattnerconst PointerType *Type::getAsPointerType() const { 2437a2e047c602d6ba28d6c434c990d4b9f7ef8c694Chris Lattner // If this is directly a pointer type, return it. 2447a2e047c602d6ba28d6c434c990d4b9f7ef8c694Chris Lattner if (const PointerType *PTy = dyn_cast<PointerType>(this)) 2457a2e047c602d6ba28d6c434c990d4b9f7ef8c694Chris Lattner return PTy; 246a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner 247dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner // If the canonical form of this type isn't the right kind, reject it. 248ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb if (!isa<PointerType>(CanonicalType)) { 249ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb // Look through type qualifiers 250ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb if (isa<PointerType>(CanonicalType.getUnqualifiedType())) 251ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb return CanonicalType.getUnqualifiedType()->getAsPointerType(); 252dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner return 0; 253ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb } 254dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner 255a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner // If this is a typedef for a pointer type, strip the typedef off without 256a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner // losing all typedef information. 257dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner return getDesugaredType()->getAsPointerType(); 2585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 2595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2605618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroffconst BlockPointerType *Type::getAsBlockPointerType() const { 2615618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff // If this is directly a block pointer type, return it. 2625618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff if (const BlockPointerType *PTy = dyn_cast<BlockPointerType>(this)) 2635618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff return PTy; 2645618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff 2655618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff // If the canonical form of this type isn't the right kind, reject it. 2662a18dfe292cf3c406a769c3672080970ac586345Chris Lattner if (!isa<BlockPointerType>(CanonicalType)) { 2672a18dfe292cf3c406a769c3672080970ac586345Chris Lattner // Look through type qualifiers 2682a18dfe292cf3c406a769c3672080970ac586345Chris Lattner if (isa<BlockPointerType>(CanonicalType.getUnqualifiedType())) 2692a18dfe292cf3c406a769c3672080970ac586345Chris Lattner return CanonicalType.getUnqualifiedType()->getAsBlockPointerType(); 2705618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff return 0; 2712a18dfe292cf3c406a769c3672080970ac586345Chris Lattner } 2725618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff 2735618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff // If this is a typedef for a block pointer type, strip the typedef off 2745618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff // without losing all typedef information. 2755618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff return getDesugaredType()->getAsBlockPointerType(); 2765618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff} 2775618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff 278a1d9fdea79ba7bbd71862b9f9f78f5f117331fc7Chris Lattnerconst ReferenceType *Type::getAsReferenceType() const { 279ea5e79f930bcab2087646d1cb4fc1fe9dcf986a1Bill Wendling // If this is directly a reference type, return it. 280ea5e79f930bcab2087646d1cb4fc1fe9dcf986a1Bill Wendling if (const ReferenceType *RTy = dyn_cast<ReferenceType>(this)) 281ea5e79f930bcab2087646d1cb4fc1fe9dcf986a1Bill Wendling return RTy; 282ea5e79f930bcab2087646d1cb4fc1fe9dcf986a1Bill Wendling 283dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner // If the canonical form of this type isn't the right kind, reject it. 284ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb if (!isa<ReferenceType>(CanonicalType)) { 285ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb // Look through type qualifiers 286ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb if (isa<ReferenceType>(CanonicalType.getUnqualifiedType())) 287ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb return CanonicalType.getUnqualifiedType()->getAsReferenceType(); 288dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner return 0; 289ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb } 290dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner 291ea5e79f930bcab2087646d1cb4fc1fe9dcf986a1Bill Wendling // If this is a typedef for a reference type, strip the typedef off without 292ea5e79f930bcab2087646d1cb4fc1fe9dcf986a1Bill Wendling // losing all typedef information. 293dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner return getDesugaredType()->getAsReferenceType(); 2945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 2955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 296f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redlconst MemberPointerType *Type::getAsMemberPointerType() const { 297f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // If this is directly a member pointer type, return it. 298f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl if (const MemberPointerType *MTy = dyn_cast<MemberPointerType>(this)) 299f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl return MTy; 300f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 301f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // If the canonical form of this type isn't the right kind, reject it. 302f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl if (!isa<MemberPointerType>(CanonicalType)) { 303f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // Look through type qualifiers 304f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl if (isa<MemberPointerType>(CanonicalType.getUnqualifiedType())) 305f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl return CanonicalType.getUnqualifiedType()->getAsMemberPointerType(); 306f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl return 0; 307f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl } 308f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 309f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // If this is a typedef for a member pointer type, strip the typedef off 310f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // without losing all typedef information. 311f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl return getDesugaredType()->getAsMemberPointerType(); 312f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl} 313f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 314d3f2f79fedfef7cae818c55a1f3d7a8f5992e5a0Eli Friedman/// isVariablyModifiedType (C99 6.7.5p3) - Return true for variable length 315d3f2f79fedfef7cae818c55a1f3d7a8f5992e5a0Eli Friedman/// array types and types that contain variable array types in their 316d3f2f79fedfef7cae818c55a1f3d7a8f5992e5a0Eli Friedman/// declarator 317d7444aac1af1c2c1d5e5b7467ecf6006ee2d8abeSteve Naroffbool Type::isVariablyModifiedType() const { 318c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // A VLA is a variably modified type. 319c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (isVariableArrayType()) 320d3f2f79fedfef7cae818c55a1f3d7a8f5992e5a0Eli Friedman return true; 321d3f2f79fedfef7cae818c55a1f3d7a8f5992e5a0Eli Friedman 322d3f2f79fedfef7cae818c55a1f3d7a8f5992e5a0Eli Friedman // An array can contain a variably modified type 323c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const Type *T = getArrayElementTypeNoTypeQual()) 324c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return T->isVariablyModifiedType(); 325d3f2f79fedfef7cae818c55a1f3d7a8f5992e5a0Eli Friedman 326f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // A pointer can point to a variably modified type. 327f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // Also, C++ references and member pointers can point to a variably modified 328f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // type, where VLAs appear as an extension to C++, and should be treated 329f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // correctly. 330f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl if (const PointerLikeType *PT = getAsPointerLikeType()) 331d3f2f79fedfef7cae818c55a1f3d7a8f5992e5a0Eli Friedman return PT->getPointeeType()->isVariablyModifiedType(); 3328edef7c31d27fc9d5d163660702a8a7730a0d19fSebastian Redl if (const MemberPointerType *PT = getAsMemberPointerType()) 3338edef7c31d27fc9d5d163660702a8a7730a0d19fSebastian Redl return PT->getPointeeType()->isVariablyModifiedType(); 334d3f2f79fedfef7cae818c55a1f3d7a8f5992e5a0Eli Friedman 335d3f2f79fedfef7cae818c55a1f3d7a8f5992e5a0Eli Friedman // A function can return a variably modified type 336d3f2f79fedfef7cae818c55a1f3d7a8f5992e5a0Eli Friedman // This one isn't completely obvious, but it follows from the 337d3f2f79fedfef7cae818c55a1f3d7a8f5992e5a0Eli Friedman // definition in C99 6.7.5p3. Because of this rule, it's 338d3f2f79fedfef7cae818c55a1f3d7a8f5992e5a0Eli Friedman // illegal to declare a function returning a variably modified type. 3392a18dfe292cf3c406a769c3672080970ac586345Chris Lattner if (const FunctionType *FT = getAsFunctionType()) 340d3f2f79fedfef7cae818c55a1f3d7a8f5992e5a0Eli Friedman return FT->getResultType()->isVariablyModifiedType(); 341d3f2f79fedfef7cae818c55a1f3d7a8f5992e5a0Eli Friedman 342d7444aac1af1c2c1d5e5b7467ecf6006ee2d8abeSteve Naroff return false; 343d7444aac1af1c2c1d5e5b7467ecf6006ee2d8abeSteve Naroff} 344d7444aac1af1c2c1d5e5b7467ecf6006ee2d8abeSteve Naroff 345c8629630ce3e7f0da231bf10a4b39240caaac68aChris Lattnerconst RecordType *Type::getAsRecordType() const { 346dfa6aae5a119a527e537c35566ba3272fd8c5d74Steve Naroff // If this is directly a reference type, return it. 347dfa6aae5a119a527e537c35566ba3272fd8c5d74Steve Naroff if (const RecordType *RTy = dyn_cast<RecordType>(this)) 348dfa6aae5a119a527e537c35566ba3272fd8c5d74Steve Naroff return RTy; 349dfa6aae5a119a527e537c35566ba3272fd8c5d74Steve Naroff 350dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner // If the canonical form of this type isn't the right kind, reject it. 351ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb if (!isa<RecordType>(CanonicalType)) { 352ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb // Look through type qualifiers 353ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb if (isa<RecordType>(CanonicalType.getUnqualifiedType())) 354ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb return CanonicalType.getUnqualifiedType()->getAsRecordType(); 355dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner return 0; 356ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb } 357dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner 358dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner // If this is a typedef for a record type, strip the typedef off without 359dfa6aae5a119a527e537c35566ba3272fd8c5d74Steve Naroff // losing all typedef information. 360dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner return getDesugaredType()->getAsRecordType(); 361dfa6aae5a119a527e537c35566ba3272fd8c5d74Steve Naroff} 362dfa6aae5a119a527e537c35566ba3272fd8c5d74Steve Naroff 363c8629630ce3e7f0da231bf10a4b39240caaac68aChris Lattnerconst RecordType *Type::getAsStructureType() const { 3647064f5c95bbdb17680d0ea658d4090898c2592d3Steve Naroff // If this is directly a structure type, return it. 365c8629630ce3e7f0da231bf10a4b39240caaac68aChris Lattner if (const RecordType *RT = dyn_cast<RecordType>(this)) { 36639ba4aeca296b1c9f04bde7d9d3cbbf129f1abd3Argyrios Kyrtzidis if (RT->getDecl()->isStruct()) 367c8629630ce3e7f0da231bf10a4b39240caaac68aChris Lattner return RT; 3687064f5c95bbdb17680d0ea658d4090898c2592d3Steve Naroff } 369dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner 370dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner // If the canonical form of this type isn't the right kind, reject it. 371c8629630ce3e7f0da231bf10a4b39240caaac68aChris Lattner if (const RecordType *RT = dyn_cast<RecordType>(CanonicalType)) { 37239ba4aeca296b1c9f04bde7d9d3cbbf129f1abd3Argyrios Kyrtzidis if (!RT->getDecl()->isStruct()) 373dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner return 0; 374dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner 375dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner // If this is a typedef for a structure type, strip the typedef off without 376dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner // losing all typedef information. 377dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner return getDesugaredType()->getAsStructureType(); 3785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 379ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb // Look through type qualifiers 380ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb if (isa<RecordType>(CanonicalType.getUnqualifiedType())) 381ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb return CanonicalType.getUnqualifiedType()->getAsStructureType(); 3827064f5c95bbdb17680d0ea658d4090898c2592d3Steve Naroff return 0; 3835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 385c8629630ce3e7f0da231bf10a4b39240caaac68aChris Lattnerconst RecordType *Type::getAsUnionType() const { 3867064f5c95bbdb17680d0ea658d4090898c2592d3Steve Naroff // If this is directly a union type, return it. 387c8629630ce3e7f0da231bf10a4b39240caaac68aChris Lattner if (const RecordType *RT = dyn_cast<RecordType>(this)) { 38839ba4aeca296b1c9f04bde7d9d3cbbf129f1abd3Argyrios Kyrtzidis if (RT->getDecl()->isUnion()) 389c8629630ce3e7f0da231bf10a4b39240caaac68aChris Lattner return RT; 3907064f5c95bbdb17680d0ea658d4090898c2592d3Steve Naroff } 391ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb 392dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner // If the canonical form of this type isn't the right kind, reject it. 393c8629630ce3e7f0da231bf10a4b39240caaac68aChris Lattner if (const RecordType *RT = dyn_cast<RecordType>(CanonicalType)) { 39439ba4aeca296b1c9f04bde7d9d3cbbf129f1abd3Argyrios Kyrtzidis if (!RT->getDecl()->isUnion()) 395dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner return 0; 396dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner 397dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner // If this is a typedef for a union type, strip the typedef off without 398dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner // losing all typedef information. 399dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner return getDesugaredType()->getAsUnionType(); 4005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 401ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb 402ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb // Look through type qualifiers 403ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb if (isa<RecordType>(CanonicalType.getUnqualifiedType())) 404ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb return CanonicalType.getUnqualifiedType()->getAsUnionType(); 4057064f5c95bbdb17680d0ea658d4090898c2592d3Steve Naroff return 0; 4065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 4075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 408ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedmanconst EnumType *Type::getAsEnumType() const { 409ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman // Check the canonicalized unqualified type directly; the more complex 410ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman // version is unnecessary because there isn't any typedef information 411ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman // to preserve. 412ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return dyn_cast<EnumType>(CanonicalType.getUnqualifiedType()); 413ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman} 414ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman 415c6fb90a7246c2d5d3233e70107bf9d8c7c9e535bChris Lattnerconst ComplexType *Type::getAsComplexType() const { 416c6fb90a7246c2d5d3233e70107bf9d8c7c9e535bChris Lattner // Are we directly a complex type? 417c6fb90a7246c2d5d3233e70107bf9d8c7c9e535bChris Lattner if (const ComplexType *CTy = dyn_cast<ComplexType>(this)) 418c6fb90a7246c2d5d3233e70107bf9d8c7c9e535bChris Lattner return CTy; 419c6fb90a7246c2d5d3233e70107bf9d8c7c9e535bChris Lattner 420dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner // If the canonical form of this type isn't the right kind, reject it. 421ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb if (!isa<ComplexType>(CanonicalType)) { 422ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb // Look through type qualifiers 423ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb if (isa<ComplexType>(CanonicalType.getUnqualifiedType())) 424ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb return CanonicalType.getUnqualifiedType()->getAsComplexType(); 425dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner return 0; 426ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb } 427dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner 428c6fb90a7246c2d5d3233e70107bf9d8c7c9e535bChris Lattner // If this is a typedef for a complex type, strip the typedef off without 429c6fb90a7246c2d5d3233e70107bf9d8c7c9e535bChris Lattner // losing all typedef information. 430dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner return getDesugaredType()->getAsComplexType(); 4317a2e047c602d6ba28d6c434c990d4b9f7ef8c694Chris Lattner} 4327a2e047c602d6ba28d6c434c990d4b9f7ef8c694Chris Lattner 433c8629630ce3e7f0da231bf10a4b39240caaac68aChris Lattnerconst VectorType *Type::getAsVectorType() const { 4347a2e047c602d6ba28d6c434c990d4b9f7ef8c694Chris Lattner // Are we directly a vector type? 4357a2e047c602d6ba28d6c434c990d4b9f7ef8c694Chris Lattner if (const VectorType *VTy = dyn_cast<VectorType>(this)) 4367a2e047c602d6ba28d6c434c990d4b9f7ef8c694Chris Lattner return VTy; 437a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner 438dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner // If the canonical form of this type isn't the right kind, reject it. 439ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb if (!isa<VectorType>(CanonicalType)) { 440ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb // Look through type qualifiers 441ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb if (isa<VectorType>(CanonicalType.getUnqualifiedType())) 442ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb return CanonicalType.getUnqualifiedType()->getAsVectorType(); 443dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner return 0; 444ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb } 445dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner 446a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner // If this is a typedef for a vector type, strip the typedef off without 447a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner // losing all typedef information. 448dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner return getDesugaredType()->getAsVectorType(); 4497a2e047c602d6ba28d6c434c990d4b9f7ef8c694Chris Lattner} 4507a2e047c602d6ba28d6c434c990d4b9f7ef8c694Chris Lattner 451213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begemanconst ExtVectorType *Type::getAsExtVectorType() const { 4527064f5c95bbdb17680d0ea658d4090898c2592d3Steve Naroff // Are we directly an OpenCU vector type? 453213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman if (const ExtVectorType *VTy = dyn_cast<ExtVectorType>(this)) 4547064f5c95bbdb17680d0ea658d4090898c2592d3Steve Naroff return VTy; 4557064f5c95bbdb17680d0ea658d4090898c2592d3Steve Naroff 456dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner // If the canonical form of this type isn't the right kind, reject it. 457213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman if (!isa<ExtVectorType>(CanonicalType)) { 458ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb // Look through type qualifiers 459213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman if (isa<ExtVectorType>(CanonicalType.getUnqualifiedType())) 460213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman return CanonicalType.getUnqualifiedType()->getAsExtVectorType(); 461dea6146deede4b89a1757d46cd92ebf158659c25Chris Lattner return 0; 462ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb } 4637064f5c95bbdb17680d0ea658d4090898c2592d3Steve Naroff 464213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman // If this is a typedef for an extended vector type, strip the typedef off 465213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman // without losing all typedef information. 466213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman return getDesugaredType()->getAsExtVectorType(); 4677064f5c95bbdb17680d0ea658d4090898c2592d3Steve Naroff} 4687064f5c95bbdb17680d0ea658d4090898c2592d3Steve Naroff 469368eefa081d12f0a265ee90ee8ec61b54168d57dChris Lattnerconst ObjCInterfaceType *Type::getAsObjCInterfaceType() const { 470eca7be6b7ebd93682eeaab2c71d59f2995dacdccChris Lattner // There is no sugar for ObjCInterfaceType's, just return the canonical 4712a18dfe292cf3c406a769c3672080970ac586345Chris Lattner // type pointer if it is the right class. There is no typedef information to 4722a18dfe292cf3c406a769c3672080970ac586345Chris Lattner // return and these cannot be Address-space qualified. 473eca7be6b7ebd93682eeaab2c71d59f2995dacdccChris Lattner return dyn_cast<ObjCInterfaceType>(CanonicalType); 474368eefa081d12f0a265ee90ee8ec61b54168d57dChris Lattner} 475368eefa081d12f0a265ee90ee8ec61b54168d57dChris Lattner 476368eefa081d12f0a265ee90ee8ec61b54168d57dChris Lattnerconst ObjCQualifiedInterfaceType * 477368eefa081d12f0a265ee90ee8ec61b54168d57dChris LattnerType::getAsObjCQualifiedInterfaceType() const { 4782a18dfe292cf3c406a769c3672080970ac586345Chris Lattner // There is no sugar for ObjCQualifiedInterfaceType's, just return the 4792a18dfe292cf3c406a769c3672080970ac586345Chris Lattner // canonical type pointer if it is the right class. 480eca7be6b7ebd93682eeaab2c71d59f2995dacdccChris Lattner return dyn_cast<ObjCQualifiedInterfaceType>(CanonicalType); 481eca7be6b7ebd93682eeaab2c71d59f2995dacdccChris Lattner} 482eca7be6b7ebd93682eeaab2c71d59f2995dacdccChris Lattner 483eca7be6b7ebd93682eeaab2c71d59f2995dacdccChris Lattnerconst ObjCQualifiedIdType *Type::getAsObjCQualifiedIdType() const { 484eca7be6b7ebd93682eeaab2c71d59f2995dacdccChris Lattner // There is no sugar for ObjCQualifiedIdType's, just return the canonical 485eca7be6b7ebd93682eeaab2c71d59f2995dacdccChris Lattner // type pointer if it is the right class. 486eca7be6b7ebd93682eeaab2c71d59f2995dacdccChris Lattner return dyn_cast<ObjCQualifiedIdType>(CanonicalType); 487368eefa081d12f0a265ee90ee8ec61b54168d57dChris Lattner} 488368eefa081d12f0a265ee90ee8ec61b54168d57dChris Lattner 48972c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregorconst TemplateTypeParmType *Type::getAsTemplateTypeParmType() const { 49072c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor // There is no sugar for template type parameters, so just return 49172c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor // the canonical type pointer if it is the right class. 4922a18dfe292cf3c406a769c3672080970ac586345Chris Lattner // FIXME: can these be address-space qualified? 49372c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor return dyn_cast<TemplateTypeParmType>(CanonicalType); 49472c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor} 495368eefa081d12f0a265ee90ee8ec61b54168d57dChris Lattner 49655f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregorconst ClassTemplateSpecializationType * 49755f6b14230c94272efbbcdd89a92224c8db9f225Douglas GregorType::getClassTemplateSpecializationType() const { 49855f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor // There is no sugar for class template specialization types, so 49955f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor // just return the canonical type pointer if it is the right class. 50055f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor return dyn_cast<ClassTemplateSpecializationType>(CanonicalType); 50155f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor} 50255f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor 50355f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor 5045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerbool Type::isIntegerType() const { 5055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 5065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return BT->getKind() >= BuiltinType::Bool && 5075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer BT->getKind() <= BuiltinType::LongLong; 5085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 509834a72ac74cf4ff07ba6215545dba3db578f8a07Chris Lattner // Incomplete enum types are not treated as integer types. 5108e9bebdea69c590dedfbf27374114cb76fe12fbdDouglas Gregor // FIXME: In C++, enum types are never integer types. 511834a72ac74cf4ff07ba6215545dba3db578f8a07Chris Lattner if (TT->getDecl()->isEnum() && TT->getDecl()->isDefinition()) 5125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return true; 513f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman if (isa<FixedWidthIntType>(CanonicalType)) 514f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return true; 515c63b96ad706e054a1390dd2ab53af9f05d33bbb1Steve Naroff if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 516c63b96ad706e054a1390dd2ab53af9f05d33bbb1Steve Naroff return VT->getElementType()->isIntegerType(); 517f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 518f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian return EXTQT->getBaseType()->isIntegerType(); 5195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 5205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 5215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 52233e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanianbool Type::isIntegralType() const { 52333e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 52433e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian return BT->getKind() >= BuiltinType::Bool && 52533e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian BT->getKind() <= BuiltinType::LongLong; 52633e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 527834a72ac74cf4ff07ba6215545dba3db578f8a07Chris Lattner if (TT->getDecl()->isEnum() && TT->getDecl()->isDefinition()) 528834a72ac74cf4ff07ba6215545dba3db578f8a07Chris Lattner return true; // Complete enum types are integral. 5298e9bebdea69c590dedfbf27374114cb76fe12fbdDouglas Gregor // FIXME: In C++, enum types are never integral. 530f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman if (isa<FixedWidthIntType>(CanonicalType)) 531f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return true; 532f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 533f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian return EXTQT->getBaseType()->isIntegralType(); 53433e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian return false; 53533e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian} 53633e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian 53713b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroffbool Type::isEnumeralType() const { 53813b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 53939ba4aeca296b1c9f04bde7d9d3cbbf129f1abd3Argyrios Kyrtzidis return TT->getDecl()->isEnum(); 540f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 541f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian return EXTQT->getBaseType()->isEnumeralType(); 54213b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff return false; 54313b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff} 54413b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff 54513b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroffbool Type::isBooleanType() const { 54613b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 54713b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff return BT->getKind() == BuiltinType::Bool; 548f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 549f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian return EXTQT->getBaseType()->isBooleanType(); 55013b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff return false; 55113b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff} 55213b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff 55313b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroffbool Type::isCharType() const { 55413b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 55513b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff return BT->getKind() == BuiltinType::Char_U || 55613b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff BT->getKind() == BuiltinType::UChar || 557c67ad5f299bb2c09e4567def8ff0d34bd15a42fdAnders Carlsson BT->getKind() == BuiltinType::Char_S || 558c67ad5f299bb2c09e4567def8ff0d34bd15a42fdAnders Carlsson BT->getKind() == BuiltinType::SChar; 559f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 560f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian return EXTQT->getBaseType()->isCharType(); 56113b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff return false; 56213b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff} 56313b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff 56477a52233f7c0f162672652051bfe78b65ad4f789Douglas Gregorbool Type::isWideCharType() const { 56577a52233f7c0f162672652051bfe78b65ad4f789Douglas Gregor if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 56677a52233f7c0f162672652051bfe78b65ad4f789Douglas Gregor return BT->getKind() == BuiltinType::WChar; 567f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 568f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian return EXTQT->getBaseType()->isWideCharType(); 56977a52233f7c0f162672652051bfe78b65ad4f789Douglas Gregor return false; 57077a52233f7c0f162672652051bfe78b65ad4f789Douglas Gregor} 57177a52233f7c0f162672652051bfe78b65ad4f789Douglas Gregor 572d5bbce4382622feb4ca5978c4bb8fcceb7aaec00Chris Lattner/// isSignedIntegerType - Return true if this is an integer type that is 573d5bbce4382622feb4ca5978c4bb8fcceb7aaec00Chris Lattner/// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], 574d5bbce4382622feb4ca5978c4bb8fcceb7aaec00Chris Lattner/// an enum decl which has a signed representation, or a vector of signed 575d5bbce4382622feb4ca5978c4bb8fcceb7aaec00Chris Lattner/// integer element type. 5765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerbool Type::isSignedIntegerType() const { 5775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) { 5785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return BT->getKind() >= BuiltinType::Char_S && 5795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer BT->getKind() <= BuiltinType::LongLong; 5805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 581d5bbce4382622feb4ca5978c4bb8fcceb7aaec00Chris Lattner 58237c1b78a20a09b0456aa5caa15e159027010ca22Chris Lattner if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 58337c1b78a20a09b0456aa5caa15e159027010ca22Chris Lattner return ET->getDecl()->getIntegerType()->isSignedIntegerType(); 584d5bbce4382622feb4ca5978c4bb8fcceb7aaec00Chris Lattner 585f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman if (const FixedWidthIntType *FWIT = 586f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman dyn_cast<FixedWidthIntType>(CanonicalType)) 587f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return FWIT->isSigned(); 588f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman 589c63b96ad706e054a1390dd2ab53af9f05d33bbb1Steve Naroff if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 590c63b96ad706e054a1390dd2ab53af9f05d33bbb1Steve Naroff return VT->getElementType()->isSignedIntegerType(); 591f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 592f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian return EXTQT->getBaseType()->isSignedIntegerType(); 5935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 5945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 5955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 596d5bbce4382622feb4ca5978c4bb8fcceb7aaec00Chris Lattner/// isUnsignedIntegerType - Return true if this is an integer type that is 597d5bbce4382622feb4ca5978c4bb8fcceb7aaec00Chris Lattner/// unsigned, according to C99 6.2.5p6 [which returns true for _Bool], an enum 598d5bbce4382622feb4ca5978c4bb8fcceb7aaec00Chris Lattner/// decl which has an unsigned representation, or a vector of unsigned integer 599d5bbce4382622feb4ca5978c4bb8fcceb7aaec00Chris Lattner/// element type. 6005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerbool Type::isUnsignedIntegerType() const { 6015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) { 6025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return BT->getKind() >= BuiltinType::Bool && 6035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer BT->getKind() <= BuiltinType::ULongLong; 6045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 605d5bbce4382622feb4ca5978c4bb8fcceb7aaec00Chris Lattner 60637c1b78a20a09b0456aa5caa15e159027010ca22Chris Lattner if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 60737c1b78a20a09b0456aa5caa15e159027010ca22Chris Lattner return ET->getDecl()->getIntegerType()->isUnsignedIntegerType(); 608d5bbce4382622feb4ca5978c4bb8fcceb7aaec00Chris Lattner 609f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman if (const FixedWidthIntType *FWIT = 610f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman dyn_cast<FixedWidthIntType>(CanonicalType)) 611f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return !FWIT->isSigned(); 612f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman 613c63b96ad706e054a1390dd2ab53af9f05d33bbb1Steve Naroff if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 614c63b96ad706e054a1390dd2ab53af9f05d33bbb1Steve Naroff return VT->getElementType()->isUnsignedIntegerType(); 615f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 616f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian return EXTQT->getBaseType()->isUnsignedIntegerType(); 6175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 6185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 6195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 6205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerbool Type::isFloatingType() const { 6215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 6225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return BT->getKind() >= BuiltinType::Float && 6235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer BT->getKind() <= BuiltinType::LongDouble; 6245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType)) 625729a2131228cb7fcbc00bd8af36bc6f14d12317dChris Lattner return CT->getElementType()->isFloatingType(); 626c63b96ad706e054a1390dd2ab53af9f05d33bbb1Steve Naroff if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 627c63b96ad706e054a1390dd2ab53af9f05d33bbb1Steve Naroff return VT->getElementType()->isFloatingType(); 628f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 629f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian return EXTQT->getBaseType()->isFloatingType(); 6305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 6315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 6325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 6335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerbool Type::isRealFloatingType() const { 6345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 6355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return BT->getKind() >= BuiltinType::Float && 6365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer BT->getKind() <= BuiltinType::LongDouble; 637c63b96ad706e054a1390dd2ab53af9f05d33bbb1Steve Naroff if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 638c63b96ad706e054a1390dd2ab53af9f05d33bbb1Steve Naroff return VT->getElementType()->isRealFloatingType(); 639f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 640f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian return EXTQT->getBaseType()->isRealFloatingType(); 6415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 6425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 6435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 6445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerbool Type::isRealType() const { 6455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 6465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return BT->getKind() >= BuiltinType::Bool && 6475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer BT->getKind() <= BuiltinType::LongDouble; 6485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 649834a72ac74cf4ff07ba6215545dba3db578f8a07Chris Lattner return TT->getDecl()->isEnum() && TT->getDecl()->isDefinition(); 650f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman if (isa<FixedWidthIntType>(CanonicalType)) 651f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return true; 652c63b96ad706e054a1390dd2ab53af9f05d33bbb1Steve Naroff if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 653c63b96ad706e054a1390dd2ab53af9f05d33bbb1Steve Naroff return VT->getElementType()->isRealType(); 654f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 655f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian return EXTQT->getBaseType()->isRealType(); 6565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 6575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 6585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 6595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerbool Type::isArithmeticType() const { 6605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 661a7fbf7282eadebaf1293d9f970b01fb57f4b0ae4Douglas Gregor return BT->getKind() >= BuiltinType::Bool && 662a7fbf7282eadebaf1293d9f970b01fb57f4b0ae4Douglas Gregor BT->getKind() <= BuiltinType::LongDouble; 66337c1b78a20a09b0456aa5caa15e159027010ca22Chris Lattner if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 66437c1b78a20a09b0456aa5caa15e159027010ca22Chris Lattner // GCC allows forward declaration of enum types (forbid by C99 6.7.2.3p2). 66537c1b78a20a09b0456aa5caa15e159027010ca22Chris Lattner // If a body isn't seen by the time we get here, return false. 66637c1b78a20a09b0456aa5caa15e159027010ca22Chris Lattner return ET->getDecl()->isDefinition(); 667f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman if (isa<FixedWidthIntType>(CanonicalType)) 668f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return true; 669f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 670f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian return EXTQT->getBaseType()->isArithmeticType(); 6715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return isa<ComplexType>(CanonicalType) || isa<VectorType>(CanonicalType); 6725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 6735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 6745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerbool Type::isScalarType() const { 6755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 6765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return BT->getKind() != BuiltinType::Void; 6775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) { 678834a72ac74cf4ff07ba6215545dba3db578f8a07Chris Lattner // Enums are scalar types, but only if they are defined. Incomplete enums 679834a72ac74cf4ff07ba6215545dba3db578f8a07Chris Lattner // are not treated as scalar types. 680834a72ac74cf4ff07ba6215545dba3db578f8a07Chris Lattner if (TT->getDecl()->isEnum() && TT->getDecl()->isDefinition()) 6815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return true; 6825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 6835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 684f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 685f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian return EXTQT->getBaseType()->isScalarType(); 686f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman if (isa<FixedWidthIntType>(CanonicalType)) 687f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return true; 6885618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff return isa<PointerType>(CanonicalType) || 6895618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff isa<BlockPointerType>(CanonicalType) || 690f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl isa<MemberPointerType>(CanonicalType) || 6915618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff isa<ComplexType>(CanonicalType) || 692a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek isa<ObjCQualifiedIdType>(CanonicalType); 6935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 6945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 695d7eb846aaf5ee4a8d22c3cd0796d1e7229d46013Douglas Gregor/// \brief Determines whether the type is a C++ aggregate type or C 696d7eb846aaf5ee4a8d22c3cd0796d1e7229d46013Douglas Gregor/// aggregate or union type. 697d7eb846aaf5ee4a8d22c3cd0796d1e7229d46013Douglas Gregor/// 698d7eb846aaf5ee4a8d22c3cd0796d1e7229d46013Douglas Gregor/// An aggregate type is an array or a class type (struct, union, or 699d7eb846aaf5ee4a8d22c3cd0796d1e7229d46013Douglas Gregor/// class) that has no user-declared constructors, no private or 700d7eb846aaf5ee4a8d22c3cd0796d1e7229d46013Douglas Gregor/// protected non-static data members, no base classes, and no virtual 701d7eb846aaf5ee4a8d22c3cd0796d1e7229d46013Douglas Gregor/// functions (C++ [dcl.init.aggr]p1). The notion of an aggregate type 702d7eb846aaf5ee4a8d22c3cd0796d1e7229d46013Douglas Gregor/// subsumes the notion of C aggregates (C99 6.2.5p21) because it also 703d7eb846aaf5ee4a8d22c3cd0796d1e7229d46013Douglas Gregor/// includes union types. 7045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerbool Type::isAggregateType() const { 705d7eb846aaf5ee4a8d22c3cd0796d1e7229d46013Douglas Gregor if (const CXXRecordType *CXXClassType = dyn_cast<CXXRecordType>(CanonicalType)) 706d7eb846aaf5ee4a8d22c3cd0796d1e7229d46013Douglas Gregor return CXXClassType->getDecl()->isAggregate(); 707d7eb846aaf5ee4a8d22c3cd0796d1e7229d46013Douglas Gregor if (isa<RecordType>(CanonicalType)) 708d7eb846aaf5ee4a8d22c3cd0796d1e7229d46013Douglas Gregor return true; 709f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 710f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian return EXTQT->getBaseType()->isAggregateType(); 711c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman return isa<ArrayType>(CanonicalType); 7125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 7135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 7149bfa73c5ab7bf4b0e749d04f29da6884e8d5bd9fChris Lattner/// isConstantSizeType - Return true if this is not a variable sized type, 7159bfa73c5ab7bf4b0e749d04f29da6884e8d5bd9fChris Lattner/// according to the rules of C99 6.7.5p3. It is not legal to call this on 716898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// incomplete types or dependent types. 7173c2b3170041f69a92904e3bab9b6d654eaf260acEli Friedmanbool Type::isConstantSizeType() const { 718f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 719f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian return EXTQT->getBaseType()->isConstantSizeType(); 720d52a4578144ab2887912e52eabec58a857a44adbChris Lattner assert(!isIncompleteType() && "This doesn't make sense for incomplete types"); 721898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor assert(!isDependentType() && "This doesn't make sense for dependent types"); 7229bfa73c5ab7bf4b0e749d04f29da6884e8d5bd9fChris Lattner // The VAT must have a size, as it is known to be complete. 7239bfa73c5ab7bf4b0e749d04f29da6884e8d5bd9fChris Lattner return !isa<VariableArrayType>(CanonicalType); 7245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 7255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 7265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isIncompleteType - Return true if this is an incomplete type (C99 6.2.5p1) 7275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - a type that can describe objects, but which lacks information needed to 7285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// determine its size. 7295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerbool Type::isIncompleteType() const { 7305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (CanonicalType->getTypeClass()) { 7315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: return false; 732f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian case ExtQual: 733f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian return cast<ExtQualType>(CanonicalType)->getBaseType()->isIncompleteType(); 7345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Builtin: 7355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Void is the only incomplete builtin type. Per C99 6.2.5p19, it can never 7365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // be completed. 7375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return isVoidType(); 7385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Tagged: 7395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // A tagged type (struct/union/enum/class) is incomplete if the decl is a 7405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // forward declaration, but not a full definition (C99 6.2.5p22). 7415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return !cast<TagType>(CanonicalType)->getDecl()->isDefinition(); 742c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman case IncompleteArray: 7435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // An array of unknown size is an incomplete type (C99 6.2.5p22). 744c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman return true; 7455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 7465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 7475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 74864b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl/// isPODType - Return true if this is a plain-old-data type (C++ 3.9p10) 74964b45f7e0d3167f040841ac2920aead7f080730dSebastian Redlbool Type::isPODType() const { 75064b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl // The compiler shouldn't query this for incomplete types, but the user might. 75164b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl // We return false for that case. 75264b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl if (isIncompleteType()) 75364b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl return false; 75464b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl 75564b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl switch (CanonicalType->getTypeClass()) { 75664b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl // Everything not explicitly mentioned is not POD. 75764b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl default: return false; 758f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian case ExtQual: 759f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian return cast<ExtQualType>(CanonicalType)->getBaseType()->isPODType(); 76064b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl case VariableArray: 76164b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl case ConstantArray: 76264b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl // IncompleteArray is caught by isIncompleteType() above. 76364b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl return cast<ArrayType>(CanonicalType)->getElementType()->isPODType(); 76464b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl 76564b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl case Builtin: 76664b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl case Complex: 76764b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl case Pointer: 768f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl case MemberPointer: 76964b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl case Vector: 77064b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl case ExtVector: 771672c91db00d28187600dd18ef6c524ff45e95ef2Anders Carlsson case ObjCQualifiedId: 77264b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl return true; 77364b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl 77464b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl case Tagged: 77564b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl if (isEnumeralType()) 77664b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl return true; 77764b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl if (CXXRecordDecl *RDecl = dyn_cast<CXXRecordDecl>( 77864b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl cast<TagType>(CanonicalType)->getDecl())) 77964b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl return RDecl->isPOD(); 78064b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl // C struct/union is POD. 78164b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl return true; 78264b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl } 78364b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl} 78464b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl 7855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerbool Type::isPromotableIntegerType() const { 7862a18dfe292cf3c406a769c3672080970ac586345Chris Lattner if (const BuiltinType *BT = getAsBuiltinType()) 7872a18dfe292cf3c406a769c3672080970ac586345Chris Lattner switch (BT->getKind()) { 7882a18dfe292cf3c406a769c3672080970ac586345Chris Lattner case BuiltinType::Bool: 7892a18dfe292cf3c406a769c3672080970ac586345Chris Lattner case BuiltinType::Char_S: 7902a18dfe292cf3c406a769c3672080970ac586345Chris Lattner case BuiltinType::Char_U: 7912a18dfe292cf3c406a769c3672080970ac586345Chris Lattner case BuiltinType::SChar: 7922a18dfe292cf3c406a769c3672080970ac586345Chris Lattner case BuiltinType::UChar: 7932a18dfe292cf3c406a769c3672080970ac586345Chris Lattner case BuiltinType::Short: 7942a18dfe292cf3c406a769c3672080970ac586345Chris Lattner case BuiltinType::UShort: 7952a18dfe292cf3c406a769c3672080970ac586345Chris Lattner return true; 7962a18dfe292cf3c406a769c3672080970ac586345Chris Lattner default: 7972a18dfe292cf3c406a769c3672080970ac586345Chris Lattner return false; 7982a18dfe292cf3c406a769c3672080970ac586345Chris Lattner } 7992a18dfe292cf3c406a769c3672080970ac586345Chris Lattner return false; 8005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 8015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 8025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerconst char *BuiltinType::getName() const { 8035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (getKind()) { 8045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: assert(0 && "Unknown builtin type!"); 8055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Void: return "void"; 8065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Bool: return "_Bool"; 8075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Char_S: return "char"; 8085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Char_U: return "char"; 8095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case SChar: return "signed char"; 8105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Short: return "short"; 8115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Int: return "int"; 8125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Long: return "long"; 8135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LongLong: return "long long"; 8145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UChar: return "unsigned char"; 8155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UShort: return "unsigned short"; 8165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UInt: return "unsigned int"; 8175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ULong: return "unsigned long"; 8185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ULongLong: return "unsigned long long"; 8195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Float: return "float"; 8205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Double: return "double"; 8215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LongDouble: return "long double"; 82246713efe13c89f4ec9cd9546c7b598fe7186089bArgyrios Kyrtzidis case WChar: return "wchar_t"; 8238e9bebdea69c590dedfbf27374114cb76fe12fbdDouglas Gregor case Overload: return "<overloaded function type>"; 824898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor case Dependent: return "<dependent type>"; 8255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 8265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 8275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 8285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid FunctionTypeProto::Profile(llvm::FoldingSetNodeID &ID, QualType Result, 829942cfd37297528918616d06cd6e4e8bd6e4915a2Chris Lattner arg_type_iterator ArgTys, 830971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis unsigned NumArgs, bool isVariadic, 831971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis unsigned TypeQuals) { 8325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ID.AddPointer(Result.getAsOpaquePtr()); 8335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0; i != NumArgs; ++i) 8345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ID.AddPointer(ArgTys[i].getAsOpaquePtr()); 8355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ID.AddInteger(isVariadic); 836971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis ID.AddInteger(TypeQuals); 8375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 8385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 8395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid FunctionTypeProto::Profile(llvm::FoldingSetNodeID &ID) { 840971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis Profile(ID, getResultType(), arg_type_begin(), NumArgs, isVariadic(), 841971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis getTypeQuals()); 8425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 8435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 844a526c5c67e5a0473c340903ee542ce570119665fTed Kremenekvoid ObjCQualifiedInterfaceType::Profile(llvm::FoldingSetNodeID &ID, 8451ee0700c7dbe3554df09b4558e0b35a53d487ff2Chris Lattner const ObjCInterfaceDecl *Decl, 846a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek ObjCProtocolDecl **protocols, 8474b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian unsigned NumProtocols) { 8481ee0700c7dbe3554df09b4558e0b35a53d487ff2Chris Lattner ID.AddPointer(Decl); 8494b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian for (unsigned i = 0; i != NumProtocols; i++) 8504b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian ID.AddPointer(protocols[i]); 8514b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian} 8524b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian 853a526c5c67e5a0473c340903ee542ce570119665fTed Kremenekvoid ObjCQualifiedInterfaceType::Profile(llvm::FoldingSetNodeID &ID) { 8541ee0700c7dbe3554df09b4558e0b35a53d487ff2Chris Lattner Profile(ID, getDecl(), &Protocols[0], getNumProtocols()); 8554b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian} 8564b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian 857a526c5c67e5a0473c340903ee542ce570119665fTed Kremenekvoid ObjCQualifiedIdType::Profile(llvm::FoldingSetNodeID &ID, 85862f5f7ffad57e0c2af2b308af3735351505937cbChris Lattner ObjCProtocolDecl **protocols, 85962f5f7ffad57e0c2af2b308af3735351505937cbChris Lattner unsigned NumProtocols) { 860c569249ca0ab755ac79d8cbbfcb2bcae19743624Fariborz Jahanian for (unsigned i = 0; i != NumProtocols; i++) 861c569249ca0ab755ac79d8cbbfcb2bcae19743624Fariborz Jahanian ID.AddPointer(protocols[i]); 862c569249ca0ab755ac79d8cbbfcb2bcae19743624Fariborz Jahanian} 863c569249ca0ab755ac79d8cbbfcb2bcae19743624Fariborz Jahanian 864a526c5c67e5a0473c340903ee542ce570119665fTed Kremenekvoid ObjCQualifiedIdType::Profile(llvm::FoldingSetNodeID &ID) { 865c569249ca0ab755ac79d8cbbfcb2bcae19743624Fariborz Jahanian Profile(ID, &Protocols[0], getNumProtocols()); 866c569249ca0ab755ac79d8cbbfcb2bcae19743624Fariborz Jahanian} 867c569249ca0ab755ac79d8cbbfcb2bcae19743624Fariborz Jahanian 868a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner/// LookThroughTypedefs - Return the ultimate type this typedef corresponds to 869a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner/// potentially looking through *all* consequtive typedefs. This returns the 870a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner/// sum of the type qualifiers, so if you have: 871a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner/// typedef const int A; 872a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner/// typedef volatile A B; 873a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner/// looking through the typedefs for B will give you "const volatile A". 874a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner/// 875a2c7767ce7d8feb10253f4b650826a20f3324c6fChris LattnerQualType TypedefType::LookThroughTypedefs() const { 876a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner // Usually, there is only a single level of typedefs, be fast in that case. 877a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner QualType FirstType = getDecl()->getUnderlyingType(); 878a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner if (!isa<TypedefType>(FirstType)) 879a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner return FirstType; 880a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner 881a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner // Otherwise, do the fully general loop. 882a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner unsigned TypeQuals = 0; 883a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner const TypedefType *TDT = this; 884a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner while (1) { 885a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner QualType CurType = TDT->getDecl()->getUnderlyingType(); 886f46699ce225811d8d9dbab9d00189a0e54469457Chris Lattner 887f46699ce225811d8d9dbab9d00189a0e54469457Chris Lattner 888f46699ce225811d8d9dbab9d00189a0e54469457Chris Lattner /// FIXME: 889f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian /// FIXME: This is incorrect for ExtQuals! 890f46699ce225811d8d9dbab9d00189a0e54469457Chris Lattner /// FIXME: 891f46699ce225811d8d9dbab9d00189a0e54469457Chris Lattner TypeQuals |= CurType.getCVRQualifiers(); 892a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner 893a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner TDT = dyn_cast<TypedefType>(CurType); 894a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner if (TDT == 0) 895a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner return QualType(CurType.getTypePtr(), TypeQuals); 896a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner } 897a2c7767ce7d8feb10253f4b650826a20f3324c6fChris Lattner} 8985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 899898574e7496ba8fd76290079d3a9d06954992734Douglas GregorTypeOfExpr::TypeOfExpr(Expr *E, QualType can) 900898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor : Type(TypeOfExp, can, E->isTypeDependent()), TOExpr(E) { 901898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor assert(!isa<TypedefType>(can) && "Invalid canonical type"); 902898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor} 903898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 9042daa5df1b53f7ef745d724771384409f6f5df5c1Chris Lattnerbool RecordType::classof(const TagType *TT) { 9052daa5df1b53f7ef745d724771384409f6f5df5c1Chris Lattner return isa<RecordDecl>(TT->getDecl()); 9065edb8bfe8472e7d7bf6a82386394ef27359eb846Chris Lattner} 9075edb8bfe8472e7d7bf6a82386394ef27359eb846Chris Lattner 90849aa7ff1245abd03e6e998e01302df31e4c6f8f6Argyrios Kyrtzidisbool CXXRecordType::classof(const TagType *TT) { 90949aa7ff1245abd03e6e998e01302df31e4c6f8f6Argyrios Kyrtzidis return isa<CXXRecordDecl>(TT->getDecl()); 91049aa7ff1245abd03e6e998e01302df31e4c6f8f6Argyrios Kyrtzidis} 91149aa7ff1245abd03e6e998e01302df31e4c6f8f6Argyrios Kyrtzidis 9122daa5df1b53f7ef745d724771384409f6f5df5c1Chris Lattnerbool EnumType::classof(const TagType *TT) { 9132daa5df1b53f7ef745d724771384409f6f5df5c1Chris Lattner return isa<EnumDecl>(TT->getDecl()); 9145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 9155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 91655f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregorvoid 91755f6b14230c94272efbbcdd89a92224c8db9f225Douglas GregorClassTemplateSpecializationType:: 91855f6b14230c94272efbbcdd89a92224c8db9f225Douglas GregorpackBooleanValues(unsigned NumArgs, bool *Values, uintptr_t *Words) { 919dedb84afce2cf2e52a6360e200c2c40822022235Douglas Gregor const unsigned BitsPerWord = sizeof(uintptr_t) * 8; 92055f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor 92155f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor for (unsigned PW = 0, NumPackedWords = getNumPackedWords(NumArgs), Arg = 0; 92255f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor PW != NumPackedWords; ++PW) { 92355f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor uintptr_t Word = 0; 92455f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor for (unsigned Bit = 0; Bit < BitsPerWord && Arg < NumArgs; ++Bit, ++Arg) { 92555f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor Word <<= 1; 92655f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor Word |= Values[Arg]; 92755f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor } 92855f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor Words[PW] = Word; 92955f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor } 93055f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor} 93155f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor 93255f6b14230c94272efbbcdd89a92224c8db9f225Douglas GregorClassTemplateSpecializationType:: 93355f6b14230c94272efbbcdd89a92224c8db9f225Douglas GregorClassTemplateSpecializationType(TemplateDecl *T, unsigned NumArgs, 93455f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor uintptr_t *Args, bool *ArgIsType, 93555f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor QualType Canon) 93655f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor : Type(ClassTemplateSpecialization, Canon, /*FIXME:Dependent=*/false), 93755f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor Template(T), NumArgs(NumArgs) 93855f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor{ 93955f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor uintptr_t *Data = reinterpret_cast<uintptr_t *>(this + 1); 94055f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor 94155f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor // Pack the argument-is-type values into the words just after the 94255f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor // class template specialization type. 94355f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor packBooleanValues(NumArgs, ArgIsType, Data); 94455f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor 94555f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor // Copy the template arguments after the packed words. 94655f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor Data += getNumPackedWords(NumArgs); 94755f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor for (unsigned Arg = 0; Arg < NumArgs; ++Arg) 94855f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor Data[Arg] = Args[Arg]; 94955f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor} 95055f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor 9515908e9f25bc9a334c99c095e0b1e6a515445be2dDouglas Gregorvoid ClassTemplateSpecializationType::Destroy(ASTContext& C) { 9525908e9f25bc9a334c99c095e0b1e6a515445be2dDouglas Gregor for (unsigned Arg = 0; Arg < NumArgs; ++Arg) 9535908e9f25bc9a334c99c095e0b1e6a515445be2dDouglas Gregor if (!isArgType(Arg)) 9545908e9f25bc9a334c99c095e0b1e6a515445be2dDouglas Gregor getArgAsExpr(Arg)->Destroy(C); 9555908e9f25bc9a334c99c095e0b1e6a515445be2dDouglas Gregor} 9565908e9f25bc9a334c99c095e0b1e6a515445be2dDouglas Gregor 95755f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregoruintptr_t 95855f6b14230c94272efbbcdd89a92224c8db9f225Douglas GregorClassTemplateSpecializationType::getArgAsOpaqueValue(unsigned Arg) const { 95955f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor const uintptr_t *Data = reinterpret_cast<const uintptr_t *>(this + 1); 96055f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor Data += getNumPackedWords(NumArgs); 96155f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor return Data[Arg]; 96255f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor} 96355f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor 96455f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregorbool ClassTemplateSpecializationType::isArgType(unsigned Arg) const { 965dedb84afce2cf2e52a6360e200c2c40822022235Douglas Gregor const unsigned BitsPerWord = sizeof(uintptr_t) * 8; 96655f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor const uintptr_t *Data = reinterpret_cast<const uintptr_t *>(this + 1); 96755f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor Data += Arg / BitsPerWord; 968c15cb38a4ff717097b32532fbf761c71b1376a02Douglas Gregor return (*Data >> ((NumArgs - Arg) % BitsPerWord - 1)) & 0x01; 96955f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor} 97097e0179f1ae545e07d9f5e7c1d2ef5c5bab06676Anders Carlsson 9715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 9725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Type Printing 9735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 9745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 9755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid QualType::dump(const char *msg) const { 97639caea961530bc95d19114ab546ebcdb229263c9Chris Lattner std::string R = "identifier"; 9775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer getAsStringInternal(R); 9785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (msg) 9795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer fprintf(stderr, "%s: %s\n", msg, R.c_str()); 9805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer else 9815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer fprintf(stderr, "%s\n", R.c_str()); 9825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 983c36d405a02fab41f6c45cb2bc750d64949742903Chris Lattnervoid QualType::dump() const { 984c36d405a02fab41f6c45cb2bc750d64949742903Chris Lattner dump(""); 985c36d405a02fab41f6c45cb2bc750d64949742903Chris Lattner} 986c36d405a02fab41f6c45cb2bc750d64949742903Chris Lattner 987c36d405a02fab41f6c45cb2bc750d64949742903Chris Lattnervoid Type::dump() const { 988c36d405a02fab41f6c45cb2bc750d64949742903Chris Lattner std::string S = "identifier"; 989c36d405a02fab41f6c45cb2bc750d64949742903Chris Lattner getAsStringInternal(S); 990c36d405a02fab41f6c45cb2bc750d64949742903Chris Lattner fprintf(stderr, "%s\n", S.c_str()); 991c36d405a02fab41f6c45cb2bc750d64949742903Chris Lattner} 992c36d405a02fab41f6c45cb2bc750d64949742903Chris Lattner 993c36d405a02fab41f6c45cb2bc750d64949742903Chris Lattner 9945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 9955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerstatic void AppendTypeQualList(std::string &S, unsigned TypeQuals) { 9965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Note: funkiness to ensure we get a space only between quals. 9975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer bool NonePrinted = true; 9985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (TypeQuals & QualType::Const) 9995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S += "const", NonePrinted = false; 10005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (TypeQuals & QualType::Volatile) 10015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S += (NonePrinted+" volatile"), NonePrinted = false; 10025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (TypeQuals & QualType::Restrict) 10035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S += (NonePrinted+" restrict"), NonePrinted = false; 10045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 10055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 10065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid QualType::getAsStringInternal(std::string &S) const { 10075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (isNull()) { 100861366e9cd41a6dbde4e66416dac21269c8ac1d94Douglas Gregor S += "NULL TYPE"; 10095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return; 10105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 10115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 10125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Print qualifiers as appropriate. 10133513e138cc75205b48d3078dfa4669355adb5714Gabor Greif if (unsigned Tq = getCVRQualifiers()) { 10145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer std::string TQS; 10153513e138cc75205b48d3078dfa4669355adb5714Gabor Greif AppendTypeQualList(TQS, Tq); 10165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!S.empty()) 10175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S = TQS + ' ' + S; 10185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer else 10195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S = TQS; 10205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 10215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 10225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer getTypePtr()->getAsStringInternal(S); 10235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 10245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 10255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid BuiltinType::getAsStringInternal(std::string &S) const { 10265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (S.empty()) { 10275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S = getName(); 10285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } else { 10295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Prefix the basic type, e.g. 'int X'. 10305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S = ' ' + S; 10315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S = getName() + S; 10325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 10335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 10345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1035f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedmanvoid FixedWidthIntType::getAsStringInternal(std::string &S) const { 1036f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman // FIXME: Once we get bitwidth attribute, write as 1037f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman // "int __attribute__((bitwidth(x)))". 1038f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman std::string prefix = "__clang_fixedwidth"; 1039f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman prefix += llvm::utostr_32(Width); 1040f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman prefix += (char)(Signed ? 'S' : 'U'); 1041f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman if (S.empty()) { 1042f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman S = prefix; 1043f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman } else { 1044f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman // Prefix the basic type, e.g. 'int X'. 1045f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman S = prefix + S; 1046f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman } 1047f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman} 1048f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman 1049f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman 10505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid ComplexType::getAsStringInternal(std::string &S) const { 10515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ElementType->getAsStringInternal(S); 10525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S = "_Complex " + S; 10535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 10545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1055f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanianvoid ExtQualType::getAsStringInternal(std::string &S) const { 105659d16d1402d76a298ab7fc5f362e9d3dfd744aa5Fariborz Jahanian bool space = false; 105759d16d1402d76a298ab7fc5f362e9d3dfd744aa5Fariborz Jahanian if (ExtQualTypeKind & ASQUAL) { 105859d16d1402d76a298ab7fc5f362e9d3dfd744aa5Fariborz Jahanian S = "__attribute__((address_space("+llvm::utostr_32(AddressSpace)+")))" + S; 105959d16d1402d76a298ab7fc5f362e9d3dfd744aa5Fariborz Jahanian space = true; 106059d16d1402d76a298ab7fc5f362e9d3dfd744aa5Fariborz Jahanian } 106159d16d1402d76a298ab7fc5f362e9d3dfd744aa5Fariborz Jahanian if (ExtQualTypeKind & GCQUAL) { 106259d16d1402d76a298ab7fc5f362e9d3dfd744aa5Fariborz Jahanian if (space) 106359d16d1402d76a298ab7fc5f362e9d3dfd744aa5Fariborz Jahanian S += ' '; 106459d16d1402d76a298ab7fc5f362e9d3dfd744aa5Fariborz Jahanian S += "__attribute__((objc_gc("; 106559d16d1402d76a298ab7fc5f362e9d3dfd744aa5Fariborz Jahanian ObjCGCAttr *gcattr = getGCAttr(); 106659d16d1402d76a298ab7fc5f362e9d3dfd744aa5Fariborz Jahanian ObjCGCAttr::GCAttrTypes attr = gcattr->getType(); 106759d16d1402d76a298ab7fc5f362e9d3dfd744aa5Fariborz Jahanian if (attr & ObjCGCAttr::Weak) 106859d16d1402d76a298ab7fc5f362e9d3dfd744aa5Fariborz Jahanian S += "weak"; 106959d16d1402d76a298ab7fc5f362e9d3dfd744aa5Fariborz Jahanian else 107059d16d1402d76a298ab7fc5f362e9d3dfd744aa5Fariborz Jahanian S += "strong"; 107159d16d1402d76a298ab7fc5f362e9d3dfd744aa5Fariborz Jahanian S += ")))"; 107259d16d1402d76a298ab7fc5f362e9d3dfd744aa5Fariborz Jahanian } 1073ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb BaseType->getAsStringInternal(S); 1074ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb} 1075ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb 10765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid PointerType::getAsStringInternal(std::string &S) const { 10775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S = '*' + S; 10785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 10795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Handle things like 'int (*A)[4];' correctly. 10805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // FIXME: this should include vectors, but vectors use attributes I guess. 1081bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner if (isa<ArrayType>(getPointeeType())) 10825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S = '(' + S + ')'; 10835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1084bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner getPointeeType().getAsStringInternal(S); 10855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 10865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 10875618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroffvoid BlockPointerType::getAsStringInternal(std::string &S) const { 10885618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff S = '^' + S; 10895618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff PointeeType.getAsStringInternal(S); 10905618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff} 10915618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff 10925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid ReferenceType::getAsStringInternal(std::string &S) const { 10935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S = '&' + S; 10945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 10955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Handle things like 'int (&A)[4];' correctly. 10965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // FIXME: this should include vectors, but vectors use attributes I guess. 1097bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner if (isa<ArrayType>(getPointeeType())) 10985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S = '(' + S + ')'; 10995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1100bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner getPointeeType().getAsStringInternal(S); 11015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 11025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1103f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redlvoid MemberPointerType::getAsStringInternal(std::string &S) const { 1104f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl std::string C; 1105f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl Class->getAsStringInternal(C); 1106f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl C += "::*"; 1107f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl S = C + S; 1108f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 1109f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // Handle things like 'int (&A)[4];' correctly. 1110f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // FIXME: this should include vectors, but vectors use attributes I guess. 1111f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl if (isa<ArrayType>(getPointeeType())) 1112f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl S = '(' + S + ')'; 1113f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 1114f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl getPointeeType().getAsStringInternal(S); 1115f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl} 1116f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 1117fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroffvoid ConstantArrayType::getAsStringInternal(std::string &S) const { 1118fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff S += '['; 11196b91cd9af12fe1340e48e03e9b988d9888b4889fSteve Naroff S += llvm::utostr(getSize().getZExtValue()); 1120fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff S += ']'; 1121fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff 1122fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff getElementType().getAsStringInternal(S); 1123fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff} 1124fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff 1125c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedmanvoid IncompleteArrayType::getAsStringInternal(std::string &S) const { 1126c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman S += "[]"; 1127c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1128c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman getElementType().getAsStringInternal(S); 1129c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman} 1130c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1131fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroffvoid VariableArrayType::getAsStringInternal(std::string &S) const { 11325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S += '['; 11335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1134c9406125e2cac9208098655ac8058c095c2c3a65Steve Naroff if (getIndexTypeQualifier()) { 1135c9406125e2cac9208098655ac8058c095c2c3a65Steve Naroff AppendTypeQualList(S, getIndexTypeQualifier()); 11365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S += ' '; 11375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 11385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1139c9406125e2cac9208098655ac8058c095c2c3a65Steve Naroff if (getSizeModifier() == Static) 11405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S += "static"; 1141c9406125e2cac9208098655ac8058c095c2c3a65Steve Naroff else if (getSizeModifier() == Star) 11425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S += '*'; 11435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1144fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff if (getSizeExpr()) { 1145a95d3750441ac8ad03e36af8e6e74039c9a3109dTed Kremenek std::string SStr; 1146a95d3750441ac8ad03e36af8e6e74039c9a3109dTed Kremenek llvm::raw_string_ostream s(SStr); 1147fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff getSizeExpr()->printPretty(s); 1148fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff S += s.str(); 1149fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff } 11505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S += ']'; 11515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1152fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff getElementType().getAsStringInternal(S); 11535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 11545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1155898574e7496ba8fd76290079d3a9d06954992734Douglas Gregorvoid DependentSizedArrayType::getAsStringInternal(std::string &S) const { 1156898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor S += '['; 1157898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 1158898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor if (getIndexTypeQualifier()) { 1159898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor AppendTypeQualList(S, getIndexTypeQualifier()); 1160898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor S += ' '; 1161898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor } 1162898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 1163898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor if (getSizeModifier() == Static) 1164898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor S += "static"; 1165898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor else if (getSizeModifier() == Star) 1166898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor S += '*'; 1167898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 1168898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor if (getSizeExpr()) { 1169898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor std::string SStr; 1170898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor llvm::raw_string_ostream s(SStr); 1171898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor getSizeExpr()->printPretty(s); 1172898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor S += s.str(); 1173898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor } 1174898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor S += ']'; 1175898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 1176898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor getElementType().getAsStringInternal(S); 1177898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor} 1178898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 11795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid VectorType::getAsStringInternal(std::string &S) const { 11805620b50f8f81854b2a6fea16c69ff1853f8f4d9bDaniel Dunbar // FIXME: We prefer to print the size directly here, but have no way 11815620b50f8f81854b2a6fea16c69ff1853f8f4d9bDaniel Dunbar // to get the size of the type. 11827ee261c8e71f363d86461f4d1a37e3def354c976Chris Lattner S += " __attribute__((__vector_size__("; 11835620b50f8f81854b2a6fea16c69ff1853f8f4d9bDaniel Dunbar S += llvm::utostr_32(NumElements); // convert back to bytes. 11845620b50f8f81854b2a6fea16c69ff1853f8f4d9bDaniel Dunbar S += " * sizeof(" + ElementType.getAsString() + "))))"; 11855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 11865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1187213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begemanvoid ExtVectorType::getAsStringInternal(std::string &S) const { 1188213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman S += " __attribute__((ext_vector_type("; 118931a458462c6cf417a84e0c47852b18fb22d79acbSteve Naroff S += llvm::utostr_32(NumElements); 119031a458462c6cf417a84e0c47852b18fb22d79acbSteve Naroff S += ")))"; 119131a458462c6cf417a84e0c47852b18fb22d79acbSteve Naroff ElementType.getAsStringInternal(S); 119231a458462c6cf417a84e0c47852b18fb22d79acbSteve Naroff} 119331a458462c6cf417a84e0c47852b18fb22d79acbSteve Naroff 1194d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroffvoid TypeOfExpr::getAsStringInternal(std::string &InnerString) const { 1195363bcff47df2fda3cfcfcd994b7888157df58c43Steve Naroff if (!InnerString.empty()) // Prefix the basic type, e.g. 'typeof(e) X'. 1196363bcff47df2fda3cfcfcd994b7888157df58c43Steve Naroff InnerString = ' ' + InnerString; 1197a95d3750441ac8ad03e36af8e6e74039c9a3109dTed Kremenek std::string Str; 1198a95d3750441ac8ad03e36af8e6e74039c9a3109dTed Kremenek llvm::raw_string_ostream s(Str); 11996000dace22f110d8768476989313e9d981d690d0Chris Lattner getUnderlyingExpr()->printPretty(s); 12001bfd5cc29035e4bfccca855160109b07c5e85416Steve Naroff InnerString = "typeof(" + s.str() + ")" + InnerString; 1201d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff} 1202d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff 1203363bcff47df2fda3cfcfcd994b7888157df58c43Steve Naroffvoid TypeOfType::getAsStringInternal(std::string &InnerString) const { 1204363bcff47df2fda3cfcfcd994b7888157df58c43Steve Naroff if (!InnerString.empty()) // Prefix the basic type, e.g. 'typeof(t) X'. 1205363bcff47df2fda3cfcfcd994b7888157df58c43Steve Naroff InnerString = ' ' + InnerString; 1206d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff std::string Tmp; 1207d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff getUnderlyingType().getAsStringInternal(Tmp); 1208363bcff47df2fda3cfcfcd994b7888157df58c43Steve Naroff InnerString = "typeof(" + Tmp + ")" + InnerString; 1209d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff} 1210d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff 12115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid FunctionTypeNoProto::getAsStringInternal(std::string &S) const { 12125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If needed for precedence reasons, wrap the inner part in grouping parens. 12135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!S.empty()) 12145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S = "(" + S + ")"; 12155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 12165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S += "()"; 12175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer getResultType().getAsStringInternal(S); 12185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 12195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 12205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid FunctionTypeProto::getAsStringInternal(std::string &S) const { 12215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If needed for precedence reasons, wrap the inner part in grouping parens. 12225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!S.empty()) 12235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S = "(" + S + ")"; 12245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 12255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S += "("; 12265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer std::string Tmp; 12275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0, e = getNumArgs(); i != e; ++i) { 12285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (i) S += ", "; 12295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer getArgType(i).getAsStringInternal(Tmp); 12305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S += Tmp; 12315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Tmp.clear(); 12325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 12335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 12345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (isVariadic()) { 12355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (getNumArgs()) 12365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S += ", "; 12375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S += "..."; 12385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } else if (getNumArgs() == 0) { 12395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Do not emit int() if we have a proto, emit 'int(void)'. 12405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S += "void"; 12415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 12425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 12435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer S += ")"; 12445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer getResultType().getAsStringInternal(S); 12455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 12465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 12475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 12485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid TypedefType::getAsStringInternal(std::string &InnerString) const { 12495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'. 12505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InnerString = ' ' + InnerString; 12515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InnerString = getDecl()->getIdentifier()->getName() + InnerString; 12525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 12535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 125472c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregorvoid TemplateTypeParmType::getAsStringInternal(std::string &InnerString) const { 125572c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor if (!InnerString.empty()) // Prefix the basic type, e.g. 'parmname X'. 125672c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor InnerString = ' ' + InnerString; 1257fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor 1258fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor if (!Name) 1259fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor InnerString = "type-parameter-" + llvm::utostr_32(Depth) + '-' + 1260fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor llvm::utostr_32(Index) + InnerString; 1261fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor else 1262fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor InnerString = Name->getName() + InnerString; 126372c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor} 126472c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor 126555f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregorvoid 126655f6b14230c94272efbbcdd89a92224c8db9f225Douglas GregorClassTemplateSpecializationType:: 126755f6b14230c94272efbbcdd89a92224c8db9f225Douglas GregorgetAsStringInternal(std::string &InnerString) const { 126855f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor std::string SpecString = Template->getNameAsString(); 126955f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor SpecString += '<'; 127055f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor for (unsigned Arg = 0; Arg < NumArgs; ++Arg) { 127155f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor if (Arg) 127255f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor SpecString += ", "; 127355f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor 127455f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor // Print the argument into a string. 127555f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor std::string ArgString; 127655f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor if (isArgType(Arg)) 127755f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor getArgAsType(Arg).getAsStringInternal(ArgString); 127855f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor else { 127955f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor llvm::raw_string_ostream s(ArgString); 128055f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor getArgAsExpr(Arg)->printPretty(s); 128155f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor } 128255f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor 128355f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor // If this is the first argument and its string representation 128455f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor // begins with the global scope specifier ('::foo'), add a space 128555f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor // to avoid printing the diagraph '<:'. 128655f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor if (!Arg && !ArgString.empty() && ArgString[0] == ':') 128755f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor SpecString += ' '; 128855f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor 128955f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor SpecString += ArgString; 129055f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor } 129155f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor 129255f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor // If the last character of our string is '>', add another space to 129355f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor // keep the two '>''s separate tokens. We don't *have* to do this in 129455f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor // C++0x, but it's still good hygiene. 129555f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor if (SpecString[SpecString.size() - 1] == '>') 129655f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor SpecString += ' '; 129755f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor 129855f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor SpecString += '>'; 129955f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor 130055f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor if (InnerString.empty()) 130155f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor InnerString.swap(SpecString); 130255f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor else 130355f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor InnerString = SpecString + ' ' + InnerString; 130455f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor} 130555f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor 1306a526c5c67e5a0473c340903ee542ce570119665fTed Kremenekvoid ObjCInterfaceType::getAsStringInternal(std::string &InnerString) const { 13073536b443bc50d58a79f14fca9b6842541a434854Steve Naroff if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'. 13083536b443bc50d58a79f14fca9b6842541a434854Steve Naroff InnerString = ' ' + InnerString; 13093536b443bc50d58a79f14fca9b6842541a434854Steve Naroff InnerString = getDecl()->getIdentifier()->getName() + InnerString; 13103536b443bc50d58a79f14fca9b6842541a434854Steve Naroff} 13113536b443bc50d58a79f14fca9b6842541a434854Steve Naroff 1312a526c5c67e5a0473c340903ee542ce570119665fTed Kremenekvoid ObjCQualifiedInterfaceType::getAsStringInternal( 13134b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian std::string &InnerString) const { 1314dfbcce2b55ca8b45ce9d9c09c32e43c3bd73ac2aFariborz Jahanian if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'. 1315dfbcce2b55ca8b45ce9d9c09c32e43c3bd73ac2aFariborz Jahanian InnerString = ' ' + InnerString; 131639f34e97d6a468f0a7dfa5664c61217cffc65b74Chris Lattner std::string ObjCQIString = getDecl()->getNameAsString(); 1317a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek ObjCQIString += '<'; 1318cdce6d17be572ae49417022357906ce04b54137dChris Lattner bool isFirst = true; 1319cdce6d17be572ae49417022357906ce04b54137dChris Lattner for (qual_iterator I = qual_begin(), E = qual_end(); I != E; ++I) { 1320cdce6d17be572ae49417022357906ce04b54137dChris Lattner if (isFirst) 1321cdce6d17be572ae49417022357906ce04b54137dChris Lattner isFirst = false; 1322cdce6d17be572ae49417022357906ce04b54137dChris Lattner else 1323a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek ObjCQIString += ','; 132439f34e97d6a468f0a7dfa5664c61217cffc65b74Chris Lattner ObjCQIString += (*I)->getNameAsString(); 13254b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian } 1326a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek ObjCQIString += '>'; 1327a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek InnerString = ObjCQIString + InnerString; 13284b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian} 13294b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian 1330e8e4f928e51091c1f9c7f5b4595941e33dc0bfecChris Lattnervoid ObjCQualifiedIdType::getAsStringInternal(std::string &InnerString) const { 1331c569249ca0ab755ac79d8cbbfcb2bcae19743624Fariborz Jahanian if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'. 1332c569249ca0ab755ac79d8cbbfcb2bcae19743624Fariborz Jahanian InnerString = ' ' + InnerString; 1333a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek std::string ObjCQIString = "id"; 1334a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek ObjCQIString += '<'; 1335c569249ca0ab755ac79d8cbbfcb2bcae19743624Fariborz Jahanian int num = getNumProtocols(); 1336c569249ca0ab755ac79d8cbbfcb2bcae19743624Fariborz Jahanian for (int i = 0; i < num; i++) { 133739f34e97d6a468f0a7dfa5664c61217cffc65b74Chris Lattner ObjCQIString += getProtocols(i)->getNameAsString(); 1338c569249ca0ab755ac79d8cbbfcb2bcae19743624Fariborz Jahanian if (i < num-1) 1339a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek ObjCQIString += ','; 1340c569249ca0ab755ac79d8cbbfcb2bcae19743624Fariborz Jahanian } 1341a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek ObjCQIString += '>'; 1342a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek InnerString = ObjCQIString + InnerString; 1343c569249ca0ab755ac79d8cbbfcb2bcae19743624Fariborz Jahanian} 1344c569249ca0ab755ac79d8cbbfcb2bcae19743624Fariborz Jahanian 13455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid TagType::getAsStringInternal(std::string &InnerString) const { 13465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'. 13475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InnerString = ' ' + InnerString; 13485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 13495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const char *Kind = getDecl()->getKindName(); 13505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const char *ID; 13515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (const IdentifierInfo *II = getDecl()->getIdentifier()) 13525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ID = II->getName(); 13535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer else 13545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ID = "<anonymous>"; 13555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 13565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InnerString = std::string(Kind) + " " + ID + InnerString; 13575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1358