[libc] Extend WrapperGen to emit aliases.

[sivachandra]

Sorry, this is wrong diff.

libc/cmake/modules/LLVMLibCObjectRules.cmake

function(add_entrypoint_object target_name)
 
   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(wrapper_cpp "${CMAKE_CURRENT_BINARY_DIR}/${target_name}_wrapper.cpp")
+  set(wrappergen_target "${fq_target_name}__wrapper_gen")
+  add_custom_command(
+    OUTPUT ${wrapper_cpp}
+    COMMAND $<TARGET_FILE:libc-wrappergen> -I ${LIBC_SOURCE_DIR} -name ${entrypoint_name} ${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/api.td -o ${wrapper_cpp}
+    DEPENDS libc-wrappergen
+  )
+  add_custom_target(
+    "${wrappergen_target}"
+    DEPENDS ${wrapper_cpp}
+  )
+  set(wrapper_target "${fq_target_name}_wrapper_object")
+  add_library(
+    ${wrapper_target}
+    OBJECT
+    ${wrapper_cpp}
+  )
+  target_include_directories(
+    ${wrapper_target}
+    PRIVATE
+      ${LIBC_BUILD_DIR}/include
+      ${LIBC_SOURCE_DIR}
+      ${LIBC_BUILD_DIR}
+  )
+  set(mangled_name_file "${CMAKE_CURRENT_BINARY_DIR}/${target_name}_mangled_name.txt")
+  add_custom_command(
+    OUTPUT ${mangled_name_file}
+    COMMAND $<TARGET_FILE:llvm-nm> --undefined-only --just-symbol-name $<TARGET_OBJECTS:${wrapper_target}> > ${mangled_name_file}
+    VERBATIM
+    DEPENDS ${wrapper_target}
+  )
+  set(mangled_name_target "${fq_target_name}__mangled_name_gen")
+  add_custom_target(
+    ${mangled_name_target}
+    DEPENDS ${mangled_name_file}
+  )
+  set(source_with_alias "${CMAKE_CURRENT_BINARY_DIR}/__${target_name}_with_alias.cpp")
+  add_custom_command(
+    OUTPUT ${source_with_alias}
+    COMMAND $<TARGET_FILE:libc-wrappergen> -I ${LIBC_SOURCE_DIR} -name ${entrypoint_name} -alias-file ${mangled_name_file} ${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/api.td -add-alias-to ${CMAKE_CURRENT_SOURCE_DIR}/${ADD_ENTRYPOINT_OBJ_SRCS} -o ${source_with_alias}
+    DEPENDS libc-wrappergen
+  )
+
   set(objects_target_name "${fq_target_name}_objects")
 
   add_library(
-    ${objects_target_name}
+    ${fq_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}
+    ${source_with_alias}
     ${ADD_ENTRYPOINT_OBJ_HDRS}
   )
   target_compile_options(
-    ${objects_target_name}
+    ${fq_target_name}
     BEFORE
     PRIVATE
       -fpie ${LLVM_CXX_STD_default} -ffreestanding
   )
   target_include_directories(
-    ${objects_target_name}
+    ${fq_target_name}
     PRIVATE
       ${LIBC_BUILD_DIR}/include
       ${LIBC_SOURCE_DIR}
       ${LIBC_BUILD_DIR}
   )
   get_fq_deps_list(fq_deps_list ${ADD_ENTRYPOINT_OBJ_DEPENDS})
   add_dependencies(
-    ${objects_target_name}
+    ${fq_target_name}
     libc.src.__support.common
     ${fq_deps_list}
+    ${mangled_name_target}
   )
 
   if(ADD_ENTRYPOINT_OBJ_COMPILE_OPTIONS)
     target_compile_options(
-      ${objects_target_name}
+      ${fq_target_name}
       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:${objects_target_name}>)
-  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}
-  )
+  set(object_file_raw $<TARGET_OBJECTS:${fq_target_name}>)
+  set(object_file $<TARGET_OBJECTS:${fq_target_name}>)
 
-  add_custom_target(
-    ${fq_target_name}
-    ALL
-    DEPENDS ${object_file}
-  )
+#  set(input_objects $<TARGET_OBJECTS:${objects_target_name}>)
+#  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")
+#  else()
+#    set(alias_attributes "${alias_attributes},weak")
+#  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(
+#    ${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}"
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 ${fq_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__)
+    #add_dependencies(${fq_target_name} ${fq_target_name}.__lint__)
   endif()
 
 endfunction(add_entrypoint_object)
 
 # Rule build a redirector object file.
 function(add_redirector_object target_name)
   cmake_parse_arguments(
     "REDIRECTOR_OBJECT"

libc/config/linux/platform_defs.h.inc

 //===----- Definition of platform specific macros for ELF paltforms -------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 %%begin()
 
 #define ENTRYPOINT_SECTION_ATTRIBUTE(name) \
     __attribute__((section(".llvm.libc.entrypoint."#name)))
-#define LLVM_LIBC_ENTRYPOINT(name) ENTRYPOINT_SECTION_ATTRIBUTE(name) name
+#define LLVM_LIBC_ENTRYPOINT(name) name // ENTRYPOINT_SECTION_ATTRIBUTE(name) name

libc/src/math/CMakeLists.txt

add_entrypoint_object(
   round
   SRCS
     round.cpp
   HDRS
     round.h
   DEPENDS
     libc.utils.FPUtil.fputil
   COMPILE_OPTIONS
-    -O2
+    -O3
 )
 
 add_entrypoint_object(
   roundf
   SRCS
     roundf.cpp
   HDRS
     roundf.h

libc/utils/tools/WrapperGen/Main.cpp

 //===-- "main" function of libc-wrappergen --------------------------------===//
 //
 // 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 "utils/LibcTableGenUtil/APIIndexer.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/MemoryBuffer.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Main.h"
 
 #include <sstream>
 #include <string>
 
 llvm::cl::opt<std::string>
     FunctionName("name", llvm::cl::desc("Name of the function to be wrapped."),
                  llvm::cl::value_desc("<function name>"), llvm::cl::Required);
+llvm::cl::opt<std::string>
+    AliaseeString("aliasee",
+                  llvm::cl::desc("Declare as an alias to this C name."),
+                  llvm::cl::value_desc("<aliasee string>"));
+llvm::cl::opt<std::string>
+    AliaseeFile("aliasee-file",
+                llvm::cl::desc("Declare as an alias to the C name read from "
+                               "this file."),
+                llvm::cl::value_desc("<path to a file containing alias name>"));
+llvm::cl::opt<std::string>
+    AppendToFile("append-to-file",
+                 llvm::cl::desc("Append the generated content at the end of "
+                                "the contents of this file."),
+                 llvm::cl::value_desc("<path to a file>"));
+
+static std::string GetAliaseeName() {
+  if (AliaseeString.size() > 0)
+    return AliaseeString;
+
+  auto ErrorOrBuf = llvm::MemoryBuffer::getFile(AliaseeFile);
+  if (!ErrorOrBuf)
+    llvm::PrintFatalError("Unable to read the aliasee file " + AliaseeFile);
+  return std::string(ErrorOrBuf.get()->getBuffer().trim());
+}
 
 static bool WrapperGenMain(llvm::raw_ostream &OS, llvm::RecordKeeper &Records) {
+  if (!AliaseeString.empty() && !AliaseeFile.empty()) {
+    llvm::PrintFatalError("The options 'aliasee' and 'aliasee-file' cannot "
+                          "be specified simultaniously.");
+  }
+
   llvm_libc::APIIndexer Indexer(Records);
   auto Iter = Indexer.FunctionSpecMap.find(FunctionName);
   if (Iter == Indexer.FunctionSpecMap.end()) {
     llvm::PrintFatalError("Function '" + FunctionName +
                           "' not found in any standard spec.");
   }
 
+  bool EmitAlias = !(AliaseeString.empty() && AliaseeFile.empty());
+
+  if (!EmitAlias && AppendToFile.empty()) {
+    // If not emitting an alias, and not appending to another file,
+    // we should include the implementtion header to ensure the wrapper
+    // compiles.
     // To avoid all confusion, we include the implementation header using the
-  // full path (relative the libc directory.)
+    // full path (relative to the libc directory.)
     std::string Header = Indexer.FunctionToHeaderMap[FunctionName];
-  auto RelPath = llvm::StringRef(Header).drop_back(2); // Drop the ".h" suffix.
+    auto RelPath =
+        llvm::StringRef(Header).drop_back(2); // Drop the ".h" suffix.
     OS << "#include \"src/" << RelPath << "/" << FunctionName << ".h\"\n";
+  }
+  if (!AppendToFile.empty()) {
+    auto ErrorOrBuf = llvm::MemoryBuffer::getFile(AppendToFile);
+    if (!ErrorOrBuf) {
+      llvm::PrintFatalError("Unable to read the file " + AppendToFile +
+                            " to append to.");
+    }
+    OS << ErrorOrBuf.get()->getBuffer().trim() << '\n';
+  }
 
   auto &NameSpecPair = *Iter;
   llvm::Record *FunctionSpec = NameSpecPair.second;
   llvm::Record *RetValSpec = FunctionSpec->getValueAsDef("Return");
   llvm::Record *ReturnType = RetValSpec->getValueAsDef("ReturnType");
   std::string ReturnTypeString = Indexer.getTypeAsString(ReturnType);
   bool ShouldReturn = true;
   // We are generating C wrappers in C++ code. So, we should convert the C
for (size_t i = 0; i < ArgsList.size(); ++i) {
     OS << TypeName << " " << ArgPrefix << i;
     CallArgs << ArgPrefix << i;
     if (i < ArgsList.size() - 1) {
       OS << ", ";
       CallArgs << ", ";
     }
   }
 
+  if (EmitAlias) {
+    OS << ") [[gnu::alias(\"" << GetAliaseeName() << "\")]];\n";
+  } else {
     // TODO: Arg types of the C++ implementation functions need not
     // match the standard types. Either handle such differences here, or
     // avoid such a thing in the implementations.
     OS << ") {\n"
        << "  " << (ShouldReturn ? "return " : "")
        << "__llvm_libc::" << FunctionName << "(" << CallArgs.str() << ");\n"
        << "}\n";
-
+  }
   return false;
 }
 
 int main(int argc, char *argv[]) {
   llvm::cl::ParseCommandLineOptions(argc, argv);
   return TableGenMain(argv[0], WrapperGenMain);
 }