[WIP][private] Add Obj-C discriminator to MS ABI RTTI

[smeenai]

Summary

Obj-C classes are mangled as C++ structs with the same name (in both the
Itanium and the Microsoft ABIs), but we want to be able to distinguish
them for the purposes of exception handling, so we need to add a
discriminator to the RTTI and the RTTI name.

lib/AST/MicrosoftMangle.cpp

void mangleMemberFunctionPointer(const CXXRecordDecl *RD,
                                    const CXXMethodDecl *MD);
   void mangleVirtualMemPtrThunk(const CXXMethodDecl *MD,
                                 const MethodVFTableLocation &ML);
   void mangleNumber(int64_t Number);
   void mangleTagTypeKind(TagTypeKind TK);
   void mangleArtificalTagType(TagTypeKind TK, StringRef UnqualifiedName,
                               ArrayRef<StringRef> NestedNames = None);
   void mangleType(QualType T, SourceRange Range,
-                  QualifierMangleMode QMM = QMM_Mangle);
+                  QualifierMangleMode QMM = QMM_Mangle, bool ForRTTI = false);
   void mangleFunctionType(const FunctionType *T,
                           const FunctionDecl *D = nullptr,
                           bool ForceThisQuals = false);
   void mangleNestedName(const NamedDecl *ND);
 
 private:
   bool isStructorDecl(const NamedDecl *ND) const {
     return ND == Structor || getStructor(ND) == Structor;

 #define TYPE(CLASS, PARENT) void mangleType(const CLASS##Type *T, \
                                             Qualifiers Quals, \
                                             SourceRange Range);
 #include "clang/AST/TypeNodes.def"
 #undef ABSTRACT_TYPE
 #undef NON_CANONICAL_TYPE
 #undef TYPE
 
+  // Obj-C mangling needs special handing for RTTI.
+  void mangleType(const BuiltinType *T, Qualifiers Quals, SourceRange Range,
+                  bool ForRTTI);
+  void mangleType(const ObjCInterfaceType *T, Qualifiers Quals,
+                  SourceRange Range, bool ForRTTI);
+  void mangleType(const ObjCObjectType *T, Qualifiers Quals, SourceRange Range,
+                  bool ForRTTI);
+  void mangleType(const ObjCObjectPointerType *T, Qualifiers Quals,
+                  SourceRange Range, bool ForRTTI);
+
   void mangleType(const TagDecl *TD);
   void mangleDecayedArrayType(const ArrayType *T);
   void mangleArrayType(const ArrayType *T);
   void mangleFunctionClass(const FunctionDecl *FD);
   void mangleCallingConvention(CallingConv CC);
   void mangleCallingConvention(const FunctionType *T);
   void mangleIntegerLiteral(const llvm::APSInt &Number, bool IsBoolean);
   void mangleExpression(const Expr *E);
if (TypeBackReferences.size() < 10) {
       TypeBackReferences[TypePtr] = Size;
     }
   } else {
     Out << Found->second;
   }
 }
 
 void MicrosoftCXXNameMangler::mangleType(QualType T, SourceRange Range,
-                                         QualifierMangleMode QMM) {
+                                         QualifierMangleMode QMM,
+                                         bool ForRTTI) {
   // Don't use the canonical types.  MSVC includes things like 'const' on
   // pointer arguments to function pointers that canonicalization strips away.
   T = T.getDesugaredType(getASTContext());
   Qualifiers Quals = T.getLocalQualifiers();
   if (const ArrayType *AT = getASTContext().getAsArrayType(T)) {
     // If there were any Quals, getAsArrayType() pushed them onto the array
     // element type.
     if (QMM == QMM_Mangle)
if ((!IsPointer && Quals) || isa<TagType>(T) || isArtificialTagType(T)) {
       mangleQualifiers(Quals, false);
     }
     break;
   }
 
   const Type *ty = T.getTypePtr();
 
   switch (ty->getTypeClass()) {
+  case Type::Builtin:
+    mangleType(cast<BuiltinType>(ty), Quals, Range, ForRTTI);
+    return;
+  case Type::ObjCObjectPointer:
+    mangleType(cast<ObjCObjectPointerType>(ty), Quals, Range, ForRTTI);
+    return;
+  case Type::ObjCObject:
+    mangleType(cast<ObjCObjectType>(ty), Quals, Range, ForRTTI);
+    return;
+  case Type::ObjCInterface:
+    mangleType(cast<ObjCInterfaceType>(ty), Quals, Range, ForRTTI);
+    return;
+  default:
+    break; // handled by next switch
+  }
+
+  switch (ty->getTypeClass()) {
 #define ABSTRACT_TYPE(CLASS, PARENT)
 #define NON_CANONICAL_TYPE(CLASS, PARENT) \
   case Type::CLASS: \
     llvm_unreachable("can't mangle non-canonical type " #CLASS "Type"); \
     return;
 #define TYPE(CLASS, PARENT) \
   case Type::CLASS: \
     mangleType(cast<CLASS##Type>(ty), Quals, Range); \
     break;
 #include "clang/AST/TypeNodes.def"
 #undef ABSTRACT_TYPE
 #undef NON_CANONICAL_TYPE
 #undef TYPE
   }
 }
 
-void MicrosoftCXXNameMangler::mangleType(const BuiltinType *T, Qualifiers,
+void MicrosoftCXXNameMangler::mangleType(const BuiltinType *T, Qualifiers Quals,
                                          SourceRange Range) {
+  mangleType(T, Quals, Range, /*ForRTTI=*/false);
+}
+
+void MicrosoftCXXNameMangler::mangleType(const BuiltinType *T, Qualifiers,
+                                         SourceRange Range, bool ForRTTI) {
   //  <type>         ::= <builtin-type>
   //  <builtin-type> ::= X  # void
   //                 ::= C  # signed char
   //                 ::= D  # char
   //                 ::= E  # unsigned char
   //                 ::= F  # short
   //                 ::= G  # unsigned short (or wchar_t if it's not a builtin)
   //                 ::= H  # int

 
 #define BUILTIN_TYPE(Id, SingletonId)
 #define PLACEHOLDER_TYPE(Id, SingletonId) \
   case BuiltinType::Id:
 #include "clang/AST/BuiltinTypes.def"
   case BuiltinType::Dependent:
     llvm_unreachable("placeholder types shouldn't get to name mangling");
 
-  case BuiltinType::ObjCId:
+  case BuiltinType::ObjCId: {
+    if (!ForRTTI) {
       mangleArtificalTagType(TTK_Struct, "objc_object");
       break;
+    }
+
+    llvm::SmallString<64> TemplateMangling;
+    llvm::raw_svector_ostream Stream(TemplateMangling);
+    MicrosoftCXXNameMangler Extra(Context, Stream);
+
+    // Obj-C classes are mangled as C++ structs with the same name, but we want
+    // to be able to distinguish a C++ struct X from an Obj-C class X for the
+    // purposes of exception handling, so we add a discriminator.
+    Stream << "?$";
+    Extra.mangleSourceName("Class");
+    // ObjC interfaces have structs underlying them.
+    Extra.mangleArtificalTagType(TTK_Struct, "objc_object");
+
+    mangleArtificalTagType(TTK_Struct, TemplateMangling, {"__ObjC"});
+    break;
+  }
   case BuiltinType::ObjCClass:
     mangleArtificalTagType(TTK_Struct, "objc_class");
     break;
   case BuiltinType::ObjCSel:
     mangleArtificalTagType(TTK_Struct, "objc_selector");
     break;
 
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
void MicrosoftCXXNameMangler::mangleType(const PointerType *T, Qualifiers Quals,
   QualType PointeeType = T->getPointeeType();
   manglePointerCVQualifiers(Quals);
   manglePointerExtQualifiers(Quals, PointeeType);
   mangleType(PointeeType, Range);
 }
 
 void MicrosoftCXXNameMangler::mangleType(const ObjCObjectPointerType *T,
                                          Qualifiers Quals, SourceRange Range) {
+  mangleType(T, Quals, Range, /*ForRTTI=*/false);
+}
+
+void MicrosoftCXXNameMangler::mangleType(const ObjCObjectPointerType *T,
+                                         Qualifiers Quals, SourceRange Range,
+                                         bool ForRTTI) {
   QualType PointeeType = T->getPointeeType();
   switch (Quals.getObjCLifetime()) {
   case Qualifiers::OCL_None:
   case Qualifiers::OCL_ExplicitNone:
     break;
   case Qualifiers::OCL_Autoreleasing:
   case Qualifiers::OCL_Strong:
   case Qualifiers::OCL_Weak:
     return mangleObjCLifetime(PointeeType, Quals, Range);
   }
   manglePointerCVQualifiers(Quals);
   manglePointerExtQualifiers(Quals, PointeeType);
-  mangleType(PointeeType, Range);
+  mangleType(PointeeType, Range, QMM_Mangle, /*ForRTTI=*/ForRTTI);
 }
 
 // <type> ::= <reference-type>
 // <reference-type> ::= A E? <cvr-qualifiers> <type>
 //                 # the E is required for 64-bit non-static lvalue references
 void MicrosoftCXXNameMangler::mangleType(const LValueReferenceType *T,
                                          Qualifiers Quals, SourceRange Range) {
   QualType PointeeType = T->getPointeeType();
void MicrosoftCXXNameMangler::mangleType(const DependentAddressSpaceType *T,
                                          Qualifiers, SourceRange Range) {
   DiagnosticsEngine &Diags = Context.getDiags();
   unsigned DiagID = Diags.getCustomDiagID(
       DiagnosticsEngine::Error,
       "cannot mangle this dependent address space type yet");
   Diags.Report(Range.getBegin(), DiagID) << Range;
 }
 
+void MicrosoftCXXNameMangler::mangleType(const ObjCInterfaceType *T,
+                                         Qualifiers Quals, SourceRange Range) {
+  mangleType(T, Quals, Range, /*ForRTTI=*/false);
+}
+
 void MicrosoftCXXNameMangler::mangleType(const ObjCInterfaceType *T, Qualifiers,
-                                         SourceRange) {
+                                         SourceRange, bool ForRTTI) {
+  if (!ForRTTI) {
     // ObjC interfaces have structs underlying them.
     mangleTagTypeKind(TTK_Struct);
     mangleName(T->getDecl());
+    return;
+  }
+
+  llvm::SmallString<64> TemplateMangling;
+  llvm::raw_svector_ostream Stream(TemplateMangling);
+  MicrosoftCXXNameMangler Extra(Context, Stream);
+
+  // Obj-C classes are mangled as C++ structs with the same name, but we want to
+  // be able to distinguish a C++ struct X from an Obj-C class X for the
+  // purposes of exception handling, so we add a discriminator.
+  Stream << "?$";
+  Extra.mangleSourceName("Class");
+  // ObjC interfaces have structs underlying them.
+  Extra.mangleArtificalTagType(TTK_Struct, T->getDecl()->getName());
+
+  mangleArtificalTagType(TTK_Struct, TemplateMangling, {"__ObjC"});
 }
 
 void MicrosoftCXXNameMangler::mangleType(const ObjCObjectType *T,
                                          Qualifiers Quals, SourceRange Range) {
+  mangleType(T, Quals, Range, /*ForRTTI=*/false);
+}
+
+void MicrosoftCXXNameMangler::mangleType(const ObjCObjectType *T,
+                                         Qualifiers Quals, SourceRange Range,
+                                         bool ForRTTI) {
   if (T->isKindOfType())
     return mangleObjCKindOfType(T, Quals, Range);
 
   if (T->qual_empty() && !T->isSpecialized())
-    return mangleType(T->getBaseType(), Range, QMM_Drop);
+    return mangleType(T->getBaseType(), Range, QMM_Drop, ForRTTI);
 
   ArgBackRefMap OuterArgsContext;
   BackRefVec OuterTemplateContext;
 
   TypeBackReferences.swap(OuterArgsContext);
   NameBackReferences.swap(OuterTemplateContext);
 
   mangleTagTypeKind(TTK_Struct);
for (const CXXRecordDecl *RD : BasePath)
     Mangler.mangleName(RD);
   Mangler.getStream() << '@';
 }
 
 void MicrosoftMangleContextImpl::mangleCXXRTTI(QualType T, raw_ostream &Out) {
   msvc_hashing_ostream MHO(Out);
   MicrosoftCXXNameMangler Mangler(*this, MHO);
   Mangler.getStream() << "??_R0";
-  Mangler.mangleType(T, SourceRange(), MicrosoftCXXNameMangler::QMM_Result);
+  Mangler.mangleType(T, SourceRange(), MicrosoftCXXNameMangler::QMM_Result,
+                     /*ForRTTI=*/true);
   Mangler.getStream() << "@8";
 }
 
 void MicrosoftMangleContextImpl::mangleCXXRTTIName(QualType T,
                                                    raw_ostream &Out) {
   MicrosoftCXXNameMangler Mangler(*this, Out);
   Mangler.getStream() << '.';
-  Mangler.mangleType(T, SourceRange(), MicrosoftCXXNameMangler::QMM_Result);
+  Mangler.mangleType(T, SourceRange(), MicrosoftCXXNameMangler::QMM_Result,
+                     /*ForRTTI=*/true);
 }
 
 void MicrosoftMangleContextImpl::mangleCXXVirtualDisplacementMap(
     const CXXRecordDecl *SrcRD, const CXXRecordDecl *DstRD, raw_ostream &Out) {
   msvc_hashing_ostream MHO(Out);
   MicrosoftCXXNameMangler Mangler(*this, MHO);
   Mangler.getStream() << "??_K";
   Mangler.mangleName(SrcRD);

test/CodeGenObjCXX/msabi-objc-exceptions-gnustep.mm

+// RUN: %clang_cc1 -triple i686-windows-msvc -fobjc-runtime=gnustep-2.0 -fexceptions -fobjc-exceptions -emit-llvm -o - %s | FileCheck -check-prefix=X86 %s
+// RUN: %clang_cc1 -triple x86_64-windows-msvc -fobjc-runtime=gnustep-2.0 -fexceptions -fobjc-exceptions -emit-llvm -o - %s | FileCheck -check-prefix=X64 %s
+
+// Ensure we have the __ObjC::class discriminator in the RTTI and the RTTI name.
+// X86-DAG: @"??_R0PAU?$Class@Uobjc_object@@@__ObjC@@@8" = linkonce_odr global %{{[^ ]+}} { i8** @"??_7type_info@@6B@", i8* null, [36 x i8] c".PAU?$Class@Uobjc_object@@@__ObjC@@\00" }, comdat
+// X64-DAG: @"??_R0PEAU?$Class@Uobjc_object@@@__ObjC@@@8" = linkonce_odr global %{{[^ ]+}} { i8** @"??_7type_info@@6B@", i8* null, [37 x i8] c".PEAU?$Class@Uobjc_object@@@__ObjC@@\00" }, comdat
+
+@class I;
+// X86-DAG: @"??_R0PAU?$Class@UI@@@__ObjC@@@8" = linkonce_odr global %{{[^ ]+}} { i8** @"??_7type_info@@6B@", i8* null, [26 x i8] c".PAU?$Class@UI@@@__ObjC@@\00" }, comdat
+// X64-DAG: @"??_R0PEAU?$Class@UI@@@__ObjC@@@8" = linkonce_odr global %{{[^ ]+}} { i8** @"??_7type_info@@6B@", i8* null, [27 x i8] c".PEAU?$Class@UI@@@__ObjC@@\00" }, comdat
+
+void f();
+void g() {
+  @try {
+    f();
+  } @catch (I *) {
+  } @catch (id) {
+  }
+}