2018-05-11 06:16:44 +08:00
|
|
|
//===- WebAssemblyDisassemblerEmitter.cpp - Disassembler tables -*- C++ -*-===//
|
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2018-05-11 06:16:44 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file is part of the WebAssembly Disassembler Emitter.
|
|
|
|
// It contains the implementation of the disassembler tables.
|
|
|
|
// Documentation for the disassembler emitter in general can be found in
|
|
|
|
// WebAssemblyDisassemblerEmitter.h.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "WebAssemblyDisassemblerEmitter.h"
|
|
|
|
#include "llvm/TableGen/Record.h"
|
|
|
|
|
|
|
|
namespace llvm {
|
|
|
|
|
2018-11-09 09:57:00 +08:00
|
|
|
static constexpr int WebAssemblyInstructionTableSize = 256;
|
|
|
|
|
2018-05-11 06:16:44 +08:00
|
|
|
void emitWebAssemblyDisassemblerTables(
|
|
|
|
raw_ostream &OS,
|
|
|
|
const ArrayRef<const CodeGenInstruction *> &NumberedInstructions) {
|
|
|
|
// First lets organize all opcodes by (prefix) byte. Prefix 0 is the
|
|
|
|
// starting table.
|
|
|
|
std::map<unsigned,
|
|
|
|
std::map<unsigned, std::pair<unsigned, const CodeGenInstruction *>>>
|
|
|
|
OpcodeTable;
|
|
|
|
for (unsigned I = 0; I != NumberedInstructions.size(); ++I) {
|
|
|
|
auto &CGI = *NumberedInstructions[I];
|
|
|
|
auto &Def = *CGI.TheDef;
|
|
|
|
if (!Def.getValue("Inst"))
|
|
|
|
continue;
|
|
|
|
auto &Inst = *Def.getValueAsBitsInit("Inst");
|
|
|
|
auto Opc = static_cast<unsigned>(
|
|
|
|
reinterpret_cast<IntInit *>(Inst.convertInitializerTo(IntRecTy::get()))
|
|
|
|
->getValue());
|
|
|
|
if (Opc == 0xFFFFFFFF)
|
|
|
|
continue; // No opcode defined.
|
|
|
|
assert(Opc <= 0xFFFF);
|
|
|
|
auto Prefix = Opc >> 8;
|
|
|
|
Opc = Opc & 0xFF;
|
|
|
|
auto &CGIP = OpcodeTable[Prefix][Opc];
|
2018-10-23 05:55:26 +08:00
|
|
|
// All wasm instructions have a StackBased field of type string, we only
|
|
|
|
// want the instructions for which this is "true".
|
|
|
|
auto StackString =
|
|
|
|
Def.getValue("StackBased")->getValue()->getCastTo(StringRecTy::get());
|
|
|
|
auto IsStackBased =
|
|
|
|
StackString &&
|
|
|
|
reinterpret_cast<const StringInit *>(StackString)->getValue() == "true";
|
[WebAssembly] Make disassembler always emit most canonical name.
Summary:
There are a few instructions that all map to the same opcode, so
when disassembling, we have to pick one. That was just the first one
before (the except_ref variant in the case of "call"), now it is the
one marked as IsCanonical in tablegen, or failing that, the shortest
name (which is typically the "canonical" one).
Also introduced a canonical "end" instruction for this purpose.
Reviewers: dschuff, tlively
Subscribers: sbc100, jgravelle-google, aheejin, llvm-commits, sunfish
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D57713
llvm-svn: 353131
2019-02-05 09:19:45 +08:00
|
|
|
if (!IsStackBased)
|
|
|
|
continue;
|
|
|
|
if (CGIP.second) {
|
|
|
|
// We already have an instruction for this slot, so decide which one
|
|
|
|
// should be the canonical one. This determines which variant gets
|
|
|
|
// printed in a disassembly. We want e.g. "call" not "i32.call", and
|
|
|
|
// "end" when we don't know if its "end_loop" or "end_block" etc.
|
|
|
|
auto IsCanonicalExisting = CGIP.second->TheDef->getValue("IsCanonical")
|
|
|
|
->getValue()
|
|
|
|
->getAsString() == "1";
|
|
|
|
// We already have one marked explicitly as canonical, so keep it.
|
|
|
|
if (IsCanonicalExisting)
|
|
|
|
continue;
|
|
|
|
auto IsCanonicalNew =
|
|
|
|
Def.getValue("IsCanonical")->getValue()->getAsString() == "1";
|
|
|
|
// If the new one is explicitly marked as canonical, take it.
|
|
|
|
if (!IsCanonicalNew) {
|
|
|
|
// Neither the existing or new instruction is canonical.
|
2019-02-05 23:00:56 +08:00
|
|
|
// Pick the one with the shortest name as heuristic.
|
[WebAssembly] Make disassembler always emit most canonical name.
Summary:
There are a few instructions that all map to the same opcode, so
when disassembling, we have to pick one. That was just the first one
before (the except_ref variant in the case of "call"), now it is the
one marked as IsCanonical in tablegen, or failing that, the shortest
name (which is typically the "canonical" one).
Also introduced a canonical "end" instruction for this purpose.
Reviewers: dschuff, tlively
Subscribers: sbc100, jgravelle-google, aheejin, llvm-commits, sunfish
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D57713
llvm-svn: 353131
2019-02-05 09:19:45 +08:00
|
|
|
// Though ideally IsCanonical is always defined for at least one
|
|
|
|
// variant so this never has to apply.
|
|
|
|
if (CGIP.second->AsmString.size() <= CGI.AsmString.size())
|
|
|
|
continue;
|
|
|
|
}
|
2018-05-11 06:16:44 +08:00
|
|
|
}
|
[WebAssembly] Make disassembler always emit most canonical name.
Summary:
There are a few instructions that all map to the same opcode, so
when disassembling, we have to pick one. That was just the first one
before (the except_ref variant in the case of "call"), now it is the
one marked as IsCanonical in tablegen, or failing that, the shortest
name (which is typically the "canonical" one).
Also introduced a canonical "end" instruction for this purpose.
Reviewers: dschuff, tlively
Subscribers: sbc100, jgravelle-google, aheejin, llvm-commits, sunfish
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D57713
llvm-svn: 353131
2019-02-05 09:19:45 +08:00
|
|
|
// Set this instruction as the one to use.
|
|
|
|
CGIP = std::make_pair(I, &CGI);
|
2018-05-11 06:16:44 +08:00
|
|
|
}
|
|
|
|
OS << "#include \"MCTargetDesc/WebAssemblyMCTargetDesc.h\"\n";
|
|
|
|
OS << "\n";
|
|
|
|
OS << "namespace llvm {\n\n";
|
2018-11-09 09:57:00 +08:00
|
|
|
OS << "static constexpr int WebAssemblyInstructionTableSize = ";
|
|
|
|
OS << WebAssemblyInstructionTableSize << ";\n\n";
|
2018-05-11 06:16:44 +08:00
|
|
|
OS << "enum EntryType : uint8_t { ";
|
|
|
|
OS << "ET_Unused, ET_Prefix, ET_Instruction };\n\n";
|
|
|
|
OS << "struct WebAssemblyInstruction {\n";
|
|
|
|
OS << " uint16_t Opcode;\n";
|
|
|
|
OS << " EntryType ET;\n";
|
|
|
|
OS << " uint8_t NumOperands;\n";
|
2018-08-30 23:40:53 +08:00
|
|
|
OS << " uint16_t OperandStart;\n";
|
2018-05-11 06:16:44 +08:00
|
|
|
OS << "};\n\n";
|
2018-08-30 23:40:53 +08:00
|
|
|
std::vector<std::string> OperandTable, CurOperandList;
|
2018-05-11 06:16:44 +08:00
|
|
|
// Output one table per prefix.
|
|
|
|
for (auto &PrefixPair : OpcodeTable) {
|
|
|
|
if (PrefixPair.second.empty())
|
|
|
|
continue;
|
|
|
|
OS << "WebAssemblyInstruction InstructionTable" << PrefixPair.first;
|
|
|
|
OS << "[] = {\n";
|
2018-11-09 09:57:00 +08:00
|
|
|
for (unsigned I = 0; I < WebAssemblyInstructionTableSize; I++) {
|
2018-05-11 06:16:44 +08:00
|
|
|
auto InstIt = PrefixPair.second.find(I);
|
|
|
|
if (InstIt != PrefixPair.second.end()) {
|
|
|
|
// Regular instruction.
|
|
|
|
assert(InstIt->second.second);
|
|
|
|
auto &CGI = *InstIt->second.second;
|
|
|
|
OS << " // 0x";
|
|
|
|
OS.write_hex(static_cast<unsigned long long>(I));
|
|
|
|
OS << ": " << CGI.AsmString << "\n";
|
|
|
|
OS << " { " << InstIt->second.first << ", ET_Instruction, ";
|
2018-08-30 23:40:53 +08:00
|
|
|
OS << CGI.Operands.OperandList.size() << ", ";
|
|
|
|
// Collect operand types for storage in a shared list.
|
|
|
|
CurOperandList.clear();
|
2018-05-11 06:16:44 +08:00
|
|
|
for (auto &Op : CGI.Operands.OperandList) {
|
2019-01-04 07:01:30 +08:00
|
|
|
assert(Op.OperandType != "MCOI::OPERAND_UNKNOWN");
|
2018-08-30 23:40:53 +08:00
|
|
|
CurOperandList.push_back(Op.OperandType);
|
2018-05-11 06:16:44 +08:00
|
|
|
}
|
2018-08-30 23:40:53 +08:00
|
|
|
// See if we already have stored this sequence before. This is not
|
|
|
|
// strictly necessary but makes the table really small.
|
|
|
|
size_t OperandStart = OperandTable.size();
|
|
|
|
if (CurOperandList.size() <= OperandTable.size()) {
|
|
|
|
for (size_t J = 0; J <= OperandTable.size() - CurOperandList.size();
|
|
|
|
++J) {
|
|
|
|
size_t K = 0;
|
|
|
|
for (; K < CurOperandList.size(); ++K) {
|
|
|
|
if (OperandTable[J + K] != CurOperandList[K]) break;
|
|
|
|
}
|
|
|
|
if (K == CurOperandList.size()) {
|
|
|
|
OperandStart = J;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Store operands if no prior occurrence.
|
|
|
|
if (OperandStart == OperandTable.size()) {
|
|
|
|
OperandTable.insert(OperandTable.end(), CurOperandList.begin(),
|
|
|
|
CurOperandList.end());
|
|
|
|
}
|
|
|
|
OS << OperandStart;
|
2018-05-11 06:16:44 +08:00
|
|
|
} else {
|
|
|
|
auto PrefixIt = OpcodeTable.find(I);
|
|
|
|
// If we have a non-empty table for it that's not 0, this is a prefix.
|
|
|
|
if (PrefixIt != OpcodeTable.end() && I && !PrefixPair.first) {
|
2018-08-30 23:40:53 +08:00
|
|
|
OS << " { 0, ET_Prefix, 0, 0";
|
2018-05-11 06:16:44 +08:00
|
|
|
} else {
|
2018-08-30 23:40:53 +08:00
|
|
|
OS << " { 0, ET_Unused, 0, 0";
|
2018-05-11 06:16:44 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
OS << " },\n";
|
|
|
|
}
|
|
|
|
OS << "};\n\n";
|
|
|
|
}
|
2018-08-30 23:40:53 +08:00
|
|
|
// Create a table of all operands:
|
|
|
|
OS << "const uint8_t OperandTable[] = {\n";
|
|
|
|
for (auto &Op : OperandTable) {
|
|
|
|
OS << " " << Op << ",\n";
|
|
|
|
}
|
|
|
|
OS << "};\n\n";
|
2018-05-11 06:16:44 +08:00
|
|
|
// Create a table of all extension tables:
|
|
|
|
OS << "struct { uint8_t Prefix; const WebAssemblyInstruction *Table; }\n";
|
|
|
|
OS << "PrefixTable[] = {\n";
|
|
|
|
for (auto &PrefixPair : OpcodeTable) {
|
|
|
|
if (PrefixPair.second.empty() || !PrefixPair.first)
|
|
|
|
continue;
|
|
|
|
OS << " { " << PrefixPair.first << ", InstructionTable"
|
|
|
|
<< PrefixPair.first;
|
|
|
|
OS << " },\n";
|
|
|
|
}
|
|
|
|
OS << " { 0, nullptr }\n};\n\n";
|
2019-08-25 18:47:30 +08:00
|
|
|
OS << "} // end namespace llvm\n";
|
2018-05-11 06:16:44 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace llvm
|