Skip to content

R
riscv-gcc-1
Commit 0f33506c by Richard Kenner
Options

(version_string): Declare. 

(current_file_function_operand): New function, replaces
current_function_operand.
(print_operand, case 'F'): Case deleted.
(alpha_builtin_saveregs): Reworked to use homed arglists, as recommended in
the calling standard.
(alpha_need_gp): Deleted, code moved into output_prolog.
(alpha_gp_dead_after): Deleted; optimization is not safe.
(alpha_write_verstamp): New function.
(output_prolog, output_epilog): Major rework to update to current
calling standard.

From-SVN: r3459
parent 4ba7b922
Showing with 119 additions and 267 deletions
gcc/config/alpha/alpha.c
...@@ -51,6 +51,8 @@ char *alpha_function_name; ...@@ -51,6 +51,8 @@ char *alpha_function_name;
/* Nonzero if the current function needs gp. */ /* Nonzero if the current function needs gp. */
int alpha_function_needs_gp; int alpha_function_needs_gp;
extern char *version_string;
/* Returns 1 if VALUE is a mask that contains full bytes of zero or ones. */ /* Returns 1 if VALUE is a mask that contains full bytes of zero or ones. */
...@@ -270,15 +272,17 @@ input_operand (op, mode) ...@@ -270,15 +272,17 @@ input_operand (op, mode)
return 0; return 0;
} }
/* Return 1 if OP is a SYMBOL_REF for the current function. */ /* Return 1 if OP is a SYMBOL_REF for a function known to be in this
file. */
int int
current_function_operand (op, mode) current_file_function_operand (op, mode)
rtx op; rtx op;
enum machine_mode mode; enum machine_mode mode;
{ {
return (GET_CODE (op) == SYMBOL_REF return (GET_CODE (op) == SYMBOL_REF
&& ! strcmp (XSTR (op, 0), current_function_name)); && (SYMBOL_REF_FLAG (op)
|| op == XEXP (DECL_RTL (current_function_decl), 0)));
} }
/* Return 1 if OP is a valid Alpha comparison operator. Here we know which /* Return 1 if OP is a valid Alpha comparison operator. Here we know which
...@@ -981,17 +985,6 @@ print_operand (file, x, code) ...@@ -981,17 +985,6 @@ print_operand (file, x, code)
} }
break; break;
case 'F':
/* Write the symbol; if the current function uses GP, write a
modified version. */
if (GET_CODE (x) != SYMBOL_REF)
output_operand_lossage ("invalid %%F value");
output_addr_const (file, x);
if (alpha_function_needs_gp)
fprintf (file, "..ng");
break;
case 'A': case 'A':
/* Write "_u" for unaligned access. */ /* Write "_u" for unaligned access. */
if (GET_CODE (x) == MEM && GET_CODE (XEXP (x, 0)) == AND) if (GET_CODE (x) == MEM && GET_CODE (XEXP (x, 0)) == AND)
...@@ -1026,94 +1019,35 @@ alpha_builtin_saveregs (arglist) ...@@ -1026,94 +1019,35 @@ alpha_builtin_saveregs (arglist)
int stdarg = (TYPE_ARG_TYPES (fntype) != 0 int stdarg = (TYPE_ARG_TYPES (fntype) != 0
&& (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype))) && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
!= void_type_node)); != void_type_node));
int nregs = current_function_args_info;
/* If we have a variable-sized argument already, we will have used all /* Compute the current position into the args, taking into account
the registers, so set up to indicate that. */ both registers and memory. */
if (GET_CODE (current_function_arg_offset_rtx) != CONST_INT) argsize = plus_constant (current_function_arg_offset_rtx,
{ current_function_args_info * UNITS_PER_WORD);
argsize = plus_constant (current_function_arg_offset_rtx,
(6 * UNITS_PER_WORD + UNITS_PER_WORD - 1));
argsize = expand_shift (RSHIFT_EXPR, Pmode, argsize,
build_int_2 (3, 0), argsize, 0);
}
else
{
/* Compute the number of args in memory and number of arguments already
processed. Then adjust the number of registers if this is stdarg. */
int memargs = ((INTVAL (current_function_arg_offset_rtx)
+ UNITS_PER_WORD - 1)
/ UNITS_PER_WORD);
argsize = GEN_INT (MIN (nregs, 6) + memargs);
if (nregs <= 6)
nregs -= stdarg;
}
/* Allocate the va_list constructor */ /* Allocate the va_list constructor */
block = assign_stack_local (BLKmode, 4 * UNITS_PER_WORD, BITS_PER_WORD); block = assign_stack_local (BLKmode, 2 * UNITS_PER_WORD, BITS_PER_WORD);
RTX_UNCHANGING_P (block) = 1; RTX_UNCHANGING_P (block) = 1;
RTX_UNCHANGING_P (XEXP (block, 0)) = 1; RTX_UNCHANGING_P (XEXP (block, 0)) = 1;
/* Store the argsize as the __va_arg member. */ /* Store the address of the first integer register in the
__va_base member. */
emit_move_insn (change_address (block, DImode, XEXP (block, 0)), emit_move_insn (change_address (block, DImode, XEXP (block, 0)),
argsize); force_operand (plus_constant (virtual_incoming_args_rtx,
-6 * UNITS_PER_WORD),
NULL_RTX));
/* Store the arg pointer in the __va_stack member. */ /* Store the argsize as the __va_offset member. */
emit_move_insn (change_address (block, Pmode, emit_move_insn (change_address (block, Pmode,
plus_constant (XEXP (block, 0), plus_constant (XEXP (block, 0),
UNITS_PER_WORD)), UNITS_PER_WORD)),
virtual_incoming_args_rtx); force_operand (argsize, NULL_RTX));
/* Allocate the integer register space, and store it as the
__va_ireg member. */
addr = assign_stack_local (BLKmode, 6 * UNITS_PER_WORD, -1);
MEM_IN_STRUCT_P (addr) = 1;
RTX_UNCHANGING_P (addr) = 1;
RTX_UNCHANGING_P (XEXP (addr, 0)) = 1;
emit_move_insn (change_address (block, Pmode,
plus_constant (XEXP (block, 0),
2 * UNITS_PER_WORD)),
copy_to_reg (XEXP (addr, 0)));
/* Now store the incoming integer registers. */
if (nregs < 6)
move_block_from_reg
(16 + nregs,
change_address (addr, Pmode,
plus_constant (XEXP (addr, 0),
nregs * UNITS_PER_WORD)),
6 - nregs);
/* Allocate the FP register space, and store it as the
__va_freg member. */
addr = assign_stack_local (BLKmode, 6 * UNITS_PER_WORD, -1);
MEM_IN_STRUCT_P (addr) = 1;
RTX_UNCHANGING_P (addr) = 1;
RTX_UNCHANGING_P (XEXP (addr, 0)) = 1;
emit_move_insn (change_address (block, Pmode,
plus_constant (XEXP (block, 0),
3 * UNITS_PER_WORD)),
copy_to_reg (XEXP (addr, 0)));
/* Now store the incoming floating-point registers. If we are not
to use the floating-point registers, store the integer registers
in those locations too. */
if (nregs < 6)
move_block_from_reg
(16 + 32 * (TARGET_FPREGS != 0) + nregs,
change_address (addr, Pmode,
plus_constant (XEXP (addr, 0),
nregs * UNITS_PER_WORD)),
6 - nregs);
/* Return the address of the va_list constructor, but don't put it in a /* Return the address of the va_list constructor, but don't put it in a
register. This fails when not optimizing and produces worse code when register. Doing so would fail when not optimizing and produce worse
optimizing. */ code when optimizing. */
return XEXP (block, 0); return XEXP (block, 0);
} }
...@@ -1132,77 +1066,15 @@ alpha_sa_size () ...@@ -1132,77 +1066,15 @@ alpha_sa_size ()
if (! fixed_regs[i] && ! call_used_regs[i] && regs_ever_live[i]) if (! fixed_regs[i] && ! call_used_regs[i] && regs_ever_live[i])
size++; size++;
return size * 8; /* If we are going to need a frame, we MUST save $26. */
} if (! regs_ever_live[26]
&& (size != 0
/* Return non-zero if this function needs gp. It does if it has || get_frame_size () != 0
an LDSYM insn. */ || current_function_outgoing_args_size != 0
|| current_function_pretend_args_size != 0))
int size++;
alpha_need_gp ()
{
rtx insn;
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
&& GET_CODE (PATTERN (insn)) != USE
&& GET_CODE (PATTERN (insn)) != CLOBBER
&& get_attr_type (insn) == TYPE_LDSYM)
return 1;
return 0;
}
/* Return 1 if GP is dead at after INSN. */
int
alpha_gp_dead_after (insn)
rtx insn;
{
int jump_count = 0;
int found = 0;
rtx p;
/* If we aren't optimizing, don't do this optimization. More importantly,
JUMP_LABEL isn't properly set when not optimizing. */
if (optimize == 0)
return 0;
/* If we are followed by a BARRIER, we don't return. */
if (NEXT_INSN (insn) && GET_CODE (NEXT_INSN (insn)) == BARRIER)
return 1;
/* Otherwise search for a use of GP before a return. */
for (p = next_active_insn (insn); p; p = next_active_insn (p))
{
if (get_attr_type (p) == TYPE_LDSYM
|| get_attr_type (p) == TYPE_JSR)
{
found = 1;
break;
}
if (GET_CODE (p) == JUMP_INSN)
{
if (GET_CODE (PATTERN (p)) == RETURN)
break;
if (! simplejump_p (p) || jump_count++ > 10)
{
found = 1;
break;
}
p = JUMP_LABEL (p); return size * 8;
}
}
/* Restore any operands destroyed by the attribute calls above. */
insn_extract (insn);
return ! found;
} }
/* Return 1 if this function can directly return via $26. */ /* Return 1 if this function can directly return via $26. */
...@@ -1215,6 +1087,27 @@ direct_return () ...@@ -1215,6 +1087,27 @@ direct_return ()
&& current_function_pretend_args_size == 0); && current_function_pretend_args_size == 0);
} }
/* Write a version stamp. Don't write anything if we are running as a
cross-compiler. Otherwise, use the versions in /usr/include/stamp.h. */
#ifndef CROSS_COMPILE
#include <stamp.h>
#endif
void
alpha_write_verstamp (file)
FILE *file;
{
#ifdef MS_STAMP
char *p;
fprintf (file, "\t.verstamp %d %d ", MS_STAMP, LS_STAMP);
for (p = version_string; *p != ' ' && *p != 0; p++)
fprintf (file, "%c", *p == '.' ? ' ' : *p);
fprintf (file, "\n");
#endif
}
/* Write function prologue. */ /* Write function prologue. */
void void
...@@ -1225,29 +1118,33 @@ output_prolog (file, size) ...@@ -1225,29 +1118,33 @@ output_prolog (file, size)
HOST_WIDE_INT frame_size = ((size + current_function_outgoing_args_size HOST_WIDE_INT frame_size = ((size + current_function_outgoing_args_size
+ current_function_pretend_args_size + current_function_pretend_args_size
+ alpha_sa_size () + 15) & ~15); + alpha_sa_size () + 15) & ~15);
int reg_offset = current_function_outgoing_args_size; int reg_offset = size + current_function_outgoing_args_size;
rtx insn;
int start_reg_offset = reg_offset; int start_reg_offset = reg_offset;
unsigned reg_mask = 0; unsigned reg_mask = 0;
int i; int i;
/* If we need a GP, load it first. */ /* If we need a GP (we have a LDSYM insn or a CALL_INSN) and we are not
alpha_function_needs_gp = alpha_need_gp (); a static function), load it first. */
alpha_function_needs_gp = 0;
if (TREE_PUBLIC (current_function_decl))
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
if ((GET_CODE (insn) == CALL_INSN)
|| (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
&& GET_CODE (PATTERN (insn)) != USE
&& GET_CODE (PATTERN (insn)) != CLOBBER
&& get_attr_type (insn) == TYPE_LDSYM))
{
alpha_function_needs_gp = 1;
break;
}
if (alpha_function_needs_gp) if (alpha_function_needs_gp)
{ fprintf (file, "\tldgp $29,0($27)\n");
rtx insn;
fprintf (file, "\tldgp $29,0($27)\n"); /* Put a label after the GP load so we can enter the function at it. */
fprintf (file, "%s..ng:\n", alpha_function_name);
/* If we have a recursive call, put a special label here. */
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
if (GET_CODE (insn) == CALL_INSN
&& get_attr_type (insn) != TYPE_JSR)
{
fprintf (file, "%s..ng:\n", current_function_name);
break;
}
}
/* Adjust the stack by the frame size. If the frame size is > 32768 /* Adjust the stack by the frame size. If the frame size is > 32768
bytes, we have to load it into a register first and then subtract bytes, we have to load it into a register first and then subtract
...@@ -1290,30 +1187,25 @@ output_prolog (file, size) ...@@ -1290,30 +1187,25 @@ output_prolog (file, size)
} }
fprintf (file, "\tldah $28,%d($%d)\n", high, in_reg); fprintf (file, "\tldah $28,%d($%d)\n", high, in_reg);
fprintf (file, "\tsubq $30,$28,$30\n"); fprintf (file, "\tsubq $30,$28,$30\n");
} }
else if (frame_size) else if (frame_size)
fprintf (file, "\tlda $30,-%d($30)\n", frame_size); fprintf (file, "\tlda $30,-%d($30)\n", frame_size);
/* Write out the .frame line. If we need a frame pointer, we use /* Describe our frame. */
an offset of zero. */ fprintf (file, "\t.frame $%d,%d,$26,%d\n",
frame_pointer_needed ? FRAME_POINTER_REGNUM : STACK_POINTER_REGNUM,
if (frame_pointer_needed) frame_size, current_function_pretend_args_size);
fprintf (file, "\t.frame $15,0,$26\n");
else
fprintf (file, "\t.frame $30,%d,$26\n", frame_size);
/* Save register 26 if it is used. */ /* Save register 26 if we have a frame. */
if (regs_ever_live[26]) if (frame_size != 0)
{ {
reg_mask |= 1 << 26; reg_mask |= 1 << 26;
fprintf (file, "\tstq $26,%d($30)\n", reg_offset); fprintf (file, "\tstq $26,%d($30)\n", reg_offset);
reg_offset += 8; reg_offset += 8;
} }
/* Now save any other used register that are required to be saved. */ /* Now save any other used integer registers required to be saved. */
for (i = 0; i < 32; i++) for (i = 0; i < 32; i++)
if (! fixed_regs[i] && ! call_used_regs[i] && regs_ever_live[i] && i != 26) if (! fixed_regs[i] && ! call_used_regs[i] && regs_ever_live[i] && i != 26)
{ {
...@@ -1343,21 +1235,13 @@ output_prolog (file, size) ...@@ -1343,21 +1235,13 @@ output_prolog (file, size)
if (reg_mask) if (reg_mask)
fprintf (file, "\t.fmask 0x%x,%d\n", reg_mask, start_reg_offset); fprintf (file, "\t.fmask 0x%x,%d\n", reg_mask, start_reg_offset);
/* If we need a frame pointer, set it to the value of incoming stack /* If we need a frame pointer, set it from the stack pointer. Note that
which we compute by adding back the frame size pointer. Because we this must always be the last instruction in the prologue. */
can subtract one more than we can add, we have to special-case
frame sizes of 32K. Note that there is no restriction that the frame
pointer be updated in one instruction. */
if (frame_pointer_needed) if (frame_pointer_needed)
{ fprintf (file, "\tbis $30,$30,$15\n");
if (frame_size == 32768)
fprintf (file, "\tlda $15,16384($30)\n\tlda $15,16384($15)\n"); /* End the prologue and say if we used gp. */
else if (frame_size > 32768) fprintf (file, "\t.prologue %d\n", alpha_function_needs_gp);
fprintf (file, "\taddq $30,$28,$15\n");
else
fprintf (file, "\tlda $15,%d($30)\n", frame_size);
}
} }
/* Write function epilogue. */ /* Write function epilogue. */
...@@ -1371,8 +1255,7 @@ output_epilog (file, size) ...@@ -1371,8 +1255,7 @@ output_epilog (file, size)
HOST_WIDE_INT frame_size = ((size + current_function_outgoing_args_size HOST_WIDE_INT frame_size = ((size + current_function_outgoing_args_size
+ current_function_pretend_args_size + current_function_pretend_args_size
+ alpha_sa_size () + 15) & ~15); + alpha_sa_size () + 15) & ~15);
int reg_offset = current_function_outgoing_args_size; int reg_offset = size + current_function_outgoing_args_size;
int reg_offset_from = STACK_POINTER_REGNUM;
int i; int i;
/* If the last insn was a BARRIER, we don't have to write anything except /* If the last insn was a BARRIER, we don't have to write anything except
...@@ -1381,72 +1264,32 @@ output_epilog (file, size) ...@@ -1381,72 +1264,32 @@ output_epilog (file, size)
insn = prev_nonnote_insn (insn); insn = prev_nonnote_insn (insn);
if (insn == 0 || GET_CODE (insn) != BARRIER) if (insn == 0 || GET_CODE (insn) != BARRIER)
{ {
/* If we have a frame pointer, we restore the registers from an int fp_offset;
offset from it, assuming that we can reach the offset. If not,
we have to compute the address using a scratch register. This is
messy, but should not be common. We have to copy the frame
pointer elsewhere here since we will be restoring it before we can
use it to restore the stack pointer. We use $25. */
/* If we have a frame pointer, restore SP from it. */
if (frame_pointer_needed) if (frame_pointer_needed)
{ fprintf (file, "\tbis $15,$15,$30\n");
fprintf (file, "\tbis $15,$15,$25\n");
if (frame_size < 32768)
reg_offset -= frame_size, reg_offset_from = 25;
else
{
HOST_WIDE_INT low
= (frame_size & 0xffff) - 2 * (frame_size & 0x8000);
HOST_WIDE_INT tmp1 = frame_size - low;
HOST_WIDE_INT high
= ((tmp1 >> 16) & 0xffff) - 2 * ((tmp1 >> 16) & 0x8000);
HOST_WIDE_INT tmp2 = frame_size - (high << 16) - low;
int extra = 0;
int in_reg = 31;
if (tmp2)
{
extra = 0x4000;
tmp1 -= 0x40000000;
high = ((tmp1 >> 16) & 0xffff) - 2 * ((tmp1 >> 16) & 0x8000);
}
if (low != 0)
{
fprintf (file, "\tlda $28,%d($%d)\n", low, in_reg);
in_reg = 28;
}
if (extra)
{
fprintf (file, "\tldah $28,%d($%d)\n", extra, in_reg);
in_reg = 28;
}
fprintf (file, "\tldah $28,%d($%d)\n", high, in_reg);
fprintf (file, "\tsubq $25,$28,$28\n");
reg_offset_from = 28;
}
}
/* Restore all the registers, starting with the return address /* Restore all the registers, starting with the return address
register. */ register. */
if (regs_ever_live[26]) if (frame_size != 0)
{ {
fprintf (file, "\tldq $26,%d($%d)\n", reg_offset, reg_offset_from); fprintf (file, "\tldq $26,%d($30)\n", reg_offset);
reg_offset += 8; reg_offset += 8;
} }
/* Now restore any other used register that that we saved. */ /* Now restore any other used integer registers that that we saved,
except for FP if it is being used as FP, since it must be
restored last. */
for (i = 0; i < 32; i++) for (i = 0; i < 32; i++)
if (! fixed_regs[i] && ! call_used_regs[i] && regs_ever_live[i] if (! fixed_regs[i] && ! call_used_regs[i] && regs_ever_live[i]
&& i != 26) && i != 26)
{ {
fprintf (file, "\tldq $%d,%d($%d)\n", if (i == FRAME_POINTER_REGNUM && frame_pointer_needed)
i, reg_offset, reg_offset_from); fp_offset = reg_offset;
else
fprintf (file, "\tldq $%d,%d($30)\n", i, reg_offset);
reg_offset += 8; reg_offset += 8;
} }
...@@ -1454,17 +1297,14 @@ output_epilog (file, size) ...@@ -1454,17 +1297,14 @@ output_epilog (file, size)
if (! fixed_regs[i + 32] && ! call_used_regs[i + 32] if (! fixed_regs[i + 32] && ! call_used_regs[i + 32]
&& regs_ever_live[i + 32]) && regs_ever_live[i + 32])
{ {
fprintf (file, "\tldt $f%d,%d($%d)\n", fprintf (file, "\tldt $f%d,%d($30)\n", i, reg_offset);
i, reg_offset, reg_offset_from);
reg_offset += 8; reg_offset += 8;
} }
/* Restore the stack. If we have a frame pointer, use it. Otherwise, /* If the stack size is large, compute the size of the stack into
add the size back into the stack, handling the large frame size. */ a register because the old FP restore, stack pointer adjust,
and return are required to be consecutive instructions. */
if (frame_pointer_needed) if (frame_size > 32767)
fprintf (file, "\tbis $25,$25,$30\n");
else if (frame_size > 32767)
{ {
HOST_WIDE_INT low HOST_WIDE_INT low
= (frame_size & 0xffff) - 2 * (frame_size & 0x8000); = (frame_size & 0xffff) - 2 * (frame_size & 0x8000);
...@@ -1501,16 +1341,28 @@ output_epilog (file, size) ...@@ -1501,16 +1341,28 @@ output_epilog (file, size)
} }
fprintf (file, "\tldah $28,%d($%d)\n", high, in_reg); fprintf (file, "\tldah $28,%d($%d)\n", high, in_reg);
fprintf (file, "\taddq $30,$28,$30\n");
} }
else if (frame_size)
/* If we needed a frame pointer and we have to restore it, do it
now. */
if (frame_pointer_needed && regs_ever_live[FRAME_POINTER_REGNUM])
fprintf (file, "\tldq $15,%d($30)\n", fp_offset);
/* Now update the stack pointer, if needed. This must be done in
one, styalized, instruction. */
if (frame_size > 32768)
fprintf (file, "\taddq $28,$30,$30\n");
else
fprintf (file, "\tlda $30,%d($30)\n", frame_size); fprintf (file, "\tlda $30,%d($30)\n", frame_size);
/* Now return to the caller. */ /* Finally return to the caller. */
fprintf (file, "\tret $31,($26),1\n"); fprintf (file, "\tret $31,($26),1\n");
} }
/* End the function. */ /* End the function. */
fprintf (file, "\t.end %s\n", alpha_function_name); fprintf (file, "\t.end %s\n", alpha_function_name);
/* Show that we know this function if it is called again. */
SYMBOL_REF_FLAG (XEXP (DECL_RTL (current_function_decl), 0)) = 1;
} }
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment