Context Navigation

source: trunk/kLdr/kLdrModMachO.c@ 102

Last change on this file since 102 was 102, checked in by bird, 8 years ago
gcc7 warning fixes
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 143.5 KB

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

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

Download in other formats: