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