llvm.org GIT mirror llvm / release_80 utils / TableGen / TableGen.cpp
release_80

Tree @release_80 (Download .tar.gz)

TableGen.cpp @release_80

7c78888
3da94ae
01d4582
 
3060910
 
3da94ae
01d4582
1d1adea
7c78888
1d1adea
 
 
6f36fa9
81cb8ca
d149f59
81cb8ca
1f6efa3
7c78888
 
3b2a256
7c78888
2082ebe
d0fde30
bc52013
 
9cfd4e5
bc52013
73f50d9
22fee2d
bf70e59
22fee2d
 
4058874
86f9adb
839cd7f
50d4565
4a24c64
dc81e5d
b0cf29c
f5fc2cb
af7c445
 
 
 
1de9982
96a564f
426db65
f805775
69ada66
 
8097fcb
b59d804
cb92739
1086a51
f4fb61b
bc52013
 
 
 
 
 
85df225
9cfd4e5
 
bc52013
 
a347f85
73f50d9
22fee2d
15de32d
bf70e59
 
50d4565
 
2e1f51b
 
4058874
 
86f9adb
 
839cd7f
 
d51ffcf
 
4a24c64
 
dc81e5d
 
b0cf29c
 
f5fc2cb
 
af7c445
 
 
9e493cf
af7c445
 
 
49de982
bc52013
 
1de9982
 
96a564f
 
426db65
 
f805775
 
69ada66
8097fcb
 
1086a51
b59d804
 
cb92739
 
1086a51
f4fb61b
 
 
bc52013
d5d8607
bc52013
85df225
d5d8607
6f36fa9
9e21138
 
 
 
 
9cfd4e5
 
 
9e21138
 
 
 
 
 
 
 
 
bf70e59
 
 
9e21138
 
 
 
 
 
 
 
 
 
 
 
 
 
 
839cd7f
 
 
9e21138
 
 
 
 
 
 
 
 
 
 
 
af7c445
 
9e21138
af7c445
 
 
 
 
 
 
 
9e21138
96a564f
 
 
9e21138
 
3490558
 
9e21138
 
 
 
 
 
 
3490558
 
 
9e21138
3490558
 
9e21138
d0fde30
9e21138
 
426db65
 
 
f805775
 
 
69ada66
 
 
8097fcb
 
2733db6
1086a51
 
8097fcb
b59d804
 
 
cb92739
 
 
f4fb61b
 
 
9e21138
 
 
 
2d24e2a
7c78888
 
0eeb3d4
7c78888
 
84e2f95
d149f59
 
9e21138
e62c118
ab39685
3846ce9
 
 
ab39685
3846ce9
48c5bd3
3846ce9
 
//===- 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,
  GenExegesis,
};

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"),
                    clEnumValN(GenExegesis, "gen-exegesis",
                               "Generate llvm-exegesis tables")));

  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;
  case GenExegesis:
    EmitExegesis(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)