ASTContext.cpp revision f62f9cd5a78e5445a02e37b277f7a2df9c19b7a3
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/// CmpProtocolNames - Comparison predicate for sorting protocols 815/// alphabetically. 816static bool CmpProtocolNames(const ObjCProtocolDecl *LHS, 817 const ObjCProtocolDecl *RHS) { 818 return strcmp(LHS->getName(), RHS->getName()) < 0; 819} 820 821static void SortAndUniqueProtocols(ObjCProtocolDecl **&Protocols, 822 unsigned &NumProtocols) { 823 ObjCProtocolDecl **ProtocolsEnd = Protocols+NumProtocols; 824 825 // Sort protocols, keyed by name. 826 std::sort(Protocols, Protocols+NumProtocols, CmpProtocolNames); 827 828 // Remove duplicates. 829 ProtocolsEnd = std::unique(Protocols, ProtocolsEnd); 830 NumProtocols = ProtocolsEnd-Protocols; 831} 832 833 834/// getObjCQualifiedInterfaceType - Return a ObjCQualifiedInterfaceType type for 835/// the given interface decl and the conforming protocol list. 836QualType ASTContext::getObjCQualifiedInterfaceType(ObjCInterfaceDecl *Decl, 837 ObjCProtocolDecl **Protocols, unsigned NumProtocols) { 838 // Sort the protocol list alphabetically to canonicalize it. 839 SortAndUniqueProtocols(Protocols, NumProtocols); 840 841 llvm::FoldingSetNodeID ID; 842 ObjCQualifiedInterfaceType::Profile(ID, Protocols, NumProtocols); 843 844 void *InsertPos = 0; 845 if (ObjCQualifiedInterfaceType *QT = 846 ObjCQualifiedInterfaceTypes.FindNodeOrInsertPos(ID, InsertPos)) 847 return QualType(QT, 0); 848 849 // No Match; 850 ObjCQualifiedInterfaceType *QType = 851 new ObjCQualifiedInterfaceType(Decl, Protocols, NumProtocols); 852 Types.push_back(QType); 853 ObjCQualifiedInterfaceTypes.InsertNode(QType, InsertPos); 854 return QualType(QType, 0); 855} 856 857/// getObjCQualifiedIdType - Return an ObjCQualifiedIdType for the 'id' decl 858/// and the conforming protocol list. 859QualType ASTContext::getObjCQualifiedIdType(QualType idType, 860 ObjCProtocolDecl **Protocols, 861 unsigned NumProtocols) { 862 // Sort the protocol list alphabetically to canonicalize it. 863 SortAndUniqueProtocols(Protocols, NumProtocols); 864 865 llvm::FoldingSetNodeID ID; 866 ObjCQualifiedIdType::Profile(ID, Protocols, NumProtocols); 867 868 void *InsertPos = 0; 869 if (ObjCQualifiedIdType *QT = 870 ObjCQualifiedIdTypes.FindNodeOrInsertPos(ID, InsertPos)) 871 return QualType(QT, 0); 872 873 // No Match; 874 QualType Canonical; 875 if (!idType->isCanonical()) { 876 Canonical = getObjCQualifiedIdType(getCanonicalType(idType), 877 Protocols, NumProtocols); 878 ObjCQualifiedIdType *NewQT = 879 ObjCQualifiedIdTypes.FindNodeOrInsertPos(ID, InsertPos); 880 assert(NewQT == 0 && "Shouldn't be in the map!"); 881 } 882 883 ObjCQualifiedIdType *QType = 884 new ObjCQualifiedIdType(Canonical, Protocols, NumProtocols); 885 Types.push_back(QType); 886 ObjCQualifiedIdTypes.InsertNode(QType, InsertPos); 887 return QualType(QType, 0); 888} 889 890/// getTypeOfExpr - Unlike many "get<Type>" functions, we can't unique 891/// TypeOfExpr AST's (since expression's are never shared). For example, 892/// multiple declarations that refer to "typeof(x)" all contain different 893/// DeclRefExpr's. This doesn't effect the type checker, since it operates 894/// on canonical type's (which are always unique). 895QualType ASTContext::getTypeOfExpr(Expr *tofExpr) { 896 QualType Canonical = getCanonicalType(tofExpr->getType()); 897 TypeOfExpr *toe = new TypeOfExpr(tofExpr, Canonical); 898 Types.push_back(toe); 899 return QualType(toe, 0); 900} 901 902/// getTypeOfType - Unlike many "get<Type>" functions, we don't unique 903/// TypeOfType AST's. The only motivation to unique these nodes would be 904/// memory savings. Since typeof(t) is fairly uncommon, space shouldn't be 905/// an issue. This doesn't effect the type checker, since it operates 906/// on canonical type's (which are always unique). 907QualType ASTContext::getTypeOfType(QualType tofType) { 908 QualType Canonical = getCanonicalType(tofType); 909 TypeOfType *tot = new TypeOfType(tofType, Canonical); 910 Types.push_back(tot); 911 return QualType(tot, 0); 912} 913 914/// getTagDeclType - Return the unique reference to the type for the 915/// specified TagDecl (struct/union/class/enum) decl. 916QualType ASTContext::getTagDeclType(TagDecl *Decl) { 917 assert (Decl); 918 919 // The decl stores the type cache. 920 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 921 922 TagType* T = new TagType(Decl, QualType()); 923 Types.push_back(T); 924 Decl->TypeForDecl = T; 925 926 return QualType(T, 0); 927} 928 929/// getSizeType - Return the unique type for "size_t" (C99 7.17), the result 930/// of the sizeof operator (C99 6.5.3.4p4). The value is target dependent and 931/// needs to agree with the definition in <stddef.h>. 932QualType ASTContext::getSizeType() const { 933 // On Darwin, size_t is defined as a "long unsigned int". 934 // FIXME: should derive from "Target". 935 return UnsignedLongTy; 936} 937 938/// getWcharType - Return the unique type for "wchar_t" (C99 7.17), the 939/// width of characters in wide strings, The value is target dependent and 940/// needs to agree with the definition in <stddef.h>. 941QualType ASTContext::getWcharType() const { 942 // On Darwin, wchar_t is defined as a "int". 943 // FIXME: should derive from "Target". 944 return IntTy; 945} 946 947/// getPointerDiffType - Return the unique type for "ptrdiff_t" (ref?) 948/// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9). 949QualType ASTContext::getPointerDiffType() const { 950 // On Darwin, ptrdiff_t is defined as a "int". This seems like a bug... 951 // FIXME: should derive from "Target". 952 return IntTy; 953} 954 955//===----------------------------------------------------------------------===// 956// Type Operators 957//===----------------------------------------------------------------------===// 958 959/// getCanonicalType - Return the canonical (structural) type corresponding to 960/// the specified potentially non-canonical type. The non-canonical version 961/// of a type may have many "decorated" versions of types. Decorators can 962/// include typedefs, 'typeof' operators, etc. The returned type is guaranteed 963/// to be free of any of these, allowing two canonical types to be compared 964/// for exact equality with a simple pointer comparison. 965QualType ASTContext::getCanonicalType(QualType T) { 966 QualType CanType = T.getTypePtr()->getCanonicalTypeInternal(); 967 return QualType(CanType.getTypePtr(), 968 T.getCVRQualifiers() | CanType.getCVRQualifiers()); 969} 970 971 972/// getArrayDecayedType - Return the properly qualified result of decaying the 973/// specified array type to a pointer. This operation is non-trivial when 974/// handling typedefs etc. The canonical type of "T" must be an array type, 975/// this returns a pointer to a properly qualified element of the array. 976/// 977/// See C99 6.7.5.3p7 and C99 6.3.2.1p3. 978QualType ASTContext::getArrayDecayedType(QualType Ty) { 979 // Handle the common case where typedefs are not involved directly. 980 QualType EltTy; 981 unsigned ArrayQuals = 0; 982 unsigned PointerQuals = 0; 983 if (ArrayType *AT = dyn_cast<ArrayType>(Ty)) { 984 // Since T "isa" an array type, it could not have had an address space 985 // qualifier, just CVR qualifiers. The properly qualified element pointer 986 // gets the union of the CVR qualifiers from the element and the array, and 987 // keeps any address space qualifier on the element type if present. 988 EltTy = AT->getElementType(); 989 ArrayQuals = Ty.getCVRQualifiers(); 990 PointerQuals = AT->getIndexTypeQualifier(); 991 } else { 992 // Otherwise, we have an ASQualType or a typedef, etc. Make sure we don't 993 // lose qualifiers when dealing with typedefs. Example: 994 // typedef int arr[10]; 995 // void test2() { 996 // const arr b; 997 // b[4] = 1; 998 // } 999 // 1000 // The decayed type of b is "const int*" even though the element type of the 1001 // array is "int". 1002 QualType CanTy = getCanonicalType(Ty); 1003 const ArrayType *PrettyArrayType = Ty->getAsArrayType(); 1004 assert(PrettyArrayType && "Not an array type!"); 1005 1006 // Get the element type with 'getAsArrayType' so that we don't lose any 1007 // typedefs in the element type of the array. 1008 EltTy = PrettyArrayType->getElementType(); 1009 1010 // If the array was address-space qualifier, make sure to ASQual the element 1011 // type. We can just grab the address space from the canonical type. 1012 if (unsigned AS = CanTy.getAddressSpace()) 1013 EltTy = getASQualType(EltTy, AS); 1014 1015 // To properly handle [multiple levels of] typedefs, typeof's etc, we take 1016 // the CVR qualifiers directly from the canonical type, which is guaranteed 1017 // to have the full set unioned together. 1018 ArrayQuals = CanTy.getCVRQualifiers(); 1019 PointerQuals = PrettyArrayType->getIndexTypeQualifier(); 1020 } 1021 1022 // Apply any CVR qualifiers from the array type to the element type. This 1023 // implements C99 6.7.3p8: "If the specification of an array type includes 1024 // any type qualifiers, the element type is so qualified, not the array type." 1025 EltTy = EltTy.getQualifiedType(ArrayQuals | EltTy.getCVRQualifiers()); 1026 1027 QualType PtrTy = getPointerType(EltTy); 1028 1029 // int x[restrict 4] -> int *restrict 1030 PtrTy = PtrTy.getQualifiedType(PointerQuals); 1031 1032 return PtrTy; 1033} 1034 1035/// getFloatingRank - Return a relative rank for floating point types. 1036/// This routine will assert if passed a built-in type that isn't a float. 1037static FloatingRank getFloatingRank(QualType T) { 1038 if (const ComplexType *CT = T->getAsComplexType()) 1039 return getFloatingRank(CT->getElementType()); 1040 1041 switch (T->getAsBuiltinType()->getKind()) { 1042 default: assert(0 && "getFloatingRank(): not a floating type"); 1043 case BuiltinType::Float: return FloatRank; 1044 case BuiltinType::Double: return DoubleRank; 1045 case BuiltinType::LongDouble: return LongDoubleRank; 1046 } 1047} 1048 1049/// getFloatingTypeOfSizeWithinDomain - Returns a real floating 1050/// point or a complex type (based on typeDomain/typeSize). 1051/// 'typeDomain' is a real floating point or complex type. 1052/// 'typeSize' is a real floating point or complex type. 1053QualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size, 1054 QualType Domain) const { 1055 FloatingRank EltRank = getFloatingRank(Size); 1056 if (Domain->isComplexType()) { 1057 switch (EltRank) { 1058 default: assert(0 && "getFloatingRank(): illegal value for rank"); 1059 case FloatRank: return FloatComplexTy; 1060 case DoubleRank: return DoubleComplexTy; 1061 case LongDoubleRank: return LongDoubleComplexTy; 1062 } 1063 } 1064 1065 assert(Domain->isRealFloatingType() && "Unknown domain!"); 1066 switch (EltRank) { 1067 default: assert(0 && "getFloatingRank(): illegal value for rank"); 1068 case FloatRank: return FloatTy; 1069 case DoubleRank: return DoubleTy; 1070 case LongDoubleRank: return LongDoubleTy; 1071 } 1072} 1073 1074/// getFloatingTypeOrder - Compare the rank of the two specified floating 1075/// point types, ignoring the domain of the type (i.e. 'double' == 1076/// '_Complex double'). If LHS > RHS, return 1. If LHS == RHS, return 0. If 1077/// LHS < RHS, return -1. 1078int ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) { 1079 FloatingRank LHSR = getFloatingRank(LHS); 1080 FloatingRank RHSR = getFloatingRank(RHS); 1081 1082 if (LHSR == RHSR) 1083 return 0; 1084 if (LHSR > RHSR) 1085 return 1; 1086 return -1; 1087} 1088 1089/// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This 1090/// routine will assert if passed a built-in type that isn't an integer or enum, 1091/// or if it is not canonicalized. 1092static unsigned getIntegerRank(Type *T) { 1093 assert(T->isCanonical() && "T should be canonicalized"); 1094 if (isa<EnumType>(T)) 1095 return 4; 1096 1097 switch (cast<BuiltinType>(T)->getKind()) { 1098 default: assert(0 && "getIntegerRank(): not a built-in integer"); 1099 case BuiltinType::Bool: 1100 return 1; 1101 case BuiltinType::Char_S: 1102 case BuiltinType::Char_U: 1103 case BuiltinType::SChar: 1104 case BuiltinType::UChar: 1105 return 2; 1106 case BuiltinType::Short: 1107 case BuiltinType::UShort: 1108 return 3; 1109 case BuiltinType::Int: 1110 case BuiltinType::UInt: 1111 return 4; 1112 case BuiltinType::Long: 1113 case BuiltinType::ULong: 1114 return 5; 1115 case BuiltinType::LongLong: 1116 case BuiltinType::ULongLong: 1117 return 6; 1118 } 1119} 1120 1121/// getIntegerTypeOrder - Returns the highest ranked integer type: 1122/// C99 6.3.1.8p1. If LHS > RHS, return 1. If LHS == RHS, return 0. If 1123/// LHS < RHS, return -1. 1124int ASTContext::getIntegerTypeOrder(QualType LHS, QualType RHS) { 1125 Type *LHSC = getCanonicalType(LHS).getTypePtr(); 1126 Type *RHSC = getCanonicalType(RHS).getTypePtr(); 1127 if (LHSC == RHSC) return 0; 1128 1129 bool LHSUnsigned = LHSC->isUnsignedIntegerType(); 1130 bool RHSUnsigned = RHSC->isUnsignedIntegerType(); 1131 1132 unsigned LHSRank = getIntegerRank(LHSC); 1133 unsigned RHSRank = getIntegerRank(RHSC); 1134 1135 if (LHSUnsigned == RHSUnsigned) { // Both signed or both unsigned. 1136 if (LHSRank == RHSRank) return 0; 1137 return LHSRank > RHSRank ? 1 : -1; 1138 } 1139 1140 // Otherwise, the LHS is signed and the RHS is unsigned or visa versa. 1141 if (LHSUnsigned) { 1142 // If the unsigned [LHS] type is larger, return it. 1143 if (LHSRank >= RHSRank) 1144 return 1; 1145 1146 // If the signed type can represent all values of the unsigned type, it 1147 // wins. Because we are dealing with 2's complement and types that are 1148 // powers of two larger than each other, this is always safe. 1149 return -1; 1150 } 1151 1152 // If the unsigned [RHS] type is larger, return it. 1153 if (RHSRank >= LHSRank) 1154 return -1; 1155 1156 // If the signed type can represent all values of the unsigned type, it 1157 // wins. Because we are dealing with 2's complement and types that are 1158 // powers of two larger than each other, this is always safe. 1159 return 1; 1160} 1161 1162// getCFConstantStringType - Return the type used for constant CFStrings. 1163QualType ASTContext::getCFConstantStringType() { 1164 if (!CFConstantStringTypeDecl) { 1165 CFConstantStringTypeDecl = 1166 RecordDecl::Create(*this, Decl::Struct, NULL, SourceLocation(), 1167 &Idents.get("NSConstantString"), 0); 1168 QualType FieldTypes[4]; 1169 1170 // const int *isa; 1171 FieldTypes[0] = getPointerType(IntTy.getQualifiedType(QualType::Const)); 1172 // int flags; 1173 FieldTypes[1] = IntTy; 1174 // const char *str; 1175 FieldTypes[2] = getPointerType(CharTy.getQualifiedType(QualType::Const)); 1176 // long length; 1177 FieldTypes[3] = LongTy; 1178 // Create fields 1179 FieldDecl *FieldDecls[4]; 1180 1181 for (unsigned i = 0; i < 4; ++i) 1182 FieldDecls[i] = FieldDecl::Create(*this, SourceLocation(), 0, 1183 FieldTypes[i]); 1184 1185 CFConstantStringTypeDecl->defineBody(FieldDecls, 4); 1186 } 1187 1188 return getTagDeclType(CFConstantStringTypeDecl); 1189} 1190 1191// This returns true if a type has been typedefed to BOOL: 1192// typedef <type> BOOL; 1193static bool isTypeTypedefedAsBOOL(QualType T) { 1194 if (const TypedefType *TT = dyn_cast<TypedefType>(T)) 1195 return !strcmp(TT->getDecl()->getName(), "BOOL"); 1196 1197 return false; 1198} 1199 1200/// getObjCEncodingTypeSize returns size of type for objective-c encoding 1201/// purpose. 1202int ASTContext::getObjCEncodingTypeSize(QualType type) { 1203 uint64_t sz = getTypeSize(type); 1204 1205 // Make all integer and enum types at least as large as an int 1206 if (sz > 0 && type->isIntegralType()) 1207 sz = std::max(sz, getTypeSize(IntTy)); 1208 // Treat arrays as pointers, since that's how they're passed in. 1209 else if (type->isArrayType()) 1210 sz = getTypeSize(VoidPtrTy); 1211 return sz / getTypeSize(CharTy); 1212} 1213 1214/// getObjCEncodingForMethodDecl - Return the encoded type for this method 1215/// declaration. 1216void ASTContext::getObjCEncodingForMethodDecl(ObjCMethodDecl *Decl, 1217 std::string& S) 1218{ 1219 // Encode type qualifer, 'in', 'inout', etc. for the return type. 1220 getObjCEncodingForTypeQualifier(Decl->getObjCDeclQualifier(), S); 1221 // Encode result type. 1222 getObjCEncodingForType(Decl->getResultType(), S, EncodingRecordTypes); 1223 // Compute size of all parameters. 1224 // Start with computing size of a pointer in number of bytes. 1225 // FIXME: There might(should) be a better way of doing this computation! 1226 SourceLocation Loc; 1227 int PtrSize = getTypeSize(VoidPtrTy) / getTypeSize(CharTy); 1228 // The first two arguments (self and _cmd) are pointers; account for 1229 // their size. 1230 int ParmOffset = 2 * PtrSize; 1231 int NumOfParams = Decl->getNumParams(); 1232 for (int i = 0; i < NumOfParams; i++) { 1233 QualType PType = Decl->getParamDecl(i)->getType(); 1234 int sz = getObjCEncodingTypeSize (PType); 1235 assert (sz > 0 && "getObjCEncodingForMethodDecl - Incomplete param type"); 1236 ParmOffset += sz; 1237 } 1238 S += llvm::utostr(ParmOffset); 1239 S += "@0:"; 1240 S += llvm::utostr(PtrSize); 1241 1242 // Argument types. 1243 ParmOffset = 2 * PtrSize; 1244 for (int i = 0; i < NumOfParams; i++) { 1245 QualType PType = Decl->getParamDecl(i)->getType(); 1246 // Process argument qualifiers for user supplied arguments; such as, 1247 // 'in', 'inout', etc. 1248 getObjCEncodingForTypeQualifier( 1249 Decl->getParamDecl(i)->getObjCDeclQualifier(), S); 1250 getObjCEncodingForType(PType, S, EncodingRecordTypes); 1251 S += llvm::utostr(ParmOffset); 1252 ParmOffset += getObjCEncodingTypeSize(PType); 1253 } 1254} 1255 1256void ASTContext::getObjCEncodingForType(QualType T, std::string& S, 1257 llvm::SmallVector<const RecordType *, 8> &ERType) const 1258{ 1259 // FIXME: This currently doesn't encode: 1260 // @ An object (whether statically typed or typed id) 1261 // # A class object (Class) 1262 // : A method selector (SEL) 1263 // {name=type...} A structure 1264 // (name=type...) A union 1265 // bnum A bit field of num bits 1266 1267 if (const BuiltinType *BT = T->getAsBuiltinType()) { 1268 char encoding; 1269 switch (BT->getKind()) { 1270 default: assert(0 && "Unhandled builtin type kind"); 1271 case BuiltinType::Void: encoding = 'v'; break; 1272 case BuiltinType::Bool: encoding = 'B'; break; 1273 case BuiltinType::Char_U: 1274 case BuiltinType::UChar: encoding = 'C'; break; 1275 case BuiltinType::UShort: encoding = 'S'; break; 1276 case BuiltinType::UInt: encoding = 'I'; break; 1277 case BuiltinType::ULong: encoding = 'L'; break; 1278 case BuiltinType::ULongLong: encoding = 'Q'; break; 1279 case BuiltinType::Char_S: 1280 case BuiltinType::SChar: encoding = 'c'; break; 1281 case BuiltinType::Short: encoding = 's'; break; 1282 case BuiltinType::Int: encoding = 'i'; break; 1283 case BuiltinType::Long: encoding = 'l'; break; 1284 case BuiltinType::LongLong: encoding = 'q'; break; 1285 case BuiltinType::Float: encoding = 'f'; break; 1286 case BuiltinType::Double: encoding = 'd'; break; 1287 case BuiltinType::LongDouble: encoding = 'd'; break; 1288 } 1289 1290 S += encoding; 1291 } 1292 else if (T->isObjCQualifiedIdType()) { 1293 // Treat id<P...> same as 'id' for encoding purposes. 1294 return getObjCEncodingForType(getObjCIdType(), S, ERType); 1295 1296 } 1297 else if (const PointerType *PT = T->getAsPointerType()) { 1298 QualType PointeeTy = PT->getPointeeType(); 1299 if (isObjCIdType(PointeeTy) || PointeeTy->isObjCInterfaceType()) { 1300 S += '@'; 1301 return; 1302 } else if (isObjCClassType(PointeeTy)) { 1303 S += '#'; 1304 return; 1305 } else if (isObjCSelType(PointeeTy)) { 1306 S += ':'; 1307 return; 1308 } 1309 1310 if (PointeeTy->isCharType()) { 1311 // char pointer types should be encoded as '*' unless it is a 1312 // type that has been typedef'd to 'BOOL'. 1313 if (!isTypeTypedefedAsBOOL(PointeeTy)) { 1314 S += '*'; 1315 return; 1316 } 1317 } 1318 1319 S += '^'; 1320 getObjCEncodingForType(PT->getPointeeType(), S, ERType); 1321 } else if (const ArrayType *AT = T->getAsArrayType()) { 1322 S += '['; 1323 1324 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) 1325 S += llvm::utostr(CAT->getSize().getZExtValue()); 1326 else 1327 assert(0 && "Unhandled array type!"); 1328 1329 getObjCEncodingForType(AT->getElementType(), S, ERType); 1330 S += ']'; 1331 } else if (T->getAsFunctionType()) { 1332 S += '?'; 1333 } else if (const RecordType *RTy = T->getAsRecordType()) { 1334 RecordDecl *RDecl= RTy->getDecl(); 1335 S += '{'; 1336 S += RDecl->getName(); 1337 bool found = false; 1338 for (unsigned i = 0, e = ERType.size(); i != e; ++i) 1339 if (ERType[i] == RTy) { 1340 found = true; 1341 break; 1342 } 1343 if (!found) { 1344 ERType.push_back(RTy); 1345 S += '='; 1346 for (int i = 0; i < RDecl->getNumMembers(); i++) { 1347 FieldDecl *field = RDecl->getMember(i); 1348 getObjCEncodingForType(field->getType(), S, ERType); 1349 } 1350 assert(ERType.back() == RTy && "Record Type stack mismatch."); 1351 ERType.pop_back(); 1352 } 1353 S += '}'; 1354 } else if (T->isEnumeralType()) { 1355 S += 'i'; 1356 } else 1357 assert(0 && "@encode for type not implemented!"); 1358} 1359 1360void ASTContext::getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT, 1361 std::string& S) const { 1362 if (QT & Decl::OBJC_TQ_In) 1363 S += 'n'; 1364 if (QT & Decl::OBJC_TQ_Inout) 1365 S += 'N'; 1366 if (QT & Decl::OBJC_TQ_Out) 1367 S += 'o'; 1368 if (QT & Decl::OBJC_TQ_Bycopy) 1369 S += 'O'; 1370 if (QT & Decl::OBJC_TQ_Byref) 1371 S += 'R'; 1372 if (QT & Decl::OBJC_TQ_Oneway) 1373 S += 'V'; 1374} 1375 1376void ASTContext::setBuiltinVaListType(QualType T) 1377{ 1378 assert(BuiltinVaListType.isNull() && "__builtin_va_list type already set!"); 1379 1380 BuiltinVaListType = T; 1381} 1382 1383void ASTContext::setObjCIdType(TypedefDecl *TD) 1384{ 1385 assert(ObjCIdType.isNull() && "'id' type already set!"); 1386 1387 ObjCIdType = getTypedefType(TD); 1388 1389 // typedef struct objc_object *id; 1390 const PointerType *ptr = TD->getUnderlyingType()->getAsPointerType(); 1391 assert(ptr && "'id' incorrectly typed"); 1392 const RecordType *rec = ptr->getPointeeType()->getAsStructureType(); 1393 assert(rec && "'id' incorrectly typed"); 1394 IdStructType = rec; 1395} 1396 1397void ASTContext::setObjCSelType(TypedefDecl *TD) 1398{ 1399 assert(ObjCSelType.isNull() && "'SEL' type already set!"); 1400 1401 ObjCSelType = getTypedefType(TD); 1402 1403 // typedef struct objc_selector *SEL; 1404 const PointerType *ptr = TD->getUnderlyingType()->getAsPointerType(); 1405 assert(ptr && "'SEL' incorrectly typed"); 1406 const RecordType *rec = ptr->getPointeeType()->getAsStructureType(); 1407 assert(rec && "'SEL' incorrectly typed"); 1408 SelStructType = rec; 1409} 1410 1411void ASTContext::setObjCProtoType(QualType QT) 1412{ 1413 assert(ObjCProtoType.isNull() && "'Protocol' type already set!"); 1414 ObjCProtoType = QT; 1415} 1416 1417void ASTContext::setObjCClassType(TypedefDecl *TD) 1418{ 1419 assert(ObjCClassType.isNull() && "'Class' type already set!"); 1420 1421 ObjCClassType = getTypedefType(TD); 1422 1423 // typedef struct objc_class *Class; 1424 const PointerType *ptr = TD->getUnderlyingType()->getAsPointerType(); 1425 assert(ptr && "'Class' incorrectly typed"); 1426 const RecordType *rec = ptr->getPointeeType()->getAsStructureType(); 1427 assert(rec && "'Class' incorrectly typed"); 1428 ClassStructType = rec; 1429} 1430 1431void ASTContext::setObjCConstantStringInterface(ObjCInterfaceDecl *Decl) { 1432 assert(ObjCConstantStringType.isNull() && 1433 "'NSConstantString' type already set!"); 1434 1435 ObjCConstantStringType = getObjCInterfaceType(Decl); 1436} 1437 1438bool ASTContext::builtinTypesAreCompatible(QualType lhs, QualType rhs) { 1439 const BuiltinType *lBuiltin = lhs->getAsBuiltinType(); 1440 const BuiltinType *rBuiltin = rhs->getAsBuiltinType(); 1441 1442 return lBuiltin->getKind() == rBuiltin->getKind(); 1443} 1444 1445/// objcTypesAreCompatible - This routine is called when two types 1446/// are of different class; one is interface type or is 1447/// a qualified interface type and the other type is of a different class. 1448/// Example, II or II<P>. 1449bool ASTContext::objcTypesAreCompatible(QualType LHS, QualType RHS) { 1450 // ID is compatible with all interface types. 1451 if (LHS->isObjCInterfaceType() && isObjCIdType(RHS)) 1452 return true; 1453 else if (isObjCIdType(LHS) && RHS->isObjCInterfaceType()) 1454 return true; 1455 1456 // II is compatible with II<P> if the base is the same. Otherwise, no two 1457 // qualified interface types are the same. 1458 if (const ObjCInterfaceType *LHSIT = LHS->getAsObjCInterfaceType()) { 1459 if (const ObjCInterfaceType *RHSIT = RHS->getAsObjCInterfaceType()) { 1460 // If the base decls match and one is a qualified interface and one isn't, 1461 // then they are compatible. 1462 return LHSIT->getDecl() == RHSIT->getDecl() && 1463 isa<ObjCQualifiedInterfaceType>(LHSIT) != 1464 isa<ObjCQualifiedInterfaceType>(RHSIT); 1465 } 1466 } 1467 return false; 1468} 1469 1470/// areCompatObjCQualInterfaces - Return true if the two qualified interface 1471/// types are compatible for assignment from RHS to LHS. 1472/// 1473static bool 1474areCompatObjCQualInterfaces(const ObjCQualifiedInterfaceType *LHS, 1475 const ObjCQualifiedInterfaceType *RHS) { 1476 // Verify that the base decls are compatible: the RHS must be a subclass of 1477 // the LHS. 1478 if (!LHS->getDecl()->isSuperClassOf(RHS->getDecl())) 1479 return false; 1480 1481 // All protocols in LHS must have a presence in RHS. Since the protocol lists 1482 // are both sorted alphabetically and have no duplicates, we can scan RHS and 1483 // LHS in a single parallel scan until we run out of elements in LHS. 1484 ObjCQualifiedInterfaceType::qual_iterator LHSPI = LHS->qual_begin(); 1485 ObjCQualifiedInterfaceType::qual_iterator LHSPE = LHS->qual_end(); 1486 ObjCQualifiedInterfaceType::qual_iterator RHSPI = RHS->qual_begin(); 1487 ObjCQualifiedInterfaceType::qual_iterator RHSPE = RHS->qual_end(); 1488 1489 assert(LHSPI != LHSPE && "Empty LHS protocol list?"); 1490 ObjCProtocolDecl *LHSProto = *LHSPI; 1491 1492 while (RHSPI != RHSPE) { 1493 ObjCProtocolDecl *RHSProto = *RHSPI++; 1494 // If the RHS has a protocol that the LHS doesn't, ignore it. 1495 if (RHSProto != LHSProto) 1496 continue; 1497 1498 // Otherwise, the RHS does have this element. 1499 ++LHSPI; 1500 if (LHSPI == LHSPE) 1501 return true; // All protocols in LHS exist in RHS. 1502 1503 LHSProto = *LHSPI; 1504 } 1505 1506 // If we got here, we didn't find one of the LHS's protocols in the RHS list. 1507 return false; 1508} 1509 1510/// areCompatVectorTypes - Return true if the two specified vector types are 1511/// compatible. 1512static bool areCompatVectorTypes(const VectorType *LHS, 1513 const VectorType *RHS) { 1514 assert(LHS->isCanonical() && RHS->isCanonical()); 1515 return LHS->getElementType() == RHS->getElementType() && 1516 LHS->getNumElements() == RHS->getNumElements(); 1517} 1518 1519// C99 6.2.7p1: If both are complete types, then the following additional 1520// requirements apply...FIXME (handle compatibility across source files). 1521bool ASTContext::tagTypesAreCompatible(QualType lhs, QualType rhs) { 1522 // "Class" and "id" are compatible built-in structure types. 1523 if (isObjCIdType(lhs) && isObjCClassType(rhs) || 1524 isObjCClassType(lhs) && isObjCIdType(rhs)) 1525 return true; 1526 1527 // Within a translation unit a tag type is 1528 // only compatible with itself. 1529 return lhs.getCanonicalType() == rhs.getCanonicalType(); 1530} 1531 1532bool ASTContext::pointerTypesAreCompatible(QualType lhs, QualType rhs) { 1533 // C99 6.7.5.1p2: For two pointer types to be compatible, both shall be 1534 // identically qualified and both shall be pointers to compatible types. 1535 if (lhs.getCVRQualifiers() != rhs.getCVRQualifiers() || 1536 lhs.getAddressSpace() != rhs.getAddressSpace()) 1537 return false; 1538 1539 QualType ltype = cast<PointerType>(lhs.getCanonicalType())->getPointeeType(); 1540 QualType rtype = cast<PointerType>(rhs.getCanonicalType())->getPointeeType(); 1541 1542 return typesAreCompatible(ltype, rtype); 1543} 1544 1545// C++ 5.17p6: When the left operand of an assignment operator denotes a 1546// reference to T, the operation assigns to the object of type T denoted by the 1547// reference. 1548bool ASTContext::referenceTypesAreCompatible(QualType lhs, QualType rhs) { 1549 QualType ltype = lhs; 1550 1551 if (lhs->isReferenceType()) 1552 ltype = cast<ReferenceType>(lhs.getCanonicalType())->getPointeeType(); 1553 1554 QualType rtype = rhs; 1555 1556 if (rhs->isReferenceType()) 1557 rtype = cast<ReferenceType>(rhs.getCanonicalType())->getPointeeType(); 1558 1559 return typesAreCompatible(ltype, rtype); 1560} 1561 1562bool ASTContext::functionTypesAreCompatible(QualType lhs, QualType rhs) { 1563 const FunctionType *lbase = cast<FunctionType>(lhs.getCanonicalType()); 1564 const FunctionType *rbase = cast<FunctionType>(rhs.getCanonicalType()); 1565 const FunctionTypeProto *lproto = dyn_cast<FunctionTypeProto>(lbase); 1566 const FunctionTypeProto *rproto = dyn_cast<FunctionTypeProto>(rbase); 1567 1568 // first check the return types (common between C99 and K&R). 1569 if (!typesAreCompatible(lbase->getResultType(), rbase->getResultType())) 1570 return false; 1571 1572 if (lproto && rproto) { // two C99 style function prototypes 1573 unsigned lproto_nargs = lproto->getNumArgs(); 1574 unsigned rproto_nargs = rproto->getNumArgs(); 1575 1576 if (lproto_nargs != rproto_nargs) 1577 return false; 1578 1579 // both prototypes have the same number of arguments. 1580 if ((lproto->isVariadic() && !rproto->isVariadic()) || 1581 (rproto->isVariadic() && !lproto->isVariadic())) 1582 return false; 1583 1584 // The use of ellipsis agree...now check the argument types. 1585 for (unsigned i = 0; i < lproto_nargs; i++) 1586 // C99 6.7.5.3p15: ...and each parameter declared with qualified type 1587 // is taken as having the unqualified version of it's declared type. 1588 if (!typesAreCompatible(lproto->getArgType(i).getUnqualifiedType(), 1589 rproto->getArgType(i).getUnqualifiedType())) 1590 return false; 1591 return true; 1592 } 1593 if (!lproto && !rproto) // two K&R style function decls, nothing to do. 1594 return true; 1595 1596 // we have a mixture of K&R style with C99 prototypes 1597 const FunctionTypeProto *proto = lproto ? lproto : rproto; 1598 1599 if (proto->isVariadic()) 1600 return false; 1601 1602 // FIXME: Each parameter type T in the prototype must be compatible with the 1603 // type resulting from applying the usual argument conversions to T. 1604 return true; 1605} 1606 1607bool ASTContext::arrayTypesAreCompatible(QualType lhs, QualType rhs) { 1608 // Compatible arrays must have compatible element types 1609 QualType ltype = lhs->getAsArrayType()->getElementType(); 1610 QualType rtype = rhs->getAsArrayType()->getElementType(); 1611 1612 if (!typesAreCompatible(ltype, rtype)) 1613 return false; 1614 1615 // Compatible arrays must be the same size 1616 if (const ConstantArrayType* LCAT = lhs->getAsConstantArrayType()) 1617 if (const ConstantArrayType* RCAT = rhs->getAsConstantArrayType()) 1618 return RCAT->getSize() == LCAT->getSize(); 1619 1620 return true; 1621} 1622 1623/// typesAreCompatible - C99 6.7.3p9: For two qualified types to be compatible, 1624/// both shall have the identically qualified version of a compatible type. 1625/// C99 6.2.7p1: Two types have compatible types if their types are the 1626/// same. See 6.7.[2,3,5] for additional rules. 1627bool ASTContext::typesAreCompatible(QualType LHS_NC, QualType RHS_NC) { 1628 QualType LHS = LHS_NC.getCanonicalType(); 1629 QualType RHS = RHS_NC.getCanonicalType(); 1630 1631 // If two types are identical, they are are compatible 1632 if (LHS == RHS) 1633 return true; 1634 1635 if (LHS.getCVRQualifiers() != RHS.getCVRQualifiers() || 1636 LHS.getAddressSpace() != RHS.getAddressSpace()) 1637 return false; 1638 1639 // C++ [expr]: If an expression initially has the type "reference to T", the 1640 // type is adjusted to "T" prior to any further analysis, the expression 1641 // designates the object or function denoted by the reference, and the 1642 // expression is an lvalue. 1643 if (ReferenceType *RT = dyn_cast<ReferenceType>(LHS)) 1644 LHS = RT->getPointeeType(); 1645 if (ReferenceType *RT = dyn_cast<ReferenceType>(RHS)) 1646 RHS = RT->getPointeeType(); 1647 1648 Type::TypeClass LHSClass = LHS->getTypeClass(); 1649 Type::TypeClass RHSClass = RHS->getTypeClass(); 1650 1651 // We want to consider the two function types to be the same for these 1652 // comparisons, just force one to the other. 1653 if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto; 1654 if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto; 1655 1656 // Same as above for arrays 1657 if (LHSClass == Type::VariableArray) LHSClass = Type::ConstantArray; 1658 if (RHSClass == Type::VariableArray) RHSClass = Type::ConstantArray; 1659 if (LHSClass == Type::IncompleteArray) LHSClass = Type::ConstantArray; 1660 if (RHSClass == Type::IncompleteArray) RHSClass = Type::ConstantArray; 1661 1662 // If the canonical type classes don't match... 1663 if (LHSClass != RHSClass) { 1664 // For Objective-C, it is possible for two types to be compatible 1665 // when their classes don't match (when dealing with "id"). If either type 1666 // is an interface, we defer to objcTypesAreCompatible(). 1667 if (LHS->isObjCInterfaceType() || RHS->isObjCInterfaceType()) 1668 return objcTypesAreCompatible(LHS, RHS); 1669 1670 // C99 6.7.2.2p4: Each enumerated type shall be compatible with char, 1671 // a signed integer type, or an unsigned integer type. 1672 if (LHS->isEnumeralType() && RHS->isIntegralType()) { 1673 EnumDecl* EDecl = cast<EnumType>(LHS)->getDecl(); 1674 return EDecl->getIntegerType() == RHS; 1675 } 1676 if (RHS->isEnumeralType() && LHS->isIntegralType()) { 1677 EnumDecl* EDecl = cast<EnumType>(RHS)->getDecl(); 1678 return EDecl->getIntegerType() == LHS; 1679 } 1680 1681 return false; 1682 } 1683 // The canonical type classes match. 1684 switch (LHSClass) { 1685 case Type::FunctionProto: assert(0 && "Canonicalized away above"); 1686 case Type::Pointer: 1687 return pointerTypesAreCompatible(LHS, RHS); 1688 case Type::ConstantArray: 1689 case Type::VariableArray: 1690 case Type::IncompleteArray: 1691 return arrayTypesAreCompatible(LHS, RHS); 1692 case Type::FunctionNoProto: 1693 return functionTypesAreCompatible(LHS, RHS); 1694 case Type::Tagged: // handle structures, unions 1695 return tagTypesAreCompatible(LHS, RHS); 1696 case Type::Builtin: 1697 return builtinTypesAreCompatible(LHS, RHS); 1698 case Type::ObjCInterface: 1699 // The LHS must be a superclass of the RHS. 1700 return cast<ObjCInterfaceType>(LHS)->getDecl()->isSuperClassOf( 1701 cast<ObjCInterfaceType>(RHS)->getDecl()); 1702 case Type::Vector: 1703 case Type::OCUVector: 1704 return areCompatVectorTypes(cast<VectorType>(LHS), cast<VectorType>(RHS)); 1705 case Type::ObjCQualifiedInterface: 1706 return areCompatObjCQualInterfaces(cast<ObjCQualifiedInterfaceType>(LHS), 1707 cast<ObjCQualifiedInterfaceType>(RHS)); 1708 default: 1709 assert(0 && "unexpected type"); 1710 } 1711 return true; // should never get here... 1712} 1713 1714/// Emit - Serialize an ASTContext object to Bitcode. 1715void ASTContext::Emit(llvm::Serializer& S) const { 1716 S.EmitRef(SourceMgr); 1717 S.EmitRef(Target); 1718 S.EmitRef(Idents); 1719 S.EmitRef(Selectors); 1720 1721 // Emit the size of the type vector so that we can reserve that size 1722 // when we reconstitute the ASTContext object. 1723 S.EmitInt(Types.size()); 1724 1725 for (std::vector<Type*>::const_iterator I=Types.begin(), E=Types.end(); 1726 I!=E;++I) 1727 (*I)->Emit(S); 1728 1729 // FIXME: S.EmitOwnedPtr(CFConstantStringTypeDecl); 1730} 1731 1732ASTContext* ASTContext::Create(llvm::Deserializer& D) { 1733 SourceManager &SM = D.ReadRef<SourceManager>(); 1734 TargetInfo &t = D.ReadRef<TargetInfo>(); 1735 IdentifierTable &idents = D.ReadRef<IdentifierTable>(); 1736 SelectorTable &sels = D.ReadRef<SelectorTable>(); 1737 1738 unsigned size_reserve = D.ReadInt(); 1739 1740 ASTContext* A = new ASTContext(SM,t,idents,sels,size_reserve); 1741 1742 for (unsigned i = 0; i < size_reserve; ++i) 1743 Type::Create(*A,i,D); 1744 1745 // FIXME: A->CFConstantStringTypeDecl = D.ReadOwnedPtr<RecordDecl>(); 1746 1747 return A; 1748} 1749