2017-03-31 03:44:09 +08:00
|
|
|
//===------ utils/wasm2yaml.cpp - obj2yaml conversion tool ------*- C++ -*-===//
|
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2017-03-31 03:44:09 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "obj2yaml.h"
|
|
|
|
#include "llvm/Object/COFF.h"
|
|
|
|
#include "llvm/ObjectYAML/WasmYAML.h"
|
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
|
|
#include "llvm/Support/YAMLTraits.h"
|
|
|
|
|
|
|
|
using namespace llvm;
|
2017-06-20 12:04:59 +08:00
|
|
|
using object::WasmSection;
|
2017-03-31 03:44:09 +08:00
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
class WasmDumper {
|
|
|
|
const object::WasmObjectFile &Obj;
|
|
|
|
|
|
|
|
public:
|
|
|
|
WasmDumper(const object::WasmObjectFile &O) : Obj(O) {}
|
2017-06-20 12:04:59 +08:00
|
|
|
|
2017-03-31 03:44:09 +08:00
|
|
|
ErrorOr<WasmYAML::Object *> dump();
|
2017-06-20 12:04:59 +08:00
|
|
|
|
|
|
|
std::unique_ptr<WasmYAML::CustomSection>
|
|
|
|
dumpCustomSection(const WasmSection &WasmSec);
|
2017-03-31 03:44:09 +08:00
|
|
|
};
|
|
|
|
|
2017-06-20 12:04:59 +08:00
|
|
|
} // namespace
|
|
|
|
|
[WebAssembly] clang-tidy (NFC)
Summary:
This patch fixes clang-tidy warnings on wasm-only files.
The list of checks used is:
`-*,clang-diagnostic-*,llvm-*,misc-*,-misc-unused-parameters,readability-identifier-naming,modernize-*`
(LLVM's default .clang-tidy list is the same except it does not have
`modernize-*`. But I've seen in multiple CLs in LLVM the modernize style
was recommended and code was fixed based on the style, so I added it as
well.)
The common fixes are:
- Variable names start with an uppercase letter
- Function names start with a lowercase letter
- Use `auto` when you use casts so the type is evident
- Use inline initialization for class member variables
- Use `= default` for empty constructors / destructors
- Use `using` in place of `typedef`
Reviewers: sbc100, tlively, aardappel
Subscribers: dschuff, sunfish, jgravelle-google, yurydelendik, kripken, MatzeB, mgorny, rupprecht, llvm-commits
Differential Revision: https://reviews.llvm.org/D57500
llvm-svn: 353075
2019-02-05 03:13:39 +08:00
|
|
|
static WasmYAML::Table makeTable(const wasm::WasmTable &Table) {
|
2017-05-10 07:48:41 +08:00
|
|
|
WasmYAML::Table T;
|
|
|
|
T.ElemType = Table.ElemType;
|
|
|
|
T.TableLimits.Flags = Table.Limits.Flags;
|
|
|
|
T.TableLimits.Initial = Table.Limits.Initial;
|
|
|
|
T.TableLimits.Maximum = Table.Limits.Maximum;
|
|
|
|
return T;
|
|
|
|
}
|
|
|
|
|
[WebAssembly] clang-tidy (NFC)
Summary:
This patch fixes clang-tidy warnings on wasm-only files.
The list of checks used is:
`-*,clang-diagnostic-*,llvm-*,misc-*,-misc-unused-parameters,readability-identifier-naming,modernize-*`
(LLVM's default .clang-tidy list is the same except it does not have
`modernize-*`. But I've seen in multiple CLs in LLVM the modernize style
was recommended and code was fixed based on the style, so I added it as
well.)
The common fixes are:
- Variable names start with an uppercase letter
- Function names start with a lowercase letter
- Use `auto` when you use casts so the type is evident
- Use inline initialization for class member variables
- Use `= default` for empty constructors / destructors
- Use `using` in place of `typedef`
Reviewers: sbc100, tlively, aardappel
Subscribers: dschuff, sunfish, jgravelle-google, yurydelendik, kripken, MatzeB, mgorny, rupprecht, llvm-commits
Differential Revision: https://reviews.llvm.org/D57500
llvm-svn: 353075
2019-02-05 03:13:39 +08:00
|
|
|
static WasmYAML::Limits makeLimits(const wasm::WasmLimits &Limits) {
|
2017-05-10 07:48:41 +08:00
|
|
|
WasmYAML::Limits L;
|
|
|
|
L.Flags = Limits.Flags;
|
|
|
|
L.Initial = Limits.Initial;
|
|
|
|
L.Maximum = Limits.Maximum;
|
|
|
|
return L;
|
|
|
|
}
|
|
|
|
|
2018-09-05 09:27:38 +08:00
|
|
|
std::unique_ptr<WasmYAML::CustomSection>
|
|
|
|
WasmDumper::dumpCustomSection(const WasmSection &WasmSec) {
|
2017-06-20 12:04:59 +08:00
|
|
|
std::unique_ptr<WasmYAML::CustomSection> CustomSec;
|
2018-11-15 02:36:24 +08:00
|
|
|
if (WasmSec.Name == "dylink") {
|
|
|
|
std::unique_ptr<WasmYAML::DylinkSection> DylinkSec =
|
|
|
|
make_unique<WasmYAML::DylinkSection>();
|
|
|
|
const wasm::WasmDylinkInfo& Info = Obj.dylinkInfo();
|
|
|
|
DylinkSec->MemorySize = Info.MemorySize;
|
|
|
|
DylinkSec->MemoryAlignment = Info.MemoryAlignment;
|
|
|
|
DylinkSec->TableSize = Info.TableSize;
|
|
|
|
DylinkSec->TableAlignment = Info.TableAlignment;
|
2018-12-13 07:40:58 +08:00
|
|
|
DylinkSec->Needed = Info.Needed;
|
2018-11-15 02:36:24 +08:00
|
|
|
CustomSec = std::move(DylinkSec);
|
|
|
|
} else if (WasmSec.Name == "name") {
|
2018-09-05 09:27:38 +08:00
|
|
|
std::unique_ptr<WasmYAML::NameSection> NameSec =
|
|
|
|
make_unique<WasmYAML::NameSection>();
|
|
|
|
for (const llvm::wasm::WasmFunctionName &Func : Obj.debugNames()) {
|
2017-06-20 12:04:59 +08:00
|
|
|
WasmYAML::NameEntry NameEntry;
|
2018-01-18 03:28:43 +08:00
|
|
|
NameEntry.Name = Func.Name;
|
|
|
|
NameEntry.Index = Func.Index;
|
2017-06-20 12:04:59 +08:00
|
|
|
NameSec->FunctionNames.push_back(NameEntry);
|
|
|
|
}
|
|
|
|
CustomSec = std::move(NameSec);
|
|
|
|
} else if (WasmSec.Name == "linking") {
|
2018-09-05 09:27:38 +08:00
|
|
|
std::unique_ptr<WasmYAML::LinkingSection> LinkingSec =
|
|
|
|
make_unique<WasmYAML::LinkingSection>();
|
2018-04-27 02:15:32 +08:00
|
|
|
LinkingSec->Version = Obj.linkingData().Version;
|
|
|
|
|
2018-03-14 23:44:45 +08:00
|
|
|
ArrayRef<StringRef> Comdats = Obj.linkingData().Comdats;
|
|
|
|
for (StringRef ComdatName : Comdats)
|
2018-01-10 07:43:14 +08:00
|
|
|
LinkingSec->Comdats.emplace_back(WasmYAML::Comdat{ComdatName, {}});
|
|
|
|
for (auto &Func : Obj.functions()) {
|
2018-03-14 23:44:45 +08:00
|
|
|
if (Func.Comdat != UINT32_MAX) {
|
|
|
|
LinkingSec->Comdats[Func.Comdat].Entries.emplace_back(
|
2018-09-05 09:27:38 +08:00
|
|
|
WasmYAML::ComdatEntry{wasm::WASM_COMDAT_FUNCTION, Func.Index});
|
2018-01-10 07:43:14 +08:00
|
|
|
}
|
|
|
|
}
|
2018-04-27 02:15:32 +08:00
|
|
|
|
2018-01-10 07:43:14 +08:00
|
|
|
uint32_t SegmentIndex = 0;
|
2017-09-21 03:03:35 +08:00
|
|
|
for (const object::WasmSegment &Segment : Obj.dataSegments()) {
|
|
|
|
if (!Segment.Data.Name.empty()) {
|
2017-09-30 00:50:08 +08:00
|
|
|
WasmYAML::SegmentInfo SegmentInfo;
|
|
|
|
SegmentInfo.Name = Segment.Data.Name;
|
2018-01-10 07:43:14 +08:00
|
|
|
SegmentInfo.Index = SegmentIndex;
|
2017-09-30 00:50:08 +08:00
|
|
|
SegmentInfo.Alignment = Segment.Data.Alignment;
|
|
|
|
SegmentInfo.Flags = Segment.Data.Flags;
|
|
|
|
LinkingSec->SegmentInfos.push_back(SegmentInfo);
|
2017-09-21 03:03:35 +08:00
|
|
|
}
|
2018-03-14 23:44:45 +08:00
|
|
|
if (Segment.Data.Comdat != UINT32_MAX) {
|
|
|
|
LinkingSec->Comdats[Segment.Data.Comdat].Entries.emplace_back(
|
2018-01-10 07:43:14 +08:00
|
|
|
WasmYAML::ComdatEntry{wasm::WASM_COMDAT_DATA, SegmentIndex});
|
|
|
|
}
|
|
|
|
SegmentIndex++;
|
2017-09-21 03:03:35 +08:00
|
|
|
}
|
2018-04-27 02:15:32 +08:00
|
|
|
|
2018-02-23 13:08:34 +08:00
|
|
|
uint32_t SymbolIndex = 0;
|
|
|
|
for (const wasm::WasmSymbolInfo &Symbol : Obj.linkingData().SymbolTable) {
|
|
|
|
WasmYAML::SymbolInfo Info;
|
|
|
|
Info.Index = SymbolIndex++;
|
|
|
|
Info.Kind = static_cast<uint32_t>(Symbol.Kind);
|
|
|
|
Info.Name = Symbol.Name;
|
|
|
|
Info.Flags = Symbol.Flags;
|
|
|
|
switch (Symbol.Kind) {
|
|
|
|
case wasm::WASM_SYMBOL_TYPE_DATA:
|
|
|
|
Info.DataRef = Symbol.DataRef;
|
|
|
|
break;
|
|
|
|
case wasm::WASM_SYMBOL_TYPE_FUNCTION:
|
|
|
|
case wasm::WASM_SYMBOL_TYPE_GLOBAL:
|
2018-11-14 10:46:21 +08:00
|
|
|
case wasm::WASM_SYMBOL_TYPE_EVENT:
|
2018-02-23 13:08:34 +08:00
|
|
|
Info.ElementIndex = Symbol.ElementIndex;
|
|
|
|
break;
|
2018-04-27 03:27:28 +08:00
|
|
|
case wasm::WASM_SYMBOL_TYPE_SECTION:
|
|
|
|
Info.ElementIndex = Symbol.ElementIndex;
|
|
|
|
break;
|
2017-06-20 12:04:59 +08:00
|
|
|
}
|
2018-02-23 13:08:34 +08:00
|
|
|
LinkingSec->SymbolTable.emplace_back(Info);
|
2017-06-20 12:04:59 +08:00
|
|
|
}
|
2018-04-27 02:15:32 +08:00
|
|
|
|
2017-12-15 05:10:03 +08:00
|
|
|
for (const wasm::WasmInitFunc &Func : Obj.linkingData().InitFunctions) {
|
2018-02-23 13:08:34 +08:00
|
|
|
WasmYAML::InitFunction F{Func.Priority, Func.Symbol};
|
2017-12-15 05:10:03 +08:00
|
|
|
LinkingSec->InitFunctions.emplace_back(F);
|
|
|
|
}
|
2018-04-27 02:15:32 +08:00
|
|
|
|
2017-06-20 12:04:59 +08:00
|
|
|
CustomSec = std::move(LinkingSec);
|
2019-01-17 10:29:55 +08:00
|
|
|
} else if (WasmSec.Name == "producers") {
|
|
|
|
std::unique_ptr<WasmYAML::ProducersSection> ProducersSec =
|
|
|
|
make_unique<WasmYAML::ProducersSection>();
|
|
|
|
const llvm::wasm::WasmProducerInfo &Info = Obj.getProducerInfo();
|
|
|
|
for (auto &E : Info.Languages) {
|
|
|
|
WasmYAML::ProducerEntry Producer;
|
|
|
|
Producer.Name = E.first;
|
|
|
|
Producer.Version = E.second;
|
|
|
|
ProducersSec->Languages.push_back(Producer);
|
|
|
|
}
|
|
|
|
for (auto &E : Info.Tools) {
|
|
|
|
WasmYAML::ProducerEntry Producer;
|
|
|
|
Producer.Name = E.first;
|
|
|
|
Producer.Version = E.second;
|
|
|
|
ProducersSec->Tools.push_back(Producer);
|
|
|
|
}
|
|
|
|
for (auto &E : Info.SDKs) {
|
|
|
|
WasmYAML::ProducerEntry Producer;
|
|
|
|
Producer.Name = E.first;
|
|
|
|
Producer.Version = E.second;
|
|
|
|
ProducersSec->SDKs.push_back(Producer);
|
|
|
|
}
|
|
|
|
CustomSec = std::move(ProducersSec);
|
2017-06-20 12:04:59 +08:00
|
|
|
} else {
|
|
|
|
CustomSec = make_unique<WasmYAML::CustomSection>(WasmSec.Name);
|
|
|
|
}
|
|
|
|
CustomSec->Payload = yaml::BinaryRef(WasmSec.Content);
|
|
|
|
return CustomSec;
|
|
|
|
}
|
|
|
|
|
2017-03-31 03:44:09 +08:00
|
|
|
ErrorOr<WasmYAML::Object *> WasmDumper::dump() {
|
|
|
|
auto Y = make_unique<WasmYAML::Object>();
|
|
|
|
|
|
|
|
// Dump header
|
|
|
|
Y->Header.Version = Obj.getHeader().Version;
|
|
|
|
|
|
|
|
// Dump sections
|
|
|
|
for (const auto &Sec : Obj.sections()) {
|
2017-06-20 12:04:59 +08:00
|
|
|
const WasmSection &WasmSec = Obj.getWasmSection(Sec);
|
2017-03-31 03:44:09 +08:00
|
|
|
std::unique_ptr<WasmYAML::Section> S;
|
|
|
|
switch (WasmSec.Type) {
|
|
|
|
case wasm::WASM_SEC_CUSTOM: {
|
|
|
|
if (WasmSec.Name.startswith("reloc.")) {
|
|
|
|
// Relocations are attached the sections they apply to rather than
|
|
|
|
// being represented as a custom section in the YAML output.
|
|
|
|
continue;
|
|
|
|
}
|
2017-06-20 12:04:59 +08:00
|
|
|
S = dumpCustomSection(WasmSec);
|
2017-03-31 03:44:09 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case wasm::WASM_SEC_TYPE: {
|
|
|
|
auto TypeSec = make_unique<WasmYAML::TypeSection>();
|
|
|
|
uint32_t Index = 0;
|
|
|
|
for (const auto &FunctionSig : Obj.types()) {
|
|
|
|
WasmYAML::Signature Sig;
|
|
|
|
Sig.Index = Index++;
|
2018-10-04 06:22:48 +08:00
|
|
|
Sig.ReturnType = wasm::WASM_TYPE_NORESULT;
|
|
|
|
assert(FunctionSig.Returns.size() <= 1 &&
|
|
|
|
"Functions with multiple returns are not supported");
|
|
|
|
if (FunctionSig.Returns.size())
|
|
|
|
Sig.ReturnType = static_cast<uint32_t>(FunctionSig.Returns[0]);
|
|
|
|
for (const auto &ParamType : FunctionSig.Params)
|
[WebAssembly] clang-tidy (NFC)
Summary:
This patch fixes clang-tidy warnings on wasm-only files.
The list of checks used is:
`-*,clang-diagnostic-*,llvm-*,misc-*,-misc-unused-parameters,readability-identifier-naming,modernize-*`
(LLVM's default .clang-tidy list is the same except it does not have
`modernize-*`. But I've seen in multiple CLs in LLVM the modernize style
was recommended and code was fixed based on the style, so I added it as
well.)
The common fixes are:
- Variable names start with an uppercase letter
- Function names start with a lowercase letter
- Use `auto` when you use casts so the type is evident
- Use inline initialization for class member variables
- Use `= default` for empty constructors / destructors
- Use `using` in place of `typedef`
Reviewers: sbc100, tlively, aardappel
Subscribers: dschuff, sunfish, jgravelle-google, yurydelendik, kripken, MatzeB, mgorny, rupprecht, llvm-commits
Differential Revision: https://reviews.llvm.org/D57500
llvm-svn: 353075
2019-02-05 03:13:39 +08:00
|
|
|
Sig.ParamTypes.emplace_back(static_cast<uint32_t>(ParamType));
|
2017-03-31 03:44:09 +08:00
|
|
|
TypeSec->Signatures.push_back(Sig);
|
|
|
|
}
|
|
|
|
S = std::move(TypeSec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case wasm::WASM_SEC_IMPORT: {
|
|
|
|
auto ImportSec = make_unique<WasmYAML::ImportSection>();
|
|
|
|
for (auto &Import : Obj.imports()) {
|
2017-05-10 07:48:41 +08:00
|
|
|
WasmYAML::Import Im;
|
|
|
|
Im.Module = Import.Module;
|
|
|
|
Im.Field = Import.Field;
|
|
|
|
Im.Kind = Import.Kind;
|
|
|
|
switch (Im.Kind) {
|
|
|
|
case wasm::WASM_EXTERNAL_FUNCTION:
|
|
|
|
Im.SigIndex = Import.SigIndex;
|
|
|
|
break;
|
|
|
|
case wasm::WASM_EXTERNAL_GLOBAL:
|
2017-05-10 08:14:04 +08:00
|
|
|
Im.GlobalImport.Type = Import.Global.Type;
|
|
|
|
Im.GlobalImport.Mutable = Import.Global.Mutable;
|
2017-05-10 07:48:41 +08:00
|
|
|
break;
|
2018-11-14 10:46:21 +08:00
|
|
|
case wasm::WASM_EXTERNAL_EVENT:
|
|
|
|
Im.EventImport.Attribute = Import.Event.Attribute;
|
|
|
|
Im.EventImport.SigIndex = Import.Event.SigIndex;
|
|
|
|
break;
|
2017-05-10 07:48:41 +08:00
|
|
|
case wasm::WASM_EXTERNAL_TABLE:
|
[WebAssembly] clang-tidy (NFC)
Summary:
This patch fixes clang-tidy warnings on wasm-only files.
The list of checks used is:
`-*,clang-diagnostic-*,llvm-*,misc-*,-misc-unused-parameters,readability-identifier-naming,modernize-*`
(LLVM's default .clang-tidy list is the same except it does not have
`modernize-*`. But I've seen in multiple CLs in LLVM the modernize style
was recommended and code was fixed based on the style, so I added it as
well.)
The common fixes are:
- Variable names start with an uppercase letter
- Function names start with a lowercase letter
- Use `auto` when you use casts so the type is evident
- Use inline initialization for class member variables
- Use `= default` for empty constructors / destructors
- Use `using` in place of `typedef`
Reviewers: sbc100, tlively, aardappel
Subscribers: dschuff, sunfish, jgravelle-google, yurydelendik, kripken, MatzeB, mgorny, rupprecht, llvm-commits
Differential Revision: https://reviews.llvm.org/D57500
llvm-svn: 353075
2019-02-05 03:13:39 +08:00
|
|
|
Im.TableImport = makeTable(Import.Table);
|
2017-05-10 07:48:41 +08:00
|
|
|
break;
|
|
|
|
case wasm::WASM_EXTERNAL_MEMORY:
|
[WebAssembly] clang-tidy (NFC)
Summary:
This patch fixes clang-tidy warnings on wasm-only files.
The list of checks used is:
`-*,clang-diagnostic-*,llvm-*,misc-*,-misc-unused-parameters,readability-identifier-naming,modernize-*`
(LLVM's default .clang-tidy list is the same except it does not have
`modernize-*`. But I've seen in multiple CLs in LLVM the modernize style
was recommended and code was fixed based on the style, so I added it as
well.)
The common fixes are:
- Variable names start with an uppercase letter
- Function names start with a lowercase letter
- Use `auto` when you use casts so the type is evident
- Use inline initialization for class member variables
- Use `= default` for empty constructors / destructors
- Use `using` in place of `typedef`
Reviewers: sbc100, tlively, aardappel
Subscribers: dschuff, sunfish, jgravelle-google, yurydelendik, kripken, MatzeB, mgorny, rupprecht, llvm-commits
Differential Revision: https://reviews.llvm.org/D57500
llvm-svn: 353075
2019-02-05 03:13:39 +08:00
|
|
|
Im.Memory = makeLimits(Import.Memory);
|
2017-05-10 07:48:41 +08:00
|
|
|
break;
|
2017-03-31 03:44:09 +08:00
|
|
|
}
|
2017-05-10 07:48:41 +08:00
|
|
|
ImportSec->Imports.push_back(Im);
|
2017-03-31 03:44:09 +08:00
|
|
|
}
|
|
|
|
S = std::move(ImportSec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case wasm::WASM_SEC_FUNCTION: {
|
|
|
|
auto FuncSec = make_unique<WasmYAML::FunctionSection>();
|
|
|
|
for (const auto &Func : Obj.functionTypes()) {
|
|
|
|
FuncSec->FunctionTypes.push_back(Func);
|
|
|
|
}
|
|
|
|
S = std::move(FuncSec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case wasm::WASM_SEC_TABLE: {
|
|
|
|
auto TableSec = make_unique<WasmYAML::TableSection>();
|
2017-05-10 07:48:41 +08:00
|
|
|
for (const wasm::WasmTable &Table : Obj.tables()) {
|
[WebAssembly] clang-tidy (NFC)
Summary:
This patch fixes clang-tidy warnings on wasm-only files.
The list of checks used is:
`-*,clang-diagnostic-*,llvm-*,misc-*,-misc-unused-parameters,readability-identifier-naming,modernize-*`
(LLVM's default .clang-tidy list is the same except it does not have
`modernize-*`. But I've seen in multiple CLs in LLVM the modernize style
was recommended and code was fixed based on the style, so I added it as
well.)
The common fixes are:
- Variable names start with an uppercase letter
- Function names start with a lowercase letter
- Use `auto` when you use casts so the type is evident
- Use inline initialization for class member variables
- Use `= default` for empty constructors / destructors
- Use `using` in place of `typedef`
Reviewers: sbc100, tlively, aardappel
Subscribers: dschuff, sunfish, jgravelle-google, yurydelendik, kripken, MatzeB, mgorny, rupprecht, llvm-commits
Differential Revision: https://reviews.llvm.org/D57500
llvm-svn: 353075
2019-02-05 03:13:39 +08:00
|
|
|
TableSec->Tables.push_back(makeTable(Table));
|
2017-03-31 03:44:09 +08:00
|
|
|
}
|
|
|
|
S = std::move(TableSec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case wasm::WASM_SEC_MEMORY: {
|
|
|
|
auto MemorySec = make_unique<WasmYAML::MemorySection>();
|
2017-05-10 07:48:41 +08:00
|
|
|
for (const wasm::WasmLimits &Memory : Obj.memories()) {
|
[WebAssembly] clang-tidy (NFC)
Summary:
This patch fixes clang-tidy warnings on wasm-only files.
The list of checks used is:
`-*,clang-diagnostic-*,llvm-*,misc-*,-misc-unused-parameters,readability-identifier-naming,modernize-*`
(LLVM's default .clang-tidy list is the same except it does not have
`modernize-*`. But I've seen in multiple CLs in LLVM the modernize style
was recommended and code was fixed based on the style, so I added it as
well.)
The common fixes are:
- Variable names start with an uppercase letter
- Function names start with a lowercase letter
- Use `auto` when you use casts so the type is evident
- Use inline initialization for class member variables
- Use `= default` for empty constructors / destructors
- Use `using` in place of `typedef`
Reviewers: sbc100, tlively, aardappel
Subscribers: dschuff, sunfish, jgravelle-google, yurydelendik, kripken, MatzeB, mgorny, rupprecht, llvm-commits
Differential Revision: https://reviews.llvm.org/D57500
llvm-svn: 353075
2019-02-05 03:13:39 +08:00
|
|
|
MemorySec->Memories.push_back(makeLimits(Memory));
|
2017-03-31 03:44:09 +08:00
|
|
|
}
|
|
|
|
S = std::move(MemorySec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case wasm::WASM_SEC_GLOBAL: {
|
|
|
|
auto GlobalSec = make_unique<WasmYAML::GlobalSection>();
|
|
|
|
for (auto &Global : Obj.globals()) {
|
|
|
|
WasmYAML::Global G;
|
2018-01-10 05:38:53 +08:00
|
|
|
G.Index = Global.Index;
|
2018-02-01 03:50:14 +08:00
|
|
|
G.Type = Global.Type.Type;
|
|
|
|
G.Mutable = Global.Type.Mutable;
|
2017-03-31 03:44:09 +08:00
|
|
|
G.InitExpr = Global.InitExpr;
|
|
|
|
GlobalSec->Globals.push_back(G);
|
|
|
|
}
|
|
|
|
S = std::move(GlobalSec);
|
|
|
|
break;
|
|
|
|
}
|
2018-11-14 10:46:21 +08:00
|
|
|
case wasm::WASM_SEC_EVENT: {
|
|
|
|
auto EventSec = make_unique<WasmYAML::EventSection>();
|
|
|
|
for (auto &Event : Obj.events()) {
|
|
|
|
WasmYAML::Event E;
|
|
|
|
E.Index = Event.Index;
|
|
|
|
E.Attribute = Event.Type.Attribute;
|
|
|
|
E.SigIndex = Event.Type.SigIndex;
|
|
|
|
EventSec->Events.push_back(E);
|
|
|
|
}
|
|
|
|
S = std::move(EventSec);
|
|
|
|
break;
|
|
|
|
}
|
2017-03-31 03:44:09 +08:00
|
|
|
case wasm::WASM_SEC_START: {
|
|
|
|
auto StartSec = make_unique<WasmYAML::StartSection>();
|
|
|
|
StartSec->StartFunction = Obj.startFunction();
|
|
|
|
S = std::move(StartSec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case wasm::WASM_SEC_EXPORT: {
|
|
|
|
auto ExportSec = make_unique<WasmYAML::ExportSection>();
|
|
|
|
for (auto &Export : Obj.exports()) {
|
|
|
|
WasmYAML::Export Ex;
|
|
|
|
Ex.Name = Export.Name;
|
|
|
|
Ex.Kind = Export.Kind;
|
|
|
|
Ex.Index = Export.Index;
|
|
|
|
ExportSec->Exports.push_back(Ex);
|
|
|
|
}
|
|
|
|
S = std::move(ExportSec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case wasm::WASM_SEC_ELEM: {
|
|
|
|
auto ElemSec = make_unique<WasmYAML::ElemSection>();
|
|
|
|
for (auto &Segment : Obj.elements()) {
|
|
|
|
WasmYAML::ElemSegment Seg;
|
|
|
|
Seg.TableIndex = Segment.TableIndex;
|
|
|
|
Seg.Offset = Segment.Offset;
|
|
|
|
for (auto &Func : Segment.Functions) {
|
|
|
|
Seg.Functions.push_back(Func);
|
|
|
|
}
|
|
|
|
ElemSec->Segments.push_back(Seg);
|
|
|
|
}
|
|
|
|
S = std::move(ElemSec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case wasm::WASM_SEC_CODE: {
|
|
|
|
auto CodeSec = make_unique<WasmYAML::CodeSection>();
|
|
|
|
for (auto &Func : Obj.functions()) {
|
|
|
|
WasmYAML::Function Function;
|
2018-01-10 05:38:53 +08:00
|
|
|
Function.Index = Func.Index;
|
2017-03-31 03:44:09 +08:00
|
|
|
for (auto &Local : Func.Locals) {
|
|
|
|
WasmYAML::LocalDecl LocalDecl;
|
|
|
|
LocalDecl.Type = Local.Type;
|
|
|
|
LocalDecl.Count = Local.Count;
|
|
|
|
Function.Locals.push_back(LocalDecl);
|
|
|
|
}
|
|
|
|
Function.Body = yaml::BinaryRef(Func.Body);
|
|
|
|
CodeSec->Functions.push_back(Function);
|
|
|
|
}
|
|
|
|
S = std::move(CodeSec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case wasm::WASM_SEC_DATA: {
|
|
|
|
auto DataSec = make_unique<WasmYAML::DataSection>();
|
2017-09-21 03:03:35 +08:00
|
|
|
for (const object::WasmSegment &Segment : Obj.dataSegments()) {
|
2017-03-31 03:44:09 +08:00
|
|
|
WasmYAML::DataSegment Seg;
|
2017-07-12 08:24:54 +08:00
|
|
|
Seg.SectionOffset = Segment.SectionOffset;
|
|
|
|
Seg.MemoryIndex = Segment.Data.MemoryIndex;
|
|
|
|
Seg.Offset = Segment.Data.Offset;
|
|
|
|
Seg.Content = yaml::BinaryRef(Segment.Data.Content);
|
2017-03-31 03:44:09 +08:00
|
|
|
DataSec->Segments.push_back(Seg);
|
|
|
|
}
|
|
|
|
S = std::move(DataSec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
llvm_unreachable("Unknown section type");
|
|
|
|
break;
|
|
|
|
}
|
2018-09-05 09:27:38 +08:00
|
|
|
for (const wasm::WasmRelocation &Reloc : WasmSec.Relocations) {
|
2017-03-31 03:44:09 +08:00
|
|
|
WasmYAML::Relocation R;
|
|
|
|
R.Type = Reloc.Type;
|
|
|
|
R.Index = Reloc.Index;
|
|
|
|
R.Offset = Reloc.Offset;
|
|
|
|
R.Addend = Reloc.Addend;
|
|
|
|
S->Relocations.push_back(R);
|
|
|
|
}
|
|
|
|
Y->Sections.push_back(std::move(S));
|
|
|
|
}
|
|
|
|
|
|
|
|
return Y.release();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::error_code wasm2yaml(raw_ostream &Out, const object::WasmObjectFile &Obj) {
|
|
|
|
WasmDumper Dumper(Obj);
|
|
|
|
ErrorOr<WasmYAML::Object *> YAMLOrErr = Dumper.dump();
|
|
|
|
if (std::error_code EC = YAMLOrErr.getError())
|
|
|
|
return EC;
|
|
|
|
|
|
|
|
std::unique_ptr<WasmYAML::Object> YAML(YAMLOrErr.get());
|
|
|
|
yaml::Output Yout(Out);
|
|
|
|
Yout << *YAML;
|
|
|
|
|
|
|
|
return std::error_code();
|
|
|
|
}
|