gcc/except.h

   1 /* Exception Handling interface routines.
   2    Copyright (C) 1996, 1997 Free Software Foundation, Inc.
   3    Contributed by Mike Stump <mrs@cygnus.com>.
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22
  23 #ifndef GET_CODE
  24 #define rtx int *
  25 #endif
  26
  27 #ifdef TREE_CODE
  28
  29 /* A stack of labels. CHAIN points to the next entry in the stack.  */
  30
  31 struct label_node {
  32   union {
  33     rtx rlabel;
  34     tree tlabel;
  35   } u;
  36   struct label_node *chain;
  37 };
  38
  39 /* An eh_entry is used to describe one exception handling region.
  40
  41    OUTER_CONTEXT is the label used for rethrowing into the outer context.
  42
  43    EXCEPTION_HANDLER_LABEL is the label corresponding to the handler
  44    for this region.
  45
  46    FINALIZATION is the tree codes for the handler, or is NULL_TREE if
  47    one hasn't been generated yet, or is integer_zero_node to mark the
  48    end of a group of try blocks.  */
  49
  50 struct eh_entry {
  51   rtx outer_context;
  52   rtx exception_handler_label;
  53
  54   tree finalization;
  55 };
  56
  57 /* A list of EH_ENTRYs. ENTRY is the entry; CHAIN points to the next
  58    entry in the list, or is NULL if this is the last entry.  */
  59
  60 struct eh_node {
  61   struct eh_entry *entry;
  62   struct eh_node *chain;
  63 };
  64
  65 /* A stack of EH_ENTRYs. TOP is the topmost entry on the stack. TOP is
  66    NULL if the stack is empty.  */
  67
  68 struct eh_stack {
  69   struct eh_node *top;
  70 };
  71
  72 /* A queue of EH_ENTRYs. HEAD is the front of the queue; TAIL is the
  73    end (the latest entry). HEAD and TAIL are NULL if the queue is
  74    empty.  */
  75
  76 struct eh_queue {
  77   struct eh_node *head;
  78   struct eh_node *tail;
  79 };
  80
  81
  82 /* Start an exception handling region.  All instructions emitted after
  83    this point are considered to be part of the region until
  84    expand_eh_region_end () is invoked.  */
  85
  86 extern void expand_eh_region_start              PROTO((void));
  87
  88 /* Just like expand_eh_region_start, except if a cleanup action is
  89    entered on the cleanup chain, the TREE_PURPOSE of the element put
  90    on the chain is DECL.  DECL should be the associated VAR_DECL, if
  91    any, otherwise it should be NULL_TREE.  */
  92
  93 extern void expand_eh_region_start_for_decl     PROTO((tree));
  94
  95 /* Start an exception handling region for the given cleanup action.
  96    All instructions emitted after this point are considered to be part
  97    of the region until expand_eh_region_end () is invoked.  CLEANUP is
  98    the cleanup action to perform.  The return value is true if the
  99    exception region was optimized away.  If that case,
 100    expand_eh_region_end does not need to be called for this cleanup,
 101    nor should it be.
 102
 103    This routine notices one particular common case in C++ code
 104    generation, and optimizes it so as to not need the exception
 105    region.  */
 106
 107 extern int expand_eh_region_start_tree          PROTO((tree, tree));
 108
 109 /* End an exception handling region.  The information about the region
 110    is found on the top of ehstack.
 111
 112    HANDLER is either the cleanup for the exception region, or if we're
 113    marking the end of a try block, HANDLER is integer_zero_node.
 114
 115    HANDLER will be transformed to rtl when expand_leftover_cleanups ()
 116    is invoked.  */
 117
 118 extern void expand_eh_region_end                PROTO((tree));
 119
 120 /* Push RLABEL or TLABEL onto LABELSTACK. Only one of RLABEL or TLABEL
 121    should be set; the other must be NULL.  */
 122
 123 extern void push_label_entry                    PROTO((struct label_node **labelstack, rtx rlabel, tree tlabel));
 124
 125 /* Pop the topmost entry from LABELSTACK and return its value as an
 126    rtx node. If LABELSTACK is empty, return NULL.  */
 127
 128 extern rtx pop_label_entry                      PROTO((struct label_node **labelstack));
 129
 130 /* Return the topmost entry of LABELSTACK as a tree node, or return
 131    NULL_TREE if LABELSTACK is empty.  */
 132
 133 extern tree top_label_entry                     PROTO((struct label_node **labelstack));
 134
 135 /* A set of insns for the catch clauses in the current function. They
 136    will be emitted at the end of the current function.  */
 137
 138 extern rtx catch_clauses;
 139
 140 #endif
 141
 142 /* Toplevel initialization for EH.  */
 143
 144 extern void init_eh                             PROTO((void));
 145
 146 /* Initialization for the per-function EH data.  */
 147
 148 extern void init_eh_for_function                PROTO((void));
 149
 150 /* Adds an EH table entry for EH entry number N. Called from
 151    final_scan_insn for NOTE_INSN_EH_REGION_BEG.  */
 152
 153 extern void add_eh_table_entry                  PROTO((int n));
 154
 155 /* Returns a non-zero value if we need to output an exception table.  */
 156
 157 extern int exception_table_p                    PROTO((void));
 158
 159 /* Outputs the exception table if we have one.  */
 160
 161 extern void output_exception_table              PROTO((void));
 162
 163 /* Given a return address in ADDR, determine the address we should use
 164    to find the corresponding EH region.  */
 165
 166 extern rtx eh_outer_context                     PROTO((rtx addr));
 167
 168 /* Called at the start of a block of try statements for which there is
 169    a supplied catch handler.  */
 170
 171 extern void expand_start_try_stmts              PROTO((void));
 172
 173 /* Called at the start of a block of catch statements. It terminates the
 174    previous set of try statements.  */
 175
 176 extern void expand_start_all_catch              PROTO((void));
 177
 178 /* Called at the end of a block of catch statements.  */
 179
 180 extern void expand_end_all_catch                PROTO((void));
 181
 182 #ifdef TREE_CODE
 183 /* Create a new exception region and add the handler for the region
 184    onto a list. These regions will be ended (and their handlers
 185    emitted) when end_protect_partials is invoked.  */
 186
 187 extern void add_partial_entry                   PROTO((tree handler));
 188 #endif
 189
 190 /* End all of the pending exception regions that have handlers added with
 191    push_protect_entry ().  */
 192
 193 extern void end_protect_partials                PROTO((void));
 194
 195 /* An internal throw.  */
 196
 197 extern void expand_internal_throw               PROTO((void));
 198
 199 /* Called from expand_exception_blocks and expand_end_catch_block to
 200    expand and pending handlers.  */
 201
 202 extern void expand_leftover_cleanups            PROTO((void));
 203
 204 /* If necessary, emit insns to get EH context for the current
 205    function. */
 206
 207 extern void emit_eh_context                     PROTO((void));
 208
 209 /* If necessary, emit insns for the start of per-function unwinder for
 210    the current function.  */
 211
 212 extern void emit_unwinder                       PROTO((void));
 213
 214 /* If necessary, emit insns for the end of the per-function unwinder
 215    for the current function.  */
 216
 217 extern void end_eh_unwinder                     PROTO((void));
 218
 219 /* Builds a list of handler labels and puts them in the global
 220    variable exception_handler_labels.  */
 221
 222 extern void find_exception_handler_labels       PROTO((void));
 223
 224 /* Performs sanity checking on the check_exception_handler_labels
 225    list.  */
 226
 227 extern void check_exception_handler_labels      PROTO((void));
 228
 229 /* A stack used to keep track of the label used to resume normal program
 230    flow out of the current exception handler region.  */
 231
 232 extern struct label_node *caught_return_label_stack;
 233
 234 /* Keeps track of the label used as the context of a throw to rethrow an
 235    exception to the outer exception region.  */
 236
 237 extern struct label_node *outer_context_label_stack;
 238
 239 /* A random area used for purposes elsewhere.  */
 240
 241 extern struct label_node *false_label_stack;
 242
 243 /* A list of labels used for exception handlers. It is created by
 244    find_exception_handler_labels for the optimization passes.  */
 245
 246 extern rtx exception_handler_labels;
 247
 248 /* Performs optimizations for exception handling, such as removing
 249    unnecessary exception regions. Invoked from jump_optimize ().  */
 250
 251 extern void exception_optimize                  PROTO((void));
 252
 253 /* Return EH context (and set it up once per fn).  */
 254 extern rtx get_eh_context                       PROTO((void));
 255
 256 /* Get the dynamic handler chain.  */
 257 extern rtx get_dynamic_handler_chain            PROTO((void));
 258
 259 /* Get the dynamic cleanup chain.  */
 260 extern rtx get_dynamic_cleanup_chain            PROTO((void));
 261
 262 /* Throw an exception.  */
 263
 264 extern void emit_throw                          PROTO((void));
 265
 266 /* One to use setjmp/longjmp method of generating code.  */
 267
 268 extern int exceptions_via_longjmp;
 269
 270 /* One to enable asynchronous exception support.  */
 271
 272 extern int asynchronous_exceptions;
 273
 274 /* One to protect cleanup actions with a handler that calls
 275    __terminate, zero otherwise.  */
 276
 277 extern int protect_cleanup_actions_with_terminate;
 278
 279 #ifdef TREE_CODE
 280 extern tree protect_with_terminate              PROTO((tree));
 281 #endif
 282
 283 /* Various hooks for the DWARF 2 __throw routine.  */
 284
 285 void expand_builtin_unwind_init         PROTO((void));
 286 rtx expand_builtin_dwarf_fp_regnum      PROTO((void));
 287 rtx expand_builtin_eh_stub              PROTO((void));
 288 #ifdef TREE_CODE
 289 rtx expand_builtin_frob_return_addr     PROTO((tree));
 290 rtx expand_builtin_extract_return_addr  PROTO((tree));
 291 void expand_builtin_set_return_addr_reg PROTO((tree));
 292 void expand_builtin_set_eh_regs         PROTO((tree, tree));
 293 rtx expand_builtin_dwarf_reg_size       PROTO((tree, rtx));
 294 #endif
 295
 296
 297 /* Checking whether 2 instructions are within the same exception region. */
 298
 299 int in_same_eh_region                   PROTO((rtx, rtx));
 300 void free_insn_eh_region                PROTO((void));
 301 void init_insn_eh_region                PROTO((rtx, int));