[WebAssembly] Use uint8_t for single byte values to match the spec

[sbc100]

Summary

The original BinaryEncoding.md document used to specify that
these values were varint7, but the official spec lists them
explicitly as single byte values and not LEB.

A similar change for wabt is in flight:
https://github.com/WebAssembly/wabt/pull/782

And also lld:
https://reviews.llvm.org/D43922

[dschuff]

I'm fine with doing this change since it does reflect the spec. Although IIRC the relevant types don't yet have any values over 128 and we've kept it that way so we can always upgrade to varint when we need to. So in principle we could keep the code using varint and then it won't have to change in the future.

[sbc100]

In D43921#1023974, @dschuff wrote:

I'm fine with doing this change since it does reflect the spec. Although IIRC the relevant types don't yet have any values over 128 and we've kept it that way so we can always upgrade to varint when we need to. So in principle we could keep the code using varint and then it won't have to change in the future.

I'd rather match the spec than try to guess what the future brings and jump ahead of the spec.

[sbc100]

Looks like this broke the gcc builders.. working on a fix now.

include/llvm/BinaryFormat/Wasm.h

 const uint32_t WasmPageSize = 65536;
 
 struct WasmObjectHeader {
   StringRef Magic;
   uint32_t Version;
 };
 
 struct WasmSignature {
-  std::vector<int32_t> ParamTypes;
-  int32_t ReturnType;
+  std::vector<uint8_t> ParamTypes;
+  uint8_t ReturnType;
 };
 
 struct WasmExport {
   StringRef Name;
-  uint32_t Kind;
+  uint8_t Kind;
   uint32_t Index;
 };
 
 struct WasmLimits {
-  uint32_t Flags;
+  uint8_t Flags;
   uint32_t Initial;
   uint32_t Maximum;
 };
 
 struct WasmTable {
-  int32_t ElemType;
+  uint8_t ElemType;
   WasmLimits Limits;
 };
 
 struct WasmInitExpr {
   uint8_t Opcode;
   union {
     int32_t Int32;
     int64_t Int64;
     int32_t Float32;
     int64_t Float64;
     uint32_t Global;
   } Value;
 };
 
 struct WasmGlobalType {
-  int32_t Type;
+  uint8_t Type;
   bool Mutable;
 };
 
 struct WasmGlobal {
   uint32_t Index;
   WasmGlobalType Type;
   WasmInitExpr InitExpr;
 };
 
 struct WasmImport {
   StringRef Module;
   StringRef Field;
-  uint32_t Kind;
+  uint8_t Kind;
   union {
     uint32_t SigIndex;
     WasmGlobalType Global;
     WasmTable Table;
     WasmLimits Memory;
   };
 };
 
 struct WasmLocalDecl {
-  int32_t Type;
+  uint8_t Type;
   uint32_t Count;
 };
 
 struct WasmFunction {
   uint32_t Index;
   std::vector<WasmLocalDecl> Locals;
   ArrayRef<uint8_t> Body;
   uint32_t CodeSectionOffset;

 // the index of the segment, and the offset and size within the segment.
 struct WasmDataReference {
   uint32_t Segment;
   uint32_t Offset;
   uint32_t Size;
 };
 
 struct WasmRelocation {
-  uint32_t Type;   // The type of the relocation.
+  uint8_t Type;    // The type of the relocation.
   uint32_t Index;  // Index into either symbol or type index space.
   uint64_t Offset; // Offset from the start of the section.
   int64_t Addend;  // A value to add to the symbol.
 };
 
 struct WasmInitFunc {
   uint32_t Priority;
   uint32_t Symbol;
 };
 
 struct WasmSymbolInfo {
   StringRef Name;
-  uint32_t Kind;
+  uint8_t Kind;
   uint32_t Flags;
   union {
     // For function or global symbols, the index in function of global index
     // space.
     uint32_t ElementIndex;
     // For a data symbols, the address of the data relative to segment.
     WasmDataReference DataRef;
   };
enum : unsigned {
   WASM_SEC_EXPORT = 7,   // Exports
   WASM_SEC_START = 8,    // Start function declaration
   WASM_SEC_ELEM = 9,     // Elements section
   WASM_SEC_CODE = 10,    // Function bodies (code)
   WASM_SEC_DATA = 11     // Data segments
 };
 
 // Type immediate encodings used in various contexts.
-enum {
-  WASM_TYPE_I32 = -0x01,
-  WASM_TYPE_I64 = -0x02,
-  WASM_TYPE_F32 = -0x03,
-  WASM_TYPE_F64 = -0x04,
-  WASM_TYPE_ANYFUNC = -0x10,
-  WASM_TYPE_FUNC = -0x20,
-  WASM_TYPE_NORESULT = -0x40, // for blocks with no result values
+enum : uint8_t {
+  WASM_TYPE_I32 = 0x7F,
+  WASM_TYPE_I64 = 0x7E,
+  WASM_TYPE_F32 = 0x7D,
+  WASM_TYPE_F64 = 0x7C,
+  WASM_TYPE_ANYFUNC = 0x70,
+  WASM_TYPE_FUNC = 0x60,
+  WASM_TYPE_NORESULT = 0x40, // for blocks with no result values
 };
 
 // Kinds of externals (for imports and exports).
-enum : unsigned {
+enum : uint8_t {
   WASM_EXTERNAL_FUNCTION = 0x0,
   WASM_EXTERNAL_TABLE = 0x1,
   WASM_EXTERNAL_MEMORY = 0x2,
   WASM_EXTERNAL_GLOBAL = 0x3,
 };
 
 // Opcodes used in initializer expressions.
 enum : unsigned {

 
 // Kind codes used in the custom "linking" section in the WASM_COMDAT_INFO
 enum : unsigned {
   WASM_COMDAT_DATA        = 0x0,
   WASM_COMDAT_FUNCTION    = 0x1,
 };
 
 // Kind codes used in the custom "linking" section in the WASM_SYMBOL_TABLE
-enum WasmSymbolType : unsigned {
+enum WasmSymbolType : uint8_t {
   WASM_SYMBOL_TYPE_FUNCTION = 0x0,
   WASM_SYMBOL_TYPE_DATA     = 0x1,
   WASM_SYMBOL_TYPE_GLOBAL   = 0x2,
 };
 
 const unsigned WASM_SYMBOL_BINDING_MASK       = 0x3;
 const unsigned WASM_SYMBOL_VISIBILITY_MASK    = 0xc;
 
 const unsigned WASM_SYMBOL_BINDING_GLOBAL     = 0x0;
 const unsigned WASM_SYMBOL_BINDING_WEAK       = 0x1;
 const unsigned WASM_SYMBOL_BINDING_LOCAL      = 0x2;
 const unsigned WASM_SYMBOL_VISIBILITY_DEFAULT = 0x0;
 const unsigned WASM_SYMBOL_VISIBILITY_HIDDEN  = 0x4;
 const unsigned WASM_SYMBOL_UNDEFINED          = 0x10;
 
 #define WASM_RELOC(name, value) name = value,
 
-enum : unsigned {
+enum : uint8_t {
 #include "WasmRelocs.def"
 };
 
 #undef WASM_RELOC
 
 } // end namespace wasm
 } // end namespace llvm
 
 #endif

include/llvm/ObjectYAML/WasmYAML.h

 #include <cstdint>
 #include <memory>
 #include <vector>
 
 namespace llvm {
 namespace WasmYAML {
 
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, SectionType)
-LLVM_YAML_STRONG_TYPEDEF(int32_t, ValueType)
-LLVM_YAML_STRONG_TYPEDEF(int32_t, TableType)
-LLVM_YAML_STRONG_TYPEDEF(int32_t, SignatureForm)
-LLVM_YAML_STRONG_TYPEDEF(uint32_t, ExportKind)
+LLVM_YAML_STRONG_TYPEDEF(uint8_t, ValueType)
+LLVM_YAML_STRONG_TYPEDEF(uint8_t, TableType)
+LLVM_YAML_STRONG_TYPEDEF(uint8_t, SignatureForm)
+LLVM_YAML_STRONG_TYPEDEF(uint8_t, ExportKind)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, Opcode)
-LLVM_YAML_STRONG_TYPEDEF(uint32_t, RelocType)
+LLVM_YAML_STRONG_TYPEDEF(uint8_t, RelocType)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, SymbolFlags)
-LLVM_YAML_STRONG_TYPEDEF(uint32_t, SymbolKind)
+LLVM_YAML_STRONG_TYPEDEF(uint8_t, SymbolKind)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, SegmentFlags)
-LLVM_YAML_STRONG_TYPEDEF(uint32_t, LimitFlags)
-LLVM_YAML_STRONG_TYPEDEF(uint32_t, ComdatKind)
+LLVM_YAML_STRONG_TYPEDEF(uint8_t, LimitFlags)
+LLVM_YAML_STRONG_TYPEDEF(uint8_t, ComdatKind)
 
 struct FileHeader {
   yaml::Hex32 Version;
 };
 
 struct Limits {
   LimitFlags Flags;
   yaml::Hex32 Initial;

lib/MC/WasmObjectWriter.cpp

private:
   void writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
 
   void writeString(const StringRef Str) {
     encodeULEB128(Str.size(), getStream());
     writeBytes(Str);
   }
 
   void writeValueType(wasm::ValType Ty) {
-    encodeSLEB128(int32_t(Ty), getStream());
+    write8(static_cast<uint8_t>(Ty));
   }
 
   void writeTypeSection(ArrayRef<WasmFunctionType> FunctionTypes);
   void writeImportSection(ArrayRef<wasm::WasmImport> Imports, uint32_t DataSize,
                           uint32_t NumElements);
   void writeFunctionSection(ArrayRef<WasmFunction> Functions);
   void writeGlobalSection();
   void writeExportSection(ArrayRef<wasm::WasmExport> Exports);

 // Write out a section header and a patchable section size field.
 void WasmObjectWriter::startSection(SectionBookkeeping &Section,
                                     unsigned SectionId,
                                     const char *Name) {
   assert((Name != nullptr) == (SectionId == wasm::WASM_SEC_CUSTOM) &&
          "Only custom sections can have names");
 
   DEBUG(dbgs() << "startSection " << SectionId << ": " << Name << "\n");
-  encodeULEB128(SectionId, getStream());
+  write8(SectionId);
 
   Section.SizeOffset = getStream().tell();
 
   // The section size. We don't know the size yet, so reserve enough space
   // for any 32-bit value; we'll patch it later.
   encodeULEB128(UINT32_MAX, getStream());
 
   // The position where the section starts, for measuring its size.
void WasmObjectWriter::writeRelocations(
     ArrayRef<WasmRelocationEntry> Relocations) {
   raw_pwrite_stream &Stream = getStream();
   for (const WasmRelocationEntry& RelEntry : Relocations) {
 
     uint64_t Offset = RelEntry.Offset +
                       RelEntry.FixupSection->getSectionOffset();
     uint32_t Index = getRelocationIndexValue(RelEntry);
 
-    encodeULEB128(RelEntry.Type, Stream);
+    write8(RelEntry.Type);
     encodeULEB128(Offset, Stream);
     encodeULEB128(Index, Stream);
     if (RelEntry.hasAddend())
       encodeSLEB128(RelEntry.Addend, Stream);
   }
 }
 
 void WasmObjectWriter::writeTypeSection(
     ArrayRef<WasmFunctionType> FunctionTypes) {
   if (FunctionTypes.empty())
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_TYPE);
 
   encodeULEB128(FunctionTypes.size(), getStream());
 
   for (const WasmFunctionType &FuncTy : FunctionTypes) {
-    encodeSLEB128(wasm::WASM_TYPE_FUNC, getStream());
+    write8(wasm::WASM_TYPE_FUNC);
     encodeULEB128(FuncTy.Params.size(), getStream());
     for (wasm::ValType Ty : FuncTy.Params)
       writeValueType(Ty);
     encodeULEB128(FuncTy.Returns.size(), getStream());
     for (wasm::ValType Ty : FuncTy.Returns)
       writeValueType(Ty);
   }
 
void WasmObjectWriter::writeImportSection(ArrayRef<wasm::WasmImport> Imports,
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_IMPORT);
 
   encodeULEB128(Imports.size(), getStream());
   for (const wasm::WasmImport &Import : Imports) {
     writeString(Import.Module);
     writeString(Import.Field);
-    encodeULEB128(Import.Kind, getStream());
+    write8(Import.Kind);
 
     switch (Import.Kind) {
     case wasm::WASM_EXTERNAL_FUNCTION:
       encodeULEB128(Import.SigIndex, getStream());
       break;
     case wasm::WASM_EXTERNAL_GLOBAL:
-      encodeSLEB128(Import.Global.Type, getStream());
-      encodeULEB128(uint32_t(Import.Global.Mutable), getStream());
+      write8(Import.Global.Type);
+      write8(Import.Global.Mutable ? 1 : 0);
       break;
     case wasm::WASM_EXTERNAL_MEMORY:
       encodeULEB128(0, getStream()); // flags
       encodeULEB128(NumPages, getStream()); // initial
       break;
     case wasm::WASM_EXTERNAL_TABLE:
-      encodeSLEB128(Import.Table.ElemType, getStream());
+      write8(Import.Table.ElemType);
       encodeULEB128(0, getStream()); // flags
       encodeULEB128(NumElements, getStream()); // initial
       break;
     default:
       llvm_unreachable("unsupported import kind");
     }
   }
 
if (Exports.empty())
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_EXPORT);
 
   encodeULEB128(Exports.size(), getStream());
   for (const wasm::WasmExport &Export : Exports) {
     writeString(Export.Name);
-    encodeSLEB128(Export.Kind, getStream());
+    write8(Export.Kind);
     encodeULEB128(Export.Index, getStream());
   }
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeElemSection(ArrayRef<uint32_t> TableElems) {
   if (TableElems.empty())

lib/Object/WasmObjectFile.cpp

 }
 
 static uint8_t readVaruint1(const uint8_t *&Ptr) {
   int64_t result = readLEB128(Ptr);
   assert(result <= VARUINT1_MAX && result >= 0);
   return result;
 }
 
-static int8_t readVarint7(const uint8_t *&Ptr) {
-  int64_t result = readLEB128(Ptr);
-  assert(result <= VARINT7_MAX && result >= VARINT7_MIN);
-  return result;
-}
-
-static uint8_t readVaruint7(const uint8_t *&Ptr) {
-  uint64_t result = readULEB128(Ptr);
-  assert(result <= VARUINT7_MAX);
-  return result;
-}
-
 static int32_t readVarint32(const uint8_t *&Ptr) {
   int64_t result = readLEB128(Ptr);
   assert(result <= INT32_MAX && result >= INT32_MIN);
   return result;
 }
 
 static uint32_t readVaruint32(const uint8_t *&Ptr) {
   uint64_t result = readULEB128(Ptr);
static wasm::WasmLimits readLimits(const uint8_t *&Ptr) {
   Result.Initial = readVaruint32(Ptr);
   if (Result.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
     Result.Maximum = readVaruint32(Ptr);
   return Result;
 }
 
 static wasm::WasmTable readTable(const uint8_t *&Ptr) {
   wasm::WasmTable Table;
-  Table.ElemType = readVarint7(Ptr);
+  Table.ElemType = readUint8(Ptr);
   Table.Limits = readLimits(Ptr);
   return Table;
 }
 
 static Error readSection(WasmSection &Section, const uint8_t *&Ptr,
                          const uint8_t *Start, const uint8_t *Eof) {
   Section.Offset = Ptr - Start;
-  Section.Type = readVaruint7(Ptr);
+  Section.Type = readUint8(Ptr);
   uint32_t Size = readVaruint32(Ptr);
   if (Size == 0)
     return make_error<StringError>("Zero length section",
                                    object_error::parse_failed);
   if (Ptr + Size > Eof)
     return make_error<StringError>("Section too large",
                                    object_error::parse_failed);
   Section.Content = ArrayRef<uint8_t>(Ptr, Size);

 Error WasmObjectFile::parseNameSection(const uint8_t *Ptr, const uint8_t *End) {
   llvm::DenseSet<uint64_t> Seen;
   if (Functions.size() != FunctionTypes.size()) {
     return make_error<GenericBinaryError>("Names must come after code section",
                                           object_error::parse_failed);
   }
 
   while (Ptr < End) {
-    uint8_t Type = readVarint7(Ptr);
+    uint8_t Type = readUint8(Ptr);
     uint32_t Size = readVaruint32(Ptr);
     const uint8_t *SubSectionEnd = Ptr + Size;
     switch (Type) {
     case wasm::WASM_NAMES_FUNCTION: {
       uint32_t Count = readVaruint32(Ptr);
       while (Count--) {
         uint32_t Index = readVaruint32(Ptr);
         if (!Seen.insert(Index).second)
Error WasmObjectFile::parseLinkingSection(const uint8_t *Ptr,
                                           const uint8_t *End) {
   HasLinkingSection = true;
   if (Functions.size() != FunctionTypes.size()) {
     return make_error<GenericBinaryError>(
         "Linking data must come after code section", object_error::parse_failed);
   }
 
   while (Ptr < End) {
-    uint8_t Type = readVarint7(Ptr);
+    uint8_t Type = readUint8(Ptr);
     uint32_t Size = readVaruint32(Ptr);
     const uint8_t *SubSectionEnd = Ptr + Size;
     switch (Type) {
     case wasm::WASM_SYMBOL_TABLE:
       if (Error Err = parseLinkingSectionSymtab(Ptr, SubSectionEnd))
         return Err;
       break;
     case wasm::WASM_SEGMENT_INFO: {
for (WasmSection& Section : Sections) {
     if (Section.Type == Type)
       return &Section;
   }
   return nullptr;
 }
 
 Error WasmObjectFile::parseRelocSection(StringRef Name, const uint8_t *Ptr,
                                         const uint8_t *End) {
-  uint8_t SectionCode = readVarint7(Ptr);
+  uint8_t SectionCode = readUint8(Ptr);
   WasmSection* Section = nullptr;
   if (SectionCode == wasm::WASM_SEC_CUSTOM) {
     StringRef Name = readString(Ptr);
     Section = findCustomSectionByName(Name);
   } else {
     Section = findSectionByType(SectionCode);
   }
   if (!Section)

 }
 
 Error WasmObjectFile::parseTypeSection(const uint8_t *Ptr, const uint8_t *End) {
   uint32_t Count = readVaruint32(Ptr);
   Signatures.reserve(Count);
   while (Count--) {
     wasm::WasmSignature Sig;
     Sig.ReturnType = wasm::WASM_TYPE_NORESULT;
-    int8_t Form = readVarint7(Ptr);
+    uint8_t Form = readUint8(Ptr);
     if (Form != wasm::WASM_TYPE_FUNC) {
       return make_error<GenericBinaryError>("Invalid signature type",
                                             object_error::parse_failed);
     }
     uint32_t ParamCount = readVaruint32(Ptr);
     Sig.ParamTypes.reserve(ParamCount);
     while (ParamCount--) {
-      uint32_t ParamType = readVarint7(Ptr);
+      uint32_t ParamType = readUint8(Ptr);
       Sig.ParamTypes.push_back(ParamType);
     }
     uint32_t ReturnCount = readVaruint32(Ptr);
     if (ReturnCount) {
       if (ReturnCount != 1) {
         return make_error<GenericBinaryError>(
             "Multiple return types not supported", object_error::parse_failed);
       }
-      Sig.ReturnType = readVarint7(Ptr);
+      Sig.ReturnType = readUint8(Ptr);
     }
     Signatures.push_back(Sig);
   }
   if (Ptr != End)
     return make_error<GenericBinaryError>("Type section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseImportSection(const uint8_t *Ptr, const uint8_t *End) {
   uint32_t Count = readVaruint32(Ptr);
   Imports.reserve(Count);
   for (uint32_t i = 0; i < Count; i++) {
     wasm::WasmImport Im;
     Im.Module = readString(Ptr);
     Im.Field = readString(Ptr);
     Im.Kind = readUint8(Ptr);
     switch (Im.Kind) {
     case wasm::WASM_EXTERNAL_FUNCTION:
       NumImportedFunctions++;
       Im.SigIndex = readVaruint32(Ptr);
       break;
     case wasm::WASM_EXTERNAL_GLOBAL:
       NumImportedGlobals++;
-      Im.Global.Type = readVarint7(Ptr);
+      Im.Global.Type = readUint8(Ptr);
       Im.Global.Mutable = readVaruint1(Ptr);
       break;
     case wasm::WASM_EXTERNAL_MEMORY:
       Im.Memory = readLimits(Ptr);
       break;
     case wasm::WASM_EXTERNAL_TABLE:
       Im.Table = readTable(Ptr);
       if (Im.Table.ElemType != wasm::WASM_TYPE_ANYFUNC)

 
 Error WasmObjectFile::parseGlobalSection(const uint8_t *Ptr, const uint8_t *End) {
   GlobalSection = Sections.size();
   uint32_t Count = readVaruint32(Ptr);
   Globals.reserve(Count);
   while (Count--) {
     wasm::WasmGlobal Global;
     Global.Index = NumImportedGlobals + Globals.size();
-    Global.Type.Type = readVarint7(Ptr);
+    Global.Type.Type = readUint8(Ptr);
     Global.Type.Mutable = readVaruint1(Ptr);
     if (Error Err = readInitExpr(Global.InitExpr, Ptr))
       return Err;
     Globals.push_back(Global);
   }
   if (Ptr != End)
     return make_error<GenericBinaryError>("Global section ended prematurely",
                                           object_error::parse_failed);
while (FunctionCount--) {
     Function.CodeSectionOffset = FunctionStart - CodeSectionStart;
     Function.Size = FunctionEnd - FunctionStart;
 
     uint32_t NumLocalDecls = readVaruint32(Ptr);
     Function.Locals.reserve(NumLocalDecls);
     while (NumLocalDecls--) {
       wasm::WasmLocalDecl Decl;
       Decl.Count = readVaruint32(Ptr);
-      Decl.Type = readVarint7(Ptr);
+      Decl.Type = readUint8(Ptr);
       Function.Locals.push_back(Decl);
     }
 
     uint32_t BodySize = FunctionEnd - Ptr;
     Function.Body = ArrayRef<uint8_t>(Ptr, BodySize);
     Ptr += BodySize;
     assert(Ptr == FunctionEnd);
     Functions.push_back(Function);

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyTargetStreamer.cpp

 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FormattedStream.h"
 using namespace llvm;
 
 WebAssemblyTargetStreamer::WebAssemblyTargetStreamer(MCStreamer &S)
     : MCTargetStreamer(S) {}
 
 void WebAssemblyTargetStreamer::emitValueType(wasm::ValType Type) {
-  Streamer.EmitSLEB128IntValue(int32_t(Type));
+  Streamer.EmitIntValue(uint8_t(Type), 1);
 }
 
 WebAssemblyTargetAsmStreamer::WebAssemblyTargetAsmStreamer(
     MCStreamer &S, formatted_raw_ostream &OS)
     : WebAssemblyTargetStreamer(S), OS(OS) {}
 
 WebAssemblyTargetELFStreamer::WebAssemblyTargetELFStreamer(MCStreamer &S)
     : WebAssemblyTargetStreamer(S) {}

lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

MCSymbol *WebAssemblyMCInstLower::GetExternalSymbolSymbol(
   MCSymbolWasm *WasmSym = cast<MCSymbolWasm>(Sym);
   const WebAssemblySubtarget &Subtarget = Printer.getSubtarget();
 
   // __stack_pointer is a global variable; all other external symbols used by
   // CodeGen are functions.  It's OK to hardcode knowledge of specific symbols
   // here; this method is precisely there for fetching the signatures of known
   // Clang-provided symbols.
   if (strcmp(Name, "__stack_pointer") == 0) {
-    wasm::ValType iPTR =
-        Subtarget.hasAddr64() ? wasm::ValType::I64 : wasm::ValType::I32;
     WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
-    WasmSym->setGlobalType(wasm::WasmGlobalType{int32_t(iPTR), true});
+    WasmSym->setGlobalType(wasm::WasmGlobalType{
+        Subtarget.hasAddr64() ? wasm::WASM_TYPE_I64 : wasm::WASM_TYPE_I32,
+        true});
     return WasmSym;
   }
 
   SmallVector<wasm::ValType, 4> Returns;
   SmallVector<wasm::ValType, 4> Params;
   GetSignature(Subtarget, Name, Returns, Params);
 
   WasmSym->setReturns(std::move(Returns));

tools/yaml2obj/yaml2wasm.cpp

 
 static int writeStringRef(const StringRef &Str, raw_ostream &OS) {
   encodeULEB128(Str.size(), OS);
   OS << Str;
   return 0;
 }
 
 static int writeLimits(const WasmYAML::Limits &Lim, raw_ostream &OS) {
-  encodeULEB128(Lim.Flags, OS);
+  writeUint8(OS, Lim.Flags);
   encodeULEB128(Lim.Initial, OS);
   if (Lim.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
     encodeULEB128(Lim.Maximum, OS);
   return 0;
 }
 
 static int writeInitExpr(const wasm::WasmInitExpr &InitExpr, raw_ostream &OS) {
   writeUint8(OS, InitExpr.Opcode);

 
 int WasmWriter::writeSectionContent(raw_ostream &OS, WasmYAML::LinkingSection &Section) {
   writeStringRef(Section.Name, OS);
 
   SubSectionWriter SubSection(OS);
 
   // SYMBOL_TABLE subsection
   if (Section.SymbolTable.size()) {
-    encodeULEB128(wasm::WASM_SYMBOL_TABLE, OS);
+    writeUint8(OS, wasm::WASM_SYMBOL_TABLE);
 
     encodeULEB128(Section.SymbolTable.size(), SubSection.GetStream());
 #ifndef NDEBUG
     uint32_t SymbolIndex = 0;
 #endif
     for (const WasmYAML::SymbolInfo &Info : Section.SymbolTable) {
       assert(Info.Index == SymbolIndex++);
-      encodeULEB128(Info.Kind, SubSection.GetStream());
+      writeUint8(SubSection.GetStream(), Info.Kind);
       encodeULEB128(Info.Flags, SubSection.GetStream());
       switch (Info.Kind) {
       case wasm::WASM_SYMBOL_TYPE_FUNCTION:
       case wasm::WASM_SYMBOL_TYPE_GLOBAL:
         encodeULEB128(Info.ElementIndex, SubSection.GetStream());
         if ((Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0)
           writeStringRef(Info.Name, SubSection.GetStream());
         break;
for (const WasmYAML::SymbolInfo &Info : Section.SymbolTable) {
       }
     }
 
     SubSection.Done();
   }
 
   // SEGMENT_NAMES subsection
   if (Section.SegmentInfos.size()) {
-    encodeULEB128(wasm::WASM_SEGMENT_INFO, OS);
+    writeUint8(OS, wasm::WASM_SEGMENT_INFO);
     encodeULEB128(Section.SegmentInfos.size(), SubSection.GetStream());
     for (const WasmYAML::SegmentInfo &SegmentInfo : Section.SegmentInfos) {
       writeStringRef(SegmentInfo.Name, SubSection.GetStream());
       encodeULEB128(SegmentInfo.Alignment, SubSection.GetStream());
       encodeULEB128(SegmentInfo.Flags, SubSection.GetStream());
     }
     SubSection.Done();
   }
 
   // INIT_FUNCS subsection
   if (Section.InitFunctions.size()) {
-    encodeULEB128(wasm::WASM_INIT_FUNCS, OS);
+    writeUint8(OS, wasm::WASM_INIT_FUNCS);
     encodeULEB128(Section.InitFunctions.size(), SubSection.GetStream());
     for (const WasmYAML::InitFunction &Func : Section.InitFunctions) {
       encodeULEB128(Func.Priority, SubSection.GetStream());
       encodeULEB128(Func.Symbol, SubSection.GetStream());
     }
     SubSection.Done();
   }
 
   // COMDAT_INFO subsection
   if (Section.Comdats.size()) {
-    encodeULEB128(wasm::WASM_COMDAT_INFO, OS);
+    writeUint8(OS, wasm::WASM_COMDAT_INFO);
     encodeULEB128(Section.Comdats.size(), SubSection.GetStream());
     for (const auto &C : Section.Comdats) {
       writeStringRef(C.Name, SubSection.GetStream());
       encodeULEB128(0, SubSection.GetStream()); // flags for future use
       encodeULEB128(C.Entries.size(), SubSection.GetStream());
       for (const WasmYAML::ComdatEntry &Entry : C.Entries) {
-        encodeULEB128(Entry.Kind, SubSection.GetStream());
+        writeUint8(SubSection.GetStream(), Entry.Kind);
         encodeULEB128(Entry.Index, SubSection.GetStream());
       }
     }
     SubSection.Done();
   }
 
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS, WasmYAML::NameSection &Section) {
   writeStringRef(Section.Name, OS);
   if (Section.FunctionNames.size()) {
-    encodeULEB128(wasm::WASM_NAMES_FUNCTION, OS);
+    writeUint8(OS, wasm::WASM_NAMES_FUNCTION);
 
     SubSectionWriter SubSection(OS);
 
     encodeULEB128(Section.FunctionNames.size(), SubSection.GetStream());
     for (const WasmYAML::NameEntry &NameEntry : Section.FunctionNames) {
       encodeULEB128(NameEntry.Index, SubSection.GetStream());
       writeStringRef(NameEntry.Name, SubSection.GetStream());
     }
int WasmWriter::writeSectionContent(raw_ostream &OS,
   encodeULEB128(Section.Signatures.size(), OS);
   uint32_t ExpectedIndex = 0;
   for (const WasmYAML::Signature &Sig : Section.Signatures) {
     if (Sig.Index != ExpectedIndex) {
       errs() << "Unexpected type index: " << Sig.Index << "\n";
       return 1;
     }
     ++ExpectedIndex;
-    encodeSLEB128(Sig.Form, OS);
+    writeUint8(OS, Sig.Form);
     encodeULEB128(Sig.ParamTypes.size(), OS);
     for (auto ParamType : Sig.ParamTypes)
-      encodeSLEB128(ParamType, OS);
+      writeUint8(OS, ParamType);
     if (Sig.ReturnType == wasm::WASM_TYPE_NORESULT) {
-      encodeSLEB128(0, OS);
+      encodeULEB128(0, OS);
     } else {
       encodeULEB128(1, OS);
-      encodeSLEB128(Sig.ReturnType, OS);
+      writeUint8(OS, Sig.ReturnType);
     }
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::ImportSection &Section) {
   encodeULEB128(Section.Imports.size(), OS);
   for (const WasmYAML::Import &Import : Section.Imports) {
     writeStringRef(Import.Module, OS);
     writeStringRef(Import.Field, OS);
-    encodeULEB128(Import.Kind, OS);
+    writeUint8(OS, Import.Kind);
     switch (Import.Kind) {
     case wasm::WASM_EXTERNAL_FUNCTION:
       encodeULEB128(Import.SigIndex, OS);
       NumImportedFunctions++;
       break;
     case wasm::WASM_EXTERNAL_GLOBAL:
-      encodeSLEB128(Import.GlobalImport.Type, OS);
+      writeUint8(OS, Import.GlobalImport.Type);
       writeUint8(OS, Import.GlobalImport.Mutable);
       NumImportedGlobals++;
       break;
     case wasm::WASM_EXTERNAL_MEMORY:
       writeLimits(Import.Memory, OS);
       break;
     case wasm::WASM_EXTERNAL_TABLE:
-      encodeSLEB128(Import.TableImport.ElemType, OS);
+      writeUint8(OS,Import.TableImport.ElemType);
       writeLimits(Import.TableImport.TableLimits, OS);
       break;
     default:
       errs() << "Unknown import type: " << Import.Kind << "\n";
       return 1;
     }
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::FunctionSection &Section) {
   encodeULEB128(Section.FunctionTypes.size(), OS);
   for (uint32_t FuncType : Section.FunctionTypes) {
     encodeULEB128(FuncType, OS);
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::ExportSection &Section) {
   encodeULEB128(Section.Exports.size(), OS);
   for (const WasmYAML::Export &Export : Section.Exports) {
     writeStringRef(Export.Name, OS);
-    encodeULEB128(Export.Kind, OS);
+    writeUint8(OS, Export.Kind);
     encodeULEB128(Export.Index, OS);
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::StartSection &Section) {
   encodeULEB128(Section.StartFunction, OS);
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::TableSection &Section) {
   encodeULEB128(Section.Tables.size(), OS);
   for (auto &Table : Section.Tables) {
-    encodeSLEB128(Table.ElemType, OS);
+    writeUint8(OS, Table.ElemType);
     writeLimits(Table.TableLimits, OS);
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::MemorySection &Section) {
   encodeULEB128(Section.Memories.size(), OS);
   for (const WasmYAML::Limits &Mem : Section.Memories) {
     writeLimits(Mem, OS);
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::GlobalSection &Section) {
   encodeULEB128(Section.Globals.size(), OS);
   uint32_t ExpectedIndex = NumImportedGlobals;
   for (auto &Global : Section.Globals) {
     if (Global.Index != ExpectedIndex) {
       errs() << "Unexpected global index: " << Global.Index << "\n";
       return 1;
     }
     ++ExpectedIndex;
-    encodeSLEB128(Global.Type, OS);
+    writeUint8(OS, Global.Type);
     writeUint8(OS, Global.Mutable);
     writeInitExpr(Global.InitExpr, OS);
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::ElemSection &Section) {
if (Func.Index != ExpectedIndex) {
       errs() << "Unexpected function index: " << Func.Index << "\n";
       return 1;
     }
     ++ExpectedIndex;
 
     encodeULEB128(Func.Locals.size(), StringStream);
     for (auto &LocalDecl : Func.Locals) {
       encodeULEB128(LocalDecl.Count, StringStream);
-      encodeSLEB128(LocalDecl.Type, StringStream);
+      writeUint8(StringStream, LocalDecl.Type);
     }
 
     Func.Body.writeAsBinary(StringStream);
 
     // Write the section size followed by the content
     StringStream.flush();
     encodeULEB128(OutString.size(), OS);
     OS << OutString;
case wasm::WASM_SEC_DATA:
       Name = "reloc.DATA";
       break;
     default:
       llvm_unreachable("not yet implemented");
       return 1;
   }
 
   writeStringRef(Name, OS);
-  encodeULEB128(Sec.Type, OS);
+  writeUint8(OS, Sec.Type);
   encodeULEB128(Sec.Relocations.size(), OS);
 
   for (auto Reloc: Sec.Relocations) {
-    encodeULEB128(Reloc.Type, OS);
+    writeUint8(OS, Reloc.Type);
     encodeULEB128(Reloc.Offset, OS);
     encodeULEB128(Reloc.Index, OS);
     switch (Reloc.Type) {
       case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
       case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
       case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
         encodeULEB128(Reloc.Addend, OS);
     }
for (const std::unique_ptr<WasmYAML::Section> &Sec : Obj.Sections) {
     OS << OutString;
   }
 
   // write reloc sections for any section that have relocations
   for (const std::unique_ptr<WasmYAML::Section> &Sec : Obj.Sections) {
     if (Sec->Relocations.empty())
       continue;
 
-    encodeULEB128(wasm::WASM_SEC_CUSTOM, OS);
+    writeUint8(OS, wasm::WASM_SEC_CUSTOM);
     std::string OutString;
     raw_string_ostream StringStream(OutString);
     writeRelocSection(StringStream, *Sec);
     StringStream.flush();
 
     encodeULEB128(OutString.size(), OS);
     OS << OutString;
   }