From 1a91cb0402270a3ce77a9397abda655384d89a43 Mon Sep 17 00:00:00 2001 From: Wouter van Oortmerssen Date: Tue, 5 Feb 2019 01:19:45 +0000 Subject: [PATCH] [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 --- .../lib/Target/WebAssembly/WebAssemblyInstrCall.td | 16 ++++++----- .../Target/WebAssembly/WebAssemblyInstrControl.td | 4 +++ .../Target/WebAssembly/WebAssemblyInstrFormats.td | 3 +++ .../lib/Target/WebAssembly/WebAssemblyInstrSIMD.td | 10 ++++--- llvm/test/MC/Disassembler/WebAssembly/wasm.txt | 11 ++++++-- llvm/test/MC/WebAssembly/objdump.s | 4 +-- .../TableGen/WebAssemblyDisassemblerEmitter.cpp | 31 ++++++++++++++++++---- 7 files changed, 59 insertions(+), 20 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrCall.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrCall.td index a4efa85..6b7c9b2 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrCall.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrCall.td @@ -93,17 +93,18 @@ let Uses = [SP32, SP64], isCall = 1 in { defm "" : SIMD_CALL; defm "" : SIMD_CALL; + let IsCanonical = 1 in { defm CALL_VOID : I<(outs), (ins function32_op:$callee, variable_ops), - (outs), (ins function32_op:$callee), - [(WebAssemblycall0 (i32 imm:$callee))], - "call \t$callee", "call\t$callee", 0x10>; + (outs), (ins function32_op:$callee), + [(WebAssemblycall0 (i32 imm:$callee))], + "call \t$callee", "call\t$callee", 0x10>; let isCodeGenOnly = 1 in { defm PCALL_INDIRECT_VOID : I<(outs), (ins I32:$callee, variable_ops), - (outs), (ins I32:$callee), - [(WebAssemblycall0 I32:$callee)], - "PSEUDO CALL INDIRECT\t$callee", - "PSEUDO CALL INDIRECT\t$callee">; + (outs), (ins I32:$callee), + [(WebAssemblycall0 I32:$callee)], + "PSEUDO CALL INDIRECT\t$callee", + "PSEUDO CALL INDIRECT\t$callee">; } // isCodeGenOnly = 1 defm CALL_INDIRECT_VOID : I<(outs), @@ -113,6 +114,7 @@ let Uses = [SP32, SP64], isCall = 1 in { [], "call_indirect\t", "call_indirect\t$type", 0x11>; + } } // Uses = [SP32,SP64], isCall = 1 // Patterns for matching a direct call to a global address. diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrControl.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrControl.td index 8160cab..59faeb8 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrControl.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrControl.td @@ -81,6 +81,10 @@ defm ELSE : NRI<(outs), (ins), [], "else", 0x05>; defm END_BLOCK : NRI<(outs), (ins), [], "end_block", 0x0b>; defm END_LOOP : NRI<(outs), (ins), [], "end_loop", 0x0b>; defm END_IF : NRI<(outs), (ins), [], "end_if", 0x0b>; +// Generic instruction, for disassembler. +let IsCanonical = 1 in { +defm END : NRI<(outs), (ins), [], "end", 0x0b>; +} let isTerminator = 1, isBarrier = 1 in defm END_FUNCTION : NRI<(outs), (ins), [], "end_function", 0x0b>; } // Uses = [VALUE_STACK], Defs = [VALUE_STACK] diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrFormats.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrFormats.td index 2a2c79c..aff4d20 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrFormats.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrFormats.td @@ -22,6 +22,9 @@ class WebAssemblyInst inst, string asmstr, string stack> : StackRel, let Namespace = "WebAssembly"; let Pattern = []; let AsmString = asmstr; + // When there are multiple instructions that map to the same encoding (in + // e.g. the disassembler use case) prefer the one where IsCanonical == 1. + bit IsCanonical = 0; } // Normal instructions. Default instantiation of a WebAssemblyInst. diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrSIMD.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrSIMD.td index ab0f48c..71c469d 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrSIMD.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrSIMD.td @@ -125,12 +125,14 @@ defm "" : ConstVec; +let IsCanonical = 1 in { defm "" : ConstVec; + (build_vector (i32 imm:$i0), (i32 imm:$i1), + (i32 imm:$i2), (i32 imm:$i3)), + "$i0, $i1, $i2, $i3">; +} defm "" : ConstVec(StackString)->getValue() == "true"; - if (IsStackBased && !CGIP.second) { - // this picks the first of many typed variants, which is - // currently the except_ref one, though this shouldn't matter for - // disassembly purposes. - CGIP = std::make_pair(I, &CGI); + 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. + // Pick the one with with the shortest name as heuristic. + // 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; + } } + // Set this instruction as the one to use. + CGIP = std::make_pair(I, &CGI); } OS << "#include \"MCTargetDesc/WebAssemblyMCTargetDesc.h\"\n"; OS << "\n"; -- 2.7.4