Lines Matching refs:IO
32 IO &IO, ELFYAML::ELF_ET &Value) {
33 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
40 IO.enumFallback<Hex16>(Value);
44 IO &IO, ELFYAML::ELF_PT &Value) {
45 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
59 IO.enumFallback<Hex32>(Value);
63 IO &IO, ELFYAML::ELF_EM &Value) {
64 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
225 IO.enumFallback<Hex16>(Value);
229 IO &IO, ELFYAML::ELF_ELFCLASS &Value) {
230 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
239 IO &IO, ELFYAML::ELF_ELFDATA &Value) {
240 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
250 IO &IO, ELFYAML::ELF_ELFOSABI &Value) {
251 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
278 IO.enumFallback<Hex8>(Value);
281 void ScalarBitSetTraits<ELFYAML::ELF_EF>::bitset(IO &IO,
283 const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
284 assert(Object && "The IO context is not initialized");
285 #define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
286 #define BCaseMask(X, M) IO.maskedBitSetCase(Value, #X, ELF::X, ELF::M)
439 IO &IO, ELFYAML::ELF_SHT &Value) {
440 const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
441 assert(Object && "The IO context is not initialized");
442 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
503 IO.enumFallback<Hex32>(Value);
506 void ScalarBitSetTraits<ELFYAML::ELF_PF>::bitset(IO &IO,
508 #define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
514 void ScalarBitSetTraits<ELFYAML::ELF_SHF>::bitset(IO &IO,
516 const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
517 #define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
558 IO &IO, ELFYAML::ELF_SHN &Value) {
559 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
577 IO.enumFallback<Hex16>(Value);
581 IO &IO, ELFYAML::ELF_STB &Value) {
582 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
588 IO.enumFallback<Hex8>(Value);
592 IO &IO, ELFYAML::ELF_STT &Value) {
593 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
603 IO.enumFallback<Hex8>(Value);
608 IO &IO, ELFYAML::ELF_RSS &Value) {
609 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
618 IO &IO, ELFYAML::ELF_REL &Value) {
619 const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
620 assert(Object && "The IO context is not initialized");
621 #define ELF_RELOC(X, Y) IO.enumCase(Value, #X, ELF::X);
665 IO.enumFallback<Hex32>(Value);
669 IO &IO, ELFYAML::ELF_DYNTAG &Value) {
670 const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
671 assert(Object && "The IO context is not initialized");
683 #define DYNAMIC_TAG(X, Y) IO.enumCase(Value, STRINGIFY(DT_##X), ELF::DT_##X);
733 IO.enumFallback<Hex64>(Value);
737 IO &IO, ELFYAML::MIPS_AFL_REG &Value) {
738 #define ECase(X) IO.enumCase(Value, #X, Mips::AFL_##X)
747 IO &IO, ELFYAML::MIPS_ABI_FP &Value) {
748 #define ECase(X) IO.enumCase(Value, #X, Mips::Val_GNU_MIPS_ABI_##X)
761 IO &IO, ELFYAML::MIPS_AFL_EXT &Value) {
762 #define ECase(X) IO.enumCase(Value, #X, Mips::AFL_##X)
787 IO &IO, ELFYAML::MIPS_ISA &Value) {
788 IO.enumCase(Value, "MIPS1", 1);
789 IO.enumCase(Value, "MIPS2", 2);
790 IO.enumCase(Value, "MIPS3", 3);
791 IO.enumCase(Value, "MIPS4", 4);
792 IO.enumCase(Value, "MIPS5", 5);
793 IO.enumCase(Value, "MIPS32", 32);
794 IO.enumCase(Value, "MIPS64", 64);
798 IO &IO, ELFYAML::MIPS_AFL_ASE &Value) {
799 #define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_ASE_##X)
817 IO &IO, ELFYAML::MIPS_AFL_FLAGS1 &Value) {
818 #define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_FLAGS1_##X)
823 void MappingTraits<ELFYAML::FileHeader>::mapping(IO &IO,
825 IO.mapRequired("Class", FileHdr.Class);
826 IO.mapRequired("Data", FileHdr.Data);
827 IO.mapOptional("OSABI", FileHdr.OSABI, ELFYAML::ELF_ELFOSABI(0));
828 IO.mapOptional("ABIVersion", FileHdr.ABIVersion, Hex8(0));
829 IO.mapRequired("Type", FileHdr.Type);
830 IO.mapRequired("Machine", FileHdr.Machine);
831 IO.mapOptional("Flags", FileHdr.Flags, ELFYAML::ELF_EF(0));
832 IO.mapOptional("Entry", FileHdr.Entry, Hex64(0));
834 IO.mapOptional("SHEntSize", FileHdr.SHEntSize);
835 IO.mapOptional("SHOff", FileHdr.SHOff);
836 IO.mapOptional("SHNum", FileHdr.SHNum);
837 IO.mapOptional("SHStrNdx", FileHdr.SHStrNdx);
841 IO &IO, ELFYAML::ProgramHeader &Phdr) {
842 IO.mapRequired("Type", Phdr.Type);
843 IO.mapOptional("Flags", Phdr.Flags, ELFYAML::ELF_PF(0));
844 IO.mapOptional("Sections", Phdr.Sections);
845 IO.mapOptional("VAddr", Phdr.VAddr, Hex64(0));
846 IO.mapOptional("PAddr", Phdr.PAddr, Hex64(0));
847 IO.mapOptional("Align", Phdr.Align);
848 IO.mapOptional("FileSize", Phdr.FileSize);
849 IO.mapOptional("MemSize", Phdr.MemSize);
850 IO.mapOptional("Offset", Phdr.Offset);
890 NormalizedOther(IO &IO) : YamlIO(IO) {}
891 NormalizedOther(IO &IO, Optional<uint8_t> Original) : YamlIO(IO) {
931 Optional<uint8_t> denormalize(IO &) {
973 IO &YamlIO;
980 void MappingTraits<ELFYAML::Symbol>::mapping(IO &IO, ELFYAML::Symbol &Symbol) {
981 IO.mapOptional("Name", Symbol.Name, StringRef());
982 IO.mapOptional("NameIndex", Symbol.NameIndex);
983 IO.mapOptional("Type", Symbol.Type, ELFYAML::ELF_STT(0));
984 IO.mapOptional("Section", Symbol.Section, StringRef());
985 IO.mapOptional("Index", Symbol.Index);
986 IO.mapOptional("Binding", Symbol.Binding, ELFYAML::ELF_STB(0));
987 IO.mapOptional("Value", Symbol.Value, Hex64(0));
988 IO.mapOptional("Size", Symbol.Size, Hex64(0));
995 MappingNormalization<NormalizedOther, Optional<uint8_t>> Keys(IO,
997 IO.mapOptional("Other", Keys->Other);
1000 StringRef MappingTraits<ELFYAML::Symbol>::validate(IO &IO,
1009 static void commonSectionMapping(IO &IO, ELFYAML::Section &Section) {
1010 IO.mapOptional("Name", Section.Name, StringRef());
1011 IO.mapRequired("Type", Section.Type);
1012 IO.mapOptional("Flags", Section.Flags);
1013 IO.mapOptional("Address", Section.Address, Hex64(0));
1014 IO.mapOptional("Link", Section.Link, StringRef());
1015 IO.mapOptional("AddressAlign", Section.AddressAlign, Hex64(0));
1016 IO.mapOptional("EntSize", Section.EntSize);
1021 assert(!IO.outputting() ||
1024 IO.mapOptional("ShName", Section.ShName);
1025 IO.mapOptional("ShOffset", Section.ShOffset);
1026 IO.mapOptional("ShSize", Section.ShSize);
1027 IO.mapOptional("ShFlags", Section.ShFlags);
1030 static void sectionMapping(IO &IO, ELFYAML::DynamicSection &Section) {
1031 commonSectionMapping(IO, Section);
1032 IO.mapOptional("Entries", Section.Entries);
1033 IO.mapOptional("Content", Section.Content);
1036 static void sectionMapping(IO &IO, ELFYAML::RawContentSection &Section) {
1037 commonSectionMapping(IO, Section);
1038 IO.mapOptional("Content", Section.Content);
1039 IO.mapOptional("Size", Section.Size);
1040 IO.mapOptional("Info", Section.Info);
1043 static void sectionMapping(IO &IO, ELFYAML::StackSizesSection &Section) {
1044 commonSectionMapping(IO, Section);
1045 IO.mapOptional("Content", Section.Content);
1046 IO.mapOptional("Size", Section.Size);
1047 IO.mapOptional("Entries", Section.Entries);
1050 static void sectionMapping(IO &IO, ELFYAML::HashSection &Section) {
1051 commonSectionMapping(IO, Section);
1052 IO.mapOptional("Content", Section.Content);
1053 IO.mapOptional("Bucket", Section.Bucket);
1054 IO.mapOptional("Chain", Section.Chain);
1055 IO.mapOptional("Size", Section.Size);
1058 static void sectionMapping(IO &IO, ELFYAML::NoteSection &Section) {
1059 commonSectionMapping(IO, Section);
1060 IO.mapOptional("Content", Section.Content);
1061 IO.mapOptional("Size", Section.Size);
1062 IO.mapOptional("Notes", Section.Notes);
1066 static void sectionMapping(IO &IO, ELFYAML::GnuHashSection &Section) {
1067 commonSectionMapping(IO, Section);
1068 IO.mapOptional("Content", Section.Content);
1069 IO.mapOptional("Header", Section.Header);
1070 IO.mapOptional("BloomFilter", Section.BloomFilter);
1071 IO.mapOptional("HashBuckets", Section.HashBuckets);
1072 IO.mapOptional("HashValues", Section.HashValues);
1074 static void sectionMapping(IO &IO, ELFYAML::NoBitsSection &Section) {
1075 commonSectionMapping(IO, Section);
1076 IO.mapOptional("Size", Section.Size, Hex64(0));
1079 static void sectionMapping(IO &IO, ELFYAML::VerdefSection &Section) {
1080 commonSectionMapping(IO, Section);
1081 IO.mapRequired("Info", Section.Info);
1082 IO.mapOptional("Entries", Section.Entries);
1083 IO.mapOptional("Content", Section.Content);
1086 static void sectionMapping(IO &IO, ELFYAML::SymverSection &Section) {
1087 commonSectionMapping(IO, Section);
1088 IO.mapRequired("Entries", Section.Entries);
1091 static void sectionMapping(IO &IO, ELFYAML::VerneedSection &Section) {
1092 commonSectionMapping(IO, Section);
1093 IO.mapRequired("Info", Section.Info);
1094 IO.mapOptional("Dependencies", Section.VerneedV);
1095 IO.mapOptional("Content", Section.Content);
1098 static void sectionMapping(IO &IO, ELFYAML::RelocationSection &Section) {
1099 commonSectionMapping(IO, Section);
1100 IO.mapOptional("Info", Section.RelocatableSec, StringRef());
1101 IO.mapOptional("Relocations", Section.Relocations);
1104 static void sectionMapping(IO &IO, ELFYAML::RelrSection &Section) {
1105 commonSectionMapping(IO, Section);
1106 IO.mapOptional("Entries", Section.Entries);
1107 IO.mapOptional("Content", Section.Content);
1110 static void groupSectionMapping(IO &IO, ELFYAML::Group &Group) {
1111 commonSectionMapping(IO, Group);
1112 IO.mapOptional("Info", Group.Signature);
1113 IO.mapRequired("Members", Group.Members);
1116 static void sectionMapping(IO &IO, ELFYAML::SymtabShndxSection &Section) {
1117 commonSectionMapping(IO, Section);
1118 IO.mapRequired("Entries", Section.Entries);
1121 static void sectionMapping(IO &IO, ELFYAML::AddrsigSection &Section) {
1122 commonSectionMapping(IO, Section);
1123 IO.mapOptional("Content", Section.Content);
1124 IO.mapOptional("Size", Section.Size);
1125 IO.mapOptional("Symbols", Section.Symbols);
1128 static void fillMapping(IO &IO, ELFYAML::Fill &Fill) {
1129 IO.mapOptional("Name", Fill.Name, StringRef());
1130 IO.mapOptional("Pattern", Fill.Pattern);
1131 IO.mapRequired("Size", Fill.Size);
1134 static void sectionMapping(IO &IO, ELFYAML::LinkerOptionsSection &Section) {
1135 commonSectionMapping(IO, Section);
1136 IO.mapOptional("Options", Section.Options);
1137 IO.mapOptional("Content", Section.Content);
1140 static void sectionMapping(IO &IO,
1142 commonSectionMapping(IO, Section);
1143 IO.mapOptional("Libraries", Section.Libs);
1144 IO.mapOptional("Content", Section.Content);
1148 IO &IO, ELFYAML::SectionOrType §ionOrType) {
1149 IO.mapRequired("SectionOrType", sectionOrType.sectionNameOrType);
1153 IO &IO, ELFYAML::SectionName §ionName) {
1154 IO.mapRequired("Section", sectionName.Section);
1157 static void sectionMapping(IO &IO, ELFYAML::MipsABIFlags &Section) {
1158 commonSectionMapping(IO, Section);
1159 IO.mapOptional("Version", Section.Version, Hex16(0));
1160 IO.mapRequired("ISA", Section.ISALevel);
1161 IO.mapOptional("ISARevision", Section.ISARevision, Hex8(0));
1162 IO.mapOptional("ISAExtension", Section.ISAExtension,
1164 IO.mapOptional("ASEs", Section.ASEs, ELFYAML::MIPS_AFL_ASE(0));
1165 IO.mapOptional("FpABI", Section.FpABI,
1167 IO.mapOptional("GPRSize", Section.GPRSize,
1169 IO.mapOptional("CPR1Size", Section.CPR1Size,
1171 IO.mapOptional("CPR2Size", Section.CPR2Size,
1173 IO.mapOptional("Flags1", Section.Flags1, ELFYAML::MIPS_AFL_FLAGS1(0));
1174 IO.mapOptional("Flags2", Section.Flags2, Hex32(0));
1178 IO &IO, std::unique_ptr<ELFYAML::Chunk> &Section) {
1180 if (IO.outputting()) {
1187 IO.mapRequired("Type", StrType);
1190 fillMapping(IO, *cast<ELFYAML::Fill>(Section.get()));
1194 IO.mapRequired("Type", Type);
1199 if (!IO.outputting())
1201 sectionMapping(IO, *cast<ELFYAML::DynamicSection>(Section.get()));
1205 if (!IO.outputting())
1207 sectionMapping(IO, *cast<ELFYAML::RelocationSection>(Section.get()));
1210 if (!IO.outputting())
1212 sectionMapping(IO, *cast<ELFYAML::RelrSection>(Section.get()));
1215 if (!IO.outputting())
1217 groupSectionMapping(IO, *cast<ELFYAML::Group>(Section.get()));
1220 if (!IO.outputting())
1222 sectionMapping(IO, *cast<ELFYAML::NoBitsSection>(Section.get()));
1225 if (!IO.outputting())
1227 sectionMapping(IO, *cast<ELFYAML::HashSection>(Section.get()));
1230 if (!IO.outputting())
1232 sectionMapping(IO, *cast<ELFYAML::NoteSection>(Section.get()));
1235 if (!IO.outputting())
1237 sectionMapping(IO, *cast<ELFYAML::GnuHashSection>(Section.get()));
1240 if (!IO.outputting())
1242 sectionMapping(IO, *cast<ELFYAML::MipsABIFlags>(Section.get()));
1245 if (!IO.outputting())
1247 sectionMapping(IO, *cast<ELFYAML::VerdefSection>(Section.get()));
1250 if (!IO.outputting())
1252 sectionMapping(IO, *cast<ELFYAML::SymverSection>(Section.get()));
1255 if (!IO.outputting())
1257 sectionMapping(IO, *cast<ELFYAML::VerneedSection>(Section.get()));
1260 if (!IO.outputting())
1262 sectionMapping(IO, *cast<ELFYAML::SymtabShndxSection>(Section.get()));
1265 if (!IO.outputting())
1267 sectionMapping(IO, *cast<ELFYAML::AddrsigSection>(Section.get()));
1270 if (!IO.outputting())
1272 sectionMapping(IO, *cast<ELFYAML::LinkerOptionsSection>(Section.get()));
1275 if (!IO.outputting())
1277 sectionMapping(IO,
1281 if (!IO.outputting()) {
1283 IO.mapOptional("Name", Name, StringRef());
1293 sectionMapping(IO, *S);
1295 sectionMapping(IO, *cast<ELFYAML::StackSizesSection>(Section.get()));
1300 IO &io, std::unique_ptr<ELFYAML::Chunk> &C) {
1467 NormalizedMips64RelType(IO &)
1472 NormalizedMips64RelType(IO &, ELFYAML::ELF_REL Original)
1476 ELFYAML::ELF_REL denormalize(IO &) {
1490 IO &IO, ELFYAML::StackSizeEntry &E) {
1491 assert(IO.getContext() && "The IO context is not initialized");
1492 IO.mapOptional("Address", E.Address, Hex64(0));
1493 IO.mapRequired("Size", E.Size);
1496 void MappingTraits<ELFYAML::GnuHashHeader>::mapping(IO &IO,
1498 assert(IO.getContext() && "The IO context is not initialized");
1499 IO.mapOptional("NBuckets", E.NBuckets);
1500 IO.mapRequired("SymNdx", E.SymNdx);
1501 IO.mapOptional("MaskWords", E.MaskWords);
1502 IO.mapRequired("Shift2", E.Shift2);
1505 void MappingTraits<ELFYAML::DynamicEntry>::mapping(IO &IO,
1507 assert(IO.getContext() && "The IO context is not initialized");
1509 IO.mapRequired("Tag", Rel.Tag);
1510 IO.mapRequired("Value", Rel.Val);
1513 void MappingTraits<ELFYAML::NoteEntry>::mapping(IO &IO, ELFYAML::NoteEntry &N) {
1514 assert(IO.getContext() && "The IO context is not initialized");
1516 IO.mapOptional("Name", N.Name);
1517 IO.mapOptional("Desc", N.Desc);
1518 IO.mapRequired("Type", N.Type);
1521 void MappingTraits<ELFYAML::VerdefEntry>::mapping(IO &IO,
1523 assert(IO.getContext() && "The IO context is not initialized");
1525 IO.mapRequired("Version", E.Version);
1526 IO.mapRequired("Flags", E.Flags);
1527 IO.mapRequired("VersionNdx", E.VersionNdx);
1528 IO.mapRequired("Hash", E.Hash);
1529 IO.mapRequired("Names", E.VerNames);
1532 void MappingTraits<ELFYAML::VerneedEntry>::mapping(IO &IO,
1534 assert(IO.getContext() && "The IO context is not initialized");
1536 IO.mapRequired("Version", E.Version);
1537 IO.mapRequired("File", E.File);
1538 IO.mapRequired("Entries", E.AuxV);
1541 void MappingTraits<ELFYAML::VernauxEntry>::mapping(IO &IO,
1543 assert(IO.getContext() && "The IO context is not initialized");
1545 IO.mapRequired("Name", E.Name);
1546 IO.mapRequired("Hash", E.Hash);
1547 IO.mapRequired("Flags", E.Flags);
1548 IO.mapRequired("Other", E.Other);
1551 void MappingTraits<ELFYAML::Relocation>::mapping(IO &IO,
1553 const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
1554 assert(Object && "The IO context is not initialized");
1556 IO.mapRequired("Offset", Rel.Offset);
1557 IO.mapOptional("Symbol", Rel.Symbol);
1562 IO, Rel.Type);
1563 IO.mapRequired("Type", Key->Type);
1564 IO.mapOptional("Type2", Key->Type2, ELFYAML::ELF_REL(ELF::R_MIPS_NONE));
1565 IO.mapOptional("Type3", Key->Type3, ELFYAML::ELF_REL(ELF::R_MIPS_NONE));
1566 IO.mapOptional("SpecSym", Key->SpecSym, ELFYAML::ELF_RSS(ELF::RSS_UNDEF));
1568 IO.mapRequired("Type", Rel.Type);
1570 IO.mapOptional("Addend", Rel.Addend, (int64_t)0);
1573 void MappingTraits<ELFYAML::Object>::mapping(IO &IO, ELFYAML::Object &Object) {
1574 assert(!IO.getContext() && "The IO context is initialized already");
1575 IO.setContext(&Object);
1576 IO.mapTag("!ELF", true);
1577 IO.mapRequired("FileHeader", Object.Header);
1578 IO.mapOptional("ProgramHeaders", Object.ProgramHeaders);
1579 IO.mapOptional("Sections", Object.Chunks);
1580 IO.mapOptional("Symbols", Object.Symbols);
1581 IO.mapOptional("DynamicSymbols", Object.DynamicSymbols);
1582 IO.setContext(nullptr);
1585 void MappingTraits<ELFYAML::AddrsigSymbol>::mapping(IO &IO, ELFYAML::AddrsigSymbol &Sym) {
1586 assert(IO.getContext() && "The IO context is not initialized");
1587 IO.mapOptional("Name", Sym.Name);
1588 IO.mapOptional("Index", Sym.Index);
1591 void MappingTraits<ELFYAML::LinkerOption>::mapping(IO &IO,
1593 assert(IO.getContext() && "The IO context is not initialized");
1594 IO.mapRequired("Name", Opt.Key);
1595 IO.mapRequired("Value", Opt.Value);