OSDN Git Service

75bbd6f9c3886b8daaf675c13ee8a0e8f93b53b4
[pf3gnuchains/gcc-fork.git] / gcc / except.h
1 /* Exception Handling interface routines.
2    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3    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 2, 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 COPYING.  If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
21 02111-1307, USA.  */
22
23
24 struct function;
25
26 struct inline_remap;
27
28 /* Per-function EH data.  Used only in except.c, but GC and others
29    manipulate pointers to the opaque type.  */
30 struct eh_status;
31
32 /* Internal structure describing a region.  */
33 struct eh_region;
34
35 /* Test: is exception handling turned on?  */
36 extern int doing_eh (int);
37
38 /* Start an exception handling region.  All instructions emitted after
39    this point are considered to be part of the region until an
40    expand_eh_region_end variant is invoked.  */
41 extern void expand_eh_region_start (void);
42
43 /* End an exception handling region for a cleanup.  HANDLER is an
44    expression to expand for the cleanup.  */
45 extern void expand_eh_region_end_cleanup (tree);
46
47 /* End an exception handling region for a try block, and prepares
48    for subsequent calls to expand_start_catch.  */
49 extern void expand_start_all_catch (void);
50
51 /* Begin a catch clause.  TYPE is an object to be matched by the
52    runtime, or a list of such objects, or null if this is a catch-all
53    clause.  */
54 extern void expand_start_catch (tree);
55
56 /* End a catch clause.  Control will resume after the try/catch block.  */
57 extern void expand_end_catch (void);
58
59 /* End a sequence of catch handlers for a try block.  */
60 extern void expand_end_all_catch (void);
61
62 /* End an exception region for an exception type filter.  ALLOWED is a
63    TREE_LIST of TREE_VALUE objects to be matched by the runtime.
64    FAILURE is a function to invoke if a mismatch occurs.  */
65 extern void expand_eh_region_end_allowed (tree, tree);
66
67 /* End an exception region for a must-not-throw filter.  FAILURE is a
68    function to invoke if an uncaught exception propagates this far.  */
69 extern void expand_eh_region_end_must_not_throw (tree);
70
71 /* End an exception region for a throw.  No handling goes on here,
72    but it's the easiest way for the front-end to indicate what type
73    is being thrown.  */
74 extern void expand_eh_region_end_throw (tree);
75
76 /* End a fixup region.  Within this region the cleanups for the immediately
77    enclosing region are _not_ run.  This is used for goto cleanup to avoid
78    destroying an object twice.  */
79 extern void expand_eh_region_end_fixup (tree);
80
81 /* Note that the current EH region (if any) may contain a throw, or a
82    call to a function which itself may contain a throw.  */
83 extern void note_eh_region_may_contain_throw (void);
84
85 /* Invokes CALLBACK for every exception handler label.  Only used by old
86    loop hackery; should not be used by new code.  */
87 extern void for_each_eh_label (void (*) (rtx));
88
89 /* Determine if the given INSN can throw an exception.  */
90 extern bool can_throw_internal (rtx);
91 extern bool can_throw_external (rtx);
92
93 /* Set current_function_nothrow and cfun->all_throwers_are_sibcalls.  */
94 extern void set_nothrow_function_flags (void);
95
96 /* After initial rtl generation, call back to finish generating
97    exception support code.  */
98 extern void finish_eh_generation (void);
99
100 extern void init_eh (void);
101 extern void init_eh_for_function (void);
102
103 extern rtx reachable_handlers (rtx);
104 extern void maybe_remove_eh_handler (rtx);
105
106 extern void convert_from_eh_region_ranges (void);
107 extern void convert_to_eh_region_ranges (void);
108 extern void find_exception_handler_labels (void);
109 extern bool current_function_has_exception_handlers (void);
110 extern void output_function_exception_table (void);
111
112 extern void expand_builtin_unwind_init (void);
113 extern rtx expand_builtin_eh_return_data_regno (tree);
114 extern rtx expand_builtin_extract_return_addr (tree);
115 extern void expand_builtin_init_dwarf_reg_sizes (tree);
116 extern rtx expand_builtin_frob_return_addr (tree);
117 extern rtx expand_builtin_dwarf_sp_column (void);
118 extern void expand_builtin_eh_return (tree, tree);
119 extern void expand_eh_return (void);
120 extern rtx get_exception_pointer (struct function *);
121 extern int duplicate_eh_regions (struct function *, struct inline_remap *);
122
123 extern void sjlj_emit_function_exit_after (rtx);
124
125
126 /* If non-NULL, this is a function that returns an expression to be
127    executed if an unhandled exception is propagated out of a cleanup
128    region.  For example, in C++, an exception thrown by a destructor
129    during stack unwinding is required to result in a call to
130    `std::terminate', so the C++ version of this function returns a
131    CALL_EXPR for `std::terminate'.  */
132 extern tree (*lang_protect_cleanup_actions) (void);
133
134 /* Return true if type A catches type B.  */
135 extern int (*lang_eh_type_covers) (tree a, tree b);
136
137 /* Map a type to a runtime object to match type.  */
138 extern tree (*lang_eh_runtime_type) (tree);
139
140
141 /* Just because the user configured --with-sjlj-exceptions=no doesn't
142    mean that we can use call frame exceptions.  Detect that the target
143    has appropriate support.  */
144
145 #ifndef MUST_USE_SJLJ_EXCEPTIONS
146 # if !(defined (EH_RETURN_DATA_REGNO)                   \
147        && (defined (IA64_UNWIND_INFO)                   \
148            || (DWARF2_UNWIND_INFO                       \
149                && (defined (EH_RETURN_HANDLER_RTX)      \
150                    || defined (HAVE_eh_return)))))
151 #  define MUST_USE_SJLJ_EXCEPTIONS      1
152 # else
153 #  define MUST_USE_SJLJ_EXCEPTIONS      0
154 # endif
155 #endif
156
157 #ifdef CONFIG_SJLJ_EXCEPTIONS
158 # if CONFIG_SJLJ_EXCEPTIONS == 1
159 #  define USING_SJLJ_EXCEPTIONS         1
160 # endif
161 # if CONFIG_SJLJ_EXCEPTIONS == 0
162 #  define USING_SJLJ_EXCEPTIONS         0
163 #  ifndef EH_RETURN_DATA_REGNO
164     #error "EH_RETURN_DATA_REGNO required"
165 #  endif
166 #  if !defined(EH_RETURN_HANDLER_RTX) && !defined(HAVE_eh_return)
167     #error "EH_RETURN_HANDLER_RTX or eh_return required"
168 #  endif
169 #  if !defined(DWARF2_UNWIND_INFO) && !defined(IA64_UNWIND_INFO)
170     #error "{DWARF2,IA64}_UNWIND_INFO required"
171 #  endif
172 # endif
173 #else
174 # define USING_SJLJ_EXCEPTIONS          MUST_USE_SJLJ_EXCEPTIONS
175 #endif