forked from OSchip/llvm-project
163 lines
6.0 KiB
C++
163 lines
6.0 KiB
C++
//===-- Implementation of APIIndexer class --------------------------------===//
|
|
//
|
|
// 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 "APIIndexer.h"
|
|
|
|
#include "llvm/ADT/StringExtras.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/TableGen/Error.h"
|
|
#include "llvm/TableGen/Record.h"
|
|
|
|
namespace llvm_libc {
|
|
|
|
static const char NamedTypeClassName[] = "NamedType";
|
|
static const char PtrTypeClassName[] = "PtrType";
|
|
static const char RestrictedPtrTypeClassName[] = "RestrictedPtrType";
|
|
static const char ConstTypeClassName[] = "ConstType";
|
|
static const char StructTypeClassName[] = "Struct";
|
|
|
|
static const char StandardSpecClassName[] = "StandardSpec";
|
|
static const char PublicAPIClassName[] = "PublicAPI";
|
|
|
|
static bool isa(llvm::Record *Def, llvm::Record *TypeClass) {
|
|
llvm::RecordRecTy *RecordType = Def->getType();
|
|
llvm::ArrayRef<llvm::Record *> Classes = RecordType->getClasses();
|
|
// We want exact types. That is, we don't want the classes listed in
|
|
// spec.td to be subclassed. Hence, we do not want the record |Def|
|
|
// to be of more than one class type..
|
|
if (Classes.size() != 1)
|
|
return false;
|
|
return Classes[0] == TypeClass;
|
|
}
|
|
|
|
bool APIIndexer::isaNamedType(llvm::Record *Def) {
|
|
return isa(Def, NamedTypeClass);
|
|
}
|
|
|
|
bool APIIndexer::isaStructType(llvm::Record *Def) {
|
|
return isa(Def, StructClass);
|
|
}
|
|
|
|
bool APIIndexer::isaPtrType(llvm::Record *Def) {
|
|
return isa(Def, PtrTypeClass);
|
|
}
|
|
|
|
bool APIIndexer::isaConstType(llvm::Record *Def) {
|
|
return isa(Def, ConstTypeClass);
|
|
}
|
|
|
|
bool APIIndexer::isaRestrictedPtrType(llvm::Record *Def) {
|
|
return isa(Def, RestrictedPtrTypeClass);
|
|
}
|
|
|
|
bool APIIndexer::isaStandardSpec(llvm::Record *Def) {
|
|
return isa(Def, StandardSpecClass);
|
|
}
|
|
|
|
bool APIIndexer::isaPublicAPI(llvm::Record *Def) {
|
|
return isa(Def, PublicAPIClass);
|
|
}
|
|
|
|
std::string APIIndexer::getTypeAsString(llvm::Record *TypeRecord) {
|
|
if (isaNamedType(TypeRecord) || isaStructType(TypeRecord)) {
|
|
return std::string(TypeRecord->getValueAsString("Name"));
|
|
} else if (isaPtrType(TypeRecord)) {
|
|
return getTypeAsString(TypeRecord->getValueAsDef("PointeeType")) + " *";
|
|
} else if (isaConstType(TypeRecord)) {
|
|
return std::string("const ") +
|
|
getTypeAsString(TypeRecord->getValueAsDef("UnqualifiedType"));
|
|
} else if (isaRestrictedPtrType(TypeRecord)) {
|
|
return getTypeAsString(TypeRecord->getValueAsDef("PointeeType")) +
|
|
" *__restrict";
|
|
} else {
|
|
llvm::PrintFatalError(TypeRecord->getLoc(), "Invalid type.\n");
|
|
}
|
|
}
|
|
|
|
void APIIndexer::indexStandardSpecDef(llvm::Record *StandardSpec) {
|
|
auto HeaderSpecList = StandardSpec->getValueAsListOfDefs("Headers");
|
|
for (llvm::Record *HeaderSpec : HeaderSpecList) {
|
|
llvm::StringRef Header = HeaderSpec->getValueAsString("Name");
|
|
if (!StdHeader.hasValue() || Header == StdHeader) {
|
|
PublicHeaders.emplace(Header);
|
|
auto MacroSpecList = HeaderSpec->getValueAsListOfDefs("Macros");
|
|
// TODO: Trigger a fatal error on duplicate specs.
|
|
for (llvm::Record *MacroSpec : MacroSpecList)
|
|
MacroSpecMap[std::string(MacroSpec->getValueAsString("Name"))] =
|
|
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) {
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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 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 APIIndexer::index(llvm::RecordKeeper &Records) {
|
|
NamedTypeClass = Records.getClass(NamedTypeClassName);
|
|
PtrTypeClass = Records.getClass(PtrTypeClassName);
|
|
RestrictedPtrTypeClass = Records.getClass(RestrictedPtrTypeClassName);
|
|
StructClass = Records.getClass(StructTypeClassName);
|
|
ConstTypeClass = Records.getClass(ConstTypeClassName);
|
|
StandardSpecClass = Records.getClass(StandardSpecClassName);
|
|
PublicAPIClass = Records.getClass(PublicAPIClassName);
|
|
|
|
const auto &DefsMap = Records.getDefs();
|
|
for (auto &Pair : DefsMap) {
|
|
llvm::Record *Def = Pair.second.get();
|
|
if (isaStandardSpec(Def))
|
|
indexStandardSpecDef(Def);
|
|
if (isaPublicAPI(Def)) {
|
|
if (!StdHeader.hasValue() ||
|
|
Def->getValueAsString("HeaderName") == StdHeader)
|
|
indexPublicAPIDef(Def);
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace llvm_libc
|