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 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