contrib/llvm/tools/clang/lib/CodeGen/CGRTTI.cpp

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