[apple/xnu.git] / osfmk / mach-o / mach_header.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 *	File: kern/mach_header.c
 *
 *	Functions for accessing mach-o headers.
 *
 * HISTORY
 * 27-MAR-97  Umesh Vaishampayan (umeshv@NeXT.com)
 *	Added getsegdatafromheader();
 *
 * 29-Jan-92  Mike DeMoney (mike@next.com)
 *	Made into machine independent form from machdep/m68k/mach_header.c.
 *	Ifdef'ed out most of this since I couldn't find any references.
 */

#include <vm/vm_map.h>
#include <vm/vm_kern.h>
#include <mach-o/mach_header.h>

#ifdef __MACHO__

extern struct mach_header _mh_execute_header;

struct section *getsectbynamefromheader(
	struct mach_header	*header,
	char			*seg_name,
	char			*sect_name);
struct segment_command *getsegbynamefromheader(
	struct mach_header	*header,
	char			*seg_name);

/*
 * return the last address (first avail)
 */
#ifdef	MACH_BSD
__private_extern__
#endif
vm_offset_t getlastaddr(void)
{
	struct segment_command	*sgp;
	vm_offset_t		last_addr = 0;
	struct mach_header *header = &_mh_execute_header;
	int i;

	sgp = (struct segment_command *)
		((char *)header + sizeof(struct mach_header));
	for (i = 0; i < header->ncmds; i++){
		if (   sgp->cmd == LC_SEGMENT) {
			if (sgp->vmaddr + sgp->vmsize > last_addr)
				last_addr = sgp->vmaddr + sgp->vmsize;
		}
		sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize);
	}
	return last_addr;
}

#ifdef	XXX_MACH_BSD
__private_extern__
#endif
struct mach_header **
getmachheaders(void)
{
	extern struct mach_header _mh_execute_header;
	struct mach_header **tl;
	
	if (kmem_alloc(kernel_map, (vm_offset_t *) &tl, 2*sizeof(struct mach_header *)) != KERN_SUCCESS)
		return	NULL;

	tl[0] = &_mh_execute_header;
	tl[1] = (struct mach_header *)0;
	return tl;
}

/*
 * This routine returns the a pointer to the data for the named section in the
 * named segment if it exist in the mach header passed to it.  Also it returns
 * the size of the section data indirectly through the pointer size.  Otherwise
 *  it returns zero for the pointer and the size.
 */
#ifdef	MACH_BSD
__private_extern__
#endif
void *
getsectdatafromheader(
    struct mach_header *mhp,
    char *segname,
    char *sectname,
    int *size)
{		
	const struct section *sp;
	void *result;

	sp = getsectbynamefromheader(mhp, segname, sectname);
	if(sp == (struct section *)0){
	    *size = 0;
	    return((char *)0);
	}
	*size = sp->size;
	result = (void *)sp->addr;
	return result;
}

/*
 * This routine returns the a pointer to the data for the named segment
 * if it exist in the mach header passed to it.  Also it returns
 * the size of the segment data indirectly through the pointer size.
 * Otherwise it returns zero for the pointer and the size.
 */
#ifdef	MACH_BSD
__private_extern__
#endif
void *
getsegdatafromheader(
    struct mach_header *mhp,
	char *segname,
	int *size)
{
	const struct segment_command *sc;
	void *result;

	sc = getsegbynamefromheader(mhp, segname);
	if(sc == (struct segment_command *)0){
	    *size = 0;
	    return((char *)0);
	}
	*size = sc->vmsize;
	result = (void *)sc->vmaddr;
	return result;
}

/*
 * This routine returns the section structure for the named section in the
 * named segment for the mach_header pointer passed to it if it exist.
 * Otherwise it returns zero.
 */
#ifdef	MACH_BSD
__private_extern__
#endif
struct section *
getsectbynamefromheader(
    struct mach_header *mhp,
    char *segname,
    char *sectname)
{
	struct segment_command *sgp;
	struct section *sp;
	long i, j;

	sgp = (struct segment_command *)
	      ((char *)mhp + sizeof(struct mach_header));
	for(i = 0; i < mhp->ncmds; i++){
	    if(sgp->cmd == LC_SEGMENT)
		if(strncmp(sgp->segname, segname, sizeof(sgp->segname)) == 0 ||
		   mhp->filetype == MH_OBJECT){
		    sp = (struct section *)((char *)sgp +
			 sizeof(struct segment_command));
		    for(j = 0; j < sgp->nsects; j++){
			if(strncmp(sp->sectname, sectname,
			   sizeof(sp->sectname)) == 0 &&
			   strncmp(sp->segname, segname,
			   sizeof(sp->segname)) == 0)
			    return(sp);
			sp = (struct section *)((char *)sp +
			     sizeof(struct section));
		    }
		}
	    sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize);
	}
	return((struct section *)0);
}

#ifdef	MACH_BSD
__private_extern__
#endif
struct segment_command *getsegbynamefromheader(
	struct mach_header	*header,
	char			*seg_name)
{
	struct segment_command *sgp;
	int i;

	sgp = (struct segment_command *)
		((char *)header + sizeof(struct mach_header));
	for (i = 0; i < header->ncmds; i++){
		if (   sgp->cmd == LC_SEGMENT
		    && !strncmp(sgp->segname, seg_name, sizeof(sgp->segname)))
			return sgp;
		sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize);
	}
	return (struct segment_command *)0;
}


/*
 * For now at least, all the rest of this seems unused.
 * NOTE: The constant in here for segment alignment is machine-dependent,
 * so if you include this, define a machine dependent constant for it's
 * value.
 */
static struct {
	struct segment_command	seg;
	struct section		sect;
} fvm_data = {
	{
		LC_SEGMENT, 		// cmd
		sizeof(fvm_data),	// cmdsize
		"__USER",		// segname
		0,			// vmaddr
		0,			// vmsize
		0,			// fileoff
		0,			// filesize
		VM_PROT_READ,		// maxprot
		VM_PROT_READ,		// initprot,
		1,			// nsects
		0			// flags
	},
	{
		"",			// sectname
		"__USER",		// segname
		0,			// addr
		0,			// size
		0,			// offset
		4,			// align
		0,			// reloff
		0,			// nreloc
		0			// flags
	}
};

#ifdef	MACH_BSD
static
#endif
struct segment_command *fvm_seg;

static struct fvmfile_command *fvmfilefromheader(struct mach_header *header);
static vm_offset_t getsizeofmacho(struct mach_header *header);

/*
 * Return the first segment_command in the header.
 */
#ifdef	MACH_BSD
__private_extern__
#endif
struct segment_command *firstseg(void)
{
	return firstsegfromheader(&_mh_execute_header);
}

#ifdef	MACH_BSD
__private_extern__
#endif
struct segment_command *firstsegfromheader(struct mach_header *header)
{
	struct segment_command *sgp;
	int i;

	sgp = (struct segment_command *)
		((char *)header + sizeof(struct mach_header));
	for (i = 0; i < header->ncmds; i++){
		if (sgp->cmd == LC_SEGMENT)
			return sgp;
		sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize);
	}
	return (struct segment_command *)0;
}

#ifdef	MACH_BSD
__private_extern__
#endif
struct segment_command *nextseg(struct segment_command *sgp)
{
	struct segment_command *this;

	this = nextsegfromheader(&_mh_execute_header, sgp);

	/*
	 * For the kernel's header add on the faked segment for the
	 * USER boot code identified by a FVMFILE_COMMAND in the mach header.
	 */
	if (!this && sgp != fvm_seg)
		this = fvm_seg;

	return this;
}

#ifdef	MACH_BSD
__private_extern__
#endif
struct segment_command *nextsegfromheader(
	struct mach_header	*header,
	struct segment_command	*seg)
{
	struct segment_command *sgp;
	int i;

	sgp = (struct segment_command *)
		((char *)header + sizeof(struct mach_header));
	for (i = 0; i < header->ncmds; i++) {
		if (sgp == seg)
			break;
		sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize);
	}

	if (i == header->ncmds)
		return (struct segment_command *)0;

	sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize);
	for (; i < header->ncmds; i++) {
		if (sgp->cmd == LC_SEGMENT)
			return sgp;
		sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize);
	}

	return (struct segment_command *)0;
}


/*
 * Return the address of the named Mach-O segment, or NULL.
 */
#ifdef	MACH_BSD
__private_extern__
#endif
struct segment_command *getsegbyname(char *seg_name)
{
	struct segment_command *this;

	this = getsegbynamefromheader(&_mh_execute_header, seg_name);

	/*
	 * For the kernel's header add on the faked segment for the
	 * USER boot code identified by a FVMFILE_COMMAND in the mach header.
	 */
	if (!this && strcmp(seg_name, fvm_seg->segname) == 0)
		this = fvm_seg;

	return this;
}

/*
 * This routine returns the a pointer the section structure of the named
 * section in the named segment if it exist in the mach executable it is
 * linked into.  Otherwise it returns zero.
 */
#ifdef	MACH_BSD
__private_extern__
#endif
struct section *
getsectbyname(
    char *segname,
    char *sectname)
{
	return(getsectbynamefromheader(
		(struct mach_header *)&_mh_execute_header, segname, sectname));
}

#ifdef	MACH_BSD
__private_extern__
#endif
struct section *firstsect(struct segment_command *sgp)
{
	struct section *sp;

	if (!sgp || sgp->nsects == 0)
		return (struct section *)0;

	return (struct section *)(sgp+1);
}

#ifdef	MACH_BSD
__private_extern__
#endif
struct section *nextsect(struct segment_command *sgp, struct section *sp)
{
	struct section *fsp = firstsect(sgp);

	if (sp - fsp >= sgp->nsects-1)
		return (struct section *)0;

	return sp+1;
}

static struct fvmfile_command *fvmfilefromheader(struct mach_header *header)
{
	struct fvmfile_command *fvp;
	int i;

	fvp = (struct fvmfile_command *)
		((char *)header + sizeof(struct mach_header));
	for (i = 0; i < header->ncmds; i++){
		if (fvp->cmd == LC_FVMFILE)
			return fvp;
		fvp = (struct fvmfile_command *)((char *)fvp + fvp->cmdsize);
	}
	return (struct fvmfile_command *)0;
}

/*
 * Create a fake USER seg if a fvmfile_command is present.
 */
#ifdef	MACH_BSD
__private_extern__
#endif
struct segment_command *getfakefvmseg(void)
{
	struct segment_command *sgp = getsegbyname("__USER");
	struct fvmfile_command *fvp = fvmfilefromheader(&_mh_execute_header);
	struct section *sp;

	if (sgp)
		return sgp;

	if (!fvp)
		return (struct segment_command *)0;

	fvm_seg = &fvm_data.seg;
	sgp = fvm_seg;
	sp = &fvm_data.sect;

	sgp->vmaddr = fvp->header_addr;
	sgp->vmsize = getsizeofmacho((struct mach_header *)(sgp->vmaddr));

	strcpy(sp->sectname, fvp->name.ptr);
	sp->addr = sgp->vmaddr;
	sp->size = sgp->vmsize;

#if	DEBUG
	printf("fake fvm seg __USER/\"%s\" at 0x%x, size 0x%x\n",
		sp->sectname, sp->addr, sp->size);
#endif	/*DEBUG*/
	return sgp;
}

/*
 * Figure out the size the size of the data associated with a
 * loaded mach_header.
 */
static vm_offset_t getsizeofmacho(struct mach_header *header)
{
	struct segment_command	*sgp;
	struct section		*sp;
	vm_offset_t		last_addr;

	last_addr = 0;
	for (  sgp = firstsegfromheader(header)
	    ; sgp
	    ; sgp = nextsegfromheader(header, sgp))
	{
		if (sgp->fileoff + sgp->filesize > last_addr)
			last_addr = sgp->fileoff + sgp->filesize;
	}

	return last_addr;
}

#ifdef MACH_KDB
/*
 * This routine returns the section command for the symbol table in the
 * named segment for the mach_header pointer passed to it if it exist.
 * Otherwise it returns zero.
 */
struct symtab_command *
getsectcmdsymtabfromheader(
	struct mach_header *mhp)
{
	struct segment_command *sgp;
	struct section *sp;
	long i;

	sgp = (struct segment_command *)
		((char *)mhp + sizeof(struct mach_header));
	for(i = 0; i < mhp->ncmds; i++){
		if(sgp->cmd == LC_SYMTAB)
		return((struct symtab_command *)sgp);
		sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize);
	}
	return(NULL);
}

boolean_t getsymtab(struct mach_header *header,
			vm_offset_t *symtab,
			int *nsyms,
			vm_offset_t *strtab,
			vm_size_t *strtabsize)
{
	struct segment_command *seglink_cmd;
	struct symtab_command *symtab_cmd;

	seglink_cmd = NULL;
	
	if(header->magic != MH_MAGIC) {						/* Check if this is a valid header format */
		printf("Attempt to use invalid header (magic = %08X) to find symbol table\n", 
			header->magic);								/* Tell them what's wrong */
		return (FALSE);									/* Bye y'all... */
	}
	
	seglink_cmd = getsegbynamefromheader(header,"__LINKEDIT");
	if (seglink_cmd == NULL) {
		return(FALSE);
	}

	symtab_cmd = NULL;
	symtab_cmd = getsectcmdsymtabfromheader(header);
	if (symtab_cmd == NULL)
		return(FALSE);

	*nsyms = symtab_cmd->nsyms;
	if(symtab_cmd->nsyms == 0) return (FALSE);	/* No symbols */

	*strtabsize = symtab_cmd->strsize;
	if(symtab_cmd->strsize == 0) return (FALSE);	/* Symbol length is 0 */
	
	*symtab = seglink_cmd->vmaddr + symtab_cmd->symoff -
		seglink_cmd->fileoff;

	*strtab = seglink_cmd->vmaddr + symtab_cmd->stroff -
			seglink_cmd->fileoff;

	return(TRUE);
}
#endif

#else

void * getsegdatafromheader( struct mach_header *mhp, char *segname, int *size)
{
	return	0;
}

#endif
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
43866e37	6	* Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved.
1c79356b	7	*
43866e37 A	8	* This file contains Original Code and/or Modifications of Original Code
	9	* as defined in and that are subject to the Apple Public Source License
	10	* Version 2.0 (the 'License'). You may not use this file except in
	11	* compliance with the License. Please obtain a copy of the License at
	12	* http://www.opensource.apple.com/apsl/ and read it before using this
	13	* file.
	14	*
	15	* The Original Code and all software distributed under the License are
	16	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
1c79356b A	17	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
1c79356b A	18	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
43866e37 A	19	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	20	* Please see the License for the specific language governing rights and
	21	* limitations under the License.
1c79356b A	22	*
	23	* @APPLE_LICENSE_HEADER_END@
	24	*/
	25	/*
	26	* File: kern/mach_header.c
	27	*
	28	* Functions for accessing mach-o headers.
	29	*
	30	* HISTORY
	31	* 27-MAR-97 Umesh Vaishampayan (umeshv@NeXT.com)
	32	* Added getsegdatafromheader();
	33	*
	34	* 29-Jan-92 Mike DeMoney (mike@next.com)
	35	* Made into machine independent form from machdep/m68k/mach_header.c.
	36	* Ifdef'ed out most of this since I couldn't find any references.
	37	*/
	38
	39	#include <vm/vm_map.h>
	40	#include <vm/vm_kern.h>
	41	#include <mach-o/mach_header.h>
	42
	43	#ifdef __MACHO__
	44
	45	extern struct mach_header _mh_execute_header;
	46
	47	struct section *getsectbynamefromheader(
	48	struct mach_header *header,
	49	char *seg_name,
	50	char *sect_name);
	51	struct segment_command *getsegbynamefromheader(
	52	struct mach_header *header,
	53	char *seg_name);
	54
	55	/*
	56	* return the last address (first avail)
	57	*/
	58	#ifdef MACH_BSD
	59	__private_extern__
	60	#endif
	61	vm_offset_t getlastaddr(void)
	62	{
	63	struct segment_command *sgp;
	64	vm_offset_t last_addr = 0;
	65	struct mach_header *header = &_mh_execute_header;
	66	int i;
	67
	68	sgp = (struct segment_command *)
	69	((char *)header + sizeof(struct mach_header));
	70	for (i = 0; i < header->ncmds; i++){
	71	if ( sgp->cmd == LC_SEGMENT) {
	72	if (sgp->vmaddr + sgp->vmsize > last_addr)
	73	last_addr = sgp->vmaddr + sgp->vmsize;
	74	}
	75	sgp = (struct segment_command )((char )sgp + sgp->cmdsize);
	76	}
	77	return last_addr;
	78	}
	79
	80	#ifdef XXX_MACH_BSD
	81	__private_extern__
	82	#endif
	83	struct mach_header **
	84	getmachheaders(void)
	85	{
86	extern struct mach_header _mh_execute_header;
87	struct mach_header **tl;
88
89	if (kmem_alloc(kernel_map, (vm_offset_t ) &tl, 2sizeof(struct mach_header *)) != KERN_SUCCESS)
90	return NULL;
91
92	tl[0] = &_mh_execute_header;
93	tl[1] = (struct mach_header *)0;
94	return tl;
95	}
96
97	/*
98	* This routine returns the a pointer to the data for the named section in the
99	* named segment if it exist in the mach header passed to it. Also it returns
100	* the size of the section data indirectly through the pointer size. Otherwise
101	* it returns zero for the pointer and the size.
102	*/
103	#ifdef MACH_BSD
104	__private_extern__
105	#endif
106	void *
107	getsectdatafromheader(
108	struct mach_header *mhp,
109	char *segname,
110	char *sectname,
111	int *size)
112	{
113	const struct section *sp;
114	void *result;
115
116	sp = getsectbynamefromheader(mhp, segname, sectname);
117	if(sp == (struct section *)0){
118	*size = 0;
119	return((char *)0);
120	}
121	*size = sp->size;
122	result = (void *)sp->addr;
123	return result;
124	}
125
126	/*
127	* This routine returns the a pointer to the data for the named segment
128	* if it exist in the mach header passed to it. Also it returns
129	* the size of the segment data indirectly through the pointer size.
130	* Otherwise it returns zero for the pointer and the size.
131	*/
132	#ifdef MACH_BSD
133	__private_extern__
134	#endif
135	void *
136	getsegdatafromheader(
137	struct mach_header *mhp,
138	char *segname,
139	int *size)
140	{
141	const struct segment_command *sc;
142	void *result;
143
144	sc = getsegbynamefromheader(mhp, segname);
145	if(sc == (struct segment_command *)0){
146	*size = 0;
147	return((char *)0);
148	}
149	*size = sc->vmsize;
150	result = (void *)sc->vmaddr;
151	return result;
152	}
153
154	/*
155	* This routine returns the section structure for the named section in the
156	* named segment for the mach_header pointer passed to it if it exist.
157	* Otherwise it returns zero.
158	*/
159	#ifdef MACH_BSD
160	__private_extern__
161	#endif
162	struct section *
163	getsectbynamefromheader(
164	struct mach_header *mhp,
165	char *segname,
166	char *sectname)
167	{
168	struct segment_command *sgp;
169	struct section *sp;
170	long i, j;
171
172	sgp = (struct segment_command *)
173	((char *)mhp + sizeof(struct mach_header));
174	for(i = 0; i < mhp->ncmds; i++){
175	if(sgp->cmd == LC_SEGMENT)
176	if(strncmp(sgp->segname, segname, sizeof(sgp->segname)) == 0 \|\|
177	mhp->filetype == MH_OBJECT){
178	sp = (struct section )((char )sgp +
179	sizeof(struct segment_command));
180	for(j = 0; j < sgp->nsects; j++){
181	if(strncmp(sp->sectname, sectname,
182	sizeof(sp->sectname)) == 0 &&
183	strncmp(sp->segname, segname,
184	sizeof(sp->segname)) == 0)
185	return(sp);
186	sp = (struct section )((char )sp +
187	sizeof(struct section));
188	}
189	}
190	sgp = (struct segment_command )((char )sgp + sgp->cmdsize);
191	}
192	return((struct section *)0);
193	}
194
195	#ifdef MACH_BSD
196	__private_extern__
197	#endif
198	struct segment_command *getsegbynamefromheader(
199	struct mach_header *header,
200	char *seg_name)
201	{
202	struct segment_command *sgp;
203	int i;
204
205	sgp = (struct segment_command *)
206	((char *)header + sizeof(struct mach_header));
207	for (i = 0; i < header->ncmds; i++){
208	if ( sgp->cmd == LC_SEGMENT
209	&& !strncmp(sgp->segname, seg_name, sizeof(sgp->segname)))
210	return sgp;
211	sgp = (struct segment_command )((char )sgp + sgp->cmdsize);
212	}
213	return (struct segment_command *)0;
214	}
215
216
217	/*
218	* For now at least, all the rest of this seems unused.
219	* NOTE: The constant in here for segment alignment is machine-dependent,
220	* so if you include this, define a machine dependent constant for it's
221	* value.
222	*/
223	static struct {
224	struct segment_command seg;
225	struct section sect;
226	} fvm_data = {
227	{
228	LC_SEGMENT, // cmd
229	sizeof(fvm_data), // cmdsize
230	"__USER", // segname
231	0, // vmaddr
232	0, // vmsize
233	0, // fileoff
234	0, // filesize
235	VM_PROT_READ, // maxprot
236	VM_PROT_READ, // initprot,
237	1, // nsects
238	0 // flags
239	},
240	{
241	"", // sectname
242	"__USER", // segname
243	0, // addr
244	0, // size
245	0, // offset
246	4, // align
247	0, // reloff
248	0, // nreloc
249	0 // flags
250	}
251	};
252
253	#ifdef MACH_BSD
254	static
255	#endif
256	struct segment_command *fvm_seg;
257
258	static struct fvmfile_command fvmfilefromheader(struct mach_header header);
259	static vm_offset_t getsizeofmacho(struct mach_header *header);
260
261	/*
262	* Return the first segment_command in the header.
263	*/
264	#ifdef MACH_BSD
265	__private_extern__
266	#endif
267	struct segment_command *firstseg(void)
268	{
269	return firstsegfromheader(&_mh_execute_header);
270	}
271
272	#ifdef MACH_BSD
273	__private_extern__
274	#endif
275	struct segment_command firstsegfromheader(struct mach_header header)
276	{
277	struct segment_command *sgp;
278	int i;
279
280	sgp = (struct segment_command *)
281	((char *)header + sizeof(struct mach_header));
282	for (i = 0; i < header->ncmds; i++){
283	if (sgp->cmd == LC_SEGMENT)
284	return sgp;
285	sgp = (struct segment_command )((char )sgp + sgp->cmdsize);
286	}
287	return (struct segment_command *)0;
288	}
289
290	#ifdef MACH_BSD
291	__private_extern__
292	#endif
293	struct segment_command nextseg(struct segment_command sgp)
294	{
295	struct segment_command *this;
296
297	this = nextsegfromheader(&_mh_execute_header, sgp);
298
299	/*
300	* For the kernel's header add on the faked segment for the
301	* USER boot code identified by a FVMFILE_COMMAND in the mach header.
302	*/
303	if (!this && sgp != fvm_seg)
304	this = fvm_seg;
305
306	return this;
307	}
308
309	#ifdef MACH_BSD
310	__private_extern__
311	#endif
312	struct segment_command *nextsegfromheader(
313	struct mach_header *header,
314	struct segment_command *seg)
315	{
316	struct segment_command *sgp;
317	int i;
318
319	sgp = (struct segment_command *)
320	((char *)header + sizeof(struct mach_header));
321	for (i = 0; i < header->ncmds; i++) {
322	if (sgp == seg)
323	break;
324	sgp = (struct segment_command )((char )sgp + sgp->cmdsize);
325	}
326
327	if (i == header->ncmds)
328	return (struct segment_command *)0;
329
330	sgp = (struct segment_command )((char )sgp + sgp->cmdsize);
331	for (; i < header->ncmds; i++) {
332	if (sgp->cmd == LC_SEGMENT)
333	return sgp;
334	sgp = (struct segment_command )((char )sgp + sgp->cmdsize);
335	}
336
337	return (struct segment_command *)0;
338	}
339
340
341	/*
342	* Return the address of the named Mach-O segment, or NULL.
343	*/
344	#ifdef MACH_BSD
345	__private_extern__
346	#endif
347	struct segment_command getsegbyname(char seg_name)
348	{
349	struct segment_command *this;
350
351	this = getsegbynamefromheader(&_mh_execute_header, seg_name);
352
353	/*
354	* For the kernel's header add on the faked segment for the
355	* USER boot code identified by a FVMFILE_COMMAND in the mach header.
356	*/
357	if (!this && strcmp(seg_name, fvm_seg->segname) == 0)
358	this = fvm_seg;
359
360	return this;
361	}
362
363	/*
364	* This routine returns the a pointer the section structure of the named
365	* section in the named segment if it exist in the mach executable it is
366	* linked into. Otherwise it returns zero.
367	*/
368	#ifdef MACH_BSD
369	__private_extern__
370	#endif
371	struct section *
372	getsectbyname(
373	char *segname,
374	char *sectname)
375	{
376	return(getsectbynamefromheader(
377	(struct mach_header *)&_mh_execute_header, segname, sectname));
378	}
379
380	#ifdef MACH_BSD
381	__private_extern__
382	#endif
383	struct section firstsect(struct segment_command sgp)
384	{
385	struct section *sp;
386
387	if (!sgp \|\| sgp->nsects == 0)
388	return (struct section *)0;
389
390	return (struct section *)(sgp+1);
391	}
392
393	#ifdef MACH_BSD
394	__private_extern__
395	#endif
396	struct section nextsect(struct segment_command sgp, struct section *sp)
397	{
398	struct section *fsp = firstsect(sgp);
399
400	if (sp - fsp >= sgp->nsects-1)
401	return (struct section *)0;
402
403	return sp+1;
404	}
405
406	static struct fvmfile_command fvmfilefromheader(struct mach_header header)
407	{
408	struct fvmfile_command *fvp;
409	int i;
410
411	fvp = (struct fvmfile_command *)
412	((char *)header + sizeof(struct mach_header));
413	for (i = 0; i < header->ncmds; i++){
414	if (fvp->cmd == LC_FVMFILE)
415	return fvp;
416	fvp = (struct fvmfile_command )((char )fvp + fvp->cmdsize);
417	}
418	return (struct fvmfile_command *)0;
419	}
420
421	/*
422	* Create a fake USER seg if a fvmfile_command is present.
423	*/
424	#ifdef MACH_BSD
425	__private_extern__
426	#endif
427	struct segment_command *getfakefvmseg(void)
428	{
429	struct segment_command *sgp = getsegbyname("__USER");
430	struct fvmfile_command *fvp = fvmfilefromheader(&_mh_execute_header);
431	struct section *sp;
432
433	if (sgp)
434	return sgp;
435
436	if (!fvp)
437	return (struct segment_command *)0;
438
439	fvm_seg = &fvm_data.seg;
440	sgp = fvm_seg;
441	sp = &fvm_data.sect;
442
443	sgp->vmaddr = fvp->header_addr;
444	sgp->vmsize = getsizeofmacho((struct mach_header *)(sgp->vmaddr));
445
446	strcpy(sp->sectname, fvp->name.ptr);
447	sp->addr = sgp->vmaddr;
448	sp->size = sgp->vmsize;
449
450	#if DEBUG
451	printf("fake fvm seg __USER/\"%s\" at 0x%x, size 0x%x\n",
452	sp->sectname, sp->addr, sp->size);
453	#endif /DEBUG/
454	return sgp;
455	}
456
457	/*
458	* Figure out the size the size of the data associated with a
459	* loaded mach_header.
460	*/
461	static vm_offset_t getsizeofmacho(struct mach_header *header)
462	{
463	struct segment_command *sgp;
464	struct section *sp;
465	vm_offset_t last_addr;
466
467	last_addr = 0;
468	for ( sgp = firstsegfromheader(header)
469	; sgp
470	; sgp = nextsegfromheader(header, sgp))
471	{
472	if (sgp->fileoff + sgp->filesize > last_addr)
473	last_addr = sgp->fileoff + sgp->filesize;
474	}
475
476	return last_addr;
477	}
478
479	#ifdef MACH_KDB
480	/*
481	* This routine returns the section command for the symbol table in the
482	* named segment for the mach_header pointer passed to it if it exist.
483	* Otherwise it returns zero.
484	*/
485	struct symtab_command *
486	getsectcmdsymtabfromheader(
487	struct mach_header *mhp)
488	{
489	struct segment_command *sgp;
490	struct section *sp;
491	long i;
492
493	sgp = (struct segment_command *)
494	((char *)mhp + sizeof(struct mach_header));
495	for(i = 0; i < mhp->ncmds; i++){
496	if(sgp->cmd == LC_SYMTAB)
497	return((struct symtab_command *)sgp);
498	sgp = (struct segment_command )((char )sgp + sgp->cmdsize);
499	}
500	return(NULL);
501	}
502
503	boolean_t getsymtab(struct mach_header *header,
504	vm_offset_t *symtab,
505	int *nsyms,
506	vm_offset_t *strtab,
507	vm_size_t *strtabsize)
508	{
509	struct segment_command *seglink_cmd;
510	struct symtab_command *symtab_cmd;
511
512	seglink_cmd = NULL;
513
514	if(header->magic != MH_MAGIC) { /* Check if this is a valid header format */
515	printf("Attempt to use invalid header (magic = %08X) to find symbol table\n",
516	header->magic); /* Tell them what's wrong */
517	return (FALSE); /* Bye y'all... */
518	}
519
520	seglink_cmd = getsegbynamefromheader(header,"__LINKEDIT");
521	if (seglink_cmd == NULL) {
522	return(FALSE);
523	}
524
525	symtab_cmd = NULL;
526	symtab_cmd = getsectcmdsymtabfromheader(header);
527	if (symtab_cmd == NULL)
528	return(FALSE);
529
530	*nsyms = symtab_cmd->nsyms;
531	if(symtab_cmd->nsyms == 0) return (FALSE); /* No symbols */
532
533	*strtabsize = symtab_cmd->strsize;
534	if(symtab_cmd->strsize == 0) return (FALSE); /* Symbol length is 0 */
535
536	*symtab = seglink_cmd->vmaddr + symtab_cmd->symoff -
537	seglink_cmd->fileoff;
538
539	*strtab = seglink_cmd->vmaddr + symtab_cmd->stroff -
540	seglink_cmd->fileoff;
541
542	return(TRUE);
543	}
544	#endif
545
546	#else
547
548	void * getsegdatafromheader( struct mach_header mhp, char segname, int *size)
549	{
550	return 0;
551	}
552
553	#endif