/* Implements exception handling.
|
/* 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, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
|
1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
Contributed by Mike Stump <mrs@cygnus.com>.
|
Contributed by Mike Stump <mrs@cygnus.com>.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
GCC is free software; you can redistribute it and/or modify it under
|
the terms of the GNU General Public License as published by the Free
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
|
/* An exception is an event that can be "thrown" from within a
|
/* An exception is an event that can be "thrown" from within a
|
function. This event can then be "caught" by the callers of
|
function. This event can then be "caught" by the callers of
|
the function.
|
the function.
|
|
|
The representation of exceptions changes several times during
|
The representation of exceptions changes several times during
|
the compilation process:
|
the compilation process:
|
|
|
In the beginning, in the front end, we have the GENERIC trees
|
In the beginning, in the front end, we have the GENERIC trees
|
TRY_CATCH_EXPR, TRY_FINALLY_EXPR, WITH_CLEANUP_EXPR,
|
TRY_CATCH_EXPR, TRY_FINALLY_EXPR, WITH_CLEANUP_EXPR,
|
CLEANUP_POINT_EXPR, CATCH_EXPR, and EH_FILTER_EXPR.
|
CLEANUP_POINT_EXPR, CATCH_EXPR, and EH_FILTER_EXPR.
|
|
|
During initial gimplification (gimplify.c) these are lowered
|
During initial gimplification (gimplify.c) these are lowered
|
to the GIMPLE_TRY, GIMPLE_CATCH, and GIMPLE_EH_FILTER nodes.
|
to the GIMPLE_TRY, GIMPLE_CATCH, and GIMPLE_EH_FILTER nodes.
|
The WITH_CLEANUP_EXPR and CLEANUP_POINT_EXPR nodes are converted
|
The WITH_CLEANUP_EXPR and CLEANUP_POINT_EXPR nodes are converted
|
into GIMPLE_TRY_FINALLY nodes; the others are a more direct 1-1
|
into GIMPLE_TRY_FINALLY nodes; the others are a more direct 1-1
|
conversion.
|
conversion.
|
|
|
During pass_lower_eh (tree-eh.c) we record the nested structure
|
During pass_lower_eh (tree-eh.c) we record the nested structure
|
of the TRY nodes in EH_REGION nodes in CFUN->EH->REGION_TREE.
|
of the TRY nodes in EH_REGION nodes in CFUN->EH->REGION_TREE.
|
We expand the lang_protect_cleanup_actions hook into MUST_NOT_THROW
|
We expand the lang_protect_cleanup_actions hook into MUST_NOT_THROW
|
regions at this time. We can then flatten the statements within
|
regions at this time. We can then flatten the statements within
|
the TRY nodes to straight-line code. Statements that had been within
|
the TRY nodes to straight-line code. Statements that had been within
|
TRY nodes that can throw are recorded within CFUN->EH->THROW_STMT_TABLE,
|
TRY nodes that can throw are recorded within CFUN->EH->THROW_STMT_TABLE,
|
so that we may remember what action is supposed to be taken if
|
so that we may remember what action is supposed to be taken if
|
a given statement does throw. During this lowering process,
|
a given statement does throw. During this lowering process,
|
we create an EH_LANDING_PAD node for each EH_REGION that has
|
we create an EH_LANDING_PAD node for each EH_REGION that has
|
some code within the function that needs to be executed if a
|
some code within the function that needs to be executed if a
|
throw does happen. We also create RESX statements that are
|
throw does happen. We also create RESX statements that are
|
used to transfer control from an inner EH_REGION to an outer
|
used to transfer control from an inner EH_REGION to an outer
|
EH_REGION. We also create EH_DISPATCH statements as placeholders
|
EH_REGION. We also create EH_DISPATCH statements as placeholders
|
for a runtime type comparison that should be made in order to
|
for a runtime type comparison that should be made in order to
|
select the action to perform among different CATCH and EH_FILTER
|
select the action to perform among different CATCH and EH_FILTER
|
regions.
|
regions.
|
|
|
During pass_lower_eh_dispatch (tree-eh.c), which is run after
|
During pass_lower_eh_dispatch (tree-eh.c), which is run after
|
all inlining is complete, we are able to run assign_filter_values,
|
all inlining is complete, we are able to run assign_filter_values,
|
which allows us to map the set of types manipulated by all of the
|
which allows us to map the set of types manipulated by all of the
|
CATCH and EH_FILTER regions to a set of integers. This set of integers
|
CATCH and EH_FILTER regions to a set of integers. This set of integers
|
will be how the exception runtime communicates with the code generated
|
will be how the exception runtime communicates with the code generated
|
within the function. We then expand the GIMPLE_EH_DISPATCH statements
|
within the function. We then expand the GIMPLE_EH_DISPATCH statements
|
to a switch or conditional branches that use the argument provided by
|
to a switch or conditional branches that use the argument provided by
|
the runtime (__builtin_eh_filter) and the set of integers we computed
|
the runtime (__builtin_eh_filter) and the set of integers we computed
|
in assign_filter_values.
|
in assign_filter_values.
|
|
|
During pass_lower_resx (tree-eh.c), which is run near the end
|
During pass_lower_resx (tree-eh.c), which is run near the end
|
of optimization, we expand RESX statements. If the eh region
|
of optimization, we expand RESX statements. If the eh region
|
that is outer to the RESX statement is a MUST_NOT_THROW, then
|
that is outer to the RESX statement is a MUST_NOT_THROW, then
|
the RESX expands to some form of abort statement. If the eh
|
the RESX expands to some form of abort statement. If the eh
|
region that is outer to the RESX statement is within the current
|
region that is outer to the RESX statement is within the current
|
function, then the RESX expands to a bookkeeping call
|
function, then the RESX expands to a bookkeeping call
|
(__builtin_eh_copy_values) and a goto. Otherwise, the next
|
(__builtin_eh_copy_values) and a goto. Otherwise, the next
|
handler for the exception must be within a function somewhere
|
handler for the exception must be within a function somewhere
|
up the call chain, so we call back into the exception runtime
|
up the call chain, so we call back into the exception runtime
|
(__builtin_unwind_resume).
|
(__builtin_unwind_resume).
|
|
|
During pass_expand (cfgexpand.c), we generate REG_EH_REGION notes
|
During pass_expand (cfgexpand.c), we generate REG_EH_REGION notes
|
that create an rtl to eh_region mapping that corresponds to the
|
that create an rtl to eh_region mapping that corresponds to the
|
gimple to eh_region mapping that had been recorded in the
|
gimple to eh_region mapping that had been recorded in the
|
THROW_STMT_TABLE.
|
THROW_STMT_TABLE.
|
|
|
During pass_rtl_eh (except.c), we generate the real landing pads
|
During pass_rtl_eh (except.c), we generate the real landing pads
|
to which the runtime will actually transfer control. These new
|
to which the runtime will actually transfer control. These new
|
landing pads perform whatever bookkeeping is needed by the target
|
landing pads perform whatever bookkeeping is needed by the target
|
backend in order to resume execution within the current function.
|
backend in order to resume execution within the current function.
|
Each of these new landing pads falls through into the post_landing_pad
|
Each of these new landing pads falls through into the post_landing_pad
|
label which had been used within the CFG up to this point. All
|
label which had been used within the CFG up to this point. All
|
exception edges within the CFG are redirected to the new landing pads.
|
exception edges within the CFG are redirected to the new landing pads.
|
If the target uses setjmp to implement exceptions, the various extra
|
If the target uses setjmp to implement exceptions, the various extra
|
calls into the runtime to register and unregister the current stack
|
calls into the runtime to register and unregister the current stack
|
frame are emitted at this time.
|
frame are emitted at this time.
|
|
|
During pass_convert_to_eh_region_ranges (except.c), we transform
|
During pass_convert_to_eh_region_ranges (except.c), we transform
|
the REG_EH_REGION notes attached to individual insns into
|
the REG_EH_REGION notes attached to individual insns into
|
non-overlapping ranges of insns bounded by NOTE_INSN_EH_REGION_BEG
|
non-overlapping ranges of insns bounded by NOTE_INSN_EH_REGION_BEG
|
and NOTE_INSN_EH_REGION_END. Each insn within such ranges has the
|
and NOTE_INSN_EH_REGION_END. Each insn within such ranges has the
|
same associated action within the exception region tree, meaning
|
same associated action within the exception region tree, meaning
|
that (1) the exception is caught by the same landing pad within the
|
that (1) the exception is caught by the same landing pad within the
|
current function, (2) the exception is blocked by the runtime with
|
current function, (2) the exception is blocked by the runtime with
|
a MUST_NOT_THROW region, or (3) the exception is not handled at all
|
a MUST_NOT_THROW region, or (3) the exception is not handled at all
|
within the current function.
|
within the current function.
|
|
|
Finally, during assembly generation, we call
|
Finally, during assembly generation, we call
|
output_function_exception_table (except.c) to emit the tables with
|
output_function_exception_table (except.c) to emit the tables with
|
which the exception runtime can determine if a given stack frame
|
which the exception runtime can determine if a given stack frame
|
handles a given exception, and if so what filter value to provide
|
handles a given exception, and if so what filter value to provide
|
to the function when the non-local control transfer is effected.
|
to the function when the non-local control transfer is effected.
|
If the target uses dwarf2 unwinding to implement exceptions, then
|
If the target uses dwarf2 unwinding to implement exceptions, then
|
output_call_frame_info (dwarf2out.c) emits the required unwind data. */
|
output_call_frame_info (dwarf2out.c) emits the required unwind data. */
|
|
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "function.h"
|
#include "function.h"
|
#include "expr.h"
|
#include "expr.h"
|
#include "libfuncs.h"
|
#include "libfuncs.h"
|
#include "insn-config.h"
|
#include "insn-config.h"
|
#include "except.h"
|
#include "except.h"
|
#include "integrate.h"
|
#include "integrate.h"
|
#include "hard-reg-set.h"
|
#include "hard-reg-set.h"
|
#include "basic-block.h"
|
#include "basic-block.h"
|
#include "output.h"
|
#include "output.h"
|
#include "dwarf2asm.h"
|
#include "dwarf2asm.h"
|
#include "dwarf2out.h"
|
#include "dwarf2out.h"
|
#include "dwarf2.h"
|
#include "dwarf2.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "hashtab.h"
|
#include "hashtab.h"
|
#include "intl.h"
|
#include "intl.h"
|
#include "ggc.h"
|
#include "ggc.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "target.h"
|
#include "target.h"
|
#include "langhooks.h"
|
#include "langhooks.h"
|
#include "cgraph.h"
|
#include "cgraph.h"
|
#include "diagnostic.h"
|
#include "diagnostic.h"
|
#include "tree-pass.h"
|
#include "tree-pass.h"
|
#include "timevar.h"
|
#include "timevar.h"
|
#include "tree-flow.h"
|
#include "tree-flow.h"
|
|
|
/* Provide defaults for stuff that may not be defined when using
|
/* Provide defaults for stuff that may not be defined when using
|
sjlj exceptions. */
|
sjlj exceptions. */
|
#ifndef EH_RETURN_DATA_REGNO
|
#ifndef EH_RETURN_DATA_REGNO
|
#define EH_RETURN_DATA_REGNO(N) INVALID_REGNUM
|
#define EH_RETURN_DATA_REGNO(N) INVALID_REGNUM
|
#endif
|
#endif
|
|
|
/* Protect cleanup actions with must-not-throw regions, with a call
|
/* Protect cleanup actions with must-not-throw regions, with a call
|
to the given failure handler. */
|
to the given failure handler. */
|
tree (*lang_protect_cleanup_actions) (void);
|
tree (*lang_protect_cleanup_actions) (void);
|
|
|
/* Return true if type A catches type B. */
|
/* Return true if type A catches type B. */
|
int (*lang_eh_type_covers) (tree a, tree b);
|
int (*lang_eh_type_covers) (tree a, tree b);
|
|
|
static GTY(()) int call_site_base;
|
static GTY(()) int call_site_base;
|
static GTY ((param_is (union tree_node)))
|
static GTY ((param_is (union tree_node)))
|
htab_t type_to_runtime_map;
|
htab_t type_to_runtime_map;
|
|
|
/* Describe the SjLj_Function_Context structure. */
|
/* Describe the SjLj_Function_Context structure. */
|
static GTY(()) tree sjlj_fc_type_node;
|
static GTY(()) tree sjlj_fc_type_node;
|
static int sjlj_fc_call_site_ofs;
|
static int sjlj_fc_call_site_ofs;
|
static int sjlj_fc_data_ofs;
|
static int sjlj_fc_data_ofs;
|
static int sjlj_fc_personality_ofs;
|
static int sjlj_fc_personality_ofs;
|
static int sjlj_fc_lsda_ofs;
|
static int sjlj_fc_lsda_ofs;
|
static int sjlj_fc_jbuf_ofs;
|
static int sjlj_fc_jbuf_ofs;
|
|
|
|
|
struct GTY(()) call_site_record_d
|
struct GTY(()) call_site_record_d
|
{
|
{
|
rtx landing_pad;
|
rtx landing_pad;
|
int action;
|
int action;
|
};
|
};
|
|
|
static bool get_eh_region_and_lp_from_rtx (const_rtx, eh_region *,
|
static bool get_eh_region_and_lp_from_rtx (const_rtx, eh_region *,
|
eh_landing_pad *);
|
eh_landing_pad *);
|
|
|
static int t2r_eq (const void *, const void *);
|
static int t2r_eq (const void *, const void *);
|
static hashval_t t2r_hash (const void *);
|
static hashval_t t2r_hash (const void *);
|
|
|
static int ttypes_filter_eq (const void *, const void *);
|
static int ttypes_filter_eq (const void *, const void *);
|
static hashval_t ttypes_filter_hash (const void *);
|
static hashval_t ttypes_filter_hash (const void *);
|
static int ehspec_filter_eq (const void *, const void *);
|
static int ehspec_filter_eq (const void *, const void *);
|
static hashval_t ehspec_filter_hash (const void *);
|
static hashval_t ehspec_filter_hash (const void *);
|
static int add_ttypes_entry (htab_t, tree);
|
static int add_ttypes_entry (htab_t, tree);
|
static int add_ehspec_entry (htab_t, htab_t, tree);
|
static int add_ehspec_entry (htab_t, htab_t, tree);
|
static void dw2_build_landing_pads (void);
|
static void dw2_build_landing_pads (void);
|
|
|
static int action_record_eq (const void *, const void *);
|
static int action_record_eq (const void *, const void *);
|
static hashval_t action_record_hash (const void *);
|
static hashval_t action_record_hash (const void *);
|
static int add_action_record (htab_t, int, int);
|
static int add_action_record (htab_t, int, int);
|
static int collect_one_action_chain (htab_t, eh_region);
|
static int collect_one_action_chain (htab_t, eh_region);
|
static int add_call_site (rtx, int, int);
|
static int add_call_site (rtx, int, int);
|
|
|
static void push_uleb128 (VEC (uchar, gc) **, unsigned int);
|
static void push_uleb128 (VEC (uchar, gc) **, unsigned int);
|
static void push_sleb128 (VEC (uchar, gc) **, int);
|
static void push_sleb128 (VEC (uchar, gc) **, int);
|
#ifndef HAVE_AS_LEB128
|
#ifndef HAVE_AS_LEB128
|
static int dw2_size_of_call_site_table (int);
|
static int dw2_size_of_call_site_table (int);
|
static int sjlj_size_of_call_site_table (void);
|
static int sjlj_size_of_call_site_table (void);
|
#endif
|
#endif
|
static void dw2_output_call_site_table (int, int);
|
static void dw2_output_call_site_table (int, int);
|
static void sjlj_output_call_site_table (void);
|
static void sjlj_output_call_site_table (void);
|
|
|
|
|
/* Routine to see if exception handling is turned on.
|
/* Routine to see if exception handling is turned on.
|
DO_WARN is nonzero if we want to inform the user that exception
|
DO_WARN is nonzero 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
|
This is used to ensure that -fexceptions has been specified if the
|
compiler tries to use any exception-specific functions. */
|
compiler tries to use any exception-specific functions. */
|
|
|
int
|
int
|
doing_eh (int do_warn)
|
doing_eh (int do_warn)
|
{
|
{
|
if (! flag_exceptions)
|
if (! flag_exceptions)
|
{
|
{
|
static int warned = 0;
|
static int warned = 0;
|
if (! warned && do_warn)
|
if (! warned && do_warn)
|
{
|
{
|
error ("exception handling disabled, use -fexceptions to enable");
|
error ("exception handling disabled, use -fexceptions to enable");
|
warned = 1;
|
warned = 1;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
return 1;
|
return 1;
|
}
|
}
|
|
|
|
|
void
|
void
|
init_eh (void)
|
init_eh (void)
|
{
|
{
|
if (! flag_exceptions)
|
if (! flag_exceptions)
|
return;
|
return;
|
|
|
type_to_runtime_map = htab_create_ggc (31, t2r_hash, t2r_eq, NULL);
|
type_to_runtime_map = htab_create_ggc (31, t2r_hash, t2r_eq, NULL);
|
|
|
/* Create the SjLj_Function_Context structure. This should match
|
/* Create the SjLj_Function_Context structure. This should match
|
the definition in unwind-sjlj.c. */
|
the definition in unwind-sjlj.c. */
|
if (USING_SJLJ_EXCEPTIONS)
|
if (USING_SJLJ_EXCEPTIONS)
|
{
|
{
|
tree f_jbuf, f_per, f_lsda, f_prev, f_cs, f_data, tmp;
|
tree f_jbuf, f_per, f_lsda, f_prev, f_cs, f_data, tmp;
|
|
|
sjlj_fc_type_node = lang_hooks.types.make_type (RECORD_TYPE);
|
sjlj_fc_type_node = lang_hooks.types.make_type (RECORD_TYPE);
|
|
|
f_prev = build_decl (BUILTINS_LOCATION,
|
f_prev = build_decl (BUILTINS_LOCATION,
|
FIELD_DECL, get_identifier ("__prev"),
|
FIELD_DECL, get_identifier ("__prev"),
|
build_pointer_type (sjlj_fc_type_node));
|
build_pointer_type (sjlj_fc_type_node));
|
DECL_FIELD_CONTEXT (f_prev) = sjlj_fc_type_node;
|
DECL_FIELD_CONTEXT (f_prev) = sjlj_fc_type_node;
|
|
|
f_cs = build_decl (BUILTINS_LOCATION,
|
f_cs = build_decl (BUILTINS_LOCATION,
|
FIELD_DECL, get_identifier ("__call_site"),
|
FIELD_DECL, get_identifier ("__call_site"),
|
integer_type_node);
|
integer_type_node);
|
DECL_FIELD_CONTEXT (f_cs) = sjlj_fc_type_node;
|
DECL_FIELD_CONTEXT (f_cs) = sjlj_fc_type_node;
|
|
|
tmp = build_index_type (build_int_cst (NULL_TREE, 4 - 1));
|
tmp = build_index_type (build_int_cst (NULL_TREE, 4 - 1));
|
tmp = build_array_type (lang_hooks.types.type_for_mode
|
tmp = build_array_type (lang_hooks.types.type_for_mode
|
(targetm.unwind_word_mode (), 1),
|
(targetm.unwind_word_mode (), 1),
|
tmp);
|
tmp);
|
f_data = build_decl (BUILTINS_LOCATION,
|
f_data = build_decl (BUILTINS_LOCATION,
|
FIELD_DECL, get_identifier ("__data"), tmp);
|
FIELD_DECL, get_identifier ("__data"), tmp);
|
DECL_FIELD_CONTEXT (f_data) = sjlj_fc_type_node;
|
DECL_FIELD_CONTEXT (f_data) = sjlj_fc_type_node;
|
|
|
f_per = build_decl (BUILTINS_LOCATION,
|
f_per = build_decl (BUILTINS_LOCATION,
|
FIELD_DECL, get_identifier ("__personality"),
|
FIELD_DECL, get_identifier ("__personality"),
|
ptr_type_node);
|
ptr_type_node);
|
DECL_FIELD_CONTEXT (f_per) = sjlj_fc_type_node;
|
DECL_FIELD_CONTEXT (f_per) = sjlj_fc_type_node;
|
|
|
f_lsda = build_decl (BUILTINS_LOCATION,
|
f_lsda = build_decl (BUILTINS_LOCATION,
|
FIELD_DECL, get_identifier ("__lsda"),
|
FIELD_DECL, get_identifier ("__lsda"),
|
ptr_type_node);
|
ptr_type_node);
|
DECL_FIELD_CONTEXT (f_lsda) = sjlj_fc_type_node;
|
DECL_FIELD_CONTEXT (f_lsda) = sjlj_fc_type_node;
|
|
|
#ifdef DONT_USE_BUILTIN_SETJMP
|
#ifdef DONT_USE_BUILTIN_SETJMP
|
#ifdef JMP_BUF_SIZE
|
#ifdef JMP_BUF_SIZE
|
tmp = build_int_cst (NULL_TREE, JMP_BUF_SIZE - 1);
|
tmp = build_int_cst (NULL_TREE, JMP_BUF_SIZE - 1);
|
#else
|
#else
|
/* Should be large enough for most systems, if it is not,
|
/* Should be large enough for most systems, if it is not,
|
JMP_BUF_SIZE should be defined with the proper value. It will
|
JMP_BUF_SIZE should be defined with the proper value. It will
|
also tend to be larger than necessary for most systems, a more
|
also tend to be larger than necessary for most systems, a more
|
optimal port will define JMP_BUF_SIZE. */
|
optimal port will define JMP_BUF_SIZE. */
|
tmp = build_int_cst (NULL_TREE, FIRST_PSEUDO_REGISTER + 2 - 1);
|
tmp = build_int_cst (NULL_TREE, FIRST_PSEUDO_REGISTER + 2 - 1);
|
#endif
|
#endif
|
#else
|
#else
|
/* builtin_setjmp takes a pointer to 5 words. */
|
/* builtin_setjmp takes a pointer to 5 words. */
|
tmp = build_int_cst (NULL_TREE, 5 * BITS_PER_WORD / POINTER_SIZE - 1);
|
tmp = build_int_cst (NULL_TREE, 5 * BITS_PER_WORD / POINTER_SIZE - 1);
|
#endif
|
#endif
|
tmp = build_index_type (tmp);
|
tmp = build_index_type (tmp);
|
tmp = build_array_type (ptr_type_node, tmp);
|
tmp = build_array_type (ptr_type_node, tmp);
|
f_jbuf = build_decl (BUILTINS_LOCATION,
|
f_jbuf = build_decl (BUILTINS_LOCATION,
|
FIELD_DECL, get_identifier ("__jbuf"), tmp);
|
FIELD_DECL, get_identifier ("__jbuf"), tmp);
|
#ifdef DONT_USE_BUILTIN_SETJMP
|
#ifdef DONT_USE_BUILTIN_SETJMP
|
/* We don't know what the alignment requirements of the
|
/* We don't know what the alignment requirements of the
|
runtime's jmp_buf has. Overestimate. */
|
runtime's jmp_buf has. Overestimate. */
|
DECL_ALIGN (f_jbuf) = BIGGEST_ALIGNMENT;
|
DECL_ALIGN (f_jbuf) = BIGGEST_ALIGNMENT;
|
DECL_USER_ALIGN (f_jbuf) = 1;
|
DECL_USER_ALIGN (f_jbuf) = 1;
|
#endif
|
#endif
|
DECL_FIELD_CONTEXT (f_jbuf) = sjlj_fc_type_node;
|
DECL_FIELD_CONTEXT (f_jbuf) = sjlj_fc_type_node;
|
|
|
TYPE_FIELDS (sjlj_fc_type_node) = f_prev;
|
TYPE_FIELDS (sjlj_fc_type_node) = f_prev;
|
TREE_CHAIN (f_prev) = f_cs;
|
TREE_CHAIN (f_prev) = f_cs;
|
TREE_CHAIN (f_cs) = f_data;
|
TREE_CHAIN (f_cs) = f_data;
|
TREE_CHAIN (f_data) = f_per;
|
TREE_CHAIN (f_data) = f_per;
|
TREE_CHAIN (f_per) = f_lsda;
|
TREE_CHAIN (f_per) = f_lsda;
|
TREE_CHAIN (f_lsda) = f_jbuf;
|
TREE_CHAIN (f_lsda) = f_jbuf;
|
|
|
layout_type (sjlj_fc_type_node);
|
layout_type (sjlj_fc_type_node);
|
|
|
/* Cache the interesting field offsets so that we have
|
/* Cache the interesting field offsets so that we have
|
easy access from rtl. */
|
easy access from rtl. */
|
sjlj_fc_call_site_ofs
|
sjlj_fc_call_site_ofs
|
= (tree_low_cst (DECL_FIELD_OFFSET (f_cs), 1)
|
= (tree_low_cst (DECL_FIELD_OFFSET (f_cs), 1)
|
+ tree_low_cst (DECL_FIELD_BIT_OFFSET (f_cs), 1) / BITS_PER_UNIT);
|
+ tree_low_cst (DECL_FIELD_BIT_OFFSET (f_cs), 1) / BITS_PER_UNIT);
|
sjlj_fc_data_ofs
|
sjlj_fc_data_ofs
|
= (tree_low_cst (DECL_FIELD_OFFSET (f_data), 1)
|
= (tree_low_cst (DECL_FIELD_OFFSET (f_data), 1)
|
+ tree_low_cst (DECL_FIELD_BIT_OFFSET (f_data), 1) / BITS_PER_UNIT);
|
+ tree_low_cst (DECL_FIELD_BIT_OFFSET (f_data), 1) / BITS_PER_UNIT);
|
sjlj_fc_personality_ofs
|
sjlj_fc_personality_ofs
|
= (tree_low_cst (DECL_FIELD_OFFSET (f_per), 1)
|
= (tree_low_cst (DECL_FIELD_OFFSET (f_per), 1)
|
+ tree_low_cst (DECL_FIELD_BIT_OFFSET (f_per), 1) / BITS_PER_UNIT);
|
+ tree_low_cst (DECL_FIELD_BIT_OFFSET (f_per), 1) / BITS_PER_UNIT);
|
sjlj_fc_lsda_ofs
|
sjlj_fc_lsda_ofs
|
= (tree_low_cst (DECL_FIELD_OFFSET (f_lsda), 1)
|
= (tree_low_cst (DECL_FIELD_OFFSET (f_lsda), 1)
|
+ tree_low_cst (DECL_FIELD_BIT_OFFSET (f_lsda), 1) / BITS_PER_UNIT);
|
+ tree_low_cst (DECL_FIELD_BIT_OFFSET (f_lsda), 1) / BITS_PER_UNIT);
|
sjlj_fc_jbuf_ofs
|
sjlj_fc_jbuf_ofs
|
= (tree_low_cst (DECL_FIELD_OFFSET (f_jbuf), 1)
|
= (tree_low_cst (DECL_FIELD_OFFSET (f_jbuf), 1)
|
+ tree_low_cst (DECL_FIELD_BIT_OFFSET (f_jbuf), 1) / BITS_PER_UNIT);
|
+ tree_low_cst (DECL_FIELD_BIT_OFFSET (f_jbuf), 1) / BITS_PER_UNIT);
|
}
|
}
|
}
|
}
|
|
|
void
|
void
|
init_eh_for_function (void)
|
init_eh_for_function (void)
|
{
|
{
|
cfun->eh = GGC_CNEW (struct eh_status);
|
cfun->eh = GGC_CNEW (struct eh_status);
|
|
|
/* Make sure zero'th entries are used. */
|
/* Make sure zero'th entries are used. */
|
VEC_safe_push (eh_region, gc, cfun->eh->region_array, NULL);
|
VEC_safe_push (eh_region, gc, cfun->eh->region_array, NULL);
|
VEC_safe_push (eh_landing_pad, gc, cfun->eh->lp_array, NULL);
|
VEC_safe_push (eh_landing_pad, gc, cfun->eh->lp_array, NULL);
|
}
|
}
|
|
|
/* Routines to generate the exception tree somewhat directly.
|
/* Routines to generate the exception tree somewhat directly.
|
These are used from tree-eh.c when processing exception related
|
These are used from tree-eh.c when processing exception related
|
nodes during tree optimization. */
|
nodes during tree optimization. */
|
|
|
static eh_region
|
static eh_region
|
gen_eh_region (enum eh_region_type type, eh_region outer)
|
gen_eh_region (enum eh_region_type type, eh_region outer)
|
{
|
{
|
eh_region new_eh;
|
eh_region new_eh;
|
|
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
gcc_assert (doing_eh (0));
|
gcc_assert (doing_eh (0));
|
#endif
|
#endif
|
|
|
/* Insert a new blank region as a leaf in the tree. */
|
/* Insert a new blank region as a leaf in the tree. */
|
new_eh = GGC_CNEW (struct eh_region_d);
|
new_eh = GGC_CNEW (struct eh_region_d);
|
new_eh->type = type;
|
new_eh->type = type;
|
new_eh->outer = outer;
|
new_eh->outer = outer;
|
if (outer)
|
if (outer)
|
{
|
{
|
new_eh->next_peer = outer->inner;
|
new_eh->next_peer = outer->inner;
|
outer->inner = new_eh;
|
outer->inner = new_eh;
|
}
|
}
|
else
|
else
|
{
|
{
|
new_eh->next_peer = cfun->eh->region_tree;
|
new_eh->next_peer = cfun->eh->region_tree;
|
cfun->eh->region_tree = new_eh;
|
cfun->eh->region_tree = new_eh;
|
}
|
}
|
|
|
new_eh->index = VEC_length (eh_region, cfun->eh->region_array);
|
new_eh->index = VEC_length (eh_region, cfun->eh->region_array);
|
VEC_safe_push (eh_region, gc, cfun->eh->region_array, new_eh);
|
VEC_safe_push (eh_region, gc, cfun->eh->region_array, new_eh);
|
|
|
/* Copy the language's notion of whether to use __cxa_end_cleanup. */
|
/* Copy the language's notion of whether to use __cxa_end_cleanup. */
|
if (targetm.arm_eabi_unwinder && lang_hooks.eh_use_cxa_end_cleanup)
|
if (targetm.arm_eabi_unwinder && lang_hooks.eh_use_cxa_end_cleanup)
|
new_eh->use_cxa_end_cleanup = true;
|
new_eh->use_cxa_end_cleanup = true;
|
|
|
return new_eh;
|
return new_eh;
|
}
|
}
|
|
|
eh_region
|
eh_region
|
gen_eh_region_cleanup (eh_region outer)
|
gen_eh_region_cleanup (eh_region outer)
|
{
|
{
|
return gen_eh_region (ERT_CLEANUP, outer);
|
return gen_eh_region (ERT_CLEANUP, outer);
|
}
|
}
|
|
|
eh_region
|
eh_region
|
gen_eh_region_try (eh_region outer)
|
gen_eh_region_try (eh_region outer)
|
{
|
{
|
return gen_eh_region (ERT_TRY, outer);
|
return gen_eh_region (ERT_TRY, outer);
|
}
|
}
|
|
|
eh_catch
|
eh_catch
|
gen_eh_region_catch (eh_region t, tree type_or_list)
|
gen_eh_region_catch (eh_region t, tree type_or_list)
|
{
|
{
|
eh_catch c, l;
|
eh_catch c, l;
|
tree type_list, type_node;
|
tree type_list, type_node;
|
|
|
gcc_assert (t->type == ERT_TRY);
|
gcc_assert (t->type == ERT_TRY);
|
|
|
/* Ensure to always end up with a type list to normalize further
|
/* Ensure to always end up with a type list to normalize further
|
processing, then register each type against the runtime types map. */
|
processing, then register each type against the runtime types map. */
|
type_list = type_or_list;
|
type_list = type_or_list;
|
if (type_or_list)
|
if (type_or_list)
|
{
|
{
|
if (TREE_CODE (type_or_list) != TREE_LIST)
|
if (TREE_CODE (type_or_list) != TREE_LIST)
|
type_list = tree_cons (NULL_TREE, type_or_list, NULL_TREE);
|
type_list = tree_cons (NULL_TREE, type_or_list, NULL_TREE);
|
|
|
type_node = type_list;
|
type_node = type_list;
|
for (; type_node; type_node = TREE_CHAIN (type_node))
|
for (; type_node; type_node = TREE_CHAIN (type_node))
|
add_type_for_runtime (TREE_VALUE (type_node));
|
add_type_for_runtime (TREE_VALUE (type_node));
|
}
|
}
|
|
|
c = GGC_CNEW (struct eh_catch_d);
|
c = GGC_CNEW (struct eh_catch_d);
|
c->type_list = type_list;
|
c->type_list = type_list;
|
l = t->u.eh_try.last_catch;
|
l = t->u.eh_try.last_catch;
|
c->prev_catch = l;
|
c->prev_catch = l;
|
if (l)
|
if (l)
|
l->next_catch = c;
|
l->next_catch = c;
|
else
|
else
|
t->u.eh_try.first_catch = c;
|
t->u.eh_try.first_catch = c;
|
t->u.eh_try.last_catch = c;
|
t->u.eh_try.last_catch = c;
|
|
|
return c;
|
return c;
|
}
|
}
|
|
|
eh_region
|
eh_region
|
gen_eh_region_allowed (eh_region outer, tree allowed)
|
gen_eh_region_allowed (eh_region outer, tree allowed)
|
{
|
{
|
eh_region region = gen_eh_region (ERT_ALLOWED_EXCEPTIONS, outer);
|
eh_region region = gen_eh_region (ERT_ALLOWED_EXCEPTIONS, outer);
|
region->u.allowed.type_list = allowed;
|
region->u.allowed.type_list = allowed;
|
|
|
for (; allowed ; allowed = TREE_CHAIN (allowed))
|
for (; allowed ; allowed = TREE_CHAIN (allowed))
|
add_type_for_runtime (TREE_VALUE (allowed));
|
add_type_for_runtime (TREE_VALUE (allowed));
|
|
|
return region;
|
return region;
|
}
|
}
|
|
|
eh_region
|
eh_region
|
gen_eh_region_must_not_throw (eh_region outer)
|
gen_eh_region_must_not_throw (eh_region outer)
|
{
|
{
|
return gen_eh_region (ERT_MUST_NOT_THROW, outer);
|
return gen_eh_region (ERT_MUST_NOT_THROW, outer);
|
}
|
}
|
|
|
eh_landing_pad
|
eh_landing_pad
|
gen_eh_landing_pad (eh_region region)
|
gen_eh_landing_pad (eh_region region)
|
{
|
{
|
eh_landing_pad lp = GGC_CNEW (struct eh_landing_pad_d);
|
eh_landing_pad lp = GGC_CNEW (struct eh_landing_pad_d);
|
|
|
lp->next_lp = region->landing_pads;
|
lp->next_lp = region->landing_pads;
|
lp->region = region;
|
lp->region = region;
|
lp->index = VEC_length (eh_landing_pad, cfun->eh->lp_array);
|
lp->index = VEC_length (eh_landing_pad, cfun->eh->lp_array);
|
region->landing_pads = lp;
|
region->landing_pads = lp;
|
|
|
VEC_safe_push (eh_landing_pad, gc, cfun->eh->lp_array, lp);
|
VEC_safe_push (eh_landing_pad, gc, cfun->eh->lp_array, lp);
|
|
|
return lp;
|
return lp;
|
}
|
}
|
|
|
eh_region
|
eh_region
|
get_eh_region_from_number_fn (struct function *ifun, int i)
|
get_eh_region_from_number_fn (struct function *ifun, int i)
|
{
|
{
|
return VEC_index (eh_region, ifun->eh->region_array, i);
|
return VEC_index (eh_region, ifun->eh->region_array, i);
|
}
|
}
|
|
|
eh_region
|
eh_region
|
get_eh_region_from_number (int i)
|
get_eh_region_from_number (int i)
|
{
|
{
|
return get_eh_region_from_number_fn (cfun, i);
|
return get_eh_region_from_number_fn (cfun, i);
|
}
|
}
|
|
|
eh_landing_pad
|
eh_landing_pad
|
get_eh_landing_pad_from_number_fn (struct function *ifun, int i)
|
get_eh_landing_pad_from_number_fn (struct function *ifun, int i)
|
{
|
{
|
return VEC_index (eh_landing_pad, ifun->eh->lp_array, i);
|
return VEC_index (eh_landing_pad, ifun->eh->lp_array, i);
|
}
|
}
|
|
|
eh_landing_pad
|
eh_landing_pad
|
get_eh_landing_pad_from_number (int i)
|
get_eh_landing_pad_from_number (int i)
|
{
|
{
|
return get_eh_landing_pad_from_number_fn (cfun, i);
|
return get_eh_landing_pad_from_number_fn (cfun, i);
|
}
|
}
|
|
|
eh_region
|
eh_region
|
get_eh_region_from_lp_number_fn (struct function *ifun, int i)
|
get_eh_region_from_lp_number_fn (struct function *ifun, int i)
|
{
|
{
|
if (i < 0)
|
if (i < 0)
|
return VEC_index (eh_region, ifun->eh->region_array, -i);
|
return VEC_index (eh_region, ifun->eh->region_array, -i);
|
else if (i == 0)
|
else if (i == 0)
|
return NULL;
|
return NULL;
|
else
|
else
|
{
|
{
|
eh_landing_pad lp;
|
eh_landing_pad lp;
|
lp = VEC_index (eh_landing_pad, ifun->eh->lp_array, i);
|
lp = VEC_index (eh_landing_pad, ifun->eh->lp_array, i);
|
return lp->region;
|
return lp->region;
|
}
|
}
|
}
|
}
|
|
|
eh_region
|
eh_region
|
get_eh_region_from_lp_number (int i)
|
get_eh_region_from_lp_number (int i)
|
{
|
{
|
return get_eh_region_from_lp_number_fn (cfun, i);
|
return get_eh_region_from_lp_number_fn (cfun, i);
|
}
|
}
|
|
|
/* Returns true if the current function has exception handling regions. */
|
/* Returns true if the current function has exception handling regions. */
|
|
|
bool
|
bool
|
current_function_has_exception_handlers (void)
|
current_function_has_exception_handlers (void)
|
{
|
{
|
return cfun->eh->region_tree != NULL;
|
return cfun->eh->region_tree != NULL;
|
}
|
}
|
|
|
/* A subroutine of duplicate_eh_regions. Copy the eh_region tree at OLD.
|
/* A subroutine of duplicate_eh_regions. Copy the eh_region tree at OLD.
|
Root it at OUTER, and apply LP_OFFSET to the lp numbers. */
|
Root it at OUTER, and apply LP_OFFSET to the lp numbers. */
|
|
|
struct duplicate_eh_regions_data
|
struct duplicate_eh_regions_data
|
{
|
{
|
duplicate_eh_regions_map label_map;
|
duplicate_eh_regions_map label_map;
|
void *label_map_data;
|
void *label_map_data;
|
struct pointer_map_t *eh_map;
|
struct pointer_map_t *eh_map;
|
};
|
};
|
|
|
static void
|
static void
|
duplicate_eh_regions_1 (struct duplicate_eh_regions_data *data,
|
duplicate_eh_regions_1 (struct duplicate_eh_regions_data *data,
|
eh_region old_r, eh_region outer)
|
eh_region old_r, eh_region outer)
|
{
|
{
|
eh_landing_pad old_lp, new_lp;
|
eh_landing_pad old_lp, new_lp;
|
eh_region new_r;
|
eh_region new_r;
|
void **slot;
|
void **slot;
|
|
|
new_r = gen_eh_region (old_r->type, outer);
|
new_r = gen_eh_region (old_r->type, outer);
|
slot = pointer_map_insert (data->eh_map, (void *)old_r);
|
slot = pointer_map_insert (data->eh_map, (void *)old_r);
|
gcc_assert (*slot == NULL);
|
gcc_assert (*slot == NULL);
|
*slot = (void *)new_r;
|
*slot = (void *)new_r;
|
|
|
switch (old_r->type)
|
switch (old_r->type)
|
{
|
{
|
case ERT_CLEANUP:
|
case ERT_CLEANUP:
|
break;
|
break;
|
|
|
case ERT_TRY:
|
case ERT_TRY:
|
{
|
{
|
eh_catch oc, nc;
|
eh_catch oc, nc;
|
for (oc = old_r->u.eh_try.first_catch; oc ; oc = oc->next_catch)
|
for (oc = old_r->u.eh_try.first_catch; oc ; oc = oc->next_catch)
|
{
|
{
|
/* We should be doing all our region duplication before and
|
/* We should be doing all our region duplication before and
|
during inlining, which is before filter lists are created. */
|
during inlining, which is before filter lists are created. */
|
gcc_assert (oc->filter_list == NULL);
|
gcc_assert (oc->filter_list == NULL);
|
nc = gen_eh_region_catch (new_r, oc->type_list);
|
nc = gen_eh_region_catch (new_r, oc->type_list);
|
nc->label = data->label_map (oc->label, data->label_map_data);
|
nc->label = data->label_map (oc->label, data->label_map_data);
|
}
|
}
|
}
|
}
|
break;
|
break;
|
|
|
case ERT_ALLOWED_EXCEPTIONS:
|
case ERT_ALLOWED_EXCEPTIONS:
|
new_r->u.allowed.type_list = old_r->u.allowed.type_list;
|
new_r->u.allowed.type_list = old_r->u.allowed.type_list;
|
if (old_r->u.allowed.label)
|
if (old_r->u.allowed.label)
|
new_r->u.allowed.label
|
new_r->u.allowed.label
|
= data->label_map (old_r->u.allowed.label, data->label_map_data);
|
= data->label_map (old_r->u.allowed.label, data->label_map_data);
|
else
|
else
|
new_r->u.allowed.label = NULL_TREE;
|
new_r->u.allowed.label = NULL_TREE;
|
break;
|
break;
|
|
|
case ERT_MUST_NOT_THROW:
|
case ERT_MUST_NOT_THROW:
|
new_r->u.must_not_throw = old_r->u.must_not_throw;
|
new_r->u.must_not_throw = old_r->u.must_not_throw;
|
break;
|
break;
|
}
|
}
|
|
|
for (old_lp = old_r->landing_pads; old_lp ; old_lp = old_lp->next_lp)
|
for (old_lp = old_r->landing_pads; old_lp ; old_lp = old_lp->next_lp)
|
{
|
{
|
/* Don't bother copying unused landing pads. */
|
/* Don't bother copying unused landing pads. */
|
if (old_lp->post_landing_pad == NULL)
|
if (old_lp->post_landing_pad == NULL)
|
continue;
|
continue;
|
|
|
new_lp = gen_eh_landing_pad (new_r);
|
new_lp = gen_eh_landing_pad (new_r);
|
slot = pointer_map_insert (data->eh_map, (void *)old_lp);
|
slot = pointer_map_insert (data->eh_map, (void *)old_lp);
|
gcc_assert (*slot == NULL);
|
gcc_assert (*slot == NULL);
|
*slot = (void *)new_lp;
|
*slot = (void *)new_lp;
|
|
|
new_lp->post_landing_pad
|
new_lp->post_landing_pad
|
= data->label_map (old_lp->post_landing_pad, data->label_map_data);
|
= data->label_map (old_lp->post_landing_pad, data->label_map_data);
|
EH_LANDING_PAD_NR (new_lp->post_landing_pad) = new_lp->index;
|
EH_LANDING_PAD_NR (new_lp->post_landing_pad) = new_lp->index;
|
}
|
}
|
|
|
/* Make sure to preserve the original use of __cxa_end_cleanup. */
|
/* Make sure to preserve the original use of __cxa_end_cleanup. */
|
new_r->use_cxa_end_cleanup = old_r->use_cxa_end_cleanup;
|
new_r->use_cxa_end_cleanup = old_r->use_cxa_end_cleanup;
|
|
|
for (old_r = old_r->inner; old_r ; old_r = old_r->next_peer)
|
for (old_r = old_r->inner; old_r ; old_r = old_r->next_peer)
|
duplicate_eh_regions_1 (data, old_r, new_r);
|
duplicate_eh_regions_1 (data, old_r, new_r);
|
}
|
}
|
|
|
/* Duplicate the EH regions from IFUN rooted at COPY_REGION into
|
/* Duplicate the EH regions from IFUN rooted at COPY_REGION into
|
the current function and root the tree below OUTER_REGION.
|
the current function and root the tree below OUTER_REGION.
|
The special case of COPY_REGION of NULL means all regions.
|
The special case of COPY_REGION of NULL means all regions.
|
Remap labels using MAP/MAP_DATA callback. Return a pointer map
|
Remap labels using MAP/MAP_DATA callback. Return a pointer map
|
that allows the caller to remap uses of both EH regions and
|
that allows the caller to remap uses of both EH regions and
|
EH landing pads. */
|
EH landing pads. */
|
|
|
struct pointer_map_t *
|
struct pointer_map_t *
|
duplicate_eh_regions (struct function *ifun,
|
duplicate_eh_regions (struct function *ifun,
|
eh_region copy_region, int outer_lp,
|
eh_region copy_region, int outer_lp,
|
duplicate_eh_regions_map map, void *map_data)
|
duplicate_eh_regions_map map, void *map_data)
|
{
|
{
|
struct duplicate_eh_regions_data data;
|
struct duplicate_eh_regions_data data;
|
eh_region outer_region;
|
eh_region outer_region;
|
|
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
verify_eh_tree (ifun);
|
verify_eh_tree (ifun);
|
#endif
|
#endif
|
|
|
data.label_map = map;
|
data.label_map = map;
|
data.label_map_data = map_data;
|
data.label_map_data = map_data;
|
data.eh_map = pointer_map_create ();
|
data.eh_map = pointer_map_create ();
|
|
|
outer_region = get_eh_region_from_lp_number (outer_lp);
|
outer_region = get_eh_region_from_lp_number (outer_lp);
|
|
|
/* Copy all the regions in the subtree. */
|
/* Copy all the regions in the subtree. */
|
if (copy_region)
|
if (copy_region)
|
duplicate_eh_regions_1 (&data, copy_region, outer_region);
|
duplicate_eh_regions_1 (&data, copy_region, outer_region);
|
else
|
else
|
{
|
{
|
eh_region r;
|
eh_region r;
|
for (r = ifun->eh->region_tree; r ; r = r->next_peer)
|
for (r = ifun->eh->region_tree; r ; r = r->next_peer)
|
duplicate_eh_regions_1 (&data, r, outer_region);
|
duplicate_eh_regions_1 (&data, r, outer_region);
|
}
|
}
|
|
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
verify_eh_tree (cfun);
|
verify_eh_tree (cfun);
|
#endif
|
#endif
|
|
|
return data.eh_map;
|
return data.eh_map;
|
}
|
}
|
|
|
/* Return the region that is outer to both REGION_A and REGION_B in IFUN. */
|
/* Return the region that is outer to both REGION_A and REGION_B in IFUN. */
|
|
|
eh_region
|
eh_region
|
eh_region_outermost (struct function *ifun, eh_region region_a,
|
eh_region_outermost (struct function *ifun, eh_region region_a,
|
eh_region region_b)
|
eh_region region_b)
|
{
|
{
|
sbitmap b_outer;
|
sbitmap b_outer;
|
|
|
gcc_assert (ifun->eh->region_array);
|
gcc_assert (ifun->eh->region_array);
|
gcc_assert (ifun->eh->region_tree);
|
gcc_assert (ifun->eh->region_tree);
|
|
|
b_outer = sbitmap_alloc (VEC_length (eh_region, ifun->eh->region_array));
|
b_outer = sbitmap_alloc (VEC_length (eh_region, ifun->eh->region_array));
|
sbitmap_zero (b_outer);
|
sbitmap_zero (b_outer);
|
|
|
do
|
do
|
{
|
{
|
SET_BIT (b_outer, region_b->index);
|
SET_BIT (b_outer, region_b->index);
|
region_b = region_b->outer;
|
region_b = region_b->outer;
|
}
|
}
|
while (region_b);
|
while (region_b);
|
|
|
do
|
do
|
{
|
{
|
if (TEST_BIT (b_outer, region_a->index))
|
if (TEST_BIT (b_outer, region_a->index))
|
break;
|
break;
|
region_a = region_a->outer;
|
region_a = region_a->outer;
|
}
|
}
|
while (region_a);
|
while (region_a);
|
|
|
sbitmap_free (b_outer);
|
sbitmap_free (b_outer);
|
return region_a;
|
return region_a;
|
}
|
}
|
|
|
static int
|
static int
|
t2r_eq (const void *pentry, const void *pdata)
|
t2r_eq (const void *pentry, const void *pdata)
|
{
|
{
|
const_tree const entry = (const_tree) pentry;
|
const_tree const entry = (const_tree) pentry;
|
const_tree const data = (const_tree) pdata;
|
const_tree const data = (const_tree) pdata;
|
|
|
return TREE_PURPOSE (entry) == data;
|
return TREE_PURPOSE (entry) == data;
|
}
|
}
|
|
|
static hashval_t
|
static hashval_t
|
t2r_hash (const void *pentry)
|
t2r_hash (const void *pentry)
|
{
|
{
|
const_tree const entry = (const_tree) pentry;
|
const_tree const entry = (const_tree) pentry;
|
return TREE_HASH (TREE_PURPOSE (entry));
|
return TREE_HASH (TREE_PURPOSE (entry));
|
}
|
}
|
|
|
void
|
void
|
add_type_for_runtime (tree type)
|
add_type_for_runtime (tree type)
|
{
|
{
|
tree *slot;
|
tree *slot;
|
|
|
/* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
|
/* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
|
if (TREE_CODE (type) == NOP_EXPR)
|
if (TREE_CODE (type) == NOP_EXPR)
|
return;
|
return;
|
|
|
slot = (tree *) htab_find_slot_with_hash (type_to_runtime_map, type,
|
slot = (tree *) htab_find_slot_with_hash (type_to_runtime_map, type,
|
TREE_HASH (type), INSERT);
|
TREE_HASH (type), INSERT);
|
if (*slot == NULL)
|
if (*slot == NULL)
|
{
|
{
|
tree runtime = lang_hooks.eh_runtime_type (type);
|
tree runtime = lang_hooks.eh_runtime_type (type);
|
*slot = tree_cons (type, runtime, NULL_TREE);
|
*slot = tree_cons (type, runtime, NULL_TREE);
|
}
|
}
|
}
|
}
|
|
|
tree
|
tree
|
lookup_type_for_runtime (tree type)
|
lookup_type_for_runtime (tree type)
|
{
|
{
|
tree *slot;
|
tree *slot;
|
|
|
/* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
|
/* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
|
if (TREE_CODE (type) == NOP_EXPR)
|
if (TREE_CODE (type) == NOP_EXPR)
|
return type;
|
return type;
|
|
|
slot = (tree *) htab_find_slot_with_hash (type_to_runtime_map, type,
|
slot = (tree *) htab_find_slot_with_hash (type_to_runtime_map, type,
|
TREE_HASH (type), NO_INSERT);
|
TREE_HASH (type), NO_INSERT);
|
|
|
/* We should have always inserted the data earlier. */
|
/* We should have always inserted the data earlier. */
|
return TREE_VALUE (*slot);
|
return TREE_VALUE (*slot);
|
}
|
}
|
|
|
|
|
/* Represent an entry in @TTypes for either catch actions
|
/* Represent an entry in @TTypes for either catch actions
|
or exception filter actions. */
|
or exception filter actions. */
|
struct GTY(()) ttypes_filter {
|
struct GTY(()) ttypes_filter {
|
tree t;
|
tree t;
|
int filter;
|
int filter;
|
};
|
};
|
|
|
/* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA
|
/* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA
|
(a tree) for a @TTypes type node we are thinking about adding. */
|
(a tree) for a @TTypes type node we are thinking about adding. */
|
|
|
static int
|
static int
|
ttypes_filter_eq (const void *pentry, const void *pdata)
|
ttypes_filter_eq (const void *pentry, const void *pdata)
|
{
|
{
|
const struct ttypes_filter *const entry
|
const struct ttypes_filter *const entry
|
= (const struct ttypes_filter *) pentry;
|
= (const struct ttypes_filter *) pentry;
|
const_tree const data = (const_tree) pdata;
|
const_tree const data = (const_tree) pdata;
|
|
|
return entry->t == data;
|
return entry->t == data;
|
}
|
}
|
|
|
static hashval_t
|
static hashval_t
|
ttypes_filter_hash (const void *pentry)
|
ttypes_filter_hash (const void *pentry)
|
{
|
{
|
const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry;
|
const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry;
|
return TREE_HASH (entry->t);
|
return TREE_HASH (entry->t);
|
}
|
}
|
|
|
/* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes
|
/* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes
|
exception specification list we are thinking about adding. */
|
exception specification list we are thinking about adding. */
|
/* ??? Currently we use the type lists in the order given. Someone
|
/* ??? Currently we use the type lists in the order given. Someone
|
should put these in some canonical order. */
|
should put these in some canonical order. */
|
|
|
static int
|
static int
|
ehspec_filter_eq (const void *pentry, const void *pdata)
|
ehspec_filter_eq (const void *pentry, const void *pdata)
|
{
|
{
|
const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry;
|
const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry;
|
const struct ttypes_filter *data = (const struct ttypes_filter *) pdata;
|
const struct ttypes_filter *data = (const struct ttypes_filter *) pdata;
|
|
|
return type_list_equal (entry->t, data->t);
|
return type_list_equal (entry->t, data->t);
|
}
|
}
|
|
|
/* Hash function for exception specification lists. */
|
/* Hash function for exception specification lists. */
|
|
|
static hashval_t
|
static hashval_t
|
ehspec_filter_hash (const void *pentry)
|
ehspec_filter_hash (const void *pentry)
|
{
|
{
|
const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry;
|
const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry;
|
hashval_t h = 0;
|
hashval_t h = 0;
|
tree list;
|
tree list;
|
|
|
for (list = entry->t; list ; list = TREE_CHAIN (list))
|
for (list = entry->t; list ; list = TREE_CHAIN (list))
|
h = (h << 5) + (h >> 27) + TREE_HASH (TREE_VALUE (list));
|
h = (h << 5) + (h >> 27) + TREE_HASH (TREE_VALUE (list));
|
return h;
|
return h;
|
}
|
}
|
|
|
/* Add TYPE (which may be NULL) to cfun->eh->ttype_data, using TYPES_HASH
|
/* Add TYPE (which may be NULL) to cfun->eh->ttype_data, using TYPES_HASH
|
to speed up the search. Return the filter value to be used. */
|
to speed up the search. Return the filter value to be used. */
|
|
|
static int
|
static int
|
add_ttypes_entry (htab_t ttypes_hash, tree type)
|
add_ttypes_entry (htab_t ttypes_hash, tree type)
|
{
|
{
|
struct ttypes_filter **slot, *n;
|
struct ttypes_filter **slot, *n;
|
|
|
slot = (struct ttypes_filter **)
|
slot = (struct ttypes_filter **)
|
htab_find_slot_with_hash (ttypes_hash, type, TREE_HASH (type), INSERT);
|
htab_find_slot_with_hash (ttypes_hash, type, TREE_HASH (type), INSERT);
|
|
|
if ((n = *slot) == NULL)
|
if ((n = *slot) == NULL)
|
{
|
{
|
/* Filter value is a 1 based table index. */
|
/* Filter value is a 1 based table index. */
|
|
|
n = XNEW (struct ttypes_filter);
|
n = XNEW (struct ttypes_filter);
|
n->t = type;
|
n->t = type;
|
n->filter = VEC_length (tree, cfun->eh->ttype_data) + 1;
|
n->filter = VEC_length (tree, cfun->eh->ttype_data) + 1;
|
*slot = n;
|
*slot = n;
|
|
|
VEC_safe_push (tree, gc, cfun->eh->ttype_data, type);
|
VEC_safe_push (tree, gc, cfun->eh->ttype_data, type);
|
}
|
}
|
|
|
return n->filter;
|
return n->filter;
|
}
|
}
|
|
|
/* Add LIST to cfun->eh->ehspec_data, using EHSPEC_HASH and TYPES_HASH
|
/* Add LIST to cfun->eh->ehspec_data, using EHSPEC_HASH and TYPES_HASH
|
to speed up the search. Return the filter value to be used. */
|
to speed up the search. Return the filter value to be used. */
|
|
|
static int
|
static int
|
add_ehspec_entry (htab_t ehspec_hash, htab_t ttypes_hash, tree list)
|
add_ehspec_entry (htab_t ehspec_hash, htab_t ttypes_hash, tree list)
|
{
|
{
|
struct ttypes_filter **slot, *n;
|
struct ttypes_filter **slot, *n;
|
struct ttypes_filter dummy;
|
struct ttypes_filter dummy;
|
|
|
dummy.t = list;
|
dummy.t = list;
|
slot = (struct ttypes_filter **)
|
slot = (struct ttypes_filter **)
|
htab_find_slot (ehspec_hash, &dummy, INSERT);
|
htab_find_slot (ehspec_hash, &dummy, INSERT);
|
|
|
if ((n = *slot) == NULL)
|
if ((n = *slot) == NULL)
|
{
|
{
|
int len;
|
int len;
|
|
|
if (targetm.arm_eabi_unwinder)
|
if (targetm.arm_eabi_unwinder)
|
len = VEC_length (tree, cfun->eh->ehspec_data.arm_eabi);
|
len = VEC_length (tree, cfun->eh->ehspec_data.arm_eabi);
|
else
|
else
|
len = VEC_length (uchar, cfun->eh->ehspec_data.other);
|
len = VEC_length (uchar, cfun->eh->ehspec_data.other);
|
|
|
/* Filter value is a -1 based byte index into a uleb128 buffer. */
|
/* Filter value is a -1 based byte index into a uleb128 buffer. */
|
|
|
n = XNEW (struct ttypes_filter);
|
n = XNEW (struct ttypes_filter);
|
n->t = list;
|
n->t = list;
|
n->filter = -(len + 1);
|
n->filter = -(len + 1);
|
*slot = n;
|
*slot = n;
|
|
|
/* Generate a 0 terminated list of filter values. */
|
/* Generate a 0 terminated list of filter values. */
|
for (; list ; list = TREE_CHAIN (list))
|
for (; list ; list = TREE_CHAIN (list))
|
{
|
{
|
if (targetm.arm_eabi_unwinder)
|
if (targetm.arm_eabi_unwinder)
|
VEC_safe_push (tree, gc, cfun->eh->ehspec_data.arm_eabi,
|
VEC_safe_push (tree, gc, cfun->eh->ehspec_data.arm_eabi,
|
TREE_VALUE (list));
|
TREE_VALUE (list));
|
else
|
else
|
{
|
{
|
/* Look up each type in the list and encode its filter
|
/* Look up each type in the list and encode its filter
|
value as a uleb128. */
|
value as a uleb128. */
|
push_uleb128 (&cfun->eh->ehspec_data.other,
|
push_uleb128 (&cfun->eh->ehspec_data.other,
|
add_ttypes_entry (ttypes_hash, TREE_VALUE (list)));
|
add_ttypes_entry (ttypes_hash, TREE_VALUE (list)));
|
}
|
}
|
}
|
}
|
if (targetm.arm_eabi_unwinder)
|
if (targetm.arm_eabi_unwinder)
|
VEC_safe_push (tree, gc, cfun->eh->ehspec_data.arm_eabi, NULL_TREE);
|
VEC_safe_push (tree, gc, cfun->eh->ehspec_data.arm_eabi, NULL_TREE);
|
else
|
else
|
VEC_safe_push (uchar, gc, cfun->eh->ehspec_data.other, 0);
|
VEC_safe_push (uchar, gc, cfun->eh->ehspec_data.other, 0);
|
}
|
}
|
|
|
return n->filter;
|
return n->filter;
|
}
|
}
|
|
|
/* Generate the action filter values to be used for CATCH and
|
/* Generate the action filter values to be used for CATCH and
|
ALLOWED_EXCEPTIONS regions. When using dwarf2 exception regions,
|
ALLOWED_EXCEPTIONS regions. When using dwarf2 exception regions,
|
we use lots of landing pads, and so every type or list can share
|
we use lots of landing pads, and so every type or list can share
|
the same filter value, which saves table space. */
|
the same filter value, which saves table space. */
|
|
|
void
|
void
|
assign_filter_values (void)
|
assign_filter_values (void)
|
{
|
{
|
int i;
|
int i;
|
htab_t ttypes, ehspec;
|
htab_t ttypes, ehspec;
|
eh_region r;
|
eh_region r;
|
eh_catch c;
|
eh_catch c;
|
|
|
cfun->eh->ttype_data = VEC_alloc (tree, gc, 16);
|
cfun->eh->ttype_data = VEC_alloc (tree, gc, 16);
|
if (targetm.arm_eabi_unwinder)
|
if (targetm.arm_eabi_unwinder)
|
cfun->eh->ehspec_data.arm_eabi = VEC_alloc (tree, gc, 64);
|
cfun->eh->ehspec_data.arm_eabi = VEC_alloc (tree, gc, 64);
|
else
|
else
|
cfun->eh->ehspec_data.other = VEC_alloc (uchar, gc, 64);
|
cfun->eh->ehspec_data.other = VEC_alloc (uchar, gc, 64);
|
|
|
ttypes = htab_create (31, ttypes_filter_hash, ttypes_filter_eq, free);
|
ttypes = htab_create (31, ttypes_filter_hash, ttypes_filter_eq, free);
|
ehspec = htab_create (31, ehspec_filter_hash, ehspec_filter_eq, free);
|
ehspec = htab_create (31, ehspec_filter_hash, ehspec_filter_eq, free);
|
|
|
for (i = 1; VEC_iterate (eh_region, cfun->eh->region_array, i, r); ++i)
|
for (i = 1; VEC_iterate (eh_region, cfun->eh->region_array, i, r); ++i)
|
{
|
{
|
if (r == NULL)
|
if (r == NULL)
|
continue;
|
continue;
|
|
|
switch (r->type)
|
switch (r->type)
|
{
|
{
|
case ERT_TRY:
|
case ERT_TRY:
|
for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
|
for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
|
{
|
{
|
/* Whatever type_list is (NULL or true list), we build a list
|
/* Whatever type_list is (NULL or true list), we build a list
|
of filters for the region. */
|
of filters for the region. */
|
c->filter_list = NULL_TREE;
|
c->filter_list = NULL_TREE;
|
|
|
if (c->type_list != NULL)
|
if (c->type_list != NULL)
|
{
|
{
|
/* Get a filter value for each of the types caught and store
|
/* Get a filter value for each of the types caught and store
|
them in the region's dedicated list. */
|
them in the region's dedicated list. */
|
tree tp_node = c->type_list;
|
tree tp_node = c->type_list;
|
|
|
for ( ; tp_node; tp_node = TREE_CHAIN (tp_node))
|
for ( ; tp_node; tp_node = TREE_CHAIN (tp_node))
|
{
|
{
|
int flt = add_ttypes_entry (ttypes, TREE_VALUE (tp_node));
|
int flt = add_ttypes_entry (ttypes, TREE_VALUE (tp_node));
|
tree flt_node = build_int_cst (NULL_TREE, flt);
|
tree flt_node = build_int_cst (NULL_TREE, flt);
|
|
|
c->filter_list
|
c->filter_list
|
= tree_cons (NULL_TREE, flt_node, c->filter_list);
|
= tree_cons (NULL_TREE, flt_node, c->filter_list);
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Get a filter value for the NULL list also since it
|
/* Get a filter value for the NULL list also since it
|
will need an action record anyway. */
|
will need an action record anyway. */
|
int flt = add_ttypes_entry (ttypes, NULL);
|
int flt = add_ttypes_entry (ttypes, NULL);
|
tree flt_node = build_int_cst (NULL_TREE, flt);
|
tree flt_node = build_int_cst (NULL_TREE, flt);
|
|
|
c->filter_list
|
c->filter_list
|
= tree_cons (NULL_TREE, flt_node, NULL);
|
= tree_cons (NULL_TREE, flt_node, NULL);
|
}
|
}
|
}
|
}
|
break;
|
break;
|
|
|
case ERT_ALLOWED_EXCEPTIONS:
|
case ERT_ALLOWED_EXCEPTIONS:
|
r->u.allowed.filter
|
r->u.allowed.filter
|
= add_ehspec_entry (ehspec, ttypes, r->u.allowed.type_list);
|
= add_ehspec_entry (ehspec, ttypes, r->u.allowed.type_list);
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
htab_delete (ttypes);
|
htab_delete (ttypes);
|
htab_delete (ehspec);
|
htab_delete (ehspec);
|
}
|
}
|
|
|
/* Emit SEQ into basic block just before INSN (that is assumed to be
|
/* Emit SEQ into basic block just before INSN (that is assumed to be
|
first instruction of some existing BB and return the newly
|
first instruction of some existing BB and return the newly
|
produced block. */
|
produced block. */
|
static basic_block
|
static basic_block
|
emit_to_new_bb_before (rtx seq, rtx insn)
|
emit_to_new_bb_before (rtx seq, rtx insn)
|
{
|
{
|
rtx last;
|
rtx last;
|
basic_block bb;
|
basic_block bb;
|
edge e;
|
edge e;
|
edge_iterator ei;
|
edge_iterator ei;
|
|
|
/* If there happens to be a fallthru edge (possibly created by cleanup_cfg
|
/* If there happens to be a fallthru edge (possibly created by cleanup_cfg
|
call), we don't want it to go into newly created landing pad or other EH
|
call), we don't want it to go into newly created landing pad or other EH
|
construct. */
|
construct. */
|
for (ei = ei_start (BLOCK_FOR_INSN (insn)->preds); (e = ei_safe_edge (ei)); )
|
for (ei = ei_start (BLOCK_FOR_INSN (insn)->preds); (e = ei_safe_edge (ei)); )
|
if (e->flags & EDGE_FALLTHRU)
|
if (e->flags & EDGE_FALLTHRU)
|
force_nonfallthru (e);
|
force_nonfallthru (e);
|
else
|
else
|
ei_next (&ei);
|
ei_next (&ei);
|
last = emit_insn_before (seq, insn);
|
last = emit_insn_before (seq, insn);
|
if (BARRIER_P (last))
|
if (BARRIER_P (last))
|
last = PREV_INSN (last);
|
last = PREV_INSN (last);
|
bb = create_basic_block (seq, last, BLOCK_FOR_INSN (insn)->prev_bb);
|
bb = create_basic_block (seq, last, BLOCK_FOR_INSN (insn)->prev_bb);
|
update_bb_for_insn (bb);
|
update_bb_for_insn (bb);
|
bb->flags |= BB_SUPERBLOCK;
|
bb->flags |= BB_SUPERBLOCK;
|
return bb;
|
return bb;
|
}
|
}
|
|
|
/* Expand the extra code needed at landing pads for dwarf2 unwinding. */
|
/* Expand the extra code needed at landing pads for dwarf2 unwinding. */
|
|
|
static void
|
static void
|
dw2_build_landing_pads (void)
|
dw2_build_landing_pads (void)
|
{
|
{
|
int i;
|
int i;
|
eh_landing_pad lp;
|
eh_landing_pad lp;
|
|
|
for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i)
|
for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i)
|
{
|
{
|
eh_region region;
|
eh_region region;
|
basic_block bb;
|
basic_block bb;
|
rtx seq;
|
rtx seq;
|
edge e;
|
edge e;
|
|
|
if (lp == NULL || lp->post_landing_pad == NULL)
|
if (lp == NULL || lp->post_landing_pad == NULL)
|
continue;
|
continue;
|
|
|
start_sequence ();
|
start_sequence ();
|
|
|
lp->landing_pad = gen_label_rtx ();
|
lp->landing_pad = gen_label_rtx ();
|
emit_label (lp->landing_pad);
|
emit_label (lp->landing_pad);
|
LABEL_PRESERVE_P (lp->landing_pad) = 1;
|
LABEL_PRESERVE_P (lp->landing_pad) = 1;
|
|
|
#ifdef HAVE_exception_receiver
|
#ifdef HAVE_exception_receiver
|
if (HAVE_exception_receiver)
|
if (HAVE_exception_receiver)
|
emit_insn (gen_exception_receiver ());
|
emit_insn (gen_exception_receiver ());
|
else
|
else
|
#endif
|
#endif
|
#ifdef HAVE_nonlocal_goto_receiver
|
#ifdef HAVE_nonlocal_goto_receiver
|
if (HAVE_nonlocal_goto_receiver)
|
if (HAVE_nonlocal_goto_receiver)
|
emit_insn (gen_nonlocal_goto_receiver ());
|
emit_insn (gen_nonlocal_goto_receiver ());
|
else
|
else
|
#endif
|
#endif
|
{ /* Nothing */ }
|
{ /* Nothing */ }
|
|
|
region = lp->region;
|
region = lp->region;
|
if (region->exc_ptr_reg)
|
if (region->exc_ptr_reg)
|
emit_move_insn (region->exc_ptr_reg,
|
emit_move_insn (region->exc_ptr_reg,
|
gen_rtx_REG (ptr_mode, EH_RETURN_DATA_REGNO (0)));
|
gen_rtx_REG (ptr_mode, EH_RETURN_DATA_REGNO (0)));
|
if (region->filter_reg)
|
if (region->filter_reg)
|
emit_move_insn (region->filter_reg,
|
emit_move_insn (region->filter_reg,
|
gen_rtx_REG (targetm.eh_return_filter_mode (),
|
gen_rtx_REG (targetm.eh_return_filter_mode (),
|
EH_RETURN_DATA_REGNO (1)));
|
EH_RETURN_DATA_REGNO (1)));
|
|
|
seq = get_insns ();
|
seq = get_insns ();
|
end_sequence ();
|
end_sequence ();
|
|
|
bb = emit_to_new_bb_before (seq, label_rtx (lp->post_landing_pad));
|
bb = emit_to_new_bb_before (seq, label_rtx (lp->post_landing_pad));
|
e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
|
e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
|
e->count = bb->count;
|
e->count = bb->count;
|
e->probability = REG_BR_PROB_BASE;
|
e->probability = REG_BR_PROB_BASE;
|
}
|
}
|
}
|
}
|
|
|
|
|
static VEC (int, heap) *sjlj_lp_call_site_index;
|
static VEC (int, heap) *sjlj_lp_call_site_index;
|
|
|
/* Process all active landing pads. Assign each one a compact dispatch
|
/* Process all active landing pads. Assign each one a compact dispatch
|
index, and a call-site index. */
|
index, and a call-site index. */
|
|
|
static int
|
static int
|
sjlj_assign_call_site_values (void)
|
sjlj_assign_call_site_values (void)
|
{
|
{
|
htab_t ar_hash;
|
htab_t ar_hash;
|
int i, disp_index;
|
int i, disp_index;
|
eh_landing_pad lp;
|
eh_landing_pad lp;
|
|
|
crtl->eh.action_record_data = VEC_alloc (uchar, gc, 64);
|
crtl->eh.action_record_data = VEC_alloc (uchar, gc, 64);
|
ar_hash = htab_create (31, action_record_hash, action_record_eq, free);
|
ar_hash = htab_create (31, action_record_hash, action_record_eq, free);
|
|
|
disp_index = 0;
|
disp_index = 0;
|
call_site_base = 1;
|
call_site_base = 1;
|
for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i)
|
for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i)
|
if (lp && lp->post_landing_pad)
|
if (lp && lp->post_landing_pad)
|
{
|
{
|
int action, call_site;
|
int action, call_site;
|
|
|
/* First: build the action table. */
|
/* First: build the action table. */
|
action = collect_one_action_chain (ar_hash, lp->region);
|
action = collect_one_action_chain (ar_hash, lp->region);
|
if (action != -1)
|
if (action != -1)
|
crtl->uses_eh_lsda = 1;
|
crtl->uses_eh_lsda = 1;
|
|
|
/* Next: assign call-site values. If dwarf2 terms, this would be
|
/* Next: assign call-site values. If dwarf2 terms, this would be
|
the region number assigned by convert_to_eh_region_ranges, but
|
the region number assigned by convert_to_eh_region_ranges, but
|
handles no-action and must-not-throw differently. */
|
handles no-action and must-not-throw differently. */
|
/* Map must-not-throw to otherwise unused call-site index 0. */
|
/* Map must-not-throw to otherwise unused call-site index 0. */
|
if (action == -2)
|
if (action == -2)
|
call_site = 0;
|
call_site = 0;
|
/* Map no-action to otherwise unused call-site index -1. */
|
/* Map no-action to otherwise unused call-site index -1. */
|
else if (action == -1)
|
else if (action == -1)
|
call_site = -1;
|
call_site = -1;
|
/* Otherwise, look it up in the table. */
|
/* Otherwise, look it up in the table. */
|
else
|
else
|
call_site = add_call_site (GEN_INT (disp_index), action, 0);
|
call_site = add_call_site (GEN_INT (disp_index), action, 0);
|
VEC_replace (int, sjlj_lp_call_site_index, i, call_site);
|
VEC_replace (int, sjlj_lp_call_site_index, i, call_site);
|
|
|
disp_index++;
|
disp_index++;
|
}
|
}
|
|
|
htab_delete (ar_hash);
|
htab_delete (ar_hash);
|
|
|
return disp_index;
|
return disp_index;
|
}
|
}
|
|
|
/* Emit code to record the current call-site index before every
|
/* Emit code to record the current call-site index before every
|
insn that can throw. */
|
insn that can throw. */
|
|
|
static void
|
static void
|
sjlj_mark_call_sites (void)
|
sjlj_mark_call_sites (void)
|
{
|
{
|
int last_call_site = -2;
|
int last_call_site = -2;
|
rtx insn, mem;
|
rtx insn, mem;
|
|
|
for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
|
for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
|
{
|
{
|
eh_landing_pad lp;
|
eh_landing_pad lp;
|
eh_region r;
|
eh_region r;
|
bool nothrow;
|
bool nothrow;
|
int this_call_site;
|
int this_call_site;
|
rtx before, p;
|
rtx before, p;
|
|
|
/* Reset value tracking at extended basic block boundaries. */
|
/* Reset value tracking at extended basic block boundaries. */
|
if (LABEL_P (insn))
|
if (LABEL_P (insn))
|
last_call_site = -2;
|
last_call_site = -2;
|
|
|
if (! INSN_P (insn))
|
if (! INSN_P (insn))
|
continue;
|
continue;
|
|
|
nothrow = get_eh_region_and_lp_from_rtx (insn, &r, &lp);
|
nothrow = get_eh_region_and_lp_from_rtx (insn, &r, &lp);
|
if (nothrow)
|
if (nothrow)
|
continue;
|
continue;
|
if (lp)
|
if (lp)
|
this_call_site = VEC_index (int, sjlj_lp_call_site_index, lp->index);
|
this_call_site = VEC_index (int, sjlj_lp_call_site_index, lp->index);
|
else if (r == NULL)
|
else if (r == NULL)
|
{
|
{
|
/* Calls (and trapping insns) without notes are outside any
|
/* Calls (and trapping insns) without notes are outside any
|
exception handling region in this function. Mark them as
|
exception handling region in this function. Mark them as
|
no action. */
|
no action. */
|
this_call_site = -1;
|
this_call_site = -1;
|
}
|
}
|
else
|
else
|
{
|
{
|
gcc_assert (r->type == ERT_MUST_NOT_THROW);
|
gcc_assert (r->type == ERT_MUST_NOT_THROW);
|
this_call_site = 0;
|
this_call_site = 0;
|
}
|
}
|
|
|
if (this_call_site == last_call_site)
|
if (this_call_site == last_call_site)
|
continue;
|
continue;
|
|
|
/* Don't separate a call from it's argument loads. */
|
/* Don't separate a call from it's argument loads. */
|
before = insn;
|
before = insn;
|
if (CALL_P (insn))
|
if (CALL_P (insn))
|
before = find_first_parameter_load (insn, NULL_RTX);
|
before = find_first_parameter_load (insn, NULL_RTX);
|
|
|
start_sequence ();
|
start_sequence ();
|
mem = adjust_address (crtl->eh.sjlj_fc, TYPE_MODE (integer_type_node),
|
mem = adjust_address (crtl->eh.sjlj_fc, TYPE_MODE (integer_type_node),
|
sjlj_fc_call_site_ofs);
|
sjlj_fc_call_site_ofs);
|
emit_move_insn (mem, GEN_INT (this_call_site));
|
emit_move_insn (mem, GEN_INT (this_call_site));
|
p = get_insns ();
|
p = get_insns ();
|
end_sequence ();
|
end_sequence ();
|
|
|
emit_insn_before (p, before);
|
emit_insn_before (p, before);
|
last_call_site = this_call_site;
|
last_call_site = this_call_site;
|
}
|
}
|
}
|
}
|
|
|
/* Construct the SjLj_Function_Context. */
|
/* Construct the SjLj_Function_Context. */
|
|
|
static void
|
static void
|
sjlj_emit_function_enter (rtx dispatch_label)
|
sjlj_emit_function_enter (rtx dispatch_label)
|
{
|
{
|
rtx fn_begin, fc, mem, seq;
|
rtx fn_begin, fc, mem, seq;
|
bool fn_begin_outside_block;
|
bool fn_begin_outside_block;
|
rtx personality = get_personality_function (current_function_decl);
|
rtx personality = get_personality_function (current_function_decl);
|
|
|
fc = crtl->eh.sjlj_fc;
|
fc = crtl->eh.sjlj_fc;
|
|
|
start_sequence ();
|
start_sequence ();
|
|
|
/* We're storing this libcall's address into memory instead of
|
/* We're storing this libcall's address into memory instead of
|
calling it directly. Thus, we must call assemble_external_libcall
|
calling it directly. Thus, we must call assemble_external_libcall
|
here, as we can not depend on emit_library_call to do it for us. */
|
here, as we can not depend on emit_library_call to do it for us. */
|
assemble_external_libcall (personality);
|
assemble_external_libcall (personality);
|
mem = adjust_address (fc, Pmode, sjlj_fc_personality_ofs);
|
mem = adjust_address (fc, Pmode, sjlj_fc_personality_ofs);
|
emit_move_insn (mem, personality);
|
emit_move_insn (mem, personality);
|
|
|
mem = adjust_address (fc, Pmode, sjlj_fc_lsda_ofs);
|
mem = adjust_address (fc, Pmode, sjlj_fc_lsda_ofs);
|
if (crtl->uses_eh_lsda)
|
if (crtl->uses_eh_lsda)
|
{
|
{
|
char buf[20];
|
char buf[20];
|
rtx sym;
|
rtx sym;
|
|
|
ASM_GENERATE_INTERNAL_LABEL (buf, "LLSDA", current_function_funcdef_no);
|
ASM_GENERATE_INTERNAL_LABEL (buf, "LLSDA", current_function_funcdef_no);
|
sym = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
|
sym = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
|
SYMBOL_REF_FLAGS (sym) = SYMBOL_FLAG_LOCAL;
|
SYMBOL_REF_FLAGS (sym) = SYMBOL_FLAG_LOCAL;
|
emit_move_insn (mem, sym);
|
emit_move_insn (mem, sym);
|
}
|
}
|
else
|
else
|
emit_move_insn (mem, const0_rtx);
|
emit_move_insn (mem, const0_rtx);
|
|
|
#ifdef DONT_USE_BUILTIN_SETJMP
|
#ifdef DONT_USE_BUILTIN_SETJMP
|
{
|
{
|
rtx x, last;
|
rtx x, last;
|
x = emit_library_call_value (setjmp_libfunc, NULL_RTX, LCT_RETURNS_TWICE,
|
x = emit_library_call_value (setjmp_libfunc, NULL_RTX, LCT_RETURNS_TWICE,
|
TYPE_MODE (integer_type_node), 1,
|
TYPE_MODE (integer_type_node), 1,
|
plus_constant (XEXP (fc, 0),
|
plus_constant (XEXP (fc, 0),
|
sjlj_fc_jbuf_ofs), Pmode);
|
sjlj_fc_jbuf_ofs), Pmode);
|
|
|
emit_cmp_and_jump_insns (x, const0_rtx, NE, 0,
|
emit_cmp_and_jump_insns (x, const0_rtx, NE, 0,
|
TYPE_MODE (integer_type_node), 0, dispatch_label);
|
TYPE_MODE (integer_type_node), 0, dispatch_label);
|
last = get_last_insn ();
|
last = get_last_insn ();
|
if (JUMP_P (last) && any_condjump_p (last))
|
if (JUMP_P (last) && any_condjump_p (last))
|
{
|
{
|
gcc_assert (!find_reg_note (last, REG_BR_PROB, 0));
|
gcc_assert (!find_reg_note (last, REG_BR_PROB, 0));
|
add_reg_note (last, REG_BR_PROB, GEN_INT (REG_BR_PROB_BASE / 100));
|
add_reg_note (last, REG_BR_PROB, GEN_INT (REG_BR_PROB_BASE / 100));
|
}
|
}
|
}
|
}
|
#else
|
#else
|
expand_builtin_setjmp_setup (plus_constant (XEXP (fc, 0), sjlj_fc_jbuf_ofs),
|
expand_builtin_setjmp_setup (plus_constant (XEXP (fc, 0), sjlj_fc_jbuf_ofs),
|
dispatch_label);
|
dispatch_label);
|
#endif
|
#endif
|
|
|
emit_library_call (unwind_sjlj_register_libfunc, LCT_NORMAL, VOIDmode,
|
emit_library_call (unwind_sjlj_register_libfunc, LCT_NORMAL, VOIDmode,
|
1, XEXP (fc, 0), Pmode);
|
1, XEXP (fc, 0), Pmode);
|
|
|
seq = get_insns ();
|
seq = get_insns ();
|
end_sequence ();
|
end_sequence ();
|
|
|
/* ??? Instead of doing this at the beginning of the function,
|
/* ??? Instead of doing this at the beginning of the function,
|
do this in a block that is at loop level 0 and dominates all
|
do this in a block that is at loop level 0 and dominates all
|
can_throw_internal instructions. */
|
can_throw_internal instructions. */
|
|
|
fn_begin_outside_block = true;
|
fn_begin_outside_block = true;
|
for (fn_begin = get_insns (); ; fn_begin = NEXT_INSN (fn_begin))
|
for (fn_begin = get_insns (); ; fn_begin = NEXT_INSN (fn_begin))
|
if (NOTE_P (fn_begin))
|
if (NOTE_P (fn_begin))
|
{
|
{
|
if (NOTE_KIND (fn_begin) == NOTE_INSN_FUNCTION_BEG)
|
if (NOTE_KIND (fn_begin) == NOTE_INSN_FUNCTION_BEG)
|
break;
|
break;
|
else if (NOTE_INSN_BASIC_BLOCK_P (fn_begin))
|
else if (NOTE_INSN_BASIC_BLOCK_P (fn_begin))
|
fn_begin_outside_block = false;
|
fn_begin_outside_block = false;
|
}
|
}
|
|
|
if (fn_begin_outside_block)
|
if (fn_begin_outside_block)
|
insert_insn_on_edge (seq, single_succ_edge (ENTRY_BLOCK_PTR));
|
insert_insn_on_edge (seq, single_succ_edge (ENTRY_BLOCK_PTR));
|
else
|
else
|
emit_insn_after (seq, fn_begin);
|
emit_insn_after (seq, fn_begin);
|
}
|
}
|
|
|
/* Call back from expand_function_end to know where we should put
|
/* Call back from expand_function_end to know where we should put
|
the call to unwind_sjlj_unregister_libfunc if needed. */
|
the call to unwind_sjlj_unregister_libfunc if needed. */
|
|
|
void
|
void
|
sjlj_emit_function_exit_after (rtx after)
|
sjlj_emit_function_exit_after (rtx after)
|
{
|
{
|
crtl->eh.sjlj_exit_after = after;
|
crtl->eh.sjlj_exit_after = after;
|
}
|
}
|
|
|
static void
|
static void
|
sjlj_emit_function_exit (void)
|
sjlj_emit_function_exit (void)
|
{
|
{
|
rtx seq, insn;
|
rtx seq, insn;
|
|
|
start_sequence ();
|
start_sequence ();
|
|
|
emit_library_call (unwind_sjlj_unregister_libfunc, LCT_NORMAL, VOIDmode,
|
emit_library_call (unwind_sjlj_unregister_libfunc, LCT_NORMAL, VOIDmode,
|
1, XEXP (crtl->eh.sjlj_fc, 0), Pmode);
|
1, XEXP (crtl->eh.sjlj_fc, 0), Pmode);
|
|
|
seq = get_insns ();
|
seq = get_insns ();
|
end_sequence ();
|
end_sequence ();
|
|
|
/* ??? Really this can be done in any block at loop level 0 that
|
/* ??? Really this can be done in any block at loop level 0 that
|
post-dominates all can_throw_internal instructions. This is
|
post-dominates all can_throw_internal instructions. This is
|
the last possible moment. */
|
the last possible moment. */
|
|
|
insn = crtl->eh.sjlj_exit_after;
|
insn = crtl->eh.sjlj_exit_after;
|
if (LABEL_P (insn))
|
if (LABEL_P (insn))
|
insn = NEXT_INSN (insn);
|
insn = NEXT_INSN (insn);
|
|
|
emit_insn_after (seq, insn);
|
emit_insn_after (seq, insn);
|
}
|
}
|
|
|
static void
|
static void
|
sjlj_emit_dispatch_table (rtx dispatch_label, int num_dispatch)
|
sjlj_emit_dispatch_table (rtx dispatch_label, int num_dispatch)
|
{
|
{
|
enum machine_mode unwind_word_mode = targetm.unwind_word_mode ();
|
enum machine_mode unwind_word_mode = targetm.unwind_word_mode ();
|
enum machine_mode filter_mode = targetm.eh_return_filter_mode ();
|
enum machine_mode filter_mode = targetm.eh_return_filter_mode ();
|
eh_landing_pad lp;
|
eh_landing_pad lp;
|
rtx mem, seq, fc, before, exc_ptr_reg, filter_reg;
|
rtx mem, seq, fc, before, exc_ptr_reg, filter_reg;
|
rtx first_reachable_label;
|
rtx first_reachable_label;
|
basic_block bb;
|
basic_block bb;
|
eh_region r;
|
eh_region r;
|
edge e;
|
edge e;
|
int i, disp_index;
|
int i, disp_index;
|
gimple switch_stmt;
|
gimple switch_stmt;
|
|
|
fc = crtl->eh.sjlj_fc;
|
fc = crtl->eh.sjlj_fc;
|
|
|
start_sequence ();
|
start_sequence ();
|
|
|
emit_label (dispatch_label);
|
emit_label (dispatch_label);
|
|
|
#ifndef DONT_USE_BUILTIN_SETJMP
|
#ifndef DONT_USE_BUILTIN_SETJMP
|
expand_builtin_setjmp_receiver (dispatch_label);
|
expand_builtin_setjmp_receiver (dispatch_label);
|
|
|
/* The caller of expand_builtin_setjmp_receiver is responsible for
|
/* The caller of expand_builtin_setjmp_receiver is responsible for
|
making sure that the label doesn't vanish. The only other caller
|
making sure that the label doesn't vanish. The only other caller
|
is the expander for __builtin_setjmp_receiver, which places this
|
is the expander for __builtin_setjmp_receiver, which places this
|
label on the nonlocal_goto_label list. Since we're modeling these
|
label on the nonlocal_goto_label list. Since we're modeling these
|
CFG edges more exactly, we can use the forced_labels list instead. */
|
CFG edges more exactly, we can use the forced_labels list instead. */
|
LABEL_PRESERVE_P (dispatch_label) = 1;
|
LABEL_PRESERVE_P (dispatch_label) = 1;
|
forced_labels
|
forced_labels
|
= gen_rtx_EXPR_LIST (VOIDmode, dispatch_label, forced_labels);
|
= gen_rtx_EXPR_LIST (VOIDmode, dispatch_label, forced_labels);
|
#endif
|
#endif
|
|
|
/* Load up exc_ptr and filter values from the function context. */
|
/* Load up exc_ptr and filter values from the function context. */
|
mem = adjust_address (fc, unwind_word_mode, sjlj_fc_data_ofs);
|
mem = adjust_address (fc, unwind_word_mode, sjlj_fc_data_ofs);
|
if (unwind_word_mode != ptr_mode)
|
if (unwind_word_mode != ptr_mode)
|
{
|
{
|
#ifdef POINTERS_EXTEND_UNSIGNED
|
#ifdef POINTERS_EXTEND_UNSIGNED
|
mem = convert_memory_address (ptr_mode, mem);
|
mem = convert_memory_address (ptr_mode, mem);
|
#else
|
#else
|
mem = convert_to_mode (ptr_mode, mem, 0);
|
mem = convert_to_mode (ptr_mode, mem, 0);
|
#endif
|
#endif
|
}
|
}
|
exc_ptr_reg = force_reg (ptr_mode, mem);
|
exc_ptr_reg = force_reg (ptr_mode, mem);
|
|
|
mem = adjust_address (fc, unwind_word_mode,
|
mem = adjust_address (fc, unwind_word_mode,
|
sjlj_fc_data_ofs + GET_MODE_SIZE (unwind_word_mode));
|
sjlj_fc_data_ofs + GET_MODE_SIZE (unwind_word_mode));
|
if (unwind_word_mode != filter_mode)
|
if (unwind_word_mode != filter_mode)
|
mem = convert_to_mode (filter_mode, mem, 0);
|
mem = convert_to_mode (filter_mode, mem, 0);
|
filter_reg = force_reg (filter_mode, mem);
|
filter_reg = force_reg (filter_mode, mem);
|
|
|
/* Jump to one of the directly reachable regions. */
|
/* Jump to one of the directly reachable regions. */
|
|
|
disp_index = 0;
|
disp_index = 0;
|
first_reachable_label = NULL;
|
first_reachable_label = NULL;
|
|
|
/* If there's exactly one call site in the function, don't bother
|
/* If there's exactly one call site in the function, don't bother
|
generating a switch statement. */
|
generating a switch statement. */
|
switch_stmt = NULL;
|
switch_stmt = NULL;
|
if (num_dispatch > 1)
|
if (num_dispatch > 1)
|
{
|
{
|
tree disp;
|
tree disp;
|
|
|
mem = adjust_address (fc, TYPE_MODE (integer_type_node),
|
mem = adjust_address (fc, TYPE_MODE (integer_type_node),
|
sjlj_fc_call_site_ofs);
|
sjlj_fc_call_site_ofs);
|
disp = make_tree (integer_type_node, mem);
|
disp = make_tree (integer_type_node, mem);
|
|
|
switch_stmt = gimple_build_switch_nlabels (num_dispatch, disp, NULL);
|
switch_stmt = gimple_build_switch_nlabels (num_dispatch, disp, NULL);
|
}
|
}
|
|
|
for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i)
|
for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i)
|
if (lp && lp->post_landing_pad)
|
if (lp && lp->post_landing_pad)
|
{
|
{
|
rtx seq2, label;
|
rtx seq2, label;
|
|
|
start_sequence ();
|
start_sequence ();
|
|
|
lp->landing_pad = dispatch_label;
|
lp->landing_pad = dispatch_label;
|
|
|
if (num_dispatch > 1)
|
if (num_dispatch > 1)
|
{
|
{
|
tree t_label, case_elt;
|
tree t_label, case_elt;
|
|
|
t_label = create_artificial_label (UNKNOWN_LOCATION);
|
t_label = create_artificial_label (UNKNOWN_LOCATION);
|
case_elt = build3 (CASE_LABEL_EXPR, void_type_node,
|
case_elt = build3 (CASE_LABEL_EXPR, void_type_node,
|
build_int_cst (NULL, disp_index),
|
build_int_cst (NULL, disp_index),
|
NULL, t_label);
|
NULL, t_label);
|
gimple_switch_set_label (switch_stmt, disp_index, case_elt);
|
gimple_switch_set_label (switch_stmt, disp_index, case_elt);
|
|
|
label = label_rtx (t_label);
|
label = label_rtx (t_label);
|
}
|
}
|
else
|
else
|
label = gen_label_rtx ();
|
label = gen_label_rtx ();
|
|
|
if (disp_index == 0)
|
if (disp_index == 0)
|
first_reachable_label = label;
|
first_reachable_label = label;
|
emit_label (label);
|
emit_label (label);
|
|
|
r = lp->region;
|
r = lp->region;
|
if (r->exc_ptr_reg)
|
if (r->exc_ptr_reg)
|
emit_move_insn (r->exc_ptr_reg, exc_ptr_reg);
|
emit_move_insn (r->exc_ptr_reg, exc_ptr_reg);
|
if (r->filter_reg)
|
if (r->filter_reg)
|
emit_move_insn (r->filter_reg, filter_reg);
|
emit_move_insn (r->filter_reg, filter_reg);
|
|
|
seq2 = get_insns ();
|
seq2 = get_insns ();
|
end_sequence ();
|
end_sequence ();
|
|
|
before = label_rtx (lp->post_landing_pad);
|
before = label_rtx (lp->post_landing_pad);
|
bb = emit_to_new_bb_before (seq2, before);
|
bb = emit_to_new_bb_before (seq2, before);
|
e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
|
e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
|
e->count = bb->count;
|
e->count = bb->count;
|
e->probability = REG_BR_PROB_BASE;
|
e->probability = REG_BR_PROB_BASE;
|
|
|
disp_index++;
|
disp_index++;
|
}
|
}
|
gcc_assert (disp_index == num_dispatch);
|
gcc_assert (disp_index == num_dispatch);
|
|
|
if (num_dispatch > 1)
|
if (num_dispatch > 1)
|
{
|
{
|
expand_case (switch_stmt);
|
expand_case (switch_stmt);
|
expand_builtin_trap ();
|
expand_builtin_trap ();
|
}
|
}
|
|
|
seq = get_insns ();
|
seq = get_insns ();
|
end_sequence ();
|
end_sequence ();
|
|
|
bb = emit_to_new_bb_before (seq, first_reachable_label);
|
bb = emit_to_new_bb_before (seq, first_reachable_label);
|
if (num_dispatch == 1)
|
if (num_dispatch == 1)
|
{
|
{
|
e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
|
e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
|
e->count = bb->count;
|
e->count = bb->count;
|
e->probability = REG_BR_PROB_BASE;
|
e->probability = REG_BR_PROB_BASE;
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
sjlj_build_landing_pads (void)
|
sjlj_build_landing_pads (void)
|
{
|
{
|
int num_dispatch;
|
int num_dispatch;
|
|
|
num_dispatch = VEC_length (eh_landing_pad, cfun->eh->lp_array);
|
num_dispatch = VEC_length (eh_landing_pad, cfun->eh->lp_array);
|
if (num_dispatch == 0)
|
if (num_dispatch == 0)
|
return;
|
return;
|
VEC_safe_grow (int, heap, sjlj_lp_call_site_index, num_dispatch);
|
VEC_safe_grow (int, heap, sjlj_lp_call_site_index, num_dispatch);
|
|
|
num_dispatch = sjlj_assign_call_site_values ();
|
num_dispatch = sjlj_assign_call_site_values ();
|
if (num_dispatch > 0)
|
if (num_dispatch > 0)
|
{
|
{
|
rtx dispatch_label = gen_label_rtx ();
|
rtx dispatch_label = gen_label_rtx ();
|
int align = STACK_SLOT_ALIGNMENT (sjlj_fc_type_node,
|
int align = STACK_SLOT_ALIGNMENT (sjlj_fc_type_node,
|
TYPE_MODE (sjlj_fc_type_node),
|
TYPE_MODE (sjlj_fc_type_node),
|
TYPE_ALIGN (sjlj_fc_type_node));
|
TYPE_ALIGN (sjlj_fc_type_node));
|
crtl->eh.sjlj_fc
|
crtl->eh.sjlj_fc
|
= assign_stack_local (TYPE_MODE (sjlj_fc_type_node),
|
= assign_stack_local (TYPE_MODE (sjlj_fc_type_node),
|
int_size_in_bytes (sjlj_fc_type_node),
|
int_size_in_bytes (sjlj_fc_type_node),
|
align);
|
align);
|
|
|
sjlj_mark_call_sites ();
|
sjlj_mark_call_sites ();
|
sjlj_emit_function_enter (dispatch_label);
|
sjlj_emit_function_enter (dispatch_label);
|
sjlj_emit_dispatch_table (dispatch_label, num_dispatch);
|
sjlj_emit_dispatch_table (dispatch_label, num_dispatch);
|
sjlj_emit_function_exit ();
|
sjlj_emit_function_exit ();
|
}
|
}
|
|
|
VEC_free (int, heap, sjlj_lp_call_site_index);
|
VEC_free (int, heap, sjlj_lp_call_site_index);
|
}
|
}
|
|
|
/* After initial rtl generation, call back to finish generating
|
/* After initial rtl generation, call back to finish generating
|
exception support code. */
|
exception support code. */
|
|
|
static void
|
static void
|
finish_eh_generation (void)
|
finish_eh_generation (void)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
|
|
/* Construct the landing pads. */
|
/* Construct the landing pads. */
|
if (USING_SJLJ_EXCEPTIONS)
|
if (USING_SJLJ_EXCEPTIONS)
|
sjlj_build_landing_pads ();
|
sjlj_build_landing_pads ();
|
else
|
else
|
dw2_build_landing_pads ();
|
dw2_build_landing_pads ();
|
break_superblocks ();
|
break_superblocks ();
|
|
|
if (USING_SJLJ_EXCEPTIONS
|
if (USING_SJLJ_EXCEPTIONS
|
/* Kludge for Alpha/Tru64 (see alpha_gp_save_rtx). */
|
/* Kludge for Alpha/Tru64 (see alpha_gp_save_rtx). */
|
|| single_succ_edge (ENTRY_BLOCK_PTR)->insns.r)
|
|| single_succ_edge (ENTRY_BLOCK_PTR)->insns.r)
|
commit_edge_insertions ();
|
commit_edge_insertions ();
|
|
|
/* Redirect all EH edges from the post_landing_pad to the landing pad. */
|
/* Redirect all EH edges from the post_landing_pad to the landing pad. */
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
eh_landing_pad lp;
|
eh_landing_pad lp;
|
edge_iterator ei;
|
edge_iterator ei;
|
edge e;
|
edge e;
|
|
|
lp = get_eh_landing_pad_from_rtx (BB_END (bb));
|
lp = get_eh_landing_pad_from_rtx (BB_END (bb));
|
|
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
if (e->flags & EDGE_EH)
|
if (e->flags & EDGE_EH)
|
break;
|
break;
|
|
|
/* We should not have generated any new throwing insns during this
|
/* We should not have generated any new throwing insns during this
|
pass, and we should not have lost any EH edges, so we only need
|
pass, and we should not have lost any EH edges, so we only need
|
to handle two cases here:
|
to handle two cases here:
|
(1) reachable handler and an existing edge to post-landing-pad,
|
(1) reachable handler and an existing edge to post-landing-pad,
|
(2) no reachable handler and no edge. */
|
(2) no reachable handler and no edge. */
|
gcc_assert ((lp != NULL) == (e != NULL));
|
gcc_assert ((lp != NULL) == (e != NULL));
|
if (lp != NULL)
|
if (lp != NULL)
|
{
|
{
|
gcc_assert (BB_HEAD (e->dest) == label_rtx (lp->post_landing_pad));
|
gcc_assert (BB_HEAD (e->dest) == label_rtx (lp->post_landing_pad));
|
|
|
redirect_edge_succ (e, BLOCK_FOR_INSN (lp->landing_pad));
|
redirect_edge_succ (e, BLOCK_FOR_INSN (lp->landing_pad));
|
e->flags |= (CALL_P (BB_END (bb))
|
e->flags |= (CALL_P (BB_END (bb))
|
? EDGE_ABNORMAL | EDGE_ABNORMAL_CALL
|
? EDGE_ABNORMAL | EDGE_ABNORMAL_CALL
|
: EDGE_ABNORMAL);
|
: EDGE_ABNORMAL);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
static bool
|
static bool
|
gate_handle_eh (void)
|
gate_handle_eh (void)
|
{
|
{
|
/* Nothing to do if no regions created. */
|
/* Nothing to do if no regions created. */
|
return cfun->eh->region_tree != NULL;
|
return cfun->eh->region_tree != NULL;
|
}
|
}
|
|
|
/* Complete generation of exception handling code. */
|
/* Complete generation of exception handling code. */
|
static unsigned int
|
static unsigned int
|
rest_of_handle_eh (void)
|
rest_of_handle_eh (void)
|
{
|
{
|
finish_eh_generation ();
|
finish_eh_generation ();
|
cleanup_cfg (CLEANUP_NO_INSN_DEL);
|
cleanup_cfg (CLEANUP_NO_INSN_DEL);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
struct rtl_opt_pass pass_rtl_eh =
|
struct rtl_opt_pass pass_rtl_eh =
|
{
|
{
|
{
|
{
|
RTL_PASS,
|
RTL_PASS,
|
"rtl eh", /* name */
|
"rtl eh", /* name */
|
gate_handle_eh, /* gate */
|
gate_handle_eh, /* gate */
|
rest_of_handle_eh, /* execute */
|
rest_of_handle_eh, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_JUMP, /* tv_id */
|
TV_JUMP, /* tv_id */
|
0, /* properties_required */
|
0, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
TODO_dump_func /* todo_flags_finish */
|
TODO_dump_func /* todo_flags_finish */
|
}
|
}
|
};
|
};
|
|
|
/* This section handles removing dead code for flow. */
|
/* This section handles removing dead code for flow. */
|
|
|
void
|
void
|
remove_eh_landing_pad (eh_landing_pad lp)
|
remove_eh_landing_pad (eh_landing_pad lp)
|
{
|
{
|
eh_landing_pad *pp;
|
eh_landing_pad *pp;
|
|
|
for (pp = &lp->region->landing_pads; *pp != lp; pp = &(*pp)->next_lp)
|
for (pp = &lp->region->landing_pads; *pp != lp; pp = &(*pp)->next_lp)
|
continue;
|
continue;
|
*pp = lp->next_lp;
|
*pp = lp->next_lp;
|
|
|
if (lp->post_landing_pad)
|
if (lp->post_landing_pad)
|
EH_LANDING_PAD_NR (lp->post_landing_pad) = 0;
|
EH_LANDING_PAD_NR (lp->post_landing_pad) = 0;
|
VEC_replace (eh_landing_pad, cfun->eh->lp_array, lp->index, NULL);
|
VEC_replace (eh_landing_pad, cfun->eh->lp_array, lp->index, NULL);
|
}
|
}
|
|
|
/* Splice REGION from the region tree. */
|
/* Splice REGION from the region tree. */
|
|
|
void
|
void
|
remove_eh_handler (eh_region region)
|
remove_eh_handler (eh_region region)
|
{
|
{
|
eh_region *pp, *pp_start, p, outer;
|
eh_region *pp, *pp_start, p, outer;
|
eh_landing_pad lp;
|
eh_landing_pad lp;
|
|
|
for (lp = region->landing_pads; lp ; lp = lp->next_lp)
|
for (lp = region->landing_pads; lp ; lp = lp->next_lp)
|
{
|
{
|
if (lp->post_landing_pad)
|
if (lp->post_landing_pad)
|
EH_LANDING_PAD_NR (lp->post_landing_pad) = 0;
|
EH_LANDING_PAD_NR (lp->post_landing_pad) = 0;
|
VEC_replace (eh_landing_pad, cfun->eh->lp_array, lp->index, NULL);
|
VEC_replace (eh_landing_pad, cfun->eh->lp_array, lp->index, NULL);
|
}
|
}
|
|
|
outer = region->outer;
|
outer = region->outer;
|
if (outer)
|
if (outer)
|
pp_start = &outer->inner;
|
pp_start = &outer->inner;
|
else
|
else
|
pp_start = &cfun->eh->region_tree;
|
pp_start = &cfun->eh->region_tree;
|
for (pp = pp_start, p = *pp; p != region; pp = &p->next_peer, p = *pp)
|
for (pp = pp_start, p = *pp; p != region; pp = &p->next_peer, p = *pp)
|
continue;
|
continue;
|
if (region->inner)
|
if (region->inner)
|
{
|
{
|
*pp = p = region->inner;
|
*pp = p = region->inner;
|
do
|
do
|
{
|
{
|
p->outer = outer;
|
p->outer = outer;
|
pp = &p->next_peer;
|
pp = &p->next_peer;
|
p = *pp;
|
p = *pp;
|
}
|
}
|
while (p);
|
while (p);
|
}
|
}
|
*pp = region->next_peer;
|
*pp = region->next_peer;
|
|
|
VEC_replace (eh_region, cfun->eh->region_array, region->index, NULL);
|
VEC_replace (eh_region, cfun->eh->region_array, region->index, NULL);
|
}
|
}
|
|
|
/* Invokes CALLBACK for every exception handler landing pad label.
|
/* Invokes CALLBACK for every exception handler landing pad label.
|
Only used by reload hackery; should not be used by new code. */
|
Only used by reload hackery; should not be used by new code. */
|
|
|
void
|
void
|
for_each_eh_label (void (*callback) (rtx))
|
for_each_eh_label (void (*callback) (rtx))
|
{
|
{
|
eh_landing_pad lp;
|
eh_landing_pad lp;
|
int i;
|
int i;
|
|
|
for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i)
|
for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i)
|
{
|
{
|
if (lp)
|
if (lp)
|
{
|
{
|
rtx lab = lp->landing_pad;
|
rtx lab = lp->landing_pad;
|
if (lab && LABEL_P (lab))
|
if (lab && LABEL_P (lab))
|
(*callback) (lab);
|
(*callback) (lab);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Create the REG_EH_REGION note for INSN, given its ECF_FLAGS for a
|
/* Create the REG_EH_REGION note for INSN, given its ECF_FLAGS for a
|
call insn.
|
call insn.
|
|
|
At the gimple level, we use LP_NR
|
At the gimple level, we use LP_NR
|
> 0 : The statement transfers to landing pad LP_NR
|
> 0 : The statement transfers to landing pad LP_NR
|
= 0 : The statement is outside any EH region
|
= 0 : The statement is outside any EH region
|
< 0 : The statement is within MUST_NOT_THROW region -LP_NR.
|
< 0 : The statement is within MUST_NOT_THROW region -LP_NR.
|
|
|
At the rtl level, we use LP_NR
|
At the rtl level, we use LP_NR
|
> 0 : The insn transfers to landing pad LP_NR
|
> 0 : The insn transfers to landing pad LP_NR
|
= 0 : The insn cannot throw
|
= 0 : The insn cannot throw
|
< 0 : The insn is within MUST_NOT_THROW region -LP_NR
|
< 0 : The insn is within MUST_NOT_THROW region -LP_NR
|
= INT_MIN : The insn cannot throw or execute a nonlocal-goto.
|
= INT_MIN : The insn cannot throw or execute a nonlocal-goto.
|
missing note: The insn is outside any EH region.
|
missing note: The insn is outside any EH region.
|
|
|
??? This difference probably ought to be avoided. We could stand
|
??? This difference probably ought to be avoided. We could stand
|
to record nothrow for arbitrary gimple statements, and so avoid
|
to record nothrow for arbitrary gimple statements, and so avoid
|
some moderately complex lookups in stmt_could_throw_p. Perhaps
|
some moderately complex lookups in stmt_could_throw_p. Perhaps
|
NOTHROW should be mapped on both sides to INT_MIN. Perhaps the
|
NOTHROW should be mapped on both sides to INT_MIN. Perhaps the
|
no-nonlocal-goto property should be recorded elsewhere as a bit
|
no-nonlocal-goto property should be recorded elsewhere as a bit
|
on the call_insn directly. Perhaps we should make more use of
|
on the call_insn directly. Perhaps we should make more use of
|
attaching the trees to call_insns (reachable via symbol_ref in
|
attaching the trees to call_insns (reachable via symbol_ref in
|
direct call cases) and just pull the data out of the trees. */
|
direct call cases) and just pull the data out of the trees. */
|
|
|
void
|
void
|
make_reg_eh_region_note (rtx insn, int ecf_flags, int lp_nr)
|
make_reg_eh_region_note (rtx insn, int ecf_flags, int lp_nr)
|
{
|
{
|
rtx value;
|
rtx value;
|
if (ecf_flags & ECF_NOTHROW)
|
if (ecf_flags & ECF_NOTHROW)
|
value = const0_rtx;
|
value = const0_rtx;
|
else if (lp_nr != 0)
|
else if (lp_nr != 0)
|
value = GEN_INT (lp_nr);
|
value = GEN_INT (lp_nr);
|
else
|
else
|
return;
|
return;
|
add_reg_note (insn, REG_EH_REGION, value);
|
add_reg_note (insn, REG_EH_REGION, value);
|
}
|
}
|
|
|
/* Create a REG_EH_REGION note for a CALL_INSN that cannot throw
|
/* Create a REG_EH_REGION note for a CALL_INSN that cannot throw
|
nor perform a non-local goto. Replace the region note if it
|
nor perform a non-local goto. Replace the region note if it
|
already exists. */
|
already exists. */
|
|
|
void
|
void
|
make_reg_eh_region_note_nothrow_nononlocal (rtx insn)
|
make_reg_eh_region_note_nothrow_nononlocal (rtx insn)
|
{
|
{
|
rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
|
rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
|
rtx intmin = GEN_INT (INT_MIN);
|
rtx intmin = GEN_INT (INT_MIN);
|
|
|
if (note != 0)
|
if (note != 0)
|
XEXP (note, 0) = intmin;
|
XEXP (note, 0) = intmin;
|
else
|
else
|
add_reg_note (insn, REG_EH_REGION, intmin);
|
add_reg_note (insn, REG_EH_REGION, intmin);
|
}
|
}
|
|
|
/* Return true if INSN could throw, assuming no REG_EH_REGION note
|
/* Return true if INSN could throw, assuming no REG_EH_REGION note
|
to the contrary. */
|
to the contrary. */
|
|
|
bool
|
bool
|
insn_could_throw_p (const_rtx insn)
|
insn_could_throw_p (const_rtx insn)
|
{
|
{
|
if (!flag_exceptions)
|
if (!flag_exceptions)
|
return false;
|
return false;
|
if (CALL_P (insn))
|
if (CALL_P (insn))
|
return true;
|
return true;
|
if (INSN_P (insn) && flag_non_call_exceptions)
|
if (INSN_P (insn) && flag_non_call_exceptions)
|
return may_trap_p (PATTERN (insn));
|
return may_trap_p (PATTERN (insn));
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Copy an REG_EH_REGION note to each insn that might throw beginning
|
/* Copy an REG_EH_REGION note to each insn that might throw beginning
|
at FIRST and ending at LAST. NOTE_OR_INSN is either the source insn
|
at FIRST and ending at LAST. NOTE_OR_INSN is either the source insn
|
to look for a note, or the note itself. */
|
to look for a note, or the note itself. */
|
|
|
void
|
void
|
copy_reg_eh_region_note_forward (rtx note_or_insn, rtx first, rtx last)
|
copy_reg_eh_region_note_forward (rtx note_or_insn, rtx first, rtx last)
|
{
|
{
|
rtx insn, note = note_or_insn;
|
rtx insn, note = note_or_insn;
|
|
|
if (INSN_P (note_or_insn))
|
if (INSN_P (note_or_insn))
|
{
|
{
|
note = find_reg_note (note_or_insn, REG_EH_REGION, NULL_RTX);
|
note = find_reg_note (note_or_insn, REG_EH_REGION, NULL_RTX);
|
if (note == NULL)
|
if (note == NULL)
|
return;
|
return;
|
}
|
}
|
note = XEXP (note, 0);
|
note = XEXP (note, 0);
|
|
|
for (insn = first; insn != last ; insn = NEXT_INSN (insn))
|
for (insn = first; insn != last ; insn = NEXT_INSN (insn))
|
if (!find_reg_note (insn, REG_EH_REGION, NULL_RTX)
|
if (!find_reg_note (insn, REG_EH_REGION, NULL_RTX)
|
&& insn_could_throw_p (insn))
|
&& insn_could_throw_p (insn))
|
add_reg_note (insn, REG_EH_REGION, note);
|
add_reg_note (insn, REG_EH_REGION, note);
|
}
|
}
|
|
|
/* Likewise, but iterate backward. */
|
/* Likewise, but iterate backward. */
|
|
|
void
|
void
|
copy_reg_eh_region_note_backward (rtx note_or_insn, rtx last, rtx first)
|
copy_reg_eh_region_note_backward (rtx note_or_insn, rtx last, rtx first)
|
{
|
{
|
rtx insn, note = note_or_insn;
|
rtx insn, note = note_or_insn;
|
|
|
if (INSN_P (note_or_insn))
|
if (INSN_P (note_or_insn))
|
{
|
{
|
note = find_reg_note (note_or_insn, REG_EH_REGION, NULL_RTX);
|
note = find_reg_note (note_or_insn, REG_EH_REGION, NULL_RTX);
|
if (note == NULL)
|
if (note == NULL)
|
return;
|
return;
|
}
|
}
|
note = XEXP (note, 0);
|
note = XEXP (note, 0);
|
|
|
for (insn = last; insn != first; insn = PREV_INSN (insn))
|
for (insn = last; insn != first; insn = PREV_INSN (insn))
|
if (insn_could_throw_p (insn))
|
if (insn_could_throw_p (insn))
|
add_reg_note (insn, REG_EH_REGION, note);
|
add_reg_note (insn, REG_EH_REGION, note);
|
}
|
}
|
|
|
|
|
/* Extract all EH information from INSN. Return true if the insn
|
/* Extract all EH information from INSN. Return true if the insn
|
was marked NOTHROW. */
|
was marked NOTHROW. */
|
|
|
static bool
|
static bool
|
get_eh_region_and_lp_from_rtx (const_rtx insn, eh_region *pr,
|
get_eh_region_and_lp_from_rtx (const_rtx insn, eh_region *pr,
|
eh_landing_pad *plp)
|
eh_landing_pad *plp)
|
{
|
{
|
eh_landing_pad lp = NULL;
|
eh_landing_pad lp = NULL;
|
eh_region r = NULL;
|
eh_region r = NULL;
|
bool ret = false;
|
bool ret = false;
|
rtx note;
|
rtx note;
|
int lp_nr;
|
int lp_nr;
|
|
|
if (! INSN_P (insn))
|
if (! INSN_P (insn))
|
goto egress;
|
goto egress;
|
|
|
if (NONJUMP_INSN_P (insn)
|
if (NONJUMP_INSN_P (insn)
|
&& GET_CODE (PATTERN (insn)) == SEQUENCE)
|
&& GET_CODE (PATTERN (insn)) == SEQUENCE)
|
insn = XVECEXP (PATTERN (insn), 0, 0);
|
insn = XVECEXP (PATTERN (insn), 0, 0);
|
|
|
note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
|
note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
|
if (!note)
|
if (!note)
|
{
|
{
|
ret = !insn_could_throw_p (insn);
|
ret = !insn_could_throw_p (insn);
|
goto egress;
|
goto egress;
|
}
|
}
|
|
|
lp_nr = INTVAL (XEXP (note, 0));
|
lp_nr = INTVAL (XEXP (note, 0));
|
if (lp_nr == 0 || lp_nr == INT_MIN)
|
if (lp_nr == 0 || lp_nr == INT_MIN)
|
{
|
{
|
ret = true;
|
ret = true;
|
goto egress;
|
goto egress;
|
}
|
}
|
|
|
if (lp_nr < 0)
|
if (lp_nr < 0)
|
r = VEC_index (eh_region, cfun->eh->region_array, -lp_nr);
|
r = VEC_index (eh_region, cfun->eh->region_array, -lp_nr);
|
else
|
else
|
{
|
{
|
lp = VEC_index (eh_landing_pad, cfun->eh->lp_array, lp_nr);
|
lp = VEC_index (eh_landing_pad, cfun->eh->lp_array, lp_nr);
|
r = lp->region;
|
r = lp->region;
|
}
|
}
|
|
|
egress:
|
egress:
|
*plp = lp;
|
*plp = lp;
|
*pr = r;
|
*pr = r;
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* Return the landing pad to which INSN may go, or NULL if it does not
|
/* Return the landing pad to which INSN may go, or NULL if it does not
|
have a reachable landing pad within this function. */
|
have a reachable landing pad within this function. */
|
|
|
eh_landing_pad
|
eh_landing_pad
|
get_eh_landing_pad_from_rtx (const_rtx insn)
|
get_eh_landing_pad_from_rtx (const_rtx insn)
|
{
|
{
|
eh_landing_pad lp;
|
eh_landing_pad lp;
|
eh_region r;
|
eh_region r;
|
|
|
get_eh_region_and_lp_from_rtx (insn, &r, &lp);
|
get_eh_region_and_lp_from_rtx (insn, &r, &lp);
|
return lp;
|
return lp;
|
}
|
}
|
|
|
/* Return the region to which INSN may go, or NULL if it does not
|
/* Return the region to which INSN may go, or NULL if it does not
|
have a reachable region within this function. */
|
have a reachable region within this function. */
|
|
|
eh_region
|
eh_region
|
get_eh_region_from_rtx (const_rtx insn)
|
get_eh_region_from_rtx (const_rtx insn)
|
{
|
{
|
eh_landing_pad lp;
|
eh_landing_pad lp;
|
eh_region r;
|
eh_region r;
|
|
|
get_eh_region_and_lp_from_rtx (insn, &r, &lp);
|
get_eh_region_and_lp_from_rtx (insn, &r, &lp);
|
return r;
|
return r;
|
}
|
}
|
|
|
/* Return true if INSN throws and is caught by something in this function. */
|
/* Return true if INSN throws and is caught by something in this function. */
|
|
|
bool
|
bool
|
can_throw_internal (const_rtx insn)
|
can_throw_internal (const_rtx insn)
|
{
|
{
|
return get_eh_landing_pad_from_rtx (insn) != NULL;
|
return get_eh_landing_pad_from_rtx (insn) != NULL;
|
}
|
}
|
|
|
/* Return true if INSN throws and escapes from the current function. */
|
/* Return true if INSN throws and escapes from the current function. */
|
|
|
bool
|
bool
|
can_throw_external (const_rtx insn)
|
can_throw_external (const_rtx insn)
|
{
|
{
|
eh_landing_pad lp;
|
eh_landing_pad lp;
|
eh_region r;
|
eh_region r;
|
bool nothrow;
|
bool nothrow;
|
|
|
if (! INSN_P (insn))
|
if (! INSN_P (insn))
|
return false;
|
return false;
|
|
|
if (NONJUMP_INSN_P (insn)
|
if (NONJUMP_INSN_P (insn)
|
&& GET_CODE (PATTERN (insn)) == SEQUENCE)
|
&& GET_CODE (PATTERN (insn)) == SEQUENCE)
|
{
|
{
|
rtx seq = PATTERN (insn);
|
rtx seq = PATTERN (insn);
|
int i, n = XVECLEN (seq, 0);
|
int i, n = XVECLEN (seq, 0);
|
|
|
for (i = 0; i < n; i++)
|
for (i = 0; i < n; i++)
|
if (can_throw_external (XVECEXP (seq, 0, i)))
|
if (can_throw_external (XVECEXP (seq, 0, i)))
|
return true;
|
return true;
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
nothrow = get_eh_region_and_lp_from_rtx (insn, &r, &lp);
|
nothrow = get_eh_region_and_lp_from_rtx (insn, &r, &lp);
|
|
|
/* If we can't throw, we obviously can't throw external. */
|
/* If we can't throw, we obviously can't throw external. */
|
if (nothrow)
|
if (nothrow)
|
return false;
|
return false;
|
|
|
/* If we have an internal landing pad, then we're not external. */
|
/* If we have an internal landing pad, then we're not external. */
|
if (lp != NULL)
|
if (lp != NULL)
|
return false;
|
return false;
|
|
|
/* If we're not within an EH region, then we are external. */
|
/* If we're not within an EH region, then we are external. */
|
if (r == NULL)
|
if (r == NULL)
|
return true;
|
return true;
|
|
|
/* The only thing that ought to be left is MUST_NOT_THROW regions,
|
/* The only thing that ought to be left is MUST_NOT_THROW regions,
|
which don't always have landing pads. */
|
which don't always have landing pads. */
|
gcc_assert (r->type == ERT_MUST_NOT_THROW);
|
gcc_assert (r->type == ERT_MUST_NOT_THROW);
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Return true if INSN cannot throw at all. */
|
/* Return true if INSN cannot throw at all. */
|
|
|
bool
|
bool
|
insn_nothrow_p (const_rtx insn)
|
insn_nothrow_p (const_rtx insn)
|
{
|
{
|
eh_landing_pad lp;
|
eh_landing_pad lp;
|
eh_region r;
|
eh_region r;
|
|
|
if (! INSN_P (insn))
|
if (! INSN_P (insn))
|
return true;
|
return true;
|
|
|
if (NONJUMP_INSN_P (insn)
|
if (NONJUMP_INSN_P (insn)
|
&& GET_CODE (PATTERN (insn)) == SEQUENCE)
|
&& GET_CODE (PATTERN (insn)) == SEQUENCE)
|
{
|
{
|
rtx seq = PATTERN (insn);
|
rtx seq = PATTERN (insn);
|
int i, n = XVECLEN (seq, 0);
|
int i, n = XVECLEN (seq, 0);
|
|
|
for (i = 0; i < n; i++)
|
for (i = 0; i < n; i++)
|
if (!insn_nothrow_p (XVECEXP (seq, 0, i)))
|
if (!insn_nothrow_p (XVECEXP (seq, 0, i)))
|
return false;
|
return false;
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
return get_eh_region_and_lp_from_rtx (insn, &r, &lp);
|
return get_eh_region_and_lp_from_rtx (insn, &r, &lp);
|
}
|
}
|
|
|
/* Return true if INSN can perform a non-local goto. */
|
/* Return true if INSN can perform a non-local goto. */
|
/* ??? This test is here in this file because it (ab)uses REG_EH_REGION. */
|
/* ??? This test is here in this file because it (ab)uses REG_EH_REGION. */
|
|
|
bool
|
bool
|
can_nonlocal_goto (const_rtx insn)
|
can_nonlocal_goto (const_rtx insn)
|
{
|
{
|
if (nonlocal_goto_handler_labels && CALL_P (insn))
|
if (nonlocal_goto_handler_labels && CALL_P (insn))
|
{
|
{
|
rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
|
rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
|
if (!note || INTVAL (XEXP (note, 0)) != INT_MIN)
|
if (!note || INTVAL (XEXP (note, 0)) != INT_MIN)
|
return true;
|
return true;
|
}
|
}
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Set TREE_NOTHROW and crtl->all_throwers_are_sibcalls. */
|
/* Set TREE_NOTHROW and crtl->all_throwers_are_sibcalls. */
|
|
|
static unsigned int
|
static unsigned int
|
set_nothrow_function_flags (void)
|
set_nothrow_function_flags (void)
|
{
|
{
|
rtx insn;
|
rtx insn;
|
|
|
crtl->nothrow = 1;
|
crtl->nothrow = 1;
|
|
|
/* Assume crtl->all_throwers_are_sibcalls until we encounter
|
/* Assume crtl->all_throwers_are_sibcalls until we encounter
|
something that can throw an exception. We specifically exempt
|
something that can throw an exception. We specifically exempt
|
CALL_INSNs that are SIBLING_CALL_P, as these are really jumps,
|
CALL_INSNs that are SIBLING_CALL_P, as these are really jumps,
|
and can't throw. Most CALL_INSNs are not SIBLING_CALL_P, so this
|
and can't throw. Most CALL_INSNs are not SIBLING_CALL_P, so this
|
is optimistic. */
|
is optimistic. */
|
|
|
crtl->all_throwers_are_sibcalls = 1;
|
crtl->all_throwers_are_sibcalls = 1;
|
|
|
/* If we don't know that this implementation of the function will
|
/* If we don't know that this implementation of the function will
|
actually be used, then we must not set TREE_NOTHROW, since
|
actually be used, then we must not set TREE_NOTHROW, since
|
callers must not assume that this function does not throw. */
|
callers must not assume that this function does not throw. */
|
if (TREE_NOTHROW (current_function_decl))
|
if (TREE_NOTHROW (current_function_decl))
|
return 0;
|
return 0;
|
|
|
if (! flag_exceptions)
|
if (! flag_exceptions)
|
return 0;
|
return 0;
|
|
|
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
|
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
|
if (can_throw_external (insn))
|
if (can_throw_external (insn))
|
{
|
{
|
crtl->nothrow = 0;
|
crtl->nothrow = 0;
|
|
|
if (!CALL_P (insn) || !SIBLING_CALL_P (insn))
|
if (!CALL_P (insn) || !SIBLING_CALL_P (insn))
|
{
|
{
|
crtl->all_throwers_are_sibcalls = 0;
|
crtl->all_throwers_are_sibcalls = 0;
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
|
|
for (insn = crtl->epilogue_delay_list; insn;
|
for (insn = crtl->epilogue_delay_list; insn;
|
insn = XEXP (insn, 1))
|
insn = XEXP (insn, 1))
|
if (can_throw_external (insn))
|
if (can_throw_external (insn))
|
{
|
{
|
crtl->nothrow = 0;
|
crtl->nothrow = 0;
|
|
|
if (!CALL_P (insn) || !SIBLING_CALL_P (insn))
|
if (!CALL_P (insn) || !SIBLING_CALL_P (insn))
|
{
|
{
|
crtl->all_throwers_are_sibcalls = 0;
|
crtl->all_throwers_are_sibcalls = 0;
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
if (crtl->nothrow
|
if (crtl->nothrow
|
&& (cgraph_function_body_availability (cgraph_node
|
&& (cgraph_function_body_availability (cgraph_node
|
(current_function_decl))
|
(current_function_decl))
|
>= AVAIL_AVAILABLE))
|
>= AVAIL_AVAILABLE))
|
{
|
{
|
struct cgraph_node *node = cgraph_node (current_function_decl);
|
struct cgraph_node *node = cgraph_node (current_function_decl);
|
struct cgraph_edge *e;
|
struct cgraph_edge *e;
|
for (e = node->callers; e; e = e->next_caller)
|
for (e = node->callers; e; e = e->next_caller)
|
e->can_throw_external = false;
|
e->can_throw_external = false;
|
cgraph_set_nothrow_flag (node, true);
|
cgraph_set_nothrow_flag (node, true);
|
|
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file, "Marking function nothrow: %s\n\n",
|
fprintf (dump_file, "Marking function nothrow: %s\n\n",
|
current_function_name ());
|
current_function_name ());
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
struct rtl_opt_pass pass_set_nothrow_function_flags =
|
struct rtl_opt_pass pass_set_nothrow_function_flags =
|
{
|
{
|
{
|
{
|
RTL_PASS,
|
RTL_PASS,
|
"nothrow", /* name */
|
"nothrow", /* name */
|
NULL, /* gate */
|
NULL, /* gate */
|
set_nothrow_function_flags, /* execute */
|
set_nothrow_function_flags, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_NONE, /* tv_id */
|
TV_NONE, /* tv_id */
|
0, /* properties_required */
|
0, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
TODO_dump_func, /* todo_flags_finish */
|
TODO_dump_func, /* todo_flags_finish */
|
}
|
}
|
};
|
};
|
|
|
|
|
/* Various hooks for unwind library. */
|
/* Various hooks for unwind library. */
|
|
|
/* Expand the EH support builtin functions:
|
/* Expand the EH support builtin functions:
|
__builtin_eh_pointer and __builtin_eh_filter. */
|
__builtin_eh_pointer and __builtin_eh_filter. */
|
|
|
static eh_region
|
static eh_region
|
expand_builtin_eh_common (tree region_nr_t)
|
expand_builtin_eh_common (tree region_nr_t)
|
{
|
{
|
HOST_WIDE_INT region_nr;
|
HOST_WIDE_INT region_nr;
|
eh_region region;
|
eh_region region;
|
|
|
gcc_assert (host_integerp (region_nr_t, 0));
|
gcc_assert (host_integerp (region_nr_t, 0));
|
region_nr = tree_low_cst (region_nr_t, 0);
|
region_nr = tree_low_cst (region_nr_t, 0);
|
|
|
region = VEC_index (eh_region, cfun->eh->region_array, region_nr);
|
region = VEC_index (eh_region, cfun->eh->region_array, region_nr);
|
|
|
/* ??? We shouldn't have been able to delete a eh region without
|
/* ??? We shouldn't have been able to delete a eh region without
|
deleting all the code that depended on it. */
|
deleting all the code that depended on it. */
|
gcc_assert (region != NULL);
|
gcc_assert (region != NULL);
|
|
|
return region;
|
return region;
|
}
|
}
|
|
|
/* Expand to the exc_ptr value from the given eh region. */
|
/* Expand to the exc_ptr value from the given eh region. */
|
|
|
rtx
|
rtx
|
expand_builtin_eh_pointer (tree exp)
|
expand_builtin_eh_pointer (tree exp)
|
{
|
{
|
eh_region region
|
eh_region region
|
= expand_builtin_eh_common (CALL_EXPR_ARG (exp, 0));
|
= expand_builtin_eh_common (CALL_EXPR_ARG (exp, 0));
|
if (region->exc_ptr_reg == NULL)
|
if (region->exc_ptr_reg == NULL)
|
region->exc_ptr_reg = gen_reg_rtx (ptr_mode);
|
region->exc_ptr_reg = gen_reg_rtx (ptr_mode);
|
return region->exc_ptr_reg;
|
return region->exc_ptr_reg;
|
}
|
}
|
|
|
/* Expand to the filter value from the given eh region. */
|
/* Expand to the filter value from the given eh region. */
|
|
|
rtx
|
rtx
|
expand_builtin_eh_filter (tree exp)
|
expand_builtin_eh_filter (tree exp)
|
{
|
{
|
eh_region region
|
eh_region region
|
= expand_builtin_eh_common (CALL_EXPR_ARG (exp, 0));
|
= expand_builtin_eh_common (CALL_EXPR_ARG (exp, 0));
|
if (region->filter_reg == NULL)
|
if (region->filter_reg == NULL)
|
region->filter_reg = gen_reg_rtx (targetm.eh_return_filter_mode ());
|
region->filter_reg = gen_reg_rtx (targetm.eh_return_filter_mode ());
|
return region->filter_reg;
|
return region->filter_reg;
|
}
|
}
|
|
|
/* Copy the exc_ptr and filter values from one landing pad's registers
|
/* Copy the exc_ptr and filter values from one landing pad's registers
|
to another. This is used to inline the resx statement. */
|
to another. This is used to inline the resx statement. */
|
|
|
rtx
|
rtx
|
expand_builtin_eh_copy_values (tree exp)
|
expand_builtin_eh_copy_values (tree exp)
|
{
|
{
|
eh_region dst
|
eh_region dst
|
= expand_builtin_eh_common (CALL_EXPR_ARG (exp, 0));
|
= expand_builtin_eh_common (CALL_EXPR_ARG (exp, 0));
|
eh_region src
|
eh_region src
|
= expand_builtin_eh_common (CALL_EXPR_ARG (exp, 1));
|
= expand_builtin_eh_common (CALL_EXPR_ARG (exp, 1));
|
enum machine_mode fmode = targetm.eh_return_filter_mode ();
|
enum machine_mode fmode = targetm.eh_return_filter_mode ();
|
|
|
if (dst->exc_ptr_reg == NULL)
|
if (dst->exc_ptr_reg == NULL)
|
dst->exc_ptr_reg = gen_reg_rtx (ptr_mode);
|
dst->exc_ptr_reg = gen_reg_rtx (ptr_mode);
|
if (src->exc_ptr_reg == NULL)
|
if (src->exc_ptr_reg == NULL)
|
src->exc_ptr_reg = gen_reg_rtx (ptr_mode);
|
src->exc_ptr_reg = gen_reg_rtx (ptr_mode);
|
|
|
if (dst->filter_reg == NULL)
|
if (dst->filter_reg == NULL)
|
dst->filter_reg = gen_reg_rtx (fmode);
|
dst->filter_reg = gen_reg_rtx (fmode);
|
if (src->filter_reg == NULL)
|
if (src->filter_reg == NULL)
|
src->filter_reg = gen_reg_rtx (fmode);
|
src->filter_reg = gen_reg_rtx (fmode);
|
|
|
emit_move_insn (dst->exc_ptr_reg, src->exc_ptr_reg);
|
emit_move_insn (dst->exc_ptr_reg, src->exc_ptr_reg);
|
emit_move_insn (dst->filter_reg, src->filter_reg);
|
emit_move_insn (dst->filter_reg, src->filter_reg);
|
|
|
return const0_rtx;
|
return const0_rtx;
|
}
|
}
|
|
|
/* Do any necessary initialization to access arbitrary stack frames.
|
/* Do any necessary initialization to access arbitrary stack frames.
|
On the SPARC, this means flushing the register windows. */
|
On the SPARC, this means flushing the register windows. */
|
|
|
void
|
void
|
expand_builtin_unwind_init (void)
|
expand_builtin_unwind_init (void)
|
{
|
{
|
/* Set this so all the registers get saved in our frame; we need to be
|
/* Set this so all the registers get saved in our frame; we need to be
|
able to copy the saved values for any registers from frames we unwind. */
|
able to copy the saved values for any registers from frames we unwind. */
|
crtl->saves_all_registers = 1;
|
crtl->saves_all_registers = 1;
|
|
|
#ifdef SETUP_FRAME_ADDRESSES
|
#ifdef SETUP_FRAME_ADDRESSES
|
SETUP_FRAME_ADDRESSES ();
|
SETUP_FRAME_ADDRESSES ();
|
#endif
|
#endif
|
}
|
}
|
|
|
/* Map a non-negative number to an eh return data register number; expands
|
/* Map a non-negative number to an eh return data register number; expands
|
to -1 if no return data register is associated with the input number.
|
to -1 if no return data register is associated with the input number.
|
At least the inputs 0 and 1 must be mapped; the target may provide more. */
|
At least the inputs 0 and 1 must be mapped; the target may provide more. */
|
|
|
rtx
|
rtx
|
expand_builtin_eh_return_data_regno (tree exp)
|
expand_builtin_eh_return_data_regno (tree exp)
|
{
|
{
|
tree which = CALL_EXPR_ARG (exp, 0);
|
tree which = CALL_EXPR_ARG (exp, 0);
|
unsigned HOST_WIDE_INT iwhich;
|
unsigned HOST_WIDE_INT iwhich;
|
|
|
if (TREE_CODE (which) != INTEGER_CST)
|
if (TREE_CODE (which) != INTEGER_CST)
|
{
|
{
|
error ("argument of %<__builtin_eh_return_regno%> must be constant");
|
error ("argument of %<__builtin_eh_return_regno%> must be constant");
|
return constm1_rtx;
|
return constm1_rtx;
|
}
|
}
|
|
|
iwhich = tree_low_cst (which, 1);
|
iwhich = tree_low_cst (which, 1);
|
iwhich = EH_RETURN_DATA_REGNO (iwhich);
|
iwhich = EH_RETURN_DATA_REGNO (iwhich);
|
if (iwhich == INVALID_REGNUM)
|
if (iwhich == INVALID_REGNUM)
|
return constm1_rtx;
|
return constm1_rtx;
|
|
|
#ifdef DWARF_FRAME_REGNUM
|
#ifdef DWARF_FRAME_REGNUM
|
iwhich = DWARF_FRAME_REGNUM (iwhich);
|
iwhich = DWARF_FRAME_REGNUM (iwhich);
|
#else
|
#else
|
iwhich = DBX_REGISTER_NUMBER (iwhich);
|
iwhich = DBX_REGISTER_NUMBER (iwhich);
|
#endif
|
#endif
|
|
|
return GEN_INT (iwhich);
|
return GEN_INT (iwhich);
|
}
|
}
|
|
|
/* Given a value extracted from the return address register or stack slot,
|
/* Given a value extracted from the return address register or stack slot,
|
return the actual address encoded in that value. */
|
return the actual address encoded in that value. */
|
|
|
rtx
|
rtx
|
expand_builtin_extract_return_addr (tree addr_tree)
|
expand_builtin_extract_return_addr (tree addr_tree)
|
{
|
{
|
rtx addr = expand_expr (addr_tree, NULL_RTX, Pmode, EXPAND_NORMAL);
|
rtx addr = expand_expr (addr_tree, NULL_RTX, Pmode, EXPAND_NORMAL);
|
|
|
if (GET_MODE (addr) != Pmode
|
if (GET_MODE (addr) != Pmode
|
&& GET_MODE (addr) != VOIDmode)
|
&& GET_MODE (addr) != VOIDmode)
|
{
|
{
|
#ifdef POINTERS_EXTEND_UNSIGNED
|
#ifdef POINTERS_EXTEND_UNSIGNED
|
addr = convert_memory_address (Pmode, addr);
|
addr = convert_memory_address (Pmode, addr);
|
#else
|
#else
|
addr = convert_to_mode (Pmode, addr, 0);
|
addr = convert_to_mode (Pmode, addr, 0);
|
#endif
|
#endif
|
}
|
}
|
|
|
/* First mask out any unwanted bits. */
|
/* First mask out any unwanted bits. */
|
#ifdef MASK_RETURN_ADDR
|
#ifdef MASK_RETURN_ADDR
|
expand_and (Pmode, addr, MASK_RETURN_ADDR, addr);
|
expand_and (Pmode, addr, MASK_RETURN_ADDR, addr);
|
#endif
|
#endif
|
|
|
/* Then adjust to find the real return address. */
|
/* Then adjust to find the real return address. */
|
#if defined (RETURN_ADDR_OFFSET)
|
#if defined (RETURN_ADDR_OFFSET)
|
addr = plus_constant (addr, RETURN_ADDR_OFFSET);
|
addr = plus_constant (addr, RETURN_ADDR_OFFSET);
|
#endif
|
#endif
|
|
|
return addr;
|
return addr;
|
}
|
}
|
|
|
/* Given an actual address in addr_tree, do any necessary encoding
|
/* Given an actual address in addr_tree, do any necessary encoding
|
and return the value to be stored in the return address register or
|
and return the value to be stored in the return address register or
|
stack slot so the epilogue will return to that address. */
|
stack slot so the epilogue will return to that address. */
|
|
|
rtx
|
rtx
|
expand_builtin_frob_return_addr (tree addr_tree)
|
expand_builtin_frob_return_addr (tree addr_tree)
|
{
|
{
|
rtx addr = expand_expr (addr_tree, NULL_RTX, ptr_mode, EXPAND_NORMAL);
|
rtx addr = expand_expr (addr_tree, NULL_RTX, ptr_mode, EXPAND_NORMAL);
|
|
|
addr = convert_memory_address (Pmode, addr);
|
addr = convert_memory_address (Pmode, addr);
|
|
|
#ifdef RETURN_ADDR_OFFSET
|
#ifdef RETURN_ADDR_OFFSET
|
addr = force_reg (Pmode, addr);
|
addr = force_reg (Pmode, addr);
|
addr = plus_constant (addr, -RETURN_ADDR_OFFSET);
|
addr = plus_constant (addr, -RETURN_ADDR_OFFSET);
|
#endif
|
#endif
|
|
|
return addr;
|
return addr;
|
}
|
}
|
|
|
/* Set up the epilogue with the magic bits we'll need to return to the
|
/* Set up the epilogue with the magic bits we'll need to return to the
|
exception handler. */
|
exception handler. */
|
|
|
void
|
void
|
expand_builtin_eh_return (tree stackadj_tree ATTRIBUTE_UNUSED,
|
expand_builtin_eh_return (tree stackadj_tree ATTRIBUTE_UNUSED,
|
tree handler_tree)
|
tree handler_tree)
|
{
|
{
|
rtx tmp;
|
rtx tmp;
|
|
|
#ifdef EH_RETURN_STACKADJ_RTX
|
#ifdef EH_RETURN_STACKADJ_RTX
|
tmp = expand_expr (stackadj_tree, crtl->eh.ehr_stackadj,
|
tmp = expand_expr (stackadj_tree, crtl->eh.ehr_stackadj,
|
VOIDmode, EXPAND_NORMAL);
|
VOIDmode, EXPAND_NORMAL);
|
tmp = convert_memory_address (Pmode, tmp);
|
tmp = convert_memory_address (Pmode, tmp);
|
if (!crtl->eh.ehr_stackadj)
|
if (!crtl->eh.ehr_stackadj)
|
crtl->eh.ehr_stackadj = copy_to_reg (tmp);
|
crtl->eh.ehr_stackadj = copy_to_reg (tmp);
|
else if (tmp != crtl->eh.ehr_stackadj)
|
else if (tmp != crtl->eh.ehr_stackadj)
|
emit_move_insn (crtl->eh.ehr_stackadj, tmp);
|
emit_move_insn (crtl->eh.ehr_stackadj, tmp);
|
#endif
|
#endif
|
|
|
tmp = expand_expr (handler_tree, crtl->eh.ehr_handler,
|
tmp = expand_expr (handler_tree, crtl->eh.ehr_handler,
|
VOIDmode, EXPAND_NORMAL);
|
VOIDmode, EXPAND_NORMAL);
|
tmp = convert_memory_address (Pmode, tmp);
|
tmp = convert_memory_address (Pmode, tmp);
|
if (!crtl->eh.ehr_handler)
|
if (!crtl->eh.ehr_handler)
|
crtl->eh.ehr_handler = copy_to_reg (tmp);
|
crtl->eh.ehr_handler = copy_to_reg (tmp);
|
else if (tmp != crtl->eh.ehr_handler)
|
else if (tmp != crtl->eh.ehr_handler)
|
emit_move_insn (crtl->eh.ehr_handler, tmp);
|
emit_move_insn (crtl->eh.ehr_handler, tmp);
|
|
|
if (!crtl->eh.ehr_label)
|
if (!crtl->eh.ehr_label)
|
crtl->eh.ehr_label = gen_label_rtx ();
|
crtl->eh.ehr_label = gen_label_rtx ();
|
emit_jump (crtl->eh.ehr_label);
|
emit_jump (crtl->eh.ehr_label);
|
}
|
}
|
|
|
/* Expand __builtin_eh_return. This exit path from the function loads up
|
/* Expand __builtin_eh_return. This exit path from the function loads up
|
the eh return data registers, adjusts the stack, and branches to a
|
the eh return data registers, adjusts the stack, and branches to a
|
given PC other than the normal return address. */
|
given PC other than the normal return address. */
|
|
|
void
|
void
|
expand_eh_return (void)
|
expand_eh_return (void)
|
{
|
{
|
rtx around_label;
|
rtx around_label;
|
|
|
if (! crtl->eh.ehr_label)
|
if (! crtl->eh.ehr_label)
|
return;
|
return;
|
|
|
crtl->calls_eh_return = 1;
|
crtl->calls_eh_return = 1;
|
|
|
#ifdef EH_RETURN_STACKADJ_RTX
|
#ifdef EH_RETURN_STACKADJ_RTX
|
emit_move_insn (EH_RETURN_STACKADJ_RTX, const0_rtx);
|
emit_move_insn (EH_RETURN_STACKADJ_RTX, const0_rtx);
|
#endif
|
#endif
|
|
|
around_label = gen_label_rtx ();
|
around_label = gen_label_rtx ();
|
emit_jump (around_label);
|
emit_jump (around_label);
|
|
|
emit_label (crtl->eh.ehr_label);
|
emit_label (crtl->eh.ehr_label);
|
clobber_return_register ();
|
clobber_return_register ();
|
|
|
#ifdef EH_RETURN_STACKADJ_RTX
|
#ifdef EH_RETURN_STACKADJ_RTX
|
emit_move_insn (EH_RETURN_STACKADJ_RTX, crtl->eh.ehr_stackadj);
|
emit_move_insn (EH_RETURN_STACKADJ_RTX, crtl->eh.ehr_stackadj);
|
#endif
|
#endif
|
|
|
#ifdef HAVE_eh_return
|
#ifdef HAVE_eh_return
|
if (HAVE_eh_return)
|
if (HAVE_eh_return)
|
emit_insn (gen_eh_return (crtl->eh.ehr_handler));
|
emit_insn (gen_eh_return (crtl->eh.ehr_handler));
|
else
|
else
|
#endif
|
#endif
|
{
|
{
|
#ifdef EH_RETURN_HANDLER_RTX
|
#ifdef EH_RETURN_HANDLER_RTX
|
emit_move_insn (EH_RETURN_HANDLER_RTX, crtl->eh.ehr_handler);
|
emit_move_insn (EH_RETURN_HANDLER_RTX, crtl->eh.ehr_handler);
|
#else
|
#else
|
error ("__builtin_eh_return not supported on this target");
|
error ("__builtin_eh_return not supported on this target");
|
#endif
|
#endif
|
}
|
}
|
|
|
emit_label (around_label);
|
emit_label (around_label);
|
}
|
}
|
|
|
/* Convert a ptr_mode address ADDR_TREE to a Pmode address controlled by
|
/* Convert a ptr_mode address ADDR_TREE to a Pmode address controlled by
|
POINTERS_EXTEND_UNSIGNED and return it. */
|
POINTERS_EXTEND_UNSIGNED and return it. */
|
|
|
rtx
|
rtx
|
expand_builtin_extend_pointer (tree addr_tree)
|
expand_builtin_extend_pointer (tree addr_tree)
|
{
|
{
|
rtx addr = expand_expr (addr_tree, NULL_RTX, ptr_mode, EXPAND_NORMAL);
|
rtx addr = expand_expr (addr_tree, NULL_RTX, ptr_mode, EXPAND_NORMAL);
|
int extend;
|
int extend;
|
|
|
#ifdef POINTERS_EXTEND_UNSIGNED
|
#ifdef POINTERS_EXTEND_UNSIGNED
|
extend = POINTERS_EXTEND_UNSIGNED;
|
extend = POINTERS_EXTEND_UNSIGNED;
|
#else
|
#else
|
/* The previous EH code did an unsigned extend by default, so we do this also
|
/* The previous EH code did an unsigned extend by default, so we do this also
|
for consistency. */
|
for consistency. */
|
extend = 1;
|
extend = 1;
|
#endif
|
#endif
|
|
|
return convert_modes (targetm.unwind_word_mode (), ptr_mode, addr, extend);
|
return convert_modes (targetm.unwind_word_mode (), ptr_mode, addr, extend);
|
}
|
}
|
|
|
/* In the following functions, we represent entries in the action table
|
/* In the following functions, we represent entries in the action table
|
as 1-based indices. Special cases are:
|
as 1-based indices. Special cases are:
|
|
|
0: null action record, non-null landing pad; implies cleanups
|
0: null action record, non-null landing pad; implies cleanups
|
-1: null action record, null landing pad; implies no action
|
-1: null action record, null landing pad; implies no action
|
-2: no call-site entry; implies must_not_throw
|
-2: no call-site entry; implies must_not_throw
|
-3: we have yet to process outer regions
|
-3: we have yet to process outer regions
|
|
|
Further, no special cases apply to the "next" field of the record.
|
Further, no special cases apply to the "next" field of the record.
|
For next, 0 means end of list. */
|
For next, 0 means end of list. */
|
|
|
struct action_record
|
struct action_record
|
{
|
{
|
int offset;
|
int offset;
|
int filter;
|
int filter;
|
int next;
|
int next;
|
};
|
};
|
|
|
static int
|
static int
|
action_record_eq (const void *pentry, const void *pdata)
|
action_record_eq (const void *pentry, const void *pdata)
|
{
|
{
|
const struct action_record *entry = (const struct action_record *) pentry;
|
const struct action_record *entry = (const struct action_record *) pentry;
|
const struct action_record *data = (const struct action_record *) pdata;
|
const struct action_record *data = (const struct action_record *) pdata;
|
return entry->filter == data->filter && entry->next == data->next;
|
return entry->filter == data->filter && entry->next == data->next;
|
}
|
}
|
|
|
static hashval_t
|
static hashval_t
|
action_record_hash (const void *pentry)
|
action_record_hash (const void *pentry)
|
{
|
{
|
const struct action_record *entry = (const struct action_record *) pentry;
|
const struct action_record *entry = (const struct action_record *) pentry;
|
return entry->next * 1009 + entry->filter;
|
return entry->next * 1009 + entry->filter;
|
}
|
}
|
|
|
static int
|
static int
|
add_action_record (htab_t ar_hash, int filter, int next)
|
add_action_record (htab_t ar_hash, int filter, int next)
|
{
|
{
|
struct action_record **slot, *new_ar, tmp;
|
struct action_record **slot, *new_ar, tmp;
|
|
|
tmp.filter = filter;
|
tmp.filter = filter;
|
tmp.next = next;
|
tmp.next = next;
|
slot = (struct action_record **) htab_find_slot (ar_hash, &tmp, INSERT);
|
slot = (struct action_record **) htab_find_slot (ar_hash, &tmp, INSERT);
|
|
|
if ((new_ar = *slot) == NULL)
|
if ((new_ar = *slot) == NULL)
|
{
|
{
|
new_ar = XNEW (struct action_record);
|
new_ar = XNEW (struct action_record);
|
new_ar->offset = VEC_length (uchar, crtl->eh.action_record_data) + 1;
|
new_ar->offset = VEC_length (uchar, crtl->eh.action_record_data) + 1;
|
new_ar->filter = filter;
|
new_ar->filter = filter;
|
new_ar->next = next;
|
new_ar->next = next;
|
*slot = new_ar;
|
*slot = new_ar;
|
|
|
/* The filter value goes in untouched. The link to the next
|
/* The filter value goes in untouched. The link to the next
|
record is a "self-relative" byte offset, or zero to indicate
|
record is a "self-relative" byte offset, or zero to indicate
|
that there is no next record. So convert the absolute 1 based
|
that there is no next record. So convert the absolute 1 based
|
indices we've been carrying around into a displacement. */
|
indices we've been carrying around into a displacement. */
|
|
|
push_sleb128 (&crtl->eh.action_record_data, filter);
|
push_sleb128 (&crtl->eh.action_record_data, filter);
|
if (next)
|
if (next)
|
next -= VEC_length (uchar, crtl->eh.action_record_data) + 1;
|
next -= VEC_length (uchar, crtl->eh.action_record_data) + 1;
|
push_sleb128 (&crtl->eh.action_record_data, next);
|
push_sleb128 (&crtl->eh.action_record_data, next);
|
}
|
}
|
|
|
return new_ar->offset;
|
return new_ar->offset;
|
}
|
}
|
|
|
static int
|
static int
|
collect_one_action_chain (htab_t ar_hash, eh_region region)
|
collect_one_action_chain (htab_t ar_hash, eh_region region)
|
{
|
{
|
int next;
|
int next;
|
|
|
/* If we've reached the top of the region chain, then we have
|
/* If we've reached the top of the region chain, then we have
|
no actions, and require no landing pad. */
|
no actions, and require no landing pad. */
|
if (region == NULL)
|
if (region == NULL)
|
return -1;
|
return -1;
|
|
|
switch (region->type)
|
switch (region->type)
|
{
|
{
|
case ERT_CLEANUP:
|
case ERT_CLEANUP:
|
{
|
{
|
eh_region r;
|
eh_region r;
|
/* A cleanup adds a zero filter to the beginning of the chain, but
|
/* A cleanup adds a zero filter to the beginning of the chain, but
|
there are special cases to look out for. If there are *only*
|
there are special cases to look out for. If there are *only*
|
cleanups along a path, then it compresses to a zero action.
|
cleanups along a path, then it compresses to a zero action.
|
Further, if there are multiple cleanups along a path, we only
|
Further, if there are multiple cleanups along a path, we only
|
need to represent one of them, as that is enough to trigger
|
need to represent one of them, as that is enough to trigger
|
entry to the landing pad at runtime. */
|
entry to the landing pad at runtime. */
|
next = collect_one_action_chain (ar_hash, region->outer);
|
next = collect_one_action_chain (ar_hash, region->outer);
|
if (next <= 0)
|
if (next <= 0)
|
return 0;
|
return 0;
|
for (r = region->outer; r ; r = r->outer)
|
for (r = region->outer; r ; r = r->outer)
|
if (r->type == ERT_CLEANUP)
|
if (r->type == ERT_CLEANUP)
|
return next;
|
return next;
|
return add_action_record (ar_hash, 0, next);
|
return add_action_record (ar_hash, 0, next);
|
}
|
}
|
|
|
case ERT_TRY:
|
case ERT_TRY:
|
{
|
{
|
eh_catch c;
|
eh_catch c;
|
|
|
/* Process the associated catch regions in reverse order.
|
/* Process the associated catch regions in reverse order.
|
If there's a catch-all handler, then we don't need to
|
If there's a catch-all handler, then we don't need to
|
search outer regions. Use a magic -3 value to record
|
search outer regions. Use a magic -3 value to record
|
that we haven't done the outer search. */
|
that we haven't done the outer search. */
|
next = -3;
|
next = -3;
|
for (c = region->u.eh_try.last_catch; c ; c = c->prev_catch)
|
for (c = region->u.eh_try.last_catch; c ; c = c->prev_catch)
|
{
|
{
|
if (c->type_list == NULL)
|
if (c->type_list == NULL)
|
{
|
{
|
/* Retrieve the filter from the head of the filter list
|
/* Retrieve the filter from the head of the filter list
|
where we have stored it (see assign_filter_values). */
|
where we have stored it (see assign_filter_values). */
|
int filter = TREE_INT_CST_LOW (TREE_VALUE (c->filter_list));
|
int filter = TREE_INT_CST_LOW (TREE_VALUE (c->filter_list));
|
next = add_action_record (ar_hash, filter, 0);
|
next = add_action_record (ar_hash, filter, 0);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Once the outer search is done, trigger an action record for
|
/* Once the outer search is done, trigger an action record for
|
each filter we have. */
|
each filter we have. */
|
tree flt_node;
|
tree flt_node;
|
|
|
if (next == -3)
|
if (next == -3)
|
{
|
{
|
next = collect_one_action_chain (ar_hash, region->outer);
|
next = collect_one_action_chain (ar_hash, region->outer);
|
|
|
/* If there is no next action, terminate the chain. */
|
/* If there is no next action, terminate the chain. */
|
if (next == -1)
|
if (next == -1)
|
next = 0;
|
next = 0;
|
/* If all outer actions are cleanups or must_not_throw,
|
/* If all outer actions are cleanups or must_not_throw,
|
we'll have no action record for it, since we had wanted
|
we'll have no action record for it, since we had wanted
|
to encode these states in the call-site record directly.
|
to encode these states in the call-site record directly.
|
Add a cleanup action to the chain to catch these. */
|
Add a cleanup action to the chain to catch these. */
|
else if (next <= 0)
|
else if (next <= 0)
|
next = add_action_record (ar_hash, 0, 0);
|
next = add_action_record (ar_hash, 0, 0);
|
}
|
}
|
|
|
flt_node = c->filter_list;
|
flt_node = c->filter_list;
|
for (; flt_node; flt_node = TREE_CHAIN (flt_node))
|
for (; flt_node; flt_node = TREE_CHAIN (flt_node))
|
{
|
{
|
int filter = TREE_INT_CST_LOW (TREE_VALUE (flt_node));
|
int filter = TREE_INT_CST_LOW (TREE_VALUE (flt_node));
|
next = add_action_record (ar_hash, filter, next);
|
next = add_action_record (ar_hash, filter, next);
|
}
|
}
|
}
|
}
|
}
|
}
|
return next;
|
return next;
|
}
|
}
|
|
|
case ERT_ALLOWED_EXCEPTIONS:
|
case ERT_ALLOWED_EXCEPTIONS:
|
/* An exception specification adds its filter to the
|
/* An exception specification adds its filter to the
|
beginning of the chain. */
|
beginning of the chain. */
|
next = collect_one_action_chain (ar_hash, region->outer);
|
next = collect_one_action_chain (ar_hash, region->outer);
|
|
|
/* If there is no next action, terminate the chain. */
|
/* If there is no next action, terminate the chain. */
|
if (next == -1)
|
if (next == -1)
|
next = 0;
|
next = 0;
|
/* If all outer actions are cleanups or must_not_throw,
|
/* If all outer actions are cleanups or must_not_throw,
|
we'll have no action record for it, since we had wanted
|
we'll have no action record for it, since we had wanted
|
to encode these states in the call-site record directly.
|
to encode these states in the call-site record directly.
|
Add a cleanup action to the chain to catch these. */
|
Add a cleanup action to the chain to catch these. */
|
else if (next <= 0)
|
else if (next <= 0)
|
next = add_action_record (ar_hash, 0, 0);
|
next = add_action_record (ar_hash, 0, 0);
|
|
|
return add_action_record (ar_hash, region->u.allowed.filter, next);
|
return add_action_record (ar_hash, region->u.allowed.filter, next);
|
|
|
case ERT_MUST_NOT_THROW:
|
case ERT_MUST_NOT_THROW:
|
/* A must-not-throw region with no inner handlers or cleanups
|
/* A must-not-throw region with no inner handlers or cleanups
|
requires no call-site entry. Note that this differs from
|
requires no call-site entry. Note that this differs from
|
the no handler or cleanup case in that we do require an lsda
|
the no handler or cleanup case in that we do require an lsda
|
to be generated. Return a magic -2 value to record this. */
|
to be generated. Return a magic -2 value to record this. */
|
return -2;
|
return -2;
|
}
|
}
|
|
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
static int
|
static int
|
add_call_site (rtx landing_pad, int action, int section)
|
add_call_site (rtx landing_pad, int action, int section)
|
{
|
{
|
call_site_record record;
|
call_site_record record;
|
|
|
record = GGC_NEW (struct call_site_record_d);
|
record = GGC_NEW (struct call_site_record_d);
|
record->landing_pad = landing_pad;
|
record->landing_pad = landing_pad;
|
record->action = action;
|
record->action = action;
|
|
|
VEC_safe_push (call_site_record, gc,
|
VEC_safe_push (call_site_record, gc,
|
crtl->eh.call_site_record[section], record);
|
crtl->eh.call_site_record[section], record);
|
|
|
return call_site_base + VEC_length (call_site_record,
|
return call_site_base + VEC_length (call_site_record,
|
crtl->eh.call_site_record[section]) - 1;
|
crtl->eh.call_site_record[section]) - 1;
|
}
|
}
|
|
|
/* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes.
|
/* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes.
|
The new note numbers will not refer to region numbers, but
|
The new note numbers will not refer to region numbers, but
|
instead to call site entries. */
|
instead to call site entries. */
|
|
|
static unsigned int
|
static unsigned int
|
convert_to_eh_region_ranges (void)
|
convert_to_eh_region_ranges (void)
|
{
|
{
|
rtx insn, iter, note;
|
rtx insn, iter, note;
|
htab_t ar_hash;
|
htab_t ar_hash;
|
int last_action = -3;
|
int last_action = -3;
|
rtx last_action_insn = NULL_RTX;
|
rtx last_action_insn = NULL_RTX;
|
rtx last_landing_pad = NULL_RTX;
|
rtx last_landing_pad = NULL_RTX;
|
rtx first_no_action_insn = NULL_RTX;
|
rtx first_no_action_insn = NULL_RTX;
|
int call_site = 0;
|
int call_site = 0;
|
int cur_sec = 0;
|
int cur_sec = 0;
|
rtx section_switch_note = NULL_RTX;
|
rtx section_switch_note = NULL_RTX;
|
rtx first_no_action_insn_before_switch = NULL_RTX;
|
rtx first_no_action_insn_before_switch = NULL_RTX;
|
rtx last_no_action_insn_before_switch = NULL_RTX;
|
rtx last_no_action_insn_before_switch = NULL_RTX;
|
rtx *pad_map = NULL;
|
rtx *pad_map = NULL;
|
sbitmap pad_loc = NULL;
|
sbitmap pad_loc = NULL;
|
int min_labelno = 0, max_labelno = 0;
|
int min_labelno = 0, max_labelno = 0;
|
int saved_call_site_base = call_site_base;
|
int saved_call_site_base = call_site_base;
|
|
|
crtl->eh.action_record_data = VEC_alloc (uchar, gc, 64);
|
crtl->eh.action_record_data = VEC_alloc (uchar, gc, 64);
|
|
|
ar_hash = htab_create (31, action_record_hash, action_record_eq, free);
|
ar_hash = htab_create (31, action_record_hash, action_record_eq, free);
|
|
|
for (iter = get_insns (); iter ; iter = NEXT_INSN (iter))
|
for (iter = get_insns (); iter ; iter = NEXT_INSN (iter))
|
if (INSN_P (iter))
|
if (INSN_P (iter))
|
{
|
{
|
eh_landing_pad lp;
|
eh_landing_pad lp;
|
eh_region region;
|
eh_region region;
|
bool nothrow;
|
bool nothrow;
|
int this_action;
|
int this_action;
|
rtx this_landing_pad;
|
rtx this_landing_pad;
|
|
|
insn = iter;
|
insn = iter;
|
if (NONJUMP_INSN_P (insn)
|
if (NONJUMP_INSN_P (insn)
|
&& GET_CODE (PATTERN (insn)) == SEQUENCE)
|
&& GET_CODE (PATTERN (insn)) == SEQUENCE)
|
insn = XVECEXP (PATTERN (insn), 0, 0);
|
insn = XVECEXP (PATTERN (insn), 0, 0);
|
|
|
nothrow = get_eh_region_and_lp_from_rtx (insn, ®ion, &lp);
|
nothrow = get_eh_region_and_lp_from_rtx (insn, ®ion, &lp);
|
if (nothrow)
|
if (nothrow)
|
continue;
|
continue;
|
if (region)
|
if (region)
|
this_action = collect_one_action_chain (ar_hash, region);
|
this_action = collect_one_action_chain (ar_hash, region);
|
else
|
else
|
this_action = -1;
|
this_action = -1;
|
|
|
/* Existence of catch handlers, or must-not-throw regions
|
/* Existence of catch handlers, or must-not-throw regions
|
implies that an lsda is needed (even if empty). */
|
implies that an lsda is needed (even if empty). */
|
if (this_action != -1)
|
if (this_action != -1)
|
crtl->uses_eh_lsda = 1;
|
crtl->uses_eh_lsda = 1;
|
|
|
/* Delay creation of region notes for no-action regions
|
/* Delay creation of region notes for no-action regions
|
until we're sure that an lsda will be required. */
|
until we're sure that an lsda will be required. */
|
else if (last_action == -3)
|
else if (last_action == -3)
|
{
|
{
|
first_no_action_insn = iter;
|
first_no_action_insn = iter;
|
last_action = -1;
|
last_action = -1;
|
}
|
}
|
|
|
if (this_action >= 0)
|
if (this_action >= 0)
|
this_landing_pad = lp->landing_pad;
|
this_landing_pad = lp->landing_pad;
|
else
|
else
|
this_landing_pad = NULL_RTX;
|
this_landing_pad = NULL_RTX;
|
|
|
/* Differing actions or landing pads implies a change in call-site
|
/* Differing actions or landing pads implies a change in call-site
|
info, which implies some EH_REGION note should be emitted. */
|
info, which implies some EH_REGION note should be emitted. */
|
if (last_action != this_action
|
if (last_action != this_action
|
|| last_landing_pad != this_landing_pad)
|
|| last_landing_pad != this_landing_pad)
|
{
|
{
|
/* If we'd not seen a previous action (-3) or the previous
|
/* If we'd not seen a previous action (-3) or the previous
|
action was must-not-throw (-2), then we do not need an
|
action was must-not-throw (-2), then we do not need an
|
end note. */
|
end note. */
|
if (last_action >= -1)
|
if (last_action >= -1)
|
{
|
{
|
/* If we delayed the creation of the begin, do it now. */
|
/* If we delayed the creation of the begin, do it now. */
|
if (first_no_action_insn_before_switch)
|
if (first_no_action_insn_before_switch)
|
{
|
{
|
call_site = add_call_site (NULL_RTX, 0, 0);
|
call_site = add_call_site (NULL_RTX, 0, 0);
|
note
|
note
|
= emit_note_before (NOTE_INSN_EH_REGION_BEG,
|
= emit_note_before (NOTE_INSN_EH_REGION_BEG,
|
first_no_action_insn_before_switch);
|
first_no_action_insn_before_switch);
|
NOTE_EH_HANDLER (note) = call_site;
|
NOTE_EH_HANDLER (note) = call_site;
|
if (first_no_action_insn)
|
if (first_no_action_insn)
|
{
|
{
|
note
|
note
|
= emit_note_after (NOTE_INSN_EH_REGION_END,
|
= emit_note_after (NOTE_INSN_EH_REGION_END,
|
last_no_action_insn_before_switch);
|
last_no_action_insn_before_switch);
|
NOTE_EH_HANDLER (note) = call_site;
|
NOTE_EH_HANDLER (note) = call_site;
|
}
|
}
|
else
|
else
|
gcc_assert (last_action_insn
|
gcc_assert (last_action_insn
|
== last_no_action_insn_before_switch);
|
== last_no_action_insn_before_switch);
|
}
|
}
|
if (first_no_action_insn)
|
if (first_no_action_insn)
|
{
|
{
|
call_site = add_call_site (NULL_RTX, 0, cur_sec);
|
call_site = add_call_site (NULL_RTX, 0, cur_sec);
|
note = emit_note_before (NOTE_INSN_EH_REGION_BEG,
|
note = emit_note_before (NOTE_INSN_EH_REGION_BEG,
|
first_no_action_insn);
|
first_no_action_insn);
|
NOTE_EH_HANDLER (note) = call_site;
|
NOTE_EH_HANDLER (note) = call_site;
|
first_no_action_insn = NULL_RTX;
|
first_no_action_insn = NULL_RTX;
|
}
|
}
|
|
|
note = emit_note_after (NOTE_INSN_EH_REGION_END,
|
note = emit_note_after (NOTE_INSN_EH_REGION_END,
|
last_action_insn);
|
last_action_insn);
|
NOTE_EH_HANDLER (note) = call_site;
|
NOTE_EH_HANDLER (note) = call_site;
|
}
|
}
|
|
|
/* If the new action is must-not-throw, then no region notes
|
/* If the new action is must-not-throw, then no region notes
|
are created. */
|
are created. */
|
if (this_action >= -1)
|
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,
|
this_action < 0 ? 0 : this_action,
|
cur_sec);
|
cur_sec);
|
note = emit_note_before (NOTE_INSN_EH_REGION_BEG, iter);
|
note = emit_note_before (NOTE_INSN_EH_REGION_BEG, iter);
|
NOTE_EH_HANDLER (note) = call_site;
|
NOTE_EH_HANDLER (note) = call_site;
|
}
|
}
|
|
|
last_action = this_action;
|
last_action = this_action;
|
last_landing_pad = this_landing_pad;
|
last_landing_pad = this_landing_pad;
|
}
|
}
|
last_action_insn = iter;
|
last_action_insn = iter;
|
}
|
}
|
else if (NOTE_P (iter)
|
else if (NOTE_P (iter)
|
&& NOTE_KIND (iter) == NOTE_INSN_SWITCH_TEXT_SECTIONS)
|
&& NOTE_KIND (iter) == NOTE_INSN_SWITCH_TEXT_SECTIONS)
|
{
|
{
|
gcc_assert (section_switch_note == NULL_RTX);
|
gcc_assert (section_switch_note == NULL_RTX);
|
gcc_assert (flag_reorder_blocks_and_partition);
|
gcc_assert (flag_reorder_blocks_and_partition);
|
section_switch_note = iter;
|
section_switch_note = iter;
|
if (first_no_action_insn)
|
if (first_no_action_insn)
|
{
|
{
|
first_no_action_insn_before_switch = first_no_action_insn;
|
first_no_action_insn_before_switch = first_no_action_insn;
|
last_no_action_insn_before_switch = last_action_insn;
|
last_no_action_insn_before_switch = last_action_insn;
|
first_no_action_insn = NULL_RTX;
|
first_no_action_insn = NULL_RTX;
|
gcc_assert (last_action == -1);
|
gcc_assert (last_action == -1);
|
last_action = -3;
|
last_action = -3;
|
}
|
}
|
/* Force closing of current EH region before section switch and
|
/* Force closing of current EH region before section switch and
|
opening a new one afterwards. */
|
opening a new one afterwards. */
|
else if (last_action != -3)
|
else if (last_action != -3)
|
last_landing_pad = pc_rtx;
|
last_landing_pad = pc_rtx;
|
call_site_base += VEC_length (call_site_record,
|
call_site_base += VEC_length (call_site_record,
|
crtl->eh.call_site_record[cur_sec]);
|
crtl->eh.call_site_record[cur_sec]);
|
cur_sec++;
|
cur_sec++;
|
gcc_assert (crtl->eh.call_site_record[cur_sec] == NULL);
|
gcc_assert (crtl->eh.call_site_record[cur_sec] == NULL);
|
crtl->eh.call_site_record[cur_sec]
|
crtl->eh.call_site_record[cur_sec]
|
= VEC_alloc (call_site_record, gc, 10);
|
= VEC_alloc (call_site_record, gc, 10);
|
max_labelno = max_label_num ();
|
max_labelno = max_label_num ();
|
min_labelno = get_first_label_num ();
|
min_labelno = get_first_label_num ();
|
pad_map = XCNEWVEC (rtx, max_labelno - min_labelno + 1);
|
pad_map = XCNEWVEC (rtx, max_labelno - min_labelno + 1);
|
pad_loc = sbitmap_alloc (max_labelno - min_labelno + 1);
|
pad_loc = sbitmap_alloc (max_labelno - min_labelno + 1);
|
}
|
}
|
else if (LABEL_P (iter) && pad_map)
|
else if (LABEL_P (iter) && pad_map)
|
SET_BIT (pad_loc, CODE_LABEL_NUMBER (iter) - min_labelno);
|
SET_BIT (pad_loc, CODE_LABEL_NUMBER (iter) - min_labelno);
|
|
|
if (last_action >= -1 && ! first_no_action_insn)
|
if (last_action >= -1 && ! first_no_action_insn)
|
{
|
{
|
note = emit_note_after (NOTE_INSN_EH_REGION_END, last_action_insn);
|
note = emit_note_after (NOTE_INSN_EH_REGION_END, last_action_insn);
|
NOTE_EH_HANDLER (note) = call_site;
|
NOTE_EH_HANDLER (note) = call_site;
|
}
|
}
|
|
|
call_site_base = saved_call_site_base;
|
call_site_base = saved_call_site_base;
|
|
|
if (pad_map)
|
if (pad_map)
|
{
|
{
|
/* When doing hot/cold partitioning, ensure landing pads are
|
/* When doing hot/cold partitioning, ensure landing pads are
|
always in the same section as the EH region, .gcc_except_table
|
always in the same section as the EH region, .gcc_except_table
|
can't express it otherwise. */
|
can't express it otherwise. */
|
for (cur_sec = 0; cur_sec < 2; cur_sec++)
|
for (cur_sec = 0; cur_sec < 2; cur_sec++)
|
{
|
{
|
int i, idx;
|
int i, idx;
|
int n = VEC_length (call_site_record,
|
int n = VEC_length (call_site_record,
|
crtl->eh.call_site_record[cur_sec]);
|
crtl->eh.call_site_record[cur_sec]);
|
basic_block prev_bb = NULL, padbb;
|
basic_block prev_bb = NULL, padbb;
|
|
|
for (i = 0; i < n; ++i)
|
for (i = 0; i < n; ++i)
|
{
|
{
|
struct call_site_record_d *cs =
|
struct call_site_record_d *cs =
|
VEC_index (call_site_record,
|
VEC_index (call_site_record,
|
crtl->eh.call_site_record[cur_sec], i);
|
crtl->eh.call_site_record[cur_sec], i);
|
rtx jump, note;
|
rtx jump, note;
|
|
|
if (cs->landing_pad == NULL_RTX)
|
if (cs->landing_pad == NULL_RTX)
|
continue;
|
continue;
|
idx = CODE_LABEL_NUMBER (cs->landing_pad) - min_labelno;
|
idx = CODE_LABEL_NUMBER (cs->landing_pad) - min_labelno;
|
/* If the landing pad is in the correct section, nothing
|
/* If the landing pad is in the correct section, nothing
|
is needed. */
|
is needed. */
|
if (TEST_BIT (pad_loc, idx) ^ (cur_sec == 0))
|
if (TEST_BIT (pad_loc, idx) ^ (cur_sec == 0))
|
continue;
|
continue;
|
/* Otherwise, if we haven't seen this pad yet, we need to
|
/* Otherwise, if we haven't seen this pad yet, we need to
|
add a new label and jump to the correct section. */
|
add a new label and jump to the correct section. */
|
if (pad_map[idx] == NULL_RTX)
|
if (pad_map[idx] == NULL_RTX)
|
{
|
{
|
pad_map[idx] = gen_label_rtx ();
|
pad_map[idx] = gen_label_rtx ();
|
if (prev_bb == NULL)
|
if (prev_bb == NULL)
|
for (iter = section_switch_note;
|
for (iter = section_switch_note;
|
iter; iter = PREV_INSN (iter))
|
iter; iter = PREV_INSN (iter))
|
if (NOTE_INSN_BASIC_BLOCK_P (iter))
|
if (NOTE_INSN_BASIC_BLOCK_P (iter))
|
{
|
{
|
prev_bb = NOTE_BASIC_BLOCK (iter);
|
prev_bb = NOTE_BASIC_BLOCK (iter);
|
break;
|
break;
|
}
|
}
|
if (cur_sec == 0)
|
if (cur_sec == 0)
|
{
|
{
|
note = emit_label_before (pad_map[idx],
|
note = emit_label_before (pad_map[idx],
|
section_switch_note);
|
section_switch_note);
|
jump = emit_jump_insn_before (gen_jump (cs->landing_pad),
|
jump = emit_jump_insn_before (gen_jump (cs->landing_pad),
|
section_switch_note);
|
section_switch_note);
|
}
|
}
|
else
|
else
|
{
|
{
|
jump = emit_jump_insn_after (gen_jump (cs->landing_pad),
|
jump = emit_jump_insn_after (gen_jump (cs->landing_pad),
|
section_switch_note);
|
section_switch_note);
|
note = emit_label_after (pad_map[idx],
|
note = emit_label_after (pad_map[idx],
|
section_switch_note);
|
section_switch_note);
|
}
|
}
|
JUMP_LABEL (jump) = cs->landing_pad;
|
JUMP_LABEL (jump) = cs->landing_pad;
|
add_reg_note (jump, REG_CROSSING_JUMP, NULL_RTX);
|
add_reg_note (jump, REG_CROSSING_JUMP, NULL_RTX);
|
iter = NEXT_INSN (cs->landing_pad);
|
iter = NEXT_INSN (cs->landing_pad);
|
if (iter && NOTE_INSN_BASIC_BLOCK_P (iter))
|
if (iter && NOTE_INSN_BASIC_BLOCK_P (iter))
|
padbb = NOTE_BASIC_BLOCK (iter);
|
padbb = NOTE_BASIC_BLOCK (iter);
|
else
|
else
|
padbb = NULL;
|
padbb = NULL;
|
if (padbb && prev_bb
|
if (padbb && prev_bb
|
&& BB_PARTITION (padbb) != BB_UNPARTITIONED)
|
&& BB_PARTITION (padbb) != BB_UNPARTITIONED)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
int part
|
int part
|
= BB_PARTITION (padbb) == BB_COLD_PARTITION
|
= BB_PARTITION (padbb) == BB_COLD_PARTITION
|
? BB_HOT_PARTITION : BB_COLD_PARTITION;
|
? BB_HOT_PARTITION : BB_COLD_PARTITION;
|
edge_iterator ei;
|
edge_iterator ei;
|
edge e;
|
edge e;
|
|
|
bb = create_basic_block (note, jump, prev_bb);
|
bb = create_basic_block (note, jump, prev_bb);
|
make_single_succ_edge (bb, padbb, EDGE_CROSSING);
|
make_single_succ_edge (bb, padbb, EDGE_CROSSING);
|
BB_SET_PARTITION (bb, part);
|
BB_SET_PARTITION (bb, part);
|
for (ei = ei_start (padbb->preds);
|
for (ei = ei_start (padbb->preds);
|
(e = ei_safe_edge (ei)); )
|
(e = ei_safe_edge (ei)); )
|
{
|
{
|
if ((e->flags & (EDGE_EH|EDGE_CROSSING))
|
if ((e->flags & (EDGE_EH|EDGE_CROSSING))
|
== (EDGE_EH|EDGE_CROSSING))
|
== (EDGE_EH|EDGE_CROSSING))
|
{
|
{
|
redirect_edge_succ (e, bb);
|
redirect_edge_succ (e, bb);
|
e->flags &= ~EDGE_CROSSING;
|
e->flags &= ~EDGE_CROSSING;
|
}
|
}
|
else
|
else
|
ei_next (&ei);
|
ei_next (&ei);
|
}
|
}
|
if (cur_sec == 0)
|
if (cur_sec == 0)
|
prev_bb = bb;
|
prev_bb = bb;
|
}
|
}
|
}
|
}
|
cs->landing_pad = pad_map[idx];
|
cs->landing_pad = pad_map[idx];
|
}
|
}
|
}
|
}
|
|
|
sbitmap_free (pad_loc);
|
sbitmap_free (pad_loc);
|
XDELETEVEC (pad_map);
|
XDELETEVEC (pad_map);
|
}
|
}
|
|
|
htab_delete (ar_hash);
|
htab_delete (ar_hash);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static bool
|
static bool
|
gate_convert_to_eh_region_ranges (void)
|
gate_convert_to_eh_region_ranges (void)
|
{
|
{
|
/* Nothing to do for SJLJ exceptions or if no regions created. */
|
/* Nothing to do for SJLJ exceptions or if no regions created. */
|
return !(USING_SJLJ_EXCEPTIONS || cfun->eh->region_tree == NULL);
|
return !(USING_SJLJ_EXCEPTIONS || cfun->eh->region_tree == NULL);
|
}
|
}
|
|
|
struct rtl_opt_pass pass_convert_to_eh_region_ranges =
|
struct rtl_opt_pass pass_convert_to_eh_region_ranges =
|
{
|
{
|
{
|
{
|
RTL_PASS,
|
RTL_PASS,
|
"eh_ranges", /* name */
|
"eh_ranges", /* name */
|
gate_convert_to_eh_region_ranges, /* gate */
|
gate_convert_to_eh_region_ranges, /* gate */
|
convert_to_eh_region_ranges, /* execute */
|
convert_to_eh_region_ranges, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_NONE, /* tv_id */
|
TV_NONE, /* tv_id */
|
0, /* properties_required */
|
0, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
TODO_dump_func, /* todo_flags_finish */
|
TODO_dump_func, /* todo_flags_finish */
|
}
|
}
|
};
|
};
|
|
|
static void
|
static void
|
push_uleb128 (VEC (uchar, gc) **data_area, unsigned int value)
|
push_uleb128 (VEC (uchar, gc) **data_area, unsigned int value)
|
{
|
{
|
do
|
do
|
{
|
{
|
unsigned char byte = value & 0x7f;
|
unsigned char byte = value & 0x7f;
|
value >>= 7;
|
value >>= 7;
|
if (value)
|
if (value)
|
byte |= 0x80;
|
byte |= 0x80;
|
VEC_safe_push (uchar, gc, *data_area, byte);
|
VEC_safe_push (uchar, gc, *data_area, byte);
|
}
|
}
|
while (value);
|
while (value);
|
}
|
}
|
|
|
static void
|
static void
|
push_sleb128 (VEC (uchar, gc) **data_area, int value)
|
push_sleb128 (VEC (uchar, gc) **data_area, int value)
|
{
|
{
|
unsigned char byte;
|
unsigned char byte;
|
int more;
|
int more;
|
|
|
do
|
do
|
{
|
{
|
byte = value & 0x7f;
|
byte = value & 0x7f;
|
value >>= 7;
|
value >>= 7;
|
more = ! ((value == 0 && (byte & 0x40) == 0)
|
more = ! ((value == 0 && (byte & 0x40) == 0)
|
|| (value == -1 && (byte & 0x40) != 0));
|
|| (value == -1 && (byte & 0x40) != 0));
|
if (more)
|
if (more)
|
byte |= 0x80;
|
byte |= 0x80;
|
VEC_safe_push (uchar, gc, *data_area, byte);
|
VEC_safe_push (uchar, gc, *data_area, byte);
|
}
|
}
|
while (more);
|
while (more);
|
}
|
}
|
|
|
|
|
#ifndef HAVE_AS_LEB128
|
#ifndef HAVE_AS_LEB128
|
static int
|
static int
|
dw2_size_of_call_site_table (int section)
|
dw2_size_of_call_site_table (int section)
|
{
|
{
|
int n = VEC_length (call_site_record, crtl->eh.call_site_record[section]);
|
int n = VEC_length (call_site_record, crtl->eh.call_site_record[section]);
|
int size = n * (4 + 4 + 4);
|
int size = n * (4 + 4 + 4);
|
int i;
|
int i;
|
|
|
for (i = 0; i < n; ++i)
|
for (i = 0; i < n; ++i)
|
{
|
{
|
struct call_site_record_d *cs =
|
struct call_site_record_d *cs =
|
VEC_index (call_site_record, crtl->eh.call_site_record[section], i);
|
VEC_index (call_site_record, crtl->eh.call_site_record[section], i);
|
size += size_of_uleb128 (cs->action);
|
size += size_of_uleb128 (cs->action);
|
}
|
}
|
|
|
return size;
|
return size;
|
}
|
}
|
|
|
static int
|
static int
|
sjlj_size_of_call_site_table (void)
|
sjlj_size_of_call_site_table (void)
|
{
|
{
|
int n = VEC_length (call_site_record, crtl->eh.call_site_record[0]);
|
int n = VEC_length (call_site_record, crtl->eh.call_site_record[0]);
|
int size = 0;
|
int size = 0;
|
int i;
|
int i;
|
|
|
for (i = 0; i < n; ++i)
|
for (i = 0; i < n; ++i)
|
{
|
{
|
struct call_site_record_d *cs =
|
struct call_site_record_d *cs =
|
VEC_index (call_site_record, crtl->eh.call_site_record[0], i);
|
VEC_index (call_site_record, crtl->eh.call_site_record[0], i);
|
size += size_of_uleb128 (INTVAL (cs->landing_pad));
|
size += size_of_uleb128 (INTVAL (cs->landing_pad));
|
size += size_of_uleb128 (cs->action);
|
size += size_of_uleb128 (cs->action);
|
}
|
}
|
|
|
return size;
|
return size;
|
}
|
}
|
#endif
|
#endif
|
|
|
static void
|
static void
|
dw2_output_call_site_table (int cs_format, int section)
|
dw2_output_call_site_table (int cs_format, int section)
|
{
|
{
|
int n = VEC_length (call_site_record, crtl->eh.call_site_record[section]);
|
int n = VEC_length (call_site_record, crtl->eh.call_site_record[section]);
|
int i;
|
int i;
|
const char *begin;
|
const char *begin;
|
|
|
if (section == 0)
|
if (section == 0)
|
begin = current_function_func_begin_label;
|
begin = current_function_func_begin_label;
|
else if (first_function_block_is_cold)
|
else if (first_function_block_is_cold)
|
begin = crtl->subsections.hot_section_label;
|
begin = crtl->subsections.hot_section_label;
|
else
|
else
|
begin = crtl->subsections.cold_section_label;
|
begin = crtl->subsections.cold_section_label;
|
|
|
for (i = 0; i < n; ++i)
|
for (i = 0; i < n; ++i)
|
{
|
{
|
struct call_site_record_d *cs =
|
struct call_site_record_d *cs =
|
VEC_index (call_site_record, crtl->eh.call_site_record[section], i);
|
VEC_index (call_site_record, crtl->eh.call_site_record[section], i);
|
char reg_start_lab[32];
|
char reg_start_lab[32];
|
char reg_end_lab[32];
|
char reg_end_lab[32];
|
char landing_pad_lab[32];
|
char landing_pad_lab[32];
|
|
|
ASM_GENERATE_INTERNAL_LABEL (reg_start_lab, "LEHB", call_site_base + i);
|
ASM_GENERATE_INTERNAL_LABEL (reg_start_lab, "LEHB", call_site_base + i);
|
ASM_GENERATE_INTERNAL_LABEL (reg_end_lab, "LEHE", call_site_base + i);
|
ASM_GENERATE_INTERNAL_LABEL (reg_end_lab, "LEHE", call_site_base + i);
|
|
|
if (cs->landing_pad)
|
if (cs->landing_pad)
|
ASM_GENERATE_INTERNAL_LABEL (landing_pad_lab, "L",
|
ASM_GENERATE_INTERNAL_LABEL (landing_pad_lab, "L",
|
CODE_LABEL_NUMBER (cs->landing_pad));
|
CODE_LABEL_NUMBER (cs->landing_pad));
|
|
|
/* ??? Perhaps use insn length scaling if the assembler supports
|
/* ??? Perhaps use insn length scaling if the assembler supports
|
generic arithmetic. */
|
generic arithmetic. */
|
/* ??? Perhaps use attr_length to choose data1 or data2 instead of
|
/* ??? Perhaps use attr_length to choose data1 or data2 instead of
|
data4 if the function is small enough. */
|
data4 if the function is small enough. */
|
if (cs_format == DW_EH_PE_uleb128)
|
if (cs_format == DW_EH_PE_uleb128)
|
{
|
{
|
dw2_asm_output_delta_uleb128 (reg_start_lab, begin,
|
dw2_asm_output_delta_uleb128 (reg_start_lab, begin,
|
"region %d start", i);
|
"region %d start", i);
|
dw2_asm_output_delta_uleb128 (reg_end_lab, reg_start_lab,
|
dw2_asm_output_delta_uleb128 (reg_end_lab, reg_start_lab,
|
"length");
|
"length");
|
if (cs->landing_pad)
|
if (cs->landing_pad)
|
dw2_asm_output_delta_uleb128 (landing_pad_lab, begin,
|
dw2_asm_output_delta_uleb128 (landing_pad_lab, begin,
|
"landing pad");
|
"landing pad");
|
else
|
else
|
dw2_asm_output_data_uleb128 (0, "landing pad");
|
dw2_asm_output_data_uleb128 (0, "landing pad");
|
}
|
}
|
else
|
else
|
{
|
{
|
dw2_asm_output_delta (4, reg_start_lab, begin,
|
dw2_asm_output_delta (4, reg_start_lab, begin,
|
"region %d start", i);
|
"region %d start", i);
|
dw2_asm_output_delta (4, reg_end_lab, reg_start_lab, "length");
|
dw2_asm_output_delta (4, reg_end_lab, reg_start_lab, "length");
|
if (cs->landing_pad)
|
if (cs->landing_pad)
|
dw2_asm_output_delta (4, landing_pad_lab, begin,
|
dw2_asm_output_delta (4, landing_pad_lab, begin,
|
"landing pad");
|
"landing pad");
|
else
|
else
|
dw2_asm_output_data (4, 0, "landing pad");
|
dw2_asm_output_data (4, 0, "landing pad");
|
}
|
}
|
dw2_asm_output_data_uleb128 (cs->action, "action");
|
dw2_asm_output_data_uleb128 (cs->action, "action");
|
}
|
}
|
|
|
call_site_base += n;
|
call_site_base += n;
|
}
|
}
|
|
|
static void
|
static void
|
sjlj_output_call_site_table (void)
|
sjlj_output_call_site_table (void)
|
{
|
{
|
int n = VEC_length (call_site_record, crtl->eh.call_site_record[0]);
|
int n = VEC_length (call_site_record, crtl->eh.call_site_record[0]);
|
int i;
|
int i;
|
|
|
for (i = 0; i < n; ++i)
|
for (i = 0; i < n; ++i)
|
{
|
{
|
struct call_site_record_d *cs =
|
struct call_site_record_d *cs =
|
VEC_index (call_site_record, crtl->eh.call_site_record[0], i);
|
VEC_index (call_site_record, crtl->eh.call_site_record[0], i);
|
|
|
dw2_asm_output_data_uleb128 (INTVAL (cs->landing_pad),
|
dw2_asm_output_data_uleb128 (INTVAL (cs->landing_pad),
|
"region %d landing pad", i);
|
"region %d landing pad", i);
|
dw2_asm_output_data_uleb128 (cs->action, "action");
|
dw2_asm_output_data_uleb128 (cs->action, "action");
|
}
|
}
|
|
|
call_site_base += n;
|
call_site_base += n;
|
}
|
}
|
|
|
#ifndef TARGET_UNWIND_INFO
|
#ifndef TARGET_UNWIND_INFO
|
/* Switch to the section that should be used for exception tables. */
|
/* Switch to the section that should be used for exception tables. */
|
|
|
static void
|
static void
|
switch_to_exception_section (const char * ARG_UNUSED (fnname))
|
switch_to_exception_section (const char * ARG_UNUSED (fnname))
|
{
|
{
|
section *s;
|
section *s;
|
|
|
if (exception_section)
|
if (exception_section)
|
s = exception_section;
|
s = exception_section;
|
else
|
else
|
{
|
{
|
/* Compute the section and cache it into exception_section,
|
/* Compute the section and cache it into exception_section,
|
unless it depends on the function name. */
|
unless it depends on the function name. */
|
if (targetm.have_named_sections)
|
if (targetm.have_named_sections)
|
{
|
{
|
int flags;
|
int flags;
|
|
|
if (EH_TABLES_CAN_BE_READ_ONLY)
|
if (EH_TABLES_CAN_BE_READ_ONLY)
|
{
|
{
|
int tt_format =
|
int tt_format =
|
ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
|
ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
|
flags = ((! flag_pic
|
flags = ((! flag_pic
|
|| ((tt_format & 0x70) != DW_EH_PE_absptr
|
|| ((tt_format & 0x70) != DW_EH_PE_absptr
|
&& (tt_format & 0x70) != DW_EH_PE_aligned))
|
&& (tt_format & 0x70) != DW_EH_PE_aligned))
|
? 0 : SECTION_WRITE);
|
? 0 : SECTION_WRITE);
|
}
|
}
|
else
|
else
|
flags = SECTION_WRITE;
|
flags = SECTION_WRITE;
|
|
|
#ifdef HAVE_LD_EH_GC_SECTIONS
|
#ifdef HAVE_LD_EH_GC_SECTIONS
|
if (flag_function_sections)
|
if (flag_function_sections)
|
{
|
{
|
char *section_name = XNEWVEC (char, strlen (fnname) + 32);
|
char *section_name = XNEWVEC (char, strlen (fnname) + 32);
|
sprintf (section_name, ".gcc_except_table.%s", fnname);
|
sprintf (section_name, ".gcc_except_table.%s", fnname);
|
s = get_section (section_name, flags, NULL);
|
s = get_section (section_name, flags, NULL);
|
free (section_name);
|
free (section_name);
|
}
|
}
|
else
|
else
|
#endif
|
#endif
|
exception_section
|
exception_section
|
= s = get_section (".gcc_except_table", flags, NULL);
|
= s = get_section (".gcc_except_table", flags, NULL);
|
}
|
}
|
else
|
else
|
exception_section
|
exception_section
|
= s = flag_pic ? data_section : readonly_data_section;
|
= s = flag_pic ? data_section : readonly_data_section;
|
}
|
}
|
|
|
switch_to_section (s);
|
switch_to_section (s);
|
}
|
}
|
#endif
|
#endif
|
|
|
|
|
/* Output a reference from an exception table to the type_info object TYPE.
|
/* Output a reference from an exception table to the type_info object TYPE.
|
TT_FORMAT and TT_FORMAT_SIZE describe the DWARF encoding method used for
|
TT_FORMAT and TT_FORMAT_SIZE describe the DWARF encoding method used for
|
the value. */
|
the value. */
|
|
|
static void
|
static void
|
output_ttype (tree type, int tt_format, int tt_format_size)
|
output_ttype (tree type, int tt_format, int tt_format_size)
|
{
|
{
|
rtx value;
|
rtx value;
|
bool is_public = true;
|
bool is_public = true;
|
|
|
if (type == NULL_TREE)
|
if (type == NULL_TREE)
|
value = const0_rtx;
|
value = const0_rtx;
|
else
|
else
|
{
|
{
|
struct varpool_node *node;
|
struct varpool_node *node;
|
|
|
/* FIXME lto. pass_ipa_free_lang_data changes all types to
|
/* FIXME lto. pass_ipa_free_lang_data changes all types to
|
runtime types so TYPE should already be a runtime type
|
runtime types so TYPE should already be a runtime type
|
reference. When pass_ipa_free_lang data is made a default
|
reference. When pass_ipa_free_lang data is made a default
|
pass, we can then remove the call to lookup_type_for_runtime
|
pass, we can then remove the call to lookup_type_for_runtime
|
below. */
|
below. */
|
if (TYPE_P (type))
|
if (TYPE_P (type))
|
type = lookup_type_for_runtime (type);
|
type = lookup_type_for_runtime (type);
|
|
|
value = expand_expr (type, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
|
value = expand_expr (type, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
|
|
|
/* Let cgraph know that the rtti decl is used. Not all of the
|
/* Let cgraph know that the rtti decl is used. Not all of the
|
paths below go through assemble_integer, which would take
|
paths below go through assemble_integer, which would take
|
care of this for us. */
|
care of this for us. */
|
STRIP_NOPS (type);
|
STRIP_NOPS (type);
|
if (TREE_CODE (type) == ADDR_EXPR)
|
if (TREE_CODE (type) == ADDR_EXPR)
|
{
|
{
|
type = TREE_OPERAND (type, 0);
|
type = TREE_OPERAND (type, 0);
|
if (TREE_CODE (type) == VAR_DECL)
|
if (TREE_CODE (type) == VAR_DECL)
|
{
|
{
|
node = varpool_node (type);
|
node = varpool_node (type);
|
if (node)
|
if (node)
|
varpool_mark_needed_node (node);
|
varpool_mark_needed_node (node);
|
is_public = TREE_PUBLIC (type);
|
is_public = TREE_PUBLIC (type);
|
}
|
}
|
}
|
}
|
else
|
else
|
gcc_assert (TREE_CODE (type) == INTEGER_CST);
|
gcc_assert (TREE_CODE (type) == INTEGER_CST);
|
}
|
}
|
|
|
/* Allow the target to override the type table entry format. */
|
/* Allow the target to override the type table entry format. */
|
if (targetm.asm_out.ttype (value))
|
if (targetm.asm_out.ttype (value))
|
return;
|
return;
|
|
|
if (tt_format == DW_EH_PE_absptr || tt_format == DW_EH_PE_aligned)
|
if (tt_format == DW_EH_PE_absptr || tt_format == DW_EH_PE_aligned)
|
assemble_integer (value, tt_format_size,
|
assemble_integer (value, tt_format_size,
|
tt_format_size * BITS_PER_UNIT, 1);
|
tt_format_size * BITS_PER_UNIT, 1);
|
else
|
else
|
dw2_asm_output_encoded_addr_rtx (tt_format, value, is_public, NULL);
|
dw2_asm_output_encoded_addr_rtx (tt_format, value, is_public, NULL);
|
}
|
}
|
|
|
static void
|
static void
|
output_one_function_exception_table (const char * ARG_UNUSED (fnname),
|
output_one_function_exception_table (const char * ARG_UNUSED (fnname),
|
int section, rtx ARG_UNUSED (personality))
|
int section, rtx ARG_UNUSED (personality))
|
{
|
{
|
int tt_format, cs_format, lp_format, i;
|
int tt_format, cs_format, lp_format, i;
|
#ifdef HAVE_AS_LEB128
|
#ifdef HAVE_AS_LEB128
|
char ttype_label[32];
|
char ttype_label[32];
|
char cs_after_size_label[32];
|
char cs_after_size_label[32];
|
char cs_end_label[32];
|
char cs_end_label[32];
|
#else
|
#else
|
int call_site_len;
|
int call_site_len;
|
#endif
|
#endif
|
int have_tt_data;
|
int have_tt_data;
|
int tt_format_size = 0;
|
int tt_format_size = 0;
|
|
|
#ifdef TARGET_UNWIND_INFO
|
#ifdef TARGET_UNWIND_INFO
|
/* TODO: Move this into target file. */
|
/* TODO: Move this into target file. */
|
fputs ("\t.personality\t", asm_out_file);
|
fputs ("\t.personality\t", asm_out_file);
|
output_addr_const (asm_out_file, personality);
|
output_addr_const (asm_out_file, personality);
|
fputs ("\n\t.handlerdata\n", asm_out_file);
|
fputs ("\n\t.handlerdata\n", asm_out_file);
|
/* Note that varasm still thinks we're in the function's code section.
|
/* Note that varasm still thinks we're in the function's code section.
|
The ".endp" directive that will immediately follow will take us back. */
|
The ".endp" directive that will immediately follow will take us back. */
|
#else
|
#else
|
switch_to_exception_section (fnname);
|
switch_to_exception_section (fnname);
|
#endif
|
#endif
|
|
|
/* If the target wants a label to begin the table, emit it here. */
|
/* If the target wants a label to begin the table, emit it here. */
|
targetm.asm_out.except_table_label (asm_out_file);
|
targetm.asm_out.except_table_label (asm_out_file);
|
|
|
have_tt_data = (VEC_length (tree, cfun->eh->ttype_data)
|
have_tt_data = (VEC_length (tree, cfun->eh->ttype_data)
|
|| (targetm.arm_eabi_unwinder
|
|| (targetm.arm_eabi_unwinder
|
? VEC_length (tree, cfun->eh->ehspec_data.arm_eabi)
|
? VEC_length (tree, cfun->eh->ehspec_data.arm_eabi)
|
: VEC_length (uchar, cfun->eh->ehspec_data.other)));
|
: VEC_length (uchar, cfun->eh->ehspec_data.other)));
|
|
|
/* Indicate the format of the @TType entries. */
|
/* Indicate the format of the @TType entries. */
|
if (! have_tt_data)
|
if (! have_tt_data)
|
tt_format = DW_EH_PE_omit;
|
tt_format = DW_EH_PE_omit;
|
else
|
else
|
{
|
{
|
tt_format = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
|
tt_format = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
|
#ifdef HAVE_AS_LEB128
|
#ifdef HAVE_AS_LEB128
|
ASM_GENERATE_INTERNAL_LABEL (ttype_label,
|
ASM_GENERATE_INTERNAL_LABEL (ttype_label,
|
section ? "LLSDATTC" : "LLSDATT",
|
section ? "LLSDATTC" : "LLSDATT",
|
current_function_funcdef_no);
|
current_function_funcdef_no);
|
#endif
|
#endif
|
tt_format_size = size_of_encoded_value (tt_format);
|
tt_format_size = size_of_encoded_value (tt_format);
|
|
|
assemble_align (tt_format_size * BITS_PER_UNIT);
|
assemble_align (tt_format_size * BITS_PER_UNIT);
|
}
|
}
|
|
|
targetm.asm_out.internal_label (asm_out_file, section ? "LLSDAC" : "LLSDA",
|
targetm.asm_out.internal_label (asm_out_file, section ? "LLSDAC" : "LLSDA",
|
current_function_funcdef_no);
|
current_function_funcdef_no);
|
|
|
/* The LSDA header. */
|
/* The LSDA header. */
|
|
|
/* Indicate the format of the landing pad start pointer. An omitted
|
/* Indicate the format of the landing pad start pointer. An omitted
|
field implies @LPStart == @Start. */
|
field implies @LPStart == @Start. */
|
/* Currently we always put @LPStart == @Start. This field would
|
/* Currently we always put @LPStart == @Start. This field would
|
be most useful in moving the landing pads completely out of
|
be most useful in moving the landing pads completely out of
|
line to another section, but it could also be used to minimize
|
line to another section, but it could also be used to minimize
|
the size of uleb128 landing pad offsets. */
|
the size of uleb128 landing pad offsets. */
|
lp_format = DW_EH_PE_omit;
|
lp_format = DW_EH_PE_omit;
|
dw2_asm_output_data (1, lp_format, "@LPStart format (%s)",
|
dw2_asm_output_data (1, lp_format, "@LPStart format (%s)",
|
eh_data_format_name (lp_format));
|
eh_data_format_name (lp_format));
|
|
|
/* @LPStart pointer would go here. */
|
/* @LPStart pointer would go here. */
|
|
|
dw2_asm_output_data (1, tt_format, "@TType format (%s)",
|
dw2_asm_output_data (1, tt_format, "@TType format (%s)",
|
eh_data_format_name (tt_format));
|
eh_data_format_name (tt_format));
|
|
|
#ifndef HAVE_AS_LEB128
|
#ifndef HAVE_AS_LEB128
|
if (USING_SJLJ_EXCEPTIONS)
|
if (USING_SJLJ_EXCEPTIONS)
|
call_site_len = sjlj_size_of_call_site_table ();
|
call_site_len = sjlj_size_of_call_site_table ();
|
else
|
else
|
call_site_len = dw2_size_of_call_site_table (section);
|
call_site_len = dw2_size_of_call_site_table (section);
|
#endif
|
#endif
|
|
|
/* A pc-relative 4-byte displacement to the @TType data. */
|
/* A pc-relative 4-byte displacement to the @TType data. */
|
if (have_tt_data)
|
if (have_tt_data)
|
{
|
{
|
#ifdef HAVE_AS_LEB128
|
#ifdef HAVE_AS_LEB128
|
char ttype_after_disp_label[32];
|
char ttype_after_disp_label[32];
|
ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label,
|
ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label,
|
section ? "LLSDATTDC" : "LLSDATTD",
|
section ? "LLSDATTDC" : "LLSDATTD",
|
current_function_funcdef_no);
|
current_function_funcdef_no);
|
dw2_asm_output_delta_uleb128 (ttype_label, ttype_after_disp_label,
|
dw2_asm_output_delta_uleb128 (ttype_label, ttype_after_disp_label,
|
"@TType base offset");
|
"@TType base offset");
|
ASM_OUTPUT_LABEL (asm_out_file, ttype_after_disp_label);
|
ASM_OUTPUT_LABEL (asm_out_file, ttype_after_disp_label);
|
#else
|
#else
|
/* Ug. Alignment queers things. */
|
/* Ug. Alignment queers things. */
|
unsigned int before_disp, after_disp, last_disp, disp;
|
unsigned int before_disp, after_disp, last_disp, disp;
|
|
|
before_disp = 1 + 1;
|
before_disp = 1 + 1;
|
after_disp = (1 + size_of_uleb128 (call_site_len)
|
after_disp = (1 + size_of_uleb128 (call_site_len)
|
+ call_site_len
|
+ call_site_len
|
+ VEC_length (uchar, crtl->eh.action_record_data)
|
+ VEC_length (uchar, crtl->eh.action_record_data)
|
+ (VEC_length (tree, cfun->eh->ttype_data)
|
+ (VEC_length (tree, cfun->eh->ttype_data)
|
* tt_format_size));
|
* tt_format_size));
|
|
|
disp = after_disp;
|
disp = after_disp;
|
do
|
do
|
{
|
{
|
unsigned int disp_size, pad;
|
unsigned int disp_size, pad;
|
|
|
last_disp = disp;
|
last_disp = disp;
|
disp_size = size_of_uleb128 (disp);
|
disp_size = size_of_uleb128 (disp);
|
pad = before_disp + disp_size + after_disp;
|
pad = before_disp + disp_size + after_disp;
|
if (pad % tt_format_size)
|
if (pad % tt_format_size)
|
pad = tt_format_size - (pad % tt_format_size);
|
pad = tt_format_size - (pad % tt_format_size);
|
else
|
else
|
pad = 0;
|
pad = 0;
|
disp = after_disp + pad;
|
disp = after_disp + pad;
|
}
|
}
|
while (disp != last_disp);
|
while (disp != last_disp);
|
|
|
dw2_asm_output_data_uleb128 (disp, "@TType base offset");
|
dw2_asm_output_data_uleb128 (disp, "@TType base offset");
|
#endif
|
#endif
|
}
|
}
|
|
|
/* Indicate the format of the call-site offsets. */
|
/* Indicate the format of the call-site offsets. */
|
#ifdef HAVE_AS_LEB128
|
#ifdef HAVE_AS_LEB128
|
cs_format = DW_EH_PE_uleb128;
|
cs_format = DW_EH_PE_uleb128;
|
#else
|
#else
|
cs_format = DW_EH_PE_udata4;
|
cs_format = DW_EH_PE_udata4;
|
#endif
|
#endif
|
dw2_asm_output_data (1, cs_format, "call-site format (%s)",
|
dw2_asm_output_data (1, cs_format, "call-site format (%s)",
|
eh_data_format_name (cs_format));
|
eh_data_format_name (cs_format));
|
|
|
#ifdef HAVE_AS_LEB128
|
#ifdef HAVE_AS_LEB128
|
ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label,
|
ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label,
|
section ? "LLSDACSBC" : "LLSDACSB",
|
section ? "LLSDACSBC" : "LLSDACSB",
|
current_function_funcdef_no);
|
current_function_funcdef_no);
|
ASM_GENERATE_INTERNAL_LABEL (cs_end_label,
|
ASM_GENERATE_INTERNAL_LABEL (cs_end_label,
|
section ? "LLSDACSEC" : "LLSDACSE",
|
section ? "LLSDACSEC" : "LLSDACSE",
|
current_function_funcdef_no);
|
current_function_funcdef_no);
|
dw2_asm_output_delta_uleb128 (cs_end_label, cs_after_size_label,
|
dw2_asm_output_delta_uleb128 (cs_end_label, cs_after_size_label,
|
"Call-site table length");
|
"Call-site table length");
|
ASM_OUTPUT_LABEL (asm_out_file, cs_after_size_label);
|
ASM_OUTPUT_LABEL (asm_out_file, cs_after_size_label);
|
if (USING_SJLJ_EXCEPTIONS)
|
if (USING_SJLJ_EXCEPTIONS)
|
sjlj_output_call_site_table ();
|
sjlj_output_call_site_table ();
|
else
|
else
|
dw2_output_call_site_table (cs_format, section);
|
dw2_output_call_site_table (cs_format, section);
|
ASM_OUTPUT_LABEL (asm_out_file, cs_end_label);
|
ASM_OUTPUT_LABEL (asm_out_file, cs_end_label);
|
#else
|
#else
|
dw2_asm_output_data_uleb128 (call_site_len, "Call-site table length");
|
dw2_asm_output_data_uleb128 (call_site_len, "Call-site table length");
|
if (USING_SJLJ_EXCEPTIONS)
|
if (USING_SJLJ_EXCEPTIONS)
|
sjlj_output_call_site_table ();
|
sjlj_output_call_site_table ();
|
else
|
else
|
dw2_output_call_site_table (cs_format, section);
|
dw2_output_call_site_table (cs_format, section);
|
#endif
|
#endif
|
|
|
/* ??? Decode and interpret the data for flag_debug_asm. */
|
/* ??? Decode and interpret the data for flag_debug_asm. */
|
{
|
{
|
uchar uc;
|
uchar uc;
|
for (i = 0; VEC_iterate (uchar, crtl->eh.action_record_data, i, uc); ++i)
|
for (i = 0; VEC_iterate (uchar, crtl->eh.action_record_data, i, uc); ++i)
|
dw2_asm_output_data (1, uc, i ? NULL : "Action record table");
|
dw2_asm_output_data (1, uc, i ? NULL : "Action record table");
|
}
|
}
|
|
|
if (have_tt_data)
|
if (have_tt_data)
|
assemble_align (tt_format_size * BITS_PER_UNIT);
|
assemble_align (tt_format_size * BITS_PER_UNIT);
|
|
|
i = VEC_length (tree, cfun->eh->ttype_data);
|
i = VEC_length (tree, cfun->eh->ttype_data);
|
while (i-- > 0)
|
while (i-- > 0)
|
{
|
{
|
tree type = VEC_index (tree, cfun->eh->ttype_data, i);
|
tree type = VEC_index (tree, cfun->eh->ttype_data, i);
|
output_ttype (type, tt_format, tt_format_size);
|
output_ttype (type, tt_format, tt_format_size);
|
}
|
}
|
|
|
#ifdef HAVE_AS_LEB128
|
#ifdef HAVE_AS_LEB128
|
if (have_tt_data)
|
if (have_tt_data)
|
ASM_OUTPUT_LABEL (asm_out_file, ttype_label);
|
ASM_OUTPUT_LABEL (asm_out_file, ttype_label);
|
#endif
|
#endif
|
|
|
/* ??? Decode and interpret the data for flag_debug_asm. */
|
/* ??? Decode and interpret the data for flag_debug_asm. */
|
if (targetm.arm_eabi_unwinder)
|
if (targetm.arm_eabi_unwinder)
|
{
|
{
|
tree type;
|
tree type;
|
for (i = 0;
|
for (i = 0;
|
VEC_iterate (tree, cfun->eh->ehspec_data.arm_eabi, i, type); ++i)
|
VEC_iterate (tree, cfun->eh->ehspec_data.arm_eabi, i, type); ++i)
|
output_ttype (type, tt_format, tt_format_size);
|
output_ttype (type, tt_format, tt_format_size);
|
}
|
}
|
else
|
else
|
{
|
{
|
uchar uc;
|
uchar uc;
|
for (i = 0;
|
for (i = 0;
|
VEC_iterate (uchar, cfun->eh->ehspec_data.other, i, uc); ++i)
|
VEC_iterate (uchar, cfun->eh->ehspec_data.other, i, uc); ++i)
|
dw2_asm_output_data (1, uc,
|
dw2_asm_output_data (1, uc,
|
i ? NULL : "Exception specification table");
|
i ? NULL : "Exception specification table");
|
}
|
}
|
}
|
}
|
|
|
void
|
void
|
output_function_exception_table (const char * ARG_UNUSED (fnname))
|
output_function_exception_table (const char * ARG_UNUSED (fnname))
|
{
|
{
|
rtx personality = get_personality_function (current_function_decl);
|
rtx personality = get_personality_function (current_function_decl);
|
|
|
/* Not all functions need anything. */
|
/* Not all functions need anything. */
|
if (! crtl->uses_eh_lsda)
|
if (! crtl->uses_eh_lsda)
|
return;
|
return;
|
|
|
if (personality)
|
if (personality)
|
assemble_external_libcall (personality);
|
assemble_external_libcall (personality);
|
|
|
output_one_function_exception_table (fnname, 0, personality);
|
output_one_function_exception_table (fnname, 0, personality);
|
if (crtl->eh.call_site_record[1] != NULL)
|
if (crtl->eh.call_site_record[1] != NULL)
|
output_one_function_exception_table (fnname, 1, personality);
|
output_one_function_exception_table (fnname, 1, personality);
|
|
|
switch_to_section (current_function_section ());
|
switch_to_section (current_function_section ());
|
}
|
}
|
|
|
void
|
void
|
set_eh_throw_stmt_table (struct function *fun, struct htab *table)
|
set_eh_throw_stmt_table (struct function *fun, struct htab *table)
|
{
|
{
|
fun->eh->throw_stmt_table = table;
|
fun->eh->throw_stmt_table = table;
|
}
|
}
|
|
|
htab_t
|
htab_t
|
get_eh_throw_stmt_table (struct function *fun)
|
get_eh_throw_stmt_table (struct function *fun)
|
{
|
{
|
return fun->eh->throw_stmt_table;
|
return fun->eh->throw_stmt_table;
|
}
|
}
|
|
|
/* Determine if the function needs an EH personality function. */
|
/* Determine if the function needs an EH personality function. */
|
|
|
enum eh_personality_kind
|
enum eh_personality_kind
|
function_needs_eh_personality (struct function *fn)
|
function_needs_eh_personality (struct function *fn)
|
{
|
{
|
enum eh_personality_kind kind = eh_personality_none;
|
enum eh_personality_kind kind = eh_personality_none;
|
eh_region i;
|
eh_region i;
|
|
|
FOR_ALL_EH_REGION_FN (i, fn)
|
FOR_ALL_EH_REGION_FN (i, fn)
|
{
|
{
|
switch (i->type)
|
switch (i->type)
|
{
|
{
|
case ERT_CLEANUP:
|
case ERT_CLEANUP:
|
/* Can do with any personality including the generic C one. */
|
/* Can do with any personality including the generic C one. */
|
kind = eh_personality_any;
|
kind = eh_personality_any;
|
break;
|
break;
|
|
|
case ERT_TRY:
|
case ERT_TRY:
|
case ERT_ALLOWED_EXCEPTIONS:
|
case ERT_ALLOWED_EXCEPTIONS:
|
/* Always needs a EH personality function. The generic C
|
/* Always needs a EH personality function. The generic C
|
personality doesn't handle these even for empty type lists. */
|
personality doesn't handle these even for empty type lists. */
|
return eh_personality_lang;
|
return eh_personality_lang;
|
|
|
case ERT_MUST_NOT_THROW:
|
case ERT_MUST_NOT_THROW:
|
/* Always needs a EH personality function. The language may specify
|
/* Always needs a EH personality function. The language may specify
|
what abort routine that must be used, e.g. std::terminate. */
|
what abort routine that must be used, e.g. std::terminate. */
|
return eh_personality_lang;
|
return eh_personality_lang;
|
}
|
}
|
}
|
}
|
|
|
return kind;
|
return kind;
|
}
|
}
|
|
|
/* Dump EH information to OUT. */
|
/* Dump EH information to OUT. */
|
|
|
void
|
void
|
dump_eh_tree (FILE * out, struct function *fun)
|
dump_eh_tree (FILE * out, struct function *fun)
|
{
|
{
|
eh_region i;
|
eh_region i;
|
int depth = 0;
|
int depth = 0;
|
static const char *const type_name[] = {
|
static const char *const type_name[] = {
|
"cleanup", "try", "allowed_exceptions", "must_not_throw"
|
"cleanup", "try", "allowed_exceptions", "must_not_throw"
|
};
|
};
|
|
|
i = fun->eh->region_tree;
|
i = fun->eh->region_tree;
|
if (!i)
|
if (!i)
|
return;
|
return;
|
|
|
fprintf (out, "Eh tree:\n");
|
fprintf (out, "Eh tree:\n");
|
while (1)
|
while (1)
|
{
|
{
|
fprintf (out, " %*s %i %s", depth * 2, "",
|
fprintf (out, " %*s %i %s", depth * 2, "",
|
i->index, type_name[(int) i->type]);
|
i->index, type_name[(int) i->type]);
|
|
|
if (i->landing_pads)
|
if (i->landing_pads)
|
{
|
{
|
eh_landing_pad lp;
|
eh_landing_pad lp;
|
|
|
fprintf (out, " land:");
|
fprintf (out, " land:");
|
if (current_ir_type () == IR_GIMPLE)
|
if (current_ir_type () == IR_GIMPLE)
|
{
|
{
|
for (lp = i->landing_pads; lp ; lp = lp->next_lp)
|
for (lp = i->landing_pads; lp ; lp = lp->next_lp)
|
{
|
{
|
fprintf (out, "{%i,", lp->index);
|
fprintf (out, "{%i,", lp->index);
|
print_generic_expr (out, lp->post_landing_pad, 0);
|
print_generic_expr (out, lp->post_landing_pad, 0);
|
fputc ('}', out);
|
fputc ('}', out);
|
if (lp->next_lp)
|
if (lp->next_lp)
|
fputc (',', out);
|
fputc (',', out);
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
for (lp = i->landing_pads; lp ; lp = lp->next_lp);
|
for (lp = i->landing_pads; lp ; lp = lp->next_lp);
|
{
|
{
|
fprintf (out, "{%i,", lp->index);
|
fprintf (out, "{%i,", lp->index);
|
if (lp->landing_pad)
|
if (lp->landing_pad)
|
fprintf (out, "%i%s,", INSN_UID (lp->landing_pad),
|
fprintf (out, "%i%s,", INSN_UID (lp->landing_pad),
|
NOTE_P (lp->landing_pad) ? "(del)" : "");
|
NOTE_P (lp->landing_pad) ? "(del)" : "");
|
else
|
else
|
fprintf (out, "(nil),");
|
fprintf (out, "(nil),");
|
if (lp->post_landing_pad)
|
if (lp->post_landing_pad)
|
{
|
{
|
rtx lab = label_rtx (lp->post_landing_pad);
|
rtx lab = label_rtx (lp->post_landing_pad);
|
fprintf (out, "%i%s}", INSN_UID (lab),
|
fprintf (out, "%i%s}", INSN_UID (lab),
|
NOTE_P (lab) ? "(del)" : "");
|
NOTE_P (lab) ? "(del)" : "");
|
}
|
}
|
else
|
else
|
fprintf (out, "(nil)}");
|
fprintf (out, "(nil)}");
|
if (lp->next_lp)
|
if (lp->next_lp)
|
fputc (',', out);
|
fputc (',', out);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
switch (i->type)
|
switch (i->type)
|
{
|
{
|
case ERT_CLEANUP:
|
case ERT_CLEANUP:
|
case ERT_MUST_NOT_THROW:
|
case ERT_MUST_NOT_THROW:
|
break;
|
break;
|
|
|
case ERT_TRY:
|
case ERT_TRY:
|
{
|
{
|
eh_catch c;
|
eh_catch c;
|
fprintf (out, " catch:");
|
fprintf (out, " catch:");
|
for (c = i->u.eh_try.first_catch; c; c = c->next_catch)
|
for (c = i->u.eh_try.first_catch; c; c = c->next_catch)
|
{
|
{
|
fputc ('{', out);
|
fputc ('{', out);
|
if (c->label)
|
if (c->label)
|
{
|
{
|
fprintf (out, "lab:");
|
fprintf (out, "lab:");
|
print_generic_expr (out, c->label, 0);
|
print_generic_expr (out, c->label, 0);
|
fputc (';', out);
|
fputc (';', out);
|
}
|
}
|
print_generic_expr (out, c->type_list, 0);
|
print_generic_expr (out, c->type_list, 0);
|
fputc ('}', out);
|
fputc ('}', out);
|
if (c->next_catch)
|
if (c->next_catch)
|
fputc (',', out);
|
fputc (',', out);
|
}
|
}
|
}
|
}
|
break;
|
break;
|
|
|
case ERT_ALLOWED_EXCEPTIONS:
|
case ERT_ALLOWED_EXCEPTIONS:
|
fprintf (out, " filter :%i types:", i->u.allowed.filter);
|
fprintf (out, " filter :%i types:", i->u.allowed.filter);
|
print_generic_expr (out, i->u.allowed.type_list, 0);
|
print_generic_expr (out, i->u.allowed.type_list, 0);
|
break;
|
break;
|
}
|
}
|
fputc ('\n', out);
|
fputc ('\n', out);
|
|
|
/* If there are sub-regions, process them. */
|
/* If there are sub-regions, process them. */
|
if (i->inner)
|
if (i->inner)
|
i = i->inner, depth++;
|
i = i->inner, depth++;
|
/* If there are peers, process them. */
|
/* If there are peers, process them. */
|
else if (i->next_peer)
|
else if (i->next_peer)
|
i = i->next_peer;
|
i = i->next_peer;
|
/* Otherwise, step back up the tree to the next peer. */
|
/* Otherwise, step back up the tree to the next peer. */
|
else
|
else
|
{
|
{
|
do
|
do
|
{
|
{
|
i = i->outer;
|
i = i->outer;
|
depth--;
|
depth--;
|
if (i == NULL)
|
if (i == NULL)
|
return;
|
return;
|
}
|
}
|
while (i->next_peer == NULL);
|
while (i->next_peer == NULL);
|
i = i->next_peer;
|
i = i->next_peer;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Dump the EH tree for FN on stderr. */
|
/* Dump the EH tree for FN on stderr. */
|
|
|
void
|
void
|
debug_eh_tree (struct function *fn)
|
debug_eh_tree (struct function *fn)
|
{
|
{
|
dump_eh_tree (stderr, fn);
|
dump_eh_tree (stderr, fn);
|
}
|
}
|
|
|
/* Verify invariants on EH datastructures. */
|
/* Verify invariants on EH datastructures. */
|
|
|
void
|
void
|
verify_eh_tree (struct function *fun)
|
verify_eh_tree (struct function *fun)
|
{
|
{
|
eh_region r, outer;
|
eh_region r, outer;
|
int nvisited_lp, nvisited_r;
|
int nvisited_lp, nvisited_r;
|
int count_lp, count_r, depth, i;
|
int count_lp, count_r, depth, i;
|
eh_landing_pad lp;
|
eh_landing_pad lp;
|
bool err = false;
|
bool err = false;
|
|
|
if (!fun->eh->region_tree)
|
if (!fun->eh->region_tree)
|
return;
|
return;
|
|
|
count_r = 0;
|
count_r = 0;
|
for (i = 1; VEC_iterate (eh_region, fun->eh->region_array, i, r); ++i)
|
for (i = 1; VEC_iterate (eh_region, fun->eh->region_array, i, r); ++i)
|
if (r)
|
if (r)
|
{
|
{
|
if (r->index == i)
|
if (r->index == i)
|
count_r++;
|
count_r++;
|
else
|
else
|
{
|
{
|
error ("region_array is corrupted for region %i", r->index);
|
error ("region_array is corrupted for region %i", r->index);
|
err = true;
|
err = true;
|
}
|
}
|
}
|
}
|
|
|
count_lp = 0;
|
count_lp = 0;
|
for (i = 1; VEC_iterate (eh_landing_pad, fun->eh->lp_array, i, lp); ++i)
|
for (i = 1; VEC_iterate (eh_landing_pad, fun->eh->lp_array, i, lp); ++i)
|
if (lp)
|
if (lp)
|
{
|
{
|
if (lp->index == i)
|
if (lp->index == i)
|
count_lp++;
|
count_lp++;
|
else
|
else
|
{
|
{
|
error ("lp_array is corrupted for lp %i", lp->index);
|
error ("lp_array is corrupted for lp %i", lp->index);
|
err = true;
|
err = true;
|
}
|
}
|
}
|
}
|
|
|
depth = nvisited_lp = nvisited_r = 0;
|
depth = nvisited_lp = nvisited_r = 0;
|
outer = NULL;
|
outer = NULL;
|
r = fun->eh->region_tree;
|
r = fun->eh->region_tree;
|
while (1)
|
while (1)
|
{
|
{
|
if (VEC_index (eh_region, fun->eh->region_array, r->index) != r)
|
if (VEC_index (eh_region, fun->eh->region_array, r->index) != r)
|
{
|
{
|
error ("region_array is corrupted for region %i", r->index);
|
error ("region_array is corrupted for region %i", r->index);
|
err = true;
|
err = true;
|
}
|
}
|
if (r->outer != outer)
|
if (r->outer != outer)
|
{
|
{
|
error ("outer block of region %i is wrong", r->index);
|
error ("outer block of region %i is wrong", r->index);
|
err = true;
|
err = true;
|
}
|
}
|
if (depth < 0)
|
if (depth < 0)
|
{
|
{
|
error ("negative nesting depth of region %i", r->index);
|
error ("negative nesting depth of region %i", r->index);
|
err = true;
|
err = true;
|
}
|
}
|
nvisited_r++;
|
nvisited_r++;
|
|
|
for (lp = r->landing_pads; lp ; lp = lp->next_lp)
|
for (lp = r->landing_pads; lp ; lp = lp->next_lp)
|
{
|
{
|
if (VEC_index (eh_landing_pad, fun->eh->lp_array, lp->index) != lp)
|
if (VEC_index (eh_landing_pad, fun->eh->lp_array, lp->index) != lp)
|
{
|
{
|
error ("lp_array is corrupted for lp %i", lp->index);
|
error ("lp_array is corrupted for lp %i", lp->index);
|
err = true;
|
err = true;
|
}
|
}
|
if (lp->region != r)
|
if (lp->region != r)
|
{
|
{
|
error ("region of lp %i is wrong", lp->index);
|
error ("region of lp %i is wrong", lp->index);
|
err = true;
|
err = true;
|
}
|
}
|
nvisited_lp++;
|
nvisited_lp++;
|
}
|
}
|
|
|
if (r->inner)
|
if (r->inner)
|
outer = r, r = r->inner, depth++;
|
outer = r, r = r->inner, depth++;
|
else if (r->next_peer)
|
else if (r->next_peer)
|
r = r->next_peer;
|
r = r->next_peer;
|
else
|
else
|
{
|
{
|
do
|
do
|
{
|
{
|
r = r->outer;
|
r = r->outer;
|
if (r == NULL)
|
if (r == NULL)
|
goto region_done;
|
goto region_done;
|
depth--;
|
depth--;
|
outer = r->outer;
|
outer = r->outer;
|
}
|
}
|
while (r->next_peer == NULL);
|
while (r->next_peer == NULL);
|
r = r->next_peer;
|
r = r->next_peer;
|
}
|
}
|
}
|
}
|
region_done:
|
region_done:
|
if (depth != 0)
|
if (depth != 0)
|
{
|
{
|
error ("tree list ends on depth %i", depth);
|
error ("tree list ends on depth %i", depth);
|
err = true;
|
err = true;
|
}
|
}
|
if (count_r != nvisited_r)
|
if (count_r != nvisited_r)
|
{
|
{
|
error ("region_array does not match region_tree");
|
error ("region_array does not match region_tree");
|
err = true;
|
err = true;
|
}
|
}
|
if (count_lp != nvisited_lp)
|
if (count_lp != nvisited_lp)
|
{
|
{
|
error ("lp_array does not match region_tree");
|
error ("lp_array does not match region_tree");
|
err = true;
|
err = true;
|
}
|
}
|
|
|
if (err)
|
if (err)
|
{
|
{
|
dump_eh_tree (stderr, fun);
|
dump_eh_tree (stderr, fun);
|
internal_error ("verify_eh_tree failed");
|
internal_error ("verify_eh_tree failed");
|
}
|
}
|
}
|
}
|
|
|
#include "gt-except.h"
|
#include "gt-except.h"
|
|
|
