1/* Exception Handling interface routines.
2   Copyright (C) 1996-2015 Free Software Foundation, Inc.
3   Contributed by Mike Stump <mrs@cygnus.com>.
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING3.  If not see
19<http://www.gnu.org/licenses/>.  */
20
21/* No include guards here, but define an include file marker anyway, so
22   that the compiler can keep track of where this file is included.  This
23   is e.g. used to avoid including this file in front-end specific files.  */
24#ifndef GCC_EXCEPT_H
25#define GCC_EXCEPT_H
26
27#include "hash-map.h"
28#include "hashtab.h"
29
30struct function;
31struct eh_region_d;
32
33/* The type of an exception region.  */
34enum eh_region_type
35{
36  /* CLEANUP regions implement e.g. destructors run when exiting a block.
37     They can be generated from both GIMPLE_TRY_FINALLY and GIMPLE_TRY_CATCH
38     nodes.  It is expected by the runtime that cleanup regions will *not*
39     resume normal program flow, but will continue propagation of the
40     exception.  */
41  ERT_CLEANUP,
42
43  /* TRY regions implement catching an exception.  The list of types associated
44     with the attached catch handlers is examined in order by the runtime and
45     control is transferred to the appropriate handler.  Note that a NULL type
46     list is a catch-all handler, and that it will catch *all* exceptions
47     including those originating from a different language.  */
48  ERT_TRY,
49
50  /* ALLOWED_EXCEPTIONS regions implement exception filtering, e.g. the
51     throw(type-list) specification that can be added to C++ functions.
52     The runtime examines the thrown exception vs the type list, and if
53     the exception does not match, transfers control to the handler.  The
54     normal handler for C++ calls __cxa_call_unexpected.  */
55  ERT_ALLOWED_EXCEPTIONS,
56
57  /* MUST_NOT_THROW regions prevent all exceptions from propagating.  This
58     region type is used in C++ to surround destructors being run inside a
59     CLEANUP region.  This differs from an ALLOWED_EXCEPTIONS region with
60     an empty type list in that the runtime is prepared to terminate the
61     program directly.  We only generate code for MUST_NOT_THROW regions
62     along control paths that are already handling an exception within the
63     current function.  */
64  ERT_MUST_NOT_THROW
65};
66
67
68/* A landing pad for a given exception region.  Any transfer of control
69   from the EH runtime to the function happens at a landing pad.  */
70
71struct GTY(()) eh_landing_pad_d
72{
73  /* The linked list of all landing pads associated with the region.  */
74  struct eh_landing_pad_d *next_lp;
75
76  /* The region with which this landing pad is associated.  */
77  struct eh_region_d *region;
78
79  /* At the gimple level, the location to which control will be transferred
80     for this landing pad.  There can be both EH and normal edges into the
81     block containing the post-landing-pad label.  */
82  tree post_landing_pad;
83
84  /* At the rtl level, the location to which the runtime will transfer
85     control.  This differs from the post-landing-pad in that the target's
86     EXCEPTION_RECEIVER pattern will be expanded here, as well as other
87     bookkeeping specific to exceptions.  There must not be normal edges
88     into the block containing the landing-pad label.  */
89  rtx_code_label *landing_pad;
90
91  /* The index of this landing pad within fun->eh->lp_array.  */
92  int index;
93};
94
95/* A catch handler associated with an ERT_TRY region.  */
96
97struct GTY(()) eh_catch_d
98{
99  /* The double-linked list of all catch handlers for the region.  */
100  struct eh_catch_d *next_catch;
101  struct eh_catch_d *prev_catch;
102
103  /* A TREE_LIST of runtime type objects that this catch handler
104     will catch, or NULL if all exceptions are caught.  */
105  tree type_list;
106
107  /* A TREE_LIST of INTEGER_CSTs that correspond to the type_list entries,
108     having been mapped by assign_filter_values.  These integers are to be
109     compared against the __builtin_eh_filter value.  */
110  tree filter_list;
111
112  /* The code that should be executed if this catch handler matches the
113     thrown exception.  This label is only maintained until
114     pass_lower_eh_dispatch, at which point it is cleared.  */
115  tree label;
116};
117
118/* Describes one exception region.  */
119
120struct GTY(()) eh_region_d
121{
122  /* The immediately surrounding region.  */
123  struct eh_region_d *outer;
124
125  /* The list of immediately contained regions.  */
126  struct eh_region_d *inner;
127  struct eh_region_d *next_peer;
128
129  /* The index of this region within fun->eh->region_array.  */
130  int index;
131
132  /* Each region does exactly one thing.  */
133  enum eh_region_type type;
134
135  /* Holds the action to perform based on the preceding type.  */
136  union eh_region_u {
137    struct eh_region_u_try {
138      /* The double-linked list of all catch handlers for this region.  */
139      struct eh_catch_d *first_catch;
140      struct eh_catch_d *last_catch;
141    } GTY ((tag ("ERT_TRY"))) eh_try;
142
143    struct eh_region_u_allowed {
144      /* A TREE_LIST of runtime type objects allowed to pass.  */
145      tree type_list;
146      /* The code that should be executed if the thrown exception does
147	 not match the type list.  This label is only maintained until
148	 pass_lower_eh_dispatch, at which point it is cleared.  */
149      tree label;
150      /* The integer that will be passed by the runtime to signal that
151	 we should execute the code at LABEL.  This integer is assigned
152	 by assign_filter_values and is to be compared against the
153	 __builtin_eh_filter value.  */
154      int filter;
155    } GTY ((tag ("ERT_ALLOWED_EXCEPTIONS"))) allowed;
156
157    struct eh_region_u_must_not_throw {
158      /* A function decl to be invoked if this region is actually reachable
159	 from within the function, rather than implementable from the runtime.
160	 The normal way for this to happen is for there to be a CLEANUP region
161	 contained within this MUST_NOT_THROW region.  Note that if the
162	 runtime handles the MUST_NOT_THROW region, we have no control over
163	 what termination function is called; it will be decided by the
164	 personality function in effect for this CIE.  */
165      tree failure_decl;
166      /* The location assigned to the call of FAILURE_DECL, if expanded.  */
167      location_t failure_loc;
168    } GTY ((tag ("ERT_MUST_NOT_THROW"))) must_not_throw;
169  } GTY ((desc ("%0.type"))) u;
170
171  /* The list of landing pads associated with this region.  */
172  struct eh_landing_pad_d *landing_pads;
173
174  /* EXC_PTR and FILTER values copied from the runtime for this region.
175     Each region gets its own psuedos so that if there are nested exceptions
176     we do not overwrite the values of the first exception.  */
177  rtx exc_ptr_reg, filter_reg;
178
179  /* True if this region should use __cxa_end_cleanup instead
180     of _Unwind_Resume.  */
181  bool use_cxa_end_cleanup;
182};
183
184typedef struct eh_landing_pad_d *eh_landing_pad;
185typedef struct eh_catch_d *eh_catch;
186typedef struct eh_region_d *eh_region;
187
188
189
190
191/* The exception status for each function.  */
192
193struct GTY(()) eh_status
194{
195  /* The tree of all regions for this function.  */
196  eh_region region_tree;
197
198  /* The same information as an indexable array.  */
199  vec<eh_region, va_gc> *region_array;
200
201  /* The landing pads as an indexable array.  */
202  vec<eh_landing_pad, va_gc> *lp_array;
203
204  /* At the gimple level, a mapping from gimple statement to landing pad
205     or must-not-throw region.  See record_stmt_eh_region.  */
206  hash_map<gimple, int> *GTY(()) throw_stmt_table;
207
208  /* All of the runtime type data used by the function.  These objects
209     are emitted to the lang-specific-data-area for the function.  */
210  vec<tree, va_gc> *ttype_data;
211
212  /* The table of all action chains.  These encode the eh_region tree in
213     a compact form for use by the runtime, and is also emitted to the
214     lang-specific-data-area.  Note that the ARM EABI uses a different
215     format for the encoding than all other ports.  */
216  union eh_status_u {
217    vec<tree, va_gc> *GTY((tag ("1"))) arm_eabi;
218    vec<uchar, va_gc> *GTY((tag ("0"))) other;
219  } GTY ((desc ("targetm.arm_eabi_unwinder"))) ehspec_data;
220};
221
222
223/* Invokes CALLBACK for every exception handler label.  Only used by old
224   loop hackery; should not be used by new code.  */
225extern void for_each_eh_label (void (*) (rtx));
226
227extern void init_eh_for_function (void);
228
229extern void remove_eh_landing_pad (eh_landing_pad);
230extern void remove_eh_handler (eh_region);
231extern void remove_unreachable_eh_regions (sbitmap);
232
233extern bool current_function_has_exception_handlers (void);
234extern void output_function_exception_table (const char *);
235
236extern rtx expand_builtin_eh_pointer (tree);
237extern rtx expand_builtin_eh_filter (tree);
238extern rtx expand_builtin_eh_copy_values (tree);
239extern void expand_builtin_unwind_init (void);
240extern rtx expand_builtin_eh_return_data_regno (tree);
241extern rtx expand_builtin_extract_return_addr (tree);
242extern void expand_builtin_init_dwarf_reg_sizes (tree);
243extern rtx expand_builtin_frob_return_addr (tree);
244extern rtx expand_builtin_dwarf_sp_column (void);
245extern void expand_builtin_eh_return (tree, tree);
246extern void expand_eh_return (void);
247extern rtx expand_builtin_extend_pointer (tree);
248extern void expand_dw2_landing_pad_for_region (eh_region);
249
250typedef tree (*duplicate_eh_regions_map) (tree, void *);
251extern hash_map<void *, void *> *duplicate_eh_regions
252  (struct function *, eh_region, int, duplicate_eh_regions_map, void *);
253
254extern void sjlj_emit_function_exit_after (rtx_insn *);
255
256extern eh_region gen_eh_region_cleanup (eh_region);
257extern eh_region gen_eh_region_try (eh_region);
258extern eh_region gen_eh_region_allowed (eh_region, tree);
259extern eh_region gen_eh_region_must_not_throw (eh_region);
260
261extern eh_catch gen_eh_region_catch (eh_region, tree);
262extern eh_landing_pad gen_eh_landing_pad (eh_region);
263
264extern eh_region get_eh_region_from_number_fn (struct function *, int);
265extern eh_region get_eh_region_from_number (int);
266extern eh_landing_pad get_eh_landing_pad_from_number_fn (struct function*,int);
267extern eh_landing_pad get_eh_landing_pad_from_number (int);
268extern eh_region get_eh_region_from_lp_number_fn (struct function *, int);
269extern eh_region get_eh_region_from_lp_number (int);
270
271extern eh_region eh_region_outermost (struct function *, eh_region, eh_region);
272
273extern void make_reg_eh_region_note (rtx insn, int ecf_flags, int lp_nr);
274extern void make_reg_eh_region_note_nothrow_nononlocal (rtx);
275
276extern void verify_eh_tree (struct function *);
277extern void dump_eh_tree (FILE *, struct function *);
278void debug_eh_tree (struct function *);
279extern void add_type_for_runtime (tree);
280extern tree lookup_type_for_runtime (tree);
281extern void assign_filter_values (void);
282
283extern eh_region get_eh_region_from_rtx (const_rtx);
284extern eh_landing_pad get_eh_landing_pad_from_rtx (const_rtx);
285
286extern void finish_eh_generation (void);
287
288struct GTY(()) throw_stmt_node {
289  gimple stmt;
290  int lp_nr;
291};
292
293extern hash_map<gimple, int> *get_eh_throw_stmt_table (struct function *);
294extern void set_eh_throw_stmt_table (function *, hash_map<gimple, int> *);
295
296enum eh_personality_kind {
297  eh_personality_none,
298  eh_personality_any,
299  eh_personality_lang
300};
301
302extern enum eh_personality_kind
303function_needs_eh_personality (struct function *);
304
305/* Pre-order iteration within the eh_region tree.  */
306
307static inline eh_region
308ehr_next (eh_region r, eh_region start)
309{
310  if (r->inner)
311    r = r->inner;
312  else if (r->next_peer && r != start)
313    r = r->next_peer;
314  else
315    {
316      do
317	{
318	  r = r->outer;
319	  if (r == start)
320	    return NULL;
321	}
322      while (r->next_peer == NULL);
323      r = r->next_peer;
324    }
325  return r;
326}
327
328#define FOR_ALL_EH_REGION_AT(R, START) \
329  for ((R) = (START); (R) != NULL; (R) = ehr_next (R, START))
330
331#define FOR_ALL_EH_REGION_FN(R, FN) \
332  for ((R) = (FN)->eh->region_tree; (R) != NULL; (R) = ehr_next (R, NULL))
333
334#define FOR_ALL_EH_REGION(R) FOR_ALL_EH_REGION_FN (R, cfun)
335
336#endif
337