1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
/* Exception Handling interface routines.
Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001
Free Software Foundation, Inc.
Contributed by Mike Stump <mrs@cygnus.com>.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2, or (at your option) any later
version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */
#ifndef GCC_VARRAY_H
struct varray_head_tag;
#define varray_type struct varray_head_tag *
#endif
struct function;
struct inline_remap;
/* Per-function EH data. Used only in except.c, but GC and others
manipulate pointers to the opaque type. */
struct eh_status;
/* Internal structure describing a region. */
struct eh_region;
/* Test: is exception handling turned on? */
extern int doing_eh PARAMS ((int));
/* Start an exception handling region. All instructions emitted after
this point are considered to be part of the region until an
expand_eh_region_end variant is invoked. */
extern void expand_eh_region_start PARAMS ((void));
/* End an exception handling region for a cleanup. HANDLER is an
expression to expand for the cleanup. */
extern void expand_eh_region_end_cleanup PARAMS ((tree));
/* End an exception handling region for a try block, and prepares
for subsequent calls to expand_start_catch. */
extern void expand_start_all_catch PARAMS ((void));
/* Begin a catch clause. TYPE is an object to be matched by the
runtime, or a list of such objects, or null if this is a catch-all
clause. */
extern void expand_start_catch PARAMS ((tree));
/* End a catch clause. Control will resume after the try/catch block. */
extern void expand_end_catch PARAMS ((void));
/* End a sequence of catch handlers for a try block. */
extern void expand_end_all_catch PARAMS ((void));
/* End an exception region for an exception type filter. ALLOWED is a
TREE_LIST of TREE_VALUE objects to be matched by the runtime.
FAILURE is a function to invoke if a mismatch occurs. */
extern void expand_eh_region_end_allowed PARAMS ((tree, tree));
/* End an exception region for a must-not-throw filter. FAILURE is a
function to invoke if an uncaught exception propagates this far. */
extern void expand_eh_region_end_must_not_throw PARAMS ((tree));
/* End an exception region for a throw. No handling goes on here,
but it's the easiest way for the front-end to indicate what type
is being thrown. */
extern void expand_eh_region_end_throw PARAMS ((tree));
/* End a fixup region. Within this region the cleanups for the immediately
enclosing region are _not_ run. This is used for goto cleanup to avoid
destroying an object twice. */
extern void expand_eh_region_end_fixup PARAMS ((tree));
/* Begin a region that will contain entries created with
add_partial_entry. */
extern void begin_protect_partials PARAMS ((void));
/* Create a new exception region and add the handler for the region
onto a list. These regions will be ended (and their handlers emitted)
when end_protect_partials is invoked. */
extern void add_partial_entry PARAMS ((tree));
/* End all of the pending exception regions that have handlers added with
add_partial_entry. */
extern void end_protect_partials PARAMS ((void));
/* A list of labels used for exception handlers. */
extern rtx exception_handler_labels;
/* Determine if the given INSN can throw an exception. */
extern bool can_throw_internal PARAMS ((rtx));
extern bool can_throw_external PARAMS ((rtx));
/* Return nonzero if nothing in this function can throw. */
extern bool nothrow_function_p PARAMS ((void));
/* After initial rtl generation, call back to finish generating
exception support code. */
extern void finish_eh_generation PARAMS ((void));
extern void init_eh PARAMS ((void));
extern void init_eh_for_function PARAMS ((void));
extern rtx reachable_handlers PARAMS ((rtx));
extern void maybe_remove_eh_handler PARAMS ((rtx));
extern void convert_from_eh_region_ranges PARAMS ((void));
extern void convert_to_eh_region_ranges PARAMS ((void));
extern void find_exception_handler_labels PARAMS ((void));
extern void output_function_exception_table PARAMS ((void));
extern void expand_builtin_unwind_init PARAMS ((void));
extern rtx expand_builtin_eh_return_data_regno PARAMS ((tree));
extern rtx expand_builtin_extract_return_addr PARAMS ((tree));
extern void expand_builtin_init_dwarf_reg_sizes PARAMS ((tree));
extern rtx expand_builtin_frob_return_addr PARAMS ((tree));
extern rtx expand_builtin_dwarf_fp_regnum PARAMS ((void));
extern void expand_builtin_eh_return PARAMS ((tree, tree));
extern void expand_eh_return PARAMS ((void));
extern rtx get_exception_pointer PARAMS ((struct function *));
extern int duplicate_eh_regions PARAMS ((struct function *,
struct inline_remap *));
extern void sjlj_emit_function_exit_after PARAMS ((rtx));
/* If non-NULL, this is a function that returns an expression to be
executed if an unhandled exception is propagated out of a cleanup
region. For example, in C++, an exception thrown by a destructor
during stack unwinding is required to result in a call to
`std::terminate', so the C++ version of this function returns a
CALL_EXPR for `std::terminate'. */
extern tree (*lang_protect_cleanup_actions) PARAMS ((void));
/* Return true if type A catches type B. */
extern int (*lang_eh_type_covers) PARAMS ((tree a, tree b));
/* Map a type to a runtime object to match type. */
extern tree (*lang_eh_runtime_type) PARAMS ((tree));
#ifndef GCC_VARRAY_H
#undef varray_type
#endif
/* Just because the user configured --with-sjlj-exceptions=no doesn't
mean that we can use call frame exceptions. Detect that the target
has appropriate support. */
#if ! (defined (EH_RETURN_DATA_REGNO) \
&& (defined (IA64_UNWIND_INFO) \
|| (DWARF2_UNWIND_INFO \
&& defined (EH_RETURN_STACKADJ_RTX) \
&& (defined (EH_RETURN_HANDLER_RTX) \
|| defined (HAVE_eh_return)))))
#define MUST_USE_SJLJ_EXCEPTIONS 1
#else
#define MUST_USE_SJLJ_EXCEPTIONS 0
#endif
#ifdef CONFIG_SJLJ_EXCEPTIONS
# if CONFIG_SJLJ_EXCEPTIONS == 1
# define USING_SJLJ_EXCEPTIONS 1
# endif
# if CONFIG_SJLJ_EXCEPTIONS == 0
# define USING_SJLJ_EXCEPTIONS 0
# ifndef EH_RETURN_DATA_REGNO
#error "EH_RETURN_DATA_REGNO required"
# endif
# ifndef EH_RETURN_STACKADJ_RTX
#error "EH_RETURN_STACKADJ_RTX required"
# endif
# if !defined(EH_RETURN_HANDLER_RTX) && !defined(HAVE_eh_return)
#error "EH_RETURN_HANDLER_RTX or eh_return required"
# endif
# if !defined(DWARF2_UNWIND_INFO) && !defined(IA64_UNWIND_INFO)
#error "{DWARF2,IA64}_UNWIND_INFO required"
# endif
# endif
#else
# define USING_SJLJ_EXCEPTIONS MUST_USE_SJLJ_EXCEPTIONS
#endif
|
