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