include/llvm/ObjectYAML/MachOYAML.h

   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