gcc/except.h

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