static char * shift_op PARAMS ((rtx, HOST_WIDE_INT *));
static int pattern_really_clobbers_lr PARAMS ((rtx));
static int function_really_clobbers_lr PARAMS ((rtx));
-static rtx emit_multi_reg_push PARAMS ((int));
+static rtx emit_multi_reg_push PARAMS ((int));
static rtx emit_sfm PARAMS ((int, int));
static enum arm_cond_code get_arm_condition_code PARAMS ((rtx));
static int const_ok_for_op PARAMS ((HOST_WIDE_INT, enum rtx_code));
extern FILE * asm_out_file;
-/* True if we are currently building a constant table. */
+/* True if we are currently building a constant table. */
int making_const_table;
/* Define the information needed to generate branch insns. This is
- stored from the compare operation. */
+ stored from the compare operation. */
rtx arm_compare_op0, arm_compare_op1;
-/* What type of floating point are we tuning for? */
+/* What type of floating point are we tuning for? */
enum floating_point_type arm_fpu;
-/* What type of floating point instructions are available? */
+/* What type of floating point instructions are available? */
enum floating_point_type arm_fpu_arch;
-/* What program mode is the cpu running in? 26-bit mode or 32-bit mode */
+/* What program mode is the cpu running in? 26-bit mode or 32-bit mode. */
enum prog_mode_type arm_prgmode;
-/* Set by the -mfp=... option */
+/* Set by the -mfp=... option. */
const char * target_fp_name = NULL;
/* Used to parse -mstructure_size_boundary command line option. */
/* Nonzero if this is an "M" variant of the processor. */
int arm_fast_multiply = 0;
-/* Nonzero if this chip supports the ARM Architecture 4 extensions */
+/* Nonzero if this chip supports the ARM Architecture 4 extensions. */
int arm_arch4 = 0;
-/* Nonzero if this chip supports the ARM Architecture 5 extensions */
+/* Nonzero if this chip supports the ARM Architecture 5 extensions. */
int arm_arch5 = 0;
/* Nonzero if this chip can benefit from load scheduling. */
int arm_pic_register = 9;
/* Set to one if we think that lr is only saved because of subroutine calls,
- but all of these can be `put after' return insns */
+ but all of these can be `put after' return insns. */
int lr_save_eliminated;
/* Set to 1 when a return insn is output, this means that the epilogue
- is not needed. */
+ is not needed. */
static int return_used_this_function;
/* Set to 1 after arm_reorg has started. Reset to start at the start of
#define streq(string1, string2) (strcmp (string1, string2) == 0)
\f
-/* Initialization code */
+/* Initialization code. */
struct processors
{
/* If we have been given an architecture and a processor
make sure that they are compatible. We only generate
a warning though, and we prefer the CPU over the
- architecture. */
+ architecture. */
if (insn_flags != 0 && (insn_flags ^ sel->flags))
warning ("switch -mcpu=%s conflicts with -march= switch",
ptr->string);
}
\f
-/* Return 1 if it is possible to return using a single instruction */
-
+/* Return 1 if it is possible to return using a single instruction. */
int
use_return_insn (iscond)
int iscond;
}
/* Can't be done if any of the FPU regs are pushed, since this also
- requires an insn */
+ requires an insn. */
for (regno = 16; regno < 24; regno++)
if (regs_ever_live[regno] && ! call_used_regs[regno])
return 0;
return FALSE;
}
-/* Return true if I is a valid constant for the operation CODE. */
+/* Return true if I is a valid constant for the operation CODE. */
static int
const_ok_for_op (i, code)
HOST_WIDE_INT i;
abort ();
}
- /* If we can do it in one insn get out quickly */
+ /* If we can do it in one insn get out quickly. */
if (const_ok_for_arm (val)
|| (can_negate_initial && const_ok_for_arm (-val))
|| (can_invert && const_ok_for_arm (~val)))
return 1;
}
-
/* Calculate a few attributes that may be useful for specific
- optimizations. */
-
+ optimizations. */
for (i = 31; i >= 0; i--)
{
if ((remainder & (1 << i)) == 0)
temp1 = remainder & 0xffff0000UL;
temp2 = remainder & 0x0000ffff;
- /* Overlaps outside this range are best done using other methods. */
+ /* Overlaps outside this range are best done using other methods. */
for (i = 9; i < 24; i++)
{
if ((((temp2 | (temp2 << i)) & 0xffffffffUL) == remainder)
}
}
- /* Don't duplicate cases already considered. */
+ /* Don't duplicate cases already considered. */
for (i = 17; i < 24; i++)
{
if (((temp1 | (temp1 >> i)) == remainder)
We start by looking for the largest block of zeros that are aligned on
a 2-bit boundary, we then fill up the temps, wrapping around to the
top of the word when we drop off the bottom.
- In the worst case this code should produce no more than four insns. */
+ In the worst case this code should produce no more than four insns. */
{
int best_start = 0;
int best_consecutive_zeros = 0;
/* Now start emitting the insns, starting with the one with the highest
bit set: we do this so that the smallest number will be emitted last;
- this is more likely to be combinable with addressing insns. */
+ this is more likely to be combinable with addressing insns. */
i = best_start;
do
{
return 0;
}
- /* XXX Not sure what should be done for
- other aggregates so put them in memory. */
+ /* Put other aggregates in memory. */
return 1;
}
char flag;
{
const char * str = XSTR (XEXP (DECL_RTL (decl), 0), 0);
- int len = strlen (str);
- char * newstr;
+ int len = strlen (str);
+ char * newstr;
if (TREE_CODE (decl) != FUNCTION_DECL)
return;
#ifdef AOF_ASSEMBLER
/* The AOF assembler can generate relocations for these directly, and
- understands that the PIC register has to be added into the offset.
- */
+ understands that the PIC register has to be added into the offset. */
insn = emit_insn (gen_pic_load_addr_based (reg, orig));
#else
if (subregs)
case MULT:
/* There is no point basing this on the tuning, since it is always the
- fast variant if it exists at all */
+ fast variant if it exists at all. */
if (arm_fast_multiply && mode == DImode
&& (GET_CODE (XEXP (x, 0)) == GET_CODE (XEXP (x, 1)))
&& (GET_CODE (XEXP (x, 0)) == ZERO_EXTEND
& (unsigned HOST_WIDE_INT) 0xffffffffUL);
int add_cost = const_ok_for_arm (i) ? 4 : 8;
int j;
- /* Tune as appropriate */
+
+ /* Tune as appropriate. */
int booth_unit_size = ((tune_flags & FL_FAST_MULT) ? 8 : 2);
for (j = 0; i && j < 32; j += booth_unit_size)
{
rtx i_pat, d_pat;
- /* XXX This is not strictly true for the FPA. */
+ /* XXX This is not strictly true for the FPA. */
if (REG_NOTE_KIND(link) == REG_DEP_ANTI
|| REG_NOTE_KIND(link) == REG_DEP_OUTPUT)
return 0;
/* This is a load after a store, there is no conflict if the load reads
from a cached area. Assume that loads from the stack, and from the
constant pool are cached, and that others will miss. This is a
- hack. */
+ hack. */
if (CONSTANT_POOL_ADDRESS_P (XEXP (SET_SRC (i_pat), 0))
|| reg_mentioned_p (stack_pointer_rtx, XEXP (SET_SRC (i_pat), 0))
return cost;
}
-/* This code has been fixed for cross compilation. */
+/* This code has been fixed for cross compilation. */
static int fpa_consts_inited = 0;
fpa_consts_inited = 1;
}
-/* Return TRUE if rtx X is a valid immediate FPU constant. */
+/* Return TRUE if rtx X is a valid immediate FPU constant. */
int
const_double_rtx_ok_for_fpu (x)
return 0;
}
-/* Return TRUE if rtx X is a valid immediate FPU constant. */
+/* Return TRUE if rtx X is a valid immediate FPU constant. */
int
neg_const_double_rtx_ok_for_fpu (x)
op = XEXP (op, 0);
- /* A sum of anything more complex than reg + reg or reg + const is bad */
+ /* A sum of anything more complex than reg + reg or reg + const is bad. */
if ((GET_CODE (op) == PLUS || GET_CODE (op) == MINUS)
&& (! s_register_operand (XEXP (op, 0), VOIDmode)
|| (! s_register_operand (XEXP (op, 1), VOIDmode)
&& GET_CODE (XEXP (op, 1)) != CONST_INT)))
return 1;
- /* Big constants are also bad */
+ /* Big constants are also bad. */
if (GET_CODE (op) == PLUS && GET_CODE (XEXP (op, 1)) == CONST_INT
&& (INTVAL (XEXP (op, 1)) > 0xff
|| -INTVAL (XEXP (op, 1)) > 0xff))
return 1;
- /* Everything else is good, or can will automatically be made so. */
+ /* Everything else is good, or can will automatically be made so. */
return 0;
}
}
}
-/* Return TRUE for valid index operands. */
+/* Return TRUE for valid index operands. */
int
index_operand (op, mode)
/* Return TRUE for valid shifts by a constant. This also accepts any
power of two on the (somewhat overly relaxed) assumption that the
- shift operator in this case was a mult. */
+ shift operator in this case was a mult. */
int
const_shift_operand (op, mode)
}
}
-/* Return TRUE for shift operators. */
+/* Return TRUE for shift operators. */
int
shift_operator (x, mode)
}
}
-int equality_operator (x, mode)
+/* Return TRUE if x is EQ or NE. */
+int
+equality_operator (x, mode)
rtx x;
enum machine_mode mode ATTRIBUTE_UNUSED;
{
return GET_CODE (x) == EQ || GET_CODE (x) == NE;
}
-/* Return TRUE for SMIN SMAX UMIN UMAX operators. */
-
+/* Return TRUE for SMIN SMAX UMIN UMAX operators. */
int
minmax_operator (x, mode)
rtx x;
return code == SMIN || code == SMAX || code == UMIN || code == UMAX;
}
-/* return TRUE if x is EQ or NE */
-
/* Return TRUE if this is the condition code register, if we aren't given
- a mode, accept any class CCmode register */
-
+ a mode, accept any class CCmode register. */
int
cc_register (x, mode)
rtx x;
/* Return TRUE if this is the condition code register, if we aren't given
a mode, accept any class CCmode register which indicates a dominance
expression. */
-
int
dominant_cc_register (x, mode)
rtx x;
abort ();
}
-/* Return 1 if memory locations are adjacent */
-
+/* Return 1 if memory locations are adjacent. */
int
adjacent_mem_locations (a, b)
rtx a, b;
}
/* Return 1 if OP is a load multiple operation. It is known to be
- parallel and the first section will be tested. */
+ parallel and the first section will be tested. */
int
load_multiple_operation (op, mode)
|| GET_CODE (XVECEXP (op, 0, 0)) != SET)
return 0;
- /* Check to see if this might be a write-back */
+ /* Check to see if this might be a write-back. */
if (GET_CODE (SET_SRC (elt = XVECEXP (op, 0, 0))) == PLUS)
{
i++;
base = 1;
- /* Now check it more carefully */
+ /* Now check it more carefully. */
if (GET_CODE (SET_DEST (elt)) != REG
|| GET_CODE (XEXP (SET_SRC (elt), 0)) != REG
|| REGNO (XEXP (SET_SRC (elt), 0)) != REGNO (SET_DEST (elt))
if (GET_CODE (elt) != SET
|| GET_CODE (SET_DEST (elt)) != REG
|| GET_MODE (SET_DEST (elt)) != SImode
- || REGNO (SET_DEST (elt)) != dest_regno + i - base
+ || REGNO (SET_DEST (elt)) != (unsigned int)(dest_regno + i - base)
|| GET_CODE (SET_SRC (elt)) != MEM
|| GET_MODE (SET_SRC (elt)) != SImode
|| GET_CODE (XEXP (SET_SRC (elt), 0)) != PLUS
}
/* Return 1 if OP is a store multiple operation. It is known to be
- parallel and the first section will be tested. */
-
+ parallel and the first section will be tested. */
int
store_multiple_operation (op, mode)
rtx op;
|| GET_CODE (XVECEXP (op, 0, 0)) != SET)
return 0;
- /* Check to see if this might be a write-back */
+ /* Check to see if this might be a write-back. */
if (GET_CODE (SET_SRC (elt = XVECEXP (op, 0, 0))) == PLUS)
{
i++;
base = 1;
- /* Now check it more carefully */
+ /* Now check it more carefully. */
if (GET_CODE (SET_DEST (elt)) != REG
|| GET_CODE (XEXP (SET_SRC (elt), 0)) != REG
|| REGNO (XEXP (SET_SRC (elt), 0)) != REGNO (SET_DEST (elt))
if (GET_CODE (elt) != SET
|| GET_CODE (SET_SRC (elt)) != REG
|| GET_MODE (SET_SRC (elt)) != SImode
- || REGNO (SET_SRC (elt)) != src_regno + i - base
+ || REGNO (SET_SRC (elt)) != (unsigned int)(src_regno + i - base)
|| GET_CODE (SET_DEST (elt)) != MEM
|| GET_MODE (SET_DEST (elt)) != SImode
|| GET_CODE (XEXP (SET_DEST (elt), 0)) != PLUS
}
else
{
- if (base_reg != REGNO (reg))
+ if (base_reg != (int) REGNO (reg))
/* Not addressed from the same base register. */
return 0;
}
else
{
- if (base_reg != REGNO (reg))
+ if (base_reg != (int) REGNO (reg))
/* Not addressed from the same base register. */
return 0;
return a != NULL_TREE;
}
\f
-/* Routines for use in generating RTL */
-
+/* Routines for use in generating RTL. */
rtx
arm_gen_load_multiple (base_regno, count, from, up, write_back, unchanging_p,
in_struct_p, scalar_p)
if (part_bytes_reg == NULL)
abort ();
- /* The bytes we want are in the top end of the word */
+ /* The bytes we want are in the top end of the word. */
emit_insn (gen_lshrsi3 (tmp, part_bytes_reg,
GEN_INT (8 * (4 - last_bytes))));
part_bytes_reg = tmp;
base = find_replacement (&XEXP (ref, 0));
}
else
- /* The slot is out of range, or was dressed up in a SUBREG */
+ /* The slot is out of range, or was dressed up in a SUBREG. */
base = reg_equiv_address[REGNO (ref)];
}
else
}
else if (GET_CODE (base) == PLUS)
{
- /* The addend must be CONST_INT, or we would have dealt with it above */
+ /* The addend must be CONST_INT, or we would have dealt with it above. */
HOST_WIDE_INT hi, lo;
offset += INTVAL (XEXP (base, 1));
base = XEXP (base, 0);
- /* Rework the address into a legal sequence of insns */
+ /* Rework the address into a legal sequence of insns. */
/* Valid range for lo is -4095 -> 4095 */
lo = (offset >= 0
? (offset & 0xfff)
rtx base_plus = gen_rtx_REG (SImode, REGNO (operands[2]) + 1);
/* Get the base address; addsi3 knows how to handle constants
- that require more than one insn */
+ that require more than one insn. */
emit_insn (gen_addsi3 (base_plus, base, GEN_INT (hi)));
base = base_plus;
offset = lo;
base = find_replacement (&XEXP (ref, 0));
}
else
- /* The slot is out of range, or was dressed up in a SUBREG */
+ /* The slot is out of range, or was dressed up in a SUBREG. */
base = reg_equiv_address[REGNO (ref)];
}
else
}
else if (GET_CODE (base) == PLUS)
{
- /* The addend must be CONST_INT, or we would have dealt with it above */
+ /* The addend must be CONST_INT, or we would have dealt with it above. */
HOST_WIDE_INT hi, lo;
offset += INTVAL (XEXP (base, 1));
base = XEXP (base, 0);
- /* Rework the address into a legal sequence of insns */
+ /* Rework the address into a legal sequence of insns. */
/* Valid range for lo is -4095 -> 4095 */
lo = (offset >= 0
? (offset & 0xfff)
}
/* Get the base address; addsi3 knows how to handle constants
- that require more than one insn */
+ that require more than one insn. */
emit_insn (gen_addsi3 (base_plus, base, GEN_INT (hi)));
base = base_plus;
offset = lo;
been inserted, the insns are then modified to reference the
relevant entry in the pool.
- Possible enhancements to the alogorithm (not implemented) are:
+ Possible enhancements to the algorithm (not implemented) are:
- 1) ARM instructions (but not thumb) can use negative offsets, so we
+ 1) ARM instructions (but not Thumb) can use negative offsets, so we
could reference back to a previous pool rather than forwards to a
new one. For large functions this may reduce the number of pools
required.
2) For some processors and object formats, there may be benefit in
aligning the pools to the start of cache lines; this alignment
would need to be taken into account when calculating addressability
- of a pool.
-
- */
+ of a pool. */
typedef struct
{
/* The maximum number of constants that can fit into one pool, since
the pc relative range is 0...4092 bytes and constants are at least 4
bytes long. */
-
#define MAX_MINIPOOL_SIZE (4092/4)
static minipool_node minipool_vector[MAX_MINIPOOL_SIZE];
static int minipool_size;
}
}
- /* Need a new one */
+ /* Need a new one. */
minipool_vector[minipool_size].next_offset = GET_MODE_SIZE (mode);
offset = 0;
if (minipool_size == 0)
return offset;
}
-/* Output the literal table */
+/* Output the literal table. */
static void
dump_minipool (scan)
rtx scan;
if (GET_CODE (from) == BARRIER)
found_barrier = from;
- /* Count the length of this insn */
+ /* Count the length of this insn. */
if (GET_CODE (from) == JUMP_INSN
&& JUMP_LABEL (from) != 0
&& ((tmp = next_real_insn (JUMP_LABEL (from)))
if (fix->range == 0)
abort ();
- /* Add it to the chain of fixes */
+ /* Add it to the chain of fixes. */
fix->next = NULL;
if (minipool_fix_head != NULL)
minipool_fix_tail->next = fix;
{
int opno;
- /* Extract the operands of the insn */
+ /* Extract the operands of the insn. */
extract_insn(insn);
- /* Find the alternative selected */
+ /* Find the alternative selected. */
if (! constrain_operands (1))
fatal_insn_not_found (insn);
for (opno = 0; opno < recog_data.n_operands; opno++)
{
- /* Things we need to fix can only occur in inputs */
+ /* Things we need to fix can only occur in inputs. */
if (recog_data.operand_type[opno] != OP_IN)
continue;
/* If the rtx is the correct value then return the string of the number.
In this way we can ensure that valid double constants are generated even
- when cross compiling. */
+ when cross compiling. */
char *
fp_immediate_constant (x)
rtx x;
fprintf (stream, "}%s\n", hat ? "^" : "");
}
-/* Output a 'call' insn. */
+/* Output a 'call' insn. */
char *
output_call (operands)
rtx * operands;
{
- /* Handle calls to lr using ip (which may be clobbered in subr anyway). */
+ /* Handle calls to lr using ip (which may be clobbered in subr anyway). */
if (REGNO (operands[0]) == LR_REGNUM)
{
}
return 0;
default:
- /* Scan through the sub-elements and change any references there */
+ /* Scan through the sub-elements and change any references there. */
fmt = GET_RTX_FORMAT (code);
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
}
}
-/* Output a 'call' insn that is a reference in memory. */
+/* Output a 'call' insn that is a reference in memory. */
char *
output_call_mem (operands)
rtx * operands;
{
- operands[0] = copy_rtx (operands[0]); /* Be ultra careful */
- /* Handle calls using lr by using ip (which may be clobbered in subr anyway).
- */
+ operands[0] = copy_rtx (operands[0]); /* Be ultra careful. */
+ /* Handle calls using lr by using ip (which may be clobbered in subr anyway). */
if (eliminate_lr2ip (&operands[0]))
output_asm_insn ("mov%?\t%|ip, %|lr", operands);
output_mov_long_double_arm_from_arm (operands)
rtx * operands;
{
- /* We have to be careful here because the two might overlap */
+ /* We have to be careful here because the two might overlap. */
int dest_start = REGNO (operands[0]);
int src_start = REGNO (operands[1]);
rtx ops[2];
if (reg1 == IP_REGNUM)
abort ();
- /* Ensure the second source is not overwritten */
+ /* Ensure the second source is not overwritten. */
if (reg1 == reg0 + (WORDS_BIG_ENDIAN ? -1 : 1))
output_asm_insn ("mov%?\t%Q0, %Q1\n\tmov%?\t%R0, %R1", operands);
else
operands[1] = GEN_INT (ARM_SIGN_EXTEND (INTVAL (operands[1])));
}
#else
- /* Sign extend the intval into the high-order word */
+ /* Sign extend the intval into the high-order word. */
if (WORDS_BIG_ENDIAN)
{
otherops[1] = operands[1];
break;
case PRE_INC:
- abort (); /* Should never happen now */
+ abort (); /* Should never happen now. */
break;
case PRE_DEC:
break;
case POST_DEC:
- abort (); /* Should never happen now */
+ abort (); /* Should never happen now. */
break;
case LABEL_REF:
}
}
else
- abort (); /* Constraints should prevent this */
+ abort (); /* Constraints should prevent this. */
}
else if (code0 == MEM && code1 == REG)
{
break;
case PRE_INC:
- abort (); /* Should never happen now */
+ abort (); /* Should never happen now. */
break;
case PRE_DEC:
break;
case POST_DEC:
- abort (); /* Should never happen now */
+ abort (); /* Should never happen now. */
break;
case PLUS:
return "";
}
- /* If all else fails, make it out of ORRs or BICs as appropriate. */
+ /* If all else fails, make it out of ORRs or BICs as appropriate. */
for (i=0; i < 32; i++)
if (n & 1 << i)
n_ones++;
- if (n_ones > 16) /* Shorter to use MVN with BIC in this case. */
+ if (n_ones > 16) /* Shorter to use MVN with BIC in this case. */
output_multi_immediate(operands, "mvn%?\t%0, %1", "bic%?\t%0, %0, %1", 1,
~n);
else
if (n == 0)
{
operands[immed_op] = const0_rtx;
- output_asm_insn (instr1, operands); /* Quick and easy output */
+ output_asm_insn (instr1, operands); /* Quick and easy output. */
}
else
{
int i;
char *instr = instr1;
- /* Note that n is never zero here (which would give no output) */
+ /* Note that n is never zero here (which would give no output). */
for (i = 0; i < 32; i += 2)
{
if (n & (3 << i))
for the operation code. The returned result should not be overwritten.
OP is the rtx code of the shift.
On exit, *AMOUNTP will be -1 if the shift is by a register, or a constant
- shift. */
+ shift. */
static char *
shift_op (op, amountp)
}
-/* Obtain the shift from the POWER of two. */
-
+/* Obtain the shift from the POWER of two. */
static HOST_WIDE_INT
int_log2 (power)
HOST_WIDE_INT power;
NOTE: This code does not check for side-effect expressions in a SET_SRC:
such a check should not be needed because these only update an existing
value within a register; the register must still be set elsewhere within
- the function. */
-
+ the function. */
static int
pattern_really_clobbers_lr (x)
rtx x;
case CALL_INSN:
/* Don't yet know how to handle those calls that are not to a
- SYMBOL_REF */
+ SYMBOL_REF. */
if (GET_CODE (PATTERN (insn)) != PARALLEL)
abort ();
return 1;
break;
- default: /* Don't recognize it, be safe */
+ default: /* Don't recognize it, be safe. */
return 1;
}
if ((next = next_nonnote_insn (insn)) == NULL)
return 1;
- /* No need to worry about lr if the call never returns */
+ /* No need to worry about lr if the call never returns. */
if (GET_CODE (next) == BARRIER)
break;
- if (GET_CODE (next) == INSN && GET_CODE (PATTERN (next)) == USE
+ if (GET_CODE (next) == INSN
+ && GET_CODE (PATTERN (next)) == USE
&& (GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == SET)
&& (REGNO (SET_DEST (XVECEXP (PATTERN (insn), 0, 0)))
== REGNO (XEXP (PATTERN (next), 0))))
}
}
- /* We have reached the end of the chain so lr was _not_ clobbered */
+ /* We have reached the end of the chain so lr was _not_ clobbered. */
return 0;
}
Such functions never return, and many memory cycles can be saved
by not storing register values that will never be needed again.
This optimization was added to speed up context switching in a
- kernel application. */
-
+ kernel application. */
int
arm_volatile_func ()
{
- return (optimize > 0 && current_function_nothrow
+ return (optimize > 0
+ && current_function_nothrow
&& TREE_THIS_VOLATILE (current_function_decl));
}
no stack frame requirement and no live registers execpt for `lr'. If we
can guarantee that by making all function calls into tail calls and that
lr is not clobbered in any other way, then there is no need to push lr
- onto the stack. */
-
+ onto the stack. */
void
output_func_prologue (f, frame_size)
FILE * f;
int store_arg_regs = 0;
if (arm_ccfsm_state || arm_target_insn)
- abort (); /* Sanity check */
+ abort (); /* Sanity check. */
if (arm_naked_function_p (current_function_decl))
return;
if (live_regs_mask)
{
- /* if a di mode load/store multiple is used, and the base register
+ /* If a di mode load/store multiple is used, and the base register
is r3, then r4 can become an ever live register without lr
doing so, in this case we need to push lr as well, or we
- will fail to get a proper return. */
-
+ will fail to get a proper return. */
live_regs_mask |= 1 << LR_REGNUM;
lr_save_eliminated = 0;
{
int reg;
int live_regs_mask = 0;
- /* If we need this, then it will always be at least this much */
+ /* If we need this, then it will always be at least this much. */
int floats_offset = 12;
rtx operands[3];
int frame_size = get_frame_size ();
{
floats_offset += 12;
- /* We can't unstack more than four registers at once */
+ /* We can't unstack more than four registers at once. */
if (start_reg - reg == 3)
{
asm_fprintf (f, "\tlfm\t%r, 4, [%r, #-%d]\n",
{
if (live_regs_mask || regs_ever_live[LR_REGNUM])
{
- /* Restore the integer regs, and the return address into lr */
+ /* Restore the integer regs, and the return address into lr. */
if (! lr_save_eliminated)
live_regs_mask |= 1 << LR_REGNUM;
if (current_function_pretend_args_size)
{
- /* Unwind the pre-pushed regs */
+ /* Unwind the pre-pushed regs. */
operands[0] = operands[1] = stack_pointer_rtx;
operands[2] = GEN_INT (current_function_pretend_args_size);
output_add_immediate (operands);
}
- /* And finally, go home */
+ /* And finally, go home. */
if (TARGET_INTERWORK)
asm_fprintf (f, "\tbx\t%r\n", LR_REGNUM);
else if (TARGET_APCS_32)
Unfortunately, since this insn does not reflect very well the actual
semantics of the operation, we need to annotate the insn for the benefit
of DWARF2 frame unwind information. */
-
static rtx
emit_multi_reg_push (mask)
int mask;
}
/* And now the floating point regs. */
-
if (! volatile_func)
{
if (arm_fpu_arch == FP_SOFT2)
else if (GET_CODE (x) == CONST_DOUBLE)
fprintf (stream, "#%s", fp_immediate_constant (x));
else if (GET_CODE (x) == NEG)
- abort (); /* This should never happen now. */
+ abort (); /* This should never happen now. */
else
{
fputc ('#', stream);
out what the conditions are when the jump isn't taken. */
int jump_clobbers = 0;
- /* If we start with a return insn, we only succeed if we find another one. */
+ /* If we start with a return insn, we only succeed if we find another one. */
int seeking_return = 0;
/* START_INSN will hold the insn from where we start looking. This is the
/* Succeed if the following insn is the target label.
Otherwise fail.
If return insns are used then the last insn in a function
- will be a barrier. */
+ will be a barrier. */
this_insn = next_nonnote_insn (this_insn);
if (this_insn && this_insn == label)
{
}
#ifdef AOF_ASSEMBLER
-/* Special functions only needed when producing AOF syntax assembler. */
+/* Special functions only needed when producing AOF syntax assembler. */
rtx aof_pic_label = NULL_RTX;
struct pic_chain
projects / gcc.git / commitdiff