1 //===------ utils/wasm2yaml.cpp - obj2yaml conversion tool ------*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
10 #include "llvm/Object/COFF.h"
11 #include "llvm/ObjectYAML/WasmYAML.h"
12 #include "llvm/Support/ErrorHandling.h"
13 #include "llvm/Support/YAMLTraits.h"
16 using object::WasmSection
;
21 const object::WasmObjectFile
&Obj
;
24 WasmDumper(const object::WasmObjectFile
&O
) : Obj(O
) {}
26 ErrorOr
<WasmYAML::Object
*> dump();
28 std::unique_ptr
<WasmYAML::CustomSection
>
29 dumpCustomSection(const WasmSection
&WasmSec
);
34 static WasmYAML::Table
makeTable(const wasm::WasmTable
&Table
) {
36 T
.ElemType
= Table
.ElemType
;
37 T
.TableLimits
.Flags
= Table
.Limits
.Flags
;
38 T
.TableLimits
.Initial
= Table
.Limits
.Initial
;
39 T
.TableLimits
.Maximum
= Table
.Limits
.Maximum
;
43 static WasmYAML::Limits
makeLimits(const wasm::WasmLimits
&Limits
) {
45 L
.Flags
= Limits
.Flags
;
46 L
.Initial
= Limits
.Initial
;
47 L
.Maximum
= Limits
.Maximum
;
51 std::unique_ptr
<WasmYAML::CustomSection
>
52 WasmDumper::dumpCustomSection(const WasmSection
&WasmSec
) {
53 std::unique_ptr
<WasmYAML::CustomSection
> CustomSec
;
54 if (WasmSec
.Name
== "dylink") {
55 std::unique_ptr
<WasmYAML::DylinkSection
> DylinkSec
=
56 std::make_unique
<WasmYAML::DylinkSection
>();
57 const wasm::WasmDylinkInfo
& Info
= Obj
.dylinkInfo();
58 DylinkSec
->MemorySize
= Info
.MemorySize
;
59 DylinkSec
->MemoryAlignment
= Info
.MemoryAlignment
;
60 DylinkSec
->TableSize
= Info
.TableSize
;
61 DylinkSec
->TableAlignment
= Info
.TableAlignment
;
62 DylinkSec
->Needed
= Info
.Needed
;
63 CustomSec
= std::move(DylinkSec
);
64 } else if (WasmSec
.Name
== "name") {
65 std::unique_ptr
<WasmYAML::NameSection
> NameSec
=
66 std::make_unique
<WasmYAML::NameSection
>();
67 for (const llvm::wasm::WasmFunctionName
&Func
: Obj
.debugNames()) {
68 WasmYAML::NameEntry NameEntry
;
69 NameEntry
.Name
= Func
.Name
;
70 NameEntry
.Index
= Func
.Index
;
71 NameSec
->FunctionNames
.push_back(NameEntry
);
73 CustomSec
= std::move(NameSec
);
74 } else if (WasmSec
.Name
== "linking") {
75 std::unique_ptr
<WasmYAML::LinkingSection
> LinkingSec
=
76 std::make_unique
<WasmYAML::LinkingSection
>();
77 LinkingSec
->Version
= Obj
.linkingData().Version
;
79 ArrayRef
<StringRef
> Comdats
= Obj
.linkingData().Comdats
;
80 for (StringRef ComdatName
: Comdats
)
81 LinkingSec
->Comdats
.emplace_back(WasmYAML::Comdat
{ComdatName
, {}});
82 for (auto &Func
: Obj
.functions()) {
83 if (Func
.Comdat
!= UINT32_MAX
) {
84 LinkingSec
->Comdats
[Func
.Comdat
].Entries
.emplace_back(
85 WasmYAML::ComdatEntry
{wasm::WASM_COMDAT_FUNCTION
, Func
.Index
});
89 uint32_t SegmentIndex
= 0;
90 for (const object::WasmSegment
&Segment
: Obj
.dataSegments()) {
91 if (!Segment
.Data
.Name
.empty()) {
92 WasmYAML::SegmentInfo SegmentInfo
;
93 SegmentInfo
.Name
= Segment
.Data
.Name
;
94 SegmentInfo
.Index
= SegmentIndex
;
95 SegmentInfo
.Alignment
= Segment
.Data
.Alignment
;
96 SegmentInfo
.Flags
= Segment
.Data
.LinkerFlags
;
97 LinkingSec
->SegmentInfos
.push_back(SegmentInfo
);
99 if (Segment
.Data
.Comdat
!= UINT32_MAX
) {
100 LinkingSec
->Comdats
[Segment
.Data
.Comdat
].Entries
.emplace_back(
101 WasmYAML::ComdatEntry
{wasm::WASM_COMDAT_DATA
, SegmentIndex
});
106 uint32_t SymbolIndex
= 0;
107 for (const wasm::WasmSymbolInfo
&Symbol
: Obj
.linkingData().SymbolTable
) {
108 WasmYAML::SymbolInfo Info
;
109 Info
.Index
= SymbolIndex
++;
110 Info
.Kind
= static_cast<uint32_t>(Symbol
.Kind
);
111 Info
.Name
= Symbol
.Name
;
112 Info
.Flags
= Symbol
.Flags
;
113 switch (Symbol
.Kind
) {
114 case wasm::WASM_SYMBOL_TYPE_DATA
:
115 Info
.DataRef
= Symbol
.DataRef
;
117 case wasm::WASM_SYMBOL_TYPE_FUNCTION
:
118 case wasm::WASM_SYMBOL_TYPE_GLOBAL
:
119 case wasm::WASM_SYMBOL_TYPE_EVENT
:
120 Info
.ElementIndex
= Symbol
.ElementIndex
;
122 case wasm::WASM_SYMBOL_TYPE_SECTION
:
123 Info
.ElementIndex
= Symbol
.ElementIndex
;
126 LinkingSec
->SymbolTable
.emplace_back(Info
);
129 for (const wasm::WasmInitFunc
&Func
: Obj
.linkingData().InitFunctions
) {
130 WasmYAML::InitFunction F
{Func
.Priority
, Func
.Symbol
};
131 LinkingSec
->InitFunctions
.emplace_back(F
);
134 CustomSec
= std::move(LinkingSec
);
135 } else if (WasmSec
.Name
== "producers") {
136 std::unique_ptr
<WasmYAML::ProducersSection
> ProducersSec
=
137 std::make_unique
<WasmYAML::ProducersSection
>();
138 const llvm::wasm::WasmProducerInfo
&Info
= Obj
.getProducerInfo();
139 for (auto &E
: Info
.Languages
) {
140 WasmYAML::ProducerEntry Producer
;
141 Producer
.Name
= E
.first
;
142 Producer
.Version
= E
.second
;
143 ProducersSec
->Languages
.push_back(Producer
);
145 for (auto &E
: Info
.Tools
) {
146 WasmYAML::ProducerEntry Producer
;
147 Producer
.Name
= E
.first
;
148 Producer
.Version
= E
.second
;
149 ProducersSec
->Tools
.push_back(Producer
);
151 for (auto &E
: Info
.SDKs
) {
152 WasmYAML::ProducerEntry Producer
;
153 Producer
.Name
= E
.first
;
154 Producer
.Version
= E
.second
;
155 ProducersSec
->SDKs
.push_back(Producer
);
157 CustomSec
= std::move(ProducersSec
);
158 } else if (WasmSec
.Name
== "target_features") {
159 std::unique_ptr
<WasmYAML::TargetFeaturesSection
> TargetFeaturesSec
=
160 std::make_unique
<WasmYAML::TargetFeaturesSection
>();
161 for (auto &E
: Obj
.getTargetFeatures()) {
162 WasmYAML::FeatureEntry Feature
;
163 Feature
.Prefix
= E
.Prefix
;
164 Feature
.Name
= E
.Name
;
165 TargetFeaturesSec
->Features
.push_back(Feature
);
167 CustomSec
= std::move(TargetFeaturesSec
);
169 CustomSec
= std::make_unique
<WasmYAML::CustomSection
>(WasmSec
.Name
);
171 CustomSec
->Payload
= yaml::BinaryRef(WasmSec
.Content
);
175 ErrorOr
<WasmYAML::Object
*> WasmDumper::dump() {
176 auto Y
= std::make_unique
<WasmYAML::Object
>();
179 Y
->Header
.Version
= Obj
.getHeader().Version
;
182 for (const auto &Sec
: Obj
.sections()) {
183 const WasmSection
&WasmSec
= Obj
.getWasmSection(Sec
);
184 std::unique_ptr
<WasmYAML::Section
> S
;
185 switch (WasmSec
.Type
) {
186 case wasm::WASM_SEC_CUSTOM
: {
187 if (WasmSec
.Name
.startswith("reloc.")) {
188 // Relocations are attached the sections they apply to rather than
189 // being represented as a custom section in the YAML output.
192 S
= dumpCustomSection(WasmSec
);
195 case wasm::WASM_SEC_TYPE
: {
196 auto TypeSec
= std::make_unique
<WasmYAML::TypeSection
>();
198 for (const auto &FunctionSig
: Obj
.types()) {
199 WasmYAML::Signature Sig
;
201 for (const auto &ParamType
: FunctionSig
.Params
)
202 Sig
.ParamTypes
.emplace_back(static_cast<uint32_t>(ParamType
));
203 for (const auto &ReturnType
: FunctionSig
.Returns
)
204 Sig
.ReturnTypes
.emplace_back(static_cast<uint32_t>(ReturnType
));
205 TypeSec
->Signatures
.push_back(Sig
);
207 S
= std::move(TypeSec
);
210 case wasm::WASM_SEC_IMPORT
: {
211 auto ImportSec
= std::make_unique
<WasmYAML::ImportSection
>();
212 for (auto &Import
: Obj
.imports()) {
214 Im
.Module
= Import
.Module
;
215 Im
.Field
= Import
.Field
;
216 Im
.Kind
= Import
.Kind
;
218 case wasm::WASM_EXTERNAL_FUNCTION
:
219 Im
.SigIndex
= Import
.SigIndex
;
221 case wasm::WASM_EXTERNAL_GLOBAL
:
222 Im
.GlobalImport
.Type
= Import
.Global
.Type
;
223 Im
.GlobalImport
.Mutable
= Import
.Global
.Mutable
;
225 case wasm::WASM_EXTERNAL_EVENT
:
226 Im
.EventImport
.Attribute
= Import
.Event
.Attribute
;
227 Im
.EventImport
.SigIndex
= Import
.Event
.SigIndex
;
229 case wasm::WASM_EXTERNAL_TABLE
:
230 Im
.TableImport
= makeTable(Import
.Table
);
232 case wasm::WASM_EXTERNAL_MEMORY
:
233 Im
.Memory
= makeLimits(Import
.Memory
);
236 ImportSec
->Imports
.push_back(Im
);
238 S
= std::move(ImportSec
);
241 case wasm::WASM_SEC_FUNCTION
: {
242 auto FuncSec
= std::make_unique
<WasmYAML::FunctionSection
>();
243 for (const auto &Func
: Obj
.functionTypes()) {
244 FuncSec
->FunctionTypes
.push_back(Func
);
246 S
= std::move(FuncSec
);
249 case wasm::WASM_SEC_TABLE
: {
250 auto TableSec
= std::make_unique
<WasmYAML::TableSection
>();
251 for (const wasm::WasmTable
&Table
: Obj
.tables()) {
252 TableSec
->Tables
.push_back(makeTable(Table
));
254 S
= std::move(TableSec
);
257 case wasm::WASM_SEC_MEMORY
: {
258 auto MemorySec
= std::make_unique
<WasmYAML::MemorySection
>();
259 for (const wasm::WasmLimits
&Memory
: Obj
.memories()) {
260 MemorySec
->Memories
.push_back(makeLimits(Memory
));
262 S
= std::move(MemorySec
);
265 case wasm::WASM_SEC_GLOBAL
: {
266 auto GlobalSec
= std::make_unique
<WasmYAML::GlobalSection
>();
267 for (auto &Global
: Obj
.globals()) {
269 G
.Index
= Global
.Index
;
270 G
.Type
= Global
.Type
.Type
;
271 G
.Mutable
= Global
.Type
.Mutable
;
272 G
.InitExpr
= Global
.InitExpr
;
273 GlobalSec
->Globals
.push_back(G
);
275 S
= std::move(GlobalSec
);
278 case wasm::WASM_SEC_EVENT
: {
279 auto EventSec
= std::make_unique
<WasmYAML::EventSection
>();
280 for (auto &Event
: Obj
.events()) {
282 E
.Index
= Event
.Index
;
283 E
.Attribute
= Event
.Type
.Attribute
;
284 E
.SigIndex
= Event
.Type
.SigIndex
;
285 EventSec
->Events
.push_back(E
);
287 S
= std::move(EventSec
);
290 case wasm::WASM_SEC_START
: {
291 auto StartSec
= std::make_unique
<WasmYAML::StartSection
>();
292 StartSec
->StartFunction
= Obj
.startFunction();
293 S
= std::move(StartSec
);
296 case wasm::WASM_SEC_EXPORT
: {
297 auto ExportSec
= std::make_unique
<WasmYAML::ExportSection
>();
298 for (auto &Export
: Obj
.exports()) {
300 Ex
.Name
= Export
.Name
;
301 Ex
.Kind
= Export
.Kind
;
302 Ex
.Index
= Export
.Index
;
303 ExportSec
->Exports
.push_back(Ex
);
305 S
= std::move(ExportSec
);
308 case wasm::WASM_SEC_ELEM
: {
309 auto ElemSec
= std::make_unique
<WasmYAML::ElemSection
>();
310 for (auto &Segment
: Obj
.elements()) {
311 WasmYAML::ElemSegment Seg
;
312 Seg
.TableIndex
= Segment
.TableIndex
;
313 Seg
.Offset
= Segment
.Offset
;
314 for (auto &Func
: Segment
.Functions
) {
315 Seg
.Functions
.push_back(Func
);
317 ElemSec
->Segments
.push_back(Seg
);
319 S
= std::move(ElemSec
);
322 case wasm::WASM_SEC_CODE
: {
323 auto CodeSec
= std::make_unique
<WasmYAML::CodeSection
>();
324 for (auto &Func
: Obj
.functions()) {
325 WasmYAML::Function Function
;
326 Function
.Index
= Func
.Index
;
327 for (auto &Local
: Func
.Locals
) {
328 WasmYAML::LocalDecl LocalDecl
;
329 LocalDecl
.Type
= Local
.Type
;
330 LocalDecl
.Count
= Local
.Count
;
331 Function
.Locals
.push_back(LocalDecl
);
333 Function
.Body
= yaml::BinaryRef(Func
.Body
);
334 CodeSec
->Functions
.push_back(Function
);
336 S
= std::move(CodeSec
);
339 case wasm::WASM_SEC_DATA
: {
340 auto DataSec
= std::make_unique
<WasmYAML::DataSection
>();
341 for (const object::WasmSegment
&Segment
: Obj
.dataSegments()) {
342 WasmYAML::DataSegment Seg
;
343 Seg
.SectionOffset
= Segment
.SectionOffset
;
344 Seg
.InitFlags
= Segment
.Data
.InitFlags
;
345 Seg
.MemoryIndex
= Segment
.Data
.MemoryIndex
;
346 Seg
.Offset
= Segment
.Data
.Offset
;
347 Seg
.Content
= yaml::BinaryRef(Segment
.Data
.Content
);
348 DataSec
->Segments
.push_back(Seg
);
350 S
= std::move(DataSec
);
353 case wasm::WASM_SEC_DATACOUNT
: {
354 auto DataCountSec
= std::make_unique
<WasmYAML::DataCountSection
>();
355 DataCountSec
->Count
= Obj
.dataSegments().size();
356 S
= std::move(DataCountSec
);
360 llvm_unreachable("Unknown section type");
363 for (const wasm::WasmRelocation
&Reloc
: WasmSec
.Relocations
) {
364 WasmYAML::Relocation R
;
366 R
.Index
= Reloc
.Index
;
367 R
.Offset
= Reloc
.Offset
;
368 R
.Addend
= Reloc
.Addend
;
369 S
->Relocations
.push_back(R
);
371 Y
->Sections
.push_back(std::move(S
));
377 std::error_code
wasm2yaml(raw_ostream
&Out
, const object::WasmObjectFile
&Obj
) {
378 WasmDumper
Dumper(Obj
);
379 ErrorOr
<WasmYAML::Object
*> YAMLOrErr
= Dumper
.dump();
380 if (std::error_code EC
= YAMLOrErr
.getError())
383 std::unique_ptr
<WasmYAML::Object
> YAML(YAMLOrErr
.get());
384 yaml::Output
Yout(Out
);
387 return std::error_code();