mirror of
https://github.com/xomboverlord/ldc.git
synced 2026-01-11 18:33:14 +01:00
74d7562a59
This makes much more sense since the subdirecotry also contains the build system for them, and reduces clutter.
352 lines
13 KiB
CMake
352 lines
13 KiB
CMake
project(runtime)
|
|
|
|
cmake_minimum_required(VERSION 2.6)
|
|
|
|
#
|
|
# Main configuration.
|
|
#
|
|
|
|
if(D_VERSION EQUAL 1)
|
|
message(FATAL_ERROR "Please use bob to build Tango for D1.")
|
|
endif()
|
|
|
|
include(CheckTypeSize)
|
|
check_type_size(void* ptr_size)
|
|
|
|
if(${ptr_size} MATCHES "^8$") ## if it's 64-bit OS
|
|
set(MULTILIB OFF CACHE BOOL "Build both 64-bit and 32-bit libraries")
|
|
ENDIF(${ptr_size} MATCHES "^8$")
|
|
|
|
set(BUILD_BC_LIBS OFF CACHE BOOL "Build the runtime as bytecode libraries")
|
|
set(BUILD_SINGLE_LIB ON CACHE BOOL "Build single runtime library")
|
|
set(LIB_SUFFIX "" CACHE STRING "Takes an empty string or 64. Directory where lib will be installed: lib or lib64")
|
|
set(INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/include/d CACHE PATH "Directory where will be put header files")
|
|
set(BUILD_SHARED_LIBS OFF CACHE BOOL "Build as shared library or as static library")
|
|
set(CMAKE_INSTALL_LIBDIR ${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX} CACHE PATH "Directory where lib will be installed")
|
|
set(D_FLAGS -g -w -d CACHE STRING "runtime build flags, separated by ;")
|
|
|
|
if(BUILD_SHARED_LIBS)
|
|
list(APPEND D_FLAGS -relocation-model=pic)
|
|
set(D_LIBRARY_TYPE SHARED)
|
|
else(BUILD_SHARED_LIBS)
|
|
set(D_LIBRARY_TYPE STATIC)
|
|
set(CXX_COMPILE_FLAGS " ")
|
|
endif(BUILD_SHARED_LIBS)
|
|
|
|
get_directory_property(PROJECT_PARENT_DIR DIRECTORY ${PROJECT_SOURCE_DIR} PARENT_DIRECTORY)
|
|
set(RUNTIME_DIR ${PROJECT_SOURCE_DIR}/druntime CACHE PATH "runtime source dir")
|
|
|
|
#
|
|
# Gather source files.
|
|
#
|
|
|
|
set(PHOBOS2_DIR ${PROJECT_SOURCE_DIR}/phobos CACHE PATH "phobos2 source dir")
|
|
set(RUNTIME_CC druntime-core)
|
|
set(RUNTIME_GC druntime-gc-basic)
|
|
set(RUNTIME_DC druntime-rt-ldc)
|
|
set(RUNTIME_AIO ldruntime)
|
|
set(RUNTIME_DC_DIR ${RUNTIME_DIR}/src/rt)
|
|
set(RUNTIME_GC_DIR ${RUNTIME_DIR}/src/gc)
|
|
set(RUNTIME_INCLUDE ${RUNTIME_DIR}/src)
|
|
file(GLOB CORE_D ${RUNTIME_DIR}/src/core/*.d )
|
|
file(GLOB CORE_D_SYNC ${RUNTIME_DIR}/src/core/sync/*.d )
|
|
file(GLOB CORE_D_STDC ${RUNTIME_DIR}/src/core/stdc/*.d )
|
|
file(GLOB_RECURSE GC_D ${RUNTIME_GC_DIR}/*.d)
|
|
file(GLOB_RECURSE DCRT_D ${RUNTIME_DC_DIR}/*.d)
|
|
file(GLOB_RECURSE LDC_D ${RUNTIME_DIR}/src/ldc/*.d)
|
|
list(REMOVE_ITEM DCRT_D
|
|
${RUNTIME_DC_DIR}/alloca.d
|
|
${RUNTIME_DC_DIR}/arraybyte.d
|
|
${RUNTIME_DC_DIR}/arraycast.d
|
|
${RUNTIME_DC_DIR}/arraycat.d
|
|
${RUNTIME_DC_DIR}/arraydouble.d
|
|
${RUNTIME_DC_DIR}/arrayfloat.d
|
|
${RUNTIME_DC_DIR}/arrayreal.d
|
|
${RUNTIME_DC_DIR}/arrayshort.d
|
|
${RUNTIME_DC_DIR}/critical_.d
|
|
${RUNTIME_DC_DIR}/deh.d
|
|
${RUNTIME_DC_DIR}/deh2.d
|
|
${RUNTIME_DC_DIR}/llmath.d
|
|
${RUNTIME_DC_DIR}/qsort2.d
|
|
${RUNTIME_DC_DIR}/trace.d
|
|
)
|
|
file(GLOB DCRT_C ${RUNTIME_DC_DIR}/*.c)
|
|
list(REMOVE_ITEM DCRT_C ${RUNTIME_DC_DIR}/deh.c ${RUNTIME_DC_DIR}/memory_osx.c ${RUNTIME_DC_DIR}/dylib_fixes.c)
|
|
if(UNIX)
|
|
file(GLOB_RECURSE CORE_D_SYS ${RUNTIME_DIR}/src/core/sys/posix/*.d)
|
|
elseif(WIN32)
|
|
file(GLOB_RECURSE CORE_D_SYS ${RUNTIME_DIR}/src/core/sys/windows/*.d)
|
|
elseif(APPLE)
|
|
file(GLOB_RECURSE CORE_D_SYS ${RUNTIME_DIR}/src/core/sys/osx/*.d)
|
|
endif(UNIX)
|
|
list(APPEND CORE_D ${CORE_D_SYNC} ${CORE_D_SYS} ${CORE_D_STDC} )
|
|
list(APPEND GENERATE_DI ${CORE_D})
|
|
list(APPEND CORE_D ${LDC_D} ${RUNTIME_DIR}/src/object_.d)
|
|
file(GLOB CORE_C ${RUNTIME_DIR}/src/core/stdc/*.c)
|
|
|
|
if(PHOBOS2_DIR)
|
|
file(GLOB PHOBOS2_D ${PHOBOS2_DIR}/std/*.d)
|
|
file(GLOB_RECURSE PHOBOS2_D_INTERNAL ${PHOBOS2_DIR}/std/internal/*.d)
|
|
file(GLOB PHOBOS2_D_C ${PHOBOS2_DIR}/std/c/*.d)
|
|
if(UNIX)
|
|
file(GLOB PHOBOS2_D_C_SYS ${PHOBOS2_DIR}/std/c/linux/*.d)
|
|
elseif(WIN32)
|
|
file(GLOB PHOBOS2_D_C_SYS ${PHOBOS2_DIR}/std/c/windows/*.d)
|
|
elseif(APPLE)
|
|
file(GLOB PHOBOS2_D_C_SYS ${PHOBOS2_DIR}/std/c/osx/*.d)
|
|
endif(UNIX)
|
|
file(GLOB ZLIB_C ${PHOBOS2_DIR}/etc/c/zlib/*.c)
|
|
list(REMOVE_ITEM ZLIB_C
|
|
${PHOBOS2_DIR}/etc/c/zlib/minigzip.c
|
|
${PHOBOS2_DIR}/etc/c/zlib/example.c
|
|
${PHOBOS2_DIR}/etc/c/zlib/gzio.c
|
|
)
|
|
if(WIN32)
|
|
file(GLOB PHOBOS2_D_WIN ${PHOBOS2_DIR}/std/windows/*.d)
|
|
endif(WIN32)
|
|
list(APPEND PHOBOS2_D
|
|
${PHOBOS2_D_INTERNAL}
|
|
${PHOBOS2_D_WIN}
|
|
${PHOBOS2_D_C}
|
|
${PHOBOS2_D_C_SYS}
|
|
${PHOBOS2_DIR}/etc/c/zlib.d
|
|
${PHOBOS2_DIR}/crc32.d
|
|
)
|
|
list(REMOVE_ITEM PHOBOS2_D
|
|
${PHOBOS2_DIR}/std/intrinsic.d
|
|
)
|
|
set(CONFIG_NAME ${LDC_EXE}_phobos)
|
|
else(PHOBOS2_DIR)
|
|
set(CONFIG_NAME ${LDC_EXE})
|
|
endif(PHOBOS2_DIR)
|
|
|
|
# should only be necessary if run independently from ldc cmake project
|
|
if(NOT LDC_LOC)
|
|
if(NOT LDC_EXE)
|
|
set(LDC_EXE ldc2)
|
|
endif(NOT LDC_EXE)
|
|
|
|
find_program(LDC_LOC ${LDC_EXE} ${PROJECT_BINARY_DIR}/../bin DOC "path to ldc binary")
|
|
if(NOT LDC_LOC)
|
|
message(SEND_ERROR "ldc not found")
|
|
endif(NOT LDC_LOC)
|
|
set(LDC_EXE_NAME ${LDC_EXE})
|
|
endif(NOT LDC_LOC)
|
|
|
|
#
|
|
# Create configuration files.
|
|
#
|
|
|
|
if(MULTILIB)
|
|
set(MUTILIB_ADDITIONAL_PATH "\n \"-L-L${CMAKE_BINARY_DIR}/lib32\",")
|
|
set(MUTILIB_ADDITIONAL_INSTALL_PATH "\n \"-L-L${CMAKE_INSTALL_PREFIX}/lib32\",")
|
|
endif(MULTILIB)
|
|
|
|
configure_file(${PROJECT_PARENT_DIR}/${CONFIG_NAME}.conf.in ${PROJECT_BINARY_DIR}/../bin/${LDC_EXE}.conf)
|
|
# Prepare the config files for installation in bin.
|
|
configure_file(${PROJECT_PARENT_DIR}/${LDC_EXE}_install.conf.in ${PROJECT_BINARY_DIR}/../bin/${LDC_EXE}_install.conf)
|
|
configure_file(${PROJECT_PARENT_DIR}/${LDC_EXE}.rebuild.conf.in ${PROJECT_BINARY_DIR}/../bin/${LDC_EXE}_install.rebuild.conf)
|
|
|
|
#
|
|
# Macros.
|
|
#
|
|
|
|
macro(dc INPUT_D OUTLIST_O OUTLIST_BC MOREFLAGS PATH SUFFIX)
|
|
if ("${PATH}" STREQUAL "")
|
|
file(RELATIVE_PATH output ${RUNTIME_DIR} ${INPUT_D})
|
|
else ("${PATH}" STREQUAL "")
|
|
file(RELATIVE_PATH output ${PATH} ${INPUT_D})
|
|
endif ("${PATH}" STREQUAL "")
|
|
get_filename_component(name ${output} NAME_WE)
|
|
get_filename_component(path ${output} PATH)
|
|
if ("${path}" STREQUAL "")
|
|
set(output ${name})
|
|
else ("${path}" STREQUAL "")
|
|
set(output ${path}/${name})
|
|
endif ("${path}" STREQUAL "")
|
|
set(OUTPUT_O ${PROJECT_BINARY_DIR}/${output}${SUFFIX}.o)
|
|
set(OUTPUT_BC ${PROJECT_BINARY_DIR}/${output}${SUFFIX}.bc)
|
|
list(APPEND ${OUTLIST_O} ${OUTPUT_O})
|
|
list(APPEND ${OUTLIST_BC} ${OUTPUT_BC})
|
|
|
|
list(FIND GENERATE_DI "${INPUT_D}" INDEX)
|
|
if (INDEX EQUAL -1)
|
|
set(DI_CMD "")
|
|
else (INDEX EQUAL -1)
|
|
string(REGEX REPLACE "src/ldc" "src/core" output ${output})
|
|
string(REGEX REPLACE "^src/" "" di_output ${output})
|
|
set(DI_CMD -Hf=${CMAKE_BINARY_DIR}/import/${di_output}.di)
|
|
list(REMOVE_AT GENERATE_DI ${INDEX})
|
|
endif (INDEX EQUAL -1)
|
|
|
|
# Compile
|
|
add_custom_command(
|
|
OUTPUT
|
|
${OUTPUT_O}
|
|
${OUTPUT_BC}
|
|
COMMAND ${LDC_LOC} --output-o --output-bc -c -I${RUNTIME_INCLUDE} -I${RUNTIME_GC_DIR} ${INPUT_D} -of${OUTPUT_O} ${DI_CMD} ${D_FLAGS} ${MOREFLAGS}
|
|
WORKING_DIRECTORY ${PROJECT_PARENT_DIR}
|
|
DEPENDS ${LDC_LOC}
|
|
${INPUT_D}
|
|
${LDC_IMPORTS}
|
|
${PROJECT_BINARY_DIR}/../bin/${LDC_EXE}.conf
|
|
)
|
|
endmacro(dc)
|
|
|
|
macro(build_runtime d_flags c_flags ld_flags lib_suffix path_suffix)
|
|
set(output_path ${CMAKE_BINARY_DIR}/lib${path_suffix})
|
|
|
|
set(target_suffix "")
|
|
if(NOT "${lib_suffix}" STREQUAL "")
|
|
set(target_suffix "_${lib_suffix}")
|
|
endif(NOT "${lib_suffix}" STREQUAL "")
|
|
if(NOT "${path_suffix}" STREQUAL "")
|
|
set(target_suffix "${target_suffix}_${path_suffix}")
|
|
endif(NOT "${path_suffix}" STREQUAL "")
|
|
|
|
set(CORE_O "")
|
|
set(CORE_BC "")
|
|
foreach(f ${CORE_D})
|
|
dc(${f} CORE_O CORE_BC "${d_flags};-disable-invariants" "" "${target_suffix}")
|
|
endforeach(f)
|
|
|
|
set(GC_O "")
|
|
set(GC_BC "")
|
|
foreach(f ${GC_D})
|
|
dc(${f} GC_O GC_BC "${d_flags};-disable-invariants" "" "${target_suffix}")
|
|
endforeach(f)
|
|
|
|
set(DCRT_O "")
|
|
set(DCRT_BC "")
|
|
foreach(f ${DCRT_D})
|
|
dc(${f} DCRT_O DCRT_BC "${d_flags}" "" "${target_suffix}")
|
|
endforeach(f)
|
|
|
|
if(EXISTS ${RUNTIME_DIR})
|
|
if(BUILD_SINGLE_LIB)
|
|
add_library(${RUNTIME_AIO}${target_suffix}
|
|
${D_LIBRARY_TYPE}
|
|
${CORE_O}
|
|
${CORE_C}
|
|
${GC_O}
|
|
${DCRT_O}
|
|
${DCRT_C}
|
|
)
|
|
set(LIBS ${RUNTIME_AIO})
|
|
set_target_properties(${RUNTIME_AIO}${target_suffix} PROPERTIES OUTPUT_NAME ${RUNTIME_AIO}${lib_suffix})
|
|
else(BUILD_SINGLE_LIB)
|
|
add_library(${RUNTIME_CC}${target_suffix} ${D_LIBRARY_TYPE} ${CORE_O} ${CORE_C})
|
|
add_library(${RUNTIME_GC}${target_suffix} ${D_LIBRARY_TYPE} ${GC_O})
|
|
add_library(${RUNTIME_DC}${target_suffix} ${D_LIBRARY_TYPE} ${DCRT_O} ${DCRT_C})
|
|
set_target_properties(${RUNTIME_CC}${target_suffix} PROPERTIES OUTPUT_NAME ${RUNTIME_CC}${lib_suffix})
|
|
set_target_properties(${RUNTIME_GC}${target_suffix} PROPERTIES OUTPUT_NAME ${RUNTIME_GC}${lib_suffix})
|
|
set_target_properties(${RUNTIME_DC}${target_suffix} PROPERTIES OUTPUT_NAME ${RUNTIME_DC}${lib_suffix})
|
|
set(LIBS
|
|
${RUNTIME_CC}${lib_suffix}
|
|
${RUNTIME_GC}${lib_suffix}
|
|
${RUNTIME_DC}${lib_suffix}
|
|
)
|
|
endif(BUILD_SINGLE_LIB)
|
|
endif()
|
|
|
|
if(BUILD_BC_LIBS)
|
|
find_program(LLVM_AR_EXE llvm-ar ${LLVM_INSTDIR}/bin DOC "path to llvm-ar tool")
|
|
if(NOT LLVM_AR_EXE)
|
|
message(SEND_ERROR "llvm-ar not found")
|
|
endif(NOT LLVM_AR_EXE)
|
|
|
|
add_library(${RUNTIME_CC}-c ${CORE_C})
|
|
add_library(${RUNTIME_DC}-c ${DCRT_C})
|
|
list(APPEND LIBS
|
|
${RUNTIME_CC}-c
|
|
${RUNTIME_DC}-c
|
|
)
|
|
add_custom_command(
|
|
OUTPUT bclibs
|
|
COMMAND ${LLVM_AR_EXE} rs lib${RUNTIME_CC}-bc.a ${CORE_BC}
|
|
COMMAND ${LLVM_AR_EXE} rs lib${RUNTIME_GC}-bc.a ${GC_BC}
|
|
# cannot parse genobj.bc if built with -g
|
|
# COMMAND ${LLVM_AR_EXE} rs lib${RUNTIME_DC}-bc.a ${DCRT_BC}
|
|
WORKING_DIRECTORY ${output_path}
|
|
DEPENDS
|
|
${CORE_BC}
|
|
${GC_BC}
|
|
${DCRT_BC}
|
|
${LDC_IMPORTS}
|
|
)
|
|
set(BCLIBS bclibs)
|
|
endif(BUILD_BC_LIBS)
|
|
|
|
set_target_properties(
|
|
${LIBS} PROPERTIES
|
|
LINKER_LANGUAGE C
|
|
ARCHIVE_OUTPUT_DIRECTORY ${output_path}
|
|
LIBRARY_OUTPUT_DIRECTORY ${output_path}
|
|
RUNTIME_OUTPUT_DIRECTORY ${output_path}
|
|
COMPILE_FLAGS "${c_flags}"
|
|
LINK_FLAGS "${ld_flags}"
|
|
)
|
|
install(TARGETS ${LIBS} DESTINATION ${CMAKE_INSTALL_PREFIX}/lib${path_suffix})
|
|
|
|
# BCLIBS is empty if BUILD_BC_LIBS is not selected
|
|
add_custom_target(runtime${target_suffix} DEPENDS ${LIBS} ${BCLIBS})
|
|
|
|
if(PHOBOS2_DIR)
|
|
set(PHOBOS2_O "")
|
|
set(PHOBOS2_BC "")
|
|
foreach(f ${PHOBOS2_D})
|
|
dc(${f} PHOBOS2_O PHOBOS2_BC "${d_flags};-I${PHOBOS2_DIR}" ${PHOBOS2_DIR} "${target_suffix}")
|
|
endforeach(f)
|
|
|
|
add_library(lphobos2${target_suffix} ${D_LIBRARY_TYPE}
|
|
${ZLIB_C}
|
|
${PHOBOS2_O}
|
|
${CORE_O}
|
|
${CORE_C}
|
|
${GC_O}
|
|
${DCRT_O}
|
|
${DCRT_C}
|
|
)
|
|
add_dependencies(lphobos2${target_suffix} runtime)
|
|
set_target_properties(
|
|
lphobos2${target_suffix} PROPERTIES
|
|
OUTPUT_NAME lphobos2${lib_suffix}
|
|
LINKER_LANGUAGE C
|
|
ARCHIVE_OUTPUT_DIRECTORY ${output_path}
|
|
LIBRARY_OUTPUT_DIRECTORY ${output_path}
|
|
RUNTIME_OUTPUT_DIRECTORY ${output_path}
|
|
COMPILE_FLAGS "${c_flags}"
|
|
LINK_FLAGS "${ld_flags}"
|
|
)
|
|
install(TARGETS lphobos2${target_suffix} DESTINATION ${CMAKE_INSTALL_PREFIX}/lib${path_suffix})
|
|
add_dependencies(phobos2 DEPENDS lphobos2${target_suffix})
|
|
endif(PHOBOS2_DIR)
|
|
endmacro(build_runtime d_flags c_flags ld_flags lib_suffix path_suffix)
|
|
|
|
#
|
|
# Set up build targets.
|
|
#
|
|
|
|
if(PHOBOS2_DIR)
|
|
add_custom_target(phobos2)
|
|
endif(PHOBOS2_DIR)
|
|
build_runtime("" "" "" "" "${LIB_SUFFIX}")
|
|
set(GENERATE_DI "")
|
|
if(MULTILIB)
|
|
build_runtime("-m32" "-m32" "-m32" "" "32")
|
|
endif(MULTILIB)
|
|
|
|
#
|
|
# Install target.
|
|
#
|
|
|
|
install(DIRECTORY ${CMAKE_BINARY_DIR}/import/core DESTINATION ${INCLUDE_INSTALL_DIR} FILES_MATCHING PATTERN "*.di")
|
|
if(PHOBOS2_DIR)
|
|
install(DIRECTORY ${PHOBOS2_DIR}/std DESTINATION ${INCLUDE_INSTALL_DIR} FILES_MATCHING PATTERN "*.d")
|
|
install(DIRECTORY ${PHOBOS2_DIR}/etc DESTINATION ${INCLUDE_INSTALL_DIR} FILES_MATCHING PATTERN "*.d")
|
|
install(FILES ${PHOBOS2_DIR}/crc32.d DESTINATION ${INCLUDE_INSTALL_DIR})
|
|
endif(PHOBOS2_DIR)
|
|
install(FILES ${RUNTIME_DIR}/import/object.di DESTINATION ${INCLUDE_INSTALL_DIR}/ldc)
|
|
install(FILES ${RUNTIME_DIR}/src/ldc/bitop.d DESTINATION ${INCLUDE_INSTALL_DIR}/core)
|
|
install(DIRECTORY ${RUNTIME_DIR}/import/ldc DESTINATION ${INCLUDE_INSTALL_DIR} FILES_MATCHING PATTERN "*.di")
|