+2001-03-14 Mark Mitchell <mark@codesourcery.com>
+
+ * varasm.c (assemble_alias): Use DECL_ASSEMBLER_NAME, not the
+ contents of the RTL, to determine the name of the object.
+
+2001-03-14 Mark Mitchell <mark@codesourcery.com>
+
+ * tree.h (DECL_RTL): Allocate RTL lazily.
+ (SET_DECL_RTL): New macro.
+ (DECL_RTL_SET_P): Likewise.
+ (COPY_DECL_RTL): Likewise.
+ (DECL_RTL_IF_SET): Likewise.
+ * varasm.c (make_decl_rtl): Add assertions about the kind of
+ declaration we are processing.
+ * c-decl.c (duplicate_decls): Use COPY_DECL_RTL, DECL_RTL_SET_P, etc.
+ (start_decl): Likewise.
+ (finish_decl): Likewise.
+ * c-semantics.c (emit_local_var): Likewise.
+ * calls.c (expand_call): Likewise.
+ * dbxout.c (dbxout_symbol): Likewise.
+ * emit-rtl.c (unshare_all_rtl): Likewise.
+ (unshare_all_decls): Likewise.
+ (reset_used_decls): Likewise.
+ * expr.c (store_constructor): Likewise.
+ (safe_from_p): Likewise.
+ (expand_expr): Likewise.
+ * function.c (put_var_into_stack): Likewise.
+ (instantiate_decls_1): Likewise.
+ (assign_parms): Likewise.
+ (expand_function_start): Likewise.
+ (expand_function_end): Likewise.
+ * ggc-common.c (gcc_mark_trees): Likewise.
+ * integrate.c (function_cannot_inline_p): Likewise.
+ (copy_decl_for_inlining): Likewise.
+ (expand_inline_function): Likewise.
+ (integrate_parm_decls): Likewise.
+ (integrate_decl_tree): Likewise.
+ * print-tree.c (print_node): Likewise.
+ * reg-stack.c (stack_result): Likewise.
+ * stmt.c (label_rtx): Likewise.
+ (expand_return): Likewise.
+ (expand_decl): Likewise.
+ (expand_decl_cleanup): Likewise.
+ (expand_anon_union_decl): Likewise.
+ * toplev.c (check_global_declarations): Likewise.
+ (rest_of_decl_compilation): Likewise.
+ * tree.c (simple_cst_equal): Likewise.
+ * objc/objc-act.c (generate_static_references): Likewise.
+
2001-03-14 Zack Weinberg <zackw@stanford.edu>
* aclocal.m4 (gcc_AC_C_CHARSET, gcc_AC_C_COMPILE_BIGENDIAN,
}
/* Keep the old rtl since we can safely use it. */
- DECL_RTL (newdecl) = DECL_RTL (olddecl);
+ COPY_DECL_RTL (olddecl, newdecl);
/* Merge the type qualifiers. */
if (TREE_CODE (olddecl) == FUNCTION_DECL
/* But not if this is a duplicate decl
and we preserved the rtl from the previous one
(which may or may not happen). */
- && DECL_RTL (tem) == 0
+ && !DECL_RTL_SET_P (tem)
&& !DECL_CONTEXT (tem))
{
if (TREE_TYPE (tem) != error_mark_node
if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
{
DECL_BUILT_IN_CLASS (decl) = NOT_BUILT_IN;
- DECL_RTL (decl) = 0;
+ SET_DECL_RTL (decl, NULL_RTX);
DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
}
tree decl;
{
/* Create RTL for this variable. */
- if (!DECL_RTL (decl))
+ if (!DECL_RTL_SET_P (decl))
{
if (DECL_C_HARD_REGISTER (decl))
/* The user specified an assembler name for this variable.
{
tree var = build_decl (VAR_DECL, NULL_TREE,
TREE_TYPE (args[i].tree_value));
- DECL_RTL (var) = expand_expr (args[i].tree_value, NULL_RTX,
- VOIDmode, EXPAND_NORMAL);
+ SET_DECL_RTL (var,
+ expand_expr (args[i].tree_value, NULL_RTX,
+ VOIDmode, EXPAND_NORMAL));
args[i].tree_value = var;
}
break;
+2001-03-14 Mark Mitchell <mark@codesourcery.com>
+
+ * class.c (build_clone): Use COPY_DECL_RTL, DECL_RTL_SET_P, etc.
+ * cp-tree.h (DECL_IN_MEMORY_P): Likewise.
+ * decl.c (duplicate_decls): Likewise.
+ (builtin_function): Likewise.
+ (build_library_fn): Likewise.
+ (build_cp_library_fn): Likewise.
+ (check_initializer): Likewise.
+ (cp_finish_decl): Likewise.
+ * decl2.c (grokfield): Likewise.
+ (grok_function_init): Remove #if 0'd code.
+ (finish_anon_union): Use COPY_DECL_RTL, DECL_RTL_SET_P, etc.
+ * friend.c (do_friend): Likewise.
+ * init.c (get_temp_regvar): Likewise.
+ * method.c (make_thunk): Likewise.
+ * pt.c (tsubst_friend_function): Likewise.
+ (tsubst_decl): Likewise.
+ (regenerate_decl_from_template): Likewise.
+ * semantics.c (genrtl_named_return_value): Likewise.
+ (expand_body): Likewise.
+ (genrtl_finish_function): Likewise.
+ * tree.c (cp_tree_equal): Likewise.
+
2001-03-12 Nathan Sidwell <nathan@codesourcery.com>
* call.c (convert_like_real): Add extra semantics to INNER
set_mangled_name_for_decl (clone);
/* Create the RTL for this function. */
- DECL_RTL (clone) = NULL_RTX;
+ SET_DECL_RTL (clone, NULL_RTX);
rest_of_decl_compilation (clone, NULL, /*top_level=*/1, at_eof);
/* Make it easy to find the CLONE given the FN. */
/* Complete the rtl for any static member objects of the type we're
working on. */
for (x = TYPE_FIELDS (t); x; x = TREE_CHAIN (x))
- {
- if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x)
- && TREE_TYPE (x) == t)
- {
- DECL_MODE (x) = TYPE_MODE (t);
- make_decl_rtl (x, NULL);
- }
- }
+ if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x)
+ && TREE_TYPE (x) == t)
+ DECL_MODE (x) = TYPE_MODE (t);
/* Done with FIELDS...now decide whether to sort these for
faster lookups later.
here because on most RISC machines, a variable's address
is not, by itself, a legitimate address. */
#define DECL_IN_MEMORY_P(NODE) \
- (DECL_RTL (NODE) != NULL_RTX && GET_CODE (DECL_RTL (NODE)) == MEM)
+ (DECL_RTL_SET_P (NODE) && GET_CODE (DECL_RTL (NODE)) == MEM)
/* For FUNCTION_DECLs: return the language in which this decl
was declared. */
that all remnants of the builtin-ness of this function
will be banished. */
DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
- DECL_RTL (olddecl) = DECL_RTL (newdecl);
+ SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
newdecl);
DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
/* Keep the old rtl since we can safely use it. */
- DECL_RTL (newdecl) = DECL_RTL (olddecl);
+ COPY_DECL_RTL (olddecl, newdecl);
if (TREE_CODE (newdecl) == FUNCTION_DECL)
{
{
DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
- DECL_RTL (olddecl) = DECL_RTL (newdecl);
+ SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
}
if (! types_match || new_defines_function)
{
DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
/* If we're keeping the built-in definition, keep the rtl,
regardless of declaration matches. */
- DECL_RTL (newdecl) = DECL_RTL (olddecl);
+ SET_DECL_RTL (newdecl, DECL_RTL (olddecl));
}
else
DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
function in the namespace. */
if (libname)
DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
- make_decl_rtl (decl, NULL);
/* Warn if a function in the namespace for users
is used without an occasion to consider it declared. */
tree name;
tree type;
{
- tree fn = build_library_fn_1 (name, ERROR_MARK, type);
- make_decl_rtl (fn, NULL);
- return fn;
+ return build_library_fn_1 (name, ERROR_MARK, type);
}
/* Returns the _DECL for a library function with C++ linkage. */
TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
set_mangled_name_for_decl (fn);
- make_decl_rtl (fn, NULL);
return fn;
}
}
else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
{
- if (TREE_STATIC (decl))
- make_decl_rtl (decl, NULL_PTR);
grok_reference_init (decl, type, init);
init = NULL_TREE;
}
{
/* This must override the asm specifier which was placed by
grokclassfn. Lay this out fresh. */
- DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
+ SET_DECL_RTL (TREE_TYPE (decl), NULL_RTX);
DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
make_decl_rtl (decl, asmspec);
}
{
/* This must override the asm specifier which was placed
by grokclassfn. Lay this out fresh. */
- DECL_RTL (value) = NULL_RTX;
+ SET_DECL_RTL (value, NULL_RTX);
DECL_ASSEMBLER_NAME (value) = get_identifier (asmspec);
}
cp_finish_decl (value, init, asmspec_tree, flags);
if (TREE_CODE (type) == FUNCTION_TYPE)
cp_error ("initializer specified for non-member function `%D'", decl);
-#if 0
- /* We'll check for this in finish_struct_1. */
- else if (DECL_VINDEX (decl) == NULL_TREE)
- cp_error ("initializer specified for non-virtual member function `%D'", decl);
-#endif
else if (integer_zerop (init))
{
-#if 0
- /* Mark this function as being "defined". */
- DECL_INITIAL (decl) = error_mark_node;
- /* pure virtual destructors must be defined. */
- /* pure virtual needs to be defined (as abort) only when put in
- vtbl. For wellformed call, it should be itself. pr4737 */
- if (!DECL_DESTRUCTOR_P (decl)))
- {
- /* Give this node rtl from `abort'. */
- DECL_RTL (decl) = DECL_RTL (abort_fndecl);
- }
-#endif
DECL_PURE_VIRTUAL_P (decl) = 1;
if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
{
if (static_p)
{
make_decl_rtl (main_decl, 0);
- DECL_RTL (anon_union_decl) = DECL_RTL (main_decl);
+ COPY_DECL_RTL (main_decl, anon_union_decl);
expand_anon_union_decl (anon_union_decl,
NULL_TREE,
DECL_ANON_UNION_ELEMS (anon_union_decl));
}
}
- make_decl_rtl (decl, NULL_PTR);
add_friend (current_class_type,
is_friend_template ? DECL_TI_TEMPLATE (decl) : decl);
DECL_FRIEND_P (decl) = 1;
if (building_stmt_tree ())
add_decl_stmt (decl);
if (!building_stmt_tree ())
- DECL_RTL (decl) = assign_temp (type, 2, 0, 1);
+ SET_DECL_RTL (decl, assign_temp (type, 2, 0, 1));
finish_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));
return decl;
DECL_DEFERRED_FN (thunk) = 0;
/* So that finish_file can write out any thunks that need to be: */
pushdecl_top_level (thunk);
- /* Create RTL for this thunk so that its address can be taken. */
- make_decl_rtl (thunk, NULL);
}
return thunk;
}
if (TREE_CODE (new_friend) != TEMPLATE_DECL)
{
set_mangled_name_for_decl (new_friend);
- DECL_RTL (new_friend) = 0;
- make_decl_rtl (new_friend, NULL_PTR);
+ SET_DECL_RTL (new_friend, NULL_RTX);
}
if (DECL_NAMESPACE_SCOPE_P (new_friend))
set_mangled_name_for_template_decl (r);
}
- DECL_RTL (r) = 0;
- make_decl_rtl (r, NULL_PTR);
+ SET_DECL_RTL (r, NULL_RTX);
/* Like grokfndecl. If we don't do this, pushdecl will
mess up our TREE_CHAIN because it doesn't find a
/* Don't try to expand the initializer until someone tries to use
this variable; otherwise we run into circular dependencies. */
DECL_INITIAL (r) = NULL_TREE;
- DECL_RTL (r) = 0;
+ SET_DECL_RTL (r, NULL_RTX);
DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
/* For __PRETTY_FUNCTION__ we have to adjust the initializer. */
details. */
DECL_TI_TEMPLATE (new_decl) = DECL_TI_TEMPLATE (decl);
DECL_ASSEMBLER_NAME (new_decl) = DECL_ASSEMBLER_NAME (decl);
- DECL_RTL (new_decl) = DECL_RTL (decl);
+ COPY_DECL_RTL (decl, new_decl);
DECL_USE_TEMPLATE (new_decl) = DECL_USE_TEMPLATE (decl);
/* Call duplicate decls to merge the old and new declarations. */
SImode but the DECL_RTL for the DECL_RESULT has DImode. So,
here, we use the mode the back-end has already assigned for
the return value. */
- DECL_RTL (decl) = gen_reg_rtx (GET_MODE (DECL_RTL (decl)));
+ SET_DECL_RTL (decl, gen_reg_rtx (GET_MODE (DECL_RTL (decl))));
if (TREE_ADDRESSABLE (decl))
put_var_into_stack (decl);
}
/* Or if this is a nested function. */
&& !decl_function_context (fn))
{
- /* Give the function RTL now so that we can assign it to a
- function pointer, etc. */
- make_decl_rtl (fn, NULL);
/* Set DECL_EXTERNAL so that assemble_external will be called as
necessary. We'll clear it again in finish_file. */
if (!DECL_EXTERNAL (fn))
was an actual function definition. */
DECL_INITIAL (fn) = error_mark_node;
for (t = DECL_ARGUMENTS (fn); t; t = TREE_CHAIN (t))
- DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
+ {
+ SET_DECL_RTL (t, NULL_RTX);
+ DECL_INCOMING_RTL (t) = NULL_RTX;
+ }
}
/* Let the error reporting routines know that we're outside a
as being equivalent to anything. */
if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
&& DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
- && DECL_RTL (TREE_OPERAND (t1, 0)) == 0)
+ && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
|| (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
&& DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
- && DECL_RTL (TREE_OPERAND (t2, 0)) == 0))
+ && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
cmp = 1;
else
cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
/* else it is something we handle like a normal variable. */
}
- DECL_RTL (decl) = eliminate_regs (DECL_RTL (decl), 0, NULL_RTX);
+ SET_DECL_RTL (decl, eliminate_regs (DECL_RTL (decl), 0, NULL_RTX));
#ifdef LEAF_REG_REMAP
if (current_function_uses_only_leaf_regs)
leaf_renumber_regs_insn (DECL_RTL (decl));
so that the debugging output will be accurate. */
DECL_INCOMING_RTL (parms)
= eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
- DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX);
+ SET_DECL_RTL (parms, eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
#ifdef LEAF_REG_REMAP
if (current_function_uses_only_leaf_regs)
{
/* Make sure that virtual parameters are not shared. */
for (decl = DECL_ARGUMENTS (fndecl); decl; decl = TREE_CHAIN (decl))
- DECL_RTL (decl) = copy_rtx_if_shared (DECL_RTL (decl));
+ SET_DECL_RTL (decl, copy_rtx_if_shared (DECL_RTL (decl)));
/* Make sure that virtual stack slots are not shared. */
unshare_all_decls (DECL_INITIAL (fndecl));
/* Copy shared decls. */
for (t = BLOCK_VARS (blk); t; t = TREE_CHAIN (t))
- DECL_RTL (t) = copy_rtx_if_shared (DECL_RTL (t));
+ if (DECL_RTL_SET_P (t))
+ SET_DECL_RTL (t, copy_rtx_if_shared (DECL_RTL (t)));
/* Now process sub-blocks. */
for (t = BLOCK_SUBBLOCKS (blk); t; t = TREE_CHAIN (t))
/* Mark decls. */
for (t = BLOCK_VARS (blk); t; t = TREE_CHAIN (t))
- reset_used_flags (DECL_RTL (t));
+ if (DECL_RTL_SET_P (t))
+ reset_used_flags (DECL_RTL (t));
/* Now process sub-blocks. */
for (t = BLOCK_SUBBLOCKS (blk); t; t = TREE_CHAIN (t))
index = build_decl (VAR_DECL, NULL_TREE, domain);
- DECL_RTL (index) = index_r
+ index_r
= gen_reg_rtx (promote_mode (domain, DECL_MODE (index),
&unsignedp, 0));
-
+ SET_DECL_RTL (index, index_r);
if (TREE_CODE (value) == SAVE_EXPR
&& SAVE_EXPR_RTL (value) == 0)
{
switch (TREE_CODE_CLASS (TREE_CODE (exp)))
{
case 'd':
- exp_rtl = DECL_RTL (exp);
+ exp_rtl = DECL_RTL_SET_P (exp) ? DECL_RTL (exp) : NULL_RTX;
break;
case 'c':
/* If VARS have not yet been expanded, expand them now. */
while (vars)
{
- if (DECL_RTL (vars) == 0)
+ if (!DECL_RTL_SET_P (vars))
{
vars_need_expansion = 1;
expand_decl (vars);
if (target == 0)
{
- if (DECL_RTL (slot) != 0)
+ if (DECL_RTL_SET_P (slot))
{
target = DECL_RTL (slot);
/* If we have already expanded the slot, so don't do
target = assign_temp (type, 2, 0, 1);
/* All temp slots at this level must not conflict. */
preserve_temp_slots (target);
- DECL_RTL (slot) = target;
+ SET_DECL_RTL (slot, target);
if (TREE_ADDRESSABLE (slot))
put_var_into_stack (slot);
/* If we have already assigned it space, use that space,
not target that we were passed in, as our target
parameter is only a hint. */
- if (DECL_RTL (slot) != 0)
+ if (DECL_RTL_SET_P (slot))
{
target = DECL_RTL (slot);
/* If we have already expanded the slot, so don't do
}
else
{
- DECL_RTL (slot) = target;
+ SET_DECL_RTL (slot, target);
/* If we must have an addressable slot, then make sure that
the RTL that we just stored in slot is OK. */
if (TREE_ADDRESSABLE (slot))
+Wed Mar 14 09:29:27 2001 Mark Mitchell <mark@codesourcery.com>
+
+ * com.c (ffecom_member_phase_2): Use COPY_DECL_RTL,
+ DECL_RTL_SET_P, etc.
+ (duplicate_decls): Likewise.
+ (start_decl): Likewise.
+
Fri Mar 9 22:52:55 2001 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
* fini.c (main): Use really_call_malloc, not malloc.
TREE_ASM_WRITTEN (t) = 1;
TREE_USED (t) = 1;
- DECL_RTL (t)
- = gen_rtx (MEM, TYPE_MODE (type),
- plus_constant (XEXP (DECL_RTL (mt), 0),
- ffestorag_modulo (mst)
- + ffestorag_offset (st)
- - ffestorag_offset (mst)));
+ SET_DECL_RTL (t,
+ gen_rtx (MEM, TYPE_MODE (type),
+ plus_constant (XEXP (DECL_RTL (mt), 0),
+ ffestorag_modulo (mst)
+ + ffestorag_offset (st)
+ - ffestorag_offset (mst))));
t = start_decl (t, FALSE);
}
/* Keep the old rtl since we can safely use it. */
- DECL_RTL (newdecl) = DECL_RTL (olddecl);
+ COPY_DECL_RTL (newdecl, olddecl);
/* Merge the type qualifiers. */
if (DECL_BUILT_IN_NONANSI (olddecl) && TREE_THIS_VOLATILE (olddecl)
if (!top_level
/* But not if this is a duplicate decl and we preserved the rtl from the
previous one (which may or may not happen). */
- && DECL_RTL (tem) == 0)
+ && !DECL_RTL_SET_P (tem))
{
if (TYPE_SIZE (TREE_TYPE (tem)) != 0)
expand_decl (tem);
context = decl_function_context (decl);
/* Get the current rtl used for this object and its original mode. */
- reg = TREE_CODE (decl) == SAVE_EXPR ? SAVE_EXPR_RTL (decl) : DECL_RTL (decl);
+ reg = (TREE_CODE (decl) == SAVE_EXPR
+ ? SAVE_EXPR_RTL (decl)
+ : DECL_RTL_IF_SET (decl));
/* No need to do anything if decl has no rtx yet
since in that case caller is setting TREE_ADDRESSABLE
tree t;
for (t = BLOCK_VARS (let); t; t = TREE_CHAIN (t))
- instantiate_decl (DECL_RTL (t), int_size_in_bytes (TREE_TYPE (t)),
- valid_only);
+ if (DECL_RTL_SET_P (t))
+ instantiate_decl (DECL_RTL (t),
+ int_size_in_bytes (TREE_TYPE (t)),
+ valid_only);
/* Process all subblocks. */
for (t = BLOCK_SUBBLOCKS (let); t; t = TREE_CHAIN (t))
|| TREE_CODE (parm) != PARM_DECL
|| passed_type == NULL)
{
- DECL_INCOMING_RTL (parm) = DECL_RTL (parm)
- = gen_rtx_MEM (BLKmode, const0_rtx);
+ SET_DECL_RTL (parm, gen_rtx_MEM (BLKmode, const0_rtx));
+ DECL_INCOMING_RTL (parm) = DECL_RTL (parm);
TREE_USED (parm) = 1;
continue;
}
and avoid the usual things like emit_move_insn that could crash. */
if (nominal_mode == VOIDmode)
{
- DECL_INCOMING_RTL (parm) = DECL_RTL (parm) = const0_rtx;
+ SET_DECL_RTL (parm, const0_rtx);
+ DECL_INCOMING_RTL (parm) = DECL_RTL (parm);
continue;
}
size_stored / UNITS_PER_WORD,
int_size_in_bytes (TREE_TYPE (parm)));
}
- DECL_RTL (parm) = stack_parm;
+ SET_DECL_RTL (parm, stack_parm);
}
else if (! ((! optimize
&& ! DECL_REGISTER (parm)
appropriately. */
if (passed_pointer)
{
- DECL_RTL (parm)
- = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (passed_type)), parmreg);
+ SET_DECL_RTL (parm,
+ gen_rtx_MEM (TYPE_MODE (TREE_TYPE (passed_type)),
+ parmreg));
set_mem_attributes (DECL_RTL (parm), parm, 1);
}
else
{
- DECL_RTL (parm) = parmreg;
+ SET_DECL_RTL (parm, parmreg);
maybe_set_unchanging (DECL_RTL (parm), parm);
}
if (GET_MODE (parmreg) != GET_MODE (DECL_RTL (parm)))
{
rtx tempreg = gen_reg_rtx (GET_MODE (DECL_RTL (parm)));
-
+ int unsigned_p = TREE_UNSIGNED (TREE_TYPE (parm));
push_to_sequence (conversion_insns);
emit_move_insn (tempreg, DECL_RTL (parm));
- DECL_RTL (parm)
- = convert_to_mode (GET_MODE (parmreg), tempreg,
- TREE_UNSIGNED (TREE_TYPE (parm)));
+ SET_DECL_RTL (parm,
+ convert_to_mode (GET_MODE (parmreg),
+ tempreg,
+ unsigned_p));
emit_move_insn (parmreg, DECL_RTL (parm));
conversion_insns = get_insns();
did_conversion = 1;
}
else
emit_move_insn (parmreg, DECL_RTL (parm));
- DECL_RTL (parm) = parmreg;
+ SET_DECL_RTL (parm, parmreg);
/* STACK_PARM is the pointer, not the parm, and PARMREG is
now the parm. */
stack_parm = 0;
conversion_insns = get_insns ();
end_sequence ();
}
- DECL_RTL (parm) = stack_parm;
+ SET_DECL_RTL (parm, stack_parm);
}
/* If this "parameter" was the place where we are receiving the
{
tree result = DECL_RESULT (fndecl);
- DECL_RTL (result)
- = gen_rtx_MEM (DECL_MODE (result), DECL_RTL (parm));
+ SET_DECL_RTL (result,
+ gen_rtx_MEM (DECL_MODE (result), DECL_RTL (parm)));
set_mem_attributes (DECL_RTL (result), result, 1);
}
to include tree.h. Do this here so it gets done when an inlined
function gets output. */
- current_function_return_rtx = DECL_RTL (DECL_RESULT (fndecl));
+ current_function_return_rtx
+ = (DECL_RTL_SET_P (DECL_RESULT (fndecl))
+ ? DECL_RTL (DECL_RESULT (fndecl)) : NULL_RTX);
}
\f
/* Indicate whether REGNO is an incoming argument to the current function
}
if (value_address)
{
- DECL_RTL (DECL_RESULT (subr))
- = gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr)), value_address);
+ SET_DECL_RTL (DECL_RESULT (subr),
+ gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr)),
+ value_address));
set_mem_attributes (DECL_RTL (DECL_RESULT (subr)),
DECL_RESULT (subr), 1);
}
}
else if (DECL_MODE (DECL_RESULT (subr)) == VOIDmode)
/* If return mode is void, this decl rtl should not be used. */
- DECL_RTL (DECL_RESULT (subr)) = 0;
+ SET_DECL_RTL (DECL_RESULT (subr), NULL_RTX);
else if (parms_have_cleanups || current_function_instrument_entry_exit)
{
/* If function will end with cleanup code for parms,
mode = promote_mode (type, mode, &unsignedp, 1);
#endif
- DECL_RTL (DECL_RESULT (subr)) = gen_reg_rtx (mode);
+ SET_DECL_RTL (DECL_RESULT (subr), gen_reg_rtx (mode));
}
else
/* Scalar, returned in a register. */
{
- DECL_RTL (DECL_RESULT (subr))
- = hard_function_value (TREE_TYPE (DECL_RESULT (subr)), subr, 1);
+ SET_DECL_RTL (DECL_RESULT (subr),
+ hard_function_value (TREE_TYPE (DECL_RESULT (subr)),
+ subr, 1));
/* Mark this reg as the function's return value. */
if (GET_CODE (DECL_RTL (DECL_RESULT (subr))) == REG)
/* If scalar return value was computed in a pseudo-reg, or was a named
return value that got dumped to the stack, copy that to the hard
return register. */
- if (DECL_RTL (DECL_RESULT (current_function_decl)) != 0)
+ if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl)))
{
tree decl_result = DECL_RESULT (current_function_decl);
rtx decl_rtl = DECL_RTL (decl_result);
ggc_mark_tree (DECL_ASSEMBLER_NAME (t));
ggc_mark_tree (DECL_SECTION_NAME (t));
ggc_mark_tree (DECL_MACHINE_ATTRIBUTES (t));
- ggc_mark_rtx (DECL_RTL (t));
+ if (DECL_RTL_SET_P (t))
+ ggc_mark_rtx (DECL_RTL (t));
ggc_mark_rtx (DECL_LIVE_RANGE_RTL (t));
ggc_mark_tree (DECL_VINDEX (t));
lang_mark_tree (t);
register int ninsns = 0;
register tree parms;
- rtx result;
if (DECL_UNINLINABLE (fndecl))
return N_("function cannot be inline");
}
/* We can't inline functions that return a PARALLEL rtx. */
- result = DECL_RTL (DECL_RESULT (fndecl));
- if (result && GET_CODE (result) == PARALLEL)
- return N_("inline functions not supported for this return value type");
+ if (DECL_RTL_SET_P (DECL_RESULT (fndecl)))
+ {
+ rtx result = DECL_RTL (DECL_RESULT (fndecl));
+ if (GET_CODE (result) == PARALLEL)
+ return N_("inline functions not supported for this return value type");
+ }
/* If the function has a target specific attribute attached to it,
then we assume that we should not inline it. This can be overriden
DECL_ABSTRACT_ORIGIN (copy) = DECL_ORIGIN (decl);
/* The new variable/label has no RTL, yet. */
- DECL_RTL (copy) = NULL_RTX;
+ SET_DECL_RTL (copy, NULL_RTX);
/* These args would always appear unused, if not for this. */
TREE_USED (copy) = 1;
REG_FUNCTION_RETURN_VALUE_P. */
map->inline_target = 0;
- loc = DECL_RTL (DECL_RESULT (fndecl));
+ loc = (DECL_RTL_SET_P (DECL_RESULT (fndecl))
+ ? DECL_RTL (DECL_RESULT (fndecl)) : NULL_RTX);
if (TYPE_MODE (type) == VOIDmode)
/* There is no return value to worry about. */
subst_constants. */
subst_constants (&new_decl_rtl, NULL_RTX, map, 1);
apply_change_group ();
- DECL_RTL (decl) = new_decl_rtl;
+ SET_DECL_RTL (decl, new_decl_rtl);
}
}
d = copy_decl_for_inlining (t, map->fndecl, current_function_decl);
- if (DECL_RTL (t) != 0)
+ if (DECL_RTL_SET_P (t))
{
- DECL_RTL (d) = copy_rtx_and_substitute (DECL_RTL (t), map, 1);
+ rtx r;
+
+ SET_DECL_RTL (d, copy_rtx_and_substitute (DECL_RTL (t), map, 1));
/* Fully instantiate the address with the equivalent form so that the
debugging information contains the actual register, instead of the
virtual register. Do this by not passing an insn to
subst_constants. */
- subst_constants (&DECL_RTL (d), NULL_RTX, map, 1);
+ r = DECL_RTL (d);
+ subst_constants (&r, NULL_RTX, map, 1);
+ SET_DECL_RTL (d, r);
apply_change_group ();
}
+2001-03-14 Mark Mitchell <mark@codesourcery.com>
+
+ * class.c (build_static_field_ref): Likewise.
+ (make_method_value): Likewise.
+ (get_dispatch_table): Likewise.
+
+ * decl.c (push_jvm_slot): Use COPY_DECL_RTL, DECL_RTL_SET_P, etc.
+
2001-03-07 Tom Tromey <tromey@redhat.com>
* config-lang.in (lang_requires): Define.
int is_compiled = is_compiled_class (fclass);
if (is_compiled)
{
- if (DECL_RTL (fdecl) == 0)
+ if (!DECL_RTL_SET_P (fdecl))
{
make_decl_rtl (fdecl, NULL);
if (is_compiled == 1)
#define ACC_TRANSLATED 0x4000
int accflags = get_access_flags_from_decl (mdecl) | ACC_TRANSLATED;
code = null_pointer_node;
- if (DECL_RTL (mdecl))
+ if (DECL_RTL_SET_P (mdecl))
code = build1 (ADDR_EXPR, nativecode_ptr_type_node, mdecl);
START_RECORD_CONSTRUCTOR (minit, method_type_node);
PUSH_FIELD_VALUE (minit, "name",
}
else
{
- if (DECL_RTL (method) == 0)
+ if (!DECL_RTL_SET_P (method))
make_decl_rtl (method, NULL);
method = build1 (ADDR_EXPR, nativecode_ptr_type_node, method);
}
while (tmp != NULL_TREE)
{
if (TYPE_MODE (type) == TYPE_MODE (TREE_TYPE (tmp)))
- rtl = DECL_RTL (tmp);
+ rtl = DECL_RTL_IF_SET (tmp);
if (rtl != NULL)
break;
tmp = DECL_LOCAL_SLOT_CHAIN (tmp);
}
if (rtl != NULL)
- DECL_RTL (decl) = rtl;
+ SET_DECL_RTL (decl, rtl);
else
{
if (index >= DECL_MAX_LOCALS (current_function_decl))
type = build_array_type (build_pointer_type (void_type_node), 0);
decl = build_decl (VAR_DECL, ident, type);
- make_decl_rtl (decl, 0);
TREE_USED (decl) = 1;
+ TREE_STATIC (decl) = 1;
decls
= tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, decl, 1), decls);
}
print_lang_decl (file, node, indent);
- if (DECL_RTL (node) != 0)
+ if (DECL_RTL_SET_P (node))
{
indent_to (file, indent + 4);
print_rtl (file, DECL_RTL (node));
if (aggregate_value_p (DECL_RESULT (decl)))
return 0;
- result = DECL_RTL (DECL_RESULT (decl));
+ result = DECL_RTL_IF_SET (DECL_RESULT (decl));
if (result != 0)
{
#ifdef FUNCTION_OUTGOING_VALUE
if (TREE_CODE (label) != LABEL_DECL)
abort ();
- if (DECL_RTL (label))
- return DECL_RTL (label);
+ if (!DECL_RTL_SET_P (label))
+ SET_DECL_RTL (label, gen_label_rtx ());
- return DECL_RTL (label) = gen_label_rtx ();
+ return DECL_RTL (label);
}
+
/* Add an unconditional jump to LABEL as the next sequential instruction. */
void
run destructors on variables that might be used in the subsequent
computation of the return value. */
rtx last_insn = 0;
- rtx result_rtl = DECL_RTL (DECL_RESULT (current_function_decl));
+ rtx result_rtl;
register rtx val = 0;
tree retval_rhs;
int cleanups;
return;
}
+ result_rtl = DECL_RTL (DECL_RESULT (current_function_decl));
+
/* If the result is an aggregate that is being returned in one (or more)
registers, load the registers here. The compiler currently can't handle
copying a BLKmode value into registers. We could put this code in a
/* Create the RTL representation for the variable. */
if (type == error_mark_node)
- DECL_RTL (decl) = gen_rtx_MEM (BLKmode, const0_rtx);
+ SET_DECL_RTL (decl, gen_rtx_MEM (BLKmode, const0_rtx));
else if (DECL_SIZE (decl) == 0)
/* Variable with incomplete type. */
{
if (DECL_INITIAL (decl) == 0)
/* Error message was already done; now avoid a crash. */
- DECL_RTL (decl) = gen_rtx_MEM (BLKmode, const0_rtx);
+ SET_DECL_RTL (decl, gen_rtx_MEM (BLKmode, const0_rtx));
else
/* An initializer is going to decide the size of this array.
Until we know the size, represent its address with a reg. */
- DECL_RTL (decl) = gen_rtx_MEM (BLKmode, gen_reg_rtx (Pmode));
+ SET_DECL_RTL (decl, gen_rtx_MEM (BLKmode, gen_reg_rtx (Pmode)));
set_mem_attributes (DECL_RTL (decl), decl, 1);
}
enum machine_mode reg_mode
= promote_mode (type, DECL_MODE (decl), &unsignedp, 0);
- DECL_RTL (decl) = gen_reg_rtx (reg_mode);
+ SET_DECL_RTL (decl, gen_reg_rtx (reg_mode));
mark_user_reg (DECL_RTL (decl));
if (POINTER_TYPE_P (type))
whose size was determined by the initializer.
The old address was a register; set that register now
to the proper address. */
- if (DECL_RTL (decl) != 0)
+ if (DECL_RTL_SET_P (decl))
{
if (GET_CODE (DECL_RTL (decl)) != MEM
|| GET_CODE (XEXP (DECL_RTL (decl), 0)) != REG)
oldaddr = XEXP (DECL_RTL (decl), 0);
}
- DECL_RTL (decl) = assign_temp (TREE_TYPE (decl), 1, 1, 1);
+ SET_DECL_RTL (decl,
+ assign_temp (TREE_TYPE (decl), 1, 1, 1));
/* Set alignment we actually gave this decl. */
DECL_ALIGN (decl) = (DECL_MODE (decl) == BLKmode ? BIGGEST_ALIGNMENT
TYPE_ALIGN (TREE_TYPE (decl)));
/* Reference the variable indirect through that rtx. */
- DECL_RTL (decl) = gen_rtx_MEM (DECL_MODE (decl), address);
+ SET_DECL_RTL (decl, gen_rtx_MEM (DECL_MODE (decl), address));
set_mem_attributes (DECL_RTL (decl), decl, 1);
emit_move_insn (flag, const1_rtx);
cond = build_decl (VAR_DECL, NULL_TREE, type_for_mode (word_mode, 1));
- DECL_RTL (cond) = flag;
+ SET_DECL_RTL (cond, flag);
/* Conditionalize the cleanup. */
cleanup = build (COND_EXPR, void_type_node,
if (GET_CODE (x) == MEM)
{
if (mode == GET_MODE (x))
- DECL_RTL (decl_elt) = x;
+ SET_DECL_RTL (decl_elt, x);
else
{
- DECL_RTL (decl_elt) = gen_rtx_MEM (mode, copy_rtx (XEXP (x, 0)));
+ SET_DECL_RTL (decl_elt,
+ gen_rtx_MEM (mode, copy_rtx (XEXP (x, 0))));
MEM_COPY_ATTRIBUTES (DECL_RTL (decl_elt), x);
}
}
else if (GET_CODE (x) == REG)
{
if (mode == GET_MODE (x))
- DECL_RTL (decl_elt) = x;
+ SET_DECL_RTL (decl_elt, x);
else
- DECL_RTL (decl_elt) = gen_rtx_SUBREG (mode, x, 0);
+ SET_DECL_RTL (decl_elt, gen_rtx_SUBREG (mode, x, 0));
}
else
abort ();
/* Cancel the RTL for this decl so that, if debugging info
output for global variables is still to come,
this one will be omitted. */
- DECL_RTL (decl) = NULL;
+ SET_DECL_RTL (decl, NULL_RTX);
/* Warn about any function
declared static but not defined.
|| TREE_CODE (decl) == FUNCTION_DECL)
{
timevar_push (TV_VARCONST);
- make_decl_rtl (decl, asmspec);
+ if (asmspec)
+ make_decl_rtl (decl, asmspec);
/* Don't output anything
when a tentative file-scope definition is seen.
But at end of compilation, do output code for them. */
{
if (decode_reg_name (asmspec) >= 0)
{
- DECL_RTL (decl) = 0;
+ SET_DECL_RTL (decl, NULL_RTX);
make_decl_rtl (decl, asmspec);
}
else
{
error ("invalid register name `%s' for register variable", asmspec);
DECL_REGISTER (decl) = 0;
- make_decl_rtl (decl, NULL);
+ if (!top_level)
+ expand_decl (decl);
}
}
#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
as being equivalent to anything. */
if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
&& DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
- && DECL_RTL (TREE_OPERAND (t1, 0)) == 0)
+ && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
|| (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
&& DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
- && DECL_RTL (TREE_OPERAND (t2, 0)) == 0))
+ && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
cmp = 1;
else
cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
PROMOTED_MODE is defined, the mode of this expression may not be same
as DECL_MODE. In that case, DECL_MODE contains the mode corresponding
to the variable's data type, while the mode
- of DECL_RTL is the mode actually used to contain the data. */
-#define DECL_RTL(NODE) (DECL_CHECK (NODE)->decl.rtl)
+ of DECL_RTL is the mode actually used to contain the data.
+
+ This value can be evaluated lazily for functions, variables with
+ static storage duration, and labels. */
+#define DECL_RTL(NODE) \
+ (DECL_CHECK (NODE)->decl.rtl \
+ ? (NODE)->decl.rtl \
+ : (make_decl_rtl (NODE, NULL), (NODE)->decl.rtl))
+/* Set the DECL_RTL for NODE to RTL. */
+#define SET_DECL_RTL(NODE, RTL) \
+ (DECL_CHECK (NODE)->decl.rtl = (RTL))
+/* Returns non-zero if the DECL_RTL for NODE has already been set. */
+#define DECL_RTL_SET_P(NODE) \
+ (DECL_CHECK (NODE)->decl.rtl != NULL)
+/* Copy the RTL from NODE1 to NODE2. If the RTL was not set for
+ NODE1, it will not be set for NODE2; this is a lazy copy. */
+#define COPY_DECL_RTL(NODE1, NODE2) \
+ (DECL_CHECK (NODE2)->decl.rtl = DECL_CHECK (NODE1)->decl.rtl)
+/* The DECL_RTL for NODE, if it is set, or NULL, if it is not set. */
+#define DECL_RTL_IF_SET(NODE) \
+ (DECL_RTL_SET_P (NODE) ? DECL_RTL (NODE) : NULL)
/* Holds an INSN_LIST of all of the live ranges in which the variable
has been moved to a possibly different register. */
#define DECL_LIVE_RANGE_RTL(NODE) (DECL_CHECK (NODE)->decl.live_range_rtl)
return -1;
}
\f
-/* Create the DECL_RTL for a declaration for a static or external variable
- or static or external function.
- ASMSPEC, if not 0, is the string which the user specified
- as the assembler symbol name.
+/* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL should
+ have static storage duration. In other words, it should not be an
+ automatic variable, including PARM_DECLs.
+
+ There is, however, one exception: this function handles variables
+ explicitly placed in a particular register by the user.
+
+ ASMSPEC, if not 0, is the string which the user specified as the
+ assembler symbol name.
This is never called for PARM_DECL nodes. */
const char *new_name = 0;
int reg_number;
+ /* Check that we are not being given an automatic variable. */
+ if (TREE_CODE (decl) == PARM_DECL
+ || TREE_CODE (decl) == RESULT_DECL
+ || (TREE_CODE (decl) == VAR_DECL
+ && !TREE_STATIC (decl)
+ && !DECL_EXTERNAL (decl)
+ && !DECL_REGISTER (decl)))
+ abort ();
+ /* And that we were not given a type or a label. */
+ else if (TREE_CODE (decl) == TYPE_DECL
+ || TREE_CODE (decl) == LABEL_DECL)
+ abort ();
+
/* For a duplicate declaration, we can be called twice on the
same DECL node. Don't discard the RTL already made. */
- if (DECL_RTL (decl) != 0)
+ if (DECL_RTL_SET_P (decl))
{
/* If the old RTL had the wrong mode, fix the mode. */
if (GET_MODE (DECL_RTL (decl)) != DECL_MODE (decl))
usage is somewhat suspect, we nevertheless use the following
kludge to avoid setting DECL_RTL to frame_pointer_rtx. */
- DECL_RTL (decl)
- = gen_rtx_REG (DECL_MODE (decl), FIRST_PSEUDO_REGISTER);
+ SET_DECL_RTL (decl,
+ gen_rtx_REG (DECL_MODE (decl),
+ FIRST_PSEUDO_REGISTER));
REGNO (DECL_RTL (decl)) = reg_number;
REG_USERVAR_P (DECL_RTL (decl)) = 1;
&& (TREE_PUBLIC (decl) || TREE_STATIC (decl)))))
TREE_SIDE_EFFECTS (decl) = 1;
- DECL_RTL (decl) = gen_rtx_MEM (DECL_MODE (decl),
- gen_rtx_SYMBOL_REF (Pmode, name));
+ SET_DECL_RTL (decl, gen_rtx_MEM (DECL_MODE (decl),
+ gen_rtx_SYMBOL_REF (Pmode, name)));
if (TREE_CODE (decl) != FUNCTION_DECL)
set_mem_attributes (DECL_RTL (decl), decl, 1);
{
const char *name;
- make_decl_rtl (decl, (char *) 0);
- name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
+ name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
#ifdef ASM_OUTPUT_DEF
/* Make name accessible from other files, if appropriate. */
projects / gcc.git / commitdiff