1 //! Mach-O definitions.
2 //!
3 //! These definitions are independent of read/write support, although we do implement
4 //! some traits useful for those.
5 //!
6 //! This module is based heavily on macOS header files.
7
8 #![allow(missing_docs)]
9
10 use crate::endian::{BigEndian, Endian, U64Bytes, U16, U32, U64};
11 use crate::pod::Pod;
12
13 // Definitions from "/usr/include/mach-o/machine.h".
14
15 /*
16 * Capability bits used in the definition of cpu_type.
17 */
18
19 /// mask for architecture bits
20 pub const CPU_ARCH_MASK: u32 = 0xff00_0000;
21 /// 64 bit ABI
22 pub const CPU_ARCH_ABI64: u32 = 0x0100_0000;
23 /// ABI for 64-bit hardware with 32-bit types; LP32
24 pub const CPU_ARCH_ABI64_32: u32 = 0x0200_0000;
25
26 /*
27 * Machine types known by all.
28 */
29
30 pub const CPU_TYPE_ANY: u32 = !0;
31
32 pub const CPU_TYPE_VAX: u32 = 1;
33 pub const CPU_TYPE_MC680X0: u32 = 6;
34 pub const CPU_TYPE_X86: u32 = 7;
35 pub const CPU_TYPE_X86_64: u32 = CPU_TYPE_X86 | CPU_ARCH_ABI64;
36 pub const CPU_TYPE_MIPS: u32 = 8;
37 pub const CPU_TYPE_MC98000: u32 = 10;
38 pub const CPU_TYPE_HPPA: u32 = 11;
39 pub const CPU_TYPE_ARM: u32 = 12;
40 pub const CPU_TYPE_ARM64: u32 = CPU_TYPE_ARM | CPU_ARCH_ABI64;
41 pub const CPU_TYPE_ARM64_32: u32 = CPU_TYPE_ARM | CPU_ARCH_ABI64_32;
42 pub const CPU_TYPE_MC88000: u32 = 13;
43 pub const CPU_TYPE_SPARC: u32 = 14;
44 pub const CPU_TYPE_I860: u32 = 15;
45 pub const CPU_TYPE_ALPHA: u32 = 16;
46 pub const CPU_TYPE_POWERPC: u32 = 18;
47 pub const CPU_TYPE_POWERPC64: u32 = CPU_TYPE_POWERPC | CPU_ARCH_ABI64;
48
49 /*
50 * Capability bits used in the definition of cpu_subtype.
51 */
52 /// mask for feature flags
53 pub const CPU_SUBTYPE_MASK: u32 = 0xff00_0000;
54 /// 64 bit libraries
55 pub const CPU_SUBTYPE_LIB64: u32 = 0x8000_0000;
56
57 /*
58 * Object files that are hand-crafted to run on any
59 * implementation of an architecture are tagged with
60 * CPU_SUBTYPE_MULTIPLE. This functions essentially the same as
61 * the "ALL" subtype of an architecture except that it allows us
62 * to easily find object files that may need to be modified
63 * whenever a new implementation of an architecture comes out.
64 *
65 * It is the responsibility of the implementor to make sure the
66 * software handles unsupported implementations elegantly.
67 */
68 pub const CPU_SUBTYPE_MULTIPLE: u32 = !0;
69 pub const CPU_SUBTYPE_LITTLE_ENDIAN: u32 = 0;
70 pub const CPU_SUBTYPE_BIG_ENDIAN: u32 = 1;
71
72 /*
73 * VAX subtypes (these do *not* necessary conform to the actual cpu
74 * ID assigned by DEC available via the SID register).
75 */
76
77 pub const CPU_SUBTYPE_VAX_ALL: u32 = 0;
78 pub const CPU_SUBTYPE_VAX780: u32 = 1;
79 pub const CPU_SUBTYPE_VAX785: u32 = 2;
80 pub const CPU_SUBTYPE_VAX750: u32 = 3;
81 pub const CPU_SUBTYPE_VAX730: u32 = 4;
82 pub const CPU_SUBTYPE_UVAXI: u32 = 5;
83 pub const CPU_SUBTYPE_UVAXII: u32 = 6;
84 pub const CPU_SUBTYPE_VAX8200: u32 = 7;
85 pub const CPU_SUBTYPE_VAX8500: u32 = 8;
86 pub const CPU_SUBTYPE_VAX8600: u32 = 9;
87 pub const CPU_SUBTYPE_VAX8650: u32 = 10;
88 pub const CPU_SUBTYPE_VAX8800: u32 = 11;
89 pub const CPU_SUBTYPE_UVAXIII: u32 = 12;
90
91 /*
92 * 680x0 subtypes
93 *
94 * The subtype definitions here are unusual for historical reasons.
95 * NeXT used to consider 68030 code as generic 68000 code. For
96 * backwards compatability:
97 *
98 * CPU_SUBTYPE_MC68030 symbol has been preserved for source code
99 * compatability.
100 *
101 * CPU_SUBTYPE_MC680x0_ALL has been defined to be the same
102 * subtype as CPU_SUBTYPE_MC68030 for binary comatability.
103 *
104 * CPU_SUBTYPE_MC68030_ONLY has been added to allow new object
105 * files to be tagged as containing 68030-specific instructions.
106 */
107
108 pub const CPU_SUBTYPE_MC680X0_ALL: u32 = 1;
109 // compat
110 pub const CPU_SUBTYPE_MC68030: u32 = 1;
111 pub const CPU_SUBTYPE_MC68040: u32 = 2;
112 pub const CPU_SUBTYPE_MC68030_ONLY: u32 = 3;
113
114 /*
115 * I386 subtypes
116 */
117
118 #[inline]
cpu_subtype_intel(f: u32, m: u32) -> u32119 pub const fn cpu_subtype_intel(f: u32, m: u32) -> u32 {
120 f + (m << 4)
121 }
122
123 pub const CPU_SUBTYPE_I386_ALL: u32 = cpu_subtype_intel(3, 0);
124 pub const CPU_SUBTYPE_386: u32 = cpu_subtype_intel(3, 0);
125 pub const CPU_SUBTYPE_486: u32 = cpu_subtype_intel(4, 0);
126 pub const CPU_SUBTYPE_486SX: u32 = cpu_subtype_intel(4, 8);
127 pub const CPU_SUBTYPE_586: u32 = cpu_subtype_intel(5, 0);
128 pub const CPU_SUBTYPE_PENT: u32 = cpu_subtype_intel(5, 0);
129 pub const CPU_SUBTYPE_PENTPRO: u32 = cpu_subtype_intel(6, 1);
130 pub const CPU_SUBTYPE_PENTII_M3: u32 = cpu_subtype_intel(6, 3);
131 pub const CPU_SUBTYPE_PENTII_M5: u32 = cpu_subtype_intel(6, 5);
132 pub const CPU_SUBTYPE_CELERON: u32 = cpu_subtype_intel(7, 6);
133 pub const CPU_SUBTYPE_CELERON_MOBILE: u32 = cpu_subtype_intel(7, 7);
134 pub const CPU_SUBTYPE_PENTIUM_3: u32 = cpu_subtype_intel(8, 0);
135 pub const CPU_SUBTYPE_PENTIUM_3_M: u32 = cpu_subtype_intel(8, 1);
136 pub const CPU_SUBTYPE_PENTIUM_3_XEON: u32 = cpu_subtype_intel(8, 2);
137 pub const CPU_SUBTYPE_PENTIUM_M: u32 = cpu_subtype_intel(9, 0);
138 pub const CPU_SUBTYPE_PENTIUM_4: u32 = cpu_subtype_intel(10, 0);
139 pub const CPU_SUBTYPE_PENTIUM_4_M: u32 = cpu_subtype_intel(10, 1);
140 pub const CPU_SUBTYPE_ITANIUM: u32 = cpu_subtype_intel(11, 0);
141 pub const CPU_SUBTYPE_ITANIUM_2: u32 = cpu_subtype_intel(11, 1);
142 pub const CPU_SUBTYPE_XEON: u32 = cpu_subtype_intel(12, 0);
143 pub const CPU_SUBTYPE_XEON_MP: u32 = cpu_subtype_intel(12, 1);
144
145 #[inline]
cpu_subtype_intel_family(x: u32) -> u32146 pub const fn cpu_subtype_intel_family(x: u32) -> u32 {
147 x & 15
148 }
149 pub const CPU_SUBTYPE_INTEL_FAMILY_MAX: u32 = 15;
150
151 #[inline]
cpu_subtype_intel_model(x: u32) -> u32152 pub const fn cpu_subtype_intel_model(x: u32) -> u32 {
153 x >> 4
154 }
155 pub const CPU_SUBTYPE_INTEL_MODEL_ALL: u32 = 0;
156
157 /*
158 * X86 subtypes.
159 */
160
161 pub const CPU_SUBTYPE_X86_ALL: u32 = 3;
162 pub const CPU_SUBTYPE_X86_64_ALL: u32 = 3;
163 pub const CPU_SUBTYPE_X86_ARCH1: u32 = 4;
164 /// Haswell feature subset
165 pub const CPU_SUBTYPE_X86_64_H: u32 = 8;
166
167 /*
168 * Mips subtypes.
169 */
170
171 pub const CPU_SUBTYPE_MIPS_ALL: u32 = 0;
172 pub const CPU_SUBTYPE_MIPS_R2300: u32 = 1;
173 pub const CPU_SUBTYPE_MIPS_R2600: u32 = 2;
174 pub const CPU_SUBTYPE_MIPS_R2800: u32 = 3;
175 /// pmax
176 pub const CPU_SUBTYPE_MIPS_R2000A: u32 = 4;
177 pub const CPU_SUBTYPE_MIPS_R2000: u32 = 5;
178 /// 3max
179 pub const CPU_SUBTYPE_MIPS_R3000A: u32 = 6;
180 pub const CPU_SUBTYPE_MIPS_R3000: u32 = 7;
181
182 /*
183 * MC98000 (PowerPC) subtypes
184 */
185 pub const CPU_SUBTYPE_MC98000_ALL: u32 = 0;
186 pub const CPU_SUBTYPE_MC98601: u32 = 1;
187
188 /*
189 * HPPA subtypes for Hewlett-Packard HP-PA family of
190 * risc processors. Port by NeXT to 700 series.
191 */
192
193 pub const CPU_SUBTYPE_HPPA_ALL: u32 = 0;
194 pub const CPU_SUBTYPE_HPPA_7100LC: u32 = 1;
195
196 /*
197 * MC88000 subtypes.
198 */
199 pub const CPU_SUBTYPE_MC88000_ALL: u32 = 0;
200 pub const CPU_SUBTYPE_MC88100: u32 = 1;
201 pub const CPU_SUBTYPE_MC88110: u32 = 2;
202
203 /*
204 * SPARC subtypes
205 */
206 pub const CPU_SUBTYPE_SPARC_ALL: u32 = 0;
207
208 /*
209 * I860 subtypes
210 */
211 pub const CPU_SUBTYPE_I860_ALL: u32 = 0;
212 pub const CPU_SUBTYPE_I860_860: u32 = 1;
213
214 /*
215 * PowerPC subtypes
216 */
217 pub const CPU_SUBTYPE_POWERPC_ALL: u32 = 0;
218 pub const CPU_SUBTYPE_POWERPC_601: u32 = 1;
219 pub const CPU_SUBTYPE_POWERPC_602: u32 = 2;
220 pub const CPU_SUBTYPE_POWERPC_603: u32 = 3;
221 pub const CPU_SUBTYPE_POWERPC_603E: u32 = 4;
222 pub const CPU_SUBTYPE_POWERPC_603EV: u32 = 5;
223 pub const CPU_SUBTYPE_POWERPC_604: u32 = 6;
224 pub const CPU_SUBTYPE_POWERPC_604E: u32 = 7;
225 pub const CPU_SUBTYPE_POWERPC_620: u32 = 8;
226 pub const CPU_SUBTYPE_POWERPC_750: u32 = 9;
227 pub const CPU_SUBTYPE_POWERPC_7400: u32 = 10;
228 pub const CPU_SUBTYPE_POWERPC_7450: u32 = 11;
229 pub const CPU_SUBTYPE_POWERPC_970: u32 = 100;
230
231 /*
232 * ARM subtypes
233 */
234 pub const CPU_SUBTYPE_ARM_ALL: u32 = 0;
235 pub const CPU_SUBTYPE_ARM_V4T: u32 = 5;
236 pub const CPU_SUBTYPE_ARM_V6: u32 = 6;
237 pub const CPU_SUBTYPE_ARM_V5TEJ: u32 = 7;
238 pub const CPU_SUBTYPE_ARM_XSCALE: u32 = 8;
239 pub const CPU_SUBTYPE_ARM_V7: u32 = 9;
240 /// Cortex A9
241 pub const CPU_SUBTYPE_ARM_V7F: u32 = 10;
242 /// Swift
243 pub const CPU_SUBTYPE_ARM_V7S: u32 = 11;
244 pub const CPU_SUBTYPE_ARM_V7K: u32 = 12;
245 /// Not meant to be run under xnu
246 pub const CPU_SUBTYPE_ARM_V6M: u32 = 14;
247 /// Not meant to be run under xnu
248 pub const CPU_SUBTYPE_ARM_V7M: u32 = 15;
249 /// Not meant to be run under xnu
250 pub const CPU_SUBTYPE_ARM_V7EM: u32 = 16;
251
252 pub const CPU_SUBTYPE_ARM_V8: u32 = 13;
253
254 /*
255 * ARM64 subtypes
256 */
257 pub const CPU_SUBTYPE_ARM64_ALL: u32 = 0;
258 pub const CPU_SUBTYPE_ARM64_V8: u32 = 1;
259 pub const CPU_SUBTYPE_ARM64E: u32 = 2;
260
261 /*
262 * ARM64_32 subtypes
263 */
264 pub const CPU_SUBTYPE_ARM64_32_ALL: u32 = 0;
265 pub const CPU_SUBTYPE_ARM64_32_V8: u32 = 1;
266
267 // Definitions from "/usr/include/mach/vm_prot.h".
268
269 /// read permission
270 pub const VM_PROT_READ: u32 = 0x01;
271 /// write permission
272 pub const VM_PROT_WRITE: u32 = 0x02;
273 /// execute permission
274 pub const VM_PROT_EXECUTE: u32 = 0x04;
275
276 // Definitions from "/usr/include/mach-o/loader.h".
277
278 /*
279 * This header file describes the structures of the file format for "fat"
280 * architecture specific file (wrapper design). At the begining of the file
281 * there is one `FatHeader` structure followed by a number of `FatArch*`
282 * structures. For each architecture in the file, specified by a pair of
283 * cputype and cpusubtype, the `FatHeader` describes the file offset, file
284 * size and alignment in the file of the architecture specific member.
285 * The padded bytes in the file to place each member on it's specific alignment
286 * are defined to be read as zeros and can be left as "holes" if the file system
287 * can support them as long as they read as zeros.
288 *
289 * All structures defined here are always written and read to/from disk
290 * in big-endian order.
291 */
292
293 pub const FAT_MAGIC: u32 = 0xcafe_babe;
294 /// NXSwapLong(FAT_MAGIC)
295 pub const FAT_CIGAM: u32 = 0xbeba_feca;
296
297 #[derive(Debug, Clone, Copy)]
298 #[repr(C)]
299 pub struct FatHeader {
300 /// FAT_MAGIC or FAT_MAGIC_64
301 pub magic: U32<BigEndian>,
302 /// number of structs that follow
303 pub nfat_arch: U32<BigEndian>,
304 }
305
306 #[derive(Debug, Clone, Copy)]
307 #[repr(C)]
308 pub struct FatArch32 {
309 /// cpu specifier (int)
310 pub cputype: U32<BigEndian>,
311 /// machine specifier (int)
312 pub cpusubtype: U32<BigEndian>,
313 /// file offset to this object file
314 pub offset: U32<BigEndian>,
315 /// size of this object file
316 pub size: U32<BigEndian>,
317 /// alignment as a power of 2
318 pub align: U32<BigEndian>,
319 }
320
321 /*
322 * The support for the 64-bit fat file format described here is a work in
323 * progress and not yet fully supported in all the Apple Developer Tools.
324 *
325 * When a slice is greater than 4mb or an offset to a slice is greater than 4mb
326 * then the 64-bit fat file format is used.
327 */
328 pub const FAT_MAGIC_64: u32 = 0xcafe_babf;
329 /// NXSwapLong(FAT_MAGIC_64)
330 pub const FAT_CIGAM_64: u32 = 0xbfba_feca;
331
332 #[derive(Debug, Clone, Copy)]
333 #[repr(C)]
334 pub struct FatArch64 {
335 /// cpu specifier (int)
336 pub cputype: U32<BigEndian>,
337 /// machine specifier (int)
338 pub cpusubtype: U32<BigEndian>,
339 /// file offset to this object file
340 pub offset: U64<BigEndian>,
341 /// size of this object file
342 pub size: U64<BigEndian>,
343 /// alignment as a power of 2
344 pub align: U32<BigEndian>,
345 /// reserved
346 pub reserved: U32<BigEndian>,
347 }
348
349 // Definitions from "/usr/include/mach-o/loader.h".
350
351 /// The 32-bit mach header.
352 ///
353 /// Appears at the very beginning of the object file for 32-bit architectures.
354 #[derive(Debug, Clone, Copy)]
355 #[repr(C)]
356 pub struct MachHeader32<E: Endian> {
357 /// mach magic number identifier
358 pub magic: U32<BigEndian>,
359 /// cpu specifier
360 pub cputype: U32<E>,
361 /// machine specifier
362 pub cpusubtype: U32<E>,
363 /// type of file
364 pub filetype: U32<E>,
365 /// number of load commands
366 pub ncmds: U32<E>,
367 /// the size of all the load commands
368 pub sizeofcmds: U32<E>,
369 /// flags
370 pub flags: U32<E>,
371 }
372
373 // Values for `MachHeader32::magic`.
374 /// the mach magic number
375 pub const MH_MAGIC: u32 = 0xfeed_face;
376 /// NXSwapInt(MH_MAGIC)
377 pub const MH_CIGAM: u32 = 0xcefa_edfe;
378
379 /// The 64-bit mach header.
380 ///
381 /// Appears at the very beginning of object files for 64-bit architectures.
382 #[derive(Debug, Clone, Copy)]
383 #[repr(C)]
384 pub struct MachHeader64<E: Endian> {
385 /// mach magic number identifier
386 pub magic: U32<BigEndian>,
387 /// cpu specifier
388 pub cputype: U32<E>,
389 /// machine specifier
390 pub cpusubtype: U32<E>,
391 /// type of file
392 pub filetype: U32<E>,
393 /// number of load commands
394 pub ncmds: U32<E>,
395 /// the size of all the load commands
396 pub sizeofcmds: U32<E>,
397 /// flags
398 pub flags: U32<E>,
399 /// reserved
400 pub reserved: U32<E>,
401 }
402
403 // Values for `MachHeader64::magic`.
404 /// the 64-bit mach magic number
405 pub const MH_MAGIC_64: u32 = 0xfeed_facf;
406 /// NXSwapInt(MH_MAGIC_64)
407 pub const MH_CIGAM_64: u32 = 0xcffa_edfe;
408
409 /*
410 * The layout of the file depends on the filetype. For all but the MH_OBJECT
411 * file type the segments are padded out and aligned on a segment alignment
412 * boundary for efficient demand pageing. The MH_EXECUTE, MH_FVMLIB, MH_DYLIB,
413 * MH_DYLINKER and MH_BUNDLE file types also have the headers included as part
414 * of their first segment.
415 *
416 * The file type MH_OBJECT is a compact format intended as output of the
417 * assembler and input (and possibly output) of the link editor (the .o
418 * format). All sections are in one unnamed segment with no segment padding.
419 * This format is used as an executable format when the file is so small the
420 * segment padding greatly increases its size.
421 *
422 * The file type MH_PRELOAD is an executable format intended for things that
423 * are not executed under the kernel (proms, stand alones, kernels, etc). The
424 * format can be executed under the kernel but may demand paged it and not
425 * preload it before execution.
426 *
427 * A core file is in MH_CORE format and can be any in an arbritray legal
428 * Mach-O file.
429 */
430
431 // Values for `MachHeader*::filetype`.
432 /// relocatable object file
433 pub const MH_OBJECT: u32 = 0x1;
434 /// demand paged executable file
435 pub const MH_EXECUTE: u32 = 0x2;
436 /// fixed VM shared library file
437 pub const MH_FVMLIB: u32 = 0x3;
438 /// core file
439 pub const MH_CORE: u32 = 0x4;
440 /// preloaded executable file
441 pub const MH_PRELOAD: u32 = 0x5;
442 /// dynamically bound shared library
443 pub const MH_DYLIB: u32 = 0x6;
444 /// dynamic link editor
445 pub const MH_DYLINKER: u32 = 0x7;
446 /// dynamically bound bundle file
447 pub const MH_BUNDLE: u32 = 0x8;
448 /// shared library stub for static linking only, no section contents
449 pub const MH_DYLIB_STUB: u32 = 0x9;
450 /// companion file with only debug sections
451 pub const MH_DSYM: u32 = 0xa;
452 /// x86_64 kexts
453 pub const MH_KEXT_BUNDLE: u32 = 0xb;
454
455 // Values for `MachHeader*::flags`.
456 /// the object file has no undefined references
457 pub const MH_NOUNDEFS: u32 = 0x1;
458 /// the object file is the output of an incremental link against a base file and can't be link edited again
459 pub const MH_INCRLINK: u32 = 0x2;
460 /// the object file is input for the dynamic linker and can't be staticly link edited again
461 pub const MH_DYLDLINK: u32 = 0x4;
462 /// the object file's undefined references are bound by the dynamic linker when loaded.
463 pub const MH_BINDATLOAD: u32 = 0x8;
464 /// the file has its dynamic undefined references prebound.
465 pub const MH_PREBOUND: u32 = 0x10;
466 /// the file has its read-only and read-write segments split
467 pub const MH_SPLIT_SEGS: u32 = 0x20;
468 /// the shared library init routine is to be run lazily via catching memory faults to its writeable segments (obsolete)
469 pub const MH_LAZY_INIT: u32 = 0x40;
470 /// the image is using two-level name space bindings
471 pub const MH_TWOLEVEL: u32 = 0x80;
472 /// the executable is forcing all images to use flat name space bindings
473 pub const MH_FORCE_FLAT: u32 = 0x100;
474 /// this umbrella guarantees no multiple defintions of symbols in its sub-images so the two-level namespace hints can always be used.
475 pub const MH_NOMULTIDEFS: u32 = 0x200;
476 /// do not have dyld notify the prebinding agent about this executable
477 pub const MH_NOFIXPREBINDING: u32 = 0x400;
478 /// the binary is not prebound but can have its prebinding redone. only used when MH_PREBOUND is not set.
479 pub const MH_PREBINDABLE: u32 = 0x800;
480 /// indicates that this binary binds to all two-level namespace modules of its dependent libraries. only used when MH_PREBINDABLE and MH_TWOLEVEL are both set.
481 pub const MH_ALLMODSBOUND: u32 = 0x1000;
482 /// safe to divide up the sections into sub-sections via symbols for dead code stripping
483 pub const MH_SUBSECTIONS_VIA_SYMBOLS: u32 = 0x2000;
484 /// the binary has been canonicalized via the unprebind operation
485 pub const MH_CANONICAL: u32 = 0x4000;
486 /// the final linked image contains external weak symbols
487 pub const MH_WEAK_DEFINES: u32 = 0x8000;
488 /// the final linked image uses weak symbols
489 pub const MH_BINDS_TO_WEAK: u32 = 0x10000;
490
491 /// When this bit is set, all stacks in the task will be given stack execution privilege. Only used in MH_EXECUTE filetypes.
492 pub const MH_ALLOW_STACK_EXECUTION: u32 = 0x20000;
493 /// When this bit is set, the binary declares it is safe for use in processes with uid zero
494 pub const MH_ROOT_SAFE: u32 = 0x40000;
495
496 /// When this bit is set, the binary declares it is safe for use in processes when issetugid() is true
497 pub const MH_SETUID_SAFE: u32 = 0x80000;
498
499 /// When this bit is set on a dylib, the static linker does not need to examine dependent dylibs to see if any are re-exported
500 pub const MH_NO_REEXPORTED_DYLIBS: u32 = 0x10_0000;
501 /// When this bit is set, the OS will load the main executable at a random address. Only used in MH_EXECUTE filetypes.
502 pub const MH_PIE: u32 = 0x20_0000;
503 /// Only for use on dylibs. When linking against a dylib that has this bit set, the static linker will automatically not create a LC_LOAD_DYLIB load command to the dylib if no symbols are being referenced from the dylib.
504 pub const MH_DEAD_STRIPPABLE_DYLIB: u32 = 0x40_0000;
505 /// Contains a section of type S_THREAD_LOCAL_VARIABLES
506 pub const MH_HAS_TLV_DESCRIPTORS: u32 = 0x80_0000;
507
508 /// When this bit is set, the OS will run the main executable with a non-executable heap even on platforms (e.g. i386) that don't require it. Only used in MH_EXECUTE filetypes.
509 pub const MH_NO_HEAP_EXECUTION: u32 = 0x100_0000;
510
511 /// The code was linked for use in an application extension.
512 pub const MH_APP_EXTENSION_SAFE: u32 = 0x0200_0000;
513
514 pub const MH_NLIST_OUTOFSYNC_WITH_DYLDINFO: u32 = 0x0400_0000;
515 /// The external symbols listed in the nlist symbol table do not include all the symbols listed in the dyld info.
516
517 pub const MH_SIM_SUPPORT: u32 = 0x0800_0000;
518
519 /// Common fields at the start of every load command.
520 ///
521 /// The load commands directly follow the mach_header. The total size of all
522 /// of the commands is given by the sizeofcmds field in the mach_header. All
523 /// load commands must have as their first two fields `cmd` and `cmdsize`. The `cmd`
524 /// field is filled in with a constant for that command type. Each command type
525 /// has a structure specifically for it. The `cmdsize` field is the size in bytes
526 /// of the particular load command structure plus anything that follows it that
527 /// is a part of the load command (i.e. section structures, strings, etc.). To
528 /// advance to the next load command the `cmdsize` can be added to the offset or
529 /// pointer of the current load command. The `cmdsize` for 32-bit architectures
530 /// MUST be a multiple of 4 bytes and for 64-bit architectures MUST be a multiple
531 /// of 8 bytes (these are forever the maximum alignment of any load commands).
532 /// The padded bytes must be zero. All tables in the object file must also
533 /// follow these rules so the file can be memory mapped. Otherwise the pointers
534 /// to these tables will not work well or at all on some machines. With all
535 /// padding zeroed like objects will compare byte for byte.
536 #[derive(Debug, Clone, Copy)]
537 #[repr(C)]
538 pub struct LoadCommand<E: Endian> {
539 /// Type of load command.
540 ///
541 /// One of the `LC_*` constants.
542 pub cmd: U32<E>,
543 /// Total size of command in bytes.
544 pub cmdsize: U32<E>,
545 }
546
547 /*
548 * After MacOS X 10.1 when a new load command is added that is required to be
549 * understood by the dynamic linker for the image to execute properly the
550 * LC_REQ_DYLD bit will be or'ed into the load command constant. If the dynamic
551 * linker sees such a load command it it does not understand will issue a
552 * "unknown load command required for execution" error and refuse to use the
553 * image. Other load commands without this bit that are not understood will
554 * simply be ignored.
555 */
556 pub const LC_REQ_DYLD: u32 = 0x8000_0000;
557
558 /* Constants for the cmd field of all load commands, the type */
559 /// segment of this file to be mapped
560 pub const LC_SEGMENT: u32 = 0x1;
561 /// link-edit stab symbol table info
562 pub const LC_SYMTAB: u32 = 0x2;
563 /// link-edit gdb symbol table info (obsolete)
564 pub const LC_SYMSEG: u32 = 0x3;
565 /// thread
566 pub const LC_THREAD: u32 = 0x4;
567 /// unix thread (includes a stack)
568 pub const LC_UNIXTHREAD: u32 = 0x5;
569 /// load a specified fixed VM shared library
570 pub const LC_LOADFVMLIB: u32 = 0x6;
571 /// fixed VM shared library identification
572 pub const LC_IDFVMLIB: u32 = 0x7;
573 /// object identification info (obsolete)
574 pub const LC_IDENT: u32 = 0x8;
575 /// fixed VM file inclusion (internal use)
576 pub const LC_FVMFILE: u32 = 0x9;
577 /// prepage command (internal use)
578 pub const LC_PREPAGE: u32 = 0xa;
579 /// dynamic link-edit symbol table info
580 pub const LC_DYSYMTAB: u32 = 0xb;
581 /// load a dynamically linked shared library
582 pub const LC_LOAD_DYLIB: u32 = 0xc;
583 /// dynamically linked shared lib ident
584 pub const LC_ID_DYLIB: u32 = 0xd;
585 /// load a dynamic linker
586 pub const LC_LOAD_DYLINKER: u32 = 0xe;
587 /// dynamic linker identification
588 pub const LC_ID_DYLINKER: u32 = 0xf;
589 /// modules prebound for a dynamically linked shared library
590 pub const LC_PREBOUND_DYLIB: u32 = 0x10;
591 /// image routines
592 pub const LC_ROUTINES: u32 = 0x11;
593 /// sub framework
594 pub const LC_SUB_FRAMEWORK: u32 = 0x12;
595 /// sub umbrella
596 pub const LC_SUB_UMBRELLA: u32 = 0x13;
597 /// sub client
598 pub const LC_SUB_CLIENT: u32 = 0x14;
599 /// sub library
600 pub const LC_SUB_LIBRARY: u32 = 0x15;
601 /// two-level namespace lookup hints
602 pub const LC_TWOLEVEL_HINTS: u32 = 0x16;
603 /// prebind checksum
604 pub const LC_PREBIND_CKSUM: u32 = 0x17;
605 /// load a dynamically linked shared library that is allowed to be missing
606 /// (all symbols are weak imported).
607 pub const LC_LOAD_WEAK_DYLIB: u32 = 0x18 | LC_REQ_DYLD;
608 /// 64-bit segment of this file to be mapped
609 pub const LC_SEGMENT_64: u32 = 0x19;
610 /// 64-bit image routines
611 pub const LC_ROUTINES_64: u32 = 0x1a;
612 /// the uuid
613 pub const LC_UUID: u32 = 0x1b;
614 /// runpath additions
615 pub const LC_RPATH: u32 = 0x1c | LC_REQ_DYLD;
616 /// local of code signature
617 pub const LC_CODE_SIGNATURE: u32 = 0x1d;
618 /// local of info to split segments
619 pub const LC_SEGMENT_SPLIT_INFO: u32 = 0x1e;
620 /// load and re-export dylib
621 pub const LC_REEXPORT_DYLIB: u32 = 0x1f | LC_REQ_DYLD;
622 /// delay load of dylib until first use
623 pub const LC_LAZY_LOAD_DYLIB: u32 = 0x20;
624 /// encrypted segment information
625 pub const LC_ENCRYPTION_INFO: u32 = 0x21;
626 /// compressed dyld information
627 pub const LC_DYLD_INFO: u32 = 0x22;
628 /// compressed dyld information only
629 pub const LC_DYLD_INFO_ONLY: u32 = 0x22 | LC_REQ_DYLD;
630 /// load upward dylib
631 pub const LC_LOAD_UPWARD_DYLIB: u32 = 0x23 | LC_REQ_DYLD;
632 /// build for MacOSX min OS version
633 pub const LC_VERSION_MIN_MACOSX: u32 = 0x24;
634 /// build for iPhoneOS min OS version
635 pub const LC_VERSION_MIN_IPHONEOS: u32 = 0x25;
636 /// compressed table of function start addresses
637 pub const LC_FUNCTION_STARTS: u32 = 0x26;
638 /// string for dyld to treat like environment variable
639 pub const LC_DYLD_ENVIRONMENT: u32 = 0x27;
640 /// replacement for LC_UNIXTHREAD
641 pub const LC_MAIN: u32 = 0x28 | LC_REQ_DYLD;
642 /// table of non-instructions in __text
643 pub const LC_DATA_IN_CODE: u32 = 0x29;
644 /// source version used to build binary
645 pub const LC_SOURCE_VERSION: u32 = 0x2A;
646 /// Code signing DRs copied from linked dylibs
647 pub const LC_DYLIB_CODE_SIGN_DRS: u32 = 0x2B;
648 /// 64-bit encrypted segment information
649 pub const LC_ENCRYPTION_INFO_64: u32 = 0x2C;
650 /// linker options in MH_OBJECT files
651 pub const LC_LINKER_OPTION: u32 = 0x2D;
652 /// optimization hints in MH_OBJECT files
653 pub const LC_LINKER_OPTIMIZATION_HINT: u32 = 0x2E;
654 /// build for AppleTV min OS version
655 pub const LC_VERSION_MIN_TVOS: u32 = 0x2F;
656 /// build for Watch min OS version
657 pub const LC_VERSION_MIN_WATCHOS: u32 = 0x30;
658 /// arbitrary data included within a Mach-O file
659 pub const LC_NOTE: u32 = 0x31;
660 /// build for platform min OS version
661 pub const LC_BUILD_VERSION: u32 = 0x32;
662 /// used with `LinkeditDataCommand`, payload is trie
663 pub const LC_DYLD_EXPORTS_TRIE: u32 = 0x33 | LC_REQ_DYLD;
664 /// used with `LinkeditDataCommand`
665 pub const LC_DYLD_CHAINED_FIXUPS: u32 = 0x34 | LC_REQ_DYLD;
666
667 /// A variable length string in a load command.
668 ///
669 /// The strings are stored just after the load command structure and
670 /// the offset is from the start of the load command structure. The size
671 /// of the string is reflected in the `cmdsize` field of the load command.
672 /// Once again any padded bytes to bring the `cmdsize` field to a multiple
673 /// of 4 bytes must be zero.
674 #[derive(Debug, Clone, Copy)]
675 #[repr(C)]
676 pub struct LcStr<E: Endian> {
677 /// offset to the string
678 pub offset: U32<E>,
679 }
680
681 /// 32-bit segment load command.
682 ///
683 /// The segment load command indicates that a part of this file is to be
684 /// mapped into the task's address space. The size of this segment in memory,
685 /// vmsize, maybe equal to or larger than the amount to map from this file,
686 /// filesize. The file is mapped starting at fileoff to the beginning of
687 /// the segment in memory, vmaddr. The rest of the memory of the segment,
688 /// if any, is allocated zero fill on demand. The segment's maximum virtual
689 /// memory protection and initial virtual memory protection are specified
690 /// by the maxprot and initprot fields. If the segment has sections then the
691 /// `Section32` structures directly follow the segment command and their size is
692 /// reflected in `cmdsize`.
693 #[derive(Debug, Clone, Copy)]
694 #[repr(C)]
695 pub struct SegmentCommand32<E: Endian> {
696 /// LC_SEGMENT
697 pub cmd: U32<E>,
698 /// includes sizeof section structs
699 pub cmdsize: U32<E>,
700 /// segment name
701 pub segname: [u8; 16],
702 /// memory address of this segment
703 pub vmaddr: U32<E>,
704 /// memory size of this segment
705 pub vmsize: U32<E>,
706 /// file offset of this segment
707 pub fileoff: U32<E>,
708 /// amount to map from the file
709 pub filesize: U32<E>,
710 /// maximum VM protection
711 pub maxprot: U32<E>,
712 /// initial VM protection
713 pub initprot: U32<E>,
714 /// number of sections in segment
715 pub nsects: U32<E>,
716 /// flags
717 pub flags: U32<E>,
718 }
719
720 /// 64-bit segment load command.
721 ///
722 /// The 64-bit segment load command indicates that a part of this file is to be
723 /// mapped into a 64-bit task's address space. If the 64-bit segment has
724 /// sections then `Section64` structures directly follow the 64-bit segment
725 /// command and their size is reflected in `cmdsize`.
726 #[derive(Debug, Clone, Copy)]
727 #[repr(C)]
728 pub struct SegmentCommand64<E: Endian> {
729 /// LC_SEGMENT_64
730 pub cmd: U32<E>,
731 /// includes sizeof section_64 structs
732 pub cmdsize: U32<E>,
733 /// segment name
734 pub segname: [u8; 16],
735 /// memory address of this segment
736 pub vmaddr: U64<E>,
737 /// memory size of this segment
738 pub vmsize: U64<E>,
739 /// file offset of this segment
740 pub fileoff: U64<E>,
741 /// amount to map from the file
742 pub filesize: U64<E>,
743 /// maximum VM protection
744 pub maxprot: U32<E>,
745 /// initial VM protection
746 pub initprot: U32<E>,
747 /// number of sections in segment
748 pub nsects: U32<E>,
749 /// flags
750 pub flags: U32<E>,
751 }
752
753 // Values for `SegmentCommand*::flags`.
754 /// the file contents for this segment is for the high part of the VM space, the low part is zero filled (for stacks in core files)
755 pub const SG_HIGHVM: u32 = 0x1;
756 /// this segment is the VM that is allocated by a fixed VM library, for overlap checking in the link editor
757 pub const SG_FVMLIB: u32 = 0x2;
758 /// this segment has nothing that was relocated in it and nothing relocated to it, that is it maybe safely replaced without relocation
759 pub const SG_NORELOC: u32 = 0x4;
760 /// This segment is protected. If the segment starts at file offset 0, the first page of the segment is not protected. All other pages of the segment are protected.
761 pub const SG_PROTECTED_VERSION_1: u32 = 0x8;
762 /// This segment is made read-only after fixups
763 pub const SG_READ_ONLY: u32 = 0x10;
764
765 /*
766 * A segment is made up of zero or more sections. Non-MH_OBJECT files have
767 * all of their segments with the proper sections in each, and padded to the
768 * specified segment alignment when produced by the link editor. The first
769 * segment of a MH_EXECUTE and MH_FVMLIB format file contains the mach_header
770 * and load commands of the object file before its first section. The zero
771 * fill sections are always last in their segment (in all formats). This
772 * allows the zeroed segment padding to be mapped into memory where zero fill
773 * sections might be. The gigabyte zero fill sections, those with the section
774 * type S_GB_ZEROFILL, can only be in a segment with sections of this type.
775 * These segments are then placed after all other segments.
776 *
777 * The MH_OBJECT format has all of its sections in one segment for
778 * compactness. There is no padding to a specified segment boundary and the
779 * mach_header and load commands are not part of the segment.
780 *
781 * Sections with the same section name, sectname, going into the same segment,
782 * segname, are combined by the link editor. The resulting section is aligned
783 * to the maximum alignment of the combined sections and is the new section's
784 * alignment. The combined sections are aligned to their original alignment in
785 * the combined section. Any padded bytes to get the specified alignment are
786 * zeroed.
787 *
788 * The format of the relocation entries referenced by the reloff and nreloc
789 * fields of the section structure for mach object files is described in the
790 * header file <reloc.h>.
791 */
792 /// 32-bit section.
793 #[derive(Debug, Clone, Copy)]
794 #[repr(C)]
795 pub struct Section32<E: Endian> {
796 /// name of this section
797 pub sectname: [u8; 16],
798 /// segment this section goes in
799 pub segname: [u8; 16],
800 /// memory address of this section
801 pub addr: U32<E>,
802 /// size in bytes of this section
803 pub size: U32<E>,
804 /// file offset of this section
805 pub offset: U32<E>,
806 /// section alignment (power of 2)
807 pub align: U32<E>,
808 /// file offset of relocation entries
809 pub reloff: U32<E>,
810 /// number of relocation entries
811 pub nreloc: U32<E>,
812 /// flags (section type and attributes)
813 pub flags: U32<E>,
814 /// reserved (for offset or index)
815 pub reserved1: U32<E>,
816 /// reserved (for count or sizeof)
817 pub reserved2: U32<E>,
818 }
819
820 /// 64-bit section.
821 #[derive(Debug, Clone, Copy)]
822 #[repr(C)]
823 pub struct Section64<E: Endian> {
824 /// name of this section
825 pub sectname: [u8; 16],
826 /// segment this section goes in
827 pub segname: [u8; 16],
828 /// memory address of this section
829 pub addr: U64<E>,
830 /// size in bytes of this section
831 pub size: U64<E>,
832 /// file offset of this section
833 pub offset: U32<E>,
834 /// section alignment (power of 2)
835 pub align: U32<E>,
836 /// file offset of relocation entries
837 pub reloff: U32<E>,
838 /// number of relocation entries
839 pub nreloc: U32<E>,
840 /// flags (section type and attributes)
841 pub flags: U32<E>,
842 /// reserved (for offset or index)
843 pub reserved1: U32<E>,
844 /// reserved (for count or sizeof)
845 pub reserved2: U32<E>,
846 /// reserved
847 pub reserved3: U32<E>,
848 }
849
850 /*
851 * The flags field of a section structure is separated into two parts a section
852 * type and section attributes. The section types are mutually exclusive (it
853 * can only have one type) but the section attributes are not (it may have more
854 * than one attribute).
855 */
856 /// 256 section types
857 pub const SECTION_TYPE: u32 = 0x0000_00ff;
858 /// 24 section attributes
859 pub const SECTION_ATTRIBUTES: u32 = 0xffff_ff00;
860
861 /* Constants for the type of a section */
862 /// regular section
863 pub const S_REGULAR: u32 = 0x0;
864 /// zero fill on demand section
865 pub const S_ZEROFILL: u32 = 0x1;
866 /// section with only literal C strings
867 pub const S_CSTRING_LITERALS: u32 = 0x2;
868 /// section with only 4 byte literals
869 pub const S_4BYTE_LITERALS: u32 = 0x3;
870 /// section with only 8 byte literals
871 pub const S_8BYTE_LITERALS: u32 = 0x4;
872 /// section with only pointers to literals
873 pub const S_LITERAL_POINTERS: u32 = 0x5;
874 /*
875 * For the two types of symbol pointers sections and the symbol stubs section
876 * they have indirect symbol table entries. For each of the entries in the
877 * section the indirect symbol table entries, in corresponding order in the
878 * indirect symbol table, start at the index stored in the reserved1 field
879 * of the section structure. Since the indirect symbol table entries
880 * correspond to the entries in the section the number of indirect symbol table
881 * entries is inferred from the size of the section divided by the size of the
882 * entries in the section. For symbol pointers sections the size of the entries
883 * in the section is 4 bytes and for symbol stubs sections the byte size of the
884 * stubs is stored in the reserved2 field of the section structure.
885 */
886 /// section with only non-lazy symbol pointers
887 pub const S_NON_LAZY_SYMBOL_POINTERS: u32 = 0x6;
888 /// section with only lazy symbol pointers
889 pub const S_LAZY_SYMBOL_POINTERS: u32 = 0x7;
890 /// section with only symbol stubs, byte size of stub in the reserved2 field
891 pub const S_SYMBOL_STUBS: u32 = 0x8;
892 /// section with only function pointers for initialization
893 pub const S_MOD_INIT_FUNC_POINTERS: u32 = 0x9;
894 /// section with only function pointers for termination
895 pub const S_MOD_TERM_FUNC_POINTERS: u32 = 0xa;
896 /// section contains symbols that are to be coalesced
897 pub const S_COALESCED: u32 = 0xb;
898 /// zero fill on demand section (that can be larger than 4 gigabytes)
899 pub const S_GB_ZEROFILL: u32 = 0xc;
900 /// section with only pairs of function pointers for interposing
901 pub const S_INTERPOSING: u32 = 0xd;
902 /// section with only 16 byte literals
903 pub const S_16BYTE_LITERALS: u32 = 0xe;
904 /// section contains DTrace Object Format
905 pub const S_DTRACE_DOF: u32 = 0xf;
906 /// section with only lazy symbol pointers to lazy loaded dylibs
907 pub const S_LAZY_DYLIB_SYMBOL_POINTERS: u32 = 0x10;
908 /*
909 * Section types to support thread local variables
910 */
911 /// template of initial values for TLVs
912 pub const S_THREAD_LOCAL_REGULAR: u32 = 0x11;
913 /// template of initial values for TLVs
914 pub const S_THREAD_LOCAL_ZEROFILL: u32 = 0x12;
915 /// TLV descriptors
916 pub const S_THREAD_LOCAL_VARIABLES: u32 = 0x13;
917 /// pointers to TLV descriptors
918 pub const S_THREAD_LOCAL_VARIABLE_POINTERS: u32 = 0x14;
919 /// functions to call to initialize TLV values
920 pub const S_THREAD_LOCAL_INIT_FUNCTION_POINTERS: u32 = 0x15;
921 /// 32-bit offsets to initializers
922 pub const S_INIT_FUNC_OFFSETS: u32 = 0x16;
923
924 /*
925 * Constants for the section attributes part of the flags field of a section
926 * structure.
927 */
928 /// User setable attributes
929 pub const SECTION_ATTRIBUTES_USR: u32 = 0xff00_0000;
930 /// section contains only true machine instructions
931 pub const S_ATTR_PURE_INSTRUCTIONS: u32 = 0x8000_0000;
932 /// section contains coalesced symbols that are not to be in a ranlib table of contents
933 pub const S_ATTR_NO_TOC: u32 = 0x4000_0000;
934 /// ok to strip static symbols in this section in files with the MH_DYLDLINK flag
935 pub const S_ATTR_STRIP_STATIC_SYMS: u32 = 0x2000_0000;
936 /// no dead stripping
937 pub const S_ATTR_NO_DEAD_STRIP: u32 = 0x1000_0000;
938 /// blocks are live if they reference live blocks
939 pub const S_ATTR_LIVE_SUPPORT: u32 = 0x0800_0000;
940 /// Used with i386 code stubs written on by dyld
941 pub const S_ATTR_SELF_MODIFYING_CODE: u32 = 0x0400_0000;
942 /*
943 * If a segment contains any sections marked with S_ATTR_DEBUG then all
944 * sections in that segment must have this attribute. No section other than
945 * a section marked with this attribute may reference the contents of this
946 * section. A section with this attribute may contain no symbols and must have
947 * a section type S_REGULAR. The static linker will not copy section contents
948 * from sections with this attribute into its output file. These sections
949 * generally contain DWARF debugging info.
950 */
951 /// a debug section
952 pub const S_ATTR_DEBUG: u32 = 0x0200_0000;
953 /// system setable attributes
954 pub const SECTION_ATTRIBUTES_SYS: u32 = 0x00ff_ff00;
955 /// section contains some machine instructions
956 pub const S_ATTR_SOME_INSTRUCTIONS: u32 = 0x0000_0400;
957 /// section has external relocation entries
958 pub const S_ATTR_EXT_RELOC: u32 = 0x0000_0200;
959 /// section has local relocation entries
960 pub const S_ATTR_LOC_RELOC: u32 = 0x0000_0100;
961
962 /*
963 * The names of segments and sections in them are mostly meaningless to the
964 * link-editor. But there are few things to support traditional UNIX
965 * executables that require the link-editor and assembler to use some names
966 * agreed upon by convention.
967 *
968 * The initial protection of the "__TEXT" segment has write protection turned
969 * off (not writeable).
970 *
971 * The link-editor will allocate common symbols at the end of the "__common"
972 * section in the "__DATA" segment. It will create the section and segment
973 * if needed.
974 */
975
976 /* The currently known segment names and the section names in those segments */
977
978 /// the pagezero segment which has no protections and catches NULL references for MH_EXECUTE files
979 pub const SEG_PAGEZERO: &str = "__PAGEZERO";
980
981 /// the tradition UNIX text segment
982 pub const SEG_TEXT: &str = "__TEXT";
983 /// the real text part of the text section no headers, and no padding
984 pub const SECT_TEXT: &str = "__text";
985 /// the fvmlib initialization section
986 pub const SECT_FVMLIB_INIT0: &str = "__fvmlib_init0";
987 /// the section following the fvmlib initialization section
988 pub const SECT_FVMLIB_INIT1: &str = "__fvmlib_init1";
989
990 /// the tradition UNIX data segment
991 pub const SEG_DATA: &str = "__DATA";
992 /// the real initialized data section no padding, no bss overlap
993 pub const SECT_DATA: &str = "__data";
994 /// the real uninitialized data section no padding
995 pub const SECT_BSS: &str = "__bss";
996 /// the section common symbols are allocated in by the link editor
997 pub const SECT_COMMON: &str = "__common";
998
999 /// objective-C runtime segment
1000 pub const SEG_OBJC: &str = "__OBJC";
1001 /// symbol table
1002 pub const SECT_OBJC_SYMBOLS: &str = "__symbol_table";
1003 /// module information
1004 pub const SECT_OBJC_MODULES: &str = "__module_info";
1005 /// string table
1006 pub const SECT_OBJC_STRINGS: &str = "__selector_strs";
1007 /// string table
1008 pub const SECT_OBJC_REFS: &str = "__selector_refs";
1009
1010 /// the icon segment
1011 pub const SEG_ICON: &str = "__ICON";
1012 /// the icon headers
1013 pub const SECT_ICON_HEADER: &str = "__header";
1014 /// the icons in tiff format
1015 pub const SECT_ICON_TIFF: &str = "__tiff";
1016
1017 /// the segment containing all structs created and maintained by the link editor. Created with -seglinkedit option to ld(1) for MH_EXECUTE and FVMLIB file types only
1018 pub const SEG_LINKEDIT: &str = "__LINKEDIT";
1019
1020 /// the unix stack segment
1021 pub const SEG_UNIXSTACK: &str = "__UNIXSTACK";
1022
1023 /// the segment for the self (dyld) modifing code stubs that has read, write and execute permissions
1024 pub const SEG_IMPORT: &str = "__IMPORT";
1025
1026 /*
1027 * Fixed virtual memory shared libraries are identified by two things. The
1028 * target pathname (the name of the library as found for execution), and the
1029 * minor version number. The address of where the headers are loaded is in
1030 * header_addr. (THIS IS OBSOLETE and no longer supported).
1031 */
1032 #[derive(Debug, Clone, Copy)]
1033 #[repr(C)]
1034 pub struct Fvmlib<E: Endian> {
1035 /// library's target pathname
1036 pub name: LcStr<E>,
1037 /// library's minor version number
1038 pub minor_version: U32<E>,
1039 /// library's header address
1040 pub header_addr: U32<E>,
1041 }
1042
1043 /*
1044 * A fixed virtual shared library (filetype == MH_FVMLIB in the mach header)
1045 * contains a `FvmlibCommand` (cmd == LC_IDFVMLIB) to identify the library.
1046 * An object that uses a fixed virtual shared library also contains a
1047 * `FvmlibCommand` (cmd == LC_LOADFVMLIB) for each library it uses.
1048 * (THIS IS OBSOLETE and no longer supported).
1049 */
1050 #[derive(Debug, Clone, Copy)]
1051 #[repr(C)]
1052 pub struct FvmlibCommand<E: Endian> {
1053 /// LC_IDFVMLIB or LC_LOADFVMLIB
1054 pub cmd: U32<E>,
1055 /// includes pathname string
1056 pub cmdsize: U32<E>,
1057 /// the library identification
1058 pub fvmlib: Fvmlib<E>,
1059 }
1060
1061 /*
1062 * Dynamicly linked shared libraries are identified by two things. The
1063 * pathname (the name of the library as found for execution), and the
1064 * compatibility version number. The pathname must match and the compatibility
1065 * number in the user of the library must be greater than or equal to the
1066 * library being used. The time stamp is used to record the time a library was
1067 * built and copied into user so it can be use to determined if the library used
1068 * at runtime is exactly the same as used to built the program.
1069 */
1070 #[derive(Debug, Clone, Copy)]
1071 #[repr(C)]
1072 pub struct Dylib<E: Endian> {
1073 /// library's path name
1074 pub name: LcStr<E>,
1075 /// library's build time stamp
1076 pub timestamp: U32<E>,
1077 /// library's current version number
1078 pub current_version: U32<E>,
1079 /// library's compatibility vers number
1080 pub compatibility_version: U32<E>,
1081 }
1082
1083 /*
1084 * A dynamically linked shared library (filetype == MH_DYLIB in the mach header)
1085 * contains a `DylibCommand` (cmd == LC_ID_DYLIB) to identify the library.
1086 * An object that uses a dynamically linked shared library also contains a
1087 * `DylibCommand` (cmd == LC_LOAD_DYLIB, LC_LOAD_WEAK_DYLIB, or
1088 * LC_REEXPORT_DYLIB) for each library it uses.
1089 */
1090 #[derive(Debug, Clone, Copy)]
1091 #[repr(C)]
1092 pub struct DylibCommand<E: Endian> {
1093 /// LC_ID_DYLIB, LC_LOAD_{,WEAK_}DYLIB, LC_REEXPORT_DYLIB
1094 pub cmd: U32<E>,
1095 /// includes pathname string
1096 pub cmdsize: U32<E>,
1097 /// the library identification
1098 pub dylib: Dylib<E>,
1099 }
1100
1101 /*
1102 * A dynamically linked shared library may be a subframework of an umbrella
1103 * framework. If so it will be linked with "-umbrella umbrella_name" where
1104 * Where "umbrella_name" is the name of the umbrella framework. A subframework
1105 * can only be linked against by its umbrella framework or other subframeworks
1106 * that are part of the same umbrella framework. Otherwise the static link
1107 * editor produces an error and states to link against the umbrella framework.
1108 * The name of the umbrella framework for subframeworks is recorded in the
1109 * following structure.
1110 */
1111 #[derive(Debug, Clone, Copy)]
1112 #[repr(C)]
1113 pub struct SubFrameworkCommand<E: Endian> {
1114 /// LC_SUB_FRAMEWORK
1115 pub cmd: U32<E>,
1116 /// includes umbrella string
1117 pub cmdsize: U32<E>,
1118 /// the umbrella framework name
1119 pub umbrella: LcStr<E>,
1120 }
1121
1122 /*
1123 * For dynamically linked shared libraries that are subframework of an umbrella
1124 * framework they can allow clients other than the umbrella framework or other
1125 * subframeworks in the same umbrella framework. To do this the subframework
1126 * is built with "-allowable_client client_name" and an LC_SUB_CLIENT load
1127 * command is created for each -allowable_client flag. The client_name is
1128 * usually a framework name. It can also be a name used for bundles clients
1129 * where the bundle is built with "-client_name client_name".
1130 */
1131 #[derive(Debug, Clone, Copy)]
1132 #[repr(C)]
1133 pub struct SubClientCommand<E: Endian> {
1134 /// LC_SUB_CLIENT
1135 pub cmd: U32<E>,
1136 /// includes client string
1137 pub cmdsize: U32<E>,
1138 /// the client name
1139 pub client: LcStr<E>,
1140 }
1141
1142 /*
1143 * A dynamically linked shared library may be a sub_umbrella of an umbrella
1144 * framework. If so it will be linked with "-sub_umbrella umbrella_name" where
1145 * Where "umbrella_name" is the name of the sub_umbrella framework. When
1146 * staticly linking when -twolevel_namespace is in effect a twolevel namespace
1147 * umbrella framework will only cause its subframeworks and those frameworks
1148 * listed as sub_umbrella frameworks to be implicited linked in. Any other
1149 * dependent dynamic libraries will not be linked it when -twolevel_namespace
1150 * is in effect. The primary library recorded by the static linker when
1151 * resolving a symbol in these libraries will be the umbrella framework.
1152 * Zero or more sub_umbrella frameworks may be use by an umbrella framework.
1153 * The name of a sub_umbrella framework is recorded in the following structure.
1154 */
1155 #[derive(Debug, Clone, Copy)]
1156 #[repr(C)]
1157 pub struct SubUmbrellaCommand<E: Endian> {
1158 /// LC_SUB_UMBRELLA
1159 pub cmd: U32<E>,
1160 /// includes sub_umbrella string
1161 pub cmdsize: U32<E>,
1162 /// the sub_umbrella framework name
1163 pub sub_umbrella: LcStr<E>,
1164 }
1165
1166 /*
1167 * A dynamically linked shared library may be a sub_library of another shared
1168 * library. If so it will be linked with "-sub_library library_name" where
1169 * Where "library_name" is the name of the sub_library shared library. When
1170 * staticly linking when -twolevel_namespace is in effect a twolevel namespace
1171 * shared library will only cause its subframeworks and those frameworks
1172 * listed as sub_umbrella frameworks and libraries listed as sub_libraries to
1173 * be implicited linked in. Any other dependent dynamic libraries will not be
1174 * linked it when -twolevel_namespace is in effect. The primary library
1175 * recorded by the static linker when resolving a symbol in these libraries
1176 * will be the umbrella framework (or dynamic library). Zero or more sub_library
1177 * shared libraries may be use by an umbrella framework or (or dynamic library).
1178 * The name of a sub_library framework is recorded in the following structure.
1179 * For example /usr/lib/libobjc_profile.A.dylib would be recorded as "libobjc".
1180 */
1181 #[derive(Debug, Clone, Copy)]
1182 #[repr(C)]
1183 pub struct SubLibraryCommand<E: Endian> {
1184 /// LC_SUB_LIBRARY
1185 pub cmd: U32<E>,
1186 /// includes sub_library string
1187 pub cmdsize: U32<E>,
1188 /// the sub_library name
1189 pub sub_library: LcStr<E>,
1190 }
1191
1192 /*
1193 * A program (filetype == MH_EXECUTE) that is
1194 * prebound to its dynamic libraries has one of these for each library that
1195 * the static linker used in prebinding. It contains a bit vector for the
1196 * modules in the library. The bits indicate which modules are bound (1) and
1197 * which are not (0) from the library. The bit for module 0 is the low bit
1198 * of the first byte. So the bit for the Nth module is:
1199 * (linked_modules[N/8] >> N%8) & 1
1200 */
1201 #[derive(Debug, Clone, Copy)]
1202 #[repr(C)]
1203 pub struct PreboundDylibCommand<E: Endian> {
1204 /// LC_PREBOUND_DYLIB
1205 pub cmd: U32<E>,
1206 /// includes strings
1207 pub cmdsize: U32<E>,
1208 /// library's path name
1209 pub name: LcStr<E>,
1210 /// number of modules in library
1211 pub nmodules: U32<E>,
1212 /// bit vector of linked modules
1213 pub linked_modules: LcStr<E>,
1214 }
1215
1216 /*
1217 * A program that uses a dynamic linker contains a `DylinkerCommand` to identify
1218 * the name of the dynamic linker (LC_LOAD_DYLINKER). And a dynamic linker
1219 * contains a `DylinkerCommand` to identify the dynamic linker (LC_ID_DYLINKER).
1220 * A file can have at most one of these.
1221 * This struct is also used for the LC_DYLD_ENVIRONMENT load command and
1222 * contains string for dyld to treat like environment variable.
1223 */
1224 #[derive(Debug, Clone, Copy)]
1225 #[repr(C)]
1226 pub struct DylinkerCommand<E: Endian> {
1227 /// LC_ID_DYLINKER, LC_LOAD_DYLINKER or LC_DYLD_ENVIRONMENT
1228 pub cmd: U32<E>,
1229 /// includes pathname string
1230 pub cmdsize: U32<E>,
1231 /// dynamic linker's path name
1232 pub name: LcStr<E>,
1233 }
1234
1235 /*
1236 * Thread commands contain machine-specific data structures suitable for
1237 * use in the thread state primitives. The machine specific data structures
1238 * follow the struct `ThreadCommand` as follows.
1239 * Each flavor of machine specific data structure is preceded by an uint32_t
1240 * constant for the flavor of that data structure, an uint32_t that is the
1241 * count of uint32_t's of the size of the state data structure and then
1242 * the state data structure follows. This triple may be repeated for many
1243 * flavors. The constants for the flavors, counts and state data structure
1244 * definitions are expected to be in the header file <machine/thread_status.h>.
1245 * These machine specific data structures sizes must be multiples of
1246 * 4 bytes. The `cmdsize` reflects the total size of the `ThreadCommand`
1247 * and all of the sizes of the constants for the flavors, counts and state
1248 * data structures.
1249 *
1250 * For executable objects that are unix processes there will be one
1251 * `ThreadCommand` (cmd == LC_UNIXTHREAD) created for it by the link-editor.
1252 * This is the same as a LC_THREAD, except that a stack is automatically
1253 * created (based on the shell's limit for the stack size). Command arguments
1254 * and environment variables are copied onto that stack.
1255 */
1256 #[derive(Debug, Clone, Copy)]
1257 #[repr(C)]
1258 pub struct ThreadCommand<E: Endian> {
1259 /// LC_THREAD or LC_UNIXTHREAD
1260 pub cmd: U32<E>,
1261 /// total size of this command
1262 pub cmdsize: U32<E>,
1263 /* uint32_t flavor flavor of thread state */
1264 /* uint32_t count count of uint32_t's in thread state */
1265 /* struct XXX_thread_state state thread state for this flavor */
1266 /* ... */
1267 }
1268
1269 /*
1270 * The routines command contains the address of the dynamic shared library
1271 * initialization routine and an index into the module table for the module
1272 * that defines the routine. Before any modules are used from the library the
1273 * dynamic linker fully binds the module that defines the initialization routine
1274 * and then calls it. This gets called before any module initialization
1275 * routines (used for C++ static constructors) in the library.
1276 */
1277 #[derive(Debug, Clone, Copy)]
1278 #[repr(C)]
1279 pub struct RoutinesCommand<E: Endian> {
1280 /* for 32-bit architectures */
1281 /// LC_ROUTINES
1282 pub cmd: U32<E>,
1283 /// total size of this command
1284 pub cmdsize: U32<E>,
1285 /// address of initialization routine
1286 pub init_address: U32<E>,
1287 /// index into the module table that the init routine is defined in
1288 pub init_module: U32<E>,
1289 pub reserved1: U32<E>,
1290 pub reserved2: U32<E>,
1291 pub reserved3: U32<E>,
1292 pub reserved4: U32<E>,
1293 pub reserved5: U32<E>,
1294 pub reserved6: U32<E>,
1295 }
1296
1297 /*
1298 * The 64-bit routines command. Same use as above.
1299 */
1300 #[derive(Debug, Clone, Copy)]
1301 #[repr(C)]
1302 pub struct RoutinesCommand_64<E: Endian> {
1303 /* for 64-bit architectures */
1304 /// LC_ROUTINES_64
1305 pub cmd: U32<E>,
1306 /// total size of this command
1307 pub cmdsize: U32<E>,
1308 /// address of initialization routine
1309 pub init_address: U64<E>,
1310 /// index into the module table that the init routine is defined in
1311 pub init_module: U64<E>,
1312 pub reserved1: U64<E>,
1313 pub reserved2: U64<E>,
1314 pub reserved3: U64<E>,
1315 pub reserved4: U64<E>,
1316 pub reserved5: U64<E>,
1317 pub reserved6: U64<E>,
1318 }
1319
1320 /*
1321 * The `SymtabCommand` contains the offsets and sizes of the link-edit 4.3BSD
1322 * "stab" style symbol table information as described in the header files
1323 * <nlist.h> and <stab.h>.
1324 */
1325 #[derive(Debug, Clone, Copy)]
1326 #[repr(C)]
1327 pub struct SymtabCommand<E: Endian> {
1328 /// LC_SYMTAB
1329 pub cmd: U32<E>,
1330 /// sizeof(struct SymtabCommand)
1331 pub cmdsize: U32<E>,
1332 /// symbol table offset
1333 pub symoff: U32<E>,
1334 /// number of symbol table entries
1335 pub nsyms: U32<E>,
1336 /// string table offset
1337 pub stroff: U32<E>,
1338 /// string table size in bytes
1339 pub strsize: U32<E>,
1340 }
1341
1342 /*
1343 * This is the second set of the symbolic information which is used to support
1344 * the data structures for the dynamically link editor.
1345 *
1346 * The original set of symbolic information in the `SymtabCommand` which contains
1347 * the symbol and string tables must also be present when this load command is
1348 * present. When this load command is present the symbol table is organized
1349 * into three groups of symbols:
1350 * local symbols (static and debugging symbols) - grouped by module
1351 * defined external symbols - grouped by module (sorted by name if not lib)
1352 * undefined external symbols (sorted by name if MH_BINDATLOAD is not set,
1353 * and in order the were seen by the static
1354 * linker if MH_BINDATLOAD is set)
1355 * In this load command there are offsets and counts to each of the three groups
1356 * of symbols.
1357 *
1358 * This load command contains a the offsets and sizes of the following new
1359 * symbolic information tables:
1360 * table of contents
1361 * module table
1362 * reference symbol table
1363 * indirect symbol table
1364 * The first three tables above (the table of contents, module table and
1365 * reference symbol table) are only present if the file is a dynamically linked
1366 * shared library. For executable and object modules, which are files
1367 * containing only one module, the information that would be in these three
1368 * tables is determined as follows:
1369 * table of contents - the defined external symbols are sorted by name
1370 * module table - the file contains only one module so everything in the
1371 * file is part of the module.
1372 * reference symbol table - is the defined and undefined external symbols
1373 *
1374 * For dynamically linked shared library files this load command also contains
1375 * offsets and sizes to the pool of relocation entries for all sections
1376 * separated into two groups:
1377 * external relocation entries
1378 * local relocation entries
1379 * For executable and object modules the relocation entries continue to hang
1380 * off the section structures.
1381 */
1382 #[derive(Debug, Clone, Copy)]
1383 #[repr(C)]
1384 pub struct DysymtabCommand<E: Endian> {
1385 /// LC_DYSYMTAB
1386 pub cmd: U32<E>,
1387 /// sizeof(struct DysymtabCommand)
1388 pub cmdsize: U32<E>,
1389
1390 /*
1391 * The symbols indicated by symoff and nsyms of the LC_SYMTAB load command
1392 * are grouped into the following three groups:
1393 * local symbols (further grouped by the module they are from)
1394 * defined external symbols (further grouped by the module they are from)
1395 * undefined symbols
1396 *
1397 * The local symbols are used only for debugging. The dynamic binding
1398 * process may have to use them to indicate to the debugger the local
1399 * symbols for a module that is being bound.
1400 *
1401 * The last two groups are used by the dynamic binding process to do the
1402 * binding (indirectly through the module table and the reference symbol
1403 * table when this is a dynamically linked shared library file).
1404 */
1405 /// index to local symbols
1406 pub ilocalsym: U32<E>,
1407 /// number of local symbols
1408 pub nlocalsym: U32<E>,
1409
1410 /// index to externally defined symbols
1411 pub iextdefsym: U32<E>,
1412 /// number of externally defined symbols
1413 pub nextdefsym: U32<E>,
1414
1415 /// index to undefined symbols
1416 pub iundefsym: U32<E>,
1417 /// number of undefined symbols
1418 pub nundefsym: U32<E>,
1419
1420 /*
1421 * For the for the dynamic binding process to find which module a symbol
1422 * is defined in the table of contents is used (analogous to the ranlib
1423 * structure in an archive) which maps defined external symbols to modules
1424 * they are defined in. This exists only in a dynamically linked shared
1425 * library file. For executable and object modules the defined external
1426 * symbols are sorted by name and is use as the table of contents.
1427 */
1428 /// file offset to table of contents
1429 pub tocoff: U32<E>,
1430 /// number of entries in table of contents
1431 pub ntoc: U32<E>,
1432
1433 /*
1434 * To support dynamic binding of "modules" (whole object files) the symbol
1435 * table must reflect the modules that the file was created from. This is
1436 * done by having a module table that has indexes and counts into the merged
1437 * tables for each module. The module structure that these two entries
1438 * refer to is described below. This exists only in a dynamically linked
1439 * shared library file. For executable and object modules the file only
1440 * contains one module so everything in the file belongs to the module.
1441 */
1442 /// file offset to module table
1443 pub modtaboff: U32<E>,
1444 /// number of module table entries
1445 pub nmodtab: U32<E>,
1446
1447 /*
1448 * To support dynamic module binding the module structure for each module
1449 * indicates the external references (defined and undefined) each module
1450 * makes. For each module there is an offset and a count into the
1451 * reference symbol table for the symbols that the module references.
1452 * This exists only in a dynamically linked shared library file. For
1453 * executable and object modules the defined external symbols and the
1454 * undefined external symbols indicates the external references.
1455 */
1456 /// offset to referenced symbol table
1457 pub extrefsymoff: U32<E>,
1458 /// number of referenced symbol table entries
1459 pub nextrefsyms: U32<E>,
1460
1461 /*
1462 * The sections that contain "symbol pointers" and "routine stubs" have
1463 * indexes and (implied counts based on the size of the section and fixed
1464 * size of the entry) into the "indirect symbol" table for each pointer
1465 * and stub. For every section of these two types the index into the
1466 * indirect symbol table is stored in the section header in the field
1467 * reserved1. An indirect symbol table entry is simply a 32bit index into
1468 * the symbol table to the symbol that the pointer or stub is referring to.
1469 * The indirect symbol table is ordered to match the entries in the section.
1470 */
1471 /// file offset to the indirect symbol table
1472 pub indirectsymoff: U32<E>,
1473 /// number of indirect symbol table entries
1474 pub nindirectsyms: U32<E>,
1475
1476 /*
1477 * To support relocating an individual module in a library file quickly the
1478 * external relocation entries for each module in the library need to be
1479 * accessed efficiently. Since the relocation entries can't be accessed
1480 * through the section headers for a library file they are separated into
1481 * groups of local and external entries further grouped by module. In this
1482 * case the presents of this load command who's extreloff, nextrel,
1483 * locreloff and nlocrel fields are non-zero indicates that the relocation
1484 * entries of non-merged sections are not referenced through the section
1485 * structures (and the reloff and nreloc fields in the section headers are
1486 * set to zero).
1487 *
1488 * Since the relocation entries are not accessed through the section headers
1489 * this requires the r_address field to be something other than a section
1490 * offset to identify the item to be relocated. In this case r_address is
1491 * set to the offset from the vmaddr of the first LC_SEGMENT command.
1492 * For MH_SPLIT_SEGS images r_address is set to the the offset from the
1493 * vmaddr of the first read-write LC_SEGMENT command.
1494 *
1495 * The relocation entries are grouped by module and the module table
1496 * entries have indexes and counts into them for the group of external
1497 * relocation entries for that the module.
1498 *
1499 * For sections that are merged across modules there must not be any
1500 * remaining external relocation entries for them (for merged sections
1501 * remaining relocation entries must be local).
1502 */
1503 /// offset to external relocation entries
1504 pub extreloff: U32<E>,
1505 /// number of external relocation entries
1506 pub nextrel: U32<E>,
1507
1508 /*
1509 * All the local relocation entries are grouped together (they are not
1510 * grouped by their module since they are only used if the object is moved
1511 * from it staticly link edited address).
1512 */
1513 /// offset to local relocation entries
1514 pub locreloff: U32<E>,
1515 /// number of local relocation entries
1516 pub nlocrel: U32<E>,
1517 }
1518
1519 /*
1520 * An indirect symbol table entry is simply a 32bit index into the symbol table
1521 * to the symbol that the pointer or stub is refering to. Unless it is for a
1522 * non-lazy symbol pointer section for a defined symbol which strip(1) as
1523 * removed. In which case it has the value INDIRECT_SYMBOL_LOCAL. If the
1524 * symbol was also absolute INDIRECT_SYMBOL_ABS is or'ed with that.
1525 */
1526 pub const INDIRECT_SYMBOL_LOCAL: u32 = 0x8000_0000;
1527 pub const INDIRECT_SYMBOL_ABS: u32 = 0x4000_0000;
1528
1529 /* a table of contents entry */
1530 #[derive(Debug, Clone, Copy)]
1531 #[repr(C)]
1532 pub struct DylibTableOfContents<E: Endian> {
1533 /// the defined external symbol (index into the symbol table)
1534 pub symbol_index: U32<E>,
1535 /// index into the module table this symbol is defined in
1536 pub module_index: U32<E>,
1537 }
1538
1539 /* a module table entry */
1540 #[derive(Debug, Clone, Copy)]
1541 #[repr(C)]
1542 pub struct DylibModule32<E: Endian> {
1543 /// the module name (index into string table)
1544 pub module_name: U32<E>,
1545
1546 /// index into externally defined symbols
1547 pub iextdefsym: U32<E>,
1548 /// number of externally defined symbols
1549 pub nextdefsym: U32<E>,
1550 /// index into reference symbol table
1551 pub irefsym: U32<E>,
1552 /// number of reference symbol table entries
1553 pub nrefsym: U32<E>,
1554 /// index into symbols for local symbols
1555 pub ilocalsym: U32<E>,
1556 /// number of local symbols
1557 pub nlocalsym: U32<E>,
1558
1559 /// index into external relocation entries
1560 pub iextrel: U32<E>,
1561 /// number of external relocation entries
1562 pub nextrel: U32<E>,
1563
1564 /// low 16 bits are the index into the init section, high 16 bits are the index into the term section
1565 pub iinit_iterm: U32<E>,
1566 /// low 16 bits are the number of init section entries, high 16 bits are the number of term section entries
1567 pub ninit_nterm: U32<E>,
1568
1569 /// for this module address of the start of the (__OBJC,__module_info) section
1570 pub objc_module_info_addr: U32<E>,
1571 /// for this module size of the (__OBJC,__module_info) section
1572 pub objc_module_info_size: U32<E>,
1573 }
1574
1575 /* a 64-bit module table entry */
1576 #[derive(Debug, Clone, Copy)]
1577 #[repr(C)]
1578 pub struct DylibModule64<E: Endian> {
1579 /// the module name (index into string table)
1580 pub module_name: U32<E>,
1581
1582 /// index into externally defined symbols
1583 pub iextdefsym: U32<E>,
1584 /// number of externally defined symbols
1585 pub nextdefsym: U32<E>,
1586 /// index into reference symbol table
1587 pub irefsym: U32<E>,
1588 /// number of reference symbol table entries
1589 pub nrefsym: U32<E>,
1590 /// index into symbols for local symbols
1591 pub ilocalsym: U32<E>,
1592 /// number of local symbols
1593 pub nlocalsym: U32<E>,
1594
1595 /// index into external relocation entries
1596 pub iextrel: U32<E>,
1597 /// number of external relocation entries
1598 pub nextrel: U32<E>,
1599
1600 /// low 16 bits are the index into the init section, high 16 bits are the index into the term section
1601 pub iinit_iterm: U32<E>,
1602 /// low 16 bits are the number of init section entries, high 16 bits are the number of term section entries
1603 pub ninit_nterm: U32<E>,
1604
1605 /// for this module size of the (__OBJC,__module_info) section
1606 pub objc_module_info_size: U32<E>,
1607 /// for this module address of the start of the (__OBJC,__module_info) section
1608 pub objc_module_info_addr: U64<E>,
1609 }
1610
1611 /*
1612 * The entries in the reference symbol table are used when loading the module
1613 * (both by the static and dynamic link editors) and if the module is unloaded
1614 * or replaced. Therefore all external symbols (defined and undefined) are
1615 * listed in the module's reference table. The flags describe the type of
1616 * reference that is being made. The constants for the flags are defined in
1617 * <mach-o/nlist.h> as they are also used for symbol table entries.
1618 */
1619 #[derive(Debug, Clone, Copy)]
1620 #[repr(C)]
1621 pub struct DylibReference<E: Endian> {
1622 /* TODO:
1623 uint32_t isym:24, /* index into the symbol table */
1624 flags:8; /* flags to indicate the type of reference */
1625 */
1626 pub bitfield: U32<E>,
1627 }
1628
1629 /*
1630 * The TwolevelHintsCommand contains the offset and number of hints in the
1631 * two-level namespace lookup hints table.
1632 */
1633 #[derive(Debug, Clone, Copy)]
1634 #[repr(C)]
1635 pub struct TwolevelHintsCommand<E: Endian> {
1636 /// LC_TWOLEVEL_HINTS
1637 pub cmd: U32<E>,
1638 /// sizeof(struct TwolevelHintsCommand)
1639 pub cmdsize: U32<E>,
1640 /// offset to the hint table
1641 pub offset: U32<E>,
1642 /// number of hints in the hint table
1643 pub nhints: U32<E>,
1644 }
1645
1646 /*
1647 * The entries in the two-level namespace lookup hints table are TwolevelHint
1648 * structs. These provide hints to the dynamic link editor where to start
1649 * looking for an undefined symbol in a two-level namespace image. The
1650 * isub_image field is an index into the sub-images (sub-frameworks and
1651 * sub-umbrellas list) that made up the two-level image that the undefined
1652 * symbol was found in when it was built by the static link editor. If
1653 * isub-image is 0 the the symbol is expected to be defined in library and not
1654 * in the sub-images. If isub-image is non-zero it is an index into the array
1655 * of sub-images for the umbrella with the first index in the sub-images being
1656 * 1. The array of sub-images is the ordered list of sub-images of the umbrella
1657 * that would be searched for a symbol that has the umbrella recorded as its
1658 * primary library. The table of contents index is an index into the
1659 * library's table of contents. This is used as the starting point of the
1660 * binary search or a directed linear search.
1661 */
1662 #[derive(Debug, Clone, Copy)]
1663 #[repr(C)]
1664 pub struct TwolevelHint<E: Endian> {
1665 /* TODO:
1666 uint32_t
1667 isub_image:8, /* index into the sub images */
1668 itoc:24; /* index into the table of contents */
1669 */
1670 pub bitfield: U32<E>,
1671 }
1672
1673 /*
1674 * The PrebindCksumCommand contains the value of the original check sum for
1675 * prebound files or zero. When a prebound file is first created or modified
1676 * for other than updating its prebinding information the value of the check sum
1677 * is set to zero. When the file has it prebinding re-done and if the value of
1678 * the check sum is zero the original check sum is calculated and stored in
1679 * cksum field of this load command in the output file. If when the prebinding
1680 * is re-done and the cksum field is non-zero it is left unchanged from the
1681 * input file.
1682 */
1683 #[derive(Debug, Clone, Copy)]
1684 #[repr(C)]
1685 pub struct PrebindCksumCommand<E: Endian> {
1686 /// LC_PREBIND_CKSUM
1687 pub cmd: U32<E>,
1688 /// sizeof(struct PrebindCksumCommand)
1689 pub cmdsize: U32<E>,
1690 /// the check sum or zero
1691 pub cksum: U32<E>,
1692 }
1693
1694 /*
1695 * The uuid load command contains a single 128-bit unique random number that
1696 * identifies an object produced by the static link editor.
1697 */
1698 #[derive(Debug, Clone, Copy)]
1699 #[repr(C)]
1700 pub struct UuidCommand<E: Endian> {
1701 /// LC_UUID
1702 pub cmd: U32<E>,
1703 /// sizeof(struct UuidCommand)
1704 pub cmdsize: U32<E>,
1705 /// the 128-bit uuid
1706 pub uuid: [u8; 16],
1707 }
1708
1709 /*
1710 * The RpathCommand contains a path which at runtime should be added to
1711 * the current run path used to find @rpath prefixed dylibs.
1712 */
1713 #[derive(Debug, Clone, Copy)]
1714 #[repr(C)]
1715 pub struct RpathCommand<E: Endian> {
1716 /// LC_RPATH
1717 pub cmd: U32<E>,
1718 /// includes string
1719 pub cmdsize: U32<E>,
1720 /// path to add to run path
1721 pub path: LcStr<E>,
1722 }
1723
1724 /*
1725 * The LinkeditDataCommand contains the offsets and sizes of a blob
1726 * of data in the __LINKEDIT segment.
1727 */
1728 #[derive(Debug, Clone, Copy)]
1729 #[repr(C)]
1730 pub struct LinkeditDataCommand<E: Endian> {
1731 /// LC_CODE_SIGNATURE, LC_SEGMENT_SPLIT_INFO, LC_FUNCTION_STARTS, LC_DATA_IN_CODE, LC_DYLIB_CODE_SIGN_DRS or LC_LINKER_OPTIMIZATION_HINT.
1732 pub cmd: U32<E>,
1733 /// sizeof(struct LinkeditDataCommand)
1734 pub cmdsize: U32<E>,
1735 /// file offset of data in __LINKEDIT segment
1736 pub dataoff: U32<E>,
1737 /// file size of data in __LINKEDIT segment
1738 pub datasize: U32<E>,
1739 }
1740
1741 /*
1742 * The EncryptionInfoCommand contains the file offset and size of an
1743 * of an encrypted segment.
1744 */
1745 #[derive(Debug, Clone, Copy)]
1746 #[repr(C)]
1747 pub struct EncryptionInfoCommand<E: Endian> {
1748 /// LC_ENCRYPTION_INFO
1749 pub cmd: U32<E>,
1750 /// sizeof(struct EncryptionInfoCommand)
1751 pub cmdsize: U32<E>,
1752 /// file offset of encrypted range
1753 pub cryptoff: U32<E>,
1754 /// file size of encrypted range
1755 pub cryptsize: U32<E>,
1756 /// which enryption system, 0 means not-encrypted yet
1757 pub cryptid: U32<E>,
1758 }
1759
1760 /*
1761 * The EncryptionInfoCommand64 contains the file offset and size of an
1762 * of an encrypted segment (for use in x86_64 targets).
1763 */
1764 #[derive(Debug, Clone, Copy)]
1765 #[repr(C)]
1766 pub struct EncryptionInfoCommand64<E: Endian> {
1767 /// LC_ENCRYPTION_INFO_64
1768 pub cmd: U32<E>,
1769 /// sizeof(struct EncryptionInfoCommand64)
1770 pub cmdsize: U32<E>,
1771 /// file offset of encrypted range
1772 pub cryptoff: U32<E>,
1773 /// file size of encrypted range
1774 pub cryptsize: U32<E>,
1775 /// which enryption system, 0 means not-encrypted yet
1776 pub cryptid: U32<E>,
1777 /// padding to make this struct's size a multiple of 8 bytes
1778 pub pad: U32<E>,
1779 }
1780
1781 /*
1782 * The VersionMinCommand contains the min OS version on which this
1783 * binary was built to run.
1784 */
1785 #[derive(Debug, Clone, Copy)]
1786 #[repr(C)]
1787 pub struct VersionMinCommand<E: Endian> {
1788 /// LC_VERSION_MIN_MACOSX or LC_VERSION_MIN_IPHONEOS or LC_VERSION_MIN_WATCHOS or LC_VERSION_MIN_TVOS
1789 pub cmd: U32<E>,
1790 /// sizeof(struct VersionMinCommand)
1791 pub cmdsize: U32<E>,
1792 /// X.Y.Z is encoded in nibbles xxxx.yy.zz
1793 pub version: U32<E>,
1794 /// X.Y.Z is encoded in nibbles xxxx.yy.zz
1795 pub sdk: U32<E>,
1796 }
1797
1798 /*
1799 * The BuildVersionCommand contains the min OS version on which this
1800 * binary was built to run for its platform. The list of known platforms and
1801 * tool values following it.
1802 */
1803 #[derive(Debug, Clone, Copy)]
1804 #[repr(C)]
1805 pub struct BuildVersionCommand<E: Endian> {
1806 /// LC_BUILD_VERSION
1807 pub cmd: U32<E>,
1808 /// sizeof(struct BuildVersionCommand) plus ntools * sizeof(struct BuildToolVersion)
1809 pub cmdsize: U32<E>,
1810 /// platform
1811 pub platform: U32<E>,
1812 /// X.Y.Z is encoded in nibbles xxxx.yy.zz
1813 pub minos: U32<E>,
1814 /// X.Y.Z is encoded in nibbles xxxx.yy.zz
1815 pub sdk: U32<E>,
1816 /// number of tool entries following this
1817 pub ntools: U32<E>,
1818 }
1819
1820 #[derive(Debug, Clone, Copy)]
1821 #[repr(C)]
1822 pub struct BuildToolVersion<E: Endian> {
1823 /// enum for the tool
1824 pub tool: U32<E>,
1825 /// version number of the tool
1826 pub version: U32<E>,
1827 }
1828
1829 /* Known values for the platform field above. */
1830 pub const PLATFORM_MACOS: u32 = 1;
1831 pub const PLATFORM_IOS: u32 = 2;
1832 pub const PLATFORM_TVOS: u32 = 3;
1833 pub const PLATFORM_WATCHOS: u32 = 4;
1834 pub const PLATFORM_BRIDGEOS: u32 = 5;
1835 pub const PLATFORM_IOSMAC: u32 = 6;
1836 pub const PLATFORM_IOSSIMULATOR: u32 = 7;
1837 pub const PLATFORM_TVOSSIMULATOR: u32 = 8;
1838 pub const PLATFORM_WATCHOSSIMULATOR: u32 = 9;
1839
1840 /* Known values for the tool field above. */
1841 pub const TOOL_CLANG: u32 = 1;
1842 pub const TOOL_SWIFT: u32 = 2;
1843 pub const TOOL_LD: u32 = 3;
1844
1845 /*
1846 * The DyldInfoCommand contains the file offsets and sizes of
1847 * the new compressed form of the information dyld needs to
1848 * load the image. This information is used by dyld on Mac OS X
1849 * 10.6 and later. All information pointed to by this command
1850 * is encoded using byte streams, so no endian swapping is needed
1851 * to interpret it.
1852 */
1853 #[derive(Debug, Clone, Copy)]
1854 #[repr(C)]
1855 pub struct DyldInfoCommand<E: Endian> {
1856 /// LC_DYLD_INFO or LC_DYLD_INFO_ONLY
1857 pub cmd: U32<E>,
1858 /// sizeof(struct DyldInfoCommand)
1859 pub cmdsize: U32<E>,
1860
1861 /*
1862 * Dyld rebases an image whenever dyld loads it at an address different
1863 * from its preferred address. The rebase information is a stream
1864 * of byte sized opcodes whose symbolic names start with REBASE_OPCODE_.
1865 * Conceptually the rebase information is a table of tuples:
1866 * <seg-index, seg-offset, type>
1867 * The opcodes are a compressed way to encode the table by only
1868 * encoding when a column changes. In addition simple patterns
1869 * like "every n'th offset for m times" can be encoded in a few
1870 * bytes.
1871 */
1872 /// file offset to rebase info
1873 pub rebase_off: U32<E>,
1874 /// size of rebase info
1875 pub rebase_size: U32<E>,
1876
1877 /*
1878 * Dyld binds an image during the loading process, if the image
1879 * requires any pointers to be initialized to symbols in other images.
1880 * The bind information is a stream of byte sized
1881 * opcodes whose symbolic names start with BIND_OPCODE_.
1882 * Conceptually the bind information is a table of tuples:
1883 * <seg-index, seg-offset, type, symbol-library-ordinal, symbol-name, addend>
1884 * The opcodes are a compressed way to encode the table by only
1885 * encoding when a column changes. In addition simple patterns
1886 * like for runs of pointers initialzed to the same value can be
1887 * encoded in a few bytes.
1888 */
1889 /// file offset to binding info
1890 pub bind_off: U32<E>,
1891 /// size of binding info
1892 pub bind_size: U32<E>,
1893
1894 /*
1895 * Some C++ programs require dyld to unique symbols so that all
1896 * images in the process use the same copy of some code/data.
1897 * This step is done after binding. The content of the weak_bind
1898 * info is an opcode stream like the bind_info. But it is sorted
1899 * alphabetically by symbol name. This enable dyld to walk
1900 * all images with weak binding information in order and look
1901 * for collisions. If there are no collisions, dyld does
1902 * no updating. That means that some fixups are also encoded
1903 * in the bind_info. For instance, all calls to "operator new"
1904 * are first bound to libstdc++.dylib using the information
1905 * in bind_info. Then if some image overrides operator new
1906 * that is detected when the weak_bind information is processed
1907 * and the call to operator new is then rebound.
1908 */
1909 /// file offset to weak binding info
1910 pub weak_bind_off: U32<E>,
1911 /// size of weak binding info
1912 pub weak_bind_size: U32<E>,
1913
1914 /*
1915 * Some uses of external symbols do not need to be bound immediately.
1916 * Instead they can be lazily bound on first use. The lazy_bind
1917 * are contains a stream of BIND opcodes to bind all lazy symbols.
1918 * Normal use is that dyld ignores the lazy_bind section when
1919 * loading an image. Instead the static linker arranged for the
1920 * lazy pointer to initially point to a helper function which
1921 * pushes the offset into the lazy_bind area for the symbol
1922 * needing to be bound, then jumps to dyld which simply adds
1923 * the offset to lazy_bind_off to get the information on what
1924 * to bind.
1925 */
1926 /// file offset to lazy binding info
1927 pub lazy_bind_off: U32<E>,
1928 /// size of lazy binding infs
1929 pub lazy_bind_size: U32<E>,
1930
1931 /*
1932 * The symbols exported by a dylib are encoded in a trie. This
1933 * is a compact representation that factors out common prefixes.
1934 * It also reduces LINKEDIT pages in RAM because it encodes all
1935 * information (name, address, flags) in one small, contiguous range.
1936 * The export area is a stream of nodes. The first node sequentially
1937 * is the start node for the trie.
1938 *
1939 * Nodes for a symbol start with a uleb128 that is the length of
1940 * the exported symbol information for the string so far.
1941 * If there is no exported symbol, the node starts with a zero byte.
1942 * If there is exported info, it follows the length.
1943 *
1944 * First is a uleb128 containing flags. Normally, it is followed by
1945 * a uleb128 encoded offset which is location of the content named
1946 * by the symbol from the mach_header for the image. If the flags
1947 * is EXPORT_SYMBOL_FLAGS_REEXPORT, then following the flags is
1948 * a uleb128 encoded library ordinal, then a zero terminated
1949 * UTF8 string. If the string is zero length, then the symbol
1950 * is re-export from the specified dylib with the same name.
1951 * If the flags is EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER, then following
1952 * the flags is two uleb128s: the stub offset and the resolver offset.
1953 * The stub is used by non-lazy pointers. The resolver is used
1954 * by lazy pointers and must be called to get the actual address to use.
1955 *
1956 * After the optional exported symbol information is a byte of
1957 * how many edges (0-255) that this node has leaving it,
1958 * followed by each edge.
1959 * Each edge is a zero terminated UTF8 of the addition chars
1960 * in the symbol, followed by a uleb128 offset for the node that
1961 * edge points to.
1962 *
1963 */
1964 /// file offset to lazy binding info
1965 pub export_off: U32<E>,
1966 /// size of lazy binding infs
1967 pub export_size: U32<E>,
1968 }
1969
1970 /*
1971 * The following are used to encode rebasing information
1972 */
1973 pub const REBASE_TYPE_POINTER: u8 = 1;
1974 pub const REBASE_TYPE_TEXT_ABSOLUTE32: u8 = 2;
1975 pub const REBASE_TYPE_TEXT_PCREL32: u8 = 3;
1976
1977 pub const REBASE_OPCODE_MASK: u8 = 0xF0;
1978 pub const REBASE_IMMEDIATE_MASK: u8 = 0x0F;
1979 pub const REBASE_OPCODE_DONE: u8 = 0x00;
1980 pub const REBASE_OPCODE_SET_TYPE_IMM: u8 = 0x10;
1981 pub const REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: u8 = 0x20;
1982 pub const REBASE_OPCODE_ADD_ADDR_ULEB: u8 = 0x30;
1983 pub const REBASE_OPCODE_ADD_ADDR_IMM_SCALED: u8 = 0x40;
1984 pub const REBASE_OPCODE_DO_REBASE_IMM_TIMES: u8 = 0x50;
1985 pub const REBASE_OPCODE_DO_REBASE_ULEB_TIMES: u8 = 0x60;
1986 pub const REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB: u8 = 0x70;
1987 pub const REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB: u8 = 0x80;
1988
1989 /*
1990 * The following are used to encode binding information
1991 */
1992 pub const BIND_TYPE_POINTER: u8 = 1;
1993 pub const BIND_TYPE_TEXT_ABSOLUTE32: u8 = 2;
1994 pub const BIND_TYPE_TEXT_PCREL32: u8 = 3;
1995
1996 pub const BIND_SPECIAL_DYLIB_SELF: i8 = 0;
1997 pub const BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE: i8 = -1;
1998 pub const BIND_SPECIAL_DYLIB_FLAT_LOOKUP: i8 = -2;
1999 pub const BIND_SPECIAL_DYLIB_WEAK_LOOKUP: i8 = -3;
2000
2001 pub const BIND_SYMBOL_FLAGS_WEAK_IMPORT: u8 = 0x1;
2002 pub const BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION: u8 = 0x8;
2003
2004 pub const BIND_OPCODE_MASK: u8 = 0xF0;
2005 pub const BIND_IMMEDIATE_MASK: u8 = 0x0F;
2006 pub const BIND_OPCODE_DONE: u8 = 0x00;
2007 pub const BIND_OPCODE_SET_DYLIB_ORDINAL_IMM: u8 = 0x10;
2008 pub const BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB: u8 = 0x20;
2009 pub const BIND_OPCODE_SET_DYLIB_SPECIAL_IMM: u8 = 0x30;
2010 pub const BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM: u8 = 0x40;
2011 pub const BIND_OPCODE_SET_TYPE_IMM: u8 = 0x50;
2012 pub const BIND_OPCODE_SET_ADDEND_SLEB: u8 = 0x60;
2013 pub const BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: u8 = 0x70;
2014 pub const BIND_OPCODE_ADD_ADDR_ULEB: u8 = 0x80;
2015 pub const BIND_OPCODE_DO_BIND: u8 = 0x90;
2016 pub const BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB: u8 = 0xA0;
2017 pub const BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED: u8 = 0xB0;
2018 pub const BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB: u8 = 0xC0;
2019 pub const BIND_OPCODE_THREADED: u8 = 0xD0;
2020 pub const BIND_SUBOPCODE_THREADED_SET_BIND_ORDINAL_TABLE_SIZE_ULEB: u8 = 0x00;
2021 pub const BIND_SUBOPCODE_THREADED_APPLY: u8 = 0x01;
2022
2023 /*
2024 * The following are used on the flags byte of a terminal node
2025 * in the export information.
2026 */
2027 pub const EXPORT_SYMBOL_FLAGS_KIND_MASK: u32 = 0x03;
2028 pub const EXPORT_SYMBOL_FLAGS_KIND_REGULAR: u32 = 0x00;
2029 pub const EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL: u32 = 0x01;
2030 pub const EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE: u32 = 0x02;
2031 pub const EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION: u32 = 0x04;
2032 pub const EXPORT_SYMBOL_FLAGS_REEXPORT: u32 = 0x08;
2033 pub const EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER: u32 = 0x10;
2034
2035 /*
2036 * The LinkerOptionCommand contains linker options embedded in object files.
2037 */
2038 #[derive(Debug, Clone, Copy)]
2039 #[repr(C)]
2040 pub struct LinkerOptionCommand<E: Endian> {
2041 /// LC_LINKER_OPTION only used in MH_OBJECT filetypes
2042 pub cmd: U32<E>,
2043 pub cmdsize: U32<E>,
2044 /// number of strings
2045 pub count: U32<E>,
2046 /* concatenation of zero terminated UTF8 strings.
2047 Zero filled at end to align */
2048 }
2049
2050 /*
2051 * The SymSegCommand contains the offset and size of the GNU style
2052 * symbol table information as described in the header file <symseg.h>.
2053 * The symbol roots of the symbol segments must also be aligned properly
2054 * in the file. So the requirement of keeping the offsets aligned to a
2055 * multiple of a 4 bytes translates to the length field of the symbol
2056 * roots also being a multiple of a long. Also the padding must again be
2057 * zeroed. (THIS IS OBSOLETE and no longer supported).
2058 */
2059 #[derive(Debug, Clone, Copy)]
2060 #[repr(C)]
2061 pub struct SymSegCommand<E: Endian> {
2062 /// LC_SYMSEG
2063 pub cmd: U32<E>,
2064 /// sizeof(struct SymSegCommand)
2065 pub cmdsize: U32<E>,
2066 /// symbol segment offset
2067 pub offset: U32<E>,
2068 /// symbol segment size in bytes
2069 pub size: U32<E>,
2070 }
2071
2072 /*
2073 * The IdentCommand contains a free format string table following the
2074 * IdentCommand structure. The strings are null terminated and the size of
2075 * the command is padded out with zero bytes to a multiple of 4 bytes/
2076 * (THIS IS OBSOLETE and no longer supported).
2077 */
2078 #[derive(Debug, Clone, Copy)]
2079 #[repr(C)]
2080 pub struct IdentCommand<E: Endian> {
2081 /// LC_IDENT
2082 pub cmd: U32<E>,
2083 /// strings that follow this command
2084 pub cmdsize: U32<E>,
2085 }
2086
2087 /*
2088 * The FvmfileCommand contains a reference to a file to be loaded at the
2089 * specified virtual address. (Presently, this command is reserved for
2090 * internal use. The kernel ignores this command when loading a program into
2091 * memory).
2092 */
2093 #[derive(Debug, Clone, Copy)]
2094 #[repr(C)]
2095 pub struct FvmfileCommand<E: Endian> {
2096 /// LC_FVMFILE
2097 pub cmd: U32<E>,
2098 /// includes pathname string
2099 pub cmdsize: U32<E>,
2100 /// files pathname
2101 pub name: LcStr<E>,
2102 /// files virtual address
2103 pub header_addr: U32<E>,
2104 }
2105
2106 /*
2107 * The EntryPointCommand is a replacement for thread_command.
2108 * It is used for main executables to specify the location (file offset)
2109 * of main(). If -stack_size was used at link time, the stacksize
2110 * field will contain the stack size need for the main thread.
2111 */
2112 #[derive(Debug, Clone, Copy)]
2113 #[repr(C)]
2114 pub struct EntryPointCommand<E: Endian> {
2115 /// LC_MAIN only used in MH_EXECUTE filetypes
2116 pub cmd: U32<E>,
2117 /// 24
2118 pub cmdsize: U32<E>,
2119 /// file (__TEXT) offset of main()
2120 pub entryoff: U64<E>,
2121 /// if not zero, initial stack size
2122 pub stacksize: U64<E>,
2123 }
2124
2125 /*
2126 * The SourceVersionCommand is an optional load command containing
2127 * the version of the sources used to build the binary.
2128 */
2129 #[derive(Debug, Clone, Copy)]
2130 #[repr(C)]
2131 pub struct SourceVersionCommand<E: Endian> {
2132 /// LC_SOURCE_VERSION
2133 pub cmd: U32<E>,
2134 /// 16
2135 pub cmdsize: U32<E>,
2136 /// A.B.C.D.E packed as a24.b10.c10.d10.e10
2137 pub version: U64<E>,
2138 }
2139
2140 /*
2141 * The LC_DATA_IN_CODE load commands uses a linkedit_data_command
2142 * to point to an array of DataInCodeEntry entries. Each entry
2143 * describes a range of data in a code section.
2144 */
2145 #[derive(Debug, Clone, Copy)]
2146 #[repr(C)]
2147 pub struct DataInCodeEntry<E: Endian> {
2148 /// from mach_header to start of data range
2149 pub offset: U32<E>,
2150 /// number of bytes in data range
2151 pub length: U16<E>,
2152 /// a DICE_KIND_* value
2153 pub kind: U16<E>,
2154 }
2155 pub const DICE_KIND_DATA: u32 = 0x0001;
2156 pub const DICE_KIND_JUMP_TABLE8: u32 = 0x0002;
2157 pub const DICE_KIND_JUMP_TABLE16: u32 = 0x0003;
2158 pub const DICE_KIND_JUMP_TABLE32: u32 = 0x0004;
2159 pub const DICE_KIND_ABS_JUMP_TABLE32: u32 = 0x0005;
2160
2161 /*
2162 * Sections of type S_THREAD_LOCAL_VARIABLES contain an array
2163 * of TlvDescriptor structures.
2164 */
2165 /* TODO:
2166 #[derive(Debug, Clone, Copy)]
2167 #[repr(C)]
2168 pub struct TlvDescriptor<E: Endian>
2169 {
2170 void* (*thunk)(struct TlvDescriptor*);
2171 unsigned long key;
2172 unsigned long offset;
2173 }
2174 */
2175
2176 /*
2177 * LC_NOTE commands describe a region of arbitrary data included in a Mach-O
2178 * file. Its initial use is to record extra data in MH_CORE files.
2179 */
2180 #[derive(Debug, Clone, Copy)]
2181 #[repr(C)]
2182 pub struct NoteCommand<E: Endian> {
2183 /// LC_NOTE
2184 pub cmd: U32<E>,
2185 /// sizeof(struct NoteCommand)
2186 pub cmdsize: U32<E>,
2187 /// owner name for this LC_NOTE
2188 pub data_owner: [u8; 16],
2189 /// file offset of this data
2190 pub offset: U64<E>,
2191 /// length of data region
2192 pub size: U64<E>,
2193 }
2194
2195 // Definitions from "/usr/include/mach-o/nlist.h".
2196
2197 #[derive(Debug, Clone, Copy)]
2198 #[repr(C)]
2199 pub struct Nlist32<E: Endian> {
2200 /// index into the string table
2201 pub n_strx: U32<E>,
2202 /// type flag, see below
2203 pub n_type: u8,
2204 /// section number or NO_SECT
2205 pub n_sect: u8,
2206 /// see <mach-o/stab.h>
2207 pub n_desc: U16<E>,
2208 /// value of this symbol (or stab offset)
2209 pub n_value: U32<E>,
2210 }
2211
2212 /*
2213 * This is the symbol table entry structure for 64-bit architectures.
2214 */
2215 #[derive(Debug, Clone, Copy)]
2216 #[repr(C)]
2217 pub struct Nlist64<E: Endian> {
2218 /// index into the string table
2219 pub n_strx: U32<E>,
2220 /// type flag, see below
2221 pub n_type: u8,
2222 /// section number or NO_SECT
2223 pub n_sect: u8,
2224 /// see <mach-o/stab.h>
2225 pub n_desc: U16<E>,
2226 /// value of this symbol (or stab offset)
2227 // Note: 4 byte alignment has been observed in practice.
2228 pub n_value: U64Bytes<E>,
2229 }
2230
2231 /*
2232 * Symbols with a index into the string table of zero (n_un.n_strx == 0) are
2233 * defined to have a null, "", name. Therefore all string indexes to non null
2234 * names must not have a zero string index. This is bit historical information
2235 * that has never been well documented.
2236 */
2237
2238 /*
2239 * The n_type field really contains four fields:
2240 * unsigned char N_STAB:3,
2241 * N_PEXT:1,
2242 * N_TYPE:3,
2243 * N_EXT:1;
2244 * which are used via the following masks.
2245 */
2246 /// if any of these bits set, a symbolic debugging entry
2247 pub const N_STAB: u8 = 0xe0;
2248 /// private external symbol bit
2249 pub const N_PEXT: u8 = 0x10;
2250 /// mask for the type bits
2251 pub const N_TYPE: u8 = 0x0e;
2252 /// external symbol bit, set for external symbols
2253 pub const N_EXT: u8 = 0x01;
2254
2255 /*
2256 * Only symbolic debugging entries have some of the N_STAB bits set and if any
2257 * of these bits are set then it is a symbolic debugging entry (a stab). In
2258 * which case then the values of the n_type field (the entire field) are given
2259 * in <mach-o/stab.h>
2260 */
2261
2262 /*
2263 * Values for N_TYPE bits of the n_type field.
2264 */
2265 /// undefined, n_sect == NO_SECT
2266 pub const N_UNDF: u8 = 0x0;
2267 /// absolute, n_sect == NO_SECT
2268 pub const N_ABS: u8 = 0x2;
2269 /// defined in section number n_sect
2270 pub const N_SECT: u8 = 0xe;
2271 /// prebound undefined (defined in a dylib)
2272 pub const N_PBUD: u8 = 0xc;
2273 /// indirect
2274 pub const N_INDR: u8 = 0xa;
2275
2276 /*
2277 * If the type is N_INDR then the symbol is defined to be the same as another
2278 * symbol. In this case the n_value field is an index into the string table
2279 * of the other symbol's name. When the other symbol is defined then they both
2280 * take on the defined type and value.
2281 */
2282
2283 /*
2284 * If the type is N_SECT then the n_sect field contains an ordinal of the
2285 * section the symbol is defined in. The sections are numbered from 1 and
2286 * refer to sections in order they appear in the load commands for the file
2287 * they are in. This means the same ordinal may very well refer to different
2288 * sections in different files.
2289 *
2290 * The n_value field for all symbol table entries (including N_STAB's) gets
2291 * updated by the link editor based on the value of it's n_sect field and where
2292 * the section n_sect references gets relocated. If the value of the n_sect
2293 * field is NO_SECT then it's n_value field is not changed by the link editor.
2294 */
2295 /// symbol is not in any section
2296 pub const NO_SECT: u8 = 0;
2297 /// 1 thru 255 inclusive
2298 pub const MAX_SECT: u8 = 255;
2299
2300 /*
2301 * Common symbols are represented by undefined (N_UNDF) external (N_EXT) types
2302 * who's values (n_value) are non-zero. In which case the value of the n_value
2303 * field is the size (in bytes) of the common symbol. The n_sect field is set
2304 * to NO_SECT. The alignment of a common symbol may be set as a power of 2
2305 * between 2^1 and 2^15 as part of the n_desc field using the macros below. If
2306 * the alignment is not set (a value of zero) then natural alignment based on
2307 * the size is used.
2308 */
2309 /* TODO:
2310 #define GET_COMM_ALIGN(n_desc) (((n_desc) >> 8) & 0x0f)
2311 #define SET_COMM_ALIGN(n_desc,align) \
2312 (n_desc) = (((n_desc) & 0xf0ff) | (((align) & 0x0f) << 8))
2313 */
2314
2315 /*
2316 * To support the lazy binding of undefined symbols in the dynamic link-editor,
2317 * the undefined symbols in the symbol table (the nlist structures) are marked
2318 * with the indication if the undefined reference is a lazy reference or
2319 * non-lazy reference. If both a non-lazy reference and a lazy reference is
2320 * made to the same symbol the non-lazy reference takes precedence. A reference
2321 * is lazy only when all references to that symbol are made through a symbol
2322 * pointer in a lazy symbol pointer section.
2323 *
2324 * The implementation of marking nlist structures in the symbol table for
2325 * undefined symbols will be to use some of the bits of the n_desc field as a
2326 * reference type. The mask REFERENCE_TYPE will be applied to the n_desc field
2327 * of an nlist structure for an undefined symbol to determine the type of
2328 * undefined reference (lazy or non-lazy).
2329 *
2330 * The constants for the REFERENCE FLAGS are propagated to the reference table
2331 * in a shared library file. In that case the constant for a defined symbol,
2332 * REFERENCE_FLAG_DEFINED, is also used.
2333 */
2334 /* Reference type bits of the n_desc field of undefined symbols */
2335 pub const REFERENCE_TYPE: u16 = 0x7;
2336 /* types of references */
2337 pub const REFERENCE_FLAG_UNDEFINED_NON_LAZY: u16 = 0;
2338 pub const REFERENCE_FLAG_UNDEFINED_LAZY: u16 = 1;
2339 pub const REFERENCE_FLAG_DEFINED: u16 = 2;
2340 pub const REFERENCE_FLAG_PRIVATE_DEFINED: u16 = 3;
2341 pub const REFERENCE_FLAG_PRIVATE_UNDEFINED_NON_LAZY: u16 = 4;
2342 pub const REFERENCE_FLAG_PRIVATE_UNDEFINED_LAZY: u16 = 5;
2343
2344 /*
2345 * To simplify stripping of objects that use are used with the dynamic link
2346 * editor, the static link editor marks the symbols defined an object that are
2347 * referenced by a dynamicly bound object (dynamic shared libraries, bundles).
2348 * With this marking strip knows not to strip these symbols.
2349 */
2350 pub const REFERENCED_DYNAMICALLY: u16 = 0x0010;
2351
2352 /*
2353 * For images created by the static link editor with the -twolevel_namespace
2354 * option in effect the flags field of the mach header is marked with
2355 * MH_TWOLEVEL. And the binding of the undefined references of the image are
2356 * determined by the static link editor. Which library an undefined symbol is
2357 * bound to is recorded by the static linker in the high 8 bits of the n_desc
2358 * field using the SET_LIBRARY_ORDINAL macro below. The ordinal recorded
2359 * references the libraries listed in the Mach-O's LC_LOAD_DYLIB,
2360 * LC_LOAD_WEAK_DYLIB, LC_REEXPORT_DYLIB, LC_LOAD_UPWARD_DYLIB, and
2361 * LC_LAZY_LOAD_DYLIB, etc. load commands in the order they appear in the
2362 * headers. The library ordinals start from 1.
2363 * For a dynamic library that is built as a two-level namespace image the
2364 * undefined references from module defined in another use the same nlist struct
2365 * an in that case SELF_LIBRARY_ORDINAL is used as the library ordinal. For
2366 * defined symbols in all images they also must have the library ordinal set to
2367 * SELF_LIBRARY_ORDINAL. The EXECUTABLE_ORDINAL refers to the executable
2368 * image for references from plugins that refer to the executable that loads
2369 * them.
2370 *
2371 * The DYNAMIC_LOOKUP_ORDINAL is for undefined symbols in a two-level namespace
2372 * image that are looked up by the dynamic linker with flat namespace semantics.
2373 * This ordinal was added as a feature in Mac OS X 10.3 by reducing the
2374 * value of MAX_LIBRARY_ORDINAL by one. So it is legal for existing binaries
2375 * or binaries built with older tools to have 0xfe (254) dynamic libraries. In
2376 * this case the ordinal value 0xfe (254) must be treated as a library ordinal
2377 * for compatibility.
2378 */
2379 /* TODO:
2380 #define GET_LIBRARY_ORDINAL(n_desc) (((n_desc) >> 8) & 0xff)
2381 #define SET_LIBRARY_ORDINAL(n_desc,ordinal) \
2382 (n_desc) = (((n_desc) & 0x00ff) | (((ordinal) & 0xff) << 8))
2383 */
2384 pub const SELF_LIBRARY_ORDINAL: u8 = 0x0;
2385 pub const MAX_LIBRARY_ORDINAL: u8 = 0xfd;
2386 pub const DYNAMIC_LOOKUP_ORDINAL: u8 = 0xfe;
2387 pub const EXECUTABLE_ORDINAL: u8 = 0xff;
2388
2389 /*
2390 * The bit 0x0020 of the n_desc field is used for two non-overlapping purposes
2391 * and has two different symbolic names, N_NO_DEAD_STRIP and N_DESC_DISCARDED.
2392 */
2393
2394 /*
2395 * The N_NO_DEAD_STRIP bit of the n_desc field only ever appears in a
2396 * relocatable .o file (MH_OBJECT filetype). And is used to indicate to the
2397 * static link editor it is never to dead strip the symbol.
2398 */
2399 /// symbol is not to be dead stripped
2400 pub const N_NO_DEAD_STRIP: u16 = 0x0020;
2401
2402 /*
2403 * The N_DESC_DISCARDED bit of the n_desc field never appears in linked image.
2404 * But is used in very rare cases by the dynamic link editor to mark an in
2405 * memory symbol as discared and longer used for linking.
2406 */
2407 /// symbol is discarded
2408 pub const N_DESC_DISCARDED: u16 = 0x0020;
2409
2410 /*
2411 * The N_WEAK_REF bit of the n_desc field indicates to the dynamic linker that
2412 * the undefined symbol is allowed to be missing and is to have the address of
2413 * zero when missing.
2414 */
2415 /// symbol is weak referenced
2416 pub const N_WEAK_REF: u16 = 0x0040;
2417
2418 /*
2419 * The N_WEAK_DEF bit of the n_desc field indicates to the static and dynamic
2420 * linkers that the symbol definition is weak, allowing a non-weak symbol to
2421 * also be used which causes the weak definition to be discared. Currently this
2422 * is only supported for symbols in coalesed sections.
2423 */
2424 /// coalesed symbol is a weak definition
2425 pub const N_WEAK_DEF: u16 = 0x0080;
2426
2427 /*
2428 * The N_REF_TO_WEAK bit of the n_desc field indicates to the dynamic linker
2429 * that the undefined symbol should be resolved using flat namespace searching.
2430 */
2431 /// reference to a weak symbol
2432 pub const N_REF_TO_WEAK: u16 = 0x0080;
2433
2434 /*
2435 * The N_ARM_THUMB_DEF bit of the n_desc field indicates that the symbol is
2436 * a defintion of a Thumb function.
2437 */
2438 /// symbol is a Thumb function (ARM)
2439 pub const N_ARM_THUMB_DEF: u16 = 0x0008;
2440
2441 /*
2442 * The N_SYMBOL_RESOLVER bit of the n_desc field indicates that the
2443 * that the function is actually a resolver function and should
2444 * be called to get the address of the real function to use.
2445 * This bit is only available in .o files (MH_OBJECT filetype)
2446 */
2447 pub const N_SYMBOL_RESOLVER: u16 = 0x0100;
2448
2449 /*
2450 * The N_ALT_ENTRY bit of the n_desc field indicates that the
2451 * symbol is pinned to the previous content.
2452 */
2453 pub const N_ALT_ENTRY: u16 = 0x0200;
2454
2455 // Definitions from "/usr/include/mach-o/stab.h".
2456
2457 /*
2458 * This file gives definitions supplementing <nlist.h> for permanent symbol
2459 * table entries of Mach-O files. Modified from the BSD definitions. The
2460 * modifications from the original definitions were changing what the values of
2461 * what was the n_other field (an unused field) which is now the n_sect field.
2462 * These modifications are required to support symbols in an arbitrary number of
2463 * sections not just the three sections (text, data and bss) in a BSD file.
2464 * The values of the defined constants have NOT been changed.
2465 *
2466 * These must have one of the N_STAB bits on. The n_value fields are subject
2467 * to relocation according to the value of their n_sect field. So for types
2468 * that refer to things in sections the n_sect field must be filled in with the
2469 * proper section ordinal. For types that are not to have their n_value field
2470 * relocatated the n_sect field must be NO_SECT.
2471 */
2472
2473 /*
2474 * Symbolic debugger symbols. The comments give the conventional use for
2475 *
2476 * .stabs "n_name", n_type, n_sect, n_desc, n_value
2477 *
2478 * where n_type is the defined constant and not listed in the comment. Other
2479 * fields not listed are zero. n_sect is the section ordinal the entry is
2480 * refering to.
2481 */
2482 /// global symbol: name,,NO_SECT,type,0
2483 pub const N_GSYM: u8 = 0x20;
2484 /// procedure name (f77 kludge): name,,NO_SECT,0,0
2485 pub const N_FNAME: u8 = 0x22;
2486 /// procedure: name,,n_sect,linenumber,address
2487 pub const N_FUN: u8 = 0x24;
2488 /// static symbol: name,,n_sect,type,address
2489 pub const N_STSYM: u8 = 0x26;
2490 /// .lcomm symbol: name,,n_sect,type,address
2491 pub const N_LCSYM: u8 = 0x28;
2492 /// begin nsect sym: 0,,n_sect,0,address
2493 pub const N_BNSYM: u8 = 0x2e;
2494 /// AST file path: name,,NO_SECT,0,0
2495 pub const N_AST: u8 = 0x32;
2496 /// emitted with gcc2_compiled and in gcc source
2497 pub const N_OPT: u8 = 0x3c;
2498 /// register sym: name,,NO_SECT,type,register
2499 pub const N_RSYM: u8 = 0x40;
2500 /// src line: 0,,n_sect,linenumber,address
2501 pub const N_SLINE: u8 = 0x44;
2502 /// end nsect sym: 0,,n_sect,0,address
2503 pub const N_ENSYM: u8 = 0x4e;
2504 /// structure elt: name,,NO_SECT,type,struct_offset
2505 pub const N_SSYM: u8 = 0x60;
2506 /// source file name: name,,n_sect,0,address
2507 pub const N_SO: u8 = 0x64;
2508 /// object file name: name,,0,0,st_mtime
2509 pub const N_OSO: u8 = 0x66;
2510 /// local sym: name,,NO_SECT,type,offset
2511 pub const N_LSYM: u8 = 0x80;
2512 /// include file beginning: name,,NO_SECT,0,sum
2513 pub const N_BINCL: u8 = 0x82;
2514 /// #included file name: name,,n_sect,0,address
2515 pub const N_SOL: u8 = 0x84;
2516 /// compiler parameters: name,,NO_SECT,0,0
2517 pub const N_PARAMS: u8 = 0x86;
2518 /// compiler version: name,,NO_SECT,0,0
2519 pub const N_VERSION: u8 = 0x88;
2520 /// compiler -O level: name,,NO_SECT,0,0
2521 pub const N_OLEVEL: u8 = 0x8A;
2522 /// parameter: name,,NO_SECT,type,offset
2523 pub const N_PSYM: u8 = 0xa0;
2524 /// include file end: name,,NO_SECT,0,0
2525 pub const N_EINCL: u8 = 0xa2;
2526 /// alternate entry: name,,n_sect,linenumber,address
2527 pub const N_ENTRY: u8 = 0xa4;
2528 /// left bracket: 0,,NO_SECT,nesting level,address
2529 pub const N_LBRAC: u8 = 0xc0;
2530 /// deleted include file: name,,NO_SECT,0,sum
2531 pub const N_EXCL: u8 = 0xc2;
2532 /// right bracket: 0,,NO_SECT,nesting level,address
2533 pub const N_RBRAC: u8 = 0xe0;
2534 /// begin common: name,,NO_SECT,0,0
2535 pub const N_BCOMM: u8 = 0xe2;
2536 /// end common: name,,n_sect,0,0
2537 pub const N_ECOMM: u8 = 0xe4;
2538 /// end common (local name): 0,,n_sect,0,address
2539 pub const N_ECOML: u8 = 0xe8;
2540 /// second stab entry with length information
2541 pub const N_LENG: u8 = 0xfe;
2542
2543 /*
2544 * for the berkeley pascal compiler, pc(1):
2545 */
2546 /// global pascal symbol: name,,NO_SECT,subtype,line
2547 pub const N_PC: u8 = 0x30;
2548
2549 // Definitions from "/usr/include/mach-o/reloc.h".
2550
2551 /// A relocation entry.
2552 ///
2553 /// Mach-O relocations have plain and scattered variants, with the
2554 /// meaning of the fields depending on the variant.
2555 ///
2556 /// This type provides functions for determining whether the relocation
2557 /// is scattered, and for accessing the fields of each variant.
2558 #[derive(Debug, Clone, Copy)]
2559 #[repr(C)]
2560 pub struct Relocation<E: Endian> {
2561 pub r_word0: U32<E>,
2562 pub r_word1: U32<E>,
2563 }
2564
2565 impl<E: Endian> Relocation<E> {
2566 /// Determine whether this is a scattered relocation.
2567 #[inline]
r_scattered(self, endian: E, cputype: u32) -> bool2568 pub fn r_scattered(self, endian: E, cputype: u32) -> bool {
2569 if cputype == CPU_TYPE_X86_64 {
2570 false
2571 } else {
2572 self.r_word0.get(endian) & R_SCATTERED != 0
2573 }
2574 }
2575
2576 /// Return the fields of a plain relocation.
info(self, endian: E) -> RelocationInfo2577 pub fn info(self, endian: E) -> RelocationInfo {
2578 let r_address = self.r_word0.get(endian);
2579 let r_word1 = self.r_word1.get(endian);
2580 if endian.is_little_endian() {
2581 RelocationInfo {
2582 r_address,
2583 r_symbolnum: r_word1 & 0x00ff_ffff,
2584 r_pcrel: ((r_word1 >> 24) & 0x1) != 0,
2585 r_length: ((r_word1 >> 25) & 0x3) as u8,
2586 r_extern: ((r_word1 >> 27) & 0x1) != 0,
2587 r_type: (r_word1 >> 28) as u8,
2588 }
2589 } else {
2590 RelocationInfo {
2591 r_address,
2592 r_symbolnum: r_word1 >> 8,
2593 r_pcrel: ((r_word1 >> 7) & 0x1) != 0,
2594 r_length: ((r_word1 >> 5) & 0x3) as u8,
2595 r_extern: ((r_word1 >> 4) & 0x1) != 0,
2596 r_type: (r_word1 & 0xf) as u8,
2597 }
2598 }
2599 }
2600
2601 /// Return the fields of a scattered relocation.
scattered_info(self, endian: E) -> ScatteredRelocationInfo2602 pub fn scattered_info(self, endian: E) -> ScatteredRelocationInfo {
2603 let r_word0 = self.r_word0.get(endian);
2604 let r_value = self.r_word1.get(endian);
2605 ScatteredRelocationInfo {
2606 r_address: r_word0 & 0x00ff_ffff,
2607 r_type: ((r_word0 >> 24) & 0xf) as u8,
2608 r_length: ((r_word0 >> 28) & 0x3) as u8,
2609 r_pcrel: ((r_word0 >> 30) & 0x1) != 0,
2610 r_value,
2611 }
2612 }
2613 }
2614
2615 /*
2616 * Format of a relocation entry of a Mach-O file. Modified from the 4.3BSD
2617 * format. The modifications from the original format were changing the value
2618 * of the r_symbolnum field for "local" (r_extern == 0) relocation entries.
2619 * This modification is required to support symbols in an arbitrary number of
2620 * sections not just the three sections (text, data and bss) in a 4.3BSD file.
2621 * Also the last 4 bits have had the r_type tag added to them.
2622 */
2623
2624 #[derive(Debug, Clone, Copy)]
2625 pub struct RelocationInfo {
2626 /// offset in the section to what is being relocated
2627 pub r_address: u32,
2628 /// symbol index if r_extern == 1 or section ordinal if r_extern == 0
2629 pub r_symbolnum: u32,
2630 /// was relocated pc relative already
2631 pub r_pcrel: bool,
2632 /// 0=byte, 1=word, 2=long, 3=quad
2633 pub r_length: u8,
2634 /// does not include value of sym referenced
2635 pub r_extern: bool,
2636 /// if not 0, machine specific relocation type
2637 pub r_type: u8,
2638 }
2639
2640 impl RelocationInfo {
2641 /// Combine the fields into a `Relocation`.
relocation<E: Endian>(self, endian: E) -> Relocation<E>2642 pub fn relocation<E: Endian>(self, endian: E) -> Relocation<E> {
2643 let r_word0 = U32::new(endian, self.r_address);
2644 let r_word1 = U32::new(
2645 endian,
2646 if endian.is_little_endian() {
2647 self.r_symbolnum & 0x00ff_ffff
2648 | u32::from(self.r_pcrel) << 24
2649 | u32::from(self.r_length & 0x3) << 25
2650 | u32::from(self.r_extern) << 27
2651 | u32::from(self.r_type) << 28
2652 } else {
2653 self.r_symbolnum >> 8
2654 | u32::from(self.r_pcrel) << 7
2655 | u32::from(self.r_length & 0x3) << 5
2656 | u32::from(self.r_extern) << 4
2657 | u32::from(self.r_type) & 0xf
2658 },
2659 );
2660 Relocation { r_word0, r_word1 }
2661 }
2662 }
2663
2664 /// absolute relocation type for Mach-O files
2665 pub const R_ABS: u8 = 0;
2666
2667 /*
2668 * The r_address is not really the address as it's name indicates but an offset.
2669 * In 4.3BSD a.out objects this offset is from the start of the "segment" for
2670 * which relocation entry is for (text or data). For Mach-O object files it is
2671 * also an offset but from the start of the "section" for which the relocation
2672 * entry is for. See comments in <mach-o/loader.h> about the r_address feild
2673 * in images for used with the dynamic linker.
2674 *
2675 * In 4.3BSD a.out objects if r_extern is zero then r_symbolnum is an ordinal
2676 * for the segment the symbol being relocated is in. These ordinals are the
2677 * symbol types N_TEXT, N_DATA, N_BSS or N_ABS. In Mach-O object files these
2678 * ordinals refer to the sections in the object file in the order their section
2679 * structures appear in the headers of the object file they are in. The first
2680 * section has the ordinal 1, the second 2, and so on. This means that the
2681 * same ordinal in two different object files could refer to two different
2682 * sections. And further could have still different ordinals when combined
2683 * by the link-editor. The value R_ABS is used for relocation entries for
2684 * absolute symbols which need no further relocation.
2685 */
2686
2687 /*
2688 * For RISC machines some of the references are split across two instructions
2689 * and the instruction does not contain the complete value of the reference.
2690 * In these cases a second, or paired relocation entry, follows each of these
2691 * relocation entries, using a PAIR r_type, which contains the other part of the
2692 * reference not contained in the instruction. This other part is stored in the
2693 * pair's r_address field. The exact number of bits of the other part of the
2694 * reference store in the r_address field is dependent on the particular
2695 * relocation type for the particular architecture.
2696 */
2697
2698 /*
2699 * To make scattered loading by the link editor work correctly "local"
2700 * relocation entries can't be used when the item to be relocated is the value
2701 * of a symbol plus an offset (where the resulting expresion is outside the
2702 * block the link editor is moving, a blocks are divided at symbol addresses).
2703 * In this case. where the item is a symbol value plus offset, the link editor
2704 * needs to know more than just the section the symbol was defined. What is
2705 * needed is the actual value of the symbol without the offset so it can do the
2706 * relocation correctly based on where the value of the symbol got relocated to
2707 * not the value of the expression (with the offset added to the symbol value).
2708 * So for the NeXT 2.0 release no "local" relocation entries are ever used when
2709 * there is a non-zero offset added to a symbol. The "external" and "local"
2710 * relocation entries remain unchanged.
2711 *
2712 * The implemention is quite messy given the compatibility with the existing
2713 * relocation entry format. The ASSUMPTION is that a section will never be
2714 * bigger than 2**24 - 1 (0x00ffffff or 16,777,215) bytes. This assumption
2715 * allows the r_address (which is really an offset) to fit in 24 bits and high
2716 * bit of the r_address field in the relocation_info structure to indicate
2717 * it is really a scattered_relocation_info structure. Since these are only
2718 * used in places where "local" relocation entries are used and not where
2719 * "external" relocation entries are used the r_extern field has been removed.
2720 *
2721 * For scattered loading to work on a RISC machine where some of the references
2722 * are split across two instructions the link editor needs to be assured that
2723 * each reference has a unique 32 bit reference (that more than one reference is
2724 * NOT sharing the same high 16 bits for example) so it move each referenced
2725 * item independent of each other. Some compilers guarantees this but the
2726 * compilers don't so scattered loading can be done on those that do guarantee
2727 * this.
2728 */
2729
2730 /// Bit set in `Relocation::r_word0` for scattered relocations.
2731 pub const R_SCATTERED: u32 = 0x8000_0000;
2732
2733 #[derive(Debug, Clone, Copy)]
2734 pub struct ScatteredRelocationInfo {
2735 /// offset in the section to what is being relocated
2736 pub r_address: u32,
2737 /// if not 0, machine specific relocation type
2738 pub r_type: u8,
2739 /// 0=byte, 1=word, 2=long, 3=quad
2740 pub r_length: u8,
2741 /// was relocated pc relative already
2742 pub r_pcrel: bool,
2743 /// the value the item to be relocated is refering to (without any offset added)
2744 pub r_value: u32,
2745 }
2746
2747 impl ScatteredRelocationInfo {
2748 /// Combine the fields into a `Relocation`.
relocation<E: Endian>(self, endian: E) -> Relocation<E>2749 pub fn relocation<E: Endian>(self, endian: E) -> Relocation<E> {
2750 let r_word0 = U32::new(
2751 endian,
2752 self.r_address & 0x00ff_ffff
2753 | u32::from(self.r_type & 0xf) << 24
2754 | u32::from(self.r_length & 0x3) << 28
2755 | u32::from(self.r_pcrel) << 30
2756 | R_SCATTERED,
2757 );
2758 let r_word1 = U32::new(endian, self.r_value);
2759 Relocation { r_word0, r_word1 }
2760 }
2761 }
2762
2763 /*
2764 * Relocation types used in a generic implementation. Relocation entries for
2765 * normal things use the generic relocation as discribed above and their r_type
2766 * is GENERIC_RELOC_VANILLA (a value of zero).
2767 *
2768 * Another type of generic relocation, GENERIC_RELOC_SECTDIFF, is to support
2769 * the difference of two symbols defined in different sections. That is the
2770 * expression "symbol1 - symbol2 + constant" is a relocatable expression when
2771 * both symbols are defined in some section. For this type of relocation the
2772 * both relocations entries are scattered relocation entries. The value of
2773 * symbol1 is stored in the first relocation entry's r_value field and the
2774 * value of symbol2 is stored in the pair's r_value field.
2775 *
2776 * A special case for a prebound lazy pointer is needed to beable to set the
2777 * value of the lazy pointer back to its non-prebound state. This is done
2778 * using the GENERIC_RELOC_PB_LA_PTR r_type. This is a scattered relocation
2779 * entry where the r_value feild is the value of the lazy pointer not prebound.
2780 */
2781 /// generic relocation as discribed above
2782 pub const GENERIC_RELOC_VANILLA: u8 = 0;
2783 /// Only follows a GENERIC_RELOC_SECTDIFF
2784 pub const GENERIC_RELOC_PAIR: u8 = 1;
2785 pub const GENERIC_RELOC_SECTDIFF: u8 = 2;
2786 /// prebound lazy pointer
2787 pub const GENERIC_RELOC_PB_LA_PTR: u8 = 3;
2788 pub const GENERIC_RELOC_LOCAL_SECTDIFF: u8 = 4;
2789 /// thread local variables
2790 pub const GENERIC_RELOC_TLV: u8 = 5;
2791
2792 // Definitions from "/usr/include/mach-o/arm/reloc.h".
2793
2794 /*
2795 * Relocation types used in the arm implementation. Relocation entries for
2796 * things other than instructions use the same generic relocation as discribed
2797 * in <mach-o/reloc.h> and their r_type is ARM_RELOC_VANILLA, one of the
2798 * *_SECTDIFF or the *_PB_LA_PTR types. The rest of the relocation types are
2799 * for instructions. Since they are for instructions the r_address field
2800 * indicates the 32 bit instruction that the relocation is to be preformed on.
2801 */
2802 /// generic relocation as discribed above
2803 pub const ARM_RELOC_VANILLA: u8 = 0;
2804 /// the second relocation entry of a pair
2805 pub const ARM_RELOC_PAIR: u8 = 1;
2806 /// a PAIR follows with subtract symbol value
2807 pub const ARM_RELOC_SECTDIFF: u8 = 2;
2808 /// like ARM_RELOC_SECTDIFF, but the symbol referenced was local.
2809 pub const ARM_RELOC_LOCAL_SECTDIFF: u8 = 3;
2810 /// prebound lazy pointer
2811 pub const ARM_RELOC_PB_LA_PTR: u8 = 4;
2812 /// 24 bit branch displacement (to a word address)
2813 pub const ARM_RELOC_BR24: u8 = 5;
2814 /// 22 bit branch displacement (to a half-word address)
2815 pub const ARM_THUMB_RELOC_BR22: u8 = 6;
2816 /// obsolete - a thumb 32-bit branch instruction possibly needing page-spanning branch workaround
2817 pub const ARM_THUMB_32BIT_BRANCH: u8 = 7;
2818
2819 /*
2820 * For these two r_type relocations they always have a pair following them
2821 * and the r_length bits are used differently. The encoding of the
2822 * r_length is as follows:
2823 * low bit of r_length:
2824 * 0 - :lower16: for movw instructions
2825 * 1 - :upper16: for movt instructions
2826 * high bit of r_length:
2827 * 0 - arm instructions
2828 * 1 - thumb instructions
2829 * the other half of the relocated expression is in the following pair
2830 * relocation entry in the the low 16 bits of r_address field.
2831 */
2832 pub const ARM_RELOC_HALF: u8 = 8;
2833 pub const ARM_RELOC_HALF_SECTDIFF: u8 = 9;
2834
2835 // Definitions from "/usr/include/mach-o/arm64/reloc.h".
2836
2837 /*
2838 * Relocation types used in the arm64 implementation.
2839 */
2840 /// for pointers
2841 pub const ARM64_RELOC_UNSIGNED: u8 = 0;
2842 /// must be followed by a ARM64_RELOC_UNSIGNED
2843 pub const ARM64_RELOC_SUBTRACTOR: u8 = 1;
2844 /// a B/BL instruction with 26-bit displacement
2845 pub const ARM64_RELOC_BRANCH26: u8 = 2;
2846 /// pc-rel distance to page of target
2847 pub const ARM64_RELOC_PAGE21: u8 = 3;
2848 /// offset within page, scaled by r_length
2849 pub const ARM64_RELOC_PAGEOFF12: u8 = 4;
2850 /// pc-rel distance to page of GOT slot
2851 pub const ARM64_RELOC_GOT_LOAD_PAGE21: u8 = 5;
2852 /// offset within page of GOT slot, scaled by r_length
2853 pub const ARM64_RELOC_GOT_LOAD_PAGEOFF12: u8 = 6;
2854 /// for pointers to GOT slots
2855 pub const ARM64_RELOC_POINTER_TO_GOT: u8 = 7;
2856 /// pc-rel distance to page of TLVP slot
2857 pub const ARM64_RELOC_TLVP_LOAD_PAGE21: u8 = 8;
2858 /// offset within page of TLVP slot, scaled by r_length
2859 pub const ARM64_RELOC_TLVP_LOAD_PAGEOFF12: u8 = 9;
2860 /// must be followed by PAGE21 or PAGEOFF12
2861 pub const ARM64_RELOC_ADDEND: u8 = 10;
2862
2863 // An arm64e authenticated pointer.
2864 //
2865 // Represents a pointer to a symbol (like ARM64_RELOC_UNSIGNED).
2866 // Additionally, the resulting pointer is signed. The signature is
2867 // specified in the target location: the addend is restricted to the lower
2868 // 32 bits (instead of the full 64 bits for ARM64_RELOC_UNSIGNED):
2869 //
2870 // |63|62|61-51|50-49| 48 |47 - 32|31 - 0|
2871 // | 1| 0| 0 | key | addr | discriminator | addend |
2872 //
2873 // The key is one of:
2874 // IA: 00 IB: 01
2875 // DA: 10 DB: 11
2876 //
2877 // The discriminator field is used as extra signature diversification.
2878 //
2879 // The addr field indicates whether the target address should be blended
2880 // into the discriminator.
2881 //
2882 pub const ARM64_RELOC_AUTHENTICATED_POINTER: u8 = 11;
2883
2884 // Definitions from "/usr/include/mach-o/ppc/reloc.h".
2885
2886 /*
2887 * Relocation types used in the ppc implementation. Relocation entries for
2888 * things other than instructions use the same generic relocation as discribed
2889 * above and their r_type is RELOC_VANILLA. The rest of the relocation types
2890 * are for instructions. Since they are for instructions the r_address field
2891 * indicates the 32 bit instruction that the relocation is to be preformed on.
2892 * The fields r_pcrel and r_length are ignored for non-RELOC_VANILLA r_types
2893 * except for PPC_RELOC_BR14.
2894 *
2895 * For PPC_RELOC_BR14 if the r_length is the unused value 3, then the branch was
2896 * statically predicted setting or clearing the Y-bit based on the sign of the
2897 * displacement or the opcode. If this is the case the static linker must flip
2898 * the value of the Y-bit if the sign of the displacement changes for non-branch
2899 * always conditions.
2900 */
2901 /// generic relocation as discribed above
2902 pub const PPC_RELOC_VANILLA: u8 = 0;
2903 /// the second relocation entry of a pair
2904 pub const PPC_RELOC_PAIR: u8 = 1;
2905 /// 14 bit branch displacement (to a word address)
2906 pub const PPC_RELOC_BR14: u8 = 2;
2907 /// 24 bit branch displacement (to a word address)
2908 pub const PPC_RELOC_BR24: u8 = 3;
2909 /// a PAIR follows with the low half
2910 pub const PPC_RELOC_HI16: u8 = 4;
2911 /// a PAIR follows with the high half
2912 pub const PPC_RELOC_LO16: u8 = 5;
2913 /// Same as the RELOC_HI16 except the low 16 bits and the high 16 bits are added together
2914 /// with the low 16 bits sign extened first. This means if bit 15 of the low 16 bits is
2915 /// set the high 16 bits stored in the instruction will be adjusted.
2916 pub const PPC_RELOC_HA16: u8 = 6;
2917 /// Same as the LO16 except that the low 2 bits are not stored in the instruction and are
2918 /// always zero. This is used in double word load/store instructions.
2919 pub const PPC_RELOC_LO14: u8 = 7;
2920 /// a PAIR follows with subtract symbol value
2921 pub const PPC_RELOC_SECTDIFF: u8 = 8;
2922 /// prebound lazy pointer
2923 pub const PPC_RELOC_PB_LA_PTR: u8 = 9;
2924 /// section difference forms of above. a PAIR
2925 pub const PPC_RELOC_HI16_SECTDIFF: u8 = 10;
2926 /// follows these with subtract symbol value
2927 pub const PPC_RELOC_LO16_SECTDIFF: u8 = 11;
2928 pub const PPC_RELOC_HA16_SECTDIFF: u8 = 12;
2929 pub const PPC_RELOC_JBSR: u8 = 13;
2930 pub const PPC_RELOC_LO14_SECTDIFF: u8 = 14;
2931 /// like PPC_RELOC_SECTDIFF, but the symbol referenced was local.
2932 pub const PPC_RELOC_LOCAL_SECTDIFF: u8 = 15;
2933
2934 // Definitions from "/usr/include/mach-o/x86_64/reloc.h".
2935
2936 /*
2937 * Relocations for x86_64 are a bit different than for other architectures in
2938 * Mach-O: Scattered relocations are not used. Almost all relocations produced
2939 * by the compiler are external relocations. An external relocation has the
2940 * r_extern bit set to 1 and the r_symbolnum field contains the symbol table
2941 * index of the target label.
2942 *
2943 * When the assembler is generating relocations, if the target label is a local
2944 * label (begins with 'L'), then the previous non-local label in the same
2945 * section is used as the target of the external relocation. An addend is used
2946 * with the distance from that non-local label to the target label. Only when
2947 * there is no previous non-local label in the section is an internal
2948 * relocation used.
2949 *
2950 * The addend (i.e. the 4 in _foo+4) is encoded in the instruction (Mach-O does
2951 * not have RELA relocations). For PC-relative relocations, the addend is
2952 * stored directly in the instruction. This is different from other Mach-O
2953 * architectures, which encode the addend minus the current section offset.
2954 *
2955 * The relocation types are:
2956 *
2957 * X86_64_RELOC_UNSIGNED // for absolute addresses
2958 * X86_64_RELOC_SIGNED // for signed 32-bit displacement
2959 * X86_64_RELOC_BRANCH // a CALL/JMP instruction with 32-bit displacement
2960 * X86_64_RELOC_GOT_LOAD // a MOVQ load of a GOT entry
2961 * X86_64_RELOC_GOT // other GOT references
2962 * X86_64_RELOC_SUBTRACTOR // must be followed by a X86_64_RELOC_UNSIGNED
2963 *
2964 * The following are sample assembly instructions, followed by the relocation
2965 * and section content they generate in an object file:
2966 *
2967 * call _foo
2968 * r_type=X86_64_RELOC_BRANCH, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
2969 * E8 00 00 00 00
2970 *
2971 * call _foo+4
2972 * r_type=X86_64_RELOC_BRANCH, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
2973 * E8 04 00 00 00
2974 *
2975 * movq _foo@GOTPCREL(%rip), %rax
2976 * r_type=X86_64_RELOC_GOT_LOAD, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
2977 * 48 8B 05 00 00 00 00
2978 *
2979 * pushq _foo@GOTPCREL(%rip)
2980 * r_type=X86_64_RELOC_GOT, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
2981 * FF 35 00 00 00 00
2982 *
2983 * movl _foo(%rip), %eax
2984 * r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
2985 * 8B 05 00 00 00 00
2986 *
2987 * movl _foo+4(%rip), %eax
2988 * r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
2989 * 8B 05 04 00 00 00
2990 *
2991 * movb $0x12, _foo(%rip)
2992 * r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
2993 * C6 05 FF FF FF FF 12
2994 *
2995 * movl $0x12345678, _foo(%rip)
2996 * r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
2997 * C7 05 FC FF FF FF 78 56 34 12
2998 *
2999 * .quad _foo
3000 * r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
3001 * 00 00 00 00 00 00 00 00
3002 *
3003 * .quad _foo+4
3004 * r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
3005 * 04 00 00 00 00 00 00 00
3006 *
3007 * .quad _foo - _bar
3008 * r_type=X86_64_RELOC_SUBTRACTOR, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_bar
3009 * r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
3010 * 00 00 00 00 00 00 00 00
3011 *
3012 * .quad _foo - _bar + 4
3013 * r_type=X86_64_RELOC_SUBTRACTOR, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_bar
3014 * r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
3015 * 04 00 00 00 00 00 00 00
3016 *
3017 * .long _foo - _bar
3018 * r_type=X86_64_RELOC_SUBTRACTOR, r_length=2, r_extern=1, r_pcrel=0, r_symbolnum=_bar
3019 * r_type=X86_64_RELOC_UNSIGNED, r_length=2, r_extern=1, r_pcrel=0, r_symbolnum=_foo
3020 * 00 00 00 00
3021 *
3022 * lea L1(%rip), %rax
3023 * r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_prev
3024 * 48 8d 05 12 00 00 00
3025 * // assumes _prev is the first non-local label 0x12 bytes before L1
3026 *
3027 * lea L0(%rip), %rax
3028 * r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=0, r_pcrel=1, r_symbolnum=3
3029 * 48 8d 05 56 00 00 00
3030 * // assumes L0 is in third section and there is no previous non-local label.
3031 * // The rip-relative-offset of 0x00000056 is L0-address_of_next_instruction.
3032 * // address_of_next_instruction is the address of the relocation + 4.
3033 *
3034 * add $6,L0(%rip)
3035 * r_type=X86_64_RELOC_SIGNED_1, r_length=2, r_extern=0, r_pcrel=1, r_symbolnum=3
3036 * 83 05 18 00 00 00 06
3037 * // assumes L0 is in third section and there is no previous non-local label.
3038 * // The rip-relative-offset of 0x00000018 is L0-address_of_next_instruction.
3039 * // address_of_next_instruction is the address of the relocation + 4 + 1.
3040 * // The +1 comes from SIGNED_1. This is used because the relocation is not
3041 * // at the end of the instruction.
3042 *
3043 * .quad L1
3044 * r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_prev
3045 * 12 00 00 00 00 00 00 00
3046 * // assumes _prev is the first non-local label 0x12 bytes before L1
3047 *
3048 * .quad L0
3049 * r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=0, r_pcrel=0, r_symbolnum=3
3050 * 56 00 00 00 00 00 00 00
3051 * // assumes L0 is in third section, has an address of 0x00000056 in .o
3052 * // file, and there is no previous non-local label
3053 *
3054 * .quad _foo - .
3055 * r_type=X86_64_RELOC_SUBTRACTOR, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_prev
3056 * r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
3057 * EE FF FF FF FF FF FF FF
3058 * // assumes _prev is the first non-local label 0x12 bytes before this
3059 * // .quad
3060 *
3061 * .quad _foo - L1
3062 * r_type=X86_64_RELOC_SUBTRACTOR, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_prev
3063 * r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
3064 * EE FF FF FF FF FF FF FF
3065 * // assumes _prev is the first non-local label 0x12 bytes before L1
3066 *
3067 * .quad L1 - _prev
3068 * // No relocations. This is an assembly time constant.
3069 * 12 00 00 00 00 00 00 00
3070 * // assumes _prev is the first non-local label 0x12 bytes before L1
3071 *
3072 *
3073 *
3074 * In final linked images, there are only two valid relocation kinds:
3075 *
3076 * r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_pcrel=0, r_extern=1, r_symbolnum=sym_index
3077 * This tells dyld to add the address of a symbol to a pointer sized (8-byte)
3078 * piece of data (i.e on disk the 8-byte piece of data contains the addend). The
3079 * r_symbolnum contains the index into the symbol table of the target symbol.
3080 *
3081 * r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_pcrel=0, r_extern=0, r_symbolnum=0
3082 * This tells dyld to adjust the pointer sized (8-byte) piece of data by the amount
3083 * the containing image was loaded from its base address (e.g. slide).
3084 *
3085 */
3086 /// for absolute addresses
3087 pub const X86_64_RELOC_UNSIGNED: u8 = 0;
3088 /// for signed 32-bit displacement
3089 pub const X86_64_RELOC_SIGNED: u8 = 1;
3090 /// a CALL/JMP instruction with 32-bit displacement
3091 pub const X86_64_RELOC_BRANCH: u8 = 2;
3092 /// a MOVQ load of a GOT entry
3093 pub const X86_64_RELOC_GOT_LOAD: u8 = 3;
3094 /// other GOT references
3095 pub const X86_64_RELOC_GOT: u8 = 4;
3096 /// must be followed by a X86_64_RELOC_UNSIGNED
3097 pub const X86_64_RELOC_SUBTRACTOR: u8 = 5;
3098 /// for signed 32-bit displacement with a -1 addend
3099 pub const X86_64_RELOC_SIGNED_1: u8 = 6;
3100 /// for signed 32-bit displacement with a -2 addend
3101 pub const X86_64_RELOC_SIGNED_2: u8 = 7;
3102 /// for signed 32-bit displacement with a -4 addend
3103 pub const X86_64_RELOC_SIGNED_4: u8 = 8;
3104 /// for thread local variables
3105 pub const X86_64_RELOC_TLV: u8 = 9;
3106
3107 unsafe_impl_pod!(FatHeader, FatArch32, FatArch64,);
3108 unsafe_impl_endian_pod!(
3109 MachHeader32,
3110 MachHeader64,
3111 LoadCommand,
3112 LcStr,
3113 SegmentCommand32,
3114 SegmentCommand64,
3115 Section32,
3116 Section64,
3117 Fvmlib,
3118 FvmlibCommand,
3119 Dylib,
3120 DylibCommand,
3121 SubFrameworkCommand,
3122 SubClientCommand,
3123 SubUmbrellaCommand,
3124 SubLibraryCommand,
3125 PreboundDylibCommand,
3126 DylinkerCommand,
3127 ThreadCommand,
3128 RoutinesCommand,
3129 RoutinesCommand_64,
3130 SymtabCommand,
3131 DysymtabCommand,
3132 DylibTableOfContents,
3133 DylibModule32,
3134 DylibModule64,
3135 DylibReference,
3136 TwolevelHintsCommand,
3137 TwolevelHint,
3138 PrebindCksumCommand,
3139 UuidCommand,
3140 RpathCommand,
3141 LinkeditDataCommand,
3142 EncryptionInfoCommand,
3143 EncryptionInfoCommand64,
3144 VersionMinCommand,
3145 BuildVersionCommand,
3146 BuildToolVersion,
3147 DyldInfoCommand,
3148 LinkerOptionCommand,
3149 SymSegCommand,
3150 IdentCommand,
3151 FvmfileCommand,
3152 EntryPointCommand,
3153 SourceVersionCommand,
3154 DataInCodeEntry,
3155 //TlvDescriptor,
3156 NoteCommand,
3157 Nlist32,
3158 Nlist64,
3159 Relocation,
3160 );
3161