reg's live range. */
if (t != chain)
IOR_HARD_REG_SET (*pset, live);
- clear_dead_regs (&live, REG_UNUSED, REG_NOTES (insn));
+ clear_dead_regs (&live, REG_UNUSED, REG_NOTES (insn));
}
insn = NEXT_INSN (insn);
}
if (frame_pointer_needed)
{
int i;
-
+
for (i = HARD_REGNO_NREGS (FRAME_POINTER_REGNUM, Pmode); i--;)
SET_HARD_REG_BIT (unavailable, FRAME_POINTER_REGNUM + i);
-
+
#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
for (i = HARD_REGNO_NREGS (HARD_FRAME_POINTER_REGNUM, Pmode); i--;)
SET_HARD_REG_BIT (unavailable, HARD_FRAME_POINTER_REGNUM + i);
int i;
all_chains = this->next_chain;
-
+
#if 0 /* This just disables optimization opportunities. */
/* Only rename once we've seen the reg more than once. */
if (! TEST_HARD_REG_BIT (regs_seen, reg))
|| (! regs_ever_live[new_reg + i]
&& ! call_used_regs[new_reg + i])
#ifdef LEAF_REGISTERS
- /* We can't use a non-leaf register if we're in a
+ /* We can't use a non-leaf register if we're in a
leaf function. */
- || (current_function_is_leaf
+ || (current_function_is_leaf
&& !LEAF_REGISTERS[new_reg + i])
#endif
#ifdef HARD_REGNO_RENAME_OK
reg_names[reg], INSN_UID (last->insn));
if (last->need_caller_save_reg)
fprintf (rtl_dump_file, " crosses a call");
- }
+ }
if (best_new_reg == -1)
{
if (*this->loc == cc0_rtx)
p = &this->next_chain;
else
- {
+ {
int regno = REGNO (*this->loc);
int nregs = HARD_REGNO_NREGS (regno, GET_MODE (*this->loc));
int exact_match = (regno == this_regno && nregs == this_nregs);
if (! exact_match)
abort ();
- /* ??? Class NO_REGS can happen if the md file makes use of
+ /* ??? Class NO_REGS can happen if the md file makes use of
EXTRA_CONSTRAINTS to match registers. Which is arguably
wrong, but there we are. Since we know not what this may
be replaced with, terminate the chain. */
return;
case ZERO_EXTRACT:
- case SIGN_EXTRACT:
+ case SIGN_EXTRACT:
scan_rtx (insn, &XEXP (x, 0), class, action,
type == OP_IN ? OP_IN : OP_INOUT, earlyclobber);
scan_rtx (insn, &XEXP (x, 1), class, action, OP_IN, 0);
icode = recog_memoized (insn);
extract_insn (insn);
if (! constrain_operands (1))
- fatal_insn_not_found (insn);
+ fatal_insn_not_found (insn);
preprocess_constraints ();
alt = which_alternative;
n_ops = recog_data.n_operands;
recog_data.operand_type[i], 0);
/* Step 2: Close chains for which we have reads outside operands.
- We do this by munging all operands into CC0, and closing
+ We do this by munging all operands into CC0, and closing
everything remaining. */
for (i = 0; i < n_ops; i++)
{
old_operands[i] = recog_data.operand[i];
/* Don't squash match_operator or match_parallel here, since
- we don't know that all of the contained registers are
+ we don't know that all of the contained registers are
reachable by proper operands. */
if (recog_data.constraints[i][0] == '\0')
continue;
enum reg_class class = recog_op_alt[i][alt].class;
if (GET_CODE (op) == REG
- && REGNO (op) == ORIGINAL_REGNO (op))
+ && REGNO (op) == ORIGINAL_REGNO (op))
continue;
scan_rtx (insn, loc, class, mark_write, OP_OUT,
/* The following code does forward propagation of hard register copies.
The object is to eliminate as many dependencies as possible, so that
we have the most scheduling freedom. As a side effect, we also clean
- up some silly register allocation decisions made by reload. This
+ up some silly register allocation decisions made by reload. This
code may be obsoleted by a new register allocator. */
/* For each register, we have a list of registers that contain the same
- value. The OLDEST_REGNO field points to the head of the list, and
+ value. The OLDEST_REGNO field points to the head of the list, and
the NEXT_REGNO field runs through the list. The MODE field indicates
what mode the data is known to be in; this field is VOIDmode when the
register is not known to contain valid data. */
struct value_data *));
static bool replace_oldest_value_mem PARAMS ((rtx, rtx, struct value_data *));
static bool copyprop_hardreg_forward_1 PARAMS ((basic_block,
- struct value_data *));
+ struct value_data *));
extern void debug_value_data PARAMS ((struct value_data *));
#ifdef ENABLE_CHECKING
static void validate_value_data PARAMS ((struct value_data *));
else if ((next = vd->e[regno].next_regno) != INVALID_REGNUM)
{
for (i = next; i != INVALID_REGNUM; i = vd->e[i].next_regno)
- vd->e[i].oldest_regno = next;
+ vd->e[i].oldest_regno = next;
}
vd->e[regno].mode = VOIDmode;
kill_value (x, vd);
}
-/* Called through note_stores. If X is set, not clobbered, kill its
+/* Called through note_stores. If X is set, not clobbered, kill its
current value and install it as the root of its own value list. */
static void
{
kill_value (x, vd);
if (REG_P (x))
- set_value_regno (REGNO (x), GET_MODE (x), vd);
+ set_value_regno (REGNO (x), GET_MODE (x), vd);
}
}
if (locI)
changed |= replace_oldest_value_addr (locI, INDEX_REG_CLASS, mode,
- insn, vd);
+ insn, vd);
if (locB)
changed |= replace_oldest_value_addr (locB,
MODE_BASE_REG_CLASS (mode),
else if (fmt[i] == 'E')
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
changed |= replace_oldest_value_addr (&XVECEXP (x, i, j), class,
- mode, insn, vd);
+ mode, insn, vd);
}
return changed;
set = single_set (insn);
extract_insn (insn);
if (! constrain_operands (1))
- fatal_insn_not_found (insn);
+ fatal_insn_not_found (insn);
preprocess_constraints ();
alt = which_alternative;
n_ops = recog_data.n_operands;
fprintf (rtl_dump_file,
"insn %u: replaced reg %u with %u\n",
INSN_UID (insn), regno, REGNO (new));
- changed = true;
+ changed = true;
goto did_replacement;
}
}
}
else if (GET_CODE (recog_data.operand[i]) == MEM)
replaced = replace_oldest_value_mem (recog_data.operand[i],
- insn, vd);
+ insn, vd);
/* If we performed any replacement, update match_dups. */
if (replaced)
the end of the predecessor block. */
/* ??? Ought to use more intelligent queueing of blocks. */
if (bb->pred
- && ! bb->pred->pred_next
+ && ! bb->pred->pred_next
&& ! (bb->pred->flags & (EDGE_ABNORMAL_CALL | EDGE_EH))
&& bb->pred->src->index != ENTRY_BLOCK
&& bb->pred->src->index < b)
all_vd[b] = all_vd[bb->pred->src->index];
else
- init_value_data (all_vd + b);
+ init_value_data (all_vd + b);
if (copyprop_hardreg_forward_1 (bb, all_vd + b))
need_refresh = true;
static void set_type_quals PARAMS ((tree, int));
static void append_random_chars PARAMS ((char *));
-static int type_hash_eq PARAMS ((const void*, const void*));
-static unsigned int type_hash_hash PARAMS ((const void*));
+static int type_hash_eq PARAMS ((const void *, const void *));
+static unsigned int type_hash_hash PARAMS ((const void *));
static void print_type_hash_statistics PARAMS((void));
static void finish_vector_type PARAMS((tree));
static tree make_vector PARAMS ((enum machine_mode, tree, int));
case 'x': /* something random, like an identifier. */
{
- size_t length;
- length = (sizeof (struct tree_common)
- + TREE_CODE_LENGTH (code) * sizeof (char *));
- if (code == TREE_VEC)
- length += (TREE_VEC_LENGTH (node) - 1) * sizeof (char *);
- return length;
+ size_t length;
+ length = (sizeof (struct tree_common)
+ + TREE_CODE_LENGTH (code) * sizeof (char *));
+ if (code == TREE_VEC)
+ length += (TREE_VEC_LENGTH (node) - 1) * sizeof (char *);
+ return length;
}
default:
tree_node_kind kind;
#endif
struct tree_common ttmp;
-
+
/* We can't allocate a TREE_VEC without knowing how many elements
it will have. */
if (code == TREE_VEC)
abort ();
-
+
TREE_SET_CODE ((tree)&ttmp, code);
length = tree_size ((tree)&ttmp);
over1 |= TREE_OVERFLOW (value);
over2 |= TREE_CONSTANT_OVERFLOW (value);
}
-
+
TREE_OVERFLOW (v) = over1;
TREE_CONSTANT_OVERFLOW (v) = over2;
int len;
{
tree t;
- int length = (len-1) * sizeof (tree) + sizeof (struct tree_vec);
+ int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
#ifdef GATHER_STATISTICS
- tree_node_counts[(int)vec_kind]++;
- tree_node_sizes[(int)vec_kind] += length;
+ tree_node_counts[(int) vec_kind]++;
+ tree_node_sizes[(int) vec_kind] += length;
#endif
t = ggc_alloc_tree (length);
TREE_CHAIN (t1) = op2;
#ifdef ENABLE_TREE_CHECKING
for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
- if (t2 == t1)
- abort (); /* Circularity created. */
+ if (t2 == t1)
+ abort (); /* Circularity created. */
#endif
return op1;
}
#endif
#ifdef ENABLE_CHECKING
- if (TREE_CODE_CLASS (code) == '2'
+ if (TREE_CODE_CLASS (code) == '2'
|| TREE_CODE_CLASS (code) == '<'
|| TREE_CODE_LENGTH (code) != 1)
abort ();
build_type_attribute_variant (ttype, attribute)
tree ttype, attribute;
{
- if ( ! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
+ if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
{
unsigned int hashcode;
tree ntype;
return 1;
}
-/* Mark ARG (which is really a htab_t whose slots are trees) for
+/* Mark ARG (which is really a htab_t whose slots are trees) for
GC. */
void
attribute_list_equal (l1, l2)
tree l1, l2;
{
- return attribute_list_contained (l1, l2)
- && attribute_list_contained (l2, l1);
+ return attribute_list_contained (l1, l2)
+ && attribute_list_contained (l2, l1);
}
/* Given two lists of attributes, return true if list L2 is
return -1;
else if (tree_int_cst_lt (t2, t1))
return 1;
- else
+ else
return 0;
}
))
*p = '_';
}
-
+
/* Generate a name for a function unique to this translation unit.
TYPE is some string to identify the purpose of this function to the
linker or collect2. */
case CONSTRUCTOR:
{
if (AGGREGATE_TYPE_P (TREE_TYPE (init)))
- {
- tree aggr_init = TREE_OPERAND (init, 1);
-
- while (aggr_init)
- {
- if (! initializer_zerop (TREE_VALUE (aggr_init)))
- return false;
- aggr_init = TREE_CHAIN (aggr_init);
- }
- return true;
- }
+ {
+ tree aggr_init = TREE_OPERAND (init, 1);
+
+ while (aggr_init)
+ {
+ if (! initializer_zerop (TREE_VALUE (aggr_init)))
+ return false;
+ aggr_init = TREE_CHAIN (aggr_init);
+ }
+ return true;
+ }
return false;
}
default:
projects / platform / upstream / linaro-gcc.git / commitdiff