1 //===- WebAssemblyDisassemblerEmitter.cpp - Disassembler tables -*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file is part of the WebAssembly Disassembler Emitter.
11 // It contains the implementation of the disassembler tables.
12 // Documentation for the disassembler emitter in general can be found in
13 // WebAssemblyDisassemblerEmitter.h.
14 //
15 //===----------------------------------------------------------------------===//
16
17 #include "WebAssemblyDisassemblerEmitter.h"
18 #include "llvm/TableGen/Record.h"
19
20 namespace llvm {
21
22 static constexpr int WebAssemblyInstructionTableSize = 256;
23
emitWebAssemblyDisassemblerTables(raw_ostream & OS,const ArrayRef<const CodeGenInstruction * > & NumberedInstructions)24 void emitWebAssemblyDisassemblerTables(
25 raw_ostream &OS,
26 const ArrayRef<const CodeGenInstruction *> &NumberedInstructions) {
27 // First lets organize all opcodes by (prefix) byte. Prefix 0 is the
28 // starting table.
29 std::map<unsigned,
30 std::map<unsigned, std::pair<unsigned, const CodeGenInstruction *>>>
31 OpcodeTable;
32 for (unsigned I = 0; I != NumberedInstructions.size(); ++I) {
33 auto &CGI = *NumberedInstructions[I];
34 auto &Def = *CGI.TheDef;
35 if (!Def.getValue("Inst"))
36 continue;
37 auto &Inst = *Def.getValueAsBitsInit("Inst");
38 auto Opc = static_cast<unsigned>(
39 reinterpret_cast<IntInit *>(Inst.convertInitializerTo(IntRecTy::get()))
40 ->getValue());
41 if (Opc == 0xFFFFFFFF)
42 continue; // No opcode defined.
43 assert(Opc <= 0xFFFF);
44 auto Prefix = Opc >> 8;
45 Opc = Opc & 0xFF;
46 auto &CGIP = OpcodeTable[Prefix][Opc];
47 // All wasm instructions have a StackBased field of type string, we only
48 // want the instructions for which this is "true".
49 auto StackString =
50 Def.getValue("StackBased")->getValue()->getCastTo(StringRecTy::get());
51 auto IsStackBased =
52 StackString &&
53 reinterpret_cast<const StringInit *>(StackString)->getValue() == "true";
54 if (IsStackBased && !CGIP.second) {
55 // this picks the first of many typed variants, which is
56 // currently the except_ref one, though this shouldn't matter for
57 // disassembly purposes.
58 CGIP = std::make_pair(I, &CGI);
59 }
60 }
61 OS << "#include \"MCTargetDesc/WebAssemblyMCTargetDesc.h\"\n";
62 OS << "\n";
63 OS << "namespace llvm {\n\n";
64 OS << "static constexpr int WebAssemblyInstructionTableSize = ";
65 OS << WebAssemblyInstructionTableSize << ";\n\n";
66 OS << "enum EntryType : uint8_t { ";
67 OS << "ET_Unused, ET_Prefix, ET_Instruction };\n\n";
68 OS << "struct WebAssemblyInstruction {\n";
69 OS << " uint16_t Opcode;\n";
70 OS << " EntryType ET;\n";
71 OS << " uint8_t NumOperands;\n";
72 OS << " uint16_t OperandStart;\n";
73 OS << "};\n\n";
74 std::vector<std::string> OperandTable, CurOperandList;
75 // Output one table per prefix.
76 for (auto &PrefixPair : OpcodeTable) {
77 if (PrefixPair.second.empty())
78 continue;
79 OS << "WebAssemblyInstruction InstructionTable" << PrefixPair.first;
80 OS << "[] = {\n";
81 for (unsigned I = 0; I < WebAssemblyInstructionTableSize; I++) {
82 auto InstIt = PrefixPair.second.find(I);
83 if (InstIt != PrefixPair.second.end()) {
84 // Regular instruction.
85 assert(InstIt->second.second);
86 auto &CGI = *InstIt->second.second;
87 OS << " // 0x";
88 OS.write_hex(static_cast<unsigned long long>(I));
89 OS << ": " << CGI.AsmString << "\n";
90 OS << " { " << InstIt->second.first << ", ET_Instruction, ";
91 OS << CGI.Operands.OperandList.size() << ", ";
92 // Collect operand types for storage in a shared list.
93 CurOperandList.clear();
94 for (auto &Op : CGI.Operands.OperandList) {
95 assert(Op.OperandType != "MCOI::OPERAND_UNKNOWN");
96 CurOperandList.push_back(Op.OperandType);
97 }
98 // See if we already have stored this sequence before. This is not
99 // strictly necessary but makes the table really small.
100 size_t OperandStart = OperandTable.size();
101 if (CurOperandList.size() <= OperandTable.size()) {
102 for (size_t J = 0; J <= OperandTable.size() - CurOperandList.size();
103 ++J) {
104 size_t K = 0;
105 for (; K < CurOperandList.size(); ++K) {
106 if (OperandTable[J + K] != CurOperandList[K]) break;
107 }
108 if (K == CurOperandList.size()) {
109 OperandStart = J;
110 break;
111 }
112 }
113 }
114 // Store operands if no prior occurrence.
115 if (OperandStart == OperandTable.size()) {
116 OperandTable.insert(OperandTable.end(), CurOperandList.begin(),
117 CurOperandList.end());
118 }
119 OS << OperandStart;
120 } else {
121 auto PrefixIt = OpcodeTable.find(I);
122 // If we have a non-empty table for it that's not 0, this is a prefix.
123 if (PrefixIt != OpcodeTable.end() && I && !PrefixPair.first) {
124 OS << " { 0, ET_Prefix, 0, 0";
125 } else {
126 OS << " { 0, ET_Unused, 0, 0";
127 }
128 }
129 OS << " },\n";
130 }
131 OS << "};\n\n";
132 }
133 // Create a table of all operands:
134 OS << "const uint8_t OperandTable[] = {\n";
135 for (auto &Op : OperandTable) {
136 OS << " " << Op << ",\n";
137 }
138 OS << "};\n\n";
139 // Create a table of all extension tables:
140 OS << "struct { uint8_t Prefix; const WebAssemblyInstruction *Table; }\n";
141 OS << "PrefixTable[] = {\n";
142 for (auto &PrefixPair : OpcodeTable) {
143 if (PrefixPair.second.empty() || !PrefixPair.first)
144 continue;
145 OS << " { " << PrefixPair.first << ", InstructionTable"
146 << PrefixPair.first;
147 OS << " },\n";
148 }
149 OS << " { 0, nullptr }\n};\n\n";
150 OS << "} // End llvm namespace\n";
151 }
152
153 } // namespace llvm
154