Context Navigation

source: trunk/kLdr/kLdrModMachO.c@ 22

Last change on this file since 22 was 22, checked in by bird, 17 years ago
kLdrModMachO.c: Initial 64-bit support (MH_OBJECT).
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 123.1 KB

Line
1	/* $Id: kLdrModMachO.c 22 2009-01-30 06:29:43Z bird $ */
2	/** @file
3	* kLdr - The Module Interpreter for the MACH-O format.
4	*/
5
6	/*
7	* Copyright (c) 2006-2007 knut st. osmundsen <bird-kStuff-spam@anduin.net>
8	*
9	* This file is part of kStuff.
10	*
11	* kStuff is free software; you can redistribute it and/or
12	* modify it under the terms of the GNU Lesser General Public
13	* License as published by the Free Software Foundation; either
14	* version 2.1 of the License, or (at your option) any later version.
15	*
16	* In addition to the permissions in the GNU Lesser General Public
17	* License, you are granted unlimited permission to link the compiled
18	* version of this file into combinations with other programs, and to
19	* distribute those combinations without any restriction coming from
20	* the use of this file.
21	*
22	* kStuff is distributed in the hope that it will be useful,
23	* but WITHOUT ANY WARRANTY; without even the implied warranty of
24	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
25	* Lesser General Public License for more details.
26	*
27	* You should have received a copy of the GNU Lesser General Public
28	* License along with kStuff; if not, write to the Free Software
29	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
30	* 02110-1301, USA
31	*/
32
33	/*******************************************************************************
34	* Header Files *
35	*******************************************************************************/
36	#include <k/kLdr.h>
37	#include "kLdrInternal.h"
38	#include <k/kLdrFmts/mach-o.h>
39
40
41	/*******************************************************************************
42	* Defined Constants And Macros *
43	*******************************************************************************/
44	/** @def KLDRMODMACHO_STRICT
45	* Define KLDRMODMACHO_STRICT to enabled strict checks in KLDRMODMACHO. */
46	#define KLDRMODMACHO_STRICT 1
47
48	/** @def KLDRMODMACHO_ASSERT
49	* Assert that an expression is true when KLDR_STRICT is defined.
50	*/
51	#ifdef KLDRMODMACHO_STRICT
52	# define KLDRMODMACHO_ASSERT(expr) kHlpAssert(expr)
53	#else
54	# define KLDRMODMACHO_ASSERT(expr) do {} while (0)
55	#endif
56
57	/** @def KLDRMODMACHO_CHECK_RETURN
58	* Checks that an expression is true and return if it isn't.
59	* This is a debug aid.
60	*/
61	#ifdef KLDRMODMACHO_STRICT2
62	# define KLDRMODMACHO_CHECK_RETURN(expr, rc) kHlpAssertReturn(expr, rc)
63	#else
64	# define KLDRMODMACHO_CHECK_RETURN(expr, rc) do { if (!(expr)) { return (rc); } } while (0)
65	#endif
66
67
68	/*******************************************************************************
69	* Structures and Typedefs *
70	*******************************************************************************/
71	/**
72	* Mach-O section details.
73	*/
74	typedef struct KLDRMODMACHOSECT
75	{
76	/** The size of the section (in bytes). */
77	KLDRSIZE cb;
78	/** The link address of this section. */
79	KLDRADDR LinkAddress;
80	/** The RVA of this section. */
81	KLDRADDR RVA;
82	/** The file offset of this section.
83	* This is -1 if the section doesn't have a file backing. */
84	KLDRFOFF offFile;
85	/** The number of fixups. */
86	KU32 cFixups;
87	/** The array of fixups. (lazy loaded) */
88	macho_relocation_info_t *paFixups;
89	/** The file offset of the fixups for this section.
90	* This is -1 if the section doesn't have any fixups. */
91	KLDRFOFF offFixups;
92	/** Mach-O section flags. */
93	KU32 fFlags;
94	/** kLdr segment index. */
95	KU32 iSegment;
96	/** Pointer to the Mach-O section structure. */
97	void *pvMachoSection;
98	} KLDRMODMACHOSECT, *PKLDRMODMACHOSECT;
99
100	/**
101	* Extra per-segment info.
102	*
103	* This is corresponds to a kLdr segment, not a Mach-O segment!
104	*/
105	typedef struct KLDRMODMACHOSEG
106	{
107	/** The number of sections in the segment. */
108	KU32 cSections;
109	/** Pointer to the sections belonging to this segment.
110	* The array resides in the big memory chunk allocated for
111	* the module handle, so it doesn't need freeing. */
112	PKLDRMODMACHOSECT paSections;
113
114	} KLDRMODMACHOSEG, *PKLDRMODMACHOSEG;
115
116	/**
117	* Instance data for the Mach-O MH_OBJECT module interpreter.
118	* @todo interpret the other MH_* formats.
119	*/
120	typedef struct KLDRMODMACHO
121	{
122	/** Pointer to the module. (Follows the section table.) */
123	PKLDRMOD pMod;
124	/** Pointer to the RDR file mapping of the raw file bits. NULL if not mapped. */
125	const void *pvBits;
126	/** Pointer to the user mapping. */
127	void *pvMapping;
128
129	/** The link address. */
130	KLDRADDR LinkAddress;
131	/** The size of the mapped image. */
132	KLDRADDR cbImage;
133	/** The RVA of the Global Offset Table. */
134	KLDRADDR GotRVA;
135	/** Whether we're creating a global offset table segment.
136	* This dependes on the cputype and image type. */
137	KBOOL fMakeGot;
138	/** When set the sections in the load command segments must be used when
139	* mapping or loading the image. */
140	KBOOL fMapUsingLoadCommandSections;
141	/** Pointer to the load commands. (endian converted) */
142	KU8 *pbLoadCommands;
143	/** The Mach-O header. (endian converted)
144	* @remark The reserved field is only valid for real 64-bit headers. */
145	mach_header_64_t Hdr;
146
147	/** The offset of the symbol table. */
148	KLDRFOFF offSymbols;
149	/** The number of symbols. */
150	KU32 cSymbols;
151	/** The pointer to the loaded symbol table. */
152	void *pvaSymbols;
153	/** The offset of the string table. */
154	KLDRFOFF offStrings;
155	/** The size of the of the string table. */
156	KU32 cchStrings;
157	/** Pointer to the loaded string table. */
158	char *pchStrings;
159
160	/** The number of sections. */
161	KU32 cSections;
162	/** Pointer to the section array running in parallel to the Mach-O one. */
163	PKLDRMODMACHOSECT paSections;
164
165	/** Array of segments parallel to the one in KLDRMOD. */
166	KLDRMODMACHOSEG aSegments[1];
167	} KLDRMODMACHO, *PKLDRMODMACHO;
168
169
170
171	/*******************************************************************************
172	* Internal Functions *
173	*******************************************************************************/
174	#if 0
175	static KI32 kldrModMachONumberOfImports(PKLDRMOD pMod, const void *pvBits);
176	#endif
177	static int kldrModMachORelocateBits(PKLDRMOD pMod, void *pvBits, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress,
178	PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
179
180	static int kldrModMachODoCreate(PKRDR pRdr, PKLDRMODMACHO *ppMod);
181	static int kldrModMachOPreParseLoadCommands(KU8 pbLoadCommands, const mach_header_32_t pHdr, PKRDR pRdr,
182	KU32 pcSegments, KU32 pcSections, KU32 *pcbStringPool);
183	static int kldrModMachOParseLoadCommands(PKLDRMODMACHO pModMachO, char *pbStringPool, KU32 cbStringPool);
184	static int kldrModMachOAdjustBaseAddress(PKLDRMODMACHO pModMachO, PKLDRADDR pBaseAddress);
185
186	/static int kldrModMachOLoadLoadCommands(PKLDRMODMACHO pModMachO);/
187	static int kldrModMachOLoadObjSymTab(PKLDRMODMACHO pModMachO);
188	static int kldrModMachOLoadFixups(PKLDRMODMACHO pModMachO, KLDRFOFF offFixups, KU32 cFixups, macho_relocation_info_t **ppaFixups);
189	static int kldrModMachOMapVirginBits(PKLDRMODMACHO pModMachO);
190
191	static int kldrModMachODoQuerySymbol32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t paSyms, KU32 cSyms, const char pchStrings,
192	KU32 cchStrings, KLDRADDR BaseAddress, KU32 iSymbol, const char *pchSymbol,
193	KSIZE cchSymbol, PKLDRADDR puValue, KU32 *pfKind);
194	static int kldrModMachODoQuerySymbol64Bit(PKLDRMODMACHO pModMachO, const macho_nlist_64_t paSyms, KU32 cSyms, const char pchStrings,
195	KU32 cchStrings, KLDRADDR BaseAddress, KU32 iSymbol, const char *pchSymbol,
196	KSIZE cchSymbol, PKLDRADDR puValue, KU32 *pfKind);
197	static int kldrModMachODoEnumSymbols32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t *paSyms, KU32 cSyms,
198	const char *pchStrings, KU32 cchStrings, KLDRADDR BaseAddress,
199	KU32 fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser);
200	static int kldrModMachODoEnumSymbols64Bit(PKLDRMODMACHO pModMachO, const macho_nlist_64_t *paSyms, KU32 cSyms,
201	const char *pchStrings, KU32 cchStrings, KLDRADDR BaseAddress,
202	KU32 fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser);
203	static int kldrModMachOObjDoImports(PKLDRMODMACHO pModMachO, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
204	static int kldrModMachOObjDoFixups(PKLDRMODMACHO pModMachO, void *pvMapping, KLDRADDR NewBaseAddress);
205	static int kldrModMachOFixupSectionGeneric32Bit(PKLDRMODMACHO pModMachO, KU8 *pbSectBits, PKLDRMODMACHOSECT pFixupSect,
206	macho_nlist_32_t *paSyms, KU32 cSyms, KLDRADDR NewBaseAddress);
207	static int kldrModMachOFixupSectionAMD64(PKLDRMODMACHO pModMachO, KU8 *pbSectBits, PKLDRMODMACHOSECT pFixupSect,
208	macho_nlist_64_t *paSyms, KU32 cSyms, KLDRADDR NewBaseAddress);
209
210	static int kldrModMachOMakeGOT(PKLDRMODMACHO pModMachO, void *pvBits, KLDRADDR NewBaseAddress);
211
212	/static int kldrModMachODoFixups(PKLDRMODMACHO pModMachO, void pvMapping, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress);
213	static int kldrModMachODoImports(PKLDRMODMACHO pModMachO, void pvMapping, PFNKLDRMODGETIMPORT pfnGetImport, void pvUser);*/
214
215
216	/**
217	* Create a loader module instance interpreting the executable image found
218	* in the specified file provider instance.
219	*
220	* @returns 0 on success and *ppMod pointing to a module instance.
221	* On failure, a non-zero OS specific error code is returned.
222	* @param pOps Pointer to the registered method table.
223	* @param pRdr The file provider instance to use.
224	* @param offNewHdr The offset of the new header in MZ files. -1 if not found.
225	* @param ppMod Where to store the module instance pointer.
226	*/
227	static int kldrModMachOCreate(PCKLDRMODOPS pOps, PKRDR pRdr, KLDRFOFF offNewHdr, PPKLDRMOD ppMod)
228	{
229	PKLDRMODMACHO pModMachO;
230	int rc;
231
232	/*
233	* Create the instance data and do a minimal header validation.
234	*/
235	rc = kldrModMachODoCreate(pRdr, &pModMachO);
236	if (!rc)
237	{
238	pModMachO->pMod->pOps = pOps;
239	pModMachO->pMod->u32Magic = KLDRMOD_MAGIC;
240	*ppMod = pModMachO->pMod;
241	return 0;
242	}
243	if (pModMachO)
244	{
245	kHlpFree(pModMachO->pbLoadCommands);
246	kHlpFree(pModMachO);
247	}
248	return rc;
249	}
250
251
252	/**
253	* Separate function for reading creating the Mach-O module instance to
254	* simplify cleanup on failure.
255	*/
256	static int kldrModMachODoCreate(PKRDR pRdr, PKLDRMODMACHO *ppModMachO)
257	{
258	union
259	{
260	mach_header_32_t Hdr32;
261	mach_header_64_t Hdr64;
262	} s;
263	PKLDRMODMACHO pModMachO;
264	PKLDRMOD pMod;
265	KU8 *pbLoadCommands;
266	KU32 cSegments;
267	KU32 cSections;
268	KU32 cbStringPool;
269	KSIZE cchFilename;
270	KSIZE cb;
271	KBOOL fMakeGot;
272	int rc;
273	*ppModMachO = NULL;
274
275	kHlpAssert(&s.Hdr32.magic == &s.Hdr64.magic);
276	kHlpAssert(&s.Hdr32.flags == &s.Hdr64.flags);
277
278	/*
279	* Read the Mach-O header.
280	*/
281	rc = kRdrRead(pRdr, &s, sizeof(s), 0);
282	if (rc)
283	return rc;
284	if ( s.Hdr32.magic != IMAGE_MACHO32_SIGNATURE
285	&& s.Hdr32.magic != IMAGE_MACHO64_SIGNATURE
286	)
287	{
288	if ( s.Hdr32.magic == IMAGE_MACHO32_SIGNATURE_OE
289	\|\| s.Hdr32.magic == IMAGE_MACHO64_SIGNATURE_OE)
290	return KLDR_ERR_MACHO_OTHER_ENDIAN_NOT_SUPPORTED;
291	return KLDR_ERR_UNKNOWN_FORMAT;
292	}
293
294	/* sanity checks. */
295	if ( s.Hdr32.sizeofcmds > kRdrSize(pRdr) - sizeof(mach_header_32_t)
296	\|\| s.Hdr32.sizeofcmds < sizeof(load_command_t) * s.Hdr32.ncmds
297	\|\| (s.Hdr32.flags & ~MH_VALID_FLAGS))
298	return KLDR_ERR_MACHO_BAD_HEADER;
299	switch (s.Hdr32.cputype)
300	{
301	case CPU_TYPE_X86:
302	fMakeGot = K_FALSE;
303	break;
304	case CPU_TYPE_X86_64:
305	fMakeGot = s.Hdr32.filetype == MH_OBJECT;
306	break;
307	default:
308	return KLDR_ERR_MACHO_UNSUPPORTED_MACHINE;
309	}
310	if (s.Hdr32.filetype != MH_OBJECT)
311	return KLDR_ERR_MACHO_UNSUPPORTED_FILE_TYPE;
312
313	/*
314	* Read and pre-parse the load commands to figure out how many segments we'll be needing.
315	*/
316	pbLoadCommands = kHlpAlloc(s.Hdr32.sizeofcmds);
317	if (!pbLoadCommands)
318	return KERR_NO_MEMORY;
319	rc = kRdrRead(pRdr, pbLoadCommands, s.Hdr32.sizeofcmds,
320	s.Hdr32.magic == IMAGE_MACHO32_SIGNATURE
321	\|\| s.Hdr32.magic == IMAGE_MACHO32_SIGNATURE_OE
322	? sizeof(mach_header_32_t) : sizeof(mach_header_64_t));
323	if (!rc)
324	rc = kldrModMachOPreParseLoadCommands(pbLoadCommands, &s.Hdr32, pRdr, &cSegments, &cSections, &cbStringPool);
325	if (rc)
326	{
327	kHlpFree(pbLoadCommands);
328	return rc;
329	}
330	cSegments += fMakeGot;
331
332
333	/*
334	* Calc the instance size, allocate and initialize it.
335	*/
336	cchFilename = kHlpStrLen(kRdrName(pRdr));
337	cb = K_ALIGN_Z( K_OFFSETOF(KLDRMODMACHO, aSegments[cSegments])
338	+ sizeof(KLDRMODMACHOSECT) * cSections, 16)
339	+ K_OFFSETOF(KLDRMOD, aSegments[cSegments])
340	+ cchFilename + 1
341	+ cbStringPool;
342	pModMachO = (PKLDRMODMACHO)kHlpAlloc(cb);
343	if (!pModMachO)
344	return KERR_NO_MEMORY;
345	*ppModMachO = pModMachO;
346	pModMachO->pbLoadCommands = pbLoadCommands;
347
348	/* KLDRMOD */
349	pMod = (PKLDRMOD)((KU8 *)pModMachO + K_ALIGN_Z( K_OFFSETOF(KLDRMODMACHO, aSegments[cSegments])
350	+ sizeof(KLDRMODMACHOSECT) * cSections, 16));
351	pMod->pvData = pModMachO;
352	pMod->pRdr = pRdr;
353	pMod->pOps = NULL; /* set upon success. */
354	pMod->cSegments = cSegments;
355	pMod->cchFilename = cchFilename;
356	pMod->pszFilename = (char *)&pMod->aSegments[pMod->cSegments];
357	kHlpMemCopy((char *)pMod->pszFilename, kRdrName(pRdr), cchFilename + 1);
358	pMod->pszName = kHlpGetFilename(pMod->pszFilename);
359	pMod->cchName = cchFilename - (pMod->pszName - pMod->pszFilename);
360	switch (s.Hdr32.cputype)
361	{
362	case CPU_TYPE_X86:
363	pMod->enmArch = KCPUARCH_X86_32;
364	pMod->enmEndian = KLDRENDIAN_LITTLE;
365	switch (s.Hdr32.cpusubtype)
366	{
367	case CPU_SUBTYPE_I386_ALL: pMod->enmCpu = KCPU_X86_32_BLEND; break;
368	/case CPU_SUBTYPE_386: ^^ pMod->enmCpu = KCPU_I386; break;/
369	case CPU_SUBTYPE_486: pMod->enmCpu = KCPU_I486; break;
370	case CPU_SUBTYPE_486SX: pMod->enmCpu = KCPU_I486SX; break;
371	/case CPU_SUBTYPE_586: vv /
372	case CPU_SUBTYPE_PENT: pMod->enmCpu = KCPU_I586; break;
373	case CPU_SUBTYPE_PENTPRO:
374	case CPU_SUBTYPE_PENTII_M3:
375	case CPU_SUBTYPE_PENTII_M5:
376	case CPU_SUBTYPE_CELERON:
377	case CPU_SUBTYPE_CELERON_MOBILE:
378	case CPU_SUBTYPE_PENTIUM_3:
379	case CPU_SUBTYPE_PENTIUM_3_M:
380	case CPU_SUBTYPE_PENTIUM_3_XEON: pMod->enmCpu = KCPU_I686; break;
381	case CPU_SUBTYPE_PENTIUM_M:
382	case CPU_SUBTYPE_PENTIUM_4:
383	case CPU_SUBTYPE_PENTIUM_4_M:
384	case CPU_SUBTYPE_XEON:
385	case CPU_SUBTYPE_XEON_MP: pMod->enmCpu = KCPU_P4; break;
386	break;
387	default:
388	return KLDR_ERR_MACHO_UNSUPPORTED_MACHINE;
389	}
390	break;
391
392	case CPU_TYPE_X86_64:
393	pMod->enmArch = KCPUARCH_AMD64;
394	pMod->enmEndian = KLDRENDIAN_LITTLE;
395	switch (s.Hdr32.cpusubtype & ~CPU_SUBTYPE_MASK)
396	{
397	case CPU_SUBTYPE_X86_64_ALL: pMod->enmCpu = KCPU_AMD64_BLEND; break;
398	default:
399	return KLDR_ERR_MACHO_UNSUPPORTED_MACHINE;
400	}
401	break;
402
403	default:
404	return KLDR_ERR_MACHO_UNSUPPORTED_MACHINE;
405	}
406
407	pMod->enmFmt = KLDRFMT_MACHO;
408	switch (s.Hdr32.filetype)
409	{
410	case MH_OBJECT:
411	pMod->enmType = KLDRTYPE_OBJECT;
412	break;
413	default:
414	return KLDR_ERR_MACHO_UNSUPPORTED_FILE_TYPE;
415	}
416	pMod->u32Magic = 0; /* set upon success. */
417
418	/* KLDRMODMACHO */
419	pModMachO->pMod = pMod;
420	pModMachO->pvBits = NULL;
421	pModMachO->pvMapping = NULL;
422	pModMachO->Hdr = s.Hdr64;
423	if ( s.Hdr32.magic == IMAGE_MACHO32_SIGNATURE
424	\|\| s.Hdr32.magic == IMAGE_MACHO32_SIGNATURE_OE)
425	pModMachO->Hdr.reserved = 0;
426	pModMachO->LinkAddress = 0;
427	pModMachO->cbImage = 0;
428	pModMachO->GotRVA = NIL_KLDRADDR;
429	pModMachO->fMakeGot = fMakeGot;
430	pModMachO->fMapUsingLoadCommandSections = K_FALSE;
431	pModMachO->offSymbols = 0;
432	pModMachO->cSymbols = 0;
433	pModMachO->pvaSymbols = NULL;
434	pModMachO->offStrings = 0;
435	pModMachO->cchStrings = 0;
436	pModMachO->pchStrings = NULL;
437	pModMachO->cSections = cSections;
438	pModMachO->paSections = (PKLDRMODMACHOSECT)&pModMachO->aSegments[pModMachO->pMod->cSegments];
439
440	/*
441	* Setup the KLDRMOD segment array.
442	*/
443	rc = kldrModMachOParseLoadCommands(pModMachO, (char *)pMod->pszFilename + pMod->cchFilename + 1, cbStringPool);
444	if (rc)
445	return rc;
446
447	/*
448	* We're done.
449	*/
450	return 0;
451	}
452
453
454	/**
455	* Converts, validates and preparses the load commands before we carve
456	* out the module instance.
457	*
458	* The conversion that's preformed is format endian to host endian.
459	* The preparsing has to do with segment counting, section counting and string pool sizing.
460	*
461	* @returns 0 on success.
462	* @returns KLDR_ERR_MACHO_* on failure.
463	* @param pbLoadCommands The load commands to parse.
464	* @param pHdr The header.
465	* @param pRdr The file reader.
466	* @param pcSegments Where to store the segment count.
467	* @param pcSegments Where to store the section count.
468	* @param pcbStringPool Where to store the string pool size.
469	*/
470	static int kldrModMachOPreParseLoadCommands(KU8 pbLoadCommands, const mach_header_32_t pHdr, PKRDR pRdr,
471	KU32 pcSegments, KU32 pcSections, KU32 *pcbStringPool)
472	{
473	union
474	{
475	KU8 *pb;
476	load_command_t *pLoadCmd;
477	segment_command_32_t *pSeg32;
478	segment_command_64_t *pSeg64;
479	thread_command_t *pThread;
480	symtab_command_t *pSymTab;
481	uuid_command_t *pUuid;
482	} u;
483	const KU64 cbFile = kRdrSize(pRdr);
484	KU32 cSegments = 0;
485	KU32 cSections = 0;
486	KU32 cbStringPool = 0;
487	KU32 cLeft = pHdr->ncmds;
488	KU32 cbLeft = pHdr->sizeofcmds;
489	KU8 *pb = pbLoadCommands;
490	int cSegmentCommands = 0;
491	int cSymbolTabs = 0;
492	int fConvertEndian = pHdr->magic == IMAGE_MACHO32_SIGNATURE_OE
493	\|\| pHdr->magic == IMAGE_MACHO64_SIGNATURE_OE;
494
495	*pcSegments = 0;
496	*pcSections = 0;
497	*pcbStringPool = 0;
498
499	while (cLeft-- > 0)
500	{
501	u.pb = pb;
502
503	/*
504	* Convert and validate command header.
505	*/
506	if (cbLeft < sizeof(load_command_t))
507	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
508	if (fConvertEndian)
509	{
510	u.pLoadCmd->cmd = K_E2E_U32(u.pLoadCmd->cmd);
511	u.pLoadCmd->cmdsize = K_E2E_U32(u.pLoadCmd->cmdsize);
512	}
513	if (u.pLoadCmd->cmdsize > cbLeft)
514	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
515	cbLeft -= u.pLoadCmd->cmdsize;
516	pb += u.pLoadCmd->cmdsize;
517
518	/*
519	* Convert endian if needed, parse and validate the command.
520	*/
521	switch (u.pLoadCmd->cmd)
522	{
523	case LC_SEGMENT_32:
524	{
525	section_32_t *pSect;
526	section_32_t *pFirstSect;
527	KU32 cSectionsLeft;
528
529	/* convert and verify*/
530	if (u.pLoadCmd->cmdsize < sizeof(segment_command_32_t))
531	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
532	if ( pHdr->magic != IMAGE_MACHO32_SIGNATURE_OE
533	&& pHdr->magic != IMAGE_MACHO32_SIGNATURE)
534	return KLDR_ERR_MACHO_BIT_MIX;
535	if (fConvertEndian)
536	{
537	u.pSeg32->vmaddr = K_E2E_U32(u.pSeg32->vmaddr);
538	u.pSeg32->vmsize = K_E2E_U32(u.pSeg32->vmsize);
539	u.pSeg32->fileoff = K_E2E_U32(u.pSeg32->fileoff);
540	u.pSeg32->filesize = K_E2E_U32(u.pSeg32->filesize);
541	u.pSeg32->maxprot = K_E2E_U32(u.pSeg32->maxprot);
542	u.pSeg32->initprot = K_E2E_U32(u.pSeg32->initprot);
543	u.pSeg32->nsects = K_E2E_U32(u.pSeg32->nsects);
544	u.pSeg32->flags = K_E2E_U32(u.pSeg32->flags);
545	}
546
547	if ( u.pSeg32->filesize
548	&& ( u.pSeg32->fileoff > cbFile
549	\|\| (KU64)u.pSeg32->fileoff + u.pSeg32->filesize > cbFile))
550	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
551	if (!u.pSeg32->filesize && u.pSeg32->fileoff)
552	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
553	if (u.pSeg32->vmsize < u.pSeg32->filesize)
554	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
555	if ((u.pSeg32->maxprot & u.pSeg32->initprot) != u.pSeg32->initprot)
556	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
557	if (u.pSeg32->flags & ~(SG_HIGHVM \| SG_FVMLIB \| SG_NORELOC \| SG_PROTECTED_VERSION_1))
558	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
559	if (u.pSeg32->nsects * sizeof(section_32_t) > u.pLoadCmd->cmdsize - sizeof(segment_command_32_t))
560	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
561	if ( pHdr->filetype == MH_OBJECT
562	&& cSegmentCommands > 0)
563	return KLDR_ERR_MACHO_BAD_OBJECT_FILE;
564	cSegmentCommands++;
565
566	/*
567	* convert, validate and parse the sections.
568	*/
569	cSectionsLeft = u.pSeg32->nsects;
570	pFirstSect = pSect = (section_32_t *)(u.pSeg32 + 1);
571	while (cSectionsLeft-- > 0)
572	{
573	int fFileBits;
574
575	if (fConvertEndian)
576	{
577	pSect->addr = K_E2E_U32(pSect->addr);
578	pSect->size = K_E2E_U32(pSect->size);
579	pSect->offset = K_E2E_U32(pSect->offset);
580	pSect->align = K_E2E_U32(pSect->align);
581	pSect->reloff = K_E2E_U32(pSect->reloff);
582	pSect->nreloc = K_E2E_U32(pSect->nreloc);
583	pSect->flags = K_E2E_U32(pSect->flags);
584	pSect->reserved1 = K_E2E_U32(pSect->reserved1);
585	pSect->reserved2 = K_E2E_U32(pSect->reserved2);
586	}
587
588	/* validate */
589	switch (pSect->flags & SECTION_TYPE)
590	{
591	case S_ZEROFILL:
592	if (pSect->reserved1 \|\| pSect->reserved2)
593	return KLDR_ERR_MACHO_BAD_SECTION;
594	fFileBits = 0;
595	break;
596	case S_REGULAR:
597	case S_CSTRING_LITERALS:
598	case S_COALESCED:
599	case S_4BYTE_LITERALS:
600	case S_8BYTE_LITERALS:
601	case S_16BYTE_LITERALS:
602	if (pSect->reserved1 \|\| pSect->reserved2)
603	return KLDR_ERR_MACHO_BAD_SECTION;
604	fFileBits = 1;
605	break;
606
607	case S_LITERAL_POINTERS:
608	case S_INTERPOSING:
609	case S_GB_ZEROFILL:
610	case S_NON_LAZY_SYMBOL_POINTERS:
611	case S_LAZY_SYMBOL_POINTERS:
612	case S_SYMBOL_STUBS:
613	return KLDR_ERR_MACHO_UNSUPPORTED_SECTION;
614	case S_MOD_INIT_FUNC_POINTERS:
615	return KLDR_ERR_MACHO_UNSUPPORTED_INIT_SECTION;
616	case S_MOD_TERM_FUNC_POINTERS:
617	return KLDR_ERR_MACHO_UNSUPPORTED_TERM_SECTION;
618
619	default:
620	return KLDR_ERR_MACHO_UNKNOWN_SECTION;
621	}
622	if (pSect->flags & ~( S_ATTR_PURE_INSTRUCTIONS \| S_ATTR_NO_TOC \| S_ATTR_STRIP_STATIC_SYMS
623	\| S_ATTR_NO_DEAD_STRIP \| S_ATTR_LIVE_SUPPORT \| S_ATTR_SELF_MODIFYING_CODE
624	\| S_ATTR_DEBUG \| S_ATTR_SOME_INSTRUCTIONS \| S_ATTR_EXT_RELOC
625	\| S_ATTR_LOC_RELOC \| SECTION_TYPE))
626	return KLDR_ERR_MACHO_BAD_SECTION;
627	if ( pSect->addr - u.pSeg32->vmaddr > u.pSeg32->vmsize
628	\|\| pSect->addr - u.pSeg32->vmaddr + pSect->size > u.pSeg32->vmsize)
629	return KLDR_ERR_MACHO_BAD_SECTION;
630	if ( pSect->align >= 31
631	\|\| (((1 << pSect->align) - 1) & pSect->addr)
632	\|\| (((1 << pSect->align) - 1) & u.pSeg32->vmaddr))
633	return KLDR_ERR_MACHO_BAD_SECTION;
634	if ( fFileBits
635	&& ( pSect->offset > cbFile
636	\|\| (KU64)pSect->offset + pSect->size > cbFile))
637	return KLDR_ERR_MACHO_BAD_SECTION;
638	if (!fFileBits && pSect->offset)
639	return KLDR_ERR_MACHO_BAD_SECTION;
640	if (!pSect->nreloc && pSect->reloff)
641	return KLDR_ERR_MACHO_BAD_SECTION;
642	if ( pSect->nreloc
643	&& ( pSect->reloff > cbFile
644	\|\| (KU64)pSect->reloff + (KLDRFOFF)pSect->nreloc * sizeof(macho_relocation_info_t)) > cbFile)
645	return KLDR_ERR_MACHO_BAD_SECTION;
646
647
648	/* count segments and strings */
649	switch (pHdr->filetype)
650	{
651	case MH_OBJECT:
652	{
653	cSections++;
654
655	/* Don't load debug symbols. (test this) */
656	if (pSect->flags & S_ATTR_DEBUG)
657	break;
658
659	/* a new segment? */
660	if ( !cSegments
661	\|\| kHlpStrNComp(pSect->segname, (pSect - 1)->segname, sizeof(pSect->segname)))
662	{
663	#if 0 /** @todo This doesn't work because of BSS. */
664	/* verify that the linker/assembler has ordered sections correctly. */
665	section_32_t *pCur = (pSect - 2);
666	while ((KUPTR)pCur >= (KUPTR)pFirstSect)
667	{
668	if (!kHlpStrNComp(pCur->segname, pSect->segname, sizeof(pSect->segname)))
669	return KLDR_ERR_MACHO_BAD_SECTION_ORDER;
670	pCur--;
671	}
672	#endif
673
674	/* ok. count it and the string. */
675	cSegments++;
676	cbStringPool += kHlpStrNLen(&pSect->segname[0], sizeof(pSect->segname)) + 1;
677	}
678	break;
679	}
680
681	default:
682	return KERR_INVALID_PARAMETER;
683	}
684
685	/* next */
686	pSect++;
687	}
688	break;
689	}
690
691	case LC_SEGMENT_64:
692	{
693	section_64_t *pSect;
694	section_64_t *pFirstSect;
695	KU32 cSectionsLeft;
696
697	/* convert and verify*/
698	if (u.pLoadCmd->cmdsize < sizeof(segment_command_64_t))
699	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
700	if ( pHdr->magic != IMAGE_MACHO64_SIGNATURE_OE
701	&& pHdr->magic != IMAGE_MACHO64_SIGNATURE)
702	return KLDR_ERR_MACHO_BIT_MIX;
703	if (fConvertEndian)
704	{
705	u.pSeg64->vmaddr = K_E2E_U64(u.pSeg64->vmaddr);
706	u.pSeg64->vmsize = K_E2E_U64(u.pSeg64->vmsize);
707	u.pSeg64->fileoff = K_E2E_U64(u.pSeg64->fileoff);
708	u.pSeg64->filesize = K_E2E_U64(u.pSeg64->filesize);
709	u.pSeg64->maxprot = K_E2E_U32(u.pSeg64->maxprot);
710	u.pSeg64->initprot = K_E2E_U32(u.pSeg64->initprot);
711	u.pSeg64->nsects = K_E2E_U32(u.pSeg64->nsects);
712	u.pSeg64->flags = K_E2E_U32(u.pSeg64->flags);
713	}
714
715	if ( u.pSeg64->filesize
716	&& ( u.pSeg64->fileoff > cbFile
717	\|\| u.pSeg64->fileoff + u.pSeg64->filesize > cbFile))
718	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
719	if (!u.pSeg64->filesize && u.pSeg64->fileoff)
720	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
721	if (u.pSeg64->vmsize < u.pSeg64->filesize)
722	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
723	if ((u.pSeg64->maxprot & u.pSeg64->initprot) != u.pSeg64->initprot)
724	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
725	if (u.pSeg64->flags & ~(SG_HIGHVM \| SG_FVMLIB \| SG_NORELOC \| SG_PROTECTED_VERSION_1))
726	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
727	if (u.pSeg64->nsects * sizeof(section_64_t) > u.pLoadCmd->cmdsize - sizeof(segment_command_64_t))
728	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
729	if ( pHdr->filetype == MH_OBJECT
730	&& cSegmentCommands > 0)
731	return KLDR_ERR_MACHO_BAD_OBJECT_FILE;
732	cSegmentCommands++;
733
734	/*
735	* convert, validate and parse the sections.
736	*/
737	cSectionsLeft = u.pSeg64->nsects;
738	pFirstSect = pSect = (section_64_t *)(u.pSeg64 + 1);
739	while (cSectionsLeft-- > 0)
740	{
741	int fFileBits;
742
743	if (fConvertEndian)
744	{
745	pSect->addr = K_E2E_U64(pSect->addr);
746	pSect->size = K_E2E_U64(pSect->size);
747	pSect->offset = K_E2E_U32(pSect->offset);
748	pSect->align = K_E2E_U32(pSect->align);
749	pSect->reloff = K_E2E_U32(pSect->reloff);
750	pSect->nreloc = K_E2E_U32(pSect->nreloc);
751	pSect->flags = K_E2E_U32(pSect->flags);
752	pSect->reserved1 = K_E2E_U32(pSect->reserved1);
753	pSect->reserved2 = K_E2E_U32(pSect->reserved2);
754	}
755
756	/* validate */
757	switch (pSect->flags & SECTION_TYPE)
758	{
759	case S_ZEROFILL:
760	if (pSect->reserved1 \|\| pSect->reserved2)
761	return KLDR_ERR_MACHO_BAD_SECTION;
762	fFileBits = 0;
763	break;
764	case S_REGULAR:
765	case S_CSTRING_LITERALS:
766	case S_COALESCED:
767	case S_4BYTE_LITERALS:
768	case S_8BYTE_LITERALS:
769	case S_16BYTE_LITERALS:
770	if (pSect->reserved1 \|\| pSect->reserved2)
771	return KLDR_ERR_MACHO_BAD_SECTION;
772	fFileBits = 1;
773	break;
774
775	case S_LITERAL_POINTERS:
776	case S_INTERPOSING:
777	case S_GB_ZEROFILL:
778	case S_NON_LAZY_SYMBOL_POINTERS:
779	case S_LAZY_SYMBOL_POINTERS:
780	case S_SYMBOL_STUBS:
781	return KLDR_ERR_MACHO_UNSUPPORTED_SECTION;
782	#if 1 /** @todo this requires a query API or flag... */
783	case S_MOD_INIT_FUNC_POINTERS:
784	return KLDR_ERR_MACHO_UNSUPPORTED_INIT_SECTION;
785	case S_MOD_TERM_FUNC_POINTERS:
786	return KLDR_ERR_MACHO_UNSUPPORTED_TERM_SECTION;
787	#else
788	case S_MOD_INIT_FUNC_POINTERS:
789	case S_MOD_TERM_FUNC_POINTERS:
790	fFileBits = 1;
791	break; /* ignored */
792	#endif
793
794	default:
795	return KLDR_ERR_MACHO_UNKNOWN_SECTION;
796	}
797	if (pSect->flags & ~( S_ATTR_PURE_INSTRUCTIONS \| S_ATTR_NO_TOC \| S_ATTR_STRIP_STATIC_SYMS
798	\| S_ATTR_NO_DEAD_STRIP \| S_ATTR_LIVE_SUPPORT \| S_ATTR_SELF_MODIFYING_CODE
799	\| S_ATTR_DEBUG \| S_ATTR_SOME_INSTRUCTIONS \| S_ATTR_EXT_RELOC
800	\| S_ATTR_LOC_RELOC \| SECTION_TYPE))
801	return KLDR_ERR_MACHO_BAD_SECTION;
802	if ( pSect->addr - u.pSeg64->vmaddr > u.pSeg64->vmsize
803	\|\| pSect->addr - u.pSeg64->vmaddr + pSect->size > u.pSeg64->vmsize)
804	return KLDR_ERR_MACHO_BAD_SECTION;
805	if ( pSect->align >= 31
806	\|\| (((1 << pSect->align) - 1) & pSect->addr)
807	\|\| (((1 << pSect->align) - 1) & u.pSeg64->vmaddr))
808	return KLDR_ERR_MACHO_BAD_SECTION;
809	if ( fFileBits
810	&& ( pSect->offset > cbFile
811	\|\| (KU64)pSect->offset + pSect->size > cbFile))
812	return KLDR_ERR_MACHO_BAD_SECTION;
813	if (!fFileBits && pSect->offset)
814	return KLDR_ERR_MACHO_BAD_SECTION;
815	if (!pSect->nreloc && pSect->reloff)
816	return KLDR_ERR_MACHO_BAD_SECTION;
817	if ( pSect->nreloc
818	&& ( pSect->reloff > cbFile
819	\|\| (KU64)pSect->reloff + (KLDRFOFF)pSect->nreloc * sizeof(macho_relocation_info_t)) > cbFile)
820	return KLDR_ERR_MACHO_BAD_SECTION;
821
822
823	/* count segments and strings */
824	switch (pHdr->filetype)
825	{
826	case MH_OBJECT:
827	{
828	cSections++;
829
830	/* Don't load debug symbols. (test this) */
831	if (pSect->flags & S_ATTR_DEBUG)
832	break;
833
834	/* a new segment? */
835	if ( !cSegments
836	\|\| kHlpStrNComp(pSect->segname, (pSect - 1)->segname, sizeof(pSect->segname)))
837	{
838	#if 0 /** @todo This doesn't work because of BSS. */
839	/* verify that the linker/assembler has ordered sections correctly. */
840	section_64_t *pCur = (pSect - 2);
841	while ((KUPTR)pCur >= (KUPTR)pFirstSect)
842	{
843	if (!kHlpStrNComp(pCur->segname, pSect->segname, sizeof(pSect->segname)))
844	return KLDR_ERR_MACHO_BAD_SECTION_ORDER;
845	pCur--;
846	}
847	#endif
848
849	/* ok. count it and the string. */
850	cSegments++;
851	cbStringPool += kHlpStrNLen(&pSect->segname[0], sizeof(pSect->segname)) + 1;
852	}
853	break;
854	}
855
856	default:
857	return KERR_INVALID_PARAMETER;
858	}
859
860	/* next */
861	pSect++;
862	}
863	break;
864	} /* LC_SEGMENT_64 */
865
866
867	case LC_SYMTAB:
868	{
869	KSIZE cbSym;
870	if (fConvertEndian)
871	{
872	u.pSymTab->symoff = K_E2E_U32(u.pSymTab->symoff);
873	u.pSymTab->nsyms = K_E2E_U32(u.pSymTab->nsyms);
874	u.pSymTab->stroff = K_E2E_U32(u.pSymTab->stroff);
875	u.pSymTab->strsize = K_E2E_U32(u.pSymTab->strsize);
876	}
877
878	/* verify */
879	cbSym = pHdr->magic == IMAGE_MACHO32_SIGNATURE
880	\|\| pHdr->magic == IMAGE_MACHO32_SIGNATURE_OE
881	? sizeof(macho_nlist_32_t)
882	: sizeof(macho_nlist_64_t);
883	if ( u.pSymTab->symoff >= cbFile
884	\|\| (KU64)u.pSymTab->symoff + u.pSymTab->nsyms * cbSym > cbFile)
885	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
886	if ( u.pSymTab->stroff >= cbFile
887	\|\| (KU64)u.pSymTab->stroff + u.pSymTab->strsize > cbFile)
888	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
889
890	/* only one string in objects, please. */
891	cSymbolTabs++;
892	if ( pHdr->filetype == MH_OBJECT
893	&& cSymbolTabs != 1)
894	return KLDR_ERR_MACHO_BAD_OBJECT_FILE;
895	break;
896	}
897
898	case LC_DYSYMTAB:
899	/** @todo deal with this! */
900	break;
901
902	case LC_THREAD:
903	case LC_UNIXTHREAD:
904	{
905	KU32 pu32 = (KU32 )(u.pb + sizeof(load_command_t));
906	KU32 cItemsLeft = (u.pThread->cmdsize - sizeof(load_command_t)) / sizeof(KU32);
907	while (cItemsLeft)
908	{
909	/* convert & verify header items ([0] == flavor, [1] == KU32 count). */
910	if (cItemsLeft < 2)
911	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
912	if (fConvertEndian)
913	{
914	pu32[0] = K_E2E_U32(pu32[0]);
915	pu32[1] = K_E2E_U32(pu32[1]);
916	}
917	if (pu32[1] + 2 > cItemsLeft)
918	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
919
920	/* convert & verify according to flavor. */
921	switch (pu32[0])
922	{
923	/** @todo */
924	default:
925	break;
926	}
927
928	/* next */
929	cItemsLeft -= pu32[1] + 2;
930	pu32 += pu32[1] + 2;
931	}
932	break;
933	}
934
935	case LC_UUID:
936	if (u.pUuid->cmdsize != sizeof(uuid_command_t))
937	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
938	/** @todo Check anything here need converting? */
939	break;
940
941	case LC_LOADFVMLIB:
942	case LC_IDFVMLIB:
943	case LC_IDENT:
944	case LC_FVMFILE:
945	case LC_PREPAGE:
946	case LC_LOAD_DYLIB:
947	case LC_ID_DYLIB:
948	case LC_LOAD_DYLINKER:
949	case LC_ID_DYLINKER:
950	case LC_PREBOUND_DYLIB:
951	case LC_ROUTINES:
952	case LC_ROUTINES_64:
953	case LC_SUB_FRAMEWORK:
954	case LC_SUB_UMBRELLA:
955	case LC_SUB_CLIENT:
956	case LC_SUB_LIBRARY:
957	case LC_TWOLEVEL_HINTS:
958	case LC_PREBIND_CKSUM:
959	case LC_LOAD_WEAK_DYLIB:
960	case LC_SYMSEG:
961	return KLDR_ERR_MACHO_UNSUPPORTED_LOAD_COMMAND;
962
963	default:
964	return KLDR_ERR_MACHO_UNKNOWN_LOAD_COMMAND;
965	}
966	}
967
968	/* be strict. */
969	if (cbLeft)
970	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
971
972	switch (pHdr->filetype)
973	{
974	case MH_OBJECT:
975	if (!cSegments)
976	return KLDR_ERR_MACHO_BAD_OBJECT_FILE;
977	break;
978	}
979
980	*pcSegments = cSegments;
981	*pcSections = cSections;
982	*pcbStringPool = cbStringPool;
983
984	return 0;
985	}
986
987
988	/**
989	* Parses the load commands after we've carved out the module instance.
990	*
991	* This fills in the segment table and perhaps some other properties.
992	*
993	* @returns 0 on success.
994	* @returns KLDR_ERR_MACHO_* on failure.
995	* @param pModMachO The module.
996	* @param pbStringPool The string pool
997	* @param cbStringPool The size of the string pool.
998	*/
999	static int kldrModMachOParseLoadCommands(PKLDRMODMACHO pModMachO, char *pbStringPool, KU32 cbStringPool)
1000	{
1001	union
1002	{
1003	const KU8 *pb;
1004	const load_command_t *pLoadCmd;
1005	const segment_command_32_t *pSeg32;
1006	const segment_command_64_t *pSeg64;
1007	const symtab_command_t *pSymTab;
1008	} u;
1009	KU32 cLeft = pModMachO->Hdr.ncmds;
1010	KU32 cbLeft = pModMachO->Hdr.sizeofcmds;
1011	const KU8 *pb = pModMachO->pbLoadCommands;
1012	int fFirstSegment = 1;
1013	PKLDRSEG pSeg = &pModMachO->pMod->aSegments[0];
1014	PKLDRMODMACHOSEG pSegExtra = &pModMachO->aSegments[0];
1015	PKLDRMODMACHOSECT pSectExtra = pModMachO->paSections;
1016	const KU32 cSegments = pModMachO->pMod->cSegments;
1017	KU32 i;
1018
1019	while (cLeft-- > 0)
1020	{
1021	u.pb = pb;
1022	cbLeft -= u.pLoadCmd->cmdsize;
1023	pb += u.pLoadCmd->cmdsize;
1024
1025	/*
1026	* Convert endian if needed, parse and validate the command.
1027	*/
1028	switch (u.pLoadCmd->cmd)
1029	{
1030	case LC_SEGMENT_32:
1031	{
1032	section_32_t *pSect;
1033	section_32_t *pFirstSect;
1034	KU32 cSectionsLeft;
1035
1036	pModMachO->LinkAddress = u.pSeg32->vmaddr;
1037
1038	/*
1039	* convert, validate and parse the sections.
1040	*/
1041	cSectionsLeft = u.pSeg32->nsects;
1042	pFirstSect = pSect = (section_32_t *)(u.pSeg32 + 1);
1043	while (cSectionsLeft-- > 0)
1044	{
1045	switch (pModMachO->Hdr.filetype)
1046	{
1047	case MH_OBJECT:
1048	{
1049	/* Section data extract. */
1050	pSectExtra->cb = pSect->size;
1051	pSectExtra->RVA = pSect->addr;
1052	pSectExtra->LinkAddress = pSect->addr;
1053	pSectExtra->offFile = pSect->offset ? pSect->offset : -1;
1054	pSectExtra->cFixups = pSect->nreloc;
1055	pSectExtra->paFixups = NULL;
1056	pSectExtra->offFixups = pSect->nreloc ? pSect->reloff : -1;
1057	pSectExtra->fFlags = pSect->flags;
1058	pSectExtra->iSegment = pSegExtra - &pModMachO->aSegments[0];
1059	pSectExtra->pvMachoSection = pSect;
1060
1061	/* Don't load debug symbols. (test this!) */
1062	if (pSect->flags & S_ATTR_DEBUG)
1063	{
1064	pSectExtra++;
1065	/** @todo */
1066	break;
1067	}
1068
1069	if ( fFirstSegment
1070	\|\| kHlpStrNComp(pSect->segname, (pSect - 1)->segname, sizeof(pSect->segname)))
1071	{
1072	/* close the previous segment */
1073	if (pSegExtra != &pModMachO->aSegments[0])
1074	pSegExtra[-1].cSections = pSectExtra - pSegExtra[-1].paSections;
1075
1076	/* new segment. */
1077	pSeg->pvUser = NULL;
1078	pSeg->pchName = pbStringPool;
1079	pSeg->cchName = (KU32)kHlpStrNLen(&pSect->segname[0], sizeof(pSect->sectname));
1080	kHlpMemCopy(pbStringPool, &pSect->segname[0], pSeg->cchName);
1081	pbStringPool += pSeg->cchName;
1082	*pbStringPool++ = '\0';
1083	pSeg->SelFlat = 0;
1084	pSeg->Sel16bit = 0;
1085	pSeg->fFlags = 0;
1086	pSeg->enmProt = KPROT_EXECUTE_WRITECOPY; /** @todo fixme! */
1087	pSeg->cb = pSect->size;
1088	pSeg->Alignment = (1 << pSect->align);
1089	pSeg->LinkAddress = pSect->addr;
1090	pSeg->offFile = pSect->offset ? pSect->offset : -1;
1091	pSeg->cbFile = pSect->offset ? pSect->size : -1;
1092	pSeg->RVA = pSect->addr - pModMachO->LinkAddress;
1093	pSeg->cbMapped = 0;
1094	pSeg->MapAddress = 0;
1095
1096	pSegExtra->cSections = 0;
1097	pSegExtra->paSections = pSectExtra;
1098
1099	pSeg++;
1100	pSegExtra++;
1101	fFirstSegment = 0;
1102	}
1103	else
1104	{
1105	/* update exiting segment */
1106	if (pSeg[-1].Alignment < (1 << pSect->align))
1107	pSeg[-1].Alignment = (1 << pSect->align);
1108	if (pSect->addr < pSeg[-1].LinkAddress)
1109	return KLDR_ERR_MACHO_BAD_SECTION; /** @todo move up! */
1110
1111	/* If there are file bits, ensure they are in the current flow.
1112	(yes, we are very very careful here, I know.) */
1113	if ( pSect->offset
1114	&& pSeg[-1].cbFile == pSeg[-1].cb)
1115	{
1116	int fOk = pSeg[-1].offFile + (pSect->addr - pSeg[-1].LinkAddress) == pSect->offset
1117	&& pSect[-1].offset
1118	&& pSeg[-1].offFile + pSeg[-1].cbFile == pSect[-1].offset + pSect[-1].size;
1119	/* more checks? */
1120	if (fOk)
1121	pSeg[-1].cbFile = (KLDRFOFF)(pSect->addr - pSeg[-1].LinkAddress) + pSect->size;
1122	else
1123	{
1124
1125	pSeg[-1].cbFile = pSeg[-1].offFile = -1;
1126	pModMachO->fMapUsingLoadCommandSections = K_TRUE;
1127	}
1128	}
1129	pSeg[-1].cb = pSect->addr - pSeg[-1].LinkAddress + pSect->size;
1130
1131	/** @todo update the protection... */
1132	}
1133	pSectExtra++;
1134	break;
1135	}
1136
1137	default:
1138	return KERR_INVALID_PARAMETER;
1139	}
1140
1141	/* next */
1142	pSect++;
1143	}
1144	break;
1145	}
1146
1147	case LC_SEGMENT_64:
1148	{
1149	section_64_t *pSect;
1150	section_64_t *pFirstSect;
1151	KU32 cSectionsLeft;
1152
1153	pModMachO->LinkAddress = u.pSeg64->vmaddr;
1154
1155	/*
1156	* convert, validate and parse the sections.
1157	*/
1158	cSectionsLeft = u.pSeg64->nsects;
1159	pFirstSect = pSect = (section_64_t *)(u.pSeg64 + 1);
1160	while (cSectionsLeft-- > 0)
1161	{
1162	switch (pModMachO->Hdr.filetype)
1163	{
1164	case MH_OBJECT:
1165	{
1166	/* Section data extract. */
1167	pSectExtra->cb = pSect->size;
1168	pSectExtra->RVA = pSect->addr;
1169	pSectExtra->LinkAddress = pSect->addr;
1170	pSectExtra->offFile = pSect->offset ? pSect->offset : -1;
1171	pSectExtra->cFixups = pSect->nreloc;
1172	pSectExtra->paFixups = NULL;
1173	pSectExtra->offFixups = pSect->nreloc ? pSect->reloff : -1;
1174	pSectExtra->fFlags = pSect->flags;
1175	pSectExtra->iSegment = pSegExtra - &pModMachO->aSegments[0];
1176	pSectExtra->pvMachoSection = pSect;
1177
1178	/* Don't load debug symbols. (test this!) */
1179	if (pSect->flags & S_ATTR_DEBUG)
1180	{
1181	pSectExtra++;
1182	/** @todo */
1183	break;
1184	}
1185
1186	if ( fFirstSegment
1187	\|\| kHlpStrNComp(pSect->segname, (pSect - 1)->segname, sizeof(pSect->segname)))
1188	{
1189	/* close the previous segment */
1190	if (pSegExtra != &pModMachO->aSegments[0])
1191	pSegExtra[-1].cSections = pSectExtra - pSegExtra[-1].paSections;
1192
1193	/* new segment. */
1194	pSeg->pvUser = NULL;
1195	pSeg->pchName = pbStringPool;
1196	pSeg->cchName = (KU32)kHlpStrNLen(&pSect->segname[0], sizeof(pSect->sectname));
1197	kHlpMemCopy(pbStringPool, &pSect->segname[0], pSeg->cchName);
1198	pbStringPool += pSeg->cchName;
1199	*pbStringPool++ = '\0';
1200	pSeg->SelFlat = 0;
1201	pSeg->Sel16bit = 0;
1202	pSeg->fFlags = 0;
1203	pSeg->enmProt = KPROT_EXECUTE_WRITECOPY; /** @todo fixme! */
1204	pSeg->cb = pSect->size;
1205	pSeg->Alignment = (1 << pSect->align);
1206	pSeg->LinkAddress = pSect->addr;
1207	pSeg->offFile = pSect->offset ? pSect->offset : -1;
1208	pSeg->cbFile = pSect->offset ? pSect->size : -1;
1209	pSeg->RVA = pSect->addr - pModMachO->LinkAddress;
1210	pSeg->cbMapped = 0;
1211	pSeg->MapAddress = 0;
1212
1213	pSegExtra->cSections = 0;
1214	pSegExtra->paSections = pSectExtra;
1215
1216	pSeg++;
1217	pSegExtra++;
1218	fFirstSegment = 0;
1219	}
1220	else
1221	{
1222	/* update exiting segment */
1223	if (pSeg[-1].Alignment < (1 << pSect->align))
1224	pSeg[-1].Alignment = (1 << pSect->align);
1225	if (pSect->addr < pSeg[-1].LinkAddress)
1226	return KLDR_ERR_MACHO_BAD_SECTION; /** @todo move up! */
1227
1228	/* If there are file bits, ensure they are in the current flow.
1229	(yes, we are very very careful here, I know.) */
1230	if ( pSect->offset
1231	&& pSeg[-1].cbFile == pSeg[-1].cb)
1232	{
1233	int fOk = pSeg[-1].offFile + (pSect->addr - pSeg[-1].LinkAddress) == pSect->offset
1234	&& pSect[-1].offset
1235	&& pSeg[-1].offFile + pSeg[-1].cbFile == pSect[-1].offset + pSect[-1].size;
1236	/* more checks? */
1237	if (fOk)
1238	pSeg[-1].cbFile = (KLDRFOFF)(pSect->addr - pSeg[-1].LinkAddress) + pSect->size;
1239	else
1240	{
1241
1242	pSeg[-1].cbFile = pSeg[-1].offFile = -1;
1243	pModMachO->fMapUsingLoadCommandSections = K_TRUE;
1244	}
1245	}
1246	pSeg[-1].cb = pSect->addr - pSeg[-1].LinkAddress + pSect->size;
1247
1248	/** @todo update the protection... */
1249	}
1250	pSectExtra++;
1251	break;
1252	}
1253
1254	default:
1255	return KERR_INVALID_PARAMETER;
1256	}
1257
1258	/* next */
1259	pSect++;
1260	}
1261	break;
1262	}
1263
1264	case LC_SYMTAB:
1265	switch (pModMachO->Hdr.filetype)
1266	{
1267	case MH_OBJECT:
1268	pModMachO->offSymbols = u.pSymTab->symoff;
1269	pModMachO->cSymbols = u.pSymTab->nsyms;
1270	pModMachO->offStrings = u.pSymTab->stroff;
1271	pModMachO->cchStrings = u.pSymTab->strsize;
1272	break;
1273	}
1274	break;
1275
1276	default:
1277	break;
1278	} /* command switch */
1279	} /* while more commands */
1280
1281	/*
1282	* Close the last segment (if any).
1283	*/
1284	if (pSegExtra != &pModMachO->aSegments[0])
1285	pSegExtra[-1].cSections = pSectExtra - pSegExtra[-1].paSections;
1286
1287	/*
1288	* Make the GOT segment if necessary.
1289	*/
1290	if (pModMachO->fMakeGot)
1291	{
1292	KSIZE cbPtr = ( pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE
1293	\|\| pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE_OE)
1294	? sizeof(KU32)
1295	: sizeof(KU64);
1296
1297	if (pSeg != &pModMachO->pMod->aSegments[0])
1298	pModMachO->GotRVA = pSeg[-1].RVA + KLDR_ALIGN_ADDR(pSeg[-1].cb, pSeg[-1].Alignment);
1299	else
1300	pModMachO->GotRVA = 0;
1301
1302	pSeg->pvUser = NULL;
1303	pSeg->pchName = "GOT";
1304	pSeg->cchName = 3;
1305	pSeg->SelFlat = 0;
1306	pSeg->Sel16bit = 0;
1307	pSeg->fFlags = 0;
1308	pSeg->enmProt = KPROT_READONLY;
1309	pSeg->cb = cbPtr * pModMachO->cSymbols;
1310	pSeg->Alignment = 64;
1311	pSeg->LinkAddress = pModMachO->LinkAddress + pModMachO->GotRVA;
1312	pSeg->offFile = -1;
1313	pSeg->cbFile = -1;
1314	pSeg->RVA = pModMachO->GotRVA;
1315	pSeg->cbMapped = 0;
1316	pSeg->MapAddress = 0;
1317
1318	pSegExtra->cSections = 0;
1319	pSegExtra->paSections = NULL;
1320	}
1321
1322	/*
1323	* Adjust mapping addresses calculating the image size.
1324	*/
1325	pSeg = &pModMachO->pMod->aSegments[0];
1326	switch (pModMachO->Hdr.filetype)
1327	{
1328	case MH_OBJECT:
1329	{
1330	KLDRADDR cb1;
1331	KSIZE cb2;
1332
1333	for (i = 0; i < cSegments - 1; i++)
1334	{
1335	cb1 = pSeg[i + 1].LinkAddress - pSeg[i].LinkAddress;
1336	cb2 = (KSIZE)cb1;
1337	pSeg[i].cbMapped = cb2 == cb1 ? cb2 : ~(KSIZE)0;
1338	}
1339	cb1 = KLDR_ALIGN_ADDR(pSeg[i].cb, pSeg[i].Alignment);
1340	cb2 = (KSIZE)cb1;
1341	pSeg[i].cbMapped = cb2 == cb1 ? cb2 : ~(KSIZE)0;
1342
1343	pModMachO->cbImage = pSeg[i].RVA + cb1;
1344	break;
1345	}
1346	}
1347
1348
1349	return 0;
1350	}
1351
1352
1353	/** @copydoc KLDRMODOPS::pfnDestroy */
1354	static int kldrModMachODestroy(PKLDRMOD pMod)
1355	{
1356	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
1357	int rc = 0;
1358	KU32 i, j;
1359	KLDRMODMACHO_ASSERT(!pModMachO->pvMapping);
1360
1361	i = pMod->cSegments;
1362	while (i-- > 0)
1363	{
1364	j = pModMachO->aSegments[i].cSections;
1365	while (j-- > 0)
1366	{
1367	kHlpFree(pModMachO->aSegments[i].paSections[j].paFixups);
1368	pModMachO->aSegments[i].paSections[j].paFixups = NULL;
1369	}
1370	}
1371
1372	if (pMod->pRdr)
1373	{
1374	rc = kRdrClose(pMod->pRdr);
1375	pMod->pRdr = NULL;
1376	}
1377	pMod->u32Magic = 0;
1378	pMod->pOps = NULL;
1379	kHlpFree(pModMachO->pbLoadCommands);
1380	pModMachO->pbLoadCommands = NULL;
1381	kHlpFree(pModMachO->pchStrings);
1382	pModMachO->pchStrings = NULL;
1383	kHlpFree(pModMachO->pvaSymbols);
1384	pModMachO->pvaSymbols = NULL;
1385	kHlpFree(pModMachO);
1386	return rc;
1387	}
1388
1389
1390	/**
1391	* Gets the right base address.
1392	*
1393	* @returns 0 on success.
1394	* @returns A non-zero status code if the BaseAddress isn't right.
1395	* @param pModMachO The interpreter module instance
1396	* @param pBaseAddress The base address, IN & OUT. Optional.
1397	*/
1398	static int kldrModMachOAdjustBaseAddress(PKLDRMODMACHO pModMachO, PKLDRADDR pBaseAddress)
1399	{
1400	/*
1401	* Adjust the base address.
1402	*/
1403	if (*pBaseAddress == KLDRMOD_BASEADDRESS_MAP)
1404	*pBaseAddress = pModMachO->pMod->aSegments[0].MapAddress;
1405	else if (*pBaseAddress == KLDRMOD_BASEADDRESS_LINK)
1406	*pBaseAddress = pModMachO->LinkAddress;
1407
1408	return 0;
1409	}
1410
1411
1412
1413	/** @copydoc kLdrModQuerySymbol */
1414	static int kldrModMachOQuerySymbol(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, KU32 iSymbol,
1415	const char pchSymbol, KSIZE cchSymbol, const char pszVersion,
1416	PFNKLDRMODGETIMPORT pfnGetForwarder, void pvUser, PKLDRADDR puValue, KU32 pfKind)
1417	{
1418	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
1419	int rc;
1420
1421	/*
1422	* Resolve defaults.
1423	*/
1424	rc = kldrModMachOAdjustBaseAddress(pModMachO, &BaseAddress);
1425	if (rc)
1426	return rc;
1427
1428	/*
1429	* Refuse segmented requests for now.
1430	*/
1431	KLDRMODMACHO_CHECK_RETURN( !pfKind
1432	\|\| (*pfKind & KLDRSYMKIND_REQ_TYPE_MASK) == KLDRSYMKIND_REQ_FLAT,
1433	KLDR_ERR_TODO);
1434
1435	/*
1436	* Take action according to file type.
1437	*/
1438	if (pModMachO->Hdr.filetype == MH_OBJECT)
1439	{
1440	rc = kldrModMachOLoadObjSymTab(pModMachO);
1441	if (!rc)
1442	{
1443	if ( pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE
1444	\|\| pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE_OE)
1445	rc = kldrModMachODoQuerySymbol32Bit(pModMachO, (macho_nlist_32_t *)pModMachO->pvaSymbols, pModMachO->cSymbols,
1446	pModMachO->pchStrings, pModMachO->cchStrings, BaseAddress, iSymbol, pchSymbol,
1447	cchSymbol, puValue, pfKind);
1448	else
1449	rc = kldrModMachODoQuerySymbol64Bit(pModMachO, (macho_nlist_64_t *)pModMachO->pvaSymbols, pModMachO->cSymbols,
1450	pModMachO->pchStrings, pModMachO->cchStrings, BaseAddress, iSymbol, pchSymbol,
1451	cchSymbol, puValue, pfKind);
1452	}
1453	}
1454	else
1455	rc = KLDR_ERR_TODO;
1456
1457	return rc;
1458	}
1459
1460
1461	/**
1462	* Lookup a symbol in a 32-bit symbol table.
1463	*
1464	* @returns See kLdrModQuerySymbol.
1465	* @param pModMachO
1466	* @param paSyms Pointer to the symbol table.
1467	* @param cSyms Number of symbols in the table.
1468	* @param pchStrings Pointer to the string table.
1469	* @param cchStrings Size of the string table.
1470	* @param BaseAddress Adjusted base address, see kLdrModQuerySymbol.
1471	* @param iSymbol See kLdrModQuerySymbol.
1472	* @param pchSymbol See kLdrModQuerySymbol.
1473	* @param cchSymbol See kLdrModQuerySymbol.
1474	* @param puValue See kLdrModQuerySymbol.
1475	* @param pfKind See kLdrModQuerySymbol.
1476	*/
1477	static int kldrModMachODoQuerySymbol32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t paSyms, KU32 cSyms, const char pchStrings,
1478	KU32 cchStrings, KLDRADDR BaseAddress, KU32 iSymbol, const char *pchSymbol, KSIZE cchSymbol,
1479	PKLDRADDR puValue, KU32 *pfKind)
1480	{
1481	/*
1482	* Find a valid symbol matching the search criteria.
1483	*/
1484	if (iSymbol == NIL_KLDRMOD_SYM_ORDINAL)
1485	{
1486	/* simplify validation. */
1487	if (cchStrings <= cchSymbol)
1488	return KLDR_ERR_SYMBOL_NOT_FOUND;
1489	cchStrings -= cchSymbol;
1490
1491	/* external symbols are usually at the end, so search the other way. */
1492	for (iSymbol = cSyms - 1; iSymbol != KU32_MAX; iSymbol--)
1493	{
1494	const char *psz;
1495
1496	/* Skip irrellevant and non-public symbols. */
1497	if (paSyms[iSymbol].n_type & MACHO_N_STAB)
1498	continue;
1499	if ((paSyms[iSymbol].n_type & MACHO_N_TYPE) == MACHO_N_UNDF)
1500	continue;
1501	if (!(paSyms[iSymbol].n_type & MACHO_N_EXT)) /??/
1502	continue;
1503	if (paSyms[iSymbol].n_type & MACHO_N_PEXT) /??/
1504	continue;
1505
1506	/* get name */
1507	if (!paSyms[iSymbol].n_un.n_strx)
1508	continue;
1509	if ((KU32)paSyms[iSymbol].n_un.n_strx >= cchStrings)
1510	continue;
1511	psz = &pchStrings[paSyms[iSymbol].n_un.n_strx];
1512	if (psz[cchSymbol])
1513	continue;
1514	if (kHlpMemComp(psz, pchSymbol, cchSymbol))
1515	continue;
1516
1517	/* match! */
1518	break;
1519	}
1520	if (iSymbol == KU32_MAX)
1521	return KLDR_ERR_SYMBOL_NOT_FOUND;
1522	}
1523	else
1524	{
1525	if (iSymbol >= cSyms)
1526	return KLDR_ERR_SYMBOL_NOT_FOUND;
1527	if (paSyms[iSymbol].n_type & MACHO_N_STAB)
1528	return KLDR_ERR_SYMBOL_NOT_FOUND;
1529	if ((paSyms[iSymbol].n_type & MACHO_N_TYPE) == MACHO_N_UNDF)
1530	return KLDR_ERR_SYMBOL_NOT_FOUND;
1531	}
1532
1533	/*
1534	* Calc the return values.
1535	*/
1536	if (pfKind)
1537	{
1538	if ( pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE
1539	\|\| pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE_OE)
1540	*pfKind = KLDRSYMKIND_32BIT \| KLDRSYMKIND_NO_TYPE;
1541	else
1542	*pfKind = KLDRSYMKIND_64BIT \| KLDRSYMKIND_NO_TYPE;
1543	if (paSyms[iSymbol].n_desc & N_WEAK_DEF)
1544	*pfKind \|= KLDRSYMKIND_WEAK;
1545	}
1546
1547	switch (paSyms[iSymbol].n_type & MACHO_N_TYPE)
1548	{
1549	case MACHO_N_SECT:
1550	{
1551	PKLDRMODMACHOSECT pSect;
1552	KLDRADDR RVA;
1553	if ((KU32)(paSyms[iSymbol].n_sect - 1) >= pModMachO->cSections)
1554	return KLDR_ERR_MACHO_BAD_SYMBOL;
1555	pSect = &pModMachO->paSections[paSyms[iSymbol].n_sect - 1];
1556
1557	RVA = paSyms[iSymbol].n_value - pModMachO->LinkAddress;
1558	if (RVA - pSect->RVA >= pSect->cb)
1559	return KLDR_ERR_MACHO_BAD_SYMBOL;
1560	if (puValue)
1561	*puValue = RVA + BaseAddress;
1562
1563	if ( pfKind
1564	&& (pSect->fFlags & (S_ATTR_PURE_INSTRUCTIONS \| S_ATTR_SELF_MODIFYING_CODE)))
1565	pfKind = (pfKind & ~KLDRSYMKIND_TYPE_MASK) \| KLDRSYMKIND_CODE;
1566	break;
1567	}
1568
1569	case MACHO_N_ABS:
1570	if (puValue)
1571	*puValue = paSyms[iSymbol].n_value;
1572	/*if (pfKind)
1573	pfKind \|= KLDRSYMKIND_ABS;*/
1574	break;
1575
1576	case MACHO_N_PBUD:
1577	case MACHO_N_INDR:
1578	/** @todo implement indirect and prebound symbols. */
1579	default:
1580	KLDRMODMACHO_CHECK_RETURN(0, KLDR_ERR_TODO);
1581	}
1582
1583	return 0;
1584	}
1585
1586
1587	/**
1588	* Lookup a symbol in a 64-bit symbol table.
1589	*
1590	* @returns See kLdrModQuerySymbol.
1591	* @param pModMachO
1592	* @param paSyms Pointer to the symbol table.
1593	* @param cSyms Number of symbols in the table.
1594	* @param pchStrings Pointer to the string table.
1595	* @param cchStrings Size of the string table.
1596	* @param BaseAddress Adjusted base address, see kLdrModQuerySymbol.
1597	* @param iSymbol See kLdrModQuerySymbol.
1598	* @param pchSymbol See kLdrModQuerySymbol.
1599	* @param cchSymbol See kLdrModQuerySymbol.
1600	* @param puValue See kLdrModQuerySymbol.
1601	* @param pfKind See kLdrModQuerySymbol.
1602	*/
1603	static int kldrModMachODoQuerySymbol64Bit(PKLDRMODMACHO pModMachO, const macho_nlist_64_t paSyms, KU32 cSyms, const char pchStrings,
1604	KU32 cchStrings, KLDRADDR BaseAddress, KU32 iSymbol, const char *pchSymbol, KSIZE cchSymbol,
1605	PKLDRADDR puValue, KU32 *pfKind)
1606	{
1607	/*
1608	* Find a valid symbol matching the search criteria.
1609	*/
1610	if (iSymbol == NIL_KLDRMOD_SYM_ORDINAL)
1611	{
1612	/* simplify validation. */
1613	if (cchStrings <= cchSymbol)
1614	return KLDR_ERR_SYMBOL_NOT_FOUND;
1615	cchStrings -= cchSymbol;
1616
1617	/* external symbols are usually at the end, so search the other way. */
1618	for (iSymbol = cSyms - 1; iSymbol != KU32_MAX; iSymbol--)
1619	{
1620	const char *psz;
1621
1622	/* Skip irrellevant and non-public symbols. */
1623	if (paSyms[iSymbol].n_type & MACHO_N_STAB)
1624	continue;
1625	if ((paSyms[iSymbol].n_type & MACHO_N_TYPE) == MACHO_N_UNDF)
1626	continue;
1627	if (!(paSyms[iSymbol].n_type & MACHO_N_EXT)) /??/
1628	continue;
1629	if (paSyms[iSymbol].n_type & MACHO_N_PEXT) /??/
1630	continue;
1631
1632	/* get name */
1633	if (!paSyms[iSymbol].n_un.n_strx)
1634	continue;
1635	if ((KU32)paSyms[iSymbol].n_un.n_strx >= cchStrings)
1636	continue;
1637	psz = &pchStrings[paSyms[iSymbol].n_un.n_strx];
1638	if (psz[cchSymbol])
1639	continue;
1640	if (kHlpMemComp(psz, pchSymbol, cchSymbol))
1641	continue;
1642
1643	/* match! */
1644	break;
1645	}
1646	if (iSymbol == KU32_MAX)
1647	return KLDR_ERR_SYMBOL_NOT_FOUND;
1648	}
1649	else
1650	{
1651	if (iSymbol >= cSyms)
1652	return KLDR_ERR_SYMBOL_NOT_FOUND;
1653	if (paSyms[iSymbol].n_type & MACHO_N_STAB)
1654	return KLDR_ERR_SYMBOL_NOT_FOUND;
1655	if ((paSyms[iSymbol].n_type & MACHO_N_TYPE) == MACHO_N_UNDF)
1656	return KLDR_ERR_SYMBOL_NOT_FOUND;
1657	}
1658
1659	/*
1660	* Calc the return values.
1661	*/
1662	if (pfKind)
1663	{
1664	if ( pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE
1665	\|\| pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE_OE)
1666	*pfKind = KLDRSYMKIND_32BIT \| KLDRSYMKIND_NO_TYPE;
1667	else
1668	*pfKind = KLDRSYMKIND_64BIT \| KLDRSYMKIND_NO_TYPE;
1669	if (paSyms[iSymbol].n_desc & N_WEAK_DEF)
1670	*pfKind \|= KLDRSYMKIND_WEAK;
1671	}
1672
1673	switch (paSyms[iSymbol].n_type & MACHO_N_TYPE)
1674	{
1675	case MACHO_N_SECT:
1676	{
1677	PKLDRMODMACHOSECT pSect;
1678	KLDRADDR RVA;
1679	if ((KU32)(paSyms[iSymbol].n_sect - 1) >= pModMachO->cSections)
1680	return KLDR_ERR_MACHO_BAD_SYMBOL;
1681	pSect = &pModMachO->paSections[paSyms[iSymbol].n_sect - 1];
1682
1683	RVA = paSyms[iSymbol].n_value - pModMachO->LinkAddress;
1684	if (RVA - pSect->RVA >= pSect->cb)
1685	return KLDR_ERR_MACHO_BAD_SYMBOL;
1686	if (puValue)
1687	*puValue = RVA + BaseAddress;
1688
1689	if ( pfKind
1690	&& (pSect->fFlags & (S_ATTR_PURE_INSTRUCTIONS \| S_ATTR_SELF_MODIFYING_CODE)))
1691	pfKind = (pfKind & ~KLDRSYMKIND_TYPE_MASK) \| KLDRSYMKIND_CODE;
1692	break;
1693	}
1694
1695	case MACHO_N_ABS:
1696	if (puValue)
1697	*puValue = paSyms[iSymbol].n_value;
1698	/*if (pfKind)
1699	pfKind \|= KLDRSYMKIND_ABS;*/
1700	break;
1701
1702	case MACHO_N_PBUD:
1703	case MACHO_N_INDR:
1704	/** @todo implement indirect and prebound symbols. */
1705	default:
1706	KLDRMODMACHO_CHECK_RETURN(0, KLDR_ERR_TODO);
1707	}
1708
1709	return 0;
1710	}
1711
1712
1713	/** @copydoc kLdrModEnumSymbols */
1714	static int kldrModMachOEnumSymbols(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress,
1715	KU32 fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
1716	{
1717	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
1718	int rc;
1719
1720	/*
1721	* Resolve defaults.
1722	*/
1723	rc = kldrModMachOAdjustBaseAddress(pModMachO, &BaseAddress);
1724	if (rc)
1725	return rc;
1726
1727	/*
1728	* Take action according to file type.
1729	*/
1730	if (pModMachO->Hdr.filetype == MH_OBJECT)
1731	{
1732	rc = kldrModMachOLoadObjSymTab(pModMachO);
1733	if (!rc)
1734	{
1735	if ( pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE
1736	\|\| pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE_OE)
1737	rc = kldrModMachODoEnumSymbols32Bit(pModMachO, (macho_nlist_32_t *)pModMachO->pvaSymbols, pModMachO->cSymbols,
1738	pModMachO->pchStrings, pModMachO->cchStrings, BaseAddress,
1739	fFlags, pfnCallback, pvUser);
1740	else
1741	rc = kldrModMachODoEnumSymbols64Bit(pModMachO, (macho_nlist_64_t *)pModMachO->pvaSymbols, pModMachO->cSymbols,
1742	pModMachO->pchStrings, pModMachO->cchStrings, BaseAddress,
1743	fFlags, pfnCallback, pvUser);
1744	}
1745	}
1746	else
1747	KLDRMODMACHO_CHECK_RETURN(0, KLDR_ERR_TODO);
1748
1749	return rc;
1750	}
1751
1752
1753	/**
1754	* Enum a 32-bit symbol table.
1755	*
1756	* @returns See kLdrModQuerySymbol.
1757	* @param pModMachO
1758	* @param paSyms Pointer to the symbol table.
1759	* @param cSyms Number of symbols in the table.
1760	* @param pchStrings Pointer to the string table.
1761	* @param cchStrings Size of the string table.
1762	* @param BaseAddress Adjusted base address, see kLdrModEnumSymbols.
1763	* @param fFlags See kLdrModEnumSymbols.
1764	* @param pfnCallback See kLdrModEnumSymbols.
1765	* @param pvUser See kLdrModEnumSymbols.
1766	*/
1767	static int kldrModMachODoEnumSymbols32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t *paSyms, KU32 cSyms,
1768	const char *pchStrings, KU32 cchStrings, KLDRADDR BaseAddress,
1769	KU32 fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
1770	{
1771	const KU32 fKindBase = pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE
1772	\|\| pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE_OE
1773	? KLDRSYMKIND_32BIT : KLDRSYMKIND_64BIT;
1774	KU32 iSym;
1775	int rc;
1776
1777	/*
1778	* Iterate the symbol table.
1779	*/
1780	for (iSym = 0; iSym < cSyms; iSym++)
1781	{
1782	KU32 fKind;
1783	KLDRADDR uValue;
1784	const char *psz;
1785	KSIZE cch;
1786
1787	/* Skip debug symbols and undefined symbols. */
1788	if (paSyms[iSym].n_type & MACHO_N_STAB)
1789	continue;
1790	if ((paSyms[iSym].n_type & MACHO_N_TYPE) == MACHO_N_UNDF)
1791	continue;
1792
1793	/* Skip non-public symbols unless they are requested explicitly. */
1794	if (!(fFlags & KLDRMOD_ENUM_SYMS_FLAGS_ALL))
1795	{
1796	if (!(paSyms[iSym].n_type & MACHO_N_EXT)) /??/
1797	continue;
1798	if (paSyms[iSym].n_type & MACHO_N_PEXT) /??/
1799	continue;
1800	if (!paSyms[iSym].n_un.n_strx)
1801	continue;
1802	}
1803
1804	/*
1805	* Gather symbol info
1806	*/
1807
1808	/* name */
1809	if ((KU32)paSyms[iSym].n_un.n_strx >= cchStrings)
1810	return KLDR_ERR_MACHO_BAD_SYMBOL;
1811	psz = &pchStrings[paSyms[iSym].n_un.n_strx];
1812	cch = kHlpStrLen(psz);
1813	if (!cch)
1814	psz = NULL;
1815
1816	/* kind & value */
1817	fKind = fKindBase;
1818	if (paSyms[iSym].n_desc & N_WEAK_DEF)
1819	fKind \|= KLDRSYMKIND_WEAK;
1820	switch (paSyms[iSym].n_type & MACHO_N_TYPE)
1821	{
1822	case MACHO_N_SECT:
1823	{
1824	PKLDRMODMACHOSECT pSect;
1825	if ((KU32)(paSyms[iSym].n_sect - 1) >= pModMachO->cSections)
1826	return KLDR_ERR_MACHO_BAD_SYMBOL;
1827	pSect = &pModMachO->paSections[paSyms[iSym].n_sect - 1];
1828
1829	uValue = paSyms[iSym].n_value - pModMachO->LinkAddress;
1830	if (uValue - pSect->RVA >= pSect->cb)
1831	return KLDR_ERR_MACHO_BAD_SYMBOL;
1832	uValue += BaseAddress;
1833
1834	if (pSect->fFlags & (S_ATTR_PURE_INSTRUCTIONS \| S_ATTR_SELF_MODIFYING_CODE))
1835	fKind \|= KLDRSYMKIND_CODE;
1836	else
1837	fKind \|= KLDRSYMKIND_NO_TYPE;
1838	break;
1839	}
1840
1841	case MACHO_N_ABS:
1842	uValue = paSyms[iSym].n_value;
1843	fKind \|= KLDRSYMKIND_NO_TYPE /KLDRSYMKIND_ABS/;
1844	break;
1845
1846	case MACHO_N_PBUD:
1847	case MACHO_N_INDR:
1848	/** @todo implement indirect and prebound symbols. */
1849	default:
1850	KLDRMODMACHO_CHECK_RETURN(0, KLDR_ERR_TODO);
1851	}
1852
1853	/*
1854	* Do callback.
1855	*/
1856	rc = pfnCallback(pModMachO->pMod, iSym, psz, cch, NULL, uValue, fKind, pvUser);
1857	if (rc)
1858	return rc;
1859	}
1860	return 0;
1861	}
1862
1863
1864	/**
1865	* Enum a 64-bit symbol table.
1866	*
1867	* @returns See kLdrModQuerySymbol.
1868	* @param pModMachO
1869	* @param paSyms Pointer to the symbol table.
1870	* @param cSyms Number of symbols in the table.
1871	* @param pchStrings Pointer to the string table.
1872	* @param cchStrings Size of the string table.
1873	* @param BaseAddress Adjusted base address, see kLdrModEnumSymbols.
1874	* @param fFlags See kLdrModEnumSymbols.
1875	* @param pfnCallback See kLdrModEnumSymbols.
1876	* @param pvUser See kLdrModEnumSymbols.
1877	*/
1878	static int kldrModMachODoEnumSymbols64Bit(PKLDRMODMACHO pModMachO, const macho_nlist_64_t *paSyms, KU32 cSyms,
1879	const char *pchStrings, KU32 cchStrings, KLDRADDR BaseAddress,
1880	KU32 fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
1881	{
1882	const KU32 fKindBase = pModMachO->Hdr.magic == IMAGE_MACHO64_SIGNATURE
1883	\|\| pModMachO->Hdr.magic == IMAGE_MACHO64_SIGNATURE_OE
1884	? KLDRSYMKIND_64BIT : KLDRSYMKIND_32BIT;
1885	KU32 iSym;
1886	int rc;
1887
1888	/*
1889	* Iterate the symbol table.
1890	*/
1891	for (iSym = 0; iSym < cSyms; iSym++)
1892	{
1893	KU32 fKind;
1894	KLDRADDR uValue;
1895	const char *psz;
1896	KSIZE cch;
1897
1898	/* Skip debug symbols and undefined symbols. */
1899	if (paSyms[iSym].n_type & MACHO_N_STAB)
1900	continue;
1901	if ((paSyms[iSym].n_type & MACHO_N_TYPE) == MACHO_N_UNDF)
1902	continue;
1903
1904	/* Skip non-public symbols unless they are requested explicitly. */
1905	if (!(fFlags & KLDRMOD_ENUM_SYMS_FLAGS_ALL))
1906	{
1907	if (!(paSyms[iSym].n_type & MACHO_N_EXT)) /??/
1908	continue;
1909	if (paSyms[iSym].n_type & MACHO_N_PEXT) /??/
1910	continue;
1911	if (!paSyms[iSym].n_un.n_strx)
1912	continue;
1913	}
1914
1915	/*
1916	* Gather symbol info
1917	*/
1918
1919	/* name */
1920	if ((KU32)paSyms[iSym].n_un.n_strx >= cchStrings)
1921	return KLDR_ERR_MACHO_BAD_SYMBOL;
1922	psz = &pchStrings[paSyms[iSym].n_un.n_strx];
1923	cch = kHlpStrLen(psz);
1924	if (!cch)
1925	psz = NULL;
1926
1927	/* kind & value */
1928	fKind = fKindBase;
1929	if (paSyms[iSym].n_desc & N_WEAK_DEF)
1930	fKind \|= KLDRSYMKIND_WEAK;
1931	switch (paSyms[iSym].n_type & MACHO_N_TYPE)
1932	{
1933	case MACHO_N_SECT:
1934	{
1935	PKLDRMODMACHOSECT pSect;
1936	if ((KU32)(paSyms[iSym].n_sect - 1) >= pModMachO->cSections)
1937	return KLDR_ERR_MACHO_BAD_SYMBOL;
1938	pSect = &pModMachO->paSections[paSyms[iSym].n_sect - 1];
1939
1940	uValue = paSyms[iSym].n_value - pModMachO->LinkAddress;
1941	if (uValue - pSect->RVA >= pSect->cb)
1942	return KLDR_ERR_MACHO_BAD_SYMBOL;
1943	uValue += BaseAddress;
1944
1945	if (pSect->fFlags & (S_ATTR_PURE_INSTRUCTIONS \| S_ATTR_SELF_MODIFYING_CODE))
1946	fKind \|= KLDRSYMKIND_CODE;
1947	else
1948	fKind \|= KLDRSYMKIND_NO_TYPE;
1949	break;
1950	}
1951
1952	case MACHO_N_ABS:
1953	uValue = paSyms[iSym].n_value;
1954	fKind \|= KLDRSYMKIND_NO_TYPE /KLDRSYMKIND_ABS/;
1955	break;
1956
1957	case MACHO_N_PBUD:
1958	case MACHO_N_INDR:
1959	/** @todo implement indirect and prebound symbols. */
1960	default:
1961	KLDRMODMACHO_CHECK_RETURN(0, KLDR_ERR_TODO);
1962	}
1963
1964	/*
1965	* Do callback.
1966	*/
1967	rc = pfnCallback(pModMachO->pMod, iSym, psz, cch, NULL, uValue, fKind, pvUser);
1968	if (rc)
1969	return rc;
1970	}
1971	return 0;
1972	}
1973
1974
1975	/** @copydoc kLdrModGetImport */
1976	static int kldrModMachOGetImport(PKLDRMOD pMod, const void pvBits, KU32 iImport, char pszName, KSIZE cchName)
1977	{
1978	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
1979	if (pModMachO->Hdr.filetype == MH_OBJECT)
1980	return KLDR_ERR_IMPORT_ORDINAL_OUT_OF_BOUNDS;
1981
1982	/* later */
1983	return KLDR_ERR_IMPORT_ORDINAL_OUT_OF_BOUNDS;
1984	}
1985
1986
1987	/** @copydoc kLdrModNumberOfImports */
1988	static KI32 kldrModMachONumberOfImports(PKLDRMOD pMod, const void *pvBits)
1989	{
1990	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
1991	if (pModMachO->Hdr.filetype == MH_OBJECT)
1992	return 0;
1993
1994	/* later */
1995	return 0;
1996	}
1997
1998
1999	/** @copydoc kLdrModGetStackInfo */
2000	static int kldrModMachOGetStackInfo(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, PKLDRSTACKINFO pStackInfo)
2001	{
2002	/PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;/
2003
2004	pStackInfo->Address = NIL_KLDRADDR;
2005	pStackInfo->LinkAddress = NIL_KLDRADDR;
2006	pStackInfo->cbStack = pStackInfo->cbStackThread = 0;
2007	/* later */
2008
2009	return 0;
2010	}
2011
2012
2013	/** @copydoc kLdrModQueryMainEntrypoint */
2014	static int kldrModMachOQueryMainEntrypoint(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, PKLDRADDR pMainEPAddress)
2015	{
2016	#if 0
2017	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
2018	int rc;
2019
2020	/*
2021	* Resolve base address alias if any.
2022	*/
2023	rc = kldrModMachOBitsAndBaseAddress(pModMachO, NULL, &BaseAddress);
2024	if (rc)
2025	return rc;
2026
2027	/*
2028	* Convert the address from the header.
2029	*/
2030	*pMainEPAddress = pModMachO->Hdrs.OptionalHeader.AddressOfEntryPoint
2031	? BaseAddress + pModMachO->Hdrs.OptionalHeader.AddressOfEntryPoint
2032	: NIL_KLDRADDR;
2033	#else
2034	*pMainEPAddress = NIL_KLDRADDR;
2035	#endif
2036	return 0;
2037	}
2038
2039
2040	/** @copydoc kLdrModEnumDbgInfo */
2041	static int kldrModMachOEnumDbgInfo(PKLDRMOD pMod, const void pvBits, PFNKLDRENUMDBG pfnCallback, void pvUser)
2042	{
2043	#if 0
2044	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
2045	const IMAGE_DEBUG_DIRECTORY *pDbgDir;
2046	KU32 iDbgInfo;
2047	KU32 cb;
2048	int rc;
2049
2050	/*
2051	* Check that there is a debug directory first.
2052	*/
2053	cb = pModMachO->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].Size;
2054	if ( cb < sizeof(IMAGE_DEBUG_DIRECTORY) /* screw borland linkers */
2055	\|\| !pModMachO->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress)
2056	return 0;
2057
2058	/*
2059	* Make sure we've got mapped bits.
2060	*/
2061	rc = kldrModMachOBitsAndBaseAddress(pModMachO, &pvBits, NULL);
2062	if (rc)
2063	return rc;
2064
2065	/*
2066	* Enumerate the debug directory.
2067	*/
2068	pDbgDir = KLDRMODMACHO_RVA2TYPE(pvBits,
2069	pModMachO->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress,
2070	const IMAGE_DEBUG_DIRECTORY *);
2071	for (iDbgInfo = 0;; iDbgInfo++, pDbgDir++, cb -= sizeof(IMAGE_DEBUG_DIRECTORY))
2072	{
2073	KLDRDBGINFOTYPE enmDbgInfoType;
2074
2075	/* convert the type. */
2076	switch (pDbgDir->Type)
2077	{
2078	case IMAGE_DEBUG_TYPE_UNKNOWN:
2079	case IMAGE_DEBUG_TYPE_FPO:
2080	case IMAGE_DEBUG_TYPE_COFF: /stabs dialect??/
2081	case IMAGE_DEBUG_TYPE_MISC:
2082	case IMAGE_DEBUG_TYPE_EXCEPTION:
2083	case IMAGE_DEBUG_TYPE_FIXUP:
2084	case IMAGE_DEBUG_TYPE_BORLAND:
2085	default:
2086	enmDbgInfoType = KLDRDBGINFOTYPE_UNKNOWN;
2087	break;
2088	case IMAGE_DEBUG_TYPE_CODEVIEW:
2089	enmDbgInfoType = KLDRDBGINFOTYPE_CODEVIEW;
2090	break;
2091	}
2092
2093	rc = pfnCallback(pMod, iDbgInfo,
2094	enmDbgInfoType, pDbgDir->MajorVersion, pDbgDir->MinorVersion,
2095	pDbgDir->PointerToRawData ? pDbgDir->PointerToRawData : -1,
2096	pDbgDir->AddressOfRawData ? pDbgDir->AddressOfRawData : NIL_KLDRADDR,
2097	pDbgDir->SizeOfData,
2098	NULL,
2099	pvUser);
2100	if (rc)
2101	break;
2102
2103	/* next */
2104	if (cb <= sizeof(IMAGE_DEBUG_DIRECTORY))
2105	break;
2106	}
2107
2108	return rc;
2109	#else
2110	return 0;
2111	#endif
2112	}
2113
2114
2115	/** @copydoc kLdrModHasDbgInfo */
2116	static int kldrModMachOHasDbgInfo(PKLDRMOD pMod, const void *pvBits)
2117	{
2118	/PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;/
2119
2120	#if 0
2121	/*
2122	* Base this entirely on the presence of a debug directory.
2123	*/
2124	if ( pModMachO->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].Size
2125	< sizeof(IMAGE_DEBUG_DIRECTORY) /* screw borland linkers */
2126	\|\| !pModMachO->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress)
2127	return KLDR_ERR_NO_DEBUG_INFO;
2128	return 0;
2129	#else
2130	return KLDR_ERR_NO_DEBUG_INFO;
2131	#endif
2132	}
2133
2134
2135	/** @copydoc kLdrModMap */
2136	static int kldrModMachOMap(PKLDRMOD pMod)
2137	{
2138	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
2139	unsigned fFixed;
2140	KU32 i;
2141	void *pvBase;
2142	int rc;
2143
2144	/*
2145	* Already mapped?
2146	*/
2147	if (pModMachO->pvMapping)
2148	return KLDR_ERR_ALREADY_MAPPED;
2149
2150	/*
2151	* Map it.
2152	*/
2153	/* fixed image? */
2154	fFixed = pMod->enmType == KLDRTYPE_EXECUTABLE_FIXED
2155	\|\| pMod->enmType == KLDRTYPE_SHARED_LIBRARY_FIXED;
2156	if (!fFixed)
2157	pvBase = NULL;
2158	else
2159	{
2160	pvBase = (void *)(KUPTR)pMod->aSegments[0].LinkAddress;
2161	if ((KUPTR)pvBase != pMod->aSegments[0].LinkAddress)
2162	return KLDR_ERR_ADDRESS_OVERFLOW;
2163	}
2164
2165	/* try do the prepare */
2166	if (pModMachO->fMapUsingLoadCommandSections)
2167	KLDRMODMACHO_CHECK_RETURN(0, KLDR_ERR_TODO); /* deal with this if it ever occurs. */
2168	else
2169	{
2170	rc = kRdrMap(pMod->pRdr, &pvBase, pMod->cSegments, pMod->aSegments, fFixed);
2171	if (rc)
2172	return rc;
2173	}
2174
2175	/*
2176	* Update the segments with their map addresses.
2177	*/
2178	for (i = 0; i < pMod->cSegments; i++)
2179	{
2180	if (pMod->aSegments[i].RVA != NIL_KLDRADDR)
2181	pMod->aSegments[i].MapAddress = (KUPTR)pvBase + (KUPTR)pMod->aSegments[i].RVA;
2182	}
2183	pModMachO->pvMapping = pvBase;
2184
2185	return 0;
2186	}
2187
2188
2189	/** @copydoc kLdrModUnmap */
2190	static int kldrModMachOUnmap(PKLDRMOD pMod)
2191	{
2192	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
2193	KU32 i;
2194	int rc;
2195
2196	/*
2197	* Mapped?
2198	*/
2199	if (!pModMachO->pvMapping)
2200	return KLDR_ERR_NOT_MAPPED;
2201
2202	/*
2203	* Try unmap the image.
2204	*/
2205	if (pModMachO->fMapUsingLoadCommandSections)
2206	KLDRMODMACHO_CHECK_RETURN(0, KLDR_ERR_TODO); /* deal with this if it ever occurs. */
2207	else
2208	{
2209	rc = kRdrUnmap(pMod->pRdr, pModMachO->pvMapping, pMod->cSegments, pMod->aSegments);
2210	if (rc)
2211	return rc;
2212	}
2213
2214	/*
2215	* Update the segments to reflect that they aren't mapped any longer.
2216	*/
2217	pModMachO->pvMapping = NULL;
2218	for (i = 0; i < pMod->cSegments; i++)
2219	pMod->aSegments[i].MapAddress = 0;
2220
2221	return 0;
2222	}
2223
2224
2225	/** @copydoc kLdrModAllocTLS */
2226	static int kldrModMachOAllocTLS(PKLDRMOD pMod)
2227	{
2228	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
2229
2230	/*
2231	* Mapped?
2232	*/
2233	if (!pModMachO->pvMapping)
2234	return KLDR_ERR_NOT_MAPPED;
2235	return 0;
2236	}
2237
2238
2239	/** @copydoc kLdrModFreeTLS */
2240	static void kldrModMachOFreeTLS(PKLDRMOD pMod)
2241	{
2242	}
2243
2244
2245	/** @copydoc kLdrModReload */
2246	static int kldrModMachOReload(PKLDRMOD pMod)
2247	{
2248	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
2249
2250	/*
2251	* Mapped?
2252	*/
2253	if (!pModMachO->pvMapping)
2254	return KLDR_ERR_NOT_MAPPED;
2255
2256	/* the file provider does it all */
2257	return kRdrRefresh(pMod->pRdr, pModMachO->pvMapping, pMod->cSegments, pMod->aSegments);
2258	}
2259
2260
2261	/** @copydoc kLdrModFixupMapping */
2262	static int kldrModMachOFixupMapping(PKLDRMOD pMod, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser)
2263	{
2264	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
2265	int rc, rc2;
2266
2267	/*
2268	* Mapped?
2269	*/
2270	if (!pModMachO->pvMapping)
2271	return KLDR_ERR_NOT_MAPPED;
2272
2273	/*
2274	* Before doing anything we'll have to make all pages writable.
2275	*/
2276	if (pModMachO->fMapUsingLoadCommandSections)
2277	KLDRMODMACHO_CHECK_RETURN(0, KLDR_ERR_TODO); /* deal with this if it ever occurs. */
2278	else
2279	{
2280	rc = kRdrProtect(pMod->pRdr, pModMachO->pvMapping, pMod->cSegments, pMod->aSegments, 1 /* unprotect */);
2281	if (rc)
2282	return rc;
2283	}
2284
2285	/*
2286	* Resolve imports and apply base relocations.
2287	*/
2288	rc = kldrModMachORelocateBits(pMod, pModMachO->pvMapping, (KUPTR)pModMachO->pvMapping, pModMachO->LinkAddress,
2289	pfnGetImport, pvUser);
2290
2291	/*
2292	* Restore protection.
2293	*/
2294	if (pModMachO->fMapUsingLoadCommandSections)
2295	rc2 = KLDR_ERR_TODO; /* deal with this if it ever occurs. */
2296	else
2297	rc2 = kRdrProtect(pMod->pRdr, pModMachO->pvMapping, pMod->cSegments, pMod->aSegments, 0 /* protect */);
2298	if (!rc && rc2)
2299	rc = rc2;
2300	return rc;
2301	}
2302
2303
2304	/**
2305	* MH_OBJECT: Resolves undefined symbols (imports).
2306	*
2307	* @returns 0 on success, non-zero kLdr status code on failure.
2308	* @param pModMachO The Mach-O module interpreter instance.
2309	* @param pfnGetImport The callback for resolving an imported symbol.
2310	* @param pvUser User argument to the callback.
2311	*/
2312	static int kldrModMachOObjDoImports(PKLDRMODMACHO pModMachO, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser)
2313	{
2314	const KU32 cSyms = pModMachO->cSymbols;
2315	KU32 iSym;
2316	int rc;
2317
2318	/*
2319	* Ensure that we've got the symbol table and section fixups handy.
2320	*/
2321	rc = kldrModMachOLoadObjSymTab(pModMachO);
2322	if (rc)
2323	return rc;
2324
2325	/*
2326	* Iterate the symbol table and resolve undefined symbols.
2327	* We currently ignore REFERENCE_TYPE.
2328	*/
2329	if ( pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE
2330	\|\| pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE_OE)
2331	{
2332	macho_nlist_32_t paSyms = (macho_nlist_32_t )pModMachO->pvaSymbols;
2333	for (iSym = 0; iSym < cSyms; iSym++)
2334	{
2335	/* skip stabs */
2336	if (paSyms[iSym].n_type & MACHO_N_STAB)
2337	continue;
2338
2339	if ((paSyms[iSym].n_type & MACHO_N_TYPE) == MACHO_N_UNDF)
2340	{
2341	const char *pszSymbol;
2342	KSIZE cchSymbol;
2343	KU32 fKind = KLDRSYMKIND_REQ_FLAT;
2344	KLDRADDR Value;
2345
2346	/** @todo Implement N_REF_TO_WEAK. */
2347	KLDRMODMACHO_CHECK_RETURN(!(paSyms[iSym].n_desc & N_REF_TO_WEAK), KLDR_ERR_TODO);
2348
2349	/* Get the symbol name and try resolve it. */
2350	if ((KU32)paSyms[iSym].n_un.n_strx >= pModMachO->cchStrings)
2351	return KLDR_ERR_MACHO_BAD_SYMBOL;
2352	pszSymbol = &pModMachO->pchStrings[paSyms[iSym].n_un.n_strx];
2353	cchSymbol = kHlpStrLen(pszSymbol);
2354	rc = pfnGetImport(pModMachO->pMod, NIL_KLDRMOD_IMPORT, iSym, pszSymbol, cchSymbol, NULL,
2355	&Value, &fKind, pvUser);
2356	if (rc)
2357	{
2358	/* weak reference? */
2359	if (!(paSyms[iSym].n_desc & N_WEAK_REF))
2360	break;
2361	Value = 0;
2362	}
2363
2364	/* Update the symbol. */
2365	paSyms[iSym].n_value = (KU32)Value;
2366	if (paSyms[iSym].n_value != Value)
2367	{
2368	rc = KLDR_ERR_ADDRESS_OVERFLOW;
2369	break;
2370	}
2371	}
2372	else if (paSyms[iSym].n_desc & N_WEAK_DEF)
2373	{
2374	/** @todo implement weak symbols. */
2375	/return KLDR_ERR_TODO; - ignored for now. /
2376	}
2377	}
2378	}
2379	else
2380	{
2381	/* (Identical to the 32-bit code, just different paSym type. (and n_strx is unsigned)) */
2382	macho_nlist_64_t paSyms = (macho_nlist_64_t )pModMachO->pvaSymbols;
2383	for (iSym = 0; iSym < cSyms; iSym++)
2384	{
2385	/* skip stabs */
2386	if (paSyms[iSym].n_type & MACHO_N_STAB)
2387	continue;
2388
2389	if ((paSyms[iSym].n_type & MACHO_N_TYPE) == MACHO_N_UNDF)
2390	{
2391	const char *pszSymbol;
2392	KSIZE cchSymbol;
2393	KU32 fKind = KLDRSYMKIND_REQ_FLAT;
2394	KLDRADDR Value;
2395
2396	/** @todo Implement N_REF_TO_WEAK. */
2397	KLDRMODMACHO_CHECK_RETURN(!(paSyms[iSym].n_desc & N_REF_TO_WEAK), KLDR_ERR_TODO);
2398
2399	/* Get the symbol name and try resolve it. */
2400	if (paSyms[iSym].n_un.n_strx >= pModMachO->cchStrings)
2401	return KLDR_ERR_MACHO_BAD_SYMBOL;
2402	pszSymbol = &pModMachO->pchStrings[paSyms[iSym].n_un.n_strx];
2403	cchSymbol = kHlpStrLen(pszSymbol);
2404	rc = pfnGetImport(pModMachO->pMod, NIL_KLDRMOD_IMPORT, iSym, pszSymbol, cchSymbol, NULL,
2405	&Value, &fKind, pvUser);
2406	if (rc)
2407	{
2408	/* weak reference? */
2409	if (!(paSyms[iSym].n_desc & N_WEAK_REF))
2410	break;
2411	Value = 0;
2412	}
2413
2414	/* Update the symbol. */
2415	paSyms[iSym].n_value = Value;
2416	if (paSyms[iSym].n_value != Value)
2417	{
2418	rc = KLDR_ERR_ADDRESS_OVERFLOW;
2419	break;
2420	}
2421	}
2422	else if (paSyms[iSym].n_desc & N_WEAK_DEF)
2423	{
2424	/** @todo implement weak symbols. */
2425	/return KLDR_ERR_TODO; - ignored for now. /
2426	}
2427	}
2428	}
2429
2430	return rc;
2431	}
2432
2433
2434	/**
2435	* MH_OBJECT: Applies base relocations to a (unprotected) image mapping.
2436	*
2437	* @returns 0 on success, non-zero kLdr status code on failure.
2438	* @param pModMachO The Mach-O module interpreter instance.
2439	* @param pvMapping The mapping to fixup.
2440	* @param NewBaseAddress The address to fixup the mapping to.
2441	* @param OldBaseAddress The address the mapping is currently fixed up to.
2442	*/
2443	static int kldrModMachOObjDoFixups(PKLDRMODMACHO pModMachO, void *pvMapping, KLDRADDR NewBaseAddress)
2444	{
2445	KU32 iSeg;
2446	int rc;
2447
2448
2449	/*
2450	* Ensure that we've got the symbol table and section fixups handy.
2451	*/
2452	rc = kldrModMachOLoadObjSymTab(pModMachO);
2453	if (rc)
2454	return rc;
2455
2456	/*
2457	* Iterate over the segments and their sections and apply fixups.
2458	*/
2459	for (iSeg = rc = 0; !rc && iSeg < pModMachO->pMod->cSegments; iSeg++)
2460	{
2461	PKLDRMODMACHOSEG pSeg = &pModMachO->aSegments[iSeg];
2462	KU32 iSect;
2463
2464	for (iSect = 0; iSect < pSeg->cSections; iSect++)
2465	{
2466	PKLDRMODMACHOSECT pSect = &pSeg->paSections[iSect];
2467	KU8 *pbSectBits;
2468
2469	/* skip sections without fixups. */
2470	if (!pSect->cFixups)
2471	continue;
2472
2473	/* lazy load (and endian convert) the fixups. */
2474	if (!pSect->paFixups)
2475	{
2476	rc = kldrModMachOLoadFixups(pModMachO, pSect->offFixups, pSect->cFixups, &pSect->paFixups);
2477	if (rc)
2478	break;
2479	}
2480
2481	/*
2482	* Apply the fixups.
2483	*/
2484	pbSectBits = (KU8 *)pvMapping + (KUPTR)pSect->RVA;
2485	if (pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE) /** @todo this aint right. */
2486	rc = kldrModMachOFixupSectionGeneric32Bit(pModMachO, pbSectBits, pSect,
2487	(macho_nlist_32_t *)pModMachO->pvaSymbols,
2488	pModMachO->cSymbols, NewBaseAddress);
2489	else if ( pModMachO->Hdr.magic == IMAGE_MACHO64_SIGNATURE
2490	&& pModMachO->Hdr.cputype == CPU_TYPE_X86_64)
2491	rc = kldrModMachOFixupSectionAMD64(pModMachO, pbSectBits, pSect,
2492	(macho_nlist_64_t *)pModMachO->pvaSymbols,
2493	pModMachO->cSymbols, NewBaseAddress);
2494	else
2495	KLDRMODMACHO_CHECK_RETURN(0, KLDR_ERR_TODO);
2496	if (rc)
2497	break;
2498	}
2499	}
2500
2501	return rc;
2502	}
2503
2504
2505	/**
2506	* Applies generic fixups to a section in an image of the same endian-ness
2507	* as the host CPU.
2508	*
2509	* @returns 0 on success, non-zero kLdr status code on failure.
2510	* @param pModMachO The Mach-O module interpreter instance.
2511	* @param pbSectBits Pointer to the section bits.
2512	* @param pFixupSect The section being fixed up.
2513	* @param NewBaseAddress The new base image address.
2514	*/
2515	static int kldrModMachOFixupSectionGeneric32Bit(PKLDRMODMACHO pModMachO, KU8 *pbSectBits, PKLDRMODMACHOSECT pFixupSect,
2516	macho_nlist_32_t *paSyms, KU32 cSyms, KLDRADDR NewBaseAddress)
2517	{
2518	const macho_relocation_info_t *paFixups = pFixupSect->paFixups;
2519	const KU32 cFixups = pFixupSect->cFixups;
2520	KSIZE cbSectBits = (KSIZE)pFixupSect->cb;
2521	const KU8 *pbSectVirginBits;
2522	KU32 iFixup;
2523	KLDRPU uFixVirgin;
2524	KLDRPU uFix;
2525	KLDRADDR SymAddr;
2526	int rc;
2527
2528	/*
2529	* Find the virgin bits.
2530	*/
2531	if (pFixupSect->offFile != -1)
2532	{
2533	rc = kldrModMachOMapVirginBits(pModMachO);
2534	if (rc)
2535	return rc;
2536	pbSectVirginBits = (const KU8 *)pModMachO->pvBits + pFixupSect->offFile;
2537	}
2538	else
2539	pbSectVirginBits = NULL;
2540
2541	/*
2542	* Iterate the fixups and apply them.
2543	*/
2544	for (iFixup = 0; iFixup < cFixups; iFixup++)
2545	{
2546	union
2547	{
2548	macho_relocation_info_t r;
2549	scattered_relocation_info_t s;
2550	} Fixup;
2551	Fixup.r = paFixups[iFixup];
2552
2553	if (!(Fixup.r.r_address & R_SCATTERED))
2554	{
2555	/* sanity */
2556	if ((KU32)Fixup.r.r_address >= cbSectBits)
2557	return KLDR_ERR_BAD_FIXUP;
2558
2559	/* calc fixup addresses. */
2560	uFix.pv = pbSectBits + Fixup.r.r_address;
2561	uFixVirgin.pv = pbSectVirginBits ? (KU8 *)pbSectVirginBits + Fixup.r.r_address : 0;
2562
2563	/*
2564	* Calc the symbol value.
2565	*/
2566	/* Calc the linked symbol address / addend. */
2567	switch (Fixup.r.r_length)
2568	{
2569	/** @todo Deal with unaligned accesses on non x86 platforms. */
2570	case 0: SymAddr = *uFixVirgin.pi8; break;
2571	case 1: SymAddr = *uFixVirgin.pi16; break;
2572	case 2: SymAddr = *uFixVirgin.pi32; break;
2573	case 3: SymAddr = *uFixVirgin.pi64; break;
2574	}
2575	if (Fixup.r.r_pcrel)
2576	SymAddr += Fixup.r.r_address + pFixupSect->LinkAddress;
2577
2578	/* Add symbol / section address. */
2579	if (Fixup.r.r_extern)
2580	{
2581	const macho_nlist_32_t *pSym;
2582	if (Fixup.r.r_symbolnum >= cSyms)
2583	return KLDR_ERR_BAD_FIXUP;
2584	pSym = &paSyms[Fixup.r.r_symbolnum];
2585
2586	if (pSym->n_type & MACHO_N_STAB)
2587	return KLDR_ERR_BAD_FIXUP;
2588
2589	switch (pSym->n_type & MACHO_N_TYPE)
2590	{
2591	case MACHO_N_SECT:
2592	{
2593	PKLDRMODMACHOSECT pSymSect;
2594	if ((KU32)pSym->n_sect - 1 > pModMachO->cSections)
2595	return KLDR_ERR_MACHO_BAD_SYMBOL;
2596	pSymSect = &pModMachO->paSections[pSym->n_sect - 1];
2597
2598	SymAddr += pSym->n_value - pSymSect->LinkAddress + pSymSect->RVA + NewBaseAddress;
2599	break;
2600	}
2601
2602	case MACHO_N_UNDF:
2603	case MACHO_N_ABS:
2604	SymAddr += pSym->n_value;
2605	break;
2606
2607	case MACHO_N_INDR:
2608	case MACHO_N_PBUD:
2609	KLDRMODMACHO_CHECK_RETURN(0, KLDR_ERR_TODO);
2610	default:
2611	KLDRMODMACHO_CHECK_RETURN(0, KLDR_ERR_MACHO_BAD_SYMBOL);
2612	}
2613	}
2614	else if (Fixup.r.r_symbolnum != R_ABS)
2615	{
2616	PKLDRMODMACHOSECT pSymSect;
2617	if (Fixup.r.r_symbolnum > pModMachO->cSections)
2618	return KLDR_ERR_BAD_FIXUP;
2619	pSymSect = &pModMachO->paSections[Fixup.r.r_symbolnum - 1];
2620
2621	SymAddr -= pSymSect->LinkAddress;
2622	SymAddr += pSymSect->RVA + NewBaseAddress;
2623	}
2624
2625	/* adjust for PC relative */
2626	if (Fixup.r.r_pcrel)
2627	SymAddr -= Fixup.r.r_address + pFixupSect->RVA + NewBaseAddress;
2628	}
2629	else
2630	{
2631	PKLDRMODMACHOSECT pSymSect;
2632	KU32 iSymSect;
2633	KLDRADDR Value;
2634
2635	/* sanity */
2636	KLDRMODMACHO_ASSERT(Fixup.s.r_scattered);
2637	if ((KU32)Fixup.s.r_address >= cbSectBits)
2638	return KLDR_ERR_BAD_FIXUP;
2639
2640	/* calc fixup addresses. */
2641	uFix.pv = pbSectBits + Fixup.s.r_address;
2642	uFixVirgin.pv = pbSectVirginBits ? (KU8 *)pbSectVirginBits + Fixup.s.r_address : 0;
2643
2644	/*
2645	* Calc the symbol value.
2646	*/
2647	/* The addend is stored in the code. */
2648	switch (Fixup.s.r_length)
2649	{
2650	case 0: SymAddr = *uFixVirgin.pi8; break;
2651	case 1: SymAddr = *uFixVirgin.pi16; break;
2652	case 2: SymAddr = *uFixVirgin.pi32; break;
2653	case 3: SymAddr = *uFixVirgin.pi64; break;
2654	}
2655	if (Fixup.s.r_pcrel)
2656	SymAddr += Fixup.s.r_address;
2657	Value = Fixup.s.r_value;
2658	SymAddr -= Value; /* (-> addend only) */
2659
2660	/* Find the section number from the r_value. */
2661	pSymSect = NULL;
2662	for (iSymSect = 0; iSymSect < pModMachO->cSections; iSymSect++)
2663	{
2664	KLDRADDR off = Value - pModMachO->paSections[iSymSect].LinkAddress;
2665	if (off < pModMachO->paSections[iSymSect].cb)
2666	{
2667	pSymSect = &pModMachO->paSections[iSymSect];
2668	break;
2669	}
2670	else if (off == pModMachO->paSections[iSymSect].cb) /* edge case */
2671	pSymSect = &pModMachO->paSections[iSymSect];
2672	}
2673	if (!pSymSect)
2674	return KLDR_ERR_BAD_FIXUP;
2675
2676	/* Calc the symbol address. */
2677	SymAddr += Value - pSymSect->LinkAddress + pSymSect->RVA + NewBaseAddress;
2678	if (Fixup.s.r_pcrel)
2679	SymAddr -= Fixup.s.r_address + pFixupSect->RVA + NewBaseAddress;
2680
2681	Fixup.r.r_length = ((scattered_relocation_info_t *)&paFixups[iFixup])->r_length;
2682	Fixup.r.r_type = ((scattered_relocation_info_t *)&paFixups[iFixup])->r_type;
2683	}
2684
2685	/*
2686	* Write back the fixed up value.
2687	*/
2688	if (Fixup.r.r_type == GENERIC_RELOC_VANILLA)
2689	{
2690	switch (Fixup.r.r_length)
2691	{
2692	case 0: *uFix.pu8 = (KU8)SymAddr; break;
2693	case 1: *uFix.pu16 = (KU16)SymAddr; break;
2694	case 2: *uFix.pu32 = (KU32)SymAddr; break;
2695	case 3: *uFix.pu64 = (KU64)SymAddr; break;
2696	}
2697	}
2698	else if (Fixup.r.r_type <= GENERIC_RELOC_LOCAL_SECTDIFF)
2699	return KLDR_ERR_MACHO_UNSUPPORTED_FIXUP_TYPE;
2700	else
2701	return KLDR_ERR_BAD_FIXUP;
2702	}
2703
2704	return 0;
2705	}
2706
2707
2708	/**
2709	* Applies AMD64 fixups to a section.
2710	*
2711	* @returns 0 on success, non-zero kLdr status code on failure.
2712	* @param pModMachO The Mach-O module interpreter instance.
2713	* @param pbSectBits Pointer to the section bits.
2714	* @param pFixupSect The section being fixed up.
2715	* @param NewBaseAddress The new base image address.
2716	*/
2717	static int kldrModMachOFixupSectionAMD64(PKLDRMODMACHO pModMachO, KU8 *pbSectBits, PKLDRMODMACHOSECT pFixupSect,
2718	macho_nlist_64_t *paSyms, KU32 cSyms, KLDRADDR NewBaseAddress)
2719	{
2720	const macho_relocation_info_t *paFixups = pFixupSect->paFixups;
2721	const KU32 cFixups = pFixupSect->cFixups;
2722	KSIZE cbSectBits = (KSIZE)pFixupSect->cb;
2723	const KU8 *pbSectVirginBits;
2724	KU32 iFixup;
2725	KLDRPU uFixVirgin;
2726	KLDRPU uFix;
2727	KLDRADDR SymAddr;
2728	int rc;
2729
2730	/*
2731	* Find the virgin bits.
2732	*/
2733	if (pFixupSect->offFile != -1)
2734	{
2735	rc = kldrModMachOMapVirginBits(pModMachO);
2736	if (rc)
2737	return rc;
2738	pbSectVirginBits = (const KU8 *)pModMachO->pvBits + pFixupSect->offFile;
2739	}
2740	else
2741	pbSectVirginBits = NULL;
2742
2743	/*
2744	* Iterate the fixups and apply them.
2745	*/
2746	for (iFixup = 0; iFixup < cFixups; iFixup++)
2747	{
2748	union
2749	{
2750	macho_relocation_info_t r;
2751	scattered_relocation_info_t s;
2752	} Fixup;
2753	Fixup.r = paFixups[iFixup];
2754
2755	/* AMD64 doesn't use scattered fixups. */
2756	KLDRMODMACHO_CHECK_RETURN(!(Fixup.r.r_address & R_SCATTERED), KLDR_ERR_BAD_FIXUP);
2757
2758	/* sanity */
2759	KLDRMODMACHO_CHECK_RETURN((KU32)Fixup.r.r_address < cbSectBits, KLDR_ERR_BAD_FIXUP);
2760
2761	/* calc fixup addresses. */
2762	uFix.pv = pbSectBits + Fixup.r.r_address;
2763	uFixVirgin.pv = pbSectVirginBits ? (KU8 *)pbSectVirginBits + Fixup.r.r_address : 0;
2764
2765	/*
2766	* Calc the symbol value.
2767	*/
2768	/* Calc the linked symbol address / addend. */
2769	switch (Fixup.r.r_length)
2770	{
2771	/** @todo Deal with unaligned accesses on non x86 platforms. */
2772	case 2: SymAddr = *uFixVirgin.pi32; break;
2773	case 3: SymAddr = *uFixVirgin.pi64; break;
2774	default:
2775	KLDRMODMACHO_CHECK_RETURN(0, KLDR_ERR_BAD_FIXUP);
2776	}
2777	if (Fixup.r.r_pcrel)
2778	SymAddr += Fixup.r.r_address + pFixupSect->LinkAddress;
2779
2780	/* Add symbol / section address. */
2781	if (Fixup.r.r_extern)
2782	{
2783	const macho_nlist_64_t *pSym;
2784
2785	KLDRMODMACHO_CHECK_RETURN(Fixup.r.r_symbolnum < cSyms, KLDR_ERR_BAD_FIXUP);
2786	pSym = &paSyms[Fixup.r.r_symbolnum];
2787	KLDRMODMACHO_CHECK_RETURN(!(pSym->n_type & MACHO_N_STAB), KLDR_ERR_BAD_FIXUP);
2788
2789	switch (Fixup.r.r_type)
2790	{
2791	/* GOT references just needs to have their symbol verified.
2792	Later, we'll optimize GOT building here using a parallel sym->got array. */
2793	case X86_64_RELOC_GOT_LOAD:
2794	case X86_64_RELOC_GOT:
2795	switch (pSym->n_type & MACHO_N_TYPE)
2796	{
2797	case MACHO_N_SECT:
2798	case MACHO_N_UNDF:
2799	case MACHO_N_ABS:
2800	break;
2801	case MACHO_N_INDR:
2802	case MACHO_N_PBUD:
2803	KLDRMODMACHO_CHECK_RETURN(0, KLDR_ERR_TODO);
2804	default:
2805	KLDRMODMACHO_CHECK_RETURN(0, KLDR_ERR_MACHO_BAD_SYMBOL);
2806	}
2807	SymAddr = sizeof(KU64) * Fixup.r.r_symbolnum + pModMachO->GotRVA + NewBaseAddress;
2808	break;
2809
2810	/* Verify the r_pcrel field for signed fixups on the way into the default case. */
2811	case X86_64_RELOC_BRANCH:
2812	case X86_64_RELOC_SIGNED:
2813	case X86_64_RELOC_SIGNED_1:
2814	case X86_64_RELOC_SIGNED_2:
2815	case X86_64_RELOC_SIGNED_4:
2816	KLDRMODMACHO_CHECK_RETURN(Fixup.r.r_pcrel, KLDR_ERR_BAD_FIXUP);
2817	default:
2818	{
2819	/* Adjust with fixup specific addend and vierfy unsigned/r_pcrel. */
2820	switch (Fixup.r.r_type)
2821	{
2822	case X86_64_RELOC_UNSIGNED:
2823	KLDRMODMACHO_CHECK_RETURN(!Fixup.r.r_pcrel, KLDR_ERR_BAD_FIXUP);
2824	break;
2825	case X86_64_RELOC_SIGNED:
2826	break;
2827	case X86_64_RELOC_BRANCH:
2828	switch (Fixup.r.r_length)
2829	{
2830	case 0: SymAddr -= 1; break;
2831	case 1: SymAddr -= 2; break;
2832	case 2: SymAddr -= 4; break;
2833	case 3: SymAddr -= 8; break;
2834	}
2835	break;
2836	case X86_64_RELOC_SIGNED_1: SymAddr -= 1; break;
2837	case X86_64_RELOC_SIGNED_2: SymAddr -= 2; break;
2838	case X86_64_RELOC_SIGNED_4: SymAddr -= 4; break;
2839	default:
2840	KLDRMODMACHO_CHECK_RETURN(0, KLDR_ERR_BAD_FIXUP);
2841	}
2842
2843	switch (pSym->n_type & MACHO_N_TYPE)
2844	{
2845	case MACHO_N_SECT:
2846	{
2847	PKLDRMODMACHOSECT pSymSect;
2848	KLDRMODMACHO_CHECK_RETURN((KU32)pSym->n_sect - 1 <= pModMachO->cSections, KLDR_ERR_MACHO_BAD_SYMBOL);
2849	pSymSect = &pModMachO->paSections[pSym->n_sect - 1];
2850	SymAddr += pSym->n_value - pSymSect->LinkAddress + pSymSect->RVA + NewBaseAddress;
2851	break;
2852	}
2853
2854	case MACHO_N_UNDF:
2855	case MACHO_N_ABS:
2856	SymAddr += pSym->n_value;
2857	break;
2858
2859	case MACHO_N_INDR:
2860	case MACHO_N_PBUD:
2861	KLDRMODMACHO_CHECK_RETURN(0, KLDR_ERR_TODO);
2862	default:
2863	KLDRMODMACHO_CHECK_RETURN(0, KLDR_ERR_MACHO_BAD_SYMBOL);
2864	}
2865	break;
2866	}
2867
2868	/*
2869	* This is a weird customer, it will always be follows by an UNSIGNED fixup.
2870	*/
2871	case X86_64_RELOC_SUBTRACTOR:
2872	{
2873	macho_relocation_info_t Fixup2;
2874
2875	/* Deal with the SUBTRACT symbol first, by subtracting it from SymAddr. */
2876	switch (pSym->n_type & MACHO_N_TYPE)
2877	{
2878	case MACHO_N_SECT:
2879	{
2880	PKLDRMODMACHOSECT pSymSect;
2881	KLDRMODMACHO_CHECK_RETURN((KU32)pSym->n_sect - 1 <= pModMachO->cSections, KLDR_ERR_MACHO_BAD_SYMBOL);
2882	pSymSect = &pModMachO->paSections[pSym->n_sect - 1];
2883	SymAddr -= pSym->n_value - pSymSect->LinkAddress + pSymSect->RVA + NewBaseAddress;
2884	break;
2885	}
2886
2887	case MACHO_N_UNDF:
2888	case MACHO_N_ABS:
2889	SymAddr -= pSym->n_value;
2890	break;
2891
2892	case MACHO_N_INDR:
2893	case MACHO_N_PBUD:
2894	KLDRMODMACHO_CHECK_RETURN(0,KLDR_ERR_TODO);
2895	default:
2896	KLDRMODMACHO_CHECK_RETURN(0, KLDR_ERR_MACHO_BAD_SYMBOL);
2897	}
2898
2899	/* Load the 2nd fixup, check sanity. */
2900	iFixup++;
2901	KLDRMODMACHO_CHECK_RETURN(!Fixup.r.r_pcrel && iFixup < cFixups, KLDR_ERR_BAD_FIXUP);
2902	Fixup2 = paFixups[iFixup];
2903	KLDRMODMACHO_CHECK_RETURN( Fixup2.r_address == Fixup.r.r_address
2904	&& Fixup2.r_length == Fixup.r.r_length
2905	&& Fixup2.r_type == X86_64_RELOC_UNSIGNED
2906	&& !Fixup2.r_pcrel
2907	&& Fixup2.r_extern /??/
2908	&& Fixup2.r_symbolnum < cSyms,
2909	KLDR_ERR_BAD_FIXUP);
2910
2911	pSym = &paSyms[Fixup.r.r_symbolnum];
2912	KLDRMODMACHO_CHECK_RETURN(!(pSym->n_type & MACHO_N_STAB), KLDR_ERR_BAD_FIXUP);
2913
2914	/* Add it's value to SymAddr. */
2915	switch (pSym->n_type & MACHO_N_TYPE)
2916	{
2917	case MACHO_N_SECT:
2918	{
2919	PKLDRMODMACHOSECT pSymSect;
2920	KLDRMODMACHO_CHECK_RETURN((KU32)pSym->n_sect - 1 <= pModMachO->cSections, KLDR_ERR_MACHO_BAD_SYMBOL);
2921	pSymSect = &pModMachO->paSections[pSym->n_sect - 1];
2922	SymAddr += pSym->n_value - pSymSect->LinkAddress + pSymSect->RVA + NewBaseAddress;
2923	break;
2924	}
2925
2926	case MACHO_N_UNDF:
2927	case MACHO_N_ABS:
2928	SymAddr += pSym->n_value;
2929	break;
2930
2931	case MACHO_N_INDR:
2932	case MACHO_N_PBUD:
2933	KLDRMODMACHO_CHECK_RETURN(0, KLDR_ERR_TODO);
2934	default:
2935	KLDRMODMACHO_CHECK_RETURN(0, KLDR_ERR_MACHO_BAD_SYMBOL);
2936	}
2937	}
2938	break;
2939	}
2940	}
2941	else
2942	{
2943	/* verify against fixup type */
2944	switch (Fixup.r.r_type)
2945	{
2946	case X86_64_RELOC_UNSIGNED:
2947	case X86_64_RELOC_SIGNED:
2948	case X86_64_RELOC_BRANCH:
2949	/case X86_64_RELOC_GOT_LOAD:/
2950	/case X86_64_RELOC_GOT: /
2951	/case X86_64_RELOC_SUBTRACTOR: - ???/
2952	case X86_64_RELOC_SIGNED_1:
2953	case X86_64_RELOC_SIGNED_2:
2954	case X86_64_RELOC_SIGNED_4:
2955	break;
2956	default:
2957	KLDRMODMACHO_CHECK_RETURN(0, KLDR_ERR_BAD_FIXUP);
2958	}
2959	if (Fixup.r.r_symbolnum != R_ABS)
2960	{
2961	PKLDRMODMACHOSECT pSymSect;
2962	KLDRMODMACHO_CHECK_RETURN(Fixup.r.r_symbolnum <= pModMachO->cSections, KLDR_ERR_BAD_FIXUP);
2963	pSymSect = &pModMachO->paSections[Fixup.r.r_symbolnum - 1];
2964
2965	SymAddr -= pSymSect->LinkAddress;
2966	SymAddr += pSymSect->RVA + NewBaseAddress;
2967	}
2968	}
2969
2970	/* adjust for PC relative */
2971	if (Fixup.r.r_pcrel)
2972	SymAddr -= Fixup.r.r_address + pFixupSect->RVA + NewBaseAddress;
2973
2974	/*
2975	* Write back the fixed up value.
2976	*/
2977	switch (Fixup.r.r_length)
2978	{
2979	case 3:
2980	*uFix.pu64 = (KU64)SymAddr;
2981	break;
2982	case 2:
2983	KLDRMODMACHO_CHECK_RETURN(Fixup.r.r_pcrel \|\| Fixup.r.r_type == X86_64_RELOC_SUBTRACTOR, KLDR_ERR_BAD_FIXUP);
2984	KLDRMODMACHO_CHECK_RETURN((KI32)SymAddr == (KI64)SymAddr, KLDR_ERR_ADDRESS_OVERFLOW);
2985	*uFix.pu32 = (KU32)SymAddr;
2986	break;
2987	default:
2988	KLDRMODMACHO_CHECK_RETURN(0, KLDR_ERR_BAD_FIXUP);
2989	}
2990	}
2991
2992	return 0;
2993	}
2994
2995
2996	/**
2997	* Loads the symbol table for a MH_OBJECT file.
2998	*
2999	* The symbol table is pointed to by KLDRMODMACHO::pvaSymbols.
3000	*
3001	* @returns 0 on success, non-zero kLdr status code on failure.
3002	* @param pModMachO The Mach-O module interpreter instance.
3003	*/
3004	static int kldrModMachOLoadObjSymTab(PKLDRMODMACHO pModMachO)
3005	{
3006	int rc = 0;
3007
3008	if ( !pModMachO->pvaSymbols
3009	&& pModMachO->cSymbols)
3010	{
3011	KSIZE cbSyms;
3012	KSIZE cbSym;
3013	void *pvSyms;
3014	void *pvStrings;
3015
3016	/* sanity */
3017	KLDRMODMACHO_CHECK_RETURN( pModMachO->offSymbols
3018	&& (!pModMachO->cchStrings \|\| pModMachO->offStrings),
3019	KLDR_ERR_MACHO_BAD_OBJECT_FILE);
3020
3021	/* allocate */
3022	cbSym = pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE
3023	\|\| pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE_OE
3024	? sizeof(macho_nlist_32_t)
3025	: sizeof(macho_nlist_64_t);
3026	cbSyms = pModMachO->cSymbols * cbSym;
3027	KLDRMODMACHO_CHECK_RETURN(cbSyms / cbSym == pModMachO->cSymbols, KLDR_ERR_SIZE_OVERFLOW);
3028	rc = KERR_NO_MEMORY;
3029	pvSyms = kHlpAlloc(cbSyms);
3030	if (pvSyms)
3031	{
3032	if (pModMachO->cchStrings)
3033	pvStrings = kHlpAlloc(pModMachO->cchStrings);
3034	else
3035	pvStrings = kHlpAllocZ(4);
3036	if (pvStrings)
3037	{
3038	/* read */
3039	rc = kRdrRead(pModMachO->pMod->pRdr, pvSyms, cbSyms, pModMachO->offSymbols);
3040	if (!rc && pModMachO->cchStrings)
3041	rc = kRdrRead(pModMachO->pMod->pRdr, pvStrings, pModMachO->cchStrings, pModMachO->offStrings);
3042	if (!rc)
3043	{
3044	pModMachO->pvaSymbols = pvSyms;
3045	pModMachO->pchStrings = (char *)pvStrings;
3046
3047	/* perform endian conversion? */
3048	if (pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE_OE)
3049	{
3050	KU32 cLeft = pModMachO->cSymbols;
3051	macho_nlist_32_t pSym = (macho_nlist_32_t )pvSyms;
3052	while (cLeft-- > 0)
3053	{
3054	pSym->n_un.n_strx = K_E2E_U32(pSym->n_un.n_strx);
3055	pSym->n_desc = (KI16)K_E2E_U16(pSym->n_desc);
3056	pSym->n_value = K_E2E_U32(pSym->n_value);
3057	pSym++;
3058	}
3059	}
3060	else if (pModMachO->Hdr.magic == IMAGE_MACHO64_SIGNATURE_OE)
3061	{
3062	KU32 cLeft = pModMachO->cSymbols;
3063	macho_nlist_64_t pSym = (macho_nlist_64_t )pvSyms;
3064	while (cLeft-- > 0)
3065	{
3066	pSym->n_un.n_strx = K_E2E_U32(pSym->n_un.n_strx);
3067	pSym->n_desc = (KI16)K_E2E_U16(pSym->n_desc);
3068	pSym->n_value = K_E2E_U64(pSym->n_value);
3069	pSym++;
3070	}
3071	}
3072
3073	return 0;
3074	}
3075	kHlpFree(pvStrings);
3076	}
3077	kHlpFree(pvSyms);
3078	}
3079	}
3080	else
3081	KLDRMODMACHO_ASSERT(pModMachO->pchStrings);
3082
3083	return rc;
3084	}
3085
3086
3087	/**
3088	* Loads the fixups at the given address and performs endian
3089	* conversion if necessary.
3090	*
3091	* @returns 0 on success, non-zero kLdr status code on failure.
3092	* @param pModMachO The Mach-O module interpreter instance.
3093	* @param offFixups The file offset of the fixups.
3094	* @param cFixups The number of fixups to load.
3095	* @param ppaFixups Where to put the pointer to the allocated fixup array.
3096	*/
3097	static int kldrModMachOLoadFixups(PKLDRMODMACHO pModMachO, KLDRFOFF offFixups, KU32 cFixups, macho_relocation_info_t **ppaFixups)
3098	{
3099	macho_relocation_info_t *paFixups;
3100	KSIZE cbFixups;
3101	int rc;
3102
3103	/* allocate the memory. */
3104	cbFixups = cFixups * sizeof(*paFixups);
3105	KLDRMODMACHO_CHECK_RETURN(cbFixups / sizeof(*paFixups) == cFixups, KLDR_ERR_SIZE_OVERFLOW);
3106	paFixups = (macho_relocation_info_t *)kHlpAlloc(cbFixups);
3107	if (!paFixups)
3108	return KERR_NO_MEMORY;
3109
3110	/* read the fixups. */
3111	rc = kRdrRead(pModMachO->pMod->pRdr, paFixups, cbFixups, offFixups);
3112	if (!rc)
3113	{
3114	*ppaFixups = paFixups;
3115
3116	/* do endian conversion if necessary. */
3117	if ( pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE_OE
3118	\|\| pModMachO->Hdr.magic == IMAGE_MACHO64_SIGNATURE_OE)
3119	{
3120	KU32 iFixup;
3121	for (iFixup = 0; iFixup < cFixups; iFixup++)
3122	{
3123	KU32 pu32 = (KU32 )&paFixups[iFixup];
3124	pu32[0] = K_E2E_U32(pu32[0]);
3125	pu32[1] = K_E2E_U32(pu32[1]);
3126	}
3127	}
3128	}
3129	else
3130	kHlpFree(paFixups);
3131	return rc;
3132	}
3133
3134
3135	/**
3136	* Maps the virgin file bits into memory if not already done.
3137	*
3138	* @returns 0 on success, non-zero kLdr status code on failure.
3139	* @param pModMachO The Mach-O module interpreter instance.
3140	*/
3141	static int kldrModMachOMapVirginBits(PKLDRMODMACHO pModMachO)
3142	{
3143	int rc = 0;
3144	if (!pModMachO->pvBits)
3145	rc = kRdrAllMap(pModMachO->pMod->pRdr, &pModMachO->pvBits);
3146	return rc;
3147	}
3148
3149
3150	/** @copydoc kLdrModCallInit */
3151	static int kldrModMachOCallInit(PKLDRMOD pMod, KUPTR uHandle)
3152	{
3153	/* later */
3154	return 0;
3155	}
3156
3157
3158	/** @copydoc kLdrModCallTerm */
3159	static int kldrModMachOCallTerm(PKLDRMOD pMod, KUPTR uHandle)
3160	{
3161	/* later */
3162	return 0;
3163	}
3164
3165
3166	/** @copydoc kLdrModCallThread */
3167	static int kldrModMachOCallThread(PKLDRMOD pMod, KUPTR uHandle, unsigned fAttachingOrDetaching)
3168	{
3169	/* Relevant for Mach-O? */
3170	return 0;
3171	}
3172
3173
3174	/** @copydoc kLdrModSize */
3175	static KLDRADDR kldrModMachOSize(PKLDRMOD pMod)
3176	{
3177	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
3178	return pModMachO->cbImage;
3179	}
3180
3181
3182	/** @copydoc kLdrModGetBits */
3183	static int kldrModMachOGetBits(PKLDRMOD pMod, void pvBits, KLDRADDR BaseAddress, PFNKLDRMODGETIMPORT pfnGetImport, void pvUser)
3184	{
3185	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
3186	KU32 i;
3187	int rc;
3188
3189	/*
3190	* Zero the entire buffer first to simplify things.
3191	*/
3192	kHlpMemSet(pvBits, 0, (KSIZE)pModMachO->cbImage);
3193
3194	/*
3195	* When possible use the segment table to load the data.
3196	* If not iterate the load commands and execute the segment / section loads.
3197	*/
3198	if (pModMachO->fMapUsingLoadCommandSections)
3199	KLDRMODMACHO_CHECK_RETURN(0, KLDR_ERR_TODO); /* deal with this if it ever occurs. */
3200	else
3201	{
3202	for (i = 0; i < pMod->cSegments; i++)
3203	{
3204	/* skip it? */
3205	if ( pMod->aSegments[i].cbFile == -1
3206	\|\| pMod->aSegments[i].offFile == -1
3207	\|\| pMod->aSegments[i].LinkAddress == NIL_KLDRADDR
3208	\|\| !pMod->aSegments[i].Alignment)
3209	continue;
3210	rc = kRdrRead(pMod->pRdr,
3211	(KU8 *)pvBits + (pMod->aSegments[i].LinkAddress - pModMachO->LinkAddress),
3212	pMod->aSegments[i].cbFile,
3213	pMod->aSegments[i].offFile);
3214	if (rc)
3215	return rc;
3216	}
3217	}
3218
3219	/*
3220	* Perform relocations.
3221	*/
3222	rc = kldrModMachORelocateBits(pMod, pvBits, BaseAddress, pModMachO->LinkAddress, pfnGetImport, pvUser);
3223	if (rc)
3224	return rc;
3225
3226	/*
3227	* Construct the global offset table if necessary, it's always the last
3228	* segment when present.
3229	*/
3230	if (pModMachO->fMakeGot)
3231	rc = kldrModMachOMakeGOT(pModMachO, pvBits, BaseAddress);
3232	return rc;
3233	}
3234
3235
3236	/**
3237	* Builds the GOT.
3238	*
3239	* Assumes the symbol table has all external symbols resolved correctly and that
3240	* the bits has been cleared up front.
3241	*/
3242	static int kldrModMachOMakeGOT(PKLDRMODMACHO pModMachO, void *pvBits, KLDRADDR NewBaseAddress)
3243	{
3244	KU32 iSym = pModMachO->cSymbols;
3245	if ( pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE
3246	\|\| pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE_OE)
3247	{
3248	macho_nlist_32_t const paSyms = (macho_nlist_32_t const )pModMachO->pvaSymbols;
3249	KU32 paGOT = (KU32 )((KU8 *)pvBits + pModMachO->GotRVA);
3250	while (iSym-- > 0)
3251	switch (paSyms[iSym].n_type & MACHO_N_TYPE)
3252	{
3253	case MACHO_N_SECT:
3254	{
3255	PKLDRMODMACHOSECT pSymSect;
3256	KLDRMODMACHO_CHECK_RETURN((KU32)paSyms[iSym].n_sect - 1 <= pModMachO->cSections, KLDR_ERR_MACHO_BAD_SYMBOL);
3257	pSymSect = &pModMachO->paSections[paSyms[iSym].n_sect - 1];
3258	paGOT[iSym] = paSyms[iSym].n_value - pSymSect->LinkAddress + pSymSect->RVA + NewBaseAddress;
3259	break;
3260	}
3261
3262	case MACHO_N_UNDF:
3263	case MACHO_N_ABS:
3264	paGOT[iSym] = paSyms[iSym].n_value;
3265	break;
3266	}
3267	}
3268	else
3269	{
3270	macho_nlist_64_t const paSyms = (macho_nlist_64_t const )pModMachO->pvaSymbols;
3271	KU64 paGOT = (KU64 )((KU8 *)pvBits + pModMachO->GotRVA);
3272	while (iSym-- > 0)
3273	switch (paSyms[iSym].n_type & MACHO_N_TYPE)
3274	{
3275	case MACHO_N_SECT:
3276	{
3277	PKLDRMODMACHOSECT pSymSect;
3278	KLDRMODMACHO_CHECK_RETURN((KU32)paSyms[iSym].n_sect - 1 <= pModMachO->cSections, KLDR_ERR_MACHO_BAD_SYMBOL);
3279	pSymSect = &pModMachO->paSections[paSyms[iSym].n_sect - 1];
3280	paGOT[iSym] = paSyms[iSym].n_value - pSymSect->LinkAddress + pSymSect->RVA + NewBaseAddress;
3281	break;
3282	}
3283
3284	case MACHO_N_UNDF:
3285	case MACHO_N_ABS:
3286	paGOT[iSym] = paSyms[iSym].n_value;
3287	break;
3288	}
3289	}
3290	return 0;
3291	}
3292
3293
3294	/** @copydoc kLdrModRelocateBits */
3295	static int kldrModMachORelocateBits(PKLDRMOD pMod, void *pvBits, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress,
3296	PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser)
3297	{
3298	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
3299	int rc;
3300
3301	/*
3302	* Call workers to do the jobs.
3303	*/
3304	if (pModMachO->Hdr.filetype == MH_OBJECT)
3305	{
3306	rc = kldrModMachOObjDoImports(pModMachO, pfnGetImport, pvUser);
3307	if (!rc)
3308	rc = kldrModMachOObjDoFixups(pModMachO, pvBits, NewBaseAddress);
3309
3310	}
3311	else
3312	rc = KLDR_ERR_TODO;
3313	/*{
3314	rc = kldrModMachODoFixups(pModMachO, pvBits, NewBaseAddress, OldBaseAddress, pfnGetImport, pvUser);
3315	if (!rc)
3316	rc = kldrModMachODoImports(pModMachO, pvBits, pfnGetImport, pvUser);
3317	}*/
3318
3319	return rc;
3320	}
3321
3322
3323	/**
3324	* The Mach-O module interpreter method table.
3325	*/
3326	KLDRMODOPS g_kLdrModMachOOps =
3327	{
3328	"Mach-O",
3329	NULL,
3330	kldrModMachOCreate,
3331	kldrModMachODestroy,
3332	kldrModMachOQuerySymbol,
3333	kldrModMachOEnumSymbols,
3334	kldrModMachOGetImport,
3335	kldrModMachONumberOfImports,
3336	NULL /* can execute one is optional */,
3337	kldrModMachOGetStackInfo,
3338	kldrModMachOQueryMainEntrypoint,
3339	NULL,
3340	NULL,
3341	kldrModMachOEnumDbgInfo,
3342	kldrModMachOHasDbgInfo,
3343	kldrModMachOMap,
3344	kldrModMachOUnmap,
3345	kldrModMachOAllocTLS,
3346	kldrModMachOFreeTLS,
3347	kldrModMachOReload,
3348	kldrModMachOFixupMapping,
3349	kldrModMachOCallInit,
3350	kldrModMachOCallTerm,
3351	kldrModMachOCallThread,
3352	kldrModMachOSize,
3353	kldrModMachOGetBits,
3354	kldrModMachORelocateBits,
3355	NULL, /** @todo mostly done */
3356	42 /* the end */
3357	};
3358

Note: See TracBrowser for help on using the repository browser.

Download in other formats: