mirror of
git://gcc.gnu.org/git/gcc.git
synced 2025-03-08 15:17:18 +08:00
i386-protos.h (split_xf, [...]): Remove.
* i386-protos.h (split_xf, ix86_split_movdi): Remove.
(ix86_split_long_move): Declare.
* i386.c (split_xf, ix86_split_movdi): Remove.
(ix86_split_to_parts, ix86_split_long_move): New.
* i386.md (dimode move splitters): Use ix86_split_long_move.
(dfmode move splitters): Likewise.
(xfmode move splitters): Likewise.
(movsf_1): Allow F->r.
(movdf_1, movxf_1): Allow F->ro.
Co-Authored-By: Richard Henderson <rth@cygnus.com>
From-SVN: r30578
This commit is contained in:
Jan Hubicka
Richard Henderson
parent
4a6ef811c8
commit
2450a05729
@ -1,3 +1,16 @@
|
||||
Thu Nov 18 11:10:03 1999 Jan Hubicka <hubicka@freesoft.cz>
|
||||
Richard Henderson <rth@cygnus.com>
|
||||
|
||||
* i386-protos.h (split_xf, ix86_split_movdi): Remove.
|
||||
(ix86_split_long_move): Declare.
|
||||
* i386.c (split_xf, ix86_split_movdi): Remove.
|
||||
(ix86_split_to_parts, ix86_split_long_move): New.
|
||||
* i386.md (dimode move splitters): Use ix86_split_long_move.
|
||||
(dfmode move splitters): Likewise.
|
||||
(xfmode move splitters): Likewise.
|
||||
(movsf_1): Allow F->r.
|
||||
(movdf_1, movxf_1): Allow F->ro.
|
||||
|
||||
1999-11-17 Mark Mitchell <mark@codesourcery.com>
|
||||
|
||||
* except.h (struct eh_entry): Add goto_entry_p.
|
||||
|
||||
@ -73,7 +73,6 @@ extern void print_operand PROTO((FILE*, rtx, int));
|
||||
extern void print_operand_address PROTO((FILE*, rtx));
|
||||
|
||||
extern void split_di PROTO((rtx[], int, rtx[], rtx[]));
|
||||
extern void split_xf PROTO((rtx, rtx[3]));
|
||||
|
||||
extern char *output_387_binary_op PROTO((rtx, rtx*));
|
||||
extern char *output_fix_trunc PROTO((rtx, rtx*));
|
||||
@ -92,7 +91,7 @@ extern void ix86_expand_branch PROTO((enum rtx_code, int, rtx));
|
||||
extern int ix86_expand_setcc PROTO((enum rtx_code, int, rtx));
|
||||
extern int ix86_expand_int_movcc PROTO((rtx[]));
|
||||
extern int ix86_expand_fp_movcc PROTO((rtx[]));
|
||||
extern int ix86_split_movdi PROTO((rtx[]));
|
||||
extern int ix86_split_long_move PROTO((rtx[]));
|
||||
extern void ix86_split_ashldi PROTO((rtx *, rtx));
|
||||
extern void ix86_split_ashrdi PROTO((rtx *, rtx));
|
||||
extern void ix86_split_lshrdi PROTO((rtx *, rtx));
|
||||
|
||||
@ -2996,26 +2996,6 @@ split_di (operands, num, lo_half, hi_half)
|
||||
abort();
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
split_xf (orig, out)
|
||||
rtx orig;
|
||||
rtx out[3];
|
||||
{
|
||||
if (REG_P (orig))
|
||||
{
|
||||
int regno = REGNO (orig);
|
||||
out[0] = gen_rtx_REG (SImode, regno);
|
||||
out[1] = gen_rtx_REG (SImode, regno + 1);
|
||||
out[2] = gen_rtx_REG (SImode, regno + 2);
|
||||
}
|
||||
else
|
||||
{
|
||||
out[0] = change_address (orig, SImode, NULL_RTX);
|
||||
out[1] = adj_offsettable_operand (out[0], 4);
|
||||
out[2] = adj_offsettable_operand (out[0], 8);
|
||||
}
|
||||
}
|
||||
|
||||
/* Output code to perform a 387 binary operation in INSN, one of PLUS,
|
||||
MINUS, MULT or DIV. OPERANDS are the insn operands, where operands[3]
|
||||
@ -4643,27 +4623,211 @@ ix86_expand_fp_movcc (operands)
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
ix86_split_movdi (operands)
|
||||
rtx operands[];
|
||||
/* Split operands 0 and 1 into SImode parts. Similar to split_di, but
|
||||
works for floating pointer parameters and nonoffsetable memories.
|
||||
For pushes, it returns just stack offsets; the values will be saved
|
||||
in the right order. Maximally three parts are generated. */
|
||||
|
||||
static void
|
||||
ix86_split_to_parts (operand, parts, mode)
|
||||
rtx operand;
|
||||
rtx *parts;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
split_di (operands+0, 1, operands+2, operands+3);
|
||||
split_di (operands+1, 1, operands+4, operands+5);
|
||||
if (reg_overlap_mentioned_p (operands[2], operands[1]))
|
||||
int size = GET_MODE_SIZE (mode) / 4;
|
||||
|
||||
if (size < 2 || size > 3)
|
||||
abort ();
|
||||
|
||||
if (GET_CODE (operand) == MEM && !offsettable_memref_p (operand))
|
||||
{
|
||||
rtx tmp;
|
||||
if (!reg_overlap_mentioned_p (operands[3], operands[4]))
|
||||
/* The only non-offsetable memories we handle are pushes. */
|
||||
if (! push_operand (operand, VOIDmode))
|
||||
abort ();
|
||||
|
||||
PUT_MODE (operand, SImode);
|
||||
parts[0] = parts[1] = parts[2] = operand;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (mode == DImode)
|
||||
split_di (&operand, 1, &parts[0], &parts[1]);
|
||||
else
|
||||
{
|
||||
tmp = operands[2], operands[2] = operands[3], operands[3] = tmp;
|
||||
tmp = operands[4], operands[4] = operands[5], operands[5] = tmp;
|
||||
if (REG_P (operand))
|
||||
{
|
||||
if (!reload_completed)
|
||||
abort ();
|
||||
parts[0] = gen_rtx_REG (SImode, REGNO (operand) + 0);
|
||||
parts[1] = gen_rtx_REG (SImode, REGNO (operand) + 1);
|
||||
if (size == 3)
|
||||
parts[2] = gen_rtx_REG (SImode, REGNO (operand) + 2);
|
||||
}
|
||||
else if (offsettable_memref_p (operand))
|
||||
{
|
||||
PUT_MODE (operand, SImode);
|
||||
parts[0] = operand;
|
||||
parts[1] = adj_offsettable_operand (operand, 4);
|
||||
if (size == 3)
|
||||
parts[2] = adj_offsettable_operand (operand, 8);
|
||||
}
|
||||
else if (GET_CODE (operand) == CONST_DOUBLE)
|
||||
{
|
||||
REAL_VALUE_TYPE r;
|
||||
long l[3];
|
||||
|
||||
REAL_VALUE_FROM_CONST_DOUBLE (r, operand);
|
||||
switch (mode)
|
||||
{
|
||||
case XFmode:
|
||||
REAL_VALUE_TO_TARGET_LONG_DOUBLE (r, l);
|
||||
parts[2] = GEN_INT (l[2]);
|
||||
break;
|
||||
case DFmode:
|
||||
REAL_VALUE_TO_TARGET_DOUBLE (r, l);
|
||||
break;
|
||||
default:
|
||||
abort ();
|
||||
}
|
||||
parts[1] = GEN_INT (l[1]);
|
||||
parts[0] = GEN_INT (l[0]);
|
||||
}
|
||||
else
|
||||
abort ();
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
/* Emit insns to perform a move or push of DI, DF, and XF values.
|
||||
Return false when normal moves are needed; true when all required
|
||||
insns have been emitted. Operands 2-4 contain the input values
|
||||
int the correct order; operands 5-7 contain the output values. */
|
||||
|
||||
int
|
||||
ix86_split_long_move (operands1)
|
||||
rtx operands1[];
|
||||
{
|
||||
rtx part[2][3];
|
||||
rtx operands[2];
|
||||
int size = GET_MODE_SIZE (GET_MODE (operands1[0])) / 4;
|
||||
int push = 0;
|
||||
int collisions = 0;
|
||||
|
||||
/* Make our own copy to avoid clobbering the operands. */
|
||||
operands[0] = copy_rtx (operands1[0]);
|
||||
operands[1] = copy_rtx (operands1[1]);
|
||||
|
||||
if (size < 2 || size > 3)
|
||||
abort ();
|
||||
|
||||
/* The only non-offsettable memory we handle is push. */
|
||||
if (push_operand (operands[0], VOIDmode))
|
||||
push = 1;
|
||||
else if (GET_CODE (operands[0]) == MEM
|
||||
&& ! offsettable_memref_p (operands[0]))
|
||||
abort ();
|
||||
|
||||
ix86_split_to_parts (operands[0], part[0], GET_MODE (operands1[0]));
|
||||
ix86_split_to_parts (operands[1], part[1], GET_MODE (operands1[0]));
|
||||
|
||||
/* When emitting push, take care for source operands on the stack. */
|
||||
if (push && GET_CODE (operands[1]) == MEM
|
||||
&& reg_overlap_mentioned_p (stack_pointer_rtx, operands[1]))
|
||||
{
|
||||
if (size == 3)
|
||||
part[1][1] = part[1][2];
|
||||
part[1][0] = part[1][1];
|
||||
}
|
||||
|
||||
/* We need to do copy in the right order in case an address register
|
||||
of the source overlaps the destination. */
|
||||
if (REG_P (part[0][0]) && GET_CODE (part[1][0]) == MEM)
|
||||
{
|
||||
if (reg_overlap_mentioned_p (part[0][0], XEXP (part[1][0], 0)))
|
||||
collisions++;
|
||||
if (reg_overlap_mentioned_p (part[0][1], XEXP (part[1][0], 0)))
|
||||
collisions++;
|
||||
if (size == 3
|
||||
&& reg_overlap_mentioned_p (part[0][2], XEXP (part[1][0], 0)))
|
||||
collisions++;
|
||||
|
||||
/* Collision in the middle part can be handled by reordering. */
|
||||
if (collisions == 1 && size == 3
|
||||
&& reg_overlap_mentioned_p (part[0][1], XEXP (part[1][0], 0)))
|
||||
{
|
||||
rtx tmp;
|
||||
tmp = part[0][1]; part[0][1] = part[0][2]; part[0][2] = tmp;
|
||||
tmp = part[1][1]; part[1][1] = part[1][2]; part[1][2] = tmp;
|
||||
}
|
||||
|
||||
/* If there are more collisions, we can't handle it by reordering.
|
||||
Do an lea to the last part and use only one colliding move. */
|
||||
else if (collisions > 1)
|
||||
{
|
||||
collisions = 1;
|
||||
emit_insn (gen_rtx_SET (VOIDmode, part[0][size - 1],
|
||||
XEXP (part[1][0], 0)));
|
||||
part[1][0] = change_address (part[1][0], SImode, part[0][size - 1]);
|
||||
part[1][1] = adj_offsettable_operand (part[1][0], 4);
|
||||
if (size == 3)
|
||||
part[1][2] = adj_offsettable_operand (part[1][0], 8);
|
||||
}
|
||||
}
|
||||
|
||||
if (push)
|
||||
{
|
||||
if (size == 3)
|
||||
emit_insn (gen_push (part[1][2]));
|
||||
emit_insn (gen_push (part[1][1]));
|
||||
emit_insn (gen_push (part[1][0]));
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Choose correct order to not overwrite the source before it is copied. */
|
||||
if ((REG_P (part[0][0])
|
||||
&& REG_P (part[1][1])
|
||||
&& (REGNO (part[0][0]) == REGNO (part[1][1])
|
||||
|| (size == 3
|
||||
&& REGNO (part[0][0]) == REGNO (part[1][2]))))
|
||||
|| (collisions > 0
|
||||
&& reg_overlap_mentioned_p (part[0][0], XEXP (part[1][0], 0))))
|
||||
{
|
||||
if (size == 3)
|
||||
{
|
||||
operands1[2] = part[0][2];
|
||||
operands1[3] = part[0][1];
|
||||
operands1[4] = part[0][0];
|
||||
operands1[5] = part[1][2];
|
||||
operands1[6] = part[1][1];
|
||||
operands1[7] = part[1][0];
|
||||
}
|
||||
else
|
||||
{
|
||||
emit_insn (gen_push (operands[4]));
|
||||
emit_insn (gen_rtx_SET (VOIDmode, operands[3], operands[5]));
|
||||
emit_insn (gen_popsi1 (operands[2]));
|
||||
|
||||
return 1; /* DONE */
|
||||
operands1[2] = part[0][1];
|
||||
operands1[3] = part[0][0];
|
||||
operands1[5] = part[1][1];
|
||||
operands1[6] = part[1][0];
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (size == 3)
|
||||
{
|
||||
operands1[2] = part[0][0];
|
||||
operands1[3] = part[0][1];
|
||||
operands1[4] = part[0][2];
|
||||
operands1[5] = part[1][0];
|
||||
operands1[6] = part[1][1];
|
||||
operands1[7] = part[1][2];
|
||||
}
|
||||
else
|
||||
{
|
||||
operands1[2] = part[0][0];
|
||||
operands1[3] = part[0][1];
|
||||
operands1[5] = part[1][0];
|
||||
operands1[6] = part[1][1];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1665,17 +1665,9 @@
|
||||
(define_split
|
||||
[(set (match_operand:DI 0 "push_operand" "")
|
||||
(match_operand:DI 1 "general_operand" ""))]
|
||||
""
|
||||
[(set (mem:SI (pre_dec:SI (reg:SI 7))) (match_dup 3))
|
||||
(set (mem:SI (pre_dec:SI (reg:SI 7))) (match_dup 2))]
|
||||
"
|
||||
{
|
||||
split_di (operands+1, 1, operands+2, operands+3);
|
||||
/* Compensate for the fact that we're changing stack offsets in
|
||||
the middle of this operation. */
|
||||
if (reg_mentioned_p (stack_pointer_rtx, operands[2]))
|
||||
operands[2] = adj_offsettable_operand (operands[2], 4);
|
||||
}")
|
||||
"reload_completed"
|
||||
[(const_int 0)]
|
||||
"if (!ix86_split_long_move (operands)) abort (); DONE;")
|
||||
|
||||
;; %%% This multiword shite has got to go.
|
||||
(define_split
|
||||
@ -1683,19 +1675,19 @@
|
||||
(match_operand:DI 1 "general_operand" ""))
|
||||
(clobber (reg:CC 17))]
|
||||
"reload_completed"
|
||||
[(parallel [(set (match_dup 2) (match_dup 4))
|
||||
[(parallel [(set (match_dup 2) (match_dup 5))
|
||||
(clobber (reg:CC 17))])
|
||||
(parallel [(set (match_dup 3) (match_dup 5))
|
||||
(parallel [(set (match_dup 3) (match_dup 6))
|
||||
(clobber (reg:CC 17))])]
|
||||
"if (ix86_split_movdi (operands)) DONE;")
|
||||
"if (ix86_split_long_move (operands)) DONE;")
|
||||
|
||||
(define_split
|
||||
[(set (match_operand:DI 0 "nonimmediate_operand" "")
|
||||
(match_operand:DI 1 "general_operand" ""))]
|
||||
"reload_completed"
|
||||
[(set (match_dup 2) (match_dup 4))
|
||||
(set (match_dup 3) (match_dup 5))]
|
||||
"if (ix86_split_movdi (operands)) DONE;")
|
||||
[(set (match_dup 2) (match_dup 5))
|
||||
(set (match_dup 3) (match_dup 6))]
|
||||
"if (ix86_split_long_move (operands)) DONE;")
|
||||
|
||||
(define_expand "movsf"
|
||||
[(set (match_operand:SF 0 "general_operand" "")
|
||||
@ -1740,7 +1732,7 @@
|
||||
|
||||
(define_insn "*movsf_1"
|
||||
[(set (match_operand:SF 0 "nonimmediate_operand" "=f,m,f,*r,m,*r")
|
||||
(match_operand:SF 1 "general_operand" "fm,f,G,*rm,*r,G"))]
|
||||
(match_operand:SF 1 "general_operand" "fm,f,G,*rm,F*r,GF"))]
|
||||
""
|
||||
"*
|
||||
{
|
||||
@ -1843,20 +1835,12 @@
|
||||
[(set (match_operand:DF 0 "push_operand" "")
|
||||
(match_operand:DF 1 "general_operand" ""))]
|
||||
"reload_completed"
|
||||
[(set (mem:SI (pre_dec:SI (reg:SI 7))) (match_dup 1))
|
||||
(set (mem:SI (pre_dec:SI (reg:SI 7))) (match_dup 0))]
|
||||
"
|
||||
{
|
||||
split_di (operands+1, 1, operands+0, operands+1);
|
||||
/* Compensate for the fact that we're changing stack offsets in
|
||||
the middle of this operation. */
|
||||
if (reg_mentioned_p (stack_pointer_rtx, operands[0]))
|
||||
operands[0] = adj_offsettable_operand (operands[0], 4);
|
||||
}")
|
||||
[(const_int 0)]
|
||||
"if (!ix86_split_long_move (operands)) abort (); DONE;")
|
||||
|
||||
(define_insn "*movdf_1"
|
||||
[(set (match_operand:DF 0 "nonimmediate_operand" "=f,m,f,*&r,m,*r")
|
||||
(match_operand:DF 1 "general_operand" "fm,f,G,*rm,*r,G"))]
|
||||
[(set (match_operand:DF 0 "nonimmediate_operand" "=f,m,f,*r,o")
|
||||
(match_operand:DF 1 "general_operand" "fm,f,G,*roF,F*r"))]
|
||||
""
|
||||
"*
|
||||
{
|
||||
@ -1889,14 +1873,13 @@
|
||||
|
||||
case 3:
|
||||
case 4:
|
||||
case 5:
|
||||
return \"#\";
|
||||
|
||||
default:
|
||||
abort();
|
||||
}
|
||||
}"
|
||||
[(set_attr "type" "fmov,fmov,fmov,multi,multi,multi")])
|
||||
[(set_attr "type" "fmov,fmov,fmov,multi,multi")])
|
||||
|
||||
(define_split
|
||||
[(set (match_operand:DF 0 "nonimmediate_operand" "")
|
||||
@ -1909,10 +1892,9 @@
|
||||
&& ! (FP_REG_P (operands[1]) ||
|
||||
(GET_CODE (operands[1]) == SUBREG
|
||||
&& FP_REG_P (SUBREG_REG (operands[1]))))"
|
||||
[(set (match_dup 0) (match_dup 2))
|
||||
(set (match_dup 1) (match_dup 3))]
|
||||
"split_di (operands+1, 1, operands+2, operands+3);
|
||||
split_di (operands+0, 1, operands+0, operands+1);")
|
||||
[(set (match_dup 2) (match_dup 5))
|
||||
(set (match_dup 3) (match_dup 6))]
|
||||
"if (ix86_split_long_move (operands)) DONE;")
|
||||
|
||||
(define_insn "swapdf"
|
||||
[(set (match_operand:DF 0 "register_operand" "+f")
|
||||
@ -1936,8 +1918,8 @@
|
||||
"ix86_expand_move (XFmode, operands); DONE;")
|
||||
|
||||
(define_insn "*pushxf"
|
||||
[(set (match_operand:XF 0 "push_operand" "=<")
|
||||
(match_operand:XF 1 "register_operand" "f"))]
|
||||
[(set (match_operand:XF 0 "push_operand" "=<,<")
|
||||
(match_operand:XF 1 "register_operand" "f,oF*r"))]
|
||||
""
|
||||
"*
|
||||
{
|
||||
@ -1952,6 +1934,14 @@
|
||||
}"
|
||||
[(set_attr "type" "multi")])
|
||||
|
||||
(define_split
|
||||
[(set (match_operand:XF 0 "push_operand" "")
|
||||
(match_operand:XF 1 "general_operand" ""))]
|
||||
"reload_completed
|
||||
&& (!REG_P (operands[1]) || !FP_REGNO_P (REGNO (operands[1])))"
|
||||
[(const_int 0)]
|
||||
"if (!ix86_split_long_move (operands)) abort (); DONE;")
|
||||
|
||||
(define_split
|
||||
[(set (match_operand:XF 0 "push_operand" "")
|
||||
(match_operand:XF 1 "register_operand" ""))]
|
||||
@ -1980,8 +1970,8 @@
|
||||
}")
|
||||
|
||||
(define_insn "*movxf_1"
|
||||
[(set (match_operand:XF 0 "nonimmediate_operand" "=f,m,f,*&r,o")
|
||||
(match_operand:XF 1 "general_operand" "fm,f,G,*ro,*r"))]
|
||||
[(set (match_operand:XF 0 "nonimmediate_operand" "=f,m,f,*r,o")
|
||||
(match_operand:XF 1 "general_operand" "fm,f,G,*roF,*r"))]
|
||||
""
|
||||
"*
|
||||
{
|
||||
@ -2023,14 +2013,14 @@
|
||||
|
||||
(define_split
|
||||
[(set (match_operand:XF 0 "nonimmediate_operand" "")
|
||||
(match_operand:XF 1 "nonimmediate_operand" ""))]
|
||||
"(REG_P (operands[0]) && ! FP_REGNO_P (REGNO (operands[0])))
|
||||
|| (REG_P (operands[1]) && ! FP_REGNO_P (REGNO (operands[1])))"
|
||||
[(set (match_dup 0) (match_dup 3))
|
||||
(set (match_dup 1) (match_dup 4))
|
||||
(set (match_dup 2) (match_dup 5))]
|
||||
"split_xf (operands[1], &operands[3]);
|
||||
split_xf (operands[0], &operands[0]);")
|
||||
(match_operand:XF 1 "general_operand" ""))]
|
||||
"reload_completed
|
||||
&& ((REG_P (operands[0]) && ! FP_REGNO_P (REGNO (operands[0])))
|
||||
|| (REG_P (operands[1]) && ! FP_REGNO_P (REGNO (operands[1]))))"
|
||||
[(set (match_dup 2) (match_dup 5))
|
||||
(set (match_dup 3) (match_dup 6))
|
||||
(set (match_dup 4) (match_dup 7))]
|
||||
"if (ix86_split_long_move (operands)) DONE;")
|
||||
|
||||
(define_insn "swapxf"
|
||||
[(set (match_operand:XF 0 "register_operand" "+f")
|
||||
|
||||
Loading…
Reference in New Issue
Block a user