1 /**
2  * This file describes the format of Mach-O object files.
3  *
4  * D header file for `mach-o/loader.h` from the macOS 10.15 SDK.
5  *
6  * Copyright: Copyright Digital Mars 2010-2019.
7  * License: $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
8  * Authors: Jacob Carlborg
9  * Version: Initial created: Feb 20, 2010-2018
10  * Source: $(DRUNTIMESRC core/sys/darwin/mach/_loader.d)
11  */
12 module core.sys.darwin.mach.loader;
13 
14 import core.stdc.config;
15 
16 version (CoreDdoc)
17 {
18     /**
19      * The 32-bit mach header appears at the very beginning of the object file
20      * for 32-bit architectures.
21      */
22     struct mach_header
23     {
24         /// Mach magic number identifier.
25         uint magic;
26 
27         /// Cpu specifier.
28         int cputype;
29 
30         /// Machine specifier.
31         int cpusubtype;
32 
33         /// Type of file.
34         uint filetype;
35 
36         /// Number of load commands.
37         uint ncmds;
38 
39         /// The size of all the load commands.
40         uint sizeofcmds;
41 
42         /// Flags.
43         uint flags;
44     }
45 
46     /// Constant for the magic field of the mach_header (32-bit architectures)
47     enum
48     {
49         /// The mach magic number
50         MH_MAGIC,
51 
52         /// NXSwapInt(MH_MAGIC)
53         MH_CIGAM
54     }
55 
56     /**
57      * The 64-bit mach header appears at the very beginning of object files for
58      * 64-bit architectures.
59      */
60     struct mach_header_64
61     {
62         /// Mach magic number identifier.
63         uint magic;
64 
65         /// Cpu specifier.
66         int cputype;
67 
68         /// Machine specifier.
69         int cpusubtype;
70 
71         /// Type of file.
72         uint filetype;
73 
74         /// Number of load commands.
75         uint ncmds;
76 
77         /// The size of all the load commands.
78         uint sizeofcmds;
79 
80         /// Flags.
81         uint flags;
82 
83         /// Reserved.
84         uint reserved;
85     }
86 
87     /// Constant for the magic field of the mach_header_64 (64-bit architectures)
88     enum
89     {
90         /// The 64-bit mach magic number.
91         MH_MAGIC_64,
92 
93         /// NXSwapInt(MH_MAGIC_64).
94         MH_CIGAM_64
95     }
96 
97     /**
98      * The layout of the file depends on the filetype. For all but the MH_OBJECT
99      * file type the segments are padded out and aligned on a segment alignment
100      * boundary for efficient demand pageing. The MH_EXECUTE, MH_FVMLIB,
101      * MH_DYLIB, MH_DYLINKER and MH_BUNDLE file types also have the headers
102      * included as part of their first segment.
103      *
104      * The file type MH_OBJECT is a compact format intended as output of the
105      * assembler and input (and possibly output) of the link editor (the .o
106      * format). All sections are in one unnamed segment with no segment padding.
107      * This format is used as an executable format when the file is so small the
108      * segment padding greatly increases its size.
109      *
110      * The file type MH_PRELOAD is an executable format intended for things that
111      * are not executed under the kernel (proms, stand alones, kernels, etc).
112      * The format can be executed under the kernel but may demand paged it and
113      * not preload it before execution.
114      *
115      * A core file is in MH_CORE format and can be any in an arbitrary legal
116      * Mach-O file.
117      *
118      * Constants for the filetype field of the mach_header
119      */
120     enum
121     {
122         /// Relocatable object file.
123         MH_OBJECT,
124 
125         /// Demand paged executable file.
126         MH_EXECUTE,
127 
128         /// Fixed VM shared library file.
129         MH_FVMLIB,
130 
131         /// Core file.
132         MH_CORE,
133 
134         /// Preloaded executable file.
135         MH_PRELOAD,
136 
137         /// Dynamically bound shared library.
138         MH_DYLIB,
139 
140         /// Dynamic link editor.
141         MH_DYLINKER,
142 
143         /// Dynamically bound bundle file.
144         MH_BUNDLE,
145 
146         /// Shared library stub for static linking only, no section contents.
147         MH_DYLIB_STUB,
148 
149         /// Companion file with only debug sections.
150         MH_DSYM,
151 
152         /// X86_64 kexts.
153         MH_KEXT_BUNDLE
154     }
155 
156 
157     /// Constants for the flags field of the mach_header
158     enum
159     {
160         /// The object file has no undefined references.
161         MH_NOUNDEFS,
162 
163         /**
164          * The object file is the output of an incremental link against a base
165          * file and can't be link edited again.
166          */
167         MH_INCRLINK,
168 
169         /**
170          * The object file is input for the dynamic linker and can't be
171          * statically link edited again.
172          */
173         MH_DYLDLINK,
174 
175         /**
176          * The object file's undefined references are bound by the dynamic
177          * linker when loaded.
178          */
179         MH_BINDATLOAD,
180 
181         /// The file has its dynamic undefined references prebound.
182         MH_PREBOUND,
183 
184         /// The file has its read-only and read-write segments split.
185         MH_SPLIT_SEGS,
186 
187         /**
188          * The shared library init routine is to be run lazily via catching
189          * memory faults to its writeable segments (obsolete).
190          */
191         MH_LAZY_INIT,
192 
193         /// The image is using two-level name space bindings.
194         MH_TWOLEVEL,
195 
196         /// The executable is forcing all images to use flat name space bindings.
197         MH_FORCE_FLAT,
198 
199         /**
200          * This umbrella guarantees no multiple definitions of symbols in its
201          * sub-images so the two-level namespace hints can always be used.
202          */
203         MH_NOMULTIDEFS,
204 
205         /// Do not have dyld notify the prebinding agent about this executable.
206         MH_NOFIXPREBINDING,
207 
208         /**
209          * The binary is not prebound but can have its prebinding redone. only
210          * used when MH_PREBOUND is not set.
211          */
212         MH_PREBINDABLE,
213 
214         /**
215          * Indicates that this binary binds to all two-level namespace modules
216          * of its dependent libraries. only used when MH_PREBINDABLE and
217          * MH_TWOLEVEL are both set.
218          */
219         MH_ALLMODSBOUND,
220 
221         /**
222          * Safe to divide up the sections into sub-sections via symbols for dead
223          * code stripping.
224          */
225         MH_SUBSECTIONS_VIA_SYMBOLS,
226 
227         /// The binary has been canonicalized via the unprebind operation.
228         MH_CANONICAL,
229 
230         /// The final linked image contains external weak symbols.
231         MH_WEAK_DEFINES,
232 
233         /// The final linked image uses weak symbols.
234         MH_BINDS_TO_WEAK,
235 
236 
237 
238         /**
239          * When this bit is set, all stacks in the task will be given stack
240          * execution privilege. Only used in MH_EXECUTE filetypes.
241          */
242         MH_ALLOW_STACK_EXECUTION,
243 
244         /**
245          * When this bit is set, the binary declares it is safe for use in
246          * processes with uid zero.
247          */
248         MH_ROOT_SAFE,
249 
250 
251 
252         /**
253          * When this bit is set, the binary declares it is safe for use in
254          * processes when issetugid() is true.
255          */
256         MH_SETUID_SAFE,
257 
258 
259 
260         /**
261          * When this bit is set on a dylib, the static linker does not need to
262          * examine dependent dylibs to see if any are re-exported.
263          */
264         MH_NO_REEXPORTED_DYLIBS,
265 
266         /**
267          * When this bit is set, the OS will load the main executable at a
268          * random address. Only used in MH_EXECUTE filetypes.
269          */
270         MH_PIE,
271 
272         /**
273          * Only for use on dylibs. When linking against a dylib that has this
274          * bit set, the static linker will automatically not create a
275          * LC_LOAD_DYLIB load command to the dylib if no symbols are being
276          * referenced from the dylib..
277          */
278         MH_DEAD_STRIPPABLE_DYLIB,
279 
280         /// Contains a section of type S_THREAD_LOCAL_VARIABLES.
281         MH_HAS_TLV_DESCRIPTORS,
282 
283 
284 
285         /**
286          * When this bit is set, the OS will run the main executable with a
287          * non-executable heap even on platforms (e.g. i386) that don't require
288          * it. Only used in MH_EXECUTE filetypes.
289          */
290         MH_NO_HEAP_EXECUTION,
291 
292 
293 
294         /// The code was linked for use in an application extension..
295         MH_APP_EXTENSION_SAFE,
296 
297 
298 
299         /**
300          * The external symbols listed in the nlist symbol table do not include
301          * all the symbols listed in the dyld info.
302          */
303         MH_NLIST_OUTOFSYNC_WITH_DYLDINFO,
304 
305         /**
306          * Allow LC_MIN_VERSION_MACOS and LC_BUILD_VERSION load commands with
307          * the platforms macOS, iOSMac, iOSSimulator, tvOSSimulator and
308          * watchOSSimulator.
309          */
310         MH_SIM_SUPPORT,
311 
312         /**
313          * Only for use on dylibs. When this bit is set, the dylib is part of
314          * the dyld shared cache, rather than loose in the filesystem.
315          */
316         MH_DYLIB_IN_CACHE
317     }
318 
319     /**
320      * The load commands directly follow the mach_header. The total size of all
321      * of the commands is given by the sizeofcmds field in the mach_header. All
322      * load commands must have as their first two fields cmd and cmdsize. The
323      * cmd field is filled in with a constant for that command type. Each
324      * command type has a structure specifically for it. The cmdsize field is
325      * the size in bytes of the particular load command structure plus anything
326      * that follows it that is a part of the load command
327      * (i.e. section structures, strings, etc.). To advance to the next load
328      * command the cmdsize can be added to the offset or pointer of the current
329      * load command. The cmdsize for 32-bit architectures MUST be a multiple of
330      * 4 bytes and for 64-bit architectures MUST be a multiple of 8 bytes
331      * (these are forever the maximum alignment of any load commands). The
332      * padded bytes must be zero. All tables in the object file must also
333      * follow these rules so the file can be memory mapped. Otherwise the
334      * pointers to these tables will not work well or at all on some machines.
335      * With all padding zeroed like objects will compare byte for byte.
336      */
337     struct load_command
338     {
339         /// Type of load command.
340         uint cmd;
341 
342         /// Total size of command in bytes.
343         uint cmdsize;
344     }
345 
346     /**
347      * After MacOS X 10.1 when a new load command is added that is required to
348      * be understood by the dynamic linker for the image to execute properly the
349      * LC_REQ_DYLD bit will be or'ed into the load command constant. If the
350      * dynamic linker sees such a load command it it does not understand will
351      * issue a "unknown load command required for execution" error and refuse to
352      * use the image. Other load commands without this bit that are not
353      * understood will simply be ignored.
354      */
355     enum LC_REQ_DYLD;
356 
357     /// Constants for the cmd field of all load commands, the type.
358     enum
359     {
360         /// Segment of this file to be mapped.
361         LC_SEGMENT,
362 
363         /// Link-edit stab symbol table info.
364         LC_SYMTAB,
365 
366         /// Link-edit gdb symbol table info (obsolete).
367         LC_SYMSEG,
368 
369         /// Thread.
370         LC_THREAD,
371 
372         /// Unix thread (includes a stack).
373         LC_UNIXTHREAD,
374 
375         /// Load a specified fixed VM shared library.
376         LC_LOADFVMLIB,
377 
378         /// Fixed VM shared library identification.
379         LC_IDFVMLIB,
380 
381         /// Object identification info (obsolete).
382         LC_IDENT,
383 
384         /// Fixed VM file inclusion (internal use).
385         LC_FVMFILE,
386 
387         /// Prepage command (internal use).
388         LC_PREPAGE,
389 
390         /// Dynamic link-edit symbol table info.
391         LC_DYSYMTAB,
392 
393         /// Load a dynamically linked shared library.
394         LC_LOAD_DYLIB,
395 
396         /// Dynamically linked shared lib ident.
397         LC_ID_DYLIB,
398 
399         /// Load a dynamic linker.
400         LC_LOAD_DYLINKER,
401 
402         /// Dynamic linker identification.
403         LC_ID_DYLINKER,
404 
405         /// Modules prebound for a dynamically linked shared library.
406         LC_PREBOUND_DYLIB,
407 
408         /// Image routines.
409         LC_ROUTINES,
410 
411         /// Sub framework.
412         LC_SUB_FRAMEWORK,
413 
414         /// Sub umbrella.
415         LC_SUB_UMBRELLA,
416 
417         /// Sub client.
418         LC_SUB_CLIENT,
419 
420         /// Sub library.
421         LC_SUB_LIBRARY,
422 
423         /// Two-level namespace lookup hints.
424         LC_TWOLEVEL_HINTS,
425 
426         /// Prebind checksum.
427         LC_PREBIND_CKSUM
428     }
429 
430 
431     /**
432      * Load a dynamically linked shared library that is allowed to be missing
433      * (all symbols are weak imported).
434      */
435     ///
436     enum LC_LOAD_WEAK_DYLIB;
437 
438     ///
439     enum
440     {
441         /// 64-bit segment of this file to be mapped.
442         LC_SEGMENT_64,
443 
444         /// 64-bit image routines.
445         LC_ROUTINES_64,
446 
447         /// The uuid.
448         LC_UUID,
449 
450         /// Runpath additions.
451         LC_RPATH,
452 
453         /// Local of code signature.
454         LC_CODE_SIGNATURE,
455 
456         /// Local of info to split segments.
457         LC_SEGMENT_SPLIT_INFO,
458 
459         /// Load and re-export dylib.
460         LC_REEXPORT_DYLIB,
461 
462         /// Delay load of dylib until first use.
463         LC_LAZY_LOAD_DYLIB,
464 
465         /// Encrypted segment information.
466         LC_ENCRYPTION_INFO,
467 
468         /// Compressed dyld information.
469         LC_DYLD_INFO,
470 
471         /// Compressed dyld information only.
472         LC_DYLD_INFO_ONLY,
473 
474         /// Load upward dylib.
475         LC_LOAD_UPWARD_DYLIB,
476 
477         /// Build for MacOSX min OS version.
478         LC_VERSION_MIN_MACOSX,
479 
480         /// Build for iPhoneOS min OS version.
481         LC_VERSION_MIN_IPHONEOS,
482 
483         /// Compressed table of function start addresses.
484         LC_FUNCTION_STARTS,
485 
486         /// String for dyld to treat like environment variable.
487         LC_DYLD_ENVIRONMENT,
488 
489         /// Replacement for LC_UNIXTHREAD.
490         LC_MAIN,
491 
492         /// Table of non-instructions in __text.
493         LC_DATA_IN_CODE,
494 
495         /// Source version used to build binary.
496         LC_SOURCE_VERSION,
497 
498         /// Code signing DRs copied from linked dylibs.
499         LC_DYLIB_CODE_SIGN_DRS,
500 
501         /// 64-bit encrypted segment information.
502         LC_ENCRYPTION_INFO_64,
503 
504         /// Linker options in MH_OBJECT files.
505         LC_LINKER_OPTION,
506 
507         /// Optimization hints in MH_OBJECT files.
508         LC_LINKER_OPTIMIZATION_HINT,
509 
510         /// Build for AppleTV min OS version.
511         LC_VERSION_MIN_TVOS,
512 
513         /// Build for Watch min OS version.
514         LC_VERSION_MIN_WATCHOS,
515 
516         /// Arbitrary data included within a Mach-O file.
517         LC_NOTE,
518 
519         /// Build for platform min OS version.
520         LC_BUILD_VERSION,
521 
522         /// Used with linkedit_data_command, payload is trie.
523         LC_DYLD_EXPORTS_TRIE,
524 
525         /// Used with linkedit_data_command.
526         LC_DYLD_CHAINED_FIXUPS
527     }
528 
529 
530     /**
531      * A variable length string in a load command is represented by an lc_str
532      * union. The strings are stored just after the load command structure and
533      * the offset is from the start of the load command structure. The size
534      * of the string is reflected in the cmdsize field of the load command.
535      * Once again any padded bytes to bring the cmdsize field to a multiple
536      * of 4 bytes must be zero.
537      */
538     union lc_str
539     {
540         /// Offset to the string.
541         uint offset;
542 
543         /// Pointer to the string (only available on non 64 bit platforms).
544         char* ptr;
545     }
546 
547     /**
548      * The segment load command indicates that a part of this file is to be
549      * mapped into the task's address space. The size of this segment in memory,
550      * vmsize, maybe equal to or larger than the amount to map from this file,
551      * filesize. The file is mapped starting at fileoff to the beginning of
552      * the segment in memory, vmaddr. The rest of the memory of the segment,
553      * if any, is allocated zero fill on demand. The segment's maximum virtual
554      * memory protection and initial virtual memory protection are specified
555      * by the maxprot and initprot fields. If the segment has sections then the
556      * section structures directly follow the segment command and their size is
557      * reflected in cmdsize.
558      */
559     struct segment_command
560     {
561         /// LC_SEGMENT.
562         uint cmd;
563 
564         /// Includes sizeof section structs.
565         uint cmdsize;
566 
567         /// Segment name.
568         char[16] segname;
569 
570         /// Memory address of this segment.
571         uint vmaddr;
572 
573         /// Memory size of this segment.
574         uint vmsize;
575 
576         /// File offset of this segment.
577         uint fileoff;
578 
579         /// Amount to map from the file.
580         uint filesize;
581 
582         /// Maximum VM protection.
583         int maxprot;
584 
585         /// Initial VM protection.
586         int initprot;
587 
588         /// Number of sections in segment.
589         uint nsects;
590 
591         /// Flags.
592         uint flags;
593     }
594 
595     /*
596      * The 64-bit segment load command indicates that a part of this file is to
597      * be mapped into a 64-bit task's address space. If the 64-bit segment has
598      * sections then section_64 structures directly follow the 64-bit segment
599      * command and their size is reflected in cmdsize.
600      */
601     struct segment_command_64
602     {
603         /// LC_SEGMENT_64.
604         uint cmd;
605 
606         /// Includes sizeof section_64 structs.
607         uint cmdsize;
608 
609         /// Segment name.
610         char[16] segname;
611 
612         /// Memory address of this segment.
613         ulong vmaddr;
614 
615         /// Memory size of this segment.
616         ulong vmsize;
617 
618         /// File offset of this segment.
619         ulong fileoff;
620 
621         /// Amount to map from the file.
622         ulong filesize;
623 
624         /// Maximum VM protection.
625         int maxprot;
626 
627         /// Initial VM protection.
628         int initprot;
629 
630         /// Number of sections in segment.
631         uint nsects;
632 
633         /// Flags.
634         uint flags;
635     }
636 
637     /// Constants for the flags field of the segment_command.
638     enum
639     {
640         /**
641          * The file contents for this segment is for the high part of the VM
642          * space, the low part is zero filled (for stacks in core files).
643          */
644         SG_HIGHVM,
645 
646         /**
647          * This segment is the VM that is allocated by a fixed VM library,
648          * for overlap checking in the link editor.
649          */
650         SG_FVMLIB,
651 
652         /**
653          * This segment has nothing that was relocated in it and nothing
654          * relocated to it, that is it maybe safely replaced without relocation.
655          */
656         SG_NORELOC,
657 
658         /**
659          * This segment is protected.
660          *
661          * If the segment starts at file offset 0, the first page of the segment
662          * is not protected. All other pages of the segment are protected.
663          */
664         SG_PROTECTED_VERSION_1,
665 
666         /// This segment is made read-only after fixups.
667         SG_READ_ONLY
668     }
669 
670 
671     /**
672      * A segment is made up of zero or more sections. Non-MH_OBJECT files have
673      * all of their segments with the proper sections in each, and padded to the
674      * specified segment alignment when produced by the link editor. The first
675      * segment of a MH_EXECUTE and MH_FVMLIB format file contains the
676      * mach_header and load commands of the object file before its first
677      * section. The zero fill sections are always last in their segment
678      * (in all formats). This allows the zeroroed segment padding to be mapped
679      * into memory where zero fill sections might be. The gigabyte zero fill
680      * sections, those with the section type S_GB_ZEROFILL, can only be in a
681      * segment with sections of this type. These segments are then placed after
682      * all other segments.
683      *
684      * The MH_OBJECT format has all of its sections in one segment for
685      * compactness. There is no padding to a specified segment boundary and the
686      * mach_header and load commands are not part of the segment.
687      *
688      * Sections with the same section name, sectname, going into the same
689      * segment, segname, are combined by the link editor. The resulting section,
690      * is aligned to the maximum alignment of the combined sections and is the
691      * new section's alignment. The combined sections are aligned to their
692      * original alignment in the combined section. Any padded bytes to get the
693      * specified alignment are zeroed.
694      *
695      * The format of the relocation entries referenced by the reloff and nreloc
696      * fields of the section structure for mach object files is described in the
697      * header file <reloc.h>.
698      */
699     struct section
700     {
701         /// Name of this section.
702         char[16] sectname;
703 
704         /// Segment this section goes in.
705         char[16] segname;
706 
707         /// Memory address of this section.
708         uint addr;
709 
710         /// Size in bytes of this section.
711         uint size;
712 
713         /// File offset of this section.
714         uint offset;
715 
716         /// Section alignment (power of 2).
717         uint align_;
718 
719         /// File offset of relocation entries.
720         uint reloff;
721 
722         /// Number of relocation entries.
723         uint nreloc;
724 
725         /// Flags (section type and attributes).
726         uint flags;
727 
728         /// Reserved (for offset or index).
729         uint reserved1;
730 
731         /// Reserved (for count or sizeof).
732         uint reserved2;
733     }
734 
735     ///
736     struct section_64
737     {
738         /// Name of this section.
739         char[16] sectname;
740 
741         /// Segment this section goes in.
742         char[16] segname;
743 
744         /// Memory address of this section.
745         ulong addr;
746 
747         /// Size in bytes of this section.
748         ulong size;
749 
750         /// File offset of this section.
751         uint offset;
752 
753         /// Section alignment (power of 2).
754         uint align_;
755 
756         /// File offset of relocation entries.
757         uint reloff;
758 
759         /// Number of relocation entries.
760         uint nreloc;
761 
762         /// Flags (section type and attributes).
763         uint flags;
764 
765         /// Reserved (for offset or index).
766         uint reserved1;
767 
768         /// Reserved (for count or sizeof).
769         uint reserved2;
770 
771         /// Reserved.
772         uint reserved3;
773     }
774 
775     /**
776      * The flags field of a section structure is separated into two parts a section
777      * type and section attributes. The section types are mutually exclusive (it
778      * can only have one type) but the section attributes are not (it may have more
779      * than one attribute).
780      */
781     enum
782     {
783         /// 256 section types.
784         SECTION_TYPE,
785 
786         /// 24 section attributes.
787         SECTION_ATTRIBUTES
788     }
789 
790     /// Constants for the type of a section.
791     enum
792     {
793         /// Regular section.
794         S_REGULAR,
795 
796         /// Zero fill on demand section.
797         S_ZEROFILL,
798 
799         /// Section with only literal C strings.
800         S_CSTRING_LITERALS,
801 
802         /// Section with only 4 byte literals.
803         S_4BYTE_LITERALS,
804 
805         /// Section with only 8 byte literals.
806         S_8BYTE_LITERALS,
807 
808         /// Section with only pointers to literals.
809         S_LITERAL_POINTERS,
810 
811         /**
812          * Section with only non-lazy symbol pointers.
813          *
814          * For the two types of symbol pointers sections and the symbol stubs
815          * section they have indirect symbol table entries. For each of the
816          * entries in the section the indirect symbol table entries, in
817          * corresponding order in the indirect symbol table, start at the index
818          * stored in the reserved1 field of the section structure. Since the
819          * indirect symbol table entries correspond to the entries in the
820          * section the number of indirect symbol table entries is inferred from
821          * the size of the section divided by the size of the entries in the
822          * section. For symbol pointers sections the size of the entries in the
823          * section is 4 bytes and for symbol stubs sections the byte size of the
824          * stubs is stored in the reserved2 field of the section structure.
825          */
826         S_NON_LAZY_SYMBOL_POINTERS,
827 
828         /// Section with only lazy symbol pointers.
829         S_LAZY_SYMBOL_POINTERS,
830 
831         /// Section with only symbol stubs, byte size of stub in the reserved2 field.
832         S_SYMBOL_STUBS,
833 
834         /// Section with only function pointers for initialization.
835         S_MOD_INIT_FUNC_POINTERS,
836 
837         /// Section with only function pointers for termination.
838         S_MOD_TERM_FUNC_POINTERS,
839 
840         /// Section contains symbols that are to be coalesced.
841         S_COALESCED,
842 
843         /// Zero fill on demand section (that can be larger than 4 gigabytes).
844         S_GB_ZEROFILL,
845 
846         /// Section with only pairs of function pointers for interposing.
847         S_INTERPOSING,
848 
849         /// Section with only 16 byte literals.
850         S_16BYTE_LITERALS,
851 
852         /// Section contains DTrace Object Format.
853         S_DTRACE_DOF,
854 
855         /// Section with only lazy symbol pointers to lazy loaded dylibs.
856         S_LAZY_DYLIB_SYMBOL_POINTERS,
857 
858 
859 
860         // Section types to support thread local variables.
861 
862         /// Template of initial values for TLVs.
863         S_THREAD_LOCAL_REGULAR,
864 
865         /// Template of initial values for TLVs.
866         S_THREAD_LOCAL_ZEROFILL,
867 
868         /// TLV descriptors.
869         S_THREAD_LOCAL_VARIABLES,
870 
871         /// Pointers to TLV descriptors.
872         S_THREAD_LOCAL_VARIABLE_POINTERS,
873 
874         /// Functions to call to initialize TLV values.
875         S_THREAD_LOCAL_INIT_FUNCTION_POINTERS,
876 
877         /// 32-bit offsets to initializers.
878         S_INIT_FUNC_OFFSETS
879     }
880 
881     /**
882      * Constants for the section attributes part of the flags field of a section
883      * structure.
884      */
885     enum
886     {
887         /// User setable attributes.
888         SECTION_ATTRIBUTES_USR,
889 
890         /// Section contains only true machine instructions.
891         S_ATTR_PURE_INSTRUCTIONS,
892 
893         /// Section contains coalesced symbols that are not to be in a ranlib table of contents.
894         S_ATTR_NO_TOC,
895 
896         /// Ok to strip static symbols in this section in files with the MH_DYLDLINK flag.
897         S_ATTR_STRIP_STATIC_SYMS,
898 
899         /// No dead stripping.
900         S_ATTR_NO_DEAD_STRIP,
901 
902         /// Blocks are live if they reference live blocks.
903         S_ATTR_LIVE_SUPPORT,
904 
905         /// Used with i386 code stubs written on by dyld.
906         S_ATTR_SELF_MODIFYING_CODE,
907 
908         /**
909          * A debug section.
910          *
911          * If a segment contains any sections marked with S_ATTR_DEBUG then all
912          * sections in that segment must have this attribute. No section other
913          * than a section marked with this attribute may reference the contents
914          * of this section. A section with this attribute may contain no symbols
915          * and must have a section type S_REGULAR. The static linker will not
916          * copy section contents from sections with this attribute into its
917          * output file. These sections generally contain DWARF debugging info.
918          */
919         S_ATTR_DEBUG,
920 
921         /// System setable attributes.
922         SECTION_ATTRIBUTES_SYS,
923 
924         /// Section contains some machine instructions.
925         S_ATTR_SOME_INSTRUCTIONS,
926 
927         /// Section has external relocation entries.
928         S_ATTR_EXT_RELOC,
929 
930         /// Section has local relocation entries.
931         S_ATTR_LOC_RELOC
932     }
933 
934     /**
935      * The names of segments and sections in them are mostly meaningless to the
936      * link-editor. But there are few things to support traditional UNIX
937      * executables that require the link-editor and assembler to use some names
938      * agreed upon by convention.
939      *
940      * The initial protection of the "__TEXT" segment has write protection
941      * turned off (not writeable).
942      *
943      * The link-editor will allocate common symbols at the end of the "__common"
944      * section in the "__DATA" segment. It will create the section and segment
945      * if needed.
946      *
947      * The currently known segment names and the section names in those segments.
948      */
949     enum
950     {
951         /**
952          * The pagezero segment which has no protections and catches NULL
953          * references for MH_EXECUTE files.
954          */
955         SEG_PAGEZERO,
956 
957 
958 
959         /// The tradition UNIX text segment.
960         SEG_TEXT,
961 
962         /// The real text part of the text section no headers, and no padding.
963         SECT_TEXT,
964 
965         /// The fvmlib initialization section.
966         SECT_FVMLIB_INIT0,
967 
968         /// The section following the fvmlib initialization section.
969         SECT_FVMLIB_INIT1,
970 
971 
972 
973         /// The tradition UNIX data segment.
974         SEG_DATA,
975 
976         /// The real initialized data section no padding, no bss overlap.
977         SECT_DATA,
978 
979         /// The real uninitialized data section no padding.
980         SECT_BSS,
981 
982         /// The section common symbols are allocated in by the link editor.
983         SECT_COMMON,
984 
985 
986 
987         /// Objective-C runtime segment.
988         SEG_OBJC,
989 
990         /// Symbol table.
991         SECT_OBJC_SYMBOLS,
992 
993         /// Module information.
994         SECT_OBJC_MODULES,
995 
996         /// String table.
997         SECT_OBJC_STRINGS,
998 
999         /// String table.
1000         SECT_OBJC_REFS,
1001 
1002 
1003 
1004         /// The icon segment.
1005         SEG_ICON,
1006 
1007         /// The icon headers.
1008         SECT_ICON_HEADER,
1009 
1010         /// The icons in tiff format.
1011         SECT_ICON_TIFF,
1012 
1013 
1014 
1015         /**
1016          * The segment containing all structs created and maintained by the link
1017          * editor. Created with -seglinkedit option to ld(1) for MH_EXECUTE and
1018          * FVMLIB file types only.
1019          */
1020         SEG_LINKEDIT,
1021 
1022 
1023         /// The unix stack segment.
1024         SEG_UNIXSTACK,
1025 
1026 
1027         /**
1028          * The segment for the self (dyld) modifing code stubs that has read,
1029          * write and execute permissions.
1030          */
1031         SEG_IMPORT
1032     }
1033 
1034     /**
1035      * Fixed virtual memory shared libraries are identified by two things. The
1036      * target pathname (the name of the library as found for execution), and the
1037      * minor version number. The address of where the headers are loaded is in
1038      * header_addr. (THIS IS OBSOLETE and no longer supported).
1039      */
1040     struct fvmlib
1041     {
1042         /// Library's target pathname.
1043         lc_str name;
1044 
1045         /// Library's minor version number.
1046         uint minor_version;
1047 
1048         /// Library's header address.
1049         uint header_addr;
1050     }
1051 
1052     /**
1053      * A fixed virtual shared library (filetype == MH_FVMLIB in the mach header)
1054      * contains a fvmlib_command (cmd == LC_IDFVMLIB) to identify the library.
1055      * An object that uses a fixed virtual shared library also contains a
1056      * fvmlib_command (cmd == LC_LOADFVMLIB) for each library it uses.
1057      * (THIS IS OBSOLETE and no longer supported).
1058      */
1059     struct fvmlib_command
1060     {
1061         /// LC_IDFVMLIB or LC_LOADFVMLIB.
1062         uint cmd;
1063 
1064         /// Includes pathname string.
1065         uint cmdsize;
1066 
1067         /// The library identification.
1068         fvmlib fvmlib_;
1069     }
1070 
1071     /**
1072      * Dynamically linked shared libraries are identified by two things. The
1073      * pathname (the name of the library as found for execution), and the
1074      * compatibility version number. The pathname must match and the
1075      * compatibility number in the user of the library must be greater than or
1076      * equal to the library being used. The time stamp is used to record the
1077      * time a library was built and copied into user so it can be use to
1078      * determined if the library used at runtime is exactly the same as used to
1079      * built the program.
1080      */
1081     struct dylib
1082     {
1083         /// Library's path name.
1084         lc_str name;
1085 
1086         /// Library's build time stamp.
1087         uint timestamp;
1088 
1089         /// Library's current version number.
1090         uint current_version;
1091 
1092         /// Library's compatibility version number.
1093         uint compatibility_version;
1094     }
1095 
1096     /**
1097      * A dynamically linked shared library
1098      * (filetype == MH_DYLIB in the mach header) contains a dylib_command
1099      * (cmd == LC_ID_DYLIB) to identify the library. An object that uses a
1100      * dynamically linked shared library also contains a dylib_command
1101      * (cmd == LC_LOAD_DYLIB, LC_LOAD_WEAK_DYLIB, or LC_REEXPORT_DYLIB) for each
1102      * library it uses.
1103      */
1104     struct dylib_command
1105     {
1106         /// LC_ID_DYLIB, LC_LOAD_{,WEAK_}DYLIB, LC_REEXPORT_DYLIB.
1107         uint cmd;
1108 
1109         /// Includes pathname string.
1110         uint cmdsize;
1111 
1112         /// The library identification.
1113         dylib dylib_;
1114     }
1115 
1116     /**
1117      * A dynamically linked shared library may be a subframework of an umbrella
1118      * framework. If so it will be linked with "-umbrella umbrella_name" where
1119      * Where "umbrella_name" is the name of the umbrella framework. A
1120      * subframework can only be linked against by its umbrella framework or
1121      * other subframeworks that are part of the same umbrella framework.
1122      * Otherwise the static link editor produces an error and states to link
1123      * against the umbrella framework. The name of the umbrella framework for
1124      * subframeworks is recorded in the following structure.
1125      */
1126     struct sub_framework_command
1127     {
1128         /// LC_SUB_FRAMEWORK.
1129         uint cmd;
1130 
1131         /// Includes umbrella string.
1132         uint cmdsize;
1133 
1134         /// The umbrella framework name.
1135         lc_str umbrella;
1136     }
1137 
1138     /**
1139      * For dynamically linked shared libraries that are subframework of an
1140      * umbrella framework they can allow clients other than the umbrella
1141      * framework or other subframeworks in the same umbrella framework. To do
1142      * this the subframework is built with "-allowable_client client_name" and
1143      * an LC_SUB_CLIENT load command is created for each -allowable_client flag.
1144      * The client_name is usually a framework name. It can also be a name used
1145      * for bundles clients where the bundle is built with
1146      * "-client_name client_name".
1147      */
1148     struct sub_client_command
1149     {
1150         /// LC_SUB_CLIENT.
1151         uint cmd;
1152 
1153         /// Includes client string.
1154         uint cmdsize;
1155 
1156         /// The client name.
1157         lc_str client;
1158     }
1159 
1160     /**
1161      * A dynamically linked shared library may be a sub_umbrella of an umbrella
1162      * framework. If so it will be linked with "-sub_umbrella umbrella_name"
1163      * where "umbrella_name" is the name of the sub_umbrella framework. When
1164      * statically linking when -twolevel_namespace is in effect a twolevel
1165      * namespace umbrella framework will only cause its subframeworks and those
1166      * frameworks listed as sub_umbrella frameworks to be implicited linked in.
1167      * Any other dependent dynamic libraries will not be linked it when
1168      * -twolevel_namespace is in effect. The primary library recorded by the
1169      * static linker when resolving a symbol in these libraries will be the
1170      * umbrella framework. Zero or more sub_umbrella frameworks may be use by an
1171      * umbrella framework. The name of a sub_umbrella framework is recorded in
1172      * the following structure.
1173      */
1174     struct sub_umbrella_command
1175     {
1176         /// LC_SUB_UMBRELLA.
1177         uint cmd;
1178 
1179         /// Includes sub_umbrella string.
1180         uint cmdsize;
1181 
1182         /// The sub_umbrella framework name.
1183         lc_str sub_umbrella;
1184     }
1185 
1186     /**
1187      * A dynamically linked shared library may be a sub_library of another
1188      * shared library. If so it will be linked with "-sub_library library_name"
1189      * where "library_name" is the name of the sub_library shared library. When
1190      * statically linking when -twolevel_namespace is in effect a twolevel
1191      * namespace shared library will only cause its subframeworks and those
1192      * frameworks listed as sub_umbrella frameworks and libraries listed as
1193      * sub_libraries to be implicited linked in. Any other dependent dynamic
1194      * libraries will not be linked it when -twolevel_namespace is in effect.
1195      * The primary library recorded by the static linker when resolving a symbol
1196      * in these libraries will be the umbrella framework (or dynamic library).
1197      * Zero or more sub_library shared libraries may be use by an umbrella
1198      * framework or (or dynamic library). The name of a sub_library framework is
1199      * recorded in the following structure. For example
1200      * /usr/lib/libobjc_profile.A.dylib would be recorded as "libobjc".
1201      */
1202     struct sub_library_command
1203     {
1204         /// LC_SUB_LIBRARY.
1205         uint cmd;
1206 
1207         /// Includes sub_library string.
1208         uint cmdsize;
1209 
1210         /// The sub_library name.
1211         lc_str sub_library;
1212     }
1213 
1214     /**
1215      * A program (filetype == MH_EXECUTE) that is
1216      * prebound to its dynamic libraries has one of these for each library that
1217      * the static linker used in prebinding. It contains a bit vector for the
1218      * modules in the library. The bits indicate which modules are bound (1) and
1219      * which are not (0) from the library. The bit for module 0 is the low bit
1220      * of the first byte. So the bit for the Nth module is:
1221      * (linked_modules[N/8] >> N%8) & 1
1222      */
1223     struct prebound_dylib_command
1224     {
1225         /// LC_PREBOUND_DYLIB.
1226         uint cmd;
1227 
1228         /// Includes strings.
1229         uint cmdsize;
1230 
1231         /// Library's path name.
1232         lc_str name;
1233 
1234         /// Number of modules in library.
1235         uint nmodules;
1236 
1237         /// Bit vector of linked modules.
1238         lc_str linked_modules;
1239     }
1240 
1241     /**
1242      * A program that uses a dynamic linker contains a dylinker_command to
1243      * identify the name of the dynamic linker (LC_LOAD_DYLINKER). And a dynamic
1244      * linker contains a dylinker_command to identify the dynamic linker
1245      * (LC_ID_DYLINKER). A file can have at most one of these.
1246      * This struct is also used for the LC_DYLD_ENVIRONMENT load command and
1247      * contains string for dyld to treat like environment variable.
1248      */
1249     struct dylinker_command
1250     {
1251         /// LC_ID_DYLINKER, LC_LOAD_DYLINKER or LC_DYLD_ENVIRONMENT.
1252         uint cmd;
1253 
1254         /// Includes pathname string.
1255         uint cmdsize;
1256 
1257         /// Dynamic linker's path name.
1258         lc_str name;
1259     }
1260 
1261     /**
1262      * Thread commands contain machine-specific data structures suitable for
1263      * use in the thread state primitives. The machine specific data structures
1264      * follow the struct thread_command as follows.
1265      * Each flavor of machine specific data structure is preceded by an uint32_t
1266      * constant for the flavor of that data structure, an uint32_t that is the
1267      * count of uint32_t's of the size of the state data structure and then
1268      * the state data structure follows. This triple may be repeated for many
1269      * flavors. The constants for the flavors, counts and state data structure
1270      * definitions are expected to be in the header file <machine/thread_status.h>.
1271      * These machine specific data structures sizes must be multiples of
1272      * 4 bytes. The cmdsize reflects the total size of the thread_command
1273      * and all of the sizes of the constants for the flavors, counts and state
1274      * data structures.
1275      *
1276      * For executable objects that are unix processes there will be one
1277      * thread_command (cmd == LC_UNIXTHREAD) created for it by the link-editor.
1278      * This is the same as a LC_THREAD, except that a stack is automatically
1279      * created (based on the shell's limit for the stack size). Command
1280      * arguments and environment variables are copied onto that stack.
1281      */
1282     struct thread_command
1283     {
1284         /// LC_THREAD or  LC_UNIXTHREAD.
1285         uint cmd;
1286 
1287         /// Total size of this command.
1288         uint cmdsize;
1289     }
1290 
1291     /**
1292      * The routines command contains the address of the dynamic shared library
1293      * initialization routine and an index into the module table for the module
1294      * that defines the routine. Before any modules are used from the library
1295      * the dynamic linker fully binds the module that defines the initialization
1296      * routine and then calls it. This gets called before any module
1297      * initialization routines (used for C++ static constructors) in the library.
1298      */
1299     struct routines_command
1300     {
1301         /// LC_ROUTINES.
1302         uint cmd;
1303 
1304         /// Total size of this command.
1305         uint cmdsize;
1306 
1307         /// Address of initialization routine.
1308         uint init_address;
1309 
1310         /// Index into the module table that.
1311         uint init_module;
1312 
1313         // the init routine is defined in
1314 
1315         ///
1316         uint reserved1;
1317 
1318         ///
1319         uint reserved2;
1320 
1321         ///
1322         uint reserved3;
1323 
1324         ///
1325         uint reserved4;
1326 
1327         ///
1328         uint reserved5;
1329 
1330         ///
1331         uint reserved6;
1332     }
1333 
1334     /// The 64-bit routines command. Same use as above.
1335     struct routines_command_64
1336     {
1337         /// LC_ROUTINES_64.
1338         uint cmd;
1339 
1340         /// Total size of this command.
1341         uint cmdsize;
1342 
1343         /// Address of initialization routine.
1344         ulong init_address;
1345 
1346         /// Index into the module table that.
1347         ulong init_module;
1348 
1349         /*  the init routine is defined in */
1350 
1351         ///
1352         ulong reserved1;
1353 
1354         ///
1355         ulong reserved2;
1356 
1357         ///
1358         ulong reserved3;
1359 
1360         ///
1361         ulong reserved4;
1362 
1363         ///
1364         ulong reserved5;
1365 
1366         ///
1367         ulong reserved6;
1368     }
1369 
1370     /**
1371      * The symtab_command contains the offsets and sizes of the link-edit 4.3BSD
1372      * "stab" style symbol table information as described in the header files
1373      * <nlist.h> and <stab.h>.
1374      */
1375     struct symtab_command
1376     {
1377         /// LC_SYMTAB.
1378         uint cmd;
1379 
1380         /// Sizeof(struct symtab_command).
1381         uint cmdsize;
1382 
1383         /// Symbol table offset.
1384         uint symoff;
1385 
1386         /// Number of symbol table entries.
1387         uint nsyms;
1388 
1389         /// String table offset.
1390         uint stroff;
1391 
1392         /// String table size in bytes.
1393         uint strsize;
1394     }
1395 
1396     /**
1397      * This is the second set of the symbolic information which is used to
1398      * support the data structures for the dynamically link editor.
1399      *
1400      * The original set of symbolic information in the symtab_command which contains
1401      * the symbol and string tables must also be present when this load command is
1402      * present. When this load command is present the symbol table is organized
1403      * into three groups of symbols:
1404      * * local symbols (static and debugging symbols) - grouped by module
1405      * * defined external symbols - grouped by module (sorted by name if not lib)
1406      * * undefined external symbols (sorted by name if MH_BINDATLOAD is not set,
1407      *      and in order the were seen by the static
1408      *      linker if MH_BINDATLOAD is set)
1409      *
1410      * In this load command there are offsets and counts to each of the three
1411      * groups of symbols.
1412      *
1413      * This load command contains a the offsets and sizes of the following new
1414      * symbolic information tables:
1415      * * table of contents
1416      * * module table
1417      * * reference symbol table
1418      * * indirect symbol table
1419      *
1420      * The first three tables above (the table of contents, module table and
1421      * reference symbol table) are only present if the file is a dynamically
1422      * linked shared library. For executable and object modules, which are files
1423      * containing only one module, the information that would be in these three
1424      * tables is determined as follows:
1425      * * table of contents - the defined external symbols are sorted by name
1426      * * module table - the file contains only one module so everything in the
1427      *      file is part of the module.
1428      * * reference symbol table - is the defined and undefined external symbols
1429      *
1430      * For dynamically linked shared library files this load command also
1431      * contains offsets and sizes to the pool of relocation entries for all
1432      * sections separated into two groups:
1433      * * external relocation entries
1434      * * local relocation entries
1435      *
1436      * For executable and object modules the relocation entries continue to hang
1437      * off the section structures.
1438      */
1439     struct dysymtab_command
1440     {
1441         /// LC_DYSYMTAB.
1442         uint cmd;
1443 
1444         /// sizeof(struct dysymtab_command).
1445         uint cmdsize;
1446 
1447         /**
1448          * Index to local symbols.
1449          *
1450          * The symbols indicated by symoff and nsyms of the LC_SYMTAB load command
1451          * are grouped into the following three groups:
1452          * * local symbols (further grouped by the module they are from)
1453          * * defined external symbols (further grouped by the module they are from)
1454          * * undefined symbols
1455          *
1456          * The local symbols are used only for debugging. The dynamic binding
1457          * process may have to use them to indicate to the debugger the local
1458          * symbols for a module that is being bound.
1459          *
1460          * The last two groups are used by the dynamic binding process to do the
1461          * binding (indirectly through the module table and the reference symbol
1462          * table when this is a dynamically linked shared library file).
1463          */
1464         uint ilocalsym;
1465 
1466         /// Number of local symbols.
1467         uint nlocalsym;
1468 
1469 
1470 
1471         /// Index to externally defined symbols.
1472         uint iextdefsym;
1473 
1474         /// Number of externally defined symbols.
1475         uint nextdefsym;
1476 
1477 
1478 
1479         /// Index to undefined symbols.
1480         uint iundefsym;
1481 
1482         /// Number of undefined symbols.
1483         uint nundefsym;
1484 
1485         /**
1486          * File offset to table of contents.
1487          *
1488          * For the for the dynamic binding process to find which module a symbol
1489          * is defined in the table of contents is used (analogous to the ranlib
1490          * structure in an archive) which maps defined external symbols to
1491          * modules they are defined in. This exists only in a dynamically linked
1492          * shared library file. For executable and object modules the defined
1493          * external symbols are sorted by name and is use as the table of
1494          * contents.
1495          */
1496         uint tocoff;
1497 
1498         /// Number of entries in table of contents.
1499         uint ntoc;
1500 
1501         /**
1502          * File offset to module table.
1503          *
1504          * To support dynamic binding of "modules" (whole object files) the
1505          * symbol table must reflect the modules that the file was created from.
1506          * This is done by having a module table that has indexes and counts
1507          * into the merged tables for each module. The module structure that
1508          * these two entries refer to is described below. This exists only in a
1509          * dynamically linked shared library file. For executable and object
1510          * modules the file only contains one module so everything in the file
1511          * belongs to the module.
1512          */
1513         uint modtaboff;
1514 
1515         /// Number of module table entries.
1516         uint nmodtab;
1517 
1518         /**
1519          * Offset to referenced symbol table.
1520          *
1521          * To support dynamic module binding the module structure for each
1522          * module indicates the external references (defined and undefined) each
1523          * module makes. For each module there is an offset and a count into the
1524          * reference symbol table for the symbols that the module references.
1525          * This exists only in a dynamically linked shared library file. For
1526          * executable and object modules the defined external symbols and the
1527          * undefined external symbols indicates the external references.
1528          */
1529         uint extrefsymoff;
1530 
1531         /// Number of referenced symbol table entries.
1532         uint nextrefsyms;
1533 
1534         /**
1535          * File offset to the indirect symbol table.
1536          *
1537          * The sections that contain "symbol pointers" and "routine stubs" have
1538          * indexes and (implied counts based on the size of the section and
1539          * fixed size of the entry) into the "indirect symbol" table for each
1540          * pointer and stub. For every section of these two types the index into
1541          * the indirect symbol table is stored in the section header in the
1542          * field reserved1. An indirect symbol table entry is simply a 32bit
1543          * index into the symbol table to the symbol that the pointer or stub is
1544          * referring to. The indirect symbol table is ordered to match the
1545          * entries in the section.
1546          */
1547         uint indirectsymoff;
1548 
1549         /// Number of indirect symbol table entries.
1550         uint nindirectsyms;
1551 
1552         /**
1553          * Offset to external relocation entries-
1554          *
1555          * To support relocating an individual module in a library file quickly
1556          * the external relocation entries for each module in the library need
1557          * to be accessed efficiently. Since the relocation entries can't be
1558          * accessed through the section headers for a library file they are
1559          * separated into groups of local and external entries further grouped
1560          * by module. In this case the presents of this load command who's
1561          * extreloff, nextrel, locreloff and nlocrel fields are non-zero
1562          * indicates that the relocation entries of non-merged sections are not
1563          * referenced through the section structures (and the reloff and nreloc
1564          * fields in the section headers are set to zero).
1565          *
1566          * Since the relocation entries are not accessed through the section
1567          * headers this requires the r_address field to be something other than
1568          * a section offset to identify the item to be relocated. In this case
1569          * r_address is set to the offset from the vmaddr of the first
1570          * LC_SEGMENT command. For MH_SPLIT_SEGS images r_address is set to the
1571          * offset from thevmaddr of the first read-write LC_SEGMENT command.
1572          *
1573          * The relocation entries are grouped by module and the module table
1574          * entries have indexes and counts into them for the group of external
1575          * relocation entries for that the module.
1576          *
1577          * For sections that are merged across modules there must not be any
1578          * remaining external relocation entries for them (for merged sections
1579          * remaining relocation entries must be local).
1580          */
1581         uint extreloff;
1582 
1583         /// Number of external relocation entries.
1584         uint nextrel;
1585 
1586         /**
1587          * Offset to local relocation entries.
1588          *
1589          * All the local relocation entries are grouped together (they are not
1590          * grouped by their module since they are only used if the object is
1591          * moved from it statically link edited address).
1592          */
1593         uint locreloff;
1594 
1595         /// Number of local relocation entries.
1596         uint nlocrel;
1597     }
1598 
1599     /**
1600      * An indirect symbol table entry is simply a 32bit index into the symbol
1601      * table to the symbol that the pointer or stub is referring to. Unless it
1602      * is for a non-lazy symbol pointer section for a defined symbol which
1603      * strip(1) as removed. In which case it has the value
1604      * INDIRECT_SYMBOL_LOCAL. If the symbol was also absolute
1605      * INDIRECT_SYMBOL_ABS is or'ed with that.
1606      */
1607     enum
1608     {
1609         ///
1610         INDIRECT_SYMBOL_LOCAL,
1611 
1612         ///
1613         INDIRECT_SYMBOL_ABS
1614     }
1615 
1616     /// A table of contents entry.
1617     struct dylib_table_of_contents
1618     {
1619         /// The defined external symbol (index into the symbol table).
1620         uint symbol_index;
1621 
1622         /// Index into the module table this symbol is defined in.
1623         uint module_index;
1624     }
1625 
1626     /// A module table entry.
1627     struct dylib_module
1628     {
1629         /// The module name (index into string table).
1630         uint module_name;
1631 
1632 
1633 
1634         /// Index into externally defined symbols.
1635         uint iextdefsym;
1636 
1637         /// Number of externally defined symbols.
1638         uint nextdefsym;
1639 
1640         /// Index into reference symbol table.
1641         uint irefsym;
1642 
1643         /// Number of reference symbol table entries.
1644         uint nrefsym;
1645 
1646         /// Index into symbols for local symbols.
1647         uint ilocalsym;
1648 
1649         /// Number of local symbols.
1650         uint nlocalsym;
1651 
1652 
1653 
1654         /// Index into external relocation entries.
1655         uint iextrel;
1656 
1657         /// Number of external relocation entries.
1658         uint nextrel;
1659 
1660 
1661 
1662         /**
1663          * Low 16 bits are the index into the init section, high 16 bits are the
1664          * index into the term section.
1665          */
1666         uint iinit_iterm;
1667 
1668         /**
1669          * Low 16 bits are the number of init section entries, high 16 bits are
1670          * the number of term section entries.
1671          */
1672         uint ninit_nterm;
1673 
1674 
1675 
1676         /**
1677          * The (__OBJC,__module_info) section.
1678          *
1679          * For this module address of the start of.
1680          */
1681         uint objc_module_info_addr;
1682 
1683         /**
1684          * The (__OBJC,__module_info) section.
1685          *
1686          * For this module size of.
1687          */
1688         uint objc_module_info_size;
1689     }
1690 
1691     /// A 64-bit module table entry.
1692     struct dylib_module_64
1693     {
1694         /// The module name (index into string table).
1695         uint module_name;
1696 
1697 
1698 
1699         /// Index into externally defined symbols.
1700         uint iextdefsym;
1701 
1702         /// Number of externally defined symbols.
1703         uint nextdefsym;
1704 
1705         /// Index into reference symbol table.
1706         uint irefsym;
1707 
1708         /// Number of reference symbol table entries.
1709         uint nrefsym;
1710 
1711         /// Index into symbols for local symbols.
1712         uint ilocalsym;
1713 
1714         /// Number of local symbols.
1715         uint nlocalsym;
1716 
1717 
1718 
1719         /// Index into external relocation entries.
1720         uint iextrel;
1721 
1722         /// Number of external relocation entries.
1723         uint nextrel;
1724 
1725 
1726 
1727         /**
1728          * Low 16 bits are the index into the init section, high 16 bits are the
1729          * index into the term section.
1730          */
1731         uint iinit_iterm;
1732 
1733         /**
1734          * Low 16 bits are the number of init section entries, high 16 bits are
1735          * the number of term section entries.
1736          */
1737         uint ninit_nterm;
1738 
1739 
1740 
1741         /**
1742          * The (__OBJC,__module_info) section.
1743          *
1744          * For this module size of.
1745          */
1746         uint objc_module_info_size;
1747 
1748         /**
1749          * The (__OBJC,__module_info) section.
1750          *
1751          * For this module address of the start of.
1752          */
1753         ulong objc_module_info_addr;
1754     }
1755 
1756     /**
1757      * The entries in the reference symbol table are used when loading the
1758      * module (both by the static and dynamic link editors) and if the module is
1759      * unloaded or replaced. Therefore all external symbols
1760      * (defined and undefined) are listed in the module's reference table. The
1761      * flags describe the type of reference that is being made. The constants
1762      * for the flags are defined in <mach-o/nlist.h> as they are also used for
1763      * symbol table entries.
1764      */
1765     struct dylib_reference
1766     {
1767         /// Index into the symbol table.
1768         @property uint isym() const pure nothrow @nogc @safe;
1769 
1770         /// ditto
1771         @property void isym(uint v) @safe pure nothrow @nogc;
1772 
1773         /// Flags to indicate the type of reference.
1774         @property uint flags() const pure nothrow @nogc @safe;
1775 
1776         /// ditto
1777         @property void flags(uint v) pure nothrow @nogc @safe;
1778     }
1779 
1780     /**
1781      * The twolevel_hints_command contains the offset and number of hints in the
1782      * two-level namespace lookup hints table.
1783      */
1784     struct twolevel_hints_command
1785     {
1786         /// LC_TWOLEVEL_HINTS.
1787         uint cmd;
1788 
1789         /// Sizeof(struct twolevel_hints_command).
1790         uint cmdsize;
1791 
1792         /// Offset to the hint table.
1793         uint offset;
1794 
1795         /// Number of hints in the hint table.
1796         uint nhints;
1797     }
1798 
1799     /**
1800      * The entries in the two-level namespace lookup hints table are
1801      * twolevel_hint structs. These provide hints to the dynamic link editor
1802      * where to start looking for an undefined symbol in a two-level namespace
1803      * image. The isub_image field is an index into the sub-images
1804      * (sub-frameworks and sub-umbrellas list) that made up the two-level image
1805      * that the undefined symbol was found in when it was built by the static
1806      * link editor. If isub-image is 0 the symbol is expected to be defined
1807      * in library and not in the sub-images. If isub-image is non-zero it is an
1808      * index into the array of sub-images for the umbrella with the first index
1809      * in the sub-images being 1. The array of sub-images is the ordered list of
1810      * sub-images of the umbrella that would be searched for a symbol that has
1811      * the umbrella recorded as its primary library. The table of contents index
1812      * is an index into the library's table of contents. This is used as the
1813      * starting point of the binary search or a directed linear search.
1814      */
1815     struct twolevel_hint
1816     {
1817         /// Index into the sub images.
1818         @property uint isub_image() const pure nothrow @nogc @safe;
1819 
1820         /// ditto
1821         @property void isub_image(uint v) pure nothrow @nogc @safe;
1822 
1823         /// Index into the table of contents.
1824         @property uint itoc() const pure nothrow @nogc @safe;
1825 
1826         /// ditto
1827         @property void itoc(uint v) pure nothrow @nogc @safe;
1828     }
1829 
1830     /**
1831      * The prebind_cksum_command contains the value of the original check sum
1832      * for prebound files or zero. When a prebound file is first created or
1833      * modified for other than updating its prebinding information the value of
1834      * the check sum is set to zero. When the file has it prebinding re-done and
1835      * if the value of the check sum is zero the original check sum is
1836      * calculated and stored in cksum field of this load command in the output
1837      * file. If when the prebinding is re-done and the cksum field is non-zero
1838      * it is left unchanged from the input file.
1839      */
1840     struct prebind_cksum_command
1841     {
1842         /// LC_PREBIND_CKSUM.
1843         uint cmd;
1844 
1845         /// Sizeof(struct prebind_cksum_command).
1846         uint cmdsize;
1847 
1848         /// The check sum or zero.
1849         uint cksum;
1850     }
1851 
1852     /**
1853      * The uuid load command contains a single 128-bit unique random number that
1854      * identifies an object produced by the static link editor.
1855      */
1856     struct uuid_command
1857     {
1858         /// LC_UUID.
1859         uint cmd;
1860 
1861         /// Sizeof(struct uuid_command).
1862         uint cmdsize;
1863 
1864         /// The 128-bit uuid.
1865         ubyte[16] uuid;
1866     }
1867 
1868     /**
1869      * The rpath_command contains a path which at runtime should be added to
1870      * the current run path used to find @rpath prefixed dylibs.
1871      */
1872     struct rpath_command
1873     {
1874         /// LC_RPATH.
1875         uint cmd;
1876 
1877         /// Includes string.
1878         uint cmdsize;
1879 
1880         /// Path to add to run path.
1881         lc_str path;
1882     }
1883 
1884     /**
1885      * The linkedit_data_command contains the offsets and sizes of a blob
1886      * of data in the __LINKEDIT segment.
1887      */
1888     struct linkedit_data_command
1889     {
1890         /**
1891          * LC_CODE_SIGNATURE, LC_SEGMENT_SPLIT_INFO, LC_FUNCTION_STARTS,
1892          * LC_DATA_IN_CODE, LC_DYLIB_CODE_SIGN_DRS,
1893          * LC_LINKER_OPTIMIZATION_HINT, LC_DYLD_EXPORTS_TRIE or
1894          * LC_DYLD_CHAINED_FIXUPS.
1895          */
1896         uint cmd;
1897 
1898         /// Sizeof(struct linkedit_data_command).
1899         uint cmdsize;
1900 
1901         /// File offset of data in __LINKEDIT segment.
1902         uint dataoff;
1903 
1904         /// File size of data in __LINKEDIT segment.
1905         uint datasize;
1906 
1907     }
1908 
1909     /**
1910      * The encryption_info_command contains the file offset and size of an
1911      * of an encrypted segment.
1912      */
1913     struct encryption_info_command
1914     {
1915         /// LC_ENCRYPTION_INFO.
1916         uint cmd;
1917 
1918         /// Sizeof(struct encryption_info_command).
1919         uint cmdsize;
1920 
1921         /// File offset of encrypted range.
1922         uint cryptoff;
1923 
1924         /// File size of encrypted range.
1925         uint cryptsize;
1926 
1927         /// Which encryption system, 0 means not-encrypted yet.
1928         uint cryptid;
1929     }
1930 
1931     /**
1932      * The encryption_info_command_64 contains the file offset and size of an
1933      * of an encrypted segment (for use in x86_64 targets).
1934      */
1935     struct encryption_info_command_64
1936     {
1937         /// LC_ENCRYPTION_INFO_64.
1938         uint cmd;
1939 
1940         /// Sizeof(struct encryption_info_command_64).
1941         uint cmdsize;
1942 
1943         /// File offset of encrypted range.
1944         uint cryptoff;
1945 
1946         /// File size of encrypted range.
1947         uint cryptsize;
1948 
1949         /// Which encryption system, 0 means not-encrypted yet.
1950         uint cryptid;
1951 
1952         /// Padding to make this struct's size a multiple of 8 bytes.
1953         uint pad;
1954     }
1955 
1956     /**
1957      * The version_min_command contains the min OS version on which this
1958      * binary was built to run.
1959      */
1960     struct version_min_command
1961     {
1962         /**
1963          * LC_VERSION_MIN_MACOSX or LC_VERSION_MIN_IPHONEOS or
1964          * LC_VERSION_MIN_WATCHOS or LC_VERSION_MIN_TVOS.
1965          */
1966         uint cmd;
1967 
1968         /// Sizeof(struct min_version_command).
1969         uint cmdsize;
1970 
1971         /// X.Y.Z is encoded in nibbles xxxx.yy.zz.
1972         uint version_;
1973 
1974         /// X.Y.Z is encoded in nibbles xxxx.yy.zz.
1975         uint sdk;
1976     }
1977 
1978     /**
1979      * The build_version_command contains the min OS version on which this
1980      * binary was built to run for its platform. The list of known platforms and
1981      * tool values following it.
1982      */
1983     struct build_version_command
1984     {
1985         /// LC_BUILD_VERSION.
1986         uint cmd;
1987 
1988         /**
1989          * Sizeof(struct build_version_command) plus ntools
1990          * sizeof(struct build_tool_version).
1991          */
1992         uint cmdsize;
1993 
1994         /// Platform.
1995         uint platform;
1996 
1997         /// X.Y.Z is encoded in nibbles xxxx.yy.zz.
1998         uint minos;
1999 
2000         /// X.Y.Z is encoded in nibbles xxxx.yy.zz.
2001         uint sdk;
2002 
2003         /// Number of tool entries following this.
2004         uint ntools;
2005 
2006     }
2007 
2008     ///
2009     struct build_tool_version
2010     {
2011         /// Enum for the tool.
2012         uint tool;
2013 
2014         /// Version number of the tool.
2015         uint version_;
2016     }
2017 
2018     /// Known values for the platform field above.
2019     enum
2020     {
2021         ///
2022         PLATFORM_MACOS,
2023 
2024         ///
2025         PLATFORM_IOS,
2026 
2027         ///
2028         PLATFORM_TVOS,
2029 
2030         ///
2031         PLATFORM_WATCHOS,
2032 
2033         ///
2034         PLATFORM_BRIDGEOS,
2035 
2036         ///
2037         PLATFORM_UIKITFORMAC,
2038 
2039         ///
2040         PLATFORM_IOSSIMULATOR,
2041 
2042         ///
2043         PLATFORM_TVOSSIMULATOR,
2044 
2045         ///
2046         PLATFORM_WATCHOSSIMULATOR,
2047 
2048         ///
2049         PLATFORM_DRIVERKIT
2050     }
2051 
2052 
2053     /// Known values for the tool field above.
2054     enum
2055     {
2056         ///
2057         TOOL_CLANG,
2058 
2059         ///
2060         TOOL_SWIFT,
2061 
2062         ///
2063         TOOL_LD
2064     }
2065 
2066     /**
2067      * The dyld_info_command contains the file offsets and sizes of
2068      * the new compressed form of the information dyld needs to
2069      * load the image. This information is used by dyld on Mac OS X
2070      * 10.6 and later. All information pointed to by this command
2071      * is encoded using byte streams, so no endian swapping is needed
2072      * to interpret it.
2073      */
2074     struct dyld_info_command
2075     {
2076         /// LC_DYLD_INFO or LC_DYLD_INFO_ONLY.
2077         uint cmd;
2078 
2079         /// Sizeof(struct dyld_info_command).
2080         uint cmdsize;
2081 
2082 
2083 
2084         /**
2085          * File offset to rebase info.
2086          *
2087          * Dyld rebases an image whenever dyld loads it at an address different
2088          * from its preferred address. The rebase information is a stream
2089          * of byte sized opcodes whose symbolic names start with REBASE_OPCODE_.
2090          * Conceptually the rebase information is a table of tuples:
2091          *    <seg-index, seg-offset, type>
2092          * The opcodes are a compressed way to encode the table by only
2093          * encoding when a column changes. In addition simple patterns
2094          * like "every n'th offset for m times" can be encoded in a few
2095          * bytes.
2096          */
2097         uint rebase_off;
2098 
2099         /// Size of rebase info.
2100         uint rebase_size;
2101 
2102 
2103 
2104         /**
2105          * File offset to binding info.
2106          *
2107          * Dyld binds an image during the loading process, if the image
2108          * requires any pointers to be initialized to symbols in other images.
2109          * The bind information is a stream of byte sized
2110          * opcodes whose symbolic names start with BIND_OPCODE_.
2111          * Conceptually the bind information is a table of tuples:
2112          *    <seg-index, seg-offset, type, symbol-library-ordinal, symbol-name, addend>
2113          * The opcodes are a compressed way to encode the table by only
2114          * encoding when a column changes. In addition simple patterns
2115          * like for runs of pointers initialzed to the same value can be
2116          * encoded in a few bytes.
2117          */
2118         uint bind_off;
2119 
2120         /// Size of binding info.
2121         uint bind_size;
2122 
2123 
2124 
2125         /**
2126          * File offset to weak binding info.
2127          *
2128          * Some C++ programs require dyld to unique symbols so that all
2129          * images in the process use the same copy of some code/data.
2130          * This step is done after binding. The content of the weak_bind
2131          * info is an opcode stream like the bind_info. But it is sorted
2132          * alphabetically by symbol name. This enable dyld to walk
2133          * all images with weak binding information in order and look
2134          * for collisions. If there are no collisions, dyld does
2135          * no updating. That means that some fixups are also encoded
2136          * in the bind_info. For instance, all calls to "operator new"
2137          * are first bound to libstdc++.dylib using the information
2138          * in bind_info. Then if some image overrides operator new
2139          * that is detected when the weak_bind information is processed
2140          * and the call to operator new is then rebound.
2141          */
2142         uint weak_bind_off;
2143 
2144         /// Size of weak binding info.
2145         uint weak_bind_size;
2146 
2147 
2148 
2149         /**
2150          * File offset to lazy binding info.
2151          *
2152          * Some uses of external symbols do not need to be bound immediately.
2153          * Instead they can be lazily bound on first use. The lazy_bind
2154          * are contains a stream of BIND opcodes to bind all lazy symbols.
2155          * Normal use is that dyld ignores the lazy_bind section when
2156          * loading an image. Instead the static linker arranged for the
2157          * lazy pointer to initially point to a helper function which
2158          * pushes the offset into the lazy_bind area for the symbol
2159          * needing to be bound, then jumps to dyld which simply adds
2160          * the offset to lazy_bind_off to get the information on what
2161          * to bind.
2162          */
2163         uint lazy_bind_off;
2164 
2165         /// Size of lazy binding infs.
2166         uint lazy_bind_size;
2167 
2168 
2169 
2170         /**
2171          * File offset to lazy binding info.
2172          *
2173          * The symbols exported by a dylib are encoded in a trie. This
2174          * is a compact representation that factors out common prefixes.
2175          * It also reduces LINKEDIT pages in RAM because it encodes all
2176          * information (name, address, flags) in one small, contiguous range.
2177          * The export area is a stream of nodes. The first node sequentially
2178          * is the start node for the trie.
2179          *
2180          * Nodes for a symbol start with a uleb128 that is the length of
2181          * the exported symbol information for the string so far.
2182          * If there is no exported symbol, the node starts with a zero byte.
2183          * If there is exported info, it follows the length.
2184          *
2185          * First is a uleb128 containing flags. Normally, it is followed by
2186          * a uleb128 encoded offset which is location of the content named
2187          * by the symbol from the mach_header for the image. If the flags
2188          * is EXPORT_SYMBOL_FLAGS_REEXPORT, then following the flags is
2189          * a uleb128 encoded library ordinal, then a zero terminated
2190          * UTF8 string. If the string is zero length, then the symbol
2191          * is re-export from the specified dylib with the same name.
2192          * If the flags is EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER, then following
2193          * the flags is two uleb128s: the stub offset and the resolver offset.
2194          * The stub is used by non-lazy pointers. The resolver is used
2195          * by lazy pointers and must be called to get the actual address to use.
2196          *
2197          * After the optional exported symbol information is a byte of
2198          * how many edges (0-255) that this node has leaving it,
2199          * followed by each edge.
2200          * Each edge is a zero terminated UTF8 of the addition chars
2201          * in the symbol, followed by a uleb128 offset for the node that
2202          * edge points to.
2203          *
2204          */
2205         uint export_off;
2206 
2207         /// Size of lazy binding infs.
2208         uint export_size;
2209     }
2210 
2211     /// The following are used to encode rebasing information.
2212     enum
2213     {
2214         ///
2215         REBASE_TYPE_POINTER,
2216 
2217         ///
2218         REBASE_TYPE_TEXT_ABSOLUTE32,
2219 
2220         ///
2221         REBASE_TYPE_TEXT_PCREL32,
2222 
2223 
2224 
2225         ///
2226         REBASE_OPCODE_MASK,
2227 
2228         ///
2229         REBASE_IMMEDIATE_MASK,
2230 
2231         ///
2232         REBASE_OPCODE_DONE,
2233 
2234         ///
2235         REBASE_OPCODE_SET_TYPE_IMM,
2236 
2237         ///
2238         REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB,
2239 
2240         ///
2241         REBASE_OPCODE_ADD_ADDR_ULEB,
2242 
2243         ///
2244         REBASE_OPCODE_ADD_ADDR_IMM_SCALED,
2245 
2246         ///
2247         REBASE_OPCODE_DO_REBASE_IMM_TIMES,
2248 
2249         ///
2250         REBASE_OPCODE_DO_REBASE_ULEB_TIMES,
2251 
2252         ///
2253         REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB,
2254 
2255         ///
2256         REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB
2257     }
2258 
2259 
2260     /// The following are used to encode binding information.
2261     enum
2262     {
2263         ///
2264         BIND_TYPE_POINTER,
2265 
2266         ///
2267         BIND_TYPE_TEXT_ABSOLUTE32,
2268 
2269         ///
2270         BIND_TYPE_TEXT_PCREL32,
2271 
2272 
2273 
2274         ///
2275         BIND_SPECIAL_DYLIB_SELF,
2276 
2277         ///
2278         BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE,
2279 
2280         ///
2281         BIND_SPECIAL_DYLIB_FLAT_LOOKUP,
2282 
2283         ///
2284         BIND_SPECIAL_DYLIB_WEAK_LOOKUP,
2285 
2286 
2287 
2288         ///
2289         BIND_SYMBOL_FLAGS_WEAK_IMPORT,
2290 
2291         ///
2292         BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION,
2293 
2294 
2295 
2296         ///
2297         BIND_OPCODE_MASK,
2298 
2299         ///
2300         BIND_IMMEDIATE_MASK,
2301 
2302         ///
2303         BIND_OPCODE_DONE,
2304 
2305         ///
2306         BIND_OPCODE_SET_DYLIB_ORDINAL_IMM,
2307 
2308         ///
2309         BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB,
2310 
2311         ///
2312         BIND_OPCODE_SET_DYLIB_SPECIAL_IMM,
2313 
2314         ///
2315         BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM,
2316 
2317         ///
2318         BIND_OPCODE_SET_TYPE_IMM,
2319 
2320         ///
2321         BIND_OPCODE_SET_ADDEND_SLEB,
2322 
2323         ///
2324         BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB,
2325 
2326         ///
2327         BIND_OPCODE_ADD_ADDR_ULEB,
2328 
2329         ///
2330         BIND_OPCODE_DO_BIND,
2331 
2332         ///
2333         BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB,
2334 
2335         ///
2336         BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED,
2337 
2338         ///
2339         BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB,
2340 
2341         ///
2342         BIND_OPCODE_THREADED,
2343 
2344         ///
2345         BIND_SUBOPCODE_THREADED_SET_BIND_ORDINAL_TABLE_SIZE_ULEB,
2346 
2347         ///
2348         BIND_SUBOPCODE_THREADED_APPLY
2349     }
2350 
2351     /**
2352      * The following are used on the flags byte of a terminal node
2353      * in the export information.
2354      */
2355     enum
2356     {
2357 
2358         ///
2359         EXPORT_SYMBOL_FLAGS_KIND_MASK,
2360 
2361         ///
2362         EXPORT_SYMBOL_FLAGS_KIND_REGULAR,
2363 
2364         ///
2365         EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL,
2366 
2367         ///
2368         EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE,
2369 
2370         ///
2371         EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION,
2372 
2373         ///
2374         EXPORT_SYMBOL_FLAGS_REEXPORT,
2375 
2376         ///
2377         EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER,
2378 
2379     }
2380 
2381 
2382     /*
2383      * The linker_option_command contains linker options embedded in object files.
2384      */
2385     struct linker_option_command
2386     {
2387         /// LC_LINKER_OPTION only used in MH_OBJECT filetypes.
2388         uint cmd;
2389 
2390         ///
2391         uint cmdsize;
2392 
2393         /**
2394          * Number of strings concatenation of zero terminated UTF8 strings.
2395          * Zero filled at end to align.
2396          */
2397         uint count;
2398     }
2399 
2400     /**
2401      * The symseg_command contains the offset and size of the GNU style
2402      * symbol table information as described in the header file <symseg.h>.
2403      * The symbol roots of the symbol segments must also be aligned properly
2404      * in the file. So the requirement of keeping the offsets aligned to a
2405      * multiple of a 4 bytes translates to the length field of the symbol
2406      * roots also being a multiple of a long. Also the padding must again be
2407      * zeroed. (THIS IS OBSOLETE and no longer supported).
2408      */
2409     struct symseg_command
2410     {
2411         /// LC_SYMSEG.
2412         uint cmd;
2413 
2414         /// Sizeof(struct symseg_command).
2415         uint cmdsize;
2416 
2417         /// Symbol segment offset.
2418         uint offset;
2419 
2420         /// Symbol segment size in bytes.
2421         uint size;
2422     }
2423 
2424     /**
2425      * The ident_command contains a free format string table following the
2426      * ident_command structure. The strings are null terminated and the size of
2427      * the command is padded out with zero bytes to a multiple of 4 bytes/
2428      * (THIS IS OBSOLETE and no longer supported).
2429      */
2430     struct ident_command
2431     {
2432         /// LC_IDENT.
2433         uint cmd;
2434 
2435         /// Strings that follow this command.
2436         uint cmdsize;
2437     }
2438 
2439     /**
2440      * The fvmfile_command contains a reference to a file to be loaded at the
2441      * specified virtual address. (Presently, this command is reserved for
2442      * internal use. The kernel ignores this command when loading a program into
2443      * memory).
2444      */
2445     struct fvmfile_command
2446     {
2447         /// LC_FVMFILE.
2448         uint cmd;
2449 
2450         /// Includes pathname string.
2451         uint cmdsize;
2452 
2453         /// Files pathname.
2454         lc_str name;
2455 
2456         /// Files virtual address.
2457         uint header_addr;
2458     }
2459 
2460     /**
2461      * The entry_point_command is a replacement for thread_command.
2462      * It is used for main executables to specify the location (file offset)
2463      * of main(). If -stack_size was used at link time, the stacksize
2464      * field will contain the stack size need for the main thread.
2465      */
2466     struct entry_point_command
2467     {
2468         /// LC_MAIN only used in MH_EXECUTE filetypes.
2469         uint cmd;
2470 
2471         /// 24.
2472         uint cmdsize;
2473 
2474         /// File (__TEXT) offset of main().
2475         ulong entryoff;
2476 
2477         /// If not zero, initial stack size.
2478         ulong stacksize;
2479     }
2480 
2481     /**
2482      * The source_version_command is an optional load command containing
2483      * the version of the sources used to build the binary.
2484      */
2485     struct source_version_command
2486     {
2487         /// LC_SOURCE_VERSION.
2488         uint cmd;
2489 
2490         /// 16.
2491         uint cmdsize;
2492 
2493         /// A.B.C.D.E packed as a24.b10.c10.d10.e10.
2494         ulong version_;
2495     }
2496 
2497     /**
2498      * The LC_DATA_IN_CODE load commands uses a linkedit_data_command
2499      * to point to an array of data_in_code_entry entries. Each entry
2500      * describes a range of data in a code section.
2501      */
2502     struct data_in_code_entry
2503     {
2504         /// From mach_header to start of data range.
2505         uint offset;
2506 
2507         /// Number of bytes in data range.
2508         ushort length;
2509 
2510         /// A DICE_KIND_* value.
2511         ushort kind;
2512     }
2513 
2514     ///
2515     enum
2516     {
2517         ///
2518         DICE_KIND_DATA,
2519 
2520         ///
2521         DICE_KIND_JUMP_TABLE8,
2522 
2523         ///
2524         DICE_KIND_JUMP_TABLE16,
2525 
2526         ///
2527         DICE_KIND_JUMP_TABLE32,
2528 
2529         ///
2530         DICE_KIND_ABS_JUMP_TABLE32
2531     }
2532 
2533     /**
2534      * Sections of type S_THREAD_LOCAL_VARIABLES contain an array
2535      * of tlv_descriptor structures.
2536      */
2537     struct tlv_descriptor
2538     {
2539         ///
2540         void* function (tlv_descriptor*) thunk;
2541 
2542         ///
2543         c_ulong key;
2544 
2545         ///
2546         c_ulong offset;
2547     }
2548 
2549     /**
2550      * LC_NOTE commands describe a region of arbitrary data included in a Mach-O
2551      * file. Its initial use is to record extra data in MH_CORE files.
2552      */
2553     struct note_command
2554     {
2555         /// LC_NOTE.
2556         uint cmd;
2557 
2558         /// Sizeof(struct note_command).
2559         uint cmdsize;
2560 
2561         /// Owner name for this LC_NOTE.
2562         char[16] data_owner;
2563 
2564         /// File offset of this data.
2565         ulong offset;
2566 
2567         /// Length of data region.
2568         ulong size;
2569     }
2570 }
2571 else
2572     version = Darwin;
2573 
2574 version (Darwin):
2575 extern (C):
2576 
2577 struct mach_header
2578 {
2579     uint magic;
2580     int cputype;
2581     int cpusubtype;
2582     uint filetype;
2583     uint ncmds;
2584     uint sizeofcmds;
2585     uint flags;
2586 }
2587 
2588 enum
2589 {
2590     MH_MAGIC = 0xfeedface,
2591     MH_CIGAM = 0xcefaedfe
2592 }
2593 
2594 struct mach_header_64
2595 {
2596     uint magic;
2597     int cputype;
2598     int cpusubtype;
2599     uint filetype;
2600     uint ncmds;
2601     uint sizeofcmds;
2602     uint flags;
2603     uint reserved;
2604 }
2605 
2606 enum
2607 {
2608     MH_MAGIC_64 = 0xfeedfacf,
2609     MH_CIGAM_64 = 0xcffaedfe
2610 }
2611 
2612 enum
2613 {
2614     MH_OBJECT = 0x1,
2615     MH_EXECUTE = 0x2,
2616     MH_FVMLIB = 0x3,
2617     MH_CORE = 0x4,
2618     MH_PRELOAD = 0x5,
2619     MH_DYLIB = 0x6,
2620     MH_DYLINKER = 0x7,
2621     MH_BUNDLE = 0x8,
2622     MH_DYLIB_STUB = 0x9,
2623     MH_DSYM = 0xa,
2624     MH_KEXT_BUNDLE = 0xb
2625 }
2626 
2627 enum
2628 {
2629     MH_NOUNDEFS = 0x1,
2630     MH_INCRLINK = 0x2,
2631     MH_DYLDLINK = 0x4,
2632     MH_BINDATLOAD = 0x8,
2633     MH_PREBOUND = 0x10,
2634     MH_SPLIT_SEGS = 0x20,
2635     MH_LAZY_INIT = 0x40,
2636     MH_TWOLEVEL = 0x80,
2637     MH_FORCE_FLAT = 0x100,
2638     MH_NOMULTIDEFS = 0x200,
2639     MH_NOFIXPREBINDING = 0x400,
2640     MH_PREBINDABLE = 0x800,
2641     MH_ALLMODSBOUND = 0x1000,
2642     MH_SUBSECTIONS_VIA_SYMBOLS = 0x2000,
2643     MH_CANONICAL = 0x4000,
2644     MH_WEAK_DEFINES = 0x8000,
2645     MH_BINDS_TO_WEAK = 0x10000,
2646 
2647     MH_ALLOW_STACK_EXECUTION = 0x20000,
2648     MH_ROOT_SAFE = 0x40000,
2649 
2650     MH_SETUID_SAFE = 0x80000,
2651     MH_NO_REEXPORTED_DYLIBS = 0x100000,
2652     MH_PIE = 0x200000,
2653     MH_DEAD_STRIPPABLE_DYLIB = 0x400000,
2654     MH_HAS_TLV_DESCRIPTORS = 0x800000,
2655 
2656     MH_NO_HEAP_EXECUTION = 0x1000000,
2657 
2658     MH_APP_EXTENSION_SAFE = 0x02000000,
2659 
2660     MH_NLIST_OUTOFSYNC_WITH_DYLDINFO = 0x04000000,
2661 
2662     MH_SIM_SUPPORT = 0x08000000,
2663 
2664     MH_DYLIB_IN_CACHE = 0x80000000
2665 }
2666 
2667 struct load_command
2668 {
2669     uint cmd;
2670     uint cmdsize;
2671 }
2672 
2673 enum LC_REQ_DYLD = 0x80000000;
2674 
2675 enum
2676 {
2677     LC_SEGMENT = 0x1,
2678     LC_SYMTAB = 0x2,
2679     LC_SYMSEG = 0x3,
2680     LC_THREAD = 0x4,
2681     LC_UNIXTHREAD = 0x5,
2682     LC_LOADFVMLIB = 0x6,
2683     LC_IDFVMLIB = 0x7,
2684     LC_IDENT = 0x8,
2685     LC_FVMFILE = 0x9,
2686     LC_PREPAGE = 0xa,
2687     LC_DYSYMTAB = 0xb,
2688     LC_LOAD_DYLIB = 0xc,
2689     LC_ID_DYLIB = 0xd,
2690     LC_LOAD_DYLINKER = 0xe,
2691     LC_ID_DYLINKER = 0xf,
2692     LC_PREBOUND_DYLIB = 0x10,
2693     LC_ROUTINES = 0x11,
2694     LC_SUB_FRAMEWORK = 0x12,
2695     LC_SUB_UMBRELLA = 0x13,
2696     LC_SUB_CLIENT = 0x14,
2697     LC_SUB_LIBRARY = 0x15,
2698     LC_TWOLEVEL_HINTS = 0x16,
2699     LC_PREBIND_CKSUM = 0x17
2700 }
2701 
2702 enum LC_LOAD_WEAK_DYLIB = 0x18 | LC_REQ_DYLD;
2703 
2704 enum
2705 {
2706     LC_SEGMENT_64 = 0x19,
2707     LC_ROUTINES_64 = 0x1a,
2708     LC_UUID = 0x1b,
2709     LC_RPATH = 0x1c | LC_REQ_DYLD,
2710     LC_CODE_SIGNATURE = 0x1d,
2711     LC_SEGMENT_SPLIT_INFO = 0x1e,
2712     LC_REEXPORT_DYLIB = 0x1f | LC_REQ_DYLD,
2713     LC_LAZY_LOAD_DYLIB = 0x20,
2714     LC_ENCRYPTION_INFO = 0x21,
2715     LC_DYLD_INFO = 0x22,
2716     LC_DYLD_INFO_ONLY = 0x22 | LC_REQ_DYLD,
2717     LC_LOAD_UPWARD_DYLIB = 0x23 | LC_REQ_DYLD,
2718     LC_VERSION_MIN_MACOSX = 0x24,
2719     LC_VERSION_MIN_IPHONEOS = 0x25,
2720     LC_FUNCTION_STARTS = 0x26,
2721     LC_DYLD_ENVIRONMENT = 0x27,
2722     LC_MAIN = 0x28 | LC_REQ_DYLD,
2723     LC_DATA_IN_CODE = 0x29,
2724     LC_SOURCE_VERSION = 0x2A,
2725     LC_DYLIB_CODE_SIGN_DRS = 0x2B,
2726     LC_ENCRYPTION_INFO_64 = 0x2C,
2727     LC_LINKER_OPTION = 0x2D,
2728     LC_LINKER_OPTIMIZATION_HINT = 0x2E,
2729     LC_VERSION_MIN_TVOS = 0x2F,
2730     LC_VERSION_MIN_WATCHOS = 0x30,
2731     LC_NOTE = 0x31,
2732     LC_BUILD_VERSION = 0x32,
2733     LC_DYLD_EXPORTS_TRIE = 0x33 | LC_REQ_DYLD,
2734     LC_DYLD_CHAINED_FIXUPS = 0x34 | LC_REQ_DYLD
2735 }
2736 
2737 union lc_str
2738 {
2739     uint offset;
2740 
2741     version (D_LP64) {}
2742     else
2743         char* ptr;
2744 }
2745 
2746 struct segment_command
2747 {
2748     uint cmd;
2749     uint cmdsize;
2750     char[16] segname = 0;
2751     uint vmaddr;
2752     uint vmsize;
2753     uint fileoff;
2754     uint filesize;
2755     int maxprot;
2756     int initprot;
2757     uint nsects;
2758     uint flags;
2759 }
2760 
2761 struct segment_command_64
2762 {
2763     uint cmd;
2764     uint cmdsize;
2765     char[16] segname = 0;
2766     ulong vmaddr;
2767     ulong vmsize;
2768     ulong fileoff;
2769     ulong filesize;
2770     int maxprot;
2771     int initprot;
2772     uint nsects;
2773     uint flags;
2774 }
2775 
2776 enum
2777 {
2778     SG_HIGHVM = 0x1,
2779     SG_FVMLIB = 0x2,
2780     SG_NORELOC = 0x4,
2781     SG_PROTECTED_VERSION_1 = 0x8,
2782     SG_READ_ONLY = 0x10
2783 }
2784 
2785 struct section
2786 {
2787     char[16] sectname = 0;
2788     char[16] segname = 0;
2789     uint addr;
2790     uint size;
2791     uint offset;
2792     uint align_;
2793     uint reloff;
2794     uint nreloc;
2795     uint flags;
2796     uint reserved1;
2797     uint reserved2;
2798 }
2799 
2800 struct section_64
2801 {
2802     char[16] sectname = 0;
2803     char[16] segname = 0;
2804     ulong addr;
2805     ulong size;
2806     uint offset;
2807     uint align_;
2808     uint reloff;
2809     uint nreloc;
2810     uint flags;
2811     uint reserved1;
2812     uint reserved2;
2813     uint reserved3;
2814 }
2815 
2816 
2817 enum
2818 {
2819     SECTION_TYPE = 0x000000ff,
2820     SECTION_ATTRIBUTES = 0xffffff00
2821 }
2822 
2823 enum
2824 {
2825     S_REGULAR = 0x0,
2826     S_ZEROFILL = 0x1,
2827     S_CSTRING_LITERALS = 0x2,
2828     S_4BYTE_LITERALS = 0x3,
2829     S_8BYTE_LITERALS = 0x4,
2830     S_LITERAL_POINTERS = 0x5,
2831     S_NON_LAZY_SYMBOL_POINTERS = 0x6,
2832     S_LAZY_SYMBOL_POINTERS = 0x7,
2833     S_SYMBOL_STUBS = 0x8,
2834     S_MOD_INIT_FUNC_POINTERS = 0x9,
2835     S_MOD_TERM_FUNC_POINTERS = 0xa,
2836     S_COALESCED = 0xb,
2837     S_GB_ZEROFILL = 0xc,
2838     S_INTERPOSING = 0xd,
2839     S_16BYTE_LITERALS = 0xe,
2840     S_DTRACE_DOF = 0xf,
2841     S_LAZY_DYLIB_SYMBOL_POINTERS = 0x10,
2842 
2843     S_THREAD_LOCAL_REGULAR = 0x11,
2844     S_THREAD_LOCAL_ZEROFILL = 0x12,
2845     S_THREAD_LOCAL_VARIABLES = 0x13,
2846     S_THREAD_LOCAL_VARIABLE_POINTERS = 0x14,
2847     S_THREAD_LOCAL_INIT_FUNCTION_POINTERS = 0x15,
2848     S_INIT_FUNC_OFFSETS = 0x16
2849 }
2850 
2851 enum
2852 {
2853     SECTION_ATTRIBUTES_USR = 0xff000000,
2854     S_ATTR_PURE_INSTRUCTIONS = 0x80000000,
2855     S_ATTR_NO_TOC = 0x40000000,
2856     S_ATTR_STRIP_STATIC_SYMS = 0x20000000,
2857     S_ATTR_NO_DEAD_STRIP = 0x10000000,
2858     S_ATTR_LIVE_SUPPORT = 0x08000000,
2859     S_ATTR_SELF_MODIFYING_CODE = 0x04000000,
2860     S_ATTR_DEBUG = 0x02000000,
2861     SECTION_ATTRIBUTES_SYS = 0x00ffff00,
2862     S_ATTR_SOME_INSTRUCTIONS = 0x00000400,
2863     S_ATTR_EXT_RELOC = 0x00000200,
2864     S_ATTR_LOC_RELOC = 0x00000100
2865 }
2866 
2867 enum
2868 {
2869     SEG_PAGEZERO = "__PAGEZERO",
2870 
2871     SEG_TEXT = "__TEXT",
2872     SECT_TEXT = "__text",
2873     SECT_FVMLIB_INIT0 = "__fvmlib_init0",
2874     SECT_FVMLIB_INIT1 = "__fvmlib_init1",
2875 
2876     SEG_DATA = "__DATA",
2877     SECT_DATA = "__data",
2878     SECT_BSS = "__bss",
2879     SECT_COMMON = "__common",
2880 
2881     SEG_OBJC = "__OBJC",
2882     SECT_OBJC_SYMBOLS = "__symbol_table",
2883     SECT_OBJC_MODULES = "__module_info",
2884     SECT_OBJC_STRINGS = "__selector_strs",
2885     SECT_OBJC_REFS = "__selector_refs",
2886 
2887     SEG_ICON = "__ICON",
2888     SECT_ICON_HEADER = "__header",
2889     SECT_ICON_TIFF = "__tiff",
2890 
2891     SEG_LINKEDIT = "__LINKEDIT",
2892 
2893     SEG_UNIXSTACK = "__UNIXSTACK",
2894 
2895     SEG_IMPORT = "__IMPORT"
2896 }
2897 
2898 struct fvmlib
2899 {
2900     lc_str name;
2901     uint minor_version;
2902     uint header_addr;
2903 }
2904 
2905 struct fvmlib_command
2906 {
2907     uint cmd;
2908     uint cmdsize;
2909     fvmlib fvmlib_;
2910 }
2911 
2912 struct dylib
2913 {
2914     lc_str name;
2915     uint timestamp;
2916     uint current_version;
2917     uint compatibility_version;
2918 }
2919 
2920 struct dylib_command
2921 {
2922     uint cmd;
2923     uint cmdsize;
2924     dylib dylib_;
2925 }
2926 
2927 struct sub_framework_command
2928 {
2929     uint cmd;
2930     uint cmdsize;
2931     lc_str umbrella;
2932 }
2933 
2934 struct sub_client_command
2935 {
2936     uint cmd;
2937     uint cmdsize;
2938     lc_str client;
2939 }
2940 
2941 struct sub_umbrella_command
2942 {
2943     uint cmd;
2944     uint cmdsize;
2945     lc_str sub_umbrella;
2946 }
2947 
2948 struct sub_library_command
2949 {
2950     uint cmd;
2951     uint cmdsize;
2952     lc_str sub_library;
2953 }
2954 
2955 struct prebound_dylib_command
2956 {
2957     uint cmd;
2958     uint cmdsize;
2959     lc_str name;
2960     uint nmodules;
2961     lc_str linked_modules;
2962 }
2963 
2964 struct dylinker_command
2965 {
2966     uint cmd;
2967     uint cmdsize;
2968     lc_str name;
2969 }
2970 
2971 struct thread_command
2972 {
2973     uint cmd;
2974     uint cmdsize;
2975 }
2976 
2977 struct routines_command
2978 {
2979     uint cmd;
2980     uint cmdsize;
2981     uint init_address;
2982     uint init_module;
2983     uint reserved1;
2984     uint reserved2;
2985     uint reserved3;
2986     uint reserved4;
2987     uint reserved5;
2988     uint reserved6;
2989 }
2990 
2991 struct routines_command_64
2992 {
2993     uint cmd;
2994     uint cmdsize;
2995     ulong init_address;
2996     ulong init_module;
2997     ulong reserved1;
2998     ulong reserved2;
2999     ulong reserved3;
3000     ulong reserved4;
3001     ulong reserved5;
3002     ulong reserved6;
3003 }
3004 
3005 struct symtab_command
3006 {
3007     uint cmd;
3008     uint cmdsize;
3009     uint symoff;
3010     uint nsyms;
3011     uint stroff;
3012     uint strsize;
3013 }
3014 
3015 struct dysymtab_command
3016 {
3017     uint cmd;
3018     uint cmdsize;
3019 
3020     uint ilocalsym;
3021     uint nlocalsym;
3022 
3023     uint iextdefsym;
3024     uint nextdefsym;
3025 
3026     uint iundefsym;
3027     uint nundefsym;
3028 
3029     uint tocoff;
3030     uint ntoc;
3031 
3032     uint modtaboff;
3033     uint nmodtab;
3034 
3035     uint extrefsymoff;
3036     uint nextrefsyms;
3037 
3038     uint indirectsymoff;
3039     uint nindirectsyms;
3040 
3041     uint extreloff;
3042     uint nextrel;
3043 
3044     uint locreloff;
3045     uint nlocrel;
3046 }
3047 
3048 enum
3049 {
3050     INDIRECT_SYMBOL_LOCAL = 0x80000000,
3051     INDIRECT_SYMBOL_ABS = 0x40000000
3052 }
3053 
3054 struct dylib_table_of_contents
3055 {
3056     uint symbol_index;
3057     uint module_index;
3058 }
3059 
3060 struct dylib_module
3061 {
3062     uint module_name;
3063 
3064     uint iextdefsym;
3065     uint nextdefsym;
3066     uint irefsym;
3067     uint nrefsym;
3068     uint ilocalsym;
3069     uint nlocalsym;
3070 
3071     uint iextrel;
3072     uint nextrel;
3073 
3074     uint iinit_iterm;
3075     uint ninit_nterm;
3076 
3077     uint objc_module_info_addr;
3078     uint objc_module_info_size;
3079 }
3080 
3081 struct dylib_module_64
3082 {
3083     uint module_name;
3084 
3085     uint iextdefsym;
3086     uint nextdefsym;
3087     uint irefsym;
3088     uint nrefsym;
3089     uint ilocalsym;
3090     uint nlocalsym;
3091 
3092     uint iextrel;
3093     uint nextrel;
3094 
3095     uint iinit_iterm;
3096     uint ninit_nterm;
3097 
3098     uint objc_module_info_size;
3099     ulong objc_module_info_addr;
3100 }
3101 
3102 struct dylib_reference
3103 {
3104     private uint storage;
3105 
3106     @property uint isym()() const pure nothrow @nogc @safe
3107     {
3108         return cast(uint) ((storage & 16777215U) >> 0U);
3109     }
3110 
3111     @property void isym()(uint v) @safe pure nothrow @nogc
3112     in(v >= 0U, "Value is smaller than the minimum value of bitfield 'isym'")
3113     in(v <= 16777215U, "Value is greater than the maximum value of bitfield 'isym'")
3114     {
3115         storage = cast(uint) ((storage & (-1 - cast(uint) 16777215U)) |
3116             ((cast(uint) v << 0U) & 16777215U));
3117     }
3118 
3119     @property uint flags()() const pure nothrow @nogc @safe
3120     {
3121         return cast(uint) ((storage & 4278190080U) >> 24U);
3122     }
3123 
3124     @property void flags()(uint v) pure nothrow @nogc @safe
3125     in(v >= 0U, "Value is smaller than the minimum value of bitfield 'flags'")
3126     in(v <= 255U, "Value is greater than the maximum value of bitfield 'flags'")
3127     {
3128         storage = cast(uint) ((storage & (-1 - cast(uint) 4278190080U)) |
3129             ((cast(uint) v << 24U) & 4278190080U));
3130     }
3131 }
3132 
3133 struct twolevel_hints_command
3134 {
3135     uint cmd;
3136     uint cmdsize;
3137     uint offset;
3138     uint nhints;
3139 }
3140 
3141 struct twolevel_hint
3142 {
3143     private uint storage;
3144 
3145     @property uint isub_image()() const pure nothrow @nogc @safe
3146     {
3147         return cast(uint) ((storage & 255U) >>0U);
3148     }
3149 
3150     @property void isub_image()(uint v) pure nothrow @nogc @safe
3151     in(v >= 0U, "Value is smaller than the minimum value of bitfield 'isub_image'")
3152     in(v <= 255U, "Value is greater than the maximum value of bitfield 'isub_image'")
3153     {
3154         storage = cast(uint) ((storage & (-1-cast(uint)255U)) |
3155             ((cast(uint) v << 0U) & 255U));
3156     }
3157 
3158     @property uint itoc()() const pure nothrow @nogc @safe
3159     {
3160         return cast(uint) ((storage & 4294967040U) >>8U);
3161     }
3162 
3163     @property void itoc()(uint v) pure nothrow @nogc @safe
3164     in(v >= 0U, "Value is smaller than the minimum value of bitfield 'itoc'")
3165     in(v <= 16777215U, "Value is greater than the maximum value of bitfield 'itoc'")
3166     {
3167         storage = cast(uint) ((storage & (-1-cast(uint)4294967040U)) |
3168             ((cast(uint) v << 8U) & 4294967040U));
3169     }
3170 }
3171 
3172 struct prebind_cksum_command
3173 {
3174     uint cmd;
3175     uint cmdsize;
3176     uint cksum;
3177 }
3178 
3179 struct uuid_command
3180 {
3181     uint cmd;
3182     uint cmdsize;
3183     ubyte[16] uuid;
3184 }
3185 
3186 struct rpath_command
3187 {
3188     uint cmd;
3189     uint cmdsize;
3190     lc_str path;
3191 }
3192 
3193 struct linkedit_data_command
3194 {
3195     uint cmd;
3196     uint cmdsize;
3197     uint dataoff;
3198     uint datasize;
3199 }
3200 
3201 struct encryption_info_command
3202 {
3203     uint cmd;
3204     uint cmdsize;
3205     uint cryptoff;
3206     uint cryptsize;
3207     uint cryptid;
3208 }
3209 
3210 struct encryption_info_command_64
3211 {
3212     uint cmd;
3213     uint cmdsize;
3214     uint cryptoff;
3215     uint cryptsize;
3216     uint cryptid;
3217     uint pad;
3218 }
3219 
3220 struct version_min_command
3221 {
3222     uint cmd;
3223     uint cmdsize;
3224     uint version_;
3225     uint sdk;
3226 }
3227 
3228 struct build_version_command
3229 {
3230     uint cmd;
3231     uint cmdsize;
3232 
3233     uint platform;
3234     uint minos;
3235     uint sdk;
3236     uint ntools;
3237 }
3238 
3239 struct build_tool_version
3240 {
3241     uint tool;
3242     uint version_;
3243 }
3244 
3245 enum
3246 {
3247     PLATFORM_MACOS = 1,
3248     PLATFORM_IOS = 2,
3249     PLATFORM_TVOS = 3,
3250     PLATFORM_WATCHOS = 4,
3251     PLATFORM_BRIDGEOS = 5,
3252     PLATFORM_UIKITFORMAC = 6,
3253     PLATFORM_IOSSIMULATOR = 7,
3254     PLATFORM_TVOSSIMULATOR = 8,
3255     PLATFORM_WATCHOSSIMULATOR = 9,
3256     PLATFORM_DRIVERKIT = 10
3257 }
3258 
3259 enum
3260 {
3261     TOOL_CLANG = 1,
3262     TOOL_SWIFT = 2,
3263     TOOL_LD = 3
3264 }
3265 
3266 struct dyld_info_command
3267 {
3268     uint cmd;
3269     uint cmdsize;
3270 
3271     uint rebase_off;
3272     uint rebase_size;
3273 
3274     uint bind_off;
3275     uint bind_size;
3276 
3277     uint weak_bind_off;
3278     uint weak_bind_size;
3279 
3280     uint lazy_bind_off;
3281     uint lazy_bind_size;
3282 
3283     uint export_off;
3284     uint export_size;
3285 }
3286 
3287 enum
3288 {
3289     REBASE_TYPE_POINTER = 1,
3290     REBASE_TYPE_TEXT_ABSOLUTE32 = 2,
3291     REBASE_TYPE_TEXT_PCREL32 = 3,
3292 
3293     REBASE_OPCODE_MASK = 0xF0,
3294     REBASE_IMMEDIATE_MASK = 0x0F,
3295     REBASE_OPCODE_DONE = 0x00,
3296     REBASE_OPCODE_SET_TYPE_IMM = 0x10,
3297     REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB = 0x20,
3298     REBASE_OPCODE_ADD_ADDR_ULEB = 0x30,
3299     REBASE_OPCODE_ADD_ADDR_IMM_SCALED = 0x40,
3300     REBASE_OPCODE_DO_REBASE_IMM_TIMES = 0x50,
3301     REBASE_OPCODE_DO_REBASE_ULEB_TIMES = 0x60,
3302     REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB = 0x70,
3303     REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB = 0x80
3304 }
3305 
3306 enum
3307 {
3308     BIND_TYPE_POINTER = 1,
3309     BIND_TYPE_TEXT_ABSOLUTE32 = 2,
3310     BIND_TYPE_TEXT_PCREL32 = 3,
3311 
3312     BIND_SPECIAL_DYLIB_SELF = 0,
3313     BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE = -1,
3314     BIND_SPECIAL_DYLIB_FLAT_LOOKUP = -2,
3315     BIND_SPECIAL_DYLIB_WEAK_LOOKUP = -3,
3316 
3317     BIND_SYMBOL_FLAGS_WEAK_IMPORT = 0x1,
3318     BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION = 0x8,
3319 
3320     BIND_OPCODE_MASK = 0xF0,
3321     BIND_IMMEDIATE_MASK = 0x0F,
3322     BIND_OPCODE_DONE = 0x00,
3323     BIND_OPCODE_SET_DYLIB_ORDINAL_IMM = 0x10,
3324     BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB = 0x20,
3325     BIND_OPCODE_SET_DYLIB_SPECIAL_IMM = 0x30,
3326     BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM = 0x40,
3327     BIND_OPCODE_SET_TYPE_IMM = 0x50,
3328     BIND_OPCODE_SET_ADDEND_SLEB = 0x60,
3329     BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB = 0x70,
3330     BIND_OPCODE_ADD_ADDR_ULEB = 0x80,
3331     BIND_OPCODE_DO_BIND = 0x90,
3332     BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB = 0xA0,
3333     BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED = 0xB0,
3334     BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB = 0xC0,
3335     BIND_OPCODE_THREADED = 0xD0,
3336     BIND_SUBOPCODE_THREADED_SET_BIND_ORDINAL_TABLE_SIZE_ULEB = 0x00,
3337     BIND_SUBOPCODE_THREADED_APPLY = 0x01
3338 }
3339 
3340 enum
3341 {
3342     EXPORT_SYMBOL_FLAGS_KIND_MASK = 0x03,
3343     EXPORT_SYMBOL_FLAGS_KIND_REGULAR = 0x00,
3344     EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL = 0x01,
3345     EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE = 0x02,
3346     EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION = 0x04,
3347     EXPORT_SYMBOL_FLAGS_REEXPORT = 0x08,
3348     EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER = 0x10
3349 }
3350 
3351 struct linker_option_command
3352 {
3353     uint cmd;
3354     uint cmdsize;
3355     uint count;
3356 }
3357 
3358 struct symseg_command
3359 {
3360     uint cmd;
3361     uint cmdsize;
3362     uint offset;
3363     uint size;
3364 }
3365 
3366 struct ident_command
3367 {
3368     uint cmd;
3369     uint cmdsize;
3370 }
3371 
3372 struct fvmfile_command
3373 {
3374     uint cmd;
3375     uint cmdsize;
3376     lc_str name;
3377     uint header_addr;
3378 }
3379 
3380 struct entry_point_command
3381 {
3382     uint cmd;
3383     uint cmdsize;
3384     ulong entryoff;
3385     ulong stacksize;
3386 }
3387 
3388 struct source_version_command
3389 {
3390     uint cmd;
3391     uint cmdsize;
3392     ulong version_;
3393 }
3394 
3395 struct data_in_code_entry
3396 {
3397     uint offset;
3398     ushort length;
3399     ushort kind;
3400 }
3401 
3402 enum
3403 {
3404     DICE_KIND_DATA = 0x0001,
3405     DICE_KIND_JUMP_TABLE8 = 0x0002,
3406     DICE_KIND_JUMP_TABLE16 = 0x0003,
3407     DICE_KIND_JUMP_TABLE32 = 0x0004,
3408     DICE_KIND_ABS_JUMP_TABLE32 = 0x0005,
3409 }
3410 
3411 struct tlv_descriptor
3412 {
3413     void* function(tlv_descriptor*) thunk;
3414     c_ulong key;
3415     c_ulong offset;
3416 }
3417 
3418 struct note_command
3419 {
3420     uint cmd;
3421     uint cmdsize;
3422     char[16] data_owner = 0;
3423     ulong offset;
3424     ulong size;
3425 }