xref: /freebsd/contrib/llvm-project/llvm/lib/ObjectYAML/WasmEmitter.cpp (revision 8bcb0991864975618c09697b1aca10683346d9f0) 
1 //===- yaml2wasm - Convert YAML to a Wasm object file --------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 ///
9 /// \file
10 /// The Wasm component of yaml2obj.
11 ///
12 //===----------------------------------------------------------------------===//
13 //
14 
15 #include "llvm/Object/Wasm.h"
16 #include "llvm/ObjectYAML/ObjectYAML.h"
17 #include "llvm/ObjectYAML/yaml2obj.h"
18 #include "llvm/Support/Endian.h"
19 #include "llvm/Support/LEB128.h"
20 
21 using namespace llvm;
22 
23 namespace {
24 /// This parses a yaml stream that represents a Wasm object file.
25 /// See docs/yaml2obj for the yaml scheema.
26 class WasmWriter {
27 public:
28   WasmWriter(WasmYAML::Object &Obj, yaml::ErrorHandler EH)
29       : Obj(Obj), ErrHandler(EH) {}
30   bool writeWasm(raw_ostream &OS);
31 
32 private:
33   void writeRelocSection(raw_ostream &OS, WasmYAML::Section &Sec,
34                          uint32_t SectionIndex);
35 
36   void writeInitExpr(raw_ostream &OS, const wasm::WasmInitExpr &InitExpr);
37 
38   void writeSectionContent(raw_ostream &OS, WasmYAML::CustomSection &Section);
39   void writeSectionContent(raw_ostream &OS, WasmYAML::TypeSection &Section);
40   void writeSectionContent(raw_ostream &OS, WasmYAML::ImportSection &Section);
41   void writeSectionContent(raw_ostream &OS, WasmYAML::FunctionSection &Section);
42   void writeSectionContent(raw_ostream &OS, WasmYAML::TableSection &Section);
43   void writeSectionContent(raw_ostream &OS, WasmYAML::MemorySection &Section);
44   void writeSectionContent(raw_ostream &OS, WasmYAML::GlobalSection &Section);
45   void writeSectionContent(raw_ostream &OS, WasmYAML::EventSection &Section);
46   void writeSectionContent(raw_ostream &OS, WasmYAML::ExportSection &Section);
47   void writeSectionContent(raw_ostream &OS, WasmYAML::StartSection &Section);
48   void writeSectionContent(raw_ostream &OS, WasmYAML::ElemSection &Section);
49   void writeSectionContent(raw_ostream &OS, WasmYAML::CodeSection &Section);
50   void writeSectionContent(raw_ostream &OS, WasmYAML::DataSection &Section);
51   void writeSectionContent(raw_ostream &OS, WasmYAML::DataCountSection &Section);
52 
53   // Custom section types
54   void writeSectionContent(raw_ostream &OS, WasmYAML::DylinkSection &Section);
55   void writeSectionContent(raw_ostream &OS, WasmYAML::NameSection &Section);
56   void writeSectionContent(raw_ostream &OS, WasmYAML::LinkingSection &Section);
57   void writeSectionContent(raw_ostream &OS, WasmYAML::ProducersSection &Section);
58   void writeSectionContent(raw_ostream &OS,
59                           WasmYAML::TargetFeaturesSection &Section);
60   WasmYAML::Object &Obj;
61   uint32_t NumImportedFunctions = 0;
62   uint32_t NumImportedGlobals = 0;
63   uint32_t NumImportedEvents = 0;
64 
65   bool HasError = false;
66   yaml::ErrorHandler ErrHandler;
67   void reportError(const Twine &Msg);
68 };
69 
70 class SubSectionWriter {
71   raw_ostream &OS;
72   std::string OutString;
73   raw_string_ostream StringStream;
74 
75 public:
76   SubSectionWriter(raw_ostream &OS) : OS(OS), StringStream(OutString) {}
77 
78   void done() {
79     StringStream.flush();
80     encodeULEB128(OutString.size(), OS);
81     OS << OutString;
82     OutString.clear();
83   }
84 
85   raw_ostream &getStream() { return StringStream; }
86 };
87 
88 } // end anonymous namespace
89 
90 static int writeUint64(raw_ostream &OS, uint64_t Value) {
91   char Data[sizeof(Value)];
92   support::endian::write64le(Data, Value);
93   OS.write(Data, sizeof(Data));
94   return 0;
95 }
96 
97 static int writeUint32(raw_ostream &OS, uint32_t Value) {
98   char Data[sizeof(Value)];
99   support::endian::write32le(Data, Value);
100   OS.write(Data, sizeof(Data));
101   return 0;
102 }
103 
104 static int writeUint8(raw_ostream &OS, uint8_t Value) {
105   char Data[sizeof(Value)];
106   memcpy(Data, &Value, sizeof(Data));
107   OS.write(Data, sizeof(Data));
108   return 0;
109 }
110 
111 static int writeStringRef(const StringRef &Str, raw_ostream &OS) {
112   encodeULEB128(Str.size(), OS);
113   OS << Str;
114   return 0;
115 }
116 
117 static int writeLimits(const WasmYAML::Limits &Lim, raw_ostream &OS) {
118   writeUint8(OS, Lim.Flags);
119   encodeULEB128(Lim.Initial, OS);
120   if (Lim.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
121     encodeULEB128(Lim.Maximum, OS);
122   return 0;
123 }
124 
125 void WasmWriter::reportError(const Twine &Msg) {
126   ErrHandler(Msg);
127   HasError = true;
128 }
129 
130 void WasmWriter::writeInitExpr(raw_ostream &OS,
131                                const wasm::WasmInitExpr &InitExpr) {
132   writeUint8(OS, InitExpr.Opcode);
133   switch (InitExpr.Opcode) {
134   case wasm::WASM_OPCODE_I32_CONST:
135     encodeSLEB128(InitExpr.Value.Int32, OS);
136     break;
137   case wasm::WASM_OPCODE_I64_CONST:
138     encodeSLEB128(InitExpr.Value.Int64, OS);
139     break;
140   case wasm::WASM_OPCODE_F32_CONST:
141     writeUint32(OS, InitExpr.Value.Float32);
142     break;
143   case wasm::WASM_OPCODE_F64_CONST:
144     writeUint64(OS, InitExpr.Value.Float64);
145     break;
146   case wasm::WASM_OPCODE_GLOBAL_GET:
147     encodeULEB128(InitExpr.Value.Global, OS);
148     break;
149   default:
150     reportError("unknown opcode in init_expr: " + Twine(InitExpr.Opcode));
151     return;
152   }
153   writeUint8(OS, wasm::WASM_OPCODE_END);
154 }
155 
156 void WasmWriter::writeSectionContent(raw_ostream &OS,
157                                      WasmYAML::DylinkSection &Section) {
158   writeStringRef(Section.Name, OS);
159   encodeULEB128(Section.MemorySize, OS);
160   encodeULEB128(Section.MemoryAlignment, OS);
161   encodeULEB128(Section.TableSize, OS);
162   encodeULEB128(Section.TableAlignment, OS);
163   encodeULEB128(Section.Needed.size(), OS);
164   for (StringRef Needed : Section.Needed)
165     writeStringRef(Needed, OS);
166 }
167 
168 void WasmWriter::writeSectionContent(raw_ostream &OS,
169                                      WasmYAML::LinkingSection &Section) {
170   writeStringRef(Section.Name, OS);
171   encodeULEB128(Section.Version, OS);
172 
173   SubSectionWriter SubSection(OS);
174 
175   // SYMBOL_TABLE subsection
176   if (Section.SymbolTable.size()) {
177     writeUint8(OS, wasm::WASM_SYMBOL_TABLE);
178 
179     encodeULEB128(Section.SymbolTable.size(), SubSection.getStream());
180 #ifndef NDEBUG
181     uint32_t SymbolIndex = 0;
182 #endif
183     for (const WasmYAML::SymbolInfo &Info : Section.SymbolTable) {
184       assert(Info.Index == SymbolIndex++);
185       writeUint8(SubSection.getStream(), Info.Kind);
186       encodeULEB128(Info.Flags, SubSection.getStream());
187       switch (Info.Kind) {
188       case wasm::WASM_SYMBOL_TYPE_FUNCTION:
189       case wasm::WASM_SYMBOL_TYPE_GLOBAL:
190       case wasm::WASM_SYMBOL_TYPE_EVENT:
191         encodeULEB128(Info.ElementIndex, SubSection.getStream());
192         if ((Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0 ||
193             (Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0)
194           writeStringRef(Info.Name, SubSection.getStream());
195         break;
196       case wasm::WASM_SYMBOL_TYPE_DATA:
197         writeStringRef(Info.Name, SubSection.getStream());
198         if ((Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0) {
199           encodeULEB128(Info.DataRef.Segment, SubSection.getStream());
200           encodeULEB128(Info.DataRef.Offset, SubSection.getStream());
201           encodeULEB128(Info.DataRef.Size, SubSection.getStream());
202         }
203         break;
204       case wasm::WASM_SYMBOL_TYPE_SECTION:
205         encodeULEB128(Info.ElementIndex, SubSection.getStream());
206         break;
207       default:
208         llvm_unreachable("unexpected kind");
209       }
210     }
211 
212     SubSection.done();
213   }
214 
215   // SEGMENT_NAMES subsection
216   if (Section.SegmentInfos.size()) {
217     writeUint8(OS, wasm::WASM_SEGMENT_INFO);
218     encodeULEB128(Section.SegmentInfos.size(), SubSection.getStream());
219     for (const WasmYAML::SegmentInfo &SegmentInfo : Section.SegmentInfos) {
220       writeStringRef(SegmentInfo.Name, SubSection.getStream());
221       encodeULEB128(SegmentInfo.Alignment, SubSection.getStream());
222       encodeULEB128(SegmentInfo.Flags, SubSection.getStream());
223     }
224     SubSection.done();
225   }
226 
227   // INIT_FUNCS subsection
228   if (Section.InitFunctions.size()) {
229     writeUint8(OS, wasm::WASM_INIT_FUNCS);
230     encodeULEB128(Section.InitFunctions.size(), SubSection.getStream());
231     for (const WasmYAML::InitFunction &Func : Section.InitFunctions) {
232       encodeULEB128(Func.Priority, SubSection.getStream());
233       encodeULEB128(Func.Symbol, SubSection.getStream());
234     }
235     SubSection.done();
236   }
237 
238   // COMDAT_INFO subsection
239   if (Section.Comdats.size()) {
240     writeUint8(OS, wasm::WASM_COMDAT_INFO);
241     encodeULEB128(Section.Comdats.size(), SubSection.getStream());
242     for (const auto &C : Section.Comdats) {
243       writeStringRef(C.Name, SubSection.getStream());
244       encodeULEB128(0, SubSection.getStream()); // flags for future use
245       encodeULEB128(C.Entries.size(), SubSection.getStream());
246       for (const WasmYAML::ComdatEntry &Entry : C.Entries) {
247         writeUint8(SubSection.getStream(), Entry.Kind);
248         encodeULEB128(Entry.Index, SubSection.getStream());
249       }
250     }
251     SubSection.done();
252   }
253 }
254 
255 void WasmWriter::writeSectionContent(raw_ostream &OS,
256                                      WasmYAML::NameSection &Section) {
257   writeStringRef(Section.Name, OS);
258   if (Section.FunctionNames.size()) {
259     writeUint8(OS, wasm::WASM_NAMES_FUNCTION);
260 
261     SubSectionWriter SubSection(OS);
262 
263     encodeULEB128(Section.FunctionNames.size(), SubSection.getStream());
264     for (const WasmYAML::NameEntry &NameEntry : Section.FunctionNames) {
265       encodeULEB128(NameEntry.Index, SubSection.getStream());
266       writeStringRef(NameEntry.Name, SubSection.getStream());
267     }
268 
269     SubSection.done();
270   }
271 }
272 
273 void WasmWriter::writeSectionContent(raw_ostream &OS,
274                                      WasmYAML::ProducersSection &Section) {
275   writeStringRef(Section.Name, OS);
276   int Fields = int(!Section.Languages.empty()) + int(!Section.Tools.empty()) +
277                int(!Section.SDKs.empty());
278   if (Fields == 0)
279     return;
280   encodeULEB128(Fields, OS);
281   for (auto &Field : {std::make_pair(StringRef("language"), &Section.Languages),
282                       std::make_pair(StringRef("processed-by"), &Section.Tools),
283                       std::make_pair(StringRef("sdk"), &Section.SDKs)}) {
284     if (Field.second->empty())
285       continue;
286     writeStringRef(Field.first, OS);
287     encodeULEB128(Field.second->size(), OS);
288     for (auto &Entry : *Field.second) {
289       writeStringRef(Entry.Name, OS);
290       writeStringRef(Entry.Version, OS);
291     }
292   }
293 }
294 
295 void WasmWriter::writeSectionContent(raw_ostream &OS,
296                                      WasmYAML::TargetFeaturesSection &Section) {
297   writeStringRef(Section.Name, OS);
298   encodeULEB128(Section.Features.size(), OS);
299   for (auto &E : Section.Features) {
300     writeUint8(OS, E.Prefix);
301     writeStringRef(E.Name, OS);
302   }
303 }
304 
305 void WasmWriter::writeSectionContent(raw_ostream &OS,
306                                      WasmYAML::CustomSection &Section) {
307   if (auto S = dyn_cast<WasmYAML::DylinkSection>(&Section)) {
308     writeSectionContent(OS, *S);
309   } else if (auto S = dyn_cast<WasmYAML::NameSection>(&Section)) {
310     writeSectionContent(OS, *S);
311   } else if (auto S = dyn_cast<WasmYAML::LinkingSection>(&Section)) {
312     writeSectionContent(OS, *S);
313   } else if (auto S = dyn_cast<WasmYAML::ProducersSection>(&Section)) {
314     writeSectionContent(OS, *S);
315   } else if (auto S = dyn_cast<WasmYAML::TargetFeaturesSection>(&Section)) {
316     writeSectionContent(OS, *S);
317   } else {
318     writeStringRef(Section.Name, OS);
319     Section.Payload.writeAsBinary(OS);
320   }
321 }
322 
323 void WasmWriter::writeSectionContent(raw_ostream &OS,
324                                     WasmYAML::TypeSection &Section) {
325   encodeULEB128(Section.Signatures.size(), OS);
326   uint32_t ExpectedIndex = 0;
327   for (const WasmYAML::Signature &Sig : Section.Signatures) {
328     if (Sig.Index != ExpectedIndex) {
329       reportError("unexpected type index: " + Twine(Sig.Index));
330       return;
331     }
332     ++ExpectedIndex;
333     writeUint8(OS, Sig.Form);
334     encodeULEB128(Sig.ParamTypes.size(), OS);
335     for (auto ParamType : Sig.ParamTypes)
336       writeUint8(OS, ParamType);
337     encodeULEB128(Sig.ReturnTypes.size(), OS);
338     for (auto ReturnType : Sig.ReturnTypes)
339       writeUint8(OS, ReturnType);
340   }
341 }
342 
343 void WasmWriter::writeSectionContent(raw_ostream &OS,
344                                     WasmYAML::ImportSection &Section) {
345   encodeULEB128(Section.Imports.size(), OS);
346   for (const WasmYAML::Import &Import : Section.Imports) {
347     writeStringRef(Import.Module, OS);
348     writeStringRef(Import.Field, OS);
349     writeUint8(OS, Import.Kind);
350     switch (Import.Kind) {
351     case wasm::WASM_EXTERNAL_FUNCTION:
352       encodeULEB128(Import.SigIndex, OS);
353       NumImportedFunctions++;
354       break;
355     case wasm::WASM_EXTERNAL_GLOBAL:
356       writeUint8(OS, Import.GlobalImport.Type);
357       writeUint8(OS, Import.GlobalImport.Mutable);
358       NumImportedGlobals++;
359       break;
360     case wasm::WASM_EXTERNAL_EVENT:
361       writeUint32(OS, Import.EventImport.Attribute);
362       writeUint32(OS, Import.EventImport.SigIndex);
363       NumImportedGlobals++;
364       break;
365     case wasm::WASM_EXTERNAL_MEMORY:
366       writeLimits(Import.Memory, OS);
367       break;
368     case wasm::WASM_EXTERNAL_TABLE:
369       writeUint8(OS, Import.TableImport.ElemType);
370       writeLimits(Import.TableImport.TableLimits, OS);
371       break;
372     default:
373       reportError("unknown import type: " +Twine(Import.Kind));
374       return;
375     }
376   }
377 }
378 
379 void WasmWriter::writeSectionContent(raw_ostream &OS,
380                                      WasmYAML::FunctionSection &Section) {
381   encodeULEB128(Section.FunctionTypes.size(), OS);
382   for (uint32_t FuncType : Section.FunctionTypes)
383     encodeULEB128(FuncType, OS);
384 }
385 
386 void WasmWriter::writeSectionContent(raw_ostream &OS,
387                                     WasmYAML::ExportSection &Section) {
388   encodeULEB128(Section.Exports.size(), OS);
389   for (const WasmYAML::Export &Export : Section.Exports) {
390     writeStringRef(Export.Name, OS);
391     writeUint8(OS, Export.Kind);
392     encodeULEB128(Export.Index, OS);
393   }
394 }
395 
396 void WasmWriter::writeSectionContent(raw_ostream &OS,
397                                      WasmYAML::StartSection &Section) {
398   encodeULEB128(Section.StartFunction, OS);
399 }
400 
401 void WasmWriter::writeSectionContent(raw_ostream &OS,
402                                      WasmYAML::TableSection &Section) {
403   encodeULEB128(Section.Tables.size(), OS);
404   for (auto &Table : Section.Tables) {
405     writeUint8(OS, Table.ElemType);
406     writeLimits(Table.TableLimits, OS);
407   }
408 }
409 
410 void WasmWriter::writeSectionContent(raw_ostream &OS,
411                                      WasmYAML::MemorySection &Section) {
412   encodeULEB128(Section.Memories.size(), OS);
413   for (const WasmYAML::Limits &Mem : Section.Memories)
414     writeLimits(Mem, OS);
415 }
416 
417 void WasmWriter::writeSectionContent(raw_ostream &OS,
418                                      WasmYAML::GlobalSection &Section) {
419   encodeULEB128(Section.Globals.size(), OS);
420   uint32_t ExpectedIndex = NumImportedGlobals;
421   for (auto &Global : Section.Globals) {
422     if (Global.Index != ExpectedIndex) {
423       reportError("unexpected global index: " + Twine(Global.Index));
424       return;
425     }
426     ++ExpectedIndex;
427     writeUint8(OS, Global.Type);
428     writeUint8(OS, Global.Mutable);
429     writeInitExpr(OS, Global.InitExpr);
430   }
431 }
432 
433 void WasmWriter::writeSectionContent(raw_ostream &OS,
434                                     WasmYAML::EventSection &Section) {
435   encodeULEB128(Section.Events.size(), OS);
436   uint32_t ExpectedIndex = NumImportedEvents;
437   for (auto &Event : Section.Events) {
438     if (Event.Index != ExpectedIndex) {
439       reportError("unexpected event index: " + Twine(Event.Index));
440       return;
441     }
442     ++ExpectedIndex;
443     encodeULEB128(Event.Attribute, OS);
444     encodeULEB128(Event.SigIndex, OS);
445   }
446 }
447 
448 void WasmWriter::writeSectionContent(raw_ostream &OS,
449                                      WasmYAML::ElemSection &Section) {
450   encodeULEB128(Section.Segments.size(), OS);
451   for (auto &Segment : Section.Segments) {
452     encodeULEB128(Segment.TableIndex, OS);
453     writeInitExpr(OS, Segment.Offset);
454 
455     encodeULEB128(Segment.Functions.size(), OS);
456     for (auto &Function : Segment.Functions)
457       encodeULEB128(Function, OS);
458   }
459 }
460 
461 void WasmWriter::writeSectionContent(raw_ostream &OS,
462                                     WasmYAML::CodeSection &Section) {
463   encodeULEB128(Section.Functions.size(), OS);
464   uint32_t ExpectedIndex = NumImportedFunctions;
465   for (auto &Func : Section.Functions) {
466     std::string OutString;
467     raw_string_ostream StringStream(OutString);
468     if (Func.Index != ExpectedIndex) {
469       reportError("unexpected function index: " + Twine(Func.Index));
470       return;
471     }
472     ++ExpectedIndex;
473 
474     encodeULEB128(Func.Locals.size(), StringStream);
475     for (auto &LocalDecl : Func.Locals) {
476       encodeULEB128(LocalDecl.Count, StringStream);
477       writeUint8(StringStream, LocalDecl.Type);
478     }
479 
480     Func.Body.writeAsBinary(StringStream);
481 
482     // Write the section size followed by the content
483     StringStream.flush();
484     encodeULEB128(OutString.size(), OS);
485     OS << OutString;
486   }
487 }
488 
489 void WasmWriter::writeSectionContent(raw_ostream &OS,
490                                      WasmYAML::DataSection &Section) {
491   encodeULEB128(Section.Segments.size(), OS);
492   for (auto &Segment : Section.Segments) {
493     encodeULEB128(Segment.InitFlags, OS);
494     if (Segment.InitFlags & wasm::WASM_SEGMENT_HAS_MEMINDEX)
495       encodeULEB128(Segment.MemoryIndex, OS);
496     if ((Segment.InitFlags & wasm::WASM_SEGMENT_IS_PASSIVE) == 0)
497       writeInitExpr(OS, Segment.Offset);
498     encodeULEB128(Segment.Content.binary_size(), OS);
499     Segment.Content.writeAsBinary(OS);
500   }
501 }
502 
503 void WasmWriter::writeSectionContent(raw_ostream &OS,
504                                      WasmYAML::DataCountSection &Section) {
505   encodeULEB128(Section.Count, OS);
506 }
507 
508 void WasmWriter::writeRelocSection(raw_ostream &OS, WasmYAML::Section &Sec,
509                                   uint32_t SectionIndex) {
510   switch (Sec.Type) {
511   case wasm::WASM_SEC_CODE:
512     writeStringRef("reloc.CODE", OS);
513     break;
514   case wasm::WASM_SEC_DATA:
515     writeStringRef("reloc.DATA", OS);
516     break;
517   case wasm::WASM_SEC_CUSTOM: {
518     auto *CustomSection = cast<WasmYAML::CustomSection>(&Sec);
519     writeStringRef(("reloc." + CustomSection->Name).str(), OS);
520     break;
521   }
522   default:
523     llvm_unreachable("not yet implemented");
524   }
525 
526   encodeULEB128(SectionIndex, OS);
527   encodeULEB128(Sec.Relocations.size(), OS);
528 
529   for (auto Reloc : Sec.Relocations) {
530     writeUint8(OS, Reloc.Type);
531     encodeULEB128(Reloc.Offset, OS);
532     encodeULEB128(Reloc.Index, OS);
533     switch (Reloc.Type) {
534     case wasm::R_WASM_MEMORY_ADDR_LEB:
535     case wasm::R_WASM_MEMORY_ADDR_SLEB:
536     case wasm::R_WASM_MEMORY_ADDR_I32:
537     case wasm::R_WASM_FUNCTION_OFFSET_I32:
538     case wasm::R_WASM_SECTION_OFFSET_I32:
539       encodeULEB128(Reloc.Addend, OS);
540     }
541   }
542 }
543 
544 bool WasmWriter::writeWasm(raw_ostream &OS) {
545   // Write headers
546   OS.write(wasm::WasmMagic, sizeof(wasm::WasmMagic));
547   writeUint32(OS, Obj.Header.Version);
548 
549   // Write each section
550   llvm::object::WasmSectionOrderChecker Checker;
551   for (const std::unique_ptr<WasmYAML::Section> &Sec : Obj.Sections) {
552     StringRef SecName = "";
553     if (auto S = dyn_cast<WasmYAML::CustomSection>(Sec.get()))
554       SecName = S->Name;
555     if (!Checker.isValidSectionOrder(Sec->Type, SecName)) {
556       reportError("out of order section type: " + Twine(Sec->Type));
557       return false;
558     }
559     encodeULEB128(Sec->Type, OS);
560     std::string OutString;
561     raw_string_ostream StringStream(OutString);
562     if (auto S = dyn_cast<WasmYAML::CustomSection>(Sec.get()))
563       writeSectionContent(StringStream, *S);
564     else if (auto S = dyn_cast<WasmYAML::TypeSection>(Sec.get()))
565       writeSectionContent(StringStream, *S);
566     else if (auto S = dyn_cast<WasmYAML::ImportSection>(Sec.get()))
567       writeSectionContent(StringStream, *S);
568     else if (auto S = dyn_cast<WasmYAML::FunctionSection>(Sec.get()))
569       writeSectionContent(StringStream, *S);
570     else if (auto S = dyn_cast<WasmYAML::TableSection>(Sec.get()))
571       writeSectionContent(StringStream, *S);
572     else if (auto S = dyn_cast<WasmYAML::MemorySection>(Sec.get()))
573       writeSectionContent(StringStream, *S);
574     else if (auto S = dyn_cast<WasmYAML::GlobalSection>(Sec.get()))
575       writeSectionContent(StringStream, *S);
576     else if (auto S = dyn_cast<WasmYAML::EventSection>(Sec.get()))
577       writeSectionContent(StringStream, *S);
578     else if (auto S = dyn_cast<WasmYAML::ExportSection>(Sec.get()))
579       writeSectionContent(StringStream, *S);
580     else if (auto S = dyn_cast<WasmYAML::StartSection>(Sec.get()))
581       writeSectionContent(StringStream, *S);
582     else if (auto S = dyn_cast<WasmYAML::ElemSection>(Sec.get()))
583       writeSectionContent(StringStream, *S);
584     else if (auto S = dyn_cast<WasmYAML::CodeSection>(Sec.get()))
585       writeSectionContent(StringStream, *S);
586     else if (auto S = dyn_cast<WasmYAML::DataSection>(Sec.get()))
587       writeSectionContent(StringStream, *S);
588     else if (auto S = dyn_cast<WasmYAML::DataCountSection>(Sec.get()))
589       writeSectionContent(StringStream, *S);
590     else
591       reportError("unknown section type: " + Twine(Sec->Type));
592 
593     if (HasError)
594       return false;
595 
596     StringStream.flush();
597 
598     // Write the section size followed by the content
599     encodeULEB128(OutString.size(), OS);
600     OS << OutString;
601   }
602 
603   // write reloc sections for any section that have relocations
604   uint32_t SectionIndex = 0;
605   for (const std::unique_ptr<WasmYAML::Section> &Sec : Obj.Sections) {
606     if (Sec->Relocations.empty()) {
607       SectionIndex++;
608       continue;
609     }
610 
611     writeUint8(OS, wasm::WASM_SEC_CUSTOM);
612     std::string OutString;
613     raw_string_ostream StringStream(OutString);
614     writeRelocSection(StringStream, *Sec, SectionIndex++);
615     StringStream.flush();
616 
617     encodeULEB128(OutString.size(), OS);
618     OS << OutString;
619   }
620 
621   return true;
622 }
623 
624 namespace llvm {
625 namespace yaml {
626 
627 bool yaml2wasm(WasmYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH) {
628   WasmWriter Writer(Doc, EH);
629   return Writer.writeWasm(Out);
630 }
631 
632 } // namespace yaml
633 } // namespace llvm
634