[WebAssembly] Make tag attribute's encoding uint8

[aheejin]

Summary

This changes the encoding of the attribute field, which currently only
contains the value 0 denoting this tag is for an exception, from
varuint32 to uint8. This field is effectively unused at the moment
and reserved for future use, and it is not likely to need varuint32
even in future.
See https://github.com/WebAssembly/exception-handling/pull/162.

This does not change any encoded binaries because 0 is encoded in the
same way both in varuint32 and uint8.

[tlively]

llvm/lib/MC/WasmObjectWriter.cpp

817

Normally I would suggest using uint8_t rather than char here, but I see that this file already uses char in many places, so it's probably best to stay consistent.

llvm/include/llvm/BinaryFormat/Wasm.h

struct WasmGlobal {
   uint32_t Index;
   WasmGlobalType Type;
   WasmInitExpr InitExpr;
   StringRef SymbolName; // from the "linking" section
 };
 
 struct WasmTagType {
   // Kind of tag. Currently only WASM_TAG_ATTRIBUTE_EXCEPTION is possible.
-  uint32_t Attribute;
+  uint8_t Attribute;
   uint32_t SigIndex;
 };
 
 struct WasmTag {
   uint32_t Index;
   WasmTagType Type;
   StringRef SymbolName; // from the "linking" section
 };

 };
 
 enum WasmSegmentFlag : unsigned {
   WASM_SEG_FLAG_STRINGS = 0x1,
   WASM_SEG_FLAG_TLS = 0x2,
 };
 
 // Kinds of tag attributes.
-enum WasmTagAttribute : unsigned {
+enum WasmTagAttribute : uint8_t {
   WASM_TAG_ATTRIBUTE_EXCEPTION = 0x0,
 };
 
 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;

llvm/lib/MC/WasmObjectWriter.cpp

case wasm::WASM_EXTERNAL_MEMORY:
       encodeULEB128(NumPages, W->OS); // initial
       break;
     case wasm::WASM_EXTERNAL_TABLE:
       W->OS << char(Import.Table.ElemType);
       encodeULEB128(0, W->OS);           // flags
       encodeULEB128(NumElements, W->OS); // initial
       break;
     case wasm::WASM_EXTERNAL_TAG:
-      encodeULEB128(Import.Tag.Attribute, W->OS);
+      W->OS << char(Import.Tag.Attribute);
       encodeULEB128(Import.Tag.SigIndex, W->OS);
       break;
     default:
       llvm_unreachable("unsupported import kind");
     }
   }
 
   endSection(Section);
void WasmObjectWriter::writeTagSection(ArrayRef<wasm::WasmTagType> Tags) {
   if (Tags.empty())
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_TAG);
 
   encodeULEB128(Tags.size(), W->OS);
   for (const wasm::WasmTagType &Tag : Tags) {
-    encodeULEB128(Tag.Attribute, W->OS);
+    W->OS << char(Tag.Attribute);
     encodeULEB128(Tag.SigIndex, W->OS);
   }
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeGlobalSection(ArrayRef<wasm::WasmGlobal> Globals) {
   if (Globals.empty())

llvm/lib/Object/WasmObjectFile.cpp

case wasm::WASM_EXTERNAL_TABLE: {
       if (ElemType != wasm::WASM_TYPE_FUNCREF &&
           ElemType != wasm::WASM_TYPE_EXTERNREF)
         return make_error<GenericBinaryError>("invalid table element type",
                                               object_error::parse_failed);
       break;
     }
     case wasm::WASM_EXTERNAL_TAG:
       NumImportedTags++;
-      Im.Tag.Attribute = readVarint32(Ctx);
+      Im.Tag.Attribute = readUint8(Ctx);
       Im.Tag.SigIndex = readVarint32(Ctx);
       break;
     default:
       return make_error<GenericBinaryError>("unexpected import kind",
                                             object_error::parse_failed);
     }
     Imports.push_back(Im);
   }

 
 Error WasmObjectFile::parseTagSection(ReadContext &Ctx) {
   TagSection = Sections.size();
   uint32_t Count = readVaruint32(Ctx);
   Tags.reserve(Count);
   while (Count--) {
     wasm::WasmTag Tag;
     Tag.Index = NumImportedTags + Tags.size();
-    Tag.Type.Attribute = readVaruint32(Ctx);
+    Tag.Type.Attribute = readUint8(Ctx);
     Tag.Type.SigIndex = readVaruint32(Ctx);
     Tags.push_back(Tag);
   }
 
   if (Ctx.Ptr != Ctx.End)
     return make_error<GenericBinaryError>("tag section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();