/* Implements exception handling.
- Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
+ Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
1999, 2000, 2001 Free Software Foundation, Inc.
Contributed by Mike Stump <mrs@cygnus.com>.
int filter;
} allowed;
- /* The type given by a call to "throw foo();", or discovered
+ /* The type given by a call to "throw foo();", or discovered
for a throw. */
struct {
tree type;
\f
/* Routine to see if exception handling is turned on.
DO_WARN is non-zero if we want to inform the user that exception
- handling is turned off.
+ handling is turned off.
This is used to ensure that -fexceptions has been specified if the
compiler tries to use any exception-specific functions. */
/* Give the language a chance to specify an action to be taken if an
exception is thrown that would propagate out of the HANDLER. */
- protect_cleanup_actions
- = (lang_protect_cleanup_actions
- ? (*lang_protect_cleanup_actions) ()
+ protect_cleanup_actions
+ = (lang_protect_cleanup_actions
+ ? (*lang_protect_cleanup_actions) ()
: NULL_TREE);
if (protect_cleanup_actions)
begin_protect_partials ();
/* Add this entry to the front of the list. */
- TREE_VALUE (cfun->eh->protect_list)
+ TREE_VALUE (cfun->eh->protect_list)
= tree_cons (NULL_TREE, handler, TREE_VALUE (cfun->eh->protect_list));
}
case ERT_THROW:
n->u.throw.type = o->u.throw.type;
-
+
default:
abort ();
}
n->inner = n_array[o->inner->region_number];
if (o->next_peer)
n->next_peer = n_array[o->next_peer->region_number];
-}
+}
int
duplicate_eh_regions (ifun, map)
*slot = tree_cons (type, runtime, NULL_TREE);
}
}
-
+
static tree
lookup_type_for_runtime (type)
tree type;
/* Look up each type in the list and encode its filter
value as a uleb128. Terminate the list with 0. */
for (; list ; list = TREE_CHAIN (list))
- push_uleb128 (&cfun->eh->ehspec_data,
+ push_uleb128 (&cfun->eh->ehspec_data,
add_ttypes_entry (ttypes_hash, TREE_VALUE (list)));
VARRAY_PUSH_UCHAR (cfun->eh->ehspec_data, 0);
}
{
int flt = add_ttypes_entry (ttypes, TREE_VALUE (tp_node));
tree flt_node = build_int_2 (flt, 0);
-
- r->u.catch.filter_list
+
+ r->u.catch.filter_list
= tree_cons (NULL_TREE, flt_node, r->u.catch.filter_list);
}
}
an action record anyway. */
int flt = add_ttypes_entry (ttypes, NULL);
tree flt_node = build_int_2 (flt, 0);
-
- r->u.catch.filter_list
+
+ r->u.catch.filter_list
= tree_cons (NULL_TREE, flt_node, r->u.catch.filter_list);
}
-
+
break;
case ERT_ALLOWED_EXCEPTIONS:
}
else
emit_move_insn (mem, const0_rtx);
-
+
#ifdef DONT_USE_BUILTIN_SETJMP
{
rtx x, note;
start_sequence ();
emit_label (dispatch_label);
-
+
#ifndef DONT_USE_BUILTIN_SETJMP
expand_builtin_setjmp_receiver (dispatch_label);
#endif
/* A subroutine of reachable_next_level. If we are collecting a list
of handlers, add one. After landing pad generation, reference
it instead of the handlers themselves. Further, the handlers are
- all wired together, so by referencing one, we've got them all.
+ all wired together, so by referencing one, we've got them all.
Before landing pad generation we reference each handler individually.
LP_REGION contains the landing pad; REGION is the handler. */
info->handlers = alloc_INSN_LIST (region->label, info->handlers);
}
-/* Process one level of exception regions for reachability.
+/* Process one level of exception regions for reachability.
If TYPE_THROWN is non-null, then it is the *exact* type being
propagated. If INFO is non-null, then collect handler labels
and caught/allowed type information between invocations. */
{
/* If we have a at least one type match, end the search. */
tree tp_node = c->u.catch.type_list;
-
+
for (; tp_node; tp_node = TREE_CHAIN (tp_node))
{
tree type = TREE_VALUE (tp_node);
/* At this point, we either don't know what type is thrown or
don't have front-end assistance to help deciding if it is
covered by one of the types in the list for this region.
-
+
We'd then like to add this region to the list of reachable
handlers since it is indeed potentially reachable based on the
- information we have.
-
+ information we have.
+
Actually, this handler is for sure not reachable if all the
types it matches have already been caught. That is, it is only
potentially reachable if at least one of the types it catches
{
info->types_caught
= tree_cons (NULL, type, info->types_caught);
-
+
maybe_reachable = true;
}
}
-
+
if (maybe_reachable)
{
add_reachable_handler (info, region, c);
-
+
/* ??? If the catch type is a base class of every allowed
type, then we know we can stop the search. */
ret = RNL_MAYBE_CAUGHT;
info->types_allowed = tree_cons (NULL_TREE,
region->u.allowed.type_list,
info->types_allowed);
-
+
/* If we have definitive information about the type hierarchy,
then we can tell if the thrown type will pass through the
filter. */
case ERT_THROW:
case ERT_FIXUP:
+ case ERT_UNKNOWN:
/* Shouldn't see these here. */
break;
}
iwhich = DBX_REGISTER_NUMBER (iwhich);
#endif
- return GEN_INT (iwhich);
+ return GEN_INT (iwhich);
}
/* Given a value extracted from the return address register or stack slot,
{
/* Retrieve the filter from the head of the filter list
where we have stored it (see assign_filter_values). */
- int filter
+ int filter
= TREE_INT_CST_LOW (TREE_VALUE (c->u.catch.filter_list));
next = add_action_record (ar_hash, filter, 0);
else if (next <= 0)
next = add_action_record (ar_hash, 0, 0);
}
-
+
flt_node = c->u.catch.filter_list;
for (; flt_node; flt_node = TREE_CHAIN (flt_node))
{
are created. */
if (this_action >= -1)
{
- call_site = add_call_site (this_landing_pad,
+ call_site = add_call_site (this_landing_pad,
this_action < 0 ? 0 : this_action);
note = emit_note_before (NOTE_INSN_EH_REGION_BEG, iter);
NOTE_EH_HANDLER (note) = call_site;
{
#ifdef HAVE_AS_LEB128
char ttype_after_disp_label[32];
- ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label, "LLSDATTD",
+ ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label, "LLSDATTD",
funcdef_number);
dw2_asm_output_delta_uleb128 (ttype_label, ttype_after_disp_label,
"@TType base offset");
projects / gcc.git / commitdiff