+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.
static rtx
find_base_value (src)
- register rtx src;
+ rtx src;
{
unsigned int regno;
switch (GET_CODE (src))
rtx dest, set;
void *data ATTRIBUTE_UNUSED;
{
- register unsigned regno;
+ unsigned regno;
rtx src;
if (GET_CODE (dest) != REG)
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;
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)
static rtx
find_base_term (x)
- register rtx x;
+ rtx x;
{
cselib_val *val;
struct elt_loc_list *l;
static int
memrefs_conflict_p (xsize, x, ysize, y, c)
- register rtx x, y;
+ rtx x, y;
int xsize, ysize;
HOST_WIDE_INT c;
{
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))
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;
int
output_dependence (mem, x)
- register rtx mem;
- register rtx x;
+ rtx mem;
+ rtx x;
{
return write_dependence_p (mem, x, /*writep=*/1);
}
rtx x;
{
rtx base;
- register RTX_CODE code;
+ RTX_CODE code;
int regno;
code = GET_CODE (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--)
{
}
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;
void
init_alias_once ()
{
- register int i;
+ int i;
#ifndef OUTGOING_REGNO
#define OUTGOING_REGNO(N) N
{
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;
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;
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.
binary_op_error (code)
enum tree_code code;
{
- register const char *opname;
+ const char *opname;
switch (code)
{
tree *restype_ptr;
enum tree_code *rescode_ptr;
{
- register tree type;
+ tree type;
tree op0 = *op0_ptr;
tree op1 = *op1_ptr;
int unsignedp0, unsignedp1;
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;
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;
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
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. */
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;
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)
{
/* 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;
void
set_block (block)
- register tree block;
+ tree block;
{
current_binding_level->this_block = block;
current_binding_level->names = chainon (current_binding_level->names,
void
push_label_level ()
{
- register struct binding_level *newlevel;
+ struct binding_level *newlevel;
/* Reuse or create a struct for this binding 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.
pushtag (name, type)
tree name, type;
{
- register struct binding_level *b;
+ struct binding_level *b;
/* Find the proper binding level for this type tag. */
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));
&& 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)
&& 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),
/* 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),
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))
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);
lookup_label (id)
tree id;
{
- register tree decl = IDENTIFIER_LABEL_VALUE (id);
+ tree decl = IDENTIFIER_LABEL_VALUE (id);
if (current_function_decl == 0)
{
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 */
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)
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)
lookup_name (name)
tree name;
{
- register tree val;
+ tree val;
if (current_binding_level != global_binding_level
&& IDENTIFIER_LOCAL_VALUE (name))
lookup_name_current_level (name)
tree name;
{
- register tree t;
+ tree t;
if (current_binding_level == global_binding_level)
return IDENTIFIER_GLOBAL_VALUE (name);
void
init_decl_processing ()
{
- register tree endlink;
+ tree endlink;
tree ptr_ftype_void, ptr_ftype_ptr;
current_function_decl = NULL;
no pedwarn. */
{
int found_tag = 0;
- register tree link;
+ tree link;
tree specs, attrs;
pending_invalid_xref = 0;
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++;
{
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)))
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;
tree initial_value;
int do_default;
{
- register tree maxindex = NULL_TREE;
+ tree maxindex = NULL_TREE;
int value = 0;
if (initial_value)
/* 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)
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;
/* 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)
}
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);
the FUNCTION_TYPE node itself. */
{
- register tree link;
+ tree link;
for (link = last_function_parm_tags;
link;
if (TREE_TYPE (declarator))
{
- register tree typemodlist;
+ tree typemodlist;
int erred = 0;
constp = 0;
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 ();
/* 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
/* 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);
tree fieldlist;
tree attributes;
{
- register tree x;
+ tree x;
int toplevel = global_binding_level == current_binding_level;
int saw_named_field;
x = TREE_CHAIN (x);
else
{
- register tree y = fieldlist;
+ tree y = fieldlist;
while (1)
{
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
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);
build_enumerator (name, value)
tree name, value;
{
- register tree decl, type;
+ tree decl, type;
/* Validate and default VALUE. */
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). */
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;
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;
for (parm = specparms; parm; parm = TREE_CHAIN (parm))
{
- register tree tail, found = NULL;
+ tree tail, found = NULL;
if (TREE_VALUE (parm) == 0)
{
parm = specparms;
DECL_ARGUMENTS (fndecl) = 0;
{
- register tree last;
+ tree last;
for (last = 0; parm; parm = TREE_CHAIN (parm))
if (TREE_PURPOSE (parm))
{
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))
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
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;
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);
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. */
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. */
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)
}
if (code == ARRAY_TYPE)
{
- register tree adr;
+ tree adr;
tree restype = TREE_TYPE (type);
tree ptrtype;
int constp = 0;
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. */
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)
{
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)
{
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. */
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
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)
{
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.
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. */
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)
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)
{
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));
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)
}
{
- register tree inc;
+ tree inc;
tree result_type = TREE_TYPE (arg);
arg = get_unwidened (arg, 0);
lvalue_p (ref)
tree ref;
{
- register enum tree_code code = TREE_CODE (ref);
+ enum tree_code code = TREE_CODE (ref);
switch (code)
{
mark_addressable (exp)
tree exp;
{
- register tree x = exp;
+ tree x = exp;
while (1)
switch (TREE_CODE (x))
{
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));
tree list;
int first_p;
{
- register tree rest;
+ tree rest;
if (TREE_CHAIN (list) == 0)
{
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;
tree lhs, rhs;
enum tree_code modifycode;
{
- register tree result;
+ tree result;
tree newrhs;
tree lhstype = TREE_TYPE (lhs);
tree olhstype = lhstype;
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
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.
{
/* 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. */
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.
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. */
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++)
{
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)
}
else
{
- register const char *s;
+ const char *s;
if (p->kind == SPELLING_MEMBER)
*d++ = '.';
for (s = p->u.s; (*d = *s++); d++)
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++)
c_start_case (exp)
tree exp;
{
- register enum tree_code code;
+ enum tree_code code;
tree type;
struct c_switch *cs;
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)
rtx setter;
void *data;
{
- register int regno, endregno, i;
+ int regno, endregno, i;
enum machine_mode mode = GET_MODE (reg);
int offset = 0;
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);
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
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. */
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;
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;
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;
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
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;
}
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
{
/* BLKmode, at least partly to be pushed. */
- register int excess;
+ int excess;
rtx size_rtx;
/* Pushing a nonscalar.
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);
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);
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;
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;
FILE *outf;
rtx rtx_first;
{
- register rtx tmp_rtx;
+ rtx tmp_rtx;
if (rtx_first == 0)
fprintf (outf, "(nil)\n");
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 },
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;
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;
int maxreg;
rtx temp;
- register rtx link;
+ rtx link;
int i;
/* Exit early if one of the insns involved can't be used for
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
{
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))
rtx insn;
rtx *pnotes;
{
- register rtx pat = *pnewpat;
+ rtx pat = *pnewpat;
int insn_code_number;
int num_clobbers_to_add = 0;
int i;
static rtx
gen_lowpart_for_combine (mode, x)
enum machine_mode mode;
- register rtx x;
+ rtx x;
{
rtx result;
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. */
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)
{
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))
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)
{
{
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;
{
/* 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
/* 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--)
{
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));
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)
{
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)
{
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);
{
/* 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. */
/* 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. */
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;
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;
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;
static void
new_basic_block ()
{
- register int i;
+ int i;
next_qty = max_reg;
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 ();
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)
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;
static void
remove_from_table (elt, hash)
- register struct table_elt *elt;
+ struct table_elt *elt;
unsigned hash;
{
if (elt == 0)
/* 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;
prev->next_same_value = next;
else
{
- register struct table_elt *newfirst = next;
+ struct table_elt *newfirst = next;
while (next)
{
next->first_same_value = newfirst;
/* 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;
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;
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)
unsigned hash;
enum machine_mode mode;
{
- register struct table_elt *p;
+ struct table_elt *p;
if (GET_CODE (x) == REG)
{
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
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. */
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;
{
/* 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);
&& ! 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)
{
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))
{
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);
for (i = 0; i < HASH_SIZE; i++)
{
- register struct table_elt *next;
+ struct table_elt *next;
for (p = table[i]; p; p = next)
{
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?
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:
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')
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. */
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
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;
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
fmt = GET_RTX_FORMAT (code);
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
{
- register int j;
+ int j;
if (fmt[i] == 'e')
{
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;
|| (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)
{
rtx
gen_lowpart_if_possible (mode, x)
enum machine_mode mode;
- register rtx x;
+ rtx x;
{
rtx result = gen_lowpart_common (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)
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. */
}
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));
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);
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
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;
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);
{
/* 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);
|| 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
{
/* 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.
/* 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;
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
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)
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
}
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);
/* 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)
{
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;
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;
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
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;
tree type;
int full;
{
- register tree tem;
+ tree tem;
static int anonymous_type_number = 0;
if (TREE_CODE (type) == VECTOR_TYPE)
static void
dbxout_type_name (type)
- register tree type;
+ tree type;
{
tree t;
if (TYPE_NAME (type) == 0)
static void
dbxout_block (block, depth, args)
- register tree block;
+ tree block;
int depth;
tree args;
{
\
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)) \
/* 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--)
static const char *
dwarf_cfi_name (cfi_opc)
- register unsigned cfi_opc;
+ unsigned cfi_opc;
{
switch (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;
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)
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 ();
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);
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)
{
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;
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);
}
void
dwarf2out_def_cfa (label, reg, offset)
- register const char *label;
+ const char *label;
unsigned reg;
long 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;
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;
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);
}
const char *label;
long size;
{
- register dw_cfi_ref cfi;
+ dw_cfi_ref cfi;
if (size == old_args_size)
return;
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);
}
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);
}
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);
}
static void
initial_return_save (rtl)
- register rtx rtl;
+ rtx rtl;
{
unsigned int reg = (unsigned int) -1;
long offset = 0;
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)
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];
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;
static const char *
dwarf_stack_op_name (op)
- register unsigned op;
+ unsigned op;
{
switch (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;
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)
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)
{
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)
{
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)
{
static rtx
save_rtx (orig)
- register rtx orig;
+ rtx orig;
{
VARRAY_PUSH_RTX (used_rtx_varray, 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
static inline tree
type_main_variant (type)
- register tree type;
+ tree type;
{
type = 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);
static const char *
dwarf_tag_name (tag)
- register unsigned tag;
+ unsigned tag;
{
switch (tag)
{
static const char *
dwarf_attr_name (attr)
- register unsigned attr;
+ unsigned attr;
{
switch (attr)
{
static const char *
dwarf_form_name (form)
- register unsigned form;
+ unsigned form;
{
switch (form)
{
#if 0
static const char *
dwarf_type_encoding_name (enc)
- register unsigned enc;
+ unsigned enc;
{
switch (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
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
return NULL_TREE;
else
{
- register tree ret_val;
- register tree lookahead = immediate_origin;
+ tree ret_val;
+ tree lookahead = immediate_origin;
do
{
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)
{
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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)
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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))
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)
{
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;
}
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;
}
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;
}
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;
}
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);
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);
}
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);
}
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)
{
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);
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)
{
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;
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);
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;
}
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);
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)
{
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",
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)
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)
{
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);
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))
{
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
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)
/* 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;
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). */
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)
{
static unsigned long
size_of_string (str)
- register const char *str;
+ const char *str;
{
return strlen (str) + 1;
}
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)
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);
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);
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);
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);
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);
}
static unsigned long
size_of_aranges ()
{
- register unsigned long size;
+ unsigned long size;
size = DWARF_ARANGES_HEADER_SIZE;
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)");
static inline void
output_die_symbol (die)
- register dw_die_ref die;
+ dw_die_ref die;
{
char *sym = die->die_symbol;
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;
/* 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)
/* 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
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. */
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);
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");
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)
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");
static void
output_ranges ()
{
- register unsigned i;
+ unsigned i;
static const char *const start_fmt = "Offset 0x%x";
const char *fmt = start_fmt;
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);
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
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
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)
static tree
root_type (type)
- register tree type;
+ tree type;
{
if (TREE_CODE (type) == ERROR_MARK)
return error_mark_node;
static inline int
is_base_type (type)
- register tree type;
+ tree type;
{
switch (TREE_CODE (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)
{
static inline int
type_is_enum (type)
- register tree type;
+ tree type;
{
return TREE_CODE (type) == ENUMERAL_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)
{
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);
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);
static inline int
is_based_loc (rtl)
- register rtx rtl;
+ rtx rtl;
{
return (GET_CODE (rtl) == PLUS
&& ((GET_CODE (XEXP (rtl, 0)) == REG
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;
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;
static dw_loc_descr_ref
loc_descriptor (rtl)
- register rtx rtl;
+ rtx rtl;
{
dw_loc_descr_ref loc_result = NULL;
switch (GET_CODE (rtl))
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;
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;
}
static inline unsigned HOST_WIDE_INT
simple_type_size_in_bits (type)
- register tree type;
+ tree type;
{
tree type_size_tree;
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;
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,
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);
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))
{
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;
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
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;
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)
{
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
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. */
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
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
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))
{
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);
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
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)
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;
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))
{
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));
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)
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))
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
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)
static inline tree
member_declared_type (member)
- register tree member;
+ tree member;
{
return (DECL_BIT_FIELD_TYPE (member)
? DECL_BIT_FIELD_TYPE (member)
#if 0
static const char *
decl_start_label (decl)
- register tree decl;
+ tree decl;
{
rtx x;
const char *fnname;
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
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);
#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
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);
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. */
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. */
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)
{
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);
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)));
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)))
{
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);
}
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)
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)
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);
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,
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);
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" */
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)
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)
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))
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. */
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),
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);
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);
/* 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);
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;
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);
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);
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
/* 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);
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))));
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,
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);
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;
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))
{
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;
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;
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)
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))
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);
static inline int
is_redundant_typedef (decl)
- register tree decl;
+ tree decl;
{
if (TYPE_DECL_IS_STUB (decl))
return 1;
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;
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;
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
static void
dwarf2out_source_line (line, filename)
unsigned int line;
- register const char *filename;
+ const char *filename;
{
if (debug_info_level >= DINFO_LEVEL_NORMAL)
{
}
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);
}
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);
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)
{
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)
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)
{
static void
dwarf2out_init (main_input_filename)
- register const char *main_input_filename;
+ const char *main_input_filename;
{
init_file_table ();
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;
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)
static inline tree
type_main_variant (type)
- register tree type;
+ tree type;
{
type = 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);
static const char *
dwarf_tag_name (tag)
- register unsigned tag;
+ unsigned tag;
{
switch (tag)
{
static const char *
dwarf_attr_name (attr)
- register unsigned attr;
+ unsigned attr;
{
switch (attr)
{
static const char *
dwarf_stack_op_name (op)
- register unsigned op;
+ unsigned op;
{
switch (op)
{
static const char *
dwarf_typemod_name (mod)
- register unsigned mod;
+ unsigned mod;
{
switch (mod)
{
static const char *
dwarf_fmt_byte_name (fmt)
- register unsigned fmt;
+ unsigned fmt;
{
switch (fmt)
{
static const char *
dwarf_fund_type_name (ft)
- register unsigned ft;
+ unsigned ft;
{
switch (ft)
{
static tree
decl_ultimate_origin (decl)
- register tree decl;
+ tree decl;
{
#ifdef ENABLE_CHECKING
if (DECL_FROM_INLINE (DECL_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
{
#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 */
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)
static int
fundamental_type_code (type)
- register tree type;
+ tree type;
{
if (TREE_CODE (type) == ERROR_MARK)
return 0;
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
static tree
root_type (type)
- register tree type;
+ tree type;
{
type = root_type_1 (type, 0);
if (type != error_mark_node)
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;
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);
}
static inline int
type_is_fundamental (type)
- register tree type;
+ tree type;
{
switch (TREE_CODE (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
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];
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)
{
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
static void
output_loc_descriptor (rtl)
- register rtx rtl;
+ rtx rtl;
{
switch (GET_CODE (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))
{
static void
output_enumeral_list (link)
- register tree link;
+ tree link;
{
if (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);
}
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;
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;
}
static inline unsigned HOST_WIDE_INT
simple_type_size_in_bits (type)
- register tree type;
+ tree type;
{
tree type_size_tree;
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;
static void
location_attribute (rtl)
- register rtx rtl;
+ rtx rtl;
{
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
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];
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];
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;
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. */
static inline void
name_attribute (name_string)
- register const char *name_string;
+ const char *name_string;
{
if (name_string && *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);
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];
static inline void
user_def_type_attribute (type)
- register tree type;
+ tree type;
{
char ud_type_name[MAX_ARTIFICIAL_LABEL_BYTES];
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];
#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);
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];
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
{
/* 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))
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))
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);
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
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];
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. */
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);
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);
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);
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);
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);
static inline void
member_attribute (context)
- register tree context;
+ tree context;
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
#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];
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);
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. */
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. */
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. */
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))
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);
static inline void
inline_attribute (decl)
- register tree decl;
+ tree decl;
{
if (DECL_INLINE (decl))
{
static inline void
containing_type_attribute (containing_type)
- register tree containing_type;
+ tree containing_type;
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
static inline void
abstract_origin_attribute (origin)
- register tree origin;
+ tree origin;
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
#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);
static inline void
pure_or_virtual_attribute (func_decl)
- register tree func_decl;
+ tree func_decl;
{
if (DECL_VIRTUAL_P (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))
{
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;
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)
static inline tree
member_declared_type (member)
- register tree member;
+ tree member;
{
return (DECL_BIT_FIELD_TYPE (member))
? DECL_BIT_FIELD_TYPE (member)
static const char *
function_start_label (decl)
- register tree decl;
+ tree decl;
{
rtx x;
const char *fnname;
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 ();
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 ();
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 ();
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 ();
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 ();
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 ();
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 ();
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 ();
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 ();
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);
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 ();
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 ();
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
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 ();
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 ();
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 ();
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 ();
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 ();
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 ();
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 ();
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 ();
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 ();
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 ();
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 ();
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 ();
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);
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 ();
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 ();
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 ();
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 ();
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 */
}
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];
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
static void
pend_type (type)
- register tree type;
+ tree type;
{
if (pending_types == pending_types_allocated)
{
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
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];
static void
retry_incomplete_types ()
{
- register tree type;
+ tree type;
finalizing = 1;
while (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;
{
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. */
}
else
{
- register tree element_type;
+ tree element_type;
element_type = TREE_TYPE (type);
while (TREE_CODE (element_type) == ARRAY_TYPE)
++in_class;
{
- register tree normal_member;
+ tree normal_member;
/* Now output info about the data members and type members. */
}
{
- register tree func_member;
+ tree func_member;
/* Now output info about the function members (if any). */
static void
output_tagged_type_instantiation (type)
- register tree type;
+ tree type;
{
if (type == 0 || type == error_mark_node)
return;
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. */
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. */
static void
output_decls_for_scope (stmt, depth)
- register tree stmt;
+ tree stmt;
int depth;
{
/* Ignore blocks never really used to make RTL. */
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);
therein) of this block. */
{
- register tree subblocks;
+ tree subblocks;
for (subblocks = BLOCK_SUBBLOCKS (stmt);
subblocks;
static inline int
is_redundant_typedef (decl)
- register tree decl;
+ tree decl;
{
if (TYPE_DECL_IS_STUB (decl))
return 1;
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
{
/* 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
*/
{
- 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)
{
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)
{
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)
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;
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;
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))
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);
}
{
- register const char *tail = strrchr (filename, '/');
+ const char *tail = strrchr (filename, '/');
if (tail != NULL)
filename = tail;
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;
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);
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];
/* 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);
static void
dwarfout_end_source_file (lineno)
- register unsigned lineno;
+ unsigned lineno;
{
char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*2];
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];
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];
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. */
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");
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];
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);
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... */
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. */
register. */
int
subreg_hard_regno (x, check_mode)
- register rtx x;
+ rtx x;
int check_mode;
{
enum machine_mode mode = GET_MODE (x);
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));
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
rtx
gen_imagpart (mode, x)
enum machine_mode mode;
- register rtx x;
+ rtx x;
{
if (WORDS_BIG_ENDIAN)
return gen_lowpart (mode, x);
rtx
gen_lowpart (mode, x)
enum machine_mode mode;
- register rtx x;
+ rtx x;
{
rtx result = gen_lowpart_common (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));
rtx
gen_highpart (mode, x)
enum machine_mode mode;
- register rtx x;
+ rtx x;
{
unsigned int msize = GET_MODE_SIZE (mode);
rtx result;
rtx
gen_label_rtx ()
{
- register rtx label;
+ rtx label;
label = gen_rtx_CODE_LABEL (VOIDmode, 0, NULL_RTX,
NULL_RTX, label_num++, NULL, NULL);
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)
if (x->used)
{
- register rtx copy;
+ rtx copy;
copy = rtx_alloc (code);
memcpy (copy, x,
case 'E':
if (XVEC (x, i) != NULL)
{
- register int j;
+ int j;
int len = XVECLEN (x, i);
if (copied && len > 0)
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;
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)
make_insn_raw (pattern)
rtx pattern;
{
- register rtx insn;
+ rtx insn;
insn = rtx_alloc (INSN);
make_jump_insn_raw (pattern)
rtx pattern;
{
- register rtx insn;
+ rtx insn;
insn = rtx_alloc (JUMP_INSN);
INSN_UID (insn) = cur_insn_uid++;
make_call_insn_raw (pattern)
rtx pattern;
{
- register rtx insn;
+ rtx insn;
insn = rtx_alloc (CALL_INSN);
INSN_UID (insn) = cur_insn_uid++;
void
add_insn (insn)
- register rtx insn;
+ rtx insn;
{
PREV_INSN (insn) = last_insn;
NEXT_INSN (insn) = 0;
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++)
{
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);
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);
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++;
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;
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++)
{
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);
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++;
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;
int line;
rtx after;
{
- register rtx note;
+ rtx note;
if (no_line_numbers && line > 0)
{
if (GET_CODE (pattern) == SEQUENCE)
{
- register int i;
+ int i;
for (i = 0; i < XVECLEN (pattern, 0); i++)
{
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)
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;
}
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;
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;
const char *file;
int line;
{
- register rtx note;
+ rtx note;
if (line > 0)
{
}
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;
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;
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);
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)
rtx x;
rtx *constptr;
{
- register rtx x0, x1;
+ rtx x0, x1;
rtx tem;
if (GET_CODE (x) != PLUS)
static rtx
break_out_memory_refs (x)
- register rtx x;
+ rtx x;
{
if (GET_CODE (x) == MEM
|| (CONSTANT_P (x) && CONSTANT_ADDRESS_P (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);
rtx
copy_all_regs (x)
- register rtx x;
+ rtx x;
{
if (GET_CODE (x) == REG)
{
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);
}
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;
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. */
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. */
enum machine_mode mode;
rtx x;
{
- register rtx temp, insn, set;
+ rtx temp, insn, set;
if (GET_CODE (x) == REG)
return x;
force_not_mem (x)
rtx x;
{
- register rtx temp;
+ rtx temp;
if (GET_CODE (x) != MEM || GET_MODE (x) == BLKmode)
return x;
rtx x, target;
enum machine_mode mode;
{
- register rtx temp;
+ rtx temp;
if (target && GET_CODE (target) == REG)
temp = target;
= (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);
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;
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;
= (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;
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;
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
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;
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;
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;
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;
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. */
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:
void
emit_queue ()
{
- register rtx p;
+ rtx p;
while ((p = pending_chain))
{
rtx body = QUEUED_BODY (p);
void
convert_move (to, from, unsignedp)
- register rtx to, from;
+ rtx to, from;
int unsignedp;
{
enum machine_mode to_mode = GET_MODE (to);
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. */
rtx size;
int extra, below;
{
- register rtx temp;
+ rtx temp;
size = convert_modes (Pmode, ptr_mode, size, 1);
if (CONSTANT_P (size))
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));
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;
{
/* 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;
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. */
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;
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
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;
}
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);
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;
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
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;
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;
}
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);
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));
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. */
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);
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;
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;
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;
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.
int optimize;
int prescan;
{
- register rtx insn;
+ rtx insn;
int max_line = 0;
int max_uid = 0;
/* 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.
default:
{
- register rtx body = PATTERN (insn);
+ rtx body = PATTERN (insn);
int insn_code_number;
const char *template;
#ifdef HAVE_cc0
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)
if (GET_CODE (body) == SEQUENCE)
{
/* A delayed-branch sequence */
- register int i;
+ int i;
rtx next;
if (prescan > 0)
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)
case EQ:
case NE:
{
- register int result;
+ int result;
if (XEXP (cond_rtx, 0) != cc0_rtx)
break;
result = alter_cond (cond_rtx);
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
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);
static int
alter_cond (cond)
- register rtx cond;
+ rtx cond;
{
int value = 0;
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);
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. */
#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 '|'. */
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;
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);
{
struct fn_decl *fn;
const char *cptr;
- register struct symbol_list *cur_symbols;
+ struct symbol_list *cur_symbols;
if (required_unseen_count)
{
static int
inf_scan_ident (s, c)
- register sstring *s;
+ sstring *s;
int c;
{
s->ptr = s->base;
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++)
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;
float
__subsf3 (float a1, float a2)
{
- register union float_long fl1, fl2;
+ union float_long fl1, fl2;
fl1.f = a1;
fl2.f = a2;
long
__cmpsf2 (float a1, float a2)
{
- register union float_long fl1, fl2;
+ union float_long fl1, fl2;
fl1.f = a1;
fl2.f = 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;
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;
/* 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)
}
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;
}
float
-__floatsisf (register long a1)
+__floatsisf (long a1)
{
(float)__floatsidf(a1);
}
float
-__floatdisf (register long long a1)
+__floatdisf (long long a1)
{
(float)__floatdidf(a1);
}
float
__negsf2 (float a1)
{
- register union float_long fl1;
+ union float_long fl1;
fl1.f = a1;
if (!fl1.l)
double
__negdf2 (double a1)
{
- register union double_long dl1;
+ union double_long dl1;
dl1.d = 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;
float
__truncdfsf2 (double a1)
OSDN Git Service
