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