]> git.saurik.com Git - apple/ld64.git/blob - src/MachOAbstraction.h
projects / apple / ld64.git / blob
? search:


fe4b01ec444d89c34e7f07161f5cac949c02dc43
[apple/ld64.git] / src / MachOAbstraction.h
1 /* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
2 *
3 * Copyright (c) 2005 Apple Computer, Inc. All rights reserved.
4 *
5 * @APPLE_LICENSE_HEADER_START@
6 *
7 * This file contains Original Code and/or Modifications of Original Code
8 * as defined in and that are subject to the Apple Public Source License
9 * Version 2.0 (the 'License'). You may not use this file except in
10 * compliance with the License. Please obtain a copy of the License at
11 * http://www.opensource.apple.com/apsl/ and read it before using this
12 * file.
13 *
14 * The Original Code and all software distributed under the License are
15 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
19 * Please see the License for the specific language governing rights and
20 * limitations under the License.
21 *
22 * @APPLE_LICENSE_HEADER_END@
23 */
24 #include <stdint.h>
25 #include <string.h>
26 #include <mach-o/nlist.h>
27 #include <mach-o/loader.h>
28 #include <libkern/OSByteOrder.h>
29
30
31 #undef ENDIAN_READ16
32 #undef ENDIAN_WRITE16
33 #undef ENDIAN_READ32
34 #undef ENDIAN_WRITE32
35 #undef ENDIAN_SWAP64
36 #undef ENDIAN_SWAP_POINTER
37
38 #if defined(MACHO_32_SAME_ENDIAN) || defined(MACHO_64_SAME_ENDIAN)
39 #define ENDIAN_READ16(x) (x)
40 #define ENDIAN_WRITE16(into, value) into = (value);
41
42 #define ENDIAN_READ32(x) (x)
43 #define ENDIAN_WRITE32(into, value) into = (value);
44
45 #define ENDIAN_SWAP64(x) (x)
46
47 #elif defined(MACHO_32_OPPOSITE_ENDIAN) || defined(MACHO_64_OPPOSITE_ENDIAN)
48 #define ENDIAN_READ16(x) OSReadSwapInt16((uint16_t*)&(x), 0)
49 #define ENDIAN_WRITE16(into, value) OSWriteSwapInt16(&(into), 0, value);
50
51 #define ENDIAN_READ32(x) OSReadSwapInt32((uint32_t*)&(x), 0)
52 #define ENDIAN_WRITE32(into, value) OSWriteSwapInt32(&(into), 0, value);
53
54 #define ENDIAN_SWAP64(x) OSSwapInt64(x)
55
56 #else
57 #error file format undefined
58 #endif
59
60
61 #if defined(MACHO_64_SAME_ENDIAN) || defined(MACHO_64_OPPOSITE_ENDIAN)
62 typedef uint64_t macho_uintptr_t;
63 typedef int64_t macho_intptr_t;
64 #else
65 typedef uint32_t macho_uintptr_t;
66 typedef int32_t macho_intptr_t;
67 #endif
68
69 #if defined(MACHO_32_SAME_ENDIAN)
70 #define ENDIAN_SWAP_POINTER(x) (x)
71 #elif defined(MACHO_64_SAME_ENDIAN)
72 #define ENDIAN_SWAP_POINTER(x) (x)
73 #elif defined(MACHO_32_OPPOSITE_ENDIAN)
74 #define ENDIAN_SWAP_POINTER(x) OSSwapInt32(x)
75 #elif defined(MACHO_64_OPPOSITE_ENDIAN)
76 #define ENDIAN_SWAP_POINTER(x) OSSwapInt64(x)
77 #else
78 #error file format undefined
79 #endif
80
81
82 #undef mach_header
83 #undef mach_header_64
84 class macho_header {
85 public:
86 uint32_t magic() const;
87 void set_magic(uint32_t);
88
89 cpu_type_t cputype() const;
90 void set_cputype(cpu_type_t);
91
92 cpu_subtype_t cpusubtype() const;
93 void set_cpusubtype(cpu_subtype_t);
94
95 uint32_t filetype() const;
96 void set_filetype(uint32_t);
97
98 uint32_t ncmds() const;
99 void set_ncmds(uint32_t);
100
101 uint32_t sizeofcmds() const;
102 void set_sizeofcmds(uint32_t);
103
104 uint32_t flags() const;
105 void set_flags(uint32_t);
106
107 void set_reserved();
108
109 #if defined(MACHO_64_SAME_ENDIAN)
110 enum { size = sizeof(mach_header_64) };
111 enum { magic_value = MH_MAGIC_64 };
112 #elif defined(MACHO_64_OPPOSITE_ENDIAN)
113 enum { size = sizeof(mach_header_64) };
114 enum { magic_value = MH_MAGIC_64 };
115 #elif defined(MACHO_32_SAME_ENDIAN)
116 enum { size = sizeof(mach_header) };
117 enum { magic_value = MH_MAGIC };
118 #elif defined(MACHO_32_OPPOSITE_ENDIAN)
119 enum { size = sizeof(mach_header) };
120 enum { magic_value = MH_MAGIC };
121 #endif
122
123 private:
124 #if defined(MACHO_64_SAME_ENDIAN) || defined(MACHO_64_OPPOSITE_ENDIAN)
125 struct mach_header_64 content;
126 #else
127 struct mach_header content;
128 #endif
129 };
130 #define mach_header __my_bad
131 #define mach_header_64 __my_bad
132
133 inline __attribute__((always_inline))
134 uint32_t macho_header::magic() const {
135 return ENDIAN_READ32(content.magic);
136 }
137
138 inline __attribute__((always_inline))
139 void macho_header::set_magic(uint32_t _value) {
140 ENDIAN_WRITE32(content.magic, _value);
141 }
142
143 inline __attribute__((always_inline))
144 cpu_type_t macho_header::cputype() const {
145 return ENDIAN_READ32(content.cputype);
146 }
147
148 inline __attribute__((always_inline))
149 void macho_header::set_cputype(cpu_type_t _value) {
150 ENDIAN_WRITE32(content.cputype, _value);
151 }
152
153 inline __attribute__((always_inline))
154 cpu_subtype_t macho_header::cpusubtype() const {
155 return ENDIAN_READ32(content.cpusubtype);
156 }
157
158 inline __attribute__((always_inline))
159 void macho_header::set_cpusubtype(cpu_subtype_t _value) {
160 ENDIAN_WRITE32(content.cpusubtype, _value);
161 }
162
163 inline __attribute__((always_inline))
164 uint32_t macho_header::filetype() const {
165 return ENDIAN_READ32(content.filetype);
166 }
167
168 inline __attribute__((always_inline))
169 void macho_header::set_filetype(uint32_t _value) {
170 ENDIAN_WRITE32(content.filetype, _value);
171 }
172
173 inline __attribute__((always_inline))
174 uint32_t macho_header::ncmds() const {
175 return ENDIAN_READ32(content.ncmds);
176 }
177
178 inline __attribute__((always_inline))
179 void macho_header::set_ncmds(uint32_t _value) {
180 ENDIAN_WRITE32(content.ncmds, _value);
181 }
182
183 inline __attribute__((always_inline))
184 uint32_t macho_header::sizeofcmds() const {
185 return ENDIAN_READ32(content.sizeofcmds);
186 }
187
188 inline __attribute__((always_inline))
189 void macho_header::set_sizeofcmds(uint32_t _value) {
190 ENDIAN_WRITE32(content.sizeofcmds, _value);
191 }
192
193 inline __attribute__((always_inline))
194 uint32_t macho_header::flags() const {
195 return ENDIAN_READ32(content.flags);
196 }
197
198 inline __attribute__((always_inline))
199 void macho_header::set_flags(uint32_t _value) {
200 ENDIAN_WRITE32(content.flags, _value);
201 }
202
203 inline __attribute__((always_inline))
204 void macho_header::set_reserved() {
205 #if defined(MACHO_64_SAME_ENDIAN) || defined(MACHO_64_OPPOSITE_ENDIAN)
206 content.reserved = 0;
207 #endif
208 }
209
210
211 #undef load_command
212 class macho_load_command {
213 public:
214 uint32_t cmd() const;
215 void set_cmd(uint32_t);
216
217 uint32_t cmdsize() const;
218 void set_cmdsize(uint32_t);
219
220 private:
221 struct load_command content;
222 };
223
224 inline __attribute__((always_inline))
225 uint32_t macho_load_command::cmd() const {
226 return ENDIAN_READ32(content.cmd);
227 }
228
229 inline __attribute__((always_inline))
230 void macho_load_command::set_cmd(uint32_t _value) {
231 ENDIAN_WRITE32(content.cmd, _value);
232 }
233
234 inline __attribute__((always_inline))
235 uint32_t macho_load_command::cmdsize() const {
236 return ENDIAN_READ32(content.cmdsize);
237 }
238
239 inline __attribute__((always_inline))
240 void macho_load_command::set_cmdsize(uint32_t _value) {
241 ENDIAN_WRITE32(content.cmdsize, _value);
242 }
243 #define load_command __my_bad
244
245
246 #undef segment_command
247 #undef segment_command_64
248 class macho_segment_command {
249 public:
250 uint32_t cmd() const;
251 void set_cmd(uint32_t);
252
253 uint32_t cmdsize() const;
254 void set_cmdsize(uint32_t);
255
256 const char* segname() const;
257 void set_segname(const char*);
258
259 uint64_t vmaddr() const;
260 void set_vmaddr(uint64_t);
261
262 uint64_t vmsize() const;
263 void set_vmsize(uint64_t);
264
265 uint64_t fileoff() const;
266 void set_fileoff(uint64_t);
267
268 uint64_t filesize() const;
269 void set_filesize(uint64_t);
270
271 vm_prot_t maxprot() const;
272 void set_maxprot(vm_prot_t);
273
274 vm_prot_t initprot() const;
275 void set_initprot(vm_prot_t);
276
277 uint32_t nsects() const;
278 void set_nsects(uint32_t);
279
280 uint32_t flags() const;
281 void set_flags(uint32_t);
282
283 enum { size =
284 #if defined(MACHO_64_SAME_ENDIAN) || defined(MACHO_64_OPPOSITE_ENDIAN)
285 sizeof(segment_command_64) };
286 #else
287 sizeof(segment_command) };
288 #endif
289
290 enum { command =
291 #if defined(MACHO_64_SAME_ENDIAN) || defined(MACHO_64_OPPOSITE_ENDIAN)
292 LC_SEGMENT_64
293 #else
294 LC_SEGMENT
295 #endif
296 };
297
298 private:
299 #if defined(MACHO_64_SAME_ENDIAN) || defined(MACHO_64_OPPOSITE_ENDIAN)
300 struct segment_command_64 content;
301 #else
302 struct segment_command content;
303 #endif
304 };
305 #define segment_command __my_bad
306 #define segment_command_64 __my_bad
307
308 inline __attribute__((always_inline))
309 uint32_t macho_segment_command::cmd() const {
310 return ENDIAN_READ32(content.cmd);
311 }
312
313 inline __attribute__((always_inline))
314 void macho_segment_command::set_cmd(uint32_t _value) {
315 ENDIAN_WRITE32(content.cmd, _value);
316 }
317
318 inline __attribute__((always_inline))
319 uint32_t macho_segment_command::cmdsize() const {
320 return ENDIAN_READ32(content.cmdsize);
321 }
322
323 inline __attribute__((always_inline))
324 void macho_segment_command::set_cmdsize(uint32_t _value) {
325 ENDIAN_WRITE32(content.cmdsize, _value);
326 }
327
328 inline __attribute__((always_inline))
329 const char* macho_segment_command::segname() const {
330 return content.segname;
331 }
332
333 inline __attribute__((always_inline))
334 void macho_segment_command::set_segname(const char* _value) {
335 strncpy(content.segname, _value, 16);
336 }
337
338 inline __attribute__((always_inline))
339 uint64_t macho_segment_command::vmaddr() const {
340 #if defined(ARCH_PPC64)
341 return ENDIAN_SWAP64(content.vmaddr);
342 #elif defined(ARCH_PPC) || defined(ARCH_I386)
343 return ENDIAN_READ32(content.vmaddr);
344 #else
345 #error unknown architecture
346 #endif
347 }
348
349 inline __attribute__((always_inline))
350 void macho_segment_command::set_vmaddr(uint64_t _value) {
351 #if defined(ARCH_PPC64)
352 content.vmaddr = ENDIAN_SWAP64(_value);
353 #elif defined(ARCH_PPC) || defined(ARCH_I386)
354 ENDIAN_WRITE32(content.vmaddr, _value);
355 #else
356 #error unknown architecture
357 #endif
358 }
359
360 inline __attribute__((always_inline))
361 uint64_t macho_segment_command::vmsize() const {
362 #if defined(ARCH_PPC64)
363 return ENDIAN_SWAP64(content.vmsize);
364 #elif defined(ARCH_PPC) || defined(ARCH_I386)
365 return ENDIAN_READ32(content.vmsize);
366 #else
367 #error unknown architecture
368 #endif
369 }
370
371 inline __attribute__((always_inline))
372 void macho_segment_command::set_vmsize(uint64_t _value) {
373 #if defined(ARCH_PPC64)
374 content.vmsize = ENDIAN_SWAP64(_value);
375 #elif defined(ARCH_PPC) || defined(ARCH_I386)
376 ENDIAN_WRITE32(content.vmsize, _value);
377 #else
378 #error unknown architecture
379 #endif
380 }
381
382 inline __attribute__((always_inline))
383 uint64_t macho_segment_command::fileoff() const {
384 #if defined(ARCH_PPC64)
385 return ENDIAN_SWAP64(content.fileoff);
386 #elif defined(ARCH_PPC) || defined(ARCH_I386)
387 return ENDIAN_READ32(content.fileoff);
388 #else
389 #error unknown architecture
390 #endif
391 }
392
393 inline __attribute__((always_inline))
394 void macho_segment_command::set_fileoff(uint64_t _value) {
395 #if defined(ARCH_PPC64)
396 content.fileoff = ENDIAN_SWAP64(_value);
397 #elif defined(ARCH_PPC) || defined(ARCH_I386)
398 ENDIAN_WRITE32(content.fileoff, _value);
399 #else
400 #error unknown architecture
401 #endif
402 }
403
404 inline __attribute__((always_inline))
405 uint64_t macho_segment_command::filesize() const {
406 #if defined(ARCH_PPC64)
407 return ENDIAN_SWAP64(content.filesize);
408 #elif defined(ARCH_PPC) || defined(ARCH_I386)
409 return ENDIAN_READ32(content.filesize);
410 #else
411 #error unknown architecture
412 #endif
413 }
414
415 inline __attribute__((always_inline))
416 void macho_segment_command::set_filesize(uint64_t _value) {
417 #if defined(ARCH_PPC64)
418 content.filesize = ENDIAN_SWAP64(_value);
419 #elif defined(ARCH_PPC) || defined(ARCH_I386)
420 ENDIAN_WRITE32(content.filesize, _value);
421 #else
422 #error unknown architecture
423 #endif
424 }
425
426 inline __attribute__((always_inline))
427 vm_prot_t macho_segment_command::maxprot() const {
428 return ENDIAN_READ32(content.maxprot);
429 }
430
431 inline __attribute__((always_inline))
432 void macho_segment_command::set_maxprot(vm_prot_t _value) {
433 ENDIAN_WRITE32(content.maxprot, _value);
434 }
435
436 inline __attribute__((always_inline))
437 vm_prot_t macho_segment_command::initprot() const {
438 return ENDIAN_READ32(content.initprot);
439 }
440
441 inline __attribute__((always_inline))
442 void macho_segment_command::set_initprot(vm_prot_t _value) {
443 ENDIAN_WRITE32(content.initprot, _value);
444 }
445
446 inline __attribute__((always_inline))
447 uint32_t macho_segment_command::nsects() const {
448 return ENDIAN_READ32(content.nsects);
449 }
450
451 inline __attribute__((always_inline))
452 void macho_segment_command::set_nsects(uint32_t _value) {
453 ENDIAN_WRITE32(content.nsects, _value);
454 }
455
456 inline __attribute__((always_inline))
457 uint32_t macho_segment_command::flags() const {
458 return ENDIAN_READ32(content.flags);
459 }
460
461 inline __attribute__((always_inline))
462 void macho_segment_command::set_flags(uint32_t _value) {
463 ENDIAN_WRITE32(content.flags, _value);
464 }
465
466 #undef section
467 #undef section_64
468 class macho_section {
469 public:
470 const char* sectname() const;
471 void set_sectname(const char*);
472
473 const char* segname() const;
474 void set_segname(const char*);
475
476 uint64_t addr() const;
477 void set_addr(uint64_t);
478
479 uint64_t size() const;
480 void set_size(uint64_t);
481
482 uint32_t offset() const;
483 void set_offset(uint32_t);
484
485 uint32_t align() const;
486 void set_align(uint32_t);
487
488 uint32_t reloff() const;
489 void set_reloff(uint32_t);
490
491 uint32_t nreloc() const;
492 void set_nreloc(uint32_t);
493
494 uint32_t flags() const;
495 void set_flags(uint32_t);
496
497 uint32_t reserved1() const;
498 void set_reserved1(uint32_t);
499
500 uint32_t reserved2() const;
501 void set_reserved2(uint32_t);
502
503 enum { content_size =
504 #if defined(MACHO_64_SAME_ENDIAN) || defined(MACHO_64_OPPOSITE_ENDIAN)
505 sizeof(section_64) };
506 #else
507 sizeof(section) };
508 #endif
509
510 private:
511 #if defined(MACHO_64_SAME_ENDIAN) || defined(MACHO_64_OPPOSITE_ENDIAN)
512 struct section_64 content;
513 #else
514 struct section content;
515 #endif
516 };
517 #define section __my_bad
518 #define section_64 __my_bad
519
520 inline __attribute__((always_inline))
521 const char* macho_section::sectname() const {
522 return content.sectname;
523 }
524
525 inline __attribute__((always_inline))
526 void macho_section::set_sectname(const char* _value) {
527 strncpy(content.sectname, _value, 16);
528 }
529
530 inline __attribute__((always_inline))
531 const char* macho_section::segname() const {
532 return content.segname;
533 }
534
535 inline __attribute__((always_inline))
536 void macho_section::set_segname(const char* _value) {
537 strncpy(content.segname, _value, 16);
538 }
539
540 inline __attribute__((always_inline))
541 uint64_t macho_section::addr() const {
542 #if defined(ARCH_PPC64)
543 return ENDIAN_SWAP64(content.addr);
544 #elif defined(ARCH_PPC) || defined(ARCH_I386)
545 return ENDIAN_READ32(content.addr);
546 #else
547 #error unknown architecture
548 #endif
549 }
550
551 inline __attribute__((always_inline))
552 void macho_section::set_addr(uint64_t _value) {
553 #if defined(ARCH_PPC64)
554 content.addr = ENDIAN_SWAP64(_value);
555 #elif defined(ARCH_PPC) || defined(ARCH_I386)
556 ENDIAN_WRITE32(content.addr, _value);
557 #else
558 #error unknown architecture
559 #endif
560 }
561
562 inline __attribute__((always_inline))
563 uint64_t macho_section::size() const {
564 #if defined(ARCH_PPC64)
565 return ENDIAN_SWAP64(content.size);
566 #elif defined(ARCH_PPC) || defined(ARCH_I386)
567 return ENDIAN_READ32(content.size);
568 #else
569 #error unknown architecture
570 #endif
571 }
572
573 inline __attribute__((always_inline))
574 void macho_section::set_size(uint64_t _value) {
575 #if defined(ARCH_PPC64)
576 content.size = ENDIAN_SWAP64(_value);
577 #elif defined(ARCH_PPC) || defined(ARCH_I386)
578 ENDIAN_WRITE32(content.size, _value);
579 #else
580 #error unknown architecture
581 #endif
582 }
583
584 inline __attribute__((always_inline))
585 uint32_t macho_section::offset() const {
586 return ENDIAN_READ32(content.offset);
587 }
588
589 inline __attribute__((always_inline))
590 void macho_section::set_offset(uint32_t _value) {
591 ENDIAN_WRITE32(content.offset, _value);
592 }
593
594 inline __attribute__((always_inline))
595 uint32_t macho_section::align() const {
596 return ENDIAN_READ32(content.align);
597 }
598
599 inline __attribute__((always_inline))
600 void macho_section::set_align(uint32_t _value) {
601 ENDIAN_WRITE32(content.align, _value);
602 }
603
604 inline __attribute__((always_inline))
605 uint32_t macho_section::reloff() const {
606 return ENDIAN_READ32(content.reloff);
607 }
608
609 inline __attribute__((always_inline))
610 void macho_section::set_reloff(uint32_t _value) {
611 ENDIAN_WRITE32(content.reloff, _value);
612 }
613
614 inline __attribute__((always_inline))
615 uint32_t macho_section::nreloc() const {
616 return ENDIAN_READ32(content.nreloc);
617 }
618
619 inline __attribute__((always_inline))
620 void macho_section::set_nreloc(uint32_t _value) {
621 ENDIAN_WRITE32(content.nreloc, _value);
622 }
623
624 inline __attribute__((always_inline))
625 uint32_t macho_section::flags() const {
626 return ENDIAN_READ32(content.flags);
627 }
628
629 inline __attribute__((always_inline))
630 void macho_section::set_flags(uint32_t _value) {
631 ENDIAN_WRITE32(content.flags, _value);
632 }
633
634 inline __attribute__((always_inline))
635 uint32_t macho_section::reserved1() const {
636 return ENDIAN_READ32(content.reserved1);
637 }
638
639 inline __attribute__((always_inline))
640 void macho_section::set_reserved1(uint32_t _value) {
641 ENDIAN_WRITE32(content.reserved1, _value);
642 }
643
644 inline __attribute__((always_inline))
645 uint32_t macho_section::reserved2() const {
646 return ENDIAN_READ32(content.reserved2);
647 }
648
649 inline __attribute__((always_inline))
650 void macho_section::set_reserved2(uint32_t _value) {
651 ENDIAN_WRITE32(content.reserved2, _value);
652 }
653
654 #undef dylib_command
655 class macho_dylib_command {
656 public:
657 uint32_t cmd() const;
658 void set_cmd(uint32_t);
659
660 uint32_t cmdsize() const;
661 void set_cmdsize(uint32_t);
662
663 const char* name() const;
664 void set_name_offset();
665
666 uint32_t timestamp() const;
667 void set_timestamp(uint32_t);
668
669 uint32_t current_version() const;
670 void set_current_version(uint32_t);
671
672 uint32_t compatibility_version() const;
673 void set_compatibility_version(uint32_t);
674
675 enum { name_offset = sizeof(struct dylib_command) };
676
677 private:
678 struct dylib_command content;
679 };
680 #define dylib_command __my_bad
681
682 inline __attribute__((always_inline))
683 uint32_t macho_dylib_command::cmd() const {
684 return ENDIAN_READ32(content.cmd);
685 }
686
687 inline __attribute__((always_inline))
688 void macho_dylib_command::set_cmd(uint32_t _value) {
689 ENDIAN_WRITE32(content.cmd, _value);
690 }
691
692 inline __attribute__((always_inline))
693 uint32_t macho_dylib_command::cmdsize() const {
694 return ENDIAN_READ32(content.cmdsize);
695 }
696
697 inline __attribute__((always_inline))
698 void macho_dylib_command::set_cmdsize(uint32_t _value) {
699 ENDIAN_WRITE32(content.cmdsize, _value);
700 }
701
702 inline __attribute__((always_inline))
703 const char* macho_dylib_command::name() const {
704 return (char*)(&content) + ENDIAN_READ32(content.dylib.name.offset);
705 }
706
707 inline __attribute__((always_inline))
708 void macho_dylib_command::set_name_offset() {
709 ENDIAN_WRITE32(content.dylib.name.offset, name_offset);
710 }
711
712 inline __attribute__((always_inline))
713 uint32_t macho_dylib_command::timestamp() const {
714 return ENDIAN_READ32(content.dylib.timestamp);
715 }
716
717 inline __attribute__((always_inline))
718 void macho_dylib_command::set_timestamp(uint32_t _value) {
719 ENDIAN_WRITE32(content.dylib.timestamp, _value);
720 }
721
722 inline __attribute__((always_inline))
723 uint32_t macho_dylib_command::current_version() const {
724 return ENDIAN_READ32(content.dylib.current_version);
725 }
726
727 inline __attribute__((always_inline))
728 void macho_dylib_command::set_current_version(uint32_t _value) {
729 ENDIAN_WRITE32(content.dylib.current_version, _value);
730 }
731
732 inline __attribute__((always_inline))
733 uint32_t macho_dylib_command::compatibility_version() const {
734 return ENDIAN_READ32(content.dylib.compatibility_version);
735 }
736
737 inline __attribute__((always_inline))
738 void macho_dylib_command::set_compatibility_version(uint32_t _value) {
739 ENDIAN_WRITE32(content.dylib.compatibility_version, _value);
740 }
741
742
743
744 #undef dylinker_command
745 class macho_dylinker_command {
746 public:
747 uint32_t cmd() const;
748 void set_cmd(uint32_t);
749
750 uint32_t cmdsize() const;
751 void set_cmdsize(uint32_t);
752
753 void set_name_offset();
754
755 enum { name_offset = sizeof(struct dylinker_command) };
756
757 private:
758 struct dylinker_command content;
759 };
760 #define dylinker_command __my_bad
761
762 inline __attribute__((always_inline))
763 uint32_t macho_dylinker_command::cmd() const {
764 return ENDIAN_READ32(content.cmd);
765 }
766
767 inline __attribute__((always_inline))
768 void macho_dylinker_command::set_cmd(uint32_t _value) {
769 ENDIAN_WRITE32(content.cmd, _value);
770 }
771
772 inline __attribute__((always_inline))
773 uint32_t macho_dylinker_command::cmdsize() const {
774 return ENDIAN_READ32(content.cmdsize);
775 }
776
777 inline __attribute__((always_inline))
778 void macho_dylinker_command::set_cmdsize(uint32_t _value) {
779 ENDIAN_WRITE32(content.cmdsize, _value);
780 }
781
782 inline __attribute__((always_inline))
783 void macho_dylinker_command::set_name_offset() {
784 ENDIAN_WRITE32(content.name.offset, name_offset);
785 }
786
787
788
789 #undef sub_framework_command
790 class macho_sub_framework_command {
791 public:
792 uint32_t cmd() const;
793 void set_cmd(uint32_t);
794
795 uint32_t cmdsize() const;
796 void set_cmdsize(uint32_t);
797
798 const char* name() const;
799 void set_name_offset();
800
801 enum { name_offset = sizeof(struct sub_framework_command) };
802
803 private:
804 struct sub_framework_command content;
805 };
806 #define sub_framework_command __my_bad
807
808 inline __attribute__((always_inline))
809 uint32_t macho_sub_framework_command::cmd() const {
810 return ENDIAN_READ32(content.cmd);
811 }
812
813 inline __attribute__((always_inline))
814 void macho_sub_framework_command::set_cmd(uint32_t _value) {
815 ENDIAN_WRITE32(content.cmd, _value);
816 }
817
818 inline __attribute__((always_inline))
819 uint32_t macho_sub_framework_command::cmdsize() const {
820 return ENDIAN_READ32(content.cmdsize);
821 }
822
823 inline __attribute__((always_inline))
824 void macho_sub_framework_command::set_cmdsize(uint32_t _value) {
825 ENDIAN_WRITE32(content.cmdsize, _value);
826 }
827
828 inline __attribute__((always_inline))
829 const char* macho_sub_framework_command::name() const {
830 return (char*)(&content) + ENDIAN_READ32(content.umbrella.offset);
831 }
832
833 inline __attribute__((always_inline))
834 void macho_sub_framework_command::set_name_offset() {
835 ENDIAN_WRITE32(content.umbrella.offset, name_offset);
836 }
837
838 #undef sub_client_command
839 class macho_sub_client_command {
840 public:
841 uint32_t cmd() const;
842 void set_cmd(uint32_t);
843
844 uint32_t cmdsize() const;
845 void set_cmdsize(uint32_t);
846
847 const char* name() const;
848 void set_name_offset();
849
850 enum { name_offset = sizeof(struct sub_client_command) };
851 private:
852 struct sub_client_command content;
853 };
854 #define sub_client_command __my_bad
855
856 inline __attribute__((always_inline))
857 uint32_t macho_sub_client_command::cmd() const {
858 return ENDIAN_READ32(content.cmd);
859 }
860
861 inline __attribute__((always_inline))
862 void macho_sub_client_command::set_cmd(uint32_t _value) {
863 ENDIAN_WRITE32(content.cmd, _value);
864 }
865
866 inline __attribute__((always_inline))
867 uint32_t macho_sub_client_command::cmdsize() const {
868 return ENDIAN_READ32(content.cmdsize);
869 }
870
871 inline __attribute__((always_inline))
872 void macho_sub_client_command::set_cmdsize(uint32_t _value) {
873 ENDIAN_WRITE32(content.cmdsize, _value);
874 }
875
876 inline __attribute__((always_inline))
877 const char* macho_sub_client_command::name() const {
878 return (char*)(&content) + ENDIAN_READ32(content.client.offset);
879 }
880
881 inline __attribute__((always_inline))
882 void macho_sub_client_command::set_name_offset() {
883 ENDIAN_WRITE32(content.client.offset, name_offset);
884 }
885
886
887
888 #undef sub_umbrella_command
889 class macho_sub_umbrella_command {
890 public:
891 uint32_t cmd() const;
892 void set_cmd(uint32_t);
893
894 uint32_t cmdsize() const;
895 void set_cmdsize(uint32_t);
896
897 const char* name() const;
898 void set_name_offset();
899
900 enum { name_offset = sizeof(struct sub_umbrella_command) };
901 private:
902 struct sub_umbrella_command content;
903 };
904 #define sub_umbrella_command __my_bad
905
906 inline __attribute__((always_inline))
907 uint32_t macho_sub_umbrella_command::cmd() const {
908 return ENDIAN_READ32(content.cmd);
909 }
910
911 inline __attribute__((always_inline))
912 void macho_sub_umbrella_command::set_cmd(uint32_t _value) {
913 ENDIAN_WRITE32(content.cmd, _value);
914 }
915
916 inline __attribute__((always_inline))
917 uint32_t macho_sub_umbrella_command::cmdsize() const {
918 return ENDIAN_READ32(content.cmdsize);
919 }
920
921 inline __attribute__((always_inline))
922 void macho_sub_umbrella_command::set_cmdsize(uint32_t _value) {
923 ENDIAN_WRITE32(content.cmdsize, _value);
924 }
925
926 inline __attribute__((always_inline))
927 const char* macho_sub_umbrella_command::name() const {
928 return (char*)(&content) + ENDIAN_READ32(content.sub_umbrella.offset);
929 }
930
931 inline __attribute__((always_inline))
932 void macho_sub_umbrella_command::set_name_offset() {
933 ENDIAN_WRITE32(content.sub_umbrella.offset, name_offset);
934 }
935
936
937
938
939 #undef sub_library_command
940 class macho_sub_library_command {
941 public:
942 uint32_t cmd() const;
943 void set_cmd(uint32_t);
944
945 uint32_t cmdsize() const;
946 void set_cmdsize(uint32_t);
947
948 const char* name() const;
949 void set_name_offset();
950
951 enum { name_offset = sizeof(struct sub_library_command) };
952 private:
953 struct sub_library_command content;
954 };
955 #define sub_library_command __my_bad
956
957 inline __attribute__((always_inline))
958 uint32_t macho_sub_library_command::cmd() const {
959 return ENDIAN_READ32(content.cmd);
960 }
961
962 inline __attribute__((always_inline))
963 void macho_sub_library_command::set_cmd(uint32_t _value) {
964 ENDIAN_WRITE32(content.cmd, _value);
965 }
966
967 inline __attribute__((always_inline))
968 uint32_t macho_sub_library_command::cmdsize() const {
969 return ENDIAN_READ32(content.cmdsize);
970 }
971
972 inline __attribute__((always_inline))
973 void macho_sub_library_command::set_cmdsize(uint32_t _value) {
974 ENDIAN_WRITE32(content.cmdsize, _value);
975 }
976
977 inline __attribute__((always_inline))
978 const char* macho_sub_library_command::name() const {
979 return (char*)(&content) + ENDIAN_READ32(content.sub_library.offset);
980 }
981
982 inline __attribute__((always_inline))
983 void macho_sub_library_command::set_name_offset() {
984 ENDIAN_WRITE32(content.sub_library.offset, name_offset);
985 }
986
987
988
989 #undef routines_command
990 #undef routines_command_64
991 class macho_routines_command {
992 public:
993 uint32_t cmd() const;
994 void set_cmd(uint32_t);
995
996 uint32_t cmdsize() const;
997 void set_cmdsize(uint32_t);
998
999 uint64_t init_address() const;
1000 void set_init_address(uint64_t);
1001
1002 uint64_t init_module() const;
1003 void set_init_module(uint64_t);
1004
1005 #if defined(MACHO_64_SAME_ENDIAN) || defined(MACHO_64_OPPOSITE_ENDIAN)
1006 enum { size = sizeof(struct routines_command_64) };
1007 enum { command = LC_ROUTINES_64 };
1008 #else
1009 enum { size = sizeof(struct routines_command) };
1010 enum { command = LC_ROUTINES };
1011 #endif
1012
1013 private:
1014 #if defined(MACHO_64_SAME_ENDIAN) || defined(MACHO_64_OPPOSITE_ENDIAN)
1015 struct routines_command_64 content;
1016 #else
1017 struct routines_command content;
1018 #endif
1019 };
1020 #define routines_command __my_bad
1021 #define routines_command_64 __my_bad
1022
1023 inline __attribute__((always_inline))
1024 uint32_t macho_routines_command::cmd() const {
1025 return ENDIAN_READ32(content.cmd);
1026 }
1027
1028 inline __attribute__((always_inline))
1029 void macho_routines_command::set_cmd(uint32_t _value) {
1030 ENDIAN_WRITE32(content.cmd, _value);
1031 }
1032
1033 inline __attribute__((always_inline))
1034 uint32_t macho_routines_command::cmdsize() const {
1035 return ENDIAN_READ32(content.cmdsize);
1036 }
1037
1038 inline __attribute__((always_inline))
1039 void macho_routines_command::set_cmdsize(uint32_t _value) {
1040 ENDIAN_WRITE32(content.cmdsize, _value);
1041 }
1042
1043 inline __attribute__((always_inline))
1044 uint64_t macho_routines_command::init_address() const {
1045 #if defined(ARCH_PPC64)
1046 return ENDIAN_SWAP64(content.init_address);
1047 #elif defined(ARCH_PPC) || defined(ARCH_I386)
1048 return ENDIAN_READ32(content.init_address);
1049 #else
1050 #error unknown architecture
1051 #endif
1052 }
1053
1054 inline __attribute__((always_inline))
1055 void macho_routines_command::set_init_address(uint64_t _value) {
1056 #if defined(ARCH_PPC64)
1057 content.init_address = ENDIAN_SWAP64(_value);
1058 #elif defined(ARCH_PPC) || defined(ARCH_I386)
1059 ENDIAN_WRITE32(content.init_address, _value);
1060 #else
1061 #error unknown architecture
1062 #endif
1063 }
1064
1065 inline __attribute__((always_inline))
1066 uint64_t macho_routines_command::init_module() const {
1067 #if defined(ARCH_PPC64)
1068 return ENDIAN_SWAP64(content.init_module);
1069 #elif defined(ARCH_PPC) || defined(ARCH_I386)
1070 return ENDIAN_READ32(content.init_module);
1071 #else
1072 #error unknown architecture
1073 #endif
1074 }
1075
1076 inline __attribute__((always_inline))
1077 void macho_routines_command::set_init_module(uint64_t _value) {
1078 #if defined(ARCH_PPC64)
1079 content.init_module = ENDIAN_SWAP64(_value);
1080 #elif defined(ARCH_PPC) || defined(ARCH_I386)
1081 ENDIAN_WRITE32(content.init_module, _value);
1082 #else
1083 #error unknown architecture
1084 #endif
1085 }
1086
1087
1088
1089 #undef symtab_command
1090 class macho_symtab_command {
1091 public:
1092 uint32_t cmd() const;
1093 void set_cmd(uint32_t);
1094
1095 uint32_t cmdsize() const;
1096 void set_cmdsize(uint32_t);
1097
1098 uint32_t symoff() const;
1099 void set_symoff(uint32_t);
1100
1101 uint32_t nsyms() const;
1102 void set_nsyms(uint32_t);
1103
1104 uint32_t stroff() const;
1105 void set_stroff(uint32_t);
1106
1107 uint32_t strsize() const;
1108 void set_strsize(uint32_t);
1109
1110 enum { size = sizeof(struct symtab_command ) };
1111
1112 private:
1113 struct symtab_command content;
1114 };
1115 #define symtab_command __my_bad
1116
1117
1118 inline __attribute__((always_inline))
1119 uint32_t macho_symtab_command::cmd() const {
1120 return ENDIAN_READ32(content.cmd);
1121 }
1122
1123 inline __attribute__((always_inline))
1124 void macho_symtab_command::set_cmd(uint32_t _value) {
1125 ENDIAN_WRITE32(content.cmd, _value);
1126 }
1127
1128 inline __attribute__((always_inline))
1129 uint32_t macho_symtab_command::cmdsize() const {
1130 return ENDIAN_READ32(content.cmdsize);
1131 }
1132
1133 inline __attribute__((always_inline))
1134 void macho_symtab_command::set_cmdsize(uint32_t _value) {
1135 ENDIAN_WRITE32(content.cmdsize, _value);
1136 }
1137
1138 inline __attribute__((always_inline))
1139 uint32_t macho_symtab_command::symoff() const {
1140 return ENDIAN_READ32(content.symoff);
1141 }
1142
1143 inline __attribute__((always_inline))
1144 void macho_symtab_command::set_symoff(uint32_t _value) {
1145 ENDIAN_WRITE32(content.symoff, _value);
1146 }
1147
1148 inline __attribute__((always_inline))
1149 uint32_t macho_symtab_command::nsyms() const {
1150 return ENDIAN_READ32(content.nsyms);
1151 }
1152
1153 inline __attribute__((always_inline))
1154 void macho_symtab_command::set_nsyms(uint32_t _value) {
1155 ENDIAN_WRITE32(content.nsyms, _value);
1156 }
1157
1158 inline __attribute__((always_inline))
1159 uint32_t macho_symtab_command::stroff() const {
1160 return ENDIAN_READ32(content.stroff);
1161 }
1162
1163 inline __attribute__((always_inline))
1164 void macho_symtab_command::set_stroff(uint32_t _value) {
1165 ENDIAN_WRITE32(content.stroff, _value);
1166 }
1167
1168 inline __attribute__((always_inline))
1169 uint32_t macho_symtab_command::strsize() const {
1170 return ENDIAN_READ32(content.strsize);
1171 }
1172
1173 inline __attribute__((always_inline))
1174 void macho_symtab_command::set_strsize(uint32_t _value) {
1175 ENDIAN_WRITE32(content.strsize, _value);
1176 }
1177
1178
1179 #undef dysymtab_command
1180 class macho_dysymtab_command {
1181 public:
1182 uint32_t cmd() const;
1183 void set_cmd(uint32_t);
1184
1185 uint32_t cmdsize() const;
1186 void set_cmdsize(uint32_t);
1187
1188 uint32_t ilocalsym() const;
1189 void set_ilocalsym(uint32_t);
1190
1191 uint32_t nlocalsym() const;
1192 void set_nlocalsym(uint32_t);
1193
1194 uint32_t iextdefsym() const;
1195 void set_iextdefsym(uint32_t);
1196
1197 uint32_t nextdefsym() const;
1198 void set_nextdefsym(uint32_t);
1199
1200 uint32_t iundefsym() const;
1201 void set_iundefsym(uint32_t);
1202
1203 uint32_t nundefsym() const;
1204 void set_nundefsym(uint32_t);
1205
1206 uint32_t tocoff() const;
1207 void set_tocoff(uint32_t);
1208
1209 uint32_t ntoc() const;
1210 void set_ntoc(uint32_t);
1211
1212 uint32_t modtaboff() const;
1213 void set_modtaboff(uint32_t);
1214
1215 uint32_t nmodtab() const;
1216 void set_nmodtab(uint32_t);
1217
1218 uint32_t extrefsymoff() const;
1219 void set_extrefsymoff(uint32_t);
1220
1221 uint32_t nextrefsyms() const;
1222 void set_nextrefsyms(uint32_t);
1223
1224 uint32_t indirectsymoff() const;
1225 void set_indirectsymoff(uint32_t);
1226
1227 uint32_t nindirectsyms() const;
1228 void set_nindirectsyms(uint32_t);
1229
1230 uint32_t extreloff() const;
1231 void set_extreloff(uint32_t);
1232
1233 uint32_t nextrel() const;
1234 void set_nextrel(uint32_t);
1235
1236 uint32_t locreloff() const;
1237 void set_locreloff(uint32_t);
1238
1239 uint32_t nlocrel() const;
1240 void set_nlocrel(uint32_t);
1241
1242 enum { size = sizeof(struct dysymtab_command ) };
1243 private:
1244 struct dysymtab_command content;
1245 };
1246 #define dysymtab_command __my_bad
1247
1248 inline __attribute__((always_inline))
1249 uint32_t macho_dysymtab_command::cmd() const {
1250 return ENDIAN_READ32(content.cmd);
1251 }
1252
1253 inline __attribute__((always_inline))
1254 void macho_dysymtab_command::set_cmd(uint32_t _value) {
1255 ENDIAN_WRITE32(content.cmd, _value);
1256 }
1257
1258 inline __attribute__((always_inline))
1259 uint32_t macho_dysymtab_command::cmdsize() const {
1260 return ENDIAN_READ32(content.cmdsize);
1261 }
1262
1263 inline __attribute__((always_inline))
1264 void macho_dysymtab_command::set_cmdsize(uint32_t _value) {
1265 ENDIAN_WRITE32(content.cmdsize, _value);
1266 }
1267
1268 inline __attribute__((always_inline))
1269 uint32_t macho_dysymtab_command::ilocalsym() const {
1270 return ENDIAN_READ32(content.ilocalsym);
1271 }
1272
1273 inline __attribute__((always_inline))
1274 void macho_dysymtab_command::set_ilocalsym(uint32_t _value) {
1275 ENDIAN_WRITE32(content.ilocalsym, _value);
1276 }
1277
1278 inline __attribute__((always_inline))
1279 uint32_t macho_dysymtab_command::nlocalsym() const {
1280 return ENDIAN_READ32(content.nlocalsym);
1281 }
1282
1283 inline __attribute__((always_inline))
1284 void macho_dysymtab_command::set_nlocalsym(uint32_t _value) {
1285 ENDIAN_WRITE32(content.nlocalsym, _value);
1286 }
1287
1288 inline __attribute__((always_inline))
1289 uint32_t macho_dysymtab_command::iextdefsym() const {
1290 return ENDIAN_READ32(content.iextdefsym);
1291 }
1292
1293 inline __attribute__((always_inline))
1294 void macho_dysymtab_command::set_iextdefsym(uint32_t _value) {
1295 ENDIAN_WRITE32(content.iextdefsym, _value);
1296 }
1297
1298 inline __attribute__((always_inline))
1299 uint32_t macho_dysymtab_command::nextdefsym() const {
1300 return ENDIAN_READ32(content.nextdefsym);
1301 }
1302
1303 inline __attribute__((always_inline))
1304 void macho_dysymtab_command::set_nextdefsym(uint32_t _value) {
1305 ENDIAN_WRITE32(content.nextdefsym, _value);
1306 }
1307
1308 inline __attribute__((always_inline))
1309 uint32_t macho_dysymtab_command::iundefsym() const {
1310 return ENDIAN_READ32(content.iundefsym);
1311 }
1312
1313 inline __attribute__((always_inline))
1314 void macho_dysymtab_command::set_iundefsym(uint32_t _value) {
1315 ENDIAN_WRITE32(content.iundefsym, _value);
1316 }
1317
1318 inline __attribute__((always_inline))
1319 uint32_t macho_dysymtab_command::nundefsym() const {
1320 return ENDIAN_READ32(content.nundefsym);
1321 }
1322
1323 inline __attribute__((always_inline))
1324 void macho_dysymtab_command::set_nundefsym(uint32_t _value) {
1325 ENDIAN_WRITE32(content.nundefsym, _value);
1326 }
1327
1328 inline __attribute__((always_inline))
1329 uint32_t macho_dysymtab_command::tocoff() const {
1330 return ENDIAN_READ32(content.tocoff);
1331 }
1332
1333 inline __attribute__((always_inline))
1334 void macho_dysymtab_command::set_tocoff(uint32_t _value) {
1335 ENDIAN_WRITE32(content.tocoff, _value);
1336 }
1337
1338 inline __attribute__((always_inline))
1339 uint32_t macho_dysymtab_command::ntoc() const {
1340 return ENDIAN_READ32(content.ntoc);
1341 }
1342
1343 inline __attribute__((always_inline))
1344 void macho_dysymtab_command::set_ntoc(uint32_t _value) {
1345 ENDIAN_WRITE32(content.ntoc, _value);
1346 }
1347
1348 inline __attribute__((always_inline))
1349 uint32_t macho_dysymtab_command::modtaboff() const {
1350 return ENDIAN_READ32(content.modtaboff);
1351 }
1352
1353 inline __attribute__((always_inline))
1354 void macho_dysymtab_command::set_modtaboff(uint32_t _value) {
1355 ENDIAN_WRITE32(content.modtaboff, _value);
1356 }
1357
1358 inline __attribute__((always_inline))
1359 uint32_t macho_dysymtab_command::nmodtab() const {
1360 return ENDIAN_READ32(content.nmodtab);
1361 }
1362
1363 inline __attribute__((always_inline))
1364 void macho_dysymtab_command::set_nmodtab(uint32_t _value) {
1365 ENDIAN_WRITE32(content.nmodtab, _value);
1366 }
1367
1368 inline __attribute__((always_inline))
1369 uint32_t macho_dysymtab_command::extrefsymoff() const {
1370 return ENDIAN_READ32(content.extrefsymoff);
1371 }
1372
1373 inline __attribute__((always_inline))
1374 void macho_dysymtab_command::set_extrefsymoff(uint32_t _value) {
1375 ENDIAN_WRITE32(content.extrefsymoff, _value);
1376 }
1377
1378 inline __attribute__((always_inline))
1379 uint32_t macho_dysymtab_command::nextrefsyms() const {
1380 return ENDIAN_READ32(content.nextrefsyms);
1381 }
1382
1383 inline __attribute__((always_inline))
1384 void macho_dysymtab_command::set_nextrefsyms(uint32_t _value) {
1385 ENDIAN_WRITE32(content.nextrefsyms, _value);
1386 }
1387
1388 inline __attribute__((always_inline))
1389 uint32_t macho_dysymtab_command::indirectsymoff() const {
1390 return ENDIAN_READ32(content.indirectsymoff);
1391 }
1392
1393 inline __attribute__((always_inline))
1394 void macho_dysymtab_command::set_indirectsymoff(uint32_t _value) {
1395 ENDIAN_WRITE32(content.indirectsymoff, _value);
1396 }
1397
1398 inline __attribute__((always_inline))
1399 uint32_t macho_dysymtab_command::nindirectsyms() const {
1400 return ENDIAN_READ32(content.nindirectsyms);
1401 }
1402
1403 inline __attribute__((always_inline))
1404 void macho_dysymtab_command::set_nindirectsyms(uint32_t _value) {
1405 ENDIAN_WRITE32(content.nindirectsyms, _value);
1406 }
1407
1408 inline __attribute__((always_inline))
1409 uint32_t macho_dysymtab_command::extreloff() const {
1410 return ENDIAN_READ32(content.extreloff);
1411 }
1412
1413 inline __attribute__((always_inline))
1414 void macho_dysymtab_command::set_extreloff(uint32_t _value) {
1415 ENDIAN_WRITE32(content.extreloff, _value);
1416 }
1417
1418 inline __attribute__((always_inline))
1419 uint32_t macho_dysymtab_command::nextrel() const {
1420 return ENDIAN_READ32(content.nextrel);
1421 }
1422
1423 inline __attribute__((always_inline))
1424 void macho_dysymtab_command::set_nextrel(uint32_t _value) {
1425 ENDIAN_WRITE32(content.nextrel, _value);
1426 }
1427
1428 inline __attribute__((always_inline))
1429 uint32_t macho_dysymtab_command::locreloff() const {
1430 return ENDIAN_READ32(content.locreloff);
1431 }
1432
1433 inline __attribute__((always_inline))
1434 void macho_dysymtab_command::set_locreloff(uint32_t _value) {
1435 ENDIAN_WRITE32(content.locreloff, _value);
1436 }
1437
1438 inline __attribute__((always_inline))
1439 uint32_t macho_dysymtab_command::nlocrel() const {
1440 return ENDIAN_READ32(content.nlocrel);
1441 }
1442
1443 inline __attribute__((always_inline))
1444 void macho_dysymtab_command::set_nlocrel(uint32_t _value) {
1445 ENDIAN_WRITE32(content.nlocrel, _value);
1446 }
1447
1448
1449
1450 #undef twolevel_hints_command
1451 class macho_twolevel_hints_command {
1452 public:
1453 uint32_t cmd() const;
1454 void set_cmd(uint32_t);
1455
1456 uint32_t cmdsize() const;
1457 void set_cmdsize(uint32_t);
1458
1459 uint32_t offset() const;
1460 void set_offset(uint32_t);
1461
1462 uint32_t nhints() const;
1463 void set_nhints(uint32_t);
1464
1465 private:
1466 struct twolevel_hints_command content;
1467 };
1468 #define twolevel_hints_command __my_bad
1469
1470 inline __attribute__((always_inline))
1471 uint32_t macho_twolevel_hints_command::cmd() const {
1472 return ENDIAN_READ32(content.cmd);
1473 }
1474
1475 inline __attribute__((always_inline))
1476 void macho_twolevel_hints_command::set_cmd(uint32_t _value) {
1477 ENDIAN_WRITE32(content.cmd, _value);
1478 }
1479
1480 inline __attribute__((always_inline))
1481 uint32_t macho_twolevel_hints_command::cmdsize() const {
1482 return ENDIAN_READ32(content.cmdsize);
1483 }
1484
1485 inline __attribute__((always_inline))
1486 void macho_twolevel_hints_command::set_cmdsize(uint32_t _value) {
1487 ENDIAN_WRITE32(content.cmdsize, _value);
1488 }
1489
1490 inline __attribute__((always_inline))
1491 uint32_t macho_twolevel_hints_command::offset() const {
1492 return ENDIAN_READ32(content.offset);
1493 }
1494
1495 inline __attribute__((always_inline))
1496 void macho_twolevel_hints_command::set_offset(uint32_t _value) {
1497 ENDIAN_WRITE32(content.offset, _value);
1498 }
1499
1500 inline __attribute__((always_inline))
1501 uint32_t macho_twolevel_hints_command::nhints() const {
1502 return ENDIAN_READ32(content.nhints);
1503 }
1504
1505 inline __attribute__((always_inline))
1506 void macho_twolevel_hints_command::set_nhints(uint32_t _value) {
1507 ENDIAN_WRITE32(content.nhints, _value);
1508 }
1509
1510
1511 #undef thread_command
1512 class macho_thread_command {
1513 public:
1514 uint32_t cmd() const;
1515 void set_cmd(uint32_t);
1516
1517 uint32_t cmdsize() const;
1518 void set_cmdsize(uint32_t);
1519
1520 uint32_t flavor() const;
1521 void set_flavor(uint32_t);
1522
1523 uint32_t count() const;
1524 void set_count(uint32_t);
1525
1526 uint32_t threadState32(uint32_t index) const;
1527 void set_threadState32(uint32_t index, uint32_t value);
1528
1529 uint64_t threadState64(uint32_t offset) const;
1530 void set_threadState64(uint32_t index, uint64_t value);
1531
1532 enum { size = sizeof(struct thread_command) + 8 };
1533
1534 private:
1535 struct thread_command content;
1536 uint32_t content_flavor;
1537 uint32_t content_count;
1538 uint32_t threadState[1];
1539 };
1540 #define thread_command __my_bad
1541
1542 inline __attribute__((always_inline))
1543 uint32_t macho_thread_command::cmd() const {
1544 return ENDIAN_READ32(content.cmd);
1545 }
1546
1547 inline __attribute__((always_inline))
1548 void macho_thread_command::set_cmd(uint32_t _value) {
1549 ENDIAN_WRITE32(content.cmd, _value);
1550 }
1551
1552 inline __attribute__((always_inline))
1553 uint32_t macho_thread_command::cmdsize() const {
1554 return ENDIAN_READ32(content.cmdsize);
1555 }
1556
1557 inline __attribute__((always_inline))
1558 void macho_thread_command::set_cmdsize(uint32_t _value) {
1559 ENDIAN_WRITE32(content.cmdsize, _value);
1560 }
1561
1562 inline __attribute__((always_inline))
1563 uint32_t macho_thread_command::flavor() const {
1564 return ENDIAN_READ32(content_flavor);
1565 }
1566
1567 inline __attribute__((always_inline))
1568 void macho_thread_command::set_flavor(uint32_t _value) {
1569 ENDIAN_WRITE32(content_flavor, _value);
1570 }
1571
1572 inline __attribute__((always_inline))
1573 uint32_t macho_thread_command::count() const {
1574 return ENDIAN_READ32(content_count);
1575 }
1576
1577 inline __attribute__((always_inline))
1578 void macho_thread_command::set_count(uint32_t _value) {
1579 ENDIAN_WRITE32(content_count, _value);
1580 }
1581
1582 inline __attribute__((always_inline))
1583 uint32_t macho_thread_command::threadState32(uint32_t index) const
1584 {
1585 return ENDIAN_READ32(threadState[index]);
1586 }
1587
1588 inline __attribute__((always_inline))
1589 void macho_thread_command::set_threadState32(uint32_t index, uint32_t _value)
1590 {
1591 ENDIAN_WRITE32(threadState[index], _value);
1592 }
1593
1594 inline __attribute__((always_inline))
1595 uint64_t macho_thread_command::threadState64(uint32_t index) const
1596 {
1597 uint64_t temp = *((uint64_t*)(&threadState[index]));
1598 return ENDIAN_SWAP64(temp);
1599 }
1600
1601 inline __attribute__((always_inline))
1602 void macho_thread_command::set_threadState64(uint32_t index, uint64_t _value)
1603 {
1604 *((uint64_t*)(&threadState[index])) = ENDIAN_SWAP64(_value);
1605 }
1606
1607
1608
1609 #undef nlist
1610 #undef nlist_64
1611 class macho_nlist {
1612 public:
1613 uint32_t n_strx() const;
1614 void set_n_strx(uint32_t);
1615
1616 uint8_t n_type() const;
1617 void set_n_type(uint8_t);
1618
1619 uint8_t n_sect() const;
1620 void set_n_sect(uint8_t);
1621
1622 uint16_t n_desc() const;
1623 void set_n_desc(uint16_t);
1624
1625 uint64_t n_value() const;
1626 void set_n_value(uint64_t);
1627
1628
1629 #if defined(MACHO_64_SAME_ENDIAN) || defined(MACHO_64_OPPOSITE_ENDIAN)
1630 enum { size = sizeof(struct nlist_64) };
1631 #else
1632 enum { size = sizeof(struct nlist) };
1633 #endif
1634
1635 private:
1636 #if defined(MACHO_64_SAME_ENDIAN) || defined(MACHO_64_OPPOSITE_ENDIAN)
1637 struct nlist_64 content;
1638 #else
1639 struct nlist content;
1640 #endif
1641 };
1642 #define nlist __my_bad
1643 #define nlist_64 __my_bad
1644
1645 inline __attribute__((always_inline))
1646 uint32_t macho_nlist::n_strx() const {
1647 return ENDIAN_READ32(content.n_un.n_strx);
1648 }
1649
1650 inline __attribute__((always_inline))
1651 void macho_nlist::set_n_strx(uint32_t _value) {
1652 ENDIAN_WRITE32(content.n_un.n_strx, _value);
1653 }
1654
1655 inline __attribute__((always_inline))
1656 uint8_t macho_nlist::n_type() const {
1657 return content.n_type;
1658 }
1659
1660 inline __attribute__((always_inline))
1661 void macho_nlist::set_n_type(uint8_t _value) {
1662 content.n_type = _value;
1663 }
1664
1665 inline __attribute__((always_inline))
1666 uint8_t macho_nlist::n_sect() const {
1667 return content.n_sect;
1668 }
1669
1670 inline __attribute__((always_inline))
1671 void macho_nlist::set_n_sect(uint8_t _value) {
1672 content.n_sect = _value;
1673 }
1674
1675 inline __attribute__((always_inline))
1676 uint16_t macho_nlist::n_desc() const {
1677 return ENDIAN_READ16(content.n_desc);
1678 }
1679
1680 inline __attribute__((always_inline))
1681 void macho_nlist::set_n_desc(uint16_t _value) {
1682 ENDIAN_WRITE16(content.n_desc, _value);
1683 }
1684
1685 inline __attribute__((always_inline))
1686 uint64_t macho_nlist::n_value() const {
1687 #if defined(ARCH_PPC64)
1688 return ENDIAN_SWAP64(content.n_value);
1689 #elif defined(ARCH_PPC) || defined(ARCH_I386)
1690 return ENDIAN_READ32(content.n_value);
1691 #else
1692 #error unknown architecture
1693 #endif
1694 }
1695
1696 inline __attribute__((always_inline))
1697 void macho_nlist::set_n_value(uint64_t _value) {
1698 #if defined(ARCH_PPC64)
1699 content.n_value = ENDIAN_SWAP64(_value);
1700 #elif defined(ARCH_PPC) || defined(ARCH_I386)
1701 ENDIAN_WRITE32(content.n_value, _value);
1702 #else
1703 #error unknown architecture
1704 #endif
1705 }
1706
1707
1708
1709 #undef relocation_info
1710 class macho_relocation_info {
1711 public:
1712 int32_t r_address() const;
1713 void set_r_address(int32_t);
1714
1715 uint32_t r_symbolnum() const;
1716 void set_r_symbolnum(uint32_t);
1717
1718 bool r_pcrel() const;
1719 void set_r_pcrel(bool);
1720
1721 uint8_t r_length() const;
1722 void set_r_length(uint8_t);
1723
1724 bool r_extern() const;
1725 void set_r_extern(bool);
1726
1727 uint8_t r_type() const;
1728 void set_r_type(uint8_t);
1729
1730 enum { size = sizeof(struct relocation_info) };
1731 #if defined(MACHO_64_SAME_ENDIAN) || defined(MACHO_64_OPPOSITE_ENDIAN)
1732 enum { pointer_length = 3 };
1733 #else
1734 enum { pointer_length = 2 };
1735 #endif
1736
1737 private:
1738 struct relocation_info content;
1739 };
1740 #define relocation_info __my_bad
1741
1742
1743 inline __attribute__((always_inline))
1744 int32_t macho_relocation_info::r_address() const {
1745 return ENDIAN_READ32(content.r_address);
1746 }
1747
1748 inline __attribute__((always_inline))
1749 void macho_relocation_info::set_r_address(int32_t _value) {
1750 ENDIAN_WRITE32(content.r_address, _value);
1751 }
1752
1753 inline __attribute__((always_inline))
1754 uint32_t macho_relocation_info::r_symbolnum() const {
1755 uint32_t temp = ENDIAN_READ32(((const uint32_t*)&content)[1]);
1756 #if defined(ARCH_PPC) || defined(ARCH_PPC64)
1757 return (temp >> 8);
1758 #elif defined(ARCH_I386)
1759 return temp & 0x00FFFFFF;
1760 #else
1761 #error unknown architecture
1762 #endif
1763 }
1764
1765 inline __attribute__((always_inline))
1766 void macho_relocation_info::set_r_symbolnum(uint32_t _value) {
1767 uint32_t temp = ENDIAN_READ32(((const uint32_t*)&content)[1]);
1768 #if defined(ARCH_PPC) || defined(ARCH_PPC64)
1769 temp &= 0x000000FF;
1770 temp |= ((_value & 0x00FFFFFF) << 8);
1771 #elif defined(ARCH_I386)
1772 temp &= 0xFF000000;
1773 temp |= (_value & 0x00FFFFFF);
1774 #else
1775 #error unknown architecture
1776 #endif
1777 ENDIAN_WRITE32(((uint32_t*)&content)[1], temp);
1778 }
1779
1780 inline __attribute__((always_inline))
1781 bool macho_relocation_info::r_pcrel() const {
1782 uint32_t temp = ENDIAN_READ32(((const uint32_t*)&content)[1]);
1783 #if defined(ARCH_PPC) || defined(ARCH_PPC64)
1784 return ((temp & 0x00000080) != 0);
1785 #elif defined(ARCH_I386)
1786 return ((temp & 0x01000000) != 0);
1787 #else
1788 #error unknown architecture
1789 #endif
1790 }
1791
1792 inline __attribute__((always_inline))
1793 void macho_relocation_info::set_r_pcrel(bool _value) {
1794 uint32_t temp = ENDIAN_READ32(((const uint32_t*)&content)[1]);
1795 #if defined(ARCH_PPC) || defined(ARCH_PPC64)
1796 temp &= 0xFFFFFF7F;
1797 if ( _value )
1798 temp |= 0x00000080;
1799 #elif defined(ARCH_I386)
1800 temp &= 0xFEFFFFFF;
1801 if ( _value )
1802 temp |= 0x01000000;
1803 #else
1804 #error unknown architecture
1805 #endif
1806 ENDIAN_WRITE32(((uint32_t*)&content)[1], temp);
1807 }
1808
1809 inline __attribute__((always_inline))
1810 uint8_t macho_relocation_info::r_length() const {
1811 uint32_t temp = ENDIAN_READ32(((const uint32_t*)&content)[1]);
1812 #if defined(ARCH_PPC) || defined(ARCH_PPC64)
1813 return ((temp & 0x00000060) >> 5);
1814 #elif defined(ARCH_I386)
1815 return ((temp & 0x06000000) >> 25);
1816 #else
1817 #error unknown architecture
1818 #endif
1819 }
1820
1821 inline __attribute__((always_inline))
1822 void macho_relocation_info::set_r_length(uint8_t _value) {
1823 uint32_t temp = ENDIAN_READ32(((const uint32_t*)&content)[1]);
1824 #if defined(ARCH_PPC) || defined(ARCH_PPC64)
1825 temp &= 0xFFFFFF9F;
1826 temp |= ((_value & 0x03) << 5);
1827 #elif defined(ARCH_I386)
1828 temp &= 0xF9FFFFFF;
1829 temp |= ((_value & 0x03) << 25);
1830 #else
1831 #error unknown architecture
1832 #endif
1833 ENDIAN_WRITE32(((uint32_t*)&content)[1], temp);
1834 }
1835
1836 inline __attribute__((always_inline))
1837 bool macho_relocation_info::r_extern() const {
1838 uint32_t temp = ENDIAN_READ32(((const uint32_t*)&content)[1]);
1839 #if defined(ARCH_PPC) || defined(ARCH_PPC64)
1840 return ((temp & 0x00000010) != 0);
1841 #elif defined(ARCH_I386)
1842 return ((temp & 0x08000000) != 0);
1843 #else
1844 #error unknown architecture
1845 #endif
1846 }
1847
1848 inline __attribute__((always_inline))
1849 void macho_relocation_info::set_r_extern(bool _value) {
1850 uint32_t temp = ENDIAN_READ32(((const uint32_t*)&content)[1]);
1851 #if defined(ARCH_PPC) || defined(ARCH_PPC64)
1852 temp &= 0xFFFFFFEF;
1853 if ( _value )
1854 temp |= 0x00000010;
1855 #elif defined(ARCH_I386)
1856 temp &= 0xF7FFFFFF;
1857 if ( _value )
1858 temp |= 0x08000000;
1859 #else
1860 #error unknown architecture
1861 #endif
1862 ENDIAN_WRITE32(((uint32_t*)&content)[1], temp);
1863 }
1864
1865 inline __attribute__((always_inline))
1866 uint8_t macho_relocation_info::r_type() const {
1867 uint32_t temp = ENDIAN_READ32(((const uint32_t*)&content)[1]);
1868 #if defined(ARCH_PPC) || defined(ARCH_PPC64)
1869 return (temp & 0x0000000F);
1870 #elif defined(ARCH_I386)
1871 return ((temp & 0xF0000000) >> 28);
1872 #else
1873 #error unknown architecture
1874 #endif
1875 }
1876
1877 inline __attribute__((always_inline))
1878 void macho_relocation_info::set_r_type(uint8_t _value) {
1879 uint32_t temp = ENDIAN_READ32(((const uint32_t*)&content)[1]);
1880 #if defined(ARCH_PPC) || defined(ARCH_PPC64)
1881 temp &= 0xFFFFFFF0;
1882 temp |= (_value & 0x0F);
1883 #elif defined(ARCH_I386)
1884 temp &= 0x0FFFFFFF;
1885 temp |= ((_value & 0x0F) << 28);
1886 #else
1887 #error unknown architecture
1888 #endif
1889 ENDIAN_WRITE32(((uint32_t*)&content)[1], temp);
1890 }
1891
1892
1893
1894 #undef scattered_relocation_info
1895 class macho_scattered_relocation_info {
1896 public:
1897 bool r_scattered() const;
1898 void set_r_scattered(bool);
1899
1900 bool r_pcrel() const;
1901 void set_r_pcrel(bool);
1902
1903 uint8_t r_length() const;
1904 void set_r_length(uint8_t);
1905
1906 uint8_t r_type() const;
1907 void set_r_type(uint8_t);
1908
1909 uint32_t r_address() const;
1910 void set_r_address(uint32_t);
1911
1912 int32_t r_value() const;
1913 void set_r_value(int32_t);
1914
1915 private:
1916 struct scattered_relocation_info content;
1917 };
1918 #define scattered_relocation_info __my_bad
1919
1920 inline __attribute__((always_inline))
1921 bool macho_scattered_relocation_info::r_scattered() const {
1922 uint32_t temp = *((const uint32_t*)&content);
1923 temp = ENDIAN_READ32(temp);
1924 return ((temp & 0x80000000) != 0);
1925 }
1926
1927 inline __attribute__((always_inline))
1928 void macho_scattered_relocation_info::set_r_scattered(bool _value) {
1929 uint32_t temp = ENDIAN_READ32(*((const uint32_t*)&content));
1930 if ( _value )
1931 temp |= 0x80000000;
1932 else
1933 temp &= ~0x80000000;
1934 ENDIAN_WRITE32(*((uint32_t*)&content), temp);
1935 }
1936
1937 inline __attribute__((always_inline))
1938 bool macho_scattered_relocation_info::r_pcrel() const {
1939 uint32_t temp = *((const uint32_t*)&content);
1940 temp = ENDIAN_READ32(temp);
1941 return ((temp & 0x40000000) != 0);
1942 }
1943
1944 inline __attribute__((always_inline))
1945 void macho_scattered_relocation_info::set_r_pcrel(bool _value) {
1946 uint32_t temp = ENDIAN_READ32(*((const uint32_t*)&content));
1947 if ( _value )
1948 temp |= 0x40000000;
1949 else
1950 temp &= ~0x40000000;
1951 ENDIAN_WRITE32(*((uint32_t*)&content), temp);
1952 }
1953
1954 inline __attribute__((always_inline))
1955 uint8_t macho_scattered_relocation_info::r_length() const {
1956 uint32_t temp = ENDIAN_READ32(*((const uint32_t*)&content));
1957 return (temp >> 28) & 0x03;
1958 }
1959
1960 inline __attribute__((always_inline))
1961 void macho_scattered_relocation_info::set_r_length(uint8_t _value) {
1962 uint32_t temp = ENDIAN_READ32(*((const uint32_t*)&content));
1963 temp &= 0xCFFFFFFF;
1964 temp |= ((_value & 0x03) << 28);
1965 ENDIAN_WRITE32(*((uint32_t*)&content), temp);
1966 }
1967
1968 inline __attribute__((always_inline))
1969 uint8_t macho_scattered_relocation_info::r_type() const {
1970 uint32_t temp = ENDIAN_READ32(*((const uint32_t*)&content));
1971 return (temp >> 24) & 0x0F;
1972 }
1973
1974 inline __attribute__((always_inline))
1975 void macho_scattered_relocation_info::set_r_type(uint8_t _value) {
1976 uint32_t temp = ENDIAN_READ32(*((const uint32_t*)&content));
1977 temp &= 0xF0FFFFFF;
1978 temp |= ((_value &0x0F) << 24);
1979 ENDIAN_WRITE32(*((uint32_t*)&content), temp);
1980 }
1981
1982 inline __attribute__((always_inline))
1983 uint32_t macho_scattered_relocation_info::r_address() const {
1984 uint32_t temp = ENDIAN_READ32(*((const uint32_t*)&content));
1985 return temp & 0x00FFFFFF;
1986 }
1987
1988 inline __attribute__((always_inline))
1989 void macho_scattered_relocation_info::set_r_address(uint32_t _value) {
1990 uint32_t temp = ENDIAN_READ32(*((const uint32_t*)&content));
1991 _value &= 0x00FFFFFF;
1992 temp &= 0xFF000000;
1993 temp |= _value;
1994 ENDIAN_WRITE32(*((uint32_t*)&content), temp);
1995 }
1996
1997 inline __attribute__((always_inline))
1998 int32_t macho_scattered_relocation_info::r_value() const {
1999 return ENDIAN_READ32(content.r_value);
2000 }
2001
2002 inline __attribute__((always_inline))
2003 void macho_scattered_relocation_info::set_r_value(int32_t _value) {
2004 ENDIAN_WRITE32(content.r_value, _value);
2005 }
2006
2007
2008
2009
mirror of ld64