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 */ 54struct 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 */ 72struct 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 */ 227struct 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 */ 308union 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 */ 327struct 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 */ 347struct 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 */ 404struct 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 418struct 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 */ 606struct 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 */ 619struct 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 */ 634struct 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 */ 648struct 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 */ 665struct 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 */ 680struct 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 */ 699struct 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 */ 720struct 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 */ 735struct 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 */ 751struct 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 */ 779struct 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 */ 796struct 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 */ 813struct 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 */ 832struct 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 */ 881struct 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 */ 1009struct 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 */ 1017struct 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 */ 1044struct 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 */ 1078struct 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 */ 1087struct 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 */ 1110struct 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 */ 1126struct 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 */ 1136struct 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 */ 1146struct 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 */ 1156struct 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 */ 1169struct 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 */ 1182struct 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 */ 1197struct 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 */ 1213struct 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 */ 1387struct 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 */ 1400struct 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 */ 1411struct 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 */ 1425struct 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 */ 1437struct 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 */ 1449struct 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 */ 1466struct 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