/* Implements exception handling.

Copyright (C) 1989-2014 Free Software Foundation, Inc.

Contributed by Mike Stump <mrs@cygnus.com>.

This file is part of GCC.

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

Software Foundation; either version 3, or (at your option) any later

version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING3. If not see

<http://www.gnu.org/licenses/>. */

/* An exception is an event that can be "thrown" from within a

function. This event can then be "caught" by the callers of

the function.

The representation of exceptions changes several times during

the compilation process:

In the beginning, in the front end, we have the GENERIC trees

TRY_CATCH_EXPR, TRY_FINALLY_EXPR, WITH_CLEANUP_EXPR,

CLEANUP_POINT_EXPR, CATCH_EXPR, and EH_FILTER_EXPR.

During initial gimplification (gimplify.c) these are lowered

to the GIMPLE_TRY, GIMPLE_CATCH, and GIMPLE_EH_FILTER nodes.

The WITH_CLEANUP_EXPR and CLEANUP_POINT_EXPR nodes are converted

into GIMPLE_TRY_FINALLY nodes; the others are a more direct 1-1

conversion.

During pass_lower_eh (tree-eh.c) we record the nested structure

of the TRY nodes in EH_REGION nodes in CFUN->EH->REGION_TREE.

We expand the eh_protect_cleanup_actions langhook into MUST_NOT_THROW

regions at this time. We can then flatten the statements within

the TRY nodes to straight-line code. Statements that had been within

TRY nodes that can throw are recorded within CFUN->EH->THROW_STMT_TABLE,

so that we may remember what action is supposed to be taken if

a given statement does throw. During this lowering process,

we create an EH_LANDING_PAD node for each EH_REGION that has

some code within the function that needs to be executed if a

throw does happen. We also create RESX statements that are

used to transfer control from an inner EH_REGION to an outer

EH_REGION. We also create EH_DISPATCH statements as placeholders

for a runtime type comparison that should be made in order to

select the action to perform among different CATCH and EH_FILTER

regions.

During pass_lower_eh_dispatch (tree-eh.c), which is run after

all inlining is complete, we are able to run assign_filter_values,

which allows us to map the set of types manipulated by all of the

CATCH and EH_FILTER regions to a set of integers. This set of integers

will be how the exception runtime communicates with the code generated

within the function. We then expand the GIMPLE_EH_DISPATCH statements

to a switch or conditional branches that use the argument provided by

the runtime (__builtin_eh_filter) and the set of integers we computed

in assign_filter_values.

During pass_lower_resx (tree-eh.c), which is run near the end

of optimization, we expand RESX statements. If the eh region

that is outer to the RESX statement is a MUST_NOT_THROW, then

the RESX expands to some form of abort statement. If the eh

region that is outer to the RESX statement is within the current

function, then the RESX expands to a bookkeeping call

(__builtin_eh_copy_values) and a goto. Otherwise, the next

handler for the exception must be within a function somewhere

up the call chain, so we call back into the exception runtime

(__builtin_unwind_resume).

During pass_expand (cfgexpand.c), we generate REG_EH_REGION notes

that create an rtl to eh_region mapping that corresponds to the

gimple to eh_region mapping that had been recorded in the

THROW_STMT_TABLE.

Then, via finish_eh_generation, we generate the real landing pads

to which the runtime will actually transfer control. These new

landing pads perform whatever bookkeeping is needed by the target

backend in order to resume execution within the current function.

Each of these new landing pads falls through into the post_landing_pad

label which had been used within the CFG up to this point. All

exception edges within the CFG are redirected to the new landing pads.

If the target uses setjmp to implement exceptions, the various extra

calls into the runtime to register and unregister the current stack

frame are emitted at this time.

During pass_convert_to_eh_region_ranges (except.c), we transform

the REG_EH_REGION notes attached to individual insns into

non-overlapping ranges of insns bounded by NOTE_INSN_EH_REGION_BEG

and NOTE_INSN_EH_REGION_END. Each insn within such ranges has the

same associated action within the exception region tree, meaning

that (1) the exception is caught by the same landing pad within the

current function, (2) the exception is blocked by the runtime with

a MUST_NOT_THROW region, or (3) the exception is not handled at all

within the current function.

Finally, during assembly generation, we call

output_function_exception_table (except.c) to emit the tables with

which the exception runtime can determine if a given stack frame

handles a given exception, and if so what filter value to provide

to the function when the non-local control transfer is effected.

If the target uses dwarf2 unwinding to implement exceptions, then

output_call_frame_info (dwarf2out.c) emits the required unwind data. */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "rtl.h"

#include "tree.h"

#include "stringpool.h"

#include "stor-layout.h"

#include "flags.h"

#include "hashtab.h"

#include "hash-set.h"

#include "vec.h"

#include "machmode.h"

#include "hard-reg-set.h"

#include "input.h"

#include "function.h"

#include "insn-codes.h"

#include "optabs.h"

#include "expr.h"

#include "libfuncs.h"

#include "insn-config.h"

#include "except.h"

#include "output.h"

#include "dwarf2asm.h"

#include "dwarf2out.h"

#include "dwarf2.h"

#include "toplev.h"

#include "hash-table.h"

#include "intl.h"

#include "tm_p.h"

#include "target.h"

#include "common/common-target.h"

#include "langhooks.h"

#include "predict.h"

#include "dominance.h"

#include "cfg.h"

#include "cfgrtl.h"

#include "basic-block.h"

#include "hash-map.h"

#include "is-a.h"

#include "plugin-api.h"

#include "ipa-ref.h"

#include "cgraph.h"

#include "diagnostic.h"

#include "tree-pretty-print.h"

#include "tree-pass.h"

#include "cfgloop.h"

#include "builtins.h"

/* Provide defaults for stuff that may not be defined when using

sjlj exceptions. */

#ifndef EH_RETURN_DATA_REGNO

#define EH_RETURN_DATA_REGNO(N) INVALID_REGNUM

#endif

static GTY(()) int call_site_base;

struct tree_hash_traits : default_hashmap_traits

{

static hashval_t hash (tree t) { return TREE_HASH (t); }

};

static GTY (()) hash_map<tree, tree, tree_hash_traits> *type_to_runtime_map;

/* Describe the SjLj_Function_Context structure. */

static GTY(()) tree sjlj_fc_type_node;

static int sjlj_fc_call_site_ofs;

static int sjlj_fc_data_ofs;

static int sjlj_fc_personality_ofs;

static int sjlj_fc_lsda_ofs;

static int sjlj_fc_jbuf_ofs;



struct GTY(()) call_site_record_d

{

rtx landing_pad;

int action;

};

/* In the following structure and associated functions,

we represent entries in the action table as 1-based indices.

Special cases are:

0: null action record, non-null landing pad; implies cleanups

-1: null action record, null landing pad; implies no action

-2: no call-site entry; implies must_not_throw

-3: we have yet to process outer regions

Further, no special cases apply to the "next" field of the record.

For next, 0 means end of list. */

struct action_record

};

/* Hashtable helpers. */

struct action_record_hasher : typed_free_remove <action_record>

{

typedef action_record value_type;

typedef action_record compare_type;

static inline hashval_t hash (const value_type *);

static inline bool equal (const value_type *, const compare_type *);

};

inline hashval_t

action_record_hasher::hash (const value_type *entry)

{

return entry->next * 1009 + entry->filter;

}

inline bool

action_record_hasher::equal (const value_type *entry, const compare_type *data)

{

return entry->filter == data->filter && entry->next == data->next;

}

typedef hash_table<action_record_hasher> action_hash_type;



static bool get_eh_region_and_lp_from_rtx (const_rtx, eh_region *,

eh_landing_pad *);

static void dw2_build_landing_pads (void);

static int collect_one_action_chain (action_hash_type *, eh_region);

static int add_call_site (rtx, int, int);

static void push_uleb128 (vec<uchar, va_gc> **, unsigned int);

static void push_sleb128 (vec<uchar, va_gc> **, int);

#ifndef HAVE_AS_LEB128

static int dw2_size_of_call_site_table (int);

static int sjlj_size_of_call_site_table (void);

#endif

static void dw2_output_call_site_table (int, int);

static void sjlj_output_call_site_table (void);



void

init_eh (void)

{

if (! flag_exceptions)

return;

type_to_runtime_map

= hash_map<tree, tree, tree_hash_traits>::create_ggc (31);

/* Create the SjLj_Function_Context structure. This should match

the definition in unwind-sjlj.c. */

if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)

{

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);

f_prev = build_decl (BUILTINS_LOCATION,

FIELD_DECL, get_identifier ("__prev"),

build_pointer_type (sjlj_fc_type_node));

DECL_FIELD_CONTEXT (f_prev) = sjlj_fc_type_node;

f_cs = build_decl (BUILTINS_LOCATION,

FIELD_DECL, get_identifier ("__call_site"),

integer_type_node);

DECL_FIELD_CONTEXT (f_cs) = sjlj_fc_type_node;

tmp = build_index_type (size_int (4 - 1));

tmp = build_array_type (lang_hooks.types.type_for_mode

(targetm.unwind_word_mode (), 1),

tmp);

f_data = build_decl (BUILTINS_LOCATION,

FIELD_DECL, get_identifier ("__data"), tmp);

DECL_FIELD_CONTEXT (f_data) = sjlj_fc_type_node;

f_per = build_decl (BUILTINS_LOCATION,

FIELD_DECL, get_identifier ("__personality"),

ptr_type_node);

DECL_FIELD_CONTEXT (f_per) = sjlj_fc_type_node;

f_lsda = build_decl (BUILTINS_LOCATION,

FIELD_DECL, get_identifier ("__lsda"),

ptr_type_node);

DECL_FIELD_CONTEXT (f_lsda) = sjlj_fc_type_node;

#ifdef DONT_USE_BUILTIN_SETJMP

#ifdef JMP_BUF_SIZE

tmp = size_int (JMP_BUF_SIZE - 1);

#else

/* Should be large enough for most systems, if it is not,

JMP_BUF_SIZE should be defined with the proper value. It will

also tend to be larger than necessary for most systems, a more

optimal port will define JMP_BUF_SIZE. */

tmp = size_int (FIRST_PSEUDO_REGISTER + 2 - 1);

#endif

#else

/* Compute a minimally sized jump buffer. We need room to store at

least 3 pointers - stack pointer, frame pointer and return address.

Plus for some targets we need room for an extra pointer - in the

case of MIPS this is the global pointer. This makes a total of four

pointers, but to be safe we actually allocate room for 5.

If pointers are smaller than words then we allocate enough room for

5 words, just in case the backend needs this much room. For more

discussion on this issue see:

http://gcc.gnu.org/ml/gcc-patches/2014-05/msg00313.html. */

if (POINTER_SIZE > BITS_PER_WORD)

tmp = size_int (5 - 1);

else

tmp = size_int ((5 * BITS_PER_WORD / POINTER_SIZE) - 1);

#endif

tmp = build_index_type (tmp);

tmp = build_array_type (ptr_type_node, tmp);

f_jbuf = build_decl (BUILTINS_LOCATION,

FIELD_DECL, get_identifier ("__jbuf"), tmp);

#ifdef DONT_USE_BUILTIN_SETJMP

/* We don't know what the alignment requirements of the

runtime's jmp_buf has. Overestimate. */

DECL_ALIGN (f_jbuf) = BIGGEST_ALIGNMENT;

DECL_USER_ALIGN (f_jbuf) = 1;

#endif

DECL_FIELD_CONTEXT (f_jbuf) = sjlj_fc_type_node;

TYPE_FIELDS (sjlj_fc_type_node) = f_prev;

TREE_CHAIN (f_prev) = f_cs;

TREE_CHAIN (f_cs) = f_data;

TREE_CHAIN (f_data) = f_per;

TREE_CHAIN (f_per) = f_lsda;

TREE_CHAIN (f_lsda) = f_jbuf;

layout_type (sjlj_fc_type_node);

/* Cache the interesting field offsets so that we have

easy access from rtl. */

sjlj_fc_call_site_ofs

= (tree_to_uhwi (DECL_FIELD_OFFSET (f_cs))

+ tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_cs)) / BITS_PER_UNIT);

sjlj_fc_data_ofs

= (tree_to_uhwi (DECL_FIELD_OFFSET (f_data))

+ tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_data)) / BITS_PER_UNIT);

sjlj_fc_personality_ofs

= (tree_to_uhwi (DECL_FIELD_OFFSET (f_per))

+ tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_per)) / BITS_PER_UNIT);

sjlj_fc_lsda_ofs

= (tree_to_uhwi (DECL_FIELD_OFFSET (f_lsda))

+ tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_lsda)) / BITS_PER_UNIT);

sjlj_fc_jbuf_ofs

= (tree_to_uhwi (DECL_FIELD_OFFSET (f_jbuf))

+ tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_jbuf)) / BITS_PER_UNIT);

}

}

void

init_eh_for_function (void)

{

cfun->eh = ggc_cleared_alloc<eh_status> ();

/* Make sure zero'th entries are used. */

vec_safe_push (cfun->eh->region_array, (eh_region)0);

vec_safe_push (cfun->eh->lp_array, (eh_landing_pad)0);

}



/* Routines to generate the exception tree somewhat directly.

These are used from tree-eh.c when processing exception related

nodes during tree optimization. */

static eh_region

gen_eh_region (enum eh_region_type type, eh_region outer)

{

eh_region new_eh;

/* Insert a new blank region as a leaf in the tree. */

new_eh = ggc_cleared_alloc<eh_region_d> ();

new_eh->type = type;

new_eh->outer = outer;

if (outer)

{

new_eh->next_peer = outer->inner;

outer->inner = new_eh;

}

else

{

new_eh->next_peer = cfun->eh->region_tree;

cfun->eh->region_tree = new_eh;

}

new_eh->index = vec_safe_length (cfun->eh->region_array);

vec_safe_push (cfun->eh->region_array, new_eh);

/* Copy the language's notion of whether to use __cxa_end_cleanup. */

if (targetm.arm_eabi_unwinder && lang_hooks.eh_use_cxa_end_cleanup)

new_eh->use_cxa_end_cleanup = true;

return new_eh;

}

eh_region

gen_eh_region_cleanup (eh_region outer)

{

return gen_eh_region (ERT_CLEANUP, outer);

}

eh_region

gen_eh_region_try (eh_region outer)

{

return gen_eh_region (ERT_TRY, outer);

}

eh_catch

gen_eh_region_catch (eh_region t, tree type_or_list)

{

eh_catch c, l;

tree type_list, type_node;

gcc_assert (t->type == ERT_TRY);

/* Ensure to always end up with a type list to normalize further

processing, then register each type against the runtime types map. */

type_list = type_or_list;

if (type_or_list)

{

if (TREE_CODE (type_or_list) != TREE_LIST)

type_list = tree_cons (NULL_TREE, type_or_list, NULL_TREE);

type_node = type_list;

for (; type_node; type_node = TREE_CHAIN (type_node))

add_type_for_runtime (TREE_VALUE (type_node));

}

c = ggc_cleared_alloc<eh_catch_d> ();

c->type_list = type_list;

l = t->u.eh_try.last_catch;

c->prev_catch = l;

if (l)

l->next_catch = c;

else

t->u.eh_try.first_catch = c;

t->u.eh_try.last_catch = c;

return c;

}

eh_region

gen_eh_region_allowed (eh_region outer, tree allowed)

{

eh_region region = gen_eh_region (ERT_ALLOWED_EXCEPTIONS, outer);

region->u.allowed.type_list = allowed;

for (; allowed ; allowed = TREE_CHAIN (allowed))

add_type_for_runtime (TREE_VALUE (allowed));

return region;

}

eh_region

gen_eh_region_must_not_throw (eh_region outer)

{

return gen_eh_region (ERT_MUST_NOT_THROW, outer);

}

eh_landing_pad

gen_eh_landing_pad (eh_region region)

{

eh_landing_pad lp = ggc_cleared_alloc<eh_landing_pad_d> ();

lp->next_lp = region->landing_pads;

lp->region = region;

lp->index = vec_safe_length (cfun->eh->lp_array);

region->landing_pads = lp;

vec_safe_push (cfun->eh->lp_array, lp);

return lp;

}

eh_region

get_eh_region_from_number_fn (struct function *ifun, int i)

{

return (*ifun->eh->region_array)[i];

}

eh_region

get_eh_region_from_number (int i)

{

return get_eh_region_from_number_fn (cfun, i);

}

eh_landing_pad

get_eh_landing_pad_from_number_fn (struct function *ifun, int i)

{

return (*ifun->eh->lp_array)[i];

}

eh_landing_pad

get_eh_landing_pad_from_number (int i)

{

return get_eh_landing_pad_from_number_fn (cfun, i);

}

eh_region

get_eh_region_from_lp_number_fn (struct function *ifun, int i)

{

if (i < 0)

return (*ifun->eh->region_array)[-i];

else if (i == 0)

return NULL;

else

{

eh_landing_pad lp;

lp = (*ifun->eh->lp_array)[i];

return lp->region;

}

}

eh_region

get_eh_region_from_lp_number (int i)

{

return get_eh_region_from_lp_number_fn (cfun, i);

}



/* Returns true if the current function has exception handling regions. */

bool

current_function_has_exception_handlers (void)

{

return cfun->eh->region_tree != NULL;

}



/* A subroutine of duplicate_eh_regions. Copy the eh_region tree at OLD.

Root it at OUTER, and apply LP_OFFSET to the lp numbers. */

struct duplicate_eh_regions_data

};

static void

duplicate_eh_regions_1 (struct duplicate_eh_regions_data *data,

eh_region old_r, eh_region outer)

{

eh_landing_pad old_lp, new_lp;

eh_region new_r;

new_r = gen_eh_region (old_r->type, outer);

gcc_assert (!data->eh_map->put (old_r, new_r));

switch (old_r->type)

{

case ERT_CLEANUP:

break;

case ERT_TRY:

{

eh_catch oc, nc;

for (oc = old_r->u.eh_try.first_catch; oc ; oc = oc->next_catch)

{

/* We should be doing all our region duplication before and

during inlining, which is before filter lists are created. */

gcc_assert (oc->filter_list == NULL);

nc = gen_eh_region_catch (new_r, oc->type_list);

nc->label = data->label_map (oc->label, data->label_map_data);

}

}

break;

case ERT_ALLOWED_EXCEPTIONS:

new_r->u.allowed.type_list = old_r->u.allowed.type_list;

if (old_r->u.allowed.label)

new_r->u.allowed.label

= data->label_map (old_r->u.allowed.label, data->label_map_data);

else

new_r->u.allowed.label = NULL_TREE;

break;

case ERT_MUST_NOT_THROW:

new_r->u.must_not_throw.failure_loc =

LOCATION_LOCUS (old_r->u.must_not_throw.failure_loc);

new_r->u.must_not_throw.failure_decl =

old_r->u.must_not_throw.failure_decl;

break;

}

for (old_lp = old_r->landing_pads; old_lp ; old_lp = old_lp->next_lp)

{

/* Don't bother copying unused landing pads. */

if (old_lp->post_landing_pad == NULL)

continue;

new_lp = gen_eh_landing_pad (new_r);

gcc_assert (!data->eh_map->put (old_lp, new_lp));

new_lp->post_landing_pad

= data->label_map (old_lp->post_landing_pad, data->label_map_data);

EH_LANDING_PAD_NR (new_lp->post_landing_pad) = new_lp->index;

}

/* Make sure to preserve the original use of __cxa_end_cleanup. */

new_r->use_cxa_end_cleanup = old_r->use_cxa_end_cleanup;

for (old_r = old_r->inner; old_r ; old_r = old_r->next_peer)

duplicate_eh_regions_1 (data, old_r, new_r);

}

/* Duplicate the EH regions from IFUN rooted at COPY_REGION into

the current function and root the tree below OUTER_REGION.

The special case of COPY_REGION of NULL means all regions.

Remap labels using MAP/MAP_DATA callback. Return a pointer map

that allows the caller to remap uses of both EH regions and

EH landing pads. */

hash_map<void *, void *> *

duplicate_eh_regions (struct function *ifun,

eh_region copy_region, int outer_lp,

duplicate_eh_regions_map map, void *map_data)

{

struct duplicate_eh_regions_data data;

eh_region outer_region;

#ifdef ENABLE_CHECKING

verify_eh_tree (ifun);

#endif

data.label_map = map;

data.label_map_data = map_data;

data.eh_map = new hash_map<void *, void *>;

outer_region = get_eh_region_from_lp_number (outer_lp);

/* Copy all the regions in the subtree. */

if (copy_region)

duplicate_eh_regions_1 (&data, copy_region, outer_region);

else

{

eh_region r;

for (r = ifun->eh->region_tree; r ; r = r->next_peer)

duplicate_eh_regions_1 (&data, r, outer_region);

}

#ifdef ENABLE_CHECKING

verify_eh_tree (cfun);

#endif

return data.eh_map;

}

/* Return the region that is outer to both REGION_A and REGION_B in IFUN. */

eh_region

eh_region_outermost (struct function *ifun, eh_region region_a,

eh_region region_b)

{

sbitmap b_outer;

gcc_assert (ifun->eh->region_array);

gcc_assert (ifun->eh->region_tree);

b_outer = sbitmap_alloc (ifun->eh->region_array->length ());

bitmap_clear (b_outer);

do

{

bitmap_set_bit (b_outer, region_b->index);

region_b = region_b->outer;

}

while (region_b);

do

{

if (bitmap_bit_p (b_outer, region_a->index))

break;

region_a = region_a->outer;

}

while (region_a);

sbitmap_free (b_outer);

return region_a;

}



void

add_type_for_runtime (tree type)

{

/* If TYPE is NOP_EXPR, it means that it already is a runtime type. */

if (TREE_CODE (type) == NOP_EXPR)

return;

bool existed = false;

tree *slot = &type_to_runtime_map->get_or_insert (type, &existed);

if (!existed)

*slot = lang_hooks.eh_runtime_type (type);

}

tree

lookup_type_for_runtime (tree type)

{

/* If TYPE is NOP_EXPR, it means that it already is a runtime type. */

if (TREE_CODE (type) == NOP_EXPR)

return type;

/* We should have always inserted the data earlier. */

return *type_to_runtime_map->get (type);

}



/* Represent an entry in @TTypes for either catch actions

or exception filter actions. */

struct ttypes_filter {

tree t;

int filter;

};

/* Helper for ttypes_filter hashing. */

struct ttypes_filter_hasher : typed_free_remove <ttypes_filter>

{

typedef ttypes_filter value_type;

typedef tree_node compare_type;

static inline hashval_t hash (const value_type *);

static inline bool equal (const value_type *, const compare_type *);

};

/* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA

(a tree) for a @TTypes type node we are thinking about adding. */

inline bool

ttypes_filter_hasher::equal (const value_type *entry, const compare_type *data)

{

return entry->t == data;

}

inline hashval_t

ttypes_filter_hasher::hash (const value_type *entry)

{

return TREE_HASH (entry->t);

}

typedef hash_table<ttypes_filter_hasher> ttypes_hash_type;

/* Helper for ehspec hashing. */

struct ehspec_hasher : typed_free_remove <ttypes_filter>

{

typedef ttypes_filter value_type;

typedef ttypes_filter compare_type;

static inline hashval_t hash (const value_type *);

static inline bool equal (const value_type *, const compare_type *);

};

/* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes

exception specification list we are thinking about adding. */

/* ??? Currently we use the type lists in the order given. Someone

should put these in some canonical order. */

inline bool

ehspec_hasher::equal (const value_type *entry, const compare_type *data)

{

return type_list_equal (entry->t, data->t);

}

/* Hash function for exception specification lists. */

inline hashval_t

ehspec_hasher::hash (const value_type *entry)

{

hashval_t h = 0;

tree list;

for (list = entry->t; list ; list = TREE_CHAIN (list))

h = (h << 5) + (h >> 27) + TREE_HASH (TREE_VALUE (list));

return h;

}

typedef hash_table<ehspec_hasher> ehspec_hash_type;

/* 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. */

static int

add_ttypes_entry (ttypes_hash_type *ttypes_hash, tree type)

{

struct ttypes_filter **slot, *n;

slot = ttypes_hash->find_slot_with_hash (type, (hashval_t) TREE_HASH (type),

INSERT);

if ((n = *slot) == NULL)

{

/* Filter value is a 1 based table index. */

n = XNEW (struct ttypes_filter);

n->t = type;

n->filter = vec_safe_length (cfun->eh->ttype_data) + 1;

*slot = n;

vec_safe_push (cfun->eh->ttype_data, type);

}

return n->filter;

}

/* 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. */

static int

add_ehspec_entry (ehspec_hash_type *ehspec_hash, ttypes_hash_type *ttypes_hash,

tree list)

{

struct ttypes_filter **slot, *n;

struct ttypes_filter dummy;

dummy.t = list;

slot = ehspec_hash->find_slot (&dummy, INSERT);

if ((n = *slot) == NULL)

{

int len;

if (targetm.arm_eabi_unwinder)

len = vec_safe_length (cfun->eh->ehspec_data.arm_eabi);

else

len = vec_safe_length (cfun->eh->ehspec_data.other);

/* Filter value is a -1 based byte index into a uleb128 buffer. */

n = XNEW (struct ttypes_filter);

n->t = list;

n->filter = -(len + 1);

*slot = n;

/* Generate a 0 terminated list of filter values. */

for (; list ; list = TREE_CHAIN (list))

{

if (targetm.arm_eabi_unwinder)

vec_safe_push (cfun->eh->ehspec_data.arm_eabi, TREE_VALUE (list));

else

{

/* Look up each type in the list and encode its filter

value as a uleb128. */

push_uleb128 (&cfun->eh->ehspec_data.other,

add_ttypes_entry (ttypes_hash, TREE_VALUE (list)));

}

}

if (targetm.arm_eabi_unwinder)

vec_safe_push (cfun->eh->ehspec_data.arm_eabi, NULL_TREE);

else

vec_safe_push (cfun->eh->ehspec_data.other, (uchar)0);

}

return n->filter;

}

/* Generate the action filter values to be used for CATCH and

ALLOWED_EXCEPTIONS regions. When using dwarf2 exception regions,

we use lots of landing pads, and so every type or list can share

the same filter value, which saves table space. */

void

assign_filter_values (void)

{

int i;

eh_region r;

eh_catch c;

vec_alloc (cfun->eh->ttype_data, 16);

if (targetm.arm_eabi_unwinder)

vec_alloc (cfun->eh->ehspec_data.arm_eabi, 64);

else

vec_alloc (cfun->eh->ehspec_data.other, 64);

ehspec_hash_type ehspec (31);

ttypes_hash_type ttypes (31);

for (i = 1; vec_safe_iterate (cfun->eh->region_array, i, &r); ++i)

{

if (r == NULL)

continue;

switch (r->type)

{

case ERT_TRY:

for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)

{

/* Whatever type_list is (NULL or true list), we build a list

of filters for the region. */

c->filter_list = NULL_TREE;

if (c->type_list != NULL)

{

/* Get a filter value for each of the types caught and store

them in the region's dedicated list. */

tree tp_node = c->type_list;

for ( ; tp_node; tp_node = TREE_CHAIN (tp_node))

{

int flt

= add_ttypes_entry (&ttypes, TREE_VALUE (tp_node));

tree flt_node = build_int_cst (integer_type_node, flt);

c->filter_list

= tree_cons (NULL_TREE, flt_node, c->filter_list);

}

}

else

{

/* Get a filter value for the NULL list also since it

will need an action record anyway. */

int flt = add_ttypes_entry (&ttypes, NULL);

tree flt_node = build_int_cst (integer_type_node, flt);

c->filter_list

= tree_cons (NULL_TREE, flt_node, NULL);

}

}

break;

case ERT_ALLOWED_EXCEPTIONS:

r->u.allowed.filter

= add_ehspec_entry (&ehspec, &ttypes, r->u.allowed.type_list);

break;

default:

break;

}

}

}

/* Emit SEQ into basic block just before INSN (that is assumed to be

first instruction of some existing BB and return the newly

produced block. */

static basic_block

emit_to_new_bb_before (rtx_insn *seq, rtx insn)

{

rtx_insn *last;

basic_block bb;

edge e;

edge_iterator ei;

/* 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

construct. */

for (ei = ei_start (BLOCK_FOR_INSN (insn)->preds); (e = ei_safe_edge (ei)); )

if (e->flags & EDGE_FALLTHRU)

force_nonfallthru (e);

else

ei_next (&ei);

last = emit_insn_before (seq, insn);

if (BARRIER_P (last))

last = PREV_INSN (last);

bb = create_basic_block (seq, last, BLOCK_FOR_INSN (insn)->prev_bb);

update_bb_for_insn (bb);

bb->flags |= BB_SUPERBLOCK;

return bb;

}



/* A subroutine of dw2_build_landing_pads, also used for edge splitting

at the rtl level. Emit the code required by the target at a landing

pad for the given region. */

void

expand_dw2_landing_pad_for_region (eh_region region)

{

#ifdef HAVE_exception_receiver

if (HAVE_exception_receiver)

emit_insn (gen_exception_receiver ());

else

#endif

#ifdef HAVE_nonlocal_goto_receiver

if (HAVE_nonlocal_goto_receiver)

emit_insn (gen_nonlocal_goto_receiver ());

else

#endif

{ /* Nothing */ }

if (region->exc_ptr_reg)

emit_move_insn (region->exc_ptr_reg,

gen_rtx_REG (ptr_mode, EH_RETURN_DATA_REGNO (0)));

if (region->filter_reg)

emit_move_insn (region->filter_reg,

gen_rtx_REG (targetm.eh_return_filter_mode (),

EH_RETURN_DATA_REGNO (1)));

}

/* Expand the extra code needed at landing pads for dwarf2 unwinding. */

static void