[libc] Let header generator generate the type header inclusion boiler plate.

[michaelrj]

LGTM

libc/config/linux/api.td

 include "config/public_api.td"
 
 include "spec/gnu_ext.td"
 include "spec/linux.td"
 include "spec/llvm_libc_ext.td"
 include "spec/posix.td"
 include "spec/stdc.td"
 
-// TODO: Eliminate all TypeDecl specializations. Since we define all public
-// types in their own self contained header files, the header generator can
-// produce the boiler plate which pulls in the type definitions.
-
-def SizeT : TypeDecl<"size_t"> {
-  let Decl = [{
-    #include <llvm-libc-types/size_t.h>
-  }];
-}
-
-def SSizeT : TypeDecl<"ssize_t"> {
-  let Decl = [{
-    #include <llvm-libc-types/ssize_t.h>
-  }];
-}
-
-def StructTm: TypeDecl<"struct tm"> {
-  let Decl = [{
-    #include <llvm-libc-types/struct_tm.h>
-  }];
-}
-
-def TimeT: TypeDecl<"time_t"> {
-  let Decl = [{
-    #include <llvm-libc-types/time_t.h>
-  }];
-}
-
-def OffT : TypeDecl<"off_t"> {
-  let Decl = [{
-    #include <llvm-libc-types/off_t.h>
-  }];
-}
-
-def FILE : TypeDecl<"FILE"> {
-  let Decl = [{
-    #include <llvm-libc-types/FILE.h>
-  }];
-}
-
 def AssertMacro : MacroDef<"assert"> {
   let Defn = [{
     #undef assert
 
     #ifdef NDEBUG
     #define assert(e) (void)0
     #else
 
let Macros = [
     AssertMacro,
     StaticAssertMacro,
   ];
 }
 
 def CTypeAPI : PublicAPI<"ctype.h"> {
 }
 
-def IMaxDivT : TypeDecl<"imaxdiv_t"> {
-  let Decl = [{
-    #include <llvm-libc-types/imaxdiv_t.h>
-  }];
-}
-
 def IntTypesAPI : PublicAPI<"inttypes.h"> {
-  let TypeDeclarations = [
-    IMaxDivT,
-  ];
+  let Types = ["imaxdiv_t"];
 }
 
 def MathErrHandlingMacro : MacroDef<"math_errhandling"> {
   let Defn = [{
     #ifndef math_errhandling
     #ifdef __FAST_MATH__
     #define math_errhandling 0
     #elif defined __NO_MATH_ERRNO__

 }
 
 def IsNanMacro : MacroDef<"isnan"> {
   let Defn = [{
     #define isnan(x) __builtin_isnan(x)
   }];
 }
 
-def FloatT : TypeDecl<"float_t"> {
-  let Decl = [{
-    #include <llvm-libc-types/float_t.h>
-  }];
-}
-
-def DoubleT : TypeDecl<"double_t"> {
-  let Decl = [{
-    #include <llvm-libc-types/double_t.h>
-  }];
-}
-
 def MathAPI : PublicAPI<"math.h"> {
   let Macros = [
     SimpleMacroDef<"MATH_ERRNO", "1">,
     SimpleMacroDef<"MATH_ERREXCEPT", "2">,
     MathErrHandlingMacro,
 
     SimpleMacroDef<"INFINITY", "__builtin_inff()">,
     SimpleMacroDef<"NAN", "__builtin_nanf(\"\")">,
 
     SimpleMacroDef<"FP_ILOGB0", "(-__INT_MAX__ - 1)">, // INT_MIN
     SimpleMacroDef<"FP_ILOGBNAN", "__INT_MAX__">,
 
     IsFiniteMacro,
     IsInfMacro,
     IsNanMacro,
   ];
-  let TypeDeclarations = [
-    DoubleT,
-    FloatT,
-  ];
-}
-
-def FEnvT : TypeDecl<"fenv_t"> {
-  let Decl = [{
-    #include <llvm-libc-types/fenv_t.h>
-  }];
-}
-
-def FExceptT : TypeDecl<"fexcept_t"> {
-  let Decl = [{
-    #include <llvm-libc-types/fexcept_t.h>
-  }];
+  let Types = ["double_t", "float_t"];
 }
 
 def FenvAPI: PublicAPI<"fenv.h"> {
   let Macros = [
     SimpleMacroDef<"FE_DIVBYZERO", "1">,
     SimpleMacroDef<"FE_INEXACT", "2">,
     SimpleMacroDef<"FE_INVALID", "4">,
     SimpleMacroDef<"FE_OVERFLOW", "8">,
     SimpleMacroDef<"FE_UNDERFLOW", "16">,
     SimpleMacroDef<"FE_ALL_EXCEPT", "(FE_DIVBYZERO|FE_INEXACT|FE_INVALID|FE_OVERFLOW|FE_UNDERFLOW)">,
 
     SimpleMacroDef<"FE_DOWNWARD", "1">,
     SimpleMacroDef<"FE_TONEAREST", "2">,
     SimpleMacroDef<"FE_TOWARDZERO", "4">,
     SimpleMacroDef<"FE_UPWARD", "8">,
 
     SimpleMacroDef<"FE_DFL_ENV", "((fenv_t *)-1)">,
   ];
-  let TypeDeclarations = [
-    FEnvT,
-    FExceptT,
-  ];
+  let Types = ["fenv_t", "fexcept_t"];
 }
 
 def StringAPI : PublicAPI<"string.h"> {
-  let TypeDeclarations = [
-    SizeT,
-  ];
+  let Types = ["size_t"];
 
   let Macros = [
     NullMacro,
   ];
 }
 
 def StdIOAPI : PublicAPI<"stdio.h"> {
-  let TypeDeclarations = [
-    SizeT,
-    FILE,
-  ];
-}
-
-def DivT : TypeDecl<"div_t"> {
-  let Decl = [{
-    #include <llvm-libc-types/div_t.h>
-  }];
-}
-
-def LDivT : TypeDecl<"ldiv_t"> {
-  let Decl = [{
-    #include <llvm-libc-types/ldiv_t.h>
-  }];
-}
-
-def LLDivT : TypeDecl<"lldiv_t"> {
-  let Decl = [{
-    #include <llvm-libc-types/lldiv_t.h>
-  }];
-}
-
-def BSearchCompareTDefn : TypeDecl<"__bsearchcompare_t"> {
-  let Decl = [{
-    #include <llvm-libc-types/__bsearchcompare_t.h>
-  }];
-}
-
-def QSortCompareTDefn : TypeDecl<"__qsortcompare_t"> {
-  let Decl = [{
-    #include <llvm-libc-types/__qsortcompare_t.h>
-  }];
+  let Types = ["size_t", "FILE"];
 }
 
 def StdlibAPI : PublicAPI<"stdlib.h"> {
-  let TypeDeclarations = [
-    DivT,
-    LDivT,
-    LLDivT,
-    SizeT,
-    BSearchCompareTDefn,
-    QSortCompareTDefn,
+  let Types = [
+    "div_t",
+    "ldiv_t",
+    "lldiv_t",
+    "size_t",
+    "__bsearchcompare_t",
+    "__qsortcompare_t"
   ];
 }
 
 def TimeAPI : PublicAPI<"time.h"> {
-  let TypeDeclarations = [
-    StructTm,
-    TimeT,
-  ];
-
-  let Functions = [
-    "asctime",
-    "asctime_r",
-    "gmtime",
-    "gmtime_r",
-    "mktime",
-  ];
+  let Types = ["time_t", "struct tm"];
 }
 
 def ErrnoAPI : PublicAPI<"errno.h"> {
   let Macros = [
     ErrnoMacro,
     // We largely depend on linux/errno.h to give us the
     // various error macro definitions. However, some libc
     // implementations have chosen to provide definitions
     // for some of the error macros to account for the ones
     // missing in linux/errno.h. There is no harm in doing
     // the same here if we define the macros only when they
     // are not already defined.
     MacroDefineIfNot<"ENOTSUP", "EOPNOTSUPP">,
     MacroDefineIfNot<"ECANCELED", "125">,
     MacroDefineIfNot<"EOWNERDEAD", "130">,
     MacroDefineIfNot<"ENOTRECOVERABLE", "131">,
     MacroDefineIfNot<"ERFKILL", "132">,
     MacroDefineIfNot<"EHWPOISON", "133">,
   ];
 }
 
 def SysMManAPI : PublicAPI<"sys/mman.h"> {
+  let Types = ["off_t", "size_t"];
   let Macros = [
     SimpleMacroDef<"PROT_NONE", "0">,
     SimpleMacroDef<"PROT_READ", "1">,
     SimpleMacroDef<"PROT_WRITE", "2">,
     SimpleMacroDef<"PROT_EXEC", "4">,
 
     SimpleMacroDef<"MAP_FIXED", "1">,
     SimpleMacroDef<"MAP_PRIVATE", "2">,
     SimpleMacroDef<"MAP_SHARED", "4">,
 
     SimpleMacroDef<"MAP_FAILED", "((void*)-1)">,
 
     // TODO: The value of 0x20 is good for x86_64, but has to be extended
     // in some manner to accommodate other machine architectures.
     SimpleMacroDef<"MAP_ANONYMOUS", "0x20">
 
     // TODO: Add other MAP_* macros used by Linux.
   ];
 
-  let TypeDeclarations = [
-    SizeT,
-    OffT,
-  ];
-}
-
-def StructSigactionDefn : TypeDecl<"struct sigaction"> {
-  let Decl = [{
-    #include <llvm-libc-types/struct_sigaction.h>
-  }];
-}
-
-def SighandlerTDefn : TypeDecl<"__sighandler_t"> {
-  let Decl = [{
-    #include <llvm-libc-types/__sighandler_t.h>
-  }];
 }
 
 def SignalAPI : PublicAPI<"signal.h"> {
-  let TypeDeclarations = [
-    StructSigactionDefn,
-    SighandlerTDefn,
-  ];
-}
-
-def OnceFlag : TypeDecl<"once_flag"> {
-  let Decl = [{
-    #include <llvm-libc-types/once_flag.h>
-  }];
-}
-
-def MtxT : TypeDecl<"mtx_t"> {
-  let Decl = [{
-    #include <llvm-libc-types/mtx_t.h>
-  }];
-}
-
-def CndT : TypeDecl<"cnd_t"> {
-  let Decl = [{
-    #include <llvm-libc-types/cnd_t.h>
-  }];
-}
-
-def ThrdT : TypeDecl<"thrd_t"> {
-  let Decl = [{
-    #include <llvm-libc-types/thrd_t.h>
-  }];
-}
-
-def ThreadStartT : TypeDecl<"thrd_start_t"> {
-  let Decl = [{
-    #include <llvm-libc-types/thrd_start_t.h>
-  }];
-}
-
-def CallOnceFuncT : TypeDecl<"__call_once_func_t"> {
-  let Decl = [{
-    #include <llvm-libc-types/__call_once_func_t.h>
-  }];
+  let Types = ["struct sigaction", "__sighandler_t"];
 }
 
 def ThreadsAPI : PublicAPI<"threads.h"> {
   let Macros = [
     SimpleMacroDef<"ONCE_FLAG_INIT", "0">,
   ];
 
-  let TypeDeclarations = [
-    OnceFlag,
-    CallOnceFuncT,
-    MtxT,
-    CndT,
-    ThrdT,
-    ThreadStartT,
+  let Types = [
+    "__call_once_func_t",
+    "once_flag",
+    "cnd_t",
+    "mtx_t",
+    "thrd_t",
+    "thrd_start_t",
   ];
 
   let Enumerations = [
     "mtx_plain",
     "mtx_recursive",
     "mtx_timed",
     "thrd_timedout",
     "thrd_success",
     "thrd_busy",
     "thrd_error",
     "thrd_nomem",
   ];
 }
 
 def UniStdAPI : PublicAPI<"unistd.h"> {
-  let TypeDeclarations = [
-    SSizeT,
-    SizeT,
-  ];
+  let Types = ["size_t", "ssize_t"];
 }

libc/config/public_api.td

 include "spec/spec.td"
 
-class TypeDecl<string name> {
-  string Name = name;
-  string Decl = "";
-}
-
 class MacroDef<string name> {
   string Name = name;
   string Defn = "";
 }
 
 class SimpleMacroDef<string name, string value> : MacroDef<name> {
   let Defn = !strconcat("#define ", name, " ", value);
 }
 
 class MacroDefineIfNot<string name, string value> : MacroDef<name> {
   let Defn = !strconcat("#ifndef ", name, "\n",
                         "#define " , name, " ", value, "\n",
                         "#endif // ", name);
 }
 
 class PublicAPI<string name> {
   string HeaderName = name;
   list<MacroDef> Macros = [];
-  list<TypeDecl> TypeDeclarations = [];
+  list<string> Types = [];
   list<string> Enumerations = [];
   list<string> Structs = [];
   list<string> Functions = [];
 }

libc/utils/HdrGen/PublicAPICommand.cpp

 //===-- Implementation of PublicAPICommand --------------------------------===//
 //
 // 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 "utils/LibcTableGenUtil/APIIndexer.h"
 
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/TableGen/Record.h"
 
 // Text blocks for macro definitions and type decls can be indented to
 // suit the surrounding tablegen listing. We need to dedent such blocks
 // before writing them out.
if (IndentSize < shortest_indent)
       shortest_indent = IndentSize;
   }
   for (llvm::StringRef L : Lines) {
     if (L.size() >= shortest_indent)
       OS << L.drop_front(shortest_indent) << '\n';
   }
 }
 
+static std::string getTypeHdrName(const std::string &Name) {
+  llvm::SmallVector<llvm::StringRef> Parts;
+  llvm::SplitString(llvm::StringRef(Name), Parts);
+  return llvm::join(Parts.begin(), Parts.end(), "_");
+}
+
 namespace llvm_libc {
 
 void writeAPIFromIndex(APIIndexer &G,
                        std::vector<std::string> EntrypointNameList,
                        llvm::raw_ostream &OS) {
   for (auto &Pair : G.MacroDefsMap) {
     const std::string &Name = Pair.first;
     if (G.MacroSpecMap.find(Name) == G.MacroSpecMap.end())
       llvm::PrintFatalError(Name + " not found in any standard spec.\n");
 
     llvm::Record *MacroDef = Pair.second;
     dedentAndWrite(MacroDef->getValueAsString("Defn"), OS);
 
     OS << '\n';
   }
 
-  for (auto &Pair : G.TypeDeclsMap) {
-    const std::string &Name = Pair.first;
-    if (G.TypeSpecMap.find(Name) == G.TypeSpecMap.end())
-      llvm::PrintFatalError(Name + " not found in any standard spec.\n");
-
-    llvm::Record *TypeDecl = Pair.second;
-    dedentAndWrite(TypeDecl->getValueAsString("Decl"), OS);
-
-    OS << '\n';
+  for (auto &TypeName : G.RequiredTypes) {
+    if (G.TypeSpecMap.find(TypeName) == G.TypeSpecMap.end())
+      llvm::PrintFatalError(TypeName + " not found in any standard spec.\n");
+    OS << "#include <llvm-libc-types/" << getTypeHdrName(TypeName) << ".h>\n";
   }
+  OS << '\n';
 
   if (G.Enumerations.size() != 0)
     OS << "enum {" << '\n';
   for (const auto &Name : G.Enumerations) {
     if (G.EnumerationSpecMap.find(Name) == G.EnumerationSpecMap.end())
       llvm::PrintFatalError(
           Name + " is not listed as an enumeration in any standard spec.\n");
 

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 RequiredTypes;
   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

 void APIIndexer::indexPublicAPIDef(llvm::Record *PublicAPI) {
   // While indexing the public API, we do not check if any of the entities
   // requested is from an included standard. Such a check is done while
   // generating the API.
   auto MacroDefList = PublicAPI->getValueAsListOfDefs("Macros");
   for (llvm::Record *MacroDef : MacroDefList)
     MacroDefsMap[std::string(MacroDef->getValueAsString("Name"))] = MacroDef;
 
-  auto TypeDeclList = PublicAPI->getValueAsListOfDefs("TypeDeclarations");
-  for (llvm::Record *TypeDecl : TypeDeclList)
-    TypeDeclsMap[std::string(TypeDecl->getValueAsString("Name"))] = TypeDecl;
+  auto TypeList = PublicAPI->getValueAsListOfStrings("Types");
+  for (llvm::StringRef TypeName : TypeList)
+    RequiredTypes.insert(std::string(TypeName));
 
   auto StructList = PublicAPI->getValueAsListOfStrings("Structs");
   for (llvm::StringRef StructName : StructList)
     Structs.insert(std::string(StructName));
 
   auto FunctionList = PublicAPI->getValueAsListOfStrings("Functions");
   for (llvm::StringRef FunctionName : FunctionList)
     Functions.insert(std::string(FunctionName));