Context Navigation

source: trunk/kLdr/kLdrModMachO.c@ 54

Last change on this file since 54 was 54, checked in by bird, 12 years ago
Added kLdrModQueryImageUuid for Mach-O.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 141.4 KB

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

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

Download in other formats: