mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-04-26 16:06:07 +00:00
Code Issues Projects Releases Wiki Activity
llvm-project/libc/cmake/modules/LLVMLibCObjectRules.cmake
Joseph Huber 2dc60b4ea4 [libc] Use LTO for AMDGPU compilation and linking 
Summary:
The AMDGPU ABI isn't stable or well defined. For that reson we prefer to
rely on LTO to ensure that multiple files get linked correctly.
Currently the internal targets used for testing mix LLVM-IR and
assembly. We should be consistent here.
2023-03-29 14:20:44 -05:00

819 lines
28 KiB
CMake
Raw Blame History

set(OBJECT_LIBRARY_TARGET_TYPE "OBJECT_LIBRARY")
function(_get_common_compile_options output_var flags)
list(FIND flags ${FMA_OPT_FLAG} fma)
if(${fma} LESS 0)
list(FIND flags "${FMA_OPT_FLAG}__ONLY" fma)
endif()
if((${fma} GREATER -1) AND (LIBC_CPU_FEATURES MATCHES "FMA"))
set(ADD_FMA_FLAG TRUE)
endif()
list(FIND flags ${ROUND_OPT_FLAG} round)
if(${round} LESS 0)
list(FIND flags "${ROUND_OPT_FLAG}__ONLY" round)
endif()
if((${round} GREATER -1) AND (LIBC_CPU_FEATURES MATCHES "SSE4_2"))
set(ADD_SSE4_2_FLAG TRUE)
endif()
set(compile_options ${LIBC_COMPILE_OPTIONS_DEFAULT} ${ARGN})
if(LLVM_COMPILER_IS_GCC_COMPATIBLE)
list(APPEND compile_options "-fpie")
list(APPEND compile_options "-ffreestanding")
list(APPEND compile_options "-fno-builtin")
list(APPEND compile_options "-fno-exceptions")
list(APPEND compile_options "-fno-lax-vector-conversions")
list(APPEND compile_options "-fno-unwind-tables")
list(APPEND compile_options "-fno-asynchronous-unwind-tables")
list(APPEND compile_options "-fno-rtti")
list(APPEND compile_options "-Wall")
list(APPEND compile_options "-Wextra")
list(APPEND compile_options "-Wimplicit-fallthrough")
list(APPEND compile_options "-Wwrite-strings")
list(APPEND compile_options "-Wextra-semi")
if(NOT CMAKE_COMPILER_IS_GNUCXX)
list(APPEND compile_options "-Wnewline-eof")
list(APPEND compile_options "-Wnonportable-system-include-path")
list(APPEND compile_options "-Wstrict-prototypes")
list(APPEND compile_options "-Wthread-safety")
endif()
if(ADD_FMA_FLAG)
list(APPEND compile_options "-mavx2")
list(APPEND compile_options "-mfma")
endif()
if(ADD_SSE4_2_FLAG)
list(APPEND compile_options "-msse4.2")
endif()
elseif(MSVC)
list(APPEND compile_options "/EHs-c-")
list(APPEND compile_options "/GR-")
if(ADD_FMA_FLAG)
list(APPEND compile_options "/arch:AVX2")
endif()
endif()
if (LIBC_TARGET_ARCHITECTURE_IS_GPU)
list(APPEND compile_options "-nogpulib")
list(APPEND compile_options "-fvisibility=hidden")
endif()
set(${output_var} ${compile_options} PARENT_SCOPE)
endfunction()
# Builds the object target for the GPU.
# This compiles the target for all supported architectures and embeds it into
# host binary for installing. The internal target contains the GPU code directly
# compiled for a single architecture used internally.
# Usage:
# _build_gpu_objects(
# <target_name>
# <internal_target_name>
# SRCS <list of .cpp files>
# HDRS <list of .h files>
# DEPENDS <list of dependencies>
# COMPILE_OPTIONS <optional list of special compile options for this target>
# FLAGS <optional list of flags>
# )
function(_build_gpu_objects fq_target_name internal_target_name)
cmake_parse_arguments(
"ADD_GPU_OBJ"
"" # No optional arguments
"NAME;CXX_STANDARD" # Single value arguments
"SRCS;HDRS;DEPENDS;COMPILE_OPTIONS;FLAGS" # Multi value arguments
${ARGN}
)
set(include_dirs ${LIBC_BUILD_DIR}/include ${LIBC_SOURCE_DIR} ${LIBC_BUILD_DIR})
set(common_compile_options ${ADD_GPU_OBJ_COMPILE_OPTIONS})
foreach(add_gpu_obj_src ${ADD_GPU_OBJ_SRCS})
# The packaged version will be built for every target GPU architecture. We do
# this so we can support multiple accelerators on the same machine.
foreach(gpu_arch ${LIBC_GPU_ARCHITECTURES})
get_filename_component(src_name ${add_gpu_obj_src} NAME)
set(gpu_target_name ${fq_target_name}.${src_name}.${gpu_arch})
set(compile_options ${ADD_GPU_OBJ_COMPILE_OPTIONS})
# Derive the triple from the specified architecture.
if("${gpu_arch}" IN_LIST all_amdgpu_architectures)
set(gpu_target_triple "amdgcn-amd-amdhsa")
list(APPEND compile_options "-mcpu=${gpu_arch}")
elseif("${gpu_arch}" IN_LIST all_nvptx_architectures)
set(gpu_target_triple "nvptx64-nvidia-cuda")
list(APPEND compile_options "-march=${gpu_arch}")
else()
message(FATAL_ERROR "Unknown GPU architecture '${gpu_arch}'")
endif()
list(APPEND compile_options "--target=${gpu_target_triple}")
list(APPEND compile_options "-emit-llvm")
# Build the library for this target architecture. We always emit LLVM-IR for
# packaged GPU binaries.
add_library(${gpu_target_name}
EXCLUDE_FROM_ALL
OBJECT
${add_gpu_obj_src}
${ADD_GPU_OBJ_HDRS}
)
target_compile_options(${gpu_target_name} PRIVATE ${compile_options})
target_include_directories(${gpu_target_name} PRIVATE ${include_dirs})
target_compile_definitions(${gpu_target_name} PRIVATE LIBC_COPT_PUBLIC_PACKAGING)
if(ADD_GPU_OBJ_DEPENDS)
add_dependencies(${gpu_target_name} ${ADD_GPU_OBJ_DEPENDS})
endif()
# Append this target to a list of images to package into a single binary.
set(input_file $<TARGET_OBJECTS:${gpu_target_name}>)
list(APPEND packager_images
--image=file=${input_file},arch=${gpu_arch},triple=${gpu_target_triple})
list(APPEND gpu_target_names ${gpu_target_name})
endforeach()
# After building the target for the desired GPUs we must package the output
# into a fatbinary, see https://clang.llvm.org/docs/OffloadingDesign.html for
# more information.
set(packaged_target_name ${fq_target_name}.${src_name}.__gpu__)
set(packaged_output_name ${CMAKE_CURRENT_BINARY_DIR}/${fq_target_name}.${src_name}.gpubin)
add_custom_command(OUTPUT ${packaged_output_name}
COMMAND ${LIBC_CLANG_OFFLOAD_PACKAGER}
${packager_images} -o ${packaged_output_name}
DEPENDS ${gpu_target_names} ${add_gpu_obj_src} ${ADD_GPU_OBJ_HDRS}
COMMENT "Packaging LLVM offloading binary")
add_custom_target(${packaged_target_name} DEPENDS ${packaged_output_name})
list(APPEND packaged_gpu_names ${packaged_target_name})
list(APPEND packaged_gpu_binaries ${packaged_output_name})
endforeach()
# We create an empty 'stub' file for the host to contain the embedded device
# code. This will be packaged into 'libcgpu.a'.
# TODO: In the future we will want to combine every architecture for a target
# into a single bitcode file and use that. For now we simply build for
# every single one and let the offloading linker handle it.
string(FIND ${fq_target_name} "." last_dot_loc REVERSE)
math(EXPR name_loc "${last_dot_loc} + 1")
string(SUBSTRING ${fq_target_name} ${name_loc} -1 target_name)
set(stub_filename "${target_name}.cpp")
add_custom_command(
OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/stubs/${stub_filename}"
COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/stubs/
COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/stubs/${stub_filename}
DEPENDS ${gpu_target_names} ${ADD_GPU_OBJ_SRCS} ${ADD_GPU_OBJ_HDRS}
)
set(stub_target_name ${fq_target_name}.__stub__)
add_custom_target(${stub_target_name} DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/stubs/${stub_filename})
add_library(
${fq_target_name}
# We want an object library as the objects will eventually get packaged into
# an archive (like libcgpu.a).
EXCLUDE_FROM_ALL
OBJECT
${CMAKE_CURRENT_BINARY_DIR}/stubs/${stub_filename}
)
target_compile_options(${fq_target_name} BEFORE PRIVATE
${common_compile_options} -nostdlib)
foreach(packaged_gpu_binary ${packaged_gpu_binaries})
target_compile_options(${fq_target_name} PRIVATE
"SHELL:-Xclang -fembed-offload-object=${packaged_gpu_binary}")
endforeach()
target_include_directories(${fq_target_name} PRIVATE ${include_dirs})
add_dependencies(${fq_target_name}
${full_deps_list} ${packaged_gpu_names} ${stub_target_name})
# We only build the internal target for a single supported architecture.
if(LIBC_GPU_TARGET_ARCHITECTURE_IS_AMDGPU OR
LIBC_GPU_TARGET_ARCHITECTURE_IS_NVPTX)
add_library(
${internal_target_name}
EXCLUDE_FROM_ALL
OBJECT
${ADD_GPU_OBJ_SRCS}
${ADD_GPU_OBJ_HDRS}
)
target_compile_options(${internal_target_name} BEFORE PRIVATE
${common_compile_options} --target=${LIBC_GPU_TARGET_TRIPLE})
if(LIBC_GPU_TARGET_ARCHITECTURE_IS_AMDGPU)
target_compile_options(${internal_target_name} PRIVATE -mcpu=${LIBC_GPU_TARGET_ARCHITECTURE} -flto)
elseif(LIBC_GPU_TARGET_ARCHITECTURE_IS_NVPTX)
target_compile_options(${internal_target_name} PRIVATE -march=${LIBC_GPU_TARGET_ARCHITECTURE})
endif()
target_include_directories(${internal_target_name} PRIVATE ${include_dirs})
if(full_deps_list)
add_dependencies(${internal_target_name} ${full_deps_list})
endif()
endif()
endfunction()
# Rule which is essentially a wrapper over add_library to compile a set of
# sources to object files.
# Usage:
# add_object_library(
# <target_name>
# HDRS <list of header files>
# SRCS <list of source files>
# [ALIAS] <If this object library is an alias for another object library.>
# DEPENDS <list of dependencies; Should be a single item for ALIAS libraries>
# COMPILE_OPTIONS <optional list of special compile options for this target>
# FLAGS <optional list of flags>
function(create_object_library fq_target_name)
cmake_parse_arguments(
"ADD_OBJECT"
"ALIAS;NO_GPU_BUNDLE" # optional arguments
"CXX_STANDARD" # Single value arguments
"SRCS;HDRS;COMPILE_OPTIONS;DEPENDS;FLAGS" # Multivalue arguments
${ARGN}
)
get_fq_deps_list(fq_deps_list ${ADD_OBJECT_DEPENDS})
if(ADD_OBJECT_ALIAS)
if(ADD_OBJECT_SRCS OR ADD_OBJECT_HDRS)
message(FATAL_ERROR
"${fq_target_name}: object library alias cannot have SRCS and/or HDRS.")
endif()
list(LENGTH fq_deps_list depends_size)
if(NOT ${depends_size} EQUAL 1)
message(FATAL_ERROR
"${fq_targe_name}: object library alias should have exactly one DEPENDS.")
endif()
add_library(
${fq_target_name}
ALIAS
${fq_deps_list}
)
return()
endif()
if(NOT ADD_OBJECT_SRCS)
message(FATAL_ERROR "'add_object_library' rule requires SRCS to be specified.")
endif()
# The GPU build uses a separate internal file.
if(LIBC_TARGET_ARCHITECTURE_IS_GPU AND NOT ${ADD_OBJECT_NO_GPU_BUNDLE})
set(internal_target_name ${fq_target_name}.__internal__)
else()
set(internal_target_name ${fq_target_name})
endif()
_get_common_compile_options(
compile_options
"${ADD_OBJECT_FLAGS}"
${ADD_OBJECT_COMPILE_OPTIONS}
)
# GPU builds require special handling for the objects because we want to
# export several different targets at once, e.g. for both Nvidia and AMD.
if(LIBC_TARGET_ARCHITECTURE_IS_GPU AND NOT ${ADD_OBJECT_NO_GPU_BUNDLE})
_build_gpu_objects(
${fq_target_name}
${internal_target_name}
SRCS ${ADD_OBJECT_SRCS}
HDRS ${ADD_OBJECT_HDRS}
DEPENDS ${fq_deps_list}
COMPILE_OPTIONS ${compile_options}
)
else()
add_library(
${fq_target_name}
EXCLUDE_FROM_ALL
OBJECT
${ADD_OBJECT_SRCS}
${ADD_OBJECT_HDRS}
)
target_include_directories(
${fq_target_name}
PRIVATE
${LIBC_BUILD_DIR}/include
${LIBC_SOURCE_DIR}
${LIBC_BUILD_DIR}
)
target_compile_options(${fq_target_name} PRIVATE ${compile_options})
endif()
if(SHOW_INTERMEDIATE_OBJECTS)
message(STATUS "Adding object library ${fq_target_name}")
if(${SHOW_INTERMEDIATE_OBJECTS} STREQUAL "DEPS")
foreach(dep IN LISTS ADD_OBJECT_DEPENDS)
message(STATUS " ${fq_target_name} depends on ${dep}")
endforeach()
endif()
endif()
if(fq_deps_list)
add_dependencies(${fq_target_name} ${fq_deps_list})
endif()
if(NOT ADD_OBJECT_CXX_STANDARD)
set(ADD_OBJECT_CXX_STANDARD ${CMAKE_CXX_STANDARD})
endif()
set_target_properties(
${fq_target_name}
PROPERTIES
TARGET_TYPE ${OBJECT_LIBRARY_TARGET_TYPE}
CXX_STANDARD ${ADD_OBJECT_CXX_STANDARD}
DEPS "${fq_deps_list}"
FLAGS "${ADD_OBJECT_FLAGS}"
)
if(TARGET ${internal_target_name})
set_target_properties(
${fq_target_name}
PROPERTIES
OBJECT_FILES "$<TARGET_OBJECTS:${internal_target_name}>"
)
endif()
endfunction(create_object_library)
# Internal function, used by `add_object_library`.
function(expand_flags_for_object_library target_name flags)
cmake_parse_arguments(
"EXPAND_FLAGS"
"IGNORE_MARKER" # Optional arguments
"" # Single-value arguments
"DEPENDS;FLAGS" # Multi-value arguments
${ARGN}
)
list(LENGTH flags nflags)
if(NOT ${nflags})
create_object_library(
${target_name}
DEPENDS ${EXPAND_FLAGS_DEPENDS}
FLAGS ${EXPAND_FLAGS_FLAGS}
${EXPAND_FLAGS_UNPARSED_ARGUMENTS}
)
return()
endif()
list(GET flags 0 flag)
list(REMOVE_AT flags 0)
extract_flag_modifier(${flag} real_flag modifier)
if(NOT "${modifier}" STREQUAL "NO")
expand_flags_for_object_library(
${target_name}
"${flags}"
DEPENDS "${EXPAND_FLAGS_DEPENDS}" IGNORE_MARKER
FLAGS "${EXPAND_FLAGS_FLAGS}" IGNORE_MARKER
"${EXPAND_FLAGS_UNPARSED_ARGUMENTS}"
)
endif()
if("${real_flag}" STREQUAL "" OR "${modifier}" STREQUAL "ONLY")
return()
endif()
set(NEW_FLAGS ${EXPAND_FLAGS_FLAGS})
list(REMOVE_ITEM NEW_FLAGS ${flag})
get_fq_dep_list_without_flag(NEW_DEPS ${real_flag} ${EXPAND_FLAGS_DEPENDS})
# Only target with `flag` has `.__NO_flag` target, `flag__NO` and
# `flag__ONLY` do not.
if("${modifier}" STREQUAL "")
set(TARGET_NAME "${target_name}.__NO_${flag}")
else()
set(TARGET_NAME "${target_name}")
endif()
expand_flags_for_object_library(
${TARGET_NAME}
"${flags}"
DEPENDS "${NEW_DEPS}" IGNORE_MARKER
FLAGS "${NEW_FLAGS}" IGNORE_MARKER
"${EXPAND_FLAGS_UNPARSED_ARGUMENTS}"
)
endfunction(expand_flags_for_object_library)
function(add_object_library target_name)
cmake_parse_arguments(
"ADD_TO_EXPAND"
"" # Optional arguments
"" # Single value arguments
"DEPENDS;FLAGS" # Multi-value arguments
${ARGN}
)
get_fq_target_name(${target_name} fq_target_name)
if(ADD_TO_EXPAND_DEPENDS AND ("${SHOW_INTERMEDIATE_OBJECTS}" STREQUAL "DEPS"))
message(STATUS "Gathering FLAGS from dependencies for ${fq_target_name}")
endif()
get_fq_deps_list(fq_deps_list ${ADD_TO_EXPAND_DEPENDS})
get_flags_from_dep_list(deps_flag_list ${fq_deps_list})
list(APPEND ADD_TO_EXPAND_FLAGS ${deps_flag_list})
remove_duplicated_flags("${ADD_TO_EXPAND_FLAGS}" flags)
list(SORT flags)
if(SHOW_INTERMEDIATE_OBJECTS AND flags)
message(STATUS "Object library ${fq_target_name} has FLAGS: ${flags}")
endif()
expand_flags_for_object_library(
${fq_target_name}
"${flags}"
DEPENDS "${fq_deps_list}" IGNORE_MARKER
FLAGS "${flags}" IGNORE_MARKER
${ADD_TO_EXPAND_UNPARSED_ARGUMENTS}
)
endfunction(add_object_library)
set(ENTRYPOINT_OBJ_TARGET_TYPE "ENTRYPOINT_OBJ")
# A rule for entrypoint object targets.
# Usage:
# add_entrypoint_object(
# <target_name>
# [ALIAS|REDIRECTED] # Specified if the entrypoint is redirected or an alias.
# [NAME] <the C name of the entrypoint if different from target_name>
# SRCS <list of .cpp files>
# HDRS <list of .h files>
# DEPENDS <list of dependencies>
# COMPILE_OPTIONS <optional list of special compile options for this target>
# SPECIAL_OBJECTS <optional list of special object targets added by the rule `add_object`>
# FLAGS <optional list of flags>
# )
function(create_entrypoint_object fq_target_name)
cmake_parse_arguments(
"ADD_ENTRYPOINT_OBJ"
"ALIAS;REDIRECTED" # Optional argument
"NAME;CXX_STANDARD" # Single value arguments
"SRCS;HDRS;DEPENDS;COMPILE_OPTIONS;FLAGS" # Multi value arguments
${ARGN}
)
list(FIND TARGET_ENTRYPOINT_NAME_LIST ${ADD_ENTRYPOINT_OBJ_NAME} entrypoint_name_index)
if(${entrypoint_name_index} EQUAL -1)
add_custom_target(${fq_target_name})
set_target_properties(
${fq_target_name}
PROPERTIES
"ENTRYPOINT_NAME" ${ADD_ENTRYPOINT_OBJ_NAME}
"TARGET_TYPE" ${ENTRYPOINT_OBJ_TARGET_TYPE}
"OBJECT_FILE" ""
"OBJECT_FILE_RAW" ""
"DEPS" ""
"SKIPPED" "YES"
)
if(LIBC_CMAKE_VERBOSE_LOGGING)
message(STATUS "Skipping libc entrypoint ${fq_target_name}.")
endif()
return()
endif()
if(ADD_ENTRYPOINT_OBJ_ALIAS)
# Alias targets help one add aliases to other entrypoint object targets.
# One can use alias targets setup OS/machine independent entrypoint targets.
list(LENGTH ADD_ENTRYPOINT_OBJ_DEPENDS deps_size)
if(NOT (${deps_size} EQUAL "1"))
message(FATAL_ERROR "An entrypoint alias should have exactly one dependency.")
endif()
list(GET ADD_ENTRYPOINT_OBJ_DEPENDS 0 dep_target)
get_fq_dep_name(fq_dep_name ${dep_target})
if(SHOW_INTERMEDIATE_OBJECTS)
message(STATUS "Adding entrypoint object ${fq_target_name} as an alias of"
" ${fq_dep_name}")
endif()
if(NOT TARGET ${fq_dep_name})
message(WARNING "Aliasee ${fq_dep_name} for entrypoint alias ${target_name} missing; "
"Target ${target_name} will be ignored.")
return()
endif()
get_target_property(obj_type ${fq_dep_name} "TARGET_TYPE")
if((NOT obj_type) OR (NOT (${obj_type} STREQUAL ${ENTRYPOINT_OBJ_TARGET_TYPE})))
message(FATAL_ERROR "The aliasee of an entrypoint alias should be an entrypoint.")
endif()
add_custom_target(${fq_target_name})
add_dependencies(${fq_target_name} ${fq_dep_name})
get_target_property(object_file ${fq_dep_name} "OBJECT_FILE")
get_target_property(object_file_raw ${fq_dep_name} "OBJECT_FILE_RAW")
set_target_properties(
${fq_target_name}
PROPERTIES
ENTRYPOINT_NAME ${ADD_ENTRYPOINT_OBJ_NAME}
TARGET_TYPE ${ENTRYPOINT_OBJ_TARGET_TYPE}
IS_ALIAS "YES"
OBJECT_FILE ""
OBJECT_FILE_RAW ""
DEPS "${fq_dep_name}"
FLAGS "${ADD_ENTRYPOINT_OBJ_FLAGS}"
)
return()
endif()
if(NOT ADD_ENTRYPOINT_OBJ_SRCS)
message(FATAL_ERROR "`add_entrypoint_object` rule requires SRCS to be specified.")
endif()
if(NOT ADD_ENTRYPOINT_OBJ_HDRS)
message(FATAL_ERROR "`add_entrypoint_object` rule requires HDRS to be specified.")
endif()
if(NOT ADD_ENTRYPOINT_OBJ_CXX_STANDARD)
set(ADD_ENTRYPOINT_OBJ_CXX_STANDARD ${CMAKE_CXX_STANDARD})
endif()
_get_common_compile_options(
common_compile_options
"${ADD_ENTRYPOINT_OBJ_FLAGS}"
${ADD_ENTRYPOINT_OBJ_COMPILE_OPTIONS}
)
set(internal_target_name ${fq_target_name}.__internal__)
set(include_dirs ${LIBC_BUILD_DIR}/include ${LIBC_SOURCE_DIR} ${LIBC_BUILD_DIR})
get_fq_deps_list(fq_deps_list ${ADD_ENTRYPOINT_OBJ_DEPENDS})
set(full_deps_list ${fq_deps_list} libc.src.__support.common)
if(SHOW_INTERMEDIATE_OBJECTS)
message(STATUS "Adding entrypoint object ${fq_target_name}")
if(${SHOW_INTERMEDIATE_OBJECTS} STREQUAL "DEPS")
foreach(dep IN LISTS ADD_OBJECT_DEPENDS)
message(STATUS " ${fq_target_name} depends on ${dep}")
endforeach()
endif()
endif()
# GPU builds require special handling for the objects because we want to
# export several different targets at once, e.g. for both Nvidia and AMD.
if(LIBC_TARGET_ARCHITECTURE_IS_GPU)
_build_gpu_objects(
${fq_target_name}
${internal_target_name}
SRCS ${ADD_ENTRYPOINT_OBJ_SRCS}
HDRS ${ADD_ENTRYPOINT_OBJ_HDRS}
COMPILE_OPTIONS ${common_compile_options}
DEPENDS ${full_deps_list}
FLAGS "${ADD_ENTRYPOINT_OBJ_FLAGS}"
)
else()
add_library(
${internal_target_name}
# TODO: We don't need an object library for internal consumption.
# A future change should switch this to a normal static library.
EXCLUDE_FROM_ALL
OBJECT
${ADD_ENTRYPOINT_OBJ_SRCS}
${ADD_ENTRYPOINT_OBJ_HDRS}
)
target_compile_options(${internal_target_name} BEFORE PRIVATE ${common_compile_options})
target_include_directories(${internal_target_name} PRIVATE ${include_dirs})
add_dependencies(${internal_target_name} ${full_deps_list})
add_library(
${fq_target_name}
# We want an object library as the objects will eventually get packaged into
# an archive (like libc.a).
EXCLUDE_FROM_ALL
OBJECT
${ADD_ENTRYPOINT_OBJ_SRCS}
${ADD_ENTRYPOINT_OBJ_HDRS}
)
target_compile_options(${fq_target_name} BEFORE PRIVATE ${common_compile_options} -DLIBC_COPT_PUBLIC_PACKAGING)
target_include_directories(${fq_target_name} PRIVATE ${include_dirs})
add_dependencies(${fq_target_name} ${full_deps_list})
endif()
set_target_properties(
${fq_target_name}
PROPERTIES
ENTRYPOINT_NAME ${ADD_ENTRYPOINT_OBJ_NAME}
TARGET_TYPE ${ENTRYPOINT_OBJ_TARGET_TYPE}
OBJECT_FILE "$<TARGET_OBJECTS:${fq_target_name}>"
CXX_STANDARD ${ADD_ENTRYPOINT_OBJ_CXX_STANDARD}
DEPS "${fq_deps_list}"
FLAGS "${ADD_ENTRYPOINT_OBJ_FLAGS}"
)
if(TARGET ${internal_target_name})
set_target_properties(
${internal_target_name}
PROPERTIES
CXX_STANDARD ${ADD_ENTRYPOINT_OBJ_CXX_STANDARD}
FLAGS "${ADD_ENTRYPOINT_OBJ_FLAGS}"
)
set_target_properties(
${fq_target_name}
PROPERTIES
# TODO: We don't need to list internal object files if the internal
# target is a normal static library.
OBJECT_FILE_RAW "$<TARGET_OBJECTS:${internal_target_name}>"
)
endif()
if(LLVM_LIBC_ENABLE_LINTING AND TARGET ${internal_target_name})
if(NOT LLVM_LIBC_CLANG_TIDY)
message(FATAL_ERROR "Something is wrong! LLVM_LIBC_ENABLE_LINTING is "
"ON but LLVM_LIBC_CLANG_TIDY is not set.")
endif()
# We only want a second invocation of clang-tidy to run
# restrict-system-libc-headers if the compiler-resource-dir was set in
# order to prevent false-positives due to a mismatch between the host
# compiler and the compiled clang-tidy.
if(COMPILER_RESOURCE_DIR)
# We run restrict-system-libc-headers with --system-headers to prevent
# transitive inclusion through compler provided headers.
set(restrict_system_headers_check_invocation
COMMAND ${LLVM_LIBC_CLANG_TIDY} --system-headers
--checks="-*,llvmlibc-restrict-system-libc-headers"
# We explicitly set the resource dir here to match the
# resource dir of the host compiler.
"--extra-arg=-resource-dir=${COMPILER_RESOURCE_DIR}"
--quiet
-p ${PROJECT_BINARY_DIR}
${ADD_ENTRYPOINT_OBJ_SRCS}
)
else()
set(restrict_system_headers_check_invocation
COMMAND ${CMAKE_COMMAND} -E echo "Header file check skipped")
endif()
add_custom_target(
${fq_target_name}.__lint__
# --quiet is used to surpress warning statistics from clang-tidy like:
# Suppressed X warnings (X in non-user code).
# There seems to be a bug in clang-tidy where by even with --quiet some
# messages from clang's own diagnostics engine leak through:
# X warnings generated.
# Until this is fixed upstream, we use -fno-caret-diagnostics to surpress
# these.
COMMAND ${LLVM_LIBC_CLANG_TIDY}
"--extra-arg=-fno-caret-diagnostics" --quiet
# Path to directory containing compile_commands.json
-p ${PROJECT_BINARY_DIR}
${ADD_ENTRYPOINT_OBJ_SRCS}
# See above: this might be a second invocation of clang-tidy depending on
# the conditions above.
${restrict_system_headers_check_invocation}
# We have two options for running commands, add_custom_command and
# add_custom_target. We don't want to run the linter unless source files
# have changed. add_custom_target explicitly runs everytime therefore we
# use add_custom_command. This function requires an output file and since
# linting doesn't produce a file, we create a dummy file using a
# crossplatform touch.
COMMENT "Linting... ${fq_target_name}"
DEPENDS ${internal_target_name} ${ADD_ENTRYPOINT_OBJ_SRCS}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)
add_dependencies(libc-lint ${fq_target_name}.__lint__)
endif()
endfunction(create_entrypoint_object)
# Internal function, used by `add_entrypoint_object`.
function(expand_flags_for_entrypoint_object target_name flags)
cmake_parse_arguments(
"EXPAND_FLAGS"
"IGNORE_MARKER" # Optional arguments
"" # Single-value arguments
"DEPENDS;FLAGS" # Multi-value arguments
${ARGN}
)
list(LENGTH flags nflags)
if(NOT ${nflags})
create_entrypoint_object(
${target_name}
DEPENDS ${EXPAND_FLAGS_DEPENDS}
FLAGS ${EXPAND_FLAGS_FLAGS}
${EXPAND_FLAGS_UNPARSED_ARGUMENTS}
)
return()
endif()
list(GET flags 0 flag)
list(REMOVE_AT flags 0)
extract_flag_modifier(${flag} real_flag modifier)
if(NOT "${modifier}" STREQUAL "NO")
expand_flags_for_entrypoint_object(
${target_name}
"${flags}"
DEPENDS "${EXPAND_FLAGS_DEPENDS}" IGNORE_MARKER
FLAGS "${EXPAND_FLAGS_FLAGS}" IGNORE_MARKER
"${EXPAND_FLAGS_UNPARSED_ARGUMENTS}"
)
endif()
if("${real_flag}" STREQUAL "" OR "${modifier}" STREQUAL "ONLY")
return()
endif()
set(NEW_FLAGS ${EXPAND_FLAGS_FLAGS})
list(REMOVE_ITEM NEW_FLAGS ${flag})
get_fq_dep_list_without_flag(NEW_DEPS ${real_flag} ${EXPAND_FLAGS_DEPENDS})
# Only target with `flag` has `.__NO_flag` target, `flag__NO` and
# `flag__ONLY` do not.
if("${modifier}" STREQUAL "")
set(TARGET_NAME "${target_name}.__NO_${flag}")
else()
set(TARGET_NAME "${target_name}")
endif()
expand_flags_for_entrypoint_object(
${TARGET_NAME}
"${flags}"
DEPENDS "${NEW_DEPS}" IGNORE_MARKER
FLAGS "${NEW_FLAGS}" IGNORE_MARKER
"${EXPAND_FLAGS_UNPARSED_ARGUMENTS}"
)
endfunction(expand_flags_for_entrypoint_object)
function(add_entrypoint_object target_name)
cmake_parse_arguments(
"ADD_TO_EXPAND"
"" # Optional arguments
"NAME" # Single value arguments
"DEPENDS;FLAGS" # Multi-value arguments
${ARGN}
)
get_fq_target_name(${target_name} fq_target_name)
if(ADD_TO_EXPAND_DEPENDS AND ("${SHOW_INTERMEDIATE_OBJECTS}" STREQUAL "DEPS"))
message(STATUS "Gathering FLAGS from dependencies for ${fq_target_name}")
endif()
get_fq_deps_list(fq_deps_list ${ADD_TO_EXPAND_DEPENDS})
get_flags_from_dep_list(deps_flag_list ${fq_deps_list})
list(APPEND ADD_TO_EXPAND_FLAGS ${deps_flag_list})
remove_duplicated_flags("${ADD_TO_EXPAND_FLAGS}" flags)
list(SORT flags)
if(SHOW_INTERMEDIATE_OBJECTS AND flags)
message(STATUS "Entrypoint object ${fq_target_name} has FLAGS: ${flags}")
endif()
if(NOT ADD_TO_EXPAND_NAME)
set(ADD_TO_EXPAND_NAME ${target_name})
endif()
expand_flags_for_entrypoint_object(
${fq_target_name}
"${flags}"
NAME ${ADD_TO_EXPAND_NAME} IGNORE_MARKER
DEPENDS "${fq_deps_list}" IGNORE_MARKER
FLAGS "${flags}" IGNORE_MARKER
${ADD_TO_EXPAND_UNPARSED_ARGUMENTS}
)
endfunction(add_entrypoint_object)
set(ENTRYPOINT_EXT_TARGET_TYPE "ENTRYPOINT_EXT")
# A rule for external entrypoint targets.
# Usage:
# add_entrypoint_external(
# <target_name>
# DEPENDS <list of dependencies>
# )
function(add_entrypoint_external target_name)
cmake_parse_arguments(
"ADD_ENTRYPOINT_EXT"
"" # No optional arguments
"" # No single value arguments
"DEPENDS" # Multi value arguments
${ARGN}
)
get_fq_target_name(${target_name} fq_target_name)
set(entrypoint_name ${target_name})
add_custom_target(${fq_target_name})
set_target_properties(
${fq_target_name}
PROPERTIES
"ENTRYPOINT_NAME" ${entrypoint_name}
"TARGET_TYPE" ${ENTRYPOINT_EXT_TARGET_TYPE}
"DEPS" "${ADD_ENTRYPOINT_EXT_DEPENDS}"
)
endfunction(add_entrypoint_external)
# Rule build a redirector object file.
function(add_redirector_object target_name)
cmake_parse_arguments(
"REDIRECTOR_OBJECT"
"" # No optional arguments
"SRC" # The cpp file in which the redirector is defined.
"" # No multivalue arguments
${ARGN}
)
if(NOT REDIRECTOR_OBJECT_SRC)
message(FATAL_ERROR "'add_redirector_object' rule requires SRC option listing one source file.")
endif()
add_library(
${target_name}
EXCLUDE_FROM_ALL
OBJECT
${REDIRECTOR_OBJECT_SRC}
)
target_compile_options(
${target_name}
BEFORE PRIVATE -fPIC ${LIBC_COMPILE_OPTIONS_DEFAULT}
)
endfunction(add_redirector_object)
Reference in New Issue View Git Blame Copy Permalink