libc/utils/LibcTableGenUtil/APIIndexer.cpp

   1 //===-- Implementation of APIIndexer class --------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "APIIndexer.h"
  10
  11 #include "llvm/ADT/StringExtras.h"
  12 #include "llvm/ADT/StringRef.h"
  13 #include "llvm/TableGen/Error.h"
  14 #include "llvm/TableGen/Record.h"
  15
  16 namespace llvm_libc {
  17
  18 static const char NamedTypeClassName[] = "NamedType";
  19 static const char PtrTypeClassName[] = "PtrType";
  20 static const char RestrictedPtrTypeClassName[] = "RestrictedPtrType";
  21 static const char ConstTypeClassName[] = "ConstType";
  22 static const char StructTypeClassName[] = "Struct";
  23
  24 static const char StandardSpecClassName[] = "StandardSpec";
  25 static const char PublicAPIClassName[] = "PublicAPI";
  26
  27 static bool isa(llvm::Record *Def, llvm::Record *TypeClass) {
  28   llvm::RecordRecTy *RecordType = Def->getType();
  29   llvm::ArrayRef<llvm::Record *> Classes = RecordType->getClasses();
  30   // We want exact types. That is, we don't want the classes listed in
  31   // spec.td to be subclassed. Hence, we do not want the record |Def|
  32   // to be of more than one class type..
  33   if (Classes.size() != 1)
  34     return false;
  35   return Classes[0] == TypeClass;
  36 }
  37
  38 bool APIIndexer::isaNamedType(llvm::Record *Def) {
  39   return isa(Def, NamedTypeClass);
  40 }
  41
  42 bool APIIndexer::isaStructType(llvm::Record *Def) {
  43   return isa(Def, StructClass);
  44 }
  45
  46 bool APIIndexer::isaPtrType(llvm::Record *Def) {
  47   return isa(Def, PtrTypeClass);
  48 }
  49
  50 bool APIIndexer::isaConstType(llvm::Record *Def) {
  51   return isa(Def, ConstTypeClass);
  52 }
  53
  54 bool APIIndexer::isaRestrictedPtrType(llvm::Record *Def) {
  55   return isa(Def, RestrictedPtrTypeClass);
  56 }
  57
  58 bool APIIndexer::isaStandardSpec(llvm::Record *Def) {
  59   return isa(Def, StandardSpecClass);
  60 }
  61
  62 bool APIIndexer::isaPublicAPI(llvm::Record *Def) {
  63   return isa(Def, PublicAPIClass);
  64 }
  65
  66 std::string APIIndexer::getTypeAsString(llvm::Record *TypeRecord) {
  67   if (isaNamedType(TypeRecord) || isaStructType(TypeRecord)) {
  68     return std::string(TypeRecord->getValueAsString("Name"));
  69   } else if (isaPtrType(TypeRecord)) {
  70     return getTypeAsString(TypeRecord->getValueAsDef("PointeeType")) + " *";
  71   } else if (isaConstType(TypeRecord)) {
  72     return std::string("const ") +
  73            getTypeAsString(TypeRecord->getValueAsDef("UnqualifiedType"));
  74   } else if (isaRestrictedPtrType(TypeRecord)) {
  75     return getTypeAsString(TypeRecord->getValueAsDef("PointeeType")) +
  76            " *__restrict";
  77   } else {
  78     llvm::PrintFatalError(TypeRecord->getLoc(), "Invalid type.\n");
  79   }
  80 }
  81
  82 void APIIndexer::indexStandardSpecDef(llvm::Record *StandardSpec) {
  83   auto HeaderSpecList = StandardSpec->getValueAsListOfDefs("Headers");
  84   for (llvm::Record *HeaderSpec : HeaderSpecList) {
  85     llvm::StringRef Header = HeaderSpec->getValueAsString("Name");
  86     if (!StdHeader.has_value() || Header == StdHeader) {
  87       PublicHeaders.emplace(Header);
  88       auto MacroSpecList = HeaderSpec->getValueAsListOfDefs("Macros");
  89       // TODO: Trigger a fatal error on duplicate specs.
  90       for (llvm::Record *MacroSpec : MacroSpecList)
  91         MacroSpecMap[std::string(MacroSpec->getValueAsString("Name"))] =
  92             MacroSpec;
  93
  94       auto TypeSpecList = HeaderSpec->getValueAsListOfDefs("Types");
  95       for (llvm::Record *TypeSpec : TypeSpecList)
  96         TypeSpecMap[std::string(TypeSpec->getValueAsString("Name"))] = TypeSpec;
  97
  98       auto FunctionSpecList = HeaderSpec->getValueAsListOfDefs("Functions");
  99       for (llvm::Record *FunctionSpec : FunctionSpecList) {
 100         auto FunctionName = std::string(FunctionSpec->getValueAsString("Name"));
 101         FunctionSpecMap[FunctionName] = FunctionSpec;
 102         FunctionToHeaderMap[FunctionName] = std::string(Header);
 103       }
 104
 105       auto EnumerationSpecList =
 106           HeaderSpec->getValueAsListOfDefs("Enumerations");
 107       for (llvm::Record *EnumerationSpec : EnumerationSpecList) {
 108         EnumerationSpecMap[std::string(
 109             EnumerationSpec->getValueAsString("Name"))] = EnumerationSpec;
 110       }
 111
 112       auto ObjectSpecList = HeaderSpec->getValueAsListOfDefs("Objects");
 113       for (llvm::Record *ObjectSpec : ObjectSpecList) {
 114         auto ObjectName = std::string(ObjectSpec->getValueAsString("Name"));
 115         ObjectSpecMap[ObjectName] = ObjectSpec;
 116         ObjectToHeaderMap[ObjectName] = std::string(Header);
 117       }
 118     }
 119   }
 120 }
 121
 122 void APIIndexer::indexPublicAPIDef(llvm::Record *PublicAPI) {
 123   // While indexing the public API, we do not check if any of the entities
 124   // requested is from an included standard. Such a check is done while
 125   // generating the API.
 126   auto MacroDefList = PublicAPI->getValueAsListOfDefs("Macros");
 127   for (llvm::Record *MacroDef : MacroDefList)
 128     MacroDefsMap[std::string(MacroDef->getValueAsString("Name"))] = MacroDef;
 129
 130   auto TypeList = PublicAPI->getValueAsListOfStrings("Types");
 131   for (llvm::StringRef TypeName : TypeList)
 132     RequiredTypes.insert(std::string(TypeName));
 133
 134   auto StructList = PublicAPI->getValueAsListOfStrings("Structs");
 135   for (llvm::StringRef StructName : StructList)
 136     Structs.insert(std::string(StructName));
 137
 138   auto FunctionList = PublicAPI->getValueAsListOfStrings("Functions");
 139   for (llvm::StringRef FunctionName : FunctionList)
 140     Functions.insert(std::string(FunctionName));
 141
 142   auto EnumerationList = PublicAPI->getValueAsListOfStrings("Enumerations");
 143   for (llvm::StringRef EnumerationName : EnumerationList)
 144     Enumerations.insert(std::string(EnumerationName));
 145
 146   auto ObjectList = PublicAPI->getValueAsListOfStrings("Objects");
 147   for (llvm::StringRef ObjectName : ObjectList)
 148     Objects.insert(std::string(ObjectName));
 149 }
 150
 151 void APIIndexer::index(llvm::RecordKeeper &Records) {
 152   NamedTypeClass = Records.getClass(NamedTypeClassName);
 153   PtrTypeClass = Records.getClass(PtrTypeClassName);
 154   RestrictedPtrTypeClass = Records.getClass(RestrictedPtrTypeClassName);
 155   StructClass = Records.getClass(StructTypeClassName);
 156   ConstTypeClass = Records.getClass(ConstTypeClassName);
 157   StandardSpecClass = Records.getClass(StandardSpecClassName);
 158   PublicAPIClass = Records.getClass(PublicAPIClassName);
 159
 160   const auto &DefsMap = Records.getDefs();
 161   for (auto &Pair : DefsMap) {
 162     llvm::Record *Def = Pair.second.get();
 163     if (isaStandardSpec(Def))
 164       indexStandardSpecDef(Def);
 165     if (isaPublicAPI(Def)) {
 166       if (!StdHeader.has_value() ||
 167           Def->getValueAsString("HeaderName") == StdHeader)
 168         indexPublicAPIDef(Def);
 169     }
 170   }
 171 }
 172
 173 } // namespace llvm_libc