[WebAssembly] MC: Pass ArrayRefs rather than SmallVectors

[sbc100]

Summary

This is more flexible and less verbose.

llvm/trunk/lib/MC/WasmObjectWriter.cpp

void writeString(const StringRef Str) {
     encodeULEB128(Str.size(), getStream());
     writeBytes(Str);
   }
 
   void writeValueType(wasm::ValType Ty) {
     encodeSLEB128(int32_t(Ty), getStream());
   }
 
-  void writeTypeSection(const SmallVector<WasmFunctionType, 4> &FunctionTypes);
-  void writeImportSection(const SmallVector<WasmImport, 4> &Imports);
-  void writeFunctionSection(const SmallVector<WasmFunction, 4> &Functions);
+  void writeTypeSection(ArrayRef<WasmFunctionType> FunctionTypes);
+  void writeImportSection(ArrayRef<WasmImport> Imports);
+  void writeFunctionSection(ArrayRef<WasmFunction> Functions);
   void writeTableSection(uint32_t NumElements);
   void writeMemorySection(uint32_t DataSize);
   void writeGlobalSection();
-  void writeExportSection(const SmallVector<WasmExport, 4> &Exports);
-  void writeElemSection(const SmallVector<uint32_t, 4> &TableElems);
+  void writeExportSection(ArrayRef<WasmExport> Exports);
+  void writeElemSection(ArrayRef<uint32_t> TableElems);
   void writeCodeSection(const MCAssembler &Asm, const MCAsmLayout &Layout,
-                        const SmallVector<WasmFunction, 4> &Functions);
-  void writeDataSection(const SmallVector<WasmDataSegment, 4> &Segments);
-  void writeNameSection(const SmallVector<WasmFunction, 4> &Functions,
-                        const SmallVector<WasmImport, 4> &Imports,
+                        ArrayRef<WasmFunction> Functions);
+  void writeDataSection(ArrayRef<WasmDataSegment> Segments);
+  void writeNameSection(ArrayRef<WasmFunction> Functions,
+                        ArrayRef<WasmImport> Imports,
                         uint32_t NumFuncImports);
   void writeCodeRelocSection();
   void writeDataRelocSection();
   void writeLinkingMetaDataSection(uint32_t DataSize, uint32_t DataAlignment,
                                    ArrayRef<StringRef> WeakSymbols,
                                    bool HasStackPointer,
                                    uint32_t StackPointerGlobal);
 
for (const WasmRelocationEntry& RelEntry : Relocations) {
     encodeULEB128(Offset, Stream);
     encodeULEB128(Index, Stream);
     if (RelEntry.hasAddend())
       encodeSLEB128(RelEntry.Addend, Stream);
   }
 }
 
 void WasmObjectWriter::writeTypeSection(
-    const SmallVector<WasmFunctionType, 4> &FunctionTypes) {
+    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());
     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);
   }
 
   endSection(Section);
 }
 
-
-void WasmObjectWriter::writeImportSection(
-    const SmallVector<WasmImport, 4> &Imports) {
+void WasmObjectWriter::writeImportSection(ArrayRef<WasmImport> Imports) {
   if (Imports.empty())
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_IMPORT);
 
   encodeULEB128(Imports.size(), getStream());
   for (const WasmImport &Import : Imports) {
for (const WasmImport &Import : Imports) {
     default:
       llvm_unreachable("unsupported import kind");
     }
   }
 
   endSection(Section);
 }
 
-void WasmObjectWriter::writeFunctionSection(
-    const SmallVector<WasmFunction, 4> &Functions) {
+void WasmObjectWriter::writeFunctionSection(ArrayRef<WasmFunction> Functions) {
   if (Functions.empty())
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_FUNCTION);
 
   encodeULEB128(Functions.size(), getStream());
   for (const WasmFunction &Func : Functions)
if (Global.HasImport) {
       encodeSLEB128(Global.InitialValue, getStream()); // offset
     }
     write8(wasm::WASM_OPCODE_END);
   }
 
   endSection(Section);
 }
 
-void WasmObjectWriter::writeExportSection(
-    const SmallVector<WasmExport, 4> &Exports) {
+void WasmObjectWriter::writeExportSection(ArrayRef<WasmExport> Exports) {
   if (Exports.empty())
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_EXPORT);
 
   encodeULEB128(Exports.size(), getStream());
   for (const WasmExport &Export : Exports) {
     writeString(Export.FieldName);
     encodeSLEB128(Export.Kind, getStream());
     encodeULEB128(Export.Index, getStream());
   }
 
   endSection(Section);
 }
 
-void WasmObjectWriter::writeElemSection(
-    const SmallVector<uint32_t, 4> &TableElems) {
+void WasmObjectWriter::writeElemSection(ArrayRef<uint32_t> TableElems) {
   if (TableElems.empty())
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_ELEM);
 
   encodeULEB128(1, getStream()); // number of "segments"
   encodeULEB128(0, getStream()); // the table index
 
   // init expr for starting offset
   write8(wasm::WASM_OPCODE_I32_CONST);
   encodeSLEB128(0, getStream());
   write8(wasm::WASM_OPCODE_END);
 
   encodeULEB128(TableElems.size(), getStream());
   for (uint32_t Elem : TableElems)
     encodeULEB128(Elem, getStream());
 
   endSection(Section);
 }
 
-void WasmObjectWriter::writeCodeSection(
-    const MCAssembler &Asm, const MCAsmLayout &Layout,
-    const SmallVector<WasmFunction, 4> &Functions) {
+void WasmObjectWriter::writeCodeSection(const MCAssembler &Asm,
+                                        const MCAsmLayout &Layout,
+                                        ArrayRef<WasmFunction> Functions) {
   if (Functions.empty())
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_CODE);
 
   encodeULEB128(Functions.size(), getStream());
 
void WasmObjectWriter::writeCodeSection(const MCAssembler &Asm,
   }
 
   // Apply fixups.
   applyRelocations(CodeRelocations, Section.ContentsOffset);
 
   endSection(Section);
 }
 
-void WasmObjectWriter::writeDataSection(
-    const SmallVector<WasmDataSegment, 4> &Segments) {
+void WasmObjectWriter::writeDataSection(ArrayRef<WasmDataSegment> Segments) {
   if (Segments.empty())
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_DATA);
 
   encodeULEB128(Segments.size(), getStream()); // count
 
void WasmObjectWriter::writeDataSection(ArrayRef<WasmDataSegment> Segments) {
 
   // Apply fixups.
   applyRelocations(DataRelocations, Section.ContentsOffset);
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeNameSection(
-    const SmallVector<WasmFunction, 4> &Functions,
-    const SmallVector<WasmImport, 4> &Imports,
+    ArrayRef<WasmFunction> Functions,
+    ArrayRef<WasmImport> Imports,
     unsigned NumFuncImports) {
   uint32_t TotalFunctions = NumFuncImports + Functions.size();
   if (TotalFunctions == 0)
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_CUSTOM, "name");
   SectionBookkeeping SubSection;