void
byte_swap_dinode_in(struct dinode *di)
{
int i;
di->di_mode = NXSwapShort(di->di_mode);
di->di_nlink = NXSwapShort(di->di_nlink);
#ifdef LFS
di->di_u.inumber = NXSwapLong(di->di_u.inumber);
#else
di->di_u.oldids[0] = NXSwapShort(di->di_u.oldids[0]);
di->di_u.oldids[1] = NXSwapShort(di->di_u.oldids[1]);
#endif
di->di_size = NXSwapLongLong(di->di_size);
di->di_atime = NXSwapLong(di->di_atime);
di->di_atimensec = NXSwapLong(di->di_atimensec);
di->di_mtime = NXSwapLong(di->di_mtime);
di->di_mtimensec = NXSwapLong(di->di_mtimensec);
di->di_ctime = NXSwapLong(di->di_ctime);
di->di_ctimensec = NXSwapLong(di->di_ctimensec);
if (((di->di_mode & IFMT) != IFLNK ) || (di->di_size > RESYMLNKLEN)) {
for (i=0; i < NDADDR; i++) /* direct blocks */
di->di_db[i] = NXSwapLong(di->di_db[i]);
for (i=0; i < NIADDR; i++) /* indirect blocks */
di->di_ib[i] = NXSwapLong(di->di_ib[i]);
}
di->di_flags = NXSwapLong(di->di_flags);
di->di_blocks = NXSwapLong(di->di_blocks);
di->di_gen = NXSwapLong(di->di_gen);
di->di_uid = NXSwapLong(di->di_uid);
di->di_gid = NXSwapLong(di->di_gid);
di->di_spare[0] = NXSwapLong(di->di_spare[0]);
di->di_spare[1] = NXSwapLong(di->di_spare[1]);
}
void
swap_m68k_thread_state_regs(
struct m68k_thread_state_regs *cpu,
enum NXByteOrder target_byte_sex)
{
unsigned long i;
for(i = 0; i < 8; i++)
cpu->dreg[i] = NXSwapLong(cpu->dreg[i]);
for(i = 0; i < 8; i++)
cpu->areg[i] = NXSwapLong(cpu->areg[i]);
cpu->pad0 = NXSwapShort(cpu->pad0);
cpu->sr = NXSwapShort(cpu->sr);
cpu->pc = NXSwapLong(cpu->pc);
}
void
swap_nlist(
struct nlist *symbols,
unsigned long nsymbols,
enum NXByteOrder target_byte_sex)
{
unsigned long i;
for(i = 0; i < nsymbols; i++){
symbols[i].n_un.n_strx = NXSwapLong(symbols[i].n_un.n_strx);
/* n_type */
/* n_sect */
symbols[i].n_desc = NXSwapShort(symbols[i].n_desc);
symbols[i].n_value = NXSwapLong(symbols[i].n_value);
}
}
void
swap_i386_thread_fpstate(
i386_thread_fpstate_t *fpu,
enum NXByteOrder target_byte_sex)
{
struct swapped_fp_control {
union {
struct {
unsigned short
:3,
/*inf*/ :1,
rc :2,
pc :2,
:2,
precis :1,
undfl :1,
ovrfl :1,
zdiv :1,
denorm :1,
invalid :1;
} fields;
unsigned short half;
} u;
} sfpc;
struct swapped_fp_status {
union {
struct {
unsigned short
busy :1,
c3 :1,
tos :3,
c2 :1,
c1 :1,
c0 :1,
errsumm :1,
stkflt :1,
precis :1,
undfl :1,
ovrfl :1,
zdiv :1,
denorm :1,
invalid :1;
} fields;
unsigned short half;
} u;
} sfps;
struct swapped_fp_tag {
union {
struct {
unsigned short
tag7 :2,
tag6 :2,
tag5 :2,
tag4 :2,
tag3 :2,
tag2 :2,
tag1 :2,
tag0 :2;
} fields;
unsigned short half;
} u;
} sfpt;
struct swapped_fp_data_reg {
unsigned short mant;
unsigned short mant1 :16,
mant2 :16,
mant3 :16;
union {
struct {
unsigned short sign :1,
exp :15;
} fields;
unsigned short half;
} u;
} sfpd;
struct swapped_sel {
union {
struct {
unsigned short
index :13,
ti :1,
rpl :2;
} fields;
unsigned short half;
} u;
} ss;
enum NXByteOrder host_byte_sex;
unsigned long i;
host_byte_sex = NXHostByteOrder();
fpu->environ.ip = NXSwapLong(fpu->environ.ip);
fpu->environ.opcode = NXSwapShort(fpu->environ.opcode);
fpu->environ.dp = NXSwapLong(fpu->environ.dp);
if(target_byte_sex == host_byte_sex) {
memcpy(&sfpc, &(fpu->environ.control),
sizeof(struct swapped_fp_control));
sfpc.u.half = NXSwapShort(sfpc.u.half);
fpu->environ.control.rc = sfpc.u.fields.rc;
fpu->environ.control.pc = sfpc.u.fields.pc;
fpu->environ.control.precis = sfpc.u.fields.precis;
fpu->environ.control.undfl = sfpc.u.fields.undfl;
fpu->environ.control.ovrfl = sfpc.u.fields.ovrfl;
fpu->environ.control.zdiv = sfpc.u.fields.zdiv;
fpu->environ.control.denorm = sfpc.u.fields.denorm;
fpu->environ.control.invalid = sfpc.u.fields.invalid;
memcpy(&sfps, &(fpu->environ.status),
sizeof(struct swapped_fp_status));
sfps.u.half = NXSwapShort(sfps.u.half);
fpu->environ.status.busy = sfps.u.fields.busy;
fpu->environ.status.c3 = sfps.u.fields.c3;
fpu->environ.status.tos = sfps.u.fields.tos;
fpu->environ.status.c2 = sfps.u.fields.c2;
fpu->environ.status.c1 = sfps.u.fields.c1;
fpu->environ.status.c0 = sfps.u.fields.c0;
fpu->environ.status.errsumm = sfps.u.fields.errsumm;
fpu->environ.status.stkflt = sfps.u.fields.stkflt;
fpu->environ.status.precis = sfps.u.fields.precis;
fpu->environ.status.undfl = sfps.u.fields.undfl;
fpu->environ.status.ovrfl = sfps.u.fields.ovrfl;
fpu->environ.status.zdiv = sfps.u.fields.zdiv;
fpu->environ.status.denorm = sfps.u.fields.denorm;
fpu->environ.status.invalid = sfps.u.fields.invalid;
memcpy(&sfpt, &(fpu->environ.tag),
sizeof(struct swapped_fp_tag));
sfpt.u.half = NXSwapShort(sfpt.u.half);
fpu->environ.tag.tag7 = sfpt.u.fields.tag7;
fpu->environ.tag.tag6 = sfpt.u.fields.tag6;
fpu->environ.tag.tag5 = sfpt.u.fields.tag5;
fpu->environ.tag.tag4 = sfpt.u.fields.tag4;
fpu->environ.tag.tag3 = sfpt.u.fields.tag3;
fpu->environ.tag.tag2 = sfpt.u.fields.tag2;
fpu->environ.tag.tag1 = sfpt.u.fields.tag1;
fpu->environ.tag.tag0 = sfpt.u.fields.tag0;
memcpy(&ss, &(fpu->environ.cs),
sizeof(struct swapped_sel));
ss.u.half = NXSwapShort(ss.u.half);
fpu->environ.cs.index = ss.u.fields.index;
fpu->environ.cs.ti = ss.u.fields.ti;
fpu->environ.cs.rpl = ss.u.fields.rpl;
memcpy(&ss, &(fpu->environ.ds),
sizeof(struct swapped_sel));
ss.u.half = NXSwapShort(ss.u.half);
fpu->environ.ds.index = ss.u.fields.index;
fpu->environ.ds.ti = ss.u.fields.ti;
fpu->environ.ds.rpl = ss.u.fields.rpl;
for(i = 0; i < 8; i++) {
memcpy(&sfpd, &(fpu->stack.ST[i]),
sizeof(struct swapped_fp_data_reg));
fpu->stack.ST[i].mant = NXSwapShort(sfpd.mant);
fpu->stack.ST[i].mant1 = NXSwapShort(sfpd.mant1);
fpu->stack.ST[i].mant2 = NXSwapShort(sfpd.mant2);
fpu->stack.ST[i].mant3 = NXSwapShort(sfpd.mant3);
sfpd.u.half = NXSwapShort(sfpd.u.half);
fpu->stack.ST[i].exp = sfpd.u.fields.exp;
fpu->stack.ST[i].sign = sfpd.u.fields.sign;
}
}
else {
sfpc.u.fields.rc = fpu->environ.control.rc;
sfpc.u.fields.pc = fpu->environ.control.pc;
sfpc.u.fields.precis = fpu->environ.control.precis;
sfpc.u.fields.undfl = fpu->environ.control.undfl;
sfpc.u.fields.ovrfl = fpu->environ.control.ovrfl;
sfpc.u.fields.zdiv = fpu->environ.control.zdiv;
sfpc.u.fields.denorm = fpu->environ.control.denorm;
sfpc.u.fields.invalid = fpu->environ.control.invalid;
sfpc.u.half = NXSwapShort(sfpc.u.half);
memcpy(&(fpu->environ.control), &sfpc,
sizeof(struct swapped_fp_control));
sfps.u.fields.busy = fpu->environ.status.busy;
sfps.u.fields.c3 = fpu->environ.status.c3;
sfps.u.fields.tos = fpu->environ.status.tos;
sfps.u.fields.c2 = fpu->environ.status.c2;
sfps.u.fields.c1 = fpu->environ.status.c1;
sfps.u.fields.c0 = fpu->environ.status.c0;
sfps.u.fields.errsumm = fpu->environ.status.errsumm;
sfps.u.fields.stkflt = fpu->environ.status.stkflt;
sfps.u.fields.precis = fpu->environ.status.precis;
sfps.u.fields.undfl = fpu->environ.status.undfl;
sfps.u.fields.ovrfl = fpu->environ.status.ovrfl;
sfps.u.fields.zdiv = fpu->environ.status.zdiv;
sfps.u.fields.denorm = fpu->environ.status.denorm;
sfps.u.fields.invalid = fpu->environ.status.invalid;
sfps.u.half = NXSwapShort(sfps.u.half);
memcpy(&(fpu->environ.status), &sfps,
sizeof(struct swapped_fp_status));
sfpt.u.fields.tag7 = fpu->environ.tag.tag7;
sfpt.u.fields.tag6 = fpu->environ.tag.tag6;
sfpt.u.fields.tag5 = fpu->environ.tag.tag5;
sfpt.u.fields.tag4 = fpu->environ.tag.tag4;
sfpt.u.fields.tag3 = fpu->environ.tag.tag3;
sfpt.u.fields.tag2 = fpu->environ.tag.tag2;
sfpt.u.fields.tag1 = fpu->environ.tag.tag1;
sfpt.u.fields.tag0 = fpu->environ.tag.tag0;
sfpt.u.half = NXSwapShort(sfpt.u.half);
memcpy(&(fpu->environ.tag), &sfpt,
sizeof(struct swapped_fp_tag));
ss.u.fields.index = fpu->environ.cs.index;
ss.u.fields.ti = fpu->environ.cs.ti;
ss.u.fields.rpl = fpu->environ.cs.rpl;
ss.u.half = NXSwapShort(ss.u.half);
memcpy(&(fpu->environ.cs), &ss,
sizeof(struct swapped_sel));
ss.u.fields.index = fpu->environ.ds.index;
ss.u.fields.ti = fpu->environ.ds.ti;
ss.u.fields.rpl = fpu->environ.ds.rpl;
ss.u.half = NXSwapShort(ss.u.half);
memcpy(&(fpu->environ.cs), &ss,
sizeof(struct swapped_sel));
for(i = 0; i < 8; i++) {
sfpd.mant = NXSwapShort(fpu->stack.ST[i].mant);
sfpd.mant1 = NXSwapShort(fpu->stack.ST[i].mant1);
sfpd.mant2 = NXSwapShort(fpu->stack.ST[i].mant2);
sfpd.mant3 = NXSwapShort(fpu->stack.ST[i].mant3);
sfpd.u.fields.exp = fpu->stack.ST[i].exp;
sfpd.u.fields.sign = fpu->stack.ST[i].sign;
sfpd.u.half = NXSwapShort(sfpd.u.half);
memcpy(&(fpu->stack.ST[i]), &sfpd,
sizeof(struct swapped_fp_data_reg));
}
}
}
void
swap_i386_float_state(
struct i386_float_state *fpu,
enum NXByteOrder target_byte_sex)
{
#ifndef i386_EXCEPTION_STATE_COUNT
/* this routine does nothing as their are currently no non-byte fields */
#else /* !defined(i386_EXCEPTION_STATE_COUNT) */
struct swapped_fp_control {
union {
struct {
unsigned short
:3,
/*inf*/ :1,
rc :2,
pc :2,
:2,
precis :1,
undfl :1,
ovrfl :1,
zdiv :1,
denorm :1,
invalid :1;
} fields;
unsigned short half;
} u;
} sfpc;
struct swapped_fp_status {
union {
struct {
unsigned short
busy :1,
c3 :1,
tos :3,
c2 :1,
c1 :1,
c0 :1,
errsumm :1,
stkflt :1,
precis :1,
undfl :1,
ovrfl :1,
zdiv :1,
denorm :1,
invalid :1;
} fields;
unsigned short half;
} u;
} sfps;
enum NXByteOrder host_byte_sex;
host_byte_sex = NXHostByteOrder();
fpu->fpu_reserved[0] = NXSwapLong(fpu->fpu_reserved[0]);
fpu->fpu_reserved[1] = NXSwapLong(fpu->fpu_reserved[1]);
if(target_byte_sex == host_byte_sex) {
memcpy(&sfpc, &(fpu->fpu_fcw),
sizeof(struct swapped_fp_control));
sfpc.u.half = NXSwapShort(sfpc.u.half);
fpu->fpu_fcw.rc = sfpc.u.fields.rc;
fpu->fpu_fcw.pc = sfpc.u.fields.pc;
fpu->fpu_fcw.precis = sfpc.u.fields.precis;
fpu->fpu_fcw.undfl = sfpc.u.fields.undfl;
fpu->fpu_fcw.ovrfl = sfpc.u.fields.ovrfl;
fpu->fpu_fcw.zdiv = sfpc.u.fields.zdiv;
fpu->fpu_fcw.denorm = sfpc.u.fields.denorm;
fpu->fpu_fcw.invalid = sfpc.u.fields.invalid;
memcpy(&sfps, &(fpu->fpu_fsw),
sizeof(struct swapped_fp_status));
sfps.u.half = NXSwapShort(sfps.u.half);
fpu->fpu_fsw.busy = sfps.u.fields.busy;
fpu->fpu_fsw.c3 = sfps.u.fields.c3;
fpu->fpu_fsw.tos = sfps.u.fields.tos;
fpu->fpu_fsw.c2 = sfps.u.fields.c2;
fpu->fpu_fsw.c1 = sfps.u.fields.c1;
fpu->fpu_fsw.c0 = sfps.u.fields.c0;
fpu->fpu_fsw.errsumm = sfps.u.fields.errsumm;
fpu->fpu_fsw.stkflt = sfps.u.fields.stkflt;
fpu->fpu_fsw.precis = sfps.u.fields.precis;
fpu->fpu_fsw.undfl = sfps.u.fields.undfl;
fpu->fpu_fsw.ovrfl = sfps.u.fields.ovrfl;
fpu->fpu_fsw.zdiv = sfps.u.fields.zdiv;
fpu->fpu_fsw.denorm = sfps.u.fields.denorm;
fpu->fpu_fsw.invalid = sfps.u.fields.invalid;
}
else {
sfpc.u.fields.rc = fpu->fpu_fcw.rc;
sfpc.u.fields.pc = fpu->fpu_fcw.pc;
sfpc.u.fields.precis = fpu->fpu_fcw.precis;
sfpc.u.fields.undfl = fpu->fpu_fcw.undfl;
sfpc.u.fields.ovrfl = fpu->fpu_fcw.ovrfl;
sfpc.u.fields.zdiv = fpu->fpu_fcw.zdiv;
sfpc.u.fields.denorm = fpu->fpu_fcw.denorm;
sfpc.u.fields.invalid = fpu->fpu_fcw.invalid;
sfpc.u.half = NXSwapShort(sfpc.u.half);
memcpy(&(fpu->fpu_fcw), &sfpc,
sizeof(struct swapped_fp_control));
sfps.u.fields.busy = fpu->fpu_fsw.busy;
sfps.u.fields.c3 = fpu->fpu_fsw.c3;
sfps.u.fields.tos = fpu->fpu_fsw.tos;
sfps.u.fields.c2 = fpu->fpu_fsw.c2;
sfps.u.fields.c1 = fpu->fpu_fsw.c1;
sfps.u.fields.c0 = fpu->fpu_fsw.c0;
sfps.u.fields.errsumm = fpu->fpu_fsw.errsumm;
sfps.u.fields.stkflt = fpu->fpu_fsw.stkflt;
sfps.u.fields.precis = fpu->fpu_fsw.precis;
sfps.u.fields.undfl = fpu->fpu_fsw.undfl;
sfps.u.fields.ovrfl = fpu->fpu_fsw.ovrfl;
sfps.u.fields.zdiv = fpu->fpu_fsw.zdiv;
sfps.u.fields.denorm = fpu->fpu_fsw.denorm;
sfps.u.fields.invalid = fpu->fpu_fsw.invalid;
sfps.u.half = NXSwapShort(sfps.u.half);
memcpy(&(fpu->fpu_fsw), &sfps,
sizeof(struct swapped_fp_status));
}
fpu->fpu_fop = NXSwapShort(fpu->fpu_fop);
fpu->fpu_ip = NXSwapLong(fpu->fpu_ip);
fpu->fpu_cs = NXSwapShort(fpu->fpu_cs);
fpu->fpu_rsrv2 = NXSwapShort(fpu->fpu_rsrv2);
fpu->fpu_dp = NXSwapLong(fpu->fpu_dp);
fpu->fpu_ds = NXSwapShort(fpu->fpu_ds);
fpu->fpu_rsrv3 = NXSwapShort(fpu->fpu_rsrv3);
fpu->fpu_mxcsr = NXSwapLong(fpu->fpu_mxcsr);
fpu->fpu_mxcsrmask = NXSwapLong(fpu->fpu_mxcsrmask);
fpu->fpu_reserved1 = NXSwapLong(fpu->fpu_reserved1);
#endif /* !defined(i386_EXCEPTION_STATE_COUNT) */
}