1 //===- MachOYAML.h - Mach-O YAMLIO implementation ---------------*- 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 /// \file 10 /// This file declares classes for handling the YAML representation 11 /// of Mach-O. 12 /// 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_OBJECTYAML_MACHOYAML_H 16 #define LLVM_OBJECTYAML_MACHOYAML_H 17 18 #include "llvm/ADT/StringRef.h" 19 #include "llvm/BinaryFormat/MachO.h" 20 #include "llvm/ObjectYAML/DWARFYAML.h" 21 #include "llvm/ObjectYAML/YAML.h" 22 #include "llvm/Support/YAMLTraits.h" 23 #include <cstdint> 24 #include <string> 25 #include <vector> 26 27 namespace llvm { 28 namespace MachOYAML { 29 30 struct Section { 31 char sectname[16]; 32 char segname[16]; 33 llvm::yaml::Hex64 addr; 34 uint64_t size; 35 llvm::yaml::Hex32 offset; 36 uint32_t align; 37 llvm::yaml::Hex32 reloff; 38 uint32_t nreloc; 39 llvm::yaml::Hex32 flags; 40 llvm::yaml::Hex32 reserved1; 41 llvm::yaml::Hex32 reserved2; 42 llvm::yaml::Hex32 reserved3; 43 Optional<llvm::yaml::BinaryRef> content; 44 }; 45 46 struct FileHeader { 47 llvm::yaml::Hex32 magic; 48 llvm::yaml::Hex32 cputype; 49 llvm::yaml::Hex32 cpusubtype; 50 llvm::yaml::Hex32 filetype; 51 uint32_t ncmds; 52 uint32_t sizeofcmds; 53 llvm::yaml::Hex32 flags; 54 llvm::yaml::Hex32 reserved; 55 }; 56 57 struct LoadCommand { 58 virtual ~LoadCommand(); 59 60 llvm::MachO::macho_load_command Data; 61 std::vector<Section> Sections; 62 std::vector<MachO::build_tool_version> Tools; 63 std::vector<llvm::yaml::Hex8> PayloadBytes; 64 std::string PayloadString; 65 uint64_t ZeroPadBytes; 66 }; 67 68 struct NListEntry { 69 uint32_t n_strx; 70 llvm::yaml::Hex8 n_type; 71 uint8_t n_sect; 72 uint16_t n_desc; 73 uint64_t n_value; 74 }; 75 76 struct RebaseOpcode { 77 MachO::RebaseOpcode Opcode; 78 uint8_t Imm; 79 std::vector<yaml::Hex64> ExtraData; 80 }; 81 82 struct BindOpcode { 83 MachO::BindOpcode Opcode; 84 uint8_t Imm; 85 std::vector<yaml::Hex64> ULEBExtraData; 86 std::vector<int64_t> SLEBExtraData; 87 StringRef Symbol; 88 }; 89 90 struct ExportEntry { 91 uint64_t TerminalSize = 0; 92 uint64_t NodeOffset = 0; 93 std::string Name; 94 llvm::yaml::Hex64 Flags = 0; 95 llvm::yaml::Hex64 Address = 0; 96 llvm::yaml::Hex64 Other = 0; 97 std::string ImportName; 98 std::vector<MachOYAML::ExportEntry> Children; 99 }; 100 101 struct LinkEditData { 102 std::vector<MachOYAML::RebaseOpcode> RebaseOpcodes; 103 std::vector<MachOYAML::BindOpcode> BindOpcodes; 104 std::vector<MachOYAML::BindOpcode> WeakBindOpcodes; 105 std::vector<MachOYAML::BindOpcode> LazyBindOpcodes; 106 MachOYAML::ExportEntry ExportTrie; 107 std::vector<NListEntry> NameList; 108 std::vector<StringRef> StringTable; 109 110 bool isEmpty() const; 111 }; 112 113 struct Object { 114 bool IsLittleEndian; 115 FileHeader Header; 116 std::vector<LoadCommand> LoadCommands; 117 std::vector<Section> Sections; 118 LinkEditData LinkEdit; 119 DWARFYAML::Data DWARF; 120 }; 121 122 struct FatHeader { 123 llvm::yaml::Hex32 magic; 124 uint32_t nfat_arch; 125 }; 126 127 struct FatArch { 128 llvm::yaml::Hex32 cputype; 129 llvm::yaml::Hex32 cpusubtype; 130 llvm::yaml::Hex64 offset; 131 uint64_t size; 132 uint32_t align; 133 llvm::yaml::Hex32 reserved; 134 }; 135 136 struct UniversalBinary { 137 FatHeader Header; 138 std::vector<FatArch> FatArchs; 139 std::vector<Object> Slices; 140 }; 141 142 } // end namespace MachOYAML 143 } // end namespace llvm 144 145 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::LoadCommand) 146 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::Section) 147 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::RebaseOpcode) 148 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::BindOpcode) 149 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::ExportEntry) 150 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::NListEntry) 151 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::Object) 152 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::FatArch) 153 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachO::build_tool_version) 154 155 namespace llvm { 156 157 class raw_ostream; 158 159 namespace yaml { 160 161 template <> struct MappingTraits<MachOYAML::FileHeader> { 162 static void mapping(IO &IO, MachOYAML::FileHeader &FileHeader); 163 }; 164 165 template <> struct MappingTraits<MachOYAML::Object> { 166 static void mapping(IO &IO, MachOYAML::Object &Object); 167 }; 168 169 template <> struct MappingTraits<MachOYAML::FatHeader> { 170 static void mapping(IO &IO, MachOYAML::FatHeader &FatHeader); 171 }; 172 173 template <> struct MappingTraits<MachOYAML::FatArch> { 174 static void mapping(IO &IO, MachOYAML::FatArch &FatArch); 175 }; 176 177 template <> struct MappingTraits<MachOYAML::UniversalBinary> { 178 static void mapping(IO &IO, MachOYAML::UniversalBinary &UniversalBinary); 179 }; 180 181 template <> struct MappingTraits<MachOYAML::LoadCommand> { 182 static void mapping(IO &IO, MachOYAML::LoadCommand &LoadCommand); 183 }; 184 185 template <> struct MappingTraits<MachOYAML::LinkEditData> { 186 static void mapping(IO &IO, MachOYAML::LinkEditData &LinkEditData); 187 }; 188 189 template <> struct MappingTraits<MachOYAML::RebaseOpcode> { 190 static void mapping(IO &IO, MachOYAML::RebaseOpcode &RebaseOpcode); 191 }; 192 193 template <> struct MappingTraits<MachOYAML::BindOpcode> { 194 static void mapping(IO &IO, MachOYAML::BindOpcode &BindOpcode); 195 }; 196 197 template <> struct MappingTraits<MachOYAML::ExportEntry> { 198 static void mapping(IO &IO, MachOYAML::ExportEntry &ExportEntry); 199 }; 200 201 template <> struct MappingTraits<MachOYAML::Section> { 202 static void mapping(IO &IO, MachOYAML::Section &Section); 203 static StringRef validate(IO &io, MachOYAML::Section &Section); 204 }; 205 206 template <> struct MappingTraits<MachOYAML::NListEntry> { 207 static void mapping(IO &IO, MachOYAML::NListEntry &NListEntry); 208 }; 209 210 template <> struct MappingTraits<MachO::build_tool_version> { 211 static void mapping(IO &IO, MachO::build_tool_version &tool); 212 }; 213 214 #define HANDLE_LOAD_COMMAND(LCName, LCValue, LCStruct) \ 215 io.enumCase(value, #LCName, MachO::LCName); 216 217 template <> struct ScalarEnumerationTraits<MachO::LoadCommandType> { 218 static void enumeration(IO &io, MachO::LoadCommandType &value) { 219 #include "llvm/BinaryFormat/MachO.def" 220 io.enumFallback<Hex32>(value); 221 } 222 }; 223 224 #define ENUM_CASE(Enum) io.enumCase(value, #Enum, MachO::Enum); 225 226 template <> struct ScalarEnumerationTraits<MachO::RebaseOpcode> { 227 static void enumeration(IO &io, MachO::RebaseOpcode &value) { 228 ENUM_CASE(REBASE_OPCODE_DONE) 229 ENUM_CASE(REBASE_OPCODE_SET_TYPE_IMM) 230 ENUM_CASE(REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB) 231 ENUM_CASE(REBASE_OPCODE_ADD_ADDR_ULEB) 232 ENUM_CASE(REBASE_OPCODE_ADD_ADDR_IMM_SCALED) 233 ENUM_CASE(REBASE_OPCODE_DO_REBASE_IMM_TIMES) 234 ENUM_CASE(REBASE_OPCODE_DO_REBASE_ULEB_TIMES) 235 ENUM_CASE(REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB) 236 ENUM_CASE(REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB) 237 io.enumFallback<Hex8>(value); 238 } 239 }; 240 241 template <> struct ScalarEnumerationTraits<MachO::BindOpcode> { 242 static void enumeration(IO &io, MachO::BindOpcode &value) { 243 ENUM_CASE(BIND_OPCODE_DONE) 244 ENUM_CASE(BIND_OPCODE_SET_DYLIB_ORDINAL_IMM) 245 ENUM_CASE(BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB) 246 ENUM_CASE(BIND_OPCODE_SET_DYLIB_SPECIAL_IMM) 247 ENUM_CASE(BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM) 248 ENUM_CASE(BIND_OPCODE_SET_TYPE_IMM) 249 ENUM_CASE(BIND_OPCODE_SET_ADDEND_SLEB) 250 ENUM_CASE(BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB) 251 ENUM_CASE(BIND_OPCODE_ADD_ADDR_ULEB) 252 ENUM_CASE(BIND_OPCODE_DO_BIND) 253 ENUM_CASE(BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB) 254 ENUM_CASE(BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED) 255 ENUM_CASE(BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB) 256 io.enumFallback<Hex8>(value); 257 } 258 }; 259 260 // This trait is used for 16-byte chars in Mach structures used for strings 261 using char_16 = char[16]; 262 263 template <> struct ScalarTraits<char_16> { 264 static void output(const char_16 &Val, void *, raw_ostream &Out); 265 static StringRef input(StringRef Scalar, void *, char_16 &Val); 266 static QuotingType mustQuote(StringRef S); 267 }; 268 269 // This trait is used for UUIDs. It reads and writes them matching otool's 270 // formatting style. 271 using uuid_t = raw_ostream::uuid_t; 272 273 template <> struct ScalarTraits<uuid_t> { 274 static void output(const uuid_t &Val, void *, raw_ostream &Out); 275 static StringRef input(StringRef Scalar, void *, uuid_t &Val); 276 static QuotingType mustQuote(StringRef S); 277 }; 278 279 // Load Command struct mapping traits 280 281 #define LOAD_COMMAND_STRUCT(LCStruct) \ 282 template <> struct MappingTraits<MachO::LCStruct> { \ 283 static void mapping(IO &IO, MachO::LCStruct &LoadCommand); \ 284 }; 285 286 #include "llvm/BinaryFormat/MachO.def" 287 288 // Extra structures used by load commands 289 template <> struct MappingTraits<MachO::dylib> { 290 static void mapping(IO &IO, MachO::dylib &LoadCommand); 291 }; 292 293 template <> struct MappingTraits<MachO::fvmlib> { 294 static void mapping(IO &IO, MachO::fvmlib &LoadCommand); 295 }; 296 297 template <> struct MappingTraits<MachO::section> { 298 static void mapping(IO &IO, MachO::section &LoadCommand); 299 }; 300 301 template <> struct MappingTraits<MachO::section_64> { 302 static void mapping(IO &IO, MachO::section_64 &LoadCommand); 303 }; 304 305 } // end namespace yaml 306 307 } // end namespace llvm 308 309 #endif // LLVM_OBJECTYAML_MACHOYAML_H 310