[WebAssembly] Fixed objdump not parsing function headers.

[aardappel]

Summary

objdump was interpreting the function header containing the locals
declaration as instructions. To parse these without injecting target
specific code in objdump, MCDisassembler::onSymbolStart was added to
be implemented by the WebAssembly implemention.

WasmObjectFile now returns a code offset for the "address" of a symbol,
rather than the index. This is also more in-line with what other
targets do.

Also ensured that the AsmParser correctly puts each function
in its own segment to enable this test case.

[aardappel]

rebased / new instruction names.

[sbc100]

Generally LGTM.

Previously objdump had listed "function index" for address of function symbols because in the wasm world the address of a function is its index. But I guess listing code section offset is fine too.

This change will require a corresponding lld-side change.

include/llvm/MC/MCDisassembler/MCDisassembler.h

91 ↗

(On Diff #181658)

actual bytes at the symbol location?

include/llvm/Object/Wasm.h

225 ↗

(On Diff #181658)

Do we still need to non-const version?

lib/MC/MCParser/WasmAsmParser.cpp

96 ↗

(On Diff #181658)

This seems unrelated? Separate change maybe?

lib/Object/WasmObjectFile.cpp

1016 ↗

(On Diff #181658)

Seems strange to have to duplicate the body here.

lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

302 ↗

(On Diff #181658)

Separate change?

lib/Target/WebAssembly/Disassembler/LLVMBuild.txt

22 ↗

(On Diff #181658)

What made this necessary?

lib/Target/WebAssembly/Disassembler/WebAssemblyDisassembler.cpp

133 ↗

(On Diff #181658)

But will any symbol ever point to this address?

181 ↗

(On Diff #181658)

Separate bug fix?

[aardappel]

LLD fix: https://reviews.llvm.org/D56687

include/llvm/Object/Wasm.h

225 ↗

(On Diff #181658)

Yup I checked, it is in use.

lib/MC/MCParser/WasmAsmParser.cpp

96 ↗

(On Diff #181658)

This change is required for the tests to work (see commit message)

lib/Object/WasmObjectFile.cpp

1016 ↗

(On Diff #181658)

Afaik having one call the other requires a const_cast which is a bit awkward?

lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

302 ↗

(On Diff #181658)

I personally feel small "drive by" fixes are ok. I could have also left this type out of the test but felt this was better.

lib/Target/WebAssembly/Disassembler/LLVMBuild.txt

22 ↗

(On Diff #181658)

The disassembler calls WebAssembly::anyTypeToString which I didn't want to duplicate. And the WebAssemblyAsmPrinter library is really small, just a single small .cpp

lib/Target/WebAssembly/Disassembler/WebAssemblyDisassembler.cpp

133 ↗

(On Diff #181658)

objdump automatically generates a symbol at address 0 if there isn't one. Rather than adding more wasm specifics into the main objdump code to prevent this, I made use of that fact to have it parse just the function count.

181 ↗

(On Diff #181658)

This isn't even a bug, it's just a refactoring (making an argument non-default).

[aardappel]

code review fixes

[dschuff]

Is this actually what we want?
If I'm debugging a crash in a browser, the browser shows stack traces by function index rather than file offset, in this format
${url}:wasm-function[${funcIndex}]:${pcOffset}
(see https://webassembly.github.io/spec/web-api/index.html#conventions)
So it might be better for objdump to match that format.

Is this change just for consistency (between targets) of printing, or is there another reason why it's better to have "addresses" be offsets rather than indices?

[dschuff]

Oh I had actually forgotten that the PC offset is the offset in the module, not the offset within the function. So for objdump either way would be ok, since you could easily find what function a particular instruction is in. I guess my point is not that the formats have to match, (since e.g. you probably wouldn't be using the same code to parse both browser output and tool output?) but if you are debugging and looking at a stack trace, you should easily be able to find the same location in an objdump-produced assembly dump.... Without a calculator (annoyance of mismatched hex/dec address formats was what originally led me to add that section to the spec :) )

[aardappel]

@dschuff This change only affects how internally symbol.getAddress works, which is needed for objdump disassembly to work at all, and what is reported for objdump symbol tables.. it should not affect what you see in a stack trace.

I can also not make this change, but then I'll need further wasm specifics in the general objdump and object code. For example I could introduce a new getOffset or whatever, that does the same as getAddress on most targets but has a different meaning in wasm. Then I could leave getAddress as is and objdump symbol table output would not change as it does now.

[dschuff]

Yeah, thinking about this a little more, I think it makes sense. IIRC the "address" (or value of a symbol, which I think is equivalent?) in the object file/linking/executable context refers to the section offset rather than memory-mapped address even for ELF, which would make our objdump consistent with other targets too. For the purposes of LLVM internals, I think you are right that having that consistency seems best; for the users, it's possible we'll want to put some more info in the final displayed output, but we can figure out how to get that once the guts are hooked up.

[aardappel]

Ok, sounds like we're good to land this then..

llvm/trunk/include/llvm/MC/MCDisassembler/MCDisassembler.h

 
 #include "llvm/MC/MCDisassembler/MCSymbolizer.h"
 #include <cstdint>
 #include <memory>
 
 namespace llvm {
 
 template <typename T> class ArrayRef;
+class StringRef;
 class MCContext;
 class MCInst;
 class MCSubtargetInfo;
 class raw_ostream;
 
 /// Superclass for all disassemblers. Consumes a memory region and provides an
 /// array of assembly instructions.
 class MCDisassembler {
public:
   ///                   MCDisassembler::SoftFail if the instruction was
   ///                                            disassemblable but invalid,
   ///                   MCDisassembler::Fail if the instruction was invalid.
   virtual DecodeStatus getInstruction(MCInst &Instr, uint64_t &Size,
                                       ArrayRef<uint8_t> Bytes, uint64_t Address,
                                       raw_ostream &VStream,
                                       raw_ostream &CStream) const = 0;
 
+  /// May parse any prelude that precedes instructions after the start of a
+  /// symbol. Needed for some targets, e.g. WebAssembly.
+  ///
+  /// \param Name     - The name of the symbol.
+  /// \param Size     - The number of bytes consumed.
+  /// \param Address  - The address, in the memory space of region, of the first
+  ///                   byte of the symbol.
+  /// \param Bytes    - A reference to the actual bytes at the symbol location.
+  /// \param VStream  - The stream to print warnings and diagnostic messages on.
+  /// \param CStream  - The stream to print comments and annotations on.
+  /// \return         - MCDisassembler::Success if the bytes are valid,
+  ///                   MCDisassembler::Fail if the bytes were invalid.
+  virtual DecodeStatus onSymbolStart(StringRef Name, uint64_t &Size,
+                                     ArrayRef<uint8_t> Bytes, uint64_t Address,
+                                     raw_ostream &VStream,
+                                     raw_ostream &CStream) const;
+
 private:
   MCContext &Ctx;
 
 protected:
   // Subtarget information, for instruction decoding predicates if required.
   const MCSubtargetInfo &STI;
   std::unique_ptr<MCSymbolizer> Symbolizer;
 

llvm/trunk/include/llvm/Object/Wasm.h

private:
   bool isValidEventIndex(uint32_t Index) const;
   bool isDefinedEventIndex(uint32_t Index) const;
   bool isValidFunctionSymbol(uint32_t Index) const;
   bool isValidGlobalSymbol(uint32_t Index) const;
   bool isValidEventSymbol(uint32_t Index) const;
   bool isValidDataSymbol(uint32_t Index) const;
   bool isValidSectionSymbol(uint32_t Index) const;
   wasm::WasmFunction &getDefinedFunction(uint32_t Index);
+  const wasm::WasmFunction &getDefinedFunction(uint32_t Index) const;
   wasm::WasmGlobal &getDefinedGlobal(uint32_t Index);
   wasm::WasmEvent &getDefinedEvent(uint32_t Index);
 
   const WasmSection &getWasmSection(DataRefImpl Ref) const;
   const wasm::WasmRelocation &getWasmRelocation(DataRefImpl Ref) const;
 
   const uint8_t *getPtr(size_t Offset) const;
   Error parseSection(WasmSection &Sec);

llvm/trunk/lib/MC/MCDisassembler/MCDisassembler.cpp

 //===- MCDisassembler.cpp - Disassembler interface ------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 
 using namespace llvm;
 
 MCDisassembler::~MCDisassembler() = default;
 
+MCDisassembler::DecodeStatus MCDisassembler::onSymbolStart(
+    StringRef Name, uint64_t &Size, ArrayRef<uint8_t> Bytes, uint64_t Address,
+    raw_ostream &VStream, raw_ostream &CStream) const {
+  Size = 0;
+  return MCDisassembler::Success;
+}
+
 bool MCDisassembler::tryAddingSymbolicOperand(MCInst &Inst, int64_t Value,
                                               uint64_t Address, bool IsBranch,
                                               uint64_t Offset,
                                               uint64_t InstSize) const {
   raw_ostream &cStream = CommentStream ? *CommentStream : nulls();
   if (Symbolizer)
     return Symbolizer->tryAddingSymbolicOperand(Inst, cStream, Value, Address,
                                                 IsBranch, Offset, InstSize);

llvm/trunk/lib/MC/MCParser/WasmAsmParser.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCParser/MCAsmLexer.h"
 #include "llvm/MC/MCParser/MCAsmParser.h"
 #include "llvm/MC/MCParser/MCAsmParserExtension.h"
+#include "llvm/MC/MCSectionWasm.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolWasm.h"
 #include "llvm/Support/MachineValueType.h"
 
 using namespace llvm;
 
 namespace {
public:
   }
 
   bool parseSectionDirectiveText(StringRef, SMLoc) {
     // FIXME: .text currently no-op.
     return false;
   }
 
   bool parseSectionDirective(StringRef, SMLoc) {
-    // FIXME: .section currently no-op.
-    while (Lexer->isNot(AsmToken::EndOfStatement)) Parser->Lex();
+    StringRef Name;
+    if (Parser->parseIdentifier(Name))
+      return TokError("expected identifier in directive");
+    // FIXME: currently requiring this very fixed format.
+    if (Expect(AsmToken::Comma, ",") || Expect(AsmToken::String, "string") ||
+        Expect(AsmToken::Comma, ",") || Expect(AsmToken::At, "@") ||
+        Expect(AsmToken::EndOfStatement, "eol"))
+      return true;
+    auto WS = getContext().getWasmSection(Name, SectionKind::getText());
+    getStreamer().SwitchSection(WS);
     return false;
   }
 
   // TODO: This function is almost the same as ELFAsmParser::ParseDirectiveSize
   // so maybe could be shared somehow.
   bool parseDirectiveSize(StringRef, SMLoc) {
     StringRef Name;
     if (Parser->parseIdentifier(Name))
       return TokError("expected identifier in directive");
     auto Sym = getContext().getOrCreateSymbol(Name);
-    if (Lexer->isNot(AsmToken::Comma))
-      return TokError("unexpected token in directive");
-    Lex();
+    if (Expect(AsmToken::Comma, ","))
+      return true;
     const MCExpr *Expr;
     if (Parser->parseExpression(Expr))
       return true;
-    if (Lexer->isNot(AsmToken::EndOfStatement))
-      return TokError("unexpected token in directive");
-    Lex();
+    if (Expect(AsmToken::EndOfStatement, "eol"))
+      return true;
     // MCWasmStreamer implements this.
     getStreamer().emitELFSize(Sym, Expr);
     return false;
   }
 
   bool parseDirectiveType(StringRef, SMLoc) {
     // This could be the start of a function, check if followed by
     // "label,@function"

llvm/trunk/lib/Object/WasmObjectFile.cpp

bool WasmObjectFile::isValidSectionSymbol(uint32_t Index) const {
   return Index < Symbols.size() && Symbols[Index].isTypeSection();
 }
 
 wasm::WasmFunction &WasmObjectFile::getDefinedFunction(uint32_t Index) {
   assert(isDefinedFunctionIndex(Index));
   return Functions[Index - NumImportedFunctions];
 }
 
+const wasm::WasmFunction &
+WasmObjectFile::getDefinedFunction(uint32_t Index) const {
+  assert(isDefinedFunctionIndex(Index));
+  return Functions[Index - NumImportedFunctions];
+}
+
 wasm::WasmGlobal &WasmObjectFile::getDefinedGlobal(uint32_t Index) {
   assert(isDefinedGlobalIndex(Index));
   return Globals[Index - NumImportedGlobals];
 }
 
 wasm::WasmEvent &WasmObjectFile::getDefinedEvent(uint32_t Index) {
   assert(isDefinedEventIndex(Index));
   return Events[Index - NumImportedEvents];
const WasmSymbol &WasmObjectFile::getWasmSymbol(const SymbolRef &Symb) const {
   return getWasmSymbol(Symb.getRawDataRefImpl());
 }
 
 Expected<StringRef> WasmObjectFile::getSymbolName(DataRefImpl Symb) const {
   return getWasmSymbol(Symb).Info.Name;
 }
 
 Expected<uint64_t> WasmObjectFile::getSymbolAddress(DataRefImpl Symb) const {
+  auto &Sym = getWasmSymbol(Symb);
+  if (Sym.Info.Kind == wasm::WASM_SYMBOL_TYPE_FUNCTION &&
+      isDefinedFunctionIndex(Sym.Info.ElementIndex))
+    return getDefinedFunction(Sym.Info.ElementIndex).CodeSectionOffset;
+  else
     return getSymbolValue(Symb);
 }
 
 uint64_t WasmObjectFile::getWasmSymbolValue(const WasmSymbol &Sym) const {
   switch (Sym.Info.Kind) {
   case wasm::WASM_SYMBOL_TYPE_FUNCTION:
   case wasm::WASM_SYMBOL_TYPE_GLOBAL:
   case wasm::WASM_SYMBOL_TYPE_EVENT:
     return Sym.Info.ElementIndex;

llvm/trunk/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

Optional<wasm::ValType> parseType(const StringRef &Type) {
     if (Type == "f32")
       return wasm::ValType::F32;
     if (Type == "f64")
       return wasm::ValType::F64;
     if (Type == "v128" || Type == "i8x16" || Type == "i16x8" ||
         Type == "i32x4" || Type == "i64x2" || Type == "f32x4" ||
         Type == "f64x2")
       return wasm::ValType::V128;
+    if (Type == "except_ref")
+      return wasm::ValType::EXCEPT_REF;
     return Optional<wasm::ValType>();
   }
 
   WebAssembly::ExprType parseBlockType(StringRef ID) {
     return StringSwitch<WebAssembly::ExprType>(ID)
         .Case("i32", WebAssembly::ExprType::I32)
         .Case("i64", WebAssembly::ExprType::I64)
         .Case("f32", WebAssembly::ExprType::F32)
         .Case("f64", WebAssembly::ExprType::F64)
         .Case("v128", WebAssembly::ExprType::V128)
         .Case("except_ref", WebAssembly::ExprType::ExceptRef)
         .Case("void", WebAssembly::ExprType::Void)
         .Default(WebAssembly::ExprType::Invalid);
   }
 
   bool parseRegTypeList(SmallVectorImpl<wasm::ValType> &Types) {
     while (Lexer.is(AsmToken::Identifier)) {
       auto Type = parseType(Lexer.getTok().getString());
       if (!Type)
-        return true;
+        return error("unknown type: ", Lexer.getTok());
       Types.push_back(Type.getValue());
       Parser.Lex();
       if (!isNext(AsmToken::Comma))
         break;
     }
     return false;
   }
 
bool ParseDirective(AsmToken DirectiveID) override {
     // - return true && no tokens consumed -> don't know this directive / let
     //   the generic parser handle it.
     // - return true && tokens consumed -> a parsing error occurred.
     // - return false -> processed this directive successfully.
     assert(DirectiveID.getKind() == AsmToken::Identifier);
     auto &Out = getStreamer();
     auto &TOut =
         reinterpret_cast<WebAssemblyTargetStreamer &>(*Out.getTargetStreamer());
+    auto &Ctx = Out.getContext();
 
     // TODO: any time we return an error, at least one token must have been
     // consumed, otherwise this will not signal an error to the caller.
     if (DirectiveID.getString() == ".globaltype") {
       auto SymName = expectIdent();
       if (SymName.empty())
         return true;
       if (expect(AsmToken::Comma, ","))
         return true;
       auto TypeTok = Lexer.getTok();
       auto TypeName = expectIdent();
       if (TypeName.empty())
         return true;
       auto Type = parseType(TypeName);
       if (!Type)
         return error("Unknown type in .globaltype directive: ", TypeTok);
       // Now set this symbol with the correct type.
-      auto WasmSym = cast<MCSymbolWasm>(
-          TOut.getStreamer().getContext().getOrCreateSymbol(SymName));
+      auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
       WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
       WasmSym->setGlobalType(
           wasm::WasmGlobalType{uint8_t(Type.getValue()), true});
       // And emit the directive again.
       TOut.emitGlobalType(WasmSym);
       return expect(AsmToken::EndOfStatement, "EOL");
     }
 
     if (DirectiveID.getString() == ".functype") {
       // This code has to send things to the streamer similar to
       // WebAssemblyAsmPrinter::EmitFunctionBodyStart.
       // TODO: would be good to factor this into a common function, but the
       // assembler and backend really don't share any common code, and this code
       // parses the locals seperately.
       auto SymName = expectIdent();
       if (SymName.empty())
         return true;
-      auto WasmSym = cast<MCSymbolWasm>(
-          TOut.getStreamer().getContext().getOrCreateSymbol(SymName));
+      auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
       if (CurrentState == Label && WasmSym == LastLabel) {
         // This .functype indicates a start of a function.
         if (ensureEmptyNestingStack())
           return true;
         CurrentState = FunctionStart;
         push(Function);
       }
       auto Signature = make_unique<wasm::WasmSignature>();
       if (parseSignature(Signature.get()))
         return true;
       WasmSym->setSignature(Signature.get());
       addSignature(std::move(Signature));
       WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
       TOut.emitFunctionType(WasmSym);
       // TODO: backend also calls TOut.emitIndIdx, but that is not implemented.
       return expect(AsmToken::EndOfStatement, "EOL");
     }
 
     if (DirectiveID.getString() == ".eventtype") {
       auto SymName = expectIdent();
       if (SymName.empty())
         return true;
-      auto WasmSym = cast<MCSymbolWasm>(
-          TOut.getStreamer().getContext().getOrCreateSymbol(SymName));
+      auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
       auto Signature = make_unique<wasm::WasmSignature>();
       if (parseRegTypeList(Signature->Params))
         return true;
       WasmSym->setSignature(Signature.get());
       addSignature(std::move(Signature));
       WasmSym->setType(wasm::WASM_SYMBOL_TYPE_EVENT);
       TOut.emitEventType(WasmSym);
       // TODO: backend also calls TOut.emitIndIdx, but that is not implemented.

llvm/trunk/lib/Target/WebAssembly/Disassembler/LLVMBuild.txt

 ;   http://llvm.org/docs/LLVMBuild.html
 ;
 ;===------------------------------------------------------------------------===;
 
 [component_0]
 type = Library
 name = WebAssemblyDisassembler
 parent = WebAssembly
-required_libraries = MCDisassembler WebAssemblyInfo Support
+required_libraries = MCDisassembler WebAssemblyInfo WebAssemblyAsmPrinter Support
 add_to_library_groups = WebAssembly

llvm/trunk/lib/Target/WebAssembly/Disassembler/WebAssemblyDisassembler.cpp

 /// \file
 /// This file is part of the WebAssembly Disassembler.
 ///
 /// It contains code to translate the data produced by the decoder into
 /// MCInsts.
 ///
 //===----------------------------------------------------------------------===//
 
+#include "InstPrinter/WebAssemblyInstPrinter.h"
 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/MC/MCFixedLenDisassembler.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCSymbol.h"

 
 class WebAssemblyDisassembler final : public MCDisassembler {
   std::unique_ptr<const MCInstrInfo> MCII;
 
   DecodeStatus getInstruction(MCInst &Instr, uint64_t &Size,
                               ArrayRef<uint8_t> Bytes, uint64_t Address,
                               raw_ostream &VStream,
                               raw_ostream &CStream) const override;
+  DecodeStatus onSymbolStart(StringRef Name, uint64_t &Size,
+                             ArrayRef<uint8_t> Bytes, uint64_t Address,
+                             raw_ostream &VStream,
+                             raw_ostream &CStream) const override;
 
 public:
   WebAssemblyDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx,
                           std::unique_ptr<const MCInstrInfo> MCII)
       : MCDisassembler(STI, Ctx), MCII(std::move(MCII)) {}
 };
 } // end anonymous namespace
 
static int nextByte(ArrayRef<uint8_t> Bytes, uint64_t &Size) {
   if (Size >= Bytes.size())
     return -1;
   auto V = Bytes[Size];
   Size++;
   return V;
 }
 
 static bool nextLEB(int64_t &Val, ArrayRef<uint8_t> Bytes, uint64_t &Size,
-                    bool Signed = false) {
+                    bool Signed) {
   unsigned N = 0;
   const char *Error = nullptr;
   Val = Signed ? decodeSLEB128(Bytes.data() + Size, &N,
                                Bytes.data() + Bytes.size(), &Error)
                : static_cast<int64_t>(decodeULEB128(Bytes.data() + Size, &N,
                                                     Bytes.data() + Bytes.size(),
                                                     &Error));
   if (Error)
bool parseImmediate(MCInst &MI, uint64_t &Size, ArrayRef<uint8_t> Bytes) {
   if (std::is_floating_point<T>::value) {
     MI.addOperand(MCOperand::createFPImm(static_cast<double>(Val)));
   } else {
     MI.addOperand(MCOperand::createImm(static_cast<int64_t>(Val)));
   }
   return true;
 }
 
+MCDisassembler::DecodeStatus WebAssemblyDisassembler::onSymbolStart(
+    StringRef Name, uint64_t &Size, ArrayRef<uint8_t> Bytes, uint64_t Address,
+    raw_ostream &VStream, raw_ostream &CStream) const {
+  Size = 0;
+  if (Address == 0) {
+    // Start of a code section: we're parsing only the function count.
+    int64_t FunctionCount;
+    if (!nextLEB(FunctionCount, Bytes, Size, false))
+      return MCDisassembler::Fail;
+    outs() << "        # " << FunctionCount << " functions in section.";
+  } else {
+    // Parse the start of a single function.
+    int64_t BodySize, LocalEntryCount;
+    if (!nextLEB(BodySize, Bytes, Size, false) ||
+        !nextLEB(LocalEntryCount, Bytes, Size, false))
+      return MCDisassembler::Fail;
+    if (LocalEntryCount) {
+      outs() << "        .local ";
+      for (int64_t I = 0; I < LocalEntryCount; I++) {
+        int64_t Count, Type;
+        if (!nextLEB(Count, Bytes, Size, false) ||
+            !nextLEB(Type, Bytes, Size, false))
+          return MCDisassembler::Fail;
+        for (int64_t J = 0; J < Count; J++) {
+          if (I || J)
+            outs() << ", ";
+          outs() << WebAssembly::anyTypeToString(Type);
+        }
+      }
+    }
+  }
+  outs() << "\n";
+  return MCDisassembler::Success;
+}
+
 MCDisassembler::DecodeStatus WebAssemblyDisassembler::getInstruction(
     MCInst &MI, uint64_t &Size, ArrayRef<uint8_t> Bytes, uint64_t /*Address*/,
     raw_ostream & /*OS*/, raw_ostream &CS) const {
   CommentStream = &CS;
   Size = 0;
   int Opc = nextByte(Bytes, Size);
   if (Opc < 0)
     return MCDisassembler::Fail;
   const auto *WasmInst = &InstructionTable0[Opc];
   // If this is a prefix byte, indirect to another table.
   if (WasmInst->ET == ET_Prefix) {
     WasmInst = nullptr;
     // Linear search, so far only 2 entries.
     for (auto PT = PrefixTable; PT->Table; PT++) {
       if (PT->Prefix == Opc) {
         WasmInst = PT->Table;
         break;
       }
     }
     if (!WasmInst)
       return MCDisassembler::Fail;
     int64_t PrefixedOpc;
-    if (!nextLEB(PrefixedOpc, Bytes, Size))
+    if (!nextLEB(PrefixedOpc, Bytes, Size, false))
       return MCDisassembler::Fail;
     if (PrefixedOpc < 0 || PrefixedOpc >= WebAssemblyInstructionTableSize)
       return MCDisassembler::Fail;
     WasmInst += PrefixedOpc;
   }
   if (WasmInst->ET == ET_Unused)
     return MCDisassembler::Fail;
   // At this point we must have a valid instruction to decode.

llvm/trunk/test/MC/WebAssembly/objdump.s

+# RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj -o %t.o -mattr=+simd128,+nontrapping-fptoint,+exception-handling < %s
+# RUN: llvm-objdump -triple=wasm32-unknown-unknown -disassemble %t.o | FileCheck %s
+
+    .section .text.main1,"",@
+    .type    test0,@function
+test0:
+    .functype   test0 (i32, i64) -> (i32)
+    .local      f32, f64, v128, v128
+    local.get   2
+    end_function
+.Lfunc_end0:
+    .size test0, .Lfunc_end0-test0
+
+    .section .text.main2,"",@
+    .type    test1,@function
+test1:
+    .functype   test1 (i32, i64) -> (i32)
+    .local      i32, i64, except_ref
+    local.get   3
+    end_function
+.Lfunc_end1:
+    .size test1, .Lfunc_end1-test1
+
+
+# CHECK-LABEL: CODE:
+# CHECK:             # 2 functions in section.
+# CHECK-LABEL: test0:
+# CHECK-NEXT:        .local  f32, f64, v128, v128
+# CHECK-NEXT:       9:       20 02  local.get 2
+# CHECK-NEXT:       b:       0b     end_block
+# CHECK-LABEL: test1:
+# CHECK-NEXT:        .local  i32, i64, except_ref
+# CHECK-NEXT:      14:       20 03  local.get 3
+# CHECK-NEXT:      16:       0b     end_block

llvm/trunk/test/MC/WebAssembly/weak-alias.ll

 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            .data.alias_address
 ; CHECK-NEXT:         Alignment:       3
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT: ...
 
 ; CHECK-SYMS: SYMBOL TABLE:
-; CHECK-SYMS-NEXT: 00000000 g     F CODE  .hidden foo
-; CHECK-SYMS-NEXT: 00000001 g     F CODE  .hidden call_direct
-; CHECK-SYMS-NEXT: 00000002 g     F CODE  .hidden call_alias
-; CHECK-SYMS-NEXT: 00000000 gw    F CODE  .hidden foo_alias
-; CHECK-SYMS-NEXT: 00000003 g     F CODE  .hidden call_direct_ptr
+; CHECK-SYMS-NEXT: 00000001 g     F CODE  .hidden foo
+; CHECK-SYMS-NEXT: 00000006 g     F CODE  .hidden call_direct
+; CHECK-SYMS-NEXT: 0000000f g     F CODE  .hidden call_alias
+; CHECK-SYMS-NEXT: 00000001 gw    F CODE  .hidden foo_alias
+; CHECK-SYMS-NEXT: 00000018 g     F CODE  .hidden call_direct_ptr
 ; CHECK-SYMS-NEXT: 00000008 g     O DATA  direct_address
-; CHECK-SYMS-NEXT: 00000004 g     F CODE  .hidden call_alias_ptr
+; CHECK-SYMS-NEXT: 0000002b g     F CODE  .hidden call_alias_ptr
 ; CHECK-SYMS-NEXT: 00000010 g     O DATA  alias_address
 ; CHECK-SYMS-NEXT: 00000000 g     O DATA  bar
 ; CHECK-SYMS-NEXT: 00000000 gw    O DATA  .hidden bar_alias

llvm/trunk/test/tools/llvm-objdump/WebAssembly/symbol-table.test

 RUN: llvm-objdump -t %p/../Inputs/trivial.obj.wasm | FileCheck %s
 
 CHECK:      SYMBOL TABLE:
-CHECK-NEXT: 00000002 g     F CODE main
+CHECK-NEXT: 00000001 g     F CODE main
 CHECK-NEXT: 00000000 l     O DATA .L.str
 CHECK-NEXT: 00000000 g     F *UND*  puts
-CHECK-NEXT: 00000003 l     F CODE .LSomeOtherFunction_bitcast
+CHECK-NEXT: 00000019 l     F CODE .LSomeOtherFunction_bitcast
 CHECK-NEXT: 00000000 g     F *UND*  SomeOtherFunction
 CHECK-NEXT: 00000010 g     O DATA var

llvm/trunk/tools/llvm-objdump/llvm-objdump.cpp

for (unsigned SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
       }
 
 #ifndef NDEBUG
       raw_ostream &DebugOut = DebugFlag ? dbgs() : nulls();
 #else
       raw_ostream &DebugOut = nulls();
 #endif
 
+      // Some targets (like WebAssembly) have a special prelude at the start
+      // of each symbol.
+      DisAsm->onSymbolStart(SymbolName, Size, Bytes.slice(Start, End - Start),
+                            SectionAddr + Start, DebugOut, CommentStream);
+      Start += Size;
+
       for (Index = Start; Index < End; Index += Size) {
         MCInst Inst;
 
         if (Index + SectionAddr < StartAddress ||
             Index + SectionAddr > StopAddress) {
           // skip byte by byte till StartAddress is reached
           Size = 1;
           continue;