+2000-03-05 Mark Mitchell <mark@codesourcery.com>
+
+ Revert this patch:
+ 2000-03-04 Mark Mitchell <mark@codesourcery.com>
+
2000-03-04 Thomas Schuster <Thomas.Schuster@gmx.net>
* regmove.c (copy_src_to_dest) Do not create src->dest move
tem->next = seq_stack;
tem->first = first_insn;
tem->last = last_insn;
+ tem->sequence_rtl_expr = seq_rtl_expr;
seq_stack = tem;
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 (t)
+ 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. */
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
top->first = first_insn;
top->last = last_insn;
+ /* ??? Why don't we save seq_rtl_expr here? */
end_sequence ();
}
first_insn = tem->first;
last_insn = tem->last;
+ seq_rtl_expr = tem->sequence_rtl_expr;
seq_stack = tem->next;
free (tem);
f->emit = (struct emit_status *) xmalloc (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_linenum = 0;
while (ss)
{
ggc_mark_rtx (ss->first);
+ ggc_mark_tree (ss->sequence_rtl_expr);
ss = ss->next;
}
}
ggc_mark_rtx (*r);
mark_sequence_stack (es->sequence_stack);
+ ggc_mark_tree (es->sequence_rtl_expr);
ggc_mark_rtx (es->x_first_insn);
}
TREE_TYPE (handler) = void_type_node;
RTL_EXPR_RTL (handler) = const0_rtx;
TREE_SIDE_EFFECTS (handler) = 1;
- start_sequence ();
+ start_sequence_for_rtl_expr (handler);
emit_library_call (terminate_libfunc, 0, VOIDmode, 0);
emit_barrier ();
emit_insns (RTL_EXPR_SEQUENCE (exp));
RTL_EXPR_SEQUENCE (exp) = const0_rtx;
}
+ preserve_rtl_expr_result (RTL_EXPR_RTL (exp));
+ free_temps_for_rtl_expr (exp);
return RTL_EXPR_RTL (exp);
case CONSTRUCTOR:
rounded_size));
p->align = best_p->align;
p->address = 0;
+ p->rtl_expr = 0;
p->next = temp_slots;
temp_slots = p;
p->in_use = 1;
p->addr_taken = 0;
+ p->rtl_expr = seq_rtl_expr;
if (keep == 2)
{
p->level--;
}
+/* 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 (x)
+ 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 || GET_CODE (x) != MEM || 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)
+ {
+ p->level = 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.
struct temp_slot *p;
for (p = temp_slots; p; p = p->next)
- if (p->in_use && p->level == temp_slot_level && ! p->keep)
+ if (p->in_use && p->level == temp_slot_level && ! p->keep
+ && p->rtl_expr == 0)
+ p->in_use = 0;
+
+ combine_temp_slots ();
+}
+
+/* Free all temporary slots used in T, an RTL_EXPR node. */
+
+void
+free_temps_for_rtl_expr (t)
+ tree t;
+{
+ struct temp_slot *p;
+
+ for (p = temp_slots; p; p = p->next)
+ if (p->rtl_expr == t)
p->in_use = 0;
combine_temp_slots ();
struct temp_slot *p;
for (p = temp_slots; p; p = p->next)
- if (p->in_use && p->level == temp_slot_level)
+ if (p->in_use && p->level == temp_slot_level && p->rtl_expr == 0)
p->in_use = 0;
combine_temp_slots ();
{
ggc_mark_rtx (t->slot);
ggc_mark_rtx (t->address);
+ ggc_mark_tree (t->rtl_expr);
+
t = t->next;
}
}
{
/* First and last insns in the chain of the saved sequence. */
rtx first, last;
+ tree sequence_rtl_expr;
struct sequence_stack *next;
};
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,
/* 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)
extern void thread_prologue_and_epilogue_insns PARAMS ((rtx));
extern int prologue_epilogue_contains PARAMS ((rtx));
extern HOST_WIDE_INT get_frame_size PARAMS ((void));
+extern void preserve_rtl_expr_result PARAMS ((rtx));
extern void mark_temp_addr_taken PARAMS ((rtx));
extern void update_temp_slot_address PARAMS ((rtx, rtx));
extern void purge_addressof PARAMS ((rtx));
t = make_node (RTL_EXPR);
resume_momentary (momentary);
do_pending_stack_adjust ();
- start_sequence ();
+ start_sequence_for_rtl_expr (t);
NO_DEFER_POP;
expr_stmts_for_value++;
return t;
extern int aggregate_value_p PARAMS ((tree));
extern tree reorder_blocks PARAMS ((tree,
struct rtx_def *));
+extern void free_temps_for_rtl_expr PARAMS ((tree));
extern void instantiate_virtual_regs PARAMS ((tree, struct rtx_def *));
extern void unshare_all_rtl PARAMS ((tree, struct rtx_def *));
extern int max_parm_reg_num PARAMS ((void));
extern void check_max_integer_computation_mode PARAMS ((tree));
/* In emit-rtl.c */
+extern void start_sequence_for_rtl_expr PARAMS ((tree));
extern struct rtx_def *emit_line_note_after PARAMS ((char *, int,
struct rtx_def *));
extern struct rtx_def *emit_line_note PARAMS ((char *, int));