![[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.