1 //===- Object.h - Mach-O object file model ----------------------*- 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 #ifndef LLVM_OBJCOPY_MACHO_OBJECT_H 10 #define LLVM_OBJCOPY_MACHO_OBJECT_H 11 12 #include "llvm/ADT/Optional.h" 13 #include "llvm/ADT/StringRef.h" 14 #include "llvm/BinaryFormat/MachO.h" 15 #include "llvm/MC/StringTableBuilder.h" 16 #include "llvm/ObjectYAML/DWARFYAML.h" 17 #include "llvm/Support/YAMLTraits.h" 18 #include <cstdint> 19 #include <string> 20 #include <vector> 21 22 namespace llvm { 23 namespace objcopy { 24 namespace macho { 25 26 struct MachHeader { 27 uint32_t Magic; 28 uint32_t CPUType; 29 uint32_t CPUSubType; 30 uint32_t FileType; 31 uint32_t NCmds; 32 uint32_t SizeOfCmds; 33 uint32_t Flags; 34 uint32_t Reserved = 0; 35 }; 36 37 struct RelocationInfo; 38 struct Section { 39 std::string Sectname; 40 std::string Segname; 41 uint64_t Addr; 42 uint64_t Size; 43 uint32_t Offset; 44 uint32_t Align; 45 uint32_t RelOff; 46 uint32_t NReloc; 47 uint32_t Flags; 48 uint32_t Reserved1; 49 uint32_t Reserved2; 50 uint32_t Reserved3; 51 52 StringRef Content; 53 std::vector<RelocationInfo> Relocations; 54 getTypeSection55 MachO::SectionType getType() const { 56 return static_cast<MachO::SectionType>(Flags & MachO::SECTION_TYPE); 57 } 58 isVirtualSectionSection59 bool isVirtualSection() const { 60 return (getType() == MachO::S_ZEROFILL || 61 getType() == MachO::S_GB_ZEROFILL || 62 getType() == MachO::S_THREAD_LOCAL_ZEROFILL); 63 } 64 }; 65 66 struct LoadCommand { 67 // The type MachO::macho_load_command is defined in llvm/BinaryFormat/MachO.h 68 // and it is a union of all the structs corresponding to various load 69 // commands. 70 MachO::macho_load_command MachOLoadCommand; 71 72 // The raw content of the payload of the load command (located right after the 73 // corresponding struct). In some cases it is either empty or can be 74 // copied-over without digging into its structure. 75 ArrayRef<uint8_t> Payload; 76 77 // Some load commands can contain (inside the payload) an array of sections, 78 // though the contents of the sections are stored separately. The struct 79 // Section describes only sections' metadata and where to find the 80 // corresponding content inside the binary. 81 std::vector<Section> Sections; 82 }; 83 84 // A symbol information. Fields which starts with "n_" are same as them in the 85 // nlist. 86 struct SymbolEntry { 87 std::string Name; 88 uint32_t Index; 89 uint8_t n_type; 90 uint8_t n_sect; 91 uint16_t n_desc; 92 uint64_t n_value; 93 }; 94 95 /// The location of the symbol table inside the binary is described by LC_SYMTAB 96 /// load command. 97 struct SymbolTable { 98 std::vector<std::unique_ptr<SymbolEntry>> Symbols; 99 100 const SymbolEntry *getSymbolByIndex(uint32_t Index) const; 101 }; 102 103 /// The location of the string table inside the binary is described by LC_SYMTAB 104 /// load command. 105 struct StringTable { 106 std::vector<std::string> Strings; 107 }; 108 109 struct RelocationInfo { 110 const SymbolEntry *Symbol; 111 // True if Info is a scattered_relocation_info. 112 bool Scattered; 113 MachO::any_relocation_info Info; 114 }; 115 116 /// The location of the rebase info inside the binary is described by 117 /// LC_DYLD_INFO load command. Dyld rebases an image whenever dyld loads it at 118 /// an address different from its preferred address. The rebase information is 119 /// a stream of byte sized opcodes whose symbolic names start with 120 /// REBASE_OPCODE_. Conceptually the rebase information is a table of tuples: 121 /// <seg-index, seg-offset, type> 122 /// The opcodes are a compressed way to encode the table by only 123 /// encoding when a column changes. In addition simple patterns 124 /// like "every n'th offset for m times" can be encoded in a few 125 /// bytes. 126 struct RebaseInfo { 127 // At the moment we do not parse this info (and it is simply copied over), 128 // but the proper support will be added later. 129 ArrayRef<uint8_t> Opcodes; 130 }; 131 132 /// The location of the bind info inside the binary is described by 133 /// LC_DYLD_INFO load command. Dyld binds an image during the loading process, 134 /// if the image requires any pointers to be initialized to symbols in other 135 /// images. The bind information is a stream of byte sized opcodes whose 136 /// symbolic names start with BIND_OPCODE_. Conceptually the bind information is 137 /// a table of tuples: <seg-index, seg-offset, type, symbol-library-ordinal, 138 /// symbol-name, addend> The opcodes are a compressed way to encode the table by 139 /// only encoding when a column changes. In addition simple patterns like for 140 /// runs of pointers initialized to the same value can be encoded in a few 141 /// bytes. 142 struct BindInfo { 143 // At the moment we do not parse this info (and it is simply copied over), 144 // but the proper support will be added later. 145 ArrayRef<uint8_t> Opcodes; 146 }; 147 148 /// The location of the weak bind info inside the binary is described by 149 /// LC_DYLD_INFO load command. Some C++ programs require dyld to unique symbols 150 /// so that all images in the process use the same copy of some code/data. This 151 /// step is done after binding. The content of the weak_bind info is an opcode 152 /// stream like the bind_info. But it is sorted alphabetically by symbol name. 153 /// This enable dyld to walk all images with weak binding information in order 154 /// and look for collisions. If there are no collisions, dyld does no updating. 155 /// That means that some fixups are also encoded in the bind_info. For 156 /// instance, all calls to "operator new" are first bound to libstdc++.dylib 157 /// using the information in bind_info. Then if some image overrides operator 158 /// new that is detected when the weak_bind information is processed and the 159 /// call to operator new is then rebound. 160 struct WeakBindInfo { 161 // At the moment we do not parse this info (and it is simply copied over), 162 // but the proper support will be added later. 163 ArrayRef<uint8_t> Opcodes; 164 }; 165 166 /// The location of the lazy bind info inside the binary is described by 167 /// LC_DYLD_INFO load command. Some uses of external symbols do not need to be 168 /// bound immediately. Instead they can be lazily bound on first use. The 169 /// lazy_bind contains a stream of BIND opcodes to bind all lazy symbols. Normal 170 /// use is that dyld ignores the lazy_bind section when loading an image. 171 /// Instead the static linker arranged for the lazy pointer to initially point 172 /// to a helper function which pushes the offset into the lazy_bind area for the 173 /// symbol needing to be bound, then jumps to dyld which simply adds the offset 174 /// to lazy_bind_off to get the information on what to bind. 175 struct LazyBindInfo { 176 ArrayRef<uint8_t> Opcodes; 177 }; 178 179 /// The location of the export info inside the binary is described by 180 /// LC_DYLD_INFO load command. The symbols exported by a dylib are encoded in a 181 /// trie. This is a compact representation that factors out common prefixes. It 182 /// also reduces LINKEDIT pages in RAM because it encodes all information (name, 183 /// address, flags) in one small, contiguous range. The export area is a stream 184 /// of nodes. The first node sequentially is the start node for the trie. Nodes 185 /// for a symbol start with a uleb128 that is the length of the exported symbol 186 /// information for the string so far. If there is no exported symbol, the node 187 /// starts with a zero byte. If there is exported info, it follows the length. 188 /// First is a uleb128 containing flags. Normally, it is followed by 189 /// a uleb128 encoded offset which is location of the content named 190 /// by the symbol from the mach_header for the image. If the flags 191 /// is EXPORT_SYMBOL_FLAGS_REEXPORT, then following the flags is 192 /// a uleb128 encoded library ordinal, then a zero terminated 193 /// UTF8 string. If the string is zero length, then the symbol 194 /// is re-export from the specified dylib with the same name. 195 /// If the flags is EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER, then following 196 /// the flags is two uleb128s: the stub offset and the resolver offset. 197 /// The stub is used by non-lazy pointers. The resolver is used 198 /// by lazy pointers and must be called to get the actual address to use. 199 /// After the optional exported symbol information is a byte of 200 /// how many edges (0-255) that this node has leaving it, 201 /// followed by each edge. 202 /// Each edge is a zero terminated UTF8 of the addition chars 203 /// in the symbol, followed by a uleb128 offset for the node that 204 /// edge points to. 205 struct ExportInfo { 206 ArrayRef<uint8_t> Trie; 207 }; 208 209 struct Object { 210 MachHeader Header; 211 std::vector<LoadCommand> LoadCommands; 212 213 SymbolTable SymTable; 214 StringTable StrTable; 215 216 RebaseInfo Rebases; 217 BindInfo Binds; 218 WeakBindInfo WeakBinds; 219 LazyBindInfo LazyBinds; 220 ExportInfo Exports; 221 222 /// The index of LC_SYMTAB load command if present. 223 Optional<size_t> SymTabCommandIndex; 224 /// The index of LC_DYLD_INFO or LC_DYLD_INFO_ONLY load command if present. 225 Optional<size_t> DyLdInfoCommandIndex; 226 }; 227 228 } // end namespace macho 229 } // end namespace objcopy 230 } // end namespace llvm 231 232 #endif // LLVM_OBJCOPY_MACHO_OBJECT_H 233