[libc] Extend add_object rule to handle helper object libraries.

[sivachandra]

Summary

The rule is now called add_object_library.

[abrachet]

libc/cmake/modules/LLVMLibCRules.cmake

117–118

Nit: this could say requires SRCS to be specified.

238

Why not from add_entrypoint_object targets?

[sivachandra]

libc/cmake/modules/LLVMLibCRules.cmake

238

Essentially to avoid inconsistency. Either we get object files from all of the entrypoint deps, or from none of them. We cannot get from all of them as CMake might not have seen some of them yet. In case of object library deps though, we are enforcing that they be visible. This is not really a big ask as object libraries are usually helper libraries for a bunch of related functions.

That said, if we move to CMake 3.15, the widely expanded generator support could allow us to simplify and improve the situation here.

[sivachandra]

Fix typos.

libc/cmake/modules/LLVMLibCRules.cmake

function(add_gen_header target_name)
   )
 
   add_custom_target(
     ${target_name}
     DEPENDS ${out_file} ${ADD_GEN_HDR_DEPENDS}
   )
 endfunction(add_gen_header)
 
-set(SINGLE_OBJECT_TARGET_TYPE "LIBC_SINGLE_OBJECT")
+set(OBJECT_LIBRARY_TARGET_TYPE "OBJECT_LIBRARY")
 
-# Function to generate single object file.
+# Rule which is essentially a wrapper over add_library to compile a set of
+# sources to object files.
 # Usage:
-#     add_object(
+#     add_object_library(
 #       <target_name>
-#       SRC <source file to compile>
+#       HDRS <list of header files>
+#       SRCS <list of source files>
 #       DEPENDS <list of dependencies>
 #       COMPILE_OPTIONS <optional list of special compile options for this target>
-function(add_object target_name)
+function(add_object_library target_name)
   cmake_parse_arguments(
     "ADD_OBJECT"
     "" # No option arguments
-    "SRC" # Single value arguments
-    "COMPILE_OPTIONS;DEPENDS" # Multivalue arguments
+    "" # Single value arguments
+    "SRCS;HDRS;COMPILE_OPTIONS;DEPENDS" # Multivalue arguments
     ${ARGN}
   )
 
-  if(NOT ADD_OBJECT_SRC)
-    message(FATAL_ERROR "'add_object' rules requires a SRC to be specified.")
+  if(NOT ADD_OBJECT_SRCS)
+    message(FATAL_ERROR "'add_object_library' rule requires SRCS to be specified.")
   endif()
 
   add_library(
     ${target_name}
     OBJECT
-    ${ADD_OBJECT_SRC}
+    ${ADD_OBJECT_SRCS}
+    ${ADD_OBJECT_HDRS}
   )
   target_include_directories(
     ${target_name}
     PRIVATE
       "${LIBC_BUILD_DIR}/include;${LIBC_SOURCE_DIR};${LIBC_BUILD_DIR}"
   )
   if(ADD_OBJECT_COMPILE_OPTIONS)
     target_compile_options(
       ${target_name}
       PRIVATE ${ADD_OBJECT_COMPILE_OPTIONS}
     )
   endif()
+
+  set(all_object_files $<TARGET_OBJECTS:${target_name}>)
   if(ADD_OBJECT_DEPENDS)
     add_dependencies(
       ${target_name}
       ${ADD_OBJECT_DEPENDS}
     )
+    foreach(obj_target IN LISTS ADD_ENTRYPOINT_OBJ_SPECIAL_OBJECTS)
+      get_target_property(obj_type ${obj_target} "TARGET_TYPE")
+      if((NOT obj_type) OR (NOT (${obj_type} STREQUAL ${OBJECT_LIBRARY_TARGET_TYPE})))
+        continue()
+      endif()
+      # If a dependency is also a object file library, we will collect the list of
+      # object files from it.
+      get_target_property(obj_files ${obj_target} "OBJECT_FILES")
+      list(APPEND all_object_files ${obj_files})
+    endforeach(obj_target)
   endif()
+  list(REMOVE_DUPLICATES all_object_files)
+
   set_target_properties(
     ${target_name}
     PROPERTIES
-      "TARGET_TYPE" ${SINGLE_OBJECT_TARGET_TYPE}
-      "OBJECT_FILE" $<TARGET_OBJECTS:${target_name}>
+      "TARGET_TYPE" ${OBJECT_LIBRARY_TARGET_TYPE}
+      "OBJECT_FILES" "${all_object_files}"
   )
-endfunction(add_object)
+endfunction(add_object_library)
 
 set(ENTRYPOINT_OBJ_TARGET_TYPE "ENTRYPOINT_OBJ")
 
 # A rule for entrypoint object targets.
 # Usage:
 #     add_entrypoint_object(
 #       <target_name>
 #       [REDIRECTED] # Specified if the entrypoint is redirected.
 #       [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`>
 #     )
 function(add_entrypoint_object target_name)
   cmake_parse_arguments(
     "ADD_ENTRYPOINT_OBJ"
     "REDIRECTED" # Optional argument
     "NAME" # Single value arguments
-    "SRCS;HDRS;SPECIAL_OBJECTS;DEPENDS;COMPILE_OPTIONS"  # Multi value arguments
+    "SRCS;HDRS;DEPENDS;COMPILE_OPTIONS"  # Multi value arguments
     ${ARGN}
   )
   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()
target_include_directories(
     ${target_name}_objects
     PRIVATE
       "${LIBC_BUILD_DIR}/include;${LIBC_SOURCE_DIR};${LIBC_BUILD_DIR}"
   )
   add_dependencies(
     ${target_name}_objects
     support_common_h
   )
+  set(dep_objects "")
   if(ADD_ENTRYPOINT_OBJ_DEPENDS)
     add_dependencies(
       ${target_name}_objects
       ${ADD_ENTRYPOINT_OBJ_DEPENDS}
     )
+    foreach(dep_target IN LISTS ADD_ENTRYPOINT_OBJ_DEPENDS)
+      if(NOT TARGET ${dep_target})
+        # Not all targets will be visible. So, we will ignore those which aren't
+        # visible yet.
+        continue()
+      endif()
+      get_target_property(obj_type ${dep_target} "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
+        # only from add_object_library targets.
+        continue()
+      endif()
+      # Calling get_target_property requires that the target be visible at this
+      # point. For object library dependencies, this is a reasonable requirement.
+      # We can revisit this in future if we need cases which break under this
+      # requirement.
+      get_target_property(obj_files ${dep_target} "OBJECT_FILES")
+      list(APPEND dep_objects ${obj_files})
+    endforeach(dep_target)
   endif()
+  list(REMOVE_DUPLICATES dep_objects)
+
   if(ADD_ENTRYPOINT_OBJ_COMPILE_OPTIONS)
     target_compile_options(
       ${target_name}_objects
       PRIVATE ${ADD_ENTRYPOINT_OBJ_COMPILE_OPTIONS}
     )
   endif()
 
   set(object_file_raw "${CMAKE_CURRENT_BINARY_DIR}/${target_name}_raw.o")
   set(object_file "${CMAKE_CURRENT_BINARY_DIR}/${target_name}.o")
 
   set(input_objects $<TARGET_OBJECTS:${target_name}_objects>)
-  if(ADD_ENTRYPOINT_OBJ_SPECIAL_OBJECTS)
-    foreach(obj_target IN LISTS ADD_ENTRYPOINT_OBJ_SPECIAL_OBJECTS)
-      get_target_property(obj_type ${obj_target} "TARGET_TYPE")
-      if((NOT obj_type) OR (NOT (${obj_type} STREQUAL ${SINGLE_OBJECT_TARGET_TYPE})))
-        message(FATAL_ERROR "Unexpected target type for 'SPECIAL_OBJECT' - should be a target introduced by the `add_object` rule.")
-      endif()
-      list(APPEND input_objects $<TARGET_OBJECTS:${obj_target}>)
-    endforeach(obj_target)
-  endif()
-
   add_custom_command(
     OUTPUT ${object_file_raw}
     DEPENDS ${input_objects}
     COMMAND ${CMAKE_LINKER} -r ${input_objects} -o ${object_file_raw}
   )
 
   set(alias_attributes "0,function,global")
   if(ADD_ENTRYPOINT_OBJ_REDIRECTED)
     set(alias_attributes "${alias_attributes},hidden")
   endif()
 
   add_custom_command(
     OUTPUT ${object_file}
     # We llvm-objcopy here as GNU-binutils objcopy does not support the 'hidden' flag.
     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}
   )
 
   add_custom_target(
     ${target_name}
     ALL
     DEPENDS ${object_file}
   )
+  set(all_objects ${object_file})
+  list(APPEND all_objects ${dep_objects})
+  set(all_objects_raw ${object_file_raw})
+  list(APPEND all_objects_raw ${dep_objects})
   set_target_properties(
     ${target_name}
     PROPERTIES
       "TARGET_TYPE" ${ENTRYPOINT_OBJ_TARGET_TYPE}
-      "OBJECT_FILE" ${object_file}
-      "OBJECT_FILE_RAW" ${object_file_raw}
+      "OBJECT_FILES" "${all_objects}"
+      "OBJECT_FILES_RAW" "${all_objects_raw}"
   )
 endfunction(add_entrypoint_object)
 
 # A rule to build a library from a collection of entrypoint objects.
 # Usage:
 #     add_entrypoint_library(
 #       DEPENDS <list of add_entrypoint_object targets>
 #     )
 function(add_entrypoint_library target_name)
   cmake_parse_arguments(
     "ENTRYPOINT_LIBRARY"
     "" # No optional arguments
     "" # No single value arguments
     "DEPENDS" # Multi-value arguments
     ${ARGN}
   )
   if(NOT ENTRYPOINT_LIBRARY_DEPENDS)
     message(FATAL_ERROR "'add_entrypoint_library' target requires a DEPENDS list of 'add_entrypoint_object' targets.")
   endif()
 
   set(obj_list "")
   foreach(dep IN LISTS ENTRYPOINT_LIBRARY_DEPENDS)
     get_target_property(dep_type ${dep} "TARGET_TYPE")
-    string(COMPARE EQUAL ${dep_type} ${ENTRYPOINT_OBJ_TARGET_TYPE} dep_is_entrypoint)
-    if(NOT dep_is_entrypoint)
+    if(NOT (${dep_type} STREQUAL ${ENTRYPOINT_OBJ_TARGET_TYPE}))
       message(FATAL_ERROR "Dependency '${dep}' of 'add_entrypoint_collection' is not an 'add_entrypoint_object' target.")
     endif()
-    get_target_property(target_obj_file ${dep} "OBJECT_FILE")
-    list(APPEND obj_list "${target_obj_file}")
+    get_target_property(target_obj_files ${dep} "OBJECT_FILES")
+    list(APPEND obj_list "${target_obj_files}")
   endforeach(dep)
+  list(REMOVE_DUPLICATES obj_list)
 
   set(library_file "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}${target_name}${CMAKE_STATIC_LIBRARY_SUFFIX}")
   add_custom_command(
     OUTPUT ${library_file}
     COMMAND ${CMAKE_AR} -r ${library_file} ${obj_list}
     DEPENDS ${obj_list}
   )
   add_custom_target(
function(add_libc_unittest target_name)
   endif()
   if(NOT LIBC_UNITTEST_DEPENDS)
     message(FATAL_ERROR "'add_libc_unittest' target requires a DEPENDS list of 'add_entrypoint_object' targets.")
   endif()
 
   set(library_deps "")
   foreach(dep IN LISTS LIBC_UNITTEST_DEPENDS)
     get_target_property(dep_type ${dep} "TARGET_TYPE")
-    if (dep_type)
-      string(COMPARE EQUAL ${dep_type} ${ENTRYPOINT_OBJ_TARGET_TYPE} dep_is_entrypoint)
-      if(dep_is_entrypoint)
-        get_target_property(obj_file ${dep} "OBJECT_FILE_RAW")
-        list(APPEND library_deps ${obj_file})
-        continue()
-      endif()
+    if(${dep_type} STREQUAL ${ENTRYPOINT_OBJ_TARGET_TYPE})
+      get_target_property(obj_files ${dep} "OBJECT_FILES_RAW")
+      list(APPEND library_deps ${obj_files})
+    elseif(${dep_type} STREQUAL ${OBJECT_LIBRARY_TARGET_TYPE})
+      get_target_property(obj_files ${dep} "OBJECT_FILES")
+      list(APPEND library_deps ${obj_files})
     endif()
     # TODO: Check if the dep is a normal CMake library target. If yes, then add it
     # to the list of library_deps.
   endforeach(dep)
+  list(REMOVE_DUPLICATES library_deps)
 
   add_executable(
     ${target_name}
     EXCLUDE_FROM_ALL
     ${LIBC_UNITTEST_SRCS}
     ${LIBC_UNITTEST_HDRS}
   )
   target_include_directories(
function(add_libc_fuzzer target_name)
   endif()
 
   set(library_deps "")
   foreach(dep IN LISTS LIBC_FUZZER_DEPENDS)
     get_target_property(dep_type ${dep} "TARGET_TYPE")
     if (dep_type)
       string(COMPARE EQUAL ${dep_type} ${ENTRYPOINT_OBJ_TARGET_TYPE} dep_is_entrypoint)
       if(dep_is_entrypoint)
-        get_target_property(obj_file ${dep} "OBJECT_FILE_RAW")
+        get_target_property(obj_file ${dep} "OBJECT_FILES_RAW")
         list(APPEND library_deps ${obj_file})
         continue()
       endif()
     endif()
     # TODO: Check if the dep is a normal CMake library target. If yes, then add it
     # to the list of library_deps.
   endforeach(dep)
 

libc/loader/linux/CMakeLists.txt

 function(add_loader_object name)
   cmake_parse_arguments(
     "ADD_LOADER_OBJECT"
     ""    # No option arguments
     "SRC" # Single value arguments
     "DEPENDS;COMPILE_OPTIONS" # Multi value arguments
     ${ARGN}
   )
-  add_object(
+  add_object_library(
     ${name}_object
-    SRC ${ADD_LOADER_OBJECT_SRC}
+    SRCS ${ADD_LOADER_OBJECT_SRC}
     DEPENDS ${ADD_LOADER_OBJECT_DEPENDS}
     COMPILE_OPTIONS ${ADD_LOADER_OBJECT_COMPILE_OPTIONS}
   )
 
   set(objfile ${LIBC_BUILD_DIR}/lib/${name}.o)
   add_custom_command(
     OUTPUT ${objfile}
     COMMAND cp $<TARGET_OBJECTS:${name}_object> ${objfile}
     DEPENDS $<TARGET_OBJECTS:${name}_object>
   )
   add_custom_target(
     ${name}
     DEPENDS ${objfile}
   )
   set_target_properties(
     ${name}
     PROPERTIES
       "TARGET_TYPE" "LOADER_OBJECT"
-      "OBJECT_FILE" ${objfile}
+      "OBJECT_FILES" ${objfile}
   )
 endfunction()
 
 add_subdirectory(${LIBC_TARGET_MACHINE})

libc/src/signal/linux/CMakeLists.txt

 
 add_entrypoint_object(
   raise
   SRCS
     raise.cpp
   HDRS
     signal.h
     ../raise.h
   DEPENDS
     sys_syscall_h
     linux_syscall_h
     signal_h
 )
 
-add_object(
+add_object_library(
   __restore
-  SRC
+  SRCS
     __restore.cpp
   COMPILE_OPTIONS
     -fomit-frame-pointer
     -O3
     -Wframe-larger-than=0
     -Werror
     -Wno-attributes
     # asan creates asan.module_ctor which uses stack space, causing warinngs.
add_entrypoint_object(
   HDRS
     signal.h
     ../sigaction.h
   DEPENDS
     __restore
     sys_syscall_h
     linux_syscall_h
     signal_h
-  SPECIAL_OBJECTS
-    __restore
 )
 
 add_entrypoint_object(
   sigprocmask
   SRCS
     sigprocmask.cpp
   HDRS
     signal.h

libc/test/loader/CMakeLists.txt

function(add_loader_test target_name)
   )
 
   set_target_properties(${target_name} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 
   set(dep_objects "")
   if(ADD_LOADER_TEST_DEPENDS)
     add_dependencies(${target_name} ${ADD_LOADER_TEST_DEPENDS})
     foreach(dep IN LISTS ADD_LOADER_TEST_DEPENDS)
-      get_target_property(objfile ${dep} "OBJECT_FILE")
+      get_target_property(objfile ${dep} "OBJECT_FILES")
       if(NOT objfile)
         message(
             FATAL_ERROR
             "Unexpected dependency of an `add_loader_test` target. A dependency "
             "should be a target of type `add_entrypoint_object, `add_object`, or "
             "`add_loader_object`.")
       endif()
       list(APPEND dep_objects ${objfile})

libc/test/src/signal/CMakeLists.txt

add_libc_unittest(
   SRCS
     sigaction_test.cpp
   DEPENDS
     sigaction
     raise
     signal_h
     errno_h
     __errno_location
-    __restore
 )
 
 add_libc_unittest(
   sigprocmask_test
   SUITE
     libc_signal_unittests
   SRCS
     sigprocmask_test.cpp