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