1 //===--- CGCXXRTTI.cpp - Emit LLVM Code for C++ RTTI descriptors ----------===// 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 contains code dealing with C++ code generation of RTTI descriptors. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "CodeGenModule.h" 15 #include "CGCXXABI.h" 16 #include "clang/AST/RecordLayout.h" 17 #include "clang/AST/Type.h" 18 #include "clang/Frontend/CodeGenOptions.h" 19 #include "CGObjCRuntime.h" 20 21 using namespace clang; 22 using namespace CodeGen; 23 24 namespace { 25 class RTTIBuilder { 26 CodeGenModule &CGM; // Per-module state. 27 llvm::LLVMContext &VMContext; 28 29 /// Fields - The fields of the RTTI descriptor currently being built. 30 SmallVector<llvm::Constant *, 16> Fields; 31 32 /// GetAddrOfTypeName - Returns the mangled type name of the given type. 33 llvm::GlobalVariable * 34 GetAddrOfTypeName(QualType Ty, llvm::GlobalVariable::LinkageTypes Linkage); 35 36 /// GetAddrOfExternalRTTIDescriptor - Returns the constant for the RTTI 37 /// descriptor of the given type. 38 llvm::Constant *GetAddrOfExternalRTTIDescriptor(QualType Ty); 39 40 /// BuildVTablePointer - Build the vtable pointer for the given type. 41 void BuildVTablePointer(const Type *Ty); 42 43 /// BuildSIClassTypeInfo - Build an abi::__si_class_type_info, used for single 44 /// inheritance, according to the Itanium C++ ABI, 2.9.5p6b. 45 void BuildSIClassTypeInfo(const CXXRecordDecl *RD); 46 47 /// BuildVMIClassTypeInfo - Build an abi::__vmi_class_type_info, used for 48 /// classes with bases that do not satisfy the abi::__si_class_type_info 49 /// constraints, according ti the Itanium C++ ABI, 2.9.5p5c. 50 void BuildVMIClassTypeInfo(const CXXRecordDecl *RD); 51 52 /// BuildPointerTypeInfo - Build an abi::__pointer_type_info struct, used 53 /// for pointer types. 54 void BuildPointerTypeInfo(QualType PointeeTy); 55 56 /// BuildObjCObjectTypeInfo - Build the appropriate kind of 57 /// type_info for an object type. 58 void BuildObjCObjectTypeInfo(const ObjCObjectType *Ty); 59 60 /// BuildPointerToMemberTypeInfo - Build an abi::__pointer_to_member_type_info 61 /// struct, used for member pointer types. 62 void BuildPointerToMemberTypeInfo(const MemberPointerType *Ty); 63 64 public: 65 RTTIBuilder(CodeGenModule &CGM) : CGM(CGM), 66 VMContext(CGM.getModule().getContext()) { } 67 68 // Pointer type info flags. 69 enum { 70 /// PTI_Const - Type has const qualifier. 71 PTI_Const = 0x1, 72 73 /// PTI_Volatile - Type has volatile qualifier. 74 PTI_Volatile = 0x2, 75 76 /// PTI_Restrict - Type has restrict qualifier. 77 PTI_Restrict = 0x4, 78 79 /// PTI_Incomplete - Type is incomplete. 80 PTI_Incomplete = 0x8, 81 82 /// PTI_ContainingClassIncomplete - Containing class is incomplete. 83 /// (in pointer to member). 84 PTI_ContainingClassIncomplete = 0x10 85 }; 86 87 // VMI type info flags. 88 enum { 89 /// VMI_NonDiamondRepeat - Class has non-diamond repeated inheritance. 90 VMI_NonDiamondRepeat = 0x1, 91 92 /// VMI_DiamondShaped - Class is diamond shaped. 93 VMI_DiamondShaped = 0x2 94 }; 95 96 // Base class type info flags. 97 enum { 98 /// BCTI_Virtual - Base class is virtual. 99 BCTI_Virtual = 0x1, 100 101 /// BCTI_Public - Base class is public. 102 BCTI_Public = 0x2 103 }; 104 105 /// BuildTypeInfo - Build the RTTI type info struct for the given type. 106 /// 107 /// \param Force - true to force the creation of this RTTI value 108 /// \param ForEH - true if this is for exception handling 109 llvm::Constant *BuildTypeInfo(QualType Ty, bool Force = false); 110 }; 111 } 112 113 llvm::GlobalVariable * 114 RTTIBuilder::GetAddrOfTypeName(QualType Ty, 115 llvm::GlobalVariable::LinkageTypes Linkage) { 116 SmallString<256> OutName; 117 llvm::raw_svector_ostream Out(OutName); 118 CGM.getCXXABI().getMangleContext().mangleCXXRTTIName(Ty, Out); 119 Out.flush(); 120 StringRef Name = OutName.str(); 121 122 // We know that the mangled name of the type starts at index 4 of the 123 // mangled name of the typename, so we can just index into it in order to 124 // get the mangled name of the type. 125 llvm::Constant *Init = llvm::ConstantDataArray::getString(VMContext, 126 Name.substr(4)); 127 128 llvm::GlobalVariable *GV = 129 CGM.CreateOrReplaceCXXRuntimeVariable(Name, Init->getType(), Linkage); 130 131 GV->setInitializer(Init); 132 133 return GV; 134 } 135 136 llvm::Constant *RTTIBuilder::GetAddrOfExternalRTTIDescriptor(QualType Ty) { 137 // Mangle the RTTI name. 138 SmallString<256> OutName; 139 llvm::raw_svector_ostream Out(OutName); 140 CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty, Out); 141 Out.flush(); 142 StringRef Name = OutName.str(); 143 144 // Look for an existing global. 145 llvm::GlobalVariable *GV = CGM.getModule().getNamedGlobal(Name); 146 147 if (!GV) { 148 // Create a new global variable. 149 GV = new llvm::GlobalVariable(CGM.getModule(), CGM.Int8PtrTy, 150 /*Constant=*/true, 151 llvm::GlobalValue::ExternalLinkage, 0, Name); 152 } 153 154 return llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy); 155 } 156 157 /// TypeInfoIsInStandardLibrary - Given a builtin type, returns whether the type 158 /// info for that type is defined in the standard library. 159 static bool TypeInfoIsInStandardLibrary(const BuiltinType *Ty) { 160 // Itanium C++ ABI 2.9.2: 161 // Basic type information (e.g. for "int", "bool", etc.) will be kept in 162 // the run-time support library. Specifically, the run-time support 163 // library should contain type_info objects for the types X, X* and 164 // X const*, for every X in: void, std::nullptr_t, bool, wchar_t, char, 165 // unsigned char, signed char, short, unsigned short, int, unsigned int, 166 // long, unsigned long, long long, unsigned long long, float, double, 167 // long double, char16_t, char32_t, and the IEEE 754r decimal and 168 // half-precision floating point types. 169 switch (Ty->getKind()) { 170 case BuiltinType::Void: 171 case BuiltinType::NullPtr: 172 case BuiltinType::Bool: 173 case BuiltinType::WChar_S: 174 case BuiltinType::WChar_U: 175 case BuiltinType::Char_U: 176 case BuiltinType::Char_S: 177 case BuiltinType::UChar: 178 case BuiltinType::SChar: 179 case BuiltinType::Short: 180 case BuiltinType::UShort: 181 case BuiltinType::Int: 182 case BuiltinType::UInt: 183 case BuiltinType::Long: 184 case BuiltinType::ULong: 185 case BuiltinType::LongLong: 186 case BuiltinType::ULongLong: 187 case BuiltinType::Half: 188 case BuiltinType::Float: 189 case BuiltinType::Double: 190 case BuiltinType::LongDouble: 191 case BuiltinType::Char16: 192 case BuiltinType::Char32: 193 case BuiltinType::Int128: 194 case BuiltinType::UInt128: 195 return true; 196 197 case BuiltinType::Dependent: 198 #define BUILTIN_TYPE(Id, SingletonId) 199 #define PLACEHOLDER_TYPE(Id, SingletonId) \ 200 case BuiltinType::Id: 201 #include "clang/AST/BuiltinTypes.def" 202 llvm_unreachable("asking for RRTI for a placeholder type!"); 203 204 case BuiltinType::ObjCId: 205 case BuiltinType::ObjCClass: 206 case BuiltinType::ObjCSel: 207 llvm_unreachable("FIXME: Objective-C types are unsupported!"); 208 } 209 210 llvm_unreachable("Invalid BuiltinType Kind!"); 211 } 212 213 static bool TypeInfoIsInStandardLibrary(const PointerType *PointerTy) { 214 QualType PointeeTy = PointerTy->getPointeeType(); 215 const BuiltinType *BuiltinTy = dyn_cast<BuiltinType>(PointeeTy); 216 if (!BuiltinTy) 217 return false; 218 219 // Check the qualifiers. 220 Qualifiers Quals = PointeeTy.getQualifiers(); 221 Quals.removeConst(); 222 223 if (!Quals.empty()) 224 return false; 225 226 return TypeInfoIsInStandardLibrary(BuiltinTy); 227 } 228 229 /// IsStandardLibraryRTTIDescriptor - Returns whether the type 230 /// information for the given type exists in the standard library. 231 static bool IsStandardLibraryRTTIDescriptor(QualType Ty) { 232 // Type info for builtin types is defined in the standard library. 233 if (const BuiltinType *BuiltinTy = dyn_cast<BuiltinType>(Ty)) 234 return TypeInfoIsInStandardLibrary(BuiltinTy); 235 236 // Type info for some pointer types to builtin types is defined in the 237 // standard library. 238 if (const PointerType *PointerTy = dyn_cast<PointerType>(Ty)) 239 return TypeInfoIsInStandardLibrary(PointerTy); 240 241 return false; 242 } 243 244 /// ShouldUseExternalRTTIDescriptor - Returns whether the type information for 245 /// the given type exists somewhere else, and that we should not emit the type 246 /// information in this translation unit. Assumes that it is not a 247 /// standard-library type. 248 static bool ShouldUseExternalRTTIDescriptor(CodeGenModule &CGM, QualType Ty) { 249 ASTContext &Context = CGM.getContext(); 250 251 // If RTTI is disabled, don't consider key functions. 252 if (!Context.getLangOpts().RTTI) return false; 253 254 if (const RecordType *RecordTy = dyn_cast<RecordType>(Ty)) { 255 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl()); 256 if (!RD->hasDefinition()) 257 return false; 258 259 if (!RD->isDynamicClass()) 260 return false; 261 262 return !CGM.getVTables().ShouldEmitVTableInThisTU(RD); 263 } 264 265 return false; 266 } 267 268 /// IsIncompleteClassType - Returns whether the given record type is incomplete. 269 static bool IsIncompleteClassType(const RecordType *RecordTy) { 270 return !RecordTy->getDecl()->isCompleteDefinition(); 271 } 272 273 /// ContainsIncompleteClassType - Returns whether the given type contains an 274 /// incomplete class type. This is true if 275 /// 276 /// * The given type is an incomplete class type. 277 /// * The given type is a pointer type whose pointee type contains an 278 /// incomplete class type. 279 /// * The given type is a member pointer type whose class is an incomplete 280 /// class type. 281 /// * The given type is a member pointer type whoise pointee type contains an 282 /// incomplete class type. 283 /// is an indirect or direct pointer to an incomplete class type. 284 static bool ContainsIncompleteClassType(QualType Ty) { 285 if (const RecordType *RecordTy = dyn_cast<RecordType>(Ty)) { 286 if (IsIncompleteClassType(RecordTy)) 287 return true; 288 } 289 290 if (const PointerType *PointerTy = dyn_cast<PointerType>(Ty)) 291 return ContainsIncompleteClassType(PointerTy->getPointeeType()); 292 293 if (const MemberPointerType *MemberPointerTy = 294 dyn_cast<MemberPointerType>(Ty)) { 295 // Check if the class type is incomplete. 296 const RecordType *ClassType = cast<RecordType>(MemberPointerTy->getClass()); 297 if (IsIncompleteClassType(ClassType)) 298 return true; 299 300 return ContainsIncompleteClassType(MemberPointerTy->getPointeeType()); 301 } 302 303 return false; 304 } 305 306 /// getTypeInfoLinkage - Return the linkage that the type info and type info 307 /// name constants should have for the given type. 308 static llvm::GlobalVariable::LinkageTypes 309 getTypeInfoLinkage(CodeGenModule &CGM, QualType Ty) { 310 // Itanium C++ ABI 2.9.5p7: 311 // In addition, it and all of the intermediate abi::__pointer_type_info 312 // structs in the chain down to the abi::__class_type_info for the 313 // incomplete class type must be prevented from resolving to the 314 // corresponding type_info structs for the complete class type, possibly 315 // by making them local static objects. Finally, a dummy class RTTI is 316 // generated for the incomplete type that will not resolve to the final 317 // complete class RTTI (because the latter need not exist), possibly by 318 // making it a local static object. 319 if (ContainsIncompleteClassType(Ty)) 320 return llvm::GlobalValue::InternalLinkage; 321 322 switch (Ty->getLinkage()) { 323 case NoLinkage: 324 case InternalLinkage: 325 case UniqueExternalLinkage: 326 return llvm::GlobalValue::InternalLinkage; 327 328 case ExternalLinkage: 329 if (!CGM.getLangOpts().RTTI) { 330 // RTTI is not enabled, which means that this type info struct is going 331 // to be used for exception handling. Give it linkonce_odr linkage. 332 return llvm::GlobalValue::LinkOnceODRLinkage; 333 } 334 335 if (const RecordType *Record = dyn_cast<RecordType>(Ty)) { 336 const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl()); 337 if (RD->hasAttr<WeakAttr>()) 338 return llvm::GlobalValue::WeakODRLinkage; 339 if (RD->isDynamicClass()) 340 return CGM.getVTableLinkage(RD); 341 } 342 343 return llvm::GlobalValue::LinkOnceODRLinkage; 344 } 345 346 llvm_unreachable("Invalid linkage!"); 347 } 348 349 // CanUseSingleInheritance - Return whether the given record decl has a "single, 350 // public, non-virtual base at offset zero (i.e. the derived class is dynamic 351 // iff the base is)", according to Itanium C++ ABI, 2.95p6b. 352 static bool CanUseSingleInheritance(const CXXRecordDecl *RD) { 353 // Check the number of bases. 354 if (RD->getNumBases() != 1) 355 return false; 356 357 // Get the base. 358 CXXRecordDecl::base_class_const_iterator Base = RD->bases_begin(); 359 360 // Check that the base is not virtual. 361 if (Base->isVirtual()) 362 return false; 363 364 // Check that the base is public. 365 if (Base->getAccessSpecifier() != AS_public) 366 return false; 367 368 // Check that the class is dynamic iff the base is. 369 const CXXRecordDecl *BaseDecl = 370 cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 371 if (!BaseDecl->isEmpty() && 372 BaseDecl->isDynamicClass() != RD->isDynamicClass()) 373 return false; 374 375 return true; 376 } 377 378 void RTTIBuilder::BuildVTablePointer(const Type *Ty) { 379 // abi::__class_type_info. 380 static const char * const ClassTypeInfo = 381 "_ZTVN10__cxxabiv117__class_type_infoE"; 382 // abi::__si_class_type_info. 383 static const char * const SIClassTypeInfo = 384 "_ZTVN10__cxxabiv120__si_class_type_infoE"; 385 // abi::__vmi_class_type_info. 386 static const char * const VMIClassTypeInfo = 387 "_ZTVN10__cxxabiv121__vmi_class_type_infoE"; 388 389 const char *VTableName = 0; 390 391 switch (Ty->getTypeClass()) { 392 #define TYPE(Class, Base) 393 #define ABSTRACT_TYPE(Class, Base) 394 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class: 395 #define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 396 #define DEPENDENT_TYPE(Class, Base) case Type::Class: 397 #include "clang/AST/TypeNodes.def" 398 llvm_unreachable("Non-canonical and dependent types shouldn't get here"); 399 400 case Type::LValueReference: 401 case Type::RValueReference: 402 llvm_unreachable("References shouldn't get here"); 403 404 case Type::Builtin: 405 // GCC treats vector and complex types as fundamental types. 406 case Type::Vector: 407 case Type::ExtVector: 408 case Type::Complex: 409 case Type::Atomic: 410 // FIXME: GCC treats block pointers as fundamental types?! 411 case Type::BlockPointer: 412 // abi::__fundamental_type_info. 413 VTableName = "_ZTVN10__cxxabiv123__fundamental_type_infoE"; 414 break; 415 416 case Type::ConstantArray: 417 case Type::IncompleteArray: 418 case Type::VariableArray: 419 // abi::__array_type_info. 420 VTableName = "_ZTVN10__cxxabiv117__array_type_infoE"; 421 break; 422 423 case Type::FunctionNoProto: 424 case Type::FunctionProto: 425 // abi::__function_type_info. 426 VTableName = "_ZTVN10__cxxabiv120__function_type_infoE"; 427 break; 428 429 case Type::Enum: 430 // abi::__enum_type_info. 431 VTableName = "_ZTVN10__cxxabiv116__enum_type_infoE"; 432 break; 433 434 case Type::Record: { 435 const CXXRecordDecl *RD = 436 cast<CXXRecordDecl>(cast<RecordType>(Ty)->getDecl()); 437 438 if (!RD->hasDefinition() || !RD->getNumBases()) { 439 VTableName = ClassTypeInfo; 440 } else if (CanUseSingleInheritance(RD)) { 441 VTableName = SIClassTypeInfo; 442 } else { 443 VTableName = VMIClassTypeInfo; 444 } 445 446 break; 447 } 448 449 case Type::ObjCObject: 450 // Ignore protocol qualifiers. 451 Ty = cast<ObjCObjectType>(Ty)->getBaseType().getTypePtr(); 452 453 // Handle id and Class. 454 if (isa<BuiltinType>(Ty)) { 455 VTableName = ClassTypeInfo; 456 break; 457 } 458 459 assert(isa<ObjCInterfaceType>(Ty)); 460 // Fall through. 461 462 case Type::ObjCInterface: 463 if (cast<ObjCInterfaceType>(Ty)->getDecl()->getSuperClass()) { 464 VTableName = SIClassTypeInfo; 465 } else { 466 VTableName = ClassTypeInfo; 467 } 468 break; 469 470 case Type::ObjCObjectPointer: 471 case Type::Pointer: 472 // abi::__pointer_type_info. 473 VTableName = "_ZTVN10__cxxabiv119__pointer_type_infoE"; 474 break; 475 476 case Type::MemberPointer: 477 // abi::__pointer_to_member_type_info. 478 VTableName = "_ZTVN10__cxxabiv129__pointer_to_member_type_infoE"; 479 break; 480 } 481 482 llvm::Constant *VTable = 483 CGM.getModule().getOrInsertGlobal(VTableName, CGM.Int8PtrTy); 484 485 llvm::Type *PtrDiffTy = 486 CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType()); 487 488 // The vtable address point is 2. 489 llvm::Constant *Two = llvm::ConstantInt::get(PtrDiffTy, 2); 490 VTable = llvm::ConstantExpr::getInBoundsGetElementPtr(VTable, Two); 491 VTable = llvm::ConstantExpr::getBitCast(VTable, CGM.Int8PtrTy); 492 493 Fields.push_back(VTable); 494 } 495 496 // maybeUpdateRTTILinkage - Will update the linkage of the RTTI data structures 497 // from available_externally to the correct linkage if necessary. An example of 498 // this is: 499 // 500 // struct A { 501 // virtual void f(); 502 // }; 503 // 504 // const std::type_info &g() { 505 // return typeid(A); 506 // } 507 // 508 // void A::f() { } 509 // 510 // When we're generating the typeid(A) expression, we do not yet know that 511 // A's key function is defined in this translation unit, so we will give the 512 // typeinfo and typename structures available_externally linkage. When A::f 513 // forces the vtable to be generated, we need to change the linkage of the 514 // typeinfo and typename structs, otherwise we'll end up with undefined 515 // externals when linking. 516 static void 517 maybeUpdateRTTILinkage(CodeGenModule &CGM, llvm::GlobalVariable *GV, 518 QualType Ty) { 519 // We're only interested in globals with available_externally linkage. 520 if (!GV->hasAvailableExternallyLinkage()) 521 return; 522 523 // Get the real linkage for the type. 524 llvm::GlobalVariable::LinkageTypes Linkage = getTypeInfoLinkage(CGM, Ty); 525 526 // If variable is supposed to have available_externally linkage, we don't 527 // need to do anything. 528 if (Linkage == llvm::GlobalVariable::AvailableExternallyLinkage) 529 return; 530 531 // Update the typeinfo linkage. 532 GV->setLinkage(Linkage); 533 534 // Get the typename global. 535 SmallString<256> OutName; 536 llvm::raw_svector_ostream Out(OutName); 537 CGM.getCXXABI().getMangleContext().mangleCXXRTTIName(Ty, Out); 538 Out.flush(); 539 StringRef Name = OutName.str(); 540 541 llvm::GlobalVariable *TypeNameGV = CGM.getModule().getNamedGlobal(Name); 542 543 assert(TypeNameGV->hasAvailableExternallyLinkage() && 544 "Type name has different linkage from type info!"); 545 546 // And update its linkage. 547 TypeNameGV->setLinkage(Linkage); 548 } 549 550 llvm::Constant *RTTIBuilder::BuildTypeInfo(QualType Ty, bool Force) { 551 // We want to operate on the canonical type. 552 Ty = CGM.getContext().getCanonicalType(Ty); 553 554 // Check if we've already emitted an RTTI descriptor for this type. 555 SmallString<256> OutName; 556 llvm::raw_svector_ostream Out(OutName); 557 CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty, Out); 558 Out.flush(); 559 StringRef Name = OutName.str(); 560 561 llvm::GlobalVariable *OldGV = CGM.getModule().getNamedGlobal(Name); 562 if (OldGV && !OldGV->isDeclaration()) { 563 maybeUpdateRTTILinkage(CGM, OldGV, Ty); 564 565 return llvm::ConstantExpr::getBitCast(OldGV, CGM.Int8PtrTy); 566 } 567 568 // Check if there is already an external RTTI descriptor for this type. 569 bool IsStdLib = IsStandardLibraryRTTIDescriptor(Ty); 570 if (!Force && (IsStdLib || ShouldUseExternalRTTIDescriptor(CGM, Ty))) 571 return GetAddrOfExternalRTTIDescriptor(Ty); 572 573 // Emit the standard library with external linkage. 574 llvm::GlobalVariable::LinkageTypes Linkage; 575 if (IsStdLib) 576 Linkage = llvm::GlobalValue::ExternalLinkage; 577 else 578 Linkage = getTypeInfoLinkage(CGM, Ty); 579 580 // Add the vtable pointer. 581 BuildVTablePointer(cast<Type>(Ty)); 582 583 // And the name. 584 llvm::GlobalVariable *TypeName = GetAddrOfTypeName(Ty, Linkage); 585 586 Fields.push_back(llvm::ConstantExpr::getBitCast(TypeName, CGM.Int8PtrTy)); 587 588 switch (Ty->getTypeClass()) { 589 #define TYPE(Class, Base) 590 #define ABSTRACT_TYPE(Class, Base) 591 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class: 592 #define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 593 #define DEPENDENT_TYPE(Class, Base) case Type::Class: 594 #include "clang/AST/TypeNodes.def" 595 llvm_unreachable("Non-canonical and dependent types shouldn't get here"); 596 597 // GCC treats vector types as fundamental types. 598 case Type::Builtin: 599 case Type::Vector: 600 case Type::ExtVector: 601 case Type::Complex: 602 case Type::BlockPointer: 603 // Itanium C++ ABI 2.9.5p4: 604 // abi::__fundamental_type_info adds no data members to std::type_info. 605 break; 606 607 case Type::LValueReference: 608 case Type::RValueReference: 609 llvm_unreachable("References shouldn't get here"); 610 611 case Type::ConstantArray: 612 case Type::IncompleteArray: 613 case Type::VariableArray: 614 // Itanium C++ ABI 2.9.5p5: 615 // abi::__array_type_info adds no data members to std::type_info. 616 break; 617 618 case Type::FunctionNoProto: 619 case Type::FunctionProto: 620 // Itanium C++ ABI 2.9.5p5: 621 // abi::__function_type_info adds no data members to std::type_info. 622 break; 623 624 case Type::Enum: 625 // Itanium C++ ABI 2.9.5p5: 626 // abi::__enum_type_info adds no data members to std::type_info. 627 break; 628 629 case Type::Record: { 630 const CXXRecordDecl *RD = 631 cast<CXXRecordDecl>(cast<RecordType>(Ty)->getDecl()); 632 if (!RD->hasDefinition() || !RD->getNumBases()) { 633 // We don't need to emit any fields. 634 break; 635 } 636 637 if (CanUseSingleInheritance(RD)) 638 BuildSIClassTypeInfo(RD); 639 else 640 BuildVMIClassTypeInfo(RD); 641 642 break; 643 } 644 645 case Type::ObjCObject: 646 case Type::ObjCInterface: 647 BuildObjCObjectTypeInfo(cast<ObjCObjectType>(Ty)); 648 break; 649 650 case Type::ObjCObjectPointer: 651 BuildPointerTypeInfo(cast<ObjCObjectPointerType>(Ty)->getPointeeType()); 652 break; 653 654 case Type::Pointer: 655 BuildPointerTypeInfo(cast<PointerType>(Ty)->getPointeeType()); 656 break; 657 658 case Type::MemberPointer: 659 BuildPointerToMemberTypeInfo(cast<MemberPointerType>(Ty)); 660 break; 661 662 case Type::Atomic: 663 // No fields, at least for the moment. 664 break; 665 } 666 667 llvm::Constant *Init = llvm::ConstantStruct::getAnon(Fields); 668 669 llvm::GlobalVariable *GV = 670 new llvm::GlobalVariable(CGM.getModule(), Init->getType(), 671 /*Constant=*/true, Linkage, Init, Name); 672 673 // If there's already an old global variable, replace it with the new one. 674 if (OldGV) { 675 GV->takeName(OldGV); 676 llvm::Constant *NewPtr = 677 llvm::ConstantExpr::getBitCast(GV, OldGV->getType()); 678 OldGV->replaceAllUsesWith(NewPtr); 679 OldGV->eraseFromParent(); 680 } 681 682 // GCC only relies on the uniqueness of the type names, not the 683 // type_infos themselves, so we can emit these as hidden symbols. 684 // But don't do this if we're worried about strict visibility 685 // compatibility. 686 if (const RecordType *RT = dyn_cast<RecordType>(Ty)) { 687 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 688 689 CGM.setTypeVisibility(GV, RD, CodeGenModule::TVK_ForRTTI); 690 CGM.setTypeVisibility(TypeName, RD, CodeGenModule::TVK_ForRTTIName); 691 } else { 692 Visibility TypeInfoVisibility = DefaultVisibility; 693 if (CGM.getCodeGenOpts().HiddenWeakVTables && 694 Linkage == llvm::GlobalValue::LinkOnceODRLinkage) 695 TypeInfoVisibility = HiddenVisibility; 696 697 // The type name should have the same visibility as the type itself. 698 Visibility ExplicitVisibility = Ty->getVisibility(); 699 TypeName->setVisibility(CodeGenModule:: 700 GetLLVMVisibility(ExplicitVisibility)); 701 702 TypeInfoVisibility = minVisibility(TypeInfoVisibility, Ty->getVisibility()); 703 GV->setVisibility(CodeGenModule::GetLLVMVisibility(TypeInfoVisibility)); 704 } 705 706 GV->setUnnamedAddr(true); 707 708 return llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy); 709 } 710 711 /// ComputeQualifierFlags - Compute the pointer type info flags from the 712 /// given qualifier. 713 static unsigned ComputeQualifierFlags(Qualifiers Quals) { 714 unsigned Flags = 0; 715 716 if (Quals.hasConst()) 717 Flags |= RTTIBuilder::PTI_Const; 718 if (Quals.hasVolatile()) 719 Flags |= RTTIBuilder::PTI_Volatile; 720 if (Quals.hasRestrict()) 721 Flags |= RTTIBuilder::PTI_Restrict; 722 723 return Flags; 724 } 725 726 /// BuildObjCObjectTypeInfo - Build the appropriate kind of type_info 727 /// for the given Objective-C object type. 728 void RTTIBuilder::BuildObjCObjectTypeInfo(const ObjCObjectType *OT) { 729 // Drop qualifiers. 730 const Type *T = OT->getBaseType().getTypePtr(); 731 assert(isa<BuiltinType>(T) || isa<ObjCInterfaceType>(T)); 732 733 // The builtin types are abi::__class_type_infos and don't require 734 // extra fields. 735 if (isa<BuiltinType>(T)) return; 736 737 ObjCInterfaceDecl *Class = cast<ObjCInterfaceType>(T)->getDecl(); 738 ObjCInterfaceDecl *Super = Class->getSuperClass(); 739 740 // Root classes are also __class_type_info. 741 if (!Super) return; 742 743 QualType SuperTy = CGM.getContext().getObjCInterfaceType(Super); 744 745 // Everything else is single inheritance. 746 llvm::Constant *BaseTypeInfo = RTTIBuilder(CGM).BuildTypeInfo(SuperTy); 747 Fields.push_back(BaseTypeInfo); 748 } 749 750 /// BuildSIClassTypeInfo - Build an abi::__si_class_type_info, used for single 751 /// inheritance, according to the Itanium C++ ABI, 2.95p6b. 752 void RTTIBuilder::BuildSIClassTypeInfo(const CXXRecordDecl *RD) { 753 // Itanium C++ ABI 2.9.5p6b: 754 // It adds to abi::__class_type_info a single member pointing to the 755 // type_info structure for the base type, 756 llvm::Constant *BaseTypeInfo = 757 RTTIBuilder(CGM).BuildTypeInfo(RD->bases_begin()->getType()); 758 Fields.push_back(BaseTypeInfo); 759 } 760 761 namespace { 762 /// SeenBases - Contains virtual and non-virtual bases seen when traversing 763 /// a class hierarchy. 764 struct SeenBases { 765 llvm::SmallPtrSet<const CXXRecordDecl *, 16> NonVirtualBases; 766 llvm::SmallPtrSet<const CXXRecordDecl *, 16> VirtualBases; 767 }; 768 } 769 770 /// ComputeVMIClassTypeInfoFlags - Compute the value of the flags member in 771 /// abi::__vmi_class_type_info. 772 /// 773 static unsigned ComputeVMIClassTypeInfoFlags(const CXXBaseSpecifier *Base, 774 SeenBases &Bases) { 775 776 unsigned Flags = 0; 777 778 const CXXRecordDecl *BaseDecl = 779 cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 780 781 if (Base->isVirtual()) { 782 if (Bases.VirtualBases.count(BaseDecl)) { 783 // If this virtual base has been seen before, then the class is diamond 784 // shaped. 785 Flags |= RTTIBuilder::VMI_DiamondShaped; 786 } else { 787 if (Bases.NonVirtualBases.count(BaseDecl)) 788 Flags |= RTTIBuilder::VMI_NonDiamondRepeat; 789 790 // Mark the virtual base as seen. 791 Bases.VirtualBases.insert(BaseDecl); 792 } 793 } else { 794 if (Bases.NonVirtualBases.count(BaseDecl)) { 795 // If this non-virtual base has been seen before, then the class has non- 796 // diamond shaped repeated inheritance. 797 Flags |= RTTIBuilder::VMI_NonDiamondRepeat; 798 } else { 799 if (Bases.VirtualBases.count(BaseDecl)) 800 Flags |= RTTIBuilder::VMI_NonDiamondRepeat; 801 802 // Mark the non-virtual base as seen. 803 Bases.NonVirtualBases.insert(BaseDecl); 804 } 805 } 806 807 // Walk all bases. 808 for (CXXRecordDecl::base_class_const_iterator I = BaseDecl->bases_begin(), 809 E = BaseDecl->bases_end(); I != E; ++I) 810 Flags |= ComputeVMIClassTypeInfoFlags(I, Bases); 811 812 return Flags; 813 } 814 815 static unsigned ComputeVMIClassTypeInfoFlags(const CXXRecordDecl *RD) { 816 unsigned Flags = 0; 817 SeenBases Bases; 818 819 // Walk all bases. 820 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), 821 E = RD->bases_end(); I != E; ++I) 822 Flags |= ComputeVMIClassTypeInfoFlags(I, Bases); 823 824 return Flags; 825 } 826 827 /// BuildVMIClassTypeInfo - Build an abi::__vmi_class_type_info, used for 828 /// classes with bases that do not satisfy the abi::__si_class_type_info 829 /// constraints, according ti the Itanium C++ ABI, 2.9.5p5c. 830 void RTTIBuilder::BuildVMIClassTypeInfo(const CXXRecordDecl *RD) { 831 llvm::Type *UnsignedIntLTy = 832 CGM.getTypes().ConvertType(CGM.getContext().UnsignedIntTy); 833 834 // Itanium C++ ABI 2.9.5p6c: 835 // __flags is a word with flags describing details about the class 836 // structure, which may be referenced by using the __flags_masks 837 // enumeration. These flags refer to both direct and indirect bases. 838 unsigned Flags = ComputeVMIClassTypeInfoFlags(RD); 839 Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags)); 840 841 // Itanium C++ ABI 2.9.5p6c: 842 // __base_count is a word with the number of direct proper base class 843 // descriptions that follow. 844 Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, RD->getNumBases())); 845 846 if (!RD->getNumBases()) 847 return; 848 849 llvm::Type *LongLTy = 850 CGM.getTypes().ConvertType(CGM.getContext().LongTy); 851 852 // Now add the base class descriptions. 853 854 // Itanium C++ ABI 2.9.5p6c: 855 // __base_info[] is an array of base class descriptions -- one for every 856 // direct proper base. Each description is of the type: 857 // 858 // struct abi::__base_class_type_info { 859 // public: 860 // const __class_type_info *__base_type; 861 // long __offset_flags; 862 // 863 // enum __offset_flags_masks { 864 // __virtual_mask = 0x1, 865 // __public_mask = 0x2, 866 // __offset_shift = 8 867 // }; 868 // }; 869 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), 870 E = RD->bases_end(); I != E; ++I) { 871 const CXXBaseSpecifier *Base = I; 872 873 // The __base_type member points to the RTTI for the base type. 874 Fields.push_back(RTTIBuilder(CGM).BuildTypeInfo(Base->getType())); 875 876 const CXXRecordDecl *BaseDecl = 877 cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 878 879 int64_t OffsetFlags = 0; 880 881 // All but the lower 8 bits of __offset_flags are a signed offset. 882 // For a non-virtual base, this is the offset in the object of the base 883 // subobject. For a virtual base, this is the offset in the virtual table of 884 // the virtual base offset for the virtual base referenced (negative). 885 CharUnits Offset; 886 if (Base->isVirtual()) 887 Offset = 888 CGM.getVTableContext().getVirtualBaseOffsetOffset(RD, BaseDecl); 889 else { 890 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); 891 Offset = Layout.getBaseClassOffset(BaseDecl); 892 }; 893 894 OffsetFlags = Offset.getQuantity() << 8; 895 896 // The low-order byte of __offset_flags contains flags, as given by the 897 // masks from the enumeration __offset_flags_masks. 898 if (Base->isVirtual()) 899 OffsetFlags |= BCTI_Virtual; 900 if (Base->getAccessSpecifier() == AS_public) 901 OffsetFlags |= BCTI_Public; 902 903 Fields.push_back(llvm::ConstantInt::get(LongLTy, OffsetFlags)); 904 } 905 } 906 907 /// BuildPointerTypeInfo - Build an abi::__pointer_type_info struct, 908 /// used for pointer types. 909 void RTTIBuilder::BuildPointerTypeInfo(QualType PointeeTy) { 910 Qualifiers Quals; 911 QualType UnqualifiedPointeeTy = 912 CGM.getContext().getUnqualifiedArrayType(PointeeTy, Quals); 913 914 // Itanium C++ ABI 2.9.5p7: 915 // __flags is a flag word describing the cv-qualification and other 916 // attributes of the type pointed to 917 unsigned Flags = ComputeQualifierFlags(Quals); 918 919 // Itanium C++ ABI 2.9.5p7: 920 // When the abi::__pbase_type_info is for a direct or indirect pointer to an 921 // incomplete class type, the incomplete target type flag is set. 922 if (ContainsIncompleteClassType(UnqualifiedPointeeTy)) 923 Flags |= PTI_Incomplete; 924 925 llvm::Type *UnsignedIntLTy = 926 CGM.getTypes().ConvertType(CGM.getContext().UnsignedIntTy); 927 Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags)); 928 929 // Itanium C++ ABI 2.9.5p7: 930 // __pointee is a pointer to the std::type_info derivation for the 931 // unqualified type being pointed to. 932 llvm::Constant *PointeeTypeInfo = 933 RTTIBuilder(CGM).BuildTypeInfo(UnqualifiedPointeeTy); 934 Fields.push_back(PointeeTypeInfo); 935 } 936 937 /// BuildPointerToMemberTypeInfo - Build an abi::__pointer_to_member_type_info 938 /// struct, used for member pointer types. 939 void RTTIBuilder::BuildPointerToMemberTypeInfo(const MemberPointerType *Ty) { 940 QualType PointeeTy = Ty->getPointeeType(); 941 942 Qualifiers Quals; 943 QualType UnqualifiedPointeeTy = 944 CGM.getContext().getUnqualifiedArrayType(PointeeTy, Quals); 945 946 // Itanium C++ ABI 2.9.5p7: 947 // __flags is a flag word describing the cv-qualification and other 948 // attributes of the type pointed to. 949 unsigned Flags = ComputeQualifierFlags(Quals); 950 951 const RecordType *ClassType = cast<RecordType>(Ty->getClass()); 952 953 // Itanium C++ ABI 2.9.5p7: 954 // When the abi::__pbase_type_info is for a direct or indirect pointer to an 955 // incomplete class type, the incomplete target type flag is set. 956 if (ContainsIncompleteClassType(UnqualifiedPointeeTy)) 957 Flags |= PTI_Incomplete; 958 959 if (IsIncompleteClassType(ClassType)) 960 Flags |= PTI_ContainingClassIncomplete; 961 962 llvm::Type *UnsignedIntLTy = 963 CGM.getTypes().ConvertType(CGM.getContext().UnsignedIntTy); 964 Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags)); 965 966 // Itanium C++ ABI 2.9.5p7: 967 // __pointee is a pointer to the std::type_info derivation for the 968 // unqualified type being pointed to. 969 llvm::Constant *PointeeTypeInfo = 970 RTTIBuilder(CGM).BuildTypeInfo(UnqualifiedPointeeTy); 971 Fields.push_back(PointeeTypeInfo); 972 973 // Itanium C++ ABI 2.9.5p9: 974 // __context is a pointer to an abi::__class_type_info corresponding to the 975 // class type containing the member pointed to 976 // (e.g., the "A" in "int A::*"). 977 Fields.push_back(RTTIBuilder(CGM).BuildTypeInfo(QualType(ClassType, 0))); 978 } 979 980 llvm::Constant *CodeGenModule::GetAddrOfRTTIDescriptor(QualType Ty, 981 bool ForEH) { 982 // Return a bogus pointer if RTTI is disabled, unless it's for EH. 983 // FIXME: should we even be calling this method if RTTI is disabled 984 // and it's not for EH? 985 if (!ForEH && !getContext().getLangOpts().RTTI) 986 return llvm::Constant::getNullValue(Int8PtrTy); 987 988 if (ForEH && Ty->isObjCObjectPointerType() && !LangOpts.NeXTRuntime) 989 return ObjCRuntime->GetEHType(Ty); 990 991 return RTTIBuilder(*this).BuildTypeInfo(Ty); 992 } 993 994 void CodeGenModule::EmitFundamentalRTTIDescriptor(QualType Type) { 995 QualType PointerType = Context.getPointerType(Type); 996 QualType PointerTypeConst = Context.getPointerType(Type.withConst()); 997 RTTIBuilder(*this).BuildTypeInfo(Type, true); 998 RTTIBuilder(*this).BuildTypeInfo(PointerType, true); 999 RTTIBuilder(*this).BuildTypeInfo(PointerTypeConst, true); 1000 } 1001 1002 void CodeGenModule::EmitFundamentalRTTIDescriptors() { 1003 QualType FundamentalTypes[] = { Context.VoidTy, Context.NullPtrTy, 1004 Context.BoolTy, Context.WCharTy, 1005 Context.CharTy, Context.UnsignedCharTy, 1006 Context.SignedCharTy, Context.ShortTy, 1007 Context.UnsignedShortTy, Context.IntTy, 1008 Context.UnsignedIntTy, Context.LongTy, 1009 Context.UnsignedLongTy, Context.LongLongTy, 1010 Context.UnsignedLongLongTy, Context.FloatTy, 1011 Context.DoubleTy, Context.LongDoubleTy, 1012 Context.Char16Ty, Context.Char32Ty }; 1013 for (unsigned i = 0; i < sizeof(FundamentalTypes)/sizeof(QualType); ++i) 1014 EmitFundamentalRTTIDescriptor(FundamentalTypes[i]); 1015 } 1016