alias.c: Remove uses of "register" specifier in declarations of arguments and local...
2001-10-10 Stan Shebs <shebs@apple.com> * alias.c: Remove uses of "register" specifier in declarations of arguments and local variables. * c-common.c: Ditto. * c-convert.c: Ditto. * c-decl.c: Ditto. * c-format.c: Ditto. * c-semantics.c: Ditto. * c-typeck.c: Ditto. * caller-save.c: Ditto. * calls.c: Ditto. * cfg.c: Ditto. * cfgbuild.c: Ditto. * cfgrtl.c: Ditto. * collect2.c: Ditto. * combine.c: Ditto. * convert.c: Ditto. * cppexp.c: Ditto. * cppfiles.c: Ditto. * cse.c: Ditto. * dbxout.c: Ditto. * defaults.h: Ditto. * df.c: Ditto. * dwarf2out.c: Ditto. * dwarfout.c: Ditto. * emit-rtl.c: Ditto. * explow.c: Ditto. * expmed.c: Ditto. * expr.c: Ditto. * final.c: Ditto. * fix-header.c: Ditto. * floatlib.c: Ditto. * flow.c: Ditto. * fold-const.c: Ditto. * function.c: Ditto. * gcc.c: Ditto. * gcse.c: Ditto. * gen-protos.c: Ditto. * genattrtab.c: Ditto. * gencheck.c: Ditto. * genconfig.c: Ditto. * genemit.c: Ditto. * genextract.c: Ditto. * genflags.c: Ditto. * gengenrtl.c: Ditto. * genoutput.c: Ditto. * genpeep.c: Ditto. * genrecog.c: Ditto. * gensupport.c: Ditto. * global.c: Ditto. * gmon.c: Ditto. * graph.c: Ditto. * haifa-sched.c: Ditto. * hard-reg-set.h: Ditto. * hash.c: Ditto. * integrate.c: Ditto. * jump.c: Ditto. * lists.c: Ditto. * local-alloc.c: Ditto. * loop.c: Ditto. * mips-tdump.c: Ditto. * mips-tfile.c: Ditto. * optabs.c: Ditto. * prefix.c: Ditto. * print-rtl.c: Ditto. * read-rtl.c: Ditto. * real.c: Ditto. * recog.c: Ditto. * reg-stack.c: Ditto. * regclass.c: Ditto. * regmove.c: Ditto. * reload.c: Ditto. * reload1.c: Ditto. * reorg.c: Ditto. * resource.c: Ditto. * rtl.c: Ditto. * rtlanal.c: Ditto. * scan.c: Ditto. * sched-deps.c: Ditto. * sched-rgn.c: Ditto. * sdbout.c: Ditto. * simplify-rtx.c: Ditto. * stmt.c: Ditto. * stor-layout.c: Ditto. * toplev.c: Ditto. * tradcif.y: Ditto. * tradcpp.c: Ditto. * tree.c: Ditto. * unroll.c: Ditto. * varasm.c: Ditto. * xcoffout.c: Ditto. From-SVN: r46173
This commit is contained in:
parent
b83018caca
commit
b36948478c
|
@ -1,3 +1,96 @@
|
|||
2001-10-10 Stan Shebs <shebs@apple.com>
|
||||
|
||||
* alias.c: Remove uses of "register" specifier in declarations
|
||||
of arguments and local variables.
|
||||
* c-common.c: Ditto.
|
||||
* c-convert.c: Ditto.
|
||||
* c-decl.c: Ditto.
|
||||
* c-format.c: Ditto.
|
||||
* c-semantics.c: Ditto.
|
||||
* c-typeck.c: Ditto.
|
||||
* caller-save.c: Ditto.
|
||||
* calls.c: Ditto.
|
||||
* cfg.c: Ditto.
|
||||
* cfgbuild.c: Ditto.
|
||||
* cfgrtl.c: Ditto.
|
||||
* collect2.c: Ditto.
|
||||
* combine.c: Ditto.
|
||||
* convert.c: Ditto.
|
||||
* cppexp.c: Ditto.
|
||||
* cppfiles.c: Ditto.
|
||||
* cse.c: Ditto.
|
||||
* dbxout.c: Ditto.
|
||||
* defaults.h: Ditto.
|
||||
* df.c: Ditto.
|
||||
* dwarf2out.c: Ditto.
|
||||
* dwarfout.c: Ditto.
|
||||
* emit-rtl.c: Ditto.
|
||||
* explow.c: Ditto.
|
||||
* expmed.c: Ditto.
|
||||
* expr.c: Ditto.
|
||||
* final.c: Ditto.
|
||||
* fix-header.c: Ditto.
|
||||
* floatlib.c: Ditto.
|
||||
* flow.c: Ditto.
|
||||
* fold-const.c: Ditto.
|
||||
* function.c: Ditto.
|
||||
* gcc.c: Ditto.
|
||||
* gcse.c: Ditto.
|
||||
* gen-protos.c: Ditto.
|
||||
* genattrtab.c: Ditto.
|
||||
* gencheck.c: Ditto.
|
||||
* genconfig.c: Ditto.
|
||||
* genemit.c: Ditto.
|
||||
* genextract.c: Ditto.
|
||||
* genflags.c: Ditto.
|
||||
* gengenrtl.c: Ditto.
|
||||
* genoutput.c: Ditto.
|
||||
* genpeep.c: Ditto.
|
||||
* genrecog.c: Ditto.
|
||||
* gensupport.c: Ditto.
|
||||
* global.c: Ditto.
|
||||
* gmon.c: Ditto.
|
||||
* graph.c: Ditto.
|
||||
* haifa-sched.c: Ditto.
|
||||
* hard-reg-set.h: Ditto.
|
||||
* hash.c: Ditto.
|
||||
* integrate.c: Ditto.
|
||||
* jump.c: Ditto.
|
||||
* lists.c: Ditto.
|
||||
* local-alloc.c: Ditto.
|
||||
* loop.c: Ditto.
|
||||
* mips-tdump.c: Ditto.
|
||||
* mips-tfile.c: Ditto.
|
||||
* optabs.c: Ditto.
|
||||
* prefix.c: Ditto.
|
||||
* print-rtl.c: Ditto.
|
||||
* read-rtl.c: Ditto.
|
||||
* real.c: Ditto.
|
||||
* recog.c: Ditto.
|
||||
* reg-stack.c: Ditto.
|
||||
* regclass.c: Ditto.
|
||||
* regmove.c: Ditto.
|
||||
* reload.c: Ditto.
|
||||
* reload1.c: Ditto.
|
||||
* reorg.c: Ditto.
|
||||
* resource.c: Ditto.
|
||||
* rtl.c: Ditto.
|
||||
* rtlanal.c: Ditto.
|
||||
* scan.c: Ditto.
|
||||
* sched-deps.c: Ditto.
|
||||
* sched-rgn.c: Ditto.
|
||||
* sdbout.c: Ditto.
|
||||
* simplify-rtx.c: Ditto.
|
||||
* stmt.c: Ditto.
|
||||
* stor-layout.c: Ditto.
|
||||
* toplev.c: Ditto.
|
||||
* tradcif.y: Ditto.
|
||||
* tradcpp.c: Ditto.
|
||||
* tree.c: Ditto.
|
||||
* unroll.c: Ditto.
|
||||
* varasm.c: Ditto.
|
||||
* xcoffout.c: Ditto.
|
||||
|
||||
2001-10-10 Richard Henderson <rth@redhat.com>
|
||||
|
||||
* rtl.h (can_reverse_comparison_p): Remove.
|
||||
|
|
46
gcc/alias.c
46
gcc/alias.c
|
@ -714,7 +714,7 @@ get_frame_alias_set ()
|
|||
|
||||
static rtx
|
||||
find_base_value (src)
|
||||
register rtx src;
|
||||
rtx src;
|
||||
{
|
||||
unsigned int regno;
|
||||
switch (GET_CODE (src))
|
||||
|
@ -846,7 +846,7 @@ record_set (dest, set, data)
|
|||
rtx dest, set;
|
||||
void *data ATTRIBUTE_UNUSED;
|
||||
{
|
||||
register unsigned regno;
|
||||
unsigned regno;
|
||||
rtx src;
|
||||
|
||||
if (GET_CODE (dest) != REG)
|
||||
|
@ -1020,10 +1020,10 @@ static int
|
|||
rtx_equal_for_memref_p (x, y)
|
||||
rtx x, y;
|
||||
{
|
||||
register int i;
|
||||
register int j;
|
||||
register enum rtx_code code;
|
||||
register const char *fmt;
|
||||
int i;
|
||||
int j;
|
||||
enum rtx_code code;
|
||||
const char *fmt;
|
||||
|
||||
if (x == 0 && y == 0)
|
||||
return 1;
|
||||
|
@ -1149,9 +1149,9 @@ static rtx
|
|||
find_symbolic_term (x)
|
||||
rtx x;
|
||||
{
|
||||
register int i;
|
||||
register enum rtx_code code;
|
||||
register const char *fmt;
|
||||
int i;
|
||||
enum rtx_code code;
|
||||
const char *fmt;
|
||||
|
||||
code = GET_CODE (x);
|
||||
if (code == SYMBOL_REF || code == LABEL_REF)
|
||||
|
@ -1178,7 +1178,7 @@ find_symbolic_term (x)
|
|||
|
||||
static rtx
|
||||
find_base_term (x)
|
||||
register rtx x;
|
||||
rtx x;
|
||||
{
|
||||
cselib_val *val;
|
||||
struct elt_loc_list *l;
|
||||
|
@ -1452,7 +1452,7 @@ addr_side_effect_eval (addr, size, n_refs)
|
|||
|
||||
static int
|
||||
memrefs_conflict_p (xsize, x, ysize, y, c)
|
||||
register rtx x, y;
|
||||
rtx x, y;
|
||||
int xsize, ysize;
|
||||
HOST_WIDE_INT c;
|
||||
{
|
||||
|
@ -1737,7 +1737,7 @@ true_dependence (mem, mem_mode, x, varies)
|
|||
rtx x;
|
||||
int (*varies) PARAMS ((rtx, int));
|
||||
{
|
||||
register rtx x_addr, mem_addr;
|
||||
rtx x_addr, mem_addr;
|
||||
rtx base;
|
||||
|
||||
if (MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem))
|
||||
|
@ -1810,7 +1810,7 @@ canon_true_dependence (mem, mem_mode, mem_addr, x, varies)
|
|||
enum machine_mode mem_mode;
|
||||
int (*varies) PARAMS ((rtx, int));
|
||||
{
|
||||
register rtx x_addr;
|
||||
rtx x_addr;
|
||||
|
||||
if (MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem))
|
||||
return 1;
|
||||
|
@ -1929,8 +1929,8 @@ anti_dependence (mem, x)
|
|||
|
||||
int
|
||||
output_dependence (mem, x)
|
||||
register rtx mem;
|
||||
register rtx x;
|
||||
rtx mem;
|
||||
rtx x;
|
||||
{
|
||||
return write_dependence_p (mem, x, /*writep=*/1);
|
||||
}
|
||||
|
@ -1943,7 +1943,7 @@ nonlocal_mentioned_p (x)
|
|||
rtx x;
|
||||
{
|
||||
rtx base;
|
||||
register RTX_CODE code;
|
||||
RTX_CODE code;
|
||||
int regno;
|
||||
|
||||
code = GET_CODE (x);
|
||||
|
@ -2047,8 +2047,8 @@ nonlocal_mentioned_p (x)
|
|||
/* Recursively scan the operands of this expression. */
|
||||
|
||||
{
|
||||
register const char *fmt = GET_RTX_FORMAT (code);
|
||||
register int i;
|
||||
const char *fmt = GET_RTX_FORMAT (code);
|
||||
int i;
|
||||
|
||||
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
||||
{
|
||||
|
@ -2059,7 +2059,7 @@ nonlocal_mentioned_p (x)
|
|||
}
|
||||
else if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = 0; j < XVECLEN (x, i); j++)
|
||||
if (nonlocal_mentioned_p (XVECEXP (x, i, j)))
|
||||
return 1;
|
||||
|
@ -2116,7 +2116,7 @@ static HARD_REG_SET argument_registers;
|
|||
void
|
||||
init_alias_once ()
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
#ifndef OUTGOING_REGNO
|
||||
#define OUTGOING_REGNO(N) N
|
||||
|
@ -2140,9 +2140,9 @@ init_alias_analysis ()
|
|||
{
|
||||
int maxreg = max_reg_num ();
|
||||
int changed, pass;
|
||||
register int i;
|
||||
register unsigned int ui;
|
||||
register rtx insn;
|
||||
int i;
|
||||
unsigned int ui;
|
||||
rtx insn;
|
||||
|
||||
reg_known_value_size = maxreg;
|
||||
|
||||
|
|
|
@ -510,8 +510,8 @@ tree
|
|||
combine_strings (strings)
|
||||
tree strings;
|
||||
{
|
||||
register tree value, t;
|
||||
register int length = 1;
|
||||
tree value, t;
|
||||
int length = 1;
|
||||
int wide_length = 0;
|
||||
int wide_flag = 0;
|
||||
int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
|
||||
|
@ -521,7 +521,7 @@ combine_strings (strings)
|
|||
if (TREE_CHAIN (strings))
|
||||
{
|
||||
/* More than one in the chain, so concatenate. */
|
||||
register char *p, *q;
|
||||
char *p, *q;
|
||||
|
||||
/* Don't include the \0 at the end of each substring,
|
||||
except for the last one.
|
||||
|
@ -1502,7 +1502,7 @@ void
|
|||
binary_op_error (code)
|
||||
enum tree_code code;
|
||||
{
|
||||
register const char *opname;
|
||||
const char *opname;
|
||||
|
||||
switch (code)
|
||||
{
|
||||
|
@ -1581,7 +1581,7 @@ shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
|
|||
tree *restype_ptr;
|
||||
enum tree_code *rescode_ptr;
|
||||
{
|
||||
register tree type;
|
||||
tree type;
|
||||
tree op0 = *op0_ptr;
|
||||
tree op1 = *op1_ptr;
|
||||
int unsignedp0, unsignedp1;
|
||||
|
@ -1614,8 +1614,8 @@ shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
|
|||
if (TREE_CONSTANT (primop0)
|
||||
&& ! integer_zerop (primop1) && ! real_zerop (primop1))
|
||||
{
|
||||
register tree tem = primop0;
|
||||
register int temi = unsignedp0;
|
||||
tree tem = primop0;
|
||||
int temi = unsignedp0;
|
||||
primop0 = primop1;
|
||||
primop1 = tem;
|
||||
tem = op0;
|
||||
|
@ -2836,10 +2836,10 @@ int
|
|||
self_promoting_args_p (parms)
|
||||
tree parms;
|
||||
{
|
||||
register tree t;
|
||||
tree t;
|
||||
for (t = parms; t; t = TREE_CHAIN (t))
|
||||
{
|
||||
register tree type = TREE_VALUE (t);
|
||||
tree type = TREE_VALUE (t);
|
||||
|
||||
if (TREE_CHAIN (t) == 0 && type != void_type_node)
|
||||
return 0;
|
||||
|
|
|
@ -61,8 +61,8 @@ tree
|
|||
convert (type, expr)
|
||||
tree type, expr;
|
||||
{
|
||||
register tree e = expr;
|
||||
register enum tree_code code = TREE_CODE (type);
|
||||
tree e = expr;
|
||||
enum tree_code code = TREE_CODE (type);
|
||||
|
||||
if (type == TREE_TYPE (expr)
|
||||
|| TREE_CODE (expr) == ERROR_MARK
|
||||
|
|
122
gcc/c-decl.c
122
gcc/c-decl.c
|
@ -912,7 +912,7 @@ void
|
|||
pushlevel (tag_transparent)
|
||||
int tag_transparent;
|
||||
{
|
||||
register struct binding_level *newlevel = NULL_BINDING_LEVEL;
|
||||
struct binding_level *newlevel = NULL_BINDING_LEVEL;
|
||||
|
||||
/* If this is the top level of a function,
|
||||
just make sure that NAMED_LABELS is 0. */
|
||||
|
@ -988,7 +988,7 @@ poplevel (keep, reverse, functionbody)
|
|||
int reverse;
|
||||
int functionbody;
|
||||
{
|
||||
register tree link;
|
||||
tree link;
|
||||
/* The chain of decls was accumulated in reverse order.
|
||||
Put it into forward order, just for cleanliness. */
|
||||
tree decls;
|
||||
|
@ -1131,7 +1131,7 @@ poplevel (keep, reverse, functionbody)
|
|||
|
||||
for (link = named_labels; link; link = TREE_CHAIN (link))
|
||||
{
|
||||
register tree label = TREE_VALUE (link);
|
||||
tree label = TREE_VALUE (link);
|
||||
|
||||
if (DECL_INITIAL (label) == 0)
|
||||
{
|
||||
|
@ -1154,7 +1154,7 @@ poplevel (keep, reverse, functionbody)
|
|||
/* Pop the current level, and free the structure for reuse. */
|
||||
|
||||
{
|
||||
register struct binding_level *level = current_binding_level;
|
||||
struct binding_level *level = current_binding_level;
|
||||
current_binding_level = current_binding_level->level_chain;
|
||||
|
||||
level->level_chain = free_binding_level;
|
||||
|
@ -1248,7 +1248,7 @@ insert_block (block)
|
|||
|
||||
void
|
||||
set_block (block)
|
||||
register tree block;
|
||||
tree block;
|
||||
{
|
||||
current_binding_level->this_block = block;
|
||||
current_binding_level->names = chainon (current_binding_level->names,
|
||||
|
@ -1260,7 +1260,7 @@ set_block (block)
|
|||
void
|
||||
push_label_level ()
|
||||
{
|
||||
register struct binding_level *newlevel;
|
||||
struct binding_level *newlevel;
|
||||
|
||||
/* Reuse or create a struct for this binding level. */
|
||||
|
||||
|
@ -1288,7 +1288,7 @@ push_label_level ()
|
|||
void
|
||||
pop_label_level ()
|
||||
{
|
||||
register struct binding_level *level = label_level_chain;
|
||||
struct binding_level *level = label_level_chain;
|
||||
tree link, prev;
|
||||
|
||||
/* Clear out the definitions of the declared labels in this level.
|
||||
|
@ -1350,7 +1350,7 @@ void
|
|||
pushtag (name, type)
|
||||
tree name, type;
|
||||
{
|
||||
register struct binding_level *b;
|
||||
struct binding_level *b;
|
||||
|
||||
/* Find the proper binding level for this type tag. */
|
||||
|
||||
|
@ -1394,7 +1394,7 @@ pushtag (name, type)
|
|||
|
||||
static int
|
||||
duplicate_decls (newdecl, olddecl, different_binding_level)
|
||||
register tree newdecl, olddecl;
|
||||
tree newdecl, olddecl;
|
||||
int different_binding_level;
|
||||
{
|
||||
int types_match = comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
|
||||
|
@ -1610,12 +1610,12 @@ duplicate_decls (newdecl, olddecl, different_binding_level)
|
|||
&& DECL_INITIAL (newdecl) == 0)))
|
||||
{
|
||||
/* Classify the problem further. */
|
||||
register tree t = TYPE_ARG_TYPES (oldtype);
|
||||
tree t = TYPE_ARG_TYPES (oldtype);
|
||||
if (t == 0)
|
||||
t = TYPE_ARG_TYPES (newtype);
|
||||
for (; t; t = TREE_CHAIN (t))
|
||||
{
|
||||
register tree type = TREE_VALUE (t);
|
||||
tree type = TREE_VALUE (t);
|
||||
|
||||
if (TREE_CHAIN (t) == 0
|
||||
&& TYPE_MAIN_VARIANT (type) != void_type_node)
|
||||
|
@ -1677,8 +1677,8 @@ duplicate_decls (newdecl, olddecl, different_binding_level)
|
|||
&& TYPE_ARG_TYPES (newtype) != 0
|
||||
&& TYPE_ACTUAL_ARG_TYPES (oldtype) != 0)
|
||||
{
|
||||
register tree type, parm;
|
||||
register int nargs;
|
||||
tree type, parm;
|
||||
int nargs;
|
||||
/* Prototype decl follows defn w/o prototype. */
|
||||
|
||||
for (parm = TYPE_ACTUAL_ARG_TYPES (oldtype),
|
||||
|
@ -2028,7 +2028,7 @@ duplicate_decls (newdecl, olddecl, different_binding_level)
|
|||
/* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
|
||||
But preserve OLDDECL's DECL_UID. */
|
||||
{
|
||||
register unsigned olddecl_uid = DECL_UID (olddecl);
|
||||
unsigned olddecl_uid = DECL_UID (olddecl);
|
||||
|
||||
memcpy ((char *) olddecl + sizeof (struct tree_common),
|
||||
(char *) newdecl + sizeof (struct tree_common),
|
||||
|
@ -2055,9 +2055,9 @@ tree
|
|||
pushdecl (x)
|
||||
tree x;
|
||||
{
|
||||
register tree t;
|
||||
register tree name = DECL_NAME (x);
|
||||
register struct binding_level *b = current_binding_level;
|
||||
tree t;
|
||||
tree name = DECL_NAME (x);
|
||||
struct binding_level *b = current_binding_level;
|
||||
|
||||
/* Functions need the lang_decl data. */
|
||||
if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_LANG_SPECIFIC (x))
|
||||
|
@ -2505,8 +2505,8 @@ tree
|
|||
pushdecl_top_level (x)
|
||||
tree x;
|
||||
{
|
||||
register tree t;
|
||||
register struct binding_level *b = current_binding_level;
|
||||
tree t;
|
||||
struct binding_level *b = current_binding_level;
|
||||
|
||||
current_binding_level = global_binding_level;
|
||||
t = pushdecl (x);
|
||||
|
@ -2669,7 +2669,7 @@ tree
|
|||
lookup_label (id)
|
||||
tree id;
|
||||
{
|
||||
register tree decl = IDENTIFIER_LABEL_VALUE (id);
|
||||
tree decl = IDENTIFIER_LABEL_VALUE (id);
|
||||
|
||||
if (current_function_decl == 0)
|
||||
{
|
||||
|
@ -2719,11 +2719,11 @@ tree
|
|||
shadow_label (name)
|
||||
tree name;
|
||||
{
|
||||
register tree decl = IDENTIFIER_LABEL_VALUE (name);
|
||||
tree decl = IDENTIFIER_LABEL_VALUE (name);
|
||||
|
||||
if (decl != 0)
|
||||
{
|
||||
register tree dup;
|
||||
tree dup;
|
||||
|
||||
/* Check to make sure that the label hasn't already been declared
|
||||
at this label scope */
|
||||
|
@ -2843,12 +2843,12 @@ lookup_tag (code, name, binding_level, thislevel_only)
|
|||
tree name;
|
||||
int thislevel_only;
|
||||
{
|
||||
register struct binding_level *level;
|
||||
struct binding_level *level;
|
||||
int thislevel = 1;
|
||||
|
||||
for (level = binding_level; level; level = level->level_chain)
|
||||
{
|
||||
register tree tail;
|
||||
tree tail;
|
||||
for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
|
||||
{
|
||||
if (TREE_PURPOSE (tail) == name)
|
||||
|
@ -2902,11 +2902,11 @@ static tree
|
|||
lookup_tag_reverse (type)
|
||||
tree type;
|
||||
{
|
||||
register struct binding_level *level;
|
||||
struct binding_level *level;
|
||||
|
||||
for (level = current_binding_level; level; level = level->level_chain)
|
||||
{
|
||||
register tree tail;
|
||||
tree tail;
|
||||
for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
|
||||
{
|
||||
if (TREE_VALUE (tail) == type)
|
||||
|
@ -2925,7 +2925,7 @@ tree
|
|||
lookup_name (name)
|
||||
tree name;
|
||||
{
|
||||
register tree val;
|
||||
tree val;
|
||||
|
||||
if (current_binding_level != global_binding_level
|
||||
&& IDENTIFIER_LOCAL_VALUE (name))
|
||||
|
@ -2941,7 +2941,7 @@ tree
|
|||
lookup_name_current_level (name)
|
||||
tree name;
|
||||
{
|
||||
register tree t;
|
||||
tree t;
|
||||
|
||||
if (current_binding_level == global_binding_level)
|
||||
return IDENTIFIER_GLOBAL_VALUE (name);
|
||||
|
@ -2983,7 +2983,7 @@ mark_binding_level (arg)
|
|||
void
|
||||
init_decl_processing ()
|
||||
{
|
||||
register tree endlink;
|
||||
tree endlink;
|
||||
tree ptr_ftype_void, ptr_ftype_ptr;
|
||||
|
||||
current_function_decl = NULL;
|
||||
|
@ -3210,7 +3210,7 @@ shadow_tag_warned (declspecs, warned)
|
|||
no pedwarn. */
|
||||
{
|
||||
int found_tag = 0;
|
||||
register tree link;
|
||||
tree link;
|
||||
tree specs, attrs;
|
||||
|
||||
pending_invalid_xref = 0;
|
||||
|
@ -3221,15 +3221,15 @@ shadow_tag_warned (declspecs, warned)
|
|||
|
||||
for (link = specs; link; link = TREE_CHAIN (link))
|
||||
{
|
||||
register tree value = TREE_VALUE (link);
|
||||
register enum tree_code code = TREE_CODE (value);
|
||||
tree value = TREE_VALUE (link);
|
||||
enum tree_code code = TREE_CODE (value);
|
||||
|
||||
if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
|
||||
/* Used to test also that TYPE_SIZE (value) != 0.
|
||||
That caused warning for `struct foo;' at top level in the file. */
|
||||
{
|
||||
register tree name = lookup_tag_reverse (value);
|
||||
register tree t;
|
||||
tree name = lookup_tag_reverse (value);
|
||||
tree t;
|
||||
|
||||
found_tag++;
|
||||
|
||||
|
@ -3376,7 +3376,7 @@ start_decl (declarator, declspecs, initialized, attributes)
|
|||
{
|
||||
tree decl = grokdeclarator (declarator, declspecs,
|
||||
NORMAL, initialized);
|
||||
register tree tem;
|
||||
tree tem;
|
||||
|
||||
if (warn_main > 0 && TREE_CODE (decl) != FUNCTION_DECL
|
||||
&& MAIN_NAME_P (DECL_NAME (decl)))
|
||||
|
@ -3516,7 +3516,7 @@ finish_decl (decl, init, asmspec_tree)
|
|||
tree decl, init;
|
||||
tree asmspec_tree;
|
||||
{
|
||||
register tree type = TREE_TYPE (decl);
|
||||
tree type = TREE_TYPE (decl);
|
||||
int was_incomplete = (DECL_SIZE (decl) == 0);
|
||||
const char *asmspec = 0;
|
||||
|
||||
|
@ -3789,7 +3789,7 @@ complete_array_type (type, initial_value, do_default)
|
|||
tree initial_value;
|
||||
int do_default;
|
||||
{
|
||||
register tree maxindex = NULL_TREE;
|
||||
tree maxindex = NULL_TREE;
|
||||
int value = 0;
|
||||
|
||||
if (initial_value)
|
||||
|
@ -3918,7 +3918,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized)
|
|||
/* Look inside a declarator for the name being declared
|
||||
and get it as a string, for an error message. */
|
||||
{
|
||||
register tree decl = declarator;
|
||||
tree decl = declarator;
|
||||
name = 0;
|
||||
|
||||
while (decl)
|
||||
|
@ -3980,7 +3980,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized)
|
|||
|
||||
for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
|
||||
{
|
||||
register tree id = TREE_VALUE (spec);
|
||||
tree id = TREE_VALUE (spec);
|
||||
|
||||
if (id == ridpointers[(int) RID_INT])
|
||||
explicit_int = 1;
|
||||
|
@ -4022,7 +4022,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized)
|
|||
/* Built-in types come as identifiers. */
|
||||
else if (TREE_CODE (id) == IDENTIFIER_NODE)
|
||||
{
|
||||
register tree t = lookup_name (id);
|
||||
tree t = lookup_name (id);
|
||||
if (TREE_TYPE (t) == error_mark_node)
|
||||
;
|
||||
else if (!t || TREE_CODE (t) != TYPE_DECL)
|
||||
|
@ -4376,8 +4376,8 @@ grokdeclarator (declarator, declspecs, decl_context, initialized)
|
|||
}
|
||||
else if (TREE_CODE (declarator) == ARRAY_REF)
|
||||
{
|
||||
register tree itype = NULL_TREE;
|
||||
register tree size = TREE_OPERAND (declarator, 1);
|
||||
tree itype = NULL_TREE;
|
||||
tree size = TREE_OPERAND (declarator, 1);
|
||||
/* The index is a signed object `sizetype' bits wide. */
|
||||
tree index_type = signed_type (sizetype);
|
||||
|
||||
|
@ -4613,7 +4613,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized)
|
|||
the FUNCTION_TYPE node itself. */
|
||||
|
||||
{
|
||||
register tree link;
|
||||
tree link;
|
||||
|
||||
for (link = last_function_parm_tags;
|
||||
link;
|
||||
|
@ -4641,7 +4641,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized)
|
|||
|
||||
if (TREE_TYPE (declarator))
|
||||
{
|
||||
register tree typemodlist;
|
||||
tree typemodlist;
|
||||
int erred = 0;
|
||||
|
||||
constp = 0;
|
||||
|
@ -5155,8 +5155,8 @@ tree
|
|||
get_parm_info (void_at_end)
|
||||
int void_at_end;
|
||||
{
|
||||
register tree decl, t;
|
||||
register tree types = 0;
|
||||
tree decl, t;
|
||||
tree types = 0;
|
||||
int erred = 0;
|
||||
tree tags = gettags ();
|
||||
tree parms = getdecls ();
|
||||
|
@ -5300,7 +5300,7 @@ xref_tag (code, name)
|
|||
/* If a cross reference is requested, look up the type
|
||||
already defined for this tag and return it. */
|
||||
|
||||
register tree ref = lookup_tag (code, name, current_binding_level, 0);
|
||||
tree ref = lookup_tag (code, name, current_binding_level, 0);
|
||||
/* If this is the right type of tag, return what we found.
|
||||
(This reference will be shadowed by shadow_tag later if appropriate.)
|
||||
If this is the wrong type of tag, do not return it. If it was the
|
||||
|
@ -5351,7 +5351,7 @@ start_struct (code, name)
|
|||
/* If there is already a tag defined at this binding level
|
||||
(as a forward reference), just return it. */
|
||||
|
||||
register tree ref = 0;
|
||||
tree ref = 0;
|
||||
|
||||
if (name != 0)
|
||||
ref = lookup_tag (code, name, current_binding_level, 1);
|
||||
|
@ -5423,7 +5423,7 @@ finish_struct (t, fieldlist, attributes)
|
|||
tree fieldlist;
|
||||
tree attributes;
|
||||
{
|
||||
register tree x;
|
||||
tree x;
|
||||
int toplevel = global_binding_level == current_binding_level;
|
||||
int saw_named_field;
|
||||
|
||||
|
@ -5623,7 +5623,7 @@ finish_struct (t, fieldlist, attributes)
|
|||
x = TREE_CHAIN (x);
|
||||
else
|
||||
{
|
||||
register tree y = fieldlist;
|
||||
tree y = fieldlist;
|
||||
|
||||
while (1)
|
||||
{
|
||||
|
@ -5740,7 +5740,7 @@ tree
|
|||
start_enum (name)
|
||||
tree name;
|
||||
{
|
||||
register tree enumtype = 0;
|
||||
tree enumtype = 0;
|
||||
|
||||
/* If this is the real definition for a previous forward reference,
|
||||
fill in the contents in the same object that used to be the
|
||||
|
@ -5788,7 +5788,7 @@ finish_enum (enumtype, values, attributes)
|
|||
tree values;
|
||||
tree attributes;
|
||||
{
|
||||
register tree pair, tem;
|
||||
tree pair, tem;
|
||||
tree minnode = 0, maxnode = 0, enum_value_type;
|
||||
int precision, unsign;
|
||||
int toplevel = (global_binding_level == current_binding_level);
|
||||
|
@ -5919,7 +5919,7 @@ tree
|
|||
build_enumerator (name, value)
|
||||
tree name, value;
|
||||
{
|
||||
register tree decl, type;
|
||||
tree decl, type;
|
||||
|
||||
/* Validate and default VALUE. */
|
||||
|
||||
|
@ -6235,8 +6235,8 @@ c_mark_varargs ()
|
|||
void
|
||||
store_parm_decls ()
|
||||
{
|
||||
register tree fndecl = current_function_decl;
|
||||
register tree parm;
|
||||
tree fndecl = current_function_decl;
|
||||
tree parm;
|
||||
|
||||
/* This is either a chain of PARM_DECLs (if a prototype was used)
|
||||
or a list of IDENTIFIER_NODEs (for an old-fashioned C definition). */
|
||||
|
@ -6246,7 +6246,7 @@ store_parm_decls ()
|
|||
tree parmtags = current_function_parm_tags;
|
||||
|
||||
/* This is a chain of PARM_DECLs from old-style parm declarations. */
|
||||
register tree parmdecls = getdecls ();
|
||||
tree parmdecls = getdecls ();
|
||||
|
||||
/* This is a chain of any other decls that came in among the parm
|
||||
declarations. If a parm is declared with enum {foo, bar} x;
|
||||
|
@ -6266,7 +6266,7 @@ store_parm_decls ()
|
|||
except record them as in effect
|
||||
and complain if any redundant old-style parm decls were written. */
|
||||
|
||||
register tree next;
|
||||
tree next;
|
||||
tree others = 0;
|
||||
|
||||
prototype = 1;
|
||||
|
@ -6372,7 +6372,7 @@ store_parm_decls ()
|
|||
|
||||
for (parm = specparms; parm; parm = TREE_CHAIN (parm))
|
||||
{
|
||||
register tree tail, found = NULL;
|
||||
tree tail, found = NULL;
|
||||
|
||||
if (TREE_VALUE (parm) == 0)
|
||||
{
|
||||
|
@ -6484,7 +6484,7 @@ store_parm_decls ()
|
|||
parm = specparms;
|
||||
DECL_ARGUMENTS (fndecl) = 0;
|
||||
{
|
||||
register tree last;
|
||||
tree last;
|
||||
for (last = 0; parm; parm = TREE_CHAIN (parm))
|
||||
if (TREE_PURPOSE (parm))
|
||||
{
|
||||
|
@ -6503,7 +6503,7 @@ store_parm_decls ()
|
|||
|
||||
if (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
|
||||
{
|
||||
register tree type;
|
||||
tree type;
|
||||
for (parm = DECL_ARGUMENTS (fndecl),
|
||||
type = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
|
||||
parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type))
|
||||
|
@ -6671,7 +6671,7 @@ void
|
|||
finish_function (nested)
|
||||
int nested;
|
||||
{
|
||||
register tree fndecl = current_function_decl;
|
||||
tree fndecl = current_function_decl;
|
||||
|
||||
/* TREE_READONLY (fndecl) = 1;
|
||||
This caused &foo to be of type ptr-to-const-function
|
||||
|
|
|
@ -2362,8 +2362,8 @@ check_format_types (status, types)
|
|||
continue;
|
||||
/* Now we have a type mismatch. */
|
||||
{
|
||||
register const char *this;
|
||||
register const char *that;
|
||||
const char *this;
|
||||
const char *that;
|
||||
|
||||
this = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (wanted_type)));
|
||||
that = 0;
|
||||
|
|
|
@ -170,9 +170,9 @@ finish_stmt_tree (t)
|
|||
tree
|
||||
build_stmt VPARAMS ((enum tree_code code, ...))
|
||||
{
|
||||
register tree t;
|
||||
register int length;
|
||||
register int i;
|
||||
tree t;
|
||||
int length;
|
||||
int i;
|
||||
|
||||
VA_OPEN (p, code);
|
||||
VA_FIXEDARG (p, enum tree_code, code);
|
||||
|
|
137
gcc/c-typeck.c
137
gcc/c-typeck.c
|
@ -191,8 +191,8 @@ tree
|
|||
common_type (t1, t2)
|
||||
tree t1, t2;
|
||||
{
|
||||
register enum tree_code code1;
|
||||
register enum tree_code code2;
|
||||
enum tree_code code1;
|
||||
enum tree_code code2;
|
||||
tree attributes;
|
||||
|
||||
/* Save time if the two types are the same. */
|
||||
|
@ -436,8 +436,8 @@ int
|
|||
comptypes (type1, type2)
|
||||
tree type1, type2;
|
||||
{
|
||||
register tree t1 = type1;
|
||||
register tree t2 = type2;
|
||||
tree t1 = type1;
|
||||
tree t2 = type2;
|
||||
int attrval, val;
|
||||
|
||||
/* Suppress errors caused by previously reported errors. */
|
||||
|
@ -847,8 +847,8 @@ tree
|
|||
default_conversion (exp)
|
||||
tree exp;
|
||||
{
|
||||
register tree type = TREE_TYPE (exp);
|
||||
register enum tree_code code = TREE_CODE (type);
|
||||
tree type = TREE_TYPE (exp);
|
||||
enum tree_code code = TREE_CODE (type);
|
||||
|
||||
/* Constants can be used directly unless they're not loadable. */
|
||||
if (TREE_CODE (exp) == CONST_DECL)
|
||||
|
@ -924,7 +924,7 @@ default_conversion (exp)
|
|||
}
|
||||
if (code == ARRAY_TYPE)
|
||||
{
|
||||
register tree adr;
|
||||
tree adr;
|
||||
tree restype = TREE_TYPE (type);
|
||||
tree ptrtype;
|
||||
int constp = 0;
|
||||
|
@ -1091,10 +1091,10 @@ tree
|
|||
build_component_ref (datum, component)
|
||||
tree datum, component;
|
||||
{
|
||||
register tree type = TREE_TYPE (datum);
|
||||
register enum tree_code code = TREE_CODE (type);
|
||||
register tree field = NULL;
|
||||
register tree ref;
|
||||
tree type = TREE_TYPE (datum);
|
||||
enum tree_code code = TREE_CODE (type);
|
||||
tree field = NULL;
|
||||
tree ref;
|
||||
|
||||
/* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference inside it
|
||||
unless we are not to support things not strictly ANSI. */
|
||||
|
@ -1178,8 +1178,8 @@ build_indirect_ref (ptr, errorstring)
|
|||
tree ptr;
|
||||
const char *errorstring;
|
||||
{
|
||||
register tree pointer = default_conversion (ptr);
|
||||
register tree type = TREE_TYPE (pointer);
|
||||
tree pointer = default_conversion (ptr);
|
||||
tree type = TREE_TYPE (pointer);
|
||||
|
||||
if (TREE_CODE (type) == POINTER_TYPE)
|
||||
{
|
||||
|
@ -1191,8 +1191,7 @@ build_indirect_ref (ptr, errorstring)
|
|||
else
|
||||
{
|
||||
tree t = TREE_TYPE (type);
|
||||
register tree ref = build1 (INDIRECT_REF,
|
||||
TYPE_MAIN_VARIANT (t), pointer);
|
||||
tree ref = build1 (INDIRECT_REF, TYPE_MAIN_VARIANT (t), pointer);
|
||||
|
||||
if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
|
||||
{
|
||||
|
@ -1462,8 +1461,8 @@ tree
|
|||
build_function_call (function, params)
|
||||
tree function, params;
|
||||
{
|
||||
register tree fntype, fundecl = 0;
|
||||
register tree coerced_params;
|
||||
tree fntype, fundecl = 0;
|
||||
tree coerced_params;
|
||||
tree name = NULL_TREE, assembler_name = NULL_TREE, result;
|
||||
|
||||
/* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
|
||||
|
@ -1559,8 +1558,8 @@ static tree
|
|||
convert_arguments (typelist, values, name, fundecl)
|
||||
tree typelist, values, name, fundecl;
|
||||
{
|
||||
register tree typetail, valtail;
|
||||
register tree result = NULL;
|
||||
tree typetail, valtail;
|
||||
tree result = NULL;
|
||||
int parmnum;
|
||||
|
||||
/* Scan the given expressions and types, producing individual
|
||||
|
@ -1570,8 +1569,8 @@ convert_arguments (typelist, values, name, fundecl)
|
|||
valtail;
|
||||
valtail = TREE_CHAIN (valtail), parmnum++)
|
||||
{
|
||||
register tree type = typetail ? TREE_VALUE (typetail) : 0;
|
||||
register tree val = TREE_VALUE (valtail);
|
||||
tree type = typetail ? TREE_VALUE (typetail) : 0;
|
||||
tree val = TREE_VALUE (valtail);
|
||||
|
||||
if (type == void_type_node)
|
||||
{
|
||||
|
@ -1866,17 +1865,17 @@ build_binary_op (code, orig_op0, orig_op1, convert_p)
|
|||
int convert_p;
|
||||
{
|
||||
tree type0, type1;
|
||||
register enum tree_code code0, code1;
|
||||
enum tree_code code0, code1;
|
||||
tree op0, op1;
|
||||
|
||||
/* Expression code to give to the expression when it is built.
|
||||
Normally this is CODE, which is what the caller asked for,
|
||||
but in some special cases we change it. */
|
||||
register enum tree_code resultcode = code;
|
||||
enum tree_code resultcode = code;
|
||||
|
||||
/* Data type in which the computation is to be performed.
|
||||
In the simplest cases this is the common type of the arguments. */
|
||||
register tree result_type = NULL;
|
||||
tree result_type = NULL;
|
||||
|
||||
/* Nonzero means operands have already been type-converted
|
||||
in whatever way is necessary.
|
||||
|
@ -2164,8 +2163,8 @@ build_binary_op (code, orig_op0, orig_op1, convert_p)
|
|||
short_compare = 1;
|
||||
else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
|
||||
{
|
||||
register tree tt0 = TREE_TYPE (type0);
|
||||
register tree tt1 = TREE_TYPE (type1);
|
||||
tree tt0 = TREE_TYPE (type0);
|
||||
tree tt1 = TREE_TYPE (type1);
|
||||
/* Anything compares with void *. void * compares with anything.
|
||||
Otherwise, the targets must be compatible
|
||||
and both must be object or both incomplete. */
|
||||
|
@ -2585,8 +2584,8 @@ build_binary_op (code, orig_op0, orig_op1, convert_p)
|
|||
build_type = result_type;
|
||||
|
||||
{
|
||||
register tree result = build (resultcode, build_type, op0, op1);
|
||||
register tree folded;
|
||||
tree result = build (resultcode, build_type, op0, op1);
|
||||
tree folded;
|
||||
|
||||
folded = fold (result);
|
||||
if (folded == result)
|
||||
|
@ -2603,16 +2602,16 @@ build_binary_op (code, orig_op0, orig_op1, convert_p)
|
|||
static tree
|
||||
pointer_int_sum (resultcode, ptrop, intop)
|
||||
enum tree_code resultcode;
|
||||
register tree ptrop, intop;
|
||||
tree ptrop, intop;
|
||||
{
|
||||
tree size_exp;
|
||||
|
||||
register tree result;
|
||||
register tree folded;
|
||||
tree result;
|
||||
tree folded;
|
||||
|
||||
/* The result is a pointer of the same type that is being added. */
|
||||
|
||||
register tree result_type = TREE_TYPE (ptrop);
|
||||
tree result_type = TREE_TYPE (ptrop);
|
||||
|
||||
if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
|
||||
{
|
||||
|
@ -2691,9 +2690,9 @@ pointer_int_sum (resultcode, ptrop, intop)
|
|||
|
||||
static tree
|
||||
pointer_diff (op0, op1)
|
||||
register tree op0, op1;
|
||||
tree op0, op1;
|
||||
{
|
||||
register tree result, folded;
|
||||
tree result, folded;
|
||||
tree restype = ptrdiff_type_node;
|
||||
|
||||
tree target_type = TREE_TYPE (TREE_TYPE (op0));
|
||||
|
@ -2778,9 +2777,9 @@ build_unary_op (code, xarg, noconvert)
|
|||
int noconvert;
|
||||
{
|
||||
/* No default_conversion here. It causes trouble for ADDR_EXPR. */
|
||||
register tree arg = xarg;
|
||||
register tree argtype = 0;
|
||||
register enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
|
||||
tree arg = xarg;
|
||||
tree argtype = 0;
|
||||
enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
|
||||
tree val;
|
||||
|
||||
if (typecode == ERROR_MARK)
|
||||
|
@ -2927,7 +2926,7 @@ build_unary_op (code, xarg, noconvert)
|
|||
}
|
||||
|
||||
{
|
||||
register tree inc;
|
||||
tree inc;
|
||||
tree result_type = TREE_TYPE (arg);
|
||||
|
||||
arg = get_unwidened (arg, 0);
|
||||
|
@ -3188,7 +3187,7 @@ int
|
|||
lvalue_p (ref)
|
||||
tree ref;
|
||||
{
|
||||
register enum tree_code code = TREE_CODE (ref);
|
||||
enum tree_code code = TREE_CODE (ref);
|
||||
|
||||
switch (code)
|
||||
{
|
||||
|
@ -3327,7 +3326,7 @@ int
|
|||
mark_addressable (exp)
|
||||
tree exp;
|
||||
{
|
||||
register tree x = exp;
|
||||
tree x = exp;
|
||||
while (1)
|
||||
switch (TREE_CODE (x))
|
||||
{
|
||||
|
@ -3412,11 +3411,11 @@ tree
|
|||
build_conditional_expr (ifexp, op1, op2)
|
||||
tree ifexp, op1, op2;
|
||||
{
|
||||
register tree type1;
|
||||
register tree type2;
|
||||
register enum tree_code code1;
|
||||
register enum tree_code code2;
|
||||
register tree result_type = NULL;
|
||||
tree type1;
|
||||
tree type2;
|
||||
enum tree_code code1;
|
||||
enum tree_code code2;
|
||||
tree result_type = NULL;
|
||||
tree orig_op1 = op1, orig_op2 = op2;
|
||||
|
||||
ifexp = truthvalue_conversion (default_conversion (ifexp));
|
||||
|
@ -3600,7 +3599,7 @@ internal_build_compound_expr (list, first_p)
|
|||
tree list;
|
||||
int first_p;
|
||||
{
|
||||
register tree rest;
|
||||
tree rest;
|
||||
|
||||
if (TREE_CHAIN (list) == 0)
|
||||
{
|
||||
|
@ -3654,10 +3653,10 @@ internal_build_compound_expr (list, first_p)
|
|||
|
||||
tree
|
||||
build_c_cast (type, expr)
|
||||
register tree type;
|
||||
tree type;
|
||||
tree expr;
|
||||
{
|
||||
register tree value = expr;
|
||||
tree value = expr;
|
||||
|
||||
if (type == error_mark_node || expr == error_mark_node)
|
||||
return error_mark_node;
|
||||
|
@ -3856,7 +3855,7 @@ build_modify_expr (lhs, modifycode, rhs)
|
|||
tree lhs, rhs;
|
||||
enum tree_code modifycode;
|
||||
{
|
||||
register tree result;
|
||||
tree result;
|
||||
tree newrhs;
|
||||
tree lhstype = TREE_TYPE (lhs);
|
||||
tree olhstype = lhstype;
|
||||
|
@ -4037,9 +4036,9 @@ convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
|
|||
tree fundecl, funname;
|
||||
int parmnum;
|
||||
{
|
||||
register enum tree_code codel = TREE_CODE (type);
|
||||
register tree rhstype;
|
||||
register enum tree_code coder;
|
||||
enum tree_code codel = TREE_CODE (type);
|
||||
tree rhstype;
|
||||
enum tree_code coder;
|
||||
|
||||
/* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
|
||||
/* Do not use STRIP_NOPS here. We do not want an enumerator
|
||||
|
@ -4124,8 +4123,8 @@ convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
|
|||
|
||||
if (coder == POINTER_TYPE)
|
||||
{
|
||||
register tree ttl = TREE_TYPE (memb_type);
|
||||
register tree ttr = TREE_TYPE (rhstype);
|
||||
tree ttl = TREE_TYPE (memb_type);
|
||||
tree ttr = TREE_TYPE (rhstype);
|
||||
|
||||
/* Any non-function converts to a [const][volatile] void *
|
||||
and vice versa; otherwise, targets must be the same.
|
||||
|
@ -4166,8 +4165,8 @@ convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
|
|||
{
|
||||
/* We have only a marginally acceptable member type;
|
||||
it needs a warning. */
|
||||
register tree ttl = TREE_TYPE (marginal_memb_type);
|
||||
register tree ttr = TREE_TYPE (rhstype);
|
||||
tree ttl = TREE_TYPE (marginal_memb_type);
|
||||
tree ttr = TREE_TYPE (rhstype);
|
||||
|
||||
/* Const and volatile mean something different for function
|
||||
types, so the usual warnings are not appropriate. */
|
||||
|
@ -4200,8 +4199,8 @@ convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
|
|||
else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
|
||||
&& (coder == POINTER_TYPE || coder == REFERENCE_TYPE))
|
||||
{
|
||||
register tree ttl = TREE_TYPE (type);
|
||||
register tree ttr = TREE_TYPE (rhstype);
|
||||
tree ttl = TREE_TYPE (type);
|
||||
tree ttr = TREE_TYPE (rhstype);
|
||||
|
||||
/* Any non-function converts to a [const][volatile] void *
|
||||
and vice versa; otherwise, targets must be the same.
|
||||
|
@ -4386,7 +4385,7 @@ void
|
|||
store_init_value (decl, init)
|
||||
tree decl, init;
|
||||
{
|
||||
register tree value, type;
|
||||
tree value, type;
|
||||
|
||||
/* If variable's type was invalidly declared, just ignore it. */
|
||||
|
||||
|
@ -4539,8 +4538,8 @@ push_array_bounds (bounds)
|
|||
static int
|
||||
spelling_length ()
|
||||
{
|
||||
register int size = 0;
|
||||
register struct spelling *p;
|
||||
int size = 0;
|
||||
struct spelling *p;
|
||||
|
||||
for (p = spelling_base; p < spelling; p++)
|
||||
{
|
||||
|
@ -4557,10 +4556,10 @@ spelling_length ()
|
|||
|
||||
static char *
|
||||
print_spelling (buffer)
|
||||
register char *buffer;
|
||||
char *buffer;
|
||||
{
|
||||
register char *d = buffer;
|
||||
register struct spelling *p;
|
||||
char *d = buffer;
|
||||
struct spelling *p;
|
||||
|
||||
for (p = spelling_base; p < spelling; p++)
|
||||
if (p->kind == SPELLING_BOUNDS)
|
||||
|
@ -4570,7 +4569,7 @@ print_spelling (buffer)
|
|||
}
|
||||
else
|
||||
{
|
||||
register const char *s;
|
||||
const char *s;
|
||||
if (p->kind == SPELLING_MEMBER)
|
||||
*d++ = '.';
|
||||
for (s = p->u.s; (*d = *s++); d++)
|
||||
|
@ -6854,10 +6853,10 @@ c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
|
|||
int line;
|
||||
{
|
||||
int noutputs = list_length (outputs);
|
||||
register int i;
|
||||
int i;
|
||||
/* o[I] is the place that output number I should be written. */
|
||||
register tree *o = (tree *) alloca (noutputs * sizeof (tree));
|
||||
register tree tail;
|
||||
tree *o = (tree *) alloca (noutputs * sizeof (tree));
|
||||
tree tail;
|
||||
|
||||
/* Record the contents of OUTPUTS before it is modified. */
|
||||
for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
|
||||
|
@ -7022,7 +7021,7 @@ tree
|
|||
c_start_case (exp)
|
||||
tree exp;
|
||||
{
|
||||
register enum tree_code code;
|
||||
enum tree_code code;
|
||||
tree type;
|
||||
struct c_switch *cs;
|
||||
|
||||
|
|
|
@ -482,7 +482,7 @@ mark_set_regs (reg, setter, data)
|
|||
rtx setter ATTRIBUTE_UNUSED;
|
||||
void *data ATTRIBUTE_UNUSED;
|
||||
{
|
||||
register int regno, endregno, i;
|
||||
int regno, endregno, i;
|
||||
enum machine_mode mode = GET_MODE (reg);
|
||||
|
||||
if (GET_CODE (reg) == SUBREG)
|
||||
|
@ -515,7 +515,7 @@ add_stored_regs (reg, setter, data)
|
|||
rtx setter;
|
||||
void *data;
|
||||
{
|
||||
register int regno, endregno, i;
|
||||
int regno, endregno, i;
|
||||
enum machine_mode mode = GET_MODE (reg);
|
||||
int offset = 0;
|
||||
|
||||
|
|
30
gcc/calls.c
30
gcc/calls.c
|
@ -256,7 +256,7 @@ calls_function_1 (exp, which)
|
|||
tree exp;
|
||||
int which;
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
enum tree_code code = TREE_CODE (exp);
|
||||
int class = TREE_CODE_CLASS (code);
|
||||
int length = first_rtl_op (code);
|
||||
|
@ -308,8 +308,8 @@ calls_function_1 (exp, which)
|
|||
|
||||
case BLOCK:
|
||||
{
|
||||
register tree local;
|
||||
register tree subblock;
|
||||
tree local;
|
||||
tree subblock;
|
||||
|
||||
for (local = BLOCK_VARS (exp); local; local = TREE_CHAIN (local))
|
||||
if (DECL_INITIAL (local) != 0
|
||||
|
@ -2156,8 +2156,8 @@ expand_call (exp, target, ignore)
|
|||
int old_inhibit_defer_pop = inhibit_defer_pop;
|
||||
int old_stack_allocated;
|
||||
rtx call_fusage;
|
||||
register tree p = TREE_OPERAND (exp, 0);
|
||||
register int i;
|
||||
tree p = TREE_OPERAND (exp, 0);
|
||||
int i;
|
||||
/* The alignment of the stack, in bits. */
|
||||
HOST_WIDE_INT preferred_stack_boundary;
|
||||
/* The alignment of the stack, in bytes. */
|
||||
|
@ -3461,7 +3461,7 @@ emit_library_call_value_1 (retval, orgfun, value, fn_type, outmode, nargs, p)
|
|||
struct args_size args_size;
|
||||
/* Size of arguments before any adjustments (such as rounding). */
|
||||
struct args_size original_args_size;
|
||||
register int argnum;
|
||||
int argnum;
|
||||
rtx fun;
|
||||
int inc;
|
||||
int count;
|
||||
|
@ -3912,8 +3912,8 @@ emit_library_call_value_1 (retval, orgfun, value, fn_type, outmode, nargs, p)
|
|||
are to be pushed. */
|
||||
for (count = 0; count < nargs; count++, argnum += inc)
|
||||
{
|
||||
register enum machine_mode mode = argvec[argnum].mode;
|
||||
register rtx val = argvec[argnum].value;
|
||||
enum machine_mode mode = argvec[argnum].mode;
|
||||
rtx val = argvec[argnum].value;
|
||||
rtx reg = argvec[argnum].reg;
|
||||
int partial = argvec[argnum].partial;
|
||||
int lower_bound = 0, upper_bound = 0, i;
|
||||
|
@ -3995,7 +3995,7 @@ emit_library_call_value_1 (retval, orgfun, value, fn_type, outmode, nargs, p)
|
|||
are to be pushed. */
|
||||
for (count = 0; count < nargs; count++, argnum += inc)
|
||||
{
|
||||
register rtx val = argvec[argnum].value;
|
||||
rtx val = argvec[argnum].value;
|
||||
rtx reg = argvec[argnum].reg;
|
||||
int partial = argvec[argnum].partial;
|
||||
|
||||
|
@ -4200,9 +4200,9 @@ emit_library_call_value_1 (retval, orgfun, value, fn_type, outmode, nargs, p)
|
|||
and machine_modes to convert them to.
|
||||
The rtx values should have been passed through protect_from_queue already.
|
||||
|
||||
FN_TYPE will is zero for `normal' calls, one for `const' calls, wich
|
||||
which will be enclosed in REG_LIBCALL/REG_RETVAL notes and two for `pure'
|
||||
calls, that are handled like `const' calls with extra
|
||||
FN_TYPE will be zero for `normal' calls, one for `const' calls,
|
||||
which will be enclosed in REG_LIBCALL/REG_RETVAL notes, and two for
|
||||
`pure' calls, that are handled like `const' calls with extra
|
||||
(use (memory (scratch)). */
|
||||
|
||||
void
|
||||
|
@ -4315,7 +4315,7 @@ store_one_arg (arg, argblock, flags, variable_size, reg_parm_stack_space)
|
|||
int variable_size ATTRIBUTE_UNUSED;
|
||||
int reg_parm_stack_space;
|
||||
{
|
||||
register tree pval = arg->tree_value;
|
||||
tree pval = arg->tree_value;
|
||||
rtx reg = 0;
|
||||
int partial = 0;
|
||||
int used = 0;
|
||||
|
@ -4475,7 +4475,7 @@ store_one_arg (arg, argblock, flags, variable_size, reg_parm_stack_space)
|
|||
}
|
||||
else if (arg->mode != BLKmode)
|
||||
{
|
||||
register int size;
|
||||
int size;
|
||||
|
||||
/* Argument is a scalar, not entirely passed in registers.
|
||||
(If part is passed in registers, arg->partial says how much
|
||||
|
@ -4514,7 +4514,7 @@ store_one_arg (arg, argblock, flags, variable_size, reg_parm_stack_space)
|
|||
{
|
||||
/* BLKmode, at least partly to be pushed. */
|
||||
|
||||
register int excess;
|
||||
int excess;
|
||||
rtx size_rtx;
|
||||
|
||||
/* Pushing a nonscalar.
|
||||
|
|
|
@ -410,7 +410,7 @@ void
|
|||
dump_flow_info (file)
|
||||
FILE *file;
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
static const char * const reg_class_names[] = REG_CLASS_NAMES;
|
||||
|
||||
fprintf (file, "%d registers.\n", max_regno);
|
||||
|
@ -456,8 +456,8 @@ dump_flow_info (file)
|
|||
fprintf (file, "\n%d basic blocks, %d edges.\n", n_basic_blocks, n_edges);
|
||||
for (i = 0; i < n_basic_blocks; i++)
|
||||
{
|
||||
register basic_block bb = BASIC_BLOCK (i);
|
||||
register edge e;
|
||||
basic_block bb = BASIC_BLOCK (i);
|
||||
edge e;
|
||||
|
||||
fprintf (file, "\nBasic block %d: first insn %d, last %d, loop_depth %d, count ",
|
||||
i, INSN_UID (bb->head), INSN_UID (bb->end), bb->loop_depth);
|
||||
|
|
|
@ -62,9 +62,9 @@ static int
|
|||
count_basic_blocks (f)
|
||||
rtx f;
|
||||
{
|
||||
register rtx insn;
|
||||
register RTX_CODE prev_code;
|
||||
register int count = 0;
|
||||
rtx insn;
|
||||
RTX_CODE prev_code;
|
||||
int count = 0;
|
||||
int saw_abnormal_edge = 0;
|
||||
|
||||
prev_code = JUMP_INSN;
|
||||
|
@ -407,7 +407,7 @@ static void
|
|||
find_basic_blocks_1 (f)
|
||||
rtx f;
|
||||
{
|
||||
register rtx insn, next;
|
||||
rtx insn, next;
|
||||
int i = 0;
|
||||
rtx bb_note = NULL_RTX;
|
||||
rtx lvl = NULL_RTX;
|
||||
|
|
|
@ -1410,7 +1410,7 @@ print_rtl_with_bb (outf, rtx_first)
|
|||
FILE *outf;
|
||||
rtx rtx_first;
|
||||
{
|
||||
register rtx tmp_rtx;
|
||||
rtx tmp_rtx;
|
||||
|
||||
if (rtx_first == 0)
|
||||
fprintf (outf, "(nil)\n");
|
||||
|
|
|
@ -560,9 +560,9 @@ is_ctor_dtor (s)
|
|||
struct names { const char *const name; const int len; const int ret;
|
||||
const int two_underscores; };
|
||||
|
||||
register struct names *p;
|
||||
register int ch;
|
||||
register const char *orig_s = s;
|
||||
struct names *p;
|
||||
int ch;
|
||||
const char *orig_s = s;
|
||||
|
||||
static struct names special[] = {
|
||||
{ "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, 1, 0 },
|
||||
|
|
|
@ -478,12 +478,12 @@ combine_instructions (f, nregs)
|
|||
rtx f;
|
||||
unsigned int nregs;
|
||||
{
|
||||
register rtx insn, next;
|
||||
rtx insn, next;
|
||||
#ifdef HAVE_cc0
|
||||
register rtx prev;
|
||||
rtx prev;
|
||||
#endif
|
||||
register int i;
|
||||
register rtx links, nextlinks;
|
||||
int i;
|
||||
rtx links, nextlinks;
|
||||
|
||||
int new_direct_jump_p = 0;
|
||||
|
||||
|
@ -1473,8 +1473,8 @@ cant_combine_insn_p (insn)
|
|||
|
||||
static rtx
|
||||
try_combine (i3, i2, i1, new_direct_jump_p)
|
||||
register rtx i3, i2, i1;
|
||||
register int *new_direct_jump_p;
|
||||
rtx i3, i2, i1;
|
||||
int *new_direct_jump_p;
|
||||
{
|
||||
/* New patterns for I3 and I2, respectively. */
|
||||
rtx newpat, newi2pat = 0;
|
||||
|
@ -1506,7 +1506,7 @@ try_combine (i3, i2, i1, new_direct_jump_p)
|
|||
|
||||
int maxreg;
|
||||
rtx temp;
|
||||
register rtx link;
|
||||
rtx link;
|
||||
int i;
|
||||
|
||||
/* Exit early if one of the insns involved can't be used for
|
||||
|
@ -3261,14 +3261,14 @@ find_split_point (loc, insn)
|
|||
|
||||
static rtx
|
||||
subst (x, from, to, in_dest, unique_copy)
|
||||
register rtx x, from, to;
|
||||
rtx x, from, to;
|
||||
int in_dest;
|
||||
int unique_copy;
|
||||
{
|
||||
register enum rtx_code code = GET_CODE (x);
|
||||
enum rtx_code code = GET_CODE (x);
|
||||
enum machine_mode op0_mode = VOIDmode;
|
||||
register const char *fmt;
|
||||
register int len, i;
|
||||
const char *fmt;
|
||||
int len, i;
|
||||
rtx new;
|
||||
|
||||
/* Two expressions are equal if they are identical copies of a shared
|
||||
|
@ -3376,7 +3376,7 @@ subst (x, from, to, in_dest, unique_copy)
|
|||
{
|
||||
if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
||||
{
|
||||
if (COMBINE_RTX_EQUAL_P (XVECEXP (x, i, j), from))
|
||||
|
@ -9550,7 +9550,7 @@ recog_for_combine (pnewpat, insn, pnotes)
|
|||
rtx insn;
|
||||
rtx *pnotes;
|
||||
{
|
||||
register rtx pat = *pnewpat;
|
||||
rtx pat = *pnewpat;
|
||||
int insn_code_number;
|
||||
int num_clobbers_to_add = 0;
|
||||
int i;
|
||||
|
@ -9654,7 +9654,7 @@ recog_for_combine (pnewpat, insn, pnotes)
|
|||
static rtx
|
||||
gen_lowpart_for_combine (mode, x)
|
||||
enum machine_mode mode;
|
||||
register rtx x;
|
||||
rtx x;
|
||||
{
|
||||
rtx result;
|
||||
|
||||
|
@ -9697,7 +9697,7 @@ gen_lowpart_for_combine (mode, x)
|
|||
|
||||
if (GET_CODE (x) == MEM)
|
||||
{
|
||||
register int offset = 0;
|
||||
int offset = 0;
|
||||
|
||||
/* Refuse to work on a volatile memory ref or one with a mode-dependent
|
||||
address. */
|
||||
|
@ -10964,9 +10964,9 @@ static void
|
|||
update_table_tick (x)
|
||||
rtx x;
|
||||
{
|
||||
register enum rtx_code code = GET_CODE (x);
|
||||
register const char *fmt = GET_RTX_FORMAT (code);
|
||||
register int i;
|
||||
enum rtx_code code = GET_CODE (x);
|
||||
const char *fmt = GET_RTX_FORMAT (code);
|
||||
int i;
|
||||
|
||||
if (code == REG)
|
||||
{
|
||||
|
@ -11148,7 +11148,7 @@ static void
|
|||
record_dead_and_set_regs (insn)
|
||||
rtx insn;
|
||||
{
|
||||
register rtx link;
|
||||
rtx link;
|
||||
unsigned int i;
|
||||
|
||||
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
|
||||
|
@ -11409,12 +11409,12 @@ get_last_value (x)
|
|||
|
||||
static int
|
||||
use_crosses_set_p (x, from_cuid)
|
||||
register rtx x;
|
||||
rtx x;
|
||||
int from_cuid;
|
||||
{
|
||||
register const char *fmt;
|
||||
register int i;
|
||||
register enum rtx_code code = GET_CODE (x);
|
||||
const char *fmt;
|
||||
int i;
|
||||
enum rtx_code code = GET_CODE (x);
|
||||
|
||||
if (code == REG)
|
||||
{
|
||||
|
@ -11444,7 +11444,7 @@ use_crosses_set_p (x, from_cuid)
|
|||
{
|
||||
if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
||||
if (use_crosses_set_p (XVECEXP (x, i, j), from_cuid))
|
||||
return 1;
|
||||
|
@ -11617,7 +11617,7 @@ mark_used_regs_combine (x)
|
|||
{
|
||||
/* If setting a MEM, or a SUBREG of a MEM, then note any hard regs in
|
||||
the address. */
|
||||
register rtx testreg = SET_DEST (x);
|
||||
rtx testreg = SET_DEST (x);
|
||||
|
||||
while (GET_CODE (testreg) == SUBREG
|
||||
|| GET_CODE (testreg) == ZERO_EXTRACT
|
||||
|
@ -11639,7 +11639,7 @@ mark_used_regs_combine (x)
|
|||
/* Recursively scan the operands of this expression. */
|
||||
|
||||
{
|
||||
register const char *fmt = GET_RTX_FORMAT (code);
|
||||
const char *fmt = GET_RTX_FORMAT (code);
|
||||
|
||||
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
||||
{
|
||||
|
@ -11647,7 +11647,7 @@ mark_used_regs_combine (x)
|
|||
mark_used_regs_combine (XEXP (x, i));
|
||||
else if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
|
||||
for (j = 0; j < XVECLEN (x, i); j++)
|
||||
mark_used_regs_combine (XVECEXP (x, i, j));
|
||||
|
@ -11665,7 +11665,7 @@ remove_death (regno, insn)
|
|||
unsigned int regno;
|
||||
rtx insn;
|
||||
{
|
||||
register rtx note = find_regno_note (insn, REG_DEAD, regno);
|
||||
rtx note = find_regno_note (insn, REG_DEAD, regno);
|
||||
|
||||
if (note)
|
||||
{
|
||||
|
@ -11694,15 +11694,15 @@ move_deaths (x, maybe_kill_insn, from_cuid, to_insn, pnotes)
|
|||
rtx to_insn;
|
||||
rtx *pnotes;
|
||||
{
|
||||
register const char *fmt;
|
||||
register int len, i;
|
||||
register enum rtx_code code = GET_CODE (x);
|
||||
const char *fmt;
|
||||
int len, i;
|
||||
enum rtx_code code = GET_CODE (x);
|
||||
|
||||
if (code == REG)
|
||||
{
|
||||
unsigned int regno = REGNO (x);
|
||||
register rtx where_dead = reg_last_death[regno];
|
||||
register rtx before_dead, after_dead;
|
||||
rtx where_dead = reg_last_death[regno];
|
||||
rtx before_dead, after_dead;
|
||||
|
||||
/* Don't move the register if it gets killed in between from and to */
|
||||
if (maybe_kill_insn && reg_set_p (x, maybe_kill_insn)
|
||||
|
@ -11846,7 +11846,7 @@ move_deaths (x, maybe_kill_insn, from_cuid, to_insn, pnotes)
|
|||
{
|
||||
if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
||||
move_deaths (XVECEXP (x, i, j), maybe_kill_insn, from_cuid,
|
||||
to_insn, pnotes);
|
||||
|
|
|
@ -295,7 +295,7 @@ convert_to_integer (type, expr)
|
|||
{
|
||||
/* Do the arithmetic in type TYPEX,
|
||||
then convert result to TYPE. */
|
||||
register tree typex = type;
|
||||
tree typex = type;
|
||||
|
||||
/* Can't do arithmetic in enumeral types
|
||||
so use an integer type that will hold the values. */
|
||||
|
@ -333,7 +333,7 @@ convert_to_integer (type, expr)
|
|||
/* This is not correct for ABS_EXPR,
|
||||
since we must test the sign before truncation. */
|
||||
{
|
||||
register tree typex = type;
|
||||
tree typex = type;
|
||||
|
||||
/* Can't do arithmetic in enumeral types
|
||||
so use an integer type that will hold the values. */
|
||||
|
|
|
@ -572,7 +572,7 @@ _cpp_parse_expr (pfile)
|
|||
struct op init_stack[INIT_STACK_SIZE];
|
||||
struct op *stack = init_stack;
|
||||
struct op *limit = stack + INIT_STACK_SIZE;
|
||||
register struct op *top = stack + 1;
|
||||
struct op *top = stack + 1;
|
||||
int skip_evaluation = 0;
|
||||
int result;
|
||||
unsigned int lex_count, saw_leading_not;
|
||||
|
|
|
@ -859,7 +859,7 @@ read_name_map (pfile, dirname)
|
|||
cpp_reader *pfile;
|
||||
const char *dirname;
|
||||
{
|
||||
register struct file_name_map_list *map_list_ptr;
|
||||
struct file_name_map_list *map_list_ptr;
|
||||
char *name;
|
||||
FILE *f;
|
||||
|
||||
|
|
180
gcc/cse.c
180
gcc/cse.c
|
@ -826,10 +826,10 @@ rtx_cost (x, outer_code)
|
|||
rtx x;
|
||||
enum rtx_code outer_code ATTRIBUTE_UNUSED;
|
||||
{
|
||||
register int i, j;
|
||||
register enum rtx_code code;
|
||||
register const char *fmt;
|
||||
register int total;
|
||||
int i, j;
|
||||
enum rtx_code code;
|
||||
const char *fmt;
|
||||
int total;
|
||||
|
||||
if (x == 0)
|
||||
return 0;
|
||||
|
@ -985,7 +985,7 @@ get_cse_reg_info (regno)
|
|||
static void
|
||||
new_basic_block ()
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
next_qty = max_reg;
|
||||
|
||||
|
@ -1043,9 +1043,9 @@ make_new_qty (reg, mode)
|
|||
unsigned int reg;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
register int q;
|
||||
register struct qty_table_elem *ent;
|
||||
register struct reg_eqv_elem *eqv;
|
||||
int q;
|
||||
struct qty_table_elem *ent;
|
||||
struct reg_eqv_elem *eqv;
|
||||
|
||||
if (next_qty >= max_qty)
|
||||
abort ();
|
||||
|
@ -1133,9 +1133,9 @@ static void
|
|||
delete_reg_equiv (reg)
|
||||
unsigned int reg;
|
||||
{
|
||||
register struct qty_table_elem *ent;
|
||||
register int q = REG_QTY (reg);
|
||||
register int p, n;
|
||||
struct qty_table_elem *ent;
|
||||
int q = REG_QTY (reg);
|
||||
int p, n;
|
||||
|
||||
/* If invalid, do nothing. */
|
||||
if (q == (int) reg)
|
||||
|
@ -1174,10 +1174,10 @@ static int
|
|||
mention_regs (x)
|
||||
rtx x;
|
||||
{
|
||||
register enum rtx_code code;
|
||||
register int i, j;
|
||||
register const char *fmt;
|
||||
register int changed = 0;
|
||||
enum rtx_code code;
|
||||
int i, j;
|
||||
const char *fmt;
|
||||
int changed = 0;
|
||||
|
||||
if (x == 0)
|
||||
return 0;
|
||||
|
@ -1358,7 +1358,7 @@ insert_regs (x, classp, modified)
|
|||
|
||||
static void
|
||||
remove_from_table (elt, hash)
|
||||
register struct table_elt *elt;
|
||||
struct table_elt *elt;
|
||||
unsigned hash;
|
||||
{
|
||||
if (elt == 0)
|
||||
|
@ -1370,8 +1370,8 @@ remove_from_table (elt, hash)
|
|||
/* Remove the table element from its equivalence class. */
|
||||
|
||||
{
|
||||
register struct table_elt *prev = elt->prev_same_value;
|
||||
register struct table_elt *next = elt->next_same_value;
|
||||
struct table_elt *prev = elt->prev_same_value;
|
||||
struct table_elt *next = elt->next_same_value;
|
||||
|
||||
if (next)
|
||||
next->prev_same_value = prev;
|
||||
|
@ -1380,7 +1380,7 @@ remove_from_table (elt, hash)
|
|||
prev->next_same_value = next;
|
||||
else
|
||||
{
|
||||
register struct table_elt *newfirst = next;
|
||||
struct table_elt *newfirst = next;
|
||||
while (next)
|
||||
{
|
||||
next->first_same_value = newfirst;
|
||||
|
@ -1392,8 +1392,8 @@ remove_from_table (elt, hash)
|
|||
/* Remove the table element from its hash bucket. */
|
||||
|
||||
{
|
||||
register struct table_elt *prev = elt->prev_same_hash;
|
||||
register struct table_elt *next = elt->next_same_hash;
|
||||
struct table_elt *prev = elt->prev_same_hash;
|
||||
struct table_elt *next = elt->next_same_hash;
|
||||
|
||||
if (next)
|
||||
next->prev_same_hash = prev;
|
||||
|
@ -1418,7 +1418,7 @@ remove_from_table (elt, hash)
|
|||
|
||||
if (elt->related_value != 0 && elt->related_value != elt)
|
||||
{
|
||||
register struct table_elt *p = elt->related_value;
|
||||
struct table_elt *p = elt->related_value;
|
||||
|
||||
while (p->related_value != elt)
|
||||
p = p->related_value;
|
||||
|
@ -1447,7 +1447,7 @@ lookup (x, hash, mode)
|
|||
unsigned hash;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
register struct table_elt *p;
|
||||
struct table_elt *p;
|
||||
|
||||
for (p = table[hash]; p; p = p->next_same_hash)
|
||||
if (mode == p->mode && ((x == p->exp && GET_CODE (x) == REG)
|
||||
|
@ -1466,7 +1466,7 @@ lookup_for_remove (x, hash, mode)
|
|||
unsigned hash;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
register struct table_elt *p;
|
||||
struct table_elt *p;
|
||||
|
||||
if (GET_CODE (x) == REG)
|
||||
{
|
||||
|
@ -1497,7 +1497,7 @@ lookup_as_function (x, code)
|
|||
rtx x;
|
||||
enum rtx_code code;
|
||||
{
|
||||
register struct table_elt *p
|
||||
struct table_elt *p
|
||||
= lookup (x, safe_hash (x, VOIDmode) & HASH_MASK, GET_MODE (x));
|
||||
|
||||
/* If we are looking for a CONST_INT, the mode doesn't really matter, as
|
||||
|
@ -1552,12 +1552,12 @@ lookup_as_function (x, code)
|
|||
|
||||
static struct table_elt *
|
||||
insert (x, classp, hash, mode)
|
||||
register rtx x;
|
||||
register struct table_elt *classp;
|
||||
rtx x;
|
||||
struct table_elt *classp;
|
||||
unsigned hash;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
register struct table_elt *elt;
|
||||
struct table_elt *elt;
|
||||
|
||||
/* If X is a register and we haven't made a quantity for it,
|
||||
something is wrong. */
|
||||
|
@ -1616,7 +1616,7 @@ insert (x, classp, hash, mode)
|
|||
if (CHEAPER (elt, classp))
|
||||
/* Insert at the head of the class */
|
||||
{
|
||||
register struct table_elt *p;
|
||||
struct table_elt *p;
|
||||
elt->next_same_value = classp;
|
||||
classp->prev_same_value = elt;
|
||||
elt->first_same_value = elt;
|
||||
|
@ -1628,7 +1628,7 @@ insert (x, classp, hash, mode)
|
|||
{
|
||||
/* Insert not at head of the class. */
|
||||
/* Put it after the last element cheaper than X. */
|
||||
register struct table_elt *p, *next;
|
||||
struct table_elt *p, *next;
|
||||
|
||||
for (p = classp; (next = p->next_same_value) && CHEAPER (next, elt);
|
||||
p = next);
|
||||
|
@ -1676,7 +1676,7 @@ insert (x, classp, hash, mode)
|
|||
&& ! qty_table[REG_QTY (REGNO (x))].const_rtx
|
||||
&& ! elt->is_const)
|
||||
{
|
||||
register struct table_elt *p;
|
||||
struct table_elt *p;
|
||||
|
||||
for (p = classp; p != 0; p = p->next_same_value)
|
||||
{
|
||||
|
@ -1842,8 +1842,8 @@ invalidate (x, full_mode)
|
|||
rtx x;
|
||||
enum machine_mode full_mode;
|
||||
{
|
||||
register int i;
|
||||
register struct table_elt *p;
|
||||
int i;
|
||||
struct table_elt *p;
|
||||
|
||||
switch (GET_CODE (x))
|
||||
{
|
||||
|
@ -1884,7 +1884,7 @@ invalidate (x, full_mode)
|
|||
unsigned int endregno
|
||||
= regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
|
||||
unsigned int tregno, tendregno, rn;
|
||||
register struct table_elt *p, *next;
|
||||
struct table_elt *p, *next;
|
||||
|
||||
CLEAR_HARD_REG_BIT (hard_regs_in_table, regno);
|
||||
|
||||
|
@ -1943,7 +1943,7 @@ invalidate (x, full_mode)
|
|||
|
||||
for (i = 0; i < HASH_SIZE; i++)
|
||||
{
|
||||
register struct table_elt *next;
|
||||
struct table_elt *next;
|
||||
|
||||
for (p = table[i]; p; p = next)
|
||||
{
|
||||
|
@ -2141,8 +2141,8 @@ use_related_value (x, elt)
|
|||
rtx x;
|
||||
struct table_elt *elt;
|
||||
{
|
||||
register struct table_elt *relt = 0;
|
||||
register struct table_elt *p, *q;
|
||||
struct table_elt *relt = 0;
|
||||
struct table_elt *p, *q;
|
||||
HOST_WIDE_INT offset;
|
||||
|
||||
/* First, is there anything related known?
|
||||
|
@ -2238,10 +2238,10 @@ canon_hash (x, mode)
|
|||
rtx x;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
register int i, j;
|
||||
register unsigned hash = 0;
|
||||
register enum rtx_code code;
|
||||
register const char *fmt;
|
||||
int i, j;
|
||||
unsigned hash = 0;
|
||||
enum rtx_code code;
|
||||
const char *fmt;
|
||||
|
||||
/* repeat is used to turn tail-recursion into iteration. */
|
||||
repeat:
|
||||
|
@ -2449,7 +2449,7 @@ canon_hash (x, mode)
|
|||
hash += canon_hash_string (XSTR (x, i));
|
||||
else if (fmt[i] == 'i')
|
||||
{
|
||||
register unsigned tem = XINT (x, i);
|
||||
unsigned tem = XINT (x, i);
|
||||
hash += tem;
|
||||
}
|
||||
else if (fmt[i] == '0' || fmt[i] == 't')
|
||||
|
@ -2497,9 +2497,9 @@ exp_equiv_p (x, y, validate, equal_values)
|
|||
int validate;
|
||||
int equal_values;
|
||||
{
|
||||
register int i, j;
|
||||
register enum rtx_code code;
|
||||
register const char *fmt;
|
||||
int i, j;
|
||||
enum rtx_code code;
|
||||
const char *fmt;
|
||||
|
||||
/* Note: it is incorrect to assume an expression is equivalent to itself
|
||||
if VALIDATE is nonzero. */
|
||||
|
@ -2688,7 +2688,7 @@ exp_equiv_p (x, y, validate, equal_values)
|
|||
|
||||
static int
|
||||
cse_rtx_varies_p (x, from_alias)
|
||||
register rtx x;
|
||||
rtx x;
|
||||
int from_alias;
|
||||
{
|
||||
/* We need not check for X and the equivalence class being of the same
|
||||
|
@ -2761,9 +2761,9 @@ canon_reg (x, insn)
|
|||
rtx x;
|
||||
rtx insn;
|
||||
{
|
||||
register int i;
|
||||
register enum rtx_code code;
|
||||
register const char *fmt;
|
||||
int i;
|
||||
enum rtx_code code;
|
||||
const char *fmt;
|
||||
|
||||
if (x == 0)
|
||||
return x;
|
||||
|
@ -2784,9 +2784,9 @@ canon_reg (x, insn)
|
|||
|
||||
case REG:
|
||||
{
|
||||
register int first;
|
||||
register int q;
|
||||
register struct qty_table_elem *ent;
|
||||
int first;
|
||||
int q;
|
||||
struct qty_table_elem *ent;
|
||||
|
||||
/* Never replace a hard reg, because hard regs can appear
|
||||
in more than one machine mode, and we must preserve the mode
|
||||
|
@ -2812,7 +2812,7 @@ canon_reg (x, insn)
|
|||
fmt = GET_RTX_FORMAT (code);
|
||||
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
|
||||
if (fmt[i] == 'e')
|
||||
{
|
||||
|
@ -3285,10 +3285,10 @@ fold_rtx (x, insn)
|
|||
rtx x;
|
||||
rtx insn;
|
||||
{
|
||||
register enum rtx_code code;
|
||||
register enum machine_mode mode;
|
||||
register const char *fmt;
|
||||
register int i;
|
||||
enum rtx_code code;
|
||||
enum machine_mode mode;
|
||||
const char *fmt;
|
||||
int i;
|
||||
rtx new = 0;
|
||||
int copied = 0;
|
||||
int must_swap = 0;
|
||||
|
@ -3845,7 +3845,7 @@ fold_rtx (x, insn)
|
|||
|| (GET_CODE (const_arg0) == CONST_INT
|
||||
&& GET_CODE (const_arg1) != CONST_INT))))
|
||||
{
|
||||
register rtx tem = XEXP (x, 0);
|
||||
rtx tem = XEXP (x, 0);
|
||||
|
||||
if (insn == 0 && ! copied)
|
||||
{
|
||||
|
@ -4363,7 +4363,7 @@ equiv_constant (x)
|
|||
rtx
|
||||
gen_lowpart_if_possible (mode, x)
|
||||
enum machine_mode mode;
|
||||
register rtx x;
|
||||
rtx x;
|
||||
{
|
||||
rtx result = gen_lowpart_common (mode, x);
|
||||
|
||||
|
@ -4372,7 +4372,7 @@ gen_lowpart_if_possible (mode, x)
|
|||
else if (GET_CODE (x) == MEM)
|
||||
{
|
||||
/* This is the only other case we handle. */
|
||||
register int offset = 0;
|
||||
int offset = 0;
|
||||
rtx new;
|
||||
|
||||
if (WORDS_BIG_ENDIAN)
|
||||
|
@ -4716,10 +4716,10 @@ cse_insn (insn, libcall_insn)
|
|||
rtx insn;
|
||||
rtx libcall_insn;
|
||||
{
|
||||
register rtx x = PATTERN (insn);
|
||||
register int i;
|
||||
rtx x = PATTERN (insn);
|
||||
int i;
|
||||
rtx tem;
|
||||
register int n_sets = 0;
|
||||
int n_sets = 0;
|
||||
|
||||
#ifdef HAVE_cc0
|
||||
/* Records what this insn does to set CC0. */
|
||||
|
@ -4787,7 +4787,7 @@ cse_insn (insn, libcall_insn)
|
|||
}
|
||||
else if (GET_CODE (x) == PARALLEL)
|
||||
{
|
||||
register int lim = XVECLEN (x, 0);
|
||||
int lim = XVECLEN (x, 0);
|
||||
|
||||
sets = (struct set *) alloca (lim * sizeof (struct set));
|
||||
|
||||
|
@ -4804,7 +4804,7 @@ cse_insn (insn, libcall_insn)
|
|||
anything in that case. */
|
||||
for (i = 0; i < lim; i++)
|
||||
{
|
||||
register rtx y = XVECEXP (x, 0, i);
|
||||
rtx y = XVECEXP (x, 0, i);
|
||||
if (GET_CODE (y) == CLOBBER)
|
||||
{
|
||||
rtx clobbered = XEXP (y, 0);
|
||||
|
@ -4820,7 +4820,7 @@ cse_insn (insn, libcall_insn)
|
|||
|
||||
for (i = 0; i < lim; i++)
|
||||
{
|
||||
register rtx y = XVECEXP (x, 0, i);
|
||||
rtx y = XVECEXP (x, 0, i);
|
||||
if (GET_CODE (y) == SET)
|
||||
{
|
||||
/* As above, we ignore unconditional jumps and call-insns and
|
||||
|
@ -4952,9 +4952,9 @@ cse_insn (insn, libcall_insn)
|
|||
|
||||
for (i = 0; i < n_sets; i++)
|
||||
{
|
||||
register rtx src, dest;
|
||||
register rtx src_folded;
|
||||
register struct table_elt *elt = 0, *p;
|
||||
rtx src, dest;
|
||||
rtx src_folded;
|
||||
struct table_elt *elt = 0, *p;
|
||||
enum machine_mode mode;
|
||||
rtx src_eqv_here;
|
||||
rtx src_const = 0;
|
||||
|
@ -5853,8 +5853,8 @@ cse_insn (insn, libcall_insn)
|
|||
if (src_eqv && src_eqv_elt == 0 && sets[0].rtl != 0 && ! src_eqv_volatile
|
||||
&& ! rtx_equal_p (src_eqv, SET_DEST (sets[0].rtl)))
|
||||
{
|
||||
register struct table_elt *elt;
|
||||
register struct table_elt *classp = sets[0].src_elt;
|
||||
struct table_elt *elt;
|
||||
struct table_elt *classp = sets[0].src_elt;
|
||||
rtx dest = SET_DEST (sets[0].rtl);
|
||||
enum machine_mode eqvmode = GET_MODE (dest);
|
||||
|
||||
|
@ -5899,9 +5899,9 @@ cse_insn (insn, libcall_insn)
|
|||
{
|
||||
/* Insert source and constant equivalent into hash table, if not
|
||||
already present. */
|
||||
register struct table_elt *classp = src_eqv_elt;
|
||||
register rtx src = sets[i].src;
|
||||
register rtx dest = SET_DEST (sets[i].rtl);
|
||||
struct table_elt *classp = src_eqv_elt;
|
||||
rtx src = sets[i].src;
|
||||
rtx dest = SET_DEST (sets[i].rtl);
|
||||
enum machine_mode mode
|
||||
= GET_MODE (src) == VOIDmode ? GET_MODE (dest) : GET_MODE (src);
|
||||
|
||||
|
@ -5914,7 +5914,7 @@ cse_insn (insn, libcall_insn)
|
|||
|| REGNO (src) >= FIRST_PSEUDO_REGISTER
|
||||
|| ! find_reg_note (insn, REG_RETVAL, NULL_RTX))
|
||||
{
|
||||
register struct table_elt *elt;
|
||||
struct table_elt *elt;
|
||||
|
||||
/* Note that these insert_regs calls cannot remove
|
||||
any of the src_elt's, because they would have failed to
|
||||
|
@ -5966,7 +5966,7 @@ cse_insn (insn, libcall_insn)
|
|||
{
|
||||
/* We can't use the inner dest, because the mode associated with
|
||||
a ZERO_EXTRACT is significant. */
|
||||
register rtx dest = SET_DEST (sets[i].rtl);
|
||||
rtx dest = SET_DEST (sets[i].rtl);
|
||||
|
||||
/* Needed for registers to remove the register from its
|
||||
previous quantity's chain.
|
||||
|
@ -6050,7 +6050,7 @@ cse_insn (insn, libcall_insn)
|
|||
/* If elt was removed, find current head of same class,
|
||||
or 0 if nothing remains of that class. */
|
||||
{
|
||||
register struct table_elt *elt = sets[i].src_elt;
|
||||
struct table_elt *elt = sets[i].src_elt;
|
||||
|
||||
while (elt && elt->prev_same_value)
|
||||
elt = elt->prev_same_value;
|
||||
|
@ -6066,9 +6066,9 @@ cse_insn (insn, libcall_insn)
|
|||
for (i = 0; i < n_sets; i++)
|
||||
if (sets[i].rtl)
|
||||
{
|
||||
register rtx dest = SET_DEST (sets[i].rtl);
|
||||
rtx dest = SET_DEST (sets[i].rtl);
|
||||
rtx inner_dest = sets[i].inner_dest;
|
||||
register struct table_elt *elt;
|
||||
struct table_elt *elt;
|
||||
|
||||
/* Don't record value if we are not supposed to risk allocating
|
||||
floating-point values in registers that might be wider than
|
||||
|
@ -6320,8 +6320,8 @@ cse_insn (insn, libcall_insn)
|
|||
static void
|
||||
invalidate_memory ()
|
||||
{
|
||||
register int i;
|
||||
register struct table_elt *p, *next;
|
||||
int i;
|
||||
struct table_elt *p, *next;
|
||||
|
||||
for (i = 0; i < HASH_SIZE; i++)
|
||||
for (p = table[i]; p; p = next)
|
||||
|
@ -6337,7 +6337,7 @@ invalidate_memory ()
|
|||
|
||||
static int
|
||||
addr_affects_sp_p (addr)
|
||||
register rtx addr;
|
||||
rtx addr;
|
||||
{
|
||||
if (GET_RTX_CLASS (GET_CODE (addr)) == 'a'
|
||||
&& GET_CODE (XEXP (addr, 0)) == REG
|
||||
|
@ -6382,10 +6382,10 @@ invalidate_from_clobbers (x)
|
|||
}
|
||||
else if (GET_CODE (x) == PARALLEL)
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
|
||||
{
|
||||
register rtx y = XVECEXP (x, 0, i);
|
||||
rtx y = XVECEXP (x, 0, i);
|
||||
if (GET_CODE (y) == CLOBBER)
|
||||
{
|
||||
rtx ref = XEXP (y, 0);
|
||||
|
@ -6938,7 +6938,7 @@ cse_end_of_basic_block (insn, data, follow_jumps, after_loop, skip_blocks)
|
|||
/* Detect a branch around a block of code. */
|
||||
else if (skip_blocks && q != 0 && GET_CODE (q) != CODE_LABEL)
|
||||
{
|
||||
register rtx tmp;
|
||||
rtx tmp;
|
||||
|
||||
if (next_real_insn (q) == next)
|
||||
{
|
||||
|
@ -7013,8 +7013,8 @@ cse_main (f, nregs, after_loop, file)
|
|||
FILE *file;
|
||||
{
|
||||
struct cse_basic_block_data val;
|
||||
register rtx insn = f;
|
||||
register int i;
|
||||
rtx insn = f;
|
||||
int i;
|
||||
|
||||
cse_jumps_altered = 0;
|
||||
recorded_label_ref = 0;
|
||||
|
@ -7153,11 +7153,11 @@ cse_main (f, nregs, after_loop, file)
|
|||
|
||||
static rtx
|
||||
cse_basic_block (from, to, next_branch, around_loop)
|
||||
register rtx from, to;
|
||||
rtx from, to;
|
||||
struct branch_path *next_branch;
|
||||
int around_loop;
|
||||
{
|
||||
register rtx insn;
|
||||
rtx insn;
|
||||
int to_usage = 0;
|
||||
rtx libcall_insn = NULL_RTX;
|
||||
int num_insns = 0;
|
||||
|
@ -7178,7 +7178,7 @@ cse_basic_block (from, to, next_branch, around_loop)
|
|||
|
||||
for (insn = from; insn != to; insn = NEXT_INSN (insn))
|
||||
{
|
||||
register enum rtx_code code = GET_CODE (insn);
|
||||
enum rtx_code code = GET_CODE (insn);
|
||||
|
||||
/* If we have processed 1,000 insns, flush the hash table to
|
||||
avoid extreme quadratic behavior. We must not include NOTEs
|
||||
|
|
14
gcc/dbxout.c
14
gcc/dbxout.c
|
@ -855,15 +855,15 @@ dbxout_type_method_1 (decl, debug_name)
|
|||
|
||||
static void
|
||||
dbxout_type_methods (type)
|
||||
register tree type;
|
||||
tree type;
|
||||
{
|
||||
/* C++: put out the method names and their parameter lists */
|
||||
tree methods = TYPE_METHODS (type);
|
||||
tree type_encoding;
|
||||
register tree fndecl;
|
||||
register tree last;
|
||||
tree fndecl;
|
||||
tree last;
|
||||
char formatted_type_identifier_length[16];
|
||||
register int type_identifier_length;
|
||||
int type_identifier_length;
|
||||
|
||||
if (methods == NULL_TREE)
|
||||
return;
|
||||
|
@ -1032,7 +1032,7 @@ dbxout_type (type, full)
|
|||
tree type;
|
||||
int full;
|
||||
{
|
||||
register tree tem;
|
||||
tree tem;
|
||||
static int anonymous_type_number = 0;
|
||||
|
||||
if (TREE_CODE (type) == VECTOR_TYPE)
|
||||
|
@ -1759,7 +1759,7 @@ print_wide_int (c)
|
|||
|
||||
static void
|
||||
dbxout_type_name (type)
|
||||
register tree type;
|
||||
tree type;
|
||||
{
|
||||
tree t;
|
||||
if (TYPE_NAME (type) == 0)
|
||||
|
@ -2712,7 +2712,7 @@ dbxout_args (args)
|
|||
|
||||
static void
|
||||
dbxout_block (block, depth, args)
|
||||
register tree block;
|
||||
tree block;
|
||||
int depth;
|
||||
tree args;
|
||||
{
|
||||
|
|
|
@ -91,7 +91,7 @@ do { ASM_OUTPUT_LABEL(FILE,LABEL_ALTERNATE_NAME (INSN)); } while (0)
|
|||
\
|
||||
for (i = 0; i < thissize; i++) \
|
||||
{ \
|
||||
register int c = p[i]; \
|
||||
int c = p[i]; \
|
||||
if (c == '\"' || c == '\\') \
|
||||
putc ('\\', asm_out_file); \
|
||||
if (ISPRINT(c)) \
|
||||
|
|
2
gcc/df.c
2
gcc/df.c
|
@ -1186,7 +1186,7 @@ df_uses_record (df, loc, ref_type, bb, insn)
|
|||
|
||||
/* Recursively scan the operands of this expression. */
|
||||
{
|
||||
register const char *fmt = GET_RTX_FORMAT (code);
|
||||
const char *fmt = GET_RTX_FORMAT (code);
|
||||
int i;
|
||||
|
||||
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
||||
|
|
989
gcc/dwarf2out.c
989
gcc/dwarf2out.c
File diff suppressed because it is too large
Load Diff
478
gcc/dwarfout.c
478
gcc/dwarfout.c
File diff suppressed because it is too large
Load Diff
130
gcc/emit-rtl.c
130
gcc/emit-rtl.c
|
@ -487,9 +487,9 @@ gen_lowpart_SUBREG (mode, reg)
|
|||
rtx
|
||||
gen_rtx VPARAMS ((enum rtx_code code, enum machine_mode mode, ...))
|
||||
{
|
||||
register int i; /* Array indices... */
|
||||
register const char *fmt; /* Current rtx's format... */
|
||||
register rtx rt_val; /* RTX to return to caller... */
|
||||
int i; /* Array indices... */
|
||||
const char *fmt; /* Current rtx's format... */
|
||||
rtx rt_val; /* RTX to return to caller... */
|
||||
|
||||
VA_OPEN (p, mode);
|
||||
VA_FIXEDARG (p, enum rtx_code, code);
|
||||
|
@ -606,8 +606,8 @@ gen_rtvec_v (n, argp)
|
|||
int n;
|
||||
rtx *argp;
|
||||
{
|
||||
register int i;
|
||||
register rtvec rt_val;
|
||||
int i;
|
||||
rtvec rt_val;
|
||||
|
||||
if (n == 0)
|
||||
return NULL_RTVEC; /* Don't allocate an empty rtvec... */
|
||||
|
@ -628,7 +628,7 @@ gen_reg_rtx (mode)
|
|||
enum machine_mode mode;
|
||||
{
|
||||
struct function *f = cfun;
|
||||
register rtx val;
|
||||
rtx val;
|
||||
|
||||
/* Don't let anything called after initial flow analysis create new
|
||||
registers. */
|
||||
|
@ -749,7 +749,7 @@ get_first_label_num ()
|
|||
register. */
|
||||
int
|
||||
subreg_hard_regno (x, check_mode)
|
||||
register rtx x;
|
||||
rtx x;
|
||||
int check_mode;
|
||||
{
|
||||
enum machine_mode mode = GET_MODE (x);
|
||||
|
@ -791,7 +791,7 @@ subreg_hard_regno (x, check_mode)
|
|||
rtx
|
||||
gen_lowpart_common (mode, x)
|
||||
enum machine_mode mode;
|
||||
register rtx x;
|
||||
rtx x;
|
||||
{
|
||||
int msize = GET_MODE_SIZE (mode);
|
||||
int xsize = GET_MODE_SIZE (GET_MODE (x));
|
||||
|
@ -1075,7 +1075,7 @@ gen_lowpart_common (mode, x)
|
|||
rtx
|
||||
gen_realpart (mode, x)
|
||||
enum machine_mode mode;
|
||||
register rtx x;
|
||||
rtx x;
|
||||
{
|
||||
if (WORDS_BIG_ENDIAN
|
||||
&& GET_MODE_BITSIZE (mode) < BITS_PER_WORD
|
||||
|
@ -1095,7 +1095,7 @@ gen_realpart (mode, x)
|
|||
rtx
|
||||
gen_imagpart (mode, x)
|
||||
enum machine_mode mode;
|
||||
register rtx x;
|
||||
rtx x;
|
||||
{
|
||||
if (WORDS_BIG_ENDIAN)
|
||||
return gen_lowpart (mode, x);
|
||||
|
@ -1135,7 +1135,7 @@ subreg_realpart_p (x)
|
|||
rtx
|
||||
gen_lowpart (mode, x)
|
||||
enum machine_mode mode;
|
||||
register rtx x;
|
||||
rtx x;
|
||||
{
|
||||
rtx result = gen_lowpart_common (mode, x);
|
||||
|
||||
|
@ -1152,7 +1152,7 @@ gen_lowpart (mode, x)
|
|||
else if (GET_CODE (x) == MEM)
|
||||
{
|
||||
/* The only additional case we can do is MEM. */
|
||||
register int offset = 0;
|
||||
int offset = 0;
|
||||
if (WORDS_BIG_ENDIAN)
|
||||
offset = (MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD)
|
||||
- MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD));
|
||||
|
@ -1177,7 +1177,7 @@ gen_lowpart (mode, x)
|
|||
rtx
|
||||
gen_highpart (mode, x)
|
||||
enum machine_mode mode;
|
||||
register rtx x;
|
||||
rtx x;
|
||||
{
|
||||
unsigned int msize = GET_MODE_SIZE (mode);
|
||||
rtx result;
|
||||
|
@ -1855,7 +1855,7 @@ replace_equiv_address_nv (memref, addr)
|
|||
rtx
|
||||
gen_label_rtx ()
|
||||
{
|
||||
register rtx label;
|
||||
rtx label;
|
||||
|
||||
label = gen_rtx_CODE_LABEL (VOIDmode, 0, NULL_RTX,
|
||||
NULL_RTX, label_num++, NULL, NULL);
|
||||
|
@ -2055,10 +2055,10 @@ rtx
|
|||
copy_rtx_if_shared (orig)
|
||||
rtx orig;
|
||||
{
|
||||
register rtx x = orig;
|
||||
register int i;
|
||||
register enum rtx_code code;
|
||||
register const char *format_ptr;
|
||||
rtx x = orig;
|
||||
int i;
|
||||
enum rtx_code code;
|
||||
const char *format_ptr;
|
||||
int copied = 0;
|
||||
|
||||
if (x == 0)
|
||||
|
@ -2122,7 +2122,7 @@ copy_rtx_if_shared (orig)
|
|||
|
||||
if (x->used)
|
||||
{
|
||||
register rtx copy;
|
||||
rtx copy;
|
||||
|
||||
copy = rtx_alloc (code);
|
||||
memcpy (copy, x,
|
||||
|
@ -2151,7 +2151,7 @@ copy_rtx_if_shared (orig)
|
|||
case 'E':
|
||||
if (XVEC (x, i) != NULL)
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
int len = XVECLEN (x, i);
|
||||
|
||||
if (copied && len > 0)
|
||||
|
@ -2172,9 +2172,9 @@ void
|
|||
reset_used_flags (x)
|
||||
rtx x;
|
||||
{
|
||||
register int i, j;
|
||||
register enum rtx_code code;
|
||||
register const char *format_ptr;
|
||||
int i, j;
|
||||
enum rtx_code code;
|
||||
const char *format_ptr;
|
||||
|
||||
if (x == 0)
|
||||
return;
|
||||
|
@ -2604,9 +2604,9 @@ static void
|
|||
mark_label_nuses(x)
|
||||
rtx x;
|
||||
{
|
||||
register enum rtx_code code;
|
||||
register int i, j;
|
||||
register const char *fmt;
|
||||
enum rtx_code code;
|
||||
int i, j;
|
||||
const char *fmt;
|
||||
|
||||
code = GET_CODE (x);
|
||||
if (code == LABEL_REF)
|
||||
|
@ -2810,7 +2810,7 @@ rtx
|
|||
make_insn_raw (pattern)
|
||||
rtx pattern;
|
||||
{
|
||||
register rtx insn;
|
||||
rtx insn;
|
||||
|
||||
insn = rtx_alloc (INSN);
|
||||
|
||||
|
@ -2841,7 +2841,7 @@ static rtx
|
|||
make_jump_insn_raw (pattern)
|
||||
rtx pattern;
|
||||
{
|
||||
register rtx insn;
|
||||
rtx insn;
|
||||
|
||||
insn = rtx_alloc (JUMP_INSN);
|
||||
INSN_UID (insn) = cur_insn_uid++;
|
||||
|
@ -2861,7 +2861,7 @@ static rtx
|
|||
make_call_insn_raw (pattern)
|
||||
rtx pattern;
|
||||
{
|
||||
register rtx insn;
|
||||
rtx insn;
|
||||
|
||||
insn = rtx_alloc (CALL_INSN);
|
||||
INSN_UID (insn) = cur_insn_uid++;
|
||||
|
@ -2880,7 +2880,7 @@ make_call_insn_raw (pattern)
|
|||
|
||||
void
|
||||
add_insn (insn)
|
||||
register rtx insn;
|
||||
rtx insn;
|
||||
{
|
||||
PREV_INSN (insn) = last_insn;
|
||||
NEXT_INSN (insn) = 0;
|
||||
|
@ -3341,13 +3341,13 @@ remove_unnecessary_notes ()
|
|||
|
||||
rtx
|
||||
emit_insn_before (pattern, before)
|
||||
register rtx pattern, before;
|
||||
rtx pattern, before;
|
||||
{
|
||||
register rtx insn = before;
|
||||
rtx insn = before;
|
||||
|
||||
if (GET_CODE (pattern) == SEQUENCE)
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < XVECLEN (pattern, 0); i++)
|
||||
{
|
||||
|
@ -3369,9 +3369,9 @@ emit_insn_before (pattern, before)
|
|||
|
||||
rtx
|
||||
emit_jump_insn_before (pattern, before)
|
||||
register rtx pattern, before;
|
||||
rtx pattern, before;
|
||||
{
|
||||
register rtx insn;
|
||||
rtx insn;
|
||||
|
||||
if (GET_CODE (pattern) == SEQUENCE)
|
||||
insn = emit_insn_before (pattern, before);
|
||||
|
@ -3389,9 +3389,9 @@ emit_jump_insn_before (pattern, before)
|
|||
|
||||
rtx
|
||||
emit_call_insn_before (pattern, before)
|
||||
register rtx pattern, before;
|
||||
rtx pattern, before;
|
||||
{
|
||||
register rtx insn;
|
||||
rtx insn;
|
||||
|
||||
if (GET_CODE (pattern) == SEQUENCE)
|
||||
insn = emit_insn_before (pattern, before);
|
||||
|
@ -3410,9 +3410,9 @@ emit_call_insn_before (pattern, before)
|
|||
|
||||
rtx
|
||||
emit_barrier_before (before)
|
||||
register rtx before;
|
||||
rtx before;
|
||||
{
|
||||
register rtx insn = rtx_alloc (BARRIER);
|
||||
rtx insn = rtx_alloc (BARRIER);
|
||||
|
||||
INSN_UID (insn) = cur_insn_uid++;
|
||||
|
||||
|
@ -3444,7 +3444,7 @@ emit_note_before (subtype, before)
|
|||
int subtype;
|
||||
rtx before;
|
||||
{
|
||||
register rtx note = rtx_alloc (NOTE);
|
||||
rtx note = rtx_alloc (NOTE);
|
||||
INSN_UID (note) = cur_insn_uid++;
|
||||
NOTE_SOURCE_FILE (note) = 0;
|
||||
NOTE_LINE_NUMBER (note) = subtype;
|
||||
|
@ -3458,13 +3458,13 @@ emit_note_before (subtype, before)
|
|||
|
||||
rtx
|
||||
emit_insn_after (pattern, after)
|
||||
register rtx pattern, after;
|
||||
rtx pattern, after;
|
||||
{
|
||||
register rtx insn = after;
|
||||
rtx insn = after;
|
||||
|
||||
if (GET_CODE (pattern) == SEQUENCE)
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < XVECLEN (pattern, 0); i++)
|
||||
{
|
||||
|
@ -3509,9 +3509,9 @@ emit_insn_after_with_line_notes (pattern, after, from)
|
|||
|
||||
rtx
|
||||
emit_jump_insn_after (pattern, after)
|
||||
register rtx pattern, after;
|
||||
rtx pattern, after;
|
||||
{
|
||||
register rtx insn;
|
||||
rtx insn;
|
||||
|
||||
if (GET_CODE (pattern) == SEQUENCE)
|
||||
insn = emit_insn_after (pattern, after);
|
||||
|
@ -3529,9 +3529,9 @@ emit_jump_insn_after (pattern, after)
|
|||
|
||||
rtx
|
||||
emit_barrier_after (after)
|
||||
register rtx after;
|
||||
rtx after;
|
||||
{
|
||||
register rtx insn = rtx_alloc (BARRIER);
|
||||
rtx insn = rtx_alloc (BARRIER);
|
||||
|
||||
INSN_UID (insn) = cur_insn_uid++;
|
||||
|
||||
|
@ -3564,7 +3564,7 @@ emit_note_after (subtype, after)
|
|||
int subtype;
|
||||
rtx after;
|
||||
{
|
||||
register rtx note = rtx_alloc (NOTE);
|
||||
rtx note = rtx_alloc (NOTE);
|
||||
INSN_UID (note) = cur_insn_uid++;
|
||||
NOTE_SOURCE_FILE (note) = 0;
|
||||
NOTE_LINE_NUMBER (note) = subtype;
|
||||
|
@ -3580,7 +3580,7 @@ emit_line_note_after (file, line, after)
|
|||
int line;
|
||||
rtx after;
|
||||
{
|
||||
register rtx note;
|
||||
rtx note;
|
||||
|
||||
if (no_line_numbers && line > 0)
|
||||
{
|
||||
|
@ -3611,7 +3611,7 @@ emit_insn (pattern)
|
|||
|
||||
if (GET_CODE (pattern) == SEQUENCE)
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < XVECLEN (pattern, 0); i++)
|
||||
{
|
||||
|
@ -3674,11 +3674,11 @@ emit_insns_before (insn, before)
|
|||
|
||||
rtx
|
||||
emit_insns_after (first, after)
|
||||
register rtx first;
|
||||
register rtx after;
|
||||
rtx first;
|
||||
rtx after;
|
||||
{
|
||||
register rtx last;
|
||||
register rtx after_after;
|
||||
rtx last;
|
||||
rtx after_after;
|
||||
basic_block bb;
|
||||
|
||||
if (!after)
|
||||
|
@ -3725,7 +3725,7 @@ emit_jump_insn (pattern)
|
|||
return emit_insn (pattern);
|
||||
else
|
||||
{
|
||||
register rtx insn = make_jump_insn_raw (pattern);
|
||||
rtx insn = make_jump_insn_raw (pattern);
|
||||
add_insn (insn);
|
||||
return insn;
|
||||
}
|
||||
|
@ -3742,7 +3742,7 @@ emit_call_insn (pattern)
|
|||
return emit_insn (pattern);
|
||||
else
|
||||
{
|
||||
register rtx insn = make_call_insn_raw (pattern);
|
||||
rtx insn = make_call_insn_raw (pattern);
|
||||
add_insn (insn);
|
||||
PUT_CODE (insn, CALL_INSN);
|
||||
return insn;
|
||||
|
@ -3772,7 +3772,7 @@ emit_label (label)
|
|||
rtx
|
||||
emit_barrier ()
|
||||
{
|
||||
register rtx barrier = rtx_alloc (BARRIER);
|
||||
rtx barrier = rtx_alloc (BARRIER);
|
||||
INSN_UID (barrier) = cur_insn_uid++;
|
||||
add_insn (barrier);
|
||||
return barrier;
|
||||
|
@ -3808,7 +3808,7 @@ emit_note (file, line)
|
|||
const char *file;
|
||||
int line;
|
||||
{
|
||||
register rtx note;
|
||||
rtx note;
|
||||
|
||||
if (line > 0)
|
||||
{
|
||||
|
@ -3895,7 +3895,7 @@ classify_insn (x)
|
|||
}
|
||||
if (GET_CODE (x) == PARALLEL)
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
|
||||
if (GET_CODE (XVECEXP (x, 0, j)) == CALL)
|
||||
return CALL_INSN;
|
||||
|
@ -3924,7 +3924,7 @@ emit (x)
|
|||
return emit_insn (x);
|
||||
else if (code == JUMP_INSN)
|
||||
{
|
||||
register rtx insn = emit_jump_insn (x);
|
||||
rtx insn = emit_jump_insn (x);
|
||||
if (any_uncondjump_p (insn) || GET_CODE (x) == RETURN)
|
||||
return emit_barrier ();
|
||||
return insn;
|
||||
|
@ -4181,12 +4181,12 @@ static rtvec copy_asm_constraints_vector;
|
|||
|
||||
rtx
|
||||
copy_insn_1 (orig)
|
||||
register rtx orig;
|
||||
rtx orig;
|
||||
{
|
||||
register rtx copy;
|
||||
register int i, j;
|
||||
register RTX_CODE code;
|
||||
register const char *format_ptr;
|
||||
rtx copy;
|
||||
int i, j;
|
||||
RTX_CODE code;
|
||||
const char *format_ptr;
|
||||
|
||||
code = GET_CODE (orig);
|
||||
|
||||
|
|
38
gcc/explow.c
38
gcc/explow.c
|
@ -71,13 +71,13 @@ trunc_int_for_mode (c, mode)
|
|||
|
||||
rtx
|
||||
plus_constant_wide (x, c)
|
||||
register rtx x;
|
||||
register HOST_WIDE_INT c;
|
||||
rtx x;
|
||||
HOST_WIDE_INT c;
|
||||
{
|
||||
register RTX_CODE code;
|
||||
RTX_CODE code;
|
||||
rtx y;
|
||||
register enum machine_mode mode;
|
||||
register rtx tem;
|
||||
enum machine_mode mode;
|
||||
rtx tem;
|
||||
int all_constant = 0;
|
||||
|
||||
if (c == 0)
|
||||
|
@ -202,7 +202,7 @@ eliminate_constant_term (x, constptr)
|
|||
rtx x;
|
||||
rtx *constptr;
|
||||
{
|
||||
register rtx x0, x1;
|
||||
rtx x0, x1;
|
||||
rtx tem;
|
||||
|
||||
if (GET_CODE (x) != PLUS)
|
||||
|
@ -318,7 +318,7 @@ expr_size (exp)
|
|||
|
||||
static rtx
|
||||
break_out_memory_refs (x)
|
||||
register rtx x;
|
||||
rtx x;
|
||||
{
|
||||
if (GET_CODE (x) == MEM
|
||||
|| (CONSTANT_P (x) && CONSTANT_ADDRESS_P (x)
|
||||
|
@ -327,8 +327,8 @@ break_out_memory_refs (x)
|
|||
else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
|
||||
|| GET_CODE (x) == MULT)
|
||||
{
|
||||
register rtx op0 = break_out_memory_refs (XEXP (x, 0));
|
||||
register rtx op1 = break_out_memory_refs (XEXP (x, 1));
|
||||
rtx op0 = break_out_memory_refs (XEXP (x, 0));
|
||||
rtx op1 = break_out_memory_refs (XEXP (x, 1));
|
||||
|
||||
if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
|
||||
x = gen_rtx_fmt_ee (GET_CODE (x), Pmode, op0, op1);
|
||||
|
@ -433,7 +433,7 @@ convert_memory_address (to_mode, x)
|
|||
|
||||
rtx
|
||||
copy_all_regs (x)
|
||||
register rtx x;
|
||||
rtx x;
|
||||
{
|
||||
if (GET_CODE (x) == REG)
|
||||
{
|
||||
|
@ -449,8 +449,8 @@ copy_all_regs (x)
|
|||
else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
|
||||
|| GET_CODE (x) == MULT)
|
||||
{
|
||||
register rtx op0 = copy_all_regs (XEXP (x, 0));
|
||||
register rtx op1 = copy_all_regs (XEXP (x, 1));
|
||||
rtx op0 = copy_all_regs (XEXP (x, 0));
|
||||
rtx op1 = copy_all_regs (XEXP (x, 1));
|
||||
if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
|
||||
x = gen_rtx_fmt_ee (GET_CODE (x), Pmode, op0, op1);
|
||||
}
|
||||
|
@ -464,9 +464,9 @@ copy_all_regs (x)
|
|||
rtx
|
||||
memory_address (mode, x)
|
||||
enum machine_mode mode;
|
||||
register rtx x;
|
||||
rtx x;
|
||||
{
|
||||
register rtx oldx = x;
|
||||
rtx oldx = x;
|
||||
|
||||
if (GET_CODE (x) == ADDRESSOF)
|
||||
return x;
|
||||
|
@ -667,7 +667,7 @@ rtx
|
|||
copy_to_reg (x)
|
||||
rtx x;
|
||||
{
|
||||
register rtx temp = gen_reg_rtx (GET_MODE (x));
|
||||
rtx temp = gen_reg_rtx (GET_MODE (x));
|
||||
|
||||
/* If not an operand, must be an address with PLUS and MULT so
|
||||
do the computation. */
|
||||
|
@ -698,7 +698,7 @@ copy_to_mode_reg (mode, x)
|
|||
enum machine_mode mode;
|
||||
rtx x;
|
||||
{
|
||||
register rtx temp = gen_reg_rtx (mode);
|
||||
rtx temp = gen_reg_rtx (mode);
|
||||
|
||||
/* If not an operand, must be an address with PLUS and MULT so
|
||||
do the computation. */
|
||||
|
@ -725,7 +725,7 @@ force_reg (mode, x)
|
|||
enum machine_mode mode;
|
||||
rtx x;
|
||||
{
|
||||
register rtx temp, insn, set;
|
||||
rtx temp, insn, set;
|
||||
|
||||
if (GET_CODE (x) == REG)
|
||||
return x;
|
||||
|
@ -761,7 +761,7 @@ rtx
|
|||
force_not_mem (x)
|
||||
rtx x;
|
||||
{
|
||||
register rtx temp;
|
||||
rtx temp;
|
||||
|
||||
if (GET_CODE (x) != MEM || GET_MODE (x) == BLKmode)
|
||||
return x;
|
||||
|
@ -780,7 +780,7 @@ copy_to_suggested_reg (x, target, mode)
|
|||
rtx x, target;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
register rtx temp;
|
||||
rtx temp;
|
||||
|
||||
if (target && GET_CODE (target) == REG)
|
||||
temp = target;
|
||||
|
|
34
gcc/expmed.c
34
gcc/expmed.c
|
@ -302,7 +302,7 @@ store_bit_field (str_rtx, bitsize, bitnum, fieldmode, value, align, total_size)
|
|||
= (GET_CODE (str_rtx) == MEM) ? BITS_PER_UNIT : BITS_PER_WORD;
|
||||
unsigned HOST_WIDE_INT offset = bitnum / unit;
|
||||
unsigned HOST_WIDE_INT bitpos = bitnum % unit;
|
||||
register rtx op0 = str_rtx;
|
||||
rtx op0 = str_rtx;
|
||||
|
||||
enum machine_mode op_mode = mode_for_extraction (EP_insv, 3);
|
||||
|
||||
|
@ -693,12 +693,12 @@ store_bit_field (str_rtx, bitsize, bitnum, fieldmode, value, align, total_size)
|
|||
|
||||
static void
|
||||
store_fixed_bit_field (op0, offset, bitsize, bitpos, value, struct_align)
|
||||
register rtx op0;
|
||||
rtx op0;
|
||||
unsigned HOST_WIDE_INT offset, bitsize, bitpos;
|
||||
register rtx value;
|
||||
rtx value;
|
||||
unsigned int struct_align;
|
||||
{
|
||||
register enum machine_mode mode;
|
||||
enum machine_mode mode;
|
||||
unsigned int total_bits = BITS_PER_WORD;
|
||||
rtx subtarget, temp;
|
||||
int all_zero = 0;
|
||||
|
@ -794,7 +794,7 @@ store_fixed_bit_field (op0, offset, bitsize, bitpos, value, struct_align)
|
|||
|
||||
if (GET_CODE (value) == CONST_INT)
|
||||
{
|
||||
register HOST_WIDE_INT v = INTVAL (value);
|
||||
HOST_WIDE_INT v = INTVAL (value);
|
||||
|
||||
if (bitsize < HOST_BITS_PER_WIDE_INT)
|
||||
v &= ((HOST_WIDE_INT) 1 << bitsize) - 1;
|
||||
|
@ -1033,7 +1033,7 @@ extract_bit_field (str_rtx, bitsize, bitnum, unsignedp,
|
|||
= (GET_CODE (str_rtx) == MEM) ? BITS_PER_UNIT : BITS_PER_WORD;
|
||||
unsigned HOST_WIDE_INT offset = bitnum / unit;
|
||||
unsigned HOST_WIDE_INT bitpos = bitnum % unit;
|
||||
register rtx op0 = str_rtx;
|
||||
rtx op0 = str_rtx;
|
||||
rtx spec_target = target;
|
||||
rtx spec_target_subreg = 0;
|
||||
enum machine_mode int_mode;
|
||||
|
@ -1577,7 +1577,7 @@ static rtx
|
|||
extract_fixed_bit_field (tmode, op0, offset, bitsize, bitpos,
|
||||
target, unsignedp, align)
|
||||
enum machine_mode tmode;
|
||||
register rtx op0, target;
|
||||
rtx op0, target;
|
||||
unsigned HOST_WIDE_INT offset, bitsize, bitpos;
|
||||
int unsignedp;
|
||||
unsigned int align;
|
||||
|
@ -1931,15 +1931,15 @@ expand_dec (target, dec)
|
|||
rtx
|
||||
expand_shift (code, mode, shifted, amount, target, unsignedp)
|
||||
enum tree_code code;
|
||||
register enum machine_mode mode;
|
||||
enum machine_mode mode;
|
||||
rtx shifted;
|
||||
tree amount;
|
||||
register rtx target;
|
||||
rtx target;
|
||||
int unsignedp;
|
||||
{
|
||||
register rtx op1, temp = 0;
|
||||
register int left = (code == LSHIFT_EXPR || code == LROTATE_EXPR);
|
||||
register int rotate = (code == LROTATE_EXPR || code == RROTATE_EXPR);
|
||||
rtx op1, temp = 0;
|
||||
int left = (code == LSHIFT_EXPR || code == LROTATE_EXPR);
|
||||
int rotate = (code == LROTATE_EXPR || code == RROTATE_EXPR);
|
||||
int try;
|
||||
|
||||
/* Previously detected shift-counts computed by NEGATE_EXPR
|
||||
|
@ -2371,7 +2371,7 @@ synth_mult (alg_out, t, cost_limit)
|
|||
rtx
|
||||
expand_mult (mode, op0, op1, target, unsignedp)
|
||||
enum machine_mode mode;
|
||||
register rtx op0, op1, target;
|
||||
rtx op0, op1, target;
|
||||
int unsignedp;
|
||||
{
|
||||
rtx const_op1 = op1;
|
||||
|
@ -2757,7 +2757,7 @@ invert_mod2n (x, n)
|
|||
rtx
|
||||
expand_mult_highpart_adjust (mode, adj_operand, op0, op1, target, unsignedp)
|
||||
enum machine_mode mode;
|
||||
register rtx adj_operand, op0, op1, target;
|
||||
rtx adj_operand, op0, op1, target;
|
||||
int unsignedp;
|
||||
{
|
||||
rtx tem;
|
||||
|
@ -2794,7 +2794,7 @@ expand_mult_highpart_adjust (mode, adj_operand, op0, op1, target, unsignedp)
|
|||
rtx
|
||||
expand_mult_highpart (mode, op0, cnst1, target, unsignedp, max_cost)
|
||||
enum machine_mode mode;
|
||||
register rtx op0, target;
|
||||
rtx op0, target;
|
||||
unsigned HOST_WIDE_INT cnst1;
|
||||
int unsignedp;
|
||||
int max_cost;
|
||||
|
@ -2976,11 +2976,11 @@ expand_divmod (rem_flag, code, mode, op0, op1, target, unsignedp)
|
|||
int rem_flag;
|
||||
enum tree_code code;
|
||||
enum machine_mode mode;
|
||||
register rtx op0, op1, target;
|
||||
rtx op0, op1, target;
|
||||
int unsignedp;
|
||||
{
|
||||
enum machine_mode compute_mode;
|
||||
register rtx tquotient;
|
||||
rtx tquotient;
|
||||
rtx quotient = 0, remainder = 0;
|
||||
rtx last;
|
||||
int size;
|
||||
|
|
88
gcc/expr.c
88
gcc/expr.c
|
@ -365,10 +365,10 @@ enqueue_insn (var, body)
|
|||
|
||||
rtx
|
||||
protect_from_queue (x, modify)
|
||||
register rtx x;
|
||||
rtx x;
|
||||
int modify;
|
||||
{
|
||||
register RTX_CODE code = GET_CODE (x);
|
||||
RTX_CODE code = GET_CODE (x);
|
||||
|
||||
#if 0 /* A QUEUED can hang around after the queue is forced out. */
|
||||
/* Shortcut for most common case. */
|
||||
|
@ -453,7 +453,7 @@ int
|
|||
queued_subexp_p (x)
|
||||
rtx x;
|
||||
{
|
||||
register enum rtx_code code = GET_CODE (x);
|
||||
enum rtx_code code = GET_CODE (x);
|
||||
switch (code)
|
||||
{
|
||||
case QUEUED:
|
||||
|
@ -475,7 +475,7 @@ queued_subexp_p (x)
|
|||
void
|
||||
emit_queue ()
|
||||
{
|
||||
register rtx p;
|
||||
rtx p;
|
||||
while ((p = pending_chain))
|
||||
{
|
||||
rtx body = QUEUED_BODY (p);
|
||||
|
@ -498,7 +498,7 @@ emit_queue ()
|
|||
|
||||
void
|
||||
convert_move (to, from, unsignedp)
|
||||
register rtx to, from;
|
||||
rtx to, from;
|
||||
int unsignedp;
|
||||
{
|
||||
enum machine_mode to_mode = GET_MODE (to);
|
||||
|
@ -1294,7 +1294,7 @@ convert_modes (mode, oldmode, x, unsignedp)
|
|||
rtx x;
|
||||
int unsignedp;
|
||||
{
|
||||
register rtx temp;
|
||||
rtx temp;
|
||||
|
||||
/* If FROM is a SUBREG that indicates that we have already done at least
|
||||
the required extension, strip it. */
|
||||
|
@ -3082,7 +3082,7 @@ push_block (size, extra, below)
|
|||
rtx size;
|
||||
int extra, below;
|
||||
{
|
||||
register rtx temp;
|
||||
rtx temp;
|
||||
|
||||
size = convert_modes (Pmode, ptr_mode, size, 1);
|
||||
if (CONSTANT_P (size))
|
||||
|
@ -3132,7 +3132,7 @@ static rtx
|
|||
get_push_address (size)
|
||||
int size;
|
||||
{
|
||||
register rtx temp;
|
||||
rtx temp;
|
||||
|
||||
if (STACK_PUSH_CODE == POST_DEC)
|
||||
temp = gen_rtx_PLUS (Pmode, stack_pointer_rtx, GEN_INT (size));
|
||||
|
@ -3237,7 +3237,7 @@ void
|
|||
emit_push_insn (x, mode, type, size, align, partial, reg, extra,
|
||||
args_addr, args_so_far, reg_parm_stack_space,
|
||||
alignment_pad)
|
||||
register rtx x;
|
||||
rtx x;
|
||||
enum machine_mode mode;
|
||||
tree type;
|
||||
rtx size;
|
||||
|
@ -3275,7 +3275,7 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
|
|||
{
|
||||
/* Copy a block into the stack, entirely or partially. */
|
||||
|
||||
register rtx temp;
|
||||
rtx temp;
|
||||
int used = partial * UNITS_PER_WORD;
|
||||
int offset = used % (PARM_BOUNDARY / BITS_PER_UNIT);
|
||||
int skip;
|
||||
|
@ -3683,7 +3683,7 @@ expand_assignment (to, from, want_value, suggest_reg)
|
|||
int want_value;
|
||||
int suggest_reg ATTRIBUTE_UNUSED;
|
||||
{
|
||||
register rtx to_rtx = 0;
|
||||
rtx to_rtx = 0;
|
||||
rtx result;
|
||||
|
||||
/* Don't crash if the lhs of the assignment was erroneous. */
|
||||
|
@ -4023,11 +4023,11 @@ expand_assignment (to, from, want_value, suggest_reg)
|
|||
|
||||
rtx
|
||||
store_expr (exp, target, want_value)
|
||||
register tree exp;
|
||||
register rtx target;
|
||||
tree exp;
|
||||
rtx target;
|
||||
int want_value;
|
||||
{
|
||||
register rtx temp;
|
||||
rtx temp;
|
||||
int dont_return_target = 0;
|
||||
int dont_store_target = 0;
|
||||
|
||||
|
@ -4542,7 +4542,7 @@ store_constructor (exp, target, align, cleared, size)
|
|||
if (TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
|
||||
|| TREE_CODE (type) == QUAL_UNION_TYPE)
|
||||
{
|
||||
register tree elt;
|
||||
tree elt;
|
||||
|
||||
/* Inform later passes that the whole union value is dead. */
|
||||
if ((TREE_CODE (type) == UNION_TYPE
|
||||
|
@ -4595,11 +4595,11 @@ store_constructor (exp, target, align, cleared, size)
|
|||
|
||||
for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
|
||||
{
|
||||
register tree field = TREE_PURPOSE (elt);
|
||||
tree field = TREE_PURPOSE (elt);
|
||||
#ifdef WORD_REGISTER_OPERATIONS
|
||||
tree value = TREE_VALUE (elt);
|
||||
#endif
|
||||
register enum machine_mode mode;
|
||||
enum machine_mode mode;
|
||||
HOST_WIDE_INT bitsize;
|
||||
HOST_WIDE_INT bitpos = 0;
|
||||
int unsignedp;
|
||||
|
@ -4709,8 +4709,8 @@ store_constructor (exp, target, align, cleared, size)
|
|||
}
|
||||
else if (TREE_CODE (type) == ARRAY_TYPE)
|
||||
{
|
||||
register tree elt;
|
||||
register int i;
|
||||
tree elt;
|
||||
int i;
|
||||
int need_to_clear;
|
||||
tree domain = TYPE_DOMAIN (type);
|
||||
tree elttype = TREE_TYPE (type);
|
||||
|
@ -4795,7 +4795,7 @@ store_constructor (exp, target, align, cleared, size)
|
|||
elt;
|
||||
elt = TREE_CHAIN (elt), i++)
|
||||
{
|
||||
register enum machine_mode mode;
|
||||
enum machine_mode mode;
|
||||
HOST_WIDE_INT bitsize;
|
||||
HOST_WIDE_INT bitpos;
|
||||
int unsignedp;
|
||||
|
@ -5582,13 +5582,13 @@ rtx
|
|||
force_operand (value, target)
|
||||
rtx value, target;
|
||||
{
|
||||
register optab binoptab = 0;
|
||||
optab binoptab = 0;
|
||||
/* Use a temporary to force order of execution of calls to
|
||||
`force_operand'. */
|
||||
rtx tmp;
|
||||
register rtx op2;
|
||||
rtx op2;
|
||||
/* Use subtarget as the target for operand 0 of a binary operation. */
|
||||
register rtx subtarget = get_subtarget (target);
|
||||
rtx subtarget = get_subtarget (target);
|
||||
|
||||
/* Check for a PIC address load. */
|
||||
if (flag_pic
|
||||
|
@ -6059,16 +6059,16 @@ find_placeholder (exp, plist)
|
|||
|
||||
rtx
|
||||
expand_expr (exp, target, tmode, modifier)
|
||||
register tree exp;
|
||||
tree exp;
|
||||
rtx target;
|
||||
enum machine_mode tmode;
|
||||
enum expand_modifier modifier;
|
||||
{
|
||||
register rtx op0, op1, temp;
|
||||
rtx op0, op1, temp;
|
||||
tree type = TREE_TYPE (exp);
|
||||
int unsignedp = TREE_UNSIGNED (type);
|
||||
register enum machine_mode mode;
|
||||
register enum tree_code code = TREE_CODE (exp);
|
||||
enum machine_mode mode;
|
||||
enum tree_code code = TREE_CODE (exp);
|
||||
optab this_optab;
|
||||
rtx subtarget, original_target;
|
||||
int ignore;
|
||||
|
@ -7658,7 +7658,7 @@ expand_expr (exp, target, tmode, modifier)
|
|||
check the second operand. */
|
||||
if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST)
|
||||
{
|
||||
register tree t1 = TREE_OPERAND (exp, 0);
|
||||
tree t1 = TREE_OPERAND (exp, 0);
|
||||
TREE_OPERAND (exp, 0) = TREE_OPERAND (exp, 1);
|
||||
TREE_OPERAND (exp, 1) = t1;
|
||||
}
|
||||
|
@ -8811,12 +8811,12 @@ expand_expr (exp, target, tmode, modifier)
|
|||
|
||||
static rtx
|
||||
expand_expr_unaligned (exp, palign)
|
||||
register tree exp;
|
||||
tree exp;
|
||||
unsigned int *palign;
|
||||
{
|
||||
register rtx op0;
|
||||
rtx op0;
|
||||
tree type = TREE_TYPE (exp);
|
||||
register enum machine_mode mode = TYPE_MODE (type);
|
||||
enum machine_mode mode = TYPE_MODE (type);
|
||||
|
||||
/* Default the alignment we return to that of the type. */
|
||||
*palign = TYPE_ALIGN (type);
|
||||
|
@ -9163,12 +9163,12 @@ string_constant (arg, ptr_offset)
|
|||
|
||||
static rtx
|
||||
expand_increment (exp, post, ignore)
|
||||
register tree exp;
|
||||
tree exp;
|
||||
int post, ignore;
|
||||
{
|
||||
register rtx op0, op1;
|
||||
register rtx temp, value;
|
||||
register tree incremented = TREE_OPERAND (exp, 0);
|
||||
rtx op0, op1;
|
||||
rtx temp, value;
|
||||
tree incremented = TREE_OPERAND (exp, 0);
|
||||
optab this_optab = add_optab;
|
||||
int icode;
|
||||
enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
|
||||
|
@ -9448,7 +9448,7 @@ do_jump (exp, if_false_label, if_true_label)
|
|||
tree exp;
|
||||
rtx if_false_label, if_true_label;
|
||||
{
|
||||
register enum tree_code code = TREE_CODE (exp);
|
||||
enum tree_code code = TREE_CODE (exp);
|
||||
/* Some cases need to create a label to jump to
|
||||
in order to properly fall through.
|
||||
These cases set DROP_THROUGH_LABEL nonzero. */
|
||||
|
@ -9634,7 +9634,7 @@ do_jump (exp, if_false_label, if_true_label)
|
|||
|
||||
else
|
||||
{
|
||||
register rtx label1 = gen_label_rtx ();
|
||||
rtx label1 = gen_label_rtx ();
|
||||
drop_through_label = gen_label_rtx ();
|
||||
|
||||
do_jump (TREE_OPERAND (exp, 0), label1, NULL_RTX);
|
||||
|
@ -10095,7 +10095,7 @@ do_jump_by_parts_equality_rtx (op0, if_false_label, if_true_label)
|
|||
|
||||
rtx
|
||||
compare_from_rtx (op0, op1, code, unsignedp, mode, size, align)
|
||||
register rtx op0, op1;
|
||||
rtx op0, op1;
|
||||
enum rtx_code code;
|
||||
int unsignedp;
|
||||
enum machine_mode mode;
|
||||
|
@ -10166,7 +10166,7 @@ compare_from_rtx (op0, op1, code, unsignedp, mode, size, align)
|
|||
void
|
||||
do_compare_rtx_and_jump (op0, op1, code, unsignedp, mode, size, align,
|
||||
if_false_label, if_true_label)
|
||||
register rtx op0, op1;
|
||||
rtx op0, op1;
|
||||
enum rtx_code code;
|
||||
int unsignedp;
|
||||
enum machine_mode mode;
|
||||
|
@ -10271,14 +10271,14 @@ do_compare_rtx_and_jump (op0, op1, code, unsignedp, mode, size, align,
|
|||
static void
|
||||
do_compare_and_jump (exp, signed_code, unsigned_code, if_false_label,
|
||||
if_true_label)
|
||||
register tree exp;
|
||||
tree exp;
|
||||
enum rtx_code signed_code, unsigned_code;
|
||||
rtx if_false_label, if_true_label;
|
||||
{
|
||||
unsigned int align0, align1;
|
||||
register rtx op0, op1;
|
||||
register tree type;
|
||||
register enum machine_mode mode;
|
||||
rtx op0, op1;
|
||||
tree type;
|
||||
enum machine_mode mode;
|
||||
int unsignedp;
|
||||
enum rtx_code code;
|
||||
|
||||
|
@ -10754,7 +10754,7 @@ do_tablejump (index, mode, range, table_label, default_label)
|
|||
rtx index, range, table_label, default_label;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
register rtx temp, vector;
|
||||
rtx temp, vector;
|
||||
|
||||
/* Do an unsigned comparison (in the proper mode) between the index
|
||||
expression and the value which represents the length of the range.
|
||||
|
|
36
gcc/final.c
36
gcc/final.c
|
@ -1948,7 +1948,7 @@ final (first, file, optimize, prescan)
|
|||
int optimize;
|
||||
int prescan;
|
||||
{
|
||||
register rtx insn;
|
||||
rtx insn;
|
||||
int max_line = 0;
|
||||
int max_uid = 0;
|
||||
|
||||
|
@ -2205,7 +2205,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes)
|
|||
|
||||
/* This note is a line-number. */
|
||||
{
|
||||
register rtx note;
|
||||
rtx note;
|
||||
int note_after = 0;
|
||||
|
||||
/* If there is anything real after this note, output it.
|
||||
|
@ -2372,7 +2372,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes)
|
|||
|
||||
default:
|
||||
{
|
||||
register rtx body = PATTERN (insn);
|
||||
rtx body = PATTERN (insn);
|
||||
int insn_code_number;
|
||||
const char *template;
|
||||
#ifdef HAVE_cc0
|
||||
|
@ -2406,7 +2406,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes)
|
|||
if (GET_CODE (body) == ADDR_VEC || GET_CODE (body) == ADDR_DIFF_VEC)
|
||||
{
|
||||
#if !(defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC))
|
||||
register int vlen, idx;
|
||||
int vlen, idx;
|
||||
#endif
|
||||
|
||||
if (prescan > 0)
|
||||
|
@ -2541,7 +2541,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes)
|
|||
if (GET_CODE (body) == SEQUENCE)
|
||||
{
|
||||
/* A delayed-branch sequence */
|
||||
register int i;
|
||||
int i;
|
||||
rtx next;
|
||||
|
||||
if (prescan > 0)
|
||||
|
@ -2705,7 +2705,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes)
|
|||
It may also return 1 meaning condition now always true
|
||||
or -1 meaning condition now always false
|
||||
or 2 meaning condition nontrivial but altered. */
|
||||
register int result = alter_cond (XEXP (SET_SRC (body), 0));
|
||||
int result = alter_cond (XEXP (SET_SRC (body), 0));
|
||||
/* If condition now has fixed value, replace the IF_THEN_ELSE
|
||||
with its then-operand or its else-operand. */
|
||||
if (result == 1)
|
||||
|
@ -2766,7 +2766,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes)
|
|||
case EQ:
|
||||
case NE:
|
||||
{
|
||||
register int result;
|
||||
int result;
|
||||
if (XEXP (cond_rtx, 0) != cc0_rtx)
|
||||
break;
|
||||
result = alter_cond (cond_rtx);
|
||||
|
@ -2966,7 +2966,7 @@ static void
|
|||
notice_source_line (insn)
|
||||
rtx insn;
|
||||
{
|
||||
register const char *filename = NOTE_SOURCE_FILE (insn);
|
||||
const char *filename = NOTE_SOURCE_FILE (insn);
|
||||
|
||||
/* Remember filename for basic block profiling.
|
||||
Filenames are allocated on the permanent obstack
|
||||
|
@ -3017,9 +3017,9 @@ cleanup_subreg_operands (insn)
|
|||
|
||||
rtx
|
||||
alter_subreg (x)
|
||||
register rtx x;
|
||||
rtx x;
|
||||
{
|
||||
register rtx y = SUBREG_REG (x);
|
||||
rtx y = SUBREG_REG (x);
|
||||
|
||||
if (GET_CODE (y) == SUBREG)
|
||||
y = alter_subreg (y);
|
||||
|
@ -3097,7 +3097,7 @@ walk_alter_subreg (x)
|
|||
|
||||
static int
|
||||
alter_cond (cond)
|
||||
register rtx cond;
|
||||
rtx cond;
|
||||
{
|
||||
int value = 0;
|
||||
|
||||
|
@ -3286,7 +3286,7 @@ output_asm_name ()
|
|||
alternative used. */
|
||||
if (debug_insn)
|
||||
{
|
||||
register int num = INSN_CODE (debug_insn);
|
||||
int num = INSN_CODE (debug_insn);
|
||||
fprintf (asm_out_file, "\t%s %d\t%s",
|
||||
ASM_COMMENT_START, INSN_UID (debug_insn),
|
||||
insn_data[num].name);
|
||||
|
@ -3308,8 +3308,8 @@ output_asm_insn (template, operands)
|
|||
const char *template;
|
||||
rtx *operands;
|
||||
{
|
||||
register const char *p;
|
||||
register int c;
|
||||
const char *p;
|
||||
int c;
|
||||
|
||||
/* An insn may return a null string template
|
||||
in a case where no assembler code is needed. */
|
||||
|
@ -3342,7 +3342,7 @@ output_asm_insn (template, operands)
|
|||
#ifdef ASSEMBLER_DIALECT
|
||||
case '{':
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
/* If we want the first dialect, do nothing. Otherwise, skip
|
||||
DIALECT_NUMBER of strings ending with '|'. */
|
||||
|
@ -4096,10 +4096,10 @@ leaf_renumber_regs (first)
|
|||
|
||||
void
|
||||
leaf_renumber_regs_insn (in_rtx)
|
||||
register rtx in_rtx;
|
||||
rtx in_rtx;
|
||||
{
|
||||
register int i, j;
|
||||
register const char *format_ptr;
|
||||
int i, j;
|
||||
const char *format_ptr;
|
||||
|
||||
if (in_rtx == 0)
|
||||
return;
|
||||
|
|
|
@ -617,7 +617,7 @@ read_scan_file (in_fname, argc, argv)
|
|||
cpp_options *options;
|
||||
struct fn_decl *fn;
|
||||
int i;
|
||||
register struct symbol_list *cur_symbols;
|
||||
struct symbol_list *cur_symbols;
|
||||
|
||||
obstack_init (&scan_file_obstack);
|
||||
|
||||
|
@ -730,7 +730,7 @@ write_rbrac ()
|
|||
{
|
||||
struct fn_decl *fn;
|
||||
const char *cptr;
|
||||
register struct symbol_list *cur_symbols;
|
||||
struct symbol_list *cur_symbols;
|
||||
|
||||
if (required_unseen_count)
|
||||
{
|
||||
|
@ -929,7 +929,7 @@ inf_read_upto (str, delim)
|
|||
|
||||
static int
|
||||
inf_scan_ident (s, c)
|
||||
register sstring *s;
|
||||
sstring *s;
|
||||
int c;
|
||||
{
|
||||
s->ptr = s->base;
|
||||
|
@ -1074,11 +1074,11 @@ main (argc, argv)
|
|||
int endif_line;
|
||||
long to_read;
|
||||
long int inf_size;
|
||||
register struct symbol_list *cur_symbols;
|
||||
struct symbol_list *cur_symbols;
|
||||
|
||||
if (argv[0] && argv[0][0])
|
||||
{
|
||||
register char *p;
|
||||
char *p;
|
||||
|
||||
progname = 0;
|
||||
for (p = argv[0]; *p; p++)
|
||||
|
|
100
gcc/floatlib.c
100
gcc/floatlib.c
|
@ -100,9 +100,9 @@ union float_long
|
|||
float
|
||||
__addsf3 (float a1, float a2)
|
||||
{
|
||||
register long mant1, mant2;
|
||||
register union float_long fl1, fl2;
|
||||
register int exp1, exp2;
|
||||
long mant1, mant2;
|
||||
union float_long fl1, fl2;
|
||||
int exp1, exp2;
|
||||
int sign = 0;
|
||||
|
||||
fl1.f = a1;
|
||||
|
@ -196,7 +196,7 @@ test_done:
|
|||
float
|
||||
__subsf3 (float a1, float a2)
|
||||
{
|
||||
register union float_long fl1, fl2;
|
||||
union float_long fl1, fl2;
|
||||
|
||||
fl1.f = a1;
|
||||
fl2.f = a2;
|
||||
|
@ -216,7 +216,7 @@ __subsf3 (float a1, float a2)
|
|||
long
|
||||
__cmpsf2 (float a1, float a2)
|
||||
{
|
||||
register union float_long fl1, fl2;
|
||||
union float_long fl1, fl2;
|
||||
|
||||
fl1.f = a1;
|
||||
fl2.f = a2;
|
||||
|
@ -237,9 +237,9 @@ __cmpsf2 (float a1, float a2)
|
|||
float
|
||||
__mulsf3 (float a1, float a2)
|
||||
{
|
||||
register union float_long fl1, fl2;
|
||||
register unsigned long result;
|
||||
register int exp;
|
||||
union float_long fl1, fl2;
|
||||
unsigned long result;
|
||||
int exp;
|
||||
int sign;
|
||||
|
||||
fl1.f = a1;
|
||||
|
@ -294,10 +294,10 @@ test_done:
|
|||
float
|
||||
__divsf3 (float a1, float a2)
|
||||
{
|
||||
register union float_long fl1, fl2;
|
||||
register int result;
|
||||
register int mask;
|
||||
register int exp, sign;
|
||||
union float_long fl1, fl2;
|
||||
int result;
|
||||
int mask;
|
||||
int exp, sign;
|
||||
|
||||
fl1.f = a1;
|
||||
fl2.f = a2;
|
||||
|
@ -358,9 +358,9 @@ __divsf3 (float a1, float a2)
|
|||
|
||||
/* convert int to double */
|
||||
double
|
||||
__floatsidf (register long a1)
|
||||
__floatsidf (long a1)
|
||||
{
|
||||
register int sign = 0, exp = 31 + EXCESSD;
|
||||
int sign = 0, exp = 31 + EXCESSD;
|
||||
union double_long dl;
|
||||
|
||||
if (!a1)
|
||||
|
@ -397,9 +397,9 @@ __floatsidf (register long a1)
|
|||
}
|
||||
|
||||
double
|
||||
__floatdidf (register long long a1)
|
||||
__floatdidf (long long a1)
|
||||
{
|
||||
register int exp = 63 + EXCESSD;
|
||||
int exp = 63 + EXCESSD;
|
||||
union double_long dl;
|
||||
|
||||
dl.l.upper = dl.l.lower = 0;
|
||||
|
@ -428,13 +428,13 @@ __floatdidf (register long long a1)
|
|||
}
|
||||
|
||||
float
|
||||
__floatsisf (register long a1)
|
||||
__floatsisf (long a1)
|
||||
{
|
||||
(float)__floatsidf(a1);
|
||||
}
|
||||
|
||||
float
|
||||
__floatdisf (register long long a1)
|
||||
__floatdisf (long long a1)
|
||||
{
|
||||
(float)__floatdidf(a1);
|
||||
}
|
||||
|
@ -443,7 +443,7 @@ __floatdisf (register long long a1)
|
|||
float
|
||||
__negsf2 (float a1)
|
||||
{
|
||||
register union float_long fl1;
|
||||
union float_long fl1;
|
||||
|
||||
fl1.f = a1;
|
||||
if (!fl1.l)
|
||||
|
@ -457,7 +457,7 @@ __negsf2 (float a1)
|
|||
double
|
||||
__negdf2 (double a1)
|
||||
{
|
||||
register union double_long dl1;
|
||||
union double_long dl1;
|
||||
|
||||
dl1.d = a1;
|
||||
|
||||
|
@ -472,9 +472,9 @@ __negdf2 (double a1)
|
|||
double
|
||||
__extendsfdf2 (float a1)
|
||||
{
|
||||
register union float_long fl1;
|
||||
register union double_long dl;
|
||||
register int exp;
|
||||
union float_long fl1;
|
||||
union double_long dl;
|
||||
int exp;
|
||||
|
||||
fl1.f = a1;
|
||||
|
||||
|
@ -497,10 +497,10 @@ __extendsfdf2 (float a1)
|
|||
float
|
||||
__truncdfsf2 (double a1)
|
||||
{
|
||||
register int exp;
|
||||
register long mant;
|
||||
register union float_long fl;
|
||||
register union double_long dl1;
|
||||
int exp;
|
||||
long mant;
|
||||
union float_long fl;
|
||||
union double_long dl1;
|
||||
|
||||
dl1.d = a1;
|
||||
|
||||
|
@ -534,7 +534,7 @@ __truncdfsf2 (double a1)
|
|||
long
|
||||
__cmpdf2 (double a1, double a2)
|
||||
{
|
||||
register union double_long dl1, dl2;
|
||||
union double_long dl1, dl2;
|
||||
|
||||
dl1.d = a1;
|
||||
dl2.d = a2;
|
||||
|
@ -559,9 +559,9 @@ __cmpdf2 (double a1, double a2)
|
|||
long
|
||||
__fixdfsi (double a1)
|
||||
{
|
||||
register union double_long dl1;
|
||||
register int exp;
|
||||
register long l;
|
||||
union double_long dl1;
|
||||
int exp;
|
||||
long l;
|
||||
|
||||
dl1.d = a1;
|
||||
|
||||
|
@ -587,9 +587,9 @@ __fixdfsi (double a1)
|
|||
long long
|
||||
__fixdfdi (double a1)
|
||||
{
|
||||
register union double_long dl1;
|
||||
register int exp;
|
||||
register long long l;
|
||||
union double_long dl1;
|
||||
int exp;
|
||||
long long l;
|
||||
|
||||
dl1.d = a1;
|
||||
|
||||
|
@ -619,9 +619,9 @@ __fixdfdi (double a1)
|
|||
unsigned long
|
||||
__fixunsdfsi (double a1)
|
||||
{
|
||||
register union double_long dl1;
|
||||
register int exp;
|
||||
register unsigned long l;
|
||||
union double_long dl1;
|
||||
int exp;
|
||||
unsigned long l;
|
||||
|
||||
dl1.d = a1;
|
||||
|
||||
|
@ -647,9 +647,9 @@ __fixunsdfsi (double a1)
|
|||
unsigned long long
|
||||
__fixunsdfdi (double a1)
|
||||
{
|
||||
register union double_long dl1;
|
||||
register int exp;
|
||||
register unsigned long long l;
|
||||
union double_long dl1;
|
||||
int exp;
|
||||
unsigned long long l;
|
||||
|
||||
dl1.d = a1;
|
||||
|
||||
|
@ -676,9 +676,9 @@ __fixunsdfdi (double a1)
|
|||
double
|
||||
__adddf3 (double a1, double a2)
|
||||
{
|
||||
register long long mant1, mant2;
|
||||
register union double_long fl1, fl2;
|
||||
register int exp1, exp2;
|
||||
long long mant1, mant2;
|
||||
union double_long fl1, fl2;
|
||||
int exp1, exp2;
|
||||
int sign = 0;
|
||||
|
||||
fl1.d = a1;
|
||||
|
@ -765,7 +765,7 @@ test_done:
|
|||
double
|
||||
__subdf3 (double a1, double a2)
|
||||
{
|
||||
register union double_long fl1, fl2;
|
||||
union double_long fl1, fl2;
|
||||
|
||||
fl1.d = a1;
|
||||
fl2.d = a2;
|
||||
|
@ -784,9 +784,9 @@ __subdf3 (double a1, double a2)
|
|||
double
|
||||
__muldf3 (double a1, double a2)
|
||||
{
|
||||
register union double_long fl1, fl2;
|
||||
register unsigned long long result;
|
||||
register int exp;
|
||||
union double_long fl1, fl2;
|
||||
unsigned long long result;
|
||||
int exp;
|
||||
int sign;
|
||||
|
||||
fl1.d = a1;
|
||||
|
@ -838,9 +838,9 @@ test_done:
|
|||
double
|
||||
__divdf3 (double a1, double a2)
|
||||
{
|
||||
register union double_long fl1, fl2;
|
||||
register long long mask,result;
|
||||
register int exp, sign;
|
||||
union double_long fl1, fl2;
|
||||
long long mask,result;
|
||||
int exp, sign;
|
||||
|
||||
fl1.d = a1;
|
||||
fl2.d = a2;
|
||||
|
|
49
gcc/flow.c
49
gcc/flow.c
|
@ -416,7 +416,7 @@ life_analysis (f, file, flags)
|
|||
int flags;
|
||||
{
|
||||
#ifdef ELIMINABLE_REGS
|
||||
register int i;
|
||||
int i;
|
||||
static const struct {const int from, to; } eliminables[] = ELIMINABLE_REGS;
|
||||
#endif
|
||||
|
||||
|
@ -1273,7 +1273,7 @@ calculate_global_regs_live (blocks_in, blocks_out, flags)
|
|||
void
|
||||
allocate_bb_life_data ()
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n_basic_blocks; i++)
|
||||
{
|
||||
|
@ -1452,7 +1452,7 @@ propagate_one_insn (pbi, insn)
|
|||
a following memory address. */
|
||||
#ifdef AUTO_INC_DEC
|
||||
{
|
||||
register rtx x = single_set (insn);
|
||||
rtx x = single_set (insn);
|
||||
|
||||
/* Does this instruction increment or decrement a register? */
|
||||
if ((flags & PROP_AUTOINC)
|
||||
|
@ -1510,7 +1510,7 @@ propagate_one_insn (pbi, insn)
|
|||
|
||||
if (GET_CODE (insn) == CALL_INSN)
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
rtx note, cond;
|
||||
|
||||
cond = NULL_RTX;
|
||||
|
@ -1560,7 +1560,7 @@ propagate_one_insn (pbi, insn)
|
|||
|
||||
if (! insn_is_dead && GET_CODE (insn) == CALL_INSN)
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
rtx note, cond;
|
||||
|
||||
cond = NULL_RTX;
|
||||
|
@ -1815,7 +1815,7 @@ propagate_block (bb, live, local_set, cond_local_set, flags)
|
|||
|
||||
if (flags & PROP_REG_INFO)
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
/* Process the regs live at the end of the block.
|
||||
Mark them as not local to any one basic block. */
|
||||
|
@ -2062,13 +2062,13 @@ libcall_dead_p (pbi, note, insn)
|
|||
|
||||
if (x)
|
||||
{
|
||||
register rtx r = SET_SRC (x);
|
||||
rtx r = SET_SRC (x);
|
||||
|
||||
if (GET_CODE (r) == REG)
|
||||
{
|
||||
rtx call = XEXP (note, 0);
|
||||
rtx call_pat;
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
/* Find the call insn. */
|
||||
while (call != insn && GET_CODE (call) != CALL_INSN)
|
||||
|
@ -2271,7 +2271,8 @@ mark_set_regs (pbi, x, insn)
|
|||
|
||||
case PARALLEL:
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
|
||||
{
|
||||
rtx sub = XVECEXP (x, 0, i);
|
||||
|
@ -2486,8 +2487,8 @@ mark_set_1 (pbi, code, reg, cond, insn, flags)
|
|||
if (flags & (PROP_LOG_LINKS | PROP_REG_INFO
|
||||
| PROP_DEATH_NOTES | PROP_AUTOINC))
|
||||
{
|
||||
register rtx y;
|
||||
register int blocknum = pbi->bb->index;
|
||||
rtx y;
|
||||
int blocknum = pbi->bb->index;
|
||||
|
||||
y = NULL_RTX;
|
||||
if (flags & (PROP_LOG_LINKS | PROP_AUTOINC))
|
||||
|
@ -3331,7 +3332,7 @@ mark_used_reg (pbi, reg, cond, insn)
|
|||
{
|
||||
/* Keep track of which basic block each reg appears in. */
|
||||
|
||||
register int blocknum = pbi->bb->index;
|
||||
int blocknum = pbi->bb->index;
|
||||
if (REG_BASIC_BLOCK (regno_first) == REG_BLOCK_UNKNOWN)
|
||||
REG_BASIC_BLOCK (regno_first) = blocknum;
|
||||
else if (REG_BASIC_BLOCK (regno_first) != blocknum)
|
||||
|
@ -3463,8 +3464,8 @@ mark_used_regs (pbi, x, cond, insn)
|
|||
struct propagate_block_info *pbi;
|
||||
rtx x, cond, insn;
|
||||
{
|
||||
register RTX_CODE code;
|
||||
register int regno;
|
||||
RTX_CODE code;
|
||||
int regno;
|
||||
int flags = pbi->flags;
|
||||
|
||||
retry:
|
||||
|
@ -3565,7 +3566,7 @@ mark_used_regs (pbi, x, cond, insn)
|
|||
|
||||
case SET:
|
||||
{
|
||||
register rtx testreg = SET_DEST (x);
|
||||
rtx testreg = SET_DEST (x);
|
||||
int mark_dest = 0;
|
||||
|
||||
/* If storing into MEM, don't show it as being used. But do
|
||||
|
@ -3704,8 +3705,8 @@ mark_used_regs (pbi, x, cond, insn)
|
|||
/* Recursively scan the operands of this expression. */
|
||||
|
||||
{
|
||||
register const char * const fmt = GET_RTX_FORMAT (code);
|
||||
register int i;
|
||||
const char * const fmt = GET_RTX_FORMAT (code);
|
||||
int i;
|
||||
|
||||
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
||||
{
|
||||
|
@ -3721,7 +3722,7 @@ mark_used_regs (pbi, x, cond, insn)
|
|||
}
|
||||
else if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = 0; j < XVECLEN (x, i); j++)
|
||||
mark_used_regs (pbi, XVECEXP (x, i, j), cond, insn);
|
||||
}
|
||||
|
@ -3784,7 +3785,7 @@ try_pre_increment (insn, reg, amount)
|
|||
rtx insn, reg;
|
||||
HOST_WIDE_INT amount;
|
||||
{
|
||||
register rtx use;
|
||||
rtx use;
|
||||
|
||||
/* Nonzero if we can try to make a pre-increment or pre-decrement.
|
||||
For example, addl $4,r1; movl (r1),... can become movl +(r1),... */
|
||||
|
@ -3861,15 +3862,15 @@ try_pre_increment (insn, reg, amount)
|
|||
|
||||
rtx
|
||||
find_use_as_address (x, reg, plusconst)
|
||||
register rtx x;
|
||||
rtx x;
|
||||
rtx reg;
|
||||
HOST_WIDE_INT plusconst;
|
||||
{
|
||||
enum rtx_code code = GET_CODE (x);
|
||||
const char * const fmt = GET_RTX_FORMAT (code);
|
||||
register int i;
|
||||
register rtx value = 0;
|
||||
register rtx tem;
|
||||
int i;
|
||||
rtx value = 0;
|
||||
rtx tem;
|
||||
|
||||
if (code == MEM && XEXP (x, 0) == reg && plusconst == 0)
|
||||
return x;
|
||||
|
@ -3903,7 +3904,7 @@ find_use_as_address (x, reg, plusconst)
|
|||
}
|
||||
else if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
||||
{
|
||||
tem = find_use_as_address (XVECEXP (x, i, j), reg, plusconst);
|
||||
|
|
|
@ -324,8 +324,8 @@ mul_double (l1, h1, l2, h2, lv, hv)
|
|||
HOST_WIDE_INT arg1[4];
|
||||
HOST_WIDE_INT arg2[4];
|
||||
HOST_WIDE_INT prod[4 * 2];
|
||||
register unsigned HOST_WIDE_INT carry;
|
||||
register int i, j, k;
|
||||
unsigned HOST_WIDE_INT carry;
|
||||
int i, j, k;
|
||||
unsigned HOST_WIDE_INT toplow, neglow;
|
||||
HOST_WIDE_INT tophigh, neghigh;
|
||||
|
||||
|
@ -537,7 +537,7 @@ div_and_round_double (code, uns,
|
|||
int quo_neg = 0;
|
||||
HOST_WIDE_INT num[4 + 1]; /* extra element for scaling. */
|
||||
HOST_WIDE_INT den[4], quo[4];
|
||||
register int i, j;
|
||||
int i, j;
|
||||
unsigned HOST_WIDE_INT work;
|
||||
unsigned HOST_WIDE_INT carry = 0;
|
||||
unsigned HOST_WIDE_INT lnum = lnum_orig;
|
||||
|
@ -1486,7 +1486,7 @@ associate_trees (t1, t2, code, type)
|
|||
static tree
|
||||
int_const_binop (code, arg1, arg2, notrunc)
|
||||
enum tree_code code;
|
||||
register tree arg1, arg2;
|
||||
tree arg1, arg2;
|
||||
int notrunc;
|
||||
{
|
||||
unsigned HOST_WIDE_INT int1l, int2l;
|
||||
|
@ -1495,7 +1495,7 @@ int_const_binop (code, arg1, arg2, notrunc)
|
|||
HOST_WIDE_INT hi;
|
||||
unsigned HOST_WIDE_INT garbagel;
|
||||
HOST_WIDE_INT garbageh;
|
||||
register tree t;
|
||||
tree t;
|
||||
tree type = TREE_TYPE (arg1);
|
||||
int uns = TREE_UNSIGNED (type);
|
||||
int is_sizetype
|
||||
|
@ -1744,7 +1744,7 @@ const_binop_1 (data)
|
|||
static tree
|
||||
const_binop (code, arg1, arg2, notrunc)
|
||||
enum tree_code code;
|
||||
register tree arg1, arg2;
|
||||
tree arg1, arg2;
|
||||
int notrunc;
|
||||
{
|
||||
STRIP_NOPS (arg1);
|
||||
|
@ -1800,12 +1800,12 @@ const_binop (code, arg1, arg2, notrunc)
|
|||
#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
|
||||
if (TREE_CODE (arg1) == COMPLEX_CST)
|
||||
{
|
||||
register tree type = TREE_TYPE (arg1);
|
||||
register tree r1 = TREE_REALPART (arg1);
|
||||
register tree i1 = TREE_IMAGPART (arg1);
|
||||
register tree r2 = TREE_REALPART (arg2);
|
||||
register tree i2 = TREE_IMAGPART (arg2);
|
||||
register tree t;
|
||||
tree type = TREE_TYPE (arg1);
|
||||
tree r1 = TREE_REALPART (arg1);
|
||||
tree i1 = TREE_IMAGPART (arg1);
|
||||
tree r2 = TREE_REALPART (arg2);
|
||||
tree i2 = TREE_IMAGPART (arg2);
|
||||
tree t;
|
||||
|
||||
switch (code)
|
||||
{
|
||||
|
@ -1839,7 +1839,7 @@ const_binop (code, arg1, arg2, notrunc)
|
|||
|
||||
case RDIV_EXPR:
|
||||
{
|
||||
register tree magsquared
|
||||
tree magsquared
|
||||
= const_binop (PLUS_EXPR,
|
||||
const_binop (MULT_EXPR, r2, r2, notrunc),
|
||||
const_binop (MULT_EXPR, i2, i2, notrunc),
|
||||
|
@ -2069,10 +2069,10 @@ fold_convert_1 (data)
|
|||
|
||||
static tree
|
||||
fold_convert (t, arg1)
|
||||
register tree t;
|
||||
register tree arg1;
|
||||
tree t;
|
||||
tree arg1;
|
||||
{
|
||||
register tree type = TREE_TYPE (t);
|
||||
tree type = TREE_TYPE (t);
|
||||
int overflow = 0;
|
||||
|
||||
if (POINTER_TYPE_P (type) || INTEGRAL_TYPE_P (type))
|
||||
|
@ -4913,13 +4913,13 @@ tree
|
|||
fold (expr)
|
||||
tree expr;
|
||||
{
|
||||
register tree t = expr;
|
||||
tree t = expr;
|
||||
tree t1 = NULL_TREE;
|
||||
tree tem;
|
||||
tree type = TREE_TYPE (expr);
|
||||
register tree arg0 = NULL_TREE, arg1 = NULL_TREE;
|
||||
register enum tree_code code = TREE_CODE (t);
|
||||
register int kind = TREE_CODE_CLASS (code);
|
||||
tree arg0 = NULL_TREE, arg1 = NULL_TREE;
|
||||
enum tree_code code = TREE_CODE (t);
|
||||
int kind = TREE_CODE_CLASS (code);
|
||||
int invert;
|
||||
/* WINS will be nonzero when the switch is done
|
||||
if all operands are constant. */
|
||||
|
@ -4966,8 +4966,8 @@ fold (expr)
|
|||
}
|
||||
else if (IS_EXPR_CODE_CLASS (kind) || kind == 'r')
|
||||
{
|
||||
register int len = first_rtl_op (code);
|
||||
register int i;
|
||||
int len = first_rtl_op (code);
|
||||
int i;
|
||||
for (i = 0; i < len; i++)
|
||||
{
|
||||
tree op = TREE_OPERAND (t, i);
|
||||
|
@ -5544,7 +5544,7 @@ fold (expr)
|
|||
/* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
|
||||
is a rotate of A by B bits. */
|
||||
{
|
||||
register enum tree_code code0, code1;
|
||||
enum tree_code code0, code1;
|
||||
code0 = TREE_CODE (arg0);
|
||||
code1 = TREE_CODE (arg1);
|
||||
if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
|
||||
|
@ -5553,8 +5553,8 @@ fold (expr)
|
|||
TREE_OPERAND (arg1, 0), 0)
|
||||
&& TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
|
||||
{
|
||||
register tree tree01, tree11;
|
||||
register enum tree_code code01, code11;
|
||||
tree tree01, tree11;
|
||||
enum tree_code code01, code11;
|
||||
|
||||
tree01 = TREE_OPERAND (arg0, 1);
|
||||
tree11 = TREE_OPERAND (arg1, 1);
|
||||
|
|
|
@ -523,7 +523,7 @@ assign_stack_local_1 (mode, size, align, function)
|
|||
int align;
|
||||
struct function *function;
|
||||
{
|
||||
register rtx x, addr;
|
||||
rtx x, addr;
|
||||
int bigend_correction = 0;
|
||||
int alignment;
|
||||
|
||||
|
@ -1303,7 +1303,7 @@ void
|
|||
put_var_into_stack (decl)
|
||||
tree decl;
|
||||
{
|
||||
register rtx reg;
|
||||
rtx reg;
|
||||
enum machine_mode promoted_mode, decl_mode;
|
||||
struct function *function = 0;
|
||||
tree context;
|
||||
|
@ -1879,17 +1879,17 @@ fixup_var_refs_insn (insn, var, promoted_mode, unsignedp, toplevel)
|
|||
|
||||
static void
|
||||
fixup_var_refs_1 (var, promoted_mode, loc, insn, replacements)
|
||||
register rtx var;
|
||||
rtx var;
|
||||
enum machine_mode promoted_mode;
|
||||
register rtx *loc;
|
||||
rtx *loc;
|
||||
rtx insn;
|
||||
struct fixup_replacement **replacements;
|
||||
{
|
||||
register int i;
|
||||
register rtx x = *loc;
|
||||
int i;
|
||||
rtx x = *loc;
|
||||
RTX_CODE code = GET_CODE (x);
|
||||
register const char *fmt;
|
||||
register rtx tem, tem1;
|
||||
const char *fmt;
|
||||
rtx tem, tem1;
|
||||
struct fixup_replacement *replacement;
|
||||
|
||||
switch (code)
|
||||
|
@ -2458,7 +2458,7 @@ fixup_var_refs_1 (var, promoted_mode, loc, insn, replacements)
|
|||
fixup_var_refs_1 (var, promoted_mode, &XEXP (x, i), insn, replacements);
|
||||
else if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = 0; j < XVECLEN (x, i); j++)
|
||||
fixup_var_refs_1 (var, promoted_mode, &XVECEXP (x, i, j),
|
||||
insn, replacements);
|
||||
|
@ -2512,13 +2512,13 @@ fixup_memory_subreg (x, insn, uncritical)
|
|||
|
||||
static rtx
|
||||
walk_fixup_memory_subreg (x, insn, uncritical)
|
||||
register rtx x;
|
||||
rtx x;
|
||||
rtx insn;
|
||||
int uncritical;
|
||||
{
|
||||
register enum rtx_code code;
|
||||
register const char *fmt;
|
||||
register int i;
|
||||
enum rtx_code code;
|
||||
const char *fmt;
|
||||
int i;
|
||||
|
||||
if (x == 0)
|
||||
return 0;
|
||||
|
@ -2537,7 +2537,7 @@ walk_fixup_memory_subreg (x, insn, uncritical)
|
|||
XEXP (x, i) = walk_fixup_memory_subreg (XEXP (x, i), insn, uncritical);
|
||||
else if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = 0; j < XVECLEN (x, i); j++)
|
||||
XVECEXP (x, i, j)
|
||||
= walk_fixup_memory_subreg (XVECEXP (x, i, j), insn, uncritical);
|
||||
|
@ -2557,13 +2557,13 @@ fixup_stack_1 (x, insn)
|
|||
rtx x;
|
||||
rtx insn;
|
||||
{
|
||||
register int i;
|
||||
register RTX_CODE code = GET_CODE (x);
|
||||
register const char *fmt;
|
||||
int i;
|
||||
RTX_CODE code = GET_CODE (x);
|
||||
const char *fmt;
|
||||
|
||||
if (code == MEM)
|
||||
{
|
||||
register rtx ad = XEXP (x, 0);
|
||||
rtx ad = XEXP (x, 0);
|
||||
/* If we have address of a stack slot but it's not valid
|
||||
(displacement is too large), compute the sum in a register. */
|
||||
if (GET_CODE (ad) == PLUS
|
||||
|
@ -2600,7 +2600,7 @@ fixup_stack_1 (x, insn)
|
|||
XEXP (x, i) = fixup_stack_1 (XEXP (x, i), insn);
|
||||
else if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = 0; j < XVECLEN (x, i); j++)
|
||||
XVECEXP (x, i, j) = fixup_stack_1 (XVECEXP (x, i, j), insn);
|
||||
}
|
||||
|
@ -2625,7 +2625,7 @@ optimize_bit_field (body, insn, equiv_mem)
|
|||
rtx insn;
|
||||
rtx *equiv_mem;
|
||||
{
|
||||
register rtx bitfield;
|
||||
rtx bitfield;
|
||||
int destflag;
|
||||
rtx seq = 0;
|
||||
enum machine_mode mode;
|
||||
|
@ -2645,7 +2645,7 @@ optimize_bit_field (body, insn, equiv_mem)
|
|||
!= BLKmode)
|
||||
&& INTVAL (XEXP (bitfield, 2)) % INTVAL (XEXP (bitfield, 1)) == 0)
|
||||
{
|
||||
register rtx memref = 0;
|
||||
rtx memref = 0;
|
||||
|
||||
/* Now check that the containing word is memory, not a register,
|
||||
and that it is safe to change the machine mode. */
|
||||
|
@ -4150,8 +4150,8 @@ get_first_nonparm_insn ()
|
|||
rtx
|
||||
get_first_block_beg ()
|
||||
{
|
||||
register rtx searcher;
|
||||
register rtx insn = get_first_nonparm_insn ();
|
||||
rtx searcher;
|
||||
rtx insn = get_first_nonparm_insn ();
|
||||
|
||||
for (searcher = insn; searcher; searcher = NEXT_INSN (searcher))
|
||||
if (GET_CODE (searcher) == NOTE
|
||||
|
@ -4211,9 +4211,9 @@ void
|
|||
assign_parms (fndecl)
|
||||
tree fndecl;
|
||||
{
|
||||
register tree parm;
|
||||
register rtx entry_parm = 0;
|
||||
register rtx stack_parm = 0;
|
||||
tree parm;
|
||||
rtx entry_parm = 0;
|
||||
rtx stack_parm = 0;
|
||||
CUMULATIVE_ARGS args_so_far;
|
||||
enum machine_mode promoted_mode, passed_mode;
|
||||
enum machine_mode nominal_mode, promoted_nominal_mode;
|
||||
|
@ -4660,7 +4660,7 @@ assign_parms (fndecl)
|
|||
/* Store the parm in a pseudoregister during the function, but we
|
||||
may need to do it in a wider mode. */
|
||||
|
||||
register rtx parmreg;
|
||||
rtx parmreg;
|
||||
unsigned int regno, regnoi = 0, regnor = 0;
|
||||
|
||||
unsignedp = TREE_UNSIGNED (TREE_TYPE (parm));
|
||||
|
@ -5354,7 +5354,7 @@ void
|
|||
uninitialized_vars_warning (block)
|
||||
tree block;
|
||||
{
|
||||
register tree decl, sub;
|
||||
tree decl, sub;
|
||||
for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
|
||||
{
|
||||
if (warn_uninitialized
|
||||
|
@ -5395,7 +5395,7 @@ uninitialized_vars_warning (block)
|
|||
void
|
||||
setjmp_args_warning ()
|
||||
{
|
||||
register tree decl;
|
||||
tree decl;
|
||||
for (decl = DECL_ARGUMENTS (current_function_decl);
|
||||
decl; decl = TREE_CHAIN (decl))
|
||||
if (DECL_RTL (decl) != 0
|
||||
|
@ -5412,7 +5412,7 @@ void
|
|||
setjmp_protect (block)
|
||||
tree block;
|
||||
{
|
||||
register tree decl, sub;
|
||||
tree decl, sub;
|
||||
for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
|
||||
if ((TREE_CODE (decl) == VAR_DECL
|
||||
|| TREE_CODE (decl) == PARM_DECL)
|
||||
|
@ -5444,7 +5444,7 @@ setjmp_protect (block)
|
|||
void
|
||||
setjmp_protect_args ()
|
||||
{
|
||||
register tree decl;
|
||||
tree decl;
|
||||
for (decl = DECL_ARGUMENTS (current_function_decl);
|
||||
decl; decl = TREE_CHAIN (decl))
|
||||
if ((TREE_CODE (decl) == VAR_DECL
|
||||
|
@ -5969,7 +5969,7 @@ static tree
|
|||
blocks_nreverse (t)
|
||||
tree t;
|
||||
{
|
||||
register tree prev = 0, decl, next;
|
||||
tree prev = 0, decl, next;
|
||||
for (decl = t; decl; decl = next)
|
||||
{
|
||||
next = BLOCK_CHAIN (decl);
|
||||
|
@ -6403,7 +6403,7 @@ expand_function_start (subr, parms_have_cleanups)
|
|||
if (aggregate_value_p (DECL_RESULT (subr)))
|
||||
{
|
||||
/* Returning something that won't go in a register. */
|
||||
register rtx value_address = 0;
|
||||
rtx value_address = 0;
|
||||
|
||||
#ifdef PCC_STATIC_STRUCT_RETURN
|
||||
if (current_function_returns_pcc_struct)
|
||||
|
@ -7046,7 +7046,7 @@ contains (insn, vec)
|
|||
rtx insn;
|
||||
varray_type vec;
|
||||
{
|
||||
register int i, j;
|
||||
int i, j;
|
||||
|
||||
if (GET_CODE (insn) == INSN
|
||||
&& GET_CODE (PATTERN (insn)) == SEQUENCE)
|
||||
|
@ -7487,7 +7487,7 @@ reposition_prologue_and_epilogue_notes (f)
|
|||
|
||||
if ((len = VARRAY_SIZE (prologue)) > 0)
|
||||
{
|
||||
register rtx insn, note = 0;
|
||||
rtx insn, note = 0;
|
||||
|
||||
/* Scan from the beginning until we reach the last prologue insn.
|
||||
We apparently can't depend on basic_block_{head,end} after
|
||||
|
@ -7530,7 +7530,7 @@ reposition_prologue_and_epilogue_notes (f)
|
|||
|
||||
if ((len = VARRAY_SIZE (epilogue)) > 0)
|
||||
{
|
||||
register rtx insn, note = 0;
|
||||
rtx insn, note = 0;
|
||||
|
||||
/* Scan from the end until we reach the first epilogue insn.
|
||||
We apparently can't depend on basic_block_{head,end} after
|
||||
|
|
44
gcc/gcc.c
44
gcc/gcc.c
|
@ -1737,7 +1737,7 @@ read_specs (filename, main_p)
|
|||
int main_p;
|
||||
{
|
||||
char *buffer;
|
||||
register char *p;
|
||||
char *p;
|
||||
|
||||
buffer = load_specs (filename);
|
||||
|
||||
|
@ -2003,11 +2003,11 @@ record_temp_file (filename, always_delete, fail_delete)
|
|||
int always_delete;
|
||||
int fail_delete;
|
||||
{
|
||||
register char *const name = xstrdup (filename);
|
||||
char *const name = xstrdup (filename);
|
||||
|
||||
if (always_delete)
|
||||
{
|
||||
register struct temp_file *temp;
|
||||
struct temp_file *temp;
|
||||
for (temp = always_delete_queue; temp; temp = temp->next)
|
||||
if (! strcmp (name, temp->name))
|
||||
goto already1;
|
||||
|
@ -2022,7 +2022,7 @@ record_temp_file (filename, always_delete, fail_delete)
|
|||
|
||||
if (fail_delete)
|
||||
{
|
||||
register struct temp_file *temp;
|
||||
struct temp_file *temp;
|
||||
for (temp = failure_delete_queue; temp; temp = temp->next)
|
||||
if (! strcmp (name, temp->name))
|
||||
goto already2;
|
||||
|
@ -2064,7 +2064,7 @@ delete_if_ordinary (name)
|
|||
static void
|
||||
delete_temp_files ()
|
||||
{
|
||||
register struct temp_file *temp;
|
||||
struct temp_file *temp;
|
||||
|
||||
for (temp = always_delete_queue; temp; temp = temp->next)
|
||||
delete_if_ordinary (temp->name);
|
||||
|
@ -2076,7 +2076,7 @@ delete_temp_files ()
|
|||
static void
|
||||
delete_failure_queue ()
|
||||
{
|
||||
register struct temp_file *temp;
|
||||
struct temp_file *temp;
|
||||
|
||||
for (temp = failure_delete_queue; temp; temp = temp->next)
|
||||
delete_if_ordinary (temp->name);
|
||||
|
@ -3065,7 +3065,7 @@ process_command (argc, argv)
|
|||
int argc;
|
||||
const char *const *argv;
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
const char *temp;
|
||||
char *temp1;
|
||||
const char *spec_lang = 0;
|
||||
|
@ -3413,8 +3413,8 @@ process_command (argc, argv)
|
|||
report_times = 1;
|
||||
else if (argv[i][0] == '-' && argv[i][1] != 0)
|
||||
{
|
||||
register const char *p = &argv[i][1];
|
||||
register int c = *p;
|
||||
const char *p = &argv[i][1];
|
||||
int c = *p;
|
||||
|
||||
switch (c)
|
||||
{
|
||||
|
@ -4060,8 +4060,8 @@ do_spec_1 (spec, inswitch, soft_matched_part)
|
|||
int inswitch;
|
||||
const char *soft_matched_part;
|
||||
{
|
||||
register const char *p = spec;
|
||||
register int c;
|
||||
const char *p = spec;
|
||||
int c;
|
||||
int i;
|
||||
const char *string;
|
||||
int value;
|
||||
|
@ -5004,7 +5004,7 @@ do_spec_1 (spec, inswitch, soft_matched_part)
|
|||
|
||||
static const char *
|
||||
handle_braces (p)
|
||||
register const char *p;
|
||||
const char *p;
|
||||
{
|
||||
const char *filter, *body = NULL, *endbody = NULL;
|
||||
int pipe_p = 0;
|
||||
|
@ -5076,8 +5076,8 @@ next_member:
|
|||
{
|
||||
if (*p != '}' && *p != '&')
|
||||
{
|
||||
register int count = 1;
|
||||
register const char *q = p;
|
||||
int count = 1;
|
||||
const char *q = p;
|
||||
|
||||
while (*q++ != ':')
|
||||
continue;
|
||||
|
@ -5115,7 +5115,7 @@ next_member:
|
|||
else if (p[-1] == '*' && (p[0] == '}' || p[0] == '&'))
|
||||
{
|
||||
/* Substitute all matching switches as separate args. */
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n_switches; i++)
|
||||
if (!strncmp (switches[i].part1, filter, p - 1 - filter)
|
||||
|
@ -5133,7 +5133,7 @@ next_member:
|
|||
else
|
||||
{
|
||||
/* Test for presence of the specified switch. */
|
||||
register int i;
|
||||
int i;
|
||||
int present = 0;
|
||||
|
||||
/* If name specified ends in *, as in {x*:...},
|
||||
|
@ -5487,7 +5487,7 @@ static void
|
|||
set_input (filename)
|
||||
const char *filename;
|
||||
{
|
||||
register const char *p;
|
||||
const char *p;
|
||||
|
||||
input_filename = filename;
|
||||
input_filename_length = strlen (input_filename);
|
||||
|
@ -6138,7 +6138,7 @@ save_string (s, len)
|
|||
const char *s;
|
||||
int len;
|
||||
{
|
||||
register char *result = xmalloc (len + 1);
|
||||
char *result = xmalloc (len + 1);
|
||||
|
||||
memcpy (result, s, len);
|
||||
result[len] = 0;
|
||||
|
@ -6232,8 +6232,8 @@ static void
|
|||
validate_all_switches ()
|
||||
{
|
||||
struct compiler *comp;
|
||||
register const char *p;
|
||||
register char c;
|
||||
const char *p;
|
||||
char c;
|
||||
struct spec_list *spec;
|
||||
|
||||
for (comp = compilers; comp->spec; comp++)
|
||||
|
@ -6269,9 +6269,9 @@ static void
|
|||
validate_switches (start)
|
||||
const char *start;
|
||||
{
|
||||
register const char *p = start;
|
||||
const char *p = start;
|
||||
const char *filter;
|
||||
register int i;
|
||||
int i;
|
||||
int suffix;
|
||||
|
||||
if (*p == '|')
|
||||
|
|
|
@ -1798,9 +1798,9 @@ static int
|
|||
expr_equiv_p (x, y)
|
||||
rtx x, y;
|
||||
{
|
||||
register int i, j;
|
||||
register enum rtx_code code;
|
||||
register const char *fmt;
|
||||
int i, j;
|
||||
enum rtx_code code;
|
||||
const char *fmt;
|
||||
|
||||
if (x == y)
|
||||
return 1;
|
||||
|
|
|
@ -69,7 +69,7 @@ parse_fn_proto (start, end, fn)
|
|||
char *start, *end;
|
||||
struct fn_decl *fn;
|
||||
{
|
||||
register char *ptr;
|
||||
char *ptr;
|
||||
int param_nesting = 1;
|
||||
char *param_start, *param_end, *decl_start, *name_start, *name_end;
|
||||
|
||||
|
|
|
@ -503,7 +503,7 @@ attr_hash_add_rtx (hashcode, rtl)
|
|||
int hashcode;
|
||||
rtx rtl;
|
||||
{
|
||||
register struct attr_hash *h;
|
||||
struct attr_hash *h;
|
||||
|
||||
h = (struct attr_hash *) obstack_alloc (hash_obstack,
|
||||
sizeof (struct attr_hash));
|
||||
|
@ -520,7 +520,7 @@ attr_hash_add_string (hashcode, str)
|
|||
int hashcode;
|
||||
char *str;
|
||||
{
|
||||
register struct attr_hash *h;
|
||||
struct attr_hash *h;
|
||||
|
||||
h = (struct attr_hash *) obstack_alloc (hash_obstack,
|
||||
sizeof (struct attr_hash));
|
||||
|
@ -547,11 +547,11 @@ attr_rtx VPARAMS ((enum rtx_code code, ...))
|
|||
enum rtx_code code;
|
||||
#endif
|
||||
va_list p;
|
||||
register int i; /* Array indices... */
|
||||
register const char *fmt; /* Current rtx's format... */
|
||||
register rtx rt_val = NULL_RTX;/* RTX to return to caller... */
|
||||
int i; /* Array indices... */
|
||||
const char *fmt; /* Current rtx's format... */
|
||||
rtx rt_val = NULL_RTX;/* RTX to return to caller... */
|
||||
int hashcode;
|
||||
register struct attr_hash *h;
|
||||
struct attr_hash *h;
|
||||
struct obstack *old_obstack = rtl_obstack;
|
||||
|
||||
VA_START (p, code);
|
||||
|
@ -743,7 +743,7 @@ attr_rtx VPARAMS ((enum rtx_code code, ...))
|
|||
rtx attr_printf (len, format, [arg1, ..., argn]) */
|
||||
|
||||
static char *
|
||||
attr_printf VPARAMS ((register unsigned int len, const char *fmt, ...))
|
||||
attr_printf VPARAMS ((unsigned int len, const char *fmt, ...))
|
||||
{
|
||||
char str[256];
|
||||
|
||||
|
@ -783,10 +783,10 @@ attr_string (str, len)
|
|||
const char *str;
|
||||
int len;
|
||||
{
|
||||
register struct attr_hash *h;
|
||||
struct attr_hash *h;
|
||||
int hashcode;
|
||||
int i;
|
||||
register char *new_str;
|
||||
char *new_str;
|
||||
|
||||
/* Compute the hash code. */
|
||||
hashcode = (len + 1) * 613 + (unsigned) str[0];
|
||||
|
@ -828,12 +828,12 @@ attr_equal_p (x, y)
|
|||
|
||||
static rtx
|
||||
attr_copy_rtx (orig)
|
||||
register rtx orig;
|
||||
rtx orig;
|
||||
{
|
||||
register rtx copy;
|
||||
register int i, j;
|
||||
register RTX_CODE code;
|
||||
register const char *format_ptr;
|
||||
rtx copy;
|
||||
int i, j;
|
||||
RTX_CODE code;
|
||||
const char *format_ptr;
|
||||
|
||||
/* No need to copy a permanent object. */
|
||||
if (RTX_INTEGRATED_P (orig))
|
||||
|
@ -2260,10 +2260,10 @@ static rtx
|
|||
encode_units_mask (x)
|
||||
rtx x;
|
||||
{
|
||||
register int i;
|
||||
register int j;
|
||||
register enum rtx_code code;
|
||||
register const char *fmt;
|
||||
int i;
|
||||
int j;
|
||||
enum rtx_code code;
|
||||
const char *fmt;
|
||||
|
||||
code = GET_CODE (x);
|
||||
|
||||
|
@ -4024,7 +4024,7 @@ static rtx
|
|||
simplify_with_current_value_aux (exp)
|
||||
rtx exp;
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
rtx cond;
|
||||
|
||||
switch (GET_CODE (exp))
|
||||
|
@ -4103,10 +4103,10 @@ static void
|
|||
clear_struct_flag (x)
|
||||
rtx x;
|
||||
{
|
||||
register int i;
|
||||
register int j;
|
||||
register enum rtx_code code;
|
||||
register const char *fmt;
|
||||
int i;
|
||||
int j;
|
||||
enum rtx_code code;
|
||||
const char *fmt;
|
||||
|
||||
MEM_IN_STRUCT_P (x) = 0;
|
||||
if (RTX_UNCHANGING_P (x))
|
||||
|
@ -4161,10 +4161,10 @@ count_sub_rtxs (x, max)
|
|||
rtx x;
|
||||
int max;
|
||||
{
|
||||
register int i;
|
||||
register int j;
|
||||
register enum rtx_code code;
|
||||
register const char *fmt;
|
||||
int i;
|
||||
int j;
|
||||
enum rtx_code code;
|
||||
const char *fmt;
|
||||
int total = 0;
|
||||
|
||||
code = GET_CODE (x);
|
||||
|
@ -4907,8 +4907,8 @@ static void
|
|||
walk_attr_value (exp)
|
||||
rtx exp;
|
||||
{
|
||||
register int i, j;
|
||||
register const char *fmt;
|
||||
int i, j;
|
||||
const char *fmt;
|
||||
RTX_CODE code;
|
||||
|
||||
if (exp == NULL)
|
||||
|
@ -5276,11 +5276,11 @@ write_expr_attr_cache (p, attr)
|
|||
return 0;
|
||||
|
||||
if (!attr->is_numeric)
|
||||
printf (" register enum attr_%s ", attr->name);
|
||||
printf (" enum attr_%s ", attr->name);
|
||||
else if (attr->unsigned_p)
|
||||
printf (" register unsigned int ");
|
||||
printf (" unsigned int ");
|
||||
else
|
||||
printf (" register int ");
|
||||
printf (" int ");
|
||||
|
||||
printf ("attr_%s = get_attr_%s (insn);\n", attr->name, attr->name);
|
||||
return 1;
|
||||
|
@ -5325,7 +5325,7 @@ write_toplevel_expr (p)
|
|||
if (!attr->is_const)
|
||||
write_expr_attr_cache (p, attr);
|
||||
|
||||
printf (" register unsigned long accum = 0;\n\n");
|
||||
printf (" unsigned long accum = 0;\n\n");
|
||||
|
||||
while (GET_CODE (p) == IOR)
|
||||
{
|
||||
|
@ -5983,11 +5983,11 @@ extend_range (range, min, max)
|
|||
|
||||
static rtx
|
||||
copy_rtx_unchanging (orig)
|
||||
register rtx orig;
|
||||
rtx orig;
|
||||
{
|
||||
#if 0
|
||||
register rtx copy;
|
||||
register RTX_CODE code;
|
||||
rtx copy;
|
||||
RTX_CODE code;
|
||||
#endif
|
||||
|
||||
if (RTX_UNCHANGING_P (orig) || MEM_IN_STRUCT_P (orig))
|
||||
|
|
|
@ -77,9 +77,9 @@ main (argc, argv)
|
|||
we link against libiberty.a. (ghazi@caip.rutgers.edu 6/3/98) */
|
||||
PTR
|
||||
xmalloc (nbytes)
|
||||
size_t nbytes;
|
||||
size_t nbytes;
|
||||
{
|
||||
register PTR tmp = (PTR) really_call_malloc (nbytes);
|
||||
PTR tmp = (PTR) really_call_malloc (nbytes);
|
||||
|
||||
if (!tmp)
|
||||
{
|
||||
|
|
|
@ -67,9 +67,9 @@ walk_insn_part (part, recog_p, non_pc_set_src)
|
|||
int recog_p;
|
||||
int non_pc_set_src;
|
||||
{
|
||||
register int i, j;
|
||||
register RTX_CODE code;
|
||||
register const char *format_ptr;
|
||||
int i, j;
|
||||
RTX_CODE code;
|
||||
const char *format_ptr;
|
||||
|
||||
if (part == 0)
|
||||
return;
|
||||
|
|
|
@ -72,10 +72,10 @@ static void
|
|||
max_operand_1 (x)
|
||||
rtx x;
|
||||
{
|
||||
register RTX_CODE code;
|
||||
register int i;
|
||||
register int len;
|
||||
register const char *fmt;
|
||||
RTX_CODE code;
|
||||
int i;
|
||||
int len;
|
||||
const char *fmt;
|
||||
|
||||
if (x == 0)
|
||||
return;
|
||||
|
@ -114,8 +114,8 @@ max_operand_vec (insn, arg)
|
|||
rtx insn;
|
||||
int arg;
|
||||
{
|
||||
register int len = XVECLEN (insn, arg);
|
||||
register int i;
|
||||
int len = XVECLEN (insn, arg);
|
||||
int i;
|
||||
|
||||
max_opno = -1;
|
||||
max_dup_opno = -1;
|
||||
|
@ -131,7 +131,7 @@ static void
|
|||
print_code (code)
|
||||
RTX_CODE code;
|
||||
{
|
||||
register const char *p1;
|
||||
const char *p1;
|
||||
for (p1 = GET_RTX_NAME (code); *p1; p1++)
|
||||
putchar (TOUPPER(*p1));
|
||||
}
|
||||
|
@ -159,10 +159,10 @@ gen_exp (x, subroutine_type)
|
|||
rtx x;
|
||||
enum rtx_code subroutine_type;
|
||||
{
|
||||
register RTX_CODE code;
|
||||
register int i;
|
||||
register int len;
|
||||
register const char *fmt;
|
||||
RTX_CODE code;
|
||||
int i;
|
||||
int len;
|
||||
const char *fmt;
|
||||
|
||||
if (x == 0)
|
||||
{
|
||||
|
@ -291,7 +291,7 @@ gen_insn (insn)
|
|||
rtx insn;
|
||||
{
|
||||
int operands;
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
/* See if the pattern for this insn ends with a group of CLOBBERs of (hard)
|
||||
registers or MATCH_SCRATCHes. If so, store away the information for
|
||||
|
@ -314,10 +314,10 @@ gen_insn (insn)
|
|||
|
||||
if (i != XVECLEN (insn, 1) - 1)
|
||||
{
|
||||
register struct clobber_pat *p;
|
||||
register struct clobber_ent *link
|
||||
struct clobber_pat *p;
|
||||
struct clobber_ent *link
|
||||
= (struct clobber_ent *) xmalloc (sizeof (struct clobber_ent));
|
||||
register int j;
|
||||
int j;
|
||||
|
||||
link->code_number = insn_code_number;
|
||||
|
||||
|
@ -421,7 +421,7 @@ gen_expand (expand)
|
|||
rtx expand;
|
||||
{
|
||||
int operands;
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
if (strlen (XSTR (expand, 0)) == 0)
|
||||
fatal ("define_expand lacks a name");
|
||||
|
@ -556,7 +556,7 @@ static void
|
|||
gen_split (split)
|
||||
rtx split;
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
int operands;
|
||||
const char *const name =
|
||||
((GET_CODE (split) == DEFINE_PEEPHOLE2) ? "peephole2" : "split");
|
||||
|
|
|
@ -102,9 +102,9 @@ static void
|
|||
gen_insn (insn)
|
||||
rtx insn;
|
||||
{
|
||||
register int i;
|
||||
register struct extraction *p;
|
||||
register struct code_ptr *link;
|
||||
int i;
|
||||
struct extraction *p;
|
||||
struct code_ptr *link;
|
||||
|
||||
op_count = 0;
|
||||
dup_count = 0;
|
||||
|
@ -183,10 +183,10 @@ walk_rtx (x, path)
|
|||
rtx x;
|
||||
const char *path;
|
||||
{
|
||||
register RTX_CODE code;
|
||||
register int i;
|
||||
register int len;
|
||||
register const char *fmt;
|
||||
RTX_CODE code;
|
||||
int i;
|
||||
int len;
|
||||
const char *fmt;
|
||||
int depth = strlen (path);
|
||||
char *newpath;
|
||||
|
||||
|
@ -307,8 +307,8 @@ static void
|
|||
print_path (path)
|
||||
const char *path;
|
||||
{
|
||||
register int len = strlen (path);
|
||||
register int i;
|
||||
int len = strlen (path);
|
||||
int i;
|
||||
|
||||
if (len == 0)
|
||||
{
|
||||
|
@ -387,8 +387,8 @@ from the machine description file `md'. */\n\n");
|
|||
printf ("void\ninsn_extract (insn)\n");
|
||||
printf (" rtx insn;\n");
|
||||
printf ("{\n");
|
||||
printf (" register rtx *ro = recog_data.operand;\n");
|
||||
printf (" register rtx **ro_loc = recog_data.operand_loc;\n");
|
||||
printf (" rtx *ro = recog_data.operand;\n");
|
||||
printf (" rtx **ro_loc = recog_data.operand_loc;\n");
|
||||
printf (" rtx pat = PATTERN (insn);\n");
|
||||
printf (" int i ATTRIBUTE_UNUSED;\n\n");
|
||||
printf (" memset (ro, 0, sizeof (*ro) * MAX_RECOG_OPERANDS);\n");
|
||||
|
|
|
@ -54,10 +54,10 @@ static void
|
|||
max_operand_1 (x)
|
||||
rtx x;
|
||||
{
|
||||
register RTX_CODE code;
|
||||
register int i;
|
||||
register int len;
|
||||
register const char *fmt;
|
||||
RTX_CODE code;
|
||||
int i;
|
||||
int len;
|
||||
const char *fmt;
|
||||
|
||||
if (x == 0)
|
||||
return;
|
||||
|
@ -87,8 +87,8 @@ static int
|
|||
num_operands (insn)
|
||||
rtx insn;
|
||||
{
|
||||
register int len = XVECLEN (insn, 1);
|
||||
register int i;
|
||||
int len = XVECLEN (insn, 1);
|
||||
int i;
|
||||
|
||||
max_opno = -1;
|
||||
|
||||
|
|
|
@ -395,7 +395,7 @@ PTR
|
|||
xmalloc (nbytes)
|
||||
size_t nbytes;
|
||||
{
|
||||
register PTR tmp = (PTR) really_call_malloc (nbytes);
|
||||
PTR tmp = (PTR) really_call_malloc (nbytes);
|
||||
|
||||
if (!tmp)
|
||||
{
|
||||
|
|
|
@ -247,7 +247,7 @@ static void
|
|||
output_predicate_decls ()
|
||||
{
|
||||
struct predicate *predicates = 0;
|
||||
register struct operand_data *d;
|
||||
struct operand_data *d;
|
||||
struct predicate *p, *next;
|
||||
|
||||
for (d = odata; d; d = d->next)
|
||||
|
@ -279,7 +279,7 @@ output_predicate_decls ()
|
|||
static void
|
||||
output_operand_data ()
|
||||
{
|
||||
register struct operand_data *d;
|
||||
struct operand_data *d;
|
||||
|
||||
printf ("\nstatic const struct insn_operand_data operand_data[] = \n{\n");
|
||||
|
||||
|
@ -306,12 +306,12 @@ output_operand_data ()
|
|||
static void
|
||||
output_insn_data ()
|
||||
{
|
||||
register struct data *d;
|
||||
struct data *d;
|
||||
int name_offset = 0;
|
||||
int next_name_offset;
|
||||
const char * last_name = 0;
|
||||
const char * next_name = 0;
|
||||
register struct data *n;
|
||||
struct data *n;
|
||||
|
||||
for (n = idata, next_name_offset = 1; n; n = n->next, next_name_offset++)
|
||||
if (n->name)
|
||||
|
@ -429,8 +429,8 @@ scan_operands (d, part, this_address_p, this_strict_low)
|
|||
int this_address_p;
|
||||
int this_strict_low;
|
||||
{
|
||||
register int i, j;
|
||||
register const char *format_ptr;
|
||||
int i, j;
|
||||
const char *format_ptr;
|
||||
int opno;
|
||||
|
||||
if (part == 0)
|
||||
|
@ -662,8 +662,8 @@ process_template (d, template)
|
|||
struct data *d;
|
||||
const char *template;
|
||||
{
|
||||
register const char *cp;
|
||||
register int i;
|
||||
const char *cp;
|
||||
int i;
|
||||
|
||||
/* Templates starting with * contain straight code to be run. */
|
||||
if (template[0] == '*')
|
||||
|
@ -732,7 +732,7 @@ static void
|
|||
validate_insn_alternatives (d)
|
||||
struct data *d;
|
||||
{
|
||||
register int n = 0, start;
|
||||
int n = 0, start;
|
||||
|
||||
/* Make sure all the operands have the same number of alternatives
|
||||
in their constraints. Let N be that number. */
|
||||
|
@ -779,8 +779,8 @@ gen_insn (insn, lineno)
|
|||
rtx insn;
|
||||
int lineno;
|
||||
{
|
||||
register struct data *d = (struct data *) xmalloc (sizeof (struct data));
|
||||
register int i;
|
||||
struct data *d = (struct data *) xmalloc (sizeof (struct data));
|
||||
int i;
|
||||
|
||||
d->code_number = next_code_number;
|
||||
d->index_number = next_index_number;
|
||||
|
@ -821,8 +821,8 @@ gen_peephole (peep, lineno)
|
|||
rtx peep;
|
||||
int lineno;
|
||||
{
|
||||
register struct data *d = (struct data *) xmalloc (sizeof (struct data));
|
||||
register int i;
|
||||
struct data *d = (struct data *) xmalloc (sizeof (struct data));
|
||||
int i;
|
||||
|
||||
d->code_number = next_code_number;
|
||||
d->index_number = next_index_number;
|
||||
|
@ -861,8 +861,8 @@ gen_expand (insn, lineno)
|
|||
rtx insn;
|
||||
int lineno;
|
||||
{
|
||||
register struct data *d = (struct data *) xmalloc (sizeof (struct data));
|
||||
register int i;
|
||||
struct data *d = (struct data *) xmalloc (sizeof (struct data));
|
||||
int i;
|
||||
|
||||
d->code_number = next_code_number;
|
||||
d->index_number = next_index_number;
|
||||
|
@ -906,8 +906,8 @@ gen_split (split, lineno)
|
|||
rtx split;
|
||||
int lineno;
|
||||
{
|
||||
register struct data *d = (struct data *) xmalloc (sizeof (struct data));
|
||||
register int i;
|
||||
struct data *d = (struct data *) xmalloc (sizeof (struct data));
|
||||
int i;
|
||||
|
||||
d->code_number = next_code_number;
|
||||
d->index_number = next_index_number;
|
||||
|
|
|
@ -146,10 +146,10 @@ match_rtx (x, path, fail_label)
|
|||
struct link *path;
|
||||
int fail_label;
|
||||
{
|
||||
register RTX_CODE code;
|
||||
register int i;
|
||||
register int len;
|
||||
register const char *fmt;
|
||||
RTX_CODE code;
|
||||
int i;
|
||||
int len;
|
||||
const char *fmt;
|
||||
struct link link;
|
||||
|
||||
if (x == 0)
|
||||
|
@ -364,7 +364,7 @@ static void
|
|||
print_code (code)
|
||||
RTX_CODE code;
|
||||
{
|
||||
register const char *p1;
|
||||
const char *p1;
|
||||
for (p1 = GET_RTX_NAME (code); *p1; p1++)
|
||||
putchar (TOUPPER(*p1));
|
||||
}
|
||||
|
|
|
@ -319,7 +319,7 @@ new_decision (position, last)
|
|||
const char *position;
|
||||
struct decision_head *last;
|
||||
{
|
||||
register struct decision *new
|
||||
struct decision *new
|
||||
= (struct decision *) xmalloc (sizeof (struct decision));
|
||||
|
||||
memset (new, 0, sizeof (*new));
|
||||
|
@ -777,8 +777,8 @@ add_to_sequence (pattern, last, position, insn_type, top)
|
|||
struct decision_test *test;
|
||||
struct decision_test **place;
|
||||
char *subpos;
|
||||
register size_t i;
|
||||
register const char *fmt;
|
||||
size_t i;
|
||||
const char *fmt;
|
||||
int depth = strlen (position);
|
||||
int len;
|
||||
enum machine_mode mode;
|
||||
|
@ -1009,7 +1009,7 @@ add_to_sequence (pattern, last, position, insn_type, top)
|
|||
|
||||
case 'E':
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = 0; j < XVECLEN (pattern, i); j++)
|
||||
{
|
||||
subpos[depth] = 'a' + j;
|
||||
|
@ -1772,7 +1772,7 @@ static void
|
|||
print_code (code)
|
||||
enum rtx_code code;
|
||||
{
|
||||
register const char *p;
|
||||
const char *p;
|
||||
for (p = GET_RTX_NAME (code); *p; p++)
|
||||
putchar (TOUPPER (*p));
|
||||
}
|
||||
|
@ -2271,7 +2271,7 @@ write_tree (head, prevpos, type, initial)
|
|||
enum routine_type type;
|
||||
int initial;
|
||||
{
|
||||
register struct decision *p = head->first;
|
||||
struct decision *p = head->first;
|
||||
|
||||
putchar ('\n');
|
||||
if (p->need_label)
|
||||
|
@ -2349,7 +2349,7 @@ write_subroutine (head, type)
|
|||
printf ("%sint recog%s PARAMS ((rtx, rtx, int *));\n", s_or_e, extension);
|
||||
printf ("%sint\n\
|
||||
recog%s (x0, insn, pnum_clobbers)\n\
|
||||
register rtx x0;\n\
|
||||
rtx x0;\n\
|
||||
rtx insn ATTRIBUTE_UNUSED;\n\
|
||||
int *pnum_clobbers ATTRIBUTE_UNUSED;\n", s_or_e, extension);
|
||||
break;
|
||||
|
@ -2357,7 +2357,7 @@ recog%s (x0, insn, pnum_clobbers)\n\
|
|||
printf ("%srtx split%s PARAMS ((rtx, rtx));\n", s_or_e, extension);
|
||||
printf ("%srtx\n\
|
||||
split%s (x0, insn)\n\
|
||||
register rtx x0;\n\
|
||||
rtx x0;\n\
|
||||
rtx insn ATTRIBUTE_UNUSED;\n", s_or_e, extension);
|
||||
break;
|
||||
case PEEPHOLE2:
|
||||
|
@ -2365,15 +2365,15 @@ split%s (x0, insn)\n\
|
|||
s_or_e, extension);
|
||||
printf ("%srtx\n\
|
||||
peephole2%s (x0, insn, _pmatch_len)\n\
|
||||
register rtx x0;\n\
|
||||
rtx x0;\n\
|
||||
rtx insn ATTRIBUTE_UNUSED;\n\
|
||||
int *_pmatch_len ATTRIBUTE_UNUSED;\n", s_or_e, extension);
|
||||
break;
|
||||
}
|
||||
|
||||
printf ("{\n register rtx * const operands ATTRIBUTE_UNUSED = &recog_data.operand[0];\n");
|
||||
printf ("{\n rtx * const operands ATTRIBUTE_UNUSED = &recog_data.operand[0];\n");
|
||||
for (i = 1; i <= max_depth; i++)
|
||||
printf (" register rtx x%d ATTRIBUTE_UNUSED;\n", i);
|
||||
printf (" rtx x%d ATTRIBUTE_UNUSED;\n", i);
|
||||
|
||||
printf (" %s tem ATTRIBUTE_UNUSED;\n", IS_SPLIT (type) ? "rtx" : "int");
|
||||
|
||||
|
|
|
@ -112,8 +112,8 @@ static void
|
|||
remove_constraints (part)
|
||||
rtx part;
|
||||
{
|
||||
register int i, j;
|
||||
register const char *format_ptr;
|
||||
int i, j;
|
||||
const char *format_ptr;
|
||||
|
||||
if (part == 0)
|
||||
return;
|
||||
|
@ -847,8 +847,8 @@ char *
|
|||
xstrdup (input)
|
||||
const char *input;
|
||||
{
|
||||
register size_t len = strlen (input) + 1;
|
||||
register char *output = xmalloc (len);
|
||||
size_t len = strlen (input) + 1;
|
||||
char *output = xmalloc (len);
|
||||
memcpy (output, input, len);
|
||||
return output;
|
||||
}
|
||||
|
@ -873,7 +873,7 @@ xrealloc (old, size)
|
|||
PTR old;
|
||||
size_t size;
|
||||
{
|
||||
register PTR ptr;
|
||||
PTR ptr;
|
||||
if (old)
|
||||
ptr = (PTR) really_call_realloc (old, size);
|
||||
else
|
||||
|
@ -887,7 +887,7 @@ PTR
|
|||
xmalloc (size)
|
||||
size_t size;
|
||||
{
|
||||
register PTR val = (PTR) really_call_malloc (size);
|
||||
PTR val = (PTR) really_call_malloc (size);
|
||||
|
||||
if (val == 0)
|
||||
fatal ("virtual memory exhausted");
|
||||
|
|
79
gcc/global.c
79
gcc/global.c
|
@ -335,7 +335,7 @@ global_alloc (file)
|
|||
#endif
|
||||
|| FRAME_POINTER_REQUIRED);
|
||||
|
||||
register size_t i;
|
||||
size_t i;
|
||||
rtx x;
|
||||
|
||||
max_allocno = 0;
|
||||
|
@ -614,11 +614,11 @@ allocno_compare (v1p, v2p)
|
|||
times a register can occur in one insn (surely less than 100)
|
||||
weighted by the frequency (maximally REG_FREQ_MAX).
|
||||
Multiplying this by 10000/REG_FREQ_MAX can't overflow. */
|
||||
register int pri1
|
||||
int pri1
|
||||
= (((double) (floor_log2 (allocno[v1].n_refs) * allocno[v1].freq)
|
||||
/ allocno[v1].live_length)
|
||||
* (10000 / REG_FREQ_MAX) * allocno[v1].size);
|
||||
register int pri2
|
||||
int pri2
|
||||
= (((double) (floor_log2 (allocno[v2].n_refs) * allocno[v2].freq)
|
||||
/ allocno[v2].live_length)
|
||||
* (10000 / REG_FREQ_MAX) * allocno[v2].size);
|
||||
|
@ -636,8 +636,8 @@ allocno_compare (v1p, v2p)
|
|||
static void
|
||||
global_conflicts ()
|
||||
{
|
||||
register int b, i;
|
||||
register rtx insn;
|
||||
int b, i;
|
||||
rtx insn;
|
||||
int *block_start_allocnos;
|
||||
|
||||
/* Make a vector that mark_reg_{store,clobber} will store in. */
|
||||
|
@ -664,13 +664,13 @@ global_conflicts ()
|
|||
are explicitly marked in basic_block_live_at_start. */
|
||||
|
||||
{
|
||||
register regset old = BASIC_BLOCK (b)->global_live_at_start;
|
||||
regset old = BASIC_BLOCK (b)->global_live_at_start;
|
||||
int ax = 0;
|
||||
|
||||
REG_SET_TO_HARD_REG_SET (hard_regs_live, old);
|
||||
EXECUTE_IF_SET_IN_REG_SET (old, FIRST_PSEUDO_REGISTER, i,
|
||||
{
|
||||
register int a = reg_allocno[i];
|
||||
int a = reg_allocno[i];
|
||||
if (a >= 0)
|
||||
{
|
||||
SET_ALLOCNO_LIVE (a);
|
||||
|
@ -731,8 +731,8 @@ global_conflicts ()
|
|||
|
||||
while (1)
|
||||
{
|
||||
register RTX_CODE code = GET_CODE (insn);
|
||||
register rtx link;
|
||||
RTX_CODE code = GET_CODE (insn);
|
||||
rtx link;
|
||||
|
||||
/* Make regs_set an empty set. */
|
||||
|
||||
|
@ -984,7 +984,7 @@ find_reg (num, losers, alt_regs_p, accept_call_clobbered, retrying)
|
|||
int accept_call_clobbered;
|
||||
int retrying;
|
||||
{
|
||||
register int i, best_reg, pass;
|
||||
int i, best_reg, pass;
|
||||
#ifdef HARD_REG_SET
|
||||
register /* Declare it register if it's a scalar. */
|
||||
#endif
|
||||
|
@ -1048,8 +1048,8 @@ find_reg (num, losers, alt_regs_p, accept_call_clobbered, retrying)
|
|||
|| accept_call_clobbered
|
||||
|| ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode)))
|
||||
{
|
||||
register int j;
|
||||
register int lim = regno + HARD_REGNO_NREGS (regno, mode);
|
||||
int j;
|
||||
int lim = regno + HARD_REGNO_NREGS (regno, mode);
|
||||
for (j = regno + 1;
|
||||
(j < lim
|
||||
&& ! TEST_HARD_REG_BIT (used, j));
|
||||
|
@ -1092,8 +1092,8 @@ find_reg (num, losers, alt_regs_p, accept_call_clobbered, retrying)
|
|||
|| reg_class_subset_p (REGNO_REG_CLASS (best_reg),
|
||||
REGNO_REG_CLASS (i))))
|
||||
{
|
||||
register int j;
|
||||
register int lim = i + HARD_REGNO_NREGS (i, mode);
|
||||
int j;
|
||||
int lim = i + HARD_REGNO_NREGS (i, mode);
|
||||
for (j = i + 1;
|
||||
(j < lim
|
||||
&& ! TEST_HARD_REG_BIT (used, j)
|
||||
|
@ -1128,8 +1128,8 @@ find_reg (num, losers, alt_regs_p, accept_call_clobbered, retrying)
|
|||
|| reg_class_subset_p (REGNO_REG_CLASS (best_reg),
|
||||
REGNO_REG_CLASS (i))))
|
||||
{
|
||||
register int j;
|
||||
register int lim = i + HARD_REGNO_NREGS (i, mode);
|
||||
int j;
|
||||
int lim = i + HARD_REGNO_NREGS (i, mode);
|
||||
for (j = i + 1;
|
||||
(j < lim
|
||||
&& ! TEST_HARD_REG_BIT (used, j)
|
||||
|
@ -1246,7 +1246,7 @@ find_reg (num, losers, alt_regs_p, accept_call_clobbered, retrying)
|
|||
|
||||
if (best_reg >= 0)
|
||||
{
|
||||
register int lim, j;
|
||||
int lim, j;
|
||||
HARD_REG_SET this_reg;
|
||||
|
||||
/* Yes. Record it as the hard register of this pseudo-reg. */
|
||||
|
@ -1322,7 +1322,7 @@ static void
|
|||
record_one_conflict (regno)
|
||||
int regno;
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
|
||||
if (regno < FIRST_PSEUDO_REGISTER)
|
||||
/* When a hard register becomes live,
|
||||
|
@ -1336,8 +1336,9 @@ record_one_conflict (regno)
|
|||
record conflicts first with hard regs,
|
||||
then with other pseudo regs. */
|
||||
{
|
||||
register int ialloc = reg_allocno[regno];
|
||||
register int ialloc_prod = ialloc * allocno_row_words;
|
||||
int ialloc = reg_allocno[regno];
|
||||
int ialloc_prod = ialloc * allocno_row_words;
|
||||
|
||||
IOR_HARD_REG_SET (allocno[ialloc].hard_reg_conflicts, hard_regs_live);
|
||||
for (j = allocno_row_words - 1; j >= 0; j--)
|
||||
{
|
||||
|
@ -1363,11 +1364,11 @@ record_one_conflict (regno)
|
|||
|
||||
static void
|
||||
record_conflicts (allocno_vec, len)
|
||||
register int *allocno_vec;
|
||||
register int len;
|
||||
int *allocno_vec;
|
||||
int len;
|
||||
{
|
||||
register int num;
|
||||
register int ialloc_prod;
|
||||
int num;
|
||||
int ialloc_prod;
|
||||
|
||||
while (--len >= 0)
|
||||
{
|
||||
|
@ -1381,7 +1382,7 @@ record_conflicts (allocno_vec, len)
|
|||
static void
|
||||
mirror_conflicts ()
|
||||
{
|
||||
register int i, j;
|
||||
int i, j;
|
||||
int rw = allocno_row_words;
|
||||
int rwb = rw * INT_BITS;
|
||||
INT_TYPE *p = conflicts;
|
||||
|
@ -1431,7 +1432,7 @@ mark_reg_store (reg, setter, data)
|
|||
rtx reg, setter;
|
||||
void *data ATTRIBUTE_UNUSED;
|
||||
{
|
||||
register int regno;
|
||||
int regno;
|
||||
|
||||
if (GET_CODE (reg) == SUBREG)
|
||||
reg = SUBREG_REG (reg);
|
||||
|
@ -1463,7 +1464,7 @@ mark_reg_store (reg, setter, data)
|
|||
/* Handle hardware regs (and pseudos allocated to hard regs). */
|
||||
if (regno < FIRST_PSEUDO_REGISTER && ! fixed_regs[regno])
|
||||
{
|
||||
register int last = regno + HARD_REGNO_NREGS (regno, GET_MODE (reg));
|
||||
int last = regno + HARD_REGNO_NREGS (regno, GET_MODE (reg));
|
||||
while (regno < last)
|
||||
{
|
||||
record_one_conflict (regno);
|
||||
|
@ -1491,7 +1492,7 @@ static void
|
|||
mark_reg_conflicts (reg)
|
||||
rtx reg;
|
||||
{
|
||||
register int regno;
|
||||
int regno;
|
||||
|
||||
if (GET_CODE (reg) == SUBREG)
|
||||
reg = SUBREG_REG (reg);
|
||||
|
@ -1515,7 +1516,7 @@ mark_reg_conflicts (reg)
|
|||
/* Handle hardware regs (and pseudos allocated to hard regs). */
|
||||
if (regno < FIRST_PSEUDO_REGISTER && ! fixed_regs[regno])
|
||||
{
|
||||
register int last = regno + HARD_REGNO_NREGS (regno, GET_MODE (reg));
|
||||
int last = regno + HARD_REGNO_NREGS (regno, GET_MODE (reg));
|
||||
while (regno < last)
|
||||
{
|
||||
record_one_conflict (regno);
|
||||
|
@ -1531,7 +1532,7 @@ static void
|
|||
mark_reg_death (reg)
|
||||
rtx reg;
|
||||
{
|
||||
register int regno = REGNO (reg);
|
||||
int regno = REGNO (reg);
|
||||
|
||||
/* Either this is one of the max_allocno pseudo regs not allocated,
|
||||
or it is a hardware reg. First handle the pseudo-regs. */
|
||||
|
@ -1550,7 +1551,7 @@ mark_reg_death (reg)
|
|||
{
|
||||
/* Pseudo regs already assigned hardware regs are treated
|
||||
almost the same as explicit hardware regs. */
|
||||
register int last = regno + HARD_REGNO_NREGS (regno, GET_MODE (reg));
|
||||
int last = regno + HARD_REGNO_NREGS (regno, GET_MODE (reg));
|
||||
while (regno < last)
|
||||
{
|
||||
CLEAR_HARD_REG_BIT (hard_regs_live, regno);
|
||||
|
@ -1566,10 +1567,10 @@ mark_reg_death (reg)
|
|||
|
||||
static void
|
||||
mark_reg_live_nc (regno, mode)
|
||||
register int regno;
|
||||
int regno;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
register int last = regno + HARD_REGNO_NREGS (regno, mode);
|
||||
int last = regno + HARD_REGNO_NREGS (regno, mode);
|
||||
while (regno < last)
|
||||
{
|
||||
SET_HARD_REG_BIT (hard_regs_live, regno);
|
||||
|
@ -1702,7 +1703,7 @@ mark_elimination (from, to)
|
|||
|
||||
for (i = 0; i < n_basic_blocks; i++)
|
||||
{
|
||||
register regset r = BASIC_BLOCK (i)->global_live_at_start;
|
||||
regset r = BASIC_BLOCK (i)->global_live_at_start;
|
||||
if (REGNO_REG_SET_P (r, from))
|
||||
{
|
||||
CLEAR_REGNO_REG_SET (r, from);
|
||||
|
@ -1888,9 +1889,9 @@ static void
|
|||
dump_conflicts (file)
|
||||
FILE *file;
|
||||
{
|
||||
register int i;
|
||||
register int has_preferences;
|
||||
register int nregs;
|
||||
int i;
|
||||
int has_preferences;
|
||||
int nregs;
|
||||
nregs = 0;
|
||||
for (i = 0; i < max_allocno; i++)
|
||||
{
|
||||
|
@ -1916,7 +1917,7 @@ dump_conflicts (file)
|
|||
|
||||
for (i = 0; i < max_allocno; i++)
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
fprintf (file, ";; %d conflicts:", allocno[i].reg);
|
||||
for (j = 0; j < max_allocno; j++)
|
||||
if (CONFLICTP (j, i))
|
||||
|
@ -1946,7 +1947,7 @@ void
|
|||
dump_global_regs (file)
|
||||
FILE *file;
|
||||
{
|
||||
register int i, j;
|
||||
int i, j;
|
||||
|
||||
fprintf (file, ";; Register dispositions:\n");
|
||||
for (i = FIRST_PSEUDO_REGISTER, j = 0; i < max_regno; i++)
|
||||
|
|
|
@ -74,7 +74,7 @@ monstartup(lowpc, highpc)
|
|||
{
|
||||
int monsize;
|
||||
char *buffer;
|
||||
register int o;
|
||||
int o;
|
||||
|
||||
/*
|
||||
* round lowpc and highpc to multiples of the density we're using
|
||||
|
|
|
@ -236,7 +236,7 @@ print_rtl_graph_with_bb (base, suffix, rtx_first)
|
|||
const char *suffix;
|
||||
rtx rtx_first;
|
||||
{
|
||||
register rtx tmp_rtx;
|
||||
rtx tmp_rtx;
|
||||
size_t namelen = strlen (base);
|
||||
size_t suffixlen = strlen (suffix);
|
||||
size_t extlen = strlen (graph_ext[graph_dump_format]) + 1;
|
||||
|
|
|
@ -360,7 +360,7 @@ HAIFA_INLINE int
|
|||
insn_unit (insn)
|
||||
rtx insn;
|
||||
{
|
||||
register int unit = INSN_UNIT (insn);
|
||||
int unit = INSN_UNIT (insn);
|
||||
|
||||
if (unit == 0)
|
||||
{
|
||||
|
@ -646,7 +646,7 @@ HAIFA_INLINE int
|
|||
insn_cost (insn, link, used)
|
||||
rtx insn, link, used;
|
||||
{
|
||||
register int cost = INSN_COST (insn);
|
||||
int cost = INSN_COST (insn);
|
||||
|
||||
if (cost == 0)
|
||||
{
|
||||
|
@ -1462,7 +1462,7 @@ queue_to_ready (ready)
|
|||
of the pending insns at that point to the ready list. */
|
||||
if (ready->n_ready == 0)
|
||||
{
|
||||
register int stalls;
|
||||
int stalls;
|
||||
|
||||
for (stalls = 1; stalls < INSN_QUEUE_SIZE; stalls++)
|
||||
{
|
||||
|
|
|
@ -127,53 +127,53 @@ typedef HARD_REG_ELT_TYPE HARD_REG_SET[HARD_REG_SET_LONGS];
|
|||
|
||||
#if FIRST_PSEUDO_REGISTER <= 2*HOST_BITS_PER_WIDE_INT
|
||||
#define CLEAR_HARD_REG_SET(TO) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
||||
scan_tp_[0] = 0; \
|
||||
scan_tp_[1] = 0; } while (0)
|
||||
|
||||
#define SET_HARD_REG_SET(TO) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
||||
scan_tp_[0] = -1; \
|
||||
scan_tp_[1] = -1; } while (0)
|
||||
|
||||
#define COPY_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
scan_tp_[0] = scan_fp_[0]; \
|
||||
scan_tp_[1] = scan_fp_[1]; } while (0)
|
||||
|
||||
#define COMPL_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
scan_tp_[0] = ~ scan_fp_[0]; \
|
||||
scan_tp_[1] = ~ scan_fp_[1]; } while (0)
|
||||
|
||||
#define AND_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
scan_tp_[0] &= scan_fp_[0]; \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
scan_tp_[0] &= scan_fp_[0]; \
|
||||
scan_tp_[1] &= scan_fp_[1]; } while (0)
|
||||
|
||||
#define AND_COMPL_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
scan_tp_[0] &= ~ scan_fp_[0]; \
|
||||
scan_tp_[1] &= ~ scan_fp_[1]; } while (0)
|
||||
|
||||
#define IOR_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
scan_tp_[0] |= scan_fp_[0]; \
|
||||
scan_tp_[1] |= scan_fp_[1]; } while (0)
|
||||
|
||||
#define IOR_COMPL_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
scan_tp_[0] |= ~ scan_fp_[0]; \
|
||||
scan_tp_[1] |= ~ scan_fp_[1]; } while (0)
|
||||
|
||||
#define GO_IF_HARD_REG_SUBSET(X,Y,TO) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
|
||||
do { HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
|
||||
if ((0 == (scan_xp_[0] & ~ scan_yp_[0])) \
|
||||
&& (0 == (scan_xp_[1] & ~ scan_yp_[1]))) \
|
||||
goto TO; } while (0)
|
||||
|
||||
#define GO_IF_HARD_REG_EQUAL(X,Y,TO) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
|
||||
do { HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
|
||||
if ((scan_xp_[0] == scan_yp_[0]) \
|
||||
&& (scan_xp_[1] == scan_yp_[1])) \
|
||||
goto TO; } while (0)
|
||||
|
@ -181,62 +181,62 @@ do { register HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
|
|||
#else
|
||||
#if FIRST_PSEUDO_REGISTER <= 3*HOST_BITS_PER_WIDE_INT
|
||||
#define CLEAR_HARD_REG_SET(TO) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
||||
scan_tp_[0] = 0; \
|
||||
scan_tp_[1] = 0; \
|
||||
scan_tp_[2] = 0; } while (0)
|
||||
|
||||
#define SET_HARD_REG_SET(TO) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
||||
scan_tp_[0] = -1; \
|
||||
scan_tp_[1] = -1; \
|
||||
scan_tp_[2] = -1; } while (0)
|
||||
|
||||
#define COPY_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
scan_tp_[0] = scan_fp_[0]; \
|
||||
scan_tp_[1] = scan_fp_[1]; \
|
||||
scan_tp_[2] = scan_fp_[2]; } while (0)
|
||||
|
||||
#define COMPL_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
scan_tp_[0] = ~ scan_fp_[0]; \
|
||||
scan_tp_[1] = ~ scan_fp_[1]; \
|
||||
scan_tp_[2] = ~ scan_fp_[2]; } while (0)
|
||||
|
||||
#define AND_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
scan_tp_[0] &= scan_fp_[0]; \
|
||||
scan_tp_[1] &= scan_fp_[1]; \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
scan_tp_[0] &= scan_fp_[0]; \
|
||||
scan_tp_[1] &= scan_fp_[1]; \
|
||||
scan_tp_[2] &= scan_fp_[2]; } while (0)
|
||||
|
||||
#define AND_COMPL_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
scan_tp_[0] &= ~ scan_fp_[0]; \
|
||||
scan_tp_[1] &= ~ scan_fp_[1]; \
|
||||
scan_tp_[2] &= ~ scan_fp_[2]; } while (0)
|
||||
|
||||
#define IOR_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
scan_tp_[0] |= scan_fp_[0]; \
|
||||
scan_tp_[1] |= scan_fp_[1]; \
|
||||
scan_tp_[2] |= scan_fp_[2]; } while (0)
|
||||
|
||||
#define IOR_COMPL_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
scan_tp_[0] |= ~ scan_fp_[0]; \
|
||||
scan_tp_[1] |= ~ scan_fp_[1]; \
|
||||
scan_tp_[2] |= ~ scan_fp_[2]; } while (0)
|
||||
|
||||
#define GO_IF_HARD_REG_SUBSET(X,Y,TO) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
|
||||
do { HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
|
||||
if ((0 == (scan_xp_[0] & ~ scan_yp_[0])) \
|
||||
&& (0 == (scan_xp_[1] & ~ scan_yp_[1])) \
|
||||
&& (0 == (scan_xp_[2] & ~ scan_yp_[2]))) \
|
||||
goto TO; } while (0)
|
||||
|
||||
#define GO_IF_HARD_REG_EQUAL(X,Y,TO) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
|
||||
do { HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
|
||||
if ((scan_xp_[0] == scan_yp_[0]) \
|
||||
&& (scan_xp_[1] == scan_yp_[1]) \
|
||||
&& (scan_xp_[2] == scan_yp_[2])) \
|
||||
|
@ -245,63 +245,63 @@ do { register HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
|
|||
#else
|
||||
#if FIRST_PSEUDO_REGISTER <= 4*HOST_BITS_PER_WIDE_INT
|
||||
#define CLEAR_HARD_REG_SET(TO) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
||||
scan_tp_[0] = 0; \
|
||||
scan_tp_[1] = 0; \
|
||||
scan_tp_[2] = 0; \
|
||||
scan_tp_[3] = 0; } while (0)
|
||||
|
||||
#define SET_HARD_REG_SET(TO) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
||||
scan_tp_[0] = -1; \
|
||||
scan_tp_[1] = -1; \
|
||||
scan_tp_[2] = -1; \
|
||||
scan_tp_[3] = -1; } while (0)
|
||||
|
||||
#define COPY_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
scan_tp_[0] = scan_fp_[0]; \
|
||||
scan_tp_[1] = scan_fp_[1]; \
|
||||
scan_tp_[2] = scan_fp_[2]; \
|
||||
scan_tp_[3] = scan_fp_[3]; } while (0)
|
||||
|
||||
#define COMPL_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
scan_tp_[0] = ~ scan_fp_[0]; \
|
||||
scan_tp_[1] = ~ scan_fp_[1]; \
|
||||
scan_tp_[2] = ~ scan_fp_[2]; \
|
||||
scan_tp_[3] = ~ scan_fp_[3]; } while (0)
|
||||
|
||||
#define AND_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
scan_tp_[0] &= scan_fp_[0]; \
|
||||
scan_tp_[1] &= scan_fp_[1]; \
|
||||
scan_tp_[2] &= scan_fp_[2]; \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
scan_tp_[0] &= scan_fp_[0]; \
|
||||
scan_tp_[1] &= scan_fp_[1]; \
|
||||
scan_tp_[2] &= scan_fp_[2]; \
|
||||
scan_tp_[3] &= scan_fp_[3]; } while (0)
|
||||
|
||||
#define AND_COMPL_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
scan_tp_[0] &= ~ scan_fp_[0]; \
|
||||
scan_tp_[1] &= ~ scan_fp_[1]; \
|
||||
scan_tp_[2] &= ~ scan_fp_[2]; \
|
||||
scan_tp_[3] &= ~ scan_fp_[3]; } while (0)
|
||||
|
||||
#define IOR_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
scan_tp_[0] |= scan_fp_[0]; \
|
||||
scan_tp_[1] |= scan_fp_[1]; \
|
||||
scan_tp_[2] |= scan_fp_[2]; \
|
||||
scan_tp_[3] |= scan_fp_[3]; } while (0)
|
||||
|
||||
#define IOR_COMPL_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
scan_tp_[0] |= ~ scan_fp_[0]; \
|
||||
scan_tp_[1] |= ~ scan_fp_[1]; \
|
||||
scan_tp_[2] |= ~ scan_fp_[2]; \
|
||||
scan_tp_[3] |= ~ scan_fp_[3]; } while (0)
|
||||
|
||||
#define GO_IF_HARD_REG_SUBSET(X,Y,TO) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
|
||||
do { HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
|
||||
if ((0 == (scan_xp_[0] & ~ scan_yp_[0])) \
|
||||
&& (0 == (scan_xp_[1] & ~ scan_yp_[1])) \
|
||||
&& (0 == (scan_xp_[2] & ~ scan_yp_[2])) \
|
||||
|
@ -309,7 +309,7 @@ do { register HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
|
|||
goto TO; } while (0)
|
||||
|
||||
#define GO_IF_HARD_REG_EQUAL(X,Y,TO) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
|
||||
do { HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
|
||||
if ((scan_xp_[0] == scan_yp_[0]) \
|
||||
&& (scan_xp_[1] == scan_yp_[1]) \
|
||||
&& (scan_xp_[2] == scan_yp_[2]) \
|
||||
|
@ -319,63 +319,63 @@ do { register HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
|
|||
#else /* FIRST_PSEUDO_REGISTER > 3*HOST_BITS_PER_WIDE_INT */
|
||||
|
||||
#define CLEAR_HARD_REG_SET(TO) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
||||
register int i; \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
||||
int i; \
|
||||
for (i = 0; i < HARD_REG_SET_LONGS; i++) \
|
||||
*scan_tp_++ = 0; } while (0)
|
||||
|
||||
#define SET_HARD_REG_SET(TO) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
||||
register int i; \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
||||
int i; \
|
||||
for (i = 0; i < HARD_REG_SET_LONGS; i++) \
|
||||
*scan_tp_++ = -1; } while (0)
|
||||
|
||||
#define COPY_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
register int i; \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
int i; \
|
||||
for (i = 0; i < HARD_REG_SET_LONGS; i++) \
|
||||
*scan_tp_++ = *scan_fp_++; } while (0)
|
||||
|
||||
#define COMPL_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
register int i; \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
int i; \
|
||||
for (i = 0; i < HARD_REG_SET_LONGS; i++) \
|
||||
*scan_tp_++ = ~ *scan_fp_++; } while (0)
|
||||
|
||||
#define AND_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
register int i; \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
int i; \
|
||||
for (i = 0; i < HARD_REG_SET_LONGS; i++) \
|
||||
*scan_tp_++ &= *scan_fp_++; } while (0)
|
||||
|
||||
#define AND_COMPL_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
register int i; \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
int i; \
|
||||
for (i = 0; i < HARD_REG_SET_LONGS; i++) \
|
||||
*scan_tp_++ &= ~ *scan_fp_++; } while (0)
|
||||
|
||||
#define IOR_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
register int i; \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
int i; \
|
||||
for (i = 0; i < HARD_REG_SET_LONGS; i++) \
|
||||
*scan_tp_++ |= *scan_fp_++; } while (0)
|
||||
|
||||
#define IOR_COMPL_HARD_REG_SET(TO, FROM) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
register int i; \
|
||||
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
||||
int i; \
|
||||
for (i = 0; i < HARD_REG_SET_LONGS; i++) \
|
||||
*scan_tp_++ |= ~ *scan_fp_++; } while (0)
|
||||
|
||||
#define GO_IF_HARD_REG_SUBSET(X,Y,TO) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
|
||||
register int i; \
|
||||
do { HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
|
||||
int i; \
|
||||
for (i = 0; i < HARD_REG_SET_LONGS; i++) \
|
||||
if (0 != (*scan_xp_++ & ~ *scan_yp_++)) break; \
|
||||
if (i == HARD_REG_SET_LONGS) goto TO; } while (0)
|
||||
|
||||
#define GO_IF_HARD_REG_EQUAL(X,Y,TO) \
|
||||
do { register HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
|
||||
register int i; \
|
||||
do { HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
|
||||
int i; \
|
||||
for (i = 0; i < HARD_REG_SET_LONGS; i++) \
|
||||
if (*scan_xp_++ != *scan_yp_++) break; \
|
||||
if (i == HARD_REG_SET_LONGS) goto TO; } while (0)
|
||||
|
|
|
@ -91,7 +91,7 @@ hash_lookup (table, key, create, copy)
|
|||
hash_table_key (*copy) PARAMS ((struct obstack* memory,
|
||||
hash_table_key key));
|
||||
{
|
||||
register unsigned long hash;
|
||||
unsigned long hash;
|
||||
struct hash_entry *hashp;
|
||||
unsigned int index;
|
||||
|
||||
|
|
|
@ -164,9 +164,9 @@ function_attribute_inlinable_p (fndecl)
|
|||
|
||||
const char *
|
||||
function_cannot_inline_p (fndecl)
|
||||
register tree fndecl;
|
||||
tree fndecl;
|
||||
{
|
||||
register rtx insn;
|
||||
rtx insn;
|
||||
tree last = tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl)));
|
||||
|
||||
/* For functions marked as inline increase the maximum size to
|
||||
|
@ -178,8 +178,8 @@ function_cannot_inline_p (fndecl)
|
|||
+ 8 * list_length (DECL_ARGUMENTS (fndecl)))
|
||||
: INTEGRATE_THRESHOLD (fndecl);
|
||||
|
||||
register int ninsns = 0;
|
||||
register tree parms;
|
||||
int ninsns = 0;
|
||||
tree parms;
|
||||
|
||||
if (DECL_UNINLINABLE (fndecl))
|
||||
return N_("function cannot be inline");
|
||||
|
@ -655,7 +655,7 @@ expand_inline_function (fndecl, parms, target, ignore, type,
|
|||
tree *arg_trees;
|
||||
rtx *arg_vals;
|
||||
int max_regno;
|
||||
register int i;
|
||||
int i;
|
||||
int min_labelno = inl_f->emit->x_first_label_num;
|
||||
int max_labelno = inl_f->inl_max_label_num;
|
||||
int nargs;
|
||||
|
@ -1315,7 +1315,7 @@ copy_insn_list (insns, map, static_chain_value)
|
|||
struct inline_remap *map;
|
||||
rtx static_chain_value;
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
rtx insn;
|
||||
rtx temp;
|
||||
#ifdef HAVE_cc0
|
||||
|
@ -1717,8 +1717,8 @@ integrate_parm_decls (args, map, arg_vector)
|
|||
struct inline_remap *map;
|
||||
rtvec arg_vector;
|
||||
{
|
||||
register tree tail;
|
||||
register int i;
|
||||
tree tail;
|
||||
int i;
|
||||
|
||||
for (tail = args, i = 0; tail; tail = TREE_CHAIN (tail), i++)
|
||||
{
|
||||
|
@ -1819,15 +1819,15 @@ integrate_decl_tree (let, map)
|
|||
|
||||
rtx
|
||||
copy_rtx_and_substitute (orig, map, for_lhs)
|
||||
register rtx orig;
|
||||
rtx orig;
|
||||
struct inline_remap *map;
|
||||
int for_lhs;
|
||||
{
|
||||
register rtx copy, temp;
|
||||
register int i, j;
|
||||
register RTX_CODE code;
|
||||
register enum machine_mode mode;
|
||||
register const char *format_ptr;
|
||||
rtx copy, temp;
|
||||
int i, j;
|
||||
RTX_CODE code;
|
||||
enum machine_mode mode;
|
||||
const char *format_ptr;
|
||||
int regno;
|
||||
|
||||
if (orig == 0)
|
||||
|
@ -2409,9 +2409,9 @@ subst_constants (loc, insn, map, memonly)
|
|||
int memonly;
|
||||
{
|
||||
rtx x = *loc;
|
||||
register int i, j;
|
||||
register enum rtx_code code;
|
||||
register const char *format_ptr;
|
||||
int i, j;
|
||||
enum rtx_code code;
|
||||
const char *format_ptr;
|
||||
int num_changes = num_validated_changes ();
|
||||
rtx new = 0;
|
||||
enum machine_mode op0_mode = MAX_MACHINE_MODE;
|
||||
|
@ -2793,14 +2793,14 @@ mark_stores (dest, x, data)
|
|||
|
||||
static void
|
||||
set_block_origin_self (stmt)
|
||||
register tree stmt;
|
||||
tree stmt;
|
||||
{
|
||||
if (BLOCK_ABSTRACT_ORIGIN (stmt) == NULL_TREE)
|
||||
{
|
||||
BLOCK_ABSTRACT_ORIGIN (stmt) = stmt;
|
||||
|
||||
{
|
||||
register tree local_decl;
|
||||
tree local_decl;
|
||||
|
||||
for (local_decl = BLOCK_VARS (stmt);
|
||||
local_decl != NULL_TREE;
|
||||
|
@ -2809,7 +2809,7 @@ set_block_origin_self (stmt)
|
|||
}
|
||||
|
||||
{
|
||||
register tree subblock;
|
||||
tree subblock;
|
||||
|
||||
for (subblock = BLOCK_SUBBLOCKS (stmt);
|
||||
subblock != NULL_TREE;
|
||||
|
@ -2832,14 +2832,14 @@ set_block_origin_self (stmt)
|
|||
|
||||
void
|
||||
set_decl_origin_self (decl)
|
||||
register tree decl;
|
||||
tree decl;
|
||||
{
|
||||
if (DECL_ABSTRACT_ORIGIN (decl) == NULL_TREE)
|
||||
{
|
||||
DECL_ABSTRACT_ORIGIN (decl) = decl;
|
||||
if (TREE_CODE (decl) == FUNCTION_DECL)
|
||||
{
|
||||
register tree arg;
|
||||
tree arg;
|
||||
|
||||
for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg))
|
||||
DECL_ABSTRACT_ORIGIN (arg) = arg;
|
||||
|
@ -2857,11 +2857,11 @@ set_decl_origin_self (decl)
|
|||
|
||||
static void
|
||||
set_block_abstract_flags (stmt, setting)
|
||||
register tree stmt;
|
||||
register int setting;
|
||||
tree stmt;
|
||||
int setting;
|
||||
{
|
||||
register tree local_decl;
|
||||
register tree subblock;
|
||||
tree local_decl;
|
||||
tree subblock;
|
||||
|
||||
BLOCK_ABSTRACT (stmt) = setting;
|
||||
|
||||
|
@ -2884,13 +2884,13 @@ set_block_abstract_flags (stmt, setting)
|
|||
|
||||
void
|
||||
set_decl_abstract_flags (decl, setting)
|
||||
register tree decl;
|
||||
register int setting;
|
||||
tree decl;
|
||||
int setting;
|
||||
{
|
||||
DECL_ABSTRACT (decl) = setting;
|
||||
if (TREE_CODE (decl) == FUNCTION_DECL)
|
||||
{
|
||||
register tree arg;
|
||||
tree arg;
|
||||
|
||||
for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg))
|
||||
DECL_ABSTRACT (arg) = setting;
|
||||
|
|
76
gcc/jump.c
76
gcc/jump.c
|
@ -78,7 +78,7 @@ void
|
|||
rebuild_jump_labels (f)
|
||||
rtx f;
|
||||
{
|
||||
register rtx insn;
|
||||
rtx insn;
|
||||
int max_uid = 0;
|
||||
|
||||
max_uid = init_label_info (f) + 1;
|
||||
|
@ -131,7 +131,7 @@ void
|
|||
copy_loop_headers (f)
|
||||
rtx f;
|
||||
{
|
||||
register rtx insn, next;
|
||||
rtx insn, next;
|
||||
/* Now iterate optimizing jumps until nothing changes over one pass. */
|
||||
for (insn = f; insn; insn = next)
|
||||
{
|
||||
|
@ -1094,7 +1094,7 @@ int
|
|||
condjump_p (insn)
|
||||
rtx insn;
|
||||
{
|
||||
register rtx x = PATTERN (insn);
|
||||
rtx x = PATTERN (insn);
|
||||
|
||||
if (GET_CODE (x) != SET
|
||||
|| GET_CODE (SET_DEST (x)) != PC)
|
||||
|
@ -1125,7 +1125,7 @@ int
|
|||
condjump_in_parallel_p (insn)
|
||||
rtx insn;
|
||||
{
|
||||
register rtx x = PATTERN (insn);
|
||||
rtx x = PATTERN (insn);
|
||||
|
||||
if (GET_CODE (x) != PARALLEL)
|
||||
return 0;
|
||||
|
@ -1347,10 +1347,10 @@ rtx
|
|||
follow_jumps (label)
|
||||
rtx label;
|
||||
{
|
||||
register rtx insn;
|
||||
register rtx next;
|
||||
register rtx value = label;
|
||||
register int depth;
|
||||
rtx insn;
|
||||
rtx next;
|
||||
rtx value = label;
|
||||
int depth;
|
||||
|
||||
for (depth = 0;
|
||||
(depth < 10
|
||||
|
@ -1409,13 +1409,13 @@ follow_jumps (label)
|
|||
|
||||
void
|
||||
mark_jump_label (x, insn, in_mem)
|
||||
register rtx x;
|
||||
rtx x;
|
||||
rtx insn;
|
||||
int in_mem;
|
||||
{
|
||||
register RTX_CODE code = GET_CODE (x);
|
||||
register int i;
|
||||
register const char *fmt;
|
||||
RTX_CODE code = GET_CODE (x);
|
||||
int i;
|
||||
const char *fmt;
|
||||
|
||||
switch (code)
|
||||
{
|
||||
|
@ -1505,7 +1505,7 @@ mark_jump_label (x, insn, in_mem)
|
|||
mark_jump_label (XEXP (x, i), insn, in_mem);
|
||||
else if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = 0; j < XVECLEN (x, i); j++)
|
||||
mark_jump_label (XVECEXP (x, i, j), insn, in_mem);
|
||||
}
|
||||
|
@ -1520,7 +1520,7 @@ void
|
|||
delete_jump (insn)
|
||||
rtx insn;
|
||||
{
|
||||
register rtx set = single_set (insn);
|
||||
rtx set = single_set (insn);
|
||||
|
||||
if (set && GET_CODE (SET_DEST (set)) == PC)
|
||||
delete_computation (insn);
|
||||
|
@ -1723,9 +1723,9 @@ delete_computation (insn)
|
|||
|
||||
rtx
|
||||
delete_related_insns (insn)
|
||||
register rtx insn;
|
||||
rtx insn;
|
||||
{
|
||||
register int was_code_label = (GET_CODE (insn) == CODE_LABEL);
|
||||
int was_code_label = (GET_CODE (insn) == CODE_LABEL);
|
||||
rtx note;
|
||||
rtx next = NEXT_INSN (insn), prev = PREV_INSN (insn);
|
||||
|
||||
|
@ -1824,7 +1824,7 @@ delete_related_insns (insn)
|
|||
|
||||
if (was_code_label && prev && GET_CODE (prev) == BARRIER)
|
||||
{
|
||||
register RTX_CODE code;
|
||||
RTX_CODE code;
|
||||
while (next != 0
|
||||
&& (GET_RTX_CLASS (code = GET_CODE (next)) == 'i'
|
||||
|| code == NOTE || code == BARRIER
|
||||
|
@ -1867,14 +1867,14 @@ next_nondeleted_insn (insn)
|
|||
|
||||
void
|
||||
delete_for_peephole (from, to)
|
||||
register rtx from, to;
|
||||
rtx from, to;
|
||||
{
|
||||
register rtx insn = from;
|
||||
rtx insn = from;
|
||||
|
||||
while (1)
|
||||
{
|
||||
register rtx next = NEXT_INSN (insn);
|
||||
register rtx prev = PREV_INSN (insn);
|
||||
rtx next = NEXT_INSN (insn);
|
||||
rtx prev = PREV_INSN (insn);
|
||||
|
||||
if (GET_CODE (insn) != NOTE)
|
||||
{
|
||||
|
@ -1956,10 +1956,10 @@ redirect_exp_1 (loc, olabel, nlabel, insn)
|
|||
rtx olabel, nlabel;
|
||||
rtx insn;
|
||||
{
|
||||
register rtx x = *loc;
|
||||
register RTX_CODE code = GET_CODE (x);
|
||||
register int i;
|
||||
register const char *fmt;
|
||||
rtx x = *loc;
|
||||
RTX_CODE code = GET_CODE (x);
|
||||
int i;
|
||||
const char *fmt;
|
||||
|
||||
if (code == LABEL_REF)
|
||||
{
|
||||
|
@ -1999,7 +1999,7 @@ redirect_exp_1 (loc, olabel, nlabel, insn)
|
|||
redirect_exp_1 (&XEXP (x, i), olabel, nlabel, insn);
|
||||
else if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = 0; j < XVECLEN (x, i); j++)
|
||||
redirect_exp_1 (&XVECEXP (x, i, j), olabel, nlabel, insn);
|
||||
}
|
||||
|
@ -2062,7 +2062,7 @@ redirect_jump (jump, nlabel, delete_unused)
|
|||
rtx jump, nlabel;
|
||||
int delete_unused;
|
||||
{
|
||||
register rtx olabel = JUMP_LABEL (jump);
|
||||
rtx olabel = JUMP_LABEL (jump);
|
||||
|
||||
if (nlabel == olabel)
|
||||
return 1;
|
||||
|
@ -2095,7 +2095,7 @@ static void
|
|||
invert_exp_1 (insn)
|
||||
rtx insn;
|
||||
{
|
||||
register RTX_CODE code;
|
||||
RTX_CODE code;
|
||||
rtx x = pc_set (insn);
|
||||
|
||||
if (!x)
|
||||
|
@ -2106,8 +2106,8 @@ invert_exp_1 (insn)
|
|||
|
||||
if (code == IF_THEN_ELSE)
|
||||
{
|
||||
register rtx comp = XEXP (x, 0);
|
||||
register rtx tem;
|
||||
rtx comp = XEXP (x, 0);
|
||||
rtx tem;
|
||||
enum rtx_code reversed_code;
|
||||
|
||||
/* We can do this in two ways: The preferable way, which can only
|
||||
|
@ -2218,9 +2218,9 @@ int
|
|||
rtx_renumbered_equal_p (x, y)
|
||||
rtx x, y;
|
||||
{
|
||||
register int i;
|
||||
register RTX_CODE code = GET_CODE (x);
|
||||
register const char *fmt;
|
||||
int i;
|
||||
RTX_CODE code = GET_CODE (x);
|
||||
const char *fmt;
|
||||
|
||||
if (x == y)
|
||||
return 1;
|
||||
|
@ -2349,7 +2349,7 @@ rtx_renumbered_equal_p (x, y)
|
|||
fmt = GET_RTX_FORMAT (code);
|
||||
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
switch (fmt[i])
|
||||
{
|
||||
case 'w':
|
||||
|
@ -2716,10 +2716,10 @@ rtx_equal_for_thread_p (x, y, yinsn)
|
|||
rtx x, y;
|
||||
rtx yinsn;
|
||||
{
|
||||
register int i;
|
||||
register int j;
|
||||
register enum rtx_code code;
|
||||
register const char *fmt;
|
||||
int i;
|
||||
int j;
|
||||
enum rtx_code code;
|
||||
const char *fmt;
|
||||
|
||||
code = GET_CODE (x);
|
||||
/* Rtx's of different codes cannot be equal. */
|
||||
|
|
|
@ -45,7 +45,7 @@ static void
|
|||
free_list (listp, unused_listp)
|
||||
rtx *listp, *unused_listp;
|
||||
{
|
||||
register rtx link, prev_link;
|
||||
rtx link, prev_link;
|
||||
|
||||
prev_link = *listp;
|
||||
link = XEXP (prev_link, 1);
|
||||
|
|
|
@ -312,7 +312,7 @@ alloc_qty (regno, mode, size, birth)
|
|||
enum machine_mode mode;
|
||||
int size, birth;
|
||||
{
|
||||
register int qtyno = next_qty++;
|
||||
int qtyno = next_qty++;
|
||||
|
||||
reg_qty[regno] = qtyno;
|
||||
reg_offset[regno] = 0;
|
||||
|
@ -335,7 +335,7 @@ alloc_qty (regno, mode, size, birth)
|
|||
int
|
||||
local_alloc ()
|
||||
{
|
||||
register int b, i;
|
||||
int b, i;
|
||||
int max_qty;
|
||||
|
||||
/* We need to keep track of whether or not we recorded a LABEL_REF so
|
||||
|
@ -523,9 +523,9 @@ static int
|
|||
equiv_init_varies_p (x)
|
||||
rtx x;
|
||||
{
|
||||
register RTX_CODE code = GET_CODE (x);
|
||||
register int i;
|
||||
register const char *fmt;
|
||||
RTX_CODE code = GET_CODE (x);
|
||||
int i;
|
||||
const char *fmt;
|
||||
|
||||
switch (code)
|
||||
{
|
||||
|
@ -1215,8 +1215,8 @@ static void
|
|||
block_alloc (b)
|
||||
int b;
|
||||
{
|
||||
register int i, q;
|
||||
register rtx insn;
|
||||
int i, q;
|
||||
rtx insn;
|
||||
rtx note;
|
||||
int insn_number = 0;
|
||||
int insn_count = 0;
|
||||
|
@ -1258,9 +1258,9 @@ block_alloc (b)
|
|||
|
||||
if (INSN_P (insn))
|
||||
{
|
||||
register rtx link, set;
|
||||
register int win = 0;
|
||||
register rtx r0, r1 = NULL_RTX;
|
||||
rtx link, set;
|
||||
int win = 0;
|
||||
rtx r0, r1 = NULL_RTX;
|
||||
int combined_regno = -1;
|
||||
int i;
|
||||
|
||||
|
@ -1690,8 +1690,8 @@ qty_compare_1 (q1p, q2p)
|
|||
const PTR q1p;
|
||||
const PTR q2p;
|
||||
{
|
||||
register int q1 = *(const int *) q1p, q2 = *(const int *) q2p;
|
||||
register int tem = QTY_CMP_PRI (q2) - QTY_CMP_PRI (q1);
|
||||
int q1 = *(const int *) q1p, q2 = *(const int *) q2p;
|
||||
int tem = QTY_CMP_PRI (q2) - QTY_CMP_PRI (q1);
|
||||
|
||||
if (tem != 0)
|
||||
return tem;
|
||||
|
@ -1717,7 +1717,7 @@ static int
|
|||
qty_sugg_compare (q1, q2)
|
||||
int q1, q2;
|
||||
{
|
||||
register int tem = QTY_CMP_SUGG (q1) - QTY_CMP_SUGG (q2);
|
||||
int tem = QTY_CMP_SUGG (q1) - QTY_CMP_SUGG (q2);
|
||||
|
||||
if (tem != 0)
|
||||
return tem;
|
||||
|
@ -1730,8 +1730,8 @@ qty_sugg_compare_1 (q1p, q2p)
|
|||
const PTR q1p;
|
||||
const PTR q2p;
|
||||
{
|
||||
register int q1 = *(const int *) q1p, q2 = *(const int *) q2p;
|
||||
register int tem = QTY_CMP_SUGG (q1) - QTY_CMP_SUGG (q2);
|
||||
int q1 = *(const int *) q1p, q2 = *(const int *) q2p;
|
||||
int tem = QTY_CMP_SUGG (q1) - QTY_CMP_SUGG (q2);
|
||||
|
||||
if (tem != 0)
|
||||
return tem;
|
||||
|
@ -1778,10 +1778,10 @@ combine_regs (usedreg, setreg, may_save_copy, insn_number, insn, already_dead)
|
|||
rtx insn;
|
||||
int already_dead;
|
||||
{
|
||||
register int ureg, sreg;
|
||||
register int offset = 0;
|
||||
int ureg, sreg;
|
||||
int offset = 0;
|
||||
int usize, ssize;
|
||||
register int sqty;
|
||||
int sqty;
|
||||
|
||||
/* Determine the numbers and sizes of registers being used. If a subreg
|
||||
is present that does not change the entire register, don't consider
|
||||
|
@ -1947,7 +1947,7 @@ combine_regs (usedreg, setreg, may_save_copy, insn_number, insn, already_dead)
|
|||
qty[sqty].freq += REG_FREQ (sreg);
|
||||
if (usize < ssize)
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
for (i = qty[sqty].first_reg; i >= 0; i = reg_next_in_qty[i])
|
||||
reg_offset[i] -= offset;
|
||||
|
@ -1971,7 +1971,7 @@ reg_meets_class_p (reg, class)
|
|||
int reg;
|
||||
enum reg_class class;
|
||||
{
|
||||
register enum reg_class rclass = reg_preferred_class (reg);
|
||||
enum reg_class rclass = reg_preferred_class (reg);
|
||||
return (reg_class_subset_p (rclass, class)
|
||||
|| reg_class_subset_p (class, rclass));
|
||||
}
|
||||
|
@ -2032,7 +2032,7 @@ reg_is_born (reg, birth)
|
|||
rtx reg;
|
||||
int birth;
|
||||
{
|
||||
register int regno;
|
||||
int regno;
|
||||
|
||||
if (GET_CODE (reg) == SUBREG)
|
||||
{
|
||||
|
@ -2070,10 +2070,10 @@ reg_is_born (reg, birth)
|
|||
|
||||
static void
|
||||
wipe_dead_reg (reg, output_p)
|
||||
register rtx reg;
|
||||
rtx reg;
|
||||
int output_p;
|
||||
{
|
||||
register int regno = REGNO (reg);
|
||||
int regno = REGNO (reg);
|
||||
|
||||
/* If this insn has multiple results,
|
||||
and the dead reg is used in one of the results,
|
||||
|
@ -2145,7 +2145,7 @@ find_free_reg (class, mode, qtyno, accept_call_clobbered, just_try_suggested,
|
|||
int just_try_suggested;
|
||||
int born_index, dead_index;
|
||||
{
|
||||
register int i, ins;
|
||||
int i, ins;
|
||||
#ifdef HARD_REG_SET
|
||||
/* Declare it register if it's a scalar. */
|
||||
register
|
||||
|
@ -2238,8 +2238,8 @@ find_free_reg (class, mode, qtyno, accept_call_clobbered, just_try_suggested,
|
|||
|| accept_call_clobbered
|
||||
|| ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode)))
|
||||
{
|
||||
register int j;
|
||||
register int size1 = HARD_REGNO_NREGS (regno, mode);
|
||||
int j;
|
||||
int size1 = HARD_REGNO_NREGS (regno, mode);
|
||||
for (j = 1; j < size1 && ! TEST_HARD_REG_BIT (used, regno + j); j++);
|
||||
if (j == size1)
|
||||
{
|
||||
|
@ -2296,11 +2296,11 @@ find_free_reg (class, mode, qtyno, accept_call_clobbered, just_try_suggested,
|
|||
|
||||
static void
|
||||
mark_life (regno, mode, life)
|
||||
register int regno;
|
||||
int regno;
|
||||
enum machine_mode mode;
|
||||
int life;
|
||||
{
|
||||
register int j = HARD_REGNO_NREGS (regno, mode);
|
||||
int j = HARD_REGNO_NREGS (regno, mode);
|
||||
if (life)
|
||||
while (--j >= 0)
|
||||
SET_HARD_REG_BIT (regs_live, regno + j);
|
||||
|
@ -2319,7 +2319,7 @@ post_mark_life (regno, mode, life, birth, death)
|
|||
enum machine_mode mode;
|
||||
int life, birth, death;
|
||||
{
|
||||
register int j = HARD_REGNO_NREGS (regno, mode);
|
||||
int j = HARD_REGNO_NREGS (regno, mode);
|
||||
#ifdef HARD_REG_SET
|
||||
/* Declare it register if it's a scalar. */
|
||||
register
|
||||
|
@ -2451,7 +2451,7 @@ void
|
|||
dump_local_alloc (file)
|
||||
FILE *file;
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
|
||||
if (reg_renumber[i] != -1)
|
||||
fprintf (file, ";; Register %d in %d.\n", i, reg_renumber[i]);
|
||||
|
|
102
gcc/loop.c
102
gcc/loop.c
|
@ -356,8 +356,8 @@ loop_optimize (f, dumpfile, flags)
|
|||
FILE *dumpfile;
|
||||
int flags;
|
||||
{
|
||||
register rtx insn;
|
||||
register int i;
|
||||
rtx insn;
|
||||
int i;
|
||||
struct loops loops_data;
|
||||
struct loops *loops = &loops_data;
|
||||
struct loop_info *loops_info;
|
||||
|
@ -522,7 +522,7 @@ scan_loop (loop, flags)
|
|||
{
|
||||
struct loop_info *loop_info = LOOP_INFO (loop);
|
||||
struct loop_regs *regs = LOOP_REGS (loop);
|
||||
register int i;
|
||||
int i;
|
||||
rtx loop_start = loop->start;
|
||||
rtx loop_end = loop->end;
|
||||
rtx p;
|
||||
|
@ -761,8 +761,8 @@ scan_loop (loop, flags)
|
|||
&& ! ((maybe_never || call_passed)
|
||||
&& may_trap_p (src)))
|
||||
{
|
||||
register struct movable *m;
|
||||
register int regno = REGNO (SET_DEST (set));
|
||||
struct movable *m;
|
||||
int regno = REGNO (SET_DEST (set));
|
||||
|
||||
/* A potential lossage is where we have a case where two insns
|
||||
can be combined as long as they are both in the loop, but
|
||||
|
@ -892,10 +892,10 @@ scan_loop (loop, flags)
|
|||
== SET_DEST (set))
|
||||
&& !reg_mentioned_p (SET_DEST (set), SET_SRC (set1)))
|
||||
{
|
||||
register int regno = REGNO (SET_DEST (set));
|
||||
int regno = REGNO (SET_DEST (set));
|
||||
if (regs->array[regno].set_in_loop == 2)
|
||||
{
|
||||
register struct movable *m;
|
||||
struct movable *m;
|
||||
m = (struct movable *) xmalloc (sizeof (struct movable));
|
||||
m->next = 0;
|
||||
m->insn = p;
|
||||
|
@ -1252,7 +1252,7 @@ static void
|
|||
ignore_some_movables (movables)
|
||||
struct loop_movables *movables;
|
||||
{
|
||||
register struct movable *m, *m1;
|
||||
struct movable *m, *m1;
|
||||
|
||||
for (m = movables->head; m; m = m->next)
|
||||
{
|
||||
|
@ -1284,7 +1284,8 @@ static void
|
|||
force_movables (movables)
|
||||
struct loop_movables *movables;
|
||||
{
|
||||
register struct movable *m, *m1;
|
||||
struct movable *m, *m1;
|
||||
|
||||
for (m1 = movables->head; m1; m1 = m1->next)
|
||||
/* Omit this if moving just the (SET (REG) 0) of a zero-extend. */
|
||||
if (!m1->partial && !m1->done)
|
||||
|
@ -1324,7 +1325,7 @@ combine_movables (movables, regs)
|
|||
struct loop_movables *movables;
|
||||
struct loop_regs *regs;
|
||||
{
|
||||
register struct movable *m;
|
||||
struct movable *m;
|
||||
char *matched_regs = (char *) xmalloc (regs->num);
|
||||
enum machine_mode mode;
|
||||
|
||||
|
@ -1336,7 +1337,7 @@ combine_movables (movables, regs)
|
|||
if (m->match == 0 && regs->array[m->regno].n_times_set == 1
|
||||
&& !m->partial)
|
||||
{
|
||||
register struct movable *m1;
|
||||
struct movable *m1;
|
||||
int regno = m->regno;
|
||||
|
||||
memset (matched_regs, 0, regs->num);
|
||||
|
@ -1389,7 +1390,7 @@ combine_movables (movables, regs)
|
|||
for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
|
||||
mode = GET_MODE_WIDER_MODE (mode))
|
||||
{
|
||||
register struct movable *m0 = 0;
|
||||
struct movable *m0 = 0;
|
||||
|
||||
/* Combine all the registers for extension from mode MODE.
|
||||
Don't combine any that are used outside this loop. */
|
||||
|
@ -1397,7 +1398,8 @@ combine_movables (movables, regs)
|
|||
if (m->partial && ! m->global
|
||||
&& mode == GET_MODE (SET_SRC (PATTERN (NEXT_INSN (m->insn)))))
|
||||
{
|
||||
register struct movable *m1;
|
||||
struct movable *m1;
|
||||
|
||||
int first = REGNO_FIRST_LUID (m->regno);
|
||||
int last = REGNO_LAST_LUID (m->regno);
|
||||
|
||||
|
@ -1491,11 +1493,11 @@ rtx_equal_for_loop_p (x, y, movables, regs)
|
|||
struct loop_movables *movables;
|
||||
struct loop_regs *regs;
|
||||
{
|
||||
register int i;
|
||||
register int j;
|
||||
register struct movable *m;
|
||||
register enum rtx_code code;
|
||||
register const char *fmt;
|
||||
int i;
|
||||
int j;
|
||||
struct movable *m;
|
||||
enum rtx_code code;
|
||||
const char *fmt;
|
||||
|
||||
if (x == y)
|
||||
return 1;
|
||||
|
@ -1656,8 +1658,8 @@ move_movables (loop, movables, threshold, insn_count)
|
|||
struct loop_regs *regs = LOOP_REGS (loop);
|
||||
int nregs = regs->num;
|
||||
rtx new_start = 0;
|
||||
register struct movable *m;
|
||||
register rtx p;
|
||||
struct movable *m;
|
||||
rtx p;
|
||||
rtx loop_start = loop->start;
|
||||
rtx loop_end = loop->end;
|
||||
/* Map of pseudo-register replacements to handle combining
|
||||
|
@ -1708,8 +1710,8 @@ move_movables (loop, movables, threshold, insn_count)
|
|||
m->insn))))
|
||||
&& (! m->forces || m->forces->done))
|
||||
{
|
||||
register int regno;
|
||||
register rtx p;
|
||||
int regno;
|
||||
rtx p;
|
||||
int savings = m->savings;
|
||||
|
||||
/* We have an insn that is safe to move.
|
||||
|
@ -1745,7 +1747,7 @@ move_movables (loop, movables, threshold, insn_count)
|
|||
&& regs->array[m->forces->regno].n_times_set == 1))
|
||||
{
|
||||
int count;
|
||||
register struct movable *m1;
|
||||
struct movable *m1;
|
||||
rtx first = NULL_RTX;
|
||||
|
||||
/* Now move the insns that set the reg. */
|
||||
|
@ -2185,9 +2187,9 @@ static void
|
|||
replace_call_address (x, reg, addr)
|
||||
rtx x, reg, addr;
|
||||
{
|
||||
register enum rtx_code code;
|
||||
register int i;
|
||||
register const char *fmt;
|
||||
enum rtx_code code;
|
||||
int i;
|
||||
const char *fmt;
|
||||
|
||||
if (x == 0)
|
||||
return;
|
||||
|
@ -2233,7 +2235,7 @@ replace_call_address (x, reg, addr)
|
|||
replace_call_address (XEXP (x, i), reg, addr);
|
||||
else if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = 0; j < XVECLEN (x, i); j++)
|
||||
replace_call_address (XVECEXP (x, i, j), reg, addr);
|
||||
}
|
||||
|
@ -2249,9 +2251,9 @@ count_nonfixed_reads (loop, x)
|
|||
const struct loop *loop;
|
||||
rtx x;
|
||||
{
|
||||
register enum rtx_code code;
|
||||
register int i;
|
||||
register const char *fmt;
|
||||
enum rtx_code code;
|
||||
int i;
|
||||
const char *fmt;
|
||||
int value;
|
||||
|
||||
if (x == 0)
|
||||
|
@ -2286,7 +2288,7 @@ count_nonfixed_reads (loop, x)
|
|||
value += count_nonfixed_reads (loop, XEXP (x, i));
|
||||
if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = 0; j < XVECLEN (x, i); j++)
|
||||
value += count_nonfixed_reads (loop, XVECEXP (x, i, j));
|
||||
}
|
||||
|
@ -2304,7 +2306,7 @@ static void
|
|||
prescan_loop (loop)
|
||||
struct loop *loop;
|
||||
{
|
||||
register int level = 1;
|
||||
int level = 1;
|
||||
rtx insn;
|
||||
struct loop_info *loop_info = LOOP_INFO (loop);
|
||||
rtx start = loop->start;
|
||||
|
@ -3058,13 +3060,13 @@ note_set_pseudo_multiple_uses (x, y, data)
|
|||
int
|
||||
loop_invariant_p (loop, x)
|
||||
const struct loop *loop;
|
||||
register rtx x;
|
||||
rtx x;
|
||||
{
|
||||
struct loop_info *loop_info = LOOP_INFO (loop);
|
||||
struct loop_regs *regs = LOOP_REGS (loop);
|
||||
register int i;
|
||||
register enum rtx_code code;
|
||||
register const char *fmt;
|
||||
int i;
|
||||
enum rtx_code code;
|
||||
const char *fmt;
|
||||
int conditional = 0;
|
||||
rtx mem_list_entry;
|
||||
|
||||
|
@ -3162,7 +3164,7 @@ loop_invariant_p (loop, x)
|
|||
}
|
||||
else if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = 0; j < XVECLEN (x, i); j++)
|
||||
{
|
||||
int tem = loop_invariant_p (loop, XVECEXP (x, i, j));
|
||||
|
@ -3212,7 +3214,7 @@ consec_sets_invariant_p (loop, reg, n_sets, insn)
|
|||
|
||||
while (count > 0)
|
||||
{
|
||||
register enum rtx_code code;
|
||||
enum rtx_code code;
|
||||
rtx set;
|
||||
|
||||
p = NEXT_INSN (p);
|
||||
|
@ -3269,12 +3271,12 @@ all_sets_invariant_p (reg, insn, table)
|
|||
rtx reg, insn;
|
||||
short *table;
|
||||
{
|
||||
register rtx p = insn;
|
||||
register int regno = REGNO (reg);
|
||||
rtx p = insn;
|
||||
int regno = REGNO (reg);
|
||||
|
||||
while (1)
|
||||
{
|
||||
register enum rtx_code code;
|
||||
enum rtx_code code;
|
||||
p = NEXT_INSN (p);
|
||||
code = GET_CODE (p);
|
||||
if (code == CODE_LABEL || code == JUMP_INSN)
|
||||
|
@ -3356,7 +3358,7 @@ count_one_set (regs, insn, x, last_set)
|
|||
dest = XEXP (dest, 0);
|
||||
if (GET_CODE (dest) == REG)
|
||||
{
|
||||
register int regno = REGNO (dest);
|
||||
int regno = REGNO (dest);
|
||||
/* If this is the first setting of this reg
|
||||
in current basic block, and it was set before,
|
||||
it must be set in two basic blocks, so it cannot
|
||||
|
@ -4722,9 +4724,9 @@ find_mem_givs (loop, x, insn, not_every_iteration, maybe_multiple)
|
|||
rtx insn;
|
||||
int not_every_iteration, maybe_multiple;
|
||||
{
|
||||
register int i, j;
|
||||
register enum rtx_code code;
|
||||
register const char *fmt;
|
||||
int i, j;
|
||||
enum rtx_code code;
|
||||
const char *fmt;
|
||||
|
||||
if (x == 0)
|
||||
return;
|
||||
|
@ -5396,7 +5398,7 @@ update_giv_derive (loop, p)
|
|||
static int
|
||||
basic_induction_var (loop, x, mode, dest_reg, p, inc_val, mult_val, location)
|
||||
const struct loop *loop;
|
||||
register rtx x;
|
||||
rtx x;
|
||||
enum machine_mode mode;
|
||||
rtx dest_reg;
|
||||
rtx p;
|
||||
|
@ -5404,7 +5406,7 @@ basic_induction_var (loop, x, mode, dest_reg, p, inc_val, mult_val, location)
|
|||
rtx *mult_val;
|
||||
rtx **location;
|
||||
{
|
||||
register enum rtx_code code;
|
||||
enum rtx_code code;
|
||||
rtx *argp, arg;
|
||||
rtx insn, set = 0;
|
||||
|
||||
|
@ -8311,8 +8313,8 @@ update_reg_last_use (x, insn)
|
|||
}
|
||||
else
|
||||
{
|
||||
register int i, j;
|
||||
register const char *fmt = GET_RTX_FORMAT (GET_CODE (x));
|
||||
int i, j;
|
||||
const char *fmt = GET_RTX_FORMAT (GET_CODE (x));
|
||||
for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
|
||||
{
|
||||
if (fmt[i] == 'e')
|
||||
|
@ -8808,7 +8810,7 @@ loop_regs_scan (loop, extra_size)
|
|||
count_one_set (regs, insn, PATTERN (insn), last_set);
|
||||
else if (GET_CODE (PATTERN (insn)) == PARALLEL)
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
|
||||
count_one_set (regs, insn, XVECEXP (PATTERN (insn), 0, i),
|
||||
last_set);
|
||||
|
|
|
@ -1011,9 +1011,10 @@ print_symbol (sym_ptr, number, strbase, aux_base, ifd, fdp)
|
|||
|
||||
if (MIPS_IS_STAB(sym_ptr))
|
||||
{
|
||||
register int i = ARRAY_SIZE (stab_names);
|
||||
int i = ARRAY_SIZE (stab_names);
|
||||
const char *stab_name = "stab";
|
||||
short code = MIPS_UNMARK_STAB(sym_ptr->index);
|
||||
|
||||
while (--i >= 0)
|
||||
if (stab_names[i].code == code)
|
||||
{
|
||||
|
|
272
gcc/mips-tfile.c
272
gcc/mips-tfile.c
|
@ -1778,10 +1778,10 @@ hash_string (text, hash_len, hash_tbl, ret_hash_index)
|
|||
shash_t **hash_tbl; /* hash table */
|
||||
symint_t *ret_hash_index; /* ptr to store hash index */
|
||||
{
|
||||
register unsigned long hi;
|
||||
register Ptrdiff_t i;
|
||||
register shash_t *ptr;
|
||||
register int first_ch = *text;
|
||||
unsigned long hi;
|
||||
Ptrdiff_t i;
|
||||
shash_t *ptr;
|
||||
int first_ch = *text;
|
||||
|
||||
hi = hash_len;
|
||||
for (i = 0; i < hash_len; i++)
|
||||
|
@ -1815,8 +1815,8 @@ add_string (vp, hash_tbl, start, end_p1, ret_hash)
|
|||
const char *end_p1; /* 1st byte after string */
|
||||
shash_t **ret_hash; /* return hash pointer */
|
||||
{
|
||||
register Ptrdiff_t len = end_p1 - start;
|
||||
register shash_t *hash_ptr;
|
||||
Ptrdiff_t len = end_p1 - start;
|
||||
shash_t *hash_ptr;
|
||||
symint_t hi;
|
||||
|
||||
if (len >= (Ptrdiff_t) PAGE_USIZE)
|
||||
|
@ -1825,7 +1825,7 @@ add_string (vp, hash_tbl, start, end_p1, ret_hash)
|
|||
hash_ptr = hash_string (start, len, hash_tbl, &hi);
|
||||
if (hash_ptr == (shash_t *) 0)
|
||||
{
|
||||
register char *p;
|
||||
char *p;
|
||||
|
||||
if (vp->objects_last_page + len >= (long) PAGE_USIZE)
|
||||
{
|
||||
|
@ -1869,14 +1869,14 @@ add_local_symbol (str_start, str_end_p1, type, storage, value, indx)
|
|||
symint_t value; /* value of symbol */
|
||||
symint_t indx; /* index to local/aux. syms */
|
||||
{
|
||||
register symint_t ret;
|
||||
register SYMR *psym;
|
||||
register scope_t *pscope;
|
||||
register thead_t *ptag_head;
|
||||
register tag_t *ptag;
|
||||
register tag_t *ptag_next;
|
||||
register varray_t *vp = &cur_file_ptr->symbols;
|
||||
register int scope_delta = 0;
|
||||
symint_t ret;
|
||||
SYMR *psym;
|
||||
scope_t *pscope;
|
||||
thead_t *ptag_head;
|
||||
tag_t *ptag;
|
||||
tag_t *ptag_next;
|
||||
varray_t *vp = &cur_file_ptr->symbols;
|
||||
int scope_delta = 0;
|
||||
shash_t *hash_ptr = (shash_t *) 0;
|
||||
|
||||
if (vp->objects_last_page == vp->objects_per_page)
|
||||
|
@ -2045,8 +2045,8 @@ add_ext_symbol (esym, ifd)
|
|||
{
|
||||
const char *str_start; /* first byte in string */
|
||||
const char *str_end_p1; /* first byte after string */
|
||||
register EXTR *psym;
|
||||
register varray_t *vp = &ext_symbols;
|
||||
EXTR *psym;
|
||||
varray_t *vp = &ext_symbols;
|
||||
shash_t *hash_ptr = (shash_t *) 0;
|
||||
|
||||
str_start = ORIG_ESTRS (esym->asym.iss);
|
||||
|
@ -2096,9 +2096,9 @@ STATIC symint_t
|
|||
add_aux_sym_symint (aux_word)
|
||||
symint_t aux_word; /* auxiliary information word */
|
||||
{
|
||||
register AUXU *aux_ptr;
|
||||
register efdr_t *file_ptr = cur_file_ptr;
|
||||
register varray_t *vp = &file_ptr->aux_syms;
|
||||
AUXU *aux_ptr;
|
||||
efdr_t *file_ptr = cur_file_ptr;
|
||||
varray_t *vp = &file_ptr->aux_syms;
|
||||
|
||||
if (vp->objects_last_page == vp->objects_per_page)
|
||||
add_varray_page (vp);
|
||||
|
@ -2117,9 +2117,9 @@ add_aux_sym_rndx (file_index, sym_index)
|
|||
int file_index;
|
||||
symint_t sym_index;
|
||||
{
|
||||
register AUXU *aux_ptr;
|
||||
register efdr_t *file_ptr = cur_file_ptr;
|
||||
register varray_t *vp = &file_ptr->aux_syms;
|
||||
AUXU *aux_ptr;
|
||||
efdr_t *file_ptr = cur_file_ptr;
|
||||
varray_t *vp = &file_ptr->aux_syms;
|
||||
|
||||
if (vp->objects_last_page == vp->objects_per_page)
|
||||
add_varray_page (vp);
|
||||
|
@ -2141,9 +2141,9 @@ add_aux_sym_tir (t, state, hash_tbl)
|
|||
hash_state_t state; /* whether to hash type or not */
|
||||
thash_t **hash_tbl; /* pointer to hash table to use */
|
||||
{
|
||||
register AUXU *aux_ptr;
|
||||
register efdr_t *file_ptr = cur_file_ptr;
|
||||
register varray_t *vp = &file_ptr->aux_syms;
|
||||
AUXU *aux_ptr;
|
||||
efdr_t *file_ptr = cur_file_ptr;
|
||||
varray_t *vp = &file_ptr->aux_syms;
|
||||
static AUXU init_aux;
|
||||
symint_t ret;
|
||||
int i;
|
||||
|
@ -2186,8 +2186,8 @@ add_aux_sym_tir (t, state, hash_tbl)
|
|||
|
||||
if (state != hash_no)
|
||||
{
|
||||
register thash_t *hash_ptr;
|
||||
register symint_t hi;
|
||||
thash_t *hash_ptr;
|
||||
symint_t hi;
|
||||
|
||||
hi = aux.isym & ((1 << HASHBITS) - 1);
|
||||
hi %= THASH_SIZE;
|
||||
|
@ -2243,8 +2243,8 @@ add_aux_sym_tir (t, state, hash_tbl)
|
|||
|| t->basic_type == bt_Union
|
||||
|| t->basic_type == bt_Enum)
|
||||
{
|
||||
register symint_t file_index = t->tag_ptr->ifd;
|
||||
register symint_t sym_index = t->tag_ptr->indx;
|
||||
symint_t file_index = t->tag_ptr->ifd;
|
||||
symint_t sym_index = t->tag_ptr->indx;
|
||||
|
||||
if (t->unknown_tag)
|
||||
{
|
||||
|
@ -2258,7 +2258,7 @@ add_aux_sym_tir (t, state, hash_tbl)
|
|||
}
|
||||
else
|
||||
{
|
||||
register forward_t *forward_ref = allocate_forward ();
|
||||
forward_t *forward_ref = allocate_forward ();
|
||||
|
||||
forward_ref->type_ptr = aux_ptr;
|
||||
forward_ref->next = t->tag_ptr->forward_ref;
|
||||
|
@ -2414,15 +2414,15 @@ add_procedure (func_start, func_end_p1)
|
|||
const char *func_start; /* 1st byte of func name */
|
||||
const char *func_end_p1; /* 1st byte after func name */
|
||||
{
|
||||
register PDR *new_proc_ptr;
|
||||
register efdr_t *file_ptr = cur_file_ptr;
|
||||
register varray_t *vp = &file_ptr->procs;
|
||||
register symint_t value = 0;
|
||||
register st_t proc_type = st_Proc;
|
||||
register shash_t *shash_ptr = hash_string (func_start,
|
||||
func_end_p1 - func_start,
|
||||
&orig_str_hash[0],
|
||||
(symint_t *) 0);
|
||||
PDR *new_proc_ptr;
|
||||
efdr_t *file_ptr = cur_file_ptr;
|
||||
varray_t *vp = &file_ptr->procs;
|
||||
symint_t value = 0;
|
||||
st_t proc_type = st_Proc;
|
||||
shash_t *shash_ptr = hash_string (func_start,
|
||||
func_end_p1 - func_start,
|
||||
&orig_str_hash[0],
|
||||
(symint_t *) 0);
|
||||
|
||||
if (debug)
|
||||
fputc ('\n', stderr);
|
||||
|
@ -2439,8 +2439,8 @@ add_procedure (func_start, func_end_p1)
|
|||
cur_oproc_ptr = (PDR *) 0;
|
||||
if (shash_ptr != (shash_t *) 0)
|
||||
{
|
||||
register PDR *old_proc_ptr = shash_ptr->proc_ptr;
|
||||
register SYMR *sym_ptr = shash_ptr->sym_ptr;
|
||||
PDR *old_proc_ptr = shash_ptr->proc_ptr;
|
||||
SYMR *sym_ptr = shash_ptr->sym_ptr;
|
||||
|
||||
if (old_proc_ptr != (PDR *) 0
|
||||
&& sym_ptr != (SYMR *) 0
|
||||
|
@ -2482,9 +2482,9 @@ add_file (file_start, file_end_p1)
|
|||
{
|
||||
static char zero_bytes[2] = { '\0', '\0' };
|
||||
|
||||
register Ptrdiff_t len = file_end_p1 - file_start;
|
||||
register int first_ch = *file_start;
|
||||
register efdr_t *file_ptr;
|
||||
Ptrdiff_t len = file_end_p1 - file_start;
|
||||
int first_ch = *file_start;
|
||||
efdr_t *file_ptr;
|
||||
|
||||
if (debug)
|
||||
fprintf (stderr, "\tfile\t%.*s\n", (int) len, file_start);
|
||||
|
@ -2561,9 +2561,9 @@ add_bytes (vp, input_ptr, nitems)
|
|||
char *input_ptr; /* start of the bytes */
|
||||
Size_t nitems; /* # items to move */
|
||||
{
|
||||
register Size_t move_items;
|
||||
register Size_t move_bytes;
|
||||
register char *ptr;
|
||||
Size_t move_items;
|
||||
Size_t move_bytes;
|
||||
char *ptr;
|
||||
|
||||
while (nitems > 0)
|
||||
{
|
||||
|
@ -2673,10 +2673,10 @@ STATIC char *
|
|||
read_line ()
|
||||
{
|
||||
static int line_split_p = 0;
|
||||
register int string_p = 0;
|
||||
register int comment_p = 0;
|
||||
register int ch;
|
||||
register char *ptr;
|
||||
int string_p = 0;
|
||||
int comment_p = 0;
|
||||
int ch;
|
||||
char *ptr;
|
||||
|
||||
if (cur_line_start == (char *) 0)
|
||||
{ /* allocate initial page */
|
||||
|
@ -2694,8 +2694,8 @@ read_line ()
|
|||
{
|
||||
if (++cur_line_nbytes >= cur_line_alloc-1)
|
||||
{
|
||||
register int num_pages = cur_line_alloc / PAGE_SIZE;
|
||||
register char *old_buffer = cur_line_start;
|
||||
int num_pages = cur_line_alloc / PAGE_SIZE;
|
||||
char *old_buffer = cur_line_start;
|
||||
|
||||
cur_line_alloc += PAGE_SIZE;
|
||||
cur_line_start = (char *) allocate_multiple_pages (num_pages+1);
|
||||
|
@ -3435,10 +3435,10 @@ STATIC void
|
|||
parse_end (start)
|
||||
const char *start; /* start of directive */
|
||||
{
|
||||
register const char *start_func, *end_func_p1;
|
||||
register int ch;
|
||||
register symint_t value;
|
||||
register FDR *orig_fdr;
|
||||
const char *start_func, *end_func_p1;
|
||||
int ch;
|
||||
symint_t value;
|
||||
FDR *orig_fdr;
|
||||
|
||||
if (cur_file_ptr == (efdr_t *) 0)
|
||||
{
|
||||
|
@ -3498,8 +3498,8 @@ STATIC void
|
|||
parse_ent (start)
|
||||
const char *start; /* start of directive */
|
||||
{
|
||||
register const char *start_func, *end_func_p1;
|
||||
register int ch;
|
||||
const char *start_func, *end_func_p1;
|
||||
int ch;
|
||||
|
||||
if (cur_file_ptr == (efdr_t *) 0)
|
||||
{
|
||||
|
@ -3537,7 +3537,7 @@ parse_file (start)
|
|||
const char *start; /* start of directive */
|
||||
{
|
||||
char *p;
|
||||
register char *start_name, *end_name_p1;
|
||||
char *start_name, *end_name_p1;
|
||||
|
||||
(void) strtol (start, &p, 0);
|
||||
if (start == p
|
||||
|
@ -3834,11 +3834,11 @@ parse_stabn (start)
|
|||
STATIC void
|
||||
parse_input ()
|
||||
{
|
||||
register char *p;
|
||||
register Size_t i;
|
||||
register thead_t *ptag_head;
|
||||
register tag_t *ptag;
|
||||
register tag_t *ptag_next;
|
||||
char *p;
|
||||
Size_t i;
|
||||
thead_t *ptag_head;
|
||||
tag_t *ptag;
|
||||
tag_t *ptag_next;
|
||||
|
||||
if (debug)
|
||||
fprintf (stderr, "\tinput\n");
|
||||
|
@ -3897,8 +3897,8 @@ parse_input ()
|
|||
STATIC void
|
||||
update_headers ()
|
||||
{
|
||||
register symint_t i;
|
||||
register efdr_t *file_ptr;
|
||||
symint_t i;
|
||||
efdr_t *file_ptr;
|
||||
|
||||
/* Set up the symbolic header. */
|
||||
file_offset = sizeof (symbolic_header) + orig_file_header.f_symptr;
|
||||
|
@ -3924,10 +3924,10 @@ update_headers ()
|
|||
file_ptr != (efdr_t *) 0;
|
||||
file_ptr = file_ptr->next_file)
|
||||
{
|
||||
register SYMR *sym_start;
|
||||
register SYMR *sym;
|
||||
register SYMR *sym_end_p1;
|
||||
register FDR *fd_ptr = file_ptr->orig_fdr;
|
||||
SYMR *sym_start;
|
||||
SYMR *sym;
|
||||
SYMR *sym_end_p1;
|
||||
FDR *fd_ptr = file_ptr->orig_fdr;
|
||||
|
||||
cur_file_ptr = file_ptr;
|
||||
|
||||
|
@ -3941,9 +3941,9 @@ update_headers ()
|
|||
{
|
||||
if ((st_t)sym->st == st_Static)
|
||||
{
|
||||
register char *str = ORIG_LSTRS (fd_ptr->issBase + sym->iss);
|
||||
register Size_t len = strlen (str);
|
||||
register shash_t *hash_ptr;
|
||||
char *str = ORIG_LSTRS (fd_ptr->issBase + sym->iss);
|
||||
Size_t len = strlen (str);
|
||||
shash_t *hash_ptr;
|
||||
|
||||
/* Ignore internal labels. */
|
||||
if (str[0] == '$' && str[1] == 'L')
|
||||
|
@ -4440,13 +4440,13 @@ STATIC void
|
|||
copy_object ()
|
||||
{
|
||||
char buffer[ PAGE_SIZE ];
|
||||
register int sys_read;
|
||||
register int remaining;
|
||||
register int num_write;
|
||||
register int sys_write;
|
||||
register int fd, es;
|
||||
register int delete_ifd = 0;
|
||||
register int *remap_file_number;
|
||||
int sys_read;
|
||||
int remaining;
|
||||
int num_write;
|
||||
int sys_write;
|
||||
int fd, es;
|
||||
int delete_ifd = 0;
|
||||
int *remap_file_number;
|
||||
struct stat stat_buf;
|
||||
|
||||
if (debug)
|
||||
|
@ -4597,8 +4597,8 @@ copy_object ()
|
|||
|
||||
for (fd = delete_ifd; fd < orig_sym_hdr.ifdMax; fd++)
|
||||
{
|
||||
register FDR *fd_ptr = ORIG_FILES (fd);
|
||||
register char *filename = ORIG_LSTRS (fd_ptr->issBase + fd_ptr->rss);
|
||||
FDR *fd_ptr = ORIG_FILES (fd);
|
||||
char *filename = ORIG_LSTRS (fd_ptr->issBase + fd_ptr->rss);
|
||||
|
||||
/* file support itself. */
|
||||
add_file (filename, filename + strlen (filename));
|
||||
|
@ -4622,8 +4622,8 @@ copy_object ()
|
|||
|
||||
for (es = 0; es < orig_sym_hdr.iextMax; es++)
|
||||
{
|
||||
register EXTR *eptr = orig_ext_syms + es;
|
||||
register unsigned ifd = eptr->ifd;
|
||||
EXTR *eptr = orig_ext_syms + es;
|
||||
unsigned ifd = eptr->ifd;
|
||||
|
||||
(void) add_ext_symbol (eptr, ((long) ifd < orig_sym_hdr.ifdMax)
|
||||
? remap_file_number[ ifd ] : ifd );
|
||||
|
@ -4635,14 +4635,14 @@ copy_object ()
|
|||
|
||||
for (fd = delete_ifd; fd < orig_sym_hdr.ifdMax; fd++)
|
||||
{
|
||||
register FDR *fd_ptr = ORIG_FILES (fd);
|
||||
register char *filename = ORIG_LSTRS (fd_ptr->issBase + fd_ptr->rss);
|
||||
register SYMR *sym_start;
|
||||
register SYMR *sym;
|
||||
register SYMR *sym_end_p1;
|
||||
register PDR *proc_start;
|
||||
register PDR *proc;
|
||||
register PDR *proc_end_p1;
|
||||
FDR *fd_ptr = ORIG_FILES (fd);
|
||||
char *filename = ORIG_LSTRS (fd_ptr->issBase + fd_ptr->rss);
|
||||
SYMR *sym_start;
|
||||
SYMR *sym;
|
||||
SYMR *sym_end_p1;
|
||||
PDR *proc_start;
|
||||
PDR *proc;
|
||||
PDR *proc_end_p1;
|
||||
|
||||
/* file support itself. */
|
||||
add_file (filename, filename + strlen (filename));
|
||||
|
@ -4683,12 +4683,12 @@ copy_object ()
|
|||
case st_StaticProc:
|
||||
{
|
||||
auto symint_t hash_index;
|
||||
register char *str = ORIG_LSTRS (fd_ptr->issBase + sym->iss);
|
||||
register Size_t len = strlen (str);
|
||||
register shash_t *shash_ptr = hash_string (str,
|
||||
(Ptrdiff_t)len,
|
||||
&orig_str_hash[0],
|
||||
&hash_index);
|
||||
char *str = ORIG_LSTRS (fd_ptr->issBase + sym->iss);
|
||||
Size_t len = strlen (str);
|
||||
shash_t *shash_ptr = hash_string (str,
|
||||
(Ptrdiff_t)len,
|
||||
&orig_str_hash[0],
|
||||
&hash_index);
|
||||
|
||||
if (shash_ptr != (shash_t *) 0)
|
||||
error ("internal error, %s is already in original symbol table", str);
|
||||
|
@ -4710,15 +4710,15 @@ copy_object ()
|
|||
case st_End:
|
||||
if ((sc_t) sym->sc == sc_Text)
|
||||
{
|
||||
register char *str = ORIG_LSTRS (fd_ptr->issBase + sym->iss);
|
||||
char *str = ORIG_LSTRS (fd_ptr->issBase + sym->iss);
|
||||
|
||||
if (*str != '\0')
|
||||
{
|
||||
register Size_t len = strlen (str);
|
||||
register shash_t *shash_ptr = hash_string (str,
|
||||
(Ptrdiff_t)len,
|
||||
&orig_str_hash[0],
|
||||
(symint_t *) 0);
|
||||
Size_t len = strlen (str);
|
||||
shash_t *shash_ptr = hash_string (str,
|
||||
(Ptrdiff_t)len,
|
||||
&orig_str_hash[0],
|
||||
(symint_t *) 0);
|
||||
|
||||
if (shash_ptr != (shash_t *) 0)
|
||||
shash_ptr->end_ptr = sym;
|
||||
|
@ -4742,13 +4742,13 @@ copy_object ()
|
|||
proc_end_p1 = proc_start + fd_ptr->cpd;
|
||||
for (proc = proc_start; proc < proc_end_p1; proc++)
|
||||
{
|
||||
register SYMR *proc_sym = ORIG_LSYMS (fd_ptr->isymBase + proc->isym);
|
||||
register char *str = ORIG_LSTRS (fd_ptr->issBase + proc_sym->iss);
|
||||
register Size_t len = strlen (str);
|
||||
register shash_t *shash_ptr = hash_string (str,
|
||||
(Ptrdiff_t)len,
|
||||
&orig_str_hash[0],
|
||||
(symint_t *) 0);
|
||||
SYMR *proc_sym = ORIG_LSYMS (fd_ptr->isymBase + proc->isym);
|
||||
char *str = ORIG_LSTRS (fd_ptr->issBase + proc_sym->iss);
|
||||
Size_t len = strlen (str);
|
||||
shash_t *shash_ptr = hash_string (str,
|
||||
(Ptrdiff_t)len,
|
||||
&orig_str_hash[0],
|
||||
(symint_t *) 0);
|
||||
|
||||
if (shash_ptr == (shash_t *) 0)
|
||||
error ("internal error, function %s is not in original symbol table", str);
|
||||
|
@ -5091,7 +5091,7 @@ STATIC page_t *
|
|||
allocate_cluster (npages)
|
||||
Size_t npages;
|
||||
{
|
||||
register page_t *value = (page_t *) xcalloc (npages, PAGE_USIZE);
|
||||
page_t *value = (page_t *) xcalloc (npages, PAGE_USIZE);
|
||||
|
||||
if (debug > 3)
|
||||
fprintf (stderr, "\talloc\tnpages = %d, value = 0x%.8x\n", npages, value);
|
||||
|
@ -5105,7 +5105,7 @@ STATIC page_t *
|
|||
allocate_cluster (npages)
|
||||
Size_t npages;
|
||||
{
|
||||
register page_t *ptr = (page_t *) sbrk (0); /* current sbreak */
|
||||
page_t *ptr = (page_t *) sbrk (0); /* current sbreak */
|
||||
unsigned long offset = ((unsigned long) ptr) & (PAGE_SIZE - 1);
|
||||
|
||||
if (offset != 0) /* align to a page boundary */
|
||||
|
@ -5227,7 +5227,7 @@ allocate_page ()
|
|||
STATIC scope_t *
|
||||
allocate_scope ()
|
||||
{
|
||||
register scope_t *ptr;
|
||||
scope_t *ptr;
|
||||
static scope_t initial_scope;
|
||||
|
||||
#ifndef MALLOC_CHECK
|
||||
|
@ -5237,8 +5237,8 @@ allocate_scope ()
|
|||
|
||||
else
|
||||
{
|
||||
register int unallocated = alloc_counts[ (int)alloc_type_scope ].unallocated;
|
||||
register page_t *cur_page = alloc_counts[ (int)alloc_type_scope ].cur_page;
|
||||
int unallocated = alloc_counts[ (int)alloc_type_scope ].unallocated;
|
||||
page_t *cur_page = alloc_counts[ (int)alloc_type_scope ].cur_page;
|
||||
|
||||
if (unallocated == 0)
|
||||
{
|
||||
|
@ -5285,12 +5285,12 @@ free_scope (ptr)
|
|||
STATIC vlinks_t *
|
||||
allocate_vlinks ()
|
||||
{
|
||||
register vlinks_t *ptr;
|
||||
vlinks_t *ptr;
|
||||
static vlinks_t initial_vlinks;
|
||||
|
||||
#ifndef MALLOC_CHECK
|
||||
register int unallocated = alloc_counts[ (int)alloc_type_vlinks ].unallocated;
|
||||
register page_t *cur_page = alloc_counts[ (int)alloc_type_vlinks ].cur_page;
|
||||
int unallocated = alloc_counts[ (int)alloc_type_vlinks ].unallocated;
|
||||
page_t *cur_page = alloc_counts[ (int)alloc_type_vlinks ].cur_page;
|
||||
|
||||
if (unallocated == 0)
|
||||
{
|
||||
|
@ -5318,12 +5318,12 @@ allocate_vlinks ()
|
|||
STATIC shash_t *
|
||||
allocate_shash ()
|
||||
{
|
||||
register shash_t *ptr;
|
||||
shash_t *ptr;
|
||||
static shash_t initial_shash;
|
||||
|
||||
#ifndef MALLOC_CHECK
|
||||
register int unallocated = alloc_counts[ (int)alloc_type_shash ].unallocated;
|
||||
register page_t *cur_page = alloc_counts[ (int)alloc_type_shash ].cur_page;
|
||||
int unallocated = alloc_counts[ (int)alloc_type_shash ].unallocated;
|
||||
page_t *cur_page = alloc_counts[ (int)alloc_type_shash ].cur_page;
|
||||
|
||||
if (unallocated == 0)
|
||||
{
|
||||
|
@ -5351,12 +5351,12 @@ allocate_shash ()
|
|||
STATIC thash_t *
|
||||
allocate_thash ()
|
||||
{
|
||||
register thash_t *ptr;
|
||||
thash_t *ptr;
|
||||
static thash_t initial_thash;
|
||||
|
||||
#ifndef MALLOC_CHECK
|
||||
register int unallocated = alloc_counts[ (int)alloc_type_thash ].unallocated;
|
||||
register page_t *cur_page = alloc_counts[ (int)alloc_type_thash ].cur_page;
|
||||
int unallocated = alloc_counts[ (int)alloc_type_thash ].unallocated;
|
||||
page_t *cur_page = alloc_counts[ (int)alloc_type_thash ].cur_page;
|
||||
|
||||
if (unallocated == 0)
|
||||
{
|
||||
|
@ -5384,7 +5384,7 @@ allocate_thash ()
|
|||
STATIC tag_t *
|
||||
allocate_tag ()
|
||||
{
|
||||
register tag_t *ptr;
|
||||
tag_t *ptr;
|
||||
static tag_t initial_tag;
|
||||
|
||||
#ifndef MALLOC_CHECK
|
||||
|
@ -5394,8 +5394,8 @@ allocate_tag ()
|
|||
|
||||
else
|
||||
{
|
||||
register int unallocated = alloc_counts[ (int)alloc_type_tag ].unallocated;
|
||||
register page_t *cur_page = alloc_counts[ (int)alloc_type_tag ].cur_page;
|
||||
int unallocated = alloc_counts[ (int)alloc_type_tag ].unallocated;
|
||||
page_t *cur_page = alloc_counts[ (int)alloc_type_tag ].cur_page;
|
||||
|
||||
if (unallocated == 0)
|
||||
{
|
||||
|
@ -5442,7 +5442,7 @@ free_tag (ptr)
|
|||
STATIC forward_t *
|
||||
allocate_forward ()
|
||||
{
|
||||
register forward_t *ptr;
|
||||
forward_t *ptr;
|
||||
static forward_t initial_forward;
|
||||
|
||||
#ifndef MALLOC_CHECK
|
||||
|
@ -5452,8 +5452,8 @@ allocate_forward ()
|
|||
|
||||
else
|
||||
{
|
||||
register int unallocated = alloc_counts[ (int)alloc_type_forward ].unallocated;
|
||||
register page_t *cur_page = alloc_counts[ (int)alloc_type_forward ].cur_page;
|
||||
int unallocated = alloc_counts[ (int)alloc_type_forward ].unallocated;
|
||||
page_t *cur_page = alloc_counts[ (int)alloc_type_forward ].cur_page;
|
||||
|
||||
if (unallocated == 0)
|
||||
{
|
||||
|
@ -5500,7 +5500,7 @@ free_forward (ptr)
|
|||
STATIC thead_t *
|
||||
allocate_thead ()
|
||||
{
|
||||
register thead_t *ptr;
|
||||
thead_t *ptr;
|
||||
static thead_t initial_thead;
|
||||
|
||||
#ifndef MALLOC_CHECK
|
||||
|
@ -5510,8 +5510,8 @@ allocate_thead ()
|
|||
|
||||
else
|
||||
{
|
||||
register int unallocated = alloc_counts[ (int)alloc_type_thead ].unallocated;
|
||||
register page_t *cur_page = alloc_counts[ (int)alloc_type_thead ].cur_page;
|
||||
int unallocated = alloc_counts[ (int)alloc_type_thead ].unallocated;
|
||||
page_t *cur_page = alloc_counts[ (int)alloc_type_thead ].cur_page;
|
||||
|
||||
if (unallocated == 0)
|
||||
{
|
||||
|
|
62
gcc/optabs.c
62
gcc/optabs.c
|
@ -645,7 +645,7 @@ expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods)
|
|||
? OPTAB_WIDEN : methods);
|
||||
enum mode_class class;
|
||||
enum machine_mode wider_mode;
|
||||
register rtx temp;
|
||||
rtx temp;
|
||||
int commutative_op = 0;
|
||||
int shift_op = (binoptab->code == ASHIFT
|
||||
|| binoptab->code == ASHIFTRT
|
||||
|
@ -738,7 +738,7 @@ expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods)
|
|||
if (GET_MODE (op0) != mode0 && GET_MODE (op1) != mode1
|
||||
&& GET_MODE (op0) == mode1 && GET_MODE (op1) == mode0)
|
||||
{
|
||||
register rtx tmp;
|
||||
rtx tmp;
|
||||
|
||||
tmp = op0; op0 = op1; op1 = tmp;
|
||||
tmp = xop0; xop0 = xop1; xop1 = tmp;
|
||||
|
@ -1862,7 +1862,7 @@ sign_expand_binop (mode, uoptab, soptab, op0, op1, target, unsignedp, methods)
|
|||
int unsignedp;
|
||||
enum optab_methods methods;
|
||||
{
|
||||
register rtx temp;
|
||||
rtx temp;
|
||||
optab direct_optab = unsignedp ? uoptab : soptab;
|
||||
struct optab wide_soptab;
|
||||
|
||||
|
@ -2011,8 +2011,8 @@ expand_twoval_binop (binoptab, op0, op1, targ0, targ1, unsignedp)
|
|||
if (binoptab->handlers[(int) wider_mode].insn_code
|
||||
!= CODE_FOR_nothing)
|
||||
{
|
||||
register rtx t0 = gen_reg_rtx (wider_mode);
|
||||
register rtx t1 = gen_reg_rtx (wider_mode);
|
||||
rtx t0 = gen_reg_rtx (wider_mode);
|
||||
rtx t1 = gen_reg_rtx (wider_mode);
|
||||
rtx cop0 = convert_modes (wider_mode, mode, op0, unsignedp);
|
||||
rtx cop1 = convert_modes (wider_mode, mode, op1, unsignedp);
|
||||
|
||||
|
@ -2072,7 +2072,7 @@ expand_unop (mode, unoptab, op0, target, unsignedp)
|
|||
{
|
||||
enum mode_class class;
|
||||
enum machine_mode wider_mode;
|
||||
register rtx temp;
|
||||
rtx temp;
|
||||
rtx last = get_last_insn ();
|
||||
rtx pat;
|
||||
|
||||
|
@ -2448,7 +2448,7 @@ expand_complex_abs (mode, op0, target, unsignedp)
|
|||
{
|
||||
enum mode_class class = GET_MODE_CLASS (mode);
|
||||
enum machine_mode wider_mode;
|
||||
register rtx temp;
|
||||
rtx temp;
|
||||
rtx entry_last = get_last_insn ();
|
||||
rtx last;
|
||||
rtx pat;
|
||||
|
@ -2649,7 +2649,7 @@ emit_unop_insn (icode, target, op0, code)
|
|||
rtx op0;
|
||||
enum rtx_code code;
|
||||
{
|
||||
register rtx temp;
|
||||
rtx temp;
|
||||
enum machine_mode mode0 = insn_data[icode].operand[1].mode;
|
||||
rtx pat;
|
||||
|
||||
|
@ -3923,7 +3923,7 @@ rtx
|
|||
gen_move_insn (x, y)
|
||||
rtx x, y;
|
||||
{
|
||||
register enum machine_mode mode = GET_MODE (x);
|
||||
enum machine_mode mode = GET_MODE (x);
|
||||
enum insn_code insn_code;
|
||||
rtx seq;
|
||||
|
||||
|
@ -4070,7 +4070,7 @@ expand_float (to, from, unsignedp)
|
|||
int unsignedp;
|
||||
{
|
||||
enum insn_code icode;
|
||||
register rtx target = to;
|
||||
rtx target = to;
|
||||
enum machine_mode fmode, imode;
|
||||
|
||||
/* Crash now, because we won't be able to decide which mode to use. */
|
||||
|
@ -4337,11 +4337,11 @@ ftruncify (x)
|
|||
|
||||
void
|
||||
expand_fix (to, from, unsignedp)
|
||||
register rtx to, from;
|
||||
rtx to, from;
|
||||
int unsignedp;
|
||||
{
|
||||
enum insn_code icode;
|
||||
register rtx target = to;
|
||||
rtx target = to;
|
||||
enum machine_mode fmode, imode;
|
||||
int must_trunc = 0;
|
||||
rtx libfcn = 0;
|
||||
|
@ -4625,23 +4625,23 @@ init_optabv (code)
|
|||
|
||||
static void
|
||||
init_libfuncs (optable, first_mode, last_mode, opname, suffix)
|
||||
register optab optable;
|
||||
register int first_mode;
|
||||
register int last_mode;
|
||||
register const char *opname;
|
||||
register int suffix;
|
||||
optab optable;
|
||||
int first_mode;
|
||||
int last_mode;
|
||||
const char *opname;
|
||||
int suffix;
|
||||
{
|
||||
register int mode;
|
||||
register unsigned opname_len = strlen (opname);
|
||||
int mode;
|
||||
unsigned opname_len = strlen (opname);
|
||||
|
||||
for (mode = first_mode; (int) mode <= (int) last_mode;
|
||||
mode = (enum machine_mode) ((int) mode + 1))
|
||||
{
|
||||
register const char *mname = GET_MODE_NAME(mode);
|
||||
register unsigned mname_len = strlen (mname);
|
||||
register char *libfunc_name = alloca (2 + opname_len + mname_len + 1 + 1);
|
||||
register char *p;
|
||||
register const char *q;
|
||||
const char *mname = GET_MODE_NAME(mode);
|
||||
unsigned mname_len = strlen (mname);
|
||||
char *libfunc_name = alloca (2 + opname_len + mname_len + 1 + 1);
|
||||
char *p;
|
||||
const char *q;
|
||||
|
||||
p = libfunc_name;
|
||||
*p++ = '_';
|
||||
|
@ -4666,9 +4666,9 @@ init_libfuncs (optable, first_mode, last_mode, opname, suffix)
|
|||
|
||||
static void
|
||||
init_integral_libfuncs (optable, opname, suffix)
|
||||
register optab optable;
|
||||
register const char *opname;
|
||||
register int suffix;
|
||||
optab optable;
|
||||
const char *opname;
|
||||
int suffix;
|
||||
{
|
||||
init_libfuncs (optable, SImode, TImode, opname, suffix);
|
||||
}
|
||||
|
@ -4680,16 +4680,16 @@ init_integral_libfuncs (optable, opname, suffix)
|
|||
|
||||
static void
|
||||
init_floating_libfuncs (optable, opname, suffix)
|
||||
register optab optable;
|
||||
register const char *opname;
|
||||
register int suffix;
|
||||
optab optable;
|
||||
const char *opname;
|
||||
int suffix;
|
||||
{
|
||||
init_libfuncs (optable, SFmode, TFmode, opname, suffix);
|
||||
}
|
||||
|
||||
rtx
|
||||
init_one_libfunc (name)
|
||||
register const char *name;
|
||||
const char *name;
|
||||
{
|
||||
/* Create a FUNCTION_DECL that can be passed to ENCODE_SECTION_INFO. */
|
||||
/* ??? We don't have any type information except for this is
|
||||
|
|
|
@ -115,7 +115,7 @@ save_string (s, len)
|
|||
const char *s;
|
||||
int len;
|
||||
{
|
||||
register char *result = xmalloc (len + 1);
|
||||
char *result = xmalloc (len + 1);
|
||||
|
||||
memcpy (result, s, len);
|
||||
result[len] = 0;
|
||||
|
|
|
@ -76,12 +76,12 @@ static int debug_call_placeholder_verbose;
|
|||
|
||||
static void
|
||||
print_rtx (in_rtx)
|
||||
register rtx in_rtx;
|
||||
rtx in_rtx;
|
||||
{
|
||||
register int i = 0;
|
||||
register int j;
|
||||
register const char *format_ptr;
|
||||
register int is_insn;
|
||||
int i = 0;
|
||||
int j;
|
||||
const char *format_ptr;
|
||||
int is_insn;
|
||||
rtx tem;
|
||||
|
||||
if (sawclose)
|
||||
|
@ -335,7 +335,7 @@ print_rtx (in_rtx)
|
|||
}
|
||||
else
|
||||
{
|
||||
register int value = XINT (in_rtx, i);
|
||||
int value = XINT (in_rtx, i);
|
||||
const char *name;
|
||||
|
||||
if (GET_CODE (in_rtx) == REG && value < FIRST_PSEUDO_REGISTER)
|
||||
|
@ -639,7 +639,7 @@ print_rtl (outf, rtx_first)
|
|||
FILE *outf;
|
||||
rtx rtx_first;
|
||||
{
|
||||
register rtx tmp_rtx;
|
||||
rtx tmp_rtx;
|
||||
|
||||
outfile = outf;
|
||||
sawclose = 0;
|
||||
|
|
|
@ -105,7 +105,8 @@ int
|
|||
read_skip_spaces (infile)
|
||||
FILE *infile;
|
||||
{
|
||||
register int c;
|
||||
int c;
|
||||
|
||||
while (1)
|
||||
{
|
||||
c = getc (infile);
|
||||
|
@ -127,7 +128,7 @@ read_skip_spaces (infile)
|
|||
|
||||
case '/':
|
||||
{
|
||||
register int prevc;
|
||||
int prevc;
|
||||
c = getc (infile);
|
||||
if (c != '*')
|
||||
fatal_expected_char (infile, '*', c);
|
||||
|
@ -158,10 +159,10 @@ read_name (str, infile)
|
|||
char *str;
|
||||
FILE *infile;
|
||||
{
|
||||
register char *p;
|
||||
register int c;
|
||||
char *p;
|
||||
int c;
|
||||
|
||||
c = read_skip_spaces(infile);
|
||||
c = read_skip_spaces (infile);
|
||||
|
||||
p = str;
|
||||
while (1)
|
||||
|
@ -212,6 +213,7 @@ read_escape (ob, infile)
|
|||
FILE *infile;
|
||||
{
|
||||
int c = getc (infile);
|
||||
|
||||
switch (c)
|
||||
{
|
||||
/* Backslash-newline is replaced by nothing, as in C. */
|
||||
|
@ -266,6 +268,7 @@ read_quoted_string (ob, infile)
|
|||
FILE *infile;
|
||||
{
|
||||
int c;
|
||||
|
||||
while (1)
|
||||
{
|
||||
c = getc (infile); /* Read the string */
|
||||
|
@ -500,15 +503,15 @@ rtx
|
|||
read_rtx (infile)
|
||||
FILE *infile;
|
||||
{
|
||||
register int i, j;
|
||||
int i, j;
|
||||
RTX_CODE tmp_code;
|
||||
register const char *format_ptr;
|
||||
const char *format_ptr;
|
||||
/* tmp_char is a buffer used for reading decimal integers
|
||||
and names of rtx types and machine modes.
|
||||
Therefore, 256 must be enough. */
|
||||
char tmp_char[256];
|
||||
rtx return_rtx;
|
||||
register int c;
|
||||
int c;
|
||||
int tmp_int;
|
||||
HOST_WIDE_INT tmp_wide;
|
||||
|
||||
|
|
94
gcc/real.c
94
gcc/real.c
|
@ -1606,9 +1606,9 @@ extern int rndprc;
|
|||
|
||||
static void
|
||||
eclear (x)
|
||||
register UEMUSHORT *x;
|
||||
UEMUSHORT *x;
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < NE; i++)
|
||||
*x++ = 0;
|
||||
|
@ -1618,9 +1618,9 @@ eclear (x)
|
|||
|
||||
static void
|
||||
emov (a, b)
|
||||
register UEMUSHORT *a, *b;
|
||||
UEMUSHORT *a, *b;
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < NE; i++)
|
||||
*b++ = *a++;
|
||||
|
@ -1708,9 +1708,9 @@ eisnan (x)
|
|||
|
||||
static void
|
||||
einfin (x)
|
||||
register UEMUSHORT *x;
|
||||
UEMUSHORT *x;
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
#ifdef INFINITY
|
||||
for (i = 0; i < NE - 1; i++)
|
||||
|
@ -1752,10 +1752,10 @@ einfin (x)
|
|||
#ifdef NANS
|
||||
static void
|
||||
enan (x, sign)
|
||||
register UEMUSHORT *x;
|
||||
UEMUSHORT *x;
|
||||
int sign;
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < NE - 2; i++)
|
||||
*x++ = 0;
|
||||
|
@ -1770,7 +1770,7 @@ static void
|
|||
emovi (a, b)
|
||||
UEMUSHORT *a, *b;
|
||||
{
|
||||
register UEMUSHORT *p, *q;
|
||||
UEMUSHORT *p, *q;
|
||||
int i;
|
||||
|
||||
q = b;
|
||||
|
@ -1817,7 +1817,7 @@ static void
|
|||
emovo (a, b)
|
||||
UEMUSHORT *a, *b;
|
||||
{
|
||||
register UEMUSHORT *p, *q;
|
||||
UEMUSHORT *p, *q;
|
||||
UEMUSHORT i;
|
||||
int j;
|
||||
|
||||
|
@ -1854,9 +1854,9 @@ emovo (a, b)
|
|||
|
||||
static void
|
||||
ecleaz (xi)
|
||||
register UEMUSHORT *xi;
|
||||
UEMUSHORT *xi;
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < NI; i++)
|
||||
*xi++ = 0;
|
||||
|
@ -1866,9 +1866,9 @@ ecleaz (xi)
|
|||
|
||||
static void
|
||||
ecleazs (xi)
|
||||
register UEMUSHORT *xi;
|
||||
UEMUSHORT *xi;
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
++xi;
|
||||
for (i = 0; i < NI - 1; i++)
|
||||
|
@ -1879,9 +1879,9 @@ ecleazs (xi)
|
|||
|
||||
static void
|
||||
emovz (a, b)
|
||||
register UEMUSHORT *a, *b;
|
||||
UEMUSHORT *a, *b;
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < NI - 1; i++)
|
||||
*b++ = *a++;
|
||||
|
@ -1979,7 +1979,7 @@ eiisinf (x)
|
|||
|
||||
static int
|
||||
ecmpm (a, b)
|
||||
register UEMUSHORT *a, *b;
|
||||
UEMUSHORT *a, *b;
|
||||
{
|
||||
int i;
|
||||
|
||||
|
@ -2003,9 +2003,9 @@ ecmpm (a, b)
|
|||
|
||||
static void
|
||||
eshdn1 (x)
|
||||
register UEMUSHORT *x;
|
||||
UEMUSHORT *x;
|
||||
{
|
||||
register UEMUSHORT bits;
|
||||
UEMUSHORT bits;
|
||||
int i;
|
||||
|
||||
x += M; /* point to significand area */
|
||||
|
@ -2027,9 +2027,9 @@ eshdn1 (x)
|
|||
|
||||
static void
|
||||
eshup1 (x)
|
||||
register UEMUSHORT *x;
|
||||
UEMUSHORT *x;
|
||||
{
|
||||
register UEMUSHORT bits;
|
||||
UEMUSHORT bits;
|
||||
int i;
|
||||
|
||||
x += NI - 1;
|
||||
|
@ -2052,9 +2052,9 @@ eshup1 (x)
|
|||
|
||||
static void
|
||||
eshdn8 (x)
|
||||
register UEMUSHORT *x;
|
||||
UEMUSHORT *x;
|
||||
{
|
||||
register UEMUSHORT newbyt, oldbyt;
|
||||
UEMUSHORT newbyt, oldbyt;
|
||||
int i;
|
||||
|
||||
x += M;
|
||||
|
@ -2073,10 +2073,10 @@ eshdn8 (x)
|
|||
|
||||
static void
|
||||
eshup8 (x)
|
||||
register UEMUSHORT *x;
|
||||
UEMUSHORT *x;
|
||||
{
|
||||
int i;
|
||||
register UEMUSHORT newbyt, oldbyt;
|
||||
UEMUSHORT newbyt, oldbyt;
|
||||
|
||||
x += NI - 1;
|
||||
oldbyt = 0;
|
||||
|
@ -2095,10 +2095,10 @@ eshup8 (x)
|
|||
|
||||
static void
|
||||
eshup6 (x)
|
||||
register UEMUSHORT *x;
|
||||
UEMUSHORT *x;
|
||||
{
|
||||
int i;
|
||||
register UEMUSHORT *p;
|
||||
UEMUSHORT *p;
|
||||
|
||||
p = x + M;
|
||||
x += M + 1;
|
||||
|
@ -2113,10 +2113,10 @@ eshup6 (x)
|
|||
|
||||
static void
|
||||
eshdn6 (x)
|
||||
register UEMUSHORT *x;
|
||||
UEMUSHORT *x;
|
||||
{
|
||||
int i;
|
||||
register UEMUSHORT *p;
|
||||
UEMUSHORT *p;
|
||||
|
||||
x += NI - 1;
|
||||
p = x + 1;
|
||||
|
@ -2133,7 +2133,7 @@ static void
|
|||
eaddm (x, y)
|
||||
UEMUSHORT *x, *y;
|
||||
{
|
||||
register unsigned EMULONG a;
|
||||
unsigned EMULONG a;
|
||||
int i;
|
||||
unsigned int carry;
|
||||
|
||||
|
@ -2194,7 +2194,7 @@ edivm (den, num)
|
|||
UEMUSHORT den[], num[];
|
||||
{
|
||||
int i;
|
||||
register UEMUSHORT *p, *q;
|
||||
UEMUSHORT *p, *q;
|
||||
UEMUSHORT j;
|
||||
|
||||
p = &equot[0];
|
||||
|
@ -2344,8 +2344,8 @@ m16m (a, b, c)
|
|||
unsigned int a;
|
||||
UEMUSHORT b[], c[];
|
||||
{
|
||||
register UEMUSHORT *pp;
|
||||
register unsigned EMULONG carry;
|
||||
UEMUSHORT *pp;
|
||||
unsigned EMULONG carry;
|
||||
UEMUSHORT *ps;
|
||||
UEMUSHORT p[NI];
|
||||
unsigned EMULONG aa, m;
|
||||
|
@ -2388,7 +2388,7 @@ edivm (den, num)
|
|||
UEMUSHORT den[], num[];
|
||||
{
|
||||
int i;
|
||||
register UEMUSHORT *p;
|
||||
UEMUSHORT *p;
|
||||
unsigned EMULONG tnum;
|
||||
UEMUSHORT j, tdenm, tquot;
|
||||
UEMUSHORT tprod[NI+1];
|
||||
|
@ -3135,8 +3135,8 @@ e53toe (pe, y)
|
|||
c4xtoe (pe, y, HFmode);
|
||||
|
||||
#else
|
||||
register UEMUSHORT r;
|
||||
register UEMUSHORT *e, *p;
|
||||
UEMUSHORT r;
|
||||
UEMUSHORT *e, *p;
|
||||
UEMUSHORT yy[NI];
|
||||
int denorm, k;
|
||||
|
||||
|
@ -3352,7 +3352,7 @@ static void
|
|||
e113toe (pe, y)
|
||||
UEMUSHORT *pe, *y;
|
||||
{
|
||||
register UEMUSHORT r;
|
||||
UEMUSHORT r;
|
||||
UEMUSHORT *e, *p;
|
||||
UEMUSHORT yy[NI];
|
||||
int denorm, i;
|
||||
|
@ -3450,8 +3450,8 @@ e24toe (pe, y)
|
|||
|
||||
#else
|
||||
|
||||
register UEMUSHORT r;
|
||||
register UEMUSHORT *e, *p;
|
||||
UEMUSHORT r;
|
||||
UEMUSHORT *e, *p;
|
||||
UEMUSHORT yy[NI];
|
||||
int denorm, k;
|
||||
|
||||
|
@ -3576,7 +3576,7 @@ static void
|
|||
toe113 (a, b)
|
||||
UEMUSHORT *a, *b;
|
||||
{
|
||||
register UEMUSHORT *p, *q;
|
||||
UEMUSHORT *p, *q;
|
||||
UEMUSHORT i;
|
||||
|
||||
#ifdef NANS
|
||||
|
@ -3670,7 +3670,7 @@ static void
|
|||
toe64 (a, b)
|
||||
UEMUSHORT *a, *b;
|
||||
{
|
||||
register UEMUSHORT *p, *q;
|
||||
UEMUSHORT *p, *q;
|
||||
UEMUSHORT i;
|
||||
|
||||
#ifdef NANS
|
||||
|
@ -4161,8 +4161,8 @@ ecmp (a, b)
|
|||
UEMUSHORT *a, *b;
|
||||
{
|
||||
UEMUSHORT ai[NI], bi[NI];
|
||||
register UEMUSHORT *p, *q;
|
||||
register int i;
|
||||
UEMUSHORT *p, *q;
|
||||
int i;
|
||||
int msign;
|
||||
|
||||
#ifdef NANS
|
||||
|
@ -4534,7 +4534,7 @@ static int
|
|||
enormlz (x)
|
||||
UEMUSHORT x[];
|
||||
{
|
||||
register UEMUSHORT *p;
|
||||
UEMUSHORT *p;
|
||||
int sc;
|
||||
|
||||
sc = 0;
|
||||
|
@ -5561,7 +5561,7 @@ static void
|
|||
efloor (x, y)
|
||||
UEMUSHORT x[], y[];
|
||||
{
|
||||
register UEMUSHORT *p;
|
||||
UEMUSHORT *p;
|
||||
int e, expon, i;
|
||||
UEMUSHORT f[NE];
|
||||
|
||||
|
@ -5795,7 +5795,7 @@ dectoe (d, e)
|
|||
UEMUSHORT *e;
|
||||
{
|
||||
UEMUSHORT y[NI];
|
||||
register UEMUSHORT r, *p;
|
||||
UEMUSHORT r, *p;
|
||||
|
||||
ecleaz (y); /* start with a zero */
|
||||
p = y; /* point to our number */
|
||||
|
@ -5904,7 +5904,7 @@ ibmtoe (d, e, mode)
|
|||
enum machine_mode mode;
|
||||
{
|
||||
UEMUSHORT y[NI];
|
||||
register UEMUSHORT r, *p;
|
||||
UEMUSHORT r, *p;
|
||||
|
||||
ecleaz (y); /* start with a zero */
|
||||
p = y; /* point to our number */
|
||||
|
|
68
gcc/recog.c
68
gcc/recog.c
|
@ -437,9 +437,9 @@ validate_replace_rtx_1 (loc, from, to, object)
|
|||
rtx *loc;
|
||||
rtx from, to, object;
|
||||
{
|
||||
register int i, j;
|
||||
register const char *fmt;
|
||||
register rtx x = *loc;
|
||||
int i, j;
|
||||
const char *fmt;
|
||||
rtx x = *loc;
|
||||
enum rtx_code code;
|
||||
enum machine_mode op0_mode = VOIDmode;
|
||||
int prev_changes = num_changes;
|
||||
|
@ -687,7 +687,7 @@ int
|
|||
next_insn_tests_no_inequality (insn)
|
||||
rtx insn;
|
||||
{
|
||||
register rtx next = next_cc0_user (insn);
|
||||
rtx next = next_cc0_user (insn);
|
||||
|
||||
/* If there is no next insn, we have to take the conservative choice. */
|
||||
if (next == 0)
|
||||
|
@ -707,7 +707,7 @@ int
|
|||
next_insns_test_no_inequality (insn)
|
||||
rtx insn;
|
||||
{
|
||||
register rtx next = NEXT_INSN (insn);
|
||||
rtx next = NEXT_INSN (insn);
|
||||
|
||||
for (; next != 0; next = NEXT_INSN (next))
|
||||
{
|
||||
|
@ -913,10 +913,10 @@ find_single_use (dest, insn, ploc)
|
|||
|
||||
int
|
||||
general_operand (op, mode)
|
||||
register rtx op;
|
||||
rtx op;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
register enum rtx_code code = GET_CODE (op);
|
||||
enum rtx_code code = GET_CODE (op);
|
||||
|
||||
if (mode == VOIDmode)
|
||||
mode = GET_MODE (op);
|
||||
|
@ -976,7 +976,7 @@ general_operand (op, mode)
|
|||
|
||||
if (code == MEM)
|
||||
{
|
||||
register rtx y = XEXP (op, 0);
|
||||
rtx y = XEXP (op, 0);
|
||||
|
||||
if (! volatile_ok && MEM_VOLATILE_P (op))
|
||||
return 0;
|
||||
|
@ -1008,7 +1008,7 @@ general_operand (op, mode)
|
|||
|
||||
int
|
||||
address_operand (op, mode)
|
||||
register rtx op;
|
||||
rtx op;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
return memory_address_p (mode, op);
|
||||
|
@ -1030,7 +1030,7 @@ address_operand (op, mode)
|
|||
|
||||
int
|
||||
register_operand (op, mode)
|
||||
register rtx op;
|
||||
rtx op;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
if (GET_MODE (op) != mode && mode != VOIDmode)
|
||||
|
@ -1089,7 +1089,7 @@ pmode_register_operand (op, mode)
|
|||
|
||||
int
|
||||
scratch_operand (op, mode)
|
||||
register rtx op;
|
||||
rtx op;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
if (GET_MODE (op) != mode && mode != VOIDmode)
|
||||
|
@ -1107,7 +1107,7 @@ scratch_operand (op, mode)
|
|||
|
||||
int
|
||||
immediate_operand (op, mode)
|
||||
register rtx op;
|
||||
rtx op;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
/* Don't accept CONST_INT or anything similar
|
||||
|
@ -1140,7 +1140,7 @@ immediate_operand (op, mode)
|
|||
|
||||
int
|
||||
const_int_operand (op, mode)
|
||||
register rtx op;
|
||||
rtx op;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
if (GET_CODE (op) != CONST_INT)
|
||||
|
@ -1158,7 +1158,7 @@ const_int_operand (op, mode)
|
|||
|
||||
int
|
||||
const_double_operand (op, mode)
|
||||
register rtx op;
|
||||
rtx op;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
/* Don't accept CONST_INT or anything similar
|
||||
|
@ -1177,7 +1177,7 @@ const_double_operand (op, mode)
|
|||
|
||||
int
|
||||
nonimmediate_operand (op, mode)
|
||||
register rtx op;
|
||||
rtx op;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
return (general_operand (op, mode) && ! CONSTANT_P (op));
|
||||
|
@ -1187,7 +1187,7 @@ nonimmediate_operand (op, mode)
|
|||
|
||||
int
|
||||
nonmemory_operand (op, mode)
|
||||
register rtx op;
|
||||
rtx op;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
if (CONSTANT_P (op))
|
||||
|
@ -1312,7 +1312,7 @@ pop_operand (op, mode)
|
|||
int
|
||||
memory_address_p (mode, addr)
|
||||
enum machine_mode mode ATTRIBUTE_UNUSED;
|
||||
register rtx addr;
|
||||
rtx addr;
|
||||
{
|
||||
if (GET_CODE (addr) == ADDRESSOF)
|
||||
return 1;
|
||||
|
@ -1332,7 +1332,7 @@ memory_address_p (mode, addr)
|
|||
|
||||
int
|
||||
memory_operand (op, mode)
|
||||
register rtx op;
|
||||
rtx op;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
rtx inner;
|
||||
|
@ -1357,14 +1357,14 @@ memory_operand (op, mode)
|
|||
|
||||
int
|
||||
indirect_operand (op, mode)
|
||||
register rtx op;
|
||||
rtx op;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
/* Before reload, a SUBREG isn't in memory (see memory_operand, above). */
|
||||
if (! reload_completed
|
||||
&& GET_CODE (op) == SUBREG && GET_CODE (SUBREG_REG (op)) == MEM)
|
||||
{
|
||||
register int offset = SUBREG_BYTE (op);
|
||||
int offset = SUBREG_BYTE (op);
|
||||
rtx inner = SUBREG_REG (op);
|
||||
|
||||
if (mode != VOIDmode && GET_MODE (op) != mode)
|
||||
|
@ -1392,7 +1392,7 @@ indirect_operand (op, mode)
|
|||
|
||||
int
|
||||
comparison_operator (op, mode)
|
||||
register rtx op;
|
||||
rtx op;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
return ((mode == VOIDmode || GET_MODE (op) == mode)
|
||||
|
@ -1496,7 +1496,7 @@ decode_asm_operands (body, operands, operand_locs, constraints, modes)
|
|||
const char **constraints;
|
||||
enum machine_mode *modes;
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
int noperands;
|
||||
const char *template = 0;
|
||||
|
||||
|
@ -1828,8 +1828,8 @@ rtx *
|
|||
find_constant_term_loc (p)
|
||||
rtx *p;
|
||||
{
|
||||
register rtx *tem;
|
||||
register enum rtx_code code = GET_CODE (*p);
|
||||
rtx *tem;
|
||||
enum rtx_code code = GET_CODE (*p);
|
||||
|
||||
/* If *P IS such a constant term, P is its location. */
|
||||
|
||||
|
@ -1911,10 +1911,10 @@ int
|
|||
offsettable_address_p (strictp, mode, y)
|
||||
int strictp;
|
||||
enum machine_mode mode;
|
||||
register rtx y;
|
||||
rtx y;
|
||||
{
|
||||
register enum rtx_code ycode = GET_CODE (y);
|
||||
register rtx z;
|
||||
enum rtx_code ycode = GET_CODE (y);
|
||||
rtx z;
|
||||
rtx y1 = y;
|
||||
rtx *y2;
|
||||
int (*addressp) PARAMS ((enum machine_mode, rtx)) =
|
||||
|
@ -2291,7 +2291,7 @@ constrain_operands (strict)
|
|||
const char *constraints[MAX_RECOG_OPERANDS];
|
||||
int matching_operands[MAX_RECOG_OPERANDS];
|
||||
int earlyclobber[MAX_RECOG_OPERANDS];
|
||||
register int c;
|
||||
int c;
|
||||
|
||||
struct funny_match funny_match[MAX_RECOG_OPERANDS];
|
||||
int funny_match_index;
|
||||
|
@ -2308,15 +2308,15 @@ constrain_operands (strict)
|
|||
|
||||
do
|
||||
{
|
||||
register int opno;
|
||||
int opno;
|
||||
int lose = 0;
|
||||
funny_match_index = 0;
|
||||
|
||||
for (opno = 0; opno < recog_data.n_operands; opno++)
|
||||
{
|
||||
register rtx op = recog_data.operand[opno];
|
||||
rtx op = recog_data.operand[opno];
|
||||
enum machine_mode mode = GET_MODE (op);
|
||||
register const char *p = constraints[opno];
|
||||
const char *p = constraints[opno];
|
||||
int offset = 0;
|
||||
int win = 0;
|
||||
int val;
|
||||
|
@ -2631,16 +2631,16 @@ constrain_operands (strict)
|
|||
int
|
||||
reg_fits_class_p (operand, class, offset, mode)
|
||||
rtx operand;
|
||||
register enum reg_class class;
|
||||
enum reg_class class;
|
||||
int offset;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
register int regno = REGNO (operand);
|
||||
int regno = REGNO (operand);
|
||||
if (regno < FIRST_PSEUDO_REGISTER
|
||||
&& TEST_HARD_REG_BIT (reg_class_contents[(int) class],
|
||||
regno + offset))
|
||||
{
|
||||
register int sr;
|
||||
int sr;
|
||||
regno += offset;
|
||||
for (sr = HARD_REGNO_NREGS (regno, mode) - 1;
|
||||
sr > 0; sr--)
|
||||
|
|
|
@ -273,8 +273,8 @@ static int
|
|||
stack_regs_mentioned_p (pat)
|
||||
rtx pat;
|
||||
{
|
||||
register const char *fmt;
|
||||
register int i;
|
||||
const char *fmt;
|
||||
int i;
|
||||
|
||||
if (STACK_REG_P (pat))
|
||||
return 1;
|
||||
|
@ -284,7 +284,7 @@ stack_regs_mentioned_p (pat)
|
|||
{
|
||||
if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
|
||||
for (j = XVECLEN (pat, i) - 1; j >= 0; j--)
|
||||
if (stack_regs_mentioned_p (XVECEXP (pat, i, j)))
|
||||
|
@ -508,14 +508,14 @@ static void
|
|||
record_label_references (insn, pat)
|
||||
rtx insn, pat;
|
||||
{
|
||||
register enum rtx_code code = GET_CODE (pat);
|
||||
register int i;
|
||||
register const char *fmt;
|
||||
enum rtx_code code = GET_CODE (pat);
|
||||
int i;
|
||||
const char *fmt;
|
||||
|
||||
if (code == LABEL_REF)
|
||||
{
|
||||
register rtx label = XEXP (pat, 0);
|
||||
register rtx ref;
|
||||
rtx label = XEXP (pat, 0);
|
||||
rtx ref;
|
||||
|
||||
if (GET_CODE (label) != CODE_LABEL)
|
||||
abort ();
|
||||
|
@ -547,7 +547,7 @@ record_label_references (insn, pat)
|
|||
record_label_references (insn, XEXP (pat, i));
|
||||
if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = 0; j < XVECLEN (pat, i); j++)
|
||||
record_label_references (insn, XVECEXP (pat, i, j));
|
||||
}
|
||||
|
@ -867,7 +867,7 @@ remove_regno_note (insn, note, regno)
|
|||
enum reg_note note;
|
||||
unsigned int regno;
|
||||
{
|
||||
register rtx *note_link, this;
|
||||
rtx *note_link, this;
|
||||
|
||||
note_link = ®_NOTES(insn);
|
||||
for (this = *note_link; this; this = XEXP (this, 1))
|
||||
|
@ -1206,8 +1206,8 @@ static int
|
|||
swap_rtx_condition_1 (pat)
|
||||
rtx pat;
|
||||
{
|
||||
register const char *fmt;
|
||||
register int i, r = 0;
|
||||
const char *fmt;
|
||||
int i, r = 0;
|
||||
|
||||
if (GET_RTX_CLASS (GET_CODE (pat)) == '<')
|
||||
{
|
||||
|
@ -1221,7 +1221,7 @@ swap_rtx_condition_1 (pat)
|
|||
{
|
||||
if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
|
||||
for (j = XVECLEN (pat, i) - 1; j >= 0; j--)
|
||||
r |= swap_rtx_condition_1 (XVECEXP (pat, i, j));
|
||||
|
@ -2155,8 +2155,8 @@ subst_stack_regs (insn, regstack)
|
|||
rtx insn;
|
||||
stack regstack;
|
||||
{
|
||||
register rtx *note_link, note;
|
||||
register int i;
|
||||
rtx *note_link, note;
|
||||
int i;
|
||||
|
||||
if (GET_CODE (insn) == CALL_INSN)
|
||||
{
|
||||
|
|
|
@ -276,7 +276,7 @@ static int no_global_reg_vars = 0;
|
|||
void
|
||||
init_reg_sets ()
|
||||
{
|
||||
register int i, j;
|
||||
int i, j;
|
||||
|
||||
/* First copy the register information from the initial int form into
|
||||
the regsets. */
|
||||
|
@ -311,8 +311,8 @@ init_reg_sets ()
|
|||
static void
|
||||
init_reg_sets_1 ()
|
||||
{
|
||||
register unsigned int i, j;
|
||||
register unsigned int /* enum machine_mode */ m;
|
||||
unsigned int i, j;
|
||||
unsigned int /* enum machine_mode */ m;
|
||||
char allocatable_regs_of_mode [MAX_MACHINE_MODE];
|
||||
|
||||
/* This macro allows the fixed or call-used registers
|
||||
|
@ -342,7 +342,7 @@ init_reg_sets_1 ()
|
|||
register /* Declare it register if it's a scalar. */
|
||||
#endif
|
||||
HARD_REG_SET c;
|
||||
register int k;
|
||||
int k;
|
||||
|
||||
COPY_HARD_REG_SET (c, reg_class_contents[i]);
|
||||
IOR_HARD_REG_SET (c, reg_class_contents[j]);
|
||||
|
@ -376,7 +376,7 @@ init_reg_sets_1 ()
|
|||
register /* Declare it register if it's a scalar. */
|
||||
#endif
|
||||
HARD_REG_SET c;
|
||||
register int k;
|
||||
int k;
|
||||
|
||||
COPY_HARD_REG_SET (c, reg_class_contents[i]);
|
||||
IOR_HARD_REG_SET (c, reg_class_contents[j]);
|
||||
|
@ -578,7 +578,7 @@ init_reg_sets_1 ()
|
|||
static void
|
||||
init_reg_modes ()
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
|
||||
{
|
||||
|
@ -1163,8 +1163,8 @@ regclass (f, nregs, dump)
|
|||
int nregs;
|
||||
FILE *dump;
|
||||
{
|
||||
register rtx insn;
|
||||
register int i;
|
||||
rtx insn;
|
||||
int i;
|
||||
int pass;
|
||||
|
||||
init_recog ();
|
||||
|
@ -1188,7 +1188,7 @@ regclass (f, nregs, dump)
|
|||
{
|
||||
rtx r = gen_rtx_REG (VOIDmode, 0);
|
||||
enum machine_mode m;
|
||||
register int j;
|
||||
int j;
|
||||
|
||||
for (j = 0; j < FIRST_PSEUDO_REGISTER; j++)
|
||||
if (TEST_HARD_REG_BIT (reg_class_contents[i], j))
|
||||
|
@ -1289,12 +1289,12 @@ regclass (f, nregs, dump)
|
|||
}
|
||||
for (i = FIRST_PSEUDO_REGISTER; i < nregs; i++)
|
||||
{
|
||||
register int best_cost = (1 << (HOST_BITS_PER_INT - 2)) - 1;
|
||||
int best_cost = (1 << (HOST_BITS_PER_INT - 2)) - 1;
|
||||
enum reg_class best = ALL_REGS, alt = NO_REGS;
|
||||
/* This is an enum reg_class, but we call it an int
|
||||
to save lots of casts. */
|
||||
register int class;
|
||||
register struct costs *p = &costs[i];
|
||||
int class;
|
||||
struct costs *p = &costs[i];
|
||||
|
||||
/* In non-optimizing compilation REG_N_REFS is not initialized
|
||||
yet. */
|
||||
|
@ -1948,7 +1948,7 @@ record_address_regs (x, class, scale)
|
|||
enum reg_class class;
|
||||
int scale;
|
||||
{
|
||||
register enum rtx_code code = GET_CODE (x);
|
||||
enum rtx_code code = GET_CODE (x);
|
||||
|
||||
switch (code)
|
||||
{
|
||||
|
@ -1976,8 +1976,8 @@ record_address_regs (x, class, scale)
|
|||
{
|
||||
rtx arg0 = XEXP (x, 0);
|
||||
rtx arg1 = XEXP (x, 1);
|
||||
register enum rtx_code code0 = GET_CODE (arg0);
|
||||
register enum rtx_code code1 = GET_CODE (arg1);
|
||||
enum rtx_code code0 = GET_CODE (arg0);
|
||||
enum rtx_code code1 = GET_CODE (arg1);
|
||||
|
||||
/* Look inside subregs. */
|
||||
if (code0 == SUBREG)
|
||||
|
@ -2097,8 +2097,8 @@ record_address_regs (x, class, scale)
|
|||
|
||||
case REG:
|
||||
{
|
||||
register struct costs *pp = &costs[REGNO (x)];
|
||||
register int i;
|
||||
struct costs *pp = &costs[REGNO (x)];
|
||||
int i;
|
||||
|
||||
pp->mem_cost += (MEMORY_MOVE_COST (Pmode, class, 1) * scale) / 2;
|
||||
|
||||
|
@ -2109,8 +2109,8 @@ record_address_regs (x, class, scale)
|
|||
|
||||
default:
|
||||
{
|
||||
register const char *fmt = GET_RTX_FORMAT (code);
|
||||
register int i;
|
||||
const char *fmt = GET_RTX_FORMAT (code);
|
||||
int i;
|
||||
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
||||
if (fmt[i] == 'e')
|
||||
record_address_regs (XEXP (x, i), class, scale);
|
||||
|
@ -2318,7 +2318,7 @@ reg_scan (f, nregs, repeat)
|
|||
unsigned int nregs;
|
||||
int repeat ATTRIBUTE_UNUSED;
|
||||
{
|
||||
register rtx insn;
|
||||
rtx insn;
|
||||
|
||||
allocate_reg_info (nregs, TRUE, FALSE);
|
||||
max_parallel = 3;
|
||||
|
@ -2352,7 +2352,7 @@ reg_scan_update (first, last, old_max_regno)
|
|||
rtx last;
|
||||
unsigned int old_max_regno;
|
||||
{
|
||||
register rtx insn;
|
||||
rtx insn;
|
||||
|
||||
allocate_reg_info (max_reg_num (), FALSE, FALSE);
|
||||
|
||||
|
@ -2383,9 +2383,9 @@ reg_scan_mark_refs (x, insn, note_flag, min_regno)
|
|||
int note_flag;
|
||||
unsigned int min_regno;
|
||||
{
|
||||
register enum rtx_code code;
|
||||
register rtx dest;
|
||||
register rtx note;
|
||||
enum rtx_code code;
|
||||
rtx dest;
|
||||
rtx note;
|
||||
|
||||
code = GET_CODE (x);
|
||||
switch (code)
|
||||
|
@ -2500,15 +2500,15 @@ reg_scan_mark_refs (x, insn, note_flag, min_regno)
|
|||
|
||||
default:
|
||||
{
|
||||
register const char *fmt = GET_RTX_FORMAT (code);
|
||||
register int i;
|
||||
const char *fmt = GET_RTX_FORMAT (code);
|
||||
int i;
|
||||
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
||||
{
|
||||
if (fmt[i] == 'e')
|
||||
reg_scan_mark_refs (XEXP (x, i), insn, note_flag, min_regno);
|
||||
else if (fmt[i] == 'E' && XVEC (x, i) != 0)
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
||||
reg_scan_mark_refs (XVECEXP (x, i, j), insn, note_flag, min_regno);
|
||||
}
|
||||
|
@ -2522,8 +2522,8 @@ reg_scan_mark_refs (x, insn, note_flag, min_regno)
|
|||
|
||||
int
|
||||
reg_class_subset_p (c1, c2)
|
||||
register enum reg_class c1;
|
||||
register enum reg_class c2;
|
||||
enum reg_class c1;
|
||||
enum reg_class c2;
|
||||
{
|
||||
if (c1 == c2) return 1;
|
||||
|
||||
|
@ -2540,8 +2540,8 @@ reg_class_subset_p (c1, c2)
|
|||
|
||||
int
|
||||
reg_classes_intersect_p (c1, c2)
|
||||
register enum reg_class c1;
|
||||
register enum reg_class c2;
|
||||
enum reg_class c1;
|
||||
enum reg_class c2;
|
||||
{
|
||||
#ifdef HARD_REG_SET
|
||||
register
|
||||
|
|
|
@ -863,7 +863,7 @@ reg_is_remote_constant_p (reg, insn, first)
|
|||
rtx insn;
|
||||
rtx first;
|
||||
{
|
||||
register rtx p;
|
||||
rtx p;
|
||||
|
||||
if (REG_N_SETS (REGNO (reg)) != 1)
|
||||
return 0;
|
||||
|
|
150
gcc/reload.c
150
gcc/reload.c
|
@ -857,7 +857,7 @@ push_reload (in, out, inloc, outloc, class,
|
|||
int opnum;
|
||||
enum reload_type type;
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
int dont_share = 0;
|
||||
int dont_remove_subreg = 0;
|
||||
rtx *in_subreg_loc = 0, *out_subreg_loc = 0;
|
||||
|
@ -879,7 +879,7 @@ push_reload (in, out, inloc, outloc, class,
|
|||
Often this is done earlier, but not always in find_reloads_address. */
|
||||
if (in != 0 && GET_CODE (in) == REG)
|
||||
{
|
||||
register int regno = REGNO (in);
|
||||
int regno = REGNO (in);
|
||||
|
||||
if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
|
||||
&& reg_equiv_constant[regno] != 0)
|
||||
|
@ -891,7 +891,7 @@ push_reload (in, out, inloc, outloc, class,
|
|||
(in the case of a parameter). */
|
||||
if (out != 0 && GET_CODE (out) == REG)
|
||||
{
|
||||
register int regno = REGNO (out);
|
||||
int regno = REGNO (out);
|
||||
|
||||
if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
|
||||
&& reg_equiv_constant[regno] != 0)
|
||||
|
@ -1402,7 +1402,7 @@ push_reload (in, out, inloc, outloc, class,
|
|||
{
|
||||
if (inloc != 0)
|
||||
{
|
||||
register struct replacement *r = &replacements[n_replacements++];
|
||||
struct replacement *r = &replacements[n_replacements++];
|
||||
r->what = i;
|
||||
r->subreg_loc = in_subreg_loc;
|
||||
r->where = inloc;
|
||||
|
@ -1410,7 +1410,7 @@ push_reload (in, out, inloc, outloc, class,
|
|||
}
|
||||
if (outloc != 0 && outloc != inloc)
|
||||
{
|
||||
register struct replacement *r = &replacements[n_replacements++];
|
||||
struct replacement *r = &replacements[n_replacements++];
|
||||
r->what = i;
|
||||
r->where = outloc;
|
||||
r->subreg_loc = out_subreg_loc;
|
||||
|
@ -1537,7 +1537,7 @@ push_replacement (loc, reloadnum, mode)
|
|||
{
|
||||
if (replace_reloads)
|
||||
{
|
||||
register struct replacement *r = &replacements[n_replacements++];
|
||||
struct replacement *r = &replacements[n_replacements++];
|
||||
r->what = reloadnum;
|
||||
r->where = loc;
|
||||
r->subreg_loc = 0;
|
||||
|
@ -1978,7 +1978,7 @@ hard_reg_set_here_p (beg_regno, end_regno, x)
|
|||
{
|
||||
if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
|
||||
{
|
||||
register rtx op0 = SET_DEST (x);
|
||||
rtx op0 = SET_DEST (x);
|
||||
|
||||
while (GET_CODE (op0) == SUBREG)
|
||||
op0 = SUBREG_REG (op0);
|
||||
|
@ -1994,7 +1994,7 @@ hard_reg_set_here_p (beg_regno, end_regno, x)
|
|||
}
|
||||
else if (GET_CODE (x) == PARALLEL)
|
||||
{
|
||||
register int i = XVECLEN (x, 0) - 1;
|
||||
int i = XVECLEN (x, 0) - 1;
|
||||
|
||||
for (; i >= 0; i--)
|
||||
if (hard_reg_set_here_p (beg_regno, end_regno, XVECEXP (x, 0, i)))
|
||||
|
@ -2011,7 +2011,7 @@ hard_reg_set_here_p (beg_regno, end_regno, x)
|
|||
int
|
||||
strict_memory_address_p (mode, addr)
|
||||
enum machine_mode mode ATTRIBUTE_UNUSED;
|
||||
register rtx addr;
|
||||
rtx addr;
|
||||
{
|
||||
GO_IF_LEGITIMATE_ADDRESS (mode, addr, win);
|
||||
return 0;
|
||||
|
@ -2037,11 +2037,11 @@ strict_memory_address_p (mode, addr)
|
|||
|
||||
int
|
||||
operands_match_p (x, y)
|
||||
register rtx x, y;
|
||||
rtx x, y;
|
||||
{
|
||||
register int i;
|
||||
register RTX_CODE code = GET_CODE (x);
|
||||
register const char *fmt;
|
||||
int i;
|
||||
RTX_CODE code = GET_CODE (x);
|
||||
const char *fmt;
|
||||
int success_2;
|
||||
|
||||
if (x == y)
|
||||
|
@ -2050,7 +2050,7 @@ operands_match_p (x, y)
|
|||
&& (GET_CODE (y) == REG || (GET_CODE (y) == SUBREG
|
||||
&& GET_CODE (SUBREG_REG (y)) == REG)))
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
|
||||
if (code == SUBREG)
|
||||
{
|
||||
|
@ -2410,8 +2410,8 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
|
|||
int live_known;
|
||||
short *reload_reg_p;
|
||||
{
|
||||
register int insn_code_number;
|
||||
register int i, j;
|
||||
int insn_code_number;
|
||||
int i, j;
|
||||
int noperands;
|
||||
/* These start out as the constraints for the insn
|
||||
and they are chewed up as we consider alternatives. */
|
||||
|
@ -2524,8 +2524,8 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
|
|||
|
||||
for (i = 0; i < noperands; i++)
|
||||
{
|
||||
register char *p;
|
||||
register int c;
|
||||
char *p;
|
||||
int c;
|
||||
|
||||
substed_operand[i] = recog_data.operand[i];
|
||||
p = constraints[i];
|
||||
|
@ -2596,7 +2596,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
|
|||
|
||||
for (i = 0; i < noperands; i++)
|
||||
{
|
||||
register RTX_CODE code = GET_CODE (recog_data.operand[i]);
|
||||
RTX_CODE code = GET_CODE (recog_data.operand[i]);
|
||||
|
||||
address_reloaded[i] = 0;
|
||||
operand_type[i] = (modified[i] == RELOAD_READ ? RELOAD_FOR_INPUT
|
||||
|
@ -2687,7 +2687,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
|
|||
we replace it by the constant. We must be sure, however,
|
||||
that we don't try to replace it in the insn in which it
|
||||
is being set. */
|
||||
register int regno = REGNO (recog_data.operand[i]);
|
||||
int regno = REGNO (recog_data.operand[i]);
|
||||
if (reg_equiv_constant[regno] != 0
|
||||
&& (set == 0 || &SET_DEST (set) != recog_data.operand_loc[i]))
|
||||
{
|
||||
|
@ -2774,15 +2774,15 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
|
|||
|
||||
for (i = 0; i < noperands; i++)
|
||||
{
|
||||
register char *p = constraints[i];
|
||||
register int win = 0;
|
||||
char *p = constraints[i];
|
||||
int win = 0;
|
||||
int did_match = 0;
|
||||
/* 0 => this operand can be reloaded somehow for this alternative. */
|
||||
int badop = 1;
|
||||
/* 0 => this operand can be reloaded if the alternative allows regs. */
|
||||
int winreg = 0;
|
||||
int c;
|
||||
register rtx operand = recog_data.operand[i];
|
||||
rtx operand = recog_data.operand[i];
|
||||
int offset = 0;
|
||||
/* Nonzero means this is a MEM that must be reloaded into a reg
|
||||
regardless of what the constraint says. */
|
||||
|
@ -3494,8 +3494,8 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
|
|||
swapped = !swapped;
|
||||
if (swapped)
|
||||
{
|
||||
register enum reg_class tclass;
|
||||
register int t;
|
||||
enum reg_class tclass;
|
||||
int t;
|
||||
|
||||
recog_data.operand[commutative] = substed_operand[commutative + 1];
|
||||
recog_data.operand[commutative + 1] = substed_operand[commutative];
|
||||
|
@ -3564,7 +3564,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
|
|||
|
||||
if (goal_alternative_swapped)
|
||||
{
|
||||
register rtx tem;
|
||||
rtx tem;
|
||||
|
||||
tem = substed_operand[commutative];
|
||||
substed_operand[commutative] = substed_operand[commutative + 1];
|
||||
|
@ -4229,7 +4229,7 @@ alternative_allows_memconst (constraint, altnum)
|
|||
const char *constraint;
|
||||
int altnum;
|
||||
{
|
||||
register int c;
|
||||
int c;
|
||||
/* Skip alternatives before the one requested. */
|
||||
while (altnum > 0)
|
||||
{
|
||||
|
@ -4277,16 +4277,16 @@ find_reloads_toplev (x, opnum, type, ind_levels, is_set_dest, insn,
|
|||
rtx insn;
|
||||
int *address_reloaded;
|
||||
{
|
||||
register RTX_CODE code = GET_CODE (x);
|
||||
RTX_CODE code = GET_CODE (x);
|
||||
|
||||
register const char *fmt = GET_RTX_FORMAT (code);
|
||||
register int i;
|
||||
const char *fmt = GET_RTX_FORMAT (code);
|
||||
int i;
|
||||
int copied;
|
||||
|
||||
if (code == REG)
|
||||
{
|
||||
/* This code is duplicated for speed in find_reloads. */
|
||||
register int regno = REGNO (x);
|
||||
int regno = REGNO (x);
|
||||
if (reg_equiv_constant[regno] != 0 && !is_set_dest)
|
||||
x = reg_equiv_constant[regno];
|
||||
#if 0
|
||||
|
@ -4343,7 +4343,7 @@ find_reloads_toplev (x, opnum, type, ind_levels, is_set_dest, insn,
|
|||
the register (this should never happen because one of the cases
|
||||
above should handle it). */
|
||||
|
||||
register int regno = REGNO (SUBREG_REG (x));
|
||||
int regno = REGNO (SUBREG_REG (x));
|
||||
rtx tem;
|
||||
|
||||
if (subreg_lowpart_p (x)
|
||||
|
@ -4514,7 +4514,7 @@ find_reloads_address (mode, memrefloc, ad, loc, opnum, type, ind_levels, insn)
|
|||
int ind_levels;
|
||||
rtx insn;
|
||||
{
|
||||
register int regno;
|
||||
int regno;
|
||||
int removed_and = 0;
|
||||
rtx tem;
|
||||
|
||||
|
@ -4874,9 +4874,9 @@ subst_reg_equivs (ad, insn)
|
|||
rtx ad;
|
||||
rtx insn;
|
||||
{
|
||||
register RTX_CODE code = GET_CODE (ad);
|
||||
register int i;
|
||||
register const char *fmt;
|
||||
RTX_CODE code = GET_CODE (ad);
|
||||
int i;
|
||||
const char *fmt;
|
||||
|
||||
switch (code)
|
||||
{
|
||||
|
@ -4892,7 +4892,7 @@ subst_reg_equivs (ad, insn)
|
|||
|
||||
case REG:
|
||||
{
|
||||
register int regno = REGNO (ad);
|
||||
int regno = REGNO (ad);
|
||||
|
||||
if (reg_equiv_constant[regno] != 0)
|
||||
{
|
||||
|
@ -5105,18 +5105,18 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
|
|||
int ind_levels;
|
||||
rtx insn;
|
||||
{
|
||||
register RTX_CODE code = GET_CODE (x);
|
||||
RTX_CODE code = GET_CODE (x);
|
||||
|
||||
switch (code)
|
||||
{
|
||||
case PLUS:
|
||||
{
|
||||
register rtx orig_op0 = XEXP (x, 0);
|
||||
register rtx orig_op1 = XEXP (x, 1);
|
||||
register RTX_CODE code0 = GET_CODE (orig_op0);
|
||||
register RTX_CODE code1 = GET_CODE (orig_op1);
|
||||
register rtx op0 = orig_op0;
|
||||
register rtx op1 = orig_op1;
|
||||
rtx orig_op0 = XEXP (x, 0);
|
||||
rtx orig_op1 = XEXP (x, 1);
|
||||
RTX_CODE code0 = GET_CODE (orig_op0);
|
||||
RTX_CODE code1 = GET_CODE (orig_op1);
|
||||
rtx op0 = orig_op0;
|
||||
rtx op1 = orig_op1;
|
||||
|
||||
if (GET_CODE (op0) == SUBREG)
|
||||
{
|
||||
|
@ -5316,7 +5316,7 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
|
|||
case PRE_DEC:
|
||||
if (GET_CODE (XEXP (x, 0)) == REG)
|
||||
{
|
||||
register int regno = REGNO (XEXP (x, 0));
|
||||
int regno = REGNO (XEXP (x, 0));
|
||||
int value = 0;
|
||||
rtx x_orig = x;
|
||||
|
||||
|
@ -5429,7 +5429,7 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
|
|||
reload it into a register. */
|
||||
/* Variable `tem' might or might not be used in FIND_REG_INC_NOTE. */
|
||||
rtx tem ATTRIBUTE_UNUSED = XEXP (x, 0);
|
||||
register rtx link;
|
||||
rtx link;
|
||||
int reloadnum;
|
||||
|
||||
/* Since we know we are going to reload this item, don't decrement
|
||||
|
@ -5481,7 +5481,7 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
|
|||
|
||||
case REG:
|
||||
{
|
||||
register int regno = REGNO (x);
|
||||
int regno = REGNO (x);
|
||||
|
||||
if (reg_equiv_constant[regno] != 0)
|
||||
{
|
||||
|
@ -5586,8 +5586,8 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
|
|||
}
|
||||
|
||||
{
|
||||
register const char *fmt = GET_RTX_FORMAT (code);
|
||||
register int i;
|
||||
const char *fmt = GET_RTX_FORMAT (code);
|
||||
int i;
|
||||
|
||||
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
||||
{
|
||||
|
@ -5765,12 +5765,12 @@ void
|
|||
subst_reloads (insn)
|
||||
rtx insn;
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n_replacements; i++)
|
||||
{
|
||||
register struct replacement *r = &replacements[i];
|
||||
register rtx reloadreg = rld[r->what].reg_rtx;
|
||||
struct replacement *r = &replacements[i];
|
||||
rtx reloadreg = rld[r->what].reg_rtx;
|
||||
if (reloadreg)
|
||||
{
|
||||
#ifdef ENABLE_CHECKING
|
||||
|
@ -6090,7 +6090,7 @@ refers_to_regno_for_reload_p (regno, endregno, x, loc)
|
|||
}
|
||||
else if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
||||
if (loc != &XVECEXP (x, i, j)
|
||||
&& refers_to_regno_for_reload_p (regno, endregno,
|
||||
|
@ -6218,18 +6218,18 @@ refers_to_mem_for_reload_p (x)
|
|||
|
||||
rtx
|
||||
find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
|
||||
register rtx goal;
|
||||
rtx goal;
|
||||
rtx insn;
|
||||
enum reg_class class;
|
||||
register int other;
|
||||
int other;
|
||||
short *reload_reg_p;
|
||||
int goalreg;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
register rtx p = insn;
|
||||
rtx p = insn;
|
||||
rtx goaltry, valtry, value, where;
|
||||
register rtx pat;
|
||||
register int regno = -1;
|
||||
rtx pat;
|
||||
int regno = -1;
|
||||
int valueno;
|
||||
int goal_mem = 0;
|
||||
int goal_const = 0;
|
||||
|
@ -6515,7 +6515,7 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
|
|||
pat = COND_EXEC_CODE (pat);
|
||||
if (GET_CODE (pat) == SET || GET_CODE (pat) == CLOBBER)
|
||||
{
|
||||
register rtx dest = SET_DEST (pat);
|
||||
rtx dest = SET_DEST (pat);
|
||||
while (GET_CODE (dest) == SUBREG
|
||||
|| GET_CODE (dest) == ZERO_EXTRACT
|
||||
|| GET_CODE (dest) == SIGN_EXTRACT
|
||||
|
@ -6523,7 +6523,7 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
|
|||
dest = XEXP (dest, 0);
|
||||
if (GET_CODE (dest) == REG)
|
||||
{
|
||||
register int xregno = REGNO (dest);
|
||||
int xregno = REGNO (dest);
|
||||
int xnregs;
|
||||
if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
|
||||
xnregs = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
|
||||
|
@ -6551,15 +6551,15 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
|
|||
}
|
||||
else if (GET_CODE (pat) == PARALLEL)
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)
|
||||
{
|
||||
register rtx v1 = XVECEXP (pat, 0, i);
|
||||
rtx v1 = XVECEXP (pat, 0, i);
|
||||
if (GET_CODE (v1) == COND_EXEC)
|
||||
v1 = COND_EXEC_CODE (v1);
|
||||
if (GET_CODE (v1) == SET || GET_CODE (v1) == CLOBBER)
|
||||
{
|
||||
register rtx dest = SET_DEST (v1);
|
||||
rtx dest = SET_DEST (v1);
|
||||
while (GET_CODE (dest) == SUBREG
|
||||
|| GET_CODE (dest) == ZERO_EXTRACT
|
||||
|| GET_CODE (dest) == SIGN_EXTRACT
|
||||
|
@ -6567,7 +6567,7 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
|
|||
dest = XEXP (dest, 0);
|
||||
if (GET_CODE (dest) == REG)
|
||||
{
|
||||
register int xregno = REGNO (dest);
|
||||
int xregno = REGNO (dest);
|
||||
int xnregs;
|
||||
if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
|
||||
xnregs = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
|
||||
|
@ -6609,11 +6609,11 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
|
|||
pat = XEXP (link, 0);
|
||||
if (GET_CODE (pat) == CLOBBER)
|
||||
{
|
||||
register rtx dest = SET_DEST (pat);
|
||||
rtx dest = SET_DEST (pat);
|
||||
|
||||
if (GET_CODE (dest) == REG)
|
||||
{
|
||||
register int xregno = REGNO (dest);
|
||||
int xregno = REGNO (dest);
|
||||
int xnregs
|
||||
= HARD_REGNO_NREGS (xregno, GET_MODE (dest));
|
||||
|
||||
|
@ -6645,13 +6645,13 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
|
|||
If GOAL is a memory ref and its address is not constant,
|
||||
and this insn P increments a register used in GOAL, return 0. */
|
||||
{
|
||||
register rtx link;
|
||||
rtx link;
|
||||
|
||||
for (link = REG_NOTES (p); link; link = XEXP (link, 1))
|
||||
if (REG_NOTE_KIND (link) == REG_INC
|
||||
&& GET_CODE (XEXP (link, 0)) == REG)
|
||||
{
|
||||
register int incno = REGNO (XEXP (link, 0));
|
||||
int incno = REGNO (XEXP (link, 0));
|
||||
if (incno < regno + nregs && incno >= regno)
|
||||
return 0;
|
||||
if (incno < valueno + valuenregs && incno >= valueno)
|
||||
|
@ -6675,13 +6675,13 @@ static int
|
|||
find_inc_amount (x, inced)
|
||||
rtx x, inced;
|
||||
{
|
||||
register enum rtx_code code = GET_CODE (x);
|
||||
register const char *fmt;
|
||||
register int i;
|
||||
enum rtx_code code = GET_CODE (x);
|
||||
const char *fmt;
|
||||
int i;
|
||||
|
||||
if (code == MEM)
|
||||
{
|
||||
register rtx addr = XEXP (x, 0);
|
||||
rtx addr = XEXP (x, 0);
|
||||
if ((GET_CODE (addr) == PRE_DEC
|
||||
|| GET_CODE (addr) == POST_DEC
|
||||
|| GET_CODE (addr) == PRE_INC
|
||||
|
@ -6705,16 +6705,16 @@ find_inc_amount (x, inced)
|
|||
{
|
||||
if (fmt[i] == 'e')
|
||||
{
|
||||
register int tem = find_inc_amount (XEXP (x, i), inced);
|
||||
int tem = find_inc_amount (XEXP (x, i), inced);
|
||||
if (tem != 0)
|
||||
return tem;
|
||||
}
|
||||
if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
||||
{
|
||||
register int tem = find_inc_amount (XVECEXP (x, i, j), inced);
|
||||
int tem = find_inc_amount (XVECEXP (x, i, j), inced);
|
||||
if (tem != 0)
|
||||
return tem;
|
||||
}
|
||||
|
|
|
@ -467,13 +467,13 @@ extern void dump_needs PARAMS ((struct insn_chain *));
|
|||
void
|
||||
init_reload ()
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
/* Often (MEM (REG n)) is still valid even if (REG n) is put on the stack.
|
||||
Set spill_indirect_levels to the number of levels such addressing is
|
||||
permitted, zero if it is not permitted at all. */
|
||||
|
||||
register rtx tem
|
||||
rtx tem
|
||||
= gen_rtx_MEM (Pmode,
|
||||
gen_rtx_PLUS (Pmode,
|
||||
gen_rtx_REG (Pmode,
|
||||
|
@ -672,9 +672,9 @@ reload (first, global)
|
|||
rtx first;
|
||||
int global;
|
||||
{
|
||||
register int i;
|
||||
register rtx insn;
|
||||
register struct elim_table *ep;
|
||||
int i;
|
||||
rtx insn;
|
||||
struct elim_table *ep;
|
||||
|
||||
/* The two pointers used to track the true location of the memory used
|
||||
for label offsets. */
|
||||
|
@ -1519,8 +1519,8 @@ reload_reg_class_lower (r1p, r2p)
|
|||
const PTR r1p;
|
||||
const PTR r2p;
|
||||
{
|
||||
register int r1 = *(const short *) r1p, r2 = *(const short *) r2p;
|
||||
register int t;
|
||||
int r1 = *(const short *) r1p, r2 = *(const short *) r2p;
|
||||
int t;
|
||||
|
||||
/* Consider required reloads before optional ones. */
|
||||
t = rld[r1].optional - rld[r2].optional;
|
||||
|
@ -1921,7 +1921,7 @@ delete_dead_insn (insn)
|
|||
|
||||
static void
|
||||
alter_reg (i, from_reg)
|
||||
register int i;
|
||||
int i;
|
||||
int from_reg;
|
||||
{
|
||||
/* When outputting an inline function, this can happen
|
||||
|
@ -1947,7 +1947,7 @@ alter_reg (i, from_reg)
|
|||
&& reg_equiv_constant[i] == 0
|
||||
&& reg_equiv_memory_loc[i] == 0)
|
||||
{
|
||||
register rtx x;
|
||||
rtx x;
|
||||
unsigned int inherent_size = PSEUDO_REGNO_BYTES (i);
|
||||
unsigned int total_size = MAX (inherent_size, reg_max_ref_width[i]);
|
||||
int adjust = 0;
|
||||
|
@ -2053,7 +2053,7 @@ void
|
|||
mark_home_live (regno)
|
||||
int regno;
|
||||
{
|
||||
register int i, lim;
|
||||
int i, lim;
|
||||
|
||||
i = reg_renumber[regno];
|
||||
if (i < 0)
|
||||
|
@ -3262,7 +3262,7 @@ mark_not_eliminable (dest, x, data)
|
|||
rtx x;
|
||||
void *data ATTRIBUTE_UNUSED;
|
||||
{
|
||||
register unsigned int i;
|
||||
unsigned int i;
|
||||
|
||||
/* A SUBREG of a hard register here is just changing its mode. We should
|
||||
not see a SUBREG of an eliminable hard register, but check just in
|
||||
|
@ -3404,7 +3404,7 @@ update_eliminables (pset)
|
|||
for (ep = reg_eliminate; ep < ®_eliminate[NUM_ELIMINABLE_REGS]; ep++)
|
||||
{
|
||||
struct elim_table *op;
|
||||
register int new_to = -1;
|
||||
int new_to = -1;
|
||||
|
||||
if (! ep->can_eliminate && ep->can_eliminate_previous)
|
||||
{
|
||||
|
@ -3530,7 +3530,7 @@ spill_hard_reg (regno, cant_eliminate)
|
|||
unsigned int regno;
|
||||
int cant_eliminate;
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
if (cant_eliminate)
|
||||
{
|
||||
|
@ -3718,11 +3718,11 @@ finish_spills (global)
|
|||
|
||||
static void
|
||||
scan_paradoxical_subregs (x)
|
||||
register rtx x;
|
||||
rtx x;
|
||||
{
|
||||
register int i;
|
||||
register const char *fmt;
|
||||
register enum rtx_code code = GET_CODE (x);
|
||||
int i;
|
||||
const char *fmt;
|
||||
enum rtx_code code = GET_CODE (x);
|
||||
|
||||
switch (code)
|
||||
{
|
||||
|
@ -3763,7 +3763,7 @@ scan_paradoxical_subregs (x)
|
|||
scan_paradoxical_subregs (XEXP (x, i));
|
||||
else if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
||||
scan_paradoxical_subregs (XVECEXP (x, i, j));
|
||||
}
|
||||
|
@ -3785,7 +3785,7 @@ reload_as_needed (live_known)
|
|||
{
|
||||
struct insn_chain *chain;
|
||||
#if defined (AUTO_INC_DEC)
|
||||
register int i;
|
||||
int i;
|
||||
#endif
|
||||
rtx x;
|
||||
|
||||
|
@ -5276,7 +5276,7 @@ choose_reload_regs (chain)
|
|||
struct insn_chain *chain;
|
||||
{
|
||||
rtx insn = chain->insn;
|
||||
register int i, j;
|
||||
int i, j;
|
||||
unsigned int max_group_size = 1;
|
||||
enum reg_class group_class = NO_REGS;
|
||||
int pass, win, inheritance;
|
||||
|
@ -5340,7 +5340,7 @@ choose_reload_regs (chain)
|
|||
|
||||
for (j = 0; j < n_reloads; j++)
|
||||
{
|
||||
register int r = reload_order[j];
|
||||
int r = reload_order[j];
|
||||
rtx search_equiv = NULL_RTX;
|
||||
|
||||
/* Ignore reloads that got marked inoperative. */
|
||||
|
@ -5393,7 +5393,7 @@ choose_reload_regs (chain)
|
|||
if (inheritance)
|
||||
{
|
||||
int byte = 0;
|
||||
register int regno = -1;
|
||||
int regno = -1;
|
||||
enum machine_mode mode = VOIDmode;
|
||||
|
||||
if (rld[r].in == 0)
|
||||
|
@ -5612,7 +5612,7 @@ choose_reload_regs (chain)
|
|||
|
||||
if (search_equiv)
|
||||
{
|
||||
register rtx equiv
|
||||
rtx equiv
|
||||
= find_equiv_reg (search_equiv, insn, rld[r].class,
|
||||
-1, NULL, 0, rld[r].mode);
|
||||
int regno = 0;
|
||||
|
@ -5787,7 +5787,7 @@ choose_reload_regs (chain)
|
|||
didn't get one yet. */
|
||||
for (j = 0; j < n_reloads; j++)
|
||||
{
|
||||
register int r = reload_order[j];
|
||||
int r = reload_order[j];
|
||||
|
||||
/* Ignore reloads that got marked inoperative. */
|
||||
if (rld[r].out == 0 && rld[r].in == 0 && ! rld[r].secondary_p)
|
||||
|
@ -5848,7 +5848,7 @@ choose_reload_regs (chain)
|
|||
{
|
||||
for (j = 0; j < n_reloads; j++)
|
||||
{
|
||||
register int r = reload_order[j];
|
||||
int r = reload_order[j];
|
||||
rtx check_reg;
|
||||
if (reload_inherited[r] && rld[r].reg_rtx)
|
||||
check_reg = rld[r].reg_rtx;
|
||||
|
@ -5915,7 +5915,7 @@ choose_reload_regs (chain)
|
|||
/* Record which pseudos and which spill regs have output reloads. */
|
||||
for (j = 0; j < n_reloads; j++)
|
||||
{
|
||||
register int r = reload_order[j];
|
||||
int r = reload_order[j];
|
||||
|
||||
i = reload_spill_index[r];
|
||||
|
||||
|
@ -5925,7 +5925,7 @@ choose_reload_regs (chain)
|
|||
if (rld[r].out_reg != 0 && GET_CODE (rld[r].out_reg) == REG
|
||||
&& rld[r].reg_rtx != 0)
|
||||
{
|
||||
register int nregno = REGNO (rld[r].out_reg);
|
||||
int nregno = REGNO (rld[r].out_reg);
|
||||
int nr = 1;
|
||||
|
||||
if (nregno < FIRST_PSEUDO_REGISTER)
|
||||
|
@ -6106,7 +6106,7 @@ emit_input_reload_insns (chain, rl, old, j)
|
|||
int j;
|
||||
{
|
||||
rtx insn = chain->insn;
|
||||
register rtx reloadreg = rl->reg_rtx;
|
||||
rtx reloadreg = rl->reg_rtx;
|
||||
rtx oldequiv_reg = 0;
|
||||
rtx oldequiv = 0;
|
||||
int special = 0;
|
||||
|
@ -6937,7 +6937,7 @@ emit_reload_insns (chain)
|
|||
{
|
||||
rtx insn = chain->insn;
|
||||
|
||||
register int j;
|
||||
int j;
|
||||
|
||||
CLEAR_HARD_REG_SET (reg_reloaded_died);
|
||||
|
||||
|
@ -7028,8 +7028,8 @@ emit_reload_insns (chain)
|
|||
|
||||
for (j = 0; j < n_reloads; j++)
|
||||
{
|
||||
register int r = reload_order[j];
|
||||
register int i = reload_spill_index[r];
|
||||
int r = reload_order[j];
|
||||
int i = reload_spill_index[r];
|
||||
|
||||
/* If this is a non-inherited input reload from a pseudo, we must
|
||||
clear any memory of a previous store to the same pseudo. Only do
|
||||
|
@ -7104,7 +7104,7 @@ emit_reload_insns (chain)
|
|||
: rld[r].out_reg
|
||||
? rld[r].out_reg
|
||||
/* AUTO_INC */ : XEXP (rld[r].in_reg, 0));
|
||||
register int nregno = REGNO (out);
|
||||
int nregno = REGNO (out);
|
||||
int nnr = (nregno >= FIRST_PSEUDO_REGISTER ? 1
|
||||
: HARD_REGNO_NREGS (nregno,
|
||||
GET_MODE (rld[r].reg_rtx)));
|
||||
|
@ -7152,7 +7152,7 @@ emit_reload_insns (chain)
|
|||
&& ! reg_has_output_reload[REGNO (rld[r].in_reg)]))
|
||||
&& ! reg_set_p (rld[r].reg_rtx, PATTERN (insn)))
|
||||
{
|
||||
register int nregno;
|
||||
int nregno;
|
||||
int nnr;
|
||||
|
||||
if (GET_CODE (rld[r].in) == REG
|
||||
|
@ -7225,7 +7225,7 @@ emit_reload_insns (chain)
|
|||
{
|
||||
rtx out = (GET_CODE (rld[r].out) == REG
|
||||
? rld[r].out : rld[r].out_reg);
|
||||
register int nregno = REGNO (out);
|
||||
int nregno = REGNO (out);
|
||||
if (nregno >= FIRST_PSEUDO_REGISTER)
|
||||
{
|
||||
rtx src_reg, store_insn = NULL_RTX;
|
||||
|
@ -7541,7 +7541,7 @@ delete_output_reload (insn, j, last_reload_reg)
|
|||
int k;
|
||||
int n_occurrences;
|
||||
int n_inherited = 0;
|
||||
register rtx i1;
|
||||
rtx i1;
|
||||
rtx substed;
|
||||
|
||||
/* Get the raw pseudo-register referred to. */
|
||||
|
|
30
gcc/reorg.c
30
gcc/reorg.c
|
@ -301,8 +301,8 @@ resource_conflicts_p (res1, res2)
|
|||
|
||||
static int
|
||||
insn_references_resource_p (insn, res, include_delayed_effects)
|
||||
register rtx insn;
|
||||
register struct resources *res;
|
||||
rtx insn;
|
||||
struct resources *res;
|
||||
int include_delayed_effects;
|
||||
{
|
||||
struct resources insn_res;
|
||||
|
@ -319,8 +319,8 @@ insn_references_resource_p (insn, res, include_delayed_effects)
|
|||
|
||||
static int
|
||||
insn_sets_resource_p (insn, res, include_delayed_effects)
|
||||
register rtx insn;
|
||||
register struct resources *res;
|
||||
rtx insn;
|
||||
struct resources *res;
|
||||
int include_delayed_effects;
|
||||
{
|
||||
struct resources insn_sets;
|
||||
|
@ -436,8 +436,8 @@ emit_delay_sequence (insn, list, length)
|
|||
rtx list;
|
||||
int length;
|
||||
{
|
||||
register int i = 1;
|
||||
register rtx li;
|
||||
int i = 1;
|
||||
rtx li;
|
||||
int had_barrier = 0;
|
||||
|
||||
/* Allocate the rtvec to hold the insns and the SEQUENCE. */
|
||||
|
@ -719,9 +719,9 @@ note_delay_statistics (slots_filled, index)
|
|||
|
||||
static rtx
|
||||
optimize_skip (insn)
|
||||
register rtx insn;
|
||||
rtx insn;
|
||||
{
|
||||
register rtx trial = next_nonnote_insn (insn);
|
||||
rtx trial = next_nonnote_insn (insn);
|
||||
rtx next_trial = next_active_insn (trial);
|
||||
rtx delay_list = 0;
|
||||
rtx target_label;
|
||||
|
@ -2034,8 +2034,8 @@ static void
|
|||
fill_simple_delay_slots (non_jumps_p)
|
||||
int non_jumps_p;
|
||||
{
|
||||
register rtx insn, pat, trial, next_trial;
|
||||
register int i;
|
||||
rtx insn, pat, trial, next_trial;
|
||||
int i;
|
||||
int num_unfilled_slots = unfilled_slots_next - unfilled_slots_base;
|
||||
struct resources needed, set;
|
||||
int slots_to_fill, slots_filled;
|
||||
|
@ -2943,8 +2943,8 @@ fill_slots_from_thread (insn, condition, thread, opposite_thread, likely,
|
|||
static void
|
||||
fill_eager_delay_slots ()
|
||||
{
|
||||
register rtx insn;
|
||||
register int i;
|
||||
rtx insn;
|
||||
int i;
|
||||
int num_unfilled_slots = unfilled_slots_next - unfilled_slots_base;
|
||||
|
||||
for (i = 0; i < num_unfilled_slots; i++)
|
||||
|
@ -3072,8 +3072,8 @@ static void
|
|||
relax_delay_slots (first)
|
||||
rtx first;
|
||||
{
|
||||
register rtx insn, next, pat;
|
||||
register rtx trial, delay_insn, target_label;
|
||||
rtx insn, next, pat;
|
||||
rtx trial, delay_insn, target_label;
|
||||
|
||||
/* Look at every JUMP_INSN and see if we can improve it. */
|
||||
for (insn = first; insn; insn = next)
|
||||
|
@ -3662,7 +3662,7 @@ dbr_schedule (first, file)
|
|||
|
||||
if (file)
|
||||
{
|
||||
register int i, j, need_comma;
|
||||
int i, j, need_comma;
|
||||
int total_delay_slots[MAX_DELAY_HISTOGRAM + 1];
|
||||
int total_annul_slots[MAX_DELAY_HISTOGRAM + 1];
|
||||
|
||||
|
|
|
@ -196,14 +196,14 @@ next_insn_no_annul (insn)
|
|||
|
||||
void
|
||||
mark_referenced_resources (x, res, include_delayed_effects)
|
||||
register rtx x;
|
||||
register struct resources *res;
|
||||
register int include_delayed_effects;
|
||||
rtx x;
|
||||
struct resources *res;
|
||||
int include_delayed_effects;
|
||||
{
|
||||
enum rtx_code code = GET_CODE (x);
|
||||
int i, j;
|
||||
unsigned int r;
|
||||
register const char *format_ptr;
|
||||
const char *format_ptr;
|
||||
|
||||
/* Handle leaf items for which we set resource flags. Also, special-case
|
||||
CALL, SET and CLOBBER operators. */
|
||||
|
@ -623,8 +623,8 @@ find_dead_or_set_registers (target, res, jump_target, jump_count, set, needed)
|
|||
|
||||
void
|
||||
mark_set_resources (x, res, in_dest, mark_type)
|
||||
register rtx x;
|
||||
register struct resources *res;
|
||||
rtx x;
|
||||
struct resources *res;
|
||||
int in_dest;
|
||||
enum mark_resource_type mark_type;
|
||||
{
|
||||
|
|
45
gcc/rtl.c
45
gcc/rtl.c
|
@ -330,12 +330,12 @@ rtx_alloc (code)
|
|||
|
||||
rtx
|
||||
copy_rtx (orig)
|
||||
register rtx orig;
|
||||
rtx orig;
|
||||
{
|
||||
register rtx copy;
|
||||
register int i, j;
|
||||
register RTX_CODE code;
|
||||
register const char *format_ptr;
|
||||
rtx copy;
|
||||
int i, j;
|
||||
RTX_CODE code;
|
||||
const char *format_ptr;
|
||||
|
||||
code = GET_CODE (orig);
|
||||
|
||||
|
@ -435,13 +435,13 @@ copy_rtx (orig)
|
|||
|
||||
rtx
|
||||
copy_most_rtx (orig, may_share)
|
||||
register rtx orig;
|
||||
register rtx may_share;
|
||||
rtx orig;
|
||||
rtx may_share;
|
||||
{
|
||||
register rtx copy;
|
||||
register int i, j;
|
||||
register RTX_CODE code;
|
||||
register const char *format_ptr;
|
||||
rtx copy;
|
||||
int i, j;
|
||||
RTX_CODE code;
|
||||
const char *format_ptr;
|
||||
|
||||
if (orig == may_share)
|
||||
return orig;
|
||||
|
@ -534,9 +534,9 @@ rtx
|
|||
shallow_copy_rtx (orig)
|
||||
rtx orig;
|
||||
{
|
||||
register int i;
|
||||
register RTX_CODE code = GET_CODE (orig);
|
||||
register rtx copy = rtx_alloc (code);
|
||||
int i;
|
||||
RTX_CODE code = GET_CODE (orig);
|
||||
rtx copy = rtx_alloc (code);
|
||||
|
||||
PUT_MODE (copy, GET_MODE (orig));
|
||||
copy->in_struct = orig->in_struct;
|
||||
|
@ -564,10 +564,10 @@ int
|
|||
rtx_equal_p (x, y)
|
||||
rtx x, y;
|
||||
{
|
||||
register int i;
|
||||
register int j;
|
||||
register enum rtx_code code;
|
||||
register const char *fmt;
|
||||
int i;
|
||||
int j;
|
||||
enum rtx_code code;
|
||||
const char *fmt;
|
||||
|
||||
if (x == y)
|
||||
return 1;
|
||||
|
@ -589,10 +589,11 @@ rtx_equal_p (x, y)
|
|||
switch (code)
|
||||
{
|
||||
case REG:
|
||||
/* Until rtl generation is complete, don't consider a reference to the
|
||||
return register of the current function the same as the return from a
|
||||
called function. This eases the job of function integration. Once the
|
||||
distinction is no longer needed, they can be considered equivalent. */
|
||||
/* Until rtl generation is complete, don't consider a reference
|
||||
to the return register of the current function the same as
|
||||
the return from a called function. This eases the job of
|
||||
function integration. Once the distinction is no longer
|
||||
needed, they can be considered equivalent. */
|
||||
return (REGNO (x) == REGNO (y)
|
||||
&& (! rtx_equal_function_value_matters
|
||||
|| REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y)));
|
||||
|
|
112
gcc/rtlanal.c
112
gcc/rtlanal.c
|
@ -47,9 +47,9 @@ int
|
|||
rtx_unstable_p (x)
|
||||
rtx x;
|
||||
{
|
||||
register RTX_CODE code = GET_CODE (x);
|
||||
register int i;
|
||||
register const char *fmt;
|
||||
RTX_CODE code = GET_CODE (x);
|
||||
int i;
|
||||
const char *fmt;
|
||||
|
||||
switch (code)
|
||||
{
|
||||
|
@ -123,9 +123,9 @@ rtx_varies_p (x, for_alias)
|
|||
rtx x;
|
||||
int for_alias;
|
||||
{
|
||||
register RTX_CODE code = GET_CODE (x);
|
||||
register int i;
|
||||
register const char *fmt;
|
||||
RTX_CODE code = GET_CODE (x);
|
||||
int i;
|
||||
const char *fmt;
|
||||
|
||||
switch (code)
|
||||
{
|
||||
|
@ -202,9 +202,9 @@ rtx_varies_p (x, for_alias)
|
|||
|
||||
int
|
||||
rtx_addr_can_trap_p (x)
|
||||
register rtx x;
|
||||
rtx x;
|
||||
{
|
||||
register enum rtx_code code = GET_CODE (x);
|
||||
enum rtx_code code = GET_CODE (x);
|
||||
|
||||
switch (code)
|
||||
{
|
||||
|
@ -269,9 +269,9 @@ rtx_addr_varies_p (x, for_alias)
|
|||
rtx x;
|
||||
int for_alias;
|
||||
{
|
||||
register enum rtx_code code;
|
||||
register int i;
|
||||
register const char *fmt;
|
||||
enum rtx_code code;
|
||||
int i;
|
||||
const char *fmt;
|
||||
|
||||
if (x == 0)
|
||||
return 0;
|
||||
|
@ -407,11 +407,11 @@ count_occurrences (x, find, count_dest)
|
|||
|
||||
int
|
||||
reg_mentioned_p (reg, in)
|
||||
register rtx reg, in;
|
||||
rtx reg, in;
|
||||
{
|
||||
register const char *fmt;
|
||||
register int i;
|
||||
register enum rtx_code code;
|
||||
const char *fmt;
|
||||
int i;
|
||||
enum rtx_code code;
|
||||
|
||||
if (in == 0)
|
||||
return 0;
|
||||
|
@ -457,7 +457,7 @@ reg_mentioned_p (reg, in)
|
|||
{
|
||||
if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = XVECLEN (in, i) - 1; j >= 0; j--)
|
||||
if (reg_mentioned_p (reg, XVECEXP (in, i, j)))
|
||||
return 1;
|
||||
|
@ -476,7 +476,7 @@ int
|
|||
no_labels_between_p (beg, end)
|
||||
rtx beg, end;
|
||||
{
|
||||
register rtx p;
|
||||
rtx p;
|
||||
if (beg == end)
|
||||
return 0;
|
||||
for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
|
||||
|
@ -492,7 +492,7 @@ int
|
|||
no_jumps_between_p (beg, end)
|
||||
rtx beg, end;
|
||||
{
|
||||
register rtx p;
|
||||
rtx p;
|
||||
for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
|
||||
if (GET_CODE (p) == JUMP_INSN)
|
||||
return 0;
|
||||
|
@ -506,7 +506,7 @@ int
|
|||
reg_used_between_p (reg, from_insn, to_insn)
|
||||
rtx reg, from_insn, to_insn;
|
||||
{
|
||||
register rtx insn;
|
||||
rtx insn;
|
||||
|
||||
if (from_insn == to_insn)
|
||||
return 0;
|
||||
|
@ -605,7 +605,7 @@ int
|
|||
reg_referenced_between_p (reg, from_insn, to_insn)
|
||||
rtx reg, from_insn, to_insn;
|
||||
{
|
||||
register rtx insn;
|
||||
rtx insn;
|
||||
|
||||
if (from_insn == to_insn)
|
||||
return 0;
|
||||
|
@ -626,7 +626,7 @@ int
|
|||
reg_set_between_p (reg, from_insn, to_insn)
|
||||
rtx reg, from_insn, to_insn;
|
||||
{
|
||||
register rtx insn;
|
||||
rtx insn;
|
||||
|
||||
if (from_insn == to_insn)
|
||||
return 0;
|
||||
|
@ -1218,7 +1218,7 @@ refers_to_regno_p (regno, endregno, x, loc)
|
|||
}
|
||||
else if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = XVECLEN (x, i) - 1; j >=0; j--)
|
||||
if (loc != &XVECEXP (x, i, j)
|
||||
&& refers_to_regno_p (regno, endregno, XVECEXP (x, i, j), loc))
|
||||
|
@ -1364,7 +1364,7 @@ reg_set_last (x, insn)
|
|||
|
||||
void
|
||||
note_stores (x, fun, data)
|
||||
register rtx x;
|
||||
rtx x;
|
||||
void (*fun) PARAMS ((rtx, rtx, void *));
|
||||
void *data;
|
||||
{
|
||||
|
@ -1375,7 +1375,7 @@ note_stores (x, fun, data)
|
|||
|
||||
if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
|
||||
{
|
||||
register rtx dest = SET_DEST (x);
|
||||
rtx dest = SET_DEST (x);
|
||||
|
||||
while ((GET_CODE (dest) == SUBREG
|
||||
&& (GET_CODE (SUBREG_REG (dest)) != REG
|
||||
|
@ -1582,7 +1582,7 @@ dead_or_set_regno_p (insn, test_regno)
|
|||
}
|
||||
else if (GET_CODE (pattern) == PARALLEL)
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
for (i = XVECLEN (pattern, 0) - 1; i >= 0; i--)
|
||||
{
|
||||
|
@ -1627,7 +1627,7 @@ find_reg_note (insn, kind, datum)
|
|||
enum reg_note kind;
|
||||
rtx datum;
|
||||
{
|
||||
register rtx link;
|
||||
rtx link;
|
||||
|
||||
/* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
|
||||
if (! INSN_P (insn))
|
||||
|
@ -1651,7 +1651,7 @@ find_regno_note (insn, kind, regno)
|
|||
enum reg_note kind;
|
||||
unsigned int regno;
|
||||
{
|
||||
register rtx link;
|
||||
rtx link;
|
||||
|
||||
/* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
|
||||
if (! INSN_P (insn))
|
||||
|
@ -1708,7 +1708,7 @@ find_reg_fusage (insn, code, datum)
|
|||
|
||||
if (GET_CODE (datum) != REG)
|
||||
{
|
||||
register rtx link;
|
||||
rtx link;
|
||||
|
||||
for (link = CALL_INSN_FUNCTION_USAGE (insn);
|
||||
link;
|
||||
|
@ -1748,7 +1748,7 @@ find_regno_fusage (insn, code, regno)
|
|||
enum rtx_code code;
|
||||
unsigned int regno;
|
||||
{
|
||||
register rtx link;
|
||||
rtx link;
|
||||
|
||||
/* CALL_INSN_FUNCTION_USAGE information cannot contain references
|
||||
to pseudo registers, so don't bother checking. */
|
||||
|
@ -1776,10 +1776,10 @@ find_regno_fusage (insn, code, regno)
|
|||
|
||||
void
|
||||
remove_note (insn, note)
|
||||
register rtx insn;
|
||||
register rtx note;
|
||||
rtx insn;
|
||||
rtx note;
|
||||
{
|
||||
register rtx link;
|
||||
rtx link;
|
||||
|
||||
if (note == NULL_RTX)
|
||||
return;
|
||||
|
@ -1840,7 +1840,7 @@ int
|
|||
volatile_insn_p (x)
|
||||
rtx x;
|
||||
{
|
||||
register RTX_CODE code;
|
||||
RTX_CODE code;
|
||||
|
||||
code = GET_CODE (x);
|
||||
switch (code)
|
||||
|
@ -1877,8 +1877,8 @@ volatile_insn_p (x)
|
|||
/* Recursively scan the operands of this expression. */
|
||||
|
||||
{
|
||||
register const char *fmt = GET_RTX_FORMAT (code);
|
||||
register int i;
|
||||
const char *fmt = GET_RTX_FORMAT (code);
|
||||
int i;
|
||||
|
||||
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
||||
{
|
||||
|
@ -1889,7 +1889,7 @@ volatile_insn_p (x)
|
|||
}
|
||||
else if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = 0; j < XVECLEN (x, i); j++)
|
||||
if (volatile_insn_p (XVECEXP (x, i, j)))
|
||||
return 1;
|
||||
|
@ -1906,7 +1906,7 @@ int
|
|||
volatile_refs_p (x)
|
||||
rtx x;
|
||||
{
|
||||
register RTX_CODE code;
|
||||
RTX_CODE code;
|
||||
|
||||
code = GET_CODE (x);
|
||||
switch (code)
|
||||
|
@ -1943,8 +1943,8 @@ volatile_refs_p (x)
|
|||
/* Recursively scan the operands of this expression. */
|
||||
|
||||
{
|
||||
register const char *fmt = GET_RTX_FORMAT (code);
|
||||
register int i;
|
||||
const char *fmt = GET_RTX_FORMAT (code);
|
||||
int i;
|
||||
|
||||
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
||||
{
|
||||
|
@ -1955,7 +1955,7 @@ volatile_refs_p (x)
|
|||
}
|
||||
else if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = 0; j < XVECLEN (x, i); j++)
|
||||
if (volatile_refs_p (XVECEXP (x, i, j)))
|
||||
return 1;
|
||||
|
@ -1972,7 +1972,7 @@ int
|
|||
side_effects_p (x)
|
||||
rtx x;
|
||||
{
|
||||
register RTX_CODE code;
|
||||
RTX_CODE code;
|
||||
|
||||
code = GET_CODE (x);
|
||||
switch (code)
|
||||
|
@ -2020,8 +2020,8 @@ side_effects_p (x)
|
|||
/* Recursively scan the operands of this expression. */
|
||||
|
||||
{
|
||||
register const char *fmt = GET_RTX_FORMAT (code);
|
||||
register int i;
|
||||
const char *fmt = GET_RTX_FORMAT (code);
|
||||
int i;
|
||||
|
||||
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
||||
{
|
||||
|
@ -2032,7 +2032,7 @@ side_effects_p (x)
|
|||
}
|
||||
else if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = 0; j < XVECLEN (x, i); j++)
|
||||
if (side_effects_p (XVECEXP (x, i, j)))
|
||||
return 1;
|
||||
|
@ -2140,7 +2140,7 @@ may_trap_p (x)
|
|||
}
|
||||
else if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = 0; j < XVECLEN (x, i); j++)
|
||||
if (may_trap_p (XVECEXP (x, i, j)))
|
||||
return 1;
|
||||
|
@ -2156,9 +2156,9 @@ int
|
|||
inequality_comparisons_p (x)
|
||||
rtx x;
|
||||
{
|
||||
register const char *fmt;
|
||||
register int len, i;
|
||||
register enum rtx_code code = GET_CODE (x);
|
||||
const char *fmt;
|
||||
int len, i;
|
||||
enum rtx_code code = GET_CODE (x);
|
||||
|
||||
switch (code)
|
||||
{
|
||||
|
@ -2199,7 +2199,7 @@ inequality_comparisons_p (x)
|
|||
}
|
||||
else if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
||||
if (inequality_comparisons_p (XVECEXP (x, i, j)))
|
||||
return 1;
|
||||
|
@ -2219,8 +2219,8 @@ rtx
|
|||
replace_rtx (x, from, to)
|
||||
rtx x, from, to;
|
||||
{
|
||||
register int i, j;
|
||||
register const char *fmt;
|
||||
int i, j;
|
||||
const char *fmt;
|
||||
|
||||
/* The following prevents loops occurrence when we change MEM in
|
||||
CONST_DOUBLE onto the same CONST_DOUBLE. */
|
||||
|
@ -2266,9 +2266,9 @@ replace_regs (x, reg_map, nregs, replace_dest)
|
|||
unsigned int nregs;
|
||||
int replace_dest;
|
||||
{
|
||||
register enum rtx_code code;
|
||||
register int i;
|
||||
register const char *fmt;
|
||||
enum rtx_code code;
|
||||
int i;
|
||||
const char *fmt;
|
||||
|
||||
if (x == 0)
|
||||
return x;
|
||||
|
@ -2341,7 +2341,7 @@ replace_regs (x, reg_map, nregs, replace_dest)
|
|||
XEXP (x, i) = replace_regs (XEXP (x, i), reg_map, nregs, replace_dest);
|
||||
else if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = 0; j < XVECLEN (x, i); j++)
|
||||
XVECEXP (x, i, j) = replace_regs (XVECEXP (x, i, j), reg_map,
|
||||
nregs, replace_dest);
|
||||
|
@ -2527,7 +2527,7 @@ regno_use_in (regno, x)
|
|||
unsigned int regno;
|
||||
rtx x;
|
||||
{
|
||||
register const char *fmt;
|
||||
const char *fmt;
|
||||
int i, j;
|
||||
rtx tem;
|
||||
|
||||
|
|
22
gcc/scan.c
22
gcc/scan.c
|
@ -45,8 +45,9 @@ sstring_append (dst, src)
|
|||
sstring *dst;
|
||||
sstring *src;
|
||||
{
|
||||
register char *d, *s;
|
||||
register int count = SSTRING_LENGTH(src);
|
||||
char *d, *s;
|
||||
int count = SSTRING_LENGTH(src);
|
||||
|
||||
MAKE_SSTRING_SPACE(dst, count + 1);
|
||||
d = dst->ptr;
|
||||
s = src->base;
|
||||
|
@ -57,8 +58,8 @@ sstring_append (dst, src)
|
|||
|
||||
int
|
||||
scan_ident (fp, s, c)
|
||||
register FILE *fp;
|
||||
register sstring *s;
|
||||
FILE *fp;
|
||||
sstring *s;
|
||||
int c;
|
||||
{
|
||||
s->ptr = s->base;
|
||||
|
@ -79,11 +80,12 @@ scan_ident (fp, s, c)
|
|||
|
||||
int
|
||||
scan_string (fp, s, init)
|
||||
register FILE *fp;
|
||||
register sstring *s;
|
||||
FILE *fp;
|
||||
sstring *s;
|
||||
int init;
|
||||
{
|
||||
int c;
|
||||
|
||||
for (;;)
|
||||
{
|
||||
c = getc (fp);
|
||||
|
@ -113,7 +115,7 @@ scan_string (fp, s, init)
|
|||
|
||||
int
|
||||
skip_spaces (fp, c)
|
||||
register FILE *fp;
|
||||
FILE *fp;
|
||||
int c;
|
||||
{
|
||||
for (;;)
|
||||
|
@ -156,6 +158,7 @@ read_upto (fp, str, delim)
|
|||
int delim;
|
||||
{
|
||||
int ch;
|
||||
|
||||
for (;;)
|
||||
{
|
||||
ch = getc (fp);
|
||||
|
@ -170,10 +173,11 @@ read_upto (fp, str, delim)
|
|||
|
||||
int
|
||||
get_token (fp, s)
|
||||
register FILE *fp;
|
||||
register sstring *s;
|
||||
FILE *fp;
|
||||
sstring *s;
|
||||
{
|
||||
int c;
|
||||
|
||||
s->ptr = s->base;
|
||||
retry:
|
||||
c = ' ';
|
||||
|
|
|
@ -488,7 +488,7 @@ add_insn_mem_dependence (deps, insn_list, mem_list, insn, mem)
|
|||
struct deps *deps;
|
||||
rtx *insn_list, *mem_list, insn, mem;
|
||||
{
|
||||
register rtx link;
|
||||
rtx link;
|
||||
|
||||
link = alloc_INSN_LIST (insn, *insn_list);
|
||||
*insn_list = link;
|
||||
|
@ -564,8 +564,8 @@ sched_analyze_1 (deps, x, insn)
|
|||
rtx x;
|
||||
rtx insn;
|
||||
{
|
||||
register int regno;
|
||||
register rtx dest = XEXP (x, 0);
|
||||
int regno;
|
||||
rtx dest = XEXP (x, 0);
|
||||
enum rtx_code code = GET_CODE (x);
|
||||
|
||||
if (dest == 0)
|
||||
|
@ -573,7 +573,7 @@ sched_analyze_1 (deps, x, insn)
|
|||
|
||||
if (GET_CODE (dest) == PARALLEL)
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
|
||||
if (XEXP (XVECEXP (dest, 0, i), 0) != 0)
|
||||
|
@ -601,7 +601,7 @@ sched_analyze_1 (deps, x, insn)
|
|||
|
||||
if (GET_CODE (dest) == REG)
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
regno = REGNO (dest);
|
||||
|
||||
|
@ -759,10 +759,10 @@ sched_analyze_2 (deps, x, insn)
|
|||
rtx x;
|
||||
rtx insn;
|
||||
{
|
||||
register int i;
|
||||
register int j;
|
||||
register enum rtx_code code;
|
||||
register const char *fmt;
|
||||
int i;
|
||||
int j;
|
||||
enum rtx_code code;
|
||||
const char *fmt;
|
||||
|
||||
if (x == 0)
|
||||
return;
|
||||
|
@ -1007,7 +1007,7 @@ sched_analyze_insn (deps, x, insn, loop_notes)
|
|||
rtx x, insn;
|
||||
rtx loop_notes;
|
||||
{
|
||||
register RTX_CODE code = GET_CODE (x);
|
||||
RTX_CODE code = GET_CODE (x);
|
||||
int schedule_barrier_found = 0;
|
||||
rtx link;
|
||||
int i;
|
||||
|
@ -1025,7 +1025,7 @@ sched_analyze_insn (deps, x, insn, loop_notes)
|
|||
sched_analyze_1 (deps, x, insn);
|
||||
else if (code == PARALLEL)
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
|
||||
{
|
||||
rtx sub = XVECEXP (x, 0, i);
|
||||
|
@ -1264,8 +1264,8 @@ sched_analyze (deps, head, tail)
|
|||
struct deps *deps;
|
||||
rtx head, tail;
|
||||
{
|
||||
register rtx insn;
|
||||
register rtx u;
|
||||
rtx insn;
|
||||
rtx u;
|
||||
rtx loop_notes = 0;
|
||||
|
||||
if (current_sched_info->use_cselib)
|
||||
|
@ -1298,7 +1298,7 @@ sched_analyze (deps, head, tail)
|
|||
else if (GET_CODE (insn) == CALL_INSN)
|
||||
{
|
||||
rtx x;
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
/* Clear out stale SCHED_GROUP_P. */
|
||||
SCHED_GROUP_P (insn) = 0;
|
||||
|
|
|
@ -486,29 +486,29 @@ new_edge (source, target)
|
|||
|
||||
/* Compute bitwise union of two bitsets. */
|
||||
#define BITSET_UNION(set1, set2, len) \
|
||||
do { register bitset tp = set1, sp = set2; \
|
||||
register int i; \
|
||||
do { bitset tp = set1, sp = set2; \
|
||||
int i; \
|
||||
for (i = 0; i < len; i++) \
|
||||
*(tp++) |= *(sp++); } while (0)
|
||||
|
||||
/* Compute bitwise intersection of two bitsets. */
|
||||
#define BITSET_INTER(set1, set2, len) \
|
||||
do { register bitset tp = set1, sp = set2; \
|
||||
register int i; \
|
||||
do { bitset tp = set1, sp = set2; \
|
||||
int i; \
|
||||
for (i = 0; i < len; i++) \
|
||||
*(tp++) &= *(sp++); } while (0)
|
||||
|
||||
/* Compute bitwise difference of two bitsets. */
|
||||
#define BITSET_DIFFER(set1, set2, len) \
|
||||
do { register bitset tp = set1, sp = set2; \
|
||||
register int i; \
|
||||
do { bitset tp = set1, sp = set2; \
|
||||
int i; \
|
||||
for (i = 0; i < len; i++) \
|
||||
*(tp++) &= ~*(sp++); } while (0)
|
||||
|
||||
/* Inverts every bit of bitset 'set'. */
|
||||
#define BITSET_INVERT(set, len) \
|
||||
do { register bitset tmpset = set; \
|
||||
register int i; \
|
||||
do { bitset tmpset = set; \
|
||||
int i; \
|
||||
for (i = 0; i < len; i++, tmpset++) \
|
||||
*tmpset = ~*tmpset; } while (0)
|
||||
|
||||
|
@ -1229,7 +1229,7 @@ static void
|
|||
compute_trg_info (trg)
|
||||
int trg;
|
||||
{
|
||||
register candidate *sp;
|
||||
candidate *sp;
|
||||
edgelst el;
|
||||
int check_block, update_idx;
|
||||
int i, j, k, fst_edge, nxt_edge;
|
||||
|
@ -1384,9 +1384,9 @@ check_live_1 (src, x)
|
|||
int src;
|
||||
rtx x;
|
||||
{
|
||||
register int i;
|
||||
register int regno;
|
||||
register rtx reg = SET_DEST (x);
|
||||
int i;
|
||||
int regno;
|
||||
rtx reg = SET_DEST (x);
|
||||
|
||||
if (reg == 0)
|
||||
return 1;
|
||||
|
@ -1398,7 +1398,7 @@ check_live_1 (src, x)
|
|||
|
||||
if (GET_CODE (reg) == PARALLEL)
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
for (i = XVECLEN (reg, 0) - 1; i >= 0; i--)
|
||||
if (XEXP (XVECEXP (reg, 0, i), 0) != 0)
|
||||
|
@ -1464,9 +1464,9 @@ update_live_1 (src, x)
|
|||
int src;
|
||||
rtx x;
|
||||
{
|
||||
register int i;
|
||||
register int regno;
|
||||
register rtx reg = SET_DEST (x);
|
||||
int i;
|
||||
int regno;
|
||||
rtx reg = SET_DEST (x);
|
||||
|
||||
if (reg == 0)
|
||||
return;
|
||||
|
@ -1478,7 +1478,7 @@ update_live_1 (src, x)
|
|||
|
||||
if (GET_CODE (reg) == PARALLEL)
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
|
||||
for (i = XVECLEN (reg, 0) - 1; i >= 0; i--)
|
||||
if (XEXP (XVECEXP (reg, 0, i), 0) != 0)
|
||||
|
@ -1770,7 +1770,7 @@ is_pfree (load_insn, bb_src, bb_trg)
|
|||
int bb_src, bb_trg;
|
||||
{
|
||||
rtx back_link;
|
||||
register candidate *candp = candidate_table + bb_src;
|
||||
candidate *candp = candidate_table + bb_src;
|
||||
|
||||
if (candp->split_bbs.nr_members != 1)
|
||||
/* Must have exactly one escape block. */
|
||||
|
|
14
gcc/sdbout.c
14
gcc/sdbout.c
|
@ -429,7 +429,7 @@ static int
|
|||
template_name_p (name)
|
||||
tree name;
|
||||
{
|
||||
register const char *ptr = IDENTIFIER_POINTER (name);
|
||||
const char *ptr = IDENTIFIER_POINTER (name);
|
||||
while (*ptr && *ptr != '<')
|
||||
ptr++;
|
||||
|
||||
|
@ -661,7 +661,7 @@ static int do_block = 0;
|
|||
|
||||
static void
|
||||
sdbout_block (block)
|
||||
register tree block;
|
||||
tree block;
|
||||
{
|
||||
while (block)
|
||||
{
|
||||
|
@ -999,7 +999,7 @@ sdbout_queue_anonymous_type (type)
|
|||
static void
|
||||
sdbout_dequeue_anonymous_types ()
|
||||
{
|
||||
register tree types, link;
|
||||
tree types, link;
|
||||
|
||||
while (anonymous_types)
|
||||
{
|
||||
|
@ -1008,7 +1008,7 @@ sdbout_dequeue_anonymous_types ()
|
|||
|
||||
for (link = types; link; link = TREE_CHAIN (link))
|
||||
{
|
||||
register tree type = TREE_VALUE (link);
|
||||
tree type = TREE_VALUE (link);
|
||||
|
||||
if (type && ! TREE_ASM_WRITTEN (type))
|
||||
sdbout_one_type (type);
|
||||
|
@ -1023,9 +1023,9 @@ sdbout_dequeue_anonymous_types ()
|
|||
|
||||
void
|
||||
sdbout_types (types)
|
||||
register tree types;
|
||||
tree types;
|
||||
{
|
||||
register tree link;
|
||||
tree link;
|
||||
|
||||
for (link = types; link; link = TREE_CHAIN (link))
|
||||
sdbout_one_type (link);
|
||||
|
@ -1697,7 +1697,7 @@ sdbout_end_epilogue ()
|
|||
|
||||
static void
|
||||
sdbout_label (insn)
|
||||
register rtx insn;
|
||||
rtx insn;
|
||||
{
|
||||
PUT_SDB_DEF (LABEL_NAME (insn));
|
||||
PUT_SDB_VAL (insn);
|
||||
|
|
|
@ -488,8 +488,8 @@ simplify_unary_operation (code, mode, op, op_mode)
|
|||
if (GET_CODE (trueop) == CONST_INT
|
||||
&& width <= HOST_BITS_PER_WIDE_INT && width > 0)
|
||||
{
|
||||
register HOST_WIDE_INT arg0 = INTVAL (trueop);
|
||||
register HOST_WIDE_INT val;
|
||||
HOST_WIDE_INT arg0 = INTVAL (trueop);
|
||||
HOST_WIDE_INT val;
|
||||
|
||||
switch (code)
|
||||
{
|
||||
|
@ -859,7 +859,7 @@ simplify_binary_operation (code, mode, op0, op1)
|
|||
enum machine_mode mode;
|
||||
rtx op0, op1;
|
||||
{
|
||||
register HOST_WIDE_INT arg0, arg1, arg0s, arg1s;
|
||||
HOST_WIDE_INT arg0, arg1, arg0s, arg1s;
|
||||
HOST_WIDE_INT val;
|
||||
unsigned int width = GET_MODE_BITSIZE (mode);
|
||||
rtx tem;
|
||||
|
|
62
gcc/stmt.c
62
gcc/stmt.c
|
@ -1040,7 +1040,7 @@ expand_fixup (tree_label, rtl_label, last_insn)
|
|||
as a placeholder. */
|
||||
|
||||
{
|
||||
register rtx original_before_jump
|
||||
rtx original_before_jump
|
||||
= last_insn ? last_insn : get_last_insn ();
|
||||
rtx start;
|
||||
rtx end;
|
||||
|
@ -1118,7 +1118,7 @@ fixup_gotos (thisblock, stack_level, cleanup_list, first_insn, dont_jump_in)
|
|||
rtx first_insn;
|
||||
int dont_jump_in;
|
||||
{
|
||||
register struct goto_fixup *f, *prev;
|
||||
struct goto_fixup *f, *prev;
|
||||
|
||||
/* F is the fixup we are considering; PREV is the previous one. */
|
||||
/* We run this loop in two passes so that cleanups of exited blocks
|
||||
|
@ -1138,7 +1138,7 @@ fixup_gotos (thisblock, stack_level, cleanup_list, first_insn, dont_jump_in)
|
|||
If so, we can finalize it. */
|
||||
else if (PREV_INSN (f->target_rtl) != 0)
|
||||
{
|
||||
register rtx cleanup_insns;
|
||||
rtx cleanup_insns;
|
||||
|
||||
/* If this fixup jumped into this contour from before the beginning
|
||||
of this contour, report an error. This code used to use
|
||||
|
@ -1485,7 +1485,7 @@ expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
|
|||
int ninout = 0;
|
||||
int nclobbers;
|
||||
tree tail;
|
||||
register int i;
|
||||
int i;
|
||||
/* Vector of RTX's of evaluated output operands. */
|
||||
rtx *output_rtx = (rtx *) alloca (noutputs * sizeof (rtx));
|
||||
int *inout_opnum = (int *) alloca (noutputs * sizeof (int));
|
||||
|
@ -2333,7 +2333,7 @@ struct nesting *
|
|||
expand_start_loop (exit_flag)
|
||||
int exit_flag;
|
||||
{
|
||||
register struct nesting *thisloop = ALLOC_NESTING ();
|
||||
struct nesting *thisloop = ALLOC_NESTING ();
|
||||
|
||||
/* Make an entry on loop_stack for the loop we are entering. */
|
||||
|
||||
|
@ -2374,7 +2374,7 @@ expand_start_loop_continue_elsewhere (exit_flag)
|
|||
struct nesting *
|
||||
expand_start_null_loop ()
|
||||
{
|
||||
register struct nesting *thisloop = ALLOC_NESTING ();
|
||||
struct nesting *thisloop = ALLOC_NESTING ();
|
||||
|
||||
/* Make an entry on loop_stack for the loop we are entering. */
|
||||
|
||||
|
@ -2655,8 +2655,8 @@ expand_end_loop ()
|
|||
/* We found one. Move everything from there up
|
||||
to the end of the loop, and add a jump into the loop
|
||||
to jump to there. */
|
||||
register rtx newstart_label = gen_label_rtx ();
|
||||
register rtx start_move = start_label;
|
||||
rtx newstart_label = gen_label_rtx ();
|
||||
rtx start_move = start_label;
|
||||
rtx next_insn;
|
||||
|
||||
/* If the start label is preceded by a NOTE_INSN_LOOP_CONT note,
|
||||
|
@ -2945,7 +2945,7 @@ expand_return (retval)
|
|||
computation of the return value. */
|
||||
rtx last_insn = 0;
|
||||
rtx result_rtl;
|
||||
register rtx val = 0;
|
||||
rtx val = 0;
|
||||
tree retval_rhs;
|
||||
|
||||
/* If function wants no value, give it none. */
|
||||
|
@ -3197,9 +3197,9 @@ static int
|
|||
tail_recursion_args (actuals, formals)
|
||||
tree actuals, formals;
|
||||
{
|
||||
register tree a = actuals, f = formals;
|
||||
register int i;
|
||||
register rtx *argvec;
|
||||
tree a = actuals, f = formals;
|
||||
int i;
|
||||
rtx *argvec;
|
||||
|
||||
/* Check that number and types of actuals are compatible
|
||||
with the formals. This is not always true in valid C code.
|
||||
|
@ -3232,7 +3232,7 @@ tail_recursion_args (actuals, formals)
|
|||
for (a = actuals, i = 0; a; a = TREE_CHAIN (a), i++)
|
||||
{
|
||||
int copy = 0;
|
||||
register int j;
|
||||
int j;
|
||||
for (f = formals, j = 0; j < i; f = TREE_CHAIN (f), j++)
|
||||
if (reg_mentioned_p (DECL_RTL (f), argvec[i]))
|
||||
{
|
||||
|
@ -3387,7 +3387,7 @@ expand_end_target_temps ()
|
|||
|
||||
int
|
||||
is_body_block (stmt)
|
||||
register tree stmt;
|
||||
tree stmt;
|
||||
{
|
||||
if (TREE_CODE (stmt) == BLOCK)
|
||||
{
|
||||
|
@ -3619,7 +3619,7 @@ expand_end_bindings (vars, mark_ends, dont_jump_in)
|
|||
int mark_ends;
|
||||
int dont_jump_in;
|
||||
{
|
||||
register struct nesting *thisblock = block_stack;
|
||||
struct nesting *thisblock = block_stack;
|
||||
|
||||
/* If any of the variables in this scope were not used, warn the
|
||||
user. */
|
||||
|
@ -3764,7 +3764,7 @@ save_stack_pointer ()
|
|||
|
||||
void
|
||||
expand_decl (decl)
|
||||
register tree decl;
|
||||
tree decl;
|
||||
{
|
||||
struct nesting *thisblock;
|
||||
tree type;
|
||||
|
@ -4311,7 +4311,7 @@ expand_start_case (exit_flag, expr, type, printname)
|
|||
tree type;
|
||||
const char *printname;
|
||||
{
|
||||
register struct nesting *thiscase = ALLOC_NESTING ();
|
||||
struct nesting *thiscase = ALLOC_NESTING ();
|
||||
|
||||
/* Make an entry on case_stack for the case we are entering. */
|
||||
|
||||
|
@ -4348,7 +4348,7 @@ expand_start_case (exit_flag, expr, type, printname)
|
|||
void
|
||||
expand_start_case_dummy ()
|
||||
{
|
||||
register struct nesting *thiscase = ALLOC_NESTING ();
|
||||
struct nesting *thiscase = ALLOC_NESTING ();
|
||||
|
||||
/* Make an entry on case_stack for the dummy. */
|
||||
|
||||
|
@ -4439,9 +4439,9 @@ check_seenlabel ()
|
|||
|
||||
int
|
||||
pushcase (value, converter, label, duplicate)
|
||||
register tree value;
|
||||
tree value;
|
||||
tree (*converter) PARAMS ((tree, tree));
|
||||
register tree label;
|
||||
tree label;
|
||||
tree *duplicate;
|
||||
{
|
||||
tree index_type;
|
||||
|
@ -4489,9 +4489,9 @@ pushcase (value, converter, label, duplicate)
|
|||
|
||||
int
|
||||
pushcase_range (value1, value2, converter, label, duplicate)
|
||||
register tree value1, value2;
|
||||
tree value1, value2;
|
||||
tree (*converter) PARAMS ((tree, tree));
|
||||
register tree label;
|
||||
tree label;
|
||||
tree *duplicate;
|
||||
{
|
||||
tree index_type;
|
||||
|
@ -4882,7 +4882,7 @@ mark_seen_cases (type, cases_seen, count, sparseness)
|
|||
tree next_node_to_try = NULL_TREE;
|
||||
HOST_WIDE_INT next_node_offset = 0;
|
||||
|
||||
register struct case_node *n, *root = case_stack->data.case_stmt.case_list;
|
||||
struct case_node *n, *root = case_stack->data.case_stmt.case_list;
|
||||
tree val = make_node (INTEGER_CST);
|
||||
|
||||
TREE_TYPE (val) = type;
|
||||
|
@ -5011,8 +5011,8 @@ void
|
|||
check_for_full_enumeration_handling (type)
|
||||
tree type;
|
||||
{
|
||||
register struct case_node *n;
|
||||
register tree chain;
|
||||
struct case_node *n;
|
||||
tree chain;
|
||||
|
||||
/* True iff the selector type is a numbered set mode. */
|
||||
int sparseness = 0;
|
||||
|
@ -5138,15 +5138,15 @@ expand_end_case (orig_index)
|
|||
{
|
||||
tree minval = NULL_TREE, maxval = NULL_TREE, range = NULL_TREE, orig_minval;
|
||||
rtx default_label = 0;
|
||||
register struct case_node *n;
|
||||
struct case_node *n;
|
||||
unsigned int count;
|
||||
rtx index;
|
||||
rtx table_label;
|
||||
int ncases;
|
||||
rtx *labelvec;
|
||||
register int i;
|
||||
int i;
|
||||
rtx before_case, end;
|
||||
register struct nesting *thiscase = case_stack;
|
||||
struct nesting *thiscase = case_stack;
|
||||
tree index_expr, index_type;
|
||||
int unsignedp;
|
||||
|
||||
|
@ -5366,7 +5366,7 @@ expand_end_case (orig_index)
|
|||
|
||||
for (n = thiscase->data.case_stmt.case_list; n; n = n->right)
|
||||
{
|
||||
register HOST_WIDE_INT i
|
||||
HOST_WIDE_INT i
|
||||
= TREE_INT_CST_LOW (n->low) - TREE_INT_CST_LOW (orig_minval);
|
||||
|
||||
while (1)
|
||||
|
@ -5614,7 +5614,7 @@ balance_case_nodes (head, parent)
|
|||
case_node_ptr *head;
|
||||
case_node_ptr parent;
|
||||
{
|
||||
register case_node_ptr np;
|
||||
case_node_ptr np;
|
||||
|
||||
np = *head;
|
||||
if (np)
|
||||
|
@ -5622,7 +5622,7 @@ balance_case_nodes (head, parent)
|
|||
int cost = 0;
|
||||
int i = 0;
|
||||
int ranges = 0;
|
||||
register case_node_ptr *npp;
|
||||
case_node_ptr *npp;
|
||||
case_node_ptr left;
|
||||
|
||||
/* Count the number of entries on branch. Also count the ranges. */
|
||||
|
|
|
@ -198,7 +198,7 @@ mode_for_size (size, class, limit)
|
|||
enum mode_class class;
|
||||
int limit;
|
||||
{
|
||||
register enum machine_mode mode;
|
||||
enum machine_mode mode;
|
||||
|
||||
if (limit && size > MAX_FIXED_MODE_SIZE)
|
||||
return BLKmode;
|
||||
|
@ -238,7 +238,7 @@ smallest_mode_for_size (size, class)
|
|||
unsigned int size;
|
||||
enum mode_class class;
|
||||
{
|
||||
register enum machine_mode mode;
|
||||
enum machine_mode mode;
|
||||
|
||||
/* Get the first mode which has at least this size, in the
|
||||
specified class. */
|
||||
|
@ -327,8 +327,8 @@ layout_decl (decl, known_align)
|
|||
tree decl;
|
||||
unsigned int known_align;
|
||||
{
|
||||
register tree type = TREE_TYPE (decl);
|
||||
register enum tree_code code = TREE_CODE (decl);
|
||||
tree type = TREE_TYPE (decl);
|
||||
enum tree_code code = TREE_CODE (decl);
|
||||
|
||||
if (code == CONST_DECL)
|
||||
return;
|
||||
|
@ -396,7 +396,7 @@ layout_decl (decl, known_align)
|
|||
&& TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
|
||||
&& GET_MODE_CLASS (TYPE_MODE (type)) == MODE_INT)
|
||||
{
|
||||
register enum machine_mode xmode
|
||||
enum machine_mode xmode
|
||||
= mode_for_size_tree (DECL_SIZE (decl), MODE_INT, 1);
|
||||
|
||||
if (xmode != BLKmode && known_align >= GET_MODE_ALIGNMENT (xmode))
|
||||
|
@ -1390,8 +1390,8 @@ layout_type (type)
|
|||
|
||||
case ARRAY_TYPE:
|
||||
{
|
||||
register tree index = TYPE_DOMAIN (type);
|
||||
register tree element = TREE_TYPE (type);
|
||||
tree index = TYPE_DOMAIN (type);
|
||||
tree element = TREE_TYPE (type);
|
||||
|
||||
build_pointer_type (element);
|
||||
|
||||
|
@ -1596,7 +1596,7 @@ tree
|
|||
make_signed_type (precision)
|
||||
int precision;
|
||||
{
|
||||
register tree type = make_node (INTEGER_TYPE);
|
||||
tree type = make_node (INTEGER_TYPE);
|
||||
|
||||
TYPE_PRECISION (type) = precision;
|
||||
|
||||
|
@ -1610,7 +1610,7 @@ tree
|
|||
make_unsigned_type (precision)
|
||||
int precision;
|
||||
{
|
||||
register tree type = make_node (INTEGER_TYPE);
|
||||
tree type = make_node (INTEGER_TYPE);
|
||||
|
||||
TYPE_PRECISION (type) = precision;
|
||||
|
||||
|
@ -1741,7 +1741,7 @@ void
|
|||
fixup_signed_type (type)
|
||||
tree type;
|
||||
{
|
||||
register int precision = TYPE_PRECISION (type);
|
||||
int precision = TYPE_PRECISION (type);
|
||||
|
||||
TYPE_MIN_VALUE (type)
|
||||
= build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
|
||||
|
@ -1773,7 +1773,7 @@ void
|
|||
fixup_unsigned_type (type)
|
||||
tree type;
|
||||
{
|
||||
register int precision = TYPE_PRECISION (type);
|
||||
int precision = TYPE_PRECISION (type);
|
||||
|
||||
TYPE_MIN_VALUE (type) = build_int_2 (0, 0);
|
||||
TYPE_MAX_VALUE (type)
|
||||
|
|
14
gcc/toplev.c
14
gcc/toplev.c
|
@ -1638,9 +1638,9 @@ botch (s)
|
|||
|
||||
int
|
||||
exact_log2_wide (x)
|
||||
register unsigned HOST_WIDE_INT x;
|
||||
unsigned HOST_WIDE_INT x;
|
||||
{
|
||||
register int log = 0;
|
||||
int log = 0;
|
||||
/* Test for 0 or a power of 2. */
|
||||
if (x == 0 || x != (x & -x))
|
||||
return -1;
|
||||
|
@ -1656,9 +1656,9 @@ exact_log2_wide (x)
|
|||
|
||||
int
|
||||
floor_log2_wide (x)
|
||||
register unsigned HOST_WIDE_INT x;
|
||||
unsigned HOST_WIDE_INT x;
|
||||
{
|
||||
register int log = -1;
|
||||
int log = -1;
|
||||
while (x != 0)
|
||||
log++,
|
||||
x >>= 1;
|
||||
|
@ -2613,7 +2613,7 @@ void
|
|||
rest_of_compilation (decl)
|
||||
tree decl;
|
||||
{
|
||||
register rtx insns;
|
||||
rtx insns;
|
||||
int tem;
|
||||
int failure = 0;
|
||||
int rebuild_label_notes_after_reload;
|
||||
|
@ -4612,7 +4612,7 @@ toplev_main (argc, argv)
|
|||
int argc;
|
||||
char **argv;
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
char *p;
|
||||
|
||||
/* save in case md file wants to emit args as a comment. */
|
||||
|
@ -4986,7 +4986,7 @@ static void
|
|||
set_target_switch (name)
|
||||
const char *name;
|
||||
{
|
||||
register size_t j;
|
||||
size_t j;
|
||||
int valid_target_option = 0;
|
||||
|
||||
for (j = 0; j < ARRAY_SIZE (target_switches); j++)
|
||||
|
|
|
@ -218,11 +218,11 @@ static int
|
|||
parse_number (olen)
|
||||
int olen;
|
||||
{
|
||||
register const char *p = lexptr;
|
||||
register long n = 0;
|
||||
register int c;
|
||||
register int base = 10;
|
||||
register int len = olen;
|
||||
const char *p = lexptr;
|
||||
long n = 0;
|
||||
int c;
|
||||
int base = 10;
|
||||
int len = olen;
|
||||
|
||||
for (c = 0; c < len; c++)
|
||||
if (p[c] == '.') {
|
||||
|
@ -310,10 +310,10 @@ static const struct token tokentab2[] = {
|
|||
static int
|
||||
yylex ()
|
||||
{
|
||||
register int c;
|
||||
register int namelen;
|
||||
register const char *tokstart;
|
||||
register const struct token *toktab;
|
||||
int c;
|
||||
int namelen;
|
||||
const char *tokstart;
|
||||
const struct token *toktab;
|
||||
|
||||
retry:
|
||||
|
||||
|
@ -440,7 +440,7 @@ static int
|
|||
parse_escape (string_ptr)
|
||||
const char **string_ptr;
|
||||
{
|
||||
register int c = *(*string_ptr)++;
|
||||
int c = *(*string_ptr)++;
|
||||
switch (c)
|
||||
{
|
||||
case 'a':
|
||||
|
@ -481,8 +481,8 @@ parse_escape (string_ptr)
|
|||
case '6':
|
||||
case '7':
|
||||
{
|
||||
register int i = c - '0';
|
||||
register int count = 0;
|
||||
int i = c - '0';
|
||||
int count = 0;
|
||||
while (++count < 3)
|
||||
{
|
||||
c = *(*string_ptr)++;
|
||||
|
@ -503,7 +503,7 @@ parse_escape (string_ptr)
|
|||
}
|
||||
case 'x':
|
||||
{
|
||||
register int i = 0;
|
||||
int i = 0;
|
||||
for (;;)
|
||||
{
|
||||
c = *(*string_ptr)++;
|
||||
|
|
158
gcc/tradcpp.c
158
gcc/tradcpp.c
|
@ -1075,8 +1075,8 @@ static void
|
|||
newline_fix (bp)
|
||||
U_CHAR *bp;
|
||||
{
|
||||
register U_CHAR *p = bp;
|
||||
register int count = 0;
|
||||
U_CHAR *p = bp;
|
||||
int count = 0;
|
||||
|
||||
/* First count the backslash-newline pairs here. */
|
||||
|
||||
|
@ -1110,8 +1110,8 @@ static void
|
|||
name_newline_fix (bp)
|
||||
U_CHAR *bp;
|
||||
{
|
||||
register U_CHAR *p = bp;
|
||||
register int count = 0;
|
||||
U_CHAR *p = bp;
|
||||
int count = 0;
|
||||
|
||||
/* First count the backslash-newline pairs here. */
|
||||
|
||||
|
@ -1181,25 +1181,25 @@ rescan (op, output_marks)
|
|||
int output_marks;
|
||||
{
|
||||
/* Character being scanned in main loop. */
|
||||
register U_CHAR c;
|
||||
U_CHAR c;
|
||||
|
||||
/* Length of pending accumulated identifier. */
|
||||
register int ident_length = 0;
|
||||
int ident_length = 0;
|
||||
|
||||
/* Hash code of pending accumulated identifier. */
|
||||
register int hash = 0;
|
||||
int hash = 0;
|
||||
|
||||
/* Current input level (&instack[indepth]). */
|
||||
FILE_BUF *ip;
|
||||
|
||||
/* Pointer for scanning input. */
|
||||
register U_CHAR *ibp;
|
||||
U_CHAR *ibp;
|
||||
|
||||
/* Pointer to end of input. End of scan is controlled by LIMIT. */
|
||||
register U_CHAR *limit;
|
||||
U_CHAR *limit;
|
||||
|
||||
/* Pointer for storing output. */
|
||||
register U_CHAR *obp;
|
||||
U_CHAR *obp;
|
||||
|
||||
/* REDO_CHAR is nonzero if we are processing an identifier
|
||||
after backing up over the terminating character.
|
||||
|
@ -1629,7 +1629,7 @@ specialchar:
|
|||
randomchar:
|
||||
|
||||
if (ident_length > 0) {
|
||||
register HASHNODE *hp;
|
||||
HASHNODE *hp;
|
||||
|
||||
/* We have just seen an identifier end. If it's a macro, expand it.
|
||||
|
||||
|
@ -1654,9 +1654,9 @@ randomchar:
|
|||
/* obufp_before_macroname is used only in this block,
|
||||
but it has to be global because of RECACHE. */
|
||||
int op_lineno_before_macroname;
|
||||
register int i = ident_length;
|
||||
register U_CHAR *p = hp->name;
|
||||
register U_CHAR *q = obp - i;
|
||||
int i = ident_length;
|
||||
U_CHAR *p = hp->name;
|
||||
U_CHAR *q = obp - i;
|
||||
|
||||
if (! redo_char)
|
||||
q--;
|
||||
|
@ -1821,7 +1821,7 @@ expand_to_temp_buffer (buf, limit, output_marks)
|
|||
const U_CHAR *buf, *limit;
|
||||
int output_marks;
|
||||
{
|
||||
register FILE_BUF *ip;
|
||||
FILE_BUF *ip;
|
||||
FILE_BUF obuf;
|
||||
int length = limit - buf;
|
||||
U_CHAR *buf1;
|
||||
|
@ -1834,8 +1834,8 @@ expand_to_temp_buffer (buf, limit, output_marks)
|
|||
|
||||
buf1 = (U_CHAR *) alloca (length + 1);
|
||||
{
|
||||
register const U_CHAR *p1 = buf;
|
||||
register U_CHAR *p2 = buf1;
|
||||
const U_CHAR *p1 = buf;
|
||||
U_CHAR *p2 = buf1;
|
||||
|
||||
while (p1 != limit)
|
||||
*p2++ = *p1++;
|
||||
|
@ -1898,9 +1898,9 @@ static int
|
|||
handle_directive (ip, op)
|
||||
FILE_BUF *ip, *op;
|
||||
{
|
||||
register U_CHAR *bp, *cp;
|
||||
register struct directive *kt;
|
||||
register int ident_length;
|
||||
U_CHAR *bp, *cp;
|
||||
struct directive *kt;
|
||||
int ident_length;
|
||||
U_CHAR *resume_p;
|
||||
|
||||
/* Nonzero means we must copy the entire command
|
||||
|
@ -1957,8 +1957,8 @@ handle_directive (ip, op)
|
|||
for (kt = directive_table; kt->length > 0; kt++) {
|
||||
if (kt->length == ident_length
|
||||
&& !strncmp (kt->name, (const char *)ident, ident_length)) {
|
||||
register U_CHAR *buf;
|
||||
register U_CHAR *limit = ip->buf + ip->length;
|
||||
U_CHAR *buf;
|
||||
U_CHAR *limit = ip->buf + ip->length;
|
||||
int unterminated = 0;
|
||||
|
||||
/* Nonzero means do not delete comments within the directive.
|
||||
|
@ -1972,7 +1972,7 @@ handle_directive (ip, op)
|
|||
|
||||
buf = bp = after_ident;
|
||||
while (bp < limit) {
|
||||
register U_CHAR c = *bp++;
|
||||
U_CHAR c = *bp++;
|
||||
switch (c) {
|
||||
case '\\':
|
||||
if (bp < limit) {
|
||||
|
@ -2036,7 +2036,7 @@ handle_directive (ip, op)
|
|||
A comment may come between. */
|
||||
|
||||
if (copy_command) {
|
||||
register U_CHAR *xp = buf;
|
||||
U_CHAR *xp = buf;
|
||||
/* Need to copy entire command into temp buffer before dispatching */
|
||||
|
||||
cp = (U_CHAR *) alloca (bp - buf + 5); /* room for cmd plus
|
||||
|
@ -2047,7 +2047,7 @@ handle_directive (ip, op)
|
|||
and backslash-newlines (and whitespace surrounding the latter). */
|
||||
|
||||
while (xp < bp) {
|
||||
register U_CHAR c = *xp++;
|
||||
U_CHAR c = *xp++;
|
||||
*cp++ = c;
|
||||
|
||||
switch (c) {
|
||||
|
@ -2087,7 +2087,7 @@ handle_directive (ip, op)
|
|||
case '\'':
|
||||
case '\"':
|
||||
{
|
||||
register const U_CHAR *bp1
|
||||
const U_CHAR *bp1
|
||||
= skip_quoted_string (xp - 1, limit, ip->lineno, 0, 0, 0);
|
||||
while (xp != bp1)
|
||||
*cp++ = *xp++;
|
||||
|
@ -2825,9 +2825,9 @@ static int
|
|||
compare_defs (d1, d2)
|
||||
DEFINITION *d1, *d2;
|
||||
{
|
||||
register struct reflist *a1, *a2;
|
||||
register U_CHAR *p1 = d1->expansion;
|
||||
register U_CHAR *p2 = d2->expansion;
|
||||
struct reflist *a1, *a2;
|
||||
U_CHAR *p1 = d1->expansion;
|
||||
U_CHAR *p2 = d2->expansion;
|
||||
int first = 1;
|
||||
|
||||
if (d1->nargs != d2->nargs)
|
||||
|
@ -2871,8 +2871,8 @@ comp_def_part (first, beg1, len1, beg2, len2, last)
|
|||
int len1, len2;
|
||||
int last;
|
||||
{
|
||||
register const U_CHAR *end1 = beg1 + len1;
|
||||
register const U_CHAR *end2 = beg2 + len2;
|
||||
const U_CHAR *end1 = beg1 + len1;
|
||||
const U_CHAR *end2 = beg2 + len2;
|
||||
if (first) {
|
||||
while (beg1 != end1 && is_space (*beg1)) beg1++;
|
||||
while (beg2 != end2 && is_space (*beg2)) beg2++;
|
||||
|
@ -2920,7 +2920,7 @@ collect_expansion (buf, end, nargs, arglist)
|
|||
struct arglist *arglist;
|
||||
{
|
||||
DEFINITION *defn;
|
||||
register U_CHAR *p, *limit, *lastp, *exp_p;
|
||||
U_CHAR *p, *limit, *lastp, *exp_p;
|
||||
struct reflist *endpat = NULL;
|
||||
/* Pointer to first nonspace after last ## seen. */
|
||||
U_CHAR *concat = 0;
|
||||
|
@ -2969,7 +2969,7 @@ collect_expansion (buf, end, nargs, arglist)
|
|||
/* Process the main body of the definition. */
|
||||
while (p < limit) {
|
||||
int skipped_arg = 0;
|
||||
register U_CHAR c = *p++;
|
||||
U_CHAR c = *p++;
|
||||
|
||||
*exp_p++ = c;
|
||||
|
||||
|
@ -3020,7 +3020,7 @@ collect_expansion (buf, end, nargs, arglist)
|
|||
id_len = p - id_beg;
|
||||
|
||||
if (is_idstart (c)) {
|
||||
register struct arglist *arg;
|
||||
struct arglist *arg;
|
||||
|
||||
for (arg = arglist; arg != NULL; arg = arg->next) {
|
||||
struct reflist *tpat;
|
||||
|
@ -3046,7 +3046,7 @@ collect_expansion (buf, end, nargs, arglist)
|
|||
tpat->argno = arg->argno;
|
||||
tpat->nchars = exp_p - lastp;
|
||||
{
|
||||
register U_CHAR *p1 = p;
|
||||
U_CHAR *p1 = p;
|
||||
SKIP_WHITE_SPACE (p1);
|
||||
if (p1 + 2 <= limit && p1[0] == '#' && p1[1] == '#')
|
||||
tpat->raw_after = 1;
|
||||
|
@ -3060,7 +3060,7 @@ collect_expansion (buf, end, nargs, arglist)
|
|||
|
||||
/* If this was not a macro arg, copy it into the expansion. */
|
||||
if (! skipped_arg) {
|
||||
register U_CHAR *lim1 = p;
|
||||
U_CHAR *lim1 = p;
|
||||
p = id_beg;
|
||||
while (p != lim1)
|
||||
*exp_p++ = *p++;
|
||||
|
@ -3098,7 +3098,7 @@ do_line (buf, limit, op)
|
|||
U_CHAR *buf, *limit;
|
||||
FILE_BUF *op;
|
||||
{
|
||||
register U_CHAR *bp;
|
||||
U_CHAR *bp;
|
||||
FILE_BUF *ip = &instack[indepth];
|
||||
FILE_BUF tem;
|
||||
int new_lineno;
|
||||
|
@ -3677,8 +3677,8 @@ skip_if_group (ip, any)
|
|||
FILE_BUF *ip;
|
||||
int any;
|
||||
{
|
||||
register U_CHAR *bp = ip->bufp, *cp;
|
||||
register U_CHAR *endb = ip->buf + ip->length;
|
||||
U_CHAR *bp = ip->bufp, *cp;
|
||||
U_CHAR *endb = ip->buf + ip->length;
|
||||
struct directive *kt;
|
||||
IF_STACK_FRAME *save_if_stack = if_stack; /* don't pop past here */
|
||||
U_CHAR *beg_of_line = bp;
|
||||
|
@ -3897,11 +3897,11 @@ do_endif (buf, limit, op)
|
|||
*/
|
||||
static U_CHAR *
|
||||
skip_to_end_of_comment (ip, line_counter)
|
||||
register FILE_BUF *ip;
|
||||
FILE_BUF *ip;
|
||||
int *line_counter; /* place to remember newlines, or NULL */
|
||||
{
|
||||
register U_CHAR *limit = ip->buf + ip->length;
|
||||
register U_CHAR *bp = ip->bufp;
|
||||
U_CHAR *limit = ip->buf + ip->length;
|
||||
U_CHAR *bp = ip->bufp;
|
||||
FILE_BUF *op = &outbuf; /* JF */
|
||||
int output = put_out_comments && !line_counter;
|
||||
|
||||
|
@ -3960,14 +3960,14 @@ skip_to_end_of_comment (ip, line_counter)
|
|||
*/
|
||||
static U_CHAR *
|
||||
skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p, eofp)
|
||||
register const U_CHAR *bp;
|
||||
register const U_CHAR *limit;
|
||||
const U_CHAR *bp;
|
||||
const U_CHAR *limit;
|
||||
int start_line;
|
||||
int *count_newlines;
|
||||
int *backslash_newlines_p;
|
||||
int *eofp;
|
||||
{
|
||||
register U_CHAR c, match;
|
||||
U_CHAR c, match;
|
||||
|
||||
match = *bp++;
|
||||
while (1) {
|
||||
|
@ -4076,7 +4076,7 @@ macroexpand (hp, op)
|
|||
{
|
||||
int nargs;
|
||||
DEFINITION *defn = hp->value.defn;
|
||||
register U_CHAR *xbuf;
|
||||
U_CHAR *xbuf;
|
||||
int xbuf_len;
|
||||
int start_line = instack[indepth].lineno;
|
||||
|
||||
|
@ -4091,7 +4091,7 @@ macroexpand (hp, op)
|
|||
nargs = defn->nargs;
|
||||
|
||||
if (nargs >= 0) {
|
||||
register int i;
|
||||
int i;
|
||||
struct argdata *args;
|
||||
const char *parse_error = 0;
|
||||
|
||||
|
@ -4123,8 +4123,8 @@ macroexpand (hp, op)
|
|||
|
||||
/* If we got one arg but it was just whitespace, call that 0 args. */
|
||||
if (i == 1) {
|
||||
register const U_CHAR *bp = args[0].raw;
|
||||
register const U_CHAR *lim = bp + args[0].raw_length;
|
||||
const U_CHAR *bp = args[0].raw;
|
||||
const U_CHAR *lim = bp + args[0].raw_length;
|
||||
while (bp != lim && is_space (*bp)) bp++;
|
||||
if (bp == lim)
|
||||
i = 0;
|
||||
|
@ -4154,12 +4154,12 @@ macroexpand (hp, op)
|
|||
xbuf = defn->expansion;
|
||||
xbuf_len = defn->length;
|
||||
} else {
|
||||
register U_CHAR *exp = defn->expansion;
|
||||
register int offset; /* offset in expansion,
|
||||
U_CHAR *exp = defn->expansion;
|
||||
int offset; /* offset in expansion,
|
||||
copied a piece at a time */
|
||||
register int totlen; /* total amount of exp buffer filled so far */
|
||||
int totlen; /* total amount of exp buffer filled so far */
|
||||
|
||||
register struct reflist *ap;
|
||||
struct reflist *ap;
|
||||
|
||||
/* Macro really takes args. Compute the expansion of this call. */
|
||||
|
||||
|
@ -4181,7 +4181,7 @@ macroexpand (hp, op)
|
|||
of where we are copying from. */
|
||||
offset = totlen = 0;
|
||||
for (ap = defn->pattern; ap != NULL; ap = ap->next) {
|
||||
register struct argdata *arg = &args[ap->argno];
|
||||
struct argdata *arg = &args[ap->argno];
|
||||
|
||||
for (i = 0; i < ap->nchars; i++)
|
||||
xbuf[totlen++] = exp[offset++];
|
||||
|
@ -4312,7 +4312,7 @@ macroexpand (hp, op)
|
|||
/* Now put the expansion on the input stack
|
||||
so our caller will commence reading from it. */
|
||||
{
|
||||
register FILE_BUF *ip2;
|
||||
FILE_BUF *ip2;
|
||||
|
||||
ip2 = &instack[++indepth];
|
||||
|
||||
|
@ -4334,7 +4334,7 @@ macroexpand (hp, op)
|
|||
|
||||
static const char *
|
||||
macarg (argptr)
|
||||
register struct argdata *argptr;
|
||||
struct argdata *argptr;
|
||||
{
|
||||
FILE_BUF *ip = &instack[indepth];
|
||||
int paren = 0;
|
||||
|
@ -4420,8 +4420,8 @@ macarg (argptr)
|
|||
|
||||
if (argptr != 0) {
|
||||
FILE_BUF obuf;
|
||||
register const U_CHAR *buf, *lim;
|
||||
register int totlen;
|
||||
const U_CHAR *buf, *lim;
|
||||
int totlen;
|
||||
|
||||
obuf = expand_to_temp_buffer (argptr->raw,
|
||||
argptr->raw + argptr->raw_length,
|
||||
|
@ -4436,7 +4436,7 @@ macarg (argptr)
|
|||
|
||||
totlen = 0;
|
||||
while (buf != lim) {
|
||||
register U_CHAR c = *buf++;
|
||||
U_CHAR c = *buf++;
|
||||
totlen++;
|
||||
/* Internal sequences of whitespace are replaced by one space
|
||||
in most cases, but not always. So count all the whitespace
|
||||
|
@ -4466,10 +4466,10 @@ macarg (argptr)
|
|||
static U_CHAR *
|
||||
macarg1 (start, limit, depthptr, newlines, comments)
|
||||
U_CHAR *start;
|
||||
register const U_CHAR *limit;
|
||||
const U_CHAR *limit;
|
||||
int *depthptr, *newlines, *comments;
|
||||
{
|
||||
register U_CHAR *bp = start;
|
||||
U_CHAR *bp = start;
|
||||
|
||||
while (bp < limit) {
|
||||
switch (*bp) {
|
||||
|
@ -4557,10 +4557,10 @@ discard_comments (start, length, newlines)
|
|||
int length;
|
||||
int newlines;
|
||||
{
|
||||
register U_CHAR *ibp;
|
||||
register U_CHAR *obp;
|
||||
register const U_CHAR *limit;
|
||||
register int c;
|
||||
U_CHAR *ibp;
|
||||
U_CHAR *obp;
|
||||
const U_CHAR *limit;
|
||||
int c;
|
||||
|
||||
/* If we have newlines to duplicate, copy everything
|
||||
that many characters up. Then, in the second part,
|
||||
|
@ -4797,10 +4797,10 @@ line_for_error (line)
|
|||
|
||||
static void
|
||||
grow_outbuf (obuf, needed)
|
||||
register FILE_BUF *obuf;
|
||||
register int needed;
|
||||
FILE_BUF *obuf;
|
||||
int needed;
|
||||
{
|
||||
register U_CHAR *p;
|
||||
U_CHAR *p;
|
||||
int minsize;
|
||||
|
||||
if (obuf->length - (obuf->bufp - obuf->buf) > needed)
|
||||
|
@ -4844,9 +4844,9 @@ install (name, len, type, hash)
|
|||
int hash;
|
||||
/* watch out here if sizeof (U_CHAR *) != sizeof (int) */
|
||||
{
|
||||
register HASHNODE *hp;
|
||||
register int bucket;
|
||||
register const U_CHAR *p;
|
||||
HASHNODE *hp;
|
||||
int bucket;
|
||||
const U_CHAR *p;
|
||||
U_CHAR *q;
|
||||
|
||||
if (len < 0) {
|
||||
|
@ -4891,8 +4891,8 @@ lookup (name, len, hash)
|
|||
int len;
|
||||
int hash;
|
||||
{
|
||||
register const U_CHAR *bp;
|
||||
register HASHNODE *bucket;
|
||||
const U_CHAR *bp;
|
||||
HASHNODE *bucket;
|
||||
|
||||
if (len < 0) {
|
||||
for (bp = name; is_idchar (*bp); bp++) ;
|
||||
|
@ -4949,11 +4949,11 @@ delete_macro (hp)
|
|||
*/
|
||||
static int
|
||||
hashf (name, len, hashsize)
|
||||
register const U_CHAR *name;
|
||||
register int len;
|
||||
const U_CHAR *name;
|
||||
int len;
|
||||
int hashsize;
|
||||
{
|
||||
register int r = 0;
|
||||
int r = 0;
|
||||
|
||||
while (len--)
|
||||
r = HASHSTEP (r, *name++);
|
||||
|
@ -4969,11 +4969,11 @@ dump_all_macros ()
|
|||
int bucket;
|
||||
|
||||
for (bucket = 0; bucket < HASHSIZE; bucket++) {
|
||||
register HASHNODE *hp;
|
||||
HASHNODE *hp;
|
||||
|
||||
for (hp = hashtab[bucket]; hp; hp= hp->next) {
|
||||
if (hp->type == T_MACRO) {
|
||||
register DEFINITION *defn = hp->value.defn;
|
||||
DEFINITION *defn = hp->value.defn;
|
||||
struct reflist *ap;
|
||||
int offset;
|
||||
int concat;
|
||||
|
@ -5055,7 +5055,7 @@ dump_arg_n (defn, argnum)
|
|||
DEFINITION *defn;
|
||||
int argnum;
|
||||
{
|
||||
register const U_CHAR *p = defn->argnames;
|
||||
const U_CHAR *p = defn->argnames;
|
||||
while (argnum + 1 < defn->nargs) {
|
||||
p = (const U_CHAR *) strchr ((const char *)p, ' ') + 1;
|
||||
argnum++;
|
||||
|
|
146
gcc/tree.c
146
gcc/tree.c
|
@ -326,11 +326,11 @@ tree
|
|||
make_node (code)
|
||||
enum tree_code code;
|
||||
{
|
||||
register tree t;
|
||||
register int type = TREE_CODE_CLASS (code);
|
||||
register size_t length;
|
||||
tree t;
|
||||
int type = TREE_CODE_CLASS (code);
|
||||
size_t length;
|
||||
#ifdef GATHER_STATISTICS
|
||||
register tree_node_kind kind;
|
||||
tree_node_kind kind;
|
||||
#endif
|
||||
struct tree_common ttmp;
|
||||
|
||||
|
@ -485,9 +485,9 @@ tree
|
|||
copy_node (node)
|
||||
tree node;
|
||||
{
|
||||
register tree t;
|
||||
register enum tree_code code = TREE_CODE (node);
|
||||
register size_t length;
|
||||
tree t;
|
||||
enum tree_code code = TREE_CODE (node);
|
||||
size_t length;
|
||||
|
||||
length = tree_size (node);
|
||||
t = ggc_alloc_tree (length);
|
||||
|
@ -521,7 +521,7 @@ copy_list (list)
|
|||
tree list;
|
||||
{
|
||||
tree head;
|
||||
register tree prev, next;
|
||||
tree prev, next;
|
||||
|
||||
if (list == 0)
|
||||
return 0;
|
||||
|
@ -549,7 +549,7 @@ build_int_2_wide (low, hi)
|
|||
unsigned HOST_WIDE_INT low;
|
||||
HOST_WIDE_INT hi;
|
||||
{
|
||||
register tree t = make_node (INTEGER_CST);
|
||||
tree t = make_node (INTEGER_CST);
|
||||
|
||||
TREE_INT_CST_LOW (t) = low;
|
||||
TREE_INT_CST_HIGH (t) = hi;
|
||||
|
@ -713,7 +713,7 @@ build_string (len, str)
|
|||
int len;
|
||||
const char *str;
|
||||
{
|
||||
register tree s = make_node (STRING_CST);
|
||||
tree s = make_node (STRING_CST);
|
||||
|
||||
TREE_STRING_LENGTH (s) = len;
|
||||
TREE_STRING_POINTER (s) = ggc_alloc_string (str, len);
|
||||
|
@ -731,7 +731,7 @@ build_complex (type, real, imag)
|
|||
tree type;
|
||||
tree real, imag;
|
||||
{
|
||||
register tree t = make_node (COMPLEX_CST);
|
||||
tree t = make_node (COMPLEX_CST);
|
||||
|
||||
TREE_REALPART (t) = real;
|
||||
TREE_IMAGPART (t) = imag;
|
||||
|
@ -748,8 +748,8 @@ tree
|
|||
make_tree_vec (len)
|
||||
int len;
|
||||
{
|
||||
register tree t;
|
||||
register int length = (len-1) * sizeof (tree) + sizeof (struct tree_vec);
|
||||
tree t;
|
||||
int length = (len-1) * sizeof (tree) + sizeof (struct tree_vec);
|
||||
|
||||
#ifdef GATHER_STATISTICS
|
||||
tree_node_counts[(int)vec_kind]++;
|
||||
|
@ -808,8 +808,8 @@ int
|
|||
integer_all_onesp (expr)
|
||||
tree expr;
|
||||
{
|
||||
register int prec;
|
||||
register int uns;
|
||||
int prec;
|
||||
int uns;
|
||||
|
||||
STRIP_NOPS (expr);
|
||||
|
||||
|
@ -1148,8 +1148,8 @@ int
|
|||
list_length (t)
|
||||
tree t;
|
||||
{
|
||||
register tree tail;
|
||||
register int len = 0;
|
||||
tree tail;
|
||||
int len = 0;
|
||||
|
||||
for (tail = t; tail; tail = TREE_CHAIN (tail))
|
||||
len++;
|
||||
|
@ -1184,9 +1184,9 @@ chainon (op1, op2)
|
|||
|
||||
if (op1)
|
||||
{
|
||||
register tree t1;
|
||||
tree t1;
|
||||
#ifdef ENABLE_TREE_CHECKING
|
||||
register tree t2;
|
||||
tree t2;
|
||||
#endif
|
||||
|
||||
for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
|
||||
|
@ -1207,9 +1207,9 @@ chainon (op1, op2)
|
|||
|
||||
tree
|
||||
tree_last (chain)
|
||||
register tree chain;
|
||||
tree chain;
|
||||
{
|
||||
register tree next;
|
||||
tree next;
|
||||
if (chain)
|
||||
while ((next = TREE_CHAIN (chain)))
|
||||
chain = next;
|
||||
|
@ -1223,7 +1223,7 @@ tree
|
|||
nreverse (t)
|
||||
tree t;
|
||||
{
|
||||
register tree prev = 0, decl, next;
|
||||
tree prev = 0, decl, next;
|
||||
for (decl = t; decl; decl = next)
|
||||
{
|
||||
next = TREE_CHAIN (decl);
|
||||
|
@ -1265,7 +1265,7 @@ tree
|
|||
build_tree_list (parm, value)
|
||||
tree parm, value;
|
||||
{
|
||||
register tree t = make_node (TREE_LIST);
|
||||
tree t = make_node (TREE_LIST);
|
||||
TREE_PURPOSE (t) = parm;
|
||||
TREE_VALUE (t) = value;
|
||||
return t;
|
||||
|
@ -1279,7 +1279,7 @@ tree
|
|||
tree_cons (purpose, value, chain)
|
||||
tree purpose, value, chain;
|
||||
{
|
||||
register tree node;
|
||||
tree node;
|
||||
|
||||
node = ggc_alloc_tree (sizeof (struct tree_list));
|
||||
|
||||
|
@ -1548,7 +1548,7 @@ tree
|
|||
save_expr (expr)
|
||||
tree expr;
|
||||
{
|
||||
register tree t = fold (expr);
|
||||
tree t = fold (expr);
|
||||
|
||||
/* We don't care about whether this can be used as an lvalue in this
|
||||
context. */
|
||||
|
@ -1833,7 +1833,7 @@ int
|
|||
contains_placeholder_p (exp)
|
||||
tree exp;
|
||||
{
|
||||
register enum tree_code code;
|
||||
enum tree_code code;
|
||||
int result;
|
||||
|
||||
if (!exp)
|
||||
|
@ -2158,8 +2158,8 @@ tree
|
|||
stabilize_reference (ref)
|
||||
tree ref;
|
||||
{
|
||||
register tree result;
|
||||
register enum tree_code code = TREE_CODE (ref);
|
||||
tree result;
|
||||
enum tree_code code = TREE_CODE (ref);
|
||||
|
||||
switch (code)
|
||||
{
|
||||
|
@ -2256,8 +2256,8 @@ tree
|
|||
stabilize_reference_1 (e)
|
||||
tree e;
|
||||
{
|
||||
register tree result;
|
||||
register enum tree_code code = TREE_CODE (e);
|
||||
tree result;
|
||||
enum tree_code code = TREE_CODE (e);
|
||||
|
||||
/* We cannot ignore const expressions because it might be a reference
|
||||
to a const array but whose index contains side-effects. But we can
|
||||
|
@ -2331,9 +2331,9 @@ stabilize_reference_1 (e)
|
|||
tree
|
||||
build VPARAMS ((enum tree_code code, tree tt, ...))
|
||||
{
|
||||
register tree t;
|
||||
register int length;
|
||||
register int i;
|
||||
tree t;
|
||||
int length;
|
||||
int i;
|
||||
int fro;
|
||||
int constant;
|
||||
|
||||
|
@ -2361,8 +2361,8 @@ build VPARAMS ((enum tree_code code, tree tt, ...))
|
|||
if (length == 2)
|
||||
{
|
||||
/* This is equivalent to the loop below, but faster. */
|
||||
register tree arg0 = va_arg (p, tree);
|
||||
register tree arg1 = va_arg (p, tree);
|
||||
tree arg0 = va_arg (p, tree);
|
||||
tree arg1 = va_arg (p, tree);
|
||||
|
||||
TREE_OPERAND (t, 0) = arg0;
|
||||
TREE_OPERAND (t, 1) = arg1;
|
||||
|
@ -2389,7 +2389,7 @@ build VPARAMS ((enum tree_code code, tree tt, ...))
|
|||
}
|
||||
else if (length == 1)
|
||||
{
|
||||
register tree arg0 = va_arg (p, tree);
|
||||
tree arg0 = va_arg (p, tree);
|
||||
|
||||
/* The only one-operand cases we handle here are those with side-effects.
|
||||
Others are handled with build1. So don't bother checked if the
|
||||
|
@ -2404,7 +2404,7 @@ build VPARAMS ((enum tree_code code, tree tt, ...))
|
|||
{
|
||||
for (i = 0; i < length; i++)
|
||||
{
|
||||
register tree operand = va_arg (p, tree);
|
||||
tree operand = va_arg (p, tree);
|
||||
|
||||
TREE_OPERAND (t, i) = operand;
|
||||
if (operand && fro > i)
|
||||
|
@ -2432,11 +2432,11 @@ build1 (code, type, node)
|
|||
tree type;
|
||||
tree node;
|
||||
{
|
||||
register int length;
|
||||
int length;
|
||||
#ifdef GATHER_STATISTICS
|
||||
register tree_node_kind kind;
|
||||
tree_node_kind kind;
|
||||
#endif
|
||||
register tree t;
|
||||
tree t;
|
||||
|
||||
#ifdef GATHER_STATISTICS
|
||||
if (TREE_CODE_CLASS (code) == 'r')
|
||||
|
@ -2507,9 +2507,9 @@ build1 (code, type, node)
|
|||
tree
|
||||
build_nt VPARAMS ((enum tree_code code, ...))
|
||||
{
|
||||
register tree t;
|
||||
register int length;
|
||||
register int i;
|
||||
tree t;
|
||||
int length;
|
||||
int i;
|
||||
|
||||
VA_OPEN (p, code);
|
||||
VA_FIXEDARG (p, enum tree_code, code);
|
||||
|
@ -2535,7 +2535,7 @@ build_decl (code, name, type)
|
|||
enum tree_code code;
|
||||
tree name, type;
|
||||
{
|
||||
register tree t;
|
||||
tree t;
|
||||
|
||||
t = make_node (code);
|
||||
|
||||
|
@ -2563,7 +2563,7 @@ tree
|
|||
build_block (vars, tags, subblocks, supercontext, chain)
|
||||
tree vars, tags ATTRIBUTE_UNUSED, subblocks, supercontext, chain;
|
||||
{
|
||||
register tree block = make_node (BLOCK);
|
||||
tree block = make_node (BLOCK);
|
||||
|
||||
BLOCK_VARS (block) = vars;
|
||||
BLOCK_SUBBLOCKS (block) = subblocks;
|
||||
|
@ -2585,7 +2585,7 @@ build_expr_wfl (node, file, line, col)
|
|||
{
|
||||
static const char *last_file = 0;
|
||||
static tree last_filenode = NULL_TREE;
|
||||
register tree wfl = make_node (EXPR_WITH_FILE_LOCATION);
|
||||
tree wfl = make_node (EXPR_WITH_FILE_LOCATION);
|
||||
|
||||
EXPR_WFL_NODE (wfl) = node;
|
||||
EXPR_WFL_SET_LINECOL (wfl, line, col);
|
||||
|
@ -2790,7 +2790,7 @@ lookup_attribute (attr_name, list)
|
|||
|
||||
tree
|
||||
merge_attributes (a1, a2)
|
||||
register tree a1, a2;
|
||||
tree a1, a2;
|
||||
{
|
||||
tree attributes;
|
||||
|
||||
|
@ -2979,7 +2979,7 @@ tree
|
|||
build_type_copy (type)
|
||||
tree type;
|
||||
{
|
||||
register tree t, m = TYPE_MAIN_VARIANT (type);
|
||||
tree t, m = TYPE_MAIN_VARIANT (type);
|
||||
|
||||
t = copy_node (type);
|
||||
|
||||
|
@ -3005,7 +3005,7 @@ type_hash_list (list)
|
|||
tree list;
|
||||
{
|
||||
unsigned int hashcode;
|
||||
register tree tail;
|
||||
tree tail;
|
||||
|
||||
for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
|
||||
hashcode += TYPE_HASH (TREE_VALUE (tail));
|
||||
|
@ -3207,7 +3207,7 @@ attribute_hash_list (list)
|
|||
tree list;
|
||||
{
|
||||
unsigned int hashcode;
|
||||
register tree tail;
|
||||
tree tail;
|
||||
|
||||
for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
|
||||
/* ??? Do we want to add in TREE_VALUE too? */
|
||||
|
@ -3238,7 +3238,7 @@ int
|
|||
attribute_list_contained (l1, l2)
|
||||
tree l1, l2;
|
||||
{
|
||||
register tree t1, t2;
|
||||
tree t1, t2;
|
||||
|
||||
/* First check the obvious, maybe the lists are identical. */
|
||||
if (l1 == l2)
|
||||
|
@ -3286,7 +3286,7 @@ int
|
|||
type_list_equal (l1, l2)
|
||||
tree l1, l2;
|
||||
{
|
||||
register tree t1, t2;
|
||||
tree t1, t2;
|
||||
|
||||
for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
|
||||
if (TREE_VALUE (t1) != TREE_VALUE (t2)
|
||||
|
@ -3413,7 +3413,7 @@ int
|
|||
tree_int_cst_msb (t)
|
||||
tree t;
|
||||
{
|
||||
register int prec;
|
||||
int prec;
|
||||
HOST_WIDE_INT h;
|
||||
unsigned HOST_WIDE_INT l;
|
||||
|
||||
|
@ -3472,7 +3472,7 @@ int
|
|||
simple_cst_equal (t1, t2)
|
||||
tree t1, t2;
|
||||
{
|
||||
register enum tree_code code1, code2;
|
||||
enum tree_code code1, code2;
|
||||
int cmp;
|
||||
int i;
|
||||
|
||||
|
@ -3635,7 +3635,7 @@ tree
|
|||
build_pointer_type (to_type)
|
||||
tree to_type;
|
||||
{
|
||||
register tree t = TYPE_POINTER_TO (to_type);
|
||||
tree t = TYPE_POINTER_TO (to_type);
|
||||
|
||||
/* First, if we already have a type for pointers to TO_TYPE, use it. */
|
||||
|
||||
|
@ -3664,7 +3664,7 @@ tree
|
|||
build_reference_type (to_type)
|
||||
tree to_type;
|
||||
{
|
||||
register tree t = TYPE_REFERENCE_TO (to_type);
|
||||
tree t = TYPE_REFERENCE_TO (to_type);
|
||||
|
||||
/* First, if we already have a type for pointers to TO_TYPE, use it. */
|
||||
|
||||
|
@ -3717,7 +3717,7 @@ tree
|
|||
build_index_type (maxval)
|
||||
tree maxval;
|
||||
{
|
||||
register tree itype = make_node (INTEGER_TYPE);
|
||||
tree itype = make_node (INTEGER_TYPE);
|
||||
|
||||
TREE_TYPE (itype) = sizetype;
|
||||
TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
|
||||
|
@ -3744,7 +3744,7 @@ tree
|
|||
build_range_type (type, lowval, highval)
|
||||
tree type, lowval, highval;
|
||||
{
|
||||
register tree itype = make_node (INTEGER_TYPE);
|
||||
tree itype = make_node (INTEGER_TYPE);
|
||||
|
||||
TREE_TYPE (itype) = type;
|
||||
if (type == NULL_TREE)
|
||||
|
@ -3816,7 +3816,7 @@ tree
|
|||
build_array_type (elt_type, index_type)
|
||||
tree elt_type, index_type;
|
||||
{
|
||||
register tree t;
|
||||
tree t;
|
||||
unsigned int hashcode;
|
||||
|
||||
if (TREE_CODE (elt_type) == FUNCTION_TYPE)
|
||||
|
@ -3873,7 +3873,7 @@ tree
|
|||
build_function_type (value_type, arg_types)
|
||||
tree value_type, arg_types;
|
||||
{
|
||||
register tree t;
|
||||
tree t;
|
||||
unsigned int hashcode;
|
||||
|
||||
if (TREE_CODE (value_type) == FUNCTION_TYPE)
|
||||
|
@ -3905,7 +3905,7 @@ tree
|
|||
build_method_type (basetype, type)
|
||||
tree basetype, type;
|
||||
{
|
||||
register tree t;
|
||||
tree t;
|
||||
unsigned int hashcode;
|
||||
|
||||
/* Make a node of the sort we want. */
|
||||
|
@ -3942,7 +3942,7 @@ tree
|
|||
build_offset_type (basetype, type)
|
||||
tree basetype, type;
|
||||
{
|
||||
register tree t;
|
||||
tree t;
|
||||
unsigned int hashcode;
|
||||
|
||||
/* Make a node of the sort we want. */
|
||||
|
@ -3967,7 +3967,7 @@ tree
|
|||
build_complex_type (component_type)
|
||||
tree component_type;
|
||||
{
|
||||
register tree t;
|
||||
tree t;
|
||||
unsigned int hashcode;
|
||||
|
||||
/* Make a node of the sort we want. */
|
||||
|
@ -4045,22 +4045,22 @@ build_complex_type (component_type)
|
|||
|
||||
tree
|
||||
get_unwidened (op, for_type)
|
||||
register tree op;
|
||||
tree op;
|
||||
tree for_type;
|
||||
{
|
||||
/* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
|
||||
register tree type = TREE_TYPE (op);
|
||||
register unsigned final_prec
|
||||
tree type = TREE_TYPE (op);
|
||||
unsigned final_prec
|
||||
= TYPE_PRECISION (for_type != 0 ? for_type : type);
|
||||
register int uns
|
||||
int uns
|
||||
= (for_type != 0 && for_type != type
|
||||
&& final_prec > TYPE_PRECISION (type)
|
||||
&& TREE_UNSIGNED (type));
|
||||
register tree win = op;
|
||||
tree win = op;
|
||||
|
||||
while (TREE_CODE (op) == NOP_EXPR)
|
||||
{
|
||||
register int bitschange
|
||||
int bitschange
|
||||
= TYPE_PRECISION (TREE_TYPE (op))
|
||||
- TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
|
||||
|
||||
|
@ -4138,16 +4138,16 @@ get_unwidened (op, for_type)
|
|||
|
||||
tree
|
||||
get_narrower (op, unsignedp_ptr)
|
||||
register tree op;
|
||||
tree op;
|
||||
int *unsignedp_ptr;
|
||||
{
|
||||
register int uns = 0;
|
||||
int uns = 0;
|
||||
int first = 1;
|
||||
register tree win = op;
|
||||
tree win = op;
|
||||
|
||||
while (TREE_CODE (op) == NOP_EXPR)
|
||||
{
|
||||
register int bitschange
|
||||
int bitschange
|
||||
= (TYPE_PRECISION (TREE_TYPE (op))
|
||||
- TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
|
||||
|
||||
|
|
10
gcc/unroll.c
10
gcc/unroll.c
|
@ -898,7 +898,7 @@ unroll_loop (loop, insn_count, strength_reduce_p)
|
|||
&initial_value, &final_value, &increment,
|
||||
&mode))
|
||||
{
|
||||
register rtx diff;
|
||||
rtx diff;
|
||||
rtx *labels;
|
||||
int abs_inc, neg_inc;
|
||||
|
||||
|
@ -4043,9 +4043,9 @@ remap_split_bivs (loop, x)
|
|||
rtx x;
|
||||
{
|
||||
struct loop_ivs *ivs = LOOP_IVS (loop);
|
||||
register enum rtx_code code;
|
||||
register int i;
|
||||
register const char *fmt;
|
||||
enum rtx_code code;
|
||||
int i;
|
||||
const char *fmt;
|
||||
|
||||
if (x == 0)
|
||||
return x;
|
||||
|
@ -4084,7 +4084,7 @@ remap_split_bivs (loop, x)
|
|||
XEXP (x, i) = remap_split_bivs (loop, XEXP (x, i));
|
||||
else if (fmt[i] == 'E')
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
for (j = 0; j < XVECLEN (x, i); j++)
|
||||
XVECEXP (x, i, j) = remap_split_bivs (loop, XVECEXP (x, i, j));
|
||||
}
|
||||
|
|
76
gcc/varasm.c
76
gcc/varasm.c
|
@ -1477,7 +1477,7 @@ assemble_variable (decl, top_level, at_end, dont_output_data)
|
|||
int at_end ATTRIBUTE_UNUSED;
|
||||
int dont_output_data;
|
||||
{
|
||||
register const char *name;
|
||||
const char *name;
|
||||
unsigned int align;
|
||||
int reloc = 0;
|
||||
rtx decl_rtl;
|
||||
|
@ -2170,7 +2170,7 @@ immed_double_const (i0, i1, mode)
|
|||
HOST_WIDE_INT i0, i1;
|
||||
enum machine_mode mode;
|
||||
{
|
||||
register rtx r;
|
||||
rtx r;
|
||||
|
||||
if (GET_MODE_CLASS (mode) == MODE_INT
|
||||
|| GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
|
||||
|
@ -2262,7 +2262,7 @@ immed_real_const_1 (d, mode)
|
|||
enum machine_mode mode;
|
||||
{
|
||||
union real_extract u;
|
||||
register rtx r;
|
||||
rtx r;
|
||||
|
||||
/* Get the desired `double' value as a sequence of ints
|
||||
since that is how they are stored in a CONST_DOUBLE. */
|
||||
|
@ -2343,7 +2343,7 @@ immed_real_const (exp)
|
|||
void
|
||||
clear_const_double_mem ()
|
||||
{
|
||||
register rtx r, next;
|
||||
rtx r, next;
|
||||
enum machine_mode mode;
|
||||
int i;
|
||||
|
||||
|
@ -2381,9 +2381,9 @@ decode_addr_const (exp, value)
|
|||
tree exp;
|
||||
struct addr_const *value;
|
||||
{
|
||||
register tree target = TREE_OPERAND (exp, 0);
|
||||
register int offset = 0;
|
||||
register rtx x;
|
||||
tree target = TREE_OPERAND (exp, 0);
|
||||
int offset = 0;
|
||||
rtx x;
|
||||
|
||||
while (1)
|
||||
{
|
||||
|
@ -2564,9 +2564,9 @@ static int
|
|||
const_hash (exp)
|
||||
tree exp;
|
||||
{
|
||||
register const char *p;
|
||||
register int len, hi, i;
|
||||
register enum tree_code code = TREE_CODE (exp);
|
||||
const char *p;
|
||||
int len, hi, i;
|
||||
enum tree_code code = TREE_CODE (exp);
|
||||
|
||||
/* Either set P and LEN to the address and len of something to hash and
|
||||
exit the switch or return a value. */
|
||||
|
@ -2605,7 +2605,7 @@ const_hash (exp)
|
|||
}
|
||||
else
|
||||
{
|
||||
register tree link;
|
||||
tree link;
|
||||
|
||||
/* For record type, include the type in the hashing.
|
||||
We do not do so for array types
|
||||
|
@ -2702,9 +2702,9 @@ compare_constant_1 (exp, p)
|
|||
tree exp;
|
||||
const unsigned char *p;
|
||||
{
|
||||
register const unsigned char *strp;
|
||||
register int len;
|
||||
register enum tree_code code = TREE_CODE (exp);
|
||||
const unsigned char *strp;
|
||||
int len;
|
||||
enum tree_code code = TREE_CODE (exp);
|
||||
|
||||
if (code != (enum tree_code) *p++)
|
||||
return 0;
|
||||
|
@ -2771,7 +2771,7 @@ compare_constant_1 (exp, p)
|
|||
}
|
||||
else
|
||||
{
|
||||
register tree link;
|
||||
tree link;
|
||||
int length = list_length (CONSTRUCTOR_ELTS (exp));
|
||||
tree type;
|
||||
enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
|
||||
|
@ -2957,9 +2957,9 @@ static void
|
|||
record_constant_1 (exp)
|
||||
tree exp;
|
||||
{
|
||||
register const unsigned char *strp;
|
||||
register int len;
|
||||
register enum tree_code code = TREE_CODE (exp);
|
||||
const unsigned char *strp;
|
||||
int len;
|
||||
enum tree_code code = TREE_CODE (exp);
|
||||
|
||||
obstack_1grow (&permanent_obstack, (unsigned int) code);
|
||||
|
||||
|
@ -3006,7 +3006,7 @@ record_constant_1 (exp)
|
|||
}
|
||||
else
|
||||
{
|
||||
register tree link;
|
||||
tree link;
|
||||
int length = list_length (CONSTRUCTOR_ELTS (exp));
|
||||
enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
|
||||
tree type;
|
||||
|
@ -3276,8 +3276,8 @@ output_constant_def (exp, defer)
|
|||
tree exp;
|
||||
int defer;
|
||||
{
|
||||
register int hash;
|
||||
register struct constant_descriptor *desc;
|
||||
int hash;
|
||||
struct constant_descriptor *desc;
|
||||
struct deferred_string **defstr;
|
||||
char label[256];
|
||||
int reloc;
|
||||
|
@ -3705,8 +3705,8 @@ const_hash_rtx (mode, x)
|
|||
enum machine_mode mode;
|
||||
rtx x;
|
||||
{
|
||||
register int hi;
|
||||
register size_t i;
|
||||
int hi;
|
||||
size_t i;
|
||||
|
||||
struct rtx_const value;
|
||||
decode_rtx_const (mode, x, &value);
|
||||
|
@ -3730,9 +3730,9 @@ compare_constant_rtx (mode, x, desc)
|
|||
rtx x;
|
||||
struct constant_descriptor *desc;
|
||||
{
|
||||
register int *p = (int *) desc->u.contents;
|
||||
register int *strp;
|
||||
register int len;
|
||||
int *p = (int *) desc->u.contents;
|
||||
int *strp;
|
||||
int len;
|
||||
struct rtx_const value;
|
||||
|
||||
decode_rtx_const (mode, x, &value);
|
||||
|
@ -3773,8 +3773,8 @@ force_const_mem (mode, x)
|
|||
enum machine_mode mode;
|
||||
rtx x;
|
||||
{
|
||||
register int hash;
|
||||
register struct constant_descriptor *desc;
|
||||
int hash;
|
||||
struct constant_descriptor *desc;
|
||||
char label[256];
|
||||
const char *found = 0;
|
||||
rtx def;
|
||||
|
@ -3807,7 +3807,7 @@ force_const_mem (mode, x)
|
|||
|
||||
if (found == 0)
|
||||
{
|
||||
register struct pool_constant *pool;
|
||||
struct pool_constant *pool;
|
||||
int align;
|
||||
|
||||
/* No constant equal to X is known to have been output.
|
||||
|
@ -4081,7 +4081,7 @@ output_constant_pool (fnname, fndecl)
|
|||
static void
|
||||
mark_constant_pool ()
|
||||
{
|
||||
register rtx insn;
|
||||
rtx insn;
|
||||
struct pool_constant *pool;
|
||||
|
||||
if (first_pool == 0 && htab_elements (const_str_htab) == 0)
|
||||
|
@ -4110,8 +4110,8 @@ static void
|
|||
mark_constants (x)
|
||||
rtx x;
|
||||
{
|
||||
register int i;
|
||||
register const char *format_ptr;
|
||||
int i;
|
||||
const char *format_ptr;
|
||||
|
||||
if (x == 0)
|
||||
return;
|
||||
|
@ -4148,7 +4148,7 @@ mark_constants (x)
|
|||
case 'E':
|
||||
if (XVEC (x, i) != 0)
|
||||
{
|
||||
register int j;
|
||||
int j;
|
||||
|
||||
for (j = 0; j < XVECLEN (x, i); j++)
|
||||
mark_constants (XVECEXP (x, i, j));
|
||||
|
@ -4238,7 +4238,7 @@ output_addressed_constants (exp)
|
|||
{
|
||||
case ADDR_EXPR:
|
||||
{
|
||||
register tree constant = TREE_OPERAND (exp, 0);
|
||||
tree constant = TREE_OPERAND (exp, 0);
|
||||
|
||||
while (TREE_CODE (constant) == COMPONENT_REF)
|
||||
{
|
||||
|
@ -4268,7 +4268,7 @@ output_addressed_constants (exp)
|
|||
|
||||
case CONSTRUCTOR:
|
||||
{
|
||||
register tree link;
|
||||
tree link;
|
||||
for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
|
||||
if (TREE_VALUE (link) != 0)
|
||||
reloc |= output_addressed_constants (TREE_VALUE (link));
|
||||
|
@ -4476,7 +4476,7 @@ output_constant (exp, size, align)
|
|||
int size;
|
||||
unsigned int align;
|
||||
{
|
||||
register enum tree_code code = TREE_CODE (TREE_TYPE (exp));
|
||||
enum tree_code code = TREE_CODE (TREE_TYPE (exp));
|
||||
|
||||
/* Some front-ends use constants other than the standard
|
||||
language-indepdent varieties, but which may still be output
|
||||
|
@ -4672,14 +4672,14 @@ output_constructor (exp, size, align)
|
|||
unsigned int align;
|
||||
{
|
||||
tree type = TREE_TYPE (exp);
|
||||
register tree link, field = 0;
|
||||
tree link, field = 0;
|
||||
tree min_index = 0;
|
||||
/* Number of bytes output or skipped so far.
|
||||
In other words, current position within the constructor. */
|
||||
HOST_WIDE_INT total_bytes = 0;
|
||||
/* Non-zero means BYTE contains part of a byte, to be output. */
|
||||
int byte_buffer_in_use = 0;
|
||||
register int byte = 0;
|
||||
int byte = 0;
|
||||
|
||||
if (HOST_BITS_PER_WIDE_INT < BITS_PER_UNIT)
|
||||
abort ();
|
||||
|
|
|
@ -328,7 +328,7 @@ static int do_block = 0;
|
|||
|
||||
static void
|
||||
xcoffout_block (block, depth, args)
|
||||
register tree block;
|
||||
tree block;
|
||||
int depth;
|
||||
tree args;
|
||||
{
|
||||
|
|
Loading…
Reference in New Issue