64-bit OSX: Mangle [u]long as C++ [u]int64_t

This is a breaking ABI change and affects LDC itself as mixed D/C++ code
base. So we now need to check the front-end version of the D host
compiler and adapt the corresponding C++ types accordingly.

Author: kinke

CMakeLists.txt

@@ -417,6 +417,7 @@ append("-DOPAQUE_VTBLS" LDC_CXXFLAGS)
 append("\"-DLDC_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}\"" LDC_CXXFLAGS)
 append("-DLDC_LLVM_VER=${LDC_LLVM_VER}" LDC_CXXFLAGS)
 append("\"-DLDC_LIBDIR_SUFFIX=\\\"${LIB_SUFFIX}\\\"\"" LDC_CXXFLAGS)
+append("-DLDC_HOST_FE_VER=${D_COMPILER_FE_VERSION}" LDC_CXXFLAGS)
 
 if(GENERATE_OFFTI)
     append("-DGENERATE_OFFTI" LDC_CXXFLAGS)

cmake/Modules/FindDCompiler.cmake

@@ -8,6 +8,7 @@
 #  D_COMPILER_FLAGS    - D compiler flags (could be passed in the DMD environment variable)
 #  D_COMPILER_ID       = {"DigitalMars", "LDMD", "LDC", "GDC"}
 #  D_COMPILER_VERSION_STRING - String containing the compiler version, e.g. "DMD64 D Compiler v2.070.2"
+#  D_COMPILER_FE_VERSION - compiler front-end version, e.g. "2070"
 #  D_COMPILER_DMD_COMPAT - true if the D compiler cmdline interface is compatible with DMD
 
 
@@ -64,13 +65,16 @@ if (D_COMPILER)
                     OUTPUT_VARIABLE D_COMPILER_VERSION_STRING
                     ERROR_VARIABLE D_COMPILER_VERSION_STRING
                     ERROR_QUIET)
+    string(REGEX MATCH " (D Compiler|based on DMD) v([0-9]+)\\.([0-9]+)" D_COMPILER_FE_VERSION "${D_COMPILER_VERSION_STRING}")
+    math(EXPR D_COMPILER_FE_VERSION ${CMAKE_MATCH_2}*1000+${CMAKE_MATCH_3}) # e.g., 2079
     string(REGEX MATCH "^[^\r\n:]*" D_COMPILER_VERSION_STRING "${D_COMPILER_VERSION_STRING}")
 endif()
 
 
 if (D_COMPILER_FOUND)
     message(STATUS "Found host D compiler ${D_COMPILER}, with default flags '${D_COMPILER_FLAGS}'")
     message(STATUS "Host D compiler version: ${D_COMPILER_VERSION_STRING}")
+    message(STATUS "Host D compiler front-end version: ${D_COMPILER_FE_VERSION}")
 else()
     message(FATAL_ERROR "No D compiler found! Try setting the 'D_COMPILER' variable or 'DMD' environment variable.")
 endif()

dmd/globals.h

@@ -330,6 +330,11 @@ struct Global
 
 extern Global global;
 
+#if LDC_HOST_FE_VER >= 2079
+typedef uint64_t dinteger_t;
+typedef int64_t sinteger_t;
+typedef uint64_t uinteger_t;
+#else
 // Because int64_t and friends may be any integral type of the
 // correct size, we have to explicitly ask for the correct
 // integer type to get the correct mangling with dmd
@@ -346,6 +351,7 @@ typedef unsigned long long dinteger_t;
 typedef long long sinteger_t;
 typedef unsigned long long uinteger_t;
 #endif
+#endif
 
 typedef int8_t                  d_int8;
 typedef uint8_t                 d_uns8;

dmd/identifier.h

@@ -38,7 +38,7 @@ class Identifier : public RootObject
     static StringTable stringtable;
     static Identifier *generateId(const char *prefix);
     static Identifier *generateId(const char *prefix, size_t i);
-    static Identifier *idPool(const char *s, size_t len);
+    static Identifier *idPool(const char *s, d_size_t len);
 
     static inline Identifier *idPool(const char *s)
     {

dmd/root/rmem.h

@@ -10,15 +10,16 @@
 #ifndef ROOT_MEM_H
 #define ROOT_MEM_H
 
-#include <stddef.h>     // for size_t
+#include <stdint.h>
 
-#if __APPLE__ && __i386__
-    /* size_t is 'unsigned long', which makes it mangle differently
-     * than D's 'uint'
-     */
-    typedef unsigned d_size_t;
+#if __LP64__ || _M_X64
+#if LDC_HOST_FE_VER >= 2079 || _M_X64
+typedef uint64_t d_size_t;
 #else
-    typedef size_t d_size_t;
+typedef unsigned long d_size_t;
+#endif
+#else
+typedef uint32_t d_size_t;
 #endif
 
 struct Mem

driver/cache_pruning.h

@@ -10,14 +10,10 @@
 #ifndef LDC_DRIVER_IR2OBJ_CACHE_PRUNING_H
 #define LDC_DRIVER_IR2OBJ_CACHE_PRUNING_H
 
-#if __LP64__
-using d_ulong = unsigned long;
-#else
-using d_ulong = unsigned long long;
-#endif
+#include "globals.h"
 
-void pruneCache(const char *cacheDirectoryPtr, size_t cacheDirectoryLen,
+void pruneCache(const char *cacheDirectoryPtr, d_size_t cacheDirectoryLen,
                 uint32_t pruneIntervalSeconds, uint32_t expireIntervalSeconds,
-                d_ulong sizeLimitBytes, uint32_t sizeLimitPercentage);
+                uinteger_t sizeLimitBytes, uint32_t sizeLimitPercentage);
 
 #endif