ASTContext.cpp revision 7b9a2ee5a4393001bdec7dec841eb7c811da492c
1//===--- ASTContext.cpp - Context to hold long-lived AST nodes ------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the ASTContext interface. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/AST/ASTContext.h" 15#include "clang/AST/DeclCXX.h" 16#include "clang/AST/DeclObjC.h" 17#include "clang/AST/DeclTemplate.h" 18#include "clang/AST/Expr.h" 19#include "clang/AST/ExternalASTSource.h" 20#include "clang/AST/RecordLayout.h" 21#include "clang/Basic/SourceManager.h" 22#include "clang/Basic/TargetInfo.h" 23#include "llvm/ADT/StringExtras.h" 24#include "llvm/Support/MathExtras.h" 25#include "llvm/Support/MemoryBuffer.h" 26using namespace clang; 27 28enum FloatingRank { 29 FloatRank, DoubleRank, LongDoubleRank 30}; 31 32ASTContext::ASTContext(const LangOptions& LOpts, SourceManager &SM, 33 TargetInfo &t, 34 IdentifierTable &idents, SelectorTable &sels, 35 bool FreeMem, unsigned size_reserve, 36 bool InitializeBuiltins) : 37 GlobalNestedNameSpecifier(0), CFConstantStringTypeDecl(0), 38 ObjCFastEnumerationStateTypeDecl(0), SourceMgr(SM), LangOpts(LOpts), 39 FreeMemory(FreeMem), Target(t), Idents(idents), Selectors(sels), 40 ExternalSource(0) { 41 if (size_reserve > 0) Types.reserve(size_reserve); 42 InitBuiltinTypes(); 43 TUDecl = TranslationUnitDecl::Create(*this); 44 BuiltinInfo.InitializeTargetBuiltins(Target); 45 if (InitializeBuiltins) 46 this->InitializeBuiltins(idents); 47} 48 49ASTContext::~ASTContext() { 50 // Deallocate all the types. 51 while (!Types.empty()) { 52 Types.back()->Destroy(*this); 53 Types.pop_back(); 54 } 55 56 { 57 llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator 58 I = ASTRecordLayouts.begin(), E = ASTRecordLayouts.end(); 59 while (I != E) { 60 ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second); 61 delete R; 62 } 63 } 64 65 { 66 llvm::DenseMap<const ObjCInterfaceDecl*, const ASTRecordLayout*>::iterator 67 I = ASTObjCInterfaces.begin(), E = ASTObjCInterfaces.end(); 68 while (I != E) { 69 ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second); 70 delete R; 71 } 72 } 73 74 { 75 llvm::DenseMap<const ObjCInterfaceDecl*, RecordDecl*>::iterator 76 I = ASTRecordForInterface.begin(), E = ASTRecordForInterface.end(); 77 while (I != E) { 78 RecordDecl *R = (I++)->second; 79 R->Destroy(*this); 80 } 81 } 82 83 // Destroy nested-name-specifiers. 84 for (llvm::FoldingSet<NestedNameSpecifier>::iterator 85 NNS = NestedNameSpecifiers.begin(), 86 NNSEnd = NestedNameSpecifiers.end(); 87 NNS != NNSEnd; 88 /* Increment in loop */) 89 (*NNS++).Destroy(*this); 90 91 if (GlobalNestedNameSpecifier) 92 GlobalNestedNameSpecifier->Destroy(*this); 93 94 TUDecl->Destroy(*this); 95} 96 97void ASTContext::InitializeBuiltins(IdentifierTable &idents) { 98 BuiltinInfo.InitializeBuiltins(idents, LangOpts.NoBuiltin); 99} 100 101void 102ASTContext::setExternalSource(llvm::OwningPtr<ExternalASTSource> &Source) { 103 ExternalSource.reset(Source.take()); 104} 105 106void ASTContext::PrintStats() const { 107 fprintf(stderr, "*** AST Context Stats:\n"); 108 fprintf(stderr, " %d types total.\n", (int)Types.size()); 109 unsigned NumBuiltin = 0, NumPointer = 0, NumArray = 0, NumFunctionP = 0; 110 unsigned NumVector = 0, NumComplex = 0, NumBlockPointer = 0; 111 unsigned NumFunctionNP = 0, NumTypeName = 0, NumTagged = 0; 112 unsigned NumLValueReference = 0, NumRValueReference = 0, NumMemberPointer = 0; 113 114 unsigned NumTagStruct = 0, NumTagUnion = 0, NumTagEnum = 0, NumTagClass = 0; 115 unsigned NumObjCInterfaces = 0, NumObjCQualifiedInterfaces = 0; 116 unsigned NumObjCQualifiedIds = 0; 117 unsigned NumTypeOfTypes = 0, NumTypeOfExprTypes = 0; 118 unsigned NumExtQual = 0; 119 120 for (unsigned i = 0, e = Types.size(); i != e; ++i) { 121 Type *T = Types[i]; 122 if (isa<BuiltinType>(T)) 123 ++NumBuiltin; 124 else if (isa<PointerType>(T)) 125 ++NumPointer; 126 else if (isa<BlockPointerType>(T)) 127 ++NumBlockPointer; 128 else if (isa<LValueReferenceType>(T)) 129 ++NumLValueReference; 130 else if (isa<RValueReferenceType>(T)) 131 ++NumRValueReference; 132 else if (isa<MemberPointerType>(T)) 133 ++NumMemberPointer; 134 else if (isa<ComplexType>(T)) 135 ++NumComplex; 136 else if (isa<ArrayType>(T)) 137 ++NumArray; 138 else if (isa<VectorType>(T)) 139 ++NumVector; 140 else if (isa<FunctionNoProtoType>(T)) 141 ++NumFunctionNP; 142 else if (isa<FunctionProtoType>(T)) 143 ++NumFunctionP; 144 else if (isa<TypedefType>(T)) 145 ++NumTypeName; 146 else if (TagType *TT = dyn_cast<TagType>(T)) { 147 ++NumTagged; 148 switch (TT->getDecl()->getTagKind()) { 149 default: assert(0 && "Unknown tagged type!"); 150 case TagDecl::TK_struct: ++NumTagStruct; break; 151 case TagDecl::TK_union: ++NumTagUnion; break; 152 case TagDecl::TK_class: ++NumTagClass; break; 153 case TagDecl::TK_enum: ++NumTagEnum; break; 154 } 155 } else if (isa<ObjCInterfaceType>(T)) 156 ++NumObjCInterfaces; 157 else if (isa<ObjCQualifiedInterfaceType>(T)) 158 ++NumObjCQualifiedInterfaces; 159 else if (isa<ObjCQualifiedIdType>(T)) 160 ++NumObjCQualifiedIds; 161 else if (isa<TypeOfType>(T)) 162 ++NumTypeOfTypes; 163 else if (isa<TypeOfExprType>(T)) 164 ++NumTypeOfExprTypes; 165 else if (isa<ExtQualType>(T)) 166 ++NumExtQual; 167 else { 168 QualType(T, 0).dump(); 169 assert(0 && "Unknown type!"); 170 } 171 } 172 173 fprintf(stderr, " %d builtin types\n", NumBuiltin); 174 fprintf(stderr, " %d pointer types\n", NumPointer); 175 fprintf(stderr, " %d block pointer types\n", NumBlockPointer); 176 fprintf(stderr, " %d lvalue reference types\n", NumLValueReference); 177 fprintf(stderr, " %d rvalue reference types\n", NumRValueReference); 178 fprintf(stderr, " %d member pointer types\n", NumMemberPointer); 179 fprintf(stderr, " %d complex types\n", NumComplex); 180 fprintf(stderr, " %d array types\n", NumArray); 181 fprintf(stderr, " %d vector types\n", NumVector); 182 fprintf(stderr, " %d function types with proto\n", NumFunctionP); 183 fprintf(stderr, " %d function types with no proto\n", NumFunctionNP); 184 fprintf(stderr, " %d typename (typedef) types\n", NumTypeName); 185 fprintf(stderr, " %d tagged types\n", NumTagged); 186 fprintf(stderr, " %d struct types\n", NumTagStruct); 187 fprintf(stderr, " %d union types\n", NumTagUnion); 188 fprintf(stderr, " %d class types\n", NumTagClass); 189 fprintf(stderr, " %d enum types\n", NumTagEnum); 190 fprintf(stderr, " %d interface types\n", NumObjCInterfaces); 191 fprintf(stderr, " %d protocol qualified interface types\n", 192 NumObjCQualifiedInterfaces); 193 fprintf(stderr, " %d protocol qualified id types\n", 194 NumObjCQualifiedIds); 195 fprintf(stderr, " %d typeof types\n", NumTypeOfTypes); 196 fprintf(stderr, " %d typeof exprs\n", NumTypeOfExprTypes); 197 fprintf(stderr, " %d attribute-qualified types\n", NumExtQual); 198 199 fprintf(stderr, "Total bytes = %d\n", int(NumBuiltin*sizeof(BuiltinType)+ 200 NumPointer*sizeof(PointerType)+NumArray*sizeof(ArrayType)+ 201 NumComplex*sizeof(ComplexType)+NumVector*sizeof(VectorType)+ 202 NumLValueReference*sizeof(LValueReferenceType)+ 203 NumRValueReference*sizeof(RValueReferenceType)+ 204 NumMemberPointer*sizeof(MemberPointerType)+ 205 NumFunctionP*sizeof(FunctionProtoType)+ 206 NumFunctionNP*sizeof(FunctionNoProtoType)+ 207 NumTypeName*sizeof(TypedefType)+NumTagged*sizeof(TagType)+ 208 NumTypeOfTypes*sizeof(TypeOfType)+NumTypeOfExprTypes*sizeof(TypeOfExprType)+ 209 NumExtQual*sizeof(ExtQualType))); 210 211 if (ExternalSource.get()) { 212 fprintf(stderr, "\n"); 213 ExternalSource->PrintStats(); 214 } 215} 216 217 218void ASTContext::InitBuiltinType(QualType &R, BuiltinType::Kind K) { 219 Types.push_back((R = QualType(new (*this,8) BuiltinType(K),0)).getTypePtr()); 220} 221 222void ASTContext::InitBuiltinTypes() { 223 assert(VoidTy.isNull() && "Context reinitialized?"); 224 225 // C99 6.2.5p19. 226 InitBuiltinType(VoidTy, BuiltinType::Void); 227 228 // C99 6.2.5p2. 229 InitBuiltinType(BoolTy, BuiltinType::Bool); 230 // C99 6.2.5p3. 231 if (Target.isCharSigned()) 232 InitBuiltinType(CharTy, BuiltinType::Char_S); 233 else 234 InitBuiltinType(CharTy, BuiltinType::Char_U); 235 // C99 6.2.5p4. 236 InitBuiltinType(SignedCharTy, BuiltinType::SChar); 237 InitBuiltinType(ShortTy, BuiltinType::Short); 238 InitBuiltinType(IntTy, BuiltinType::Int); 239 InitBuiltinType(LongTy, BuiltinType::Long); 240 InitBuiltinType(LongLongTy, BuiltinType::LongLong); 241 242 // C99 6.2.5p6. 243 InitBuiltinType(UnsignedCharTy, BuiltinType::UChar); 244 InitBuiltinType(UnsignedShortTy, BuiltinType::UShort); 245 InitBuiltinType(UnsignedIntTy, BuiltinType::UInt); 246 InitBuiltinType(UnsignedLongTy, BuiltinType::ULong); 247 InitBuiltinType(UnsignedLongLongTy, BuiltinType::ULongLong); 248 249 // C99 6.2.5p10. 250 InitBuiltinType(FloatTy, BuiltinType::Float); 251 InitBuiltinType(DoubleTy, BuiltinType::Double); 252 InitBuiltinType(LongDoubleTy, BuiltinType::LongDouble); 253 254 // GNU extension, 128-bit integers. 255 InitBuiltinType(Int128Ty, BuiltinType::Int128); 256 InitBuiltinType(UnsignedInt128Ty, BuiltinType::UInt128); 257 258 if (LangOpts.CPlusPlus) // C++ 3.9.1p5 259 InitBuiltinType(WCharTy, BuiltinType::WChar); 260 else // C99 261 WCharTy = getFromTargetType(Target.getWCharType()); 262 263 // Placeholder type for functions. 264 InitBuiltinType(OverloadTy, BuiltinType::Overload); 265 266 // Placeholder type for type-dependent expressions whose type is 267 // completely unknown. No code should ever check a type against 268 // DependentTy and users should never see it; however, it is here to 269 // help diagnose failures to properly check for type-dependent 270 // expressions. 271 InitBuiltinType(DependentTy, BuiltinType::Dependent); 272 273 // C99 6.2.5p11. 274 FloatComplexTy = getComplexType(FloatTy); 275 DoubleComplexTy = getComplexType(DoubleTy); 276 LongDoubleComplexTy = getComplexType(LongDoubleTy); 277 278 BuiltinVaListType = QualType(); 279 ObjCIdType = QualType(); 280 IdStructType = 0; 281 ObjCClassType = QualType(); 282 ClassStructType = 0; 283 284 ObjCConstantStringType = QualType(); 285 286 // void * type 287 VoidPtrTy = getPointerType(VoidTy); 288} 289 290//===----------------------------------------------------------------------===// 291// Type Sizing and Analysis 292//===----------------------------------------------------------------------===// 293 294/// getFloatTypeSemantics - Return the APFloat 'semantics' for the specified 295/// scalar floating point type. 296const llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const { 297 const BuiltinType *BT = T->getAsBuiltinType(); 298 assert(BT && "Not a floating point type!"); 299 switch (BT->getKind()) { 300 default: assert(0 && "Not a floating point type!"); 301 case BuiltinType::Float: return Target.getFloatFormat(); 302 case BuiltinType::Double: return Target.getDoubleFormat(); 303 case BuiltinType::LongDouble: return Target.getLongDoubleFormat(); 304 } 305} 306 307/// getDeclAlign - Return a conservative estimate of the alignment of the 308/// specified decl. Note that bitfields do not have a valid alignment, so 309/// this method will assert on them. 310unsigned ASTContext::getDeclAlignInBytes(const Decl *D) { 311 unsigned Align = Target.getCharWidth(); 312 313 if (const AlignedAttr* AA = D->getAttr<AlignedAttr>()) 314 Align = std::max(Align, AA->getAlignment()); 315 316 if (const ValueDecl *VD = dyn_cast<ValueDecl>(D)) { 317 QualType T = VD->getType(); 318 if (const ReferenceType* RT = T->getAsReferenceType()) { 319 unsigned AS = RT->getPointeeType().getAddressSpace(); 320 Align = Target.getPointerAlign(AS); 321 } else if (!T->isIncompleteType() && !T->isFunctionType()) { 322 // Incomplete or function types default to 1. 323 while (isa<VariableArrayType>(T) || isa<IncompleteArrayType>(T)) 324 T = cast<ArrayType>(T)->getElementType(); 325 326 Align = std::max(Align, getPreferredTypeAlign(T.getTypePtr())); 327 } 328 } 329 330 return Align / Target.getCharWidth(); 331} 332 333/// getTypeSize - Return the size of the specified type, in bits. This method 334/// does not work on incomplete types. 335std::pair<uint64_t, unsigned> 336ASTContext::getTypeInfo(const Type *T) { 337 uint64_t Width=0; 338 unsigned Align=8; 339 switch (T->getTypeClass()) { 340#define TYPE(Class, Base) 341#define ABSTRACT_TYPE(Class, Base) 342#define NON_CANONICAL_TYPE(Class, Base) 343#define DEPENDENT_TYPE(Class, Base) case Type::Class: 344#include "clang/AST/TypeNodes.def" 345 assert(false && "Should not see dependent types"); 346 break; 347 348 case Type::FunctionNoProto: 349 case Type::FunctionProto: 350 // GCC extension: alignof(function) = 32 bits 351 Width = 0; 352 Align = 32; 353 break; 354 355 case Type::IncompleteArray: 356 case Type::VariableArray: 357 Width = 0; 358 Align = getTypeAlign(cast<ArrayType>(T)->getElementType()); 359 break; 360 361 case Type::ConstantArray: { 362 const ConstantArrayType *CAT = cast<ConstantArrayType>(T); 363 364 std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(CAT->getElementType()); 365 Width = EltInfo.first*CAT->getSize().getZExtValue(); 366 Align = EltInfo.second; 367 break; 368 } 369 case Type::ExtVector: 370 case Type::Vector: { 371 std::pair<uint64_t, unsigned> EltInfo = 372 getTypeInfo(cast<VectorType>(T)->getElementType()); 373 Width = EltInfo.first*cast<VectorType>(T)->getNumElements(); 374 Align = Width; 375 // If the alignment is not a power of 2, round up to the next power of 2. 376 // This happens for non-power-of-2 length vectors. 377 // FIXME: this should probably be a target property. 378 Align = 1 << llvm::Log2_32_Ceil(Align); 379 break; 380 } 381 382 case Type::Builtin: 383 switch (cast<BuiltinType>(T)->getKind()) { 384 default: assert(0 && "Unknown builtin type!"); 385 case BuiltinType::Void: 386 // GCC extension: alignof(void) = 8 bits. 387 Width = 0; 388 Align = 8; 389 break; 390 391 case BuiltinType::Bool: 392 Width = Target.getBoolWidth(); 393 Align = Target.getBoolAlign(); 394 break; 395 case BuiltinType::Char_S: 396 case BuiltinType::Char_U: 397 case BuiltinType::UChar: 398 case BuiltinType::SChar: 399 Width = Target.getCharWidth(); 400 Align = Target.getCharAlign(); 401 break; 402 case BuiltinType::WChar: 403 Width = Target.getWCharWidth(); 404 Align = Target.getWCharAlign(); 405 break; 406 case BuiltinType::UShort: 407 case BuiltinType::Short: 408 Width = Target.getShortWidth(); 409 Align = Target.getShortAlign(); 410 break; 411 case BuiltinType::UInt: 412 case BuiltinType::Int: 413 Width = Target.getIntWidth(); 414 Align = Target.getIntAlign(); 415 break; 416 case BuiltinType::ULong: 417 case BuiltinType::Long: 418 Width = Target.getLongWidth(); 419 Align = Target.getLongAlign(); 420 break; 421 case BuiltinType::ULongLong: 422 case BuiltinType::LongLong: 423 Width = Target.getLongLongWidth(); 424 Align = Target.getLongLongAlign(); 425 break; 426 case BuiltinType::Int128: 427 case BuiltinType::UInt128: 428 Width = 128; 429 Align = 128; // int128_t is 128-bit aligned on all targets. 430 break; 431 case BuiltinType::Float: 432 Width = Target.getFloatWidth(); 433 Align = Target.getFloatAlign(); 434 break; 435 case BuiltinType::Double: 436 Width = Target.getDoubleWidth(); 437 Align = Target.getDoubleAlign(); 438 break; 439 case BuiltinType::LongDouble: 440 Width = Target.getLongDoubleWidth(); 441 Align = Target.getLongDoubleAlign(); 442 break; 443 } 444 break; 445 case Type::FixedWidthInt: 446 // FIXME: This isn't precisely correct; the width/alignment should depend 447 // on the available types for the target 448 Width = cast<FixedWidthIntType>(T)->getWidth(); 449 Width = std::max(llvm::NextPowerOf2(Width - 1), (uint64_t)8); 450 Align = Width; 451 break; 452 case Type::ExtQual: 453 // FIXME: Pointers into different addr spaces could have different sizes and 454 // alignment requirements: getPointerInfo should take an AddrSpace. 455 return getTypeInfo(QualType(cast<ExtQualType>(T)->getBaseType(), 0)); 456 case Type::ObjCQualifiedId: 457 case Type::ObjCQualifiedInterface: 458 Width = Target.getPointerWidth(0); 459 Align = Target.getPointerAlign(0); 460 break; 461 case Type::BlockPointer: { 462 unsigned AS = cast<BlockPointerType>(T)->getPointeeType().getAddressSpace(); 463 Width = Target.getPointerWidth(AS); 464 Align = Target.getPointerAlign(AS); 465 break; 466 } 467 case Type::Pointer: { 468 unsigned AS = cast<PointerType>(T)->getPointeeType().getAddressSpace(); 469 Width = Target.getPointerWidth(AS); 470 Align = Target.getPointerAlign(AS); 471 break; 472 } 473 case Type::LValueReference: 474 case Type::RValueReference: 475 // "When applied to a reference or a reference type, the result is the size 476 // of the referenced type." C++98 5.3.3p2: expr.sizeof. 477 // FIXME: This is wrong for struct layout: a reference in a struct has 478 // pointer size. 479 return getTypeInfo(cast<ReferenceType>(T)->getPointeeType()); 480 case Type::MemberPointer: { 481 // FIXME: This is not only platform- but also ABI-dependent. We follow 482 // the GCC ABI, where pointers to data are one pointer large, pointers to 483 // functions two pointers. But if we want to support ABI compatibility with 484 // other compilers too, we need to delegate this completely to TargetInfo 485 // or some ABI abstraction layer. 486 QualType Pointee = cast<MemberPointerType>(T)->getPointeeType(); 487 unsigned AS = Pointee.getAddressSpace(); 488 Width = Target.getPointerWidth(AS); 489 if (Pointee->isFunctionType()) 490 Width *= 2; 491 Align = Target.getPointerAlign(AS); 492 // GCC aligns at single pointer width. 493 } 494 case Type::Complex: { 495 // Complex types have the same alignment as their elements, but twice the 496 // size. 497 std::pair<uint64_t, unsigned> EltInfo = 498 getTypeInfo(cast<ComplexType>(T)->getElementType()); 499 Width = EltInfo.first*2; 500 Align = EltInfo.second; 501 break; 502 } 503 case Type::ObjCInterface: { 504 const ObjCInterfaceType *ObjCI = cast<ObjCInterfaceType>(T); 505 const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl()); 506 Width = Layout.getSize(); 507 Align = Layout.getAlignment(); 508 break; 509 } 510 case Type::Record: 511 case Type::Enum: { 512 const TagType *TT = cast<TagType>(T); 513 514 if (TT->getDecl()->isInvalidDecl()) { 515 Width = 1; 516 Align = 1; 517 break; 518 } 519 520 if (const EnumType *ET = dyn_cast<EnumType>(TT)) 521 return getTypeInfo(ET->getDecl()->getIntegerType()); 522 523 const RecordType *RT = cast<RecordType>(TT); 524 const ASTRecordLayout &Layout = getASTRecordLayout(RT->getDecl()); 525 Width = Layout.getSize(); 526 Align = Layout.getAlignment(); 527 break; 528 } 529 530 case Type::Typedef: { 531 const TypedefDecl *Typedef = cast<TypedefType>(T)->getDecl(); 532 if (const AlignedAttr *Aligned = Typedef->getAttr<AlignedAttr>()) { 533 Align = Aligned->getAlignment(); 534 Width = getTypeSize(Typedef->getUnderlyingType().getTypePtr()); 535 } else 536 return getTypeInfo(Typedef->getUnderlyingType().getTypePtr()); 537 break; 538 } 539 540 case Type::TypeOfExpr: 541 return getTypeInfo(cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType() 542 .getTypePtr()); 543 544 case Type::TypeOf: 545 return getTypeInfo(cast<TypeOfType>(T)->getUnderlyingType().getTypePtr()); 546 547 case Type::QualifiedName: 548 return getTypeInfo(cast<QualifiedNameType>(T)->getNamedType().getTypePtr()); 549 550 case Type::TemplateSpecialization: 551 assert(getCanonicalType(T) != T && 552 "Cannot request the size of a dependent type"); 553 // FIXME: this is likely to be wrong once we support template 554 // aliases, since a template alias could refer to a typedef that 555 // has an __aligned__ attribute on it. 556 return getTypeInfo(getCanonicalType(T)); 557 } 558 559 assert(Align && (Align & (Align-1)) == 0 && "Alignment must be power of 2"); 560 return std::make_pair(Width, Align); 561} 562 563/// getPreferredTypeAlign - Return the "preferred" alignment of the specified 564/// type for the current target in bits. This can be different than the ABI 565/// alignment in cases where it is beneficial for performance to overalign 566/// a data type. 567unsigned ASTContext::getPreferredTypeAlign(const Type *T) { 568 unsigned ABIAlign = getTypeAlign(T); 569 570 // Doubles should be naturally aligned if possible. 571 if (T->isSpecificBuiltinType(BuiltinType::Double)) 572 return std::max(ABIAlign, 64U); 573 574 return ABIAlign; 575} 576 577 578/// LayoutField - Field layout. 579void ASTRecordLayout::LayoutField(const FieldDecl *FD, unsigned FieldNo, 580 bool IsUnion, unsigned StructPacking, 581 ASTContext &Context) { 582 unsigned FieldPacking = StructPacking; 583 uint64_t FieldOffset = IsUnion ? 0 : Size; 584 uint64_t FieldSize; 585 unsigned FieldAlign; 586 587 // FIXME: Should this override struct packing? Probably we want to 588 // take the minimum? 589 if (const PackedAttr *PA = FD->getAttr<PackedAttr>()) 590 FieldPacking = PA->getAlignment(); 591 592 if (const Expr *BitWidthExpr = FD->getBitWidth()) { 593 // TODO: Need to check this algorithm on other targets! 594 // (tested on Linux-X86) 595 FieldSize = BitWidthExpr->EvaluateAsInt(Context).getZExtValue(); 596 597 std::pair<uint64_t, unsigned> FieldInfo = 598 Context.getTypeInfo(FD->getType()); 599 uint64_t TypeSize = FieldInfo.first; 600 601 // Determine the alignment of this bitfield. The packing 602 // attributes define a maximum and the alignment attribute defines 603 // a minimum. 604 // FIXME: What is the right behavior when the specified alignment 605 // is smaller than the specified packing? 606 FieldAlign = FieldInfo.second; 607 if (FieldPacking) 608 FieldAlign = std::min(FieldAlign, FieldPacking); 609 if (const AlignedAttr *AA = FD->getAttr<AlignedAttr>()) 610 FieldAlign = std::max(FieldAlign, AA->getAlignment()); 611 612 // Check if we need to add padding to give the field the correct 613 // alignment. 614 if (FieldSize == 0 || (FieldOffset & (FieldAlign-1)) + FieldSize > TypeSize) 615 FieldOffset = (FieldOffset + (FieldAlign-1)) & ~(FieldAlign-1); 616 617 // Padding members don't affect overall alignment 618 if (!FD->getIdentifier()) 619 FieldAlign = 1; 620 } else { 621 if (FD->getType()->isIncompleteArrayType()) { 622 // This is a flexible array member; we can't directly 623 // query getTypeInfo about these, so we figure it out here. 624 // Flexible array members don't have any size, but they 625 // have to be aligned appropriately for their element type. 626 FieldSize = 0; 627 const ArrayType* ATy = Context.getAsArrayType(FD->getType()); 628 FieldAlign = Context.getTypeAlign(ATy->getElementType()); 629 } else if (const ReferenceType *RT = FD->getType()->getAsReferenceType()) { 630 unsigned AS = RT->getPointeeType().getAddressSpace(); 631 FieldSize = Context.Target.getPointerWidth(AS); 632 FieldAlign = Context.Target.getPointerAlign(AS); 633 } else { 634 std::pair<uint64_t, unsigned> FieldInfo = 635 Context.getTypeInfo(FD->getType()); 636 FieldSize = FieldInfo.first; 637 FieldAlign = FieldInfo.second; 638 } 639 640 // Determine the alignment of this bitfield. The packing 641 // attributes define a maximum and the alignment attribute defines 642 // a minimum. Additionally, the packing alignment must be at least 643 // a byte for non-bitfields. 644 // 645 // FIXME: What is the right behavior when the specified alignment 646 // is smaller than the specified packing? 647 if (FieldPacking) 648 FieldAlign = std::min(FieldAlign, std::max(8U, FieldPacking)); 649 if (const AlignedAttr *AA = FD->getAttr<AlignedAttr>()) 650 FieldAlign = std::max(FieldAlign, AA->getAlignment()); 651 652 // Round up the current record size to the field's alignment boundary. 653 FieldOffset = (FieldOffset + (FieldAlign-1)) & ~(FieldAlign-1); 654 } 655 656 // Place this field at the current location. 657 FieldOffsets[FieldNo] = FieldOffset; 658 659 // Reserve space for this field. 660 if (IsUnion) { 661 Size = std::max(Size, FieldSize); 662 } else { 663 Size = FieldOffset + FieldSize; 664 } 665 666 // Remember max struct/class alignment. 667 Alignment = std::max(Alignment, FieldAlign); 668} 669 670static void CollectLocalObjCIvars(ASTContext *Ctx, 671 const ObjCInterfaceDecl *OI, 672 llvm::SmallVectorImpl<FieldDecl*> &Fields) { 673 for (ObjCInterfaceDecl::ivar_iterator I = OI->ivar_begin(), 674 E = OI->ivar_end(); I != E; ++I) { 675 ObjCIvarDecl *IVDecl = *I; 676 if (!IVDecl->isInvalidDecl()) 677 Fields.push_back(cast<FieldDecl>(IVDecl)); 678 } 679 // look into properties. 680 for (ObjCInterfaceDecl::prop_iterator I = OI->prop_begin(*Ctx), 681 E = OI->prop_end(*Ctx); I != E; ++I) { 682 if (ObjCIvarDecl *IV = (*I)->getPropertyIvarDecl()) 683 Fields.push_back(cast<FieldDecl>(IV)); 684 } 685} 686 687void ASTContext::CollectObjCIvars(const ObjCInterfaceDecl *OI, 688 llvm::SmallVectorImpl<FieldDecl*> &Fields) { 689 if (const ObjCInterfaceDecl *SuperClass = OI->getSuperClass()) 690 CollectObjCIvars(SuperClass, Fields); 691 CollectLocalObjCIvars(this, OI, Fields); 692} 693 694/// addRecordToClass - produces record info. for the class for its 695/// ivars and all those inherited. 696/// 697const RecordDecl *ASTContext::addRecordToClass(const ObjCInterfaceDecl *D) { 698 assert(!D->isForwardDecl() && "Invalid decl!"); 699 700 RecordDecl *&RD = ASTRecordForInterface[D]; 701 if (RD) 702 return RD; 703 704 llvm::SmallVector<FieldDecl*, 32> RecFields; 705 CollectLocalObjCIvars(this, D, RecFields); 706 707 RD = RecordDecl::Create(*this, TagDecl::TK_struct, 0, D->getLocation(), 708 D->getIdentifier()); 709 const RecordDecl *SRD; 710 if (const ObjCInterfaceDecl *SuperClass = D->getSuperClass()) { 711 SRD = addRecordToClass(SuperClass); 712 } else { 713 SRD = RecordDecl::Create(*this, TagDecl::TK_struct, 0, SourceLocation(), 0); 714 const_cast<RecordDecl*>(SRD)->completeDefinition(*this); 715 } 716 717 RD->addDecl(*this, 718 FieldDecl::Create(*this, RD, 719 SourceLocation(), 720 0, 721 getTagDeclType(const_cast<RecordDecl*>(SRD)), 722 0, false)); 723 724 /// FIXME! Can do collection of ivars and adding to the record while 725 /// doing it. 726 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) { 727 RD->addDecl(*this, 728 FieldDecl::Create(*this, RD, 729 RecFields[i]->getLocation(), 730 RecFields[i]->getIdentifier(), 731 RecFields[i]->getType(), 732 RecFields[i]->getBitWidth(), false)); 733 } 734 735 RD->completeDefinition(*this); 736 return RD; 737} 738 739/// getASTObjcInterfaceLayout - Get or compute information about the layout of 740/// the specified Objective C, which indicates its size and ivar 741/// position information. 742const ASTRecordLayout & 743ASTContext::getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) { 744 // Look up this layout, if already laid out, return what we have. 745 const ASTRecordLayout *&Entry = ASTObjCInterfaces[D]; 746 if (Entry) return *Entry; 747 748 // Allocate and assign into ASTRecordLayouts here. The "Entry" reference can 749 // be invalidated (dangle) if the ASTRecordLayouts hashtable is inserted into. 750 ASTRecordLayout *NewEntry = NULL; 751 // FIXME. Add actual count of synthesized ivars, instead of count 752 // of properties which is the upper bound, but is safe. 753 unsigned FieldCount = 754 D->ivar_size() + std::distance(D->prop_begin(*this), D->prop_end(*this)); 755 if (ObjCInterfaceDecl *SD = D->getSuperClass()) { 756 FieldCount++; 757 const ASTRecordLayout &SL = getASTObjCInterfaceLayout(SD); 758 unsigned Alignment = SL.getAlignment(); 759 uint64_t Size = SL.getSize(); 760 NewEntry = new ASTRecordLayout(Size, Alignment); 761 NewEntry->InitializeLayout(FieldCount); 762 // Super class is at the beginning of the layout. 763 NewEntry->SetFieldOffset(0, 0); 764 } else { 765 NewEntry = new ASTRecordLayout(); 766 NewEntry->InitializeLayout(FieldCount); 767 } 768 Entry = NewEntry; 769 770 unsigned StructPacking = 0; 771 if (const PackedAttr *PA = D->getAttr<PackedAttr>()) 772 StructPacking = PA->getAlignment(); 773 774 if (const AlignedAttr *AA = D->getAttr<AlignedAttr>()) 775 NewEntry->SetAlignment(std::max(NewEntry->getAlignment(), 776 AA->getAlignment())); 777 778 // Layout each ivar sequentially. 779 unsigned i = 0; 780 for (ObjCInterfaceDecl::ivar_iterator IVI = D->ivar_begin(), 781 IVE = D->ivar_end(); IVI != IVE; ++IVI) { 782 const ObjCIvarDecl* Ivar = (*IVI); 783 NewEntry->LayoutField(Ivar, i++, false, StructPacking, *this); 784 } 785 // Also synthesized ivars 786 for (ObjCInterfaceDecl::prop_iterator I = D->prop_begin(*this), 787 E = D->prop_end(*this); I != E; ++I) { 788 if (ObjCIvarDecl *Ivar = (*I)->getPropertyIvarDecl()) 789 NewEntry->LayoutField(Ivar, i++, false, StructPacking, *this); 790 } 791 792 // Finally, round the size of the total struct up to the alignment of the 793 // struct itself. 794 NewEntry->FinalizeLayout(); 795 return *NewEntry; 796} 797 798/// getASTRecordLayout - Get or compute information about the layout of the 799/// specified record (struct/union/class), which indicates its size and field 800/// position information. 801const ASTRecordLayout &ASTContext::getASTRecordLayout(const RecordDecl *D) { 802 D = D->getDefinition(*this); 803 assert(D && "Cannot get layout of forward declarations!"); 804 805 // Look up this layout, if already laid out, return what we have. 806 const ASTRecordLayout *&Entry = ASTRecordLayouts[D]; 807 if (Entry) return *Entry; 808 809 // Allocate and assign into ASTRecordLayouts here. The "Entry" reference can 810 // be invalidated (dangle) if the ASTRecordLayouts hashtable is inserted into. 811 ASTRecordLayout *NewEntry = new ASTRecordLayout(); 812 Entry = NewEntry; 813 814 // FIXME: Avoid linear walk through the fields, if possible. 815 NewEntry->InitializeLayout(std::distance(D->field_begin(*this), 816 D->field_end(*this))); 817 bool IsUnion = D->isUnion(); 818 819 unsigned StructPacking = 0; 820 if (const PackedAttr *PA = D->getAttr<PackedAttr>()) 821 StructPacking = PA->getAlignment(); 822 823 if (const AlignedAttr *AA = D->getAttr<AlignedAttr>()) 824 NewEntry->SetAlignment(std::max(NewEntry->getAlignment(), 825 AA->getAlignment())); 826 827 // Layout each field, for now, just sequentially, respecting alignment. In 828 // the future, this will need to be tweakable by targets. 829 unsigned FieldIdx = 0; 830 for (RecordDecl::field_iterator Field = D->field_begin(*this), 831 FieldEnd = D->field_end(*this); 832 Field != FieldEnd; (void)++Field, ++FieldIdx) 833 NewEntry->LayoutField(*Field, FieldIdx, IsUnion, StructPacking, *this); 834 835 // Finally, round the size of the total struct up to the alignment of the 836 // struct itself. 837 NewEntry->FinalizeLayout(); 838 return *NewEntry; 839} 840 841//===----------------------------------------------------------------------===// 842// Type creation/memoization methods 843//===----------------------------------------------------------------------===// 844 845QualType ASTContext::getAddrSpaceQualType(QualType T, unsigned AddressSpace) { 846 QualType CanT = getCanonicalType(T); 847 if (CanT.getAddressSpace() == AddressSpace) 848 return T; 849 850 // If we are composing extended qualifiers together, merge together into one 851 // ExtQualType node. 852 unsigned CVRQuals = T.getCVRQualifiers(); 853 QualType::GCAttrTypes GCAttr = QualType::GCNone; 854 Type *TypeNode = T.getTypePtr(); 855 856 if (ExtQualType *EQT = dyn_cast<ExtQualType>(TypeNode)) { 857 // If this type already has an address space specified, it cannot get 858 // another one. 859 assert(EQT->getAddressSpace() == 0 && 860 "Type cannot be in multiple addr spaces!"); 861 GCAttr = EQT->getObjCGCAttr(); 862 TypeNode = EQT->getBaseType(); 863 } 864 865 // Check if we've already instantiated this type. 866 llvm::FoldingSetNodeID ID; 867 ExtQualType::Profile(ID, TypeNode, AddressSpace, GCAttr); 868 void *InsertPos = 0; 869 if (ExtQualType *EXTQy = ExtQualTypes.FindNodeOrInsertPos(ID, InsertPos)) 870 return QualType(EXTQy, CVRQuals); 871 872 // If the base type isn't canonical, this won't be a canonical type either, 873 // so fill in the canonical type field. 874 QualType Canonical; 875 if (!TypeNode->isCanonical()) { 876 Canonical = getAddrSpaceQualType(CanT, AddressSpace); 877 878 // Update InsertPos, the previous call could have invalidated it. 879 ExtQualType *NewIP = ExtQualTypes.FindNodeOrInsertPos(ID, InsertPos); 880 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 881 } 882 ExtQualType *New = 883 new (*this, 8) ExtQualType(TypeNode, Canonical, AddressSpace, GCAttr); 884 ExtQualTypes.InsertNode(New, InsertPos); 885 Types.push_back(New); 886 return QualType(New, CVRQuals); 887} 888 889QualType ASTContext::getObjCGCQualType(QualType T, 890 QualType::GCAttrTypes GCAttr) { 891 QualType CanT = getCanonicalType(T); 892 if (CanT.getObjCGCAttr() == GCAttr) 893 return T; 894 895 // If we are composing extended qualifiers together, merge together into one 896 // ExtQualType node. 897 unsigned CVRQuals = T.getCVRQualifiers(); 898 Type *TypeNode = T.getTypePtr(); 899 unsigned AddressSpace = 0; 900 901 if (ExtQualType *EQT = dyn_cast<ExtQualType>(TypeNode)) { 902 // If this type already has an address space specified, it cannot get 903 // another one. 904 assert(EQT->getObjCGCAttr() == QualType::GCNone && 905 "Type cannot be in multiple addr spaces!"); 906 AddressSpace = EQT->getAddressSpace(); 907 TypeNode = EQT->getBaseType(); 908 } 909 910 // Check if we've already instantiated an gc qual'd type of this type. 911 llvm::FoldingSetNodeID ID; 912 ExtQualType::Profile(ID, TypeNode, AddressSpace, GCAttr); 913 void *InsertPos = 0; 914 if (ExtQualType *EXTQy = ExtQualTypes.FindNodeOrInsertPos(ID, InsertPos)) 915 return QualType(EXTQy, CVRQuals); 916 917 // If the base type isn't canonical, this won't be a canonical type either, 918 // so fill in the canonical type field. 919 // FIXME: Isn't this also not canonical if the base type is a array 920 // or pointer type? I can't find any documentation for objc_gc, though... 921 QualType Canonical; 922 if (!T->isCanonical()) { 923 Canonical = getObjCGCQualType(CanT, GCAttr); 924 925 // Update InsertPos, the previous call could have invalidated it. 926 ExtQualType *NewIP = ExtQualTypes.FindNodeOrInsertPos(ID, InsertPos); 927 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 928 } 929 ExtQualType *New = 930 new (*this, 8) ExtQualType(TypeNode, Canonical, AddressSpace, GCAttr); 931 ExtQualTypes.InsertNode(New, InsertPos); 932 Types.push_back(New); 933 return QualType(New, CVRQuals); 934} 935 936/// getComplexType - Return the uniqued reference to the type for a complex 937/// number with the specified element type. 938QualType ASTContext::getComplexType(QualType T) { 939 // Unique pointers, to guarantee there is only one pointer of a particular 940 // structure. 941 llvm::FoldingSetNodeID ID; 942 ComplexType::Profile(ID, T); 943 944 void *InsertPos = 0; 945 if (ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos)) 946 return QualType(CT, 0); 947 948 // If the pointee type isn't canonical, this won't be a canonical type either, 949 // so fill in the canonical type field. 950 QualType Canonical; 951 if (!T->isCanonical()) { 952 Canonical = getComplexType(getCanonicalType(T)); 953 954 // Get the new insert position for the node we care about. 955 ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos); 956 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 957 } 958 ComplexType *New = new (*this,8) ComplexType(T, Canonical); 959 Types.push_back(New); 960 ComplexTypes.InsertNode(New, InsertPos); 961 return QualType(New, 0); 962} 963 964QualType ASTContext::getFixedWidthIntType(unsigned Width, bool Signed) { 965 llvm::DenseMap<unsigned, FixedWidthIntType*> &Map = Signed ? 966 SignedFixedWidthIntTypes : UnsignedFixedWidthIntTypes; 967 FixedWidthIntType *&Entry = Map[Width]; 968 if (!Entry) 969 Entry = new FixedWidthIntType(Width, Signed); 970 return QualType(Entry, 0); 971} 972 973/// getPointerType - Return the uniqued reference to the type for a pointer to 974/// the specified type. 975QualType ASTContext::getPointerType(QualType T) { 976 // Unique pointers, to guarantee there is only one pointer of a particular 977 // structure. 978 llvm::FoldingSetNodeID ID; 979 PointerType::Profile(ID, T); 980 981 void *InsertPos = 0; 982 if (PointerType *PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 983 return QualType(PT, 0); 984 985 // If the pointee type isn't canonical, this won't be a canonical type either, 986 // so fill in the canonical type field. 987 QualType Canonical; 988 if (!T->isCanonical()) { 989 Canonical = getPointerType(getCanonicalType(T)); 990 991 // Get the new insert position for the node we care about. 992 PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos); 993 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 994 } 995 PointerType *New = new (*this,8) PointerType(T, Canonical); 996 Types.push_back(New); 997 PointerTypes.InsertNode(New, InsertPos); 998 return QualType(New, 0); 999} 1000 1001/// getBlockPointerType - Return the uniqued reference to the type for 1002/// a pointer to the specified block. 1003QualType ASTContext::getBlockPointerType(QualType T) { 1004 assert(T->isFunctionType() && "block of function types only"); 1005 // Unique pointers, to guarantee there is only one block of a particular 1006 // structure. 1007 llvm::FoldingSetNodeID ID; 1008 BlockPointerType::Profile(ID, T); 1009 1010 void *InsertPos = 0; 1011 if (BlockPointerType *PT = 1012 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 1013 return QualType(PT, 0); 1014 1015 // If the block pointee type isn't canonical, this won't be a canonical 1016 // type either so fill in the canonical type field. 1017 QualType Canonical; 1018 if (!T->isCanonical()) { 1019 Canonical = getBlockPointerType(getCanonicalType(T)); 1020 1021 // Get the new insert position for the node we care about. 1022 BlockPointerType *NewIP = 1023 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 1024 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 1025 } 1026 BlockPointerType *New = new (*this,8) BlockPointerType(T, Canonical); 1027 Types.push_back(New); 1028 BlockPointerTypes.InsertNode(New, InsertPos); 1029 return QualType(New, 0); 1030} 1031 1032/// getLValueReferenceType - Return the uniqued reference to the type for an 1033/// lvalue reference to the specified type. 1034QualType ASTContext::getLValueReferenceType(QualType T) { 1035 // Unique pointers, to guarantee there is only one pointer of a particular 1036 // structure. 1037 llvm::FoldingSetNodeID ID; 1038 ReferenceType::Profile(ID, T); 1039 1040 void *InsertPos = 0; 1041 if (LValueReferenceType *RT = 1042 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos)) 1043 return QualType(RT, 0); 1044 1045 // If the referencee type isn't canonical, this won't be a canonical type 1046 // either, so fill in the canonical type field. 1047 QualType Canonical; 1048 if (!T->isCanonical()) { 1049 Canonical = getLValueReferenceType(getCanonicalType(T)); 1050 1051 // Get the new insert position for the node we care about. 1052 LValueReferenceType *NewIP = 1053 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos); 1054 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 1055 } 1056 1057 LValueReferenceType *New = new (*this,8) LValueReferenceType(T, Canonical); 1058 Types.push_back(New); 1059 LValueReferenceTypes.InsertNode(New, InsertPos); 1060 return QualType(New, 0); 1061} 1062 1063/// getRValueReferenceType - Return the uniqued reference to the type for an 1064/// rvalue reference to the specified type. 1065QualType ASTContext::getRValueReferenceType(QualType T) { 1066 // Unique pointers, to guarantee there is only one pointer of a particular 1067 // structure. 1068 llvm::FoldingSetNodeID ID; 1069 ReferenceType::Profile(ID, T); 1070 1071 void *InsertPos = 0; 1072 if (RValueReferenceType *RT = 1073 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos)) 1074 return QualType(RT, 0); 1075 1076 // If the referencee type isn't canonical, this won't be a canonical type 1077 // either, so fill in the canonical type field. 1078 QualType Canonical; 1079 if (!T->isCanonical()) { 1080 Canonical = getRValueReferenceType(getCanonicalType(T)); 1081 1082 // Get the new insert position for the node we care about. 1083 RValueReferenceType *NewIP = 1084 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos); 1085 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 1086 } 1087 1088 RValueReferenceType *New = new (*this,8) RValueReferenceType(T, Canonical); 1089 Types.push_back(New); 1090 RValueReferenceTypes.InsertNode(New, InsertPos); 1091 return QualType(New, 0); 1092} 1093 1094/// getMemberPointerType - Return the uniqued reference to the type for a 1095/// member pointer to the specified type, in the specified class. 1096QualType ASTContext::getMemberPointerType(QualType T, const Type *Cls) 1097{ 1098 // Unique pointers, to guarantee there is only one pointer of a particular 1099 // structure. 1100 llvm::FoldingSetNodeID ID; 1101 MemberPointerType::Profile(ID, T, Cls); 1102 1103 void *InsertPos = 0; 1104 if (MemberPointerType *PT = 1105 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 1106 return QualType(PT, 0); 1107 1108 // If the pointee or class type isn't canonical, this won't be a canonical 1109 // type either, so fill in the canonical type field. 1110 QualType Canonical; 1111 if (!T->isCanonical()) { 1112 Canonical = getMemberPointerType(getCanonicalType(T),getCanonicalType(Cls)); 1113 1114 // Get the new insert position for the node we care about. 1115 MemberPointerType *NewIP = 1116 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 1117 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 1118 } 1119 MemberPointerType *New = new (*this,8) MemberPointerType(T, Cls, Canonical); 1120 Types.push_back(New); 1121 MemberPointerTypes.InsertNode(New, InsertPos); 1122 return QualType(New, 0); 1123} 1124 1125/// getConstantArrayType - Return the unique reference to the type for an 1126/// array of the specified element type. 1127QualType ASTContext::getConstantArrayType(QualType EltTy, 1128 const llvm::APInt &ArySize, 1129 ArrayType::ArraySizeModifier ASM, 1130 unsigned EltTypeQuals) { 1131 llvm::FoldingSetNodeID ID; 1132 ConstantArrayType::Profile(ID, EltTy, ArySize, ASM, EltTypeQuals); 1133 1134 void *InsertPos = 0; 1135 if (ConstantArrayType *ATP = 1136 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos)) 1137 return QualType(ATP, 0); 1138 1139 // If the element type isn't canonical, this won't be a canonical type either, 1140 // so fill in the canonical type field. 1141 QualType Canonical; 1142 if (!EltTy->isCanonical()) { 1143 Canonical = getConstantArrayType(getCanonicalType(EltTy), ArySize, 1144 ASM, EltTypeQuals); 1145 // Get the new insert position for the node we care about. 1146 ConstantArrayType *NewIP = 1147 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos); 1148 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 1149 } 1150 1151 ConstantArrayType *New = 1152 new(*this,8)ConstantArrayType(EltTy, Canonical, ArySize, ASM, EltTypeQuals); 1153 ConstantArrayTypes.InsertNode(New, InsertPos); 1154 Types.push_back(New); 1155 return QualType(New, 0); 1156} 1157 1158/// getVariableArrayType - Returns a non-unique reference to the type for a 1159/// variable array of the specified element type. 1160QualType ASTContext::getVariableArrayType(QualType EltTy, Expr *NumElts, 1161 ArrayType::ArraySizeModifier ASM, 1162 unsigned EltTypeQuals) { 1163 // Since we don't unique expressions, it isn't possible to unique VLA's 1164 // that have an expression provided for their size. 1165 1166 VariableArrayType *New = 1167 new(*this,8)VariableArrayType(EltTy,QualType(), NumElts, ASM, EltTypeQuals); 1168 1169 VariableArrayTypes.push_back(New); 1170 Types.push_back(New); 1171 return QualType(New, 0); 1172} 1173 1174/// getDependentSizedArrayType - Returns a non-unique reference to 1175/// the type for a dependently-sized array of the specified element 1176/// type. FIXME: We will need these to be uniqued, or at least 1177/// comparable, at some point. 1178QualType ASTContext::getDependentSizedArrayType(QualType EltTy, Expr *NumElts, 1179 ArrayType::ArraySizeModifier ASM, 1180 unsigned EltTypeQuals) { 1181 assert((NumElts->isTypeDependent() || NumElts->isValueDependent()) && 1182 "Size must be type- or value-dependent!"); 1183 1184 // Since we don't unique expressions, it isn't possible to unique 1185 // dependently-sized array types. 1186 1187 DependentSizedArrayType *New = 1188 new (*this,8) DependentSizedArrayType(EltTy, QualType(), NumElts, 1189 ASM, EltTypeQuals); 1190 1191 DependentSizedArrayTypes.push_back(New); 1192 Types.push_back(New); 1193 return QualType(New, 0); 1194} 1195 1196QualType ASTContext::getIncompleteArrayType(QualType EltTy, 1197 ArrayType::ArraySizeModifier ASM, 1198 unsigned EltTypeQuals) { 1199 llvm::FoldingSetNodeID ID; 1200 IncompleteArrayType::Profile(ID, EltTy, ASM, EltTypeQuals); 1201 1202 void *InsertPos = 0; 1203 if (IncompleteArrayType *ATP = 1204 IncompleteArrayTypes.FindNodeOrInsertPos(ID, InsertPos)) 1205 return QualType(ATP, 0); 1206 1207 // If the element type isn't canonical, this won't be a canonical type 1208 // either, so fill in the canonical type field. 1209 QualType Canonical; 1210 1211 if (!EltTy->isCanonical()) { 1212 Canonical = getIncompleteArrayType(getCanonicalType(EltTy), 1213 ASM, EltTypeQuals); 1214 1215 // Get the new insert position for the node we care about. 1216 IncompleteArrayType *NewIP = 1217 IncompleteArrayTypes.FindNodeOrInsertPos(ID, InsertPos); 1218 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 1219 } 1220 1221 IncompleteArrayType *New = new (*this,8) IncompleteArrayType(EltTy, Canonical, 1222 ASM, EltTypeQuals); 1223 1224 IncompleteArrayTypes.InsertNode(New, InsertPos); 1225 Types.push_back(New); 1226 return QualType(New, 0); 1227} 1228 1229/// getVectorType - Return the unique reference to a vector type of 1230/// the specified element type and size. VectorType must be a built-in type. 1231QualType ASTContext::getVectorType(QualType vecType, unsigned NumElts) { 1232 BuiltinType *baseType; 1233 1234 baseType = dyn_cast<BuiltinType>(getCanonicalType(vecType).getTypePtr()); 1235 assert(baseType != 0 && "getVectorType(): Expecting a built-in type"); 1236 1237 // Check if we've already instantiated a vector of this type. 1238 llvm::FoldingSetNodeID ID; 1239 VectorType::Profile(ID, vecType, NumElts, Type::Vector); 1240 void *InsertPos = 0; 1241 if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos)) 1242 return QualType(VTP, 0); 1243 1244 // If the element type isn't canonical, this won't be a canonical type either, 1245 // so fill in the canonical type field. 1246 QualType Canonical; 1247 if (!vecType->isCanonical()) { 1248 Canonical = getVectorType(getCanonicalType(vecType), NumElts); 1249 1250 // Get the new insert position for the node we care about. 1251 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos); 1252 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 1253 } 1254 VectorType *New = new (*this,8) VectorType(vecType, NumElts, Canonical); 1255 VectorTypes.InsertNode(New, InsertPos); 1256 Types.push_back(New); 1257 return QualType(New, 0); 1258} 1259 1260/// getExtVectorType - Return the unique reference to an extended vector type of 1261/// the specified element type and size. VectorType must be a built-in type. 1262QualType ASTContext::getExtVectorType(QualType vecType, unsigned NumElts) { 1263 BuiltinType *baseType; 1264 1265 baseType = dyn_cast<BuiltinType>(getCanonicalType(vecType).getTypePtr()); 1266 assert(baseType != 0 && "getExtVectorType(): Expecting a built-in type"); 1267 1268 // Check if we've already instantiated a vector of this type. 1269 llvm::FoldingSetNodeID ID; 1270 VectorType::Profile(ID, vecType, NumElts, Type::ExtVector); 1271 void *InsertPos = 0; 1272 if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos)) 1273 return QualType(VTP, 0); 1274 1275 // If the element type isn't canonical, this won't be a canonical type either, 1276 // so fill in the canonical type field. 1277 QualType Canonical; 1278 if (!vecType->isCanonical()) { 1279 Canonical = getExtVectorType(getCanonicalType(vecType), NumElts); 1280 1281 // Get the new insert position for the node we care about. 1282 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos); 1283 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 1284 } 1285 ExtVectorType *New = new (*this,8) ExtVectorType(vecType, NumElts, Canonical); 1286 VectorTypes.InsertNode(New, InsertPos); 1287 Types.push_back(New); 1288 return QualType(New, 0); 1289} 1290 1291/// getFunctionNoProtoType - Return a K&R style C function type like 'int()'. 1292/// 1293QualType ASTContext::getFunctionNoProtoType(QualType ResultTy) { 1294 // Unique functions, to guarantee there is only one function of a particular 1295 // structure. 1296 llvm::FoldingSetNodeID ID; 1297 FunctionNoProtoType::Profile(ID, ResultTy); 1298 1299 void *InsertPos = 0; 1300 if (FunctionNoProtoType *FT = 1301 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) 1302 return QualType(FT, 0); 1303 1304 QualType Canonical; 1305 if (!ResultTy->isCanonical()) { 1306 Canonical = getFunctionNoProtoType(getCanonicalType(ResultTy)); 1307 1308 // Get the new insert position for the node we care about. 1309 FunctionNoProtoType *NewIP = 1310 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos); 1311 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 1312 } 1313 1314 FunctionNoProtoType *New =new(*this,8)FunctionNoProtoType(ResultTy,Canonical); 1315 Types.push_back(New); 1316 FunctionNoProtoTypes.InsertNode(New, InsertPos); 1317 return QualType(New, 0); 1318} 1319 1320/// getFunctionType - Return a normal function type with a typed argument 1321/// list. isVariadic indicates whether the argument list includes '...'. 1322QualType ASTContext::getFunctionType(QualType ResultTy,const QualType *ArgArray, 1323 unsigned NumArgs, bool isVariadic, 1324 unsigned TypeQuals, bool hasExceptionSpec, 1325 bool hasAnyExceptionSpec, unsigned NumExs, 1326 const QualType *ExArray) { 1327 // Unique functions, to guarantee there is only one function of a particular 1328 // structure. 1329 llvm::FoldingSetNodeID ID; 1330 FunctionProtoType::Profile(ID, ResultTy, ArgArray, NumArgs, isVariadic, 1331 TypeQuals, hasExceptionSpec, hasAnyExceptionSpec, 1332 NumExs, ExArray); 1333 1334 void *InsertPos = 0; 1335 if (FunctionProtoType *FTP = 1336 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) 1337 return QualType(FTP, 0); 1338 1339 // Determine whether the type being created is already canonical or not. 1340 bool isCanonical = ResultTy->isCanonical(); 1341 for (unsigned i = 0; i != NumArgs && isCanonical; ++i) 1342 if (!ArgArray[i]->isCanonical()) 1343 isCanonical = false; 1344 1345 // If this type isn't canonical, get the canonical version of it. 1346 QualType Canonical; 1347 if (!isCanonical) { 1348 llvm::SmallVector<QualType, 16> CanonicalArgs; 1349 CanonicalArgs.reserve(NumArgs); 1350 for (unsigned i = 0; i != NumArgs; ++i) 1351 CanonicalArgs.push_back(getCanonicalType(ArgArray[i])); 1352 llvm::SmallVector<QualType, 2> CanonicalExs; 1353 CanonicalExs.reserve(NumExs); 1354 for (unsigned i = 0; i != NumExs; ++i) 1355 CanonicalExs.push_back(getCanonicalType(ExArray[i])); 1356 1357 Canonical = getFunctionType(getCanonicalType(ResultTy), 1358 &CanonicalArgs[0], NumArgs, 1359 isVariadic, TypeQuals, hasExceptionSpec, 1360 hasAnyExceptionSpec, NumExs, &CanonicalExs[0]); 1361 1362 // Get the new insert position for the node we care about. 1363 FunctionProtoType *NewIP = 1364 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos); 1365 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 1366 } 1367 1368 // FunctionProtoType objects are allocated with extra bytes after them 1369 // for two variable size arrays (for parameter and exception types) at the 1370 // end of them. 1371 FunctionProtoType *FTP = 1372 (FunctionProtoType*)Allocate(sizeof(FunctionProtoType) + 1373 NumArgs*sizeof(QualType) + 1374 NumExs*sizeof(QualType), 8); 1375 new (FTP) FunctionProtoType(ResultTy, ArgArray, NumArgs, isVariadic, 1376 TypeQuals, hasExceptionSpec, hasAnyExceptionSpec, 1377 ExArray, NumExs, Canonical); 1378 Types.push_back(FTP); 1379 FunctionProtoTypes.InsertNode(FTP, InsertPos); 1380 return QualType(FTP, 0); 1381} 1382 1383/// getTypeDeclType - Return the unique reference to the type for the 1384/// specified type declaration. 1385QualType ASTContext::getTypeDeclType(TypeDecl *Decl, TypeDecl* PrevDecl) { 1386 assert(Decl && "Passed null for Decl param"); 1387 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 1388 1389 if (TypedefDecl *Typedef = dyn_cast<TypedefDecl>(Decl)) 1390 return getTypedefType(Typedef); 1391 else if (isa<TemplateTypeParmDecl>(Decl)) { 1392 assert(false && "Template type parameter types are always available."); 1393 } else if (ObjCInterfaceDecl *ObjCInterface = dyn_cast<ObjCInterfaceDecl>(Decl)) 1394 return getObjCInterfaceType(ObjCInterface); 1395 1396 if (RecordDecl *Record = dyn_cast<RecordDecl>(Decl)) { 1397 if (PrevDecl) 1398 Decl->TypeForDecl = PrevDecl->TypeForDecl; 1399 else 1400 Decl->TypeForDecl = new (*this,8) RecordType(Record); 1401 } 1402 else if (EnumDecl *Enum = dyn_cast<EnumDecl>(Decl)) { 1403 if (PrevDecl) 1404 Decl->TypeForDecl = PrevDecl->TypeForDecl; 1405 else 1406 Decl->TypeForDecl = new (*this,8) EnumType(Enum); 1407 } 1408 else 1409 assert(false && "TypeDecl without a type?"); 1410 1411 if (!PrevDecl) Types.push_back(Decl->TypeForDecl); 1412 return QualType(Decl->TypeForDecl, 0); 1413} 1414 1415/// getTypedefType - Return the unique reference to the type for the 1416/// specified typename decl. 1417QualType ASTContext::getTypedefType(TypedefDecl *Decl) { 1418 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 1419 1420 QualType Canonical = getCanonicalType(Decl->getUnderlyingType()); 1421 Decl->TypeForDecl = new(*this,8) TypedefType(Type::Typedef, Decl, Canonical); 1422 Types.push_back(Decl->TypeForDecl); 1423 return QualType(Decl->TypeForDecl, 0); 1424} 1425 1426/// getObjCInterfaceType - Return the unique reference to the type for the 1427/// specified ObjC interface decl. 1428QualType ASTContext::getObjCInterfaceType(const ObjCInterfaceDecl *Decl) { 1429 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 1430 1431 ObjCInterfaceDecl *OID = const_cast<ObjCInterfaceDecl*>(Decl); 1432 Decl->TypeForDecl = new(*this,8) ObjCInterfaceType(Type::ObjCInterface, OID); 1433 Types.push_back(Decl->TypeForDecl); 1434 return QualType(Decl->TypeForDecl, 0); 1435} 1436 1437/// \brief Retrieve the template type parameter type for a template 1438/// parameter with the given depth, index, and (optionally) name. 1439QualType ASTContext::getTemplateTypeParmType(unsigned Depth, unsigned Index, 1440 IdentifierInfo *Name) { 1441 llvm::FoldingSetNodeID ID; 1442 TemplateTypeParmType::Profile(ID, Depth, Index, Name); 1443 void *InsertPos = 0; 1444 TemplateTypeParmType *TypeParm 1445 = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 1446 1447 if (TypeParm) 1448 return QualType(TypeParm, 0); 1449 1450 if (Name) 1451 TypeParm = new (*this, 8) TemplateTypeParmType(Depth, Index, Name, 1452 getTemplateTypeParmType(Depth, Index)); 1453 else 1454 TypeParm = new (*this, 8) TemplateTypeParmType(Depth, Index); 1455 1456 Types.push_back(TypeParm); 1457 TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos); 1458 1459 return QualType(TypeParm, 0); 1460} 1461 1462QualType 1463ASTContext::getTemplateSpecializationType(TemplateName Template, 1464 const TemplateArgument *Args, 1465 unsigned NumArgs, 1466 QualType Canon) { 1467 if (!Canon.isNull()) 1468 Canon = getCanonicalType(Canon); 1469 1470 llvm::FoldingSetNodeID ID; 1471 TemplateSpecializationType::Profile(ID, Template, Args, NumArgs); 1472 1473 void *InsertPos = 0; 1474 TemplateSpecializationType *Spec 1475 = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 1476 1477 if (Spec) 1478 return QualType(Spec, 0); 1479 1480 void *Mem = Allocate((sizeof(TemplateSpecializationType) + 1481 sizeof(TemplateArgument) * NumArgs), 1482 8); 1483 Spec = new (Mem) TemplateSpecializationType(Template, Args, NumArgs, Canon); 1484 Types.push_back(Spec); 1485 TemplateSpecializationTypes.InsertNode(Spec, InsertPos); 1486 1487 return QualType(Spec, 0); 1488} 1489 1490QualType 1491ASTContext::getQualifiedNameType(NestedNameSpecifier *NNS, 1492 QualType NamedType) { 1493 llvm::FoldingSetNodeID ID; 1494 QualifiedNameType::Profile(ID, NNS, NamedType); 1495 1496 void *InsertPos = 0; 1497 QualifiedNameType *T 1498 = QualifiedNameTypes.FindNodeOrInsertPos(ID, InsertPos); 1499 if (T) 1500 return QualType(T, 0); 1501 1502 T = new (*this) QualifiedNameType(NNS, NamedType, 1503 getCanonicalType(NamedType)); 1504 Types.push_back(T); 1505 QualifiedNameTypes.InsertNode(T, InsertPos); 1506 return QualType(T, 0); 1507} 1508 1509QualType ASTContext::getTypenameType(NestedNameSpecifier *NNS, 1510 const IdentifierInfo *Name, 1511 QualType Canon) { 1512 assert(NNS->isDependent() && "nested-name-specifier must be dependent"); 1513 1514 if (Canon.isNull()) { 1515 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 1516 if (CanonNNS != NNS) 1517 Canon = getTypenameType(CanonNNS, Name); 1518 } 1519 1520 llvm::FoldingSetNodeID ID; 1521 TypenameType::Profile(ID, NNS, Name); 1522 1523 void *InsertPos = 0; 1524 TypenameType *T 1525 = TypenameTypes.FindNodeOrInsertPos(ID, InsertPos); 1526 if (T) 1527 return QualType(T, 0); 1528 1529 T = new (*this) TypenameType(NNS, Name, Canon); 1530 Types.push_back(T); 1531 TypenameTypes.InsertNode(T, InsertPos); 1532 return QualType(T, 0); 1533} 1534 1535QualType 1536ASTContext::getTypenameType(NestedNameSpecifier *NNS, 1537 const TemplateSpecializationType *TemplateId, 1538 QualType Canon) { 1539 assert(NNS->isDependent() && "nested-name-specifier must be dependent"); 1540 1541 if (Canon.isNull()) { 1542 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 1543 QualType CanonType = getCanonicalType(QualType(TemplateId, 0)); 1544 if (CanonNNS != NNS || CanonType != QualType(TemplateId, 0)) { 1545 const TemplateSpecializationType *CanonTemplateId 1546 = CanonType->getAsTemplateSpecializationType(); 1547 assert(CanonTemplateId && 1548 "Canonical type must also be a template specialization type"); 1549 Canon = getTypenameType(CanonNNS, CanonTemplateId); 1550 } 1551 } 1552 1553 llvm::FoldingSetNodeID ID; 1554 TypenameType::Profile(ID, NNS, TemplateId); 1555 1556 void *InsertPos = 0; 1557 TypenameType *T 1558 = TypenameTypes.FindNodeOrInsertPos(ID, InsertPos); 1559 if (T) 1560 return QualType(T, 0); 1561 1562 T = new (*this) TypenameType(NNS, TemplateId, Canon); 1563 Types.push_back(T); 1564 TypenameTypes.InsertNode(T, InsertPos); 1565 return QualType(T, 0); 1566} 1567 1568/// CmpProtocolNames - Comparison predicate for sorting protocols 1569/// alphabetically. 1570static bool CmpProtocolNames(const ObjCProtocolDecl *LHS, 1571 const ObjCProtocolDecl *RHS) { 1572 return LHS->getDeclName() < RHS->getDeclName(); 1573} 1574 1575static void SortAndUniqueProtocols(ObjCProtocolDecl **&Protocols, 1576 unsigned &NumProtocols) { 1577 ObjCProtocolDecl **ProtocolsEnd = Protocols+NumProtocols; 1578 1579 // Sort protocols, keyed by name. 1580 std::sort(Protocols, Protocols+NumProtocols, CmpProtocolNames); 1581 1582 // Remove duplicates. 1583 ProtocolsEnd = std::unique(Protocols, ProtocolsEnd); 1584 NumProtocols = ProtocolsEnd-Protocols; 1585} 1586 1587 1588/// getObjCQualifiedInterfaceType - Return a ObjCQualifiedInterfaceType type for 1589/// the given interface decl and the conforming protocol list. 1590QualType ASTContext::getObjCQualifiedInterfaceType(ObjCInterfaceDecl *Decl, 1591 ObjCProtocolDecl **Protocols, unsigned NumProtocols) { 1592 // Sort the protocol list alphabetically to canonicalize it. 1593 SortAndUniqueProtocols(Protocols, NumProtocols); 1594 1595 llvm::FoldingSetNodeID ID; 1596 ObjCQualifiedInterfaceType::Profile(ID, Decl, Protocols, NumProtocols); 1597 1598 void *InsertPos = 0; 1599 if (ObjCQualifiedInterfaceType *QT = 1600 ObjCQualifiedInterfaceTypes.FindNodeOrInsertPos(ID, InsertPos)) 1601 return QualType(QT, 0); 1602 1603 // No Match; 1604 ObjCQualifiedInterfaceType *QType = 1605 new (*this,8) ObjCQualifiedInterfaceType(Decl, Protocols, NumProtocols); 1606 1607 Types.push_back(QType); 1608 ObjCQualifiedInterfaceTypes.InsertNode(QType, InsertPos); 1609 return QualType(QType, 0); 1610} 1611 1612/// getObjCQualifiedIdType - Return an ObjCQualifiedIdType for the 'id' decl 1613/// and the conforming protocol list. 1614QualType ASTContext::getObjCQualifiedIdType(ObjCProtocolDecl **Protocols, 1615 unsigned NumProtocols) { 1616 // Sort the protocol list alphabetically to canonicalize it. 1617 SortAndUniqueProtocols(Protocols, NumProtocols); 1618 1619 llvm::FoldingSetNodeID ID; 1620 ObjCQualifiedIdType::Profile(ID, Protocols, NumProtocols); 1621 1622 void *InsertPos = 0; 1623 if (ObjCQualifiedIdType *QT = 1624 ObjCQualifiedIdTypes.FindNodeOrInsertPos(ID, InsertPos)) 1625 return QualType(QT, 0); 1626 1627 // No Match; 1628 ObjCQualifiedIdType *QType = 1629 new (*this,8) ObjCQualifiedIdType(Protocols, NumProtocols); 1630 Types.push_back(QType); 1631 ObjCQualifiedIdTypes.InsertNode(QType, InsertPos); 1632 return QualType(QType, 0); 1633} 1634 1635/// getTypeOfExprType - Unlike many "get<Type>" functions, we can't unique 1636/// TypeOfExprType AST's (since expression's are never shared). For example, 1637/// multiple declarations that refer to "typeof(x)" all contain different 1638/// DeclRefExpr's. This doesn't effect the type checker, since it operates 1639/// on canonical type's (which are always unique). 1640QualType ASTContext::getTypeOfExprType(Expr *tofExpr) { 1641 QualType Canonical = getCanonicalType(tofExpr->getType()); 1642 TypeOfExprType *toe = new (*this,8) TypeOfExprType(tofExpr, Canonical); 1643 Types.push_back(toe); 1644 return QualType(toe, 0); 1645} 1646 1647/// getTypeOfType - Unlike many "get<Type>" functions, we don't unique 1648/// TypeOfType AST's. The only motivation to unique these nodes would be 1649/// memory savings. Since typeof(t) is fairly uncommon, space shouldn't be 1650/// an issue. This doesn't effect the type checker, since it operates 1651/// on canonical type's (which are always unique). 1652QualType ASTContext::getTypeOfType(QualType tofType) { 1653 QualType Canonical = getCanonicalType(tofType); 1654 TypeOfType *tot = new (*this,8) TypeOfType(tofType, Canonical); 1655 Types.push_back(tot); 1656 return QualType(tot, 0); 1657} 1658 1659/// getTagDeclType - Return the unique reference to the type for the 1660/// specified TagDecl (struct/union/class/enum) decl. 1661QualType ASTContext::getTagDeclType(TagDecl *Decl) { 1662 assert (Decl); 1663 return getTypeDeclType(Decl); 1664} 1665 1666/// getSizeType - Return the unique type for "size_t" (C99 7.17), the result 1667/// of the sizeof operator (C99 6.5.3.4p4). The value is target dependent and 1668/// needs to agree with the definition in <stddef.h>. 1669QualType ASTContext::getSizeType() const { 1670 return getFromTargetType(Target.getSizeType()); 1671} 1672 1673/// getSignedWCharType - Return the type of "signed wchar_t". 1674/// Used when in C++, as a GCC extension. 1675QualType ASTContext::getSignedWCharType() const { 1676 // FIXME: derive from "Target" ? 1677 return WCharTy; 1678} 1679 1680/// getUnsignedWCharType - Return the type of "unsigned wchar_t". 1681/// Used when in C++, as a GCC extension. 1682QualType ASTContext::getUnsignedWCharType() const { 1683 // FIXME: derive from "Target" ? 1684 return UnsignedIntTy; 1685} 1686 1687/// getPointerDiffType - Return the unique type for "ptrdiff_t" (ref?) 1688/// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9). 1689QualType ASTContext::getPointerDiffType() const { 1690 return getFromTargetType(Target.getPtrDiffType(0)); 1691} 1692 1693//===----------------------------------------------------------------------===// 1694// Type Operators 1695//===----------------------------------------------------------------------===// 1696 1697/// getCanonicalType - Return the canonical (structural) type corresponding to 1698/// the specified potentially non-canonical type. The non-canonical version 1699/// of a type may have many "decorated" versions of types. Decorators can 1700/// include typedefs, 'typeof' operators, etc. The returned type is guaranteed 1701/// to be free of any of these, allowing two canonical types to be compared 1702/// for exact equality with a simple pointer comparison. 1703QualType ASTContext::getCanonicalType(QualType T) { 1704 QualType CanType = T.getTypePtr()->getCanonicalTypeInternal(); 1705 1706 // If the result has type qualifiers, make sure to canonicalize them as well. 1707 unsigned TypeQuals = T.getCVRQualifiers() | CanType.getCVRQualifiers(); 1708 if (TypeQuals == 0) return CanType; 1709 1710 // If the type qualifiers are on an array type, get the canonical type of the 1711 // array with the qualifiers applied to the element type. 1712 ArrayType *AT = dyn_cast<ArrayType>(CanType); 1713 if (!AT) 1714 return CanType.getQualifiedType(TypeQuals); 1715 1716 // Get the canonical version of the element with the extra qualifiers on it. 1717 // This can recursively sink qualifiers through multiple levels of arrays. 1718 QualType NewEltTy=AT->getElementType().getWithAdditionalQualifiers(TypeQuals); 1719 NewEltTy = getCanonicalType(NewEltTy); 1720 1721 if (ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) 1722 return getConstantArrayType(NewEltTy, CAT->getSize(),CAT->getSizeModifier(), 1723 CAT->getIndexTypeQualifier()); 1724 if (IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) 1725 return getIncompleteArrayType(NewEltTy, IAT->getSizeModifier(), 1726 IAT->getIndexTypeQualifier()); 1727 1728 if (DependentSizedArrayType *DSAT = dyn_cast<DependentSizedArrayType>(AT)) 1729 return getDependentSizedArrayType(NewEltTy, DSAT->getSizeExpr(), 1730 DSAT->getSizeModifier(), 1731 DSAT->getIndexTypeQualifier()); 1732 1733 VariableArrayType *VAT = cast<VariableArrayType>(AT); 1734 return getVariableArrayType(NewEltTy, VAT->getSizeExpr(), 1735 VAT->getSizeModifier(), 1736 VAT->getIndexTypeQualifier()); 1737} 1738 1739NestedNameSpecifier * 1740ASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) { 1741 if (!NNS) 1742 return 0; 1743 1744 switch (NNS->getKind()) { 1745 case NestedNameSpecifier::Identifier: 1746 // Canonicalize the prefix but keep the identifier the same. 1747 return NestedNameSpecifier::Create(*this, 1748 getCanonicalNestedNameSpecifier(NNS->getPrefix()), 1749 NNS->getAsIdentifier()); 1750 1751 case NestedNameSpecifier::Namespace: 1752 // A namespace is canonical; build a nested-name-specifier with 1753 // this namespace and no prefix. 1754 return NestedNameSpecifier::Create(*this, 0, NNS->getAsNamespace()); 1755 1756 case NestedNameSpecifier::TypeSpec: 1757 case NestedNameSpecifier::TypeSpecWithTemplate: { 1758 QualType T = getCanonicalType(QualType(NNS->getAsType(), 0)); 1759 NestedNameSpecifier *Prefix = 0; 1760 1761 // FIXME: This isn't the right check! 1762 if (T->isDependentType()) 1763 Prefix = getCanonicalNestedNameSpecifier(NNS->getPrefix()); 1764 1765 return NestedNameSpecifier::Create(*this, Prefix, 1766 NNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate, 1767 T.getTypePtr()); 1768 } 1769 1770 case NestedNameSpecifier::Global: 1771 // The global specifier is canonical and unique. 1772 return NNS; 1773 } 1774 1775 // Required to silence a GCC warning 1776 return 0; 1777} 1778 1779 1780const ArrayType *ASTContext::getAsArrayType(QualType T) { 1781 // Handle the non-qualified case efficiently. 1782 if (T.getCVRQualifiers() == 0) { 1783 // Handle the common positive case fast. 1784 if (const ArrayType *AT = dyn_cast<ArrayType>(T)) 1785 return AT; 1786 } 1787 1788 // Handle the common negative case fast, ignoring CVR qualifiers. 1789 QualType CType = T->getCanonicalTypeInternal(); 1790 1791 // Make sure to look through type qualifiers (like ExtQuals) for the negative 1792 // test. 1793 if (!isa<ArrayType>(CType) && 1794 !isa<ArrayType>(CType.getUnqualifiedType())) 1795 return 0; 1796 1797 // Apply any CVR qualifiers from the array type to the element type. This 1798 // implements C99 6.7.3p8: "If the specification of an array type includes 1799 // any type qualifiers, the element type is so qualified, not the array type." 1800 1801 // If we get here, we either have type qualifiers on the type, or we have 1802 // sugar such as a typedef in the way. If we have type qualifiers on the type 1803 // we must propagate them down into the elemeng type. 1804 unsigned CVRQuals = T.getCVRQualifiers(); 1805 unsigned AddrSpace = 0; 1806 Type *Ty = T.getTypePtr(); 1807 1808 // Rip through ExtQualType's and typedefs to get to a concrete type. 1809 while (1) { 1810 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(Ty)) { 1811 AddrSpace = EXTQT->getAddressSpace(); 1812 Ty = EXTQT->getBaseType(); 1813 } else { 1814 T = Ty->getDesugaredType(); 1815 if (T.getTypePtr() == Ty && T.getCVRQualifiers() == 0) 1816 break; 1817 CVRQuals |= T.getCVRQualifiers(); 1818 Ty = T.getTypePtr(); 1819 } 1820 } 1821 1822 // If we have a simple case, just return now. 1823 const ArrayType *ATy = dyn_cast<ArrayType>(Ty); 1824 if (ATy == 0 || (AddrSpace == 0 && CVRQuals == 0)) 1825 return ATy; 1826 1827 // Otherwise, we have an array and we have qualifiers on it. Push the 1828 // qualifiers into the array element type and return a new array type. 1829 // Get the canonical version of the element with the extra qualifiers on it. 1830 // This can recursively sink qualifiers through multiple levels of arrays. 1831 QualType NewEltTy = ATy->getElementType(); 1832 if (AddrSpace) 1833 NewEltTy = getAddrSpaceQualType(NewEltTy, AddrSpace); 1834 NewEltTy = NewEltTy.getWithAdditionalQualifiers(CVRQuals); 1835 1836 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(ATy)) 1837 return cast<ArrayType>(getConstantArrayType(NewEltTy, CAT->getSize(), 1838 CAT->getSizeModifier(), 1839 CAT->getIndexTypeQualifier())); 1840 if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(ATy)) 1841 return cast<ArrayType>(getIncompleteArrayType(NewEltTy, 1842 IAT->getSizeModifier(), 1843 IAT->getIndexTypeQualifier())); 1844 1845 if (const DependentSizedArrayType *DSAT 1846 = dyn_cast<DependentSizedArrayType>(ATy)) 1847 return cast<ArrayType>( 1848 getDependentSizedArrayType(NewEltTy, 1849 DSAT->getSizeExpr(), 1850 DSAT->getSizeModifier(), 1851 DSAT->getIndexTypeQualifier())); 1852 1853 const VariableArrayType *VAT = cast<VariableArrayType>(ATy); 1854 return cast<ArrayType>(getVariableArrayType(NewEltTy, VAT->getSizeExpr(), 1855 VAT->getSizeModifier(), 1856 VAT->getIndexTypeQualifier())); 1857} 1858 1859 1860/// getArrayDecayedType - Return the properly qualified result of decaying the 1861/// specified array type to a pointer. This operation is non-trivial when 1862/// handling typedefs etc. The canonical type of "T" must be an array type, 1863/// this returns a pointer to a properly qualified element of the array. 1864/// 1865/// See C99 6.7.5.3p7 and C99 6.3.2.1p3. 1866QualType ASTContext::getArrayDecayedType(QualType Ty) { 1867 // Get the element type with 'getAsArrayType' so that we don't lose any 1868 // typedefs in the element type of the array. This also handles propagation 1869 // of type qualifiers from the array type into the element type if present 1870 // (C99 6.7.3p8). 1871 const ArrayType *PrettyArrayType = getAsArrayType(Ty); 1872 assert(PrettyArrayType && "Not an array type!"); 1873 1874 QualType PtrTy = getPointerType(PrettyArrayType->getElementType()); 1875 1876 // int x[restrict 4] -> int *restrict 1877 return PtrTy.getQualifiedType(PrettyArrayType->getIndexTypeQualifier()); 1878} 1879 1880QualType ASTContext::getBaseElementType(const VariableArrayType *VAT) { 1881 QualType ElemTy = VAT->getElementType(); 1882 1883 if (const VariableArrayType *VAT = getAsVariableArrayType(ElemTy)) 1884 return getBaseElementType(VAT); 1885 1886 return ElemTy; 1887} 1888 1889/// getFloatingRank - Return a relative rank for floating point types. 1890/// This routine will assert if passed a built-in type that isn't a float. 1891static FloatingRank getFloatingRank(QualType T) { 1892 if (const ComplexType *CT = T->getAsComplexType()) 1893 return getFloatingRank(CT->getElementType()); 1894 1895 assert(T->getAsBuiltinType() && "getFloatingRank(): not a floating type"); 1896 switch (T->getAsBuiltinType()->getKind()) { 1897 default: assert(0 && "getFloatingRank(): not a floating type"); 1898 case BuiltinType::Float: return FloatRank; 1899 case BuiltinType::Double: return DoubleRank; 1900 case BuiltinType::LongDouble: return LongDoubleRank; 1901 } 1902} 1903 1904/// getFloatingTypeOfSizeWithinDomain - Returns a real floating 1905/// point or a complex type (based on typeDomain/typeSize). 1906/// 'typeDomain' is a real floating point or complex type. 1907/// 'typeSize' is a real floating point or complex type. 1908QualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size, 1909 QualType Domain) const { 1910 FloatingRank EltRank = getFloatingRank(Size); 1911 if (Domain->isComplexType()) { 1912 switch (EltRank) { 1913 default: assert(0 && "getFloatingRank(): illegal value for rank"); 1914 case FloatRank: return FloatComplexTy; 1915 case DoubleRank: return DoubleComplexTy; 1916 case LongDoubleRank: return LongDoubleComplexTy; 1917 } 1918 } 1919 1920 assert(Domain->isRealFloatingType() && "Unknown domain!"); 1921 switch (EltRank) { 1922 default: assert(0 && "getFloatingRank(): illegal value for rank"); 1923 case FloatRank: return FloatTy; 1924 case DoubleRank: return DoubleTy; 1925 case LongDoubleRank: return LongDoubleTy; 1926 } 1927} 1928 1929/// getFloatingTypeOrder - Compare the rank of the two specified floating 1930/// point types, ignoring the domain of the type (i.e. 'double' == 1931/// '_Complex double'). If LHS > RHS, return 1. If LHS == RHS, return 0. If 1932/// LHS < RHS, return -1. 1933int ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) { 1934 FloatingRank LHSR = getFloatingRank(LHS); 1935 FloatingRank RHSR = getFloatingRank(RHS); 1936 1937 if (LHSR == RHSR) 1938 return 0; 1939 if (LHSR > RHSR) 1940 return 1; 1941 return -1; 1942} 1943 1944/// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This 1945/// routine will assert if passed a built-in type that isn't an integer or enum, 1946/// or if it is not canonicalized. 1947unsigned ASTContext::getIntegerRank(Type *T) { 1948 assert(T->isCanonical() && "T should be canonicalized"); 1949 if (EnumType* ET = dyn_cast<EnumType>(T)) 1950 T = ET->getDecl()->getIntegerType().getTypePtr(); 1951 1952 // There are two things which impact the integer rank: the width, and 1953 // the ordering of builtins. The builtin ordering is encoded in the 1954 // bottom three bits; the width is encoded in the bits above that. 1955 if (FixedWidthIntType* FWIT = dyn_cast<FixedWidthIntType>(T)) { 1956 return FWIT->getWidth() << 3; 1957 } 1958 1959 switch (cast<BuiltinType>(T)->getKind()) { 1960 default: assert(0 && "getIntegerRank(): not a built-in integer"); 1961 case BuiltinType::Bool: 1962 return 1 + (getIntWidth(BoolTy) << 3); 1963 case BuiltinType::Char_S: 1964 case BuiltinType::Char_U: 1965 case BuiltinType::SChar: 1966 case BuiltinType::UChar: 1967 return 2 + (getIntWidth(CharTy) << 3); 1968 case BuiltinType::Short: 1969 case BuiltinType::UShort: 1970 return 3 + (getIntWidth(ShortTy) << 3); 1971 case BuiltinType::Int: 1972 case BuiltinType::UInt: 1973 return 4 + (getIntWidth(IntTy) << 3); 1974 case BuiltinType::Long: 1975 case BuiltinType::ULong: 1976 return 5 + (getIntWidth(LongTy) << 3); 1977 case BuiltinType::LongLong: 1978 case BuiltinType::ULongLong: 1979 return 6 + (getIntWidth(LongLongTy) << 3); 1980 case BuiltinType::Int128: 1981 case BuiltinType::UInt128: 1982 return 7 + (getIntWidth(Int128Ty) << 3); 1983 } 1984} 1985 1986/// getIntegerTypeOrder - Returns the highest ranked integer type: 1987/// C99 6.3.1.8p1. If LHS > RHS, return 1. If LHS == RHS, return 0. If 1988/// LHS < RHS, return -1. 1989int ASTContext::getIntegerTypeOrder(QualType LHS, QualType RHS) { 1990 Type *LHSC = getCanonicalType(LHS).getTypePtr(); 1991 Type *RHSC = getCanonicalType(RHS).getTypePtr(); 1992 if (LHSC == RHSC) return 0; 1993 1994 bool LHSUnsigned = LHSC->isUnsignedIntegerType(); 1995 bool RHSUnsigned = RHSC->isUnsignedIntegerType(); 1996 1997 unsigned LHSRank = getIntegerRank(LHSC); 1998 unsigned RHSRank = getIntegerRank(RHSC); 1999 2000 if (LHSUnsigned == RHSUnsigned) { // Both signed or both unsigned. 2001 if (LHSRank == RHSRank) return 0; 2002 return LHSRank > RHSRank ? 1 : -1; 2003 } 2004 2005 // Otherwise, the LHS is signed and the RHS is unsigned or visa versa. 2006 if (LHSUnsigned) { 2007 // If the unsigned [LHS] type is larger, return it. 2008 if (LHSRank >= RHSRank) 2009 return 1; 2010 2011 // If the signed type can represent all values of the unsigned type, it 2012 // wins. Because we are dealing with 2's complement and types that are 2013 // powers of two larger than each other, this is always safe. 2014 return -1; 2015 } 2016 2017 // If the unsigned [RHS] type is larger, return it. 2018 if (RHSRank >= LHSRank) 2019 return -1; 2020 2021 // If the signed type can represent all values of the unsigned type, it 2022 // wins. Because we are dealing with 2's complement and types that are 2023 // powers of two larger than each other, this is always safe. 2024 return 1; 2025} 2026 2027// getCFConstantStringType - Return the type used for constant CFStrings. 2028QualType ASTContext::getCFConstantStringType() { 2029 if (!CFConstantStringTypeDecl) { 2030 CFConstantStringTypeDecl = 2031 RecordDecl::Create(*this, TagDecl::TK_struct, TUDecl, SourceLocation(), 2032 &Idents.get("NSConstantString")); 2033 QualType FieldTypes[4]; 2034 2035 // const int *isa; 2036 FieldTypes[0] = getPointerType(IntTy.getQualifiedType(QualType::Const)); 2037 // int flags; 2038 FieldTypes[1] = IntTy; 2039 // const char *str; 2040 FieldTypes[2] = getPointerType(CharTy.getQualifiedType(QualType::Const)); 2041 // long length; 2042 FieldTypes[3] = LongTy; 2043 2044 // Create fields 2045 for (unsigned i = 0; i < 4; ++i) { 2046 FieldDecl *Field = FieldDecl::Create(*this, CFConstantStringTypeDecl, 2047 SourceLocation(), 0, 2048 FieldTypes[i], /*BitWidth=*/0, 2049 /*Mutable=*/false); 2050 CFConstantStringTypeDecl->addDecl(*this, Field); 2051 } 2052 2053 CFConstantStringTypeDecl->completeDefinition(*this); 2054 } 2055 2056 return getTagDeclType(CFConstantStringTypeDecl); 2057} 2058 2059void ASTContext::setCFConstantStringType(QualType T) { 2060 const RecordType *Rec = T->getAsRecordType(); 2061 assert(Rec && "Invalid CFConstantStringType"); 2062 CFConstantStringTypeDecl = Rec->getDecl(); 2063} 2064 2065QualType ASTContext::getObjCFastEnumerationStateType() 2066{ 2067 if (!ObjCFastEnumerationStateTypeDecl) { 2068 ObjCFastEnumerationStateTypeDecl = 2069 RecordDecl::Create(*this, TagDecl::TK_struct, TUDecl, SourceLocation(), 2070 &Idents.get("__objcFastEnumerationState")); 2071 2072 QualType FieldTypes[] = { 2073 UnsignedLongTy, 2074 getPointerType(ObjCIdType), 2075 getPointerType(UnsignedLongTy), 2076 getConstantArrayType(UnsignedLongTy, 2077 llvm::APInt(32, 5), ArrayType::Normal, 0) 2078 }; 2079 2080 for (size_t i = 0; i < 4; ++i) { 2081 FieldDecl *Field = FieldDecl::Create(*this, 2082 ObjCFastEnumerationStateTypeDecl, 2083 SourceLocation(), 0, 2084 FieldTypes[i], /*BitWidth=*/0, 2085 /*Mutable=*/false); 2086 ObjCFastEnumerationStateTypeDecl->addDecl(*this, Field); 2087 } 2088 2089 ObjCFastEnumerationStateTypeDecl->completeDefinition(*this); 2090 } 2091 2092 return getTagDeclType(ObjCFastEnumerationStateTypeDecl); 2093} 2094 2095void ASTContext::setObjCFastEnumerationStateType(QualType T) { 2096 const RecordType *Rec = T->getAsRecordType(); 2097 assert(Rec && "Invalid ObjCFAstEnumerationStateType"); 2098 ObjCFastEnumerationStateTypeDecl = Rec->getDecl(); 2099} 2100 2101// This returns true if a type has been typedefed to BOOL: 2102// typedef <type> BOOL; 2103static bool isTypeTypedefedAsBOOL(QualType T) { 2104 if (const TypedefType *TT = dyn_cast<TypedefType>(T)) 2105 if (IdentifierInfo *II = TT->getDecl()->getIdentifier()) 2106 return II->isStr("BOOL"); 2107 2108 return false; 2109} 2110 2111/// getObjCEncodingTypeSize returns size of type for objective-c encoding 2112/// purpose. 2113int ASTContext::getObjCEncodingTypeSize(QualType type) { 2114 uint64_t sz = getTypeSize(type); 2115 2116 // Make all integer and enum types at least as large as an int 2117 if (sz > 0 && type->isIntegralType()) 2118 sz = std::max(sz, getTypeSize(IntTy)); 2119 // Treat arrays as pointers, since that's how they're passed in. 2120 else if (type->isArrayType()) 2121 sz = getTypeSize(VoidPtrTy); 2122 return sz / getTypeSize(CharTy); 2123} 2124 2125/// getObjCEncodingForMethodDecl - Return the encoded type for this method 2126/// declaration. 2127void ASTContext::getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl, 2128 std::string& S) { 2129 // FIXME: This is not very efficient. 2130 // Encode type qualifer, 'in', 'inout', etc. for the return type. 2131 getObjCEncodingForTypeQualifier(Decl->getObjCDeclQualifier(), S); 2132 // Encode result type. 2133 getObjCEncodingForType(Decl->getResultType(), S); 2134 // Compute size of all parameters. 2135 // Start with computing size of a pointer in number of bytes. 2136 // FIXME: There might(should) be a better way of doing this computation! 2137 SourceLocation Loc; 2138 int PtrSize = getTypeSize(VoidPtrTy) / getTypeSize(CharTy); 2139 // The first two arguments (self and _cmd) are pointers; account for 2140 // their size. 2141 int ParmOffset = 2 * PtrSize; 2142 for (ObjCMethodDecl::param_iterator PI = Decl->param_begin(), 2143 E = Decl->param_end(); PI != E; ++PI) { 2144 QualType PType = (*PI)->getType(); 2145 int sz = getObjCEncodingTypeSize(PType); 2146 assert (sz > 0 && "getObjCEncodingForMethodDecl - Incomplete param type"); 2147 ParmOffset += sz; 2148 } 2149 S += llvm::utostr(ParmOffset); 2150 S += "@0:"; 2151 S += llvm::utostr(PtrSize); 2152 2153 // Argument types. 2154 ParmOffset = 2 * PtrSize; 2155 for (ObjCMethodDecl::param_iterator PI = Decl->param_begin(), 2156 E = Decl->param_end(); PI != E; ++PI) { 2157 ParmVarDecl *PVDecl = *PI; 2158 QualType PType = PVDecl->getOriginalType(); 2159 if (const ArrayType *AT = 2160 dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) { 2161 // Use array's original type only if it has known number of 2162 // elements. 2163 if (!isa<ConstantArrayType>(AT)) 2164 PType = PVDecl->getType(); 2165 } else if (PType->isFunctionType()) 2166 PType = PVDecl->getType(); 2167 // Process argument qualifiers for user supplied arguments; such as, 2168 // 'in', 'inout', etc. 2169 getObjCEncodingForTypeQualifier(PVDecl->getObjCDeclQualifier(), S); 2170 getObjCEncodingForType(PType, S); 2171 S += llvm::utostr(ParmOffset); 2172 ParmOffset += getObjCEncodingTypeSize(PType); 2173 } 2174} 2175 2176/// getObjCEncodingForPropertyDecl - Return the encoded type for this 2177/// property declaration. If non-NULL, Container must be either an 2178/// ObjCCategoryImplDecl or ObjCImplementationDecl; it should only be 2179/// NULL when getting encodings for protocol properties. 2180/// Property attributes are stored as a comma-delimited C string. The simple 2181/// attributes readonly and bycopy are encoded as single characters. The 2182/// parametrized attributes, getter=name, setter=name, and ivar=name, are 2183/// encoded as single characters, followed by an identifier. Property types 2184/// are also encoded as a parametrized attribute. The characters used to encode 2185/// these attributes are defined by the following enumeration: 2186/// @code 2187/// enum PropertyAttributes { 2188/// kPropertyReadOnly = 'R', // property is read-only. 2189/// kPropertyBycopy = 'C', // property is a copy of the value last assigned 2190/// kPropertyByref = '&', // property is a reference to the value last assigned 2191/// kPropertyDynamic = 'D', // property is dynamic 2192/// kPropertyGetter = 'G', // followed by getter selector name 2193/// kPropertySetter = 'S', // followed by setter selector name 2194/// kPropertyInstanceVariable = 'V' // followed by instance variable name 2195/// kPropertyType = 't' // followed by old-style type encoding. 2196/// kPropertyWeak = 'W' // 'weak' property 2197/// kPropertyStrong = 'P' // property GC'able 2198/// kPropertyNonAtomic = 'N' // property non-atomic 2199/// }; 2200/// @endcode 2201void ASTContext::getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD, 2202 const Decl *Container, 2203 std::string& S) { 2204 // Collect information from the property implementation decl(s). 2205 bool Dynamic = false; 2206 ObjCPropertyImplDecl *SynthesizePID = 0; 2207 2208 // FIXME: Duplicated code due to poor abstraction. 2209 if (Container) { 2210 if (const ObjCCategoryImplDecl *CID = 2211 dyn_cast<ObjCCategoryImplDecl>(Container)) { 2212 for (ObjCCategoryImplDecl::propimpl_iterator 2213 i = CID->propimpl_begin(*this), e = CID->propimpl_end(*this); 2214 i != e; ++i) { 2215 ObjCPropertyImplDecl *PID = *i; 2216 if (PID->getPropertyDecl() == PD) { 2217 if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) { 2218 Dynamic = true; 2219 } else { 2220 SynthesizePID = PID; 2221 } 2222 } 2223 } 2224 } else { 2225 const ObjCImplementationDecl *OID=cast<ObjCImplementationDecl>(Container); 2226 for (ObjCCategoryImplDecl::propimpl_iterator 2227 i = OID->propimpl_begin(*this), e = OID->propimpl_end(*this); 2228 i != e; ++i) { 2229 ObjCPropertyImplDecl *PID = *i; 2230 if (PID->getPropertyDecl() == PD) { 2231 if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) { 2232 Dynamic = true; 2233 } else { 2234 SynthesizePID = PID; 2235 } 2236 } 2237 } 2238 } 2239 } 2240 2241 // FIXME: This is not very efficient. 2242 S = "T"; 2243 2244 // Encode result type. 2245 // GCC has some special rules regarding encoding of properties which 2246 // closely resembles encoding of ivars. 2247 getObjCEncodingForTypeImpl(PD->getType(), S, true, true, 0, 2248 true /* outermost type */, 2249 true /* encoding for property */); 2250 2251 if (PD->isReadOnly()) { 2252 S += ",R"; 2253 } else { 2254 switch (PD->getSetterKind()) { 2255 case ObjCPropertyDecl::Assign: break; 2256 case ObjCPropertyDecl::Copy: S += ",C"; break; 2257 case ObjCPropertyDecl::Retain: S += ",&"; break; 2258 } 2259 } 2260 2261 // It really isn't clear at all what this means, since properties 2262 // are "dynamic by default". 2263 if (Dynamic) 2264 S += ",D"; 2265 2266 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_nonatomic) 2267 S += ",N"; 2268 2269 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_getter) { 2270 S += ",G"; 2271 S += PD->getGetterName().getAsString(); 2272 } 2273 2274 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter) { 2275 S += ",S"; 2276 S += PD->getSetterName().getAsString(); 2277 } 2278 2279 if (SynthesizePID) { 2280 const ObjCIvarDecl *OID = SynthesizePID->getPropertyIvarDecl(); 2281 S += ",V"; 2282 S += OID->getNameAsString(); 2283 } 2284 2285 // FIXME: OBJCGC: weak & strong 2286} 2287 2288/// getLegacyIntegralTypeEncoding - 2289/// Another legacy compatibility encoding: 32-bit longs are encoded as 2290/// 'l' or 'L' , but not always. For typedefs, we need to use 2291/// 'i' or 'I' instead if encoding a struct field, or a pointer! 2292/// 2293void ASTContext::getLegacyIntegralTypeEncoding (QualType &PointeeTy) const { 2294 if (dyn_cast<TypedefType>(PointeeTy.getTypePtr())) { 2295 if (const BuiltinType *BT = PointeeTy->getAsBuiltinType()) { 2296 if (BT->getKind() == BuiltinType::ULong && 2297 ((const_cast<ASTContext *>(this))->getIntWidth(PointeeTy) == 32)) 2298 PointeeTy = UnsignedIntTy; 2299 else 2300 if (BT->getKind() == BuiltinType::Long && 2301 ((const_cast<ASTContext *>(this))->getIntWidth(PointeeTy) == 32)) 2302 PointeeTy = IntTy; 2303 } 2304 } 2305} 2306 2307void ASTContext::getObjCEncodingForType(QualType T, std::string& S, 2308 const FieldDecl *Field) { 2309 // We follow the behavior of gcc, expanding structures which are 2310 // directly pointed to, and expanding embedded structures. Note that 2311 // these rules are sufficient to prevent recursive encoding of the 2312 // same type. 2313 getObjCEncodingForTypeImpl(T, S, true, true, Field, 2314 true /* outermost type */); 2315} 2316 2317static void EncodeBitField(const ASTContext *Context, std::string& S, 2318 const FieldDecl *FD) { 2319 const Expr *E = FD->getBitWidth(); 2320 assert(E && "bitfield width not there - getObjCEncodingForTypeImpl"); 2321 ASTContext *Ctx = const_cast<ASTContext*>(Context); 2322 unsigned N = E->EvaluateAsInt(*Ctx).getZExtValue(); 2323 S += 'b'; 2324 S += llvm::utostr(N); 2325} 2326 2327void ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S, 2328 bool ExpandPointedToStructures, 2329 bool ExpandStructures, 2330 const FieldDecl *FD, 2331 bool OutermostType, 2332 bool EncodingProperty) { 2333 if (const BuiltinType *BT = T->getAsBuiltinType()) { 2334 if (FD && FD->isBitField()) { 2335 EncodeBitField(this, S, FD); 2336 } 2337 else { 2338 char encoding; 2339 switch (BT->getKind()) { 2340 default: assert(0 && "Unhandled builtin type kind"); 2341 case BuiltinType::Void: encoding = 'v'; break; 2342 case BuiltinType::Bool: encoding = 'B'; break; 2343 case BuiltinType::Char_U: 2344 case BuiltinType::UChar: encoding = 'C'; break; 2345 case BuiltinType::UShort: encoding = 'S'; break; 2346 case BuiltinType::UInt: encoding = 'I'; break; 2347 case BuiltinType::ULong: 2348 encoding = 2349 (const_cast<ASTContext *>(this))->getIntWidth(T) == 32 ? 'L' : 'Q'; 2350 break; 2351 case BuiltinType::UInt128: encoding = 'T'; break; 2352 case BuiltinType::ULongLong: encoding = 'Q'; break; 2353 case BuiltinType::Char_S: 2354 case BuiltinType::SChar: encoding = 'c'; break; 2355 case BuiltinType::Short: encoding = 's'; break; 2356 case BuiltinType::Int: encoding = 'i'; break; 2357 case BuiltinType::Long: 2358 encoding = 2359 (const_cast<ASTContext *>(this))->getIntWidth(T) == 32 ? 'l' : 'q'; 2360 break; 2361 case BuiltinType::LongLong: encoding = 'q'; break; 2362 case BuiltinType::Int128: encoding = 't'; break; 2363 case BuiltinType::Float: encoding = 'f'; break; 2364 case BuiltinType::Double: encoding = 'd'; break; 2365 case BuiltinType::LongDouble: encoding = 'd'; break; 2366 } 2367 2368 S += encoding; 2369 } 2370 } else if (const ComplexType *CT = T->getAsComplexType()) { 2371 S += 'j'; 2372 getObjCEncodingForTypeImpl(CT->getElementType(), S, false, false, 0, false, 2373 false); 2374 } else if (T->isObjCQualifiedIdType()) { 2375 getObjCEncodingForTypeImpl(getObjCIdType(), S, 2376 ExpandPointedToStructures, 2377 ExpandStructures, FD); 2378 if (FD || EncodingProperty) { 2379 // Note that we do extended encoding of protocol qualifer list 2380 // Only when doing ivar or property encoding. 2381 const ObjCQualifiedIdType *QIDT = T->getAsObjCQualifiedIdType(); 2382 S += '"'; 2383 for (unsigned i =0; i < QIDT->getNumProtocols(); i++) { 2384 ObjCProtocolDecl *Proto = QIDT->getProtocols(i); 2385 S += '<'; 2386 S += Proto->getNameAsString(); 2387 S += '>'; 2388 } 2389 S += '"'; 2390 } 2391 return; 2392 } 2393 else if (const PointerType *PT = T->getAsPointerType()) { 2394 QualType PointeeTy = PT->getPointeeType(); 2395 bool isReadOnly = false; 2396 // For historical/compatibility reasons, the read-only qualifier of the 2397 // pointee gets emitted _before_ the '^'. The read-only qualifier of 2398 // the pointer itself gets ignored, _unless_ we are looking at a typedef! 2399 // Also, do not emit the 'r' for anything but the outermost type! 2400 if (dyn_cast<TypedefType>(T.getTypePtr())) { 2401 if (OutermostType && T.isConstQualified()) { 2402 isReadOnly = true; 2403 S += 'r'; 2404 } 2405 } 2406 else if (OutermostType) { 2407 QualType P = PointeeTy; 2408 while (P->getAsPointerType()) 2409 P = P->getAsPointerType()->getPointeeType(); 2410 if (P.isConstQualified()) { 2411 isReadOnly = true; 2412 S += 'r'; 2413 } 2414 } 2415 if (isReadOnly) { 2416 // Another legacy compatibility encoding. Some ObjC qualifier and type 2417 // combinations need to be rearranged. 2418 // Rewrite "in const" from "nr" to "rn" 2419 const char * s = S.c_str(); 2420 int len = S.length(); 2421 if (len >= 2 && s[len-2] == 'n' && s[len-1] == 'r') { 2422 std::string replace = "rn"; 2423 S.replace(S.end()-2, S.end(), replace); 2424 } 2425 } 2426 if (isObjCIdStructType(PointeeTy)) { 2427 S += '@'; 2428 return; 2429 } 2430 else if (PointeeTy->isObjCInterfaceType()) { 2431 if (!EncodingProperty && 2432 isa<TypedefType>(PointeeTy.getTypePtr())) { 2433 // Another historical/compatibility reason. 2434 // We encode the underlying type which comes out as 2435 // {...}; 2436 S += '^'; 2437 getObjCEncodingForTypeImpl(PointeeTy, S, 2438 false, ExpandPointedToStructures, 2439 NULL); 2440 return; 2441 } 2442 S += '@'; 2443 if (FD || EncodingProperty) { 2444 const ObjCInterfaceType *OIT = 2445 PointeeTy.getUnqualifiedType()->getAsObjCInterfaceType(); 2446 ObjCInterfaceDecl *OI = OIT->getDecl(); 2447 S += '"'; 2448 S += OI->getNameAsCString(); 2449 for (unsigned i =0; i < OIT->getNumProtocols(); i++) { 2450 ObjCProtocolDecl *Proto = OIT->getProtocol(i); 2451 S += '<'; 2452 S += Proto->getNameAsString(); 2453 S += '>'; 2454 } 2455 S += '"'; 2456 } 2457 return; 2458 } else if (isObjCClassStructType(PointeeTy)) { 2459 S += '#'; 2460 return; 2461 } else if (isObjCSelType(PointeeTy)) { 2462 S += ':'; 2463 return; 2464 } 2465 2466 if (PointeeTy->isCharType()) { 2467 // char pointer types should be encoded as '*' unless it is a 2468 // type that has been typedef'd to 'BOOL'. 2469 if (!isTypeTypedefedAsBOOL(PointeeTy)) { 2470 S += '*'; 2471 return; 2472 } 2473 } 2474 2475 S += '^'; 2476 getLegacyIntegralTypeEncoding(PointeeTy); 2477 2478 getObjCEncodingForTypeImpl(PointeeTy, S, 2479 false, ExpandPointedToStructures, 2480 NULL); 2481 } else if (const ArrayType *AT = 2482 // Ignore type qualifiers etc. 2483 dyn_cast<ArrayType>(T->getCanonicalTypeInternal())) { 2484 if (isa<IncompleteArrayType>(AT)) { 2485 // Incomplete arrays are encoded as a pointer to the array element. 2486 S += '^'; 2487 2488 getObjCEncodingForTypeImpl(AT->getElementType(), S, 2489 false, ExpandStructures, FD); 2490 } else { 2491 S += '['; 2492 2493 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) 2494 S += llvm::utostr(CAT->getSize().getZExtValue()); 2495 else { 2496 //Variable length arrays are encoded as a regular array with 0 elements. 2497 assert(isa<VariableArrayType>(AT) && "Unknown array type!"); 2498 S += '0'; 2499 } 2500 2501 getObjCEncodingForTypeImpl(AT->getElementType(), S, 2502 false, ExpandStructures, FD); 2503 S += ']'; 2504 } 2505 } else if (T->getAsFunctionType()) { 2506 S += '?'; 2507 } else if (const RecordType *RTy = T->getAsRecordType()) { 2508 RecordDecl *RDecl = RTy->getDecl(); 2509 S += RDecl->isUnion() ? '(' : '{'; 2510 // Anonymous structures print as '?' 2511 if (const IdentifierInfo *II = RDecl->getIdentifier()) { 2512 S += II->getName(); 2513 } else { 2514 S += '?'; 2515 } 2516 if (ExpandStructures) { 2517 S += '='; 2518 for (RecordDecl::field_iterator Field = RDecl->field_begin(*this), 2519 FieldEnd = RDecl->field_end(*this); 2520 Field != FieldEnd; ++Field) { 2521 if (FD) { 2522 S += '"'; 2523 S += Field->getNameAsString(); 2524 S += '"'; 2525 } 2526 2527 // Special case bit-fields. 2528 if (Field->isBitField()) { 2529 getObjCEncodingForTypeImpl(Field->getType(), S, false, true, 2530 (*Field)); 2531 } else { 2532 QualType qt = Field->getType(); 2533 getLegacyIntegralTypeEncoding(qt); 2534 getObjCEncodingForTypeImpl(qt, S, false, true, 2535 FD); 2536 } 2537 } 2538 } 2539 S += RDecl->isUnion() ? ')' : '}'; 2540 } else if (T->isEnumeralType()) { 2541 if (FD && FD->isBitField()) 2542 EncodeBitField(this, S, FD); 2543 else 2544 S += 'i'; 2545 } else if (T->isBlockPointerType()) { 2546 S += "@?"; // Unlike a pointer-to-function, which is "^?". 2547 } else if (T->isObjCInterfaceType()) { 2548 // @encode(class_name) 2549 ObjCInterfaceDecl *OI = T->getAsObjCInterfaceType()->getDecl(); 2550 S += '{'; 2551 const IdentifierInfo *II = OI->getIdentifier(); 2552 S += II->getName(); 2553 S += '='; 2554 llvm::SmallVector<FieldDecl*, 32> RecFields; 2555 CollectObjCIvars(OI, RecFields); 2556 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) { 2557 if (RecFields[i]->isBitField()) 2558 getObjCEncodingForTypeImpl(RecFields[i]->getType(), S, false, true, 2559 RecFields[i]); 2560 else 2561 getObjCEncodingForTypeImpl(RecFields[i]->getType(), S, false, true, 2562 FD); 2563 } 2564 S += '}'; 2565 } 2566 else 2567 assert(0 && "@encode for type not implemented!"); 2568} 2569 2570void ASTContext::getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT, 2571 std::string& S) const { 2572 if (QT & Decl::OBJC_TQ_In) 2573 S += 'n'; 2574 if (QT & Decl::OBJC_TQ_Inout) 2575 S += 'N'; 2576 if (QT & Decl::OBJC_TQ_Out) 2577 S += 'o'; 2578 if (QT & Decl::OBJC_TQ_Bycopy) 2579 S += 'O'; 2580 if (QT & Decl::OBJC_TQ_Byref) 2581 S += 'R'; 2582 if (QT & Decl::OBJC_TQ_Oneway) 2583 S += 'V'; 2584} 2585 2586void ASTContext::setBuiltinVaListType(QualType T) 2587{ 2588 assert(BuiltinVaListType.isNull() && "__builtin_va_list type already set!"); 2589 2590 BuiltinVaListType = T; 2591} 2592 2593void ASTContext::setObjCIdType(QualType T) 2594{ 2595 ObjCIdType = T; 2596 2597 const TypedefType *TT = T->getAsTypedefType(); 2598 if (!TT) 2599 return; 2600 2601 TypedefDecl *TD = TT->getDecl(); 2602 2603 // typedef struct objc_object *id; 2604 const PointerType *ptr = TD->getUnderlyingType()->getAsPointerType(); 2605 // User error - caller will issue diagnostics. 2606 if (!ptr) 2607 return; 2608 const RecordType *rec = ptr->getPointeeType()->getAsStructureType(); 2609 // User error - caller will issue diagnostics. 2610 if (!rec) 2611 return; 2612 IdStructType = rec; 2613} 2614 2615void ASTContext::setObjCSelType(QualType T) 2616{ 2617 ObjCSelType = T; 2618 2619 const TypedefType *TT = T->getAsTypedefType(); 2620 if (!TT) 2621 return; 2622 TypedefDecl *TD = TT->getDecl(); 2623 2624 // typedef struct objc_selector *SEL; 2625 const PointerType *ptr = TD->getUnderlyingType()->getAsPointerType(); 2626 if (!ptr) 2627 return; 2628 const RecordType *rec = ptr->getPointeeType()->getAsStructureType(); 2629 if (!rec) 2630 return; 2631 SelStructType = rec; 2632} 2633 2634void ASTContext::setObjCProtoType(QualType QT) 2635{ 2636 ObjCProtoType = QT; 2637} 2638 2639void ASTContext::setObjCClassType(QualType T) 2640{ 2641 ObjCClassType = T; 2642 2643 const TypedefType *TT = T->getAsTypedefType(); 2644 if (!TT) 2645 return; 2646 TypedefDecl *TD = TT->getDecl(); 2647 2648 // typedef struct objc_class *Class; 2649 const PointerType *ptr = TD->getUnderlyingType()->getAsPointerType(); 2650 assert(ptr && "'Class' incorrectly typed"); 2651 const RecordType *rec = ptr->getPointeeType()->getAsStructureType(); 2652 assert(rec && "'Class' incorrectly typed"); 2653 ClassStructType = rec; 2654} 2655 2656void ASTContext::setObjCConstantStringInterface(ObjCInterfaceDecl *Decl) { 2657 assert(ObjCConstantStringType.isNull() && 2658 "'NSConstantString' type already set!"); 2659 2660 ObjCConstantStringType = getObjCInterfaceType(Decl); 2661} 2662 2663/// \brief Retrieve the template name that represents a qualified 2664/// template name such as \c std::vector. 2665TemplateName ASTContext::getQualifiedTemplateName(NestedNameSpecifier *NNS, 2666 bool TemplateKeyword, 2667 TemplateDecl *Template) { 2668 llvm::FoldingSetNodeID ID; 2669 QualifiedTemplateName::Profile(ID, NNS, TemplateKeyword, Template); 2670 2671 void *InsertPos = 0; 2672 QualifiedTemplateName *QTN = 2673 QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 2674 if (!QTN) { 2675 QTN = new (*this,4) QualifiedTemplateName(NNS, TemplateKeyword, Template); 2676 QualifiedTemplateNames.InsertNode(QTN, InsertPos); 2677 } 2678 2679 return TemplateName(QTN); 2680} 2681 2682/// \brief Retrieve the template name that represents a dependent 2683/// template name such as \c MetaFun::template apply. 2684TemplateName ASTContext::getDependentTemplateName(NestedNameSpecifier *NNS, 2685 const IdentifierInfo *Name) { 2686 assert(NNS->isDependent() && "Nested name specifier must be dependent"); 2687 2688 llvm::FoldingSetNodeID ID; 2689 DependentTemplateName::Profile(ID, NNS, Name); 2690 2691 void *InsertPos = 0; 2692 DependentTemplateName *QTN = 2693 DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 2694 2695 if (QTN) 2696 return TemplateName(QTN); 2697 2698 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 2699 if (CanonNNS == NNS) { 2700 QTN = new (*this,4) DependentTemplateName(NNS, Name); 2701 } else { 2702 TemplateName Canon = getDependentTemplateName(CanonNNS, Name); 2703 QTN = new (*this,4) DependentTemplateName(NNS, Name, Canon); 2704 } 2705 2706 DependentTemplateNames.InsertNode(QTN, InsertPos); 2707 return TemplateName(QTN); 2708} 2709 2710/// getFromTargetType - Given one of the integer types provided by 2711/// TargetInfo, produce the corresponding type. The unsigned @p Type 2712/// is actually a value of type @c TargetInfo::IntType. 2713QualType ASTContext::getFromTargetType(unsigned Type) const { 2714 switch (Type) { 2715 case TargetInfo::NoInt: return QualType(); 2716 case TargetInfo::SignedShort: return ShortTy; 2717 case TargetInfo::UnsignedShort: return UnsignedShortTy; 2718 case TargetInfo::SignedInt: return IntTy; 2719 case TargetInfo::UnsignedInt: return UnsignedIntTy; 2720 case TargetInfo::SignedLong: return LongTy; 2721 case TargetInfo::UnsignedLong: return UnsignedLongTy; 2722 case TargetInfo::SignedLongLong: return LongLongTy; 2723 case TargetInfo::UnsignedLongLong: return UnsignedLongLongTy; 2724 } 2725 2726 assert(false && "Unhandled TargetInfo::IntType value"); 2727 return QualType(); 2728} 2729 2730//===----------------------------------------------------------------------===// 2731// Type Predicates. 2732//===----------------------------------------------------------------------===// 2733 2734/// isObjCNSObjectType - Return true if this is an NSObject object using 2735/// NSObject attribute on a c-style pointer type. 2736/// FIXME - Make it work directly on types. 2737/// 2738bool ASTContext::isObjCNSObjectType(QualType Ty) const { 2739 if (TypedefType *TDT = dyn_cast<TypedefType>(Ty)) { 2740 if (TypedefDecl *TD = TDT->getDecl()) 2741 if (TD->getAttr<ObjCNSObjectAttr>()) 2742 return true; 2743 } 2744 return false; 2745} 2746 2747/// isObjCObjectPointerType - Returns true if type is an Objective-C pointer 2748/// to an object type. This includes "id" and "Class" (two 'special' pointers 2749/// to struct), Interface* (pointer to ObjCInterfaceType) and id<P> (qualified 2750/// ID type). 2751bool ASTContext::isObjCObjectPointerType(QualType Ty) const { 2752 if (Ty->isObjCQualifiedIdType()) 2753 return true; 2754 2755 // Blocks are objects. 2756 if (Ty->isBlockPointerType()) 2757 return true; 2758 2759 // All other object types are pointers. 2760 const PointerType *PT = Ty->getAsPointerType(); 2761 if (PT == 0) 2762 return false; 2763 2764 // If this a pointer to an interface (e.g. NSString*), it is ok. 2765 if (PT->getPointeeType()->isObjCInterfaceType() || 2766 // If is has NSObject attribute, OK as well. 2767 isObjCNSObjectType(Ty)) 2768 return true; 2769 2770 // Check to see if this is 'id' or 'Class', both of which are typedefs for 2771 // pointer types. This looks for the typedef specifically, not for the 2772 // underlying type. Iteratively strip off typedefs so that we can handle 2773 // typedefs of typedefs. 2774 while (TypedefType *TDT = dyn_cast<TypedefType>(Ty)) { 2775 if (Ty.getUnqualifiedType() == getObjCIdType() || 2776 Ty.getUnqualifiedType() == getObjCClassType()) 2777 return true; 2778 2779 Ty = TDT->getDecl()->getUnderlyingType(); 2780 } 2781 2782 return false; 2783} 2784 2785/// getObjCGCAttr - Returns one of GCNone, Weak or Strong objc's 2786/// garbage collection attribute. 2787/// 2788QualType::GCAttrTypes ASTContext::getObjCGCAttrKind(const QualType &Ty) const { 2789 QualType::GCAttrTypes GCAttrs = QualType::GCNone; 2790 if (getLangOptions().ObjC1 && 2791 getLangOptions().getGCMode() != LangOptions::NonGC) { 2792 GCAttrs = Ty.getObjCGCAttr(); 2793 // Default behavious under objective-c's gc is for objective-c pointers 2794 // (or pointers to them) be treated as though they were declared 2795 // as __strong. 2796 if (GCAttrs == QualType::GCNone) { 2797 if (isObjCObjectPointerType(Ty)) 2798 GCAttrs = QualType::Strong; 2799 else if (Ty->isPointerType()) 2800 return getObjCGCAttrKind(Ty->getAsPointerType()->getPointeeType()); 2801 } 2802 // Non-pointers have none gc'able attribute regardless of the attribute 2803 // set on them. 2804 else if (!isObjCObjectPointerType(Ty) && !Ty->isPointerType()) 2805 return QualType::GCNone; 2806 } 2807 return GCAttrs; 2808} 2809 2810//===----------------------------------------------------------------------===// 2811// Type Compatibility Testing 2812//===----------------------------------------------------------------------===// 2813 2814/// typesAreBlockCompatible - This routine is called when comparing two 2815/// block types. Types must be strictly compatible here. For example, 2816/// C unfortunately doesn't produce an error for the following: 2817/// 2818/// int (*emptyArgFunc)(); 2819/// int (*intArgList)(int) = emptyArgFunc; 2820/// 2821/// For blocks, we will produce an error for the following (similar to C++): 2822/// 2823/// int (^emptyArgBlock)(); 2824/// int (^intArgBlock)(int) = emptyArgBlock; 2825/// 2826/// FIXME: When the dust settles on this integration, fold this into mergeTypes. 2827/// 2828bool ASTContext::typesAreBlockCompatible(QualType lhs, QualType rhs) { 2829 const FunctionType *lbase = lhs->getAsFunctionType(); 2830 const FunctionType *rbase = rhs->getAsFunctionType(); 2831 const FunctionProtoType *lproto = dyn_cast<FunctionProtoType>(lbase); 2832 const FunctionProtoType *rproto = dyn_cast<FunctionProtoType>(rbase); 2833 if (lproto && rproto == 0) 2834 return false; 2835 return !mergeTypes(lhs, rhs).isNull(); 2836} 2837 2838/// areCompatVectorTypes - Return true if the two specified vector types are 2839/// compatible. 2840static bool areCompatVectorTypes(const VectorType *LHS, 2841 const VectorType *RHS) { 2842 assert(LHS->isCanonical() && RHS->isCanonical()); 2843 return LHS->getElementType() == RHS->getElementType() && 2844 LHS->getNumElements() == RHS->getNumElements(); 2845} 2846 2847/// canAssignObjCInterfaces - Return true if the two interface types are 2848/// compatible for assignment from RHS to LHS. This handles validation of any 2849/// protocol qualifiers on the LHS or RHS. 2850/// 2851bool ASTContext::canAssignObjCInterfaces(const ObjCInterfaceType *LHS, 2852 const ObjCInterfaceType *RHS) { 2853 // Verify that the base decls are compatible: the RHS must be a subclass of 2854 // the LHS. 2855 if (!LHS->getDecl()->isSuperClassOf(RHS->getDecl())) 2856 return false; 2857 2858 // RHS must have a superset of the protocols in the LHS. If the LHS is not 2859 // protocol qualified at all, then we are good. 2860 if (!isa<ObjCQualifiedInterfaceType>(LHS)) 2861 return true; 2862 2863 // Okay, we know the LHS has protocol qualifiers. If the RHS doesn't, then it 2864 // isn't a superset. 2865 if (!isa<ObjCQualifiedInterfaceType>(RHS)) 2866 return true; // FIXME: should return false! 2867 2868 // Finally, we must have two protocol-qualified interfaces. 2869 const ObjCQualifiedInterfaceType *LHSP =cast<ObjCQualifiedInterfaceType>(LHS); 2870 const ObjCQualifiedInterfaceType *RHSP =cast<ObjCQualifiedInterfaceType>(RHS); 2871 2872 // All LHS protocols must have a presence on the RHS. 2873 assert(LHSP->qual_begin() != LHSP->qual_end() && "Empty LHS protocol list?"); 2874 2875 for (ObjCQualifiedInterfaceType::qual_iterator LHSPI = LHSP->qual_begin(), 2876 LHSPE = LHSP->qual_end(); 2877 LHSPI != LHSPE; LHSPI++) { 2878 bool RHSImplementsProtocol = false; 2879 2880 // If the RHS doesn't implement the protocol on the left, the types 2881 // are incompatible. 2882 for (ObjCQualifiedInterfaceType::qual_iterator RHSPI = RHSP->qual_begin(), 2883 RHSPE = RHSP->qual_end(); 2884 !RHSImplementsProtocol && (RHSPI != RHSPE); RHSPI++) { 2885 if ((*RHSPI)->lookupProtocolNamed((*LHSPI)->getIdentifier())) 2886 RHSImplementsProtocol = true; 2887 } 2888 // FIXME: For better diagnostics, consider passing back the protocol name. 2889 if (!RHSImplementsProtocol) 2890 return false; 2891 } 2892 // The RHS implements all protocols listed on the LHS. 2893 return true; 2894} 2895 2896bool ASTContext::areComparableObjCPointerTypes(QualType LHS, QualType RHS) { 2897 // get the "pointed to" types 2898 const PointerType *LHSPT = LHS->getAsPointerType(); 2899 const PointerType *RHSPT = RHS->getAsPointerType(); 2900 2901 if (!LHSPT || !RHSPT) 2902 return false; 2903 2904 QualType lhptee = LHSPT->getPointeeType(); 2905 QualType rhptee = RHSPT->getPointeeType(); 2906 const ObjCInterfaceType* LHSIface = lhptee->getAsObjCInterfaceType(); 2907 const ObjCInterfaceType* RHSIface = rhptee->getAsObjCInterfaceType(); 2908 // ID acts sort of like void* for ObjC interfaces 2909 if (LHSIface && isObjCIdStructType(rhptee)) 2910 return true; 2911 if (RHSIface && isObjCIdStructType(lhptee)) 2912 return true; 2913 if (!LHSIface || !RHSIface) 2914 return false; 2915 return canAssignObjCInterfaces(LHSIface, RHSIface) || 2916 canAssignObjCInterfaces(RHSIface, LHSIface); 2917} 2918 2919/// typesAreCompatible - C99 6.7.3p9: For two qualified types to be compatible, 2920/// both shall have the identically qualified version of a compatible type. 2921/// C99 6.2.7p1: Two types have compatible types if their types are the 2922/// same. See 6.7.[2,3,5] for additional rules. 2923bool ASTContext::typesAreCompatible(QualType LHS, QualType RHS) { 2924 return !mergeTypes(LHS, RHS).isNull(); 2925} 2926 2927QualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs) { 2928 const FunctionType *lbase = lhs->getAsFunctionType(); 2929 const FunctionType *rbase = rhs->getAsFunctionType(); 2930 const FunctionProtoType *lproto = dyn_cast<FunctionProtoType>(lbase); 2931 const FunctionProtoType *rproto = dyn_cast<FunctionProtoType>(rbase); 2932 bool allLTypes = true; 2933 bool allRTypes = true; 2934 2935 // Check return type 2936 QualType retType = mergeTypes(lbase->getResultType(), rbase->getResultType()); 2937 if (retType.isNull()) return QualType(); 2938 if (getCanonicalType(retType) != getCanonicalType(lbase->getResultType())) 2939 allLTypes = false; 2940 if (getCanonicalType(retType) != getCanonicalType(rbase->getResultType())) 2941 allRTypes = false; 2942 2943 if (lproto && rproto) { // two C99 style function prototypes 2944 assert(!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec() && 2945 "C++ shouldn't be here"); 2946 unsigned lproto_nargs = lproto->getNumArgs(); 2947 unsigned rproto_nargs = rproto->getNumArgs(); 2948 2949 // Compatible functions must have the same number of arguments 2950 if (lproto_nargs != rproto_nargs) 2951 return QualType(); 2952 2953 // Variadic and non-variadic functions aren't compatible 2954 if (lproto->isVariadic() != rproto->isVariadic()) 2955 return QualType(); 2956 2957 if (lproto->getTypeQuals() != rproto->getTypeQuals()) 2958 return QualType(); 2959 2960 // Check argument compatibility 2961 llvm::SmallVector<QualType, 10> types; 2962 for (unsigned i = 0; i < lproto_nargs; i++) { 2963 QualType largtype = lproto->getArgType(i).getUnqualifiedType(); 2964 QualType rargtype = rproto->getArgType(i).getUnqualifiedType(); 2965 QualType argtype = mergeTypes(largtype, rargtype); 2966 if (argtype.isNull()) return QualType(); 2967 types.push_back(argtype); 2968 if (getCanonicalType(argtype) != getCanonicalType(largtype)) 2969 allLTypes = false; 2970 if (getCanonicalType(argtype) != getCanonicalType(rargtype)) 2971 allRTypes = false; 2972 } 2973 if (allLTypes) return lhs; 2974 if (allRTypes) return rhs; 2975 return getFunctionType(retType, types.begin(), types.size(), 2976 lproto->isVariadic(), lproto->getTypeQuals()); 2977 } 2978 2979 if (lproto) allRTypes = false; 2980 if (rproto) allLTypes = false; 2981 2982 const FunctionProtoType *proto = lproto ? lproto : rproto; 2983 if (proto) { 2984 assert(!proto->hasExceptionSpec() && "C++ shouldn't be here"); 2985 if (proto->isVariadic()) return QualType(); 2986 // Check that the types are compatible with the types that 2987 // would result from default argument promotions (C99 6.7.5.3p15). 2988 // The only types actually affected are promotable integer 2989 // types and floats, which would be passed as a different 2990 // type depending on whether the prototype is visible. 2991 unsigned proto_nargs = proto->getNumArgs(); 2992 for (unsigned i = 0; i < proto_nargs; ++i) { 2993 QualType argTy = proto->getArgType(i); 2994 if (argTy->isPromotableIntegerType() || 2995 getCanonicalType(argTy).getUnqualifiedType() == FloatTy) 2996 return QualType(); 2997 } 2998 2999 if (allLTypes) return lhs; 3000 if (allRTypes) return rhs; 3001 return getFunctionType(retType, proto->arg_type_begin(), 3002 proto->getNumArgs(), lproto->isVariadic(), 3003 lproto->getTypeQuals()); 3004 } 3005 3006 if (allLTypes) return lhs; 3007 if (allRTypes) return rhs; 3008 return getFunctionNoProtoType(retType); 3009} 3010 3011QualType ASTContext::mergeTypes(QualType LHS, QualType RHS) { 3012 // C++ [expr]: If an expression initially has the type "reference to T", the 3013 // type is adjusted to "T" prior to any further analysis, the expression 3014 // designates the object or function denoted by the reference, and the 3015 // expression is an lvalue unless the reference is an rvalue reference and 3016 // the expression is a function call (possibly inside parentheses). 3017 // FIXME: C++ shouldn't be going through here! The rules are different 3018 // enough that they should be handled separately. 3019 // FIXME: Merging of lvalue and rvalue references is incorrect. C++ *really* 3020 // shouldn't be going through here! 3021 if (const ReferenceType *RT = LHS->getAsReferenceType()) 3022 LHS = RT->getPointeeType(); 3023 if (const ReferenceType *RT = RHS->getAsReferenceType()) 3024 RHS = RT->getPointeeType(); 3025 3026 QualType LHSCan = getCanonicalType(LHS), 3027 RHSCan = getCanonicalType(RHS); 3028 3029 // If two types are identical, they are compatible. 3030 if (LHSCan == RHSCan) 3031 return LHS; 3032 3033 // If the qualifiers are different, the types aren't compatible 3034 // Note that we handle extended qualifiers later, in the 3035 // case for ExtQualType. 3036 if (LHSCan.getCVRQualifiers() != RHSCan.getCVRQualifiers()) 3037 return QualType(); 3038 3039 Type::TypeClass LHSClass = LHSCan.getUnqualifiedType()->getTypeClass(); 3040 Type::TypeClass RHSClass = RHSCan.getUnqualifiedType()->getTypeClass(); 3041 3042 // We want to consider the two function types to be the same for these 3043 // comparisons, just force one to the other. 3044 if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto; 3045 if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto; 3046 3047 // Same as above for arrays 3048 if (LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray) 3049 LHSClass = Type::ConstantArray; 3050 if (RHSClass == Type::VariableArray || RHSClass == Type::IncompleteArray) 3051 RHSClass = Type::ConstantArray; 3052 3053 // Canonicalize ExtVector -> Vector. 3054 if (LHSClass == Type::ExtVector) LHSClass = Type::Vector; 3055 if (RHSClass == Type::ExtVector) RHSClass = Type::Vector; 3056 3057 // Consider qualified interfaces and interfaces the same. 3058 if (LHSClass == Type::ObjCQualifiedInterface) LHSClass = Type::ObjCInterface; 3059 if (RHSClass == Type::ObjCQualifiedInterface) RHSClass = Type::ObjCInterface; 3060 3061 // If the canonical type classes don't match. 3062 if (LHSClass != RHSClass) { 3063 const ObjCInterfaceType* LHSIface = LHS->getAsObjCInterfaceType(); 3064 const ObjCInterfaceType* RHSIface = RHS->getAsObjCInterfaceType(); 3065 3066 // 'id' and 'Class' act sort of like void* for ObjC interfaces 3067 if (LHSIface && (isObjCIdStructType(RHS) || isObjCClassStructType(RHS))) 3068 return LHS; 3069 if (RHSIface && (isObjCIdStructType(LHS) || isObjCClassStructType(LHS))) 3070 return RHS; 3071 3072 // ID is compatible with all qualified id types. 3073 if (LHS->isObjCQualifiedIdType()) { 3074 if (const PointerType *PT = RHS->getAsPointerType()) { 3075 QualType pType = PT->getPointeeType(); 3076 if (isObjCIdStructType(pType) || isObjCClassStructType(pType)) 3077 return LHS; 3078 // FIXME: need to use ObjCQualifiedIdTypesAreCompatible(LHS, RHS, true). 3079 // Unfortunately, this API is part of Sema (which we don't have access 3080 // to. Need to refactor. The following check is insufficient, since we 3081 // need to make sure the class implements the protocol. 3082 if (pType->isObjCInterfaceType()) 3083 return LHS; 3084 } 3085 } 3086 if (RHS->isObjCQualifiedIdType()) { 3087 if (const PointerType *PT = LHS->getAsPointerType()) { 3088 QualType pType = PT->getPointeeType(); 3089 if (isObjCIdStructType(pType) || isObjCClassStructType(pType)) 3090 return RHS; 3091 // FIXME: need to use ObjCQualifiedIdTypesAreCompatible(LHS, RHS, true). 3092 // Unfortunately, this API is part of Sema (which we don't have access 3093 // to. Need to refactor. The following check is insufficient, since we 3094 // need to make sure the class implements the protocol. 3095 if (pType->isObjCInterfaceType()) 3096 return RHS; 3097 } 3098 } 3099 // C99 6.7.2.2p4: Each enumerated type shall be compatible with char, 3100 // a signed integer type, or an unsigned integer type. 3101 if (const EnumType* ETy = LHS->getAsEnumType()) { 3102 if (ETy->getDecl()->getIntegerType() == RHSCan.getUnqualifiedType()) 3103 return RHS; 3104 } 3105 if (const EnumType* ETy = RHS->getAsEnumType()) { 3106 if (ETy->getDecl()->getIntegerType() == LHSCan.getUnqualifiedType()) 3107 return LHS; 3108 } 3109 3110 return QualType(); 3111 } 3112 3113 // The canonical type classes match. 3114 switch (LHSClass) { 3115#define TYPE(Class, Base) 3116#define ABSTRACT_TYPE(Class, Base) 3117#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 3118#define DEPENDENT_TYPE(Class, Base) case Type::Class: 3119#include "clang/AST/TypeNodes.def" 3120 assert(false && "Non-canonical and dependent types shouldn't get here"); 3121 return QualType(); 3122 3123 case Type::LValueReference: 3124 case Type::RValueReference: 3125 case Type::MemberPointer: 3126 assert(false && "C++ should never be in mergeTypes"); 3127 return QualType(); 3128 3129 case Type::IncompleteArray: 3130 case Type::VariableArray: 3131 case Type::FunctionProto: 3132 case Type::ExtVector: 3133 case Type::ObjCQualifiedInterface: 3134 assert(false && "Types are eliminated above"); 3135 return QualType(); 3136 3137 case Type::Pointer: 3138 { 3139 // Merge two pointer types, while trying to preserve typedef info 3140 QualType LHSPointee = LHS->getAsPointerType()->getPointeeType(); 3141 QualType RHSPointee = RHS->getAsPointerType()->getPointeeType(); 3142 QualType ResultType = mergeTypes(LHSPointee, RHSPointee); 3143 if (ResultType.isNull()) return QualType(); 3144 if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType)) 3145 return LHS; 3146 if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType)) 3147 return RHS; 3148 return getPointerType(ResultType); 3149 } 3150 case Type::BlockPointer: 3151 { 3152 // Merge two block pointer types, while trying to preserve typedef info 3153 QualType LHSPointee = LHS->getAsBlockPointerType()->getPointeeType(); 3154 QualType RHSPointee = RHS->getAsBlockPointerType()->getPointeeType(); 3155 QualType ResultType = mergeTypes(LHSPointee, RHSPointee); 3156 if (ResultType.isNull()) return QualType(); 3157 if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType)) 3158 return LHS; 3159 if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType)) 3160 return RHS; 3161 return getBlockPointerType(ResultType); 3162 } 3163 case Type::ConstantArray: 3164 { 3165 const ConstantArrayType* LCAT = getAsConstantArrayType(LHS); 3166 const ConstantArrayType* RCAT = getAsConstantArrayType(RHS); 3167 if (LCAT && RCAT && RCAT->getSize() != LCAT->getSize()) 3168 return QualType(); 3169 3170 QualType LHSElem = getAsArrayType(LHS)->getElementType(); 3171 QualType RHSElem = getAsArrayType(RHS)->getElementType(); 3172 QualType ResultType = mergeTypes(LHSElem, RHSElem); 3173 if (ResultType.isNull()) return QualType(); 3174 if (LCAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType)) 3175 return LHS; 3176 if (RCAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType)) 3177 return RHS; 3178 if (LCAT) return getConstantArrayType(ResultType, LCAT->getSize(), 3179 ArrayType::ArraySizeModifier(), 0); 3180 if (RCAT) return getConstantArrayType(ResultType, RCAT->getSize(), 3181 ArrayType::ArraySizeModifier(), 0); 3182 const VariableArrayType* LVAT = getAsVariableArrayType(LHS); 3183 const VariableArrayType* RVAT = getAsVariableArrayType(RHS); 3184 if (LVAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType)) 3185 return LHS; 3186 if (RVAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType)) 3187 return RHS; 3188 if (LVAT) { 3189 // FIXME: This isn't correct! But tricky to implement because 3190 // the array's size has to be the size of LHS, but the type 3191 // has to be different. 3192 return LHS; 3193 } 3194 if (RVAT) { 3195 // FIXME: This isn't correct! But tricky to implement because 3196 // the array's size has to be the size of RHS, but the type 3197 // has to be different. 3198 return RHS; 3199 } 3200 if (getCanonicalType(LHSElem) == getCanonicalType(ResultType)) return LHS; 3201 if (getCanonicalType(RHSElem) == getCanonicalType(ResultType)) return RHS; 3202 return getIncompleteArrayType(ResultType, ArrayType::ArraySizeModifier(),0); 3203 } 3204 case Type::FunctionNoProto: 3205 return mergeFunctionTypes(LHS, RHS); 3206 case Type::Record: 3207 case Type::Enum: 3208 // FIXME: Why are these compatible? 3209 if (isObjCIdStructType(LHS) && isObjCClassStructType(RHS)) return LHS; 3210 if (isObjCClassStructType(LHS) && isObjCIdStructType(RHS)) return LHS; 3211 return QualType(); 3212 case Type::Builtin: 3213 // Only exactly equal builtin types are compatible, which is tested above. 3214 return QualType(); 3215 case Type::Complex: 3216 // Distinct complex types are incompatible. 3217 return QualType(); 3218 case Type::Vector: 3219 // FIXME: The merged type should be an ExtVector! 3220 if (areCompatVectorTypes(LHS->getAsVectorType(), RHS->getAsVectorType())) 3221 return LHS; 3222 return QualType(); 3223 case Type::ObjCInterface: { 3224 // Check if the interfaces are assignment compatible. 3225 // FIXME: This should be type compatibility, e.g. whether 3226 // "LHS x; RHS x;" at global scope is legal. 3227 const ObjCInterfaceType* LHSIface = LHS->getAsObjCInterfaceType(); 3228 const ObjCInterfaceType* RHSIface = RHS->getAsObjCInterfaceType(); 3229 if (LHSIface && RHSIface && 3230 canAssignObjCInterfaces(LHSIface, RHSIface)) 3231 return LHS; 3232 3233 return QualType(); 3234 } 3235 case Type::ObjCQualifiedId: 3236 // Distinct qualified id's are not compatible. 3237 return QualType(); 3238 case Type::FixedWidthInt: 3239 // Distinct fixed-width integers are not compatible. 3240 return QualType(); 3241 case Type::ExtQual: 3242 // FIXME: ExtQual types can be compatible even if they're not 3243 // identical! 3244 return QualType(); 3245 // First attempt at an implementation, but I'm not really sure it's 3246 // right... 3247#if 0 3248 ExtQualType* LQual = cast<ExtQualType>(LHSCan); 3249 ExtQualType* RQual = cast<ExtQualType>(RHSCan); 3250 if (LQual->getAddressSpace() != RQual->getAddressSpace() || 3251 LQual->getObjCGCAttr() != RQual->getObjCGCAttr()) 3252 return QualType(); 3253 QualType LHSBase, RHSBase, ResultType, ResCanUnqual; 3254 LHSBase = QualType(LQual->getBaseType(), 0); 3255 RHSBase = QualType(RQual->getBaseType(), 0); 3256 ResultType = mergeTypes(LHSBase, RHSBase); 3257 if (ResultType.isNull()) return QualType(); 3258 ResCanUnqual = getCanonicalType(ResultType).getUnqualifiedType(); 3259 if (LHSCan.getUnqualifiedType() == ResCanUnqual) 3260 return LHS; 3261 if (RHSCan.getUnqualifiedType() == ResCanUnqual) 3262 return RHS; 3263 ResultType = getAddrSpaceQualType(ResultType, LQual->getAddressSpace()); 3264 ResultType = getObjCGCQualType(ResultType, LQual->getObjCGCAttr()); 3265 ResultType.setCVRQualifiers(LHSCan.getCVRQualifiers()); 3266 return ResultType; 3267#endif 3268 3269 case Type::TemplateSpecialization: 3270 assert(false && "Dependent types have no size"); 3271 break; 3272 } 3273 3274 return QualType(); 3275} 3276 3277//===----------------------------------------------------------------------===// 3278// Integer Predicates 3279//===----------------------------------------------------------------------===// 3280 3281unsigned ASTContext::getIntWidth(QualType T) { 3282 if (T == BoolTy) 3283 return 1; 3284 if (FixedWidthIntType* FWIT = dyn_cast<FixedWidthIntType>(T)) { 3285 return FWIT->getWidth(); 3286 } 3287 // For builtin types, just use the standard type sizing method 3288 return (unsigned)getTypeSize(T); 3289} 3290 3291QualType ASTContext::getCorrespondingUnsignedType(QualType T) { 3292 assert(T->isSignedIntegerType() && "Unexpected type"); 3293 if (const EnumType* ETy = T->getAsEnumType()) 3294 T = ETy->getDecl()->getIntegerType(); 3295 const BuiltinType* BTy = T->getAsBuiltinType(); 3296 assert (BTy && "Unexpected signed integer type"); 3297 switch (BTy->getKind()) { 3298 case BuiltinType::Char_S: 3299 case BuiltinType::SChar: 3300 return UnsignedCharTy; 3301 case BuiltinType::Short: 3302 return UnsignedShortTy; 3303 case BuiltinType::Int: 3304 return UnsignedIntTy; 3305 case BuiltinType::Long: 3306 return UnsignedLongTy; 3307 case BuiltinType::LongLong: 3308 return UnsignedLongLongTy; 3309 case BuiltinType::Int128: 3310 return UnsignedInt128Ty; 3311 default: 3312 assert(0 && "Unexpected signed integer type"); 3313 return QualType(); 3314 } 3315} 3316 3317ExternalASTSource::~ExternalASTSource() { } 3318 3319void ExternalASTSource::PrintStats() { } 3320