1 /* Implements exception handling.
2 Copyright (C) 1989, 1992-1999, 2000 Free Software Foundation, Inc.
3 Contributed by Mike Stump <mrs@cygnus.com>.
5 This file is part of GNU CC.
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)
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.
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. */
23 /* An exception is an event that can be signaled from within a
24 function. This event can then be "caught" or "trapped" by the
25 callers of this function. This potentially allows program flow to
26 be transferred to any arbitrary code associated with a function call
27 several levels up the stack.
29 The intended use for this mechanism is for signaling "exceptional
30 events" in an out-of-band fashion, hence its name. The C++ language
31 (and many other OO-styled or functional languages) practically
32 requires such a mechanism, as otherwise it becomes very difficult
33 or even impossible to signal failure conditions in complex
34 situations. The traditional C++ example is when an error occurs in
35 the process of constructing an object; without such a mechanism, it
36 is impossible to signal that the error occurs without adding global
37 state variables and error checks around every object construction.
39 The act of causing this event to occur is referred to as "throwing
40 an exception". (Alternate terms include "raising an exception" or
41 "signaling an exception".) The term "throw" is used because control
42 is returned to the callers of the function that is signaling the
43 exception, and thus there is the concept of "throwing" the
44 exception up the call stack.
46 There are two major codegen options for exception handling. The
47 flag -fsjlj-exceptions can be used to select the setjmp/longjmp
48 approach, which is the default. -fno-sjlj-exceptions can be used to
49 get the PC range table approach. While this is a compile time
50 flag, an entire application must be compiled with the same codegen
51 option. The first is a PC range table approach, the second is a
52 setjmp/longjmp based scheme. We will first discuss the PC range
53 table approach, after that, we will discuss the setjmp/longjmp
56 It is appropriate to speak of the "context of a throw". This
57 context refers to the address where the exception is thrown from,
58 and is used to determine which exception region will handle the
61 Regions of code within a function can be marked such that if it
62 contains the context of a throw, control will be passed to a
63 designated "exception handler". These areas are known as "exception
64 regions". Exception regions cannot overlap, but they can be nested
65 to any arbitrary depth. Also, exception regions cannot cross
68 Exception handlers can either be specified by the user (which we
69 will call a "user-defined handler") or generated by the compiler
70 (which we will designate as a "cleanup"). Cleanups are used to
71 perform tasks such as destruction of objects allocated on the
74 In the current implementation, cleanups are handled by allocating an
75 exception region for the area that the cleanup is designated for,
76 and the handler for the region performs the cleanup and then
77 rethrows the exception to the outer exception region. From the
78 standpoint of the current implementation, there is little
79 distinction made between a cleanup and a user-defined handler, and
80 the phrase "exception handler" can be used to refer to either one
81 equally well. (The section "Future Directions" below discusses how
84 Each object file that is compiled with exception handling contains
85 a static array of exception handlers named __EXCEPTION_TABLE__.
86 Each entry contains the starting and ending addresses of the
87 exception region, and the address of the handler designated for
90 If the target does not use the DWARF 2 frame unwind information, at
91 program startup each object file invokes a function named
92 __register_exceptions with the address of its local
93 __EXCEPTION_TABLE__. __register_exceptions is defined in libgcc2.c, and
94 is responsible for recording all of the exception regions into one list
95 (which is kept in a static variable named exception_table_list).
97 On targets that support crtstuff.c, the unwind information
98 is stored in a section named .eh_frame and the information for the
99 entire shared object or program is registered with a call to
100 __register_frame_info. On other targets, the information for each
101 translation unit is registered from the file generated by collect2.
102 __register_frame_info is defined in frame.c, and is responsible for
103 recording all of the unwind regions into one list (which is kept in a
104 static variable named unwind_table_list).
106 The function __throw is actually responsible for doing the
107 throw. On machines that have unwind info support, __throw is generated
108 by code in libgcc2.c, otherwise __throw is generated on a
109 per-object-file basis for each source file compiled with
110 -fexceptions by the C++ frontend. Before __throw is invoked,
111 the current context of the throw needs to be placed in the global
114 __throw attempts to find the appropriate exception handler for the
115 PC value stored in __eh_pc by calling __find_first_exception_table_match
116 (which is defined in libgcc2.c). If __find_first_exception_table_match
117 finds a relevant handler, __throw transfers control directly to it.
119 If a handler for the context being thrown from can't be found, __throw
120 walks (see Walking the stack below) the stack up the dynamic call chain to
121 continue searching for an appropriate exception handler based upon the
122 caller of the function it last sought a exception handler for. It stops
123 then either an exception handler is found, or when the top of the
124 call chain is reached.
126 If no handler is found, an external library function named
127 __terminate is called. If a handler is found, then we restart
128 our search for a handler at the end of the call chain, and repeat
129 the search process, but instead of just walking up the call chain,
130 we unwind the call chain as we walk up it.
132 Internal implementation details:
134 To associate a user-defined handler with a block of statements, the
135 function expand_start_try_stmts is used to mark the start of the
136 block of statements with which the handler is to be associated
137 (which is known as a "try block"). All statements that appear
138 afterwards will be associated with the try block.
140 A call to expand_start_all_catch marks the end of the try block,
141 and also marks the start of the "catch block" (the user-defined
142 handler) associated with the try block.
144 This user-defined handler will be invoked for *every* exception
145 thrown with the context of the try block. It is up to the handler
146 to decide whether or not it wishes to handle any given exception,
147 as there is currently no mechanism in this implementation for doing
148 this. (There are plans for conditionally processing an exception
149 based on its "type", which will provide a language-independent
152 If the handler chooses not to process the exception (perhaps by
153 looking at an "exception type" or some other additional data
154 supplied with the exception), it can fall through to the end of the
155 handler. expand_end_all_catch and expand_leftover_cleanups
156 add additional code to the end of each handler to take care of
157 rethrowing to the outer exception handler.
159 The handler also has the option to continue with "normal flow of
160 code", or in other words to resume executing at the statement
161 immediately after the end of the exception region. The variable
162 caught_return_label_stack contains a stack of labels, and jumping
163 to the topmost entry's label via expand_goto will resume normal
164 flow to the statement immediately after the end of the exception
165 region. If the handler falls through to the end, the exception will
166 be rethrown to the outer exception region.
168 The instructions for the catch block are kept as a separate
169 sequence, and will be emitted at the end of the function along with
170 the handlers specified via expand_eh_region_end. The end of the
171 catch block is marked with expand_end_all_catch.
173 Any data associated with the exception must currently be handled by
174 some external mechanism maintained in the frontend. For example,
175 the C++ exception mechanism passes an arbitrary value along with
176 the exception, and this is handled in the C++ frontend by using a
177 global variable to hold the value. (This will be changing in the
180 The mechanism in C++ for handling data associated with the
181 exception is clearly not thread-safe. For a thread-based
182 environment, another mechanism must be used (possibly using a
183 per-thread allocation mechanism if the size of the area that needs
184 to be allocated isn't known at compile time.)
186 Internally-generated exception regions (cleanups) are marked by
187 calling expand_eh_region_start to mark the start of the region,
188 and expand_eh_region_end (handler) is used to both designate the
189 end of the region and to associate a specified handler/cleanup with
190 the region. The rtl code in HANDLER will be invoked whenever an
191 exception occurs in the region between the calls to
192 expand_eh_region_start and expand_eh_region_end. After HANDLER is
193 executed, additional code is emitted to handle rethrowing the
194 exception to the outer exception handler. The code for HANDLER will
195 be emitted at the end of the function.
197 TARGET_EXPRs can also be used to designate exception regions. A
198 TARGET_EXPR gives an unwind-protect style interface commonly used
199 in functional languages such as LISP. The associated expression is
200 evaluated, and whether or not it (or any of the functions that it
201 calls) throws an exception, the protect expression is always
202 invoked. This implementation takes care of the details of
203 associating an exception table entry with the expression and
204 generating the necessary code (it actually emits the protect
205 expression twice, once for normal flow and once for the exception
206 case). As for the other handlers, the code for the exception case
207 will be emitted at the end of the function.
209 Cleanups can also be specified by using add_partial_entry (handler)
210 and end_protect_partials. add_partial_entry creates the start of
211 a new exception region; HANDLER will be invoked if an exception is
212 thrown with the context of the region between the calls to
213 add_partial_entry and end_protect_partials. end_protect_partials is
214 used to mark the end of these regions. add_partial_entry can be
215 called as many times as needed before calling end_protect_partials.
216 However, end_protect_partials should only be invoked once for each
217 group of calls to add_partial_entry as the entries are queued
218 and all of the outstanding entries are processed simultaneously
219 when end_protect_partials is invoked. Similarly to the other
220 handlers, the code for HANDLER will be emitted at the end of the
223 The generated RTL for an exception region includes
224 NOTE_INSN_EH_REGION_BEG and NOTE_INSN_EH_REGION_END notes that mark
225 the start and end of the exception region. A unique label is also
226 generated at the start of the exception region, which is available
227 by looking at the ehstack variable. The topmost entry corresponds
228 to the current region.
230 In the current implementation, an exception can only be thrown from
231 a function call (since the mechanism used to actually throw an
232 exception involves calling __throw). If an exception region is
233 created but no function calls occur within that region, the region
234 can be safely optimized away (along with its exception handlers)
235 since no exceptions can ever be caught in that region. This
236 optimization is performed unless -fasynchronous-exceptions is
237 given. If the user wishes to throw from a signal handler, or other
238 asynchronous place, -fasynchronous-exceptions should be used when
239 compiling for maximally correct code, at the cost of additional
240 exception regions. Using -fasynchronous-exceptions only produces
241 code that is reasonably safe in such situations, but a correct
242 program cannot rely upon this working. It can be used in failsafe
243 code, where trying to continue on, and proceeding with potentially
244 incorrect results is better than halting the program.
249 The stack is walked by starting with a pointer to the current
250 frame, and finding the pointer to the callers frame. The unwind info
251 tells __throw how to find it.
255 When we use the term unwinding the stack, we mean undoing the
256 effects of the function prologue in a controlled fashion so that we
257 still have the flow of control. Otherwise, we could just return
258 (jump to the normal end of function epilogue).
260 This is done in __throw in libgcc2.c when we know that a handler exists
261 in a frame higher up the call stack than its immediate caller.
263 To unwind, we find the unwind data associated with the frame, if any.
264 If we don't find any, we call the library routine __terminate. If we do
265 find it, we use the information to copy the saved register values from
266 that frame into the register save area in the frame for __throw, return
267 into a stub which updates the stack pointer, and jump to the handler.
268 The normal function epilogue for __throw handles restoring the saved
269 values into registers.
271 When unwinding, we use this method if we know it will
272 work (if DWARF2_UNWIND_INFO is defined). Otherwise, we know that
273 an inline unwinder will have been emitted for any function that
274 __unwind_function cannot unwind. The inline unwinder appears as a
275 normal exception handler for the entire function, for any function
276 that we know cannot be unwound by __unwind_function. We inform the
277 compiler of whether a function can be unwound with
278 __unwind_function by having DOESNT_NEED_UNWINDER evaluate to true
279 when the unwinder isn't needed. __unwind_function is used as an
280 action of last resort. If no other method can be used for
281 unwinding, __unwind_function is used. If it cannot unwind, it
282 should call __terminate.
284 By default, if the target-specific backend doesn't supply a definition
285 for __unwind_function and doesn't support DWARF2_UNWIND_INFO, inlined
286 unwinders will be used instead. The main tradeoff here is in text space
287 utilization. Obviously, if inline unwinders have to be generated
288 repeatedly, this uses much more space than if a single routine is used.
290 However, it is simply not possible on some platforms to write a
291 generalized routine for doing stack unwinding without having some
292 form of additional data associated with each function. The current
293 implementation can encode this data in the form of additional
294 machine instructions or as static data in tabular form. The later
295 is called the unwind data.
297 The backend macro DOESNT_NEED_UNWINDER is used to conditionalize whether
298 or not per-function unwinders are needed. If DOESNT_NEED_UNWINDER is
299 defined and has a non-zero value, a per-function unwinder is not emitted
300 for the current function. If the static unwind data is supported, then
301 a per-function unwinder is not emitted.
303 On some platforms it is possible that neither __unwind_function
304 nor inlined unwinders are available. For these platforms it is not
305 possible to throw through a function call, and abort will be
306 invoked instead of performing the throw.
308 The reason the unwind data may be needed is that on some platforms
309 the order and types of data stored on the stack can vary depending
310 on the type of function, its arguments and returned values, and the
311 compilation options used (optimization versus non-optimization,
312 -fomit-frame-pointer, processor variations, etc).
314 Unfortunately, this also means that throwing through functions that
315 aren't compiled with exception handling support will still not be
316 possible on some platforms. This problem is currently being
317 investigated, but no solutions have been found that do not imply
318 some unacceptable performance penalties.
322 Currently __throw makes no differentiation between cleanups and
323 user-defined exception regions. While this makes the implementation
324 simple, it also implies that it is impossible to determine if a
325 user-defined exception handler exists for a given exception without
326 completely unwinding the stack in the process. This is undesirable
327 from the standpoint of debugging, as ideally it would be possible
328 to trap unhandled exceptions in the debugger before the process of
329 unwinding has even started.
331 This problem can be solved by marking user-defined handlers in a
332 special way (probably by adding additional bits to exception_table_list).
333 A two-pass scheme could then be used by __throw to iterate
334 through the table. The first pass would search for a relevant
335 user-defined handler for the current context of the throw, and if
336 one is found, the second pass would then invoke all needed cleanups
337 before jumping to the user-defined handler.
339 Many languages (including C++ and Ada) make execution of a
340 user-defined handler conditional on the "type" of the exception
341 thrown. (The type of the exception is actually the type of the data
342 that is thrown with the exception.) It will thus be necessary for
343 __throw to be able to determine if a given user-defined
344 exception handler will actually be executed, given the type of
347 One scheme is to add additional information to exception_table_list
348 as to the types of exceptions accepted by each handler. __throw
349 can do the type comparisons and then determine if the handler is
350 actually going to be executed.
352 There is currently no significant level of debugging support
353 available, other than to place a breakpoint on __throw. While
354 this is sufficient in most cases, it would be helpful to be able to
355 know where a given exception was going to be thrown to before it is
356 actually thrown, and to be able to choose between stopping before
357 every exception region (including cleanups), or just user-defined
358 exception regions. This should be possible to do in the two-pass
359 scheme by adding additional labels to __throw for appropriate
360 breakpoints, and additional debugger commands could be added to
361 query various state variables to determine what actions are to be
364 Another major problem that is being worked on is the issue with stack
365 unwinding on various platforms. Currently the only platforms that have
366 support for the generation of a generic unwinder are the SPARC and MIPS.
367 All other ports require per-function unwinders, which produce large
368 amounts of code bloat.
370 For setjmp/longjmp based exception handling, some of the details
371 are as above, but there are some additional details. This section
372 discusses the details.
374 We don't use NOTE_INSN_EH_REGION_{BEG,END} pairs. We don't
375 optimize EH regions yet. We don't have to worry about machine
376 specific issues with unwinding the stack, as we rely upon longjmp
377 for all the machine specific details. There is no variable context
378 of a throw, just the one implied by the dynamic handler stack
379 pointed to by the dynamic handler chain. There is no exception
380 table, and no calls to __register_exceptions. __sjthrow is used
381 instead of __throw, and it works by using the dynamic handler
382 chain, and longjmp. -fasynchronous-exceptions has no effect, as
383 the elimination of trivial exception regions is not yet performed.
385 A frontend can set protect_cleanup_actions_with_terminate when all
386 the cleanup actions should be protected with an EH region that
387 calls terminate when an unhandled exception is throw. C++ does
388 this, Ada does not. */
392 #include "defaults.h"
393 #include "eh-common.h"
399 #include "function.h"
400 #include "insn-flags.h"
402 #include "insn-codes.h"
404 #include "hard-reg-set.h"
405 #include "insn-config.h"
414 /* One to use setjmp/longjmp method of generating code for exception
417 int exceptions_via_longjmp = 2;
419 /* One to enable asynchronous exception support. */
421 int asynchronous_exceptions = 0;
423 /* One to protect cleanup actions with a handler that calls
424 __terminate, zero otherwise. */
426 int protect_cleanup_actions_with_terminate;
428 /* A list of labels used for exception handlers. Created by
429 find_exception_handler_labels for the optimization passes. */
431 rtx exception_handler_labels;
433 /* Keeps track of the label used as the context of a throw to rethrow an
434 exception to the outer exception region. */
436 struct label_node *outer_context_label_stack = NULL;
438 /* Pseudos used to hold exception return data in the interim between
439 __builtin_eh_return and the end of the function. */
441 static rtx eh_return_context;
442 static rtx eh_return_stack_adjust;
443 static rtx eh_return_handler;
445 /* This is used for targets which can call rethrow with an offset instead
446 of an address. This is subtracted from the rethrow label we are
449 static rtx first_rethrow_symbol = NULL_RTX;
450 static rtx final_rethrow = NULL_RTX;
451 static rtx last_rethrow_symbol = NULL_RTX;
454 /* Prototypes for local functions. */
456 static void push_eh_entry PARAMS ((struct eh_stack *));
457 static struct eh_entry * pop_eh_entry PARAMS ((struct eh_stack *));
458 static void enqueue_eh_entry PARAMS ((struct eh_queue *, struct eh_entry *));
459 static struct eh_entry * dequeue_eh_entry PARAMS ((struct eh_queue *));
460 static rtx call_get_eh_context PARAMS ((void));
461 static void start_dynamic_cleanup PARAMS ((tree, tree));
462 static void start_dynamic_handler PARAMS ((void));
463 static void expand_rethrow PARAMS ((rtx));
464 static void output_exception_table_entry PARAMS ((FILE *, int));
465 static int can_throw PARAMS ((rtx));
466 static rtx scan_region PARAMS ((rtx, int, int *));
467 static void eh_regs PARAMS ((rtx *, rtx *, rtx *, int));
468 static void set_insn_eh_region PARAMS ((rtx *, int));
469 #ifdef DONT_USE_BUILTIN_SETJMP
470 static void jumpif_rtx PARAMS ((rtx, rtx));
472 static void mark_eh_node PARAMS ((struct eh_node *));
473 static void mark_eh_stack PARAMS ((struct eh_stack *));
474 static void mark_eh_queue PARAMS ((struct eh_queue *));
475 static void mark_tree_label_node PARAMS ((struct label_node *));
476 static void mark_func_eh_entry PARAMS ((void *));
477 static rtx create_rethrow_ref PARAMS ((int));
478 static void push_entry PARAMS ((struct eh_stack *, struct eh_entry*));
479 static void receive_exception_label PARAMS ((rtx));
480 static int new_eh_region_entry PARAMS ((int, rtx));
481 static int find_func_region PARAMS ((int));
482 static int find_func_region_from_symbol PARAMS ((rtx));
483 static void clear_function_eh_region PARAMS ((void));
484 static void process_nestinfo PARAMS ((int, eh_nesting_info *, int *));
486 rtx expand_builtin_return_addr PARAMS ((enum built_in_function, int, rtx));
487 static void emit_cleanup_handler PARAMS ((struct eh_entry *));
488 static int eh_region_from_symbol PARAMS ((rtx));
491 /* Various support routines to manipulate the various data structures
492 used by the exception handling code. */
494 extern struct obstack permanent_obstack;
496 /* Generate a SYMBOL_REF for rethrow to use */
498 create_rethrow_ref (region_num)
505 push_obstacks_nochange ();
506 end_temporary_allocation ();
508 ASM_GENERATE_INTERNAL_LABEL (buf, "LRTH", region_num);
509 ptr = ggc_alloc_string (buf, -1);
510 def = gen_rtx_SYMBOL_REF (Pmode, ptr);
511 SYMBOL_REF_NEED_ADJUST (def) = 1;
517 /* Push a label entry onto the given STACK. */
520 push_label_entry (stack, rlabel, tlabel)
521 struct label_node **stack;
525 struct label_node *newnode
526 = (struct label_node *) xmalloc (sizeof (struct label_node));
529 newnode->u.rlabel = rlabel;
531 newnode->u.tlabel = tlabel;
532 newnode->chain = *stack;
536 /* Pop a label entry from the given STACK. */
539 pop_label_entry (stack)
540 struct label_node **stack;
543 struct label_node *tempnode;
549 label = tempnode->u.rlabel;
550 *stack = (*stack)->chain;
556 /* Return the top element of the given STACK. */
559 top_label_entry (stack)
560 struct label_node **stack;
565 return (*stack)->u.tlabel;
568 /* get an exception label. These must be on the permanent obstack */
571 gen_exception_label ()
574 lab = gen_label_rtx ();
578 /* Push a new eh_node entry onto STACK. */
581 push_eh_entry (stack)
582 struct eh_stack *stack;
584 struct eh_node *node = (struct eh_node *) xmalloc (sizeof (struct eh_node));
585 struct eh_entry *entry = (struct eh_entry *) xmalloc (sizeof (struct eh_entry));
587 rtx rlab = gen_exception_label ();
588 entry->finalization = NULL_TREE;
589 entry->label_used = 0;
590 entry->exception_handler_label = rlab;
591 entry->false_label = NULL_RTX;
592 if (! flag_new_exceptions)
593 entry->outer_context = gen_label_rtx ();
595 entry->outer_context = create_rethrow_ref (CODE_LABEL_NUMBER (rlab));
596 entry->rethrow_label = entry->outer_context;
597 entry->goto_entry_p = 0;
600 node->chain = stack->top;
604 /* push an existing entry onto a stack. */
606 push_entry (stack, entry)
607 struct eh_stack *stack;
608 struct eh_entry *entry;
610 struct eh_node *node = (struct eh_node *) xmalloc (sizeof (struct eh_node));
612 node->chain = stack->top;
616 /* Pop an entry from the given STACK. */
618 static struct eh_entry *
620 struct eh_stack *stack;
622 struct eh_node *tempnode;
623 struct eh_entry *tempentry;
625 tempnode = stack->top;
626 tempentry = tempnode->entry;
627 stack->top = stack->top->chain;
633 /* Enqueue an ENTRY onto the given QUEUE. */
636 enqueue_eh_entry (queue, entry)
637 struct eh_queue *queue;
638 struct eh_entry *entry;
640 struct eh_node *node = (struct eh_node *) xmalloc (sizeof (struct eh_node));
645 if (queue->head == NULL)
648 queue->tail->chain = node;
652 /* Dequeue an entry from the given QUEUE. */
654 static struct eh_entry *
655 dequeue_eh_entry (queue)
656 struct eh_queue *queue;
658 struct eh_node *tempnode;
659 struct eh_entry *tempentry;
661 if (queue->head == NULL)
664 tempnode = queue->head;
665 queue->head = queue->head->chain;
667 tempentry = tempnode->entry;
674 receive_exception_label (handler_label)
677 emit_label (handler_label);
679 #ifdef HAVE_exception_receiver
680 if (! exceptions_via_longjmp)
681 if (HAVE_exception_receiver)
682 emit_insn (gen_exception_receiver ());
685 #ifdef HAVE_nonlocal_goto_receiver
686 if (! exceptions_via_longjmp)
687 if (HAVE_nonlocal_goto_receiver)
688 emit_insn (gen_nonlocal_goto_receiver ());
695 int range_number; /* EH region number from EH NOTE insn's. */
696 rtx rethrow_label; /* Label for rethrow. */
697 int rethrow_ref; /* Is rethrow referenced? */
698 struct handler_info *handlers;
702 /* table of function eh regions */
703 static struct func_eh_entry *function_eh_regions = NULL;
704 static int num_func_eh_entries = 0;
705 static int current_func_eh_entry = 0;
707 #define SIZE_FUNC_EH(X) (sizeof (struct func_eh_entry) * X)
709 /* Add a new eh_entry for this function. The number returned is an
710 number which uniquely identifies this exception range. */
713 new_eh_region_entry (note_eh_region, rethrow)
717 if (current_func_eh_entry == num_func_eh_entries)
719 if (num_func_eh_entries == 0)
721 function_eh_regions =
722 (struct func_eh_entry *) xmalloc (SIZE_FUNC_EH (50));
723 num_func_eh_entries = 50;
727 num_func_eh_entries = num_func_eh_entries * 3 / 2;
728 function_eh_regions = (struct func_eh_entry *)
729 xrealloc (function_eh_regions, SIZE_FUNC_EH (num_func_eh_entries));
732 function_eh_regions[current_func_eh_entry].range_number = note_eh_region;
733 if (rethrow == NULL_RTX)
734 function_eh_regions[current_func_eh_entry].rethrow_label =
735 create_rethrow_ref (note_eh_region);
737 function_eh_regions[current_func_eh_entry].rethrow_label = rethrow;
738 function_eh_regions[current_func_eh_entry].handlers = NULL;
740 return current_func_eh_entry++;
743 /* Add new handler information to an exception range. The first parameter
744 specifies the range number (returned from new_eh_entry()). The second
745 parameter specifies the handler. By default the handler is inserted at
746 the end of the list. A handler list may contain only ONE NULL_TREE
747 typeinfo entry. Regardless where it is positioned, a NULL_TREE entry
748 is always output as the LAST handler in the exception table for a region. */
751 add_new_handler (region, newhandler)
753 struct handler_info *newhandler;
755 struct handler_info *last;
757 /* If find_func_region returns -1, callers might attempt to pass us
758 this region number. If that happens, something has gone wrong;
759 -1 is never a valid region. */
763 newhandler->next = NULL;
764 last = function_eh_regions[region].handlers;
766 function_eh_regions[region].handlers = newhandler;
769 for ( ; ; last = last->next)
771 if (last->type_info == CATCH_ALL_TYPE)
772 pedwarn ("additional handler after ...");
773 if (last->next == NULL)
776 last->next = newhandler;
780 /* Remove a handler label. The handler label is being deleted, so all
781 regions which reference this handler should have it removed from their
782 list of possible handlers. Any region which has the final handler
783 removed can be deleted. */
785 void remove_handler (removing_label)
788 struct handler_info *handler, *last;
790 for (x = 0 ; x < current_func_eh_entry; ++x)
793 handler = function_eh_regions[x].handlers;
794 for ( ; handler; last = handler, handler = handler->next)
795 if (handler->handler_label == removing_label)
799 last->next = handler->next;
803 function_eh_regions[x].handlers = handler->next;
808 /* This function will return a malloc'd pointer to an array of
809 void pointer representing the runtime match values that
810 currently exist in all regions. */
813 find_all_handler_type_matches (array)
816 struct handler_info *handler, *last;
825 if (!doing_eh (0) || ! flag_new_exceptions)
829 ptr = (void **) xmalloc (max_ptr * sizeof (void *));
831 for (x = 0 ; x < current_func_eh_entry; x++)
834 handler = function_eh_regions[x].handlers;
835 for ( ; handler; last = handler, handler = handler->next)
837 val = handler->type_info;
838 if (val != NULL && val != CATCH_ALL_TYPE)
840 /* See if this match value has already been found. */
841 for (y = 0; y < n_ptr; y++)
845 /* If we break early, we already found this value. */
849 /* Do we need to allocate more space? */
850 if (n_ptr >= max_ptr)
852 max_ptr += max_ptr / 2;
853 ptr = (void **) xrealloc (ptr, max_ptr * sizeof (void *));
870 /* Create a new handler structure initialized with the handler label and
871 typeinfo fields passed in. */
873 struct handler_info *
874 get_new_handler (handler, typeinfo)
878 struct handler_info* ptr;
879 ptr = (struct handler_info *) xmalloc (sizeof (struct handler_info));
880 ptr->handler_label = handler;
881 ptr->handler_number = CODE_LABEL_NUMBER (handler);
882 ptr->type_info = typeinfo;
890 /* Find the index in function_eh_regions associated with a NOTE region. If
891 the region cannot be found, a -1 is returned. */
894 find_func_region (insn_region)
898 for (x = 0; x < current_func_eh_entry; x++)
899 if (function_eh_regions[x].range_number == insn_region)
905 /* Get a pointer to the first handler in an exception region's list. */
907 struct handler_info *
908 get_first_handler (region)
911 int r = find_func_region (region);
914 return function_eh_regions[r].handlers;
917 /* Clean out the function_eh_region table and free all memory */
920 clear_function_eh_region ()
923 struct handler_info *ptr, *next;
924 for (x = 0; x < current_func_eh_entry; x++)
925 for (ptr = function_eh_regions[x].handlers; ptr != NULL; ptr = next)
930 free (function_eh_regions);
931 num_func_eh_entries = 0;
932 current_func_eh_entry = 0;
935 /* Make a duplicate of an exception region by copying all the handlers
936 for an exception region. Return the new handler index. The final
937 parameter is a routine which maps old labels to new ones. */
940 duplicate_eh_handlers (old_note_eh_region, new_note_eh_region, map)
941 int old_note_eh_region, new_note_eh_region;
942 rtx (*map) PARAMS ((rtx));
944 struct handler_info *ptr, *new_ptr;
945 int new_region, region;
947 region = find_func_region (old_note_eh_region);
949 fatal ("Cannot duplicate non-existant exception region.");
951 /* duplicate_eh_handlers may have been called during a symbol remap. */
952 new_region = find_func_region (new_note_eh_region);
953 if (new_region != -1)
956 new_region = new_eh_region_entry (new_note_eh_region, NULL_RTX);
958 ptr = function_eh_regions[region].handlers;
960 for ( ; ptr; ptr = ptr->next)
962 new_ptr = get_new_handler (map (ptr->handler_label), ptr->type_info);
963 add_new_handler (new_region, new_ptr);
970 /* Given a rethrow symbol, find the EH region number this is for. */
972 eh_region_from_symbol (sym)
976 if (sym == last_rethrow_symbol)
978 for (x = 0; x < current_func_eh_entry; x++)
979 if (function_eh_regions[x].rethrow_label == sym)
980 return function_eh_regions[x].range_number;
984 /* Like find_func_region, but using the rethrow symbol for the region
985 rather than the region number itself. */
987 find_func_region_from_symbol (sym)
990 return find_func_region (eh_region_from_symbol (sym));
993 /* When inlining/unrolling, we have to map the symbols passed to
994 __rethrow as well. This performs the remap. If a symbol isn't foiund,
995 the original one is returned. This is not an efficient routine,
996 so don't call it on everything!! */
998 rethrow_symbol_map (sym, map)
1000 rtx (*map) PARAMS ((rtx));
1003 for (x = 0; x < current_func_eh_entry; x++)
1004 if (function_eh_regions[x].rethrow_label == sym)
1006 /* We've found the original region, now lets determine which region
1007 this now maps to. */
1008 rtx l1 = function_eh_regions[x].handlers->handler_label;
1010 y = CODE_LABEL_NUMBER (l2); /* This is the new region number */
1011 x = find_func_region (y); /* Get the new permanent region */
1012 if (x == -1) /* Hmm, Doesn't exist yet */
1014 x = duplicate_eh_handlers (CODE_LABEL_NUMBER (l1), y, map);
1015 /* Since we're mapping it, it must be used. */
1016 function_eh_regions[x].rethrow_ref = 1;
1018 return function_eh_regions[x].rethrow_label;
1024 rethrow_used (region)
1027 if (flag_new_exceptions)
1029 int ret = function_eh_regions[find_func_region (region)].rethrow_ref;
1036 /* Routine to see if exception handling is turned on.
1037 DO_WARN is non-zero if we want to inform the user that exception
1038 handling is turned off.
1040 This is used to ensure that -fexceptions has been specified if the
1041 compiler tries to use any exception-specific functions. */
1047 if (! flag_exceptions)
1049 static int warned = 0;
1050 if (! warned && do_warn)
1052 error ("exception handling disabled, use -fexceptions to enable");
1060 /* Given a return address in ADDR, determine the address we should use
1061 to find the corresponding EH region. */
1064 eh_outer_context (addr)
1067 /* First mask out any unwanted bits. */
1068 #ifdef MASK_RETURN_ADDR
1069 expand_and (addr, MASK_RETURN_ADDR, addr);
1072 /* Then adjust to find the real return address. */
1073 #if defined (RETURN_ADDR_OFFSET)
1074 addr = plus_constant (addr, RETURN_ADDR_OFFSET);
1080 /* Start a new exception region for a region of code that has a
1081 cleanup action and push the HANDLER for the region onto
1082 protect_list. All of the regions created with add_partial_entry
1083 will be ended when end_protect_partials is invoked. */
1086 add_partial_entry (handler)
1089 expand_eh_region_start ();
1091 /* Make sure the entry is on the correct obstack. */
1092 push_obstacks_nochange ();
1093 resume_temporary_allocation ();
1095 /* Because this is a cleanup action, we may have to protect the handler
1096 with __terminate. */
1097 handler = protect_with_terminate (handler);
1099 /* For backwards compatibility, we allow callers to omit calls to
1100 begin_protect_partials for the outermost region. So, we must
1101 explicitly do so here. */
1103 begin_protect_partials ();
1105 /* Add this entry to the front of the list. */
1106 TREE_VALUE (protect_list)
1107 = tree_cons (NULL_TREE, handler, TREE_VALUE (protect_list));
1111 /* Emit code to get EH context to current function. */
1114 call_get_eh_context ()
1119 if (fn == NULL_TREE)
1122 fn = get_identifier ("__get_eh_context");
1123 push_obstacks_nochange ();
1124 end_temporary_allocation ();
1125 fntype = build_pointer_type (build_pointer_type
1126 (build_pointer_type (void_type_node)));
1127 fntype = build_function_type (fntype, NULL_TREE);
1128 fn = build_decl (FUNCTION_DECL, fn, fntype);
1129 DECL_EXTERNAL (fn) = 1;
1130 TREE_PUBLIC (fn) = 1;
1131 DECL_ARTIFICIAL (fn) = 1;
1132 TREE_READONLY (fn) = 1;
1133 make_decl_rtl (fn, NULL_PTR, 1);
1134 assemble_external (fn);
1137 ggc_add_tree_root (&fn, 1);
1140 expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
1141 expr = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
1142 expr, NULL_TREE, NULL_TREE);
1143 TREE_SIDE_EFFECTS (expr) = 1;
1145 return copy_to_reg (expand_expr (expr, NULL_RTX, VOIDmode, 0));
1148 /* Get a reference to the EH context.
1149 We will only generate a register for the current function EH context here,
1150 and emit a USE insn to mark that this is a EH context register.
1152 Later, emit_eh_context will emit needed call to __get_eh_context
1153 in libgcc2, and copy the value to the register we have generated. */
1158 if (current_function_ehc == 0)
1162 current_function_ehc = gen_reg_rtx (Pmode);
1164 insn = gen_rtx_USE (GET_MODE (current_function_ehc),
1165 current_function_ehc);
1166 insn = emit_insn_before (insn, get_first_nonparm_insn ());
1169 = gen_rtx_EXPR_LIST (REG_EH_CONTEXT, current_function_ehc,
1172 return current_function_ehc;
1175 /* Get a reference to the dynamic handler chain. It points to the
1176 pointer to the next element in the dynamic handler chain. It ends
1177 when there are no more elements in the dynamic handler chain, when
1178 the value is &top_elt from libgcc2.c. Immediately after the
1179 pointer, is an area suitable for setjmp/longjmp when
1180 DONT_USE_BUILTIN_SETJMP is defined, and an area suitable for
1181 __builtin_setjmp/__builtin_longjmp when DONT_USE_BUILTIN_SETJMP
1185 get_dynamic_handler_chain ()
1187 rtx ehc, dhc, result;
1189 ehc = get_eh_context ();
1191 /* This is the offset of dynamic_handler_chain in the eh_context struct
1192 declared in eh-common.h. If its location is change, change this offset */
1193 dhc = plus_constant (ehc, POINTER_SIZE / BITS_PER_UNIT);
1195 result = copy_to_reg (dhc);
1197 /* We don't want a copy of the dcc, but rather, the single dcc. */
1198 return gen_rtx_MEM (Pmode, result);
1201 /* Get a reference to the dynamic cleanup chain. It points to the
1202 pointer to the next element in the dynamic cleanup chain.
1203 Immediately after the pointer, are two Pmode variables, one for a
1204 pointer to a function that performs the cleanup action, and the
1205 second, the argument to pass to that function. */
1208 get_dynamic_cleanup_chain ()
1210 rtx dhc, dcc, result;
1212 dhc = get_dynamic_handler_chain ();
1213 dcc = plus_constant (dhc, POINTER_SIZE / BITS_PER_UNIT);
1215 result = copy_to_reg (dcc);
1217 /* We don't want a copy of the dcc, but rather, the single dcc. */
1218 return gen_rtx_MEM (Pmode, result);
1221 #ifdef DONT_USE_BUILTIN_SETJMP
1222 /* Generate code to evaluate X and jump to LABEL if the value is nonzero.
1223 LABEL is an rtx of code CODE_LABEL, in this function. */
1226 jumpif_rtx (x, label)
1230 jumpif (make_tree (type_for_mode (GET_MODE (x), 0), x), label);
1234 /* Start a dynamic cleanup on the EH runtime dynamic cleanup stack.
1235 We just need to create an element for the cleanup list, and push it
1238 A dynamic cleanup is a cleanup action implied by the presence of an
1239 element on the EH runtime dynamic cleanup stack that is to be
1240 performed when an exception is thrown. The cleanup action is
1241 performed by __sjthrow when an exception is thrown. Only certain
1242 actions can be optimized into dynamic cleanup actions. For the
1243 restrictions on what actions can be performed using this routine,
1244 see expand_eh_region_start_tree. */
1247 start_dynamic_cleanup (func, arg)
1252 rtx new_func, new_arg;
1256 /* We allocate enough room for a pointer to the function, and
1260 /* XXX, FIXME: The stack space allocated this way is too long lived,
1261 but there is no allocation routine that allocates at the level of
1262 the last binding contour. */
1263 buf = assign_stack_local (BLKmode,
1264 GET_MODE_SIZE (Pmode)*(size+1),
1267 buf = change_address (buf, Pmode, NULL_RTX);
1269 /* Store dcc into the first word of the newly allocated buffer. */
1271 dcc = get_dynamic_cleanup_chain ();
1272 emit_move_insn (buf, dcc);
1274 /* Store func and arg into the cleanup list element. */
1276 new_func = gen_rtx_MEM (Pmode, plus_constant (XEXP (buf, 0),
1277 GET_MODE_SIZE (Pmode)));
1278 new_arg = gen_rtx_MEM (Pmode, plus_constant (XEXP (buf, 0),
1279 GET_MODE_SIZE (Pmode)*2));
1280 x = expand_expr (func, new_func, Pmode, 0);
1282 emit_move_insn (new_func, x);
1284 x = expand_expr (arg, new_arg, Pmode, 0);
1286 emit_move_insn (new_arg, x);
1288 /* Update the cleanup chain. */
1290 x = force_operand (XEXP (buf, 0), dcc);
1292 emit_move_insn (dcc, x);
1295 /* Emit RTL to start a dynamic handler on the EH runtime dynamic
1296 handler stack. This should only be used by expand_eh_region_start
1297 or expand_eh_region_start_tree. */
1300 start_dynamic_handler ()
1306 #ifndef DONT_USE_BUILTIN_SETJMP
1307 /* The number of Pmode words for the setjmp buffer, when using the
1308 builtin setjmp/longjmp, see expand_builtin, case BUILT_IN_LONGJMP. */
1309 /* We use 2 words here before calling expand_builtin_setjmp.
1310 expand_builtin_setjmp uses 2 words, and then calls emit_stack_save.
1311 emit_stack_save needs space of size STACK_SAVEAREA_MODE (SAVE_NONLOCAL).
1312 Subtract one, because the assign_stack_local call below adds 1. */
1313 size = (2 + 2 + (GET_MODE_SIZE (STACK_SAVEAREA_MODE (SAVE_NONLOCAL))
1314 / GET_MODE_SIZE (Pmode))
1318 size = JMP_BUF_SIZE;
1320 /* Should be large enough for most systems, if it is not,
1321 JMP_BUF_SIZE should be defined with the proper value. It will
1322 also tend to be larger than necessary for most systems, a more
1323 optimal port will define JMP_BUF_SIZE. */
1324 size = FIRST_PSEUDO_REGISTER+2;
1327 /* XXX, FIXME: The stack space allocated this way is too long lived,
1328 but there is no allocation routine that allocates at the level of
1329 the last binding contour. */
1330 arg = assign_stack_local (BLKmode,
1331 GET_MODE_SIZE (Pmode)*(size+1),
1334 arg = change_address (arg, Pmode, NULL_RTX);
1336 /* Store dhc into the first word of the newly allocated buffer. */
1338 dhc = get_dynamic_handler_chain ();
1339 dcc = gen_rtx_MEM (Pmode, plus_constant (XEXP (arg, 0),
1340 GET_MODE_SIZE (Pmode)));
1341 emit_move_insn (arg, dhc);
1343 /* Zero out the start of the cleanup chain. */
1344 emit_move_insn (dcc, const0_rtx);
1346 /* The jmpbuf starts two words into the area allocated. */
1347 buf = plus_constant (XEXP (arg, 0), GET_MODE_SIZE (Pmode)*2);
1349 #ifdef DONT_USE_BUILTIN_SETJMP
1350 x = emit_library_call_value (setjmp_libfunc, NULL_RTX, 1, SImode, 1,
1352 /* If we come back here for a catch, transfer control to the handler. */
1353 jumpif_rtx (x, ehstack.top->entry->exception_handler_label);
1356 /* A label to continue execution for the no exception case. */
1357 rtx noex = gen_label_rtx();
1358 x = expand_builtin_setjmp (buf, NULL_RTX, noex,
1359 ehstack.top->entry->exception_handler_label);
1364 /* We are committed to this, so update the handler chain. */
1366 emit_move_insn (dhc, force_operand (XEXP (arg, 0), NULL_RTX));
1369 /* Start an exception handling region for the given cleanup action.
1370 All instructions emitted after this point are considered to be part
1371 of the region until expand_eh_region_end is invoked. CLEANUP is
1372 the cleanup action to perform. The return value is true if the
1373 exception region was optimized away. If that case,
1374 expand_eh_region_end does not need to be called for this cleanup,
1377 This routine notices one particular common case in C++ code
1378 generation, and optimizes it so as to not need the exception
1379 region. It works by creating a dynamic cleanup action, instead of
1380 a using an exception region. */
1383 expand_eh_region_start_tree (decl, cleanup)
1387 /* This is the old code. */
1391 /* The optimization only applies to actions protected with
1392 terminate, and only applies if we are using the setjmp/longjmp
1394 if (exceptions_via_longjmp
1395 && protect_cleanup_actions_with_terminate)
1400 /* Ignore any UNSAVE_EXPR. */
1401 if (TREE_CODE (cleanup) == UNSAVE_EXPR)
1402 cleanup = TREE_OPERAND (cleanup, 0);
1404 /* Further, it only applies if the action is a call, if there
1405 are 2 arguments, and if the second argument is 2. */
1407 if (TREE_CODE (cleanup) == CALL_EXPR
1408 && (args = TREE_OPERAND (cleanup, 1))
1409 && (func = TREE_OPERAND (cleanup, 0))
1410 && (arg = TREE_VALUE (args))
1411 && (args = TREE_CHAIN (args))
1413 /* is the second argument 2? */
1414 && TREE_CODE (TREE_VALUE (args)) == INTEGER_CST
1415 && TREE_INT_CST_LOW (TREE_VALUE (args)) == 2
1416 && TREE_INT_CST_HIGH (TREE_VALUE (args)) == 0
1418 /* Make sure there are no other arguments. */
1419 && TREE_CHAIN (args) == NULL_TREE)
1421 /* Arrange for returns and gotos to pop the entry we make on the
1422 dynamic cleanup stack. */
1423 expand_dcc_cleanup (decl);
1424 start_dynamic_cleanup (func, arg);
1429 expand_eh_region_start_for_decl (decl);
1430 ehstack.top->entry->finalization = cleanup;
1435 /* Just like expand_eh_region_start, except if a cleanup action is
1436 entered on the cleanup chain, the TREE_PURPOSE of the element put
1437 on the chain is DECL. DECL should be the associated VAR_DECL, if
1438 any, otherwise it should be NULL_TREE. */
1441 expand_eh_region_start_for_decl (decl)
1446 /* This is the old code. */
1450 /* We need a new block to record the start and end of the
1451 dynamic handler chain. We also want to prevent jumping into
1453 expand_start_bindings (2);
1455 /* But we don't need or want a new temporary level. */
1458 /* Mark this block as created by expand_eh_region_start. This
1459 is so that we can pop the block with expand_end_bindings
1461 mark_block_as_eh_region ();
1463 if (exceptions_via_longjmp)
1465 /* Arrange for returns and gotos to pop the entry we make on the
1466 dynamic handler stack. */
1467 expand_dhc_cleanup (decl);
1470 push_eh_entry (&ehstack);
1471 note = emit_note (NULL_PTR, NOTE_INSN_EH_REGION_BEG);
1472 NOTE_EH_HANDLER (note)
1473 = CODE_LABEL_NUMBER (ehstack.top->entry->exception_handler_label);
1474 if (exceptions_via_longjmp)
1475 start_dynamic_handler ();
1478 /* Start an exception handling region. All instructions emitted after
1479 this point are considered to be part of the region until
1480 expand_eh_region_end is invoked. */
1483 expand_eh_region_start ()
1485 expand_eh_region_start_for_decl (NULL_TREE);
1488 /* End an exception handling region. The information about the region
1489 is found on the top of ehstack.
1491 HANDLER is either the cleanup for the exception region, or if we're
1492 marking the end of a try block, HANDLER is integer_zero_node.
1494 HANDLER will be transformed to rtl when expand_leftover_cleanups
1498 expand_eh_region_end (handler)
1501 struct eh_entry *entry;
1502 struct eh_node *node;
1509 entry = pop_eh_entry (&ehstack);
1511 note = emit_note (NULL_PTR, NOTE_INSN_EH_REGION_END);
1512 ret = NOTE_EH_HANDLER (note)
1513 = CODE_LABEL_NUMBER (entry->exception_handler_label);
1514 if (exceptions_via_longjmp == 0 && ! flag_new_exceptions
1515 /* We share outer_context between regions; only emit it once. */
1516 && INSN_UID (entry->outer_context) == 0)
1520 label = gen_label_rtx ();
1523 /* Emit a label marking the end of this exception region that
1524 is used for rethrowing into the outer context. */
1525 emit_label (entry->outer_context);
1526 expand_internal_throw ();
1531 entry->finalization = handler;
1533 /* create region entry in final exception table */
1534 r = new_eh_region_entry (NOTE_EH_HANDLER (note), entry->rethrow_label);
1536 enqueue_eh_entry (ehqueue, entry);
1538 /* If we have already started ending the bindings, don't recurse. */
1539 if (is_eh_region ())
1541 /* Because we don't need or want a new temporary level and
1542 because we didn't create one in expand_eh_region_start,
1543 create a fake one now to avoid removing one in
1544 expand_end_bindings. */
1547 mark_block_as_not_eh_region ();
1549 expand_end_bindings (NULL_TREE, 0, 0);
1552 /* Go through the goto handlers in the queue, emitting their
1553 handlers if we now have enough information to do so. */
1554 for (node = ehqueue->head; node; node = node->chain)
1555 if (node->entry->goto_entry_p
1556 && node->entry->outer_context == entry->rethrow_label)
1557 emit_cleanup_handler (node->entry);
1559 /* We can't emit handlers for goto entries until their scopes are
1560 complete because we don't know where they need to rethrow to,
1562 if (entry->finalization != integer_zero_node
1563 && (!entry->goto_entry_p
1564 || find_func_region_from_symbol (entry->outer_context) != -1))
1565 emit_cleanup_handler (entry);
1568 /* End the EH region for a goto fixup. We only need them in the region-based
1572 expand_fixup_region_start ()
1574 if (! doing_eh (0) || exceptions_via_longjmp)
1577 expand_eh_region_start ();
1578 /* Mark this entry as the entry for a goto. */
1579 ehstack.top->entry->goto_entry_p = 1;
1582 /* End the EH region for a goto fixup. CLEANUP is the cleanup we just
1583 expanded; to avoid running it twice if it throws, we look through the
1584 ehqueue for a matching region and rethrow from its outer_context. */
1587 expand_fixup_region_end (cleanup)
1590 struct eh_node *node;
1593 if (! doing_eh (0) || exceptions_via_longjmp)
1596 for (node = ehstack.top; node && node->entry->finalization != cleanup; )
1599 for (node = ehqueue->head; node && node->entry->finalization != cleanup; )
1604 /* If the outer context label has not been issued yet, we don't want
1605 to issue it as a part of this region, unless this is the
1606 correct region for the outer context. If we did, then the label for
1607 the outer context will be WITHIN the begin/end labels,
1608 and we could get an infinte loop when it tried to rethrow, or just
1609 generally incorrect execution following a throw. */
1611 if (flag_new_exceptions)
1614 dont_issue = ((INSN_UID (node->entry->outer_context) == 0)
1615 && (ehstack.top->entry != node->entry));
1617 ehstack.top->entry->outer_context = node->entry->outer_context;
1619 /* Since we are rethrowing to the OUTER region, we know we don't need
1620 a jump around sequence for this region, so we'll pretend the outer
1621 context label has been issued by setting INSN_UID to 1, then clearing
1622 it again afterwards. */
1625 INSN_UID (node->entry->outer_context) = 1;
1627 /* Just rethrow. size_zero_node is just a NOP. */
1628 expand_eh_region_end (size_zero_node);
1631 INSN_UID (node->entry->outer_context) = 0;
1634 /* If we are using the setjmp/longjmp EH codegen method, we emit a
1637 Otherwise, we emit a call to __throw and note that we threw
1638 something, so we know we need to generate the necessary code for
1641 Before invoking throw, the __eh_pc variable must have been set up
1642 to contain the PC being thrown from. This address is used by
1643 __throw to determine which exception region (if any) is
1644 responsible for handling the exception. */
1649 if (exceptions_via_longjmp)
1651 emit_library_call (sjthrow_libfunc, 0, VOIDmode, 0);
1655 #ifdef JUMP_TO_THROW
1656 emit_indirect_jump (throw_libfunc);
1658 emit_library_call (throw_libfunc, 0, VOIDmode, 0);
1664 /* Throw the current exception. If appropriate, this is done by jumping
1665 to the next handler. */
1668 expand_internal_throw ()
1673 /* Called from expand_exception_blocks and expand_end_catch_block to
1674 emit any pending handlers/cleanups queued from expand_eh_region_end. */
1677 expand_leftover_cleanups ()
1679 struct eh_entry *entry;
1681 for (entry = dequeue_eh_entry (ehqueue);
1683 entry = dequeue_eh_entry (ehqueue))
1685 /* A leftover try block. Shouldn't be one here. */
1686 if (entry->finalization == integer_zero_node)
1693 /* Called at the start of a block of try statements. */
1695 expand_start_try_stmts ()
1700 expand_eh_region_start ();
1703 /* Called to begin a catch clause. The parameter is the object which
1704 will be passed to the runtime type check routine. */
1706 start_catch_handler (rtime)
1710 int insn_region_num;
1711 int eh_region_entry;
1716 handler_label = catchstack.top->entry->exception_handler_label;
1717 insn_region_num = CODE_LABEL_NUMBER (handler_label);
1718 eh_region_entry = find_func_region (insn_region_num);
1720 /* If we've already issued this label, pick a new one */
1721 if (catchstack.top->entry->label_used)
1722 handler_label = gen_exception_label ();
1724 catchstack.top->entry->label_used = 1;
1726 receive_exception_label (handler_label);
1728 add_new_handler (eh_region_entry, get_new_handler (handler_label, rtime));
1730 if (flag_new_exceptions && ! exceptions_via_longjmp)
1733 /* Under the old mechanism, as well as setjmp/longjmp, we need to
1734 issue code to compare 'rtime' to the value in eh_info, via the
1735 matching function in eh_info. If its is false, we branch around
1736 the handler we are about to issue. */
1738 if (rtime != NULL_TREE && rtime != CATCH_ALL_TYPE)
1740 rtx call_rtx, rtime_address;
1742 if (catchstack.top->entry->false_label != NULL_RTX)
1744 error ("Never issued previous false_label");
1747 catchstack.top->entry->false_label = gen_exception_label ();
1749 rtime_address = expand_expr (rtime, NULL_RTX, Pmode, EXPAND_INITIALIZER);
1750 #ifdef POINTERS_EXTEND_UNSIGNED
1751 rtime_address = convert_memory_address (Pmode, rtime_address);
1753 rtime_address = force_reg (Pmode, rtime_address);
1755 /* Now issue the call, and branch around handler if needed */
1756 call_rtx = emit_library_call_value (eh_rtime_match_libfunc, NULL_RTX,
1757 0, SImode, 1, rtime_address, Pmode);
1759 /* Did the function return true? */
1760 emit_cmp_and_jump_insns (call_rtx, const0_rtx, EQ, NULL_RTX,
1761 GET_MODE (call_rtx), 0, 0,
1762 catchstack.top->entry->false_label);
1766 /* Called to end a catch clause. If we aren't using the new exception
1767 model tabel mechanism, we need to issue the branch-around label
1768 for the end of the catch block. */
1771 end_catch_handler ()
1776 if (flag_new_exceptions && ! exceptions_via_longjmp)
1782 /* A NULL label implies the catch clause was a catch all or cleanup */
1783 if (catchstack.top->entry->false_label == NULL_RTX)
1786 emit_label (catchstack.top->entry->false_label);
1787 catchstack.top->entry->false_label = NULL_RTX;
1790 /* Save away the current ehqueue. */
1796 q = (struct eh_queue *) xcalloc (1, sizeof (struct eh_queue));
1801 /* Restore a previously pushed ehqueue. */
1807 expand_leftover_cleanups ();
1813 /* Emit the handler specified by ENTRY. */
1816 emit_cleanup_handler (entry)
1817 struct eh_entry *entry;
1822 /* Since the cleanup could itself contain try-catch blocks, we
1823 squirrel away the current queue and replace it when we are done
1824 with this function. */
1827 /* Put these handler instructions in a sequence. */
1828 do_pending_stack_adjust ();
1831 /* Emit the label for the cleanup handler for this region, and
1832 expand the code for the handler.
1834 Note that a catch region is handled as a side-effect here; for a
1835 try block, entry->finalization will contain integer_zero_node, so
1836 no code will be generated in the expand_expr call below. But, the
1837 label for the handler will still be emitted, so any code emitted
1838 after this point will end up being the handler. */
1840 receive_exception_label (entry->exception_handler_label);
1842 /* register a handler for this cleanup region */
1843 add_new_handler (find_func_region (CODE_LABEL_NUMBER (entry->exception_handler_label)),
1844 get_new_handler (entry->exception_handler_label, NULL));
1846 /* And now generate the insns for the cleanup handler. */
1847 expand_expr (entry->finalization, const0_rtx, VOIDmode, 0);
1849 prev = get_last_insn ();
1850 if (prev == NULL || GET_CODE (prev) != BARRIER)
1851 /* Code to throw out to outer context when we fall off end of the
1852 handler. We can't do this here for catch blocks, so it's done
1853 in expand_end_all_catch instead. */
1854 expand_rethrow (entry->outer_context);
1856 /* Finish this sequence. */
1857 do_pending_stack_adjust ();
1858 handler_insns = get_insns ();
1861 /* And add it to the CATCH_CLAUSES. */
1862 push_to_sequence (catch_clauses);
1863 emit_insns (handler_insns);
1864 catch_clauses = get_insns ();
1867 /* Now we've left the handler. */
1871 /* Generate RTL for the start of a group of catch clauses.
1873 It is responsible for starting a new instruction sequence for the
1874 instructions in the catch block, and expanding the handlers for the
1875 internally-generated exception regions nested within the try block
1876 corresponding to this catch block. */
1879 expand_start_all_catch ()
1881 struct eh_entry *entry;
1888 outer_context = ehstack.top->entry->outer_context;
1890 /* End the try block. */
1891 expand_eh_region_end (integer_zero_node);
1893 emit_line_note (input_filename, lineno);
1894 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
1896 /* The label for the exception handling block that we will save.
1897 This is Lresume in the documentation. */
1898 expand_label (label);
1900 /* Push the label that points to where normal flow is resumed onto
1901 the top of the label stack. */
1902 push_label_entry (&caught_return_label_stack, NULL_RTX, label);
1904 /* Start a new sequence for all the catch blocks. We will add this
1905 to the global sequence catch_clauses when we have completed all
1906 the handlers in this handler-seq. */
1909 /* Throw away entries in the queue that we won't need anymore. We
1910 need entries for regions that have ended but to which there might
1911 still be gotos pending. */
1912 for (entry = dequeue_eh_entry (ehqueue);
1913 entry->finalization != integer_zero_node;
1914 entry = dequeue_eh_entry (ehqueue))
1917 /* At this point, all the cleanups are done, and the ehqueue now has
1918 the current exception region at its head. We dequeue it, and put it
1919 on the catch stack. */
1920 push_entry (&catchstack, entry);
1922 /* If we are not doing setjmp/longjmp EH, because we are reordered
1923 out of line, we arrange to rethrow in the outer context. We need to
1924 do this because we are not physically within the region, if any, that
1925 logically contains this catch block. */
1926 if (! exceptions_via_longjmp)
1928 expand_eh_region_start ();
1929 ehstack.top->entry->outer_context = outer_context;
1934 /* Finish up the catch block. At this point all the insns for the
1935 catch clauses have already been generated, so we only have to add
1936 them to the catch_clauses list. We also want to make sure that if
1937 we fall off the end of the catch clauses that we rethrow to the
1941 expand_end_all_catch ()
1943 rtx new_catch_clause;
1944 struct eh_entry *entry;
1949 /* Dequeue the current catch clause region. */
1950 entry = pop_eh_entry (&catchstack);
1953 if (! exceptions_via_longjmp)
1955 rtx outer_context = ehstack.top->entry->outer_context;
1957 /* Finish the rethrow region. size_zero_node is just a NOP. */
1958 expand_eh_region_end (size_zero_node);
1959 /* New exceptions handling models will never have a fall through
1960 of a catch clause */
1961 if (!flag_new_exceptions)
1962 expand_rethrow (outer_context);
1965 expand_rethrow (NULL_RTX);
1967 /* Code to throw out to outer context, if we fall off end of catch
1968 handlers. This is rethrow (Lresume, same id, same obj) in the
1969 documentation. We use Lresume because we know that it will throw
1970 to the correct context.
1972 In other words, if the catch handler doesn't exit or return, we
1973 do a "throw" (using the address of Lresume as the point being
1974 thrown from) so that the outer EH region can then try to process
1977 /* Now we have the complete catch sequence. */
1978 new_catch_clause = get_insns ();
1981 /* This level of catch blocks is done, so set up the successful
1982 catch jump label for the next layer of catch blocks. */
1983 pop_label_entry (&caught_return_label_stack);
1984 pop_label_entry (&outer_context_label_stack);
1986 /* Add the new sequence of catches to the main one for this function. */
1987 push_to_sequence (catch_clauses);
1988 emit_insns (new_catch_clause);
1989 catch_clauses = get_insns ();
1992 /* Here we fall through into the continuation code. */
1995 /* Rethrow from the outer context LABEL. */
1998 expand_rethrow (label)
2001 if (exceptions_via_longjmp)
2004 if (flag_new_exceptions)
2008 if (label == NULL_RTX)
2009 label = last_rethrow_symbol;
2010 emit_library_call (rethrow_libfunc, 0, VOIDmode, 1, label, Pmode);
2011 region = find_func_region (eh_region_from_symbol (label));
2012 /* If the region is -1, it doesn't exist yet. We should be
2013 trying to rethrow there yet. */
2016 function_eh_regions[region].rethrow_ref = 1;
2018 /* Search backwards for the actual call insn. */
2019 insn = get_last_insn ();
2020 while (GET_CODE (insn) != CALL_INSN)
2021 insn = PREV_INSN (insn);
2022 delete_insns_since (insn);
2024 /* Mark the label/symbol on the call. */
2025 REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EH_RETHROW, label,
2033 /* Begin a region that will contain entries created with
2034 add_partial_entry. */
2037 begin_protect_partials ()
2039 /* Put the entry on the function obstack. */
2040 push_obstacks_nochange ();
2041 resume_temporary_allocation ();
2043 /* Push room for a new list. */
2044 protect_list = tree_cons (NULL_TREE, NULL_TREE, protect_list);
2046 /* We're done with the function obstack now. */
2050 /* End all the pending exception regions on protect_list. The handlers
2051 will be emitted when expand_leftover_cleanups is invoked. */
2054 end_protect_partials ()
2058 /* For backwards compatibility, we allow callers to omit the call to
2059 begin_protect_partials for the outermost region. So,
2060 PROTECT_LIST may be NULL. */
2064 /* End all the exception regions. */
2065 for (t = TREE_VALUE (protect_list); t; t = TREE_CHAIN (t))
2066 expand_eh_region_end (TREE_VALUE (t));
2068 /* Pop the topmost entry. */
2069 protect_list = TREE_CHAIN (protect_list);
2073 /* Arrange for __terminate to be called if there is an unhandled throw
2077 protect_with_terminate (e)
2080 /* We only need to do this when using setjmp/longjmp EH and the
2081 language requires it, as otherwise we protect all of the handlers
2082 at once, if we need to. */
2083 if (exceptions_via_longjmp && protect_cleanup_actions_with_terminate)
2085 tree handler, result;
2087 /* All cleanups must be on the function_obstack. */
2088 push_obstacks_nochange ();
2089 resume_temporary_allocation ();
2091 handler = make_node (RTL_EXPR);
2092 TREE_TYPE (handler) = void_type_node;
2093 RTL_EXPR_RTL (handler) = const0_rtx;
2094 TREE_SIDE_EFFECTS (handler) = 1;
2095 start_sequence_for_rtl_expr (handler);
2097 emit_library_call (terminate_libfunc, 0, VOIDmode, 0);
2100 RTL_EXPR_SEQUENCE (handler) = get_insns ();
2103 result = build (TRY_CATCH_EXPR, TREE_TYPE (e), e, handler);
2104 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
2105 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
2106 TREE_READONLY (result) = TREE_READONLY (e);
2116 /* The exception table that we build that is used for looking up and
2117 dispatching exceptions, the current number of entries, and its
2118 maximum size before we have to extend it.
2120 The number in eh_table is the code label number of the exception
2121 handler for the region. This is added by add_eh_table_entry and
2122 used by output_exception_table_entry. */
2124 static int *eh_table = NULL;
2125 static int eh_table_size = 0;
2126 static int eh_table_max_size = 0;
2128 /* Note the need for an exception table entry for region N. If we
2129 don't need to output an explicit exception table, avoid all of the
2132 Called from final_scan_insn when a NOTE_INSN_EH_REGION_BEG is seen.
2133 (Or NOTE_INSN_EH_REGION_END sometimes)
2134 N is the NOTE_EH_HANDLER of the note, which comes from the code
2135 label number of the exception handler for the region. */
2138 add_eh_table_entry (n)
2141 #ifndef OMIT_EH_TABLE
2142 if (eh_table_size >= eh_table_max_size)
2146 eh_table_max_size += eh_table_max_size>>1;
2148 if (eh_table_max_size < 0)
2151 eh_table = (int *) xrealloc (eh_table,
2152 eh_table_max_size * sizeof (int));
2156 eh_table_max_size = 252;
2157 eh_table = (int *) xmalloc (eh_table_max_size * sizeof (int));
2160 eh_table[eh_table_size++] = n;
2164 /* Return a non-zero value if we need to output an exception table.
2166 On some platforms, we don't have to output a table explicitly.
2167 This routine doesn't mean we don't have one. */
2170 exception_table_p ()
2178 /* Output the entry of the exception table corresponding to the
2179 exception region numbered N to file FILE.
2181 N is the code label number corresponding to the handler of the
2185 output_exception_table_entry (file, n)
2191 struct handler_info *handler = get_first_handler (n);
2192 int index = find_func_region (n);
2195 /* form and emit the rethrow label, if needed */
2196 rethrow = function_eh_regions[index].rethrow_label;
2197 if (rethrow != NULL_RTX && !flag_new_exceptions)
2199 if (rethrow != NULL_RTX && handler == NULL)
2200 if (! function_eh_regions[index].rethrow_ref)
2204 for ( ; handler != NULL || rethrow != NULL_RTX; handler = handler->next)
2206 /* rethrow label should indicate the LAST entry for a region */
2207 if (rethrow != NULL_RTX && (handler == NULL || handler->next == NULL))
2209 ASM_GENERATE_INTERNAL_LABEL (buf, "LRTH", n);
2210 assemble_label(buf);
2214 ASM_GENERATE_INTERNAL_LABEL (buf, "LEHB", n);
2215 sym = gen_rtx_SYMBOL_REF (Pmode, buf);
2216 assemble_integer (sym, POINTER_SIZE / BITS_PER_UNIT, 1);
2218 ASM_GENERATE_INTERNAL_LABEL (buf, "LEHE", n);
2219 sym = gen_rtx_SYMBOL_REF (Pmode, buf);
2220 assemble_integer (sym, POINTER_SIZE / BITS_PER_UNIT, 1);
2222 if (handler == NULL)
2223 assemble_integer (GEN_INT (0), POINTER_SIZE / BITS_PER_UNIT, 1);
2226 ASM_GENERATE_INTERNAL_LABEL (buf, "L", handler->handler_number);
2227 sym = gen_rtx_SYMBOL_REF (Pmode, buf);
2228 assemble_integer (sym, POINTER_SIZE / BITS_PER_UNIT, 1);
2231 if (flag_new_exceptions)
2233 if (handler == NULL || handler->type_info == NULL)
2234 assemble_integer (const0_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
2236 if (handler->type_info == CATCH_ALL_TYPE)
2237 assemble_integer (GEN_INT (CATCH_ALL_TYPE),
2238 POINTER_SIZE / BITS_PER_UNIT, 1);
2240 output_constant ((tree)(handler->type_info),
2241 POINTER_SIZE / BITS_PER_UNIT);
2243 putc ('\n', file); /* blank line */
2244 /* We only output the first label under the old scheme */
2245 if (! flag_new_exceptions || handler == NULL)
2250 /* Output the exception table if we have and need one. */
2252 static short language_code = 0;
2253 static short version_code = 0;
2255 /* This routine will set the language code for exceptions. */
2257 set_exception_lang_code (code)
2260 language_code = code;
2263 /* This routine will set the language version code for exceptions. */
2265 set_exception_version_code (code)
2268 version_code = code;
2273 output_exception_table ()
2277 extern FILE *asm_out_file;
2279 if (! doing_eh (0) || ! eh_table)
2282 exception_section ();
2284 /* Beginning marker for table. */
2285 assemble_align (GET_MODE_ALIGNMENT (ptr_mode));
2286 assemble_label ("__EXCEPTION_TABLE__");
2288 if (flag_new_exceptions)
2290 assemble_integer (GEN_INT (NEW_EH_RUNTIME),
2291 POINTER_SIZE / BITS_PER_UNIT, 1);
2292 assemble_integer (GEN_INT (language_code), 2 , 1);
2293 assemble_integer (GEN_INT (version_code), 2 , 1);
2295 /* Add enough padding to make sure table aligns on a pointer boundry. */
2296 i = GET_MODE_ALIGNMENT (ptr_mode) / BITS_PER_UNIT - 4;
2297 for ( ; i < 0; i = i + GET_MODE_ALIGNMENT (ptr_mode) / BITS_PER_UNIT)
2300 assemble_integer (const0_rtx, i , 1);
2302 /* Generate the label for offset calculations on rethrows */
2303 ASM_GENERATE_INTERNAL_LABEL (buf, "LRTH", 0);
2304 assemble_label(buf);
2307 for (i = 0; i < eh_table_size; ++i)
2308 output_exception_table_entry (asm_out_file, eh_table[i]);
2311 clear_function_eh_region ();
2313 /* Ending marker for table. */
2314 /* Generate the label for end of table. */
2315 ASM_GENERATE_INTERNAL_LABEL (buf, "LRTH", CODE_LABEL_NUMBER (final_rethrow));
2316 assemble_label(buf);
2317 assemble_integer (constm1_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
2319 /* for binary compatability, the old __throw checked the second
2320 position for a -1, so we should output at least 2 -1's */
2321 if (! flag_new_exceptions)
2322 assemble_integer (constm1_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
2324 putc ('\n', asm_out_file); /* blank line */
2327 /* Emit code to get EH context.
2329 We have to scan thru the code to find possible EH context registers.
2330 Inlined functions may use it too, and thus we'll have to be able
2333 This is done only if using exceptions_via_longjmp. */
2344 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2345 if (GET_CODE (insn) == INSN
2346 && GET_CODE (PATTERN (insn)) == USE)
2348 rtx reg = find_reg_note (insn, REG_EH_CONTEXT, 0);
2355 /* If this is the first use insn, emit the call here. This
2356 will always be at the top of our function, because if
2357 expand_inline_function notices a REG_EH_CONTEXT note, it
2358 adds a use insn to this function as well. */
2360 ehc = call_get_eh_context ();
2362 emit_move_insn (XEXP (reg, 0), ehc);
2363 insns = get_insns ();
2366 emit_insns_before (insns, insn);
2371 /* Scan the current insns and build a list of handler labels. The
2372 resulting list is placed in the global variable exception_handler_labels.
2374 It is called after the last exception handling region is added to
2375 the current function (when the rtl is almost all built for the
2376 current function) and before the jump optimization pass. */
2379 find_exception_handler_labels ()
2383 exception_handler_labels = NULL_RTX;
2385 /* If we aren't doing exception handling, there isn't much to check. */
2389 /* For each start of a region, add its label to the list. */
2391 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2393 struct handler_info* ptr;
2394 if (GET_CODE (insn) == NOTE
2395 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
2397 ptr = get_first_handler (NOTE_EH_HANDLER (insn));
2398 for ( ; ptr; ptr = ptr->next)
2400 /* make sure label isn't in the list already */
2402 for (x = exception_handler_labels; x; x = XEXP (x, 1))
2403 if (XEXP (x, 0) == ptr->handler_label)
2406 exception_handler_labels = gen_rtx_EXPR_LIST (VOIDmode,
2407 ptr->handler_label, exception_handler_labels);
2413 /* Return a value of 1 if the parameter label number is an exception handler
2414 label. Return 0 otherwise. */
2417 is_exception_handler_label (lab)
2421 for (x = exception_handler_labels ; x ; x = XEXP (x, 1))
2422 if (lab == CODE_LABEL_NUMBER (XEXP (x, 0)))
2427 /* Perform sanity checking on the exception_handler_labels list.
2429 Can be called after find_exception_handler_labels is called to
2430 build the list of exception handlers for the current function and
2431 before we finish processing the current function. */
2434 check_exception_handler_labels ()
2438 /* If we aren't doing exception handling, there isn't much to check. */
2442 /* Make sure there is no more than 1 copy of a label */
2443 for (insn = exception_handler_labels; insn; insn = XEXP (insn, 1))
2446 for (insn2 = exception_handler_labels; insn2; insn2 = XEXP (insn2, 1))
2447 if (XEXP (insn, 0) == XEXP (insn2, 0))
2450 warning ("Counted %d copies of EH region %d in list.\n", count,
2451 CODE_LABEL_NUMBER (insn));
2456 /* Mark the children of NODE for GC. */
2460 struct eh_node *node;
2466 ggc_mark_rtx (node->entry->outer_context);
2467 ggc_mark_rtx (node->entry->exception_handler_label);
2468 ggc_mark_tree (node->entry->finalization);
2469 ggc_mark_rtx (node->entry->false_label);
2470 ggc_mark_rtx (node->entry->rethrow_label);
2472 node = node ->chain;
2476 /* Mark S for GC. */
2483 mark_eh_node (s->top);
2486 /* Mark Q for GC. */
2494 mark_eh_node (q->head);
2499 /* Mark NODE for GC. A label_node contains a union containing either
2500 a tree or an rtx. This label_node will contain a tree. */
2503 mark_tree_label_node (node)
2504 struct label_node *node;
2508 ggc_mark_tree (node->u.tlabel);
2513 /* Mark EH for GC. */
2517 struct eh_status *eh;
2522 mark_eh_stack (&eh->x_ehstack);
2523 mark_eh_stack (&eh->x_catchstack);
2524 mark_eh_queue (eh->x_ehqueue);
2525 ggc_mark_rtx (eh->x_catch_clauses);
2527 lang_mark_false_label_stack (eh->x_false_label_stack);
2528 mark_tree_label_node (eh->x_caught_return_label_stack);
2530 ggc_mark_tree (eh->x_protect_list);
2531 ggc_mark_rtx (eh->ehc);
2532 ggc_mark_rtx (eh->x_eh_return_stub_label);
2535 /* Mark ARG (which is really a struct func_eh_entry**) for GC. */
2538 mark_func_eh_entry (arg)
2541 struct func_eh_entry *fee;
2542 struct handler_info *h;
2545 fee = *((struct func_eh_entry **) arg);
2547 for (i = 0; i < current_func_eh_entry; ++i)
2549 ggc_mark_rtx (fee->rethrow_label);
2550 for (h = fee->handlers; h; h = h->next)
2552 ggc_mark_rtx (h->handler_label);
2553 if (h->type_info != CATCH_ALL_TYPE)
2554 ggc_mark_tree ((tree) h->type_info);
2557 /* Skip to the next entry in the array. */
2562 /* This group of functions initializes the exception handling data
2563 structures at the start of the compilation, initializes the data
2564 structures at the start of a function, and saves and restores the
2565 exception handling data structures for the start/end of a nested
2568 /* Toplevel initialization for EH things. */
2573 first_rethrow_symbol = create_rethrow_ref (0);
2574 final_rethrow = gen_exception_label ();
2575 last_rethrow_symbol = create_rethrow_ref (CODE_LABEL_NUMBER (final_rethrow));
2577 ggc_add_rtx_root (&exception_handler_labels, 1);
2578 ggc_add_rtx_root (&eh_return_context, 1);
2579 ggc_add_rtx_root (&eh_return_stack_adjust, 1);
2580 ggc_add_rtx_root (&eh_return_handler, 1);
2581 ggc_add_rtx_root (&first_rethrow_symbol, 1);
2582 ggc_add_rtx_root (&final_rethrow, 1);
2583 ggc_add_rtx_root (&last_rethrow_symbol, 1);
2584 ggc_add_root (&function_eh_regions, 1, sizeof (function_eh_regions),
2585 mark_func_eh_entry);
2588 /* Initialize the per-function EH information. */
2591 init_eh_for_function ()
2593 cfun->eh = (struct eh_status *) xcalloc (1, sizeof (struct eh_status));
2594 ehqueue = (struct eh_queue *) xcalloc (1, sizeof (struct eh_queue));
2595 eh_return_context = NULL_RTX;
2596 eh_return_stack_adjust = NULL_RTX;
2597 eh_return_handler = NULL_RTX;
2604 free (f->eh->x_ehqueue);
2609 /* This section is for the exception handling specific optimization
2610 pass. First are the internal routines, and then the main
2611 optimization pass. */
2613 /* Determine if the given INSN can throw an exception. */
2619 /* Calls can always potentially throw exceptions, unless they have
2620 a REG_EH_REGION note with a value of 0 or less. */
2621 if (GET_CODE (insn) == CALL_INSN)
2623 rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
2624 if (!note || XINT (XEXP (note, 0), 0) > 0)
2628 if (asynchronous_exceptions)
2630 /* If we wanted asynchronous exceptions, then everything but NOTEs
2631 and CODE_LABELs could throw. */
2632 if (GET_CODE (insn) != NOTE && GET_CODE (insn) != CODE_LABEL)
2639 /* Scan a exception region looking for the matching end and then
2640 remove it if possible. INSN is the start of the region, N is the
2641 region number, and DELETE_OUTER is to note if anything in this
2644 Regions are removed if they cannot possibly catch an exception.
2645 This is determined by invoking can_throw on each insn within the
2646 region; if can_throw returns true for any of the instructions, the
2647 region can catch an exception, since there is an insn within the
2648 region that is capable of throwing an exception.
2650 Returns the NOTE_INSN_EH_REGION_END corresponding to this region, or
2651 calls abort if it can't find one.
2653 Can abort if INSN is not a NOTE_INSN_EH_REGION_BEGIN, or if N doesn't
2654 correspond to the region number, or if DELETE_OUTER is NULL. */
2657 scan_region (insn, n, delete_outer)
2664 /* Assume we can delete the region. */
2667 /* Can't delete something which is rethrown to. */
2668 if (rethrow_used (n))
2671 if (insn == NULL_RTX
2672 || GET_CODE (insn) != NOTE
2673 || NOTE_LINE_NUMBER (insn) != NOTE_INSN_EH_REGION_BEG
2674 || NOTE_EH_HANDLER (insn) != n
2675 || delete_outer == NULL)
2678 insn = NEXT_INSN (insn);
2680 /* Look for the matching end. */
2681 while (! (GET_CODE (insn) == NOTE
2682 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END))
2684 /* If anything can throw, we can't remove the region. */
2685 if (delete && can_throw (insn))
2690 /* Watch out for and handle nested regions. */
2691 if (GET_CODE (insn) == NOTE
2692 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
2694 insn = scan_region (insn, NOTE_EH_HANDLER (insn), &delete);
2697 insn = NEXT_INSN (insn);
2700 /* The _BEG/_END NOTEs must match and nest. */
2701 if (NOTE_EH_HANDLER (insn) != n)
2704 /* If anything in this exception region can throw, we can throw. */
2709 /* Delete the start and end of the region. */
2710 delete_insn (start);
2713 /* We no longer removed labels here, since flow will now remove any
2714 handler which cannot be called any more. */
2717 /* Only do this part if we have built the exception handler
2719 if (exception_handler_labels)
2721 rtx x, *prev = &exception_handler_labels;
2723 /* Find it in the list of handlers. */
2724 for (x = exception_handler_labels; x; x = XEXP (x, 1))
2726 rtx label = XEXP (x, 0);
2727 if (CODE_LABEL_NUMBER (label) == n)
2729 /* If we are the last reference to the handler,
2731 if (--LABEL_NUSES (label) == 0)
2732 delete_insn (label);
2736 /* Remove it from the list of exception handler
2737 labels, if we are optimizing. If we are not, then
2738 leave it in the list, as we are not really going to
2739 remove the region. */
2740 *prev = XEXP (x, 1);
2747 prev = &XEXP (x, 1);
2755 /* Perform various interesting optimizations for exception handling
2758 We look for empty exception regions and make them go (away). The
2759 jump optimization code will remove the handler if nothing else uses
2763 exception_optimize ()
2768 /* Remove empty regions. */
2769 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2771 if (GET_CODE (insn) == NOTE
2772 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
2774 /* Since scan_region will return the NOTE_INSN_EH_REGION_END
2775 insn, we will indirectly skip through all the insns
2776 inbetween. We are also guaranteed that the value of insn
2777 returned will be valid, as otherwise scan_region won't
2779 insn = scan_region (insn, NOTE_EH_HANDLER (insn), &n);
2784 /* This function determines whether any of the exception regions in the
2785 current function are targets of a rethrow or not, and set the
2786 reference flag according. */
2788 update_rethrow_references ()
2792 int *saw_region, *saw_rethrow;
2794 if (!flag_new_exceptions)
2797 saw_region = (int *) xcalloc (current_func_eh_entry, sizeof (int));
2798 saw_rethrow = (int *) xcalloc (current_func_eh_entry, sizeof (int));
2800 /* Determine what regions exist, and whether there are any rethrows
2801 to those regions or not. */
2802 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2803 if (GET_CODE (insn) == CALL_INSN)
2805 rtx note = find_reg_note (insn, REG_EH_RETHROW, NULL_RTX);
2808 region = eh_region_from_symbol (XEXP (note, 0));
2809 region = find_func_region (region);
2810 saw_rethrow[region] = 1;
2814 if (GET_CODE (insn) == NOTE)
2816 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
2818 region = find_func_region (NOTE_EH_HANDLER (insn));
2819 saw_region[region] = 1;
2823 /* For any regions we did see, set the referenced flag. */
2824 for (x = 0; x < current_func_eh_entry; x++)
2826 function_eh_regions[x].rethrow_ref = saw_rethrow[x];
2833 /* Various hooks for the DWARF 2 __throw routine. */
2835 /* Do any necessary initialization to access arbitrary stack frames.
2836 On the SPARC, this means flushing the register windows. */
2839 expand_builtin_unwind_init ()
2841 /* Set this so all the registers get saved in our frame; we need to be
2842 able to copy the saved values for any registers from frames we unwind. */
2843 current_function_has_nonlocal_label = 1;
2845 #ifdef SETUP_FRAME_ADDRESSES
2846 SETUP_FRAME_ADDRESSES ();
2850 /* Given a value extracted from the return address register or stack slot,
2851 return the actual address encoded in that value. */
2854 expand_builtin_extract_return_addr (addr_tree)
2857 rtx addr = expand_expr (addr_tree, NULL_RTX, Pmode, 0);
2858 return eh_outer_context (addr);
2861 /* Given an actual address in addr_tree, do any necessary encoding
2862 and return the value to be stored in the return address register or
2863 stack slot so the epilogue will return to that address. */
2866 expand_builtin_frob_return_addr (addr_tree)
2869 rtx addr = expand_expr (addr_tree, NULL_RTX, Pmode, 0);
2870 #ifdef RETURN_ADDR_OFFSET
2871 addr = plus_constant (addr, -RETURN_ADDR_OFFSET);
2876 /* Choose three registers for communication between the main body of
2877 __throw and the epilogue (or eh stub) and the exception handler.
2878 We must do this with hard registers because the epilogue itself
2879 will be generated after reload, at which point we may not reference
2882 The first passes the exception context to the handler. For this
2883 we use the return value register for a void*.
2885 The second holds the stack pointer value to be restored. For
2886 this we use the static chain register if it exists and is different
2887 from the previous, otherwise some arbitrary call-clobbered register.
2889 The third holds the address of the handler itself. Here we use
2890 some arbitrary call-clobbered register. */
2893 eh_regs (pcontext, psp, pra, outgoing)
2894 rtx *pcontext, *psp, *pra;
2895 int outgoing ATTRIBUTE_UNUSED;
2897 rtx rcontext, rsp, rra;
2900 #ifdef FUNCTION_OUTGOING_VALUE
2902 rcontext = FUNCTION_OUTGOING_VALUE (build_pointer_type (void_type_node),
2903 current_function_decl);
2906 rcontext = FUNCTION_VALUE (build_pointer_type (void_type_node),
2907 current_function_decl);
2909 #ifdef STATIC_CHAIN_REGNUM
2911 rsp = static_chain_incoming_rtx;
2913 rsp = static_chain_rtx;
2914 if (REGNO (rsp) == REGNO (rcontext))
2915 #endif /* STATIC_CHAIN_REGNUM */
2918 if (rsp == NULL_RTX)
2920 for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
2921 if (call_used_regs[i] && ! fixed_regs[i] && i != REGNO (rcontext))
2923 if (i == FIRST_PSEUDO_REGISTER)
2926 rsp = gen_rtx_REG (Pmode, i);
2929 for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
2930 if (call_used_regs[i] && ! fixed_regs[i]
2931 && i != REGNO (rcontext) && i != REGNO (rsp))
2933 if (i == FIRST_PSEUDO_REGISTER)
2936 rra = gen_rtx_REG (Pmode, i);
2938 *pcontext = rcontext;
2943 /* Retrieve the register which contains the pointer to the eh_context
2944 structure set the __throw. */
2948 get_reg_for_handler ()
2951 reg1 = FUNCTION_VALUE (build_pointer_type (void_type_node),
2952 current_function_decl);
2957 /* Set up the epilogue with the magic bits we'll need to return to the
2958 exception handler. */
2961 expand_builtin_eh_return (context, stack, handler)
2962 tree context, stack, handler;
2964 if (eh_return_context)
2965 error("Duplicate call to __builtin_eh_return");
2968 = copy_to_reg (expand_expr (context, NULL_RTX, VOIDmode, 0));
2969 eh_return_stack_adjust
2970 = copy_to_reg (expand_expr (stack, NULL_RTX, VOIDmode, 0));
2972 = copy_to_reg (expand_expr (handler, NULL_RTX, VOIDmode, 0));
2978 rtx reg1, reg2, reg3;
2979 rtx stub_start, after_stub;
2982 if (!eh_return_context)
2985 current_function_cannot_inline = N_("function uses __builtin_eh_return");
2987 eh_regs (®1, ®2, ®3, 1);
2988 #ifdef POINTERS_EXTEND_UNSIGNED
2989 eh_return_context = convert_memory_address (Pmode, eh_return_context);
2990 eh_return_stack_adjust =
2991 convert_memory_address (Pmode, eh_return_stack_adjust);
2992 eh_return_handler = convert_memory_address (Pmode, eh_return_handler);
2994 emit_move_insn (reg1, eh_return_context);
2995 emit_move_insn (reg2, eh_return_stack_adjust);
2996 emit_move_insn (reg3, eh_return_handler);
2998 /* Talk directly to the target's epilogue code when possible. */
3000 #ifdef HAVE_eh_epilogue
3001 if (HAVE_eh_epilogue)
3003 emit_insn (gen_eh_epilogue (reg1, reg2, reg3));
3008 /* Otherwise, use the same stub technique we had before. */
3010 eh_return_stub_label = stub_start = gen_label_rtx ();
3011 after_stub = gen_label_rtx ();
3013 /* Set the return address to the stub label. */
3015 ra = expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
3016 0, hard_frame_pointer_rtx);
3017 if (GET_CODE (ra) == REG && REGNO (ra) >= FIRST_PSEUDO_REGISTER)
3020 tmp = memory_address (Pmode, gen_rtx_LABEL_REF (Pmode, stub_start));
3021 #ifdef RETURN_ADDR_OFFSET
3022 tmp = plus_constant (tmp, -RETURN_ADDR_OFFSET);
3024 tmp = force_operand (tmp, ra);
3026 emit_move_insn (ra, tmp);
3028 /* Indicate that the registers are in fact used. */
3029 emit_insn (gen_rtx_USE (VOIDmode, reg1));
3030 emit_insn (gen_rtx_USE (VOIDmode, reg2));
3031 emit_insn (gen_rtx_USE (VOIDmode, reg3));
3032 if (GET_CODE (ra) == REG)
3033 emit_insn (gen_rtx_USE (VOIDmode, ra));
3035 /* Generate the stub. */
3037 emit_jump (after_stub);
3038 emit_label (stub_start);
3040 eh_regs (®1, ®2, ®3, 0);
3041 adjust_stack (reg2);
3042 emit_indirect_jump (reg3);
3044 emit_label (after_stub);
3048 /* This contains the code required to verify whether arbitrary instructions
3049 are in the same exception region. */
3051 static int *insn_eh_region = (int *)0;
3052 static int maximum_uid;
3055 set_insn_eh_region (first, region_num)
3062 for (insn = *first; insn; insn = NEXT_INSN (insn))
3064 if ((GET_CODE (insn) == NOTE)
3065 && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG))
3067 rnum = NOTE_EH_HANDLER (insn);
3068 insn_eh_region[INSN_UID (insn)] = rnum;
3069 insn = NEXT_INSN (insn);
3070 set_insn_eh_region (&insn, rnum);
3071 /* Upon return, insn points to the EH_REGION_END of nested region */
3074 insn_eh_region[INSN_UID (insn)] = region_num;
3075 if ((GET_CODE (insn) == NOTE) &&
3076 (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END))
3082 /* Free the insn table, an make sure it cannot be used again. */
3085 free_insn_eh_region ()
3092 free (insn_eh_region);
3093 insn_eh_region = (int *)0;
3097 /* Initialize the table. max_uid must be calculated and handed into
3098 this routine. If it is unavailable, passing a value of 0 will
3099 cause this routine to calculate it as well. */
3102 init_insn_eh_region (first, max_uid)
3112 free_insn_eh_region();
3115 for (insn = first; insn; insn = NEXT_INSN (insn))
3116 if (INSN_UID (insn) > max_uid) /* find largest UID */
3117 max_uid = INSN_UID (insn);
3119 maximum_uid = max_uid;
3120 insn_eh_region = (int *) xmalloc ((max_uid + 1) * sizeof (int));
3122 set_insn_eh_region (&insn, 0);
3126 /* Check whether 2 instructions are within the same region. */
3129 in_same_eh_region (insn1, insn2)
3132 int ret, uid1, uid2;
3134 /* If no exceptions, instructions are always in same region. */
3138 /* If the table isn't allocated, assume the worst. */
3139 if (!insn_eh_region)
3142 uid1 = INSN_UID (insn1);
3143 uid2 = INSN_UID (insn2);
3145 /* if instructions have been allocated beyond the end, either
3146 the table is out of date, or this is a late addition, or
3147 something... Assume the worst. */
3148 if (uid1 > maximum_uid || uid2 > maximum_uid)
3151 ret = (insn_eh_region[uid1] == insn_eh_region[uid2]);
3156 /* This function will initialize the handler list for a specified block.
3157 It may recursively call itself if the outer block hasn't been processed
3158 yet. At some point in the future we can trim out handlers which we
3159 know cannot be called. (ie, if a block has an INT type handler,
3160 control will never be passed to an outer INT type handler). */
3162 process_nestinfo (block, info, nested_eh_region)
3164 eh_nesting_info *info;
3165 int *nested_eh_region;
3167 handler_info *ptr, *last_ptr = NULL;
3168 int x, y, count = 0;
3170 handler_info **extra_handlers = 0;
3171 int index = info->region_index[block];
3173 /* If we've already processed this block, simply return. */
3174 if (info->num_handlers[index] > 0)
3177 for (ptr = get_first_handler (block); ptr; last_ptr = ptr, ptr = ptr->next)
3180 /* pick up any information from the next outer region. It will already
3181 contain a summary of itself and all outer regions to it. */
3183 if (nested_eh_region [block] != 0)
3185 int nested_index = info->region_index[nested_eh_region[block]];
3186 process_nestinfo (nested_eh_region[block], info, nested_eh_region);
3187 extra = info->num_handlers[nested_index];
3188 extra_handlers = info->handlers[nested_index];
3189 info->outer_index[index] = nested_index;
3192 /* If the last handler is either a CATCH_ALL or a cleanup, then we
3193 won't use the outer ones since we know control will not go past the
3194 catch-all or cleanup. */
3196 if (last_ptr != NULL && (last_ptr->type_info == NULL
3197 || last_ptr->type_info == CATCH_ALL_TYPE))
3200 info->num_handlers[index] = count + extra;
3201 info->handlers[index] = (handler_info **) xmalloc ((count + extra)
3202 * sizeof (handler_info **));
3204 /* First put all our handlers into the list. */
3205 ptr = get_first_handler (block);
3206 for (x = 0; x < count; x++)
3208 info->handlers[index][x] = ptr;
3212 /* Now add all the outer region handlers, if they aren't they same as
3213 one of the types in the current block. We won't worry about
3214 derived types yet, we'll just look for the exact type. */
3215 for (y =0, x = 0; x < extra ; x++)
3219 /* Check to see if we have a type duplication. */
3220 for (i = 0; i < count; i++)
3221 if (info->handlers[index][i]->type_info == extra_handlers[x]->type_info)
3224 /* Record one less handler. */
3225 (info->num_handlers[index])--;
3230 info->handlers[index][y + count] = extra_handlers[x];
3236 /* This function will allocate and initialize an eh_nesting_info structure.
3237 It returns a pointer to the completed data structure. If there are
3238 no exception regions, a NULL value is returned. */
3240 init_eh_nesting_info ()
3242 int *nested_eh_region;
3243 int region_count = 0;
3244 rtx eh_note = NULL_RTX;
3245 eh_nesting_info *info;
3249 info = (eh_nesting_info *) xmalloc (sizeof (eh_nesting_info));
3250 info->region_index = (int *) xcalloc ((max_label_num () + 1), sizeof (int));
3251 nested_eh_region = (int *) xcalloc (max_label_num () + 1, sizeof (int));
3253 /* Create the nested_eh_region list. If indexed with a block number, it
3254 returns the block number of the next outermost region, if any.
3255 We can count the number of regions and initialize the region_index
3256 vector at the same time. */
3257 for (insn = get_insns(); insn; insn = NEXT_INSN (insn))
3259 if (GET_CODE (insn) == NOTE)
3261 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
3263 int block = NOTE_EH_HANDLER (insn);
3265 info->region_index[block] = region_count;
3267 nested_eh_region [block] =
3268 NOTE_EH_HANDLER (XEXP (eh_note, 0));
3270 nested_eh_region [block] = 0;
3271 eh_note = gen_rtx_EXPR_LIST (VOIDmode, insn, eh_note);
3273 else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END)
3274 eh_note = XEXP (eh_note, 1);
3278 /* If there are no regions, wrap it up now. */
3279 if (region_count == 0)
3281 free (info->region_index);
3283 free (nested_eh_region);
3288 info->handlers = (handler_info ***) xcalloc (region_count,
3289 sizeof (handler_info ***));
3290 info->num_handlers = (int *) xcalloc (region_count, sizeof (int));
3291 info->outer_index = (int *) xcalloc (region_count, sizeof (int));
3293 /* Now initialize the handler lists for all exception blocks. */
3294 for (x = 0; x <= max_label_num (); x++)
3296 if (info->region_index[x] != 0)
3297 process_nestinfo (x, info, nested_eh_region);
3299 info->region_count = region_count;
3302 free (nested_eh_region);
3308 /* This function is used to retreive the vector of handlers which
3309 can be reached by a given insn in a given exception region.
3310 BLOCK is the exception block the insn is in.
3311 INFO is the eh_nesting_info structure.
3312 INSN is the (optional) insn within the block. If insn is not NULL_RTX,
3313 it may contain reg notes which modify its throwing behavior, and
3314 these will be obeyed. If NULL_RTX is passed, then we simply return the
3316 HANDLERS is the address of a pointer to a vector of handler_info pointers.
3317 Upon return, this will have the handlers which can be reached by block.
3318 This function returns the number of elements in the handlers vector. */
3320 reachable_handlers (block, info, insn, handlers)
3322 eh_nesting_info *info;
3324 handler_info ***handlers;
3332 index = info->region_index[block];
3334 if (insn && GET_CODE (insn) == CALL_INSN)
3336 /* RETHROWs specify a region number from which we are going to rethrow.
3337 This means we wont pass control to handlers in the specified
3338 region, but rather any region OUTSIDE the specified region.
3339 We accomplish this by setting block to the outer_index of the
3340 specified region. */
3341 rtx note = find_reg_note (insn, REG_EH_RETHROW, NULL_RTX);
3344 index = eh_region_from_symbol (XEXP (note, 0));
3345 index = info->region_index[index];
3347 index = info->outer_index[index];
3351 /* If there is no rethrow, we look for a REG_EH_REGION, and
3352 we'll throw from that block. A value of 0 or less
3353 indicates that this insn cannot throw. */
3354 note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
3357 int b = XINT (XEXP (note, 0), 0);
3361 index = info->region_index[b];
3365 /* If we reach this point, and index is 0, there is no throw. */
3369 *handlers = info->handlers[index];
3370 return info->num_handlers[index];
3374 /* This function will free all memory associated with the eh_nesting info. */
3377 free_eh_nesting_info (info)
3378 eh_nesting_info *info;
3383 if (info->region_index)
3384 free (info->region_index);
3385 if (info->num_handlers)
3386 free (info->num_handlers);
3387 if (info->outer_index)
3388 free (info->outer_index);
3391 for (x = 0; x < info->region_count; x++)
3392 if (info->handlers[x])
3393 free (info->handlers[x]);
3394 free (info->handlers);