1/* 2 * Copyright (c) 1999-2008 Apple Inc. All Rights Reserved. 3 * 4 * @APPLE_OSREFERENCE_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. The rights granted to you under the License 10 * may not be used to create, or enable the creation or redistribution of, 11 * unlawful or unlicensed copies of an Apple operating system, or to 12 * circumvent, violate, or enable the circumvention or violation of, any 13 * terms of an Apple operating system software license agreement. 14 * 15 * Please obtain a copy of the License at 16 * http://www.opensource.apple.com/apsl/ and read it before using this file. 17 * 18 * The Original Code and all software distributed under the License are 19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 23 * Please see the License for the specific language governing rights and 24 * limitations under the License. 25 * 26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ 27 */ 28#ifndef _MACHO_LOADER_H_ 29#define _MACHO_LOADER_H_ 30 31/* 32 * This file describes the format of mach object files. 33 */ 34#include <stdint.h> 35 36/* 37 * <mach/machine.h> is needed here for the cpu_type_t and cpu_subtype_t types 38 * and contains the constants for the possible values of these types. 39 */ 40#include <mach/machine.h> 41 42/* 43 * <mach/vm_prot.h> is needed here for the vm_prot_t type and contains the 44 * constants that are or'ed together for the possible values of this type. 45 */ 46#include <mach/vm_prot.h> 47 48/* 49 * <machine/thread_status.h> is expected to define the flavors of the thread 50 * states and the structures of those flavors for each machine. 51 */ 52#include <mach/machine/thread_status.h> 53#ifndef KERNEL 54#include <architecture/byte_order.h> 55#endif /* KERNEL */ 56 57/* 58 * The 32-bit mach header appears at the very beginning of the object file for 59 * 32-bit architectures. 60 */ 61struct mach_header { 62 uint32_t magic; /* mach magic number identifier */ 63 cpu_type_t cputype; /* cpu specifier */ 64 cpu_subtype_t cpusubtype; /* machine specifier */ 65 uint32_t filetype; /* type of file */ 66 uint32_t ncmds; /* number of load commands */ 67 uint32_t sizeofcmds; /* the size of all the load commands */ 68 uint32_t flags; /* flags */ 69}; 70 71/* Constant for the magic field of the mach_header (32-bit architectures) */ 72#define MH_MAGIC 0xfeedface /* the mach magic number */ 73#define MH_CIGAM 0xcefaedfe /* NXSwapInt(MH_MAGIC) */ 74 75/* 76 * The 64-bit mach header appears at the very beginning of object files for 77 * 64-bit architectures. 78 */ 79struct mach_header_64 { 80 uint32_t magic; /* mach magic number identifier */ 81 cpu_type_t cputype; /* cpu specifier */ 82 cpu_subtype_t cpusubtype; /* machine specifier */ 83 uint32_t filetype; /* type of file */ 84 uint32_t ncmds; /* number of load commands */ 85 uint32_t sizeofcmds; /* the size of all the load commands */ 86 uint32_t flags; /* flags */ 87 uint32_t reserved; /* reserved */ 88}; 89 90/* Constant for the magic field of the mach_header_64 (64-bit architectures) */ 91#define MH_MAGIC_64 0xfeedfacf /* the 64-bit mach magic number */ 92#define MH_CIGAM_64 0xcffaedfe /* NXSwapInt(MH_MAGIC_64) */ 93 94/* 95 * The layout of the file depends on the filetype. For all but the MH_OBJECT 96 * file type the segments are padded out and aligned on a segment alignment 97 * boundary for efficient demand pageing. The MH_EXECUTE, MH_FVMLIB, MH_DYLIB, 98 * MH_DYLINKER and MH_BUNDLE file types also have the headers included as part 99 * of their first segment. 100 * 101 * The file type MH_OBJECT is a compact format intended as output of the 102 * assembler and input (and possibly output) of the link editor (the .o 103 * format). All sections are in one unnamed segment with no segment padding. 104 * This format is used as an executable format when the file is so small the 105 * segment padding greatly increases its size. 106 * 107 * The file type MH_PRELOAD is an executable format intended for things that 108 * are not executed under the kernel (proms, stand alones, kernels, etc). The 109 * format can be executed under the kernel but may demand paged it and not 110 * preload it before execution. 111 * 112 * A core file is in MH_CORE format and can be any in an arbritray legal 113 * Mach-O file. 114 * 115 * Constants for the filetype field of the mach_header 116 */ 117#define MH_OBJECT 0x1 /* relocatable object file */ 118#define MH_EXECUTE 0x2 /* demand paged executable file */ 119#define MH_FVMLIB 0x3 /* fixed VM shared library file */ 120#define MH_CORE 0x4 /* core file */ 121#define MH_PRELOAD 0x5 /* preloaded executable file */ 122#define MH_DYLIB 0x6 /* dynamically bound shared library */ 123#define MH_DYLINKER 0x7 /* dynamic link editor */ 124#define MH_BUNDLE 0x8 /* dynamically bound bundle file */ 125#define MH_DYLIB_STUB 0x9 /* shared library stub for static */ 126 /* linking only, no section contents */ 127#define MH_DSYM 0xa /* companion file with only debug */ 128 /* sections */ 129 130/* Constants for the flags field of the mach_header */ 131#define MH_NOUNDEFS 0x1 /* the object file has no undefined 132 references */ 133#define MH_INCRLINK 0x2 /* the object file is the output of an 134 incremental link against a base file 135 and can't be link edited again */ 136#define MH_DYLDLINK 0x4 /* the object file is input for the 137 dynamic linker and can't be staticly 138 link edited again */ 139#define MH_BINDATLOAD 0x8 /* the object file's undefined 140 references are bound by the dynamic 141 linker when loaded. */ 142#define MH_PREBOUND 0x10 /* the file has its dynamic undefined 143 references prebound. */ 144#define MH_SPLIT_SEGS 0x20 /* the file has its read-only and 145 read-write segments split */ 146#define MH_LAZY_INIT 0x40 /* the shared library init routine is 147 to be run lazily via catching memory 148 faults to its writeable segments 149 (obsolete) */ 150#define MH_TWOLEVEL 0x80 /* the image is using two-level name 151 space bindings */ 152#define MH_FORCE_FLAT 0x100 /* the executable is forcing all images 153 to use flat name space bindings */ 154#define MH_NOMULTIDEFS 0x200 /* this umbrella guarantees no multiple 155 defintions of symbols in its 156 sub-images so the two-level namespace 157 hints can always be used. */ 158#define MH_NOFIXPREBINDING 0x400 /* do not have dyld notify the 159 prebinding agent about this 160 executable */ 161#define MH_PREBINDABLE 0x800 /* the binary is not prebound but can 162 have its prebinding redone. only used 163 when MH_PREBOUND is not set. */ 164#define MH_ALLMODSBOUND 0x1000 /* indicates that this binary binds to 165 all two-level namespace modules of 166 its dependent libraries. only used 167 when MH_PREBINDABLE and MH_TWOLEVEL 168 are both set. */ 169#define MH_SUBSECTIONS_VIA_SYMBOLS 0x2000/* safe to divide up the sections into 170 sub-sections via symbols for dead 171 code stripping */ 172#define MH_CANONICAL 0x4000 /* the binary has been canonicalized 173 via the unprebind operation */ 174#define MH_WEAK_DEFINES 0x8000 /* the final linked image contains 175 external weak symbols */ 176#define MH_BINDS_TO_WEAK 0x10000 /* the final linked image uses 177 weak symbols */ 178 179#define MH_ALLOW_STACK_EXECUTION 0x20000/* When this bit is set, all stacks 180 in the task will be given stack 181 execution privilege. Only used in 182 MH_EXECUTE filetypes. */ 183#define MH_ROOT_SAFE 0x40000 /* When this bit is set, the binary 184 declares it is safe for use in 185 processes with uid zero */ 186 187#define MH_SETUID_SAFE 0x80000 /* When this bit is set, the binary 188 declares it is safe for use in 189 processes when issetugid() is true */ 190 191#define MH_NO_REEXPORTED_DYLIBS 0x100000 /* When this bit is set on a dylib, 192 the static linker does not need to 193 examine dependent dylibs to see 194 if any are re-exported */ 195#define MH_PIE 0x200000 /* When this bit is set, the OS will 196 load the main executable at a 197 random address. Only used in 198 MH_EXECUTE filetypes. */ 199 200/* 201 * The load commands directly follow the mach_header. The total size of all 202 * of the commands is given by the sizeofcmds field in the mach_header. All 203 * load commands must have as their first two fields cmd and cmdsize. The cmd 204 * field is filled in with a constant for that command type. Each command type 205 * has a structure specifically for it. The cmdsize field is the size in bytes 206 * of the particular load command structure plus anything that follows it that 207 * is a part of the load command (i.e. section structures, strings, etc.). To 208 * advance to the next load command the cmdsize can be added to the offset or 209 * pointer of the current load command. The cmdsize for 32-bit architectures 210 * MUST be a multiple of 4 bytes and for 64-bit architectures MUST be a multiple 211 * of 8 bytes (these are forever the maximum alignment of any load commands). 212 * The padded bytes must be zero. All tables in the object file must also 213 * follow these rules so the file can be memory mapped. Otherwise the pointers 214 * to these tables will not work well or at all on some machines. With all 215 * padding zeroed like objects will compare byte for byte. 216 */ 217struct load_command { 218 uint32_t cmd; /* type of load command */ 219 uint32_t cmdsize; /* total size of command in bytes */ 220}; 221 222/* 223 * After MacOS X 10.1 when a new load command is added that is required to be 224 * understood by the dynamic linker for the image to execute properly the 225 * LC_REQ_DYLD bit will be or'ed into the load command constant. If the dynamic 226 * linker sees such a load command it it does not understand will issue a 227 * "unknown load command required for execution" error and refuse to use the 228 * image. Other load commands without this bit that are not understood will 229 * simply be ignored. 230 */ 231#define LC_REQ_DYLD 0x80000000 232 233/* Constants for the cmd field of all load commands, the type */ 234#define LC_SEGMENT 0x1 /* segment of this file to be mapped */ 235#define LC_SYMTAB 0x2 /* link-edit stab symbol table info */ 236#define LC_SYMSEG 0x3 /* link-edit gdb symbol table info (obsolete) */ 237#define LC_THREAD 0x4 /* thread */ 238#define LC_UNIXTHREAD 0x5 /* unix thread (includes a stack) */ 239#define LC_LOADFVMLIB 0x6 /* load a specified fixed VM shared library */ 240#define LC_IDFVMLIB 0x7 /* fixed VM shared library identification */ 241#define LC_IDENT 0x8 /* object identification info (obsolete) */ 242#define LC_FVMFILE 0x9 /* fixed VM file inclusion (internal use) */ 243#define LC_PREPAGE 0xa /* prepage command (internal use) */ 244#define LC_DYSYMTAB 0xb /* dynamic link-edit symbol table info */ 245#define LC_LOAD_DYLIB 0xc /* load a dynamically linked shared library */ 246#define LC_ID_DYLIB 0xd /* dynamically linked shared lib ident */ 247#define LC_LOAD_DYLINKER 0xe /* load a dynamic linker */ 248#define LC_ID_DYLINKER 0xf /* dynamic linker identification */ 249#define LC_PREBOUND_DYLIB 0x10 /* modules prebound for a dynamically */ 250 /* linked shared library */ 251#define LC_ROUTINES 0x11 /* image routines */ 252#define LC_SUB_FRAMEWORK 0x12 /* sub framework */ 253#define LC_SUB_UMBRELLA 0x13 /* sub umbrella */ 254#define LC_SUB_CLIENT 0x14 /* sub client */ 255#define LC_SUB_LIBRARY 0x15 /* sub library */ 256#define LC_TWOLEVEL_HINTS 0x16 /* two-level namespace lookup hints */ 257#define LC_PREBIND_CKSUM 0x17 /* prebind checksum */ 258 259/* 260 * load a dynamically linked shared library that is allowed to be missing 261 * (all symbols are weak imported). 262 */ 263#define LC_LOAD_WEAK_DYLIB (0x18 | LC_REQ_DYLD) 264 265#define LC_SEGMENT_64 0x19 /* 64-bit segment of this file to be 266 mapped */ 267#define LC_ROUTINES_64 0x1a /* 64-bit image routines */ 268#define LC_UUID 0x1b /* the uuid */ 269#define LC_RPATH (0x1c | LC_REQ_DYLD) /* runpath additions */ 270#define LC_CODE_SIGNATURE 0x1d /* local of code signature */ 271#define LC_SEGMENT_SPLIT_INFO 0x1e /* local of info to split segments */ 272#define LC_REEXPORT_DYLIB (0x1f | LC_REQ_DYLD) /* load and re-export dylib */ 273#define LC_LAZY_LOAD_DYLIB 0x20 /* delay load of dylib until first use */ 274#define LC_ENCRYPTION_INFO 0x21 /* encrypted segment information */ 275 276/* 277 * A variable length string in a load command is represented by an lc_str 278 * union. The strings are stored just after the load command structure and 279 * the offset is from the start of the load command structure. The size 280 * of the string is reflected in the cmdsize field of the load command. 281 * Once again any padded bytes to bring the cmdsize field to a multiple 282 * of 4 bytes must be zero. 283 */ 284union lc_str { 285 uint32_t offset; /* offset to the string */ 286#ifndef __LP64__ 287 char *ptr; /* pointer to the string */ 288#endif 289}; 290 291/* 292 * The segment load command indicates that a part of this file is to be 293 * mapped into the task's address space. The size of this segment in memory, 294 * vmsize, maybe equal to or larger than the amount to map from this file, 295 * filesize. The file is mapped starting at fileoff to the beginning of 296 * the segment in memory, vmaddr. The rest of the memory of the segment, 297 * if any, is allocated zero fill on demand. The segment's maximum virtual 298 * memory protection and initial virtual memory protection are specified 299 * by the maxprot and initprot fields. If the segment has sections then the 300 * section structures directly follow the segment command and their size is 301 * reflected in cmdsize. 302 */ 303struct segment_command { /* for 32-bit architectures */ 304 uint32_t cmd; /* LC_SEGMENT */ 305 uint32_t cmdsize; /* includes sizeof section structs */ 306 char segname[16]; /* segment name */ 307 uint32_t vmaddr; /* memory address of this segment */ 308 uint32_t vmsize; /* memory size of this segment */ 309 uint32_t fileoff; /* file offset of this segment */ 310 uint32_t filesize; /* amount to map from the file */ 311 vm_prot_t maxprot; /* maximum VM protection */ 312 vm_prot_t initprot; /* initial VM protection */ 313 uint32_t nsects; /* number of sections in segment */ 314 uint32_t flags; /* flags */ 315}; 316 317/* 318 * The 64-bit segment load command indicates that a part of this file is to be 319 * mapped into a 64-bit task's address space. If the 64-bit segment has 320 * sections then section_64 structures directly follow the 64-bit segment 321 * command and their size is reflected in cmdsize. 322 */ 323struct segment_command_64 { /* for 64-bit architectures */ 324 uint32_t cmd; /* LC_SEGMENT_64 */ 325 uint32_t cmdsize; /* includes sizeof section_64 structs */ 326 char segname[16]; /* segment name */ 327 uint64_t vmaddr; /* memory address of this segment */ 328 uint64_t vmsize; /* memory size of this segment */ 329 uint64_t fileoff; /* file offset of this segment */ 330 uint64_t filesize; /* amount to map from the file */ 331 vm_prot_t maxprot; /* maximum VM protection */ 332 vm_prot_t initprot; /* initial VM protection */ 333 uint32_t nsects; /* number of sections in segment */ 334 uint32_t flags; /* flags */ 335}; 336 337/* Constants for the flags field of the segment_command */ 338#define SG_HIGHVM 0x1 /* the file contents for this segment is for 339 the high part of the VM space, the low part 340 is zero filled (for stacks in core files) */ 341#define SG_FVMLIB 0x2 /* this segment is the VM that is allocated by 342 a fixed VM library, for overlap checking in 343 the link editor */ 344#define SG_NORELOC 0x4 /* this segment has nothing that was relocated 345 in it and nothing relocated to it, that is 346 it maybe safely replaced without relocation*/ 347#define SG_PROTECTED_VERSION_1 0x8 /* This segment is protected. If the 348 segment starts at file offset 0, the 349 first page of the segment is not 350 protected. All other pages of the 351 segment are protected. */ 352 353/* 354 * A segment is made up of zero or more sections. Non-MH_OBJECT files have 355 * all of their segments with the proper sections in each, and padded to the 356 * specified segment alignment when produced by the link editor. The first 357 * segment of a MH_EXECUTE and MH_FVMLIB format file contains the mach_header 358 * and load commands of the object file before its first section. The zero 359 * fill sections are always last in their segment (in all formats). This 360 * allows the zeroed segment padding to be mapped into memory where zero fill 361 * sections might be. The gigabyte zero fill sections, those with the section 362 * type S_GB_ZEROFILL, can only be in a segment with sections of this type. 363 * These segments are then placed after all other segments. 364 * 365 * The MH_OBJECT format has all of its sections in one segment for 366 * compactness. There is no padding to a specified segment boundary and the 367 * mach_header and load commands are not part of the segment. 368 * 369 * Sections with the same section name, sectname, going into the same segment, 370 * segname, are combined by the link editor. The resulting section is aligned 371 * to the maximum alignment of the combined sections and is the new section's 372 * alignment. The combined sections are aligned to their original alignment in 373 * the combined section. Any padded bytes to get the specified alignment are 374 * zeroed. 375 * 376 * The format of the relocation entries referenced by the reloff and nreloc 377 * fields of the section structure for mach object files is described in the 378 * header file <reloc.h>. 379 */ 380struct section { /* for 32-bit architectures */ 381 char sectname[16]; /* name of this section */ 382 char segname[16]; /* segment this section goes in */ 383 uint32_t addr; /* memory address of this section */ 384 uint32_t size; /* size in bytes of this section */ 385 uint32_t offset; /* file offset of this section */ 386 uint32_t align; /* section alignment (power of 2) */ 387 uint32_t reloff; /* file offset of relocation entries */ 388 uint32_t nreloc; /* number of relocation entries */ 389 uint32_t flags; /* flags (section type and attributes)*/ 390 uint32_t reserved1; /* reserved (for offset or index) */ 391 uint32_t reserved2; /* reserved (for count or sizeof) */ 392}; 393 394struct section_64 { /* for 64-bit architectures */ 395 char sectname[16]; /* name of this section */ 396 char segname[16]; /* segment this section goes in */ 397 uint64_t addr; /* memory address of this section */ 398 uint64_t size; /* size in bytes of this section */ 399 uint32_t offset; /* file offset of this section */ 400 uint32_t align; /* section alignment (power of 2) */ 401 uint32_t reloff; /* file offset of relocation entries */ 402 uint32_t nreloc; /* number of relocation entries */ 403 uint32_t flags; /* flags (section type and attributes)*/ 404 uint32_t reserved1; /* reserved (for offset or index) */ 405 uint32_t reserved2; /* reserved (for count or sizeof) */ 406 uint32_t reserved3; /* reserved */ 407}; 408 409/* 410 * The flags field of a section structure is separated into two parts a section 411 * type and section attributes. The section types are mutually exclusive (it 412 * can only have one type) but the section attributes are not (it may have more 413 * than one attribute). 414 */ 415#define SECTION_TYPE 0x000000ff /* 256 section types */ 416#define SECTION_ATTRIBUTES 0xffffff00 /* 24 section attributes */ 417 418/* Constants for the type of a section */ 419#define S_REGULAR 0x0 /* regular section */ 420#define S_ZEROFILL 0x1 /* zero fill on demand section */ 421#define S_CSTRING_LITERALS 0x2 /* section with only literal C strings*/ 422#define S_4BYTE_LITERALS 0x3 /* section with only 4 byte literals */ 423#define S_8BYTE_LITERALS 0x4 /* section with only 8 byte literals */ 424#define S_LITERAL_POINTERS 0x5 /* section with only pointers to */ 425 /* literals */ 426/* 427 * For the two types of symbol pointers sections and the symbol stubs section 428 * they have indirect symbol table entries. For each of the entries in the 429 * section the indirect symbol table entries, in corresponding order in the 430 * indirect symbol table, start at the index stored in the reserved1 field 431 * of the section structure. Since the indirect symbol table entries 432 * correspond to the entries in the section the number of indirect symbol table 433 * entries is inferred from the size of the section divided by the size of the 434 * entries in the section. For symbol pointers sections the size of the entries 435 * in the section is 4 bytes and for symbol stubs sections the byte size of the 436 * stubs is stored in the reserved2 field of the section structure. 437 */ 438#define S_NON_LAZY_SYMBOL_POINTERS 0x6 /* section with only non-lazy 439 symbol pointers */ 440#define S_LAZY_SYMBOL_POINTERS 0x7 /* section with only lazy symbol 441 pointers */ 442#define S_SYMBOL_STUBS 0x8 /* section with only symbol 443 stubs, byte size of stub in 444 the reserved2 field */ 445#define S_MOD_INIT_FUNC_POINTERS 0x9 /* section with only function 446 pointers for initialization*/ 447#define S_MOD_TERM_FUNC_POINTERS 0xa /* section with only function 448 pointers for termination */ 449#define S_COALESCED 0xb /* section contains symbols that 450 are to be coalesced */ 451#define S_GB_ZEROFILL 0xc /* zero fill on demand section 452 (that can be larger than 4 453 gigabytes) */ 454#define S_INTERPOSING 0xd /* section with only pairs of 455 function pointers for 456 interposing */ 457#define S_16BYTE_LITERALS 0xe /* section with only 16 byte 458 literals */ 459#define S_DTRACE_DOF 0xf /* section contains 460 DTrace Object Format */ 461#define S_LAZY_DYLIB_SYMBOL_POINTERS 0x10 /* section with only lazy 462 symbol pointers to lazy 463 loaded dylibs */ 464/* 465 * Constants for the section attributes part of the flags field of a section 466 * structure. 467 */ 468#define SECTION_ATTRIBUTES_USR 0xff000000 /* User setable attributes */ 469#define S_ATTR_PURE_INSTRUCTIONS 0x80000000 /* section contains only true 470 machine instructions */ 471#define S_ATTR_NO_TOC 0x40000000 /* section contains coalesced 472 symbols that are not to be 473 in a ranlib table of 474 contents */ 475#define S_ATTR_STRIP_STATIC_SYMS 0x20000000 /* ok to strip static symbols 476 in this section in files 477 with the MH_DYLDLINK flag */ 478#define S_ATTR_NO_DEAD_STRIP 0x10000000 /* no dead stripping */ 479#define S_ATTR_LIVE_SUPPORT 0x08000000 /* blocks are live if they 480 reference live blocks */ 481#define S_ATTR_SELF_MODIFYING_CODE 0x04000000 /* Used with i386 code stubs 482 written on by dyld */ 483/* 484 * If a segment contains any sections marked with S_ATTR_DEBUG then all 485 * sections in that segment must have this attribute. No section other than 486 * a section marked with this attribute may reference the contents of this 487 * section. A section with this attribute may contain no symbols and must have 488 * a section type S_REGULAR. The static linker will not copy section contents 489 * from sections with this attribute into its output file. These sections 490 * generally contain DWARF debugging info. 491 */ 492#define S_ATTR_DEBUG 0x02000000 /* a debug section */ 493#define SECTION_ATTRIBUTES_SYS 0x00ffff00 /* system setable attributes */ 494#define S_ATTR_SOME_INSTRUCTIONS 0x00000400 /* section contains some 495 machine instructions */ 496#define S_ATTR_EXT_RELOC 0x00000200 /* section has external 497 relocation entries */ 498#define S_ATTR_LOC_RELOC 0x00000100 /* section has local 499 relocation entries */ 500 501 502/* 503 * The names of segments and sections in them are mostly meaningless to the 504 * link-editor. But there are few things to support traditional UNIX 505 * executables that require the link-editor and assembler to use some names 506 * agreed upon by convention. 507 * 508 * The initial protection of the "__TEXT" segment has write protection turned 509 * off (not writeable). 510 * 511 * The link-editor will allocate common symbols at the end of the "__common" 512 * section in the "__DATA" segment. It will create the section and segment 513 * if needed. 514 */ 515 516/* The currently known segment names and the section names in those segments */ 517 518#define SEG_PAGEZERO "__PAGEZERO" /* the pagezero segment which has no */ 519 /* protections and catches NULL */ 520 /* references for MH_EXECUTE files */ 521 522 523#define SEG_TEXT "__TEXT" /* the tradition UNIX text segment */ 524#define SECT_TEXT "__text" /* the real text part of the text */ 525 /* section no headers, and no padding */ 526#define SECT_FVMLIB_INIT0 "__fvmlib_init0" /* the fvmlib initialization */ 527 /* section */ 528#define SECT_FVMLIB_INIT1 "__fvmlib_init1" /* the section following the */ 529 /* fvmlib initialization */ 530 /* section */ 531 532#define SEG_DATA "__DATA" /* the tradition UNIX data segment */ 533#define SECT_DATA "__data" /* the real initialized data section */ 534 /* no padding, no bss overlap */ 535#define SECT_BSS "__bss" /* the real uninitialized data section*/ 536 /* no padding */ 537#define SECT_COMMON "__common" /* the section common symbols are */ 538 /* allocated in by the link editor */ 539 540#define SEG_OBJC "__OBJC" /* objective-C runtime segment */ 541#define SECT_OBJC_SYMBOLS "__symbol_table" /* symbol table */ 542#define SECT_OBJC_MODULES "__module_info" /* module information */ 543#define SECT_OBJC_STRINGS "__selector_strs" /* string table */ 544#define SECT_OBJC_REFS "__selector_refs" /* string table */ 545 546#define SEG_ICON "__ICON" /* the icon segment */ 547#define SECT_ICON_HEADER "__header" /* the icon headers */ 548#define SECT_ICON_TIFF "__tiff" /* the icons in tiff format */ 549 550#define SEG_LINKEDIT "__LINKEDIT" /* the segment containing all structs */ 551 /* created and maintained by the link */ 552 /* editor. Created with -seglinkedit */ 553 /* option to ld(1) for MH_EXECUTE and */ 554 /* FVMLIB file types only */ 555 556#define SEG_UNIXSTACK "__UNIXSTACK" /* the unix stack segment */ 557 558#define SEG_IMPORT "__IMPORT" /* the segment for the self (dyld) */ 559 /* modifing code stubs that has read, */ 560 /* write and execute permissions */ 561 562/* 563 * Fixed virtual memory shared libraries are identified by two things. The 564 * target pathname (the name of the library as found for execution), and the 565 * minor version number. The address of where the headers are loaded is in 566 * header_addr. (THIS IS OBSOLETE and no longer supported). 567 */ 568struct fvmlib { 569 union lc_str name; /* library's target pathname */ 570 uint32_t minor_version; /* library's minor version number */ 571 uint32_t header_addr; /* library's header address */ 572}; 573 574/* 575 * A fixed virtual shared library (filetype == MH_FVMLIB in the mach header) 576 * contains a fvmlib_command (cmd == LC_IDFVMLIB) to identify the library. 577 * An object that uses a fixed virtual shared library also contains a 578 * fvmlib_command (cmd == LC_LOADFVMLIB) for each library it uses. 579 * (THIS IS OBSOLETE and no longer supported). 580 */ 581struct fvmlib_command { 582 uint32_t cmd; /* LC_IDFVMLIB or LC_LOADFVMLIB */ 583 uint32_t cmdsize; /* includes pathname string */ 584 struct fvmlib fvmlib; /* the library identification */ 585}; 586 587/* 588 * Dynamicly linked shared libraries are identified by two things. The 589 * pathname (the name of the library as found for execution), and the 590 * compatibility version number. The pathname must match and the compatibility 591 * number in the user of the library must be greater than or equal to the 592 * library being used. The time stamp is used to record the time a library was 593 * built and copied into user so it can be use to determined if the library used 594 * at runtime is exactly the same as used to built the program. 595 */ 596struct dylib { 597 union lc_str name; /* library's path name */ 598 uint32_t timestamp; /* library's build time stamp */ 599 uint32_t current_version; /* library's current version number */ 600 uint32_t compatibility_version; /* library's compatibility vers number*/ 601}; 602 603/* 604 * A dynamically linked shared library (filetype == MH_DYLIB in the mach header) 605 * contains a dylib_command (cmd == LC_ID_DYLIB) to identify the library. 606 * An object that uses a dynamically linked shared library also contains a 607 * dylib_command (cmd == LC_LOAD_DYLIB, LC_LOAD_WEAK_DYLIB, or 608 * LC_REEXPORT_DYLIB) for each library it uses. 609 */ 610struct dylib_command { 611 uint32_t cmd; /* LC_ID_DYLIB, LC_LOAD_{,WEAK_}DYLIB, 612 LC_REEXPORT_DYLIB */ 613 uint32_t cmdsize; /* includes pathname string */ 614 struct dylib dylib; /* the library identification */ 615}; 616 617/* 618 * A dynamically linked shared library may be a subframework of an umbrella 619 * framework. If so it will be linked with "-umbrella umbrella_name" where 620 * Where "umbrella_name" is the name of the umbrella framework. A subframework 621 * can only be linked against by its umbrella framework or other subframeworks 622 * that are part of the same umbrella framework. Otherwise the static link 623 * editor produces an error and states to link against the umbrella framework. 624 * The name of the umbrella framework for subframeworks is recorded in the 625 * following structure. 626 */ 627struct sub_framework_command { 628 uint32_t cmd; /* LC_SUB_FRAMEWORK */ 629 uint32_t cmdsize; /* includes umbrella string */ 630 union lc_str umbrella; /* the umbrella framework name */ 631}; 632 633/* 634 * For dynamically linked shared libraries that are subframework of an umbrella 635 * framework they can allow clients other than the umbrella framework or other 636 * subframeworks in the same umbrella framework. To do this the subframework 637 * is built with "-allowable_client client_name" and an LC_SUB_CLIENT load 638 * command is created for each -allowable_client flag. The client_name is 639 * usually a framework name. It can also be a name used for bundles clients 640 * where the bundle is built with "-client_name client_name". 641 */ 642struct sub_client_command { 643 uint32_t cmd; /* LC_SUB_CLIENT */ 644 uint32_t cmdsize; /* includes client string */ 645 union lc_str client; /* the client name */ 646}; 647 648/* 649 * A dynamically linked shared library may be a sub_umbrella of an umbrella 650 * framework. If so it will be linked with "-sub_umbrella umbrella_name" where 651 * Where "umbrella_name" is the name of the sub_umbrella framework. When 652 * staticly linking when -twolevel_namespace is in effect a twolevel namespace 653 * umbrella framework will only cause its subframeworks and those frameworks 654 * listed as sub_umbrella frameworks to be implicited linked in. Any other 655 * dependent dynamic libraries will not be linked it when -twolevel_namespace 656 * is in effect. The primary library recorded by the static linker when 657 * resolving a symbol in these libraries will be the umbrella framework. 658 * Zero or more sub_umbrella frameworks may be use by an umbrella framework. 659 * The name of a sub_umbrella framework is recorded in the following structure. 660 */ 661struct sub_umbrella_command { 662 uint32_t cmd; /* LC_SUB_UMBRELLA */ 663 uint32_t cmdsize; /* includes sub_umbrella string */ 664 union lc_str sub_umbrella; /* the sub_umbrella framework name */ 665}; 666 667/* 668 * A dynamically linked shared library may be a sub_library of another shared 669 * library. If so it will be linked with "-sub_library library_name" where 670 * Where "library_name" is the name of the sub_library shared library. When 671 * staticly linking when -twolevel_namespace is in effect a twolevel namespace 672 * shared library will only cause its subframeworks and those frameworks 673 * listed as sub_umbrella frameworks and libraries listed as sub_libraries to 674 * be implicited linked in. Any other dependent dynamic libraries will not be 675 * linked it when -twolevel_namespace is in effect. The primary library 676 * recorded by the static linker when resolving a symbol in these libraries 677 * will be the umbrella framework (or dynamic library). Zero or more sub_library 678 * shared libraries may be use by an umbrella framework or (or dynamic library). 679 * The name of a sub_library framework is recorded in the following structure. 680 * For example /usr/lib/libobjc_profile.A.dylib would be recorded as "libobjc". 681 */ 682struct sub_library_command { 683 uint32_t cmd; /* LC_SUB_LIBRARY */ 684 uint32_t cmdsize; /* includes sub_library string */ 685 union lc_str sub_library; /* the sub_library name */ 686}; 687 688/* 689 * A program (filetype == MH_EXECUTE) that is 690 * prebound to its dynamic libraries has one of these for each library that 691 * the static linker used in prebinding. It contains a bit vector for the 692 * modules in the library. The bits indicate which modules are bound (1) and 693 * which are not (0) from the library. The bit for module 0 is the low bit 694 * of the first byte. So the bit for the Nth module is: 695 * (linked_modules[N/8] >> N%8) & 1 696 */ 697struct prebound_dylib_command { 698 uint32_t cmd; /* LC_PREBOUND_DYLIB */ 699 uint32_t cmdsize; /* includes strings */ 700 union lc_str name; /* library's path name */ 701 uint32_t nmodules; /* number of modules in library */ 702 union lc_str linked_modules; /* bit vector of linked modules */ 703}; 704 705/* 706 * A program that uses a dynamic linker contains a dylinker_command to identify 707 * the name of the dynamic linker (LC_LOAD_DYLINKER). And a dynamic linker 708 * contains a dylinker_command to identify the dynamic linker (LC_ID_DYLINKER). 709 * A file can have at most one of these. 710 */ 711struct dylinker_command { 712 uint32_t cmd; /* LC_ID_DYLINKER or LC_LOAD_DYLINKER */ 713 uint32_t cmdsize; /* includes pathname string */ 714 union lc_str name; /* dynamic linker's path name */ 715}; 716 717/* 718 * Thread commands contain machine-specific data structures suitable for 719 * use in the thread state primitives. The machine specific data structures 720 * follow the struct thread_command as follows. 721 * Each flavor of machine specific data structure is preceded by an unsigned 722 * long constant for the flavor of that data structure, an uint32_t 723 * that is the count of longs of the size of the state data structure and then 724 * the state data structure follows. This triple may be repeated for many 725 * flavors. The constants for the flavors, counts and state data structure 726 * definitions are expected to be in the header file <machine/thread_status.h>. 727 * These machine specific data structures sizes must be multiples of 728 * 4 bytes The cmdsize reflects the total size of the thread_command 729 * and all of the sizes of the constants for the flavors, counts and state 730 * data structures. 731 * 732 * For executable objects that are unix processes there will be one 733 * thread_command (cmd == LC_UNIXTHREAD) created for it by the link-editor. 734 * This is the same as a LC_THREAD, except that a stack is automatically 735 * created (based on the shell's limit for the stack size). Command arguments 736 * and environment variables are copied onto that stack. 737 */ 738struct thread_command { 739 uint32_t cmd; /* LC_THREAD or LC_UNIXTHREAD */ 740 uint32_t cmdsize; /* total size of this command */ 741 /* uint32_t flavor flavor of thread state */ 742 /* uint32_t count count of longs in thread state */ 743 /* struct XXX_thread_state state thread state for this flavor */ 744 /* ... */ 745}; 746 747/* 748 * The routines command contains the address of the dynamic shared library 749 * initialization routine and an index into the module table for the module 750 * that defines the routine. Before any modules are used from the library the 751 * dynamic linker fully binds the module that defines the initialization routine 752 * and then calls it. This gets called before any module initialization 753 * routines (used for C++ static constructors) in the library. 754 */ 755struct routines_command { /* for 32-bit architectures */ 756 uint32_t cmd; /* LC_ROUTINES */ 757 uint32_t cmdsize; /* total size of this command */ 758 uint32_t init_address; /* address of initialization routine */ 759 uint32_t init_module; /* index into the module table that */ 760 /* the init routine is defined in */ 761 uint32_t reserved1; 762 uint32_t reserved2; 763 uint32_t reserved3; 764 uint32_t reserved4; 765 uint32_t reserved5; 766 uint32_t reserved6; 767}; 768 769/* 770 * The 64-bit routines command. Same use as above. 771 */ 772struct routines_command_64 { /* for 64-bit architectures */ 773 uint32_t cmd; /* LC_ROUTINES_64 */ 774 uint32_t cmdsize; /* total size of this command */ 775 uint64_t init_address; /* address of initialization routine */ 776 uint64_t init_module; /* index into the module table that */ 777 /* the init routine is defined in */ 778 uint64_t reserved1; 779 uint64_t reserved2; 780 uint64_t reserved3; 781 uint64_t reserved4; 782 uint64_t reserved5; 783 uint64_t reserved6; 784}; 785 786/* 787 * The symtab_command contains the offsets and sizes of the link-edit 4.3BSD 788 * "stab" style symbol table information as described in the header files 789 * <nlist.h> and <stab.h>. 790 */ 791struct symtab_command { 792 uint32_t cmd; /* LC_SYMTAB */ 793 uint32_t cmdsize; /* sizeof(struct symtab_command) */ 794 uint32_t symoff; /* symbol table offset */ 795 uint32_t nsyms; /* number of symbol table entries */ 796 uint32_t stroff; /* string table offset */ 797 uint32_t strsize; /* string table size in bytes */ 798}; 799 800/* 801 * This is the second set of the symbolic information which is used to support 802 * the data structures for the dynamically link editor. 803 * 804 * The original set of symbolic information in the symtab_command which contains 805 * the symbol and string tables must also be present when this load command is 806 * present. When this load command is present the symbol table is organized 807 * into three groups of symbols: 808 * local symbols (static and debugging symbols) - grouped by module 809 * defined external symbols - grouped by module (sorted by name if not lib) 810 * undefined external symbols (sorted by name if MH_BINDATLOAD is not set, 811 * and in order the were seen by the static 812 * linker if MH_BINDATLOAD is set) 813 * In this load command there are offsets and counts to each of the three groups 814 * of symbols. 815 * 816 * This load command contains a the offsets and sizes of the following new 817 * symbolic information tables: 818 * table of contents 819 * module table 820 * reference symbol table 821 * indirect symbol table 822 * The first three tables above (the table of contents, module table and 823 * reference symbol table) are only present if the file is a dynamically linked 824 * shared library. For executable and object modules, which are files 825 * containing only one module, the information that would be in these three 826 * tables is determined as follows: 827 * table of contents - the defined external symbols are sorted by name 828 * module table - the file contains only one module so everything in the 829 * file is part of the module. 830 * reference symbol table - is the defined and undefined external symbols 831 * 832 * For dynamically linked shared library files this load command also contains 833 * offsets and sizes to the pool of relocation entries for all sections 834 * separated into two groups: 835 * external relocation entries 836 * local relocation entries 837 * For executable and object modules the relocation entries continue to hang 838 * off the section structures. 839 */ 840struct dysymtab_command { 841 uint32_t cmd; /* LC_DYSYMTAB */ 842 uint32_t cmdsize; /* sizeof(struct dysymtab_command) */ 843 844 /* 845 * The symbols indicated by symoff and nsyms of the LC_SYMTAB load command 846 * are grouped into the following three groups: 847 * local symbols (further grouped by the module they are from) 848 * defined external symbols (further grouped by the module they are from) 849 * undefined symbols 850 * 851 * The local symbols are used only for debugging. The dynamic binding 852 * process may have to use them to indicate to the debugger the local 853 * symbols for a module that is being bound. 854 * 855 * The last two groups are used by the dynamic binding process to do the 856 * binding (indirectly through the module table and the reference symbol 857 * table when this is a dynamically linked shared library file). 858 */ 859 uint32_t ilocalsym; /* index to local symbols */ 860 uint32_t nlocalsym; /* number of local symbols */ 861 862 uint32_t iextdefsym;/* index to externally defined symbols */ 863 uint32_t nextdefsym;/* number of externally defined symbols */ 864 865 uint32_t iundefsym; /* index to undefined symbols */ 866 uint32_t nundefsym; /* number of undefined symbols */ 867 868 /* 869 * For the for the dynamic binding process to find which module a symbol 870 * is defined in the table of contents is used (analogous to the ranlib 871 * structure in an archive) which maps defined external symbols to modules 872 * they are defined in. This exists only in a dynamically linked shared 873 * library file. For executable and object modules the defined external 874 * symbols are sorted by name and is use as the table of contents. 875 */ 876 uint32_t tocoff; /* file offset to table of contents */ 877 uint32_t ntoc; /* number of entries in table of contents */ 878 879 /* 880 * To support dynamic binding of "modules" (whole object files) the symbol 881 * table must reflect the modules that the file was created from. This is 882 * done by having a module table that has indexes and counts into the merged 883 * tables for each module. The module structure that these two entries 884 * refer to is described below. This exists only in a dynamically linked 885 * shared library file. For executable and object modules the file only 886 * contains one module so everything in the file belongs to the module. 887 */ 888 uint32_t modtaboff; /* file offset to module table */ 889 uint32_t nmodtab; /* number of module table entries */ 890 891 /* 892 * To support dynamic module binding the module structure for each module 893 * indicates the external references (defined and undefined) each module 894 * makes. For each module there is an offset and a count into the 895 * reference symbol table for the symbols that the module references. 896 * This exists only in a dynamically linked shared library file. For 897 * executable and object modules the defined external symbols and the 898 * undefined external symbols indicates the external references. 899 */ 900 uint32_t extrefsymoff; /* offset to referenced symbol table */ 901 uint32_t nextrefsyms; /* number of referenced symbol table entries */ 902 903 /* 904 * The sections that contain "symbol pointers" and "routine stubs" have 905 * indexes and (implied counts based on the size of the section and fixed 906 * size of the entry) into the "indirect symbol" table for each pointer 907 * and stub. For every section of these two types the index into the 908 * indirect symbol table is stored in the section header in the field 909 * reserved1. An indirect symbol table entry is simply a 32bit index into 910 * the symbol table to the symbol that the pointer or stub is referring to. 911 * The indirect symbol table is ordered to match the entries in the section. 912 */ 913 uint32_t indirectsymoff; /* file offset to the indirect symbol table */ 914 uint32_t nindirectsyms; /* number of indirect symbol table entries */ 915 916 /* 917 * To support relocating an individual module in a library file quickly the 918 * external relocation entries for each module in the library need to be 919 * accessed efficiently. Since the relocation entries can't be accessed 920 * through the section headers for a library file they are separated into 921 * groups of local and external entries further grouped by module. In this 922 * case the presents of this load command who's extreloff, nextrel, 923 * locreloff and nlocrel fields are non-zero indicates that the relocation 924 * entries of non-merged sections are not referenced through the section 925 * structures (and the reloff and nreloc fields in the section headers are 926 * set to zero). 927 * 928 * Since the relocation entries are not accessed through the section headers 929 * this requires the r_address field to be something other than a section 930 * offset to identify the item to be relocated. In this case r_address is 931 * set to the offset from the vmaddr of the first LC_SEGMENT command. 932 * For MH_SPLIT_SEGS images r_address is set to the the offset from the 933 * vmaddr of the first read-write LC_SEGMENT command. 934 * 935 * The relocation entries are grouped by module and the module table 936 * entries have indexes and counts into them for the group of external 937 * relocation entries for that the module. 938 * 939 * For sections that are merged across modules there must not be any 940 * remaining external relocation entries for them (for merged sections 941 * remaining relocation entries must be local). 942 */ 943 uint32_t extreloff; /* offset to external relocation entries */ 944 uint32_t nextrel; /* number of external relocation entries */ 945 946 /* 947 * All the local relocation entries are grouped together (they are not 948 * grouped by their module since they are only used if the object is moved 949 * from it staticly link edited address). 950 */ 951 uint32_t locreloff; /* offset to local relocation entries */ 952 uint32_t nlocrel; /* number of local relocation entries */ 953 954}; 955 956/* 957 * An indirect symbol table entry is simply a 32bit index into the symbol table 958 * to the symbol that the pointer or stub is refering to. Unless it is for a 959 * non-lazy symbol pointer section for a defined symbol which strip(1) as 960 * removed. In which case it has the value INDIRECT_SYMBOL_LOCAL. If the 961 * symbol was also absolute INDIRECT_SYMBOL_ABS is or'ed with that. 962 */ 963#define INDIRECT_SYMBOL_LOCAL 0x80000000 964#define INDIRECT_SYMBOL_ABS 0x40000000 965 966 967/* a table of contents entry */ 968struct dylib_table_of_contents { 969 uint32_t symbol_index; /* the defined external symbol 970 (index into the symbol table) */ 971 uint32_t module_index; /* index into the module table this symbol 972 is defined in */ 973}; 974 975/* a module table entry */ 976struct dylib_module { 977 uint32_t module_name; /* the module name (index into string table) */ 978 979 uint32_t iextdefsym; /* index into externally defined symbols */ 980 uint32_t nextdefsym; /* number of externally defined symbols */ 981 uint32_t irefsym; /* index into reference symbol table */ 982 uint32_t nrefsym; /* number of reference symbol table entries */ 983 uint32_t ilocalsym; /* index into symbols for local symbols */ 984 uint32_t nlocalsym; /* number of local symbols */ 985 986 uint32_t iextrel; /* index into external relocation entries */ 987 uint32_t nextrel; /* number of external relocation entries */ 988 989 uint32_t iinit_iterm; /* low 16 bits are the index into the init 990 section, high 16 bits are the index into 991 the term section */ 992 uint32_t ninit_nterm; /* low 16 bits are the number of init section 993 entries, high 16 bits are the number of 994 term section entries */ 995 996 uint32_t /* for this module address of the start of */ 997 objc_module_info_addr; /* the (__OBJC,__module_info) section */ 998 uint32_t /* for this module size of */ 999 objc_module_info_size; /* the (__OBJC,__module_info) section */ 1000}; 1001 1002/* a 64-bit module table entry */ 1003struct dylib_module_64 { 1004 uint32_t module_name; /* the module name (index into string table) */ 1005 1006 uint32_t iextdefsym; /* index into externally defined symbols */ 1007 uint32_t nextdefsym; /* number of externally defined symbols */ 1008 uint32_t irefsym; /* index into reference symbol table */ 1009 uint32_t nrefsym; /* number of reference symbol table entries */ 1010 uint32_t ilocalsym; /* index into symbols for local symbols */ 1011 uint32_t nlocalsym; /* number of local symbols */ 1012 1013 uint32_t iextrel; /* index into external relocation entries */ 1014 uint32_t nextrel; /* number of external relocation entries */ 1015 1016 uint32_t iinit_iterm; /* low 16 bits are the index into the init 1017 section, high 16 bits are the index into 1018 the term section */ 1019 uint32_t ninit_nterm; /* low 16 bits are the number of init section 1020 entries, high 16 bits are the number of 1021 term section entries */ 1022 1023 uint32_t /* for this module size of */ 1024 objc_module_info_size; /* the (__OBJC,__module_info) section */ 1025 uint64_t /* for this module address of the start of */ 1026 objc_module_info_addr; /* the (__OBJC,__module_info) section */ 1027}; 1028 1029/* 1030 * The entries in the reference symbol table are used when loading the module 1031 * (both by the static and dynamic link editors) and if the module is unloaded 1032 * or replaced. Therefore all external symbols (defined and undefined) are 1033 * listed in the module's reference table. The flags describe the type of 1034 * reference that is being made. The constants for the flags are defined in 1035 * <mach-o/nlist.h> as they are also used for symbol table entries. 1036 */ 1037struct dylib_reference { 1038 uint32_t isym:24, /* index into the symbol table */ 1039 flags:8; /* flags to indicate the type of reference */ 1040}; 1041 1042/* 1043 * The twolevel_hints_command contains the offset and number of hints in the 1044 * two-level namespace lookup hints table. 1045 */ 1046struct twolevel_hints_command { 1047 uint32_t cmd; /* LC_TWOLEVEL_HINTS */ 1048 uint32_t cmdsize; /* sizeof(struct twolevel_hints_command) */ 1049 uint32_t offset; /* offset to the hint table */ 1050 uint32_t nhints; /* number of hints in the hint table */ 1051}; 1052 1053/* 1054 * The entries in the two-level namespace lookup hints table are twolevel_hint 1055 * structs. These provide hints to the dynamic link editor where to start 1056 * looking for an undefined symbol in a two-level namespace image. The 1057 * isub_image field is an index into the sub-images (sub-frameworks and 1058 * sub-umbrellas list) that made up the two-level image that the undefined 1059 * symbol was found in when it was built by the static link editor. If 1060 * isub-image is 0 the the symbol is expected to be defined in library and not 1061 * in the sub-images. If isub-image is non-zero it is an index into the array 1062 * of sub-images for the umbrella with the first index in the sub-images being 1063 * 1. The array of sub-images is the ordered list of sub-images of the umbrella 1064 * that would be searched for a symbol that has the umbrella recorded as its 1065 * primary library. The table of contents index is an index into the 1066 * library's table of contents. This is used as the starting point of the 1067 * binary search or a directed linear search. 1068 */ 1069struct twolevel_hint { 1070 uint32_t 1071 isub_image:8, /* index into the sub images */ 1072 itoc:24; /* index into the table of contents */ 1073}; 1074 1075/* 1076 * The prebind_cksum_command contains the value of the original check sum for 1077 * prebound files or zero. When a prebound file is first created or modified 1078 * for other than updating its prebinding information the value of the check sum 1079 * is set to zero. When the file has it prebinding re-done and if the value of 1080 * the check sum is zero the original check sum is calculated and stored in 1081 * cksum field of this load command in the output file. If when the prebinding 1082 * is re-done and the cksum field is non-zero it is left unchanged from the 1083 * input file. 1084 */ 1085struct prebind_cksum_command { 1086 uint32_t cmd; /* LC_PREBIND_CKSUM */ 1087 uint32_t cmdsize; /* sizeof(struct prebind_cksum_command) */ 1088 uint32_t cksum; /* the check sum or zero */ 1089}; 1090 1091/* 1092 * The uuid load command contains a single 128-bit unique random number that 1093 * identifies an object produced by the static link editor. 1094 */ 1095struct uuid_command { 1096 uint32_t cmd; /* LC_UUID */ 1097 uint32_t cmdsize; /* sizeof(struct uuid_command) */ 1098 uint8_t uuid[16]; /* the 128-bit uuid */ 1099}; 1100 1101/* 1102 * The rpath_command contains a path which at runtime should be added to 1103 * the current run path used to find @rpath prefixed dylibs. 1104 */ 1105struct rpath_command { 1106 uint32_t cmd; /* LC_RPATH */ 1107 uint32_t cmdsize; /* includes string */ 1108 union lc_str path; /* path to add to run path */ 1109}; 1110 1111/* 1112 * The linkedit_data_command contains the offsets and sizes of a blob 1113 * of data in the __LINKEDIT segment. 1114 */ 1115struct linkedit_data_command { 1116 uint32_t cmd; /* LC_CODE_SIGNATURE or LC_SEGMENT_SPLIT_INFO */ 1117 uint32_t cmdsize; /* sizeof(struct linkedit_data_command) */ 1118 uint32_t dataoff; /* file offset of data in __LINKEDIT segment */ 1119 uint32_t datasize; /* file size of data in __LINKEDIT segment */ 1120}; 1121 1122/* 1123 * The encryption_info_command contains the file offset and size of an 1124 * of an encrypted segment. 1125 */ 1126struct encryption_info_command { 1127 uint32_t cmd; /* LC_ENCRYPTION_INFO */ 1128 uint32_t cmdsize; /* sizeof(struct encryption_info_command) */ 1129 uint32_t cryptoff; /* file offset of encrypted range */ 1130 uint32_t cryptsize; /* file size of encrypted range */ 1131 uint32_t cryptid; /* which enryption system, 1132 0 means not-encrypted yet */ 1133}; 1134 1135/* 1136 * The symseg_command contains the offset and size of the GNU style 1137 * symbol table information as described in the header file <symseg.h>. 1138 * The symbol roots of the symbol segments must also be aligned properly 1139 * in the file. So the requirement of keeping the offsets aligned to a 1140 * multiple of a 4 bytes translates to the length field of the symbol 1141 * roots also being a multiple of a long. Also the padding must again be 1142 * zeroed. (THIS IS OBSOLETE and no longer supported). 1143 */ 1144struct symseg_command { 1145 uint32_t cmd; /* LC_SYMSEG */ 1146 uint32_t cmdsize; /* sizeof(struct symseg_command) */ 1147 uint32_t offset; /* symbol segment offset */ 1148 uint32_t size; /* symbol segment size in bytes */ 1149}; 1150 1151/* 1152 * The ident_command contains a free format string table following the 1153 * ident_command structure. The strings are null terminated and the size of 1154 * the command is padded out with zero bytes to a multiple of 4 bytes/ 1155 * (THIS IS OBSOLETE and no longer supported). 1156 */ 1157struct ident_command { 1158 uint32_t cmd; /* LC_IDENT */ 1159 uint32_t cmdsize; /* strings that follow this command */ 1160}; 1161 1162/* 1163 * The fvmfile_command contains a reference to a file to be loaded at the 1164 * specified virtual address. (Presently, this command is reserved for 1165 * internal use. The kernel ignores this command when loading a program into 1166 * memory). 1167 */ 1168struct fvmfile_command { 1169 uint32_t cmd; /* LC_FVMFILE */ 1170 uint32_t cmdsize; /* includes pathname string */ 1171 union lc_str name; /* files pathname */ 1172 uint32_t header_addr; /* files virtual address */ 1173}; 1174 1175#endif /* _MACHO_LOADER_H_ */ 1176