struct func_eh_entry
{
- int range_number; /* EH region number from EH NOTE insn's */
- rtx rethrow_label; /* Label for rethrow */
+ int range_number; /* EH region number from EH NOTE insn's. */
+ rtx rethrow_label; /* Label for rethrow. */
+ int rethrow_ref; /* Is rethrow referenced? */
struct handler_info *handlers;
};
{
x = duplicate_eh_handlers (CODE_LABEL_NUMBER (l1), y, map);
/* Since we're mapping it, it must be used. */
- SYMBOL_REF_USED (function_eh_regions[x].rethrow_label) = 1;
+ function_eh_regions[x].rethrow_ref = 1;
}
return function_eh_regions[x].rethrow_label;
}
{
if (flag_new_exceptions)
{
- rtx lab = function_eh_regions[find_func_region (region)].rethrow_label;
- return (SYMBOL_REF_USED (lab));
+ int ret = function_eh_regions[find_func_region (region)].rethrow_ref;
+ return ret;
}
return 0;
}
else
if (flag_new_exceptions)
{
- rtx insn, val;
- if (label == NULL_RTX)
- label = last_rethrow_symbol;
- emit_library_call (rethrow_libfunc, 0, VOIDmode, 1, label, Pmode);
- SYMBOL_REF_USED (label) = 1;
+ rtx insn, val;
+ int region;
+ if (label == NULL_RTX)
+ label = last_rethrow_symbol;
+ emit_library_call (rethrow_libfunc, 0, VOIDmode, 1, label, Pmode);
+ region = find_func_region (eh_region_from_symbol (label));
+ function_eh_regions[region].rethrow_ref = 1;
/* Search backwards for the actual call insn. */
- insn = get_last_insn ();
+ insn = get_last_insn ();
while (GET_CODE (insn) != CALL_INSN)
insn = PREV_INSN (insn);
delete_insns_since (insn);
-
- /* Mark the label/symbol on the call. */
- val = GEN_INT (eh_region_from_symbol (label));
- REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EH_RETHROW, val,
+
+ /* Mark the label/symbol on the call. */
+ REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EH_RETHROW, label,
REG_NOTES (insn));
- emit_barrier ();
+ emit_barrier ();
}
else
emit_jump (label);
if (rethrow != NULL_RTX && !flag_new_exceptions)
rethrow = NULL_RTX;
if (rethrow != NULL_RTX && handler == NULL)
- if (! SYMBOL_REF_USED (rethrow))
+ if (! function_eh_regions[index].rethrow_ref)
rethrow = NULL_RTX;
can_throw (insn)
rtx insn;
{
- /* Calls can always potentially throw exceptions. */
+ /* Calls can always potentially throw exceptions, unless they have
+ a REG_EH_REGION note with a value of 0 or less. */
if (GET_CODE (insn) == CALL_INSN)
- return 1;
+ {
+ rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
+ if (!note || XINT (XEXP (note, 0), 0) > 0)
+ return 1;
+ }
if (asynchronous_exceptions)
{
/* Assume we can delete the region. */
int delete = 1;
- int r = find_func_region (n);
/* Can't delete something which is rethrown to. */
- if (SYMBOL_REF_USED((function_eh_regions[r].rethrow_label)))
+ if (rethrow_used (n))
delete = 0;
if (insn == NULL_RTX
}
}
}
+
+/* This function determines whether any of the exception regions in the
+ current function are targets of a rethrow or not, and set the
+ reference flag according. */
+void
+update_rethrow_references ()
+{
+ rtx insn;
+ int x, region;
+ int *saw_region, *saw_rethrow;
+
+ if (!flag_new_exceptions)
+ return;
+
+ saw_region = (int *) alloca (current_func_eh_entry * sizeof (int));
+ saw_rethrow = (int *) alloca (current_func_eh_entry * sizeof (int));
+ bzero ((char *) saw_region, (current_func_eh_entry * sizeof (int)));
+ bzero ((char *) saw_rethrow, (current_func_eh_entry * sizeof (int)));
+
+ /* Determine what regions exist, and whether there are any rethrows
+ to those regions or not. */
+ for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
+ if (GET_CODE (insn) == CALL_INSN)
+ {
+ rtx note = find_reg_note (insn, REG_EH_RETHROW, NULL_RTX);
+ if (note)
+ {
+ region = eh_region_from_symbol (XEXP (note, 0));
+ region = find_func_region (region);
+ saw_rethrow[region] = 1;
+ }
+ }
+ else
+ if (GET_CODE (insn) == NOTE)
+ {
+ if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
+ {
+ region = find_func_region (NOTE_BLOCK_NUMBER (insn));
+ saw_region[region] = 1;
+ }
+ }
+
+ /* For any regions we did see, set the referenced flag. */
+ for (x = 0; x < current_func_eh_entry; x++)
+ if (saw_region[x])
+ function_eh_regions[x].rethrow_ref = saw_rethrow[x];
+}
\f
/* Various hooks for the DWARF 2 __throw routine. */
ret = (insn_eh_region[uid1] == insn_eh_region[uid2]);
return ret;
}
+\f
+
+/* This function will initialize the handler list for a specified block.
+ It may recursively call itself if the outer block hasn't been processed
+ yet. At some point in the future we can trim out handlers which we
+ know cannot be called. (ie, if a block has an INT type handler,
+ control will never be passed to an outer INT type handler). */
+static void
+process_nestinfo (block, info, nested_eh_region)
+ int block;
+ eh_nesting_info *info;
+ int *nested_eh_region;
+{
+ handler_info *ptr, *last_ptr = NULL;
+ int x, y, count = 0;
+ int extra = 0;
+ handler_info **extra_handlers;
+ int index = info->region_index[block];
+
+ /* If we've already processed this block, simply return. */
+ if (info->num_handlers[index] > 0)
+ return;
+
+ for (ptr = get_first_handler (block); ptr; last_ptr = ptr, ptr = ptr->next)
+ count++;
+
+ /* pick up any information from the next outer region. It will already
+ contain a summary of itself and all outer regions to it. */
+
+ if (nested_eh_region [block] != 0)
+ {
+ int nested_index = info->region_index[nested_eh_region[block]];
+ process_nestinfo (nested_eh_region[block], info, nested_eh_region);
+ extra = info->num_handlers[nested_index];
+ extra_handlers = info->handlers[nested_index];
+ info->outer_index[index] = nested_index;
+ }
+
+ /* If the last handler is either a CATCH_ALL or a cleanup, then we
+ won't use the outer ones since we know control will not go past the
+ catch-all or cleanup. */
+
+ if (last_ptr != NULL && (last_ptr->type_info == NULL
+ || last_ptr->type_info == CATCH_ALL_TYPE))
+ extra = 0;
+
+ info->num_handlers[index] = count + extra;
+ info->handlers[index] = (handler_info **) malloc ((count + extra)
+ * sizeof (handler_info **));
+
+ /* First put all our handlers into the list. */
+ ptr = get_first_handler (block);
+ for (x = 0; x < count; x++)
+ {
+ info->handlers[index][x] = ptr;
+ ptr = ptr->next;
+ }
+
+ /* Now add all the outer region handlers, if they aren't they same as
+ one of the types in the current block. We won't worry about
+ derived types yet, we'll just look for the exact type. */
+ for (y =0, x = 0; x < extra ; x++)
+ {
+ int i, ok;
+ ok = 1;
+ /* Check to see if we have a type duplication. */
+ for (i = 0; i < count; i++)
+ if (info->handlers[index][i]->type_info == extra_handlers[x]->type_info)
+ {
+ ok = 0;
+ /* Record one less handler. */
+ (info->num_handlers[index])--;
+ break;
+ }
+ if (ok)
+ {
+ info->handlers[index][y + count] = extra_handlers[x];
+ y++;
+ }
+ }
+}
+
+/* This function will allocate and initialize an eh_nesting_info structure.
+ It returns a pointer to the completed data structure. If there are
+ no exception regions, a NULL value is returned. */
+eh_nesting_info *
+init_eh_nesting_info ()
+{
+ int *nested_eh_region;
+ int region_count = 0;
+ rtx eh_note = NULL_RTX;
+ eh_nesting_info *info;
+ rtx insn;
+ int x;
+
+ info = (eh_nesting_info *) malloc (sizeof (eh_nesting_info));
+ info->region_index = (int *) malloc ((max_label_num () + 1) * sizeof (int));
+ bzero ((char *) info->region_index, (max_label_num () + 1) * sizeof (int));
+
+ nested_eh_region = (int *) alloca ((max_label_num () + 1) * sizeof (int));
+ bzero ((char *) nested_eh_region, (max_label_num () + 1) * sizeof (int));
+ /* Create the nested_eh_region list. If indexed with a block number, it
+ returns the block number of the next outermost region, if any.
+ We can count the number of regions and initialize the region_index
+ vector at the same time. */
+ for (insn = get_insns(); insn; insn = NEXT_INSN (insn))
+ {
+ if (GET_CODE (insn) == NOTE)
+ {
+ if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
+ {
+ int block = NOTE_BLOCK_NUMBER (insn);
+ region_count++;
+ info->region_index[block] = region_count;
+ if (eh_note)
+ nested_eh_region [block] =
+ NOTE_BLOCK_NUMBER (XEXP (eh_note, 0));
+ else
+ nested_eh_region [block] = 0;
+ eh_note = gen_rtx_EXPR_LIST (VOIDmode, insn, eh_note);
+ }
+ else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END)
+ eh_note = XEXP (eh_note, 1);
+ }
+ }
+
+ /* If there are no regions, wrap it up now. */
+ if (region_count == 0)
+ {
+ free (info->region_index);
+ free (info);
+ return NULL;
+ }
+
+ region_count++;
+ info->handlers = (handler_info ***) malloc (region_count
+ * sizeof (handler_info ***));
+ info->num_handlers = (int *) malloc (region_count * sizeof (int));
+ info->outer_index = (int *) malloc (region_count * sizeof (int));
+
+ bzero ((char *) info->handlers, region_count * sizeof (rtx *));
+ bzero ((char *) info->num_handlers, region_count * sizeof (int));
+ bzero ((char *) info->outer_index, region_count * sizeof (int));
+
+ /* Now initialize the handler lists for all exception blocks. */
+ for (x = 0; x <= max_label_num (); x++)
+ {
+ if (info->region_index[x] != 0)
+ process_nestinfo (x, info, nested_eh_region);
+ }
+ info->region_count = region_count;
+ return info;
+}
+
+
+/* This function is used to retreive the vector of handlers which
+ can be reached by a given insn in a given exception region.
+ BLOCK is the exception block the insn is in.
+ INFO is the eh_nesting_info structure.
+ INSN is the (optional) insn within the block. If insn is not NULL_RTX,
+ it may contain reg notes which modify its throwing behavior, and
+ these will be obeyed. If NULL_RTX is passed, then we simply return the
+ handlers for block.
+ HANDLERS is the address of a pointer to a vector of handler_info pointers.
+ Upon return, this will have the handlers which can be reached by block.
+ This function returns the number of elements in the handlers vector. */
+int
+reachable_handlers (block, info, insn, handlers)
+ int block;
+ eh_nesting_info *info;
+ rtx insn ;
+ handler_info ***handlers;
+{
+ int index = 0;
+ *handlers = NULL;
+
+ if (info == NULL)
+ return 0;
+ if (block > 0)
+ index = info->region_index[block];
+
+ if (insn && GET_CODE (insn) == CALL_INSN)
+ {
+ /* RETHROWs specify a region number from which we are going to rethrow.
+ This means we wont pass control to handlers in the specified
+ region, but rather any region OUTSIDE the specified region.
+ We accomplish this by setting block to the outer_index of the
+ specified region. */
+ rtx note = find_reg_note (insn, REG_EH_RETHROW, NULL_RTX);
+ if (note)
+ {
+ index = eh_region_from_symbol (XEXP (note, 0));
+ index = info->region_index[index];
+ if (index)
+ index = info->outer_index[index];
+ }
+ else
+ {
+ /* If there is no rethrow, we look for a REG_EH_REGION, and
+ we'll throw from that block. A value of 0 or less
+ indicates that this insn cannot throw. */
+ note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
+ if (note)
+ {
+ int b = XINT (XEXP (note, 0), 0);
+ if (b <= 0)
+ index = 0;
+ else
+ index = info->region_index[b];
+ }
+ }
+ }
+ /* If we reach this point, and index is 0, there is no throw. */
+ if (index == 0)
+ return 0;
+
+ *handlers = info->handlers[index];
+ return info->num_handlers[index];
+}
+
+
+/* This function will free all memory associated with the eh_nesting info. */
+
+void
+free_eh_nesting_info (info)
+ eh_nesting_info *info;
+{
+ int x;
+ if (info != NULL)
+ {
+ if (info->region_index)
+ free (info->region_index);
+ if (info->num_handlers)
+ free (info->num_handlers);
+ if (info->outer_index)
+ free (info->outer_index);
+ if (info->handlers)
+ {
+ for (x = 0; x < info->region_count; x++)
+ if (info->handlers[x])
+ free (info->handlers[x]);
+ free (info->handlers);
+ }
+ }
+}
rtx *bb_eh_end;
{
int i;
+ eh_nesting_info *eh_nest_info = init_eh_nesting_info ();
/* Assume no computed jump; revise as we create edges. */
current_function_has_computed_jump = 0;
if (code == CALL_INSN || asynchronous_exceptions)
{
int is_call = (code == CALL_INSN ? EDGE_ABNORMAL_CALL : 0);
- handler_info *ptr;
+ handler_info **handler_list;
+ int eh_region = -1;
+ int num;
- /* Use REG_EH_RETHROW and REG_EH_REGION if available. */
- /* ??? REG_EH_REGION is not generated presently. Is it
- inteded that there be multiple notes for the regions?
- or is my eh_list collection redundant with handler linking? */
+ if (eh_list)
+ eh_region = NOTE_BLOCK_NUMBER (XEXP (eh_list, 0));
- x = find_reg_note (insn, REG_EH_RETHROW, 0);
- if (!x)
- x = find_reg_note (insn, REG_EH_REGION, 0);
- if (x)
+ num = reachable_handlers (eh_region, eh_nest_info,
+ insn, &handler_list);
+ for ( ; num > 0; num--)
{
- if (XINT (XEXP (x, 0), 0) > 0)
- {
- ptr = get_first_handler (XINT (XEXP (x, 0), 0));
- while (ptr)
- {
- make_label_edge (bb, ptr->handler_label,
- EDGE_ABNORMAL | EDGE_EH | is_call);
- ptr = ptr->next;
- }
- }
- }
- else
- {
- for (x = eh_list; x; x = XEXP (x, 1))
- {
- ptr = get_first_handler (NOTE_BLOCK_NUMBER (XEXP (x, 0)));
- while (ptr)
- {
- make_label_edge (bb, ptr->handler_label,
- EDGE_ABNORMAL | EDGE_EH | is_call);
- ptr = ptr->next;
- }
- }
+ make_label_edge (bb, handler_list[num - 1]->handler_label,
+ EDGE_ABNORMAL | EDGE_EH | is_call);
}
if (code == CALL_INSN && nonlocal_goto_handler_labels)
gotos do not have their addresses taken, then only calls to
those functions or to other nested functions that use them
could possibly do nonlocal gotos. */
-
- for (x = nonlocal_goto_handler_labels; x ; x = XEXP (x, 1))
- make_label_edge (bb, XEXP (x, 0),
- EDGE_ABNORMAL | EDGE_ABNORMAL_CALL);
+ /* We do know that a REG_EH_REGION note with a value less
+ than 0 is guaranteed not to perform a non-local goto. */
+ rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
+ if (!note || XINT (XEXP (note, 0), 0) >= 0)
+ for (x = nonlocal_goto_handler_labels; x ; x = XEXP (x, 1))
+ make_label_edge (bb, XEXP (x, 0),
+ EDGE_ABNORMAL | EDGE_ABNORMAL_CALL);
}
}
make_edge (bb, BASIC_BLOCK (i + 1), EDGE_FALLTHRU);
}
}
+ free_eh_nesting_info (eh_nest_info);
}
/* Create an edge between two basic blocks. FLAGS are auxiliary information
{
rtx insn;
+ update_rethrow_references ();
+
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
if (GET_CODE (insn) == NOTE)
{
(NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END))
{
int num = CODE_LABEL_NUMBER (insn);
- /* A NULL handler indicates a region is no longer needed */
- if (get_first_handler (num) == NULL)
+ /* A NULL handler indicates a region is no longer needed,
+ as long as it isn't the target of a rethrow. */
+ if (get_first_handler (num) == NULL && ! rethrow_used (num))
{
NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
NOTE_SOURCE_FILE (insn) = 0;
OSDN Git Service
