ASTContext.cpp revision 53efc251792bf2c9c5f295bd3507facc51a1fe7e
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/Decl.h" 16#include "clang/AST/DeclObjC.h" 17#include "clang/Basic/TargetInfo.h" 18#include "llvm/ADT/SmallVector.h" 19#include "llvm/ADT/StringExtras.h" 20#include "llvm/Bitcode/Serialize.h" 21#include "llvm/Bitcode/Deserialize.h" 22 23using namespace clang; 24 25enum FloatingRank { 26 FloatRank, DoubleRank, LongDoubleRank 27}; 28 29ASTContext::~ASTContext() { 30 // Deallocate all the types. 31 while (!Types.empty()) { 32 if (FunctionTypeProto *FT = dyn_cast<FunctionTypeProto>(Types.back())) { 33 // Destroy the object, but don't call delete. These are malloc'd. 34 FT->~FunctionTypeProto(); 35 free(FT); 36 } else { 37 delete Types.back(); 38 } 39 Types.pop_back(); 40 } 41} 42 43void ASTContext::PrintStats() const { 44 fprintf(stderr, "*** AST Context Stats:\n"); 45 fprintf(stderr, " %d types total.\n", (int)Types.size()); 46 unsigned NumBuiltin = 0, NumPointer = 0, NumArray = 0, NumFunctionP = 0; 47 unsigned NumVector = 0, NumComplex = 0; 48 unsigned NumFunctionNP = 0, NumTypeName = 0, NumTagged = 0, NumReference = 0; 49 50 unsigned NumTagStruct = 0, NumTagUnion = 0, NumTagEnum = 0, NumTagClass = 0; 51 unsigned NumObjCInterfaces = 0, NumObjCQualifiedInterfaces = 0; 52 unsigned NumObjCQualifiedIds = 0; 53 54 for (unsigned i = 0, e = Types.size(); i != e; ++i) { 55 Type *T = Types[i]; 56 if (isa<BuiltinType>(T)) 57 ++NumBuiltin; 58 else if (isa<PointerType>(T)) 59 ++NumPointer; 60 else if (isa<ReferenceType>(T)) 61 ++NumReference; 62 else if (isa<ComplexType>(T)) 63 ++NumComplex; 64 else if (isa<ArrayType>(T)) 65 ++NumArray; 66 else if (isa<VectorType>(T)) 67 ++NumVector; 68 else if (isa<FunctionTypeNoProto>(T)) 69 ++NumFunctionNP; 70 else if (isa<FunctionTypeProto>(T)) 71 ++NumFunctionP; 72 else if (isa<TypedefType>(T)) 73 ++NumTypeName; 74 else if (TagType *TT = dyn_cast<TagType>(T)) { 75 ++NumTagged; 76 switch (TT->getDecl()->getKind()) { 77 default: assert(0 && "Unknown tagged type!"); 78 case Decl::Struct: ++NumTagStruct; break; 79 case Decl::Union: ++NumTagUnion; break; 80 case Decl::Class: ++NumTagClass; break; 81 case Decl::Enum: ++NumTagEnum; break; 82 } 83 } else if (isa<ObjCInterfaceType>(T)) 84 ++NumObjCInterfaces; 85 else if (isa<ObjCQualifiedInterfaceType>(T)) 86 ++NumObjCQualifiedInterfaces; 87 else if (isa<ObjCQualifiedIdType>(T)) 88 ++NumObjCQualifiedIds; 89 else { 90 QualType(T, 0).dump(); 91 assert(0 && "Unknown type!"); 92 } 93 } 94 95 fprintf(stderr, " %d builtin types\n", NumBuiltin); 96 fprintf(stderr, " %d pointer types\n", NumPointer); 97 fprintf(stderr, " %d reference types\n", NumReference); 98 fprintf(stderr, " %d complex types\n", NumComplex); 99 fprintf(stderr, " %d array types\n", NumArray); 100 fprintf(stderr, " %d vector types\n", NumVector); 101 fprintf(stderr, " %d function types with proto\n", NumFunctionP); 102 fprintf(stderr, " %d function types with no proto\n", NumFunctionNP); 103 fprintf(stderr, " %d typename (typedef) types\n", NumTypeName); 104 fprintf(stderr, " %d tagged types\n", NumTagged); 105 fprintf(stderr, " %d struct types\n", NumTagStruct); 106 fprintf(stderr, " %d union types\n", NumTagUnion); 107 fprintf(stderr, " %d class types\n", NumTagClass); 108 fprintf(stderr, " %d enum types\n", NumTagEnum); 109 fprintf(stderr, " %d interface types\n", NumObjCInterfaces); 110 fprintf(stderr, " %d protocol qualified interface types\n", 111 NumObjCQualifiedInterfaces); 112 fprintf(stderr, " %d protocol qualified id types\n", 113 NumObjCQualifiedIds); 114 fprintf(stderr, "Total bytes = %d\n", int(NumBuiltin*sizeof(BuiltinType)+ 115 NumPointer*sizeof(PointerType)+NumArray*sizeof(ArrayType)+ 116 NumComplex*sizeof(ComplexType)+NumVector*sizeof(VectorType)+ 117 NumFunctionP*sizeof(FunctionTypeProto)+ 118 NumFunctionNP*sizeof(FunctionTypeNoProto)+ 119 NumTypeName*sizeof(TypedefType)+NumTagged*sizeof(TagType))); 120} 121 122 123void ASTContext::InitBuiltinType(QualType &R, BuiltinType::Kind K) { 124 Types.push_back((R = QualType(new BuiltinType(K),0)).getTypePtr()); 125} 126 127void ASTContext::InitBuiltinTypes() { 128 assert(VoidTy.isNull() && "Context reinitialized?"); 129 130 // C99 6.2.5p19. 131 InitBuiltinType(VoidTy, BuiltinType::Void); 132 133 // C99 6.2.5p2. 134 InitBuiltinType(BoolTy, BuiltinType::Bool); 135 // C99 6.2.5p3. 136 if (Target.isCharSigned()) 137 InitBuiltinType(CharTy, BuiltinType::Char_S); 138 else 139 InitBuiltinType(CharTy, BuiltinType::Char_U); 140 // C99 6.2.5p4. 141 InitBuiltinType(SignedCharTy, BuiltinType::SChar); 142 InitBuiltinType(ShortTy, BuiltinType::Short); 143 InitBuiltinType(IntTy, BuiltinType::Int); 144 InitBuiltinType(LongTy, BuiltinType::Long); 145 InitBuiltinType(LongLongTy, BuiltinType::LongLong); 146 147 // C99 6.2.5p6. 148 InitBuiltinType(UnsignedCharTy, BuiltinType::UChar); 149 InitBuiltinType(UnsignedShortTy, BuiltinType::UShort); 150 InitBuiltinType(UnsignedIntTy, BuiltinType::UInt); 151 InitBuiltinType(UnsignedLongTy, BuiltinType::ULong); 152 InitBuiltinType(UnsignedLongLongTy, BuiltinType::ULongLong); 153 154 // C99 6.2.5p10. 155 InitBuiltinType(FloatTy, BuiltinType::Float); 156 InitBuiltinType(DoubleTy, BuiltinType::Double); 157 InitBuiltinType(LongDoubleTy, BuiltinType::LongDouble); 158 159 // C99 6.2.5p11. 160 FloatComplexTy = getComplexType(FloatTy); 161 DoubleComplexTy = getComplexType(DoubleTy); 162 LongDoubleComplexTy = getComplexType(LongDoubleTy); 163 164 BuiltinVaListType = QualType(); 165 ObjCIdType = QualType(); 166 IdStructType = 0; 167 ObjCClassType = QualType(); 168 ClassStructType = 0; 169 170 ObjCConstantStringType = QualType(); 171 172 // void * type 173 VoidPtrTy = getPointerType(VoidTy); 174} 175 176//===----------------------------------------------------------------------===// 177// Type Sizing and Analysis 178//===----------------------------------------------------------------------===// 179 180/// getTypeSize - Return the size of the specified type, in bits. This method 181/// does not work on incomplete types. 182std::pair<uint64_t, unsigned> 183ASTContext::getTypeInfo(QualType T) { 184 T = getCanonicalType(T); 185 uint64_t Width; 186 unsigned Align; 187 switch (T->getTypeClass()) { 188 case Type::TypeName: assert(0 && "Not a canonical type!"); 189 case Type::FunctionNoProto: 190 case Type::FunctionProto: 191 default: 192 assert(0 && "Incomplete types have no size!"); 193 case Type::VariableArray: 194 assert(0 && "VLAs not implemented yet!"); 195 case Type::ConstantArray: { 196 ConstantArrayType *CAT = cast<ConstantArrayType>(T); 197 198 std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(CAT->getElementType()); 199 Width = EltInfo.first*CAT->getSize().getZExtValue(); 200 Align = EltInfo.second; 201 break; 202 } 203 case Type::OCUVector: 204 case Type::Vector: { 205 std::pair<uint64_t, unsigned> EltInfo = 206 getTypeInfo(cast<VectorType>(T)->getElementType()); 207 Width = EltInfo.first*cast<VectorType>(T)->getNumElements(); 208 // FIXME: Vector alignment is not the alignment of its elements. 209 Align = EltInfo.second; 210 break; 211 } 212 213 case Type::Builtin: 214 // FIXME: need to use TargetInfo to derive the target specific sizes. This 215 // implementation will suffice for play with vector support. 216 switch (cast<BuiltinType>(T)->getKind()) { 217 default: assert(0 && "Unknown builtin type!"); 218 case BuiltinType::Void: 219 assert(0 && "Incomplete types have no size!"); 220 case BuiltinType::Bool: 221 Width = Target.getBoolWidth(); 222 Align = Target.getBoolAlign(); 223 break; 224 case BuiltinType::Char_S: 225 case BuiltinType::Char_U: 226 case BuiltinType::UChar: 227 case BuiltinType::SChar: 228 Width = Target.getCharWidth(); 229 Align = Target.getCharAlign(); 230 break; 231 case BuiltinType::UShort: 232 case BuiltinType::Short: 233 Width = Target.getShortWidth(); 234 Align = Target.getShortAlign(); 235 break; 236 case BuiltinType::UInt: 237 case BuiltinType::Int: 238 Width = Target.getIntWidth(); 239 Align = Target.getIntAlign(); 240 break; 241 case BuiltinType::ULong: 242 case BuiltinType::Long: 243 Width = Target.getLongWidth(); 244 Align = Target.getLongAlign(); 245 break; 246 case BuiltinType::ULongLong: 247 case BuiltinType::LongLong: 248 Width = Target.getLongLongWidth(); 249 Align = Target.getLongLongAlign(); 250 break; 251 case BuiltinType::Float: 252 Width = Target.getFloatWidth(); 253 Align = Target.getFloatAlign(); 254 break; 255 case BuiltinType::Double: 256 Width = Target.getDoubleWidth(); 257 Align = Target.getDoubleAlign(); 258 break; 259 case BuiltinType::LongDouble: 260 Width = Target.getLongDoubleWidth(); 261 Align = Target.getLongDoubleAlign(); 262 break; 263 } 264 break; 265 case Type::ASQual: 266 // FIXME: Pointers into different addr spaces could have different sizes and 267 // alignment requirements: getPointerInfo should take an AddrSpace. 268 return getTypeInfo(QualType(cast<ASQualType>(T)->getBaseType(), 0)); 269 case Type::ObjCQualifiedId: 270 Width = Target.getPointerWidth(0); 271 Align = Target.getPointerAlign(0); 272 break; 273 case Type::Pointer: { 274 unsigned AS = cast<PointerType>(T)->getPointeeType().getAddressSpace(); 275 Width = Target.getPointerWidth(AS); 276 Align = Target.getPointerAlign(AS); 277 break; 278 } 279 case Type::Reference: 280 // "When applied to a reference or a reference type, the result is the size 281 // of the referenced type." C++98 5.3.3p2: expr.sizeof. 282 // FIXME: This is wrong for struct layout: a reference in a struct has 283 // pointer size. 284 return getTypeInfo(cast<ReferenceType>(T)->getPointeeType()); 285 286 case Type::Complex: { 287 // Complex types have the same alignment as their elements, but twice the 288 // size. 289 std::pair<uint64_t, unsigned> EltInfo = 290 getTypeInfo(cast<ComplexType>(T)->getElementType()); 291 Width = EltInfo.first*2; 292 Align = EltInfo.second; 293 break; 294 } 295 case Type::Tagged: { 296 if (EnumType *ET = dyn_cast<EnumType>(cast<TagType>(T))) 297 return getTypeInfo(ET->getDecl()->getIntegerType()); 298 299 RecordType *RT = cast<RecordType>(T); 300 const ASTRecordLayout &Layout = getASTRecordLayout(RT->getDecl()); 301 Width = Layout.getSize(); 302 Align = Layout.getAlignment(); 303 break; 304 } 305 } 306 307 assert(Align && (Align & (Align-1)) == 0 && "Alignment must be power of 2"); 308 return std::make_pair(Width, Align); 309} 310 311/// getASTRecordLayout - Get or compute information about the layout of the 312/// specified record (struct/union/class), which indicates its size and field 313/// position information. 314const ASTRecordLayout &ASTContext::getASTRecordLayout(const RecordDecl *D) { 315 assert(D->isDefinition() && "Cannot get layout of forward declarations!"); 316 317 // Look up this layout, if already laid out, return what we have. 318 const ASTRecordLayout *&Entry = ASTRecordLayouts[D]; 319 if (Entry) return *Entry; 320 321 // Allocate and assign into ASTRecordLayouts here. The "Entry" reference can 322 // be invalidated (dangle) if the ASTRecordLayouts hashtable is inserted into. 323 ASTRecordLayout *NewEntry = new ASTRecordLayout(); 324 Entry = NewEntry; 325 326 uint64_t *FieldOffsets = new uint64_t[D->getNumMembers()]; 327 uint64_t RecordSize = 0; 328 unsigned RecordAlign = 8; // Default alignment = 1 byte = 8 bits. 329 330 if (D->getKind() != Decl::Union) { 331 if (const AlignedAttr *AA = D->getAttr<AlignedAttr>()) 332 RecordAlign = std::max(RecordAlign, AA->getAlignment()); 333 334 bool StructIsPacked = D->getAttr<PackedAttr>(); 335 336 // Layout each field, for now, just sequentially, respecting alignment. In 337 // the future, this will need to be tweakable by targets. 338 for (unsigned i = 0, e = D->getNumMembers(); i != e; ++i) { 339 const FieldDecl *FD = D->getMember(i); 340 bool FieldIsPacked = StructIsPacked || FD->getAttr<PackedAttr>(); 341 uint64_t FieldSize; 342 unsigned FieldAlign; 343 344 if (const Expr *BitWidthExpr = FD->getBitWidth()) { 345 llvm::APSInt I(32); 346 bool BitWidthIsICE = 347 BitWidthExpr->isIntegerConstantExpr(I, *this); 348 assert (BitWidthIsICE && "Invalid BitField size expression"); 349 FieldSize = I.getZExtValue(); 350 351 std::pair<uint64_t, unsigned> TypeInfo = getTypeInfo(FD->getType()); 352 uint64_t TypeSize = TypeInfo.first; 353 354 if (const AlignedAttr *AA = FD->getAttr<AlignedAttr>()) 355 FieldAlign = AA->getAlignment(); 356 else if (FieldIsPacked) 357 FieldAlign = 8; 358 else { 359 // FIXME: This is X86 specific, use 32-bit alignment for long long. 360 if (FD->getType()->isIntegerType() && TypeInfo.second > 32) 361 FieldAlign = 32; 362 else 363 FieldAlign = TypeInfo.second; 364 } 365 366 // Check if we need to add padding to give the field the correct 367 // alignment. 368 if (RecordSize % FieldAlign + FieldSize > TypeSize) 369 RecordSize = (RecordSize+FieldAlign-1) & ~(FieldAlign-1); 370 371 } else { 372 if (FD->getType()->isIncompleteType()) { 373 // This must be a flexible array member; we can't directly 374 // query getTypeInfo about these, so we figure it out here. 375 // Flexible array members don't have any size, but they 376 // have to be aligned appropriately for their element type. 377 378 if (const AlignedAttr *AA = FD->getAttr<AlignedAttr>()) 379 FieldAlign = AA->getAlignment(); 380 else if (FieldIsPacked) 381 FieldAlign = 8; 382 else { 383 const ArrayType* ATy = FD->getType()->getAsArrayType(); 384 FieldAlign = getTypeAlign(ATy->getElementType()); 385 } 386 FieldSize = 0; 387 } else { 388 std::pair<uint64_t, unsigned> FieldInfo = getTypeInfo(FD->getType()); 389 FieldSize = FieldInfo.first; 390 391 if (const AlignedAttr *AA = FD->getAttr<AlignedAttr>()) 392 FieldAlign = AA->getAlignment(); 393 else if (FieldIsPacked) 394 FieldAlign = 8; 395 else 396 FieldAlign = FieldInfo.second; 397 } 398 399 // Round up the current record size to the field's alignment boundary. 400 RecordSize = (RecordSize+FieldAlign-1) & ~(FieldAlign-1); 401 } 402 403 // Place this field at the current location. 404 FieldOffsets[i] = RecordSize; 405 406 // Reserve space for this field. 407 RecordSize += FieldSize; 408 409 // Remember max struct/class alignment. 410 RecordAlign = std::max(RecordAlign, FieldAlign); 411 } 412 413 // Finally, round the size of the total struct up to the alignment of the 414 // struct itself. 415 RecordSize = (RecordSize+RecordAlign-1) & ~(RecordAlign-1); 416 } else { 417 // Union layout just puts each member at the start of the record. 418 for (unsigned i = 0, e = D->getNumMembers(); i != e; ++i) { 419 const FieldDecl *FD = D->getMember(i); 420 std::pair<uint64_t, unsigned> FieldInfo = getTypeInfo(FD->getType()); 421 uint64_t FieldSize = FieldInfo.first; 422 unsigned FieldAlign = FieldInfo.second; 423 424 // FIXME: This is X86 specific, use 32-bit alignment for long long. 425 if (FD->getType()->isIntegerType() && FieldAlign > 32) 426 FieldAlign = 32; 427 428 // Round up the current record size to the field's alignment boundary. 429 RecordSize = std::max(RecordSize, FieldSize); 430 431 // Place this field at the start of the record. 432 FieldOffsets[i] = 0; 433 434 // Remember max struct/class alignment. 435 RecordAlign = std::max(RecordAlign, FieldAlign); 436 } 437 } 438 439 NewEntry->SetLayout(RecordSize, RecordAlign, FieldOffsets); 440 return *NewEntry; 441} 442 443//===----------------------------------------------------------------------===// 444// Type creation/memoization methods 445//===----------------------------------------------------------------------===// 446 447QualType ASTContext::getASQualType(QualType T, unsigned AddressSpace) { 448 QualType CanT = getCanonicalType(T); 449 if (CanT.getAddressSpace() == AddressSpace) 450 return T; 451 452 // Type's cannot have multiple ASQuals, therefore we know we only have to deal 453 // with CVR qualifiers from here on out. 454 assert(CanT.getAddressSpace() == 0 && 455 "Type is already address space qualified"); 456 457 // Check if we've already instantiated an address space qual'd type of this 458 // type. 459 llvm::FoldingSetNodeID ID; 460 ASQualType::Profile(ID, T.getTypePtr(), AddressSpace); 461 void *InsertPos = 0; 462 if (ASQualType *ASQy = ASQualTypes.FindNodeOrInsertPos(ID, InsertPos)) 463 return QualType(ASQy, 0); 464 465 // If the base type isn't canonical, this won't be a canonical type either, 466 // so fill in the canonical type field. 467 QualType Canonical; 468 if (!T->isCanonical()) { 469 Canonical = getASQualType(CanT, AddressSpace); 470 471 // Get the new insert position for the node we care about. 472 ASQualType *NewIP = ASQualTypes.FindNodeOrInsertPos(ID, InsertPos); 473 assert(NewIP == 0 && "Shouldn't be in the map!"); 474 } 475 ASQualType *New = new ASQualType(T.getTypePtr(), Canonical, AddressSpace); 476 ASQualTypes.InsertNode(New, InsertPos); 477 Types.push_back(New); 478 return QualType(New, T.getCVRQualifiers()); 479} 480 481 482/// getComplexType - Return the uniqued reference to the type for a complex 483/// number with the specified element type. 484QualType ASTContext::getComplexType(QualType T) { 485 // Unique pointers, to guarantee there is only one pointer of a particular 486 // structure. 487 llvm::FoldingSetNodeID ID; 488 ComplexType::Profile(ID, T); 489 490 void *InsertPos = 0; 491 if (ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos)) 492 return QualType(CT, 0); 493 494 // If the pointee type isn't canonical, this won't be a canonical type either, 495 // so fill in the canonical type field. 496 QualType Canonical; 497 if (!T->isCanonical()) { 498 Canonical = getComplexType(getCanonicalType(T)); 499 500 // Get the new insert position for the node we care about. 501 ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos); 502 assert(NewIP == 0 && "Shouldn't be in the map!"); 503 } 504 ComplexType *New = new ComplexType(T, Canonical); 505 Types.push_back(New); 506 ComplexTypes.InsertNode(New, InsertPos); 507 return QualType(New, 0); 508} 509 510 511/// getPointerType - Return the uniqued reference to the type for a pointer to 512/// the specified type. 513QualType ASTContext::getPointerType(QualType T) { 514 // Unique pointers, to guarantee there is only one pointer of a particular 515 // structure. 516 llvm::FoldingSetNodeID ID; 517 PointerType::Profile(ID, T); 518 519 void *InsertPos = 0; 520 if (PointerType *PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 521 return QualType(PT, 0); 522 523 // If the pointee type isn't canonical, this won't be a canonical type either, 524 // so fill in the canonical type field. 525 QualType Canonical; 526 if (!T->isCanonical()) { 527 Canonical = getPointerType(getCanonicalType(T)); 528 529 // Get the new insert position for the node we care about. 530 PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos); 531 assert(NewIP == 0 && "Shouldn't be in the map!"); 532 } 533 PointerType *New = new PointerType(T, Canonical); 534 Types.push_back(New); 535 PointerTypes.InsertNode(New, InsertPos); 536 return QualType(New, 0); 537} 538 539/// getReferenceType - Return the uniqued reference to the type for a reference 540/// to the specified type. 541QualType ASTContext::getReferenceType(QualType T) { 542 // Unique pointers, to guarantee there is only one pointer of a particular 543 // structure. 544 llvm::FoldingSetNodeID ID; 545 ReferenceType::Profile(ID, T); 546 547 void *InsertPos = 0; 548 if (ReferenceType *RT = ReferenceTypes.FindNodeOrInsertPos(ID, InsertPos)) 549 return QualType(RT, 0); 550 551 // If the referencee type isn't canonical, this won't be a canonical type 552 // either, so fill in the canonical type field. 553 QualType Canonical; 554 if (!T->isCanonical()) { 555 Canonical = getReferenceType(getCanonicalType(T)); 556 557 // Get the new insert position for the node we care about. 558 ReferenceType *NewIP = ReferenceTypes.FindNodeOrInsertPos(ID, InsertPos); 559 assert(NewIP == 0 && "Shouldn't be in the map!"); 560 } 561 562 ReferenceType *New = new ReferenceType(T, Canonical); 563 Types.push_back(New); 564 ReferenceTypes.InsertNode(New, InsertPos); 565 return QualType(New, 0); 566} 567 568/// getConstantArrayType - Return the unique reference to the type for an 569/// array of the specified element type. 570QualType ASTContext::getConstantArrayType(QualType EltTy, 571 const llvm::APInt &ArySize, 572 ArrayType::ArraySizeModifier ASM, 573 unsigned EltTypeQuals) { 574 llvm::FoldingSetNodeID ID; 575 ConstantArrayType::Profile(ID, EltTy, ArySize); 576 577 void *InsertPos = 0; 578 if (ConstantArrayType *ATP = 579 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos)) 580 return QualType(ATP, 0); 581 582 // If the element type isn't canonical, this won't be a canonical type either, 583 // so fill in the canonical type field. 584 QualType Canonical; 585 if (!EltTy->isCanonical()) { 586 Canonical = getConstantArrayType(getCanonicalType(EltTy), ArySize, 587 ASM, EltTypeQuals); 588 // Get the new insert position for the node we care about. 589 ConstantArrayType *NewIP = 590 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos); 591 592 assert(NewIP == 0 && "Shouldn't be in the map!"); 593 } 594 595 ConstantArrayType *New = new ConstantArrayType(EltTy, Canonical, ArySize, 596 ASM, EltTypeQuals); 597 ConstantArrayTypes.InsertNode(New, InsertPos); 598 Types.push_back(New); 599 return QualType(New, 0); 600} 601 602/// getVariableArrayType - Returns a non-unique reference to the type for a 603/// variable array of the specified element type. 604QualType ASTContext::getVariableArrayType(QualType EltTy, Expr *NumElts, 605 ArrayType::ArraySizeModifier ASM, 606 unsigned EltTypeQuals) { 607 // Since we don't unique expressions, it isn't possible to unique VLA's 608 // that have an expression provided for their size. 609 610 VariableArrayType *New = new VariableArrayType(EltTy, QualType(), NumElts, 611 ASM, EltTypeQuals); 612 613 VariableArrayTypes.push_back(New); 614 Types.push_back(New); 615 return QualType(New, 0); 616} 617 618QualType ASTContext::getIncompleteArrayType(QualType EltTy, 619 ArrayType::ArraySizeModifier ASM, 620 unsigned EltTypeQuals) { 621 llvm::FoldingSetNodeID ID; 622 IncompleteArrayType::Profile(ID, EltTy); 623 624 void *InsertPos = 0; 625 if (IncompleteArrayType *ATP = 626 IncompleteArrayTypes.FindNodeOrInsertPos(ID, InsertPos)) 627 return QualType(ATP, 0); 628 629 // If the element type isn't canonical, this won't be a canonical type 630 // either, so fill in the canonical type field. 631 QualType Canonical; 632 633 if (!EltTy->isCanonical()) { 634 Canonical = getIncompleteArrayType(getCanonicalType(EltTy), 635 ASM, EltTypeQuals); 636 637 // Get the new insert position for the node we care about. 638 IncompleteArrayType *NewIP = 639 IncompleteArrayTypes.FindNodeOrInsertPos(ID, InsertPos); 640 641 assert(NewIP == 0 && "Shouldn't be in the map!"); 642 } 643 644 IncompleteArrayType *New = new IncompleteArrayType(EltTy, Canonical, 645 ASM, EltTypeQuals); 646 647 IncompleteArrayTypes.InsertNode(New, InsertPos); 648 Types.push_back(New); 649 return QualType(New, 0); 650} 651 652/// getVectorType - Return the unique reference to a vector type of 653/// the specified element type and size. VectorType must be a built-in type. 654QualType ASTContext::getVectorType(QualType vecType, unsigned NumElts) { 655 BuiltinType *baseType; 656 657 baseType = dyn_cast<BuiltinType>(getCanonicalType(vecType).getTypePtr()); 658 assert(baseType != 0 && "getVectorType(): Expecting a built-in type"); 659 660 // Check if we've already instantiated a vector of this type. 661 llvm::FoldingSetNodeID ID; 662 VectorType::Profile(ID, vecType, NumElts, Type::Vector); 663 void *InsertPos = 0; 664 if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos)) 665 return QualType(VTP, 0); 666 667 // If the element type isn't canonical, this won't be a canonical type either, 668 // so fill in the canonical type field. 669 QualType Canonical; 670 if (!vecType->isCanonical()) { 671 Canonical = getVectorType(getCanonicalType(vecType), NumElts); 672 673 // Get the new insert position for the node we care about. 674 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos); 675 assert(NewIP == 0 && "Shouldn't be in the map!"); 676 } 677 VectorType *New = new VectorType(vecType, NumElts, Canonical); 678 VectorTypes.InsertNode(New, InsertPos); 679 Types.push_back(New); 680 return QualType(New, 0); 681} 682 683/// getOCUVectorType - Return the unique reference to an OCU vector type of 684/// the specified element type and size. VectorType must be a built-in type. 685QualType ASTContext::getOCUVectorType(QualType vecType, unsigned NumElts) { 686 BuiltinType *baseType; 687 688 baseType = dyn_cast<BuiltinType>(getCanonicalType(vecType).getTypePtr()); 689 assert(baseType != 0 && "getOCUVectorType(): Expecting a built-in type"); 690 691 // Check if we've already instantiated a vector of this type. 692 llvm::FoldingSetNodeID ID; 693 VectorType::Profile(ID, vecType, NumElts, Type::OCUVector); 694 void *InsertPos = 0; 695 if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos)) 696 return QualType(VTP, 0); 697 698 // If the element type isn't canonical, this won't be a canonical type either, 699 // so fill in the canonical type field. 700 QualType Canonical; 701 if (!vecType->isCanonical()) { 702 Canonical = getOCUVectorType(getCanonicalType(vecType), NumElts); 703 704 // Get the new insert position for the node we care about. 705 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos); 706 assert(NewIP == 0 && "Shouldn't be in the map!"); 707 } 708 OCUVectorType *New = new OCUVectorType(vecType, NumElts, Canonical); 709 VectorTypes.InsertNode(New, InsertPos); 710 Types.push_back(New); 711 return QualType(New, 0); 712} 713 714/// getFunctionTypeNoProto - Return a K&R style C function type like 'int()'. 715/// 716QualType ASTContext::getFunctionTypeNoProto(QualType ResultTy) { 717 // Unique functions, to guarantee there is only one function of a particular 718 // structure. 719 llvm::FoldingSetNodeID ID; 720 FunctionTypeNoProto::Profile(ID, ResultTy); 721 722 void *InsertPos = 0; 723 if (FunctionTypeNoProto *FT = 724 FunctionTypeNoProtos.FindNodeOrInsertPos(ID, InsertPos)) 725 return QualType(FT, 0); 726 727 QualType Canonical; 728 if (!ResultTy->isCanonical()) { 729 Canonical = getFunctionTypeNoProto(getCanonicalType(ResultTy)); 730 731 // Get the new insert position for the node we care about. 732 FunctionTypeNoProto *NewIP = 733 FunctionTypeNoProtos.FindNodeOrInsertPos(ID, InsertPos); 734 assert(NewIP == 0 && "Shouldn't be in the map!"); 735 } 736 737 FunctionTypeNoProto *New = new FunctionTypeNoProto(ResultTy, Canonical); 738 Types.push_back(New); 739 FunctionTypeNoProtos.InsertNode(New, InsertPos); 740 return QualType(New, 0); 741} 742 743/// getFunctionType - Return a normal function type with a typed argument 744/// list. isVariadic indicates whether the argument list includes '...'. 745QualType ASTContext::getFunctionType(QualType ResultTy, QualType *ArgArray, 746 unsigned NumArgs, bool isVariadic) { 747 // Unique functions, to guarantee there is only one function of a particular 748 // structure. 749 llvm::FoldingSetNodeID ID; 750 FunctionTypeProto::Profile(ID, ResultTy, ArgArray, NumArgs, isVariadic); 751 752 void *InsertPos = 0; 753 if (FunctionTypeProto *FTP = 754 FunctionTypeProtos.FindNodeOrInsertPos(ID, InsertPos)) 755 return QualType(FTP, 0); 756 757 // Determine whether the type being created is already canonical or not. 758 bool isCanonical = ResultTy->isCanonical(); 759 for (unsigned i = 0; i != NumArgs && isCanonical; ++i) 760 if (!ArgArray[i]->isCanonical()) 761 isCanonical = false; 762 763 // If this type isn't canonical, get the canonical version of it. 764 QualType Canonical; 765 if (!isCanonical) { 766 llvm::SmallVector<QualType, 16> CanonicalArgs; 767 CanonicalArgs.reserve(NumArgs); 768 for (unsigned i = 0; i != NumArgs; ++i) 769 CanonicalArgs.push_back(getCanonicalType(ArgArray[i])); 770 771 Canonical = getFunctionType(getCanonicalType(ResultTy), 772 &CanonicalArgs[0], NumArgs, 773 isVariadic); 774 775 // Get the new insert position for the node we care about. 776 FunctionTypeProto *NewIP = 777 FunctionTypeProtos.FindNodeOrInsertPos(ID, InsertPos); 778 assert(NewIP == 0 && "Shouldn't be in the map!"); 779 } 780 781 // FunctionTypeProto objects are not allocated with new because they have a 782 // variable size array (for parameter types) at the end of them. 783 FunctionTypeProto *FTP = 784 (FunctionTypeProto*)malloc(sizeof(FunctionTypeProto) + 785 NumArgs*sizeof(QualType)); 786 new (FTP) FunctionTypeProto(ResultTy, ArgArray, NumArgs, isVariadic, 787 Canonical); 788 Types.push_back(FTP); 789 FunctionTypeProtos.InsertNode(FTP, InsertPos); 790 return QualType(FTP, 0); 791} 792 793/// getTypedefType - Return the unique reference to the type for the 794/// specified typename decl. 795QualType ASTContext::getTypedefType(TypedefDecl *Decl) { 796 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 797 798 QualType Canonical = getCanonicalType(Decl->getUnderlyingType()); 799 Decl->TypeForDecl = new TypedefType(Type::TypeName, Decl, Canonical); 800 Types.push_back(Decl->TypeForDecl); 801 return QualType(Decl->TypeForDecl, 0); 802} 803 804/// getObjCInterfaceType - Return the unique reference to the type for the 805/// specified ObjC interface decl. 806QualType ASTContext::getObjCInterfaceType(ObjCInterfaceDecl *Decl) { 807 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 808 809 Decl->TypeForDecl = new ObjCInterfaceType(Type::ObjCInterface, Decl); 810 Types.push_back(Decl->TypeForDecl); 811 return QualType(Decl->TypeForDecl, 0); 812} 813 814/// getObjCQualifiedInterfaceType - Return a 815/// ObjCQualifiedInterfaceType type for the given interface decl and 816/// the conforming protocol list. 817QualType ASTContext::getObjCQualifiedInterfaceType(ObjCInterfaceDecl *Decl, 818 ObjCProtocolDecl **Protocols, unsigned NumProtocols) { 819 llvm::FoldingSetNodeID ID; 820 ObjCQualifiedInterfaceType::Profile(ID, Protocols, NumProtocols); 821 822 void *InsertPos = 0; 823 if (ObjCQualifiedInterfaceType *QT = 824 ObjCQualifiedInterfaceTypes.FindNodeOrInsertPos(ID, InsertPos)) 825 return QualType(QT, 0); 826 827 // No Match; 828 ObjCQualifiedInterfaceType *QType = 829 new ObjCQualifiedInterfaceType(Decl, Protocols, NumProtocols); 830 Types.push_back(QType); 831 ObjCQualifiedInterfaceTypes.InsertNode(QType, InsertPos); 832 return QualType(QType, 0); 833} 834 835/// getObjCQualifiedIdType - Return a 836/// getObjCQualifiedIdType type for the 'id' decl and 837/// the conforming protocol list. 838QualType ASTContext::getObjCQualifiedIdType(QualType idType, 839 ObjCProtocolDecl **Protocols, 840 unsigned NumProtocols) { 841 llvm::FoldingSetNodeID ID; 842 ObjCQualifiedIdType::Profile(ID, Protocols, NumProtocols); 843 844 void *InsertPos = 0; 845 if (ObjCQualifiedIdType *QT = 846 ObjCQualifiedIdTypes.FindNodeOrInsertPos(ID, InsertPos)) 847 return QualType(QT, 0); 848 849 // No Match; 850 QualType Canonical; 851 if (!idType->isCanonical()) { 852 Canonical = getObjCQualifiedIdType(getCanonicalType(idType), 853 Protocols, NumProtocols); 854 ObjCQualifiedIdType *NewQT = 855 ObjCQualifiedIdTypes.FindNodeOrInsertPos(ID, InsertPos); 856 assert(NewQT == 0 && "Shouldn't be in the map!"); 857 } 858 859 ObjCQualifiedIdType *QType = 860 new ObjCQualifiedIdType(Canonical, Protocols, NumProtocols); 861 Types.push_back(QType); 862 ObjCQualifiedIdTypes.InsertNode(QType, InsertPos); 863 return QualType(QType, 0); 864} 865 866/// getTypeOfExpr - Unlike many "get<Type>" functions, we can't unique 867/// TypeOfExpr AST's (since expression's are never shared). For example, 868/// multiple declarations that refer to "typeof(x)" all contain different 869/// DeclRefExpr's. This doesn't effect the type checker, since it operates 870/// on canonical type's (which are always unique). 871QualType ASTContext::getTypeOfExpr(Expr *tofExpr) { 872 QualType Canonical = getCanonicalType(tofExpr->getType()); 873 TypeOfExpr *toe = new TypeOfExpr(tofExpr, Canonical); 874 Types.push_back(toe); 875 return QualType(toe, 0); 876} 877 878/// getTypeOfType - Unlike many "get<Type>" functions, we don't unique 879/// TypeOfType AST's. The only motivation to unique these nodes would be 880/// memory savings. Since typeof(t) is fairly uncommon, space shouldn't be 881/// an issue. This doesn't effect the type checker, since it operates 882/// on canonical type's (which are always unique). 883QualType ASTContext::getTypeOfType(QualType tofType) { 884 QualType Canonical = getCanonicalType(tofType); 885 TypeOfType *tot = new TypeOfType(tofType, Canonical); 886 Types.push_back(tot); 887 return QualType(tot, 0); 888} 889 890/// getTagDeclType - Return the unique reference to the type for the 891/// specified TagDecl (struct/union/class/enum) decl. 892QualType ASTContext::getTagDeclType(TagDecl *Decl) { 893 assert (Decl); 894 895 // The decl stores the type cache. 896 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 897 898 TagType* T = new TagType(Decl, QualType()); 899 Types.push_back(T); 900 Decl->TypeForDecl = T; 901 902 return QualType(T, 0); 903} 904 905/// getSizeType - Return the unique type for "size_t" (C99 7.17), the result 906/// of the sizeof operator (C99 6.5.3.4p4). The value is target dependent and 907/// needs to agree with the definition in <stddef.h>. 908QualType ASTContext::getSizeType() const { 909 // On Darwin, size_t is defined as a "long unsigned int". 910 // FIXME: should derive from "Target". 911 return UnsignedLongTy; 912} 913 914/// getWcharType - Return the unique type for "wchar_t" (C99 7.17), the 915/// width of characters in wide strings, The value is target dependent and 916/// needs to agree with the definition in <stddef.h>. 917QualType ASTContext::getWcharType() const { 918 // On Darwin, wchar_t is defined as a "int". 919 // FIXME: should derive from "Target". 920 return IntTy; 921} 922 923/// getPointerDiffType - Return the unique type for "ptrdiff_t" (ref?) 924/// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9). 925QualType ASTContext::getPointerDiffType() const { 926 // On Darwin, ptrdiff_t is defined as a "int". This seems like a bug... 927 // FIXME: should derive from "Target". 928 return IntTy; 929} 930 931//===----------------------------------------------------------------------===// 932// Type Operators 933//===----------------------------------------------------------------------===// 934 935/// getCanonicalType - Return the canonical (structural) type corresponding to 936/// the specified potentially non-canonical type. The non-canonical version 937/// of a type may have many "decorated" versions of types. Decorators can 938/// include typedefs, 'typeof' operators, etc. The returned type is guaranteed 939/// to be free of any of these, allowing two canonical types to be compared 940/// for exact equality with a simple pointer comparison. 941QualType ASTContext::getCanonicalType(QualType T) { 942 QualType CanType = T.getTypePtr()->getCanonicalTypeInternal(); 943 return QualType(CanType.getTypePtr(), 944 T.getCVRQualifiers() | CanType.getCVRQualifiers()); 945} 946 947 948/// getArrayDecayedType - Return the properly qualified result of decaying the 949/// specified array type to a pointer. This operation is non-trivial when 950/// handling typedefs etc. The canonical type of "T" must be an array type, 951/// this returns a pointer to a properly qualified element of the array. 952/// 953/// See C99 6.7.5.3p7 and C99 6.3.2.1p3. 954QualType ASTContext::getArrayDecayedType(QualType Ty) { 955 // Handle the common case where typedefs are not involved directly. 956 QualType EltTy; 957 unsigned ArrayQuals = 0; 958 unsigned PointerQuals = 0; 959 if (ArrayType *AT = dyn_cast<ArrayType>(Ty)) { 960 // Since T "isa" an array type, it could not have had an address space 961 // qualifier, just CVR qualifiers. The properly qualified element pointer 962 // gets the union of the CVR qualifiers from the element and the array, and 963 // keeps any address space qualifier on the element type if present. 964 EltTy = AT->getElementType(); 965 ArrayQuals = Ty.getCVRQualifiers(); 966 PointerQuals = AT->getIndexTypeQualifier(); 967 } else { 968 // Otherwise, we have an ASQualType or a typedef, etc. Make sure we don't 969 // lose qualifiers when dealing with typedefs. Example: 970 // typedef int arr[10]; 971 // void test2() { 972 // const arr b; 973 // b[4] = 1; 974 // } 975 // 976 // The decayed type of b is "const int*" even though the element type of the 977 // array is "int". 978 QualType CanTy = getCanonicalType(Ty); 979 const ArrayType *PrettyArrayType = Ty->getAsArrayType(); 980 assert(PrettyArrayType && "Not an array type!"); 981 982 // Get the element type with 'getAsArrayType' so that we don't lose any 983 // typedefs in the element type of the array. 984 EltTy = PrettyArrayType->getElementType(); 985 986 // If the array was address-space qualifier, make sure to ASQual the element 987 // type. We can just grab the address space from the canonical type. 988 if (unsigned AS = CanTy.getAddressSpace()) 989 EltTy = getASQualType(EltTy, AS); 990 991 // To properly handle [multiple levels of] typedefs, typeof's etc, we take 992 // the CVR qualifiers directly from the canonical type, which is guaranteed 993 // to have the full set unioned together. 994 ArrayQuals = CanTy.getCVRQualifiers(); 995 PointerQuals = PrettyArrayType->getIndexTypeQualifier(); 996 } 997 998 // Apply any CVR qualifiers from the array type to the element type. This 999 // implements C99 6.7.3p8: "If the specification of an array type includes 1000 // any type qualifiers, the element type is so qualified, not the array type." 1001 EltTy = EltTy.getQualifiedType(ArrayQuals | EltTy.getCVRQualifiers()); 1002 1003 QualType PtrTy = getPointerType(EltTy); 1004 1005 // int x[restrict 4] -> int *restrict 1006 PtrTy = PtrTy.getQualifiedType(PointerQuals); 1007 1008 return PtrTy; 1009} 1010 1011/// getFloatingRank - Return a relative rank for floating point types. 1012/// This routine will assert if passed a built-in type that isn't a float. 1013static FloatingRank getFloatingRank(QualType T) { 1014 if (const ComplexType *CT = T->getAsComplexType()) 1015 return getFloatingRank(CT->getElementType()); 1016 1017 switch (T->getAsBuiltinType()->getKind()) { 1018 default: assert(0 && "getFloatingRank(): not a floating type"); 1019 case BuiltinType::Float: return FloatRank; 1020 case BuiltinType::Double: return DoubleRank; 1021 case BuiltinType::LongDouble: return LongDoubleRank; 1022 } 1023} 1024 1025/// getFloatingTypeOfSizeWithinDomain - Returns a real floating 1026/// point or a complex type (based on typeDomain/typeSize). 1027/// 'typeDomain' is a real floating point or complex type. 1028/// 'typeSize' is a real floating point or complex type. 1029QualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size, 1030 QualType Domain) const { 1031 FloatingRank EltRank = getFloatingRank(Size); 1032 if (Domain->isComplexType()) { 1033 switch (EltRank) { 1034 default: assert(0 && "getFloatingRank(): illegal value for rank"); 1035 case FloatRank: return FloatComplexTy; 1036 case DoubleRank: return DoubleComplexTy; 1037 case LongDoubleRank: return LongDoubleComplexTy; 1038 } 1039 } 1040 1041 assert(Domain->isRealFloatingType() && "Unknown domain!"); 1042 switch (EltRank) { 1043 default: assert(0 && "getFloatingRank(): illegal value for rank"); 1044 case FloatRank: return FloatTy; 1045 case DoubleRank: return DoubleTy; 1046 case LongDoubleRank: return LongDoubleTy; 1047 } 1048} 1049 1050/// getFloatingTypeOrder - Compare the rank of the two specified floating 1051/// point types, ignoring the domain of the type (i.e. 'double' == 1052/// '_Complex double'). If LHS > RHS, return 1. If LHS == RHS, return 0. If 1053/// LHS < RHS, return -1. 1054int ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) { 1055 FloatingRank LHSR = getFloatingRank(LHS); 1056 FloatingRank RHSR = getFloatingRank(RHS); 1057 1058 if (LHSR == RHSR) 1059 return 0; 1060 if (LHSR > RHSR) 1061 return 1; 1062 return -1; 1063} 1064 1065/// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This 1066/// routine will assert if passed a built-in type that isn't an integer or enum, 1067/// or if it is not canonicalized. 1068static unsigned getIntegerRank(Type *T) { 1069 assert(T->isCanonical() && "T should be canonicalized"); 1070 if (isa<EnumType>(T)) 1071 return 4; 1072 1073 switch (cast<BuiltinType>(T)->getKind()) { 1074 default: assert(0 && "getIntegerRank(): not a built-in integer"); 1075 case BuiltinType::Bool: 1076 return 1; 1077 case BuiltinType::Char_S: 1078 case BuiltinType::Char_U: 1079 case BuiltinType::SChar: 1080 case BuiltinType::UChar: 1081 return 2; 1082 case BuiltinType::Short: 1083 case BuiltinType::UShort: 1084 return 3; 1085 case BuiltinType::Int: 1086 case BuiltinType::UInt: 1087 return 4; 1088 case BuiltinType::Long: 1089 case BuiltinType::ULong: 1090 return 5; 1091 case BuiltinType::LongLong: 1092 case BuiltinType::ULongLong: 1093 return 6; 1094 } 1095} 1096 1097/// getIntegerTypeOrder - Returns the highest ranked integer type: 1098/// C99 6.3.1.8p1. If LHS > RHS, return 1. If LHS == RHS, return 0. If 1099/// LHS < RHS, return -1. 1100int ASTContext::getIntegerTypeOrder(QualType LHS, QualType RHS) { 1101 Type *LHSC = getCanonicalType(LHS).getTypePtr(); 1102 Type *RHSC = getCanonicalType(RHS).getTypePtr(); 1103 if (LHSC == RHSC) return 0; 1104 1105 bool LHSUnsigned = LHSC->isUnsignedIntegerType(); 1106 bool RHSUnsigned = RHSC->isUnsignedIntegerType(); 1107 1108 unsigned LHSRank = getIntegerRank(LHSC); 1109 unsigned RHSRank = getIntegerRank(RHSC); 1110 1111 if (LHSUnsigned == RHSUnsigned) { // Both signed or both unsigned. 1112 if (LHSRank == RHSRank) return 0; 1113 return LHSRank > RHSRank ? 1 : -1; 1114 } 1115 1116 // Otherwise, the LHS is signed and the RHS is unsigned or visa versa. 1117 if (LHSUnsigned) { 1118 // If the unsigned [LHS] type is larger, return it. 1119 if (LHSRank >= RHSRank) 1120 return 1; 1121 1122 // If the signed type can represent all values of the unsigned type, it 1123 // wins. Because we are dealing with 2's complement and types that are 1124 // powers of two larger than each other, this is always safe. 1125 return -1; 1126 } 1127 1128 // If the unsigned [RHS] type is larger, return it. 1129 if (RHSRank >= LHSRank) 1130 return -1; 1131 1132 // If the signed type can represent all values of the unsigned type, it 1133 // wins. Because we are dealing with 2's complement and types that are 1134 // powers of two larger than each other, this is always safe. 1135 return 1; 1136} 1137 1138// getCFConstantStringType - Return the type used for constant CFStrings. 1139QualType ASTContext::getCFConstantStringType() { 1140 if (!CFConstantStringTypeDecl) { 1141 CFConstantStringTypeDecl = 1142 RecordDecl::Create(*this, Decl::Struct, NULL, SourceLocation(), 1143 &Idents.get("NSConstantString"), 0); 1144 QualType FieldTypes[4]; 1145 1146 // const int *isa; 1147 FieldTypes[0] = getPointerType(IntTy.getQualifiedType(QualType::Const)); 1148 // int flags; 1149 FieldTypes[1] = IntTy; 1150 // const char *str; 1151 FieldTypes[2] = getPointerType(CharTy.getQualifiedType(QualType::Const)); 1152 // long length; 1153 FieldTypes[3] = LongTy; 1154 // Create fields 1155 FieldDecl *FieldDecls[4]; 1156 1157 for (unsigned i = 0; i < 4; ++i) 1158 FieldDecls[i] = FieldDecl::Create(*this, SourceLocation(), 0, 1159 FieldTypes[i]); 1160 1161 CFConstantStringTypeDecl->defineBody(FieldDecls, 4); 1162 } 1163 1164 return getTagDeclType(CFConstantStringTypeDecl); 1165} 1166 1167// This returns true if a type has been typedefed to BOOL: 1168// typedef <type> BOOL; 1169static bool isTypeTypedefedAsBOOL(QualType T) { 1170 if (const TypedefType *TT = dyn_cast<TypedefType>(T)) 1171 return !strcmp(TT->getDecl()->getName(), "BOOL"); 1172 1173 return false; 1174} 1175 1176/// getObjCEncodingTypeSize returns size of type for objective-c encoding 1177/// purpose. 1178int ASTContext::getObjCEncodingTypeSize(QualType type) { 1179 uint64_t sz = getTypeSize(type); 1180 1181 // Make all integer and enum types at least as large as an int 1182 if (sz > 0 && type->isIntegralType()) 1183 sz = std::max(sz, getTypeSize(IntTy)); 1184 // Treat arrays as pointers, since that's how they're passed in. 1185 else if (type->isArrayType()) 1186 sz = getTypeSize(VoidPtrTy); 1187 return sz / getTypeSize(CharTy); 1188} 1189 1190/// getObjCEncodingForMethodDecl - Return the encoded type for this method 1191/// declaration. 1192void ASTContext::getObjCEncodingForMethodDecl(ObjCMethodDecl *Decl, 1193 std::string& S) 1194{ 1195 // Encode type qualifer, 'in', 'inout', etc. for the return type. 1196 getObjCEncodingForTypeQualifier(Decl->getObjCDeclQualifier(), S); 1197 // Encode result type. 1198 getObjCEncodingForType(Decl->getResultType(), S, EncodingRecordTypes); 1199 // Compute size of all parameters. 1200 // Start with computing size of a pointer in number of bytes. 1201 // FIXME: There might(should) be a better way of doing this computation! 1202 SourceLocation Loc; 1203 int PtrSize = getTypeSize(VoidPtrTy) / getTypeSize(CharTy); 1204 // The first two arguments (self and _cmd) are pointers; account for 1205 // their size. 1206 int ParmOffset = 2 * PtrSize; 1207 int NumOfParams = Decl->getNumParams(); 1208 for (int i = 0; i < NumOfParams; i++) { 1209 QualType PType = Decl->getParamDecl(i)->getType(); 1210 int sz = getObjCEncodingTypeSize (PType); 1211 assert (sz > 0 && "getObjCEncodingForMethodDecl - Incomplete param type"); 1212 ParmOffset += sz; 1213 } 1214 S += llvm::utostr(ParmOffset); 1215 S += "@0:"; 1216 S += llvm::utostr(PtrSize); 1217 1218 // Argument types. 1219 ParmOffset = 2 * PtrSize; 1220 for (int i = 0; i < NumOfParams; i++) { 1221 QualType PType = Decl->getParamDecl(i)->getType(); 1222 // Process argument qualifiers for user supplied arguments; such as, 1223 // 'in', 'inout', etc. 1224 getObjCEncodingForTypeQualifier( 1225 Decl->getParamDecl(i)->getObjCDeclQualifier(), S); 1226 getObjCEncodingForType(PType, S, EncodingRecordTypes); 1227 S += llvm::utostr(ParmOffset); 1228 ParmOffset += getObjCEncodingTypeSize(PType); 1229 } 1230} 1231 1232void ASTContext::getObjCEncodingForType(QualType T, std::string& S, 1233 llvm::SmallVector<const RecordType *, 8> &ERType) const 1234{ 1235 // FIXME: This currently doesn't encode: 1236 // @ An object (whether statically typed or typed id) 1237 // # A class object (Class) 1238 // : A method selector (SEL) 1239 // {name=type...} A structure 1240 // (name=type...) A union 1241 // bnum A bit field of num bits 1242 1243 if (const BuiltinType *BT = T->getAsBuiltinType()) { 1244 char encoding; 1245 switch (BT->getKind()) { 1246 default: assert(0 && "Unhandled builtin type kind"); 1247 case BuiltinType::Void: encoding = 'v'; break; 1248 case BuiltinType::Bool: encoding = 'B'; break; 1249 case BuiltinType::Char_U: 1250 case BuiltinType::UChar: encoding = 'C'; break; 1251 case BuiltinType::UShort: encoding = 'S'; break; 1252 case BuiltinType::UInt: encoding = 'I'; break; 1253 case BuiltinType::ULong: encoding = 'L'; break; 1254 case BuiltinType::ULongLong: encoding = 'Q'; break; 1255 case BuiltinType::Char_S: 1256 case BuiltinType::SChar: encoding = 'c'; break; 1257 case BuiltinType::Short: encoding = 's'; break; 1258 case BuiltinType::Int: encoding = 'i'; break; 1259 case BuiltinType::Long: encoding = 'l'; break; 1260 case BuiltinType::LongLong: encoding = 'q'; break; 1261 case BuiltinType::Float: encoding = 'f'; break; 1262 case BuiltinType::Double: encoding = 'd'; break; 1263 case BuiltinType::LongDouble: encoding = 'd'; break; 1264 } 1265 1266 S += encoding; 1267 } 1268 else if (T->isObjCQualifiedIdType()) { 1269 // Treat id<P...> same as 'id' for encoding purposes. 1270 return getObjCEncodingForType(getObjCIdType(), S, ERType); 1271 1272 } 1273 else if (const PointerType *PT = T->getAsPointerType()) { 1274 QualType PointeeTy = PT->getPointeeType(); 1275 if (isObjCIdType(PointeeTy) || PointeeTy->isObjCInterfaceType()) { 1276 S += '@'; 1277 return; 1278 } else if (isObjCClassType(PointeeTy)) { 1279 S += '#'; 1280 return; 1281 } else if (isObjCSelType(PointeeTy)) { 1282 S += ':'; 1283 return; 1284 } 1285 1286 if (PointeeTy->isCharType()) { 1287 // char pointer types should be encoded as '*' unless it is a 1288 // type that has been typedef'd to 'BOOL'. 1289 if (!isTypeTypedefedAsBOOL(PointeeTy)) { 1290 S += '*'; 1291 return; 1292 } 1293 } 1294 1295 S += '^'; 1296 getObjCEncodingForType(PT->getPointeeType(), S, ERType); 1297 } else if (const ArrayType *AT = T->getAsArrayType()) { 1298 S += '['; 1299 1300 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) 1301 S += llvm::utostr(CAT->getSize().getZExtValue()); 1302 else 1303 assert(0 && "Unhandled array type!"); 1304 1305 getObjCEncodingForType(AT->getElementType(), S, ERType); 1306 S += ']'; 1307 } else if (T->getAsFunctionType()) { 1308 S += '?'; 1309 } else if (const RecordType *RTy = T->getAsRecordType()) { 1310 RecordDecl *RDecl= RTy->getDecl(); 1311 S += '{'; 1312 S += RDecl->getName(); 1313 bool found = false; 1314 for (unsigned i = 0, e = ERType.size(); i != e; ++i) 1315 if (ERType[i] == RTy) { 1316 found = true; 1317 break; 1318 } 1319 if (!found) { 1320 ERType.push_back(RTy); 1321 S += '='; 1322 for (int i = 0; i < RDecl->getNumMembers(); i++) { 1323 FieldDecl *field = RDecl->getMember(i); 1324 getObjCEncodingForType(field->getType(), S, ERType); 1325 } 1326 assert(ERType.back() == RTy && "Record Type stack mismatch."); 1327 ERType.pop_back(); 1328 } 1329 S += '}'; 1330 } else if (T->isEnumeralType()) { 1331 S += 'i'; 1332 } else 1333 assert(0 && "@encode for type not implemented!"); 1334} 1335 1336void ASTContext::getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT, 1337 std::string& S) const { 1338 if (QT & Decl::OBJC_TQ_In) 1339 S += 'n'; 1340 if (QT & Decl::OBJC_TQ_Inout) 1341 S += 'N'; 1342 if (QT & Decl::OBJC_TQ_Out) 1343 S += 'o'; 1344 if (QT & Decl::OBJC_TQ_Bycopy) 1345 S += 'O'; 1346 if (QT & Decl::OBJC_TQ_Byref) 1347 S += 'R'; 1348 if (QT & Decl::OBJC_TQ_Oneway) 1349 S += 'V'; 1350} 1351 1352void ASTContext::setBuiltinVaListType(QualType T) 1353{ 1354 assert(BuiltinVaListType.isNull() && "__builtin_va_list type already set!"); 1355 1356 BuiltinVaListType = T; 1357} 1358 1359void ASTContext::setObjCIdType(TypedefDecl *TD) 1360{ 1361 assert(ObjCIdType.isNull() && "'id' type already set!"); 1362 1363 ObjCIdType = getTypedefType(TD); 1364 1365 // typedef struct objc_object *id; 1366 const PointerType *ptr = TD->getUnderlyingType()->getAsPointerType(); 1367 assert(ptr && "'id' incorrectly typed"); 1368 const RecordType *rec = ptr->getPointeeType()->getAsStructureType(); 1369 assert(rec && "'id' incorrectly typed"); 1370 IdStructType = rec; 1371} 1372 1373void ASTContext::setObjCSelType(TypedefDecl *TD) 1374{ 1375 assert(ObjCSelType.isNull() && "'SEL' type already set!"); 1376 1377 ObjCSelType = getTypedefType(TD); 1378 1379 // typedef struct objc_selector *SEL; 1380 const PointerType *ptr = TD->getUnderlyingType()->getAsPointerType(); 1381 assert(ptr && "'SEL' incorrectly typed"); 1382 const RecordType *rec = ptr->getPointeeType()->getAsStructureType(); 1383 assert(rec && "'SEL' incorrectly typed"); 1384 SelStructType = rec; 1385} 1386 1387void ASTContext::setObjCProtoType(QualType QT) 1388{ 1389 assert(ObjCProtoType.isNull() && "'Protocol' type already set!"); 1390 ObjCProtoType = QT; 1391} 1392 1393void ASTContext::setObjCClassType(TypedefDecl *TD) 1394{ 1395 assert(ObjCClassType.isNull() && "'Class' type already set!"); 1396 1397 ObjCClassType = getTypedefType(TD); 1398 1399 // typedef struct objc_class *Class; 1400 const PointerType *ptr = TD->getUnderlyingType()->getAsPointerType(); 1401 assert(ptr && "'Class' incorrectly typed"); 1402 const RecordType *rec = ptr->getPointeeType()->getAsStructureType(); 1403 assert(rec && "'Class' incorrectly typed"); 1404 ClassStructType = rec; 1405} 1406 1407void ASTContext::setObjCConstantStringInterface(ObjCInterfaceDecl *Decl) { 1408 assert(ObjCConstantStringType.isNull() && 1409 "'NSConstantString' type already set!"); 1410 1411 ObjCConstantStringType = getObjCInterfaceType(Decl); 1412} 1413 1414bool ASTContext::builtinTypesAreCompatible(QualType lhs, QualType rhs) { 1415 const BuiltinType *lBuiltin = lhs->getAsBuiltinType(); 1416 const BuiltinType *rBuiltin = rhs->getAsBuiltinType(); 1417 1418 return lBuiltin->getKind() == rBuiltin->getKind(); 1419} 1420 1421/// objcTypesAreCompatible - This routine is called when two types 1422/// are of different class; one is interface type or is 1423/// a qualified interface type and the other type is of a different class. 1424/// Example, II or II<P>. 1425bool ASTContext::objcTypesAreCompatible(QualType LHS, QualType RHS) { 1426 // ID is compatible with all interface types. 1427 if (LHS->isObjCInterfaceType() && isObjCIdType(RHS)) 1428 return true; 1429 else if (isObjCIdType(LHS) && RHS->isObjCInterfaceType()) 1430 return true; 1431 1432 // II is compatible with II<P> if the base is the same. Otherwise, no two 1433 // qualified interface types are the same. 1434 if (const ObjCInterfaceType *LHSIT = LHS->getAsObjCInterfaceType()) { 1435 if (const ObjCInterfaceType *RHSIT = RHS->getAsObjCInterfaceType()) { 1436 // If the base decls match and one is a qualified interface and one isn't, 1437 // then they are compatible. 1438 return LHSIT->getDecl() == RHSIT->getDecl() && 1439 isa<ObjCQualifiedInterfaceType>(LHSIT) != 1440 isa<ObjCQualifiedInterfaceType>(RHSIT); 1441 } 1442 } 1443 return false; 1444} 1445 1446bool ASTContext::QualifiedInterfaceTypesAreCompatible(QualType lhs, 1447 QualType rhs) { 1448 const ObjCQualifiedInterfaceType *lhsQI = 1449 lhs->getAsObjCQualifiedInterfaceType(); 1450 const ObjCQualifiedInterfaceType *rhsQI = 1451 rhs->getAsObjCQualifiedInterfaceType(); 1452 assert(lhsQI && rhsQI && "QualifiedInterfaceTypesAreCompatible - bad type"); 1453 1454 // Verify that the base decls are compatible, the RHS must be a subclass of 1455 // the LHS. 1456 if (!lhsQI->getDecl()->isSuperClassOf(rhsQI->getDecl())) 1457 return false; 1458 1459 // All protocols in lhs must have a presence in rhs. 1460 for (unsigned i = 0; i != lhsQI->getNumProtocols(); ++i) { 1461 bool match = false; 1462 ObjCProtocolDecl *lhsProto = lhsQI->getProtocols(i); 1463 for (unsigned j = 0; j != rhsQI->getNumProtocols(); ++j) { 1464 ObjCProtocolDecl *rhsProto = rhsQI->getProtocols(j); 1465 if (lhsProto == rhsProto) { 1466 match = true; 1467 break; 1468 } 1469 } 1470 if (!match) 1471 return false; 1472 } 1473 return true; 1474} 1475 1476/// ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the 1477/// inheritance hierarchy of 'rProto'. 1478static bool ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto, 1479 ObjCProtocolDecl *rProto) { 1480 if (lProto == rProto) 1481 return true; 1482 ObjCProtocolDecl** RefPDecl = rProto->getReferencedProtocols(); 1483 for (unsigned i = 0; i < rProto->getNumReferencedProtocols(); i++) 1484 if (ProtocolCompatibleWithProtocol(lProto, RefPDecl[i])) 1485 return true; 1486 return false; 1487} 1488 1489/// ClassImplementsProtocol - Checks that 'lProto' protocol 1490/// has been implemented in IDecl class, its super class or categories (if 1491/// lookupCategory is true). 1492static bool ClassImplementsProtocol(ObjCProtocolDecl *lProto, 1493 ObjCInterfaceDecl *IDecl, 1494 bool lookupCategory) { 1495 1496 // 1st, look up the class. 1497 ObjCProtocolDecl **protoList = IDecl->getReferencedProtocols(); 1498 for (unsigned i = 0; i < IDecl->getNumIntfRefProtocols(); i++) { 1499 if (ProtocolCompatibleWithProtocol(lProto, protoList[i])) 1500 return true; 1501 } 1502 1503 // 2nd, look up the category. 1504 if (lookupCategory) 1505 for (ObjCCategoryDecl *CDecl = IDecl->getCategoryList(); CDecl; 1506 CDecl = CDecl->getNextClassCategory()) { 1507 protoList = CDecl->getReferencedProtocols(); 1508 for (unsigned i = 0; i < CDecl->getNumReferencedProtocols(); i++) { 1509 if (ProtocolCompatibleWithProtocol(lProto, protoList[i])) 1510 return true; 1511 } 1512 } 1513 1514 // 3rd, look up the super class(s) 1515 if (IDecl->getSuperClass()) 1516 return 1517 ClassImplementsProtocol(lProto, IDecl->getSuperClass(), lookupCategory); 1518 1519 return false; 1520} 1521 1522/// ObjCQualifiedIdTypesAreCompatible - Compares two types, at least 1523/// one of which is a protocol qualified 'id' type. When 'compare' 1524/// is true it is for comparison; when false, for assignment/initialization. 1525bool ASTContext::ObjCQualifiedIdTypesAreCompatible(QualType lhs, 1526 QualType rhs, 1527 bool compare) { 1528 // match id<P..> with an 'id' type in all cases. 1529 if (const PointerType *PT = lhs->getAsPointerType()) { 1530 QualType PointeeTy = PT->getPointeeType(); 1531 if (isObjCIdType(PointeeTy) || PointeeTy->isVoidType()) 1532 return true; 1533 1534 } 1535 else if (const PointerType *PT = rhs->getAsPointerType()) { 1536 QualType PointeeTy = PT->getPointeeType(); 1537 if (isObjCIdType(PointeeTy) || PointeeTy->isVoidType()) 1538 return true; 1539 1540 } 1541 1542 ObjCQualifiedInterfaceType *lhsQI = 0; 1543 ObjCQualifiedInterfaceType *rhsQI = 0; 1544 ObjCInterfaceDecl *lhsID = 0; 1545 ObjCInterfaceDecl *rhsID = 0; 1546 ObjCQualifiedIdType *lhsQID = dyn_cast<ObjCQualifiedIdType>(lhs); 1547 ObjCQualifiedIdType *rhsQID = dyn_cast<ObjCQualifiedIdType>(rhs); 1548 1549 if (lhsQID) { 1550 if (!rhsQID && rhs->getTypeClass() == Type::Pointer) { 1551 QualType rtype = 1552 cast<PointerType>(rhs.getCanonicalType())->getPointeeType(); 1553 rhsQI = 1554 dyn_cast<ObjCQualifiedInterfaceType>( 1555 rtype.getCanonicalType().getTypePtr()); 1556 if (!rhsQI) { 1557 ObjCInterfaceType *IT = dyn_cast<ObjCInterfaceType>( 1558 rtype.getCanonicalType().getTypePtr()); 1559 if (IT) 1560 rhsID = IT->getDecl(); 1561 } 1562 } 1563 if (!rhsQI && !rhsQID && !rhsID) 1564 return false; 1565 1566 unsigned numRhsProtocols = 0; 1567 ObjCProtocolDecl **rhsProtoList = 0; 1568 if (rhsQI) { 1569 numRhsProtocols = rhsQI->getNumProtocols(); 1570 rhsProtoList = rhsQI->getReferencedProtocols(); 1571 } 1572 else if (rhsQID) { 1573 numRhsProtocols = rhsQID->getNumProtocols(); 1574 rhsProtoList = rhsQID->getReferencedProtocols(); 1575 } 1576 1577 for (unsigned i =0; i < lhsQID->getNumProtocols(); i++) { 1578 ObjCProtocolDecl *lhsProto = lhsQID->getProtocols(i); 1579 bool match = false; 1580 1581 // when comparing an id<P> on lhs with a static type on rhs, 1582 // see if static class implements all of id's protocols, directly or 1583 // through its super class and categories. 1584 if (rhsID) { 1585 if (ClassImplementsProtocol(lhsProto, rhsID, true)) 1586 match = true; 1587 } 1588 else for (unsigned j = 0; j < numRhsProtocols; j++) { 1589 ObjCProtocolDecl *rhsProto = rhsProtoList[j]; 1590 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 1591 compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto)) { 1592 match = true; 1593 break; 1594 } 1595 } 1596 if (!match) 1597 return false; 1598 } 1599 } 1600 else if (rhsQID) { 1601 if (!lhsQID && lhs->getTypeClass() == Type::Pointer) { 1602 QualType ltype = 1603 cast<PointerType>(lhs.getCanonicalType())->getPointeeType(); 1604 lhsQI = 1605 dyn_cast<ObjCQualifiedInterfaceType>( 1606 ltype.getCanonicalType().getTypePtr()); 1607 if (!lhsQI) { 1608 ObjCInterfaceType *IT = dyn_cast<ObjCInterfaceType>( 1609 ltype.getCanonicalType().getTypePtr()); 1610 if (IT) 1611 lhsID = IT->getDecl(); 1612 } 1613 } 1614 if (!lhsQI && !lhsQID && !lhsID) 1615 return false; 1616 1617 unsigned numLhsProtocols = 0; 1618 ObjCProtocolDecl **lhsProtoList = 0; 1619 if (lhsQI) { 1620 numLhsProtocols = lhsQI->getNumProtocols(); 1621 lhsProtoList = lhsQI->getReferencedProtocols(); 1622 } 1623 else if (lhsQID) { 1624 numLhsProtocols = lhsQID->getNumProtocols(); 1625 lhsProtoList = lhsQID->getReferencedProtocols(); 1626 } 1627 bool match = false; 1628 // for static type vs. qualified 'id' type, check that class implements 1629 // one of 'id's protocols. 1630 if (lhsID) { 1631 for (unsigned j = 0; j < rhsQID->getNumProtocols(); j++) { 1632 ObjCProtocolDecl *rhsProto = rhsQID->getProtocols(j); 1633 if (ClassImplementsProtocol(rhsProto, lhsID, compare)) { 1634 match = true; 1635 break; 1636 } 1637 } 1638 } 1639 else for (unsigned i =0; i < numLhsProtocols; i++) { 1640 match = false; 1641 ObjCProtocolDecl *lhsProto = lhsProtoList[i]; 1642 for (unsigned j = 0; j < rhsQID->getNumProtocols(); j++) { 1643 ObjCProtocolDecl *rhsProto = rhsQID->getProtocols(j); 1644 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 1645 compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto)) { 1646 match = true; 1647 break; 1648 } 1649 } 1650 } 1651 if (!match) 1652 return false; 1653 } 1654 return true; 1655} 1656 1657bool ASTContext::vectorTypesAreCompatible(QualType lhs, QualType rhs) { 1658 const VectorType *lVector = lhs->getAsVectorType(); 1659 const VectorType *rVector = rhs->getAsVectorType(); 1660 1661 if ((lVector->getElementType().getCanonicalType() == 1662 rVector->getElementType().getCanonicalType()) && 1663 (lVector->getNumElements() == rVector->getNumElements())) 1664 return true; 1665 return false; 1666} 1667 1668// C99 6.2.7p1: If both are complete types, then the following additional 1669// requirements apply...FIXME (handle compatibility across source files). 1670bool ASTContext::tagTypesAreCompatible(QualType lhs, QualType rhs) { 1671 // "Class" and "id" are compatible built-in structure types. 1672 if (isObjCIdType(lhs) && isObjCClassType(rhs) || 1673 isObjCClassType(lhs) && isObjCIdType(rhs)) 1674 return true; 1675 1676 // Within a translation unit a tag type is 1677 // only compatible with itself. 1678 return lhs.getCanonicalType() == rhs.getCanonicalType(); 1679} 1680 1681bool ASTContext::pointerTypesAreCompatible(QualType lhs, QualType rhs) { 1682 // C99 6.7.5.1p2: For two pointer types to be compatible, both shall be 1683 // identically qualified and both shall be pointers to compatible types. 1684 if (lhs.getCVRQualifiers() != rhs.getCVRQualifiers() || 1685 lhs.getAddressSpace() != rhs.getAddressSpace()) 1686 return false; 1687 1688 QualType ltype = cast<PointerType>(lhs.getCanonicalType())->getPointeeType(); 1689 QualType rtype = cast<PointerType>(rhs.getCanonicalType())->getPointeeType(); 1690 1691 return typesAreCompatible(ltype, rtype); 1692} 1693 1694// C++ 5.17p6: When the left operand of an assignment operator denotes a 1695// reference to T, the operation assigns to the object of type T denoted by the 1696// reference. 1697bool ASTContext::referenceTypesAreCompatible(QualType lhs, QualType rhs) { 1698 QualType ltype = lhs; 1699 1700 if (lhs->isReferenceType()) 1701 ltype = cast<ReferenceType>(lhs.getCanonicalType())->getPointeeType(); 1702 1703 QualType rtype = rhs; 1704 1705 if (rhs->isReferenceType()) 1706 rtype = cast<ReferenceType>(rhs.getCanonicalType())->getPointeeType(); 1707 1708 return typesAreCompatible(ltype, rtype); 1709} 1710 1711bool ASTContext::functionTypesAreCompatible(QualType lhs, QualType rhs) { 1712 const FunctionType *lbase = cast<FunctionType>(lhs.getCanonicalType()); 1713 const FunctionType *rbase = cast<FunctionType>(rhs.getCanonicalType()); 1714 const FunctionTypeProto *lproto = dyn_cast<FunctionTypeProto>(lbase); 1715 const FunctionTypeProto *rproto = dyn_cast<FunctionTypeProto>(rbase); 1716 1717 // first check the return types (common between C99 and K&R). 1718 if (!typesAreCompatible(lbase->getResultType(), rbase->getResultType())) 1719 return false; 1720 1721 if (lproto && rproto) { // two C99 style function prototypes 1722 unsigned lproto_nargs = lproto->getNumArgs(); 1723 unsigned rproto_nargs = rproto->getNumArgs(); 1724 1725 if (lproto_nargs != rproto_nargs) 1726 return false; 1727 1728 // both prototypes have the same number of arguments. 1729 if ((lproto->isVariadic() && !rproto->isVariadic()) || 1730 (rproto->isVariadic() && !lproto->isVariadic())) 1731 return false; 1732 1733 // The use of ellipsis agree...now check the argument types. 1734 for (unsigned i = 0; i < lproto_nargs; i++) 1735 // C99 6.7.5.3p15: ...and each parameter declared with qualified type 1736 // is taken as having the unqualified version of it's declared type. 1737 if (!typesAreCompatible(lproto->getArgType(i).getUnqualifiedType(), 1738 rproto->getArgType(i).getUnqualifiedType())) 1739 return false; 1740 return true; 1741 } 1742 if (!lproto && !rproto) // two K&R style function decls, nothing to do. 1743 return true; 1744 1745 // we have a mixture of K&R style with C99 prototypes 1746 const FunctionTypeProto *proto = lproto ? lproto : rproto; 1747 1748 if (proto->isVariadic()) 1749 return false; 1750 1751 // FIXME: Each parameter type T in the prototype must be compatible with the 1752 // type resulting from applying the usual argument conversions to T. 1753 return true; 1754} 1755 1756bool ASTContext::arrayTypesAreCompatible(QualType lhs, QualType rhs) { 1757 // Compatible arrays must have compatible element types 1758 QualType ltype = lhs->getAsArrayType()->getElementType(); 1759 QualType rtype = rhs->getAsArrayType()->getElementType(); 1760 1761 if (!typesAreCompatible(ltype, rtype)) 1762 return false; 1763 1764 // Compatible arrays must be the same size 1765 if (const ConstantArrayType* LCAT = lhs->getAsConstantArrayType()) 1766 if (const ConstantArrayType* RCAT = rhs->getAsConstantArrayType()) 1767 return RCAT->getSize() == LCAT->getSize(); 1768 1769 return true; 1770} 1771 1772/// typesAreCompatible - C99 6.7.3p9: For two qualified types to be compatible, 1773/// both shall have the identically qualified version of a compatible type. 1774/// C99 6.2.7p1: Two types have compatible types if their types are the 1775/// same. See 6.7.[2,3,5] for additional rules. 1776bool ASTContext::typesAreCompatible(QualType LHS_NC, QualType RHS_NC) { 1777 QualType LHS = LHS_NC.getCanonicalType(); 1778 QualType RHS = RHS_NC.getCanonicalType(); 1779 1780 // If two types are identical, they are are compatible 1781 if (LHS == RHS) 1782 return true; 1783 1784 if (LHS.getCVRQualifiers() != RHS.getCVRQualifiers() || 1785 LHS.getAddressSpace() != RHS.getAddressSpace()) 1786 return false; 1787 1788 // C++ [expr]: If an expression initially has the type "reference to T", the 1789 // type is adjusted to "T" prior to any further analysis, the expression 1790 // designates the object or function denoted by the reference, and the 1791 // expression is an lvalue. 1792 if (ReferenceType *RT = dyn_cast<ReferenceType>(LHS)) 1793 LHS = RT->getPointeeType(); 1794 if (ReferenceType *RT = dyn_cast<ReferenceType>(RHS)) 1795 RHS = RT->getPointeeType(); 1796 1797 Type::TypeClass LHSClass = LHS->getTypeClass(); 1798 Type::TypeClass RHSClass = RHS->getTypeClass(); 1799 1800 // We want to consider the two function types to be the same for these 1801 // comparisons, just force one to the other. 1802 if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto; 1803 if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto; 1804 1805 // Same as above for arrays 1806 if (LHSClass == Type::VariableArray) LHSClass = Type::ConstantArray; 1807 if (RHSClass == Type::VariableArray) RHSClass = Type::ConstantArray; 1808 if (LHSClass == Type::IncompleteArray) LHSClass = Type::ConstantArray; 1809 if (RHSClass == Type::IncompleteArray) RHSClass = Type::ConstantArray; 1810 1811 // If the canonical type classes don't match... 1812 if (LHSClass != RHSClass) { 1813 // For Objective-C, it is possible for two types to be compatible 1814 // when their classes don't match (when dealing with "id"). If either type 1815 // is an interface, we defer to objcTypesAreCompatible(). 1816 if (LHS->isObjCInterfaceType() || RHS->isObjCInterfaceType()) 1817 return objcTypesAreCompatible(LHS, RHS); 1818 1819 // C99 6.7.2.2p4: Each enumerated type shall be compatible with char, 1820 // a signed integer type, or an unsigned integer type. 1821 if (LHS->isEnumeralType() && RHS->isIntegralType()) { 1822 EnumDecl* EDecl = cast<EnumType>(LHS)->getDecl(); 1823 return EDecl->getIntegerType() == RHS; 1824 } 1825 if (RHS->isEnumeralType() && LHS->isIntegralType()) { 1826 EnumDecl* EDecl = cast<EnumType>(RHS)->getDecl(); 1827 return EDecl->getIntegerType() == LHS; 1828 } 1829 1830 return false; 1831 } 1832 // The canonical type classes match. 1833 switch (LHSClass) { 1834 case Type::FunctionProto: assert(0 && "Canonicalized away above"); 1835 case Type::Pointer: 1836 return pointerTypesAreCompatible(LHS, RHS); 1837 case Type::ConstantArray: 1838 case Type::VariableArray: 1839 case Type::IncompleteArray: 1840 return arrayTypesAreCompatible(LHS, RHS); 1841 case Type::FunctionNoProto: 1842 return functionTypesAreCompatible(LHS, RHS); 1843 case Type::Tagged: // handle structures, unions 1844 return tagTypesAreCompatible(LHS, RHS); 1845 case Type::Builtin: 1846 return builtinTypesAreCompatible(LHS, RHS); 1847 case Type::ObjCInterface: 1848 // The LHS must be a superclass of the RHS. 1849 return cast<ObjCInterfaceType>(LHS)->getDecl()->isSuperClassOf( 1850 cast<ObjCInterfaceType>(RHS)->getDecl()); 1851 case Type::Vector: 1852 case Type::OCUVector: 1853 return vectorTypesAreCompatible(LHS, RHS); 1854 case Type::ObjCQualifiedInterface: 1855 return QualifiedInterfaceTypesAreCompatible(LHS, RHS); 1856 default: 1857 assert(0 && "unexpected type"); 1858 } 1859 return true; // should never get here... 1860} 1861 1862/// Emit - Serialize an ASTContext object to Bitcode. 1863void ASTContext::Emit(llvm::Serializer& S) const { 1864 S.EmitRef(SourceMgr); 1865 S.EmitRef(Target); 1866 S.EmitRef(Idents); 1867 S.EmitRef(Selectors); 1868 1869 // Emit the size of the type vector so that we can reserve that size 1870 // when we reconstitute the ASTContext object. 1871 S.EmitInt(Types.size()); 1872 1873 for (std::vector<Type*>::const_iterator I=Types.begin(), E=Types.end(); 1874 I!=E;++I) 1875 (*I)->Emit(S); 1876 1877 // FIXME: S.EmitOwnedPtr(CFConstantStringTypeDecl); 1878} 1879 1880ASTContext* ASTContext::Create(llvm::Deserializer& D) { 1881 SourceManager &SM = D.ReadRef<SourceManager>(); 1882 TargetInfo &t = D.ReadRef<TargetInfo>(); 1883 IdentifierTable &idents = D.ReadRef<IdentifierTable>(); 1884 SelectorTable &sels = D.ReadRef<SelectorTable>(); 1885 1886 unsigned size_reserve = D.ReadInt(); 1887 1888 ASTContext* A = new ASTContext(SM,t,idents,sels,size_reserve); 1889 1890 for (unsigned i = 0; i < size_reserve; ++i) 1891 Type::Create(*A,i,D); 1892 1893 // FIXME: A->CFConstantStringTypeDecl = D.ReadOwnedPtr<RecordDecl>(); 1894 1895 return A; 1896} 1897