OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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:
Stan Shebs 2001-10-11 03:16:15 +00:00 committed by Stan Shebs
parent b83018caca
commit b36948478c
90 changed files with 2695 additions and 2591 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

93
gcc/ChangeLog
View File

@ -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
View File

@ -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;

18
gcc/c-common.c
View File

@ -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;

4
gcc/c-convert.c
View File

@ -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
View File

@ -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

4
gcc/c-format.c
View File

@ -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;

6
gcc/c-semantics.c
View File

@ -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
View File

@ -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;

4
gcc/caller-save.c
View File

@ -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
View File

@ -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.

6
gcc/cfg.c
View File

@ -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);

8
gcc/cfgbuild.c
View File

@ -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;

2
gcc/cfgrtl.c
View File

@ -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");

6
gcc/collect2.c
View File

@ -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 },

68
gcc/combine.c
View File

@ -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);

4
gcc/convert.c
View File

@ -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. */

2
gcc/cppexp.c
View File

@ -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;

2
gcc/cppfiles.c
View File

@ -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
View File

@ -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
View File

@ -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;
{

2
gcc/defaults.h
View File

@ -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
View File

@ -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
View File

File diff suppressed because it is too large Load Diff

478
gcc/dwarfout.c
View File

File diff suppressed because it is too large Load Diff

130
gcc/emit-rtl.c
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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;

10
gcc/fix-header.c
View File

@ -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
View File

@ -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
View File

@ -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);

50
gcc/fold-const.c
View File

@ -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);

72
gcc/function.c
View File

@ -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
View File

@ -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 == '|')

6
gcc/gcse.c
View File

@ -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;

2
gcc/gen-protos.c
View File

@ -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;

72
gcc/genattrtab.c
View File

@ -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))

4
gcc/gencheck.c
View File

@ -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)
{

6
gcc/genconfig.c
View File

@ -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;

34
gcc/genemit.c
View File

@ -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");

22
gcc/genextract.c
View File

@ -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");

12
gcc/genflags.c
View File

@ -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;

2
gcc/gengenrtl.c
View File

@ -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)
{

34
gcc/genoutput.c
View File

@ -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;

10
gcc/genpeep.c
View File

@ -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));
}

22
gcc/genrecog.c
View File

@ -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");

12
gcc/gensupport.c
View File

@ -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
View File

@ -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++)

2
gcc/gmon.c
View File

@ -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

2
gcc/graph.c
View File

@ -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;

6
gcc/haifa-sched.c
View File

@ -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++)
{

112
gcc/hard-reg-set.h
View File

@ -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)

2
gcc/hash.c
View File

@ -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;

58
gcc/integrate.c
View File

@ -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
View File

@ -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. */

2
gcc/lists.c
View File

@ -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);

60
gcc/local-alloc.c
View File

@ -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
View File

@ -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);

3
gcc/mips-tdump.c
View File

@ -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
View File

@ -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
View File

@ -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

2
gcc/prefix.c
View File

@ -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;

14
gcc/print-rtl.c
View File

@ -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;

19
gcc/read-rtl.c
View File

@ -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
View File

@ -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
View File

@ -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--)

30
gcc/reg-stack.c
View File

@ -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 = &REG_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)
{

62
gcc/regclass.c
View File

@ -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

2
gcc/regmove.c
View File

@ -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
View File

@ -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;
}

70
gcc/reload1.c
View File

@ -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 < &reg_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
View File

@ -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];

12
gcc/resource.c
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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 = ' ';

28
gcc/sched-deps.c
View File

@ -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;

36
gcc/sched-rgn.c
View File

@ -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
View File

@ -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);

6
gcc/simplify-rtx.c
View File

@ -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
View File

@ -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. */

22
gcc/stor-layout.c
View File

@ -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
View File

@ -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++)

26
gcc/tradcif.y
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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 ();

2
gcc/xcoffout.c
View File

@ -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;
{