kxld_object.c source code [codebrowser/libkern/kxld/kxld_object.c]

1	/*
2	* Copyright (c) 2009-2014 Apple Inc. All rights reserved.
3	*
4	* @APPLE_OSREFERENCE_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. The rights granted to you under the License
10	* may not be used to create, or enable the creation or redistribution of,
11	* unlawful or unlicensed copies of an Apple operating system, or to
12	* circumvent, violate, or enable the circumvention or violation of, any
13	* terms of an Apple operating system software license agreement.
14	*
15	* Please obtain a copy of the License at
16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
17	*
18	* The Original Code and all software distributed under the License are
19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23	* Please see the License for the specific language governing rights and
24	* limitations under the License.
25	*
26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27	*/
28	#include <string.h>
29	#include <sys/types.h>
30
31	#if KERNEL
32	#include <libkern/kernel_mach_header.h>
33	#include <mach/machine.h>
34	#include <mach/vm_param.h>
35	#include <mach-o/fat.h>
36	#else /* !KERNEL */
37	/ Get machine.h from the kernel source so we can support all platforms*
38	* that the kernel supports. Otherwise we're at the mercy of the host.
39	*/
40	#include "../../osfmk/mach/machine.h"
41
42	#include <architecture/byte_order.h>
43	#include <mach/mach_init.h>
44	#include <mach-o/arch.h>
45	#include <mach-o/swap.h>
46	#endif /* KERNEL */
47
48	#include <mach-o/loader.h>
49	#include <mach-o/nlist.h>
50	#include <mach-o/reloc.h>
51	#include <os/overflow.h>
52
53	#define DEBUG_ASSERT_COMPONENT_NAME_STRING "kxld"
54	#include <AssertMacros.h>
55
56	#include "kxld_demangle.h"
57	#include "kxld_dict.h"
58	#include "kxld_reloc.h"
59	#include "kxld_sect.h"
60	#include "kxld_seg.h"
61	#include "kxld_srcversion.h"
62	#include "kxld_symtab.h"
63	#include "kxld_util.h"
64	#include "kxld_uuid.h"
65	#include "kxld_versionmin.h"
66	#include "kxld_vtable.h"
67	#include "kxld_splitinfolc.h"
68
69	#include "kxld_object.h"
70
71	extern boolean_t isSplitKext;
72	extern boolean_t isOldInterface;
73
74	/*******************************************************************************
75	* Data structures
76	*******************************************************************************/
77
78	struct kxld_object {
79	u_char file; // used by old interface*
80	u_long size; // used by old interface
81	const char *name;
82	uint32_t filetype;
83	cpu_type_t cputype;
84	cpu_subtype_t cpusubtype;
85	KXLDArray segs;
86	KXLDArray sects;
87	KXLDArray extrelocs;
88	KXLDArray locrelocs;
89	KXLDRelocator relocator;
90	KXLDuuid uuid;
91	KXLDversionmin versionmin;
92	KXLDsrcversion srcversion;
93	KXLDSymtab *symtab;
94	struct dysymtab_command *dysymtab_hdr;
95	KXLDsplitinfolc splitinfolc;
96	splitKextLinkInfo split_info;
97	kxld_addr_t link_addr;
98	u_long output_buffer_size;
99	boolean_t is_kernel;
100	boolean_t is_final_image;
101	boolean_t is_linked;
102	boolean_t got_is_created;
103	#if KXLD_USER_OR_OBJECT
104	KXLDArray *section_order;
105	#endif
106	#if KXLD_PIC_KEXTS
107	boolean_t include_kaslr_relocs;
108	#endif
109	#if !KERNEL
110	enum NXByteOrder host_order;
111	enum NXByteOrder target_order;
112	#endif
113	};
114
115	/*******************************************************************************
116	* Prototypes
117	*******************************************************************************/
118
119	static kern_return_t get_target_machine_info(KXLDObject *object,
120	cpu_type_t cputype, cpu_subtype_t cpusubtype);
121	static kern_return_t get_macho_slice_for_arch(KXLDObject *object,
122	u_char *file, u_long size);
123
124	static u_long get_macho_header_size(const KXLDObject *object);
125	static u_long get_macho_data_size(const KXLDObject *object) __unused;
126
127	static kern_return_t init_from_execute(KXLDObject *object);
128	static kern_return_t init_from_final_linked_image(KXLDObject *object,
129	u_int filetype_out, struct* symtab_command **symtab_hdr_out);
130
131	static boolean_t target_supports_protected_segments(const KXLDObject *object)
132	__attribute__((pure));
133	static void set_is_object_linked(KXLDObject *object);
134
135	#if KXLD_USER_OR_BUNDLE
136	static boolean_t target_supports_bundle(const KXLDObject *object)
137	__attribute((pure));
138	static kern_return_t init_from_bundle(KXLDObject *object);
139	static kern_return_t process_relocs_from_tables(KXLDObject *object);
140	static KXLDSeg get_seg_by_base_addr(KXLDObject object,
141	kxld_addr_t base_addr);
142	static kern_return_t process_symbol_pointers(KXLDObject *object);
143	static void add_to_ptr(u_char *symptr, kxld_addr_t val, boolean_t is_32_bit);
144	#endif /* KXLD_USER_OR_BUNDLE */
145
146	#if KXLD_USER_OR_OBJECT
147	static boolean_t target_supports_object(const KXLDObject *object)
148	__attribute((pure));
149	static kern_return_t init_from_object(KXLDObject *object);
150	static kern_return_t process_relocs_from_sections(KXLDObject *object);
151	#endif /* KXLD_USER_OR_OBJECT */
152
153	#if KXLD_PIC_KEXTS
154	static boolean_t target_supports_slideable_kexts(const KXLDObject *object);
155	#endif /* KXLD_PIC_KEXTS */
156
157
158	static kern_return_t export_macho_header(const KXLDObject object, u_char buf,
159	u_int ncmds, u_long *header_offset, u_long header_size);
160	#if KXLD_USER_OR_ILP32
161	static u_long get_macho_cmd_data_32(u_char *file, u_long offset,
162	u_int filetype, u_int ncmds);
163	static kern_return_t export_macho_header_32(const KXLDObject *object,
164	u_char buf, u_int ncmds, u_long header_offset, u_long header_size);
165	#endif /* KXLD_USER_OR_ILP32 */
166	#if KXLD_USER_OR_LP64
167	static u_long get_macho_cmd_data_64(u_char *file, u_long offset,
168	u_int filetype, u_int ncmds);
169	static kern_return_t export_macho_header_64(const KXLDObject *object,
170	u_char buf, u_int ncmds, u_long header_offset, u_long header_size);
171	#endif /* KXLD_USER_OR_LP64 */
172
173	#if KXLD_USER_OR_GOT \|\| KXLD_USER_OR_COMMON
174	static kern_return_t add_section(KXLDObject object, KXLDSect *sect);
175	#endif /* KXLD_USER_OR_GOT \|\| KXLD_USER_OR_COMMON */
176
177	#if KXLD_USER_OR_COMMON
178	static kern_return_t resolve_common_symbols(KXLDObject *object);
179	#endif /* KXLD_USER_OR_COMMON */
180
181	#if KXLD_USER_OR_GOT
182	static boolean_t target_has_got(const KXLDObject object) __attribute__*((pure));
183	static kern_return_t create_got(KXLDObject *object);
184	static kern_return_t populate_got(KXLDObject *object);
185	#endif /* KXLD_USER_OR_GOT */
186
187	static KXLDSym get_mutable_sym(const* KXLDObject object, const* KXLDSym *sym);
188
189	static kern_return_t populate_kmod_info(KXLDObject *object);
190
191	/*******************************************************************************
192	* Prototypes that may need to be exported
193	*******************************************************************************/
194	static boolean_t kxld_object_target_needs_swap(const KXLDObject *object __unused);
195	static KXLDSeg * kxld_object_get_seg_by_name(const KXLDObject object, const* char *segname);
196	static KXLDSect * kxld_object_get_sect_by_name(const KXLDObject object, const* char *segname,
197	const char *sectname);
198
199	/*******************************************************************************
200	*******************************************************************************/
201	size_t
202	kxld_object_sizeof(void)
203	{
204	return sizeof(KXLDObject);
205	}
206
207	/*******************************************************************************
208	*******************************************************************************/
209	kern_return_t
210	kxld_object_init_from_macho(KXLDObject object, u_char file, u_long size,
211	const char name, KXLDArray section_order __unused,
212	cpu_type_t cputype, cpu_subtype_t cpusubtype, KXLDFlags flags __unused)
213	{
214	kern_return_t rval = KERN_FAILURE;
215	KXLDSeg * seg = NULL;
216	u_int i = `0`;
217	u_char * my_file;
218
219	check(object);
220	check(file);
221	check(name);
222
223	object->name = name;
224
225	#if KXLD_USER_OR_OBJECT
226	object->section_order = section_order;
227	#endif
228	#if KXLD_PIC_KEXTS
229	object->include_kaslr_relocs = ((flags & kKXLDFlagIncludeRelocs) == kKXLDFlagIncludeRelocs);
230	#endif
231
232	/ Find the local architecture /
233
234	rval = get_target_machine_info(object, cputype, cpusubtype);
235	require_noerr(rval, finish);
236
237	/ Find the Mach-O slice for the target architecture /
238
239	rval = get_macho_slice_for_arch(object, file, size);
240	require_noerr(rval, finish);
241
242	if (isOldInterface) {
243	my_file = object->file;
244	}
245	else {
246	my_file = object->split_info.kextExecutable;
247	}
248
249	/ Allocate the symbol table /
250
251	if (!object->symtab) {
252	object->symtab = kxld_alloc(kxld_symtab_sizeof());
253	require_action(object->symtab, finish, rval=KERN_RESOURCE_SHORTAGE);
254	bzero(object->symtab, kxld_symtab_sizeof());
255	}
256
257	/ Build the relocator /
258
259	rval = kxld_relocator_init(&object->relocator,
260	my_file,
261	object->symtab, &object->sects,
262	object->cputype,
263	object->cpusubtype,
264	kxld_object_target_needs_swap(object));
265	require_noerr(rval, finish);
266
267	/ There are four types of Mach-O files that we can support:*
268	* 1) 32-bit MH_OBJECT - Snow Leopard and earlier
269	* 2) 32-bit MH_KEXT_BUNDLE - Lion and Later
270	* 3) 64-bit MH_OBJECT - Unsupported
271	* 4) 64-bit MH_KEXT_BUNDLE - Snow Leopard and Later
272	*/
273
274	if (kxld_object_is_32_bit(object)) {
275	struct mach_header mach_hdr = (struct* mach_header ) ((void* *) my_file);
276	object->filetype = mach_hdr->filetype;
277	} else {
278	struct mach_header_64 mach_hdr = (struct* mach_header_64 ) ((void* *) my_file);
279	object->filetype = mach_hdr->filetype;
280	}
281
282	switch (object->filetype) {
283	#if KXLD_USER_OR_BUNDLE
284	case MH_KEXT_BUNDLE:
285	rval = init_from_bundle(object);
286	require_noerr(rval, finish);
287	break;
288	#endif /* KXLD_USER_OR_BUNDLE */
289	#if KXLD_USER_OR_OBJECT
290	case MH_OBJECT:
291	rval = init_from_object(object);
292	require_noerr(rval, finish);
293	break;
294	#endif /* KXLD_USER_OR_OBJECT */
295	case MH_EXECUTE:
296	object->is_kernel = TRUE;
297	rval = init_from_execute(object);
298	require_noerr(rval, finish);
299	break;
300	default:
301	rval = KERN_FAILURE;
302	kxld_log(kKxldLogLinking, kKxldLogErr,
303	kKxldLogFiletypeNotSupported, object->filetype);
304	goto finish;
305	}
306
307	if (!kxld_object_is_kernel(object)) {
308	for (i = `0`; i < object->segs.nitems; ++i) {
309	seg = kxld_array_get_item(&object->segs, i);
310	kxld_seg_set_vm_protections(seg,
311	target_supports_protected_segments(object));
312	}
313
314	seg = kxld_object_get_seg_by_name(object, SEG_LINKEDIT);
315	if (seg) {
316	(void) kxld_seg_populate_linkedit(seg, object->symtab,
317	kxld_object_is_32_bit(object)
318	#if KXLD_PIC_KEXTS
319	, &object->locrelocs, &object->extrelocs,
320	target_supports_slideable_kexts(object)
321	#endif
322	, isOldInterface ? `0` : object->splitinfolc.datasize
323	);
324	}
325	}
326
327	(void) set_is_object_linked(object);
328
329	rval = KERN_SUCCESS;
330	finish:
331	return rval;
332	}
333
334	/*******************************************************************************
335	*******************************************************************************/
336	splitKextLinkInfo *
337	kxld_object_get_link_info(KXLDObject *object)
338	{
339	check(object);
340
341	return &object->split_info;
342	}
343
344
345	/*******************************************************************************
346	*******************************************************************************/
347	void
348	kxld_object_set_link_info(KXLDObject object, splitKextLinkInfo link_info)
349	{
350	check(object);
351	check(link_info);
352
353	object->split_info.vmaddr_TEXT = link_info->vmaddr_TEXT;
354	object->split_info.vmaddr_TEXT_EXEC = link_info->vmaddr_TEXT_EXEC;
355	object->split_info.vmaddr_DATA = link_info->vmaddr_DATA;
356	object->split_info.vmaddr_DATA_CONST = link_info->vmaddr_DATA_CONST;
357	object->split_info.vmaddr_LLVM_COV = link_info->vmaddr_LLVM_COV;
358	object->split_info.vmaddr_LINKEDIT = link_info->vmaddr_LINKEDIT;
359
360	return;
361	}
362
363	/*******************************************************************************
364	*******************************************************************************/
365	kern_return_t
366	get_target_machine_info(KXLDObject *object, cpu_type_t cputype __unused,
367	cpu_subtype_t cpusubtype __unused)
368	{
369	#if KERNEL
370
371	/ Because the kernel can only link for its own architecture, we know what*
372	* the host and target architectures are at compile time, so we can use
373	* a vastly simplified version of this function.
374	*/
375
376	check(object);
377
378	#if defined(__x86_64__)
379	object->cputype = CPU_TYPE_X86_64;
380	/ FIXME: we need clang to provide a __x86_64h__ macro for the sub-type. Using*
381	* __AVX2__ is a temporary solution until this is available. */
382	#if defined(__AVX2__)
383	object->cpusubtype = CPU_SUBTYPE_X86_64_H;
384	#else
385	object->cpusubtype = CPU_SUBTYPE_X86_64_ALL;
386	#endif
387	return KERN_SUCCESS;
388	#elif defined(__arm__)
389	object->cputype = CPU_TYPE_ARM;
390	object->cpusubtype = CPU_SUBTYPE_ARM_ALL;
391	return KERN_SUCCESS;
392	#elif defined(__arm64__)
393	object->cputype = CPU_TYPE_ARM64;
394	object->cpusubtype = CPU_SUBTYPE_ARM64_ALL;
395	return KERN_SUCCESS;
396	#else
397	kxld_log(kKxldLogLinking, kKxldLogErr,
398	kKxldLogArchNotSupported, _mh_execute_header->cputype);
399	return KERN_NOT_SUPPORTED;
400	#endif /* Supported architecture defines */
401
402
403	#else /* !KERNEL */
404
405	/ User-space must look up the architecture it's running on and the target*
406	* architecture at run-time.
407	*/
408
409	kern_return_t rval = KERN_FAILURE;
410	const NXArchInfo *host_arch = NULL;
411
412	check(object);
413
414	host_arch = NXGetLocalArchInfo();
415	require_action(host_arch, finish, rval=KERN_FAILURE);
416
417	object->host_order = host_arch->byteorder;
418
419	/ If the user did not specify a cputype, use the local architecture.*
420	*/
421
422	if (cputype) {
423	object->cputype = cputype;
424	object->cpusubtype = cpusubtype;
425	} else {
426	object->cputype = host_arch->cputype;
427	object->target_order = object->host_order;
428
429	switch (object->cputype) {
430	case CPU_TYPE_I386:
431	object->cpusubtype = CPU_SUBTYPE_I386_ALL;
432	break;
433	case CPU_TYPE_X86_64:
434	object->cpusubtype = CPU_SUBTYPE_X86_64_ALL;
435	break;
436	case CPU_TYPE_ARM:
437	object->cpusubtype = CPU_SUBTYPE_ARM_ALL;
438	break;
439	case CPU_TYPE_ARM64:
440	object->cpusubtype = CPU_SUBTYPE_ARM64_ALL;
441	break;
442	default:
443	object->cpusubtype = `0`;
444	break;
445	}
446	}
447
448	/ Validate that we support the target architecture and record its*
449	* endianness.
450	*/
451
452	switch(object->cputype) {
453	case CPU_TYPE_ARM:
454	case CPU_TYPE_ARM64:
455	case CPU_TYPE_I386:
456	case CPU_TYPE_X86_64:
457	object->target_order = NX_LittleEndian;
458	break;
459	default:
460	rval = KERN_NOT_SUPPORTED;
461	kxld_log(kKxldLogLinking, kKxldLogErr,
462	kKxldLogArchNotSupported, object->cputype);
463	goto finish;
464	}
465
466	rval = KERN_SUCCESS;
467
468	finish:
469	return rval;
470	#endif /* KERNEL */
471	}
472
473	/*******************************************************************************
474	*******************************************************************************/
475	static kern_return_t
476	get_macho_slice_for_arch(KXLDObject object, u_char file, u_long size)
477	{
478	kern_return_t rval = KERN_FAILURE;
479	struct mach_header *mach_hdr = NULL;
480	#if !KERNEL
481	struct fat_header fat = (struct* fat_header ) ((void* *) file);
482	struct fat_arch archs = (struct* fat_arch *) &fat[`1`];
483	boolean_t swap = FALSE;
484	#endif /* KERNEL */
485	u_char *my_file = file;
486	u_long my_file_size = size;
487
488	check(object);
489	check(file);
490	check(size);
491
492	/ We are assuming that we will never receive a fat file in the kernel /
493
494	#if !KERNEL
495	require_action(size >= sizeof(*fat), finish,
496	rval=KERN_FAILURE;
497	kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogTruncatedMachO));
498
499	/ The fat header is always big endian, so swap if necessary /
500	if (fat->magic == FAT_CIGAM) {
501	(void) swap_fat_header(fat, object->host_order);
502	swap = TRUE;
503	}
504
505	if (fat->magic == FAT_MAGIC) {
506	struct fat_arch *arch = NULL;
507	u_long arch_size;
508	boolean_t ovr = os_mul_and_add_overflow(fat->nfat_arch, sizeof(archs), sizeof(fat), &arch_size);
509
510	require_action(!ovr && size >= arch_size,
511	finish,
512	rval=KERN_FAILURE;
513	kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogTruncatedMachO));
514
515	/ Swap the fat_arch structures if necessary /
516	if (swap) {
517	(void) swap_fat_arch(archs, fat->nfat_arch, object->host_order);
518	}
519
520	/ Locate the Mach-O for the requested architecture /
521
522	arch = NXFindBestFatArch(object->cputype, object->cpusubtype, archs, fat->nfat_arch);
523	require_action(arch, finish, rval=KERN_FAILURE;
524	kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogArchNotFound));
525	require_action(size >= arch->offset + arch->size, finish,
526	rval=KERN_FAILURE;
527	kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogTruncatedMachO));
528
529	my_file = my_file + arch->offset;
530	my_file_size = arch->size;
531	}
532	#endif /* !KERNEL */
533
534	/ Swap the Mach-O's headers to this architecture if necessary /
535	if (kxld_object_is_32_bit(object)) {
536	rval = validate_and_swap_macho_32(my_file, my_file_size
537	#if !KERNEL
538	, object->host_order
539	#endif /* !KERNEL */
540	);
541	} else {
542	rval = validate_and_swap_macho_64(my_file, my_file_size
543	#if !KERNEL
544	, object->host_order
545	#endif /* !KERNEL */
546	);
547	}
548	require_noerr(rval, finish);
549
550	mach_hdr = (struct mach_header ) ((void* *) my_file);
551	require_action(object->cputype == mach_hdr->cputype, finish,
552	rval=KERN_FAILURE;
553	kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogTruncatedMachO));
554	object->cpusubtype = mach_hdr->cpusubtype; / <rdar://problem/16008438> /
555
556	if (isOldInterface) {
557	object->file = my_file;
558	object->size = my_file_size;
559	}
560	else {
561	object->split_info.kextExecutable = my_file;
562	object->split_info.kextSize = my_file_size;
563	}
564
565	rval = KERN_SUCCESS;
566	finish:
567	return rval;
568	}
569
570	/*******************************************************************************
571	*******************************************************************************/
572	static kern_return_t
573	init_from_final_linked_image(KXLDObject object, u_int filetype_out,
574	struct symtab_command **symtab_hdr_out)
575	{
576	kern_return_t rval = KERN_FAILURE;
577	KXLDSeg *seg = NULL;
578	KXLDSect *sect = NULL;
579	struct load_command *cmd_hdr = NULL;
580	struct symtab_command *symtab_hdr = NULL;
581	struct uuid_command *uuid_hdr = NULL;
582	struct version_min_command *versionmin_hdr = NULL;
583	struct build_version_command *build_version_hdr = NULL;
584	struct source_version_command *source_version_hdr = NULL;
585	u_long base_offset = `0`;
586	u_long offset = `0`;
587	u_long sect_offset = `0`;
588	u_int filetype = `0`;
589	u_int i = `0`;
590	u_int j = `0`;
591	u_int segi = `0`;
592	u_int secti = `0`;
593	u_int nsegs = `0`;
594	u_int nsects = `0`;
595	u_int ncmds = `0`;
596	u_char *my_file;
597
598	if (isOldInterface) {
599	my_file = object->file;
600	}
601	else {
602	my_file = object->split_info.kextExecutable;
603	}
604
605	KXLD_3264_FUNC(kxld_object_is_32_bit(object), base_offset,
606	get_macho_cmd_data_32, get_macho_cmd_data_64,
607	my_file, offset, &filetype, &ncmds);
608
609	/ First pass to count segments and sections /
610
611	offset = base_offset;
612	for (i = `0`; i < ncmds; ++i, offset += cmd_hdr->cmdsize) {
613	cmd_hdr = (struct load_command ) ((void* *) (my_file + offset));
614
615	switch(cmd_hdr->cmd) {
616	#if KXLD_USER_OR_ILP32
617	case LC_SEGMENT:
618	{
619	struct segment_command *seg_hdr =
620	(struct segment_command *) cmd_hdr;
621
622	/ Ignore segments with no vm size /
623	if (!seg_hdr->vmsize) continue;
624
625	++nsegs;
626	nsects += seg_hdr->nsects;
627	}
628	break;
629	#endif /* KXLD_USER_OR_ILP32 */
630	#if KXLD_USER_OR_LP64
631	case LC_SEGMENT_64:
632	{
633	struct segment_command_64 *seg_hdr =
634	(struct segment_command_64 ) ((void* *) cmd_hdr);
635
636	/ Ignore segments with no vm size /
637	if (!seg_hdr->vmsize) continue;
638
639	++nsegs;
640	nsects += seg_hdr->nsects;
641	}
642	break;
643	#endif /* KXLD_USER_OR_LP64 */
644	default:
645	continue;
646	}
647	}
648
649	/ Allocate the segments and sections /
650
651	if (nsegs) {
652	rval = kxld_array_init(&object->segs, sizeof(KXLDSeg), nsegs);
653	require_noerr(rval, finish);
654
655	rval = kxld_array_init(&object->sects, sizeof(KXLDSect), nsects);
656	require_noerr(rval, finish);
657	}
658
659	/ Initialize the segments and sections /
660
661	offset = base_offset;
662	for (i = `0`; i < ncmds; ++i, offset += cmd_hdr->cmdsize) {
663	cmd_hdr = (struct load_command ) ((void* *) (my_file + offset));
664	seg = NULL;
665
666	switch(cmd_hdr->cmd) {
667	#if KXLD_USER_OR_ILP32
668	case LC_SEGMENT:
669	{
670	struct segment_command *seg_hdr =
671	(struct segment_command *) cmd_hdr;
672
673	/ Ignore segments with no vm size /
674	if (!seg_hdr->vmsize) continue;
675
676	seg = kxld_array_get_item(&object->segs, segi++);
677
678	rval = kxld_seg_init_from_macho_32(seg, seg_hdr);
679	require_noerr(rval, finish);
680
681	sect_offset = offset + sizeof(*seg_hdr);
682	}
683	break;
684	#endif /* KXLD_USER_OR_ILP32 */
685	#if KXLD_USER_OR_LP64
686	case LC_SEGMENT_64:
687	{
688	struct segment_command_64 *seg_hdr =
689	(struct segment_command_64 ) ((void* *) cmd_hdr);
690
691	/ Ignore segments with no vm size /
692	if (!seg_hdr->vmsize) continue;
693
694	seg = kxld_array_get_item(&object->segs, segi++);
695
696	rval = kxld_seg_init_from_macho_64(seg, seg_hdr);
697	require_noerr(rval, finish);
698
699	sect_offset = offset + sizeof(*seg_hdr);
700	}
701	break;
702	#endif /* KXLD_USER_OR_LP64 */
703	case LC_SYMTAB:
704	symtab_hdr = (struct symtab_command *) cmd_hdr;
705	break;
706	case LC_UUID:
707	uuid_hdr = (struct uuid_command *) cmd_hdr;
708	kxld_uuid_init_from_macho(&object->uuid, uuid_hdr);
709	break;
710	case LC_VERSION_MIN_MACOSX:
711	case LC_VERSION_MIN_IPHONEOS:
712	case LC_VERSION_MIN_TVOS:
713	case LC_VERSION_MIN_WATCHOS:
714	versionmin_hdr = (struct version_min_command *) cmd_hdr;
715	kxld_versionmin_init_from_macho(&object->versionmin, versionmin_hdr);
716	break;
717	case LC_BUILD_VERSION:
718	build_version_hdr = (struct build_version_command *)cmd_hdr;
719	kxld_versionmin_init_from_build_cmd(&object->versionmin, build_version_hdr);
720	break;
721	case LC_SOURCE_VERSION:
722	source_version_hdr = (struct source_version_command ) (void* *) cmd_hdr;
723	kxld_srcversion_init_from_macho(&object->srcversion, source_version_hdr);
724	break;
725	case LC_DYSYMTAB:
726	object->dysymtab_hdr = (struct dysymtab_command *) cmd_hdr;
727	rval = kxld_reloc_create_macho(&object->extrelocs, &object->relocator,
728	(struct relocation_info ) ((void* *) (my_file + object->dysymtab_hdr->extreloff)),
729	object->dysymtab_hdr->nextrel);
730	require_noerr(rval, finish);
731
732	rval = kxld_reloc_create_macho(&object->locrelocs, &object->relocator,
733	(struct relocation_info ) ((void* *) (my_file + object->dysymtab_hdr->locreloff)),
734	object->dysymtab_hdr->nlocrel);
735	require_noerr(rval, finish);
736
737	break;
738	case LC_UNIXTHREAD:
739	case LC_MAIN:
740	/ Don't need to do anything with UNIXTHREAD or MAIN for the kernel /
741	require_action(kxld_object_is_kernel(object),
742	finish, rval=KERN_FAILURE;
743	kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogMalformedMachO
744	"LC_UNIXTHREAD/LC_MAIN segment is not valid in a kext."));
745	break;
746	case LC_SEGMENT_SPLIT_INFO:
747	if (isSplitKext) {
748	struct linkedit_data_command *split_info_hdr = NULL;
749	split_info_hdr = (struct linkedit_data_command ) (void* *) cmd_hdr;
750	kxld_splitinfolc_init_from_macho(&object->splitinfolc, split_info_hdr);
751	}
752	break;
753	case LC_NOTE:
754	/ binary blob of data /
755	break;
756	case LC_CODE_SIGNATURE:
757	case LC_DYLD_INFO:
758	case LC_DYLD_INFO_ONLY:
759	case LC_FUNCTION_STARTS:
760	case LC_DATA_IN_CODE:
761	case LC_DYLIB_CODE_SIGN_DRS:
762	/ Various metadata that might be stored in the linkedit segment /
763	break;
764	default:
765	rval=KERN_FAILURE;
766	kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogMalformedMachO
767	"Invalid load command type in MH_KEXT_BUNDLE kext: %u.", cmd_hdr->cmd);
768	goto finish;
769	}
770
771	if (seg) {
772
773	/ Initialize the sections /
774	for (j = `0`; j < seg->sects.nitems; ++j, ++secti) {
775	sect = kxld_array_get_item(&object->sects, secti);
776
777	KXLD_3264_FUNC(kxld_object_is_32_bit(object), rval,
778	kxld_sect_init_from_macho_32, kxld_sect_init_from_macho_64,
779	sect, my_file, &sect_offset, secti, &object->relocator);
780	require_noerr(rval, finish);
781
782	/ Add the section to the segment. This will also make sure*
783	* that the sections and segments have the same segname.
784	*/
785	rval = kxld_seg_add_section(seg, sect);
786	require_noerr(rval, finish);
787	}
788	rval = kxld_seg_finish_init(seg);
789	require_noerr(rval, finish);
790	}
791	}
792
793	if (filetype_out) *filetype_out = filetype;
794	if (symtab_hdr_out) *symtab_hdr_out = symtab_hdr;
795	object->is_final_image = TRUE;
796	rval = KERN_SUCCESS;
797	finish:
798	return rval;
799	}
800
801	/*******************************************************************************
802	*******************************************************************************/
803	static kern_return_t
804	init_from_execute(KXLDObject *object)
805	{
806	kern_return_t rval = KERN_FAILURE;
807	struct symtab_command *symtab_hdr = NULL;
808	u_int filetype = `0`;
809	KXLDSeg * kernel_linkedit_seg = NULL; // used if running kernel
810	#if KXLD_USER_OR_OBJECT
811	KXLDSeg *seg = NULL;
812	KXLDSect *sect = NULL;
813	KXLDSectionName *sname = NULL;
814	u_int i = `0`, j = `0`, k = `0`;
815	#endif /* KXLD_USER_OR_OBJECT */
816	u_char *my_file;
817
818	check(object);
819
820	if (isOldInterface) {
821	my_file = object->file;
822	}
823	else {
824	my_file = object->split_info.kextExecutable;
825	}
826
827	require_action(kxld_object_is_kernel(object), finish, rval=KERN_FAILURE);
828
829	rval = init_from_final_linked_image(object, &filetype, &symtab_hdr);
830	require_noerr(rval, finish);
831
832	require_action(filetype == MH_EXECUTE, finish, rval=KERN_FAILURE;
833	kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogMalformedMachO
834	"The kernel file is not of type MH_EXECUTE."));
835
836	/ Initialize the symbol table. If this is the running kernel*
837	* we will work from the in-memory linkedit segment;
838	* otherwise we work from the whole mach-o image.
839	*/
840	#if KERNEL
841	kernel_linkedit_seg = kxld_object_get_seg_by_name(object, SEG_LINKEDIT);
842	require_action(kernel_linkedit_seg, finish, rval=KERN_FAILURE;
843	kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogMalformedMachO));
844	#endif
845
846	KXLD_3264_FUNC(kxld_object_is_32_bit(object), rval,
847	kxld_symtab_init_from_macho_32, kxld_symtab_init_from_macho_64,
848	object->symtab, symtab_hdr, my_file, kernel_linkedit_seg);
849	require_noerr(rval, finish);
850
851	#if KXLD_USER_OR_OBJECT
852	/ Save off the order of section names so that we can lay out kext*
853	* sections for MH_OBJECT-based systems.
854	*/
855	if (target_supports_object(object)) {
856
857	rval = kxld_array_init(object->section_order, sizeof(KXLDSectionName),
858	object->sects.nitems);
859	require_noerr(rval, finish);
860
861	/ Copy the section names into the section_order array for future kext*
862	* section ordering.
863	*/
864	for (i = `0`, k = `0`; i < object->segs.nitems; ++i) {
865	seg = kxld_array_get_item(&object->segs, i);
866
867	for (j = `0`; j < seg->sects.nitems; ++j, ++k) {
868	sect = (KXLDSect *) kxld_array_get_item(&seg->sects, j);
869	sname = kxld_array_get_item(object->section_order, k);
870
871	strlcpy(sname->segname, sect->segname, sizeof(sname->segname));
872	strlcpy(sname->sectname, sect->sectname, sizeof(sname->sectname));
873	}
874	}
875	}
876	#endif /* KXLD_USER_OR_OBJECT */
877
878	rval = KERN_SUCCESS;
879	finish:
880	return rval;
881	}
882
883	#if KXLD_USER_OR_BUNDLE
884	/*******************************************************************************
885	*******************************************************************************/
886	static boolean_t
887	target_supports_bundle(const KXLDObject *object __unused)
888	{
889	return TRUE;
890	}
891
892	/*******************************************************************************
893	*******************************************************************************/
894	static kern_return_t
895	init_from_bundle(KXLDObject *object)
896	{
897	kern_return_t rval = KERN_FAILURE;
898	struct symtab_command *symtab_hdr = NULL;
899	u_int filetype = `0`;
900	u_char *my_file;
901
902	check(object);
903
904	if (isOldInterface) {
905	my_file = object->file;
906	}
907	else {
908	my_file = object->split_info.kextExecutable;
909	}
910
911	require_action(target_supports_bundle(object), finish,
912	rval=KERN_FAILURE;
913	kxld_log(kKxldLogLinking, kKxldLogErr,
914	kKxldLogFiletypeNotSupported, MH_KEXT_BUNDLE));
915
916	rval = init_from_final_linked_image(object, &filetype, &symtab_hdr);
917	require_noerr(rval, finish);
918
919	require_action(filetype == MH_KEXT_BUNDLE, finish,
920	rval=KERN_FAILURE);
921
922	KXLD_3264_FUNC(kxld_object_is_32_bit(object), rval,
923	kxld_symtab_init_from_macho_32, kxld_symtab_init_from_macho_64,
924	object->symtab, symtab_hdr, my_file,
925	/ kernel_linkedit_seg / NULL);
926	require_noerr(rval, finish);
927
928	rval = KERN_SUCCESS;
929	finish:
930	return rval;
931	}
932	#endif /* KXLD_USER_OR_BUNDLE */
933
934	#if KXLD_USER_OR_OBJECT
935	/*******************************************************************************
936	*******************************************************************************/
937	static boolean_t target_supports_object(const KXLDObject *object)
938	{
939	return (object->cputype == CPU_TYPE_I386);
940	}
941
942	/*******************************************************************************
943	*******************************************************************************/
944	static kern_return_t
945	init_from_object(KXLDObject *object)
946	{
947	kern_return_t rval = KERN_FAILURE;
948	struct load_command *cmd_hdr = NULL;
949	struct symtab_command *symtab_hdr = NULL;
950	struct uuid_command *uuid_hdr = NULL;
951	KXLDSect *sect = NULL;
952	u_long offset = `0`;
953	u_long sect_offset = `0`;
954	u_int filetype = `0`;
955	u_int ncmds = `0`;
956	u_int nsects = `0`;
957	u_int i = `0`;
958	boolean_t has_segment = FALSE;
959	u_char *my_file;
960
961	check(object);
962
963	if (isOldInterface) {
964	my_file = object->file;
965	}
966	else {
967	my_file = object->split_info.kextExecutable;
968	}
969
970	require_action(target_supports_object(object),
971	finish, rval=KERN_FAILURE;
972	kxld_log(kKxldLogLinking, kKxldLogErr,
973	kKxldLogFiletypeNotSupported, MH_OBJECT));
974
975	KXLD_3264_FUNC(kxld_object_is_32_bit(object), offset,
976	get_macho_cmd_data_32, get_macho_cmd_data_64,
977	my_file, offset, &filetype, &ncmds);
978
979	require_action(filetype == MH_OBJECT, finish, rval=KERN_FAILURE);
980
981	/ MH_OBJECTs use one unnamed segment to contain all of the sections. We*
982	* loop over all of the load commands to initialize the structures we
983	* expect. Then, we'll use the unnamed segment to get to all of the
984	* sections, and then use those sections to create the actual segments.
985	*/
986
987	for (; i < ncmds; ++i, offset += cmd_hdr->cmdsize) {
988	cmd_hdr = (struct load_command ) ((void* *) (my_file + offset));
989
990	switch(cmd_hdr->cmd) {
991	#if KXLD_USER_OR_ILP32
992	case LC_SEGMENT:
993	{
994	struct segment_command *seg_hdr =
995	(struct segment_command *) cmd_hdr;
996
997	/ Ignore segments with no vm size /
998	if (!seg_hdr->vmsize) continue;
999
1000	/ Ignore LINKEDIT segments /
1001	if (streq_safe(seg_hdr->segname, SEG_LINKEDIT,
1002	const_strlen(SEG_LINKEDIT)))
1003	{
1004	continue;
1005	}
1006
1007	require_action(kxld_object_is_32_bit(object), finish, rval=KERN_FAILURE;
1008	kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogMalformedMachO
1009	"LC_SEGMENT in 64-bit kext."));
1010	require_action(!has_segment, finish, rval=KERN_FAILURE;
1011	kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogMalformedMachO
1012	"Multiple segments in an MH_OBJECT kext."));
1013
1014	nsects = seg_hdr->nsects;
1015	sect_offset = offset + sizeof(*seg_hdr);
1016	has_segment = TRUE;
1017	}
1018	break;
1019	#endif /* KXLD_USER_OR_ILP32 */
1020	#if KXLD_USER_OR_LP64
1021	case LC_SEGMENT_64:
1022	{
1023	struct segment_command_64 *seg_hdr =
1024	(struct segment_command_64 ) ((void* *) cmd_hdr);
1025
1026	/ Ignore segments with no vm size /
1027	if (!seg_hdr->vmsize) continue;
1028
1029	/ Ignore LINKEDIT segments /
1030	if (streq_safe(seg_hdr->segname, SEG_LINKEDIT,
1031	const_strlen(SEG_LINKEDIT)))
1032	{
1033	continue;
1034	}
1035
1036	require_action(!kxld_object_is_32_bit(object), finish, rval=KERN_FAILURE;
1037	kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogMalformedMachO
1038	"LC_SEGMENT_64 in a 32-bit kext."));
1039	require_action(!has_segment, finish, rval=KERN_FAILURE;
1040	kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogMalformedMachO
1041	"Multiple segments in an MH_OBJECT kext."));
1042
1043	nsects = seg_hdr->nsects;
1044	sect_offset = offset + sizeof(*seg_hdr);
1045	has_segment = TRUE;
1046	}
1047	break;
1048	#endif /* KXLD_USER_OR_LP64 */
1049	case LC_SYMTAB:
1050	symtab_hdr = (struct symtab_command *) cmd_hdr;
1051
1052	KXLD_3264_FUNC(kxld_object_is_32_bit(object), rval,
1053	kxld_symtab_init_from_macho_32, kxld_symtab_init_from_macho_64,
1054	object->symtab, symtab_hdr, my_file,
1055	/ kernel_linkedit_seg / NULL);
1056	require_noerr(rval, finish);
1057	break;
1058	case LC_UUID:
1059	uuid_hdr = (struct uuid_command *) cmd_hdr;
1060	kxld_uuid_init_from_macho(&object->uuid, uuid_hdr);
1061	break;
1062	case LC_UNIXTHREAD:
1063	case LC_MAIN:
1064	/ Don't need to do anything with UNIXTHREAD or MAIN /
1065	break;
1066	case LC_CODE_SIGNATURE:
1067	case LC_DYLD_INFO:
1068	case LC_DYLD_INFO_ONLY:
1069	case LC_FUNCTION_STARTS:
1070	case LC_DATA_IN_CODE:
1071	case LC_DYLIB_CODE_SIGN_DRS:
1072	/ Various metadata that might be stored in the linkedit segment /
1073	break;
1074	case LC_NOTE:
1075	/ bag-of-bits carried with the binary: ignore /
1076	break;
1077	case LC_BUILD_VERSION:
1078	/ should be able to ignore build version commands /
1079	kxld_log(kKxldLogLinking, kKxldLogWarn,
1080	"Ignoring LC_BUILD_VERSION (%u) in MH_OBJECT kext: (platform:%d)",
1081	cmd_hdr->cmd, ((struct build_version_command *)cmd_hdr)->platform);
1082	break;
1083	case LC_VERSION_MIN_MACOSX:
1084	case LC_VERSION_MIN_IPHONEOS:
1085	case LC_VERSION_MIN_TVOS:
1086	case LC_VERSION_MIN_WATCHOS:
1087	case LC_SOURCE_VERSION:
1088	/ Not supported for object files, fall through /
1089	default:
1090	rval = KERN_FAILURE;
1091	kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogMalformedMachO
1092	"Invalid load command type in MH_OBJECT kext: %u.", cmd_hdr->cmd);
1093	goto finish;
1094	}
1095	}
1096
1097	if (has_segment) {
1098
1099	/ Get the number of sections from the segment and build the section index /
1100
1101	rval = kxld_array_init(&object->sects, sizeof(KXLDSect), nsects);
1102	require_noerr(rval, finish);
1103
1104	/ Loop over all of the sections to initialize the section index /
1105
1106	for (i = `0`; i < nsects; ++i) {
1107	sect = kxld_array_get_item(&object->sects, i);
1108
1109	KXLD_3264_FUNC(kxld_object_is_32_bit(object), rval,
1110	kxld_sect_init_from_macho_32, kxld_sect_init_from_macho_64,
1111	sect, my_file, &sect_offset, i, &object->relocator);
1112	require_noerr(rval, finish);
1113	}
1114
1115	/ Create special sections /
1116
1117	#if KXLD_USER_OR_GOT
1118	rval = create_got(object);
1119	require_noerr(rval, finish);
1120	#endif /* KXLD_USER_OR_GOT */
1121
1122	#if KXLD_USER_OR_COMMON
1123	rval = resolve_common_symbols(object);
1124	require_noerr(rval, finish);
1125	#endif /* KXLD_USER_OR_COMMON */
1126
1127	/ Create the segments from the section index /
1128
1129	rval = kxld_seg_create_seg_from_sections(&object->segs, &object->sects);
1130	require_noerr(rval, finish);
1131
1132	rval = kxld_seg_finalize_object_segment(&object->segs,
1133	object->section_order, get_macho_header_size(object));
1134	require_noerr(rval, finish);
1135
1136	rval = kxld_seg_init_linkedit(&object->segs);
1137	require_noerr(rval, finish);
1138	}
1139
1140	rval = KERN_SUCCESS;
1141	finish:
1142	return rval;
1143	}
1144	#endif /* KXLD_USER_OR_OBJECT */
1145
1146	#if KXLD_USER_OR_ILP32
1147	/*******************************************************************************
1148	*******************************************************************************/
1149	static u_long
1150	get_macho_cmd_data_32(u_char file, u_long offset, u_int filetype, u_int *ncmds)
1151	{
1152	struct mach_header mach_hdr = (struct* mach_header ) ((void* *) (file + offset));
1153
1154	if (filetype) *filetype = mach_hdr->filetype;
1155	if (ncmds) *ncmds = mach_hdr->ncmds;
1156
1157	return sizeof(*mach_hdr);
1158	}
1159
1160	#endif /* KXLD_USER_OR_ILP32 */
1161
1162	#if KXLD_USER_OR_LP64
1163	/*******************************************************************************
1164	*******************************************************************************/
1165	static u_long
1166	get_macho_cmd_data_64(u_char file, u_long offset, u_int filetype, u_int *ncmds)
1167	{
1168	struct mach_header_64 mach_hdr = (struct* mach_header_64 ) ((void* *) (file + offset));
1169
1170	if (filetype) *filetype = mach_hdr->filetype;
1171	if (ncmds) *ncmds = mach_hdr->ncmds;
1172
1173	return sizeof(*mach_hdr);
1174	}
1175	#endif /* KXLD_USER_OR_LP64 */
1176
1177	/*******************************************************************************
1178	*******************************************************************************/
1179	static u_long
1180	get_macho_header_size(const KXLDObject *object)
1181	{
1182	KXLDSeg *seg = NULL;
1183	u_long header_size = `0`;
1184	u_int i = `0`;
1185	boolean_t object_is_32_bit = kxld_object_is_32_bit(object);
1186
1187	check(object);
1188
1189	/ Mach, segment, symtab, and UUID headers /
1190
1191	header_size += object_is_32_bit ? sizeof(struct mach_header) : sizeof(struct mach_header_64);
1192
1193	for (i = `0`; i < object->segs.nitems; ++i) {
1194	seg = kxld_array_get_item(&object->segs, i);
1195	header_size += kxld_seg_get_macho_header_size(seg, object_is_32_bit);
1196	}
1197
1198	header_size += kxld_symtab_get_macho_header_size();
1199
1200	#if KXLD_PIC_KEXTS
1201	if (target_supports_slideable_kexts(object)) {
1202	header_size += kxld_reloc_get_macho_header_size();
1203	}
1204	#endif /* KXLD_PIC_KEXTS */
1205
1206	if (object->uuid.has_uuid) {
1207	header_size += kxld_uuid_get_macho_header_size();
1208	}
1209
1210	if (object->versionmin.has_versionmin) {
1211	header_size += kxld_versionmin_get_macho_header_size(&object->versionmin);
1212	}
1213
1214	if (object->srcversion.has_srcversion) {
1215	header_size += kxld_srcversion_get_macho_header_size();
1216	}
1217
1218	if (isSplitKext && object->splitinfolc.has_splitinfolc) {
1219	header_size += kxld_splitinfolc_get_macho_header_size();
1220	}
1221
1222	return header_size;
1223	}
1224
1225	/*******************************************************************************
1226	*******************************************************************************/
1227	static u_long
1228	get_macho_data_size(const KXLDObject *object)
1229	{
1230	KXLDSeg *seg = NULL;
1231	u_long data_size = `0`;
1232	u_int i = `0`;
1233
1234	check(object);
1235
1236	/ total all segment vmsize values /
1237	for (i = `0`; i < object->segs.nitems; ++i) {
1238	seg = kxld_array_get_item(&object->segs, i);
1239	data_size += (u_long) kxld_seg_get_vmsize(seg);
1240	}
1241
1242	#if KXLD_PIC_KEXTS
1243	{
1244	/ ensure that when we eventually emit the final linked object,*
1245	* appending the __DYSYMTAB data after the __LINKEDIT data will
1246	* not overflow the space allocated for the __LINKEDIT segment
1247	*/
1248
1249	u_long seg_vmsize = `0`;
1250	u_long symtab_size = `0`;
1251	u_long reloc_size = `0`;
1252
1253	/ get current __LINKEDIT sizes /
1254	seg = kxld_object_get_seg_by_name(object, SEG_LINKEDIT);
1255
1256	seg_vmsize = (u_long) kxld_seg_get_vmsize(seg);
1257
1258	/ get size of symbol table data that will eventually be dumped*
1259	* into the __LINKEDIT segment
1260	*/
1261	symtab_size = kxld_symtab_get_macho_data_size(object->symtab, kxld_object_is_32_bit(object));
1262
1263	if (target_supports_slideable_kexts(object)) {
1264	/ get size of __DYSYMTAB relocation entries /
1265	reloc_size = kxld_reloc_get_macho_data_size(&object->locrelocs, &object->extrelocs);
1266	}
1267
1268	/ combine, and ensure they'll both fit within the page(s)*
1269	* allocated for the __LINKEDIT segment. If they'd overflow,
1270	* increase the vmsize appropriately so no overflow will occur
1271	*/
1272	if ((symtab_size + reloc_size) > seg_vmsize) {
1273	u_long overflow = (symtab_size + reloc_size) - seg_vmsize;
1274	data_size += kxld_round_page_cross_safe(overflow);
1275	}
1276	}
1277	#endif // KXLD_PIC_KEXTS
1278
1279	return data_size;
1280	}
1281
1282	/*******************************************************************************
1283	*******************************************************************************/
1284	boolean_t
1285	kxld_object_target_needs_swap(const KXLDObject *object __unused)
1286	{
1287	#if KERNEL
1288	return FALSE;
1289	#else
1290	return (object->target_order != object->host_order);
1291	#endif /* KERNEL */
1292	}
1293
1294	/*******************************************************************************
1295	*******************************************************************************/
1296	KXLDSeg *
1297	kxld_object_get_seg_by_name(const KXLDObject object, const* char *segname)
1298	{
1299	KXLDSeg *seg = NULL;
1300	u_int i = `0`;
1301
1302	for (i = `0`; i < object->segs.nitems; ++i) {
1303	seg = kxld_array_get_item(&object->segs, i);
1304
1305	if (streq_safe(segname, seg->segname, sizeof(seg->segname))) break;
1306
1307	seg = NULL;
1308	}
1309
1310	return seg;
1311	}
1312
1313	/*******************************************************************************
1314	*******************************************************************************/
1315	const KXLDRelocator *
1316	kxld_object_get_relocator(const KXLDObject * object)
1317	{
1318	check(object);
1319
1320	return &object->relocator;
1321	}
1322
1323	/*******************************************************************************
1324	*******************************************************************************/
1325	KXLDSect *
1326	kxld_object_get_sect_by_name(const KXLDObject object, const* char *segname,
1327	const char *sectname)
1328	{
1329	KXLDSect *sect = NULL;
1330	u_int i = `0`;
1331
1332	for (i = `0`; i < object->sects.nitems; ++i) {
1333	sect = kxld_array_get_item(&object->sects, i);
1334
1335	if (streq_safe(segname, sect->segname, sizeof(sect->segname)) &&
1336	streq_safe(sectname, sect->sectname, sizeof(sect->sectname)))
1337	{
1338	break;
1339	}
1340
1341	sect = NULL;
1342	}
1343
1344	return sect;
1345	}
1346
1347	/*******************************************************************************
1348	*******************************************************************************/
1349	const KXLDReloc *
1350	kxld_object_get_reloc_at_symbol(const KXLDObject object, const* KXLDSym *sym)
1351	{
1352	const KXLDReloc *reloc = NULL;
1353	const KXLDSect *sect = NULL;
1354	uint32_t offset = `0`;
1355
1356	check(object);
1357	check(sym);
1358
1359	sect = kxld_object_get_section_by_index(object, sym->sectnum);
1360	require(sect, finish);
1361
1362	if (kxld_object_is_final_image(object)) {
1363	reloc = kxld_reloc_get_reloc_by_offset(&object->extrelocs,
1364	sym->base_addr);
1365	if (!reloc) {
1366	reloc = kxld_reloc_get_reloc_by_offset(&object->locrelocs,
1367	sym->base_addr);
1368	}
1369	} else {
1370	offset = kxld_sym_get_section_offset(sym, sect);
1371	reloc = kxld_reloc_get_reloc_by_offset(&sect->relocs, offset);
1372	}
1373
1374	finish:
1375	return reloc;
1376	}
1377
1378	/*******************************************************************************
1379	*******************************************************************************/
1380	const KXLDSym *
1381	kxld_object_get_symbol_of_reloc(const KXLDObject *object,
1382	const KXLDReloc reloc, const* KXLDSect *sect)
1383	{
1384	const KXLDSym *sym = NULL;
1385	u_char *my_file;
1386
1387	if (isOldInterface) {
1388	my_file = object->file;
1389	}
1390	else {
1391	my_file = object->split_info.kextExecutable;
1392	}
1393
1394	if (kxld_object_is_final_image(object)) {
1395	sym = kxld_reloc_get_symbol(&object->relocator, reloc, my_file);
1396	} else {
1397	sym = kxld_reloc_get_symbol(&object->relocator, reloc, sect->data);
1398	}
1399	return sym;
1400	}
1401
1402	/*******************************************************************************
1403	*******************************************************************************/
1404	const KXLDSect *
1405	kxld_object_get_section_by_index(const KXLDObject *object, u_int sectnum)
1406	{
1407	KXLDSect *sect = NULL;
1408
1409	check(object);
1410
1411	if (sectnum < object->sects.nitems) {
1412	sect = kxld_array_get_item(&object->sects, sectnum);
1413	}
1414
1415	return sect;
1416	}
1417
1418	/*******************************************************************************
1419	*******************************************************************************/
1420	const KXLDArray *
1421	kxld_object_get_extrelocs(const KXLDObject *object)
1422	{
1423	const KXLDArray *rval = NULL;
1424
1425	check(object);
1426
1427	if (kxld_object_is_final_image(object)) {
1428	rval = &object->extrelocs;
1429	}
1430
1431	return rval;
1432	}
1433
1434	/*******************************************************************************
1435	*******************************************************************************/
1436	const KXLDSymtab *
1437	kxld_object_get_symtab(const KXLDObject *object)
1438	{
1439	check(object);
1440
1441	return object->symtab;
1442	}
1443
1444	#if KXLD_USER_OR_GOT \|\| KXLD_USER_OR_COMMON
1445	/*******************************************************************************
1446	*******************************************************************************/
1447	static kern_return_t
1448	add_section(KXLDObject object, KXLDSect *sect)
1449	{
1450	kern_return_t rval = KERN_FAILURE;
1451	u_int nsects = object->sects.nitems;
1452
1453	rval = kxld_array_resize(&object->sects, nsects + `1`);
1454	require_noerr(rval, finish);
1455
1456	*sect = kxld_array_get_item(&object->sects, nsects);
1457
1458	rval = KERN_SUCCESS;
1459
1460	finish:
1461	return rval;
1462	}
1463	#endif /* KXLD_USER_OR_GOT \|\| KXLD_USER_OR_COMMON */
1464
1465	#if KXLD_USER_OR_COMMON
1466	/*******************************************************************************
1467	* If there are common symbols, calculate how much space they'll need
1468	* and create/grow the __DATA __common section to accommodate them.
1469	* Then, resolve them against that section.
1470	*******************************************************************************/
1471	static kern_return_t
1472	resolve_common_symbols(KXLDObject *object)
1473	{
1474	kern_return_t rval = KERN_FAILURE;
1475	KXLDSymtabIterator iter;
1476	KXLDSym *sym = NULL;
1477	KXLDSect *sect = NULL;
1478	kxld_addr_t base_addr = `0`;
1479	kxld_size_t size = `0`;
1480	kxld_size_t total_size = `0`;
1481	u_int align = `0`;
1482	u_int max_align = `0`;
1483	u_int sectnum = `0`;
1484
1485	if (!kxld_object_target_supports_common_symbols(object)) {
1486	rval = KERN_SUCCESS;
1487	goto finish;
1488	}
1489
1490	/ Iterate over the common symbols to calculate their total aligned size /
1491	kxld_symtab_iterator_init(&iter, object->symtab, kxld_sym_is_common, FALSE);
1492	while ((sym = kxld_symtab_iterator_get_next(&iter))) {
1493	align = kxld_sym_get_common_align(sym);
1494	size = kxld_sym_get_common_size(sym);
1495
1496	if (align > max_align) max_align = align;
1497
1498	total_size = kxld_align_address(total_size, align) + size;
1499	}
1500
1501	/ If there are common symbols, grow or create the __DATA __common section*
1502	* to hold them.
1503	*/
1504	if (total_size) {
1505	sect = kxld_object_get_sect_by_name(object, SEG_DATA, SECT_COMMON);
1506	if (sect) {
1507	base_addr = sect->base_addr + sect->size;
1508
1509	kxld_sect_grow(sect, total_size, max_align);
1510	} else {
1511	base_addr = `0`;
1512
1513	rval = add_section(object, &sect);
1514	require_noerr(rval, finish);
1515
1516	kxld_sect_init_zerofill(sect, SEG_DATA, SECT_COMMON,
1517	total_size, max_align);
1518	}
1519
1520	/ Resolve the common symbols against the new section /
1521	rval = kxld_array_get_index(&object->sects, sect, &sectnum);
1522	require_noerr(rval, finish);
1523
1524	kxld_symtab_iterator_reset(&iter);
1525	while ((sym = kxld_symtab_iterator_get_next(&iter))) {
1526	align = kxld_sym_get_common_align(sym);
1527	size = kxld_sym_get_common_size(sym);
1528
1529	base_addr = kxld_align_address(base_addr, align);
1530	kxld_sym_resolve_common(sym, sectnum, base_addr);
1531
1532	base_addr += size;
1533	}
1534	}
1535
1536	rval = KERN_SUCCESS;
1537
1538	finish:
1539	return rval;
1540	}
1541	#endif /* KXLD_USER_OR_COMMON */
1542
1543	#if KXLD_USER_OR_GOT
1544	/*******************************************************************************
1545	*******************************************************************************/
1546	static boolean_t
1547	target_has_got(const KXLDObject *object)
1548	{
1549	return FALSE:
1550	}
1551
1552	/*******************************************************************************
1553	* Create and initialize the Global Offset Table
1554	*******************************************************************************/
1555	static kern_return_t
1556	create_got(KXLDObject *object)
1557	{
1558	kern_return_t rval = KERN_FAILURE;
1559	KXLDSect *sect = NULL;
1560	u_int ngots = `0`;
1561	u_int i = `0`;
1562
1563	if (!target_has_got(object)) {
1564	rval = KERN_SUCCESS;
1565	goto finish;
1566	}
1567
1568	for (i = `0`; i < object->sects.nitems; ++i) {
1569	sect = kxld_array_get_item(&object->sects, i);
1570	ngots += kxld_sect_get_ngots(sect, &object->relocator,
1571	object->symtab);
1572	}
1573
1574	rval = add_section(object, &sect);
1575	require_noerr(rval, finish);
1576
1577	rval = kxld_sect_init_got(sect, ngots);
1578	require_noerr(rval, finish);
1579
1580	object->got_is_created = TRUE;
1581	rval = KERN_SUCCESS;
1582
1583	finish:
1584	return rval;
1585	}
1586
1587	/*******************************************************************************
1588	*******************************************************************************/
1589	static kern_return_t
1590	populate_got(KXLDObject *object)
1591	{
1592	kern_return_t rval = KERN_FAILURE;
1593	KXLDSect *sect = NULL;
1594	u_int i = `0`;
1595
1596	if (!target_has_got(object) \|\| !object->got_is_created) {
1597	rval = KERN_SUCCESS;
1598	goto finish;
1599	}
1600
1601	for (i = `0`; i < object->sects.nitems; ++i) {
1602	sect = kxld_array_get_item(&object->sects, i);
1603	if (streq_safe(sect->segname, KXLD_SEG_GOT, sizeof(KXLD_SEG_GOT)) &&
1604	streq_safe(sect->sectname, KXLD_SECT_GOT, sizeof(KXLD_SECT_GOT)))
1605	{
1606	kxld_sect_populate_got(sect, object->symtab,
1607	kxld_object_target_needs_swap(object));
1608	break;
1609	}
1610	}
1611
1612	require_action(i < object->sects.nitems, finish, rval=KXLD_MISSING_GOT);
1613
1614	rval = KERN_SUCCESS;
1615
1616	finish:
1617	return rval;
1618	}
1619	#endif /* KXLD_USER_OR_GOT */
1620
1621	/*******************************************************************************
1622	*******************************************************************************/
1623	static boolean_t
1624	target_supports_protected_segments(const KXLDObject *object)
1625	{
1626	return (object->is_final_image &&
1627	(object->cputype == CPU_TYPE_X86_64 \|\|
1628	object->cputype == CPU_TYPE_ARM \|\|
1629	object->cputype == CPU_TYPE_ARM64));
1630	}
1631
1632	/*******************************************************************************
1633	*******************************************************************************/
1634	static void
1635	set_is_object_linked(KXLDObject *object)
1636	{
1637	u_int i = `0`;
1638
1639	if (kxld_object_is_kernel(object)) {
1640	object->is_linked = TRUE;
1641	return;
1642	}
1643
1644	if (object->is_final_image) {
1645	object->is_linked = !object->extrelocs.nitems;
1646	return;
1647	}
1648
1649	object->is_linked = TRUE;
1650	for (i = `0`; i < object->sects.nitems; ++i) {
1651	KXLDSect *sect = kxld_array_get_item(&object->sects, i);
1652	if (sect->relocs.nitems) {
1653	object->is_linked = FALSE;
1654	break;
1655	}
1656	}
1657	}
1658
1659
1660	/*******************************************************************************
1661	*******************************************************************************/
1662	void kxld_object_clear(KXLDObject *object)
1663	{
1664	KXLDSeg *seg = NULL;
1665	KXLDSect *sect = NULL;
1666	u_int i;
1667	u_char *my_file;
1668
1669	check(object);
1670
1671	if (isOldInterface) {
1672	my_file = object->file;
1673	}
1674	else {
1675	my_file = object->split_info.kextExecutable;
1676	}
1677
1678	#if !KERNEL
1679	if (kxld_object_is_kernel(object)) {
1680	unswap_macho(my_file, object->host_order, object->target_order);
1681	}
1682	#endif /* !KERNEL */
1683
1684	for (i = `0`; i < object->segs.nitems; ++i) {
1685	seg = kxld_array_get_item(&object->segs, i);
1686	kxld_seg_clear(seg);
1687	}
1688	kxld_array_reset(&object->segs);
1689
1690	for (i = `0`; i < object->sects.nitems; ++i) {
1691	sect = kxld_array_get_item(&object->sects, i);
1692	kxld_sect_clear(sect);
1693	}
1694	kxld_array_reset(&object->sects);
1695
1696	kxld_array_reset(&object->extrelocs);
1697	kxld_array_reset(&object->locrelocs);
1698	kxld_relocator_clear(&object->relocator);
1699	kxld_uuid_clear(&object->uuid);
1700	kxld_versionmin_clear(&object->versionmin);
1701	kxld_srcversion_clear(&object->srcversion);
1702
1703	if (object->symtab) kxld_symtab_clear(object->symtab);
1704
1705	if (isOldInterface) {
1706	object->file = NULL;
1707	object->size = `0`;
1708	}
1709	else {
1710	kxld_splitinfolc_clear(&object->splitinfolc);
1711	object->split_info.kextExecutable = NULL;
1712	object->split_info.kextSize = `0`;
1713	}
1714	object->filetype = `0`;
1715	object->cputype = `0`;
1716	object->cpusubtype = `0`;
1717	object->is_kernel = FALSE;
1718	object->is_final_image = FALSE;
1719	object->is_linked = FALSE;
1720	object->got_is_created = FALSE;
1721
1722	#if KXLD_USER_OR_OBJECT
1723	object->section_order = NULL;
1724	#endif
1725	#if !KERNEL
1726	object->host_order = `0`;
1727	object->target_order = `0`;
1728	#endif
1729	}
1730
1731	/*******************************************************************************
1732	*******************************************************************************/
1733	void kxld_object_deinit(KXLDObject *object __unused)
1734	{
1735	KXLDSeg *seg = NULL;
1736	KXLDSect *sect = NULL;
1737	u_int i;
1738	u_char *my_file;
1739
1740	check(object);
1741
1742	if (isOldInterface) {
1743	my_file = object->file;
1744	}
1745	else {
1746	my_file = object->split_info.kextExecutable;
1747	}
1748
1749	#if !KERNEL
1750	if (my_file && kxld_object_is_kernel(object)) {
1751	unswap_macho(my_file, object->host_order, object->target_order);
1752	}
1753	#endif /* !KERNEL */
1754
1755	for (i = `0`; i < object->segs.maxitems; ++i) {
1756	seg = kxld_array_get_slot(&object->segs, i);
1757	kxld_seg_deinit(seg);
1758	}
1759	kxld_array_deinit(&object->segs);
1760
1761	for (i = `0`; i < object->sects.maxitems; ++i) {
1762	sect = kxld_array_get_slot(&object->sects, i);
1763	kxld_sect_deinit(sect);
1764	}
1765	kxld_array_deinit(&object->sects);
1766
1767	kxld_array_deinit(&object->extrelocs);
1768	kxld_array_deinit(&object->locrelocs);
1769
1770	if (object->symtab) {
1771	kxld_symtab_deinit(object->symtab);
1772	kxld_free(object->symtab, kxld_symtab_sizeof());
1773	}
1774
1775	bzero(object, sizeof(*object));
1776	}
1777
1778	/*******************************************************************************
1779	*******************************************************************************/
1780	const u_char *
1781	kxld_object_get_file(const KXLDObject *object)
1782	{
1783	const u_char *my_file;
1784
1785	check(object);
1786
1787	if (isOldInterface) {
1788	my_file = object->file;
1789	}
1790	else {
1791	my_file = object->split_info.kextExecutable;
1792	}
1793
1794	return my_file;
1795	}
1796
1797	/*******************************************************************************
1798	*******************************************************************************/
1799	const char *
1800	kxld_object_get_name(const KXLDObject *object)
1801	{
1802	check(object);
1803
1804	return object->name;
1805	}
1806
1807	/*******************************************************************************
1808	*******************************************************************************/
1809	boolean_t
1810	kxld_object_is_32_bit(const KXLDObject *object)
1811	{
1812	check(object);
1813
1814	return kxld_is_32_bit(object->cputype);
1815	}
1816
1817	/*******************************************************************************
1818	*******************************************************************************/
1819	boolean_t
1820	kxld_object_is_final_image(const KXLDObject *object)
1821	{
1822	check(object);
1823
1824	return object->is_final_image;
1825	}
1826
1827	/*******************************************************************************
1828	*******************************************************************************/
1829	boolean_t
1830	kxld_object_is_kernel(const KXLDObject *object)
1831	{
1832	check(object);
1833
1834	return object->is_kernel;
1835	}
1836
1837	/*******************************************************************************
1838	*******************************************************************************/
1839	boolean_t
1840	kxld_object_is_linked(const KXLDObject *object)
1841	{
1842	check(object);
1843
1844	return object->is_linked;
1845	}
1846
1847	/*******************************************************************************
1848	*******************************************************************************/
1849	boolean_t
1850	kxld_object_target_supports_strict_patching(const KXLDObject *object)
1851	{
1852	check(object);
1853
1854	return (object->cputype != CPU_TYPE_I386);
1855	}
1856
1857	/*******************************************************************************
1858	*******************************************************************************/
1859	boolean_t
1860	kxld_object_target_supports_common_symbols(const KXLDObject *object)
1861	{
1862	check(object);
1863
1864	return (object->cputype == CPU_TYPE_I386);
1865	}
1866
1867
1868	/*******************************************************************************
1869	*******************************************************************************/
1870	void
1871	kxld_object_get_vmsize_for_seg_by_name(const KXLDObject *object,
1872	const char *segname,
1873	u_long *vmsize)
1874	{
1875	check(object);
1876	check(segname);
1877	check(vmsize);
1878
1879	KXLDSeg *seg = NULL;
1880	u_long my_size = `0`;
1881
1882	/ segment vmsize /
1883	seg = kxld_object_get_seg_by_name(object, segname);
1884
1885	my_size = (u_long) kxld_seg_get_vmsize(seg);
1886
1887	#if KXLD_PIC_KEXTS
1888	if (kxld_seg_is_linkedit_seg(seg))
1889	{
1890	u_long reloc_size = `0`;
1891
1892	if (target_supports_slideable_kexts(object)) {
1893	/ get size of __DYSYMTAB relocation entries /
1894	reloc_size = kxld_reloc_get_macho_data_size(&object->locrelocs, &object->extrelocs);
1895	my_size += reloc_size;
1896	}
1897	}
1898	#endif
1899
1900	*vmsize = my_size;
1901	}
1902
1903	/*******************************************************************************
1904	*******************************************************************************/
1905	void
1906	kxld_object_get_vmsize(const KXLDObject object, u_long header_size,
1907	u_long *vmsize)
1908	{
1909	check(object);
1910	check(header_size);
1911	check(vmsize);
1912	*header_size = `0`;
1913	*vmsize = `0`;
1914
1915	/ vmsize is the padded header page(s) + segment vmsizes /
1916
1917	*header_size = (object->is_final_image) ?
1918	`0` : (u_long)kxld_round_page_cross_safe(get_macho_header_size(object));
1919
1920	vmsize = header_size + get_macho_data_size(object);
1921
1922	}
1923
1924	/*******************************************************************************
1925	*******************************************************************************/
1926	void
1927	kxld_object_set_linked_object_size(KXLDObject *object, u_long vmsize)
1928	{
1929	check(object);
1930
1931	if (isOldInterface) {
1932	object->output_buffer_size = vmsize; / cache this for use later /
1933	}
1934	else {
1935	object->split_info.linkedKextSize = vmsize;
1936	}
1937	return;
1938	}
1939
1940	/*******************************************************************************
1941	*******************************************************************************/
1942	kern_return_t
1943	kxld_object_export_linked_object(const KXLDObject *object,
1944	void *linked_object
1945	)
1946	{
1947	kern_return_t rval = KERN_FAILURE;
1948	KXLDSeg *seg = NULL;
1949	u_long size = `0`;
1950	u_long header_size = `0`;
1951	u_long header_offset = `0`;
1952	u_long data_offset = `0`;
1953	u_int ncmds = `0`;
1954	u_int i = `0`;
1955	boolean_t is_32bit_object = kxld_object_is_32_bit(object);
1956	kxld_addr_t link_addr;
1957	u_char *my_linked_object;
1958
1959	check(object);
1960	check(linked_object);
1961
1962	if (isOldInterface) {
1963	size = object->output_buffer_size;
1964	link_addr = object->link_addr;
1965	my_linked_object = (u_char *) linked_object;
1966	}
1967	else {
1968	size = ((splitKextLinkInfo *)linked_object)->linkedKextSize;
1969	link_addr = ((splitKextLinkInfo *)linked_object)->vmaddr_TEXT;
1970	my_linked_object = ((splitKextLinkInfo *)linked_object)->linkedKext;
1971	}
1972
1973	/ Calculate the size of the headers and data /
1974
1975	header_size = get_macho_header_size(object);
1976
1977	/ Copy data to the file /
1978
1979	ncmds = object->segs.nitems + `1` / LC_SYMTAB /;
1980
1981	#if KXLD_PIC_KEXTS
1982	/ don't write out a DYSYMTAB segment for targets that can't digest it*
1983	*/
1984	if (target_supports_slideable_kexts(object)) {
1985	ncmds++; / dysymtab /
1986	}
1987	#endif /* KXLD_PIC_KEXTS */
1988
1989	if (object->uuid.has_uuid == TRUE) {
1990	ncmds++;
1991	}
1992
1993	if (object->versionmin.has_versionmin == TRUE) {
1994	ncmds++;
1995	}
1996
1997	if (object->srcversion.has_srcversion == TRUE) {
1998	ncmds++;
1999	}
2000
2001	if (isSplitKext && object->splitinfolc.has_splitinfolc) {
2002	ncmds++;
2003	}
2004
2005	rval = export_macho_header(object, my_linked_object, ncmds, &header_offset, header_size);
2006	require_noerr(rval, finish);
2007
2008	for (i = `0`; i < object->segs.nitems; ++i) {
2009	seg = kxld_array_get_item(&object->segs, i);
2010
2011	rval = kxld_seg_export_macho_to_vm(seg, my_linked_object, &header_offset,
2012	header_size, size, link_addr, is_32bit_object);
2013	require_noerr(rval, finish);
2014	}
2015
2016	seg = kxld_object_get_seg_by_name(object, SEG_LINKEDIT);
2017	data_offset = (u_long) (seg->link_addr - link_addr);
2018
2019	// data_offset is used to set the fileoff in the macho header load commands
2020	rval = kxld_symtab_export_macho(object->symtab,
2021	my_linked_object,
2022	&header_offset,
2023	header_size,
2024	&data_offset, size, is_32bit_object);
2025	require_noerr(rval, finish);
2026
2027	// data_offset now points past the symbol tab and strings data in the linkedit
2028	// segment - (it was used to set new values for symoff and stroff)
2029
2030	#if KXLD_PIC_KEXTS
2031	if (target_supports_slideable_kexts(object)) {
2032	rval = kxld_reloc_export_macho(&object->relocator,
2033	&object->locrelocs,
2034	&object->extrelocs,
2035	my_linked_object,
2036	&header_offset,
2037	header_size,
2038	&data_offset, size);
2039	require_noerr(rval, finish);
2040	}
2041	#endif /* KXLD_PIC_KEXTS */
2042
2043	if (object->uuid.has_uuid) {
2044	rval = kxld_uuid_export_macho(&object->uuid, my_linked_object, &header_offset, header_size);
2045	require_noerr(rval, finish);
2046	}
2047
2048	if (object->versionmin.has_versionmin) {
2049	rval = kxld_versionmin_export_macho(&object->versionmin, my_linked_object, &header_offset, header_size);
2050	require_noerr(rval, finish);
2051	}
2052
2053	if (object->srcversion.has_srcversion) {
2054	rval = kxld_srcversion_export_macho(&object->srcversion, my_linked_object, &header_offset, header_size);
2055	require_noerr(rval, finish);
2056	}
2057
2058	if (isSplitKext && object->splitinfolc.has_splitinfolc) {
2059	rval = kxld_splitinfolc_export_macho(&object->splitinfolc,
2060	linked_object,
2061	&header_offset,
2062	header_size,
2063	&data_offset,
2064	size);
2065	require_noerr(rval, finish);
2066	}
2067
2068	#if !KERNEL
2069	unswap_macho(my_linked_object, object->host_order, object->target_order);
2070	#endif /* KERNEL */
2071
2072	rval = KERN_SUCCESS;
2073
2074	finish:
2075	return rval;
2076	}
2077
2078	/*******************************************************************************
2079	*******************************************************************************/
2080	static kern_return_t
2081	export_macho_header(const KXLDObject object, u_char buf, u_int ncmds,
2082	u_long *header_offset, u_long header_size)
2083	{
2084	kern_return_t rval = KERN_FAILURE;
2085
2086	check(object);
2087	check(buf);
2088	check(header_offset);
2089
2090	KXLD_3264_FUNC(kxld_object_is_32_bit(object), rval,
2091	export_macho_header_32, export_macho_header_64,
2092	object, buf, ncmds, header_offset, header_size);
2093	require_noerr(rval, finish);
2094
2095	rval = KERN_SUCCESS;
2096
2097	finish:
2098	return rval;
2099	}
2100
2101	#if KXLD_USER_OR_ILP32
2102	/*******************************************************************************
2103	*******************************************************************************/
2104	static kern_return_t
2105	export_macho_header_32(const KXLDObject object, u_char buf, u_int ncmds,
2106	u_long *header_offset, u_long header_size)
2107	{
2108	kern_return_t rval = KERN_FAILURE;
2109	struct mach_header *mach = NULL;
2110
2111	check(object);
2112	check(buf);
2113	check(header_offset);
2114
2115	require_action(sizeof(mach) <= header_size - header_offset, finish,
2116	rval=KERN_FAILURE);
2117	mach = (struct mach_header ) ((void* ) (buf + header_offset));
2118
2119	mach->magic = MH_MAGIC;
2120	mach->cputype = object->cputype;
2121	mach->cpusubtype = object->cpusubtype;
2122	mach->filetype = object->filetype;
2123	mach->ncmds = ncmds;
2124	mach->sizeofcmds = (uint32_t) (header_size - sizeof(*mach));
2125	mach->flags = MH_NOUNDEFS;
2126
2127	header_offset += sizeof(mach);
2128
2129	rval = KERN_SUCCESS;
2130
2131	finish:
2132	return rval;
2133	}
2134	#endif /* KXLD_USER_OR_ILP32 */
2135
2136	#if KXLD_USER_OR_LP64
2137	/*******************************************************************************
2138	*******************************************************************************/
2139	static kern_return_t
2140	export_macho_header_64(const KXLDObject object, u_char buf, u_int ncmds,
2141	u_long *header_offset, u_long header_size)
2142	{
2143	kern_return_t rval = KERN_FAILURE;
2144	struct mach_header_64 *mach = NULL;
2145
2146	check(object);
2147	check(buf);
2148	check(header_offset);
2149
2150	require_action(sizeof(mach) <= header_size - header_offset, finish,
2151	rval=KERN_FAILURE);
2152	mach = (struct mach_header_64 ) ((void* ) (buf + header_offset));
2153
2154	mach->magic = MH_MAGIC_64;
2155	mach->cputype = object->cputype;
2156	mach->cpusubtype = object->cpusubtype;
2157	mach->filetype = object->filetype;
2158	mach->ncmds = ncmds;
2159	mach->sizeofcmds = (uint32_t) (header_size - sizeof(*mach));
2160	mach->flags = MH_NOUNDEFS;
2161
2162	header_offset += sizeof(mach);
2163
2164	#if SPLIT_KEXTS_DEBUG
2165	{
2166	kxld_log(kKxldLogLinking, kKxldLogErr,
2167	" %p >>> Start of macho header (size %lu) <%s>",
2168	(void *) mach,
2169	sizeof(*mach),
2170	__func__);
2171	kxld_log(kKxldLogLinking, kKxldLogErr,
2172	" %p <<< End of macho header <%s>",
2173	(void ) ((u_char )mach + sizeof(*mach)),
2174	__func__);
2175	}
2176	#endif
2177
2178	rval = KERN_SUCCESS;
2179
2180	finish:
2181	return rval;
2182	}
2183	#endif /* KXLD_USER_OR_LP64 */
2184
2185	/*******************************************************************************
2186	*******************************************************************************/
2187	kern_return_t
2188	kxld_object_index_symbols_by_name(KXLDObject *object)
2189	{
2190	return kxld_symtab_index_symbols_by_name(object->symtab);
2191	}
2192
2193	/*******************************************************************************
2194	*******************************************************************************/
2195	kern_return_t
2196	kxld_object_index_cxx_symbols_by_value(KXLDObject *object)
2197	{
2198	return kxld_symtab_index_cxx_symbols_by_value(object->symtab);
2199	}
2200
2201	/*******************************************************************************
2202	*******************************************************************************/
2203	kern_return_t
2204	kxld_object_relocate(KXLDObject *object, kxld_addr_t link_address)
2205	{
2206	kern_return_t rval = KERN_FAILURE;
2207	KXLDSeg *seg = NULL;
2208	u_int i = `0`;
2209
2210	check(object);
2211
2212	object->link_addr = link_address;
2213
2214	/ Relocate segments (which relocates the sections) /
2215	for (i = `0`; i < object->segs.nitems; ++i) {
2216	seg = kxld_array_get_item(&object->segs, i);
2217	kxld_seg_relocate(seg, link_address);
2218	} // for...
2219
2220	/ Relocate symbols /
2221	rval = kxld_symtab_relocate(object->symtab, &object->sects);
2222	require_noerr(rval, finish);
2223
2224	rval = KERN_SUCCESS;
2225	finish:
2226	return rval;
2227	}
2228
2229	/*******************************************************************************
2230	*******************************************************************************/
2231	static KXLDSym *
2232	get_mutable_sym(const KXLDObject object, const* KXLDSym *sym)
2233	{
2234	KXLDSym *rval = NULL;
2235	kern_return_t result = KERN_FAILURE;
2236	u_int i = `0`;
2237
2238	result = kxld_symtab_get_sym_index(object->symtab, sym, &i);
2239	require_noerr(result, finish);
2240
2241	rval = kxld_symtab_get_symbol_by_index(object->symtab, i);
2242	require_action(rval == sym, finish, rval=NULL);
2243
2244	finish:
2245	return rval;
2246	}
2247
2248	/*******************************************************************************
2249	*******************************************************************************/
2250	kern_return_t
2251	kxld_object_resolve_symbol(KXLDObject *object,
2252	const KXLDSym *sym, kxld_addr_t addr)
2253	{
2254	kern_return_t rval = KERN_FAILURE;
2255	KXLDSym *resolved_sym = NULL;
2256
2257	resolved_sym = get_mutable_sym(object, sym);
2258	require_action(resolved_sym, finish, rval=KERN_FAILURE);
2259
2260	rval = kxld_sym_resolve(resolved_sym, addr);
2261	require_noerr(rval, finish);
2262
2263	rval = KERN_SUCCESS;
2264	finish:
2265	return rval;
2266	}
2267
2268	/*******************************************************************************
2269	*******************************************************************************/
2270	kern_return_t
2271	kxld_object_patch_symbol(KXLDObject object, const* struct kxld_sym *sym)
2272	{
2273	kern_return_t rval = KERN_FAILURE;
2274	KXLDSym *patched_sym = NULL;
2275
2276	patched_sym = get_mutable_sym(object, sym);
2277	require_action(patched_sym, finish, rval=KERN_FAILURE);
2278
2279	(void) kxld_sym_patch(patched_sym);
2280	rval = KERN_SUCCESS;
2281	finish:
2282	return rval;
2283	}
2284
2285	/*******************************************************************************
2286	*******************************************************************************/
2287	kern_return_t
2288	kxld_object_add_symbol(KXLDObject object, char* *name, kxld_addr_t link_addr,
2289	const KXLDSym **sym_out)
2290	{
2291	kern_return_t rval = KERN_FAILURE;
2292	KXLDSym *sym = NULL;
2293
2294	rval = kxld_symtab_add_symbol(object->symtab, name, link_addr, &sym);
2295	require_noerr(rval, finish);
2296
2297	*sym_out = sym;
2298	rval = KERN_SUCCESS;
2299	finish:
2300	return rval;
2301	}
2302
2303	/*******************************************************************************
2304	*******************************************************************************/
2305	kern_return_t
2306	kxld_object_process_relocations(KXLDObject *object,
2307	const KXLDDict *patched_vtables)
2308	{
2309	kern_return_t rval = KERN_FAILURE;
2310
2311	(void) kxld_relocator_set_vtables(&object->relocator, patched_vtables);
2312
2313	/ Process relocation entries and populate the global offset table.*
2314	*
2315	* For final linked images: the relocation entries are contained in a couple
2316	* of tables hanging off the end of the symbol table. The GOT has its own
2317	* section created by the linker; we simply need to fill it.
2318	*
2319	* For object files: the relocation entries are bound to each section.
2320	* The GOT, if it exists for the target architecture, is created by kxld,
2321	* and we must populate it according to our internal structures.
2322	*/
2323	if (object->is_final_image) {
2324	#if KXLD_USER_OR_BUNDLE
2325	rval = process_symbol_pointers(object);
2326	require_noerr(rval, finish);
2327
2328	rval = process_relocs_from_tables(object);
2329	require_noerr(rval, finish);
2330	#else
2331	require_action(FALSE, finish, rval=KERN_FAILURE);
2332	#endif /* KXLD_USER_OR_BUNDLE */
2333	} else {
2334	#if KXLD_USER_OR_GOT
2335	/ Populate GOT /
2336	rval = populate_got(object);
2337	require_noerr(rval, finish);
2338	#endif /* KXLD_USER_OR_GOT */
2339	#if KXLD_USER_OR_OBJECT
2340	rval = process_relocs_from_sections(object);
2341	require_noerr(rval, finish);
2342	#else
2343	require_action(FALSE, finish, rval=KERN_FAILURE);
2344	#endif /* KXLD_USER_OR_OBJECT */
2345	}
2346
2347	/ Populate kmod info structure /
2348	rval = populate_kmod_info(object);
2349	require_noerr(rval, finish);
2350
2351	rval = KERN_SUCCESS;
2352	finish:
2353	return rval;
2354	}
2355
2356	#if KXLD_USER_OR_BUNDLE
2357
2358	#if SPLIT_KEXTS_DEBUG
2359	static boolean_t kxld_show_ptr_value;
2360	#endif
2361
2362	#define SECT_SYM_PTRS "__nl_symbol_ptr"
2363
2364	/*******************************************************************************
2365	* Final linked images create an __nl_symbol_ptr section for the global offset
2366	* table and for symbol pointer lookups in general. Rather than use relocation
2367	* entries, the linker creates an "indirect symbol table" which stores indexes
2368	* into the symbol table corresponding to the entries of this section. This
2369	* function populates the section with the relocated addresses of those symbols.
2370	*******************************************************************************/
2371	static kern_return_t
2372	process_symbol_pointers(KXLDObject *object)
2373	{
2374	kern_return_t rval = KERN_FAILURE;
2375	KXLDSect *sect = NULL;
2376	KXLDSym *sym = NULL;
2377	int32_t *symidx = NULL;
2378	u_char *symptr = NULL;
2379	u_long symptrsize = `0`;
2380	u_int nsyms = `0`;
2381	u_int firstsym = `0`;
2382	u_int i = `0`;
2383
2384	check(object);
2385
2386	require_action(object->is_final_image && object->dysymtab_hdr,
2387	finish, rval=KERN_FAILURE);
2388
2389	/ Get the __DATA,__nl_symbol_ptr section. If it doesn't exist, we have*
2390	* nothing to do.
2391	*/
2392
2393	sect = kxld_object_get_sect_by_name(object, SEG_DATA, SECT_SYM_PTRS);
2394	if (!sect \|\| !(sect->flags & S_NON_LAZY_SYMBOL_POINTERS)) {
2395	rval = KERN_SUCCESS;
2396	goto finish;
2397	}
2398
2399	/ Calculate the table offset and number of entries in the section /
2400
2401	if (kxld_object_is_32_bit(object)) {
2402	symptrsize = sizeof(uint32_t);
2403	} else {
2404	symptrsize = sizeof(uint64_t);
2405	}
2406
2407	nsyms = (u_int) (sect->size / symptrsize);
2408	firstsym = sect->reserved1;
2409
2410	require_action(firstsym + nsyms <= object->dysymtab_hdr->nindirectsyms,
2411	finish, rval=KERN_FAILURE;
2412	kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogMalformedMachO
2413	"firstsym + nsyms > object->dysymtab_hdr->nindirectsyms"));
2414
2415	/ Iterate through the indirect symbol table and fill in the section of*
2416	* symbol pointers. There are three cases:
2417	* 1) A normal symbol - put its value directly in the table
2418	* 2) An INDIRECT_SYMBOL_LOCAL - symbols that are local and already have
2419	* their offset from the start of the file in the section. Simply
2420	* add the file's link address to fill this entry.
2421	* 3) An INDIRECT_SYMBOL_ABS - prepopulated absolute symbols. No
2422	* action is required.
2423	*/
2424
2425	if (isOldInterface) {
2426	symidx = (int32_t ) ((void* *) (object->file + object->dysymtab_hdr->indirectsymoff));
2427	}
2428	else {
2429	symidx = (int32_t ) ((void* *) (object->split_info.kextExecutable + object->dysymtab_hdr->indirectsymoff));
2430	}
2431
2432	symidx += firstsym;
2433	symptr = sect->data;
2434	for (i = `0`; i < nsyms; ++i, ++symidx, symptr+=symptrsize) {
2435	if (*symidx & INDIRECT_SYMBOL_LOCAL) {
2436	if (symidx & INDIRECT_SYMBOL_ABS) continue*;
2437
2438	if (isOldInterface) {
2439	add_to_ptr(symptr, object->link_addr, kxld_object_is_32_bit(object));
2440	}
2441	else {
2442	add_to_ptr(symptr, object->split_info.vmaddr_TEXT, kxld_object_is_32_bit(object));
2443	}
2444	} else {
2445	sym = kxld_symtab_get_symbol_by_index(object->symtab, *symidx);
2446	require_action(sym, finish, rval=KERN_FAILURE);
2447
2448	if (isOldInterface) {
2449	add_to_ptr(symptr, sym->link_addr, kxld_object_is_32_bit(object));
2450	}
2451	else {
2452	add_to_ptr(symptr, object->split_info.vmaddr_TEXT, kxld_object_is_32_bit(object));
2453	}
2454	}
2455	}
2456
2457	rval = KERN_SUCCESS;
2458	finish:
2459	return rval;
2460	}
2461
2462	/*******************************************************************************
2463	*******************************************************************************/
2464	static KXLDSeg *
2465	get_seg_by_base_addr(KXLDObject *object, kxld_addr_t base_addr)
2466	{
2467	KXLDSeg *seg = NULL;
2468	kxld_addr_t start = `0`;
2469	kxld_addr_t end = `0`;
2470	u_int i = `0`;
2471
2472	for (i = `0`; i < object->segs.nitems; ++i) {
2473	seg = kxld_array_get_item(&object->segs, i);
2474	start = seg->base_addr;
2475	end = seg->base_addr + seg->vmsize;
2476
2477	if (start <= base_addr && base_addr < end) return seg;
2478	}
2479
2480	return NULL;
2481	}
2482
2483	/*******************************************************************************
2484	*******************************************************************************/
2485	static kern_return_t
2486	process_relocs_from_tables(KXLDObject *object)
2487	{
2488	kern_return_t rval = KERN_FAILURE;
2489	KXLDReloc *reloc = NULL;
2490	KXLDSeg *seg = NULL;
2491	u_int i = `0`;
2492
2493	/ Process external relocations /
2494	for (i = `0`; i < object->extrelocs.nitems; ++i) {
2495	reloc = kxld_array_get_item(&object->extrelocs, i);
2496
2497	seg = get_seg_by_base_addr(object, reloc->address);
2498	require_action(seg, finish, rval=KERN_FAILURE);
2499
2500	if (isOldInterface) {
2501	rval = kxld_relocator_process_table_reloc(&object->relocator, reloc,
2502	seg, object->link_addr);
2503	}
2504	else {
2505	kxld_addr_t my_link_addr = object->split_info.vmaddr_TEXT;
2506	if (isSplitKext) {
2507	if (kxld_seg_is_text_exec_seg(seg)) {
2508	my_link_addr = object->split_info.vmaddr_TEXT_EXEC;
2509	}
2510	else if (kxld_seg_is_data_seg(seg)) {
2511	my_link_addr = object->split_info.vmaddr_DATA;
2512	}
2513	else if (kxld_seg_is_data_const_seg(seg)) {
2514	my_link_addr = object->split_info.vmaddr_DATA_CONST;
2515	}
2516	else if (kxld_seg_is_llvm_cov_seg(seg)) {
2517	my_link_addr = object->split_info.vmaddr_LLVM_COV;
2518	}
2519	else if (kxld_seg_is_linkedit_seg(seg)) {
2520	my_link_addr = object->split_info.vmaddr_LINKEDIT;
2521	}
2522	}
2523	rval = kxld_relocator_process_table_reloc(&object->relocator,
2524	reloc,
2525	seg,
2526	my_link_addr);
2527	}
2528	require_noerr(rval, finish);
2529	}
2530
2531	/ Process local relocations /
2532	for (i = `0`; i < object->locrelocs.nitems; ++i) {
2533	reloc = kxld_array_get_item(&object->locrelocs, i);
2534
2535	seg = get_seg_by_base_addr(object, reloc->address);
2536	require_action(seg, finish, rval=KERN_FAILURE);
2537
2538	if (isOldInterface) {
2539	rval = kxld_relocator_process_table_reloc(&object->relocator, reloc,
2540	seg, object->link_addr);
2541	}
2542	else {
2543	kxld_addr_t my_link_addr = object->split_info.vmaddr_TEXT;
2544	if (isSplitKext) {
2545	if (kxld_seg_is_text_exec_seg(seg)) {
2546	my_link_addr = object->split_info.vmaddr_TEXT_EXEC;
2547	}
2548	else if (kxld_seg_is_data_seg(seg)) {
2549	my_link_addr = object->split_info.vmaddr_DATA;
2550	}
2551	else if (kxld_seg_is_data_const_seg(seg)) {
2552	my_link_addr = object->split_info.vmaddr_DATA_CONST;
2553	}
2554	else if (kxld_seg_is_llvm_cov_seg(seg)) {
2555	my_link_addr = object->split_info.vmaddr_LLVM_COV;
2556	}
2557	else if (kxld_seg_is_linkedit_seg(seg)) {
2558	my_link_addr = object->split_info.vmaddr_LINKEDIT;
2559	}
2560	}
2561	rval = kxld_relocator_process_table_reloc(&object->relocator,
2562	reloc,
2563	seg,
2564	my_link_addr);
2565	}
2566	require_noerr(rval, finish);
2567	}
2568
2569	rval = KERN_SUCCESS;
2570	finish:
2571	return rval;
2572	}
2573
2574	/*******************************************************************************
2575	*******************************************************************************/
2576	static void
2577	add_to_ptr(u_char *symptr, kxld_addr_t val, boolean_t is_32_bit)
2578	{
2579	if (is_32_bit) {
2580	uint32_t ptr = (uint32_t ) ((void *) symptr);
2581
2582	*ptr += (uint32_t) val;
2583	} else {
2584	uint64_t ptr = (uint64_t ) ((void *) symptr);
2585
2586	*ptr += (uint64_t) val;
2587	}
2588
2589	#if SPLIT_KEXTS_DEBUG
2590	kxld_show_ptr_value = FALSE;
2591	#endif
2592
2593	}
2594	#endif /* KXLD_USER_OR_BUNDLE */
2595
2596	#if KXLD_USER_OR_OBJECT
2597	/*******************************************************************************
2598	*******************************************************************************/
2599	static kern_return_t
2600	process_relocs_from_sections(KXLDObject *object)
2601	{
2602	kern_return_t rval = KERN_FAILURE;
2603	KXLDSect *sect = NULL;
2604	u_int i = `0`;
2605
2606	for (i = `0`; i < object->sects.nitems; ++i) {
2607	sect = kxld_array_get_item(&object->sects, i);
2608	rval = kxld_sect_process_relocs(sect, &object->relocator);
2609	require_noerr(rval, finish);
2610	}
2611
2612	rval = KERN_SUCCESS;
2613	finish:
2614	return rval;
2615	}
2616	#endif /* KXLD_USER_OR_OBJECT */
2617
2618	/*******************************************************************************
2619	*******************************************************************************/
2620	static kern_return_t
2621	populate_kmod_info(KXLDObject *object)
2622	{
2623	kern_return_t rval = KERN_FAILURE;
2624	KXLDSect *kmodsect = NULL;
2625	KXLDSym *kmodsym = NULL;
2626	kmod_info_t *kmod_info = NULL;
2627	u_long kmod_offset = `0`;
2628	u_long header_size;
2629	u_long size;
2630
2631	if (kxld_object_is_kernel(object)) {
2632	rval = KERN_SUCCESS;
2633	goto finish;
2634	}
2635
2636	kxld_object_get_vmsize(object, &header_size, &size);
2637
2638	kmodsym = kxld_symtab_get_locally_defined_symbol_by_name(object->symtab,
2639	KXLD_KMOD_INFO_SYMBOL);
2640	require_action(kmodsym, finish, rval=KERN_FAILURE;
2641	kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogNoKmodInfo));
2642
2643	kmodsect = kxld_array_get_item(&object->sects, kmodsym->sectnum);
2644
2645	kmod_offset = (u_long) (kmodsym->base_addr - kmodsect->base_addr);
2646	kmod_info = (kmod_info_t ) ((void* *) (kmodsect->data + kmod_offset));
2647
2648	if (kxld_object_is_32_bit(object)) {
2649	kmod_info_32_v1_t kmod = (kmod_info_32_v1_t ) (kmod_info);
2650
2651	if (isOldInterface) {
2652	kmod->address = (uint32_t) object->link_addr;
2653	}
2654	else {
2655	kmod->address = (uint32_t) object->split_info.vmaddr_TEXT;
2656	}
2657
2658	kmod->size = (uint32_t) size;
2659	kmod->hdr_size = (uint32_t) header_size;
2660
2661	#if !KERNEL
2662	if (kxld_object_target_needs_swap(object)) {
2663	kmod->address = OSSwapInt32(kmod->address);
2664	kmod->size = OSSwapInt32(kmod->size);
2665	kmod->hdr_size = OSSwapInt32(kmod->hdr_size);
2666	}
2667	#endif /* !KERNEL */
2668	} else {
2669	kmod_info_64_v1_t kmod = (kmod_info_64_v1_t ) (kmod_info);
2670
2671	if (isOldInterface) {
2672	kmod->address = object->link_addr;
2673	}
2674	else {
2675	kmod->address = object->split_info.vmaddr_TEXT;
2676	}
2677
2678	kmod->size = size;
2679	kmod->hdr_size = header_size;
2680
2681	#if !KERNEL
2682	if (kxld_object_target_needs_swap(object)) {
2683	kmod->address = OSSwapInt64(kmod->address);
2684	kmod->size = OSSwapInt64(kmod->size);
2685	kmod->hdr_size = OSSwapInt64(kmod->hdr_size);
2686	}
2687	#endif /* !KERNEL */
2688
2689	#if SPLIT_KEXTS_DEBUG
2690	{
2691	kxld_log(kKxldLogLinking, kKxldLogErr,
2692	" kmodsect %p kmod_info %p = kmodsect->data %p + kmod_offset %lu <%s>",
2693	(void *) kmodsect,
2694	(void *) kmod_info,
2695	(void *) kmodsect->data,
2696	kmod_offset,
2697	__func__);
2698
2699	kxld_log(kKxldLogLinking, kKxldLogErr,
2700	" kmod_info data: address %p size %llu hdr_size %llu start_addr %p stop_addr %p <%s>",
2701	(void *) kmod->address,
2702	kmod->size,
2703	kmod->hdr_size,
2704	(void *) kmod->start_addr,
2705	(void *) kmod->stop_addr,
2706	__func__);
2707	}
2708	#endif
2709
2710	}
2711
2712	rval = KERN_SUCCESS;
2713
2714	finish:
2715	return rval;
2716	}
2717
2718	#if KXLD_PIC_KEXTS
2719	/*******************************************************************************
2720	*******************************************************************************/
2721	static boolean_t
2722	target_supports_slideable_kexts(const KXLDObject *object)
2723	{
2724	check(object);
2725
2726	return (object->cputype != CPU_TYPE_I386 && object->include_kaslr_relocs);
2727	}
2728	#endif /* KXLD_PIC_KEXTS */
2729

Browse the source code of codebrowser/libkern/kxld/kxld_object.c