[apple/xnu.git] / bsd / kern / mach_header.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This 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 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.
 */

#if !defined(KERNEL_PRELOAD)
#include <kern/mach_header.h>

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)
 */
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;
}

#if FIXME  /* [ */
struct mach_header **
getmachheaders(void)
{
	extern struct mach_header _mh_execute_header;
	struct mach_header **tl;
	tl = (struct mach_header **)malloc(2*sizeof(struct mach_header *));
	tl[0] = &_mh_execute_header;
	tl[1] = (struct mach_header *)0;
	return tl;
}
#endif  /* FIXME ] */

/*
 * 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.
 */
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.
 */
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.
 */
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);
}

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
	}
};

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.
 */
struct segment_command *firstseg(void)
{
	return firstsegfromheader(&_mh_execute_header);
}

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;
}

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;
}

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.
 */
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.
 */
struct section *
getsectbyname(
    char *segname,
    char *sectname)
{
	return(getsectbynamefromheader(
		(struct mach_header *)&_mh_execute_header, segname, sectname));
}

struct section *firstsect(struct segment_command *sgp)
{
	struct section *sp;

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

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

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.
 */
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
}

/*
 * 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;
}
#endif  /* !defined(KERNEL_PRELOAD) */
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/*
	23	* File: kern/mach_header.c
	24	*
	25	* Functions for accessing mach-o headers.
	26	*
	27	* HISTORY
	28	* 27-MAR-97 Umesh Vaishampayan (umeshv@NeXT.com)
	29	* Added getsegdatafromheader();
	30	*
	31	* 29-Jan-92 Mike DeMoney (mike@next.com)
	32	* Made into machine independent form from machdep/m68k/mach_header.c.
	33	* Ifdef'ed out most of this since I couldn't find any references.
	34	*/
	35
	36	#if !defined(KERNEL_PRELOAD)
	37	#include <kern/mach_header.h>
	38
	39	extern struct mach_header _mh_execute_header;
	40
	41	struct section *getsectbynamefromheader(
	42	struct mach_header *header,
	43	char *seg_name,
	44	char *sect_name);
	45	struct segment_command *getsegbynamefromheader(
	46	struct mach_header *header,
	47	char *seg_name);
	48
	49	/*
	50	* return the last address (first avail)
	51	*/
	52	vm_offset_t getlastaddr(void)
	53	{
	54	struct segment_command *sgp;
	55	vm_offset_t last_addr = 0;
	56	struct mach_header *header = &_mh_execute_header;
	57	int i;
	58
	59	sgp = (struct segment_command *)
	60	((char *)header + sizeof(struct mach_header));
	61	for (i = 0; i < header->ncmds; i++){
	62	if ( sgp->cmd == LC_SEGMENT) {
	63	if (sgp->vmaddr + sgp->vmsize > last_addr)
	64	last_addr = sgp->vmaddr + sgp->vmsize;
65	}
66	sgp = (struct segment_command )((char )sgp + sgp->cmdsize);
67	}
68	return last_addr;
69	}
70
71	#if FIXME /* [ */
72	struct mach_header **
73	getmachheaders(void)
74	{
75	extern struct mach_header _mh_execute_header;
76	struct mach_header **tl;
77	tl = (struct mach_header *)malloc(2sizeof(struct mach_header *));
78	tl[0] = &_mh_execute_header;
79	tl[1] = (struct mach_header *)0;
80	return tl;
81	}
82	#endif /* FIXME ] */
83
84	/*
85	* This routine returns the a pointer to the data for the named section in the
86	* named segment if it exist in the mach header passed to it. Also it returns
87	* the size of the section data indirectly through the pointer size. Otherwise
88	* it returns zero for the pointer and the size.
89	*/
90	void *
91	getsectdatafromheader(
92	struct mach_header *mhp,
93	char *segname,
94	char *sectname,
95	int *size)
96	{
97	const struct section *sp;
98	void *result;
99
100	sp = getsectbynamefromheader(mhp, segname, sectname);
101	if(sp == (struct section *)0){
102	*size = 0;
103	return((char *)0);
104	}
105	*size = sp->size;
106	result = (void *)sp->addr;
107	return result;
108	}
109
110	/*
111	* This routine returns the a pointer to the data for the named segment
112	* if it exist in the mach header passed to it. Also it returns
113	* the size of the segment data indirectly through the pointer size.
114	* Otherwise it returns zero for the pointer and the size.
115	*/
116	void *
117	getsegdatafromheader(
118	struct mach_header *mhp,
119	char *segname,
120	int *size)
121	{
122	const struct segment_command *sc;
123	void *result;
124
125	sc = getsegbynamefromheader(mhp, segname);
126	if(sc == (struct segment_command *)0){
127	*size = 0;
128	return((char *)0);
129	}
130	*size = sc->vmsize;
131	result = (void *)sc->vmaddr;
132	return result;
133	}
134
135	/*
136	* This routine returns the section structure for the named section in the
137	* named segment for the mach_header pointer passed to it if it exist.
138	* Otherwise it returns zero.
139	*/
140	struct section *
141	getsectbynamefromheader(
142	struct mach_header *mhp,
143	char *segname,
144	char *sectname)
145	{
146	struct segment_command *sgp;
147	struct section *sp;
148	long i, j;
149
150	sgp = (struct segment_command *)
151	((char *)mhp + sizeof(struct mach_header));
152	for(i = 0; i < mhp->ncmds; i++){
153	if(sgp->cmd == LC_SEGMENT)
154	if(strncmp(sgp->segname, segname, sizeof(sgp->segname)) == 0 \|\|
155	mhp->filetype == MH_OBJECT){
156	sp = (struct section )((char )sgp +
157	sizeof(struct segment_command));
158	for(j = 0; j < sgp->nsects; j++){
159	if(strncmp(sp->sectname, sectname,
160	sizeof(sp->sectname)) == 0 &&
161	strncmp(sp->segname, segname,
162	sizeof(sp->segname)) == 0)
163	return(sp);
164	sp = (struct section )((char )sp +
165	sizeof(struct section));
166	}
167	}
168	sgp = (struct segment_command )((char )sgp + sgp->cmdsize);
169	}
170	return((struct section *)0);
171	}
172
173	struct segment_command *getsegbynamefromheader(
174	struct mach_header *header,
175	char *seg_name)
176	{
177	struct segment_command *sgp;
178	int i;
179
180	sgp = (struct segment_command *)
181	((char *)header + sizeof(struct mach_header));
182	for (i = 0; i < header->ncmds; i++){
183	if ( sgp->cmd == LC_SEGMENT
184	&& !strncmp(sgp->segname, seg_name, sizeof(sgp->segname)))
185	return sgp;
186	sgp = (struct segment_command )((char )sgp + sgp->cmdsize);
187	}
188	return (struct segment_command *)0;
189	}
190
191
192	/*
193	* For now at least, all the rest of this seems unused.
194	* NOTE: The constant in here for segment alignment is machine-dependent,
195	* so if you include this, define a machine dependent constant for it's
196	* value.
197	*/
198	static struct {
199	struct segment_command seg;
200	struct section sect;
201	} fvm_data = {
202	{
203	LC_SEGMENT, // cmd
204	sizeof(fvm_data), // cmdsize
205	"__USER", // segname
206	0, // vmaddr
207	0, // vmsize
208	0, // fileoff
209	0, // filesize
210	VM_PROT_READ, // maxprot
211	VM_PROT_READ, // initprot,
212	1, // nsects
213	0 // flags
214	},
215	{
216	"", // sectname
217	"__USER", // segname
218	0, // addr
219	0, // size
220	0, // offset
221	4, // align
222	0, // reloff
223	0, // nreloc
224	0 // flags
225	}
226	};
227
228	struct segment_command *fvm_seg;
229
230	static struct fvmfile_command fvmfilefromheader(struct mach_header header);
231	static vm_offset_t getsizeofmacho(struct mach_header *header);
232
233	/*
234	* Return the first segment_command in the header.
235	*/
236	struct segment_command *firstseg(void)
237	{
238	return firstsegfromheader(&_mh_execute_header);
239	}
240
241	struct segment_command firstsegfromheader(struct mach_header header)
242	{
243	struct segment_command *sgp;
244	int i;
245
246	sgp = (struct segment_command *)
247	((char *)header + sizeof(struct mach_header));
248	for (i = 0; i < header->ncmds; i++){
249	if (sgp->cmd == LC_SEGMENT)
250	return sgp;
251	sgp = (struct segment_command )((char )sgp + sgp->cmdsize);
252	}
253	return (struct segment_command *)0;
254	}
255
256	struct segment_command nextseg(struct segment_command sgp)
257	{
258	struct segment_command *this;
259
260	this = nextsegfromheader(&_mh_execute_header, sgp);
261
262	/*
263	* For the kernel's header add on the faked segment for the
264	* USER boot code identified by a FVMFILE_COMMAND in the mach header.
265	*/
266	if (!this && sgp != fvm_seg)
267	this = fvm_seg;
268
269	return this;
270	}
271
272	struct segment_command *nextsegfromheader(
273	struct mach_header *header,
274	struct segment_command *seg)
275	{
276	struct segment_command *sgp;
277	int i;
278
279	sgp = (struct segment_command *)
280	((char *)header + sizeof(struct mach_header));
281	for (i = 0; i < header->ncmds; i++) {
282	if (sgp == seg)
283	break;
284	sgp = (struct segment_command )((char )sgp + sgp->cmdsize);
285	}
286
287	if (i == header->ncmds)
288	return (struct segment_command *)0;
289
290	sgp = (struct segment_command )((char )sgp + sgp->cmdsize);
291	for (; i < header->ncmds; i++) {
292	if (sgp->cmd == LC_SEGMENT)
293	return sgp;
294	sgp = (struct segment_command )((char )sgp + sgp->cmdsize);
295	}
296
297	return (struct segment_command *)0;
298	}
299
300
301	/*
302	* Return the address of the named Mach-O segment, or NULL.
303	*/
304	struct segment_command getsegbyname(char seg_name)
305	{
306	struct segment_command *this;
307
308	this = getsegbynamefromheader(&_mh_execute_header, seg_name);
309
310	/*
311	* For the kernel's header add on the faked segment for the
312	* USER boot code identified by a FVMFILE_COMMAND in the mach header.
313	*/
314	if (!this && strcmp(seg_name, fvm_seg->segname) == 0)
315	this = fvm_seg;
316
317	return this;
318	}
319
320	/*
321	* This routine returns the a pointer the section structure of the named
322	* section in the named segment if it exist in the mach executable it is
323	* linked into. Otherwise it returns zero.
324	*/
325	struct section *
326	getsectbyname(
327	char *segname,
328	char *sectname)
329	{
330	return(getsectbynamefromheader(
331	(struct mach_header *)&_mh_execute_header, segname, sectname));
332	}
333
334	struct section firstsect(struct segment_command sgp)
335	{
336	struct section *sp;
337
338	if (!sgp \|\| sgp->nsects == 0)
339	return (struct section *)0;
340
341	return (struct section *)(sgp+1);
342	}
343
344	struct section nextsect(struct segment_command sgp, struct section *sp)
345	{
346	struct section *fsp = firstsect(sgp);
347
348	if (sp - fsp >= sgp->nsects-1)
349	return (struct section *)0;
350
351	return sp+1;
352	}
353
354	static struct fvmfile_command fvmfilefromheader(struct mach_header header)
355	{
356	struct fvmfile_command *fvp;
357	int i;
358
359	fvp = (struct fvmfile_command *)
360	((char *)header + sizeof(struct mach_header));
361	for (i = 0; i < header->ncmds; i++){
362	if (fvp->cmd == LC_FVMFILE)
363	return fvp;
364	fvp = (struct fvmfile_command )((char )fvp + fvp->cmdsize);
365	}
366	return (struct fvmfile_command *)0;
367	}
368
369	/*
370	* Create a fake USER seg if a fvmfile_command is present.
371	*/
372	struct segment_command *getfakefvmseg(void)
373	{
374	struct segment_command *sgp = getsegbyname("__USER");
375	struct fvmfile_command *fvp = fvmfilefromheader(&_mh_execute_header);
376	struct section *sp;
377
378	if (sgp)
379	return sgp;
380
381	if (!fvp)
382	return (struct segment_command *)0;
383
384	fvm_seg = &fvm_data.seg;
385	sgp = fvm_seg;
386	sp = &fvm_data.sect;
387
388	sgp->vmaddr = fvp->header_addr;
389	sgp->vmsize = getsizeofmacho((struct mach_header *)(sgp->vmaddr));
390
391	strcpy(sp->sectname, fvp->name.ptr);
392	sp->addr = sgp->vmaddr;
393	sp->size = sgp->vmsize;
394
395	#if DEBUG
396	printf("fake fvm seg __USER/\"%s\" at 0x%x, size 0x%x\n",
397	sp->sectname, sp->addr, sp->size);
398	#endif DEBUG
399	}
400
401	/*
402	* Figure out the size the size of the data associated with a
403	* loaded mach_header.
404	*/
405	static vm_offset_t getsizeofmacho(struct mach_header *header)
406	{
407	struct segment_command *sgp;
408	struct section *sp;
409	vm_offset_t last_addr;
410
411	last_addr = 0;
412	for ( sgp = firstsegfromheader(header)
413	; sgp
414	; sgp = nextsegfromheader(header, sgp))
415	{
416	if (sgp->fileoff + sgp->filesize > last_addr)
417	last_addr = sgp->fileoff + sgp->filesize;
418	}
419
420	return last_addr;
421	}
422	#endif /* !defined(KERNEL_PRELOAD) */