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

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