Context Navigation

source: trunk/kLdr/kLdrModMachO.c@ 3067

Visit:

Last change on this file since 3067 was 2977, checked in by bird, 19 years ago
fix for single segment.
File size: 86.4 KB

Rev	Line
[2952]	1	/* $Id: $ */
	2	/** @file
	3	*
	4	* kLdr - The Module Interpreter for the MACH-O format.
	5	*
	6	* Copyright (c) 2006 knut st. osmundsen <bird-kbuild-src@anduin.net>
	7	*
	8	*
	9	* This file is part of kLdr.
	10	*
	11	* kLdr is free software; you can redistribute it and/or modify
	12	* it under the terms of the GNU General Public License as published by
	13	* the Free Software Foundation; either version 2 of the License, or
	14	* (at your option) any later version.
	15	*
	16	* kLdr is distributed in the hope that it will be useful,
	17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	19	* GNU General Public License for more details.
	20	*
	21	* You should have received a copy of the GNU General Public License
	22	* along with kLdr; if not, write to the Free Software
	23	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	24	*
	25	*/
	26
	27
	28	/*******************************************************************************
	29	* Header Files *
	30	*******************************************************************************/
	31	#include <kLdr.h>
	32	#include "kLdrHlp.h"
	33	#include "kLdrInternal.h"
	34	#include "kLdrModMachO.h"
	35
	36
	37	/*******************************************************************************
	38	* Defined Constants And Macros *
	39	*******************************************************************************/
	40	/** @def KLDRMODMACHO_STRICT
	41	* Define KLDRMODMACHO_STRICT to enabled strict checks in KLDRMODMACHO. */
	42	#define KLDRMODMACHO_STRICT 1
	43
	44	/** @def KLDRMODMACHO_ASSERT
	45	* Assert that an expression is true when KLDR_STRICT is defined.
	46	*/
	47	#ifdef KLDRMODMACHO_STRICT
	48	# define KLDRMODMACHO_ASSERT(expr) kldrHlpAssert(expr)
	49	#else
	50	# define KLDRMODMACHO_ASSERT(expr) do {} while (0)
	51	#endif
	52
[2961]	53
	54	/*******************************************************************************
	55	* Structures and Typedefs *
	56	*******************************************************************************/
	57	/**
	58	* Mach-O section details.
[2952]	59	*/
[2961]	60	typedef struct KLDRMODMACHOSECT
	61	{
	62	/** The size of the section (in bytes). */
	63	KLDRSIZE cb;
[2968]	64	/** The link address of this section. */
	65	KLDRADDR LinkAddress;
[2961]	66	/** The RVA of this section. */
	67	KLDRADDR RVA;
[2963]	68	/** The file offset of this section.
[2961]	69	* This is -1 if the section doesn't have a file backing. */
[2974]	70	KLDRFOFF offFile;
[2961]	71	/** The number of fixups. */
	72	uint32_t cFixups;
	73	/** The array of fixups. (lazy loaded) */
	74	macho_relocation_info_t *paFixups;
[2963]	75	/** The file offset of the fixups for this section.
[2961]	76	* This is -1 if the section doesn't have any fixups. */
[2974]	77	KLDRFOFF offFixups;
[2962]	78	/** Mach-O section flags. */
	79	uint32_t fFlags;
	80	/** kLdr segment index. */
	81	uint32_t iSegment;
[2961]	82	/** Pointer to the Mach-O section structure. */
[2963]	83	void *pvMachoSection;
[2961]	84	} KLDRMODMACHOSECT, *PKLDRMODMACHOSECT;
[2952]	85
[2961]	86	/**
	87	* Extra per-segment info.
[2963]	88	*
[2961]	89	* This is corresponds to a kLdr segment, not a Mach-O segment!
[2952]	90	*/
[2961]	91	typedef struct KLDRMODMACHOSEG
	92	{
	93	/** The number of sections in the segment. */
	94	uint32_t cSections;
[2963]	95	/** Pointer to the sections belonging to this segment.
	96	* The array resides in the big memory chunk allocated for
[2961]	97	* the module handle, so it doesn't need freeing. */
	98	PKLDRMODMACHOSECT paSections;
[2952]	99
[2961]	100	} KLDRMODMACHOSEG, *PKLDRMODMACHOSEG;
[2952]	101
	102	/**
[2954]	103	* Instance data for the Mach-O MH_OBJECT module interpreter.
[2952]	104	* @todo interpret the other MH_* formats.
	105	*/
	106	typedef struct KLDRMODMACHO
	107	{
	108	/** Pointer to the module. (Follows the section table.) */
	109	PKLDRMOD pMod;
[2962]	110	/** Pointer to the RDR file mapping of the raw file bits. NULL if not mapped. */
[2952]	111	const void *pvBits;
	112	/** Pointer to the user mapping. */
[2962]	113	void *pvMapping;
[2952]	114
	115	/** The link address. */
	116	KLDRADDR LinkAddress;
[2955]	117	/** The size of the mapped image. */
	118	KLDRADDR cbImage;
[2956]	119	/** When set the sections in the load command segments must be used when
	120	* mapping or loading the image. */
	121	int fMapUsingLoadCommandSections;
[2952]	122
	123	/** Pointer to the load commands. (endian converted) */
	124	uint8_t *pbLoadCommands;
	125	/** The Mach-O header. (endian converted)
	126	* @remark The reserved field is only valid for real 64-bit headers. */
	127	mach_header_64_t Hdr;
	128
	129	/** The offset of the symbol table. */
[2974]	130	KLDRFOFF offSymbols;
[2952]	131	/** The number of symbols. */
	132	uint32_t cSymbols;
	133	/** The pointer to the loaded symbol table. */
[2961]	134	void *pvaSymbols;
[2952]	135	/** The offset of the string table. */
[2974]	136	KLDRFOFF offStrings;
[2952]	137	/** The size of the of the string table. */
[2962]	138	uint32_t cchStrings;
[2952]	139	/** Pointer to the loaded string table. */
[2961]	140	char *pchStrings;
[2962]	141
	142	/** The number of sections. */
	143	uint32_t cSections;
	144	/** Pointer to the section array running in parallel to the Mach-O one. */
	145	PKLDRMODMACHOSECT paSections;
	146
[2961]	147	/** Array of segments parallel to the one in KLDRMOD. */
	148	KLDRMODMACHOSEG aSegments[1];
[2952]	149	} KLDRMODMACHO, *PKLDRMODMACHO;
	150
	151
[2961]	152
[2952]	153	/*******************************************************************************
	154	* Internal Functions *
	155	*******************************************************************************/
	156	#if 0
	157	static int32_t kldrModMachONumberOfImports(PKLDRMOD pMod, const void *pvBits);
	158	#endif
[2956]	159	static int kldrModMachORelocateBits(PKLDRMOD pMod, void *pvBits, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress,
	160	PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
[2952]	161
	162	static int kldrModMachODoCreate(PKLDRRDR pRdr, PKLDRMODMACHO *ppMod);
[2954]	163	static int kldrModMachOPreParseLoadCommands(uint8_t pbLoadCommands, const mach_header_32_t pHdr, PKLDRRDR pRdr,
[2961]	164	uint32_t pcSegments, uint32_t pcSections, uint32_t *pcbStringPool);
[2952]	165	static int kldrModMachOParseLoadCommands(PKLDRMODMACHO pModMachO, char *pbStringPool, uint32_t cbStringPool);
[2962]	166	static int kldrModMachOAdjustBaseAddress(PKLDRMODMACHO pModMachO, PKLDRADDR pBaseAddress);
	167
[2961]	168	/static int kldrModMachOLoadLoadCommands(PKLDRMODMACHO pModMachO);/
[2956]	169	static int kldrModMachOLoadObjSymTab(PKLDRMODMACHO pModMachO);
[2974]	170	static int kldrModMachOLoadFixups(PKLDRMODMACHO pModMachO, KLDRFOFF offFixups, uint32_t cFixups, macho_relocation_info_t **ppaFixups);
[2963]	171	static int kldrModMachOMapVirginBits(PKLDRMODMACHO pModMachO);
[2952]	172
[2962]	173	static int kldrModMachODoQuerySymbol32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t paSyms, uint32_t cSyms, const char pchStrings,
[2963]	174	uint32_t cchStrings, KLDRADDR BaseAddress, uint32_t iSymbol, const char *pchSymbol,
[2962]	175	size_t cchSymbol, PKLDRADDR puValue, uint32_t *pfKind);
[2963]	176	static int kldrModMachODoEnumSymbols32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t *paSyms, uint32_t cSyms,
[2962]	177	const char *pchStrings, uint32_t cchStrings, KLDRADDR BaseAddress,
	178	uint32_t fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser);
[2961]	179	static int kldrModMachOObjDoImports(PKLDRMODMACHO pModMachO, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
	180	static int kldrModMachOObjDoFixups(PKLDRMODMACHO pModMachO, void *pvMapping, KLDRADDR NewBaseAddress);
[2963]	181	static int kldrModMachOFixupSectionGeneric32Bit(PKLDRMODMACHO pModMachO, uint8_t *pbSectBits, PKLDRMODMACHOSECT pFixupSect,
	182	macho_nlist_32_t *paSyms, uint32_t cSyms, KLDRADDR NewBaseAddress);
[2952]	183
[2961]	184	/static int kldrModMachODoFixups(PKLDRMODMACHO pModMachO, void pvMapping, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress);
	185	static int kldrModMachODoImports(PKLDRMODMACHO pModMachO, void pvMapping, PFNKLDRMODGETIMPORT pfnGetImport, void pvUser);*/
	186
	187
[2952]	188	/**
	189	* Create a loader module instance interpreting the executable image found
	190	* in the specified file provider instance.
	191	*
	192	* @returns 0 on success and *ppMod pointing to a module instance.
	193	* On failure, a non-zero OS specific error code is returned.
	194	* @param pOps Pointer to the registered method table.
	195	* @param pRdr The file provider instance to use.
	196	* @param offNewHdr The offset of the new header in MZ files. -1 if not found.
	197	* @param ppMod Where to store the module instance pointer.
	198	*/
[2974]	199	static int kldrModMachOCreate(PCKLDRMODOPS pOps, PKLDRRDR pRdr, KLDRFOFF offNewHdr, PPKLDRMOD ppMod)
[2952]	200	{
	201	PKLDRMODMACHO pModMachO;
	202	int rc;
	203
	204	/*
	205	* Create the instance data and do a minimal header validation.
	206	*/
	207	rc = kldrModMachODoCreate(pRdr, &pModMachO);
	208	if (!rc)
	209	{
	210	pModMachO->pMod->pOps = pOps;
	211	pModMachO->pMod->u32Magic = KLDRMOD_MAGIC;
	212	*ppMod = pModMachO->pMod;
	213	return 0;
	214	}
	215	if (pModMachO)
	216	{
	217	kldrHlpFree(pModMachO->pbLoadCommands);
	218	kldrHlpFree(pModMachO);
	219	}
	220	return rc;
	221	}
	222
	223
	224	/**
	225	* Separate function for reading creating the PE module instance to
	226	* simplify cleanup on failure.
	227	*/
	228	static int kldrModMachODoCreate(PKLDRRDR pRdr, PKLDRMODMACHO *ppModMachO)
	229	{
	230	union
	231	{
	232	mach_header_32_t Hdr32;
	233	mach_header_64_t Hdr64;
	234	} s;
	235	PKLDRMODMACHO pModMachO;
	236	PKLDRMOD pMod;
	237	uint8_t *pbLoadCommands;
	238	uint32_t cSegments;
[2961]	239	uint32_t cSections;
[2952]	240	uint32_t cbStringPool;
	241	size_t cchFilename;
	242	size_t cb;
	243	int rc;
	244	*ppModMachO = NULL;
	245
	246	/*
	247	* Read the Mach-O header.
	248	*/
	249	rc = kLdrRdrRead(pRdr, &s, sizeof(s), 0);
	250	if (rc)
	251	return rc;
	252	if (s.Hdr32.magic != IMAGE_MACHO32_SIGNATURE)
	253	{
	254	if ( s.Hdr32.magic == IMAGE_MACHO32_SIGNATURE_OE
	255	\|\| s.Hdr32.magic == IMAGE_MACHO64_SIGNATURE_OE)
	256	return KLDR_ERR_MACHO_OTHER_ENDIAN_NOT_SUPPORTED;
	257	if (s.Hdr32.magic == IMAGE_MACHO64_SIGNATURE)
	258	return KLDR_ERR_MACHO_64BIT_NOT_SUPPORTED;
	259	return KLDR_ERR_UNKNOWN_FORMAT;
	260	}
	261
	262	/* sanity checks. */
	263	if ( s.Hdr32.sizeofcmds > kLdrRdrSize(pRdr) - sizeof(mach_header_32_t)
	264	\|\| s.Hdr32.sizeofcmds < sizeof(load_command_t) * s.Hdr32.ncmds
	265	\|\| (s.Hdr32.flags & ~MH_VALID_FLAGS))
	266	return KLDR_ERR_MACHO_BAD_HEADER;
	267	switch (s.Hdr32.cputype)
	268	{
	269	case CPU_TYPE_X86:
	270	case CPU_TYPE_X86_64:
	271	break;
	272	default:
	273	return KLDR_ERR_MACHO_UNSUPPORTED_MACHINE;
	274	}
	275	if (s.Hdr32.filetype != MH_OBJECT)
	276	return KLDR_ERR_MACHO_UNSUPPORTED_FILE_TYPE;
	277
	278	/*
	279	* Read and pre-parse the load commands to figure out how many segments we'll be needing.
	280	*/
	281	pbLoadCommands = kldrHlpAlloc(s.Hdr32.sizeofcmds);
	282	if (!pbLoadCommands)
	283	return KLDR_ERR_NO_MEMORY;
	284	rc = kLdrRdrRead(pRdr, pbLoadCommands, s.Hdr32.sizeofcmds,
	285	s.Hdr32.magic == IMAGE_MACHO32_SIGNATURE
	286	\|\| s.Hdr32.magic == IMAGE_MACHO32_SIGNATURE_OE
	287	? sizeof(mach_header_32_t) : sizeof(mach_header_64_t));
	288	if (!rc)
[2961]	289	rc = kldrModMachOPreParseLoadCommands(pbLoadCommands, &s.Hdr32, pRdr, &cSegments, &cSections, &cbStringPool);
[2952]	290	if (rc)
	291	{
	292	kldrHlpFree(pbLoadCommands);
	293	return rc;
	294	}
	295
	296
	297	/*
	298	* Calc the instance size, allocate and initialize it.
	299	*/
	300	cchFilename = kLdrHlpStrLen(kLdrRdrName(pRdr));
[2963]	301	cb = KLDR_ALIGN_Z( KLDR_OFFSETOF(KLDRMODMACHO, aSegments[cSegments])
[2961]	302	+ sizeof(KLDRMODMACHOSECT) * cSections, 16)
[2952]	303	+ KLDR_OFFSETOF(KLDRMOD, aSegments[cSegments])
	304	+ cchFilename + 1
	305	+ cbStringPool;
	306	pModMachO = (PKLDRMODMACHO)kldrHlpAlloc(cb);
	307	if (!pModMachO)
	308	return KLDR_ERR_NO_MEMORY;
	309	*ppModMachO = pModMachO;
	310	pModMachO->pbLoadCommands = pbLoadCommands;
	311
	312	/* KLDRMOD */
[2961]	313	pMod = (PKLDRMOD)((uint8_t *)pModMachO + KLDR_ALIGN_Z( KLDR_OFFSETOF(KLDRMODMACHO, aSegments[cSegments])
	314	+ sizeof(KLDRMODMACHOSECT) * cSections, 16));
[2952]	315	pMod->pvData = pModMachO;
	316	pMod->pRdr = pRdr;
	317	pMod->pOps = NULL; /* set upon success. */
	318	pMod->cSegments = cSegments;
	319	pMod->cchFilename = cchFilename;
	320	pMod->pszFilename = (char *)&pMod->aSegments[pMod->cSegments];
	321	kLdrHlpMemCopy((char *)pMod->pszFilename, kLdrRdrName(pRdr), cchFilename + 1);
	322	pMod->pszName = kldrHlpGetFilename(pMod->pszFilename);
	323	pMod->cchName = cchFilename - (pMod->pszName - pMod->pszFilename);
	324	switch (s.Hdr32.cputype)
	325	{
	326	case CPU_TYPE_X86:
	327	pMod->enmArch = KLDRARCH_X86_32;
	328	pMod->enmEndian = KLDRENDIAN_LITTLE;
	329	switch (s.Hdr32.cpusubtype)
	330	{
	331	case CPU_SUBTYPE_I386_ALL: pMod->enmCpu = KLDRCPU_X86_32_BLEND; break;
	332	/case CPU_SUBTYPE_386: ^^ pMod->enmCpu = KLDRCPU_I386; break;/
	333	case CPU_SUBTYPE_486: pMod->enmCpu = KLDRCPU_I486; break;
	334	case CPU_SUBTYPE_486SX: pMod->enmCpu = KLDRCPU_I486SX; break;
	335	/case CPU_SUBTYPE_586: vv /
	336	case CPU_SUBTYPE_PENT: pMod->enmCpu = KLDRCPU_I586; break;
	337	case CPU_SUBTYPE_PENTPRO:
	338	case CPU_SUBTYPE_PENTII_M3:
	339	case CPU_SUBTYPE_PENTII_M5:
	340	case CPU_SUBTYPE_CELERON:
	341	case CPU_SUBTYPE_CELERON_MOBILE:
	342	case CPU_SUBTYPE_PENTIUM_3:
	343	case CPU_SUBTYPE_PENTIUM_3_M:
	344	case CPU_SUBTYPE_PENTIUM_3_XEON: pMod->enmCpu = KLDRCPU_I686; break;
	345	case CPU_SUBTYPE_PENTIUM_M:
	346	case CPU_SUBTYPE_PENTIUM_4:
	347	case CPU_SUBTYPE_PENTIUM_4_M:
	348	case CPU_SUBTYPE_XEON:
	349	case CPU_SUBTYPE_XEON_MP: pMod->enmCpu = KLDRCPU_P4; break;
	350	break;
	351	default:
	352	return KLDR_ERR_MACHO_UNSUPPORTED_MACHINE;
	353	}
	354	break;
	355
	356	case CPU_TYPE_X86_64:
	357	pMod->enmArch = KLDRARCH_AMD64;
	358	pMod->enmEndian = KLDRENDIAN_LITTLE;
	359	switch (s.Hdr32.cpusubtype)
	360	{
	361	case CPU_SUBTYPE_X86_64_ALL: pMod->enmCpu = KLDRCPU_AMD64_BLEND; break;
	362	default:
	363	return KLDR_ERR_MACHO_UNSUPPORTED_MACHINE;
	364	}
	365	break;
	366
	367	default:
	368	return KLDR_ERR_MACHO_UNSUPPORTED_MACHINE;
	369	}
	370
	371	pMod->enmFmt = KLDRFMT_MACHO;
	372	switch (s.Hdr32.filetype)
	373	{
	374	case MH_OBJECT:
	375	pMod->enmType = KLDRTYPE_OBJECT;
	376	break;
	377	default:
	378	return KLDR_ERR_MACHO_UNSUPPORTED_FILE_TYPE;
	379	}
	380	pMod->u32Magic = 0; /* set upon success. */
	381
	382	/* KLDRMODMACHO */
	383	pModMachO->pMod = pMod;
	384	pModMachO->pvBits = NULL;
	385	pModMachO->pvMapping = NULL;
	386	pModMachO->Hdr = s.Hdr64;
	387	if ( s.Hdr32.magic == IMAGE_MACHO32_SIGNATURE
	388	\|\| s.Hdr32.magic == IMAGE_MACHO32_SIGNATURE_OE)
	389	pModMachO->Hdr.reserved = 0;
	390	pModMachO->LinkAddress = 0;
[2955]	391	pModMachO->cbImage = 0;
[2956]	392	pModMachO->fMapUsingLoadCommandSections = 0;
[2952]	393	pModMachO->offSymbols = 0;
	394	pModMachO->cSymbols = 0;
[2961]	395	pModMachO->pvaSymbols = NULL;
[2952]	396	pModMachO->offStrings = 0;
[2962]	397	pModMachO->cchStrings = 0;
[2961]	398	pModMachO->pchStrings = NULL;
[2962]	399	pModMachO->cSections = cSections;
	400	pModMachO->paSections = (PKLDRMODMACHOSECT)&pModMachO->aSegments[pModMachO->pMod->cSegments];
[2952]	401
	402	/*
	403	* Setup the KLDRMOD segment array.
	404	*/
	405	rc = kldrModMachOParseLoadCommands(pModMachO, (char *)pMod->pszFilename + pMod->cchFilename + 1, cbStringPool);
	406	if (rc)
	407	return rc;
	408
	409	/*
	410	* We're done.
	411	*/
	412	return 0;
	413	}
	414
	415
	416	/**
	417	* Converts, validates and preparses the load commands before we carve
	418	* out the module instance.
	419	*
	420	* The conversion that's preformed is format endian to host endian.
[2961]	421	* The preparsing has to do with segment counting, section counting and string pool sizing.
[2952]	422	*
	423	* @returns 0 on success.
	424	* @returns KLDR_ERR_MACHO_* on failure.
	425	* @param pbLoadCommands The load commands to parse.
	426	* @param pHdr The header.
[2954]	427	* @param pRdr The file reader.
[2952]	428	* @param pcSegments Where to store the segment count.
[2961]	429	* @param pcSegments Where to store the section count.
[2952]	430	* @param pcbStringPool Where to store the string pool size.
	431	*/
[2954]	432	static int kldrModMachOPreParseLoadCommands(uint8_t pbLoadCommands, const mach_header_32_t pHdr, PKLDRRDR pRdr,
[2961]	433	uint32_t pcSegments, uint32_t pcSections, uint32_t *pcbStringPool)
[2952]	434	{
[2954]	435	union
	436	{
	437	uint8_t *pb;
	438	load_command_t *pLoadCmd;
	439	segment_command_32_t *pSeg32;
	440	segment_command_64_t *pSeg64;
	441	thread_command_t *pThread;
	442	symtab_command_t *pSymTab;
	443	uuid_command_t *pUuid;
	444	} u;
	445	const uint64_t cbFile = kLdrRdrSize(pRdr);
	446	uint32_t cSegments = 0;
[2961]	447	uint32_t cSections = 0;
[2954]	448	uint32_t cbStringPool = 0;
	449	uint32_t cLeft = pHdr->ncmds;
	450	uint32_t cbLeft = pHdr->sizeofcmds;
	451	uint8_t *pb = pbLoadCommands;
[2956]	452	int cSegmentCommands = 0;
	453	int cSymbolTabs = 0;
	454	int fConvertEndian = pHdr->magic == IMAGE_MACHO32_SIGNATURE_OE
	455	\|\| pHdr->magic == IMAGE_MACHO64_SIGNATURE_OE;
[2954]	456
[2952]	457	*pcSegments = 0;
[2961]	458	*pcSections = 0;
[2952]	459	*pcbStringPool = 0;
[2954]	460
	461	while (cLeft-- > 0)
	462	{
	463	u.pb = pb;
	464
	465	/*
	466	* Convert and validate command header.
	467	*/
	468	if (cbLeft < sizeof(load_command_t))
	469	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
	470	if (fConvertEndian)
	471	{
	472	u.pLoadCmd->cmd = KLDRHLP_E2E_U32(u.pLoadCmd->cmd);
	473	u.pLoadCmd->cmdsize = KLDRHLP_E2E_U32(u.pLoadCmd->cmdsize);
	474	}
	475	if (u.pLoadCmd->cmdsize > cbLeft)
	476	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
	477	cbLeft -= u.pLoadCmd->cmdsize;
	478	pb += u.pLoadCmd->cmdsize;
	479
	480	/*
	481	* Convert endian if needed, parse and validate the command.
	482	*/
	483	switch (u.pLoadCmd->cmd)
	484	{
	485	case LC_SEGMENT_32:
	486	{
	487	section_32_t *pSect;
	488	section_32_t *pFirstSect;
	489	uint32_t cSectionsLeft;
	490
	491	/* convert and verify*/
	492	if (u.pLoadCmd->cmdsize < sizeof(segment_command_32_t))
	493	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
[2955]	494	if ( pHdr->magic != IMAGE_MACHO32_SIGNATURE_OE
	495	&& pHdr->magic != IMAGE_MACHO32_SIGNATURE)
	496	return KLDR_ERR_MACHO_BIT_MIX;
[2954]	497	if (fConvertEndian)
	498	{
	499	u.pSeg32->vmaddr = KLDRHLP_E2E_U32(u.pSeg32->vmaddr);
	500	u.pSeg32->vmsize = KLDRHLP_E2E_U32(u.pSeg32->vmsize);
	501	u.pSeg32->fileoff = KLDRHLP_E2E_U32(u.pSeg32->fileoff);
	502	u.pSeg32->filesize = KLDRHLP_E2E_U32(u.pSeg32->filesize);
	503	u.pSeg32->maxprot = KLDRHLP_E2E_U32(u.pSeg32->maxprot);
	504	u.pSeg32->initprot = KLDRHLP_E2E_U32(u.pSeg32->initprot);
	505	u.pSeg32->nsects = KLDRHLP_E2E_U32(u.pSeg32->nsects);
	506	u.pSeg32->flags = KLDRHLP_E2E_U32(u.pSeg32->flags);
	507	}
	508
	509	if ( u.pSeg32->filesize
	510	&& ( u.pSeg32->fileoff > cbFile
	511	\|\| (uint64_t)u.pSeg32->fileoff + u.pSeg32->filesize > cbFile))
	512	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
	513	if (!u.pSeg32->filesize && u.pSeg32->fileoff)
	514	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
	515	if (u.pSeg32->vmsize < u.pSeg32->filesize)
	516	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
	517	if ((u.pSeg32->maxprot & u.pSeg32->initprot) != u.pSeg32->initprot)
	518	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
	519	if (u.pSeg32->flags & ~(SG_HIGHVM \| SG_FVMLIB \| SG_NORELOC \| SG_PROTECTED_VERSION_1))
	520	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
	521	if (u.pSeg32->nsects * sizeof(section_32_t) > u.pLoadCmd->cmdsize - sizeof(segment_command_32_t))
	522	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
[2955]	523	if ( pHdr->filetype == MH_OBJECT
	524	&& cSegmentCommands > 0)
	525	return KLDR_ERR_MACHO_BAD_OBJECT_FILE;
	526	cSegmentCommands++;
[2954]	527
[2963]	528	/*
	529	* convert, validate and parse the sections.
[2954]	530	*/
	531	cSectionsLeft = u.pSeg32->nsects;
	532	pFirstSect = pSect = (section_32_t *)(u.pSeg32 + 1);
	533	while (cSectionsLeft-- > 0)
	534	{
	535	int fFileBits;
	536
	537	if (fConvertEndian)
	538	{
	539	pSect->addr = KLDRHLP_E2E_U32(pSect->addr);
	540	pSect->size = KLDRHLP_E2E_U32(pSect->size);
	541	pSect->offset = KLDRHLP_E2E_U32(pSect->offset);
	542	pSect->align = KLDRHLP_E2E_U32(pSect->align);
	543	pSect->reloff = KLDRHLP_E2E_U32(pSect->reloff);
	544	pSect->nreloc = KLDRHLP_E2E_U32(pSect->nreloc);
	545	pSect->flags = KLDRHLP_E2E_U32(pSect->flags);
	546	pSect->reserved1 = KLDRHLP_E2E_U32(pSect->reserved1);
	547	pSect->reserved2 = KLDRHLP_E2E_U32(pSect->reserved2);
	548	}
	549
	550	/* validate */
	551	switch (pSect->flags & SECTION_TYPE)
	552	{
	553	case S_ZEROFILL:
	554	if (pSect->reserved1 \|\| pSect->reserved2)
	555	return KLDR_ERR_MACHO_BAD_SECTION;
	556	fFileBits = 0;
	557	break;
	558	case S_REGULAR:
	559	case S_CSTRING_LITERALS:
[2963]	560	case S_COALESCED:
[2964]	561	case S_4BYTE_LITERALS:
	562	case S_8BYTE_LITERALS:
	563	case S_16BYTE_LITERALS:
[2954]	564	if (pSect->reserved1 \|\| pSect->reserved2)
	565	return KLDR_ERR_MACHO_BAD_SECTION;
	566	fFileBits = 1;
	567	break;
	568
	569	case S_LITERAL_POINTERS:
	570	case S_INTERPOSING:
	571	case S_GB_ZEROFILL:
	572	case S_NON_LAZY_SYMBOL_POINTERS:
	573	case S_LAZY_SYMBOL_POINTERS:
	574	case S_SYMBOL_STUBS:
	575	case S_MOD_INIT_FUNC_POINTERS:
	576	case S_MOD_TERM_FUNC_POINTERS:
	577	return KLDR_ERR_MACHO_UNSUPPORTED_SECTION;
	578
	579	default:
	580	return KLDR_ERR_MACHO_UNKNOWN_SECTION;
	581	}
	582	if (pSect->flags & ~( S_ATTR_PURE_INSTRUCTIONS \| S_ATTR_NO_TOC \| S_ATTR_STRIP_STATIC_SYMS
	583	\| S_ATTR_NO_DEAD_STRIP \| S_ATTR_LIVE_SUPPORT \| S_ATTR_SELF_MODIFYING_CODE
	584	\| S_ATTR_DEBUG \| S_ATTR_SOME_INSTRUCTIONS \| S_ATTR_EXT_RELOC
	585	\| S_ATTR_LOC_RELOC \| SECTION_TYPE))
	586	return KLDR_ERR_MACHO_BAD_SECTION;
	587	if ( pSect->addr - u.pSeg32->vmaddr > u.pSeg32->vmsize
	588	\|\| pSect->addr - u.pSeg32->vmaddr + pSect->size > u.pSeg32->vmsize)
	589	return KLDR_ERR_MACHO_BAD_SECTION;
	590	if ( pSect->align >= 31
	591	\|\| (((1 << pSect->align) - 1) & pSect->addr)
	592	\|\| (((1 << pSect->align) - 1) & u.pSeg32->vmaddr))
	593	return KLDR_ERR_MACHO_BAD_SECTION;
[2963]	594	if ( fFileBits
[2954]	595	&& ( pSect->offset > cbFile
	596	\|\| (uint64_t)pSect->offset + pSect->size > cbFile))
	597	return KLDR_ERR_MACHO_BAD_SECTION;
	598	if (!fFileBits && pSect->offset)
	599	return KLDR_ERR_MACHO_BAD_SECTION;
	600	if (!pSect->nreloc && pSect->reloff)
	601	return KLDR_ERR_MACHO_BAD_SECTION;
[2963]	602	if ( pSect->nreloc
[2954]	603	&& ( pSect->reloff > cbFile
[2974]	604	\|\| (uint64_t)pSect->reloff + (KLDRFOFF)pSect->nreloc * sizeof(macho_relocation_info_t)) > cbFile)
[2954]	605	return KLDR_ERR_MACHO_BAD_SECTION;
	606
	607
	608	/* count segments and strings */
	609	switch (pHdr->filetype)
	610	{
	611	case MH_OBJECT:
	612	{
[2977]	613	cSections++;
	614
[2954]	615	/* Don't load debug symbols. (test this) */
	616	if (pSect->flags & S_ATTR_DEBUG)
	617	break;
	618
	619	/* a new segment? */
[2955]	620	if ( !cSegments
[2954]	621	\|\| kLdrHlpStrNComp(pSect->segname, (pSect - 1)->segname, sizeof(pSect->segname)))
	622	{
[2969]	623	#if 0 /** @todo This doesn't work because of BSS. */
[2954]	624	/* verify that the linker/assembler has ordered sections correctly. */
	625	section_32_t *pCur = (pSect - 2);
	626	while ((uintptr_t)pCur >= (uintptr_t)pFirstSect)
	627	{
	628	if (!kLdrHlpStrNComp(pCur->segname, pSect->segname, sizeof(pSect->segname)))
	629	return KLDR_ERR_MACHO_BAD_SECTION_ORDER;
	630	pCur--;
	631	}
[2969]	632	#endif
[2954]	633
	634	/* ok. count it and the string. */
	635	cSegments++;
[2955]	636	cbStringPool += kLdrHlpStrNLen(&pSect->segname[0], sizeof(pSect->segname)) + 1;
[2954]	637	}
	638	break;
	639	}
	640
	641	default:
	642	return KLDR_ERR_INVALID_PARAMETER;
	643	}
	644
	645	/* next */
	646	pSect++;
	647	}
	648	break;
	649	}
	650
[2955]	651	/*case LC_SEGMENT_64:
[2963]	652	copy 32-bit code
[2954]	653	break;
[2955]	654	*/
[2954]	655
	656	case LC_SYMTAB:
[2961]	657	{
	658	size_t cbSym;
[2954]	659	if (fConvertEndian)
	660	{
	661	u.pSymTab->symoff = KLDRHLP_E2E_U32(u.pSymTab->symoff);
	662	u.pSymTab->nsyms = KLDRHLP_E2E_U32(u.pSymTab->nsyms);
	663	u.pSymTab->stroff = KLDRHLP_E2E_U32(u.pSymTab->stroff);
	664	u.pSymTab->strsize = KLDRHLP_E2E_U32(u.pSymTab->strsize);
	665	}
	666
	667	/* verify */
[2961]	668	cbSym = pHdr->magic == IMAGE_MACHO32_SIGNATURE
	669	\|\| pHdr->magic == IMAGE_MACHO32_SIGNATURE_OE
[2963]	670	? sizeof(macho_nlist_32_t)
[2961]	671	: sizeof(macho_nlist_64_t);
[2954]	672	if ( u.pSymTab->symoff >= cbFile
[2961]	673	\|\| (uint64_t)u.pSymTab->symoff + u.pSymTab->nsyms * cbSym > kLdrRdrSize(pRdr))
[2954]	674	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
	675	if ( u.pSymTab->stroff >= cbFile
	676	\|\| (uint64_t)u.pSymTab->stroff + u.pSymTab->strsize > cbFile)
	677	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
[2956]	678
	679	/* only one string in objects, please. */
	680	cSymbolTabs++;
	681	if ( pHdr->filetype == MH_OBJECT
	682	&& cSymbolTabs != 1)
	683	return KLDR_ERR_MACHO_BAD_OBJECT_FILE;
[2954]	684	break;
[2961]	685	}
[2954]	686
[2963]	687	case LC_DYSYMTAB:
	688	/** @todo deal with this! */
	689	break;
	690
[2954]	691	case LC_THREAD:
	692	case LC_UNIXTHREAD:
	693	{
	694	uint32_t pu32 = (uint32_t )(u.pb + sizeof(load_command_t));
	695	uint32_t cItemsLeft = (u.pThread->cmdsize - sizeof(load_command_t)) / sizeof(uint32_t);
	696	while (cItemsLeft)
	697	{
	698	/* convert & verify header items ([0] == flavor, [1] == uint32_t count). */
	699	if (cItemsLeft < 2)
	700	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
	701	if (fConvertEndian)
	702	{
	703	pu32[0] = KLDRHLP_E2E_U32(pu32[0]);
	704	pu32[1] = KLDRHLP_E2E_U32(pu32[1]);
	705	}
	706	if (pu32[1] + 2 > cItemsLeft)
	707	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
	708
	709	/* convert & verify according to flavor. */
	710	switch (pu32[0])
	711	{
	712	/** @todo */
	713	default:
	714	break;
	715	}
	716
	717	/* next */
	718	cItemsLeft -= pu32[1] + 2;
	719	pu32 += pu32[1] + 2;
	720	}
	721	break;
	722	}
	723
	724	case LC_UUID:
	725	if (u.pUuid->cmdsize != sizeof(uuid_command_t))
	726	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
	727	/** @todo Check anything here need converting? */
	728	break;
	729
[2955]	730	case LC_SEGMENT_64:
[2954]	731	case LC_LOADFVMLIB:
	732	case LC_IDFVMLIB:
	733	case LC_IDENT:
	734	case LC_FVMFILE:
	735	case LC_PREPAGE:
	736	case LC_LOAD_DYLIB:
	737	case LC_ID_DYLIB:
	738	case LC_LOAD_DYLINKER:
	739	case LC_ID_DYLINKER:
	740	case LC_PREBOUND_DYLIB:
	741	case LC_ROUTINES:
	742	case LC_ROUTINES_64:
	743	case LC_SUB_FRAMEWORK:
	744	case LC_SUB_UMBRELLA:
	745	case LC_SUB_CLIENT:
	746	case LC_SUB_LIBRARY:
	747	case LC_TWOLEVEL_HINTS:
	748	case LC_PREBIND_CKSUM:
	749	case LC_LOAD_WEAK_DYLIB:
	750	case LC_SYMSEG:
	751	return KLDR_ERR_MACHO_UNSUPPORTED_LOAD_COMMAND;
	752
	753	default:
	754	return KLDR_ERR_MACHO_UNKNOWN_LOAD_COMMAND;
	755	}
	756	}
	757
[2955]	758	/* be strict. */
[2954]	759	if (cbLeft)
	760	return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
	761
[2955]	762	switch (pHdr->filetype)
	763	{
	764	case MH_OBJECT:
	765	if (!cSegments)
	766	return KLDR_ERR_MACHO_BAD_OBJECT_FILE;
	767	break;
	768	}
	769
[2954]	770	*pcSegments = cSegments;
[2961]	771	*pcSections = cSections;
[2955]	772	*pcbStringPool = cbStringPool;
[2954]	773
[2952]	774	return 0;
	775	}
	776
	777
	778	/**
	779	* Parses the load commands after we've carved out the module instance.
	780	*
	781	* This fills in the segment table and perhaps some other properties.
	782	*
	783	* @returns 0 on success.
	784	* @returns KLDR_ERR_MACHO_* on failure.
	785	* @param pModMachO The module.
	786	* @param pbStringPool The string pool
	787	* @param cbStringPool The size of the string pool.
	788	*/
	789	static int kldrModMachOParseLoadCommands(PKLDRMODMACHO pModMachO, char *pbStringPool, uint32_t cbStringPool)
	790	{
[2955]	791	union
	792	{
	793	const uint8_t *pb;
	794	const load_command_t *pLoadCmd;
	795	const segment_command_32_t *pSeg32;
	796	const segment_command_64_t *pSeg64;
	797	const symtab_command_t *pSymTab;
	798	} u;
	799	uint32_t cLeft = pModMachO->Hdr.ncmds;
	800	uint32_t cbLeft = pModMachO->Hdr.sizeofcmds;
	801	const uint8_t *pb = pModMachO->pbLoadCommands;
	802	int fFirstSegment = 1;
	803	PKLDRSEG pSeg = &pModMachO->pMod->aSegments[0];
[2961]	804	PKLDRMODMACHOSEG pSegExtra = &pModMachO->aSegments[0];
[2962]	805	PKLDRMODMACHOSECT pSectExtra = pModMachO->paSections;
[2955]	806	const uint32_t cSegments = pModMachO->pMod->cSegments;
	807	uint32_t i;
	808
	809	while (cLeft-- > 0)
	810	{
	811	u.pb = pb;
	812	cbLeft -= u.pLoadCmd->cmdsize;
	813	pb += u.pLoadCmd->cmdsize;
	814
	815	/*
	816	* Convert endian if needed, parse and validate the command.
	817	*/
	818	switch (u.pLoadCmd->cmd)
	819	{
	820	case LC_SEGMENT_32:
	821	{
	822	section_32_t *pSect;
	823	section_32_t *pFirstSect;
	824	uint32_t cSectionsLeft;
	825
	826	pModMachO->LinkAddress = u.pSeg32->vmaddr;
	827
[2963]	828	/*
	829	* convert, validate and parse the sections.
[2955]	830	*/
	831	cSectionsLeft = u.pSeg32->nsects;
	832	pFirstSect = pSect = (section_32_t *)(u.pSeg32 + 1);
	833	while (cSectionsLeft-- > 0)
	834	{
	835	switch (pModMachO->Hdr.filetype)
	836	{
	837	case MH_OBJECT:
	838	{
[2962]	839	/* Section data extract. */
	840	pSectExtra->cb = pSect->size;
	841	pSectExtra->RVA = pSect->addr;
[2968]	842	pSectExtra->LinkAddress = pSect->addr;
[2962]	843	pSectExtra->offFile = pSect->offset ? pSect->offset : -1;
	844	pSectExtra->cFixups = pSect->nreloc;
	845	pSectExtra->paFixups = NULL;
	846	pSectExtra->offFixups = pSect->nreloc ? pSect->reloff : -1;
	847	pSectExtra->fFlags = pSect->flags;
	848	pSectExtra->iSegment = pSegExtra - &pModMachO->aSegments[0];
	849	pSectExtra->pvMachoSection = pSect;
	850
	851	/* Don't load debug symbols. (test this!) */
[2955]	852	if (pSect->flags & S_ATTR_DEBUG)
[2977]	853	{
	854	pSectExtra++;
	855	/** @todo */
[2955]	856	break;
[2977]	857	}
[2955]	858
	859	if ( fFirstSegment
	860	\|\| kLdrHlpStrNComp(pSect->segname, (pSect - 1)->segname, sizeof(pSect->segname)))
	861	{
[2961]	862	/* close the previous segment */
[2962]	863	if (pSegExtra != &pModMachO->aSegments[0])
[2961]	864	pSegExtra[-1].cSections = pSectExtra - pSegExtra[-1].paSections;
	865
[2955]	866	/* new segment. */
	867	pSeg->pvUser = NULL;
	868	pSeg->pchName = pbStringPool;
	869	pSeg->cchName = (uint32_t)kLdrHlpStrNLen(&pSect->segname[0], sizeof(pSect->sectname));
	870	kLdrHlpMemCopy(pbStringPool, &pSect->segname[0], pSeg->cchName);
	871	pbStringPool += pSeg->cchName;
	872	*pbStringPool++ = '\0';
	873	pSeg->SelFlat = 0;
	874	pSeg->Sel16bit = 0;
	875	pSeg->fFlags = 0;
	876	pSeg->enmProt = KLDRPROT_EXECUTE_WRITECOPY; /** @todo fixme! */
	877	pSeg->cb = pSect->size;
	878	pSeg->Alignment = (1 << pSect->align);
	879	pSeg->LinkAddress = pSect->addr;
	880	pSeg->offFile = pSect->offset ? pSect->offset : -1;
	881	pSeg->cbFile = pSect->offset ? pSect->size : -1;
	882	pSeg->RVA = pSect->addr - pModMachO->LinkAddress;
	883	pSeg->cbMapped = 0;
	884	pSeg->MapAddress = 0;
	885
[2961]	886	pSegExtra->cSections = 0;
	887	pSegExtra->paSections = pSectExtra;
	888
[2955]	889	pSeg++;
[2961]	890	pSegExtra++;
[2955]	891	fFirstSegment = 0;
	892	}
[2961]	893	else
[2955]	894	{
	895	/* update exiting segment */
	896	if (pSeg[-1].Alignment < (1 << pSect->align))
	897	pSeg[-1].Alignment = (1 << pSect->align);
	898	if (pSect->addr < pSeg[-1].LinkAddress)
	899	return KLDR_ERR_MACHO_BAD_SECTION; /** @todo move up! */
	900
[2963]	901	/* If there are file bits, ensure they are in the current flow.
[2956]	902	(yes, we are very very careful here, I know.) */
[2963]	903	if ( pSect->offset
[2955]	904	&& pSeg[-1].cbFile == pSeg[-1].cb)
	905	{
[2956]	906	int fOk = pSeg[-1].offFile + (pSect->addr - pSeg[-1].LinkAddress) == pSect->offset
	907	&& pSect[-1].offset
	908	&& pSeg[-1].offFile + pSeg[-1].cbFile == pSect[-1].offset + pSect[-1].size;
	909	/* more checks? */
	910	if (fOk)
[2974]	911	pSeg[-1].cbFile = (KLDRFOFF)(pSect->addr - pSeg[-1].LinkAddress) + pSect->size;
[2963]	912	else
[2955]	913	{
[2963]	914
[2955]	915	pSeg[-1].cbFile = pSeg[-1].offFile = -1;
[2956]	916	pModMachO->fMapUsingLoadCommandSections = 1;
[2955]	917	}
	918	}
	919	pSeg[-1].cb = pSect->addr - pSeg[-1].LinkAddress + pSect->size;
	920
	921	/** @todo update the protection... */
	922	}
[2961]	923	pSectExtra++;
[2955]	924	break;
	925	}
	926
	927	default:
	928	return KLDR_ERR_INVALID_PARAMETER;
	929	}
	930
	931	/* next */
	932	pSect++;
	933	}
	934	break;
	935	}
	936
[2956]	937	case LC_SYMTAB:
	938	switch (pModMachO->Hdr.filetype)
	939	{
	940	case MH_OBJECT:
	941	pModMachO->offSymbols = u.pSymTab->symoff;
	942	pModMachO->cSymbols = u.pSymTab->nsyms;
	943	pModMachO->offStrings = u.pSymTab->stroff;
[2962]	944	pModMachO->cchStrings = u.pSymTab->strsize;
[2956]	945	break;
	946	}
	947	break;
	948
[2955]	949	default:
	950	break;
[2956]	951	} /* command switch */
	952	} /* while more commands */
[2955]	953
[2961]	954	/*
	955	* Close the last segment (if any).
	956	*/
[2977]	957	if (pSegExtra != &pModMachO->aSegments[0])
[2961]	958	pSegExtra[-1].cSections = pSectExtra - pSegExtra[-1].paSections;
	959
[2963]	960	/*
[2955]	961	* Adjust mapping addresses calculating the image size.
	962	*/
	963	pSeg = &pModMachO->pMod->aSegments[0];
	964	switch (pModMachO->Hdr.filetype)
	965	{
	966	case MH_OBJECT:
	967	{
	968	KLDRADDR cb1;
	969	size_t cb2;
	970
	971	for (i = 0; i < cSegments - 1; i++)
	972	{
	973	cb1 = pSeg[i + 1].LinkAddress - pSeg[i].LinkAddress;
	974	cb2 = (size_t)cb1;
	975	pSeg[i].cbMapped = cb2 == cb1 ? cb2 : ~(size_t)0;
	976	}
	977	cb1 = KLDR_ALIGN_ADDR(pSeg[i].cb, pSeg[i].Alignment);
	978	cb2 = (size_t)cb1;
	979	pSeg[i].cbMapped = cb2 == cb1 ? cb2 : ~(size_t)0;
	980
	981	pModMachO->cbImage = pSeg[i].RVA + cb1;
	982	break;
	983	}
	984	}
	985
[2952]	986	return 0;
	987	}
	988
	989
	990	/** @copydoc KLDRMODOPS::pfnDestroy */
	991	static int kldrModMachODestroy(PKLDRMOD pMod)
	992	{
	993	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
	994	int rc = 0;
[2961]	995	uint32_t i, j;
[2952]	996	KLDRMODMACHO_ASSERT(!pModMachO->pvMapping);
	997
[2961]	998	i = pMod->cSegments;
	999	while (i-- > 0)
	1000	{
	1001	j = pModMachO->aSegments[i].cSections;
	1002	while (j-- > 0)
	1003	{
	1004	kldrHlpFree(pModMachO->aSegments[i].paSections[j].paFixups);
	1005	pModMachO->aSegments[i].paSections[j].paFixups = NULL;
	1006	}
	1007	}
	1008
[2952]	1009	if (pMod->pRdr)
	1010	{
	1011	rc = kLdrRdrClose(pMod->pRdr);
	1012	pMod->pRdr = NULL;
	1013	}
	1014	pMod->u32Magic = 0;
	1015	pMod->pOps = NULL;
	1016	kldrHlpFree(pModMachO->pbLoadCommands);
	1017	pModMachO->pbLoadCommands = NULL;
[2961]	1018	kldrHlpFree(pModMachO->pchStrings);
	1019	pModMachO->pchStrings = NULL;
	1020	kldrHlpFree(pModMachO->pvaSymbols);
	1021	pModMachO->pvaSymbols = NULL;
[2952]	1022	kldrHlpFree(pModMachO);
	1023	return rc;
	1024	}
	1025
	1026
	1027	/**
[2962]	1028	* Gets the right base address.
[2952]	1029	*
[2962]	1030	* @returns 0 on success.
	1031	* @returns A non-zero status code if the BaseAddress isn't right.
	1032	* @param pModMachO The interpreter module instance
	1033	* @param pBaseAddress The base address, IN & OUT. Optional.
[2952]	1034	*/
[2962]	1035	static int kldrModMachOAdjustBaseAddress(PKLDRMODMACHO pModMachO, PKLDRADDR pBaseAddress)
[2952]	1036	{
	1037	/*
[2962]	1038	* Adjust the base address.
[2952]	1039	*/
[2962]	1040	if (*pBaseAddress == KLDRMOD_BASEADDRESS_MAP)
	1041	*pBaseAddress = pModMachO->pMod->aSegments[0].MapAddress;
	1042	else if (*pBaseAddress == KLDRMOD_BASEADDRESS_LINK)
	1043	*pBaseAddress = pModMachO->LinkAddress;
[2952]	1044
	1045	return 0;
	1046	}
	1047
	1048
[2962]	1049
	1050	/** @copydoc kLdrModQuerySymbol */
	1051	static int kldrModMachOQuerySymbol(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, uint32_t iSymbol,
	1052	const char pchSymbol, size_t cchSymbol, const char pszVersion,
	1053	PFNKLDRMODGETIMPORT pfnGetForwarder, void pvUser, PKLDRADDR puValue, uint32_t pfKind)
[2952]	1054	{
[2962]	1055	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
	1056	int rc;
[2952]	1057
	1058	/*
[2962]	1059	* Resolve defaults.
[2952]	1060	*/
[2962]	1061	rc = kldrModMachOAdjustBaseAddress(pModMachO, &BaseAddress);
[2952]	1062	if (rc)
	1063	return rc;
	1064
	1065	/*
[2962]	1066	* Refuse segmented requests for now.
[2952]	1067	*/
[2963]	1068	if ( pfKind
[2962]	1069	&& (*pfKind & KLDRSYMKIND_REQ_TYPE_MASK) != KLDRSYMKIND_REQ_FLAT)
	1070	return KLDR_ERR_TODO;
	1071
	1072	/*
	1073	* Take action according to file type.
	1074	*/
	1075	if (pModMachO->Hdr.filetype == MH_OBJECT)
[2952]	1076	{
[2962]	1077	rc = kldrModMachOLoadObjSymTab(pModMachO);
	1078	if (!rc)
	1079	{
	1080	if ( pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE
	1081	\|\| pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE_OE)
[2963]	1082	rc = kldrModMachODoQuerySymbol32Bit(pModMachO, (macho_nlist_32_t *)pModMachO->pvaSymbols, pModMachO->cSymbols,
	1083	pModMachO->pchStrings, pModMachO->cchStrings, BaseAddress, iSymbol, pchSymbol,
[2962]	1084	cchSymbol, puValue, pfKind);
	1085	else
	1086	rc = KLDR_ERR_TODO; /** @todo duplicate kldrModMachOQuerySymbol32 for parsing 64-bit symbols when everything is working. */
[2963]	1087	/rc = kldrModMachODoQuerySymbol64Bit(pModMachO, (macho_nlist_64_t )pModMachO->pvaSymbols, pModMachO->cSymbols,
	1088	pModMachO->pchStrings, pModMachO->cchStrings, BaseAddress, iSymbol, pchSymbol,
[2962]	1089	cchSymbol, puValue, pfKind);*/
	1090
	1091	}
[2952]	1092	}
[2962]	1093	else
	1094	rc = KLDR_ERR_TODO;
[2952]	1095
[2962]	1096	return rc;
[2952]	1097	}
	1098
	1099
[2962]	1100
[2952]	1101	/**
[2962]	1102	* Lookup a symbol in a 32-bit symbol table.
[2963]	1103	*
[2962]	1104	* @returns See kLdrModQuerySymbol.
[2963]	1105	* @param pModMachO
[2962]	1106	* @param paSyms Pointer to the symbol table.
	1107	* @param cSyms Number of symbols in the table.
	1108	* @param pchStrings Pointer to the string table.
	1109	* @param cchStrings Size of the string table.
[2963]	1110	* @param BaseAddress Adjusted base address, see kLdrModQuerySymbol.
[2962]	1111	* @param iSymbol See kLdrModQuerySymbol.
	1112	* @param pchSymbol See kLdrModQuerySymbol.
	1113	* @param cchSymbol See kLdrModQuerySymbol.
	1114	* @param puValue See kLdrModQuerySymbol.
	1115	* @param pfKind See kLdrModQuerySymbol.
[2952]	1116	*/
[2962]	1117	static int kldrModMachODoQuerySymbol32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t paSyms, uint32_t cSyms, const char pchStrings,
	1118	uint32_t cchStrings, KLDRADDR BaseAddress, uint32_t iSymbol, const char *pchSymbol, size_t cchSymbol,
	1119	PKLDRADDR puValue, uint32_t *pfKind)
[2952]	1120	{
	1121	/*
[2962]	1122	* Find a valid symbol matching the search criteria.
[2952]	1123	*/
[2962]	1124	if (iSymbol == NIL_KLDRMOD_SYM_ORDINAL)
[2952]	1125	{
[2962]	1126	/* simplify validation. */
	1127	if (cchStrings <= cchSymbol)
	1128	return KLDR_ERR_SYMBOL_NOT_FOUND;
	1129	cchStrings -= cchSymbol;
	1130
[2963]	1131	/* external symbols are usually at the end, so search the other way. */
	1132	for (iSymbol = cSyms - 1; iSymbol != UINT32_MAX; iSymbol--)
[2962]	1133	{
	1134	const char *psz;
	1135
	1136	/* Skip irrellevant and non-public symbols. */
	1137	if (paSyms[iSymbol].n_type & MACHO_N_STAB)
	1138	continue;
	1139	if ((paSyms[iSymbol].n_type & MACHO_N_TYPE) == MACHO_N_UNDF)
	1140	continue;
	1141	if (!(paSyms[iSymbol].n_type & MACHO_N_EXT)) /??/
	1142	continue;
	1143	if (paSyms[iSymbol].n_type & MACHO_N_PEXT) /??/
	1144	continue;
[2963]	1145
[2962]	1146	/* get name */
[2963]	1147	if (!paSyms[iSymbol].n_un.n_strx)
[2962]	1148	continue;
	1149	if ((uint32_t)paSyms[iSymbol].n_un.n_strx >= cchStrings)
	1150	continue;
	1151	psz = &pchStrings[paSyms[iSymbol].n_un.n_strx];
	1152	if (psz[cchSymbol])
	1153	continue;
	1154	if (kLdrHlpMemComp(psz, pchSymbol, cchSymbol))
	1155	continue;
	1156
	1157	/* match! */
	1158	break;
	1159	}
[2963]	1160	if (iSymbol == UINT32_MAX)
[2962]	1161	return KLDR_ERR_SYMBOL_NOT_FOUND;
[2952]	1162	}
[2962]	1163	else
	1164	{
	1165	if (iSymbol >= cSyms)
	1166	return KLDR_ERR_SYMBOL_NOT_FOUND;
	1167	if (paSyms[iSymbol].n_type & MACHO_N_STAB)
	1168	return KLDR_ERR_SYMBOL_NOT_FOUND;
	1169	if ((paSyms[iSymbol].n_type & MACHO_N_TYPE) == MACHO_N_UNDF)
	1170	return KLDR_ERR_SYMBOL_NOT_FOUND;
	1171	}
[2952]	1172
[2963]	1173	/*
[2962]	1174	* Calc the return values.
[2952]	1175	*/
[2962]	1176	if (pfKind)
[2952]	1177	{
[2963]	1178	if ( pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE
[2962]	1179	\|\| pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE_OE)
	1180	*pfKind = KLDRSYMKIND_32BIT \| KLDRSYMKIND_NO_TYPE;
[2952]	1181	else
[2962]	1182	*pfKind = KLDRSYMKIND_64BIT \| KLDRSYMKIND_NO_TYPE;
	1183	if (paSyms[iSymbol].n_desc & N_WEAK_DEF)
	1184	*pfKind \|= KLDRSYMKIND_WEAK;
	1185	}
	1186
	1187	switch (paSyms[iSymbol].n_type & MACHO_N_TYPE)
	1188	{
	1189	case MACHO_N_SECT:
[2952]	1190	{
[2962]	1191	PKLDRMODMACHOSECT pSect;
	1192	KLDRADDR RVA;
	1193	if ((uint32_t)(paSyms[iSymbol].n_sect - 1) >= pModMachO->cSections)
	1194	return KLDR_ERR_MACHO_BAD_SYMBOL;
	1195	pSect = &pModMachO->paSections[paSyms[iSymbol].n_sect - 1];
	1196
	1197	RVA = paSyms[iSymbol].n_value - pModMachO->LinkAddress;
	1198	if (RVA - pSect->RVA >= pSect->cb)
	1199	return KLDR_ERR_MACHO_BAD_SYMBOL;
	1200	if (puValue)
	1201	*puValue = RVA + BaseAddress;
	1202
[2963]	1203	if ( pfKind
[2962]	1204	&& (pSect->fFlags & (S_ATTR_PURE_INSTRUCTIONS \| S_ATTR_SELF_MODIFYING_CODE)))
	1205	pfKind = (pfKind & ~KLDRSYMKIND_TYPE_MASK) \| KLDRSYMKIND_CODE;
	1206	break;
[2952]	1207	}
[2962]	1208
	1209	case MACHO_N_ABS:
	1210	if (puValue)
	1211	*puValue = paSyms[iSymbol].n_value;
	1212	/*if (pfKind)
	1213	pfKind \|= KLDRSYMKIND_ABS;*/
	1214	break;
	1215
	1216	case MACHO_N_PBUD:
	1217	case MACHO_N_INDR:
	1218	/** @todo implement indirect and prebound symbols. */
	1219	default:
	1220	KLDRMODMACHO_ASSERT(0);
	1221	return KLDR_ERR_TODO;
[2952]	1222	}
	1223
	1224	return 0;
	1225	}
	1226
	1227
[2962]	1228	/** @copydoc kLdrModEnumSymbols */
	1229	static int kldrModMachOEnumSymbols(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress,
	1230	uint32_t fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
[2952]	1231	{
[2962]	1232	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
	1233	int rc;
[2952]	1234
	1235	/*
[2962]	1236	* Resolve defaults.
[2952]	1237	*/
[2962]	1238	rc = kldrModMachOAdjustBaseAddress(pModMachO, &BaseAddress);
[2952]	1239	if (rc)
	1240	return rc;
	1241
[2962]	1242	/*
	1243	* Take action according to file type.
	1244	*/
	1245	if (pModMachO->Hdr.filetype == MH_OBJECT)
[2952]	1246	{
[2962]	1247	rc = kldrModMachOLoadObjSymTab(pModMachO);
	1248	if (!rc)
[2952]	1249	{
[2962]	1250	if ( pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE
	1251	\|\| pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE_OE)
[2963]	1252	rc = kldrModMachODoEnumSymbols32Bit(pModMachO, (macho_nlist_32_t *)pModMachO->pvaSymbols, pModMachO->cSymbols,
	1253	pModMachO->pchStrings, pModMachO->cchStrings, BaseAddress,
[2962]	1254	fFlags, pfnCallback, pvUser);
[2952]	1255	else
[2962]	1256	rc = KLDR_ERR_TODO; /** @todo duplicate kldrModMachOQuerySymbol32 for parsing 64-bit symbols when everything is working. */
[2963]	1257	/rc = kldrModMachODoEnumSymbols32Bit(pModMachO, (macho_nlist_32_t )pModMachO->pvaSymbols, pModMachO->cSymbols,
[2962]	1258	pModMachO->pchStrings, pModMachO->cchStrings, BaseAddress, pfnCallback, pvUser);*/
[2952]	1259	}
	1260	}
[2962]	1261	else
	1262	rc = KLDR_ERR_TODO;
[2952]	1263
[2962]	1264	return rc;
[2952]	1265	}
	1266
	1267
[2962]	1268	/**
	1269	* Enum a 32-bit symbol table.
[2963]	1270	*
[2962]	1271	* @returns See kLdrModQuerySymbol.
[2963]	1272	* @param pModMachO
[2962]	1273	* @param paSyms Pointer to the symbol table.
	1274	* @param cSyms Number of symbols in the table.
	1275	* @param pchStrings Pointer to the string table.
	1276	* @param cchStrings Size of the string table.
[2963]	1277	* @param BaseAddress Adjusted base address, see kLdrModEnumSymbols.
[2962]	1278	* @param fFlags See kLdrModEnumSymbols.
	1279	* @param pfnCallback See kLdrModEnumSymbols.
	1280	* @param pvUser See kLdrModEnumSymbols.
	1281	*/
[2963]	1282	static int kldrModMachODoEnumSymbols32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t *paSyms, uint32_t cSyms,
[2962]	1283	const char *pchStrings, uint32_t cchStrings, KLDRADDR BaseAddress,
	1284	uint32_t fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
[2952]	1285	{
[2962]	1286	const uint32_t fKindBase = pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE
	1287	\|\| pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE_OE
	1288	? KLDRSYMKIND_32BIT : KLDRSYMKIND_64BIT;
	1289	uint32_t iSym;
	1290	int rc;
[2952]	1291
	1292	/*
[2962]	1293	* Iterate the symbol table.
[2952]	1294	*/
[2962]	1295	for (iSym = 0; iSym < cSyms; iSym++)
	1296	{
	1297	uint32_t fKind;
	1298	KLDRADDR uValue;
	1299	const char *psz;
	1300	size_t cch;
[2952]	1301
[2962]	1302	/* Skip debug symbols and undefined symbols. */
	1303	if (paSyms[iSym].n_type & MACHO_N_STAB)
	1304	continue;
	1305	if ((paSyms[iSym].n_type & MACHO_N_TYPE) == MACHO_N_UNDF)
	1306	continue;
[2952]	1307
[2962]	1308	/* Skip non-public symbols unless they are requested explicitly. */
	1309	if (!(fFlags & KLDRMOD_ENUM_SYMS_FLAGS_ALL))
	1310	{
	1311	if (!(paSyms[iSym].n_type & MACHO_N_EXT)) /??/
	1312	continue;
	1313	if (paSyms[iSym].n_type & MACHO_N_PEXT) /??/
	1314	continue;
[2963]	1315	if (!paSyms[iSym].n_un.n_strx)
[2962]	1316	continue;
	1317	}
[2952]	1318
[2963]	1319	/*
	1320	* Gather symbol info
[2962]	1321	*/
[2952]	1322
[2962]	1323	/* name */
	1324	if ((uint32_t)paSyms[iSym].n_un.n_strx >= cchStrings)
	1325	return KLDR_ERR_MACHO_BAD_SYMBOL;
	1326	psz = &pchStrings[paSyms[iSym].n_un.n_strx];
	1327	cch = kLdrHlpStrLen(psz);
	1328	if (!cch)
	1329	psz = NULL;
	1330
	1331	/* kind & value */
	1332	fKind = fKindBase;
	1333	if (paSyms[iSym].n_desc & N_WEAK_DEF)
	1334	fKind \|= KLDRSYMKIND_WEAK;
	1335	switch (paSyms[iSym].n_type & MACHO_N_TYPE)
[2952]	1336	{
[2962]	1337	case MACHO_N_SECT:
	1338	{
	1339	PKLDRMODMACHOSECT pSect;
	1340	if ((uint32_t)(paSyms[iSym].n_sect - 1) >= pModMachO->cSections)
	1341	return KLDR_ERR_MACHO_BAD_SYMBOL;
	1342	pSect = &pModMachO->paSections[paSyms[iSym].n_sect - 1];
	1343
	1344	uValue = paSyms[iSym].n_value - pModMachO->LinkAddress;
	1345	if (uValue - pSect->RVA >= pSect->cb)
	1346	return KLDR_ERR_MACHO_BAD_SYMBOL;
	1347	uValue += BaseAddress;
	1348
	1349	if (pSect->fFlags & (S_ATTR_PURE_INSTRUCTIONS \| S_ATTR_SELF_MODIFYING_CODE))
	1350	fKind \|= KLDRSYMKIND_CODE;
	1351	else
	1352	fKind \|= KLDRSYMKIND_NO_TYPE;
	1353	break;
	1354	}
	1355
	1356	case MACHO_N_ABS:
	1357	uValue = paSyms[iSym].n_value;
	1358	fKind \|= KLDRSYMKIND_NO_TYPE /KLDRSYMKIND_ABS/;
	1359	break;
	1360
	1361	case MACHO_N_PBUD:
	1362	case MACHO_N_INDR:
	1363	/** @todo implement indirect and prebound symbols. */
	1364	default:
	1365	KLDRMODMACHO_ASSERT(0);
	1366	return KLDR_ERR_TODO;
[2952]	1367	}
	1368
	1369	/*
[2962]	1370	* Do callback.
[2952]	1371	*/
[2962]	1372	rc = pfnCallback(pModMachO->pMod, iSym, psz, cch, NULL, uValue, fKind, pvUser);
	1373	if (rc)
	1374	return rc;
[2952]	1375	}
	1376	return 0;
	1377	}
	1378
	1379
	1380	/** @copydoc kLdrModGetImport */
	1381	static int kldrModMachOGetImport(PKLDRMOD pMod, const void pvBits, uint32_t iImport, char pszName, size_t cchName)
	1382	{
[2956]	1383	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
	1384	if (pModMachO->Hdr.filetype == MH_OBJECT)
[2952]	1385	return KLDR_ERR_IMPORT_ORDINAL_OUT_OF_BOUNDS;
	1386
[2956]	1387	/* later */
	1388	return KLDR_ERR_IMPORT_ORDINAL_OUT_OF_BOUNDS;
[2952]	1389	}
	1390
	1391
	1392	/** @copydoc kLdrModNumberOfImports */
	1393	static int32_t kldrModMachONumberOfImports(PKLDRMOD pMod, const void *pvBits)
	1394	{
	1395	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
[2956]	1396	if (pModMachO->Hdr.filetype == MH_OBJECT)
	1397	return 0;
[2952]	1398
[2956]	1399	/* later */
[2952]	1400	return 0;
	1401	}
	1402
	1403
	1404	/** @copydoc kLdrModGetStackInfo */
	1405	static int kldrModMachOGetStackInfo(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, PKLDRSTACKINFO pStackInfo)
	1406	{
[2972]	1407	/PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;/
[2952]	1408
	1409	pStackInfo->Address = NIL_KLDRADDR;
	1410	pStackInfo->LinkAddress = NIL_KLDRADDR;
[2956]	1411	pStackInfo->cbStack = pStackInfo->cbStackThread = 0;
	1412	/* later */
[2952]	1413
	1414	return 0;
	1415	}
	1416
	1417
	1418	/** @copydoc kLdrModQueryMainEntrypoint */
	1419	static int kldrModMachOQueryMainEntrypoint(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, PKLDRADDR pMainEPAddress)
	1420	{
	1421	#if 0
	1422	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
	1423	int rc;
	1424
	1425	/*
	1426	* Resolve base address alias if any.
	1427	*/
	1428	rc = kldrModMachOBitsAndBaseAddress(pModMachO, NULL, &BaseAddress);
	1429	if (rc)
	1430	return rc;
	1431
	1432	/*
	1433	* Convert the address from the header.
	1434	*/
	1435	*pMainEPAddress = pModMachO->Hdrs.OptionalHeader.AddressOfEntryPoint
	1436	? BaseAddress + pModMachO->Hdrs.OptionalHeader.AddressOfEntryPoint
	1437	: NIL_KLDRADDR;
	1438	#else
	1439	*pMainEPAddress = NIL_KLDRADDR;
	1440	#endif
	1441	return 0;
	1442	}
	1443
	1444
	1445	/** @copydoc kLdrModEnumDbgInfo */
	1446	static int kldrModMachOEnumDbgInfo(PKLDRMOD pMod, const void pvBits, PFNKLDRENUMDBG pfnCallback, void pvUser)
	1447	{
	1448	#if 0
	1449	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
	1450	const IMAGE_DEBUG_DIRECTORY *pDbgDir;
	1451	uint32_t iDbgInfo;
	1452	uint32_t cb;
	1453	int rc;
	1454
	1455	/*
	1456	* Check that there is a debug directory first.
	1457	*/
	1458	cb = pModMachO->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].Size;
	1459	if ( cb < sizeof(IMAGE_DEBUG_DIRECTORY) /* screw borland linkers */
	1460	\|\| !pModMachO->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress)
	1461	return 0;
	1462
	1463	/*
	1464	* Make sure we've got mapped bits.
	1465	*/
	1466	rc = kldrModMachOBitsAndBaseAddress(pModMachO, &pvBits, NULL);
	1467	if (rc)
	1468	return rc;
	1469
	1470	/*
	1471	* Enumerate the debug directory.
	1472	*/
	1473	pDbgDir = KLDRMODMACHO_RVA2TYPE(pvBits,
	1474	pModMachO->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress,
	1475	const IMAGE_DEBUG_DIRECTORY *);
	1476	for (iDbgInfo = 0;; iDbgInfo++, pDbgDir++, cb -= sizeof(IMAGE_DEBUG_DIRECTORY))
	1477	{
	1478	KLDRDBGINFOTYPE enmDbgInfoType;
	1479
	1480	/* convert the type. */
	1481	switch (pDbgDir->Type)
	1482	{
	1483	case IMAGE_DEBUG_TYPE_UNKNOWN:
	1484	case IMAGE_DEBUG_TYPE_FPO:
	1485	case IMAGE_DEBUG_TYPE_COFF: /stabs dialect??/
	1486	case IMAGE_DEBUG_TYPE_MISC:
	1487	case IMAGE_DEBUG_TYPE_EXCEPTION:
	1488	case IMAGE_DEBUG_TYPE_FIXUP:
	1489	case IMAGE_DEBUG_TYPE_BORLAND:
	1490	default:
	1491	enmDbgInfoType = KLDRDBGINFOTYPE_UNKNOWN;
	1492	break;
	1493	case IMAGE_DEBUG_TYPE_CODEVIEW:
	1494	enmDbgInfoType = KLDRDBGINFOTYPE_CODEVIEW;
	1495	break;
	1496	}
	1497
	1498	rc = pfnCallback(pMod, iDbgInfo,
	1499	enmDbgInfoType, pDbgDir->MajorVersion, pDbgDir->MinorVersion,
	1500	pDbgDir->PointerToRawData ? pDbgDir->PointerToRawData : -1,
	1501	pDbgDir->AddressOfRawData ? pDbgDir->AddressOfRawData : NIL_KLDRADDR,
	1502	pDbgDir->SizeOfData,
	1503	NULL,
	1504	pvUser);
	1505	if (rc)
	1506	break;
	1507
	1508	/* next */
	1509	if (cb <= sizeof(IMAGE_DEBUG_DIRECTORY))
	1510	break;
	1511	}
	1512
	1513	return rc;
	1514	#else
	1515	return 0;
	1516	#endif
	1517	}
	1518
	1519
	1520	/** @copydoc kLdrModHasDbgInfo */
	1521	static int kldrModMachOHasDbgInfo(PKLDRMOD pMod, const void *pvBits)
	1522	{
[2972]	1523	/PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;/
[2952]	1524
	1525	#if 0
	1526	/*
	1527	* Base this entirely on the presence of a debug directory.
	1528	*/
	1529	if ( pModMachO->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].Size
	1530	< sizeof(IMAGE_DEBUG_DIRECTORY) /* screw borland linkers */
	1531	\|\| !pModMachO->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress)
	1532	return KLDR_ERR_NO_DEBUG_INFO;
	1533	return 0;
	1534	#else
	1535	return KLDR_ERR_NO_DEBUG_INFO;
	1536	#endif
	1537	}
	1538
	1539
	1540	/** @copydoc kLdrModMap */
	1541	static int kldrModMachOMap(PKLDRMOD pMod)
	1542	{
[2962]	1543	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
	1544	unsigned fFixed;
	1545	uint32_t i;
	1546	void *pvBase;
	1547	int rc;
[2952]	1548
	1549	/*
	1550	* Already mapped?
	1551	*/
	1552	if (pModMachO->pvMapping)
	1553	return KLDR_ERR_ALREADY_MAPPED;
	1554
	1555	/*
[2962]	1556	* Map it.
[2952]	1557	*/
[2962]	1558	/* fixed image? */
	1559	fFixed = pMod->enmType == KLDRTYPE_EXECUTABLE_FIXED
	1560	\|\| pMod->enmType == KLDRTYPE_SHARED_LIBRARY_FIXED;
	1561	if (!fFixed)
	1562	pvBase = NULL;
	1563	else
	1564	{
	1565	pvBase = (void *)(uintptr_t)pMod->aSegments[0].LinkAddress;
	1566	if ((uintptr_t)pvBase != pMod->aSegments[0].LinkAddress)
	1567	return KLDR_ERR_ADDRESS_OVERFLOW;
	1568	}
	1569
	1570	/* try do the prepare */
	1571	if (pModMachO->fMapUsingLoadCommandSections)
	1572	return KLDR_ERR_TODO; /* deal with this if it ever occurs. */
	1573	else
	1574	{
	1575	rc = kLdrRdrMap(pMod->pRdr, &pvBase, pMod->cSegments, pMod->aSegments, fFixed);
	1576	if (rc)
	1577	return rc;
	1578	}
	1579
	1580	/*
	1581	* Update the segments with their map addresses.
	1582	*/
	1583	for (i = 0; i < pMod->cSegments; i++)
	1584	{
	1585	if (pMod->aSegments[i].RVA != NIL_KLDRADDR)
	1586	pMod->aSegments[i].MapAddress = (uintptr_t)pvBase + (uintptr_t)pMod->aSegments[i].RVA;
	1587	}
	1588	pModMachO->pvMapping = pvBase;
	1589
[2952]	1590	return 0;
	1591	}
	1592
	1593
	1594	/** @copydoc kLdrModUnmap */
	1595	static int kldrModMachOUnmap(PKLDRMOD pMod)
	1596	{
[2962]	1597	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
	1598	uint32_t i;
	1599	int rc;
[2952]	1600
	1601	/*
	1602	* Mapped?
	1603	*/
	1604	if (!pModMachO->pvMapping)
	1605	return KLDR_ERR_NOT_MAPPED;
	1606
	1607	/*
[2962]	1608	* Try unmap the image.
[2952]	1609	*/
[2962]	1610	if (pModMachO->fMapUsingLoadCommandSections)
	1611	return KLDR_ERR_TODO; /* deal with this if it ever occurs. */
	1612	else
	1613	{
	1614	rc = kLdrRdrUnmap(pMod->pRdr, pModMachO->pvMapping, pMod->cSegments, pMod->aSegments);
	1615	if (rc)
	1616	return rc;
	1617	}
	1618
	1619	/*
	1620	* Update the segments to reflect that they aren't mapped any longer.
	1621	*/
	1622	pModMachO->pvMapping = NULL;
	1623	for (i = 0; i < pMod->cSegments; i++)
	1624	pMod->aSegments[i].MapAddress = 0;
	1625
[2952]	1626	return 0;
	1627	}
	1628
	1629
	1630	/** @copydoc kLdrModAllocTLS */
	1631	static int kldrModMachOAllocTLS(PKLDRMOD pMod)
	1632	{
[2962]	1633	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
[2952]	1634
	1635	/*
	1636	* Mapped?
	1637	*/
	1638	if (!pModMachO->pvMapping)
	1639	return KLDR_ERR_NOT_MAPPED;
	1640	return 0;
	1641	}
	1642
	1643
	1644	/** @copydoc kLdrModFreeTLS */
	1645	static void kldrModMachOFreeTLS(PKLDRMOD pMod)
	1646	{
	1647	}
	1648
	1649
	1650	/** @copydoc kLdrModReload */
	1651	static int kldrModMachOReload(PKLDRMOD pMod)
	1652	{
	1653	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
	1654
	1655	/*
	1656	* Mapped?
	1657	*/
	1658	if (!pModMachO->pvMapping)
	1659	return KLDR_ERR_NOT_MAPPED;
	1660
	1661	/* the file provider does it all */
[2962]	1662	return kLdrRdrRefresh(pMod->pRdr, pModMachO->pvMapping, pMod->cSegments, pMod->aSegments);
[2952]	1663	}
	1664
	1665
	1666	/** @copydoc kLdrModFixupMapping */
	1667	static int kldrModMachOFixupMapping(PKLDRMOD pMod, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser)
	1668	{
	1669	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
	1670	int rc, rc2;
	1671
	1672	/*
	1673	* Mapped?
	1674	*/
	1675	if (!pModMachO->pvMapping)
	1676	return KLDR_ERR_NOT_MAPPED;
	1677
	1678	/*
	1679	* Before doing anything we'll have to make all pages writable.
	1680	*/
[2962]	1681	if (pModMachO->fMapUsingLoadCommandSections)
	1682	return KLDR_ERR_TODO; /* deal with this if it ever occurs. */
	1683	else
	1684	{
	1685	rc = kLdrRdrProtect(pMod->pRdr, pModMachO->pvMapping, pMod->cSegments, pMod->aSegments, 1 /* unprotect */);
	1686	if (rc)
	1687	return rc;
	1688	}
[2952]	1689
	1690	/*
[2962]	1691	* Resolve imports and apply base relocations.
[2952]	1692	*/
[2963]	1693	rc = kldrModMachORelocateBits(pMod, pModMachO->pvMapping, (uintptr_t)pModMachO->pvMapping, pModMachO->LinkAddress,
[2962]	1694	pfnGetImport, pvUser);
[2952]	1695
	1696	/*
	1697	* Restore protection.
	1698	*/
[2962]	1699	if (pModMachO->fMapUsingLoadCommandSections)
	1700	rc2 = KLDR_ERR_TODO; /* deal with this if it ever occurs. */
	1701	else
	1702	rc2 = kLdrRdrProtect(pMod->pRdr, pModMachO->pvMapping, pMod->cSegments, pMod->aSegments, 0 /* protect */);
[2952]	1703	if (!rc && rc2)
	1704	rc = rc2;
	1705	return rc;
	1706	}
	1707
	1708
	1709	/**
[2961]	1710	* MH_OBJECT: Resolves undefined symbols (imports).
[2952]	1711	*
	1712	* @returns 0 on success, non-zero kLdr status code on failure.
[2961]	1713	* @param pModMachO The Mach-O module interpreter instance.
	1714	* @param pfnGetImport The callback for resolving an imported symbol.
	1715	* @param pvUser User argument to the callback.
[2952]	1716	*/
[2961]	1717	static int kldrModMachOObjDoImports(PKLDRMODMACHO pModMachO, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser)
[2952]	1718	{
[2961]	1719	const uint32_t cSyms = pModMachO->cSymbols;
	1720	uint32_t iSym;
	1721	int rc;
[2952]	1722
	1723	/*
[2961]	1724	* Ensure that we've got the symbol table and section fixups handy.
[2952]	1725	*/
[2961]	1726	rc = kldrModMachOLoadObjSymTab(pModMachO);
	1727	if (rc)
	1728	return rc;
[2952]	1729
	1730	/*
[2961]	1731	* Iterate the symbol table and resolve undefined symbols.
	1732	* We currently ignore REFERENCE_TYPE.
[2952]	1733	*/
[2963]	1734	if ( pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE
[2961]	1735	\|\| pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE_OE)
[2952]	1736	{
[2961]	1737	macho_nlist_32_t paSyms = (macho_nlist_32_t )pModMachO->pvaSymbols;
	1738	for (iSym = 0; iSym < cSyms; iSym++)
[2952]	1739	{
[2961]	1740	/* skip stabs */
	1741	if (paSyms[iSym].n_type & MACHO_N_STAB)
	1742	continue;
[2952]	1743
[2961]	1744	if ((paSyms[iSym].n_type & MACHO_N_TYPE) == MACHO_N_UNDF)
[2952]	1745	{
[2961]	1746	const char *pszSymbol;
	1747	size_t cchSymbol;
	1748	uint32_t fKind = KLDRSYMKIND_REQ_FLAT;
[2963]	1749	KLDRADDR Value;
[2952]	1750
[2961]	1751	/** @todo Implement N_REF_TO_WEAK. */
	1752	if (paSyms[iSym].n_desc & N_REF_TO_WEAK)
	1753	return KLDR_ERR_TODO;
[2952]	1754
[2961]	1755	/* Get the symbol name and try resolve it. */
[2962]	1756	if ((uint32_t)paSyms[iSym].n_un.n_strx >= pModMachO->cchStrings)
[2961]	1757	return KLDR_ERR_MACHO_BAD_SYMBOL;
	1758	pszSymbol = &pModMachO->pchStrings[paSyms[iSym].n_un.n_strx];
	1759	cchSymbol = kLdrHlpStrLen(pszSymbol);
	1760	rc = pfnGetImport(pModMachO->pMod, NIL_KLDRMOD_IMPORT, iSym, pszSymbol, cchSymbol, NULL,
	1761	&Value, &fKind, pvUser);
	1762	if (rc)
	1763	{
	1764	/* weak reference? */
	1765	if (!(paSyms[iSym].n_desc & N_WEAK_REF))
	1766	break;
	1767	Value = 0;
	1768	}
[2952]	1769
[2961]	1770	/* Update the symbol. */
	1771	paSyms[iSym].n_value = (uint32_t)Value;
	1772	if (paSyms[iSym].n_value != Value)
	1773	{
	1774	rc = KLDR_ERR_ADDRESS_OVERFLOW;
[2952]	1775	break;
[2961]	1776	}
	1777	}
	1778	else if (paSyms[iSym].n_desc & N_WEAK_DEF)
[2964]	1779	{
	1780	/** @todo implement weak symbols. */
	1781	/return KLDR_ERR_TODO; - ignored for now. /
	1782	}
[2961]	1783	}
	1784	}
	1785	else
	1786	{
	1787	/* (Identical to the 32-bit code, just different paSym type. (and n_strx is unsigned)) */
	1788	macho_nlist_64_t paSyms = (macho_nlist_64_t )pModMachO->pvaSymbols;
	1789	for (iSym = 0; iSym < cSyms; iSym++)
	1790	{
	1791	/* skip stabs */
	1792	if (paSyms[iSym].n_type & MACHO_N_STAB)
	1793	continue;
[2952]	1794
[2961]	1795	if ((paSyms[iSym].n_type & MACHO_N_TYPE) == MACHO_N_UNDF)
	1796	{
	1797	const char *pszSymbol;
	1798	size_t cchSymbol;
	1799	uint32_t fKind = KLDRSYMKIND_REQ_FLAT;
[2963]	1800	KLDRADDR Value;
[2961]	1801
	1802	/** @todo Implement N_REF_TO_WEAK. */
	1803	if (paSyms[iSym].n_desc & N_REF_TO_WEAK)
	1804	return KLDR_ERR_TODO;
	1805
	1806	/* Get the symbol name and try resolve it. */
[2962]	1807	if (paSyms[iSym].n_un.n_strx >= pModMachO->cchStrings)
[2961]	1808	return KLDR_ERR_MACHO_BAD_SYMBOL;
	1809	pszSymbol = &pModMachO->pchStrings[paSyms[iSym].n_un.n_strx];
	1810	cchSymbol = kLdrHlpStrLen(pszSymbol);
	1811	rc = pfnGetImport(pModMachO->pMod, NIL_KLDRMOD_IMPORT, iSym, pszSymbol, cchSymbol, NULL,
	1812	&Value, &fKind, pvUser);
	1813	if (rc)
[2952]	1814	{
[2961]	1815	/* weak reference? */
	1816	if (!(paSyms[iSym].n_desc & N_WEAK_REF))
	1817	break;
	1818	Value = 0;
	1819	}
[2952]	1820
[2961]	1821	/* Update the symbol. */
	1822	paSyms[iSym].n_value = Value;
	1823	if (paSyms[iSym].n_value != Value)
	1824	{
	1825	rc = KLDR_ERR_ADDRESS_OVERFLOW;
[2952]	1826	break;
	1827	}
[2961]	1828	}
	1829	else if (paSyms[iSym].n_desc & N_WEAK_DEF)
[2964]	1830	{
	1831	/** @todo implement weak symbols. */
	1832	/return KLDR_ERR_TODO; - ignored for now. /
	1833	}
[2961]	1834	}
	1835	}
[2952]	1836
[2961]	1837	return rc;
	1838	}
[2952]	1839
	1840
[2961]	1841	/**
	1842	* MH_OBJECT: Applies base relocations to a (unprotected) image mapping.
	1843	*
	1844	* @returns 0 on success, non-zero kLdr status code on failure.
	1845	* @param pModMachO The Mach-O module interpreter instance.
	1846	* @param pvMapping The mapping to fixup.
	1847	* @param NewBaseAddress The address to fixup the mapping to.
	1848	* @param OldBaseAddress The address the mapping is currently fixed up to.
	1849	*/
	1850	static int kldrModMachOObjDoFixups(PKLDRMODMACHO pModMachO, void *pvMapping, KLDRADDR NewBaseAddress)
	1851	{
	1852	uint32_t iSeg;
	1853	int rc;
[2952]	1854
	1855
[2961]	1856	/*
	1857	* Ensure that we've got the symbol table and section fixups handy.
	1858	*/
	1859	rc = kldrModMachOLoadObjSymTab(pModMachO);
	1860	if (rc)
	1861	return rc;
[2952]	1862
[2961]	1863	/*
	1864	* Iterate over the segments and their sections and apply fixups.
	1865	*/
	1866	for (iSeg = rc = 0; !rc && iSeg < pModMachO->pMod->cSegments; iSeg++)
	1867	{
	1868	PKLDRMODMACHOSEG pSeg = &pModMachO->aSegments[iSeg];
	1869	uint32_t iSect;
	1870
	1871	for (iSect = 0; iSect < pSeg->cSections; iSect++)
	1872	{
	1873	PKLDRMODMACHOSECT pSect = &pSeg->paSections[iSect];
	1874	uint8_t *pbSectBits;
	1875
	1876	/* skip sections without fixups. */
	1877	if (!pSect->cFixups)
	1878	continue;
	1879
	1880	/* lazy load (and endian convert) the fixups. */
	1881	if (!pSect->paFixups)
	1882	{
	1883	rc = kldrModMachOLoadFixups(pModMachO, pSect->offFixups, pSect->cFixups, &pSect->paFixups);
	1884	if (rc)
[2952]	1885	break;
[2961]	1886	}
[2952]	1887
[2961]	1888	/*
	1889	* Apply the fixups.
	1890	*/
	1891	pbSectBits = (uint8_t *)pvMapping + (uintptr_t)pSect->RVA;
[2963]	1892	if (pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE) /** @todo this aint right. */
	1893	rc = kldrModMachOFixupSectionGeneric32Bit(pModMachO, pbSectBits, pSect,
	1894	(macho_nlist_32_t *)pModMachO->pvaSymbols,
	1895	pModMachO->cSymbols, NewBaseAddress);
	1896	else
	1897	rc = KLDR_ERR_TODO; /* save space for now. */
[2961]	1898	if (rc)
	1899	break;
[2952]	1900	}
[2961]	1901	}
[2952]	1902
[2961]	1903	return rc;
	1904	}
[2952]	1905
	1906
[2963]	1907	/**
	1908	* Applies generic fixups to a section in an image of the same endian-ness
	1909	* as the host CPU.
	1910	*
	1911	* @returns 0 on success, non-zero kLdr status code on failure.
	1912	* @param pModMachO The Mach-O module interpreter instance.
	1913	* @param pbSectBits Pointer to the section bits.
	1914	* @param pFixupSect The section being fixed up.
	1915	* @param NewBaseAddress The new base image address.
	1916	*/
	1917	static int kldrModMachOFixupSectionGeneric32Bit(PKLDRMODMACHO pModMachO, uint8_t *pbSectBits, PKLDRMODMACHOSECT pFixupSect,
	1918	macho_nlist_32_t *paSyms, uint32_t cSyms, KLDRADDR NewBaseAddress)
[2961]	1919	{
[2963]	1920	const macho_relocation_info_t *paFixups = pFixupSect->paFixups;
	1921	const uint32_t cFixups = pFixupSect->cFixups;
	1922	size_t cbSectBits = (size_t)pFixupSect->cb;
	1923	const uint8_t *pbSectVirginBits;
	1924	uint32_t iFixup;
	1925	KLDRPU uFixVirgin;
	1926	KLDRPU uFix;
	1927	KLDRADDR SymAddr;
	1928	int rc;
[2961]	1929
[2963]	1930	/*
	1931	* Find the virgin bits.
	1932	*/
	1933	if (pFixupSect->offFile != -1)
	1934	{
	1935	rc = kldrModMachOMapVirginBits(pModMachO);
	1936	if (rc)
	1937	return rc;
	1938	pbSectVirginBits = (const uint8_t *)pModMachO->pvBits + pFixupSect->offFile;
	1939	}
	1940	else
	1941	pbSectVirginBits = NULL;
	1942
	1943	/*
	1944	* Iterate the fixups and apply them.
	1945	*/
	1946	for (iFixup = 0; iFixup < cFixups; iFixup++)
	1947	{
	1948	union
	1949	{
	1950	macho_relocation_info_t r;
	1951	scattered_relocation_info_t s;
	1952	} Fixup;
	1953	Fixup.r = paFixups[iFixup];
	1954
	1955	if (!(Fixup.r.r_address & R_SCATTERED))
	1956	{
	1957	/* sanity */
	1958	if ((uint32_t)Fixup.r.r_address >= cbSectBits)
	1959	return KLDR_ERR_BAD_FIXUP;
	1960
	1961	/* calc fixup addresses. */
	1962	uFix.pv = pbSectBits + Fixup.r.r_address;
	1963	uFixVirgin.pv = pbSectVirginBits ? (uint8_t *)pbSectVirginBits + Fixup.r.r_address : 0;
	1964
	1965	/*
	1966	* Calc the symbol value.
	1967	*/
[2976]	1968	/* Calc the linked symbol address / addend. */
[2963]	1969	switch (Fixup.r.r_length)
	1970	{
[2976]	1971	/** @todo Deal with unaligned accesses on non x86 platforms. */
[2963]	1972	case 0: SymAddr = *uFixVirgin.pi8; break;
	1973	case 1: SymAddr = *uFixVirgin.pi16; break;
	1974	case 2: SymAddr = *uFixVirgin.pi32; break;
	1975	case 3: SymAddr = *uFixVirgin.pi64; break;
	1976	}
[2968]	1977	if (Fixup.r.r_pcrel)
[2976]	1978	SymAddr += Fixup.r.r_address + pFixupSect->LinkAddress;
[2963]	1979
	1980	/* Add symbol / section address. */
	1981	if (Fixup.r.r_extern)
	1982	{
	1983	const macho_nlist_32_t *pSym;
	1984	if (Fixup.r.r_symbolnum >= cSyms)
	1985	return KLDR_ERR_BAD_FIXUP;
	1986	pSym = &paSyms[Fixup.r.r_symbolnum];
	1987
	1988	if (pSym->n_type & MACHO_N_STAB)
	1989	return KLDR_ERR_BAD_FIXUP;
	1990
	1991	switch (pSym->n_type & MACHO_N_TYPE)
	1992	{
	1993	case MACHO_N_SECT:
	1994	{
	1995	PKLDRMODMACHOSECT pSymSect;
	1996	if ((uint32_t)pSym->n_sect - 1 > pModMachO->cSections)
	1997	return KLDR_ERR_MACHO_BAD_SYMBOL;
	1998	pSymSect = &pModMachO->paSections[pSym->n_sect - 1];
	1999
[2976]	2000	SymAddr += pSym->n_value - pSymSect->LinkAddress + pSymSect->RVA + NewBaseAddress;
[2963]	2001	break;
	2002	}
	2003
	2004	case MACHO_N_UNDF:
	2005	case MACHO_N_ABS:
	2006	SymAddr += pSym->n_value;
	2007	break;
	2008
	2009	case MACHO_N_INDR:
	2010	case MACHO_N_PBUD:
	2011	return KLDR_ERR_TODO;
	2012	default:
	2013	return KLDR_ERR_MACHO_BAD_SYMBOL;
	2014	}
	2015	}
	2016	else if (Fixup.r.r_symbolnum != R_ABS)
	2017	{
	2018	PKLDRMODMACHOSECT pSymSect;
	2019	if (Fixup.r.r_symbolnum > pModMachO->cSections)
	2020	return KLDR_ERR_BAD_FIXUP;
	2021	pSymSect = &pModMachO->paSections[Fixup.r.r_symbolnum - 1];
[2968]	2022
	2023	SymAddr -= pSymSect->LinkAddress;
[2976]	2024	SymAddr += pSymSect->RVA + NewBaseAddress;
[2963]	2025	}
	2026
	2027	/* adjust for PC relative */
	2028	if (Fixup.r.r_pcrel)
	2029	SymAddr -= Fixup.r.r_address + pFixupSect->RVA + NewBaseAddress;
	2030	}
	2031	else
	2032	{
	2033	PKLDRMODMACHOSECT pSymSect;
	2034	uint32_t iSymSect;
	2035	KLDRADDR Value;
	2036
	2037	/* sanity */
	2038	KLDRMODMACHO_ASSERT(Fixup.s.r_scattered);
	2039	if ((uint32_t)Fixup.s.r_address >= cbSectBits)
	2040	return KLDR_ERR_BAD_FIXUP;
	2041
	2042	/* calc fixup addresses. */
	2043	uFix.pv = pbSectBits + Fixup.s.r_address;
	2044	uFixVirgin.pv = pbSectVirginBits ? (uint8_t *)pbSectVirginBits + Fixup.s.r_address : 0;
	2045
	2046	/*
	2047	* Calc the symbol value.
	2048	*/
	2049	/* The addend is stored in the code. */
	2050	switch (Fixup.s.r_length)
	2051	{
	2052	case 0: SymAddr = *uFixVirgin.pi8; break;
	2053	case 1: SymAddr = *uFixVirgin.pi16; break;
	2054	case 2: SymAddr = *uFixVirgin.pi32; break;
	2055	case 3: SymAddr = *uFixVirgin.pi64; break;
	2056	}
[2968]	2057	if (Fixup.s.r_pcrel)
[2975]	2058	SymAddr += Fixup.s.r_address;
	2059	Value = Fixup.s.r_value;
	2060	SymAddr -= Value; /* (-> addend only) */
[2963]	2061
[2976]	2062	/* Find the section number from the r_value. */
[2963]	2063	pSymSect = NULL;
	2064	for (iSymSect = 0; iSymSect < pModMachO->cSections; iSymSect++)
	2065	{
[2968]	2066	KLDRADDR off = Value - pModMachO->paSections[iSymSect].LinkAddress;
[2963]	2067	if (off < pModMachO->paSections[iSymSect].cb)
	2068	{
	2069	pSymSect = &pModMachO->paSections[iSymSect];
	2070	break;
	2071	}
	2072	else if (off == pModMachO->paSections[iSymSect].cb) /* edge case */
	2073	pSymSect = &pModMachO->paSections[iSymSect];
	2074	}
	2075	if (!pSymSect)
	2076	return KLDR_ERR_BAD_FIXUP;
	2077
[2968]	2078	/* Calc the symbol address. */
[2976]	2079	SymAddr += Value - pSymSect->LinkAddress + pSymSect->RVA + NewBaseAddress;
[2963]	2080	if (Fixup.s.r_pcrel)
	2081	SymAddr -= Fixup.s.r_address + pFixupSect->RVA + NewBaseAddress;
	2082
	2083	Fixup.r.r_length = ((scattered_relocation_info_t *)&paFixups[iFixup])->r_length;
	2084	Fixup.r.r_type = ((scattered_relocation_info_t *)&paFixups[iFixup])->r_type;
	2085	}
	2086
	2087	/*
	2088	* Write back the fixed up value.
	2089	*/
	2090	if (Fixup.r.r_type == GENERIC_RELOC_VANILLA)
	2091	{
	2092	switch (Fixup.r.r_length)
	2093	{
	2094	case 0: *uFix.pu8 = (uint8_t)SymAddr; break;
	2095	case 1: *uFix.pu16 = (uint16_t)SymAddr; break;
	2096	case 2: *uFix.pu32 = (uint32_t)SymAddr; break;
	2097	case 3: *uFix.pu64 = (uint64_t)SymAddr; break;
	2098	}
	2099	}
	2100	else if (Fixup.r.r_type <= GENERIC_RELOC_LOCAL_SECTDIFF)
[2964]	2101	return KLDR_ERR_MACHO_UNSUPPORTED_FIXUP_TYPE;
[2963]	2102	else
	2103	return KLDR_ERR_BAD_FIXUP;
	2104	}
	2105
[2952]	2106	return 0;
	2107	}
	2108
	2109
[2961]	2110	/**
	2111	* Loads the symbol table for a MH_OBJECT file.
[2963]	2112	*
[2961]	2113	* The symbol table is pointed to by KLDRMODMACHO::pvaSymbols.
[2963]	2114	*
[2961]	2115	* @returns 0 on success, non-zero kLdr status code on failure.
[2963]	2116	* @param pModMachO The Mach-O module interpreter instance.
[2961]	2117	*/
	2118	static int kldrModMachOLoadObjSymTab(PKLDRMODMACHO pModMachO)
	2119	{
	2120	int rc = 0;
[2952]	2121
[2963]	2122	if ( !pModMachO->pvaSymbols
[2961]	2123	&& pModMachO->cSymbols)
	2124	{
	2125	size_t cbSyms;
	2126	size_t cbSym;
	2127	void *pvSyms;
	2128	void *pvStrings;
	2129
	2130	/* sanity */
	2131	if ( !pModMachO->offSymbols
[2962]	2132	\|\| (pModMachO->cchStrings && !pModMachO->offStrings))
[2961]	2133	return KLDR_ERR_MACHO_BAD_OBJECT_FILE;
	2134
	2135	/* allocate */
	2136	cbSym = pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE
	2137	\|\| pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE_OE
	2138	? sizeof(macho_nlist_32_t)
	2139	: sizeof(macho_nlist_64_t);
	2140	cbSyms = pModMachO->cSymbols * cbSym;
	2141	if (cbSyms / cbSym != pModMachO->cSymbols)
	2142	return KLDR_ERR_SIZE_OVERFLOW;
	2143	rc = KLDR_ERR_NO_MEMORY;
	2144	pvSyms = kldrHlpAlloc(cbSyms);
	2145	if (pvSyms)
	2146	{
[2962]	2147	if (pModMachO->cchStrings)
	2148	pvStrings = kldrHlpAlloc(pModMachO->cchStrings);
[2961]	2149	else
	2150	pvStrings = kldrHlpAllocZ(4);
	2151	if (pvStrings)
	2152	{
	2153	/* read */
	2154	rc = kLdrRdrRead(pModMachO->pMod->pRdr, pvSyms, cbSyms, pModMachO->offSymbols);
[2962]	2155	if (!rc && pModMachO->cchStrings)
	2156	rc = kLdrRdrRead(pModMachO->pMod->pRdr, pvStrings, pModMachO->cchStrings, pModMachO->offStrings);
[2961]	2157	if (!rc)
	2158	{
	2159	pModMachO->pvaSymbols = pvSyms;
	2160	pModMachO->pchStrings = (char *)pvStrings;
[2963]	2161
[2961]	2162	/* perform endian conversion? */
	2163	if (pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE_OE)
	2164	{
	2165	uint32_t cLeft = pModMachO->cSymbols;
	2166	macho_nlist_32_t pSym = (macho_nlist_32_t )pvSyms;
	2167	while (cLeft-- > 0)
	2168	{
	2169	pSym->n_un.n_strx = KLDRHLP_E2E_U32(pSym->n_un.n_strx);
	2170	pSym->n_desc = (int16_t)KLDRHLP_E2E_U16(pSym->n_desc);
	2171	pSym->n_value = KLDRHLP_E2E_U32(pSym->n_value);
	2172	pSym++;
	2173	}
[2963]	2174	}
[2961]	2175	else if (pModMachO->Hdr.magic == IMAGE_MACHO64_SIGNATURE_OE)
	2176	{
	2177	uint32_t cLeft = pModMachO->cSymbols;
	2178	macho_nlist_64_t pSym = (macho_nlist_64_t )pvSyms;
	2179	while (cLeft-- > 0)
	2180	{
	2181	pSym->n_un.n_strx = KLDRHLP_E2E_U32(pSym->n_un.n_strx);
	2182	pSym->n_desc = (int16_t)KLDRHLP_E2E_U16(pSym->n_desc);
	2183	pSym->n_value = KLDRHLP_E2E_U64(pSym->n_value);
	2184	pSym++;
	2185	}
	2186	}
	2187
	2188	return 0;
	2189	}
	2190	kldrHlpFree(pvStrings);
	2191	}
	2192	kldrHlpFree(pvSyms);
	2193	}
	2194	}
	2195	else
	2196	KLDRMODMACHO_ASSERT(pModMachO->pchStrings);
	2197
	2198	return rc;
	2199	}
	2200
	2201
[2952]	2202	/**
[2963]	2203	* Loads the fixups at the given address and performs endian
[2961]	2204	* conversion if necessary.
[2963]	2205	*
[2952]	2206	* @returns 0 on success, non-zero kLdr status code on failure.
[2963]	2207	* @param pModMachO The Mach-O module interpreter instance.
[2961]	2208	* @param offFixups The file offset of the fixups.
	2209	* @param cFixups The number of fixups to load.
	2210	* @param ppaFixups Where to put the pointer to the allocated fixup array.
[2952]	2211	*/
[2974]	2212	static int kldrModMachOLoadFixups(PKLDRMODMACHO pModMachO, KLDRFOFF offFixups, uint32_t cFixups, macho_relocation_info_t **ppaFixups)
[2952]	2213	{
[2961]	2214	macho_relocation_info_t *paFixups;
	2215	size_t cbFixups;
	2216	int rc;
	2217
	2218	/* allocate the memory. */
	2219	cbFixups = cFixups * sizeof(*paFixups);
	2220	if (cbFixups / sizeof(*paFixups) != cFixups)
	2221	return KLDR_ERR_SIZE_OVERFLOW;
	2222	paFixups = (macho_relocation_info_t *)kldrHlpAlloc(cbFixups);
	2223	if (!paFixups)
	2224	return KLDR_ERR_NO_MEMORY;
	2225
	2226	/* read the fixups. */
	2227	rc = kLdrRdrRead(pModMachO->pMod->pRdr, paFixups, cbFixups, offFixups);
	2228	if (!rc)
	2229	{
	2230	*ppaFixups = paFixups;
	2231
	2232	/* do endian conversion if necessary. */
[2963]	2233	if ( pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE_OE
[2961]	2234	\|\| pModMachO->Hdr.magic == IMAGE_MACHO64_SIGNATURE_OE)
	2235	{
	2236	uint32_t iFixup;
	2237	for (iFixup = 0; iFixup < cFixups; iFixup++)
	2238	{
	2239	uint32_t pu32 = (uint32_t )&paFixups[iFixup];
	2240	pu32[0] = KLDRHLP_E2E_U32(pu32[0]);
	2241	pu32[1] = KLDRHLP_E2E_U32(pu32[1]);
	2242	}
	2243	}
	2244	}
	2245	else
	2246	kldrHlpFree(paFixups);
	2247	return rc;
[2952]	2248	}
	2249
	2250
[2963]	2251	/**
	2252	* Maps the virgin file bits into memory if not already done.
	2253	*
	2254	* @returns 0 on success, non-zero kLdr status code on failure.
	2255	* @param pModMachO The Mach-O module interpreter instance.
	2256	*/
	2257	static int kldrModMachOMapVirginBits(PKLDRMODMACHO pModMachO)
	2258	{
	2259	int rc = 0;
	2260	if (!pModMachO->pvBits)
	2261	rc = kLdrRdrAllMap(pModMachO->pMod->pRdr, &pModMachO->pvBits);
	2262	return rc;
	2263	}
	2264
	2265
[2952]	2266	/** @copydoc kLdrModCallInit */
	2267	static int kldrModMachOCallInit(PKLDRMOD pMod, uintptr_t uHandle)
	2268	{
[2956]	2269	/* later */
[2952]	2270	return 0;
	2271	}
	2272
	2273
	2274	/** @copydoc kLdrModCallTerm */
	2275	static int kldrModMachOCallTerm(PKLDRMOD pMod, uintptr_t uHandle)
	2276	{
[2956]	2277	/* later */
[2952]	2278	return 0;
	2279	}
	2280
	2281
	2282	/** @copydoc kLdrModCallThread */
	2283	static int kldrModMachOCallThread(PKLDRMOD pMod, uintptr_t uHandle, unsigned fAttachingOrDetaching)
	2284	{
[2956]	2285	/* Relevant for Mach-O? */
[2952]	2286	return 0;
	2287	}
	2288
	2289
	2290	/** @copydoc kLdrModSize */
	2291	static KLDRADDR kldrModMachOSize(PKLDRMOD pMod)
	2292	{
	2293	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
[2955]	2294	return pModMachO->cbImage;
[2952]	2295	}
	2296
	2297
	2298	/** @copydoc kLdrModGetBits */
	2299	static int kldrModMachOGetBits(PKLDRMOD pMod, void pvBits, KLDRADDR BaseAddress, PFNKLDRMODGETIMPORT pfnGetImport, void pvUser)
	2300	{
	2301	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
	2302	uint32_t i;
	2303	int rc;
	2304
	2305	/*
	2306	* Zero the entire buffer first to simplify things.
	2307	*/
[2956]	2308	kLdrHlpMemSet(pvBits, 0, (size_t)pModMachO->cbImage);
[2952]	2309
	2310	/*
[2956]	2311	* When possible use the segment table to load the data.
	2312	* If not iterate the load commands and execute the segment / section loads.
[2952]	2313	*/
[2962]	2314	if (pModMachO->fMapUsingLoadCommandSections)
	2315	return KLDR_ERR_TODO; /* deal with this if it ever occurs. */
	2316	else
[2952]	2317	{
[2956]	2318	for (i = 0; i < pMod->cSegments; i++)
	2319	{
	2320	/* skip it? */
	2321	if ( pMod->aSegments[i].cbFile == -1
	2322	\|\| pMod->aSegments[i].offFile == -1
	2323	\|\| pMod->aSegments[i].LinkAddress == NIL_KLDRADDR
	2324	\|\| !pMod->aSegments[i].Alignment)
	2325	continue;
	2326	rc = kLdrRdrRead(pMod->pRdr,
	2327	(uint8_t *)pvBits + (pMod->aSegments[i].LinkAddress - pModMachO->LinkAddress),
	2328	pMod->aSegments[i].cbFile,
	2329	pMod->aSegments[i].offFile);
	2330	if (rc)
	2331	return rc;
	2332	}
[2952]	2333	}
	2334
	2335	/*
	2336	* Perform relocations.
	2337	*/
[2956]	2338	return kldrModMachORelocateBits(pMod, pvBits, BaseAddress, pModMachO->LinkAddress, pfnGetImport, pvUser);
[2952]	2339	}
	2340
	2341
	2342	/** @copydoc kLdrModRelocateBits */
	2343	static int kldrModMachORelocateBits(PKLDRMOD pMod, void *pvBits, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress,
[2954]	2344	PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser)
[2952]	2345	{
	2346	PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
	2347	int rc;
	2348
	2349	/*
	2350	* Call workers to do the jobs.
	2351	*/
[2961]	2352	if (pModMachO->Hdr.filetype == MH_OBJECT)
	2353	{
	2354	rc = kldrModMachOObjDoImports(pModMachO, pfnGetImport, pvUser);
	2355	if (!rc)
	2356	rc = kldrModMachOObjDoFixups(pModMachO, pvBits, NewBaseAddress);
[2952]	2357
[2961]	2358	}
	2359	else
	2360	rc = KLDR_ERR_TODO;
	2361	/*{
	2362	rc = kldrModMachODoFixups(pModMachO, pvBits, NewBaseAddress, OldBaseAddress, pfnGetImport, pvUser);
	2363	if (!rc)
	2364	rc = kldrModMachODoImports(pModMachO, pvBits, pfnGetImport, pvUser);
	2365	}*/
	2366
[2952]	2367	return rc;
	2368	}
	2369
	2370
	2371	/**
[2954]	2372	* The Mach-O module interpreter method table.
[2952]	2373	*/
[2954]	2374	KLDRMODOPS g_kLdrModMachOOps =
[2952]	2375	{
[2954]	2376	"Mach-O",
[2952]	2377	NULL,
	2378	kldrModMachOCreate,
	2379	kldrModMachODestroy,
	2380	kldrModMachOQuerySymbol,
	2381	kldrModMachOEnumSymbols,
	2382	kldrModMachOGetImport,
	2383	kldrModMachONumberOfImports,
	2384	NULL /* can execute one is optional */,
	2385	kldrModMachOGetStackInfo,
	2386	kldrModMachOQueryMainEntrypoint,
	2387	NULL,
	2388	NULL,
	2389	kldrModMachOEnumDbgInfo,
	2390	kldrModMachOHasDbgInfo,
	2391	kldrModMachOMap,
	2392	kldrModMachOUnmap,
	2393	kldrModMachOAllocTLS,
	2394	kldrModMachOFreeTLS,
	2395	kldrModMachOReload,
	2396	kldrModMachOFixupMapping,
	2397	kldrModMachOCallInit,
	2398	kldrModMachOCallTerm,
	2399	kldrModMachOCallThread,
	2400	kldrModMachOSize,
	2401	kldrModMachOGetBits,
	2402	kldrModMachORelocateBits,
	2403	NULL, /** @todo mostly done */
	2404	42 /* the end */
	2405	};
	2406

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

Download in other formats: