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