Skip to content

R
riscv-gcc-1
Commit 4dfa0342 by Richard Henderson Committed by Richard Henderson
Options

tree.def (RTL_EXPR): Remove. 

        * tree.def (RTL_EXPR): Remove.
        * c-typeck.c (lvalue_p): Don't handle it.
        * expr.c (safe_from_p): Likewise.
        (expand_expr_real_1): Likewise.
        * fold-const.c (non_lvalue, operand_equal_p, fold): Likewise.
        (fold_checksum_tree, tree_expr_nonnegative_p): Likewise.
        * gengtype.c (adjust_field_tree_exp): Likewise.
        * stmt.c (warn_if_unused_value): Likewise.
        * tree-gimple.c (recalculate_side_effects): Likewise.
        * tree-pretty-print.c (dump_generic_node): Likewise.
        * tree.c (make_node_stat, first_rtl_op, unsave_expr_1): Likewise.
        (unsafe_for_reeval, stabilize_reference, build1_stat): Likewise.
        * tree.h (RTL_EXPR_SEQUENCE, RTL_EXPR_RTL, RTL_EXPR_ALT_RTL): Remove.

        * stmt.c (struct stmt_status): Remove x_last_expr_type,
        x_last_expr_value, x_last_expr_alt_rtl, x_expr_stmts_for_value.
        (last_expr_type, last_expr_value, last_expr_alt_rtl): Remove.
        (expand_expr_stmt): Merge with expand_expr_stmt_value.  Remove
        all the bits that tracked last_expr.
        (expand_end_bindings): Don't track last_expr.
        (expand_start_stmt_expr, expand_end_stmt_expr): Remove.
        (clear_last_expr): Remove.
        (expand_asm): Don't call it.
        (expand_asm_operands, expand_end_cond): Likewise.
        (expand_naked_return, expand_null_return_1): Likewise.
        * c-typeck.c (c_begin_compound_stmt): Likewise.
        * cfgexpand.c (expand_block): Use expand_expr_stmt.
        * expr.c (expand_expr_real_1): Likewise.
        * tree.h: Update prototypes.

        * function.h (struct sequence_stack): Remove sequence_rtl_expr.
        (struct emit_status): Remove sequence_rtl_expr.
        (struct function): Remove x_rtl_expr_chain.
        (seq_rtl_expr, rtl_expr_chain): Remove.
        * function.c (struct temp_slot): Remove rtl_expr.
        (assign_stack_temp_for_type): Don't set it.
        (free_temp_slots, pop_temp_slots): Don't check it.
        (free_after_compilation): Don't clear x_rtl_expr_chain.
        (fixup_var_refs): Don't search it.
        (preserve_rtl_expr_result, free_temps_for_rtl_expr): Remove.
        * emit-rtl.c (start_sequence): Don't use sequence_rtl_expr
        or seq_rtl_expr.
        (push_topmost_sequence): Likewise.
        (end_sequence, init_emit): Likewise.
        (start_sequence_for_rtl_expr): Remove.
        * expmed.c (make_tree): Build a VAR_DECL instead of an RTL_EXPR.
        * rtl.h (preserve_rtl_expr_result): Remove.

ada/
        * trans.c (gnat_stabilize_reference): Don't handle RTL_EXPR.
        * utils.c (max_size): Likewise.

cp/
        * class.c (fixed_type_or_null): Don't handle RTL_EXPR.
        * method.c (synthesize_method): Don't clear_last_expr.
        * name-lookup.c (maybe_push_cleanup_level): Likewise.

From-SVN: r84009
parent f6fe65dc
Showing with 107 additions and 458 deletions
gcc/ChangeLog
2004-07-01 Richard Henderson <rth@redhat.com>
* tree.def (RTL_EXPR): Remove.
* c-typeck.c (lvalue_p): Don't handle it.
* expr.c (safe_from_p): Likewise.
(expand_expr_real_1): Likewise.
* fold-const.c (non_lvalue, operand_equal_p, fold): Likewise.
(fold_checksum_tree, tree_expr_nonnegative_p): Likewise.
* gengtype.c (adjust_field_tree_exp): Likewise.
* stmt.c (warn_if_unused_value): Likewise.
* tree-gimple.c (recalculate_side_effects): Likewise.
* tree-pretty-print.c (dump_generic_node): Likewise.
* tree.c (make_node_stat, first_rtl_op, unsave_expr_1): Likewise.
(unsafe_for_reeval, stabilize_reference, build1_stat): Likewise.
* tree.h (RTL_EXPR_SEQUENCE, RTL_EXPR_RTL, RTL_EXPR_ALT_RTL): Remove.
* stmt.c (struct stmt_status): Remove x_last_expr_type,
x_last_expr_value, x_last_expr_alt_rtl, x_expr_stmts_for_value.
(last_expr_type, last_expr_value, last_expr_alt_rtl): Remove.
(expand_expr_stmt): Merge with expand_expr_stmt_value. Remove
all the bits that tracked last_expr.
(expand_end_bindings): Don't track last_expr.
(expand_start_stmt_expr, expand_end_stmt_expr): Remove.
(clear_last_expr): Remove.
(expand_asm): Don't call it.
(expand_asm_operands, expand_end_cond): Likewise.
(expand_naked_return, expand_null_return_1): Likewise.
* c-typeck.c (c_begin_compound_stmt): Likewise.
* cfgexpand.c (expand_block): Use expand_expr_stmt.
* expr.c (expand_expr_real_1): Likewise.
* tree.h: Update prototypes.
* function.h (struct sequence_stack): Remove sequence_rtl_expr.
(struct emit_status): Remove sequence_rtl_expr.
(struct function): Remove x_rtl_expr_chain.
(seq_rtl_expr, rtl_expr_chain): Remove.
* function.c (struct temp_slot): Remove rtl_expr.
(assign_stack_temp_for_type): Don't set it.
(free_temp_slots, pop_temp_slots): Don't check it.
(free_after_compilation): Don't clear x_rtl_expr_chain.
(fixup_var_refs): Don't search it.
(preserve_rtl_expr_result, free_temps_for_rtl_expr): Remove.
* emit-rtl.c (start_sequence): Don't use sequence_rtl_expr
or seq_rtl_expr.
(push_topmost_sequence): Likewise.
(end_sequence, init_emit): Likewise.
(start_sequence_for_rtl_expr): Remove.
* expmed.c (make_tree): Build a VAR_DECL instead of an RTL_EXPR.
* rtl.h (preserve_rtl_expr_result): Remove.
2004-07-02 Kazu Hirata <kazu@cs.umass.edu>
* ifcvt.c, modulo-sched.c, tree-alias-common.c, tree-sra.c,
......
gcc/ada/ChangeLog
2004-07-01 Richard Henderson <rth@redhat.com>
* trans.c (gnat_stabilize_reference): Don't handle RTL_EXPR.
* utils.c (max_size): Likewise.
2004-06-28 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
* decl.c: Remove calls to add_decl_expr, pushdecl, rest_of_compilation,
......
gcc/ada/trans.c
......@@ -5501,12 +5501,6 @@ gnat_stabilize_reference (tree ref, int force)
force));
break;
case RTL_EXPR:
result = build1 (INDIRECT_REF, type,
save_expr (build1 (ADDR_EXPR,
build_reference_type (type), ref)));
break;
/* If arg isn't a kind of lvalue we recognize, make no change.
Caller should recognize the error for an invalid lvalue. */
default:
......
gcc/ada/utils.c
......@@ -2025,9 +2025,7 @@ max_size (tree exp, int max_p)
code == NEGATE_EXPR ? ! max_p : max_p)));
case 2:
if (code == RTL_EXPR)
gigi_abort (407);
else if (code == COMPOUND_EXPR)
if (code == COMPOUND_EXPR)
return max_size (TREE_OPERAND (exp, 1), max_p);
{
......
gcc/c-typeck.c
......@@ -2610,7 +2610,6 @@ lvalue_p (tree ref)
&& TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
case BIND_EXPR:
case RTL_EXPR:
return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
default:
......@@ -6809,10 +6808,7 @@ c_begin_compound_stmt (bool do_scope)
{
tree stmt = push_stmt_list ();
if (do_scope)
{
push_scope ();
clear_last_expr ();
}
push_scope ();
return stmt;
}
......
gcc/cfgexpand.c
......@@ -59,7 +59,7 @@ expand_block (basic_block bb, FILE * dump_file)
{
last = get_last_insn ();
expand_expr_stmt_value (stmt, 0, 0);
expand_expr_stmt (stmt);
/* Java emits line number notes in the top of labels.
??? Make this go away once line number notes are obsoleted. */
......@@ -179,7 +179,7 @@ expand_block (basic_block bb, FILE * dump_file)
case CALL_EXPR:
case MODIFY_EXPR:
case RETURN_EXPR:
expand_expr_stmt_value (stmt, 0, 0);
expand_expr_stmt (stmt);
for (last = NEXT_INSN (last); last; last = NEXT_INSN (last))
{
if (GET_CODE (last) == CALL_INSN && SIBLING_CALL_P (last))
......@@ -242,7 +242,7 @@ expand_block (basic_block bb, FILE * dump_file)
break;
default:
expand_expr_stmt_value (stmt, 0, 0);
expand_expr_stmt (stmt);
break;
}
}
......
gcc/cp/ChangeLog
2004-07-01 Richard Henderson <rth@redhat.com>
* class.c (fixed_type_or_null): Don't handle RTL_EXPR.
* method.c (synthesize_method): Don't clear_last_expr.
* name-lookup.c (maybe_push_cleanup_level): Likewise.
2004-07-01 Nick Clifton <nickc@redhat.com>
* decl2.c (import_export_class): Invoke the
......
gcc/cp/class.c
......@@ -5309,9 +5309,6 @@ fixed_type_or_null (tree instance, int* nonnull, int* cdtorp)
}
return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
case RTL_EXPR:
return NULL_TREE;
case PLUS_EXPR:
case MINUS_EXPR:
if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
......
gcc/cp/method.c
......@@ -740,7 +740,6 @@ synthesize_method (tree fndecl)
interface_unknown = 1;
start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
clear_last_expr ();
stmt = begin_function_body ();
if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
......
gcc/cp/name-lookup.c
......@@ -1440,7 +1440,6 @@ maybe_push_cleanup_level (tree type)
{
begin_scope (sk_cleanup, NULL);
current_binding_level->statement_list = push_stmt_list ();
clear_last_expr ();
}
}
......
gcc/emit-rtl.c
......@@ -4822,13 +4822,12 @@ emit (rtx x)
/* Space for free sequence stack entries. */
static GTY ((deletable)) struct sequence_stack *free_sequence_stack;
/* Begin emitting insns to a sequence which can be packaged in an
RTL_EXPR. If this sequence will contain something that might cause
the compiler to pop arguments to function calls (because those
pops have previously been deferred; see INHIBIT_DEFER_POP for more
details), use do_pending_stack_adjust before calling this function.
That will ensure that the deferred pops are not accidentally
emitted in the middle of this sequence. */
/* Begin emitting insns to a sequence. If this sequence will contain
something that might cause the compiler to pop arguments to function
calls (because those pops have previously been deferred; see
INHIBIT_DEFER_POP for more details), use do_pending_stack_adjust
before calling this function. That will ensure that the deferred
pops are not accidentally emitted in the middle of this sequence. */
void
start_sequence (void)
......@@ -4846,7 +4845,6 @@ start_sequence (void)
tem->next = seq_stack;
tem->first = first_insn;
tem->last = last_insn;
tem->sequence_rtl_expr = seq_rtl_expr;
seq_stack = tem;
......@@ -4854,18 +4852,6 @@ start_sequence (void)
last_insn = 0;
}
/* Similarly, but indicate that this sequence will be placed in T, an
RTL_EXPR. See the documentation for start_sequence for more
information about how to use this function. */
void
start_sequence_for_rtl_expr (tree t)
{
start_sequence ();
seq_rtl_expr = t;
}
/* Set up the insn chain starting with FIRST as the current sequence,
saving the previously current one. See the documentation for
start_sequence for more information about how to use this function. */
......@@ -4911,7 +4897,6 @@ push_topmost_sequence (void)
first_insn = top->first;
last_insn = top->last;
seq_rtl_expr = top->sequence_rtl_expr;
}
/* After emitting to the outer-level insn chain, update the outer-level
......@@ -4927,7 +4912,6 @@ pop_topmost_sequence (void)
top->first = first_insn;
top->last = last_insn;
/* ??? Why don't we save seq_rtl_expr here? */
end_sequence ();
}
......@@ -4952,7 +4936,6 @@ end_sequence (void)
first_insn = tem->first;
last_insn = tem->last;
seq_rtl_expr = tem->sequence_rtl_expr;
seq_stack = tem->next;
memset (tem, 0, sizeof (*tem));
......@@ -5168,7 +5151,6 @@ init_emit (void)
f->emit = ggc_alloc (sizeof (struct emit_status));
first_insn = NULL;
last_insn = NULL;
seq_rtl_expr = NULL;
cur_insn_uid = 1;
reg_rtx_no = LAST_VIRTUAL_REGISTER + 1;
last_location = UNKNOWN_LOCATION;
......
gcc/expmed.c
......@@ -4314,7 +4314,7 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
}
/* Return a tree node with data type TYPE, describing the value of X.
Usually this is an RTL_EXPR, if there is no obvious better choice.
Usually this is an VAR_DECL, if there is no obvious better choice.
X may be an expression, however we only support those expressions
generated by loop.c. */
......@@ -4424,19 +4424,16 @@ make_tree (tree type, rtx x)
GET_CODE (x) == ZERO_EXTEND);
return fold (convert (type, make_tree (t, XEXP (x, 0))));
default:
t = make_node (RTL_EXPR);
TREE_TYPE (t) = type;
default:
t = build_decl (VAR_DECL, NULL_TREE, type);
/* If TYPE is a POINTER_TYPE, X might be Pmode with TYPE_MODE being
ptr_mode. So convert. */
if (POINTER_TYPE_P (type))
x = convert_memory_address (TYPE_MODE (type), x);
RTL_EXPR_RTL (t) = x;
/* There are no insns to be output
when this rtl_expr is used. */
RTL_EXPR_SEQUENCE (t) = 0;
SET_DECL_RTL (t, x);
return t;
}
}
......
gcc/expr.c
......@@ -1533,9 +1533,7 @@ emit_block_move_via_libcall (rtx dst, rtx src, rtx size)
could get the wrong value for an argument.
To avoid this problem we go ahead and emit code to copy the addresses of
DST and SRC and SIZE into new pseudos. We can then place those new
pseudos into an RTL_EXPR and use them later, even after a call to
emit_queue.
DST and SRC and SIZE into new pseudos.
Note this is not strictly needed for library calls since they do not call
emit_queue before loading their arguments. However, we may need to have
......@@ -2665,9 +2663,7 @@ clear_storage_via_libcall (rtx object, rtx size)
not careful we could get the wrong value for an argument.
To avoid this problem we go ahead and emit code to copy OBJECT
and SIZE into new pseudos. We can then place those new pseudos
into an RTL_EXPR and use them later, even after a call to
emit_queue.
and SIZE into new pseudos.
Note this is not strictly needed for library calls since they
do not call emit_queue before loading their arguments. However,
......@@ -6138,16 +6134,6 @@ safe_from_p (rtx x, tree exp, int top_p)
return 0;
break;
case RTL_EXPR:
/* If a sequence exists, we would have to scan every instruction
in the sequence to see if it was safe. This is probably not
worthwhile. */
if (RTL_EXPR_SEQUENCE (exp))
return 0;
exp_rtl = RTL_EXPR_RTL (exp);
break;
case WITH_CLEANUP_EXPR:
exp_rtl = WITH_CLEANUP_EXPR_RTL (exp);
break;
......@@ -6962,7 +6948,7 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
case LABELED_BLOCK_EXPR:
if (LABELED_BLOCK_BODY (exp))
expand_expr_stmt_value (LABELED_BLOCK_BODY (exp), 0, 1);
expand_expr_stmt (LABELED_BLOCK_BODY (exp));
/* Should perhaps use expand_label, but this is simpler and safer. */
do_pending_stack_adjust ();
emit_label (label_rtx (LABELED_BLOCK_LABEL (exp)));
......@@ -6979,32 +6965,10 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
tree block = BIND_EXPR_BLOCK (exp);
int mark_ends;
if (TREE_CODE (BIND_EXPR_BODY (exp)) != RTL_EXPR)
{
/* If we're in functions-as-trees mode, this BIND_EXPR represents
the block, so we need to emit NOTE_INSN_BLOCK_* notes. */
mark_ends = (block != NULL_TREE);
expand_start_bindings_and_block (mark_ends ? 0 : 2, block);
}
else
{
/* If we're not in functions-as-trees mode, we've already emitted
those notes into our RTL_EXPR, so we just want to splice our BLOCK
into the enclosing one. */
mark_ends = 0;
/* Need to open a binding contour here because
if there are any cleanups they must be contained here. */
expand_start_bindings_and_block (2, NULL_TREE);
/* Mark the corresponding BLOCK for output in its proper place. */
if (block)
{
if (TREE_USED (block))
abort ();
lang_hooks.decls.insert_block (block);
}
}
/* If we're in functions-as-trees mode, this BIND_EXPR represents
the block, so we need to emit NOTE_INSN_BLOCK_* notes. */
mark_ends = (block != NULL_TREE);
expand_start_bindings_and_block (mark_ends ? 0 : 2, block);
/* If VARS have not yet been expanded, expand them now. */
expand_vars (BIND_EXPR_VARS (exp));
......@@ -7021,20 +6985,6 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
return temp;
}
case RTL_EXPR:
if (RTL_EXPR_SEQUENCE (exp))
{
if (RTL_EXPR_SEQUENCE (exp) == const0_rtx)
abort ();
emit_insn (RTL_EXPR_SEQUENCE (exp));
RTL_EXPR_SEQUENCE (exp) = const0_rtx;
}
preserve_rtl_expr_result (RTL_EXPR_RTL (exp));
free_temps_for_rtl_expr (exp);
if (alt_rtl)
*alt_rtl = RTL_EXPR_ALT_RTL (exp);
return RTL_EXPR_RTL (exp);
case CONSTRUCTOR:
/* If we don't need the result, just ensure we evaluate any
subexpressions. */
......@@ -7913,7 +7863,7 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
&& (GET_MODE_CLASS (mode) == MODE_INT)
? addv_optab : add_optab;
/* If we are adding a constant, an RTL_EXPR that is sp, fp, or ap, and
/* If we are adding a constant, a VAR_DECL that is sp, fp, or ap, and
something else, make sure we add the register to the constant and
then to the other thing. This case can occur during strength
reduction and doing it this way will produce better code if the
......@@ -7926,10 +7876,10 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
if (TREE_CODE (TREE_OPERAND (exp, 0)) == PLUS_EXPR
&& TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 1)) == INTEGER_CST
&& TREE_CODE (TREE_OPERAND (exp, 1)) == RTL_EXPR
&& (RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == frame_pointer_rtx
|| RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == stack_pointer_rtx
|| RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == arg_pointer_rtx))
&& TREE_CODE (TREE_OPERAND (exp, 1)) == VAR_DECL
&& (DECL_RTL (TREE_OPERAND (exp, 1)) == frame_pointer_rtx
|| DECL_RTL (TREE_OPERAND (exp, 1)) == stack_pointer_rtx
|| DECL_RTL (TREE_OPERAND (exp, 1)) == arg_pointer_rtx))
{
tree t = TREE_OPERAND (exp, 1);
......
gcc/fold-const.c
......@@ -2041,7 +2041,6 @@ non_lvalue (tree x)
case BIND_EXPR:
case MIN_EXPR:
case MAX_EXPR:
case RTL_EXPR:
break;
default:
......@@ -2530,9 +2529,6 @@ operand_equal_p (tree arg0, tree arg1, unsigned int flags)
&& operand_equal_p (TREE_OPERAND (arg0, 1),
TREE_OPERAND (arg1, 0), flags));
case RTL_EXPR:
return rtx_equal_p (RTL_EXPR_RTL (arg0), RTL_EXPR_RTL (arg1));
case CALL_EXPR:
/* If the CALL_EXPRs call different functions, then they
clearly can not be equal. */
......@@ -5975,9 +5971,8 @@ fold (tree expr)
if all operands are constant. */
int wins = 1;
/* Don't try to process an RTL_EXPR since its operands aren't trees.
Likewise for a SAVE_EXPR that's already been evaluated. */
if (code == RTL_EXPR || (code == SAVE_EXPR && SAVE_EXPR_RTL (t) != 0))
/* Don't try to process an SAVE_EXPR that's already been evaluated. */
if (code == SAVE_EXPR && SAVE_EXPR_RTL (t) != 0)
return t;
/* Return right away if a constant. */
......@@ -9058,7 +9053,6 @@ fold_checksum_tree (tree expr, struct md5_ctx *ctx, htab_t ht)
{
case SAVE_EXPR: len = 2; break;
case GOTO_SUBROUTINE_EXPR: len = 0; break;
case RTL_EXPR: len = 0; break;
case WITH_CLEANUP_EXPR: len = 2; break;
default: break;
}
......@@ -9376,8 +9370,6 @@ tree_expr_nonnegative_p (tree t)
return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
case FLOAT_EXPR:
return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
case RTL_EXPR:
return rtl_expr_nonnegative_p (RTL_EXPR_RTL (t));
case TARGET_EXPR:
{
......
gcc/function.c
......@@ -186,8 +186,6 @@ struct temp_slot GTY(())
It can be reused if objects of the type of the new slot will always
conflict with objects of the type of the old slot. */
tree type;
/* The value of `sequence_rtl_expr' when this temporary is allocated. */
tree rtl_expr;
/* Nonzero if this temporary is currently in use. */
char in_use;
/* Nonzero if this temporary has its address taken. */
......@@ -440,7 +438,6 @@ free_after_compilation (struct function *f)
f->x_naked_return_label = NULL;
f->x_save_expr_regs = NULL;
f->x_stack_slot_list = NULL;
f->x_rtl_expr_chain = NULL;
f->x_tail_recursion_reentry = NULL;
f->x_arg_pointer_save_area = NULL;
f->x_parm_birth_insn = NULL;
......@@ -768,7 +765,6 @@ assign_stack_temp_for_type (enum machine_mode mode, HOST_WIDE_INT size, int keep
rounded_size));
p->align = best_p->align;
p->address = 0;
p->rtl_expr = 0;
p->type = best_p->type;
insert_slot_to_list (p, &avail_temp_slots);
......@@ -834,7 +830,6 @@ assign_stack_temp_for_type (enum machine_mode mode, HOST_WIDE_INT size, int keep
p = selected;
p->in_use = 1;
p->addr_taken = 0;
p->rtl_expr = seq_rtl_expr;
p->type = type;
if (keep == 2)
......@@ -1230,39 +1225,8 @@ preserve_temp_slots (rtx x)
}
}
/* X is the result of an RTL_EXPR. If it is a temporary slot associated
with that RTL_EXPR, promote it into a temporary slot at the present
level so it will not be freed when we free slots made in the
RTL_EXPR. */
void
preserve_rtl_expr_result (rtx x)
{
struct temp_slot *p;
/* If X is not in memory or is at a constant address, it cannot be in
a temporary slot. */
if (x == 0 || !MEM_P (x) || CONSTANT_P (XEXP (x, 0)))
return;
/* If we can find a match, move it to our level unless it is already at
an upper level. */
p = find_temp_slot_from_address (XEXP (x, 0));
if (p != 0)
{
move_slot_to_level (p, MIN (p->level, temp_slot_level));
p->rtl_expr = 0;
}
return;
}
/* Free all temporaries used so far. This is normally called at the end
of generating code for a statement. Don't free any temporaries
currently in use for an RTL_EXPR that hasn't yet been emitted.
We could eventually do better than this since it can be reused while
generating the same RTL_EXPR, but this is complex and probably not
worthwhile. */
/* Free all temporaries used so far. This is normally called at the
end of generating code for a statement. */
void
free_temp_slots (void)
......@@ -1273,40 +1237,13 @@ free_temp_slots (void)
{
next = p->next;
if (!p->keep && p->rtl_expr == 0)
if (!p->keep)
make_slot_available (p);
}
combine_temp_slots ();
}
/* Free all temporary slots used in T, an RTL_EXPR node. */
void
free_temps_for_rtl_expr (tree t)
{
struct temp_slot *p, *next;
for (p = *temp_slots_at_level (temp_slot_level); p; p = next)
{
next = p->next;
if (p->rtl_expr == t)
{
/* If this slot is below the current TEMP_SLOT_LEVEL, then it
needs to be preserved. This can happen if a temporary in
the RTL_EXPR was addressed; preserve_temp_slots will move
the temporary into a higher level. */
if (temp_slot_level <= p->level)
make_slot_available (p);
else
p->rtl_expr = NULL_TREE;
}
}
combine_temp_slots ();
}
/* Push deeper into the nesting level for stack temporaries. */
void
......@@ -1326,9 +1263,7 @@ pop_temp_slots (void)
for (p = *temp_slots_at_level (temp_slot_level); p; p = next)
{
next = p->next;
if (p->rtl_expr == 0)
make_slot_available (p);
make_slot_available (p);
}
combine_temp_slots ();
......@@ -1587,10 +1522,8 @@ static void
fixup_var_refs (rtx var, enum machine_mode promoted_mode, int unsignedp,
rtx may_share, htab_t ht)
{
tree pending;
rtx first_insn = get_insns ();
struct sequence_stack *stack = seq_stack;
tree rtl_exps = rtl_expr_chain;
int save_volatile_ok = volatile_ok;
/* If there's a hash table, it must record all uses of VAR. */
......@@ -1621,19 +1554,6 @@ fixup_var_refs (rtx var, enum machine_mode promoted_mode, int unsignedp,
end_sequence ();
}
/* Scan all waiting RTL_EXPRs too. */
for (pending = rtl_exps; pending; pending = TREE_CHAIN (pending))
{
rtx seq = RTL_EXPR_SEQUENCE (TREE_VALUE (pending));
if (seq != const0_rtx && seq != 0)
{
push_to_sequence (seq);
fixup_var_refs_insns (seq, var, promoted_mode, unsignedp, 0,
may_share);
end_sequence ();
}
}
volatile_ok = save_volatile_ok;
}
......
gcc/function.h
......@@ -40,7 +40,6 @@ struct sequence_stack GTY(())
/* First and last insns in the chain of the saved sequence. */
rtx first;
rtx last;
tree sequence_rtl_expr;
struct sequence_stack *next;
};
......@@ -66,16 +65,11 @@ struct emit_status GTY(())
/* The ends of the doubly-linked chain of rtl for the current function.
Both are reset to null at the start of rtl generation for the function.
start_sequence saves both of these on `sequence_stack' along with
`sequence_rtl_expr' and then starts a new, nested sequence of insns. */
start_sequence saves both of these on `sequence_stack' and then starts
a new, nested sequence of insns. */
rtx x_first_insn;
rtx x_last_insn;
/* RTL_EXPR within which the current sequence will be placed. Use to
prevent reuse of any temporaries within the sequence until after the
RTL_EXPR is emitted. */
tree sequence_rtl_expr;
/* Stack of pending (incomplete) sequences saved by `start_sequence'.
Each element describes one pending sequence.
The main insn-chain is saved in the last element of the chain,
......@@ -112,7 +106,6 @@ struct emit_status GTY(())
/* For backward compatibility... eventually these should all go away. */
#define reg_rtx_no (cfun->emit->x_reg_rtx_no)
#define seq_rtl_expr (cfun->emit->sequence_rtl_expr)
#define regno_reg_rtx (cfun->emit->x_regno_reg_rtx)
#define seq_stack (cfun->emit->sequence_stack)
......@@ -258,9 +251,6 @@ struct function GTY(())
Made for the sake of unshare_all_rtl. */
rtx x_stack_slot_list;
/* Chain of all RTL_EXPRs that have insns in them. */
tree x_rtl_expr_chain;
/* Place after which to insert the tail_recursion_label if we need one. */
rtx x_tail_recursion_reentry;
......@@ -522,7 +512,6 @@ extern int trampolines_created;
#define frame_offset (cfun->x_frame_offset)
#define tail_recursion_reentry (cfun->x_tail_recursion_reentry)
#define arg_pointer_save_area (cfun->x_arg_pointer_save_area)
#define rtl_expr_chain (cfun->x_rtl_expr_chain)
#define used_temp_slots (cfun->x_used_temp_slots)
#define avail_temp_slots (cfun->x_avail_temp_slots)
#define temp_slot_level (cfun->x_temp_slot_level)
......
gcc/gengtype.c
......@@ -652,7 +652,6 @@ adjust_field_tree_exp (type_p t, options_p opt ATTRIBUTE_UNUSED)
} data[] = {
{ "SAVE_EXPR", 2, 1 },
{ "GOTO_SUBROUTINE_EXPR", 0, 2 },
{ "RTL_EXPR", 0, 2 },
{ "WITH_CLEANUP_EXPR", 2, 1 },
};
......
gcc/rtl.h
......@@ -2278,7 +2278,6 @@ extern void reposition_prologue_and_epilogue_notes (rtx);
extern void thread_prologue_and_epilogue_insns (rtx);
extern int prologue_epilogue_contains (rtx);
extern int sibcall_epilogue_contains (rtx);
extern void preserve_rtl_expr_result (rtx);
extern void mark_temp_addr_taken (rtx);
extern void update_temp_slot_address (rtx, rtx);
extern void purge_addressof (rtx);
......
gcc/stmt.c
......@@ -335,16 +335,6 @@ struct stmt_status GTY(())
/* Number of binding contours started so far in this function. */
int x_block_start_count;
/* Each time we expand an expression-statement,
record the expr's type and its RTL value here. */
tree x_last_expr_type;
rtx x_last_expr_value;
rtx x_last_expr_alt_rtl;
/* Nonzero if within a ({...}) grouping, in which case we must
always compute a value for each expr-stmt in case it is the last one. */
int x_expr_stmts_for_value;
/* Location of last line-number note, whether we actually
emitted it or not. */
location_t x_emit_locus;
......@@ -359,10 +349,6 @@ struct stmt_status GTY(())
#define nesting_stack (cfun->stmt->x_nesting_stack)
#define nesting_depth (cfun->stmt->x_nesting_depth)
#define current_block_start_count (cfun->stmt->x_block_start_count)
#define last_expr_type (cfun->stmt->x_last_expr_type)
#define last_expr_value (cfun->stmt->x_last_expr_value)
#define last_expr_alt_rtl (cfun->stmt->x_last_expr_alt_rtl)
#define expr_stmts_for_value (cfun->stmt->x_expr_stmts_for_value)
#define emit_locus (cfun->stmt->x_emit_locus)
#define goto_fixup_chain (cfun->stmt->x_goto_fixup_chain)
......@@ -976,8 +962,6 @@ expand_asm (tree string, int vol)
MEM_VOLATILE_P (body) = vol;
emit_insn (body);
clear_last_expr ();
}
/* Parse the output constraint pointed to by *CONSTRAINT_P. It is the
......@@ -1414,8 +1398,6 @@ expand_asm_operands (tree string, tree outputs, tree inputs,
}
}
clear_last_expr ();
/* First pass over inputs and outputs checks validity and sets
mark_addressable if needed. */
......@@ -2054,56 +2036,15 @@ resolve_operand_name_1 (char *p, tree outputs, tree inputs)
return p;
}
/* Generate RTL to evaluate the expression EXP
and remember it in case this is the VALUE in a ({... VALUE; }) constr.
Provided just for backward-compatibility. expand_expr_stmt_value()
should be used for new code. */
/* Generate RTL to evaluate the expression EXP. */
void
expand_expr_stmt (tree exp)
{
expand_expr_stmt_value (exp, -1, 1);
}
/* Generate RTL to evaluate the expression EXP. WANT_VALUE tells
whether to (1) save the value of the expression, (0) discard it or
(-1) use expr_stmts_for_value to tell. The use of -1 is
deprecated, and retained only for backward compatibility. */
void
expand_expr_stmt_value (tree exp, int want_value, int maybe_last)
{
rtx value;
tree type;
rtx alt_rtl = NULL;
if (want_value == -1)
want_value = expr_stmts_for_value != 0;
/* If -Wextra, warn about statements with no side effects,
except for an explicit cast to void (e.g. for assert()), and
except for last statement in ({...}) where they may be useful. */
if (! want_value
&& (expr_stmts_for_value == 0 || ! maybe_last)
&& exp != error_mark_node
&& warn_unused_value)
{
if (TREE_SIDE_EFFECTS (exp))
warn_if_unused_value (exp, emit_locus);
else if (!VOID_TYPE_P (TREE_TYPE (exp)) && !TREE_NO_WARNING (exp))
warning ("%Hstatement with no effect", &emit_locus);
}
/* If EXP is of function type and we are expanding statements for
value, convert it to pointer-to-function. */
if (want_value && TREE_CODE (TREE_TYPE (exp)) == FUNCTION_TYPE)
exp = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (exp)), exp);
/* The call to `expand_expr' could cause last_expr_type and
last_expr_value to get reset. Therefore, we set last_expr_value
and last_expr_type *after* calling expand_expr. */
value = expand_expr_real (exp, want_value ? NULL_RTX : const0_rtx,
VOIDmode, 0, &alt_rtl);
value = expand_expr (exp, const0_rtx, VOIDmode, 0);
type = TREE_TYPE (exp);
/* If all we do is reference a volatile value in memory,
......@@ -2127,22 +2068,9 @@ expand_expr_stmt_value (tree exp, int want_value, int maybe_last)
}
}
/* If this expression is part of a ({...}) and is in memory, we may have
to preserve temporaries. */
preserve_temp_slots (value);
/* Free any temporaries used to evaluate this expression. Any temporary
used as a result of this expression will already have been preserved
above. */
/* Free any temporaries used to evaluate this expression. */
free_temp_slots ();
if (want_value)
{
last_expr_value = value;
last_expr_alt_rtl = alt_rtl;
last_expr_type = type;
}
emit_queue ();
}
......@@ -2176,7 +2104,6 @@ warn_if_unused_value (tree exp, location_t locus)
case INIT_EXPR:
case TARGET_EXPR:
case CALL_EXPR:
case RTL_EXPR:
case TRY_CATCH_EXPR:
case WITH_CLEANUP_EXPR:
case EXIT_EXPR:
......@@ -2263,90 +2190,6 @@ warn_if_unused_value (tree exp, location_t locus)
return 1;
}
}
/* Clear out the memory of the last expression evaluated. */
void
clear_last_expr (void)
{
last_expr_type = NULL_TREE;
last_expr_value = NULL_RTX;
last_expr_alt_rtl = NULL_RTX;
}
/* Begin a statement-expression, i.e., a series of statements which
may return a value. Return the RTL_EXPR for this statement expr.
The caller must save that value and pass it to
expand_end_stmt_expr. If HAS_SCOPE is nonzero, temporaries created
in the statement-expression are deallocated at the end of the
expression. */
tree
expand_start_stmt_expr (int has_scope)
{
tree t;
/* Make the RTL_EXPR node temporary, not momentary,
so that rtl_expr_chain doesn't become garbage. */
t = make_node (RTL_EXPR);
do_pending_stack_adjust ();
if (has_scope)
start_sequence_for_rtl_expr (t);
else
start_sequence ();
NO_DEFER_POP;
expr_stmts_for_value++;
return t;
}
/* Restore the previous state at the end of a statement that returns a value.
Returns a tree node representing the statement's value and the
insns to compute the value.
The nodes of that expression have been freed by now, so we cannot use them.
But we don't want to do that anyway; the expression has already been
evaluated and now we just want to use the value. So generate a RTL_EXPR
with the proper type and RTL value.
If the last substatement was not an expression,
return something with type `void'. */
tree
expand_end_stmt_expr (tree t)
{
OK_DEFER_POP;
if (! last_expr_value || ! last_expr_type)
{
last_expr_value = const0_rtx;
last_expr_alt_rtl = NULL_RTX;
last_expr_type = void_type_node;
}
else if (!REG_P (last_expr_value) && ! CONSTANT_P (last_expr_value))
/* Remove any possible QUEUED. */
last_expr_value = protect_from_queue (last_expr_value, 0);
emit_queue ();
TREE_TYPE (t) = last_expr_type;
RTL_EXPR_RTL (t) = last_expr_value;
RTL_EXPR_ALT_RTL (t) = last_expr_alt_rtl;
RTL_EXPR_SEQUENCE (t) = get_insns ();
rtl_expr_chain = tree_cons (NULL_TREE, t, rtl_expr_chain);
end_sequence ();
/* Don't consider deleting this expr or containing exprs at tree level. */
TREE_SIDE_EFFECTS (t) = 1;
/* Propagate volatility of the actual RTL expr. */
TREE_THIS_VOLATILE (t) = volatile_refs_p (last_expr_value);
clear_last_expr ();
expr_stmts_for_value--;
return t;
}
/* Generate RTL for the start of an if-then. COND is the expression
whose truth should be tested.
......@@ -2430,7 +2273,6 @@ expand_end_cond (void)
emit_label (thiscond->data.cond.endif_label);
POPSTACK (cond_stack);
clear_last_expr ();
}
/* Return nonzero if we should preserve sub-expressions as separate
......@@ -2481,7 +2323,6 @@ expand_naked_return (void)
clear_pending_stack_adjust ();
do_pending_stack_adjust ();
clear_last_expr ();
if (end_label == 0)
end_label = naked_return_label = gen_label_rtx ();
......@@ -2604,7 +2445,6 @@ expand_null_return_1 (rtx last_insn)
clear_pending_stack_adjust ();
do_pending_stack_adjust ();
clear_last_expr ();
if (end_label == 0)
end_label = return_label = gen_label_rtx ();
......@@ -3112,13 +2952,6 @@ expand_end_bindings (tree vars, int mark_ends ATTRIBUTE_UNUSED,
int reachable;
rtx insn;
/* Don't let cleanups affect ({...}) constructs. */
int old_expr_stmts_for_value = expr_stmts_for_value;
rtx old_last_expr_value = last_expr_value;
rtx old_last_expr_alt_rtl = last_expr_alt_rtl;
tree old_last_expr_type = last_expr_type;
expr_stmts_for_value = 0;
/* Only clean up here if this point can actually be reached. */
insn = get_last_insn ();
if (GET_CODE (insn) == NOTE)
......@@ -3130,11 +2963,6 @@ expand_end_bindings (tree vars, int mark_ends ATTRIBUTE_UNUSED,
if (reachable)
do_pending_stack_adjust ();
expr_stmts_for_value = old_expr_stmts_for_value;
last_expr_value = old_last_expr_value;
last_expr_alt_rtl = old_last_expr_alt_rtl;
last_expr_type = old_last_expr_type;
/* Restore the stack level. */
if (reachable && thisblock->data.block.stack_level != 0)
......
gcc/tree-gimple.c
......@@ -495,7 +495,6 @@ recalculate_side_effects (tree t)
case INIT_EXPR:
case MODIFY_EXPR:
case VA_ARG_EXPR:
case RTL_EXPR:
case PREDECREMENT_EXPR:
case PREINCREMENT_EXPR:
case POSTDECREMENT_EXPR:
......
gcc/tree-pretty-print.c
......@@ -1109,10 +1109,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
pp_character (buffer, '>');
break;
case RTL_EXPR:
NIY;
break;
case ENTRY_VALUE_EXPR:
NIY;
break;
......
gcc/tree.c
......@@ -334,7 +334,6 @@ make_node_stat (enum tree_code code MEM_STAT_DECL)
case INIT_EXPR:
case MODIFY_EXPR:
case VA_ARG_EXPR:
case RTL_EXPR:
case PREDECREMENT_EXPR:
case PREINCREMENT_EXPR:
case POSTDECREMENT_EXPR:
......@@ -1455,7 +1454,6 @@ first_rtl_op (enum tree_code code)
case SAVE_EXPR:
return 2;
case GOTO_SUBROUTINE_EXPR:
case RTL_EXPR:
return 0;
case WITH_CLEANUP_EXPR:
return 2;
......@@ -1530,12 +1528,6 @@ unsave_expr_1 (tree expr)
TREE_OPERAND (expr, 3) = NULL_TREE;
break;
case RTL_EXPR:
/* I don't yet know how to emit a sequence multiple times. */
if (RTL_EXPR_SEQUENCE (expr) != 0)
abort ();
break;
default:
break;
}
......@@ -1552,10 +1544,7 @@ unsave_expr_1 (tree expr)
SAVE_EXPRs basically *only* appear replicated in an expression tree,
occasionally across the whole of a function. It is therefore only
safe to unsave a SAVE_EXPR if you know that all occurrences appear
below the UNSAVE_EXPR.
RTL_EXPRs consume their rtl during evaluation. It is therefore
never possible to unsave them. */
below the UNSAVE_EXPR. */
int
unsafe_for_reeval (tree expr)
......@@ -1575,7 +1564,6 @@ unsafe_for_reeval (tree expr)
switch (code)
{
case SAVE_EXPR:
case RTL_EXPR:
return 2;
/* A label can only be emitted once. */
......@@ -2194,13 +2182,6 @@ stabilize_reference (tree ref)
volatiles. */
return stabilize_reference_1 (ref);
case RTL_EXPR:
result = build1 (INDIRECT_REF, TREE_TYPE (ref),
save_expr (build1 (ADDR_EXPR,
build_pointer_type (TREE_TYPE (ref)),
ref)));
break;
/* If arg isn't a kind of lvalue we recognize, make no change.
Caller should recognize the error for an invalid lvalue. */
default:
......@@ -2459,7 +2440,6 @@ build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
case INIT_EXPR:
case MODIFY_EXPR:
case VA_ARG_EXPR:
case RTL_EXPR:
case PREDECREMENT_EXPR:
case PREINCREMENT_EXPR:
case POSTDECREMENT_EXPR:
......
gcc/tree.def
......@@ -499,9 +499,7 @@ DEFTREECODE (CALL_EXPR, "call_expr", 'e', 3)
/* Specify a value to compute along with its corresponding cleanup.
Operand 0 argument is an expression whose value needs a cleanup.
Operand 1 is the cleanup expression for the object.
Operand 2 is an RTL_EXPR which will eventually represent that value.
The RTL_EXPR is used in this expression, which is how the expression
manages to act on the proper value.
Operand 2 is unused.
The cleanup is executed by the first enclosing CLEANUP_POINT_EXPR, if
it exists, otherwise it is the responsibility of the caller to manually
call expand_start_target_temps/expand_end_target_temps, as needed.
......@@ -731,27 +729,13 @@ DEFTREECODE (VIEW_CONVERT_EXPR, "view_convert_expr", '1', 1)
DEFTREECODE (SAVE_EXPR, "save_expr", 'e', 3)
/* For a UNSAVE_EXPR, operand 0 is the value to unsave. By unsave, we
mean that all _EXPRs such as TARGET_EXPRs, SAVE_EXPRs,
CALL_EXPRs and RTL_EXPRs, that are protected
from being evaluated more than once should be reset so that a new
expand_expr call of this expr will cause those to be re-evaluated.
This is useful when we want to reuse a tree in different places,
but where we must re-expand. */
mean that all _EXPRs such as TARGET_EXPRs, SAVE_EXPRs, CALL_EXPRs,
that are protected from being evaluated more than once should be
reset so that a new expand_expr call of this expr will cause those
to be re-evaluated. This is useful when we want to reuse a tree in
different places, but where we must re-expand. */
DEFTREECODE (UNSAVE_EXPR, "unsave_expr", 'e', 1)
/* Represents something whose RTL has already been expanded as a
sequence which should be emitted when this expression is expanded.
The first operand is the RTL to emit. It is the first of a chain
of insns. The second is the RTL expression for the result. The
third operand is the "alternate RTL expression" for the result, if
any; if the second argument is the DECL_RTL for a VAR_DECL, but
with an invalid memory address replaced by a valid one, then the
third operand will be the original DECL_RTL. Any temporaries
created during the building of the RTL_EXPR can be reused once the
RTL_EXPR has been expanded, with the exception of the
RTL_EXPR_RTL. */
DEFTREECODE (RTL_EXPR, "rtl_expr", 'e', 3)
/* & in C. Value is the address at which the operand's value resides.
Operand may have any mode. Result mode is Pmode. */
DEFTREECODE (ADDR_EXPR, "addr_expr", 'e', 1)
......
gcc/tree.h
......@@ -1043,11 +1043,6 @@ struct tree_vec GTY(())
recalculated.) */
#define SAVE_EXPR_PERSISTENT_P(NODE) TREE_ASM_WRITTEN (SAVE_EXPR_CHECK (NODE))
/* In a RTL_EXPR node. */
#define RTL_EXPR_SEQUENCE(NODE) TREE_RTL_OPERAND_CHECK (NODE, RTL_EXPR, 0)
#define RTL_EXPR_RTL(NODE) TREE_RTL_OPERAND_CHECK (NODE, RTL_EXPR, 1)
#define RTL_EXPR_ALT_RTL(NODE) TREE_RTL_OPERAND_CHECK (NODE, RTL_EXPR, 2)
/* In a WITH_CLEANUP_EXPR node. */
#define WITH_CLEANUP_EXPR_RTL(NODE) \
TREE_RTL_OPERAND_CHECK (NODE, WITH_CLEANUP_EXPR, 2)
......@@ -3337,13 +3332,10 @@ extern bool commutative_tree_code (enum tree_code);
/* In stmt.c */
extern void expand_fixups (rtx);
extern tree expand_start_stmt_expr (int);
extern tree expand_end_stmt_expr (tree);
extern void expand_expr_stmt (tree);
extern void expand_expr_stmt_value (tree, int, int);
extern int warn_if_unused_value (tree, location_t);
extern void expand_decl_init (tree);
extern void clear_last_expr (void);
extern void expand_label (tree);
extern void expand_goto (tree);
extern void expand_asm (tree, int);
......@@ -3514,7 +3506,6 @@ extern void push_temp_slots (void);
extern void preserve_temp_slots (rtx);
extern void preserve_rtl_expr_temps (tree);
extern int aggregate_value_p (tree, tree);
extern void free_temps_for_rtl_expr (tree);
extern void push_function_context (void);
extern void pop_function_context (void);
extern void push_function_context_to (tree);
......@@ -3541,7 +3532,6 @@ extern rtx expand_builtin_return_addr (enum built_in_function, int, rtx);
extern void check_max_integer_computation_mode (tree);
/* In emit-rtl.c */
extern void start_sequence_for_rtl_expr (tree);
extern rtx emit_line_note (location_t);
/* In calls.c */
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment