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