ASTContext.cpp revision 212904
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/CharUnits.h" 16#include "clang/AST/DeclCXX.h" 17#include "clang/AST/DeclObjC.h" 18#include "clang/AST/DeclTemplate.h" 19#include "clang/AST/TypeLoc.h" 20#include "clang/AST/Expr.h" 21#include "clang/AST/ExprCXX.h" 22#include "clang/AST/ExternalASTSource.h" 23#include "clang/AST/RecordLayout.h" 24#include "clang/Basic/Builtins.h" 25#include "clang/Basic/SourceManager.h" 26#include "clang/Basic/TargetInfo.h" 27#include "llvm/ADT/SmallString.h" 28#include "llvm/ADT/StringExtras.h" 29#include "llvm/Support/MathExtras.h" 30#include "llvm/Support/raw_ostream.h" 31#include "CXXABI.h" 32 33using namespace clang; 34 35unsigned ASTContext::NumImplicitDefaultConstructors; 36unsigned ASTContext::NumImplicitDefaultConstructorsDeclared; 37unsigned ASTContext::NumImplicitCopyConstructors; 38unsigned ASTContext::NumImplicitCopyConstructorsDeclared; 39unsigned ASTContext::NumImplicitCopyAssignmentOperators; 40unsigned ASTContext::NumImplicitCopyAssignmentOperatorsDeclared; 41unsigned ASTContext::NumImplicitDestructors; 42unsigned ASTContext::NumImplicitDestructorsDeclared; 43 44enum FloatingRank { 45 FloatRank, DoubleRank, LongDoubleRank 46}; 47 48void 49ASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &ID, 50 TemplateTemplateParmDecl *Parm) { 51 ID.AddInteger(Parm->getDepth()); 52 ID.AddInteger(Parm->getPosition()); 53 // FIXME: Parameter pack 54 55 TemplateParameterList *Params = Parm->getTemplateParameters(); 56 ID.AddInteger(Params->size()); 57 for (TemplateParameterList::const_iterator P = Params->begin(), 58 PEnd = Params->end(); 59 P != PEnd; ++P) { 60 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) { 61 ID.AddInteger(0); 62 ID.AddBoolean(TTP->isParameterPack()); 63 continue; 64 } 65 66 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) { 67 ID.AddInteger(1); 68 // FIXME: Parameter pack 69 ID.AddPointer(NTTP->getType().getAsOpaquePtr()); 70 continue; 71 } 72 73 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P); 74 ID.AddInteger(2); 75 Profile(ID, TTP); 76 } 77} 78 79TemplateTemplateParmDecl * 80ASTContext::getCanonicalTemplateTemplateParmDecl( 81 TemplateTemplateParmDecl *TTP) { 82 // Check if we already have a canonical template template parameter. 83 llvm::FoldingSetNodeID ID; 84 CanonicalTemplateTemplateParm::Profile(ID, TTP); 85 void *InsertPos = 0; 86 CanonicalTemplateTemplateParm *Canonical 87 = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos); 88 if (Canonical) 89 return Canonical->getParam(); 90 91 // Build a canonical template parameter list. 92 TemplateParameterList *Params = TTP->getTemplateParameters(); 93 llvm::SmallVector<NamedDecl *, 4> CanonParams; 94 CanonParams.reserve(Params->size()); 95 for (TemplateParameterList::const_iterator P = Params->begin(), 96 PEnd = Params->end(); 97 P != PEnd; ++P) { 98 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) 99 CanonParams.push_back( 100 TemplateTypeParmDecl::Create(*this, getTranslationUnitDecl(), 101 SourceLocation(), TTP->getDepth(), 102 TTP->getIndex(), 0, false, 103 TTP->isParameterPack())); 104 else if (NonTypeTemplateParmDecl *NTTP 105 = dyn_cast<NonTypeTemplateParmDecl>(*P)) 106 CanonParams.push_back( 107 NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(), 108 SourceLocation(), NTTP->getDepth(), 109 NTTP->getPosition(), 0, 110 getCanonicalType(NTTP->getType()), 111 0)); 112 else 113 CanonParams.push_back(getCanonicalTemplateTemplateParmDecl( 114 cast<TemplateTemplateParmDecl>(*P))); 115 } 116 117 TemplateTemplateParmDecl *CanonTTP 118 = TemplateTemplateParmDecl::Create(*this, getTranslationUnitDecl(), 119 SourceLocation(), TTP->getDepth(), 120 TTP->getPosition(), 0, 121 TemplateParameterList::Create(*this, SourceLocation(), 122 SourceLocation(), 123 CanonParams.data(), 124 CanonParams.size(), 125 SourceLocation())); 126 127 // Get the new insert position for the node we care about. 128 Canonical = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos); 129 assert(Canonical == 0 && "Shouldn't be in the map!"); 130 (void)Canonical; 131 132 // Create the canonical template template parameter entry. 133 Canonical = new (*this) CanonicalTemplateTemplateParm(CanonTTP); 134 CanonTemplateTemplateParms.InsertNode(Canonical, InsertPos); 135 return CanonTTP; 136} 137 138CXXABI *ASTContext::createCXXABI(const TargetInfo &T) { 139 if (!LangOpts.CPlusPlus) return 0; 140 141 switch (T.getCXXABI()) { 142 case CXXABI_ARM: 143 return CreateARMCXXABI(*this); 144 case CXXABI_Itanium: 145 return CreateItaniumCXXABI(*this); 146 case CXXABI_Microsoft: 147 return CreateMicrosoftCXXABI(*this); 148 } 149 return 0; 150} 151 152ASTContext::ASTContext(const LangOptions& LOpts, SourceManager &SM, 153 const TargetInfo &t, 154 IdentifierTable &idents, SelectorTable &sels, 155 Builtin::Context &builtins, 156 unsigned size_reserve) : 157 TemplateSpecializationTypes(this_()), 158 DependentTemplateSpecializationTypes(this_()), 159 GlobalNestedNameSpecifier(0), IsInt128Installed(false), 160 CFConstantStringTypeDecl(0), NSConstantStringTypeDecl(0), 161 ObjCFastEnumerationStateTypeDecl(0), FILEDecl(0), jmp_bufDecl(0), 162 sigjmp_bufDecl(0), BlockDescriptorType(0), BlockDescriptorExtendedType(0), 163 NullTypeSourceInfo(QualType()), 164 SourceMgr(SM), LangOpts(LOpts), ABI(createCXXABI(t)), Target(t), 165 Idents(idents), Selectors(sels), 166 BuiltinInfo(builtins), 167 DeclarationNames(*this), 168 ExternalSource(0), PrintingPolicy(LOpts), 169 LastSDM(0, 0), 170 UniqueBlockByRefTypeID(0), UniqueBlockParmTypeID(0) { 171 ObjCIdRedefinitionType = QualType(); 172 ObjCClassRedefinitionType = QualType(); 173 ObjCSelRedefinitionType = QualType(); 174 if (size_reserve > 0) Types.reserve(size_reserve); 175 TUDecl = TranslationUnitDecl::Create(*this); 176 InitBuiltinTypes(); 177} 178 179ASTContext::~ASTContext() { 180 // Release the DenseMaps associated with DeclContext objects. 181 // FIXME: Is this the ideal solution? 182 ReleaseDeclContextMaps(); 183 184 // Call all of the deallocation functions. 185 for (unsigned I = 0, N = Deallocations.size(); I != N; ++I) 186 Deallocations[I].first(Deallocations[I].second); 187 188 // Release all of the memory associated with overridden C++ methods. 189 for (llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::iterator 190 OM = OverriddenMethods.begin(), OMEnd = OverriddenMethods.end(); 191 OM != OMEnd; ++OM) 192 OM->second.Destroy(); 193 194 // ASTRecordLayout objects in ASTRecordLayouts must always be destroyed 195 // because they can contain DenseMaps. 196 for (llvm::DenseMap<const ObjCContainerDecl*, 197 const ASTRecordLayout*>::iterator 198 I = ObjCLayouts.begin(), E = ObjCLayouts.end(); I != E; ) 199 // Increment in loop to prevent using deallocated memory. 200 if (ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second)) 201 R->Destroy(*this); 202 203 for (llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator 204 I = ASTRecordLayouts.begin(), E = ASTRecordLayouts.end(); I != E; ) { 205 // Increment in loop to prevent using deallocated memory. 206 if (ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second)) 207 R->Destroy(*this); 208 } 209 210 for (llvm::DenseMap<const Decl*, AttrVec*>::iterator A = DeclAttrs.begin(), 211 AEnd = DeclAttrs.end(); 212 A != AEnd; ++A) 213 A->second->~AttrVec(); 214} 215 216void ASTContext::AddDeallocation(void (*Callback)(void*), void *Data) { 217 Deallocations.push_back(std::make_pair(Callback, Data)); 218} 219 220void 221ASTContext::setExternalSource(llvm::OwningPtr<ExternalASTSource> &Source) { 222 ExternalSource.reset(Source.take()); 223} 224 225void ASTContext::PrintStats() const { 226 fprintf(stderr, "*** AST Context Stats:\n"); 227 fprintf(stderr, " %d types total.\n", (int)Types.size()); 228 229 unsigned counts[] = { 230#define TYPE(Name, Parent) 0, 231#define ABSTRACT_TYPE(Name, Parent) 232#include "clang/AST/TypeNodes.def" 233 0 // Extra 234 }; 235 236 for (unsigned i = 0, e = Types.size(); i != e; ++i) { 237 Type *T = Types[i]; 238 counts[(unsigned)T->getTypeClass()]++; 239 } 240 241 unsigned Idx = 0; 242 unsigned TotalBytes = 0; 243#define TYPE(Name, Parent) \ 244 if (counts[Idx]) \ 245 fprintf(stderr, " %d %s types\n", (int)counts[Idx], #Name); \ 246 TotalBytes += counts[Idx] * sizeof(Name##Type); \ 247 ++Idx; 248#define ABSTRACT_TYPE(Name, Parent) 249#include "clang/AST/TypeNodes.def" 250 251 fprintf(stderr, "Total bytes = %d\n", int(TotalBytes)); 252 253 // Implicit special member functions. 254 fprintf(stderr, " %u/%u implicit default constructors created\n", 255 NumImplicitDefaultConstructorsDeclared, 256 NumImplicitDefaultConstructors); 257 fprintf(stderr, " %u/%u implicit copy constructors created\n", 258 NumImplicitCopyConstructorsDeclared, 259 NumImplicitCopyConstructors); 260 fprintf(stderr, " %u/%u implicit copy assignment operators created\n", 261 NumImplicitCopyAssignmentOperatorsDeclared, 262 NumImplicitCopyAssignmentOperators); 263 fprintf(stderr, " %u/%u implicit destructors created\n", 264 NumImplicitDestructorsDeclared, NumImplicitDestructors); 265 266 if (ExternalSource.get()) { 267 fprintf(stderr, "\n"); 268 ExternalSource->PrintStats(); 269 } 270 271 BumpAlloc.PrintStats(); 272} 273 274 275void ASTContext::InitBuiltinType(CanQualType &R, BuiltinType::Kind K) { 276 BuiltinType *Ty = new (*this, TypeAlignment) BuiltinType(K); 277 R = CanQualType::CreateUnsafe(QualType(Ty, 0)); 278 Types.push_back(Ty); 279} 280 281void ASTContext::InitBuiltinTypes() { 282 assert(VoidTy.isNull() && "Context reinitialized?"); 283 284 // C99 6.2.5p19. 285 InitBuiltinType(VoidTy, BuiltinType::Void); 286 287 // C99 6.2.5p2. 288 InitBuiltinType(BoolTy, BuiltinType::Bool); 289 // C99 6.2.5p3. 290 if (LangOpts.CharIsSigned) 291 InitBuiltinType(CharTy, BuiltinType::Char_S); 292 else 293 InitBuiltinType(CharTy, BuiltinType::Char_U); 294 // C99 6.2.5p4. 295 InitBuiltinType(SignedCharTy, BuiltinType::SChar); 296 InitBuiltinType(ShortTy, BuiltinType::Short); 297 InitBuiltinType(IntTy, BuiltinType::Int); 298 InitBuiltinType(LongTy, BuiltinType::Long); 299 InitBuiltinType(LongLongTy, BuiltinType::LongLong); 300 301 // C99 6.2.5p6. 302 InitBuiltinType(UnsignedCharTy, BuiltinType::UChar); 303 InitBuiltinType(UnsignedShortTy, BuiltinType::UShort); 304 InitBuiltinType(UnsignedIntTy, BuiltinType::UInt); 305 InitBuiltinType(UnsignedLongTy, BuiltinType::ULong); 306 InitBuiltinType(UnsignedLongLongTy, BuiltinType::ULongLong); 307 308 // C99 6.2.5p10. 309 InitBuiltinType(FloatTy, BuiltinType::Float); 310 InitBuiltinType(DoubleTy, BuiltinType::Double); 311 InitBuiltinType(LongDoubleTy, BuiltinType::LongDouble); 312 313 // GNU extension, 128-bit integers. 314 InitBuiltinType(Int128Ty, BuiltinType::Int128); 315 InitBuiltinType(UnsignedInt128Ty, BuiltinType::UInt128); 316 317 if (LangOpts.CPlusPlus) // C++ 3.9.1p5 318 InitBuiltinType(WCharTy, BuiltinType::WChar); 319 else // C99 320 WCharTy = getFromTargetType(Target.getWCharType()); 321 322 if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++ 323 InitBuiltinType(Char16Ty, BuiltinType::Char16); 324 else // C99 325 Char16Ty = getFromTargetType(Target.getChar16Type()); 326 327 if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++ 328 InitBuiltinType(Char32Ty, BuiltinType::Char32); 329 else // C99 330 Char32Ty = getFromTargetType(Target.getChar32Type()); 331 332 // Placeholder type for functions. 333 InitBuiltinType(OverloadTy, BuiltinType::Overload); 334 335 // Placeholder type for type-dependent expressions whose type is 336 // completely unknown. No code should ever check a type against 337 // DependentTy and users should never see it; however, it is here to 338 // help diagnose failures to properly check for type-dependent 339 // expressions. 340 InitBuiltinType(DependentTy, BuiltinType::Dependent); 341 342 // Placeholder type for C++0x auto declarations whose real type has 343 // not yet been deduced. 344 InitBuiltinType(UndeducedAutoTy, BuiltinType::UndeducedAuto); 345 346 // C99 6.2.5p11. 347 FloatComplexTy = getComplexType(FloatTy); 348 DoubleComplexTy = getComplexType(DoubleTy); 349 LongDoubleComplexTy = getComplexType(LongDoubleTy); 350 351 BuiltinVaListType = QualType(); 352 353 // "Builtin" typedefs set by Sema::ActOnTranslationUnitScope(). 354 ObjCIdTypedefType = QualType(); 355 ObjCClassTypedefType = QualType(); 356 ObjCSelTypedefType = QualType(); 357 358 // Builtin types for 'id', 'Class', and 'SEL'. 359 InitBuiltinType(ObjCBuiltinIdTy, BuiltinType::ObjCId); 360 InitBuiltinType(ObjCBuiltinClassTy, BuiltinType::ObjCClass); 361 InitBuiltinType(ObjCBuiltinSelTy, BuiltinType::ObjCSel); 362 363 ObjCConstantStringType = QualType(); 364 365 // void * type 366 VoidPtrTy = getPointerType(VoidTy); 367 368 // nullptr type (C++0x 2.14.7) 369 InitBuiltinType(NullPtrTy, BuiltinType::NullPtr); 370} 371 372AttrVec& ASTContext::getDeclAttrs(const Decl *D) { 373 AttrVec *&Result = DeclAttrs[D]; 374 if (!Result) { 375 void *Mem = Allocate(sizeof(AttrVec)); 376 Result = new (Mem) AttrVec; 377 } 378 379 return *Result; 380} 381 382/// \brief Erase the attributes corresponding to the given declaration. 383void ASTContext::eraseDeclAttrs(const Decl *D) { 384 llvm::DenseMap<const Decl*, AttrVec*>::iterator Pos = DeclAttrs.find(D); 385 if (Pos != DeclAttrs.end()) { 386 Pos->second->~AttrVec(); 387 DeclAttrs.erase(Pos); 388 } 389} 390 391 392MemberSpecializationInfo * 393ASTContext::getInstantiatedFromStaticDataMember(const VarDecl *Var) { 394 assert(Var->isStaticDataMember() && "Not a static data member"); 395 llvm::DenseMap<const VarDecl *, MemberSpecializationInfo *>::iterator Pos 396 = InstantiatedFromStaticDataMember.find(Var); 397 if (Pos == InstantiatedFromStaticDataMember.end()) 398 return 0; 399 400 return Pos->second; 401} 402 403void 404ASTContext::setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl, 405 TemplateSpecializationKind TSK, 406 SourceLocation PointOfInstantiation) { 407 assert(Inst->isStaticDataMember() && "Not a static data member"); 408 assert(Tmpl->isStaticDataMember() && "Not a static data member"); 409 assert(!InstantiatedFromStaticDataMember[Inst] && 410 "Already noted what static data member was instantiated from"); 411 InstantiatedFromStaticDataMember[Inst] 412 = new (*this) MemberSpecializationInfo(Tmpl, TSK, PointOfInstantiation); 413} 414 415NamedDecl * 416ASTContext::getInstantiatedFromUsingDecl(UsingDecl *UUD) { 417 llvm::DenseMap<UsingDecl *, NamedDecl *>::const_iterator Pos 418 = InstantiatedFromUsingDecl.find(UUD); 419 if (Pos == InstantiatedFromUsingDecl.end()) 420 return 0; 421 422 return Pos->second; 423} 424 425void 426ASTContext::setInstantiatedFromUsingDecl(UsingDecl *Inst, NamedDecl *Pattern) { 427 assert((isa<UsingDecl>(Pattern) || 428 isa<UnresolvedUsingValueDecl>(Pattern) || 429 isa<UnresolvedUsingTypenameDecl>(Pattern)) && 430 "pattern decl is not a using decl"); 431 assert(!InstantiatedFromUsingDecl[Inst] && "pattern already exists"); 432 InstantiatedFromUsingDecl[Inst] = Pattern; 433} 434 435UsingShadowDecl * 436ASTContext::getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst) { 437 llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>::const_iterator Pos 438 = InstantiatedFromUsingShadowDecl.find(Inst); 439 if (Pos == InstantiatedFromUsingShadowDecl.end()) 440 return 0; 441 442 return Pos->second; 443} 444 445void 446ASTContext::setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst, 447 UsingShadowDecl *Pattern) { 448 assert(!InstantiatedFromUsingShadowDecl[Inst] && "pattern already exists"); 449 InstantiatedFromUsingShadowDecl[Inst] = Pattern; 450} 451 452FieldDecl *ASTContext::getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field) { 453 llvm::DenseMap<FieldDecl *, FieldDecl *>::iterator Pos 454 = InstantiatedFromUnnamedFieldDecl.find(Field); 455 if (Pos == InstantiatedFromUnnamedFieldDecl.end()) 456 return 0; 457 458 return Pos->second; 459} 460 461void ASTContext::setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, 462 FieldDecl *Tmpl) { 463 assert(!Inst->getDeclName() && "Instantiated field decl is not unnamed"); 464 assert(!Tmpl->getDeclName() && "Template field decl is not unnamed"); 465 assert(!InstantiatedFromUnnamedFieldDecl[Inst] && 466 "Already noted what unnamed field was instantiated from"); 467 468 InstantiatedFromUnnamedFieldDecl[Inst] = Tmpl; 469} 470 471ASTContext::overridden_cxx_method_iterator 472ASTContext::overridden_methods_begin(const CXXMethodDecl *Method) const { 473 llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos 474 = OverriddenMethods.find(Method); 475 if (Pos == OverriddenMethods.end()) 476 return 0; 477 478 return Pos->second.begin(); 479} 480 481ASTContext::overridden_cxx_method_iterator 482ASTContext::overridden_methods_end(const CXXMethodDecl *Method) const { 483 llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos 484 = OverriddenMethods.find(Method); 485 if (Pos == OverriddenMethods.end()) 486 return 0; 487 488 return Pos->second.end(); 489} 490 491unsigned 492ASTContext::overridden_methods_size(const CXXMethodDecl *Method) const { 493 llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos 494 = OverriddenMethods.find(Method); 495 if (Pos == OverriddenMethods.end()) 496 return 0; 497 498 return Pos->second.size(); 499} 500 501void ASTContext::addOverriddenMethod(const CXXMethodDecl *Method, 502 const CXXMethodDecl *Overridden) { 503 OverriddenMethods[Method].push_back(Overridden); 504} 505 506//===----------------------------------------------------------------------===// 507// Type Sizing and Analysis 508//===----------------------------------------------------------------------===// 509 510/// getFloatTypeSemantics - Return the APFloat 'semantics' for the specified 511/// scalar floating point type. 512const llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const { 513 const BuiltinType *BT = T->getAs<BuiltinType>(); 514 assert(BT && "Not a floating point type!"); 515 switch (BT->getKind()) { 516 default: assert(0 && "Not a floating point type!"); 517 case BuiltinType::Float: return Target.getFloatFormat(); 518 case BuiltinType::Double: return Target.getDoubleFormat(); 519 case BuiltinType::LongDouble: return Target.getLongDoubleFormat(); 520 } 521} 522 523/// getDeclAlign - Return a conservative estimate of the alignment of the 524/// specified decl. Note that bitfields do not have a valid alignment, so 525/// this method will assert on them. 526/// If @p RefAsPointee, references are treated like their underlying type 527/// (for alignof), else they're treated like pointers (for CodeGen). 528CharUnits ASTContext::getDeclAlign(const Decl *D, bool RefAsPointee) { 529 unsigned Align = Target.getCharWidth(); 530 531 Align = std::max(Align, D->getMaxAlignment()); 532 533 if (const ValueDecl *VD = dyn_cast<ValueDecl>(D)) { 534 QualType T = VD->getType(); 535 if (const ReferenceType* RT = T->getAs<ReferenceType>()) { 536 if (RefAsPointee) 537 T = RT->getPointeeType(); 538 else 539 T = getPointerType(RT->getPointeeType()); 540 } 541 if (!T->isIncompleteType() && !T->isFunctionType()) { 542 unsigned MinWidth = Target.getLargeArrayMinWidth(); 543 unsigned ArrayAlign = Target.getLargeArrayAlign(); 544 if (isa<VariableArrayType>(T) && MinWidth != 0) 545 Align = std::max(Align, ArrayAlign); 546 if (ConstantArrayType *CT = dyn_cast<ConstantArrayType>(T)) { 547 unsigned Size = getTypeSize(CT); 548 if (MinWidth != 0 && MinWidth <= Size) 549 Align = std::max(Align, ArrayAlign); 550 } 551 // Incomplete or function types default to 1. 552 while (isa<VariableArrayType>(T) || isa<IncompleteArrayType>(T)) 553 T = cast<ArrayType>(T)->getElementType(); 554 555 Align = std::max(Align, getPreferredTypeAlign(T.getTypePtr())); 556 } 557 if (const FieldDecl *FD = dyn_cast<FieldDecl>(VD)) { 558 // In the case of a field in a packed struct, we want the minimum 559 // of the alignment of the field and the alignment of the struct. 560 Align = std::min(Align, 561 getPreferredTypeAlign(FD->getParent()->getTypeForDecl())); 562 } 563 } 564 565 return CharUnits::fromQuantity(Align / Target.getCharWidth()); 566} 567 568std::pair<CharUnits, CharUnits> 569ASTContext::getTypeInfoInChars(const Type *T) { 570 std::pair<uint64_t, unsigned> Info = getTypeInfo(T); 571 return std::make_pair(CharUnits::fromQuantity(Info.first / getCharWidth()), 572 CharUnits::fromQuantity(Info.second / getCharWidth())); 573} 574 575std::pair<CharUnits, CharUnits> 576ASTContext::getTypeInfoInChars(QualType T) { 577 return getTypeInfoInChars(T.getTypePtr()); 578} 579 580/// getTypeSize - Return the size of the specified type, in bits. This method 581/// does not work on incomplete types. 582/// 583/// FIXME: Pointers into different addr spaces could have different sizes and 584/// alignment requirements: getPointerInfo should take an AddrSpace, this 585/// should take a QualType, &c. 586std::pair<uint64_t, unsigned> 587ASTContext::getTypeInfo(const Type *T) { 588 uint64_t Width=0; 589 unsigned Align=8; 590 switch (T->getTypeClass()) { 591#define TYPE(Class, Base) 592#define ABSTRACT_TYPE(Class, Base) 593#define NON_CANONICAL_TYPE(Class, Base) 594#define DEPENDENT_TYPE(Class, Base) case Type::Class: 595#include "clang/AST/TypeNodes.def" 596 assert(false && "Should not see dependent types"); 597 break; 598 599 case Type::FunctionNoProto: 600 case Type::FunctionProto: 601 // GCC extension: alignof(function) = 32 bits 602 Width = 0; 603 Align = 32; 604 break; 605 606 case Type::IncompleteArray: 607 case Type::VariableArray: 608 Width = 0; 609 Align = getTypeAlign(cast<ArrayType>(T)->getElementType()); 610 break; 611 612 case Type::ConstantArray: { 613 const ConstantArrayType *CAT = cast<ConstantArrayType>(T); 614 615 std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(CAT->getElementType()); 616 Width = EltInfo.first*CAT->getSize().getZExtValue(); 617 Align = EltInfo.second; 618 break; 619 } 620 case Type::ExtVector: 621 case Type::Vector: { 622 const VectorType *VT = cast<VectorType>(T); 623 std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(VT->getElementType()); 624 Width = EltInfo.first*VT->getNumElements(); 625 Align = Width; 626 // If the alignment is not a power of 2, round up to the next power of 2. 627 // This happens for non-power-of-2 length vectors. 628 if (Align & (Align-1)) { 629 Align = llvm::NextPowerOf2(Align); 630 Width = llvm::RoundUpToAlignment(Width, Align); 631 } 632 break; 633 } 634 635 case Type::Builtin: 636 switch (cast<BuiltinType>(T)->getKind()) { 637 default: assert(0 && "Unknown builtin type!"); 638 case BuiltinType::Void: 639 // GCC extension: alignof(void) = 8 bits. 640 Width = 0; 641 Align = 8; 642 break; 643 644 case BuiltinType::Bool: 645 Width = Target.getBoolWidth(); 646 Align = Target.getBoolAlign(); 647 break; 648 case BuiltinType::Char_S: 649 case BuiltinType::Char_U: 650 case BuiltinType::UChar: 651 case BuiltinType::SChar: 652 Width = Target.getCharWidth(); 653 Align = Target.getCharAlign(); 654 break; 655 case BuiltinType::WChar: 656 Width = Target.getWCharWidth(); 657 Align = Target.getWCharAlign(); 658 break; 659 case BuiltinType::Char16: 660 Width = Target.getChar16Width(); 661 Align = Target.getChar16Align(); 662 break; 663 case BuiltinType::Char32: 664 Width = Target.getChar32Width(); 665 Align = Target.getChar32Align(); 666 break; 667 case BuiltinType::UShort: 668 case BuiltinType::Short: 669 Width = Target.getShortWidth(); 670 Align = Target.getShortAlign(); 671 break; 672 case BuiltinType::UInt: 673 case BuiltinType::Int: 674 Width = Target.getIntWidth(); 675 Align = Target.getIntAlign(); 676 break; 677 case BuiltinType::ULong: 678 case BuiltinType::Long: 679 Width = Target.getLongWidth(); 680 Align = Target.getLongAlign(); 681 break; 682 case BuiltinType::ULongLong: 683 case BuiltinType::LongLong: 684 Width = Target.getLongLongWidth(); 685 Align = Target.getLongLongAlign(); 686 break; 687 case BuiltinType::Int128: 688 case BuiltinType::UInt128: 689 Width = 128; 690 Align = 128; // int128_t is 128-bit aligned on all targets. 691 break; 692 case BuiltinType::Float: 693 Width = Target.getFloatWidth(); 694 Align = Target.getFloatAlign(); 695 break; 696 case BuiltinType::Double: 697 Width = Target.getDoubleWidth(); 698 Align = Target.getDoubleAlign(); 699 break; 700 case BuiltinType::LongDouble: 701 Width = Target.getLongDoubleWidth(); 702 Align = Target.getLongDoubleAlign(); 703 break; 704 case BuiltinType::NullPtr: 705 Width = Target.getPointerWidth(0); // C++ 3.9.1p11: sizeof(nullptr_t) 706 Align = Target.getPointerAlign(0); // == sizeof(void*) 707 break; 708 case BuiltinType::ObjCId: 709 case BuiltinType::ObjCClass: 710 case BuiltinType::ObjCSel: 711 Width = Target.getPointerWidth(0); 712 Align = Target.getPointerAlign(0); 713 break; 714 } 715 break; 716 case Type::ObjCObjectPointer: 717 Width = Target.getPointerWidth(0); 718 Align = Target.getPointerAlign(0); 719 break; 720 case Type::BlockPointer: { 721 unsigned AS = cast<BlockPointerType>(T)->getPointeeType().getAddressSpace(); 722 Width = Target.getPointerWidth(AS); 723 Align = Target.getPointerAlign(AS); 724 break; 725 } 726 case Type::LValueReference: 727 case Type::RValueReference: { 728 // alignof and sizeof should never enter this code path here, so we go 729 // the pointer route. 730 unsigned AS = cast<ReferenceType>(T)->getPointeeType().getAddressSpace(); 731 Width = Target.getPointerWidth(AS); 732 Align = Target.getPointerAlign(AS); 733 break; 734 } 735 case Type::Pointer: { 736 unsigned AS = cast<PointerType>(T)->getPointeeType().getAddressSpace(); 737 Width = Target.getPointerWidth(AS); 738 Align = Target.getPointerAlign(AS); 739 break; 740 } 741 case Type::MemberPointer: { 742 const MemberPointerType *MPT = cast<MemberPointerType>(T); 743 std::pair<uint64_t, unsigned> PtrDiffInfo = 744 getTypeInfo(getPointerDiffType()); 745 Width = PtrDiffInfo.first * ABI->getMemberPointerSize(MPT); 746 Align = PtrDiffInfo.second; 747 break; 748 } 749 case Type::Complex: { 750 // Complex types have the same alignment as their elements, but twice the 751 // size. 752 std::pair<uint64_t, unsigned> EltInfo = 753 getTypeInfo(cast<ComplexType>(T)->getElementType()); 754 Width = EltInfo.first*2; 755 Align = EltInfo.second; 756 break; 757 } 758 case Type::ObjCObject: 759 return getTypeInfo(cast<ObjCObjectType>(T)->getBaseType().getTypePtr()); 760 case Type::ObjCInterface: { 761 const ObjCInterfaceType *ObjCI = cast<ObjCInterfaceType>(T); 762 const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl()); 763 Width = Layout.getSize(); 764 Align = Layout.getAlignment(); 765 break; 766 } 767 case Type::Record: 768 case Type::Enum: { 769 const TagType *TT = cast<TagType>(T); 770 771 if (TT->getDecl()->isInvalidDecl()) { 772 Width = 1; 773 Align = 1; 774 break; 775 } 776 777 if (const EnumType *ET = dyn_cast<EnumType>(TT)) 778 return getTypeInfo(ET->getDecl()->getIntegerType()); 779 780 const RecordType *RT = cast<RecordType>(TT); 781 const ASTRecordLayout &Layout = getASTRecordLayout(RT->getDecl()); 782 Width = Layout.getSize(); 783 Align = Layout.getAlignment(); 784 break; 785 } 786 787 case Type::SubstTemplateTypeParm: 788 return getTypeInfo(cast<SubstTemplateTypeParmType>(T)-> 789 getReplacementType().getTypePtr()); 790 791 case Type::Typedef: { 792 const TypedefDecl *Typedef = cast<TypedefType>(T)->getDecl(); 793 std::pair<uint64_t, unsigned> Info 794 = getTypeInfo(Typedef->getUnderlyingType().getTypePtr()); 795 Align = std::max(Typedef->getMaxAlignment(), Info.second); 796 Width = Info.first; 797 break; 798 } 799 800 case Type::TypeOfExpr: 801 return getTypeInfo(cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType() 802 .getTypePtr()); 803 804 case Type::TypeOf: 805 return getTypeInfo(cast<TypeOfType>(T)->getUnderlyingType().getTypePtr()); 806 807 case Type::Decltype: 808 return getTypeInfo(cast<DecltypeType>(T)->getUnderlyingExpr()->getType() 809 .getTypePtr()); 810 811 case Type::Elaborated: 812 return getTypeInfo(cast<ElaboratedType>(T)->getNamedType().getTypePtr()); 813 814 case Type::TemplateSpecialization: 815 assert(getCanonicalType(T) != T && 816 "Cannot request the size of a dependent type"); 817 // FIXME: this is likely to be wrong once we support template 818 // aliases, since a template alias could refer to a typedef that 819 // has an __aligned__ attribute on it. 820 return getTypeInfo(getCanonicalType(T)); 821 } 822 823 assert(Align && (Align & (Align-1)) == 0 && "Alignment must be power of 2"); 824 return std::make_pair(Width, Align); 825} 826 827/// getTypeSizeInChars - Return the size of the specified type, in characters. 828/// This method does not work on incomplete types. 829CharUnits ASTContext::getTypeSizeInChars(QualType T) { 830 return CharUnits::fromQuantity(getTypeSize(T) / getCharWidth()); 831} 832CharUnits ASTContext::getTypeSizeInChars(const Type *T) { 833 return CharUnits::fromQuantity(getTypeSize(T) / getCharWidth()); 834} 835 836/// getTypeAlignInChars - Return the ABI-specified alignment of a type, in 837/// characters. This method does not work on incomplete types. 838CharUnits ASTContext::getTypeAlignInChars(QualType T) { 839 return CharUnits::fromQuantity(getTypeAlign(T) / getCharWidth()); 840} 841CharUnits ASTContext::getTypeAlignInChars(const Type *T) { 842 return CharUnits::fromQuantity(getTypeAlign(T) / getCharWidth()); 843} 844 845/// getPreferredTypeAlign - Return the "preferred" alignment of the specified 846/// type for the current target in bits. This can be different than the ABI 847/// alignment in cases where it is beneficial for performance to overalign 848/// a data type. 849unsigned ASTContext::getPreferredTypeAlign(const Type *T) { 850 unsigned ABIAlign = getTypeAlign(T); 851 852 // Double and long long should be naturally aligned if possible. 853 if (const ComplexType* CT = T->getAs<ComplexType>()) 854 T = CT->getElementType().getTypePtr(); 855 if (T->isSpecificBuiltinType(BuiltinType::Double) || 856 T->isSpecificBuiltinType(BuiltinType::LongLong)) 857 return std::max(ABIAlign, (unsigned)getTypeSize(T)); 858 859 return ABIAlign; 860} 861 862/// ShallowCollectObjCIvars - 863/// Collect all ivars, including those synthesized, in the current class. 864/// 865void ASTContext::ShallowCollectObjCIvars(const ObjCInterfaceDecl *OI, 866 llvm::SmallVectorImpl<ObjCIvarDecl*> &Ivars) { 867 // FIXME. This need be removed but there are two many places which 868 // assume const-ness of ObjCInterfaceDecl 869 ObjCInterfaceDecl *IDecl = const_cast<ObjCInterfaceDecl *>(OI); 870 for (ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv; 871 Iv= Iv->getNextIvar()) 872 Ivars.push_back(Iv); 873} 874 875/// DeepCollectObjCIvars - 876/// This routine first collects all declared, but not synthesized, ivars in 877/// super class and then collects all ivars, including those synthesized for 878/// current class. This routine is used for implementation of current class 879/// when all ivars, declared and synthesized are known. 880/// 881void ASTContext::DeepCollectObjCIvars(const ObjCInterfaceDecl *OI, 882 bool leafClass, 883 llvm::SmallVectorImpl<ObjCIvarDecl*> &Ivars) { 884 if (const ObjCInterfaceDecl *SuperClass = OI->getSuperClass()) 885 DeepCollectObjCIvars(SuperClass, false, Ivars); 886 if (!leafClass) { 887 for (ObjCInterfaceDecl::ivar_iterator I = OI->ivar_begin(), 888 E = OI->ivar_end(); I != E; ++I) 889 Ivars.push_back(*I); 890 } 891 else 892 ShallowCollectObjCIvars(OI, Ivars); 893} 894 895/// CollectInheritedProtocols - Collect all protocols in current class and 896/// those inherited by it. 897void ASTContext::CollectInheritedProtocols(const Decl *CDecl, 898 llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols) { 899 if (const ObjCInterfaceDecl *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) { 900 // We can use protocol_iterator here instead of 901 // all_referenced_protocol_iterator since we are walking all categories. 902 for (ObjCInterfaceDecl::all_protocol_iterator P = OI->all_referenced_protocol_begin(), 903 PE = OI->all_referenced_protocol_end(); P != PE; ++P) { 904 ObjCProtocolDecl *Proto = (*P); 905 Protocols.insert(Proto); 906 for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(), 907 PE = Proto->protocol_end(); P != PE; ++P) { 908 Protocols.insert(*P); 909 CollectInheritedProtocols(*P, Protocols); 910 } 911 } 912 913 // Categories of this Interface. 914 for (const ObjCCategoryDecl *CDeclChain = OI->getCategoryList(); 915 CDeclChain; CDeclChain = CDeclChain->getNextClassCategory()) 916 CollectInheritedProtocols(CDeclChain, Protocols); 917 if (ObjCInterfaceDecl *SD = OI->getSuperClass()) 918 while (SD) { 919 CollectInheritedProtocols(SD, Protocols); 920 SD = SD->getSuperClass(); 921 } 922 } else if (const ObjCCategoryDecl *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) { 923 for (ObjCCategoryDecl::protocol_iterator P = OC->protocol_begin(), 924 PE = OC->protocol_end(); P != PE; ++P) { 925 ObjCProtocolDecl *Proto = (*P); 926 Protocols.insert(Proto); 927 for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(), 928 PE = Proto->protocol_end(); P != PE; ++P) 929 CollectInheritedProtocols(*P, Protocols); 930 } 931 } else if (const ObjCProtocolDecl *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) { 932 for (ObjCProtocolDecl::protocol_iterator P = OP->protocol_begin(), 933 PE = OP->protocol_end(); P != PE; ++P) { 934 ObjCProtocolDecl *Proto = (*P); 935 Protocols.insert(Proto); 936 for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(), 937 PE = Proto->protocol_end(); P != PE; ++P) 938 CollectInheritedProtocols(*P, Protocols); 939 } 940 } 941} 942 943unsigned ASTContext::CountNonClassIvars(const ObjCInterfaceDecl *OI) { 944 unsigned count = 0; 945 // Count ivars declared in class extension. 946 for (const ObjCCategoryDecl *CDecl = OI->getFirstClassExtension(); CDecl; 947 CDecl = CDecl->getNextClassExtension()) 948 count += CDecl->ivar_size(); 949 950 // Count ivar defined in this class's implementation. This 951 // includes synthesized ivars. 952 if (ObjCImplementationDecl *ImplDecl = OI->getImplementation()) 953 count += ImplDecl->ivar_size(); 954 955 return count; 956} 957 958/// \brief Get the implementation of ObjCInterfaceDecl,or NULL if none exists. 959ObjCImplementationDecl *ASTContext::getObjCImplementation(ObjCInterfaceDecl *D) { 960 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator 961 I = ObjCImpls.find(D); 962 if (I != ObjCImpls.end()) 963 return cast<ObjCImplementationDecl>(I->second); 964 return 0; 965} 966/// \brief Get the implementation of ObjCCategoryDecl, or NULL if none exists. 967ObjCCategoryImplDecl *ASTContext::getObjCImplementation(ObjCCategoryDecl *D) { 968 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator 969 I = ObjCImpls.find(D); 970 if (I != ObjCImpls.end()) 971 return cast<ObjCCategoryImplDecl>(I->second); 972 return 0; 973} 974 975/// \brief Set the implementation of ObjCInterfaceDecl. 976void ASTContext::setObjCImplementation(ObjCInterfaceDecl *IFaceD, 977 ObjCImplementationDecl *ImplD) { 978 assert(IFaceD && ImplD && "Passed null params"); 979 ObjCImpls[IFaceD] = ImplD; 980} 981/// \brief Set the implementation of ObjCCategoryDecl. 982void ASTContext::setObjCImplementation(ObjCCategoryDecl *CatD, 983 ObjCCategoryImplDecl *ImplD) { 984 assert(CatD && ImplD && "Passed null params"); 985 ObjCImpls[CatD] = ImplD; 986} 987 988/// \brief Allocate an uninitialized TypeSourceInfo. 989/// 990/// The caller should initialize the memory held by TypeSourceInfo using 991/// the TypeLoc wrappers. 992/// 993/// \param T the type that will be the basis for type source info. This type 994/// should refer to how the declarator was written in source code, not to 995/// what type semantic analysis resolved the declarator to. 996TypeSourceInfo *ASTContext::CreateTypeSourceInfo(QualType T, 997 unsigned DataSize) { 998 if (!DataSize) 999 DataSize = TypeLoc::getFullDataSizeForType(T); 1000 else 1001 assert(DataSize == TypeLoc::getFullDataSizeForType(T) && 1002 "incorrect data size provided to CreateTypeSourceInfo!"); 1003 1004 TypeSourceInfo *TInfo = 1005 (TypeSourceInfo*)BumpAlloc.Allocate(sizeof(TypeSourceInfo) + DataSize, 8); 1006 new (TInfo) TypeSourceInfo(T); 1007 return TInfo; 1008} 1009 1010TypeSourceInfo *ASTContext::getTrivialTypeSourceInfo(QualType T, 1011 SourceLocation L) { 1012 TypeSourceInfo *DI = CreateTypeSourceInfo(T); 1013 DI->getTypeLoc().initialize(L); 1014 return DI; 1015} 1016 1017const ASTRecordLayout & 1018ASTContext::getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) { 1019 return getObjCLayout(D, 0); 1020} 1021 1022const ASTRecordLayout & 1023ASTContext::getASTObjCImplementationLayout(const ObjCImplementationDecl *D) { 1024 return getObjCLayout(D->getClassInterface(), D); 1025} 1026 1027//===----------------------------------------------------------------------===// 1028// Type creation/memoization methods 1029//===----------------------------------------------------------------------===// 1030 1031QualType ASTContext::getExtQualType(const Type *TypeNode, Qualifiers Quals) { 1032 unsigned Fast = Quals.getFastQualifiers(); 1033 Quals.removeFastQualifiers(); 1034 1035 // Check if we've already instantiated this type. 1036 llvm::FoldingSetNodeID ID; 1037 ExtQuals::Profile(ID, TypeNode, Quals); 1038 void *InsertPos = 0; 1039 if (ExtQuals *EQ = ExtQualNodes.FindNodeOrInsertPos(ID, InsertPos)) { 1040 assert(EQ->getQualifiers() == Quals); 1041 QualType T = QualType(EQ, Fast); 1042 return T; 1043 } 1044 1045 ExtQuals *New = new (*this, TypeAlignment) ExtQuals(*this, TypeNode, Quals); 1046 ExtQualNodes.InsertNode(New, InsertPos); 1047 QualType T = QualType(New, Fast); 1048 return T; 1049} 1050 1051QualType ASTContext::getVolatileType(QualType T) { 1052 QualType CanT = getCanonicalType(T); 1053 if (CanT.isVolatileQualified()) return T; 1054 1055 QualifierCollector Quals; 1056 const Type *TypeNode = Quals.strip(T); 1057 Quals.addVolatile(); 1058 1059 return getExtQualType(TypeNode, Quals); 1060} 1061 1062QualType ASTContext::getAddrSpaceQualType(QualType T, unsigned AddressSpace) { 1063 QualType CanT = getCanonicalType(T); 1064 if (CanT.getAddressSpace() == AddressSpace) 1065 return T; 1066 1067 // If we are composing extended qualifiers together, merge together 1068 // into one ExtQuals node. 1069 QualifierCollector Quals; 1070 const Type *TypeNode = Quals.strip(T); 1071 1072 // If this type already has an address space specified, it cannot get 1073 // another one. 1074 assert(!Quals.hasAddressSpace() && 1075 "Type cannot be in multiple addr spaces!"); 1076 Quals.addAddressSpace(AddressSpace); 1077 1078 return getExtQualType(TypeNode, Quals); 1079} 1080 1081QualType ASTContext::getObjCGCQualType(QualType T, 1082 Qualifiers::GC GCAttr) { 1083 QualType CanT = getCanonicalType(T); 1084 if (CanT.getObjCGCAttr() == GCAttr) 1085 return T; 1086 1087 if (T->isPointerType()) { 1088 QualType Pointee = T->getAs<PointerType>()->getPointeeType(); 1089 if (Pointee->isAnyPointerType()) { 1090 QualType ResultType = getObjCGCQualType(Pointee, GCAttr); 1091 return getPointerType(ResultType); 1092 } 1093 } 1094 1095 // If we are composing extended qualifiers together, merge together 1096 // into one ExtQuals node. 1097 QualifierCollector Quals; 1098 const Type *TypeNode = Quals.strip(T); 1099 1100 // If this type already has an ObjCGC specified, it cannot get 1101 // another one. 1102 assert(!Quals.hasObjCGCAttr() && 1103 "Type cannot have multiple ObjCGCs!"); 1104 Quals.addObjCGCAttr(GCAttr); 1105 1106 return getExtQualType(TypeNode, Quals); 1107} 1108 1109static QualType getExtFunctionType(ASTContext& Context, QualType T, 1110 const FunctionType::ExtInfo &Info) { 1111 QualType ResultType; 1112 if (const PointerType *Pointer = T->getAs<PointerType>()) { 1113 QualType Pointee = Pointer->getPointeeType(); 1114 ResultType = getExtFunctionType(Context, Pointee, Info); 1115 if (ResultType == Pointee) 1116 return T; 1117 1118 ResultType = Context.getPointerType(ResultType); 1119 } else if (const BlockPointerType *BlockPointer 1120 = T->getAs<BlockPointerType>()) { 1121 QualType Pointee = BlockPointer->getPointeeType(); 1122 ResultType = getExtFunctionType(Context, Pointee, Info); 1123 if (ResultType == Pointee) 1124 return T; 1125 1126 ResultType = Context.getBlockPointerType(ResultType); 1127 } else if (const MemberPointerType *MemberPointer 1128 = T->getAs<MemberPointerType>()) { 1129 QualType Pointee = MemberPointer->getPointeeType(); 1130 ResultType = getExtFunctionType(Context, Pointee, Info); 1131 if (ResultType == Pointee) 1132 return T; 1133 1134 ResultType = Context.getMemberPointerType(ResultType, 1135 MemberPointer->getClass()); 1136 } else if (const FunctionType *F = T->getAs<FunctionType>()) { 1137 if (F->getExtInfo() == Info) 1138 return T; 1139 1140 if (const FunctionNoProtoType *FNPT = dyn_cast<FunctionNoProtoType>(F)) { 1141 ResultType = Context.getFunctionNoProtoType(FNPT->getResultType(), 1142 Info); 1143 } else { 1144 const FunctionProtoType *FPT = cast<FunctionProtoType>(F); 1145 ResultType 1146 = Context.getFunctionType(FPT->getResultType(), FPT->arg_type_begin(), 1147 FPT->getNumArgs(), FPT->isVariadic(), 1148 FPT->getTypeQuals(), 1149 FPT->hasExceptionSpec(), 1150 FPT->hasAnyExceptionSpec(), 1151 FPT->getNumExceptions(), 1152 FPT->exception_begin(), 1153 Info); 1154 } 1155 } else 1156 return T; 1157 1158 return Context.getQualifiedType(ResultType, T.getLocalQualifiers()); 1159} 1160 1161QualType ASTContext::getNoReturnType(QualType T, bool AddNoReturn) { 1162 FunctionType::ExtInfo Info = getFunctionExtInfo(T); 1163 return getExtFunctionType(*this, T, 1164 Info.withNoReturn(AddNoReturn)); 1165} 1166 1167QualType ASTContext::getCallConvType(QualType T, CallingConv CallConv) { 1168 FunctionType::ExtInfo Info = getFunctionExtInfo(T); 1169 return getExtFunctionType(*this, T, 1170 Info.withCallingConv(CallConv)); 1171} 1172 1173QualType ASTContext::getRegParmType(QualType T, unsigned RegParm) { 1174 FunctionType::ExtInfo Info = getFunctionExtInfo(T); 1175 return getExtFunctionType(*this, T, 1176 Info.withRegParm(RegParm)); 1177} 1178 1179/// getComplexType - Return the uniqued reference to the type for a complex 1180/// number with the specified element type. 1181QualType ASTContext::getComplexType(QualType T) { 1182 // Unique pointers, to guarantee there is only one pointer of a particular 1183 // structure. 1184 llvm::FoldingSetNodeID ID; 1185 ComplexType::Profile(ID, T); 1186 1187 void *InsertPos = 0; 1188 if (ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos)) 1189 return QualType(CT, 0); 1190 1191 // If the pointee type isn't canonical, this won't be a canonical type either, 1192 // so fill in the canonical type field. 1193 QualType Canonical; 1194 if (!T.isCanonical()) { 1195 Canonical = getComplexType(getCanonicalType(T)); 1196 1197 // Get the new insert position for the node we care about. 1198 ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos); 1199 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 1200 } 1201 ComplexType *New = new (*this, TypeAlignment) ComplexType(T, Canonical); 1202 Types.push_back(New); 1203 ComplexTypes.InsertNode(New, InsertPos); 1204 return QualType(New, 0); 1205} 1206 1207/// getPointerType - Return the uniqued reference to the type for a pointer to 1208/// the specified type. 1209QualType ASTContext::getPointerType(QualType T) { 1210 // Unique pointers, to guarantee there is only one pointer of a particular 1211 // structure. 1212 llvm::FoldingSetNodeID ID; 1213 PointerType::Profile(ID, T); 1214 1215 void *InsertPos = 0; 1216 if (PointerType *PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 1217 return QualType(PT, 0); 1218 1219 // If the pointee type isn't canonical, this won't be a canonical type either, 1220 // so fill in the canonical type field. 1221 QualType Canonical; 1222 if (!T.isCanonical()) { 1223 Canonical = getPointerType(getCanonicalType(T)); 1224 1225 // Get the new insert position for the node we care about. 1226 PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos); 1227 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 1228 } 1229 PointerType *New = new (*this, TypeAlignment) PointerType(T, Canonical); 1230 Types.push_back(New); 1231 PointerTypes.InsertNode(New, InsertPos); 1232 return QualType(New, 0); 1233} 1234 1235/// getBlockPointerType - Return the uniqued reference to the type for 1236/// a pointer to the specified block. 1237QualType ASTContext::getBlockPointerType(QualType T) { 1238 assert(T->isFunctionType() && "block of function types only"); 1239 // Unique pointers, to guarantee there is only one block of a particular 1240 // structure. 1241 llvm::FoldingSetNodeID ID; 1242 BlockPointerType::Profile(ID, T); 1243 1244 void *InsertPos = 0; 1245 if (BlockPointerType *PT = 1246 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 1247 return QualType(PT, 0); 1248 1249 // If the block pointee type isn't canonical, this won't be a canonical 1250 // type either so fill in the canonical type field. 1251 QualType Canonical; 1252 if (!T.isCanonical()) { 1253 Canonical = getBlockPointerType(getCanonicalType(T)); 1254 1255 // Get the new insert position for the node we care about. 1256 BlockPointerType *NewIP = 1257 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 1258 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 1259 } 1260 BlockPointerType *New 1261 = new (*this, TypeAlignment) BlockPointerType(T, Canonical); 1262 Types.push_back(New); 1263 BlockPointerTypes.InsertNode(New, InsertPos); 1264 return QualType(New, 0); 1265} 1266 1267/// getLValueReferenceType - Return the uniqued reference to the type for an 1268/// lvalue reference to the specified type. 1269QualType ASTContext::getLValueReferenceType(QualType T, bool SpelledAsLValue) { 1270 // Unique pointers, to guarantee there is only one pointer of a particular 1271 // structure. 1272 llvm::FoldingSetNodeID ID; 1273 ReferenceType::Profile(ID, T, SpelledAsLValue); 1274 1275 void *InsertPos = 0; 1276 if (LValueReferenceType *RT = 1277 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos)) 1278 return QualType(RT, 0); 1279 1280 const ReferenceType *InnerRef = T->getAs<ReferenceType>(); 1281 1282 // If the referencee type isn't canonical, this won't be a canonical type 1283 // either, so fill in the canonical type field. 1284 QualType Canonical; 1285 if (!SpelledAsLValue || InnerRef || !T.isCanonical()) { 1286 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T); 1287 Canonical = getLValueReferenceType(getCanonicalType(PointeeType)); 1288 1289 // Get the new insert position for the node we care about. 1290 LValueReferenceType *NewIP = 1291 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos); 1292 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 1293 } 1294 1295 LValueReferenceType *New 1296 = new (*this, TypeAlignment) LValueReferenceType(T, Canonical, 1297 SpelledAsLValue); 1298 Types.push_back(New); 1299 LValueReferenceTypes.InsertNode(New, InsertPos); 1300 1301 return QualType(New, 0); 1302} 1303 1304/// getRValueReferenceType - Return the uniqued reference to the type for an 1305/// rvalue reference to the specified type. 1306QualType ASTContext::getRValueReferenceType(QualType T) { 1307 // Unique pointers, to guarantee there is only one pointer of a particular 1308 // structure. 1309 llvm::FoldingSetNodeID ID; 1310 ReferenceType::Profile(ID, T, false); 1311 1312 void *InsertPos = 0; 1313 if (RValueReferenceType *RT = 1314 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos)) 1315 return QualType(RT, 0); 1316 1317 const ReferenceType *InnerRef = T->getAs<ReferenceType>(); 1318 1319 // If the referencee type isn't canonical, this won't be a canonical type 1320 // either, so fill in the canonical type field. 1321 QualType Canonical; 1322 if (InnerRef || !T.isCanonical()) { 1323 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T); 1324 Canonical = getRValueReferenceType(getCanonicalType(PointeeType)); 1325 1326 // Get the new insert position for the node we care about. 1327 RValueReferenceType *NewIP = 1328 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos); 1329 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 1330 } 1331 1332 RValueReferenceType *New 1333 = new (*this, TypeAlignment) RValueReferenceType(T, Canonical); 1334 Types.push_back(New); 1335 RValueReferenceTypes.InsertNode(New, InsertPos); 1336 return QualType(New, 0); 1337} 1338 1339/// getMemberPointerType - Return the uniqued reference to the type for a 1340/// member pointer to the specified type, in the specified class. 1341QualType ASTContext::getMemberPointerType(QualType T, const Type *Cls) { 1342 // Unique pointers, to guarantee there is only one pointer of a particular 1343 // structure. 1344 llvm::FoldingSetNodeID ID; 1345 MemberPointerType::Profile(ID, T, Cls); 1346 1347 void *InsertPos = 0; 1348 if (MemberPointerType *PT = 1349 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 1350 return QualType(PT, 0); 1351 1352 // If the pointee or class type isn't canonical, this won't be a canonical 1353 // type either, so fill in the canonical type field. 1354 QualType Canonical; 1355 if (!T.isCanonical() || !Cls->isCanonicalUnqualified()) { 1356 Canonical = getMemberPointerType(getCanonicalType(T),getCanonicalType(Cls)); 1357 1358 // Get the new insert position for the node we care about. 1359 MemberPointerType *NewIP = 1360 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 1361 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 1362 } 1363 MemberPointerType *New 1364 = new (*this, TypeAlignment) MemberPointerType(T, Cls, Canonical); 1365 Types.push_back(New); 1366 MemberPointerTypes.InsertNode(New, InsertPos); 1367 return QualType(New, 0); 1368} 1369 1370/// getConstantArrayType - Return the unique reference to the type for an 1371/// array of the specified element type. 1372QualType ASTContext::getConstantArrayType(QualType EltTy, 1373 const llvm::APInt &ArySizeIn, 1374 ArrayType::ArraySizeModifier ASM, 1375 unsigned EltTypeQuals) { 1376 assert((EltTy->isDependentType() || 1377 EltTy->isIncompleteType() || EltTy->isConstantSizeType()) && 1378 "Constant array of VLAs is illegal!"); 1379 1380 // Convert the array size into a canonical width matching the pointer size for 1381 // the target. 1382 llvm::APInt ArySize(ArySizeIn); 1383 ArySize.zextOrTrunc(Target.getPointerWidth(EltTy.getAddressSpace())); 1384 1385 llvm::FoldingSetNodeID ID; 1386 ConstantArrayType::Profile(ID, EltTy, ArySize, ASM, EltTypeQuals); 1387 1388 void *InsertPos = 0; 1389 if (ConstantArrayType *ATP = 1390 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos)) 1391 return QualType(ATP, 0); 1392 1393 // If the element type isn't canonical, this won't be a canonical type either, 1394 // so fill in the canonical type field. 1395 QualType Canonical; 1396 if (!EltTy.isCanonical()) { 1397 Canonical = getConstantArrayType(getCanonicalType(EltTy), ArySize, 1398 ASM, EltTypeQuals); 1399 // Get the new insert position for the node we care about. 1400 ConstantArrayType *NewIP = 1401 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos); 1402 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 1403 } 1404 1405 ConstantArrayType *New = new(*this,TypeAlignment) 1406 ConstantArrayType(EltTy, Canonical, ArySize, ASM, EltTypeQuals); 1407 ConstantArrayTypes.InsertNode(New, InsertPos); 1408 Types.push_back(New); 1409 return QualType(New, 0); 1410} 1411 1412/// getVariableArrayType - Returns a non-unique reference to the type for a 1413/// variable array of the specified element type. 1414QualType ASTContext::getVariableArrayType(QualType EltTy, 1415 Expr *NumElts, 1416 ArrayType::ArraySizeModifier ASM, 1417 unsigned EltTypeQuals, 1418 SourceRange Brackets) { 1419 // Since we don't unique expressions, it isn't possible to unique VLA's 1420 // that have an expression provided for their size. 1421 QualType CanonType; 1422 1423 if (!EltTy.isCanonical()) { 1424 if (NumElts) 1425 NumElts->Retain(); 1426 CanonType = getVariableArrayType(getCanonicalType(EltTy), NumElts, ASM, 1427 EltTypeQuals, Brackets); 1428 } 1429 1430 VariableArrayType *New = new(*this, TypeAlignment) 1431 VariableArrayType(EltTy, CanonType, NumElts, ASM, EltTypeQuals, Brackets); 1432 1433 VariableArrayTypes.push_back(New); 1434 Types.push_back(New); 1435 return QualType(New, 0); 1436} 1437 1438/// getDependentSizedArrayType - Returns a non-unique reference to 1439/// the type for a dependently-sized array of the specified element 1440/// type. 1441QualType ASTContext::getDependentSizedArrayType(QualType EltTy, 1442 Expr *NumElts, 1443 ArrayType::ArraySizeModifier ASM, 1444 unsigned EltTypeQuals, 1445 SourceRange Brackets) { 1446 assert((!NumElts || NumElts->isTypeDependent() || 1447 NumElts->isValueDependent()) && 1448 "Size must be type- or value-dependent!"); 1449 1450 void *InsertPos = 0; 1451 DependentSizedArrayType *Canon = 0; 1452 llvm::FoldingSetNodeID ID; 1453 1454 if (NumElts) { 1455 // Dependently-sized array types that do not have a specified 1456 // number of elements will have their sizes deduced from an 1457 // initializer. 1458 DependentSizedArrayType::Profile(ID, *this, getCanonicalType(EltTy), ASM, 1459 EltTypeQuals, NumElts); 1460 1461 Canon = DependentSizedArrayTypes.FindNodeOrInsertPos(ID, InsertPos); 1462 } 1463 1464 DependentSizedArrayType *New; 1465 if (Canon) { 1466 // We already have a canonical version of this array type; use it as 1467 // the canonical type for a newly-built type. 1468 New = new (*this, TypeAlignment) 1469 DependentSizedArrayType(*this, EltTy, QualType(Canon, 0), 1470 NumElts, ASM, EltTypeQuals, Brackets); 1471 } else { 1472 QualType CanonEltTy = getCanonicalType(EltTy); 1473 if (CanonEltTy == EltTy) { 1474 New = new (*this, TypeAlignment) 1475 DependentSizedArrayType(*this, EltTy, QualType(), 1476 NumElts, ASM, EltTypeQuals, Brackets); 1477 1478 if (NumElts) { 1479 DependentSizedArrayType *CanonCheck 1480 = DependentSizedArrayTypes.FindNodeOrInsertPos(ID, InsertPos); 1481 assert(!CanonCheck && "Dependent-sized canonical array type broken"); 1482 (void)CanonCheck; 1483 DependentSizedArrayTypes.InsertNode(New, InsertPos); 1484 } 1485 } else { 1486 QualType Canon = getDependentSizedArrayType(CanonEltTy, NumElts, 1487 ASM, EltTypeQuals, 1488 SourceRange()); 1489 New = new (*this, TypeAlignment) 1490 DependentSizedArrayType(*this, EltTy, Canon, 1491 NumElts, ASM, EltTypeQuals, Brackets); 1492 } 1493 } 1494 1495 Types.push_back(New); 1496 return QualType(New, 0); 1497} 1498 1499QualType ASTContext::getIncompleteArrayType(QualType EltTy, 1500 ArrayType::ArraySizeModifier ASM, 1501 unsigned EltTypeQuals) { 1502 llvm::FoldingSetNodeID ID; 1503 IncompleteArrayType::Profile(ID, EltTy, ASM, EltTypeQuals); 1504 1505 void *InsertPos = 0; 1506 if (IncompleteArrayType *ATP = 1507 IncompleteArrayTypes.FindNodeOrInsertPos(ID, InsertPos)) 1508 return QualType(ATP, 0); 1509 1510 // If the element type isn't canonical, this won't be a canonical type 1511 // either, so fill in the canonical type field. 1512 QualType Canonical; 1513 1514 if (!EltTy.isCanonical()) { 1515 Canonical = getIncompleteArrayType(getCanonicalType(EltTy), 1516 ASM, EltTypeQuals); 1517 1518 // Get the new insert position for the node we care about. 1519 IncompleteArrayType *NewIP = 1520 IncompleteArrayTypes.FindNodeOrInsertPos(ID, InsertPos); 1521 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 1522 } 1523 1524 IncompleteArrayType *New = new (*this, TypeAlignment) 1525 IncompleteArrayType(EltTy, Canonical, ASM, EltTypeQuals); 1526 1527 IncompleteArrayTypes.InsertNode(New, InsertPos); 1528 Types.push_back(New); 1529 return QualType(New, 0); 1530} 1531 1532/// getVectorType - Return the unique reference to a vector type of 1533/// the specified element type and size. VectorType must be a built-in type. 1534QualType ASTContext::getVectorType(QualType vecType, unsigned NumElts, 1535 VectorType::AltiVecSpecific AltiVecSpec) { 1536 BuiltinType *baseType; 1537 1538 baseType = dyn_cast<BuiltinType>(getCanonicalType(vecType).getTypePtr()); 1539 assert(baseType != 0 && "getVectorType(): Expecting a built-in type"); 1540 1541 // Check if we've already instantiated a vector of this type. 1542 llvm::FoldingSetNodeID ID; 1543 VectorType::Profile(ID, vecType, NumElts, Type::Vector, AltiVecSpec); 1544 1545 void *InsertPos = 0; 1546 if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos)) 1547 return QualType(VTP, 0); 1548 1549 // If the element type isn't canonical, this won't be a canonical type either, 1550 // so fill in the canonical type field. 1551 QualType Canonical; 1552 if (!vecType.isCanonical()) { 1553 Canonical = getVectorType(getCanonicalType(vecType), NumElts, 1554 VectorType::NotAltiVec); 1555 1556 // Get the new insert position for the node we care about. 1557 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos); 1558 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 1559 } 1560 VectorType *New = new (*this, TypeAlignment) 1561 VectorType(vecType, NumElts, Canonical, AltiVecSpec); 1562 VectorTypes.InsertNode(New, InsertPos); 1563 Types.push_back(New); 1564 return QualType(New, 0); 1565} 1566 1567/// getExtVectorType - Return the unique reference to an extended vector type of 1568/// the specified element type and size. VectorType must be a built-in type. 1569QualType ASTContext::getExtVectorType(QualType vecType, unsigned NumElts) { 1570 BuiltinType *baseType; 1571 1572 baseType = dyn_cast<BuiltinType>(getCanonicalType(vecType).getTypePtr()); 1573 assert(baseType != 0 && "getExtVectorType(): Expecting a built-in type"); 1574 1575 // Check if we've already instantiated a vector of this type. 1576 llvm::FoldingSetNodeID ID; 1577 VectorType::Profile(ID, vecType, NumElts, Type::ExtVector, 1578 VectorType::NotAltiVec); 1579 void *InsertPos = 0; 1580 if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos)) 1581 return QualType(VTP, 0); 1582 1583 // If the element type isn't canonical, this won't be a canonical type either, 1584 // so fill in the canonical type field. 1585 QualType Canonical; 1586 if (!vecType.isCanonical()) { 1587 Canonical = getExtVectorType(getCanonicalType(vecType), NumElts); 1588 1589 // Get the new insert position for the node we care about. 1590 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos); 1591 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 1592 } 1593 ExtVectorType *New = new (*this, TypeAlignment) 1594 ExtVectorType(vecType, NumElts, Canonical); 1595 VectorTypes.InsertNode(New, InsertPos); 1596 Types.push_back(New); 1597 return QualType(New, 0); 1598} 1599 1600QualType ASTContext::getDependentSizedExtVectorType(QualType vecType, 1601 Expr *SizeExpr, 1602 SourceLocation AttrLoc) { 1603 llvm::FoldingSetNodeID ID; 1604 DependentSizedExtVectorType::Profile(ID, *this, getCanonicalType(vecType), 1605 SizeExpr); 1606 1607 void *InsertPos = 0; 1608 DependentSizedExtVectorType *Canon 1609 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos); 1610 DependentSizedExtVectorType *New; 1611 if (Canon) { 1612 // We already have a canonical version of this array type; use it as 1613 // the canonical type for a newly-built type. 1614 New = new (*this, TypeAlignment) 1615 DependentSizedExtVectorType(*this, vecType, QualType(Canon, 0), 1616 SizeExpr, AttrLoc); 1617 } else { 1618 QualType CanonVecTy = getCanonicalType(vecType); 1619 if (CanonVecTy == vecType) { 1620 New = new (*this, TypeAlignment) 1621 DependentSizedExtVectorType(*this, vecType, QualType(), SizeExpr, 1622 AttrLoc); 1623 1624 DependentSizedExtVectorType *CanonCheck 1625 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos); 1626 assert(!CanonCheck && "Dependent-sized ext_vector canonical type broken"); 1627 (void)CanonCheck; 1628 DependentSizedExtVectorTypes.InsertNode(New, InsertPos); 1629 } else { 1630 QualType Canon = getDependentSizedExtVectorType(CanonVecTy, SizeExpr, 1631 SourceLocation()); 1632 New = new (*this, TypeAlignment) 1633 DependentSizedExtVectorType(*this, vecType, Canon, SizeExpr, AttrLoc); 1634 } 1635 } 1636 1637 Types.push_back(New); 1638 return QualType(New, 0); 1639} 1640 1641/// getFunctionNoProtoType - Return a K&R style C function type like 'int()'. 1642/// 1643QualType ASTContext::getFunctionNoProtoType(QualType ResultTy, 1644 const FunctionType::ExtInfo &Info) { 1645 const CallingConv CallConv = Info.getCC(); 1646 // Unique functions, to guarantee there is only one function of a particular 1647 // structure. 1648 llvm::FoldingSetNodeID ID; 1649 FunctionNoProtoType::Profile(ID, ResultTy, Info); 1650 1651 void *InsertPos = 0; 1652 if (FunctionNoProtoType *FT = 1653 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) 1654 return QualType(FT, 0); 1655 1656 QualType Canonical; 1657 if (!ResultTy.isCanonical() || 1658 getCanonicalCallConv(CallConv) != CallConv) { 1659 Canonical = 1660 getFunctionNoProtoType(getCanonicalType(ResultTy), 1661 Info.withCallingConv(getCanonicalCallConv(CallConv))); 1662 1663 // Get the new insert position for the node we care about. 1664 FunctionNoProtoType *NewIP = 1665 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos); 1666 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 1667 } 1668 1669 FunctionNoProtoType *New = new (*this, TypeAlignment) 1670 FunctionNoProtoType(ResultTy, Canonical, Info); 1671 Types.push_back(New); 1672 FunctionNoProtoTypes.InsertNode(New, InsertPos); 1673 return QualType(New, 0); 1674} 1675 1676/// getFunctionType - Return a normal function type with a typed argument 1677/// list. isVariadic indicates whether the argument list includes '...'. 1678QualType ASTContext::getFunctionType(QualType ResultTy,const QualType *ArgArray, 1679 unsigned NumArgs, bool isVariadic, 1680 unsigned TypeQuals, bool hasExceptionSpec, 1681 bool hasAnyExceptionSpec, unsigned NumExs, 1682 const QualType *ExArray, 1683 const FunctionType::ExtInfo &Info) { 1684 const CallingConv CallConv= Info.getCC(); 1685 // Unique functions, to guarantee there is only one function of a particular 1686 // structure. 1687 llvm::FoldingSetNodeID ID; 1688 FunctionProtoType::Profile(ID, ResultTy, ArgArray, NumArgs, isVariadic, 1689 TypeQuals, hasExceptionSpec, hasAnyExceptionSpec, 1690 NumExs, ExArray, Info); 1691 1692 void *InsertPos = 0; 1693 if (FunctionProtoType *FTP = 1694 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) 1695 return QualType(FTP, 0); 1696 1697 // Determine whether the type being created is already canonical or not. 1698 bool isCanonical = !hasExceptionSpec && ResultTy.isCanonical(); 1699 for (unsigned i = 0; i != NumArgs && isCanonical; ++i) 1700 if (!ArgArray[i].isCanonicalAsParam()) 1701 isCanonical = false; 1702 1703 // If this type isn't canonical, get the canonical version of it. 1704 // The exception spec is not part of the canonical type. 1705 QualType Canonical; 1706 if (!isCanonical || getCanonicalCallConv(CallConv) != CallConv) { 1707 llvm::SmallVector<QualType, 16> CanonicalArgs; 1708 CanonicalArgs.reserve(NumArgs); 1709 for (unsigned i = 0; i != NumArgs; ++i) 1710 CanonicalArgs.push_back(getCanonicalParamType(ArgArray[i])); 1711 1712 Canonical = getFunctionType(getCanonicalType(ResultTy), 1713 CanonicalArgs.data(), NumArgs, 1714 isVariadic, TypeQuals, false, 1715 false, 0, 0, 1716 Info.withCallingConv(getCanonicalCallConv(CallConv))); 1717 1718 // Get the new insert position for the node we care about. 1719 FunctionProtoType *NewIP = 1720 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos); 1721 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP; 1722 } 1723 1724 // FunctionProtoType objects are allocated with extra bytes after them 1725 // for two variable size arrays (for parameter and exception types) at the 1726 // end of them. 1727 FunctionProtoType *FTP = 1728 (FunctionProtoType*)Allocate(sizeof(FunctionProtoType) + 1729 NumArgs*sizeof(QualType) + 1730 NumExs*sizeof(QualType), TypeAlignment); 1731 new (FTP) FunctionProtoType(ResultTy, ArgArray, NumArgs, isVariadic, 1732 TypeQuals, hasExceptionSpec, hasAnyExceptionSpec, 1733 ExArray, NumExs, Canonical, Info); 1734 Types.push_back(FTP); 1735 FunctionProtoTypes.InsertNode(FTP, InsertPos); 1736 return QualType(FTP, 0); 1737} 1738 1739#ifndef NDEBUG 1740static bool NeedsInjectedClassNameType(const RecordDecl *D) { 1741 if (!isa<CXXRecordDecl>(D)) return false; 1742 const CXXRecordDecl *RD = cast<CXXRecordDecl>(D); 1743 if (isa<ClassTemplatePartialSpecializationDecl>(RD)) 1744 return true; 1745 if (RD->getDescribedClassTemplate() && 1746 !isa<ClassTemplateSpecializationDecl>(RD)) 1747 return true; 1748 return false; 1749} 1750#endif 1751 1752/// getInjectedClassNameType - Return the unique reference to the 1753/// injected class name type for the specified templated declaration. 1754QualType ASTContext::getInjectedClassNameType(CXXRecordDecl *Decl, 1755 QualType TST) { 1756 assert(NeedsInjectedClassNameType(Decl)); 1757 if (Decl->TypeForDecl) { 1758 assert(isa<InjectedClassNameType>(Decl->TypeForDecl)); 1759 } else if (CXXRecordDecl *PrevDecl = Decl->getPreviousDeclaration()) { 1760 assert(PrevDecl->TypeForDecl && "previous declaration has no type"); 1761 Decl->TypeForDecl = PrevDecl->TypeForDecl; 1762 assert(isa<InjectedClassNameType>(Decl->TypeForDecl)); 1763 } else { 1764 Decl->TypeForDecl = 1765 new (*this, TypeAlignment) InjectedClassNameType(Decl, TST); 1766 Types.push_back(Decl->TypeForDecl); 1767 } 1768 return QualType(Decl->TypeForDecl, 0); 1769} 1770 1771/// getTypeDeclType - Return the unique reference to the type for the 1772/// specified type declaration. 1773QualType ASTContext::getTypeDeclTypeSlow(const TypeDecl *Decl) { 1774 assert(Decl && "Passed null for Decl param"); 1775 assert(!Decl->TypeForDecl && "TypeForDecl present in slow case"); 1776 1777 if (const TypedefDecl *Typedef = dyn_cast<TypedefDecl>(Decl)) 1778 return getTypedefType(Typedef); 1779 1780 assert(!isa<TemplateTypeParmDecl>(Decl) && 1781 "Template type parameter types are always available."); 1782 1783 if (const RecordDecl *Record = dyn_cast<RecordDecl>(Decl)) { 1784 assert(!Record->getPreviousDeclaration() && 1785 "struct/union has previous declaration"); 1786 assert(!NeedsInjectedClassNameType(Record)); 1787 return getRecordType(Record); 1788 } else if (const EnumDecl *Enum = dyn_cast<EnumDecl>(Decl)) { 1789 assert(!Enum->getPreviousDeclaration() && 1790 "enum has previous declaration"); 1791 return getEnumType(Enum); 1792 } else if (const UnresolvedUsingTypenameDecl *Using = 1793 dyn_cast<UnresolvedUsingTypenameDecl>(Decl)) { 1794 Decl->TypeForDecl = new (*this, TypeAlignment) UnresolvedUsingType(Using); 1795 } else 1796 llvm_unreachable("TypeDecl without a type?"); 1797 1798 Types.push_back(Decl->TypeForDecl); 1799 return QualType(Decl->TypeForDecl, 0); 1800} 1801 1802/// getTypedefType - Return the unique reference to the type for the 1803/// specified typename decl. 1804QualType 1805ASTContext::getTypedefType(const TypedefDecl *Decl, QualType Canonical) { 1806 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 1807 1808 if (Canonical.isNull()) 1809 Canonical = getCanonicalType(Decl->getUnderlyingType()); 1810 Decl->TypeForDecl = new(*this, TypeAlignment) 1811 TypedefType(Type::Typedef, Decl, Canonical); 1812 Types.push_back(Decl->TypeForDecl); 1813 return QualType(Decl->TypeForDecl, 0); 1814} 1815 1816QualType ASTContext::getRecordType(const RecordDecl *Decl) { 1817 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 1818 1819 if (const RecordDecl *PrevDecl = Decl->getPreviousDeclaration()) 1820 if (PrevDecl->TypeForDecl) 1821 return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0); 1822 1823 Decl->TypeForDecl = new (*this, TypeAlignment) RecordType(Decl); 1824 Types.push_back(Decl->TypeForDecl); 1825 return QualType(Decl->TypeForDecl, 0); 1826} 1827 1828QualType ASTContext::getEnumType(const EnumDecl *Decl) { 1829 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 1830 1831 if (const EnumDecl *PrevDecl = Decl->getPreviousDeclaration()) 1832 if (PrevDecl->TypeForDecl) 1833 return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0); 1834 1835 Decl->TypeForDecl = new (*this, TypeAlignment) EnumType(Decl); 1836 Types.push_back(Decl->TypeForDecl); 1837 return QualType(Decl->TypeForDecl, 0); 1838} 1839 1840/// \brief Retrieve a substitution-result type. 1841QualType 1842ASTContext::getSubstTemplateTypeParmType(const TemplateTypeParmType *Parm, 1843 QualType Replacement) { 1844 assert(Replacement.isCanonical() 1845 && "replacement types must always be canonical"); 1846 1847 llvm::FoldingSetNodeID ID; 1848 SubstTemplateTypeParmType::Profile(ID, Parm, Replacement); 1849 void *InsertPos = 0; 1850 SubstTemplateTypeParmType *SubstParm 1851 = SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 1852 1853 if (!SubstParm) { 1854 SubstParm = new (*this, TypeAlignment) 1855 SubstTemplateTypeParmType(Parm, Replacement); 1856 Types.push_back(SubstParm); 1857 SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos); 1858 } 1859 1860 return QualType(SubstParm, 0); 1861} 1862 1863/// \brief Retrieve the template type parameter type for a template 1864/// parameter or parameter pack with the given depth, index, and (optionally) 1865/// name. 1866QualType ASTContext::getTemplateTypeParmType(unsigned Depth, unsigned Index, 1867 bool ParameterPack, 1868 IdentifierInfo *Name) { 1869 llvm::FoldingSetNodeID ID; 1870 TemplateTypeParmType::Profile(ID, Depth, Index, ParameterPack, Name); 1871 void *InsertPos = 0; 1872 TemplateTypeParmType *TypeParm 1873 = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 1874 1875 if (TypeParm) 1876 return QualType(TypeParm, 0); 1877 1878 if (Name) { 1879 QualType Canon = getTemplateTypeParmType(Depth, Index, ParameterPack); 1880 TypeParm = new (*this, TypeAlignment) 1881 TemplateTypeParmType(Depth, Index, ParameterPack, Name, Canon); 1882 1883 TemplateTypeParmType *TypeCheck 1884 = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 1885 assert(!TypeCheck && "Template type parameter canonical type broken"); 1886 (void)TypeCheck; 1887 } else 1888 TypeParm = new (*this, TypeAlignment) 1889 TemplateTypeParmType(Depth, Index, ParameterPack); 1890 1891 Types.push_back(TypeParm); 1892 TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos); 1893 1894 return QualType(TypeParm, 0); 1895} 1896 1897TypeSourceInfo * 1898ASTContext::getTemplateSpecializationTypeInfo(TemplateName Name, 1899 SourceLocation NameLoc, 1900 const TemplateArgumentListInfo &Args, 1901 QualType CanonType) { 1902 QualType TST = getTemplateSpecializationType(Name, Args, CanonType); 1903 1904 TypeSourceInfo *DI = CreateTypeSourceInfo(TST); 1905 TemplateSpecializationTypeLoc TL 1906 = cast<TemplateSpecializationTypeLoc>(DI->getTypeLoc()); 1907 TL.setTemplateNameLoc(NameLoc); 1908 TL.setLAngleLoc(Args.getLAngleLoc()); 1909 TL.setRAngleLoc(Args.getRAngleLoc()); 1910 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 1911 TL.setArgLocInfo(i, Args[i].getLocInfo()); 1912 return DI; 1913} 1914 1915QualType 1916ASTContext::getTemplateSpecializationType(TemplateName Template, 1917 const TemplateArgumentListInfo &Args, 1918 QualType Canon) { 1919 unsigned NumArgs = Args.size(); 1920 1921 llvm::SmallVector<TemplateArgument, 4> ArgVec; 1922 ArgVec.reserve(NumArgs); 1923 for (unsigned i = 0; i != NumArgs; ++i) 1924 ArgVec.push_back(Args[i].getArgument()); 1925 1926 return getTemplateSpecializationType(Template, ArgVec.data(), NumArgs, 1927 Canon); 1928} 1929 1930QualType 1931ASTContext::getTemplateSpecializationType(TemplateName Template, 1932 const TemplateArgument *Args, 1933 unsigned NumArgs, 1934 QualType Canon) { 1935 if (!Canon.isNull()) 1936 Canon = getCanonicalType(Canon); 1937 else 1938 Canon = getCanonicalTemplateSpecializationType(Template, Args, NumArgs); 1939 1940 // Allocate the (non-canonical) template specialization type, but don't 1941 // try to unique it: these types typically have location information that 1942 // we don't unique and don't want to lose. 1943 void *Mem = Allocate((sizeof(TemplateSpecializationType) + 1944 sizeof(TemplateArgument) * NumArgs), 1945 TypeAlignment); 1946 TemplateSpecializationType *Spec 1947 = new (Mem) TemplateSpecializationType(Template, 1948 Args, NumArgs, 1949 Canon); 1950 1951 Types.push_back(Spec); 1952 return QualType(Spec, 0); 1953} 1954 1955QualType 1956ASTContext::getCanonicalTemplateSpecializationType(TemplateName Template, 1957 const TemplateArgument *Args, 1958 unsigned NumArgs) { 1959 // Build the canonical template specialization type. 1960 TemplateName CanonTemplate = getCanonicalTemplateName(Template); 1961 llvm::SmallVector<TemplateArgument, 4> CanonArgs; 1962 CanonArgs.reserve(NumArgs); 1963 for (unsigned I = 0; I != NumArgs; ++I) 1964 CanonArgs.push_back(getCanonicalTemplateArgument(Args[I])); 1965 1966 // Determine whether this canonical template specialization type already 1967 // exists. 1968 llvm::FoldingSetNodeID ID; 1969 TemplateSpecializationType::Profile(ID, CanonTemplate, 1970 CanonArgs.data(), NumArgs, *this); 1971 1972 void *InsertPos = 0; 1973 TemplateSpecializationType *Spec 1974 = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 1975 1976 if (!Spec) { 1977 // Allocate a new canonical template specialization type. 1978 void *Mem = Allocate((sizeof(TemplateSpecializationType) + 1979 sizeof(TemplateArgument) * NumArgs), 1980 TypeAlignment); 1981 Spec = new (Mem) TemplateSpecializationType(CanonTemplate, 1982 CanonArgs.data(), NumArgs, 1983 QualType()); 1984 Types.push_back(Spec); 1985 TemplateSpecializationTypes.InsertNode(Spec, InsertPos); 1986 } 1987 1988 assert(Spec->isDependentType() && 1989 "Non-dependent template-id type must have a canonical type"); 1990 return QualType(Spec, 0); 1991} 1992 1993QualType 1994ASTContext::getElaboratedType(ElaboratedTypeKeyword Keyword, 1995 NestedNameSpecifier *NNS, 1996 QualType NamedType) { 1997 llvm::FoldingSetNodeID ID; 1998 ElaboratedType::Profile(ID, Keyword, NNS, NamedType); 1999 2000 void *InsertPos = 0; 2001 ElaboratedType *T = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos); 2002 if (T) 2003 return QualType(T, 0); 2004 2005 QualType Canon = NamedType; 2006 if (!Canon.isCanonical()) { 2007 Canon = getCanonicalType(NamedType); 2008 ElaboratedType *CheckT = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos); 2009 assert(!CheckT && "Elaborated canonical type broken"); 2010 (void)CheckT; 2011 } 2012 2013 T = new (*this) ElaboratedType(Keyword, NNS, NamedType, Canon); 2014 Types.push_back(T); 2015 ElaboratedTypes.InsertNode(T, InsertPos); 2016 return QualType(T, 0); 2017} 2018 2019QualType ASTContext::getDependentNameType(ElaboratedTypeKeyword Keyword, 2020 NestedNameSpecifier *NNS, 2021 const IdentifierInfo *Name, 2022 QualType Canon) { 2023 assert(NNS->isDependent() && "nested-name-specifier must be dependent"); 2024 2025 if (Canon.isNull()) { 2026 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 2027 ElaboratedTypeKeyword CanonKeyword = Keyword; 2028 if (Keyword == ETK_None) 2029 CanonKeyword = ETK_Typename; 2030 2031 if (CanonNNS != NNS || CanonKeyword != Keyword) 2032 Canon = getDependentNameType(CanonKeyword, CanonNNS, Name); 2033 } 2034 2035 llvm::FoldingSetNodeID ID; 2036 DependentNameType::Profile(ID, Keyword, NNS, Name); 2037 2038 void *InsertPos = 0; 2039 DependentNameType *T 2040 = DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos); 2041 if (T) 2042 return QualType(T, 0); 2043 2044 T = new (*this) DependentNameType(Keyword, NNS, Name, Canon); 2045 Types.push_back(T); 2046 DependentNameTypes.InsertNode(T, InsertPos); 2047 return QualType(T, 0); 2048} 2049 2050QualType 2051ASTContext::getDependentTemplateSpecializationType( 2052 ElaboratedTypeKeyword Keyword, 2053 NestedNameSpecifier *NNS, 2054 const IdentifierInfo *Name, 2055 const TemplateArgumentListInfo &Args) { 2056 // TODO: avoid this copy 2057 llvm::SmallVector<TemplateArgument, 16> ArgCopy; 2058 for (unsigned I = 0, E = Args.size(); I != E; ++I) 2059 ArgCopy.push_back(Args[I].getArgument()); 2060 return getDependentTemplateSpecializationType(Keyword, NNS, Name, 2061 ArgCopy.size(), 2062 ArgCopy.data()); 2063} 2064 2065QualType 2066ASTContext::getDependentTemplateSpecializationType( 2067 ElaboratedTypeKeyword Keyword, 2068 NestedNameSpecifier *NNS, 2069 const IdentifierInfo *Name, 2070 unsigned NumArgs, 2071 const TemplateArgument *Args) { 2072 assert(NNS->isDependent() && "nested-name-specifier must be dependent"); 2073 2074 llvm::FoldingSetNodeID ID; 2075 DependentTemplateSpecializationType::Profile(ID, *this, Keyword, NNS, 2076 Name, NumArgs, Args); 2077 2078 void *InsertPos = 0; 2079 DependentTemplateSpecializationType *T 2080 = DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 2081 if (T) 2082 return QualType(T, 0); 2083 2084 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 2085 2086 ElaboratedTypeKeyword CanonKeyword = Keyword; 2087 if (Keyword == ETK_None) CanonKeyword = ETK_Typename; 2088 2089 bool AnyNonCanonArgs = false; 2090 llvm::SmallVector<TemplateArgument, 16> CanonArgs(NumArgs); 2091 for (unsigned I = 0; I != NumArgs; ++I) { 2092 CanonArgs[I] = getCanonicalTemplateArgument(Args[I]); 2093 if (!CanonArgs[I].structurallyEquals(Args[I])) 2094 AnyNonCanonArgs = true; 2095 } 2096 2097 QualType Canon; 2098 if (AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) { 2099 Canon = getDependentTemplateSpecializationType(CanonKeyword, CanonNNS, 2100 Name, NumArgs, 2101 CanonArgs.data()); 2102 2103 // Find the insert position again. 2104 DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 2105 } 2106 2107 void *Mem = Allocate((sizeof(DependentTemplateSpecializationType) + 2108 sizeof(TemplateArgument) * NumArgs), 2109 TypeAlignment); 2110 T = new (Mem) DependentTemplateSpecializationType(Keyword, NNS, 2111 Name, NumArgs, Args, Canon); 2112 Types.push_back(T); 2113 DependentTemplateSpecializationTypes.InsertNode(T, InsertPos); 2114 return QualType(T, 0); 2115} 2116 2117/// CmpProtocolNames - Comparison predicate for sorting protocols 2118/// alphabetically. 2119static bool CmpProtocolNames(const ObjCProtocolDecl *LHS, 2120 const ObjCProtocolDecl *RHS) { 2121 return LHS->getDeclName() < RHS->getDeclName(); 2122} 2123 2124static bool areSortedAndUniqued(ObjCProtocolDecl * const *Protocols, 2125 unsigned NumProtocols) { 2126 if (NumProtocols == 0) return true; 2127 2128 for (unsigned i = 1; i != NumProtocols; ++i) 2129 if (!CmpProtocolNames(Protocols[i-1], Protocols[i])) 2130 return false; 2131 return true; 2132} 2133 2134static void SortAndUniqueProtocols(ObjCProtocolDecl **Protocols, 2135 unsigned &NumProtocols) { 2136 ObjCProtocolDecl **ProtocolsEnd = Protocols+NumProtocols; 2137 2138 // Sort protocols, keyed by name. 2139 std::sort(Protocols, Protocols+NumProtocols, CmpProtocolNames); 2140 2141 // Remove duplicates. 2142 ProtocolsEnd = std::unique(Protocols, ProtocolsEnd); 2143 NumProtocols = ProtocolsEnd-Protocols; 2144} 2145 2146QualType ASTContext::getObjCObjectType(QualType BaseType, 2147 ObjCProtocolDecl * const *Protocols, 2148 unsigned NumProtocols) { 2149 // If the base type is an interface and there aren't any protocols 2150 // to add, then the interface type will do just fine. 2151 if (!NumProtocols && isa<ObjCInterfaceType>(BaseType)) 2152 return BaseType; 2153 2154 // Look in the folding set for an existing type. 2155 llvm::FoldingSetNodeID ID; 2156 ObjCObjectTypeImpl::Profile(ID, BaseType, Protocols, NumProtocols); 2157 void *InsertPos = 0; 2158 if (ObjCObjectType *QT = ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos)) 2159 return QualType(QT, 0); 2160 2161 // Build the canonical type, which has the canonical base type and 2162 // a sorted-and-uniqued list of protocols. 2163 QualType Canonical; 2164 bool ProtocolsSorted = areSortedAndUniqued(Protocols, NumProtocols); 2165 if (!ProtocolsSorted || !BaseType.isCanonical()) { 2166 if (!ProtocolsSorted) { 2167 llvm::SmallVector<ObjCProtocolDecl*, 8> Sorted(Protocols, 2168 Protocols + NumProtocols); 2169 unsigned UniqueCount = NumProtocols; 2170 2171 SortAndUniqueProtocols(&Sorted[0], UniqueCount); 2172 Canonical = getObjCObjectType(getCanonicalType(BaseType), 2173 &Sorted[0], UniqueCount); 2174 } else { 2175 Canonical = getObjCObjectType(getCanonicalType(BaseType), 2176 Protocols, NumProtocols); 2177 } 2178 2179 // Regenerate InsertPos. 2180 ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos); 2181 } 2182 2183 unsigned Size = sizeof(ObjCObjectTypeImpl); 2184 Size += NumProtocols * sizeof(ObjCProtocolDecl *); 2185 void *Mem = Allocate(Size, TypeAlignment); 2186 ObjCObjectTypeImpl *T = 2187 new (Mem) ObjCObjectTypeImpl(Canonical, BaseType, Protocols, NumProtocols); 2188 2189 Types.push_back(T); 2190 ObjCObjectTypes.InsertNode(T, InsertPos); 2191 return QualType(T, 0); 2192} 2193 2194/// getObjCObjectPointerType - Return a ObjCObjectPointerType type for 2195/// the given object type. 2196QualType ASTContext::getObjCObjectPointerType(QualType ObjectT) { 2197 llvm::FoldingSetNodeID ID; 2198 ObjCObjectPointerType::Profile(ID, ObjectT); 2199 2200 void *InsertPos = 0; 2201 if (ObjCObjectPointerType *QT = 2202 ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 2203 return QualType(QT, 0); 2204 2205 // Find the canonical object type. 2206 QualType Canonical; 2207 if (!ObjectT.isCanonical()) { 2208 Canonical = getObjCObjectPointerType(getCanonicalType(ObjectT)); 2209 2210 // Regenerate InsertPos. 2211 ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 2212 } 2213 2214 // No match. 2215 void *Mem = Allocate(sizeof(ObjCObjectPointerType), TypeAlignment); 2216 ObjCObjectPointerType *QType = 2217 new (Mem) ObjCObjectPointerType(Canonical, ObjectT); 2218 2219 Types.push_back(QType); 2220 ObjCObjectPointerTypes.InsertNode(QType, InsertPos); 2221 return QualType(QType, 0); 2222} 2223 2224/// getObjCInterfaceType - Return the unique reference to the type for the 2225/// specified ObjC interface decl. The list of protocols is optional. 2226QualType ASTContext::getObjCInterfaceType(const ObjCInterfaceDecl *Decl) { 2227 if (Decl->TypeForDecl) 2228 return QualType(Decl->TypeForDecl, 0); 2229 2230 // FIXME: redeclarations? 2231 void *Mem = Allocate(sizeof(ObjCInterfaceType), TypeAlignment); 2232 ObjCInterfaceType *T = new (Mem) ObjCInterfaceType(Decl); 2233 Decl->TypeForDecl = T; 2234 Types.push_back(T); 2235 return QualType(T, 0); 2236} 2237 2238/// getTypeOfExprType - Unlike many "get<Type>" functions, we can't unique 2239/// TypeOfExprType AST's (since expression's are never shared). For example, 2240/// multiple declarations that refer to "typeof(x)" all contain different 2241/// DeclRefExpr's. This doesn't effect the type checker, since it operates 2242/// on canonical type's (which are always unique). 2243QualType ASTContext::getTypeOfExprType(Expr *tofExpr) { 2244 TypeOfExprType *toe; 2245 if (tofExpr->isTypeDependent()) { 2246 llvm::FoldingSetNodeID ID; 2247 DependentTypeOfExprType::Profile(ID, *this, tofExpr); 2248 2249 void *InsertPos = 0; 2250 DependentTypeOfExprType *Canon 2251 = DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos); 2252 if (Canon) { 2253 // We already have a "canonical" version of an identical, dependent 2254 // typeof(expr) type. Use that as our canonical type. 2255 toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, 2256 QualType((TypeOfExprType*)Canon, 0)); 2257 } 2258 else { 2259 // Build a new, canonical typeof(expr) type. 2260 Canon 2261 = new (*this, TypeAlignment) DependentTypeOfExprType(*this, tofExpr); 2262 DependentTypeOfExprTypes.InsertNode(Canon, InsertPos); 2263 toe = Canon; 2264 } 2265 } else { 2266 QualType Canonical = getCanonicalType(tofExpr->getType()); 2267 toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, Canonical); 2268 } 2269 Types.push_back(toe); 2270 return QualType(toe, 0); 2271} 2272 2273/// getTypeOfType - Unlike many "get<Type>" functions, we don't unique 2274/// TypeOfType AST's. The only motivation to unique these nodes would be 2275/// memory savings. Since typeof(t) is fairly uncommon, space shouldn't be 2276/// an issue. This doesn't effect the type checker, since it operates 2277/// on canonical type's (which are always unique). 2278QualType ASTContext::getTypeOfType(QualType tofType) { 2279 QualType Canonical = getCanonicalType(tofType); 2280 TypeOfType *tot = new (*this, TypeAlignment) TypeOfType(tofType, Canonical); 2281 Types.push_back(tot); 2282 return QualType(tot, 0); 2283} 2284 2285/// getDecltypeForExpr - Given an expr, will return the decltype for that 2286/// expression, according to the rules in C++0x [dcl.type.simple]p4 2287static QualType getDecltypeForExpr(const Expr *e, ASTContext &Context) { 2288 if (e->isTypeDependent()) 2289 return Context.DependentTy; 2290 2291 // If e is an id expression or a class member access, decltype(e) is defined 2292 // as the type of the entity named by e. 2293 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(e)) { 2294 if (const ValueDecl *VD = dyn_cast<ValueDecl>(DRE->getDecl())) 2295 return VD->getType(); 2296 } 2297 if (const MemberExpr *ME = dyn_cast<MemberExpr>(e)) { 2298 if (const FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) 2299 return FD->getType(); 2300 } 2301 // If e is a function call or an invocation of an overloaded operator, 2302 // (parentheses around e are ignored), decltype(e) is defined as the 2303 // return type of that function. 2304 if (const CallExpr *CE = dyn_cast<CallExpr>(e->IgnoreParens())) 2305 return CE->getCallReturnType(); 2306 2307 QualType T = e->getType(); 2308 2309 // Otherwise, where T is the type of e, if e is an lvalue, decltype(e) is 2310 // defined as T&, otherwise decltype(e) is defined as T. 2311 if (e->isLvalue(Context) == Expr::LV_Valid) 2312 T = Context.getLValueReferenceType(T); 2313 2314 return T; 2315} 2316 2317/// getDecltypeType - Unlike many "get<Type>" functions, we don't unique 2318/// DecltypeType AST's. The only motivation to unique these nodes would be 2319/// memory savings. Since decltype(t) is fairly uncommon, space shouldn't be 2320/// an issue. This doesn't effect the type checker, since it operates 2321/// on canonical type's (which are always unique). 2322QualType ASTContext::getDecltypeType(Expr *e) { 2323 DecltypeType *dt; 2324 if (e->isTypeDependent()) { 2325 llvm::FoldingSetNodeID ID; 2326 DependentDecltypeType::Profile(ID, *this, e); 2327 2328 void *InsertPos = 0; 2329 DependentDecltypeType *Canon 2330 = DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos); 2331 if (Canon) { 2332 // We already have a "canonical" version of an equivalent, dependent 2333 // decltype type. Use that as our canonical type. 2334 dt = new (*this, TypeAlignment) DecltypeType(e, DependentTy, 2335 QualType((DecltypeType*)Canon, 0)); 2336 } 2337 else { 2338 // Build a new, canonical typeof(expr) type. 2339 Canon = new (*this, TypeAlignment) DependentDecltypeType(*this, e); 2340 DependentDecltypeTypes.InsertNode(Canon, InsertPos); 2341 dt = Canon; 2342 } 2343 } else { 2344 QualType T = getDecltypeForExpr(e, *this); 2345 dt = new (*this, TypeAlignment) DecltypeType(e, T, getCanonicalType(T)); 2346 } 2347 Types.push_back(dt); 2348 return QualType(dt, 0); 2349} 2350 2351/// getTagDeclType - Return the unique reference to the type for the 2352/// specified TagDecl (struct/union/class/enum) decl. 2353QualType ASTContext::getTagDeclType(const TagDecl *Decl) { 2354 assert (Decl); 2355 // FIXME: What is the design on getTagDeclType when it requires casting 2356 // away const? mutable? 2357 return getTypeDeclType(const_cast<TagDecl*>(Decl)); 2358} 2359 2360/// getSizeType - Return the unique type for "size_t" (C99 7.17), the result 2361/// of the sizeof operator (C99 6.5.3.4p4). The value is target dependent and 2362/// needs to agree with the definition in <stddef.h>. 2363CanQualType ASTContext::getSizeType() const { 2364 return getFromTargetType(Target.getSizeType()); 2365} 2366 2367/// getSignedWCharType - Return the type of "signed wchar_t". 2368/// Used when in C++, as a GCC extension. 2369QualType ASTContext::getSignedWCharType() const { 2370 // FIXME: derive from "Target" ? 2371 return WCharTy; 2372} 2373 2374/// getUnsignedWCharType - Return the type of "unsigned wchar_t". 2375/// Used when in C++, as a GCC extension. 2376QualType ASTContext::getUnsignedWCharType() const { 2377 // FIXME: derive from "Target" ? 2378 return UnsignedIntTy; 2379} 2380 2381/// getPointerDiffType - Return the unique type for "ptrdiff_t" (ref?) 2382/// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9). 2383QualType ASTContext::getPointerDiffType() const { 2384 return getFromTargetType(Target.getPtrDiffType(0)); 2385} 2386 2387//===----------------------------------------------------------------------===// 2388// Type Operators 2389//===----------------------------------------------------------------------===// 2390 2391CanQualType ASTContext::getCanonicalParamType(QualType T) { 2392 // Push qualifiers into arrays, and then discard any remaining 2393 // qualifiers. 2394 T = getCanonicalType(T); 2395 const Type *Ty = T.getTypePtr(); 2396 2397 QualType Result; 2398 if (isa<ArrayType>(Ty)) { 2399 Result = getArrayDecayedType(QualType(Ty,0)); 2400 } else if (isa<FunctionType>(Ty)) { 2401 Result = getPointerType(QualType(Ty, 0)); 2402 } else { 2403 Result = QualType(Ty, 0); 2404 } 2405 2406 return CanQualType::CreateUnsafe(Result); 2407} 2408 2409/// getCanonicalType - Return the canonical (structural) type corresponding to 2410/// the specified potentially non-canonical type. The non-canonical version 2411/// of a type may have many "decorated" versions of types. Decorators can 2412/// include typedefs, 'typeof' operators, etc. The returned type is guaranteed 2413/// to be free of any of these, allowing two canonical types to be compared 2414/// for exact equality with a simple pointer comparison. 2415CanQualType ASTContext::getCanonicalType(QualType T) { 2416 QualifierCollector Quals; 2417 const Type *Ptr = Quals.strip(T); 2418 QualType CanType = Ptr->getCanonicalTypeInternal(); 2419 2420 // The canonical internal type will be the canonical type *except* 2421 // that we push type qualifiers down through array types. 2422 2423 // If there are no new qualifiers to push down, stop here. 2424 if (!Quals.hasQualifiers()) 2425 return CanQualType::CreateUnsafe(CanType); 2426 2427 // If the type qualifiers are on an array type, get the canonical 2428 // type of the array with the qualifiers applied to the element 2429 // type. 2430 ArrayType *AT = dyn_cast<ArrayType>(CanType); 2431 if (!AT) 2432 return CanQualType::CreateUnsafe(getQualifiedType(CanType, Quals)); 2433 2434 // Get the canonical version of the element with the extra qualifiers on it. 2435 // This can recursively sink qualifiers through multiple levels of arrays. 2436 QualType NewEltTy = getQualifiedType(AT->getElementType(), Quals); 2437 NewEltTy = getCanonicalType(NewEltTy); 2438 2439 if (ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) 2440 return CanQualType::CreateUnsafe( 2441 getConstantArrayType(NewEltTy, CAT->getSize(), 2442 CAT->getSizeModifier(), 2443 CAT->getIndexTypeCVRQualifiers())); 2444 if (IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) 2445 return CanQualType::CreateUnsafe( 2446 getIncompleteArrayType(NewEltTy, IAT->getSizeModifier(), 2447 IAT->getIndexTypeCVRQualifiers())); 2448 2449 if (DependentSizedArrayType *DSAT = dyn_cast<DependentSizedArrayType>(AT)) 2450 return CanQualType::CreateUnsafe( 2451 getDependentSizedArrayType(NewEltTy, 2452 DSAT->getSizeExpr() ? 2453 DSAT->getSizeExpr()->Retain() : 0, 2454 DSAT->getSizeModifier(), 2455 DSAT->getIndexTypeCVRQualifiers(), 2456 DSAT->getBracketsRange())->getCanonicalTypeInternal()); 2457 2458 VariableArrayType *VAT = cast<VariableArrayType>(AT); 2459 return CanQualType::CreateUnsafe(getVariableArrayType(NewEltTy, 2460 VAT->getSizeExpr() ? 2461 VAT->getSizeExpr()->Retain() : 0, 2462 VAT->getSizeModifier(), 2463 VAT->getIndexTypeCVRQualifiers(), 2464 VAT->getBracketsRange())); 2465} 2466 2467QualType ASTContext::getUnqualifiedArrayType(QualType T, 2468 Qualifiers &Quals) { 2469 Quals = T.getQualifiers(); 2470 const ArrayType *AT = getAsArrayType(T); 2471 if (!AT) { 2472 return T.getUnqualifiedType(); 2473 } 2474 2475 QualType Elt = AT->getElementType(); 2476 QualType UnqualElt = getUnqualifiedArrayType(Elt, Quals); 2477 if (Elt == UnqualElt) 2478 return T; 2479 2480 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) { 2481 return getConstantArrayType(UnqualElt, CAT->getSize(), 2482 CAT->getSizeModifier(), 0); 2483 } 2484 2485 if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) { 2486 return getIncompleteArrayType(UnqualElt, IAT->getSizeModifier(), 0); 2487 } 2488 2489 if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(AT)) { 2490 return getVariableArrayType(UnqualElt, 2491 VAT->getSizeExpr() ? 2492 VAT->getSizeExpr()->Retain() : 0, 2493 VAT->getSizeModifier(), 2494 VAT->getIndexTypeCVRQualifiers(), 2495 VAT->getBracketsRange()); 2496 } 2497 2498 const DependentSizedArrayType *DSAT = cast<DependentSizedArrayType>(AT); 2499 return getDependentSizedArrayType(UnqualElt, DSAT->getSizeExpr()->Retain(), 2500 DSAT->getSizeModifier(), 0, 2501 SourceRange()); 2502} 2503 2504/// UnwrapSimilarPointerTypes - If T1 and T2 are pointer types that 2505/// may be similar (C++ 4.4), replaces T1 and T2 with the type that 2506/// they point to and return true. If T1 and T2 aren't pointer types 2507/// or pointer-to-member types, or if they are not similar at this 2508/// level, returns false and leaves T1 and T2 unchanged. Top-level 2509/// qualifiers on T1 and T2 are ignored. This function will typically 2510/// be called in a loop that successively "unwraps" pointer and 2511/// pointer-to-member types to compare them at each level. 2512bool ASTContext::UnwrapSimilarPointerTypes(QualType &T1, QualType &T2) { 2513 const PointerType *T1PtrType = T1->getAs<PointerType>(), 2514 *T2PtrType = T2->getAs<PointerType>(); 2515 if (T1PtrType && T2PtrType) { 2516 T1 = T1PtrType->getPointeeType(); 2517 T2 = T2PtrType->getPointeeType(); 2518 return true; 2519 } 2520 2521 const MemberPointerType *T1MPType = T1->getAs<MemberPointerType>(), 2522 *T2MPType = T2->getAs<MemberPointerType>(); 2523 if (T1MPType && T2MPType && 2524 hasSameUnqualifiedType(QualType(T1MPType->getClass(), 0), 2525 QualType(T2MPType->getClass(), 0))) { 2526 T1 = T1MPType->getPointeeType(); 2527 T2 = T2MPType->getPointeeType(); 2528 return true; 2529 } 2530 2531 if (getLangOptions().ObjC1) { 2532 const ObjCObjectPointerType *T1OPType = T1->getAs<ObjCObjectPointerType>(), 2533 *T2OPType = T2->getAs<ObjCObjectPointerType>(); 2534 if (T1OPType && T2OPType) { 2535 T1 = T1OPType->getPointeeType(); 2536 T2 = T2OPType->getPointeeType(); 2537 return true; 2538 } 2539 } 2540 2541 // FIXME: Block pointers, too? 2542 2543 return false; 2544} 2545 2546DeclarationNameInfo ASTContext::getNameForTemplate(TemplateName Name, 2547 SourceLocation NameLoc) { 2548 if (TemplateDecl *TD = Name.getAsTemplateDecl()) 2549 // DNInfo work in progress: CHECKME: what about DNLoc? 2550 return DeclarationNameInfo(TD->getDeclName(), NameLoc); 2551 2552 if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) { 2553 DeclarationName DName; 2554 if (DTN->isIdentifier()) { 2555 DName = DeclarationNames.getIdentifier(DTN->getIdentifier()); 2556 return DeclarationNameInfo(DName, NameLoc); 2557 } else { 2558 DName = DeclarationNames.getCXXOperatorName(DTN->getOperator()); 2559 // DNInfo work in progress: FIXME: source locations? 2560 DeclarationNameLoc DNLoc; 2561 DNLoc.CXXOperatorName.BeginOpNameLoc = SourceLocation().getRawEncoding(); 2562 DNLoc.CXXOperatorName.EndOpNameLoc = SourceLocation().getRawEncoding(); 2563 return DeclarationNameInfo(DName, NameLoc, DNLoc); 2564 } 2565 } 2566 2567 OverloadedTemplateStorage *Storage = Name.getAsOverloadedTemplate(); 2568 assert(Storage); 2569 // DNInfo work in progress: CHECKME: what about DNLoc? 2570 return DeclarationNameInfo((*Storage->begin())->getDeclName(), NameLoc); 2571} 2572 2573TemplateName ASTContext::getCanonicalTemplateName(TemplateName Name) { 2574 if (TemplateDecl *Template = Name.getAsTemplateDecl()) { 2575 if (TemplateTemplateParmDecl *TTP 2576 = dyn_cast<TemplateTemplateParmDecl>(Template)) 2577 Template = getCanonicalTemplateTemplateParmDecl(TTP); 2578 2579 // The canonical template name is the canonical template declaration. 2580 return TemplateName(cast<TemplateDecl>(Template->getCanonicalDecl())); 2581 } 2582 2583 assert(!Name.getAsOverloadedTemplate()); 2584 2585 DependentTemplateName *DTN = Name.getAsDependentTemplateName(); 2586 assert(DTN && "Non-dependent template names must refer to template decls."); 2587 return DTN->CanonicalTemplateName; 2588} 2589 2590bool ASTContext::hasSameTemplateName(TemplateName X, TemplateName Y) { 2591 X = getCanonicalTemplateName(X); 2592 Y = getCanonicalTemplateName(Y); 2593 return X.getAsVoidPointer() == Y.getAsVoidPointer(); 2594} 2595 2596TemplateArgument 2597ASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) { 2598 switch (Arg.getKind()) { 2599 case TemplateArgument::Null: 2600 return Arg; 2601 2602 case TemplateArgument::Expression: 2603 return Arg; 2604 2605 case TemplateArgument::Declaration: 2606 return TemplateArgument(Arg.getAsDecl()->getCanonicalDecl()); 2607 2608 case TemplateArgument::Template: 2609 return TemplateArgument(getCanonicalTemplateName(Arg.getAsTemplate())); 2610 2611 case TemplateArgument::Integral: 2612 return TemplateArgument(*Arg.getAsIntegral(), 2613 getCanonicalType(Arg.getIntegralType())); 2614 2615 case TemplateArgument::Type: 2616 return TemplateArgument(getCanonicalType(Arg.getAsType())); 2617 2618 case TemplateArgument::Pack: { 2619 // FIXME: Allocate in ASTContext 2620 TemplateArgument *CanonArgs = new TemplateArgument[Arg.pack_size()]; 2621 unsigned Idx = 0; 2622 for (TemplateArgument::pack_iterator A = Arg.pack_begin(), 2623 AEnd = Arg.pack_end(); 2624 A != AEnd; (void)++A, ++Idx) 2625 CanonArgs[Idx] = getCanonicalTemplateArgument(*A); 2626 2627 TemplateArgument Result; 2628 Result.setArgumentPack(CanonArgs, Arg.pack_size(), false); 2629 return Result; 2630 } 2631 } 2632 2633 // Silence GCC warning 2634 assert(false && "Unhandled template argument kind"); 2635 return TemplateArgument(); 2636} 2637 2638NestedNameSpecifier * 2639ASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) { 2640 if (!NNS) 2641 return 0; 2642 2643 switch (NNS->getKind()) { 2644 case NestedNameSpecifier::Identifier: 2645 // Canonicalize the prefix but keep the identifier the same. 2646 return NestedNameSpecifier::Create(*this, 2647 getCanonicalNestedNameSpecifier(NNS->getPrefix()), 2648 NNS->getAsIdentifier()); 2649 2650 case NestedNameSpecifier::Namespace: 2651 // A namespace is canonical; build a nested-name-specifier with 2652 // this namespace and no prefix. 2653 return NestedNameSpecifier::Create(*this, 0, NNS->getAsNamespace()); 2654 2655 case NestedNameSpecifier::TypeSpec: 2656 case NestedNameSpecifier::TypeSpecWithTemplate: { 2657 QualType T = getCanonicalType(QualType(NNS->getAsType(), 0)); 2658 return NestedNameSpecifier::Create(*this, 0, 2659 NNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate, 2660 T.getTypePtr()); 2661 } 2662 2663 case NestedNameSpecifier::Global: 2664 // The global specifier is canonical and unique. 2665 return NNS; 2666 } 2667 2668 // Required to silence a GCC warning 2669 return 0; 2670} 2671 2672 2673const ArrayType *ASTContext::getAsArrayType(QualType T) { 2674 // Handle the non-qualified case efficiently. 2675 if (!T.hasLocalQualifiers()) { 2676 // Handle the common positive case fast. 2677 if (const ArrayType *AT = dyn_cast<ArrayType>(T)) 2678 return AT; 2679 } 2680 2681 // Handle the common negative case fast. 2682 QualType CType = T->getCanonicalTypeInternal(); 2683 if (!isa<ArrayType>(CType)) 2684 return 0; 2685 2686 // Apply any qualifiers from the array type to the element type. This 2687 // implements C99 6.7.3p8: "If the specification of an array type includes 2688 // any type qualifiers, the element type is so qualified, not the array type." 2689 2690 // If we get here, we either have type qualifiers on the type, or we have 2691 // sugar such as a typedef in the way. If we have type qualifiers on the type 2692 // we must propagate them down into the element type. 2693 2694 QualifierCollector Qs; 2695 const Type *Ty = Qs.strip(T.getDesugaredType()); 2696 2697 // If we have a simple case, just return now. 2698 const ArrayType *ATy = dyn_cast<ArrayType>(Ty); 2699 if (ATy == 0 || Qs.empty()) 2700 return ATy; 2701 2702 // Otherwise, we have an array and we have qualifiers on it. Push the 2703 // qualifiers into the array element type and return a new array type. 2704 // Get the canonical version of the element with the extra qualifiers on it. 2705 // This can recursively sink qualifiers through multiple levels of arrays. 2706 QualType NewEltTy = getQualifiedType(ATy->getElementType(), Qs); 2707 2708 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(ATy)) 2709 return cast<ArrayType>(getConstantArrayType(NewEltTy, CAT->getSize(), 2710 CAT->getSizeModifier(), 2711 CAT->getIndexTypeCVRQualifiers())); 2712 if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(ATy)) 2713 return cast<ArrayType>(getIncompleteArrayType(NewEltTy, 2714 IAT->getSizeModifier(), 2715 IAT->getIndexTypeCVRQualifiers())); 2716 2717 if (const DependentSizedArrayType *DSAT 2718 = dyn_cast<DependentSizedArrayType>(ATy)) 2719 return cast<ArrayType>( 2720 getDependentSizedArrayType(NewEltTy, 2721 DSAT->getSizeExpr() ? 2722 DSAT->getSizeExpr()->Retain() : 0, 2723 DSAT->getSizeModifier(), 2724 DSAT->getIndexTypeCVRQualifiers(), 2725 DSAT->getBracketsRange())); 2726 2727 const VariableArrayType *VAT = cast<VariableArrayType>(ATy); 2728 return cast<ArrayType>(getVariableArrayType(NewEltTy, 2729 VAT->getSizeExpr() ? 2730 VAT->getSizeExpr()->Retain() : 0, 2731 VAT->getSizeModifier(), 2732 VAT->getIndexTypeCVRQualifiers(), 2733 VAT->getBracketsRange())); 2734} 2735 2736 2737/// getArrayDecayedType - Return the properly qualified result of decaying the 2738/// specified array type to a pointer. This operation is non-trivial when 2739/// handling typedefs etc. The canonical type of "T" must be an array type, 2740/// this returns a pointer to a properly qualified element of the array. 2741/// 2742/// See C99 6.7.5.3p7 and C99 6.3.2.1p3. 2743QualType ASTContext::getArrayDecayedType(QualType Ty) { 2744 // Get the element type with 'getAsArrayType' so that we don't lose any 2745 // typedefs in the element type of the array. This also handles propagation 2746 // of type qualifiers from the array type into the element type if present 2747 // (C99 6.7.3p8). 2748 const ArrayType *PrettyArrayType = getAsArrayType(Ty); 2749 assert(PrettyArrayType && "Not an array type!"); 2750 2751 QualType PtrTy = getPointerType(PrettyArrayType->getElementType()); 2752 2753 // int x[restrict 4] -> int *restrict 2754 return getQualifiedType(PtrTy, PrettyArrayType->getIndexTypeQualifiers()); 2755} 2756 2757QualType ASTContext::getBaseElementType(QualType QT) { 2758 QualifierCollector Qs; 2759 while (const ArrayType *AT = getAsArrayType(QualType(Qs.strip(QT), 0))) 2760 QT = AT->getElementType(); 2761 return Qs.apply(QT); 2762} 2763 2764QualType ASTContext::getBaseElementType(const ArrayType *AT) { 2765 QualType ElemTy = AT->getElementType(); 2766 2767 if (const ArrayType *AT = getAsArrayType(ElemTy)) 2768 return getBaseElementType(AT); 2769 2770 return ElemTy; 2771} 2772 2773/// getConstantArrayElementCount - Returns number of constant array elements. 2774uint64_t 2775ASTContext::getConstantArrayElementCount(const ConstantArrayType *CA) const { 2776 uint64_t ElementCount = 1; 2777 do { 2778 ElementCount *= CA->getSize().getZExtValue(); 2779 CA = dyn_cast<ConstantArrayType>(CA->getElementType()); 2780 } while (CA); 2781 return ElementCount; 2782} 2783 2784/// getFloatingRank - Return a relative rank for floating point types. 2785/// This routine will assert if passed a built-in type that isn't a float. 2786static FloatingRank getFloatingRank(QualType T) { 2787 if (const ComplexType *CT = T->getAs<ComplexType>()) 2788 return getFloatingRank(CT->getElementType()); 2789 2790 assert(T->getAs<BuiltinType>() && "getFloatingRank(): not a floating type"); 2791 switch (T->getAs<BuiltinType>()->getKind()) { 2792 default: assert(0 && "getFloatingRank(): not a floating type"); 2793 case BuiltinType::Float: return FloatRank; 2794 case BuiltinType::Double: return DoubleRank; 2795 case BuiltinType::LongDouble: return LongDoubleRank; 2796 } 2797} 2798 2799/// getFloatingTypeOfSizeWithinDomain - Returns a real floating 2800/// point or a complex type (based on typeDomain/typeSize). 2801/// 'typeDomain' is a real floating point or complex type. 2802/// 'typeSize' is a real floating point or complex type. 2803QualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size, 2804 QualType Domain) const { 2805 FloatingRank EltRank = getFloatingRank(Size); 2806 if (Domain->isComplexType()) { 2807 switch (EltRank) { 2808 default: assert(0 && "getFloatingRank(): illegal value for rank"); 2809 case FloatRank: return FloatComplexTy; 2810 case DoubleRank: return DoubleComplexTy; 2811 case LongDoubleRank: return LongDoubleComplexTy; 2812 } 2813 } 2814 2815 assert(Domain->isRealFloatingType() && "Unknown domain!"); 2816 switch (EltRank) { 2817 default: assert(0 && "getFloatingRank(): illegal value for rank"); 2818 case FloatRank: return FloatTy; 2819 case DoubleRank: return DoubleTy; 2820 case LongDoubleRank: return LongDoubleTy; 2821 } 2822} 2823 2824/// getFloatingTypeOrder - Compare the rank of the two specified floating 2825/// point types, ignoring the domain of the type (i.e. 'double' == 2826/// '_Complex double'). If LHS > RHS, return 1. If LHS == RHS, return 0. If 2827/// LHS < RHS, return -1. 2828int ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) { 2829 FloatingRank LHSR = getFloatingRank(LHS); 2830 FloatingRank RHSR = getFloatingRank(RHS); 2831 2832 if (LHSR == RHSR) 2833 return 0; 2834 if (LHSR > RHSR) 2835 return 1; 2836 return -1; 2837} 2838 2839/// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This 2840/// routine will assert if passed a built-in type that isn't an integer or enum, 2841/// or if it is not canonicalized. 2842unsigned ASTContext::getIntegerRank(Type *T) { 2843 assert(T->isCanonicalUnqualified() && "T should be canonicalized"); 2844 if (EnumType* ET = dyn_cast<EnumType>(T)) 2845 T = ET->getDecl()->getPromotionType().getTypePtr(); 2846 2847 if (T->isSpecificBuiltinType(BuiltinType::WChar)) 2848 T = getFromTargetType(Target.getWCharType()).getTypePtr(); 2849 2850 if (T->isSpecificBuiltinType(BuiltinType::Char16)) 2851 T = getFromTargetType(Target.getChar16Type()).getTypePtr(); 2852 2853 if (T->isSpecificBuiltinType(BuiltinType::Char32)) 2854 T = getFromTargetType(Target.getChar32Type()).getTypePtr(); 2855 2856 switch (cast<BuiltinType>(T)->getKind()) { 2857 default: assert(0 && "getIntegerRank(): not a built-in integer"); 2858 case BuiltinType::Bool: 2859 return 1 + (getIntWidth(BoolTy) << 3); 2860 case BuiltinType::Char_S: 2861 case BuiltinType::Char_U: 2862 case BuiltinType::SChar: 2863 case BuiltinType::UChar: 2864 return 2 + (getIntWidth(CharTy) << 3); 2865 case BuiltinType::Short: 2866 case BuiltinType::UShort: 2867 return 3 + (getIntWidth(ShortTy) << 3); 2868 case BuiltinType::Int: 2869 case BuiltinType::UInt: 2870 return 4 + (getIntWidth(IntTy) << 3); 2871 case BuiltinType::Long: 2872 case BuiltinType::ULong: 2873 return 5 + (getIntWidth(LongTy) << 3); 2874 case BuiltinType::LongLong: 2875 case BuiltinType::ULongLong: 2876 return 6 + (getIntWidth(LongLongTy) << 3); 2877 case BuiltinType::Int128: 2878 case BuiltinType::UInt128: 2879 return 7 + (getIntWidth(Int128Ty) << 3); 2880 } 2881} 2882 2883/// \brief Whether this is a promotable bitfield reference according 2884/// to C99 6.3.1.1p2, bullet 2 (and GCC extensions). 2885/// 2886/// \returns the type this bit-field will promote to, or NULL if no 2887/// promotion occurs. 2888QualType ASTContext::isPromotableBitField(Expr *E) { 2889 if (E->isTypeDependent() || E->isValueDependent()) 2890 return QualType(); 2891 2892 FieldDecl *Field = E->getBitField(); 2893 if (!Field) 2894 return QualType(); 2895 2896 QualType FT = Field->getType(); 2897 2898 llvm::APSInt BitWidthAP = Field->getBitWidth()->EvaluateAsInt(*this); 2899 uint64_t BitWidth = BitWidthAP.getZExtValue(); 2900 uint64_t IntSize = getTypeSize(IntTy); 2901 // GCC extension compatibility: if the bit-field size is less than or equal 2902 // to the size of int, it gets promoted no matter what its type is. 2903 // For instance, unsigned long bf : 4 gets promoted to signed int. 2904 if (BitWidth < IntSize) 2905 return IntTy; 2906 2907 if (BitWidth == IntSize) 2908 return FT->isSignedIntegerType() ? IntTy : UnsignedIntTy; 2909 2910 // Types bigger than int are not subject to promotions, and therefore act 2911 // like the base type. 2912 // FIXME: This doesn't quite match what gcc does, but what gcc does here 2913 // is ridiculous. 2914 return QualType(); 2915} 2916 2917/// getPromotedIntegerType - Returns the type that Promotable will 2918/// promote to: C99 6.3.1.1p2, assuming that Promotable is a promotable 2919/// integer type. 2920QualType ASTContext::getPromotedIntegerType(QualType Promotable) { 2921 assert(!Promotable.isNull()); 2922 assert(Promotable->isPromotableIntegerType()); 2923 if (const EnumType *ET = Promotable->getAs<EnumType>()) 2924 return ET->getDecl()->getPromotionType(); 2925 if (Promotable->isSignedIntegerType()) 2926 return IntTy; 2927 uint64_t PromotableSize = getTypeSize(Promotable); 2928 uint64_t IntSize = getTypeSize(IntTy); 2929 assert(Promotable->isUnsignedIntegerType() && PromotableSize <= IntSize); 2930 return (PromotableSize != IntSize) ? IntTy : UnsignedIntTy; 2931} 2932 2933/// getIntegerTypeOrder - Returns the highest ranked integer type: 2934/// C99 6.3.1.8p1. If LHS > RHS, return 1. If LHS == RHS, return 0. If 2935/// LHS < RHS, return -1. 2936int ASTContext::getIntegerTypeOrder(QualType LHS, QualType RHS) { 2937 Type *LHSC = getCanonicalType(LHS).getTypePtr(); 2938 Type *RHSC = getCanonicalType(RHS).getTypePtr(); 2939 if (LHSC == RHSC) return 0; 2940 2941 bool LHSUnsigned = LHSC->isUnsignedIntegerType(); 2942 bool RHSUnsigned = RHSC->isUnsignedIntegerType(); 2943 2944 unsigned LHSRank = getIntegerRank(LHSC); 2945 unsigned RHSRank = getIntegerRank(RHSC); 2946 2947 if (LHSUnsigned == RHSUnsigned) { // Both signed or both unsigned. 2948 if (LHSRank == RHSRank) return 0; 2949 return LHSRank > RHSRank ? 1 : -1; 2950 } 2951 2952 // Otherwise, the LHS is signed and the RHS is unsigned or visa versa. 2953 if (LHSUnsigned) { 2954 // If the unsigned [LHS] type is larger, return it. 2955 if (LHSRank >= RHSRank) 2956 return 1; 2957 2958 // If the signed type can represent all values of the unsigned type, it 2959 // wins. Because we are dealing with 2's complement and types that are 2960 // powers of two larger than each other, this is always safe. 2961 return -1; 2962 } 2963 2964 // If the unsigned [RHS] type is larger, return it. 2965 if (RHSRank >= LHSRank) 2966 return -1; 2967 2968 // If the signed type can represent all values of the unsigned type, it 2969 // wins. Because we are dealing with 2's complement and types that are 2970 // powers of two larger than each other, this is always safe. 2971 return 1; 2972} 2973 2974static RecordDecl * 2975CreateRecordDecl(ASTContext &Ctx, RecordDecl::TagKind TK, DeclContext *DC, 2976 SourceLocation L, IdentifierInfo *Id) { 2977 if (Ctx.getLangOptions().CPlusPlus) 2978 return CXXRecordDecl::Create(Ctx, TK, DC, L, Id); 2979 else 2980 return RecordDecl::Create(Ctx, TK, DC, L, Id); 2981} 2982 2983// getCFConstantStringType - Return the type used for constant CFStrings. 2984QualType ASTContext::getCFConstantStringType() { 2985 if (!CFConstantStringTypeDecl) { 2986 CFConstantStringTypeDecl = 2987 CreateRecordDecl(*this, TTK_Struct, TUDecl, SourceLocation(), 2988 &Idents.get("NSConstantString")); 2989 CFConstantStringTypeDecl->startDefinition(); 2990 2991 QualType FieldTypes[4]; 2992 2993 // const int *isa; 2994 FieldTypes[0] = getPointerType(IntTy.withConst()); 2995 // int flags; 2996 FieldTypes[1] = IntTy; 2997 // const char *str; 2998 FieldTypes[2] = getPointerType(CharTy.withConst()); 2999 // long length; 3000 FieldTypes[3] = LongTy; 3001 3002 // Create fields 3003 for (unsigned i = 0; i < 4; ++i) { 3004 FieldDecl *Field = FieldDecl::Create(*this, CFConstantStringTypeDecl, 3005 SourceLocation(), 0, 3006 FieldTypes[i], /*TInfo=*/0, 3007 /*BitWidth=*/0, 3008 /*Mutable=*/false); 3009 Field->setAccess(AS_public); 3010 CFConstantStringTypeDecl->addDecl(Field); 3011 } 3012 3013 CFConstantStringTypeDecl->completeDefinition(); 3014 } 3015 3016 return getTagDeclType(CFConstantStringTypeDecl); 3017} 3018 3019void ASTContext::setCFConstantStringType(QualType T) { 3020 const RecordType *Rec = T->getAs<RecordType>(); 3021 assert(Rec && "Invalid CFConstantStringType"); 3022 CFConstantStringTypeDecl = Rec->getDecl(); 3023} 3024 3025// getNSConstantStringType - Return the type used for constant NSStrings. 3026QualType ASTContext::getNSConstantStringType() { 3027 if (!NSConstantStringTypeDecl) { 3028 NSConstantStringTypeDecl = 3029 CreateRecordDecl(*this, TTK_Struct, TUDecl, SourceLocation(), 3030 &Idents.get("__builtin_NSString")); 3031 NSConstantStringTypeDecl->startDefinition(); 3032 3033 QualType FieldTypes[3]; 3034 3035 // const int *isa; 3036 FieldTypes[0] = getPointerType(IntTy.withConst()); 3037 // const char *str; 3038 FieldTypes[1] = getPointerType(CharTy.withConst()); 3039 // unsigned int length; 3040 FieldTypes[2] = UnsignedIntTy; 3041 3042 // Create fields 3043 for (unsigned i = 0; i < 3; ++i) { 3044 FieldDecl *Field = FieldDecl::Create(*this, NSConstantStringTypeDecl, 3045 SourceLocation(), 0, 3046 FieldTypes[i], /*TInfo=*/0, 3047 /*BitWidth=*/0, 3048 /*Mutable=*/false); 3049 Field->setAccess(AS_public); 3050 NSConstantStringTypeDecl->addDecl(Field); 3051 } 3052 3053 NSConstantStringTypeDecl->completeDefinition(); 3054 } 3055 3056 return getTagDeclType(NSConstantStringTypeDecl); 3057} 3058 3059void ASTContext::setNSConstantStringType(QualType T) { 3060 const RecordType *Rec = T->getAs<RecordType>(); 3061 assert(Rec && "Invalid NSConstantStringType"); 3062 NSConstantStringTypeDecl = Rec->getDecl(); 3063} 3064 3065QualType ASTContext::getObjCFastEnumerationStateType() { 3066 if (!ObjCFastEnumerationStateTypeDecl) { 3067 ObjCFastEnumerationStateTypeDecl = 3068 CreateRecordDecl(*this, TTK_Struct, TUDecl, SourceLocation(), 3069 &Idents.get("__objcFastEnumerationState")); 3070 ObjCFastEnumerationStateTypeDecl->startDefinition(); 3071 3072 QualType FieldTypes[] = { 3073 UnsignedLongTy, 3074 getPointerType(ObjCIdTypedefType), 3075 getPointerType(UnsignedLongTy), 3076 getConstantArrayType(UnsignedLongTy, 3077 llvm::APInt(32, 5), ArrayType::Normal, 0) 3078 }; 3079 3080 for (size_t i = 0; i < 4; ++i) { 3081 FieldDecl *Field = FieldDecl::Create(*this, 3082 ObjCFastEnumerationStateTypeDecl, 3083 SourceLocation(), 0, 3084 FieldTypes[i], /*TInfo=*/0, 3085 /*BitWidth=*/0, 3086 /*Mutable=*/false); 3087 Field->setAccess(AS_public); 3088 ObjCFastEnumerationStateTypeDecl->addDecl(Field); 3089 } 3090 if (getLangOptions().CPlusPlus) 3091 if (CXXRecordDecl *CXXRD = 3092 dyn_cast<CXXRecordDecl>(ObjCFastEnumerationStateTypeDecl)) 3093 CXXRD->setEmpty(false); 3094 3095 ObjCFastEnumerationStateTypeDecl->completeDefinition(); 3096 } 3097 3098 return getTagDeclType(ObjCFastEnumerationStateTypeDecl); 3099} 3100 3101QualType ASTContext::getBlockDescriptorType() { 3102 if (BlockDescriptorType) 3103 return getTagDeclType(BlockDescriptorType); 3104 3105 RecordDecl *T; 3106 // FIXME: Needs the FlagAppleBlock bit. 3107 T = CreateRecordDecl(*this, TTK_Struct, TUDecl, SourceLocation(), 3108 &Idents.get("__block_descriptor")); 3109 T->startDefinition(); 3110 3111 QualType FieldTypes[] = { 3112 UnsignedLongTy, 3113 UnsignedLongTy, 3114 }; 3115 3116 const char *FieldNames[] = { 3117 "reserved", 3118 "Size" 3119 }; 3120 3121 for (size_t i = 0; i < 2; ++i) { 3122 FieldDecl *Field = FieldDecl::Create(*this, 3123 T, 3124 SourceLocation(), 3125 &Idents.get(FieldNames[i]), 3126 FieldTypes[i], /*TInfo=*/0, 3127 /*BitWidth=*/0, 3128 /*Mutable=*/false); 3129 Field->setAccess(AS_public); 3130 T->addDecl(Field); 3131 } 3132 3133 T->completeDefinition(); 3134 3135 BlockDescriptorType = T; 3136 3137 return getTagDeclType(BlockDescriptorType); 3138} 3139 3140void ASTContext::setBlockDescriptorType(QualType T) { 3141 const RecordType *Rec = T->getAs<RecordType>(); 3142 assert(Rec && "Invalid BlockDescriptorType"); 3143 BlockDescriptorType = Rec->getDecl(); 3144} 3145 3146QualType ASTContext::getBlockDescriptorExtendedType() { 3147 if (BlockDescriptorExtendedType) 3148 return getTagDeclType(BlockDescriptorExtendedType); 3149 3150 RecordDecl *T; 3151 // FIXME: Needs the FlagAppleBlock bit. 3152 T = CreateRecordDecl(*this, TTK_Struct, TUDecl, SourceLocation(), 3153 &Idents.get("__block_descriptor_withcopydispose")); 3154 T->startDefinition(); 3155 3156 QualType FieldTypes[] = { 3157 UnsignedLongTy, 3158 UnsignedLongTy, 3159 getPointerType(VoidPtrTy), 3160 getPointerType(VoidPtrTy) 3161 }; 3162 3163 const char *FieldNames[] = { 3164 "reserved", 3165 "Size", 3166 "CopyFuncPtr", 3167 "DestroyFuncPtr" 3168 }; 3169 3170 for (size_t i = 0; i < 4; ++i) { 3171 FieldDecl *Field = FieldDecl::Create(*this, 3172 T, 3173 SourceLocation(), 3174 &Idents.get(FieldNames[i]), 3175 FieldTypes[i], /*TInfo=*/0, 3176 /*BitWidth=*/0, 3177 /*Mutable=*/false); 3178 Field->setAccess(AS_public); 3179 T->addDecl(Field); 3180 } 3181 3182 T->completeDefinition(); 3183 3184 BlockDescriptorExtendedType = T; 3185 3186 return getTagDeclType(BlockDescriptorExtendedType); 3187} 3188 3189void ASTContext::setBlockDescriptorExtendedType(QualType T) { 3190 const RecordType *Rec = T->getAs<RecordType>(); 3191 assert(Rec && "Invalid BlockDescriptorType"); 3192 BlockDescriptorExtendedType = Rec->getDecl(); 3193} 3194 3195bool ASTContext::BlockRequiresCopying(QualType Ty) { 3196 if (Ty->isBlockPointerType()) 3197 return true; 3198 if (isObjCNSObjectType(Ty)) 3199 return true; 3200 if (Ty->isObjCObjectPointerType()) 3201 return true; 3202 return false; 3203} 3204 3205QualType ASTContext::BuildByRefType(llvm::StringRef DeclName, QualType Ty) { 3206 // type = struct __Block_byref_1_X { 3207 // void *__isa; 3208 // struct __Block_byref_1_X *__forwarding; 3209 // unsigned int __flags; 3210 // unsigned int __size; 3211 // void *__copy_helper; // as needed 3212 // void *__destroy_help // as needed 3213 // int X; 3214 // } * 3215 3216 bool HasCopyAndDispose = BlockRequiresCopying(Ty); 3217 3218 // FIXME: Move up 3219 llvm::SmallString<36> Name; 3220 llvm::raw_svector_ostream(Name) << "__Block_byref_" << 3221 ++UniqueBlockByRefTypeID << '_' << DeclName; 3222 RecordDecl *T; 3223 T = CreateRecordDecl(*this, TTK_Struct, TUDecl, SourceLocation(), 3224 &Idents.get(Name.str())); 3225 T->startDefinition(); 3226 QualType Int32Ty = IntTy; 3227 assert(getIntWidth(IntTy) == 32 && "non-32bit int not supported"); 3228 QualType FieldTypes[] = { 3229 getPointerType(VoidPtrTy), 3230 getPointerType(getTagDeclType(T)), 3231 Int32Ty, 3232 Int32Ty, 3233 getPointerType(VoidPtrTy), 3234 getPointerType(VoidPtrTy), 3235 Ty 3236 }; 3237 3238 llvm::StringRef FieldNames[] = { 3239 "__isa", 3240 "__forwarding", 3241 "__flags", 3242 "__size", 3243 "__copy_helper", 3244 "__destroy_helper", 3245 DeclName, 3246 }; 3247 3248 for (size_t i = 0; i < 7; ++i) { 3249 if (!HasCopyAndDispose && i >=4 && i <= 5) 3250 continue; 3251 FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(), 3252 &Idents.get(FieldNames[i]), 3253 FieldTypes[i], /*TInfo=*/0, 3254 /*BitWidth=*/0, /*Mutable=*/false); 3255 Field->setAccess(AS_public); 3256 T->addDecl(Field); 3257 } 3258 3259 T->completeDefinition(); 3260 3261 return getPointerType(getTagDeclType(T)); 3262} 3263 3264 3265QualType ASTContext::getBlockParmType( 3266 bool BlockHasCopyDispose, 3267 llvm::SmallVectorImpl<const Expr *> &Layout) { 3268 3269 // FIXME: Move up 3270 llvm::SmallString<36> Name; 3271 llvm::raw_svector_ostream(Name) << "__block_literal_" 3272 << ++UniqueBlockParmTypeID; 3273 RecordDecl *T; 3274 T = CreateRecordDecl(*this, TTK_Struct, TUDecl, SourceLocation(), 3275 &Idents.get(Name.str())); 3276 T->startDefinition(); 3277 QualType FieldTypes[] = { 3278 getPointerType(VoidPtrTy), 3279 IntTy, 3280 IntTy, 3281 getPointerType(VoidPtrTy), 3282 (BlockHasCopyDispose ? 3283 getPointerType(getBlockDescriptorExtendedType()) : 3284 getPointerType(getBlockDescriptorType())) 3285 }; 3286 3287 const char *FieldNames[] = { 3288 "__isa", 3289 "__flags", 3290 "__reserved", 3291 "__FuncPtr", 3292 "__descriptor" 3293 }; 3294 3295 for (size_t i = 0; i < 5; ++i) { 3296 FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(), 3297 &Idents.get(FieldNames[i]), 3298 FieldTypes[i], /*TInfo=*/0, 3299 /*BitWidth=*/0, /*Mutable=*/false); 3300 Field->setAccess(AS_public); 3301 T->addDecl(Field); 3302 } 3303 3304 for (unsigned i = 0; i < Layout.size(); ++i) { 3305 const Expr *E = Layout[i]; 3306 3307 QualType FieldType = E->getType(); 3308 IdentifierInfo *FieldName = 0; 3309 if (isa<CXXThisExpr>(E)) { 3310 FieldName = &Idents.get("this"); 3311 } else if (const BlockDeclRefExpr *BDRE = dyn_cast<BlockDeclRefExpr>(E)) { 3312 const ValueDecl *D = BDRE->getDecl(); 3313 FieldName = D->getIdentifier(); 3314 if (BDRE->isByRef()) 3315 FieldType = BuildByRefType(D->getName(), FieldType); 3316 } else { 3317 // Padding. 3318 assert(isa<ConstantArrayType>(FieldType) && 3319 isa<DeclRefExpr>(E) && 3320 !cast<DeclRefExpr>(E)->getDecl()->getDeclName() && 3321 "doesn't match characteristics of padding decl"); 3322 } 3323 3324 FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(), 3325 FieldName, FieldType, /*TInfo=*/0, 3326 /*BitWidth=*/0, /*Mutable=*/false); 3327 Field->setAccess(AS_public); 3328 T->addDecl(Field); 3329 } 3330 3331 T->completeDefinition(); 3332 3333 return getPointerType(getTagDeclType(T)); 3334} 3335 3336void ASTContext::setObjCFastEnumerationStateType(QualType T) { 3337 const RecordType *Rec = T->getAs<RecordType>(); 3338 assert(Rec && "Invalid ObjCFAstEnumerationStateType"); 3339 ObjCFastEnumerationStateTypeDecl = Rec->getDecl(); 3340} 3341 3342// This returns true if a type has been typedefed to BOOL: 3343// typedef <type> BOOL; 3344static bool isTypeTypedefedAsBOOL(QualType T) { 3345 if (const TypedefType *TT = dyn_cast<TypedefType>(T)) 3346 if (IdentifierInfo *II = TT->getDecl()->getIdentifier()) 3347 return II->isStr("BOOL"); 3348 3349 return false; 3350} 3351 3352/// getObjCEncodingTypeSize returns size of type for objective-c encoding 3353/// purpose. 3354CharUnits ASTContext::getObjCEncodingTypeSize(QualType type) { 3355 CharUnits sz = getTypeSizeInChars(type); 3356 3357 // Make all integer and enum types at least as large as an int 3358 if (sz.isPositive() && type->isIntegralOrEnumerationType()) 3359 sz = std::max(sz, getTypeSizeInChars(IntTy)); 3360 // Treat arrays as pointers, since that's how they're passed in. 3361 else if (type->isArrayType()) 3362 sz = getTypeSizeInChars(VoidPtrTy); 3363 return sz; 3364} 3365 3366static inline 3367std::string charUnitsToString(const CharUnits &CU) { 3368 return llvm::itostr(CU.getQuantity()); 3369} 3370 3371/// getObjCEncodingForBlockDecl - Return the encoded type for this block 3372/// declaration. 3373void ASTContext::getObjCEncodingForBlock(const BlockExpr *Expr, 3374 std::string& S) { 3375 const BlockDecl *Decl = Expr->getBlockDecl(); 3376 QualType BlockTy = 3377 Expr->getType()->getAs<BlockPointerType>()->getPointeeType(); 3378 // Encode result type. 3379 getObjCEncodingForType(BlockTy->getAs<FunctionType>()->getResultType(), S); 3380 // Compute size of all parameters. 3381 // Start with computing size of a pointer in number of bytes. 3382 // FIXME: There might(should) be a better way of doing this computation! 3383 SourceLocation Loc; 3384 CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy); 3385 CharUnits ParmOffset = PtrSize; 3386 for (BlockDecl::param_const_iterator PI = Decl->param_begin(), 3387 E = Decl->param_end(); PI != E; ++PI) { 3388 QualType PType = (*PI)->getType(); 3389 CharUnits sz = getObjCEncodingTypeSize(PType); 3390 assert (sz.isPositive() && "BlockExpr - Incomplete param type"); 3391 ParmOffset += sz; 3392 } 3393 // Size of the argument frame 3394 S += charUnitsToString(ParmOffset); 3395 // Block pointer and offset. 3396 S += "@?0"; 3397 ParmOffset = PtrSize; 3398 3399 // Argument types. 3400 ParmOffset = PtrSize; 3401 for (BlockDecl::param_const_iterator PI = Decl->param_begin(), E = 3402 Decl->param_end(); PI != E; ++PI) { 3403 ParmVarDecl *PVDecl = *PI; 3404 QualType PType = PVDecl->getOriginalType(); 3405 if (const ArrayType *AT = 3406 dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) { 3407 // Use array's original type only if it has known number of 3408 // elements. 3409 if (!isa<ConstantArrayType>(AT)) 3410 PType = PVDecl->getType(); 3411 } else if (PType->isFunctionType()) 3412 PType = PVDecl->getType(); 3413 getObjCEncodingForType(PType, S); 3414 S += charUnitsToString(ParmOffset); 3415 ParmOffset += getObjCEncodingTypeSize(PType); 3416 } 3417} 3418 3419/// getObjCEncodingForMethodDecl - Return the encoded type for this method 3420/// declaration. 3421void ASTContext::getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl, 3422 std::string& S) { 3423 // FIXME: This is not very efficient. 3424 // Encode type qualifer, 'in', 'inout', etc. for the return type. 3425 getObjCEncodingForTypeQualifier(Decl->getObjCDeclQualifier(), S); 3426 // Encode result type. 3427 getObjCEncodingForType(Decl->getResultType(), S); 3428 // Compute size of all parameters. 3429 // Start with computing size of a pointer in number of bytes. 3430 // FIXME: There might(should) be a better way of doing this computation! 3431 SourceLocation Loc; 3432 CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy); 3433 // The first two arguments (self and _cmd) are pointers; account for 3434 // their size. 3435 CharUnits ParmOffset = 2 * PtrSize; 3436 for (ObjCMethodDecl::param_iterator PI = Decl->param_begin(), 3437 E = Decl->sel_param_end(); PI != E; ++PI) { 3438 QualType PType = (*PI)->getType(); 3439 CharUnits sz = getObjCEncodingTypeSize(PType); 3440 assert (sz.isPositive() && 3441 "getObjCEncodingForMethodDecl - Incomplete param type"); 3442 ParmOffset += sz; 3443 } 3444 S += charUnitsToString(ParmOffset); 3445 S += "@0:"; 3446 S += charUnitsToString(PtrSize); 3447 3448 // Argument types. 3449 ParmOffset = 2 * PtrSize; 3450 for (ObjCMethodDecl::param_iterator PI = Decl->param_begin(), 3451 E = Decl->sel_param_end(); PI != E; ++PI) { 3452 ParmVarDecl *PVDecl = *PI; 3453 QualType PType = PVDecl->getOriginalType(); 3454 if (const ArrayType *AT = 3455 dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) { 3456 // Use array's original type only if it has known number of 3457 // elements. 3458 if (!isa<ConstantArrayType>(AT)) 3459 PType = PVDecl->getType(); 3460 } else if (PType->isFunctionType()) 3461 PType = PVDecl->getType(); 3462 // Process argument qualifiers for user supplied arguments; such as, 3463 // 'in', 'inout', etc. 3464 getObjCEncodingForTypeQualifier(PVDecl->getObjCDeclQualifier(), S); 3465 getObjCEncodingForType(PType, S); 3466 S += charUnitsToString(ParmOffset); 3467 ParmOffset += getObjCEncodingTypeSize(PType); 3468 } 3469} 3470 3471/// getObjCEncodingForPropertyDecl - Return the encoded type for this 3472/// property declaration. If non-NULL, Container must be either an 3473/// ObjCCategoryImplDecl or ObjCImplementationDecl; it should only be 3474/// NULL when getting encodings for protocol properties. 3475/// Property attributes are stored as a comma-delimited C string. The simple 3476/// attributes readonly and bycopy are encoded as single characters. The 3477/// parametrized attributes, getter=name, setter=name, and ivar=name, are 3478/// encoded as single characters, followed by an identifier. Property types 3479/// are also encoded as a parametrized attribute. The characters used to encode 3480/// these attributes are defined by the following enumeration: 3481/// @code 3482/// enum PropertyAttributes { 3483/// kPropertyReadOnly = 'R', // property is read-only. 3484/// kPropertyBycopy = 'C', // property is a copy of the value last assigned 3485/// kPropertyByref = '&', // property is a reference to the value last assigned 3486/// kPropertyDynamic = 'D', // property is dynamic 3487/// kPropertyGetter = 'G', // followed by getter selector name 3488/// kPropertySetter = 'S', // followed by setter selector name 3489/// kPropertyInstanceVariable = 'V' // followed by instance variable name 3490/// kPropertyType = 't' // followed by old-style type encoding. 3491/// kPropertyWeak = 'W' // 'weak' property 3492/// kPropertyStrong = 'P' // property GC'able 3493/// kPropertyNonAtomic = 'N' // property non-atomic 3494/// }; 3495/// @endcode 3496void ASTContext::getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD, 3497 const Decl *Container, 3498 std::string& S) { 3499 // Collect information from the property implementation decl(s). 3500 bool Dynamic = false; 3501 ObjCPropertyImplDecl *SynthesizePID = 0; 3502 3503 // FIXME: Duplicated code due to poor abstraction. 3504 if (Container) { 3505 if (const ObjCCategoryImplDecl *CID = 3506 dyn_cast<ObjCCategoryImplDecl>(Container)) { 3507 for (ObjCCategoryImplDecl::propimpl_iterator 3508 i = CID->propimpl_begin(), e = CID->propimpl_end(); 3509 i != e; ++i) { 3510 ObjCPropertyImplDecl *PID = *i; 3511 if (PID->getPropertyDecl() == PD) { 3512 if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) { 3513 Dynamic = true; 3514 } else { 3515 SynthesizePID = PID; 3516 } 3517 } 3518 } 3519 } else { 3520 const ObjCImplementationDecl *OID=cast<ObjCImplementationDecl>(Container); 3521 for (ObjCCategoryImplDecl::propimpl_iterator 3522 i = OID->propimpl_begin(), e = OID->propimpl_end(); 3523 i != e; ++i) { 3524 ObjCPropertyImplDecl *PID = *i; 3525 if (PID->getPropertyDecl() == PD) { 3526 if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) { 3527 Dynamic = true; 3528 } else { 3529 SynthesizePID = PID; 3530 } 3531 } 3532 } 3533 } 3534 } 3535 3536 // FIXME: This is not very efficient. 3537 S = "T"; 3538 3539 // Encode result type. 3540 // GCC has some special rules regarding encoding of properties which 3541 // closely resembles encoding of ivars. 3542 getObjCEncodingForTypeImpl(PD->getType(), S, true, true, 0, 3543 true /* outermost type */, 3544 true /* encoding for property */); 3545 3546 if (PD->isReadOnly()) { 3547 S += ",R"; 3548 } else { 3549 switch (PD->getSetterKind()) { 3550 case ObjCPropertyDecl::Assign: break; 3551 case ObjCPropertyDecl::Copy: S += ",C"; break; 3552 case ObjCPropertyDecl::Retain: S += ",&"; break; 3553 } 3554 } 3555 3556 // It really isn't clear at all what this means, since properties 3557 // are "dynamic by default". 3558 if (Dynamic) 3559 S += ",D"; 3560 3561 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_nonatomic) 3562 S += ",N"; 3563 3564 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_getter) { 3565 S += ",G"; 3566 S += PD->getGetterName().getAsString(); 3567 } 3568 3569 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter) { 3570 S += ",S"; 3571 S += PD->getSetterName().getAsString(); 3572 } 3573 3574 if (SynthesizePID) { 3575 const ObjCIvarDecl *OID = SynthesizePID->getPropertyIvarDecl(); 3576 S += ",V"; 3577 S += OID->getNameAsString(); 3578 } 3579 3580 // FIXME: OBJCGC: weak & strong 3581} 3582 3583/// getLegacyIntegralTypeEncoding - 3584/// Another legacy compatibility encoding: 32-bit longs are encoded as 3585/// 'l' or 'L' , but not always. For typedefs, we need to use 3586/// 'i' or 'I' instead if encoding a struct field, or a pointer! 3587/// 3588void ASTContext::getLegacyIntegralTypeEncoding (QualType &PointeeTy) const { 3589 if (isa<TypedefType>(PointeeTy.getTypePtr())) { 3590 if (const BuiltinType *BT = PointeeTy->getAs<BuiltinType>()) { 3591 if (BT->getKind() == BuiltinType::ULong && 3592 ((const_cast<ASTContext *>(this))->getIntWidth(PointeeTy) == 32)) 3593 PointeeTy = UnsignedIntTy; 3594 else 3595 if (BT->getKind() == BuiltinType::Long && 3596 ((const_cast<ASTContext *>(this))->getIntWidth(PointeeTy) == 32)) 3597 PointeeTy = IntTy; 3598 } 3599 } 3600} 3601 3602void ASTContext::getObjCEncodingForType(QualType T, std::string& S, 3603 const FieldDecl *Field) { 3604 // We follow the behavior of gcc, expanding structures which are 3605 // directly pointed to, and expanding embedded structures. Note that 3606 // these rules are sufficient to prevent recursive encoding of the 3607 // same type. 3608 getObjCEncodingForTypeImpl(T, S, true, true, Field, 3609 true /* outermost type */); 3610} 3611 3612static char ObjCEncodingForPrimitiveKind(const ASTContext *C, QualType T) { 3613 switch (T->getAs<BuiltinType>()->getKind()) { 3614 default: assert(0 && "Unhandled builtin type kind"); 3615 case BuiltinType::Void: return 'v'; 3616 case BuiltinType::Bool: return 'B'; 3617 case BuiltinType::Char_U: 3618 case BuiltinType::UChar: return 'C'; 3619 case BuiltinType::UShort: return 'S'; 3620 case BuiltinType::UInt: return 'I'; 3621 case BuiltinType::ULong: 3622 return 3623 (const_cast<ASTContext *>(C))->getIntWidth(T) == 32 ? 'L' : 'Q'; 3624 case BuiltinType::UInt128: return 'T'; 3625 case BuiltinType::ULongLong: return 'Q'; 3626 case BuiltinType::Char_S: 3627 case BuiltinType::SChar: return 'c'; 3628 case BuiltinType::Short: return 's'; 3629 case BuiltinType::WChar: 3630 case BuiltinType::Int: return 'i'; 3631 case BuiltinType::Long: 3632 return 3633 (const_cast<ASTContext *>(C))->getIntWidth(T) == 32 ? 'l' : 'q'; 3634 case BuiltinType::LongLong: return 'q'; 3635 case BuiltinType::Int128: return 't'; 3636 case BuiltinType::Float: return 'f'; 3637 case BuiltinType::Double: return 'd'; 3638 case BuiltinType::LongDouble: return 'd'; 3639 } 3640} 3641 3642static void EncodeBitField(const ASTContext *Context, std::string& S, 3643 QualType T, const FieldDecl *FD) { 3644 const Expr *E = FD->getBitWidth(); 3645 assert(E && "bitfield width not there - getObjCEncodingForTypeImpl"); 3646 ASTContext *Ctx = const_cast<ASTContext*>(Context); 3647 S += 'b'; 3648 // The NeXT runtime encodes bit fields as b followed by the number of bits. 3649 // The GNU runtime requires more information; bitfields are encoded as b, 3650 // then the offset (in bits) of the first element, then the type of the 3651 // bitfield, then the size in bits. For example, in this structure: 3652 // 3653 // struct 3654 // { 3655 // int integer; 3656 // int flags:2; 3657 // }; 3658 // On a 32-bit system, the encoding for flags would be b2 for the NeXT 3659 // runtime, but b32i2 for the GNU runtime. The reason for this extra 3660 // information is not especially sensible, but we're stuck with it for 3661 // compatibility with GCC, although providing it breaks anything that 3662 // actually uses runtime introspection and wants to work on both runtimes... 3663 if (!Ctx->getLangOptions().NeXTRuntime) { 3664 const RecordDecl *RD = FD->getParent(); 3665 const ASTRecordLayout &RL = Ctx->getASTRecordLayout(RD); 3666 // FIXME: This same linear search is also used in ExprConstant - it might 3667 // be better if the FieldDecl stored its offset. We'd be increasing the 3668 // size of the object slightly, but saving some time every time it is used. 3669 unsigned i = 0; 3670 for (RecordDecl::field_iterator Field = RD->field_begin(), 3671 FieldEnd = RD->field_end(); 3672 Field != FieldEnd; (void)++Field, ++i) { 3673 if (*Field == FD) 3674 break; 3675 } 3676 S += llvm::utostr(RL.getFieldOffset(i)); 3677 S += ObjCEncodingForPrimitiveKind(Context, T); 3678 } 3679 unsigned N = E->EvaluateAsInt(*Ctx).getZExtValue(); 3680 S += llvm::utostr(N); 3681} 3682 3683// FIXME: Use SmallString for accumulating string. 3684void ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S, 3685 bool ExpandPointedToStructures, 3686 bool ExpandStructures, 3687 const FieldDecl *FD, 3688 bool OutermostType, 3689 bool EncodingProperty) { 3690 if (T->getAs<BuiltinType>()) { 3691 if (FD && FD->isBitField()) 3692 return EncodeBitField(this, S, T, FD); 3693 S += ObjCEncodingForPrimitiveKind(this, T); 3694 return; 3695 } 3696 3697 if (const ComplexType *CT = T->getAs<ComplexType>()) { 3698 S += 'j'; 3699 getObjCEncodingForTypeImpl(CT->getElementType(), S, false, false, 0, false, 3700 false); 3701 return; 3702 } 3703 3704 // encoding for pointer or r3eference types. 3705 QualType PointeeTy; 3706 if (const PointerType *PT = T->getAs<PointerType>()) { 3707 if (PT->isObjCSelType()) { 3708 S += ':'; 3709 return; 3710 } 3711 PointeeTy = PT->getPointeeType(); 3712 } 3713 else if (const ReferenceType *RT = T->getAs<ReferenceType>()) 3714 PointeeTy = RT->getPointeeType(); 3715 if (!PointeeTy.isNull()) { 3716 bool isReadOnly = false; 3717 // For historical/compatibility reasons, the read-only qualifier of the 3718 // pointee gets emitted _before_ the '^'. The read-only qualifier of 3719 // the pointer itself gets ignored, _unless_ we are looking at a typedef! 3720 // Also, do not emit the 'r' for anything but the outermost type! 3721 if (isa<TypedefType>(T.getTypePtr())) { 3722 if (OutermostType && T.isConstQualified()) { 3723 isReadOnly = true; 3724 S += 'r'; 3725 } 3726 } else if (OutermostType) { 3727 QualType P = PointeeTy; 3728 while (P->getAs<PointerType>()) 3729 P = P->getAs<PointerType>()->getPointeeType(); 3730 if (P.isConstQualified()) { 3731 isReadOnly = true; 3732 S += 'r'; 3733 } 3734 } 3735 if (isReadOnly) { 3736 // Another legacy compatibility encoding. Some ObjC qualifier and type 3737 // combinations need to be rearranged. 3738 // Rewrite "in const" from "nr" to "rn" 3739 if (llvm::StringRef(S).endswith("nr")) 3740 S.replace(S.end()-2, S.end(), "rn"); 3741 } 3742 3743 if (PointeeTy->isCharType()) { 3744 // char pointer types should be encoded as '*' unless it is a 3745 // type that has been typedef'd to 'BOOL'. 3746 if (!isTypeTypedefedAsBOOL(PointeeTy)) { 3747 S += '*'; 3748 return; 3749 } 3750 } else if (const RecordType *RTy = PointeeTy->getAs<RecordType>()) { 3751 // GCC binary compat: Need to convert "struct objc_class *" to "#". 3752 if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_class")) { 3753 S += '#'; 3754 return; 3755 } 3756 // GCC binary compat: Need to convert "struct objc_object *" to "@". 3757 if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_object")) { 3758 S += '@'; 3759 return; 3760 } 3761 // fall through... 3762 } 3763 S += '^'; 3764 getLegacyIntegralTypeEncoding(PointeeTy); 3765 3766 getObjCEncodingForTypeImpl(PointeeTy, S, false, ExpandPointedToStructures, 3767 NULL); 3768 return; 3769 } 3770 3771 if (const ArrayType *AT = 3772 // Ignore type qualifiers etc. 3773 dyn_cast<ArrayType>(T->getCanonicalTypeInternal())) { 3774 if (isa<IncompleteArrayType>(AT)) { 3775 // Incomplete arrays are encoded as a pointer to the array element. 3776 S += '^'; 3777 3778 getObjCEncodingForTypeImpl(AT->getElementType(), S, 3779 false, ExpandStructures, FD); 3780 } else { 3781 S += '['; 3782 3783 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) 3784 S += llvm::utostr(CAT->getSize().getZExtValue()); 3785 else { 3786 //Variable length arrays are encoded as a regular array with 0 elements. 3787 assert(isa<VariableArrayType>(AT) && "Unknown array type!"); 3788 S += '0'; 3789 } 3790 3791 getObjCEncodingForTypeImpl(AT->getElementType(), S, 3792 false, ExpandStructures, FD); 3793 S += ']'; 3794 } 3795 return; 3796 } 3797 3798 if (T->getAs<FunctionType>()) { 3799 S += '?'; 3800 return; 3801 } 3802 3803 if (const RecordType *RTy = T->getAs<RecordType>()) { 3804 RecordDecl *RDecl = RTy->getDecl(); 3805 S += RDecl->isUnion() ? '(' : '{'; 3806 // Anonymous structures print as '?' 3807 if (const IdentifierInfo *II = RDecl->getIdentifier()) { 3808 S += II->getName(); 3809 if (ClassTemplateSpecializationDecl *Spec 3810 = dyn_cast<ClassTemplateSpecializationDecl>(RDecl)) { 3811 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 3812 std::string TemplateArgsStr 3813 = TemplateSpecializationType::PrintTemplateArgumentList( 3814 TemplateArgs.getFlatArgumentList(), 3815 TemplateArgs.flat_size(), 3816 (*this).PrintingPolicy); 3817 3818 S += TemplateArgsStr; 3819 } 3820 } else { 3821 S += '?'; 3822 } 3823 if (ExpandStructures) { 3824 S += '='; 3825 for (RecordDecl::field_iterator Field = RDecl->field_begin(), 3826 FieldEnd = RDecl->field_end(); 3827 Field != FieldEnd; ++Field) { 3828 if (FD) { 3829 S += '"'; 3830 S += Field->getNameAsString(); 3831 S += '"'; 3832 } 3833 3834 // Special case bit-fields. 3835 if (Field->isBitField()) { 3836 getObjCEncodingForTypeImpl(Field->getType(), S, false, true, 3837 (*Field)); 3838 } else { 3839 QualType qt = Field->getType(); 3840 getLegacyIntegralTypeEncoding(qt); 3841 getObjCEncodingForTypeImpl(qt, S, false, true, 3842 FD); 3843 } 3844 } 3845 } 3846 S += RDecl->isUnion() ? ')' : '}'; 3847 return; 3848 } 3849 3850 if (T->isEnumeralType()) { 3851 if (FD && FD->isBitField()) 3852 EncodeBitField(this, S, T, FD); 3853 else 3854 S += 'i'; 3855 return; 3856 } 3857 3858 if (T->isBlockPointerType()) { 3859 S += "@?"; // Unlike a pointer-to-function, which is "^?". 3860 return; 3861 } 3862 3863 // Ignore protocol qualifiers when mangling at this level. 3864 if (const ObjCObjectType *OT = T->getAs<ObjCObjectType>()) 3865 T = OT->getBaseType(); 3866 3867 if (const ObjCInterfaceType *OIT = T->getAs<ObjCInterfaceType>()) { 3868 // @encode(class_name) 3869 ObjCInterfaceDecl *OI = OIT->getDecl(); 3870 S += '{'; 3871 const IdentifierInfo *II = OI->getIdentifier(); 3872 S += II->getName(); 3873 S += '='; 3874 llvm::SmallVector<ObjCIvarDecl*, 32> Ivars; 3875 DeepCollectObjCIvars(OI, true, Ivars); 3876 for (unsigned i = 0, e = Ivars.size(); i != e; ++i) { 3877 FieldDecl *Field = cast<FieldDecl>(Ivars[i]); 3878 if (Field->isBitField()) 3879 getObjCEncodingForTypeImpl(Field->getType(), S, false, true, Field); 3880 else 3881 getObjCEncodingForTypeImpl(Field->getType(), S, false, true, FD); 3882 } 3883 S += '}'; 3884 return; 3885 } 3886 3887 if (const ObjCObjectPointerType *OPT = T->getAs<ObjCObjectPointerType>()) { 3888 if (OPT->isObjCIdType()) { 3889 S += '@'; 3890 return; 3891 } 3892 3893 if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) { 3894 // FIXME: Consider if we need to output qualifiers for 'Class<p>'. 3895 // Since this is a binary compatibility issue, need to consult with runtime 3896 // folks. Fortunately, this is a *very* obsure construct. 3897 S += '#'; 3898 return; 3899 } 3900 3901 if (OPT->isObjCQualifiedIdType()) { 3902 getObjCEncodingForTypeImpl(getObjCIdType(), S, 3903 ExpandPointedToStructures, 3904 ExpandStructures, FD); 3905 if (FD || EncodingProperty) { 3906 // Note that we do extended encoding of protocol qualifer list 3907 // Only when doing ivar or property encoding. 3908 S += '"'; 3909 for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(), 3910 E = OPT->qual_end(); I != E; ++I) { 3911 S += '<'; 3912 S += (*I)->getNameAsString(); 3913 S += '>'; 3914 } 3915 S += '"'; 3916 } 3917 return; 3918 } 3919 3920 QualType PointeeTy = OPT->getPointeeType(); 3921 if (!EncodingProperty && 3922 isa<TypedefType>(PointeeTy.getTypePtr())) { 3923 // Another historical/compatibility reason. 3924 // We encode the underlying type which comes out as 3925 // {...}; 3926 S += '^'; 3927 getObjCEncodingForTypeImpl(PointeeTy, S, 3928 false, ExpandPointedToStructures, 3929 NULL); 3930 return; 3931 } 3932 3933 S += '@'; 3934 if (OPT->getInterfaceDecl() && (FD || EncodingProperty)) { 3935 S += '"'; 3936 S += OPT->getInterfaceDecl()->getIdentifier()->getName(); 3937 for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(), 3938 E = OPT->qual_end(); I != E; ++I) { 3939 S += '<'; 3940 S += (*I)->getNameAsString(); 3941 S += '>'; 3942 } 3943 S += '"'; 3944 } 3945 return; 3946 } 3947 3948 // gcc just blithely ignores member pointers. 3949 // TODO: maybe there should be a mangling for these 3950 if (T->getAs<MemberPointerType>()) 3951 return; 3952 3953 assert(0 && "@encode for type not implemented!"); 3954} 3955 3956void ASTContext::getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT, 3957 std::string& S) const { 3958 if (QT & Decl::OBJC_TQ_In) 3959 S += 'n'; 3960 if (QT & Decl::OBJC_TQ_Inout) 3961 S += 'N'; 3962 if (QT & Decl::OBJC_TQ_Out) 3963 S += 'o'; 3964 if (QT & Decl::OBJC_TQ_Bycopy) 3965 S += 'O'; 3966 if (QT & Decl::OBJC_TQ_Byref) 3967 S += 'R'; 3968 if (QT & Decl::OBJC_TQ_Oneway) 3969 S += 'V'; 3970} 3971 3972void ASTContext::setBuiltinVaListType(QualType T) { 3973 assert(BuiltinVaListType.isNull() && "__builtin_va_list type already set!"); 3974 3975 BuiltinVaListType = T; 3976} 3977 3978void ASTContext::setObjCIdType(QualType T) { 3979 ObjCIdTypedefType = T; 3980} 3981 3982void ASTContext::setObjCSelType(QualType T) { 3983 ObjCSelTypedefType = T; 3984} 3985 3986void ASTContext::setObjCProtoType(QualType QT) { 3987 ObjCProtoType = QT; 3988} 3989 3990void ASTContext::setObjCClassType(QualType T) { 3991 ObjCClassTypedefType = T; 3992} 3993 3994void ASTContext::setObjCConstantStringInterface(ObjCInterfaceDecl *Decl) { 3995 assert(ObjCConstantStringType.isNull() && 3996 "'NSConstantString' type already set!"); 3997 3998 ObjCConstantStringType = getObjCInterfaceType(Decl); 3999} 4000 4001/// \brief Retrieve the template name that corresponds to a non-empty 4002/// lookup. 4003TemplateName ASTContext::getOverloadedTemplateName(UnresolvedSetIterator Begin, 4004 UnresolvedSetIterator End) { 4005 unsigned size = End - Begin; 4006 assert(size > 1 && "set is not overloaded!"); 4007 4008 void *memory = Allocate(sizeof(OverloadedTemplateStorage) + 4009 size * sizeof(FunctionTemplateDecl*)); 4010 OverloadedTemplateStorage *OT = new(memory) OverloadedTemplateStorage(size); 4011 4012 NamedDecl **Storage = OT->getStorage(); 4013 for (UnresolvedSetIterator I = Begin; I != End; ++I) { 4014 NamedDecl *D = *I; 4015 assert(isa<FunctionTemplateDecl>(D) || 4016 (isa<UsingShadowDecl>(D) && 4017 isa<FunctionTemplateDecl>(D->getUnderlyingDecl()))); 4018 *Storage++ = D; 4019 } 4020 4021 return TemplateName(OT); 4022} 4023 4024/// \brief Retrieve the template name that represents a qualified 4025/// template name such as \c std::vector. 4026TemplateName ASTContext::getQualifiedTemplateName(NestedNameSpecifier *NNS, 4027 bool TemplateKeyword, 4028 TemplateDecl *Template) { 4029 // FIXME: Canonicalization? 4030 llvm::FoldingSetNodeID ID; 4031 QualifiedTemplateName::Profile(ID, NNS, TemplateKeyword, Template); 4032 4033 void *InsertPos = 0; 4034 QualifiedTemplateName *QTN = 4035 QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 4036 if (!QTN) { 4037 QTN = new (*this,4) QualifiedTemplateName(NNS, TemplateKeyword, Template); 4038 QualifiedTemplateNames.InsertNode(QTN, InsertPos); 4039 } 4040 4041 return TemplateName(QTN); 4042} 4043 4044/// \brief Retrieve the template name that represents a dependent 4045/// template name such as \c MetaFun::template apply. 4046TemplateName ASTContext::getDependentTemplateName(NestedNameSpecifier *NNS, 4047 const IdentifierInfo *Name) { 4048 assert((!NNS || NNS->isDependent()) && 4049 "Nested name specifier must be dependent"); 4050 4051 llvm::FoldingSetNodeID ID; 4052 DependentTemplateName::Profile(ID, NNS, Name); 4053 4054 void *InsertPos = 0; 4055 DependentTemplateName *QTN = 4056 DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 4057 4058 if (QTN) 4059 return TemplateName(QTN); 4060 4061 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 4062 if (CanonNNS == NNS) { 4063 QTN = new (*this,4) DependentTemplateName(NNS, Name); 4064 } else { 4065 TemplateName Canon = getDependentTemplateName(CanonNNS, Name); 4066 QTN = new (*this,4) DependentTemplateName(NNS, Name, Canon); 4067 DependentTemplateName *CheckQTN = 4068 DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 4069 assert(!CheckQTN && "Dependent type name canonicalization broken"); 4070 (void)CheckQTN; 4071 } 4072 4073 DependentTemplateNames.InsertNode(QTN, InsertPos); 4074 return TemplateName(QTN); 4075} 4076 4077/// \brief Retrieve the template name that represents a dependent 4078/// template name such as \c MetaFun::template operator+. 4079TemplateName 4080ASTContext::getDependentTemplateName(NestedNameSpecifier *NNS, 4081 OverloadedOperatorKind Operator) { 4082 assert((!NNS || NNS->isDependent()) && 4083 "Nested name specifier must be dependent"); 4084 4085 llvm::FoldingSetNodeID ID; 4086 DependentTemplateName::Profile(ID, NNS, Operator); 4087 4088 void *InsertPos = 0; 4089 DependentTemplateName *QTN 4090 = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 4091 4092 if (QTN) 4093 return TemplateName(QTN); 4094 4095 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 4096 if (CanonNNS == NNS) { 4097 QTN = new (*this,4) DependentTemplateName(NNS, Operator); 4098 } else { 4099 TemplateName Canon = getDependentTemplateName(CanonNNS, Operator); 4100 QTN = new (*this,4) DependentTemplateName(NNS, Operator, Canon); 4101 4102 DependentTemplateName *CheckQTN 4103 = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 4104 assert(!CheckQTN && "Dependent template name canonicalization broken"); 4105 (void)CheckQTN; 4106 } 4107 4108 DependentTemplateNames.InsertNode(QTN, InsertPos); 4109 return TemplateName(QTN); 4110} 4111 4112/// getFromTargetType - Given one of the integer types provided by 4113/// TargetInfo, produce the corresponding type. The unsigned @p Type 4114/// is actually a value of type @c TargetInfo::IntType. 4115CanQualType ASTContext::getFromTargetType(unsigned Type) const { 4116 switch (Type) { 4117 case TargetInfo::NoInt: return CanQualType(); 4118 case TargetInfo::SignedShort: return ShortTy; 4119 case TargetInfo::UnsignedShort: return UnsignedShortTy; 4120 case TargetInfo::SignedInt: return IntTy; 4121 case TargetInfo::UnsignedInt: return UnsignedIntTy; 4122 case TargetInfo::SignedLong: return LongTy; 4123 case TargetInfo::UnsignedLong: return UnsignedLongTy; 4124 case TargetInfo::SignedLongLong: return LongLongTy; 4125 case TargetInfo::UnsignedLongLong: return UnsignedLongLongTy; 4126 } 4127 4128 assert(false && "Unhandled TargetInfo::IntType value"); 4129 return CanQualType(); 4130} 4131 4132//===----------------------------------------------------------------------===// 4133// Type Predicates. 4134//===----------------------------------------------------------------------===// 4135 4136/// isObjCNSObjectType - Return true if this is an NSObject object using 4137/// NSObject attribute on a c-style pointer type. 4138/// FIXME - Make it work directly on types. 4139/// FIXME: Move to Type. 4140/// 4141bool ASTContext::isObjCNSObjectType(QualType Ty) const { 4142 if (TypedefType *TDT = dyn_cast<TypedefType>(Ty)) { 4143 if (TypedefDecl *TD = TDT->getDecl()) 4144 if (TD->getAttr<ObjCNSObjectAttr>()) 4145 return true; 4146 } 4147 return false; 4148} 4149 4150/// getObjCGCAttr - Returns one of GCNone, Weak or Strong objc's 4151/// garbage collection attribute. 4152/// 4153Qualifiers::GC ASTContext::getObjCGCAttrKind(const QualType &Ty) const { 4154 Qualifiers::GC GCAttrs = Qualifiers::GCNone; 4155 if (getLangOptions().ObjC1 && 4156 getLangOptions().getGCMode() != LangOptions::NonGC) { 4157 GCAttrs = Ty.getObjCGCAttr(); 4158 // Default behavious under objective-c's gc is for objective-c pointers 4159 // (or pointers to them) be treated as though they were declared 4160 // as __strong. 4161 if (GCAttrs == Qualifiers::GCNone) { 4162 if (Ty->isObjCObjectPointerType() || Ty->isBlockPointerType()) 4163 GCAttrs = Qualifiers::Strong; 4164 else if (Ty->isPointerType()) 4165 return getObjCGCAttrKind(Ty->getAs<PointerType>()->getPointeeType()); 4166 } 4167 // Non-pointers have none gc'able attribute regardless of the attribute 4168 // set on them. 4169 else if (!Ty->isAnyPointerType() && !Ty->isBlockPointerType()) 4170 return Qualifiers::GCNone; 4171 } 4172 return GCAttrs; 4173} 4174 4175//===----------------------------------------------------------------------===// 4176// Type Compatibility Testing 4177//===----------------------------------------------------------------------===// 4178 4179/// areCompatVectorTypes - Return true if the two specified vector types are 4180/// compatible. 4181static bool areCompatVectorTypes(const VectorType *LHS, 4182 const VectorType *RHS) { 4183 assert(LHS->isCanonicalUnqualified() && RHS->isCanonicalUnqualified()); 4184 return LHS->getElementType() == RHS->getElementType() && 4185 LHS->getNumElements() == RHS->getNumElements(); 4186} 4187 4188bool ASTContext::areCompatibleVectorTypes(QualType FirstVec, 4189 QualType SecondVec) { 4190 assert(FirstVec->isVectorType() && "FirstVec should be a vector type"); 4191 assert(SecondVec->isVectorType() && "SecondVec should be a vector type"); 4192 4193 if (hasSameUnqualifiedType(FirstVec, SecondVec)) 4194 return true; 4195 4196 // AltiVec vectors types are identical to equivalent GCC vector types 4197 const VectorType *First = FirstVec->getAs<VectorType>(); 4198 const VectorType *Second = SecondVec->getAs<VectorType>(); 4199 if ((((First->getAltiVecSpecific() == VectorType::AltiVec) && 4200 (Second->getAltiVecSpecific() == VectorType::NotAltiVec)) || 4201 ((First->getAltiVecSpecific() == VectorType::NotAltiVec) && 4202 (Second->getAltiVecSpecific() == VectorType::AltiVec))) && 4203 hasSameType(First->getElementType(), Second->getElementType()) && 4204 (First->getNumElements() == Second->getNumElements())) 4205 return true; 4206 4207 return false; 4208} 4209 4210//===----------------------------------------------------------------------===// 4211// ObjCQualifiedIdTypesAreCompatible - Compatibility testing for qualified id's. 4212//===----------------------------------------------------------------------===// 4213 4214/// ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the 4215/// inheritance hierarchy of 'rProto'. 4216bool ASTContext::ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto, 4217 ObjCProtocolDecl *rProto) { 4218 if (lProto == rProto) 4219 return true; 4220 for (ObjCProtocolDecl::protocol_iterator PI = rProto->protocol_begin(), 4221 E = rProto->protocol_end(); PI != E; ++PI) 4222 if (ProtocolCompatibleWithProtocol(lProto, *PI)) 4223 return true; 4224 return false; 4225} 4226 4227/// QualifiedIdConformsQualifiedId - compare id<p,...> with id<p1,...> 4228/// return true if lhs's protocols conform to rhs's protocol; false 4229/// otherwise. 4230bool ASTContext::QualifiedIdConformsQualifiedId(QualType lhs, QualType rhs) { 4231 if (lhs->isObjCQualifiedIdType() && rhs->isObjCQualifiedIdType()) 4232 return ObjCQualifiedIdTypesAreCompatible(lhs, rhs, false); 4233 return false; 4234} 4235 4236/// ObjCQualifiedClassTypesAreCompatible - compare Class<p,...> and 4237/// Class<p1, ...>. 4238bool ASTContext::ObjCQualifiedClassTypesAreCompatible(QualType lhs, 4239 QualType rhs) { 4240 const ObjCObjectPointerType *lhsQID = lhs->getAs<ObjCObjectPointerType>(); 4241 const ObjCObjectPointerType *rhsOPT = rhs->getAs<ObjCObjectPointerType>(); 4242 assert ((lhsQID && rhsOPT) && "ObjCQualifiedClassTypesAreCompatible"); 4243 4244 for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 4245 E = lhsQID->qual_end(); I != E; ++I) { 4246 bool match = false; 4247 ObjCProtocolDecl *lhsProto = *I; 4248 for (ObjCObjectPointerType::qual_iterator J = rhsOPT->qual_begin(), 4249 E = rhsOPT->qual_end(); J != E; ++J) { 4250 ObjCProtocolDecl *rhsProto = *J; 4251 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto)) { 4252 match = true; 4253 break; 4254 } 4255 } 4256 if (!match) 4257 return false; 4258 } 4259 return true; 4260} 4261 4262/// ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an 4263/// ObjCQualifiedIDType. 4264bool ASTContext::ObjCQualifiedIdTypesAreCompatible(QualType lhs, QualType rhs, 4265 bool compare) { 4266 // Allow id<P..> and an 'id' or void* type in all cases. 4267 if (lhs->isVoidPointerType() || 4268 lhs->isObjCIdType() || lhs->isObjCClassType()) 4269 return true; 4270 else if (rhs->isVoidPointerType() || 4271 rhs->isObjCIdType() || rhs->isObjCClassType()) 4272 return true; 4273 4274 if (const ObjCObjectPointerType *lhsQID = lhs->getAsObjCQualifiedIdType()) { 4275 const ObjCObjectPointerType *rhsOPT = rhs->getAs<ObjCObjectPointerType>(); 4276 4277 if (!rhsOPT) return false; 4278 4279 if (rhsOPT->qual_empty()) { 4280 // If the RHS is a unqualified interface pointer "NSString*", 4281 // make sure we check the class hierarchy. 4282 if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) { 4283 for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 4284 E = lhsQID->qual_end(); I != E; ++I) { 4285 // when comparing an id<P> on lhs with a static type on rhs, 4286 // see if static class implements all of id's protocols, directly or 4287 // through its super class and categories. 4288 if (!rhsID->ClassImplementsProtocol(*I, true)) 4289 return false; 4290 } 4291 } 4292 // If there are no qualifiers and no interface, we have an 'id'. 4293 return true; 4294 } 4295 // Both the right and left sides have qualifiers. 4296 for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 4297 E = lhsQID->qual_end(); I != E; ++I) { 4298 ObjCProtocolDecl *lhsProto = *I; 4299 bool match = false; 4300 4301 // when comparing an id<P> on lhs with a static type on rhs, 4302 // see if static class implements all of id's protocols, directly or 4303 // through its super class and categories. 4304 for (ObjCObjectPointerType::qual_iterator J = rhsOPT->qual_begin(), 4305 E = rhsOPT->qual_end(); J != E; ++J) { 4306 ObjCProtocolDecl *rhsProto = *J; 4307 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 4308 (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) { 4309 match = true; 4310 break; 4311 } 4312 } 4313 // If the RHS is a qualified interface pointer "NSString<P>*", 4314 // make sure we check the class hierarchy. 4315 if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) { 4316 for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 4317 E = lhsQID->qual_end(); I != E; ++I) { 4318 // when comparing an id<P> on lhs with a static type on rhs, 4319 // see if static class implements all of id's protocols, directly or 4320 // through its super class and categories. 4321 if (rhsID->ClassImplementsProtocol(*I, true)) { 4322 match = true; 4323 break; 4324 } 4325 } 4326 } 4327 if (!match) 4328 return false; 4329 } 4330 4331 return true; 4332 } 4333 4334 const ObjCObjectPointerType *rhsQID = rhs->getAsObjCQualifiedIdType(); 4335 assert(rhsQID && "One of the LHS/RHS should be id<x>"); 4336 4337 if (const ObjCObjectPointerType *lhsOPT = 4338 lhs->getAsObjCInterfacePointerType()) { 4339 if (lhsOPT->qual_empty()) { 4340 bool match = false; 4341 if (ObjCInterfaceDecl *lhsID = lhsOPT->getInterfaceDecl()) { 4342 for (ObjCObjectPointerType::qual_iterator I = rhsQID->qual_begin(), 4343 E = rhsQID->qual_end(); I != E; ++I) { 4344 // when comparing an id<P> on rhs with a static type on lhs, 4345 // static class must implement all of id's protocols directly or 4346 // indirectly through its super class. 4347 if (lhsID->ClassImplementsProtocol(*I, true)) { 4348 match = true; 4349 break; 4350 } 4351 } 4352 if (!match) 4353 return false; 4354 } 4355 return true; 4356 } 4357 // Both the right and left sides have qualifiers. 4358 for (ObjCObjectPointerType::qual_iterator I = lhsOPT->qual_begin(), 4359 E = lhsOPT->qual_end(); I != E; ++I) { 4360 ObjCProtocolDecl *lhsProto = *I; 4361 bool match = false; 4362 4363 // when comparing an id<P> on lhs with a static type on rhs, 4364 // see if static class implements all of id's protocols, directly or 4365 // through its super class and categories. 4366 for (ObjCObjectPointerType::qual_iterator J = rhsQID->qual_begin(), 4367 E = rhsQID->qual_end(); J != E; ++J) { 4368 ObjCProtocolDecl *rhsProto = *J; 4369 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 4370 (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) { 4371 match = true; 4372 break; 4373 } 4374 } 4375 if (!match) 4376 return false; 4377 } 4378 return true; 4379 } 4380 return false; 4381} 4382 4383/// canAssignObjCInterfaces - Return true if the two interface types are 4384/// compatible for assignment from RHS to LHS. This handles validation of any 4385/// protocol qualifiers on the LHS or RHS. 4386/// 4387bool ASTContext::canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT, 4388 const ObjCObjectPointerType *RHSOPT) { 4389 const ObjCObjectType* LHS = LHSOPT->getObjectType(); 4390 const ObjCObjectType* RHS = RHSOPT->getObjectType(); 4391 4392 // If either type represents the built-in 'id' or 'Class' types, return true. 4393 if (LHS->isObjCUnqualifiedIdOrClass() || 4394 RHS->isObjCUnqualifiedIdOrClass()) 4395 return true; 4396 4397 if (LHS->isObjCQualifiedId() || RHS->isObjCQualifiedId()) 4398 return ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0), 4399 QualType(RHSOPT,0), 4400 false); 4401 4402 if (LHS->isObjCQualifiedClass() && RHS->isObjCQualifiedClass()) 4403 return ObjCQualifiedClassTypesAreCompatible(QualType(LHSOPT,0), 4404 QualType(RHSOPT,0)); 4405 4406 // If we have 2 user-defined types, fall into that path. 4407 if (LHS->getInterface() && RHS->getInterface()) 4408 return canAssignObjCInterfaces(LHS, RHS); 4409 4410 return false; 4411} 4412 4413/// canAssignObjCInterfacesInBlockPointer - This routine is specifically written 4414/// for providing type-safty for objective-c pointers used to pass/return 4415/// arguments in block literals. When passed as arguments, passing 'A*' where 4416/// 'id' is expected is not OK. Passing 'Sub *" where 'Super *" is expected is 4417/// not OK. For the return type, the opposite is not OK. 4418bool ASTContext::canAssignObjCInterfacesInBlockPointer( 4419 const ObjCObjectPointerType *LHSOPT, 4420 const ObjCObjectPointerType *RHSOPT) { 4421 if (RHSOPT->isObjCBuiltinType() || LHSOPT->isObjCIdType()) 4422 return true; 4423 4424 if (LHSOPT->isObjCBuiltinType()) { 4425 return RHSOPT->isObjCBuiltinType() || RHSOPT->isObjCQualifiedIdType(); 4426 } 4427 4428 if (LHSOPT->isObjCQualifiedIdType() || RHSOPT->isObjCQualifiedIdType()) 4429 return ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0), 4430 QualType(RHSOPT,0), 4431 false); 4432 4433 const ObjCInterfaceType* LHS = LHSOPT->getInterfaceType(); 4434 const ObjCInterfaceType* RHS = RHSOPT->getInterfaceType(); 4435 if (LHS && RHS) { // We have 2 user-defined types. 4436 if (LHS != RHS) { 4437 if (LHS->getDecl()->isSuperClassOf(RHS->getDecl())) 4438 return false; 4439 if (RHS->getDecl()->isSuperClassOf(LHS->getDecl())) 4440 return true; 4441 } 4442 else 4443 return true; 4444 } 4445 return false; 4446} 4447 4448/// getIntersectionOfProtocols - This routine finds the intersection of set 4449/// of protocols inherited from two distinct objective-c pointer objects. 4450/// It is used to build composite qualifier list of the composite type of 4451/// the conditional expression involving two objective-c pointer objects. 4452static 4453void getIntersectionOfProtocols(ASTContext &Context, 4454 const ObjCObjectPointerType *LHSOPT, 4455 const ObjCObjectPointerType *RHSOPT, 4456 llvm::SmallVectorImpl<ObjCProtocolDecl *> &IntersectionOfProtocols) { 4457 4458 const ObjCObjectType* LHS = LHSOPT->getObjectType(); 4459 const ObjCObjectType* RHS = RHSOPT->getObjectType(); 4460 assert(LHS->getInterface() && "LHS must have an interface base"); 4461 assert(RHS->getInterface() && "RHS must have an interface base"); 4462 4463 llvm::SmallPtrSet<ObjCProtocolDecl *, 8> InheritedProtocolSet; 4464 unsigned LHSNumProtocols = LHS->getNumProtocols(); 4465 if (LHSNumProtocols > 0) 4466 InheritedProtocolSet.insert(LHS->qual_begin(), LHS->qual_end()); 4467 else { 4468 llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSInheritedProtocols; 4469 Context.CollectInheritedProtocols(LHS->getInterface(), 4470 LHSInheritedProtocols); 4471 InheritedProtocolSet.insert(LHSInheritedProtocols.begin(), 4472 LHSInheritedProtocols.end()); 4473 } 4474 4475 unsigned RHSNumProtocols = RHS->getNumProtocols(); 4476 if (RHSNumProtocols > 0) { 4477 ObjCProtocolDecl **RHSProtocols = 4478 const_cast<ObjCProtocolDecl **>(RHS->qual_begin()); 4479 for (unsigned i = 0; i < RHSNumProtocols; ++i) 4480 if (InheritedProtocolSet.count(RHSProtocols[i])) 4481 IntersectionOfProtocols.push_back(RHSProtocols[i]); 4482 } 4483 else { 4484 llvm::SmallPtrSet<ObjCProtocolDecl *, 8> RHSInheritedProtocols; 4485 Context.CollectInheritedProtocols(RHS->getInterface(), 4486 RHSInheritedProtocols); 4487 for (llvm::SmallPtrSet<ObjCProtocolDecl*,8>::iterator I = 4488 RHSInheritedProtocols.begin(), 4489 E = RHSInheritedProtocols.end(); I != E; ++I) 4490 if (InheritedProtocolSet.count((*I))) 4491 IntersectionOfProtocols.push_back((*I)); 4492 } 4493} 4494 4495/// areCommonBaseCompatible - Returns common base class of the two classes if 4496/// one found. Note that this is O'2 algorithm. But it will be called as the 4497/// last type comparison in a ?-exp of ObjC pointer types before a 4498/// warning is issued. So, its invokation is extremely rare. 4499QualType ASTContext::areCommonBaseCompatible( 4500 const ObjCObjectPointerType *Lptr, 4501 const ObjCObjectPointerType *Rptr) { 4502 const ObjCObjectType *LHS = Lptr->getObjectType(); 4503 const ObjCObjectType *RHS = Rptr->getObjectType(); 4504 const ObjCInterfaceDecl* LDecl = LHS->getInterface(); 4505 const ObjCInterfaceDecl* RDecl = RHS->getInterface(); 4506 if (!LDecl || !RDecl) 4507 return QualType(); 4508 4509 while ((LDecl = LDecl->getSuperClass())) { 4510 LHS = cast<ObjCInterfaceType>(getObjCInterfaceType(LDecl)); 4511 if (canAssignObjCInterfaces(LHS, RHS)) { 4512 llvm::SmallVector<ObjCProtocolDecl *, 8> Protocols; 4513 getIntersectionOfProtocols(*this, Lptr, Rptr, Protocols); 4514 4515 QualType Result = QualType(LHS, 0); 4516 if (!Protocols.empty()) 4517 Result = getObjCObjectType(Result, Protocols.data(), Protocols.size()); 4518 Result = getObjCObjectPointerType(Result); 4519 return Result; 4520 } 4521 } 4522 4523 return QualType(); 4524} 4525 4526bool ASTContext::canAssignObjCInterfaces(const ObjCObjectType *LHS, 4527 const ObjCObjectType *RHS) { 4528 assert(LHS->getInterface() && "LHS is not an interface type"); 4529 assert(RHS->getInterface() && "RHS is not an interface type"); 4530 4531 // Verify that the base decls are compatible: the RHS must be a subclass of 4532 // the LHS. 4533 if (!LHS->getInterface()->isSuperClassOf(RHS->getInterface())) 4534 return false; 4535 4536 // RHS must have a superset of the protocols in the LHS. If the LHS is not 4537 // protocol qualified at all, then we are good. 4538 if (LHS->getNumProtocols() == 0) 4539 return true; 4540 4541 // Okay, we know the LHS has protocol qualifiers. If the RHS doesn't, then it 4542 // isn't a superset. 4543 if (RHS->getNumProtocols() == 0) 4544 return true; // FIXME: should return false! 4545 4546 for (ObjCObjectType::qual_iterator LHSPI = LHS->qual_begin(), 4547 LHSPE = LHS->qual_end(); 4548 LHSPI != LHSPE; LHSPI++) { 4549 bool RHSImplementsProtocol = false; 4550 4551 // If the RHS doesn't implement the protocol on the left, the types 4552 // are incompatible. 4553 for (ObjCObjectType::qual_iterator RHSPI = RHS->qual_begin(), 4554 RHSPE = RHS->qual_end(); 4555 RHSPI != RHSPE; RHSPI++) { 4556 if ((*RHSPI)->lookupProtocolNamed((*LHSPI)->getIdentifier())) { 4557 RHSImplementsProtocol = true; 4558 break; 4559 } 4560 } 4561 // FIXME: For better diagnostics, consider passing back the protocol name. 4562 if (!RHSImplementsProtocol) 4563 return false; 4564 } 4565 // The RHS implements all protocols listed on the LHS. 4566 return true; 4567} 4568 4569bool ASTContext::areComparableObjCPointerTypes(QualType LHS, QualType RHS) { 4570 // get the "pointed to" types 4571 const ObjCObjectPointerType *LHSOPT = LHS->getAs<ObjCObjectPointerType>(); 4572 const ObjCObjectPointerType *RHSOPT = RHS->getAs<ObjCObjectPointerType>(); 4573 4574 if (!LHSOPT || !RHSOPT) 4575 return false; 4576 4577 return canAssignObjCInterfaces(LHSOPT, RHSOPT) || 4578 canAssignObjCInterfaces(RHSOPT, LHSOPT); 4579} 4580 4581bool ASTContext::canBindObjCObjectType(QualType To, QualType From) { 4582 return canAssignObjCInterfaces( 4583 getObjCObjectPointerType(To)->getAs<ObjCObjectPointerType>(), 4584 getObjCObjectPointerType(From)->getAs<ObjCObjectPointerType>()); 4585} 4586 4587/// typesAreCompatible - C99 6.7.3p9: For two qualified types to be compatible, 4588/// both shall have the identically qualified version of a compatible type. 4589/// C99 6.2.7p1: Two types have compatible types if their types are the 4590/// same. See 6.7.[2,3,5] for additional rules. 4591bool ASTContext::typesAreCompatible(QualType LHS, QualType RHS, 4592 bool CompareUnqualified) { 4593 if (getLangOptions().CPlusPlus) 4594 return hasSameType(LHS, RHS); 4595 4596 return !mergeTypes(LHS, RHS, false, CompareUnqualified).isNull(); 4597} 4598 4599bool ASTContext::typesAreBlockPointerCompatible(QualType LHS, QualType RHS) { 4600 return !mergeTypes(LHS, RHS, true).isNull(); 4601} 4602 4603QualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs, 4604 bool OfBlockPointer, 4605 bool Unqualified) { 4606 const FunctionType *lbase = lhs->getAs<FunctionType>(); 4607 const FunctionType *rbase = rhs->getAs<FunctionType>(); 4608 const FunctionProtoType *lproto = dyn_cast<FunctionProtoType>(lbase); 4609 const FunctionProtoType *rproto = dyn_cast<FunctionProtoType>(rbase); 4610 bool allLTypes = true; 4611 bool allRTypes = true; 4612 4613 // Check return type 4614 QualType retType; 4615 if (OfBlockPointer) 4616 retType = mergeTypes(rbase->getResultType(), lbase->getResultType(), true, 4617 Unqualified); 4618 else 4619 retType = mergeTypes(lbase->getResultType(), rbase->getResultType(), 4620 false, Unqualified); 4621 if (retType.isNull()) return QualType(); 4622 4623 if (Unqualified) 4624 retType = retType.getUnqualifiedType(); 4625 4626 CanQualType LRetType = getCanonicalType(lbase->getResultType()); 4627 CanQualType RRetType = getCanonicalType(rbase->getResultType()); 4628 if (Unqualified) { 4629 LRetType = LRetType.getUnqualifiedType(); 4630 RRetType = RRetType.getUnqualifiedType(); 4631 } 4632 4633 if (getCanonicalType(retType) != LRetType) 4634 allLTypes = false; 4635 if (getCanonicalType(retType) != RRetType) 4636 allRTypes = false; 4637 // FIXME: double check this 4638 // FIXME: should we error if lbase->getRegParmAttr() != 0 && 4639 // rbase->getRegParmAttr() != 0 && 4640 // lbase->getRegParmAttr() != rbase->getRegParmAttr()? 4641 FunctionType::ExtInfo lbaseInfo = lbase->getExtInfo(); 4642 FunctionType::ExtInfo rbaseInfo = rbase->getExtInfo(); 4643 unsigned RegParm = lbaseInfo.getRegParm() == 0 ? rbaseInfo.getRegParm() : 4644 lbaseInfo.getRegParm(); 4645 bool NoReturn = lbaseInfo.getNoReturn() || rbaseInfo.getNoReturn(); 4646 if (NoReturn != lbaseInfo.getNoReturn() || 4647 RegParm != lbaseInfo.getRegParm()) 4648 allLTypes = false; 4649 if (NoReturn != rbaseInfo.getNoReturn() || 4650 RegParm != rbaseInfo.getRegParm()) 4651 allRTypes = false; 4652 CallingConv lcc = lbaseInfo.getCC(); 4653 CallingConv rcc = rbaseInfo.getCC(); 4654 // Compatible functions must have compatible calling conventions 4655 if (!isSameCallConv(lcc, rcc)) 4656 return QualType(); 4657 4658 if (lproto && rproto) { // two C99 style function prototypes 4659 assert(!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec() && 4660 "C++ shouldn't be here"); 4661 unsigned lproto_nargs = lproto->getNumArgs(); 4662 unsigned rproto_nargs = rproto->getNumArgs(); 4663 4664 // Compatible functions must have the same number of arguments 4665 if (lproto_nargs != rproto_nargs) 4666 return QualType(); 4667 4668 // Variadic and non-variadic functions aren't compatible 4669 if (lproto->isVariadic() != rproto->isVariadic()) 4670 return QualType(); 4671 4672 if (lproto->getTypeQuals() != rproto->getTypeQuals()) 4673 return QualType(); 4674 4675 // Check argument compatibility 4676 llvm::SmallVector<QualType, 10> types; 4677 for (unsigned i = 0; i < lproto_nargs; i++) { 4678 QualType largtype = lproto->getArgType(i).getUnqualifiedType(); 4679 QualType rargtype = rproto->getArgType(i).getUnqualifiedType(); 4680 QualType argtype = mergeTypes(largtype, rargtype, OfBlockPointer, 4681 Unqualified); 4682 if (argtype.isNull()) return QualType(); 4683 4684 if (Unqualified) 4685 argtype = argtype.getUnqualifiedType(); 4686 4687 types.push_back(argtype); 4688 if (Unqualified) { 4689 largtype = largtype.getUnqualifiedType(); 4690 rargtype = rargtype.getUnqualifiedType(); 4691 } 4692 4693 if (getCanonicalType(argtype) != getCanonicalType(largtype)) 4694 allLTypes = false; 4695 if (getCanonicalType(argtype) != getCanonicalType(rargtype)) 4696 allRTypes = false; 4697 } 4698 if (allLTypes) return lhs; 4699 if (allRTypes) return rhs; 4700 return getFunctionType(retType, types.begin(), types.size(), 4701 lproto->isVariadic(), lproto->getTypeQuals(), 4702 false, false, 0, 0, 4703 FunctionType::ExtInfo(NoReturn, RegParm, lcc)); 4704 } 4705 4706 if (lproto) allRTypes = false; 4707 if (rproto) allLTypes = false; 4708 4709 const FunctionProtoType *proto = lproto ? lproto : rproto; 4710 if (proto) { 4711 assert(!proto->hasExceptionSpec() && "C++ shouldn't be here"); 4712 if (proto->isVariadic()) return QualType(); 4713 // Check that the types are compatible with the types that 4714 // would result from default argument promotions (C99 6.7.5.3p15). 4715 // The only types actually affected are promotable integer 4716 // types and floats, which would be passed as a different 4717 // type depending on whether the prototype is visible. 4718 unsigned proto_nargs = proto->getNumArgs(); 4719 for (unsigned i = 0; i < proto_nargs; ++i) { 4720 QualType argTy = proto->getArgType(i); 4721 4722 // Look at the promotion type of enum types, since that is the type used 4723 // to pass enum values. 4724 if (const EnumType *Enum = argTy->getAs<EnumType>()) 4725 argTy = Enum->getDecl()->getPromotionType(); 4726 4727 if (argTy->isPromotableIntegerType() || 4728 getCanonicalType(argTy).getUnqualifiedType() == FloatTy) 4729 return QualType(); 4730 } 4731 4732 if (allLTypes) return lhs; 4733 if (allRTypes) return rhs; 4734 return getFunctionType(retType, proto->arg_type_begin(), 4735 proto->getNumArgs(), proto->isVariadic(), 4736 proto->getTypeQuals(), 4737 false, false, 0, 0, 4738 FunctionType::ExtInfo(NoReturn, RegParm, lcc)); 4739 } 4740 4741 if (allLTypes) return lhs; 4742 if (allRTypes) return rhs; 4743 FunctionType::ExtInfo Info(NoReturn, RegParm, lcc); 4744 return getFunctionNoProtoType(retType, Info); 4745} 4746 4747QualType ASTContext::mergeTypes(QualType LHS, QualType RHS, 4748 bool OfBlockPointer, 4749 bool Unqualified) { 4750 // C++ [expr]: If an expression initially has the type "reference to T", the 4751 // type is adjusted to "T" prior to any further analysis, the expression 4752 // designates the object or function denoted by the reference, and the 4753 // expression is an lvalue unless the reference is an rvalue reference and 4754 // the expression is a function call (possibly inside parentheses). 4755 assert(!LHS->getAs<ReferenceType>() && "LHS is a reference type?"); 4756 assert(!RHS->getAs<ReferenceType>() && "RHS is a reference type?"); 4757 4758 if (Unqualified) { 4759 LHS = LHS.getUnqualifiedType(); 4760 RHS = RHS.getUnqualifiedType(); 4761 } 4762 4763 QualType LHSCan = getCanonicalType(LHS), 4764 RHSCan = getCanonicalType(RHS); 4765 4766 // If two types are identical, they are compatible. 4767 if (LHSCan == RHSCan) 4768 return LHS; 4769 4770 // If the qualifiers are different, the types aren't compatible... mostly. 4771 Qualifiers LQuals = LHSCan.getLocalQualifiers(); 4772 Qualifiers RQuals = RHSCan.getLocalQualifiers(); 4773 if (LQuals != RQuals) { 4774 // If any of these qualifiers are different, we have a type 4775 // mismatch. 4776 if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() || 4777 LQuals.getAddressSpace() != RQuals.getAddressSpace()) 4778 return QualType(); 4779 4780 // Exactly one GC qualifier difference is allowed: __strong is 4781 // okay if the other type has no GC qualifier but is an Objective 4782 // C object pointer (i.e. implicitly strong by default). We fix 4783 // this by pretending that the unqualified type was actually 4784 // qualified __strong. 4785 Qualifiers::GC GC_L = LQuals.getObjCGCAttr(); 4786 Qualifiers::GC GC_R = RQuals.getObjCGCAttr(); 4787 assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements"); 4788 4789 if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak) 4790 return QualType(); 4791 4792 if (GC_L == Qualifiers::Strong && RHSCan->isObjCObjectPointerType()) { 4793 return mergeTypes(LHS, getObjCGCQualType(RHS, Qualifiers::Strong)); 4794 } 4795 if (GC_R == Qualifiers::Strong && LHSCan->isObjCObjectPointerType()) { 4796 return mergeTypes(getObjCGCQualType(LHS, Qualifiers::Strong), RHS); 4797 } 4798 return QualType(); 4799 } 4800 4801 // Okay, qualifiers are equal. 4802 4803 Type::TypeClass LHSClass = LHSCan->getTypeClass(); 4804 Type::TypeClass RHSClass = RHSCan->getTypeClass(); 4805 4806 // We want to consider the two function types to be the same for these 4807 // comparisons, just force one to the other. 4808 if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto; 4809 if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto; 4810 4811 // Same as above for arrays 4812 if (LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray) 4813 LHSClass = Type::ConstantArray; 4814 if (RHSClass == Type::VariableArray || RHSClass == Type::IncompleteArray) 4815 RHSClass = Type::ConstantArray; 4816 4817 // ObjCInterfaces are just specialized ObjCObjects. 4818 if (LHSClass == Type::ObjCInterface) LHSClass = Type::ObjCObject; 4819 if (RHSClass == Type::ObjCInterface) RHSClass = Type::ObjCObject; 4820 4821 // Canonicalize ExtVector -> Vector. 4822 if (LHSClass == Type::ExtVector) LHSClass = Type::Vector; 4823 if (RHSClass == Type::ExtVector) RHSClass = Type::Vector; 4824 4825 // If the canonical type classes don't match. 4826 if (LHSClass != RHSClass) { 4827 // C99 6.7.2.2p4: Each enumerated type shall be compatible with char, 4828 // a signed integer type, or an unsigned integer type. 4829 // Compatibility is based on the underlying type, not the promotion 4830 // type. 4831 if (const EnumType* ETy = LHS->getAs<EnumType>()) { 4832 if (ETy->getDecl()->getIntegerType() == RHSCan.getUnqualifiedType()) 4833 return RHS; 4834 } 4835 if (const EnumType* ETy = RHS->getAs<EnumType>()) { 4836 if (ETy->getDecl()->getIntegerType() == LHSCan.getUnqualifiedType()) 4837 return LHS; 4838 } 4839 4840 return QualType(); 4841 } 4842 4843 // The canonical type classes match. 4844 switch (LHSClass) { 4845#define TYPE(Class, Base) 4846#define ABSTRACT_TYPE(Class, Base) 4847#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class: 4848#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 4849#define DEPENDENT_TYPE(Class, Base) case Type::Class: 4850#include "clang/AST/TypeNodes.def" 4851 assert(false && "Non-canonical and dependent types shouldn't get here"); 4852 return QualType(); 4853 4854 case Type::LValueReference: 4855 case Type::RValueReference: 4856 case Type::MemberPointer: 4857 assert(false && "C++ should never be in mergeTypes"); 4858 return QualType(); 4859 4860 case Type::ObjCInterface: 4861 case Type::IncompleteArray: 4862 case Type::VariableArray: 4863 case Type::FunctionProto: 4864 case Type::ExtVector: 4865 assert(false && "Types are eliminated above"); 4866 return QualType(); 4867 4868 case Type::Pointer: 4869 { 4870 // Merge two pointer types, while trying to preserve typedef info 4871 QualType LHSPointee = LHS->getAs<PointerType>()->getPointeeType(); 4872 QualType RHSPointee = RHS->getAs<PointerType>()->getPointeeType(); 4873 if (Unqualified) { 4874 LHSPointee = LHSPointee.getUnqualifiedType(); 4875 RHSPointee = RHSPointee.getUnqualifiedType(); 4876 } 4877 QualType ResultType = mergeTypes(LHSPointee, RHSPointee, false, 4878 Unqualified); 4879 if (ResultType.isNull()) return QualType(); 4880 if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType)) 4881 return LHS; 4882 if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType)) 4883 return RHS; 4884 return getPointerType(ResultType); 4885 } 4886 case Type::BlockPointer: 4887 { 4888 // Merge two block pointer types, while trying to preserve typedef info 4889 QualType LHSPointee = LHS->getAs<BlockPointerType>()->getPointeeType(); 4890 QualType RHSPointee = RHS->getAs<BlockPointerType>()->getPointeeType(); 4891 if (Unqualified) { 4892 LHSPointee = LHSPointee.getUnqualifiedType(); 4893 RHSPointee = RHSPointee.getUnqualifiedType(); 4894 } 4895 QualType ResultType = mergeTypes(LHSPointee, RHSPointee, OfBlockPointer, 4896 Unqualified); 4897 if (ResultType.isNull()) return QualType(); 4898 if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType)) 4899 return LHS; 4900 if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType)) 4901 return RHS; 4902 return getBlockPointerType(ResultType); 4903 } 4904 case Type::ConstantArray: 4905 { 4906 const ConstantArrayType* LCAT = getAsConstantArrayType(LHS); 4907 const ConstantArrayType* RCAT = getAsConstantArrayType(RHS); 4908 if (LCAT && RCAT && RCAT->getSize() != LCAT->getSize()) 4909 return QualType(); 4910 4911 QualType LHSElem = getAsArrayType(LHS)->getElementType(); 4912 QualType RHSElem = getAsArrayType(RHS)->getElementType(); 4913 if (Unqualified) { 4914 LHSElem = LHSElem.getUnqualifiedType(); 4915 RHSElem = RHSElem.getUnqualifiedType(); 4916 } 4917 4918 QualType ResultType = mergeTypes(LHSElem, RHSElem, false, Unqualified); 4919 if (ResultType.isNull()) return QualType(); 4920 if (LCAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType)) 4921 return LHS; 4922 if (RCAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType)) 4923 return RHS; 4924 if (LCAT) return getConstantArrayType(ResultType, LCAT->getSize(), 4925 ArrayType::ArraySizeModifier(), 0); 4926 if (RCAT) return getConstantArrayType(ResultType, RCAT->getSize(), 4927 ArrayType::ArraySizeModifier(), 0); 4928 const VariableArrayType* LVAT = getAsVariableArrayType(LHS); 4929 const VariableArrayType* RVAT = getAsVariableArrayType(RHS); 4930 if (LVAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType)) 4931 return LHS; 4932 if (RVAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType)) 4933 return RHS; 4934 if (LVAT) { 4935 // FIXME: This isn't correct! But tricky to implement because 4936 // the array's size has to be the size of LHS, but the type 4937 // has to be different. 4938 return LHS; 4939 } 4940 if (RVAT) { 4941 // FIXME: This isn't correct! But tricky to implement because 4942 // the array's size has to be the size of RHS, but the type 4943 // has to be different. 4944 return RHS; 4945 } 4946 if (getCanonicalType(LHSElem) == getCanonicalType(ResultType)) return LHS; 4947 if (getCanonicalType(RHSElem) == getCanonicalType(ResultType)) return RHS; 4948 return getIncompleteArrayType(ResultType, 4949 ArrayType::ArraySizeModifier(), 0); 4950 } 4951 case Type::FunctionNoProto: 4952 return mergeFunctionTypes(LHS, RHS, OfBlockPointer, Unqualified); 4953 case Type::Record: 4954 case Type::Enum: 4955 return QualType(); 4956 case Type::Builtin: 4957 // Only exactly equal builtin types are compatible, which is tested above. 4958 return QualType(); 4959 case Type::Complex: 4960 // Distinct complex types are incompatible. 4961 return QualType(); 4962 case Type::Vector: 4963 // FIXME: The merged type should be an ExtVector! 4964 if (areCompatVectorTypes(LHSCan->getAs<VectorType>(), 4965 RHSCan->getAs<VectorType>())) 4966 return LHS; 4967 return QualType(); 4968 case Type::ObjCObject: { 4969 // Check if the types are assignment compatible. 4970 // FIXME: This should be type compatibility, e.g. whether 4971 // "LHS x; RHS x;" at global scope is legal. 4972 const ObjCObjectType* LHSIface = LHS->getAs<ObjCObjectType>(); 4973 const ObjCObjectType* RHSIface = RHS->getAs<ObjCObjectType>(); 4974 if (canAssignObjCInterfaces(LHSIface, RHSIface)) 4975 return LHS; 4976 4977 return QualType(); 4978 } 4979 case Type::ObjCObjectPointer: { 4980 if (OfBlockPointer) { 4981 if (canAssignObjCInterfacesInBlockPointer( 4982 LHS->getAs<ObjCObjectPointerType>(), 4983 RHS->getAs<ObjCObjectPointerType>())) 4984 return LHS; 4985 return QualType(); 4986 } 4987 if (canAssignObjCInterfaces(LHS->getAs<ObjCObjectPointerType>(), 4988 RHS->getAs<ObjCObjectPointerType>())) 4989 return LHS; 4990 4991 return QualType(); 4992 } 4993 } 4994 4995 return QualType(); 4996} 4997 4998/// mergeObjCGCQualifiers - This routine merges ObjC's GC attribute of 'LHS' and 4999/// 'RHS' attributes and returns the merged version; including for function 5000/// return types. 5001QualType ASTContext::mergeObjCGCQualifiers(QualType LHS, QualType RHS) { 5002 QualType LHSCan = getCanonicalType(LHS), 5003 RHSCan = getCanonicalType(RHS); 5004 // If two types are identical, they are compatible. 5005 if (LHSCan == RHSCan) 5006 return LHS; 5007 if (RHSCan->isFunctionType()) { 5008 if (!LHSCan->isFunctionType()) 5009 return QualType(); 5010 QualType OldReturnType = 5011 cast<FunctionType>(RHSCan.getTypePtr())->getResultType(); 5012 QualType NewReturnType = 5013 cast<FunctionType>(LHSCan.getTypePtr())->getResultType(); 5014 QualType ResReturnType = 5015 mergeObjCGCQualifiers(NewReturnType, OldReturnType); 5016 if (ResReturnType.isNull()) 5017 return QualType(); 5018 if (ResReturnType == NewReturnType || ResReturnType == OldReturnType) { 5019 // id foo(); ... __strong id foo(); or: __strong id foo(); ... id foo(); 5020 // In either case, use OldReturnType to build the new function type. 5021 const FunctionType *F = LHS->getAs<FunctionType>(); 5022 if (const FunctionProtoType *FPT = cast<FunctionProtoType>(F)) { 5023 FunctionType::ExtInfo Info = getFunctionExtInfo(LHS); 5024 QualType ResultType 5025 = getFunctionType(OldReturnType, FPT->arg_type_begin(), 5026 FPT->getNumArgs(), FPT->isVariadic(), 5027 FPT->getTypeQuals(), 5028 FPT->hasExceptionSpec(), 5029 FPT->hasAnyExceptionSpec(), 5030 FPT->getNumExceptions(), 5031 FPT->exception_begin(), 5032 Info); 5033 return ResultType; 5034 } 5035 } 5036 return QualType(); 5037 } 5038 5039 // If the qualifiers are different, the types can still be merged. 5040 Qualifiers LQuals = LHSCan.getLocalQualifiers(); 5041 Qualifiers RQuals = RHSCan.getLocalQualifiers(); 5042 if (LQuals != RQuals) { 5043 // If any of these qualifiers are different, we have a type mismatch. 5044 if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() || 5045 LQuals.getAddressSpace() != RQuals.getAddressSpace()) 5046 return QualType(); 5047 5048 // Exactly one GC qualifier difference is allowed: __strong is 5049 // okay if the other type has no GC qualifier but is an Objective 5050 // C object pointer (i.e. implicitly strong by default). We fix 5051 // this by pretending that the unqualified type was actually 5052 // qualified __strong. 5053 Qualifiers::GC GC_L = LQuals.getObjCGCAttr(); 5054 Qualifiers::GC GC_R = RQuals.getObjCGCAttr(); 5055 assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements"); 5056 5057 if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak) 5058 return QualType(); 5059 5060 if (GC_L == Qualifiers::Strong) 5061 return LHS; 5062 if (GC_R == Qualifiers::Strong) 5063 return RHS; 5064 return QualType(); 5065 } 5066 5067 if (LHSCan->isObjCObjectPointerType() && RHSCan->isObjCObjectPointerType()) { 5068 QualType LHSBaseQT = LHS->getAs<ObjCObjectPointerType>()->getPointeeType(); 5069 QualType RHSBaseQT = RHS->getAs<ObjCObjectPointerType>()->getPointeeType(); 5070 QualType ResQT = mergeObjCGCQualifiers(LHSBaseQT, RHSBaseQT); 5071 if (ResQT == LHSBaseQT) 5072 return LHS; 5073 if (ResQT == RHSBaseQT) 5074 return RHS; 5075 } 5076 return QualType(); 5077} 5078 5079//===----------------------------------------------------------------------===// 5080// Integer Predicates 5081//===----------------------------------------------------------------------===// 5082 5083unsigned ASTContext::getIntWidth(QualType T) { 5084 if (T->isBooleanType()) 5085 return 1; 5086 if (EnumType *ET = dyn_cast<EnumType>(T)) 5087 T = ET->getDecl()->getIntegerType(); 5088 // For builtin types, just use the standard type sizing method 5089 return (unsigned)getTypeSize(T); 5090} 5091 5092QualType ASTContext::getCorrespondingUnsignedType(QualType T) { 5093 assert(T->hasSignedIntegerRepresentation() && "Unexpected type"); 5094 5095 // Turn <4 x signed int> -> <4 x unsigned int> 5096 if (const VectorType *VTy = T->getAs<VectorType>()) 5097 return getVectorType(getCorrespondingUnsignedType(VTy->getElementType()), 5098 VTy->getNumElements(), VTy->getAltiVecSpecific()); 5099 5100 // For enums, we return the unsigned version of the base type. 5101 if (const EnumType *ETy = T->getAs<EnumType>()) 5102 T = ETy->getDecl()->getIntegerType(); 5103 5104 const BuiltinType *BTy = T->getAs<BuiltinType>(); 5105 assert(BTy && "Unexpected signed integer type"); 5106 switch (BTy->getKind()) { 5107 case BuiltinType::Char_S: 5108 case BuiltinType::SChar: 5109 return UnsignedCharTy; 5110 case BuiltinType::Short: 5111 return UnsignedShortTy; 5112 case BuiltinType::Int: 5113 return UnsignedIntTy; 5114 case BuiltinType::Long: 5115 return UnsignedLongTy; 5116 case BuiltinType::LongLong: 5117 return UnsignedLongLongTy; 5118 case BuiltinType::Int128: 5119 return UnsignedInt128Ty; 5120 default: 5121 assert(0 && "Unexpected signed integer type"); 5122 return QualType(); 5123 } 5124} 5125 5126ExternalASTSource::~ExternalASTSource() { } 5127 5128void ExternalASTSource::PrintStats() { } 5129 5130 5131//===----------------------------------------------------------------------===// 5132// Builtin Type Computation 5133//===----------------------------------------------------------------------===// 5134 5135/// DecodeTypeFromStr - This decodes one type descriptor from Str, advancing the 5136/// pointer over the consumed characters. This returns the resultant type. 5137static QualType DecodeTypeFromStr(const char *&Str, ASTContext &Context, 5138 ASTContext::GetBuiltinTypeError &Error, 5139 bool AllowTypeModifiers = true) { 5140 // Modifiers. 5141 int HowLong = 0; 5142 bool Signed = false, Unsigned = false; 5143 5144 // Read the modifiers first. 5145 bool Done = false; 5146 while (!Done) { 5147 switch (*Str++) { 5148 default: Done = true; --Str; break; 5149 case 'S': 5150 assert(!Unsigned && "Can't use both 'S' and 'U' modifiers!"); 5151 assert(!Signed && "Can't use 'S' modifier multiple times!"); 5152 Signed = true; 5153 break; 5154 case 'U': 5155 assert(!Signed && "Can't use both 'S' and 'U' modifiers!"); 5156 assert(!Unsigned && "Can't use 'S' modifier multiple times!"); 5157 Unsigned = true; 5158 break; 5159 case 'L': 5160 assert(HowLong <= 2 && "Can't have LLLL modifier"); 5161 ++HowLong; 5162 break; 5163 } 5164 } 5165 5166 QualType Type; 5167 5168 // Read the base type. 5169 switch (*Str++) { 5170 default: assert(0 && "Unknown builtin type letter!"); 5171 case 'v': 5172 assert(HowLong == 0 && !Signed && !Unsigned && 5173 "Bad modifiers used with 'v'!"); 5174 Type = Context.VoidTy; 5175 break; 5176 case 'f': 5177 assert(HowLong == 0 && !Signed && !Unsigned && 5178 "Bad modifiers used with 'f'!"); 5179 Type = Context.FloatTy; 5180 break; 5181 case 'd': 5182 assert(HowLong < 2 && !Signed && !Unsigned && 5183 "Bad modifiers used with 'd'!"); 5184 if (HowLong) 5185 Type = Context.LongDoubleTy; 5186 else 5187 Type = Context.DoubleTy; 5188 break; 5189 case 's': 5190 assert(HowLong == 0 && "Bad modifiers used with 's'!"); 5191 if (Unsigned) 5192 Type = Context.UnsignedShortTy; 5193 else 5194 Type = Context.ShortTy; 5195 break; 5196 case 'i': 5197 if (HowLong == 3) 5198 Type = Unsigned ? Context.UnsignedInt128Ty : Context.Int128Ty; 5199 else if (HowLong == 2) 5200 Type = Unsigned ? Context.UnsignedLongLongTy : Context.LongLongTy; 5201 else if (HowLong == 1) 5202 Type = Unsigned ? Context.UnsignedLongTy : Context.LongTy; 5203 else 5204 Type = Unsigned ? Context.UnsignedIntTy : Context.IntTy; 5205 break; 5206 case 'c': 5207 assert(HowLong == 0 && "Bad modifiers used with 'c'!"); 5208 if (Signed) 5209 Type = Context.SignedCharTy; 5210 else if (Unsigned) 5211 Type = Context.UnsignedCharTy; 5212 else 5213 Type = Context.CharTy; 5214 break; 5215 case 'b': // boolean 5216 assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'b'!"); 5217 Type = Context.BoolTy; 5218 break; 5219 case 'z': // size_t. 5220 assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'z'!"); 5221 Type = Context.getSizeType(); 5222 break; 5223 case 'F': 5224 Type = Context.getCFConstantStringType(); 5225 break; 5226 case 'a': 5227 Type = Context.getBuiltinVaListType(); 5228 assert(!Type.isNull() && "builtin va list type not initialized!"); 5229 break; 5230 case 'A': 5231 // This is a "reference" to a va_list; however, what exactly 5232 // this means depends on how va_list is defined. There are two 5233 // different kinds of va_list: ones passed by value, and ones 5234 // passed by reference. An example of a by-value va_list is 5235 // x86, where va_list is a char*. An example of by-ref va_list 5236 // is x86-64, where va_list is a __va_list_tag[1]. For x86, 5237 // we want this argument to be a char*&; for x86-64, we want 5238 // it to be a __va_list_tag*. 5239 Type = Context.getBuiltinVaListType(); 5240 assert(!Type.isNull() && "builtin va list type not initialized!"); 5241 if (Type->isArrayType()) { 5242 Type = Context.getArrayDecayedType(Type); 5243 } else { 5244 Type = Context.getLValueReferenceType(Type); 5245 } 5246 break; 5247 case 'V': { 5248 char *End; 5249 unsigned NumElements = strtoul(Str, &End, 10); 5250 assert(End != Str && "Missing vector size"); 5251 5252 Str = End; 5253 5254 QualType ElementType = DecodeTypeFromStr(Str, Context, Error, false); 5255 // FIXME: Don't know what to do about AltiVec. 5256 Type = Context.getVectorType(ElementType, NumElements, 5257 VectorType::NotAltiVec); 5258 break; 5259 } 5260 case 'X': { 5261 QualType ElementType = DecodeTypeFromStr(Str, Context, Error, false); 5262 Type = Context.getComplexType(ElementType); 5263 break; 5264 } 5265 case 'P': 5266 Type = Context.getFILEType(); 5267 if (Type.isNull()) { 5268 Error = ASTContext::GE_Missing_stdio; 5269 return QualType(); 5270 } 5271 break; 5272 case 'J': 5273 if (Signed) 5274 Type = Context.getsigjmp_bufType(); 5275 else 5276 Type = Context.getjmp_bufType(); 5277 5278 if (Type.isNull()) { 5279 Error = ASTContext::GE_Missing_setjmp; 5280 return QualType(); 5281 } 5282 break; 5283 } 5284 5285 if (!AllowTypeModifiers) 5286 return Type; 5287 5288 Done = false; 5289 while (!Done) { 5290 switch (char c = *Str++) { 5291 default: Done = true; --Str; break; 5292 case '*': 5293 case '&': 5294 { 5295 // Both pointers and references can have their pointee types 5296 // qualified with an address space. 5297 char *End; 5298 unsigned AddrSpace = strtoul(Str, &End, 10); 5299 if (End != Str && AddrSpace != 0) { 5300 Type = Context.getAddrSpaceQualType(Type, AddrSpace); 5301 Str = End; 5302 } 5303 } 5304 if (c == '*') 5305 Type = Context.getPointerType(Type); 5306 else 5307 Type = Context.getLValueReferenceType(Type); 5308 break; 5309 // FIXME: There's no way to have a built-in with an rvalue ref arg. 5310 case 'C': 5311 Type = Type.withConst(); 5312 break; 5313 case 'D': 5314 Type = Context.getVolatileType(Type); 5315 break; 5316 } 5317 } 5318 5319 return Type; 5320} 5321 5322/// GetBuiltinType - Return the type for the specified builtin. 5323QualType ASTContext::GetBuiltinType(unsigned id, 5324 GetBuiltinTypeError &Error) { 5325 const char *TypeStr = BuiltinInfo.GetTypeString(id); 5326 5327 llvm::SmallVector<QualType, 8> ArgTypes; 5328 5329 Error = GE_None; 5330 QualType ResType = DecodeTypeFromStr(TypeStr, *this, Error); 5331 if (Error != GE_None) 5332 return QualType(); 5333 while (TypeStr[0] && TypeStr[0] != '.') { 5334 QualType Ty = DecodeTypeFromStr(TypeStr, *this, Error); 5335 if (Error != GE_None) 5336 return QualType(); 5337 5338 // Do array -> pointer decay. The builtin should use the decayed type. 5339 if (Ty->isArrayType()) 5340 Ty = getArrayDecayedType(Ty); 5341 5342 ArgTypes.push_back(Ty); 5343 } 5344 5345 assert((TypeStr[0] != '.' || TypeStr[1] == 0) && 5346 "'.' should only occur at end of builtin type list!"); 5347 5348 // handle untyped/variadic arguments "T c99Style();" or "T cppStyle(...);". 5349 if (ArgTypes.size() == 0 && TypeStr[0] == '.') 5350 return getFunctionNoProtoType(ResType); 5351 5352 // FIXME: Should we create noreturn types? 5353 return getFunctionType(ResType, ArgTypes.data(), ArgTypes.size(), 5354 TypeStr[0] == '.', 0, false, false, 0, 0, 5355 FunctionType::ExtInfo()); 5356} 5357 5358QualType 5359ASTContext::UsualArithmeticConversionsType(QualType lhs, QualType rhs) { 5360 // Perform the usual unary conversions. We do this early so that 5361 // integral promotions to "int" can allow us to exit early, in the 5362 // lhs == rhs check. Also, for conversion purposes, we ignore any 5363 // qualifiers. For example, "const float" and "float" are 5364 // equivalent. 5365 if (lhs->isPromotableIntegerType()) 5366 lhs = getPromotedIntegerType(lhs); 5367 else 5368 lhs = lhs.getUnqualifiedType(); 5369 if (rhs->isPromotableIntegerType()) 5370 rhs = getPromotedIntegerType(rhs); 5371 else 5372 rhs = rhs.getUnqualifiedType(); 5373 5374 // If both types are identical, no conversion is needed. 5375 if (lhs == rhs) 5376 return lhs; 5377 5378 // If either side is a non-arithmetic type (e.g. a pointer), we are done. 5379 // The caller can deal with this (e.g. pointer + int). 5380 if (!lhs->isArithmeticType() || !rhs->isArithmeticType()) 5381 return lhs; 5382 5383 // At this point, we have two different arithmetic types. 5384 5385 // Handle complex types first (C99 6.3.1.8p1). 5386 if (lhs->isComplexType() || rhs->isComplexType()) { 5387 // if we have an integer operand, the result is the complex type. 5388 if (rhs->isIntegerType() || rhs->isComplexIntegerType()) { 5389 // convert the rhs to the lhs complex type. 5390 return lhs; 5391 } 5392 if (lhs->isIntegerType() || lhs->isComplexIntegerType()) { 5393 // convert the lhs to the rhs complex type. 5394 return rhs; 5395 } 5396 // This handles complex/complex, complex/float, or float/complex. 5397 // When both operands are complex, the shorter operand is converted to the 5398 // type of the longer, and that is the type of the result. This corresponds 5399 // to what is done when combining two real floating-point operands. 5400 // The fun begins when size promotion occur across type domains. 5401 // From H&S 6.3.4: When one operand is complex and the other is a real 5402 // floating-point type, the less precise type is converted, within it's 5403 // real or complex domain, to the precision of the other type. For example, 5404 // when combining a "long double" with a "double _Complex", the 5405 // "double _Complex" is promoted to "long double _Complex". 5406 int result = getFloatingTypeOrder(lhs, rhs); 5407 5408 if (result > 0) { // The left side is bigger, convert rhs. 5409 rhs = getFloatingTypeOfSizeWithinDomain(lhs, rhs); 5410 } else if (result < 0) { // The right side is bigger, convert lhs. 5411 lhs = getFloatingTypeOfSizeWithinDomain(rhs, lhs); 5412 } 5413 // At this point, lhs and rhs have the same rank/size. Now, make sure the 5414 // domains match. This is a requirement for our implementation, C99 5415 // does not require this promotion. 5416 if (lhs != rhs) { // Domains don't match, we have complex/float mix. 5417 if (lhs->isRealFloatingType()) { // handle "double, _Complex double". 5418 return rhs; 5419 } else { // handle "_Complex double, double". 5420 return lhs; 5421 } 5422 } 5423 return lhs; // The domain/size match exactly. 5424 } 5425 // Now handle "real" floating types (i.e. float, double, long double). 5426 if (lhs->isRealFloatingType() || rhs->isRealFloatingType()) { 5427 // if we have an integer operand, the result is the real floating type. 5428 if (rhs->isIntegerType()) { 5429 // convert rhs to the lhs floating point type. 5430 return lhs; 5431 } 5432 if (rhs->isComplexIntegerType()) { 5433 // convert rhs to the complex floating point type. 5434 return getComplexType(lhs); 5435 } 5436 if (lhs->isIntegerType()) { 5437 // convert lhs to the rhs floating point type. 5438 return rhs; 5439 } 5440 if (lhs->isComplexIntegerType()) { 5441 // convert lhs to the complex floating point type. 5442 return getComplexType(rhs); 5443 } 5444 // We have two real floating types, float/complex combos were handled above. 5445 // Convert the smaller operand to the bigger result. 5446 int result = getFloatingTypeOrder(lhs, rhs); 5447 if (result > 0) // convert the rhs 5448 return lhs; 5449 assert(result < 0 && "illegal float comparison"); 5450 return rhs; // convert the lhs 5451 } 5452 if (lhs->isComplexIntegerType() || rhs->isComplexIntegerType()) { 5453 // Handle GCC complex int extension. 5454 const ComplexType *lhsComplexInt = lhs->getAsComplexIntegerType(); 5455 const ComplexType *rhsComplexInt = rhs->getAsComplexIntegerType(); 5456 5457 if (lhsComplexInt && rhsComplexInt) { 5458 if (getIntegerTypeOrder(lhsComplexInt->getElementType(), 5459 rhsComplexInt->getElementType()) >= 0) 5460 return lhs; // convert the rhs 5461 return rhs; 5462 } else if (lhsComplexInt && rhs->isIntegerType()) { 5463 // convert the rhs to the lhs complex type. 5464 return lhs; 5465 } else if (rhsComplexInt && lhs->isIntegerType()) { 5466 // convert the lhs to the rhs complex type. 5467 return rhs; 5468 } 5469 } 5470 // Finally, we have two differing integer types. 5471 // The rules for this case are in C99 6.3.1.8 5472 int compare = getIntegerTypeOrder(lhs, rhs); 5473 bool lhsSigned = lhs->hasSignedIntegerRepresentation(), 5474 rhsSigned = rhs->hasSignedIntegerRepresentation(); 5475 QualType destType; 5476 if (lhsSigned == rhsSigned) { 5477 // Same signedness; use the higher-ranked type 5478 destType = compare >= 0 ? lhs : rhs; 5479 } else if (compare != (lhsSigned ? 1 : -1)) { 5480 // The unsigned type has greater than or equal rank to the 5481 // signed type, so use the unsigned type 5482 destType = lhsSigned ? rhs : lhs; 5483 } else if (getIntWidth(lhs) != getIntWidth(rhs)) { 5484 // The two types are different widths; if we are here, that 5485 // means the signed type is larger than the unsigned type, so 5486 // use the signed type. 5487 destType = lhsSigned ? lhs : rhs; 5488 } else { 5489 // The signed type is higher-ranked than the unsigned type, 5490 // but isn't actually any bigger (like unsigned int and long 5491 // on most 32-bit systems). Use the unsigned type corresponding 5492 // to the signed type. 5493 destType = getCorrespondingUnsignedType(lhsSigned ? lhs : rhs); 5494 } 5495 return destType; 5496} 5497 5498GVALinkage ASTContext::GetGVALinkageForFunction(const FunctionDecl *FD) { 5499 GVALinkage External = GVA_StrongExternal; 5500 5501 Linkage L = FD->getLinkage(); 5502 if (L == ExternalLinkage && getLangOptions().CPlusPlus && 5503 FD->getType()->getLinkage() == UniqueExternalLinkage) 5504 L = UniqueExternalLinkage; 5505 5506 switch (L) { 5507 case NoLinkage: 5508 case InternalLinkage: 5509 case UniqueExternalLinkage: 5510 return GVA_Internal; 5511 5512 case ExternalLinkage: 5513 switch (FD->getTemplateSpecializationKind()) { 5514 case TSK_Undeclared: 5515 case TSK_ExplicitSpecialization: 5516 External = GVA_StrongExternal; 5517 break; 5518 5519 case TSK_ExplicitInstantiationDefinition: 5520 return GVA_ExplicitTemplateInstantiation; 5521 5522 case TSK_ExplicitInstantiationDeclaration: 5523 case TSK_ImplicitInstantiation: 5524 External = GVA_TemplateInstantiation; 5525 break; 5526 } 5527 } 5528 5529 if (!FD->isInlined()) 5530 return External; 5531 5532 if (!getLangOptions().CPlusPlus || FD->hasAttr<GNUInlineAttr>()) { 5533 // GNU or C99 inline semantics. Determine whether this symbol should be 5534 // externally visible. 5535 if (FD->isInlineDefinitionExternallyVisible()) 5536 return External; 5537 5538 // C99 inline semantics, where the symbol is not externally visible. 5539 return GVA_C99Inline; 5540 } 5541 5542 // C++0x [temp.explicit]p9: 5543 // [ Note: The intent is that an inline function that is the subject of 5544 // an explicit instantiation declaration will still be implicitly 5545 // instantiated when used so that the body can be considered for 5546 // inlining, but that no out-of-line copy of the inline function would be 5547 // generated in the translation unit. -- end note ] 5548 if (FD->getTemplateSpecializationKind() 5549 == TSK_ExplicitInstantiationDeclaration) 5550 return GVA_C99Inline; 5551 5552 return GVA_CXXInline; 5553} 5554 5555GVALinkage ASTContext::GetGVALinkageForVariable(const VarDecl *VD) { 5556 // If this is a static data member, compute the kind of template 5557 // specialization. Otherwise, this variable is not part of a 5558 // template. 5559 TemplateSpecializationKind TSK = TSK_Undeclared; 5560 if (VD->isStaticDataMember()) 5561 TSK = VD->getTemplateSpecializationKind(); 5562 5563 Linkage L = VD->getLinkage(); 5564 if (L == ExternalLinkage && getLangOptions().CPlusPlus && 5565 VD->getType()->getLinkage() == UniqueExternalLinkage) 5566 L = UniqueExternalLinkage; 5567 5568 switch (L) { 5569 case NoLinkage: 5570 case InternalLinkage: 5571 case UniqueExternalLinkage: 5572 return GVA_Internal; 5573 5574 case ExternalLinkage: 5575 switch (TSK) { 5576 case TSK_Undeclared: 5577 case TSK_ExplicitSpecialization: 5578 return GVA_StrongExternal; 5579 5580 case TSK_ExplicitInstantiationDeclaration: 5581 llvm_unreachable("Variable should not be instantiated"); 5582 // Fall through to treat this like any other instantiation. 5583 5584 case TSK_ExplicitInstantiationDefinition: 5585 return GVA_ExplicitTemplateInstantiation; 5586 5587 case TSK_ImplicitInstantiation: 5588 return GVA_TemplateInstantiation; 5589 } 5590 } 5591 5592 return GVA_StrongExternal; 5593} 5594 5595bool ASTContext::DeclMustBeEmitted(const Decl *D) { 5596 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 5597 if (!VD->isFileVarDecl()) 5598 return false; 5599 } else if (!isa<FunctionDecl>(D)) 5600 return false; 5601 5602 // Weak references don't produce any output by themselves. 5603 if (D->hasAttr<WeakRefAttr>()) 5604 return false; 5605 5606 // Aliases and used decls are required. 5607 if (D->hasAttr<AliasAttr>() || D->hasAttr<UsedAttr>()) 5608 return true; 5609 5610 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 5611 // Forward declarations aren't required. 5612 if (!FD->isThisDeclarationADefinition()) 5613 return false; 5614 5615 // Constructors and destructors are required. 5616 if (FD->hasAttr<ConstructorAttr>() || FD->hasAttr<DestructorAttr>()) 5617 return true; 5618 5619 // The key function for a class is required. 5620 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 5621 const CXXRecordDecl *RD = MD->getParent(); 5622 if (MD->isOutOfLine() && RD->isDynamicClass()) { 5623 const CXXMethodDecl *KeyFunc = getKeyFunction(RD); 5624 if (KeyFunc && KeyFunc->getCanonicalDecl() == MD->getCanonicalDecl()) 5625 return true; 5626 } 5627 } 5628 5629 GVALinkage Linkage = GetGVALinkageForFunction(FD); 5630 5631 // static, static inline, always_inline, and extern inline functions can 5632 // always be deferred. Normal inline functions can be deferred in C99/C++. 5633 // Implicit template instantiations can also be deferred in C++. 5634 if (Linkage == GVA_Internal || Linkage == GVA_C99Inline || 5635 Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation) 5636 return false; 5637 return true; 5638 } 5639 5640 const VarDecl *VD = cast<VarDecl>(D); 5641 assert(VD->isFileVarDecl() && "Expected file scoped var"); 5642 5643 if (VD->isThisDeclarationADefinition() == VarDecl::DeclarationOnly) 5644 return false; 5645 5646 // Structs that have non-trivial constructors or destructors are required. 5647 5648 // FIXME: Handle references. 5649 if (const RecordType *RT = VD->getType()->getAs<RecordType>()) { 5650 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) { 5651 if (RD->hasDefinition() && 5652 (!RD->hasTrivialConstructor() || !RD->hasTrivialDestructor())) 5653 return true; 5654 } 5655 } 5656 5657 GVALinkage L = GetGVALinkageForVariable(VD); 5658 if (L == GVA_Internal || L == GVA_TemplateInstantiation) { 5659 if (!(VD->getInit() && VD->getInit()->HasSideEffects(*this))) 5660 return false; 5661 } 5662 5663 return true; 5664} 5665 5666CXXABI::~CXXABI() {} 5667