| 1 | /*␊ |
| 2 | * Copyright (c) 1999-2010 Apple Inc. All Rights Reserved.␊ |
| 3 | *␊ |
| 4 | * @APPLE_LICENSE_HEADER_START@␊ |
| 5 | *␊ |
| 6 | * This file contains Original Code and/or Modifications of Original Code␊ |
| 7 | * as defined in and that are subject to the Apple Public Source License␊ |
| 8 | * Version 2.0 (the 'License'). You may not use this file except in␊ |
| 9 | * compliance with the License. Please obtain a copy of the License at␊ |
| 10 | * http://www.opensource.apple.com/apsl/ and read it before using this␊ |
| 11 | * file.␊ |
| 12 | *␊ |
| 13 | * The Original Code and all software distributed under the License are␊ |
| 14 | * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER␊ |
| 15 | * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,␊ |
| 16 | * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,␊ |
| 17 | * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.␊ |
| 18 | * Please see the License for the specific language governing rights and␊ |
| 19 | * limitations under the License.␊ |
| 20 | *␊ |
| 21 | * @APPLE_LICENSE_HEADER_END@␊ |
| 22 | */␊ |
| 23 | #ifndef _MACHO_LOADER_H_␊ |
| 24 | #define _MACHO_LOADER_H_␊ |
| 25 | ␊ |
| 26 | /*␊ |
| 27 | * This file describes the format of mach object files.␊ |
| 28 | */␊ |
| 29 | #include <stdint.h>␊ |
| 30 | ␊ |
| 31 | /*␊ |
| 32 | * <mach/machine.h> is needed here for the cpu_type_t and cpu_subtype_t types␊ |
| 33 | * and contains the constants for the possible values of these types.␊ |
| 34 | */␊ |
| 35 | #include <mach/machine.h>␊ |
| 36 | ␊ |
| 37 | /*␊ |
| 38 | * <mach/vm_prot.h> is needed here for the vm_prot_t type and contains the␊ |
| 39 | * constants that are or'ed together for the possible values of this type.␊ |
| 40 | */␊ |
| 41 | #include <mach/vm_prot.h>␊ |
| 42 | ␊ |
| 43 | /*␊ |
| 44 | * <machine/thread_status.h> is expected to define the flavors of the thread␊ |
| 45 | * states and the structures of those flavors for each machine.␊ |
| 46 | */␊ |
| 47 | #include <mach/machine/thread_status.h>␊ |
| 48 | #include <architecture/byte_order.h>␊ |
| 49 | ␊ |
| 50 | /*␊ |
| 51 | * The 32-bit mach header appears at the very beginning of the object file for␊ |
| 52 | * 32-bit architectures.␊ |
| 53 | */␊ |
| 54 | struct mach_header {␊ |
| 55 | ␉uint32_t␉magic;␉␉/* mach magic number identifier */␊ |
| 56 | ␉cpu_type_t␉cputype;␉/* cpu specifier */␊ |
| 57 | ␉cpu_subtype_t␉cpusubtype;␉/* machine specifier */␊ |
| 58 | ␉uint32_t␉filetype;␉/* type of file */␊ |
| 59 | ␉uint32_t␉ncmds;␉␉/* number of load commands */␊ |
| 60 | ␉uint32_t␉sizeofcmds;␉/* the size of all the load commands */␊ |
| 61 | ␉uint32_t␉flags;␉␉/* flags */␊ |
| 62 | };␊ |
| 63 | ␊ |
| 64 | /* Constant for the magic field of the mach_header (32-bit architectures) */␊ |
| 65 | #define␉MH_MAGIC␉0xfeedface␉/* the mach magic number */␊ |
| 66 | #define MH_CIGAM␉0xcefaedfe␉/* NXSwapInt(MH_MAGIC) */␊ |
| 67 | ␊ |
| 68 | /*␊ |
| 69 | * The 64-bit mach header appears at the very beginning of object files for␊ |
| 70 | * 64-bit architectures.␊ |
| 71 | */␊ |
| 72 | struct mach_header_64 {␊ |
| 73 | ␉uint32_t␉magic;␉␉/* mach magic number identifier */␊ |
| 74 | ␉cpu_type_t␉cputype;␉/* cpu specifier */␊ |
| 75 | ␉cpu_subtype_t␉cpusubtype;␉/* machine specifier */␊ |
| 76 | ␉uint32_t␉filetype;␉/* type of file */␊ |
| 77 | ␉uint32_t␉ncmds;␉␉/* number of load commands */␊ |
| 78 | ␉uint32_t␉sizeofcmds;␉/* the size of all the load commands */␊ |
| 79 | ␉uint32_t␉flags;␉␉/* flags */␊ |
| 80 | ␉uint32_t␉reserved;␉/* reserved */␊ |
| 81 | };␊ |
| 82 | ␊ |
| 83 | /* Constant for the magic field of the mach_header_64 (64-bit architectures) */␊ |
| 84 | #define MH_MAGIC_64 0xfeedfacf /* the 64-bit mach magic number */␊ |
| 85 | #define MH_CIGAM_64 0xcffaedfe /* NXSwapInt(MH_MAGIC_64) */␊ |
| 86 | ␊ |
| 87 | /*␊ |
| 88 | * The layout of the file depends on the filetype. For all but the MH_OBJECT␊ |
| 89 | * file type the segments are padded out and aligned on a segment alignment␊ |
| 90 | * boundary for efficient demand pageing. The MH_EXECUTE, MH_FVMLIB, MH_DYLIB,␊ |
| 91 | * MH_DYLINKER and MH_BUNDLE file types also have the headers included as part␊ |
| 92 | * of their first segment.␊ |
| 93 | *␊ |
| 94 | * The file type MH_OBJECT is a compact format intended as output of the␊ |
| 95 | * assembler and input (and possibly output) of the link editor (the .o␊ |
| 96 | * format). All sections are in one unnamed segment with no segment padding.␊ |
| 97 | * This format is used as an executable format when the file is so small the␊ |
| 98 | * segment padding greatly increases its size.␊ |
| 99 | *␊ |
| 100 | * The file type MH_PRELOAD is an executable format intended for things that␊ |
| 101 | * are not executed under the kernel (proms, stand alones, kernels, etc). The␊ |
| 102 | * format can be executed under the kernel but may demand paged it and not␊ |
| 103 | * preload it before execution.␊ |
| 104 | *␊ |
| 105 | * A core file is in MH_CORE format and can be any in an arbritray legal␊ |
| 106 | * Mach-O file.␊ |
| 107 | *␊ |
| 108 | * Constants for the filetype field of the mach_header␊ |
| 109 | */␊ |
| 110 | #define␉MH_OBJECT␉0x1␉␉/* relocatable object file */␊ |
| 111 | #define␉MH_EXECUTE␉0x2␉␉/* demand paged executable file */␊ |
| 112 | #define␉MH_FVMLIB␉0x3␉␉/* fixed VM shared library file */␊ |
| 113 | #define␉MH_CORE␉␉0x4␉␉/* core file */␊ |
| 114 | #define␉MH_PRELOAD␉0x5␉␉/* preloaded executable file */␊ |
| 115 | #define␉MH_DYLIB␉0x6␉␉/* dynamically bound shared library */␊ |
| 116 | #define␉MH_DYLINKER␉0x7␉␉/* dynamic link editor */␊ |
| 117 | #define␉MH_BUNDLE␉0x8␉␉/* dynamically bound bundle file */␊ |
| 118 | #define␉MH_DYLIB_STUB␉0x9␉␉/* shared library stub for static */␊ |
| 119 | ␉␉␉␉␉/* linking only, no section contents */␊ |
| 120 | #define␉MH_DSYM␉␉0xa␉␉/* companion file with only debug */␊ |
| 121 | ␉␉␉␉␉/* sections */␊ |
| 122 | #define␉MH_KEXT_BUNDLE␉0xb␉␉/* x86_64 kexts */␊ |
| 123 | ␊ |
| 124 | /* Constants for the flags field of the mach_header */␊ |
| 125 | #define␉MH_NOUNDEFS␉0x1␉␉/* the object file has no undefined␊ |
| 126 | ␉␉␉␉␉ references */␊ |
| 127 | #define␉MH_INCRLINK␉0x2␉␉/* the object file is the output of an␊ |
| 128 | ␉␉␉␉␉ incremental link against a base file␊ |
| 129 | ␉␉␉␉␉ and can't be link edited again */␊ |
| 130 | #define MH_DYLDLINK␉0x4␉␉/* the object file is input for the␊ |
| 131 | ␉␉␉␉␉ dynamic linker and can't be staticly␊ |
| 132 | ␉␉␉␉␉ link edited again */␊ |
| 133 | #define MH_BINDATLOAD␉0x8␉␉/* the object file's undefined␊ |
| 134 | ␉␉␉␉␉ references are bound by the dynamic␊ |
| 135 | ␉␉␉␉␉ linker when loaded. */␊ |
| 136 | #define MH_PREBOUND␉0x10␉␉/* the file has its dynamic undefined␊ |
| 137 | ␉␉␉␉␉ references prebound. */␊ |
| 138 | #define MH_SPLIT_SEGS␉0x20␉␉/* the file has its read-only and␊ |
| 139 | ␉␉␉␉␉ read-write segments split */␊ |
| 140 | #define MH_LAZY_INIT␉0x40␉␉/* the shared library init routine is␊ |
| 141 | ␉␉␉␉␉ to be run lazily via catching memory␊ |
| 142 | ␉␉␉␉␉ faults to its writeable segments␊ |
| 143 | ␉␉␉␉␉ (obsolete) */␊ |
| 144 | #define MH_TWOLEVEL␉0x80␉␉/* the image is using two-level name␊ |
| 145 | ␉␉␉␉␉ space bindings */␊ |
| 146 | #define MH_FORCE_FLAT␉0x100␉␉/* the executable is forcing all images␊ |
| 147 | ␉␉␉␉␉ to use flat name space bindings */␊ |
| 148 | #define MH_NOMULTIDEFS␉0x200␉␉/* this umbrella guarantees no multiple␊ |
| 149 | ␉␉␉␉␉ defintions of symbols in its␊ |
| 150 | ␉␉␉␉␉ sub-images so the two-level namespace␊ |
| 151 | ␉␉␉␉␉ hints can always be used. */␊ |
| 152 | #define MH_NOFIXPREBINDING 0x400␉/* do not have dyld notify the␊ |
| 153 | ␉␉␉␉␉ prebinding agent about this␊ |
| 154 | ␉␉␉␉␉ executable */␊ |
| 155 | #define MH_PREBINDABLE 0x800 /* the binary is not prebound but can␊ |
| 156 | ␉␉␉␉␉ have its prebinding redone. only used␊ |
| 157 | when MH_PREBOUND is not set. */␊ |
| 158 | #define MH_ALLMODSBOUND 0x1000␉␉/* indicates that this binary binds to␊ |
| 159 | all two-level namespace modules of␊ |
| 160 | ␉␉␉␉␉ its dependent libraries. only used␊ |
| 161 | ␉␉␉␉␉ when MH_PREBINDABLE and MH_TWOLEVEL␊ |
| 162 | ␉␉␉␉␉ are both set. */␊ |
| 163 | #define MH_SUBSECTIONS_VIA_SYMBOLS 0x2000/* safe to divide up the sections into␊ |
| 164 | ␉␉␉␉␉ sub-sections via symbols for dead␊ |
| 165 | ␉␉␉␉␉ code stripping */␊ |
| 166 | #define MH_CANONICAL 0x4000␉␉/* the binary has been canonicalized␊ |
| 167 | ␉␉␉␉␉ via the unprebind operation */␊ |
| 168 | #define MH_WEAK_DEFINES␉0x8000␉␉/* the final linked image contains␊ |
| 169 | ␉␉␉␉␉ external weak symbols */␊ |
| 170 | #define MH_BINDS_TO_WEAK 0x10000␉/* the final linked image uses␊ |
| 171 | ␉␉␉␉␉ weak symbols */␊ |
| 172 | ␊ |
| 173 | #define MH_ALLOW_STACK_EXECUTION 0x20000/* When this bit is set, all stacks␊ |
| 174 | ␉␉␉␉␉ in the task will be given stack␊ |
| 175 | ␉␉␉␉␉ execution privilege. Only used in␊ |
| 176 | ␉␉␉␉␉ MH_EXECUTE filetypes. */␊ |
| 177 | #define MH_ROOT_SAFE 0x40000 /* When this bit is set, the binary␊ |
| 178 | ␉␉␉␉␉ declares it is safe for use in␊ |
| 179 | ␉␉␉␉␉ processes with uid zero */␊ |
| 180 | ␊ |
| 181 | #define MH_SETUID_SAFE 0x80000 /* When this bit is set, the binary␊ |
| 182 | ␉␉␉␉␉ declares it is safe for use in␊ |
| 183 | ␉␉␉␉␉ processes when issetugid() is true */␊ |
| 184 | ␊ |
| 185 | #define MH_NO_REEXPORTED_DYLIBS 0x100000 /* When this bit is set on a dylib,␊ |
| 186 | ␉␉␉␉␉ the static linker does not need to␊ |
| 187 | ␉␉␉␉␉ examine dependent dylibs to see␊ |
| 188 | ␉␉␉␉␉ if any are re-exported */␊ |
| 189 | #define␉MH_PIE 0x200000␉␉␉/* When this bit is set, the OS will␊ |
| 190 | ␉␉␉␉␉ load the main executable at a␊ |
| 191 | ␉␉␉␉␉ random address. Only used in␊ |
| 192 | ␉␉␉␉␉ MH_EXECUTE filetypes. */␊ |
| 193 | #define␉MH_DEAD_STRIPPABLE_DYLIB 0x400000 /* Only for use on dylibs. When␊ |
| 194 | ␉␉␉␉␉ linking against a dylib that␊ |
| 195 | ␉␉␉␉␉ has this bit set, the static linker␊ |
| 196 | ␉␉␉␉␉ will automatically not create a␊ |
| 197 | ␉␉␉␉␉ LC_LOAD_DYLIB load command to the␊ |
| 198 | ␉␉␉␉␉ dylib if no symbols are being␊ |
| 199 | ␉␉␉␉␉ referenced from the dylib. */␊ |
| 200 | #define MH_HAS_TLV_DESCRIPTORS 0x800000 /* Contains a section of type␊ |
| 201 | ␉␉␉␉␉ S_THREAD_LOCAL_VARIABLES */␊ |
| 202 | ␊ |
| 203 | #define MH_NO_HEAP_EXECUTION 0x1000000␉/* When this bit is set, the OS will␊ |
| 204 | ␉␉␉␉␉ run the main executable with␊ |
| 205 | ␉␉␉␉␉ a non-executable heap even on␊ |
| 206 | ␉␉␉␉␉ platforms (e.g. i386) that don't␊ |
| 207 | ␉␉␉␉␉ require it. Only used in MH_EXECUTE␊ |
| 208 | ␉␉␉␉␉ filetypes. */␊ |
| 209 | ␊ |
| 210 | /*␊ |
| 211 | * The load commands directly follow the mach_header. The total size of all␊ |
| 212 | * of the commands is given by the sizeofcmds field in the mach_header. All␊ |
| 213 | * load commands must have as their first two fields cmd and cmdsize. The cmd␊ |
| 214 | * field is filled in with a constant for that command type. Each command type␊ |
| 215 | * has a structure specifically for it. The cmdsize field is the size in bytes␊ |
| 216 | * of the particular load command structure plus anything that follows it that␊ |
| 217 | * is a part of the load command (i.e. section structures, strings, etc.). To␊ |
| 218 | * advance to the next load command the cmdsize can be added to the offset or␊ |
| 219 | * pointer of the current load command. The cmdsize for 32-bit architectures␊ |
| 220 | * MUST be a multiple of 4 bytes and for 64-bit architectures MUST be a multiple␊ |
| 221 | * of 8 bytes (these are forever the maximum alignment of any load commands).␊ |
| 222 | * The padded bytes must be zero. All tables in the object file must also␊ |
| 223 | * follow these rules so the file can be memory mapped. Otherwise the pointers␊ |
| 224 | * to these tables will not work well or at all on some machines. With all␊ |
| 225 | * padding zeroed like objects will compare byte for byte.␊ |
| 226 | */␊ |
| 227 | struct load_command {␊ |
| 228 | ␉uint32_t cmd;␉␉/* type of load command */␊ |
| 229 | ␉uint32_t cmdsize;␉/* total size of command in bytes */␊ |
| 230 | };␊ |
| 231 | ␊ |
| 232 | /*␊ |
| 233 | * After MacOS X 10.1 when a new load command is added that is required to be␊ |
| 234 | * understood by the dynamic linker for the image to execute properly the␊ |
| 235 | * LC_REQ_DYLD bit will be or'ed into the load command constant. If the dynamic␊ |
| 236 | * linker sees such a load command it it does not understand will issue a␊ |
| 237 | * "unknown load command required for execution" error and refuse to use the␊ |
| 238 | * image. Other load commands without this bit that are not understood will␊ |
| 239 | * simply be ignored.␊ |
| 240 | */␊ |
| 241 | #define LC_REQ_DYLD 0x80000000␊ |
| 242 | ␊ |
| 243 | /* Constants for the cmd field of all load commands, the type */␊ |
| 244 | #define␉LC_SEGMENT␉0x1␉/* segment of this file to be mapped */␊ |
| 245 | #define␉LC_SYMTAB␉0x2␉/* link-edit stab symbol table info */␊ |
| 246 | #define␉LC_SYMSEG␉0x3␉/* link-edit gdb symbol table info (obsolete) */␊ |
| 247 | #define␉LC_THREAD␉0x4␉/* thread */␊ |
| 248 | #define␉LC_UNIXTHREAD␉0x5␉/* unix thread (includes a stack) */␊ |
| 249 | #define␉LC_LOADFVMLIB␉0x6␉/* load a specified fixed VM shared library */␊ |
| 250 | #define␉LC_IDFVMLIB␉0x7␉/* fixed VM shared library identification */␊ |
| 251 | #define␉LC_IDENT␉0x8␉/* object identification info (obsolete) */␊ |
| 252 | #define LC_FVMFILE␉0x9␉/* fixed VM file inclusion (internal use) */␊ |
| 253 | #define LC_PREPAGE 0xa /* prepage command (internal use) */␊ |
| 254 | #define␉LC_DYSYMTAB␉0xb␉/* dynamic link-edit symbol table info */␊ |
| 255 | #define␉LC_LOAD_DYLIB␉0xc␉/* load a dynamically linked shared library */␊ |
| 256 | #define␉LC_ID_DYLIB␉0xd␉/* dynamically linked shared lib ident */␊ |
| 257 | #define LC_LOAD_DYLINKER 0xe␉/* load a dynamic linker */␊ |
| 258 | #define LC_ID_DYLINKER␉0xf␉/* dynamic linker identification */␊ |
| 259 | #define␉LC_PREBOUND_DYLIB 0x10␉/* modules prebound for a dynamically */␊ |
| 260 | ␉␉␉␉/* linked shared library */␊ |
| 261 | #define␉LC_ROUTINES␉0x11␉/* image routines */␊ |
| 262 | #define␉LC_SUB_FRAMEWORK 0x12␉/* sub framework */␊ |
| 263 | #define␉LC_SUB_UMBRELLA 0x13␉/* sub umbrella */␊ |
| 264 | #define␉LC_SUB_CLIENT␉0x14␉/* sub client */␊ |
| 265 | #define␉LC_SUB_LIBRARY 0x15␉/* sub library */␊ |
| 266 | #define␉LC_TWOLEVEL_HINTS 0x16␉/* two-level namespace lookup hints */␊ |
| 267 | #define␉LC_PREBIND_CKSUM 0x17␉/* prebind checksum */␊ |
| 268 | ␊ |
| 269 | /*␊ |
| 270 | * load a dynamically linked shared library that is allowed to be missing␊ |
| 271 | * (all symbols are weak imported).␊ |
| 272 | */␊ |
| 273 | #define␉LC_LOAD_WEAK_DYLIB (0x18 | LC_REQ_DYLD)␊ |
| 274 | ␊ |
| 275 | #define␉LC_SEGMENT_64␉0x19␉/* 64-bit segment of this file to be␊ |
| 276 | ␉␉␉␉ mapped */␊ |
| 277 | #define␉LC_ROUTINES_64␉0x1a␉/* 64-bit image routines */␊ |
| 278 | #define LC_UUID␉␉0x1b␉/* the uuid */␊ |
| 279 | #define LC_RPATH (0x1c | LC_REQ_DYLD) /* runpath additions */␊ |
| 280 | #define LC_CODE_SIGNATURE 0x1d␉/* local of code signature */␊ |
| 281 | #define LC_SEGMENT_SPLIT_INFO 0x1e /* local of info to split segments */␊ |
| 282 | #define LC_REEXPORT_DYLIB (0x1f | LC_REQ_DYLD) /* load and re-export dylib */␊ |
| 283 | #define␉LC_LAZY_LOAD_DYLIB 0x20␉/* delay load of dylib until first use */␊ |
| 284 | #define␉LC_ENCRYPTION_INFO 0x21␉/* encrypted segment information */␊ |
| 285 | #define␉LC_DYLD_INFO ␉0x22␉/* compressed dyld information */␊ |
| 286 | #define␉LC_DYLD_INFO_ONLY (0x22|LC_REQ_DYLD)␉/* compressed dyld information only */␊ |
| 287 | #define␉LC_LOAD_UPWARD_DYLIB (0x23 | LC_REQ_DYLD) /* load upward dylib */␊ |
| 288 | #define LC_VERSION_MIN_MACOSX 0x24 /* build for MacOSX min OS version */␊ |
| 289 | #define LC_VERSION_MIN_IPHONEOS 0x25 /* build for iPhoneOS min OS version */␊ |
| 290 | #define LC_FUNCTION_STARTS 0x26 /* compressed table of function start addresses */␊ |
| 291 | #define LC_DYLD_ENVIRONMENT 0x27 /* string for dyld to treat␊ |
| 292 | ␉␉␉␉ like environment variable */␊ |
| 293 | #define LC_MAIN (0x28|LC_REQ_DYLD) /* replacement for LC_UNIXTHREAD */␊ |
| 294 | #define LC_DATA_IN_CODE 0x29 /* table of non-instructions in __text */␊ |
| 295 | #define LC_SOURCE_VERSION 0x2A /* source version used to build binary */␊ |
| 296 | #define LC_DYLIB_CODE_SIGN_DRS 0x2B /* Code signing DRs copied from linked dylibs */␊ |
| 297 | #define␉LC_ENCRYPTION_INFO_64 0x2C /* 64-bit encrypted segment information */␊ |
| 298 | ␊ |
| 299 | ␊ |
| 300 | /*␊ |
| 301 | * A variable length string in a load command is represented by an lc_str␊ |
| 302 | * union. The strings are stored just after the load command structure and␊ |
| 303 | * the offset is from the start of the load command structure. The size␊ |
| 304 | * of the string is reflected in the cmdsize field of the load command.␊ |
| 305 | * Once again any padded bytes to bring the cmdsize field to a multiple␊ |
| 306 | * of 4 bytes must be zero.␊ |
| 307 | */␊ |
| 308 | union lc_str {␊ |
| 309 | ␉uint32_t␉offset;␉/* offset to the string */␊ |
| 310 | #ifndef __LP64__␊ |
| 311 | ␉char␉␉*ptr;␉/* pointer to the string */␊ |
| 312 | #endif␊ |
| 313 | };␊ |
| 314 | ␊ |
| 315 | /*␊ |
| 316 | * The segment load command indicates that a part of this file is to be␊ |
| 317 | * mapped into the task's address space. The size of this segment in memory,␊ |
| 318 | * vmsize, maybe equal to or larger than the amount to map from this file,␊ |
| 319 | * filesize. The file is mapped starting at fileoff to the beginning of␊ |
| 320 | * the segment in memory, vmaddr. The rest of the memory of the segment,␊ |
| 321 | * if any, is allocated zero fill on demand. The segment's maximum virtual␊ |
| 322 | * memory protection and initial virtual memory protection are specified␊ |
| 323 | * by the maxprot and initprot fields. If the segment has sections then the␊ |
| 324 | * section structures directly follow the segment command and their size is␊ |
| 325 | * reflected in cmdsize.␊ |
| 326 | */␊ |
| 327 | struct segment_command { /* for 32-bit architectures */␊ |
| 328 | ␉uint32_t␉cmd;␉␉/* LC_SEGMENT */␊ |
| 329 | ␉uint32_t␉cmdsize;␉/* includes sizeof section structs */␊ |
| 330 | ␉char␉␉segname[16];␉/* segment name */␊ |
| 331 | ␉uint32_t␉vmaddr;␉␉/* memory address of this segment */␊ |
| 332 | ␉uint32_t␉vmsize;␉␉/* memory size of this segment */␊ |
| 333 | ␉uint32_t␉fileoff;␉/* file offset of this segment */␊ |
| 334 | ␉uint32_t␉filesize;␉/* amount to map from the file */␊ |
| 335 | ␉vm_prot_t␉maxprot;␉/* maximum VM protection */␊ |
| 336 | ␉vm_prot_t␉initprot;␉/* initial VM protection */␊ |
| 337 | ␉uint32_t␉nsects;␉␉/* number of sections in segment */␊ |
| 338 | ␉uint32_t␉flags;␉␉/* flags */␊ |
| 339 | };␊ |
| 340 | ␊ |
| 341 | /*␊ |
| 342 | * The 64-bit segment load command indicates that a part of this file is to be␊ |
| 343 | * mapped into a 64-bit task's address space. If the 64-bit segment has␊ |
| 344 | * sections then section_64 structures directly follow the 64-bit segment␊ |
| 345 | * command and their size is reflected in cmdsize.␊ |
| 346 | */␊ |
| 347 | struct segment_command_64 { /* for 64-bit architectures */␊ |
| 348 | ␉uint32_t␉cmd;␉␉/* LC_SEGMENT_64 */␊ |
| 349 | ␉uint32_t␉cmdsize;␉/* includes sizeof section_64 structs */␊ |
| 350 | ␉char␉␉segname[16];␉/* segment name */␊ |
| 351 | ␉uint64_t␉vmaddr;␉␉/* memory address of this segment */␊ |
| 352 | ␉uint64_t␉vmsize;␉␉/* memory size of this segment */␊ |
| 353 | ␉uint64_t␉fileoff;␉/* file offset of this segment */␊ |
| 354 | ␉uint64_t␉filesize;␉/* amount to map from the file */␊ |
| 355 | ␉vm_prot_t␉maxprot;␉/* maximum VM protection */␊ |
| 356 | ␉vm_prot_t␉initprot;␉/* initial VM protection */␊ |
| 357 | ␉uint32_t␉nsects;␉␉/* number of sections in segment */␊ |
| 358 | ␉uint32_t␉flags;␉␉/* flags */␊ |
| 359 | };␊ |
| 360 | ␊ |
| 361 | /* Constants for the flags field of the segment_command */␊ |
| 362 | #define␉SG_HIGHVM␉0x1␉/* the file contents for this segment is for␊ |
| 363 | ␉␉␉␉ the high part of the VM space, the low part␊ |
| 364 | ␉␉␉␉ is zero filled (for stacks in core files) */␊ |
| 365 | #define␉SG_FVMLIB␉0x2␉/* this segment is the VM that is allocated by␊ |
| 366 | ␉␉␉␉ a fixed VM library, for overlap checking in␊ |
| 367 | ␉␉␉␉ the link editor */␊ |
| 368 | #define␉SG_NORELOC␉0x4␉/* this segment has nothing that was relocated␊ |
| 369 | ␉␉␉␉ in it and nothing relocated to it, that is␊ |
| 370 | ␉␉␉␉ it maybe safely replaced without relocation*/␊ |
| 371 | #define SG_PROTECTED_VERSION_1␉0x8 /* This segment is protected. If the␊ |
| 372 | ␉␉␉␉ segment starts at file offset 0, the␊ |
| 373 | ␉␉␉␉ first page of the segment is not␊ |
| 374 | ␉␉␉␉ protected. All other pages of the␊ |
| 375 | ␉␉␉␉ segment are protected. */␊ |
| 376 | ␊ |
| 377 | /*␊ |
| 378 | * A segment is made up of zero or more sections. Non-MH_OBJECT files have␊ |
| 379 | * all of their segments with the proper sections in each, and padded to the␊ |
| 380 | * specified segment alignment when produced by the link editor. The first␊ |
| 381 | * segment of a MH_EXECUTE and MH_FVMLIB format file contains the mach_header␊ |
| 382 | * and load commands of the object file before its first section. The zero␊ |
| 383 | * fill sections are always last in their segment (in all formats). This␊ |
| 384 | * allows the zeroed segment padding to be mapped into memory where zero fill␊ |
| 385 | * sections might be. The gigabyte zero fill sections, those with the section␊ |
| 386 | * type S_GB_ZEROFILL, can only be in a segment with sections of this type.␊ |
| 387 | * These segments are then placed after all other segments.␊ |
| 388 | *␊ |
| 389 | * The MH_OBJECT format has all of its sections in one segment for␊ |
| 390 | * compactness. There is no padding to a specified segment boundary and the␊ |
| 391 | * mach_header and load commands are not part of the segment.␊ |
| 392 | *␊ |
| 393 | * Sections with the same section name, sectname, going into the same segment,␊ |
| 394 | * segname, are combined by the link editor. The resulting section is aligned␊ |
| 395 | * to the maximum alignment of the combined sections and is the new section's␊ |
| 396 | * alignment. The combined sections are aligned to their original alignment in␊ |
| 397 | * the combined section. Any padded bytes to get the specified alignment are␊ |
| 398 | * zeroed.␊ |
| 399 | *␊ |
| 400 | * The format of the relocation entries referenced by the reloff and nreloc␊ |
| 401 | * fields of the section structure for mach object files is described in the␊ |
| 402 | * header file <reloc.h>.␊ |
| 403 | */␊ |
| 404 | struct section { /* for 32-bit architectures */␊ |
| 405 | ␉char␉␉sectname[16];␉/* name of this section */␊ |
| 406 | ␉char␉␉segname[16];␉/* segment this section goes in */␊ |
| 407 | ␉uint32_t␉addr;␉␉/* memory address of this section */␊ |
| 408 | ␉uint32_t␉size;␉␉/* size in bytes of this section */␊ |
| 409 | ␉uint32_t␉offset;␉␉/* file offset of this section */␊ |
| 410 | ␉uint32_t␉align;␉␉/* section alignment (power of 2) */␊ |
| 411 | ␉uint32_t␉reloff;␉␉/* file offset of relocation entries */␊ |
| 412 | ␉uint32_t␉nreloc;␉␉/* number of relocation entries */␊ |
| 413 | ␉uint32_t␉flags;␉␉/* flags (section type and attributes)*/␊ |
| 414 | ␉uint32_t␉reserved1;␉/* reserved (for offset or index) */␊ |
| 415 | ␉uint32_t␉reserved2;␉/* reserved (for count or sizeof) */␊ |
| 416 | };␊ |
| 417 | ␊ |
| 418 | struct section_64 { /* for 64-bit architectures */␊ |
| 419 | ␉char␉␉sectname[16];␉/* name of this section */␊ |
| 420 | ␉char␉␉segname[16];␉/* segment this section goes in */␊ |
| 421 | ␉uint64_t␉addr;␉␉/* memory address of this section */␊ |
| 422 | ␉uint64_t␉size;␉␉/* size in bytes of this section */␊ |
| 423 | ␉uint32_t␉offset;␉␉/* file offset of this section */␊ |
| 424 | ␉uint32_t␉align;␉␉/* section alignment (power of 2) */␊ |
| 425 | ␉uint32_t␉reloff;␉␉/* file offset of relocation entries */␊ |
| 426 | ␉uint32_t␉nreloc;␉␉/* number of relocation entries */␊ |
| 427 | ␉uint32_t␉flags;␉␉/* flags (section type and attributes)*/␊ |
| 428 | ␉uint32_t␉reserved1;␉/* reserved (for offset or index) */␊ |
| 429 | ␉uint32_t␉reserved2;␉/* reserved (for count or sizeof) */␊ |
| 430 | ␉uint32_t␉reserved3;␉/* reserved */␊ |
| 431 | };␊ |
| 432 | ␊ |
| 433 | /*␊ |
| 434 | * The flags field of a section structure is separated into two parts a section␊ |
| 435 | * type and section attributes. The section types are mutually exclusive (it␊ |
| 436 | * can only have one type) but the section attributes are not (it may have more␊ |
| 437 | * than one attribute).␊ |
| 438 | */␊ |
| 439 | #define SECTION_TYPE␉␉ 0x000000ff␉/* 256 section types */␊ |
| 440 | #define SECTION_ATTRIBUTES␉ 0xffffff00␉/* 24 section attributes */␊ |
| 441 | ␊ |
| 442 | /* Constants for the type of a section */␊ |
| 443 | #define␉S_REGULAR␉␉0x0␉/* regular section */␊ |
| 444 | #define␉S_ZEROFILL␉␉0x1␉/* zero fill on demand section */␊ |
| 445 | #define␉S_CSTRING_LITERALS␉0x2␉/* section with only literal C strings*/␊ |
| 446 | #define␉S_4BYTE_LITERALS␉0x3␉/* section with only 4 byte literals */␊ |
| 447 | #define␉S_8BYTE_LITERALS␉0x4␉/* section with only 8 byte literals */␊ |
| 448 | #define␉S_LITERAL_POINTERS␉0x5␉/* section with only pointers to */␊ |
| 449 | ␉␉␉␉␉/* literals */␊ |
| 450 | /*␊ |
| 451 | * For the two types of symbol pointers sections and the symbol stubs section␊ |
| 452 | * they have indirect symbol table entries. For each of the entries in the␊ |
| 453 | * section the indirect symbol table entries, in corresponding order in the␊ |
| 454 | * indirect symbol table, start at the index stored in the reserved1 field␊ |
| 455 | * of the section structure. Since the indirect symbol table entries␊ |
| 456 | * correspond to the entries in the section the number of indirect symbol table␊ |
| 457 | * entries is inferred from the size of the section divided by the size of the␊ |
| 458 | * entries in the section. For symbol pointers sections the size of the entries␊ |
| 459 | * in the section is 4 bytes and for symbol stubs sections the byte size of the␊ |
| 460 | * stubs is stored in the reserved2 field of the section structure.␊ |
| 461 | */␊ |
| 462 | #define␉S_NON_LAZY_SYMBOL_POINTERS␉0x6␉/* section with only non-lazy␊ |
| 463 | ␉␉␉␉␉␉ symbol pointers */␊ |
| 464 | #define␉S_LAZY_SYMBOL_POINTERS␉␉0x7␉/* section with only lazy symbol␊ |
| 465 | ␉␉␉␉␉␉ pointers */␊ |
| 466 | #define␉S_SYMBOL_STUBS␉␉␉0x8␉/* section with only symbol␊ |
| 467 | ␉␉␉␉␉␉ stubs, byte size of stub in␊ |
| 468 | ␉␉␉␉␉␉ the reserved2 field */␊ |
| 469 | #define␉S_MOD_INIT_FUNC_POINTERS␉0x9␉/* section with only function␊ |
| 470 | ␉␉␉␉␉␉ pointers for initialization*/␊ |
| 471 | #define␉S_MOD_TERM_FUNC_POINTERS␉0xa␉/* section with only function␊ |
| 472 | ␉␉␉␉␉␉ pointers for termination */␊ |
| 473 | #define␉S_COALESCED␉␉␉0xb␉/* section contains symbols that␊ |
| 474 | ␉␉␉␉␉␉ are to be coalesced */␊ |
| 475 | #define␉S_GB_ZEROFILL␉␉␉0xc␉/* zero fill on demand section␊ |
| 476 | ␉␉␉␉␉␉ (that can be larger than 4␊ |
| 477 | ␉␉␉␉␉␉ gigabytes) */␊ |
| 478 | #define␉S_INTERPOSING␉␉␉0xd␉/* section with only pairs of␊ |
| 479 | ␉␉␉␉␉␉ function pointers for␊ |
| 480 | ␉␉␉␉␉␉ interposing */␊ |
| 481 | #define␉S_16BYTE_LITERALS␉␉0xe␉/* section with only 16 byte␊ |
| 482 | ␉␉␉␉␉␉ literals */␊ |
| 483 | #define␉S_DTRACE_DOF␉␉␉0xf␉/* section contains␊ |
| 484 | ␉␉␉␉␉␉ DTrace Object Format */␊ |
| 485 | #define␉S_LAZY_DYLIB_SYMBOL_POINTERS␉0x10␉/* section with only lazy␊ |
| 486 | ␉␉␉␉␉␉ symbol pointers to lazy␊ |
| 487 | ␉␉␉␉␉␉ loaded dylibs */␊ |
| 488 | /*␊ |
| 489 | * Section types to support thread local variables␊ |
| 490 | */␊ |
| 491 | #define S_THREAD_LOCAL_REGULAR 0x11 /* template of initial␊ |
| 492 | ␉␉␉␉␉␉␉ values for TLVs */␊ |
| 493 | #define S_THREAD_LOCAL_ZEROFILL 0x12 /* template of initial␊ |
| 494 | ␉␉␉␉␉␉␉ values for TLVs */␊ |
| 495 | #define S_THREAD_LOCAL_VARIABLES 0x13 /* TLV descriptors */␊ |
| 496 | #define S_THREAD_LOCAL_VARIABLE_POINTERS 0x14 /* pointers to TLV␊ |
| 497 | descriptors */␊ |
| 498 | #define S_THREAD_LOCAL_INIT_FUNCTION_POINTERS 0x15 /* functions to call␊ |
| 499 | ␉␉␉␉␉␉␉ to initialize TLV␊ |
| 500 | ␉␉␉␉␉␉␉ values */␊ |
| 501 | ␊ |
| 502 | /*␊ |
| 503 | * Constants for the section attributes part of the flags field of a section␊ |
| 504 | * structure.␊ |
| 505 | */␊ |
| 506 | #define SECTION_ATTRIBUTES_USR␉ 0xff000000␉/* User setable attributes */␊ |
| 507 | #define S_ATTR_PURE_INSTRUCTIONS 0x80000000␉/* section contains only true␊ |
| 508 | ␉␉␉␉␉␉ machine instructions */␊ |
| 509 | #define S_ATTR_NO_TOC ␉␉ 0x40000000␉/* section contains coalesced␊ |
| 510 | ␉␉␉␉␉␉ symbols that are not to be␊ |
| 511 | ␉␉␉␉␉␉ in a ranlib table of␊ |
| 512 | ␉␉␉␉␉␉ contents */␊ |
| 513 | #define S_ATTR_STRIP_STATIC_SYMS 0x20000000␉/* ok to strip static symbols␊ |
| 514 | ␉␉␉␉␉␉ in this section in files␊ |
| 515 | ␉␉␉␉␉␉ with the MH_DYLDLINK flag */␊ |
| 516 | #define S_ATTR_NO_DEAD_STRIP␉ 0x10000000␉/* no dead stripping */␊ |
| 517 | #define S_ATTR_LIVE_SUPPORT␉ 0x08000000␉/* blocks are live if they␊ |
| 518 | ␉␉␉␉␉␉ reference live blocks */␊ |
| 519 | #define S_ATTR_SELF_MODIFYING_CODE 0x04000000␉/* Used with i386 code stubs␊ |
| 520 | ␉␉␉␉␉␉ written on by dyld */␊ |
| 521 | /*␊ |
| 522 | * If a segment contains any sections marked with S_ATTR_DEBUG then all␊ |
| 523 | * sections in that segment must have this attribute. No section other than␊ |
| 524 | * a section marked with this attribute may reference the contents of this␊ |
| 525 | * section. A section with this attribute may contain no symbols and must have␊ |
| 526 | * a section type S_REGULAR. The static linker will not copy section contents␊ |
| 527 | * from sections with this attribute into its output file. These sections␊ |
| 528 | * generally contain DWARF debugging info.␊ |
| 529 | */␊ |
| 530 | #define␉S_ATTR_DEBUG␉␉ 0x02000000␉/* a debug section */␊ |
| 531 | #define SECTION_ATTRIBUTES_SYS␉ 0x00ffff00␉/* system setable attributes */␊ |
| 532 | #define S_ATTR_SOME_INSTRUCTIONS 0x00000400␉/* section contains some␊ |
| 533 | ␉␉␉␉␉␉ machine instructions */␊ |
| 534 | #define S_ATTR_EXT_RELOC␉ 0x00000200␉/* section has external␊ |
| 535 | ␉␉␉␉␉␉ relocation entries */␊ |
| 536 | #define S_ATTR_LOC_RELOC␉ 0x00000100␉/* section has local␊ |
| 537 | ␉␉␉␉␉␉ relocation entries */␊ |
| 538 | ␊ |
| 539 | ␊ |
| 540 | /*␊ |
| 541 | * The names of segments and sections in them are mostly meaningless to the␊ |
| 542 | * link-editor. But there are few things to support traditional UNIX␊ |
| 543 | * executables that require the link-editor and assembler to use some names␊ |
| 544 | * agreed upon by convention.␊ |
| 545 | *␊ |
| 546 | * The initial protection of the "__TEXT" segment has write protection turned␊ |
| 547 | * off (not writeable).␊ |
| 548 | *␊ |
| 549 | * The link-editor will allocate common symbols at the end of the "__common"␊ |
| 550 | * section in the "__DATA" segment. It will create the section and segment␊ |
| 551 | * if needed.␊ |
| 552 | */␊ |
| 553 | ␊ |
| 554 | /* The currently known segment names and the section names in those segments */␊ |
| 555 | ␊ |
| 556 | #define␉SEG_PAGEZERO␉"__PAGEZERO"␉/* the pagezero segment which has no */␊ |
| 557 | ␉␉␉␉␉/* protections and catches NULL */␊ |
| 558 | ␉␉␉␉␉/* references for MH_EXECUTE files */␊ |
| 559 | ␊ |
| 560 | ␊ |
| 561 | #define␉SEG_TEXT␉"__TEXT"␉/* the tradition UNIX text segment */␊ |
| 562 | #define␉SECT_TEXT␉"__text"␉/* the real text part of the text */␊ |
| 563 | ␉␉␉␉␉/* section no headers, and no padding */␊ |
| 564 | #define SECT_FVMLIB_INIT0 "__fvmlib_init0"␉/* the fvmlib initialization */␊ |
| 565 | ␉␉␉␉␉␉/* section */␊ |
| 566 | #define SECT_FVMLIB_INIT1 "__fvmlib_init1"␉/* the section following the */␊ |
| 567 | ␉␉␉␉␉ /* fvmlib initialization */␊ |
| 568 | ␉␉␉␉␉␉/* section */␊ |
| 569 | ␊ |
| 570 | #define␉SEG_DATA␉"__DATA"␉/* the tradition UNIX data segment */␊ |
| 571 | #define␉SECT_DATA␉"__data"␉/* the real initialized data section */␊ |
| 572 | ␉␉␉␉␉/* no padding, no bss overlap */␊ |
| 573 | #define␉SECT_BSS␉"__bss"␉␉/* the real uninitialized data section*/␊ |
| 574 | ␉␉␉␉␉/* no padding */␊ |
| 575 | #define SECT_COMMON␉"__common"␉/* the section common symbols are */␊ |
| 576 | ␉␉␉␉␉/* allocated in by the link editor */␊ |
| 577 | ␊ |
| 578 | #define␉SEG_OBJC␉"__OBJC"␉/* objective-C runtime segment */␊ |
| 579 | #define SECT_OBJC_SYMBOLS "__symbol_table"␉/* symbol table */␊ |
| 580 | #define SECT_OBJC_MODULES "__module_info"␉/* module information */␊ |
| 581 | #define SECT_OBJC_STRINGS "__selector_strs"␉/* string table */␊ |
| 582 | #define SECT_OBJC_REFS "__selector_refs"␉/* string table */␊ |
| 583 | ␊ |
| 584 | #define␉SEG_ICON␉ "__ICON"␉/* the icon segment */␊ |
| 585 | #define␉SECT_ICON_HEADER "__header"␉/* the icon headers */␊ |
| 586 | #define␉SECT_ICON_TIFF "__tiff"␉/* the icons in tiff format */␊ |
| 587 | ␊ |
| 588 | #define␉SEG_LINKEDIT␉"__LINKEDIT"␉/* the segment containing all structs */␊ |
| 589 | ␉␉␉␉␉/* created and maintained by the link */␊ |
| 590 | ␉␉␉␉␉/* editor. Created with -seglinkedit */␊ |
| 591 | ␉␉␉␉␉/* option to ld(1) for MH_EXECUTE and */␊ |
| 592 | ␉␉␉␉␉/* FVMLIB file types only */␊ |
| 593 | ␊ |
| 594 | #define SEG_UNIXSTACK␉"__UNIXSTACK"␉/* the unix stack segment */␊ |
| 595 | ␊ |
| 596 | #define SEG_IMPORT␉"__IMPORT"␉/* the segment for the self (dyld) */␊ |
| 597 | ␉␉␉␉␉/* modifing code stubs that has read, */␊ |
| 598 | ␉␉␉␉␉/* write and execute permissions */␊ |
| 599 | ␊ |
| 600 | /*␊ |
| 601 | * Fixed virtual memory shared libraries are identified by two things. The␊ |
| 602 | * target pathname (the name of the library as found for execution), and the␊ |
| 603 | * minor version number. The address of where the headers are loaded is in␊ |
| 604 | * header_addr. (THIS IS OBSOLETE and no longer supported).␊ |
| 605 | */␊ |
| 606 | struct fvmlib {␊ |
| 607 | ␉union lc_str␉name;␉␉/* library's target pathname */␊ |
| 608 | ␉uint32_t␉minor_version;␉/* library's minor version number */␊ |
| 609 | ␉uint32_t␉header_addr;␉/* library's header address */␊ |
| 610 | };␊ |
| 611 | ␊ |
| 612 | /*␊ |
| 613 | * A fixed virtual shared library (filetype == MH_FVMLIB in the mach header)␊ |
| 614 | * contains a fvmlib_command (cmd == LC_IDFVMLIB) to identify the library.␊ |
| 615 | * An object that uses a fixed virtual shared library also contains a␊ |
| 616 | * fvmlib_command (cmd == LC_LOADFVMLIB) for each library it uses.␊ |
| 617 | * (THIS IS OBSOLETE and no longer supported).␊ |
| 618 | */␊ |
| 619 | struct fvmlib_command {␊ |
| 620 | ␉uint32_t␉cmd;␉␉/* LC_IDFVMLIB or LC_LOADFVMLIB */␊ |
| 621 | ␉uint32_t␉cmdsize;␉/* includes pathname string */␊ |
| 622 | ␉struct fvmlib␉fvmlib;␉␉/* the library identification */␊ |
| 623 | };␊ |
| 624 | ␊ |
| 625 | /*␊ |
| 626 | * Dynamicly linked shared libraries are identified by two things. The␊ |
| 627 | * pathname (the name of the library as found for execution), and the␊ |
| 628 | * compatibility version number. The pathname must match and the compatibility␊ |
| 629 | * number in the user of the library must be greater than or equal to the␊ |
| 630 | * library being used. The time stamp is used to record the time a library was␊ |
| 631 | * built and copied into user so it can be use to determined if the library used␊ |
| 632 | * at runtime is exactly the same as used to built the program.␊ |
| 633 | */␊ |
| 634 | struct dylib {␊ |
| 635 | union lc_str name;␉␉␉/* library's path name */␊ |
| 636 | uint32_t timestamp;␉␉␉/* library's build time stamp */␊ |
| 637 | uint32_t current_version;␉␉/* library's current version number */␊ |
| 638 | uint32_t compatibility_version;␉/* library's compatibility vers number*/␊ |
| 639 | };␊ |
| 640 | ␊ |
| 641 | /*␊ |
| 642 | * A dynamically linked shared library (filetype == MH_DYLIB in the mach header)␊ |
| 643 | * contains a dylib_command (cmd == LC_ID_DYLIB) to identify the library.␊ |
| 644 | * An object that uses a dynamically linked shared library also contains a␊ |
| 645 | * dylib_command (cmd == LC_LOAD_DYLIB, LC_LOAD_WEAK_DYLIB, or␊ |
| 646 | * LC_REEXPORT_DYLIB) for each library it uses.␊ |
| 647 | */␊ |
| 648 | struct dylib_command {␊ |
| 649 | ␉uint32_t␉cmd;␉␉/* LC_ID_DYLIB, LC_LOAD_{,WEAK_}DYLIB,␊ |
| 650 | ␉␉␉␉␉ LC_REEXPORT_DYLIB */␊ |
| 651 | ␉uint32_t␉cmdsize;␉/* includes pathname string */␊ |
| 652 | ␉struct dylib␉dylib;␉␉/* the library identification */␊ |
| 653 | };␊ |
| 654 | ␊ |
| 655 | /*␊ |
| 656 | * A dynamically linked shared library may be a subframework of an umbrella␊ |
| 657 | * framework. If so it will be linked with "-umbrella umbrella_name" where␊ |
| 658 | * Where "umbrella_name" is the name of the umbrella framework. A subframework␊ |
| 659 | * can only be linked against by its umbrella framework or other subframeworks␊ |
| 660 | * that are part of the same umbrella framework. Otherwise the static link␊ |
| 661 | * editor produces an error and states to link against the umbrella framework.␊ |
| 662 | * The name of the umbrella framework for subframeworks is recorded in the␊ |
| 663 | * following structure.␊ |
| 664 | */␊ |
| 665 | struct sub_framework_command {␊ |
| 666 | ␉uint32_t␉cmd;␉␉/* LC_SUB_FRAMEWORK */␊ |
| 667 | ␉uint32_t␉cmdsize;␉/* includes umbrella string */␊ |
| 668 | ␉union lc_str ␉umbrella;␉/* the umbrella framework name */␊ |
| 669 | };␊ |
| 670 | ␊ |
| 671 | /*␊ |
| 672 | * For dynamically linked shared libraries that are subframework of an umbrella␊ |
| 673 | * framework they can allow clients other than the umbrella framework or other␊ |
| 674 | * subframeworks in the same umbrella framework. To do this the subframework␊ |
| 675 | * is built with "-allowable_client client_name" and an LC_SUB_CLIENT load␊ |
| 676 | * command is created for each -allowable_client flag. The client_name is␊ |
| 677 | * usually a framework name. It can also be a name used for bundles clients␊ |
| 678 | * where the bundle is built with "-client_name client_name".␊ |
| 679 | */␊ |
| 680 | struct sub_client_command {␊ |
| 681 | ␉uint32_t␉cmd;␉␉/* LC_SUB_CLIENT */␊ |
| 682 | ␉uint32_t␉cmdsize;␉/* includes client string */␊ |
| 683 | ␉union lc_str ␉client;␉␉/* the client name */␊ |
| 684 | };␊ |
| 685 | ␊ |
| 686 | /*␊ |
| 687 | * A dynamically linked shared library may be a sub_umbrella of an umbrella␊ |
| 688 | * framework. If so it will be linked with "-sub_umbrella umbrella_name" where␊ |
| 689 | * Where "umbrella_name" is the name of the sub_umbrella framework. When␊ |
| 690 | * staticly linking when -twolevel_namespace is in effect a twolevel namespace␊ |
| 691 | * umbrella framework will only cause its subframeworks and those frameworks␊ |
| 692 | * listed as sub_umbrella frameworks to be implicited linked in. Any other␊ |
| 693 | * dependent dynamic libraries will not be linked it when -twolevel_namespace␊ |
| 694 | * is in effect. The primary library recorded by the static linker when␊ |
| 695 | * resolving a symbol in these libraries will be the umbrella framework.␊ |
| 696 | * Zero or more sub_umbrella frameworks may be use by an umbrella framework.␊ |
| 697 | * The name of a sub_umbrella framework is recorded in the following structure.␊ |
| 698 | */␊ |
| 699 | struct sub_umbrella_command {␊ |
| 700 | ␉uint32_t␉cmd;␉␉/* LC_SUB_UMBRELLA */␊ |
| 701 | ␉uint32_t␉cmdsize;␉/* includes sub_umbrella string */␊ |
| 702 | ␉union lc_str ␉sub_umbrella;␉/* the sub_umbrella framework name */␊ |
| 703 | };␊ |
| 704 | ␊ |
| 705 | /*␊ |
| 706 | * A dynamically linked shared library may be a sub_library of another shared␊ |
| 707 | * library. If so it will be linked with "-sub_library library_name" where␊ |
| 708 | * Where "library_name" is the name of the sub_library shared library. When␊ |
| 709 | * staticly linking when -twolevel_namespace is in effect a twolevel namespace␊ |
| 710 | * shared library will only cause its subframeworks and those frameworks␊ |
| 711 | * listed as sub_umbrella frameworks and libraries listed as sub_libraries to␊ |
| 712 | * be implicited linked in. Any other dependent dynamic libraries will not be␊ |
| 713 | * linked it when -twolevel_namespace is in effect. The primary library␊ |
| 714 | * recorded by the static linker when resolving a symbol in these libraries␊ |
| 715 | * will be the umbrella framework (or dynamic library). Zero or more sub_library␊ |
| 716 | * shared libraries may be use by an umbrella framework or (or dynamic library).␊ |
| 717 | * The name of a sub_library framework is recorded in the following structure.␊ |
| 718 | * For example /usr/lib/libobjc_profile.A.dylib would be recorded as "libobjc".␊ |
| 719 | */␊ |
| 720 | struct sub_library_command {␊ |
| 721 | ␉uint32_t␉cmd;␉␉/* LC_SUB_LIBRARY */␊ |
| 722 | ␉uint32_t␉cmdsize;␉/* includes sub_library string */␊ |
| 723 | ␉union lc_str ␉sub_library;␉/* the sub_library name */␊ |
| 724 | };␊ |
| 725 | ␊ |
| 726 | /*␊ |
| 727 | * A program (filetype == MH_EXECUTE) that is␊ |
| 728 | * prebound to its dynamic libraries has one of these for each library that␊ |
| 729 | * the static linker used in prebinding. It contains a bit vector for the␊ |
| 730 | * modules in the library. The bits indicate which modules are bound (1) and␊ |
| 731 | * which are not (0) from the library. The bit for module 0 is the low bit␊ |
| 732 | * of the first byte. So the bit for the Nth module is:␊ |
| 733 | * (linked_modules[N/8] >> N%8) & 1␊ |
| 734 | */␊ |
| 735 | struct prebound_dylib_command {␊ |
| 736 | ␉uint32_t␉cmd;␉␉/* LC_PREBOUND_DYLIB */␊ |
| 737 | ␉uint32_t␉cmdsize;␉/* includes strings */␊ |
| 738 | ␉union lc_str␉name;␉␉/* library's path name */␊ |
| 739 | ␉uint32_t␉nmodules;␉/* number of modules in library */␊ |
| 740 | ␉union lc_str␉linked_modules;␉/* bit vector of linked modules */␊ |
| 741 | };␊ |
| 742 | ␊ |
| 743 | /*␊ |
| 744 | * A program that uses a dynamic linker contains a dylinker_command to identify␊ |
| 745 | * the name of the dynamic linker (LC_LOAD_DYLINKER). And a dynamic linker␊ |
| 746 | * contains a dylinker_command to identify the dynamic linker (LC_ID_DYLINKER).␊ |
| 747 | * A file can have at most one of these.␊ |
| 748 | * This struct is also used for the LC_DYLD_ENVIRONMENT load command and␊ |
| 749 | * contains string for dyld to treat like environment variable.␊ |
| 750 | */␊ |
| 751 | struct dylinker_command {␊ |
| 752 | ␉uint32_t␉cmd;␉␉/* LC_ID_DYLINKER, LC_LOAD_DYLINKER or␊ |
| 753 | ␉␉␉␉␉ LC_DYLD_ENVIRONMENT */␊ |
| 754 | ␉uint32_t␉cmdsize;␉/* includes pathname string */␊ |
| 755 | ␉union lc_str name;␉␉/* dynamic linker's path name */␊ |
| 756 | };␊ |
| 757 | ␊ |
| 758 | /*␊ |
| 759 | * Thread commands contain machine-specific data structures suitable for␊ |
| 760 | * use in the thread state primitives. The machine specific data structures␊ |
| 761 | * follow the struct thread_command as follows.␊ |
| 762 | * Each flavor of machine specific data structure is preceded by an unsigned␊ |
| 763 | * long constant for the flavor of that data structure, an uint32_t␊ |
| 764 | * that is the count of longs of the size of the state data structure and then␊ |
| 765 | * the state data structure follows. This triple may be repeated for many␊ |
| 766 | * flavors. The constants for the flavors, counts and state data structure␊ |
| 767 | * definitions are expected to be in the header file <machine/thread_status.h>.␊ |
| 768 | * These machine specific data structures sizes must be multiples of␊ |
| 769 | * 4 bytes The cmdsize reflects the total size of the thread_command␊ |
| 770 | * and all of the sizes of the constants for the flavors, counts and state␊ |
| 771 | * data structures.␊ |
| 772 | *␊ |
| 773 | * For executable objects that are unix processes there will be one␊ |
| 774 | * thread_command (cmd == LC_UNIXTHREAD) created for it by the link-editor.␊ |
| 775 | * This is the same as a LC_THREAD, except that a stack is automatically␊ |
| 776 | * created (based on the shell's limit for the stack size). Command arguments␊ |
| 777 | * and environment variables are copied onto that stack.␊ |
| 778 | */␊ |
| 779 | struct thread_command {␊ |
| 780 | ␉uint32_t␉cmd;␉␉/* LC_THREAD or LC_UNIXTHREAD */␊ |
| 781 | ␉uint32_t␉cmdsize;␉/* total size of this command */␊ |
| 782 | ␉/* uint32_t flavor␉␉ flavor of thread state */␊ |
| 783 | ␉/* uint32_t count␉␉ count of longs in thread state */␊ |
| 784 | ␉/* struct XXX_thread_state state thread state for this flavor */␊ |
| 785 | ␉/* ... */␊ |
| 786 | };␊ |
| 787 | ␊ |
| 788 | /*␊ |
| 789 | * The routines command contains the address of the dynamic shared library␊ |
| 790 | * initialization routine and an index into the module table for the module␊ |
| 791 | * that defines the routine. Before any modules are used from the library the␊ |
| 792 | * dynamic linker fully binds the module that defines the initialization routine␊ |
| 793 | * and then calls it. This gets called before any module initialization␊ |
| 794 | * routines (used for C++ static constructors) in the library.␊ |
| 795 | */␊ |
| 796 | struct routines_command { /* for 32-bit architectures */␊ |
| 797 | ␉uint32_t␉cmd;␉␉/* LC_ROUTINES */␊ |
| 798 | ␉uint32_t␉cmdsize;␉/* total size of this command */␊ |
| 799 | ␉uint32_t␉init_address;␉/* address of initialization routine */␊ |
| 800 | ␉uint32_t␉init_module;␉/* index into the module table that */␊ |
| 801 | ␉␉␉␉ /* the init routine is defined in */␊ |
| 802 | ␉uint32_t␉reserved1;␊ |
| 803 | ␉uint32_t␉reserved2;␊ |
| 804 | ␉uint32_t␉reserved3;␊ |
| 805 | ␉uint32_t␉reserved4;␊ |
| 806 | ␉uint32_t␉reserved5;␊ |
| 807 | ␉uint32_t␉reserved6;␊ |
| 808 | };␊ |
| 809 | ␊ |
| 810 | /*␊ |
| 811 | * The 64-bit routines command. Same use as above.␊ |
| 812 | */␊ |
| 813 | struct routines_command_64 { /* for 64-bit architectures */␊ |
| 814 | ␉uint32_t␉cmd;␉␉/* LC_ROUTINES_64 */␊ |
| 815 | ␉uint32_t␉cmdsize;␉/* total size of this command */␊ |
| 816 | ␉uint64_t␉init_address;␉/* address of initialization routine */␊ |
| 817 | ␉uint64_t␉init_module;␉/* index into the module table that */␊ |
| 818 | ␉␉␉␉␉/* the init routine is defined in */␊ |
| 819 | ␉uint64_t␉reserved1;␊ |
| 820 | ␉uint64_t␉reserved2;␊ |
| 821 | ␉uint64_t␉reserved3;␊ |
| 822 | ␉uint64_t␉reserved4;␊ |
| 823 | ␉uint64_t␉reserved5;␊ |
| 824 | ␉uint64_t␉reserved6;␊ |
| 825 | };␊ |
| 826 | ␊ |
| 827 | /*␊ |
| 828 | * The symtab_command contains the offsets and sizes of the link-edit 4.3BSD␊ |
| 829 | * "stab" style symbol table information as described in the header files␊ |
| 830 | * <nlist.h> and <stab.h>.␊ |
| 831 | */␊ |
| 832 | struct symtab_command {␊ |
| 833 | ␉uint32_t␉cmd;␉␉/* LC_SYMTAB */␊ |
| 834 | ␉uint32_t␉cmdsize;␉/* sizeof(struct symtab_command) */␊ |
| 835 | ␉uint32_t␉symoff;␉␉/* symbol table offset */␊ |
| 836 | ␉uint32_t␉nsyms;␉␉/* number of symbol table entries */␊ |
| 837 | ␉uint32_t␉stroff;␉␉/* string table offset */␊ |
| 838 | ␉uint32_t␉strsize;␉/* string table size in bytes */␊ |
| 839 | };␊ |
| 840 | ␊ |
| 841 | /*␊ |
| 842 | * This is the second set of the symbolic information which is used to support␊ |
| 843 | * the data structures for the dynamically link editor.␊ |
| 844 | *␊ |
| 845 | * The original set of symbolic information in the symtab_command which contains␊ |
| 846 | * the symbol and string tables must also be present when this load command is␊ |
| 847 | * present. When this load command is present the symbol table is organized␊ |
| 848 | * into three groups of symbols:␊ |
| 849 | *␉local symbols (static and debugging symbols) - grouped by module␊ |
| 850 | *␉defined external symbols - grouped by module (sorted by name if not lib)␊ |
| 851 | *␉undefined external symbols (sorted by name if MH_BINDATLOAD is not set,␊ |
| 852 | *␉ ␉␉␉ and in order the were seen by the static␊ |
| 853 | *␉␉␉␉ linker if MH_BINDATLOAD is set)␊ |
| 854 | * In this load command there are offsets and counts to each of the three groups␊ |
| 855 | * of symbols.␊ |
| 856 | *␊ |
| 857 | * This load command contains a the offsets and sizes of the following new␊ |
| 858 | * symbolic information tables:␊ |
| 859 | *␉table of contents␊ |
| 860 | *␉module table␊ |
| 861 | *␉reference symbol table␊ |
| 862 | *␉indirect symbol table␊ |
| 863 | * The first three tables above (the table of contents, module table and␊ |
| 864 | * reference symbol table) are only present if the file is a dynamically linked␊ |
| 865 | * shared library. For executable and object modules, which are files␊ |
| 866 | * containing only one module, the information that would be in these three␊ |
| 867 | * tables is determined as follows:␊ |
| 868 | * ␉table of contents - the defined external symbols are sorted by name␊ |
| 869 | *␉module table - the file contains only one module so everything in the␊ |
| 870 | *␉␉ file is part of the module.␊ |
| 871 | *␉reference symbol table - is the defined and undefined external symbols␊ |
| 872 | *␊ |
| 873 | * For dynamically linked shared library files this load command also contains␊ |
| 874 | * offsets and sizes to the pool of relocation entries for all sections␊ |
| 875 | * separated into two groups:␊ |
| 876 | *␉external relocation entries␊ |
| 877 | *␉local relocation entries␊ |
| 878 | * For executable and object modules the relocation entries continue to hang␊ |
| 879 | * off the section structures.␊ |
| 880 | */␊ |
| 881 | struct dysymtab_command {␊ |
| 882 | uint32_t cmd;␉/* LC_DYSYMTAB */␊ |
| 883 | uint32_t cmdsize;␉/* sizeof(struct dysymtab_command) */␊ |
| 884 | ␊ |
| 885 | /*␊ |
| 886 | * The symbols indicated by symoff and nsyms of the LC_SYMTAB load command␊ |
| 887 | * are grouped into the following three groups:␊ |
| 888 | * local symbols (further grouped by the module they are from)␊ |
| 889 | * defined external symbols (further grouped by the module they are from)␊ |
| 890 | * undefined symbols␊ |
| 891 | *␊ |
| 892 | * The local symbols are used only for debugging. The dynamic binding␊ |
| 893 | * process may have to use them to indicate to the debugger the local␊ |
| 894 | * symbols for a module that is being bound.␊ |
| 895 | *␊ |
| 896 | * The last two groups are used by the dynamic binding process to do the␊ |
| 897 | * binding (indirectly through the module table and the reference symbol␊ |
| 898 | * table when this is a dynamically linked shared library file).␊ |
| 899 | */␊ |
| 900 | uint32_t ilocalsym;␉/* index to local symbols */␊ |
| 901 | uint32_t nlocalsym;␉/* number of local symbols */␊ |
| 902 | ␊ |
| 903 | uint32_t iextdefsym;/* index to externally defined symbols */␊ |
| 904 | uint32_t nextdefsym;/* number of externally defined symbols */␊ |
| 905 | ␊ |
| 906 | uint32_t iundefsym;␉/* index to undefined symbols */␊ |
| 907 | uint32_t nundefsym;␉/* number of undefined symbols */␊ |
| 908 | ␊ |
| 909 | /*␊ |
| 910 | * For the for the dynamic binding process to find which module a symbol␊ |
| 911 | * is defined in the table of contents is used (analogous to the ranlib␊ |
| 912 | * structure in an archive) which maps defined external symbols to modules␊ |
| 913 | * they are defined in. This exists only in a dynamically linked shared␊ |
| 914 | * library file. For executable and object modules the defined external␊ |
| 915 | * symbols are sorted by name and is use as the table of contents.␊ |
| 916 | */␊ |
| 917 | uint32_t tocoff;␉/* file offset to table of contents */␊ |
| 918 | uint32_t ntoc;␉/* number of entries in table of contents */␊ |
| 919 | ␊ |
| 920 | /*␊ |
| 921 | * To support dynamic binding of "modules" (whole object files) the symbol␊ |
| 922 | * table must reflect the modules that the file was created from. This is␊ |
| 923 | * done by having a module table that has indexes and counts into the merged␊ |
| 924 | * tables for each module. The module structure that these two entries␊ |
| 925 | * refer to is described below. This exists only in a dynamically linked␊ |
| 926 | * shared library file. For executable and object modules the file only␊ |
| 927 | * contains one module so everything in the file belongs to the module.␊ |
| 928 | */␊ |
| 929 | uint32_t modtaboff;␉/* file offset to module table */␊ |
| 930 | uint32_t nmodtab;␉/* number of module table entries */␊ |
| 931 | ␊ |
| 932 | /*␊ |
| 933 | * To support dynamic module binding the module structure for each module␊ |
| 934 | * indicates the external references (defined and undefined) each module␊ |
| 935 | * makes. For each module there is an offset and a count into the␊ |
| 936 | * reference symbol table for the symbols that the module references.␊ |
| 937 | * This exists only in a dynamically linked shared library file. For␊ |
| 938 | * executable and object modules the defined external symbols and the␊ |
| 939 | * undefined external symbols indicates the external references.␊ |
| 940 | */␊ |
| 941 | uint32_t extrefsymoff;␉/* offset to referenced symbol table */␊ |
| 942 | uint32_t nextrefsyms;␉/* number of referenced symbol table entries */␊ |
| 943 | ␊ |
| 944 | /*␊ |
| 945 | * The sections that contain "symbol pointers" and "routine stubs" have␊ |
| 946 | * indexes and (implied counts based on the size of the section and fixed␊ |
| 947 | * size of the entry) into the "indirect symbol" table for each pointer␊ |
| 948 | * and stub. For every section of these two types the index into the␊ |
| 949 | * indirect symbol table is stored in the section header in the field␊ |
| 950 | * reserved1. An indirect symbol table entry is simply a 32bit index into␊ |
| 951 | * the symbol table to the symbol that the pointer or stub is referring to.␊ |
| 952 | * The indirect symbol table is ordered to match the entries in the section.␊ |
| 953 | */␊ |
| 954 | uint32_t indirectsymoff; /* file offset to the indirect symbol table */␊ |
| 955 | uint32_t nindirectsyms; /* number of indirect symbol table entries */␊ |
| 956 | ␊ |
| 957 | /*␊ |
| 958 | * To support relocating an individual module in a library file quickly the␊ |
| 959 | * external relocation entries for each module in the library need to be␊ |
| 960 | * accessed efficiently. Since the relocation entries can't be accessed␊ |
| 961 | * through the section headers for a library file they are separated into␊ |
| 962 | * groups of local and external entries further grouped by module. In this␊ |
| 963 | * case the presents of this load command who's extreloff, nextrel,␊ |
| 964 | * locreloff and nlocrel fields are non-zero indicates that the relocation␊ |
| 965 | * entries of non-merged sections are not referenced through the section␊ |
| 966 | * structures (and the reloff and nreloc fields in the section headers are␊ |
| 967 | * set to zero).␊ |
| 968 | *␊ |
| 969 | * Since the relocation entries are not accessed through the section headers␊ |
| 970 | * this requires the r_address field to be something other than a section␊ |
| 971 | * offset to identify the item to be relocated. In this case r_address is␊ |
| 972 | * set to the offset from the vmaddr of the first LC_SEGMENT command.␊ |
| 973 | * For MH_SPLIT_SEGS images r_address is set to the the offset from the␊ |
| 974 | * vmaddr of the first read-write LC_SEGMENT command.␊ |
| 975 | *␊ |
| 976 | * The relocation entries are grouped by module and the module table␊ |
| 977 | * entries have indexes and counts into them for the group of external␊ |
| 978 | * relocation entries for that the module.␊ |
| 979 | *␊ |
| 980 | * For sections that are merged across modules there must not be any␊ |
| 981 | * remaining external relocation entries for them (for merged sections␊ |
| 982 | * remaining relocation entries must be local).␊ |
| 983 | */␊ |
| 984 | uint32_t extreloff;␉/* offset to external relocation entries */␊ |
| 985 | uint32_t nextrel;␉/* number of external relocation entries */␊ |
| 986 | ␊ |
| 987 | /*␊ |
| 988 | * All the local relocation entries are grouped together (they are not␊ |
| 989 | * grouped by their module since they are only used if the object is moved␊ |
| 990 | * from it staticly link edited address).␊ |
| 991 | */␊ |
| 992 | uint32_t locreloff;␉/* offset to local relocation entries */␊ |
| 993 | uint32_t nlocrel;␉/* number of local relocation entries */␊ |
| 994 | ␊ |
| 995 | };␊ |
| 996 | ␊ |
| 997 | /*␊ |
| 998 | * An indirect symbol table entry is simply a 32bit index into the symbol table␊ |
| 999 | * to the symbol that the pointer or stub is refering to. Unless it is for a␊ |
| 1000 | * non-lazy symbol pointer section for a defined symbol which strip(1) as␊ |
| 1001 | * removed. In which case it has the value INDIRECT_SYMBOL_LOCAL. If the␊ |
| 1002 | * symbol was also absolute INDIRECT_SYMBOL_ABS is or'ed with that.␊ |
| 1003 | */␊ |
| 1004 | #define INDIRECT_SYMBOL_LOCAL␉0x80000000␊ |
| 1005 | #define INDIRECT_SYMBOL_ABS␉0x40000000␊ |
| 1006 | ␊ |
| 1007 | ␊ |
| 1008 | /* a table of contents entry */␊ |
| 1009 | struct dylib_table_of_contents {␊ |
| 1010 | uint32_t symbol_index;␉/* the defined external symbol␊ |
| 1011 | ␉␉␉␉ (index into the symbol table) */␊ |
| 1012 | uint32_t module_index;␉/* index into the module table this symbol␊ |
| 1013 | ␉␉␉␉ is defined in */␊ |
| 1014 | };␊ |
| 1015 | ␊ |
| 1016 | /* a module table entry */␊ |
| 1017 | struct dylib_module {␊ |
| 1018 | uint32_t module_name;␉/* the module name (index into string table) */␊ |
| 1019 | ␊ |
| 1020 | uint32_t iextdefsym;␉/* index into externally defined symbols */␊ |
| 1021 | uint32_t nextdefsym;␉/* number of externally defined symbols */␊ |
| 1022 | uint32_t irefsym;␉␉/* index into reference symbol table */␊ |
| 1023 | uint32_t nrefsym;␉␉/* number of reference symbol table entries */␊ |
| 1024 | uint32_t ilocalsym;␉␉/* index into symbols for local symbols */␊ |
| 1025 | uint32_t nlocalsym;␉␉/* number of local symbols */␊ |
| 1026 | ␊ |
| 1027 | uint32_t iextrel;␉␉/* index into external relocation entries */␊ |
| 1028 | uint32_t nextrel;␉␉/* number of external relocation entries */␊ |
| 1029 | ␊ |
| 1030 | uint32_t iinit_iterm;␉/* low 16 bits are the index into the init␊ |
| 1031 | ␉␉␉␉ section, high 16 bits are the index into␊ |
| 1032 | ␉␉␉ the term section */␊ |
| 1033 | uint32_t ninit_nterm;␉/* low 16 bits are the number of init section␊ |
| 1034 | ␉␉␉␉ entries, high 16 bits are the number of␊ |
| 1035 | ␉␉␉␉ term section entries */␊ |
| 1036 | ␊ |
| 1037 | uint32_t␉␉␉/* for this module address of the start of */␊ |
| 1038 | ␉objc_module_info_addr; /* the (__OBJC,__module_info) section */␊ |
| 1039 | uint32_t␉␉␉/* for this module size of */␊ |
| 1040 | ␉objc_module_info_size;␉/* the (__OBJC,__module_info) section */␊ |
| 1041 | };␊ |
| 1042 | ␊ |
| 1043 | /* a 64-bit module table entry */␊ |
| 1044 | struct dylib_module_64 {␊ |
| 1045 | uint32_t module_name;␉/* the module name (index into string table) */␊ |
| 1046 | ␊ |
| 1047 | uint32_t iextdefsym;␉/* index into externally defined symbols */␊ |
| 1048 | uint32_t nextdefsym;␉/* number of externally defined symbols */␊ |
| 1049 | uint32_t irefsym;␉␉/* index into reference symbol table */␊ |
| 1050 | uint32_t nrefsym;␉␉/* number of reference symbol table entries */␊ |
| 1051 | uint32_t ilocalsym;␉␉/* index into symbols for local symbols */␊ |
| 1052 | uint32_t nlocalsym;␉␉/* number of local symbols */␊ |
| 1053 | ␊ |
| 1054 | uint32_t iextrel;␉␉/* index into external relocation entries */␊ |
| 1055 | uint32_t nextrel;␉␉/* number of external relocation entries */␊ |
| 1056 | ␊ |
| 1057 | uint32_t iinit_iterm;␉/* low 16 bits are the index into the init␊ |
| 1058 | ␉␉␉␉ section, high 16 bits are the index into␊ |
| 1059 | ␉␉␉␉ the term section */␊ |
| 1060 | uint32_t ninit_nterm; /* low 16 bits are the number of init section␊ |
| 1061 | ␉␉␉␉ entries, high 16 bits are the number of␊ |
| 1062 | ␉␉␉␉ term section entries */␊ |
| 1063 | ␊ |
| 1064 | uint32_t␉␉␉/* for this module size of */␊ |
| 1065 | objc_module_info_size;␉/* the (__OBJC,__module_info) section */␊ |
| 1066 | uint64_t␉␉␉/* for this module address of the start of */␊ |
| 1067 | objc_module_info_addr;␉/* the (__OBJC,__module_info) section */␊ |
| 1068 | };␊ |
| 1069 | ␊ |
| 1070 | /*␊ |
| 1071 | * The entries in the reference symbol table are used when loading the module␊ |
| 1072 | * (both by the static and dynamic link editors) and if the module is unloaded␊ |
| 1073 | * or replaced. Therefore all external symbols (defined and undefined) are␊ |
| 1074 | * listed in the module's reference table. The flags describe the type of␊ |
| 1075 | * reference that is being made. The constants for the flags are defined in␊ |
| 1076 | * <mach-o/nlist.h> as they are also used for symbol table entries.␊ |
| 1077 | */␊ |
| 1078 | struct dylib_reference {␊ |
| 1079 | uint32_t isym:24,␉␉/* index into the symbol table */␊ |
| 1080 | ␉␉ flags:8;␉/* flags to indicate the type of reference */␊ |
| 1081 | };␊ |
| 1082 | ␊ |
| 1083 | /*␊ |
| 1084 | * The twolevel_hints_command contains the offset and number of hints in the␊ |
| 1085 | * two-level namespace lookup hints table.␊ |
| 1086 | */␊ |
| 1087 | struct twolevel_hints_command {␊ |
| 1088 | uint32_t cmd;␉/* LC_TWOLEVEL_HINTS */␊ |
| 1089 | uint32_t cmdsize;␉/* sizeof(struct twolevel_hints_command) */␊ |
| 1090 | uint32_t offset;␉/* offset to the hint table */␊ |
| 1091 | uint32_t nhints;␉/* number of hints in the hint table */␊ |
| 1092 | };␊ |
| 1093 | ␊ |
| 1094 | /*␊ |
| 1095 | * The entries in the two-level namespace lookup hints table are twolevel_hint␊ |
| 1096 | * structs. These provide hints to the dynamic link editor where to start␊ |
| 1097 | * looking for an undefined symbol in a two-level namespace image. The␊ |
| 1098 | * isub_image field is an index into the sub-images (sub-frameworks and␊ |
| 1099 | * sub-umbrellas list) that made up the two-level image that the undefined␊ |
| 1100 | * symbol was found in when it was built by the static link editor. If␊ |
| 1101 | * isub-image is 0 the the symbol is expected to be defined in library and not␊ |
| 1102 | * in the sub-images. If isub-image is non-zero it is an index into the array␊ |
| 1103 | * of sub-images for the umbrella with the first index in the sub-images being␊ |
| 1104 | * 1. The array of sub-images is the ordered list of sub-images of the umbrella␊ |
| 1105 | * that would be searched for a symbol that has the umbrella recorded as its␊ |
| 1106 | * primary library. The table of contents index is an index into the␊ |
| 1107 | * library's table of contents. This is used as the starting point of the␊ |
| 1108 | * binary search or a directed linear search.␊ |
| 1109 | */␊ |
| 1110 | struct twolevel_hint {␊ |
| 1111 | uint32_t␊ |
| 1112 | ␉isub_image:8,␉/* index into the sub images */␊ |
| 1113 | ␉itoc:24;␉/* index into the table of contents */␊ |
| 1114 | };␊ |
| 1115 | ␊ |
| 1116 | /*␊ |
| 1117 | * The prebind_cksum_command contains the value of the original check sum for␊ |
| 1118 | * prebound files or zero. When a prebound file is first created or modified␊ |
| 1119 | * for other than updating its prebinding information the value of the check sum␊ |
| 1120 | * is set to zero. When the file has it prebinding re-done and if the value of␊ |
| 1121 | * the check sum is zero the original check sum is calculated and stored in␊ |
| 1122 | * cksum field of this load command in the output file. If when the prebinding␊ |
| 1123 | * is re-done and the cksum field is non-zero it is left unchanged from the␊ |
| 1124 | * input file.␊ |
| 1125 | */␊ |
| 1126 | struct prebind_cksum_command {␊ |
| 1127 | uint32_t cmd;␉/* LC_PREBIND_CKSUM */␊ |
| 1128 | uint32_t cmdsize;␉/* sizeof(struct prebind_cksum_command) */␊ |
| 1129 | uint32_t cksum;␉/* the check sum or zero */␊ |
| 1130 | };␊ |
| 1131 | ␊ |
| 1132 | /*␊ |
| 1133 | * The uuid load command contains a single 128-bit unique random number that␊ |
| 1134 | * identifies an object produced by the static link editor.␊ |
| 1135 | */␊ |
| 1136 | struct uuid_command {␊ |
| 1137 | uint32_t␉cmd;␉␉/* LC_UUID */␊ |
| 1138 | uint32_t␉cmdsize;␉/* sizeof(struct uuid_command) */␊ |
| 1139 | uint8_t␉uuid[16];␉/* the 128-bit uuid */␊ |
| 1140 | };␊ |
| 1141 | ␊ |
| 1142 | /*␊ |
| 1143 | * The rpath_command contains a path which at runtime should be added to␊ |
| 1144 | * the current run path used to find @rpath prefixed dylibs.␊ |
| 1145 | */␊ |
| 1146 | struct rpath_command {␊ |
| 1147 | uint32_t␉ cmd;␉␉/* LC_RPATH */␊ |
| 1148 | uint32_t␉ cmdsize;␉/* includes string */␊ |
| 1149 | union lc_str path;␉␉/* path to add to run path */␊ |
| 1150 | };␊ |
| 1151 | ␊ |
| 1152 | /*␊ |
| 1153 | * The linkedit_data_command contains the offsets and sizes of a blob␊ |
| 1154 | * of data in the __LINKEDIT segment.␊ |
| 1155 | */␊ |
| 1156 | struct linkedit_data_command {␊ |
| 1157 | uint32_t␉cmd;␉␉/* LC_CODE_SIGNATURE, LC_SEGMENT_SPLIT_INFO,␊ |
| 1158 | LC_FUNCTION_STARTS, LC_DATA_IN_CODE,␊ |
| 1159 | ␉␉␉␉ or LC_DYLIB_CODE_SIGN_DRS */␊ |
| 1160 | uint32_t␉cmdsize;␉/* sizeof(struct linkedit_data_command) */␊ |
| 1161 | uint32_t␉dataoff;␉/* file offset of data in __LINKEDIT segment */␊ |
| 1162 | uint32_t␉datasize;␉/* file size of data in __LINKEDIT segment */␊ |
| 1163 | };␊ |
| 1164 | ␊ |
| 1165 | /*␊ |
| 1166 | * The encryption_info_command contains the file offset and size of an␊ |
| 1167 | * of an encrypted segment.␊ |
| 1168 | */␊ |
| 1169 | struct encryption_info_command {␊ |
| 1170 | uint32_t␉cmd;␉␉/* LC_ENCRYPTION_INFO */␊ |
| 1171 | uint32_t␉cmdsize;␉/* sizeof(struct encryption_info_command) */␊ |
| 1172 | uint32_t␉cryptoff;␉/* file offset of encrypted range */␊ |
| 1173 | uint32_t␉cryptsize;␉/* file size of encrypted range */␊ |
| 1174 | uint32_t␉cryptid;␉/* which enryption system,␊ |
| 1175 | ␉␉␉␉ 0 means not-encrypted yet */␊ |
| 1176 | };␊ |
| 1177 | ␊ |
| 1178 | /*␊ |
| 1179 | * The encryption_info_command_64 contains the file offset and size of an␊ |
| 1180 | * of an encrypted segment (for use in 64-bit targets).␊ |
| 1181 | */␊ |
| 1182 | struct encryption_info_command_64 {␊ |
| 1183 | uint32_t␉cmd;␉␉/* LC_ENCRYPTION_INFO_64 */␊ |
| 1184 | uint32_t␉cmdsize;␉/* sizeof(struct encryption_info_command_64) */␊ |
| 1185 | uint32_t␉cryptoff;␉/* file offset of encrypted range */␊ |
| 1186 | uint32_t␉cryptsize;␉/* file size of encrypted range */␊ |
| 1187 | uint32_t␉cryptid;␉/* which enryption system,␊ |
| 1188 | ␉␉␉␉ 0 means not-encrypted yet */␊ |
| 1189 | uint32_t␉pad;␉␉/* padding to make this struct's size a multiple␊ |
| 1190 | ␉␉␉␉ of 8 bytes */␊ |
| 1191 | };␊ |
| 1192 | ␊ |
| 1193 | /*␊ |
| 1194 | * The version_min_command contains the min OS version on which this␊ |
| 1195 | * binary was built to run.␊ |
| 1196 | */␊ |
| 1197 | struct version_min_command {␊ |
| 1198 | uint32_t␉cmd;␉␉/* LC_VERSION_MIN_MACOSX or␊ |
| 1199 | ␉␉␉␉ LC_VERSION_MIN_IPHONEOS */␊ |
| 1200 | uint32_t␉cmdsize;␉/* sizeof(struct min_version_command) */␊ |
| 1201 | uint32_t␉version;␉/* X.Y.Z is encoded in nibbles xxxx.yy.zz */␊ |
| 1202 | uint32_t␉sdk;␉␉/* X.Y.Z is encoded in nibbles xxxx.yy.zz */␊ |
| 1203 | };␊ |
| 1204 | ␊ |
| 1205 | /*␊ |
| 1206 | * The dyld_info_command contains the file offsets and sizes of␊ |
| 1207 | * the new compressed form of the information dyld needs to␊ |
| 1208 | * load the image. This information is used by dyld on Mac OS X␊ |
| 1209 | * 10.6 and later. All information pointed to by this command␊ |
| 1210 | * is encoded using byte streams, so no endian swapping is needed␊ |
| 1211 | * to interpret it.␊ |
| 1212 | */␊ |
| 1213 | struct dyld_info_command {␊ |
| 1214 | uint32_t cmd;␉␉/* LC_DYLD_INFO or LC_DYLD_INFO_ONLY */␊ |
| 1215 | uint32_t cmdsize;␉␉/* sizeof(struct dyld_info_command) */␊ |
| 1216 | ␊ |
| 1217 | /*␊ |
| 1218 | * Dyld rebases an image whenever dyld loads it at an address different␊ |
| 1219 | * from its preferred address. The rebase information is a stream␊ |
| 1220 | * of byte sized opcodes whose symbolic names start with REBASE_OPCODE_.␊ |
| 1221 | * Conceptually the rebase information is a table of tuples:␊ |
| 1222 | * <seg-index, seg-offset, type>␊ |
| 1223 | * The opcodes are a compressed way to encode the table by only␊ |
| 1224 | * encoding when a column changes. In addition simple patterns␊ |
| 1225 | * like "every n'th offset for m times" can be encoded in a few␊ |
| 1226 | * bytes.␊ |
| 1227 | */␊ |
| 1228 | uint32_t rebase_off;␉/* file offset to rebase info */␊ |
| 1229 | uint32_t rebase_size;␉/* size of rebase info */␊ |
| 1230 | ␊ |
| 1231 | /*␊ |
| 1232 | * Dyld binds an image during the loading process, if the image␊ |
| 1233 | * requires any pointers to be initialized to symbols in other images.␊ |
| 1234 | * The bind information is a stream of byte sized␊ |
| 1235 | * opcodes whose symbolic names start with BIND_OPCODE_.␊ |
| 1236 | * Conceptually the bind information is a table of tuples:␊ |
| 1237 | * <seg-index, seg-offset, type, symbol-library-ordinal, symbol-name, addend>␊ |
| 1238 | * The opcodes are a compressed way to encode the table by only␊ |
| 1239 | * encoding when a column changes. In addition simple patterns␊ |
| 1240 | * like for runs of pointers initialzed to the same value can be␊ |
| 1241 | * encoded in a few bytes.␊ |
| 1242 | */␊ |
| 1243 | uint32_t bind_off;␉/* file offset to binding info */␊ |
| 1244 | uint32_t bind_size;␉/* size of binding info */␊ |
| 1245 | ␊ |
| 1246 | /*␊ |
| 1247 | * Some C++ programs require dyld to unique symbols so that all␊ |
| 1248 | * images in the process use the same copy of some code/data.␊ |
| 1249 | * This step is done after binding. The content of the weak_bind␊ |
| 1250 | * info is an opcode stream like the bind_info. But it is sorted␊ |
| 1251 | * alphabetically by symbol name. This enable dyld to walk␊ |
| 1252 | * all images with weak binding information in order and look␊ |
| 1253 | * for collisions. If there are no collisions, dyld does␊ |
| 1254 | * no updating. That means that some fixups are also encoded␊ |
| 1255 | * in the bind_info. For instance, all calls to "operator new"␊ |
| 1256 | * are first bound to libstdc++.dylib using the information␊ |
| 1257 | * in bind_info. Then if some image overrides operator new␊ |
| 1258 | * that is detected when the weak_bind information is processed␊ |
| 1259 | * and the call to operator new is then rebound.␊ |
| 1260 | */␊ |
| 1261 | uint32_t weak_bind_off;␉/* file offset to weak binding info */␊ |
| 1262 | uint32_t weak_bind_size; /* size of weak binding info */␊ |
| 1263 | ␊ |
| 1264 | /*␊ |
| 1265 | * Some uses of external symbols do not need to be bound immediately.␊ |
| 1266 | * Instead they can be lazily bound on first use. The lazy_bind␊ |
| 1267 | * are contains a stream of BIND opcodes to bind all lazy symbols.␊ |
| 1268 | * Normal use is that dyld ignores the lazy_bind section when␊ |
| 1269 | * loading an image. Instead the static linker arranged for the␊ |
| 1270 | * lazy pointer to initially point to a helper function which␊ |
| 1271 | * pushes the offset into the lazy_bind area for the symbol␊ |
| 1272 | * needing to be bound, then jumps to dyld which simply adds␊ |
| 1273 | * the offset to lazy_bind_off to get the information on what␊ |
| 1274 | * to bind.␊ |
| 1275 | */␊ |
| 1276 | uint32_t lazy_bind_off;␉/* file offset to lazy binding info */␊ |
| 1277 | uint32_t lazy_bind_size; /* size of lazy binding infs */␊ |
| 1278 | ␊ |
| 1279 | /*␊ |
| 1280 | * The symbols exported by a dylib are encoded in a trie. This␊ |
| 1281 | * is a compact representation that factors out common prefixes.␊ |
| 1282 | * It also reduces LINKEDIT pages in RAM because it encodes all␊ |
| 1283 | * information (name, address, flags) in one small, contiguous range.␊ |
| 1284 | * The export area is a stream of nodes. The first node sequentially␊ |
| 1285 | * is the start node for the trie.␊ |
| 1286 | *␊ |
| 1287 | * Nodes for a symbol start with a uleb128 that is the length of␊ |
| 1288 | * the exported symbol information for the string so far.␊ |
| 1289 | * If there is no exported symbol, the node starts with a zero byte.␊ |
| 1290 | * If there is exported info, it follows the length.␊ |
| 1291 | ␉ *␊ |
| 1292 | ␉ * First is a uleb128 containing flags. Normally, it is followed by␊ |
| 1293 | * a uleb128 encoded offset which is location of the content named␊ |
| 1294 | * by the symbol from the mach_header for the image. If the flags␊ |
| 1295 | * is EXPORT_SYMBOL_FLAGS_REEXPORT, then following the flags is␊ |
| 1296 | * a uleb128 encoded library ordinal, then a zero terminated␊ |
| 1297 | * UTF8 string. If the string is zero length, then the symbol␊ |
| 1298 | * is re-export from the specified dylib with the same name.␊ |
| 1299 | ␉ * If the flags is EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER, then following␊ |
| 1300 | ␉ * the flags is two uleb128s: the stub offset and the resolver offset.␊ |
| 1301 | ␉ * The stub is used by non-lazy pointers. The resolver is used␊ |
| 1302 | ␉ * by lazy pointers and must be called to get the actual address to use.␊ |
| 1303 | *␊ |
| 1304 | * After the optional exported symbol information is a byte of␊ |
| 1305 | * how many edges (0-255) that this node has leaving it,␊ |
| 1306 | * followed by each edge.␊ |
| 1307 | * Each edge is a zero terminated UTF8 of the addition chars␊ |
| 1308 | * in the symbol, followed by a uleb128 offset for the node that␊ |
| 1309 | * edge points to.␊ |
| 1310 | *␊ |
| 1311 | */␊ |
| 1312 | uint32_t export_off;␉/* file offset to lazy binding info */␊ |
| 1313 | uint32_t export_size;␉/* size of lazy binding infs */␊ |
| 1314 | };␊ |
| 1315 | ␊ |
| 1316 | /*␊ |
| 1317 | * The following are used to encode rebasing information␊ |
| 1318 | */␊ |
| 1319 | #define REBASE_TYPE_POINTER␉␉␉␉␉1␊ |
| 1320 | #define REBASE_TYPE_TEXT_ABSOLUTE32␉␉␉␉2␊ |
| 1321 | #define REBASE_TYPE_TEXT_PCREL32␉␉␉␉3␊ |
| 1322 | ␊ |
| 1323 | #define REBASE_OPCODE_MASK␉␉␉␉␉0xF0␊ |
| 1324 | #define REBASE_IMMEDIATE_MASK␉␉␉␉␉0x0F␊ |
| 1325 | #define REBASE_OPCODE_DONE␉␉␉␉␉0x00␊ |
| 1326 | #define REBASE_OPCODE_SET_TYPE_IMM␉␉␉␉0x10␊ |
| 1327 | #define REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB␉␉0x20␊ |
| 1328 | #define REBASE_OPCODE_ADD_ADDR_ULEB␉␉␉␉0x30␊ |
| 1329 | #define REBASE_OPCODE_ADD_ADDR_IMM_SCALED␉␉␉0x40␊ |
| 1330 | #define REBASE_OPCODE_DO_REBASE_IMM_TIMES␉␉␉0x50␊ |
| 1331 | #define REBASE_OPCODE_DO_REBASE_ULEB_TIMES␉␉␉0x60␊ |
| 1332 | #define REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB␉␉␉0x70␊ |
| 1333 | #define REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB␉0x80␊ |
| 1334 | ␊ |
| 1335 | ␊ |
| 1336 | /*␊ |
| 1337 | * The following are used to encode binding information␊ |
| 1338 | */␊ |
| 1339 | #define BIND_TYPE_POINTER␉␉␉␉␉1␊ |
| 1340 | #define BIND_TYPE_TEXT_ABSOLUTE32␉␉␉␉2␊ |
| 1341 | #define BIND_TYPE_TEXT_PCREL32␉␉␉␉␉3␊ |
| 1342 | ␊ |
| 1343 | #define BIND_SPECIAL_DYLIB_SELF␉␉␉␉␉ 0␊ |
| 1344 | #define BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE␉␉␉-1␊ |
| 1345 | #define BIND_SPECIAL_DYLIB_FLAT_LOOKUP␉␉␉␉-2␊ |
| 1346 | ␊ |
| 1347 | #define BIND_SYMBOL_FLAGS_WEAK_IMPORT␉␉␉␉0x1␊ |
| 1348 | #define BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION␉␉␉0x8␊ |
| 1349 | ␊ |
| 1350 | #define BIND_OPCODE_MASK␉␉␉␉␉0xF0␊ |
| 1351 | #define BIND_IMMEDIATE_MASK␉␉␉␉␉0x0F␊ |
| 1352 | #define BIND_OPCODE_DONE␉␉␉␉␉0x00␊ |
| 1353 | #define BIND_OPCODE_SET_DYLIB_ORDINAL_IMM␉␉␉0x10␊ |
| 1354 | #define BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB␉␉␉0x20␊ |
| 1355 | #define BIND_OPCODE_SET_DYLIB_SPECIAL_IMM␉␉␉0x30␊ |
| 1356 | #define BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM␉␉0x40␊ |
| 1357 | #define BIND_OPCODE_SET_TYPE_IMM␉␉␉␉0x50␊ |
| 1358 | #define BIND_OPCODE_SET_ADDEND_SLEB␉␉␉␉0x60␊ |
| 1359 | #define BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB␉␉␉0x70␊ |
| 1360 | #define BIND_OPCODE_ADD_ADDR_ULEB␉␉␉␉0x80␊ |
| 1361 | #define BIND_OPCODE_DO_BIND␉␉␉␉␉0x90␊ |
| 1362 | #define BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB␉␉␉0xA0␊ |
| 1363 | #define BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED␉␉␉0xB0␊ |
| 1364 | #define BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB␉␉0xC0␊ |
| 1365 | ␊ |
| 1366 | ␊ |
| 1367 | /*␊ |
| 1368 | * The following are used on the flags byte of a terminal node␊ |
| 1369 | * in the export information.␊ |
| 1370 | */␊ |
| 1371 | #define EXPORT_SYMBOL_FLAGS_KIND_MASK␉␉␉␉0x03␊ |
| 1372 | #define EXPORT_SYMBOL_FLAGS_KIND_REGULAR␉␉␉0x00␊ |
| 1373 | #define EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL␉␉␉0x01␊ |
| 1374 | #define EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION␉␉␉0x04␊ |
| 1375 | #define EXPORT_SYMBOL_FLAGS_REEXPORT␉␉␉␉0x08␊ |
| 1376 | #define EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER␉␉␉0x10␊ |
| 1377 | ␊ |
| 1378 | /*␊ |
| 1379 | * The symseg_command contains the offset and size of the GNU style␊ |
| 1380 | * symbol table information as described in the header file <symseg.h>.␊ |
| 1381 | * The symbol roots of the symbol segments must also be aligned properly␊ |
| 1382 | * in the file. So the requirement of keeping the offsets aligned to a␊ |
| 1383 | * multiple of a 4 bytes translates to the length field of the symbol␊ |
| 1384 | * roots also being a multiple of a long. Also the padding must again be␊ |
| 1385 | * zeroed. (THIS IS OBSOLETE and no longer supported).␊ |
| 1386 | */␊ |
| 1387 | struct symseg_command {␊ |
| 1388 | ␉uint32_t␉cmd;␉␉/* LC_SYMSEG */␊ |
| 1389 | ␉uint32_t␉cmdsize;␉/* sizeof(struct symseg_command) */␊ |
| 1390 | ␉uint32_t␉offset;␉␉/* symbol segment offset */␊ |
| 1391 | ␉uint32_t␉size;␉␉/* symbol segment size in bytes */␊ |
| 1392 | };␊ |
| 1393 | ␊ |
| 1394 | /*␊ |
| 1395 | * The ident_command contains a free format string table following the␊ |
| 1396 | * ident_command structure. The strings are null terminated and the size of␊ |
| 1397 | * the command is padded out with zero bytes to a multiple of 4 bytes/␊ |
| 1398 | * (THIS IS OBSOLETE and no longer supported).␊ |
| 1399 | */␊ |
| 1400 | struct ident_command {␊ |
| 1401 | ␉uint32_t cmd;␉␉/* LC_IDENT */␊ |
| 1402 | ␉uint32_t cmdsize;␉/* strings that follow this command */␊ |
| 1403 | };␊ |
| 1404 | ␊ |
| 1405 | /*␊ |
| 1406 | * The fvmfile_command contains a reference to a file to be loaded at the␊ |
| 1407 | * specified virtual address. (Presently, this command is reserved for␊ |
| 1408 | * internal use. The kernel ignores this command when loading a program into␊ |
| 1409 | * memory).␊ |
| 1410 | */␊ |
| 1411 | struct fvmfile_command {␊ |
| 1412 | ␉uint32_t cmd;␉␉␉/* LC_FVMFILE */␊ |
| 1413 | ␉uint32_t cmdsize;␉␉/* includes pathname string */␊ |
| 1414 | ␉union lc_str␉name;␉␉/* files pathname */␊ |
| 1415 | ␉uint32_t␉header_addr;␉/* files virtual address */␊ |
| 1416 | };␊ |
| 1417 | ␊ |
| 1418 | ␊ |
| 1419 | /*␊ |
| 1420 | * The entry_point_command is a replacement for thread_command.␊ |
| 1421 | * It is used for main executables to specify the location (file offset)␊ |
| 1422 | * of main(). If -stack_size was used at link time, the stacksize␊ |
| 1423 | * field will contain the stack size need for the main thread.␊ |
| 1424 | */␊ |
| 1425 | struct entry_point_command {␊ |
| 1426 | uint32_t cmd;␉/* LC_MAIN only used in MH_EXECUTE filetypes */␊ |
| 1427 | uint32_t cmdsize;␉/* 24 */␊ |
| 1428 | uint64_t entryoff;␉/* file (__TEXT) offset of main() */␊ |
| 1429 | uint64_t stacksize;/* if not zero, initial stack size */␊ |
| 1430 | };␊ |
| 1431 | ␊ |
| 1432 | ␊ |
| 1433 | /*␊ |
| 1434 | * The source_version_command is an optional load command containing␊ |
| 1435 | * the version of the sources used to build the binary.␊ |
| 1436 | */␊ |
| 1437 | struct source_version_command {␊ |
| 1438 | uint32_t cmd;␉/* LC_SOURCE_VERSION */␊ |
| 1439 | uint32_t cmdsize;␉/* 16 */␊ |
| 1440 | uint64_t version;␉/* A.B.C.D.E packed as a24.b10.c10.d10.e10 */␊ |
| 1441 | };␊ |
| 1442 | ␊ |
| 1443 | ␊ |
| 1444 | /*␊ |
| 1445 | * The LC_DATA_IN_CODE load commands uses a linkedit_data_command␊ |
| 1446 | * to point to an array of data_in_code_entry entries. Each entry␊ |
| 1447 | * describes a range of data in a code section.␊ |
| 1448 | */␊ |
| 1449 | struct data_in_code_entry {␊ |
| 1450 | uint32_t␉offset; /* from mach_header to start of data range*/␊ |
| 1451 | uint16_t␉length; /* number of bytes in data range */␊ |
| 1452 | uint16_t␉kind; /* a DICE_KIND_* value */␊ |
| 1453 | };␊ |
| 1454 | #define DICE_KIND_DATA 0x0001␊ |
| 1455 | #define DICE_KIND_JUMP_TABLE8 0x0002␊ |
| 1456 | #define DICE_KIND_JUMP_TABLE16 0x0003␊ |
| 1457 | #define DICE_KIND_JUMP_TABLE32 0x0004␊ |
| 1458 | #define DICE_KIND_ABS_JUMP_TABLE32 0x0005␊ |
| 1459 | ␊ |
| 1460 | ␊ |
| 1461 | ␊ |
| 1462 | /*␊ |
| 1463 | * Sections of type S_THREAD_LOCAL_VARIABLES contain an array␊ |
| 1464 | * of tlv_descriptor structures.␊ |
| 1465 | */␊ |
| 1466 | struct tlv_descriptor␊ |
| 1467 | {␊ |
| 1468 | ␉void*␉␉(*thunk)(struct tlv_descriptor*);␊ |
| 1469 | ␉unsigned long␉key;␊ |
| 1470 | ␉unsigned long␉offset;␊ |
| 1471 | };␊ |
| 1472 | ␊ |
| 1473 | #endif /* _MACHO_LOADER_H_ */␊ |
| 1474 | |
