Fix colliding WinEH TypeDescriptors for exceptions with the same TypeInfo_Class name

gen/irstate.h

@@ -272,7 +272,7 @@ struct IRState {
 
   // MS C++ compatible type descriptors
   llvm::DenseMap<size_t, llvm::StructType *> TypeDescriptorTypeMap;
-  llvm::DenseMap<llvm::Constant *, llvm::GlobalVariable *> TypeDescriptorMap;
+  llvm::DenseMap<ClassDeclaration *, llvm::GlobalVariable *> TypeDescriptorMap;
 
   // Target for dcompute. If not nullptr, it owns this.
   DComputeTarget *dcomputetarget = nullptr;

gen/mangling.cpp

@@ -134,9 +134,8 @@ std::string getIRMangledVarName(std::string baseMangle, LINK link) {
   return gABI->mangleVariableForLLVM(std::move(baseMangle), link);
 }
 
-namespace {
 std::string getIRMangledAggregateName(AggregateDeclaration *ad,
-                                    const char *suffix) {
+                                      const char *suffix) {
   std::string ret = "_D";
 
   OutBuffer mangleBuf;
@@ -154,7 +153,6 @@ std::string getIRMangledAggregateName(AggregateDeclaration *ad,
 
   return getIRMangledVarName(std::move(ret), LINKd);
 }
-}
 
 std::string getIRMangledInitSymbolName(AggregateDeclaration *aggrdecl) {
   return getIRMangledAggregateName(aggrdecl, "6__initZ");

gen/mangling.h

@@ -35,9 +35,12 @@ std::string getIRMangledName(VarDeclaration *vd);
 std::string getIRMangledFuncName(std::string baseMangle, LINK link);
 std::string getIRMangledVarName(std::string baseMangle, LINK link);
 
+std::string getIRMangledAggregateName(AggregateDeclaration *aggrdecl,
+                                      const char *suffix = nullptr);
 std::string getIRMangledInitSymbolName(AggregateDeclaration *aggrdecl);
 std::string getIRMangledVTableSymbolName(AggregateDeclaration *aggrdecl);
 std::string getIRMangledClassInfoSymbolName(AggregateDeclaration *aggrdecl);
 std::string getIRMangledInterfaceInfosSymbolName(ClassDeclaration *cd);
+
 std::string getIRMangledModuleInfoSymbolName(Module *module);
 std::string getIRMangledModuleRefSymbolName(const char *moduleMangle);

gen/ms-cxx-helper.cpp

@@ -1,6 +1,6 @@
 //===-- ms-cxx-helper.cpp -------------------------------------------------===//
 //
-//                         LDC � the LLVM D compiler
+//                         LDC – the LLVM D compiler
 //
 // This file is distributed under the BSD-style LDC license. See the LICENSE
 // file for details.
@@ -13,6 +13,7 @@
 #include "gen/irstate.h"
 #include "gen/llvm.h"
 #include "gen/llvmhelpers.h"
+#include "gen/mangling.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/IR/CFG.h"
@@ -162,15 +163,16 @@ llvm::GlobalVariable *getTypeDescriptor(IRState &irs, ClassDeclaration *cd) {
                          /*isConstant=*/true);
   }
 
-  auto classInfoPtr = getIrAggr(cd, true)->getClassInfoSymbol();
-  llvm::GlobalVariable *&Var = irs.TypeDescriptorMap[classInfoPtr];
+  llvm::GlobalVariable *&Var = irs.TypeDescriptorMap[cd];
   if (Var)
     return Var;
 
+  auto classInfoPtr = getIrAggr(cd, true)->getClassInfoSymbol();
+
   // first character skipped in debugger output, so we add 'D' as prefix
-  std::string TypeNameString = "D";
-  TypeNameString.append(cd->toPrettyChars());
-  std::string TypeDescName = TypeNameString + "@TypeDescriptor";
+  const auto TypeNameString = (llvm::Twine("D") + cd->toPrettyChars()).str();
+
+  const auto TypeDescName = getIRMangledAggregateName(cd, "@TypeDescriptor");
 
   // Declare and initialize the TypeDescriptor.
   llvm::Constant *Fields[] = {

gen/trycatchfinally.cpp

@@ -11,7 +11,6 @@
 
 #include "dmd/errors.h"
 #include "dmd/expression.h"
-#include "dmd/mangle.h"
 #include "dmd/statement.h"
 #include "dmd/target.h"
 #include "gen/classes.h"
@@ -165,12 +164,8 @@ void TryCatchScope::emitCatchBodies(IRState &irs, llvm::Value *ehPtrSlot) {
       // Wrap std::type_info pointers inside a __cpp_type_info_ptr class
       // instance so that the personality routine may differentiate C++ catch
       // clauses from D ones.
-      OutBuffer wrapperMangleBuf;
-      wrapperMangleBuf.writestring("_D");
-      mangleToBuffer(p.cd, &wrapperMangleBuf);
-      wrapperMangleBuf.printf("%d%s", 18, "_cpp_type_info_ptr");
       const auto wrapperMangle =
-          getIRMangledVarName(wrapperMangleBuf.peekChars(), LINKd);
+          getIRMangledAggregateName(p.cd, "18_cpp_type_info_ptr");
 
       ci = irs.module.getGlobalVariable(wrapperMangle);
       if (!ci) {

tests/compilable/gh3501.d

@@ -0,0 +1,28 @@
+// Tests EH with two exception types with the same `TypeInfo_Class.name`
+// (due to template args not being fully qualified).
+
+// RUN: %ldc -c %s
+
+void foo(T)()
+{
+    // name: gh3501.foo!(S).foo.MyException
+    static class MyException : Exception
+    {
+        this() { super(null); }
+    }
+
+    try { throw new MyException(); }
+    catch (MyException) {}
+}
+
+void bar1()
+{
+    struct S {}
+    foo!S();
+}
+
+void bar2()
+{
+    struct S {}
+    foo!S();
+}