[WebAssembly] Fix some broken type encodings in wasm binary

[sbc100]

Summary

A recent change switch the in-memory wasm value types
to be signed integers, but I missing a few cases where
these were being writing to the binary.

[sunfish]

lgtm

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyTargetStreamer.h

55

It looks like this function can have be marked protected.

[sbc100]

• make emitValueType protected

lib/MC/WasmObjectWriter.cpp

struct WasmImport {
   StringRef ModuleName;
   StringRef FieldName;
   unsigned Kind;
   uint32_t Type;
 };
 
 // A wasm function to be written into the function section.
 struct WasmFunction {
-  unsigned Type;
+  int32_t Type;
   const MCSymbolWasm *Sym;
 };
 
 // A wasm export to be written into the export section.
 struct WasmExport {
   StringRef FieldName;
   unsigned Kind;
   uint32_t Index;
 };
 
 // A wasm global to be written into the global section.
 struct WasmGlobal {
-  unsigned Type;
+  wasm::ValType Type;
   bool IsMutable;
   uint32_t InitialValue;
 };
 
 } // end anonymous namespace
 
 // Write X as an (unsigned) LEB value at offset Offset in Stream, padded
 // to allow patching.
default:
       llvm_unreachable("unsupported relocation type");
     }
   }
 }
 
 void WasmObjectWriter::writeObject(MCAssembler &Asm,
                                    const MCAsmLayout &Layout) {
   MCContext &Ctx = Asm.getContext();
-  unsigned PtrType = is64Bit() ? wasm::WASM_TYPE_I64 : wasm::WASM_TYPE_I32;
+  wasm::ValType PtrType = is64Bit() ? wasm::ValType::I64 : wasm::ValType::I32;
 
   // Collect information from the available symbols.
-  DenseMap<WasmFunctionType, unsigned, WasmFunctionTypeDenseMapInfo>
+  DenseMap<WasmFunctionType, int32_t, WasmFunctionTypeDenseMapInfo>
       FunctionTypeIndices;
   SmallVector<WasmFunctionType, 4> FunctionTypes;
   SmallVector<WasmFunction, 4> Functions;
   SmallVector<uint32_t, 4> TableElems;
   SmallVector<WasmGlobal, 4> Globals;
   SmallVector<WasmImport, 4> Imports;
   SmallVector<WasmExport, 4> Exports;
   DenseMap<const MCSymbolWasm *, uint32_t> SymbolIndices;
for (WasmRelocationEntry RelEntry : DataRelocations) {
     default:
       break;
     }
   }
 
   // Populate the Imports set.
   for (const MCSymbol &S : Asm.symbols()) {
     const auto &WS = static_cast<const MCSymbolWasm &>(S);
-    unsigned Type;
+    int32_t Type;
 
     if (WS.isFunction()) {
       // Prepare the function's type, if we haven't seen it yet.
       WasmFunctionType F;
       F.Returns = WS.getReturns();
       F.Params = WS.getParams();
       auto Pair =
           FunctionTypeIndices.insert(std::make_pair(F, FunctionTypes.size()));
       if (Pair.second)
         FunctionTypes.push_back(F);
 
       Type = Pair.first->second;
     } else {
-      Type = PtrType;
+      Type = int32_t(PtrType);
     }
 
     // If the symbol is not defined in this translation unit, import it.
     if (!WS.isTemporary() && !WS.isDefined(/*SetUsed=*/false)) {
       WasmImport Import;
       Import.ModuleName = WS.getModuleName();
       Import.FieldName = WS.getName();
 
if (!GlobalVars->getFragmentList().empty()) {
     if (Frag.hasInstructions() || Frag.getKind() != MCFragment::FT_Data)
       report_fatal_error("only data supported in .global_variables");
     const MCDataFragment &DataFrag = cast<MCDataFragment>(Frag);
     if (!DataFrag.getFixups().empty())
       report_fatal_error("fixups not supported in .global_variables");
     const SmallVectorImpl<char> &Contents = DataFrag.getContents();
     for (char p : Contents) {
       WasmGlobal G;
-      G.Type = uint8_t(p);
+      G.Type = wasm::ValType(p);
       G.IsMutable = true;
       G.InitialValue = 0;
       Globals.push_back(G);
     }
   }
 
   // Handle defined symbols.
   for (const MCSymbol &S : Asm.symbols()) {
     // Ignore unnamed temporary symbols, which aren't ever exported, imported,
     // or used in relocations.
     if (S.isTemporary() && S.getName().empty())
       continue;
     const auto &WS = static_cast<const MCSymbolWasm &>(S);
     unsigned Index;
     if (WS.isFunction()) {
       // Prepare the function's type, if we haven't seen it yet.
       WasmFunctionType F;
       F.Returns = WS.getReturns();
       F.Params = WS.getParams();
       auto Pair =
           FunctionTypeIndices.insert(std::make_pair(F, FunctionTypes.size()));
       if (Pair.second)
         FunctionTypes.push_back(F);
 
-      unsigned Type = Pair.first->second;
+      int32_t Type = Pair.first->second;
 
       if (WS.isDefined(/*SetUsed=*/false)) {
         // A definition. Take the next available index.
         Index = NumFuncImports + Functions.size();
 
         // Prepare the function.
         WasmFunction Func;
         Func.Type = Type;
void WasmObjectWriter::writeObject(MCAssembler &Asm,
   endSection(Section);
 
   // === Global Section ========================================================
   if (!Globals.empty()) {
     startSection(Section, wasm::WASM_SEC_GLOBAL);
 
     encodeULEB128(Globals.size(), getStream());
     for (const WasmGlobal &Global : Globals) {
-      encodeSLEB128(Global.Type, getStream());
+      writeValueType(Global.Type);
       write8(Global.IsMutable);
 
       write8(wasm::WASM_OPCODE_I32_CONST);
       encodeSLEB128(Global.InitialValue, getStream()); // offset
       write8(wasm::WASM_OPCODE_END);
     }
 
     endSection(Section);

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyTargetStreamer.h

 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_TARGET_WEBASSEMBLY_MCTARGETDESC_WEBASSEMBLYTARGETSTREAMER_H
 #define LLVM_LIB_TARGET_WEBASSEMBLY_MCTARGETDESC_WEBASSEMBLYTARGETSTREAMER_H
 
 #include "llvm/CodeGen/MachineValueType.h"
 #include "llvm/MC/MCStreamer.h"
+#include "llvm/Support/Wasm.h"
 
 namespace llvm {
 
 class MCELFStreamer;
 class MCWasmStreamer;
 
 /// WebAssembly-specific streamer interface, to implement support
 /// WebAssembly-specific assembly directives.
virtual void emitIndirectFunctionType(StringRef name,
                                         SmallVectorImpl<MVT> &Params,
                                         SmallVectorImpl<MVT> &Results) {
     llvm_unreachable("emitIndirectFunctionType not implemented");
   }
   /// .indidx
   virtual void emitIndIdx(const MCExpr *Value) = 0;
   /// .import_global
   virtual void emitGlobalImport(StringRef name) = 0;
+
+protected:
+  void emitValueType(wasm::ValType Type);
 };
 
 /// This part is for ascii assembly output
 class WebAssemblyTargetAsmStreamer final : public WebAssemblyTargetStreamer {
   formatted_raw_ostream &OS;
 
 public:
   WebAssemblyTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS);

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyTargetStreamer.cpp

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

 void WebAssemblyTargetELFStreamer::emitResult(MCSymbol *Symbol,
                                               ArrayRef<MVT> Types) {
   // Nothing to emit; results are declared as part of the function signature.
 }
 
 void WebAssemblyTargetELFStreamer::emitLocal(ArrayRef<MVT> Types) {
   Streamer.EmitULEB128IntValue(Types.size());
   for (MVT Type : Types)
-    Streamer.EmitIntValue(int64_t(WebAssembly::toValType(Type)), 1);
+    emitValueType(WebAssembly::toValType(Type));
 }
 
 void WebAssemblyTargetELFStreamer::emitGlobal(ArrayRef<MVT> Types) {
   llvm_unreachable(".globalvar encoding not yet implemented");
 }
 
 void WebAssemblyTargetELFStreamer::emitEndFunc() {
   Streamer.EmitIntValue(WebAssembly::End, 1);
if (Grouped.empty() || Grouped.back().first != Type)
       Grouped.push_back(std::make_pair(Type, 1));
     else
       ++Grouped.back().second;
   }
 
   Streamer.EmitULEB128IntValue(Grouped.size());
   for (auto Pair : Grouped) {
     Streamer.EmitULEB128IntValue(Pair.second);
-    Streamer.EmitULEB128IntValue(uint64_t(WebAssembly::toValType(Pair.first)));
+    emitValueType(WebAssembly::toValType(Pair.first));
   }
 }
 
 void WebAssemblyTargetWasmStreamer::emitGlobal(ArrayRef<MVT> Types) {
   // Encode the globals use by the funciton into the special .global_variables
   // section. This will later be decoded and turned into contents for the
   // Globals Section.
   Streamer.PushSection();
   Streamer.SwitchSection(Streamer.getContext()
                                  .getWasmSection(".global_variables", 0, 0));
   for (MVT Ty : Types)
-    Streamer.EmitIntValue(uint64_t(WebAssembly::toValType(Ty)), 1);
+    Streamer.EmitIntValue(int64_t(WebAssembly::toValType(Ty)), 1);
   Streamer.PopSection();
 }
 
 void WebAssemblyTargetWasmStreamer::emitEndFunc() {
   llvm_unreachable(".end_func is not needed for direct wasm output");
 }
 
 void WebAssemblyTargetWasmStreamer::emitIndIdx(const MCExpr *Value) {