Instead of using the C++-linker, use the D compiler to link LDC2 and LDMD

CMakeLists.txt

@@ -114,69 +114,24 @@ set(DDMD_DFLAGS "-wi")
 if(CMAKE_BUILD_TYPE MATCHES Debug)
     append("-g" DDMD_DFLAGS)
 else()
-    append("-O -release" DDMD_DFLAGS)
-endif()
-set(Dcode_LDFLAGS)
-get_filename_component(D_COMPILER_REALPATH "${D_COMPILER}" REALPATH)
-get_filename_component(D_COMPILER_PATH "${D_COMPILER_REALPATH}" PATH)
-if (WIN32)
-    STRING(REGEX REPLACE "/" "\\\\" D_COMPILER_PATH "${D_COMPILER_PATH}")
+    # Default to a Release build type
+    append("-O -inline -release" DDMD_DFLAGS)
 endif()
 
-if(APPLE)
-    if(${D_COMPILER_ID} STREQUAL "DigitalMars")
-        append("-L${D_COMPILER_PATH}/../lib" Dcode_LDFLAGS)
-        append("-lphobos2" Dcode_LDFLAGS)
-    elseif(${D_COMPILER_ID} STREQUAL "LDMD")
-        append("-L${D_COMPILER_PATH}/../lib" Dcode_LDFLAGS)
-        append("-lphobos2-ldc" Dcode_LDFLAGS)
-        append("-ldruntime-ldc" Dcode_LDFLAGS)
-        append("-ldl -lpthread -lm" Dcode_LDFLAGS)
-    else()
-        message(WARNING "Compiler ID not supported: probably not good!")
-    endif()
-elseif(UNIX AND NOT APPLE)
-    if(${D_COMPILER_ID} STREQUAL "DigitalMars")
-        append("-L${D_COMPILER_PATH}/../lib64" Dcode_LDFLAGS)
-        append("-L${D_COMPILER_PATH}/../lib32" Dcode_LDFLAGS)
-        append("-lphobos2 -lrt" Dcode_LDFLAGS)
-    elseif(${D_COMPILER_ID} STREQUAL "LDMD")
-        append("-L${D_COMPILER_PATH}/../lib" Dcode_LDFLAGS)
-        append("-lphobos2-ldc" Dcode_LDFLAGS)
-        append("-ldruntime-ldc" Dcode_LDFLAGS)
-        if(CMAKE_SYSTEM_NAME MATCHES ".*BSD" OR CMAKE_SYSTEM_NAME MATCHES "DragonFly")
-            append("-lrt -lpthread -lm" Dcode_LDFLAGS)
-        else()
-            append("-lrt -ldl -lpthread -lm" Dcode_LDFLAGS)
-        endif() 
-    else()
-        message(WARNING "Compiler ID not supported: probably not good!")
-    endif()
-elseif(WIN32)
+if(WIN32)
     if(${D_COMPILER_ID} STREQUAL "DigitalMars")
         if(CMAKE_SIZEOF_VOID_P EQUAL 8)
             message(STATUS "Let DMD output 64bit object files")
             append("-m64" DDMD_DFLAGS)
-            append("${D_COMPILER_PATH}\\..\\lib64\\phobos64.lib" Dcode_LDFLAGS)
         else()
             message(STATUS "Let DMD output 32bit COFF object files")
             append("-m32mscoff" DDMD_DFLAGS)
-            append("${D_COMPILER_PATH}\\..\\lib32mscoff\\phobos32mscoff.lib" Dcode_LDFLAGS)
         endif()
-    elseif(${D_COMPILER_ID} STREQUAL "LDMD")
-        append("${D_COMPILER_PATH}\\..\\lib\\druntime-ldc.lib" Dcode_LDFLAGS)
-        append("${D_COMPILER_PATH}\\..\\lib\\phobos2-ldc.lib" Dcode_LDFLAGS)
-    else()
-        message(WARNING "Compiler ID not supported: probably not good!")
     endif()
-else()
-    message(WARNING "Platform not supported: probably not good!")
-endif()
-if(MSVC)
-    append("legacy_stdio_definitions.lib" Dcode_LDFLAGS)
 endif()
+
+
 append("-J${PROJECT_SOURCE_DIR}/${DDMDFE_PATH}" DDMD_DFLAGS) # Needed for importing text files
-string(STRIP "${Dcode_LDFLAGS}" Dcode_LDFLAGS)
 string(STRIP "${DDMD_DFLAGS}" DDMD_DFLAGS)
 
 # Use separate compiler flags for the frontend and for the LDC-specific parts,
@@ -267,13 +222,6 @@ if(CMAKE_COMPILER_IS_GNUCXX)
     string(REPLACE "-fcolor-diagnostics " "" LLVM_CXXFLAGS ${LLVM_CXXFLAGS})
 endif()
 
-# Issue 1297
-# The default system-allocated stack size is 8MB on Linux and Mac, but only 1MB on Windows
-# Set LDC's stack to 8MB also on Windows:
-if(WIN32)
-    set(WINDOWS_STACK_SIZE "/STACK:8388608")
-endif()
-
 
 # Compiles the given D module into an object file.
 macro(Dcompile  input_d  output_dir  extra_d_flags  outlist_o extra_deps)
@@ -423,12 +371,15 @@ set(DRV_HDR
     driver/toobj.h
     driver/tool.h
 )
-# exclude idgen, dummy_main, and man.d
+# exclude idgen and man.d
 list(REMOVE_ITEM FE_SRC_D
     ${PROJECT_SOURCE_DIR}/${DDMDFE_PATH}/idgen.d
-    ${PROJECT_SOURCE_DIR}/${DDMDFE_PATH}/root/dummy_main.d
     ${PROJECT_SOURCE_DIR}/${DDMDFE_PATH}/root/man.d
 )
+# exclude ldmd.d from ldc
+list(REMOVE_ITEM DRV_SRC_D
+    ${PROJECT_SOURCE_DIR}/driver/ldmd.d
+)
 set(LDC_CXX_SOURCE_FILES
     ${LDC_CXX_GENERATED}
     ${FE_SRC}
@@ -572,23 +523,12 @@ set(TEST_COVERAGE OFF CACHE BOOL "instrument compiler for code coverage analysis
 if(TEST_COVERAGE)
     if(CMAKE_COMPILER_IS_GNUCXX OR (${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang"))
         append("-O0 -g -fprofile-arcs -ftest-coverage" EXTRA_CXXFLAGS)
-        append("--coverage" LLVM_LDFLAGS)
+        append("-lgcov" LLVM_LDFLAGS)
     else()
         message(WARNING "Coverage testing is not available.")
     endif()
 endif()
 
-#
-# Work around a terrible C++-D interop problem on Windows
-# See http://forum.dlang.org/post/caowrljxijchgmyyrtlr@forum.dlang.org
-# ${DMD_DUMMY_MAIN_FOR_EH_SYMBOLS} has to be added to add_executable listing, see e.g. for LDMD
-#
-if (WIN32)
-    Dcompilelib(${DDMDFE_PATH}/root/dummy_main.d ${PROJECT_SOURCE_DIR} ${DDMD_DFLAGS} DMD_DUMMY_MAIN_FOR_EH_SYMBOLS)
-else()
-    set(DMD_DUMMY_MAIN_FOR_EH_SYMBOLS)
-endif()
-
 #
 # Set up the main ldc/ldc2 target.
 #
@@ -598,29 +538,8 @@ else()
     set(LDC_LIB_TYPE STATIC)
 endif()
 
-# build D source in separate lib
-set(LDC_D_LIB LDC_D_Shared)
-foreach(f ${LDC_D_SOURCE_FILES})
-    Dcompile(${f} ${PROJECT_SOURCE_DIR} ${DDMD_DFLAGS} LDC_D_SOURCE_FILES_o "${PROJECT_BINARY_DIR}/${DDMDFE_PATH}/id.d")
-endforeach()
-add_library(${LDC_D_LIB} STATIC ${LDC_D_SOURCE_FILES_o})
-set_target_properties(
-    ${LDC_D_LIB} PROPERTIES
-    LINKER_LANGUAGE CXX
-    RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin
-    LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib
-    ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib
-    ARCHIVE_OUTPUT_NAME ldcD
-    LIBRARY_OUTPUT_NAME ldcD
-    RUNTIME_OUTPUT_NAME ldcD
-    LINK_FLAGS "${Dcode_LDFLAGS} ${SANITIZE_LDFLAGS}"
-)
-if (UNIX)
-    target_link_libraries(${LDC_D_LIB} ${Dcode_LDFLAGS})
-endif()
-
 set(LDC_LIB LDCShared)
-add_library(${LDC_LIB} ${LDC_LIB_TYPE} ${LDC_CXX_SOURCE_FILES})
+add_library(${LDC_LIB} ${LDC_LIB_TYPE} ${LDC_CXX_SOURCE_FILES} ${DRV_SRC} ${DRV_HDR})
 set_target_properties(
     ${LDC_LIB} PROPERTIES
     RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin
@@ -632,7 +551,6 @@ set_target_properties(
     COMPILE_FLAGS "${LLVM_CXXFLAGS} ${EXTRA_CXXFLAGS}"
     LINK_FLAGS "${SANITIZE_LDFLAGS}"
 )
-
 # LDFLAGS should actually be in target property LINK_FLAGS, but this works, and gets around linking problems
 target_link_libraries(${LDC_LIB} ${LLVM_LIBRARIES} ${PTHREAD_LIBS} ${TERMINFO_LIBS} "${LLVM_LDFLAGS}")
 if(WIN32)
@@ -641,16 +559,36 @@ elseif(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
     target_link_libraries(${LDC_LIB} dl)
 endif()
 
+if(WIN32)
+    set(EXECUTABLE_EXTENSION ".exe")
+endif()
+set(LDC_EXE_FULL ${PROJECT_BINARY_DIR}/bin/${LDC_EXE_NAME}${EXECUTABLE_EXTENSION})
+set(LDMD_EXE_FULL ${PROJECT_BINARY_DIR}/bin/${LDMD_EXE_NAME}${EXECUTABLE_EXTENSION})
+add_custom_target(${LDC_EXE} DEPENDS ${LDC_EXE_FULL} ${LDMD_EXE_FULL})
+string (REPLACE ";" " " LDC_LINKERFLAG_LIST "${SANITIZE_LDFLAGS} ${WINDOWS_STACK_SIZE} ${LIBCONFIG_LIBRARY} ${LLVM_LIBRARIES} ${LLVM_LDFLAGS}")
+string (REPLACE "-Wl," "" LDC_LINKERFLAG_LIST ${LDC_LINKERFLAG_LIST})
+separate_arguments(LDC_LINKERFLAG_LIST WINDOWS_COMMAND ${LDC_LINKERFLAG_LIST})
+set(tempVar "")
+FOREACH(f ${LDC_LINKERFLAG_LIST})
+      append("-L${f}" tempVar)
+ENDFOREACH(f)
+if(WIN32)
+    # Issue 1297
+    # The default system-allocated stack size is 8MB on Linux and Mac, but only 1MB on Windows
+    # Set LDC's stack to 8MB also on Windows:
+    append("-L/STACK:8388608 -L/DEFAULTLIB:msvcrt -L/NODEFAULTLIB:libcmt legacy_stdio_definitions.lib" tempVar)
+else()
+    append("-L-lstdc++" tempVar)
+endif()
 
-add_executable(${LDC_EXE} ${DRV_SRC} ${DRV_HDR})
-set_target_properties(
-    ${LDC_EXE} PROPERTIES
-    OUTPUT_NAME ${LDC_EXE_NAME}
-    RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin
-    COMPILE_FLAGS "${LLVM_CXXFLAGS} ${EXTRA_CXXFLAGS}"
-    LINK_FLAGS "${Dcode_LDFLAGS} ${SANITIZE_LDFLAGS} ${WINDOWS_STACK_SIZE}"
+separate_arguments(LDC_FLAG_LIST WINDOWS_COMMAND "${tempVar} ${D_COMPILER_FLAGS} ${DDMD_DFLAGS}")
+add_custom_command(
+    OUTPUT ${LDC_EXE_FULL}
+    COMMAND ${D_COMPILER} -L$<TARGET_LINKER_FILE:${LDC_LIB}> ${LDC_FLAG_LIST} -I${PROJECT_SOURCE_DIR}/${DDMDFE_PATH} -of${LDC_EXE_FULL} ${LDC_D_SOURCE_FILES}
+    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+    DEPENDS ${LDC_D_SOURCE_FILES} ${PROJECT_BINARY_DIR}/${DDMDFE_PATH}/id.d ${LDC_LIB} ${LDMD_EXE_FULL}
 )
-target_link_libraries(${LDC_EXE} ${LDC_LIB} ${LDC_D_LIB} ${LDC_LIB} ${LIBCONFIG_LIBRARY} ${PTHREAD_LIBS} ${CMAKE_DL_LIBS} ${TERMINFO_LIBS} ${DMD_DUMMY_MAIN_FOR_EH_SYMBOLS})
+
 
 if(MSVC_IDE)
     # the IDE generator is a multi-config one
@@ -725,26 +663,24 @@ endif()
 
 set_source_files_properties(driver/exe_path.cpp driver/ldmd.cpp driver/response.cpp PROPERTIES
     COMPILE_FLAGS "${LDC_CXXFLAGS} ${LLVM_CXXFLAGS}"
+    COMPILE_DEFINITIONS LDC_EXE_NAME="${LDC_EXE_NAME}"
 )
 
-Dcompile(${DDMDFE_PATH}/root/man.d ${PROJECT_SOURCE_DIR} ${DDMD_DFLAGS} LDMD_D_o "")
-
-add_executable(${LDMD_EXE} driver/exe_path.cpp driver/ldmd.cpp driver/response.cpp driver/exe_path.h ${LDMD_D_o} ${DMD_DUMMY_MAIN_FOR_EH_SYMBOLS})
-set_target_properties(${LDMD_EXE} PROPERTIES
-    LINKER_LANGUAGE CXX
-    COMPILE_DEFINITIONS LDC_EXE_NAME="${LDC_EXE_NAME}"
-    LINK_FLAGS "${Dcode_LDFLAGS} ${SANITIZE_LDFLAGS}"
-    OUTPUT_NAME "${LDMD_EXE_NAME}"
-    RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin
+add_library(LDMD_CXX_LIB ${LDC_LIB_TYPE} driver/exe_path.cpp driver/ldmd.cpp driver/response.cpp driver/exe_path.h)
+set_target_properties(
+    LDMD_CXX_LIB PROPERTIES
+    LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib
+    ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib
+    ARCHIVE_OUTPUT_NAME ldmd
+    LIBRARY_OUTPUT_NAME ldmd
 )
-# Same as above, LLVM_LDFLAGS should really be in LINK_FLAGS, but the LLVM libs
-# use symbols from libdl, ..., so LLVM_LDFLAGS must come _after_ them in the
-# command line. Maybe this could be improved using library groups, at least with
-# GNU ld.
-target_link_libraries(${LDMD_EXE} ${LLVM_LIBRARIES} ${PTHREAD_LIBS} ${TERMINFO_LIBS} ${CMAKE_DL_LIBS} "${LLVM_LDFLAGS}" ${DMD_DUMMY_MAIN_FOR_EH_SYMBOLS})
-if (UNIX)
-    target_link_libraries(${LDMD_EXE} "${Dcode_LDFLAGS}")
-endif()
+add_custom_command(
+    OUTPUT ${LDMD_EXE_FULL}
+    COMMAND ${D_COMPILER} -L$<TARGET_LINKER_FILE:LDMD_CXX_LIB> ${LDC_FLAG_LIST} -I${PROJECT_SOURCE_DIR}/${DDMDFE_PATH} -of${LDMD_EXE_FULL} ${DDMDFE_PATH}/root/man.d driver/ldmd.d
+    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+    DEPENDS LDMD_CXX_LIB ${LDC_LIB}
+)
+
 
 #
 # Test and runtime targets. Note that enable_testing() is order-sensitive!
@@ -760,7 +696,8 @@ add_subdirectory(tests)
 # Install target.
 #
 
-install(TARGETS ${LDC_EXE} ${LDMD_EXE} DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
+install(PROGRAMS ${LDC_EXE_FULL} DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
+install(PROGRAMS ${LDMD_EXE_FULL} DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
 if(${BUILD_SHARED})
     # For now, only install libldc if explicitely building the shared library.
     # While it might theoretically be possible to use LDC as a static library

driver/ldmd.cpp

@@ -1044,7 +1044,10 @@ static size_t addStrlen(size_t acc, const char *str) {
   return acc + strlen(str);
 }
 
-int main(int argc, char *argv[]) {
+// In driver/main.d
+int main(int argc, char **argv);
+
+int cppmain(int argc, char **argv) {
   exe_path::initialize(argv[0], reinterpret_cast<void *>(main));
 
   std::string ldcExeName = LDC_EXE_NAME;

driver/ldmd.d

@@ -0,0 +1,30 @@
+//===-- driver/ldmd.d - General LLVM codegen helpers ----------*- D -*-===//
+//
+//                         LDC – the LLVM D compiler
+//
+// This file is distributed under the BSD-style LDC license. See the LICENSE
+// file for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Startup code for driver/ldmd.cpp
+//
+//===----------------------------------------------------------------------===//
+
+// In driver/ldmd.cpp
+extern(C++) int cppmain(int argc, char **argv);
+
+/+ Having a main() in D-source solves a few issues with building/linking with
+ + DMD on Windows, with the extra benefit of implicitly initializing the D runtime.
+ +/
+int main()
+{
+    // For now, even just the frontend does not work with GC enabled, so we need
+    // to disable it entirely.
+    import core.memory;
+    GC.disable();
+
+    import core.runtime;
+    auto args = Runtime.cArgs();
+    return cppmain(args.argc, cast(char**)args.argv);
+}

driver/main.cpp

@@ -78,7 +78,6 @@ void Lexer_initLexer();
 void gendocfile(Module *m);
 
 // In driver/main.d
-void disableGC();
 void writeModuleDependencyFile();
 
 using namespace opts;
@@ -289,6 +288,7 @@ static void hideLLVMOptions() {
 #endif
 }
 
+// In driver/main.d
 int main(int argc, char **argv);
 
 static const char *tryGetExplicitConfFile(int argc, char **argv) {
@@ -918,18 +918,9 @@ static void emitJson(Modules &modules) {
   }
 }
 
-int main(int argc, char **argv) {
+int cppmain(int argc, char **argv) {
   llvm::sys::PrintStackTraceOnErrorSignal();
 
-  // Initialize the D runtime.
-  // TODO: We might want to call rt_term() using an atexit handler or so to
-  // run module destructors, etc.
-  rt_init();
-
-  // For now, even just the frontend does not work with GC enabled, so we need
-  // to disable it entirely.
-  disableGC();
-
   exe_path::initialize(argv[0], reinterpret_cast<void *>(main));
 
   global._init();

driver/main.d

@@ -17,12 +17,6 @@ import ddmd.globals;
 import ddmd.root.file;
 import ddmd.root.outbuffer;
 
-extern (C++) void disableGC()
-{
-	import core.memory;
-	GC.disable();
-}
-
 extern (C++) void writeModuleDependencyFile()
 {
     if (global.params.moduleDepsFile !is null)
@@ -32,4 +26,22 @@ extern (C++) void writeModuleDependencyFile()
         deps.setbuffer(cast(void*)ob.data, ob.offset);
         deps.write();
     }
-}
+}
+
+// In driver/main.cpp
+extern(C++) int cppmain(int argc, char **argv);
+
+/+ Having a main() in D-source solves a few issues with building/linking with
+ + DMD on Windows, with the extra benefit of implicitly initializing the D runtime.
+ +/
+int main()
+{
+    // For now, even just the frontend does not work with GC enabled, so we need
+    // to disable it entirely.
+    import core.memory;
+    GC.disable();
+
+    import core.runtime;
+    auto args = Runtime.cArgs();
+    return cppmain(args.argc, cast(char**)args.argv);
+}