[libc] Add ability to generate enum types/values to HdrGen.

[sivachandra]

Summary

A target to generate the std C threads.h file has been added. This
utilizes the new feature added in this change.

[sivachandra]

Fix a clang-tidy warning pointed out by the presubmit bot.

[phosek]

LGTM

libc/include/threads.h.def

17

Super minor nit: only a single empty line for consistency with other .def files.

libc/config/linux/api.td

def SignalAPI : PublicAPI<"signal.h"> {
   let TypeDeclarations = [
     SizeT, // This is needed by <linux/signal.h>.
   ];
 
   let Functions = [
     "raise",
   ];
 }
+
+def ThreadsAPI : PublicAPI<"threads.h"> {
+  let Enumerations = [
+    "mtx_plain",
+    "mtx_recursive",
+    "mtx_timed",
+    "thrd_timedout",
+    "thrd_success",
+    "thrd_busy",
+    "thrd_error",
+    "thrd_nomem",
+  ];
+}

libc/config/public_api.td

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> Enumerations = [];
   list<string> Structs = [];
   list<string> Functions = [];
 }

libc/include/CMakeLists.txt

add_gen_header(
   string_h
   DEF_FILE string.h.def
   GEN_HDR string.h
   DEPENDS
     llvm_libc_common_h
 )
 
 add_gen_header(
+  threads_h
+  DEF_FILE threads.h.def
+  GEN_HDR threads.h
+  DEPENDS
+    llvm_libc_common_h
+)
+
+add_gen_header(
   errno_h
   DEF_FILE errno.h.def
   PARAMS
     platform_errno=../config/${LIBC_TARGET_OS}/errno.h.in
   GEN_HDR errno.h
   DATA_FILES
     ../config/${LIBC_TARGET_OS}/errno.h.in
 )

libc/include/threads.h.def

+//===---------------- C standard library header threads.h -----------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_THREADS_H
+#define LLVM_LIBC_THREADS_H
+
+#include <__llvm-libc-common.h>
+
+%%public_api()
+
+#endif // LLVM_LIBC_THREADS_H

libc/spec/linux.td

HeaderSpec Errno = HeaderSpec<
         Macro<"EHWPOISON">,
         Macro<"ELIBMAX">,
         Macro<"ESOCKTNOSUPPORT">,
         Macro<"ENOTNAM">,
         Macro<"ELNRNG">,
         Macro<"EL2NSYNC">,
         Macro<"EADV">,
         Macro<"ECOMM">,
-      ],
-      [], // Types
-      []  // Functions
+      ]
   >;
 
   HeaderSpec SysMMan = HeaderSpec<
       "sys/mman.h",
-      [Macro<"MAP_ANONYMOUS">],
-      [], // Types
-      []  // Functions
+      [Macro<"MAP_ANONYMOUS">]
   >;
 
   HeaderSpec Signal = HeaderSpec<
       "signal.h",
       [
         Macro<"NSIG">,
 
         Macro<"SIGHUP">,
HeaderSpec Signal = HeaderSpec<
         Macro<"SIGVTALRM">,
         Macro<"SIGPROF">,
         Macro<"SIGWINCH">,
         Macro<"SIGIO">,
         Macro<"SIGPOLL">,
         Macro<"SIGPWR">,
         Macro<"SIGSYS">,
         Macro<"SIGUNUSED">,
-      ],
-      [], // Types
-      []  // Functions
+      ]
   >;
 
   let Headers = [
     Errno,
     SysMMan,
     Signal,
   ];
 }

libc/spec/posix.td

HeaderSpec Errno = HeaderSpec<
         Macro<"ESTALE">,
         Macro<"ETIME">,
         Macro<"ETIMEDOUT">,
         Macro<"ETXTBSY">,
         Macro<"EWOULDBLOCK">,
         Macro<"EXDEV">,
       ],
       [], // Types
+      [], // Enumerations
       []  // Functions
   >;
 
   HeaderSpec SysMMan = HeaderSpec<
       "sys/mman.h",
       [
         // TODO: Add a facility to bunch macros into bitwise-or-able groups.
         // POSIX requires it, so such thing should be captured in this spec.
         Macro<"PROT_EXEC">,
         Macro<"PROT_NONE">,
         Macro<"PROT_READ">,
         Macro<"PROT_WRITE">,
 
         Macro<"MAP_FIXED">,
         Macro<"MAP_PRIVATE">,
         Macro<"MAP_SHARED">,
 
         Macro<"MAP_FAILED">,
       ],
       [
         SizeTType,
         OffTType,
       ],
+      [], // Enumerations
       [
         FunctionSpec<
             "mmap",
             RetValSpec<VoidPtr>,
             [ArgSpec<VoidPtr>,
              ArgSpec<SizeTType>,
              ArgSpec<IntType>,
              ArgSpec<IntType>,

libc/spec/spec.td

 class Type {}
 
 class NamedType<string name> : Type {
   string Name = name;
 }
 
 class Field<string name, Type type> {
   string Name = name;
   Type FieldType = type;
 }
 
 // Class to describe concrete structs specified by a standard.
 class Struct<string name> : NamedType<name> {
   list<Field> Fields;
 }
 
+class EnumNameValue<string name, string value = "__default_enum_value__"> {
+  string Name = name;
+  string Value = value;
+}
+
+class Enum<string name, list<EnumNameValue> enumerations> : NamedType<name> {
+  list<EnumNameValue> Enumerations = enumerations;
+}
+
 class PtrType<Type type> : Type {
   Type PointeeType = type;
 }
 
 class ConstType<Type type> : Type {
   Type UnqualifiedType = type;
 }
 

 // Common types
 def VoidPtr : PtrType<VoidType>;
 def SizeTType : NamedType<"size_t">;
 
 class Macro<string name> {
   string Name = name;
 }
 
+class EnumeratedNameValue<string name, string value = "__default__"> {
+  string Name = name;
+  string Value = value;
+}
+
 class Annotation {}
 
 class RetValSpec<Type type, list<Annotation> annotations = []> {
   Type ReturnType = type;
   list<Annotation> Annotations = annotations;
 }
 
 class ArgSpec<Type type, list<Annotation> annotations = [], string name = ""> {
   Type ArgType = type;
   list<Annotation> Annotations = annotations;
   string Name = name;
 }
 
 class FunctionSpec<string name, RetValSpec return, list<ArgSpec> args> {
   string Name = name;
   RetValSpec Return = return;
   list<ArgSpec> Args = args;
 }
 
 class HeaderSpec<string name,
-                list<Macro> macros,
-                list<Type> types,
-                list<FunctionSpec> functions> {
+                list<Macro> macros = [],
+                list<Type> types = [],
+                list<EnumeratedNameValue> enumerations = [],
+                list<FunctionSpec> functions = []> {
   string Name = name;
   list<FunctionSpec> Functions = functions;
   list<Type> Types = types;
   list<Macro> Macros = macros;
+  list<EnumeratedNameValue> Enumerations = enumerations;
 }
 
 class StandardSpec<string name> {
   string Name = name;
   list<HeaderSpec> Headers;
 }

libc/spec/stdc.td

 def StdC : StandardSpec<"stdc"> {
   ConstType ConstVoidPtr = ConstType<VoidPtr>;
   RestrictedPtrType VoidRestrictedPtr = RestrictedPtrType<VoidType>;
   ConstType ConstVoidRestrictedPtr = ConstType<VoidRestrictedPtr>;
 
   PtrType CharPtr = PtrType<CharType>;
   ConstType ConstCharPtr = ConstType<CharPtr>;
   RestrictedPtrType CharRestrictedPtr = RestrictedPtrType<CharType>;
   ConstType ConstCharRestrictedPtr = ConstType<CharRestrictedPtr>;
 
+  NamedType MtxTType = NamedType<"mtx_t">;
+  PtrType MtxTTypePtr = PtrType<MtxTType>;
+  NamedType ThrdStartTType = NamedType<"thrd_start_t">;
+  NamedType ThrdTType = NamedType<"thrd_t">;
+  PtrType ThrdTTypePtr = PtrType<ThrdTType>;
+
+  PtrType IntPtr = PtrType<IntType>;
+
   HeaderSpec String = HeaderSpec<
       "string.h",
       [
           Macro<"NULL">,
       ],
       [
           SizeTType,
       ],
+      [], // Enumerations
       [
           FunctionSpec<
               "memcpy",
               RetValSpec<VoidPtr>, 
               [ArgSpec<VoidRestrictedPtr>,
                ArgSpec<ConstVoidRestrictedPtr>,
                ArgSpec<SizeTType>]
           >,
def StdC : StandardSpec<"stdc"> {
 
   HeaderSpec Math = HeaderSpec<
       "math.h",
       [], // Macros
       [
           NamedType<"float_t">,
           NamedType<"double_t">,
       ],
+      [], // Enumerations
       [
           FunctionSpec<"acos", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"acosl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>]>,
       ]
   >;
 
   HeaderSpec StdIO = HeaderSpec<
       "stdio.h",
       [], // Macros
       [ // Types
           SizeTType,
       ],
+      [], // Enumerations
       [
           FunctionSpec<
               "snprintf",
               RetValSpec<IntType>,
               [ArgSpec<CharPtr>,
                ArgSpec<SizeTType>,
                ArgSpec<ConstCharRestrictedPtr>,
                ArgSpec<VarArgType>]
           >,
       ]
   >;
 
   HeaderSpec Errno = HeaderSpec<
       "errno.h",
       [
         Macro<"errno">,
         Macro<"EDOM">,
         Macro<"EILSEQ">,
         Macro<"ERANGE">,
-      ],
-      [], // Types
-      []  // Functions
+      ]
   >;
 
   HeaderSpec Signal = HeaderSpec<
       "signal.h",
       [
         Macro<"SIG_BLOCK">,
         Macro<"SIG_UNBLOCK">,
         Macro<"SIG_SETMASK">,
 
         Macro<"SIGABRT">,
         Macro<"SIGFPE">,
         Macro<"SIGILL">,
         Macro<"SIGINT">,
         Macro<"SIGSEGV">,
         Macro<"SIGTERM">
       ],
       [
         NamedType<"sigset_t">,
         SizeTType,
       ],
+      [], // Enumerations
       [
         FunctionSpec<"raise", RetValSpec<IntType>, [ArgSpec<IntType>]>,
       ]
   >;
 
+  HeaderSpec Threads = HeaderSpec<
+      "threads.h",
+      [], // Macros
+      [
+          MtxTType,
+          ThrdStartTType,
+          ThrdTType,
+      ],
+      [
+          EnumeratedNameValue<"mtx_plain">,
+          EnumeratedNameValue<"mtx_recursive">,
+          EnumeratedNameValue<"mtx_timed">,
+          EnumeratedNameValue<"thrd_timedout">,
+          EnumeratedNameValue<"thrd_success">,
+          EnumeratedNameValue<"thrd_busy">,
+          EnumeratedNameValue<"thrd_error">,
+          EnumeratedNameValue<"thrd_nomem">,
+      ],
+      [
+          FunctionSpec<
+              "mtx_init",
+              RetValSpec<IntType>,
+              [
+                  ArgSpec<MtxTTypePtr>,
+                  ArgSpec<IntType>,
+              ]
+          >,
+          FunctionSpec<
+              "mtx_lock",
+              RetValSpec<IntType>,
+              [
+                  ArgSpec<MtxTTypePtr>,
+              ]
+          >,
+          FunctionSpec<
+              "mtx_unlock",
+              RetValSpec<IntType>,
+              [
+                  ArgSpec<MtxTTypePtr>,
+              ]
+          >,
+          FunctionSpec<
+              "thrd_create",
+              RetValSpec<IntType>,
+              [
+                  ArgSpec<ThrdTTypePtr>,
+                  ArgSpec<ThrdStartTType>,
+                  ArgSpec<VoidPtr>,
+              ]
+          >,
+          FunctionSpec<
+              "thrd_join",
+              RetValSpec<IntType>,
+              [
+                  ArgSpec<ThrdTTypePtr>,
+                  ArgSpec<IntPtr>,
+              ]
+          >
+      ]
+  >;
+
   let Headers = [
     Errno,
     Math,
     String,
     StdIO,
     Signal,
+    Threads,
   ];
 }

libc/utils/HdrGen/PublicAPICommand.cpp

class APIGenerator {
   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); }
 
for (llvm::Record *HeaderSpec : HeaderSpecList) {
           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 EnumerationSpecList =
+            HeaderSpec->getValueAsListOfDefs("Enumerations");
+        for (llvm::Record *EnumerationSpec : EnumerationSpecList) {
+          EnumerationSpecMap[std::string(
+              EnumerationSpec->getValueAsString("Name"))] = EnumerationSpec;
+        }
       }
     }
   }
 
   void 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 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));
+
+    auto EnumerationList = PublicAPI->getValueAsListOfStrings("Enumerations");
+    for (llvm::StringRef EnumerationName : EnumerationList)
+      Enumerations.insert(std::string(EnumerationName));
   }
 
   void index(llvm::RecordKeeper &Records) {
     NamedTypeClass = Records.getClass(NamedTypeClassName);
     PtrTypeClass = Records.getClass(PtrTypeClassName);
     RestrictedPtrTypeClass = Records.getClass(RestrictedPtrTypeClassName);
     StructClass = Records.getClass(StructTypeClassName);
     ConstTypeClass = Records.getClass(ConstTypeClassName);
for (auto &Pair : TypeDeclsMap) {
         llvm::PrintFatalError(Name + " not found in any standard spec.\n");
 
       llvm::Record *TypeDecl = Pair.second;
       dedentAndWrite(TypeDecl->getValueAsString("Decl"), OS);
 
       OS << '\n';
     }
 
+    if (Enumerations.size() != 0)
+      OS << "enum {" << '\n';
+    for (const auto &Name : Enumerations) {
+      if (EnumerationSpecMap.find(Name) == EnumerationSpecMap.end())
+        llvm::PrintFatalError(
+            Name + " is not listed as an enumeration in any standard spec.\n");
+
+      llvm::Record *EnumerationSpec = EnumerationSpecMap[Name];
+      OS << "  " << EnumerationSpec->getValueAsString("Name");
+      auto Value = EnumerationSpec->getValueAsString("Value");
+      if (Value == "__default__") {
+        OS << ",\n";
+      } else {
+        OS << " = " << Value << ",\n";
+      }
+    }
+    if (Enumerations.size() != 0)
+      OS << "};\n\n";
+
     OS << "__BEGIN_C_DECLS\n\n";
     for (auto &Name : Functions) {
       if (FunctionSpecMap.find(Name) == FunctionSpecMap.end())
         llvm::PrintFatalError(Name + " not found in any standard spec.\n");
 
       llvm::Record *FunctionSpec = FunctionSpecMap[Name];
       llvm::Record *RetValSpec = FunctionSpec->getValueAsDef("Return");
       llvm::Record *ReturnType = RetValSpec->getValueAsDef("ReturnType");