mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-19 11:02:59 +02:00
7aeb5f145e
The aim of this backend is to output everything TableGen knows about the record set, similarly to the default -print-records backend. But where -print-records produces output in TableGen's input syntax (convenient for humans to read), this backend produces it as structured JSON data, which is convenient for loading into standard scripting languages such as Python, in order to extract information from the data set in an automated way. The output data contains a JSON representation of the variable definitions in output 'def' records, and a few pieces of metadata such as which of those definitions are tagged with the 'field' prefix and which defs are derived from which classes. It doesn't dump out absolutely every piece of knowledge it _could_ produce, such as type information and complicated arithmetic operator nodes in abstract superclasses; the main aim is to allow consumers of this JSON dump to essentially act as new backends, and backends don't generally need to depend on that kind of data. The new backend is implemented as an EmitJSON() function similar to all of llvm-tblgen's other EmitFoo functions, except that it lives in lib/TableGen instead of utils/TableGen on the basis that I'm expecting to add it to clang-tblgen too in a future patch. To test it, I've written a Python script that loads the JSON output and tests properties of it based on comments in the .td source - more or less like FileCheck, except that the CHECK: lines have Python expressions after them instead of textual pattern matches. Reviewers: nhaehnle Reviewed By: nhaehnle Subscribers: arichardson, labath, mgorny, llvm-commits Differential Revision: https://reviews.llvm.org/D46054 llvm-svn: 336771
258 lines
8.8 KiB
C++
258 lines
8.8 KiB
C++
//===- TableGen.cpp - Top-Level TableGen implementation for LLVM ----------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file contains the main function for LLVM's TableGen.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "TableGenBackends.h" // Declares all backends.
|
|
#include "llvm/Support/CommandLine.h"
|
|
#include "llvm/Support/ManagedStatic.h"
|
|
#include "llvm/Support/PrettyStackTrace.h"
|
|
#include "llvm/Support/Signals.h"
|
|
#include "llvm/TableGen/Main.h"
|
|
#include "llvm/TableGen/Record.h"
|
|
#include "llvm/TableGen/SetTheory.h"
|
|
|
|
using namespace llvm;
|
|
|
|
enum ActionType {
|
|
PrintRecords,
|
|
DumpJSON,
|
|
GenEmitter,
|
|
GenRegisterInfo,
|
|
GenInstrInfo,
|
|
GenInstrDocs,
|
|
GenAsmWriter,
|
|
GenAsmMatcher,
|
|
GenDisassembler,
|
|
GenPseudoLowering,
|
|
GenCompressInst,
|
|
GenCallingConv,
|
|
GenDAGISel,
|
|
GenDFAPacketizer,
|
|
GenFastISel,
|
|
GenSubtarget,
|
|
GenIntrinsicEnums,
|
|
GenIntrinsicImpl,
|
|
GenTgtIntrinsicEnums,
|
|
GenTgtIntrinsicImpl,
|
|
PrintEnums,
|
|
PrintSets,
|
|
GenOptParserDefs,
|
|
GenCTags,
|
|
GenAttributes,
|
|
GenSearchableTables,
|
|
GenGlobalISel,
|
|
GenX86EVEX2VEXTables,
|
|
GenX86FoldTables,
|
|
GenRegisterBank,
|
|
};
|
|
|
|
namespace {
|
|
cl::opt<ActionType>
|
|
Action(cl::desc("Action to perform:"),
|
|
cl::values(clEnumValN(PrintRecords, "print-records",
|
|
"Print all records to stdout (default)"),
|
|
clEnumValN(DumpJSON, "dump-json",
|
|
"Dump all records as machine-readable JSON"),
|
|
clEnumValN(GenEmitter, "gen-emitter",
|
|
"Generate machine code emitter"),
|
|
clEnumValN(GenRegisterInfo, "gen-register-info",
|
|
"Generate registers and register classes info"),
|
|
clEnumValN(GenInstrInfo, "gen-instr-info",
|
|
"Generate instruction descriptions"),
|
|
clEnumValN(GenInstrDocs, "gen-instr-docs",
|
|
"Generate instruction documentation"),
|
|
clEnumValN(GenCallingConv, "gen-callingconv",
|
|
"Generate calling convention descriptions"),
|
|
clEnumValN(GenAsmWriter, "gen-asm-writer",
|
|
"Generate assembly writer"),
|
|
clEnumValN(GenDisassembler, "gen-disassembler",
|
|
"Generate disassembler"),
|
|
clEnumValN(GenPseudoLowering, "gen-pseudo-lowering",
|
|
"Generate pseudo instruction lowering"),
|
|
clEnumValN(GenCompressInst, "gen-compress-inst-emitter",
|
|
"Generate RISCV compressed instructions."),
|
|
clEnumValN(GenAsmMatcher, "gen-asm-matcher",
|
|
"Generate assembly instruction matcher"),
|
|
clEnumValN(GenDAGISel, "gen-dag-isel",
|
|
"Generate a DAG instruction selector"),
|
|
clEnumValN(GenDFAPacketizer, "gen-dfa-packetizer",
|
|
"Generate DFA Packetizer for VLIW targets"),
|
|
clEnumValN(GenFastISel, "gen-fast-isel",
|
|
"Generate a \"fast\" instruction selector"),
|
|
clEnumValN(GenSubtarget, "gen-subtarget",
|
|
"Generate subtarget enumerations"),
|
|
clEnumValN(GenIntrinsicEnums, "gen-intrinsic-enums",
|
|
"Generate intrinsic enums"),
|
|
clEnumValN(GenIntrinsicImpl, "gen-intrinsic-impl",
|
|
"Generate intrinsic information"),
|
|
clEnumValN(GenTgtIntrinsicEnums, "gen-tgt-intrinsic-enums",
|
|
"Generate target intrinsic enums"),
|
|
clEnumValN(GenTgtIntrinsicImpl, "gen-tgt-intrinsic-impl",
|
|
"Generate target intrinsic information"),
|
|
clEnumValN(PrintEnums, "print-enums",
|
|
"Print enum values for a class"),
|
|
clEnumValN(PrintSets, "print-sets",
|
|
"Print expanded sets for testing DAG exprs"),
|
|
clEnumValN(GenOptParserDefs, "gen-opt-parser-defs",
|
|
"Generate option definitions"),
|
|
clEnumValN(GenCTags, "gen-ctags",
|
|
"Generate ctags-compatible index"),
|
|
clEnumValN(GenAttributes, "gen-attrs",
|
|
"Generate attributes"),
|
|
clEnumValN(GenSearchableTables, "gen-searchable-tables",
|
|
"Generate generic binary-searchable table"),
|
|
clEnumValN(GenGlobalISel, "gen-global-isel",
|
|
"Generate GlobalISel selector"),
|
|
clEnumValN(GenX86EVEX2VEXTables, "gen-x86-EVEX2VEX-tables",
|
|
"Generate X86 EVEX to VEX compress tables"),
|
|
clEnumValN(GenX86FoldTables, "gen-x86-fold-tables",
|
|
"Generate X86 fold tables"),
|
|
clEnumValN(GenRegisterBank, "gen-register-bank",
|
|
"Generate registers bank descriptions")));
|
|
|
|
cl::OptionCategory PrintEnumsCat("Options for -print-enums");
|
|
cl::opt<std::string>
|
|
Class("class", cl::desc("Print Enum list for this class"),
|
|
cl::value_desc("class name"), cl::cat(PrintEnumsCat));
|
|
|
|
bool LLVMTableGenMain(raw_ostream &OS, RecordKeeper &Records) {
|
|
switch (Action) {
|
|
case PrintRecords:
|
|
OS << Records; // No argument, dump all contents
|
|
break;
|
|
case DumpJSON:
|
|
EmitJSON(Records, OS);
|
|
break;
|
|
case GenEmitter:
|
|
EmitCodeEmitter(Records, OS);
|
|
break;
|
|
case GenRegisterInfo:
|
|
EmitRegisterInfo(Records, OS);
|
|
break;
|
|
case GenInstrInfo:
|
|
EmitInstrInfo(Records, OS);
|
|
break;
|
|
case GenInstrDocs:
|
|
EmitInstrDocs(Records, OS);
|
|
break;
|
|
case GenCallingConv:
|
|
EmitCallingConv(Records, OS);
|
|
break;
|
|
case GenAsmWriter:
|
|
EmitAsmWriter(Records, OS);
|
|
break;
|
|
case GenAsmMatcher:
|
|
EmitAsmMatcher(Records, OS);
|
|
break;
|
|
case GenDisassembler:
|
|
EmitDisassembler(Records, OS);
|
|
break;
|
|
case GenPseudoLowering:
|
|
EmitPseudoLowering(Records, OS);
|
|
break;
|
|
case GenCompressInst:
|
|
EmitCompressInst(Records, OS);
|
|
break;
|
|
case GenDAGISel:
|
|
EmitDAGISel(Records, OS);
|
|
break;
|
|
case GenDFAPacketizer:
|
|
EmitDFAPacketizer(Records, OS);
|
|
break;
|
|
case GenFastISel:
|
|
EmitFastISel(Records, OS);
|
|
break;
|
|
case GenSubtarget:
|
|
EmitSubtarget(Records, OS);
|
|
break;
|
|
case GenIntrinsicEnums:
|
|
EmitIntrinsicEnums(Records, OS);
|
|
break;
|
|
case GenIntrinsicImpl:
|
|
EmitIntrinsicImpl(Records, OS);
|
|
break;
|
|
case GenTgtIntrinsicEnums:
|
|
EmitIntrinsicEnums(Records, OS, true);
|
|
break;
|
|
case GenTgtIntrinsicImpl:
|
|
EmitIntrinsicImpl(Records, OS, true);
|
|
break;
|
|
case GenOptParserDefs:
|
|
EmitOptParser(Records, OS);
|
|
break;
|
|
case PrintEnums:
|
|
{
|
|
for (Record *Rec : Records.getAllDerivedDefinitions(Class))
|
|
OS << Rec->getName() << ", ";
|
|
OS << "\n";
|
|
break;
|
|
}
|
|
case PrintSets:
|
|
{
|
|
SetTheory Sets;
|
|
Sets.addFieldExpander("Set", "Elements");
|
|
for (Record *Rec : Records.getAllDerivedDefinitions("Set")) {
|
|
OS << Rec->getName() << " = [";
|
|
const std::vector<Record*> *Elts = Sets.expand(Rec);
|
|
assert(Elts && "Couldn't expand Set instance");
|
|
for (Record *Elt : *Elts)
|
|
OS << ' ' << Elt->getName();
|
|
OS << " ]\n";
|
|
}
|
|
break;
|
|
}
|
|
case GenCTags:
|
|
EmitCTags(Records, OS);
|
|
break;
|
|
case GenAttributes:
|
|
EmitAttributes(Records, OS);
|
|
break;
|
|
case GenSearchableTables:
|
|
EmitSearchableTables(Records, OS);
|
|
break;
|
|
case GenGlobalISel:
|
|
EmitGlobalISel(Records, OS);
|
|
break;
|
|
case GenRegisterBank:
|
|
EmitRegisterBank(Records, OS);
|
|
break;
|
|
case GenX86EVEX2VEXTables:
|
|
EmitX86EVEX2VEXTables(Records, OS);
|
|
break;
|
|
case GenX86FoldTables:
|
|
EmitX86FoldTables(Records, OS);
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
sys::PrintStackTraceOnErrorSignal(argv[0]);
|
|
PrettyStackTraceProgram X(argc, argv);
|
|
cl::ParseCommandLineOptions(argc, argv);
|
|
|
|
llvm_shutdown_obj Y;
|
|
|
|
return TableGenMain(argv[0], &LLVMTableGenMain);
|
|
}
|
|
|
|
#ifdef __has_feature
|
|
#if __has_feature(address_sanitizer)
|
|
#include <sanitizer/lsan_interface.h>
|
|
// Disable LeakSanitizer for this binary as it has too many leaks that are not
|
|
// very interesting to fix. See compiler-rt/include/sanitizer/lsan_interface.h .
|
|
LLVM_ATTRIBUTE_USED int __lsan_is_turned_off() { return 1; }
|
|
#endif // __has_feature(address_sanitizer)
|
|
#endif // defined(__has_feature)
|