This is an archive of the discontinued LLVM Phabricator instance.

Differential D77340

[libc] Add fully-qualified target names.
ClosedPublic

Authored by sivachandra on Apr 2 2020, 3:17 PM.

Details

Reviewers
abrachet
PaulkaToast
phosek
Commits
rGe4767a6f1435: [libc] Add fully-qualified target names.
Summary

Only targets setup by the special LLVM libc rules now have fully
qualified names. The naming style is similar to fully qualified names in
Python.

Diff Detail

Event Timeline

sivachandra created this revision.Apr 2 2020, 3:17 PM
Herald added a project: Restricted Project. · View Herald TranscriptApr 2 2020, 3:17 PM
Herald added subscribers: libc-commits, tschuett, MaskRay, mgorny. · View Herald Transcript
sivachandra added a comment.Apr 2 2020, 3:24 PM

This change implements the topic I brought up many weeks ago: http://lists.llvm.org/pipermail/libc-dev/2020-January/000038.html.

It is probably motivated by my personal preference largely driven by my experience working with GN and Bazel. I am open to listening to opinions from others as it does add verbosity to the target names and can be viewed as a development overhead. But, it also eliminates ambiguity in naming targets, and makes it clear and explicit what each target is about when one reads the target names. More importantly, I like the fact the we can now set up directory specific build and run targets as I explained in the above post (for example, test.src.signal.__build__ and test.src.signal.__run__.)

Harbormaster completed remote builds in B51554: Diff 254632.Apr 2 2020, 4:17 PM
abrachet accepted this revision.Apr 3 2020, 3:39 PM

LGTM. I think the shortened name with the . prefix is a little confusing personally, but I can also see how it is useful.

This revision is now accepted and ready to land.Apr 3 2020, 3:39 PM
Closed by commit rGe4767a6f1435: [libc] Add fully-qualified target names. (authored by sivachandra). · Explain WhyApr 10 2020, 6:20 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
libc/
4 lines
cmake/
modules/
164 lines
32 lines
config/
linux/
2 lines
fuzzing/
string/
6 lines
include/
36 lines
lib/
50 lines
loader/
linux/
44 lines
x86_64/
4 lines
src/
__support/
2 lines
assert/
6 lines
signal/
59 lines
linux/
54 lines
stdlib/
15 lines
linux/
6 lines
string/
25 lines
memory_utils/
2 lines
sys/
mman/
16 lines
linux/
16 lines
threads/
35 lines
linux/
50 lines
test/
config/
linux/
x86_64/
3 lines
loader/
22 lines
linux/
14 lines
src/
assert/
8 lines
errno/
2 lines
signal/
70 lines
stdlib/
14 lines
string/
24 lines
memory_utils/
6 lines
sys/
mman/
linux/
10 lines
threads/
30 lines
utils/
UnitTest/
2 lines

Diff 256730

libc/CMakeLists.txt

Show All 17 Lines
string(TOLOWER ${LIBC_TARGET_OS} LIBC_TARGET_OS) string(TOLOWER ${LIBC_TARGET_OS} LIBC_TARGET_OS)
set(LIBC_TARGET_MACHINE ${CMAKE_SYSTEM_PROCESSOR}) set(LIBC_TARGET_MACHINE ${CMAKE_SYSTEM_PROCESSOR})
include(CMakeParseArguments) include(CMakeParseArguments)
include(LLVMLibCRules) include(LLVMLibCRules)
include(LLVMLibCCheckCpuFeatures) include(LLVMLibCCheckCpuFeatures)
add_subdirectory(src)
add_subdirectory(config)
add_subdirectory(include) add_subdirectory(include)
add_subdirectory(config)
add_subdirectory(src)
add_subdirectory(utils) add_subdirectory(utils)
# The loader can potentially depend on the library components so add it # The loader can potentially depend on the library components so add it
# after the library implementation directories. # after the library implementation directories.
add_subdirectory(loader) add_subdirectory(loader)
# The lib and test directories are added at the very end as tests # The lib and test directories are added at the very end as tests
# and libraries potentially draw from the components present in all # and libraries potentially draw from the components present in all
# of the other directories. # of the other directories.
add_subdirectory(lib) add_subdirectory(lib)
if(LLVM_INCLUDE_TESTS) if(LLVM_INCLUDE_TESTS)
add_subdirectory(test) add_subdirectory(test)
add_subdirectory(fuzzing) add_subdirectory(fuzzing)
endif() endif()

libc/cmake/modules/LLVMLibCRules.cmake

include(LLVMLibCTargetNameUtils)
# A rule for self contained header file targets. # A rule for self contained header file targets.
# This rule merely copies the header file from the current source directory to # This rule merely copies the header file from the current source directory to
# the current binary directory. # the current binary directory.
# Usage: # Usage:
# add_header( # add_header(
# <target name> # <target name>
# HDR <header file> # HDR <header file>
# ) # )
function(add_header target_name) function(add_header target_name)
cmake_parse_arguments( cmake_parse_arguments(
"ADD_HEADER" "ADD_HEADER"
"" # No optional arguments "" # No optional arguments
"HDR" # Single value arguments "HDR" # Single value arguments
"DEPENDS" # No multi value arguments "DEPENDS"
${ARGN} ${ARGN}
) )
if(NOT ADD_HEADER_HDR) if(NOT ADD_HEADER_HDR)
message(FATAL_ERROR "'add_header' rules requires the HDR argument specifying a headef file.") message(FATAL_ERROR "'add_header' rules requires the HDR argument specifying a headef file.")
endif() endif()
set(dest_file ${CMAKE_CURRENT_BINARY_DIR}/${ADD_HEADER_HDR}) set(dest_file ${CMAKE_CURRENT_BINARY_DIR}/${ADD_HEADER_HDR})
set(src_file ${CMAKE_CURRENT_SOURCE_DIR}/${ADD_HEADER_HDR}) set(src_file ${CMAKE_CURRENT_SOURCE_DIR}/${ADD_HEADER_HDR})
add_custom_command( add_custom_command(
OUTPUT ${dest_file} OUTPUT ${dest_file}
COMMAND cp ${src_file} ${dest_file} COMMAND cp ${src_file} ${dest_file}
DEPENDS ${src_file} DEPENDS ${src_file}
) )
get_fq_target_name(${target_name} fq_target_name)
add_custom_target( add_custom_target(
${target_name} ${fq_target_name}
DEPENDS ${dest_file} DEPENDS ${dest_file}
) )
if(ADD_HEADER_DEPENDS) if(ADD_HEADER_DEPENDS)
get_fq_deps_list(fq_deps_list ${ADD_HEADER_DEPENDS})
add_dependencies( add_dependencies(
${target_name} ${ADD_HEADER_DEPENDS} ${fq_target_name} ${fq_deps_list}
) )
endif() endif()
endfunction(add_header) endfunction(add_header)
# A rule for generated header file targets. # A rule for generated header file targets.
# Usage: # Usage:
# add_gen_header( # add_gen_header(
# <target name> # <target name>
# DEF_FILE <.h.def file> # DEF_FILE <.h.def file>
Show All 35 Linesfunction(add_gen_header target_name)
add_custom_command( add_custom_command(
OUTPUT ${out_file} OUTPUT ${out_file}
COMMAND $<TARGET_FILE:libc-hdrgen> -o ${out_file} --header ${ADD_GEN_HDR_GEN_HDR} --def ${in_file} ${replacement_params} -I ${LIBC_SOURCE_DIR} ${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/api.td COMMAND $<TARGET_FILE:libc-hdrgen> -o ${out_file} --header ${ADD_GEN_HDR_GEN_HDR} --def ${in_file} ${replacement_params} -I ${LIBC_SOURCE_DIR} ${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/api.td
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
DEPENDS ${in_file} ${fq_data_files} ${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/api.td libc-hdrgen DEPENDS ${in_file} ${fq_data_files} ${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/api.td libc-hdrgen
) )
get_fq_target_name(${target_name} fq_target_name)
if(ADD_GEN_HDR_DEPENDS)
get_fq_deps_list(fq_deps_list ${ADD_GEN_HDR_DEPENDS})
endif()
add_custom_target( add_custom_target(
${target_name} ${fq_target_name}
DEPENDS ${out_file} ${ADD_GEN_HDR_DEPENDS} DEPENDS ${out_file} ${fq_deps_list}
) )
endfunction(add_gen_header) endfunction(add_gen_header)
set(OBJECT_LIBRARY_TARGET_TYPE "OBJECT_LIBRARY") set(OBJECT_LIBRARY_TARGET_TYPE "OBJECT_LIBRARY")
# Rule which is essentially a wrapper over add_library to compile a set of # Rule which is essentially a wrapper over add_library to compile a set of
# sources to object files. # sources to object files.
# Usage: # Usage:
Show All 11 Lines cmake_parse_arguments(
"SRCS;HDRS;COMPILE_OPTIONS;DEPENDS" # Multivalue arguments "SRCS;HDRS;COMPILE_OPTIONS;DEPENDS" # Multivalue arguments
${ARGN} ${ARGN}
) )
if(NOT ADD_OBJECT_SRCS) if(NOT ADD_OBJECT_SRCS)
message(FATAL_ERROR "'add_object_library' rule requires SRCS to be specified.") message(FATAL_ERROR "'add_object_library' rule requires SRCS to be specified.")
endif() endif()
get_fq_target_name(${target_name} fq_target_name)
add_library( add_library(
${target_name} ${fq_target_name}
OBJECT OBJECT
${ADD_OBJECT_SRCS} ${ADD_OBJECT_SRCS}
${ADD_OBJECT_HDRS} ${ADD_OBJECT_HDRS}
) )
target_include_directories( target_include_directories(
${target_name} ${fq_target_name}
PRIVATE PRIVATE
"${LIBC_BUILD_DIR}/include;${LIBC_SOURCE_DIR};${LIBC_BUILD_DIR}" "${LIBC_BUILD_DIR}/include;${LIBC_SOURCE_DIR};${LIBC_BUILD_DIR}"
) )
if(ADD_OBJECT_COMPILE_OPTIONS) if(ADD_OBJECT_COMPILE_OPTIONS)
target_compile_options( target_compile_options(
${target_name} ${fq_target_name}
PRIVATE ${ADD_OBJECT_COMPILE_OPTIONS} PRIVATE ${ADD_OBJECT_COMPILE_OPTIONS}
) )
endif() endif()
set(all_object_files $<TARGET_OBJECTS:${target_name}>) set(all_object_files $<TARGET_OBJECTS:${fq_target_name}>)
if(ADD_OBJECT_DEPENDS) if(ADD_OBJECT_DEPENDS)
get_fq_deps_list(fq_deps_list ${ADD_OBJECT_DEPENDS})
add_dependencies( add_dependencies(
${target_name} ${fq_target_name}
${ADD_OBJECT_DEPENDS} ${fq_deps_list}
) )
foreach(obj_target IN LISTS ADD_OBJECT_DEPENDS) foreach(obj_target IN LISTS fq_deps_list)
if(NOT TARGET ${obj_target}) if(NOT TARGET obj_target)
# Not all targets will be visible. So, we will ignore those which aren't # Not all targets will be visible. So, we will ignore those which aren't
# visible yet. # visible yet.
continue() continue()
endif() endif()
get_target_property(obj_type ${obj_target} "TARGET_TYPE") get_target_property(obj_type ${obj_target} "TARGET_TYPE")
if((NOT obj_type) OR (NOT (${obj_type} STREQUAL ${OBJECT_LIBRARY_TARGET_TYPE}))) if((NOT obj_type) OR (NOT (${obj_type} STREQUAL ${OBJECT_LIBRARY_TARGET_TYPE})))
continue() continue()
endif() endif()
# If a dependency is also a object file library, we will collect the list of # If a dependency is also a object file library, we will collect the list of
# object files from it. # object files from it.
get_target_property(obj_files ${obj_target} "OBJECT_FILES") get_target_property(obj_files ${obj_target} "OBJECT_FILES")
list(APPEND all_object_files ${obj_files}) list(APPEND all_object_files ${obj_files})
endforeach(obj_target) endforeach(obj_target)
endif() endif()
list(REMOVE_DUPLICATES all_object_files) list(REMOVE_DUPLICATES all_object_files)
set_target_properties( set_target_properties(
${target_name} ${fq_target_name}
PROPERTIES PROPERTIES
"TARGET_TYPE" ${OBJECT_LIBRARY_TARGET_TYPE} "TARGET_TYPE" ${OBJECT_LIBRARY_TARGET_TYPE}
"OBJECT_FILES" "${all_object_files}" "OBJECT_FILES" "${all_object_files}"
) )
endfunction(add_object_library) endfunction(add_object_library)
set(ENTRYPOINT_OBJ_TARGET_TYPE "ENTRYPOINT_OBJ") set(ENTRYPOINT_OBJ_TARGET_TYPE "ENTRYPOINT_OBJ")
# A rule for entrypoint object targets. # A rule for entrypoint object targets.
# Usage: # Usage:
# add_entrypoint_object( # add_entrypoint_object(
# <target_name> # <target_name>
# [REDIRECTED] # Specified if the entrypoint is redirected. # [ALIAS|REDIRECTED] # Specified if the entrypoint is redirected or an alias.
# [NAME] <the C name of the entrypoint if different from target_name> # [NAME] <the C name of the entrypoint if different from target_name>
# SRCS <list of .cpp files> # SRCS <list of .cpp files>
# HDRS <list of .h files> # HDRS <list of .h files>
# DEPENDS <list of dependencies> # DEPENDS <list of dependencies>
# COMPILE_OPTIONS <optional list of special compile options for this target> # 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`> # SPECIAL_OBJECTS <optional list of special object targets added by the rule `add_object`>
# ) # )
function(add_entrypoint_object target_name) function(add_entrypoint_object target_name)
cmake_parse_arguments( cmake_parse_arguments(
"ADD_ENTRYPOINT_OBJ" "ADD_ENTRYPOINT_OBJ"
"REDIRECTED" # Optional argument "ALIAS;REDIRECTED" # Optional argument
"NAME" # Single value arguments "NAME" # Single value arguments
"SRCS;HDRS;DEPENDS;COMPILE_OPTIONS" # Multi value arguments "SRCS;HDRS;DEPENDS;COMPILE_OPTIONS" # Multi value arguments
${ARGN} ${ARGN}
) )
get_fq_target_name(${target_name} fq_target_name)
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(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(all_objects ${fq_dep_name} "OBJECT_FILES")
get_target_property(all_objects_raw ${fq_dep_name} "OBJECT_FILES_RAW")
set_target_properties(
${fq_target_name}
PROPERTIES
"TARGET_TYPE" ${ENTRYPOINT_OBJ_TARGET_TYPE}
"OBJECT_FILES" "${all_objects}"
"OBJECT_FILES_RAW" "${all_objects_raw}"
)
return()
endif()
if(NOT ADD_ENTRYPOINT_OBJ_SRCS) if(NOT ADD_ENTRYPOINT_OBJ_SRCS)
message(FATAL_ERROR "`add_entrypoint_object` rule requires SRCS to be specified.") message(FATAL_ERROR "`add_entrypoint_object` rule requires SRCS to be specified.")
endif() endif()
if(NOT ADD_ENTRYPOINT_OBJ_HDRS) if(NOT ADD_ENTRYPOINT_OBJ_HDRS)
message(FATAL_ERROR "`add_entrypoint_object` rule requires HDRS to be specified.") message(FATAL_ERROR "`add_entrypoint_object` rule requires HDRS to be specified.")
endif() endif()
set(entrypoint_name ${target_name}) set(entrypoint_name ${target_name})
if(ADD_ENTRYPOINT_OBJ_NAME) if(ADD_ENTRYPOINT_OBJ_NAME)
set(entrypoint_name ${ADD_ENTRYPOINT_OBJ_NAME}) set(entrypoint_name ${ADD_ENTRYPOINT_OBJ_NAME})
endif() endif()
set(objects_target_name "${fq_target_name}_objects")
add_library( add_library(
"${target_name}_objects" ${objects_target_name}
# We want an object library as the objects will eventually get packaged into # We want an object library as the objects will eventually get packaged into
# an archive (like libc.a). # an archive (like libc.a).
OBJECT OBJECT
${ADD_ENTRYPOINT_OBJ_SRCS} ${ADD_ENTRYPOINT_OBJ_SRCS}
${ADD_ENTRYPOINT_OBJ_HDRS} ${ADD_ENTRYPOINT_OBJ_HDRS}
) )
target_compile_options( target_compile_options(
${target_name}_objects ${objects_target_name}
BEFORE BEFORE
PRIVATE PRIVATE
-fpie ${LLVM_CXX_STD_default} -fpie ${LLVM_CXX_STD_default}
) )
target_include_directories( target_include_directories(
${target_name}_objects ${objects_target_name}
PRIVATE PRIVATE
"${LIBC_BUILD_DIR}/include;${LIBC_SOURCE_DIR};${LIBC_BUILD_DIR}" "${LIBC_BUILD_DIR}/include;${LIBC_SOURCE_DIR};${LIBC_BUILD_DIR}"
) )
add_dependencies( add_dependencies(
${target_name}_objects ${objects_target_name}
support_common_h libc.src.__support.common
) )
set(dep_objects "") set(dep_objects "")
if(ADD_ENTRYPOINT_OBJ_DEPENDS) if(ADD_ENTRYPOINT_OBJ_DEPENDS)
get_fq_deps_list(fq_deps_list ${ADD_ENTRYPOINT_OBJ_DEPENDS})
add_dependencies( add_dependencies(
${target_name}_objects ${objects_target_name}
${ADD_ENTRYPOINT_OBJ_DEPENDS} ${fq_deps_list}
) )
foreach(dep_target IN LISTS ADD_ENTRYPOINT_OBJ_DEPENDS) foreach(dep_target IN LISTS fq_deps_list)
if(NOT TARGET ${dep_target}) if(NOT TARGET ${dep_target})
# Not all targets will be visible. So, we will ignore those which aren't # Not all targets will be visible. So, we will ignore those which aren't
# visible yet. # visible yet.
continue() continue()
endif() endif()
get_target_property(obj_type ${dep_target} "TARGET_TYPE") get_target_property(obj_type ${dep_target} "TARGET_TYPE")
if((NOT obj_type) OR (NOT (${obj_type} STREQUAL ${OBJECT_LIBRARY_TARGET_TYPE}))) if((NOT obj_type) OR (NOT (${obj_type} STREQUAL ${OBJECT_LIBRARY_TARGET_TYPE})))
# Even from among the visible targets, we will collect object files # Even from among the visible targets, we will collect object files
# only from add_object_library targets. # only from add_object_library targets.
continue() continue()
endif() endif()
# Calling get_target_property requires that the target be visible at this # Calling get_target_property requires that the target be visible at this
# point. For object library dependencies, this is a reasonable requirement. # point. For object library dependencies, this is a reasonable requirement.
# We can revisit this in future if we need cases which break under this # We can revisit this in future if we need cases which break under this
# requirement. # requirement.
get_target_property(obj_files ${dep_target} "OBJECT_FILES") get_target_property(obj_files ${dep_target} "OBJECT_FILES")
list(APPEND dep_objects ${obj_files}) list(APPEND dep_objects ${obj_files})
endforeach(dep_target) endforeach(dep_target)
endif() endif()
list(REMOVE_DUPLICATES dep_objects) list(REMOVE_DUPLICATES dep_objects)
if(ADD_ENTRYPOINT_OBJ_COMPILE_OPTIONS) if(ADD_ENTRYPOINT_OBJ_COMPILE_OPTIONS)
target_compile_options( target_compile_options(
${target_name}_objects ${objects_target_name}
PRIVATE ${ADD_ENTRYPOINT_OBJ_COMPILE_OPTIONS} PRIVATE ${ADD_ENTRYPOINT_OBJ_COMPILE_OPTIONS}
) )
endif() endif()
set(object_file_raw "${CMAKE_CURRENT_BINARY_DIR}/${target_name}_raw.o") set(object_file_raw "${CMAKE_CURRENT_BINARY_DIR}/${target_name}_raw.o")
set(object_file "${CMAKE_CURRENT_BINARY_DIR}/${target_name}.o") set(object_file "${CMAKE_CURRENT_BINARY_DIR}/${target_name}.o")
set(input_objects $<TARGET_OBJECTS:${target_name}_objects>) set(input_objects $<TARGET_OBJECTS:${objects_target_name}>)
add_custom_command( add_custom_command(
OUTPUT ${object_file_raw} OUTPUT ${object_file_raw}
DEPENDS ${input_objects} DEPENDS ${input_objects}
COMMAND ${CMAKE_LINKER} -r ${input_objects} -o ${object_file_raw} COMMAND ${CMAKE_LINKER} -r ${input_objects} -o ${object_file_raw}
) )
set(alias_attributes "0,function,global") set(alias_attributes "0,function,global")
if(ADD_ENTRYPOINT_OBJ_REDIRECTED) if(ADD_ENTRYPOINT_OBJ_REDIRECTED)
set(alias_attributes "${alias_attributes},hidden") set(alias_attributes "${alias_attributes},hidden")
endif() endif()
add_custom_command( add_custom_command(
OUTPUT ${object_file} OUTPUT ${object_file}
# We llvm-objcopy here as GNU-binutils objcopy does not support the 'hidden' flag. # We llvm-objcopy here as GNU-binutils objcopy does not support the 'hidden' flag.
DEPENDS ${object_file_raw} ${llvm-objcopy} DEPENDS ${object_file_raw} ${llvm-objcopy}
COMMAND $<TARGET_FILE:llvm-objcopy> --add-symbol "${entrypoint_name}=.llvm.libc.entrypoint.${entrypoint_name}:${alias_attributes}" ${object_file_raw} ${object_file} COMMAND $<TARGET_FILE:llvm-objcopy> --add-symbol "${entrypoint_name}=.llvm.libc.entrypoint.${entrypoint_name}:${alias_attributes}" ${object_file_raw} ${object_file}
) )
add_custom_target( add_custom_target(
${target_name} ${fq_target_name}
ALL ALL
DEPENDS ${object_file} DEPENDS ${object_file}
) )
set(all_objects ${object_file}) set(all_objects ${object_file})
list(APPEND all_objects ${dep_objects}) list(APPEND all_objects ${dep_objects})
set(all_objects_raw ${object_file_raw}) set(all_objects_raw ${object_file_raw})
list(APPEND all_objects_raw ${dep_objects}) list(APPEND all_objects_raw ${dep_objects})
set_target_properties( set_target_properties(
${target_name} ${fq_target_name}
PROPERTIES PROPERTIES
"TARGET_TYPE" ${ENTRYPOINT_OBJ_TARGET_TYPE} "TARGET_TYPE" ${ENTRYPOINT_OBJ_TARGET_TYPE}
"OBJECT_FILES" "${all_objects}" "OBJECT_FILES" "${all_objects}"
"OBJECT_FILES_RAW" "${all_objects_raw}" "OBJECT_FILES_RAW" "${all_objects_raw}"
) )
endfunction(add_entrypoint_object) endfunction(add_entrypoint_object)
# A rule to build a library from a collection of entrypoint objects. # A rule to build a library from a collection of entrypoint objects.
▲ Show 20 Lines • Show All 123 Lines • ▼ Show 20 Linesfunction(add_libc_unittest target_name)
if(NOT LIBC_UNITTEST_SRCS) if(NOT LIBC_UNITTEST_SRCS)
message(FATAL_ERROR "'add_libc_unittest' target requires a SRCS list of .cpp files.") message(FATAL_ERROR "'add_libc_unittest' target requires a SRCS list of .cpp files.")
endif() endif()
if(NOT LIBC_UNITTEST_DEPENDS) if(NOT LIBC_UNITTEST_DEPENDS)
message(FATAL_ERROR "'add_libc_unittest' target requires a DEPENDS list of 'add_entrypoint_object' targets.") message(FATAL_ERROR "'add_libc_unittest' target requires a DEPENDS list of 'add_entrypoint_object' targets.")
endif() endif()
set(library_deps "") set(library_deps "")
foreach(dep IN LISTS LIBC_UNITTEST_DEPENDS) get_fq_deps_list(fq_deps_list ${LIBC_UNITTEST_DEPENDS})
foreach(dep IN LISTS fq_deps_list)
get_target_property(dep_type ${dep} "TARGET_TYPE") get_target_property(dep_type ${dep} "TARGET_TYPE")
if(${dep_type} STREQUAL ${ENTRYPOINT_OBJ_TARGET_TYPE}) if(${dep_type} STREQUAL ${ENTRYPOINT_OBJ_TARGET_TYPE})
get_target_property(obj_files ${dep} "OBJECT_FILES_RAW") get_target_property(obj_files ${dep} "OBJECT_FILES_RAW")
list(APPEND library_deps ${obj_files}) list(APPEND library_deps ${obj_files})
elseif(${dep_type} STREQUAL ${OBJECT_LIBRARY_TARGET_TYPE}) elseif(${dep_type} STREQUAL ${OBJECT_LIBRARY_TARGET_TYPE})
get_target_property(obj_files ${dep} "OBJECT_FILES") get_target_property(obj_files ${dep} "OBJECT_FILES")
list(APPEND library_deps ${obj_files}) list(APPEND library_deps ${obj_files})
endif() endif()
# TODO: Check if the dep is a normal CMake library target. If yes, then add it # TODO: Check if the dep is a normal CMake library target. If yes, then add it
# to the list of library_deps. # to the list of library_deps.
endforeach(dep) endforeach(dep)
list(REMOVE_DUPLICATES library_deps) list(REMOVE_DUPLICATES library_deps)
get_fq_target_name(${target_name} fq_target_name)
add_executable( add_executable(
${target_name} ${fq_target_name}
EXCLUDE_FROM_ALL EXCLUDE_FROM_ALL
${LIBC_UNITTEST_SRCS} ${LIBC_UNITTEST_SRCS}
${LIBC_UNITTEST_HDRS} ${LIBC_UNITTEST_HDRS}
) )
target_include_directories( target_include_directories(
${target_name} ${fq_target_name}
PRIVATE PRIVATE
${LIBC_SOURCE_DIR} ${LIBC_SOURCE_DIR}
${LIBC_BUILD_DIR} ${LIBC_BUILD_DIR}
${LIBC_BUILD_DIR}/include ${LIBC_BUILD_DIR}/include
) )
if(LIBC_UNITTEST_COMPILE_OPTIONS) if(LIBC_UNITTEST_COMPILE_OPTIONS)
target_compile_options( target_compile_options(
${target_name} ${target_name}
PRIVATE ${LIBC_UNITTEST_COMPILE_OPTIONS} PRIVATE ${LIBC_UNITTEST_COMPILE_OPTIONS}
) )
endif() endif()
if(library_deps) if(library_deps)
target_link_libraries(${target_name} PRIVATE ${library_deps}) target_link_libraries(${fq_target_name} PRIVATE ${library_deps})
endif() endif()
set_target_properties(${target_name} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) set_target_properties(${fq_target_name} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
add_dependencies( add_dependencies(
${target_name} ${fq_target_name}
${LIBC_UNITTEST_DEPENDS} ${fq_deps_list}
) )
target_link_libraries(${target_name} PRIVATE LibcUnitTest libc_test_utils) target_link_libraries(${fq_target_name} PRIVATE LibcUnitTest libc_test_utils)
add_custom_command( add_custom_command(
TARGET ${target_name} TARGET ${fq_target_name}
POST_BUILD POST_BUILD
COMMAND $<TARGET_FILE:${target_name}> COMMAND $<TARGET_FILE:${fq_target_name}>
) )
if(LIBC_UNITTEST_SUITE) if(LIBC_UNITTEST_SUITE)
add_dependencies( add_dependencies(
${LIBC_UNITTEST_SUITE} ${LIBC_UNITTEST_SUITE}
${target_name} ${fq_target_name}
) )
endif() endif()
endfunction(add_libc_unittest) endfunction(add_libc_unittest)
function(add_libc_testsuite suite_name) function(add_libc_testsuite suite_name)
add_custom_target(${suite_name}) add_custom_target(${suite_name})
add_dependencies(check-libc ${suite_name}) add_dependencies(check-libc ${suite_name})
endfunction(add_libc_testsuite) endfunction(add_libc_testsuite)
Show All 16 Linesfunction(add_libc_fuzzer target_name)
) )
if(NOT LIBC_FUZZER_SRCS) if(NOT LIBC_FUZZER_SRCS)
message(FATAL_ERROR "'add_libc_fuzzer' target requires a SRCS list of .cpp files.") message(FATAL_ERROR "'add_libc_fuzzer' target requires a SRCS list of .cpp files.")
endif() endif()
if(NOT LIBC_FUZZER_DEPENDS) if(NOT LIBC_FUZZER_DEPENDS)
message(FATAL_ERROR "'add_libc_fuzzer' target requires a DEPENDS list of 'add_entrypoint_object' targets.") message(FATAL_ERROR "'add_libc_fuzzer' target requires a DEPENDS list of 'add_entrypoint_object' targets.")
endif() endif()
get_fq_deps_list(fq_deps_list ${LIBC_FUZZER_DEPENDS})
set(library_deps "") set(library_deps "")
foreach(dep IN LISTS LIBC_FUZZER_DEPENDS) foreach(dep IN LISTS fq_deps_list)
get_target_property(dep_type ${dep} "TARGET_TYPE") get_target_property(dep_type ${dep} "TARGET_TYPE")
if (dep_type) if (dep_type)
string(COMPARE EQUAL ${dep_type} ${ENTRYPOINT_OBJ_TARGET_TYPE} dep_is_entrypoint) string(COMPARE EQUAL ${dep_type} ${ENTRYPOINT_OBJ_TARGET_TYPE} dep_is_entrypoint)
if(dep_is_entrypoint) if(dep_is_entrypoint)
get_target_property(obj_file ${dep} "OBJECT_FILES_RAW") get_target_property(obj_file ${dep} "OBJECT_FILES_RAW")
list(APPEND library_deps ${obj_file}) list(APPEND library_deps ${obj_file})
continue() continue()
endif() endif()
endif() endif()
# TODO: Check if the dep is a normal CMake library target. If yes, then add it # TODO: Check if the dep is a normal CMake library target. If yes, then add it
# to the list of library_deps. # to the list of library_deps.
endforeach(dep) endforeach(dep)
get_fq_target_name(${target_name} fq_target_name)
add_executable( add_executable(
${target_name} ${fq_target_name}
EXCLUDE_FROM_ALL EXCLUDE_FROM_ALL
${LIBC_FUZZER_SRCS} ${LIBC_FUZZER_SRCS}
${LIBC_FUZZER_HDRS} ${LIBC_FUZZER_HDRS}
) )
target_include_directories( target_include_directories(
${target_name} ${fq_target_name}
PRIVATE PRIVATE
${LIBC_SOURCE_DIR} ${LIBC_SOURCE_DIR}
${LIBC_BUILD_DIR} ${LIBC_BUILD_DIR}
${LIBC_BUILD_DIR}/include ${LIBC_BUILD_DIR}/include
) )
if(library_deps) if(library_deps)
target_link_libraries(${target_name} PRIVATE ${library_deps}) target_link_libraries(${fq_target_name} PRIVATE ${library_deps})
endif() endif()
set_target_properties(${target_name} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) set_target_properties(${fq_target_name} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
add_dependencies( add_dependencies(
${target_name} ${fq_target_name}
${LIBC_FUZZER_DEPENDS} ${fq_deps_list}
) )
add_dependencies(libc-fuzzer ${target_name}) add_dependencies(libc-fuzzer ${fq_target_name})
endfunction(add_libc_fuzzer) endfunction(add_libc_fuzzer)
# Rule to add header only libraries. # Rule to add header only libraries.
# Usage # Usage
# add_header_library( # add_header_library(
# <target name> # <target name>
# HDRS <list of .h files part of the library> # HDRS <list of .h files part of the library>
# DEPENDS <list of dependencies> # DEPENDS <list of dependencies>
# ) # )
function(add_header_library target_name) function(add_header_library target_name)
cmake_parse_arguments( cmake_parse_arguments(
"ADD_HEADER" "ADD_HEADER"
"" # No optional arguments "" # No optional arguments
"" # No Single value arguments "" # No Single value arguments
"HDRS;DEPENDS" # Multi-value arguments "HDRS;DEPENDS" # Multi-value arguments
${ARGN} ${ARGN}
) )
if(NOT ADD_HEADER_HDRS) if(NOT ADD_HEADER_HDRS)
message(FATAL_ERROR "'add_header_library' target requires a HDRS list of .h files.") message(FATAL_ERROR "'add_header_library' target requires a HDRS list of .h files.")
endif() endif()
get_fq_target_name(${target_name} fq_target_name)
set(FULL_HDR_PATHS "") set(FULL_HDR_PATHS "")
# TODO: Remove this foreach block when we can switch to the new # TODO: Remove this foreach block when we can switch to the new
# version of the CMake policy CMP0076. # version of the CMake policy CMP0076.
foreach(hdr IN LISTS ADD_HEADER_HDRS) foreach(hdr IN LISTS ADD_HEADER_HDRS)
list(APPEND FULL_HDR_PATHS ${CMAKE_CURRENT_SOURCE_DIR}/${hdr}) list(APPEND FULL_HDR_PATHS ${CMAKE_CURRENT_SOURCE_DIR}/${hdr})
endforeach() endforeach()
set(interface_target_name "${target_name}_header_library__") set(interface_target_name "${fq_target_name}_header_library__")
add_library(${interface_target_name} INTERFACE) add_library(${interface_target_name} INTERFACE)
target_sources(${interface_target_name} INTERFACE ${FULL_HDR_PATHS}) target_sources(${interface_target_name} INTERFACE ${FULL_HDR_PATHS})
if(ADD_HEADER_DEPENDS) if(ADD_HEADER_DEPENDS)
add_dependencies(${interface_target_name} ${ADD_HEADER_DEPENDS}) get_fq_deps_list(fq_deps_list ${ADD_HEADER_DEPENDS})
add_dependencies(${interface_target_name} ${fq_deps_list})
endif() endif()
add_custom_target(${target_name}) add_custom_target(${fq_target_name})
add_dependencies(${target_name} ${interface_target_name}) add_dependencies(${fq_target_name} ${interface_target_name})
set_target_properties( set_target_properties(
${target_name} ${fq_target_name}
PROPERTIES PROPERTIES
"TARGET_TYPE" "HDR_LIBRARY" "TARGET_TYPE" "HDR_LIBRARY"
) )
endfunction(add_header_library) endfunction(add_header_library)

libc/cmake/modules/LLVMLibCTargetNameUtils.cmake

  • This file was added.
function(get_fq_target_name local_name target_name_var)
file(RELATIVE_PATH rel_path ${LIBC_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR})
string(REPLACE "/" "." fq_name "libc.${rel_path}.${local_name}")
set(${target_name_var} ${fq_name} PARENT_SCOPE)
endfunction(get_fq_target_name)
function(is_relative_target_name target_name output_var)
string(FIND ${target_name} "." dot_loc)
string(COMPARE EQUAL "0" ${dot_loc} is_relative)
set(${output_var} ${is_relative} PARENT_SCOPE)
endfunction(is_relative_target_name)
function(get_fq_dep_name fq_name name)
is_relative_target_name(${name} "is_relative")
if(is_relative)
# Skip over the first '.' character.
string(SUBSTRING ${name} 1 -1 local_name)
get_fq_target_name(${local_name} fully_qualified_name)
set(${fq_name} ${fully_qualified_name} PARENT_SCOPE)
else()
set(${fq_name} ${name} PARENT_SCOPE)
endif()
endfunction(get_fq_dep_name)
function(get_fq_deps_list output_list)
set(fq_dep_name_list "")
foreach(dep IN LISTS ARGN)
get_fq_dep_name(fq_dep_name ${dep})
list(APPEND fq_dep_name_list ${fq_dep_name})
endforeach(dep)
set(${output_list} ${fq_dep_name_list} PARENT_SCOPE)
endfunction(get_fq_deps_list)

libc/config/linux/CMakeLists.txt

add_gen_header( add_gen_header(
linux_syscall_h linux_syscall_h
DEF_FILE syscall.h.def DEF_FILE syscall.h.def
GEN_HDR syscall.h GEN_HDR syscall.h
PARAMS PARAMS
inline_syscalls=${LIBC_TARGET_MACHINE}/syscall.h.inc inline_syscalls=${LIBC_TARGET_MACHINE}/syscall.h.inc
DATA_FILES DATA_FILES
${LIBC_TARGET_MACHINE}/syscall.h.inc ${LIBC_TARGET_MACHINE}/syscall.h.inc
DEPENDS DEPENDS
support_common_h libc.src.__support.common
) )
add_subdirectory(x86_64) add_subdirectory(x86_64)

libc/fuzzing/string/CMakeLists.txt

add_libc_fuzzer( add_libc_fuzzer(
strcpy_fuzz strcpy_fuzz
SRCS SRCS
strcpy_fuzz.cpp strcpy_fuzz.cpp
DEPENDS DEPENDS
strcpy libc.src.string.memcpy
strlen libc.src.string.strcpy
memcpy libc.src.string.strlen
) )

libc/include/CMakeLists.txt

add_header( add_header(
llvm_libc_common_h llvm_libc_common_h
HDR HDR
__llvm-libc-common.h __llvm-libc-common.h
) )
add_header( add_header(
libc_posix_types_h libc_posix_types
HDR HDR
__posix-types.h __posix-types.h
) )
add_header( add_header(
ctype_h ctype
HDR HDR
ctype.h ctype.h
DEPENDS DEPENDS
llvm_libc_common_h .llvm_libc_common_h
) )
add_gen_header( add_gen_header(
math_h math
DEF_FILE math.h.def DEF_FILE math.h.def
GEN_HDR math.h GEN_HDR math.h
DEPENDS DEPENDS
llvm_libc_common_h .llvm_libc_common_h
) )
add_gen_header( add_gen_header(
assert_h assert_h
DEF_FILE assert.h.def DEF_FILE assert.h.def
GEN_HDR assert.h GEN_HDR assert.h
DEPENDS DEPENDS
llvm_libc_common_h .llvm_libc_common_h
) )
add_gen_header( add_gen_header(
string_h string
DEF_FILE string.h.def DEF_FILE string.h.def
GEN_HDR string.h GEN_HDR string.h
DEPENDS DEPENDS
llvm_libc_common_h .llvm_libc_common_h
) )
add_gen_header( add_gen_header(
threads_h threads
DEF_FILE threads.h.def DEF_FILE threads.h.def
GEN_HDR threads.h GEN_HDR threads.h
PARAMS PARAMS
platform_threads=../config/${LIBC_TARGET_OS}/threads.h.in platform_threads=../config/${LIBC_TARGET_OS}/threads.h.in
DEPENDS DEPENDS
llvm_libc_common_h .llvm_libc_common_h
DATA_FILES DATA_FILES
../config/${LIBC_TARGET_OS}/threads.h.in ../config/${LIBC_TARGET_OS}/threads.h.in
) )
add_gen_header( add_gen_header(
errno_h errno
DEF_FILE errno.h.def DEF_FILE errno.h.def
PARAMS PARAMS
platform_errno=../config/${LIBC_TARGET_OS}/errno.h.in platform_errno=../config/${LIBC_TARGET_OS}/errno.h.in
GEN_HDR errno.h GEN_HDR errno.h
DATA_FILES DATA_FILES
../config/${LIBC_TARGET_OS}/errno.h.in ../config/${LIBC_TARGET_OS}/errno.h.in
) )
add_gen_header( add_gen_header(
signal_h signal
DEF_FILE signal.h.def DEF_FILE signal.h.def
PARAMS PARAMS
platform_signal=../config/${LIBC_TARGET_OS}/signal.h.in platform_signal=../config/${LIBC_TARGET_OS}/signal.h.in
GEN_HDR signal.h GEN_HDR signal.h
DATA_FILES DATA_FILES
../config/${LIBC_TARGET_OS}/signal.h.in ../config/${LIBC_TARGET_OS}/signal.h.in
) )
add_gen_header( add_gen_header(
stdlib_h stdlib
DEF_FILE stdlib.h.def DEF_FILE stdlib.h.def
GEN_HDR stdlib.h GEN_HDR stdlib.h
DEPENDS DEPENDS
llvm_libc_common_h .llvm_libc_common_h
) )
# TODO: Not all platforms will have a include/sys directory. Add the sys # TODO: Not all platforms will have a include/sys directory. Add the sys
# directory and the targets for sys/*.h files conditional to the OS requiring # directory and the targets for sys/*.h files conditional to the OS requiring
# them. # them.
file(MAKE_DIRECTORY "sys") file(MAKE_DIRECTORY "sys")
add_gen_header( add_gen_header(
sys_mman_h sys_mman
DEF_FILE sys/mman.h.def DEF_FILE sys/mman.h.def
GEN_HDR sys/mman.h GEN_HDR sys/mman.h
DEPENDS DEPENDS
libc_posix_types_h .libc_posix_types
llvm_libc_common_h .llvm_libc_common_h
) )
add_gen_header( add_gen_header(
sys_syscall_h sys_syscall
DEF_FILE sys/syscall.h.def DEF_FILE sys/syscall.h.def
GEN_HDR sys/syscall.h GEN_HDR sys/syscall.h
PARAMS PARAMS
syscall_numbers=../config/${LIBC_TARGET_OS}/syscall_numbers.h.inc syscall_numbers=../config/${LIBC_TARGET_OS}/syscall_numbers.h.inc
DATA_FILES DATA_FILES
../config/${LIBC_TARGET_OS}/syscall_numbers.h.inc ../config/${LIBC_TARGET_OS}/syscall_numbers.h.inc
) )

libc/lib/CMakeLists.txt

add_entrypoint_library( add_entrypoint_library(
llvmlibc llvmlibc
DEPENDS DEPENDS
# assert.h entrypoints # assert.h entrypoints
__assert_fail libc.src.assert.__assert_fail
# errno.h entrypoints # errno.h entrypoints
__errno_location libc.src.errno.__errno_location
# string.h entrypoints
strcpy
strcat
memcpy
# sys/mman.h entrypoints
mmap
munmap
# signal.h entrypoints # signal.h entrypoints
raise libc.src.signal.raise
sigaction libc.src.signal.sigaction
sigaddset libc.src.signal.sigaddset
sigemptyset libc.src.signal.sigemptyset
sigprocmask libc.src.signal.sigprocmask
signal libc.src.signal.signal
# stdlib.h entrypoints # stdlib.h entrypoints
_Exit libc.src.stdlib._Exit
abort libc.src.stdlib.abort
# string.h entrypoints
libc.src.string.memcpy
libc.src.string.strcpy
libc.src.string.strcat
# sys/mman.h entrypoints
libc.src.sys.mman.mmap
libc.src.sys.mman.munmap
# threads.h entrypoints # threads.h entrypoints
mtx_init libc.src.threads.mtx_init
mtx_lock libc.src.threads.mtx_lock
mtx_unlock libc.src.threads.mtx_unlock
thrd_create libc.src.threads.thrd_create
thrd_join libc.src.threads.thrd_join
) )
add_entrypoint_library( add_entrypoint_library(
llvmlibm llvmlibm
DEPENDS DEPENDS
# math.h entrypoints # math.h entrypoints
round libc.src.math.round
) )
add_redirector_library( add_redirector_library(
llvmlibc_redirectors llvmlibc_redirectors
DEPENDS DEPENDS
round_redirector round_redirector
) )

libc/loader/linux/CMakeLists.txt

function(add_loader_object name) function(add_loader_object name)
cmake_parse_arguments( cmake_parse_arguments(
"ADD_LOADER_OBJECT" "ADD_LOADER_OBJECT"
"" # No option arguments "ALIAS" # Option argument
"SRC" # Single value arguments "SRC" # Single value arguments
"DEPENDS;COMPILE_OPTIONS" # Multi value arguments "DEPENDS;COMPILE_OPTIONS" # Multi value arguments
${ARGN} ${ARGN}
) )
get_fq_target_name(${name} fq_target_name)
if(ADD_LOADER_OBJECT_ALIAS)
list(LENGTH ADD_LOADER_OBJECT_DEPENDS deps_size)
if(NOT (${deps_size} EQUAL "1"))
message(FATAL_ERROR "A loader object alias should have exactly one dependency.")
endif()
list(GET ADD_LOADER_OBJECT_DEPENDS 0 dep)
get_fq_dep_name(fq_dep_name ${dep})
add_custom_target(${fq_target_name})
add_dependencies(${fq_target_name} ${fq_dep_name})
get_target_property(dep_objfile ${fq_dep_name} OBJECT_FILES)
set_target_properties(
${fq_target_name}
PROPERTIES
"TARGET_TYPE" "LOADER_OBJECT"
"OBJECT_FILES" ${dep_objfile}
)
return()
endif()
add_object_library( add_object_library(
${name}_object ${name}_objects
SRCS ${ADD_LOADER_OBJECT_SRC} SRCS ${ADD_LOADER_OBJECT_SRC}
DEPENDS ${ADD_LOADER_OBJECT_DEPENDS} DEPENDS ${ADD_LOADER_OBJECT_DEPENDS}
COMPILE_OPTIONS ${ADD_LOADER_OBJECT_COMPILE_OPTIONS} COMPILE_OPTIONS ${ADD_LOADER_OBJECT_COMPILE_OPTIONS}
) )
set(objfile ${LIBC_BUILD_DIR}/lib/${name}.o) set(objfile ${LIBC_BUILD_DIR}/lib/${name}.o)
add_custom_command( add_custom_command(
OUTPUT ${objfile} OUTPUT ${objfile}
COMMAND cp $<TARGET_OBJECTS:${name}_object> ${objfile} COMMAND cp $<TARGET_OBJECTS:${fq_target_name}_objects> ${objfile}
DEPENDS $<TARGET_OBJECTS:${name}_object> DEPENDS $<TARGET_OBJECTS:${fq_target_name}_objects>
) )
add_custom_target( add_custom_target(
${name} ${fq_target_name}
DEPENDS ${objfile} DEPENDS ${objfile}
) )
set_target_properties( set_target_properties(
${name} ${fq_target_name}
PROPERTIES PROPERTIES
"TARGET_TYPE" "LOADER_OBJECT" "TARGET_TYPE" "LOADER_OBJECT"
"OBJECT_FILES" ${objfile} "OBJECT_FILES" ${objfile}
) )
endfunction() endfunction()
add_subdirectory(${LIBC_TARGET_MACHINE}) add_subdirectory(${LIBC_TARGET_MACHINE})
add_loader_object(
crt1
ALIAS
DEPENDS
.${LIBC_TARGET_MACHINE}.crt1
)

libc/loader/linux/x86_64/CMakeLists.txt

add_loader_object( add_loader_object(
crt1 crt1
SRC SRC
start.cpp start.cpp
DEPENDS DEPENDS
linux_syscall_h libc.config.linux.linux_syscall_h
sys_syscall_h libc.include.sys_syscall
COMPILE_OPTIONS COMPILE_OPTIONS
-fno-omit-frame-pointer -fno-omit-frame-pointer
-ffreestanding # To avoid compiler warnings about calling the main function. -ffreestanding # To avoid compiler warnings about calling the main function.
) )

libc/src/__support/CMakeLists.txt

add_gen_header( add_gen_header(
support_common_h common
DEF_FILE common.h.def DEF_FILE common.h.def
PARAMS PARAMS
platform_defs=../../config/${LIBC_TARGET_OS}/platfrom_defs.h.inc platform_defs=../../config/${LIBC_TARGET_OS}/platfrom_defs.h.inc
GEN_HDR common.h GEN_HDR common.h
DATA_FILES DATA_FILES
../../config/${LIBC_TARGET_OS}/platfrom_defs.h.inc ../../config/${LIBC_TARGET_OS}/platfrom_defs.h.inc
) )

libc/src/assert/CMakeLists.txt

add_entrypoint_object( add_entrypoint_object(
__assert_fail __assert_fail
SRCS SRCS
__assert_fail.cpp __assert_fail.cpp
HDRS HDRS
assert.h assert.h
DEPENDS DEPENDS
abort
# These two dependencies are temporary and should be replaced by fprintf # These two dependencies are temporary and should be replaced by fprintf
# later. # later.
sys_syscall_h libc.config.linux.linux_syscall_h
linux_syscall_h libc.include.sys_syscall
libc.src.stdlib.abort
) )

libc/src/signal/CMakeLists.txt

if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS}) if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS})
add_subdirectory(${LIBC_TARGET_OS}) add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS})
endif() endif()
add_entrypoint_object(
raise
ALIAS
DEPENDS
.${LIBC_TARGET_OS}.raise
)
add_entrypoint_object(
sigaction
ALIAS
DEPENDS
.${LIBC_TARGET_OS}.sigaction
)
add_entrypoint_object(
sigprocmask
ALIAS
DEPENDS
.${LIBC_TARGET_OS}.sigprocmask
)
add_entrypoint_object(
sigemptyset
ALIAS
DEPENDS
.${LIBC_TARGET_OS}.sigemptyset
)
add_entrypoint_object(
sigaddset
ALIAS
DEPENDS
.${LIBC_TARGET_OS}.sigaddset
)
add_entrypoint_object(
signal
ALIAS
DEPENDS
.${LIBC_TARGET_OS}.signal
)
add_entrypoint_object(
sigfillset
ALIAS
DEPENDS
.${LIBC_TARGET_OS}.sigfillset
)
add_entrypoint_object(
sigdelset
ALIAS
DEPENDS
.${LIBC_TARGET_OS}.sigdelset
)

libc/src/signal/linux/CMakeLists.txt

add_entrypoint_object( add_entrypoint_object(
raise raise
SRCS SRCS
raise.cpp raise.cpp
HDRS HDRS
signal.h signal.h
../raise.h ../raise.h
DEPENDS DEPENDS
sys_syscall_h libc.config.linux.linux_syscall_h
linux_syscall_h libc.include.signal
signal_h libc.include.sys_syscall
) )
add_object_library( add_object_library(
__restore __restore
SRCS SRCS
__restore.cpp __restore.cpp
COMPILE_OPTIONS COMPILE_OPTIONS
-fomit-frame-pointer -fomit-frame-pointer
-O3 -O3
-Wframe-larger-than=0 -Wframe-larger-than=0
-Werror -Werror
-Wno-attributes -Wno-attributes
# asan creates asan.module_ctor which uses stack space, causing warnings. # asan creates asan.module_ctor which uses stack space, causing warnings.
-fno-sanitize=address -fno-sanitize=address
DEPENDS DEPENDS
linux_syscall_h libc.config.linux.linux_syscall_h
sys_syscall_h libc.include.sys_syscall
) )
add_entrypoint_object( add_entrypoint_object(
sigaction sigaction
SRCS SRCS
sigaction.cpp sigaction.cpp
HDRS HDRS
signal.h signal.h
../sigaction.h ../sigaction.h
DEPENDS DEPENDS
__restore .__restore
sys_syscall_h libc.config.linux.linux_syscall_h
linux_syscall_h libc.include.signal
signal_h libc.include.sys_syscall
) )
add_entrypoint_object( add_entrypoint_object(
sigprocmask sigprocmask
SRCS SRCS
sigprocmask.cpp sigprocmask.cpp
HDRS HDRS
signal.h signal.h
../sigprocmask.h ../sigprocmask.h
DEPENDS DEPENDS
sys_syscall_h libc.config.linux.linux_syscall_h
linux_syscall_h libc.include.signal
__errno_location libc.include.sys_syscall
signal_h libc.src.errno.__errno_location
) )
add_entrypoint_object( add_entrypoint_object(
sigemptyset sigemptyset
SRCS SRCS
sigemptyset.cpp sigemptyset.cpp
HDRS HDRS
signal.h signal.h
../sigemptyset.h ../sigemptyset.h
DEPENDS DEPENDS
__errno_location libc.include.errno
errno_h libc.include.signal
signal_h libc.src.errno.__errno_location
) )
add_entrypoint_object( add_entrypoint_object(
sigaddset sigaddset
SRCS SRCS
sigaddset.cpp sigaddset.cpp
HDRS HDRS
signal.h signal.h
../sigaddset.h ../sigaddset.h
DEPENDS DEPENDS
__errno_location libc.include.errno
errno_h libc.include.signal
signal_h libc.src.errno.__errno_location
) )
add_entrypoint_object( add_entrypoint_object(
signal signal
SRCS SRCS
signal.cpp signal.cpp
HDRS HDRS
signal.h signal.h
../signal.h ../signal.h
DEPENDS DEPENDS
sigaction .sigaction
signal_h libc.include.signal
) )
add_entrypoint_object( add_entrypoint_object(
sigfillset sigfillset
SRCS SRCS
sigfillset.cpp sigfillset.cpp
HDRS HDRS
signal.h signal.h
../sigfillset.h ../sigfillset.h
DEPENDS DEPENDS
__errno_location libc.include.errno
errno_h libc.include.signal
signal_h libc.src.errno.__errno_location
) )
add_entrypoint_object( add_entrypoint_object(
sigdelset sigdelset
SRCS SRCS
sigdelset.cpp sigdelset.cpp
HDRS HDRS
signal.h signal.h
../sigdelset.h ../sigdelset.h
DEPENDS DEPENDS
__errno_location libc.include.errno
errno_h libc.include.signal
signal_h libc.src.errno.__errno_location
) )

libc/src/stdlib/CMakeLists.txt

if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS}) if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS})
add_subdirectory(${LIBC_TARGET_OS}) add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS})
endif() endif()
add_entrypoint_object( add_entrypoint_object(
_Exit
ALIAS
DEPENDS
.${LIBC_TARGET_OS}._Exit
)
add_entrypoint_object(
abort abort
SRCS SRCS
abort.cpp abort.cpp
HDRS HDRS
abort.h abort.h
DEPENDS DEPENDS
raise libc.include.stdlib
_Exit libc.src.signal.raise
stdlib_h ._Exit
) )

libc/src/stdlib/linux/CMakeLists.txt

add_entrypoint_object( add_entrypoint_object(
_Exit _Exit
SRCS SRCS
_Exit.cpp _Exit.cpp
HDRS HDRS
../_Exit.h ../_Exit.h
DEPENDS DEPENDS
sys_syscall_h libc.include.sys_syscall
linux_syscall_h libc.config.linux.linux_syscall_h
stdlib_h libc.include.stdlib
) )

libc/src/string/CMakeLists.txt

add_subdirectory(memory_utils) add_subdirectory(memory_utils)
add_entrypoint_object( add_entrypoint_object(
strcat strcat
SRCS SRCS
strcat.cpp strcat.cpp
HDRS HDRS
strcat.h strcat.h
DEPENDS DEPENDS
strcpy .strcpy
string_h .strlen
strlen libc.include.string
) )
add_entrypoint_object( add_entrypoint_object(
strcpy strcpy
SRCS SRCS
strcpy.cpp strcpy.cpp
HDRS HDRS
strcpy.h strcpy.h
DEPENDS DEPENDS
string_h .memcpy
strlen .strlen
memcpy libc.include.string
) )
add_entrypoint_object( add_entrypoint_object(
strlen strlen
SRCS SRCS
strlen.cpp strlen.cpp
HDRS HDRS
strlen.h strlen.h
DEPENDS DEPENDS
string_h libc.include.string
) )
# ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------
# memcpy # memcpy
# ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------
# include the relevant architecture specific implementations # include the relevant architecture specific implementations
if(${LIBC_TARGET_MACHINE} STREQUAL "x86_64") if(${LIBC_TARGET_MACHINE} STREQUAL "x86_64")
Show All 31 Lines compute_flags(flags
REQUIRE ${ADD_MEMCPY_REQUIRE} REQUIRE ${ADD_MEMCPY_REQUIRE}
REJECT ${ADD_MEMCPY_REJECT} REJECT ${ADD_MEMCPY_REJECT}
) )
add_entrypoint_object( add_entrypoint_object(
${memcpy_name} ${memcpy_name}
SRCS ${LIBC_SOURCE_DIR}/src/string/memcpy.cpp SRCS ${LIBC_SOURCE_DIR}/src/string/memcpy.cpp
HDRS ${LIBC_SOURCE_DIR}/src/string/memcpy.h HDRS ${LIBC_SOURCE_DIR}/src/string/memcpy.h
DEPENDS DEPENDS
string_h .memory_utils.memory_utils
memory_utils .memcpy_arch_specific
memcpy_arch_specific libc.include.string
COMPILE_OPTIONS COMPILE_OPTIONS
-fno-builtin-memcpy -fno-builtin-memcpy
${flags} ${flags}
) )
set_target_properties(${memcpy_name} PROPERTIES REQUIRE_CPU_FEATURES "${ADD_MEMCPY_REQUIRE}") get_fq_target_name(${memcpy_name} fq_target_name)
set_target_properties(${fq_target_name} PROPERTIES REQUIRE_CPU_FEATURES "${ADD_MEMCPY_REQUIRE}")
get_property(all GLOBAL PROPERTY memcpy_implementations) get_property(all GLOBAL PROPERTY memcpy_implementations)
list(APPEND all ${memcpy_name}) list(APPEND all ${memcpy_name})
set_property(GLOBAL PROPERTY memcpy_implementations "${all}") set_property(GLOBAL PROPERTY memcpy_implementations "${all}")
endfunction() endfunction()
add_subdirectory(${LIBC_MEMCPY_IMPL_FOLDER}) include(${LIBC_MEMCPY_IMPL_FOLDER}/CMakeLists.txt)
add_memcpy(memcpy MARCH native) add_memcpy(memcpy MARCH native)

libc/src/string/memory_utils/CMakeLists.txt

Show All 10 Lines
) )
add_header_library( add_header_library(
memory_utils memory_utils
HDRS HDRS
utils.h utils.h
memcpy_utils.h memcpy_utils.h
DEPENDS DEPENDS
cacheline_size .cacheline_size
) )

libc/src/sys/mman/CMakeLists.txt

if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS}) if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS})
add_subdirectory(${LIBC_TARGET_OS}) add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS})
endif() endif()
add_entrypoint_object(
mmap
ALIAS
DEPENDS
.${LIBC_TARGET_OS}.mmap
)
add_entrypoint_object(
munmap
ALIAS
DEPENDS
.${LIBC_TARGET_OS}.munmap
)

libc/src/sys/mman/linux/CMakeLists.txt

add_entrypoint_object( add_entrypoint_object(
mmap mmap
SRCS SRCS
mmap.cpp mmap.cpp
HDRS HDRS
../mmap.h ../mmap.h
DEPENDS DEPENDS
sys_mman_h libc.config.linux.linux_syscall_h
sys_syscall_h libc.include.sys_mman
linux_syscall_h libc.include.sys_syscall
__errno_location libc.src.errno.__errno_location
) )
add_entrypoint_object( add_entrypoint_object(
munmap munmap
SRCS SRCS
munmap.cpp munmap.cpp
HDRS HDRS
../munmap.h ../munmap.h
DEPENDS DEPENDS
sys_mman_h libc.config.linux.linux_syscall_h
sys_syscall_h libc.include.sys_mman
linux_syscall_h libc.include.sys_syscall
__errno_location libc.src.errno.__errno_location
) )

libc/src/threads/CMakeLists.txt

if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS}) if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS})
add_subdirectory(${LIBC_TARGET_OS}) add_subdirectory(${LIBC_TARGET_OS})
endif() endif()
add_entrypoint_object(
thrd_create
ALIAS
DEPENDS
.${LIBC_TARGET_OS}.thrd_create
)
add_entrypoint_object(
thrd_join
ALIAS
DEPENDS
.${LIBC_TARGET_OS}.thrd_join
)
add_entrypoint_object(
mtx_init
ALIAS
DEPENDS
.${LIBC_TARGET_OS}.mtx_init
)
add_entrypoint_object(
mtx_lock
ALIAS
DEPENDS
.${LIBC_TARGET_OS}.mtx_lock
)
add_entrypoint_object(
mtx_unlock
ALIAS
DEPENDS
.${LIBC_TARGET_OS}.mtx_unlock
)

libc/src/threads/linux/CMakeLists.txt

add_gen_header( add_gen_header(
thread_start_args_h thread_start_args_h
DEF_FILE thread_start_args.h.def DEF_FILE thread_start_args.h.def
GEN_HDR thread_start_args.h GEN_HDR thread_start_args.h
PARAMS PARAMS
thread_start_args=${LIBC_TARGET_MACHINE}/thread_start_args.h.in thread_start_args=${LIBC_TARGET_MACHINE}/thread_start_args.h.in
DATA_FILES DATA_FILES
${LIBC_TARGET_MACHINE}/thread_start_args.h.in ${LIBC_TARGET_MACHINE}/thread_start_args.h.in
) )
add_header_library( add_header_library(
threads_utils threads_utils
HDRS HDRS
thread_utils.h thread_utils.h
DEPENDS DEPENDS
thread_start_args_h .thread_start_args_h
) )
add_entrypoint_object( add_entrypoint_object(
thrd_create thrd_create
SRCS SRCS
thrd_create.cpp thrd_create.cpp
HDRS HDRS
../thrd_create.h ../thrd_create.h
DEPENDS DEPENDS
errno_h .threads_utils
linux_syscall_h libc.config.linux.linux_syscall_h
mmap libc.include.errno
support_common_h libc.include.sys_syscall
sys_syscall_h libc.include.threads
threads_h libc.src.__support.common
threads_utils libc.src.errno.__errno_location
__errno_location libc.src.sys.mman.mmap
COMPILE_OPTIONS COMPILE_OPTIONS
-fno-omit-frame-pointer # This allows us to sniff out the thread args from -fno-omit-frame-pointer # This allows us to sniff out the thread args from
# the new thread's stack reliably. # the new thread's stack reliably.
) )
add_entrypoint_object( add_entrypoint_object(
thrd_join thrd_join
SRCS SRCS
thrd_join.cpp thrd_join.cpp
HDRS HDRS
../thrd_join.h ../thrd_join.h
DEPENDS DEPENDS
linux_syscall_h .threads_utils
munmap libc.config.linux.linux_syscall_h
support_common_h libc.include.sys_syscall
sys_syscall_h libc.include.threads
threads_h libc.src.sys.mman.mmap
threads_utils libc.src.__support.common
) )
add_entrypoint_object( add_entrypoint_object(
mtx_init mtx_init
SRCS SRCS
mtx_init.cpp mtx_init.cpp
HDRS HDRS
../mtx_init.h ../mtx_init.h
DEPENDS DEPENDS
threads_h .threads_utils
threads_utils libc.include.threads
) )
add_entrypoint_object( add_entrypoint_object(
mtx_lock mtx_lock
SRCS SRCS
mtx_lock.cpp mtx_lock.cpp
HDRS HDRS
../mtx_lock.h ../mtx_lock.h
DEPENDS DEPENDS
linux_syscall_h .threads_utils
sys_syscall_h libc.config.linux.linux_syscall_h
threads_h libc.include.sys_syscall
threads_utils libc.include.threads
) )
add_entrypoint_object( add_entrypoint_object(
mtx_unlock mtx_unlock
SRCS SRCS
mtx_unlock.cpp mtx_unlock.cpp
HDRS HDRS
../mtx_unlock.h ../mtx_unlock.h
DEPENDS DEPENDS
linux_syscall_h .threads_utils
sys_syscall_h libc.config.linux.linux_syscall_h
threads_h libc.include.sys_syscall
threads_utils libc.include.threads
) )

libc/test/config/linux/x86_64/CMakeLists.txt

add_libc_unittest( add_libc_unittest(
libc_linux_x86_64_syscall_unittest libc_linux_x86_64_syscall_unittest
SUITE libc_linux_tests SUITE libc_linux_tests
SRCS syscall_test.cpp SRCS syscall_test.cpp
DEPENDS DEPENDS
linux_syscall_h libc.config.linux.linux_syscall_h
support_common_h
) )

libc/test/loader/CMakeLists.txt

Show All 14 Linesfunction(add_loader_test target_name)
cmake_parse_arguments( cmake_parse_arguments(
"ADD_LOADER_TEST" "ADD_LOADER_TEST"
"" # No option arguments "" # No option arguments
"SRC" # Single value arguments "SRC" # Single value arguments
"DEPENDS;ARGS;ENV" # Multivalue arguments. "DEPENDS;ARGS;ENV" # Multivalue arguments.
${ARGN} ${ARGN}
) )
get_fq_target_name(${target_name} fq_target_name)
add_executable( add_executable(
${target_name} ${fq_target_name}
EXCLUDE_FROM_ALL EXCLUDE_FROM_ALL
${ADD_LOADER_TEST_SRC} ${ADD_LOADER_TEST_SRC}
) )
set_target_properties(${target_name} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) set_target_properties(${fq_target_name} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
set(dep_objects "") set(dep_objects "")
if(ADD_LOADER_TEST_DEPENDS) if(ADD_LOADER_TEST_DEPENDS)
add_dependencies(${target_name} ${ADD_LOADER_TEST_DEPENDS}) get_fq_deps_list(fq_deps_list ${ADD_LOADER_TEST_DEPENDS})
foreach(dep IN LISTS ADD_LOADER_TEST_DEPENDS) add_dependencies(${fq_target_name} ${fq_deps_list})
foreach(dep IN LISTS fq_deps_list)
get_target_property(objfile ${dep} "OBJECT_FILES") get_target_property(objfile ${dep} "OBJECT_FILES")
if(NOT objfile) if(NOT objfile)
message( message(
FATAL_ERROR FATAL_ERROR
"Unexpected dependency of an `add_loader_test` target. A dependency " "Unexpected dependency of an `add_loader_test` target. A dependency "
"should be a target of type `add_entrypoint_object, `add_object`, or " "should be a target of type `add_entrypoint_object, `add_object`, or "
"`add_loader_object`.") "`add_loader_object`.")
endif() endif()
list(APPEND dep_objects ${objfile}) list(APPEND dep_objects ${objfile})
endforeach(dep) endforeach(dep)
endif() endif()
target_include_directories( target_include_directories(
${target_name} ${fq_target_name}
PRIVATE PRIVATE
${LIBC_SOURCE_DIR} ${LIBC_SOURCE_DIR}
${LIBC_BUILD_DIR} ${LIBC_BUILD_DIR}
${LIBC_BUILD_DIR}/include ${LIBC_BUILD_DIR}/include
) )
target_link_libraries(${target_name} ${dep_objects}) target_link_libraries(${fq_target_name} ${dep_objects})
target_link_options( target_link_options(
${target_name} ${fq_target_name}
BEFORE PRIVATE BEFORE PRIVATE
-nostdlib -nostdlib
) )
add_custom_command( add_custom_command(
TARGET ${target_name} TARGET ${fq_target_name}
POST_BUILD POST_BUILD
COMMAND ${ADD_LOADER_TEST_ENV} $<TARGET_FILE:${target_name}> ${ADD_LOADER_TEST_ARGS} COMMAND ${ADD_LOADER_TEST_ENV} $<TARGET_FILE:${fq_target_name}> ${ADD_LOADER_TEST_ARGS}
) )
add_dependencies(libc_loader_tests ${target_name}) add_dependencies(libc_loader_tests ${fq_target_name})
endfunction(add_loader_test) endfunction(add_loader_test)
if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS}) if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS})
add_subdirectory(${LIBC_TARGET_OS}) add_subdirectory(${LIBC_TARGET_OS})
endif() endif()

libc/test/loader/linux/CMakeLists.txt

add_loader_test( add_loader_test(
loader_args_test loader_args_test
SRC SRC
args_test.cpp args_test.cpp
DEPENDS DEPENDS
__assert_fail libc.loader.linux.crt1
_Exit libc.src.assert.__assert_fail
abort libc.src.signal.raise
crt1 libc.src.stdlib._Exit
raise libc.src.stdlib.abort
ARGS ARGS
1 2 3 1 2 3
ENV ENV
FRANCE=Paris FRANCE=Paris
GERMANY=Berlin GERMANY=Berlin
) )
add_loader_test( add_loader_test(
loader_no_envp_test loader_no_envp_test
SRC SRC
main_without_envp.cpp main_without_envp.cpp
DEPENDS DEPENDS
crt1 libc.loader.linux.crt1
) )
add_loader_test( add_loader_test(
loader_no_args_test loader_no_args_test
SRC SRC
main_without_args.cpp main_without_args.cpp
DEPENDS DEPENDS
crt1 libc.loader.linux.crt1
) )

libc/test/src/assert/CMakeLists.txt

add_libc_testsuite(libc_assert_unittests) add_libc_testsuite(libc_assert_unittests)
add_libc_unittest( add_libc_unittest(
assert_test assert_test
SUITE SUITE
libc_assert_unittests libc_assert_unittests
SRCS SRCS
assert_test.cpp assert_test.cpp
DEPENDS DEPENDS
__assert_fail libc.src.assert.__assert_fail
# These are necessary for now because dependencies are not properly added. # These are necessary for now because dependencies are not properly added.
abort libc.src.signal.raise
raise libc.src.stdlib._Exit
_Exit libc.src.stdlib.abort
) )

libc/test/src/errno/CMakeLists.txt

add_libc_testsuite(libc_errno_unittests) add_libc_testsuite(libc_errno_unittests)
add_libc_unittest( add_libc_unittest(
errno_test errno_test
SUITE SUITE
libc_errno_unittests libc_errno_unittests
SRCS SRCS
errno_test.cpp errno_test.cpp
DEPENDS DEPENDS
__errno_location libc.src.errno.__errno_location
) )

libc/test/src/signal/CMakeLists.txt

add_libc_testsuite(libc_signal_unittests) add_libc_testsuite(libc_signal_unittests)
add_libc_unittest( add_libc_unittest(
raise_test raise_test
SUITE SUITE
libc_signal_unittests libc_signal_unittests
SRCS SRCS
raise_test.cpp raise_test.cpp
DEPENDS DEPENDS
raise libc.include.signal
signal_h libc.src.signal.raise
) )
add_libc_unittest( add_libc_unittest(
sigaction_test sigaction_test
SUITE SUITE
libc_signal_unittests libc_signal_unittests
SRCS SRCS
sigaction_test.cpp sigaction_test.cpp
DEPENDS DEPENDS
sigaction libc.src.signal.sigaction
raise libc.src.signal.raise
signal_h libc.include.signal
errno_h libc.include.errno
__errno_location libc.src.errno.__errno_location
) )
add_libc_unittest( add_libc_unittest(
sigprocmask_test sigprocmask_test
SUITE SUITE
libc_signal_unittests libc_signal_unittests
SRCS SRCS
sigprocmask_test.cpp sigprocmask_test.cpp
DEPENDS DEPENDS
raise libc.include.signal
sigprocmask libc.src.errno.__errno_location
sigaddset libc.src.signal.raise
sigemptyset libc.src.signal.sigprocmask
signal_h libc.src.signal.sigaddset
__errno_location libc.src.signal.sigemptyset
) )
add_libc_unittest( add_libc_unittest(
sigaddset_test sigaddset_test
SUITE SUITE
libc_signal_unittests libc_signal_unittests
SRCS SRCS
sigaddset_test.cpp sigaddset_test.cpp
DEPENDS DEPENDS
sigaddset libc.include.signal
signal_h libc.src.errno.__errno_location
__errno_location libc.src.signal.sigaddset
) )
add_libc_unittest( add_libc_unittest(
signal_test signal_test
SUITE SUITE
libc_signal_unittests libc_signal_unittests
SRCS SRCS
signal_test.cpp signal_test.cpp
DEPENDS DEPENDS
signal libc.include.errno
signal_h libc.include.signal
sigaction libc.src.errno.__errno_location
raise libc.src.signal.raise
__errno_location libc.src.signal.sigaction
errno_h libc.src.signal.signal
) )
add_libc_unittest( add_libc_unittest(
sigfillset_test sigfillset_test
SUITE SUITE
libc_signal_unittests libc_signal_unittests
SRCS SRCS
sigfillset_test.cpp sigfillset_test.cpp
DEPENDS DEPENDS
sigfillset libc.include.errno
sigprocmask libc.include.signal
signal_h libc.src.errno.__errno_location
raise libc.src.signal.raise
errno_h libc.src.signal.sigfillset
__errno_location libc.src.signal.sigprocmask
) )
add_libc_unittest( add_libc_unittest(
sigdelset_test sigdelset_test
SUITE SUITE
libc_signal_unittests libc_signal_unittests
SRCS SRCS
sigdelset_test.cpp sigdelset_test.cpp
DEPENDS DEPENDS
sigdelset libc.include.errno
sigfillset libc.include.signal
sigprocmask libc.src.errno.__errno_location
signal_h libc.src.signal.raise
raise libc.src.signal.sigdelset
errno_h libc.src.signal.sigfillset
__errno_location libc.src.signal.sigprocmask
) )

libc/test/src/stdlib/CMakeLists.txt

add_libc_testsuite(libc_stdlib_unittests) add_libc_testsuite(libc_stdlib_unittests)
add_libc_unittest( add_libc_unittest(
_Exit_test _Exit_test
SUITE SUITE
libc_stdlib_unittests libc_stdlib_unittests
SRCS SRCS
_Exit_test.cpp _Exit_test.cpp
DEPENDS DEPENDS
stdlib_h libc.include.stdlib
_Exit libc.src.stdlib._Exit
) )
add_libc_unittest( add_libc_unittest(
abort_test abort_test
SUITE SUITE
libc_stdlib_unittests libc_stdlib_unittests
SRCS SRCS
abort_test.cpp abort_test.cpp
DEPENDS DEPENDS
stdlib_h libc.include.stdlib
signal_h libc.include.signal
abort libc.src.stdlib.abort
_Exit libc.src.stdlib._Exit
raise libc.src.signal.raise
) )

libc/test/src/string/CMakeLists.txt

add_libc_testsuite(libc_string_unittests) add_libc_testsuite(libc_string_unittests)
add_subdirectory(memory_utils) add_subdirectory(memory_utils)
add_libc_unittest( add_libc_unittest(
strcat_test strcat_test
SUITE SUITE
libc_string_unittests libc_string_unittests
SRCS SRCS
strcat_test.cpp strcat_test.cpp
DEPENDS DEPENDS
strcat
strcpy
strlen
# TODO (sivachandra): remove redundant deps. # TODO (sivachandra): remove redundant deps.
memcpy libc.src.string.memcpy
libc.src.string.strcat
libc.src.string.strcpy
libc.src.string.strlen
) )
add_libc_unittest( add_libc_unittest(
strcpy_test strcpy_test
SUITE SUITE
libc_string_unittests libc_string_unittests
SRCS SRCS
strcpy_test.cpp strcpy_test.cpp
DEPENDS DEPENDS
strcpy
strlen
# TODO (sivachandra): remove redundant deps. # TODO (sivachandra): remove redundant deps.
memcpy libc.src.string.memcpy
libc.src.string.strcpy
libc.src.string.strlen
) )
add_libc_unittest( add_libc_unittest(
strlen_test strlen_test
SUITE SUITE
libc_string_unittests libc_string_unittests
SRCS SRCS
strlen_test.cpp strlen_test.cpp
DEPENDS DEPENDS
strlen libc.src.string.strlen
) )
# Tests all implementations of memcpy that can run on the host. # Tests all implementations of memcpy that can run on the host.
get_property(memcpy_implementations GLOBAL PROPERTY memcpy_implementations) get_property(memcpy_implementations GLOBAL PROPERTY memcpy_implementations)
foreach(memcpy_config_name IN LISTS memcpy_implementations) foreach(memcpy_config_name IN LISTS memcpy_implementations)
get_target_property(require_cpu_features ${memcpy_config_name} REQUIRE_CPU_FEATURES) get_target_property(require_cpu_features libc.src.string.${memcpy_config_name} REQUIRE_CPU_FEATURES)
host_supports(can_run "${require_cpu_features}") host_supports(can_run "${require_cpu_features}")
if(can_run) if(can_run)
add_libc_unittest( add_libc_unittest(
${memcpy_config_name}_test ${memcpy_config_name}_test
SUITE SUITE
libc_string_unittests libc_string_unittests
SRCS SRCS
memcpy_test.cpp memcpy_test.cpp
DEPENDS DEPENDS
${memcpy_config_name} libc.src.string.${memcpy_config_name}
) )
else() else()
message(STATUS "Skipping test for '${memcpy_config_name}' insufficient host cpu features") message(STATUS "Skipping test for '${memcpy_config_name}' insufficient host cpu features")
endif() endif()
endforeach() endforeach()

libc/test/src/string/memory_utils/CMakeLists.txt

add_libc_unittest( add_libc_unittest(
utils_test utils_test
SUITE SUITE
libc_string_unittests libc_string_unittests
SRCS SRCS
utils_test.cpp utils_test.cpp
memcpy_utils_test.cpp memcpy_utils_test.cpp
DEPENDS DEPENDS
memory_utils libc.src.string.memory_utils.memory_utils
standalone_cpp libc.utils.CPP.standalone_cpp
) )
target_compile_definitions( target_compile_definitions(
utils_test libc.test.src.string.memory_utils.utils_test
PRIVATE PRIVATE
LLVM_LIBC_MEMCPY_MONITOR=memcpy_monitor LLVM_LIBC_MEMCPY_MONITOR=memcpy_monitor
) )

libc/test/src/sys/mman/linux/CMakeLists.txt

add_libc_testsuite(libc_sys_mman_unittests) add_libc_testsuite(libc_sys_mman_unittests)
add_libc_unittest( add_libc_unittest(
mmap_test mmap_test
SUITE SUITE
libc_sys_mman_unittests libc_sys_mman_unittests
SRCS SRCS
mmap_test.cpp mmap_test.cpp
DEPENDS DEPENDS
errno_h libc.include.errno
sys_mman_h libc.include.sys_mman
mmap libc.src.errno.__errno_location
munmap libc.src.sys.mman.mmap
__errno_location libc.src.sys.mman.munmap
) )

libc/test/src/threads/CMakeLists.txt

add_libc_testsuite(libc_threads_unittests) add_libc_testsuite(libc_threads_unittests)
add_libc_unittest( add_libc_unittest(
thrd_test thrd_test
SUITE SUITE
libc_threads_unittests libc_threads_unittests
SRCS SRCS
thrd_test.cpp thrd_test.cpp
DEPENDS DEPENDS
__errno_location libc.include.threads
mmap libc.src.errno.__errno_location
munmap libc.src.sys.mman.munmap
threads_h libc.src.sys.mman.mmap
thrd_create libc.src.threads.thrd_create
thrd_join libc.src.threads.thrd_join
) )
add_libc_unittest( add_libc_unittest(
mtx_test mtx_test
SUITE SUITE
libc_threads_unittests libc_threads_unittests
SRCS SRCS
mtx_test.cpp mtx_test.cpp
DEPENDS DEPENDS
__errno_location libc.include.threads
mmap libc.src.errno.__errno_location
munmap libc.src.sys.mman.mmap
mtx_init libc.src.sys.mman.munmap
mtx_lock libc.src.threads.mtx_init
mtx_unlock libc.src.threads.mtx_lock
thrd_create libc.src.threads.mtx_unlock
thrd_join libc.src.threads.thrd_create
threads_h libc.src.threads.thrd_join
) )

libc/utils/UnitTest/CMakeLists.txt

add_llvm_library( add_llvm_library(
LibcUnitTest LibcUnitTest
Test.cpp Test.cpp
Test.h Test.h
ErrnoSetterMatcher.h ErrnoSetterMatcher.h
LINK_COMPONENTS Support LINK_COMPONENTS Support
) )
target_include_directories(LibcUnitTest PUBLIC ${LIBC_SOURCE_DIR}) target_include_directories(LibcUnitTest PUBLIC ${LIBC_SOURCE_DIR})
add_dependencies(LibcUnitTest standalone_cpp) add_dependencies(LibcUnitTest libc.utils.CPP.standalone_cpp)
target_link_libraries(LibcUnitTest PUBLIC libc_test_utils) target_link_libraries(LibcUnitTest PUBLIC libc_test_utils)