[libc] Refactor WrapperGen to make the flow cleaner.

[michaelrj]

accepted with nits

libc/utils/tools/WrapperGen/Main.cpp

54

Nit: Exactly

59

Nit: simultaneously

68

Nit: At least

[sivachandra]

Fix nits.

[sivachandra]

Addressed comments.

libc/test/utils/tools/WrapperGen/wrappergen_test.cpp

protected:
   }
 };
 
 TEST_F(WrapperGenTest, RunWrapperGenAndGetNoErrors) {
   llvm::Optional<llvm::StringRef> Redirects[] = {
       llvm::None, llvm::StringRef(STDOutFile.get().TmpName),
       llvm::StringRef(STDErrFile.get().TmpName)};
 
-  llvm::StringRef ArgV[] = {ProgPath, llvm::StringRef(IncludeArg),
-                            llvm::StringRef(APIArg), "--name", "strlen"};
+  llvm::StringRef ArgV[] = {ProgPath,
+                            llvm::StringRef(IncludeArg),
+                            llvm::StringRef(APIArg),
+                            "--gen-wrapper",
+                            "--name",
+                            "strlen"};
 
   int ExitCode =
       llvm::sys::ExecuteAndWait(ProgPath, ArgV, llvm::None, Redirects);
 
   EXPECT_EQ(ExitCode, 0);
 
   auto STDErrOrError = llvm::MemoryBuffer::getFile(STDErrFile.get().TmpName);
   std::string STDErrOutput = STDErrOrError.get()->getBuffer().str();
   ASSERT_EQ(STDErrOutput, "");
 }
 
 TEST_F(WrapperGenTest, RunWrapperGenOnStrlen) {
   llvm::Optional<llvm::StringRef> Redirects[] = {
       llvm::None, llvm::StringRef(STDOutFile.get().TmpName),
       llvm::StringRef(STDErrFile.get().TmpName)};
 
-  llvm::StringRef ArgV[] = {ProgPath, llvm::StringRef(IncludeArg),
-                            llvm::StringRef(APIArg), "--name", "strlen"};
+  llvm::StringRef ArgV[] = {ProgPath,
+                            llvm::StringRef(IncludeArg),
+                            llvm::StringRef(APIArg),
+                            "--gen-wrapper",
+                            "--name",
+                            "strlen"};
 
   int ExitCode =
       llvm::sys::ExecuteAndWait(ProgPath, ArgV, llvm::None, Redirects);
 
   EXPECT_EQ(ExitCode, 0);
 
   auto STDErrOrError = llvm::MemoryBuffer::getFile(STDErrFile.get().TmpName);
   std::string STDErrOutput = STDErrOrError.get()->getBuffer().str();
 
   ASSERT_EQ(STDErrOutput, "");
 
   auto STDOutOrError = llvm::MemoryBuffer::getFile(STDOutFile.get().TmpName);
   std::string STDOutOutput = STDOutOrError.get()->getBuffer().str();
 
   ASSERT_EQ(STDOutOutput, "#include \"src/string/strlen.h\"\n"
                           "extern \"C\" size_t strlen(const char * __arg0) {\n"
                           "  return __llvm_libc::strlen(__arg0);\n"
                           "}\n");
   // TODO:(michaelrj) Figure out how to make this output comparison
   // less brittle. Currently it's just comparing the output of the program
   // to an exact string, this means that even a small formatting change
   // would break this test.
 }
 
-TEST_F(WrapperGenTest, RunWrapperGenOnStrlenWithAliasee) {
+TEST_F(WrapperGenTest, GenAliasForStrlen) {
   llvm::Optional<llvm::StringRef> Redirects[] = {
       llvm::None, llvm::StringRef(STDOutFile.get().TmpName),
       llvm::StringRef(STDErrFile.get().TmpName)};
 
   llvm::StringRef ArgV[] = {ProgPath,
                             llvm::StringRef(IncludeArg),
                             llvm::StringRef(APIArg),
-                            "--aliasee",
-                            "STRLEN_ALIAS",
+                            "--gen-alias",
+                            "--mangled-name",
+                            "__llvm_libc_strlen_mangled_name",
                             "--name",
                             "strlen"};
 
   int ExitCode =
       llvm::sys::ExecuteAndWait(ProgPath, ArgV, llvm::None, Redirects);
 
   EXPECT_EQ(ExitCode, 0);
 
   auto STDErrOrError = llvm::MemoryBuffer::getFile(STDErrFile.get().TmpName);
   std::string STDErrOutput = STDErrOrError.get()->getBuffer().str();
 
   ASSERT_EQ(STDErrOutput, "");
 
   auto STDOutOrError = llvm::MemoryBuffer::getFile(STDOutFile.get().TmpName);
   std::string STDOutOutput = STDOutOrError.get()->getBuffer().str();
 
-  ASSERT_EQ(STDOutOutput, "extern \"C\" size_t strlen(const char * __arg0) "
-                          "__attribute__((alias(\"STRLEN_ALIAS\")));\n");
+  ASSERT_EQ(STDOutOutput,
+            "extern \"C\" size_t strlen(const char * __arg0) "
+            "__attribute__((alias(\"__llvm_libc_strlen_mangled_name\")));\n");
   // TODO:(michaelrj) Figure out how to make this output comparison
   // less brittle. Currently it's just comparing the output of the program
   // to an exact string, this means that even a small formatting change
   // would break this test.
 }
 
-TEST_F(WrapperGenTest, DeclStrlenAliasUsingAliaseeFile) {
+TEST_F(WrapperGenTest, DeclStrlenAliasUsingMangledNameFile) {
   llvm::Optional<llvm::StringRef> Redirects[] = {
       llvm::None, llvm::StringRef(STDOutFile.get().TmpName),
       llvm::StringRef(STDErrFile.get().TmpName)};
 
-  const char *AliaseeFileContent = "abc\nxyz__llvm_libcSTRLEN_ALIAS\nijk\n";
-  llvm::SmallVector<char> AliaseeFilePath;
-  auto AliaseeFileCreateError = llvm::sys::fs::createUniqueFile(
-      "libc-wrappergen-test-aliasee-file-%%-%%-%%-%%.txt", AliaseeFilePath);
-  ASSERT_FALSE(AliaseeFileCreateError);
-  auto AliaseeFileWriteError = llvm::writeFileAtomically(
+  const char *MangledNameFileContent =
+      "abc\nxyz__llvm_libc_strlen_mangled_name\nijk\n";
+  llvm::SmallVector<char> MangledNameFilePath;
+  auto MangledNameFileCreateError = llvm::sys::fs::createUniqueFile(
+      "libc-wrappergen-test-aliasee-file-%%-%%-%%-%%.txt", MangledNameFilePath);
+  ASSERT_FALSE(MangledNameFileCreateError);
+  auto MangledNameFileWriteError = llvm::writeFileAtomically(
       "libc-wrappergen-temp-test-aliasee-file-%%-%%-%%-%%.txt",
-      llvm::StringRef(AliaseeFilePath.data()),
-      llvm::StringRef(AliaseeFileContent));
-  ASSERT_FALSE(AliaseeFileWriteError);
+      llvm::StringRef(MangledNameFilePath.data()),
+      llvm::StringRef(MangledNameFileContent));
+  ASSERT_FALSE(MangledNameFileWriteError);
 
   llvm::StringRef ArgV[] = {ProgPath,
                             llvm::StringRef(IncludeArg),
                             llvm::StringRef(APIArg),
-                            "--aliasee-file",
-                            llvm::StringRef(AliaseeFilePath.data()),
+                            "--gen-alias",
+                            "--mangled-name-file",
+                            llvm::StringRef(MangledNameFilePath.data()),
                             "--name",
                             "strlen"};
 
   int ExitCode =
       llvm::sys::ExecuteAndWait(ProgPath, ArgV, llvm::None, Redirects);
 
   EXPECT_EQ(ExitCode, 0);
 
   auto STDErrOrError = llvm::MemoryBuffer::getFile(STDErrFile.get().TmpName);
   std::string STDErrOutput = STDErrOrError.get()->getBuffer().str();
 
   ASSERT_EQ(STDErrOutput, "");
 
   auto STDOutOrError = llvm::MemoryBuffer::getFile(STDOutFile.get().TmpName);
   std::string STDOutOutput = STDOutOrError.get()->getBuffer().str();
 
-  ASSERT_EQ(STDOutOutput,
-            "extern \"C\" size_t strlen(const char * __arg0) "
-            "__attribute__((alias(\"xyz__llvm_libcSTRLEN_ALIAS\")));\n");
+  ASSERT_EQ(
+      STDOutOutput,
+      "__attribute__((alias(\"xyz__llvm_libc_strlen_mangled_name\")));\n");
 }
 
 /////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////
 // BAD INPUT TESTS
 // all of the tests after this point are testing inputs that should
 // return errors
 /////////////////////////////////////////////////////////////////////
 
-TEST_F(WrapperGenTest,
-       RunWrapperGenOnStrlenWithAliaseeAndAliaseeFileWhichIsError) {
+TEST_F(WrapperGenTest, RunWrapperGenOnStrlenWithMangledNameAndMangledNameFile) {
   llvm::Optional<llvm::StringRef> Redirects[] = {
       llvm::None, llvm::StringRef(STDOutFile.get().TmpName),
       llvm::StringRef(STDErrFile.get().TmpName)};
 
   llvm::StringRef ArgV[] = {ProgPath,
                             llvm::StringRef(IncludeArg),
                             llvm::StringRef(APIArg),
-                            "--aliasee",
-                            "STRLEN_ALIAS",
-                            "--aliasee-file",
-                            "STRLEN_ALIAS_FILE",
+                            "--gen-alias",
+                            "--mangled-name",
+                            "__llvm_libc_strlen_mangled_name",
+                            "--mangled-name-file",
+                            "non-existant-mangled-name-file.txt",
                             "--name",
                             "strlen"};
 
   int ExitCode =
       llvm::sys::ExecuteAndWait(ProgPath, ArgV, llvm::None, Redirects);
 
   EXPECT_EQ(ExitCode, 1);
 
   auto STDErrOrError = llvm::MemoryBuffer::getFile(STDErrFile.get().TmpName);
   std::string STDErrOutput = STDErrOrError.get()->getBuffer().str();
 
-  ASSERT_EQ(STDErrOutput, "error: The options 'aliasee' and 'aliasee-file' "
-                          "cannot be specified simultaniously.\n");
+  ASSERT_EQ(STDErrOutput,
+            "error: The options 'mangled-name' and 'mangled-name-file' "
 
   auto STDOutOrError = llvm::MemoryBuffer::getFile(STDOutFile.get().TmpName);
   std::string STDOutOutput = STDOutOrError.get()->getBuffer().str();
 
   ASSERT_EQ(STDOutOutput, "");
 }
 
 TEST_F(WrapperGenTest, RunWrapperGenOnBadFuncName) {
   llvm::Optional<llvm::StringRef> Redirects[] = {
       llvm::None, llvm::StringRef(STDOutFile.get().TmpName),
       llvm::StringRef(STDErrFile.get().TmpName)};
 
   llvm::StringRef BadFuncName = "FAKE_TEST_FUNC";
 
-  llvm::StringRef ArgV[] = {ProgPath, llvm::StringRef(IncludeArg),
-                            llvm::StringRef(APIArg), "--name", BadFuncName};
+  llvm::StringRef ArgV[] = {ProgPath,
+                            llvm::StringRef(IncludeArg),
+                            llvm::StringRef(APIArg),
+                            "--gen-wrapper",
+                            "--name",
+                            BadFuncName};
 
   int ExitCode =
       llvm::sys::ExecuteAndWait(ProgPath, ArgV, llvm::None, Redirects);
 
   EXPECT_EQ(ExitCode, 1);
 
   auto STDErrOrError = llvm::MemoryBuffer::getFile(STDErrFile.get().TmpName);
   std::string STDErrOutput = STDErrOrError.get()->getBuffer().str();
 
   ASSERT_EQ(STDErrOutput, ("error: Function '" + BadFuncName +
                            "' not found in any standard spec.\n")
                               .str());
 
   auto STDOutOrError = llvm::MemoryBuffer::getFile(STDOutFile.get().TmpName);
   std::string STDOutOutput = STDOutOrError.get()->getBuffer().str();
 
   ASSERT_EQ(STDOutOutput, "");
 }
 
-TEST_F(WrapperGenTest, RunWrapperGenOnStrlenWithBadAliaseeFile) {
+TEST_F(WrapperGenTest, RunWrapperGenOnStrlenWithBadMangledNameFile) {
   llvm::Optional<llvm::StringRef> Redirects[] = {
       llvm::None, llvm::StringRef(STDOutFile.get().TmpName),
       llvm::StringRef(STDErrFile.get().TmpName)};
 
-  llvm::StringRef BadAliaseeFileName = "FILE_THAT_DOESNT_EXIST.txt";
+  llvm::StringRef BadMangledNameFileName = "FILE_THAT_DOESNT_EXIST.txt";
 
-  llvm::StringRef ArgV[] = {
-      ProgPath,         llvm::StringRef(IncludeArg), llvm::StringRef(APIArg),
-      "--aliasee-file", BadAliaseeFileName,          "--name",
+  llvm::StringRef ArgV[] = {ProgPath,
+                            llvm::StringRef(IncludeArg),
+                            llvm::StringRef(APIArg),
+                            "--gen-alias",
+                            "--mangled-name-file",
+                            BadMangledNameFileName,
+                            "--name",
                             "strlen"};
 
   int ExitCode =
       llvm::sys::ExecuteAndWait(ProgPath, ArgV, llvm::None, Redirects);
 
   EXPECT_EQ(ExitCode, 1);
 
   auto STDErrOrError = llvm::MemoryBuffer::getFile(STDErrFile.get().TmpName);
   std::string STDErrOutput = STDErrOrError.get()->getBuffer().str();
 
-  ASSERT_EQ(STDErrOutput, ("error: Unable to read the aliasee file " +
-                           BadAliaseeFileName + "\n")
+  ASSERT_EQ(STDErrOutput, ("error: Unable to read the mangled name file " +
+                           BadMangledNameFileName + "\n")
                               .str());
 
   auto STDOutOrError = llvm::MemoryBuffer::getFile(STDOutFile.get().TmpName);
   std::string STDOutOutput = STDOutOrError.get()->getBuffer().str();
 
   ASSERT_EQ(STDOutOutput, "");
 }
 
-TEST_F(WrapperGenTest, RunWithAliaseeFileMissingLLVMLibcName) {
+TEST_F(WrapperGenTest, RunWithMangledNameFileMissingLLVMLibcName) {
   llvm::Optional<llvm::StringRef> Redirects[] = {
       llvm::None, llvm::StringRef(STDOutFile.get().TmpName),
       llvm::StringRef(STDErrFile.get().TmpName)};
 
-  llvm::SmallVector<char> AliaseeFilePath;
-  auto AliaseeFileCreateError = llvm::sys::fs::createUniqueFile(
-      "libc-wrappergen-test-aliasee-file-%%-%%-%%-%%.txt", AliaseeFilePath);
-  ASSERT_FALSE(AliaseeFileCreateError);
+  llvm::SmallVector<char> MangledNameFilePath;
+  auto MangledNameFileCreateError = llvm::sys::fs::createUniqueFile(
+      "libc-wrappergen-test-mangled-name-file-%%-%%-%%-%%.txt",
+      MangledNameFilePath);
+  ASSERT_FALSE(MangledNameFileCreateError);
 
   llvm::StringRef ArgV[] = {ProgPath,
                             llvm::StringRef(IncludeArg),
                             llvm::StringRef(APIArg),
-                            "--aliasee-file",
-                            llvm::StringRef(AliaseeFilePath.data()),
+                            "--gen-alias",
+                            "--mangled-name-file",
+                            llvm::StringRef(MangledNameFilePath.data()),
                             "--name",
                             "strlen"};
 
   int ExitCode =
       llvm::sys::ExecuteAndWait(ProgPath, ArgV, llvm::None, Redirects);
 
   EXPECT_NE(ExitCode, 0);
 
   auto STDErrOrError = llvm::MemoryBuffer::getFile(STDErrFile.get().TmpName);
   std::string STDErrOutput = STDErrOrError.get()->getBuffer().str();
 
   ASSERT_EQ(STDErrOutput, ("error: Did not find an LLVM libc mangled name in " +
-                           AliaseeFilePath + "\n")
+                           MangledNameFilePath + "\n")
                               .str());
 }

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/Error.h"
+#include "llvm/Support/JSON.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Main.h"
 
+#include <fstream>
+#include <map>
 #include <sstream>
 #include <string>
 
+llvm::cl::opt<bool>
+    GenWrapper("gen-wrapper",
+               llvm::cl::desc("Generate a C wrapper for <name>."));
+llvm::cl::opt<bool> GenAlias("gen-alias",
+                             llvm::cl::desc("Generate a C alias for <name>."));
+
 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> MangledNameString(
+    "mangled-name", llvm::cl::desc("Declare as an alias to this mangled name."),
+llvm::cl::opt<std::string> MangledNameFile(
+    "mangled-name-file",
 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;
+void validateOpts() {
+  int ActionCount = 0;
+  if (GenWrapper)
+    ++ActionCount;
+  if (GenAlias)
+    ++ActionCount;
+  if (ActionCount != 1) {
+    llvm::PrintFatalError("Exactly one of {--gen-wrapper, --gen-alias} "
+                          "should be specified");
+  }
+  if (!MangledNameString.empty() && !MangledNameFile.empty()) {
+    llvm::PrintFatalError("The options 'mangled-name' and 'mangled-name-file' "
+                          "cannot be specified simultaneously.");
+  }
+}
+
+static std::string getMangledName() {
+  if (!MangledNameString.empty())
+    return MangledNameString;
+
+  if (MangledNameFile.empty())
+    llvm::PrintFatalError("At least one of --mangled-name or "
+                          "--mangled-name-file should be specified.");
 
-  auto ErrorOrBuf = llvm::MemoryBuffer::getFile(AliaseeFile);
+  auto ErrorOrBuf = llvm::MemoryBuffer::getFile(MangledNameFile);
   if (!ErrorOrBuf)
-    llvm::PrintFatalError("Unable to read the aliasee file " + AliaseeFile);
+    llvm::PrintFatalError("Unable to read the mangled name file " +
+                          MangledNameFile);
   llvm::StringRef FileContent = ErrorOrBuf.get()->getBuffer().trim();
   llvm::SmallVector<llvm::StringRef> Lines;
   FileContent.split(Lines, '\n');
   for (llvm::StringRef L : Lines) {
     if (L.contains("__llvm_libc"))
       return std::string(L);
   }
   llvm::PrintFatalError("Did not find an LLVM libc mangled name in " +
-                        AliaseeFile);
+                        MangledNameFile);
   return std::string();
 }
 
-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 implementation header to ensure the wrapper
-    // compiles.
-    // To avoid all confusion, we include the implementation header using the
-    // 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.
-    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';
-  }
+void writeAppendToFile(llvm::raw_ostream &OS) {
 
+llvm::Record *getFunctionSpec(const llvm_libc::APIIndexer &Indexer) {
+  auto Iter = Indexer.FunctionSpecMap.find(FunctionName);
+  if (Iter == Indexer.FunctionSpecMap.end()) {
+    llvm::PrintFatalError("Function '" + FunctionName +
+                          "' not found in any standard spec.");
+  }
   auto &NameSpecPair = *Iter;
-  llvm::Record *FunctionSpec = NameSpecPair.second;
+  return NameSpecPair.second;
+}
+
+std::pair<std::string, bool> writeFunctionHeader(llvm_libc::APIIndexer &Indexer,
+                                                 llvm::Record *FunctionSpec,
+                                                 llvm::raw_ostream &OS) {
   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
   // _Noreturn to the C++ [[noreturn]].
   llvm::StringRef NR("_Noreturn "); // Note the space after _Noreturn
   llvm::StringRef RT(ReturnTypeString);
for (size_t i = 0; i < ArgsList.size(); ++i) {
 
     OS << TypeName << " " << ArgPrefix << i;
     CallArgs << ArgPrefix << i;
     if (i < ArgsList.size() - 1) {
       OS << ", ";
       CallArgs << ", ";
     }
   }
+  return make_pair(CallArgs.str(), ShouldReturn);
+}
 
-  if (EmitAlias) {
-    OS << ") __attribute__((alias(\"" << GetAliaseeName() << "\")));\n";
+static bool generateWrapper(llvm::raw_ostream &OS,
+                            llvm::RecordKeeper &Records) {
+  llvm_libc::APIIndexer Indexer(Records);
+  llvm::Record *FunctionSpec = getFunctionSpec(Indexer);
+  if (AppendToFile.empty()) {
+    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";
   } 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";
-  }
+    writeAppendToFile(OS);
+  }
+  auto Pair = writeFunctionHeader(Indexer, FunctionSpec, OS);
+     << "  " << (Pair.second ? "return " : "")
+     << "__llvm_libc::" << FunctionName << "(" << Pair.first << ");\n"
+  return false;
+
+static bool generateAlias(llvm::raw_ostream &OS, llvm::RecordKeeper &Records) {
+  if (!AppendToFile.empty())
+    writeAppendToFile(OS);
+  llvm_libc::APIIndexer Indexer(Records);
+  llvm::Record *FunctionSpec = getFunctionSpec(Indexer);
+  auto Pair = writeFunctionHeader(Indexer, FunctionSpec, OS);
+  OS << ") __attribute__((alias(\"" << getMangledName() << "\")));\n";
   return false;
 }
 
+static bool wrapperGenMain(llvm::raw_ostream &OS, llvm::RecordKeeper &Records) {
+  validateOpts();
+
+  if (GenWrapper)
+    return generateWrapper(OS, Records);
+  if (GenAlias)
+    return generateAlias(OS, Records);
+
+  __builtin_unreachable();
+}
+
 int main(int argc, char *argv[]) {
   llvm::cl::ParseCommandLineOptions(argc, argv);
-  return TableGenMain(argv[0], WrapperGenMain);
+  return TableGenMain(argv[0], wrapperGenMain);
 }