LCOV - code coverage report
Current view: top level - include/llvm/ObjectYAML - MachOYAML.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 38 38 100.0 %
Date: 2017-09-14 15:23:50 Functions: 18 21 85.7 %
Legend: Lines: hit not hit

          Line data    Source code
       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/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        8926 : 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         296 : struct RebaseOpcode {
      76             :   MachO::RebaseOpcode Opcode;
      77             :   uint8_t Imm;
      78             :   std::vector<yaml::Hex64> ExtraData;
      79             : };
      80             : 
      81      124347 : 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        1215 : 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         784 : 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         497 : 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          10 : 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         439 :   static void enumeration(IO &io, MachO::LoadCommandType &value) {
     217             : #include "llvm/BinaryFormat/MachO.def"
     218         439 :     io.enumFallback<Hex32>(value);
     219         439 :   }
     220             : };
     221             : 
     222             : #define ENUM_CASE(Enum) io.enumCase(value, #Enum, MachO::Enum);
     223             : 
     224             : template <> struct ScalarEnumerationTraits<MachO::RebaseOpcode> {
     225          32 :   static void enumeration(IO &io, MachO::RebaseOpcode &value) {
     226          32 :     ENUM_CASE(REBASE_OPCODE_DONE)
     227          32 :     ENUM_CASE(REBASE_OPCODE_SET_TYPE_IMM)
     228          32 :     ENUM_CASE(REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB)
     229          32 :     ENUM_CASE(REBASE_OPCODE_ADD_ADDR_ULEB)
     230          32 :     ENUM_CASE(REBASE_OPCODE_ADD_ADDR_IMM_SCALED)
     231          32 :     ENUM_CASE(REBASE_OPCODE_DO_REBASE_IMM_TIMES)
     232          32 :     ENUM_CASE(REBASE_OPCODE_DO_REBASE_ULEB_TIMES)
     233          32 :     ENUM_CASE(REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB)
     234          32 :     ENUM_CASE(REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB)
     235          32 :     io.enumFallback<Hex8>(value);
     236          32 :   }
     237             : };
     238             : 
     239             : template <> struct ScalarEnumerationTraits<MachO::BindOpcode> {
     240        6075 :   static void enumeration(IO &io, MachO::BindOpcode &value) {
     241        6075 :     ENUM_CASE(BIND_OPCODE_DONE)
     242        6075 :     ENUM_CASE(BIND_OPCODE_SET_DYLIB_ORDINAL_IMM)
     243        6075 :     ENUM_CASE(BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB)
     244        6075 :     ENUM_CASE(BIND_OPCODE_SET_DYLIB_SPECIAL_IMM)
     245        6075 :     ENUM_CASE(BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM)
     246        6075 :     ENUM_CASE(BIND_OPCODE_SET_TYPE_IMM)
     247        6075 :     ENUM_CASE(BIND_OPCODE_SET_ADDEND_SLEB)
     248        6075 :     ENUM_CASE(BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB)
     249        6075 :     ENUM_CASE(BIND_OPCODE_ADD_ADDR_ULEB)
     250        6075 :     ENUM_CASE(BIND_OPCODE_DO_BIND)
     251        6075 :     ENUM_CASE(BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB)
     252        6075 :     ENUM_CASE(BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED)
     253        6075 :     ENUM_CASE(BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB)
     254        6075 :     io.enumFallback<Hex8>(value);
     255        6075 :   }
     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 bool 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 bool 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

Generated by: LCOV version 1.13