Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

source: trunk/Cocoa/F-Script Anywhere/Source/bytesex.c@ 188

Last change on this file since 188 was 7, checked in by Nicholas Riley, 22 years ago
F-Script Anywhere 1.1.2a1
File size: 56.6 KB

Rev	Line
[7]	1	/*
	2	* Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
	7	* Reserved. This file contains Original Code and/or Modifications of
	8	* Original Code as defined in and that are subject to the Apple Public
	9	* Source License Version 1.1 (the "License"). You may not use this file
	10	* except in compliance with the License. Please obtain a copy of the
	11	* License at http://www.apple.com/publicsource and read it before using
	12	* this file.
	13	*
	14	* The Original Code and all software distributed under the License are
	15	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	16	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	17	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	18	* FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the
	19	* License for the specific language governing rights and limitations
	20	* under the License.
	21	*
	22	* @APPLE_LICENSE_HEADER_END@
	23	*/
	24	/* byte_sex.c */
	25	#include <string.h>
	26	#include <mach-o/fat.h>
	27	#include <mach-o/loader.h>
	28	#import <mach/m68k/thread_status.h>
	29	#import <mach/ppc/thread_status.h>
	30	#import <mach/m88k/thread_status.h>
	31	#import <mach/i860/thread_status.h>
	32	#import <mach/i386/thread_status.h>
	33	#import <mach/hppa/thread_status.h>
	34	#import <mach/sparc/thread_status.h>
	35	#include <mach-o/nlist.h>
	36	#include <mach-o/reloc.h>
	37	#include <mach-o/ranlib.h>
	38	#include "stuff/bool.h"
	39	#include "stuff/bytesex.h"
	40
	41	__private_extern__
	42	double
	43	SWAP_DOUBLE(
	44	double d)
	45	{
	46	union {
	47	char c[8];
	48	double d;
	49	} in, out;
	50	in.d = d;
	51	out.c[0] = in.c[7];
	52	out.c[1] = in.c[6];
	53	out.c[2] = in.c[5];
	54	out.c[3] = in.c[4];
	55	out.c[4] = in.c[3];
	56	out.c[5] = in.c[2];
	57	out.c[6] = in.c[1];
	58	out.c[7] = in.c[0];
	59	return(out.d);
	60	}
	61
	62	__private_extern__
	63	float
	64	SWAP_FLOAT(
	65	float f)
	66	{
	67	union {
	68	char c[7];
	69	float f;
	70	} in, out;
	71	in.f = f;
	72	out.c[0] = in.c[3];
	73	out.c[1] = in.c[2];
	74	out.c[2] = in.c[1];
	75	out.c[3] = in.c[0];
	76	return(out.f);
	77	}
	78
	79	/*
	80	* get_host_byte_sex() returns the enum constant for the byte sex of the host
	81	* it is running on.
	82	*/
	83	__private_extern__
	84	enum byte_sex
	85	get_host_byte_sex(
	86	void)
	87	{
	88	unsigned long s;
	89
	90	s = (BIG_ENDIAN_BYTE_SEX << 24) \| LITTLE_ENDIAN_BYTE_SEX;
	91	return((enum byte_sex)((char )&s));
	92	}
	93
	94	__private_extern__
	95	void
	96	swap_fat_header(
	97	struct fat_header *fat_header,
	98	enum byte_sex target_byte_sex)
	99	{
	100	#ifdef __MWERKS__
	101	enum byte_sex dummy;
	102	dummy = target_byte_sex;
	103	#endif
	104
	105	fat_header->magic = SWAP_LONG(fat_header->magic);
	106	fat_header->nfat_arch = SWAP_LONG(fat_header->nfat_arch);
	107	}
	108
	109	__private_extern__
	110	void
	111	swap_fat_arch(
	112	struct fat_arch *fat_archs,
	113	unsigned long nfat_arch,
	114	enum byte_sex target_byte_sex)
	115	{
	116	unsigned long i;
	117	#ifdef __MWERKS__
	118	enum byte_sex dummy;
	119	dummy = target_byte_sex;
	120	#endif
	121
	122	for(i = 0; i < nfat_arch; i++){
	123	fat_archs[i].cputype = SWAP_LONG(fat_archs[i].cputype);
	124	fat_archs[i].cpusubtype = SWAP_LONG(fat_archs[i].cpusubtype);
	125	fat_archs[i].offset = SWAP_LONG(fat_archs[i].offset);
	126	fat_archs[i].size = SWAP_LONG(fat_archs[i].size);
	127	fat_archs[i].align = SWAP_LONG(fat_archs[i].align);
	128	}
	129	}
	130
	131	__private_extern__
	132	void
	133	swap_mach_header(
	134	struct mach_header *mh,
	135	enum byte_sex target_byte_sex)
	136	{
	137	#ifdef __MWERKS__
	138	enum byte_sex dummy;
	139	dummy = target_byte_sex;
	140	#endif
	141	mh->magic = SWAP_LONG(mh->magic);
	142	mh->cputype = SWAP_LONG(mh->cputype);
	143	mh->cpusubtype = SWAP_LONG(mh->cpusubtype);
	144	mh->filetype = SWAP_LONG(mh->filetype);
	145	mh->ncmds = SWAP_LONG(mh->ncmds);
	146	mh->sizeofcmds = SWAP_LONG(mh->sizeofcmds);
	147	mh->flags = SWAP_LONG(mh->flags);
	148	}
	149
	150	__private_extern__
	151	void
	152	swap_load_command(
	153	struct load_command *lc,
	154	enum byte_sex target_byte_sex)
	155	{
	156	#ifdef __MWERKS__
	157	enum byte_sex dummy;
	158	dummy = target_byte_sex;
	159	#endif
	160	lc->cmd = SWAP_LONG(lc->cmd);
	161	lc->cmdsize = SWAP_LONG(lc->cmdsize);
	162	}
	163
	164	__private_extern__
	165	void
	166	swap_segment_command(
	167	struct segment_command *sg,
	168	enum byte_sex target_byte_sex)
	169	{
	170	#ifdef __MWERKS__
	171	enum byte_sex dummy;
	172	dummy = target_byte_sex;
	173	#endif
	174	/* segname[16] */
	175	sg->cmd = SWAP_LONG(sg->cmd);
	176	sg->cmdsize = SWAP_LONG(sg->cmdsize);
	177	sg->vmaddr = SWAP_LONG(sg->vmaddr);
	178	sg->vmsize = SWAP_LONG(sg->vmsize);
	179	sg->fileoff = SWAP_LONG(sg->fileoff);
	180	sg->filesize = SWAP_LONG(sg->filesize);
	181	sg->maxprot = SWAP_LONG(sg->maxprot);
	182	sg->initprot = SWAP_LONG(sg->initprot);
	183	sg->nsects = SWAP_LONG(sg->nsects);
	184	sg->flags = SWAP_LONG(sg->flags);
	185	}
	186
	187	__private_extern__
	188	void
	189	swap_section(
	190	struct section *s,
	191	unsigned long nsects,
	192	enum byte_sex target_byte_sex)
	193	{
	194	unsigned long i;
	195	#ifdef __MWERKS__
	196	enum byte_sex dummy;
	197	dummy = target_byte_sex;
	198	#endif
	199
	200	for(i = 0; i < nsects; i++){
	201	/* sectname[16] */
	202	/* segname[16] */
	203	s[i].addr = SWAP_LONG(s[i].addr);
	204	s[i].size = SWAP_LONG(s[i].size);
	205	s[i].offset = SWAP_LONG(s[i].offset);
	206	s[i].align = SWAP_LONG(s[i].align);
	207	s[i].reloff = SWAP_LONG(s[i].reloff);
	208	s[i].nreloc = SWAP_LONG(s[i].nreloc);
	209	s[i].flags = SWAP_LONG(s[i].flags);
	210	s[i].reserved1 = SWAP_LONG(s[i].reserved1);
	211	s[i].reserved2 = SWAP_LONG(s[i].reserved2);
	212	}
	213	}
	214
	215	__private_extern__
	216	void
	217	swap_symtab_command(
	218	struct symtab_command *st,
	219	enum byte_sex target_byte_sex)
	220	{
	221	#ifdef __MWERKS__
	222	enum byte_sex dummy;
	223	dummy = target_byte_sex;
	224	#endif
	225	st->cmd = SWAP_LONG(st->cmd);
	226	st->cmdsize = SWAP_LONG(st->cmdsize);
	227	st->symoff = SWAP_LONG(st->symoff);
	228	st->nsyms = SWAP_LONG(st->nsyms);
	229	st->stroff = SWAP_LONG(st->stroff);
	230	st->strsize = SWAP_LONG(st->strsize);
	231	}
	232
	233	__private_extern__
	234	void
	235	swap_dysymtab_command(
	236	struct dysymtab_command *dyst,
	237	enum byte_sex target_byte_sex)
	238	{
	239	#ifdef __MWERKS__
	240	enum byte_sex dummy;
	241	dummy = target_byte_sex;
	242	#endif
	243	dyst->cmd = SWAP_LONG(dyst->cmd);
	244	dyst->cmdsize = SWAP_LONG(dyst->cmdsize);
	245	dyst->ilocalsym = SWAP_LONG(dyst->ilocalsym);
	246	dyst->nlocalsym = SWAP_LONG(dyst->nlocalsym);
	247	dyst->iextdefsym = SWAP_LONG(dyst->iextdefsym);
	248	dyst->nextdefsym = SWAP_LONG(dyst->nextdefsym);
	249	dyst->iundefsym = SWAP_LONG(dyst->iundefsym);
	250	dyst->nundefsym = SWAP_LONG(dyst->nundefsym);
	251	dyst->tocoff = SWAP_LONG(dyst->tocoff);
	252	dyst->ntoc = SWAP_LONG(dyst->ntoc);
	253	dyst->modtaboff = SWAP_LONG(dyst->modtaboff);
	254	dyst->nmodtab = SWAP_LONG(dyst->nmodtab);
	255	dyst->extrefsymoff = SWAP_LONG(dyst->extrefsymoff);
	256	dyst->nextrefsyms = SWAP_LONG(dyst->nextrefsyms);
	257	dyst->indirectsymoff = SWAP_LONG(dyst->indirectsymoff);
	258	dyst->nindirectsyms = SWAP_LONG(dyst->nindirectsyms);
	259	dyst->extreloff = SWAP_LONG(dyst->extreloff);
	260	dyst->nextrel = SWAP_LONG(dyst->nextrel);
	261	dyst->locreloff = SWAP_LONG(dyst->locreloff);
	262	dyst->nlocrel = SWAP_LONG(dyst->nlocrel);
	263	}
	264
	265	__private_extern__
	266	void
	267	swap_symseg_command(
	268	struct symseg_command *ss,
	269	enum byte_sex target_byte_sex)
	270	{
	271	#ifdef __MWERKS__
	272	enum byte_sex dummy;
	273	dummy = target_byte_sex;
	274	#endif
	275	ss->cmd = SWAP_LONG(ss->cmd);
	276	ss->cmdsize = SWAP_LONG(ss->cmdsize);
	277	ss->offset = SWAP_LONG(ss->offset);
	278	ss->size = SWAP_LONG(ss->size);
	279	}
	280
	281	__private_extern__
	282	void
	283	swap_fvmlib_command(
	284	struct fvmlib_command *fl,
	285	enum byte_sex target_byte_sex)
	286	{
	287	#ifdef __MWERKS__
	288	enum byte_sex dummy;
	289	dummy = target_byte_sex;
	290	#endif
	291	fl->cmd = SWAP_LONG(fl->cmd);
	292	fl->cmdsize = SWAP_LONG(fl->cmdsize);
	293	fl->fvmlib.name.offset = SWAP_LONG(fl->fvmlib.name.offset);
	294	fl->fvmlib.minor_version = SWAP_LONG(fl->fvmlib.minor_version);
	295	fl->fvmlib.header_addr = SWAP_LONG(fl->fvmlib.header_addr);
	296	}
	297
	298	__private_extern__
	299	void
	300	swap_dylib_command(
	301	struct dylib_command *dl,
	302	enum byte_sex target_byte_sex)
	303	{
	304	#ifdef __MWERKS__
	305	enum byte_sex dummy;
	306	dummy = target_byte_sex;
	307	#endif
	308	dl->cmd = SWAP_LONG(dl->cmd);
	309	dl->cmdsize = SWAP_LONG(dl->cmdsize);
	310	dl->dylib.name.offset = SWAP_LONG(dl->dylib.name.offset);
	311	dl->dylib.timestamp = SWAP_LONG(dl->dylib.timestamp);
	312	dl->dylib.current_version = SWAP_LONG(dl->dylib.current_version);
	313	dl->dylib.compatibility_version =
	314	SWAP_LONG(dl->dylib.compatibility_version);
	315	}
	316
	317	__private_extern__
	318	void
	319	swap_sub_framework_command(
	320	struct sub_framework_command *sub,
	321	enum byte_sex target_byte_sex)
	322	{
	323	#ifdef __MWERKS__
	324	enum byte_sex dummy;
	325	dummy = target_byte_sex;
	326	#endif
	327	sub->cmd = SWAP_LONG(sub->cmd);
	328	sub->cmdsize = SWAP_LONG(sub->cmdsize);
	329	sub->umbrella.offset = SWAP_LONG(sub->umbrella.offset);
	330	}
	331
	332	__private_extern__
	333	void
	334	swap_sub_umbrella_command(
	335	struct sub_umbrella_command *usub,
	336	enum byte_sex target_byte_sex)
	337	{
	338	#ifdef __MWERKS__
	339	enum byte_sex dummy;
	340	dummy = target_byte_sex;
	341	#endif
	342	usub->cmd = SWAP_LONG(usub->cmd);
	343	usub->cmdsize = SWAP_LONG(usub->cmdsize);
	344	usub->sub_umbrella.offset = SWAP_LONG(usub->sub_umbrella.offset);
	345	}
	346
	347	__private_extern__
	348	void
	349	swap_sub_library_command(
	350	struct sub_library_command *lsub,
	351	enum byte_sex target_byte_sex)
	352	{
	353	#ifdef __MWERKS__
	354	enum byte_sex dummy;
	355	dummy = target_byte_sex;
	356	#endif
	357	lsub->cmd = SWAP_LONG(lsub->cmd);
	358	lsub->cmdsize = SWAP_LONG(lsub->cmdsize);
	359	lsub->sub_library.offset = SWAP_LONG(lsub->sub_library.offset);
	360	}
	361
	362	__private_extern__
	363	void
	364	swap_sub_client_command(
	365	struct sub_client_command *csub,
	366	enum byte_sex target_byte_sex)
	367	{
	368	#ifdef __MWERKS__
	369	enum byte_sex dummy;
	370	dummy = target_byte_sex;
	371	#endif
	372	csub->cmd = SWAP_LONG(csub->cmd);
	373	csub->cmdsize = SWAP_LONG(csub->cmdsize);
	374	csub->client.offset = SWAP_LONG(csub->client.offset);
	375	}
	376
	377	__private_extern__
	378	void
	379	swap_prebound_dylib_command(
	380	struct prebound_dylib_command *pbdylib,
	381	enum byte_sex target_byte_sex)
	382	{
	383	#ifdef __MWERKS__
	384	enum byte_sex dummy;
	385	dummy = target_byte_sex;
	386	#endif
	387	pbdylib->cmd = SWAP_LONG(pbdylib->cmd);
	388	pbdylib->cmdsize = SWAP_LONG(pbdylib->cmdsize);
	389	pbdylib->name.offset = SWAP_LONG(pbdylib->name.offset);
	390	pbdylib->nmodules = SWAP_LONG(pbdylib->nmodules);
	391	pbdylib->linked_modules.offset =
	392	SWAP_LONG(pbdylib->linked_modules.offset);
	393	}
	394
	395	__private_extern__
	396	void
	397	swap_dylinker_command(
	398	struct dylinker_command *dyld,
	399	enum byte_sex target_byte_sex)
	400	{
	401	#ifdef __MWERKS__
	402	enum byte_sex dummy;
	403	dummy = target_byte_sex;
	404	#endif
	405	dyld->cmd = SWAP_LONG(dyld->cmd);
	406	dyld->cmdsize = SWAP_LONG(dyld->cmdsize);
	407	dyld->name.offset = SWAP_LONG(dyld->name.offset);
	408	}
	409
	410	__private_extern__
	411	void
	412	swap_fvmfile_command(
	413	struct fvmfile_command *ff,
	414	enum byte_sex target_byte_sex)
	415	{
	416	#ifdef __MWERKS__
	417	enum byte_sex dummy;
	418	dummy = target_byte_sex;
	419	#endif
	420	ff->cmd = SWAP_LONG(ff->cmd);
	421	ff->cmdsize = SWAP_LONG(ff->cmdsize);
	422	ff->name.offset = SWAP_LONG(ff->name.offset);
	423	ff->header_addr = SWAP_LONG(ff->header_addr);
	424	}
	425
	426
	427	__private_extern__
	428	void
	429	swap_thread_command(
	430	struct thread_command *ut,
	431	enum byte_sex target_byte_sex)
	432	{
	433	#ifdef __MWERKS__
	434	enum byte_sex dummy;
	435	dummy = target_byte_sex;
	436	#endif
	437	ut->cmd = SWAP_LONG(ut->cmd);
	438	ut->cmdsize = SWAP_LONG(ut->cmdsize);
	439	}
	440
	441	__private_extern__
	442	void
	443	swap_m68k_thread_state_regs(
	444	struct m68k_thread_state_regs *cpu,
	445	enum byte_sex target_byte_sex)
	446	{
	447	unsigned long i;
	448	#ifdef __MWERKS__
	449	enum byte_sex dummy;
	450	dummy = target_byte_sex;
	451	#endif
	452
	453	for(i = 0; i < 8; i++)
	454	cpu->dreg[i] = SWAP_LONG(cpu->dreg[i]);
	455	for(i = 0; i < 8; i++)
	456	cpu->areg[i] = SWAP_LONG(cpu->areg[i]);
	457	cpu->pad0 = SWAP_SHORT(cpu->pad0);
	458	cpu->sr = SWAP_SHORT(cpu->sr);
	459	cpu->pc = SWAP_LONG(cpu->pc);
	460	}
	461
	462	__private_extern__
	463	void
	464	swap_m68k_thread_state_68882(
	465	struct m68k_thread_state_68882 *fpu,
	466	enum byte_sex target_byte_sex)
	467	{
	468	unsigned long i, tmp;
	469	#ifdef __MWERKS__
	470	enum byte_sex dummy;
	471	dummy = target_byte_sex;
	472	#endif
	473
	474	for(i = 0; i < 8; i++){
	475	tmp = SWAP_LONG(fpu->regs[i].fp[0]);
	476	fpu->regs[i].fp[1] = SWAP_LONG(fpu->regs[i].fp[1]);
	477	fpu->regs[i].fp[0] = SWAP_LONG(fpu->regs[i].fp[2]);
	478	fpu->regs[i].fp[2] = tmp;
	479	}
	480	fpu->cr = SWAP_LONG(fpu->cr);
	481	fpu->sr = SWAP_LONG(fpu->sr);
	482	fpu->iar = SWAP_LONG(fpu->iar);
	483	fpu->state = SWAP_LONG(fpu->state);
	484	}
	485
	486	__private_extern__
	487	void
	488	swap_m68k_thread_state_user_reg(
	489	struct m68k_thread_state_user_reg *user_reg,
	490	enum byte_sex target_byte_sex)
	491	{
	492	#ifdef __MWERKS__
	493	enum byte_sex dummy;
	494	dummy = target_byte_sex;
	495	#endif
	496	user_reg->user_reg = SWAP_LONG(user_reg->user_reg);
	497	}
	498
	499	__private_extern__
	500	void
	501	swap_ppc_thread_state_t(
	502	ppc_thread_state_t *cpu,
	503	enum byte_sex target_byte_sex)
	504	{
	505	cpu->srr0 = SWAP_LONG(cpu->srr0);
	506	cpu->srr1 = SWAP_LONG(cpu->srr1);
	507	cpu->r0 = SWAP_LONG(cpu->r0);
	508	cpu->r1 = SWAP_LONG(cpu->r1);
	509	cpu->r2 = SWAP_LONG(cpu->r2);
	510	cpu->r3 = SWAP_LONG(cpu->r3);
	511	cpu->r4 = SWAP_LONG(cpu->r4);
	512	cpu->r5 = SWAP_LONG(cpu->r5);
	513	cpu->r6 = SWAP_LONG(cpu->r6);
	514	cpu->r7 = SWAP_LONG(cpu->r7);
	515	cpu->r8 = SWAP_LONG(cpu->r8);
	516	cpu->r9 = SWAP_LONG(cpu->r9);
	517	cpu->r10 = SWAP_LONG(cpu->r10);
	518	cpu->r11 = SWAP_LONG(cpu->r11);
	519	cpu->r12 = SWAP_LONG(cpu->r12);
	520	cpu->r13 = SWAP_LONG(cpu->r13);
	521	cpu->r14 = SWAP_LONG(cpu->r14);
	522	cpu->r15 = SWAP_LONG(cpu->r15);
	523	cpu->r16 = SWAP_LONG(cpu->r16);
	524	cpu->r17 = SWAP_LONG(cpu->r17);
	525	cpu->r18 = SWAP_LONG(cpu->r18);
	526	cpu->r19 = SWAP_LONG(cpu->r19);
	527	cpu->r20 = SWAP_LONG(cpu->r20);
	528	cpu->r21 = SWAP_LONG(cpu->r21);
	529	cpu->r22 = SWAP_LONG(cpu->r22);
	530	cpu->r23 = SWAP_LONG(cpu->r23);
	531	cpu->r24 = SWAP_LONG(cpu->r24);
	532	cpu->r25 = SWAP_LONG(cpu->r25);
	533	cpu->r26 = SWAP_LONG(cpu->r26);
	534	cpu->r27 = SWAP_LONG(cpu->r27);
	535	cpu->r28 = SWAP_LONG(cpu->r28);
	536	cpu->r29 = SWAP_LONG(cpu->r29);
	537	cpu->r30 = SWAP_LONG(cpu->r30);
	538	cpu->r31 = SWAP_LONG(cpu->r31);
	539	cpu->cr = SWAP_LONG(cpu->cr);
	540	cpu->xer = SWAP_LONG(cpu->xer);
	541	cpu->lr = SWAP_LONG(cpu->lr);
	542	cpu->ctr = SWAP_LONG(cpu->ctr);
	543	cpu->mq = SWAP_LONG(cpu->mq);
	544	cpu->pad = SWAP_LONG(cpu->pad);
	545	}
	546
	547	__private_extern__
	548	void
	549	swap_ppc_float_state_t(
	550	ppc_float_state_t *fpu,
	551	enum byte_sex target_byte_sex)
	552	{
	553	unsigned long i;
	554	#ifdef __MWERKS__
	555	enum byte_sex dummy;
	556	dummy = target_byte_sex;
	557	#endif
	558
	559	for(i = 0; i < 32; i++)
	560	fpu->fpregs[i] = SWAP_DOUBLE(fpu->fpregs[i]);
	561
	562	fpu->fpscr_pad = SWAP_LONG(fpu->fpscr_pad);
	563	fpu->fpscr = SWAP_LONG(fpu->fpscr);
	564	}
	565
	566	__private_extern__
	567	void
	568	swap_ppc_exception_state_t(
	569	ppc_exception_state_t *state,
	570	enum byte_sex target_byte_sex)
	571	{
	572	unsigned long i;
	573	#ifdef __MWERKS__
	574	enum byte_sex dummy;
	575	dummy = target_byte_sex;
	576	#endif
	577
	578	state->dar = SWAP_LONG(state->dar);
	579	state->dsisr = SWAP_LONG(state->dsisr);
	580	state->exception = SWAP_LONG(state->exception);
	581	state->pad0 = SWAP_LONG(state->pad0);
	582
	583	for(i = 0; i < 4; i++)
	584	state->pad1[i] = SWAP_LONG(state->pad1[i]);
	585	}
	586
	587	__private_extern__
	588	void
	589	swap_m88k_thread_state_grf_t(
	590	m88k_thread_state_grf_t *cpu,
	591	enum byte_sex target_byte_sex)
	592	{
	593	#ifdef __MWERKS__
	594	enum byte_sex dummy;
	595	dummy = target_byte_sex;
	596	#endif
	597	cpu->r1 = SWAP_LONG(cpu->r1);
	598	cpu->r2 = SWAP_LONG(cpu->r2);
	599	cpu->r3 = SWAP_LONG(cpu->r3);
	600	cpu->r4 = SWAP_LONG(cpu->r4);
	601	cpu->r5 = SWAP_LONG(cpu->r5);
	602	cpu->r6 = SWAP_LONG(cpu->r6);
	603	cpu->r7 = SWAP_LONG(cpu->r7);
	604	cpu->r8 = SWAP_LONG(cpu->r8);
	605	cpu->r9 = SWAP_LONG(cpu->r9);
	606	cpu->r10 = SWAP_LONG(cpu->r10);
	607	cpu->r11 = SWAP_LONG(cpu->r11);
	608	cpu->r12 = SWAP_LONG(cpu->r12);
	609	cpu->r13 = SWAP_LONG(cpu->r13);
	610	cpu->r14 = SWAP_LONG(cpu->r14);
	611	cpu->r15 = SWAP_LONG(cpu->r15);
	612	cpu->r16 = SWAP_LONG(cpu->r16);
	613	cpu->r17 = SWAP_LONG(cpu->r17);
	614	cpu->r18 = SWAP_LONG(cpu->r18);
	615	cpu->r19 = SWAP_LONG(cpu->r19);
	616	cpu->r20 = SWAP_LONG(cpu->r20);
	617	cpu->r21 = SWAP_LONG(cpu->r21);
	618	cpu->r22 = SWAP_LONG(cpu->r22);
	619	cpu->r23 = SWAP_LONG(cpu->r23);
	620	cpu->r24 = SWAP_LONG(cpu->r24);
	621	cpu->r25 = SWAP_LONG(cpu->r25);
	622	cpu->r26 = SWAP_LONG(cpu->r26);
	623	cpu->r27 = SWAP_LONG(cpu->r27);
	624	cpu->r28 = SWAP_LONG(cpu->r28);
	625	cpu->r29 = SWAP_LONG(cpu->r29);
	626	cpu->r30 = SWAP_LONG(cpu->r30);
	627	cpu->r31 = SWAP_LONG(cpu->r31);
	628	cpu->xip = SWAP_LONG(cpu->xip);
	629	cpu->xip_in_bd = SWAP_LONG(cpu->xip_in_bd);
	630	cpu->nip = SWAP_LONG(cpu->nip);
	631	}
	632
	633	__private_extern__
	634	void
	635	swap_m88k_thread_state_xrf_t(
	636	m88k_thread_state_xrf_t *fpu,
	637	enum byte_sex target_byte_sex)
	638	{
	639	enum byte_sex host_byte_sex;
	640
	641	struct swapped_m88k_fpsr {
	642	union {
	643	struct {
	644	unsigned afinx:BIT_WIDTH(0);
	645	unsigned afovf:BIT_WIDTH(1);
	646	unsigned afunf:BIT_WIDTH(2);
	647	unsigned afdvz:BIT_WIDTH(3);
	648	unsigned afinv:BIT_WIDTH(4);
	649	unsigned :BITS_WIDTH(15,5);
	650	unsigned xmod:BIT_WIDTH(16);
	651	unsigned :BITS_WIDTH(31,17);
	652	} fields;
	653	unsigned long word;
	654	} u;
	655	} ssr;
	656	struct swapped_m88k_fpcr {
	657	union {
	658	struct {
	659	unsigned efinx:BIT_WIDTH(0);
	660	unsigned efovf:BIT_WIDTH(1);
	661	unsigned efunf:BIT_WIDTH(2);
	662	unsigned efdvz:BIT_WIDTH(3);
	663	unsigned efinv:BIT_WIDTH(4);
	664	unsigned :BITS_WIDTH(13,5);
	665	m88k_fpcr_rm_t rm:BITS_WIDTH(15,14);
	666	unsigned :BITS_WIDTH(31,16);
	667	} fields;
	668	unsigned long word;
	669	} u;
	670	} scr;
	671
	672	host_byte_sex = get_host_byte_sex();
	673
	674	fpu->x1.x[0] = SWAP_LONG(fpu->x1.x[0]);
	675	fpu->x1.x[1] = SWAP_LONG(fpu->x1.x[1]);
	676	fpu->x1.x[2] = SWAP_LONG(fpu->x1.x[2]);
	677	fpu->x1.x[3] = SWAP_LONG(fpu->x1.x[3]);
	678	fpu->x2.x[0] = SWAP_LONG(fpu->x2.x[0]);
	679	fpu->x2.x[1] = SWAP_LONG(fpu->x2.x[1]);
	680	fpu->x2.x[2] = SWAP_LONG(fpu->x2.x[2]);
	681	fpu->x2.x[3] = SWAP_LONG(fpu->x2.x[3]);
	682	fpu->x3.x[0] = SWAP_LONG(fpu->x3.x[0]);
	683	fpu->x3.x[1] = SWAP_LONG(fpu->x3.x[1]);
	684	fpu->x3.x[2] = SWAP_LONG(fpu->x3.x[2]);
	685	fpu->x3.x[3] = SWAP_LONG(fpu->x3.x[3]);
	686	fpu->x4.x[0] = SWAP_LONG(fpu->x4.x[0]);
	687	fpu->x4.x[1] = SWAP_LONG(fpu->x4.x[1]);
	688	fpu->x4.x[2] = SWAP_LONG(fpu->x4.x[2]);
	689	fpu->x4.x[3] = SWAP_LONG(fpu->x4.x[3]);
	690	fpu->x5.x[0] = SWAP_LONG(fpu->x5.x[0]);
	691	fpu->x5.x[1] = SWAP_LONG(fpu->x5.x[1]);
	692	fpu->x5.x[2] = SWAP_LONG(fpu->x5.x[2]);
	693	fpu->x5.x[3] = SWAP_LONG(fpu->x5.x[3]);
	694	fpu->x6.x[0] = SWAP_LONG(fpu->x6.x[0]);
	695	fpu->x6.x[1] = SWAP_LONG(fpu->x6.x[1]);
	696	fpu->x6.x[2] = SWAP_LONG(fpu->x6.x[2]);
	697	fpu->x6.x[3] = SWAP_LONG(fpu->x6.x[3]);
	698	fpu->x7.x[0] = SWAP_LONG(fpu->x7.x[0]);
	699	fpu->x7.x[1] = SWAP_LONG(fpu->x7.x[1]);
	700	fpu->x7.x[2] = SWAP_LONG(fpu->x7.x[2]);
	701	fpu->x7.x[3] = SWAP_LONG(fpu->x7.x[3]);
	702	fpu->x8.x[0] = SWAP_LONG(fpu->x8.x[0]);
	703	fpu->x8.x[1] = SWAP_LONG(fpu->x8.x[1]);
	704	fpu->x8.x[2] = SWAP_LONG(fpu->x8.x[2]);
	705	fpu->x8.x[3] = SWAP_LONG(fpu->x8.x[3]);
	706	fpu->x9.x[0] = SWAP_LONG(fpu->x9.x[0]);
	707	fpu->x9.x[1] = SWAP_LONG(fpu->x9.x[1]);
	708	fpu->x9.x[2] = SWAP_LONG(fpu->x9.x[2]);
	709	fpu->x9.x[3] = SWAP_LONG(fpu->x9.x[3]);
	710	fpu->x10.x[0] = SWAP_LONG(fpu->x10.x[0]);
	711	fpu->x10.x[1] = SWAP_LONG(fpu->x10.x[1]);
	712	fpu->x10.x[2] = SWAP_LONG(fpu->x10.x[2]);
	713	fpu->x10.x[3] = SWAP_LONG(fpu->x10.x[3]);
	714	fpu->x11.x[0] = SWAP_LONG(fpu->x11.x[0]);
	715	fpu->x11.x[1] = SWAP_LONG(fpu->x11.x[1]);
	716	fpu->x11.x[2] = SWAP_LONG(fpu->x11.x[2]);
	717	fpu->x11.x[3] = SWAP_LONG(fpu->x11.x[3]);
	718	fpu->x12.x[0] = SWAP_LONG(fpu->x12.x[0]);
	719	fpu->x12.x[1] = SWAP_LONG(fpu->x12.x[1]);
	720	fpu->x12.x[2] = SWAP_LONG(fpu->x12.x[2]);
	721	fpu->x12.x[3] = SWAP_LONG(fpu->x12.x[3]);
	722	fpu->x13.x[0] = SWAP_LONG(fpu->x13.x[0]);
	723	fpu->x13.x[1] = SWAP_LONG(fpu->x13.x[1]);
	724	fpu->x13.x[2] = SWAP_LONG(fpu->x13.x[2]);
	725	fpu->x13.x[3] = SWAP_LONG(fpu->x13.x[3]);
	726	fpu->x14.x[0] = SWAP_LONG(fpu->x14.x[0]);
	727	fpu->x14.x[1] = SWAP_LONG(fpu->x14.x[1]);
	728	fpu->x14.x[2] = SWAP_LONG(fpu->x14.x[2]);
	729	fpu->x14.x[3] = SWAP_LONG(fpu->x14.x[3]);
	730	fpu->x15.x[0] = SWAP_LONG(fpu->x15.x[0]);
	731	fpu->x15.x[1] = SWAP_LONG(fpu->x15.x[1]);
	732	fpu->x15.x[2] = SWAP_LONG(fpu->x15.x[2]);
	733	fpu->x15.x[3] = SWAP_LONG(fpu->x15.x[3]);
	734	fpu->x16.x[0] = SWAP_LONG(fpu->x16.x[0]);
	735	fpu->x16.x[1] = SWAP_LONG(fpu->x16.x[1]);
	736	fpu->x16.x[2] = SWAP_LONG(fpu->x16.x[2]);
	737	fpu->x16.x[3] = SWAP_LONG(fpu->x16.x[3]);
	738	fpu->x17.x[0] = SWAP_LONG(fpu->x17.x[0]);
	739	fpu->x17.x[1] = SWAP_LONG(fpu->x17.x[1]);
	740	fpu->x17.x[2] = SWAP_LONG(fpu->x17.x[2]);
	741	fpu->x17.x[3] = SWAP_LONG(fpu->x17.x[3]);
	742	fpu->x18.x[0] = SWAP_LONG(fpu->x18.x[0]);
	743	fpu->x18.x[1] = SWAP_LONG(fpu->x18.x[1]);
	744	fpu->x18.x[2] = SWAP_LONG(fpu->x18.x[2]);
	745	fpu->x18.x[3] = SWAP_LONG(fpu->x18.x[3]);
	746	fpu->x19.x[0] = SWAP_LONG(fpu->x19.x[0]);
	747	fpu->x19.x[1] = SWAP_LONG(fpu->x19.x[1]);
	748	fpu->x19.x[2] = SWAP_LONG(fpu->x19.x[2]);
	749	fpu->x19.x[3] = SWAP_LONG(fpu->x19.x[3]);
	750	fpu->x20.x[0] = SWAP_LONG(fpu->x20.x[0]);
	751	fpu->x20.x[1] = SWAP_LONG(fpu->x20.x[1]);
	752	fpu->x20.x[2] = SWAP_LONG(fpu->x20.x[2]);
	753	fpu->x20.x[3] = SWAP_LONG(fpu->x20.x[3]);
	754	fpu->x21.x[0] = SWAP_LONG(fpu->x21.x[0]);
	755	fpu->x21.x[1] = SWAP_LONG(fpu->x21.x[1]);
	756	fpu->x21.x[2] = SWAP_LONG(fpu->x21.x[2]);
	757	fpu->x21.x[3] = SWAP_LONG(fpu->x21.x[3]);
	758	fpu->x22.x[0] = SWAP_LONG(fpu->x22.x[0]);
	759	fpu->x22.x[1] = SWAP_LONG(fpu->x22.x[1]);
	760	fpu->x22.x[2] = SWAP_LONG(fpu->x22.x[2]);
	761	fpu->x22.x[3] = SWAP_LONG(fpu->x22.x[3]);
	762	fpu->x23.x[0] = SWAP_LONG(fpu->x23.x[0]);
	763	fpu->x23.x[1] = SWAP_LONG(fpu->x23.x[1]);
	764	fpu->x23.x[2] = SWAP_LONG(fpu->x23.x[2]);
	765	fpu->x23.x[3] = SWAP_LONG(fpu->x23.x[3]);
	766	fpu->x24.x[0] = SWAP_LONG(fpu->x24.x[0]);
	767	fpu->x24.x[1] = SWAP_LONG(fpu->x24.x[1]);
	768	fpu->x24.x[2] = SWAP_LONG(fpu->x24.x[2]);
	769	fpu->x24.x[3] = SWAP_LONG(fpu->x24.x[3]);
	770	fpu->x25.x[0] = SWAP_LONG(fpu->x25.x[0]);
	771	fpu->x25.x[1] = SWAP_LONG(fpu->x25.x[1]);
	772	fpu->x25.x[2] = SWAP_LONG(fpu->x25.x[2]);
	773	fpu->x25.x[3] = SWAP_LONG(fpu->x25.x[3]);
	774	fpu->x26.x[0] = SWAP_LONG(fpu->x26.x[0]);
	775	fpu->x26.x[1] = SWAP_LONG(fpu->x26.x[1]);
	776	fpu->x26.x[2] = SWAP_LONG(fpu->x26.x[2]);
	777	fpu->x26.x[3] = SWAP_LONG(fpu->x26.x[3]);
	778	fpu->x27.x[0] = SWAP_LONG(fpu->x27.x[0]);
	779	fpu->x27.x[1] = SWAP_LONG(fpu->x27.x[1]);
	780	fpu->x27.x[2] = SWAP_LONG(fpu->x27.x[2]);
	781	fpu->x27.x[3] = SWAP_LONG(fpu->x27.x[3]);
	782	fpu->x28.x[0] = SWAP_LONG(fpu->x28.x[0]);
	783	fpu->x28.x[1] = SWAP_LONG(fpu->x28.x[1]);
	784	fpu->x28.x[2] = SWAP_LONG(fpu->x28.x[2]);
	785	fpu->x28.x[3] = SWAP_LONG(fpu->x28.x[3]);
	786	fpu->x29.x[0] = SWAP_LONG(fpu->x29.x[0]);
	787	fpu->x29.x[1] = SWAP_LONG(fpu->x29.x[1]);
	788	fpu->x29.x[2] = SWAP_LONG(fpu->x29.x[2]);
	789	fpu->x29.x[3] = SWAP_LONG(fpu->x29.x[3]);
	790	fpu->x30.x[0] = SWAP_LONG(fpu->x30.x[0]);
	791	fpu->x30.x[1] = SWAP_LONG(fpu->x30.x[1]);
	792	fpu->x30.x[2] = SWAP_LONG(fpu->x30.x[2]);
	793	fpu->x30.x[3] = SWAP_LONG(fpu->x30.x[3]);
	794	fpu->x31.x[0] = SWAP_LONG(fpu->x31.x[0]);
	795	fpu->x31.x[1] = SWAP_LONG(fpu->x31.x[1]);
	796	fpu->x31.x[2] = SWAP_LONG(fpu->x31.x[2]);
	797	fpu->x31.x[3] = SWAP_LONG(fpu->x31.x[3]);
	798
	799	if(target_byte_sex == host_byte_sex){
	800	memcpy(&ssr, &(fpu->fpsr), sizeof(struct swapped_m88k_fpsr));
	801	ssr.u.word = SWAP_LONG(ssr.u.word);
	802	fpu->fpsr.afinx = ssr.u.fields.afinx;
	803	fpu->fpsr.afovf = ssr.u.fields.afovf;
	804	fpu->fpsr.afunf = ssr.u.fields.afunf;
	805	fpu->fpsr.afdvz = ssr.u.fields.afdvz;
	806	fpu->fpsr.afinv = ssr.u.fields.afinv;
	807	fpu->fpsr.xmod = ssr.u.fields.xmod;
	808
	809	memcpy(&scr, &(fpu->fpcr), sizeof(struct swapped_m88k_fpcr));
	810	scr.u.word = SWAP_LONG(scr.u.word);
	811	fpu->fpcr.efinx = scr.u.fields.efinx;
	812	fpu->fpcr.efovf = scr.u.fields.efovf;
	813	fpu->fpcr.efunf = scr.u.fields.efunf;
	814	fpu->fpcr.efdvz = scr.u.fields.efdvz;
	815	fpu->fpcr.efinv = scr.u.fields.efinv;
	816	fpu->fpcr.rm = scr.u.fields.rm;
	817	}
	818	else{
	819	ssr.u.fields.afinx = fpu->fpsr.afinx;
	820	ssr.u.fields.afovf = fpu->fpsr.afovf;
	821	ssr.u.fields.afunf = fpu->fpsr.afunf;
	822	ssr.u.fields.afdvz = fpu->fpsr.afdvz;
	823	ssr.u.fields.afinv = fpu->fpsr.afinv;
	824	ssr.u.fields.xmod = fpu->fpsr.xmod;
	825	ssr.u.word = SWAP_LONG(ssr.u.word);
	826	memcpy(&(fpu->fpsr), &ssr, sizeof(struct swapped_m88k_fpsr));
	827
	828	scr.u.fields.efinx = fpu->fpcr.efinx;
	829	scr.u.fields.efovf = fpu->fpcr.efovf;
	830	scr.u.fields.efunf = fpu->fpcr.efunf;
	831	scr.u.fields.efdvz = fpu->fpcr.efdvz;
	832	scr.u.fields.efinv = fpu->fpcr.efinv;
	833	scr.u.fields.rm = fpu->fpcr.rm;
	834	scr.u.word = SWAP_LONG(scr.u.word);
	835	memcpy(&(fpu->fpcr), &scr, sizeof(struct swapped_m88k_fpcr));
	836	}
	837	}
	838
	839	__private_extern__
	840	void
	841	swap_m88k_thread_state_user_t(
	842	m88k_thread_state_user_t *user,
	843	enum byte_sex target_byte_sex)
	844	{
	845	#ifdef __MWERKS__
	846	enum byte_sex dummy;
	847	dummy = target_byte_sex;
	848	#endif
	849	user->user = SWAP_LONG(user->user);
	850	}
	851
	852	__private_extern__
	853	void
	854	swap_m88110_thread_state_impl_t(
	855	m88110_thread_state_impl_t *spu,
	856	enum byte_sex target_byte_sex)
	857	{
	858	unsigned long i;
	859	enum byte_sex host_byte_sex;
	860
	861	struct swapped_m88110_bp_ctrl {
	862	union {
	863	struct {
	864	unsigned v:BIT_WIDTH(0);
	865	m88110_match_t addr_match:BITS_WIDTH(12,1);
	866	unsigned :BITS_WIDTH(26,13);
	867	unsigned rwm:BIT_WIDTH(27);
	868	unsigned rw:BIT_WIDTH(28);
	869	unsigned :BITS_WIDTH(31,29);
	870	} fields;
	871	unsigned long word;
	872	} u;
	873	} sbpc;
	874
	875	struct swap_m88110_psr {
	876	union {
	877	struct {
	878	unsigned :BITS_WIDTH(1,0);
	879	unsigned mxm_dis:BIT_WIDTH(2);
	880	unsigned sfu1dis:BIT_WIDTH(3);
	881	unsigned :BITS_WIDTH(22,4);
	882	unsigned trace:BIT_WIDTH(23);
	883	unsigned :BIT_WIDTH(24);
	884	unsigned sm:BIT_WIDTH(25);
	885	unsigned sgn_imd:BIT_WIDTH(26);
	886	unsigned :BIT_WIDTH(27);
	887	unsigned c:BIT_WIDTH(28);
	888	unsigned se:BIT_WIDTH(29);
	889	unsigned le:BIT_WIDTH(30);
	890	unsigned supr:BIT_WIDTH(31);
	891	} fields;
	892	unsigned long word;
	893	} u;
	894	} spsr;
	895
	896	struct swapped_m88110_fp_trap_status {
	897	union {
	898	struct {
	899	unsigned efinx:BIT_WIDTH(0);
	900	unsigned efovf:BIT_WIDTH(1);
	901	unsigned efunf:BIT_WIDTH(2);
	902	unsigned efdvz:BIT_WIDTH(3);
	903	unsigned efinv:BIT_WIDTH(4);
	904	unsigned priv:BIT_WIDTH(5);
	905	unsigned unimp:BIT_WIDTH(6);
	906	unsigned int:BIT_WIDTH(7);
	907	unsigned sfu1_disabled:BIT_WIDTH(8);
	908	unsigned :BITS_WIDTH(13,9);
	909	m88110_iresult_size_t iresult_size:BITS_WIDTH(15,14);
	910	unsigned :BITS_WIDTH(31,16);
	911	} fields;
	912	unsigned long word;
	913	} u;
	914	} sfps;
	915
	916	host_byte_sex = get_host_byte_sex();
	917
	918	if(target_byte_sex == host_byte_sex){
	919	for(i = 0; i < M88110_N_DATA_BP; i++){
	920	spu->data_bp[i].addr = SWAP_LONG(spu->data_bp[i].addr);
	921	memcpy(&sbpc, &(spu->data_bp[i].ctrl),
	922	sizeof(struct swapped_m88110_bp_ctrl));
	923	sbpc.u.word = SWAP_LONG(sbpc.u.word);
	924	spu->data_bp[i].ctrl.v = sbpc.u.fields.v;
	925	spu->data_bp[i].ctrl.addr_match = sbpc.u.fields.addr_match;
	926	spu->data_bp[i].ctrl.rwm = sbpc.u.fields.rwm;
	927	spu->data_bp[i].ctrl.rw = sbpc.u.fields.rw;
	928	}
	929
	930	memcpy(&spsr, &(spu->psr), sizeof(struct swap_m88110_psr));
	931	spsr.u.word = SWAP_LONG(spsr.u.word);
	932	spu->psr.mxm_dis = spsr.u.fields.mxm_dis;
	933	spu->psr.sfu1dis = spsr.u.fields.sfu1dis;
	934	spu->psr.trace = spsr.u.fields.trace;
	935	spu->psr.sm = spsr.u.fields.sm;
	936	spu->psr.sgn_imd = spsr.u.fields.sgn_imd;
	937	spu->psr.c = spsr.u.fields.c;
	938	spu->psr.se = spsr.u.fields.se;
	939	spu->psr.le = spsr.u.fields.le;
	940	spu->psr.supr = spsr.u.fields.supr;
	941
	942	memcpy(&sfps, &(spu->fp_trap_status),
	943	sizeof(struct swapped_m88110_fp_trap_status));
	944	sfps.u.word = SWAP_LONG(sfps.u.word);
	945	spu->fp_trap_status.efinx = sfps.u.fields.efinx;
	946	spu->fp_trap_status.efovf = sfps.u.fields.efovf;
	947	spu->fp_trap_status.efunf = sfps.u.fields.efunf;
	948	spu->fp_trap_status.efdvz = sfps.u.fields.efdvz;
	949	spu->fp_trap_status.efinv = sfps.u.fields.efinv;
	950	spu->fp_trap_status.priv = sfps.u.fields.priv;
	951	spu->fp_trap_status.unimp = sfps.u.fields.unimp;
	952	spu->fp_trap_status.sfu1_disabled = sfps.u.fields.sfu1_disabled;
	953	spu->fp_trap_status.iresult_size = sfps.u.fields.iresult_size;
	954	}
	955	else{
	956	for(i = 0; i < M88110_N_DATA_BP; i++){
	957	spu->data_bp[i].addr = SWAP_LONG(spu->data_bp[i].addr);
	958	sbpc.u.fields.v = spu->data_bp[i].ctrl.v;
	959	sbpc.u.fields.addr_match = spu->data_bp[i].ctrl.addr_match;
	960	sbpc.u.fields.rwm = spu->data_bp[i].ctrl.rwm;
	961	sbpc.u.fields.rw = spu->data_bp[i].ctrl.rw;
	962	sbpc.u.word = SWAP_LONG(sbpc.u.word);
	963	memcpy(&(spu->data_bp[i].ctrl), &sbpc,
	964	sizeof(struct swapped_m88110_bp_ctrl));
	965	}
	966
	967	spsr.u.fields.mxm_dis = spu->psr.mxm_dis;
	968	spsr.u.fields.sfu1dis = spu->psr.sfu1dis;
	969	spsr.u.fields.trace = spu->psr.trace;
	970	spsr.u.fields.sm = spu->psr.sm;
	971	spsr.u.fields.sgn_imd = spu->psr.sgn_imd;
	972	spsr.u.fields.c = spu->psr.c;
	973	spsr.u.fields.se = spu->psr.se;
	974	spsr.u.fields.le = spu->psr.le;
	975	spsr.u.fields.supr = spu->psr.supr;
	976	spsr.u.word = SWAP_LONG(spsr.u.word);
	977	memcpy(&(spu->psr), &spsr, sizeof(struct swap_m88110_psr));
	978
	979	sfps.u.fields.efinx = spu->fp_trap_status.efinx;
	980	sfps.u.fields.efovf = spu->fp_trap_status.efovf;
	981	sfps.u.fields.efunf = spu->fp_trap_status.efunf;
	982	sfps.u.fields.efdvz = spu->fp_trap_status.efdvz;
	983	sfps.u.fields.efinv = spu->fp_trap_status.efinv;
	984	sfps.u.fields.priv = spu->fp_trap_status.priv;
	985	sfps.u.fields.unimp = spu->fp_trap_status.unimp;
	986	sfps.u.fields.sfu1_disabled = spu->fp_trap_status.sfu1_disabled;
	987	sfps.u.fields.iresult_size = spu->fp_trap_status.iresult_size;
	988	sfps.u.word = SWAP_LONG(sfps.u.word);
	989	memcpy(&(spu->fp_trap_status), &sfps,
	990	sizeof(struct swapped_m88110_fp_trap_status));
	991	}
	992	spu->intermediate_result.x[0] =
	993	SWAP_LONG(spu->intermediate_result.x[0]);
	994	spu->intermediate_result.x[1] =
	995	SWAP_LONG(spu->intermediate_result.x[1]);
	996	spu->intermediate_result.x[2] =
	997	SWAP_LONG(spu->intermediate_result.x[2]);
	998	spu->intermediate_result.x[3] =
	999	SWAP_LONG(spu->intermediate_result.x[3]);
	1000	}
	1001
	1002	__private_extern__
	1003	void
	1004	swap_i860_thread_state_regs(
	1005	struct i860_thread_state_regs *cpu,
	1006	enum byte_sex target_byte_sex)
	1007	{
	1008	unsigned long i;
	1009	#ifdef __MWERKS__
	1010	enum byte_sex dummy;
	1011	dummy = target_byte_sex;
	1012	#endif
	1013
	1014	for(i = 0; i < 31; i++)
	1015	cpu->ireg[i] = SWAP_LONG(cpu->ireg[i]);
	1016	for(i = 0; i < 30; i++)
	1017	cpu->freg[i] = SWAP_LONG(cpu->freg[i]);
	1018	cpu->psr = SWAP_LONG(cpu->psr);
	1019	cpu->epsr = SWAP_LONG(cpu->epsr);
	1020	cpu->db = SWAP_LONG(cpu->db);
	1021	cpu->pc = SWAP_LONG(cpu->pc);
	1022	cpu->_padding_ = SWAP_LONG(cpu->_padding_);
	1023	cpu->Mres3 = SWAP_DOUBLE(cpu->Mres3);
	1024	cpu->Ares3 = SWAP_DOUBLE(cpu->Ares3);
	1025	cpu->Mres2 = SWAP_DOUBLE(cpu->Mres2);
	1026	cpu->Ares2 = SWAP_DOUBLE(cpu->Ares2);
	1027	cpu->Mres1 = SWAP_DOUBLE(cpu->Mres1);
	1028	cpu->Ares1 = SWAP_DOUBLE(cpu->Ares1);
	1029	cpu->Ires1 = SWAP_DOUBLE(cpu->Ires1);
	1030	cpu->Lres3m = SWAP_DOUBLE(cpu->Lres3m);
	1031	cpu->Lres2m = SWAP_DOUBLE(cpu->Lres2m);
	1032	cpu->Lres1m = SWAP_DOUBLE(cpu->Lres1m);
	1033	cpu->KR = SWAP_DOUBLE(cpu->KR);
	1034	cpu->KI = SWAP_DOUBLE(cpu->KI);
	1035	cpu->T = SWAP_DOUBLE(cpu->T);
	1036	cpu->Fsr3 = SWAP_LONG(cpu->Fsr3);
	1037	cpu->Fsr2 = SWAP_LONG(cpu->Fsr2);
	1038	cpu->Fsr1 = SWAP_LONG(cpu->Fsr1);
	1039	cpu->Mergelo32 = SWAP_LONG(cpu->Mergelo32);
	1040	cpu->Mergehi32 = SWAP_LONG(cpu->Mergehi32);
	1041	}
	1042
	1043	__private_extern__
	1044	void
	1045	swap_i386_thread_state(
	1046	i386_thread_state_t *cpu,
	1047	enum byte_sex target_byte_sex)
	1048	{
	1049	#ifdef __MWERKS__
	1050	enum byte_sex dummy;
	1051	dummy = target_byte_sex;
	1052	#endif
	1053	cpu->eax = SWAP_LONG(cpu->eax);
	1054	cpu->ebx = SWAP_LONG(cpu->ebx);
	1055	cpu->ecx = SWAP_LONG(cpu->ecx);
	1056	cpu->edx = SWAP_LONG(cpu->edx);
	1057	cpu->edi = SWAP_LONG(cpu->edi);
	1058	cpu->esi = SWAP_LONG(cpu->esi);
	1059	cpu->ebp = SWAP_LONG(cpu->ebp);
	1060	cpu->esp = SWAP_LONG(cpu->esp);
	1061	cpu->ss = SWAP_LONG(cpu->ss);
	1062	cpu->eflags = SWAP_LONG(cpu->eflags);
	1063	cpu->eip = SWAP_LONG(cpu->eip);
	1064	cpu->cs = SWAP_LONG(cpu->cs);
	1065	cpu->ds = SWAP_LONG(cpu->ds);
	1066	cpu->es = SWAP_LONG(cpu->es);
	1067	cpu->fs = SWAP_LONG(cpu->fs);
	1068	cpu->gs = SWAP_LONG(cpu->gs);
	1069	}
	1070
	1071	__private_extern__
	1072	void
	1073	swap_i386_thread_fpstate(
	1074	i386_thread_fpstate_t *fpu,
	1075	enum byte_sex target_byte_sex)
	1076	{
	1077	struct swapped_fp_control {
	1078	union {
	1079	struct {
	1080	unsigned short
	1081	:3,
	1082	/inf/ :1,
	1083	rc :2,
	1084	pc :2,
	1085	:2,
	1086	precis :1,
	1087	undfl :1,
	1088	ovrfl :1,
	1089	zdiv :1,
	1090	denorm :1,
	1091	invalid :1;
	1092	} fields;
	1093	unsigned short half;
	1094	} u;
	1095	} sfpc;
	1096
	1097	struct swapped_fp_status {
	1098	union {
	1099	struct {
	1100	unsigned short
	1101	busy :1,
	1102	c3 :1,
	1103	tos :3,
	1104	c2 :1,
	1105	c1 :1,
	1106	c0 :1,
	1107	errsumm :1,
	1108	stkflt :1,
	1109	precis :1,
	1110	undfl :1,
	1111	ovrfl :1,
	1112	zdiv :1,
	1113	denorm :1,
	1114	invalid :1;
	1115	} fields;
	1116	unsigned short half;
	1117	} u;
	1118	} sfps;
	1119
	1120	struct swapped_fp_tag {
	1121	union {
	1122	struct {
	1123	unsigned short
	1124	tag7 :2,
	1125	tag6 :2,
	1126	tag5 :2,
	1127	tag4 :2,
	1128	tag3 :2,
	1129	tag2 :2,
	1130	tag1 :2,
	1131	tag0 :2;
	1132	} fields;
	1133	unsigned short half;
	1134	} u;
	1135	} sfpt;
	1136
	1137	struct swapped_fp_data_reg {
	1138	unsigned short mant;
	1139	unsigned short mant1 :16,
	1140	mant2 :16,
	1141	mant3 :16;
	1142	union {
	1143	struct {
	1144	unsigned short sign :1,
	1145	exp :15;
	1146	} fields;
	1147	unsigned short half;
	1148	} u;
	1149	} sfpd;
	1150
	1151	struct swapped_sel {
	1152	union {
	1153	struct {
	1154	unsigned short
	1155	index :13,
	1156	ti :1,
	1157	rpl :2;
	1158	} fields;
	1159	unsigned short half;
	1160	} u;
	1161	} ss;
	1162
	1163	enum byte_sex host_byte_sex;
	1164	unsigned long i;
	1165
	1166	host_byte_sex = get_host_byte_sex();
	1167
	1168	fpu->environ.ip = SWAP_LONG(fpu->environ.ip);
	1169	fpu->environ.opcode = SWAP_SHORT(fpu->environ.opcode);
	1170	fpu->environ.dp = SWAP_LONG(fpu->environ.dp);
	1171
	1172	if(target_byte_sex == host_byte_sex){
	1173	memcpy(&sfpc, &(fpu->environ.control),
	1174	sizeof(struct swapped_fp_control));
	1175	sfpc.u.half = SWAP_SHORT(sfpc.u.half);
	1176	fpu->environ.control.rc = sfpc.u.fields.rc;
	1177	fpu->environ.control.pc = sfpc.u.fields.pc;
	1178	fpu->environ.control.precis = sfpc.u.fields.precis;
	1179	fpu->environ.control.undfl = sfpc.u.fields.undfl;
	1180	fpu->environ.control.ovrfl = sfpc.u.fields.ovrfl;
	1181	fpu->environ.control.zdiv = sfpc.u.fields.zdiv;
	1182	fpu->environ.control.denorm = sfpc.u.fields.denorm;
	1183	fpu->environ.control.invalid = sfpc.u.fields.invalid;
	1184
	1185	memcpy(&sfps, &(fpu->environ.status),
	1186	sizeof(struct swapped_fp_status));
	1187	sfps.u.half = SWAP_SHORT(sfps.u.half);
	1188	fpu->environ.status.busy = sfps.u.fields.busy;
	1189	fpu->environ.status.c3 = sfps.u.fields.c3;
	1190	fpu->environ.status.tos = sfps.u.fields.tos;
	1191	fpu->environ.status.c2 = sfps.u.fields.c2;
	1192	fpu->environ.status.c1 = sfps.u.fields.c1;
	1193	fpu->environ.status.c0 = sfps.u.fields.c0;
	1194	fpu->environ.status.errsumm = sfps.u.fields.errsumm;
	1195	fpu->environ.status.stkflt = sfps.u.fields.stkflt;
	1196	fpu->environ.status.precis = sfps.u.fields.precis;
	1197	fpu->environ.status.undfl = sfps.u.fields.undfl;
	1198	fpu->environ.status.ovrfl = sfps.u.fields.ovrfl;
	1199	fpu->environ.status.zdiv = sfps.u.fields.zdiv;
	1200	fpu->environ.status.denorm = sfps.u.fields.denorm;
	1201	fpu->environ.status.invalid = sfps.u.fields.invalid;
	1202
	1203	memcpy(&sfpt, &(fpu->environ.tag),
	1204	sizeof(struct swapped_fp_tag));
	1205	sfpt.u.half = SWAP_SHORT(sfpt.u.half);
	1206	fpu->environ.tag.tag7 = sfpt.u.fields.tag7;
	1207	fpu->environ.tag.tag6 = sfpt.u.fields.tag6;
	1208	fpu->environ.tag.tag5 = sfpt.u.fields.tag5;
	1209	fpu->environ.tag.tag4 = sfpt.u.fields.tag4;
	1210	fpu->environ.tag.tag3 = sfpt.u.fields.tag3;
	1211	fpu->environ.tag.tag2 = sfpt.u.fields.tag2;
	1212	fpu->environ.tag.tag1 = sfpt.u.fields.tag1;
	1213	fpu->environ.tag.tag0 = sfpt.u.fields.tag0;
	1214
	1215	memcpy(&ss, &(fpu->environ.cs),
	1216	sizeof(struct swapped_sel));
	1217	ss.u.half = SWAP_SHORT(ss.u.half);
	1218	fpu->environ.cs.index = ss.u.fields.index;
	1219	fpu->environ.cs.ti = ss.u.fields.ti;
	1220	fpu->environ.cs.rpl = ss.u.fields.rpl;
	1221
	1222	memcpy(&ss, &(fpu->environ.ds),
	1223	sizeof(struct swapped_sel));
	1224	ss.u.half = SWAP_SHORT(ss.u.half);
	1225	fpu->environ.ds.index = ss.u.fields.index;
	1226	fpu->environ.ds.ti = ss.u.fields.ti;
	1227	fpu->environ.ds.rpl = ss.u.fields.rpl;
	1228
	1229	for(i = 0; i < 8; i++){
	1230	memcpy(&sfpd, &(fpu->stack.ST[i]),
	1231	sizeof(struct swapped_fp_data_reg));
	1232	fpu->stack.ST[i].mant = SWAP_SHORT(sfpd.mant);
	1233	fpu->stack.ST[i].mant1 = SWAP_SHORT(sfpd.mant1);
	1234	fpu->stack.ST[i].mant2 = SWAP_SHORT(sfpd.mant2);
	1235	fpu->stack.ST[i].mant3 = SWAP_SHORT(sfpd.mant3);
	1236	sfpd.u.half = SWAP_SHORT(sfpd.u.half);
	1237	fpu->stack.ST[i].exp = sfpd.u.fields.exp;
	1238	fpu->stack.ST[i].sign = sfpd.u.fields.sign;
	1239	}
	1240	}
	1241	else{
	1242	sfpc.u.fields.rc = fpu->environ.control.rc;
	1243	sfpc.u.fields.pc = fpu->environ.control.pc;
	1244	sfpc.u.fields.precis = fpu->environ.control.precis;
	1245	sfpc.u.fields.undfl = fpu->environ.control.undfl;
	1246	sfpc.u.fields.ovrfl = fpu->environ.control.ovrfl;
	1247	sfpc.u.fields.zdiv = fpu->environ.control.zdiv;
	1248	sfpc.u.fields.denorm = fpu->environ.control.denorm;
	1249	sfpc.u.fields.invalid = fpu->environ.control.invalid;
	1250	sfpc.u.half = SWAP_SHORT(sfpc.u.half);
	1251	memcpy(&(fpu->environ.control), &sfpc,
	1252	sizeof(struct swapped_fp_control));
	1253
	1254	sfps.u.fields.busy = fpu->environ.status.busy;
	1255	sfps.u.fields.c3 = fpu->environ.status.c3;
	1256	sfps.u.fields.tos = fpu->environ.status.tos;
	1257	sfps.u.fields.c2 = fpu->environ.status.c2;
	1258	sfps.u.fields.c1 = fpu->environ.status.c1;
	1259	sfps.u.fields.c0 = fpu->environ.status.c0;
	1260	sfps.u.fields.errsumm = fpu->environ.status.errsumm;
	1261	sfps.u.fields.stkflt = fpu->environ.status.stkflt;
	1262	sfps.u.fields.precis = fpu->environ.status.precis;
	1263	sfps.u.fields.undfl = fpu->environ.status.undfl;
	1264	sfps.u.fields.ovrfl = fpu->environ.status.ovrfl;
	1265	sfps.u.fields.zdiv = fpu->environ.status.zdiv;
	1266	sfps.u.fields.denorm = fpu->environ.status.denorm;
	1267	sfps.u.fields.invalid = fpu->environ.status.invalid;
	1268	sfps.u.half = SWAP_SHORT(sfps.u.half);
	1269	memcpy(&(fpu->environ.status), &sfps,
	1270	sizeof(struct swapped_fp_status));
	1271
	1272	sfpt.u.fields.tag7 = fpu->environ.tag.tag7;
	1273	sfpt.u.fields.tag6 = fpu->environ.tag.tag6;
	1274	sfpt.u.fields.tag5 = fpu->environ.tag.tag5;
	1275	sfpt.u.fields.tag4 = fpu->environ.tag.tag4;
	1276	sfpt.u.fields.tag3 = fpu->environ.tag.tag3;
	1277	sfpt.u.fields.tag2 = fpu->environ.tag.tag2;
	1278	sfpt.u.fields.tag1 = fpu->environ.tag.tag1;
	1279	sfpt.u.fields.tag0 = fpu->environ.tag.tag0;
	1280	sfpt.u.half = SWAP_SHORT(sfpt.u.half);
	1281	memcpy(&(fpu->environ.tag), &sfpt,
	1282	sizeof(struct swapped_fp_tag));
	1283
	1284	ss.u.fields.index = fpu->environ.cs.index;
	1285	ss.u.fields.ti = fpu->environ.cs.ti;
	1286	ss.u.fields.rpl = fpu->environ.cs.rpl;
	1287	ss.u.half = SWAP_SHORT(ss.u.half);
	1288	memcpy(&(fpu->environ.cs), &ss,
	1289	sizeof(struct swapped_sel));
	1290
	1291	ss.u.fields.index = fpu->environ.ds.index;
	1292	ss.u.fields.ti = fpu->environ.ds.ti;
	1293	ss.u.fields.rpl = fpu->environ.ds.rpl;
	1294	ss.u.half = SWAP_SHORT(ss.u.half);
	1295	memcpy(&(fpu->environ.cs), &ss,
	1296	sizeof(struct swapped_sel));
	1297
	1298	for(i = 0; i < 8; i++){
	1299	sfpd.mant = SWAP_SHORT(fpu->stack.ST[i].mant);
	1300	sfpd.mant1 = SWAP_SHORT(fpu->stack.ST[i].mant1);
	1301	sfpd.mant2 = SWAP_SHORT(fpu->stack.ST[i].mant2);
	1302	sfpd.mant3 = SWAP_SHORT(fpu->stack.ST[i].mant3);
	1303	sfpd.u.fields.exp = fpu->stack.ST[i].exp;
	1304	sfpd.u.fields.sign = fpu->stack.ST[i].sign;
	1305	sfpd.u.half = SWAP_SHORT(sfpd.u.half);
	1306	memcpy(&(fpu->stack.ST[i]), &sfpd,
	1307	sizeof(struct swapped_fp_data_reg));
	1308	}
	1309	}
	1310	}
	1311
	1312	__private_extern__
	1313	void
	1314	swap_i386_thread_exceptstate(
	1315	i386_thread_exceptstate_t *exc,
	1316	enum byte_sex target_byte_sex)
	1317	{
	1318	struct swapped_err_code {
	1319	union {
	1320	struct err_code_normal {
	1321	unsigned int :16,
	1322	index :13,
	1323	tbl :2,
	1324	ext :1;
	1325	} normal;
	1326	struct err_code_pgfault {
	1327	unsigned int :29,
	1328	user :1,
	1329	wrtflt :1,
	1330	prot :1;
	1331	} pgfault;
	1332	unsigned long word;
	1333	} u;
	1334	} sec;
	1335	unsigned long word;
	1336	enum byte_sex host_byte_sex;
	1337
	1338	host_byte_sex = get_host_byte_sex();
	1339
	1340	exc->trapno = SWAP_LONG(exc->trapno);
	1341	if(exc->trapno == 14){
	1342	if(target_byte_sex == host_byte_sex){
	1343	memcpy(&sec, &(exc->err), sizeof(struct swapped_err_code));
	1344	sec.u.word = SWAP_LONG(sec.u.word);
	1345	exc->err.pgfault.user = sec.u.pgfault.user;
	1346	exc->err.pgfault.wrtflt = sec.u.pgfault.wrtflt;
	1347	exc->err.pgfault.prot = sec.u.pgfault.prot;
	1348	}
	1349	else{
	1350	sec.u.pgfault.prot = exc->err.pgfault.prot;
	1351	sec.u.pgfault.wrtflt = exc->err.pgfault.wrtflt;
	1352	sec.u.pgfault.user = exc->err.pgfault.user;
	1353	sec.u.word = SWAP_LONG(sec.u.word);
	1354	memcpy(&(exc->err), &sec, sizeof(struct swapped_err_code));
	1355	}
	1356	}
	1357	else{
	1358	if(target_byte_sex == host_byte_sex){
	1359	memcpy(&sec, &(exc->err), sizeof(struct swapped_err_code));
	1360	sec.u.word = SWAP_LONG(sec.u.word);
	1361	word = sec.u.normal.index;
	1362	exc->err.normal.index = SWAP_LONG(word);
	1363	exc->err.normal.tbl = sec.u.normal.tbl;
	1364	exc->err.normal.ext = sec.u.normal.ext;
	1365	}
	1366	else{
	1367	sec.u.normal.ext = exc->err.normal.ext;
	1368	sec.u.normal.tbl = exc->err.normal.tbl;
	1369	word = exc->err.normal.index;
	1370	sec.u.normal.index = SWAP_LONG(word);
	1371	sec.u.word = SWAP_LONG(sec.u.word);
	1372	memcpy(&(exc->err), &sec, sizeof(struct swapped_err_code));
	1373	}
	1374	}
	1375	}
	1376
	1377	__private_extern__
	1378	void
	1379	swap_i386_thread_cthreadstate(
	1380	i386_thread_cthreadstate_t *user,
	1381	enum byte_sex target_byte_sex)
	1382	{
	1383	#ifdef __MWERKS__
	1384	enum byte_sex dummy;
	1385	dummy = target_byte_sex;
	1386	#endif
	1387	user->self = SWAP_LONG(user->self);
	1388	}
	1389
	1390	__private_extern__
	1391	void
	1392	swap_hppa_integer_thread_state(
	1393	struct hp_pa_integer_thread_state *regs,
	1394	enum byte_sex target_byte_sex)
	1395	{
	1396	#ifdef __MWERKS__
	1397	enum byte_sex dummy;
	1398	dummy = target_byte_sex;
	1399	#endif
	1400	regs->ts_gr1 = SWAP_LONG(regs->ts_gr1);
	1401	regs->ts_gr2 = SWAP_LONG(regs->ts_gr2);
	1402	regs->ts_gr3 = SWAP_LONG(regs->ts_gr3);
	1403	regs->ts_gr4 = SWAP_LONG(regs->ts_gr4);
	1404	regs->ts_gr5 = SWAP_LONG(regs->ts_gr5);
	1405	regs->ts_gr6 = SWAP_LONG(regs->ts_gr6);
	1406	regs->ts_gr7 = SWAP_LONG(regs->ts_gr7);
	1407	regs->ts_gr8 = SWAP_LONG(regs->ts_gr8);
	1408	regs->ts_gr9 = SWAP_LONG(regs->ts_gr9);
	1409	regs->ts_gr10 = SWAP_LONG(regs->ts_gr10);
	1410	regs->ts_gr11 = SWAP_LONG(regs->ts_gr11);
	1411	regs->ts_gr12 = SWAP_LONG(regs->ts_gr12);
	1412	regs->ts_gr13 = SWAP_LONG(regs->ts_gr13);
	1413	regs->ts_gr14 = SWAP_LONG(regs->ts_gr14);
	1414	regs->ts_gr15 = SWAP_LONG(regs->ts_gr15);
	1415	regs->ts_gr16 = SWAP_LONG(regs->ts_gr16);
	1416	regs->ts_gr17 = SWAP_LONG(regs->ts_gr17);
	1417	regs->ts_gr18 = SWAP_LONG(regs->ts_gr18);
	1418	regs->ts_gr19 = SWAP_LONG(regs->ts_gr19);
	1419	regs->ts_gr20 = SWAP_LONG(regs->ts_gr20);
	1420	regs->ts_gr21 = SWAP_LONG(regs->ts_gr21);
	1421	regs->ts_gr22 = SWAP_LONG(regs->ts_gr22);
	1422	regs->ts_gr23 = SWAP_LONG(regs->ts_gr23);
	1423	regs->ts_gr24 = SWAP_LONG(regs->ts_gr24);
	1424	regs->ts_gr25 = SWAP_LONG(regs->ts_gr25);
	1425	regs->ts_gr26 = SWAP_LONG(regs->ts_gr26);
	1426	regs->ts_gr27 = SWAP_LONG(regs->ts_gr27);
	1427	regs->ts_gr28 = SWAP_LONG(regs->ts_gr28);
	1428	regs->ts_gr29 = SWAP_LONG(regs->ts_gr29);
	1429	regs->ts_gr30 = SWAP_LONG(regs->ts_gr30);
	1430	regs->ts_gr31 = SWAP_LONG(regs->ts_gr31);
	1431	regs->ts_sr0 = SWAP_LONG(regs->ts_sr0);
	1432	regs->ts_sr1 = SWAP_LONG(regs->ts_sr1);
	1433	regs->ts_sr2 = SWAP_LONG(regs->ts_sr2);
	1434	regs->ts_sr3 = SWAP_LONG(regs->ts_sr3);
	1435	regs->ts_sar = SWAP_LONG(regs->ts_sar);
	1436	}
	1437
	1438	__private_extern__
	1439	void swap_hppa_frame_thread_state(
	1440	struct hp_pa_frame_thread_state *frame,
	1441	enum byte_sex target_byte_sex)
	1442	{
	1443	#ifdef __MWERKS__
	1444	enum byte_sex dummy;
	1445	dummy = target_byte_sex;
	1446	#endif
	1447	frame->ts_pcsq_front = SWAP_LONG(frame->ts_pcsq_front);
	1448	frame->ts_pcsq_back = SWAP_LONG(frame->ts_pcsq_back);
	1449	frame->ts_pcoq_front = SWAP_LONG(frame->ts_pcoq_front);
	1450	frame->ts_pcoq_back = SWAP_LONG(frame->ts_pcoq_back);
	1451	frame->ts_psw = SWAP_LONG(frame->ts_psw);
	1452	frame->ts_unaligned_faults = SWAP_LONG(frame->ts_unaligned_faults);
	1453	frame->ts_fault_address = SWAP_LONG(frame->ts_fault_address);
	1454	frame->ts_step_range_start = SWAP_LONG(frame->ts_step_range_start);
	1455	frame->ts_step_range_stop = SWAP_LONG(frame->ts_step_range_stop);
	1456	}
	1457
	1458	__private_extern__
	1459	void swap_hppa_fp_thread_state(
	1460	struct hp_pa_fp_thread_state *fp,
	1461	enum byte_sex target_byte_sex)
	1462	{
	1463	#ifdef __MWERKS__
	1464	enum byte_sex dummy;
	1465	dummy = target_byte_sex;
	1466	#endif
	1467	fp->ts_fp0 = SWAP_DOUBLE(fp->ts_fp0);
	1468	fp->ts_fp1 = SWAP_DOUBLE(fp->ts_fp1);
	1469	fp->ts_fp2 = SWAP_DOUBLE(fp->ts_fp2);
	1470	fp->ts_fp3 = SWAP_DOUBLE(fp->ts_fp3);
	1471	fp->ts_fp4 = SWAP_DOUBLE(fp->ts_fp4);
	1472	fp->ts_fp5 = SWAP_DOUBLE(fp->ts_fp5);
	1473	fp->ts_fp6 = SWAP_DOUBLE(fp->ts_fp6);
	1474	fp->ts_fp7 = SWAP_DOUBLE(fp->ts_fp7);
	1475	fp->ts_fp8 = SWAP_DOUBLE(fp->ts_fp8);
	1476	fp->ts_fp9 = SWAP_DOUBLE(fp->ts_fp9);
	1477	fp->ts_fp10 = SWAP_DOUBLE(fp->ts_fp10);
	1478	fp->ts_fp11 = SWAP_DOUBLE(fp->ts_fp11);
	1479	fp->ts_fp12 = SWAP_DOUBLE(fp->ts_fp12);
	1480	fp->ts_fp13 = SWAP_DOUBLE(fp->ts_fp13);
	1481	fp->ts_fp14 = SWAP_DOUBLE(fp->ts_fp14);
	1482	fp->ts_fp15 = SWAP_DOUBLE(fp->ts_fp15);
	1483	fp->ts_fp16 = SWAP_DOUBLE(fp->ts_fp16);
	1484	fp->ts_fp17 = SWAP_DOUBLE(fp->ts_fp17);
	1485	fp->ts_fp18 = SWAP_DOUBLE(fp->ts_fp18);
	1486	fp->ts_fp19 = SWAP_DOUBLE(fp->ts_fp19);
	1487	fp->ts_fp20 = SWAP_DOUBLE(fp->ts_fp20);
	1488	fp->ts_fp21 = SWAP_DOUBLE(fp->ts_fp21);
	1489	fp->ts_fp22 = SWAP_DOUBLE(fp->ts_fp22);
	1490	fp->ts_fp23 = SWAP_DOUBLE(fp->ts_fp23);
	1491	fp->ts_fp24 = SWAP_DOUBLE(fp->ts_fp24);
	1492	fp->ts_fp25 = SWAP_DOUBLE(fp->ts_fp25);
	1493	fp->ts_fp26 = SWAP_DOUBLE(fp->ts_fp26);
	1494	fp->ts_fp27 = SWAP_DOUBLE(fp->ts_fp27);
	1495	fp->ts_fp28 = SWAP_DOUBLE(fp->ts_fp28);
	1496	fp->ts_fp29 = SWAP_DOUBLE(fp->ts_fp29);
	1497	fp->ts_fp30 = SWAP_DOUBLE(fp->ts_fp30);
	1498	fp->ts_fp31 = SWAP_DOUBLE(fp->ts_fp31);
	1499	}
	1500
	1501	__private_extern__
	1502	void
	1503	swap_sparc_thread_state_regs(
	1504	struct sparc_thread_state_regs *cpu,
	1505	enum byte_sex target_byte_sex)
	1506	{
	1507	struct swapped_psr {
	1508	union {
	1509	struct {
	1510	unsigned int
	1511	cwp:BITS_WIDTH(4,0),
	1512	et:BIT_WIDTH(5),
	1513	ps:BIT_WIDTH(6),
	1514	s:BIT_WIDTH(7),
	1515	pil:BITS_WIDTH(11,8),
	1516	ef:BIT_WIDTH(12),
	1517	ec:BIT_WIDTH(13),
	1518	reserved:BITS_WIDTH(19,14),
	1519	icc:BITS_WIDTH(23,20),
	1520	ver:BITS_WIDTH(27,24),
	1521	impl:BITS_WIDTH(31,28);
	1522	} fields;
	1523	unsigned int word;
	1524	} u;
	1525	} spsr;
	1526	struct p_status *pr_status;
	1527	enum byte_sex host_byte_sex;
	1528
	1529	host_byte_sex = get_host_byte_sex();
	1530
	1531	cpu->regs.r_pc = SWAP_LONG(cpu->regs.r_pc);
	1532	cpu->regs.r_npc = SWAP_LONG(cpu->regs.r_npc);
	1533	cpu->regs.r_y = SWAP_LONG(cpu->regs.r_y);
	1534	cpu->regs.r_g1 = SWAP_LONG(cpu->regs.r_g1);
	1535	cpu->regs.r_g2 = SWAP_LONG(cpu->regs.r_g2);
	1536	cpu->regs.r_g3 = SWAP_LONG(cpu->regs.r_g3);
	1537	cpu->regs.r_g4 = SWAP_LONG(cpu->regs.r_g4);
	1538	cpu->regs.r_g5 = SWAP_LONG(cpu->regs.r_g5);
	1539	cpu->regs.r_g6 = SWAP_LONG(cpu->regs.r_g6);
	1540	cpu->regs.r_g7 = SWAP_LONG(cpu->regs.r_g7);
	1541	cpu->regs.r_o0 = SWAP_LONG(cpu->regs.r_o0);
	1542	cpu->regs.r_o1 = SWAP_LONG(cpu->regs.r_o1);
	1543	cpu->regs.r_o2 = SWAP_LONG(cpu->regs.r_o2);
	1544	cpu->regs.r_o3 = SWAP_LONG(cpu->regs.r_o3);
	1545	cpu->regs.r_o4 = SWAP_LONG(cpu->regs.r_o4);
	1546	cpu->regs.r_o5 = SWAP_LONG(cpu->regs.r_o5);
	1547	cpu->regs.r_o6 = SWAP_LONG(cpu->regs.r_o6);
	1548	cpu->regs.r_o7 = SWAP_LONG(cpu->regs.r_o7);
	1549
	1550	pr_status = (struct p_status *) &(cpu->regs.r_psr);
	1551	if(target_byte_sex == host_byte_sex){
	1552	memcpy(&spsr, &(cpu->regs.r_psr), sizeof(struct swapped_psr));
	1553	spsr.u.word = SWAP_LONG(spsr.u.word);
	1554	pr_status->PSRREG.psr_bits.cwp = spsr.u.fields.cwp;
	1555	pr_status->PSRREG.psr_bits.ps = spsr.u.fields.ps;
	1556	pr_status->PSRREG.psr_bits.s = spsr.u.fields.s;
	1557	pr_status->PSRREG.psr_bits.pil = spsr.u.fields.pil;
	1558	pr_status->PSRREG.psr_bits.ef = spsr.u.fields.ef;
	1559	pr_status->PSRREG.psr_bits.ec = spsr.u.fields.ec;
	1560	pr_status->PSRREG.psr_bits.reserved = spsr.u.fields.reserved;
	1561	pr_status->PSRREG.psr_bits.icc = spsr.u.fields.icc;
	1562	pr_status->PSRREG.psr_bits.et = spsr.u.fields.ver;
	1563	pr_status->PSRREG.psr_bits.impl = spsr.u.fields.impl;
	1564	}
	1565	else{
	1566	spsr.u.fields.cwp = pr_status->PSRREG.psr_bits.cwp;
	1567	spsr.u.fields.ps = pr_status->PSRREG.psr_bits.ps;
	1568	spsr.u.fields.s = pr_status->PSRREG.psr_bits.s;
	1569	spsr.u.fields.pil = pr_status->PSRREG.psr_bits.pil;
	1570	spsr.u.fields.ef = pr_status->PSRREG.psr_bits.ef;
	1571	spsr.u.fields.ec = pr_status->PSRREG.psr_bits.ec;
	1572	spsr.u.fields.reserved = pr_status->PSRREG.psr_bits.reserved;
	1573	spsr.u.fields.icc = pr_status->PSRREG.psr_bits.icc;
	1574	spsr.u.fields.ver = pr_status->PSRREG.psr_bits.et;
	1575	spsr.u.fields.impl = pr_status->PSRREG.psr_bits.impl;
	1576	spsr.u.word = SWAP_LONG(spsr.u.word);
	1577	memcpy(&(cpu->regs.r_psr), &spsr, sizeof(struct swapped_psr));
	1578	}
	1579	}
	1580
	1581	__private_extern__
	1582	void
	1583	swap_sparc_thread_state_fpu(
	1584	struct sparc_thread_state_fpu *fpu,
	1585	enum byte_sex target_byte_sex)
	1586	{
	1587	struct swapped_fsr {
	1588	union {
	1589	struct {
	1590	unsigned int
	1591	cexc:BITS_WIDTH(4,0),
	1592	aexc:BITS_WIDTH(9,5),
	1593	fcc:BITS_WIDTH(11,10),
	1594	pr:BIT_WIDTH(12),
	1595	qne:BIT_WIDTH(13),
	1596	ftt:BITS_WIDTH(16,14),
	1597	res:BITS_WIDTH(22,17),
	1598	tem:BITS_WIDTH(27,23),
	1599	rp:BITS_WIDTH(29,28),
	1600	rd:BITS_WIDTH(31,30);
	1601	} fields;
	1602	unsigned int word;
	1603	} u;
	1604	} sfsr;
	1605	unsigned long i;
	1606	struct f_status *fpu_status;
	1607	enum byte_sex host_byte_sex;
	1608
	1609	host_byte_sex = get_host_byte_sex();
	1610
	1611
	1612	/* floating point registers */
	1613	for(i = 0; i < 16; i++) /* 16 doubles */
	1614	fpu->fpu.fpu_fr.Fpu_dregs[i] =
	1615	SWAP_DOUBLE(fpu->fpu.fpu_fr.Fpu_dregs[i]);
	1616
	1617	fpu->fpu.Fpu_q[0].FQu.whole = SWAP_DOUBLE(fpu->fpu.Fpu_q[0].FQu.whole);
	1618	fpu->fpu.Fpu_q[1].FQu.whole = SWAP_DOUBLE(fpu->fpu.Fpu_q[1].FQu.whole);
	1619	fpu->fpu.Fpu_flags = SWAP_LONG(fpu->fpu.Fpu_flags);
	1620	fpu->fpu.Fpu_extra = SWAP_LONG(fpu->fpu.Fpu_extra);
	1621	fpu->fpu.Fpu_qcnt = SWAP_LONG(fpu->fpu.Fpu_qcnt);
	1622
	1623	fpu_status = (struct f_status *) &(fpu->fpu.Fpu_fsr);
	1624	if(target_byte_sex == host_byte_sex){
	1625	memcpy(&sfsr, &(fpu->fpu.Fpu_fsr), sizeof(unsigned int));
	1626	sfsr.u.word = SWAP_LONG(sfsr.u.word);
	1627	fpu_status->FPUREG.Fpu_fsr_bits.rd = sfsr.u.fields.rd;
	1628	fpu_status->FPUREG.Fpu_fsr_bits.rp = sfsr.u.fields.rp;
	1629	fpu_status->FPUREG.Fpu_fsr_bits.tem = sfsr.u.fields.tem;
	1630	fpu_status->FPUREG.Fpu_fsr_bits.res = sfsr.u.fields.res;
	1631	fpu_status->FPUREG.Fpu_fsr_bits.ftt = sfsr.u.fields.ftt;
	1632	fpu_status->FPUREG.Fpu_fsr_bits.qne = sfsr.u.fields.qne;
	1633	fpu_status->FPUREG.Fpu_fsr_bits.pr = sfsr.u.fields.pr;
	1634	fpu_status->FPUREG.Fpu_fsr_bits.fcc = sfsr.u.fields.fcc;
	1635	fpu_status->FPUREG.Fpu_fsr_bits.aexc = sfsr.u.fields.aexc;
	1636	fpu_status->FPUREG.Fpu_fsr_bits.cexc = sfsr.u.fields.cexc;
	1637	}
	1638	else{
	1639	sfsr.u.fields.rd = fpu_status->FPUREG.Fpu_fsr_bits.rd;
	1640	sfsr.u.fields.rp = fpu_status->FPUREG.Fpu_fsr_bits.rp;
	1641	sfsr.u.fields.tem = fpu_status->FPUREG.Fpu_fsr_bits.tem;
	1642	sfsr.u.fields.res = fpu_status->FPUREG.Fpu_fsr_bits.res;
	1643	sfsr.u.fields.ftt = fpu_status->FPUREG.Fpu_fsr_bits.ftt;
	1644	sfsr.u.fields.qne = fpu_status->FPUREG.Fpu_fsr_bits.qne;
	1645	sfsr.u.fields.pr = fpu_status->FPUREG.Fpu_fsr_bits.pr;
	1646	sfsr.u.fields.fcc = fpu_status->FPUREG.Fpu_fsr_bits.fcc;
	1647	sfsr.u.fields.aexc = fpu_status->FPUREG.Fpu_fsr_bits.aexc;
	1648	sfsr.u.fields.cexc = fpu_status->FPUREG.Fpu_fsr_bits.cexc;
	1649	sfsr.u.word = SWAP_LONG(sfsr.u.word);
	1650	memcpy(&(fpu->fpu.Fpu_fsr), &sfsr, sizeof(struct swapped_fsr));
	1651	}
	1652	}
	1653
	1654	__private_extern__
	1655	void
	1656	swap_ident_command(
	1657	struct ident_command *id_cmd,
	1658	enum byte_sex target_byte_sex)
	1659	{
	1660	#ifdef __MWERKS__
	1661	enum byte_sex dummy;
	1662	dummy = target_byte_sex;
	1663	#endif
	1664	id_cmd->cmd = SWAP_LONG(id_cmd->cmd);
	1665	id_cmd->cmdsize = SWAP_LONG(id_cmd->cmdsize);
	1666	}
	1667
	1668	__private_extern__
	1669	void
	1670	swap_routines_command(
	1671	struct routines_command *r_cmd,
	1672	enum byte_sex target_byte_sex)
	1673	{
	1674	#ifdef __MWERKS__
	1675	enum byte_sex dummy;
	1676	dummy = target_byte_sex;
	1677	#endif
	1678	r_cmd->cmd = SWAP_LONG(r_cmd->cmd);
	1679	r_cmd->cmdsize = SWAP_LONG(r_cmd->cmdsize);
	1680	r_cmd->init_address = SWAP_LONG(r_cmd->init_address);
	1681	r_cmd->init_module = SWAP_LONG(r_cmd->init_module);
	1682	r_cmd->reserved1 = SWAP_LONG(r_cmd->reserved1);
	1683	r_cmd->reserved2 = SWAP_LONG(r_cmd->reserved2);
	1684	r_cmd->reserved3 = SWAP_LONG(r_cmd->reserved3);
	1685	r_cmd->reserved4 = SWAP_LONG(r_cmd->reserved4);
	1686	r_cmd->reserved5 = SWAP_LONG(r_cmd->reserved5);
	1687	r_cmd->reserved6 = SWAP_LONG(r_cmd->reserved6);
	1688	}
	1689
	1690	__private_extern__
	1691	void
	1692	swap_twolevel_hints_command(
	1693	struct twolevel_hints_command *hints_cmd,
	1694	enum byte_sex target_byte_sex)
	1695	{
	1696	#ifdef __MWERKS__
	1697	enum byte_sex dummy;
	1698	dummy = target_byte_sex;
	1699	#endif
	1700	hints_cmd->cmd = SWAP_LONG(hints_cmd->cmd);
	1701	hints_cmd->cmdsize = SWAP_LONG(hints_cmd->cmdsize);
	1702	hints_cmd->offset = SWAP_LONG(hints_cmd->offset);
	1703	hints_cmd->nhints = SWAP_LONG(hints_cmd->nhints);
	1704	}
	1705
	1706	__private_extern__
	1707	void
	1708	swap_twolevel_hint(
	1709	struct twolevel_hint *hints,
	1710	unsigned long nhints,
	1711	enum byte_sex target_byte_sex)
	1712	{
	1713	struct swapped_twolevel_hint {
	1714	union {
	1715	struct {
	1716	unsigned long
	1717	itoc:24,
	1718	isub_image:8;
	1719	} fields;
	1720	unsigned long word;
	1721	} u;
	1722	} shint;
	1723
	1724	unsigned long i;
	1725	enum byte_sex host_byte_sex;
	1726
	1727	host_byte_sex = get_host_byte_sex();
	1728
	1729	for(i = 0; i < nhints; i++){
	1730	if(target_byte_sex == host_byte_sex){
	1731	memcpy(&shint, hints + i, sizeof(struct swapped_twolevel_hint));
	1732	shint.u.word = SWAP_LONG(shint.u.word);
	1733	hints[i].itoc = shint.u.fields.itoc;
	1734	hints[i].isub_image = shint.u.fields.isub_image;
	1735	}
	1736	else{
	1737	shint.u.fields.isub_image = hints[i].isub_image;
	1738	shint.u.fields.itoc = hints[i].itoc;
	1739	shint.u.word = SWAP_LONG(shint.u.word);
	1740	memcpy(hints + i, &shint, sizeof(struct swapped_twolevel_hint));
	1741	}
	1742	}
	1743	}
	1744
	1745	__private_extern__
	1746	void
	1747	swap_prebind_cksum_command(
	1748	struct prebind_cksum_command *cksum_cmd,
	1749	enum byte_sex target_byte_sex)
	1750	{
	1751	#ifdef __MWERKS__
	1752	enum byte_sex dummy;
	1753	dummy = target_byte_sex;
	1754	#endif
	1755	cksum_cmd->cmd = SWAP_LONG(cksum_cmd->cmd);
	1756	cksum_cmd->cmdsize = SWAP_LONG(cksum_cmd->cmdsize);
	1757	cksum_cmd->cksum = SWAP_LONG(cksum_cmd->cksum);
	1758	}
	1759
	1760	__private_extern__
	1761	void
	1762	swap_nlist(
	1763	struct nlist *symbols,
	1764	unsigned long nsymbols,
	1765	enum byte_sex target_byte_sex)
	1766	{
	1767	unsigned long i;
	1768	#ifdef __MWERKS__
	1769	enum byte_sex dummy;
	1770	dummy = target_byte_sex;
	1771	#endif
	1772
	1773	for(i = 0; i < nsymbols; i++){
	1774	symbols[i].n_un.n_strx = SWAP_LONG(symbols[i].n_un.n_strx);
	1775	/* n_type */
	1776	/* n_sect */
	1777	symbols[i].n_desc = SWAP_SHORT(symbols[i].n_desc);
	1778	symbols[i].n_value = SWAP_LONG(symbols[i].n_value);
	1779	}
	1780	}
	1781
	1782	__private_extern__
	1783	void
	1784	swap_ranlib(
	1785	struct ranlib *ranlibs,
	1786	unsigned long nranlibs,
	1787	enum byte_sex target_byte_sex)
	1788	{
	1789	unsigned long i;
	1790	#ifdef __MWERKS__
	1791	enum byte_sex dummy;
	1792	dummy = target_byte_sex;
	1793	#endif
	1794
	1795	for(i = 0; i < nranlibs; i++){
	1796	ranlibs[i].ran_un.ran_strx = SWAP_LONG(ranlibs[i].ran_un.ran_strx);
	1797	ranlibs[i].ran_off = SWAP_LONG(ranlibs[i].ran_off);
	1798	}
	1799	}
	1800
	1801	__private_extern__
	1802	void
	1803	swap_relocation_info(
	1804	struct relocation_info *relocs,
	1805	unsigned long nrelocs,
	1806	enum byte_sex target_byte_sex)
	1807	{
	1808	unsigned long i;
	1809	enum byte_sex host_byte_sex;
	1810	enum bool to_host_byte_sex, scattered;
	1811
	1812	struct swapped_relocation_info {
	1813	long r_address;
	1814	union {
	1815	struct {
	1816	unsigned int
	1817	r_type:4,
	1818	r_extern:1,
	1819	r_length:2,
	1820	r_pcrel:1,
	1821	r_symbolnum:24;
	1822	} fields;
	1823	unsigned long word;
	1824	} u;
	1825	} sr;
	1826
	1827	struct swapped_scattered_relocation_info {
	1828	unsigned long word;
	1829	long r_value;
	1830	} *ssr;
	1831
	1832	host_byte_sex = get_host_byte_sex();
	1833	to_host_byte_sex = (enum bool)(target_byte_sex == host_byte_sex);
	1834
	1835	for(i = 0; i < nrelocs; i++){
	1836	if(to_host_byte_sex)
	1837	scattered = (enum bool)(
	1838	(SWAP_LONG(relocs[i].r_address) & R_SCATTERED) != 0);
	1839	else
	1840	scattered = (enum bool)
	1841	(((relocs[i].r_address) & R_SCATTERED) != 0);
	1842	if(scattered == FALSE){
	1843	if(to_host_byte_sex){
	1844	memcpy(&sr, relocs + i, sizeof(struct relocation_info));
	1845	sr.r_address = SWAP_LONG(sr.r_address);
	1846	sr.u.word = SWAP_LONG(sr.u.word);
	1847	relocs[i].r_address = sr.r_address;
	1848	relocs[i].r_symbolnum = sr.u.fields.r_symbolnum;
	1849	relocs[i].r_pcrel = sr.u.fields.r_pcrel;
	1850	relocs[i].r_length = sr.u.fields.r_length;
	1851	relocs[i].r_extern = sr.u.fields.r_extern;
	1852	relocs[i].r_type = sr.u.fields.r_type;
	1853	}
	1854	else{
	1855	sr.r_address = relocs[i].r_address;
	1856	sr.u.fields.r_symbolnum = relocs[i].r_symbolnum;
	1857	sr.u.fields.r_length = relocs[i].r_length;
	1858	sr.u.fields.r_pcrel = relocs[i].r_pcrel;
	1859	sr.u.fields.r_extern = relocs[i].r_extern;
	1860	sr.u.fields.r_type = relocs[i].r_type;
	1861	sr.r_address = SWAP_LONG(sr.r_address);
	1862	sr.u.word = SWAP_LONG(sr.u.word);
	1863	memcpy(relocs + i, &sr, sizeof(struct relocation_info));
	1864	}
	1865	}
	1866	else{
	1867	ssr = (struct swapped_scattered_relocation_info *)(relocs + i);
	1868	ssr->word = SWAP_LONG(ssr->word);
	1869	ssr->r_value = SWAP_LONG(ssr->r_value);
	1870	}
	1871	}
	1872	}
	1873
	1874	__private_extern__
	1875	void
	1876	swap_indirect_symbols(
	1877	unsigned long *indirect_symbols,
	1878	unsigned long nindirect_symbols,
	1879	enum byte_sex target_byte_sex)
	1880	{
	1881	unsigned long i;
	1882	#ifdef __MWERKS__
	1883	enum byte_sex dummy;
	1884	dummy = target_byte_sex;
	1885	#endif
	1886
	1887	for(i = 0; i < nindirect_symbols; i++)
	1888	indirect_symbols[i] = SWAP_LONG(indirect_symbols[i]);
	1889	}
	1890
	1891	__private_extern__
	1892	void
	1893	swap_dylib_reference(
	1894	struct dylib_reference *refs,
	1895	unsigned long nrefs,
	1896	enum byte_sex target_byte_sex)
	1897	{
	1898	struct swapped_dylib_reference {
	1899	union {
	1900	struct {
	1901	unsigned long
	1902	flags:8,
	1903	isym:24;
	1904	} fields;
	1905	unsigned long word;
	1906	} u;
	1907	} sref;
	1908
	1909	unsigned long i;
	1910	enum byte_sex host_byte_sex;
	1911
	1912	host_byte_sex = get_host_byte_sex();
	1913
	1914	for(i = 0; i < nrefs; i++){
	1915	if(target_byte_sex == host_byte_sex){
	1916	memcpy(&sref, refs + i, sizeof(struct swapped_dylib_reference));
	1917	sref.u.word = SWAP_LONG(sref.u.word);
	1918	refs[i].flags = sref.u.fields.flags;
	1919	refs[i].isym = sref.u.fields.isym;
	1920	}
	1921	else{
	1922	sref.u.fields.isym = refs[i].isym;
	1923	sref.u.fields.flags = refs[i].flags;
	1924	sref.u.word = SWAP_LONG(sref.u.word);
	1925	memcpy(refs + i, &sref, sizeof(struct swapped_dylib_reference));
	1926	}
	1927	}
	1928
	1929	}
	1930
	1931	__private_extern__
	1932	void
	1933	swap_dylib_module(
	1934	struct dylib_module *mods,
	1935	unsigned long nmods,
	1936	enum byte_sex target_byte_sex)
	1937	{
	1938	unsigned long i;
	1939	#ifdef __MWERKS__
	1940	enum byte_sex dummy;
	1941	dummy = target_byte_sex;
	1942	#endif
	1943
	1944	for(i = 0; i < nmods; i++){
	1945	mods[i].module_name = SWAP_LONG(mods[i].module_name);
	1946	mods[i].iextdefsym = SWAP_LONG(mods[i].iextdefsym);
	1947	mods[i].nextdefsym = SWAP_LONG(mods[i].nextdefsym);
	1948	mods[i].irefsym = SWAP_LONG(mods[i].irefsym);
	1949	mods[i].nrefsym = SWAP_LONG(mods[i].nrefsym);
	1950	mods[i].ilocalsym = SWAP_LONG(mods[i].ilocalsym);
	1951	mods[i].nlocalsym = SWAP_LONG(mods[i].nlocalsym);
	1952	mods[i].iextrel = SWAP_LONG(mods[i].iextrel);
	1953	mods[i].nextrel = SWAP_LONG(mods[i].nextrel);
	1954	mods[i].iinit_iterm = SWAP_LONG(mods[i].iinit_iterm);
	1955	mods[i].ninit_nterm = SWAP_LONG(mods[i].ninit_nterm);
	1956	mods[i].objc_module_info_addr =
	1957	SWAP_LONG(mods[i].objc_module_info_addr);
	1958	mods[i].objc_module_info_size =
	1959	SWAP_LONG(mods[i].objc_module_info_size);
	1960	}
	1961	}
	1962
	1963	__private_extern__
	1964	void
	1965	swap_dylib_table_of_contents(
	1966	struct dylib_table_of_contents *tocs,
	1967	unsigned long ntocs,
	1968	enum byte_sex target_byte_sex)
	1969	{
	1970	unsigned long i;
	1971	#ifdef __MWERKS__
	1972	enum byte_sex dummy;
	1973	dummy = target_byte_sex;
	1974	#endif
	1975
	1976	for(i = 0; i < ntocs; i++){
	1977	tocs[i].symbol_index = SWAP_LONG(tocs[i].symbol_index);
	1978	tocs[i].module_index = SWAP_LONG(tocs[i].module_index);
	1979	}
	1980	}

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

Download in other formats: