/* 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, 2007
|
1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
|
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 signaled from within a
|
/* An exception is an event that can be signaled from within a
|
function. This event can then be "caught" or "trapped" by the
|
function. This event can then be "caught" or "trapped" by the
|
callers of this function. This potentially allows program flow to
|
callers of this function. This potentially allows program flow to
|
be transferred to any arbitrary code associated with a function call
|
be transferred to any arbitrary code associated with a function call
|
several levels up the stack.
|
several levels up the stack.
|
|
|
The intended use for this mechanism is for signaling "exceptional
|
The intended use for this mechanism is for signaling "exceptional
|
events" in an out-of-band fashion, hence its name. The C++ language
|
events" in an out-of-band fashion, hence its name. The C++ language
|
(and many other OO-styled or functional languages) practically
|
(and many other OO-styled or functional languages) practically
|
requires such a mechanism, as otherwise it becomes very difficult
|
requires such a mechanism, as otherwise it becomes very difficult
|
or even impossible to signal failure conditions in complex
|
or even impossible to signal failure conditions in complex
|
situations. The traditional C++ example is when an error occurs in
|
situations. The traditional C++ example is when an error occurs in
|
the process of constructing an object; without such a mechanism, it
|
the process of constructing an object; without such a mechanism, it
|
is impossible to signal that the error occurs without adding global
|
is impossible to signal that the error occurs without adding global
|
state variables and error checks around every object construction.
|
state variables and error checks around every object construction.
|
|
|
The act of causing this event to occur is referred to as "throwing
|
The act of causing this event to occur is referred to as "throwing
|
an exception". (Alternate terms include "raising an exception" or
|
an exception". (Alternate terms include "raising an exception" or
|
"signaling an exception".) The term "throw" is used because control
|
"signaling an exception".) The term "throw" is used because control
|
is returned to the callers of the function that is signaling the
|
is returned to the callers of the function that is signaling the
|
exception, and thus there is the concept of "throwing" the
|
exception, and thus there is the concept of "throwing" the
|
exception up the call stack.
|
exception up the call stack.
|
|
|
[ Add updated documentation on how to use this. ] */
|
[ Add updated documentation on how to use this. ] */
|
|
|
|
|
#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"
|
|
|
/* 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);
|
|
|
/* Map a type to a runtime object to match type. */
|
/* Map a type to a runtime object to match type. */
|
tree (*lang_eh_runtime_type) (tree);
|
tree (*lang_eh_runtime_type) (tree);
|
|
|
/* A hash table of label to region number. */
|
/* A hash table of label to region number. */
|
|
|
struct ehl_map_entry GTY(())
|
struct ehl_map_entry GTY(())
|
{
|
{
|
rtx label;
|
rtx label;
|
struct eh_region *region;
|
struct eh_region *region;
|
};
|
};
|
|
|
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;
|
|
|
/* Describes one exception region. */
|
/* Describes one exception region. */
|
struct eh_region GTY(())
|
struct eh_region GTY(())
|
{
|
{
|
/* The immediately surrounding region. */
|
/* The immediately surrounding region. */
|
struct eh_region *outer;
|
struct eh_region *outer;
|
|
|
/* The list of immediately contained regions. */
|
/* The list of immediately contained regions. */
|
struct eh_region *inner;
|
struct eh_region *inner;
|
struct eh_region *next_peer;
|
struct eh_region *next_peer;
|
|
|
/* An identifier for this region. */
|
/* An identifier for this region. */
|
int region_number;
|
int region_number;
|
|
|
/* When a region is deleted, its parents inherit the REG_EH_REGION
|
/* When a region is deleted, its parents inherit the REG_EH_REGION
|
numbers already assigned. */
|
numbers already assigned. */
|
bitmap aka;
|
bitmap aka;
|
|
|
/* Each region does exactly one thing. */
|
/* Each region does exactly one thing. */
|
enum eh_region_type
|
enum eh_region_type
|
{
|
{
|
ERT_UNKNOWN = 0,
|
ERT_UNKNOWN = 0,
|
ERT_CLEANUP,
|
ERT_CLEANUP,
|
ERT_TRY,
|
ERT_TRY,
|
ERT_CATCH,
|
ERT_CATCH,
|
ERT_ALLOWED_EXCEPTIONS,
|
ERT_ALLOWED_EXCEPTIONS,
|
ERT_MUST_NOT_THROW,
|
ERT_MUST_NOT_THROW,
|
ERT_THROW
|
ERT_THROW
|
} type;
|
} type;
|
|
|
/* Holds the action to perform based on the preceding type. */
|
/* Holds the action to perform based on the preceding type. */
|
union eh_region_u {
|
union eh_region_u {
|
/* A list of catch blocks, a surrounding try block,
|
/* A list of catch blocks, a surrounding try block,
|
and the label for continuing after a catch. */
|
and the label for continuing after a catch. */
|
struct eh_region_u_try {
|
struct eh_region_u_try {
|
struct eh_region *catch;
|
struct eh_region *catch;
|
struct eh_region *last_catch;
|
struct eh_region *last_catch;
|
} GTY ((tag ("ERT_TRY"))) try;
|
} GTY ((tag ("ERT_TRY"))) try;
|
|
|
/* The list through the catch handlers, the list of type objects
|
/* The list through the catch handlers, the list of type objects
|
matched, and the list of associated filters. */
|
matched, and the list of associated filters. */
|
struct eh_region_u_catch {
|
struct eh_region_u_catch {
|
struct eh_region *next_catch;
|
struct eh_region *next_catch;
|
struct eh_region *prev_catch;
|
struct eh_region *prev_catch;
|
tree type_list;
|
tree type_list;
|
tree filter_list;
|
tree filter_list;
|
} GTY ((tag ("ERT_CATCH"))) catch;
|
} GTY ((tag ("ERT_CATCH"))) catch;
|
|
|
/* A tree_list of allowed types. */
|
/* A tree_list of allowed types. */
|
struct eh_region_u_allowed {
|
struct eh_region_u_allowed {
|
tree type_list;
|
tree type_list;
|
int filter;
|
int filter;
|
} GTY ((tag ("ERT_ALLOWED_EXCEPTIONS"))) allowed;
|
} GTY ((tag ("ERT_ALLOWED_EXCEPTIONS"))) allowed;
|
|
|
/* The type given by a call to "throw foo();", or discovered
|
/* The type given by a call to "throw foo();", or discovered
|
for a throw. */
|
for a throw. */
|
struct eh_region_u_throw {
|
struct eh_region_u_throw {
|
tree type;
|
tree type;
|
} GTY ((tag ("ERT_THROW"))) throw;
|
} GTY ((tag ("ERT_THROW"))) throw;
|
|
|
/* Retain the cleanup expression even after expansion so that
|
/* Retain the cleanup expression even after expansion so that
|
we can match up fixup regions. */
|
we can match up fixup regions. */
|
struct eh_region_u_cleanup {
|
struct eh_region_u_cleanup {
|
struct eh_region *prev_try;
|
struct eh_region *prev_try;
|
} GTY ((tag ("ERT_CLEANUP"))) cleanup;
|
} GTY ((tag ("ERT_CLEANUP"))) cleanup;
|
} GTY ((desc ("%0.type"))) u;
|
} GTY ((desc ("%0.type"))) u;
|
|
|
/* Entry point for this region's handler before landing pads are built. */
|
/* Entry point for this region's handler before landing pads are built. */
|
rtx label;
|
rtx label;
|
tree tree_label;
|
tree tree_label;
|
|
|
/* Entry point for this region's handler from the runtime eh library. */
|
/* Entry point for this region's handler from the runtime eh library. */
|
rtx landing_pad;
|
rtx landing_pad;
|
|
|
/* Entry point for this region's handler from an inner region. */
|
/* Entry point for this region's handler from an inner region. */
|
rtx post_landing_pad;
|
rtx post_landing_pad;
|
|
|
/* The RESX insn for handing off control to the next outermost handler,
|
/* The RESX insn for handing off control to the next outermost handler,
|
if appropriate. */
|
if appropriate. */
|
rtx resume;
|
rtx resume;
|
|
|
/* True if something in this region may throw. */
|
/* True if something in this region may throw. */
|
unsigned may_contain_throw : 1;
|
unsigned may_contain_throw : 1;
|
};
|
};
|
|
|
typedef struct eh_region *eh_region;
|
typedef struct eh_region *eh_region;
|
|
|
struct call_site_record GTY(())
|
struct call_site_record GTY(())
|
{
|
{
|
rtx landing_pad;
|
rtx landing_pad;
|
int action;
|
int action;
|
};
|
};
|
|
|
DEF_VEC_P(eh_region);
|
DEF_VEC_P(eh_region);
|
DEF_VEC_ALLOC_P(eh_region, gc);
|
DEF_VEC_ALLOC_P(eh_region, gc);
|
|
|
/* Used to save exception status for each function. */
|
/* Used to save exception status for each function. */
|
struct eh_status GTY(())
|
struct eh_status GTY(())
|
{
|
{
|
/* The tree of all regions for this function. */
|
/* The tree of all regions for this function. */
|
struct eh_region *region_tree;
|
struct eh_region *region_tree;
|
|
|
/* The same information as an indexable array. */
|
/* The same information as an indexable array. */
|
VEC(eh_region,gc) *region_array;
|
VEC(eh_region,gc) *region_array;
|
|
|
/* The most recently open region. */
|
/* The most recently open region. */
|
struct eh_region *cur_region;
|
struct eh_region *cur_region;
|
|
|
/* This is the region for which we are processing catch blocks. */
|
/* This is the region for which we are processing catch blocks. */
|
struct eh_region *try_region;
|
struct eh_region *try_region;
|
|
|
rtx filter;
|
rtx filter;
|
rtx exc_ptr;
|
rtx exc_ptr;
|
|
|
int built_landing_pads;
|
int built_landing_pads;
|
int last_region_number;
|
int last_region_number;
|
|
|
VEC(tree,gc) *ttype_data;
|
VEC(tree,gc) *ttype_data;
|
varray_type ehspec_data;
|
varray_type ehspec_data;
|
varray_type action_record_data;
|
varray_type action_record_data;
|
|
|
htab_t GTY ((param_is (struct ehl_map_entry))) exception_handler_label_map;
|
htab_t GTY ((param_is (struct ehl_map_entry))) exception_handler_label_map;
|
|
|
struct call_site_record * GTY ((length ("%h.call_site_data_used")))
|
struct call_site_record * GTY ((length ("%h.call_site_data_used")))
|
call_site_data;
|
call_site_data;
|
int call_site_data_used;
|
int call_site_data_used;
|
int call_site_data_size;
|
int call_site_data_size;
|
|
|
rtx ehr_stackadj;
|
rtx ehr_stackadj;
|
rtx ehr_handler;
|
rtx ehr_handler;
|
rtx ehr_label;
|
rtx ehr_label;
|
|
|
rtx sjlj_fc;
|
rtx sjlj_fc;
|
rtx sjlj_exit_after;
|
rtx sjlj_exit_after;
|
|
|
htab_t GTY((param_is (struct throw_stmt_node))) throw_stmt_table;
|
htab_t GTY((param_is (struct throw_stmt_node))) throw_stmt_table;
|
};
|
};
|
|
|
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 void add_type_for_runtime (tree);
|
static void add_type_for_runtime (tree);
|
static tree lookup_type_for_runtime (tree);
|
static tree lookup_type_for_runtime (tree);
|
|
|
static void remove_unreachable_regions (rtx);
|
static void remove_unreachable_regions (rtx);
|
|
|
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 assign_filter_values (void);
|
static void assign_filter_values (void);
|
static void build_post_landing_pads (void);
|
static void build_post_landing_pads (void);
|
static void connect_post_landing_pads (void);
|
static void connect_post_landing_pads (void);
|
static void dw2_build_landing_pads (void);
|
static void dw2_build_landing_pads (void);
|
|
|
struct sjlj_lp_info;
|
struct sjlj_lp_info;
|
static bool sjlj_find_directly_reachable_regions (struct sjlj_lp_info *);
|
static bool sjlj_find_directly_reachable_regions (struct sjlj_lp_info *);
|
static void sjlj_assign_call_site_values (rtx, struct sjlj_lp_info *);
|
static void sjlj_assign_call_site_values (rtx, struct sjlj_lp_info *);
|
static void sjlj_mark_call_sites (struct sjlj_lp_info *);
|
static void sjlj_mark_call_sites (struct sjlj_lp_info *);
|
static void sjlj_emit_function_enter (rtx);
|
static void sjlj_emit_function_enter (rtx);
|
static void sjlj_emit_function_exit (void);
|
static void sjlj_emit_function_exit (void);
|
static void sjlj_emit_dispatch_table (rtx, struct sjlj_lp_info *);
|
static void sjlj_emit_dispatch_table (rtx, struct sjlj_lp_info *);
|
static void sjlj_build_landing_pads (void);
|
static void sjlj_build_landing_pads (void);
|
|
|
static hashval_t ehl_hash (const void *);
|
static hashval_t ehl_hash (const void *);
|
static int ehl_eq (const void *, const void *);
|
static int ehl_eq (const void *, const void *);
|
static void add_ehl_entry (rtx, struct eh_region *);
|
static void add_ehl_entry (rtx, struct eh_region *);
|
static void remove_exception_handler_label (rtx);
|
static void remove_exception_handler_label (rtx);
|
static void remove_eh_handler (struct eh_region *);
|
static void remove_eh_handler (struct eh_region *);
|
static int for_each_eh_label_1 (void **, void *);
|
static int for_each_eh_label_1 (void **, void *);
|
|
|
/* The return value of reachable_next_level. */
|
/* The return value of reachable_next_level. */
|
enum reachable_code
|
enum reachable_code
|
{
|
{
|
/* The given exception is not processed by the given region. */
|
/* The given exception is not processed by the given region. */
|
RNL_NOT_CAUGHT,
|
RNL_NOT_CAUGHT,
|
/* The given exception may need processing by the given region. */
|
/* The given exception may need processing by the given region. */
|
RNL_MAYBE_CAUGHT,
|
RNL_MAYBE_CAUGHT,
|
/* The given exception is completely processed by the given region. */
|
/* The given exception is completely processed by the given region. */
|
RNL_CAUGHT,
|
RNL_CAUGHT,
|
/* The given exception is completely processed by the runtime. */
|
/* The given exception is completely processed by the runtime. */
|
RNL_BLOCKED
|
RNL_BLOCKED
|
};
|
};
|
|
|
struct reachable_info;
|
struct reachable_info;
|
static enum reachable_code reachable_next_level (struct eh_region *, tree,
|
static enum reachable_code reachable_next_level (struct eh_region *, tree,
|
struct reachable_info *);
|
struct reachable_info *);
|
|
|
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, struct eh_region *);
|
static int collect_one_action_chain (htab_t, struct eh_region *);
|
static int add_call_site (rtx, int);
|
static int add_call_site (rtx, int);
|
|
|
static void push_uleb128 (varray_type *, unsigned int);
|
static void push_uleb128 (varray_type *, unsigned int);
|
static void push_sleb128 (varray_type *, int);
|
static void push_sleb128 (varray_type *, int);
|
#ifndef HAVE_AS_LEB128
|
#ifndef HAVE_AS_LEB128
|
static int dw2_size_of_call_site_table (void);
|
static int dw2_size_of_call_site_table (void);
|
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 (void);
|
static void dw2_output_call_site_table (void);
|
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 (FIELD_DECL, get_identifier ("__prev"),
|
f_prev = build_decl (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 (FIELD_DECL, get_identifier ("__call_site"),
|
f_cs = build_decl (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 (word_mode, 1),
|
tmp = build_array_type (lang_hooks.types.type_for_mode (word_mode, 1),
|
tmp);
|
tmp);
|
f_data = build_decl (FIELD_DECL, get_identifier ("__data"), tmp);
|
f_data = build_decl (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 (FIELD_DECL, get_identifier ("__personality"),
|
f_per = build_decl (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 (FIELD_DECL, get_identifier ("__lsda"),
|
f_lsda = build_decl (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 (FIELD_DECL, get_identifier ("__jbuf"), tmp);
|
f_jbuf = build_decl (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_alloc_cleared (sizeof (struct eh_status));
|
cfun->eh = ggc_alloc_cleared (sizeof (struct eh_status));
|
}
|
}
|
|
|
/* 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 struct eh_region *
|
static struct eh_region *
|
gen_eh_region (enum eh_region_type type, struct eh_region *outer)
|
gen_eh_region (enum eh_region_type type, struct eh_region *outer)
|
{
|
{
|
struct eh_region *new;
|
struct eh_region *new;
|
|
|
#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 = ggc_alloc_cleared (sizeof (*new));
|
new = ggc_alloc_cleared (sizeof (*new));
|
new->type = type;
|
new->type = type;
|
new->outer = outer;
|
new->outer = outer;
|
if (outer)
|
if (outer)
|
{
|
{
|
new->next_peer = outer->inner;
|
new->next_peer = outer->inner;
|
outer->inner = new;
|
outer->inner = new;
|
}
|
}
|
else
|
else
|
{
|
{
|
new->next_peer = cfun->eh->region_tree;
|
new->next_peer = cfun->eh->region_tree;
|
cfun->eh->region_tree = new;
|
cfun->eh->region_tree = new;
|
}
|
}
|
|
|
new->region_number = ++cfun->eh->last_region_number;
|
new->region_number = ++cfun->eh->last_region_number;
|
|
|
return new;
|
return new;
|
}
|
}
|
|
|
struct eh_region *
|
struct eh_region *
|
gen_eh_region_cleanup (struct eh_region *outer, struct eh_region *prev_try)
|
gen_eh_region_cleanup (struct eh_region *outer, struct eh_region *prev_try)
|
{
|
{
|
struct eh_region *cleanup = gen_eh_region (ERT_CLEANUP, outer);
|
struct eh_region *cleanup = gen_eh_region (ERT_CLEANUP, outer);
|
cleanup->u.cleanup.prev_try = prev_try;
|
cleanup->u.cleanup.prev_try = prev_try;
|
return cleanup;
|
return cleanup;
|
}
|
}
|
|
|
struct eh_region *
|
struct eh_region *
|
gen_eh_region_try (struct eh_region *outer)
|
gen_eh_region_try (struct eh_region *outer)
|
{
|
{
|
return gen_eh_region (ERT_TRY, outer);
|
return gen_eh_region (ERT_TRY, outer);
|
}
|
}
|
|
|
struct eh_region *
|
struct eh_region *
|
gen_eh_region_catch (struct eh_region *t, tree type_or_list)
|
gen_eh_region_catch (struct eh_region *t, tree type_or_list)
|
{
|
{
|
struct eh_region *c, *l;
|
struct eh_region *c, *l;
|
tree type_list, type_node;
|
tree type_list, type_node;
|
|
|
/* 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 = gen_eh_region (ERT_CATCH, t->outer);
|
c = gen_eh_region (ERT_CATCH, t->outer);
|
c->u.catch.type_list = type_list;
|
c->u.catch.type_list = type_list;
|
l = t->u.try.last_catch;
|
l = t->u.try.last_catch;
|
c->u.catch.prev_catch = l;
|
c->u.catch.prev_catch = l;
|
if (l)
|
if (l)
|
l->u.catch.next_catch = c;
|
l->u.catch.next_catch = c;
|
else
|
else
|
t->u.try.catch = c;
|
t->u.try.catch = c;
|
t->u.try.last_catch = c;
|
t->u.try.last_catch = c;
|
|
|
return c;
|
return c;
|
}
|
}
|
|
|
struct eh_region *
|
struct eh_region *
|
gen_eh_region_allowed (struct eh_region *outer, tree allowed)
|
gen_eh_region_allowed (struct eh_region *outer, tree allowed)
|
{
|
{
|
struct eh_region *region = gen_eh_region (ERT_ALLOWED_EXCEPTIONS, outer);
|
struct 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;
|
}
|
}
|
|
|
struct eh_region *
|
struct eh_region *
|
gen_eh_region_must_not_throw (struct eh_region *outer)
|
gen_eh_region_must_not_throw (struct eh_region *outer)
|
{
|
{
|
return gen_eh_region (ERT_MUST_NOT_THROW, outer);
|
return gen_eh_region (ERT_MUST_NOT_THROW, outer);
|
}
|
}
|
|
|
int
|
int
|
get_eh_region_number (struct eh_region *region)
|
get_eh_region_number (struct eh_region *region)
|
{
|
{
|
return region->region_number;
|
return region->region_number;
|
}
|
}
|
|
|
bool
|
bool
|
get_eh_region_may_contain_throw (struct eh_region *region)
|
get_eh_region_may_contain_throw (struct eh_region *region)
|
{
|
{
|
return region->may_contain_throw;
|
return region->may_contain_throw;
|
}
|
}
|
|
|
tree
|
tree
|
get_eh_region_tree_label (struct eh_region *region)
|
get_eh_region_tree_label (struct eh_region *region)
|
{
|
{
|
return region->tree_label;
|
return region->tree_label;
|
}
|
}
|
|
|
void
|
void
|
set_eh_region_tree_label (struct eh_region *region, tree lab)
|
set_eh_region_tree_label (struct eh_region *region, tree lab)
|
{
|
{
|
region->tree_label = lab;
|
region->tree_label = lab;
|
}
|
}
|
|
|
void
|
void
|
expand_resx_expr (tree exp)
|
expand_resx_expr (tree exp)
|
{
|
{
|
int region_nr = TREE_INT_CST_LOW (TREE_OPERAND (exp, 0));
|
int region_nr = TREE_INT_CST_LOW (TREE_OPERAND (exp, 0));
|
struct eh_region *reg = VEC_index (eh_region,
|
struct eh_region *reg = VEC_index (eh_region,
|
cfun->eh->region_array, region_nr);
|
cfun->eh->region_array, region_nr);
|
|
|
gcc_assert (!reg->resume);
|
gcc_assert (!reg->resume);
|
reg->resume = emit_jump_insn (gen_rtx_RESX (VOIDmode, region_nr));
|
reg->resume = emit_jump_insn (gen_rtx_RESX (VOIDmode, region_nr));
|
emit_barrier ();
|
emit_barrier ();
|
}
|
}
|
|
|
/* Note that the current EH region (if any) may contain a throw, or a
|
/* Note that the current EH region (if any) may contain a throw, or a
|
call to a function which itself may contain a throw. */
|
call to a function which itself may contain a throw. */
|
|
|
void
|
void
|
note_eh_region_may_contain_throw (struct eh_region *region)
|
note_eh_region_may_contain_throw (struct eh_region *region)
|
{
|
{
|
while (region && !region->may_contain_throw)
|
while (region && !region->may_contain_throw)
|
{
|
{
|
region->may_contain_throw = 1;
|
region->may_contain_throw = 1;
|
region = region->outer;
|
region = region->outer;
|
}
|
}
|
}
|
}
|
|
|
void
|
void
|
note_current_region_may_contain_throw (void)
|
note_current_region_may_contain_throw (void)
|
{
|
{
|
note_eh_region_may_contain_throw (cfun->eh->cur_region);
|
note_eh_region_may_contain_throw (cfun->eh->cur_region);
|
}
|
}
|
|
|
|
|
/* Return an rtl expression for a pointer to the exception object
|
/* Return an rtl expression for a pointer to the exception object
|
within a handler. */
|
within a handler. */
|
|
|
rtx
|
rtx
|
get_exception_pointer (struct function *fun)
|
get_exception_pointer (struct function *fun)
|
{
|
{
|
rtx exc_ptr = fun->eh->exc_ptr;
|
rtx exc_ptr = fun->eh->exc_ptr;
|
if (fun == cfun && ! exc_ptr)
|
if (fun == cfun && ! exc_ptr)
|
{
|
{
|
exc_ptr = gen_reg_rtx (ptr_mode);
|
exc_ptr = gen_reg_rtx (ptr_mode);
|
fun->eh->exc_ptr = exc_ptr;
|
fun->eh->exc_ptr = exc_ptr;
|
}
|
}
|
return exc_ptr;
|
return exc_ptr;
|
}
|
}
|
|
|
/* Return an rtl expression for the exception dispatch filter
|
/* Return an rtl expression for the exception dispatch filter
|
within a handler. */
|
within a handler. */
|
|
|
rtx
|
rtx
|
get_exception_filter (struct function *fun)
|
get_exception_filter (struct function *fun)
|
{
|
{
|
rtx filter = fun->eh->filter;
|
rtx filter = fun->eh->filter;
|
if (fun == cfun && ! filter)
|
if (fun == cfun && ! filter)
|
{
|
{
|
filter = gen_reg_rtx (targetm.eh_return_filter_mode ());
|
filter = gen_reg_rtx (targetm.eh_return_filter_mode ());
|
fun->eh->filter = filter;
|
fun->eh->filter = filter;
|
}
|
}
|
return filter;
|
return filter;
|
}
|
}
|
|
|
/* This section is for the exception handling specific optimization pass. */
|
/* This section is for the exception handling specific optimization pass. */
|
|
|
/* Random access the exception region tree. */
|
/* Random access the exception region tree. */
|
|
|
void
|
void
|
collect_eh_region_array (void)
|
collect_eh_region_array (void)
|
{
|
{
|
struct eh_region *i;
|
struct eh_region *i;
|
|
|
i = cfun->eh->region_tree;
|
i = cfun->eh->region_tree;
|
if (! i)
|
if (! i)
|
return;
|
return;
|
|
|
VEC_safe_grow (eh_region, gc, cfun->eh->region_array,
|
VEC_safe_grow (eh_region, gc, cfun->eh->region_array,
|
cfun->eh->last_region_number + 1);
|
cfun->eh->last_region_number + 1);
|
VEC_replace (eh_region, cfun->eh->region_array, 0, 0);
|
VEC_replace (eh_region, cfun->eh->region_array, 0, 0);
|
|
|
while (1)
|
while (1)
|
{
|
{
|
VEC_replace (eh_region, cfun->eh->region_array, i->region_number, i);
|
VEC_replace (eh_region, cfun->eh->region_array, i->region_number, i);
|
|
|
/* If there are sub-regions, process them. */
|
/* If there are sub-regions, process them. */
|
if (i->inner)
|
if (i->inner)
|
i = i->inner;
|
i = i->inner;
|
/* 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;
|
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;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Remove all regions whose labels are not reachable from insns. */
|
/* Remove all regions whose labels are not reachable from insns. */
|
|
|
static void
|
static void
|
remove_unreachable_regions (rtx insns)
|
remove_unreachable_regions (rtx insns)
|
{
|
{
|
int i, *uid_region_num;
|
int i, *uid_region_num;
|
bool *reachable;
|
bool *reachable;
|
struct eh_region *r;
|
struct eh_region *r;
|
rtx insn;
|
rtx insn;
|
|
|
uid_region_num = xcalloc (get_max_uid (), sizeof(int));
|
uid_region_num = xcalloc (get_max_uid (), sizeof(int));
|
reachable = xcalloc (cfun->eh->last_region_number + 1, sizeof(bool));
|
reachable = xcalloc (cfun->eh->last_region_number + 1, sizeof(bool));
|
|
|
for (i = cfun->eh->last_region_number; i > 0; --i)
|
for (i = cfun->eh->last_region_number; i > 0; --i)
|
{
|
{
|
r = VEC_index (eh_region, cfun->eh->region_array, i);
|
r = VEC_index (eh_region, cfun->eh->region_array, i);
|
if (!r || r->region_number != i)
|
if (!r || r->region_number != i)
|
continue;
|
continue;
|
|
|
if (r->resume)
|
if (r->resume)
|
{
|
{
|
gcc_assert (!uid_region_num[INSN_UID (r->resume)]);
|
gcc_assert (!uid_region_num[INSN_UID (r->resume)]);
|
uid_region_num[INSN_UID (r->resume)] = i;
|
uid_region_num[INSN_UID (r->resume)] = i;
|
}
|
}
|
if (r->label)
|
if (r->label)
|
{
|
{
|
gcc_assert (!uid_region_num[INSN_UID (r->label)]);
|
gcc_assert (!uid_region_num[INSN_UID (r->label)]);
|
uid_region_num[INSN_UID (r->label)] = i;
|
uid_region_num[INSN_UID (r->label)] = i;
|
}
|
}
|
}
|
}
|
|
|
for (insn = insns; insn; insn = NEXT_INSN (insn))
|
for (insn = insns; insn; insn = NEXT_INSN (insn))
|
reachable[uid_region_num[INSN_UID (insn)]] = true;
|
reachable[uid_region_num[INSN_UID (insn)]] = true;
|
|
|
for (i = cfun->eh->last_region_number; i > 0; --i)
|
for (i = cfun->eh->last_region_number; i > 0; --i)
|
{
|
{
|
r = VEC_index (eh_region, cfun->eh->region_array, i);
|
r = VEC_index (eh_region, cfun->eh->region_array, i);
|
if (r && r->region_number == i && !reachable[i])
|
if (r && r->region_number == i && !reachable[i])
|
{
|
{
|
bool kill_it = true;
|
bool kill_it = true;
|
switch (r->type)
|
switch (r->type)
|
{
|
{
|
case ERT_THROW:
|
case ERT_THROW:
|
/* Don't remove ERT_THROW regions if their outer region
|
/* Don't remove ERT_THROW regions if their outer region
|
is reachable. */
|
is reachable. */
|
if (r->outer && reachable[r->outer->region_number])
|
if (r->outer && reachable[r->outer->region_number])
|
kill_it = false;
|
kill_it = false;
|
break;
|
break;
|
|
|
case ERT_MUST_NOT_THROW:
|
case ERT_MUST_NOT_THROW:
|
/* MUST_NOT_THROW regions are implementable solely in the
|
/* MUST_NOT_THROW regions are implementable solely in the
|
runtime, but their existence continues to affect calls
|
runtime, but their existence continues to affect calls
|
within that region. Never delete them here. */
|
within that region. Never delete them here. */
|
kill_it = false;
|
kill_it = false;
|
break;
|
break;
|
|
|
case ERT_TRY:
|
case ERT_TRY:
|
{
|
{
|
/* TRY regions are reachable if any of its CATCH regions
|
/* TRY regions are reachable if any of its CATCH regions
|
are reachable. */
|
are reachable. */
|
struct eh_region *c;
|
struct eh_region *c;
|
for (c = r->u.try.catch; c ; c = c->u.catch.next_catch)
|
for (c = r->u.try.catch; c ; c = c->u.catch.next_catch)
|
if (reachable[c->region_number])
|
if (reachable[c->region_number])
|
{
|
{
|
kill_it = false;
|
kill_it = false;
|
break;
|
break;
|
}
|
}
|
break;
|
break;
|
}
|
}
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
if (kill_it)
|
if (kill_it)
|
remove_eh_handler (r);
|
remove_eh_handler (r);
|
}
|
}
|
}
|
}
|
|
|
free (reachable);
|
free (reachable);
|
free (uid_region_num);
|
free (uid_region_num);
|
}
|
}
|
|
|
/* Set up EH labels for RTL. */
|
/* Set up EH labels for RTL. */
|
|
|
void
|
void
|
convert_from_eh_region_ranges (void)
|
convert_from_eh_region_ranges (void)
|
{
|
{
|
rtx insns = get_insns ();
|
rtx insns = get_insns ();
|
int i, n = cfun->eh->last_region_number;
|
int i, n = cfun->eh->last_region_number;
|
|
|
/* Most of the work is already done at the tree level. All we need to
|
/* Most of the work is already done at the tree level. All we need to
|
do is collect the rtl labels that correspond to the tree labels that
|
do is collect the rtl labels that correspond to the tree labels that
|
collect the rtl labels that correspond to the tree labels
|
collect the rtl labels that correspond to the tree labels
|
we allocated earlier. */
|
we allocated earlier. */
|
for (i = 1; i <= n; ++i)
|
for (i = 1; i <= n; ++i)
|
{
|
{
|
struct eh_region *region;
|
struct eh_region *region;
|
|
|
region = VEC_index (eh_region, cfun->eh->region_array, i);
|
region = VEC_index (eh_region, cfun->eh->region_array, i);
|
if (region && region->tree_label)
|
if (region && region->tree_label)
|
region->label = DECL_RTL_IF_SET (region->tree_label);
|
region->label = DECL_RTL_IF_SET (region->tree_label);
|
}
|
}
|
|
|
remove_unreachable_regions (insns);
|
remove_unreachable_regions (insns);
|
}
|
}
|
|
|
static void
|
static void
|
add_ehl_entry (rtx label, struct eh_region *region)
|
add_ehl_entry (rtx label, struct eh_region *region)
|
{
|
{
|
struct ehl_map_entry **slot, *entry;
|
struct ehl_map_entry **slot, *entry;
|
|
|
LABEL_PRESERVE_P (label) = 1;
|
LABEL_PRESERVE_P (label) = 1;
|
|
|
entry = ggc_alloc (sizeof (*entry));
|
entry = ggc_alloc (sizeof (*entry));
|
entry->label = label;
|
entry->label = label;
|
entry->region = region;
|
entry->region = region;
|
|
|
slot = (struct ehl_map_entry **)
|
slot = (struct ehl_map_entry **)
|
htab_find_slot (cfun->eh->exception_handler_label_map, entry, INSERT);
|
htab_find_slot (cfun->eh->exception_handler_label_map, entry, INSERT);
|
|
|
/* Before landing pad creation, each exception handler has its own
|
/* Before landing pad creation, each exception handler has its own
|
label. After landing pad creation, the exception handlers may
|
label. After landing pad creation, the exception handlers may
|
share landing pads. This is ok, since maybe_remove_eh_handler
|
share landing pads. This is ok, since maybe_remove_eh_handler
|
only requires the 1-1 mapping before landing pad creation. */
|
only requires the 1-1 mapping before landing pad creation. */
|
gcc_assert (!*slot || cfun->eh->built_landing_pads);
|
gcc_assert (!*slot || cfun->eh->built_landing_pads);
|
|
|
*slot = entry;
|
*slot = entry;
|
}
|
}
|
|
|
void
|
void
|
find_exception_handler_labels (void)
|
find_exception_handler_labels (void)
|
{
|
{
|
int i;
|
int i;
|
|
|
if (cfun->eh->exception_handler_label_map)
|
if (cfun->eh->exception_handler_label_map)
|
htab_empty (cfun->eh->exception_handler_label_map);
|
htab_empty (cfun->eh->exception_handler_label_map);
|
else
|
else
|
{
|
{
|
/* ??? The expansion factor here (3/2) must be greater than the htab
|
/* ??? The expansion factor here (3/2) must be greater than the htab
|
occupancy factor (4/3) to avoid unnecessary resizing. */
|
occupancy factor (4/3) to avoid unnecessary resizing. */
|
cfun->eh->exception_handler_label_map
|
cfun->eh->exception_handler_label_map
|
= htab_create_ggc (cfun->eh->last_region_number * 3 / 2,
|
= htab_create_ggc (cfun->eh->last_region_number * 3 / 2,
|
ehl_hash, ehl_eq, NULL);
|
ehl_hash, ehl_eq, NULL);
|
}
|
}
|
|
|
if (cfun->eh->region_tree == NULL)
|
if (cfun->eh->region_tree == NULL)
|
return;
|
return;
|
|
|
for (i = cfun->eh->last_region_number; i > 0; --i)
|
for (i = cfun->eh->last_region_number; i > 0; --i)
|
{
|
{
|
struct eh_region *region;
|
struct eh_region *region;
|
rtx lab;
|
rtx lab;
|
|
|
region = VEC_index (eh_region, cfun->eh->region_array, i);
|
region = VEC_index (eh_region, cfun->eh->region_array, i);
|
if (! region || region->region_number != i)
|
if (! region || region->region_number != i)
|
continue;
|
continue;
|
if (cfun->eh->built_landing_pads)
|
if (cfun->eh->built_landing_pads)
|
lab = region->landing_pad;
|
lab = region->landing_pad;
|
else
|
else
|
lab = region->label;
|
lab = region->label;
|
|
|
if (lab)
|
if (lab)
|
add_ehl_entry (lab, region);
|
add_ehl_entry (lab, region);
|
}
|
}
|
|
|
/* For sjlj exceptions, need the return label to remain live until
|
/* For sjlj exceptions, need the return label to remain live until
|
after landing pad generation. */
|
after landing pad generation. */
|
if (USING_SJLJ_EXCEPTIONS && ! cfun->eh->built_landing_pads)
|
if (USING_SJLJ_EXCEPTIONS && ! cfun->eh->built_landing_pads)
|
add_ehl_entry (return_label, NULL);
|
add_ehl_entry (return_label, NULL);
|
}
|
}
|
|
|
/* 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)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = cfun->eh->last_region_number; i > 0; --i)
|
for (i = cfun->eh->last_region_number; i > 0; --i)
|
{
|
{
|
struct eh_region *region;
|
struct eh_region *region;
|
|
|
region = VEC_index (eh_region, cfun->eh->region_array, i);
|
region = VEC_index (eh_region, cfun->eh->region_array, i);
|
if (region
|
if (region
|
&& region->region_number == i
|
&& region->region_number == i
|
&& region->type != ERT_THROW)
|
&& region->type != ERT_THROW)
|
return true;
|
return true;
|
}
|
}
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
/* A subroutine of duplicate_eh_regions. Search the region tree under O
|
/* A subroutine of duplicate_eh_regions. Search the region tree under O
|
for the minimum and maximum region numbers. Update *MIN and *MAX. */
|
for the minimum and maximum region numbers. Update *MIN and *MAX. */
|
|
|
static void
|
static void
|
duplicate_eh_regions_0 (eh_region o, int *min, int *max)
|
duplicate_eh_regions_0 (eh_region o, int *min, int *max)
|
{
|
{
|
if (o->region_number < *min)
|
if (o->region_number < *min)
|
*min = o->region_number;
|
*min = o->region_number;
|
if (o->region_number > *max)
|
if (o->region_number > *max)
|
*max = o->region_number;
|
*max = o->region_number;
|
|
|
if (o->inner)
|
if (o->inner)
|
{
|
{
|
o = o->inner;
|
o = o->inner;
|
duplicate_eh_regions_0 (o, min, max);
|
duplicate_eh_regions_0 (o, min, max);
|
while (o->next_peer)
|
while (o->next_peer)
|
{
|
{
|
o = o->next_peer;
|
o = o->next_peer;
|
duplicate_eh_regions_0 (o, min, max);
|
duplicate_eh_regions_0 (o, min, max);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* A subroutine of duplicate_eh_regions. Copy the region tree under OLD.
|
/* A subroutine of duplicate_eh_regions. Copy the region tree under OLD.
|
Root it at OUTER, and apply EH_OFFSET to the region number. Don't worry
|
Root it at OUTER, and apply EH_OFFSET to the region number. Don't worry
|
about the other internal pointers just yet, just the tree-like pointers. */
|
about the other internal pointers just yet, just the tree-like pointers. */
|
|
|
static eh_region
|
static eh_region
|
duplicate_eh_regions_1 (eh_region old, eh_region outer, int eh_offset)
|
duplicate_eh_regions_1 (eh_region old, eh_region outer, int eh_offset)
|
{
|
{
|
eh_region ret, n;
|
eh_region ret, n;
|
|
|
ret = n = ggc_alloc (sizeof (struct eh_region));
|
ret = n = ggc_alloc (sizeof (struct eh_region));
|
|
|
*n = *old;
|
*n = *old;
|
n->outer = outer;
|
n->outer = outer;
|
n->next_peer = NULL;
|
n->next_peer = NULL;
|
gcc_assert (!old->aka);
|
gcc_assert (!old->aka);
|
|
|
n->region_number += eh_offset;
|
n->region_number += eh_offset;
|
VEC_replace (eh_region, cfun->eh->region_array, n->region_number, n);
|
VEC_replace (eh_region, cfun->eh->region_array, n->region_number, n);
|
|
|
if (old->inner)
|
if (old->inner)
|
{
|
{
|
old = old->inner;
|
old = old->inner;
|
n = n->inner = duplicate_eh_regions_1 (old, ret, eh_offset);
|
n = n->inner = duplicate_eh_regions_1 (old, ret, eh_offset);
|
while (old->next_peer)
|
while (old->next_peer)
|
{
|
{
|
old = old->next_peer;
|
old = old->next_peer;
|
n = n->next_peer = duplicate_eh_regions_1 (old, ret, eh_offset);
|
n = n->next_peer = duplicate_eh_regions_1 (old, ret, eh_offset);
|
}
|
}
|
}
|
}
|
|
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* Duplicate the EH regions of IFUN, rooted at COPY_REGION, into current
|
/* Duplicate the EH regions of IFUN, rooted at COPY_REGION, into current
|
function and root the tree below OUTER_REGION. Remap labels using MAP
|
function and root the tree below OUTER_REGION. Remap labels using MAP
|
callback. The special case of COPY_REGION of 0 means all regions. */
|
callback. The special case of COPY_REGION of 0 means all regions. */
|
|
|
int
|
int
|
duplicate_eh_regions (struct function *ifun, duplicate_eh_regions_map map,
|
duplicate_eh_regions (struct function *ifun, duplicate_eh_regions_map map,
|
void *data, int copy_region, int outer_region)
|
void *data, int copy_region, int outer_region)
|
{
|
{
|
eh_region cur, prev_try, outer, *splice;
|
eh_region cur, prev_try, outer, *splice;
|
int i, min_region, max_region, eh_offset, cfun_last_region_number;
|
int i, min_region, max_region, eh_offset, cfun_last_region_number;
|
int num_regions;
|
int num_regions;
|
|
|
if (!ifun->eh->region_tree)
|
if (!ifun->eh->region_tree)
|
return 0;
|
return 0;
|
|
|
/* Find the range of region numbers to be copied. The interface we
|
/* Find the range of region numbers to be copied. The interface we
|
provide here mandates a single offset to find new number from old,
|
provide here mandates a single offset to find new number from old,
|
which means we must look at the numbers present, instead of the
|
which means we must look at the numbers present, instead of the
|
count or something else. */
|
count or something else. */
|
if (copy_region > 0)
|
if (copy_region > 0)
|
{
|
{
|
min_region = INT_MAX;
|
min_region = INT_MAX;
|
max_region = 0;
|
max_region = 0;
|
|
|
cur = VEC_index (eh_region, ifun->eh->region_array, copy_region);
|
cur = VEC_index (eh_region, ifun->eh->region_array, copy_region);
|
duplicate_eh_regions_0 (cur, &min_region, &max_region);
|
duplicate_eh_regions_0 (cur, &min_region, &max_region);
|
}
|
}
|
else
|
else
|
min_region = 1, max_region = ifun->eh->last_region_number;
|
min_region = 1, max_region = ifun->eh->last_region_number;
|
num_regions = max_region - min_region + 1;
|
num_regions = max_region - min_region + 1;
|
cfun_last_region_number = cfun->eh->last_region_number;
|
cfun_last_region_number = cfun->eh->last_region_number;
|
eh_offset = cfun_last_region_number + 1 - min_region;
|
eh_offset = cfun_last_region_number + 1 - min_region;
|
|
|
/* If we've not yet created a region array, do so now. */
|
/* If we've not yet created a region array, do so now. */
|
VEC_safe_grow (eh_region, gc, cfun->eh->region_array,
|
VEC_safe_grow (eh_region, gc, cfun->eh->region_array,
|
cfun_last_region_number + 1 + num_regions);
|
cfun_last_region_number + 1 + num_regions);
|
cfun->eh->last_region_number = max_region + eh_offset;
|
cfun->eh->last_region_number = max_region + eh_offset;
|
|
|
/* We may have just allocated the array for the first time.
|
/* We may have just allocated the array for the first time.
|
Make sure that element zero is null. */
|
Make sure that element zero is null. */
|
VEC_replace (eh_region, cfun->eh->region_array, 0, 0);
|
VEC_replace (eh_region, cfun->eh->region_array, 0, 0);
|
|
|
/* Zero all entries in the range allocated. */
|
/* Zero all entries in the range allocated. */
|
memset (VEC_address (eh_region, cfun->eh->region_array)
|
memset (VEC_address (eh_region, cfun->eh->region_array)
|
+ cfun_last_region_number + 1, 0, num_regions * sizeof (eh_region));
|
+ cfun_last_region_number + 1, 0, num_regions * sizeof (eh_region));
|
|
|
/* Locate the spot at which to insert the new tree. */
|
/* Locate the spot at which to insert the new tree. */
|
if (outer_region > 0)
|
if (outer_region > 0)
|
{
|
{
|
outer = VEC_index (eh_region, cfun->eh->region_array, outer_region);
|
outer = VEC_index (eh_region, cfun->eh->region_array, outer_region);
|
splice = &outer->inner;
|
splice = &outer->inner;
|
}
|
}
|
else
|
else
|
{
|
{
|
outer = NULL;
|
outer = NULL;
|
splice = &cfun->eh->region_tree;
|
splice = &cfun->eh->region_tree;
|
}
|
}
|
while (*splice)
|
while (*splice)
|
splice = &(*splice)->next_peer;
|
splice = &(*splice)->next_peer;
|
|
|
/* Copy all the regions in the subtree. */
|
/* Copy all the regions in the subtree. */
|
if (copy_region > 0)
|
if (copy_region > 0)
|
{
|
{
|
cur = VEC_index (eh_region, ifun->eh->region_array, copy_region);
|
cur = VEC_index (eh_region, ifun->eh->region_array, copy_region);
|
*splice = duplicate_eh_regions_1 (cur, outer, eh_offset);
|
*splice = duplicate_eh_regions_1 (cur, outer, eh_offset);
|
}
|
}
|
else
|
else
|
{
|
{
|
eh_region n;
|
eh_region n;
|
|
|
cur = ifun->eh->region_tree;
|
cur = ifun->eh->region_tree;
|
*splice = n = duplicate_eh_regions_1 (cur, outer, eh_offset);
|
*splice = n = duplicate_eh_regions_1 (cur, outer, eh_offset);
|
while (cur->next_peer)
|
while (cur->next_peer)
|
{
|
{
|
cur = cur->next_peer;
|
cur = cur->next_peer;
|
n = n->next_peer = duplicate_eh_regions_1 (cur, outer, eh_offset);
|
n = n->next_peer = duplicate_eh_regions_1 (cur, outer, eh_offset);
|
}
|
}
|
}
|
}
|
|
|
/* Remap all the labels in the new regions. */
|
/* Remap all the labels in the new regions. */
|
for (i = cfun_last_region_number + 1;
|
for (i = cfun_last_region_number + 1;
|
VEC_iterate (eh_region, cfun->eh->region_array, i, cur); ++i)
|
VEC_iterate (eh_region, cfun->eh->region_array, i, cur); ++i)
|
if (cur && cur->tree_label)
|
if (cur && cur->tree_label)
|
cur->tree_label = map (cur->tree_label, data);
|
cur->tree_label = map (cur->tree_label, data);
|
|
|
/* Search for the containing ERT_TRY region to fix up
|
/* Search for the containing ERT_TRY region to fix up
|
the prev_try short-cuts for ERT_CLEANUP regions. */
|
the prev_try short-cuts for ERT_CLEANUP regions. */
|
prev_try = NULL;
|
prev_try = NULL;
|
if (outer_region > 0)
|
if (outer_region > 0)
|
for (prev_try = VEC_index (eh_region, cfun->eh->region_array, outer_region);
|
for (prev_try = VEC_index (eh_region, cfun->eh->region_array, outer_region);
|
prev_try && prev_try->type != ERT_TRY;
|
prev_try && prev_try->type != ERT_TRY;
|
prev_try = prev_try->outer)
|
prev_try = prev_try->outer)
|
if (prev_try->type == ERT_MUST_NOT_THROW)
|
if (prev_try->type == ERT_MUST_NOT_THROW)
|
{
|
{
|
prev_try = NULL;
|
prev_try = NULL;
|
break;
|
break;
|
}
|
}
|
|
|
/* Remap all of the internal catch and cleanup linkages. Since we
|
/* Remap all of the internal catch and cleanup linkages. Since we
|
duplicate entire subtrees, all of the referenced regions will have
|
duplicate entire subtrees, all of the referenced regions will have
|
been copied too. And since we renumbered them as a block, a simple
|
been copied too. And since we renumbered them as a block, a simple
|
bit of arithmetic finds us the index for the replacement region. */
|
bit of arithmetic finds us the index for the replacement region. */
|
for (i = cfun_last_region_number + 1;
|
for (i = cfun_last_region_number + 1;
|
VEC_iterate (eh_region, cfun->eh->region_array, i, cur); ++i)
|
VEC_iterate (eh_region, cfun->eh->region_array, i, cur); ++i)
|
{
|
{
|
if (cur == NULL)
|
if (cur == NULL)
|
continue;
|
continue;
|
|
|
#define REMAP(REG) \
|
#define REMAP(REG) \
|
(REG) = VEC_index (eh_region, cfun->eh->region_array, \
|
(REG) = VEC_index (eh_region, cfun->eh->region_array, \
|
(REG)->region_number + eh_offset)
|
(REG)->region_number + eh_offset)
|
|
|
switch (cur->type)
|
switch (cur->type)
|
{
|
{
|
case ERT_TRY:
|
case ERT_TRY:
|
if (cur->u.try.catch)
|
if (cur->u.try.catch)
|
REMAP (cur->u.try.catch);
|
REMAP (cur->u.try.catch);
|
if (cur->u.try.last_catch)
|
if (cur->u.try.last_catch)
|
REMAP (cur->u.try.last_catch);
|
REMAP (cur->u.try.last_catch);
|
break;
|
break;
|
|
|
case ERT_CATCH:
|
case ERT_CATCH:
|
if (cur->u.catch.next_catch)
|
if (cur->u.catch.next_catch)
|
REMAP (cur->u.catch.next_catch);
|
REMAP (cur->u.catch.next_catch);
|
if (cur->u.catch.prev_catch)
|
if (cur->u.catch.prev_catch)
|
REMAP (cur->u.catch.prev_catch);
|
REMAP (cur->u.catch.prev_catch);
|
break;
|
break;
|
|
|
case ERT_CLEANUP:
|
case ERT_CLEANUP:
|
if (cur->u.cleanup.prev_try)
|
if (cur->u.cleanup.prev_try)
|
REMAP (cur->u.cleanup.prev_try);
|
REMAP (cur->u.cleanup.prev_try);
|
else
|
else
|
cur->u.cleanup.prev_try = prev_try;
|
cur->u.cleanup.prev_try = prev_try;
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
#undef REMAP
|
#undef REMAP
|
}
|
}
|
|
|
return eh_offset;
|
return eh_offset;
|
}
|
}
|
|
|
/* Return true if REGION_A is outer to REGION_B in IFUN. */
|
/* Return true if REGION_A is outer to REGION_B in IFUN. */
|
|
|
bool
|
bool
|
eh_region_outer_p (struct function *ifun, int region_a, int region_b)
|
eh_region_outer_p (struct function *ifun, int region_a, int region_b)
|
{
|
{
|
struct eh_region *rp_a, *rp_b;
|
struct eh_region *rp_a, *rp_b;
|
|
|
gcc_assert (ifun->eh->last_region_number > 0);
|
gcc_assert (ifun->eh->last_region_number > 0);
|
gcc_assert (ifun->eh->region_tree);
|
gcc_assert (ifun->eh->region_tree);
|
|
|
rp_a = VEC_index (eh_region, ifun->eh->region_array, region_a);
|
rp_a = VEC_index (eh_region, ifun->eh->region_array, region_a);
|
rp_b = VEC_index (eh_region, ifun->eh->region_array, region_b);
|
rp_b = VEC_index (eh_region, ifun->eh->region_array, region_b);
|
gcc_assert (rp_a != NULL);
|
gcc_assert (rp_a != NULL);
|
gcc_assert (rp_b != NULL);
|
gcc_assert (rp_b != NULL);
|
|
|
do
|
do
|
{
|
{
|
if (rp_a == rp_b)
|
if (rp_a == rp_b)
|
return true;
|
return true;
|
rp_b = rp_b->outer;
|
rp_b = rp_b->outer;
|
}
|
}
|
while (rp_b);
|
while (rp_b);
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Return region number of region that is outer to both if REGION_A and
|
/* Return region number of region that is outer to both if REGION_A and
|
REGION_B in IFUN. */
|
REGION_B in IFUN. */
|
|
|
int
|
int
|
eh_region_outermost (struct function *ifun, int region_a, int region_b)
|
eh_region_outermost (struct function *ifun, int region_a, int region_b)
|
{
|
{
|
struct eh_region *rp_a, *rp_b;
|
struct eh_region *rp_a, *rp_b;
|
sbitmap b_outer;
|
sbitmap b_outer;
|
|
|
gcc_assert (ifun->eh->last_region_number > 0);
|
gcc_assert (ifun->eh->last_region_number > 0);
|
gcc_assert (ifun->eh->region_tree);
|
gcc_assert (ifun->eh->region_tree);
|
|
|
rp_a = VEC_index (eh_region, ifun->eh->region_array, region_a);
|
rp_a = VEC_index (eh_region, ifun->eh->region_array, region_a);
|
rp_b = VEC_index (eh_region, ifun->eh->region_array, region_b);
|
rp_b = VEC_index (eh_region, ifun->eh->region_array, region_b);
|
gcc_assert (rp_a != NULL);
|
gcc_assert (rp_a != NULL);
|
gcc_assert (rp_b != NULL);
|
gcc_assert (rp_b != NULL);
|
|
|
b_outer = sbitmap_alloc (ifun->eh->last_region_number + 1);
|
b_outer = sbitmap_alloc (ifun->eh->last_region_number + 1);
|
sbitmap_zero (b_outer);
|
sbitmap_zero (b_outer);
|
|
|
do
|
do
|
{
|
{
|
SET_BIT (b_outer, rp_b->region_number);
|
SET_BIT (b_outer, rp_b->region_number);
|
rp_b = rp_b->outer;
|
rp_b = rp_b->outer;
|
}
|
}
|
while (rp_b);
|
while (rp_b);
|
|
|
do
|
do
|
{
|
{
|
if (TEST_BIT (b_outer, rp_a->region_number))
|
if (TEST_BIT (b_outer, rp_a->region_number))
|
{
|
{
|
sbitmap_free (b_outer);
|
sbitmap_free (b_outer);
|
return rp_a->region_number;
|
return rp_a->region_number;
|
}
|
}
|
rp_a = rp_a->outer;
|
rp_a = rp_a->outer;
|
}
|
}
|
while (rp_a);
|
while (rp_a);
|
|
|
sbitmap_free (b_outer);
|
sbitmap_free (b_outer);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
static int
|
static int
|
t2r_eq (const void *pentry, const void *pdata)
|
t2r_eq (const void *pentry, const void *pdata)
|
{
|
{
|
tree entry = (tree) pentry;
|
tree entry = (tree) pentry;
|
tree data = (tree) pdata;
|
tree data = (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)
|
{
|
{
|
tree entry = (tree) pentry;
|
tree entry = (tree) pentry;
|
return TREE_HASH (TREE_PURPOSE (entry));
|
return TREE_HASH (TREE_PURPOSE (entry));
|
}
|
}
|
|
|
static void
|
static void
|
add_type_for_runtime (tree type)
|
add_type_for_runtime (tree type)
|
{
|
{
|
tree *slot;
|
tree *slot;
|
|
|
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_eh_runtime_type) (type);
|
tree runtime = (*lang_eh_runtime_type) (type);
|
*slot = tree_cons (type, runtime, NULL_TREE);
|
*slot = tree_cons (type, runtime, NULL_TREE);
|
}
|
}
|
}
|
}
|
|
|
static tree
|
static tree
|
lookup_type_for_runtime (tree type)
|
lookup_type_for_runtime (tree type)
|
{
|
{
|
tree *slot;
|
tree *slot;
|
|
|
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 ttypes_filter GTY(())
|
struct ttypes_filter GTY(())
|
{
|
{
|
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 *entry = (const struct ttypes_filter *) pentry;
|
const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry;
|
tree data = (tree) pdata;
|
tree data = (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)
|
{
|
{
|
/* 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 = -(VARRAY_ACTIVE_SIZE (cfun->eh->ehspec_data) + 1);
|
n->filter = -(VARRAY_ACTIVE_SIZE (cfun->eh->ehspec_data) + 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)
|
VARRAY_PUSH_TREE (cfun->eh->ehspec_data, TREE_VALUE (list));
|
VARRAY_PUSH_TREE (cfun->eh->ehspec_data, 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,
|
push_uleb128 (&cfun->eh->ehspec_data,
|
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)
|
VARRAY_PUSH_TREE (cfun->eh->ehspec_data, NULL_TREE);
|
VARRAY_PUSH_TREE (cfun->eh->ehspec_data, NULL_TREE);
|
else
|
else
|
VARRAY_PUSH_UCHAR (cfun->eh->ehspec_data, 0);
|
VARRAY_PUSH_UCHAR (cfun->eh->ehspec_data, 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. */
|
|
|
static void
|
static void
|
assign_filter_values (void)
|
assign_filter_values (void)
|
{
|
{
|
int i;
|
int i;
|
htab_t ttypes, ehspec;
|
htab_t ttypes, ehspec;
|
|
|
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)
|
VARRAY_TREE_INIT (cfun->eh->ehspec_data, 64, "ehspec_data");
|
VARRAY_TREE_INIT (cfun->eh->ehspec_data, 64, "ehspec_data");
|
else
|
else
|
VARRAY_UCHAR_INIT (cfun->eh->ehspec_data, 64, "ehspec_data");
|
VARRAY_UCHAR_INIT (cfun->eh->ehspec_data, 64, "ehspec_data");
|
|
|
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 = cfun->eh->last_region_number; i > 0; --i)
|
for (i = cfun->eh->last_region_number; i > 0; --i)
|
{
|
{
|
struct eh_region *r;
|
struct eh_region *r;
|
|
|
r = VEC_index (eh_region, cfun->eh->region_array, i);
|
r = VEC_index (eh_region, cfun->eh->region_array, i);
|
|
|
/* Mind we don't process a region more than once. */
|
/* Mind we don't process a region more than once. */
|
if (!r || r->region_number != i)
|
if (!r || r->region_number != i)
|
continue;
|
continue;
|
|
|
switch (r->type)
|
switch (r->type)
|
{
|
{
|
case ERT_CATCH:
|
case ERT_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. */
|
r->u.catch.filter_list = NULL_TREE;
|
r->u.catch.filter_list = NULL_TREE;
|
|
|
if (r->u.catch.type_list != NULL)
|
if (r->u.catch.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 = r->u.catch.type_list;
|
tree tp_node = r->u.catch.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);
|
|
|
r->u.catch.filter_list
|
r->u.catch.filter_list
|
= tree_cons (NULL_TREE, flt_node, r->u.catch.filter_list);
|
= tree_cons (NULL_TREE, flt_node, r->u.catch.filter_list);
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Get a filter value for the NULL list also since it will need
|
/* Get a filter value for the NULL list also since it will need
|
an action record anyway. */
|
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);
|
|
|
r->u.catch.filter_list
|
r->u.catch.filter_list
|
= tree_cons (NULL_TREE, flt_node, r->u.catch.filter_list);
|
= tree_cons (NULL_TREE, flt_node, r->u.catch.filter_list);
|
}
|
}
|
|
|
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;
|
}
|
}
|
|
|
/* Generate the code to actually handle exceptions, which will follow the
|
/* Generate the code to actually handle exceptions, which will follow the
|
landing pads. */
|
landing pads. */
|
|
|
static void
|
static void
|
build_post_landing_pads (void)
|
build_post_landing_pads (void)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = cfun->eh->last_region_number; i > 0; --i)
|
for (i = cfun->eh->last_region_number; i > 0; --i)
|
{
|
{
|
struct eh_region *region;
|
struct eh_region *region;
|
rtx seq;
|
rtx seq;
|
|
|
region = VEC_index (eh_region, cfun->eh->region_array, i);
|
region = VEC_index (eh_region, cfun->eh->region_array, i);
|
/* Mind we don't process a region more than once. */
|
/* Mind we don't process a region more than once. */
|
if (!region || region->region_number != i)
|
if (!region || region->region_number != i)
|
continue;
|
continue;
|
|
|
switch (region->type)
|
switch (region->type)
|
{
|
{
|
case ERT_TRY:
|
case ERT_TRY:
|
/* ??? Collect the set of all non-overlapping catch handlers
|
/* ??? Collect the set of all non-overlapping catch handlers
|
all the way up the chain until blocked by a cleanup. */
|
all the way up the chain until blocked by a cleanup. */
|
/* ??? Outer try regions can share landing pads with inner
|
/* ??? Outer try regions can share landing pads with inner
|
try regions if the types are completely non-overlapping,
|
try regions if the types are completely non-overlapping,
|
and there are no intervening cleanups. */
|
and there are no intervening cleanups. */
|
|
|
region->post_landing_pad = gen_label_rtx ();
|
region->post_landing_pad = gen_label_rtx ();
|
|
|
start_sequence ();
|
start_sequence ();
|
|
|
emit_label (region->post_landing_pad);
|
emit_label (region->post_landing_pad);
|
|
|
/* ??? It is mighty inconvenient to call back into the
|
/* ??? It is mighty inconvenient to call back into the
|
switch statement generation code in expand_end_case.
|
switch statement generation code in expand_end_case.
|
Rapid prototyping sez a sequence of ifs. */
|
Rapid prototyping sez a sequence of ifs. */
|
{
|
{
|
struct eh_region *c;
|
struct eh_region *c;
|
for (c = region->u.try.catch; c ; c = c->u.catch.next_catch)
|
for (c = region->u.try.catch; c ; c = c->u.catch.next_catch)
|
{
|
{
|
if (c->u.catch.type_list == NULL)
|
if (c->u.catch.type_list == NULL)
|
emit_jump (c->label);
|
emit_jump (c->label);
|
else
|
else
|
{
|
{
|
/* Need for one cmp/jump per type caught. Each type
|
/* Need for one cmp/jump per type caught. Each type
|
list entry has a matching entry in the filter list
|
list entry has a matching entry in the filter list
|
(see assign_filter_values). */
|
(see assign_filter_values). */
|
tree tp_node = c->u.catch.type_list;
|
tree tp_node = c->u.catch.type_list;
|
tree flt_node = c->u.catch.filter_list;
|
tree flt_node = c->u.catch.filter_list;
|
|
|
for (; tp_node; )
|
for (; tp_node; )
|
{
|
{
|
emit_cmp_and_jump_insns
|
emit_cmp_and_jump_insns
|
(cfun->eh->filter,
|
(cfun->eh->filter,
|
GEN_INT (tree_low_cst (TREE_VALUE (flt_node), 0)),
|
GEN_INT (tree_low_cst (TREE_VALUE (flt_node), 0)),
|
EQ, NULL_RTX,
|
EQ, NULL_RTX,
|
targetm.eh_return_filter_mode (), 0, c->label);
|
targetm.eh_return_filter_mode (), 0, c->label);
|
|
|
tp_node = TREE_CHAIN (tp_node);
|
tp_node = TREE_CHAIN (tp_node);
|
flt_node = TREE_CHAIN (flt_node);
|
flt_node = TREE_CHAIN (flt_node);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* We delay the generation of the _Unwind_Resume until we generate
|
/* We delay the generation of the _Unwind_Resume until we generate
|
landing pads. We emit a marker here so as to get good control
|
landing pads. We emit a marker here so as to get good control
|
flow data in the meantime. */
|
flow data in the meantime. */
|
region->resume
|
region->resume
|
= emit_jump_insn (gen_rtx_RESX (VOIDmode, region->region_number));
|
= emit_jump_insn (gen_rtx_RESX (VOIDmode, region->region_number));
|
emit_barrier ();
|
emit_barrier ();
|
|
|
seq = get_insns ();
|
seq = get_insns ();
|
end_sequence ();
|
end_sequence ();
|
|
|
emit_to_new_bb_before (seq, region->u.try.catch->label);
|
emit_to_new_bb_before (seq, region->u.try.catch->label);
|
|
|
break;
|
break;
|
|
|
case ERT_ALLOWED_EXCEPTIONS:
|
case ERT_ALLOWED_EXCEPTIONS:
|
region->post_landing_pad = gen_label_rtx ();
|
region->post_landing_pad = gen_label_rtx ();
|
|
|
start_sequence ();
|
start_sequence ();
|
|
|
emit_label (region->post_landing_pad);
|
emit_label (region->post_landing_pad);
|
|
|
emit_cmp_and_jump_insns (cfun->eh->filter,
|
emit_cmp_and_jump_insns (cfun->eh->filter,
|
GEN_INT (region->u.allowed.filter),
|
GEN_INT (region->u.allowed.filter),
|
EQ, NULL_RTX,
|
EQ, NULL_RTX,
|
targetm.eh_return_filter_mode (), 0, region->label);
|
targetm.eh_return_filter_mode (), 0, region->label);
|
|
|
/* We delay the generation of the _Unwind_Resume until we generate
|
/* We delay the generation of the _Unwind_Resume until we generate
|
landing pads. We emit a marker here so as to get good control
|
landing pads. We emit a marker here so as to get good control
|
flow data in the meantime. */
|
flow data in the meantime. */
|
region->resume
|
region->resume
|
= emit_jump_insn (gen_rtx_RESX (VOIDmode, region->region_number));
|
= emit_jump_insn (gen_rtx_RESX (VOIDmode, region->region_number));
|
emit_barrier ();
|
emit_barrier ();
|
|
|
seq = get_insns ();
|
seq = get_insns ();
|
end_sequence ();
|
end_sequence ();
|
|
|
emit_to_new_bb_before (seq, region->label);
|
emit_to_new_bb_before (seq, region->label);
|
break;
|
break;
|
|
|
case ERT_CLEANUP:
|
case ERT_CLEANUP:
|
case ERT_MUST_NOT_THROW:
|
case ERT_MUST_NOT_THROW:
|
region->post_landing_pad = region->label;
|
region->post_landing_pad = region->label;
|
break;
|
break;
|
|
|
case ERT_CATCH:
|
case ERT_CATCH:
|
case ERT_THROW:
|
case ERT_THROW:
|
/* Nothing to do. */
|
/* Nothing to do. */
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Replace RESX patterns with jumps to the next handler if any, or calls to
|
/* Replace RESX patterns with jumps to the next handler if any, or calls to
|
_Unwind_Resume otherwise. */
|
_Unwind_Resume otherwise. */
|
|
|
static void
|
static void
|
connect_post_landing_pads (void)
|
connect_post_landing_pads (void)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = cfun->eh->last_region_number; i > 0; --i)
|
for (i = cfun->eh->last_region_number; i > 0; --i)
|
{
|
{
|
struct eh_region *region;
|
struct eh_region *region;
|
struct eh_region *outer;
|
struct eh_region *outer;
|
rtx seq;
|
rtx seq;
|
rtx barrier;
|
rtx barrier;
|
|
|
region = VEC_index (eh_region, cfun->eh->region_array, i);
|
region = VEC_index (eh_region, cfun->eh->region_array, i);
|
/* Mind we don't process a region more than once. */
|
/* Mind we don't process a region more than once. */
|
if (!region || region->region_number != i)
|
if (!region || region->region_number != i)
|
continue;
|
continue;
|
|
|
/* If there is no RESX, or it has been deleted by flow, there's
|
/* If there is no RESX, or it has been deleted by flow, there's
|
nothing to fix up. */
|
nothing to fix up. */
|
if (! region->resume || INSN_DELETED_P (region->resume))
|
if (! region->resume || INSN_DELETED_P (region->resume))
|
continue;
|
continue;
|
|
|
/* Search for another landing pad in this function. */
|
/* Search for another landing pad in this function. */
|
for (outer = region->outer; outer ; outer = outer->outer)
|
for (outer = region->outer; outer ; outer = outer->outer)
|
if (outer->post_landing_pad)
|
if (outer->post_landing_pad)
|
break;
|
break;
|
|
|
start_sequence ();
|
start_sequence ();
|
|
|
if (outer)
|
if (outer)
|
{
|
{
|
edge e;
|
edge e;
|
basic_block src, dest;
|
basic_block src, dest;
|
|
|
emit_jump (outer->post_landing_pad);
|
emit_jump (outer->post_landing_pad);
|
src = BLOCK_FOR_INSN (region->resume);
|
src = BLOCK_FOR_INSN (region->resume);
|
dest = BLOCK_FOR_INSN (outer->post_landing_pad);
|
dest = BLOCK_FOR_INSN (outer->post_landing_pad);
|
while (EDGE_COUNT (src->succs) > 0)
|
while (EDGE_COUNT (src->succs) > 0)
|
remove_edge (EDGE_SUCC (src, 0));
|
remove_edge (EDGE_SUCC (src, 0));
|
e = make_edge (src, dest, 0);
|
e = make_edge (src, dest, 0);
|
e->probability = REG_BR_PROB_BASE;
|
e->probability = REG_BR_PROB_BASE;
|
e->count = src->count;
|
e->count = src->count;
|
}
|
}
|
else
|
else
|
{
|
{
|
emit_library_call (unwind_resume_libfunc, LCT_THROW,
|
emit_library_call (unwind_resume_libfunc, LCT_THROW,
|
VOIDmode, 1, cfun->eh->exc_ptr, ptr_mode);
|
VOIDmode, 1, cfun->eh->exc_ptr, ptr_mode);
|
|
|
/* What we just emitted was a throwing libcall, so it got a
|
/* What we just emitted was a throwing libcall, so it got a
|
barrier automatically added after it. If the last insn in
|
barrier automatically added after it. If the last insn in
|
the libcall sequence isn't the barrier, it's because the
|
the libcall sequence isn't the barrier, it's because the
|
target emits multiple insns for a call, and there are insns
|
target emits multiple insns for a call, and there are insns
|
after the actual call insn (which are redundant and would be
|
after the actual call insn (which are redundant and would be
|
optimized away). The barrier is inserted exactly after the
|
optimized away). The barrier is inserted exactly after the
|
call insn, so let's go get that and delete the insns after
|
call insn, so let's go get that and delete the insns after
|
it, because below we need the barrier to be the last insn in
|
it, because below we need the barrier to be the last insn in
|
the sequence. */
|
the sequence. */
|
delete_insns_since (NEXT_INSN (last_call_insn ()));
|
delete_insns_since (NEXT_INSN (last_call_insn ()));
|
}
|
}
|
|
|
seq = get_insns ();
|
seq = get_insns ();
|
end_sequence ();
|
end_sequence ();
|
barrier = emit_insn_before (seq, region->resume);
|
barrier = emit_insn_before (seq, region->resume);
|
/* Avoid duplicate barrier. */
|
/* Avoid duplicate barrier. */
|
gcc_assert (BARRIER_P (barrier));
|
gcc_assert (BARRIER_P (barrier));
|
delete_insn (barrier);
|
delete_insn (barrier);
|
delete_insn (region->resume);
|
delete_insn (region->resume);
|
|
|
/* ??? From tree-ssa we can wind up with catch regions whose
|
/* ??? From tree-ssa we can wind up with catch regions whose
|
label is not instantiated, but whose resx is present. Now
|
label is not instantiated, but whose resx is present. Now
|
that we've dealt with the resx, kill the region. */
|
that we've dealt with the resx, kill the region. */
|
if (region->label == NULL && region->type == ERT_CLEANUP)
|
if (region->label == NULL && region->type == ERT_CLEANUP)
|
remove_eh_handler (region);
|
remove_eh_handler (region);
|
}
|
}
|
}
|
}
|
|
|
|
|
static void
|
static void
|
dw2_build_landing_pads (void)
|
dw2_build_landing_pads (void)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = cfun->eh->last_region_number; i > 0; --i)
|
for (i = cfun->eh->last_region_number; i > 0; --i)
|
{
|
{
|
struct eh_region *region;
|
struct eh_region *region;
|
rtx seq;
|
rtx seq;
|
basic_block bb;
|
basic_block bb;
|
edge e;
|
edge e;
|
|
|
region = VEC_index (eh_region, cfun->eh->region_array, i);
|
region = VEC_index (eh_region, cfun->eh->region_array, i);
|
/* Mind we don't process a region more than once. */
|
/* Mind we don't process a region more than once. */
|
if (!region || region->region_number != i)
|
if (!region || region->region_number != i)
|
continue;
|
continue;
|
|
|
if (region->type != ERT_CLEANUP
|
if (region->type != ERT_CLEANUP
|
&& region->type != ERT_TRY
|
&& region->type != ERT_TRY
|
&& region->type != ERT_ALLOWED_EXCEPTIONS)
|
&& region->type != ERT_ALLOWED_EXCEPTIONS)
|
continue;
|
continue;
|
|
|
start_sequence ();
|
start_sequence ();
|
|
|
region->landing_pad = gen_label_rtx ();
|
region->landing_pad = gen_label_rtx ();
|
emit_label (region->landing_pad);
|
emit_label (region->landing_pad);
|
|
|
#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 */ }
|
|
|
emit_move_insn (cfun->eh->exc_ptr,
|
emit_move_insn (cfun->eh->exc_ptr,
|
gen_rtx_REG (ptr_mode, EH_RETURN_DATA_REGNO (0)));
|
gen_rtx_REG (ptr_mode, EH_RETURN_DATA_REGNO (0)));
|
emit_move_insn (cfun->eh->filter,
|
emit_move_insn (cfun->eh->filter,
|
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, region->post_landing_pad);
|
bb = emit_to_new_bb_before (seq, region->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;
|
}
|
}
|
}
|
}
|
|
|
|
|
struct sjlj_lp_info
|
struct sjlj_lp_info
|
{
|
{
|
int directly_reachable;
|
int directly_reachable;
|
int action_index;
|
int action_index;
|
int dispatch_index;
|
int dispatch_index;
|
int call_site_index;
|
int call_site_index;
|
};
|
};
|
|
|
static bool
|
static bool
|
sjlj_find_directly_reachable_regions (struct sjlj_lp_info *lp_info)
|
sjlj_find_directly_reachable_regions (struct sjlj_lp_info *lp_info)
|
{
|
{
|
rtx insn;
|
rtx insn;
|
bool found_one = false;
|
bool found_one = false;
|
|
|
for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
|
for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
|
{
|
{
|
struct eh_region *region;
|
struct eh_region *region;
|
enum reachable_code rc;
|
enum reachable_code rc;
|
tree type_thrown;
|
tree type_thrown;
|
rtx note;
|
rtx note;
|
|
|
if (! INSN_P (insn))
|
if (! INSN_P (insn))
|
continue;
|
continue;
|
|
|
note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
|
note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
|
if (!note || INTVAL (XEXP (note, 0)) <= 0)
|
if (!note || INTVAL (XEXP (note, 0)) <= 0)
|
continue;
|
continue;
|
|
|
region = VEC_index (eh_region, cfun->eh->region_array, INTVAL (XEXP (note, 0)));
|
region = VEC_index (eh_region, cfun->eh->region_array, INTVAL (XEXP (note, 0)));
|
|
|
type_thrown = NULL_TREE;
|
type_thrown = NULL_TREE;
|
if (region->type == ERT_THROW)
|
if (region->type == ERT_THROW)
|
{
|
{
|
type_thrown = region->u.throw.type;
|
type_thrown = region->u.throw.type;
|
region = region->outer;
|
region = region->outer;
|
}
|
}
|
|
|
/* Find the first containing region that might handle the exception.
|
/* Find the first containing region that might handle the exception.
|
That's the landing pad to which we will transfer control. */
|
That's the landing pad to which we will transfer control. */
|
rc = RNL_NOT_CAUGHT;
|
rc = RNL_NOT_CAUGHT;
|
for (; region; region = region->outer)
|
for (; region; region = region->outer)
|
{
|
{
|
rc = reachable_next_level (region, type_thrown, NULL);
|
rc = reachable_next_level (region, type_thrown, NULL);
|
if (rc != RNL_NOT_CAUGHT)
|
if (rc != RNL_NOT_CAUGHT)
|
break;
|
break;
|
}
|
}
|
if (rc == RNL_MAYBE_CAUGHT || rc == RNL_CAUGHT)
|
if (rc == RNL_MAYBE_CAUGHT || rc == RNL_CAUGHT)
|
{
|
{
|
lp_info[region->region_number].directly_reachable = 1;
|
lp_info[region->region_number].directly_reachable = 1;
|
found_one = true;
|
found_one = true;
|
}
|
}
|
}
|
}
|
|
|
return found_one;
|
return found_one;
|
}
|
}
|
|
|
static void
|
static void
|
sjlj_assign_call_site_values (rtx dispatch_label, struct sjlj_lp_info *lp_info)
|
sjlj_assign_call_site_values (rtx dispatch_label, struct sjlj_lp_info *lp_info)
|
{
|
{
|
htab_t ar_hash;
|
htab_t ar_hash;
|
int i, index;
|
int i, index;
|
|
|
/* First task: build the action table. */
|
/* First task: build the action table. */
|
|
|
VARRAY_UCHAR_INIT (cfun->eh->action_record_data, 64, "action_record_data");
|
VARRAY_UCHAR_INIT (cfun->eh->action_record_data, 64, "action_record_data");
|
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 (i = cfun->eh->last_region_number; i > 0; --i)
|
for (i = cfun->eh->last_region_number; i > 0; --i)
|
if (lp_info[i].directly_reachable)
|
if (lp_info[i].directly_reachable)
|
{
|
{
|
struct eh_region *r = VEC_index (eh_region, cfun->eh->region_array, i);
|
struct eh_region *r = VEC_index (eh_region, cfun->eh->region_array, i);
|
|
|
r->landing_pad = dispatch_label;
|
r->landing_pad = dispatch_label;
|
lp_info[i].action_index = collect_one_action_chain (ar_hash, r);
|
lp_info[i].action_index = collect_one_action_chain (ar_hash, r);
|
if (lp_info[i].action_index != -1)
|
if (lp_info[i].action_index != -1)
|
cfun->uses_eh_lsda = 1;
|
cfun->uses_eh_lsda = 1;
|
}
|
}
|
|
|
htab_delete (ar_hash);
|
htab_delete (ar_hash);
|
|
|
/* Next: assign dispatch values. In dwarf2 terms, this would be the
|
/* Next: assign dispatch values. In dwarf2 terms, this would be the
|
landing pad label for the region. For sjlj though, there is one
|
landing pad label for the region. For sjlj though, there is one
|
common landing pad from which we dispatch to the post-landing pads.
|
common landing pad from which we dispatch to the post-landing pads.
|
|
|
A region receives a dispatch index if it is directly reachable
|
A region receives a dispatch index if it is directly reachable
|
and requires in-function processing. Regions that share post-landing
|
and requires in-function processing. Regions that share post-landing
|
pads may share dispatch indices. */
|
pads may share dispatch indices. */
|
/* ??? Post-landing pad sharing doesn't actually happen at the moment
|
/* ??? Post-landing pad sharing doesn't actually happen at the moment
|
(see build_post_landing_pads) so we don't bother checking for it. */
|
(see build_post_landing_pads) so we don't bother checking for it. */
|
|
|
index = 0;
|
index = 0;
|
for (i = cfun->eh->last_region_number; i > 0; --i)
|
for (i = cfun->eh->last_region_number; i > 0; --i)
|
if (lp_info[i].directly_reachable)
|
if (lp_info[i].directly_reachable)
|
lp_info[i].dispatch_index = index++;
|
lp_info[i].dispatch_index = index++;
|
|
|
/* Finally: assign call-site values. If dwarf2 terms, this would be
|
/* Finally: 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. */
|
|
|
call_site_base = 1;
|
call_site_base = 1;
|
for (i = cfun->eh->last_region_number; i > 0; --i)
|
for (i = cfun->eh->last_region_number; i > 0; --i)
|
if (lp_info[i].directly_reachable)
|
if (lp_info[i].directly_reachable)
|
{
|
{
|
int action = lp_info[i].action_index;
|
int action = lp_info[i].action_index;
|
|
|
/* 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)
|
index = 0;
|
index = 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)
|
index = -1;
|
index = -1;
|
/* Otherwise, look it up in the table. */
|
/* Otherwise, look it up in the table. */
|
else
|
else
|
index = add_call_site (GEN_INT (lp_info[i].dispatch_index), action);
|
index = add_call_site (GEN_INT (lp_info[i].dispatch_index), action);
|
|
|
lp_info[i].call_site_index = index;
|
lp_info[i].call_site_index = index;
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
sjlj_mark_call_sites (struct sjlj_lp_info *lp_info)
|
sjlj_mark_call_sites (struct sjlj_lp_info *lp_info)
|
{
|
{
|
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))
|
{
|
{
|
struct eh_region *region;
|
struct eh_region *region;
|
int this_call_site;
|
int this_call_site;
|
rtx note, before, p;
|
rtx note, 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;
|
|
|
note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
|
note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
|
if (!note)
|
if (!note)
|
{
|
{
|
/* 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. */
|
if (CALL_P (insn)
|
if (CALL_P (insn)
|
|| (flag_non_call_exceptions
|
|| (flag_non_call_exceptions
|
&& may_trap_p (PATTERN (insn))))
|
&& may_trap_p (PATTERN (insn))))
|
this_call_site = -1;
|
this_call_site = -1;
|
else
|
else
|
continue;
|
continue;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Calls that are known to not throw need not be marked. */
|
/* Calls that are known to not throw need not be marked. */
|
if (INTVAL (XEXP (note, 0)) <= 0)
|
if (INTVAL (XEXP (note, 0)) <= 0)
|
continue;
|
continue;
|
|
|
region = VEC_index (eh_region, cfun->eh->region_array, INTVAL (XEXP (note, 0)));
|
region = VEC_index (eh_region, cfun->eh->region_array, INTVAL (XEXP (note, 0)));
|
this_call_site = lp_info[region->region_number].call_site_index;
|
this_call_site = lp_info[region->region_number].call_site_index;
|
}
|
}
|
|
|
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 (cfun->eh->sjlj_fc, TYPE_MODE (integer_type_node),
|
mem = adjust_address (cfun->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;
|
|
|
fc = cfun->eh->sjlj_fc;
|
fc = cfun->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 (eh_personality_libfunc);
|
assemble_external_libcall (eh_personality_libfunc);
|
mem = adjust_address (fc, Pmode, sjlj_fc_personality_ofs);
|
mem = adjust_address (fc, Pmode, sjlj_fc_personality_ofs);
|
emit_move_insn (mem, eh_personality_libfunc);
|
emit_move_insn (mem, eh_personality_libfunc);
|
|
|
mem = adjust_address (fc, Pmode, sjlj_fc_lsda_ofs);
|
mem = adjust_address (fc, Pmode, sjlj_fc_lsda_ofs);
|
if (cfun->uses_eh_lsda)
|
if (cfun->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, note;
|
rtx x, note;
|
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);
|
|
|
note = emit_note (NOTE_INSN_EXPECTED_VALUE);
|
note = emit_note (NOTE_INSN_EXPECTED_VALUE);
|
NOTE_EXPECTED_VALUE (note) = gen_rtx_EQ (VOIDmode, x, const0_rtx);
|
NOTE_EXPECTED_VALUE (note) = gen_rtx_EQ (VOIDmode, x, const0_rtx);
|
|
|
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);
|
}
|
}
|
#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_LINE_NUMBER (fn_begin) == NOTE_INSN_FUNCTION_BEG)
|
if (NOTE_LINE_NUMBER (fn_begin) == NOTE_INSN_FUNCTION_BEG)
|
break;
|
break;
|
else if (NOTE_LINE_NUMBER (fn_begin) == NOTE_INSN_BASIC_BLOCK)
|
else if (NOTE_LINE_NUMBER (fn_begin) == NOTE_INSN_BASIC_BLOCK)
|
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)
|
{
|
{
|
cfun->eh->sjlj_exit_after = after;
|
cfun->eh->sjlj_exit_after = after;
|
}
|
}
|
|
|
static void
|
static void
|
sjlj_emit_function_exit (void)
|
sjlj_emit_function_exit (void)
|
{
|
{
|
rtx seq;
|
rtx seq;
|
edge e;
|
edge e;
|
edge_iterator ei;
|
edge_iterator ei;
|
|
|
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 (cfun->eh->sjlj_fc, 0), Pmode);
|
1, XEXP (cfun->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. */
|
|
|
FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
|
FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
|
if (e->flags & EDGE_FALLTHRU)
|
if (e->flags & EDGE_FALLTHRU)
|
break;
|
break;
|
if (e)
|
if (e)
|
{
|
{
|
rtx insn;
|
rtx insn;
|
|
|
/* Figure out whether the place we are supposed to insert libcall
|
/* Figure out whether the place we are supposed to insert libcall
|
is inside the last basic block or after it. In the other case
|
is inside the last basic block or after it. In the other case
|
we need to emit to edge. */
|
we need to emit to edge. */
|
gcc_assert (e->src->next_bb == EXIT_BLOCK_PTR);
|
gcc_assert (e->src->next_bb == EXIT_BLOCK_PTR);
|
for (insn = BB_HEAD (e->src); ; insn = NEXT_INSN (insn))
|
for (insn = BB_HEAD (e->src); ; insn = NEXT_INSN (insn))
|
{
|
{
|
if (insn == cfun->eh->sjlj_exit_after)
|
if (insn == cfun->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);
|
return;
|
return;
|
}
|
}
|
if (insn == BB_END (e->src))
|
if (insn == BB_END (e->src))
|
break;
|
break;
|
}
|
}
|
insert_insn_on_edge (seq, e);
|
insert_insn_on_edge (seq, e);
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
sjlj_emit_dispatch_table (rtx dispatch_label, struct sjlj_lp_info *lp_info)
|
sjlj_emit_dispatch_table (rtx dispatch_label, struct sjlj_lp_info *lp_info)
|
{
|
{
|
int i, first_reachable;
|
int i, first_reachable;
|
rtx mem, dispatch, seq, fc;
|
rtx mem, dispatch, seq, fc;
|
rtx before;
|
rtx before;
|
basic_block bb;
|
basic_block bb;
|
edge e;
|
edge e;
|
|
|
fc = cfun->eh->sjlj_fc;
|
fc = cfun->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);
|
#endif
|
#endif
|
|
|
/* Load up dispatch index, exc_ptr and filter values from the
|
/* Load up dispatch index, exc_ptr and filter values from the
|
function context. */
|
function context. */
|
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);
|
dispatch = copy_to_reg (mem);
|
dispatch = copy_to_reg (mem);
|
|
|
mem = adjust_address (fc, word_mode, sjlj_fc_data_ofs);
|
mem = adjust_address (fc, word_mode, sjlj_fc_data_ofs);
|
if (word_mode != ptr_mode)
|
if (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
|
}
|
}
|
emit_move_insn (cfun->eh->exc_ptr, mem);
|
emit_move_insn (cfun->eh->exc_ptr, mem);
|
|
|
mem = adjust_address (fc, word_mode, sjlj_fc_data_ofs + UNITS_PER_WORD);
|
mem = adjust_address (fc, word_mode, sjlj_fc_data_ofs + UNITS_PER_WORD);
|
emit_move_insn (cfun->eh->filter, mem);
|
emit_move_insn (cfun->eh->filter, mem);
|
|
|
/* Jump to one of the directly reachable regions. */
|
/* Jump to one of the directly reachable regions. */
|
/* ??? This really ought to be using a switch statement. */
|
/* ??? This really ought to be using a switch statement. */
|
|
|
first_reachable = 0;
|
first_reachable = 0;
|
for (i = cfun->eh->last_region_number; i > 0; --i)
|
for (i = cfun->eh->last_region_number; i > 0; --i)
|
{
|
{
|
if (! lp_info[i].directly_reachable)
|
if (! lp_info[i].directly_reachable)
|
continue;
|
continue;
|
|
|
if (! first_reachable)
|
if (! first_reachable)
|
{
|
{
|
first_reachable = i;
|
first_reachable = i;
|
continue;
|
continue;
|
}
|
}
|
|
|
emit_cmp_and_jump_insns (dispatch, GEN_INT (lp_info[i].dispatch_index),
|
emit_cmp_and_jump_insns (dispatch, GEN_INT (lp_info[i].dispatch_index),
|
EQ, NULL_RTX, TYPE_MODE (integer_type_node), 0,
|
EQ, NULL_RTX, TYPE_MODE (integer_type_node), 0,
|
((struct eh_region *)VEC_index (eh_region, cfun->eh->region_array, i))
|
((struct eh_region *)VEC_index (eh_region, cfun->eh->region_array, i))
|
->post_landing_pad);
|
->post_landing_pad);
|
}
|
}
|
|
|
seq = get_insns ();
|
seq = get_insns ();
|
end_sequence ();
|
end_sequence ();
|
|
|
before = (((struct eh_region *)VEC_index (eh_region, cfun->eh->region_array, first_reachable))
|
before = (((struct eh_region *)VEC_index (eh_region, cfun->eh->region_array, first_reachable))
|
->post_landing_pad);
|
->post_landing_pad);
|
|
|
bb = emit_to_new_bb_before (seq, before);
|
bb = emit_to_new_bb_before (seq, 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;
|
}
|
}
|
|
|
static void
|
static void
|
sjlj_build_landing_pads (void)
|
sjlj_build_landing_pads (void)
|
{
|
{
|
struct sjlj_lp_info *lp_info;
|
struct sjlj_lp_info *lp_info;
|
|
|
lp_info = XCNEWVEC (struct sjlj_lp_info, cfun->eh->last_region_number + 1);
|
lp_info = XCNEWVEC (struct sjlj_lp_info, cfun->eh->last_region_number + 1);
|
|
|
if (sjlj_find_directly_reachable_regions (lp_info))
|
if (sjlj_find_directly_reachable_regions (lp_info))
|
{
|
{
|
rtx dispatch_label = gen_label_rtx ();
|
rtx dispatch_label = gen_label_rtx ();
|
|
|
cfun->eh->sjlj_fc
|
cfun->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),
|
TYPE_ALIGN (sjlj_fc_type_node));
|
TYPE_ALIGN (sjlj_fc_type_node));
|
|
|
sjlj_assign_call_site_values (dispatch_label, lp_info);
|
sjlj_assign_call_site_values (dispatch_label, lp_info);
|
sjlj_mark_call_sites (lp_info);
|
sjlj_mark_call_sites (lp_info);
|
|
|
sjlj_emit_function_enter (dispatch_label);
|
sjlj_emit_function_enter (dispatch_label);
|
sjlj_emit_dispatch_table (dispatch_label, lp_info);
|
sjlj_emit_dispatch_table (dispatch_label, lp_info);
|
sjlj_emit_function_exit ();
|
sjlj_emit_function_exit ();
|
}
|
}
|
|
|
free (lp_info);
|
free (lp_info);
|
}
|
}
|
|
|
void
|
void
|
finish_eh_generation (void)
|
finish_eh_generation (void)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
|
|
/* Nothing to do if no regions created. */
|
/* Nothing to do if no regions created. */
|
if (cfun->eh->region_tree == NULL)
|
if (cfun->eh->region_tree == NULL)
|
return;
|
return;
|
|
|
/* The object here is to provide find_basic_blocks with detailed
|
/* The object here is to provide find_basic_blocks with detailed
|
information (via reachable_handlers) on how exception control
|
information (via reachable_handlers) on how exception control
|
flows within the function. In this first pass, we can include
|
flows within the function. In this first pass, we can include
|
type information garnered from ERT_THROW and ERT_ALLOWED_EXCEPTIONS
|
type information garnered from ERT_THROW and ERT_ALLOWED_EXCEPTIONS
|
regions, and hope that it will be useful in deleting unreachable
|
regions, and hope that it will be useful in deleting unreachable
|
handlers. Subsequently, we will generate landing pads which will
|
handlers. Subsequently, we will generate landing pads which will
|
connect many of the handlers, and then type information will not
|
connect many of the handlers, and then type information will not
|
be effective. Still, this is a win over previous implementations. */
|
be effective. Still, this is a win over previous implementations. */
|
|
|
/* These registers are used by the landing pads. Make sure they
|
/* These registers are used by the landing pads. Make sure they
|
have been generated. */
|
have been generated. */
|
get_exception_pointer (cfun);
|
get_exception_pointer (cfun);
|
get_exception_filter (cfun);
|
get_exception_filter (cfun);
|
|
|
/* Construct the landing pads. */
|
/* Construct the landing pads. */
|
|
|
assign_filter_values ();
|
assign_filter_values ();
|
build_post_landing_pads ();
|
build_post_landing_pads ();
|
connect_post_landing_pads ();
|
connect_post_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 ();
|
|
|
cfun->eh->built_landing_pads = 1;
|
cfun->eh->built_landing_pads = 1;
|
|
|
/* We've totally changed the CFG. Start over. */
|
/* We've totally changed the CFG. Start over. */
|
find_exception_handler_labels ();
|
find_exception_handler_labels ();
|
break_superblocks ();
|
break_superblocks ();
|
if (USING_SJLJ_EXCEPTIONS)
|
if (USING_SJLJ_EXCEPTIONS)
|
commit_edge_insertions ();
|
commit_edge_insertions ();
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
edge e;
|
edge e;
|
edge_iterator ei;
|
edge_iterator ei;
|
bool eh = false;
|
bool eh = false;
|
for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
|
for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
|
{
|
{
|
if (e->flags & EDGE_EH)
|
if (e->flags & EDGE_EH)
|
{
|
{
|
remove_edge (e);
|
remove_edge (e);
|
eh = true;
|
eh = true;
|
}
|
}
|
else
|
else
|
ei_next (&ei);
|
ei_next (&ei);
|
}
|
}
|
if (eh)
|
if (eh)
|
rtl_make_eh_edge (NULL, bb, BB_END (bb));
|
rtl_make_eh_edge (NULL, bb, BB_END (bb));
|
}
|
}
|
}
|
}
|
|
|
static hashval_t
|
static hashval_t
|
ehl_hash (const void *pentry)
|
ehl_hash (const void *pentry)
|
{
|
{
|
struct ehl_map_entry *entry = (struct ehl_map_entry *) pentry;
|
struct ehl_map_entry *entry = (struct ehl_map_entry *) pentry;
|
|
|
/* 2^32 * ((sqrt(5) - 1) / 2) */
|
/* 2^32 * ((sqrt(5) - 1) / 2) */
|
const hashval_t scaled_golden_ratio = 0x9e3779b9;
|
const hashval_t scaled_golden_ratio = 0x9e3779b9;
|
return CODE_LABEL_NUMBER (entry->label) * scaled_golden_ratio;
|
return CODE_LABEL_NUMBER (entry->label) * scaled_golden_ratio;
|
}
|
}
|
|
|
static int
|
static int
|
ehl_eq (const void *pentry, const void *pdata)
|
ehl_eq (const void *pentry, const void *pdata)
|
{
|
{
|
struct ehl_map_entry *entry = (struct ehl_map_entry *) pentry;
|
struct ehl_map_entry *entry = (struct ehl_map_entry *) pentry;
|
struct ehl_map_entry *data = (struct ehl_map_entry *) pdata;
|
struct ehl_map_entry *data = (struct ehl_map_entry *) pdata;
|
|
|
return entry->label == data->label;
|
return entry->label == data->label;
|
}
|
}
|
|
|
/* This section handles removing dead code for flow. */
|
/* This section handles removing dead code for flow. */
|
|
|
/* Remove LABEL from exception_handler_label_map. */
|
/* Remove LABEL from exception_handler_label_map. */
|
|
|
static void
|
static void
|
remove_exception_handler_label (rtx label)
|
remove_exception_handler_label (rtx label)
|
{
|
{
|
struct ehl_map_entry **slot, tmp;
|
struct ehl_map_entry **slot, tmp;
|
|
|
/* If exception_handler_label_map was not built yet,
|
/* If exception_handler_label_map was not built yet,
|
there is nothing to do. */
|
there is nothing to do. */
|
if (cfun->eh->exception_handler_label_map == NULL)
|
if (cfun->eh->exception_handler_label_map == NULL)
|
return;
|
return;
|
|
|
tmp.label = label;
|
tmp.label = label;
|
slot = (struct ehl_map_entry **)
|
slot = (struct ehl_map_entry **)
|
htab_find_slot (cfun->eh->exception_handler_label_map, &tmp, NO_INSERT);
|
htab_find_slot (cfun->eh->exception_handler_label_map, &tmp, NO_INSERT);
|
gcc_assert (slot);
|
gcc_assert (slot);
|
|
|
htab_clear_slot (cfun->eh->exception_handler_label_map, (void **) slot);
|
htab_clear_slot (cfun->eh->exception_handler_label_map, (void **) slot);
|
}
|
}
|
|
|
/* Splice REGION from the region tree etc. */
|
/* Splice REGION from the region tree etc. */
|
|
|
static void
|
static void
|
remove_eh_handler (struct eh_region *region)
|
remove_eh_handler (struct eh_region *region)
|
{
|
{
|
struct eh_region **pp, **pp_start, *p, *outer, *inner;
|
struct eh_region **pp, **pp_start, *p, *outer, *inner;
|
rtx lab;
|
rtx lab;
|
|
|
/* For the benefit of efficiently handling REG_EH_REGION notes,
|
/* For the benefit of efficiently handling REG_EH_REGION notes,
|
replace this region in the region array with its containing
|
replace this region in the region array with its containing
|
region. Note that previous region deletions may result in
|
region. Note that previous region deletions may result in
|
multiple copies of this region in the array, so we have a
|
multiple copies of this region in the array, so we have a
|
list of alternate numbers by which we are known. */
|
list of alternate numbers by which we are known. */
|
|
|
outer = region->outer;
|
outer = region->outer;
|
VEC_replace (eh_region, cfun->eh->region_array, region->region_number, outer);
|
VEC_replace (eh_region, cfun->eh->region_array, region->region_number, outer);
|
if (region->aka)
|
if (region->aka)
|
{
|
{
|
unsigned i;
|
unsigned i;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
|
|
EXECUTE_IF_SET_IN_BITMAP (region->aka, 0, i, bi)
|
EXECUTE_IF_SET_IN_BITMAP (region->aka, 0, i, bi)
|
{
|
{
|
VEC_replace (eh_region, cfun->eh->region_array, i, outer);
|
VEC_replace (eh_region, cfun->eh->region_array, i, outer);
|
}
|
}
|
}
|
}
|
|
|
if (outer)
|
if (outer)
|
{
|
{
|
if (!outer->aka)
|
if (!outer->aka)
|
outer->aka = BITMAP_GGC_ALLOC ();
|
outer->aka = BITMAP_GGC_ALLOC ();
|
if (region->aka)
|
if (region->aka)
|
bitmap_ior_into (outer->aka, region->aka);
|
bitmap_ior_into (outer->aka, region->aka);
|
bitmap_set_bit (outer->aka, region->region_number);
|
bitmap_set_bit (outer->aka, region->region_number);
|
}
|
}
|
|
|
if (cfun->eh->built_landing_pads)
|
if (cfun->eh->built_landing_pads)
|
lab = region->landing_pad;
|
lab = region->landing_pad;
|
else
|
else
|
lab = region->label;
|
lab = region->label;
|
if (lab)
|
if (lab)
|
remove_exception_handler_label (lab);
|
remove_exception_handler_label (lab);
|
|
|
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;
|
*pp = region->next_peer;
|
*pp = region->next_peer;
|
|
|
inner = region->inner;
|
inner = region->inner;
|
if (inner)
|
if (inner)
|
{
|
{
|
for (p = inner; p->next_peer ; p = p->next_peer)
|
for (p = inner; p->next_peer ; p = p->next_peer)
|
p->outer = outer;
|
p->outer = outer;
|
p->outer = outer;
|
p->outer = outer;
|
|
|
p->next_peer = *pp_start;
|
p->next_peer = *pp_start;
|
*pp_start = inner;
|
*pp_start = inner;
|
}
|
}
|
|
|
if (region->type == ERT_CATCH)
|
if (region->type == ERT_CATCH)
|
{
|
{
|
struct eh_region *try, *next, *prev;
|
struct eh_region *try, *next, *prev;
|
|
|
for (try = region->next_peer;
|
for (try = region->next_peer;
|
try->type == ERT_CATCH;
|
try->type == ERT_CATCH;
|
try = try->next_peer)
|
try = try->next_peer)
|
continue;
|
continue;
|
gcc_assert (try->type == ERT_TRY);
|
gcc_assert (try->type == ERT_TRY);
|
|
|
next = region->u.catch.next_catch;
|
next = region->u.catch.next_catch;
|
prev = region->u.catch.prev_catch;
|
prev = region->u.catch.prev_catch;
|
|
|
if (next)
|
if (next)
|
next->u.catch.prev_catch = prev;
|
next->u.catch.prev_catch = prev;
|
else
|
else
|
try->u.try.last_catch = prev;
|
try->u.try.last_catch = prev;
|
if (prev)
|
if (prev)
|
prev->u.catch.next_catch = next;
|
prev->u.catch.next_catch = next;
|
else
|
else
|
{
|
{
|
try->u.try.catch = next;
|
try->u.try.catch = next;
|
if (! next)
|
if (! next)
|
remove_eh_handler (try);
|
remove_eh_handler (try);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* LABEL heads a basic block that is about to be deleted. If this
|
/* LABEL heads a basic block that is about to be deleted. If this
|
label corresponds to an exception region, we may be able to
|
label corresponds to an exception region, we may be able to
|
delete the region. */
|
delete the region. */
|
|
|
void
|
void
|
maybe_remove_eh_handler (rtx label)
|
maybe_remove_eh_handler (rtx label)
|
{
|
{
|
struct ehl_map_entry **slot, tmp;
|
struct ehl_map_entry **slot, tmp;
|
struct eh_region *region;
|
struct eh_region *region;
|
|
|
/* ??? After generating landing pads, it's not so simple to determine
|
/* ??? After generating landing pads, it's not so simple to determine
|
if the region data is completely unused. One must examine the
|
if the region data is completely unused. One must examine the
|
landing pad and the post landing pad, and whether an inner try block
|
landing pad and the post landing pad, and whether an inner try block
|
is referencing the catch handlers directly. */
|
is referencing the catch handlers directly. */
|
if (cfun->eh->built_landing_pads)
|
if (cfun->eh->built_landing_pads)
|
return;
|
return;
|
|
|
tmp.label = label;
|
tmp.label = label;
|
slot = (struct ehl_map_entry **)
|
slot = (struct ehl_map_entry **)
|
htab_find_slot (cfun->eh->exception_handler_label_map, &tmp, NO_INSERT);
|
htab_find_slot (cfun->eh->exception_handler_label_map, &tmp, NO_INSERT);
|
if (! slot)
|
if (! slot)
|
return;
|
return;
|
region = (*slot)->region;
|
region = (*slot)->region;
|
if (! region)
|
if (! region)
|
return;
|
return;
|
|
|
/* Flow will want to remove MUST_NOT_THROW regions as unreachable
|
/* Flow will want to remove MUST_NOT_THROW regions as unreachable
|
because there is no path to the fallback call to terminate.
|
because there is no path to the fallback call to terminate.
|
But the region continues to affect call-site data until there
|
But the region continues to affect call-site data until there
|
are no more contained calls, which we don't see here. */
|
are no more contained calls, which we don't see here. */
|
if (region->type == ERT_MUST_NOT_THROW)
|
if (region->type == ERT_MUST_NOT_THROW)
|
{
|
{
|
htab_clear_slot (cfun->eh->exception_handler_label_map, (void **) slot);
|
htab_clear_slot (cfun->eh->exception_handler_label_map, (void **) slot);
|
region->label = NULL_RTX;
|
region->label = NULL_RTX;
|
}
|
}
|
else
|
else
|
remove_eh_handler (region);
|
remove_eh_handler (region);
|
}
|
}
|
|
|
/* Invokes CALLBACK for every exception handler label. Only used by old
|
/* Invokes CALLBACK for every exception handler label. Only used by old
|
loop hackery; should not be used by new code. */
|
loop hackery; should not be used by new code. */
|
|
|
void
|
void
|
for_each_eh_label (void (*callback) (rtx))
|
for_each_eh_label (void (*callback) (rtx))
|
{
|
{
|
htab_traverse (cfun->eh->exception_handler_label_map, for_each_eh_label_1,
|
htab_traverse (cfun->eh->exception_handler_label_map, for_each_eh_label_1,
|
(void *) &callback);
|
(void *) &callback);
|
}
|
}
|
|
|
static int
|
static int
|
for_each_eh_label_1 (void **pentry, void *data)
|
for_each_eh_label_1 (void **pentry, void *data)
|
{
|
{
|
struct ehl_map_entry *entry = *(struct ehl_map_entry **)pentry;
|
struct ehl_map_entry *entry = *(struct ehl_map_entry **)pentry;
|
void (*callback) (rtx) = *(void (**) (rtx)) data;
|
void (*callback) (rtx) = *(void (**) (rtx)) data;
|
|
|
(*callback) (entry->label);
|
(*callback) (entry->label);
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Invoke CALLBACK for every exception region in the current function. */
|
/* Invoke CALLBACK for every exception region in the current function. */
|
|
|
void
|
void
|
for_each_eh_region (void (*callback) (struct eh_region *))
|
for_each_eh_region (void (*callback) (struct eh_region *))
|
{
|
{
|
int i, n = cfun->eh->last_region_number;
|
int i, n = cfun->eh->last_region_number;
|
for (i = 1; i <= n; ++i)
|
for (i = 1; i <= n; ++i)
|
{
|
{
|
struct eh_region *region;
|
struct eh_region *region;
|
|
|
region = VEC_index (eh_region, cfun->eh->region_array, i);
|
region = VEC_index (eh_region, cfun->eh->region_array, i);
|
if (region)
|
if (region)
|
(*callback) (region);
|
(*callback) (region);
|
}
|
}
|
}
|
}
|
|
|
/* This section describes CFG exception edges for flow. */
|
/* This section describes CFG exception edges for flow. */
|
|
|
/* For communicating between calls to reachable_next_level. */
|
/* For communicating between calls to reachable_next_level. */
|
struct reachable_info
|
struct reachable_info
|
{
|
{
|
tree types_caught;
|
tree types_caught;
|
tree types_allowed;
|
tree types_allowed;
|
void (*callback) (struct eh_region *, void *);
|
void (*callback) (struct eh_region *, void *);
|
void *callback_data;
|
void *callback_data;
|
bool saw_any_handlers;
|
bool saw_any_handlers;
|
};
|
};
|
|
|
/* A subroutine of reachable_next_level. Return true if TYPE, or a
|
/* A subroutine of reachable_next_level. Return true if TYPE, or a
|
base class of TYPE, is in HANDLED. */
|
base class of TYPE, is in HANDLED. */
|
|
|
static int
|
static int
|
check_handled (tree handled, tree type)
|
check_handled (tree handled, tree type)
|
{
|
{
|
tree t;
|
tree t;
|
|
|
/* We can check for exact matches without front-end help. */
|
/* We can check for exact matches without front-end help. */
|
if (! lang_eh_type_covers)
|
if (! lang_eh_type_covers)
|
{
|
{
|
for (t = handled; t ; t = TREE_CHAIN (t))
|
for (t = handled; t ; t = TREE_CHAIN (t))
|
if (TREE_VALUE (t) == type)
|
if (TREE_VALUE (t) == type)
|
return 1;
|
return 1;
|
}
|
}
|
else
|
else
|
{
|
{
|
for (t = handled; t ; t = TREE_CHAIN (t))
|
for (t = handled; t ; t = TREE_CHAIN (t))
|
if ((*lang_eh_type_covers) (TREE_VALUE (t), type))
|
if ((*lang_eh_type_covers) (TREE_VALUE (t), type))
|
return 1;
|
return 1;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* A subroutine of reachable_next_level. If we are collecting a list
|
/* A subroutine of reachable_next_level. If we are collecting a list
|
of handlers, add one. After landing pad generation, reference
|
of handlers, add one. After landing pad generation, reference
|
it instead of the handlers themselves. Further, the handlers are
|
it instead of the handlers themselves. Further, the handlers are
|
all wired together, so by referencing one, we've got them all.
|
all wired together, so by referencing one, we've got them all.
|
Before landing pad generation we reference each handler individually.
|
Before landing pad generation we reference each handler individually.
|
|
|
LP_REGION contains the landing pad; REGION is the handler. */
|
LP_REGION contains the landing pad; REGION is the handler. */
|
|
|
static void
|
static void
|
add_reachable_handler (struct reachable_info *info,
|
add_reachable_handler (struct reachable_info *info,
|
struct eh_region *lp_region, struct eh_region *region)
|
struct eh_region *lp_region, struct eh_region *region)
|
{
|
{
|
if (! info)
|
if (! info)
|
return;
|
return;
|
|
|
info->saw_any_handlers = true;
|
info->saw_any_handlers = true;
|
|
|
if (cfun->eh->built_landing_pads)
|
if (cfun->eh->built_landing_pads)
|
info->callback (lp_region, info->callback_data);
|
info->callback (lp_region, info->callback_data);
|
else
|
else
|
info->callback (region, info->callback_data);
|
info->callback (region, info->callback_data);
|
}
|
}
|
|
|
/* Process one level of exception regions for reachability.
|
/* Process one level of exception regions for reachability.
|
If TYPE_THROWN is non-null, then it is the *exact* type being
|
If TYPE_THROWN is non-null, then it is the *exact* type being
|
propagated. If INFO is non-null, then collect handler labels
|
propagated. If INFO is non-null, then collect handler labels
|
and caught/allowed type information between invocations. */
|
and caught/allowed type information between invocations. */
|
|
|
static enum reachable_code
|
static enum reachable_code
|
reachable_next_level (struct eh_region *region, tree type_thrown,
|
reachable_next_level (struct eh_region *region, tree type_thrown,
|
struct reachable_info *info)
|
struct reachable_info *info)
|
{
|
{
|
switch (region->type)
|
switch (region->type)
|
{
|
{
|
case ERT_CLEANUP:
|
case ERT_CLEANUP:
|
/* Before landing-pad generation, we model control flow
|
/* Before landing-pad generation, we model control flow
|
directly to the individual handlers. In this way we can
|
directly to the individual handlers. In this way we can
|
see that catch handler types may shadow one another. */
|
see that catch handler types may shadow one another. */
|
add_reachable_handler (info, region, region);
|
add_reachable_handler (info, region, region);
|
return RNL_MAYBE_CAUGHT;
|
return RNL_MAYBE_CAUGHT;
|
|
|
case ERT_TRY:
|
case ERT_TRY:
|
{
|
{
|
struct eh_region *c;
|
struct eh_region *c;
|
enum reachable_code ret = RNL_NOT_CAUGHT;
|
enum reachable_code ret = RNL_NOT_CAUGHT;
|
|
|
for (c = region->u.try.catch; c ; c = c->u.catch.next_catch)
|
for (c = region->u.try.catch; c ; c = c->u.catch.next_catch)
|
{
|
{
|
/* A catch-all handler ends the search. */
|
/* A catch-all handler ends the search. */
|
if (c->u.catch.type_list == NULL)
|
if (c->u.catch.type_list == NULL)
|
{
|
{
|
add_reachable_handler (info, region, c);
|
add_reachable_handler (info, region, c);
|
return RNL_CAUGHT;
|
return RNL_CAUGHT;
|
}
|
}
|
|
|
if (type_thrown)
|
if (type_thrown)
|
{
|
{
|
/* If we have at least one type match, end the search. */
|
/* If we have at least one type match, end the search. */
|
tree tp_node = c->u.catch.type_list;
|
tree tp_node = c->u.catch.type_list;
|
|
|
for (; tp_node; tp_node = TREE_CHAIN (tp_node))
|
for (; tp_node; tp_node = TREE_CHAIN (tp_node))
|
{
|
{
|
tree type = TREE_VALUE (tp_node);
|
tree type = TREE_VALUE (tp_node);
|
|
|
if (type == type_thrown
|
if (type == type_thrown
|
|| (lang_eh_type_covers
|
|| (lang_eh_type_covers
|
&& (*lang_eh_type_covers) (type, type_thrown)))
|
&& (*lang_eh_type_covers) (type, type_thrown)))
|
{
|
{
|
add_reachable_handler (info, region, c);
|
add_reachable_handler (info, region, c);
|
return RNL_CAUGHT;
|
return RNL_CAUGHT;
|
}
|
}
|
}
|
}
|
|
|
/* If we have definitive information of a match failure,
|
/* If we have definitive information of a match failure,
|
the catch won't trigger. */
|
the catch won't trigger. */
|
if (lang_eh_type_covers)
|
if (lang_eh_type_covers)
|
return RNL_NOT_CAUGHT;
|
return RNL_NOT_CAUGHT;
|
}
|
}
|
|
|
/* At this point, we either don't know what type is thrown or
|
/* At this point, we either don't know what type is thrown or
|
don't have front-end assistance to help deciding if it is
|
don't have front-end assistance to help deciding if it is
|
covered by one of the types in the list for this region.
|
covered by one of the types in the list for this region.
|
|
|
We'd then like to add this region to the list of reachable
|
We'd then like to add this region to the list of reachable
|
handlers since it is indeed potentially reachable based on the
|
handlers since it is indeed potentially reachable based on the
|
information we have.
|
information we have.
|
|
|
Actually, this handler is for sure not reachable if all the
|
Actually, this handler is for sure not reachable if all the
|
types it matches have already been caught. That is, it is only
|
types it matches have already been caught. That is, it is only
|
potentially reachable if at least one of the types it catches
|
potentially reachable if at least one of the types it catches
|
has not been previously caught. */
|
has not been previously caught. */
|
|
|
if (! info)
|
if (! info)
|
ret = RNL_MAYBE_CAUGHT;
|
ret = RNL_MAYBE_CAUGHT;
|
else
|
else
|
{
|
{
|
tree tp_node = c->u.catch.type_list;
|
tree tp_node = c->u.catch.type_list;
|
bool maybe_reachable = false;
|
bool maybe_reachable = false;
|
|
|
/* Compute the potential reachability of this handler and
|
/* Compute the potential reachability of this handler and
|
update the list of types caught at the same time. */
|
update the list of types caught at the same time. */
|
for (; tp_node; tp_node = TREE_CHAIN (tp_node))
|
for (; tp_node; tp_node = TREE_CHAIN (tp_node))
|
{
|
{
|
tree type = TREE_VALUE (tp_node);
|
tree type = TREE_VALUE (tp_node);
|
|
|
if (! check_handled (info->types_caught, type))
|
if (! check_handled (info->types_caught, type))
|
{
|
{
|
info->types_caught
|
info->types_caught
|
= tree_cons (NULL, type, info->types_caught);
|
= tree_cons (NULL, type, info->types_caught);
|
|
|
maybe_reachable = true;
|
maybe_reachable = true;
|
}
|
}
|
}
|
}
|
|
|
if (maybe_reachable)
|
if (maybe_reachable)
|
{
|
{
|
add_reachable_handler (info, region, c);
|
add_reachable_handler (info, region, c);
|
|
|
/* ??? If the catch type is a base class of every allowed
|
/* ??? If the catch type is a base class of every allowed
|
type, then we know we can stop the search. */
|
type, then we know we can stop the search. */
|
ret = RNL_MAYBE_CAUGHT;
|
ret = RNL_MAYBE_CAUGHT;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
return ret;
|
return ret;
|
}
|
}
|
|
|
case ERT_ALLOWED_EXCEPTIONS:
|
case ERT_ALLOWED_EXCEPTIONS:
|
/* An empty list of types definitely ends the search. */
|
/* An empty list of types definitely ends the search. */
|
if (region->u.allowed.type_list == NULL_TREE)
|
if (region->u.allowed.type_list == NULL_TREE)
|
{
|
{
|
add_reachable_handler (info, region, region);
|
add_reachable_handler (info, region, region);
|
return RNL_CAUGHT;
|
return RNL_CAUGHT;
|
}
|
}
|
|
|
/* Collect a list of lists of allowed types for use in detecting
|
/* Collect a list of lists of allowed types for use in detecting
|
when a catch may be transformed into a catch-all. */
|
when a catch may be transformed into a catch-all. */
|
if (info)
|
if (info)
|
info->types_allowed = tree_cons (NULL_TREE,
|
info->types_allowed = tree_cons (NULL_TREE,
|
region->u.allowed.type_list,
|
region->u.allowed.type_list,
|
info->types_allowed);
|
info->types_allowed);
|
|
|
/* If we have definitive information about the type hierarchy,
|
/* If we have definitive information about the type hierarchy,
|
then we can tell if the thrown type will pass through the
|
then we can tell if the thrown type will pass through the
|
filter. */
|
filter. */
|
if (type_thrown && lang_eh_type_covers)
|
if (type_thrown && lang_eh_type_covers)
|
{
|
{
|
if (check_handled (region->u.allowed.type_list, type_thrown))
|
if (check_handled (region->u.allowed.type_list, type_thrown))
|
return RNL_NOT_CAUGHT;
|
return RNL_NOT_CAUGHT;
|
else
|
else
|
{
|
{
|
add_reachable_handler (info, region, region);
|
add_reachable_handler (info, region, region);
|
return RNL_CAUGHT;
|
return RNL_CAUGHT;
|
}
|
}
|
}
|
}
|
|
|
add_reachable_handler (info, region, region);
|
add_reachable_handler (info, region, region);
|
return RNL_MAYBE_CAUGHT;
|
return RNL_MAYBE_CAUGHT;
|
|
|
case ERT_CATCH:
|
case ERT_CATCH:
|
/* Catch regions are handled by their controlling try region. */
|
/* Catch regions are handled by their controlling try region. */
|
return RNL_NOT_CAUGHT;
|
return RNL_NOT_CAUGHT;
|
|
|
case ERT_MUST_NOT_THROW:
|
case ERT_MUST_NOT_THROW:
|
/* Here we end our search, since no exceptions may propagate.
|
/* Here we end our search, since no exceptions may propagate.
|
If we've touched down at some landing pad previous, then the
|
If we've touched down at some landing pad previous, then the
|
explicit function call we generated may be used. Otherwise
|
explicit function call we generated may be used. Otherwise
|
the call is made by the runtime.
|
the call is made by the runtime.
|
|
|
Before inlining, do not perform this optimization. We may
|
Before inlining, do not perform this optimization. We may
|
inline a subroutine that contains handlers, and that will
|
inline a subroutine that contains handlers, and that will
|
change the value of saw_any_handlers. */
|
change the value of saw_any_handlers. */
|
|
|
if ((info && info->saw_any_handlers) || !cfun->after_inlining)
|
if ((info && info->saw_any_handlers) || !cfun->after_inlining)
|
{
|
{
|
add_reachable_handler (info, region, region);
|
add_reachable_handler (info, region, region);
|
return RNL_CAUGHT;
|
return RNL_CAUGHT;
|
}
|
}
|
else
|
else
|
return RNL_BLOCKED;
|
return RNL_BLOCKED;
|
|
|
case ERT_THROW:
|
case ERT_THROW:
|
case ERT_UNKNOWN:
|
case ERT_UNKNOWN:
|
/* Shouldn't see these here. */
|
/* Shouldn't see these here. */
|
gcc_unreachable ();
|
gcc_unreachable ();
|
break;
|
break;
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
/* Invoke CALLBACK on each region reachable from REGION_NUMBER. */
|
/* Invoke CALLBACK on each region reachable from REGION_NUMBER. */
|
|
|
void
|
void
|
foreach_reachable_handler (int region_number, bool is_resx,
|
foreach_reachable_handler (int region_number, bool is_resx,
|
void (*callback) (struct eh_region *, void *),
|
void (*callback) (struct eh_region *, void *),
|
void *callback_data)
|
void *callback_data)
|
{
|
{
|
struct reachable_info info;
|
struct reachable_info info;
|
struct eh_region *region;
|
struct eh_region *region;
|
tree type_thrown;
|
tree type_thrown;
|
|
|
memset (&info, 0, sizeof (info));
|
memset (&info, 0, sizeof (info));
|
info.callback = callback;
|
info.callback = callback;
|
info.callback_data = callback_data;
|
info.callback_data = callback_data;
|
|
|
region = VEC_index (eh_region, cfun->eh->region_array, region_number);
|
region = VEC_index (eh_region, cfun->eh->region_array, region_number);
|
|
|
type_thrown = NULL_TREE;
|
type_thrown = NULL_TREE;
|
if (is_resx)
|
if (is_resx)
|
{
|
{
|
/* A RESX leaves a region instead of entering it. Thus the
|
/* A RESX leaves a region instead of entering it. Thus the
|
region itself may have been deleted out from under us. */
|
region itself may have been deleted out from under us. */
|
if (region == NULL)
|
if (region == NULL)
|
return;
|
return;
|
region = region->outer;
|
region = region->outer;
|
}
|
}
|
else if (region->type == ERT_THROW)
|
else if (region->type == ERT_THROW)
|
{
|
{
|
type_thrown = region->u.throw.type;
|
type_thrown = region->u.throw.type;
|
region = region->outer;
|
region = region->outer;
|
}
|
}
|
|
|
while (region)
|
while (region)
|
{
|
{
|
if (reachable_next_level (region, type_thrown, &info) >= RNL_CAUGHT)
|
if (reachable_next_level (region, type_thrown, &info) >= RNL_CAUGHT)
|
break;
|
break;
|
/* If we have processed one cleanup, there is no point in
|
/* If we have processed one cleanup, there is no point in
|
processing any more of them. Each cleanup will have an edge
|
processing any more of them. Each cleanup will have an edge
|
to the next outer cleanup region, so the flow graph will be
|
to the next outer cleanup region, so the flow graph will be
|
accurate. */
|
accurate. */
|
if (region->type == ERT_CLEANUP)
|
if (region->type == ERT_CLEANUP)
|
region = region->u.cleanup.prev_try;
|
region = region->u.cleanup.prev_try;
|
else
|
else
|
region = region->outer;
|
region = region->outer;
|
}
|
}
|
}
|
}
|
|
|
/* Retrieve a list of labels of exception handlers which can be
|
/* Retrieve a list of labels of exception handlers which can be
|
reached by a given insn. */
|
reached by a given insn. */
|
|
|
static void
|
static void
|
arh_to_landing_pad (struct eh_region *region, void *data)
|
arh_to_landing_pad (struct eh_region *region, void *data)
|
{
|
{
|
rtx *p_handlers = data;
|
rtx *p_handlers = data;
|
if (! *p_handlers)
|
if (! *p_handlers)
|
*p_handlers = alloc_INSN_LIST (region->landing_pad, NULL_RTX);
|
*p_handlers = alloc_INSN_LIST (region->landing_pad, NULL_RTX);
|
}
|
}
|
|
|
static void
|
static void
|
arh_to_label (struct eh_region *region, void *data)
|
arh_to_label (struct eh_region *region, void *data)
|
{
|
{
|
rtx *p_handlers = data;
|
rtx *p_handlers = data;
|
*p_handlers = alloc_INSN_LIST (region->label, *p_handlers);
|
*p_handlers = alloc_INSN_LIST (region->label, *p_handlers);
|
}
|
}
|
|
|
rtx
|
rtx
|
reachable_handlers (rtx insn)
|
reachable_handlers (rtx insn)
|
{
|
{
|
bool is_resx = false;
|
bool is_resx = false;
|
rtx handlers = NULL;
|
rtx handlers = NULL;
|
int region_number;
|
int region_number;
|
|
|
if (JUMP_P (insn)
|
if (JUMP_P (insn)
|
&& GET_CODE (PATTERN (insn)) == RESX)
|
&& GET_CODE (PATTERN (insn)) == RESX)
|
{
|
{
|
region_number = XINT (PATTERN (insn), 0);
|
region_number = XINT (PATTERN (insn), 0);
|
is_resx = true;
|
is_resx = true;
|
}
|
}
|
else
|
else
|
{
|
{
|
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)) <= 0)
|
if (!note || INTVAL (XEXP (note, 0)) <= 0)
|
return NULL;
|
return NULL;
|
region_number = INTVAL (XEXP (note, 0));
|
region_number = INTVAL (XEXP (note, 0));
|
}
|
}
|
|
|
foreach_reachable_handler (region_number, is_resx,
|
foreach_reachable_handler (region_number, is_resx,
|
(cfun->eh->built_landing_pads
|
(cfun->eh->built_landing_pads
|
? arh_to_landing_pad
|
? arh_to_landing_pad
|
: arh_to_label),
|
: arh_to_label),
|
&handlers);
|
&handlers);
|
|
|
return handlers;
|
return handlers;
|
}
|
}
|
|
|
/* Determine if the given INSN can throw an exception that is caught
|
/* Determine if the given INSN can throw an exception that is caught
|
within the function. */
|
within the function. */
|
|
|
bool
|
bool
|
can_throw_internal_1 (int region_number, bool is_resx)
|
can_throw_internal_1 (int region_number, bool is_resx)
|
{
|
{
|
struct eh_region *region;
|
struct eh_region *region;
|
tree type_thrown;
|
tree type_thrown;
|
|
|
region = VEC_index (eh_region, cfun->eh->region_array, region_number);
|
region = VEC_index (eh_region, cfun->eh->region_array, region_number);
|
|
|
type_thrown = NULL_TREE;
|
type_thrown = NULL_TREE;
|
if (is_resx)
|
if (is_resx)
|
region = region->outer;
|
region = region->outer;
|
else if (region->type == ERT_THROW)
|
else if (region->type == ERT_THROW)
|
{
|
{
|
type_thrown = region->u.throw.type;
|
type_thrown = region->u.throw.type;
|
region = region->outer;
|
region = region->outer;
|
}
|
}
|
|
|
/* If this exception is ignored by each and every containing region,
|
/* If this exception is ignored by each and every containing region,
|
then control passes straight out. The runtime may handle some
|
then control passes straight out. The runtime may handle some
|
regions, which also do not require processing internally. */
|
regions, which also do not require processing internally. */
|
for (; region; region = region->outer)
|
for (; region; region = region->outer)
|
{
|
{
|
enum reachable_code how = reachable_next_level (region, type_thrown, 0);
|
enum reachable_code how = reachable_next_level (region, type_thrown, 0);
|
if (how == RNL_BLOCKED)
|
if (how == RNL_BLOCKED)
|
return false;
|
return false;
|
if (how != RNL_NOT_CAUGHT)
|
if (how != RNL_NOT_CAUGHT)
|
return true;
|
return true;
|
}
|
}
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
bool
|
bool
|
can_throw_internal (rtx insn)
|
can_throw_internal (rtx insn)
|
{
|
{
|
rtx note;
|
rtx note;
|
|
|
if (! INSN_P (insn))
|
if (! INSN_P (insn))
|
return false;
|
return false;
|
|
|
if (JUMP_P (insn)
|
if (JUMP_P (insn)
|
&& GET_CODE (PATTERN (insn)) == RESX
|
&& GET_CODE (PATTERN (insn)) == RESX
|
&& XINT (PATTERN (insn), 0) > 0)
|
&& XINT (PATTERN (insn), 0) > 0)
|
return can_throw_internal_1 (XINT (PATTERN (insn), 0), true);
|
return can_throw_internal_1 (XINT (PATTERN (insn), 0), true);
|
|
|
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);
|
|
|
/* Every insn that might throw has an EH_REGION note. */
|
/* Every insn that might throw has an EH_REGION note. */
|
note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
|
note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
|
if (!note || INTVAL (XEXP (note, 0)) <= 0)
|
if (!note || INTVAL (XEXP (note, 0)) <= 0)
|
return false;
|
return false;
|
|
|
return can_throw_internal_1 (INTVAL (XEXP (note, 0)), false);
|
return can_throw_internal_1 (INTVAL (XEXP (note, 0)), false);
|
}
|
}
|
|
|
/* Determine if the given INSN can throw an exception that is
|
/* Determine if the given INSN can throw an exception that is
|
visible outside the function. */
|
visible outside the function. */
|
|
|
bool
|
bool
|
can_throw_external_1 (int region_number, bool is_resx)
|
can_throw_external_1 (int region_number, bool is_resx)
|
{
|
{
|
struct eh_region *region;
|
struct eh_region *region;
|
tree type_thrown;
|
tree type_thrown;
|
|
|
region = VEC_index (eh_region, cfun->eh->region_array, region_number);
|
region = VEC_index (eh_region, cfun->eh->region_array, region_number);
|
|
|
type_thrown = NULL_TREE;
|
type_thrown = NULL_TREE;
|
if (is_resx)
|
if (is_resx)
|
region = region->outer;
|
region = region->outer;
|
else if (region->type == ERT_THROW)
|
else if (region->type == ERT_THROW)
|
{
|
{
|
type_thrown = region->u.throw.type;
|
type_thrown = region->u.throw.type;
|
region = region->outer;
|
region = region->outer;
|
}
|
}
|
|
|
/* If the exception is caught or blocked by any containing region,
|
/* If the exception is caught or blocked by any containing region,
|
then it is not seen by any calling function. */
|
then it is not seen by any calling function. */
|
for (; region ; region = region->outer)
|
for (; region ; region = region->outer)
|
if (reachable_next_level (region, type_thrown, NULL) >= RNL_CAUGHT)
|
if (reachable_next_level (region, type_thrown, NULL) >= RNL_CAUGHT)
|
return false;
|
return false;
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
bool
|
bool
|
can_throw_external (rtx insn)
|
can_throw_external (rtx insn)
|
{
|
{
|
rtx note;
|
rtx note;
|
|
|
if (! INSN_P (insn))
|
if (! INSN_P (insn))
|
return false;
|
return false;
|
|
|
if (JUMP_P (insn)
|
if (JUMP_P (insn)
|
&& GET_CODE (PATTERN (insn)) == RESX
|
&& GET_CODE (PATTERN (insn)) == RESX
|
&& XINT (PATTERN (insn), 0) > 0)
|
&& XINT (PATTERN (insn), 0) > 0)
|
return can_throw_external_1 (XINT (PATTERN (insn), 0), true);
|
return can_throw_external_1 (XINT (PATTERN (insn), 0), true);
|
|
|
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)
|
{
|
{
|
/* Calls (and trapping insns) without notes are outside any
|
/* Calls (and trapping insns) without notes are outside any
|
exception handling region in this function. We have to
|
exception handling region in this function. We have to
|
assume it might throw. Given that the front end and middle
|
assume it might throw. Given that the front end and middle
|
ends mark known NOTHROW functions, this isn't so wildly
|
ends mark known NOTHROW functions, this isn't so wildly
|
inaccurate. */
|
inaccurate. */
|
return (CALL_P (insn)
|
return (CALL_P (insn)
|
|| (flag_non_call_exceptions
|
|| (flag_non_call_exceptions
|
&& may_trap_p (PATTERN (insn))));
|
&& may_trap_p (PATTERN (insn))));
|
}
|
}
|
if (INTVAL (XEXP (note, 0)) <= 0)
|
if (INTVAL (XEXP (note, 0)) <= 0)
|
return false;
|
return false;
|
|
|
return can_throw_external_1 (INTVAL (XEXP (note, 0)), false);
|
return can_throw_external_1 (INTVAL (XEXP (note, 0)), false);
|
}
|
}
|
|
|
/* Set TREE_NOTHROW and cfun->all_throwers_are_sibcalls. */
|
/* Set TREE_NOTHROW and cfun->all_throwers_are_sibcalls. */
|
|
|
unsigned int
|
unsigned int
|
set_nothrow_function_flags (void)
|
set_nothrow_function_flags (void)
|
{
|
{
|
rtx insn;
|
rtx insn;
|
|
|
/* 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 (DECL_REPLACEABLE_P (current_function_decl))
|
if (DECL_REPLACEABLE_P (current_function_decl))
|
return 0;
|
return 0;
|
|
|
TREE_NOTHROW (current_function_decl) = 1;
|
TREE_NOTHROW (current_function_decl) = 1;
|
|
|
/* Assume cfun->all_throwers_are_sibcalls until we encounter
|
/* Assume cfun->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. */
|
|
|
cfun->all_throwers_are_sibcalls = 1;
|
cfun->all_throwers_are_sibcalls = 1;
|
|
|
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))
|
{
|
{
|
TREE_NOTHROW (current_function_decl) = 0;
|
TREE_NOTHROW (current_function_decl) = 0;
|
|
|
if (!CALL_P (insn) || !SIBLING_CALL_P (insn))
|
if (!CALL_P (insn) || !SIBLING_CALL_P (insn))
|
{
|
{
|
cfun->all_throwers_are_sibcalls = 0;
|
cfun->all_throwers_are_sibcalls = 0;
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
|
|
for (insn = current_function_epilogue_delay_list; insn;
|
for (insn = current_function_epilogue_delay_list; insn;
|
insn = XEXP (insn, 1))
|
insn = XEXP (insn, 1))
|
if (can_throw_external (insn))
|
if (can_throw_external (insn))
|
{
|
{
|
TREE_NOTHROW (current_function_decl) = 0;
|
TREE_NOTHROW (current_function_decl) = 0;
|
|
|
if (!CALL_P (insn) || !SIBLING_CALL_P (insn))
|
if (!CALL_P (insn) || !SIBLING_CALL_P (insn))
|
{
|
{
|
cfun->all_throwers_are_sibcalls = 0;
|
cfun->all_throwers_are_sibcalls = 0;
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
struct tree_opt_pass pass_set_nothrow_function_flags =
|
struct tree_opt_pass pass_set_nothrow_function_flags =
|
{
|
{
|
NULL, /* name */
|
NULL, /* 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 */
|
0, /* tv_id */
|
0, /* 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 */
|
0, /* todo_flags_finish */
|
0, /* todo_flags_finish */
|
0 /* letter */
|
0 /* letter */
|
};
|
};
|
|
|
|
|
/* Various hooks for unwind library. */
|
/* Various hooks for unwind library. */
|
|
|
/* 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. */
|
current_function_has_nonlocal_label = 1;
|
current_function_has_nonlocal_label = 1;
|
|
|
#ifdef SETUP_FRAME_ADDRESSES
|
#ifdef SETUP_FRAME_ADDRESSES
|
SETUP_FRAME_ADDRESSES ();
|
SETUP_FRAME_ADDRESSES ();
|
#endif
|
#endif
|
}
|
}
|
|
|
rtx
|
rtx
|
expand_builtin_eh_return_data_regno (tree arglist)
|
expand_builtin_eh_return_data_regno (tree arglist)
|
{
|
{
|
tree which = TREE_VALUE (arglist);
|
tree which = TREE_VALUE (arglist);
|
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, 0);
|
rtx addr = expand_expr (addr_tree, NULL_RTX, Pmode, 0);
|
|
|
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, 0);
|
rtx addr = expand_expr (addr_tree, NULL_RTX, ptr_mode, 0);
|
|
|
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, cfun->eh->ehr_stackadj, VOIDmode, 0);
|
tmp = expand_expr (stackadj_tree, cfun->eh->ehr_stackadj, VOIDmode, 0);
|
tmp = convert_memory_address (Pmode, tmp);
|
tmp = convert_memory_address (Pmode, tmp);
|
if (!cfun->eh->ehr_stackadj)
|
if (!cfun->eh->ehr_stackadj)
|
cfun->eh->ehr_stackadj = copy_to_reg (tmp);
|
cfun->eh->ehr_stackadj = copy_to_reg (tmp);
|
else if (tmp != cfun->eh->ehr_stackadj)
|
else if (tmp != cfun->eh->ehr_stackadj)
|
emit_move_insn (cfun->eh->ehr_stackadj, tmp);
|
emit_move_insn (cfun->eh->ehr_stackadj, tmp);
|
#endif
|
#endif
|
|
|
tmp = expand_expr (handler_tree, cfun->eh->ehr_handler, VOIDmode, 0);
|
tmp = expand_expr (handler_tree, cfun->eh->ehr_handler, VOIDmode, 0);
|
tmp = convert_memory_address (Pmode, tmp);
|
tmp = convert_memory_address (Pmode, tmp);
|
if (!cfun->eh->ehr_handler)
|
if (!cfun->eh->ehr_handler)
|
cfun->eh->ehr_handler = copy_to_reg (tmp);
|
cfun->eh->ehr_handler = copy_to_reg (tmp);
|
else if (tmp != cfun->eh->ehr_handler)
|
else if (tmp != cfun->eh->ehr_handler)
|
emit_move_insn (cfun->eh->ehr_handler, tmp);
|
emit_move_insn (cfun->eh->ehr_handler, tmp);
|
|
|
if (!cfun->eh->ehr_label)
|
if (!cfun->eh->ehr_label)
|
cfun->eh->ehr_label = gen_label_rtx ();
|
cfun->eh->ehr_label = gen_label_rtx ();
|
emit_jump (cfun->eh->ehr_label);
|
emit_jump (cfun->eh->ehr_label);
|
}
|
}
|
|
|
void
|
void
|
expand_eh_return (void)
|
expand_eh_return (void)
|
{
|
{
|
rtx around_label;
|
rtx around_label;
|
|
|
if (! cfun->eh->ehr_label)
|
if (! cfun->eh->ehr_label)
|
return;
|
return;
|
|
|
current_function_calls_eh_return = 1;
|
current_function_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 (cfun->eh->ehr_label);
|
emit_label (cfun->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, cfun->eh->ehr_stackadj);
|
emit_move_insn (EH_RETURN_STACKADJ_RTX, cfun->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 (cfun->eh->ehr_handler));
|
emit_insn (gen_eh_return (cfun->eh->ehr_handler));
|
else
|
else
|
#endif
|
#endif
|
{
|
{
|
#ifdef EH_RETURN_HANDLER_RTX
|
#ifdef EH_RETURN_HANDLER_RTX
|
emit_move_insn (EH_RETURN_HANDLER_RTX, cfun->eh->ehr_handler);
|
emit_move_insn (EH_RETURN_HANDLER_RTX, cfun->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, 0);
|
rtx addr = expand_expr (addr_tree, NULL_RTX, ptr_mode, 0);
|
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 (word_mode, ptr_mode, addr, extend);
|
return convert_modes (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, tmp;
|
struct action_record **slot, *new, 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 = *slot) == NULL)
|
if ((new = *slot) == NULL)
|
{
|
{
|
new = xmalloc (sizeof (*new));
|
new = xmalloc (sizeof (*new));
|
new->offset = VARRAY_ACTIVE_SIZE (cfun->eh->action_record_data) + 1;
|
new->offset = VARRAY_ACTIVE_SIZE (cfun->eh->action_record_data) + 1;
|
new->filter = filter;
|
new->filter = filter;
|
new->next = next;
|
new->next = next;
|
*slot = new;
|
*slot = new;
|
|
|
/* 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 (&cfun->eh->action_record_data, filter);
|
push_sleb128 (&cfun->eh->action_record_data, filter);
|
if (next)
|
if (next)
|
next -= VARRAY_ACTIVE_SIZE (cfun->eh->action_record_data) + 1;
|
next -= VARRAY_ACTIVE_SIZE (cfun->eh->action_record_data) + 1;
|
push_sleb128 (&cfun->eh->action_record_data, next);
|
push_sleb128 (&cfun->eh->action_record_data, next);
|
}
|
}
|
|
|
return new->offset;
|
return new->offset;
|
}
|
}
|
|
|
static int
|
static int
|
collect_one_action_chain (htab_t ar_hash, struct eh_region *region)
|
collect_one_action_chain (htab_t ar_hash, struct eh_region *region)
|
{
|
{
|
struct eh_region *c;
|
struct eh_region *c;
|
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:
|
/* 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 (c = region->outer; c ; c = c->outer)
|
for (c = region->outer; c ; c = c->outer)
|
if (c->type == ERT_CLEANUP)
|
if (c->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:
|
/* 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.try.last_catch; c ; c = c->u.catch.prev_catch)
|
for (c = region->u.try.last_catch; c ; c = c->u.catch.prev_catch)
|
{
|
{
|
if (c->u.catch.type_list == NULL)
|
if (c->u.catch.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
|
int filter
|
= TREE_INT_CST_LOW (TREE_VALUE (c->u.catch.filter_list));
|
= TREE_INT_CST_LOW (TREE_VALUE (c->u.catch.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->u.catch.filter_list;
|
flt_node = c->u.catch.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;
|
|
|
case ERT_CATCH:
|
case ERT_CATCH:
|
case ERT_THROW:
|
case ERT_THROW:
|
/* CATCH regions are handled in TRY above. THROW regions are
|
/* CATCH regions are handled in TRY above. THROW regions are
|
for optimization information only and produce no output. */
|
for optimization information only and produce no output. */
|
return collect_one_action_chain (ar_hash, region->outer);
|
return collect_one_action_chain (ar_hash, region->outer);
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
static int
|
static int
|
add_call_site (rtx landing_pad, int action)
|
add_call_site (rtx landing_pad, int action)
|
{
|
{
|
struct call_site_record *data = cfun->eh->call_site_data;
|
struct call_site_record *data = cfun->eh->call_site_data;
|
int used = cfun->eh->call_site_data_used;
|
int used = cfun->eh->call_site_data_used;
|
int size = cfun->eh->call_site_data_size;
|
int size = cfun->eh->call_site_data_size;
|
|
|
if (used >= size)
|
if (used >= size)
|
{
|
{
|
size = (size ? size * 2 : 64);
|
size = (size ? size * 2 : 64);
|
data = ggc_realloc (data, sizeof (*data) * size);
|
data = ggc_realloc (data, sizeof (*data) * size);
|
cfun->eh->call_site_data = data;
|
cfun->eh->call_site_data = data;
|
cfun->eh->call_site_data_size = size;
|
cfun->eh->call_site_data_size = size;
|
}
|
}
|
|
|
data[used].landing_pad = landing_pad;
|
data[used].landing_pad = landing_pad;
|
data[used].action = action;
|
data[used].action = action;
|
|
|
cfun->eh->call_site_data_used = used + 1;
|
cfun->eh->call_site_data_used = used + 1;
|
|
|
return used + call_site_base;
|
return used + call_site_base;
|
}
|
}
|
|
|
/* 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. */
|
|
|
unsigned int
|
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;
|
|
|
if (USING_SJLJ_EXCEPTIONS || cfun->eh->region_tree == NULL)
|
if (USING_SJLJ_EXCEPTIONS || cfun->eh->region_tree == NULL)
|
return 0;
|
return 0;
|
|
|
VARRAY_UCHAR_INIT (cfun->eh->action_record_data, 64, "action_record_data");
|
VARRAY_UCHAR_INIT (cfun->eh->action_record_data, 64, "action_record_data");
|
|
|
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))
|
{
|
{
|
struct eh_region *region;
|
struct eh_region *region;
|
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);
|
|
|
note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
|
note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
|
if (!note)
|
if (!note)
|
{
|
{
|
if (! (CALL_P (insn)
|
if (! (CALL_P (insn)
|
|| (flag_non_call_exceptions
|
|| (flag_non_call_exceptions
|
&& may_trap_p (PATTERN (insn)))))
|
&& may_trap_p (PATTERN (insn)))))
|
continue;
|
continue;
|
this_action = -1;
|
this_action = -1;
|
region = NULL;
|
region = NULL;
|
}
|
}
|
else
|
else
|
{
|
{
|
if (INTVAL (XEXP (note, 0)) <= 0)
|
if (INTVAL (XEXP (note, 0)) <= 0)
|
continue;
|
continue;
|
region = VEC_index (eh_region, cfun->eh->region_array, INTVAL (XEXP (note, 0)));
|
region = VEC_index (eh_region, cfun->eh->region_array, INTVAL (XEXP (note, 0)));
|
this_action = collect_one_action_chain (ar_hash, region);
|
this_action = collect_one_action_chain (ar_hash, region);
|
}
|
}
|
|
|
/* 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)
|
cfun->uses_eh_lsda = 1;
|
cfun->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;
|
}
|
}
|
|
|
/* Cleanups and handlers may share action chains but not
|
/* Cleanups and handlers may share action chains but not
|
landing pads. Collect the landing pad for this region. */
|
landing pads. Collect the landing pad for this region. */
|
if (this_action >= 0)
|
if (this_action >= 0)
|
{
|
{
|
struct eh_region *o;
|
struct eh_region *o;
|
for (o = region; ! o->landing_pad ; o = o->outer)
|
for (o = region; ! o->landing_pad ; o = o->outer)
|
continue;
|
continue;
|
this_landing_pad = o->landing_pad;
|
this_landing_pad = o->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)
|
if (first_no_action_insn)
|
{
|
{
|
call_site = add_call_site (NULL_RTX, 0);
|
call_site = add_call_site (NULL_RTX, 0);
|
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);
|
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;
|
}
|
}
|
|
|
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;
|
}
|
}
|
|
|
htab_delete (ar_hash);
|
htab_delete (ar_hash);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
struct tree_opt_pass pass_convert_to_eh_region_ranges =
|
struct tree_opt_pass pass_convert_to_eh_region_ranges =
|
{
|
{
|
"eh-ranges", /* name */
|
"eh-ranges", /* name */
|
NULL, /* gate */
|
NULL, /* 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 */
|
0, /* tv_id */
|
0, /* 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 */
|
0 /* letter */
|
0 /* letter */
|
};
|
};
|
|
|
|
|
static void
|
static void
|
push_uleb128 (varray_type *data_area, unsigned int value)
|
push_uleb128 (varray_type *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;
|
VARRAY_PUSH_UCHAR (*data_area, byte);
|
VARRAY_PUSH_UCHAR (*data_area, byte);
|
}
|
}
|
while (value);
|
while (value);
|
}
|
}
|
|
|
static void
|
static void
|
push_sleb128 (varray_type *data_area, int value)
|
push_sleb128 (varray_type *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;
|
VARRAY_PUSH_UCHAR (*data_area, byte);
|
VARRAY_PUSH_UCHAR (*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 (void)
|
dw2_size_of_call_site_table (void)
|
{
|
{
|
int n = cfun->eh->call_site_data_used;
|
int n = cfun->eh->call_site_data_used;
|
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 *cs = &cfun->eh->call_site_data[i];
|
struct call_site_record *cs = &cfun->eh->call_site_data[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 = cfun->eh->call_site_data_used;
|
int n = cfun->eh->call_site_data_used;
|
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 *cs = &cfun->eh->call_site_data[i];
|
struct call_site_record *cs = &cfun->eh->call_site_data[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 (void)
|
dw2_output_call_site_table (void)
|
{
|
{
|
int n = cfun->eh->call_site_data_used;
|
int n = cfun->eh->call_site_data_used;
|
int i;
|
int i;
|
|
|
for (i = 0; i < n; ++i)
|
for (i = 0; i < n; ++i)
|
{
|
{
|
struct call_site_record *cs = &cfun->eh->call_site_data[i];
|
struct call_site_record *cs = &cfun->eh->call_site_data[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. */
|
#ifdef HAVE_AS_LEB128
|
#ifdef HAVE_AS_LEB128
|
dw2_asm_output_delta_uleb128 (reg_start_lab,
|
dw2_asm_output_delta_uleb128 (reg_start_lab,
|
current_function_func_begin_label,
|
current_function_func_begin_label,
|
"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,
|
dw2_asm_output_delta_uleb128 (landing_pad_lab,
|
current_function_func_begin_label,
|
current_function_func_begin_label,
|
"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,
|
dw2_asm_output_delta (4, reg_start_lab,
|
current_function_func_begin_label,
|
current_function_func_begin_label,
|
"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,
|
dw2_asm_output_delta (4, landing_pad_lab,
|
current_function_func_begin_label,
|
current_function_func_begin_label,
|
"landing pad");
|
"landing pad");
|
else
|
else
|
dw2_asm_output_data (4, 0, "landing pad");
|
dw2_asm_output_data (4, 0, "landing pad");
|
#endif
|
#endif
|
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 = cfun->eh->call_site_data_used;
|
int n = cfun->eh->call_site_data_used;
|
int i;
|
int i;
|
|
|
for (i = 0; i < n; ++i)
|
for (i = 0; i < n; ++i)
|
{
|
{
|
struct call_site_record *cs = &cfun->eh->call_site_data[i];
|
struct call_site_record *cs = &cfun->eh->call_site_data[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 (void)
|
switch_to_exception_section (void)
|
{
|
{
|
if (exception_section == 0)
|
if (exception_section == 0)
|
{
|
{
|
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;
|
exception_section = get_section (".gcc_except_table", flags, NULL);
|
exception_section = get_section (".gcc_except_table", flags, NULL);
|
}
|
}
|
else
|
else
|
exception_section = flag_pic ? data_section : readonly_data_section;
|
exception_section = flag_pic ? data_section : readonly_data_section;
|
}
|
}
|
switch_to_section (exception_section);
|
switch_to_section (exception_section);
|
}
|
}
|
#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 public = true;
|
bool public = true;
|
|
|
if (type == NULL_TREE)
|
if (type == NULL_TREE)
|
value = const0_rtx;
|
value = const0_rtx;
|
else
|
else
|
{
|
{
|
struct cgraph_varpool_node *node;
|
struct cgraph_varpool_node *node;
|
|
|
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 = cgraph_varpool_node (type);
|
node = cgraph_varpool_node (type);
|
if (node)
|
if (node)
|
cgraph_varpool_mark_needed_node (node);
|
cgraph_varpool_mark_needed_node (node);
|
public = TREE_PUBLIC (type);
|
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, public, NULL);
|
dw2_asm_output_encoded_addr_rtx (tt_format, value, public, NULL);
|
}
|
}
|
|
|
void
|
void
|
output_function_exception_table (void)
|
output_function_exception_table (void)
|
{
|
{
|
int tt_format, cs_format, lp_format, i, n;
|
int tt_format, cs_format, lp_format, i, n;
|
#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;
|
|
|
if (eh_personality_libfunc)
|
if (eh_personality_libfunc)
|
assemble_external_libcall (eh_personality_libfunc);
|
assemble_external_libcall (eh_personality_libfunc);
|
|
|
/* Not all functions need anything. */
|
/* Not all functions need anything. */
|
if (! cfun->uses_eh_lsda)
|
if (! cfun->uses_eh_lsda)
|
return;
|
return;
|
|
|
#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, eh_personality_libfunc);
|
output_addr_const (asm_out_file, eh_personality_libfunc);
|
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 ();
|
switch_to_exception_section ();
|
#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) > 0
|
have_tt_data = (VEC_length (tree, cfun->eh->ttype_data) > 0
|
|| VARRAY_ACTIVE_SIZE (cfun->eh->ehspec_data) > 0);
|
|| VARRAY_ACTIVE_SIZE (cfun->eh->ehspec_data) > 0);
|
|
|
/* 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, "LLSDATT",
|
ASM_GENERATE_INTERNAL_LABEL (ttype_label, "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, "LLSDA",
|
targetm.asm_out.internal_label (asm_out_file, "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 ();
|
call_site_len = dw2_size_of_call_site_table ();
|
#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, "LLSDATTD",
|
ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label, "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
|
+ VARRAY_ACTIVE_SIZE (cfun->eh->action_record_data)
|
+ VARRAY_ACTIVE_SIZE (cfun->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, "LLSDACSB",
|
ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label, "LLSDACSB",
|
current_function_funcdef_no);
|
current_function_funcdef_no);
|
ASM_GENERATE_INTERNAL_LABEL (cs_end_label, "LLSDACSE",
|
ASM_GENERATE_INTERNAL_LABEL (cs_end_label, "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 ();
|
dw2_output_call_site_table ();
|
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 ();
|
dw2_output_call_site_table ();
|
#endif
|
#endif
|
|
|
/* ??? Decode and interpret the data for flag_debug_asm. */
|
/* ??? Decode and interpret the data for flag_debug_asm. */
|
n = VARRAY_ACTIVE_SIZE (cfun->eh->action_record_data);
|
n = VARRAY_ACTIVE_SIZE (cfun->eh->action_record_data);
|
for (i = 0; i < n; ++i)
|
for (i = 0; i < n; ++i)
|
dw2_asm_output_data (1, VARRAY_UCHAR (cfun->eh->action_record_data, i),
|
dw2_asm_output_data (1, VARRAY_UCHAR (cfun->eh->action_record_data, i),
|
(i ? NULL : "Action record table"));
|
(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. */
|
n = VARRAY_ACTIVE_SIZE (cfun->eh->ehspec_data);
|
n = VARRAY_ACTIVE_SIZE (cfun->eh->ehspec_data);
|
for (i = 0; i < n; ++i)
|
for (i = 0; i < n; ++i)
|
{
|
{
|
if (targetm.arm_eabi_unwinder)
|
if (targetm.arm_eabi_unwinder)
|
{
|
{
|
tree type = VARRAY_TREE (cfun->eh->ehspec_data, i);
|
tree type = VARRAY_TREE (cfun->eh->ehspec_data, i);
|
output_ttype (type, tt_format, tt_format_size);
|
output_ttype (type, tt_format, tt_format_size);
|
}
|
}
|
else
|
else
|
dw2_asm_output_data (1, VARRAY_UCHAR (cfun->eh->ehspec_data, i),
|
dw2_asm_output_data (1, VARRAY_UCHAR (cfun->eh->ehspec_data, i),
|
(i ? NULL : "Exception specification table"));
|
(i ? NULL : "Exception specification table"));
|
}
|
}
|
|
|
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;
|
}
|
}
|
|
|
/* 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)
|
{
|
{
|
struct eh_region *i;
|
struct eh_region *i;
|
int depth = 0;
|
int depth = 0;
|
static const char * const type_name[] = {"unknown", "cleanup", "try", "catch",
|
static const char * const type_name[] = {"unknown", "cleanup", "try", "catch",
|
"allowed_exceptions", "must_not_throw",
|
"allowed_exceptions", "must_not_throw",
|
"throw"};
|
"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->region_number, type_name [(int)i->type]);
|
i->region_number, type_name [(int)i->type]);
|
if (i->tree_label)
|
if (i->tree_label)
|
{
|
{
|
fprintf (out, " tree_label:");
|
fprintf (out, " tree_label:");
|
print_generic_expr (out, i->tree_label, 0);
|
print_generic_expr (out, i->tree_label, 0);
|
}
|
}
|
fprintf (out, "\n");
|
fprintf (out, "\n");
|
/* 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;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Verify some basic invariants on EH datastructures. Could be extended to
|
/* Verify some basic invariants on EH datastructures. Could be extended to
|
catch more. */
|
catch more. */
|
void
|
void
|
verify_eh_tree (struct function *fun)
|
verify_eh_tree (struct function *fun)
|
{
|
{
|
struct eh_region *i, *outer = NULL;
|
struct eh_region *i, *outer = NULL;
|
bool err = false;
|
bool err = false;
|
int nvisited = 0;
|
int nvisited = 0;
|
int count = 0;
|
int count = 0;
|
int j;
|
int j;
|
int depth = 0;
|
int depth = 0;
|
|
|
i = fun->eh->region_tree;
|
i = fun->eh->region_tree;
|
if (! i)
|
if (! i)
|
return;
|
return;
|
for (j = fun->eh->last_region_number; j > 0; --j)
|
for (j = fun->eh->last_region_number; j > 0; --j)
|
if ((i = VEC_index (eh_region, cfun->eh->region_array, j)))
|
if ((i = VEC_index (eh_region, cfun->eh->region_array, j)))
|
{
|
{
|
count++;
|
count++;
|
if (i->region_number != j)
|
if (i->region_number != j)
|
{
|
{
|
error ("region_array is corrupted for region %i", i->region_number);
|
error ("region_array is corrupted for region %i", i->region_number);
|
err = true;
|
err = true;
|
}
|
}
|
}
|
}
|
|
|
while (1)
|
while (1)
|
{
|
{
|
if (VEC_index (eh_region, cfun->eh->region_array, i->region_number) != i)
|
if (VEC_index (eh_region, cfun->eh->region_array, i->region_number) != i)
|
{
|
{
|
error ("region_array is corrupted for region %i", i->region_number);
|
error ("region_array is corrupted for region %i", i->region_number);
|
err = true;
|
err = true;
|
}
|
}
|
if (i->outer != outer)
|
if (i->outer != outer)
|
{
|
{
|
error ("outer block of region %i is wrong", i->region_number);
|
error ("outer block of region %i is wrong", i->region_number);
|
err = true;
|
err = true;
|
}
|
}
|
if (i->may_contain_throw && outer && !outer->may_contain_throw)
|
if (i->may_contain_throw && outer && !outer->may_contain_throw)
|
{
|
{
|
error ("region %i may contain throw and is contained in region that may not",
|
error ("region %i may contain throw and is contained in region that may not",
|
i->region_number);
|
i->region_number);
|
err = true;
|
err = true;
|
}
|
}
|
if (depth < 0)
|
if (depth < 0)
|
{
|
{
|
error ("negative nesting depth of region %i", i->region_number);
|
error ("negative nesting depth of region %i", i->region_number);
|
err = true;
|
err = true;
|
}
|
}
|
nvisited ++;
|
nvisited ++;
|
/* If there are sub-regions, process them. */
|
/* If there are sub-regions, process them. */
|
if (i->inner)
|
if (i->inner)
|
outer = i, i = i->inner, depth++;
|
outer = i, 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)
|
{
|
{
|
if (depth != -1)
|
if (depth != -1)
|
{
|
{
|
error ("tree list ends on depth %i", depth + 1);
|
error ("tree list ends on depth %i", depth + 1);
|
err = true;
|
err = true;
|
}
|
}
|
if (count != nvisited)
|
if (count != nvisited)
|
{
|
{
|
error ("array does not match the region tree");
|
error ("array does not match the 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");
|
}
|
}
|
return;
|
return;
|
}
|
}
|
outer = i->outer;
|
outer = i->outer;
|
} while (i->next_peer == NULL);
|
} while (i->next_peer == NULL);
|
i = i->next_peer;
|
i = i->next_peer;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Initialize unwind_resume_libfunc. */
|
/* Initialize unwind_resume_libfunc. */
|
|
|
void
|
void
|
default_init_unwind_resume_libfunc (void)
|
default_init_unwind_resume_libfunc (void)
|
{
|
{
|
/* The default c++ routines aren't actually c++ specific, so use those. */
|
/* The default c++ routines aren't actually c++ specific, so use those. */
|
unwind_resume_libfunc =
|
unwind_resume_libfunc =
|
init_one_libfunc ( USING_SJLJ_EXCEPTIONS ? "_Unwind_SjLj_Resume"
|
init_one_libfunc ( USING_SJLJ_EXCEPTIONS ? "_Unwind_SjLj_Resume"
|
: "_Unwind_Resume");
|
: "_Unwind_Resume");
|
}
|
}
|
|
|
|
|
static bool
|
static bool
|
gate_handle_eh (void)
|
gate_handle_eh (void)
|
{
|
{
|
return doing_eh (0);
|
return doing_eh (0);
|
}
|
}
|
|
|
/* 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)
|
{
|
{
|
cleanup_cfg (CLEANUP_NO_INSN_DEL);
|
cleanup_cfg (CLEANUP_NO_INSN_DEL);
|
finish_eh_generation ();
|
finish_eh_generation ();
|
cleanup_cfg (CLEANUP_NO_INSN_DEL);
|
cleanup_cfg (CLEANUP_NO_INSN_DEL);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
struct tree_opt_pass pass_rtl_eh =
|
struct tree_opt_pass pass_rtl_eh =
|
{
|
{
|
"eh", /* name */
|
"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 */
|
'h' /* letter */
|
'h' /* letter */
|
};
|
};
|
|
|
#include "gt-except.h"
|
#include "gt-except.h"
|
|
|
