tools/obj2yaml/wasm2yaml.cpp

   1 //===------ utils/wasm2yaml.cpp - obj2yaml conversion tool ------*- C++ -*-===//
   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 #include "obj2yaml.h"
  10 #include "llvm/Object/COFF.h"
  11 #include "llvm/ObjectYAML/WasmYAML.h"
  12 #include "llvm/Support/ErrorHandling.h"
  13 #include "llvm/Support/YAMLTraits.h"
  14
  15 using namespace llvm;
  16 using object::WasmSection;
  17
  18 namespace {
  19
  20 class WasmDumper {
  21   const object::WasmObjectFile &Obj;
  22
  23 public:
  24   WasmDumper(const object::WasmObjectFile &O) : Obj(O) {}
  25
  26   ErrorOr<WasmYAML::Object *> dump();
  27
  28   std::unique_ptr<WasmYAML::CustomSection>
  29   dumpCustomSection(const WasmSection &WasmSec);
  30 };
  31
  32 } // namespace
  33
  34 static WasmYAML::Table makeTable(const wasm::WasmTable &Table) {
  35   WasmYAML::Table T;
  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;
  40   return T;
  41 }
  42
  43 static WasmYAML::Limits makeLimits(const wasm::WasmLimits &Limits) {
  44   WasmYAML::Limits L;
  45   L.Flags = Limits.Flags;
  46   L.Initial = Limits.Initial;
  47   L.Maximum = Limits.Maximum;
  48   return L;
  49 }
  50
  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);
  72     }
  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;
  78
  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});
  86       }
  87     }
  88
  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);
  98       }
  99       if (Segment.Data.Comdat != UINT32_MAX) {
 100         LinkingSec->Comdats[Segment.Data.Comdat].Entries.emplace_back(
 101             WasmYAML::ComdatEntry{wasm::WASM_COMDAT_DATA, SegmentIndex});
 102       }
 103       SegmentIndex++;
 104     }
 105
 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;
 116         break;
 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;
 121         break;
 122       case wasm::WASM_SYMBOL_TYPE_SECTION:
 123         Info.ElementIndex = Symbol.ElementIndex;
 124         break;
 125       }
 126       LinkingSec->SymbolTable.emplace_back(Info);
 127     }
 128
 129     for (const wasm::WasmInitFunc &Func : Obj.linkingData().InitFunctions) {
 130       WasmYAML::InitFunction F{Func.Priority, Func.Symbol};
 131       LinkingSec->InitFunctions.emplace_back(F);
 132     }
 133
 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);
 144     }
 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);
 150     }
 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);
 156     }
 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);
 166     }
 167     CustomSec = std::move(TargetFeaturesSec);
 168   } else {
 169     CustomSec = std::make_unique<WasmYAML::CustomSection>(WasmSec.Name);
 170   }
 171   CustomSec->Payload = yaml::BinaryRef(WasmSec.Content);
 172   return CustomSec;
 173 }
 174
 175 ErrorOr<WasmYAML::Object *> WasmDumper::dump() {
 176   auto Y = std::make_unique<WasmYAML::Object>();
 177
 178   // Dump header
 179   Y->Header.Version = Obj.getHeader().Version;
 180
 181   // Dump sections
 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.
 190         continue;
 191       }
 192       S = dumpCustomSection(WasmSec);
 193       break;
 194     }
 195     case wasm::WASM_SEC_TYPE: {
 196       auto TypeSec = std::make_unique<WasmYAML::TypeSection>();
 197       uint32_t Index = 0;
 198       for (const auto &FunctionSig : Obj.types()) {
 199         WasmYAML::Signature Sig;
 200         Sig.Index = Index++;
 201         Sig.ReturnType = wasm::WASM_TYPE_NORESULT;
 202         assert(FunctionSig.Returns.size() <= 1 &&
 203                "Functions with multiple returns are not supported");
 204         if (FunctionSig.Returns.size())
 205           Sig.ReturnType = static_cast<uint32_t>(FunctionSig.Returns[0]);
 206         for (const auto &ParamType : FunctionSig.Params)
 207           Sig.ParamTypes.emplace_back(static_cast<uint32_t>(ParamType));
 208         TypeSec->Signatures.push_back(Sig);
 209       }
 210       S = std::move(TypeSec);
 211       break;
 212     }
 213     case wasm::WASM_SEC_IMPORT: {
 214       auto ImportSec = std::make_unique<WasmYAML::ImportSection>();
 215       for (auto &Import : Obj.imports()) {
 216         WasmYAML::Import Im;
 217         Im.Module = Import.Module;
 218         Im.Field = Import.Field;
 219         Im.Kind = Import.Kind;
 220         switch (Im.Kind) {
 221         case wasm::WASM_EXTERNAL_FUNCTION:
 222           Im.SigIndex = Import.SigIndex;
 223           break;
 224         case wasm::WASM_EXTERNAL_GLOBAL:
 225           Im.GlobalImport.Type = Import.Global.Type;
 226           Im.GlobalImport.Mutable = Import.Global.Mutable;
 227           break;
 228         case wasm::WASM_EXTERNAL_EVENT:
 229           Im.EventImport.Attribute = Import.Event.Attribute;
 230           Im.EventImport.SigIndex = Import.Event.SigIndex;
 231           break;
 232         case wasm::WASM_EXTERNAL_TABLE:
 233           Im.TableImport = makeTable(Import.Table);
 234           break;
 235         case wasm::WASM_EXTERNAL_MEMORY:
 236           Im.Memory = makeLimits(Import.Memory);
 237           break;
 238         }
 239         ImportSec->Imports.push_back(Im);
 240       }
 241       S = std::move(ImportSec);
 242       break;
 243     }
 244     case wasm::WASM_SEC_FUNCTION: {
 245       auto FuncSec = std::make_unique<WasmYAML::FunctionSection>();
 246       for (const auto &Func : Obj.functionTypes()) {
 247         FuncSec->FunctionTypes.push_back(Func);
 248       }
 249       S = std::move(FuncSec);
 250       break;
 251     }
 252     case wasm::WASM_SEC_TABLE: {
 253       auto TableSec = std::make_unique<WasmYAML::TableSection>();
 254       for (const wasm::WasmTable &Table : Obj.tables()) {
 255         TableSec->Tables.push_back(makeTable(Table));
 256       }
 257       S = std::move(TableSec);
 258       break;
 259     }
 260     case wasm::WASM_SEC_MEMORY: {
 261       auto MemorySec = std::make_unique<WasmYAML::MemorySection>();
 262       for (const wasm::WasmLimits &Memory : Obj.memories()) {
 263         MemorySec->Memories.push_back(makeLimits(Memory));
 264       }
 265       S = std::move(MemorySec);
 266       break;
 267     }
 268     case wasm::WASM_SEC_GLOBAL: {
 269       auto GlobalSec = std::make_unique<WasmYAML::GlobalSection>();
 270       for (auto &Global : Obj.globals()) {
 271         WasmYAML::Global G;
 272         G.Index = Global.Index;
 273         G.Type = Global.Type.Type;
 274         G.Mutable = Global.Type.Mutable;
 275         G.InitExpr = Global.InitExpr;
 276         GlobalSec->Globals.push_back(G);
 277       }
 278       S = std::move(GlobalSec);
 279       break;
 280     }
 281     case wasm::WASM_SEC_EVENT: {
 282       auto EventSec = std::make_unique<WasmYAML::EventSection>();
 283       for (auto &Event : Obj.events()) {
 284         WasmYAML::Event E;
 285         E.Index = Event.Index;
 286         E.Attribute = Event.Type.Attribute;
 287         E.SigIndex = Event.Type.SigIndex;
 288         EventSec->Events.push_back(E);
 289       }
 290       S = std::move(EventSec);
 291       break;
 292     }
 293     case wasm::WASM_SEC_START: {
 294       auto StartSec = std::make_unique<WasmYAML::StartSection>();
 295       StartSec->StartFunction = Obj.startFunction();
 296       S = std::move(StartSec);
 297       break;
 298     }
 299     case wasm::WASM_SEC_EXPORT: {
 300       auto ExportSec = std::make_unique<WasmYAML::ExportSection>();
 301       for (auto &Export : Obj.exports()) {
 302         WasmYAML::Export Ex;
 303         Ex.Name = Export.Name;
 304         Ex.Kind = Export.Kind;
 305         Ex.Index = Export.Index;
 306         ExportSec->Exports.push_back(Ex);
 307       }
 308       S = std::move(ExportSec);
 309       break;
 310     }
 311     case wasm::WASM_SEC_ELEM: {
 312       auto ElemSec = std::make_unique<WasmYAML::ElemSection>();
 313       for (auto &Segment : Obj.elements()) {
 314         WasmYAML::ElemSegment Seg;
 315         Seg.TableIndex = Segment.TableIndex;
 316         Seg.Offset = Segment.Offset;
 317         for (auto &Func : Segment.Functions) {
 318           Seg.Functions.push_back(Func);
 319         }
 320         ElemSec->Segments.push_back(Seg);
 321       }
 322       S = std::move(ElemSec);
 323       break;
 324     }
 325     case wasm::WASM_SEC_CODE: {
 326       auto CodeSec = std::make_unique<WasmYAML::CodeSection>();
 327       for (auto &Func : Obj.functions()) {
 328         WasmYAML::Function Function;
 329         Function.Index = Func.Index;
 330         for (auto &Local : Func.Locals) {
 331           WasmYAML::LocalDecl LocalDecl;
 332           LocalDecl.Type = Local.Type;
 333           LocalDecl.Count = Local.Count;
 334           Function.Locals.push_back(LocalDecl);
 335         }
 336         Function.Body = yaml::BinaryRef(Func.Body);
 337         CodeSec->Functions.push_back(Function);
 338       }
 339       S = std::move(CodeSec);
 340       break;
 341     }
 342     case wasm::WASM_SEC_DATA: {
 343       auto DataSec = std::make_unique<WasmYAML::DataSection>();
 344       for (const object::WasmSegment &Segment : Obj.dataSegments()) {
 345         WasmYAML::DataSegment Seg;
 346         Seg.SectionOffset = Segment.SectionOffset;
 347         Seg.InitFlags = Segment.Data.InitFlags;
 348         Seg.MemoryIndex = Segment.Data.MemoryIndex;
 349         Seg.Offset = Segment.Data.Offset;
 350         Seg.Content = yaml::BinaryRef(Segment.Data.Content);
 351         DataSec->Segments.push_back(Seg);
 352       }
 353       S = std::move(DataSec);
 354       break;
 355     }
 356     case wasm::WASM_SEC_DATACOUNT: {
 357       auto DataCountSec = std::make_unique<WasmYAML::DataCountSection>();
 358       DataCountSec->Count = Obj.dataSegments().size();
 359       S = std::move(DataCountSec);
 360       break;
 361     }
 362     default:
 363       llvm_unreachable("Unknown section type");
 364       break;
 365     }
 366     for (const wasm::WasmRelocation &Reloc : WasmSec.Relocations) {
 367       WasmYAML::Relocation R;
 368       R.Type = Reloc.Type;
 369       R.Index = Reloc.Index;
 370       R.Offset = Reloc.Offset;
 371       R.Addend = Reloc.Addend;
 372       S->Relocations.push_back(R);
 373     }
 374     Y->Sections.push_back(std::move(S));
 375   }
 376
 377   return Y.release();
 378 }
 379
 380 std::error_code wasm2yaml(raw_ostream &Out, const object::WasmObjectFile &Obj) {
 381   WasmDumper Dumper(Obj);
 382   ErrorOr<WasmYAML::Object *> YAMLOrErr = Dumper.dump();
 383   if (std::error_code EC = YAMLOrErr.getError())
 384     return EC;
 385
 386   std::unique_ptr<WasmYAML::Object> YAML(YAMLOrErr.get());
 387   yaml::Output Yout(Out);
 388   Yout << *YAML;
 389
 390   return std::error_code();
 391 }