contrib/llvm/include/llvm/ObjectYAML/MachOYAML.h

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