[libc] Add integration tests.

[PaulkaToast]

Summary

This patch aims to add integration tests to check the following:

1. Header files are generated as expected.
2. Libc functions have the correct public name.
3. Libc functions have the correct return type and parameter types.
4. Symbols are exposed in the public lib.a files.

[sivachandra]

Few high level comments and questions:

• Instead of creating a target for every entrypoint, have you considered generating a single file which:
  1. Includes all header files listed in the api.td.
  2. Lists cpp:Function pointers to all functions as required by api.td.

There definitely are problems that need to be solved with this approach. For example, how do you ensure all public header files are already present in the build/.../libc/include directory. But, the appeal of this approach is that one does not have to create explicit or implicit targets for "integration tests". There would be just one target which would test everything in one go.

• In general, I don't think we should expect that internal API to match the public API. For example, we might choose to give internal types names which are different from the public names. So, I think the second kind of tests you mention in your description is not required as it is restrictive.

• Using -nostdinc would require us to explicitly list path to the linux headers for entrypoints which depend on the linux header files, which will very likely bring all headers into the include path. Do you have any ideas on how to get around it?

• Using -nostdlib results in an incomplete link. For ELF, most linkers only give a warning about missing _start symbol, but the resulting exe is bad/incomplete. Do you have any plans to ensure that the link is complete, resulting in an exe which can be executed?

[abrachet]

In D79192#2015295, @sivachandra wrote:

Few high level comments and questions:

• Instead of creating a target for every entrypoint, have you considered generating a single file which:
  1. Includes all header files listed in the api.td.
  2. Lists cpp:Function pointers to all functions as required by api.td.

There definitely are problems that need to be solved with this approach. For example, how do you ensure all public header files are already present in the build/.../libc/include directory. But, the appeal of this approach is that one does not have to create explicit or implicit targets for "integration tests". There would be just one target which would test everything in one go.

+1 to doing this just from api.td. As for the includes, I think it would be wise for us to make the header files dependencies of llvmlibc or maybe better create a libc_headers target to generate all of our headers.

• In general, I don't think we should expect that internal API to match the public API. For example, we might choose to give internal types names which are different from the public names. So, I think the second kind of tests you mention in your description is not required as it is restrictive.

Agreed. I think there are a few places already we use an internal __llvm_libc types I think these would break. That being said because we are doing that, it is important to test that the external api is compatible with the internal one, I cant think of a great way to do that though.

libc/utils/HdrGen/PrototypeTestGen/PrototypeTestGen.cpp

49

It was just recently renamed to Function But I think it makes more semantic sense to use cpp::IsSame<[type], decltype(EntryPointNameOption)>

[PaulkaToast]

In D79192#2015295, @sivachandra wrote:

• Instead of creating a target for every entrypoint, have you considered generating a single file which:
  1. Includes all header files listed in the api.td.
  2. Lists cpp:Function pointers to all functions as required by api.td.

There definitely are problems that need to be solved with this approach. For example, how do you ensure all public header files are already present in the build/.../libc/include directory. But, the appeal of this approach is that one does not have to create explicit or implicit targets for "integration tests". There would be just one target which would test everything in one go.

Good idea, this is done and the new integration test file now looks like this:

...
#include <unistd.h>
#include <sys/mman.h>
#include <math.h>

int main() {
  static_assert(__llvm_libc::cpp::IsSame<int(int), decltype(raise)>::Value, "raise prototype in TableGen does not match public header");
  static_assert(__llvm_libc::cpp::IsSame<int(int, const struct sigaction *__restrict, struct sigaction *__restrict), decltype(sigaction)>::Value, "sigaction prototype in TableGen does not match public header");
  static_assert(__llvm_libc::cpp::IsSame<int(sigset_t *, int), decltype(sigdelset)>::Value, "sigdelset prototype in TableGen does not match public header");
...

Thanks to @abrachet's suggestion of using IsSame we also get nice error messages. As for ensuring all public header files are present I added a top-level target for the headers that we can depend on here (same as @abrachet mentioned)

• In general, I don't think we should expect that internal API to match the public API. For example, we might choose to give internal types names which are different from the public names. So, I think the second kind of tests you mention in your description is not required as it is restrictive.

Done, this only tests the public/libc user perspective now.

• Using -nostdinc would require us to explicitly list path to the linux headers for entrypoints which depend on the linux header files, which will very likely bring all headers into the include path. Do you have any ideas on how to get around it?

For now I've commented out -nostdinc with a TODO, the most straightforward way would be to have our public headers not depend on Linux dev headers but another approach could be to use our clang-tidy RestrictSystemIncludes check to ensure only the right Linux header gets included (this would add a dependency on clang-tidy for the integration tests though)

• Using -nostdlib results in an incomplete link. For ELF, most linkers only give a warning about missing _start symbol, but the resulting exe is bad/incomplete. Do you have any plans to ensure that the link is complete, resulting in an exe which can be executed?

My earlier iteration of this had us linking with the loader for a complete executable link. However, since we now check everything statically, I think it's enough if the integration test compiles and links as this ensures the libc symbols are present and the types are compatible. We could add the loader again if you think it's necessary.

libc/utils/HdrGen/PrototypeTestGen/PrototypeTestGen.cpp

49

Thanks!

[abrachet]

libc/utils/HdrGen/PrototypeTestGen/PrototypeTestGen.cpp

25

Is there a reason for this to be namespaced? Should we use __llvm_libc instead?

28

Unecessary.

31–33

Don't need the brackets

37–42

These could be combined to

auto it = G->FunctionSpecMap.find(entrypoint);
if (it == G->FunctionSpecMap.end()) {} // error
llvm::Record *functionSpec = *it;

so as to not search twice.

46–49

_Noreturn isn't a C++ keyword, otherwise the type system shouldn't care about attributes no matter where they show up. I think instead of removing these manually we should just include __llvm-libc-common.h which will define this as [[noreturn]] we might in the future use other macros in type names.

53

for (size_t i = 0, size = args.size(); i < size; ++i)? I believe the code standards prefers this

76

& not necessary, I believe.

libc/utils/HdrGen/PublicAPICommand.cpp

111

PublicHeaders.emplace(Header)

187

explicit maybe?

280–282

Is this simpler than just using std::make_unique<APIGenerator>(Records); wherever it would be used?

[PaulkaToast]

libc/utils/HdrGen/PrototypeTestGen/PrototypeTestGen.cpp

46–49

We are already expanding this

projects/libc/lib/public_integration_test.cpp:23:42: error: expected variable name or 'this' in lambda capture list
  static_assert(__llvm_libc::cpp::IsSame<_Noreturn void(void), decltype(abort)>::Value, "abort prototype in TableGen does not match public header");
                                         ^
projects/libc/include/__llvm-libc-common.h:21:20: note: expanded from macro '_Noreturn'
#define _Noreturn [[noreturn]]

It seems square bracket [[attributes]] cannot be used on plain types/templates/outside definitions, the compiler thinks we are trying to define a lambda function.
https://godbolt.org/z/bMFzfy

Trying to use [[attributes]] in a using statement results in a similar error.

libc/utils/HdrGen/PublicAPICommand.cpp

280–282

I didn't want to take the whole class and expose it, just the parts I needed.

[sivachandra]

In D79192#2024575, @PaulkaToast wrote:

...
#include <unistd.h>
#include <sys/mman.h>
#include <math.h>

int main() {
  static_assert(__llvm_libc::cpp::IsSame<int(int), decltype(raise)>::Value, "raise prototype in TableGen does not match public header");
  static_assert(__llvm_libc::cpp::IsSame<int(int, const struct sigaction *__restrict, struct sigaction *__restrict), decltype(sigaction)>::Value, "sigaction prototype in TableGen does not match public header");
  static_assert(__llvm_libc::cpp::IsSame<int(sigset_t *, int), decltype(sigdelset)>::Value, "sigdelset prototype in TableGen does not match public header");
...

Thanks to @abrachet's suggestion of using IsSame we also get nice error messages. As for ensuring all public header files are present I added a top-level target for the headers that we can depend on here (same as @abrachet mentioned)

LG

• Using -nostdinc would require us to explicitly list path to the linux headers for entrypoints which depend on the linux header files, which will very likely bring all headers into the include path. Do you have any ideas on how to get around it?

For now I've commented out -nostdinc with a TODO, the most straightforward way would be to have our public headers not depend on Linux dev headers but another approach could be to use our clang-tidy RestrictSystemIncludes check to ensure only the right Linux header gets included (this would add a dependency on clang-tidy for the integration tests though)

I think we should be complete here. Lets split this change into two changes:

1. First change will add a target to build the main object but not the full executable. In this change, we will make use of clang-tidy to ensure only LLVM-libc or platform or compiler headers are being included.
2. Second change will add a target to link this main object with the loader object making it a true integration test.

Before you make changes, I want to bring up few other high-level points for discussion:

1. The list of public headers should be determined by the target config. However, we don't have a way for a config to list the public headers it wants. We can take two approaches here again: provide a rule to list a target for public headers, or just list the targets for the headers in .txt file. I would prefer keeping it simple and just requiring .txt file which defines a CMake list of targets for public headers. The CMake file listing the integration test target will include this file to set up the dependencies. Something like this:

# config/linux/headers.txt:

set(PUBLIC_HEADERS
  libc.include.math
  libc.inlcude.signal
  ...
)

And:

# integration_test/CMakeLists.txt
include("config/${LIBC_TARGET_OS}/headers.txt")
...

2. The list of entrypoints that go into a .a file should also be determined by the target config. This can also be done by listing the entrypoint targets in a, say entrypoints.txt file. The file lib/CMakeLists.txt can include this file and get the entrypoints for the various static libraries, just like above. This mechanism can also help us skip building and testing entrypoint targets if a config doesn't list it in its entrypoints.txt file.

WDYT?

[PaulkaToast]

Sorry for the delayed response!

I like idea of a .txt for both the headers and the entrypoints. This is nice because it also prevents us from building and including platform specific headers e.g fcntl.h which is on Linux but not on Windows.
Will send out a revised diff soon. (:

As for the Linux dev headers I think instead of a work around using clang-tidy, it might just be better to remove our dependency on the dev headers all together, especially since the dev headers differ between platforms such as sigset_t on AARCH64 vs x86.
I can send out a separate patch out for this as well.

[sivachandra]

In D79192#2048277, @PaulkaToast wrote:

As for the Linux dev headers I think instead of a work around using clang-tidy, it might just be better to remove our dependency on the dev headers all together, especially since the dev headers differ between platforms such as sigset_t on AARCH64 vs x86.
I can send out a separate patch out for this as well.

What do you mean remove the dependency on dev headers? Does it mean that we make copies of linux definitions in LLVM libc tree?

[PaulkaToast]

In D79192#2048306, @sivachandra wrote:

In D79192#2048277, @PaulkaToast wrote:

As for the Linux dev headers I think instead of a work around using clang-tidy, it might just be better to remove our dependency on the dev headers all together, especially since the dev headers differ between platforms such as sigset_t on AARCH64 vs x86.
I can send out a separate patch out for this as well.

What do you mean remove the dependency on dev headers? Does it mean that we make copies of linux definitions in LLVM libc tree?

As we discussed offline, the approach I was thinking would involve duplicating a lot of definitions from the linux headers. So I decided to take the approach you suggested and use clang-tidy to ensure we're including the correct headers in the test.

[sivachandra]

libc/CMakeLists.txt

85

Why is this change required?

libc/cmake/modules/LLVMLibCLibraryRules.cmake

93

Call this entry point *name* list throughout to avoid confusion with target names.

libc/cmake/modules/LLVMLibCObjectRules.cmake

1

Seems to me like the changes in this file should be separated out into a different patch.

libc/config/linux/entrypoints.txt

1

This LGTM. But, do you think it makes sense to put this in a target machine specific directory (config/linux/x86_64/entrypoints.txt)? For example, almost everything under LIBC_ENTRYPOINTS currently is x86_64 specific. So, putting these in a machine specific list helps us build the libc for different machine types independent of each of other.

libc/config/linux/headers.txt

1

The same would be true for headers also I suppose but we can do that separately as it does not interfere with the current patch?

libc/lib/CMakeLists.txt

22

AFAICT, this is the only place this rule is being used. Do you see it being used anywhere else? If not, just inline everything here. May be even put it under the test directory and not here?

libc/utils/HdrGen/PublicAPICommand.h

42

I see only one specialization of this class. In which case, why is this need?

[PaulkaToast]

libc/CMakeLists.txt

85

Due to the changes below its no longer required (:

libc/cmake/modules/LLVMLibCObjectRules.cmake

1

Yes, I could pull it out into another patch but this is the only current use case for this change so maybe its better to leave it in this patch? wdyt?

libc/config/linux/entrypoints.txt

1

I'm not necessarily opposed to this, although I'm not sure I know of a case where the libc differs for different architectures on linux. If the need arises it should be a very simple change to make if/when we encounter it.

libc/config/linux/headers.txt

1

yes, we can evaluate this in a different patch.

libc/lib/CMakeLists.txt

22

Ah, yes this was useful for when I was testing individual libraries but now there is no need for the function so I'll inline it instead. This also removes the reordering issue from above. Thanks!

libc/utils/HdrGen/PublicAPICommand.h

42

Right now the APIGenerator is defined in the .cpp file, so this is used to expose the parts we want. The alternative is to expose the APIGenerator class in the header, but that'd be a larger refactor. It can be done though, which would you prefer?

[sivachandra]

libc/cmake/modules/LLVMLibCObjectRules.cmake

1

OK

libc/config/linux/entrypoints.txt

1

My comment is more for our convenience while we are building the libc for different target machine architectures. Having just one linux list means that while the implementation for other architectures is incomplete, our build infrastructure will keep failing at different places.

libc/utils/HdrGen/PublicAPICommand.h

42

Yes. Refactor it separately. It need not really be a refactor. I am OK even if you just make API generator public. As it stands in this patch, the specialization and the base class have no meaning as makeAPIReader is really not a factory method.

Splitting the CMake parts and the hdrgen parts into two patches makes it easier for me to review as well.

[PaulkaToast]

libc/config/linux/entrypoints.txt

1

Ah, this is a good point. If you are porting to another architecture and building it out its much more convenient to do it in pieces, a few entrpoints at a time, which multiple lists allow. Done.

libc/utils/HdrGen/PublicAPICommand.h

42

Okay, this is now pulled into a desperate patch: D80832.
When that patch gets merged in I'll pull it in here and update the diff.

[sivachandra]

libc/utils/HdrGen/PublicAPICommand.h

42

[This is very likely a typo but funny.]
No, my intention was not to make you feel desperate.

[PaulkaToast]

libc/utils/HdrGen/PublicAPICommand.h

42

I'm so sorry that was a typo, meant to write "separate". 😅

[sivachandra]

Accepting now. The one comment I added can be addressed separately.

libc/test/src/CMakeLists.txt

96 ↗

(On Diff #267708)

Why not include the loader here?

[PaulkaToast]

libc/test/src/CMakeLists.txt

96 ↗

(On Diff #267708)

Yes, this will be incorporated in part 2, as per this comment.

https://reviews.llvm.org/D79192#2027676

I think we should be complete here. Lets split this change into two changes:

1. First change will add a target to build the main object but not the full executable. In this change, we will make use of clang-tidy to ensure only LLVM-libc or platform or compiler headers are being included.
2. Second change will add a target to link this main object with the loader object making it a true integration test.

libc/CMakeLists.txt

 
 # The loader can potentially depend on the library components so add it
 # after the library implementation directories.
 add_subdirectory(loader)
 
 # The lib and test directories are added at the very end as tests
 # and libraries potentially draw from the components present in all
 # of the other directories.
-add_subdirectory(lib)
 if(LLVM_INCLUDE_TESTS)
   add_subdirectory(test)
   add_subdirectory(fuzzing)
 endif()
+add_subdirectory(lib)

libc/cmake/modules/LLVMLibCLibraryRules.cmake

function(add_entrypoint_library target_name)
   )
   if(NOT ENTRYPOINT_LIBRARY_DEPENDS)
     message(FATAL_ERROR "'add_entrypoint_library' target requires a DEPENDS list "
                         "of 'add_entrypoint_object' targets.")
   endif()
 
   get_fq_deps_list(fq_deps_list ${ENTRYPOINT_LIBRARY_DEPENDS})
   get_object_files_for_entrypoint_library(obj_list ${fq_deps_list})
+  set(entrypoint_list  "")
   foreach(dep IN LISTS fq_deps_list)
     get_target_property(dep_type ${dep} "TARGET_TYPE")
     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_entrypoint_object_file(${dep} objfile)
+    get_target_property(entrypoint ${dep} "ENTRYPOINT_NAME")
     list(APPEND obj_list ${objfile})
+    list(APPEND entrypoint_list ${entrypoint})
   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(
     ${target_name}
     ALL
     DEPENDS ${library_file}
   )
+  set_target_properties(
+    ${target_name}
+    PROPERTIES
+    LIBRARY_FILE ${library_file}
+    ENTRYPOINTS_LIST "${entrypoint_list}"
+  )
 endfunction(add_entrypoint_library)
 
 # Rule to build a shared library of redirector objects.
 function(add_redirector_library target_name)
   cmake_parse_arguments(
     "REDIRECTOR_LIBRARY"
     ""
     ""
function(add_header_library target_name)
   add_dependencies(${fq_target_name} ${interface_target_name})
   set_target_properties(
     ${fq_target_name}
     PROPERTIES
       "TARGET_TYPE" "${HDR_LIBRARY_TARGET_TYPE}"
       "DEPS" "${fq_deps_list}"
   )
 endfunction(add_header_library)
+
+# Rule to add a libc public integration test.
+# Usage
+#    add_libc_public_integration_test(
+#      <target name>
+#      LIBS <list of public libraries to link against>
+#    )
+function(add_libc_public_integration_test target_name)
+  if(NOT LLVM_INCLUDE_TESTS)
+    return()
+  endif()
+
+  cmake_parse_arguments(
+    "LIBC_INTTEST"
+    "" # No option arguments
+    "" # No Single value arguments
+    "LIBS;PUBLIC_HDRS" # Multi value arguments
+    ${ARGN}
+  )
+
+  set(public_test ${CMAKE_CURRENT_BINARY_DIR}/${target_name}.cpp)
+
+  set(entrypoints_list "")
+  foreach(lib IN LISTS LIBC_INTTEST_LIBS)
+    get_target_property(entrypoints ${lib} "ENTRYPOINTS_LIST")
+    list(APPEND entrypoints_list ${entrypoints})
+  endforeach()
+  # TODO: Remove these when they are added to the TableGen.
+  list(REMOVE_ITEM entrypoints_list "__assert_fail" "__errno_location")
+  list(TRANSFORM entrypoints_list PREPEND "-e=")
+
+  # Generate integration test souce code.
+  add_custom_command(
+    OUTPUT ${public_test}
+    COMMAND $<TARGET_FILE:libc-prototype-testgen> -o ${public_test}
+            ${entrypoints_list}
+            -I ${LIBC_SOURCE_DIR}
+            ${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/api.td
+
+    DEPENDS ${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/api.td
+            libc-prototype-testgen ${LIBC_INTTEST_PUBLIC_HDRS}
+  )
+
+  add_executable(
+    ${target_name}
+    EXCLUDE_FROM_ALL
+    ${public_test}
+  )
+  # Blank out default include directories to prevent accidentally including
+  # system headers or our own internal headers.
+  set_target_properties(
+    ${target_name}
+    PROPERTIES
+    INCLUDE_DIRECTORIES ""
+  )
+  # Only include we need is the include for cpp::IsSame and our generated
+  # public headers.
+  target_include_directories(
+    ${target_name} BEFORE
+    PRIVATE
+      "${LIBC_SOURCE_DIR}/utils/CPP"
+      "${LIBC_BUILD_DIR}/include"
+  )
+  target_compile_options(
+    ${target_name}
+    PRIVATE
+    -ffreestanding
+  )
+  target_link_options(
+    ${target_name}
+    PRIVATE "-nostdlib"
+  )
+  set(library_files)
+  foreach(library_name IN LISTS LIBC_INTTEST_LIBS)
+    get_target_property(library_file ${library_name} "LIBRARY_FILE")
+    list(APPEND library_files ${library_file})
+  endforeach()
+
+  if(COMPILER_RESOURCE_DIR AND LLVM_LIBC_ENABLE_LINTING)
+    add_custom_target(
+      ${target_name}-tidy
+      VERBATIM
+      COMMAND $<TARGET_FILE:clang-tidy> --system-headers
+        --checks=-*,llvmlibc-restrict-system-libc-headers
+        "--extra-arg=-resource-dir=${COMPILER_RESOURCE_DIR}"
+        --header-filter=.*
+        --warnings-as-errors=llvmlibc-*
+        "-config={CheckOptions: [{key: llvmlibc-restrict-system-libc-headers.Includes, value: '-*, linux/*, asm/*.h, asm-generic/*.h'}]}"
+        --quiet
+        -p ${PROJECT_BINARY_DIR}
+        ${public_test}
+      DEPENDS
+        clang-tidy ${public_test}
+    )
+    add_dependencies(check-libc ${target_name}-tidy)
+  endif()
+
+  target_link_libraries(${target_name}
+    PRIVATE
+    ${library_files}
+  )
+  add_dependencies(check-libc ${target_name})
+endfunction(add_libc_public_integration_test)

libc/cmake/modules/LLVMLibCObjectRules.cmake

 set(OBJECT_LIBRARY_TARGET_TYPE "OBJECT_LIBRARY")
 
 # 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>
cmake_parse_arguments(
     "ADD_ENTRYPOINT_OBJ"
     "ALIAS;REDIRECTED" # Optional argument
     "NAME" # Single value arguments
     "SRCS;HDRS;DEPENDS;COMPILE_OPTIONS"  # Multi value arguments
     ${ARGN}
   )
 
   get_fq_target_name(${target_name} fq_target_name)
+  set(entrypoint_name ${target_name})
+  if(ADD_ENTRYPOINT_OBJ_NAME)
+    set(entrypoint_name ${ADD_ENTRYPOINT_OBJ_NAME})
+  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()
if(ADD_ENTRYPOINT_OBJ_ALIAS)
 
     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" ${entrypoint_name}
         "TARGET_TYPE" ${ENTRYPOINT_OBJ_TARGET_TYPE}
         "IS_ALIAS" "YES"
         "OBJECT_FILE" ""
         "OBJECT_FILE_RAW" ""
         "DEPS" "${fq_dep_name}"
     )
     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()
 
-  set(entrypoint_name ${target_name})
-  if(ADD_ENTRYPOINT_OBJ_NAME)
-    set(entrypoint_name ${ADD_ENTRYPOINT_OBJ_NAME})
-  endif()
-
   set(objects_target_name "${fq_target_name}_objects")
 
   add_library(
     ${objects_target_name}
     # We want an object library as the objects will eventually get packaged into
     # an archive (like libc.a).
     OBJECT
     ${ADD_ENTRYPOINT_OBJ_SRCS}
function(add_entrypoint_object target_name)
   add_custom_target(
     ${fq_target_name}
     ALL
     DEPENDS ${object_file}
   )
   set_target_properties(
     ${fq_target_name}
     PROPERTIES
+      "ENTRYPOINT_NAME" ${entrypoint_name}
       "TARGET_TYPE" ${ENTRYPOINT_OBJ_TARGET_TYPE}
       "OBJECT_FILE" "${object_file}"
       "OBJECT_FILE_RAW" "${object_file_raw}"
       "DEPS" "${fq_deps_list}"
   )
 
   if(LLVM_LIBC_ENABLE_LINTING)
 
add_custom_command(
       # 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.
       COMMAND "${CMAKE_COMMAND}" -E touch ${lint_timestamp}
       COMMENT "Linting... ${target_name}"
-      DEPENDS ${clang-tidy} ${objects_target_name} ${ADD_ENTRYPOINT_OBJ_SRCS}
+      DEPENDS clang-tidy ${objects_target_name} ${ADD_ENTRYPOINT_OBJ_SRCS}
       WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
     )
 
     add_custom_target(${fq_target_name}.__lint__
       DEPENDS ${lint_timestamp})
     add_dependencies(lint-libc ${fq_target_name}.__lint__)
     add_dependencies(${fq_target_name} ${fq_target_name}.__lint__)
   endif()

libc/config/linux/entrypoints.txt

-
-add_entrypoint_library(
-  llvmlibc
-  DEPENDS
+set(LIBC_ENTRYPOINTS
     # assert.h entrypoints
     libc.src.assert.__assert_fail
 
     # errno.h entrypoints
     libc.src.errno.__errno_location
 
     # signal.h entrypoints
     libc.src.signal.raise
     libc.src.signal.sigaction
     libc.src.signal.sigdelset
     libc.src.signal.sigaddset
     libc.src.signal.sigemptyset
     libc.src.signal.sigprocmask
     libc.src.signal.sigfillset
     libc.src.signal.signal
 
     # stdlib.h entrypoints
     libc.src.stdlib._Exit
     libc.src.stdlib.abort
 
     # string.h entrypoints
-    libc.src.string.bzero
     libc.src.string.memcpy
-    libc.src.string.memset
-    libc.src.string.strcat
     libc.src.string.strcpy
+    libc.src.string.strcat
     libc.src.string.strlen
 
     # sys/mman.h entrypoints
     libc.src.sys.mman.mmap
     libc.src.sys.mman.munmap
 
     # threads.h entrypoints
     libc.src.threads.mtx_init
     libc.src.threads.mtx_lock
     libc.src.threads.mtx_unlock
     libc.src.threads.thrd_create
     libc.src.threads.thrd_join
 
     # unistd.h entrypoints
     libc.src.unistd.write
 )
 
-add_entrypoint_library(
-  llvmlibm
-  DEPENDS
+set(LIBM_ENTRYPOINTS
     # math.h entrypoints
     libc.src.math.cosf
-    libc.src.math.fabs
-    libc.src.math.fabsf
-    libc.src.math.expf
-    libc.src.math.exp2f
     libc.src.math.round
     libc.src.math.sincosf
     libc.src.math.sinf
-)
-
-add_redirector_library(
-  llvmlibc_redirectors
-  DEPENDS
-    round_redirector
-)
+)

libc/config/linux/headers.txt

+set(PUBLIC_HEADERS
+    libc.include.assert_h
+    libc.include.errno
+    libc.include.math
+    libc.include.signal
+    libc.include.stdio
+    libc.include.stdlib
+    libc.include.sys_mman
+    libc.include.sys_syscall
+    libc.include.threads
+    libc.include.unistd
+)

libc/include/CMakeLists.txt

-
 add_header(
   llvm_libc_common_h
   HDR
     __llvm-libc-common.h
 )
 
 add_header(
   libc_posix_types

libc/lib/CMakeLists.txt

+include("${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/entrypoints.txt")
+include("${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/headers.txt")
 
 add_entrypoint_library(
   llvmlibc
   DEPENDS
-    # assert.h entrypoints
-    libc.src.assert.__assert_fail
-
-    # errno.h entrypoints
-    libc.src.errno.__errno_location
-
-    # signal.h entrypoints
-    libc.src.signal.raise
-    libc.src.signal.sigaction
-    libc.src.signal.sigdelset
-    libc.src.signal.sigaddset
-    libc.src.signal.sigemptyset
-    libc.src.signal.sigprocmask
-    libc.src.signal.sigfillset
-    libc.src.signal.signal
-
-    # stdlib.h entrypoints
-    libc.src.stdlib._Exit
-    libc.src.stdlib.abort
-
-    # string.h entrypoints
-    libc.src.string.bzero
-    libc.src.string.memcpy
-    libc.src.string.memset
-    libc.src.string.strcat
-    libc.src.string.strcpy
-    libc.src.string.strlen
-
-    # sys/mman.h entrypoints
-    libc.src.sys.mman.mmap
-    libc.src.sys.mman.munmap
-
-    # threads.h entrypoints
-    libc.src.threads.mtx_init
-    libc.src.threads.mtx_lock
-    libc.src.threads.mtx_unlock
-    libc.src.threads.thrd_create
-    libc.src.threads.thrd_join
-
-    # unistd.h entrypoints
-    libc.src.unistd.write
+  ${LIBC_ENTRYPOINTS}
 )
 
 add_entrypoint_library(
   llvmlibm
   DEPENDS
-    # math.h entrypoints
-    libc.src.math.cosf
-    libc.src.math.fabs
-    libc.src.math.fabsf
-    libc.src.math.expf
-    libc.src.math.exp2f
-    libc.src.math.round
-    libc.src.math.sincosf
-    libc.src.math.sinf
+  ${LIBM_ENTRYPOINTS}
 )
 
 add_redirector_library(
   llvmlibc_redirectors
   DEPENDS
     round_redirector
 )
+
+add_libc_public_integration_test(
+  public_integration_test
+  LIBS
+    llvmlibc
+    llvmlibm
+  PUBLIC_HDRS
+    ${PUBLIC_HEADERS}
+)

libc/utils/HdrGen/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS Support)
 
 add_tablegen(libc-hdrgen llvm-libc
   Command.h
   Command.cpp
   Generator.cpp
   Generator.h
   IncludeFileCommand.cpp
   IncludeFileCommand.h
   Main.cpp
   PublicAPICommand.cpp
   PublicAPICommand.h
 )
+
+add_subdirectory(PrototypeTestGen)

libc/utils/HdrGen/PrototypeTestGen/.clang-tidy

+CheckOptions:
+  - key:             readability-identifier-naming.VariableCase
+    value:           camelBack
 No newline at end of file

libc/utils/HdrGen/PrototypeTestGen/CMakeLists.txt

+add_tablegen(libc-prototype-testgen llvm-libc
+  PrototypeTestGen.cpp
+  ../PublicAPICommand.cpp
+  ../Command.cpp
+)

libc/utils/HdrGen/PrototypeTestGen/PrototypeTestGen.cpp

+//===-- PrototypeTestGen.cpp ----------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "../PublicAPICommand.h"
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/TableGen/Main.h"
+#include "llvm/TableGen/Record.h"
+
+namespace {
+
+llvm::cl::list<std::string>
+    EntrypointNamesOption("e", llvm::cl::desc("<list of entrypoints>"),
+                          llvm::cl::OneOrMore);
+
+} // anonymous namespace
+
+bool TestGeneratorMain(llvm::raw_ostream &OS, llvm::RecordKeeper &records) {
+  OS << "#include \"TypeTraits.h\"\n";
+  auto G = llvm_libc::makeAPIReader(records);
+  for (const auto &header : G->PublicHeaders)
+    OS << "#include <" << header << ">\n";
+  OS << '\n';
+  OS << "int main() {\n";
+  for (const auto &entrypoint : EntrypointNamesOption) {
+    auto match = G->FunctionSpecMap.find(entrypoint);
+    if (match == G->FunctionSpecMap.end()) {
+      llvm::errs() << "ERROR: entrypoint '" << entrypoint
+                   << "' could not be found in spec in any public header\n";
+      return true;
+    }
+    llvm::Record *functionSpec = match->second;
+    llvm::Record *retValSpec = functionSpec->getValueAsDef("Return");
+    std::string returnType =
+        G->getTypeAsString(retValSpec->getValueAsDef("ReturnType"));
+    // _Noreturn is an indication for the compiler that a function
+    // doesn't return, and isn't a type understood by c++ templates.
+    if (llvm::StringRef(returnType).contains("_Noreturn"))
+      returnType = "void";
+
+    OS << "  static_assert(__llvm_libc::cpp::IsSame<" << returnType << '(';
+    auto args = functionSpec->getValueAsListOfDefs("Args");
+    for (size_t i = 0, size = args.size(); i < size; ++i) {
+      llvm::Record *argType = args[i]->getValueAsDef("ArgType");
+      OS << G->getTypeAsString(argType);
+      if (i < size - 1)
+        OS << ", ";
+    }
+    OS << "), decltype(" << entrypoint << ")>::Value, ";
+    OS << '"' << entrypoint
+       << " prototype in TableGen does not match public header" << '"';
+    OS << ");\n";
+  }
+
+  OS << '\n';
+  OS << "  return 0;\n";
+  OS << "}\n\n";
+
+  return false;
+}
+
+int main(int argc, char *argv[]) {
+  llvm::cl::ParseCommandLineOptions(argc, argv);
+  return TableGenMain(argv[0], TestGeneratorMain);
+}

libc/utils/HdrGen/PublicAPICommand.h

 namespace llvm {
 
 class raw_ostream;
 class Record;
 class RecordKeeper;
 
 } // namespace llvm
 
+using NameToRecordMapping = std::unordered_map<std::string, llvm::Record *>;
+using NameSet = std::unordered_set<std::string>;
+
 namespace llvm_libc {
 
 class PublicAPICommand : public Command {
 public:
   static const char Name[];
 
   void run(llvm::raw_ostream &OS, const ArgVector &Args,
            llvm::StringRef StdHeader, llvm::RecordKeeper &Records,
            const Command::ErrorReporter &Reporter) const override;
 };
 
+class APIReader {
+public:
+  // Mapping from names to records defining them.
+  NameToRecordMapping MacroSpecMap;
+  NameToRecordMapping TypeSpecMap;
+  NameToRecordMapping EnumerationSpecMap;
+  NameToRecordMapping FunctionSpecMap;
+  NameToRecordMapping MacroDefsMap;
+  NameToRecordMapping TypeDeclsMap;
+
+  NameSet Structs;
+  NameSet Enumerations;
+  NameSet Functions;
+  NameSet PublicHeaders;
+
+  virtual std::string getTypeAsString(llvm::Record *TypeRecord) = 0;
+
+  virtual ~APIReader() {}
+};
+
+std::unique_ptr<APIReader> makeAPIReader(llvm::RecordKeeper &Records);
+
 } // namespace llvm_libc
 
 #endif // LLVM_LIBC_UTILS_HDRGEN_PUBLICAPICOMMAND_H

libc/utils/HdrGen/PublicAPICommand.cpp

if (IndentSize < shortest_indent)
       shortest_indent = IndentSize;
   }
   for (llvm::StringRef L : Lines) {
     if (L.size() >= shortest_indent)
       OS << L.drop_front(shortest_indent) << '\n';
   }
 }
 
-class APIGenerator {
-  llvm::StringRef StdHeader;
+class APIGenerator : public llvm_libc::APIReader {
+  llvm::Optional<llvm::StringRef> StdHeader;
 
   // TableGen classes in spec.td.
   llvm::Record *NamedTypeClass;
   llvm::Record *PtrTypeClass;
   llvm::Record *RestrictedPtrTypeClass;
   llvm::Record *ConstTypeClass;
   llvm::Record *StructClass;
   llvm::Record *StandardSpecClass;
   llvm::Record *PublicAPIClass;
 
-  using NameToRecordMapping = std::unordered_map<std::string, llvm::Record *>;
-  using NameSet = std::unordered_set<std::string>;
-
-  // Mapping from names to records defining them.
-  NameToRecordMapping MacroSpecMap;
-  NameToRecordMapping TypeSpecMap;
-  NameToRecordMapping EnumerationSpecMap;
-  NameToRecordMapping FunctionSpecMap;
-  NameToRecordMapping MacroDefsMap;
-  NameToRecordMapping TypeDeclsMap;
-
-  NameSet Structs;
-  NameSet Enumerations;
-  NameSet Functions;
-
   bool isaNamedType(llvm::Record *Def) { return isa(Def, NamedTypeClass); }
 
   bool isaStructType(llvm::Record *Def) { return isa(Def, StructClass); }
 
   bool isaPtrType(llvm::Record *Def) { return isa(Def, PtrTypeClass); }
 
   bool isaConstType(llvm::Record *Def) { return isa(Def, ConstTypeClass); }
 
   bool isaRestrictedPtrType(llvm::Record *Def) {
     return isa(Def, RestrictedPtrTypeClass);
   }
 
   bool isaStandardSpec(llvm::Record *Def) {
     return isa(Def, StandardSpecClass);
   }
 
   bool isaPublicAPI(llvm::Record *Def) { return isa(Def, PublicAPIClass); }
 
-  std::string getTypeAsString(llvm::Record *TypeRecord) {
+  std::string getTypeAsString(llvm::Record *TypeRecord) override {
     if (isaNamedType(TypeRecord) || isaStructType(TypeRecord)) {
       return std::string(TypeRecord->getValueAsString("Name"));
     } else if (isaPtrType(TypeRecord)) {
       return getTypeAsString(TypeRecord->getValueAsDef("PointeeType")) + " *";
     } else if (isaConstType(TypeRecord)) {
       return std::string("const ") +
              getTypeAsString(TypeRecord->getValueAsDef("UnqualifiedType"));
     } else if (isaRestrictedPtrType(TypeRecord)) {
       return getTypeAsString(TypeRecord->getValueAsDef("PointeeType")) +
              " *__restrict";
     } else {
       llvm::PrintFatalError(TypeRecord->getLoc(), "Invalid type.\n");
     }
   }
 
   void indexStandardSpecDef(llvm::Record *StandardSpec) {
     auto HeaderSpecList = StandardSpec->getValueAsListOfDefs("Headers");
     for (llvm::Record *HeaderSpec : HeaderSpecList) {
-      if (HeaderSpec->getValueAsString("Name") == StdHeader) {
+      llvm::StringRef Header = HeaderSpec->getValueAsString("Name");
+      if (!StdHeader.hasValue() || Header == StdHeader) {
+        PublicHeaders.emplace(Header);
         auto MacroSpecList = HeaderSpec->getValueAsListOfDefs("Macros");
         // TODO: Trigger a fatal error on duplicate specs.
         for (llvm::Record *MacroSpec : MacroSpecList)
           MacroSpecMap[std::string(MacroSpec->getValueAsString("Name"))] =
               MacroSpec;
 
         auto TypeSpecList = HeaderSpec->getValueAsListOfDefs("Types");
         for (llvm::Record *TypeSpec : TypeSpecList)
void index(llvm::RecordKeeper &Records) {
     PublicAPIClass = Records.getClass(PublicAPIClassName);
 
     const auto &DefsMap = Records.getDefs();
     for (auto &Pair : DefsMap) {
       llvm::Record *Def = Pair.second.get();
       if (isaStandardSpec(Def))
         indexStandardSpecDef(Def);
       if (isaPublicAPI(Def)) {
-        if (Def->getValueAsString("HeaderName") == StdHeader)
+        if (!StdHeader.hasValue() ||
+            Def->getValueAsString("HeaderName") == StdHeader)
           indexPublicAPIDef(Def);
       }
     }
   }
 
 public:
+  explicit APIGenerator(llvm::RecordKeeper &Records) : StdHeader(llvm::None) {
+    index(Records);
+  }
   APIGenerator(llvm::StringRef Header, llvm::RecordKeeper &Records)
       : StdHeader(Header) {
     index(Records);
   }
 
   void write(llvm::raw_ostream &OS) {
     for (auto &Pair : MacroDefsMap) {
       const std::string &Name = Pair.first;
void PublicAPICommand::run(llvm::raw_ostream &OS, const ArgVector &Args,
   if (Args.size() != 0) {
     Reporter.printFatalError("public_api command does not take any arguments.");
   }
 
   APIGenerator G(StdHeader, Records);
   G.write(OS);
 }
 
+std::unique_ptr<APIReader> makeAPIReader(llvm::RecordKeeper &Records) {
+  return std::make_unique<APIGenerator>(Records);
+}
+
 } // namespace llvm_libc