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