void MappingTraits<WasmYAML::Limits>::mapping(IO &IO, WasmYAML::Limits &Limits) { if (!IO.outputting() || Limits.Flags) IO.mapOptional("Flags", Limits.Flags); IO.mapRequired("Initial", Limits.Initial); if (!IO.outputting() || Limits.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX) IO.mapOptional("Maximum", Limits.Maximum); }
void MappingTraits<DWARFYAML::Data>::mapping( IO &IO, DWARFYAML::Data &DWARF) { IO.mapOptional("debug_str", DWARF.DebugStrings); IO.mapOptional("debug_abbrev", DWARF.AbbrevDecls); if(!DWARF.ARanges.empty() || !IO.outputting()) IO.mapOptional("debug_aranges", DWARF.ARanges); if(!DWARF.PubNames.Entries.empty() || !IO.outputting()) IO.mapOptional("debug_pubnames", DWARF.PubNames); if(!DWARF.PubTypes.Entries.empty() || !IO.outputting()) IO.mapOptional("debug_pubtypes", DWARF.PubTypes); if(!DWARF.GNUPubNames.Entries.empty() || !IO.outputting()) IO.mapOptional("debug_gnu_pubnames", DWARF.GNUPubNames); if(!DWARF.GNUPubTypes.Entries.empty() || !IO.outputting()) IO.mapOptional("debug_gnu_pubtypes", DWARF.GNUPubTypes); }
void MappingTraits<YAMLDebugSubsection>::mapping( IO &IO, YAMLDebugSubsection &Subsection) { if (!IO.outputting()) { if (IO.mapTag("!FileChecksums")) { auto SS = std::make_shared<YAMLChecksumsSubsection>(); Subsection.Subsection = SS; } else if (IO.mapTag("!Lines")) { Subsection.Subsection = std::make_shared<YAMLLinesSubsection>(); } else if (IO.mapTag("!InlineeLines")) { Subsection.Subsection = std::make_shared<YAMLInlineeLinesSubsection>(); } else if (IO.mapTag("!CrossModuleExports")) { Subsection.Subsection = std::make_shared<YAMLCrossModuleExportsSubsection>(); } else if (IO.mapTag("!CrossModuleImports")) { Subsection.Subsection = std::make_shared<YAMLCrossModuleImportsSubsection>(); } else if (IO.mapTag("!Symbols")) { Subsection.Subsection = std::make_shared<YAMLSymbolsSubsection>(); } else if (IO.mapTag("!StringTable")) { Subsection.Subsection = std::make_shared<YAMLStringTableSubsection>(); } else if (IO.mapTag("!FrameData")) { Subsection.Subsection = std::make_shared<YAMLFrameDataSubsection>(); } else if (IO.mapTag("!COFFSymbolRVAs")) { Subsection.Subsection = std::make_shared<YAMLCoffSymbolRVASubsection>(); } else { llvm_unreachable("Unexpected subsection tag!"); } } Subsection.Subsection->map(IO); }
static void mapMemberRecordImpl(IO &IO, const char *Class, TypeLeafKind Kind, MemberRecord &Obj) { if (!IO.outputting()) Obj.Member = std::make_shared<MemberRecordImpl<ConcreteType>>(Kind); IO.mapRequired(Class, *Obj.Member); }
void MappingContextTraits<PdbTpiRecord, pdb::yaml::SerializationContext>:: mapping(IO &IO, pdb::yaml::PdbTpiRecord &Obj, pdb::yaml::SerializationContext &Context) { codeview::TypeVisitorCallbackPipeline Pipeline; codeview::TypeDeserializer Deserializer; codeview::TypeSerializer Serializer(Context.Allocator); pdb::TpiHashUpdater Hasher; if (IO.outputting()) { // For PDB to Yaml, deserialize into a high level record type, then dump it. Pipeline.addCallbackToPipeline(Deserializer); Pipeline.addCallbackToPipeline(Context.Dumper); } else { // For Yaml to PDB, extract from the high level record type, then write it // to bytes. // This might be interpreted as a hack, but serializing FieldList // sub-records requires having access to the same serializer being used by // the FieldList itself. Context.ActiveSerializer = &Serializer; Pipeline.addCallbackToPipeline(Context.Dumper); Pipeline.addCallbackToPipeline(Serializer); Pipeline.addCallbackToPipeline(Hasher); } codeview::CVTypeVisitor Visitor(Pipeline); consumeError(Visitor.visitTypeRecord(Obj.Record)); Context.ActiveSerializer = nullptr; }
static void mapSymbolRecordImpl(IO &IO, const char *Class, SymbolKind Kind, CodeViewYAML::SymbolRecord &Obj) { if (!IO.outputting()) Obj.Symbol = std::make_shared<ConcreteType>(Kind); IO.mapRequired(Class, *Obj.Symbol); }
void MappingTraits<DiagnosticInfoOptimizationBase *>::mapping( IO &io, DiagnosticInfoOptimizationBase *&OptDiag) { assert(io.outputting() && "input not yet implemented"); if (io.mapTag("!Passed", (OptDiag->getKind() == DK_OptimizationRemark || OptDiag->getKind() == DK_MachineOptimizationRemark))) ; else if (io.mapTag( "!Missed", (OptDiag->getKind() == DK_OptimizationRemarkMissed || OptDiag->getKind() == DK_MachineOptimizationRemarkMissed))) ; else if (io.mapTag( "!Analysis", (OptDiag->getKind() == DK_OptimizationRemarkAnalysis || OptDiag->getKind() == DK_MachineOptimizationRemarkAnalysis))) ; else if (io.mapTag("!AnalysisFPCommute", OptDiag->getKind() == DK_OptimizationRemarkAnalysisFPCommute)) ; else if (io.mapTag("!AnalysisAliasing", OptDiag->getKind() == DK_OptimizationRemarkAnalysisAliasing)) ; else if (io.mapTag("!Failure", OptDiag->getKind() == DK_OptimizationFailure)) ; else llvm_unreachable("Unknown remark type"); // These are read-only for now. DiagnosticLocation DL = OptDiag->getLocation(); StringRef FN = GlobalValue::dropLLVMManglingEscape(OptDiag->getFunction().getName()); StringRef PassName(OptDiag->PassName); io.mapRequired("Pass", PassName); io.mapRequired("Name", OptDiag->RemarkName); if (!io.outputting() || DL.isValid()) io.mapOptional("DebugLoc", DL); io.mapRequired("Function", FN); io.mapOptional("Hotness", OptDiag->Hotness); io.mapOptional("Args", OptDiag->Args); }
static void mapping(IO &io, Export &exp) { io.mapRequired("name", exp.name); io.mapOptional("offset", exp.offset); io.mapOptional("kind", exp.kind, llvm::MachO::EXPORT_SYMBOL_FLAGS_KIND_REGULAR); if (!io.outputting() || exp.flags) io.mapOptional("flags", exp.flags); io.mapOptional("other", exp.otherOffset, Hex32(0)); io.mapOptional("other-name", exp.otherName, StringRef()); }
static void mapLeafRecordImpl(IO &IO, const char *Class, TypeLeafKind Kind, LeafRecord &Obj) { if (!IO.outputting()) Obj.Leaf = std::make_shared<LeafRecordImpl<ConcreteType>>(Kind); if (Kind == LF_FIELDLIST) Obj.Leaf->map(IO); else IO.mapRequired(Class, *Obj.Leaf); }
static void mapping(IO &io, DiagnosticLocation &DL) { assert(io.outputting() && "input not yet implemented"); StringRef File = DL.getFilename(); unsigned Line = DL.getLine(); unsigned Col = DL.getColumn(); io.mapRequired("File", File); io.mapRequired("Line", Line); io.mapRequired("Column", Col); }
void MappingTraits<MachOYAML::LinkEditData>::mapping( IO &IO, MachOYAML::LinkEditData &LinkEditData) { IO.mapOptional("RebaseOpcodes", LinkEditData.RebaseOpcodes); IO.mapOptional("BindOpcodes", LinkEditData.BindOpcodes); IO.mapOptional("WeakBindOpcodes", LinkEditData.WeakBindOpcodes); IO.mapOptional("LazyBindOpcodes", LinkEditData.LazyBindOpcodes); if(LinkEditData.ExportTrie.Children.size() > 0 || !IO.outputting()) IO.mapOptional("ExportTrie", LinkEditData.ExportTrie); IO.mapOptional("NameList", LinkEditData.NameList); IO.mapOptional("StringTable", LinkEditData.StringTable); }
void MappingTraits<msf::SuperBlock>::mapping(IO &IO, msf::SuperBlock &SB) { if (!IO.outputting()) { ::memcpy(SB.MagicBytes, msf::Magic, sizeof(msf::Magic)); } IO.mapRequired("BlockSize", SB.BlockSize); IO.mapRequired("FreeBlockMap", SB.FreeBlockMapBlock); IO.mapRequired("NumBlocks", SB.NumBlocks); IO.mapRequired("NumDirectoryBytes", SB.NumDirectoryBytes); IO.mapRequired("Unknown1", SB.Unknown1); IO.mapRequired("BlockMapAddr", SB.BlockMapAddr); }
static void mapping(IO &io, SourceLoc &Loc) { assert(io.outputting() && "input not yet implemented"); SourceManager *SM = static_cast<SourceManager *>(io.getContext()); StringRef File = SM->getDisplayNameForLoc(Loc); unsigned Line, Col; std::tie(Line, Col) = SM->getLineAndColumn(Loc); io.mapRequired("File", File); io.mapRequired("Line", Line); io.mapRequired("Column", Col); }
void MappingTraits<std::unique_ptr<ELFYAML::Section>>::mapping( IO &IO, std::unique_ptr<ELFYAML::Section> &Section) { ELFYAML::ELF_SHT sectionType; if (IO.outputting()) sectionType = Section->Type; else IO.mapRequired("Type", sectionType); switch (sectionType) { case ELF::SHT_REL: case ELF::SHT_RELA: if (!IO.outputting()) Section.reset(new ELFYAML::RelocationSection()); sectionMapping(IO, *cast<ELFYAML::RelocationSection>(Section.get())); break; default: if (!IO.outputting()) Section.reset(new ELFYAML::RawContentSection()); sectionMapping(IO, *cast<ELFYAML::RawContentSection>(Section.get())); } }
void MappingTraits<msf::SuperBlock>::mapping(IO &IO, msf::SuperBlock &SB) { if (!IO.outputting()) { ::memcpy(SB.MagicBytes, msf::Magic, sizeof(msf::Magic)); } using u32 = support::ulittle32_t; IO.mapOptional("BlockSize", SB.BlockSize, u32(4096U)); IO.mapOptional("FreeBlockMap", SB.FreeBlockMapBlock, u32(0U)); IO.mapOptional("NumBlocks", SB.NumBlocks, u32(0U)); IO.mapOptional("NumDirectoryBytes", SB.NumDirectoryBytes, u32(0U)); IO.mapOptional("Unknown1", SB.Unknown1, u32(0U)); IO.mapOptional("BlockMapAddr", SB.BlockMapAddr, u32(0U)); }
void MappingContextTraits<CVType, pdb::yaml::SerializationContext>::mapping( IO &IO, CVType &Record, pdb::yaml::SerializationContext &Context) { if (IO.outputting()) { codeview::TypeDeserializer Deserializer; codeview::TypeVisitorCallbackPipeline Pipeline; Pipeline.addCallbackToPipeline(Deserializer); Pipeline.addCallbackToPipeline(Context.Dumper); codeview::CVTypeVisitor Visitor(Pipeline); consumeError(Visitor.visitTypeRecord(Record)); } }
void MappingTraits<MachOYAML::Object>::mapping(IO &IO, MachOYAML::Object &Object) { // If the context isn't already set, tag the document as !mach-o. // For Fat files there will be a different tag so they can be differentiated. if (!IO.getContext()) { IO.setContext(&Object); } IO.mapTag("!mach-o", true); IO.mapOptional("IsLittleEndian", Object.IsLittleEndian, sys::IsLittleEndianHost); Object.DWARF.IsLittleEndian = Object.IsLittleEndian; IO.mapRequired("FileHeader", Object.Header); IO.mapOptional("LoadCommands", Object.LoadCommands); if(!Object.LinkEdit.isEmpty() || !IO.outputting()) IO.mapOptional("LinkEditData", Object.LinkEdit); if(!Object.DWARF.isEmpty() || !IO.outputting()) IO.mapOptional("DWARF", Object.DWARF); if (IO.getContext() == &Object) IO.setContext(nullptr); }
void MappingTraits<PdbSymbolRecord>::mapping(IO &IO, PdbSymbolRecord &Obj) { codeview::SymbolVisitorCallbackPipeline Pipeline; codeview::SymbolDeserializer Deserializer(nullptr); codeview::yaml::YamlSymbolDumper Dumper(IO); if (IO.outputting()) { // For PDB to Yaml, deserialize into a high level record type, then dump it. Pipeline.addCallbackToPipeline(Deserializer); Pipeline.addCallbackToPipeline(Dumper); } else { return; } codeview::CVSymbolVisitor Visitor(Pipeline); consumeError(Visitor.visitSymbolRecord(Obj.Record)); }
static void mapping(IO &IO, pdb::yaml::PdbTpiFieldListRecord &Obj, pdb::yaml::SerializationContext &Context) { assert(IO.outputting()); codeview::TypeVisitorCallbackPipeline Pipeline; BinaryByteStream Data(Obj.Record.Data, llvm::support::little); BinaryStreamReader FieldReader(Data); codeview::FieldListDeserializer Deserializer(FieldReader); // For PDB to Yaml, deserialize into a high level record type, then dump // it. Pipeline.addCallbackToPipeline(Deserializer); Pipeline.addCallbackToPipeline(Context.Dumper); codeview::CVTypeVisitor Visitor(Pipeline); consumeError(Visitor.visitMemberRecord(Obj.Record)); }
void MappingTraits<MemberRecord>::mapping(IO &IO, MemberRecord &Obj) { TypeLeafKind Kind; if (IO.outputting()) Kind = Obj.Member->Kind; IO.mapRequired("Kind", Kind); #define MEMBER_RECORD(EnumName, EnumVal, ClassName) \ case EnumName: \ mapMemberRecordImpl<ClassName##Record>(IO, #ClassName, Kind, Obj); \ break; #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName) \ MEMBER_RECORD(EnumName, EnumVal, ClassName) #define TYPE_RECORD(EnumName, EnumVal, ClassName) #define TYPE_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName) switch (Kind) { #include "llvm/DebugInfo/CodeView/CodeViewTypes.def" default: { llvm_unreachable("Unknown member kind!"); } } }
void MappingTraits<CodeViewYAML::SymbolRecord>::mapping( IO &IO, CodeViewYAML::SymbolRecord &Obj) { SymbolKind Kind; if (IO.outputting()) Kind = Obj.Symbol->Kind; IO.mapRequired("Kind", Kind); #define SYMBOL_RECORD(EnumName, EnumVal, ClassName) \ case EnumName: \ mapSymbolRecordImpl<SymbolRecordImpl<ClassName>>(IO, #ClassName, Kind, \ Obj); \ break; #define SYMBOL_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName) \ SYMBOL_RECORD(EnumName, EnumVal, ClassName) switch (Kind) { #include "llvm/DebugInfo/CodeView/CodeViewSymbols.def" default: mapSymbolRecordImpl<UnknownSymbolRecord>(IO, "UnknownSym", Kind, Obj); } }
void MappingContextTraits<PdbSymbolRecord, pdb::yaml::SerializationContext>::mapping(IO &IO, PdbSymbolRecord &Obj, pdb::yaml::SerializationContext &Context) { codeview::SymbolVisitorCallbackPipeline Pipeline; codeview::SymbolSerializer Serializer(Context.Allocator); codeview::SymbolDeserializer Deserializer(nullptr); codeview::yaml::YamlSymbolDumper Dumper(IO); if (IO.outputting()) { // For PDB to Yaml, deserialize into a high level record type, then dump it. Pipeline.addCallbackToPipeline(Deserializer); Pipeline.addCallbackToPipeline(Dumper); } else { // For the other way around, dump it into a concrete structure, and then // serialize it into the CVRecord. Pipeline.addCallbackToPipeline(Dumper); Pipeline.addCallbackToPipeline(Serializer); } codeview::CVSymbolVisitor Visitor(Pipeline); consumeError(Visitor.visitSymbolRecord(Obj.Record)); }
void MappingTraits<YamlObjectFile>::mapping(IO &IO, YamlObjectFile &ObjectFile) { if (IO.outputting()) { if (ObjectFile.Elf) MappingTraits<ELFYAML::Object>::mapping(IO, *ObjectFile.Elf); if (ObjectFile.Coff) MappingTraits<COFFYAML::Object>::mapping(IO, *ObjectFile.Coff); if (ObjectFile.MachO) MappingTraits<MachOYAML::Object>::mapping(IO, *ObjectFile.MachO); if (ObjectFile.FatMachO) MappingTraits<MachOYAML::UniversalBinary>::mapping(IO, *ObjectFile.FatMachO); } else { if (IO.mapTag("!ELF")) { ObjectFile.Elf.reset(new ELFYAML::Object()); MappingTraits<ELFYAML::Object>::mapping(IO, *ObjectFile.Elf); } else if (IO.mapTag("!COFF")) { ObjectFile.Coff.reset(new COFFYAML::Object()); MappingTraits<COFFYAML::Object>::mapping(IO, *ObjectFile.Coff); } else if (IO.mapTag("!mach-o")) { ObjectFile.MachO.reset(new MachOYAML::Object()); MappingTraits<MachOYAML::Object>::mapping(IO, *ObjectFile.MachO); } else if (IO.mapTag("!fat-mach-o")) { ObjectFile.FatMachO.reset(new MachOYAML::UniversalBinary()); MappingTraits<MachOYAML::UniversalBinary>::mapping(IO, *ObjectFile.FatMachO); } else if (IO.mapTag("!WASM")) { ObjectFile.Wasm.reset(new WasmYAML::Object()); MappingTraits<WasmYAML::Object>::mapping(IO, *ObjectFile.Wasm); } else { Input &In = (Input &)IO; std::string Tag = In.getCurrentNode()->getRawTag(); if (Tag.empty()) IO.setError("YAML Object File missing document type tag!"); else IO.setError( llvm::Twine("YAML Object File unsupported document type tag '") + llvm::Twine(Tag) + llvm::Twine("'!")); } } }
static void mapping(IO &io, Section §) { io.mapRequired("segment", sect.segmentName); io.mapRequired("section", sect.sectionName); io.mapRequired("type", sect.type); io.mapOptional("attributes", sect.attributes); io.mapOptional("alignment", sect.alignment, (uint16_t)1); io.mapRequired("address", sect.address); if (sect.type == llvm::MachO::S_ZEROFILL) { // S_ZEROFILL sections use "size:" instead of "content:" uint64_t size = sect.content.size(); io.mapOptional("size", size); if (!io.outputting()) { uint8_t *bytes = nullptr; sect.content = makeArrayRef(bytes, size); } } else { MappingNormalization<NormalizedContent, ArrayRef<uint8_t>> content( io, sect.content); io.mapOptional("content", content->_normalizedContent); } io.mapOptional("relocations", sect.relocations); io.mapOptional("indirect-syms", sect.indirectSymbols); }
static void mapping(IO &IO, pdb::yaml::PdbTpiFieldListRecord &Obj, pdb::yaml::SerializationContext &Context) { codeview::TypeVisitorCallbackPipeline Pipeline; codeview::TypeDeserializer Deserializer; codeview::TypeSerializationVisitor Serializer(Context.FieldListBuilder, Context.TypeTableBuilder); pdb::TpiHashUpdater Hasher; if (IO.outputting()) { // For PDB to Yaml, deserialize into a high level record type, then dump // it. Pipeline.addCallbackToPipeline(Deserializer); Pipeline.addCallbackToPipeline(Context.Dumper); } else { // For Yaml to PDB, extract from the high level record type, then write it // to bytes. Pipeline.addCallbackToPipeline(Context.Dumper); Pipeline.addCallbackToPipeline(Serializer); Pipeline.addCallbackToPipeline(Hasher); } codeview::CVTypeVisitor Visitor(Pipeline); consumeError(Visitor.visitMemberRecord(Obj.Record)); }
void MappingTraits<std::unique_ptr<ELFYAML::Section>>::mapping( IO &IO, std::unique_ptr<ELFYAML::Section> &Section) { ELFYAML::ELF_SHT sectionType; if (IO.outputting()) sectionType = Section->Type; else IO.mapRequired("Type", sectionType); switch (sectionType) { case ELF::SHT_REL: case ELF::SHT_RELA: if (!IO.outputting()) Section.reset(new ELFYAML::RelocationSection()); sectionMapping(IO, *cast<ELFYAML::RelocationSection>(Section.get())); break; case ELF::SHT_GROUP: if (!IO.outputting()) Section.reset(new ELFYAML::Group()); groupSectionMapping(IO, *cast<ELFYAML::Group>(Section.get())); break; case ELF::SHT_NOBITS: if (!IO.outputting()) Section.reset(new ELFYAML::NoBitsSection()); sectionMapping(IO, *cast<ELFYAML::NoBitsSection>(Section.get())); break; case ELF::SHT_MIPS_ABIFLAGS: if (!IO.outputting()) Section.reset(new ELFYAML::MipsABIFlags()); sectionMapping(IO, *cast<ELFYAML::MipsABIFlags>(Section.get())); break; default: if (!IO.outputting()) Section.reset(new ELFYAML::RawContentSection()); sectionMapping(IO, *cast<ELFYAML::RawContentSection>(Section.get())); } }
void MappingTraits<std::unique_ptr<WasmYAML::Section>>::mapping( IO &IO, std::unique_ptr<WasmYAML::Section> &Section) { WasmYAML::SectionType SectionType; if (IO.outputting()) SectionType = Section->Type; else IO.mapRequired("Type", SectionType); switch (SectionType) { case wasm::WASM_SEC_CUSTOM: { StringRef SectionName; if (IO.outputting()) { auto CustomSection = cast<WasmYAML::CustomSection>(Section.get()); SectionName = CustomSection->Name; } else { IO.mapRequired("Name", SectionName); } if (SectionName == "linking") { if (!IO.outputting()) Section.reset(new WasmYAML::LinkingSection()); sectionMapping(IO, *cast<WasmYAML::LinkingSection>(Section.get())); } else if (SectionName == "name") { if (!IO.outputting()) Section.reset(new WasmYAML::NameSection()); sectionMapping(IO, *cast<WasmYAML::NameSection>(Section.get())); } else { if (!IO.outputting()) Section.reset(new WasmYAML::CustomSection(SectionName)); sectionMapping(IO, *cast<WasmYAML::CustomSection>(Section.get())); } break; } case wasm::WASM_SEC_TYPE: if (!IO.outputting()) Section.reset(new WasmYAML::TypeSection()); sectionMapping(IO, *cast<WasmYAML::TypeSection>(Section.get())); break; case wasm::WASM_SEC_IMPORT: if (!IO.outputting()) Section.reset(new WasmYAML::ImportSection()); sectionMapping(IO, *cast<WasmYAML::ImportSection>(Section.get())); break; case wasm::WASM_SEC_FUNCTION: if (!IO.outputting()) Section.reset(new WasmYAML::FunctionSection()); sectionMapping(IO, *cast<WasmYAML::FunctionSection>(Section.get())); break; case wasm::WASM_SEC_TABLE: if (!IO.outputting()) Section.reset(new WasmYAML::TableSection()); sectionMapping(IO, *cast<WasmYAML::TableSection>(Section.get())); break; case wasm::WASM_SEC_MEMORY: if (!IO.outputting()) Section.reset(new WasmYAML::MemorySection()); sectionMapping(IO, *cast<WasmYAML::MemorySection>(Section.get())); break; case wasm::WASM_SEC_GLOBAL: if (!IO.outputting()) Section.reset(new WasmYAML::GlobalSection()); sectionMapping(IO, *cast<WasmYAML::GlobalSection>(Section.get())); break; case wasm::WASM_SEC_EXPORT: if (!IO.outputting()) Section.reset(new WasmYAML::ExportSection()); sectionMapping(IO, *cast<WasmYAML::ExportSection>(Section.get())); break; case wasm::WASM_SEC_START: if (!IO.outputting()) Section.reset(new WasmYAML::StartSection()); sectionMapping(IO, *cast<WasmYAML::StartSection>(Section.get())); break; case wasm::WASM_SEC_ELEM: if (!IO.outputting()) Section.reset(new WasmYAML::ElemSection()); sectionMapping(IO, *cast<WasmYAML::ElemSection>(Section.get())); break; case wasm::WASM_SEC_CODE: if (!IO.outputting()) Section.reset(new WasmYAML::CodeSection()); sectionMapping(IO, *cast<WasmYAML::CodeSection>(Section.get())); break; case wasm::WASM_SEC_DATA: if (!IO.outputting()) Section.reset(new WasmYAML::DataSection()); sectionMapping(IO, *cast<WasmYAML::DataSection>(Section.get())); break; default: llvm_unreachable("Unknown section type"); } }
static void mapping(IO &io, DiagnosticInfoOptimizationBase::Argument &A) { assert(io.outputting() && "input not yet implemented"); io.mapRequired(A.Key.data(), A.Val); if (A.Loc.isValid()) io.mapOptional("DebugLoc", A.Loc); }