********************************************************************/
/*
-* RULES FOR HANDLING REGISTERS:
-*
-* * In the function headers, order the parameters
-* - 1st registers written to
-* - 2nd read/modify/write registers
-* - 3rd registers read from
-* * Before calling raw_*, you must call readreg, writereg or rmw for
-* each register
-* * The order for this is
-* - 1st call remove_offset for all registers written to with size<4
-* - 2nd call readreg for all registers read without offset
-* - 3rd call rmw for all rmw registers
-* - 4th call readreg_offset for all registers that can handle offsets
-* - 5th call get_offset for all the registers from the previous step
-* - 6th call writereg for all written-to registers
-* - 7th call raw_*
-* - 8th unlock all registers that were locked
-*/
+ * RULES FOR HANDLING REGISTERS:
+ *
+ * * In the function headers, order the parameters
+ * - 1st registers written to
+ * - 2nd read/modify/write registers
+ * - 3rd registers read from
+ * * Before calling raw_*, you must call readreg, writereg or rmw for
+ * each register
+ * * The order for this is
+ * - 1st call remove_offset for all registers written to with size<4
+ * - 2nd call readreg for all registers read without offset
+ * - 3rd call rmw for all rmw registers
+ * - 4th call readreg_offset for all registers that can handle offsets
+ * - 5th call get_offset for all the registers from the previous step
+ * - 6th call writereg for all written-to registers
+ * - 7th call raw_*
+ * - 8th unlock all registers that were locked
+ */
MIDFUNC(0,live_flags,(void))
{
}
MENDFUNC(0,live_flags,(void))
- MIDFUNC(0,dont_care_flags,(void))
+MIDFUNC(0,dont_care_flags,(void))
{
live.flags_are_important=0;
}
MENDFUNC(0,dont_care_flags,(void))
-
- /*
- * Copy m68k C flag into m68k X flag
- *
- * FIXME: This needs to be moved into the machdep
- * part of the source because it depends on what bit
- * is used to hold X.
- */
- MIDFUNC(0,duplicate_carry,(void))
+/*
+ * Copy m68k C flag into m68k X flag
+ *
+ * FIXME: This needs to be moved into the machdep
+ * part of the source because it depends on what bit
+ * is used to hold X.
+ */
+MIDFUNC(0,duplicate_carry,(void))
{
evict(FLAGX);
make_flags_live_internal();
}
MENDFUNC(0,duplicate_carry,(void))
- /*
- * Set host C flag from m68k X flag.
- *
- * FIXME: This needs to be moved into the machdep
- * part of the source because it depends on what bit
- * is used to hold X.
- */
- MIDFUNC(0,restore_carry,(void))
+/*
+ * Set host C flag from m68k X flag.
+ *
+ * FIXME: This needs to be moved into the machdep
+ * part of the source because it depends on what bit
+ * is used to hold X.
+ */
+MIDFUNC(0,restore_carry,(void))
{
if (!have_rat_stall) { /* Not a P6 core, i.e. no partial stalls */
bt_l_ri_noclobber(FLAGX, 8);
}
MENDFUNC(0,restore_carry,(void))
- MIDFUNC(0,start_needflags,(void))
+MIDFUNC(0,start_needflags,(void))
{
needflags=1;
}
MENDFUNC(0,start_needflags,(void))
- MIDFUNC(0,end_needflags,(void))
+MIDFUNC(0,end_needflags,(void))
{
needflags=0;
}
MENDFUNC(0,end_needflags,(void))
- MIDFUNC(0,make_flags_live,(void))
+MIDFUNC(0,make_flags_live,(void))
{
make_flags_live_internal();
}
MENDFUNC(0,make_flags_live,(void))
- MIDFUNC(1,fflags_into_flags,(W2 tmp))
+MIDFUNC(1,fflags_into_flags,(W2 tmp))
{
clobber_flags();
fflags_into_flags_internal(tmp);
}
MENDFUNC(1,fflags_into_flags,(W2 tmp))
-
- MIDFUNC(2,bt_l_ri,(R4 r, IMM i)) /* This is defined as only affecting C */
+MIDFUNC(2,bt_l_ri,(R4 r, IMM i)) /* This is defined as only affecting C */
{
int size=4;
if (i<16)
}
MENDFUNC(2,bt_l_ri,(R4 r, IMM i)) /* This is defined as only affecting C */
- MIDFUNC(2,bt_l_rr,(R4 r, R4 b)) /* This is defined as only affecting C */
+MIDFUNC(2,bt_l_rr,(R4 r, R4 b)) /* This is defined as only affecting C */
{
CLOBBER_BT;
r=readreg(r,4);
}
MENDFUNC(2,bt_l_rr,(R4 r, R4 b)) /* This is defined as only affecting C */
- MIDFUNC(2,btc_l_ri,(RW4 r, IMM i))
+MIDFUNC(2,btc_l_ri,(RW4 r, IMM i))
{
int size=4;
if (i<16)
}
MENDFUNC(2,btc_l_ri,(RW4 r, IMM i))
- MIDFUNC(2,btc_l_rr,(RW4 r, R4 b))
+MIDFUNC(2,btc_l_rr,(RW4 r, R4 b))
{
CLOBBER_BT;
b=readreg(b,4);
}
MENDFUNC(2,btc_l_rr,(RW4 r, R4 b))
-
- MIDFUNC(2,btr_l_ri,(RW4 r, IMM i))
+MIDFUNC(2,btr_l_ri,(RW4 r, IMM i))
{
int size=4;
if (i<16)
}
MENDFUNC(2,btr_l_ri,(RW4 r, IMM i))
- MIDFUNC(2,btr_l_rr,(RW4 r, R4 b))
+MIDFUNC(2,btr_l_rr,(RW4 r, R4 b))
{
CLOBBER_BT;
b=readreg(b,4);
}
MENDFUNC(2,btr_l_rr,(RW4 r, R4 b))
-
- MIDFUNC(2,bts_l_ri,(RW4 r, IMM i))
+MIDFUNC(2,bts_l_ri,(RW4 r, IMM i))
{
int size=4;
if (i<16)
}
MENDFUNC(2,bts_l_ri,(RW4 r, IMM i))
- MIDFUNC(2,bts_l_rr,(RW4 r, R4 b))
+MIDFUNC(2,bts_l_rr,(RW4 r, R4 b))
{
CLOBBER_BT;
b=readreg(b,4);
}
MENDFUNC(2,bts_l_rr,(RW4 r, R4 b))
- MIDFUNC(2,mov_l_rm,(W4 d, IMM s))
+MIDFUNC(2,mov_l_rm,(W4 d, IMM s))
{
CLOBBER_MOV;
d=writereg(d,4);
}
MENDFUNC(2,mov_l_rm,(W4 d, IMM s))
-
- MIDFUNC(1,call_r,(R4 r)) /* Clobbering is implicit */
+MIDFUNC(1,call_r,(R4 r)) /* Clobbering is implicit */
{
r=readreg(r,4);
raw_call_r(r);
}
MENDFUNC(1,call_r,(R4 r)) /* Clobbering is implicit */
- MIDFUNC(2,sub_l_mi,(IMM d, IMM s))
+MIDFUNC(2,sub_l_mi,(IMM d, IMM s))
{
CLOBBER_SUB;
raw_sub_l_mi(d,s) ;
}
MENDFUNC(2,sub_l_mi,(IMM d, IMM s))
- MIDFUNC(2,mov_l_mi,(IMM d, IMM s))
+MIDFUNC(2,mov_l_mi,(IMM d, IMM s))
{
CLOBBER_MOV;
raw_mov_l_mi(d,s) ;
}
MENDFUNC(2,mov_l_mi,(IMM d, IMM s))
- MIDFUNC(2,mov_w_mi,(IMM d, IMM s))
+MIDFUNC(2,mov_w_mi,(IMM d, IMM s))
{
CLOBBER_MOV;
raw_mov_w_mi(d,s) ;
}
MENDFUNC(2,mov_w_mi,(IMM d, IMM s))
- MIDFUNC(2,mov_b_mi,(IMM d, IMM s))
+MIDFUNC(2,mov_b_mi,(IMM d, IMM s))
{
CLOBBER_MOV;
raw_mov_b_mi(d,s) ;
}
MENDFUNC(2,mov_b_mi,(IMM d, IMM s))
- MIDFUNC(2,rol_b_ri,(RW1 r, IMM i))
+MIDFUNC(2,rol_b_ri,(RW1 r, IMM i))
{
if (!i && !needflags)
return;
}
MENDFUNC(2,rol_b_ri,(RW1 r, IMM i))
- MIDFUNC(2,rol_w_ri,(RW2 r, IMM i))
+MIDFUNC(2,rol_w_ri,(RW2 r, IMM i))
{
if (!i && !needflags)
return;
}
MENDFUNC(2,rol_w_ri,(RW2 r, IMM i))
- MIDFUNC(2,rol_l_ri,(RW4 r, IMM i))
+MIDFUNC(2,rol_l_ri,(RW4 r, IMM i))
{
if (!i && !needflags)
return;
}
MENDFUNC(2,rol_l_ri,(RW4 r, IMM i))
- MIDFUNC(2,rol_l_rr,(RW4 d, R1 r))
+MIDFUNC(2,rol_l_rr,(RW4 d, R1 r))
{
if (isconst(r)) {
COMPCALL(rol_l_ri)(d,(uae_u8)live.state[r].val);
}
MENDFUNC(2,rol_l_rr,(RW4 d, R1 r))
- MIDFUNC(2,rol_w_rr,(RW2 d, R1 r))
+MIDFUNC(2,rol_w_rr,(RW2 d, R1 r))
{ /* Can only do this with r==1, i.e. cl */
if (isconst(r)) {
}
MENDFUNC(2,rol_w_rr,(RW2 d, R1 r))
- MIDFUNC(2,rol_b_rr,(RW1 d, R1 r))
+MIDFUNC(2,rol_b_rr,(RW1 d, R1 r))
{ /* Can only do this with r==1, i.e. cl */
if (isconst(r)) {
}
MENDFUNC(2,rol_b_rr,(RW1 d, R1 r))
-
- MIDFUNC(2,shll_l_rr,(RW4 d, R1 r))
+MIDFUNC(2,shll_l_rr,(RW4 d, R1 r))
{
if (isconst(r)) {
COMPCALL(shll_l_ri)(d,(uae_u8)live.state[r].val);
}
MENDFUNC(2,shll_l_rr,(RW4 d, R1 r))
- MIDFUNC(2,shll_w_rr,(RW2 d, R1 r))
+MIDFUNC(2,shll_w_rr,(RW2 d, R1 r))
{ /* Can only do this with r==1, i.e. cl */
if (isconst(r)) {
}
MENDFUNC(2,shll_w_rr,(RW2 d, R1 r))
- MIDFUNC(2,shll_b_rr,(RW1 d, R1 r))
+MIDFUNC(2,shll_b_rr,(RW1 d, R1 r))
{ /* Can only do this with r==1, i.e. cl */
if (isconst(r)) {
}
MENDFUNC(2,shll_b_rr,(RW1 d, R1 r))
-
- MIDFUNC(2,ror_b_ri,(R1 r, IMM i))
+MIDFUNC(2,ror_b_ri,(R1 r, IMM i))
{
if (!i && !needflags)
return;
}
MENDFUNC(2,ror_b_ri,(R1 r, IMM i))
- MIDFUNC(2,ror_w_ri,(R2 r, IMM i))
+MIDFUNC(2,ror_w_ri,(R2 r, IMM i))
{
if (!i && !needflags)
return;
}
MENDFUNC(2,ror_w_ri,(R2 r, IMM i))
- MIDFUNC(2,ror_l_ri,(R4 r, IMM i))
+MIDFUNC(2,ror_l_ri,(R4 r, IMM i))
{
if (!i && !needflags)
return;
}
MENDFUNC(2,ror_l_ri,(R4 r, IMM i))
- MIDFUNC(2,ror_l_rr,(R4 d, R1 r))
+MIDFUNC(2,ror_l_rr,(R4 d, R1 r))
{
if (isconst(r)) {
COMPCALL(ror_l_ri)(d,(uae_u8)live.state[r].val);
}
MENDFUNC(2,ror_l_rr,(R4 d, R1 r))
- MIDFUNC(2,ror_w_rr,(R2 d, R1 r))
+MIDFUNC(2,ror_w_rr,(R2 d, R1 r))
{
if (isconst(r)) {
COMPCALL(ror_w_ri)(d,(uae_u8)live.state[r].val);
}
MENDFUNC(2,ror_w_rr,(R2 d, R1 r))
- MIDFUNC(2,ror_b_rr,(R1 d, R1 r))
+MIDFUNC(2,ror_b_rr,(R1 d, R1 r))
{
if (isconst(r)) {
COMPCALL(ror_b_ri)(d,(uae_u8)live.state[r].val);
}
MENDFUNC(2,ror_b_rr,(R1 d, R1 r))
- MIDFUNC(2,shrl_l_rr,(RW4 d, R1 r))
+MIDFUNC(2,shrl_l_rr,(RW4 d, R1 r))
{
if (isconst(r)) {
COMPCALL(shrl_l_ri)(d,(uae_u8)live.state[r].val);
}
MENDFUNC(2,shrl_l_rr,(RW4 d, R1 r))
- MIDFUNC(2,shrl_w_rr,(RW2 d, R1 r))
+MIDFUNC(2,shrl_w_rr,(RW2 d, R1 r))
{ /* Can only do this with r==1, i.e. cl */
if (isconst(r)) {
}
MENDFUNC(2,shrl_w_rr,(RW2 d, R1 r))
- MIDFUNC(2,shrl_b_rr,(RW1 d, R1 r))
+MIDFUNC(2,shrl_b_rr,(RW1 d, R1 r))
{ /* Can only do this with r==1, i.e. cl */
if (isconst(r)) {
}
MENDFUNC(2,shrl_b_rr,(RW1 d, R1 r))
- MIDFUNC(2,shll_l_ri,(RW4 r, IMM i))
+MIDFUNC(2,shll_l_ri,(RW4 r, IMM i))
{
if (!i && !needflags)
return;
}
MENDFUNC(2,shll_l_ri,(RW4 r, IMM i))
- MIDFUNC(2,shll_w_ri,(RW2 r, IMM i))
+MIDFUNC(2,shll_w_ri,(RW2 r, IMM i))
{
if (!i && !needflags)
return;
}
MENDFUNC(2,shll_w_ri,(RW2 r, IMM i))
- MIDFUNC(2,shll_b_ri,(RW1 r, IMM i))
+MIDFUNC(2,shll_b_ri,(RW1 r, IMM i))
{
if (!i && !needflags)
return;
}
MENDFUNC(2,shll_b_ri,(RW1 r, IMM i))
- MIDFUNC(2,shrl_l_ri,(RW4 r, IMM i))
+MIDFUNC(2,shrl_l_ri,(RW4 r, IMM i))
{
if (!i && !needflags)
return;
}
MENDFUNC(2,shrl_l_ri,(RW4 r, IMM i))
- MIDFUNC(2,shrl_w_ri,(RW2 r, IMM i))
+MIDFUNC(2,shrl_w_ri,(RW2 r, IMM i))
{
if (!i && !needflags)
return;
}
MENDFUNC(2,shrl_w_ri,(RW2 r, IMM i))
- MIDFUNC(2,shrl_b_ri,(RW1 r, IMM i))
+MIDFUNC(2,shrl_b_ri,(RW1 r, IMM i))
{
if (!i && !needflags)
return;
}
MENDFUNC(2,shrl_b_ri,(RW1 r, IMM i))
- MIDFUNC(2,shra_l_ri,(RW4 r, IMM i))
+MIDFUNC(2,shra_l_ri,(RW4 r, IMM i))
{
if (!i && !needflags)
return;
}
MENDFUNC(2,shra_l_ri,(RW4 r, IMM i))
- MIDFUNC(2,shra_w_ri,(RW2 r, IMM i))
+MIDFUNC(2,shra_w_ri,(RW2 r, IMM i))
{
if (!i && !needflags)
return;
}
MENDFUNC(2,shra_w_ri,(RW2 r, IMM i))
- MIDFUNC(2,shra_b_ri,(RW1 r, IMM i))
+MIDFUNC(2,shra_b_ri,(RW1 r, IMM i))
{
if (!i && !needflags)
return;
}
MENDFUNC(2,shra_b_ri,(RW1 r, IMM i))
- MIDFUNC(2,shra_l_rr,(RW4 d, R1 r))
+MIDFUNC(2,shra_l_rr,(RW4 d, R1 r))
{
if (isconst(r)) {
COMPCALL(shra_l_ri)(d,(uae_u8)live.state[r].val);
}
MENDFUNC(2,shra_l_rr,(RW4 d, R1 r))
- MIDFUNC(2,shra_w_rr,(RW2 d, R1 r))
+MIDFUNC(2,shra_w_rr,(RW2 d, R1 r))
{ /* Can only do this with r==1, i.e. cl */
if (isconst(r)) {
}
MENDFUNC(2,shra_w_rr,(RW2 d, R1 r))
- MIDFUNC(2,shra_b_rr,(RW1 d, R1 r))
+MIDFUNC(2,shra_b_rr,(RW1 d, R1 r))
{ /* Can only do this with r==1, i.e. cl */
if (isconst(r)) {
}
MENDFUNC(2,shra_b_rr,(RW1 d, R1 r))
- MIDFUNC(2,setcc,(W1 d, IMM cc))
+MIDFUNC(2,setcc,(W1 d, IMM cc))
{
CLOBBER_SETCC;
d=writereg(d,1);
}
MENDFUNC(2,setcc,(W1 d, IMM cc))
- MIDFUNC(2,setcc_m,(IMM d, IMM cc))
+MIDFUNC(2,setcc_m,(IMM d, IMM cc))
{
CLOBBER_SETCC;
raw_setcc_m(d,cc);
}
MENDFUNC(2,setcc_m,(IMM d, IMM cc))
- MIDFUNC(3,cmov_b_rr,(RW1 d, R1 s, IMM cc))
+MIDFUNC(3,cmov_b_rr,(RW1 d, R1 s, IMM cc))
{
if (d==s)
return;
}
MENDFUNC(3,cmov_b_rr,(RW1 d, R1 s, IMM cc))
- MIDFUNC(3,cmov_w_rr,(RW2 d, R2 s, IMM cc))
+MIDFUNC(3,cmov_w_rr,(RW2 d, R2 s, IMM cc))
{
if (d==s)
return;
}
MENDFUNC(3,cmov_w_rr,(RW2 d, R2 s, IMM cc))
- MIDFUNC(3,cmov_l_rr,(RW4 d, R4 s, IMM cc))
+MIDFUNC(3,cmov_l_rr,(RW4 d, R4 s, IMM cc))
{
if (d==s)
return;
}
MENDFUNC(3,cmov_l_rr,(RW4 d, R4 s, IMM cc))
- MIDFUNC(1,setzflg_l,(RW4 r))
+MIDFUNC(1,setzflg_l,(RW4 r))
{
if (setzflg_uses_bsf) {
CLOBBER_BSF;
}
MENDFUNC(1,setzflg_l,(RW4 r))
- MIDFUNC(3,cmov_l_rm,(RW4 d, IMM s, IMM cc))
+MIDFUNC(3,cmov_l_rm,(RW4 d, IMM s, IMM cc))
{
CLOBBER_CMOV;
d=rmw(d,4,4);
}
MENDFUNC(3,cmov_l_rm,(RW4 d, IMM s, IMM cc))
- MIDFUNC(2,bsf_l_rr,(W4 d, R4 s))
+MIDFUNC(2,bsf_l_rr,(W4 d, R4 s))
{
CLOBBER_BSF;
s=readreg(s,4);
}
MENDFUNC(2,bsf_l_rr,(W4 d, R4 s))
- MIDFUNC(2,imul_32_32,(RW4 d, R4 s))
+MIDFUNC(2,imul_32_32,(RW4 d, R4 s))
{
CLOBBER_MUL;
s=readreg(s,4);
}
MENDFUNC(2,imul_32_32,(RW4 d, R4 s))
- MIDFUNC(2,imul_64_32,(RW4 d, RW4 s))
+MIDFUNC(2,imul_64_32,(RW4 d, RW4 s))
{
CLOBBER_MUL;
s=rmw_specific(s,4,4,MUL_NREG2);
}
MENDFUNC(2,imul_64_32,(RW4 d, RW4 s))
- MIDFUNC(2,mul_64_32,(RW4 d, RW4 s))
+MIDFUNC(2,mul_64_32,(RW4 d, RW4 s))
{
CLOBBER_MUL;
s=rmw_specific(s,4,4,MUL_NREG2);
}
MENDFUNC(2,mul_64_32,(RW4 d, RW4 s))
- MIDFUNC(2,sign_extend_16_rr,(W4 d, R2 s))
+MIDFUNC(2,sign_extend_16_rr,(W4 d, R2 s))
{
int isrmw;
}
MENDFUNC(2,sign_extend_16_rr,(W4 d, R2 s))
- MIDFUNC(2,sign_extend_8_rr,(W4 d, R1 s))
+MIDFUNC(2,sign_extend_8_rr,(W4 d, R1 s))
{
int isrmw;
}
MENDFUNC(2,sign_extend_8_rr,(W4 d, R1 s))
- MIDFUNC(2,zero_extend_16_rr,(W4 d, R2 s))
+MIDFUNC(2,zero_extend_16_rr,(W4 d, R2 s))
{
int isrmw;
}
MENDFUNC(2,zero_extend_16_rr,(W4 d, R2 s))
- MIDFUNC(2,zero_extend_8_rr,(W4 d, R1 s))
+MIDFUNC(2,zero_extend_8_rr,(W4 d, R1 s))
{
int isrmw;
if (isconst(s)) {
}
MENDFUNC(2,zero_extend_8_rr,(W4 d, R1 s))
- MIDFUNC(2,mov_b_rr,(W1 d, R1 s))
+MIDFUNC(2,mov_b_rr,(W1 d, R1 s))
{
if (d==s)
return;
}
MENDFUNC(2,mov_b_rr,(W1 d, R1 s))
- MIDFUNC(2,mov_w_rr,(W2 d, R2 s))
+MIDFUNC(2,mov_w_rr,(W2 d, R2 s))
{
if (d==s)
return;
}
MENDFUNC(2,mov_w_rr,(W2 d, R2 s))
- MIDFUNC(3,mov_l_rrm_indexed,(W4 d,R4 baser, R4 index))
+MIDFUNC(3,mov_l_rrm_indexed,(W4 d,R4 baser, R4 index))
{
CLOBBER_MOV;
baser=readreg(baser,4);
}
MENDFUNC(3,mov_l_rrm_indexed,(W4 d,R4 baser, R4 index))
- MIDFUNC(3,mov_w_rrm_indexed,(W2 d, R4 baser, R4 index))
+MIDFUNC(3,mov_w_rrm_indexed,(W2 d, R4 baser, R4 index))
{
CLOBBER_MOV;
baser=readreg(baser,4);
}
MENDFUNC(3,mov_w_rrm_indexed,(W2 d, R4 baser, R4 index))
- MIDFUNC(3,mov_b_rrm_indexed,(W1 d, R4 baser, R4 index))
+MIDFUNC(3,mov_b_rrm_indexed,(W1 d, R4 baser, R4 index))
{
CLOBBER_MOV;
baser=readreg(baser,4);
}
MENDFUNC(3,mov_b_rrm_indexed,(W1 d, R4 baser, R4 index))
- MIDFUNC(3,mov_l_mrr_indexed,(R4 baser, R4 index, R4 s))
+MIDFUNC(3,mov_l_mrr_indexed,(R4 baser, R4 index, R4 s))
{
CLOBBER_MOV;
baser=readreg(baser,4);
}
MENDFUNC(3,mov_l_mrr_indexed,(R4 baser, R4 index, R4 s))
- MIDFUNC(3,mov_w_mrr_indexed,(R4 baser, R4 index, R2 s))
+MIDFUNC(3,mov_w_mrr_indexed,(R4 baser, R4 index, R2 s))
{
CLOBBER_MOV;
baser=readreg(baser,4);
}
MENDFUNC(3,mov_w_mrr_indexed,(R4 baser, R4 index, R2 s))
- MIDFUNC(3,mov_b_mrr_indexed,(R4 baser, R4 index, R1 s))
+MIDFUNC(3,mov_b_mrr_indexed,(R4 baser, R4 index, R1 s))
{
CLOBBER_MOV;
s=readreg(s,1);
}
MENDFUNC(3,mov_b_mrr_indexed,(R4 baser, R4 index, R1 s))
- /* Read a long from base+4*index */
- MIDFUNC(3,mov_l_rm_indexed,(W4 d, IMM base, R4 index))
+/* Read a long from base+4*index */
+MIDFUNC(3,mov_l_rm_indexed,(W4 d, IMM base, R4 index))
{
int indexreg=index;
}
MENDFUNC(3,mov_l_rm_indexed,(W4 d, IMM base, R4 index))
- /* read the long at the address contained in s+offset and store in d */
- MIDFUNC(3,mov_l_rR,(W4 d, R4 s, IMM offset))
+/* read the long at the address contained in s+offset and store in d */
+MIDFUNC(3,mov_l_rR,(W4 d, R4 s, IMM offset))
{
if (isconst(s)) {
COMPCALL(mov_l_rm)(d,live.state[s].val+offset);
}
MENDFUNC(3,mov_l_rR,(W4 d, R4 s, IMM offset))
- /* read the word at the address contained in s+offset and store in d */
- MIDFUNC(3,mov_w_rR,(W2 d, R4 s, IMM offset))
+/* read the word at the address contained in s+offset and store in d */
+MIDFUNC(3,mov_w_rR,(W2 d, R4 s, IMM offset))
{
if (isconst(s)) {
COMPCALL(mov_w_rm)(d,live.state[s].val+offset);
}
MENDFUNC(3,mov_w_rR,(W2 d, R4 s, IMM offset))
- /* read the word at the address contained in s+offset and store in d */
- MIDFUNC(3,mov_b_rR,(W1 d, R4 s, IMM offset))
+/* read the word at the address contained in s+offset and store in d */
+MIDFUNC(3,mov_b_rR,(W1 d, R4 s, IMM offset))
{
if (isconst(s)) {
COMPCALL(mov_b_rm)(d,live.state[s].val+offset);
}
MENDFUNC(3,mov_b_rR,(W1 d, R4 s, IMM offset))
- /* read the long at the address contained in s+offset and store in d */
- MIDFUNC(3,mov_l_brR,(W4 d, R4 s, IMM offset))
+/* read the long at the address contained in s+offset and store in d */
+MIDFUNC(3,mov_l_brR,(W4 d, R4 s, IMM offset))
{
int sreg=s;
if (isconst(s)) {
}
MENDFUNC(3,mov_l_brR,(W4 d, R4 s, IMM offset))
- /* read the word at the address contained in s+offset and store in d */
- MIDFUNC(3,mov_w_brR,(W2 d, R4 s, IMM offset))
+/* read the word at the address contained in s+offset and store in d */
+MIDFUNC(3,mov_w_brR,(W2 d, R4 s, IMM offset))
{
int sreg=s;
if (isconst(s)) {
}
MENDFUNC(3,mov_w_brR,(W2 d, R4 s, IMM offset))
- /* read the word at the address contained in s+offset and store in d */
- MIDFUNC(3,mov_b_brR,(W1 d, R4 s, IMM offset))
+/* read the word at the address contained in s+offset and store in d */
+MIDFUNC(3,mov_b_brR,(W1 d, R4 s, IMM offset))
{
int sreg=s;
if (isconst(s)) {
}
MENDFUNC(3,mov_b_brR,(W1 d, R4 s, IMM offset))
- MIDFUNC(3,mov_l_Ri,(R4 d, IMM i, IMM offset))
+MIDFUNC(3,mov_l_Ri,(R4 d, IMM i, IMM offset))
{
int dreg=d;
if (isconst(d)) {
}
MENDFUNC(3,mov_l_Ri,(R4 d, IMM i, IMM offset))
- MIDFUNC(3,mov_w_Ri,(R4 d, IMM i, IMM offset))
+MIDFUNC(3,mov_w_Ri,(R4 d, IMM i, IMM offset))
{
int dreg=d;
if (isconst(d)) {
}
MENDFUNC(3,mov_w_Ri,(R4 d, IMM i, IMM offset))
- MIDFUNC(3,mov_b_Ri,(R4 d, IMM i, IMM offset))
+MIDFUNC(3,mov_b_Ri,(R4 d, IMM i, IMM offset))
{
int dreg=d;
if (isconst(d)) {
}
MENDFUNC(3,mov_b_Ri,(R4 d, IMM i, IMM offset))
- /* Warning! OFFSET is byte sized only! */
- MIDFUNC(3,mov_l_Rr,(R4 d, R4 s, IMM offset))
+/* Warning! OFFSET is byte sized only! */
+MIDFUNC(3,mov_l_Rr,(R4 d, R4 s, IMM offset))
{
if (isconst(d)) {
COMPCALL(mov_l_mr)(live.state[d].val+offset,s);
}
MENDFUNC(3,mov_l_Rr,(R4 d, R4 s, IMM offset))
- MIDFUNC(3,mov_w_Rr,(R4 d, R2 s, IMM offset))
+MIDFUNC(3,mov_w_Rr,(R4 d, R2 s, IMM offset))
{
if (isconst(d)) {
COMPCALL(mov_w_mr)(live.state[d].val+offset,s);
}
MENDFUNC(3,mov_w_Rr,(R4 d, R2 s, IMM offset))
- MIDFUNC(3,mov_b_Rr,(R4 d, R1 s, IMM offset))
+MIDFUNC(3,mov_b_Rr,(R4 d, R1 s, IMM offset))
{
if (isconst(d)) {
COMPCALL(mov_b_mr)(live.state[d].val+offset,s);
}
MENDFUNC(3,mov_b_Rr,(R4 d, R1 s, IMM offset))
- MIDFUNC(3,lea_l_brr,(W4 d, R4 s, IMM offset))
+MIDFUNC(3,lea_l_brr,(W4 d, R4 s, IMM offset))
{
if (isconst(s)) {
COMPCALL(mov_l_ri)(d,live.state[s].val+offset);
}
MENDFUNC(3,lea_l_brr,(W4 d, R4 s, IMM offset))
- MIDFUNC(5,lea_l_brr_indexed,(W4 d, R4 s, R4 index, IMM factor, IMM offset))
+MIDFUNC(5,lea_l_brr_indexed,(W4 d, R4 s, R4 index, IMM factor, IMM offset))
{
CLOBBER_LEA;
s=readreg(s,4);
}
MENDFUNC(5,lea_l_brr_indexed,(W4 d, R4 s, R4 index, IMM factor, IMM offset))
- /* write d to the long at the address contained in s+offset */
- MIDFUNC(3,mov_l_bRr,(R4 d, R4 s, IMM offset))
+/* write d to the long at the address contained in s+offset */
+MIDFUNC(3,mov_l_bRr,(R4 d, R4 s, IMM offset))
{
int dreg=d;
if (isconst(d)) {
}
MENDFUNC(3,mov_l_bRr,(R4 d, R4 s, IMM offset))
- /* write the word at the address contained in s+offset and store in d */
- MIDFUNC(3,mov_w_bRr,(R4 d, R2 s, IMM offset))
+/* write the word at the address contained in s+offset and store in d */
+MIDFUNC(3,mov_w_bRr,(R4 d, R2 s, IMM offset))
{
int dreg=d;
}
MENDFUNC(3,mov_w_bRr,(R4 d, R2 s, IMM offset))
- MIDFUNC(3,mov_b_bRr,(R4 d, R1 s, IMM offset))
+MIDFUNC(3,mov_b_bRr,(R4 d, R1 s, IMM offset))
{
int dreg=d;
if (isconst(d)) {
}
MENDFUNC(3,mov_b_bRr,(R4 d, R1 s, IMM offset))
- MIDFUNC(1,gen_bswap_32,(RW4 r))
+MIDFUNC(1,gen_bswap_32,(RW4 r))
{
int reg=r;
}
MENDFUNC(1,gen_bswap_32,(RW4 r))
- MIDFUNC(1,gen_bswap_16,(RW2 r))
+MIDFUNC(1,gen_bswap_16,(RW2 r))
{
if (isconst(r)) {
uae_u32 oldv=live.state[r].val;
}
MENDFUNC(1,gen_bswap_16,(RW2 r))
-
-
- MIDFUNC(2,mov_l_rr,(W4 d, R4 s))
+MIDFUNC(2,mov_l_rr,(W4 d, R4 s))
{
int olds;
}
MENDFUNC(2,mov_l_rr,(W4 d, R4 s))
- MIDFUNC(2,mov_l_mr,(IMM d, R4 s))
+MIDFUNC(2,mov_l_mr,(IMM d, R4 s))
{
if (isconst(s)) {
COMPCALL(mov_l_mi)(d,live.state[s].val);
}
MENDFUNC(2,mov_l_mr,(IMM d, R4 s))
-
- MIDFUNC(2,mov_w_mr,(IMM d, R2 s))
+MIDFUNC(2,mov_w_mr,(IMM d, R2 s))
{
if (isconst(s)) {
COMPCALL(mov_w_mi)(d,(uae_u16)live.state[s].val);
}
MENDFUNC(2,mov_w_mr,(IMM d, R2 s))
- MIDFUNC(2,mov_w_rm,(W2 d, IMM s))
+MIDFUNC(2,mov_w_rm,(W2 d, IMM s))
{
CLOBBER_MOV;
d=writereg(d,2);
}
MENDFUNC(2,mov_w_rm,(W2 d, IMM s))
- MIDFUNC(2,mov_b_mr,(IMM d, R1 s))
+MIDFUNC(2,mov_b_mr,(IMM d, R1 s))
{
if (isconst(s)) {
COMPCALL(mov_b_mi)(d,(uae_u8)live.state[s].val);
}
MENDFUNC(2,mov_b_mr,(IMM d, R1 s))
- MIDFUNC(2,mov_b_rm,(W1 d, IMM s))
+MIDFUNC(2,mov_b_rm,(W1 d, IMM s))
{
CLOBBER_MOV;
d=writereg(d,1);
}
MENDFUNC(2,mov_b_rm,(W1 d, IMM s))
- MIDFUNC(2,mov_l_ri,(W4 d, IMM s))
+MIDFUNC(2,mov_l_ri,(W4 d, IMM s))
{
set_const(d,s);
return;
}
MENDFUNC(2,mov_l_ri,(W4 d, IMM s))
- MIDFUNC(2,mov_w_ri,(W2 d, IMM s))
+MIDFUNC(2,mov_w_ri,(W2 d, IMM s))
{
CLOBBER_MOV;
d=writereg(d,2);
}
MENDFUNC(2,mov_w_ri,(W2 d, IMM s))
- MIDFUNC(2,mov_b_ri,(W1 d, IMM s))
+MIDFUNC(2,mov_b_ri,(W1 d, IMM s))
{
CLOBBER_MOV;
d=writereg(d,1);
}
MENDFUNC(2,mov_b_ri,(W1 d, IMM s))
-
- MIDFUNC(2,add_l_mi,(IMM d, IMM s))
+MIDFUNC(2,add_l_mi,(IMM d, IMM s))
{
CLOBBER_ADD;
raw_add_l_mi(d,s) ;
}
MENDFUNC(2,add_l_mi,(IMM d, IMM s))
- MIDFUNC(2,add_w_mi,(IMM d, IMM s))
+MIDFUNC(2,add_w_mi,(IMM d, IMM s))
{
CLOBBER_ADD;
raw_add_w_mi(d,s) ;
}
MENDFUNC(2,add_w_mi,(IMM d, IMM s))
- MIDFUNC(2,add_b_mi,(IMM d, IMM s))
+MIDFUNC(2,add_b_mi,(IMM d, IMM s))
{
CLOBBER_ADD;
raw_add_b_mi(d,s) ;
}
MENDFUNC(2,add_b_mi,(IMM d, IMM s))
-
- MIDFUNC(2,test_l_ri,(R4 d, IMM i))
+MIDFUNC(2,test_l_ri,(R4 d, IMM i))
{
CLOBBER_TEST;
d=readreg(d,4);
}
MENDFUNC(2,test_l_ri,(R4 d, IMM i))
- MIDFUNC(2,test_l_rr,(R4 d, R4 s))
+MIDFUNC(2,test_l_rr,(R4 d, R4 s))
{
CLOBBER_TEST;
d=readreg(d,4);
}
MENDFUNC(2,test_l_rr,(R4 d, R4 s))
- MIDFUNC(2,test_w_rr,(R2 d, R2 s))
+MIDFUNC(2,test_w_rr,(R2 d, R2 s))
{
CLOBBER_TEST;
d=readreg(d,2);
}
MENDFUNC(2,test_w_rr,(R2 d, R2 s))
- MIDFUNC(2,test_b_rr,(R1 d, R1 s))
+MIDFUNC(2,test_b_rr,(R1 d, R1 s))
{
CLOBBER_TEST;
d=readreg(d,1);
}
MENDFUNC(2,test_b_rr,(R1 d, R1 s))
- MIDFUNC(2,and_l_ri,(RW4 d, IMM i))
+MIDFUNC(2,and_l_ri,(RW4 d, IMM i))
{
if (isconst (d) && ! needflags) {
live.state[d].val &= i;
}
MENDFUNC(2,and_l_ri,(RW4 d, IMM i))
- MIDFUNC(2,and_l,(RW4 d, R4 s))
+MIDFUNC(2,and_l,(RW4 d, R4 s))
{
CLOBBER_AND;
s=readreg(s,4);
}
MENDFUNC(2,and_l,(RW4 d, R4 s))
- MIDFUNC(2,and_w,(RW2 d, R2 s))
+MIDFUNC(2,and_w,(RW2 d, R2 s))
{
CLOBBER_AND;
s=readreg(s,2);
}
MENDFUNC(2,and_w,(RW2 d, R2 s))
- MIDFUNC(2,and_b,(RW1 d, R1 s))
+MIDFUNC(2,and_b,(RW1 d, R1 s))
{
CLOBBER_AND;
s=readreg(s,1);
}
MENDFUNC(2,and_b,(RW1 d, R1 s))
- MIDFUNC(2,or_l_ri,(RW4 d, IMM i))
+MIDFUNC(2,or_l_ri,(RW4 d, IMM i))
{
if (isconst(d) && !needflags) {
live.state[d].val|=i;
}
MENDFUNC(2,or_l_ri,(RW4 d, IMM i))
- MIDFUNC(2,or_l,(RW4 d, R4 s))
+MIDFUNC(2,or_l,(RW4 d, R4 s))
{
if (isconst(d) && isconst(s) && !needflags) {
live.state[d].val|=live.state[s].val;
}
MENDFUNC(2,or_l,(RW4 d, R4 s))
- MIDFUNC(2,or_w,(RW2 d, R2 s))
+MIDFUNC(2,or_w,(RW2 d, R2 s))
{
CLOBBER_OR;
s=readreg(s,2);
}
MENDFUNC(2,or_w,(RW2 d, R2 s))
- MIDFUNC(2,or_b,(RW1 d, R1 s))
+MIDFUNC(2,or_b,(RW1 d, R1 s))
{
CLOBBER_OR;
s=readreg(s,1);
}
MENDFUNC(2,or_b,(RW1 d, R1 s))
- MIDFUNC(2,adc_l,(RW4 d, R4 s))
+MIDFUNC(2,adc_l,(RW4 d, R4 s))
{
CLOBBER_ADC;
s=readreg(s,4);
}
MENDFUNC(2,adc_l,(RW4 d, R4 s))
- MIDFUNC(2,adc_w,(RW2 d, R2 s))
+MIDFUNC(2,adc_w,(RW2 d, R2 s))
{
CLOBBER_ADC;
s=readreg(s,2);
}
MENDFUNC(2,adc_w,(RW2 d, R2 s))
- MIDFUNC(2,adc_b,(RW1 d, R1 s))
+MIDFUNC(2,adc_b,(RW1 d, R1 s))
{
CLOBBER_ADC;
s=readreg(s,1);
}
MENDFUNC(2,adc_b,(RW1 d, R1 s))
- MIDFUNC(2,add_l,(RW4 d, R4 s))
+MIDFUNC(2,add_l,(RW4 d, R4 s))
{
if (isconst(s)) {
COMPCALL(add_l_ri)(d,live.state[s].val);
}
MENDFUNC(2,add_l,(RW4 d, R4 s))
- MIDFUNC(2,add_w,(RW2 d, R2 s))
+MIDFUNC(2,add_w,(RW2 d, R2 s))
{
if (isconst(s)) {
COMPCALL(add_w_ri)(d,(uae_u16)live.state[s].val);
}
MENDFUNC(2,add_w,(RW2 d, R2 s))
- MIDFUNC(2,add_b,(RW1 d, R1 s))
+MIDFUNC(2,add_b,(RW1 d, R1 s))
{
if (isconst(s)) {
COMPCALL(add_b_ri)(d,(uae_u8)live.state[s].val);
}
MENDFUNC(2,add_b,(RW1 d, R1 s))
- MIDFUNC(2,sub_l_ri,(RW4 d, IMM i))
+MIDFUNC(2,sub_l_ri,(RW4 d, IMM i))
{
if (!i && !needflags)
return;
}
MENDFUNC(2,sub_l_ri,(RW4 d, IMM i))
- MIDFUNC(2,sub_w_ri,(RW2 d, IMM i))
+MIDFUNC(2,sub_w_ri,(RW2 d, IMM i))
{
if (!i && !needflags)
return;
}
MENDFUNC(2,sub_w_ri,(RW2 d, IMM i))
- MIDFUNC(2,sub_b_ri,(RW1 d, IMM i))
+MIDFUNC(2,sub_b_ri,(RW1 d, IMM i))
{
if (!i && !needflags)
return;
}
MENDFUNC(2,sub_b_ri,(RW1 d, IMM i))
- MIDFUNC(2,add_l_ri,(RW4 d, IMM i))
+MIDFUNC(2,add_l_ri,(RW4 d, IMM i))
{
if (!i && !needflags)
return;
}
MENDFUNC(2,add_l_ri,(RW4 d, IMM i))
- MIDFUNC(2,add_w_ri,(RW2 d, IMM i))
+MIDFUNC(2,add_w_ri,(RW2 d, IMM i))
{
if (!i && !needflags)
return;
}
MENDFUNC(2,add_w_ri,(RW2 d, IMM i))
- MIDFUNC(2,add_b_ri,(RW1 d, IMM i))
+MIDFUNC(2,add_b_ri,(RW1 d, IMM i))
{
if (!i && !needflags)
return;
}
MENDFUNC(2,add_b_ri,(RW1 d, IMM i))
- MIDFUNC(2,sbb_l,(RW4 d, R4 s))
+MIDFUNC(2,sbb_l,(RW4 d, R4 s))
{
CLOBBER_SBB;
s=readreg(s,4);
}
MENDFUNC(2,sbb_l,(RW4 d, R4 s))
- MIDFUNC(2,sbb_w,(RW2 d, R2 s))
+MIDFUNC(2,sbb_w,(RW2 d, R2 s))
{
CLOBBER_SBB;
s=readreg(s,2);
}
MENDFUNC(2,sbb_w,(RW2 d, R2 s))
- MIDFUNC(2,sbb_b,(RW1 d, R1 s))
+MIDFUNC(2,sbb_b,(RW1 d, R1 s))
{
CLOBBER_SBB;
s=readreg(s,1);
}
MENDFUNC(2,sbb_b,(RW1 d, R1 s))
- MIDFUNC(2,sub_l,(RW4 d, R4 s))
+MIDFUNC(2,sub_l,(RW4 d, R4 s))
{
if (isconst(s)) {
COMPCALL(sub_l_ri)(d,live.state[s].val);
}
MENDFUNC(2,sub_l,(RW4 d, R4 s))
- MIDFUNC(2,sub_w,(RW2 d, R2 s))
+MIDFUNC(2,sub_w,(RW2 d, R2 s))
{
if (isconst(s)) {
COMPCALL(sub_w_ri)(d,(uae_u16)live.state[s].val);
}
MENDFUNC(2,sub_w,(RW2 d, R2 s))
- MIDFUNC(2,sub_b,(RW1 d, R1 s))
+MIDFUNC(2,sub_b,(RW1 d, R1 s))
{
if (isconst(s)) {
COMPCALL(sub_b_ri)(d,(uae_u8)live.state[s].val);
}
MENDFUNC(2,sub_b,(RW1 d, R1 s))
- MIDFUNC(2,cmp_l,(R4 d, R4 s))
+MIDFUNC(2,cmp_l,(R4 d, R4 s))
{
CLOBBER_CMP;
s=readreg(s,4);
}
MENDFUNC(2,cmp_l,(R4 d, R4 s))
- MIDFUNC(2,cmp_l_ri,(R4 r, IMM i))
+MIDFUNC(2,cmp_l_ri,(R4 r, IMM i))
{
CLOBBER_CMP;
r=readreg(r,4);
}
MENDFUNC(2,cmp_l_ri,(R4 r, IMM i))
- MIDFUNC(2,cmp_w,(R2 d, R2 s))
+MIDFUNC(2,cmp_w,(R2 d, R2 s))
{
CLOBBER_CMP;
s=readreg(s,2);
}
MENDFUNC(2,cmp_w,(R2 d, R2 s))
- MIDFUNC(2,cmp_b,(R1 d, R1 s))
+MIDFUNC(2,cmp_b,(R1 d, R1 s))
{
CLOBBER_CMP;
s=readreg(s,1);
}
MENDFUNC(2,cmp_b,(R1 d, R1 s))
-
- MIDFUNC(2,xor_l,(RW4 d, R4 s))
+MIDFUNC(2,xor_l,(RW4 d, R4 s))
{
CLOBBER_XOR;
s=readreg(s,4);
}
MENDFUNC(2,xor_l,(RW4 d, R4 s))
- MIDFUNC(2,xor_w,(RW2 d, R2 s))
+MIDFUNC(2,xor_w,(RW2 d, R2 s))
{
CLOBBER_XOR;
s=readreg(s,2);
}
MENDFUNC(2,xor_w,(RW2 d, R2 s))
- MIDFUNC(2,xor_b,(RW1 d, R1 s))
+MIDFUNC(2,xor_b,(RW1 d, R1 s))
{
CLOBBER_XOR;
s=readreg(s,1);
}
MENDFUNC(2,xor_b,(RW1 d, R1 s))
- MIDFUNC(5,call_r_11,(W4 out1, R4 r, R4 in1, IMM osize, IMM isize))
+MIDFUNC(5,call_r_11,(W4 out1, R4 r, R4 in1, IMM osize, IMM isize))
{
clobber_flags();
remove_all_offsets();
}
MENDFUNC(5,call_r_11,(W4 out1, R4 r, R4 in1, IMM osize, IMM isize))
- MIDFUNC(5,call_r_02,(R4 r, R4 in1, R4 in2, IMM isize1, IMM isize2))
+MIDFUNC(5,call_r_02,(R4 r, R4 in1, R4 in2, IMM isize1, IMM isize2))
{
clobber_flags();
remove_all_offsets();
}
MENDFUNC(5,call_r_02,(R4 r, R4 in1, R4 in2, IMM isize1, IMM isize2))
- MIDFUNC(1,forget_about,(W4 r))
+MIDFUNC(1,forget_about,(W4 r))
{
if (isinreg(r))
disassociate(r);
}
MENDFUNC(1,forget_about,(W4 r))
- MIDFUNC(0,nop,(void))
+MIDFUNC(0,nop,(void))
{
raw_nop();
}
MENDFUNC(0,nop,(void))
- MIDFUNC(1,f_forget_about,(FW r))
+MIDFUNC(1,f_forget_about,(FW r))
{
if (f_isinreg(r))
f_disassociate(r);
}
MENDFUNC(1,f_forget_about,(FW r))
- MIDFUNC(1,fmov_pi,(FW r))
+MIDFUNC(1,fmov_pi,(FW r))
{
r=f_writereg(r);
raw_fmov_pi(r);
}
MENDFUNC(1,fmov_pi,(FW r))
- MIDFUNC(1,fmov_log10_2,(FW r))
+MIDFUNC(1,fmov_log10_2,(FW r))
{
r=f_writereg(r);
raw_fmov_log10_2(r);
}
MENDFUNC(1,fmov_log10_2,(FW r))
- MIDFUNC(1,fmov_log2_e,(FW r))
+MIDFUNC(1,fmov_log2_e,(FW r))
{
r=f_writereg(r);
raw_fmov_log2_e(r);
}
MENDFUNC(1,fmov_log2_e,(FW r))
- MIDFUNC(1,fmov_loge_2,(FW r))
+MIDFUNC(1,fmov_loge_2,(FW r))
{
r=f_writereg(r);
raw_fmov_loge_2(r);
}
MENDFUNC(1,fmov_loge_2,(FW r))
- MIDFUNC(1,fmov_1,(FW r))
+MIDFUNC(1,fmov_1,(FW r))
{
r=f_writereg(r);
raw_fmov_1(r);
}
MENDFUNC(1,fmov_1,(FW r))
- MIDFUNC(1,fmov_0,(FW r))
+MIDFUNC(1,fmov_0,(FW r))
{
r=f_writereg(r);
raw_fmov_0(r);
}
MENDFUNC(1,fmov_0,(FW r))
- MIDFUNC(2,fmov_rm,(FW r, MEMR m))
+MIDFUNC(2,fmov_rm,(FW r, MEMR m))
{
r=f_writereg(r);
raw_fmov_rm(r,m);
}
MENDFUNC(2,fmov_rm,(FW r, MEMR m))
- MIDFUNC(2,fmovi_rm,(FW r, MEMR m))
+MIDFUNC(2,fmovi_rm,(FW r, MEMR m))
{
r=f_writereg(r);
raw_fmovi_rm(r,m);
}
MENDFUNC(2,fmovi_rm,(FW r, MEMR m))
- MIDFUNC(3,fmovi_mrb,(MEMW m, FR r, double *bounds))
+MIDFUNC(3,fmovi_mrb,(MEMW m, FR r, double *bounds))
{
r=f_readreg(r);
raw_fmovi_mrb(m,r,bounds);
}
MENDFUNC(3,fmovi_mrb,(MEMW m, FR r, double *bounds))
- MIDFUNC(2,fmovs_rm,(FW r, MEMR m))
+MIDFUNC(2,fmovs_rm,(FW r, MEMR m))
{
r=f_writereg(r);
raw_fmovs_rm(r,m);
}
MENDFUNC(2,fmovs_rm,(FW r, MEMR m))
- MIDFUNC(2,fmovs_mr,(MEMW m, FR r))
+MIDFUNC(2,fmovs_mr,(MEMW m, FR r))
{
r=f_readreg(r);
raw_fmovs_mr(m,r);
}
MENDFUNC(2,fmovs_mr,(MEMW m, FR r))
- MIDFUNC(1,fcuts_r,(FRW r))
+MIDFUNC(1,fcuts_r,(FRW r))
{
r=f_rmw(r);
raw_fcuts_r(r);
}
MENDFUNC(1,fcuts_r,(FRW r))
- MIDFUNC(1,fcut_r,(FRW r))
+MIDFUNC(1,fcut_r,(FRW r))
{
r=f_rmw(r);
raw_fcut_r(r);
}
MENDFUNC(1,fcut_r,(FRW r))
- MIDFUNC(2,fmov_ext_mr,(MEMW m, FR r))
+MIDFUNC(2,fmov_ext_mr,(MEMW m, FR r))
{
r=f_readreg(r);
raw_fmov_ext_mr(m,r);
}
MENDFUNC(2,fmov_ext_mr,(MEMW m, FR r))
- MIDFUNC(2,fmov_mr,(MEMW m, FR r))
+MIDFUNC(2,fmov_mr,(MEMW m, FR r))
{
r=f_readreg(r);
raw_fmov_mr(m,r);
}
MENDFUNC(2,fmov_mr,(MEMW m, FR r))
- MIDFUNC(2,fmov_ext_rm,(FW r, MEMR m))
+MIDFUNC(2,fmov_ext_rm,(FW r, MEMR m))
{
r=f_writereg(r);
raw_fmov_ext_rm(r,m);
}
MENDFUNC(2,fmov_ext_rm,(FW r, MEMR m))
- MIDFUNC(2,fmov_rr,(FW d, FR s))
+MIDFUNC(2,fmov_rr,(FW d, FR s))
{
if (d==s) { /* How pointless! */
return;
}
MENDFUNC(2,fmov_rr,(FW d, FR s))
- MIDFUNC(2,fldcw_m_indexed,(R4 index, IMM base))
+MIDFUNC(2,fldcw_m_indexed,(R4 index, IMM base))
{
index=readreg(index,4);
}
MENDFUNC(2,fldcw_m_indexed,(R4 index, IMM base))
- MIDFUNC(1,ftst_r,(FR r))
+MIDFUNC(1,ftst_r,(FR r))
{
r=f_readreg(r);
raw_ftst_r(r);
}
MENDFUNC(1,ftst_r,(FR r))
- MIDFUNC(0,dont_care_fflags,(void))
+MIDFUNC(0,dont_care_fflags,(void))
{
f_disassociate(FP_RESULT);
}
MENDFUNC(0,dont_care_fflags,(void))
- MIDFUNC(2,fsqrt_rr,(FW d, FR s))
+MIDFUNC(2,fsqrt_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,fsqrt_rr,(FW d, FR s))
- MIDFUNC(2,fabs_rr,(FW d, FR s))
+MIDFUNC(2,fabs_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,fabs_rr,(FW d, FR s))
- MIDFUNC(2,frndint_rr,(FW d, FR s))
+MIDFUNC(2,frndint_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,frndint_rr,(FW d, FR s))
- MIDFUNC(2,fgetexp_rr,(FW d, FR s))
+MIDFUNC(2,fgetexp_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,fgetexp_rr,(FW d, FR s))
- MIDFUNC(2,fgetman_rr,(FW d, FR s))
+MIDFUNC(2,fgetman_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,fgetman_rr,(FW d, FR s))
- MIDFUNC(2,fsin_rr,(FW d, FR s))
+MIDFUNC(2,fsin_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,fsin_rr,(FW d, FR s))
- MIDFUNC(2,fcos_rr,(FW d, FR s))
+MIDFUNC(2,fcos_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,fcos_rr,(FW d, FR s))
- MIDFUNC(2,ftan_rr,(FW d, FR s))
+MIDFUNC(2,ftan_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,ftan_rr,(FW d, FR s))
- MIDFUNC(3,fsincos_rr,(FW d, FW c, FR s))
+MIDFUNC(3,fsincos_rr,(FW d, FW c, FR s))
{
s=f_readreg(s); /* s for source */
d=f_writereg(d); /* d for sine */
}
MENDFUNC(3,fsincos_rr,(FW d, FW c, FR s))
- MIDFUNC(2,fscale_rr,(FRW d, FR s))
+MIDFUNC(2,fscale_rr,(FRW d, FR s))
{
s=f_readreg(s);
d=f_rmw(d);
}
MENDFUNC(2,fscale_rr,(FRW d, FR s))
- MIDFUNC(2,ftwotox_rr,(FW d, FR s))
+MIDFUNC(2,ftwotox_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,ftwotox_rr,(FW d, FR s))
- MIDFUNC(2,fetox_rr,(FW d, FR s))
+MIDFUNC(2,fetox_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,fetox_rr,(FW d, FR s))
- MIDFUNC(2,fetoxM1_rr,(FW d, FR s))
+MIDFUNC(2,fetoxM1_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,fetoxM1_rr,(FW d, FR s))
- MIDFUNC(2,ftentox_rr,(FW d, FR s))
+MIDFUNC(2,ftentox_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,ftentox_rr,(FW d, FR s))
- MIDFUNC(2,flog2_rr,(FW d, FR s))
+MIDFUNC(2,flog2_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,flog2_rr,(FW d, FR s))
- MIDFUNC(2,flogN_rr,(FW d, FR s))
+MIDFUNC(2,flogN_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,flogN_rr,(FW d, FR s))
- MIDFUNC(2,flogNP1_rr,(FW d, FR s))
+MIDFUNC(2,flogNP1_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,flogNP1_rr,(FW d, FR s))
- MIDFUNC(2,flog10_rr,(FW d, FR s))
+MIDFUNC(2,flog10_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,flog10_rr,(FW d, FR s))
- MIDFUNC(2,fasin_rr,(FW d, FR s))
+MIDFUNC(2,fasin_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,fasin_rr,(FW d, FR s))
- MIDFUNC(2,facos_rr,(FW d, FR s))
+MIDFUNC(2,facos_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,facos_rr,(FW d, FR s))
- MIDFUNC(2,fatan_rr,(FW d, FR s))
+MIDFUNC(2,fatan_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,fatan_rr,(FW d, FR s))
- MIDFUNC(2,fatanh_rr,(FW d, FR s))
+MIDFUNC(2,fatanh_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,fatanh_rr,(FW d, FR s))
- MIDFUNC(2,fsinh_rr,(FW d, FR s))
+MIDFUNC(2,fsinh_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,fsinh_rr,(FW d, FR s))
- MIDFUNC(2,fcosh_rr,(FW d, FR s))
+MIDFUNC(2,fcosh_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,fcosh_rr,(FW d, FR s))
- MIDFUNC(2,ftanh_rr,(FW d, FR s))
+MIDFUNC(2,ftanh_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,ftanh_rr,(FW d, FR s))
- MIDFUNC(2,fneg_rr,(FW d, FR s))
+MIDFUNC(2,fneg_rr,(FW d, FR s))
{
s=f_readreg(s);
d=f_writereg(d);
}
MENDFUNC(2,fneg_rr,(FW d, FR s))
- MIDFUNC(2,fadd_rr,(FRW d, FR s))
+MIDFUNC(2,fadd_rr,(FRW d, FR s))
{
s=f_readreg(s);
d=f_rmw(d);
}
MENDFUNC(2,fadd_rr,(FRW d, FR s))
- MIDFUNC(2,fsub_rr,(FRW d, FR s))
+MIDFUNC(2,fsub_rr,(FRW d, FR s))
{
s=f_readreg(s);
d=f_rmw(d);
}
MENDFUNC(2,fsub_rr,(FRW d, FR s))
- MIDFUNC(2,fcmp_rr,(FR d, FR s))
+MIDFUNC(2,fcmp_rr,(FR d, FR s))
{
d=f_readreg(d);
s=f_readreg(s);
}
MENDFUNC(2,fcmp_rr,(FR d, FR s))
- MIDFUNC(2,fdiv_rr,(FRW d, FR s))
+MIDFUNC(2,fdiv_rr,(FRW d, FR s))
{
s=f_readreg(s);
d=f_rmw(d);
}
MENDFUNC(2,fdiv_rr,(FRW d, FR s))
- MIDFUNC(2,frem_rr,(FRW d, FR s))
+MIDFUNC(2,frem_rr,(FRW d, FR s))
{
s=f_readreg(s);
d=f_rmw(d);
}
MENDFUNC(2,frem_rr,(FRW d, FR s))
- MIDFUNC(2,frem1_rr,(FRW d, FR s))
+MIDFUNC(2,frem1_rr,(FRW d, FR s))
{
s=f_readreg(s);
d=f_rmw(d);
}
MENDFUNC(2,frem1_rr,(FRW d, FR s))
- MIDFUNC(2,fmul_rr,(FRW d, FR s))
+MIDFUNC(2,fmul_rr,(FRW d, FR s))
{
s=f_readreg(s);
d=f_rmw(d);
projects / francis / winuae.git / commitdiff