clang/utils/TableGen/ClangOpcodesEmitter.cpp

   1 //=== ClangOpcodesEmitter.cpp - constexpr interpreter opcodes ---*- C++ -*-===//
   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 // These tablegen backends emit Clang AST node tables
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "TableGenBackends.h"
  14 #include "llvm/TableGen/Error.h"
  15 #include "llvm/TableGen/Record.h"
  16 #include "llvm/TableGen/StringMatcher.h"
  17 #include "llvm/TableGen/TableGenBackend.h"
  18
  19 using namespace llvm;
  20
  21 namespace {
  22 class ClangOpcodesEmitter {
  23   RecordKeeper &Records;
  24   Record Root;
  25   unsigned NumTypes;
  26
  27 public:
  28   ClangOpcodesEmitter(RecordKeeper &R)
  29     : Records(R), Root("Opcode", SMLoc(), R),
  30       NumTypes(Records.getAllDerivedDefinitions("Type").size()) {}
  31
  32   void run(raw_ostream &OS);
  33
  34 private:
  35   /// Emits the opcode name for the opcode enum.
  36   /// The name is obtained by concatenating the name with the list of types.
  37   void EmitEnum(raw_ostream &OS, StringRef N, Record *R);
  38
  39   /// Emits the switch case and the invocation in the interpreter.
  40   void EmitInterp(raw_ostream &OS, StringRef N, Record *R);
  41
  42   /// Emits the disassembler.
  43   void EmitDisasm(raw_ostream &OS, StringRef N, Record *R);
  44
  45   /// Emits the byte code emitter method.
  46   void EmitEmitter(raw_ostream &OS, StringRef N, Record *R);
  47
  48   /// Emits the prototype.
  49   void EmitProto(raw_ostream &OS, StringRef N, Record *R);
  50
  51   /// Emits the prototype to dispatch from a type.
  52   void EmitGroup(raw_ostream &OS, StringRef N, Record *R);
  53
  54   /// Emits the evaluator method.
  55   void EmitEval(raw_ostream &OS, StringRef N, Record *R);
  56
  57   void PrintTypes(raw_ostream &OS, ArrayRef<Record *> Types);
  58 };
  59
  60 void Enumerate(const Record *R,
  61                StringRef N,
  62                std::function<void(ArrayRef<Record *>, Twine)> &&F) {
  63   llvm::SmallVector<Record *, 2> TypePath;
  64   auto *Types = R->getValueAsListInit("Types");
  65
  66   std::function<void(size_t, const Twine &)> Rec;
  67   Rec = [&TypePath, Types, &Rec, &F](size_t I, const Twine &ID) {
  68     if (I >= Types->size()) {
  69       F(TypePath, ID);
  70       return;
  71     }
  72
  73     if (auto *TypeClass = dyn_cast<DefInit>(Types->getElement(I))) {
  74       for (auto *Type : TypeClass->getDef()->getValueAsListOfDefs("Types")) {
  75         TypePath.push_back(Type);
  76         Rec(I + 1, ID + Type->getName());
  77         TypePath.pop_back();
  78       }
  79     } else {
  80       PrintFatalError("Expected a type class");
  81     }
  82   };
  83   Rec(0, N);
  84 }
  85
  86 } // namespace
  87
  88 void ClangOpcodesEmitter::run(raw_ostream &OS) {
  89   for (auto *Opcode : Records.getAllDerivedDefinitions(Root.getName())) {
  90     // The name is the record name, unless overriden.
  91     StringRef N = Opcode->getValueAsString("Name");
  92     if (N.empty())
  93       N = Opcode->getName();
  94
  95     EmitEnum(OS, N, Opcode);
  96     EmitInterp(OS, N, Opcode);
  97     EmitDisasm(OS, N, Opcode);
  98     EmitProto(OS, N, Opcode);
  99     EmitGroup(OS, N, Opcode);
 100     EmitEmitter(OS, N, Opcode);
 101     EmitEval(OS, N, Opcode);
 102   }
 103 }
 104
 105 void ClangOpcodesEmitter::EmitEnum(raw_ostream &OS, StringRef N, Record *R) {
 106   OS << "#ifdef GET_OPCODE_NAMES\n";
 107   Enumerate(R, N, [&OS](ArrayRef<Record *>, const Twine &ID) {
 108     OS << "OP_" << ID << ",\n";
 109   });
 110   OS << "#endif\n";
 111 }
 112
 113 void ClangOpcodesEmitter::EmitInterp(raw_ostream &OS, StringRef N, Record *R) {
 114   OS << "#ifdef GET_INTERP\n";
 115
 116   Enumerate(R, N, [this, R, &OS, &N](ArrayRef<Record *> TS, const Twine &ID) {
 117     bool CanReturn = R->getValueAsBit("CanReturn");
 118     bool ChangesPC = R->getValueAsBit("ChangesPC");
 119     auto Args = R->getValueAsListOfDefs("Args");
 120
 121     OS << "case OP_" << ID << ": {\n";
 122
 123     if (CanReturn)
 124       OS << "  bool DoReturn = (S.Current == StartFrame);\n";
 125
 126     // Emit calls to read arguments.
 127     for (size_t I = 0, N = Args.size(); I < N; ++I) {
 128       OS << "  auto V" << I;
 129       OS << " = ";
 130       OS << "ReadArg<" << Args[I]->getValueAsString("Name") << ">(S, PC);\n";
 131     }
 132
 133     // Emit a call to the template method and pass arguments.
 134     OS << "  if (!" << N;
 135     PrintTypes(OS, TS);
 136     OS << "(S";
 137     if (ChangesPC)
 138       OS << ", PC";
 139     else
 140       OS << ", OpPC";
 141     if (CanReturn)
 142       OS << ", Result";
 143     for (size_t I = 0, N = Args.size(); I < N; ++I)
 144       OS << ", V" << I;
 145     OS << "))\n";
 146     OS << "    return false;\n";
 147
 148     // Bail out if interpreter returned.
 149     if (CanReturn) {
 150       OS << "  if (!S.Current || S.Current->isRoot())\n";
 151       OS << "    return true;\n";
 152
 153       OS << "  if (DoReturn)\n";
 154       OS << "    return true;\n";
 155     }
 156
 157     OS << "  continue;\n";
 158     OS << "}\n";
 159   });
 160   OS << "#endif\n";
 161 }
 162
 163 void ClangOpcodesEmitter::EmitDisasm(raw_ostream &OS, StringRef N, Record *R) {
 164   OS << "#ifdef GET_DISASM\n";
 165   Enumerate(R, N, [R, &OS](ArrayRef<Record *>, const Twine &ID) {
 166     OS << "case OP_" << ID << ":\n";
 167     OS << "  PrintName(\"" << ID << "\");\n";
 168     OS << "  OS << \"\\t\"";
 169
 170     for (auto *Arg : R->getValueAsListOfDefs("Args")) {
 171       OS << " << ReadArg<" << Arg->getValueAsString("Name") << ">(P, PC)";
 172       OS << " << \" \"";
 173     }
 174
 175     OS << " << \"\\n\";\n";
 176     OS << "  continue;\n";
 177   });
 178   OS << "#endif\n";
 179 }
 180
 181 void ClangOpcodesEmitter::EmitEmitter(raw_ostream &OS, StringRef N, Record *R) {
 182   if (R->getValueAsBit("HasCustomLink"))
 183     return;
 184
 185   OS << "#ifdef GET_LINK_IMPL\n";
 186   Enumerate(R, N, [R, &OS](ArrayRef<Record *>, const Twine &ID) {
 187     auto Args = R->getValueAsListOfDefs("Args");
 188
 189     // Emit the list of arguments.
 190     OS << "bool ByteCodeEmitter::emit" << ID << "(";
 191     for (size_t I = 0, N = Args.size(); I < N; ++I)
 192       OS << Args[I]->getValueAsString("Name") << " A" << I << ", ";
 193     OS << "const SourceInfo &L) {\n";
 194
 195     // Emit a call to write the opcodes.
 196     OS << "  return emitOp<";
 197     for (size_t I = 0, N = Args.size(); I < N; ++I) {
 198       if (I != 0)
 199         OS << ", ";
 200       OS << Args[I]->getValueAsString("Name");
 201     }
 202     OS << ">(OP_" << ID;
 203     for (size_t I = 0, N = Args.size(); I < N; ++I)
 204       OS << ", A" << I;
 205     OS << ", L);\n";
 206     OS << "}\n";
 207   });
 208   OS << "#endif\n";
 209 }
 210
 211 void ClangOpcodesEmitter::EmitProto(raw_ostream &OS, StringRef N, Record *R) {
 212   OS << "#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)\n";
 213   auto Args = R->getValueAsListOfDefs("Args");
 214   Enumerate(R, N, [&OS, &Args](ArrayRef<Record *> TS, const Twine &ID) {
 215     OS << "bool emit" << ID << "(";
 216     for (auto *Arg : Args)
 217       OS << Arg->getValueAsString("Name") << ", ";
 218     OS << "const SourceInfo &);\n";
 219   });
 220
 221   // Emit a template method for custom emitters to have less to implement.
 222   auto TypeCount = R->getValueAsListInit("Types")->size();
 223   if (R->getValueAsBit("HasCustomEval") && TypeCount) {
 224     OS << "#if defined(GET_EVAL_PROTO)\n";
 225     OS << "template<";
 226     for (size_t I = 0; I < TypeCount; ++I) {
 227       if (I != 0)
 228         OS << ", ";
 229       OS << "PrimType";
 230     }
 231     OS << ">\n";
 232     OS << "bool emit" << N << "(";
 233     for (auto *Arg : Args)
 234       OS << Arg->getValueAsString("Name") << ", ";
 235     OS << "const SourceInfo &);\n";
 236     OS << "#endif\n";
 237   }
 238
 239   OS << "#endif\n";
 240 }
 241
 242 void ClangOpcodesEmitter::EmitGroup(raw_ostream &OS, StringRef N, Record *R) {
 243   if (!R->getValueAsBit("HasGroup"))
 244     return;
 245
 246   auto *Types = R->getValueAsListInit("Types");
 247   auto Args = R->getValueAsListOfDefs("Args");
 248
 249   // Emit the prototype of the group emitter in the header.
 250   OS << "#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)\n";
 251   OS << "bool emit" << N << "(";
 252   for (size_t I = 0, N = Types->size(); I < N; ++I)
 253     OS << "PrimType, ";
 254   for (auto *Arg : Args)
 255     OS << Arg->getValueAsString("Name") << ", ";
 256   OS << "const SourceInfo &I);\n";
 257   OS << "#endif\n";
 258
 259   // Emit the dispatch implementation in the source.
 260   OS << "#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)\n";
 261   OS << "bool\n";
 262   OS << "#if defined(GET_EVAL_IMPL)\n";
 263   OS << "EvalEmitter\n";
 264   OS << "#else\n";
 265   OS << "ByteCodeEmitter\n";
 266   OS << "#endif\n";
 267   OS << "::emit" << N << "(";
 268   for (size_t I = 0, N = Types->size(); I < N; ++I)
 269     OS << "PrimType T" << I << ", ";
 270   for (size_t I = 0, N = Args.size(); I < N; ++I)
 271     OS << Args[I]->getValueAsString("Name") << " A" << I << ", ";
 272   OS << "const SourceInfo &I) {\n";
 273
 274   std::function<void(size_t, const Twine &)> Rec;
 275   llvm::SmallVector<Record *, 2> TS;
 276   Rec = [this, &Rec, &OS, Types, &Args, R, &TS, N](size_t I, const Twine &ID) {
 277     if (I >= Types->size()) {
 278       // Print a call to the emitter method.
 279       // Custom evaluator methods dispatch to template methods.
 280       if (R->getValueAsBit("HasCustomEval")) {
 281         OS << "#ifdef GET_LINK_IMPL\n";
 282         OS << "    return emit" << ID << "\n";
 283         OS << "#else\n";
 284         OS << "    return emit" << N;
 285         PrintTypes(OS, TS);
 286         OS << "\n#endif\n";
 287         OS << "      ";
 288       } else {
 289         OS << "    return emit" << ID;
 290       }
 291
 292       OS << "(";
 293       for (size_t I = 0; I < Args.size(); ++I) {
 294         OS << "A" << I << ", ";
 295       }
 296       OS << "I);\n";
 297       return;
 298     }
 299
 300     // Print a switch statement selecting T.
 301     if (auto *TypeClass = dyn_cast<DefInit>(Types->getElement(I))) {
 302       OS << "  switch (T" << I << ") {\n";
 303       auto Cases = TypeClass->getDef()->getValueAsListOfDefs("Types");
 304       for (auto *Case : Cases) {
 305         OS << "  case PT_" << Case->getName() << ":\n";
 306         TS.push_back(Case);
 307         Rec(I + 1, ID + Case->getName());
 308         TS.pop_back();
 309       }
 310       // Emit a default case if not all types are present.
 311       if (Cases.size() < NumTypes)
 312         OS << "  default: llvm_unreachable(\"invalid type\");\n";
 313       OS << "  }\n";
 314       OS << "  llvm_unreachable(\"invalid enum value\");\n";
 315     } else {
 316       PrintFatalError("Expected a type class");
 317     }
 318   };
 319   Rec(0, N);
 320
 321   OS << "}\n";
 322   OS << "#endif\n";
 323 }
 324
 325 void ClangOpcodesEmitter::EmitEval(raw_ostream &OS, StringRef N, Record *R) {
 326   if (R->getValueAsBit("HasCustomEval"))
 327     return;
 328
 329   OS << "#ifdef GET_EVAL_IMPL\n";
 330   Enumerate(R, N, [this, R, &N, &OS](ArrayRef<Record *> TS, const Twine &ID) {
 331     auto Args = R->getValueAsListOfDefs("Args");
 332
 333     OS << "bool EvalEmitter::emit" << ID << "(";
 334     for (size_t I = 0, N = Args.size(); I < N; ++I)
 335       OS << Args[I]->getValueAsString("Name") << " A" << I << ", ";
 336     OS << "const SourceInfo &L) {\n";
 337     OS << "  if (!isActive()) return true;\n";
 338     OS << "  CurrentSource = L;\n";
 339
 340     OS << "  return " << N;
 341     PrintTypes(OS, TS);
 342     OS << "(S, OpPC";
 343     for (size_t I = 0, N = Args.size(); I < N; ++I)
 344       OS << ", A" << I;
 345     OS << ");\n";
 346     OS << "}\n";
 347   });
 348
 349   OS << "#endif\n";
 350 }
 351
 352 void ClangOpcodesEmitter::PrintTypes(raw_ostream &OS, ArrayRef<Record *> Types) {
 353   if (Types.empty())
 354     return;
 355   OS << "<";
 356   for (size_t I = 0, N = Types.size(); I < N; ++I) {
 357     if (I != 0)
 358       OS << ", ";
 359     OS << "PT_" << Types[I]->getName();
 360   }
 361   OS << ">";
 362 }
 363
 364 void clang::EmitClangOpcodes(RecordKeeper &Records, raw_ostream &OS) {
 365   ClangOpcodesEmitter(Records).run(OS);
 366 }