diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 1001a5642fb..536a3517e86 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -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.
diff --git a/gcc/alias.c b/gcc/alias.c
index 37a8790c2ee..53de65fab0c 100644
--- a/gcc/alias.c
+++ b/gcc/alias.c
@@ -714,7 +714,7 @@ get_frame_alias_set ()
 
 static rtx
 find_base_value (src)
-     register rtx src;
+     rtx src;
 {
   unsigned int regno;
   switch (GET_CODE (src))
@@ -846,7 +846,7 @@ record_set (dest, set, data)
      rtx dest, set;
      void *data ATTRIBUTE_UNUSED;
 {
-  register unsigned regno;
+  unsigned regno;
   rtx src;
 
   if (GET_CODE (dest) != REG)
@@ -1020,10 +1020,10 @@ static int
 rtx_equal_for_memref_p (x, y)
      rtx x, y;
 {
-  register int i;
-  register int j;
-  register enum rtx_code code;
-  register const char *fmt;
+  int i;
+  int j;
+  enum rtx_code code;
+  const char *fmt;
 
   if (x == 0 && y == 0)
     return 1;
@@ -1149,9 +1149,9 @@ static rtx
 find_symbolic_term (x)
      rtx x;
 {
-  register int i;
-  register enum rtx_code code;
-  register const char *fmt;
+  int i;
+  enum rtx_code code;
+  const char *fmt;
 
   code = GET_CODE (x);
   if (code == SYMBOL_REF || code == LABEL_REF)
@@ -1178,7 +1178,7 @@ find_symbolic_term (x)
 
 static rtx
 find_base_term (x)
-     register rtx x;
+     rtx x;
 {
   cselib_val *val;
   struct elt_loc_list *l;
@@ -1452,7 +1452,7 @@ addr_side_effect_eval (addr, size, n_refs)
 
 static int
 memrefs_conflict_p (xsize, x, ysize, y, c)
-     register rtx x, y;
+     rtx x, y;
      int xsize, ysize;
      HOST_WIDE_INT c;
 {
@@ -1737,7 +1737,7 @@ true_dependence (mem, mem_mode, x, varies)
      rtx x;
      int (*varies) PARAMS ((rtx, int));
 {
-  register rtx x_addr, mem_addr;
+  rtx x_addr, mem_addr;
   rtx base;
 
   if (MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem))
@@ -1810,7 +1810,7 @@ canon_true_dependence (mem, mem_mode, mem_addr, x, varies)
      enum machine_mode mem_mode;
      int (*varies) PARAMS ((rtx, int));
 {
-  register rtx x_addr;
+  rtx x_addr;
 
   if (MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem))
     return 1;
@@ -1929,8 +1929,8 @@ anti_dependence (mem, x)
 
 int
 output_dependence (mem, x)
-     register rtx mem;
-     register rtx x;
+     rtx mem;
+     rtx x;
 {
   return write_dependence_p (mem, x, /*writep=*/1);
 }
@@ -1943,7 +1943,7 @@ nonlocal_mentioned_p (x)
      rtx x;
 {
   rtx base;
-  register RTX_CODE code;
+  RTX_CODE code;
   int regno;
 
   code = GET_CODE (x);
@@ -2047,8 +2047,8 @@ nonlocal_mentioned_p (x)
   /* Recursively scan the operands of this expression.  */
 
   {
-    register const char *fmt = GET_RTX_FORMAT (code);
-    register int i;
+    const char *fmt = GET_RTX_FORMAT (code);
+    int i;
     
     for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
       {
@@ -2059,7 +2059,7 @@ nonlocal_mentioned_p (x)
 	  }
 	else if (fmt[i] == 'E')
 	  {
-	    register int j;
+	    int j;
 	    for (j = 0; j < XVECLEN (x, i); j++)
 	      if (nonlocal_mentioned_p (XVECEXP (x, i, j)))
 		return 1;
@@ -2116,7 +2116,7 @@ static HARD_REG_SET argument_registers;
 void
 init_alias_once ()
 {
-  register int i;
+  int i;
 
 #ifndef OUTGOING_REGNO
 #define OUTGOING_REGNO(N) N
@@ -2140,9 +2140,9 @@ init_alias_analysis ()
 {
   int maxreg = max_reg_num ();
   int changed, pass;
-  register int i;
-  register unsigned int ui;
-  register rtx insn;
+  int i;
+  unsigned int ui;
+  rtx insn;
 
   reg_known_value_size = maxreg;
 
diff --git a/gcc/c-common.c b/gcc/c-common.c
index 5ad4d92f832..67b6e1e6c16 100644
--- a/gcc/c-common.c
+++ b/gcc/c-common.c
@@ -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;
diff --git a/gcc/c-convert.c b/gcc/c-convert.c
index 82b69102878..947c79bcadb 100644
--- a/gcc/c-convert.c
+++ b/gcc/c-convert.c
@@ -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
diff --git a/gcc/c-decl.c b/gcc/c-decl.c
index 79530d77db9..ee45b8ff72a 100644
--- a/gcc/c-decl.c
+++ b/gcc/c-decl.c
@@ -912,7 +912,7 @@ void
 pushlevel (tag_transparent)
      int tag_transparent;
 {
-  register struct binding_level *newlevel = NULL_BINDING_LEVEL;
+  struct binding_level *newlevel = NULL_BINDING_LEVEL;
 
   /* If this is the top level of a function,
      just make sure that NAMED_LABELS is 0.  */
@@ -988,7 +988,7 @@ poplevel (keep, reverse, functionbody)
      int reverse;
      int functionbody;
 {
-  register tree link;
+  tree link;
   /* The chain of decls was accumulated in reverse order.
      Put it into forward order, just for cleanliness.  */
   tree decls;
@@ -1131,7 +1131,7 @@ poplevel (keep, reverse, functionbody)
 
       for (link = named_labels; link; link = TREE_CHAIN (link))
 	{
-	  register tree label = TREE_VALUE (link);
+	  tree label = TREE_VALUE (link);
 
 	  if (DECL_INITIAL (label) == 0)
 	    {
@@ -1154,7 +1154,7 @@ poplevel (keep, reverse, functionbody)
   /* Pop the current level, and free the structure for reuse.  */
 
   {
-    register struct binding_level *level = current_binding_level;
+    struct binding_level *level = current_binding_level;
     current_binding_level = current_binding_level->level_chain;
 
     level->level_chain = free_binding_level;
@@ -1248,7 +1248,7 @@ insert_block (block)
 
 void
 set_block (block)
-     register tree block;
+     tree block;
 {
   current_binding_level->this_block = block;
   current_binding_level->names = chainon (current_binding_level->names,
@@ -1260,7 +1260,7 @@ set_block (block)
 void
 push_label_level ()
 {
-  register struct binding_level *newlevel;
+  struct binding_level *newlevel;
 
   /* Reuse or create a struct for this binding level.  */
 
@@ -1288,7 +1288,7 @@ push_label_level ()
 void
 pop_label_level ()
 {
-  register struct binding_level *level = label_level_chain;
+  struct binding_level *level = label_level_chain;
   tree link, prev;
 
   /* Clear out the definitions of the declared labels in this level.
@@ -1350,7 +1350,7 @@ void
 pushtag (name, type)
      tree name, type;
 {
-  register struct binding_level *b;
+  struct binding_level *b;
 
   /* Find the proper binding level for this type tag.  */
 
@@ -1394,7 +1394,7 @@ pushtag (name, type)
 
 static int
 duplicate_decls (newdecl, olddecl, different_binding_level)
-     register tree newdecl, olddecl;
+     tree newdecl, olddecl;
      int different_binding_level;
 {
   int types_match = comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
@@ -1610,12 +1610,12 @@ duplicate_decls (newdecl, olddecl, different_binding_level)
 	       && DECL_INITIAL (newdecl) == 0)))
 	{
 	  /* Classify the problem further.  */
-	  register tree t = TYPE_ARG_TYPES (oldtype);
+	  tree t = TYPE_ARG_TYPES (oldtype);
 	  if (t == 0)
 	    t = TYPE_ARG_TYPES (newtype);
 	  for (; t; t = TREE_CHAIN (t))
 	    {
-	      register tree type = TREE_VALUE (t);
+	      tree type = TREE_VALUE (t);
 
 	      if (TREE_CHAIN (t) == 0
 		  && TYPE_MAIN_VARIANT (type) != void_type_node)
@@ -1677,8 +1677,8 @@ duplicate_decls (newdecl, olddecl, different_binding_level)
 	       && TYPE_ARG_TYPES (newtype) != 0
 	       && TYPE_ACTUAL_ARG_TYPES (oldtype) != 0)
 	{
-	  register tree type, parm;
-	  register int nargs;
+	  tree type, parm;
+	  int nargs;
 	  /* Prototype decl follows defn w/o prototype.  */
 
 	  for (parm = TYPE_ACTUAL_ARG_TYPES (oldtype),
@@ -2028,7 +2028,7 @@ duplicate_decls (newdecl, olddecl, different_binding_level)
   /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
      But preserve OLDDECL's DECL_UID.  */
   {
-    register unsigned olddecl_uid = DECL_UID (olddecl);
+    unsigned olddecl_uid = DECL_UID (olddecl);
 
     memcpy ((char *) olddecl + sizeof (struct tree_common),
 	    (char *) newdecl + sizeof (struct tree_common),
@@ -2055,9 +2055,9 @@ tree
 pushdecl (x)
      tree x;
 {
-  register tree t;
-  register tree name = DECL_NAME (x);
-  register struct binding_level *b = current_binding_level;
+  tree t;
+  tree name = DECL_NAME (x);
+  struct binding_level *b = current_binding_level;
 
   /* Functions need the lang_decl data.  */
   if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_LANG_SPECIFIC (x))
@@ -2505,8 +2505,8 @@ tree
 pushdecl_top_level (x)
      tree x;
 {
-  register tree t;
-  register struct binding_level *b = current_binding_level;
+  tree t;
+  struct binding_level *b = current_binding_level;
 
   current_binding_level = global_binding_level;
   t = pushdecl (x);
@@ -2669,7 +2669,7 @@ tree
 lookup_label (id)
      tree id;
 {
-  register tree decl = IDENTIFIER_LABEL_VALUE (id);
+  tree decl = IDENTIFIER_LABEL_VALUE (id);
 
   if (current_function_decl == 0)
     {
@@ -2719,11 +2719,11 @@ tree
 shadow_label (name)
      tree name;
 {
-  register tree decl = IDENTIFIER_LABEL_VALUE (name);
+  tree decl = IDENTIFIER_LABEL_VALUE (name);
 
   if (decl != 0)
     {
-      register tree dup;
+      tree dup;
 
       /* Check to make sure that the label hasn't already been declared
 	 at this label scope */
@@ -2843,12 +2843,12 @@ lookup_tag (code, name, binding_level, thislevel_only)
      tree name;
      int thislevel_only;
 {
-  register struct binding_level *level;
+  struct binding_level *level;
   int thislevel = 1;
 
   for (level = binding_level; level; level = level->level_chain)
     {
-      register tree tail;
+      tree tail;
       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
 	{
 	  if (TREE_PURPOSE (tail) == name)
@@ -2902,11 +2902,11 @@ static tree
 lookup_tag_reverse (type)
      tree type;
 {
-  register struct binding_level *level;
+  struct binding_level *level;
 
   for (level = current_binding_level; level; level = level->level_chain)
     {
-      register tree tail;
+      tree tail;
       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
 	{
 	  if (TREE_VALUE (tail) == type)
@@ -2925,7 +2925,7 @@ tree
 lookup_name (name)
      tree name;
 {
-  register tree val;
+  tree val;
 
   if (current_binding_level != global_binding_level
       && IDENTIFIER_LOCAL_VALUE (name))
@@ -2941,7 +2941,7 @@ tree
 lookup_name_current_level (name)
      tree name;
 {
-  register tree t;
+  tree t;
 
   if (current_binding_level == global_binding_level)
     return IDENTIFIER_GLOBAL_VALUE (name);
@@ -2983,7 +2983,7 @@ mark_binding_level (arg)
 void
 init_decl_processing ()
 {
-  register tree endlink;
+  tree endlink;
   tree ptr_ftype_void, ptr_ftype_ptr;
 
   current_function_decl = NULL;
@@ -3210,7 +3210,7 @@ shadow_tag_warned (declspecs, warned)
 	no pedwarn.  */
 {
   int found_tag = 0;
-  register tree link;
+  tree link;
   tree specs, attrs;
 
   pending_invalid_xref = 0;
@@ -3221,15 +3221,15 @@ shadow_tag_warned (declspecs, warned)
 
   for (link = specs; link; link = TREE_CHAIN (link))
     {
-      register tree value = TREE_VALUE (link);
-      register enum tree_code code = TREE_CODE (value);
+      tree value = TREE_VALUE (link);
+      enum tree_code code = TREE_CODE (value);
 
       if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
 	/* Used to test also that TYPE_SIZE (value) != 0.
 	   That caused warning for `struct foo;' at top level in the file.  */
 	{
-	  register tree name = lookup_tag_reverse (value);
-	  register tree t;
+	  tree name = lookup_tag_reverse (value);
+	  tree t;
 
 	  found_tag++;
 
@@ -3376,7 +3376,7 @@ start_decl (declarator, declspecs, initialized, attributes)
 {
   tree decl = grokdeclarator (declarator, declspecs,
 			      NORMAL, initialized);
-  register tree tem;
+  tree tem;
 
   if (warn_main > 0 && TREE_CODE (decl) != FUNCTION_DECL
       && MAIN_NAME_P (DECL_NAME (decl)))
@@ -3516,7 +3516,7 @@ finish_decl (decl, init, asmspec_tree)
      tree decl, init;
      tree asmspec_tree;
 {
-  register tree type = TREE_TYPE (decl);
+  tree type = TREE_TYPE (decl);
   int was_incomplete = (DECL_SIZE (decl) == 0);
   const char *asmspec = 0;
 
@@ -3789,7 +3789,7 @@ complete_array_type (type, initial_value, do_default)
      tree initial_value;
      int do_default;
 {
-  register tree maxindex = NULL_TREE;
+  tree maxindex = NULL_TREE;
   int value = 0;
 
   if (initial_value)
@@ -3918,7 +3918,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized)
   /* Look inside a declarator for the name being declared
      and get it as a string, for an error message.  */
   {
-    register tree decl = declarator;
+    tree decl = declarator;
     name = 0;
 
     while (decl)
@@ -3980,7 +3980,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized)
 
   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
     {
-      register tree id = TREE_VALUE (spec);
+      tree id = TREE_VALUE (spec);
 
       if (id == ridpointers[(int) RID_INT])
 	explicit_int = 1;
@@ -4022,7 +4022,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized)
       /* Built-in types come as identifiers.  */
       else if (TREE_CODE (id) == IDENTIFIER_NODE)
 	{
-	  register tree t = lookup_name (id);
+	  tree t = lookup_name (id);
 	  if (TREE_TYPE (t) == error_mark_node)
 	    ;
 	  else if (!t || TREE_CODE (t) != TYPE_DECL)
@@ -4376,8 +4376,8 @@ grokdeclarator (declarator, declspecs, decl_context, initialized)
 	}
       else if (TREE_CODE (declarator) == ARRAY_REF)
 	{
-	  register tree itype = NULL_TREE;
-	  register tree size = TREE_OPERAND (declarator, 1);
+	  tree itype = NULL_TREE;
+	  tree size = TREE_OPERAND (declarator, 1);
 	  /* The index is a signed object `sizetype' bits wide.  */
 	  tree index_type = signed_type (sizetype);
 
@@ -4613,7 +4613,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized)
 	     the FUNCTION_TYPE node itself.  */
 
 	  {
-	    register tree link;
+	    tree link;
 
 	    for (link = last_function_parm_tags;
 		 link;
@@ -4641,7 +4641,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized)
 
 	  if (TREE_TYPE (declarator))
 	    {
-	      register tree typemodlist;
+	      tree typemodlist;
 	      int erred = 0;
 
 	      constp = 0;
@@ -5155,8 +5155,8 @@ tree
 get_parm_info (void_at_end)
      int void_at_end;
 {
-  register tree decl, t;
-  register tree types = 0;
+  tree decl, t;
+  tree types = 0;
   int erred = 0;
   tree tags = gettags ();
   tree parms = getdecls ();
@@ -5300,7 +5300,7 @@ xref_tag (code, name)
   /* If a cross reference is requested, look up the type
      already defined for this tag and return it.  */
 
-  register tree ref = lookup_tag (code, name, current_binding_level, 0);
+  tree ref = lookup_tag (code, name, current_binding_level, 0);
   /* If this is the right type of tag, return what we found.
      (This reference will be shadowed by shadow_tag later if appropriate.)
      If this is the wrong type of tag, do not return it.  If it was the
@@ -5351,7 +5351,7 @@ start_struct (code, name)
   /* If there is already a tag defined at this binding level
      (as a forward reference), just return it.  */
 
-  register tree ref = 0;
+  tree ref = 0;
 
   if (name != 0)
     ref = lookup_tag (code, name, current_binding_level, 1);
@@ -5423,7 +5423,7 @@ finish_struct (t, fieldlist, attributes)
      tree fieldlist;
      tree attributes;
 {
-  register tree x;
+  tree x;
   int toplevel = global_binding_level == current_binding_level;
   int saw_named_field;
 
@@ -5623,7 +5623,7 @@ finish_struct (t, fieldlist, attributes)
       x = TREE_CHAIN (x);
     else
       {
-	register tree y = fieldlist;
+	tree y = fieldlist;
 
 	while (1)
 	  {
@@ -5740,7 +5740,7 @@ tree
 start_enum (name)
      tree name;
 {
-  register tree enumtype = 0;
+  tree enumtype = 0;
 
   /* If this is the real definition for a previous forward reference,
      fill in the contents in the same object that used to be the
@@ -5788,7 +5788,7 @@ finish_enum (enumtype, values, attributes)
      tree values;
      tree attributes;
 {
-  register tree pair, tem;
+  tree pair, tem;
   tree minnode = 0, maxnode = 0, enum_value_type;
   int precision, unsign;
   int toplevel = (global_binding_level == current_binding_level);
@@ -5919,7 +5919,7 @@ tree
 build_enumerator (name, value)
      tree name, value;
 {
-  register tree decl, type;
+  tree decl, type;
 
   /* Validate and default VALUE.  */
 
@@ -6235,8 +6235,8 @@ c_mark_varargs ()
 void
 store_parm_decls ()
 {
-  register tree fndecl = current_function_decl;
-  register tree parm;
+  tree fndecl = current_function_decl;
+  tree parm;
 
   /* This is either a chain of PARM_DECLs (if a prototype was used)
      or a list of IDENTIFIER_NODEs (for an old-fashioned C definition).  */
@@ -6246,7 +6246,7 @@ store_parm_decls ()
   tree parmtags = current_function_parm_tags;
 
   /* This is a chain of PARM_DECLs from old-style parm declarations.  */
-  register tree parmdecls = getdecls ();
+  tree parmdecls = getdecls ();
 
   /* This is a chain of any other decls that came in among the parm
      declarations.  If a parm is declared with  enum {foo, bar} x;
@@ -6266,7 +6266,7 @@ store_parm_decls ()
 	 except record them as in effect
 	 and complain if any redundant old-style parm decls were written.  */
 
-      register tree next;
+      tree next;
       tree others = 0;
 
       prototype = 1;
@@ -6372,7 +6372,7 @@ store_parm_decls ()
 
       for (parm = specparms; parm; parm = TREE_CHAIN (parm))
 	{
-	  register tree tail, found = NULL;
+	  tree tail, found = NULL;
 
 	  if (TREE_VALUE (parm) == 0)
 	    {
@@ -6484,7 +6484,7 @@ store_parm_decls ()
       parm = specparms;
       DECL_ARGUMENTS (fndecl) = 0;
       {
-	register tree last;
+	tree last;
 	for (last = 0; parm; parm = TREE_CHAIN (parm))
 	  if (TREE_PURPOSE (parm))
 	    {
@@ -6503,7 +6503,7 @@ store_parm_decls ()
 
       if (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
 	{
-	  register tree type;
+	  tree type;
 	  for (parm = DECL_ARGUMENTS (fndecl),
 	       type = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
 	       parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type))
@@ -6671,7 +6671,7 @@ void
 finish_function (nested)
      int nested;
 {
-  register tree fndecl = current_function_decl;
+  tree fndecl = current_function_decl;
 
 /*  TREE_READONLY (fndecl) = 1;
     This caused &foo to be of type ptr-to-const-function
diff --git a/gcc/c-format.c b/gcc/c-format.c
index 19bbccec79f..061ddb9cb46 100644
--- a/gcc/c-format.c
+++ b/gcc/c-format.c
@@ -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;
diff --git a/gcc/c-semantics.c b/gcc/c-semantics.c
index 84000b9f853..86e2e8999bb 100644
--- a/gcc/c-semantics.c
+++ b/gcc/c-semantics.c
@@ -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);
diff --git a/gcc/c-typeck.c b/gcc/c-typeck.c
index 09ebf4d4b9f..d2a7a8ccd9e 100644
--- a/gcc/c-typeck.c
+++ b/gcc/c-typeck.c
@@ -191,8 +191,8 @@ tree
 common_type (t1, t2)
      tree t1, t2;
 {
-  register enum tree_code code1;
-  register enum tree_code code2;
+  enum tree_code code1;
+  enum tree_code code2;
   tree attributes;
 
   /* Save time if the two types are the same.  */
@@ -436,8 +436,8 @@ int
 comptypes (type1, type2)
      tree type1, type2;
 {
-  register tree t1 = type1;
-  register tree t2 = type2;
+  tree t1 = type1;
+  tree t2 = type2;
   int attrval, val;
 
   /* Suppress errors caused by previously reported errors.  */
@@ -847,8 +847,8 @@ tree
 default_conversion (exp)
      tree exp;
 {
-  register tree type = TREE_TYPE (exp);
-  register enum tree_code code = TREE_CODE (type);
+  tree type = TREE_TYPE (exp);
+  enum tree_code code = TREE_CODE (type);
 
   /* Constants can be used directly unless they're not loadable.  */
   if (TREE_CODE (exp) == CONST_DECL)
@@ -924,7 +924,7 @@ default_conversion (exp)
     }
   if (code == ARRAY_TYPE)
     {
-      register tree adr;
+      tree adr;
       tree restype = TREE_TYPE (type);
       tree ptrtype;
       int constp = 0;
@@ -1091,10 +1091,10 @@ tree
 build_component_ref (datum, component)
      tree datum, component;
 {
-  register tree type = TREE_TYPE (datum);
-  register enum tree_code code = TREE_CODE (type);
-  register tree field = NULL;
-  register tree ref;
+  tree type = TREE_TYPE (datum);
+  enum tree_code code = TREE_CODE (type);
+  tree field = NULL;
+  tree ref;
 
   /* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference inside it
      unless we are not to support things not strictly ANSI.  */
@@ -1178,8 +1178,8 @@ build_indirect_ref (ptr, errorstring)
      tree ptr;
      const char *errorstring;
 {
-  register tree pointer = default_conversion (ptr);
-  register tree type = TREE_TYPE (pointer);
+  tree pointer = default_conversion (ptr);
+  tree type = TREE_TYPE (pointer);
 
   if (TREE_CODE (type) == POINTER_TYPE)
     {
@@ -1191,8 +1191,7 @@ build_indirect_ref (ptr, errorstring)
       else
 	{
 	  tree t = TREE_TYPE (type);
-	  register tree ref = build1 (INDIRECT_REF,
-				      TYPE_MAIN_VARIANT (t), pointer);
+	  tree ref = build1 (INDIRECT_REF, TYPE_MAIN_VARIANT (t), pointer);
 
 	  if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
 	    {
@@ -1462,8 +1461,8 @@ tree
 build_function_call (function, params)
      tree function, params;
 {
-  register tree fntype, fundecl = 0;
-  register tree coerced_params;
+  tree fntype, fundecl = 0;
+  tree coerced_params;
   tree name = NULL_TREE, assembler_name = NULL_TREE, result;
 
   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
@@ -1559,8 +1558,8 @@ static tree
 convert_arguments (typelist, values, name, fundecl)
      tree typelist, values, name, fundecl;
 {
-  register tree typetail, valtail;
-  register tree result = NULL;
+  tree typetail, valtail;
+  tree result = NULL;
   int parmnum;
 
   /* Scan the given expressions and types, producing individual
@@ -1570,8 +1569,8 @@ convert_arguments (typelist, values, name, fundecl)
        valtail;
        valtail = TREE_CHAIN (valtail), parmnum++)
     {
-      register tree type = typetail ? TREE_VALUE (typetail) : 0;
-      register tree val = TREE_VALUE (valtail);
+      tree type = typetail ? TREE_VALUE (typetail) : 0;
+      tree val = TREE_VALUE (valtail);
 
       if (type == void_type_node)
 	{
@@ -1866,17 +1865,17 @@ build_binary_op (code, orig_op0, orig_op1, convert_p)
      int convert_p;
 {
   tree type0, type1;
-  register enum tree_code code0, code1;
+  enum tree_code code0, code1;
   tree op0, op1;
 
   /* Expression code to give to the expression when it is built.
      Normally this is CODE, which is what the caller asked for,
      but in some special cases we change it.  */
-  register enum tree_code resultcode = code;
+  enum tree_code resultcode = code;
 
   /* Data type in which the computation is to be performed.
      In the simplest cases this is the common type of the arguments.  */
-  register tree result_type = NULL;
+  tree result_type = NULL;
 
   /* Nonzero means operands have already been type-converted
      in whatever way is necessary.
@@ -2164,8 +2163,8 @@ build_binary_op (code, orig_op0, orig_op1, convert_p)
 	short_compare = 1;
       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
 	{
-	  register tree tt0 = TREE_TYPE (type0);
-	  register tree tt1 = TREE_TYPE (type1);
+	  tree tt0 = TREE_TYPE (type0);
+	  tree tt1 = TREE_TYPE (type1);
 	  /* Anything compares with void *.  void * compares with anything.
 	     Otherwise, the targets must be compatible
 	     and both must be object or both incomplete.  */
@@ -2585,8 +2584,8 @@ build_binary_op (code, orig_op0, orig_op1, convert_p)
     build_type = result_type;
 
   {
-    register tree result = build (resultcode, build_type, op0, op1);
-    register tree folded;
+    tree result = build (resultcode, build_type, op0, op1);
+    tree folded;
 
     folded = fold (result);
     if (folded == result)
@@ -2603,16 +2602,16 @@ build_binary_op (code, orig_op0, orig_op1, convert_p)
 static tree
 pointer_int_sum (resultcode, ptrop, intop)
      enum tree_code resultcode;
-     register tree ptrop, intop;
+     tree ptrop, intop;
 {
   tree size_exp;
 
-  register tree result;
-  register tree folded;
+  tree result;
+  tree folded;
 
   /* The result is a pointer of the same type that is being added.  */
 
-  register tree result_type = TREE_TYPE (ptrop);
+  tree result_type = TREE_TYPE (ptrop);
 
   if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
     {
@@ -2691,9 +2690,9 @@ pointer_int_sum (resultcode, ptrop, intop)
 
 static tree
 pointer_diff (op0, op1)
-     register tree op0, op1;
+     tree op0, op1;
 {
-  register tree result, folded;
+  tree result, folded;
   tree restype = ptrdiff_type_node;
 
   tree target_type = TREE_TYPE (TREE_TYPE (op0));
@@ -2778,9 +2777,9 @@ build_unary_op (code, xarg, noconvert)
      int noconvert;
 {
   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
-  register tree arg = xarg;
-  register tree argtype = 0;
-  register enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
+  tree arg = xarg;
+  tree argtype = 0;
+  enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
   tree val;
 
   if (typecode == ERROR_MARK)
@@ -2927,7 +2926,7 @@ build_unary_op (code, xarg, noconvert)
 	}
 
       {
-	register tree inc;
+	tree inc;
 	tree result_type = TREE_TYPE (arg);
 
 	arg = get_unwidened (arg, 0);
@@ -3188,7 +3187,7 @@ int
 lvalue_p (ref)
      tree ref;
 {
-  register enum tree_code code = TREE_CODE (ref);
+  enum tree_code code = TREE_CODE (ref);
 
   switch (code)
     {
@@ -3327,7 +3326,7 @@ int
 mark_addressable (exp)
      tree exp;
 {
-  register tree x = exp;
+  tree x = exp;
   while (1)
     switch (TREE_CODE (x))
       {
@@ -3412,11 +3411,11 @@ tree
 build_conditional_expr (ifexp, op1, op2)
      tree ifexp, op1, op2;
 {
-  register tree type1;
-  register tree type2;
-  register enum tree_code code1;
-  register enum tree_code code2;
-  register tree result_type = NULL;
+  tree type1;
+  tree type2;
+  enum tree_code code1;
+  enum tree_code code2;
+  tree result_type = NULL;
   tree orig_op1 = op1, orig_op2 = op2;
 
   ifexp = truthvalue_conversion (default_conversion (ifexp));
@@ -3600,7 +3599,7 @@ internal_build_compound_expr (list, first_p)
      tree list;
      int first_p;
 {
-  register tree rest;
+  tree rest;
 
   if (TREE_CHAIN (list) == 0)
     {
@@ -3654,10 +3653,10 @@ internal_build_compound_expr (list, first_p)
 
 tree
 build_c_cast (type, expr)
-     register tree type;
+     tree type;
      tree expr;
 {
-  register tree value = expr;
+  tree value = expr;
   
   if (type == error_mark_node || expr == error_mark_node)
     return error_mark_node;
@@ -3856,7 +3855,7 @@ build_modify_expr (lhs, modifycode, rhs)
      tree lhs, rhs;
      enum tree_code modifycode;
 {
-  register tree result;
+  tree result;
   tree newrhs;
   tree lhstype = TREE_TYPE (lhs);
   tree olhstype = lhstype;
@@ -4037,9 +4036,9 @@ convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
      tree fundecl, funname;
      int parmnum;
 {
-  register enum tree_code codel = TREE_CODE (type);
-  register tree rhstype;
-  register enum tree_code coder;
+  enum tree_code codel = TREE_CODE (type);
+  tree rhstype;
+  enum tree_code coder;
 
   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
   /* Do not use STRIP_NOPS here.  We do not want an enumerator
@@ -4124,8 +4123,8 @@ convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
 
 	  if (coder == POINTER_TYPE)
 	    {
-	      register tree ttl = TREE_TYPE (memb_type);
-	      register tree ttr = TREE_TYPE (rhstype);
+	      tree ttl = TREE_TYPE (memb_type);
+	      tree ttr = TREE_TYPE (rhstype);
 
 	      /* Any non-function converts to a [const][volatile] void *
 		 and vice versa; otherwise, targets must be the same.
@@ -4166,8 +4165,8 @@ convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
 	    {
 	      /* We have only a marginally acceptable member type;
 		 it needs a warning.  */
-	      register tree ttl = TREE_TYPE (marginal_memb_type);
-	      register tree ttr = TREE_TYPE (rhstype);
+	      tree ttl = TREE_TYPE (marginal_memb_type);
+	      tree ttr = TREE_TYPE (rhstype);
 
 	      /* Const and volatile mean something different for function
 		 types, so the usual warnings are not appropriate.  */
@@ -4200,8 +4199,8 @@ convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
   else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
 	   && (coder == POINTER_TYPE || coder == REFERENCE_TYPE))
     {
-      register tree ttl = TREE_TYPE (type);
-      register tree ttr = TREE_TYPE (rhstype);
+      tree ttl = TREE_TYPE (type);
+      tree ttr = TREE_TYPE (rhstype);
 
       /* Any non-function converts to a [const][volatile] void *
 	 and vice versa; otherwise, targets must be the same.
@@ -4386,7 +4385,7 @@ void
 store_init_value (decl, init)
      tree decl, init;
 {
-  register tree value, type;
+  tree value, type;
 
   /* If variable's type was invalidly declared, just ignore it.  */
 
@@ -4539,8 +4538,8 @@ push_array_bounds (bounds)
 static int
 spelling_length ()
 {
-  register int size = 0;
-  register struct spelling *p;
+  int size = 0;
+  struct spelling *p;
 
   for (p = spelling_base; p < spelling; p++)
     {
@@ -4557,10 +4556,10 @@ spelling_length ()
 
 static char *
 print_spelling (buffer)
-     register char *buffer;
+     char *buffer;
 {
-  register char *d = buffer;
-  register struct spelling *p;
+  char *d = buffer;
+  struct spelling *p;
 
   for (p = spelling_base; p < spelling; p++)
     if (p->kind == SPELLING_BOUNDS)
@@ -4570,7 +4569,7 @@ print_spelling (buffer)
       }
     else
       {
-	register const char *s;
+	const char *s;
 	if (p->kind == SPELLING_MEMBER)
 	  *d++ = '.';
 	for (s = p->u.s; (*d = *s++); d++)
@@ -6854,10 +6853,10 @@ c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
      int line;
 {
   int noutputs = list_length (outputs);
-  register int i;
+  int i;
   /* o[I] is the place that output number I should be written.  */
-  register tree *o = (tree *) alloca (noutputs * sizeof (tree));
-  register tree tail;
+  tree *o = (tree *) alloca (noutputs * sizeof (tree));
+  tree tail;
 
   /* Record the contents of OUTPUTS before it is modified.  */
   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
@@ -7022,7 +7021,7 @@ tree
 c_start_case (exp)
      tree exp;
 {
-  register enum tree_code code;
+  enum tree_code code;
   tree type;
   struct c_switch *cs;
 
diff --git a/gcc/caller-save.c b/gcc/caller-save.c
index 8cc72db8445..c5baa1321b4 100644
--- a/gcc/caller-save.c
+++ b/gcc/caller-save.c
@@ -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;
 
diff --git a/gcc/calls.c b/gcc/calls.c
index b2229168b19..5b5657fc1b9 100644
--- a/gcc/calls.c
+++ b/gcc/calls.c
@@ -256,7 +256,7 @@ calls_function_1 (exp, which)
      tree exp;
      int which;
 {
-  register int i;
+  int i;
   enum tree_code code = TREE_CODE (exp);
   int class = TREE_CODE_CLASS (code);
   int length = first_rtl_op (code);
@@ -308,8 +308,8 @@ calls_function_1 (exp, which)
 
     case BLOCK:
       {
-	register tree local;
-	register tree subblock;
+	tree local;
+	tree subblock;
 
 	for (local = BLOCK_VARS (exp); local; local = TREE_CHAIN (local))
 	  if (DECL_INITIAL (local) != 0
@@ -2156,8 +2156,8 @@ expand_call (exp, target, ignore)
   int old_inhibit_defer_pop = inhibit_defer_pop;
   int old_stack_allocated;
   rtx call_fusage;
-  register tree p = TREE_OPERAND (exp, 0);
-  register int i;
+  tree p = TREE_OPERAND (exp, 0);
+  int i;
   /* The alignment of the stack, in bits.  */
   HOST_WIDE_INT preferred_stack_boundary;
   /* The alignment of the stack, in bytes.  */
@@ -3461,7 +3461,7 @@ emit_library_call_value_1 (retval, orgfun, value, fn_type, outmode, nargs, p)
   struct args_size args_size;
   /* Size of arguments before any adjustments (such as rounding).  */
   struct args_size original_args_size;
-  register int argnum;
+  int argnum;
   rtx fun;
   int inc;
   int count;
@@ -3912,8 +3912,8 @@ emit_library_call_value_1 (retval, orgfun, value, fn_type, outmode, nargs, p)
      are to be pushed.  */
   for (count = 0; count < nargs; count++, argnum += inc)
     {
-      register enum machine_mode mode = argvec[argnum].mode;
-      register rtx val = argvec[argnum].value;
+      enum machine_mode mode = argvec[argnum].mode;
+      rtx val = argvec[argnum].value;
       rtx reg = argvec[argnum].reg;
       int partial = argvec[argnum].partial;
       int lower_bound = 0, upper_bound = 0, i;
@@ -3995,7 +3995,7 @@ emit_library_call_value_1 (retval, orgfun, value, fn_type, outmode, nargs, p)
      are to be pushed.  */
   for (count = 0; count < nargs; count++, argnum += inc)
     {
-      register rtx val = argvec[argnum].value;
+      rtx val = argvec[argnum].value;
       rtx reg = argvec[argnum].reg;
       int partial = argvec[argnum].partial;
 
@@ -4200,9 +4200,9 @@ emit_library_call_value_1 (retval, orgfun, value, fn_type, outmode, nargs, p)
    and machine_modes to convert them to.
    The rtx values should have been passed through protect_from_queue already.
 
-   FN_TYPE will is zero for `normal' calls, one for `const' calls, wich
-   which will be enclosed in REG_LIBCALL/REG_RETVAL notes and two for `pure'
-   calls, that are handled like `const' calls with extra
+   FN_TYPE will be zero for `normal' calls, one for `const' calls,
+   which will be enclosed in REG_LIBCALL/REG_RETVAL notes, and two for
+   `pure' calls, that are handled like `const' calls with extra
    (use (memory (scratch)).  */
 
 void
@@ -4315,7 +4315,7 @@ store_one_arg (arg, argblock, flags, variable_size, reg_parm_stack_space)
      int variable_size ATTRIBUTE_UNUSED;
      int reg_parm_stack_space;
 {
-  register tree pval = arg->tree_value;
+  tree pval = arg->tree_value;
   rtx reg = 0;
   int partial = 0;
   int used = 0;
@@ -4475,7 +4475,7 @@ store_one_arg (arg, argblock, flags, variable_size, reg_parm_stack_space)
     }
   else if (arg->mode != BLKmode)
     {
-      register int size;
+      int size;
 
       /* Argument is a scalar, not entirely passed in registers.
 	 (If part is passed in registers, arg->partial says how much
@@ -4514,7 +4514,7 @@ store_one_arg (arg, argblock, flags, variable_size, reg_parm_stack_space)
     {
       /* BLKmode, at least partly to be pushed.  */
 
-      register int excess;
+      int excess;
       rtx size_rtx;
 
       /* Pushing a nonscalar.
diff --git a/gcc/cfg.c b/gcc/cfg.c
index f8badd3a78f..d8d8c992b7d 100644
--- a/gcc/cfg.c
+++ b/gcc/cfg.c
@@ -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);
diff --git a/gcc/cfgbuild.c b/gcc/cfgbuild.c
index 4afab8137a8..b27c23966ed 100644
--- a/gcc/cfgbuild.c
+++ b/gcc/cfgbuild.c
@@ -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;
diff --git a/gcc/cfgrtl.c b/gcc/cfgrtl.c
index c075731d1eb..edd88bd9a0f 100644
--- a/gcc/cfgrtl.c
+++ b/gcc/cfgrtl.c
@@ -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");
diff --git a/gcc/collect2.c b/gcc/collect2.c
index 297f769a6fd..c8fafc3e2c1 100644
--- a/gcc/collect2.c
+++ b/gcc/collect2.c
@@ -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 },
diff --git a/gcc/combine.c b/gcc/combine.c
index de80e8d64b5..43b1b9e9a19 100644
--- a/gcc/combine.c
+++ b/gcc/combine.c
@@ -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);
diff --git a/gcc/convert.c b/gcc/convert.c
index 69a1605a2a4..127b22b7eef 100644
--- a/gcc/convert.c
+++ b/gcc/convert.c
@@ -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.  */
diff --git a/gcc/cppexp.c b/gcc/cppexp.c
index 5a92351a03c..040bf86f48c 100644
--- a/gcc/cppexp.c
+++ b/gcc/cppexp.c
@@ -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;
diff --git a/gcc/cppfiles.c b/gcc/cppfiles.c
index 61a53d6809c..bacb8e18ef9 100644
--- a/gcc/cppfiles.c
+++ b/gcc/cppfiles.c
@@ -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;
 
diff --git a/gcc/cse.c b/gcc/cse.c
index e18f7530acc..efe1fadab48 100644
--- a/gcc/cse.c
+++ b/gcc/cse.c
@@ -826,10 +826,10 @@ rtx_cost (x, outer_code)
      rtx x;
      enum rtx_code outer_code ATTRIBUTE_UNUSED;
 {
-  register int i, j;
-  register enum rtx_code code;
-  register const char *fmt;
-  register int total;
+  int i, j;
+  enum rtx_code code;
+  const char *fmt;
+  int total;
 
   if (x == 0)
     return 0;
@@ -985,7 +985,7 @@ get_cse_reg_info (regno)
 static void
 new_basic_block ()
 {
-  register int i;
+  int i;
 
   next_qty = max_reg;
 
@@ -1043,9 +1043,9 @@ make_new_qty (reg, mode)
      unsigned int reg;
      enum machine_mode mode;
 {
-  register int q;
-  register struct qty_table_elem *ent;
-  register struct reg_eqv_elem *eqv;
+  int q;
+  struct qty_table_elem *ent;
+  struct reg_eqv_elem *eqv;
 
   if (next_qty >= max_qty)
     abort ();
@@ -1133,9 +1133,9 @@ static void
 delete_reg_equiv (reg)
      unsigned int reg;
 {
-  register struct qty_table_elem *ent;
-  register int q = REG_QTY (reg);
-  register int p, n;
+  struct qty_table_elem *ent;
+  int q = REG_QTY (reg);
+  int p, n;
 
   /* If invalid, do nothing.  */
   if (q == (int) reg)
@@ -1174,10 +1174,10 @@ static int
 mention_regs (x)
      rtx x;
 {
-  register enum rtx_code code;
-  register int i, j;
-  register const char *fmt;
-  register int changed = 0;
+  enum rtx_code code;
+  int i, j;
+  const char *fmt;
+  int changed = 0;
 
   if (x == 0)
     return 0;
@@ -1358,7 +1358,7 @@ insert_regs (x, classp, modified)
 
 static void
 remove_from_table (elt, hash)
-     register struct table_elt *elt;
+     struct table_elt *elt;
      unsigned hash;
 {
   if (elt == 0)
@@ -1370,8 +1370,8 @@ remove_from_table (elt, hash)
   /* Remove the table element from its equivalence class.  */
 
   {
-    register struct table_elt *prev = elt->prev_same_value;
-    register struct table_elt *next = elt->next_same_value;
+    struct table_elt *prev = elt->prev_same_value;
+    struct table_elt *next = elt->next_same_value;
 
     if (next)
       next->prev_same_value = prev;
@@ -1380,7 +1380,7 @@ remove_from_table (elt, hash)
       prev->next_same_value = next;
     else
       {
-	register struct table_elt *newfirst = next;
+	struct table_elt *newfirst = next;
 	while (next)
 	  {
 	    next->first_same_value = newfirst;
@@ -1392,8 +1392,8 @@ remove_from_table (elt, hash)
   /* Remove the table element from its hash bucket.  */
 
   {
-    register struct table_elt *prev = elt->prev_same_hash;
-    register struct table_elt *next = elt->next_same_hash;
+    struct table_elt *prev = elt->prev_same_hash;
+    struct table_elt *next = elt->next_same_hash;
 
     if (next)
       next->prev_same_hash = prev;
@@ -1418,7 +1418,7 @@ remove_from_table (elt, hash)
 
   if (elt->related_value != 0 && elt->related_value != elt)
     {
-      register struct table_elt *p = elt->related_value;
+      struct table_elt *p = elt->related_value;
 
       while (p->related_value != elt)
 	p = p->related_value;
@@ -1447,7 +1447,7 @@ lookup (x, hash, mode)
      unsigned hash;
      enum machine_mode mode;
 {
-  register struct table_elt *p;
+  struct table_elt *p;
 
   for (p = table[hash]; p; p = p->next_same_hash)
     if (mode == p->mode && ((x == p->exp && GET_CODE (x) == REG)
@@ -1466,7 +1466,7 @@ lookup_for_remove (x, hash, mode)
      unsigned hash;
      enum machine_mode mode;
 {
-  register struct table_elt *p;
+  struct table_elt *p;
 
   if (GET_CODE (x) == REG)
     {
@@ -1497,7 +1497,7 @@ lookup_as_function (x, code)
      rtx x;
      enum rtx_code code;
 {
-  register struct table_elt *p
+  struct table_elt *p
     = lookup (x, safe_hash (x, VOIDmode) & HASH_MASK, GET_MODE (x));
 
   /* If we are looking for a CONST_INT, the mode doesn't really matter, as
@@ -1552,12 +1552,12 @@ lookup_as_function (x, code)
 
 static struct table_elt *
 insert (x, classp, hash, mode)
-     register rtx x;
-     register struct table_elt *classp;
+     rtx x;
+     struct table_elt *classp;
      unsigned hash;
      enum machine_mode mode;
 {
-  register struct table_elt *elt;
+  struct table_elt *elt;
 
   /* If X is a register and we haven't made a quantity for it,
      something is wrong.  */
@@ -1616,7 +1616,7 @@ insert (x, classp, hash, mode)
       if (CHEAPER (elt, classp))
 	/* Insert at the head of the class */
 	{
-	  register struct table_elt *p;
+	  struct table_elt *p;
 	  elt->next_same_value = classp;
 	  classp->prev_same_value = elt;
 	  elt->first_same_value = elt;
@@ -1628,7 +1628,7 @@ insert (x, classp, hash, mode)
 	{
 	  /* Insert not at head of the class.  */
 	  /* Put it after the last element cheaper than X.  */
-	  register struct table_elt *p, *next;
+	  struct table_elt *p, *next;
 
 	  for (p = classp; (next = p->next_same_value) && CHEAPER (next, elt);
 	       p = next);
@@ -1676,7 +1676,7 @@ insert (x, classp, hash, mode)
 	   && ! qty_table[REG_QTY (REGNO (x))].const_rtx
 	   && ! elt->is_const)
     {
-      register struct table_elt *p;
+      struct table_elt *p;
 
       for (p = classp; p != 0; p = p->next_same_value)
 	{
@@ -1842,8 +1842,8 @@ invalidate (x, full_mode)
      rtx x;
      enum machine_mode full_mode;
 {
-  register int i;
-  register struct table_elt *p;
+  int i;
+  struct table_elt *p;
 
   switch (GET_CODE (x))
     {
@@ -1884,7 +1884,7 @@ invalidate (x, full_mode)
 	    unsigned int endregno
 	      = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
 	    unsigned int tregno, tendregno, rn;
-	    register struct table_elt *p, *next;
+	    struct table_elt *p, *next;
 
 	    CLEAR_HARD_REG_BIT (hard_regs_in_table, regno);
 
@@ -1943,7 +1943,7 @@ invalidate (x, full_mode)
 
       for (i = 0; i < HASH_SIZE; i++)
 	{
-	  register struct table_elt *next;
+	  struct table_elt *next;
 
 	  for (p = table[i]; p; p = next)
 	    {
@@ -2141,8 +2141,8 @@ use_related_value (x, elt)
      rtx x;
      struct table_elt *elt;
 {
-  register struct table_elt *relt = 0;
-  register struct table_elt *p, *q;
+  struct table_elt *relt = 0;
+  struct table_elt *p, *q;
   HOST_WIDE_INT offset;
 
   /* First, is there anything related known?
@@ -2238,10 +2238,10 @@ canon_hash (x, mode)
      rtx x;
      enum machine_mode mode;
 {
-  register int i, j;
-  register unsigned hash = 0;
-  register enum rtx_code code;
-  register const char *fmt;
+  int i, j;
+  unsigned hash = 0;
+  enum rtx_code code;
+  const char *fmt;
 
   /* repeat is used to turn tail-recursion into iteration.  */
  repeat:
@@ -2449,7 +2449,7 @@ canon_hash (x, mode)
 	hash += canon_hash_string (XSTR (x, i));
       else if (fmt[i] == 'i')
 	{
-	  register unsigned tem = XINT (x, i);
+	  unsigned tem = XINT (x, i);
 	  hash += tem;
 	}
       else if (fmt[i] == '0' || fmt[i] == 't')
@@ -2497,9 +2497,9 @@ exp_equiv_p (x, y, validate, equal_values)
      int validate;
      int equal_values;
 {
-  register int i, j;
-  register enum rtx_code code;
-  register const char *fmt;
+  int i, j;
+  enum rtx_code code;
+  const char *fmt;
 
   /* Note: it is incorrect to assume an expression is equivalent to itself
      if VALIDATE is nonzero.  */
@@ -2688,7 +2688,7 @@ exp_equiv_p (x, y, validate, equal_values)
 
 static int
 cse_rtx_varies_p (x, from_alias)
-     register rtx x;
+     rtx x;
      int from_alias;
 {
   /* We need not check for X and the equivalence class being of the same
@@ -2761,9 +2761,9 @@ canon_reg (x, insn)
      rtx x;
      rtx insn;
 {
-  register int i;
-  register enum rtx_code code;
-  register const char *fmt;
+  int i;
+  enum rtx_code code;
+  const char *fmt;
 
   if (x == 0)
     return x;
@@ -2784,9 +2784,9 @@ canon_reg (x, insn)
 
     case REG:
       {
-	register int first;
-	register int q;
-	register struct qty_table_elem *ent;
+	int first;
+	int q;
+	struct qty_table_elem *ent;
 
 	/* Never replace a hard reg, because hard regs can appear
 	   in more than one machine mode, and we must preserve the mode
@@ -2812,7 +2812,7 @@ canon_reg (x, insn)
   fmt = GET_RTX_FORMAT (code);
   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
     {
-      register int j;
+      int j;
 
       if (fmt[i] == 'e')
 	{
@@ -3285,10 +3285,10 @@ fold_rtx (x, insn)
      rtx x;
      rtx insn;
 {
-  register enum rtx_code code;
-  register enum machine_mode mode;
-  register const char *fmt;
-  register int i;
+  enum rtx_code code;
+  enum machine_mode mode;
+  const char *fmt;
+  int i;
   rtx new = 0;
   int copied = 0;
   int must_swap = 0;
@@ -3845,7 +3845,7 @@ fold_rtx (x, insn)
 	      		    || (GET_CODE (const_arg0) == CONST_INT
 			        && GET_CODE (const_arg1) != CONST_INT))))
 	{
-	  register rtx tem = XEXP (x, 0);
+	  rtx tem = XEXP (x, 0);
 
 	  if (insn == 0 && ! copied)
 	    {
@@ -4363,7 +4363,7 @@ equiv_constant (x)
 rtx
 gen_lowpart_if_possible (mode, x)
      enum machine_mode mode;
-     register rtx x;
+     rtx x;
 {
   rtx result = gen_lowpart_common (mode, x);
 
@@ -4372,7 +4372,7 @@ gen_lowpart_if_possible (mode, x)
   else if (GET_CODE (x) == MEM)
     {
       /* This is the only other case we handle.  */
-      register int offset = 0;
+      int offset = 0;
       rtx new;
 
       if (WORDS_BIG_ENDIAN)
@@ -4716,10 +4716,10 @@ cse_insn (insn, libcall_insn)
      rtx insn;
      rtx libcall_insn;
 {
-  register rtx x = PATTERN (insn);
-  register int i;
+  rtx x = PATTERN (insn);
+  int i;
   rtx tem;
-  register int n_sets = 0;
+  int n_sets = 0;
 
 #ifdef HAVE_cc0
   /* Records what this insn does to set CC0.  */
@@ -4787,7 +4787,7 @@ cse_insn (insn, libcall_insn)
     }
   else if (GET_CODE (x) == PARALLEL)
     {
-      register int lim = XVECLEN (x, 0);
+      int lim = XVECLEN (x, 0);
 
       sets = (struct set *) alloca (lim * sizeof (struct set));
 
@@ -4804,7 +4804,7 @@ cse_insn (insn, libcall_insn)
 	 anything in that case.  */
       for (i = 0; i < lim; i++)
 	{
-	  register rtx y = XVECEXP (x, 0, i);
+	  rtx y = XVECEXP (x, 0, i);
 	  if (GET_CODE (y) == CLOBBER)
 	    {
 	      rtx clobbered = XEXP (y, 0);
@@ -4820,7 +4820,7 @@ cse_insn (insn, libcall_insn)
 
       for (i = 0; i < lim; i++)
 	{
-	  register rtx y = XVECEXP (x, 0, i);
+	  rtx y = XVECEXP (x, 0, i);
 	  if (GET_CODE (y) == SET)
 	    {
 	      /* As above, we ignore unconditional jumps and call-insns and
@@ -4952,9 +4952,9 @@ cse_insn (insn, libcall_insn)
 
   for (i = 0; i < n_sets; i++)
     {
-      register rtx src, dest;
-      register rtx src_folded;
-      register struct table_elt *elt = 0, *p;
+      rtx src, dest;
+      rtx src_folded;
+      struct table_elt *elt = 0, *p;
       enum machine_mode mode;
       rtx src_eqv_here;
       rtx src_const = 0;
@@ -5853,8 +5853,8 @@ cse_insn (insn, libcall_insn)
   if (src_eqv && src_eqv_elt == 0 && sets[0].rtl != 0 && ! src_eqv_volatile
       && ! rtx_equal_p (src_eqv, SET_DEST (sets[0].rtl)))
     {
-      register struct table_elt *elt;
-      register struct table_elt *classp = sets[0].src_elt;
+      struct table_elt *elt;
+      struct table_elt *classp = sets[0].src_elt;
       rtx dest = SET_DEST (sets[0].rtl);
       enum machine_mode eqvmode = GET_MODE (dest);
 
@@ -5899,9 +5899,9 @@ cse_insn (insn, libcall_insn)
 	  {
 	    /* Insert source and constant equivalent into hash table, if not
 	       already present.  */
-	    register struct table_elt *classp = src_eqv_elt;
-	    register rtx src = sets[i].src;
-	    register rtx dest = SET_DEST (sets[i].rtl);
+	    struct table_elt *classp = src_eqv_elt;
+	    rtx src = sets[i].src;
+	    rtx dest = SET_DEST (sets[i].rtl);
 	    enum machine_mode mode
 	      = GET_MODE (src) == VOIDmode ? GET_MODE (dest) : GET_MODE (src);
 
@@ -5914,7 +5914,7 @@ cse_insn (insn, libcall_insn)
 		    || REGNO (src) >= FIRST_PSEUDO_REGISTER
 		    || ! find_reg_note (insn, REG_RETVAL, NULL_RTX))
 		  {
-		    register struct table_elt *elt;
+		    struct table_elt *elt;
 
 		    /* Note that these insert_regs calls cannot remove
 		       any of the src_elt's, because they would have failed to
@@ -5966,7 +5966,7 @@ cse_insn (insn, libcall_insn)
       {
 	/* We can't use the inner dest, because the mode associated with
 	   a ZERO_EXTRACT is significant.  */
-	register rtx dest = SET_DEST (sets[i].rtl);
+	rtx dest = SET_DEST (sets[i].rtl);
 
 	/* Needed for registers to remove the register from its
 	   previous quantity's chain.
@@ -6050,7 +6050,7 @@ cse_insn (insn, libcall_insn)
 	  /* If elt was removed, find current head of same class,
 	     or 0 if nothing remains of that class.  */
 	  {
-	    register struct table_elt *elt = sets[i].src_elt;
+	    struct table_elt *elt = sets[i].src_elt;
 
 	    while (elt && elt->prev_same_value)
 	      elt = elt->prev_same_value;
@@ -6066,9 +6066,9 @@ cse_insn (insn, libcall_insn)
   for (i = 0; i < n_sets; i++)
     if (sets[i].rtl)
       {
-	register rtx dest = SET_DEST (sets[i].rtl);
+	rtx dest = SET_DEST (sets[i].rtl);
 	rtx inner_dest = sets[i].inner_dest;
-	register struct table_elt *elt;
+	struct table_elt *elt;
 
 	/* Don't record value if we are not supposed to risk allocating
 	   floating-point values in registers that might be wider than
@@ -6320,8 +6320,8 @@ cse_insn (insn, libcall_insn)
 static void
 invalidate_memory ()
 {
-  register int i;
-  register struct table_elt *p, *next;
+  int i;
+  struct table_elt *p, *next;
 
   for (i = 0; i < HASH_SIZE; i++)
     for (p = table[i]; p; p = next)
@@ -6337,7 +6337,7 @@ invalidate_memory ()
 
 static int
 addr_affects_sp_p (addr)
-     register rtx addr;
+     rtx addr;
 {
   if (GET_RTX_CLASS (GET_CODE (addr)) == 'a'
       && GET_CODE (XEXP (addr, 0)) == REG
@@ -6382,10 +6382,10 @@ invalidate_from_clobbers (x)
     }
   else if (GET_CODE (x) == PARALLEL)
     {
-      register int i;
+      int i;
       for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
 	{
-	  register rtx y = XVECEXP (x, 0, i);
+	  rtx y = XVECEXP (x, 0, i);
 	  if (GET_CODE (y) == CLOBBER)
 	    {
 	      rtx ref = XEXP (y, 0);
@@ -6938,7 +6938,7 @@ cse_end_of_basic_block (insn, data, follow_jumps, after_loop, skip_blocks)
 	  /* Detect a branch around a block of code.  */
 	  else if (skip_blocks && q != 0 && GET_CODE (q) != CODE_LABEL)
 	    {
-	      register rtx tmp;
+	      rtx tmp;
 
 	      if (next_real_insn (q) == next)
 		{
@@ -7013,8 +7013,8 @@ cse_main (f, nregs, after_loop, file)
      FILE *file;
 {
   struct cse_basic_block_data val;
-  register rtx insn = f;
-  register int i;
+  rtx insn = f;
+  int i;
 
   cse_jumps_altered = 0;
   recorded_label_ref = 0;
@@ -7153,11 +7153,11 @@ cse_main (f, nregs, after_loop, file)
 
 static rtx
 cse_basic_block (from, to, next_branch, around_loop)
-     register rtx from, to;
+     rtx from, to;
      struct branch_path *next_branch;
      int around_loop;
 {
-  register rtx insn;
+  rtx insn;
   int to_usage = 0;
   rtx libcall_insn = NULL_RTX;
   int num_insns = 0;
@@ -7178,7 +7178,7 @@ cse_basic_block (from, to, next_branch, around_loop)
 
   for (insn = from; insn != to; insn = NEXT_INSN (insn))
     {
-      register enum rtx_code code = GET_CODE (insn);
+      enum rtx_code code = GET_CODE (insn);
 
       /* If we have processed 1,000 insns, flush the hash table to
 	 avoid extreme quadratic behavior.  We must not include NOTEs
diff --git a/gcc/dbxout.c b/gcc/dbxout.c
index bfb6b0e8d51..f280bc83497 100644
--- a/gcc/dbxout.c
+++ b/gcc/dbxout.c
@@ -855,15 +855,15 @@ dbxout_type_method_1 (decl, debug_name)
 
 static void
 dbxout_type_methods (type)
-     register tree type;
+     tree type;
 {
   /* C++: put out the method names and their parameter lists */
   tree methods = TYPE_METHODS (type);
   tree type_encoding;
-  register tree fndecl;
-  register tree last;
+  tree fndecl;
+  tree last;
   char formatted_type_identifier_length[16];
-  register int type_identifier_length;
+  int type_identifier_length;
 
   if (methods == NULL_TREE)
     return;
@@ -1032,7 +1032,7 @@ dbxout_type (type, full)
      tree type;
      int full;
 {
-  register tree tem;
+  tree tem;
   static int anonymous_type_number = 0;
 
   if (TREE_CODE (type) == VECTOR_TYPE)
@@ -1759,7 +1759,7 @@ print_wide_int (c)
 
 static void
 dbxout_type_name (type)
-     register tree type;
+     tree type;
 {
   tree t;
   if (TYPE_NAME (type) == 0)
@@ -2712,7 +2712,7 @@ dbxout_args (args)
 
 static void
 dbxout_block (block, depth, args)
-     register tree block;
+     tree block;
      int depth;
      tree args;
 {
diff --git a/gcc/defaults.h b/gcc/defaults.h
index f9fef2061f1..bda763fe1b1 100644
--- a/gcc/defaults.h
+++ b/gcc/defaults.h
@@ -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))						      \
diff --git a/gcc/df.c b/gcc/df.c
index 6d124a86b46..75148733e59 100644
--- a/gcc/df.c
+++ b/gcc/df.c
@@ -1186,7 +1186,7 @@ df_uses_record (df, loc, ref_type, bb, insn)
 
   /* Recursively scan the operands of this expression.  */
   {
-    register const char *fmt = GET_RTX_FORMAT (code);
+    const char *fmt = GET_RTX_FORMAT (code);
     int i;
     
     for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index 31aae4e4c10..e8a5f18f0d0 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -397,7 +397,7 @@ expand_builtin_init_dwarf_reg_sizes (address)
 
 static const char *
 dwarf_cfi_name (cfi_opc)
-     register unsigned cfi_opc;
+     unsigned cfi_opc;
 {
   switch (cfi_opc)
     {
@@ -462,7 +462,7 @@ dwarf_cfi_name (cfi_opc)
 static inline dw_cfi_ref
 new_cfi ()
 {
-  register dw_cfi_ref cfi = (dw_cfi_ref) xmalloc (sizeof (dw_cfi_node));
+  dw_cfi_ref cfi = (dw_cfi_ref) xmalloc (sizeof (dw_cfi_node));
 
   cfi->dw_cfi_next = NULL;
   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
@@ -475,10 +475,10 @@ new_cfi ()
 
 static inline void
 add_cfi (list_head, cfi)
-     register dw_cfi_ref *list_head;
-     register dw_cfi_ref cfi;
+     dw_cfi_ref *list_head;
+     dw_cfi_ref cfi;
 {
-  register dw_cfi_ref *p;
+  dw_cfi_ref *p;
 
   /* Find the end of the chain.  */
   for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
@@ -506,12 +506,12 @@ dwarf2out_cfi_label ()
 
 static void
 add_fde_cfi (label, cfi)
-     register const char *label;
-     register dw_cfi_ref cfi;
+     const char *label;
+     dw_cfi_ref cfi;
 {
   if (label)
     {
-      register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
+      dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
 
       if (*label == 0)
 	label = dwarf2out_cfi_label ();
@@ -519,7 +519,7 @@ add_fde_cfi (label, cfi)
       if (fde->dw_fde_current_label == NULL
 	  || strcmp (label, fde->dw_fde_current_label) != 0)
 	{
-	  register dw_cfi_ref xcfi;
+	  dw_cfi_ref xcfi;
 
 	  fde->dw_fde_current_label = label = xstrdup (label);
 
@@ -541,8 +541,8 @@ add_fde_cfi (label, cfi)
 
 static inline void
 lookup_cfa_1 (cfi, loc)
-     register dw_cfi_ref cfi;
-     register dw_cfa_location *loc;
+     dw_cfi_ref cfi;
+     dw_cfa_location *loc;
 {
   switch (cfi->dw_cfi_opc)
     {
@@ -568,9 +568,9 @@ lookup_cfa_1 (cfi, loc)
 
 static void
 lookup_cfa (loc)
-     register dw_cfa_location *loc;
+     dw_cfa_location *loc;
 {
-  register dw_cfi_ref cfi;
+  dw_cfi_ref cfi;
 
   loc->reg = (unsigned long) -1;
   loc->offset = 0;
@@ -582,7 +582,7 @@ lookup_cfa (loc)
 
   if (fde_table_in_use)
     {
-      register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
+      dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
       for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
 	lookup_cfa_1 (cfi, loc);
     }
@@ -607,7 +607,7 @@ static long old_args_size;
 
 void
 dwarf2out_def_cfa (label, reg, offset)
-     register const char *label;
+     const char *label;
      unsigned reg;
      long offset;
 {
@@ -623,10 +623,10 @@ dwarf2out_def_cfa (label, reg, offset)
    the dw_cfa_location structure.  */
 static void
 def_cfa_1 (label, loc_p)
-     register const char *label;
+     const char *label;
      dw_cfa_location *loc_p;
 {
-  register dw_cfi_ref cfi;
+  dw_cfi_ref cfi;
   dw_cfa_location old_cfa, loc;
 
   cfa = *loc_p;
@@ -701,12 +701,12 @@ def_cfa_1 (label, loc_p)
 
 static void
 reg_save (label, reg, sreg, offset)
-     register const char *label;
-     register unsigned reg;
-     register unsigned sreg;
-     register long offset;
+     const char *label;
+     unsigned reg;
+     unsigned sreg;
+     long offset;
 {
-  register dw_cfi_ref cfi = new_cfi ();
+  dw_cfi_ref cfi = new_cfi ();
 
   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
 
@@ -762,9 +762,9 @@ reg_save (label, reg, sreg, offset)
 
 void
 dwarf2out_window_save (label)
-     register const char *label;
+     const char *label;
 {
-  register dw_cfi_ref cfi = new_cfi ();
+  dw_cfi_ref cfi = new_cfi ();
   cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
   add_fde_cfi (label, cfi);
 }
@@ -777,7 +777,7 @@ dwarf2out_args_size (label, size)
      const char *label;
      long size;
 {
-  register dw_cfi_ref cfi;
+  dw_cfi_ref cfi;
 
   if (size == old_args_size)
     return;
@@ -794,9 +794,9 @@ dwarf2out_args_size (label, size)
 
 void
 dwarf2out_reg_save (label, reg, offset)
-     register const char *label;
-     register unsigned reg;
-     register long offset;
+     const char *label;
+     unsigned reg;
+     long offset;
 {
   reg_save (label, DWARF_FRAME_REGNUM (reg), -1, offset);
 }
@@ -806,8 +806,8 @@ dwarf2out_reg_save (label, reg, offset)
 
 void
 dwarf2out_return_save (label, offset)
-     register const char *label;
-     register long offset;
+     const char *label;
+     long offset;
 {
   reg_save (label, DWARF_FRAME_RETURN_COLUMN, -1, offset);
 }
@@ -817,8 +817,8 @@ dwarf2out_return_save (label, offset)
 
 void
 dwarf2out_return_reg (label, sreg)
-     register const char *label;
-     register unsigned sreg;
+     const char *label;
+     unsigned sreg;
 {
   reg_save (label, DWARF_FRAME_RETURN_COLUMN, sreg, 0);
 }
@@ -828,7 +828,7 @@ dwarf2out_return_reg (label, sreg)
 
 static void
 initial_return_save (rtl)
-     register rtx rtl;
+     rtx rtl;
 {
   unsigned int reg = (unsigned int) -1;
   long offset = 0;
@@ -1604,8 +1604,8 @@ dwarf2out_frame_debug (insn)
 
 static void
 output_cfi (cfi, fde, for_eh)
-     register dw_cfi_ref cfi;
-     register dw_fde_ref fde;
+     dw_cfi_ref cfi;
+     dw_fde_ref fde;
      int for_eh;
 {
   if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
@@ -1706,9 +1706,9 @@ static void
 output_call_frame_info (for_eh)
      int for_eh;
 {
-  register unsigned int i;
-  register dw_fde_ref fde;
-  register dw_cfi_ref cfi;
+  unsigned int i;
+  dw_fde_ref fde;
+  dw_cfi_ref cfi;
   char l1[20], l2[20], section_start_label[20];
   int any_lsda_needed = 0;
   char augmentation[6];
@@ -1986,7 +1986,7 @@ dwarf2out_begin_prologue (line, file)
      const char *file ATTRIBUTE_UNUSED;
 {
   char label[MAX_ARTIFICIAL_LABEL_BYTES];
-  register dw_fde_ref fde;
+  dw_fde_ref fde;
 
   current_function_func_begin_label = 0;
 
@@ -2215,7 +2215,7 @@ static void output_loc_sequence		PARAMS ((dw_loc_descr_ref));
 
 static const char *
 dwarf_stack_op_name (op)
-     register unsigned op;
+     unsigned op;
 {
   switch (op)
     {
@@ -2520,13 +2520,13 @@ dwarf_stack_op_name (op)
 
 static inline dw_loc_descr_ref
 new_loc_descr (op, oprnd1, oprnd2)
-     register enum dwarf_location_atom op;
-     register unsigned long oprnd1;
-     register unsigned long oprnd2;
+     enum dwarf_location_atom op;
+     unsigned long oprnd1;
+     unsigned long oprnd2;
 {
   /* Use xcalloc here so we clear out all of the long_long constant in
      the union.  */
-  register dw_loc_descr_ref descr
+  dw_loc_descr_ref descr
     = (dw_loc_descr_ref) xcalloc (1, sizeof (dw_loc_descr_node));
 
   descr->dw_loc_opc = op;
@@ -2543,10 +2543,10 @@ new_loc_descr (op, oprnd1, oprnd2)
 
 static inline void
 add_loc_descr (list_head, descr)
-     register dw_loc_descr_ref *list_head;
-     register dw_loc_descr_ref descr;
+     dw_loc_descr_ref *list_head;
+     dw_loc_descr_ref descr;
 {
-  register dw_loc_descr_ref *d;
+  dw_loc_descr_ref *d;
 
   /* Find the end of the chain.  */
   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
@@ -2559,9 +2559,9 @@ add_loc_descr (list_head, descr)
 
 static unsigned long
 size_of_loc_descr (loc)
-     register dw_loc_descr_ref loc;
+     dw_loc_descr_ref loc;
 {
-  register unsigned long size = 1;
+  unsigned long size = 1;
 
   switch (loc->dw_loc_opc)
     {
@@ -2662,9 +2662,9 @@ size_of_loc_descr (loc)
 
 static unsigned long
 size_of_locs (loc)
-     register dw_loc_descr_ref loc;
+     dw_loc_descr_ref loc;
 {
-  register unsigned long size = 0;
+  unsigned long size = 0;
 
   for (; loc != NULL; loc = loc->dw_loc_next)
     {
@@ -2679,10 +2679,10 @@ size_of_locs (loc)
 
 static void
 output_loc_operands (loc)
-     register dw_loc_descr_ref loc;
+     dw_loc_descr_ref loc;
 {
-  register dw_val_ref val1 = &loc->dw_loc_oprnd1;
-  register dw_val_ref val2 = &loc->dw_loc_oprnd2;
+  dw_val_ref val1 = &loc->dw_loc_oprnd1;
+  dw_val_ref val2 = &loc->dw_loc_oprnd2;
 
   switch (loc->dw_loc_opc)
     {
@@ -3700,7 +3700,7 @@ dwarf2out_set_demangle_name_func (func)
 
 static rtx
 save_rtx (orig)
-     register rtx orig;
+     rtx orig;
 {
   VARRAY_PUSH_RTX (used_rtx_varray, orig);
 
@@ -3711,7 +3711,7 @@ save_rtx (orig)
 
 static inline int
 is_pseudo_reg (rtl)
-     register rtx rtl;
+     rtx rtl;
 {
   return ((GET_CODE (rtl) == REG && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
 	  || (GET_CODE (rtl) == SUBREG
@@ -3723,7 +3723,7 @@ is_pseudo_reg (rtl)
 
 static inline tree
 type_main_variant (type)
-     register tree type;
+     tree type;
 {
   type = TYPE_MAIN_VARIANT (type);
 
@@ -3743,9 +3743,9 @@ type_main_variant (type)
 
 static inline int
 is_tagged_type (type)
-     register tree type;
+     tree type;
 {
-  register enum tree_code code = TREE_CODE (type);
+  enum tree_code code = TREE_CODE (type);
 
   return (code == RECORD_TYPE || code == UNION_TYPE
 	  || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
@@ -3755,7 +3755,7 @@ is_tagged_type (type)
 
 static const char *
 dwarf_tag_name (tag)
-     register unsigned tag;
+     unsigned tag;
 {
   switch (tag)
     {
@@ -3876,7 +3876,7 @@ dwarf_tag_name (tag)
 
 static const char *
 dwarf_attr_name (attr)
-     register unsigned attr;
+     unsigned attr;
 {
   switch (attr)
     {
@@ -4074,7 +4074,7 @@ dwarf_attr_name (attr)
 
 static const char *
 dwarf_form_name (form)
-     register unsigned form;
+     unsigned form;
 {
   switch (form)
     {
@@ -4130,7 +4130,7 @@ dwarf_form_name (form)
 #if 0
 static const char *
 dwarf_type_encoding_name (enc)
-     register unsigned enc;
+     unsigned enc;
 {
   switch (enc)
     {
@@ -4164,7 +4164,7 @@ dwarf_type_encoding_name (enc)
 
 static tree
 decl_ultimate_origin (decl)
-     register tree decl;
+     tree decl;
 {
   /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
      nodes in the function to point to themselves; ignore that if
@@ -4190,9 +4190,9 @@ decl_ultimate_origin (decl)
 
 static tree
 block_ultimate_origin (block)
-     register tree block;
+     tree block;
 {
-  register tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
+  tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
 
   /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
      nodes in the function to point to themselves; ignore that if
@@ -4204,8 +4204,8 @@ block_ultimate_origin (block)
     return NULL_TREE;
   else
     {
-      register tree ret_val;
-      register tree lookahead = immediate_origin;
+      tree ret_val;
+      tree lookahead = immediate_origin;
 
       do
 	{
@@ -4247,8 +4247,8 @@ decl_class_context (decl)
 
 static inline void
 add_dwarf_attr (die, attr)
-     register dw_die_ref die;
-     register dw_attr_ref attr;
+     dw_die_ref die;
+     dw_attr_ref attr;
 {
   if (die != NULL && attr != NULL)
     {
@@ -4269,11 +4269,11 @@ AT_class (a)
 
 static inline void
 add_AT_flag (die, attr_kind, flag)
-     register dw_die_ref die;
-     register enum dwarf_attribute attr_kind;
-     register unsigned flag;
+     dw_die_ref die;
+     enum dwarf_attribute attr_kind;
+     unsigned flag;
 {
-  register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
+  dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
 
   attr->dw_attr_next = NULL;
   attr->dw_attr = attr_kind;
@@ -4285,7 +4285,7 @@ add_AT_flag (die, attr_kind, flag)
 static inline unsigned AT_flag PARAMS ((dw_attr_ref));
 static inline unsigned
 AT_flag (a)
-     register dw_attr_ref a;
+     dw_attr_ref a;
 {
   if (a && AT_class (a) == dw_val_class_flag)
     return a->dw_attr_val.v.val_flag;
@@ -4297,11 +4297,11 @@ AT_flag (a)
 
 static inline void
 add_AT_int (die, attr_kind, int_val)
-     register dw_die_ref die;
-     register enum dwarf_attribute attr_kind;
-     register long int int_val;
+     dw_die_ref die;
+     enum dwarf_attribute attr_kind;
+     long int int_val;
 {
-  register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
+  dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
 
   attr->dw_attr_next = NULL;
   attr->dw_attr = attr_kind;
@@ -4313,7 +4313,7 @@ add_AT_int (die, attr_kind, int_val)
 static inline long int AT_int PARAMS ((dw_attr_ref));
 static inline long int
 AT_int (a)
-     register dw_attr_ref a;
+     dw_attr_ref a;
 {
   if (a && AT_class (a) == dw_val_class_const)
     return a->dw_attr_val.v.val_int;
@@ -4325,11 +4325,11 @@ AT_int (a)
 
 static inline void
 add_AT_unsigned (die, attr_kind, unsigned_val)
-     register dw_die_ref die;
-     register enum dwarf_attribute attr_kind;
-     register unsigned long unsigned_val;
+     dw_die_ref die;
+     enum dwarf_attribute attr_kind;
+     unsigned long unsigned_val;
 {
-  register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
+  dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
 
   attr->dw_attr_next = NULL;
   attr->dw_attr = attr_kind;
@@ -4341,7 +4341,7 @@ add_AT_unsigned (die, attr_kind, unsigned_val)
 static inline unsigned long AT_unsigned PARAMS ((dw_attr_ref));
 static inline unsigned long
 AT_unsigned (a)
-     register dw_attr_ref a;
+     dw_attr_ref a;
 {
   if (a && AT_class (a) == dw_val_class_unsigned_const)
     return a->dw_attr_val.v.val_unsigned;
@@ -4353,12 +4353,12 @@ AT_unsigned (a)
 
 static inline void
 add_AT_long_long (die, attr_kind, val_hi, val_low)
-     register dw_die_ref die;
-     register enum dwarf_attribute attr_kind;
-     register unsigned long val_hi;
-     register unsigned long val_low;
+     dw_die_ref die;
+     enum dwarf_attribute attr_kind;
+     unsigned long val_hi;
+     unsigned long val_low;
 {
-  register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
+  dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
 
   attr->dw_attr_next = NULL;
   attr->dw_attr = attr_kind;
@@ -4372,12 +4372,12 @@ add_AT_long_long (die, attr_kind, val_hi, val_low)
 
 static inline void
 add_AT_float (die, attr_kind, length, array)
-     register dw_die_ref die;
-     register enum dwarf_attribute attr_kind;
-     register unsigned length;
-     register long *array;
+     dw_die_ref die;
+     enum dwarf_attribute attr_kind;
+     unsigned length;
+     long *array;
 {
-  register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
+  dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
 
   attr->dw_attr_next = NULL;
   attr->dw_attr = attr_kind;
@@ -4391,11 +4391,11 @@ add_AT_float (die, attr_kind, length, array)
 
 static inline void
 add_AT_string (die, attr_kind, str)
-     register dw_die_ref die;
-     register enum dwarf_attribute attr_kind;
-     register const char *str;
+     dw_die_ref die;
+     enum dwarf_attribute attr_kind;
+     const char *str;
 {
-  register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
+  dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
 
   attr->dw_attr_next = NULL;
   attr->dw_attr = attr_kind;
@@ -4407,7 +4407,7 @@ add_AT_string (die, attr_kind, str)
 static inline const char *AT_string PARAMS ((dw_attr_ref));
 static inline const char *
 AT_string (a)
-     register dw_attr_ref a;
+     dw_attr_ref a;
 {
   if (a && AT_class (a) == dw_val_class_str)
     return a->dw_attr_val.v.val_str;
@@ -4419,11 +4419,11 @@ AT_string (a)
 
 static inline void
 add_AT_die_ref (die, attr_kind, targ_die)
-     register dw_die_ref die;
-     register enum dwarf_attribute attr_kind;
-     register dw_die_ref targ_die;
+     dw_die_ref die;
+     enum dwarf_attribute attr_kind;
+     dw_die_ref targ_die;
 {
-  register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
+  dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
 
   attr->dw_attr_next = NULL;
   attr->dw_attr = attr_kind;
@@ -4436,7 +4436,7 @@ add_AT_die_ref (die, attr_kind, targ_die)
 static inline dw_die_ref AT_ref PARAMS ((dw_attr_ref));
 static inline dw_die_ref
 AT_ref (a)
-     register dw_attr_ref a;
+     dw_attr_ref a;
 {
   if (a && AT_class (a) == dw_val_class_die_ref)
     return a->dw_attr_val.v.val_die_ref.die;
@@ -4447,7 +4447,7 @@ AT_ref (a)
 static inline int AT_ref_external PARAMS ((dw_attr_ref));
 static inline int
 AT_ref_external (a)
-     register dw_attr_ref a;
+     dw_attr_ref a;
 {
   if (a && AT_class (a) == dw_val_class_die_ref)
     return a->dw_attr_val.v.val_die_ref.external;
@@ -4458,7 +4458,7 @@ AT_ref_external (a)
 static inline void set_AT_ref_external PARAMS ((dw_attr_ref, int));
 static inline void
 set_AT_ref_external (a, i)
-     register dw_attr_ref a;
+     dw_attr_ref a;
      int i;
 {
   if (a && AT_class (a) == dw_val_class_die_ref)
@@ -4471,11 +4471,11 @@ set_AT_ref_external (a, i)
 
 static inline void
 add_AT_fde_ref (die, attr_kind, targ_fde)
-     register dw_die_ref die;
-     register enum dwarf_attribute attr_kind;
-     register unsigned targ_fde;
+     dw_die_ref die;
+     enum dwarf_attribute attr_kind;
+     unsigned targ_fde;
 {
-  register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
+  dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
 
   attr->dw_attr_next = NULL;
   attr->dw_attr = attr_kind;
@@ -4488,11 +4488,11 @@ add_AT_fde_ref (die, attr_kind, targ_fde)
 
 static inline void
 add_AT_loc (die, attr_kind, loc)
-     register dw_die_ref die;
-     register enum dwarf_attribute attr_kind;
-     register dw_loc_descr_ref loc;
+     dw_die_ref die;
+     enum dwarf_attribute attr_kind;
+     dw_loc_descr_ref loc;
 {
-  register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
+  dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
 
   attr->dw_attr_next = NULL;
   attr->dw_attr = attr_kind;
@@ -4504,7 +4504,7 @@ add_AT_loc (die, attr_kind, loc)
 static inline dw_loc_descr_ref AT_loc PARAMS ((dw_attr_ref));
 static inline dw_loc_descr_ref
 AT_loc (a)
-     register dw_attr_ref a;
+     dw_attr_ref a;
 {
   if (a && AT_class (a) == dw_val_class_loc)
     return a->dw_attr_val.v.val_loc;
@@ -4514,11 +4514,11 @@ AT_loc (a)
 
 static inline void
 add_AT_loc_list (die, attr_kind, loc_list)
-     register dw_die_ref die;
-     register enum dwarf_attribute attr_kind;
-     register dw_loc_list_ref loc_list;
+     dw_die_ref die;
+     enum dwarf_attribute attr_kind;
+     dw_loc_list_ref loc_list;
 {
-  register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
+  dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
 
   attr->dw_attr_next = NULL;
   attr->dw_attr = attr_kind;
@@ -4532,7 +4532,7 @@ static inline dw_loc_list_ref AT_loc_list PARAMS ((dw_attr_ref));
 
 static inline dw_loc_list_ref
 AT_loc_list (a)
-     register dw_attr_ref a;
+     dw_attr_ref a;
 {
   if (a && AT_class (a) == dw_val_class_loc_list)
     return a->dw_attr_val.v.val_loc_list;
@@ -4544,11 +4544,11 @@ AT_loc_list (a)
 
 static inline void
 add_AT_addr (die, attr_kind, addr)
-     register dw_die_ref die;
-     register enum dwarf_attribute attr_kind;
+     dw_die_ref die;
+     enum dwarf_attribute attr_kind;
      rtx addr;
 {
-  register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
+  dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
 
   attr->dw_attr_next = NULL;
   attr->dw_attr = attr_kind;
@@ -4560,7 +4560,7 @@ add_AT_addr (die, attr_kind, addr)
 static inline rtx AT_addr PARAMS ((dw_attr_ref));
 static inline rtx
 AT_addr (a)
-     register dw_attr_ref a;
+     dw_attr_ref a;
 {
   if (a && AT_class (a) == dw_val_class_addr)
     return a->dw_attr_val.v.val_addr;
@@ -4572,11 +4572,11 @@ AT_addr (a)
 
 static inline void
 add_AT_lbl_id (die, attr_kind, lbl_id)
-     register dw_die_ref die;
-     register enum dwarf_attribute attr_kind;
-     register const char *lbl_id;
+     dw_die_ref die;
+     enum dwarf_attribute attr_kind;
+     const char *lbl_id;
 {
-  register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
+  dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
 
   attr->dw_attr_next = NULL;
   attr->dw_attr = attr_kind;
@@ -4589,11 +4589,11 @@ add_AT_lbl_id (die, attr_kind, lbl_id)
 
 static inline void
 add_AT_lbl_offset (die, attr_kind, label)
-     register dw_die_ref die;
-     register enum dwarf_attribute attr_kind;
-     register const char *label;
+     dw_die_ref die;
+     enum dwarf_attribute attr_kind;
+     const char *label;
 {
-  register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
+  dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
 
   attr->dw_attr_next = NULL;
   attr->dw_attr = attr_kind;
@@ -4606,11 +4606,11 @@ add_AT_lbl_offset (die, attr_kind, label)
 
 static void
 add_AT_offset (die, attr_kind, offset)
-     register dw_die_ref die;
-     register enum dwarf_attribute attr_kind;
-     register unsigned long offset;
+     dw_die_ref die;
+     enum dwarf_attribute attr_kind;
+     unsigned long offset;
 {
-  register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
+  dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
 
   attr->dw_attr_next = NULL;
   attr->dw_attr = attr_kind;
@@ -4622,7 +4622,7 @@ add_AT_offset (die, attr_kind, offset)
 static inline const char *AT_lbl PARAMS ((dw_attr_ref));
 static inline const char *
 AT_lbl (a)
-     register dw_attr_ref a;
+     dw_attr_ref a;
 {
   if (a && (AT_class (a) == dw_val_class_lbl_id
 	    || AT_class (a) == dw_val_class_lbl_offset))
@@ -4635,11 +4635,11 @@ AT_lbl (a)
 
 static inline dw_attr_ref
 get_AT (die, attr_kind)
-     register dw_die_ref die;
-     register enum dwarf_attribute attr_kind;
+     dw_die_ref die;
+     enum dwarf_attribute attr_kind;
 {
-  register dw_attr_ref a;
-  register dw_die_ref spec = NULL;
+  dw_attr_ref a;
+  dw_die_ref spec = NULL;
 
   if (die != NULL)
     {
@@ -4667,9 +4667,9 @@ get_AT (die, attr_kind)
 
 static inline const char *
 get_AT_low_pc (die)
-     register dw_die_ref die;
+     dw_die_ref die;
 {
-  register dw_attr_ref a = get_AT (die, DW_AT_low_pc);
+  dw_attr_ref a = get_AT (die, DW_AT_low_pc);
   return a ? AT_lbl (a) : NULL;
 }
 
@@ -4680,9 +4680,9 @@ get_AT_low_pc (die)
 
 static inline const char *
 get_AT_hi_pc (die)
-     register dw_die_ref die;
+     dw_die_ref die;
 {
-  register dw_attr_ref a = get_AT (die, DW_AT_high_pc);
+  dw_attr_ref a = get_AT (die, DW_AT_high_pc);
   return a ? AT_lbl (a) : NULL;
 }
 
@@ -4691,10 +4691,10 @@ get_AT_hi_pc (die)
 
 static inline const char *
 get_AT_string (die, attr_kind)
-     register dw_die_ref die;
-     register enum dwarf_attribute attr_kind;
+     dw_die_ref die;
+     enum dwarf_attribute attr_kind;
 {
-  register dw_attr_ref a = get_AT (die, attr_kind);
+  dw_attr_ref a = get_AT (die, attr_kind);
   return a ? AT_string (a) : NULL;
 }
 
@@ -4703,10 +4703,10 @@ get_AT_string (die, attr_kind)
 
 static inline int
 get_AT_flag (die, attr_kind)
-     register dw_die_ref die;
-     register enum dwarf_attribute attr_kind;
+     dw_die_ref die;
+     enum dwarf_attribute attr_kind;
 {
-  register dw_attr_ref a = get_AT (die, attr_kind);
+  dw_attr_ref a = get_AT (die, attr_kind);
   return a ? AT_flag (a) : 0;
 }
 
@@ -4715,26 +4715,26 @@ get_AT_flag (die, attr_kind)
 
 static inline unsigned
 get_AT_unsigned (die, attr_kind)
-     register dw_die_ref die;
-     register enum dwarf_attribute attr_kind;
+     dw_die_ref die;
+     enum dwarf_attribute attr_kind;
 {
-  register dw_attr_ref a = get_AT (die, attr_kind);
+  dw_attr_ref a = get_AT (die, attr_kind);
   return a ? AT_unsigned (a) : 0;
 }
 
 static inline dw_die_ref
 get_AT_ref (die, attr_kind)
      dw_die_ref die;
-     register enum dwarf_attribute attr_kind;
+     enum dwarf_attribute attr_kind;
 {
-  register dw_attr_ref a = get_AT (die, attr_kind);
+  dw_attr_ref a = get_AT (die, attr_kind);
   return a ? AT_ref (a) : NULL;
 }
 
 static inline int
 is_c_family ()
 {
-  register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
+  unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
 
   return (lang == DW_LANG_C || lang == DW_LANG_C89
 	  || lang == DW_LANG_C_plus_plus);
@@ -4743,7 +4743,7 @@ is_c_family ()
 static inline int
 is_fortran ()
 {
-  register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
+  unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
 
   return (lang == DW_LANG_Fortran77 || lang == DW_LANG_Fortran90);
 }
@@ -4751,7 +4751,7 @@ is_fortran ()
 static inline int
 is_java ()
 {
-  register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
+  unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
 
   return (lang == DW_LANG_Java);
 }
@@ -4786,11 +4786,11 @@ free_AT (a)
 
 static void
 remove_AT (die, attr_kind)
-     register dw_die_ref die;
-     register enum dwarf_attribute attr_kind;
+     dw_die_ref die;
+     enum dwarf_attribute attr_kind;
 {
-  register dw_attr_ref *p;
-  register dw_attr_ref removed = NULL;
+  dw_attr_ref *p;
+  dw_attr_ref removed = NULL;
 
   if (die != NULL)
     {
@@ -4822,22 +4822,22 @@ free_die (die)
 
 static void
 remove_children (die)
-     register dw_die_ref die;
+     dw_die_ref die;
 {
-  register dw_die_ref child_die = die->die_child;
+  dw_die_ref child_die = die->die_child;
 
   die->die_child = NULL;
 
   while (child_die != NULL)
     {
-      register dw_die_ref tmp_die = child_die;
-      register dw_attr_ref a;
+      dw_die_ref tmp_die = child_die;
+      dw_attr_ref a;
 
       child_die = child_die->die_sib;
 
       for (a = tmp_die->die_attr; a != NULL;)
 	{
-	  register dw_attr_ref tmp_a = a;
+	  dw_attr_ref tmp_a = a;
 
 	  a = a->dw_attr_next;
 	  free_AT (tmp_a);
@@ -4852,8 +4852,8 @@ remove_children (die)
 
 static inline void
 add_child_die (die, child_die)
-     register dw_die_ref die;
-     register dw_die_ref child_die;
+     dw_die_ref die;
+     dw_die_ref child_die;
 {
   if (die != NULL && child_die != NULL)
     {
@@ -4902,10 +4902,10 @@ splice_child_die (parent, child)
 
 static inline dw_die_ref
 new_die (tag_value, parent_die)
-     register enum dwarf_tag tag_value;
-     register dw_die_ref parent_die;
+     enum dwarf_tag tag_value;
+     dw_die_ref parent_die;
 {
-  register dw_die_ref die = (dw_die_ref) xcalloc (1, sizeof (die_node));
+  dw_die_ref die = (dw_die_ref) xcalloc (1, sizeof (die_node));
 
   die->die_tag = tag_value;
 
@@ -4928,7 +4928,7 @@ new_die (tag_value, parent_die)
 
 static inline dw_die_ref
 lookup_type_die (type)
-     register tree type;
+     tree type;
 {
   if (TREE_CODE (type) == VECTOR_TYPE)
     type = TYPE_DEBUG_REPRESENTATION_TYPE (type);
@@ -4939,8 +4939,8 @@ lookup_type_die (type)
 
 static inline void
 equate_type_number_to_die (type, type_die)
-     register tree type;
-     register dw_die_ref type_die;
+     tree type;
+     dw_die_ref type_die;
 {
   TYPE_SYMTAB_POINTER (type) = (char *) type_die;
 }
@@ -4949,9 +4949,9 @@ equate_type_number_to_die (type, type_die)
 
 static inline dw_die_ref
 lookup_decl_die (decl)
-     register tree decl;
+     tree decl;
 {
-  register unsigned decl_id = DECL_UID (decl);
+  unsigned decl_id = DECL_UID (decl);
 
   return (decl_id < decl_die_table_in_use
 	  ? decl_die_table[decl_id] : NULL);
@@ -4961,11 +4961,11 @@ lookup_decl_die (decl)
 
 static void
 equate_decl_number_to_die (decl, decl_die)
-     register tree decl;
-     register dw_die_ref decl_die;
+     tree decl;
+     dw_die_ref decl_die;
 {
-  register unsigned decl_id = DECL_UID (decl);
-  register unsigned num_allocated;
+  unsigned decl_id = DECL_UID (decl);
+  unsigned num_allocated;
 
   if (decl_id >= decl_die_table_allocated)
     {
@@ -5011,8 +5011,8 @@ print_die (die, outfile)
      dw_die_ref die;
      FILE *outfile;
 {
-  register dw_attr_ref a;
-  register dw_die_ref c;
+  dw_attr_ref a;
+  dw_die_ref c;
 
   print_spaces (outfile);
   fprintf (outfile, "DIE %4lu: %s\n",
@@ -5105,8 +5105,8 @@ static void
 print_dwarf_line_table (outfile)
      FILE *outfile;
 {
-  register unsigned i;
-  register dw_line_info_ref line_info;
+  unsigned i;
+  dw_line_info_ref line_info;
 
   fprintf (outfile, "\n\nDWARF source line information\n");
   for (i = 1; i < line_info_table_in_use; ++i)
@@ -5148,10 +5148,10 @@ debug_dwarf ()
 
 static void
 reverse_die_lists (die)
-     register dw_die_ref die;
+     dw_die_ref die;
 {
-  register dw_die_ref c, cp, cn;
-  register dw_attr_ref a, ap, an;
+  dw_die_ref c, cp, cn;
+  dw_attr_ref a, ap, an;
 
   for (a = die->die_attr, ap = 0; a; a = an)
     {
@@ -5179,9 +5179,9 @@ reverse_die_lists (die)
 
 static void
 reverse_all_dies (die)
-     register dw_die_ref die;
+     dw_die_ref die;
 {
-  register dw_die_ref c;
+  dw_die_ref c;
 
   reverse_die_lists (die);
 
@@ -5465,9 +5465,9 @@ gen_internal_sym (prefix)
 
 static void
 assign_symbol_names (die)
-     register dw_die_ref die;
+     dw_die_ref die;
 {
-  register dw_die_ref c;
+  dw_die_ref c;
 
   if (is_symbol_die (die))
     {
@@ -5492,15 +5492,15 @@ assign_symbol_names (die)
 
 static void
 break_out_includes (die)
-     register dw_die_ref die;
+     dw_die_ref die;
 {
   dw_die_ref *ptr;
-  register dw_die_ref unit = NULL;
+  dw_die_ref unit = NULL;
   limbo_die_node *node;
 
   for (ptr = &(die->die_child); *ptr; )
     {
-      register dw_die_ref c = *ptr;
+      dw_die_ref c = *ptr;
 
       if (c->die_tag == DW_TAG_GNU_BINCL
 	  || c->die_tag == DW_TAG_GNU_EINCL
@@ -5551,9 +5551,9 @@ break_out_includes (die)
 
 static void
 add_sibling_attributes (die)
-     register dw_die_ref die;
+     dw_die_ref die;
 {
-  register dw_die_ref c;
+  dw_die_ref c;
 
   if (die->die_tag != DW_TAG_compile_unit
       && die->die_sib && die->die_child != NULL)
@@ -5567,7 +5567,7 @@ add_sibling_attributes (die)
 /* Output all location lists for the DIE and it's children */
 static void
 output_location_lists (die)
-     register dw_die_ref die;
+     dw_die_ref die;
 {
   dw_die_ref c;
   dw_attr_ref d_attr;
@@ -5590,12 +5590,12 @@ output_location_lists (die)
 
 static void
 build_abbrev_table (die)
-     register dw_die_ref die;
+     dw_die_ref die;
 {
-  register unsigned long abbrev_id;
-  register unsigned int n_alloc;
-  register dw_die_ref c;
-  register dw_attr_ref d_attr, a_attr;
+  unsigned long abbrev_id;
+  unsigned int n_alloc;
+  dw_die_ref c;
+  dw_attr_ref d_attr, a_attr;
 
   /* Scan the DIE references, and mark as external any that refer to
      DIEs from other CUs (i.e. those which are not marked).  */
@@ -5612,7 +5612,7 @@ build_abbrev_table (die)
 
   for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
     {
-      register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
+      dw_die_ref abbrev = abbrev_die_table[abbrev_id];
 
       if (abbrev->die_tag == die->die_tag)
 	{
@@ -5669,7 +5669,7 @@ build_abbrev_table (die)
 
 static unsigned long
 size_of_string (str)
-     register const char *str;
+     const char *str;
 {
   return strlen (str) + 1;
 }
@@ -5698,10 +5698,10 @@ constant_size (value)
 
 static unsigned long
 size_of_die (die)
-     register dw_die_ref die;
+     dw_die_ref die;
 {
-  register unsigned long size = 0;
-  register dw_attr_ref a;
+  unsigned long size = 0;
+  dw_attr_ref a;
 
   size += size_of_uleb128 (die->die_abbrev);
   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
@@ -5716,7 +5716,7 @@ size_of_die (die)
 	  break;
 	case dw_val_class_loc:
 	  {
-	    register unsigned long lsize = size_of_locs (AT_loc (a));
+	    unsigned long lsize = size_of_locs (AT_loc (a));
 
 	    /* Block length.  */
 	    size += constant_size (lsize);
@@ -5774,7 +5774,7 @@ static void
 calc_die_sizes (die)
      dw_die_ref die;
 {
-  register dw_die_ref c;
+  dw_die_ref c;
   die->die_offset = next_die_offset;
   next_die_offset += size_of_die (die);
 
@@ -5795,7 +5795,7 @@ static void
 mark_dies (die)
      dw_die_ref die;
 {
-  register dw_die_ref c;
+  dw_die_ref c;
   die->die_mark = 1;
   for (c = die->die_child; c; c = c->die_sib)
     mark_dies (c);
@@ -5807,7 +5807,7 @@ static void
 unmark_dies (die)
      dw_die_ref die;
 {
-  register dw_die_ref c;
+  dw_die_ref c;
   die->die_mark = 0;
   for (c = die->die_child; c; c = c->die_sib)
     unmark_dies (c);
@@ -5819,13 +5819,13 @@ unmark_dies (die)
 static unsigned long
 size_of_pubnames ()
 {
-  register unsigned long size;
-  register unsigned i;
+  unsigned long size;
+  unsigned i;
 
   size = DWARF_PUBNAMES_HEADER_SIZE;
   for (i = 0; i < pubname_table_in_use; ++i)
     {
-      register pubname_ref p = &pubname_table[i];
+      pubname_ref p = &pubname_table[i];
       size += DWARF_OFFSET_SIZE + size_of_string (p->name);
     }
 
@@ -5838,7 +5838,7 @@ size_of_pubnames ()
 static unsigned long
 size_of_aranges ()
 {
-  register unsigned long size;
+  unsigned long size;
 
   size = DWARF_ARANGES_HEADER_SIZE;
 
@@ -5943,7 +5943,7 @@ output_abbrev_section ()
   dw_attr_ref a_attr;
   for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
     {
-      register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
+      dw_die_ref abbrev = abbrev_die_table[abbrev_id];
 
       dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
 
@@ -5975,7 +5975,7 @@ output_abbrev_section ()
 
 static inline void
 output_die_symbol (die)
-     register dw_die_ref die;
+     dw_die_ref die;
 {
   char *sym = die->die_symbol;
 
@@ -5996,13 +5996,13 @@ output_die_symbol (die)
    the list only.  */ 
 static inline dw_loc_list_ref
 new_loc_list (expr, begin, end, section, gensym)
-     register dw_loc_descr_ref expr;
-     register const char *begin;
-     register const char *end;
-     register const char *section;
-     register unsigned gensym;
+     dw_loc_descr_ref expr;
+     const char *begin;
+     const char *end;
+     const char *section;
+     unsigned gensym;
 {
-  register dw_loc_list_ref retlist
+  dw_loc_list_ref retlist
     = (dw_loc_list_ref) xcalloc (1, sizeof (dw_loc_list_node));
   retlist->begin = begin;
   retlist->end = end;
@@ -6016,13 +6016,13 @@ new_loc_list (expr, begin, end, section, gensym)
 /* Add a location description expression to a location list */
 static inline void
 add_loc_descr_to_loc_list (list_head, descr, begin, end, section)
-     register dw_loc_list_ref *list_head;
-     register dw_loc_descr_ref descr;
-     register const char *begin;
-     register const char *end;
-     register const char *section;
+     dw_loc_list_ref *list_head;
+     dw_loc_descr_ref descr;
+     const char *begin;
+     const char *end;
+     const char *section;
 {
-  register dw_loc_list_ref *d;
+  dw_loc_list_ref *d;
   
   /* Find the end of the chain.  */
   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
@@ -6034,9 +6034,9 @@ add_loc_descr_to_loc_list (list_head, descr, begin, end, section)
 /* Output the location list given to us */
 static void
 output_loc_list (list_head)
-     register dw_loc_list_ref list_head;
+     dw_loc_list_ref list_head;
 {
-  register dw_loc_list_ref curr=list_head;
+  dw_loc_list_ref curr=list_head;
   ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
 
   /* ??? This shouldn't be needed now that we've forced the
@@ -6079,11 +6079,11 @@ output_loc_list (list_head)
 
 static void
 output_die (die)
-     register dw_die_ref die;
+     dw_die_ref die;
 {
-  register dw_attr_ref a;
-  register dw_die_ref c;
-  register unsigned long size;
+  dw_attr_ref a;
+  dw_die_ref c;
+  unsigned long size;
 
   /* If someone in another CU might refer to us, set up a symbol for
      them to point to.  */
@@ -6155,7 +6155,7 @@ output_die (die)
 
 	case dw_val_class_float:
 	  {
-	    register unsigned int i;
+	    unsigned int i;
 
 	    dw2_asm_output_data (1, a->dw_attr_val.v.val_float.length * 4,
 			         "%s", name);
@@ -6337,8 +6337,8 @@ add_pubname (decl, die)
 static void
 output_pubnames ()
 {
-  register unsigned i;
-  register unsigned long pubnames_length = size_of_pubnames ();
+  unsigned i;
+  unsigned long pubnames_length = size_of_pubnames ();
 
   dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
 		       "Length of Public Names Info");
@@ -6353,7 +6353,7 @@ output_pubnames ()
 
   for (i = 0; i < pubname_table_in_use; ++i)
     {
-      register pubname_ref pub = &pubname_table[i];
+      pubname_ref pub = &pubname_table[i];
 
       /* We shouldn't see pubnames for DIEs outside of the main CU.  */
       if (pub->die->die_mark == 0)
@@ -6395,8 +6395,8 @@ add_arange (decl, die)
 static void
 output_aranges ()
 {
-  register unsigned i;
-  register unsigned long aranges_length = size_of_aranges ();
+  unsigned i;
+  unsigned long aranges_length = size_of_aranges ();
 
   dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
 		       "Length of Address Ranges Info");
@@ -6494,7 +6494,7 @@ add_ranges (block)
 static void
 output_ranges ()
 {
-  register unsigned i;
+  unsigned i;
   static const char *const start_fmt = "Offset 0x%x";
   const char *fmt = start_fmt;
 
@@ -6821,14 +6821,14 @@ output_line_info ()
   char l1[20], l2[20], p1[20], p2[20];
   char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
   char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
-  register unsigned opc;
-  register unsigned n_op_args;
-  register unsigned long lt_index;
-  register unsigned long current_line;
-  register long line_offset;
-  register long line_delta;
-  register unsigned long current_file;
-  register unsigned long function;
+  unsigned opc;
+  unsigned n_op_args;
+  unsigned long lt_index;
+  unsigned long current_line;
+  long line_offset;
+  long line_delta;
+  unsigned long current_file;
+  unsigned long function;
 
   ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
   ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
@@ -6894,7 +6894,7 @@ output_line_info ()
   strcpy (prev_line_label, text_section_label);
   for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
     {
-      register dw_line_info_ref line_info = &line_info_table[lt_index];
+      dw_line_info_ref line_info = &line_info_table[lt_index];
 
 #if 0
       /* Disable this optimization for now; GDB wants to see two line notes
@@ -7003,7 +7003,7 @@ output_line_info ()
   current_line = 1;
   for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
     {
-      register dw_separate_line_info_ref line_info
+      dw_separate_line_info_ref line_info
 	= &separate_line_info_table[lt_index];
 
 #if 0
@@ -7126,12 +7126,12 @@ output_line_info ()
 
 static dw_die_ref
 base_type_die (type)
-     register tree type;
+     tree type;
 {
-  register dw_die_ref base_type_result;
-  register const char *type_name;
-  register enum dwarf_type encoding;
-  register tree name = TYPE_NAME (type);
+  dw_die_ref base_type_result;
+  const char *type_name;
+  enum dwarf_type encoding;
+  tree name = TYPE_NAME (type);
 
   if (TREE_CODE (type) == ERROR_MARK
       || TREE_CODE (type) == VOID_TYPE)
@@ -7220,7 +7220,7 @@ base_type_die (type)
 
 static tree
 root_type (type)
-     register tree type;
+     tree type;
 {
   if (TREE_CODE (type) == ERROR_MARK)
     return error_mark_node;
@@ -7244,7 +7244,7 @@ root_type (type)
 
 static inline int
 is_base_type (type)
-     register tree type;
+     tree type;
 {
   switch (TREE_CODE (type))
     {
@@ -7285,15 +7285,15 @@ is_base_type (type)
 
 static dw_die_ref
 modified_type_die (type, is_const_type, is_volatile_type, context_die)
-     register tree type;
-     register int is_const_type;
-     register int is_volatile_type;
-     register dw_die_ref context_die;
+     tree type;
+     int is_const_type;
+     int is_volatile_type;
+     dw_die_ref context_die;
 {
-  register enum tree_code code = TREE_CODE (type);
-  register dw_die_ref mod_type_die = NULL;
-  register dw_die_ref sub_die = NULL;
-  register tree item_type = NULL;
+  enum tree_code code = TREE_CODE (type);
+  dw_die_ref mod_type_die = NULL;
+  dw_die_ref sub_die = NULL;
+  tree item_type = NULL;
 
   if (code != ERROR_MARK)
     {
@@ -7414,7 +7414,7 @@ modified_type_die (type, is_const_type, is_volatile_type, context_die)
 
 static inline int
 type_is_enum (type)
-     register tree type;
+     tree type;
 {
   return TREE_CODE (type) == ENUMERAL_TYPE;
 }
@@ -7423,9 +7423,9 @@ type_is_enum (type)
 
 static unsigned int
 reg_number (rtl)
-     register rtx rtl;
+     rtx rtl;
 {
-  register unsigned regno = REGNO (rtl);
+  unsigned regno = REGNO (rtl);
 
   if (regno >= FIRST_PSEUDO_REGISTER)
     {
@@ -7441,10 +7441,10 @@ reg_number (rtl)
 
 static dw_loc_descr_ref
 reg_loc_descriptor (rtl)
-     register rtx rtl;
+     rtx rtl;
 {
-  register dw_loc_descr_ref loc_result = NULL;
-  register unsigned reg = reg_number (rtl);
+  dw_loc_descr_ref loc_result = NULL;
+  unsigned reg = reg_number (rtl);
 
   if (reg <= 31)
     loc_result = new_loc_descr (DW_OP_reg0 + reg, 0, 0);
@@ -7501,13 +7501,13 @@ based_loc_descr (reg, offset)
      unsigned reg;
      long int offset;
 {
-  register dw_loc_descr_ref loc_result;
+  dw_loc_descr_ref loc_result;
   /* For the "frame base", we use the frame pointer or stack pointer
      registers, since the RTL for local variables is relative to one of
      them.  */
-  register unsigned fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed
-						  ? HARD_FRAME_POINTER_REGNUM
-						  : STACK_POINTER_REGNUM);
+  unsigned fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed
+					 ? HARD_FRAME_POINTER_REGNUM
+					 : STACK_POINTER_REGNUM);
 
   if (reg == fp_reg)
     loc_result = new_loc_descr (DW_OP_fbreg, offset, 0);
@@ -7523,7 +7523,7 @@ based_loc_descr (reg, offset)
 
 static inline int
 is_based_loc (rtl)
-     register rtx rtl;
+     rtx rtl;
 {
     return (GET_CODE (rtl) == PLUS
 	    && ((GET_CODE (XEXP (rtl, 0)) == REG
@@ -7545,7 +7545,7 @@ is_based_loc (rtl)
 
 static dw_loc_descr_ref
 mem_loc_descriptor (rtl, mode)
-     register rtx rtl;
+     rtx rtl;
      enum machine_mode mode;
 {
   dw_loc_descr_ref mem_loc_result = NULL;
@@ -7690,7 +7690,7 @@ mem_loc_descriptor (rtl, mode)
 
 static dw_loc_descr_ref
 concat_loc_descriptor (x0, x1)
-     register rtx x0, x1;
+     rtx x0, x1;
 {
   dw_loc_descr_ref cc_loc_result = NULL;
 
@@ -7717,7 +7717,7 @@ concat_loc_descriptor (x0, x1)
 
 static dw_loc_descr_ref
 loc_descriptor (rtl)
-     register rtx rtl;
+     rtx rtl;
 {
   dw_loc_descr_ref loc_result = NULL;
   switch (GET_CODE (rtl))
@@ -8038,9 +8038,9 @@ ceiling (value, boundary)
 
 static inline tree
 field_type (decl)
-     register tree decl;
+     tree decl;
 {
-  register tree type;
+  tree type;
 
   if (TREE_CODE (decl) == ERROR_MARK)
     return integer_type_node;
@@ -8058,14 +8058,14 @@ field_type (decl)
 
 static inline unsigned
 simple_type_align_in_bits (type)
-     register tree type;
+     tree type;
 {
   return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
 }
 
 static inline unsigned
 simple_decl_align_in_bits (decl)
-     register tree decl;
+     tree decl;
 {
   return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
 }
@@ -8078,7 +8078,7 @@ simple_decl_align_in_bits (decl)
 
 static inline unsigned HOST_WIDE_INT
 simple_type_size_in_bits (type)
-     register tree type;
+     tree type;
 {
   tree type_size_tree;
 
@@ -8102,7 +8102,7 @@ simple_type_size_in_bits (type)
 
 static HOST_WIDE_INT
 field_byte_offset (decl)
-     register tree decl;
+     tree decl;
 {
   unsigned int type_align_in_bits;
   unsigned int decl_align_in_bits;
@@ -8228,7 +8228,7 @@ static void
 add_AT_location_description (die, attr_kind, rtl)
      dw_die_ref die;
      enum dwarf_attribute attr_kind;
-     register rtx rtl;
+     rtx rtl;
 {
   /* Handle a special case.  If we are about to output a location descriptor
      for a variable or parameter which has been optimized out of existence,
@@ -8278,12 +8278,12 @@ add_AT_location_description (die, attr_kind, rtl)
 
 static void
 add_data_member_location_attribute (die, decl)
-     register dw_die_ref die;
-     register tree decl;
+     dw_die_ref die;
+     tree decl;
 {
-  register unsigned long offset;
-  register dw_loc_descr_ref loc_descr;
-  register enum dwarf_location_atom op;
+  unsigned long offset;
+  dw_loc_descr_ref loc_descr;
+  enum dwarf_location_atom op;
 
   if (TREE_CODE (decl) == TREE_VEC)
     offset = tree_low_cst (BINFO_OFFSET (decl), 0);
@@ -8314,8 +8314,8 @@ add_data_member_location_attribute (die, decl)
 
 static void
 add_const_value_attribute (die, rtl)
-     register dw_die_ref die;
-     register rtx rtl;
+     dw_die_ref die;
+     rtx rtl;
 {
   switch (GET_CODE (rtl))
     {
@@ -8350,11 +8350,11 @@ add_const_value_attribute (die, rtl)
          constant requires more than one word in order to be adequately
          represented.  We output CONST_DOUBLEs as blocks.  */
       {
-	register enum machine_mode mode = GET_MODE (rtl);
+	enum machine_mode mode = GET_MODE (rtl);
 
 	if (GET_MODE_CLASS (mode) == MODE_FLOAT)
 	  {
-	    register unsigned length = GET_MODE_SIZE (mode) / 4;
+	    unsigned length = GET_MODE_SIZE (mode) / 4;
  	    long *array = (long *) xmalloc (sizeof (long) * length);
 	    REAL_VALUE_TYPE rv;
 
@@ -8426,7 +8426,7 @@ static rtx
 rtl_for_decl_location (decl)
      tree decl;
 {
-  register rtx rtl;
+  rtx rtl;
 
   /* Here we have to decide where we are going to say the parameter "lives"
      (as far as the debugger is concerned).  We only have a couple of
@@ -8583,10 +8583,10 @@ rtl_for_decl_location (decl)
 
 static void
 add_location_or_const_value_attribute (die, decl)
-     register dw_die_ref die;
-     register tree decl;
+     dw_die_ref die;
+     tree decl;
 {
-  register rtx rtl;
+  rtx rtl;
 
   if (TREE_CODE (decl) == ERROR_MARK)
     return;
@@ -8672,8 +8672,8 @@ tree_add_const_value_attribute (var_die, decl)
 
 static inline void
 add_name_attribute (die, name_string)
-     register dw_die_ref die;
-     register const char *name_string;
+     dw_die_ref die;
+     const char *name_string;
 {
   if (name_string != NULL && *name_string != 0)
     {
@@ -8689,9 +8689,9 @@ add_name_attribute (die, name_string)
 
 static void
 add_bound_info (subrange_die, bound_attr, bound)
-     register dw_die_ref subrange_die;
-     register enum dwarf_attribute bound_attr;
-     register tree bound;
+     dw_die_ref subrange_die;
+     enum dwarf_attribute bound_attr;
+     tree bound;
 {
   /* If this is an Ada unconstrained array type, then don't emit any debug
      info because the array bounds are unknown.  They are parameterized when
@@ -8748,9 +8748,9 @@ add_bound_info (subrange_die, bound_attr, bound)
       if (SAVE_EXPR_RTL (bound)
 	  && (! optimize || GET_CODE (SAVE_EXPR_RTL (bound)) == MEM))
 	{
-	  register dw_die_ref ctx = lookup_decl_die (current_function_decl);
-	  register dw_die_ref decl_die = new_die (DW_TAG_variable, ctx);
-	  register rtx loc = SAVE_EXPR_RTL (bound);
+	  dw_die_ref ctx = lookup_decl_die (current_function_decl);
+	  dw_die_ref decl_die = new_die (DW_TAG_variable, ctx);
+	  rtx loc = SAVE_EXPR_RTL (bound);
 
 	  /* If the RTL for the SAVE_EXPR is memory, handle the case where
 	     it references an outer function's frame.  */
@@ -8817,14 +8817,14 @@ add_bound_info (subrange_die, bound_attr, bound)
 
 static void
 add_subscript_info (type_die, type)
-     register dw_die_ref type_die;
-     register tree type;
+     dw_die_ref type_die;
+     tree type;
 {
 #ifndef MIPS_DEBUGGING_INFO
-  register unsigned dimension_number;
+  unsigned dimension_number;
 #endif
-  register tree lower, upper;
-  register dw_die_ref subrange_die;
+  tree lower, upper;
+  dw_die_ref subrange_die;
 
   /* The GNU compilers represent multidimensional array types as sequences of
      one dimensional array types whose element types are themselves array
@@ -8845,7 +8845,7 @@ add_subscript_info (type_die, type)
        type = TREE_TYPE (type), dimension_number++)
     {
 #endif
-      register tree domain = TYPE_DOMAIN (type);
+      tree domain = TYPE_DOMAIN (type);
 
       /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
 	 and (in GNU C only) variable bounds.  Handle all three forms
@@ -8898,9 +8898,9 @@ add_subscript_info (type_die, type)
 static void
 add_byte_size_attribute (die, tree_node)
      dw_die_ref die;
-     register tree tree_node;
+     tree tree_node;
 {
-  register unsigned size;
+  unsigned size;
 
   switch (TREE_CODE (tree_node))
     {
@@ -8951,8 +8951,8 @@ add_byte_size_attribute (die, tree_node)
 
 static inline void
 add_bit_offset_attribute (die, decl)
-     register dw_die_ref die;
-     register tree decl;
+     dw_die_ref die;
+     tree decl;
 {
   HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
   tree type = DECL_BIT_FIELD_TYPE (decl);
@@ -9002,8 +9002,8 @@ add_bit_offset_attribute (die, decl)
 
 static inline void
 add_bit_size_attribute (die, decl)
-     register dw_die_ref die;
-     register tree decl;
+     dw_die_ref die;
+     tree decl;
 {
   /* Must be a field and a bit field.  */
   if (TREE_CODE (decl) != FIELD_DECL
@@ -9019,8 +9019,8 @@ add_bit_size_attribute (die, decl)
 
 static inline void
 add_prototyped_attribute (die, func_type)
-     register dw_die_ref die;
-     register tree func_type;
+     dw_die_ref die;
+     tree func_type;
 {
   if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
       && TYPE_ARG_TYPES (func_type) != NULL)
@@ -9033,8 +9033,8 @@ add_prototyped_attribute (die, func_type)
 
 static inline void
 add_abstract_origin_attribute (die, origin)
-     register dw_die_ref die;
-     register tree origin;
+     dw_die_ref die;
+     tree origin;
 {
   dw_die_ref origin_die = NULL;
 
@@ -9069,8 +9069,8 @@ add_abstract_origin_attribute (die, origin)
 
 static inline void
 add_pure_or_virtual_attribute (die, func_decl)
-     register dw_die_ref die;
-     register tree func_decl;
+     dw_die_ref die;
+     tree func_decl;
 {
   if (DECL_VINDEX (func_decl))
     {
@@ -9093,10 +9093,10 @@ add_pure_or_virtual_attribute (die, func_decl)
 
 static void
 add_src_coords_attributes (die, decl)
-     register dw_die_ref die;
-     register tree decl;
+     dw_die_ref die;
+     tree decl;
 {
-  register unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl));
+  unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl));
 
   add_AT_unsigned (die, DW_AT_decl_file, file_index);
   add_AT_unsigned (die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
@@ -9107,10 +9107,10 @@ add_src_coords_attributes (die, decl)
 
 static void
 add_name_and_src_coords_attributes (die, decl)
-     register dw_die_ref die;
-     register tree decl;
+     dw_die_ref die;
+     tree decl;
 {
-  register tree decl_name;
+  tree decl_name;
 
   decl_name = DECL_NAME (decl);
   if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
@@ -9154,12 +9154,12 @@ pop_decl_scope ()
 
 static dw_die_ref
 scope_die_for (t, context_die)
-     register tree t;
-     register dw_die_ref context_die;
+     tree t;
+     dw_die_ref context_die;
 {
-  register dw_die_ref scope_die = NULL;
-  register tree containing_scope;
-  register int i;
+  dw_die_ref scope_die = NULL;
+  tree containing_scope;
+  int i;
 
   /* Non-types always go in the current scope.  */
   if (! TYPE_P (t))
@@ -9239,14 +9239,14 @@ class_scope_p (context_die)
 
 static void
 add_type_attribute (object_die, type, decl_const, decl_volatile, context_die)
-     register dw_die_ref object_die;
-     register tree type;
-     register int decl_const;
-     register int decl_volatile;
-     register dw_die_ref context_die;
+     dw_die_ref object_die;
+     tree type;
+     int decl_const;
+     int decl_volatile;
+     dw_die_ref context_die;
 {
-  register enum tree_code code  = TREE_CODE (type);
-  register dw_die_ref type_die  = NULL;
+  enum tree_code code  = TREE_CODE (type);
+  dw_die_ref type_die  = NULL;
 
   /* ??? If this type is an unnamed subrange type of an integral or
      floating-point type, use the inner type.  This is because we have no
@@ -9279,13 +9279,13 @@ add_type_attribute (object_die, type, decl_const, decl_volatile, context_die)
 
 static const char *
 type_tag (type)
-     register tree type;
+     tree type;
 {
-  register const char *name = 0;
+  const char *name = 0;
 
   if (TYPE_NAME (type) != 0)
     {
-      register tree t = 0;
+      tree t = 0;
 
       /* Find the IDENTIFIER_NODE for the type name.  */
       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
@@ -9311,7 +9311,7 @@ type_tag (type)
 
 static inline tree
 member_declared_type (member)
-     register tree member;
+     tree member;
 {
   return (DECL_BIT_FIELD_TYPE (member)
 	  ? DECL_BIT_FIELD_TYPE (member)
@@ -9324,7 +9324,7 @@ member_declared_type (member)
 #if 0
 static const char *
 decl_start_label (decl)
-     register tree decl;
+     tree decl;
 {
   rtx x;
   const char *fnname;
@@ -9347,12 +9347,12 @@ decl_start_label (decl)
 
 static void
 gen_array_type_die (type, context_die)
-     register tree type;
-     register dw_die_ref context_die;
+     tree type;
+     dw_die_ref context_die;
 {
-  register dw_die_ref scope_die = scope_die_for (type, context_die);
-  register dw_die_ref array_die;
-  register tree element_type;
+  dw_die_ref scope_die = scope_die_for (type, context_die);
+  dw_die_ref array_die;
+  tree element_type;
 
   /* ??? The SGI dwarf reader fails for array of array of enum types unless
      the inner array type comes before the outer array type.  Thus we must
@@ -9405,10 +9405,10 @@ gen_array_type_die (type, context_die)
 
 static void
 gen_set_type_die (type, context_die)
-     register tree type;
-     register dw_die_ref context_die;
+     tree type;
+     dw_die_ref context_die;
 {
-  register dw_die_ref type_die
+  dw_die_ref type_die
     = new_die (DW_TAG_set_type, scope_die_for (type, context_die));
 
   equate_type_number_to_die (type, type_die);
@@ -9418,11 +9418,11 @@ gen_set_type_die (type, context_die)
 #if 0
 static void
 gen_entry_point_die (decl, context_die)
-     register tree decl;
-     register dw_die_ref context_die;
+     tree decl;
+     dw_die_ref context_die;
 {
-  register tree origin = decl_ultimate_origin (decl);
-  register dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die);
+  tree origin = decl_ultimate_origin (decl);
+  dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die);
   if (origin != NULL)
     add_abstract_origin_attribute (decl_die, origin);
   else
@@ -9464,11 +9464,10 @@ retry_incomplete_types ()
 
 static void
 gen_inlined_enumeration_type_die (type, context_die)
-     register tree type;
-     register dw_die_ref context_die;
+     tree type;
+     dw_die_ref context_die;
 {
-  register dw_die_ref type_die = new_die (DW_TAG_enumeration_type,
-					  context_die);
+  dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die);
   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
      be incomplete and such types are not marked.  */
   add_abstract_origin_attribute (type_die, type);
@@ -9478,10 +9477,10 @@ gen_inlined_enumeration_type_die (type, context_die)
 
 static void
 gen_inlined_structure_type_die (type, context_die)
-     register tree type;
-     register dw_die_ref context_die;
+     tree type;
+     dw_die_ref context_die;
 {
-  register dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die);
+  dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die);
 
   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
      be incomplete and such types are not marked.  */
@@ -9492,10 +9491,10 @@ gen_inlined_structure_type_die (type, context_die)
 
 static void
 gen_inlined_union_type_die (type, context_die)
-     register tree type;
-     register dw_die_ref context_die;
+     tree type;
+     dw_die_ref context_die;
 {
-  register dw_die_ref type_die = new_die (DW_TAG_union_type, context_die);
+  dw_die_ref type_die = new_die (DW_TAG_union_type, context_die);
 
   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
      be incomplete and such types are not marked.  */
@@ -9509,10 +9508,10 @@ gen_inlined_union_type_die (type, context_die)
 
 static void
 gen_enumeration_type_die (type, context_die)
-     register tree type;
-     register dw_die_ref context_die;
+     tree type;
+     dw_die_ref context_die;
 {
-  register dw_die_ref type_die = lookup_type_die (type);
+  dw_die_ref type_die = lookup_type_die (type);
 
   if (type_die == NULL)
     {
@@ -9531,7 +9530,7 @@ gen_enumeration_type_die (type, context_die)
      attribute or the DW_AT_element_list attribute.  */
   if (TYPE_SIZE (type))
     {
-      register tree link;
+      tree link;
 
       TREE_ASM_WRITTEN (type) = 1;
       add_byte_size_attribute (type_die, type);
@@ -9546,7 +9545,7 @@ gen_enumeration_type_die (type, context_die)
       for (link = TYPE_FIELDS (type);
 	   link != NULL; link = TREE_CHAIN (link))
 	{
-	  register dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die);
+	  dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die);
 
 	  add_name_attribute (enum_die,
 			      IDENTIFIER_POINTER (TREE_PURPOSE (link)));
@@ -9581,12 +9580,12 @@ gen_enumeration_type_die (type, context_die)
 
 static dw_die_ref
 gen_formal_parameter_die (node, context_die)
-     register tree node;
-     register dw_die_ref context_die;
+     tree node;
+     dw_die_ref context_die;
 {
-  register dw_die_ref parm_die
+  dw_die_ref parm_die
     = new_die (DW_TAG_formal_parameter, context_die);
-  register tree origin;
+  tree origin;
 
   switch (TREE_CODE_CLASS (TREE_CODE (node)))
     {
@@ -9628,8 +9627,8 @@ gen_formal_parameter_die (node, context_die)
 
 static void
 gen_unspecified_parameters_die (decl_or_type, context_die)
-     register tree decl_or_type ATTRIBUTE_UNUSED;
-     register dw_die_ref context_die;
+     tree decl_or_type ATTRIBUTE_UNUSED;
+     dw_die_ref context_die;
 {
   new_die (DW_TAG_unspecified_parameters, context_die);
 }
@@ -9641,12 +9640,12 @@ gen_unspecified_parameters_die (decl_or_type, context_die)
 
 static void
 gen_formal_types_die (function_or_method_type, context_die)
-     register tree function_or_method_type;
-     register dw_die_ref context_die;
+     tree function_or_method_type;
+     dw_die_ref context_die;
 {
-  register tree link;
-  register tree formal_type = NULL;
-  register tree first_parm_type;
+  tree link;
+  tree formal_type = NULL;
+  tree first_parm_type;
   tree arg;
 
   if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
@@ -9663,7 +9662,7 @@ gen_formal_types_die (function_or_method_type, context_die)
      DW_TAG_formal_parameter DIE for each one.  */
   for (link = first_parm_type; link; )
     {
-      register dw_die_ref parm_die;
+      dw_die_ref parm_die;
 
       formal_type = TREE_VALUE (link);
       if (formal_type == void_type_node)
@@ -9738,7 +9737,7 @@ static void
 dwarf2out_abstract_function (decl)
      tree decl;
 {
-  register dw_die_ref old_die;
+  dw_die_ref old_die;
   tree save_fn;
   tree context;
   int was_abstract = DECL_ABSTRACT (decl);
@@ -9778,18 +9777,18 @@ dwarf2out_abstract_function (decl)
 
 static void
 gen_subprogram_die (decl, context_die)
-     register tree decl;
-     register dw_die_ref context_die;
+     tree decl;
+     dw_die_ref context_die;
 {
   char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
-  register tree origin = decl_ultimate_origin (decl);
-  register dw_die_ref subr_die;
-  register rtx fp_reg;
-  register tree fn_arg_types;
-  register tree outer_scope;
-  register dw_die_ref old_die = lookup_decl_die (decl);
-  register int declaration = (current_function_decl != decl
-			      || class_scope_p (context_die));
+  tree origin = decl_ultimate_origin (decl);
+  dw_die_ref subr_die;
+  rtx fp_reg;
+  tree fn_arg_types;
+  tree outer_scope;
+  dw_die_ref old_die = lookup_decl_die (decl);
+  int declaration = (current_function_decl != decl
+		     || class_scope_p (context_die));
 
   /* Note that it is possible to have both DECL_ABSTRACT and `declaration'
      be true, if we started to generate the abstract instance of an inline,
@@ -9880,7 +9879,7 @@ gen_subprogram_die (decl, context_die)
       add_name_and_src_coords_attributes (subr_die, decl);
       if (debug_info_level > DINFO_LEVEL_TERSE)
 	{
-	  register tree type = TREE_TYPE (decl);
+	  tree type = TREE_TYPE (decl);
 
 	  add_prototyped_attribute (subr_die, type);
 	  add_type_attribute (subr_die, TREE_TYPE (type), 0, 0, context_die);
@@ -9984,8 +9983,8 @@ gen_subprogram_die (decl, context_die)
   else
     {
       /* Generate DIEs to represent all known formal parameters */
-      register tree arg_decls = DECL_ARGUMENTS (decl);
-      register tree parm;
+      tree arg_decls = DECL_ARGUMENTS (decl);
+      tree parm;
 
       /* When generating DIEs, generate the unspecified_parameters DIE
          instead if we come across the arg "__builtin_va_alist" */
@@ -10058,11 +10057,11 @@ gen_subprogram_die (decl, context_die)
 
 static void
 gen_variable_die (decl, context_die)
-     register tree decl;
-     register dw_die_ref context_die;
+     tree decl;
+     dw_die_ref context_die;
 {
-  register tree origin = decl_ultimate_origin (decl);
-  register dw_die_ref var_die = new_die (DW_TAG_variable, context_die);
+  tree origin = decl_ultimate_origin (decl);
+  dw_die_ref var_die = new_die (DW_TAG_variable, context_die);
 
   dw_die_ref old_die = lookup_decl_die (decl);
   int declaration = (DECL_EXTERNAL (decl)
@@ -10134,12 +10133,12 @@ gen_variable_die (decl, context_die)
 
 static void
 gen_label_die (decl, context_die)
-     register tree decl;
-     register dw_die_ref context_die;
+     tree decl;
+     dw_die_ref context_die;
 {
-  register tree origin = decl_ultimate_origin (decl);
-  register dw_die_ref lbl_die = new_die (DW_TAG_label, context_die);
-  register rtx insn;
+  tree origin = decl_ultimate_origin (decl);
+  dw_die_ref lbl_die = new_die (DW_TAG_label, context_die);
+  rtx insn;
   char label[MAX_ARTIFICIAL_LABEL_BYTES];
 
   if (origin != NULL)
@@ -10178,11 +10177,11 @@ gen_label_die (decl, context_die)
 
 static void
 gen_lexical_block_die (stmt, context_die, depth)
-     register tree stmt;
-     register dw_die_ref context_die;
+     tree stmt;
+     dw_die_ref context_die;
      int depth;
 {
-  register dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die);
+  dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die);
   char label[MAX_ARTIFICIAL_LABEL_BYTES];
 
   if (! BLOCK_ABSTRACT (stmt))
@@ -10220,15 +10219,15 @@ gen_lexical_block_die (stmt, context_die, depth)
 
 static void
 gen_inlined_subroutine_die (stmt, context_die, depth)
-     register tree stmt;
-     register dw_die_ref context_die;
+     tree stmt;
+     dw_die_ref context_die;
      int depth;
 {
   if (! BLOCK_ABSTRACT (stmt))
     {
-      register dw_die_ref subr_die
+      dw_die_ref subr_die
 	= new_die (DW_TAG_inlined_subroutine, context_die);
-      register tree decl = block_ultimate_origin (stmt);
+      tree decl = block_ultimate_origin (stmt);
       char label[MAX_ARTIFICIAL_LABEL_BYTES];
 
       /* Emit info for the abstract instance first, if we haven't yet.  */
@@ -10250,10 +10249,10 @@ gen_inlined_subroutine_die (stmt, context_die, depth)
 
 static void
 gen_field_die (decl, context_die)
-     register tree decl;
-     register dw_die_ref context_die;
+     tree decl;
+     dw_die_ref context_die;
 {
-  register dw_die_ref decl_die = new_die (DW_TAG_member, context_die);
+  dw_die_ref decl_die = new_die (DW_TAG_member, context_die);
 
   add_name_and_src_coords_attributes (decl_die, decl);
   add_type_attribute (decl_die, member_declared_type (decl),
@@ -10288,10 +10287,10 @@ gen_field_die (decl, context_die)
    represent certain things in other languages (e.g. Pascal) someday.  */
 static void
 gen_pointer_type_die (type, context_die)
-     register tree type;
-     register dw_die_ref context_die;
+     tree type;
+     dw_die_ref context_die;
 {
-  register dw_die_ref ptr_die
+  dw_die_ref ptr_die
     = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die));
 
   equate_type_number_to_die (type, ptr_die);
@@ -10305,10 +10304,10 @@ gen_pointer_type_die (type, context_die)
    represent certain things in other languages (e.g. Pascal) someday.  */
 static void
 gen_reference_type_die (type, context_die)
-     register tree type;
-     register dw_die_ref context_die;
+     tree type;
+     dw_die_ref context_die;
 {
-  register dw_die_ref ref_die
+  dw_die_ref ref_die
     = new_die (DW_TAG_reference_type, scope_die_for (type, context_die));
 
   equate_type_number_to_die (type, ref_die);
@@ -10320,10 +10319,10 @@ gen_reference_type_die (type, context_die)
 /* Generate a DIE for a pointer to a member type.  */
 static void
 gen_ptr_to_mbr_type_die (type, context_die)
-     register tree type;
-     register dw_die_ref context_die;
+     tree type;
+     dw_die_ref context_die;
 {
-  register dw_die_ref ptr_die
+  dw_die_ref ptr_die
     = new_die (DW_TAG_ptr_to_member_type, scope_die_for (type, context_die));
 
   equate_type_number_to_die (type, ptr_die);
@@ -10336,9 +10335,9 @@ gen_ptr_to_mbr_type_die (type, context_die)
 
 static dw_die_ref
 gen_compile_unit_die (filename)
-     register const char *filename;
+     const char *filename;
 {
-  register dw_die_ref die;
+  dw_die_ref die;
   char producer[250];
   const char *wd = getpwd ();
   int language;
@@ -10388,10 +10387,10 @@ gen_compile_unit_die (filename)
 
 static void
 gen_string_type_die (type, context_die)
-     register tree type;
-     register dw_die_ref context_die;
+     tree type;
+     dw_die_ref context_die;
 {
-  register dw_die_ref type_die
+  dw_die_ref type_die
     = new_die (DW_TAG_string_type, scope_die_for (type, context_die));
 
   equate_type_number_to_die (type, type_die);
@@ -10407,8 +10406,8 @@ gen_string_type_die (type, context_die)
 
 static void
 gen_inheritance_die (binfo, context_die)
-     register tree binfo;
-     register dw_die_ref context_die;
+     tree binfo;
+     dw_die_ref context_die;
 {
   dw_die_ref die = new_die (DW_TAG_inheritance, context_die);
 
@@ -10427,10 +10426,10 @@ gen_inheritance_die (binfo, context_die)
 
 static void
 gen_member_die (type, context_die)
-     register tree type;
-     register dw_die_ref context_die;
+     tree type;
+     dw_die_ref context_die;
 {
-  register tree member;
+  tree member;
   dw_die_ref child;
 
   /* If this is not an incomplete type, output descriptions of each of its
@@ -10449,9 +10448,9 @@ gen_member_die (type, context_die)
   /* First output info about the base classes.  */
   if (TYPE_BINFO (type) && TYPE_BINFO_BASETYPES (type))
     {
-      register tree bases = TYPE_BINFO_BASETYPES (type);
-      register int n_bases = TREE_VEC_LENGTH (bases);
-      register int i;
+      tree bases = TYPE_BINFO_BASETYPES (type);
+      int n_bases = TREE_VEC_LENGTH (bases);
+      int i;
 
       for (i = 0; i < n_bases; i++)
 	gen_inheritance_die (TREE_VEC_ELT (bases, i), context_die);
@@ -10493,12 +10492,12 @@ gen_member_die (type, context_die)
 
 static void
 gen_struct_or_union_type_die (type, context_die)
-     register tree type;
-     register dw_die_ref context_die;
+     tree type;
+     dw_die_ref context_die;
 {
-  register dw_die_ref type_die = lookup_type_die (type);
-  register dw_die_ref scope_die = 0;
-  register int nested = 0;
+  dw_die_ref type_die = lookup_type_die (type);
+  dw_die_ref scope_die = 0;
+  int nested = 0;
   int complete = (TYPE_SIZE (type)
 		  && (! TYPE_STUB_DECL (type)
 		      || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
@@ -10515,7 +10514,7 @@ gen_struct_or_union_type_die (type, context_die)
   if (! type_die || (nested && scope_die == comp_unit_die))
     /* First occurrence of type or toplevel definition of nested class.  */
     {
-      register dw_die_ref old_die = type_die;
+      dw_die_ref old_die = type_die;
 
       type_die = new_die (TREE_CODE (type) == RECORD_TYPE
 			  ? DW_TAG_structure_type : DW_TAG_union_type,
@@ -10573,11 +10572,11 @@ gen_struct_or_union_type_die (type, context_die)
 
 static void
 gen_subroutine_type_die (type, context_die)
-     register tree type;
-     register dw_die_ref context_die;
+     tree type;
+     dw_die_ref context_die;
 {
-  register tree return_type = TREE_TYPE (type);
-  register dw_die_ref subr_die
+  tree return_type = TREE_TYPE (type);
+  dw_die_ref subr_die
     = new_die (DW_TAG_subroutine_type, scope_die_for (type, context_die));
 
   equate_type_number_to_die (type, subr_die);
@@ -10590,11 +10589,11 @@ gen_subroutine_type_die (type, context_die)
 
 static void
 gen_typedef_die (decl, context_die)
-     register tree decl;
-     register dw_die_ref context_die;
+     tree decl;
+     dw_die_ref context_die;
 {
-  register dw_die_ref type_die;
-  register tree origin;
+  dw_die_ref type_die;
+  tree origin;
 
   if (TREE_ASM_WRITTEN (decl))
     return;
@@ -10606,7 +10605,7 @@ gen_typedef_die (decl, context_die)
     add_abstract_origin_attribute (type_die, origin);
   else
     {
-      register tree type;
+      tree type;
       add_name_and_src_coords_attributes (type_die, decl);
       if (DECL_ORIGINAL_TYPE (decl))
 	{
@@ -10631,8 +10630,8 @@ gen_typedef_die (decl, context_die)
 
 static void
 gen_type_die (type, context_die)
-     register tree type;
-     register dw_die_ref context_die;
+     tree type;
+     dw_die_ref context_die;
 {
   int need_pop;
 
@@ -10788,8 +10787,8 @@ gen_type_die (type, context_die)
 
 static void
 gen_tagged_type_instantiation_die (type, context_die)
-     register tree type;
-     register dw_die_ref context_die;
+     tree type;
+     dw_die_ref context_die;
 {
   if (type == NULL_TREE || type == error_mark_node)
     return;
@@ -10832,14 +10831,14 @@ gen_tagged_type_instantiation_die (type, context_die)
 
 static void
 gen_block_die (stmt, context_die, depth)
-     register tree stmt;
-     register dw_die_ref context_die;
+     tree stmt;
+     dw_die_ref context_die;
      int depth;
 {
-  register int must_output_die = 0;
-  register tree origin;
-  register tree decl;
-  register enum tree_code origin_code;
+  int must_output_die = 0;
+  tree origin;
+  tree decl;
+  enum tree_code origin_code;
 
   /* Ignore blocks never really used to make RTL.  */
   if (stmt == NULL_TREE || !TREE_USED (stmt)
@@ -10927,12 +10926,12 @@ gen_block_die (stmt, context_die, depth)
 
 static void
 decls_for_scope (stmt, context_die, depth)
-     register tree stmt;
-     register dw_die_ref context_die;
+     tree stmt;
+     dw_die_ref context_die;
      int depth;
 {
-  register tree decl;
-  register tree subblocks;
+  tree decl;
+  tree subblocks;
 
   /* Ignore blocks never really used to make RTL.  */
   if (stmt == NULL_TREE || ! TREE_USED (stmt))
@@ -10945,7 +10944,7 @@ decls_for_scope (stmt, context_die, depth)
   for (decl = BLOCK_VARS (stmt);
        decl != NULL; decl = TREE_CHAIN (decl))
     {
-      register dw_die_ref die;
+      dw_die_ref die;
 
       if (TREE_CODE (decl) == FUNCTION_DECL)
 	die = lookup_decl_die (decl);
@@ -10972,7 +10971,7 @@ decls_for_scope (stmt, context_die, depth)
 
 static inline int
 is_redundant_typedef (decl)
-     register tree decl;
+     tree decl;
 {
   if (TYPE_DECL_IS_STUB (decl))
     return 1;
@@ -10992,10 +10991,10 @@ is_redundant_typedef (decl)
 
 static void
 gen_decl_die (decl, context_die)
-     register tree decl;
-     register dw_die_ref context_die;
+     tree decl;
+     dw_die_ref context_die;
 {
-  register tree origin;
+  tree origin;
 
   if (TREE_CODE (decl) == ERROR_MARK)
     return;
@@ -11179,9 +11178,9 @@ dwarf2out_global_decl (decl)
 
 void
 dwarf2out_decl (decl)
-     register tree decl;
+     tree decl;
 {
-  register dw_die_ref context_die = comp_unit_die;
+  dw_die_ref context_die = comp_unit_die;
 
   if (TREE_CODE (decl) == ERROR_MARK)
     return;
@@ -11348,7 +11347,7 @@ static unsigned
 lookup_filename (file_name)
      const char *file_name;
 {
-  register unsigned i;
+  unsigned i;
 
   /* ??? Why isn't DECL_SOURCE_FILE left null instead.  */
   if (strcmp (file_name, "<internal>") == 0
@@ -11408,7 +11407,7 @@ init_file_table ()
 static void
 dwarf2out_source_line (line, filename)
      unsigned int line;
-     register const char *filename;
+     const char *filename;
 {
   if (debug_info_level >= DINFO_LEVEL_NORMAL)
     {
@@ -11435,7 +11434,7 @@ dwarf2out_source_line (line, filename)
 	}
       else if (DECL_SECTION_NAME (current_function_decl))
 	{
-	  register dw_separate_line_info_ref line_info;
+	  dw_separate_line_info_ref line_info;
 	  ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, SEPARATE_LINE_CODE_LABEL,
 				     separate_line_info_table_in_use);
 
@@ -11460,7 +11459,7 @@ dwarf2out_source_line (line, filename)
 	}
       else
 	{
-	  register dw_line_info_ref line_info;
+	  dw_line_info_ref line_info;
 
 	  ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, LINE_CODE_LABEL,
 				     line_info_table_in_use);
@@ -11488,8 +11487,8 @@ dwarf2out_source_line (line, filename)
 
 static void
 dwarf2out_start_source_file (lineno, filename)
-     register unsigned int lineno;
-     register const char *filename;
+     unsigned int lineno;
+     const char *filename;
 {
   if (flag_eliminate_dwarf2_dups)
     {
@@ -11532,8 +11531,8 @@ dwarf2out_end_source_file (lineno)
 
 static void
 dwarf2out_define (lineno, buffer)
-     register unsigned lineno ATTRIBUTE_UNUSED;
-     register const char *buffer ATTRIBUTE_UNUSED;
+     unsigned lineno ATTRIBUTE_UNUSED;
+     const char *buffer ATTRIBUTE_UNUSED;
 {
   static int initialized = 0;
   if (!initialized)
@@ -11556,8 +11555,8 @@ dwarf2out_define (lineno, buffer)
 
 static void
 dwarf2out_undef (lineno, buffer)
-     register unsigned lineno ATTRIBUTE_UNUSED;
-     register const char *buffer ATTRIBUTE_UNUSED;
+     unsigned lineno ATTRIBUTE_UNUSED;
+     const char *buffer ATTRIBUTE_UNUSED;
 {
   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
     {
@@ -11572,7 +11571,7 @@ dwarf2out_undef (lineno, buffer)
 
 static void
 dwarf2out_init (main_input_filename)
-     register const char *main_input_filename;
+     const char *main_input_filename;
 {
   init_file_table ();
 
@@ -11660,7 +11659,7 @@ dwarf2out_init (main_input_filename)
 
 static void
 dwarf2out_finish (input_filename)
-     register const char *input_filename ATTRIBUTE_UNUSED;
+     const char *input_filename ATTRIBUTE_UNUSED;
 {
   limbo_die_node *node, *next_node;
   dw_die_ref die = 0;
diff --git a/gcc/dwarfout.c b/gcc/dwarfout.c
index abc24bd4e58..f5f2e3d6d6c 100644
--- a/gcc/dwarfout.c
+++ b/gcc/dwarfout.c
@@ -1393,7 +1393,7 @@ struct gcc_debug_hooks dwarf_debug_hooks =
 
 static inline int
 is_pseudo_reg (rtl)
-     register rtx rtl;
+     rtx rtl;
 {
   return (((GET_CODE (rtl) == REG) && (REGNO (rtl) >= FIRST_PSEUDO_REGISTER))
           || ((GET_CODE (rtl) == SUBREG)
@@ -1402,7 +1402,7 @@ is_pseudo_reg (rtl)
 
 static inline tree
 type_main_variant (type)
-     register tree type;
+     tree type;
 {
   type = TYPE_MAIN_VARIANT (type);
 
@@ -1424,9 +1424,9 @@ type_main_variant (type)
 
 static inline int
 is_tagged_type (type)
-     register tree type;
+     tree type;
 {
-  register enum tree_code code = TREE_CODE (type);
+  enum tree_code code = TREE_CODE (type);
 
   return (code == RECORD_TYPE || code == UNION_TYPE
 	  || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
@@ -1434,7 +1434,7 @@ is_tagged_type (type)
 
 static const char *
 dwarf_tag_name (tag)
-     register unsigned tag;
+     unsigned tag;
 {
   switch (tag)
     {
@@ -1484,7 +1484,7 @@ dwarf_tag_name (tag)
 
 static const char *
 dwarf_attr_name (attr)
-     register unsigned attr;
+     unsigned attr;
 {
   switch (attr)
     {
@@ -1562,7 +1562,7 @@ dwarf_attr_name (attr)
 
 static const char *
 dwarf_stack_op_name (op)
-     register unsigned op;
+     unsigned op;
 {
   switch (op)
     {
@@ -1579,7 +1579,7 @@ dwarf_stack_op_name (op)
 
 static const char *
 dwarf_typemod_name (mod)
-     register unsigned mod;
+     unsigned mod;
 {
   switch (mod)
     {
@@ -1593,7 +1593,7 @@ dwarf_typemod_name (mod)
 
 static const char *
 dwarf_fmt_byte_name (fmt)
-     register unsigned fmt;
+     unsigned fmt;
 {
   switch (fmt)
     {
@@ -1612,7 +1612,7 @@ dwarf_fmt_byte_name (fmt)
 
 static const char *
 dwarf_fund_type_name (ft)
-     register unsigned ft;
+     unsigned ft;
 {
   switch (ft)
     {
@@ -1678,7 +1678,7 @@ dwarf_fund_type_name (ft)
 
 static tree
 decl_ultimate_origin (decl)
-     register tree decl;
+     tree decl;
 {
 #ifdef ENABLE_CHECKING 
   if (DECL_FROM_INLINE (DECL_ORIGIN (decl)))
@@ -1698,16 +1698,16 @@ decl_ultimate_origin (decl)
 
 static tree
 block_ultimate_origin (block)
-     register tree block;
+     tree block;
 {
-  register tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
+  tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
 
   if (immediate_origin == NULL)
     return NULL;
   else
     {
-      register tree ret_val;
-      register tree lookahead = immediate_origin;
+      tree ret_val;
+      tree lookahead = immediate_origin;
 
       do
 	{
@@ -1745,13 +1745,13 @@ decl_class_context (decl)
 #if 0
 static void
 output_unsigned_leb128 (value)
-     register unsigned long value;
+     unsigned long value;
 {
-  register unsigned long orig_value = value;
+  unsigned long orig_value = value;
 
   do
     {
-      register unsigned byte = (value & 0x7f);
+      unsigned byte = (value & 0x7f);
 
       value >>= 7;
       if (value != 0)	/* more bytes to follow */
@@ -1767,15 +1767,15 @@ output_unsigned_leb128 (value)
 
 static void
 output_signed_leb128 (value)
-     register long value;
+     long value;
 {
-  register long orig_value = value;
-  register int negative = (value < 0);
-  register int more;
+  long orig_value = value;
+  int negative = (value < 0);
+  int more;
 
   do
     {
-      register unsigned byte = (value & 0x7f);
+      unsigned byte = (value & 0x7f);
 
       value >>= 7;
       if (negative)
@@ -1826,7 +1826,7 @@ output_signed_leb128 (value)
 
 static int
 fundamental_type_code (type)
-     register tree type;
+     tree type;
 {
   if (TREE_CODE (type) == ERROR_MARK)
     return 0;
@@ -1968,8 +1968,8 @@ fundamental_type_code (type)
 
 static tree
 root_type_1 (type, count)
-     register tree type;
-     register int count;
+     tree type;
+     int count;
 {
   /* Give up after searching 1000 levels, in case this is a recursive
      pointer type.  Such types are possible in Ada, but it is not possible
@@ -1993,7 +1993,7 @@ root_type_1 (type, count)
 
 static tree
 root_type (type)
-     register tree type;
+     tree type;
 {
   type = root_type_1 (type, 0);
   if (type != error_mark_node)
@@ -2006,10 +2006,10 @@ root_type (type)
 
 static void
 write_modifier_bytes_1 (type, decl_const, decl_volatile, count)
-     register tree type;
-     register int decl_const;
-     register int decl_volatile;
-     register int count;
+     tree type;
+     int decl_const;
+     int decl_volatile;
+     int count;
 {
   if (TREE_CODE (type) == ERROR_MARK)
     return;
@@ -2044,9 +2044,9 @@ write_modifier_bytes_1 (type, decl_const, decl_volatile, count)
 
 static void
 write_modifier_bytes (type, decl_const, decl_volatile)
-     register tree type;
-     register int decl_const;
-     register int decl_volatile;
+     tree type;
+     int decl_const;
+     int decl_volatile;
 {
   write_modifier_bytes_1 (type, decl_const, decl_volatile, 0);
 }
@@ -2056,7 +2056,7 @@ write_modifier_bytes (type, decl_const, decl_volatile)
 
 static inline int
 type_is_fundamental (type)
-     register tree type;
+     tree type;
 {
   switch (TREE_CODE (type))
     {
@@ -2106,7 +2106,7 @@ type_is_fundamental (type)
 
 static void
 equate_decl_number_to_die_number (decl)
-     register tree decl;
+     tree decl;
 {
   /* In the case where we are generating a DIE for some ..._DECL node
      which represents either some inline function declaration or some
@@ -2138,7 +2138,7 @@ equate_decl_number_to_die_number (decl)
 
 static inline void
 equate_type_number_to_die_number (type)
-     register tree type;
+     tree type;
 {
   char type_label[MAX_ARTIFICIAL_LABEL_BYTES];
   char die_label[MAX_ARTIFICIAL_LABEL_BYTES];
@@ -2157,9 +2157,9 @@ equate_type_number_to_die_number (type)
 
 static void
 output_reg_number (rtl)
-     register rtx rtl;
+     rtx rtl;
 {
-  register unsigned regno = REGNO (rtl);
+  unsigned regno = REGNO (rtl);
 
   if (regno >= DWARF_FRAME_REGISTERS)
     {
@@ -2189,7 +2189,7 @@ output_reg_number (rtl)
 
 static void
 output_mem_loc_descriptor (rtl)
-      register rtx rtl;
+     rtx rtl;
 {
   /* Note that for a dynamically sized array, the location we will
      generate a description of here will be the lowest numbered location
@@ -2282,7 +2282,7 @@ output_mem_loc_descriptor (rtl)
 
 static void
 output_loc_descriptor (rtl)
-     register rtx rtl;
+     rtx rtl;
 {
   switch (GET_CODE (rtl))
     {
@@ -2316,9 +2316,9 @@ output_loc_descriptor (rtl)
 
 static void
 output_bound_representation (bound, dim_num, u_or_l)
-     register tree bound;
-     register unsigned dim_num; /* For multi-dimensional arrays.  */
-     register char u_or_l;	/* Designates upper or lower bound.  */
+     tree bound;
+     unsigned dim_num; /* For multi-dimensional arrays.  */
+     char u_or_l;	/* Designates upper or lower bound.  */
 {
   switch (TREE_CODE (bound))
     {
@@ -2399,7 +2399,7 @@ output_bound_representation (bound, dim_num, u_or_l)
 
 static void
 output_enumeral_list (link)
-     register tree link;
+     tree link;
 {
   if (link)
     {
@@ -2419,8 +2419,8 @@ output_enumeral_list (link)
 
 static inline HOST_WIDE_INT
 ceiling (value, boundary)
-     register HOST_WIDE_INT value;
-     register unsigned int boundary;
+     HOST_WIDE_INT value;
+     unsigned int boundary;
 {
   return (((value + boundary - 1) / boundary) * boundary);
 }
@@ -2431,9 +2431,9 @@ ceiling (value, boundary)
 
 static inline tree
 field_type (decl)
-     register tree decl;
+     tree decl;
 {
-  register tree type;
+  tree type;
 
   if (TREE_CODE (decl) == ERROR_MARK)
     return integer_type_node;
@@ -2450,7 +2450,7 @@ field_type (decl)
 
 static inline unsigned int
 simple_type_align_in_bits (type)
-     register tree type;
+     tree type;
 {
   return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
 }
@@ -2463,7 +2463,7 @@ simple_type_align_in_bits (type)
 
 static inline unsigned HOST_WIDE_INT
 simple_type_size_in_bits (type)
-     register tree type;
+     tree type;
 {
   tree type_size_tree;
 
@@ -2487,7 +2487,7 @@ simple_type_size_in_bits (type)
 
 static HOST_WIDE_INT
 field_byte_offset (decl)
-     register tree decl;
+     tree decl;
 {
   unsigned int type_align_in_bytes;
   unsigned int type_align_in_bits;
@@ -2647,7 +2647,7 @@ sibling_attribute ()
 
 static void
 location_attribute (rtl)
-     register rtx rtl;
+     rtx rtl;
 {
   char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
   char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
@@ -2710,9 +2710,9 @@ location_attribute (rtl)
 
 static void
 data_member_location_attribute (t)
-     register tree t;
+     tree t;
 {
-  register unsigned object_offset_in_bytes;
+  unsigned object_offset_in_bytes;
   char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
   char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
 
@@ -2740,7 +2740,7 @@ data_member_location_attribute (t)
 
 static void
 const_value_attribute (rtl)
-     register rtx rtl;
+     rtx rtl;
 {
   char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
   char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
@@ -2825,9 +2825,9 @@ const_value_attribute (rtl)
 
 static void
 location_or_const_value_attribute (decl)
-     register tree decl;
+     tree decl;
 {
-  register rtx rtl;
+  rtx rtl;
 
   if (TREE_CODE (decl) == ERROR_MARK)
     return;
@@ -2919,8 +2919,8 @@ location_or_const_value_attribute (decl)
     if (rtl == NULL_RTX || is_pseudo_reg (rtl))
       {
 	/* This decl represents a formal parameter which was optimized out.  */
-        register tree declared_type = type_main_variant (TREE_TYPE (decl));
-        register tree passed_type = type_main_variant (DECL_ARG_TYPE (decl));
+        tree declared_type = type_main_variant (TREE_TYPE (decl));
+        tree passed_type = type_main_variant (DECL_ARG_TYPE (decl));
 
 	/* Note that DECL_INCOMING_RTL may be NULL in here, but we handle
 	   *all* cases where (rtl == NULL_RTX) just below.  */
@@ -2985,7 +2985,7 @@ location_or_const_value_attribute (decl)
 
 static inline void
 name_attribute (name_string)
-     register const char *name_string;
+     const char *name_string;
 {
   if (name_string && *name_string)
     {
@@ -2996,7 +2996,7 @@ name_attribute (name_string)
 
 static inline void
 fund_type_attribute (ft_code)
-     register unsigned ft_code;
+     unsigned ft_code;
 {
   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_fund_type);
   ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file, ft_code);
@@ -3004,9 +3004,9 @@ fund_type_attribute (ft_code)
 
 static void
 mod_fund_type_attribute (type, decl_const, decl_volatile)
-     register tree type;
-     register int decl_const;
-     register int decl_volatile;
+     tree type;
+     int decl_const;
+     int decl_volatile;
 {
   char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
   char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
@@ -3024,7 +3024,7 @@ mod_fund_type_attribute (type, decl_const, decl_volatile)
 
 static inline void
 user_def_type_attribute (type)
-     register tree type;
+     tree type;
 {
   char ud_type_name[MAX_ARTIFICIAL_LABEL_BYTES];
 
@@ -3035,9 +3035,9 @@ user_def_type_attribute (type)
 
 static void
 mod_u_d_type_attribute (type, decl_const, decl_volatile)
-     register tree type;
-     register int decl_const;
-     register int decl_volatile;
+     tree type;
+     int decl_const;
+     int decl_volatile;
 {
   char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
   char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
@@ -3057,7 +3057,7 @@ mod_u_d_type_attribute (type, decl_const, decl_volatile)
 #ifdef USE_ORDERING_ATTRIBUTE
 static inline void
 ordering_attribute (ordering)
-     register unsigned ordering;
+     unsigned ordering;
 {
   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_ordering);
   ASM_OUTPUT_DWARF_DATA2 (asm_out_file, ordering);
@@ -3069,9 +3069,9 @@ ordering_attribute (ordering)
 
 static void
 subscript_data_attribute (type)
-     register tree type;
+     tree type;
 {
-  register unsigned dimension_number;
+  unsigned dimension_number;
   char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
   char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
 
@@ -3094,7 +3094,7 @@ subscript_data_attribute (type)
 	TREE_CODE (type) == ARRAY_TYPE;
 	type = TREE_TYPE (type), dimension_number++)
     {
-      register tree domain = TYPE_DOMAIN (type);
+      tree domain = TYPE_DOMAIN (type);
 
       /* Arrays come in three flavors.	Unspecified bounds, fixed
 	 bounds, and (in GNU C only) variable bounds.  Handle all
@@ -3104,8 +3104,8 @@ subscript_data_attribute (type)
 	{
 	  /* We have an array type with specified bounds.  */
 
-	  register tree lower = TYPE_MIN_VALUE (domain);
-	  register tree upper = TYPE_MAX_VALUE (domain);
+	  tree lower = TYPE_MIN_VALUE (domain);
+	  tree upper = TYPE_MAX_VALUE (domain);
 
 	  /* Handle only fundamental types as index types for now.  */
 	  if (! type_is_fundamental (domain))
@@ -3168,9 +3168,9 @@ subscript_data_attribute (type)
 
 static void
 byte_size_attribute (tree_node)
-     register tree tree_node;
+     tree tree_node;
 {
-  register unsigned size;
+  unsigned size;
 
   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_byte_size);
   switch (TREE_CODE (tree_node))
@@ -3228,7 +3228,7 @@ byte_size_attribute (tree_node)
 
 static inline void
 bit_offset_attribute (decl)
-    register tree decl;
+     tree decl;
 {
   HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
   tree type = DECL_BIT_FIELD_TYPE (decl);
@@ -3281,7 +3281,7 @@ bit_offset_attribute (decl)
 
 static inline void
 bit_size_attribute (decl)
-    register tree decl;
+    tree decl;
 {
   /* Must be a field and a bit field.  */
   if (TREE_CODE (decl) != FIELD_DECL
@@ -3303,7 +3303,7 @@ bit_size_attribute (decl)
 
 static inline void
 element_list_attribute (element)
-     register tree element;
+     tree element;
 {
   char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
   char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
@@ -3329,7 +3329,7 @@ element_list_attribute (element)
 
 static inline void
 stmt_list_attribute (label)
-    register const char *label;
+    const char *label;
 {
   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_stmt_list);
   /* Don't use ASM_OUTPUT_DWARF_DATA4 here.  */
@@ -3341,7 +3341,7 @@ stmt_list_attribute (label)
 
 static inline void
 low_pc_attribute (asm_low_label)
-     register const char *asm_low_label;
+     const char *asm_low_label;
 {
   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_low_pc);
   ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_low_label);
@@ -3352,7 +3352,7 @@ low_pc_attribute (asm_low_label)
 
 static inline void
 high_pc_attribute (asm_high_label)
-    register const char *asm_high_label;
+     const char *asm_high_label;
 {
   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_high_pc);
   ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_high_label);
@@ -3362,7 +3362,7 @@ high_pc_attribute (asm_high_label)
 
 static inline void
 body_begin_attribute (asm_begin_label)
-     register const char *asm_begin_label;
+     const char *asm_begin_label;
 {
   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_body_begin);
   ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_begin_label);
@@ -3372,7 +3372,7 @@ body_begin_attribute (asm_begin_label)
 
 static inline void
 body_end_attribute (asm_end_label)
-     register const char *asm_end_label;
+     const char *asm_end_label;
 {
   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_body_end);
   ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_end_label);
@@ -3383,7 +3383,7 @@ body_end_attribute (asm_end_label)
 
 static inline void
 language_attribute (language_code)
-     register unsigned language_code;
+     unsigned language_code;
 {
   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_language);
   ASM_OUTPUT_DWARF_DATA4 (asm_out_file, language_code);
@@ -3391,7 +3391,7 @@ language_attribute (language_code)
 
 static inline void
 member_attribute (context)
-    register tree context;
+     tree context;
 {
   char label[MAX_ARTIFICIAL_LABEL_BYTES];
 
@@ -3408,7 +3408,7 @@ member_attribute (context)
 #if 0
 static inline void
 string_length_attribute (upper_bound)
-     register tree upper_bound;
+     tree upper_bound;
 {
   char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
   char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
@@ -3425,7 +3425,7 @@ string_length_attribute (upper_bound)
 
 static inline void
 comp_dir_attribute (dirname)
-     register const char *dirname;
+     const char *dirname;
 {
   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_comp_dir);
   ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, dirname);
@@ -3433,7 +3433,7 @@ comp_dir_attribute (dirname)
 
 static inline void
 sf_names_attribute (sf_names_start_label)
-     register const char *sf_names_start_label;
+     const char *sf_names_start_label;
 {
   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_sf_names);
   /* Don't use ASM_OUTPUT_DWARF_DATA4 here.  */
@@ -3442,7 +3442,7 @@ sf_names_attribute (sf_names_start_label)
 
 static inline void
 src_info_attribute (src_info_start_label)
-     register const char *src_info_start_label;
+     const char *src_info_start_label;
 {
   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_src_info);
   /* Don't use ASM_OUTPUT_DWARF_DATA4 here.  */
@@ -3451,7 +3451,7 @@ src_info_attribute (src_info_start_label)
 
 static inline void
 mac_info_attribute (mac_info_start_label)
-     register const char *mac_info_start_label;
+     const char *mac_info_start_label;
 {
   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_mac_info);
   /* Don't use ASM_OUTPUT_DWARF_DATA4 here.  */
@@ -3460,7 +3460,7 @@ mac_info_attribute (mac_info_start_label)
 
 static inline void
 prototyped_attribute (func_type)
-     register tree func_type;
+     tree func_type;
 {
   if ((strcmp (language_string, "GNU C") == 0)
       && (TYPE_ARG_TYPES (func_type) != NULL))
@@ -3472,7 +3472,7 @@ prototyped_attribute (func_type)
 
 static inline void
 producer_attribute (producer)
-     register const char *producer;
+     const char *producer;
 {
   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_producer);
   ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, producer);
@@ -3480,7 +3480,7 @@ producer_attribute (producer)
 
 static inline void
 inline_attribute (decl)
-     register tree decl;
+     tree decl;
 {
   if (DECL_INLINE (decl))
     {
@@ -3491,7 +3491,7 @@ inline_attribute (decl)
 
 static inline void
 containing_type_attribute (containing_type)
-     register tree containing_type;
+     tree containing_type;
 {
   char label[MAX_ARTIFICIAL_LABEL_BYTES];
 
@@ -3502,7 +3502,7 @@ containing_type_attribute (containing_type)
 
 static inline void
 abstract_origin_attribute (origin)
-     register tree origin;
+     tree origin;
 {
   char label[MAX_ARTIFICIAL_LABEL_BYTES];
 
@@ -3527,8 +3527,8 @@ abstract_origin_attribute (origin)
 #ifdef DWARF_DECL_COORDINATES
 static inline void
 src_coords_attribute (src_fileno, src_lineno)
-     register unsigned src_fileno;
-     register unsigned src_lineno;
+     unsigned src_fileno;
+     unsigned src_lineno;
 {
   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_src_coords);
   ASM_OUTPUT_DWARF_DATA2 (asm_out_file, src_fileno);
@@ -3538,7 +3538,7 @@ src_coords_attribute (src_fileno, src_lineno)
 
 static inline void
 pure_or_virtual_attribute (func_decl)
-     register tree func_decl;
+     tree func_decl;
 {
   if (DECL_VIRTUAL_P (func_decl))
     {
@@ -3561,9 +3561,9 @@ pure_or_virtual_attribute (func_decl)
 
 static void
 name_and_src_coords_attributes (decl)
-    register tree decl;
+    tree decl;
 {
-  register tree decl_name = DECL_NAME (decl);
+  tree decl_name = DECL_NAME (decl);
 
   if (decl_name && IDENTIFIER_POINTER (decl_name))
     {
@@ -3597,12 +3597,12 @@ name_and_src_coords_attributes (decl)
 
 static void
 type_attribute (type, decl_const, decl_volatile)
-     register tree type;
-     register int decl_const;
-     register int decl_volatile;
+     tree type;
+     int decl_const;
+     int decl_volatile;
 {
-  register enum tree_code code = TREE_CODE (type);
-  register int root_type_modified;
+  enum tree_code code = TREE_CODE (type);
+  int root_type_modified;
 
   if (code == ERROR_MARK)
     return;
@@ -3655,13 +3655,13 @@ type_attribute (type, decl_const, decl_volatile)
 
 static const char *
 type_tag (type)
-     register tree type;
+     tree type;
 {
-  register const char *name = 0;
+  const char *name = 0;
 
   if (TYPE_NAME (type) != 0)
     {
-      register tree t = 0;
+      tree t = 0;
 
       /* Find the IDENTIFIER_NODE for the type name.  */
       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
@@ -3711,7 +3711,7 @@ dienum_pop ()
 
 static inline tree
 member_declared_type (member)
-     register tree member;
+     tree member;
 {
   return (DECL_BIT_FIELD_TYPE (member))
 	   ? DECL_BIT_FIELD_TYPE (member)
@@ -3724,7 +3724,7 @@ member_declared_type (member)
 
 static const char *
 function_start_label (decl)
-    register tree decl;
+    tree decl;
 {
   rtx x;
   const char *fnname;
@@ -3748,9 +3748,9 @@ function_start_label (decl)
 
 static void
 output_array_type_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree type = arg;
+  tree type = arg;
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_array_type);
   sibling_attribute ();
@@ -3775,9 +3775,9 @@ output_array_type_die (arg)
 
 static void
 output_set_type_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree type = arg;
+  tree type = arg;
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_set_type);
   sibling_attribute ();
@@ -3791,10 +3791,10 @@ output_set_type_die (arg)
 
 static void
 output_entry_point_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree decl = arg;
-  register tree origin = decl_ultimate_origin (decl);
+  tree decl = arg;
+  tree origin = decl_ultimate_origin (decl);
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_entry_point);
   sibling_attribute ();
@@ -3818,9 +3818,9 @@ output_entry_point_die (arg)
 
 static void
 output_inlined_enumeration_type_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree type = arg;
+  tree type = arg;
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_enumeration_type);
   sibling_attribute ();
@@ -3833,9 +3833,9 @@ output_inlined_enumeration_type_die (arg)
 
 static void
 output_inlined_structure_type_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree type = arg;
+  tree type = arg;
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_structure_type);
   sibling_attribute ();
@@ -3848,9 +3848,9 @@ output_inlined_structure_type_die (arg)
 
 static void
 output_inlined_union_type_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree type = arg;
+  tree type = arg;
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_union_type);
   sibling_attribute ();
@@ -3865,9 +3865,9 @@ output_inlined_union_type_die (arg)
 
 static void
 output_enumeration_type_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree type = arg;
+  tree type = arg;
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_enumeration_type);
   sibling_attribute ();
@@ -3901,9 +3901,9 @@ output_enumeration_type_die (arg)
 
 static void
 output_formal_parameter_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree node = arg;
+  tree node = arg;
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_formal_parameter);
   sibling_attribute ();
@@ -3943,10 +3943,10 @@ output_formal_parameter_die (arg)
 
 static void
 output_global_subroutine_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree decl = arg;
-  register tree origin = decl_ultimate_origin (decl);
+  tree decl = arg;
+  tree origin = decl_ultimate_origin (decl);
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_global_subroutine);
   sibling_attribute ();
@@ -3955,7 +3955,7 @@ output_global_subroutine_die (arg)
     abstract_origin_attribute (origin);
   else
     {
-      register tree type = TREE_TYPE (decl);
+      tree type = TREE_TYPE (decl);
 
       name_and_src_coords_attributes (decl);
       inline_attribute (decl);
@@ -3992,10 +3992,10 @@ output_global_subroutine_die (arg)
 
 static void
 output_global_variable_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree decl = arg;
-  register tree origin = decl_ultimate_origin (decl);
+  tree decl = arg;
+  tree origin = decl_ultimate_origin (decl);
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_global_variable);
   sibling_attribute ();
@@ -4020,10 +4020,10 @@ output_global_variable_die (arg)
 
 static void
 output_label_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree decl = arg;
-  register tree origin = decl_ultimate_origin (decl);
+  tree decl = arg;
+  tree origin = decl_ultimate_origin (decl);
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_label);
   sibling_attribute ();
@@ -4035,7 +4035,7 @@ output_label_die (arg)
     equate_decl_number_to_die_number (decl);
   else
     {
-      register rtx insn = DECL_RTL (decl);
+      rtx insn = DECL_RTL (decl);
 
       /* Deleted labels are programmer specified labels which have been
 	 eliminated because of various optimisations.  We still emit them
@@ -4063,9 +4063,9 @@ output_label_die (arg)
 
 static void
 output_lexical_block_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree stmt = arg;
+  tree stmt = arg;
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_lexical_block);
   sibling_attribute ();
@@ -4084,9 +4084,9 @@ output_lexical_block_die (arg)
 
 static void
 output_inlined_subroutine_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree stmt = arg;
+  tree stmt = arg;
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_inlined_subroutine);
   sibling_attribute ();
@@ -4109,10 +4109,10 @@ output_inlined_subroutine_die (arg)
 
 static void
 output_local_variable_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree decl = arg;
-  register tree origin = decl_ultimate_origin (decl);
+  tree decl = arg;
+  tree origin = decl_ultimate_origin (decl);
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_local_variable);
   sibling_attribute ();
@@ -4133,9 +4133,9 @@ output_local_variable_die (arg)
 
 static void
 output_member_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree decl = arg;
+  tree decl = arg;
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_member);
   sibling_attribute ();
@@ -4162,9 +4162,9 @@ output_member_die (arg)
 
 static void
 output_pointer_type_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree type = arg;
+  tree type = arg;
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_pointer_type);
   sibling_attribute ();
@@ -4175,9 +4175,9 @@ output_pointer_type_die (arg)
 
 static void
 output_reference_type_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree type = arg;
+  tree type = arg;
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_reference_type);
   sibling_attribute ();
@@ -4189,9 +4189,9 @@ output_reference_type_die (arg)
 
 static void
 output_ptr_to_mbr_type_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree type = arg;
+  tree type = arg;
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_ptr_to_member_type);
   sibling_attribute ();
@@ -4203,9 +4203,9 @@ output_ptr_to_mbr_type_die (arg)
 
 static void
 output_compile_unit_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register const char *main_input_filename = arg;
+  const char *main_input_filename = arg;
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_compile_unit);
   sibling_attribute ();
@@ -4256,9 +4256,9 @@ output_compile_unit_die (arg)
 
 static void
 output_string_type_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree type = arg;
+  tree type = arg;
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_string_type);
   sibling_attribute ();
@@ -4270,9 +4270,9 @@ output_string_type_die (arg)
 
 static void
 output_inheritance_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree binfo = arg;
+  tree binfo = arg;
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_inheritance);
   sibling_attribute ();
@@ -4297,9 +4297,9 @@ output_inheritance_die (arg)
 
 static void
 output_structure_type_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree type = arg;
+  tree type = arg;
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_structure_type);
   sibling_attribute ();
@@ -4325,10 +4325,10 @@ output_structure_type_die (arg)
 
 static void
 output_local_subroutine_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree decl = arg;
-  register tree origin = decl_ultimate_origin (decl);
+  tree decl = arg;
+  tree origin = decl_ultimate_origin (decl);
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_subroutine);
   sibling_attribute ();
@@ -4337,7 +4337,7 @@ output_local_subroutine_die (arg)
     abstract_origin_attribute (origin);
   else
     {
-      register tree type = TREE_TYPE (decl);
+      tree type = TREE_TYPE (decl);
 
       name_and_src_coords_attributes (decl);
       inline_attribute (decl);
@@ -4372,10 +4372,10 @@ output_local_subroutine_die (arg)
 
 static void
 output_subroutine_type_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree type = arg;
-  register tree return_type = TREE_TYPE (type);
+  tree type = arg;
+  tree return_type = TREE_TYPE (type);
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_subroutine_type);
   sibling_attribute ();
@@ -4388,10 +4388,10 @@ output_subroutine_type_die (arg)
 
 static void
 output_typedef_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree decl = arg;
-  register tree origin = decl_ultimate_origin (decl);
+  tree decl = arg;
+  tree origin = decl_ultimate_origin (decl);
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_typedef);
   sibling_attribute ();
@@ -4410,9 +4410,9 @@ output_typedef_die (arg)
 
 static void
 output_union_type_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree type = arg;
+  tree type = arg;
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_union_type);
   sibling_attribute ();
@@ -4438,9 +4438,9 @@ output_union_type_die (arg)
 
 static void
 output_unspecified_parameters_die (arg)
-     register void *arg;
+     void *arg;
 {
-  register tree decl_or_type = arg;
+  tree decl_or_type = arg;
 
   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_unspecified_parameters);
   sibling_attribute ();
@@ -4464,7 +4464,7 @@ output_unspecified_parameters_die (arg)
 
 static void
 output_padded_null_die (arg)
-     register void *arg ATTRIBUTE_UNUSED;
+     void *arg ATTRIBUTE_UNUSED;
 {
   ASM_OUTPUT_ALIGN (asm_out_file, 2);	/* 2**2 == 4 */
 }
@@ -4479,8 +4479,8 @@ output_padded_null_die (arg)
 
 static void
 output_die (die_specific_output_function, param)
-     register void (*die_specific_output_function) PARAMS ((void *));
-     register void *param;
+     void (*die_specific_output_function) PARAMS ((void *));
+     void *param;
 {
   char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
   char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
@@ -4543,11 +4543,11 @@ end_sibling_chain ()
 
 static void
 output_formal_types (function_or_method_type)
-     register tree function_or_method_type;
+     tree function_or_method_type;
 {
-  register tree link;
-  register tree formal_type = NULL;
-  register tree first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
+  tree link;
+  tree formal_type = NULL;
+  tree first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
 
   /* Set TREE_ASM_WRITTEN while processing the parameters, lest we
      get bogus recursion when outputting tagged types local to a
@@ -4608,7 +4608,7 @@ output_formal_types (function_or_method_type)
 
 static void
 pend_type (type)
-     register tree type;
+     tree type;
 {
   if (pending_types == pending_types_allocated)
     {
@@ -4664,8 +4664,8 @@ pend_type (type)
 
 static inline int
 type_ok_for_scope (type, scope)
-    register tree type;
-    register tree scope;
+    tree type;
+    tree scope;
 {
   /* Tagged types (i.e. struct, union, and enum types) must always be
      output only in the scopes where they actually belong (or else the
@@ -4701,18 +4701,18 @@ type_ok_for_scope (type, scope)
 
 static void
 output_pending_types_for_scope (containing_scope)
-     register tree containing_scope;
+     tree containing_scope;
 {
-  register unsigned i;
+  unsigned i;
 
   for (i = 0; i < pending_types; )
     {
-      register tree type = pending_types_list[i];
+      tree type = pending_types_list[i];
 
       if (type_ok_for_scope (type, containing_scope))
 	{
-	  register tree *mover;
-	  register tree *limit;
+	  tree *mover;
+	  tree *limit;
 
 	  pending_types--;
 	  limit = &pending_types_list[pending_types];
@@ -4758,7 +4758,7 @@ add_incomplete_type (type)
 static void
 retry_incomplete_types ()
 {
-  register tree type;
+  tree type;
 
   finalizing = 1;
   while (incomplete_types)
@@ -4771,8 +4771,8 @@ retry_incomplete_types ()
 
 static void
 output_type (type, containing_scope)
-     register tree type;
-     register tree containing_scope;
+     tree type;
+     tree containing_scope;
 {
   if (type == 0 || type == error_mark_node)
     return;
@@ -4787,7 +4787,7 @@ output_type (type, containing_scope)
     {
       if (finalizing && AGGREGATE_TYPE_P (type))
 	{
-	  register tree member;
+	  tree member;
 
 	  /* Some of our nested types might not have been defined when we
 	     were written out before; force them out now.  */
@@ -4885,7 +4885,7 @@ output_type (type, containing_scope)
 	  }
 	else
 	  {
-	    register tree element_type;
+	    tree element_type;
 
 	    element_type = TREE_TYPE (type);
 	    while (TREE_CODE (element_type) == ARRAY_TYPE)
@@ -5006,7 +5006,7 @@ output_type (type, containing_scope)
 	    ++in_class;
 
 	    {
-	      register tree normal_member;
+	      tree normal_member;
 
 	      /* Now output info about the data members and type members.  */
 
@@ -5017,7 +5017,7 @@ output_type (type, containing_scope)
 	    }
 
 	    {
-	      register tree func_member;
+	      tree func_member;
 
 	      /* Now output info about the function members (if any).  */
 
@@ -5066,7 +5066,7 @@ output_type (type, containing_scope)
 
 static void
 output_tagged_type_instantiation (type)
-     register tree type;
+     tree type;
 {
   if (type == 0 || type == error_mark_node)
     return;
@@ -5110,12 +5110,12 @@ output_tagged_type_instantiation (type)
 
 static void
 output_block (stmt, depth)
-    register tree stmt;
+    tree stmt;
     int depth;
 {
-  register int must_output_die = 0;
-  register tree origin;
-  register enum tree_code origin_code;
+  int must_output_die = 0;
+  tree origin;
+  enum tree_code origin_code;
 
   /* Ignore blocks never really used to make RTL.  */
 
@@ -5161,7 +5161,7 @@ output_block (stmt, depth)
 	    must_output_die = (BLOCK_VARS (stmt) != NULL);
 	  else
 	    {
-	      register tree decl;
+	      tree decl;
 
 	      /* We are in terse mode, so only local (nested) function
 	         definitions count as "significant" local declarations.  */
@@ -5204,7 +5204,7 @@ output_block (stmt, depth)
 
 static void
 output_decls_for_scope (stmt, depth)
-     register tree stmt;
+     tree stmt;
      int depth;
 {
   /* Ignore blocks never really used to make RTL.  */
@@ -5217,7 +5217,7 @@ output_decls_for_scope (stmt, depth)
      but not within any nested sub-blocks.  */
 
   {
-    register tree decl;
+    tree decl;
 
     for (decl = BLOCK_VARS (stmt); decl; decl = TREE_CHAIN (decl))
       output_decl (decl, stmt);
@@ -5229,7 +5229,7 @@ output_decls_for_scope (stmt, depth)
      therein) of this block.	 */
 
   {
-    register tree subblocks;
+    tree subblocks;
 
     for (subblocks = BLOCK_SUBBLOCKS (stmt);
          subblocks;
@@ -5242,7 +5242,7 @@ output_decls_for_scope (stmt, depth)
 
 static inline int
 is_redundant_typedef (decl)
-     register tree decl;
+     tree decl;
 {
   if (TYPE_DECL_IS_STUB (decl))
     return 1;
@@ -5260,8 +5260,8 @@ is_redundant_typedef (decl)
 
 static void
 output_decl (decl, containing_scope)
-     register tree decl;
-     register tree containing_scope;
+     tree decl;
+     tree containing_scope;
 {
   /* Make a note of the decl node we are going to be working on.  We may
      need to give the user the source coordinates of where it appeared in
@@ -5368,8 +5368,8 @@ output_decl (decl, containing_scope)
 	{
 	  /* Generate DIEs to represent all known formal parameters */
 
-	  register tree arg_decls = DECL_ARGUMENTS (decl);
-	  register tree parm;
+	  tree arg_decls = DECL_ARGUMENTS (decl);
+	  tree parm;
 
 	  /* WARNING!  Kludge zone ahead!  Here we have a special
 	     hack for svr4 SDB compatibility.  Instead of passing the
@@ -5437,7 +5437,7 @@ output_decl (decl, containing_scope)
 	  */
 
 	  {
-	    register tree fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
+	    tree fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
 
 	    if (fn_arg_types)
 	      {
@@ -5457,7 +5457,7 @@ output_decl (decl, containing_scope)
 	     function (if it has one - it may be just a declaration).  */
 
 	  {
-	    register tree outer_scope = DECL_INITIAL (decl);
+	    tree outer_scope = DECL_INITIAL (decl);
 
 	    if (outer_scope && TREE_CODE (outer_scope) != ERROR_MARK)
 	      {
@@ -5584,7 +5584,7 @@ output_decl (decl, containing_scope)
 	 function.  */
 
       {
-        register void (*func) PARAMS ((void *));
+        void (*func) PARAMS ((void *));
 	register tree origin = decl_ultimate_origin (decl);
 
 	if (origin != NULL && TREE_CODE (origin) == PARM_DECL)
@@ -5685,8 +5685,8 @@ dwarfout_deferred_inline_function (decl)
 
 static void
 dwarfout_file_scope_decl (decl, set_finalizing)
-     register tree decl;
-     register int set_finalizing;
+     tree decl;
+     int set_finalizing;
 {
   if (TREE_CODE (decl) == ERROR_MARK)
     return;
@@ -5978,11 +5978,11 @@ dwarfout_end_epilogue ()
 
 static void
 shuffle_filename_entry (new_zeroth)
-     register filename_entry *new_zeroth;
+     filename_entry *new_zeroth;
 {
   filename_entry temp_entry;
-  register filename_entry *limit_p;
-  register filename_entry *move_p;
+  filename_entry *limit_p;
+  filename_entry *move_p;
 
   if (new_zeroth == &filename_table[0])
     return;
@@ -6053,8 +6053,8 @@ static unsigned
 lookup_filename (file_name)
      const char *file_name;
 {
-  register filename_entry *search_p;
-  register filename_entry *limit_p = &filename_table[ft_entries];
+  filename_entry *search_p;
+  filename_entry *limit_p = &filename_table[ft_entries];
 
   for (search_p = filename_table; search_p < limit_p; search_p++)
     if (!strcmp (file_name, search_p->name))
@@ -6129,7 +6129,7 @@ dwarfout_source_line (line, filename)
       char label[MAX_ARTIFICIAL_LABEL_BYTES];
       static unsigned last_line_entry_num = 0;
       static unsigned prev_file_entry_num = (unsigned) -1;
-      register unsigned this_file_entry_num;
+      unsigned this_file_entry_num;
 
       function_section (current_function_decl);
       sprintf (label, LINE_CODE_LABEL_FMT, ++last_line_entry_num);
@@ -6152,7 +6152,7 @@ dwarfout_source_line (line, filename)
         }
 
       {
-        register const char *tail = strrchr (filename, '/');
+        const char *tail = strrchr (filename, '/');
 
         if (tail != NULL)
           filename = tail;
@@ -6175,8 +6175,8 @@ dwarfout_source_line (line, filename)
 
 static void
 generate_macinfo_entry (type_and_offset, string)
-     register const char *type_and_offset;
-     register const char *string;
+     const char *type_and_offset;
+     const char *string;
 {
   if (! use_gnu_debug_info_extensions)
     return;
@@ -6192,7 +6192,7 @@ generate_macinfo_entry (type_and_offset, string)
 static void
 dwarfout_start_source_file_check (line, filename)
      unsigned int line;
-     register const char *filename;
+     const char *filename;
 {
   if (debug_info_level == DINFO_LEVEL_VERBOSE)
     dwarfout_start_source_file (line, filename);
@@ -6201,7 +6201,7 @@ dwarfout_start_source_file_check (line, filename)
 static void
 dwarfout_start_source_file (line, filename)
      unsigned int line ATTRIBUTE_UNUSED;
-     register const char *filename;
+     const char *filename;
 {
   char label[MAX_ARTIFICIAL_LABEL_BYTES];
   char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*3];
@@ -6218,7 +6218,7 @@ dwarfout_start_source_file (line, filename)
 /* Wrapper for toplev.c callback to check debug info level.  */
 static void
 dwarfout_end_source_file_check (lineno)
-     register unsigned lineno;
+     unsigned lineno;
 {
   if (debug_info_level == DINFO_LEVEL_VERBOSE)
     dwarfout_end_source_file (lineno);
@@ -6226,7 +6226,7 @@ dwarfout_end_source_file_check (lineno)
 
 static void
 dwarfout_end_source_file (lineno)
-     register unsigned lineno;
+     unsigned lineno;
 {
   char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*2];
 
@@ -6242,8 +6242,8 @@ dwarfout_end_source_file (lineno)
 
 static void
 dwarfout_define (lineno, buffer)
-     register unsigned lineno;
-     register const char *buffer;
+     unsigned lineno;
+     const char *buffer;
 {
   static int initialized = 0;
   char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*2];
@@ -6265,8 +6265,8 @@ dwarfout_define (lineno, buffer)
 
 static void
 dwarfout_undef (lineno, buffer)
-     register unsigned lineno;
-     register const char *buffer;
+     unsigned lineno;
+     const char *buffer;
 {
   char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*2];
 
@@ -6279,7 +6279,7 @@ dwarfout_undef (lineno, buffer)
 
 static void
 dwarfout_init (main_input_filename)
-     register const char *main_input_filename;
+     const char *main_input_filename;
 {
   /* Remember the name of the primary input file.  */
 
@@ -6372,8 +6372,8 @@ dwarfout_init (main_input_filename)
 	  ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SFNAMES_SECTION);
 	  ASM_OUTPUT_LABEL (asm_out_file, SFNAMES_BEGIN_LABEL);
 	  {
-	    register const char *pwd = getpwd ();
-	    register char *dirname;
+	    const char *pwd = getpwd ();
+	    char *dirname;
 
 	    if (!pwd)
 	      fatal_io_error ("can't get current directory");
@@ -6468,7 +6468,7 @@ dwarfout_init (main_input_filename)
 
 static void
 dwarfout_finish (main_input_filename)
-     register const char *main_input_filename ATTRIBUTE_UNUSED;
+     const char *main_input_filename ATTRIBUTE_UNUSED;
 {
   char label[MAX_ARTIFICIAL_LABEL_BYTES];
 
diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c
index ea0eef2c29b..eaaf20cbe12 100644
--- a/gcc/emit-rtl.c
+++ b/gcc/emit-rtl.c
@@ -487,9 +487,9 @@ gen_lowpart_SUBREG (mode, reg)
 rtx
 gen_rtx VPARAMS ((enum rtx_code code, enum machine_mode mode, ...))
 {
-  register int i;		/* Array indices...			*/
-  register const char *fmt;	/* Current rtx's format...		*/
-  register rtx rt_val;		/* RTX to return to caller...		*/
+  int i;		/* Array indices...			*/
+  const char *fmt;	/* Current rtx's format...		*/
+  rtx rt_val;		/* RTX to return to caller...		*/
 
   VA_OPEN (p, mode);
   VA_FIXEDARG (p, enum rtx_code, code);
@@ -606,8 +606,8 @@ gen_rtvec_v (n, argp)
      int n;
      rtx *argp;
 {
-  register int i;
-  register rtvec rt_val;
+  int i;
+  rtvec rt_val;
 
   if (n == 0)
     return NULL_RTVEC;		/* Don't allocate an empty rtvec...	*/
@@ -628,7 +628,7 @@ gen_reg_rtx (mode)
      enum machine_mode mode;
 {
   struct function *f = cfun;
-  register rtx val;
+  rtx val;
 
   /* Don't let anything called after initial flow analysis create new
      registers.  */
@@ -749,7 +749,7 @@ get_first_label_num ()
    register.  */
 int
 subreg_hard_regno (x, check_mode)
-     register rtx x;
+     rtx x;
      int check_mode;
 {
   enum machine_mode mode = GET_MODE (x);
@@ -791,7 +791,7 @@ subreg_hard_regno (x, check_mode)
 rtx
 gen_lowpart_common (mode, x)
      enum machine_mode mode;
-     register rtx x;
+     rtx x;
 {
   int msize = GET_MODE_SIZE (mode);
   int xsize = GET_MODE_SIZE (GET_MODE (x));
@@ -1075,7 +1075,7 @@ gen_lowpart_common (mode, x)
 rtx
 gen_realpart (mode, x)
      enum machine_mode mode;
-     register rtx x;
+     rtx x;
 {
   if (WORDS_BIG_ENDIAN
       && GET_MODE_BITSIZE (mode) < BITS_PER_WORD
@@ -1095,7 +1095,7 @@ gen_realpart (mode, x)
 rtx
 gen_imagpart (mode, x)
      enum machine_mode mode;
-     register rtx x;
+     rtx x;
 {
   if (WORDS_BIG_ENDIAN)
     return gen_lowpart (mode, x);
@@ -1135,7 +1135,7 @@ subreg_realpart_p (x)
 rtx
 gen_lowpart (mode, x)
      enum machine_mode mode;
-     register rtx x;
+     rtx x;
 {
   rtx result = gen_lowpart_common (mode, x);
 
@@ -1152,7 +1152,7 @@ gen_lowpart (mode, x)
   else if (GET_CODE (x) == MEM)
     {
       /* The only additional case we can do is MEM.  */
-      register int offset = 0;
+      int offset = 0;
       if (WORDS_BIG_ENDIAN)
 	offset = (MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD)
 		  - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD));
@@ -1177,7 +1177,7 @@ gen_lowpart (mode, x)
 rtx
 gen_highpart (mode, x)
      enum machine_mode mode;
-     register rtx x;
+     rtx x;
 {
   unsigned int msize = GET_MODE_SIZE (mode);
   rtx result;
@@ -1855,7 +1855,7 @@ replace_equiv_address_nv (memref, addr)
 rtx
 gen_label_rtx ()
 {
-  register rtx label;
+  rtx label;
 
   label = gen_rtx_CODE_LABEL (VOIDmode, 0, NULL_RTX,
 			      NULL_RTX, label_num++, NULL, NULL);
@@ -2055,10 +2055,10 @@ rtx
 copy_rtx_if_shared (orig)
      rtx orig;
 {
-  register rtx x = orig;
-  register int i;
-  register enum rtx_code code;
-  register const char *format_ptr;
+  rtx x = orig;
+  int i;
+  enum rtx_code code;
+  const char *format_ptr;
   int copied = 0;
 
   if (x == 0)
@@ -2122,7 +2122,7 @@ copy_rtx_if_shared (orig)
 
   if (x->used)
     {
-      register rtx copy;
+      rtx copy;
 
       copy = rtx_alloc (code);
       memcpy (copy, x,
@@ -2151,7 +2151,7 @@ copy_rtx_if_shared (orig)
 	case 'E':
 	  if (XVEC (x, i) != NULL)
 	    {
-	      register int j;
+	      int j;
 	      int len = XVECLEN (x, i);
 
 	      if (copied && len > 0)
@@ -2172,9 +2172,9 @@ void
 reset_used_flags (x)
      rtx x;
 {
-  register int i, j;
-  register enum rtx_code code;
-  register const char *format_ptr;
+  int i, j;
+  enum rtx_code code;
+  const char *format_ptr;
 
   if (x == 0)
     return;
@@ -2604,9 +2604,9 @@ static void
 mark_label_nuses(x)
     rtx x;
 {
-  register enum rtx_code code;
-  register int i, j;
-  register const char *fmt;
+  enum rtx_code code;
+  int i, j;
+  const char *fmt;
 
   code = GET_CODE (x);
   if (code == LABEL_REF)
@@ -2810,7 +2810,7 @@ rtx
 make_insn_raw (pattern)
      rtx pattern;
 {
-  register rtx insn;
+  rtx insn;
 
   insn = rtx_alloc (INSN);
 
@@ -2841,7 +2841,7 @@ static rtx
 make_jump_insn_raw (pattern)
      rtx pattern;
 {
-  register rtx insn;
+  rtx insn;
 
   insn = rtx_alloc (JUMP_INSN);
   INSN_UID (insn) = cur_insn_uid++;
@@ -2861,7 +2861,7 @@ static rtx
 make_call_insn_raw (pattern)
      rtx pattern;
 {
-  register rtx insn;
+  rtx insn;
 
   insn = rtx_alloc (CALL_INSN);
   INSN_UID (insn) = cur_insn_uid++;
@@ -2880,7 +2880,7 @@ make_call_insn_raw (pattern)
 
 void
 add_insn (insn)
-     register rtx insn;
+     rtx insn;
 {
   PREV_INSN (insn) = last_insn;
   NEXT_INSN (insn) = 0;
@@ -3341,13 +3341,13 @@ remove_unnecessary_notes ()
 
 rtx
 emit_insn_before (pattern, before)
-     register rtx pattern, before;
+     rtx pattern, before;
 {
-  register rtx insn = before;
+  rtx insn = before;
 
   if (GET_CODE (pattern) == SEQUENCE)
     {
-      register int i;
+      int i;
 
       for (i = 0; i < XVECLEN (pattern, 0); i++)
 	{
@@ -3369,9 +3369,9 @@ emit_insn_before (pattern, before)
 
 rtx
 emit_jump_insn_before (pattern, before)
-     register rtx pattern, before;
+     rtx pattern, before;
 {
-  register rtx insn;
+  rtx insn;
 
   if (GET_CODE (pattern) == SEQUENCE)
     insn = emit_insn_before (pattern, before);
@@ -3389,9 +3389,9 @@ emit_jump_insn_before (pattern, before)
 
 rtx
 emit_call_insn_before (pattern, before)
-     register rtx pattern, before;
+     rtx pattern, before;
 {
-  register rtx insn;
+  rtx insn;
 
   if (GET_CODE (pattern) == SEQUENCE)
     insn = emit_insn_before (pattern, before);
@@ -3410,9 +3410,9 @@ emit_call_insn_before (pattern, before)
 
 rtx
 emit_barrier_before (before)
-     register rtx before;
+     rtx before;
 {
-  register rtx insn = rtx_alloc (BARRIER);
+  rtx insn = rtx_alloc (BARRIER);
 
   INSN_UID (insn) = cur_insn_uid++;
 
@@ -3444,7 +3444,7 @@ emit_note_before (subtype, before)
      int subtype;
      rtx before;
 {
-  register rtx note = rtx_alloc (NOTE);
+  rtx note = rtx_alloc (NOTE);
   INSN_UID (note) = cur_insn_uid++;
   NOTE_SOURCE_FILE (note) = 0;
   NOTE_LINE_NUMBER (note) = subtype;
@@ -3458,13 +3458,13 @@ emit_note_before (subtype, before)
 
 rtx
 emit_insn_after (pattern, after)
-     register rtx pattern, after;
+     rtx pattern, after;
 {
-  register rtx insn = after;
+  rtx insn = after;
 
   if (GET_CODE (pattern) == SEQUENCE)
     {
-      register int i;
+      int i;
 
       for (i = 0; i < XVECLEN (pattern, 0); i++)
 	{
@@ -3509,9 +3509,9 @@ emit_insn_after_with_line_notes (pattern, after, from)
 
 rtx
 emit_jump_insn_after (pattern, after)
-     register rtx pattern, after;
+     rtx pattern, after;
 {
-  register rtx insn;
+  rtx insn;
 
   if (GET_CODE (pattern) == SEQUENCE)
     insn = emit_insn_after (pattern, after);
@@ -3529,9 +3529,9 @@ emit_jump_insn_after (pattern, after)
 
 rtx
 emit_barrier_after (after)
-     register rtx after;
+     rtx after;
 {
-  register rtx insn = rtx_alloc (BARRIER);
+  rtx insn = rtx_alloc (BARRIER);
 
   INSN_UID (insn) = cur_insn_uid++;
 
@@ -3564,7 +3564,7 @@ emit_note_after (subtype, after)
      int subtype;
      rtx after;
 {
-  register rtx note = rtx_alloc (NOTE);
+  rtx note = rtx_alloc (NOTE);
   INSN_UID (note) = cur_insn_uid++;
   NOTE_SOURCE_FILE (note) = 0;
   NOTE_LINE_NUMBER (note) = subtype;
@@ -3580,7 +3580,7 @@ emit_line_note_after (file, line, after)
      int line;
      rtx after;
 {
-  register rtx note;
+  rtx note;
 
   if (no_line_numbers && line > 0)
     {
@@ -3611,7 +3611,7 @@ emit_insn (pattern)
 
   if (GET_CODE (pattern) == SEQUENCE)
     {
-      register int i;
+      int i;
 
       for (i = 0; i < XVECLEN (pattern, 0); i++)
 	{
@@ -3674,11 +3674,11 @@ emit_insns_before (insn, before)
 
 rtx
 emit_insns_after (first, after)
-     register rtx first;
-     register rtx after;
+     rtx first;
+     rtx after;
 {
-  register rtx last;
-  register rtx after_after;
+  rtx last;
+  rtx after_after;
   basic_block bb;
 
   if (!after)
@@ -3725,7 +3725,7 @@ emit_jump_insn (pattern)
     return emit_insn (pattern);
   else
     {
-      register rtx insn = make_jump_insn_raw (pattern);
+      rtx insn = make_jump_insn_raw (pattern);
       add_insn (insn);
       return insn;
     }
@@ -3742,7 +3742,7 @@ emit_call_insn (pattern)
     return emit_insn (pattern);
   else
     {
-      register rtx insn = make_call_insn_raw (pattern);
+      rtx insn = make_call_insn_raw (pattern);
       add_insn (insn);
       PUT_CODE (insn, CALL_INSN);
       return insn;
@@ -3772,7 +3772,7 @@ emit_label (label)
 rtx
 emit_barrier ()
 {
-  register rtx barrier = rtx_alloc (BARRIER);
+  rtx barrier = rtx_alloc (BARRIER);
   INSN_UID (barrier) = cur_insn_uid++;
   add_insn (barrier);
   return barrier;
@@ -3808,7 +3808,7 @@ emit_note (file, line)
      const char *file;
      int line;
 {
-  register rtx note;
+  rtx note;
 
   if (line > 0)
     {
@@ -3895,7 +3895,7 @@ classify_insn (x)
     }
   if (GET_CODE (x) == PARALLEL)
     {
-      register int j;
+      int j;
       for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
 	if (GET_CODE (XVECEXP (x, 0, j)) == CALL)
 	  return CALL_INSN;
@@ -3924,7 +3924,7 @@ emit (x)
     return emit_insn (x);
   else if (code == JUMP_INSN)
     {
-      register rtx insn = emit_jump_insn (x);
+      rtx insn = emit_jump_insn (x);
       if (any_uncondjump_p (insn) || GET_CODE (x) == RETURN)
 	return emit_barrier ();
       return insn;
@@ -4181,12 +4181,12 @@ static rtvec copy_asm_constraints_vector;
 
 rtx
 copy_insn_1 (orig)
-     register rtx orig;
+     rtx orig;
 {
-  register rtx copy;
-  register int i, j;
-  register RTX_CODE code;
-  register const char *format_ptr;
+  rtx copy;
+  int i, j;
+  RTX_CODE code;
+  const char *format_ptr;
 
   code = GET_CODE (orig);
 
diff --git a/gcc/explow.c b/gcc/explow.c
index 85c3a7dc77b..533fe57deeb 100644
--- a/gcc/explow.c
+++ b/gcc/explow.c
@@ -71,13 +71,13 @@ trunc_int_for_mode (c, mode)
 
 rtx
 plus_constant_wide (x, c)
-     register rtx x;
-     register HOST_WIDE_INT c;
+     rtx x;
+     HOST_WIDE_INT c;
 {
-  register RTX_CODE code;
+  RTX_CODE code;
   rtx y;
-  register enum machine_mode mode;
-  register rtx tem;
+  enum machine_mode mode;
+  rtx tem;
   int all_constant = 0;
 
   if (c == 0)
@@ -202,7 +202,7 @@ eliminate_constant_term (x, constptr)
      rtx x;
      rtx *constptr;
 {
-  register rtx x0, x1;
+  rtx x0, x1;
   rtx tem;
 
   if (GET_CODE (x) != PLUS)
@@ -318,7 +318,7 @@ expr_size (exp)
 
 static rtx
 break_out_memory_refs (x)
-     register rtx x;
+     rtx x;
 {
   if (GET_CODE (x) == MEM
       || (CONSTANT_P (x) && CONSTANT_ADDRESS_P (x)
@@ -327,8 +327,8 @@ break_out_memory_refs (x)
   else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
 	   || GET_CODE (x) == MULT)
     {
-      register rtx op0 = break_out_memory_refs (XEXP (x, 0));
-      register rtx op1 = break_out_memory_refs (XEXP (x, 1));
+      rtx op0 = break_out_memory_refs (XEXP (x, 0));
+      rtx op1 = break_out_memory_refs (XEXP (x, 1));
 
       if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
 	x = gen_rtx_fmt_ee (GET_CODE (x), Pmode, op0, op1);
@@ -433,7 +433,7 @@ convert_memory_address (to_mode, x)
 
 rtx
 copy_all_regs (x)
-     register rtx x;
+     rtx x;
 {
   if (GET_CODE (x) == REG)
     {
@@ -449,8 +449,8 @@ copy_all_regs (x)
   else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
 	   || GET_CODE (x) == MULT)
     {
-      register rtx op0 = copy_all_regs (XEXP (x, 0));
-      register rtx op1 = copy_all_regs (XEXP (x, 1));
+      rtx op0 = copy_all_regs (XEXP (x, 0));
+      rtx op1 = copy_all_regs (XEXP (x, 1));
       if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
 	x = gen_rtx_fmt_ee (GET_CODE (x), Pmode, op0, op1);
     }
@@ -464,9 +464,9 @@ copy_all_regs (x)
 rtx
 memory_address (mode, x)
      enum machine_mode mode;
-     register rtx x;
+     rtx x;
 {
-  register rtx oldx = x;
+  rtx oldx = x;
 
   if (GET_CODE (x) == ADDRESSOF)
     return x;
@@ -667,7 +667,7 @@ rtx
 copy_to_reg (x)
      rtx x;
 {
-  register rtx temp = gen_reg_rtx (GET_MODE (x));
+  rtx temp = gen_reg_rtx (GET_MODE (x));
  
   /* If not an operand, must be an address with PLUS and MULT so
      do the computation.  */ 
@@ -698,7 +698,7 @@ copy_to_mode_reg (mode, x)
      enum machine_mode mode;
      rtx x;
 {
-  register rtx temp = gen_reg_rtx (mode);
+  rtx temp = gen_reg_rtx (mode);
   
   /* If not an operand, must be an address with PLUS and MULT so
      do the computation.  */ 
@@ -725,7 +725,7 @@ force_reg (mode, x)
      enum machine_mode mode;
      rtx x;
 {
-  register rtx temp, insn, set;
+  rtx temp, insn, set;
 
   if (GET_CODE (x) == REG)
     return x;
@@ -761,7 +761,7 @@ rtx
 force_not_mem (x)
      rtx x;
 {
-  register rtx temp;
+  rtx temp;
 
   if (GET_CODE (x) != MEM || GET_MODE (x) == BLKmode)
     return x;
@@ -780,7 +780,7 @@ copy_to_suggested_reg (x, target, mode)
      rtx x, target;
      enum machine_mode mode;
 {
-  register rtx temp;
+  rtx temp;
 
   if (target && GET_CODE (target) == REG)
     temp = target;
diff --git a/gcc/expmed.c b/gcc/expmed.c
index f7f3728fd2e..b08a8c60c46 100644
--- a/gcc/expmed.c
+++ b/gcc/expmed.c
@@ -302,7 +302,7 @@ store_bit_field (str_rtx, bitsize, bitnum, fieldmode, value, align, total_size)
     = (GET_CODE (str_rtx) == MEM) ? BITS_PER_UNIT : BITS_PER_WORD;
   unsigned HOST_WIDE_INT offset = bitnum / unit;
   unsigned HOST_WIDE_INT bitpos = bitnum % unit;
-  register rtx op0 = str_rtx;
+  rtx op0 = str_rtx;
 
   enum machine_mode op_mode = mode_for_extraction (EP_insv, 3);
 
@@ -693,12 +693,12 @@ store_bit_field (str_rtx, bitsize, bitnum, fieldmode, value, align, total_size)
 
 static void
 store_fixed_bit_field (op0, offset, bitsize, bitpos, value, struct_align)
-     register rtx op0;
+     rtx op0;
      unsigned HOST_WIDE_INT offset, bitsize, bitpos;
-     register rtx value;
+     rtx value;
      unsigned int struct_align;
 {
-  register enum machine_mode mode;
+  enum machine_mode mode;
   unsigned int total_bits = BITS_PER_WORD;
   rtx subtarget, temp;
   int all_zero = 0;
@@ -794,7 +794,7 @@ store_fixed_bit_field (op0, offset, bitsize, bitpos, value, struct_align)
 
   if (GET_CODE (value) == CONST_INT)
     {
-      register HOST_WIDE_INT v = INTVAL (value);
+      HOST_WIDE_INT v = INTVAL (value);
 
       if (bitsize < HOST_BITS_PER_WIDE_INT)
 	v &= ((HOST_WIDE_INT) 1 << bitsize) - 1;
@@ -1033,7 +1033,7 @@ extract_bit_field (str_rtx, bitsize, bitnum, unsignedp,
     = (GET_CODE (str_rtx) == MEM) ? BITS_PER_UNIT : BITS_PER_WORD;
   unsigned HOST_WIDE_INT offset = bitnum / unit;
   unsigned HOST_WIDE_INT bitpos = bitnum % unit;
-  register rtx op0 = str_rtx;
+  rtx op0 = str_rtx;
   rtx spec_target = target;
   rtx spec_target_subreg = 0;
   enum machine_mode int_mode;
@@ -1577,7 +1577,7 @@ static rtx
 extract_fixed_bit_field (tmode, op0, offset, bitsize, bitpos,
 			 target, unsignedp, align)
      enum machine_mode tmode;
-     register rtx op0, target;
+     rtx op0, target;
      unsigned HOST_WIDE_INT offset, bitsize, bitpos;
      int unsignedp;
      unsigned int align;
@@ -1931,15 +1931,15 @@ expand_dec (target, dec)
 rtx
 expand_shift (code, mode, shifted, amount, target, unsignedp)
      enum tree_code code;
-     register enum machine_mode mode;
+     enum machine_mode mode;
      rtx shifted;
      tree amount;
-     register rtx target;
+     rtx target;
      int unsignedp;
 {
-  register rtx op1, temp = 0;
-  register int left = (code == LSHIFT_EXPR || code == LROTATE_EXPR);
-  register int rotate = (code == LROTATE_EXPR || code == RROTATE_EXPR);
+  rtx op1, temp = 0;
+  int left = (code == LSHIFT_EXPR || code == LROTATE_EXPR);
+  int rotate = (code == LROTATE_EXPR || code == RROTATE_EXPR);
   int try;
 
   /* Previously detected shift-counts computed by NEGATE_EXPR
@@ -2371,7 +2371,7 @@ synth_mult (alg_out, t, cost_limit)
 rtx
 expand_mult (mode, op0, op1, target, unsignedp)
      enum machine_mode mode;
-     register rtx op0, op1, target;
+     rtx op0, op1, target;
      int unsignedp;
 {
   rtx const_op1 = op1;
@@ -2757,7 +2757,7 @@ invert_mod2n (x, n)
 rtx
 expand_mult_highpart_adjust (mode, adj_operand, op0, op1, target, unsignedp)
      enum machine_mode mode;
-     register rtx adj_operand, op0, op1, target;
+     rtx adj_operand, op0, op1, target;
      int unsignedp;
 {
   rtx tem;
@@ -2794,7 +2794,7 @@ expand_mult_highpart_adjust (mode, adj_operand, op0, op1, target, unsignedp)
 rtx
 expand_mult_highpart (mode, op0, cnst1, target, unsignedp, max_cost)
      enum machine_mode mode;
-     register rtx op0, target;
+     rtx op0, target;
      unsigned HOST_WIDE_INT cnst1;
      int unsignedp;
      int max_cost;
@@ -2976,11 +2976,11 @@ expand_divmod (rem_flag, code, mode, op0, op1, target, unsignedp)
      int rem_flag;
      enum tree_code code;
      enum machine_mode mode;
-     register rtx op0, op1, target;
+     rtx op0, op1, target;
      int unsignedp;
 {
   enum machine_mode compute_mode;
-  register rtx tquotient;
+  rtx tquotient;
   rtx quotient = 0, remainder = 0;
   rtx last;
   int size;
diff --git a/gcc/expr.c b/gcc/expr.c
index a45042fe832..9457e8fd7be 100644
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -365,10 +365,10 @@ enqueue_insn (var, body)
 
 rtx
 protect_from_queue (x, modify)
-     register rtx x;
+     rtx x;
      int modify;
 {
-  register RTX_CODE code = GET_CODE (x);
+  RTX_CODE code = GET_CODE (x);
 
 #if 0  /* A QUEUED can hang around after the queue is forced out.  */
   /* Shortcut for most common case.  */
@@ -453,7 +453,7 @@ int
 queued_subexp_p (x)
      rtx x;
 {
-  register enum rtx_code code = GET_CODE (x);
+  enum rtx_code code = GET_CODE (x);
   switch (code)
     {
     case QUEUED:
@@ -475,7 +475,7 @@ queued_subexp_p (x)
 void
 emit_queue ()
 {
-  register rtx p;
+  rtx p;
   while ((p = pending_chain))
     {
       rtx body = QUEUED_BODY (p);
@@ -498,7 +498,7 @@ emit_queue ()
 
 void
 convert_move (to, from, unsignedp)
-     register rtx to, from;
+     rtx to, from;
      int unsignedp;
 {
   enum machine_mode to_mode = GET_MODE (to);
@@ -1294,7 +1294,7 @@ convert_modes (mode, oldmode, x, unsignedp)
      rtx x;
      int unsignedp;
 {
-  register rtx temp;
+  rtx temp;
 
   /* If FROM is a SUBREG that indicates that we have already done at least
      the required extension, strip it.  */
@@ -3082,7 +3082,7 @@ push_block (size, extra, below)
      rtx size;
      int extra, below;
 {
-  register rtx temp;
+  rtx temp;
 
   size = convert_modes (Pmode, ptr_mode, size, 1);
   if (CONSTANT_P (size))
@@ -3132,7 +3132,7 @@ static rtx
 get_push_address (size)
      int size;
 {
-  register rtx temp;
+  rtx temp;
 
   if (STACK_PUSH_CODE == POST_DEC)
     temp = gen_rtx_PLUS (Pmode, stack_pointer_rtx, GEN_INT (size));
@@ -3237,7 +3237,7 @@ void
 emit_push_insn (x, mode, type, size, align, partial, reg, extra,
 		args_addr, args_so_far, reg_parm_stack_space,
                 alignment_pad)
-     register rtx x;
+     rtx x;
      enum machine_mode mode;
      tree type;
      rtx size;
@@ -3275,7 +3275,7 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
     {
       /* Copy a block into the stack, entirely or partially.  */
 
-      register rtx temp;
+      rtx temp;
       int used = partial * UNITS_PER_WORD;
       int offset = used % (PARM_BOUNDARY / BITS_PER_UNIT);
       int skip;
@@ -3683,7 +3683,7 @@ expand_assignment (to, from, want_value, suggest_reg)
      int want_value;
      int suggest_reg ATTRIBUTE_UNUSED;
 {
-  register rtx to_rtx = 0;
+  rtx to_rtx = 0;
   rtx result;
 
   /* Don't crash if the lhs of the assignment was erroneous.  */
@@ -4023,11 +4023,11 @@ expand_assignment (to, from, want_value, suggest_reg)
 
 rtx
 store_expr (exp, target, want_value)
-     register tree exp;
-     register rtx target;
+     tree exp;
+     rtx target;
      int want_value;
 {
-  register rtx temp;
+  rtx temp;
   int dont_return_target = 0;
   int dont_store_target = 0;
 
@@ -4542,7 +4542,7 @@ store_constructor (exp, target, align, cleared, size)
   if (TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
       || TREE_CODE (type) == QUAL_UNION_TYPE)
     {
-      register tree elt;
+      tree elt;
 
       /* Inform later passes that the whole union value is dead.  */
       if ((TREE_CODE (type) == UNION_TYPE
@@ -4595,11 +4595,11 @@ store_constructor (exp, target, align, cleared, size)
 
       for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
 	{
-	  register tree field = TREE_PURPOSE (elt);
+	  tree field = TREE_PURPOSE (elt);
 #ifdef WORD_REGISTER_OPERATIONS
 	  tree value = TREE_VALUE (elt);
 #endif
-	  register enum machine_mode mode;
+	  enum machine_mode mode;
 	  HOST_WIDE_INT bitsize;
 	  HOST_WIDE_INT bitpos = 0;
 	  int unsignedp;
@@ -4709,8 +4709,8 @@ store_constructor (exp, target, align, cleared, size)
     }
   else if (TREE_CODE (type) == ARRAY_TYPE)
     {
-      register tree elt;
-      register int i;
+      tree elt;
+      int i;
       int need_to_clear;
       tree domain = TYPE_DOMAIN (type);
       tree elttype = TREE_TYPE (type);
@@ -4795,7 +4795,7 @@ store_constructor (exp, target, align, cleared, size)
 	   elt;
 	   elt = TREE_CHAIN (elt), i++)
 	{
-	  register enum machine_mode mode;
+	  enum machine_mode mode;
 	  HOST_WIDE_INT bitsize;
 	  HOST_WIDE_INT bitpos;
 	  int unsignedp;
@@ -5582,13 +5582,13 @@ rtx
 force_operand (value, target)
      rtx value, target;
 {
-  register optab binoptab = 0;
+  optab binoptab = 0;
   /* Use a temporary to force order of execution of calls to
      `force_operand'.  */
   rtx tmp;
-  register rtx op2;
+  rtx op2;
   /* Use subtarget as the target for operand 0 of a binary operation.  */
-  register rtx subtarget = get_subtarget (target);
+  rtx subtarget = get_subtarget (target);
 
   /* Check for a PIC address load.  */
   if (flag_pic
@@ -6059,16 +6059,16 @@ find_placeholder (exp, plist)
 
 rtx
 expand_expr (exp, target, tmode, modifier)
-     register tree exp;
+     tree exp;
      rtx target;
      enum machine_mode tmode;
      enum expand_modifier modifier;
 {
-  register rtx op0, op1, temp;
+  rtx op0, op1, temp;
   tree type = TREE_TYPE (exp);
   int unsignedp = TREE_UNSIGNED (type);
-  register enum machine_mode mode;
-  register enum tree_code code = TREE_CODE (exp);
+  enum machine_mode mode;
+  enum tree_code code = TREE_CODE (exp);
   optab this_optab;
   rtx subtarget, original_target;
   int ignore;
@@ -7658,7 +7658,7 @@ expand_expr (exp, target, tmode, modifier)
 	 check the second operand.  */
       if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST)
 	{
-	  register tree t1 = TREE_OPERAND (exp, 0);
+	  tree t1 = TREE_OPERAND (exp, 0);
 	  TREE_OPERAND (exp, 0) = TREE_OPERAND (exp, 1);
 	  TREE_OPERAND (exp, 1) = t1;
 	}
@@ -8811,12 +8811,12 @@ expand_expr (exp, target, tmode, modifier)
 
 static rtx
 expand_expr_unaligned (exp, palign)
-     register tree exp;
+     tree exp;
      unsigned int *palign;
 {
-  register rtx op0;
+  rtx op0;
   tree type = TREE_TYPE (exp);
-  register enum machine_mode mode = TYPE_MODE (type);
+  enum machine_mode mode = TYPE_MODE (type);
 
   /* Default the alignment we return to that of the type.  */
   *palign = TYPE_ALIGN (type);
@@ -9163,12 +9163,12 @@ string_constant (arg, ptr_offset)
 
 static rtx
 expand_increment (exp, post, ignore)
-     register tree exp;
+     tree exp;
      int post, ignore;
 {
-  register rtx op0, op1;
-  register rtx temp, value;
-  register tree incremented = TREE_OPERAND (exp, 0);
+  rtx op0, op1;
+  rtx temp, value;
+  tree incremented = TREE_OPERAND (exp, 0);
   optab this_optab = add_optab;
   int icode;
   enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
@@ -9448,7 +9448,7 @@ do_jump (exp, if_false_label, if_true_label)
      tree exp;
      rtx if_false_label, if_true_label;
 {
-  register enum tree_code code = TREE_CODE (exp);
+  enum tree_code code = TREE_CODE (exp);
   /* Some cases need to create a label to jump to
      in order to properly fall through.
      These cases set DROP_THROUGH_LABEL nonzero.  */
@@ -9634,7 +9634,7 @@ do_jump (exp, if_false_label, if_true_label)
 
       else
 	{
-	  register rtx label1 = gen_label_rtx ();
+	  rtx label1 = gen_label_rtx ();
 	  drop_through_label = gen_label_rtx ();
 
 	  do_jump (TREE_OPERAND (exp, 0), label1, NULL_RTX);
@@ -10095,7 +10095,7 @@ do_jump_by_parts_equality_rtx (op0, if_false_label, if_true_label)
 
 rtx
 compare_from_rtx (op0, op1, code, unsignedp, mode, size, align)
-     register rtx op0, op1;
+     rtx op0, op1;
      enum rtx_code code;
      int unsignedp;
      enum machine_mode mode;
@@ -10166,7 +10166,7 @@ compare_from_rtx (op0, op1, code, unsignedp, mode, size, align)
 void
 do_compare_rtx_and_jump (op0, op1, code, unsignedp, mode, size, align,
 			 if_false_label, if_true_label)
-     register rtx op0, op1;
+     rtx op0, op1;
      enum rtx_code code;
      int unsignedp;
      enum machine_mode mode;
@@ -10271,14 +10271,14 @@ do_compare_rtx_and_jump (op0, op1, code, unsignedp, mode, size, align,
 static void
 do_compare_and_jump (exp, signed_code, unsigned_code, if_false_label,
 		     if_true_label)
-     register tree exp;
+     tree exp;
      enum rtx_code signed_code, unsigned_code;
      rtx if_false_label, if_true_label;
 {
   unsigned int align0, align1;
-  register rtx op0, op1;
-  register tree type;
-  register enum machine_mode mode;
+  rtx op0, op1;
+  tree type;
+  enum machine_mode mode;
   int unsignedp;
   enum rtx_code code;
 
@@ -10754,7 +10754,7 @@ do_tablejump (index, mode, range, table_label, default_label)
      rtx index, range, table_label, default_label;
      enum machine_mode mode;
 {
-  register rtx temp, vector;
+  rtx temp, vector;
 
   /* Do an unsigned comparison (in the proper mode) between the index
      expression and the value which represents the length of the range.
diff --git a/gcc/final.c b/gcc/final.c
index 59d1420596a..28f756d1475 100644
--- a/gcc/final.c
+++ b/gcc/final.c
@@ -1948,7 +1948,7 @@ final (first, file, optimize, prescan)
      int optimize;
      int prescan;
 {
-  register rtx insn;
+  rtx insn;
   int max_line = 0;
   int max_uid = 0;
 
@@ -2205,7 +2205,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes)
 
 	  /* This note is a line-number.  */
 	  {
-	    register rtx note;
+	    rtx note;
 	    int note_after = 0;
 
 	    /* If there is anything real after this note, output it.
@@ -2372,7 +2372,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes)
 
     default:
       {
-	register rtx body = PATTERN (insn);
+	rtx body = PATTERN (insn);
 	int insn_code_number;
 	const char *template;
 #ifdef HAVE_cc0
@@ -2406,7 +2406,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes)
 	if (GET_CODE (body) == ADDR_VEC || GET_CODE (body) == ADDR_DIFF_VEC)
 	  {
 #if !(defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC))
-	    register int vlen, idx;
+	    int vlen, idx;
 #endif
 
 	    if (prescan > 0)
@@ -2541,7 +2541,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes)
 	if (GET_CODE (body) == SEQUENCE)
 	  {
 	    /* A delayed-branch sequence */
-	    register int i;
+	    int i;
 	    rtx next;
 
 	    if (prescan > 0)
@@ -2705,7 +2705,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes)
 	       It may also return 1 meaning condition now always true
 	       or -1 meaning condition now always false
 	       or 2 meaning condition nontrivial but altered.  */
-	    register int result = alter_cond (XEXP (SET_SRC (body), 0));
+	    int result = alter_cond (XEXP (SET_SRC (body), 0));
 	    /* If condition now has fixed value, replace the IF_THEN_ELSE
 	       with its then-operand or its else-operand.  */
 	    if (result == 1)
@@ -2766,7 +2766,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes)
 	      case EQ:
 	      case NE:
 		{
-		  register int result;
+		  int result;
 		  if (XEXP (cond_rtx, 0) != cc0_rtx)
 		    break;
 		  result = alter_cond (cond_rtx);
@@ -2966,7 +2966,7 @@ static void
 notice_source_line (insn)
      rtx insn;
 {
-  register const char *filename = NOTE_SOURCE_FILE (insn);
+  const char *filename = NOTE_SOURCE_FILE (insn);
 
   /* Remember filename for basic block profiling.
      Filenames are allocated on the permanent obstack
@@ -3017,9 +3017,9 @@ cleanup_subreg_operands (insn)
 
 rtx
 alter_subreg (x)
-     register rtx x;
+     rtx x;
 {
-  register rtx y = SUBREG_REG (x);
+  rtx y = SUBREG_REG (x);
 
   if (GET_CODE (y) == SUBREG)
     y = alter_subreg (y);
@@ -3097,7 +3097,7 @@ walk_alter_subreg (x)
 
 static int
 alter_cond (cond)
-     register rtx cond;
+     rtx cond;
 {
   int value = 0;
 
@@ -3286,7 +3286,7 @@ output_asm_name ()
 	 alternative used.  */
       if (debug_insn)
 	{
-	  register int num = INSN_CODE (debug_insn);
+	  int num = INSN_CODE (debug_insn);
 	  fprintf (asm_out_file, "\t%s %d\t%s",
 		   ASM_COMMENT_START, INSN_UID (debug_insn),
 		   insn_data[num].name);
@@ -3308,8 +3308,8 @@ output_asm_insn (template, operands)
      const char *template;
      rtx *operands;
 {
-  register const char *p;
-  register int c;
+  const char *p;
+  int c;
 
   /* An insn may return a null string template
      in a case where no assembler code is needed.  */
@@ -3342,7 +3342,7 @@ output_asm_insn (template, operands)
 #ifdef ASSEMBLER_DIALECT
       case '{':
 	{
-	  register int i;
+	  int i;
 
 	  /* If we want the first dialect, do nothing.  Otherwise, skip
 	     DIALECT_NUMBER of strings ending with '|'.  */
@@ -4096,10 +4096,10 @@ leaf_renumber_regs (first)
 
 void
 leaf_renumber_regs_insn (in_rtx)
-     register rtx in_rtx;
+     rtx in_rtx;
 {
-  register int i, j;
-  register const char *format_ptr;
+  int i, j;
+  const char *format_ptr;
 
   if (in_rtx == 0)
     return;
diff --git a/gcc/fix-header.c b/gcc/fix-header.c
index cf37a41a21d..b197371c22a 100644
--- a/gcc/fix-header.c
+++ b/gcc/fix-header.c
@@ -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++)
diff --git a/gcc/floatlib.c b/gcc/floatlib.c
index ed139033d69..929aef7353c 100644
--- a/gcc/floatlib.c
+++ b/gcc/floatlib.c
@@ -100,9 +100,9 @@ union float_long
 float
 __addsf3 (float a1, float a2)
 {
-  register long mant1, mant2;
-  register union float_long fl1, fl2;
-  register int exp1, exp2;
+  long mant1, mant2;
+  union float_long fl1, fl2;
+  int exp1, exp2;
   int sign = 0;
 
   fl1.f = a1;
@@ -196,7 +196,7 @@ test_done:
 float
 __subsf3 (float a1, float a2)
 {
-  register union float_long fl1, fl2;
+  union float_long fl1, fl2;
 
   fl1.f = a1;
   fl2.f = a2;
@@ -216,7 +216,7 @@ __subsf3 (float a1, float a2)
 long
 __cmpsf2 (float a1, float a2)
 {
-  register union float_long fl1, fl2;
+  union float_long fl1, fl2;
 
   fl1.f = a1;
   fl2.f = a2;
@@ -237,9 +237,9 @@ __cmpsf2 (float a1, float a2)
 float
 __mulsf3 (float a1, float a2)
 {
-  register union float_long fl1, fl2;
-  register unsigned long result;
-  register int exp;
+  union float_long fl1, fl2;
+  unsigned long result;
+  int exp;
   int sign;
 
   fl1.f = a1;
@@ -294,10 +294,10 @@ test_done:
 float
 __divsf3 (float a1, float a2)
 {
-  register union float_long fl1, fl2;
-  register int result;
-  register int mask;
-  register int exp, sign;
+  union float_long fl1, fl2;
+  int result;
+  int mask;
+  int exp, sign;
 
   fl1.f = a1;
   fl2.f = a2;
@@ -358,9 +358,9 @@ __divsf3 (float a1, float a2)
 
 /* convert int to double */
 double
-__floatsidf (register long a1)
+__floatsidf (long a1)
 {
-  register int sign = 0, exp = 31 + EXCESSD;
+  int sign = 0, exp = 31 + EXCESSD;
   union double_long dl;
 
   if (!a1)
@@ -397,9 +397,9 @@ __floatsidf (register long a1)
 }
 
 double
-__floatdidf (register long long a1)
+__floatdidf (long long a1)
 {
-    register int exp = 63 + EXCESSD;
+    int exp = 63 + EXCESSD;
     union double_long dl;
 
     dl.l.upper = dl.l.lower = 0;
@@ -428,13 +428,13 @@ __floatdidf (register long long a1)
 }
 
 float
-__floatsisf (register long a1)
+__floatsisf (long a1)
 {
     (float)__floatsidf(a1);
 }
 
 float
-__floatdisf (register long long a1)
+__floatdisf (long long a1)
 {
     (float)__floatdidf(a1);
 }
@@ -443,7 +443,7 @@ __floatdisf (register long long a1)
 float
 __negsf2 (float a1)
 {
-  register union float_long fl1;
+  union float_long fl1;
 
   fl1.f = a1;
   if (!fl1.l)
@@ -457,7 +457,7 @@ __negsf2 (float a1)
 double
 __negdf2 (double a1)
 {
-  register union double_long dl1;
+  union double_long dl1;
 
   dl1.d = a1;
 
@@ -472,9 +472,9 @@ __negdf2 (double a1)
 double
 __extendsfdf2 (float a1)
 {
-  register union float_long fl1;
-  register union double_long dl;
-  register int exp;
+  union float_long fl1;
+  union double_long dl;
+  int exp;
 
   fl1.f = a1;
 
@@ -497,10 +497,10 @@ __extendsfdf2 (float a1)
 float
 __truncdfsf2 (double a1)
 {
-  register int exp;
-  register long mant;
-  register union float_long fl;
-  register union double_long dl1;
+  int exp;
+  long mant;
+  union float_long fl;
+  union double_long dl1;
 
   dl1.d = a1;
 
@@ -534,7 +534,7 @@ __truncdfsf2 (double a1)
 long
 __cmpdf2 (double a1, double a2)
 {
-  register union double_long dl1, dl2;
+  union double_long dl1, dl2;
 
   dl1.d = a1;
   dl2.d = a2;
@@ -559,9 +559,9 @@ __cmpdf2 (double a1, double a2)
 long
 __fixdfsi (double a1)
 {
-  register union double_long dl1;
-  register int exp;
-  register long l;
+  union double_long dl1;
+  int exp;
+  long l;
 
   dl1.d = a1;
 
@@ -587,9 +587,9 @@ __fixdfsi (double a1)
 long long
 __fixdfdi (double a1)
 {
-    register union double_long dl1;
-    register int exp;
-    register long long l;
+    union double_long dl1;
+    int exp;
+    long long l;
 
     dl1.d = a1;
 
@@ -619,9 +619,9 @@ __fixdfdi (double a1)
 unsigned long
 __fixunsdfsi (double a1)
 {
-  register union double_long dl1;
-  register int exp;
-  register unsigned long l;
+  union double_long dl1;
+  int exp;
+  unsigned long l;
 
   dl1.d = a1;
 
@@ -647,9 +647,9 @@ __fixunsdfsi (double a1)
 unsigned long long
 __fixunsdfdi (double a1)
 {
-    register union double_long dl1;
-    register int exp;
-    register unsigned long long l;
+    union double_long dl1;
+    int exp;
+    unsigned long long l;
 
     dl1.d = a1;
 
@@ -676,9 +676,9 @@ __fixunsdfdi (double a1)
 double
 __adddf3 (double a1, double a2)
 {
-    register long long mant1, mant2;
-    register union double_long fl1, fl2;
-    register int exp1, exp2;
+    long long mant1, mant2;
+    union double_long fl1, fl2;
+    int exp1, exp2;
     int sign = 0;
 
     fl1.d = a1;
@@ -765,7 +765,7 @@ test_done:
 double
 __subdf3 (double a1, double a2)
 {
-    register union double_long fl1, fl2;
+    union double_long fl1, fl2;
 
     fl1.d = a1;
     fl2.d = a2;
@@ -784,9 +784,9 @@ __subdf3 (double a1, double a2)
 double
 __muldf3 (double a1, double a2)
 {
-    register union double_long fl1, fl2;
-    register unsigned long long result;
-    register int exp;
+    union double_long fl1, fl2;
+    unsigned long long result;
+    int exp;
     int sign;
 
     fl1.d = a1;
@@ -838,9 +838,9 @@ test_done:
 double
 __divdf3 (double a1, double a2)
 {
-    register union double_long fl1, fl2;
-    register long long mask,result;
-    register int exp, sign;
+    union double_long fl1, fl2;
+    long long mask,result;
+    int exp, sign;
 
     fl1.d = a1;
     fl2.d = a2;
diff --git a/gcc/flow.c b/gcc/flow.c
index 98b3e4919ee..f0dd62e3149 100644
--- a/gcc/flow.c
+++ b/gcc/flow.c
@@ -416,7 +416,7 @@ life_analysis (f, file, flags)
      int flags;
 {
 #ifdef ELIMINABLE_REGS
-  register int i;
+  int i;
   static const struct {const int from, to; } eliminables[] = ELIMINABLE_REGS;
 #endif
 
@@ -1273,7 +1273,7 @@ calculate_global_regs_live (blocks_in, blocks_out, flags)
 void
 allocate_bb_life_data ()
 {
-  register int i;
+  int i;
 
   for (i = 0; i < n_basic_blocks; i++)
     {
@@ -1452,7 +1452,7 @@ propagate_one_insn (pbi, insn)
      a following memory address.  */
 #ifdef AUTO_INC_DEC
   {
-    register rtx x = single_set (insn);
+    rtx x = single_set (insn);
 
     /* Does this instruction increment or decrement a register?  */
     if ((flags & PROP_AUTOINC)
@@ -1510,7 +1510,7 @@ propagate_one_insn (pbi, insn)
 
       if (GET_CODE (insn) == CALL_INSN)
 	{
-	  register int i;
+	  int i;
 	  rtx note, cond;
 
 	  cond = NULL_RTX;
@@ -1560,7 +1560,7 @@ propagate_one_insn (pbi, insn)
 
       if (! insn_is_dead && GET_CODE (insn) == CALL_INSN)
 	{
-	  register int i;
+	  int i;
 	  rtx note, cond;
 
 	  cond = NULL_RTX;
@@ -1815,7 +1815,7 @@ propagate_block (bb, live, local_set, cond_local_set, flags)
 
   if (flags & PROP_REG_INFO)
     {
-      register int i;
+      int i;
 
       /* Process the regs live at the end of the block.
 	 Mark them as not local to any one basic block.  */
@@ -2062,13 +2062,13 @@ libcall_dead_p (pbi, note, insn)
 
   if (x)
     {
-      register rtx r = SET_SRC (x);
+      rtx r = SET_SRC (x);
 
       if (GET_CODE (r) == REG)
 	{
 	  rtx call = XEXP (note, 0);
 	  rtx call_pat;
-	  register int i;
+	  int i;
 
 	  /* Find the call insn.  */
 	  while (call != insn && GET_CODE (call) != CALL_INSN)
@@ -2271,7 +2271,8 @@ mark_set_regs (pbi, x, insn)
 
     case PARALLEL:
       {
-	register int i;
+	int i;
+
 	for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
 	  {
 	    rtx sub = XVECEXP (x, 0, i);
@@ -2486,8 +2487,8 @@ mark_set_1 (pbi, code, reg, cond, insn, flags)
       if (flags & (PROP_LOG_LINKS | PROP_REG_INFO
 		   | PROP_DEATH_NOTES | PROP_AUTOINC))
 	{
-	  register rtx y;
-	  register int blocknum = pbi->bb->index;
+	  rtx y;
+	  int blocknum = pbi->bb->index;
 
 	  y = NULL_RTX;
 	  if (flags & (PROP_LOG_LINKS | PROP_AUTOINC))
@@ -3331,7 +3332,7 @@ mark_used_reg (pbi, reg, cond, insn)
 	{
 	  /* Keep track of which basic block each reg appears in.  */
 
-	  register int blocknum = pbi->bb->index;
+	  int blocknum = pbi->bb->index;
 	  if (REG_BASIC_BLOCK (regno_first) == REG_BLOCK_UNKNOWN)
 	    REG_BASIC_BLOCK (regno_first) = blocknum;
 	  else if (REG_BASIC_BLOCK (regno_first) != blocknum)
@@ -3463,8 +3464,8 @@ mark_used_regs (pbi, x, cond, insn)
      struct propagate_block_info *pbi;
      rtx x, cond, insn;
 {
-  register RTX_CODE code;
-  register int regno;
+  RTX_CODE code;
+  int regno;
   int flags = pbi->flags;
 
  retry:
@@ -3565,7 +3566,7 @@ mark_used_regs (pbi, x, cond, insn)
 
     case SET:
       {
-	register rtx testreg = SET_DEST (x);
+	rtx testreg = SET_DEST (x);
 	int mark_dest = 0;
 
 	/* If storing into MEM, don't show it as being used.  But do
@@ -3704,8 +3705,8 @@ mark_used_regs (pbi, x, cond, insn)
   /* Recursively scan the operands of this expression.  */
 
   {
-    register const char * const fmt = GET_RTX_FORMAT (code);
-    register int i;
+    const char * const fmt = GET_RTX_FORMAT (code);
+    int i;
 
     for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
       {
@@ -3721,7 +3722,7 @@ mark_used_regs (pbi, x, cond, insn)
 	  }
 	else if (fmt[i] == 'E')
 	  {
-	    register int j;
+	    int j;
 	    for (j = 0; j < XVECLEN (x, i); j++)
 	      mark_used_regs (pbi, XVECEXP (x, i, j), cond, insn);
 	  }
@@ -3784,7 +3785,7 @@ try_pre_increment (insn, reg, amount)
      rtx insn, reg;
      HOST_WIDE_INT amount;
 {
-  register rtx use;
+  rtx use;
 
   /* Nonzero if we can try to make a pre-increment or pre-decrement.
      For example, addl $4,r1; movl (r1),... can become movl +(r1),...  */
@@ -3861,15 +3862,15 @@ try_pre_increment (insn, reg, amount)
 
 rtx
 find_use_as_address (x, reg, plusconst)
-     register rtx x;
+     rtx x;
      rtx reg;
      HOST_WIDE_INT plusconst;
 {
   enum rtx_code code = GET_CODE (x);
   const char * const fmt = GET_RTX_FORMAT (code);
-  register int i;
-  register rtx value = 0;
-  register rtx tem;
+  int i;
+  rtx value = 0;
+  rtx tem;
 
   if (code == MEM && XEXP (x, 0) == reg && plusconst == 0)
     return x;
@@ -3903,7 +3904,7 @@ find_use_as_address (x, reg, plusconst)
 	}
       else if (fmt[i] == 'E')
 	{
-	  register int j;
+	  int j;
 	  for (j = XVECLEN (x, i) - 1; j >= 0; j--)
 	    {
 	      tem = find_use_as_address (XVECEXP (x, i, j), reg, plusconst);
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 2aa26f317b1..e25b67fc76d 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -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);
diff --git a/gcc/function.c b/gcc/function.c
index 2e510dc66f2..19b9f505798 100644
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -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
diff --git a/gcc/gcc.c b/gcc/gcc.c
index d265fae9555..f49804019ea 100644
--- a/gcc/gcc.c
+++ b/gcc/gcc.c
@@ -1737,7 +1737,7 @@ read_specs (filename, main_p)
      int main_p;
 {
   char *buffer;
-  register char *p;
+  char *p;
 
   buffer = load_specs (filename);
 
@@ -2003,11 +2003,11 @@ record_temp_file (filename, always_delete, fail_delete)
      int always_delete;
      int fail_delete;
 {
-  register char *const name = xstrdup (filename);
+  char *const name = xstrdup (filename);
 
   if (always_delete)
     {
-      register struct temp_file *temp;
+      struct temp_file *temp;
       for (temp = always_delete_queue; temp; temp = temp->next)
 	if (! strcmp (name, temp->name))
 	  goto already1;
@@ -2022,7 +2022,7 @@ record_temp_file (filename, always_delete, fail_delete)
 
   if (fail_delete)
     {
-      register struct temp_file *temp;
+      struct temp_file *temp;
       for (temp = failure_delete_queue; temp; temp = temp->next)
 	if (! strcmp (name, temp->name))
 	  goto already2;
@@ -2064,7 +2064,7 @@ delete_if_ordinary (name)
 static void
 delete_temp_files ()
 {
-  register struct temp_file *temp;
+  struct temp_file *temp;
 
   for (temp = always_delete_queue; temp; temp = temp->next)
     delete_if_ordinary (temp->name);
@@ -2076,7 +2076,7 @@ delete_temp_files ()
 static void
 delete_failure_queue ()
 {
-  register struct temp_file *temp;
+  struct temp_file *temp;
 
   for (temp = failure_delete_queue; temp; temp = temp->next)
     delete_if_ordinary (temp->name);
@@ -3065,7 +3065,7 @@ process_command (argc, argv)
      int argc;
      const char *const *argv;
 {
-  register int i;
+  int i;
   const char *temp;
   char *temp1;
   const char *spec_lang = 0;
@@ -3413,8 +3413,8 @@ process_command (argc, argv)
 	report_times = 1;
       else if (argv[i][0] == '-' && argv[i][1] != 0)
 	{
-	  register const char *p = &argv[i][1];
-	  register int c = *p;
+	  const char *p = &argv[i][1];
+	  int c = *p;
 
 	  switch (c)
 	    {
@@ -4060,8 +4060,8 @@ do_spec_1 (spec, inswitch, soft_matched_part)
      int inswitch;
      const char *soft_matched_part;
 {
-  register const char *p = spec;
-  register int c;
+  const char *p = spec;
+  int c;
   int i;
   const char *string;
   int value;
@@ -5004,7 +5004,7 @@ do_spec_1 (spec, inswitch, soft_matched_part)
 
 static const char *
 handle_braces (p)
-     register const char *p;
+     const char *p;
 {
   const char *filter, *body = NULL, *endbody = NULL;
   int pipe_p = 0;
@@ -5076,8 +5076,8 @@ next_member:
     {
       if (*p != '}' && *p != '&')
 	{
-	  register int count = 1;
-	  register const char *q = p;
+	  int count = 1;
+	  const char *q = p;
 
 	  while (*q++ != ':')
 	    continue;
@@ -5115,7 +5115,7 @@ next_member:
   else if (p[-1] == '*' && (p[0] == '}' || p[0] == '&'))
     {
       /* Substitute all matching switches as separate args.  */
-      register int i;
+      int i;
 
       for (i = 0; i < n_switches; i++)
 	if (!strncmp (switches[i].part1, filter, p - 1 - filter)
@@ -5133,7 +5133,7 @@ next_member:
   else
     {
       /* Test for presence of the specified switch.  */
-      register int i;
+      int i;
       int present = 0;
 
       /* If name specified ends in *, as in {x*:...},
@@ -5487,7 +5487,7 @@ static void
 set_input (filename)
      const char *filename;
 {
-  register const char *p;
+  const char *p;
 
   input_filename = filename;
   input_filename_length = strlen (input_filename);
@@ -6138,7 +6138,7 @@ save_string (s, len)
      const char *s;
      int len;
 {
-  register char *result = xmalloc (len + 1);
+  char *result = xmalloc (len + 1);
 
   memcpy (result, s, len);
   result[len] = 0;
@@ -6232,8 +6232,8 @@ static void
 validate_all_switches ()
 {
   struct compiler *comp;
-  register const char *p;
-  register char c;
+  const char *p;
+  char c;
   struct spec_list *spec;
 
   for (comp = compilers; comp->spec; comp++)
@@ -6269,9 +6269,9 @@ static void
 validate_switches (start)
      const char *start;
 {
-  register const char *p = start;
+  const char *p = start;
   const char *filter;
-  register int i;
+  int i;
   int suffix;
 
   if (*p == '|')
diff --git a/gcc/gcse.c b/gcc/gcse.c
index 2e0e7ed7a35..0119f674243 100644
--- a/gcc/gcse.c
+++ b/gcc/gcse.c
@@ -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;
diff --git a/gcc/gen-protos.c b/gcc/gen-protos.c
index 0bf6ea9d87c..8e535b5eb5c 100644
--- a/gcc/gen-protos.c
+++ b/gcc/gen-protos.c
@@ -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;
 
diff --git a/gcc/genattrtab.c b/gcc/genattrtab.c
index 33cd0d85d03..060f24a0327 100644
--- a/gcc/genattrtab.c
+++ b/gcc/genattrtab.c
@@ -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))
diff --git a/gcc/gencheck.c b/gcc/gencheck.c
index b8fe254196e..87364505d8f 100644
--- a/gcc/gencheck.c
+++ b/gcc/gencheck.c
@@ -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)
     {
diff --git a/gcc/genconfig.c b/gcc/genconfig.c
index 701b19c54b0..f9ae6d5e3ce 100644
--- a/gcc/genconfig.c
+++ b/gcc/genconfig.c
@@ -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;
diff --git a/gcc/genemit.c b/gcc/genemit.c
index f4ad66f5566..24d41874c51 100644
--- a/gcc/genemit.c
+++ b/gcc/genemit.c
@@ -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");
diff --git a/gcc/genextract.c b/gcc/genextract.c
index b835a01bf9d..80602d701c1 100644
--- a/gcc/genextract.c
+++ b/gcc/genextract.c
@@ -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");
diff --git a/gcc/genflags.c b/gcc/genflags.c
index 680429f7293..cd30af1f6f5 100644
--- a/gcc/genflags.c
+++ b/gcc/genflags.c
@@ -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;
 
diff --git a/gcc/gengenrtl.c b/gcc/gengenrtl.c
index eb3e32728cf..711cede5297 100644
--- a/gcc/gengenrtl.c
+++ b/gcc/gengenrtl.c
@@ -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)
     {
diff --git a/gcc/genoutput.c b/gcc/genoutput.c
index 1339c0afbd5..00b2903d949 100644
--- a/gcc/genoutput.c
+++ b/gcc/genoutput.c
@@ -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;
diff --git a/gcc/genpeep.c b/gcc/genpeep.c
index 6d70cbad5a4..4f0861f4471 100644
--- a/gcc/genpeep.c
+++ b/gcc/genpeep.c
@@ -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));
 }
diff --git a/gcc/genrecog.c b/gcc/genrecog.c
index 08ef3b4ac8d..7e1d849c70b 100644
--- a/gcc/genrecog.c
+++ b/gcc/genrecog.c
@@ -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");
 
diff --git a/gcc/gensupport.c b/gcc/gensupport.c
index bc18866ceb6..e5ce347168e 100644
--- a/gcc/gensupport.c
+++ b/gcc/gensupport.c
@@ -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");
diff --git a/gcc/global.c b/gcc/global.c
index 31d264d42cc..a460755c29f 100644
--- a/gcc/global.c
+++ b/gcc/global.c
@@ -335,7 +335,7 @@ global_alloc (file)
 #endif
        || FRAME_POINTER_REQUIRED);
 
-  register size_t i;
+  size_t i;
   rtx x;
 
   max_allocno = 0;
@@ -614,11 +614,11 @@ allocno_compare (v1p, v2p)
      times a register can occur in one insn (surely less than 100)
      weighted by the frequency (maximally REG_FREQ_MAX).
      Multiplying this by 10000/REG_FREQ_MAX can't overflow.  */
-  register int pri1
+  int pri1
     = (((double) (floor_log2 (allocno[v1].n_refs) * allocno[v1].freq)
 	/ allocno[v1].live_length)
        * (10000 / REG_FREQ_MAX) * allocno[v1].size);
-  register int pri2
+  int pri2
     = (((double) (floor_log2 (allocno[v2].n_refs) * allocno[v2].freq)
 	/ allocno[v2].live_length)
        * (10000 / REG_FREQ_MAX) * allocno[v2].size);
@@ -636,8 +636,8 @@ allocno_compare (v1p, v2p)
 static void
 global_conflicts ()
 {
-  register int b, i;
-  register rtx insn;
+  int b, i;
+  rtx insn;
   int *block_start_allocnos;
 
   /* Make a vector that mark_reg_{store,clobber} will store in.  */
@@ -664,13 +664,13 @@ global_conflicts ()
 	 are explicitly marked in basic_block_live_at_start.  */
 
       {
-	register regset old = BASIC_BLOCK (b)->global_live_at_start;
+	regset old = BASIC_BLOCK (b)->global_live_at_start;
 	int ax = 0;
 
 	REG_SET_TO_HARD_REG_SET (hard_regs_live, old);
 	EXECUTE_IF_SET_IN_REG_SET (old, FIRST_PSEUDO_REGISTER, i,
 				   {
-				     register int a = reg_allocno[i];
+				     int a = reg_allocno[i];
 				     if (a >= 0)
 				       {
 					 SET_ALLOCNO_LIVE (a);
@@ -731,8 +731,8 @@ global_conflicts ()
 
       while (1)
 	{
-	  register RTX_CODE code = GET_CODE (insn);
-	  register rtx link;
+	  RTX_CODE code = GET_CODE (insn);
+	  rtx link;
 
 	  /* Make regs_set an empty set.  */
 
@@ -984,7 +984,7 @@ find_reg (num, losers, alt_regs_p, accept_call_clobbered, retrying)
      int accept_call_clobbered;
      int retrying;
 {
-  register int i, best_reg, pass;
+  int i, best_reg, pass;
 #ifdef HARD_REG_SET
   register		/* Declare it register if it's a scalar.  */
 #endif
@@ -1048,8 +1048,8 @@ find_reg (num, losers, alt_regs_p, accept_call_clobbered, retrying)
 		  || accept_call_clobbered
 		  || ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode)))
 	    {
-	      register int j;
-	      register int lim = regno + HARD_REGNO_NREGS (regno, mode);
+	      int j;
+	      int lim = regno + HARD_REGNO_NREGS (regno, mode);
 	      for (j = regno + 1;
 		   (j < lim
 		    && ! TEST_HARD_REG_BIT (used, j));
@@ -1092,8 +1092,8 @@ find_reg (num, losers, alt_regs_p, accept_call_clobbered, retrying)
 		|| reg_class_subset_p (REGNO_REG_CLASS (best_reg),
 				       REGNO_REG_CLASS (i))))
 	    {
-	      register int j;
-	      register int lim = i + HARD_REGNO_NREGS (i, mode);
+	      int j;
+	      int lim = i + HARD_REGNO_NREGS (i, mode);
 	      for (j = i + 1;
 		   (j < lim
 		    && ! TEST_HARD_REG_BIT (used, j)
@@ -1128,8 +1128,8 @@ find_reg (num, losers, alt_regs_p, accept_call_clobbered, retrying)
 		|| reg_class_subset_p (REGNO_REG_CLASS (best_reg),
 				       REGNO_REG_CLASS (i))))
 	    {
-	      register int j;
-	      register int lim = i + HARD_REGNO_NREGS (i, mode);
+	      int j;
+	      int lim = i + HARD_REGNO_NREGS (i, mode);
 	      for (j = i + 1;
 		   (j < lim
 		    && ! TEST_HARD_REG_BIT (used, j)
@@ -1246,7 +1246,7 @@ find_reg (num, losers, alt_regs_p, accept_call_clobbered, retrying)
 
   if (best_reg >= 0)
     {
-      register int lim, j;
+      int lim, j;
       HARD_REG_SET this_reg;
 
       /* Yes.  Record it as the hard register of this pseudo-reg.  */
@@ -1322,7 +1322,7 @@ static void
 record_one_conflict (regno)
      int regno;
 {
-  register int j;
+  int j;
 
   if (regno < FIRST_PSEUDO_REGISTER)
     /* When a hard register becomes live,
@@ -1336,8 +1336,9 @@ record_one_conflict (regno)
        record conflicts first with hard regs,
        then with other pseudo regs.  */
     {
-      register int ialloc = reg_allocno[regno];
-      register int ialloc_prod = ialloc * allocno_row_words;
+      int ialloc = reg_allocno[regno];
+      int ialloc_prod = ialloc * allocno_row_words;
+
       IOR_HARD_REG_SET (allocno[ialloc].hard_reg_conflicts, hard_regs_live);
       for (j = allocno_row_words - 1; j >= 0; j--)
 	{
@@ -1363,11 +1364,11 @@ record_one_conflict (regno)
 
 static void
 record_conflicts (allocno_vec, len)
-     register int *allocno_vec;
-     register int len;
+     int *allocno_vec;
+     int len;
 {
-  register int num;
-  register int ialloc_prod;
+  int num;
+  int ialloc_prod;
 
   while (--len >= 0)
     {
@@ -1381,7 +1382,7 @@ record_conflicts (allocno_vec, len)
 static void
 mirror_conflicts ()
 {
-  register int i, j;
+  int i, j;
   int rw = allocno_row_words;
   int rwb = rw * INT_BITS;
   INT_TYPE *p = conflicts;
@@ -1431,7 +1432,7 @@ mark_reg_store (reg, setter, data)
      rtx reg, setter;
      void *data ATTRIBUTE_UNUSED;
 {
-  register int regno;
+  int regno;
 
   if (GET_CODE (reg) == SUBREG)
     reg = SUBREG_REG (reg);
@@ -1463,7 +1464,7 @@ mark_reg_store (reg, setter, data)
   /* Handle hardware regs (and pseudos allocated to hard regs).  */
   if (regno < FIRST_PSEUDO_REGISTER && ! fixed_regs[regno])
     {
-      register int last = regno + HARD_REGNO_NREGS (regno, GET_MODE (reg));
+      int last = regno + HARD_REGNO_NREGS (regno, GET_MODE (reg));
       while (regno < last)
 	{
 	  record_one_conflict (regno);
@@ -1491,7 +1492,7 @@ static void
 mark_reg_conflicts (reg)
      rtx reg;
 {
-  register int regno;
+  int regno;
 
   if (GET_CODE (reg) == SUBREG)
     reg = SUBREG_REG (reg);
@@ -1515,7 +1516,7 @@ mark_reg_conflicts (reg)
   /* Handle hardware regs (and pseudos allocated to hard regs).  */
   if (regno < FIRST_PSEUDO_REGISTER && ! fixed_regs[regno])
     {
-      register int last = regno + HARD_REGNO_NREGS (regno, GET_MODE (reg));
+      int last = regno + HARD_REGNO_NREGS (regno, GET_MODE (reg));
       while (regno < last)
 	{
 	  record_one_conflict (regno);
@@ -1531,7 +1532,7 @@ static void
 mark_reg_death (reg)
      rtx reg;
 {
-  register int regno = REGNO (reg);
+  int regno = REGNO (reg);
 
   /* Either this is one of the max_allocno pseudo regs not allocated,
      or it is a hardware reg.  First handle the pseudo-regs.  */
@@ -1550,7 +1551,7 @@ mark_reg_death (reg)
     {
       /* Pseudo regs already assigned hardware regs are treated
 	 almost the same as explicit hardware regs.  */
-      register int last = regno + HARD_REGNO_NREGS (regno, GET_MODE (reg));
+      int last = regno + HARD_REGNO_NREGS (regno, GET_MODE (reg));
       while (regno < last)
 	{
 	  CLEAR_HARD_REG_BIT (hard_regs_live, regno);
@@ -1566,10 +1567,10 @@ mark_reg_death (reg)
 
 static void
 mark_reg_live_nc (regno, mode)
-     register int regno;
+     int regno;
      enum machine_mode mode;
 {
-  register int last = regno + HARD_REGNO_NREGS (regno, mode);
+  int last = regno + HARD_REGNO_NREGS (regno, mode);
   while (regno < last)
     {
       SET_HARD_REG_BIT (hard_regs_live, regno);
@@ -1702,7 +1703,7 @@ mark_elimination (from, to)
 
   for (i = 0; i < n_basic_blocks; i++)
     {
-      register regset r = BASIC_BLOCK (i)->global_live_at_start; 
+      regset r = BASIC_BLOCK (i)->global_live_at_start; 
       if (REGNO_REG_SET_P (r, from))
 	{
 	  CLEAR_REGNO_REG_SET (r, from);
@@ -1888,9 +1889,9 @@ static void
 dump_conflicts (file)
      FILE *file;
 {
-  register int i;
-  register int has_preferences;
-  register int nregs;
+  int i;
+  int has_preferences;
+  int nregs;
   nregs = 0;
   for (i = 0; i < max_allocno; i++)
     {
@@ -1916,7 +1917,7 @@ dump_conflicts (file)
 
   for (i = 0; i < max_allocno; i++)
     {
-      register int j;
+      int j;
       fprintf (file, ";; %d conflicts:", allocno[i].reg);
       for (j = 0; j < max_allocno; j++)
 	if (CONFLICTP (j, i))
@@ -1946,7 +1947,7 @@ void
 dump_global_regs (file)
      FILE *file;
 {
-  register int i, j;
+  int i, j;
   
   fprintf (file, ";; Register dispositions:\n");
   for (i = FIRST_PSEUDO_REGISTER, j = 0; i < max_regno; i++)
diff --git a/gcc/gmon.c b/gcc/gmon.c
index df9cfab2a1e..aa4fd166ea1 100644
--- a/gcc/gmon.c
+++ b/gcc/gmon.c
@@ -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
diff --git a/gcc/graph.c b/gcc/graph.c
index 355816edd59..87230479bb4 100644
--- a/gcc/graph.c
+++ b/gcc/graph.c
@@ -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;
diff --git a/gcc/haifa-sched.c b/gcc/haifa-sched.c
index fe4153d2b3e..90c75460609 100644
--- a/gcc/haifa-sched.c
+++ b/gcc/haifa-sched.c
@@ -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++)
 	{
diff --git a/gcc/hard-reg-set.h b/gcc/hard-reg-set.h
index dd080364878..a4ac4d02634 100644
--- a/gcc/hard-reg-set.h
+++ b/gcc/hard-reg-set.h
@@ -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)
diff --git a/gcc/hash.c b/gcc/hash.c
index 1cf6b685c64..5cf8397692d 100644
--- a/gcc/hash.c
+++ b/gcc/hash.c
@@ -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;
   
diff --git a/gcc/integrate.c b/gcc/integrate.c
index b4aee8383af..1cbeca06081 100644
--- a/gcc/integrate.c
+++ b/gcc/integrate.c
@@ -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;
diff --git a/gcc/jump.c b/gcc/jump.c
index 544b67267c8..c5a10b0a9be 100644
--- a/gcc/jump.c
+++ b/gcc/jump.c
@@ -78,7 +78,7 @@ void
 rebuild_jump_labels (f)
      rtx f;
 {
-  register rtx insn;
+  rtx insn;
   int max_uid = 0;
 
   max_uid = init_label_info (f) + 1;
@@ -131,7 +131,7 @@ void
 copy_loop_headers (f)
      rtx f;
 {
-  register rtx insn, next;
+  rtx insn, next;
   /* Now iterate optimizing jumps until nothing changes over one pass.  */
   for (insn = f; insn; insn = next)
     {
@@ -1094,7 +1094,7 @@ int
 condjump_p (insn)
      rtx insn;
 {
-  register rtx x = PATTERN (insn);
+  rtx x = PATTERN (insn);
 
   if (GET_CODE (x) != SET
       || GET_CODE (SET_DEST (x)) != PC)
@@ -1125,7 +1125,7 @@ int
 condjump_in_parallel_p (insn)
      rtx insn;
 {
-  register rtx x = PATTERN (insn);
+  rtx x = PATTERN (insn);
 
   if (GET_CODE (x) != PARALLEL)
     return 0;
@@ -1347,10 +1347,10 @@ rtx
 follow_jumps (label)
      rtx label;
 {
-  register rtx insn;
-  register rtx next;
-  register rtx value = label;
-  register int depth;
+  rtx insn;
+  rtx next;
+  rtx value = label;
+  int depth;
 
   for (depth = 0;
        (depth < 10
@@ -1409,13 +1409,13 @@ follow_jumps (label)
 
 void
 mark_jump_label (x, insn, in_mem)
-     register rtx x;
+     rtx x;
      rtx insn;
      int in_mem;
 {
-  register RTX_CODE code = GET_CODE (x);
-  register int i;
-  register const char *fmt;
+  RTX_CODE code = GET_CODE (x);
+  int i;
+  const char *fmt;
 
   switch (code)
     {
@@ -1505,7 +1505,7 @@ mark_jump_label (x, insn, in_mem)
 	mark_jump_label (XEXP (x, i), insn, in_mem);
       else if (fmt[i] == 'E')
 	{
-	  register int j;
+	  int j;
 	  for (j = 0; j < XVECLEN (x, i); j++)
 	    mark_jump_label (XVECEXP (x, i, j), insn, in_mem);
 	}
@@ -1520,7 +1520,7 @@ void
 delete_jump (insn)
      rtx insn;
 {
-  register rtx set = single_set (insn);
+  rtx set = single_set (insn);
 
   if (set && GET_CODE (SET_DEST (set)) == PC)
     delete_computation (insn);
@@ -1723,9 +1723,9 @@ delete_computation (insn)
 
 rtx
 delete_related_insns (insn)
-     register rtx insn;
+     rtx insn;
 {
-  register int was_code_label = (GET_CODE (insn) == CODE_LABEL);
+  int was_code_label = (GET_CODE (insn) == CODE_LABEL);
   rtx note;
   rtx next = NEXT_INSN (insn), prev = PREV_INSN (insn);
 
@@ -1824,7 +1824,7 @@ delete_related_insns (insn)
 
   if (was_code_label && prev && GET_CODE (prev) == BARRIER)
     {
-      register RTX_CODE code;
+      RTX_CODE code;
       while (next != 0
 	     && (GET_RTX_CLASS (code = GET_CODE (next)) == 'i'
 		 || code == NOTE || code == BARRIER
@@ -1867,14 +1867,14 @@ next_nondeleted_insn (insn)
 
 void
 delete_for_peephole (from, to)
-     register rtx from, to;
+     rtx from, to;
 {
-  register rtx insn = from;
+  rtx insn = from;
 
   while (1)
     {
-      register rtx next = NEXT_INSN (insn);
-      register rtx prev = PREV_INSN (insn);
+      rtx next = NEXT_INSN (insn);
+      rtx prev = PREV_INSN (insn);
 
       if (GET_CODE (insn) != NOTE)
 	{
@@ -1956,10 +1956,10 @@ redirect_exp_1 (loc, olabel, nlabel, insn)
      rtx olabel, nlabel;
      rtx insn;
 {
-  register rtx x = *loc;
-  register RTX_CODE code = GET_CODE (x);
-  register int i;
-  register const char *fmt;
+  rtx x = *loc;
+  RTX_CODE code = GET_CODE (x);
+  int i;
+  const char *fmt;
 
   if (code == LABEL_REF)
     {
@@ -1999,7 +1999,7 @@ redirect_exp_1 (loc, olabel, nlabel, insn)
 	redirect_exp_1 (&XEXP (x, i), olabel, nlabel, insn);
       else if (fmt[i] == 'E')
 	{
-	  register int j;
+	  int j;
 	  for (j = 0; j < XVECLEN (x, i); j++)
 	    redirect_exp_1 (&XVECEXP (x, i, j), olabel, nlabel, insn);
 	}
@@ -2062,7 +2062,7 @@ redirect_jump (jump, nlabel, delete_unused)
      rtx jump, nlabel;
      int delete_unused;
 {
-  register rtx olabel = JUMP_LABEL (jump);
+  rtx olabel = JUMP_LABEL (jump);
 
   if (nlabel == olabel)
     return 1;
@@ -2095,7 +2095,7 @@ static void
 invert_exp_1 (insn)
      rtx insn;
 {
-  register RTX_CODE code;
+  RTX_CODE code;
   rtx x = pc_set (insn);
 
   if (!x)
@@ -2106,8 +2106,8 @@ invert_exp_1 (insn)
 
   if (code == IF_THEN_ELSE)
     {
-      register rtx comp = XEXP (x, 0);
-      register rtx tem;
+      rtx comp = XEXP (x, 0);
+      rtx tem;
       enum rtx_code reversed_code;
 
       /* We can do this in two ways:  The preferable way, which can only
@@ -2218,9 +2218,9 @@ int
 rtx_renumbered_equal_p (x, y)
      rtx x, y;
 {
-  register int i;
-  register RTX_CODE code = GET_CODE (x);
-  register const char *fmt;
+  int i;
+  RTX_CODE code = GET_CODE (x);
+  const char *fmt;
 
   if (x == y)
     return 1;
@@ -2349,7 +2349,7 @@ rtx_renumbered_equal_p (x, y)
   fmt = GET_RTX_FORMAT (code);
   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
     {
-      register int j;
+      int j;
       switch (fmt[i])
 	{
 	case 'w':
@@ -2716,10 +2716,10 @@ rtx_equal_for_thread_p (x, y, yinsn)
      rtx x, y;
      rtx yinsn;
 {
-  register int i;
-  register int j;
-  register enum rtx_code code;
-  register const char *fmt;
+  int i;
+  int j;
+  enum rtx_code code;
+  const char *fmt;
 
   code = GET_CODE (x);
   /* Rtx's of different codes cannot be equal.  */
diff --git a/gcc/lists.c b/gcc/lists.c
index 2a58ea2e163..0adacfb5162 100644
--- a/gcc/lists.c
+++ b/gcc/lists.c
@@ -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);
diff --git a/gcc/local-alloc.c b/gcc/local-alloc.c
index 6bc017586c4..2637b7e78a1 100644
--- a/gcc/local-alloc.c
+++ b/gcc/local-alloc.c
@@ -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]);
diff --git a/gcc/loop.c b/gcc/loop.c
index ec465c7b6c5..c81a2c645a2 100644
--- a/gcc/loop.c
+++ b/gcc/loop.c
@@ -356,8 +356,8 @@ loop_optimize (f, dumpfile, flags)
      FILE *dumpfile;
      int flags;
 {
-  register rtx insn;
-  register int i;
+  rtx insn;
+  int i;
   struct loops loops_data;
   struct loops *loops = &loops_data;
   struct loop_info *loops_info;
@@ -522,7 +522,7 @@ scan_loop (loop, flags)
 {
   struct loop_info *loop_info = LOOP_INFO (loop);
   struct loop_regs *regs = LOOP_REGS (loop);
-  register int i;
+  int i;
   rtx loop_start = loop->start;
   rtx loop_end = loop->end;
   rtx p;
@@ -761,8 +761,8 @@ scan_loop (loop, flags)
 		   && ! ((maybe_never || call_passed)
 			 && may_trap_p (src)))
 	    {
-	      register struct movable *m;
-	      register int regno = REGNO (SET_DEST (set));
+	      struct movable *m;
+	      int regno = REGNO (SET_DEST (set));
 
 	      /* A potential lossage is where we have a case where two insns
 		 can be combined as long as they are both in the loop, but
@@ -892,10 +892,10 @@ scan_loop (loop, flags)
 		       == SET_DEST (set))
 		   && !reg_mentioned_p (SET_DEST (set), SET_SRC (set1)))
 	    {
-	      register int regno = REGNO (SET_DEST (set));
+	      int regno = REGNO (SET_DEST (set));
 	      if (regs->array[regno].set_in_loop == 2)
 		{
-		  register struct movable *m;
+		  struct movable *m;
 		  m = (struct movable *) xmalloc (sizeof (struct movable));
 		  m->next = 0;
 		  m->insn = p;
@@ -1252,7 +1252,7 @@ static void
 ignore_some_movables (movables)
      struct loop_movables *movables;
 {
-  register struct movable *m, *m1;
+  struct movable *m, *m1;
 
   for (m = movables->head; m; m = m->next)
     {
@@ -1284,7 +1284,8 @@ static void
 force_movables (movables)
      struct loop_movables *movables;
 {
-  register struct movable *m, *m1;
+  struct movable *m, *m1;
+
   for (m1 = movables->head; m1; m1 = m1->next)
     /* Omit this if moving just the (SET (REG) 0) of a zero-extend.  */
     if (!m1->partial && !m1->done)
@@ -1324,7 +1325,7 @@ combine_movables (movables, regs)
      struct loop_movables *movables;
      struct loop_regs *regs;
 {
-  register struct movable *m;
+  struct movable *m;
   char *matched_regs = (char *) xmalloc (regs->num);
   enum machine_mode mode;
 
@@ -1336,7 +1337,7 @@ combine_movables (movables, regs)
     if (m->match == 0 && regs->array[m->regno].n_times_set == 1
 	&& !m->partial)
       {
-	register struct movable *m1;
+	struct movable *m1;
 	int regno = m->regno;
 
 	memset (matched_regs, 0, regs->num);
@@ -1389,7 +1390,7 @@ combine_movables (movables, regs)
   for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
        mode = GET_MODE_WIDER_MODE (mode))
     {
-      register struct movable *m0 = 0;
+      struct movable *m0 = 0;
 
       /* Combine all the registers for extension from mode MODE.
 	 Don't combine any that are used outside this loop.  */
@@ -1397,7 +1398,8 @@ combine_movables (movables, regs)
 	if (m->partial && ! m->global
 	    && mode == GET_MODE (SET_SRC (PATTERN (NEXT_INSN (m->insn)))))
 	  {
-	    register struct movable *m1;
+	    struct movable *m1;
+
 	    int first = REGNO_FIRST_LUID (m->regno);
 	    int last = REGNO_LAST_LUID (m->regno);
 
@@ -1491,11 +1493,11 @@ rtx_equal_for_loop_p (x, y, movables, regs)
      struct loop_movables *movables;
      struct loop_regs *regs;
 {
-  register int i;
-  register int j;
-  register struct movable *m;
-  register enum rtx_code code;
-  register const char *fmt;
+  int i;
+  int j;
+  struct movable *m;
+  enum rtx_code code;
+  const char *fmt;
 
   if (x == y)
     return 1;
@@ -1656,8 +1658,8 @@ move_movables (loop, movables, threshold, insn_count)
   struct loop_regs *regs = LOOP_REGS (loop);
   int nregs = regs->num;
   rtx new_start = 0;
-  register struct movable *m;
-  register rtx p;
+  struct movable *m;
+  rtx p;
   rtx loop_start = loop->start;
   rtx loop_end = loop->end;
   /* Map of pseudo-register replacements to handle combining
@@ -1708,8 +1710,8 @@ move_movables (loop, movables, threshold, insn_count)
 						       m->insn))))
 	  && (! m->forces || m->forces->done))
 	{
-	  register int regno;
-	  register rtx p;
+	  int regno;
+	  rtx p;
 	  int savings = m->savings;
 
 	  /* We have an insn that is safe to move.
@@ -1745,7 +1747,7 @@ move_movables (loop, movables, threshold, insn_count)
 		  && regs->array[m->forces->regno].n_times_set == 1))
 	    {
 	      int count;
-	      register struct movable *m1;
+	      struct movable *m1;
 	      rtx first = NULL_RTX;
 
 	      /* Now move the insns that set the reg.  */
@@ -2185,9 +2187,9 @@ static void
 replace_call_address (x, reg, addr)
      rtx x, reg, addr;
 {
-  register enum rtx_code code;
-  register int i;
-  register const char *fmt;
+  enum rtx_code code;
+  int i;
+  const char *fmt;
 
   if (x == 0)
     return;
@@ -2233,7 +2235,7 @@ replace_call_address (x, reg, addr)
 	replace_call_address (XEXP (x, i), reg, addr);
       else if (fmt[i] == 'E')
 	{
-	  register int j;
+	  int j;
 	  for (j = 0; j < XVECLEN (x, i); j++)
 	    replace_call_address (XVECEXP (x, i, j), reg, addr);
 	}
@@ -2249,9 +2251,9 @@ count_nonfixed_reads (loop, x)
      const struct loop *loop;
      rtx x;
 {
-  register enum rtx_code code;
-  register int i;
-  register const char *fmt;
+  enum rtx_code code;
+  int i;
+  const char *fmt;
   int value;
 
   if (x == 0)
@@ -2286,7 +2288,7 @@ count_nonfixed_reads (loop, x)
 	value += count_nonfixed_reads (loop, XEXP (x, i));
       if (fmt[i] == 'E')
 	{
-	  register int j;
+	  int j;
 	  for (j = 0; j < XVECLEN (x, i); j++)
 	    value += count_nonfixed_reads (loop, XVECEXP (x, i, j));
 	}
@@ -2304,7 +2306,7 @@ static void
 prescan_loop (loop)
      struct loop *loop;
 {
-  register int level = 1;
+  int level = 1;
   rtx insn;
   struct loop_info *loop_info = LOOP_INFO (loop);
   rtx start = loop->start;
@@ -3058,13 +3060,13 @@ note_set_pseudo_multiple_uses (x, y, data)
 int
 loop_invariant_p (loop, x)
      const struct loop *loop;
-     register rtx x;
+     rtx x;
 {
   struct loop_info *loop_info = LOOP_INFO (loop);
   struct loop_regs *regs = LOOP_REGS (loop);
-  register int i;
-  register enum rtx_code code;
-  register const char *fmt;
+  int i;
+  enum rtx_code code;
+  const char *fmt;
   int conditional = 0;
   rtx mem_list_entry;
 
@@ -3162,7 +3164,7 @@ loop_invariant_p (loop, x)
 	}
       else if (fmt[i] == 'E')
 	{
-	  register int j;
+	  int j;
 	  for (j = 0; j < XVECLEN (x, i); j++)
 	    {
 	      int tem = loop_invariant_p (loop, XVECEXP (x, i, j));
@@ -3212,7 +3214,7 @@ consec_sets_invariant_p (loop, reg, n_sets, insn)
 
   while (count > 0)
     {
-      register enum rtx_code code;
+      enum rtx_code code;
       rtx set;
 
       p = NEXT_INSN (p);
@@ -3269,12 +3271,12 @@ all_sets_invariant_p (reg, insn, table)
      rtx reg, insn;
      short *table;
 {
-  register rtx p = insn;
-  register int regno = REGNO (reg);
+  rtx p = insn;
+  int regno = REGNO (reg);
 
   while (1)
     {
-      register enum rtx_code code;
+      enum rtx_code code;
       p = NEXT_INSN (p);
       code = GET_CODE (p);
       if (code == CODE_LABEL || code == JUMP_INSN)
@@ -3356,7 +3358,7 @@ count_one_set (regs, insn, x, last_set)
 	dest = XEXP (dest, 0);
       if (GET_CODE (dest) == REG)
 	{
-	  register int regno = REGNO (dest);
+	  int regno = REGNO (dest);
 	  /* If this is the first setting of this reg
 	     in current basic block, and it was set before,
 	     it must be set in two basic blocks, so it cannot
@@ -4722,9 +4724,9 @@ find_mem_givs (loop, x, insn, not_every_iteration, maybe_multiple)
      rtx insn;
      int not_every_iteration, maybe_multiple;
 {
-  register int i, j;
-  register enum rtx_code code;
-  register const char *fmt;
+  int i, j;
+  enum rtx_code code;
+  const char *fmt;
 
   if (x == 0)
     return;
@@ -5396,7 +5398,7 @@ update_giv_derive (loop, p)
 static int
 basic_induction_var (loop, x, mode, dest_reg, p, inc_val, mult_val, location)
      const struct loop *loop;
-     register rtx x;
+     rtx x;
      enum machine_mode mode;
      rtx dest_reg;
      rtx p;
@@ -5404,7 +5406,7 @@ basic_induction_var (loop, x, mode, dest_reg, p, inc_val, mult_val, location)
      rtx *mult_val;
      rtx **location;
 {
-  register enum rtx_code code;
+  enum rtx_code code;
   rtx *argp, arg;
   rtx insn, set = 0;
 
@@ -8311,8 +8313,8 @@ update_reg_last_use (x, insn)
     }
   else
     {
-      register int i, j;
-      register const char *fmt = GET_RTX_FORMAT (GET_CODE (x));
+      int i, j;
+      const char *fmt = GET_RTX_FORMAT (GET_CODE (x));
       for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
 	{
 	  if (fmt[i] == 'e')
@@ -8808,7 +8810,7 @@ loop_regs_scan (loop, extra_size)
 	    count_one_set (regs, insn, PATTERN (insn), last_set);
 	  else if (GET_CODE (PATTERN (insn)) == PARALLEL)
 	    {
-	      register int i;
+	      int i;
 	      for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
 		count_one_set (regs, insn, XVECEXP (PATTERN (insn), 0, i),
 			       last_set);
diff --git a/gcc/mips-tdump.c b/gcc/mips-tdump.c
index e133c0f8ac0..32f2bc23310 100644
--- a/gcc/mips-tdump.c
+++ b/gcc/mips-tdump.c
@@ -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)
 	  {
diff --git a/gcc/mips-tfile.c b/gcc/mips-tfile.c
index bc191db5576..ca03f263729 100644
--- a/gcc/mips-tfile.c
+++ b/gcc/mips-tfile.c
@@ -1778,10 +1778,10 @@ hash_string (text, hash_len, hash_tbl, ret_hash_index)
      shash_t **hash_tbl;		/* hash table */
      symint_t *ret_hash_index;		/* ptr to store hash index */
 {
-  register unsigned long hi;
-  register Ptrdiff_t i;
-  register shash_t *ptr;
-  register int first_ch = *text;
+  unsigned long hi;
+  Ptrdiff_t i;
+  shash_t *ptr;
+  int first_ch = *text;
 
   hi = hash_len;
   for (i = 0; i < hash_len; i++)
@@ -1815,8 +1815,8 @@ add_string (vp, hash_tbl, start, end_p1, ret_hash)
      const char *end_p1;		/* 1st byte after string */
      shash_t **ret_hash;		/* return hash pointer */
 {
-  register Ptrdiff_t len = end_p1 - start;
-  register shash_t *hash_ptr;
+  Ptrdiff_t len = end_p1 - start;
+  shash_t *hash_ptr;
   symint_t hi;
 
   if (len >= (Ptrdiff_t) PAGE_USIZE)
@@ -1825,7 +1825,7 @@ add_string (vp, hash_tbl, start, end_p1, ret_hash)
   hash_ptr = hash_string (start, len, hash_tbl, &hi);
   if (hash_ptr == (shash_t *) 0)
     {
-      register char *p;
+      char *p;
 
       if (vp->objects_last_page + len >= (long) PAGE_USIZE)
 	{
@@ -1869,14 +1869,14 @@ add_local_symbol (str_start, str_end_p1, type, storage, value, indx)
      symint_t value;			/* value of symbol */
      symint_t indx;			/* index to local/aux. syms */
 {
-  register symint_t ret;
-  register SYMR *psym;
-  register scope_t *pscope;
-  register thead_t *ptag_head;
-  register tag_t *ptag;
-  register tag_t *ptag_next;
-  register varray_t *vp = &cur_file_ptr->symbols;
-  register int scope_delta = 0;
+  symint_t ret;
+  SYMR *psym;
+  scope_t *pscope;
+  thead_t *ptag_head;
+  tag_t *ptag;
+  tag_t *ptag_next;
+  varray_t *vp = &cur_file_ptr->symbols;
+  int scope_delta = 0;
   shash_t *hash_ptr = (shash_t *) 0;
 
   if (vp->objects_last_page == vp->objects_per_page)
@@ -2045,8 +2045,8 @@ add_ext_symbol (esym, ifd)
 {
   const char *str_start;		/* first byte in string */
   const char *str_end_p1;		/* first byte after string */
-  register EXTR *psym;
-  register varray_t *vp = &ext_symbols;
+  EXTR *psym;
+  varray_t *vp = &ext_symbols;
   shash_t *hash_ptr = (shash_t *) 0;
 
   str_start = ORIG_ESTRS (esym->asym.iss);
@@ -2096,9 +2096,9 @@ STATIC symint_t
 add_aux_sym_symint (aux_word)
      symint_t aux_word;		/* auxiliary information word */
 {
-  register AUXU *aux_ptr;
-  register efdr_t *file_ptr = cur_file_ptr;
-  register varray_t *vp = &file_ptr->aux_syms;
+  AUXU *aux_ptr;
+  efdr_t *file_ptr = cur_file_ptr;
+  varray_t *vp = &file_ptr->aux_syms;
 
   if (vp->objects_last_page == vp->objects_per_page)
     add_varray_page (vp);
@@ -2117,9 +2117,9 @@ add_aux_sym_rndx (file_index, sym_index)
      int file_index;
      symint_t sym_index;
 {
-  register AUXU *aux_ptr;
-  register efdr_t *file_ptr = cur_file_ptr;
-  register varray_t *vp = &file_ptr->aux_syms;
+  AUXU *aux_ptr;
+  efdr_t *file_ptr = cur_file_ptr;
+  varray_t *vp = &file_ptr->aux_syms;
 
   if (vp->objects_last_page == vp->objects_per_page)
     add_varray_page (vp);
@@ -2141,9 +2141,9 @@ add_aux_sym_tir (t, state, hash_tbl)
      hash_state_t state;	/* whether to hash type or not */
      thash_t **hash_tbl;	/* pointer to hash table to use */
 {
-  register AUXU *aux_ptr;
-  register efdr_t *file_ptr = cur_file_ptr;
-  register varray_t *vp = &file_ptr->aux_syms;
+  AUXU *aux_ptr;
+  efdr_t *file_ptr = cur_file_ptr;
+  varray_t *vp = &file_ptr->aux_syms;
   static AUXU init_aux;
   symint_t ret;
   int i;
@@ -2186,8 +2186,8 @@ add_aux_sym_tir (t, state, hash_tbl)
 
   if (state != hash_no)
     {
-      register thash_t *hash_ptr;
-      register symint_t hi;
+      thash_t *hash_ptr;
+      symint_t hi;
 
       hi = aux.isym & ((1 << HASHBITS) - 1);
       hi %= THASH_SIZE;
@@ -2243,8 +2243,8 @@ add_aux_sym_tir (t, state, hash_tbl)
       || t->basic_type == bt_Union
       || t->basic_type == bt_Enum)
     {
-      register symint_t file_index = t->tag_ptr->ifd;
-      register symint_t sym_index  = t->tag_ptr->indx;
+      symint_t file_index = t->tag_ptr->ifd;
+      symint_t sym_index  = t->tag_ptr->indx;
 
       if (t->unknown_tag)
 	{
@@ -2258,7 +2258,7 @@ add_aux_sym_tir (t, state, hash_tbl)
 	}
       else
 	{
-	  register forward_t *forward_ref = allocate_forward ();
+	  forward_t *forward_ref = allocate_forward ();
 
 	  forward_ref->type_ptr = aux_ptr;
 	  forward_ref->next = t->tag_ptr->forward_ref;
@@ -2414,15 +2414,15 @@ add_procedure (func_start, func_end_p1)
      const char *func_start;		/* 1st byte of func name */
      const char *func_end_p1;		/* 1st byte after func name */
 {
-  register PDR *new_proc_ptr;
-  register efdr_t *file_ptr = cur_file_ptr;
-  register varray_t *vp = &file_ptr->procs;
-  register symint_t value = 0;
-  register st_t proc_type = st_Proc;
-  register shash_t *shash_ptr = hash_string (func_start,
-					    func_end_p1 - func_start,
-					    &orig_str_hash[0],
-					    (symint_t *) 0);
+  PDR *new_proc_ptr;
+  efdr_t *file_ptr = cur_file_ptr;
+  varray_t *vp = &file_ptr->procs;
+  symint_t value = 0;
+  st_t proc_type = st_Proc;
+  shash_t *shash_ptr = hash_string (func_start,
+				    func_end_p1 - func_start,
+				    &orig_str_hash[0],
+				    (symint_t *) 0);
 
   if (debug)
     fputc ('\n', stderr);
@@ -2439,8 +2439,8 @@ add_procedure (func_start, func_end_p1)
   cur_oproc_ptr = (PDR *) 0;
   if (shash_ptr != (shash_t *) 0)
     {
-      register PDR *old_proc_ptr = shash_ptr->proc_ptr;
-      register SYMR *sym_ptr = shash_ptr->sym_ptr;
+      PDR *old_proc_ptr = shash_ptr->proc_ptr;
+      SYMR *sym_ptr = shash_ptr->sym_ptr;
 
       if (old_proc_ptr != (PDR *) 0
 	  && sym_ptr != (SYMR *) 0
@@ -2482,9 +2482,9 @@ add_file (file_start, file_end_p1)
 {
   static char zero_bytes[2] = { '\0', '\0' };
 
-  register Ptrdiff_t len = file_end_p1 - file_start;
-  register int first_ch = *file_start;
-  register efdr_t *file_ptr;
+  Ptrdiff_t len = file_end_p1 - file_start;
+  int first_ch = *file_start;
+  efdr_t *file_ptr;
 
   if (debug)
     fprintf (stderr, "\tfile\t%.*s\n", (int) len, file_start);
@@ -2561,9 +2561,9 @@ add_bytes (vp, input_ptr, nitems)
      char *input_ptr;			/* start of the bytes */
      Size_t nitems;			/* # items to move */
 {
-  register Size_t move_items;
-  register Size_t move_bytes;
-  register char *ptr;
+  Size_t move_items;
+  Size_t move_bytes;
+  char *ptr;
 
   while (nitems > 0)
     {
@@ -2673,10 +2673,10 @@ STATIC char *
 read_line ()
 {
   static   int line_split_p	= 0;
-  register int string_p		= 0;
-  register int comment_p	= 0;
-  register int ch;
-  register char *ptr;
+  int string_p		= 0;
+  int comment_p	= 0;
+  int ch;
+  char *ptr;
 
   if (cur_line_start == (char *) 0)
     {				/* allocate initial page */
@@ -2694,8 +2694,8 @@ read_line ()
     {
       if (++cur_line_nbytes >= cur_line_alloc-1)
 	{
-	  register int num_pages = cur_line_alloc / PAGE_SIZE;
-	  register char *old_buffer = cur_line_start;
+	  int num_pages = cur_line_alloc / PAGE_SIZE;
+	  char *old_buffer = cur_line_start;
 
 	  cur_line_alloc += PAGE_SIZE;
 	  cur_line_start = (char *) allocate_multiple_pages (num_pages+1);
@@ -3435,10 +3435,10 @@ STATIC void
 parse_end (start)
      const char *start;			/* start of directive */
 {
-  register const char *start_func, *end_func_p1;
-  register int ch;
-  register symint_t value;
-  register FDR *orig_fdr;
+  const char *start_func, *end_func_p1;
+  int ch;
+  symint_t value;
+  FDR *orig_fdr;
 
   if (cur_file_ptr == (efdr_t *) 0)
     {
@@ -3498,8 +3498,8 @@ STATIC void
 parse_ent (start)
      const char *start;			/* start of directive */
 {
-  register const char *start_func, *end_func_p1;
-  register int ch;
+  const char *start_func, *end_func_p1;
+  int ch;
 
   if (cur_file_ptr == (efdr_t *) 0)
     {
@@ -3537,7 +3537,7 @@ parse_file (start)
      const char *start;			/* start of directive */
 {
   char *p;
-  register char *start_name, *end_name_p1;
+  char *start_name, *end_name_p1;
 
   (void) strtol (start, &p, 0);
   if (start == p
@@ -3834,11 +3834,11 @@ parse_stabn (start)
 STATIC void
 parse_input ()
 {
-  register char *p;
-  register Size_t i;
-  register thead_t *ptag_head;
-  register tag_t *ptag;
-  register tag_t *ptag_next;
+  char *p;
+  Size_t i;
+  thead_t *ptag_head;
+  tag_t *ptag;
+  tag_t *ptag_next;
 
   if (debug)
     fprintf (stderr, "\tinput\n");
@@ -3897,8 +3897,8 @@ parse_input ()
 STATIC void
 update_headers ()
 {
-  register symint_t i;
-  register efdr_t *file_ptr;
+  symint_t i;
+  efdr_t *file_ptr;
 
   /* Set up the symbolic header.  */
   file_offset = sizeof (symbolic_header) + orig_file_header.f_symptr;
@@ -3924,10 +3924,10 @@ update_headers ()
        file_ptr != (efdr_t *) 0;
        file_ptr = file_ptr->next_file)
     {
-      register SYMR *sym_start;
-      register SYMR *sym;
-      register SYMR *sym_end_p1;
-      register FDR *fd_ptr = file_ptr->orig_fdr;
+      SYMR *sym_start;
+      SYMR *sym;
+      SYMR *sym_end_p1;
+      FDR *fd_ptr = file_ptr->orig_fdr;
 
       cur_file_ptr = file_ptr;
 
@@ -3941,9 +3941,9 @@ update_headers ()
 	{
 	  if ((st_t)sym->st == st_Static)
 	    {
-	      register char *str = ORIG_LSTRS (fd_ptr->issBase + sym->iss);
-	      register Size_t len = strlen (str);
-	      register shash_t *hash_ptr;
+	      char *str = ORIG_LSTRS (fd_ptr->issBase + sym->iss);
+	      Size_t len = strlen (str);
+	      shash_t *hash_ptr;
 
 	      /* Ignore internal labels.  */
 	      if (str[0] == '$' && str[1] == 'L')
@@ -4440,13 +4440,13 @@ STATIC void
 copy_object ()
 {
   char buffer[ PAGE_SIZE ];
-  register int sys_read;
-  register int remaining;
-  register int num_write;
-  register int sys_write;
-  register int fd, es;
-  register int delete_ifd = 0;
-  register int *remap_file_number;
+  int sys_read;
+  int remaining;
+  int num_write;
+  int sys_write;
+  int fd, es;
+  int delete_ifd = 0;
+  int *remap_file_number;
   struct stat stat_buf;
 
   if (debug)
@@ -4597,8 +4597,8 @@ copy_object ()
 
   for (fd = delete_ifd; fd < orig_sym_hdr.ifdMax; fd++)
     {
-      register FDR *fd_ptr = ORIG_FILES (fd);
-      register char *filename = ORIG_LSTRS (fd_ptr->issBase + fd_ptr->rss);
+      FDR *fd_ptr = ORIG_FILES (fd);
+      char *filename = ORIG_LSTRS (fd_ptr->issBase + fd_ptr->rss);
 
       /* file support itself.  */
       add_file (filename, filename + strlen (filename));
@@ -4622,8 +4622,8 @@ copy_object ()
 
   for (es = 0; es < orig_sym_hdr.iextMax; es++)
     {
-      register EXTR *eptr = orig_ext_syms + es;
-      register unsigned ifd = eptr->ifd;
+      EXTR *eptr = orig_ext_syms + es;
+      unsigned ifd = eptr->ifd;
 
       (void) add_ext_symbol (eptr, ((long) ifd < orig_sym_hdr.ifdMax)
 			     ? remap_file_number[ ifd ] : ifd );
@@ -4635,14 +4635,14 @@ copy_object ()
 
   for (fd = delete_ifd; fd < orig_sym_hdr.ifdMax; fd++)
     {
-      register FDR *fd_ptr = ORIG_FILES (fd);
-      register char *filename = ORIG_LSTRS (fd_ptr->issBase + fd_ptr->rss);
-      register SYMR *sym_start;
-      register SYMR *sym;
-      register SYMR *sym_end_p1;
-      register PDR *proc_start;
-      register PDR *proc;
-      register PDR *proc_end_p1;
+      FDR *fd_ptr = ORIG_FILES (fd);
+      char *filename = ORIG_LSTRS (fd_ptr->issBase + fd_ptr->rss);
+      SYMR *sym_start;
+      SYMR *sym;
+      SYMR *sym_end_p1;
+      PDR *proc_start;
+      PDR *proc;
+      PDR *proc_end_p1;
 
       /* file support itself.  */
       add_file (filename, filename + strlen (filename));
@@ -4683,12 +4683,12 @@ copy_object ()
 	    case st_StaticProc:
 	      {
 		auto symint_t hash_index;
-		register char *str = ORIG_LSTRS (fd_ptr->issBase + sym->iss);
-		register Size_t len = strlen (str);
-		register shash_t *shash_ptr = hash_string (str,
-							   (Ptrdiff_t)len,
-							   &orig_str_hash[0],
-							   &hash_index);
+		char *str = ORIG_LSTRS (fd_ptr->issBase + sym->iss);
+		Size_t len = strlen (str);
+		shash_t *shash_ptr = hash_string (str,
+						  (Ptrdiff_t)len,
+						  &orig_str_hash[0],
+						  &hash_index);
 
 		if (shash_ptr != (shash_t *) 0)
 		  error ("internal error, %s is already in original symbol table", str);
@@ -4710,15 +4710,15 @@ copy_object ()
 	    case st_End:
 	      if ((sc_t) sym->sc == sc_Text)
 		{
-		  register char *str = ORIG_LSTRS (fd_ptr->issBase + sym->iss);
+		  char *str = ORIG_LSTRS (fd_ptr->issBase + sym->iss);
 
 		  if (*str != '\0')
 		    {
-		      register Size_t len = strlen (str);
-		      register shash_t *shash_ptr = hash_string (str,
-								 (Ptrdiff_t)len,
-								 &orig_str_hash[0],
-								 (symint_t *) 0);
+		      Size_t len = strlen (str);
+		      shash_t *shash_ptr = hash_string (str,
+							(Ptrdiff_t)len,
+							&orig_str_hash[0],
+							(symint_t *) 0);
 
 		      if (shash_ptr != (shash_t *) 0)
 			shash_ptr->end_ptr = sym;
@@ -4742,13 +4742,13 @@ copy_object ()
       proc_end_p1 = proc_start + fd_ptr->cpd;
       for (proc = proc_start; proc < proc_end_p1; proc++)
 	{
-	  register SYMR *proc_sym = ORIG_LSYMS (fd_ptr->isymBase + proc->isym);
-	  register char *str = ORIG_LSTRS (fd_ptr->issBase + proc_sym->iss);
-	  register Size_t len = strlen (str);
-	  register shash_t *shash_ptr = hash_string (str,
-						     (Ptrdiff_t)len,
-						     &orig_str_hash[0],
-						     (symint_t *) 0);
+	  SYMR *proc_sym = ORIG_LSYMS (fd_ptr->isymBase + proc->isym);
+	  char *str = ORIG_LSTRS (fd_ptr->issBase + proc_sym->iss);
+	  Size_t len = strlen (str);
+	  shash_t *shash_ptr = hash_string (str,
+					    (Ptrdiff_t)len,
+					    &orig_str_hash[0],
+					    (symint_t *) 0);
 
 	  if (shash_ptr == (shash_t *) 0)
 	    error ("internal error, function %s is not in original symbol table", str);
@@ -5091,7 +5091,7 @@ STATIC page_t *
 allocate_cluster (npages)
      Size_t npages;
 {
-  register page_t *value = (page_t *) xcalloc (npages, PAGE_USIZE);
+  page_t *value = (page_t *) xcalloc (npages, PAGE_USIZE);
 
   if (debug > 3)
     fprintf (stderr, "\talloc\tnpages = %d, value = 0x%.8x\n", npages, value);
@@ -5105,7 +5105,7 @@ STATIC page_t *
 allocate_cluster (npages)
      Size_t npages;
 {
-  register page_t *ptr = (page_t *) sbrk (0);	/* current sbreak */
+  page_t *ptr = (page_t *) sbrk (0);	/* current sbreak */
   unsigned long offset = ((unsigned long) ptr) & (PAGE_SIZE - 1);
 
   if (offset != 0)			/* align to a page boundary */
@@ -5227,7 +5227,7 @@ allocate_page ()
 STATIC scope_t *
 allocate_scope ()
 {
-  register scope_t *ptr;
+  scope_t *ptr;
   static scope_t initial_scope;
 
 #ifndef MALLOC_CHECK
@@ -5237,8 +5237,8 @@ allocate_scope ()
 
   else
     {
-      register int unallocated	= alloc_counts[ (int)alloc_type_scope ].unallocated;
-      register page_t *cur_page	= alloc_counts[ (int)alloc_type_scope ].cur_page;
+      int unallocated	= alloc_counts[ (int)alloc_type_scope ].unallocated;
+      page_t *cur_page	= alloc_counts[ (int)alloc_type_scope ].cur_page;
 
       if (unallocated == 0)
 	{
@@ -5285,12 +5285,12 @@ free_scope (ptr)
 STATIC vlinks_t *
 allocate_vlinks ()
 {
-  register vlinks_t *ptr;
+  vlinks_t *ptr;
   static vlinks_t initial_vlinks;
 
 #ifndef MALLOC_CHECK
-  register int unallocated	= alloc_counts[ (int)alloc_type_vlinks ].unallocated;
-  register page_t *cur_page	= alloc_counts[ (int)alloc_type_vlinks ].cur_page;
+  int unallocated	= alloc_counts[ (int)alloc_type_vlinks ].unallocated;
+  page_t *cur_page	= alloc_counts[ (int)alloc_type_vlinks ].cur_page;
 
   if (unallocated == 0)
     {
@@ -5318,12 +5318,12 @@ allocate_vlinks ()
 STATIC shash_t *
 allocate_shash ()
 {
-  register shash_t *ptr;
+  shash_t *ptr;
   static shash_t initial_shash;
 
 #ifndef MALLOC_CHECK
-  register int unallocated	= alloc_counts[ (int)alloc_type_shash ].unallocated;
-  register page_t *cur_page	= alloc_counts[ (int)alloc_type_shash ].cur_page;
+  int unallocated	= alloc_counts[ (int)alloc_type_shash ].unallocated;
+  page_t *cur_page	= alloc_counts[ (int)alloc_type_shash ].cur_page;
 
   if (unallocated == 0)
     {
@@ -5351,12 +5351,12 @@ allocate_shash ()
 STATIC thash_t *
 allocate_thash ()
 {
-  register thash_t *ptr;
+  thash_t *ptr;
   static thash_t initial_thash;
 
 #ifndef MALLOC_CHECK
-  register int unallocated	= alloc_counts[ (int)alloc_type_thash ].unallocated;
-  register page_t *cur_page	= alloc_counts[ (int)alloc_type_thash ].cur_page;
+  int unallocated	= alloc_counts[ (int)alloc_type_thash ].unallocated;
+  page_t *cur_page	= alloc_counts[ (int)alloc_type_thash ].cur_page;
 
   if (unallocated == 0)
     {
@@ -5384,7 +5384,7 @@ allocate_thash ()
 STATIC tag_t *
 allocate_tag ()
 {
-  register tag_t *ptr;
+  tag_t *ptr;
   static tag_t initial_tag;
 
 #ifndef MALLOC_CHECK
@@ -5394,8 +5394,8 @@ allocate_tag ()
 
   else
     {
-      register int unallocated	= alloc_counts[ (int)alloc_type_tag ].unallocated;
-      register page_t *cur_page	= alloc_counts[ (int)alloc_type_tag ].cur_page;
+      int unallocated	= alloc_counts[ (int)alloc_type_tag ].unallocated;
+      page_t *cur_page	= alloc_counts[ (int)alloc_type_tag ].cur_page;
 
       if (unallocated == 0)
 	{
@@ -5442,7 +5442,7 @@ free_tag (ptr)
 STATIC forward_t *
 allocate_forward ()
 {
-  register forward_t *ptr;
+  forward_t *ptr;
   static forward_t initial_forward;
 
 #ifndef MALLOC_CHECK
@@ -5452,8 +5452,8 @@ allocate_forward ()
 
   else
     {
-      register int unallocated	= alloc_counts[ (int)alloc_type_forward ].unallocated;
-      register page_t *cur_page	= alloc_counts[ (int)alloc_type_forward ].cur_page;
+      int unallocated	= alloc_counts[ (int)alloc_type_forward ].unallocated;
+      page_t *cur_page	= alloc_counts[ (int)alloc_type_forward ].cur_page;
 
       if (unallocated == 0)
 	{
@@ -5500,7 +5500,7 @@ free_forward (ptr)
 STATIC thead_t *
 allocate_thead ()
 {
-  register thead_t *ptr;
+  thead_t *ptr;
   static thead_t initial_thead;
 
 #ifndef MALLOC_CHECK
@@ -5510,8 +5510,8 @@ allocate_thead ()
 
   else
     {
-      register int unallocated	= alloc_counts[ (int)alloc_type_thead ].unallocated;
-      register page_t *cur_page	= alloc_counts[ (int)alloc_type_thead ].cur_page;
+      int unallocated	= alloc_counts[ (int)alloc_type_thead ].unallocated;
+      page_t *cur_page	= alloc_counts[ (int)alloc_type_thead ].cur_page;
 
       if (unallocated == 0)
 	{
diff --git a/gcc/optabs.c b/gcc/optabs.c
index ad21e8db603..28e227b60f9 100644
--- a/gcc/optabs.c
+++ b/gcc/optabs.c
@@ -645,7 +645,7 @@ expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods)
        ? OPTAB_WIDEN : methods);
   enum mode_class class;
   enum machine_mode wider_mode;
-  register rtx temp;
+  rtx temp;
   int commutative_op = 0;
   int shift_op = (binoptab->code ==  ASHIFT
 		  || binoptab->code == ASHIFTRT
@@ -738,7 +738,7 @@ expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods)
 	  if (GET_MODE (op0) != mode0 && GET_MODE (op1) != mode1
 	      && GET_MODE (op0) == mode1 && GET_MODE (op1) == mode0)
 	    {
-	      register rtx tmp;
+	      rtx tmp;
 
 	      tmp = op0; op0 = op1; op1 = tmp;
 	      tmp = xop0; xop0 = xop1; xop1 = tmp;
@@ -1862,7 +1862,7 @@ sign_expand_binop (mode, uoptab, soptab, op0, op1, target, unsignedp, methods)
     int unsignedp;
     enum optab_methods methods;
 {
-  register rtx temp;
+  rtx temp;
   optab direct_optab = unsignedp ? uoptab : soptab;
   struct optab wide_soptab;
 
@@ -2011,8 +2011,8 @@ expand_twoval_binop (binoptab, op0, op1, targ0, targ1, unsignedp)
 	  if (binoptab->handlers[(int) wider_mode].insn_code
 	      != CODE_FOR_nothing)
 	    {
-	      register rtx t0 = gen_reg_rtx (wider_mode);
-	      register rtx t1 = gen_reg_rtx (wider_mode);
+	      rtx t0 = gen_reg_rtx (wider_mode);
+	      rtx t1 = gen_reg_rtx (wider_mode);
 	      rtx cop0 = convert_modes (wider_mode, mode, op0, unsignedp);
 	      rtx cop1 = convert_modes (wider_mode, mode, op1, unsignedp);
 
@@ -2072,7 +2072,7 @@ expand_unop (mode, unoptab, op0, target, unsignedp)
 {
   enum mode_class class;
   enum machine_mode wider_mode;
-  register rtx temp;
+  rtx temp;
   rtx last = get_last_insn ();
   rtx pat;
 
@@ -2448,7 +2448,7 @@ expand_complex_abs (mode, op0, target, unsignedp)
 {
   enum mode_class class = GET_MODE_CLASS (mode);
   enum machine_mode wider_mode;
-  register rtx temp;
+  rtx temp;
   rtx entry_last = get_last_insn ();
   rtx last;
   rtx pat;
@@ -2649,7 +2649,7 @@ emit_unop_insn (icode, target, op0, code)
      rtx op0;
      enum rtx_code code;
 {
-  register rtx temp;
+  rtx temp;
   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
   rtx pat;
 
@@ -3923,7 +3923,7 @@ rtx
 gen_move_insn (x, y)
      rtx x, y;
 {
-  register enum machine_mode mode = GET_MODE (x);
+  enum machine_mode mode = GET_MODE (x);
   enum insn_code insn_code;
   rtx seq;
 
@@ -4070,7 +4070,7 @@ expand_float (to, from, unsignedp)
      int unsignedp;
 {
   enum insn_code icode;
-  register rtx target = to;
+  rtx target = to;
   enum machine_mode fmode, imode;
 
   /* Crash now, because we won't be able to decide which mode to use.  */
@@ -4337,11 +4337,11 @@ ftruncify (x)
 
 void
 expand_fix (to, from, unsignedp)
-     register rtx to, from;
+     rtx to, from;
      int unsignedp;
 {
   enum insn_code icode;
-  register rtx target = to;
+  rtx target = to;
   enum machine_mode fmode, imode;
   int must_trunc = 0;
   rtx libfcn = 0;
@@ -4625,23 +4625,23 @@ init_optabv (code)
 
 static void
 init_libfuncs (optable, first_mode, last_mode, opname, suffix)
-    register optab optable;
-    register int first_mode;
-    register int last_mode;
-    register const char *opname;
-    register int suffix;
+    optab optable;
+    int first_mode;
+    int last_mode;
+    const char *opname;
+    int suffix;
 {
-  register int mode;
-  register unsigned opname_len = strlen (opname);
+  int mode;
+  unsigned opname_len = strlen (opname);
 
   for (mode = first_mode; (int) mode <= (int) last_mode;
        mode = (enum machine_mode) ((int) mode + 1))
     {
-      register const char *mname = GET_MODE_NAME(mode);
-      register unsigned mname_len = strlen (mname);
-      register char *libfunc_name = alloca (2 + opname_len + mname_len + 1 + 1);
-      register char *p;
-      register const char *q;
+      const char *mname = GET_MODE_NAME(mode);
+      unsigned mname_len = strlen (mname);
+      char *libfunc_name = alloca (2 + opname_len + mname_len + 1 + 1);
+      char *p;
+      const char *q;
 
       p = libfunc_name;
       *p++ = '_';
@@ -4666,9 +4666,9 @@ init_libfuncs (optable, first_mode, last_mode, opname, suffix)
 
 static void
 init_integral_libfuncs (optable, opname, suffix)
-    register optab optable;
-    register const char *opname;
-    register int suffix;
+    optab optable;
+    const char *opname;
+    int suffix;
 {
   init_libfuncs (optable, SImode, TImode, opname, suffix);
 }
@@ -4680,16 +4680,16 @@ init_integral_libfuncs (optable, opname, suffix)
 
 static void
 init_floating_libfuncs (optable, opname, suffix)
-    register optab optable;
-    register const char *opname;
-    register int suffix;
+    optab optable;
+    const char *opname;
+    int suffix;
 {
   init_libfuncs (optable, SFmode, TFmode, opname, suffix);
 }
 
 rtx
 init_one_libfunc (name)
-     register const char *name;
+     const char *name;
 {
   /* Create a FUNCTION_DECL that can be passed to ENCODE_SECTION_INFO.  */
   /* ??? We don't have any type information except for this is
diff --git a/gcc/prefix.c b/gcc/prefix.c
index ddf50985c84..88906731bfd 100644
--- a/gcc/prefix.c
+++ b/gcc/prefix.c
@@ -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;
diff --git a/gcc/print-rtl.c b/gcc/print-rtl.c
index 9d4fbbfaba2..f2025b500ba 100644
--- a/gcc/print-rtl.c
+++ b/gcc/print-rtl.c
@@ -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;
diff --git a/gcc/read-rtl.c b/gcc/read-rtl.c
index 9342a279a8e..a366dc8c6c2 100644
--- a/gcc/read-rtl.c
+++ b/gcc/read-rtl.c
@@ -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;
 
diff --git a/gcc/real.c b/gcc/real.c
index 49785484759..0cb2cdb4134 100644
--- a/gcc/real.c
+++ b/gcc/real.c
@@ -1606,9 +1606,9 @@ extern int rndprc;
 
 static void
 eclear (x)
-     register UEMUSHORT *x;
+     UEMUSHORT *x;
 {
-  register int i;
+  int i;
 
   for (i = 0; i < NE; i++)
     *x++ = 0;
@@ -1618,9 +1618,9 @@ eclear (x)
 
 static void
 emov (a, b)
-     register UEMUSHORT *a, *b;
+     UEMUSHORT *a, *b;
 {
-  register int i;
+  int i;
 
   for (i = 0; i < NE; i++)
     *b++ = *a++;
@@ -1708,9 +1708,9 @@ eisnan (x)
 
 static void
 einfin (x)
-     register UEMUSHORT *x;
+     UEMUSHORT *x;
 {
-  register int i;
+  int i;
 
 #ifdef INFINITY
   for (i = 0; i < NE - 1; i++)
@@ -1752,10 +1752,10 @@ einfin (x)
 #ifdef NANS
 static void
 enan (x, sign)
-     register UEMUSHORT *x;
+     UEMUSHORT *x;
      int sign;
 {
-  register int i;
+  int i;
 
   for (i = 0; i < NE - 2; i++)
     *x++ = 0;
@@ -1770,7 +1770,7 @@ static void
 emovi (a, b)
      UEMUSHORT *a, *b;
 {
-  register UEMUSHORT *p, *q;
+  UEMUSHORT *p, *q;
   int i;
 
   q = b;
@@ -1817,7 +1817,7 @@ static void
 emovo (a, b)
      UEMUSHORT *a, *b;
 {
-  register UEMUSHORT *p, *q;
+  UEMUSHORT *p, *q;
   UEMUSHORT i;
   int j;
 
@@ -1854,9 +1854,9 @@ emovo (a, b)
 
 static void
 ecleaz (xi)
-     register UEMUSHORT *xi;
+     UEMUSHORT *xi;
 {
-  register int i;
+  int i;
 
   for (i = 0; i < NI; i++)
     *xi++ = 0;
@@ -1866,9 +1866,9 @@ ecleaz (xi)
 
 static void
 ecleazs (xi)
-     register UEMUSHORT *xi;
+     UEMUSHORT *xi;
 {
-  register int i;
+  int i;
 
   ++xi;
   for (i = 0; i < NI - 1; i++)
@@ -1879,9 +1879,9 @@ ecleazs (xi)
 
 static void
 emovz (a, b)
-     register UEMUSHORT *a, *b;
+     UEMUSHORT *a, *b;
 {
-  register int i;
+  int i;
 
   for (i = 0; i < NI - 1; i++)
     *b++ = *a++;
@@ -1979,7 +1979,7 @@ eiisinf (x)
 
 static int
 ecmpm (a, b)
-     register UEMUSHORT *a, *b;
+     UEMUSHORT *a, *b;
 {
   int i;
 
@@ -2003,9 +2003,9 @@ ecmpm (a, b)
 
 static void
 eshdn1 (x)
-     register UEMUSHORT *x;
+     UEMUSHORT *x;
 {
-  register UEMUSHORT bits;
+  UEMUSHORT bits;
   int i;
 
   x += M;			/* point to significand area */
@@ -2027,9 +2027,9 @@ eshdn1 (x)
 
 static void
 eshup1 (x)
-     register UEMUSHORT *x;
+     UEMUSHORT *x;
 {
-  register UEMUSHORT bits;
+  UEMUSHORT bits;
   int i;
 
   x += NI - 1;
@@ -2052,9 +2052,9 @@ eshup1 (x)
 
 static void
 eshdn8 (x)
-     register UEMUSHORT *x;
+     UEMUSHORT *x;
 {
-  register UEMUSHORT newbyt, oldbyt;
+  UEMUSHORT newbyt, oldbyt;
   int i;
 
   x += M;
@@ -2073,10 +2073,10 @@ eshdn8 (x)
 
 static void
 eshup8 (x)
-     register UEMUSHORT *x;
+     UEMUSHORT *x;
 {
   int i;
-  register UEMUSHORT newbyt, oldbyt;
+  UEMUSHORT newbyt, oldbyt;
 
   x += NI - 1;
   oldbyt = 0;
@@ -2095,10 +2095,10 @@ eshup8 (x)
 
 static void
 eshup6 (x)
-     register UEMUSHORT *x;
+     UEMUSHORT *x;
 {
   int i;
-  register UEMUSHORT *p;
+  UEMUSHORT *p;
 
   p = x + M;
   x += M + 1;
@@ -2113,10 +2113,10 @@ eshup6 (x)
 
 static void
 eshdn6 (x)
-     register UEMUSHORT *x;
+     UEMUSHORT *x;
 {
   int i;
-  register UEMUSHORT *p;
+  UEMUSHORT *p;
 
   x += NI - 1;
   p = x + 1;
@@ -2133,7 +2133,7 @@ static void
 eaddm (x, y)
      UEMUSHORT *x, *y;
 {
-  register unsigned EMULONG a;
+  unsigned EMULONG a;
   int i;
   unsigned int carry;
 
@@ -2194,7 +2194,7 @@ edivm (den, num)
      UEMUSHORT den[], num[];
 {
   int i;
-  register UEMUSHORT *p, *q;
+  UEMUSHORT *p, *q;
   UEMUSHORT j;
 
   p = &equot[0];
@@ -2344,8 +2344,8 @@ m16m (a, b, c)
      unsigned int a;
      UEMUSHORT b[], c[];
 {
-  register UEMUSHORT *pp;
-  register unsigned EMULONG carry;
+  UEMUSHORT *pp;
+  unsigned EMULONG carry;
   UEMUSHORT *ps;
   UEMUSHORT p[NI];
   unsigned EMULONG aa, m;
@@ -2388,7 +2388,7 @@ edivm (den, num)
      UEMUSHORT den[], num[];
 {
   int i;
-  register UEMUSHORT *p;
+  UEMUSHORT *p;
   unsigned EMULONG tnum;
   UEMUSHORT j, tdenm, tquot;
   UEMUSHORT tprod[NI+1];
@@ -3135,8 +3135,8 @@ e53toe (pe, y)
   c4xtoe (pe, y, HFmode);
 
 #else
-  register UEMUSHORT r;
-  register UEMUSHORT *e, *p;
+  UEMUSHORT r;
+  UEMUSHORT *e, *p;
   UEMUSHORT yy[NI];
   int denorm, k;
 
@@ -3352,7 +3352,7 @@ static void
 e113toe (pe, y)
      UEMUSHORT *pe, *y;
 {
-  register UEMUSHORT r;
+  UEMUSHORT r;
   UEMUSHORT *e, *p;
   UEMUSHORT yy[NI];
   int denorm, i;
@@ -3450,8 +3450,8 @@ e24toe (pe, y)
 
 #else
 
-  register UEMUSHORT r;
-  register UEMUSHORT *e, *p;
+  UEMUSHORT r;
+  UEMUSHORT *e, *p;
   UEMUSHORT yy[NI];
   int denorm, k;
 
@@ -3576,7 +3576,7 @@ static void
 toe113 (a, b)
      UEMUSHORT *a, *b;
 {
-  register UEMUSHORT *p, *q;
+  UEMUSHORT *p, *q;
   UEMUSHORT i;
 
 #ifdef NANS
@@ -3670,7 +3670,7 @@ static void
 toe64 (a, b)
      UEMUSHORT *a, *b;
 {
-  register UEMUSHORT *p, *q;
+  UEMUSHORT *p, *q;
   UEMUSHORT i;
 
 #ifdef NANS
@@ -4161,8 +4161,8 @@ ecmp (a, b)
      UEMUSHORT *a, *b;
 {
   UEMUSHORT ai[NI], bi[NI];
-  register UEMUSHORT *p, *q;
-  register int i;
+  UEMUSHORT *p, *q;
+  int i;
   int msign;
 
 #ifdef NANS
@@ -4534,7 +4534,7 @@ static int
 enormlz (x)
      UEMUSHORT x[];
 {
-  register UEMUSHORT *p;
+  UEMUSHORT *p;
   int sc;
 
   sc = 0;
@@ -5561,7 +5561,7 @@ static void
 efloor (x, y)
      UEMUSHORT x[], y[];
 {
-  register UEMUSHORT *p;
+  UEMUSHORT *p;
   int e, expon, i;
   UEMUSHORT f[NE];
 
@@ -5795,7 +5795,7 @@ dectoe (d, e)
      UEMUSHORT *e;
 {
   UEMUSHORT y[NI];
-  register UEMUSHORT r, *p;
+  UEMUSHORT r, *p;
 
   ecleaz (y);			/* start with a zero */
   p = y;			/* point to our number */
@@ -5904,7 +5904,7 @@ ibmtoe (d, e, mode)
      enum machine_mode mode;
 {
   UEMUSHORT y[NI];
-  register UEMUSHORT r, *p;
+  UEMUSHORT r, *p;
 
   ecleaz (y);			/* start with a zero */
   p = y;			/* point to our number */
diff --git a/gcc/recog.c b/gcc/recog.c
index 71ecfd8eb95..e240ebbe2cc 100644
--- a/gcc/recog.c
+++ b/gcc/recog.c
@@ -437,9 +437,9 @@ validate_replace_rtx_1 (loc, from, to, object)
      rtx *loc;
      rtx from, to, object;
 {
-  register int i, j;
-  register const char *fmt;
-  register rtx x = *loc;
+  int i, j;
+  const char *fmt;
+  rtx x = *loc;
   enum rtx_code code;
   enum machine_mode op0_mode = VOIDmode;
   int prev_changes = num_changes;
@@ -687,7 +687,7 @@ int
 next_insn_tests_no_inequality (insn)
      rtx insn;
 {
-  register rtx next = next_cc0_user (insn);
+  rtx next = next_cc0_user (insn);
 
   /* If there is no next insn, we have to take the conservative choice.  */
   if (next == 0)
@@ -707,7 +707,7 @@ int
 next_insns_test_no_inequality (insn)
      rtx insn;
 {
-  register rtx next = NEXT_INSN (insn);
+  rtx next = NEXT_INSN (insn);
 
   for (; next != 0; next = NEXT_INSN (next))
     {
@@ -913,10 +913,10 @@ find_single_use (dest, insn, ploc)
 
 int
 general_operand (op, mode)
-     register rtx op;
+     rtx op;
      enum machine_mode mode;
 {
-  register enum rtx_code code = GET_CODE (op);
+  enum rtx_code code = GET_CODE (op);
 
   if (mode == VOIDmode)
     mode = GET_MODE (op);
@@ -976,7 +976,7 @@ general_operand (op, mode)
 
   if (code == MEM)
     {
-      register rtx y = XEXP (op, 0);
+      rtx y = XEXP (op, 0);
 
       if (! volatile_ok && MEM_VOLATILE_P (op))
 	return 0;
@@ -1008,7 +1008,7 @@ general_operand (op, mode)
 
 int
 address_operand (op, mode)
-     register rtx op;
+     rtx op;
      enum machine_mode mode;
 {
   return memory_address_p (mode, op);
@@ -1030,7 +1030,7 @@ address_operand (op, mode)
 
 int
 register_operand (op, mode)
-     register rtx op;
+     rtx op;
      enum machine_mode mode;
 {
   if (GET_MODE (op) != mode && mode != VOIDmode)
@@ -1089,7 +1089,7 @@ pmode_register_operand (op, mode)
 
 int
 scratch_operand (op, mode)
-     register rtx op;
+     rtx op;
      enum machine_mode mode;
 {
   if (GET_MODE (op) != mode && mode != VOIDmode)
@@ -1107,7 +1107,7 @@ scratch_operand (op, mode)
 
 int
 immediate_operand (op, mode)
-     register rtx op;
+     rtx op;
      enum machine_mode mode;
 {
   /* Don't accept CONST_INT or anything similar
@@ -1140,7 +1140,7 @@ immediate_operand (op, mode)
 
 int
 const_int_operand (op, mode)
-     register rtx op;
+     rtx op;
      enum machine_mode mode;
 {
   if (GET_CODE (op) != CONST_INT)
@@ -1158,7 +1158,7 @@ const_int_operand (op, mode)
 
 int
 const_double_operand (op, mode)
-     register rtx op;
+     rtx op;
      enum machine_mode mode;
 {
   /* Don't accept CONST_INT or anything similar
@@ -1177,7 +1177,7 @@ const_double_operand (op, mode)
 
 int
 nonimmediate_operand (op, mode)
-     register rtx op;
+     rtx op;
      enum machine_mode mode;
 {
   return (general_operand (op, mode) && ! CONSTANT_P (op));
@@ -1187,7 +1187,7 @@ nonimmediate_operand (op, mode)
 
 int
 nonmemory_operand (op, mode)
-     register rtx op;
+     rtx op;
      enum machine_mode mode;
 {
   if (CONSTANT_P (op))
@@ -1312,7 +1312,7 @@ pop_operand (op, mode)
 int
 memory_address_p (mode, addr)
      enum machine_mode mode ATTRIBUTE_UNUSED;
-     register rtx addr;
+     rtx addr;
 {
   if (GET_CODE (addr) == ADDRESSOF)
     return 1;
@@ -1332,7 +1332,7 @@ memory_address_p (mode, addr)
 
 int
 memory_operand (op, mode)
-     register rtx op;
+     rtx op;
      enum machine_mode mode;
 {
   rtx inner;
@@ -1357,14 +1357,14 @@ memory_operand (op, mode)
 
 int
 indirect_operand (op, mode)
-     register rtx op;
+     rtx op;
      enum machine_mode mode;
 {
   /* Before reload, a SUBREG isn't in memory (see memory_operand, above).  */
   if (! reload_completed
       && GET_CODE (op) == SUBREG && GET_CODE (SUBREG_REG (op)) == MEM)
     {
-      register int offset = SUBREG_BYTE (op);
+      int offset = SUBREG_BYTE (op);
       rtx inner = SUBREG_REG (op);
 
       if (mode != VOIDmode && GET_MODE (op) != mode)
@@ -1392,7 +1392,7 @@ indirect_operand (op, mode)
 
 int
 comparison_operator (op, mode)
-    register rtx op;
+    rtx op;
     enum machine_mode mode;
 {
   return ((mode == VOIDmode || GET_MODE (op) == mode)
@@ -1496,7 +1496,7 @@ decode_asm_operands (body, operands, operand_locs, constraints, modes)
      const char **constraints;
      enum machine_mode *modes;
 {
-  register int i;
+  int i;
   int noperands;
   const char *template = 0;
 
@@ -1828,8 +1828,8 @@ rtx *
 find_constant_term_loc (p)
      rtx *p;
 {
-  register rtx *tem;
-  register enum rtx_code code = GET_CODE (*p);
+  rtx *tem;
+  enum rtx_code code = GET_CODE (*p);
 
   /* If *P IS such a constant term, P is its location.  */
 
@@ -1911,10 +1911,10 @@ int
 offsettable_address_p (strictp, mode, y)
      int strictp;
      enum machine_mode mode;
-     register rtx y;
+     rtx y;
 {
-  register enum rtx_code ycode = GET_CODE (y);
-  register rtx z;
+  enum rtx_code ycode = GET_CODE (y);
+  rtx z;
   rtx y1 = y;
   rtx *y2;
   int (*addressp) PARAMS ((enum machine_mode, rtx)) =
@@ -2291,7 +2291,7 @@ constrain_operands (strict)
   const char *constraints[MAX_RECOG_OPERANDS];
   int matching_operands[MAX_RECOG_OPERANDS];
   int earlyclobber[MAX_RECOG_OPERANDS];
-  register int c;
+  int c;
 
   struct funny_match funny_match[MAX_RECOG_OPERANDS];
   int funny_match_index;
@@ -2308,15 +2308,15 @@ constrain_operands (strict)
 
   do
     {
-      register int opno;
+      int opno;
       int lose = 0;
       funny_match_index = 0;
 
       for (opno = 0; opno < recog_data.n_operands; opno++)
 	{
-	  register rtx op = recog_data.operand[opno];
+	  rtx op = recog_data.operand[opno];
 	  enum machine_mode mode = GET_MODE (op);
-	  register const char *p = constraints[opno];
+	  const char *p = constraints[opno];
 	  int offset = 0;
 	  int win = 0;
 	  int val;
@@ -2631,16 +2631,16 @@ constrain_operands (strict)
 int
 reg_fits_class_p (operand, class, offset, mode)
      rtx operand;
-     register enum reg_class class;
+     enum reg_class class;
      int offset;
      enum machine_mode mode;
 {
-  register int regno = REGNO (operand);
+  int regno = REGNO (operand);
   if (regno < FIRST_PSEUDO_REGISTER
       && TEST_HARD_REG_BIT (reg_class_contents[(int) class],
 			    regno + offset))
     {
-      register int sr;
+      int sr;
       regno += offset;
       for (sr = HARD_REGNO_NREGS (regno, mode) - 1;
 	   sr > 0; sr--)
diff --git a/gcc/reg-stack.c b/gcc/reg-stack.c
index 2b39b71d7bc..b79c8741f00 100644
--- a/gcc/reg-stack.c
+++ b/gcc/reg-stack.c
@@ -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)
     {
diff --git a/gcc/regclass.c b/gcc/regclass.c
index 140a207a276..a514bd5a4a6 100644
--- a/gcc/regclass.c
+++ b/gcc/regclass.c
@@ -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
diff --git a/gcc/regmove.c b/gcc/regmove.c
index 8e2f315611f..ce62cce72a5 100644
--- a/gcc/regmove.c
+++ b/gcc/regmove.c
@@ -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;
diff --git a/gcc/reload.c b/gcc/reload.c
index 0b497aa6f96..613d6c7e2c7 100644
--- a/gcc/reload.c
+++ b/gcc/reload.c
@@ -857,7 +857,7 @@ push_reload (in, out, inloc, outloc, class,
      int opnum;
      enum reload_type type;
 {
-  register int i;
+  int i;
   int dont_share = 0;
   int dont_remove_subreg = 0;
   rtx *in_subreg_loc = 0, *out_subreg_loc = 0;
@@ -879,7 +879,7 @@ push_reload (in, out, inloc, outloc, class,
      Often this is done earlier, but not always in find_reloads_address.  */
   if (in != 0 && GET_CODE (in) == REG)
     {
-      register int regno = REGNO (in);
+      int regno = REGNO (in);
 
       if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
 	  && reg_equiv_constant[regno] != 0)
@@ -891,7 +891,7 @@ push_reload (in, out, inloc, outloc, class,
      (in the case of a parameter).  */
   if (out != 0 && GET_CODE (out) == REG)
     {
-      register int regno = REGNO (out);
+      int regno = REGNO (out);
 
       if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
 	  && reg_equiv_constant[regno] != 0)
@@ -1402,7 +1402,7 @@ push_reload (in, out, inloc, outloc, class,
     {
       if (inloc != 0)
 	{
-	  register struct replacement *r = &replacements[n_replacements++];
+	  struct replacement *r = &replacements[n_replacements++];
 	  r->what = i;
 	  r->subreg_loc = in_subreg_loc;
 	  r->where = inloc;
@@ -1410,7 +1410,7 @@ push_reload (in, out, inloc, outloc, class,
 	}
       if (outloc != 0 && outloc != inloc)
 	{
-	  register struct replacement *r = &replacements[n_replacements++];
+	  struct replacement *r = &replacements[n_replacements++];
 	  r->what = i;
 	  r->where = outloc;
 	  r->subreg_loc = out_subreg_loc;
@@ -1537,7 +1537,7 @@ push_replacement (loc, reloadnum, mode)
 {
   if (replace_reloads)
     {
-      register struct replacement *r = &replacements[n_replacements++];
+      struct replacement *r = &replacements[n_replacements++];
       r->what = reloadnum;
       r->where = loc;
       r->subreg_loc = 0;
@@ -1978,7 +1978,7 @@ hard_reg_set_here_p (beg_regno, end_regno, x)
 {
   if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
     {
-      register rtx op0 = SET_DEST (x);
+      rtx op0 = SET_DEST (x);
 
       while (GET_CODE (op0) == SUBREG)
 	op0 = SUBREG_REG (op0);
@@ -1994,7 +1994,7 @@ hard_reg_set_here_p (beg_regno, end_regno, x)
     }
   else if (GET_CODE (x) == PARALLEL)
     {
-      register int i = XVECLEN (x, 0) - 1;
+      int i = XVECLEN (x, 0) - 1;
 
       for (; i >= 0; i--)
 	if (hard_reg_set_here_p (beg_regno, end_regno, XVECEXP (x, 0, i)))
@@ -2011,7 +2011,7 @@ hard_reg_set_here_p (beg_regno, end_regno, x)
 int
 strict_memory_address_p (mode, addr)
      enum machine_mode mode ATTRIBUTE_UNUSED;
-     register rtx addr;
+     rtx addr;
 {
   GO_IF_LEGITIMATE_ADDRESS (mode, addr, win);
   return 0;
@@ -2037,11 +2037,11 @@ strict_memory_address_p (mode, addr)
 
 int
 operands_match_p (x, y)
-     register rtx x, y;
+     rtx x, y;
 {
-  register int i;
-  register RTX_CODE code = GET_CODE (x);
-  register const char *fmt;
+  int i;
+  RTX_CODE code = GET_CODE (x);
+  const char *fmt;
   int success_2;
 
   if (x == y)
@@ -2050,7 +2050,7 @@ operands_match_p (x, y)
       && (GET_CODE (y) == REG || (GET_CODE (y) == SUBREG
 				  && GET_CODE (SUBREG_REG (y)) == REG)))
     {
-      register int j;
+      int j;
 
       if (code == SUBREG)
 	{
@@ -2410,8 +2410,8 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
      int live_known;
      short *reload_reg_p;
 {
-  register int insn_code_number;
-  register int i, j;
+  int insn_code_number;
+  int i, j;
   int noperands;
   /* These start out as the constraints for the insn
      and they are chewed up as we consider alternatives.  */
@@ -2524,8 +2524,8 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 
   for (i = 0; i < noperands; i++)
     {
-      register char *p;
-      register int c;
+      char *p;
+      int c;
 
       substed_operand[i] = recog_data.operand[i];
       p = constraints[i];
@@ -2596,7 +2596,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 
   for (i = 0; i < noperands; i++)
     {
-      register RTX_CODE code = GET_CODE (recog_data.operand[i]);
+      RTX_CODE code = GET_CODE (recog_data.operand[i]);
 
       address_reloaded[i] = 0;
       operand_type[i] = (modified[i] == RELOAD_READ ? RELOAD_FOR_INPUT
@@ -2687,7 +2687,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 	     we replace it by the constant.  We must be sure, however,
 	     that we don't try to replace it in the insn in which it
 	     is being set.  */
-	  register int regno = REGNO (recog_data.operand[i]);
+	  int regno = REGNO (recog_data.operand[i]);
 	  if (reg_equiv_constant[regno] != 0
 	      && (set == 0 || &SET_DEST (set) != recog_data.operand_loc[i]))
 	    {
@@ -2774,15 +2774,15 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 
       for (i = 0; i < noperands; i++)
 	{
-	  register char *p = constraints[i];
-	  register int win = 0;
+	  char *p = constraints[i];
+	  int win = 0;
 	  int did_match = 0;
 	  /* 0 => this operand can be reloaded somehow for this alternative.  */
 	  int badop = 1;
 	  /* 0 => this operand can be reloaded if the alternative allows regs.  */
 	  int winreg = 0;
 	  int c;
-	  register rtx operand = recog_data.operand[i];
+	  rtx operand = recog_data.operand[i];
 	  int offset = 0;
 	  /* Nonzero means this is a MEM that must be reloaded into a reg
 	     regardless of what the constraint says.  */
@@ -3494,8 +3494,8 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
       swapped = !swapped;
       if (swapped)
 	{
-	  register enum reg_class tclass;
-	  register int t;
+	  enum reg_class tclass;
+	  int t;
 
 	  recog_data.operand[commutative] = substed_operand[commutative + 1];
 	  recog_data.operand[commutative + 1] = substed_operand[commutative];
@@ -3564,7 +3564,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 
   if (goal_alternative_swapped)
     {
-      register rtx tem;
+      rtx tem;
 
       tem = substed_operand[commutative];
       substed_operand[commutative] = substed_operand[commutative + 1];
@@ -4229,7 +4229,7 @@ alternative_allows_memconst (constraint, altnum)
      const char *constraint;
      int altnum;
 {
-  register int c;
+  int c;
   /* Skip alternatives before the one requested.  */
   while (altnum > 0)
     {
@@ -4277,16 +4277,16 @@ find_reloads_toplev (x, opnum, type, ind_levels, is_set_dest, insn,
      rtx insn;
      int *address_reloaded;
 {
-  register RTX_CODE code = GET_CODE (x);
+  RTX_CODE code = GET_CODE (x);
 
-  register const char *fmt = GET_RTX_FORMAT (code);
-  register int i;
+  const char *fmt = GET_RTX_FORMAT (code);
+  int i;
   int copied;
 
   if (code == REG)
     {
       /* This code is duplicated for speed in find_reloads.  */
-      register int regno = REGNO (x);
+      int regno = REGNO (x);
       if (reg_equiv_constant[regno] != 0 && !is_set_dest)
 	x = reg_equiv_constant[regno];
 #if 0
@@ -4343,7 +4343,7 @@ find_reloads_toplev (x, opnum, type, ind_levels, is_set_dest, insn,
 	 the register (this should never happen because one of the cases
 	 above should handle it).  */
 
-      register int regno = REGNO (SUBREG_REG (x));
+      int regno = REGNO (SUBREG_REG (x));
       rtx tem;
 
       if (subreg_lowpart_p (x)
@@ -4514,7 +4514,7 @@ find_reloads_address (mode, memrefloc, ad, loc, opnum, type, ind_levels, insn)
      int ind_levels;
      rtx insn;
 {
-  register int regno;
+  int regno;
   int removed_and = 0;
   rtx tem;
 
@@ -4874,9 +4874,9 @@ subst_reg_equivs (ad, insn)
      rtx ad;
      rtx insn;
 {
-  register RTX_CODE code = GET_CODE (ad);
-  register int i;
-  register const char *fmt;
+  RTX_CODE code = GET_CODE (ad);
+  int i;
+  const char *fmt;
 
   switch (code)
     {
@@ -4892,7 +4892,7 @@ subst_reg_equivs (ad, insn)
 
     case REG:
       {
-	register int regno = REGNO (ad);
+	int regno = REGNO (ad);
 
 	if (reg_equiv_constant[regno] != 0)
 	  {
@@ -5105,18 +5105,18 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
      int ind_levels;
      rtx insn;
 {
-  register RTX_CODE code = GET_CODE (x);
+  RTX_CODE code = GET_CODE (x);
 
   switch (code)
     {
     case PLUS:
       {
-	register rtx orig_op0 = XEXP (x, 0);
-	register rtx orig_op1 = XEXP (x, 1);
-	register RTX_CODE code0 = GET_CODE (orig_op0);
-	register RTX_CODE code1 = GET_CODE (orig_op1);
-	register rtx op0 = orig_op0;
-	register rtx op1 = orig_op1;
+	rtx orig_op0 = XEXP (x, 0);
+	rtx orig_op1 = XEXP (x, 1);
+	RTX_CODE code0 = GET_CODE (orig_op0);
+	RTX_CODE code1 = GET_CODE (orig_op1);
+	rtx op0 = orig_op0;
+	rtx op1 = orig_op1;
 
 	if (GET_CODE (op0) == SUBREG)
 	  {
@@ -5316,7 +5316,7 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
     case PRE_DEC:
       if (GET_CODE (XEXP (x, 0)) == REG)
 	{
-	  register int regno = REGNO (XEXP (x, 0));
+	  int regno = REGNO (XEXP (x, 0));
 	  int value = 0;
 	  rtx x_orig = x;
 
@@ -5429,7 +5429,7 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
 	     reload it into a register.  */
 	  /* Variable `tem' might or might not be used in FIND_REG_INC_NOTE.  */
 	  rtx tem ATTRIBUTE_UNUSED = XEXP (x, 0);
-	  register rtx link;
+	  rtx link;
 	  int reloadnum;
 
 	  /* Since we know we are going to reload this item, don't decrement
@@ -5481,7 +5481,7 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
 
     case REG:
       {
-	register int regno = REGNO (x);
+	int regno = REGNO (x);
 
 	if (reg_equiv_constant[regno] != 0)
 	  {
@@ -5586,8 +5586,8 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
     }
 
   {
-    register const char *fmt = GET_RTX_FORMAT (code);
-    register int i;
+    const char *fmt = GET_RTX_FORMAT (code);
+    int i;
 
     for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
       {
@@ -5765,12 +5765,12 @@ void
 subst_reloads (insn)
      rtx insn;
 {
-  register int i;
+  int i;
 
   for (i = 0; i < n_replacements; i++)
     {
-      register struct replacement *r = &replacements[i];
-      register rtx reloadreg = rld[r->what].reg_rtx;
+      struct replacement *r = &replacements[i];
+      rtx reloadreg = rld[r->what].reg_rtx;
       if (reloadreg)
 	{
 #ifdef ENABLE_CHECKING
@@ -6090,7 +6090,7 @@ refers_to_regno_for_reload_p (regno, endregno, x, loc)
 	}
       else if (fmt[i] == 'E')
 	{
-	  register int j;
+	  int j;
 	  for (j = XVECLEN (x, i) - 1; j >= 0; j--)
 	    if (loc != &XVECEXP (x, i, j)
 		&& refers_to_regno_for_reload_p (regno, endregno,
@@ -6218,18 +6218,18 @@ refers_to_mem_for_reload_p (x)
 
 rtx
 find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
-     register rtx goal;
+     rtx goal;
      rtx insn;
      enum reg_class class;
-     register int other;
+     int other;
      short *reload_reg_p;
      int goalreg;
      enum machine_mode mode;
 {
-  register rtx p = insn;
+  rtx p = insn;
   rtx goaltry, valtry, value, where;
-  register rtx pat;
-  register int regno = -1;
+  rtx pat;
+  int regno = -1;
   int valueno;
   int goal_mem = 0;
   int goal_const = 0;
@@ -6515,7 +6515,7 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
 	    pat = COND_EXEC_CODE (pat);
 	  if (GET_CODE (pat) == SET || GET_CODE (pat) == CLOBBER)
 	    {
-	      register rtx dest = SET_DEST (pat);
+	      rtx dest = SET_DEST (pat);
 	      while (GET_CODE (dest) == SUBREG
 		     || GET_CODE (dest) == ZERO_EXTRACT
 		     || GET_CODE (dest) == SIGN_EXTRACT
@@ -6523,7 +6523,7 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
 		dest = XEXP (dest, 0);
 	      if (GET_CODE (dest) == REG)
 		{
-		  register int xregno = REGNO (dest);
+		  int xregno = REGNO (dest);
 		  int xnregs;
 		  if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
 		    xnregs = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
@@ -6551,15 +6551,15 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
 	    }
 	  else if (GET_CODE (pat) == PARALLEL)
 	    {
-	      register int i;
+	      int i;
 	      for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)
 		{
-		  register rtx v1 = XVECEXP (pat, 0, i);
+		  rtx v1 = XVECEXP (pat, 0, i);
 		  if (GET_CODE (v1) == COND_EXEC)
 		    v1 = COND_EXEC_CODE (v1);
 		  if (GET_CODE (v1) == SET || GET_CODE (v1) == CLOBBER)
 		    {
-		      register rtx dest = SET_DEST (v1);
+		      rtx dest = SET_DEST (v1);
 		      while (GET_CODE (dest) == SUBREG
 			     || GET_CODE (dest) == ZERO_EXTRACT
 			     || GET_CODE (dest) == SIGN_EXTRACT
@@ -6567,7 +6567,7 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
 			dest = XEXP (dest, 0);
 		      if (GET_CODE (dest) == REG)
 			{
-			  register int xregno = REGNO (dest);
+			  int xregno = REGNO (dest);
 			  int xnregs;
 			  if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
 			    xnregs = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
@@ -6609,11 +6609,11 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
 		  pat = XEXP (link, 0);
 		  if (GET_CODE (pat) == CLOBBER)
 		    {
-		      register rtx dest = SET_DEST (pat);
+		      rtx dest = SET_DEST (pat);
 
 		      if (GET_CODE (dest) == REG)
 			{
-			  register int xregno = REGNO (dest);
+			  int xregno = REGNO (dest);
 			  int xnregs
 			    = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
 
@@ -6645,13 +6645,13 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
 	     If GOAL is a memory ref and its address is not constant,
 	     and this insn P increments a register used in GOAL, return 0.  */
 	  {
-	    register rtx link;
+	    rtx link;
 
 	    for (link = REG_NOTES (p); link; link = XEXP (link, 1))
 	      if (REG_NOTE_KIND (link) == REG_INC
 		  && GET_CODE (XEXP (link, 0)) == REG)
 		{
-		  register int incno = REGNO (XEXP (link, 0));
+		  int incno = REGNO (XEXP (link, 0));
 		  if (incno < regno + nregs && incno >= regno)
 		    return 0;
 		  if (incno < valueno + valuenregs && incno >= valueno)
@@ -6675,13 +6675,13 @@ static int
 find_inc_amount (x, inced)
      rtx x, inced;
 {
-  register enum rtx_code code = GET_CODE (x);
-  register const char *fmt;
-  register int i;
+  enum rtx_code code = GET_CODE (x);
+  const char *fmt;
+  int i;
 
   if (code == MEM)
     {
-      register rtx addr = XEXP (x, 0);
+      rtx addr = XEXP (x, 0);
       if ((GET_CODE (addr) == PRE_DEC
 	   || GET_CODE (addr) == POST_DEC
 	   || GET_CODE (addr) == PRE_INC
@@ -6705,16 +6705,16 @@ find_inc_amount (x, inced)
     {
       if (fmt[i] == 'e')
 	{
-	  register int tem = find_inc_amount (XEXP (x, i), inced);
+	  int tem = find_inc_amount (XEXP (x, i), inced);
 	  if (tem != 0)
 	    return tem;
 	}
       if (fmt[i] == 'E')
 	{
-	  register int j;
+	  int j;
 	  for (j = XVECLEN (x, i) - 1; j >= 0; j--)
 	    {
-	      register int tem = find_inc_amount (XVECEXP (x, i, j), inced);
+	      int tem = find_inc_amount (XVECEXP (x, i, j), inced);
 	      if (tem != 0)
 		return tem;
 	    }
diff --git a/gcc/reload1.c b/gcc/reload1.c
index 0bdfcb8e6d0..2be0983a2ac 100644
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -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.  */
diff --git a/gcc/reorg.c b/gcc/reorg.c
index 7ef9e1160fc..5132aef73c7 100644
--- a/gcc/reorg.c
+++ b/gcc/reorg.c
@@ -301,8 +301,8 @@ resource_conflicts_p (res1, res2)
 
 static int
 insn_references_resource_p (insn, res, include_delayed_effects)
-     register rtx insn;
-     register struct resources *res;
+     rtx insn;
+     struct resources *res;
      int include_delayed_effects;
 {
   struct resources insn_res;
@@ -319,8 +319,8 @@ insn_references_resource_p (insn, res, include_delayed_effects)
 
 static int
 insn_sets_resource_p (insn, res, include_delayed_effects)
-     register rtx insn;
-     register struct resources *res;
+     rtx insn;
+     struct resources *res;
      int include_delayed_effects;
 {
   struct resources insn_sets;
@@ -436,8 +436,8 @@ emit_delay_sequence (insn, list, length)
      rtx list;
      int length;
 {
-  register int i = 1;
-  register rtx li;
+  int i = 1;
+  rtx li;
   int had_barrier = 0;
 
   /* Allocate the rtvec to hold the insns and the SEQUENCE.  */
@@ -719,9 +719,9 @@ note_delay_statistics (slots_filled, index)
 
 static rtx
 optimize_skip (insn)
-     register rtx insn;
+     rtx insn;
 {
-  register rtx trial = next_nonnote_insn (insn);
+  rtx trial = next_nonnote_insn (insn);
   rtx next_trial = next_active_insn (trial);
   rtx delay_list = 0;
   rtx target_label;
@@ -2034,8 +2034,8 @@ static void
 fill_simple_delay_slots (non_jumps_p)
      int non_jumps_p;
 {
-  register rtx insn, pat, trial, next_trial;
-  register int i;
+  rtx insn, pat, trial, next_trial;
+  int i;
   int num_unfilled_slots = unfilled_slots_next - unfilled_slots_base;
   struct resources needed, set;
   int slots_to_fill, slots_filled;
@@ -2943,8 +2943,8 @@ fill_slots_from_thread (insn, condition, thread, opposite_thread, likely,
 static void
 fill_eager_delay_slots ()
 {
-  register rtx insn;
-  register int i;
+  rtx insn;
+  int i;
   int num_unfilled_slots = unfilled_slots_next - unfilled_slots_base;
 
   for (i = 0; i < num_unfilled_slots; i++)
@@ -3072,8 +3072,8 @@ static void
 relax_delay_slots (first)
      rtx first;
 {
-  register rtx insn, next, pat;
-  register rtx trial, delay_insn, target_label;
+  rtx insn, next, pat;
+  rtx trial, delay_insn, target_label;
 
   /* Look at every JUMP_INSN and see if we can improve it.  */
   for (insn = first; insn; insn = next)
@@ -3662,7 +3662,7 @@ dbr_schedule (first, file)
 
   if (file)
     {
-      register int i, j, need_comma;
+      int i, j, need_comma;
       int total_delay_slots[MAX_DELAY_HISTOGRAM + 1];
       int total_annul_slots[MAX_DELAY_HISTOGRAM + 1];
 
diff --git a/gcc/resource.c b/gcc/resource.c
index 8a27855e7f4..ebff8c61887 100644
--- a/gcc/resource.c
+++ b/gcc/resource.c
@@ -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;
 {
diff --git a/gcc/rtl.c b/gcc/rtl.c
index bd4d6fad682..bcf300522f4 100644
--- a/gcc/rtl.c
+++ b/gcc/rtl.c
@@ -330,12 +330,12 @@ rtx_alloc (code)
 
 rtx
 copy_rtx (orig)
-     register rtx orig;
+     rtx orig;
 {
-  register rtx copy;
-  register int i, j;
-  register RTX_CODE code;
-  register const char *format_ptr;
+  rtx copy;
+  int i, j;
+  RTX_CODE code;
+  const char *format_ptr;
 
   code = GET_CODE (orig);
 
@@ -435,13 +435,13 @@ copy_rtx (orig)
 
 rtx
 copy_most_rtx (orig, may_share)
-     register rtx orig;
-     register rtx may_share;
+     rtx orig;
+     rtx may_share;
 {
-  register rtx copy;
-  register int i, j;
-  register RTX_CODE code;
-  register const char *format_ptr;
+  rtx copy;
+  int i, j;
+  RTX_CODE code;
+  const char *format_ptr;
 
   if (orig == may_share)
     return orig;
@@ -534,9 +534,9 @@ rtx
 shallow_copy_rtx (orig)
      rtx orig;
 {
-  register int i;
-  register RTX_CODE code = GET_CODE (orig);
-  register rtx copy = rtx_alloc (code);
+  int i;
+  RTX_CODE code = GET_CODE (orig);
+  rtx copy = rtx_alloc (code);
 
   PUT_MODE (copy, GET_MODE (orig));
   copy->in_struct = orig->in_struct;
@@ -564,10 +564,10 @@ int
 rtx_equal_p (x, y)
      rtx x, y;
 {
-  register int i;
-  register int j;
-  register enum rtx_code code;
-  register const char *fmt;
+  int i;
+  int j;
+  enum rtx_code code;
+  const char *fmt;
 
   if (x == y)
     return 1;
@@ -589,10 +589,11 @@ rtx_equal_p (x, y)
   switch (code)
     {
     case REG:
-      /* Until rtl generation is complete, don't consider a reference to the
-	 return register of the current function the same as the return from a
-	 called function.  This eases the job of function integration.  Once the
-	 distinction is no longer needed, they can be considered equivalent.  */
+      /* Until rtl generation is complete, don't consider a reference
+	 to the return register of the current function the same as
+	 the return from a called function.  This eases the job of
+	 function integration.  Once the distinction is no longer
+	 needed, they can be considered equivalent.  */
       return (REGNO (x) == REGNO (y)
 	      && (! rtx_equal_function_value_matters
 		  || REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y)));
diff --git a/gcc/rtlanal.c b/gcc/rtlanal.c
index 236d9fb2e2d..ee40d6c7908 100644
--- a/gcc/rtlanal.c
+++ b/gcc/rtlanal.c
@@ -47,9 +47,9 @@ int
 rtx_unstable_p (x)
      rtx x;
 {
-  register RTX_CODE code = GET_CODE (x);
-  register int i;
-  register const char *fmt;
+  RTX_CODE code = GET_CODE (x);
+  int i;
+  const char *fmt;
 
   switch (code)
     {
@@ -123,9 +123,9 @@ rtx_varies_p (x, for_alias)
      rtx x;
      int for_alias;
 {
-  register RTX_CODE code = GET_CODE (x);
-  register int i;
-  register const char *fmt;
+  RTX_CODE code = GET_CODE (x);
+  int i;
+  const char *fmt;
 
   switch (code)
     {
@@ -202,9 +202,9 @@ rtx_varies_p (x, for_alias)
 
 int
 rtx_addr_can_trap_p (x)
-     register rtx x;
+     rtx x;
 {
-  register enum rtx_code code = GET_CODE (x);
+  enum rtx_code code = GET_CODE (x);
 
   switch (code)
     {
@@ -269,9 +269,9 @@ rtx_addr_varies_p (x, for_alias)
      rtx x;
      int for_alias;
 {
-  register enum rtx_code code;
-  register int i;
-  register const char *fmt;
+  enum rtx_code code;
+  int i;
+  const char *fmt;
 
   if (x == 0)
     return 0;
@@ -407,11 +407,11 @@ count_occurrences (x, find, count_dest)
 
 int
 reg_mentioned_p (reg, in)
-     register rtx reg, in;
+     rtx reg, in;
 {
-  register const char *fmt;
-  register int i;
-  register enum rtx_code code;
+  const char *fmt;
+  int i;
+  enum rtx_code code;
 
   if (in == 0)
     return 0;
@@ -457,7 +457,7 @@ reg_mentioned_p (reg, in)
     {
       if (fmt[i] == 'E')
 	{
-	  register int j;
+	  int j;
 	  for (j = XVECLEN (in, i) - 1; j >= 0; j--)
 	    if (reg_mentioned_p (reg, XVECEXP (in, i, j)))
 	      return 1;
@@ -476,7 +476,7 @@ int
 no_labels_between_p (beg, end)
      rtx beg, end;
 {
-  register rtx p;
+  rtx p;
   if (beg == end)
     return 0;
   for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
@@ -492,7 +492,7 @@ int
 no_jumps_between_p (beg, end)
      rtx beg, end;
 {
-  register rtx p;
+  rtx p;
   for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
     if (GET_CODE (p) == JUMP_INSN)
       return 0;
@@ -506,7 +506,7 @@ int
 reg_used_between_p (reg, from_insn, to_insn)
      rtx reg, from_insn, to_insn;
 {
-  register rtx insn;
+  rtx insn;
 
   if (from_insn == to_insn)
     return 0;
@@ -605,7 +605,7 @@ int
 reg_referenced_between_p (reg, from_insn, to_insn)
      rtx reg, from_insn, to_insn;
 {
-  register rtx insn;
+  rtx insn;
 
   if (from_insn == to_insn)
     return 0;
@@ -626,7 +626,7 @@ int
 reg_set_between_p (reg, from_insn, to_insn)
      rtx reg, from_insn, to_insn;
 {
-  register rtx insn;
+  rtx insn;
 
   if (from_insn == to_insn)
     return 0;
@@ -1218,7 +1218,7 @@ refers_to_regno_p (regno, endregno, x, loc)
 	}
       else if (fmt[i] == 'E')
 	{
-	  register int j;
+	  int j;
 	  for (j = XVECLEN (x, i) - 1; j >=0; j--)
 	    if (loc != &XVECEXP (x, i, j)
 		&& refers_to_regno_p (regno, endregno, XVECEXP (x, i, j), loc))
@@ -1364,7 +1364,7 @@ reg_set_last (x, insn)
      
 void
 note_stores (x, fun, data)
-     register rtx x;
+     rtx x;
      void (*fun) PARAMS ((rtx, rtx, void *));
      void *data;
 {
@@ -1375,7 +1375,7 @@ note_stores (x, fun, data)
 
   if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
     {
-      register rtx dest = SET_DEST (x);
+      rtx dest = SET_DEST (x);
 
       while ((GET_CODE (dest) == SUBREG
 	      && (GET_CODE (SUBREG_REG (dest)) != REG
@@ -1582,7 +1582,7 @@ dead_or_set_regno_p (insn, test_regno)
     }
   else if (GET_CODE (pattern) == PARALLEL)
     {
-      register int i;
+      int i;
 
       for (i = XVECLEN (pattern, 0) - 1; i >= 0; i--)
 	{
@@ -1627,7 +1627,7 @@ find_reg_note (insn, kind, datum)
      enum reg_note kind;
      rtx datum;
 {
-  register rtx link;
+  rtx link;
 
   /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN.  */
   if (! INSN_P (insn))
@@ -1651,7 +1651,7 @@ find_regno_note (insn, kind, regno)
      enum reg_note kind;
      unsigned int regno;
 {
-  register rtx link;
+  rtx link;
 
   /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN.  */
   if (! INSN_P (insn))
@@ -1708,7 +1708,7 @@ find_reg_fusage (insn, code, datum)
 
   if (GET_CODE (datum) != REG)
     {
-      register rtx link;
+      rtx link;
 
       for (link = CALL_INSN_FUNCTION_USAGE (insn);
            link;
@@ -1748,7 +1748,7 @@ find_regno_fusage (insn, code, regno)
      enum rtx_code code;
      unsigned int regno;
 {
-  register rtx link;
+  rtx link;
 
   /* CALL_INSN_FUNCTION_USAGE information cannot contain references
      to pseudo registers, so don't bother checking.  */
@@ -1776,10 +1776,10 @@ find_regno_fusage (insn, code, regno)
 
 void
 remove_note (insn, note)
-     register rtx insn;
-     register rtx note;
+     rtx insn;
+     rtx note;
 {
-  register rtx link;
+  rtx link;
 
   if (note == NULL_RTX)
     return;
@@ -1840,7 +1840,7 @@ int
 volatile_insn_p (x)
      rtx x;
 {
-  register RTX_CODE code;
+  RTX_CODE code;
 
   code = GET_CODE (x);
   switch (code)
@@ -1877,8 +1877,8 @@ volatile_insn_p (x)
   /* Recursively scan the operands of this expression.  */
 
   {
-    register const char *fmt = GET_RTX_FORMAT (code);
-    register int i;
+    const char *fmt = GET_RTX_FORMAT (code);
+    int i;
     
     for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
       {
@@ -1889,7 +1889,7 @@ volatile_insn_p (x)
 	  }
 	else if (fmt[i] == 'E')
 	  {
-	    register int j;
+	    int j;
 	    for (j = 0; j < XVECLEN (x, i); j++)
 	      if (volatile_insn_p (XVECEXP (x, i, j)))
 		return 1;
@@ -1906,7 +1906,7 @@ int
 volatile_refs_p (x)
      rtx x;
 {
-  register RTX_CODE code;
+  RTX_CODE code;
 
   code = GET_CODE (x);
   switch (code)
@@ -1943,8 +1943,8 @@ volatile_refs_p (x)
   /* Recursively scan the operands of this expression.  */
 
   {
-    register const char *fmt = GET_RTX_FORMAT (code);
-    register int i;
+    const char *fmt = GET_RTX_FORMAT (code);
+    int i;
     
     for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
       {
@@ -1955,7 +1955,7 @@ volatile_refs_p (x)
 	  }
 	else if (fmt[i] == 'E')
 	  {
-	    register int j;
+	    int j;
 	    for (j = 0; j < XVECLEN (x, i); j++)
 	      if (volatile_refs_p (XVECEXP (x, i, j)))
 		return 1;
@@ -1972,7 +1972,7 @@ int
 side_effects_p (x)
      rtx x;
 {
-  register RTX_CODE code;
+  RTX_CODE code;
 
   code = GET_CODE (x);
   switch (code)
@@ -2020,8 +2020,8 @@ side_effects_p (x)
   /* Recursively scan the operands of this expression.  */
 
   {
-    register const char *fmt = GET_RTX_FORMAT (code);
-    register int i;
+    const char *fmt = GET_RTX_FORMAT (code);
+    int i;
     
     for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
       {
@@ -2032,7 +2032,7 @@ side_effects_p (x)
 	  }
 	else if (fmt[i] == 'E')
 	  {
-	    register int j;
+	    int j;
 	    for (j = 0; j < XVECLEN (x, i); j++)
 	      if (side_effects_p (XVECEXP (x, i, j)))
 		return 1;
@@ -2140,7 +2140,7 @@ may_trap_p (x)
 	}
       else if (fmt[i] == 'E')
 	{
-	  register int j;
+	  int j;
 	  for (j = 0; j < XVECLEN (x, i); j++)
 	    if (may_trap_p (XVECEXP (x, i, j)))
 	      return 1;
@@ -2156,9 +2156,9 @@ int
 inequality_comparisons_p (x)
      rtx x;
 {
-  register const char *fmt;
-  register int len, i;
-  register enum rtx_code code = GET_CODE (x);
+  const char *fmt;
+  int len, i;
+  enum rtx_code code = GET_CODE (x);
 
   switch (code)
     {
@@ -2199,7 +2199,7 @@ inequality_comparisons_p (x)
 	}
       else if (fmt[i] == 'E')
 	{
-	  register int j;
+	  int j;
 	  for (j = XVECLEN (x, i) - 1; j >= 0; j--)
 	    if (inequality_comparisons_p (XVECEXP (x, i, j)))
 	      return 1;
@@ -2219,8 +2219,8 @@ rtx
 replace_rtx (x, from, to)
      rtx x, from, to;
 {
-  register int i, j;
-  register const char *fmt;
+  int i, j;
+  const char *fmt;
 
   /* The following prevents loops occurrence when we change MEM in
      CONST_DOUBLE onto the same CONST_DOUBLE.  */
@@ -2266,9 +2266,9 @@ replace_regs (x, reg_map, nregs, replace_dest)
      unsigned int nregs;
      int replace_dest;
 {
-  register enum rtx_code code;
-  register int i;
-  register const char *fmt;
+  enum rtx_code code;
+  int i;
+  const char *fmt;
 
   if (x == 0)
     return x;
@@ -2341,7 +2341,7 @@ replace_regs (x, reg_map, nregs, replace_dest)
 	XEXP (x, i) = replace_regs (XEXP (x, i), reg_map, nregs, replace_dest);
       else if (fmt[i] == 'E')
 	{
-	  register int j;
+	  int j;
 	  for (j = 0; j < XVECLEN (x, i); j++)
 	    XVECEXP (x, i, j) = replace_regs (XVECEXP (x, i, j), reg_map,
 					      nregs, replace_dest);
@@ -2527,7 +2527,7 @@ regno_use_in (regno, x)
      unsigned int regno;
      rtx x;
 {
-  register const char *fmt;
+  const char *fmt;
   int i, j;
   rtx tem;
 
diff --git a/gcc/scan.c b/gcc/scan.c
index 4af6a43a702..e9a9a4b5d25 100644
--- a/gcc/scan.c
+++ b/gcc/scan.c
@@ -45,8 +45,9 @@ sstring_append (dst, src)
      sstring *dst;
      sstring *src;
 {
-  register char *d, *s;
-  register int count = SSTRING_LENGTH(src);
+  char *d, *s;
+  int count = SSTRING_LENGTH(src);
+
   MAKE_SSTRING_SPACE(dst, count + 1);
   d = dst->ptr;
   s = src->base;
@@ -57,8 +58,8 @@ sstring_append (dst, src)
 
 int
 scan_ident (fp, s, c)
-     register FILE *fp;
-     register sstring *s;
+     FILE *fp;
+     sstring *s;
      int c;
 {
   s->ptr = s->base;
@@ -79,11 +80,12 @@ scan_ident (fp, s, c)
 
 int
 scan_string (fp, s, init)
-     register FILE *fp;
-     register sstring *s;
+     FILE *fp;
+     sstring *s;
      int init;
 {
   int c;
+
   for (;;)
     {
       c = getc (fp);
@@ -113,7 +115,7 @@ scan_string (fp, s, init)
 
 int
 skip_spaces (fp, c)
-     register FILE *fp;
+     FILE *fp;
      int c;
 {
   for (;;)
@@ -156,6 +158,7 @@ read_upto (fp, str, delim)
      int delim;
 {
   int ch;
+
   for (;;)
     {
       ch = getc (fp);
@@ -170,10 +173,11 @@ read_upto (fp, str, delim)
 
 int
 get_token (fp, s)
-     register FILE *fp;
-     register sstring *s;
+     FILE *fp;
+     sstring *s;
 {
   int c;
+
   s->ptr = s->base;
  retry:
   c = ' ';
diff --git a/gcc/sched-deps.c b/gcc/sched-deps.c
index abb02c439ab..9d53200d75a 100644
--- a/gcc/sched-deps.c
+++ b/gcc/sched-deps.c
@@ -488,7 +488,7 @@ add_insn_mem_dependence (deps, insn_list, mem_list, insn, mem)
      struct deps *deps;
      rtx *insn_list, *mem_list, insn, mem;
 {
-  register rtx link;
+  rtx link;
 
   link = alloc_INSN_LIST (insn, *insn_list);
   *insn_list = link;
@@ -564,8 +564,8 @@ sched_analyze_1 (deps, x, insn)
      rtx x;
      rtx insn;
 {
-  register int regno;
-  register rtx dest = XEXP (x, 0);
+  int regno;
+  rtx dest = XEXP (x, 0);
   enum rtx_code code = GET_CODE (x);
 
   if (dest == 0)
@@ -573,7 +573,7 @@ sched_analyze_1 (deps, x, insn)
 
   if (GET_CODE (dest) == PARALLEL)
     {
-      register int i;
+      int i;
 
       for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
 	if (XEXP (XVECEXP (dest, 0, i), 0) != 0)
@@ -601,7 +601,7 @@ sched_analyze_1 (deps, x, insn)
 
   if (GET_CODE (dest) == REG)
     {
-      register int i;
+      int i;
 
       regno = REGNO (dest);
 
@@ -759,10 +759,10 @@ sched_analyze_2 (deps, x, insn)
      rtx x;
      rtx insn;
 {
-  register int i;
-  register int j;
-  register enum rtx_code code;
-  register const char *fmt;
+  int i;
+  int j;
+  enum rtx_code code;
+  const char *fmt;
 
   if (x == 0)
     return;
@@ -1007,7 +1007,7 @@ sched_analyze_insn (deps, x, insn, loop_notes)
      rtx x, insn;
      rtx loop_notes;
 {
-  register RTX_CODE code = GET_CODE (x);
+  RTX_CODE code = GET_CODE (x);
   int schedule_barrier_found = 0;
   rtx link;
   int i;
@@ -1025,7 +1025,7 @@ sched_analyze_insn (deps, x, insn, loop_notes)
     sched_analyze_1 (deps, x, insn);
   else if (code == PARALLEL)
     {
-      register int i;
+      int i;
       for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
 	{
 	  rtx sub = XVECEXP (x, 0, i);
@@ -1264,8 +1264,8 @@ sched_analyze (deps, head, tail)
      struct deps *deps;
      rtx head, tail;
 {
-  register rtx insn;
-  register rtx u;
+  rtx insn;
+  rtx u;
   rtx loop_notes = 0;
 
   if (current_sched_info->use_cselib)
@@ -1298,7 +1298,7 @@ sched_analyze (deps, head, tail)
       else if (GET_CODE (insn) == CALL_INSN)
 	{
 	  rtx x;
-	  register int i;
+	  int i;
 
 	  /* Clear out stale SCHED_GROUP_P.  */
 	  SCHED_GROUP_P (insn) = 0;
diff --git a/gcc/sched-rgn.c b/gcc/sched-rgn.c
index 8426b4317ab..168ce8de3fd 100644
--- a/gcc/sched-rgn.c
+++ b/gcc/sched-rgn.c
@@ -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.  */
diff --git a/gcc/sdbout.c b/gcc/sdbout.c
index becc4e3fa48..a1180e2ec24 100644
--- a/gcc/sdbout.c
+++ b/gcc/sdbout.c
@@ -429,7 +429,7 @@ static int
 template_name_p (name)
      tree name;
 {
-  register const char *ptr = IDENTIFIER_POINTER (name);
+  const char *ptr = IDENTIFIER_POINTER (name);
   while (*ptr && *ptr != '<')
     ptr++;
 
@@ -661,7 +661,7 @@ static int do_block = 0;
 
 static void
 sdbout_block (block)
-     register tree block;
+     tree block;
 {
   while (block)
     {
@@ -999,7 +999,7 @@ sdbout_queue_anonymous_type (type)
 static void
 sdbout_dequeue_anonymous_types ()
 {
-  register tree types, link;
+  tree types, link;
 
   while (anonymous_types)
     {
@@ -1008,7 +1008,7 @@ sdbout_dequeue_anonymous_types ()
 
       for (link = types; link; link = TREE_CHAIN (link))
 	{
-	  register tree type = TREE_VALUE (link);
+	  tree type = TREE_VALUE (link);
 
 	  if (type && ! TREE_ASM_WRITTEN (type))
 	    sdbout_one_type (type);
@@ -1023,9 +1023,9 @@ sdbout_dequeue_anonymous_types ()
 
 void
 sdbout_types (types)
-     register tree types;
+     tree types;
 {
-  register tree link;
+  tree link;
 
   for (link = types; link; link = TREE_CHAIN (link))
     sdbout_one_type (link);
@@ -1697,7 +1697,7 @@ sdbout_end_epilogue ()
 
 static void
 sdbout_label (insn)
-     register rtx insn;
+     rtx insn;
 {
   PUT_SDB_DEF (LABEL_NAME (insn));
   PUT_SDB_VAL (insn);
diff --git a/gcc/simplify-rtx.c b/gcc/simplify-rtx.c
index 5e869bd7dec..2b7e3a2ac7a 100644
--- a/gcc/simplify-rtx.c
+++ b/gcc/simplify-rtx.c
@@ -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;
diff --git a/gcc/stmt.c b/gcc/stmt.c
index ace1490cd3d..b7ced6a8eca 100644
--- a/gcc/stmt.c
+++ b/gcc/stmt.c
@@ -1040,7 +1040,7 @@ expand_fixup (tree_label, rtl_label, last_insn)
 	 as a placeholder.  */
 
       {
-        register rtx original_before_jump
+        rtx original_before_jump
           = last_insn ? last_insn : get_last_insn ();
 	rtx start;
 	rtx end;
@@ -1118,7 +1118,7 @@ fixup_gotos (thisblock, stack_level, cleanup_list, first_insn, dont_jump_in)
      rtx first_insn;
      int dont_jump_in;
 {
-  register struct goto_fixup *f, *prev;
+  struct goto_fixup *f, *prev;
 
   /* F is the fixup we are considering; PREV is the previous one.  */
   /* We run this loop in two passes so that cleanups of exited blocks
@@ -1138,7 +1138,7 @@ fixup_gotos (thisblock, stack_level, cleanup_list, first_insn, dont_jump_in)
 	 If so, we can finalize it.  */
       else if (PREV_INSN (f->target_rtl) != 0)
 	{
-	  register rtx cleanup_insns;
+	  rtx cleanup_insns;
 
 	  /* If this fixup jumped into this contour from before the beginning
 	     of this contour, report an error.   This code used to use
@@ -1485,7 +1485,7 @@ expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
   int ninout = 0;
   int nclobbers;
   tree tail;
-  register int i;
+  int i;
   /* Vector of RTX's of evaluated output operands.  */
   rtx *output_rtx = (rtx *) alloca (noutputs * sizeof (rtx));
   int *inout_opnum = (int *) alloca (noutputs * sizeof (int));
@@ -2333,7 +2333,7 @@ struct nesting *
 expand_start_loop (exit_flag)
      int exit_flag;
 {
-  register struct nesting *thisloop = ALLOC_NESTING ();
+  struct nesting *thisloop = ALLOC_NESTING ();
 
   /* Make an entry on loop_stack for the loop we are entering.  */
 
@@ -2374,7 +2374,7 @@ expand_start_loop_continue_elsewhere (exit_flag)
 struct nesting *
 expand_start_null_loop ()
 {
-  register struct nesting *thisloop = ALLOC_NESTING ();
+  struct nesting *thisloop = ALLOC_NESTING ();
 
   /* Make an entry on loop_stack for the loop we are entering.  */
 
@@ -2655,8 +2655,8 @@ expand_end_loop ()
 	  /* We found one.  Move everything from there up
 	     to the end of the loop, and add a jump into the loop
 	     to jump to there.  */
-	  register rtx newstart_label = gen_label_rtx ();
-	  register rtx start_move = start_label;
+	  rtx newstart_label = gen_label_rtx ();
+	  rtx start_move = start_label;
 	  rtx next_insn;
 
 	  /* If the start label is preceded by a NOTE_INSN_LOOP_CONT note,
@@ -2945,7 +2945,7 @@ expand_return (retval)
      computation of the return value.  */
   rtx last_insn = 0;
   rtx result_rtl;
-  register rtx val = 0;
+  rtx val = 0;
   tree retval_rhs;
 
   /* If function wants no value, give it none.  */
@@ -3197,9 +3197,9 @@ static int
 tail_recursion_args (actuals, formals)
      tree actuals, formals;
 {
-  register tree a = actuals, f = formals;
-  register int i;
-  register rtx *argvec;
+  tree a = actuals, f = formals;
+  int i;
+  rtx *argvec;
 
   /* Check that number and types of actuals are compatible
      with the formals.  This is not always true in valid C code.
@@ -3232,7 +3232,7 @@ tail_recursion_args (actuals, formals)
   for (a = actuals, i = 0; a; a = TREE_CHAIN (a), i++)
     {
       int copy = 0;
-      register int j;
+      int j;
       for (f = formals, j = 0; j < i; f = TREE_CHAIN (f), j++)
 	if (reg_mentioned_p (DECL_RTL (f), argvec[i]))
 	  {
@@ -3387,7 +3387,7 @@ expand_end_target_temps ()
 
 int
 is_body_block (stmt)
-     register tree stmt;
+     tree stmt;
 {
   if (TREE_CODE (stmt) == BLOCK)
     {
@@ -3619,7 +3619,7 @@ expand_end_bindings (vars, mark_ends, dont_jump_in)
      int mark_ends;
      int dont_jump_in;
 {
-  register struct nesting *thisblock = block_stack;
+  struct nesting *thisblock = block_stack;
 
   /* If any of the variables in this scope were not used, warn the
      user.  */
@@ -3764,7 +3764,7 @@ save_stack_pointer ()
 
 void
 expand_decl (decl)
-     register tree decl;
+     tree decl;
 {
   struct nesting *thisblock;
   tree type;
@@ -4311,7 +4311,7 @@ expand_start_case (exit_flag, expr, type, printname)
      tree type;
      const char *printname;
 {
-  register struct nesting *thiscase = ALLOC_NESTING ();
+  struct nesting *thiscase = ALLOC_NESTING ();
 
   /* Make an entry on case_stack for the case we are entering.  */
 
@@ -4348,7 +4348,7 @@ expand_start_case (exit_flag, expr, type, printname)
 void
 expand_start_case_dummy ()
 {
-  register struct nesting *thiscase = ALLOC_NESTING ();
+  struct nesting *thiscase = ALLOC_NESTING ();
 
   /* Make an entry on case_stack for the dummy.  */
 
@@ -4439,9 +4439,9 @@ check_seenlabel ()
 
 int
 pushcase (value, converter, label, duplicate)
-     register tree value;
+     tree value;
      tree (*converter) PARAMS ((tree, tree));
-     register tree label;
+     tree label;
      tree *duplicate;
 {
   tree index_type;
@@ -4489,9 +4489,9 @@ pushcase (value, converter, label, duplicate)
 
 int
 pushcase_range (value1, value2, converter, label, duplicate)
-     register tree value1, value2;
+     tree value1, value2;
      tree (*converter) PARAMS ((tree, tree));
-     register tree label;
+     tree label;
      tree *duplicate;
 {
   tree index_type;
@@ -4882,7 +4882,7 @@ mark_seen_cases (type, cases_seen, count, sparseness)
   tree next_node_to_try = NULL_TREE;
   HOST_WIDE_INT next_node_offset = 0;
 
-  register struct case_node *n, *root = case_stack->data.case_stmt.case_list;
+  struct case_node *n, *root = case_stack->data.case_stmt.case_list;
   tree val = make_node (INTEGER_CST);
 
   TREE_TYPE (val) = type;
@@ -5011,8 +5011,8 @@ void
 check_for_full_enumeration_handling (type)
      tree type;
 {
-  register struct case_node *n;
-  register tree chain;
+  struct case_node *n;
+  tree chain;
 
   /* True iff the selector type is a numbered set mode.  */
   int sparseness = 0;
@@ -5138,15 +5138,15 @@ expand_end_case (orig_index)
 {
   tree minval = NULL_TREE, maxval = NULL_TREE, range = NULL_TREE, orig_minval;
   rtx default_label = 0;
-  register struct case_node *n;
+  struct case_node *n;
   unsigned int count;
   rtx index;
   rtx table_label;
   int ncases;
   rtx *labelvec;
-  register int i;
+  int i;
   rtx before_case, end;
-  register struct nesting *thiscase = case_stack;
+  struct nesting *thiscase = case_stack;
   tree index_expr, index_type;
   int unsignedp;
 
@@ -5366,7 +5366,7 @@ expand_end_case (orig_index)
 
 	  for (n = thiscase->data.case_stmt.case_list; n; n = n->right)
 	    {
-	      register HOST_WIDE_INT i
+	      HOST_WIDE_INT i
 		= TREE_INT_CST_LOW (n->low) - TREE_INT_CST_LOW (orig_minval);
 
 	      while (1)
@@ -5614,7 +5614,7 @@ balance_case_nodes (head, parent)
      case_node_ptr *head;
      case_node_ptr parent;
 {
-  register case_node_ptr np;
+  case_node_ptr np;
 
   np = *head;
   if (np)
@@ -5622,7 +5622,7 @@ balance_case_nodes (head, parent)
       int cost = 0;
       int i = 0;
       int ranges = 0;
-      register case_node_ptr *npp;
+      case_node_ptr *npp;
       case_node_ptr left;
 
       /* Count the number of entries on branch.  Also count the ranges.  */
diff --git a/gcc/stor-layout.c b/gcc/stor-layout.c
index 3ff8726b1a3..9de3233821a 100644
--- a/gcc/stor-layout.c
+++ b/gcc/stor-layout.c
@@ -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)
diff --git a/gcc/toplev.c b/gcc/toplev.c
index 473decb9111..e940aa6a7ac 100644
--- a/gcc/toplev.c
+++ b/gcc/toplev.c
@@ -1638,9 +1638,9 @@ botch (s)
 
 int
 exact_log2_wide (x)
-     register unsigned HOST_WIDE_INT x;
+     unsigned HOST_WIDE_INT x;
 {
-  register int log = 0;
+  int log = 0;
   /* Test for 0 or a power of 2.  */
   if (x == 0 || x != (x & -x))
     return -1;
@@ -1656,9 +1656,9 @@ exact_log2_wide (x)
 
 int
 floor_log2_wide (x)
-     register unsigned HOST_WIDE_INT x;
+     unsigned HOST_WIDE_INT x;
 {
-  register int log = -1;
+  int log = -1;
   while (x != 0)
     log++,
     x >>= 1;
@@ -2613,7 +2613,7 @@ void
 rest_of_compilation (decl)
      tree decl;
 {
-  register rtx insns;
+  rtx insns;
   int tem;
   int failure = 0;
   int rebuild_label_notes_after_reload;
@@ -4612,7 +4612,7 @@ toplev_main (argc, argv)
      int argc;
      char **argv;
 {
-  register int i;
+  int i;
   char *p;
 
   /* save in case md file wants to emit args as a comment.  */
@@ -4986,7 +4986,7 @@ static void
 set_target_switch (name)
      const char *name;
 {
-  register size_t j;
+  size_t j;
   int valid_target_option = 0;
 
   for (j = 0; j < ARRAY_SIZE (target_switches); j++)
diff --git a/gcc/tradcif.y b/gcc/tradcif.y
index e59fd1e5b7c..1f8eb2858fc 100644
--- a/gcc/tradcif.y
+++ b/gcc/tradcif.y
@@ -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)++;
diff --git a/gcc/tradcpp.c b/gcc/tradcpp.c
index 3ceeceffb95..2c47a697b10 100644
--- a/gcc/tradcpp.c
+++ b/gcc/tradcpp.c
@@ -1075,8 +1075,8 @@ static void
 newline_fix (bp)
      U_CHAR *bp;
 {
-  register U_CHAR *p = bp;
-  register int count = 0;
+  U_CHAR *p = bp;
+  int count = 0;
 
   /* First count the backslash-newline pairs here.  */
 
@@ -1110,8 +1110,8 @@ static void
 name_newline_fix (bp)
      U_CHAR *bp;
 {
-  register U_CHAR *p = bp;
-  register int count = 0;
+  U_CHAR *p = bp;
+  int count = 0;
 
   /* First count the backslash-newline pairs here.  */
 
@@ -1181,25 +1181,25 @@ rescan (op, output_marks)
      int output_marks;
 {
   /* Character being scanned in main loop.  */
-  register U_CHAR c;
+  U_CHAR c;
 
   /* Length of pending accumulated identifier.  */
-  register int ident_length = 0;
+  int ident_length = 0;
 
   /* Hash code of pending accumulated identifier.  */
-  register int hash = 0;
+  int hash = 0;
 
   /* Current input level (&instack[indepth]).  */
   FILE_BUF *ip;
 
   /* Pointer for scanning input.  */
-  register U_CHAR *ibp;
+  U_CHAR *ibp;
 
   /* Pointer to end of input.  End of scan is controlled by LIMIT.  */
-  register U_CHAR *limit;
+  U_CHAR *limit;
 
   /* Pointer for storing output.  */
-  register U_CHAR *obp;
+  U_CHAR *obp;
 
   /* REDO_CHAR is nonzero if we are processing an identifier
      after backing up over the terminating character.
@@ -1629,7 +1629,7 @@ specialchar:
 randomchar:
 
       if (ident_length > 0) {
-	register HASHNODE *hp;
+	HASHNODE *hp;
 
 	/* We have just seen an identifier end.  If it's a macro, expand it.
 
@@ -1654,9 +1654,9 @@ randomchar:
 	    /* obufp_before_macroname is used only in this block,
                but it has to be global because of RECACHE.  */
 	    int op_lineno_before_macroname;
-	    register int i = ident_length;
-	    register U_CHAR *p = hp->name;
-	    register U_CHAR *q = obp - i;
+	    int i = ident_length;
+	    U_CHAR *p = hp->name;
+	    U_CHAR *q = obp - i;
 
 	    if (! redo_char)
 	      q--;
@@ -1821,7 +1821,7 @@ expand_to_temp_buffer (buf, limit, output_marks)
      const U_CHAR *buf, *limit;
      int output_marks;
 {
-  register FILE_BUF *ip;
+  FILE_BUF *ip;
   FILE_BUF obuf;
   int length = limit - buf;
   U_CHAR *buf1;
@@ -1834,8 +1834,8 @@ expand_to_temp_buffer (buf, limit, output_marks)
 
   buf1 = (U_CHAR *) alloca (length + 1);
   {
-    register const U_CHAR *p1 = buf;
-    register U_CHAR *p2 = buf1;
+    const U_CHAR *p1 = buf;
+    U_CHAR *p2 = buf1;
 
     while (p1 != limit)
       *p2++ = *p1++;
@@ -1898,9 +1898,9 @@ static int
 handle_directive (ip, op)
      FILE_BUF *ip, *op;
 {
-  register U_CHAR *bp, *cp;
-  register struct directive *kt;
-  register int ident_length;
+  U_CHAR *bp, *cp;
+  struct directive *kt;
+  int ident_length;
   U_CHAR *resume_p;
 
   /* Nonzero means we must copy the entire command
@@ -1957,8 +1957,8 @@ handle_directive (ip, op)
   for (kt = directive_table; kt->length > 0; kt++) {
     if (kt->length == ident_length
 	&& !strncmp (kt->name, (const char *)ident, ident_length)) {
-      register U_CHAR *buf;
-      register U_CHAR *limit = ip->buf + ip->length;
+      U_CHAR *buf;
+      U_CHAR *limit = ip->buf + ip->length;
       int unterminated = 0;
 
       /* Nonzero means do not delete comments within the directive.
@@ -1972,7 +1972,7 @@ handle_directive (ip, op)
 
       buf = bp = after_ident;
       while (bp < limit) {
-	register U_CHAR c = *bp++;
+	U_CHAR c = *bp++;
 	switch (c) {
 	case '\\':
 	  if (bp < limit) {
@@ -2036,7 +2036,7 @@ handle_directive (ip, op)
 	 A comment may come between.  */
 
       if (copy_command) {
-	register U_CHAR *xp = buf;
+	U_CHAR *xp = buf;
 	/* Need to copy entire command into temp buffer before dispatching */
 
 	cp = (U_CHAR *) alloca (bp - buf + 5); /* room for cmd plus
@@ -2047,7 +2047,7 @@ handle_directive (ip, op)
 	   and backslash-newlines (and whitespace surrounding the latter).  */
 
 	while (xp < bp) {
-	  register U_CHAR c = *xp++;
+	  U_CHAR c = *xp++;
 	  *cp++ = c;
 
 	  switch (c) {
@@ -2087,7 +2087,7 @@ handle_directive (ip, op)
 	  case '\'':
 	  case '\"':
 	    {
-	      register const U_CHAR *bp1
+	      const U_CHAR *bp1
 		= skip_quoted_string (xp - 1, limit, ip->lineno, 0, 0, 0);
 	      while (xp != bp1)
 		*cp++ = *xp++;
@@ -2825,9 +2825,9 @@ static int
 compare_defs (d1, d2)
      DEFINITION *d1, *d2;
 {
-  register struct reflist *a1, *a2;
-  register U_CHAR *p1 = d1->expansion;
-  register U_CHAR *p2 = d2->expansion;
+  struct reflist *a1, *a2;
+  U_CHAR *p1 = d1->expansion;
+  U_CHAR *p2 = d2->expansion;
   int first = 1;
 
   if (d1->nargs != d2->nargs)
@@ -2871,8 +2871,8 @@ comp_def_part (first, beg1, len1, beg2, len2, last)
      int len1, len2;
      int last;
 {
-  register const U_CHAR *end1 = beg1 + len1;
-  register const U_CHAR *end2 = beg2 + len2;
+  const U_CHAR *end1 = beg1 + len1;
+  const U_CHAR *end2 = beg2 + len2;
   if (first) {
     while (beg1 != end1 && is_space (*beg1)) beg1++;
     while (beg2 != end2 && is_space (*beg2)) beg2++;
@@ -2920,7 +2920,7 @@ collect_expansion (buf, end, nargs, arglist)
      struct arglist *arglist;
 {
   DEFINITION *defn;
-  register U_CHAR *p, *limit, *lastp, *exp_p;
+  U_CHAR *p, *limit, *lastp, *exp_p;
   struct reflist *endpat = NULL;
   /* Pointer to first nonspace after last ## seen.  */
   U_CHAR *concat = 0;
@@ -2969,7 +2969,7 @@ collect_expansion (buf, end, nargs, arglist)
   /* Process the main body of the definition.  */
   while (p < limit) {
     int skipped_arg = 0;
-    register U_CHAR c = *p++;
+    U_CHAR c = *p++;
 
     *exp_p++ = c;
 
@@ -3020,7 +3020,7 @@ collect_expansion (buf, end, nargs, arglist)
       id_len = p - id_beg;
 
       if (is_idstart (c)) {
-	register struct arglist *arg;
+	struct arglist *arg;
 
 	for (arg = arglist; arg != NULL; arg = arg->next) {
 	  struct reflist *tpat;
@@ -3046,7 +3046,7 @@ collect_expansion (buf, end, nargs, arglist)
 	    tpat->argno = arg->argno;
 	    tpat->nchars = exp_p - lastp;
 	    {
-	      register U_CHAR *p1 = p;
+	      U_CHAR *p1 = p;
 	      SKIP_WHITE_SPACE (p1);
 	      if (p1 + 2 <= limit && p1[0] == '#' && p1[1] == '#')
 		tpat->raw_after = 1;
@@ -3060,7 +3060,7 @@ collect_expansion (buf, end, nargs, arglist)
 
       /* If this was not a macro arg, copy it into the expansion.  */
       if (! skipped_arg) {
-	register U_CHAR *lim1 = p;
+	U_CHAR *lim1 = p;
 	p = id_beg;
 	while (p != lim1)
 	  *exp_p++ = *p++;
@@ -3098,7 +3098,7 @@ do_line (buf, limit, op)
      U_CHAR *buf, *limit;
      FILE_BUF *op;
 {
-  register U_CHAR *bp;
+  U_CHAR *bp;
   FILE_BUF *ip = &instack[indepth];
   FILE_BUF tem;
   int new_lineno;
@@ -3677,8 +3677,8 @@ skip_if_group (ip, any)
      FILE_BUF *ip;
      int any;
 {
-  register U_CHAR *bp = ip->bufp, *cp;
-  register U_CHAR *endb = ip->buf + ip->length;
+  U_CHAR *bp = ip->bufp, *cp;
+  U_CHAR *endb = ip->buf + ip->length;
   struct directive *kt;
   IF_STACK_FRAME *save_if_stack = if_stack; /* don't pop past here */
   U_CHAR *beg_of_line = bp;
@@ -3897,11 +3897,11 @@ do_endif (buf, limit, op)
  */
 static U_CHAR *
 skip_to_end_of_comment (ip, line_counter)
-     register FILE_BUF *ip;
+     FILE_BUF *ip;
      int *line_counter;		/* place to remember newlines, or NULL */
 {
-  register U_CHAR *limit = ip->buf + ip->length;
-  register U_CHAR *bp = ip->bufp;
+  U_CHAR *limit = ip->buf + ip->length;
+  U_CHAR *bp = ip->bufp;
   FILE_BUF *op = &outbuf;	/* JF */
   int output = put_out_comments && !line_counter;
 
@@ -3960,14 +3960,14 @@ skip_to_end_of_comment (ip, line_counter)
  */
 static U_CHAR *
 skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p, eofp)
-     register const U_CHAR *bp;
-     register const U_CHAR *limit;
+     const U_CHAR *bp;
+     const U_CHAR *limit;
      int start_line;
      int *count_newlines;
      int *backslash_newlines_p;
      int *eofp;
 {
-  register U_CHAR c, match;
+  U_CHAR c, match;
 
   match = *bp++;
   while (1) {
@@ -4076,7 +4076,7 @@ macroexpand (hp, op)
 {
   int nargs;
   DEFINITION *defn = hp->value.defn;
-  register U_CHAR *xbuf;
+  U_CHAR *xbuf;
   int xbuf_len;
   int start_line = instack[indepth].lineno;
 
@@ -4091,7 +4091,7 @@ macroexpand (hp, op)
   nargs = defn->nargs;
 
   if (nargs >= 0) {
-    register int i;
+    int i;
     struct argdata *args;
     const char *parse_error = 0;
 
@@ -4123,8 +4123,8 @@ macroexpand (hp, op)
 
     /* If we got one arg but it was just whitespace, call that 0 args.  */
     if (i == 1) {
-      register const U_CHAR *bp = args[0].raw;
-      register const U_CHAR *lim = bp + args[0].raw_length;
+      const U_CHAR *bp = args[0].raw;
+      const U_CHAR *lim = bp + args[0].raw_length;
       while (bp != lim && is_space (*bp)) bp++;
       if (bp == lim)
 	i = 0;
@@ -4154,12 +4154,12 @@ macroexpand (hp, op)
       xbuf = defn->expansion;
       xbuf_len = defn->length;
     } else {
-      register U_CHAR *exp = defn->expansion;
-      register int offset;	/* offset in expansion,
+      U_CHAR *exp = defn->expansion;
+      int offset;	/* offset in expansion,
 				   copied a piece at a time */
-      register int totlen;	/* total amount of exp buffer filled so far */
+      int totlen;	/* total amount of exp buffer filled so far */
 
-      register struct reflist *ap;
+      struct reflist *ap;
 
       /* Macro really takes args.  Compute the expansion of this call.  */
 
@@ -4181,7 +4181,7 @@ macroexpand (hp, op)
 	 of where we are copying from.  */
       offset = totlen = 0;
       for (ap = defn->pattern; ap != NULL; ap = ap->next) {
-	register struct argdata *arg = &args[ap->argno];
+	struct argdata *arg = &args[ap->argno];
 
 	for (i = 0; i < ap->nchars; i++)
 	  xbuf[totlen++] = exp[offset++];
@@ -4312,7 +4312,7 @@ macroexpand (hp, op)
   /* Now put the expansion on the input stack
      so our caller will commence reading from it.  */
   {
-    register FILE_BUF *ip2;
+    FILE_BUF *ip2;
 
     ip2 = &instack[++indepth];
 
@@ -4334,7 +4334,7 @@ macroexpand (hp, op)
 
 static const char *
 macarg (argptr)
-     register struct argdata *argptr;
+     struct argdata *argptr;
 {
   FILE_BUF *ip = &instack[indepth];
   int paren = 0;
@@ -4420,8 +4420,8 @@ macarg (argptr)
 
   if (argptr != 0) {
     FILE_BUF obuf;
-    register const U_CHAR *buf, *lim;
-    register int totlen;
+    const U_CHAR *buf, *lim;
+    int totlen;
 
     obuf = expand_to_temp_buffer (argptr->raw,
 				  argptr->raw + argptr->raw_length,
@@ -4436,7 +4436,7 @@ macarg (argptr)
 
     totlen = 0;
     while (buf != lim) {
-      register U_CHAR c = *buf++;
+      U_CHAR c = *buf++;
       totlen++;
       /* Internal sequences of whitespace are replaced by one space
 	 in most cases, but not always.  So count all the whitespace
@@ -4466,10 +4466,10 @@ macarg (argptr)
 static U_CHAR *
 macarg1 (start, limit, depthptr, newlines, comments)
      U_CHAR *start;
-     register const U_CHAR *limit;
+     const U_CHAR *limit;
      int *depthptr, *newlines, *comments;
 {
-  register U_CHAR *bp = start;
+  U_CHAR *bp = start;
 
   while (bp < limit) {
     switch (*bp) {
@@ -4557,10 +4557,10 @@ discard_comments (start, length, newlines)
      int length;
      int newlines;
 {
-  register U_CHAR *ibp;
-  register U_CHAR *obp;
-  register const U_CHAR *limit;
-  register int c;
+  U_CHAR *ibp;
+  U_CHAR *obp;
+  const U_CHAR *limit;
+  int c;
 
   /* If we have newlines to duplicate, copy everything
      that many characters up.  Then, in the second part,
@@ -4797,10 +4797,10 @@ line_for_error (line)
 
 static void
 grow_outbuf (obuf, needed)
-     register FILE_BUF *obuf;
-     register int needed;
+     FILE_BUF *obuf;
+     int needed;
 {
-  register U_CHAR *p;
+  U_CHAR *p;
   int minsize;
 
   if (obuf->length - (obuf->bufp - obuf->buf) > needed)
@@ -4844,9 +4844,9 @@ install (name, len, type, hash)
      int hash;
         /* watch out here if sizeof (U_CHAR *) != sizeof (int) */
 {
-  register HASHNODE *hp;
-  register int bucket;
-  register const U_CHAR *p;
+  HASHNODE *hp;
+  int bucket;
+  const U_CHAR *p;
   U_CHAR *q;
 
   if (len < 0) {
@@ -4891,8 +4891,8 @@ lookup (name, len, hash)
      int len;
      int hash;
 {
-  register const U_CHAR *bp;
-  register HASHNODE *bucket;
+  const U_CHAR *bp;
+  HASHNODE *bucket;
 
   if (len < 0) {
     for (bp = name; is_idchar (*bp); bp++) ;
@@ -4949,11 +4949,11 @@ delete_macro (hp)
  */
 static int
 hashf (name, len, hashsize)
-     register const U_CHAR *name;
-     register int len;
+     const U_CHAR *name;
+     int len;
      int hashsize;
 {
-  register int r = 0;
+  int r = 0;
 
   while (len--)
     r = HASHSTEP (r, *name++);
@@ -4969,11 +4969,11 @@ dump_all_macros ()
   int bucket;
 
   for (bucket = 0; bucket < HASHSIZE; bucket++) {
-    register HASHNODE *hp;
+    HASHNODE *hp;
 
     for (hp = hashtab[bucket]; hp; hp= hp->next) {
       if (hp->type == T_MACRO) {
-	register DEFINITION *defn = hp->value.defn;
+	DEFINITION *defn = hp->value.defn;
 	struct reflist *ap;
 	int offset;
 	int concat;
@@ -5055,7 +5055,7 @@ dump_arg_n (defn, argnum)
      DEFINITION *defn;
      int argnum;
 {
-  register const U_CHAR *p = defn->argnames;
+  const U_CHAR *p = defn->argnames;
   while (argnum + 1 < defn->nargs) {
     p = (const U_CHAR *) strchr ((const char *)p, ' ') + 1;
     argnum++;
diff --git a/gcc/tree.c b/gcc/tree.c
index 62b07600497..a65bfb5e0b6 100644
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -326,11 +326,11 @@ tree
 make_node (code)
      enum tree_code code;
 {
-  register tree t;
-  register int type = TREE_CODE_CLASS (code);
-  register size_t length;
+  tree t;
+  int type = TREE_CODE_CLASS (code);
+  size_t length;
 #ifdef GATHER_STATISTICS
-  register tree_node_kind kind;
+  tree_node_kind kind;
 #endif
   struct tree_common ttmp;
   
@@ -485,9 +485,9 @@ tree
 copy_node (node)
      tree node;
 {
-  register tree t;
-  register enum tree_code code = TREE_CODE (node);
-  register size_t length;
+  tree t;
+  enum tree_code code = TREE_CODE (node);
+  size_t length;
 
   length = tree_size (node);
   t = ggc_alloc_tree (length);
@@ -521,7 +521,7 @@ copy_list (list)
      tree list;
 {
   tree head;
-  register tree prev, next;
+  tree prev, next;
 
   if (list == 0)
     return 0;
@@ -549,7 +549,7 @@ build_int_2_wide (low, hi)
      unsigned HOST_WIDE_INT low;
      HOST_WIDE_INT hi;
 {
-  register tree t = make_node (INTEGER_CST);
+  tree t = make_node (INTEGER_CST);
 
   TREE_INT_CST_LOW (t) = low;
   TREE_INT_CST_HIGH (t) = hi;
@@ -713,7 +713,7 @@ build_string (len, str)
      int len;
      const char *str;
 {
-  register tree s = make_node (STRING_CST);
+  tree s = make_node (STRING_CST);
 
   TREE_STRING_LENGTH (s) = len;
   TREE_STRING_POINTER (s) = ggc_alloc_string (str, len);
@@ -731,7 +731,7 @@ build_complex (type, real, imag)
      tree type;
      tree real, imag;
 {
-  register tree t = make_node (COMPLEX_CST);
+  tree t = make_node (COMPLEX_CST);
 
   TREE_REALPART (t) = real;
   TREE_IMAGPART (t) = imag;
@@ -748,8 +748,8 @@ tree
 make_tree_vec (len)
      int len;
 {
-  register tree t;
-  register int length = (len-1) * sizeof (tree) + sizeof (struct tree_vec);
+  tree t;
+  int length = (len-1) * sizeof (tree) + sizeof (struct tree_vec);
 
 #ifdef GATHER_STATISTICS
   tree_node_counts[(int)vec_kind]++;
@@ -808,8 +808,8 @@ int
 integer_all_onesp (expr)
      tree expr;
 {
-  register int prec;
-  register int uns;
+  int prec;
+  int uns;
 
   STRIP_NOPS (expr);
 
@@ -1148,8 +1148,8 @@ int
 list_length (t)
      tree t;
 {
-  register tree tail;
-  register int len = 0;
+  tree tail;
+  int len = 0;
 
   for (tail = t; tail; tail = TREE_CHAIN (tail))
     len++;
@@ -1184,9 +1184,9 @@ chainon (op1, op2)
 
   if (op1)
     {
-      register tree t1;
+      tree t1;
 #ifdef ENABLE_TREE_CHECKING
-      register tree t2;
+      tree t2;
 #endif
 
       for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
@@ -1207,9 +1207,9 @@ chainon (op1, op2)
 
 tree
 tree_last (chain)
-     register tree chain;
+     tree chain;
 {
-  register tree next;
+  tree next;
   if (chain)
     while ((next = TREE_CHAIN (chain)))
       chain = next;
@@ -1223,7 +1223,7 @@ tree
 nreverse (t)
      tree t;
 {
-  register tree prev = 0, decl, next;
+  tree prev = 0, decl, next;
   for (decl = t; decl; decl = next)
     {
       next = TREE_CHAIN (decl);
@@ -1265,7 +1265,7 @@ tree
 build_tree_list (parm, value)
      tree parm, value;
 {
-  register tree t = make_node (TREE_LIST);
+  tree t = make_node (TREE_LIST);
   TREE_PURPOSE (t) = parm;
   TREE_VALUE (t) = value;
   return t;
@@ -1279,7 +1279,7 @@ tree
 tree_cons (purpose, value, chain)
      tree purpose, value, chain;
 {
-  register tree node;
+  tree node;
 
   node = ggc_alloc_tree (sizeof (struct tree_list));
 
@@ -1548,7 +1548,7 @@ tree
 save_expr (expr)
      tree expr;
 {
-  register tree t = fold (expr);
+  tree t = fold (expr);
 
   /* We don't care about whether this can be used as an lvalue in this
      context.  */
@@ -1833,7 +1833,7 @@ int
 contains_placeholder_p (exp)
      tree exp;
 {
-  register enum tree_code code;
+  enum tree_code code;
   int result;
 
   if (!exp)
@@ -2158,8 +2158,8 @@ tree
 stabilize_reference (ref)
      tree ref;
 {
-  register tree result;
-  register enum tree_code code = TREE_CODE (ref);
+  tree result;
+  enum tree_code code = TREE_CODE (ref);
 
   switch (code)
     {
@@ -2256,8 +2256,8 @@ tree
 stabilize_reference_1 (e)
      tree e;
 {
-  register tree result;
-  register enum tree_code code = TREE_CODE (e);
+  tree result;
+  enum tree_code code = TREE_CODE (e);
 
   /* We cannot ignore const expressions because it might be a reference
      to a const array but whose index contains side-effects.  But we can
@@ -2331,9 +2331,9 @@ stabilize_reference_1 (e)
 tree
 build VPARAMS ((enum tree_code code, tree tt, ...))
 {
-  register tree t;
-  register int length;
-  register int i;
+  tree t;
+  int length;
+  int i;
   int fro;
   int constant;
 
@@ -2361,8 +2361,8 @@ build VPARAMS ((enum tree_code code, tree tt, ...))
   if (length == 2)
     {
       /* This is equivalent to the loop below, but faster.  */
-      register tree arg0 = va_arg (p, tree);
-      register tree arg1 = va_arg (p, tree);
+      tree arg0 = va_arg (p, tree);
+      tree arg1 = va_arg (p, tree);
 
       TREE_OPERAND (t, 0) = arg0;
       TREE_OPERAND (t, 1) = arg1;
@@ -2389,7 +2389,7 @@ build VPARAMS ((enum tree_code code, tree tt, ...))
     }
   else if (length == 1)
     {
-      register tree arg0 = va_arg (p, tree);
+      tree arg0 = va_arg (p, tree);
 
       /* The only one-operand cases we handle here are those with side-effects.
 	 Others are handled with build1.  So don't bother checked if the
@@ -2404,7 +2404,7 @@ build VPARAMS ((enum tree_code code, tree tt, ...))
     {
       for (i = 0; i < length; i++)
 	{
-	  register tree operand = va_arg (p, tree);
+	  tree operand = va_arg (p, tree);
 
 	  TREE_OPERAND (t, i) = operand;
 	  if (operand && fro > i)
@@ -2432,11 +2432,11 @@ build1 (code, type, node)
      tree type;
      tree node;
 {
-  register int length;
+  int length;
 #ifdef GATHER_STATISTICS
-  register tree_node_kind kind;
+  tree_node_kind kind;
 #endif
-  register tree t;
+  tree t;
 
 #ifdef GATHER_STATISTICS
   if (TREE_CODE_CLASS (code) == 'r')
@@ -2507,9 +2507,9 @@ build1 (code, type, node)
 tree
 build_nt VPARAMS ((enum tree_code code, ...))
 {
-  register tree t;
-  register int length;
-  register int i;
+  tree t;
+  int length;
+  int i;
 
   VA_OPEN (p, code);
   VA_FIXEDARG (p, enum tree_code, code);
@@ -2535,7 +2535,7 @@ build_decl (code, name, type)
      enum tree_code code;
      tree name, type;
 {
-  register tree t;
+  tree t;
 
   t = make_node (code);
 
@@ -2563,7 +2563,7 @@ tree
 build_block (vars, tags, subblocks, supercontext, chain)
      tree vars, tags ATTRIBUTE_UNUSED, subblocks, supercontext, chain;
 {
-  register tree block = make_node (BLOCK);
+  tree block = make_node (BLOCK);
 
   BLOCK_VARS (block) = vars;
   BLOCK_SUBBLOCKS (block) = subblocks;
@@ -2585,7 +2585,7 @@ build_expr_wfl (node, file, line, col)
 {
   static const char *last_file = 0;
   static tree last_filenode = NULL_TREE;
-  register tree wfl = make_node (EXPR_WITH_FILE_LOCATION);
+  tree wfl = make_node (EXPR_WITH_FILE_LOCATION);
 
   EXPR_WFL_NODE (wfl) = node;
   EXPR_WFL_SET_LINECOL (wfl, line, col);
@@ -2790,7 +2790,7 @@ lookup_attribute (attr_name, list)
 
 tree
 merge_attributes (a1, a2)
-     register tree a1, a2;
+     tree a1, a2;
 {
   tree attributes;
 
@@ -2979,7 +2979,7 @@ tree
 build_type_copy (type)
      tree type;
 {
-  register tree t, m = TYPE_MAIN_VARIANT (type);
+  tree t, m = TYPE_MAIN_VARIANT (type);
 
   t = copy_node (type);
 
@@ -3005,7 +3005,7 @@ type_hash_list (list)
      tree list;
 {
   unsigned int hashcode;
-  register tree tail;
+  tree tail;
 
   for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
     hashcode += TYPE_HASH (TREE_VALUE (tail));
@@ -3207,7 +3207,7 @@ attribute_hash_list (list)
      tree list;
 {
   unsigned int hashcode;
-  register tree tail;
+  tree tail;
 
   for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
     /* ??? Do we want to add in TREE_VALUE too? */
@@ -3238,7 +3238,7 @@ int
 attribute_list_contained (l1, l2)
      tree l1, l2;
 {
-  register tree t1, t2;
+  tree t1, t2;
 
   /* First check the obvious, maybe the lists are identical.  */
   if (l1 == l2)
@@ -3286,7 +3286,7 @@ int
 type_list_equal (l1, l2)
      tree l1, l2;
 {
-  register tree t1, t2;
+  tree t1, t2;
 
   for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
     if (TREE_VALUE (t1) != TREE_VALUE (t2)
@@ -3413,7 +3413,7 @@ int
 tree_int_cst_msb (t)
      tree t;
 {
-  register int prec;
+  int prec;
   HOST_WIDE_INT h;
   unsigned HOST_WIDE_INT l;
 
@@ -3472,7 +3472,7 @@ int
 simple_cst_equal (t1, t2)
      tree t1, t2;
 {
-  register enum tree_code code1, code2;
+  enum tree_code code1, code2;
   int cmp;
   int i;
 
@@ -3635,7 +3635,7 @@ tree
 build_pointer_type (to_type)
      tree to_type;
 {
-  register tree t = TYPE_POINTER_TO (to_type);
+  tree t = TYPE_POINTER_TO (to_type);
 
   /* First, if we already have a type for pointers to TO_TYPE, use it.  */
 
@@ -3664,7 +3664,7 @@ tree
 build_reference_type (to_type)
      tree to_type;
 {
-  register tree t = TYPE_REFERENCE_TO (to_type);
+  tree t = TYPE_REFERENCE_TO (to_type);
 
   /* First, if we already have a type for pointers to TO_TYPE, use it.  */
 
@@ -3717,7 +3717,7 @@ tree
 build_index_type (maxval)
      tree maxval;
 {
-  register tree itype = make_node (INTEGER_TYPE);
+  tree itype = make_node (INTEGER_TYPE);
 
   TREE_TYPE (itype) = sizetype;
   TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
@@ -3744,7 +3744,7 @@ tree
 build_range_type (type, lowval, highval)
      tree type, lowval, highval;
 {
-  register tree itype = make_node (INTEGER_TYPE);
+  tree itype = make_node (INTEGER_TYPE);
 
   TREE_TYPE (itype) = type;
   if (type == NULL_TREE)
@@ -3816,7 +3816,7 @@ tree
 build_array_type (elt_type, index_type)
      tree elt_type, index_type;
 {
-  register tree t;
+  tree t;
   unsigned int hashcode;
 
   if (TREE_CODE (elt_type) == FUNCTION_TYPE)
@@ -3873,7 +3873,7 @@ tree
 build_function_type (value_type, arg_types)
      tree value_type, arg_types;
 {
-  register tree t;
+  tree t;
   unsigned int hashcode;
 
   if (TREE_CODE (value_type) == FUNCTION_TYPE)
@@ -3905,7 +3905,7 @@ tree
 build_method_type (basetype, type)
      tree basetype, type;
 {
-  register tree t;
+  tree t;
   unsigned int hashcode;
 
   /* Make a node of the sort we want.  */
@@ -3942,7 +3942,7 @@ tree
 build_offset_type (basetype, type)
      tree basetype, type;
 {
-  register tree t;
+  tree t;
   unsigned int hashcode;
 
   /* Make a node of the sort we want.  */
@@ -3967,7 +3967,7 @@ tree
 build_complex_type (component_type)
      tree component_type;
 {
-  register tree t;
+  tree t;
   unsigned int hashcode;
 
   /* Make a node of the sort we want.  */
@@ -4045,22 +4045,22 @@ build_complex_type (component_type)
 
 tree
 get_unwidened (op, for_type)
-     register tree op;
+     tree op;
      tree for_type;
 {
   /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension.  */
-  register tree type = TREE_TYPE (op);
-  register unsigned final_prec
+  tree type = TREE_TYPE (op);
+  unsigned final_prec
     = TYPE_PRECISION (for_type != 0 ? for_type : type);
-  register int uns
+  int uns
     = (for_type != 0 && for_type != type
        && final_prec > TYPE_PRECISION (type)
        && TREE_UNSIGNED (type));
-  register tree win = op;
+  tree win = op;
 
   while (TREE_CODE (op) == NOP_EXPR)
     {
-      register int bitschange
+      int bitschange
 	= TYPE_PRECISION (TREE_TYPE (op))
 	  - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
 
@@ -4138,16 +4138,16 @@ get_unwidened (op, for_type)
 
 tree
 get_narrower (op, unsignedp_ptr)
-     register tree op;
+     tree op;
      int *unsignedp_ptr;
 {
-  register int uns = 0;
+  int uns = 0;
   int first = 1;
-  register tree win = op;
+  tree win = op;
 
   while (TREE_CODE (op) == NOP_EXPR)
     {
-      register int bitschange
+      int bitschange
 	= (TYPE_PRECISION (TREE_TYPE (op))
 	   - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
 
diff --git a/gcc/unroll.c b/gcc/unroll.c
index 99f56fb0d71..efb9de1db54 100644
--- a/gcc/unroll.c
+++ b/gcc/unroll.c
@@ -898,7 +898,7 @@ unroll_loop (loop, insn_count, strength_reduce_p)
 			       &initial_value, &final_value, &increment,
 			       &mode))
 	{
-	  register rtx diff;
+	  rtx diff;
 	  rtx *labels;
 	  int abs_inc, neg_inc;
 
@@ -4043,9 +4043,9 @@ remap_split_bivs (loop, x)
      rtx x;
 {
   struct loop_ivs *ivs = LOOP_IVS (loop);
-  register enum rtx_code code;
-  register int i;
-  register const char *fmt;
+  enum rtx_code code;
+  int i;
+  const char *fmt;
 
   if (x == 0)
     return x;
@@ -4084,7 +4084,7 @@ remap_split_bivs (loop, x)
 	XEXP (x, i) = remap_split_bivs (loop, XEXP (x, i));
       else if (fmt[i] == 'E')
 	{
-	  register int j;
+	  int j;
 	  for (j = 0; j < XVECLEN (x, i); j++)
 	    XVECEXP (x, i, j) = remap_split_bivs (loop, XVECEXP (x, i, j));
 	}
diff --git a/gcc/varasm.c b/gcc/varasm.c
index 80c665f3326..312387530bd 100644
--- a/gcc/varasm.c
+++ b/gcc/varasm.c
@@ -1477,7 +1477,7 @@ assemble_variable (decl, top_level, at_end, dont_output_data)
      int at_end ATTRIBUTE_UNUSED;
      int dont_output_data;
 {
-  register const char *name;
+  const char *name;
   unsigned int align;
   int reloc = 0;
   rtx decl_rtl;
@@ -2170,7 +2170,7 @@ immed_double_const (i0, i1, mode)
      HOST_WIDE_INT i0, i1;
      enum machine_mode mode;
 {
-  register rtx r;
+  rtx r;
 
   if (GET_MODE_CLASS (mode) == MODE_INT
       || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
@@ -2262,7 +2262,7 @@ immed_real_const_1 (d, mode)
      enum machine_mode mode;
 {
   union real_extract u;
-  register rtx r;
+  rtx r;
 
   /* Get the desired `double' value as a sequence of ints
      since that is how they are stored in a CONST_DOUBLE.  */
@@ -2343,7 +2343,7 @@ immed_real_const (exp)
 void
 clear_const_double_mem ()
 {
-  register rtx r, next;
+  rtx r, next;
   enum machine_mode mode;
   int i;
 
@@ -2381,9 +2381,9 @@ decode_addr_const (exp, value)
      tree exp;
      struct addr_const *value;
 {
-  register tree target = TREE_OPERAND (exp, 0);
-  register int offset = 0;
-  register rtx x;
+  tree target = TREE_OPERAND (exp, 0);
+  int offset = 0;
+  rtx x;
 
   while (1)
     {
@@ -2564,9 +2564,9 @@ static int
 const_hash (exp)
      tree exp;
 {
-  register const char *p;
-  register int len, hi, i;
-  register enum tree_code code = TREE_CODE (exp);
+  const char *p;
+  int len, hi, i;
+  enum tree_code code = TREE_CODE (exp);
 
   /* Either set P and LEN to the address and len of something to hash and
      exit the switch or return a value.  */
@@ -2605,7 +2605,7 @@ const_hash (exp)
 	}
       else
 	{
-	  register tree link;
+	  tree link;
 
 	  /* For record type, include the type in the hashing.
 	     We do not do so for array types
@@ -2702,9 +2702,9 @@ compare_constant_1 (exp, p)
      tree exp;
      const unsigned char *p;
 {
-  register const unsigned char *strp;
-  register int len;
-  register enum tree_code code = TREE_CODE (exp);
+  const unsigned char *strp;
+  int len;
+  enum tree_code code = TREE_CODE (exp);
 
   if (code != (enum tree_code) *p++)
     return 0;
@@ -2771,7 +2771,7 @@ compare_constant_1 (exp, p)
 	}
       else
 	{
-	  register tree link;
+	  tree link;
 	  int length = list_length (CONSTRUCTOR_ELTS (exp));
 	  tree type;
 	  enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
@@ -2957,9 +2957,9 @@ static void
 record_constant_1 (exp)
      tree exp;
 {
-  register const unsigned char *strp;
-  register int len;
-  register enum tree_code code = TREE_CODE (exp);
+  const unsigned char *strp;
+  int len;
+  enum tree_code code = TREE_CODE (exp);
 
   obstack_1grow (&permanent_obstack, (unsigned int) code);
 
@@ -3006,7 +3006,7 @@ record_constant_1 (exp)
 	}
       else
 	{
-	  register tree link;
+	  tree link;
 	  int length = list_length (CONSTRUCTOR_ELTS (exp));
 	  enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
 	  tree type;
@@ -3276,8 +3276,8 @@ output_constant_def (exp, defer)
      tree exp;
      int defer;
 {
-  register int hash;
-  register struct constant_descriptor *desc;
+  int hash;
+  struct constant_descriptor *desc;
   struct deferred_string **defstr;
   char label[256];
   int reloc;
@@ -3705,8 +3705,8 @@ const_hash_rtx (mode, x)
      enum machine_mode mode;
      rtx x;
 {
-  register int hi;
-  register size_t i;
+  int hi;
+  size_t i;
 
   struct rtx_const value;
   decode_rtx_const (mode, x, &value);
@@ -3730,9 +3730,9 @@ compare_constant_rtx (mode, x, desc)
      rtx x;
      struct constant_descriptor *desc;
 {
-  register int *p = (int *) desc->u.contents;
-  register int *strp;
-  register int len;
+  int *p = (int *) desc->u.contents;
+  int *strp;
+  int len;
   struct rtx_const value;
 
   decode_rtx_const (mode, x, &value);
@@ -3773,8 +3773,8 @@ force_const_mem (mode, x)
      enum machine_mode mode;
      rtx x;
 {
-  register int hash;
-  register struct constant_descriptor *desc;
+  int hash;
+  struct constant_descriptor *desc;
   char label[256];
   const char *found = 0;
   rtx def;
@@ -3807,7 +3807,7 @@ force_const_mem (mode, x)
 
   if (found == 0)
     {
-      register struct pool_constant *pool;
+      struct pool_constant *pool;
       int align;
 
       /* No constant equal to X is known to have been output.
@@ -4081,7 +4081,7 @@ output_constant_pool (fnname, fndecl)
 static void
 mark_constant_pool ()
 {
-  register rtx insn;
+  rtx insn;
   struct pool_constant *pool;
 
   if (first_pool == 0 && htab_elements (const_str_htab) == 0)
@@ -4110,8 +4110,8 @@ static void
 mark_constants (x)
      rtx x;
 {
-  register int i;
-  register const char *format_ptr;
+  int i;
+  const char *format_ptr;
 
   if (x == 0)
     return;
@@ -4148,7 +4148,7 @@ mark_constants (x)
 	case 'E':
 	  if (XVEC (x, i) != 0)
 	    {
-	      register int j;
+	      int j;
 
 	      for (j = 0; j < XVECLEN (x, i); j++)
 		mark_constants (XVECEXP (x, i, j));
@@ -4238,7 +4238,7 @@ output_addressed_constants (exp)
     {
     case ADDR_EXPR:
       {
-	register tree constant = TREE_OPERAND (exp, 0);
+	tree constant = TREE_OPERAND (exp, 0);
 
 	while (TREE_CODE (constant) == COMPONENT_REF)
 	  {
@@ -4268,7 +4268,7 @@ output_addressed_constants (exp)
 
     case CONSTRUCTOR:
       {
-	register tree link;
+	tree link;
 	for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
 	  if (TREE_VALUE (link) != 0)
 	    reloc |= output_addressed_constants (TREE_VALUE (link));
@@ -4476,7 +4476,7 @@ output_constant (exp, size, align)
      int size;
      unsigned int align;
 {
-  register enum tree_code code = TREE_CODE (TREE_TYPE (exp));
+  enum tree_code code = TREE_CODE (TREE_TYPE (exp));
 
   /* Some front-ends use constants other than the standard
      language-indepdent varieties, but which may still be output
@@ -4672,14 +4672,14 @@ output_constructor (exp, size, align)
      unsigned int align;
 {
   tree type = TREE_TYPE (exp);
-  register tree link, field = 0;
+  tree link, field = 0;
   tree min_index = 0;
   /* Number of bytes output or skipped so far.
      In other words, current position within the constructor.  */
   HOST_WIDE_INT total_bytes = 0;
   /* Non-zero means BYTE contains part of a byte, to be output.  */
   int byte_buffer_in_use = 0;
-  register int byte = 0;
+  int byte = 0;
 
   if (HOST_BITS_PER_WIDE_INT < BITS_PER_UNIT)
     abort ();
diff --git a/gcc/xcoffout.c b/gcc/xcoffout.c
index 75a8a8d80a0..36a1e726559 100644
--- a/gcc/xcoffout.c
+++ b/gcc/xcoffout.c
@@ -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;
 {