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
21using namespace clang;
22using namespace CodeGen;
23
24namespace {
25class 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
64public:
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
112llvm::GlobalVariable *
113RTTIBuilder::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
135llvm::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.
158static 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
220static 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.
238static 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.
255static 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.
280static 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.
295static 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.
319static llvm::GlobalVariable::LinkageTypes
320getTypeInfoLinkage(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 VisibleNoLinkage:
336  case InternalLinkage:
337  case UniqueExternalLinkage:
338    return llvm::GlobalValue::InternalLinkage;
339
340  case ExternalLinkage:
341    if (!CGM.getLangOpts().RTTI) {
342      // RTTI is not enabled, which means that this type info struct is going
343      // to be used for exception handling. Give it linkonce_odr linkage.
344      return llvm::GlobalValue::LinkOnceODRLinkage;
345    }
346
347    if (const RecordType *Record = dyn_cast<RecordType>(Ty)) {
348      const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
349      if (RD->hasAttr<WeakAttr>())
350        return llvm::GlobalValue::WeakODRLinkage;
351      if (RD->isDynamicClass())
352        return CGM.getVTableLinkage(RD);
353    }
354
355    return llvm::GlobalValue::LinkOnceODRLinkage;
356  }
357
358  llvm_unreachable("Invalid linkage!");
359}
360
361// CanUseSingleInheritance - Return whether the given record decl has a "single,
362// public, non-virtual base at offset zero (i.e. the derived class is dynamic
363// iff the base is)", according to Itanium C++ ABI, 2.95p6b.
364static bool CanUseSingleInheritance(const CXXRecordDecl *RD) {
365  // Check the number of bases.
366  if (RD->getNumBases() != 1)
367    return false;
368
369  // Get the base.
370  CXXRecordDecl::base_class_const_iterator Base = RD->bases_begin();
371
372  // Check that the base is not virtual.
373  if (Base->isVirtual())
374    return false;
375
376  // Check that the base is public.
377  if (Base->getAccessSpecifier() != AS_public)
378    return false;
379
380  // Check that the class is dynamic iff the base is.
381  const CXXRecordDecl *BaseDecl =
382    cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
383  if (!BaseDecl->isEmpty() &&
384      BaseDecl->isDynamicClass() != RD->isDynamicClass())
385    return false;
386
387  return true;
388}
389
390void RTTIBuilder::BuildVTablePointer(const Type *Ty) {
391  // abi::__class_type_info.
392  static const char * const ClassTypeInfo =
393    "_ZTVN10__cxxabiv117__class_type_infoE";
394  // abi::__si_class_type_info.
395  static const char * const SIClassTypeInfo =
396    "_ZTVN10__cxxabiv120__si_class_type_infoE";
397  // abi::__vmi_class_type_info.
398  static const char * const VMIClassTypeInfo =
399    "_ZTVN10__cxxabiv121__vmi_class_type_infoE";
400
401  const char *VTableName = 0;
402
403  switch (Ty->getTypeClass()) {
404#define TYPE(Class, Base)
405#define ABSTRACT_TYPE(Class, Base)
406#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
407#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
408#define DEPENDENT_TYPE(Class, Base) case Type::Class:
409#include "clang/AST/TypeNodes.def"
410    llvm_unreachable("Non-canonical and dependent types shouldn't get here");
411
412  case Type::LValueReference:
413  case Type::RValueReference:
414    llvm_unreachable("References shouldn't get here");
415
416  case Type::Auto:
417    llvm_unreachable("Undeduced auto type shouldn't get here");
418
419  case Type::Builtin:
420  // GCC treats vector and complex types as fundamental types.
421  case Type::Vector:
422  case Type::ExtVector:
423  case Type::Complex:
424  case Type::Atomic:
425  // FIXME: GCC treats block pointers as fundamental types?!
426  case Type::BlockPointer:
427    // abi::__fundamental_type_info.
428    VTableName = "_ZTVN10__cxxabiv123__fundamental_type_infoE";
429    break;
430
431  case Type::ConstantArray:
432  case Type::IncompleteArray:
433  case Type::VariableArray:
434    // abi::__array_type_info.
435    VTableName = "_ZTVN10__cxxabiv117__array_type_infoE";
436    break;
437
438  case Type::FunctionNoProto:
439  case Type::FunctionProto:
440    // abi::__function_type_info.
441    VTableName = "_ZTVN10__cxxabiv120__function_type_infoE";
442    break;
443
444  case Type::Enum:
445    // abi::__enum_type_info.
446    VTableName = "_ZTVN10__cxxabiv116__enum_type_infoE";
447    break;
448
449  case Type::Record: {
450    const CXXRecordDecl *RD =
451      cast<CXXRecordDecl>(cast<RecordType>(Ty)->getDecl());
452
453    if (!RD->hasDefinition() || !RD->getNumBases()) {
454      VTableName = ClassTypeInfo;
455    } else if (CanUseSingleInheritance(RD)) {
456      VTableName = SIClassTypeInfo;
457    } else {
458      VTableName = VMIClassTypeInfo;
459    }
460
461    break;
462  }
463
464  case Type::ObjCObject:
465    // Ignore protocol qualifiers.
466    Ty = cast<ObjCObjectType>(Ty)->getBaseType().getTypePtr();
467
468    // Handle id and Class.
469    if (isa<BuiltinType>(Ty)) {
470      VTableName = ClassTypeInfo;
471      break;
472    }
473
474    assert(isa<ObjCInterfaceType>(Ty));
475    // Fall through.
476
477  case Type::ObjCInterface:
478    if (cast<ObjCInterfaceType>(Ty)->getDecl()->getSuperClass()) {
479      VTableName = SIClassTypeInfo;
480    } else {
481      VTableName = ClassTypeInfo;
482    }
483    break;
484
485  case Type::ObjCObjectPointer:
486  case Type::Pointer:
487    // abi::__pointer_type_info.
488    VTableName = "_ZTVN10__cxxabiv119__pointer_type_infoE";
489    break;
490
491  case Type::MemberPointer:
492    // abi::__pointer_to_member_type_info.
493    VTableName = "_ZTVN10__cxxabiv129__pointer_to_member_type_infoE";
494    break;
495  }
496
497  llvm::Constant *VTable =
498    CGM.getModule().getOrInsertGlobal(VTableName, CGM.Int8PtrTy);
499
500  llvm::Type *PtrDiffTy =
501    CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
502
503  // The vtable address point is 2.
504  llvm::Constant *Two = llvm::ConstantInt::get(PtrDiffTy, 2);
505  VTable = llvm::ConstantExpr::getInBoundsGetElementPtr(VTable, Two);
506  VTable = llvm::ConstantExpr::getBitCast(VTable, CGM.Int8PtrTy);
507
508  Fields.push_back(VTable);
509}
510
511llvm::Constant *RTTIBuilder::BuildTypeInfo(QualType Ty, bool Force) {
512  // We want to operate on the canonical type.
513  Ty = CGM.getContext().getCanonicalType(Ty);
514
515  // Check if we've already emitted an RTTI descriptor for this type.
516  SmallString<256> OutName;
517  llvm::raw_svector_ostream Out(OutName);
518  CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty, Out);
519  Out.flush();
520  StringRef Name = OutName.str();
521
522  llvm::GlobalVariable *OldGV = CGM.getModule().getNamedGlobal(Name);
523  if (OldGV && !OldGV->isDeclaration()) {
524    assert(!OldGV->hasAvailableExternallyLinkage() &&
525           "available_externally typeinfos not yet implemented");
526
527    return llvm::ConstantExpr::getBitCast(OldGV, CGM.Int8PtrTy);
528  }
529
530  // Check if there is already an external RTTI descriptor for this type.
531  bool IsStdLib = IsStandardLibraryRTTIDescriptor(Ty);
532  if (!Force && (IsStdLib || ShouldUseExternalRTTIDescriptor(CGM, Ty)))
533    return GetAddrOfExternalRTTIDescriptor(Ty);
534
535  // Emit the standard library with external linkage.
536  llvm::GlobalVariable::LinkageTypes Linkage;
537  if (IsStdLib)
538    Linkage = llvm::GlobalValue::ExternalLinkage;
539  else
540    Linkage = getTypeInfoLinkage(CGM, Ty);
541
542  // Add the vtable pointer.
543  BuildVTablePointer(cast<Type>(Ty));
544
545  // And the name.
546  llvm::GlobalVariable *TypeName = GetAddrOfTypeName(Ty, Linkage);
547
548  Fields.push_back(llvm::ConstantExpr::getBitCast(TypeName, CGM.Int8PtrTy));
549
550  switch (Ty->getTypeClass()) {
551#define TYPE(Class, Base)
552#define ABSTRACT_TYPE(Class, Base)
553#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
554#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
555#define DEPENDENT_TYPE(Class, Base) case Type::Class:
556#include "clang/AST/TypeNodes.def"
557    llvm_unreachable("Non-canonical and dependent types shouldn't get here");
558
559  // GCC treats vector types as fundamental types.
560  case Type::Builtin:
561  case Type::Vector:
562  case Type::ExtVector:
563  case Type::Complex:
564  case Type::BlockPointer:
565    // Itanium C++ ABI 2.9.5p4:
566    // abi::__fundamental_type_info adds no data members to std::type_info.
567    break;
568
569  case Type::LValueReference:
570  case Type::RValueReference:
571    llvm_unreachable("References shouldn't get here");
572
573  case Type::Auto:
574    llvm_unreachable("Undeduced auto type shouldn't get here");
575
576  case Type::ConstantArray:
577  case Type::IncompleteArray:
578  case Type::VariableArray:
579    // Itanium C++ ABI 2.9.5p5:
580    // abi::__array_type_info adds no data members to std::type_info.
581    break;
582
583  case Type::FunctionNoProto:
584  case Type::FunctionProto:
585    // Itanium C++ ABI 2.9.5p5:
586    // abi::__function_type_info adds no data members to std::type_info.
587    break;
588
589  case Type::Enum:
590    // Itanium C++ ABI 2.9.5p5:
591    // abi::__enum_type_info adds no data members to std::type_info.
592    break;
593
594  case Type::Record: {
595    const CXXRecordDecl *RD =
596      cast<CXXRecordDecl>(cast<RecordType>(Ty)->getDecl());
597    if (!RD->hasDefinition() || !RD->getNumBases()) {
598      // We don't need to emit any fields.
599      break;
600    }
601
602    if (CanUseSingleInheritance(RD))
603      BuildSIClassTypeInfo(RD);
604    else
605      BuildVMIClassTypeInfo(RD);
606
607    break;
608  }
609
610  case Type::ObjCObject:
611  case Type::ObjCInterface:
612    BuildObjCObjectTypeInfo(cast<ObjCObjectType>(Ty));
613    break;
614
615  case Type::ObjCObjectPointer:
616    BuildPointerTypeInfo(cast<ObjCObjectPointerType>(Ty)->getPointeeType());
617    break;
618
619  case Type::Pointer:
620    BuildPointerTypeInfo(cast<PointerType>(Ty)->getPointeeType());
621    break;
622
623  case Type::MemberPointer:
624    BuildPointerToMemberTypeInfo(cast<MemberPointerType>(Ty));
625    break;
626
627  case Type::Atomic:
628    // No fields, at least for the moment.
629    break;
630  }
631
632  llvm::Constant *Init = llvm::ConstantStruct::getAnon(Fields);
633
634  llvm::GlobalVariable *GV =
635    new llvm::GlobalVariable(CGM.getModule(), Init->getType(),
636                             /*Constant=*/true, Linkage, Init, Name);
637
638  // If there's already an old global variable, replace it with the new one.
639  if (OldGV) {
640    GV->takeName(OldGV);
641    llvm::Constant *NewPtr =
642      llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
643    OldGV->replaceAllUsesWith(NewPtr);
644    OldGV->eraseFromParent();
645  }
646
647  // GCC only relies on the uniqueness of the type names, not the
648  // type_infos themselves, so we can emit these as hidden symbols.
649  // But don't do this if we're worried about strict visibility
650  // compatibility.
651  if (const RecordType *RT = dyn_cast<RecordType>(Ty)) {
652    const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
653
654    CGM.setTypeVisibility(GV, RD, CodeGenModule::TVK_ForRTTI);
655    CGM.setTypeVisibility(TypeName, RD, CodeGenModule::TVK_ForRTTIName);
656  } else {
657    Visibility TypeInfoVisibility = DefaultVisibility;
658    if (CGM.getCodeGenOpts().HiddenWeakVTables &&
659        Linkage == llvm::GlobalValue::LinkOnceODRLinkage)
660      TypeInfoVisibility = HiddenVisibility;
661
662    // The type name should have the same visibility as the type itself.
663    Visibility ExplicitVisibility = Ty->getVisibility();
664    TypeName->setVisibility(CodeGenModule::
665                            GetLLVMVisibility(ExplicitVisibility));
666
667    TypeInfoVisibility = minVisibility(TypeInfoVisibility, Ty->getVisibility());
668    GV->setVisibility(CodeGenModule::GetLLVMVisibility(TypeInfoVisibility));
669  }
670
671  GV->setUnnamedAddr(true);
672
673  return llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy);
674}
675
676/// ComputeQualifierFlags - Compute the pointer type info flags from the
677/// given qualifier.
678static unsigned ComputeQualifierFlags(Qualifiers Quals) {
679  unsigned Flags = 0;
680
681  if (Quals.hasConst())
682    Flags |= RTTIBuilder::PTI_Const;
683  if (Quals.hasVolatile())
684    Flags |= RTTIBuilder::PTI_Volatile;
685  if (Quals.hasRestrict())
686    Flags |= RTTIBuilder::PTI_Restrict;
687
688  return Flags;
689}
690
691/// BuildObjCObjectTypeInfo - Build the appropriate kind of type_info
692/// for the given Objective-C object type.
693void RTTIBuilder::BuildObjCObjectTypeInfo(const ObjCObjectType *OT) {
694  // Drop qualifiers.
695  const Type *T = OT->getBaseType().getTypePtr();
696  assert(isa<BuiltinType>(T) || isa<ObjCInterfaceType>(T));
697
698  // The builtin types are abi::__class_type_infos and don't require
699  // extra fields.
700  if (isa<BuiltinType>(T)) return;
701
702  ObjCInterfaceDecl *Class = cast<ObjCInterfaceType>(T)->getDecl();
703  ObjCInterfaceDecl *Super = Class->getSuperClass();
704
705  // Root classes are also __class_type_info.
706  if (!Super) return;
707
708  QualType SuperTy = CGM.getContext().getObjCInterfaceType(Super);
709
710  // Everything else is single inheritance.
711  llvm::Constant *BaseTypeInfo = RTTIBuilder(CGM).BuildTypeInfo(SuperTy);
712  Fields.push_back(BaseTypeInfo);
713}
714
715/// BuildSIClassTypeInfo - Build an abi::__si_class_type_info, used for single
716/// inheritance, according to the Itanium C++ ABI, 2.95p6b.
717void RTTIBuilder::BuildSIClassTypeInfo(const CXXRecordDecl *RD) {
718  // Itanium C++ ABI 2.9.5p6b:
719  // It adds to abi::__class_type_info a single member pointing to the
720  // type_info structure for the base type,
721  llvm::Constant *BaseTypeInfo =
722    RTTIBuilder(CGM).BuildTypeInfo(RD->bases_begin()->getType());
723  Fields.push_back(BaseTypeInfo);
724}
725
726namespace {
727  /// SeenBases - Contains virtual and non-virtual bases seen when traversing
728  /// a class hierarchy.
729  struct SeenBases {
730    llvm::SmallPtrSet<const CXXRecordDecl *, 16> NonVirtualBases;
731    llvm::SmallPtrSet<const CXXRecordDecl *, 16> VirtualBases;
732  };
733}
734
735/// ComputeVMIClassTypeInfoFlags - Compute the value of the flags member in
736/// abi::__vmi_class_type_info.
737///
738static unsigned ComputeVMIClassTypeInfoFlags(const CXXBaseSpecifier *Base,
739                                             SeenBases &Bases) {
740
741  unsigned Flags = 0;
742
743  const CXXRecordDecl *BaseDecl =
744    cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
745
746  if (Base->isVirtual()) {
747    // Mark the virtual base as seen.
748    if (!Bases.VirtualBases.insert(BaseDecl)) {
749      // If this virtual base has been seen before, then the class is diamond
750      // shaped.
751      Flags |= RTTIBuilder::VMI_DiamondShaped;
752    } else {
753      if (Bases.NonVirtualBases.count(BaseDecl))
754        Flags |= RTTIBuilder::VMI_NonDiamondRepeat;
755    }
756  } else {
757    // Mark the non-virtual base as seen.
758    if (!Bases.NonVirtualBases.insert(BaseDecl)) {
759      // If this non-virtual base has been seen before, then the class has non-
760      // diamond shaped repeated inheritance.
761      Flags |= RTTIBuilder::VMI_NonDiamondRepeat;
762    } else {
763      if (Bases.VirtualBases.count(BaseDecl))
764        Flags |= RTTIBuilder::VMI_NonDiamondRepeat;
765    }
766  }
767
768  // Walk all bases.
769  for (CXXRecordDecl::base_class_const_iterator I = BaseDecl->bases_begin(),
770       E = BaseDecl->bases_end(); I != E; ++I)
771    Flags |= ComputeVMIClassTypeInfoFlags(I, Bases);
772
773  return Flags;
774}
775
776static unsigned ComputeVMIClassTypeInfoFlags(const CXXRecordDecl *RD) {
777  unsigned Flags = 0;
778  SeenBases Bases;
779
780  // Walk all bases.
781  for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
782       E = RD->bases_end(); I != E; ++I)
783    Flags |= ComputeVMIClassTypeInfoFlags(I, Bases);
784
785  return Flags;
786}
787
788/// BuildVMIClassTypeInfo - Build an abi::__vmi_class_type_info, used for
789/// classes with bases that do not satisfy the abi::__si_class_type_info
790/// constraints, according ti the Itanium C++ ABI, 2.9.5p5c.
791void RTTIBuilder::BuildVMIClassTypeInfo(const CXXRecordDecl *RD) {
792  llvm::Type *UnsignedIntLTy =
793    CGM.getTypes().ConvertType(CGM.getContext().UnsignedIntTy);
794
795  // Itanium C++ ABI 2.9.5p6c:
796  //   __flags is a word with flags describing details about the class
797  //   structure, which may be referenced by using the __flags_masks
798  //   enumeration. These flags refer to both direct and indirect bases.
799  unsigned Flags = ComputeVMIClassTypeInfoFlags(RD);
800  Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
801
802  // Itanium C++ ABI 2.9.5p6c:
803  //   __base_count is a word with the number of direct proper base class
804  //   descriptions that follow.
805  Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, RD->getNumBases()));
806
807  if (!RD->getNumBases())
808    return;
809
810  llvm::Type *LongLTy =
811    CGM.getTypes().ConvertType(CGM.getContext().LongTy);
812
813  // Now add the base class descriptions.
814
815  // Itanium C++ ABI 2.9.5p6c:
816  //   __base_info[] is an array of base class descriptions -- one for every
817  //   direct proper base. Each description is of the type:
818  //
819  //   struct abi::__base_class_type_info {
820  //   public:
821  //     const __class_type_info *__base_type;
822  //     long __offset_flags;
823  //
824  //     enum __offset_flags_masks {
825  //       __virtual_mask = 0x1,
826  //       __public_mask = 0x2,
827  //       __offset_shift = 8
828  //     };
829  //   };
830  for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
831       E = RD->bases_end(); I != E; ++I) {
832    const CXXBaseSpecifier *Base = I;
833
834    // The __base_type member points to the RTTI for the base type.
835    Fields.push_back(RTTIBuilder(CGM).BuildTypeInfo(Base->getType()));
836
837    const CXXRecordDecl *BaseDecl =
838      cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
839
840    int64_t OffsetFlags = 0;
841
842    // All but the lower 8 bits of __offset_flags are a signed offset.
843    // For a non-virtual base, this is the offset in the object of the base
844    // subobject. For a virtual base, this is the offset in the virtual table of
845    // the virtual base offset for the virtual base referenced (negative).
846    CharUnits Offset;
847    if (Base->isVirtual())
848      Offset =
849        CGM.getVTableContext().getVirtualBaseOffsetOffset(RD, BaseDecl);
850    else {
851      const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
852      Offset = Layout.getBaseClassOffset(BaseDecl);
853    };
854
855    OffsetFlags = uint64_t(Offset.getQuantity()) << 8;
856
857    // The low-order byte of __offset_flags contains flags, as given by the
858    // masks from the enumeration __offset_flags_masks.
859    if (Base->isVirtual())
860      OffsetFlags |= BCTI_Virtual;
861    if (Base->getAccessSpecifier() == AS_public)
862      OffsetFlags |= BCTI_Public;
863
864    Fields.push_back(llvm::ConstantInt::get(LongLTy, OffsetFlags));
865  }
866}
867
868/// BuildPointerTypeInfo - Build an abi::__pointer_type_info struct,
869/// used for pointer types.
870void RTTIBuilder::BuildPointerTypeInfo(QualType PointeeTy) {
871  Qualifiers Quals;
872  QualType UnqualifiedPointeeTy =
873    CGM.getContext().getUnqualifiedArrayType(PointeeTy, Quals);
874
875  // Itanium C++ ABI 2.9.5p7:
876  //   __flags is a flag word describing the cv-qualification and other
877  //   attributes of the type pointed to
878  unsigned Flags = ComputeQualifierFlags(Quals);
879
880  // Itanium C++ ABI 2.9.5p7:
881  //   When the abi::__pbase_type_info is for a direct or indirect pointer to an
882  //   incomplete class type, the incomplete target type flag is set.
883  if (ContainsIncompleteClassType(UnqualifiedPointeeTy))
884    Flags |= PTI_Incomplete;
885
886  llvm::Type *UnsignedIntLTy =
887    CGM.getTypes().ConvertType(CGM.getContext().UnsignedIntTy);
888  Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
889
890  // Itanium C++ ABI 2.9.5p7:
891  //  __pointee is a pointer to the std::type_info derivation for the
892  //  unqualified type being pointed to.
893  llvm::Constant *PointeeTypeInfo =
894    RTTIBuilder(CGM).BuildTypeInfo(UnqualifiedPointeeTy);
895  Fields.push_back(PointeeTypeInfo);
896}
897
898/// BuildPointerToMemberTypeInfo - Build an abi::__pointer_to_member_type_info
899/// struct, used for member pointer types.
900void RTTIBuilder::BuildPointerToMemberTypeInfo(const MemberPointerType *Ty) {
901  QualType PointeeTy = Ty->getPointeeType();
902
903  Qualifiers Quals;
904  QualType UnqualifiedPointeeTy =
905    CGM.getContext().getUnqualifiedArrayType(PointeeTy, Quals);
906
907  // Itanium C++ ABI 2.9.5p7:
908  //   __flags is a flag word describing the cv-qualification and other
909  //   attributes of the type pointed to.
910  unsigned Flags = ComputeQualifierFlags(Quals);
911
912  const RecordType *ClassType = cast<RecordType>(Ty->getClass());
913
914  // Itanium C++ ABI 2.9.5p7:
915  //   When the abi::__pbase_type_info is for a direct or indirect pointer to an
916  //   incomplete class type, the incomplete target type flag is set.
917  if (ContainsIncompleteClassType(UnqualifiedPointeeTy))
918    Flags |= PTI_Incomplete;
919
920  if (IsIncompleteClassType(ClassType))
921    Flags |= PTI_ContainingClassIncomplete;
922
923  llvm::Type *UnsignedIntLTy =
924    CGM.getTypes().ConvertType(CGM.getContext().UnsignedIntTy);
925  Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
926
927  // Itanium C++ ABI 2.9.5p7:
928  //   __pointee is a pointer to the std::type_info derivation for the
929  //   unqualified type being pointed to.
930  llvm::Constant *PointeeTypeInfo =
931    RTTIBuilder(CGM).BuildTypeInfo(UnqualifiedPointeeTy);
932  Fields.push_back(PointeeTypeInfo);
933
934  // Itanium C++ ABI 2.9.5p9:
935  //   __context is a pointer to an abi::__class_type_info corresponding to the
936  //   class type containing the member pointed to
937  //   (e.g., the "A" in "int A::*").
938  Fields.push_back(RTTIBuilder(CGM).BuildTypeInfo(QualType(ClassType, 0)));
939}
940
941llvm::Constant *CodeGenModule::GetAddrOfRTTIDescriptor(QualType Ty,
942                                                       bool ForEH) {
943  // Return a bogus pointer if RTTI is disabled, unless it's for EH.
944  // FIXME: should we even be calling this method if RTTI is disabled
945  // and it's not for EH?
946  if (!ForEH && !getLangOpts().RTTI)
947    return llvm::Constant::getNullValue(Int8PtrTy);
948
949  if (ForEH && Ty->isObjCObjectPointerType() &&
950      LangOpts.ObjCRuntime.isGNUFamily())
951    return ObjCRuntime->GetEHType(Ty);
952
953  return RTTIBuilder(*this).BuildTypeInfo(Ty);
954}
955
956void CodeGenModule::EmitFundamentalRTTIDescriptor(QualType Type) {
957  QualType PointerType = Context.getPointerType(Type);
958  QualType PointerTypeConst = Context.getPointerType(Type.withConst());
959  RTTIBuilder(*this).BuildTypeInfo(Type, true);
960  RTTIBuilder(*this).BuildTypeInfo(PointerType, true);
961  RTTIBuilder(*this).BuildTypeInfo(PointerTypeConst, true);
962}
963
964void CodeGenModule::EmitFundamentalRTTIDescriptors() {
965  QualType FundamentalTypes[] = { Context.VoidTy, Context.NullPtrTy,
966                                  Context.BoolTy, Context.WCharTy,
967                                  Context.CharTy, Context.UnsignedCharTy,
968                                  Context.SignedCharTy, Context.ShortTy,
969                                  Context.UnsignedShortTy, Context.IntTy,
970                                  Context.UnsignedIntTy, Context.LongTy,
971                                  Context.UnsignedLongTy, Context.LongLongTy,
972                                  Context.UnsignedLongLongTy, Context.FloatTy,
973                                  Context.DoubleTy, Context.LongDoubleTy,
974                                  Context.Char16Ty, Context.Char32Ty };
975  for (unsigned i = 0; i < llvm::array_lengthof(FundamentalTypes); ++i)
976    EmitFundamentalRTTIDescriptor(FundamentalTypes[i]);
977}
978