+1999-12-12 Mark Mitchell <mark@codesourcery.com>
+
+ * except.h (struct eh_queue): Add `next' pointer.
+ (struct eh_status): Make x_ehqueue a pointer.
+ (push_ehqueue): Declare.
+ (pop_ehqueue): Likewise.
+ * except.c (expand_eh_region_end): Adjust now that ehqueue is a
+ pointer.
+ (expand_fixup_region_end): Likewise.
+ (expand_leftover_cleanups): Likewise.
+ (push_ehqueue): Define.
+ (pop_ehqueue): Likewise.
+ (emit_cleanup_handler): Use push_ehqueue and pop_ehqueue rather
+ than doing it inline.
+ (expand_start_all_catch): Adjust now that ehqueue is a
+ pointer.
+ (mark_eh_queue): Mark all level of the queue.
+ (mark_eh_status): Adjust now that ehqueue is a
+ pointer.
+ (init_eh_for_function): Allocate ehqueue.
+ (free_eh_status): Free it.
+ * stmt.c (expand_cleanups): Save the ehqueue around the cleanup
+ expansion for a fixup.
+
1999-12-12 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
* gthr-single.h (__gthread_active_p): Add prototype arguments.
/* create region entry in final exception table */
r = new_eh_region_entry (NOTE_EH_HANDLER (note), entry->rethrow_label);
- enqueue_eh_entry (&ehqueue, entry);
+ enqueue_eh_entry (ehqueue, entry);
/* If we have already started ending the bindings, don't recurse. */
if (is_eh_region ())
/* Go through the goto handlers in the queue, emitting their
handlers if we now have enough information to do so. */
- for (node = ehqueue.head; node; node = node->chain)
+ for (node = ehqueue->head; node; node = node->chain)
if (node->entry->goto_entry_p
&& node->entry->outer_context == entry->rethrow_label)
emit_cleanup_handler (node->entry);
for (node = ehstack.top; node && node->entry->finalization != cleanup; )
node = node->chain;
if (node == 0)
- for (node = ehqueue.head; node && node->entry->finalization != cleanup; )
+ for (node = ehqueue->head; node && node->entry->finalization != cleanup; )
node = node->chain;
if (node == 0)
abort ();
{
struct eh_entry *entry;
- for (entry = dequeue_eh_entry (&ehqueue);
+ for (entry = dequeue_eh_entry (ehqueue);
entry;
- entry = dequeue_eh_entry (&ehqueue))
+ entry = dequeue_eh_entry (ehqueue))
{
/* A leftover try block. Shouldn't be one here. */
if (entry->finalization == integer_zero_node)
catchstack.top->entry->false_label = NULL_RTX;
}
+/* Save away the current ehqueue. */
+
+void
+push_ehqueue ()
+{
+ struct eh_queue *q;
+ q = xcalloc (1, sizeof (struct eh_queue));
+ q->next = ehqueue;
+ ehqueue = q;
+}
+
+/* Restore a previously pushed ehqueue. */
+
+void
+pop_ehqueue ()
+{
+ struct eh_queue *q;
+ expand_leftover_cleanups ();
+ q = ehqueue->next;
+ free (ehqueue);
+ ehqueue = q;
+}
+
/* Emit the handler specified by ENTRY. */
static void
{
rtx prev;
rtx handler_insns;
- struct eh_queue q;
/* Since the cleanup could itself contain try-catch blocks, we
squirrel away the current queue and replace it when we are done
with this function. */
- q = ehqueue;
- ehqueue.head = ehqueue.tail = NULL;
+ push_ehqueue ();
/* Put these handler instructions in a sequence. */
do_pending_stack_adjust ();
end_sequence ();
/* Now we've left the handler. */
- expand_leftover_cleanups ();
- ehqueue = q;
+ pop_ehqueue ();
}
/* Generate RTL for the start of a group of catch clauses.
/* Throw away entries in the queue that we won't need anymore. We
need entries for regions that have ended but to which there might
still be gotos pending. */
- for (entry = dequeue_eh_entry (&ehqueue);
+ for (entry = dequeue_eh_entry (ehqueue);
entry->finalization != integer_zero_node;
- entry = dequeue_eh_entry (&ehqueue))
+ entry = dequeue_eh_entry (ehqueue))
free (entry);
/* At this point, all the cleanups are done, and the ehqueue now has
mark_eh_queue (q)
struct eh_queue *q;
{
- if (q)
- mark_eh_node (q->head);
+ while (q)
+ {
+ mark_eh_node (q->head);
+ q = q->next;
+ }
}
/* Mark NODE for GC. A label_node contains a union containing either
mark_eh_stack (&eh->x_ehstack);
mark_eh_stack (&eh->x_catchstack);
- mark_eh_queue (&eh->x_ehqueue);
+ mark_eh_queue (eh->x_ehqueue);
ggc_mark_rtx (eh->x_catch_clauses);
lang_mark_false_label_stack (eh->x_false_label_stack);
{
current_function->eh
= (struct eh_status *) xcalloc (1, sizeof (struct eh_status));
+ ehqueue = (struct eh_queue *) xcalloc (1, sizeof (struct eh_queue));
eh_return_context = NULL_RTX;
eh_return_stack_adjust = NULL_RTX;
eh_return_handler = NULL_RTX;
free_eh_status (f)
struct function *f;
{
+ free (f->eh->x_ehqueue);
free (f->eh);
f->eh = NULL;
}
struct eh_queue {
struct eh_node *head;
struct eh_node *tail;
+ struct eh_queue *next;
};
/* Used to save exception handling status for each function. */
As we exit a region, we enqueue a new entry. The entries are then
dequeued during expand_leftover_cleanups and
expand_start_all_catch. */
- struct eh_queue x_ehqueue;
+ struct eh_queue *x_ehqueue;
/* Insns for all of the exception handlers for the current function.
They are currently emitted by the frontend code. */
rtx x_catch_clauses;
extern void emit_throw PROTO((void));
+/* Save away the current ehqueue. */
+extern void push_ehqueue PROTO((void));
+
+/* Restore a previously pushed ehqueue. */
+extern void pop_ehqueue PROTO((void));
+
/* One to use setjmp/longjmp method of generating code. */
extern int exceptions_via_longjmp;
OSDN Git Service
