allow any exception to be caught in C++ by specific type

small refactorings preparing usage by x64

Author: rainers

src/ldc/eh/win32.d

@@ -13,24 +13,25 @@ import core.sys.windows.windows;
 import core.exception : onOutOfMemoryError, OutOfMemoryError;
 import core.stdc.stdlib : malloc, free;
 import core.stdc.string : memcpy;
+import rt.util.container.common : xmalloc;
 
 // pointers are image relative for Win64 versions
 version(Win64)
     alias ImgPtr(T) = uint; // offset into image
 else
-    alias ImgPtr(T) = T;
+    alias ImgPtr(T) = T*;
 
 alias PMFN = ImgPtr!(void function(void*));
 
-struct TypeDescriptor(int N)
+struct TypeDescriptor
 {
     version(_RTTI)
         const void * pVFTable;  // Field overloaded by RTTI
     else
         uint hash;  // Hash value computed from type's decorated name
 
     void * spare;   // reserved, possible for RTTI
-    char[N+1] name; // variable size, zero terminated
+    char[1] name;   // variable size, zero terminated
 }
 
 struct PMD
@@ -43,7 +44,7 @@ struct PMD
 struct CatchableType
 {
     uint  properties;       // Catchable Type properties (Bit field)
-    ImgPtr!(TypeDescriptor!1*) pType;   // Pointer to TypeDescriptor
+    ImgPtr!TypeDescriptor pType;   // Pointer to TypeDescriptor
     PMD   thisDisplacement; // Pointer to instance of catch type within thrown object.
     int   sizeOrOffset;     // Size of simple-type object or offset into buffer of 'this' pointer for catch object
     PMFN  copyFunction;     // Copy constructor or CC-closure
@@ -58,15 +59,15 @@ enum CT_IsStdBadAlloc   = 0x00000010;  // type is a a std::bad_alloc
 struct CatchableTypeArray
 {
     int	nCatchableTypes;
-    ImgPtr!(CatchableType*)[2] arrayOfCatchableTypes;
+    ImgPtr!CatchableType[1] arrayOfCatchableTypes; // variable size
 }
 
 struct _ThrowInfo
 {
     uint    attributes;     // Throw Info attributes (Bit field)
     PMFN    pmfnUnwind;     // Destructor to call when exception has been handled or aborted.
     PMFN    pForwardCompat; // pointer to Forward compatibility frame handler
-    ImgPtr!(CatchableTypeArray*) pCatchableTypeArray; // pointer to CatchableTypeArray
+    ImgPtr!CatchableTypeArray pCatchableTypeArray; // pointer to CatchableTypeArray
 }
 
 struct ExceptionRecord
@@ -142,96 +143,77 @@ extern(C) string _d_toString(Object o)
 import rt.util.container.hashtab;
 import core.sync.mutex;
 
-__gshared HashTab!(TypeInfo_Class, _ThrowInfo) throwInfoHashtab;
-__gshared HashTab!(TypeInfo_Class, CatchableType) catchableHashtab;
+__gshared HashTab!(TypeInfo_Class, ImgPtr!_ThrowInfo) throwInfoHashtab;
+__gshared HashTab!(TypeInfo_Class, ImgPtr!CatchableType) catchableHashtab;
 __gshared Mutex throwInfoMutex;
 
 // create and cache throwinfo for ti
-_ThrowInfo* getThrowInfo(TypeInfo_Class ti)
+ImgPtr!_ThrowInfo getThrowInfo(TypeInfo_Class ti)
 {
     throwInfoMutex.lock();
     if (auto p = ti in throwInfoHashtab)
     {
         throwInfoMutex.unlock();
-        return p;
+        return *p;
     }
 
-    bool isError = false;
-    bool isException = false;
     size_t classes = 0;
     for (TypeInfo_Class tic = ti; tic; tic = tic.base)
-    {
-        classes++;
-        if (tic == typeid(Exception))
-            isException = true;
-        if (tic == typeid(Error))
-            isError = true;
-    }
-    if (isError || isException)
-        classes += 2;
+        classes += 2; // D and C++
 
-    size_t sz = int.sizeof + classes * ImgPtr!(CatchableType*).sizeof;
-    auto cta = cast(CatchableTypeArray*) malloc(sz);
-    if (!cta)
-        onOutOfMemoryError();
+    size_t sz = int.sizeof + classes * ImgPtr!(CatchableType).sizeof;
+    auto cta = cast(CatchableTypeArray*) xmalloc(sz);
     cta.nCatchableTypes = classes;
 
     size_t c = 0;
-    for (TypeInfo_Class tic = ti; tic; tic = tic.base)
-        cta.arrayOfCatchableTypes.ptr[c++] = getCatchableType(tic);
-    if (isError || isException)
-        cta.arrayOfCatchableTypes.ptr[c++] = ctCxxDThrowable;
-    if (isException)
-        cta.arrayOfCatchableTypes.ptr[c++] = ctCxxDException;
-    if (isError)
-        cta.arrayOfCatchableTypes.ptr[c++] = ctCxxDError;
-
-    _ThrowInfo tinf = { 0, null, null, cta };
+    for (TypeInfo_Class tic = ti; tic; tic = tic.base, c += 2)
+    {
+        cta.arrayOfCatchableTypes.ptr[c] = getCatchableType(tic);
+        cta.arrayOfCatchableTypes.ptr[c + 1] = cta.arrayOfCatchableTypes.ptr[c] + 1;
+    }
+
+    auto tinf = cast(_ThrowInfo*) xmalloc(_ThrowInfo.sizeof);
+    *tinf = _ThrowInfo(0, null, null, cta);
     throwInfoHashtab[ti] = tinf;
-    auto pti = ti in throwInfoHashtab;
     throwInfoMutex.unlock();
-    return pti;
+    return tinf;
 }
-
+
+// returns pointer to array of 2 elements, one for D and one for C++
 CatchableType* getCatchableType(TypeInfo_Class ti)
 {
     if (auto p = ti in catchableHashtab)
-        return p;
+        return *p;
+
+    // generate catch types for both D (fully.qualified.name)
+    //  and C++ (D::name mangled to .PAVname@D@@)
+    size_t p = ti.name.length;
+    for ( ; p > 0 && ti.name[p-1] != '.'; p--) {}
+    string name = ti.name[p .. $];
+
+    size_t szd = (TypeDescriptor.sizeof + ti.name.length + 3) & ~3;
+    size_t szcpp = TypeDescriptor.sizeof + name.length + 8;
+    auto tdd = cast(TypeDescriptor*) xmalloc(szd + szcpp);
+
+    tdd.hash = 0;
+    tdd.spare = null;
+    tdd.name.ptr[0] = 'D';
+    memcpy(tdd.name.ptr + 1, ti.name.ptr, ti.name.length);
+    tdd.name.ptr[ti.name.length + 1] = 0;
+
+    auto tdcpp = cast(TypeDescriptor*) (cast(char*)tdd + szd);
+    tdcpp.hash = 0;
+    tdcpp.spare = null;
+    memcpy(tdcpp.name.ptr, ".PAV".ptr, 4);
+    memcpy(tdcpp.name.ptr + 4, name.ptr, name.length);
+    memcpy(tdcpp.name.ptr + 4 + name.length, "@D@@".ptr, 5);
+
+    auto ct = cast(CatchableType*) xmalloc(2 * CatchableType.sizeof);
+    ct[0] = CatchableType(CT_IsSimpleType, tdd,   PMD(0, -1, 0), 4, null);
+    ct[1] = CatchableType(CT_IsSimpleType, tdcpp, PMD(0, -1, 0), 4, null);
 
-    size_t sz = TypeDescriptor!1.sizeof + ti.name.length;
-    auto td = cast(TypeDescriptor!1*) malloc(sz);
-    if (!td)
-        onOutOfMemoryError();
-
-    td.hash = 0;
-    td.spare = null;
-    td.name.ptr[0] = 'D';
-    memcpy(td.name.ptr + 1, ti.name.ptr, ti.name.length);
-    td.name.ptr[ti.name.length + 1] = 0;
-
-    CatchableType ct = { CT_IsSimpleType, td, { 0, -1, 0 }, 4, null };
     catchableHashtab[ti] = ct;
-    return ti in catchableHashtab;
-}
-
-CatchableType* createCxxCatchableType(string cxxMangledName)
-{
-    size_t sz = TypeDescriptor!1.sizeof + cxxMangledName.length;
-    auto td = cast(TypeDescriptor!1*) malloc(sz);
-    if (!td)
-        onOutOfMemoryError();
-
-    td.hash = 0;
-    td.spare = null;
-    memcpy(td.name.ptr, cxxMangledName.ptr, cxxMangledName.length);
-    td.name.ptr[cxxMangledName.length + 1] = 0;
-
-    CatchableType* pct = cast(CatchableType*) malloc(CatchableType.sizeof);
-    if (!pct)
-        onOutOfMemoryError();
-    CatchableType ct = { CT_IsSimpleType, td, { 0, -1, 0 }, 4, null };
-    *pct = ct;
-    return pct;
+    return ct;
 }
 
 ///////////////////////////////////////////////////////////////
@@ -338,9 +320,7 @@ private:
     {
         // alloc from GC? add array as a GC range?
         immutable ncap = _cap ? 2 * _cap : 64;
-        auto p = cast(Throwable*)malloc(ncap * Throwable.sizeof);
-        if (p is null)
-            onOutOfMemoryError();
+        auto p = cast(Throwable*)xmalloc(ncap * Throwable.sizeof);
         p[0 .. _length] = _p[0 .. _length];
         free(_p);
         _p = p;
@@ -530,7 +510,6 @@ extern(C) int* __processing_throw() nothrow;
 
 extern(C) void* _d_eh_swapContext(FiberContext* newContext) nothrow
 {
-    import rt.util.container.common : xmalloc;
     import core.stdc.string : memset;
     if (!fiberContext)
     {
@@ -577,11 +556,6 @@ void msvc_eh_init()
 {
     throwInfoMutex = new Mutex;
 
-    // predefine CatchableTypes for C++ interop
-    ctCxxDThrowable = createCxxCatchableType(".PAVException@D@@");
-    ctCxxDException = createCxxCatchableType(".PAVException@D@@");
-    ctCxxDError = createCxxCatchableType(".PAVException@D@@");
-
     // preallocate type descriptors likely to be needed
     getThrowInfo(typeid(Exception));
     // better not have to allocate when this is thrown: