gcc/except.h

   1 /* Exception Handling interface routines.
   2    Copyright (C) 1996-2015 Free Software Foundation, Inc.
   3    Contributed by Mike Stump <mrs@cygnus.com>.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along 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
  30 struct function;
  31 struct eh_region_d;
  32
  33 /* The type of an exception region.  */
  34 enum 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
  71 struct 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
  97 struct 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
 120 struct 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
 184 typedef struct eh_landing_pad_d *eh_landing_pad;
 185 typedef struct eh_catch_d *eh_catch;
 186 typedef struct eh_region_d *eh_region;
 187
 188
 189
 190
 191 /* The exception status for each function.  */
 192
 193 struct 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.  */
 225 extern void for_each_eh_label (void (*) (rtx));
 226
 227 extern void init_eh_for_function (void);
 228
 229 extern void remove_eh_landing_pad (eh_landing_pad);
 230 extern void remove_eh_handler (eh_region);
 231 extern void remove_unreachable_eh_regions (sbitmap);
 232
 233 extern bool current_function_has_exception_handlers (void);
 234 extern void output_function_exception_table (const char *);
 235
 236 extern rtx expand_builtin_eh_pointer (tree);
 237 extern rtx expand_builtin_eh_filter (tree);
 238 extern rtx expand_builtin_eh_copy_values (tree);
 239 extern void expand_builtin_unwind_init (void);
 240 extern rtx expand_builtin_eh_return_data_regno (tree);
 241 extern rtx expand_builtin_extract_return_addr (tree);
 242 extern void expand_builtin_init_dwarf_reg_sizes (tree);
 243 extern rtx expand_builtin_frob_return_addr (tree);
 244 extern rtx expand_builtin_dwarf_sp_column (void);
 245 extern void expand_builtin_eh_return (tree, tree);
 246 extern void expand_eh_return (void);
 247 extern rtx expand_builtin_extend_pointer (tree);
 248 extern void expand_dw2_landing_pad_for_region (eh_region);
 249
 250 typedef tree (*duplicate_eh_regions_map) (tree, void *);
 251 extern hash_map<void *, void *> *duplicate_eh_regions
 252   (struct function *, eh_region, int, duplicate_eh_regions_map, void *);
 253
 254 extern void sjlj_emit_function_exit_after (rtx_insn *);
 255
 256 extern eh_region gen_eh_region_cleanup (eh_region);
 257 extern eh_region gen_eh_region_try (eh_region);
 258 extern eh_region gen_eh_region_allowed (eh_region, tree);
 259 extern eh_region gen_eh_region_must_not_throw (eh_region);
 260
 261 extern eh_catch gen_eh_region_catch (eh_region, tree);
 262 extern eh_landing_pad gen_eh_landing_pad (eh_region);
 263
 264 extern eh_region get_eh_region_from_number_fn (struct function *, int);
 265 extern eh_region get_eh_region_from_number (int);
 266 extern eh_landing_pad get_eh_landing_pad_from_number_fn (struct function*,int);
 267 extern eh_landing_pad get_eh_landing_pad_from_number (int);
 268 extern eh_region get_eh_region_from_lp_number_fn (struct function *, int);
 269 extern eh_region get_eh_region_from_lp_number (int);
 270
 271 extern eh_region eh_region_outermost (struct function *, eh_region, eh_region);
 272
 273 extern void make_reg_eh_region_note (rtx_insn *insn, int ecf_flags, int lp_nr);
 274 extern void make_reg_eh_region_note_nothrow_nononlocal (rtx_insn *);
 275
 276 extern void verify_eh_tree (struct function *);
 277 extern void dump_eh_tree (FILE *, struct function *);
 278 void debug_eh_tree (struct function *);
 279 extern void add_type_for_runtime (tree);
 280 extern tree lookup_type_for_runtime (tree);
 281 extern void assign_filter_values (void);
 282
 283 extern eh_region get_eh_region_from_rtx (const_rtx);
 284 extern eh_landing_pad get_eh_landing_pad_from_rtx (const_rtx);
 285
 286 extern void finish_eh_generation (void);
 287
 288 struct GTY(()) throw_stmt_node {
 289   gimple stmt;
 290   int lp_nr;
 291 };
 292
 293 extern hash_map<gimple, int> *get_eh_throw_stmt_table (struct function *);
 294 extern void set_eh_throw_stmt_table (function *, hash_map<gimple, int> *);
 295
 296 enum eh_personality_kind {
 297   eh_personality_none,
 298   eh_personality_any,
 299   eh_personality_lang
 300 };
 301
 302 extern enum eh_personality_kind
 303 function_needs_eh_personality (struct function *);
 304
 305 /* Pre-order iteration within the eh_region tree.  */
 306
 307 static inline eh_region
 308 ehr_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