Home | History | Annotate | Line # | Download | only in ObjectYAML 
      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 PayloadString;
     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 
    125   bool isEmpty() const;
    126 };
    127 
    128 struct Object {
    129   bool IsLittleEndian;
    130   FileHeader Header;
    131   std::vector<LoadCommand> LoadCommands;
    132   std::vector<Section> Sections;
    133   LinkEditData LinkEdit;
    134   DWARFYAML::Data DWARF;
    135 };
    136 
    137 struct FatHeader {
    138   llvm::yaml::Hex32 magic;
    139   uint32_t nfat_arch;
    140 };
    141 
    142 struct FatArch {
    143   llvm::yaml::Hex32 cputype;
    144   llvm::yaml::Hex32 cpusubtype;
    145   llvm::yaml::Hex64 offset;
    146   uint64_t size;
    147   uint32_t align;
    148   llvm::yaml::Hex32 reserved;
    149 };
    150 
    151 struct UniversalBinary {
    152   FatHeader Header;
    153   std::vector<FatArch> FatArchs;
    154   std::vector<Object> Slices;
    155 };
    156 
    157 } // end namespace MachOYAML
    158 } // end namespace llvm
    159 
    160 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::LoadCommand)
    161 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::Relocation)
    162 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::Section)
    163 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::RebaseOpcode)
    164 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::BindOpcode)
    165 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::ExportEntry)
    166 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::NListEntry)
    167 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::Object)
    168 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::FatArch)
    169 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachO::build_tool_version)
    170 
    171 namespace llvm {
    172 
    173 class raw_ostream;
    174 
    175 namespace yaml {
    176 
    177 template <> struct MappingTraits<MachOYAML::FileHeader> {
    178   static void mapping(IO &IO, MachOYAML::FileHeader &FileHeader);
    179 };
    180 
    181 template <> struct MappingTraits<MachOYAML::Object> {
    182   static void mapping(IO &IO, MachOYAML::Object &Object);
    183 };
    184 
    185 template <> struct MappingTraits<MachOYAML::FatHeader> {
    186   static void mapping(IO &IO, MachOYAML::FatHeader &FatHeader);
    187 };
    188 
    189 template <> struct MappingTraits<MachOYAML::FatArch> {
    190   static void mapping(IO &IO, MachOYAML::FatArch &FatArch);
    191 };
    192 
    193 template <> struct MappingTraits<MachOYAML::UniversalBinary> {
    194   static void mapping(IO &IO, MachOYAML::UniversalBinary &UniversalBinary);
    195 };
    196 
    197 template <> struct MappingTraits<MachOYAML::LoadCommand> {
    198   static void mapping(IO &IO, MachOYAML::LoadCommand &LoadCommand);
    199 };
    200 
    201 template <> struct MappingTraits<MachOYAML::LinkEditData> {
    202   static void mapping(IO &IO, MachOYAML::LinkEditData &LinkEditData);
    203 };
    204 
    205 template <> struct MappingTraits<MachOYAML::RebaseOpcode> {
    206   static void mapping(IO &IO, MachOYAML::RebaseOpcode &RebaseOpcode);
    207 };
    208 
    209 template <> struct MappingTraits<MachOYAML::BindOpcode> {
    210   static void mapping(IO &IO, MachOYAML::BindOpcode &BindOpcode);
    211 };
    212 
    213 template <> struct MappingTraits<MachOYAML::ExportEntry> {
    214   static void mapping(IO &IO, MachOYAML::ExportEntry &ExportEntry);
    215 };
    216 
    217 template <> struct MappingTraits<MachOYAML::Relocation> {
    218   static void mapping(IO &IO, MachOYAML::Relocation &R);
    219 };
    220 
    221 template <> struct MappingTraits<MachOYAML::Section> {
    222   static void mapping(IO &IO, MachOYAML::Section &Section);
    223   static std::string validate(IO &io, MachOYAML::Section &Section);
    224 };
    225 
    226 template <> struct MappingTraits<MachOYAML::NListEntry> {
    227   static void mapping(IO &IO, MachOYAML::NListEntry &NListEntry);
    228 };
    229 
    230 template <> struct MappingTraits<MachO::build_tool_version> {
    231   static void mapping(IO &IO, MachO::build_tool_version &tool);
    232 };
    233 
    234 #define HANDLE_LOAD_COMMAND(LCName, LCValue, LCStruct)                         \
    235   io.enumCase(value, #LCName, MachO::LCName);
    236 
    237 template <> struct ScalarEnumerationTraits<MachO::LoadCommandType> {
    238   static void enumeration(IO &io, MachO::LoadCommandType &value) {
    239 #include "llvm/BinaryFormat/MachO.def"
    240     io.enumFallback<Hex32>(value);
    241   }
    242 };
    243 
    244 #define ENUM_CASE(Enum) io.enumCase(value, #Enum, MachO::Enum);
    245 
    246 template <> struct ScalarEnumerationTraits<MachO::RebaseOpcode> {
    247   static void enumeration(IO &io, MachO::RebaseOpcode &value) {
    248     ENUM_CASE(REBASE_OPCODE_DONE)
    249     ENUM_CASE(REBASE_OPCODE_SET_TYPE_IMM)
    250     ENUM_CASE(REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB)
    251     ENUM_CASE(REBASE_OPCODE_ADD_ADDR_ULEB)
    252     ENUM_CASE(REBASE_OPCODE_ADD_ADDR_IMM_SCALED)
    253     ENUM_CASE(REBASE_OPCODE_DO_REBASE_IMM_TIMES)
    254     ENUM_CASE(REBASE_OPCODE_DO_REBASE_ULEB_TIMES)
    255     ENUM_CASE(REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB)
    256     ENUM_CASE(REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB)
    257     io.enumFallback<Hex8>(value);
    258   }
    259 };
    260 
    261 template <> struct ScalarEnumerationTraits<MachO::BindOpcode> {
    262   static void enumeration(IO &io, MachO::BindOpcode &value) {
    263     ENUM_CASE(BIND_OPCODE_DONE)
    264     ENUM_CASE(BIND_OPCODE_SET_DYLIB_ORDINAL_IMM)
    265     ENUM_CASE(BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB)
    266     ENUM_CASE(BIND_OPCODE_SET_DYLIB_SPECIAL_IMM)
    267     ENUM_CASE(BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM)
    268     ENUM_CASE(BIND_OPCODE_SET_TYPE_IMM)
    269     ENUM_CASE(BIND_OPCODE_SET_ADDEND_SLEB)
    270     ENUM_CASE(BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB)
    271     ENUM_CASE(BIND_OPCODE_ADD_ADDR_ULEB)
    272     ENUM_CASE(BIND_OPCODE_DO_BIND)
    273     ENUM_CASE(BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB)
    274     ENUM_CASE(BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED)
    275     ENUM_CASE(BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB)
    276     io.enumFallback<Hex8>(value);
    277   }
    278 };
    279 
    280 // This trait is used for 16-byte chars in Mach structures used for strings
    281 using char_16 = char[16];
    282 
    283 template <> struct ScalarTraits<char_16> {
    284   static void output(const char_16 &Val, void *, raw_ostream &Out);
    285   static StringRef input(StringRef Scalar, void *, char_16 &Val);
    286   static QuotingType mustQuote(StringRef S);
    287 };
    288 
    289 // This trait is used for UUIDs. It reads and writes them matching otool's
    290 // formatting style.
    291 using uuid_t = raw_ostream::uuid_t;
    292 
    293 template <> struct ScalarTraits<uuid_t> {
    294   static void output(const uuid_t &Val, void *, raw_ostream &Out);
    295   static StringRef input(StringRef Scalar, void *, uuid_t &Val);
    296   static QuotingType mustQuote(StringRef S);
    297 };
    298 
    299 // Load Command struct mapping traits
    300 
    301 #define LOAD_COMMAND_STRUCT(LCStruct)                                          \
    302   template <> struct MappingTraits<MachO::LCStruct> {                          \
    303     static void mapping(IO &IO, MachO::LCStruct &LoadCommand);                 \
    304   };
    305 
    306 #include "llvm/BinaryFormat/MachO.def"
    307 
    308 // Extra structures used by load commands
    309 template <> struct MappingTraits<MachO::dylib> {
    310   static void mapping(IO &IO, MachO::dylib &LoadCommand);
    311 };
    312 
    313 template <> struct MappingTraits<MachO::fvmlib> {
    314   static void mapping(IO &IO, MachO::fvmlib &LoadCommand);
    315 };
    316 
    317 template <> struct MappingTraits<MachO::section> {
    318   static void mapping(IO &IO, MachO::section &LoadCommand);
    319 };
    320 
    321 template <> struct MappingTraits<MachO::section_64> {
    322   static void mapping(IO &IO, MachO::section_64 &LoadCommand);
    323 };
    324 
    325 } // end namespace yaml
    326 
    327 } // end namespace llvm
    328 
    329 #endif // LLVM_OBJECTYAML_MACHOYAML_H
    330