[libc] Add a tool called WrapperGen.

[sivachandra]

Summary

This tool will be used to generate C wrappers for the C++ LLVM libc
implementations. This change does not hook this tool up to anything yet.
However, it can be useful for cases where one does not want to run the
objcopy step (to insert the C symbol in the object file) but can make use
of LTO to eliminate the cost of the additional wrapper call. This can be
relevant for certain downstream platforms. If this tool can benefit other
libc platforms in general, then it can be integrated into the build system
with options to use or not use the wrappers. An example of such a
platform is CUDA.

[abrachet]

This looks good. I wonder though how we will deal with global variables. Those can't be easily wrapped like functions can.

libc/utils/tools/WrapperGen/Main.cpp

20–22

How do you imagine we will invoke this tool? Our list of function names is in TableGen so it wouldn't be easy to run this over every function name. Will this be called from add_entrypoint_object then?

59

I think this should be fine because all we care about it ABI compatibility, and we're only including the src/ headers not the include/ ones so the compiler wont complain there.

[sivachandra]

In D84848#2182387, @abrachet wrote:

This looks good. I wonder though how we will deal with global variables. Those can't be easily wrapped like functions can.

Yes, global variables question is open if we have to support them in some manner. The one we have currently, errno which not really global but like one, is accessed by the extension function __errno_location. So, we are good in this case. If there are other global variables we need to support (nothing comes to my mind), we can take that up at that time.

libc/utils/tools/WrapperGen/Main.cpp

20–22

Yes, the build rules will be the right place to hook this up. The downstream use case I am working with does exactly that.

59

Right. In the existing code, there are no examples which break. But, added this TODO just in case. Does not add value you think?

[abrachet]

In D84848#2182500, @sivachandra wrote:

In D84848#2182387, @abrachet wrote:

This looks good. I wonder though how we will deal with global variables. Those can't be easily wrapped like functions can.

Yes, global variables question is open if we have to support them in some manner. The one we have currently, errno which not really global but like one, is accessed by the extension function __errno_location. So, we are good in this case. If there are other global variables we need to support (nothing comes to my mind), we can take that up at that time.

There are the stupid globals related to getopt :). Indeed solvable later.

libc/utils/tools/WrapperGen/Main.cpp

59

No preference either way.

libc/utils/CMakeLists.txt

 add_subdirectory(CPP)
 add_subdirectory(FPUtil)
 add_subdirectory(LibcTableGenUtil)
 add_subdirectory(HdrGen)
 add_subdirectory(MPFRWrapper)
 add_subdirectory(testutils)
+add_subdirectory(tools)
 add_subdirectory(UnitTest)

libc/utils/LibcTableGenUtil/APIIndexer.h

public:
   // Mapping from names to records defining them.
   NameToRecordMapping MacroSpecMap;
   NameToRecordMapping TypeSpecMap;
   NameToRecordMapping EnumerationSpecMap;
   NameToRecordMapping FunctionSpecMap;
   NameToRecordMapping MacroDefsMap;
   NameToRecordMapping TypeDeclsMap;
 
+  std::unordered_map<std::string, std::string> FunctionToHeaderMap;
+
   NameSet Structs;
   NameSet Enumerations;
   NameSet Functions;
   NameSet PublicHeaders;
 
   std::string getTypeAsString(llvm::Record *TypeRecord);
 };
 
 } // namespace llvm_libc
 
 #endif // LLVM_LIBC_UTILS_LIBC_TABLE_GEN_UTILS_API_INDEXER_H

libc/utils/LibcTableGenUtil/APIIndexer.cpp

if (!StdHeader.hasValue() || Header == StdHeader) {
             MacroSpec;
 
       auto TypeSpecList = HeaderSpec->getValueAsListOfDefs("Types");
       for (llvm::Record *TypeSpec : TypeSpecList)
         TypeSpecMap[std::string(TypeSpec->getValueAsString("Name"))] = TypeSpec;
 
       auto FunctionSpecList = HeaderSpec->getValueAsListOfDefs("Functions");
       for (llvm::Record *FunctionSpec : FunctionSpecList) {
-        FunctionSpecMap[std::string(FunctionSpec->getValueAsString("Name"))] =
-            FunctionSpec;
+        auto FunctionName = std::string(FunctionSpec->getValueAsString("Name"));
+        FunctionSpecMap[FunctionName] = FunctionSpec;
+        FunctionToHeaderMap[FunctionName] = std::string(Header);
       }
 
       auto EnumerationSpecList =
           HeaderSpec->getValueAsListOfDefs("Enumerations");
       for (llvm::Record *EnumerationSpec : EnumerationSpecList) {
         EnumerationSpecMap[std::string(
             EnumerationSpec->getValueAsString("Name"))] = EnumerationSpec;
       }

libc/utils/tools/CMakeLists.txt

+add_subdirectory(WrapperGen)

libc/utils/tools/WrapperGen/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS Support)
+
+add_tablegen(libc-wrappergen llvm-libc
+  Main.cpp
+)
+
+target_include_directories(libc-wrappergen PRIVATE ${LIBC_SOURCE_DIR})
+target_link_libraries(libc-wrappergen PRIVATE LibcTableGenUtil)

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/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);
+
+static bool WrapperGenMain(llvm::raw_ostream &OS, llvm::RecordKeeper &Records) {
+  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.");
+  }
+
+  // To avoid all confusion, we include the implementation header using the
+  // full path (relative the libc directory.)
+  std::string Header = Indexer.FunctionToHeaderMap[FunctionName];
+  auto RelPath = llvm::StringRef(Header).drop_back(2); // Drop the ".h" suffix.
+  OS << "#include \"src/" << RelPath << "/" << FunctionName << ".h\"\n";
+
+  auto &NameSpecPair = *Iter;
+  llvm::Record *FunctionSpec = NameSpecPair.second;
+  llvm::Record *RetValSpec = FunctionSpec->getValueAsDef("Return");
+  llvm::Record *ReturnType = RetValSpec->getValueAsDef("ReturnType");
+  OS << "extern \"C\" " << Indexer.getTypeAsString(ReturnType) << " "
+     << FunctionName << "(";
+
+  auto ArgsList = FunctionSpec->getValueAsListOfDefs("Args");
+  std::stringstream CallArgs;
+  std::string ArgPrefix("__arg");
+  for (size_t i = 0; i < ArgsList.size(); ++i) {
+    llvm::Record *ArgType = ArgsList[i]->getValueAsDef("ArgType");
+    auto TypeName = Indexer.getTypeAsString(ArgType);
+    OS << TypeName << " " << ArgPrefix << i;
+    CallArgs << ArgPrefix << i;
+    if (i < ArgsList.size() - 1) {
+      OS << ", ";
+      CallArgs << ", ";
+    }
+  }
+
+  // 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"
+     << "  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);
+}