OSDN Git Service

71925a575b18f311a0e5e560a4a362fa4dad8a4b
[pf3gnuchains/gcc-fork.git] / gcc / except.c
1 /* Implements exception handling.
2    Copyright (C) 1989, 92-95, 1996 Free Software Foundation, Inc.
3    Contributed by Mike Stump <mrs@cygnus.com>.
4
5 This file is part of GNU CC.
6
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING.  If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.  */
21
22
23 /* 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 assocated with a function call
27    several levels up the stack.
28
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.
38
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.
45
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.  -fnosjlj-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
54    based approach.
55
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
59    exception.
60
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
66    function boundaries.
67
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
72    stack.
73
74    In the current implementaion, 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
82    this will change).
83
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
88    that region.
89
90    At program startup each object file invokes a function named
91    __register_exceptions with the address of its local
92    __EXCEPTION_TABLE__. __register_exceptions is defined in libgcc2.c,
93    and is responsible for recording all of the exception regions into
94    one list (which is kept in a static variable named exception_table_list).
95
96    The function __throw is actually responsible for doing the
97    throw. In the C++ frontend, __throw is generated on a
98    per-object-file basis for each source file compiled with
99    -fexceptions. Before __throw is invoked, the current context
100    of the throw needs to be placed in the global variable __eh_pc.
101
102    __throw attempts to find the appropriate exception handler for the 
103    PC value stored in __eh_pc by calling __find_first_exception_table_match
104    (which is defined in libgcc2.c). If __find_first_exception_table_match
105    finds a relevant handler, __throw jumps directly to it.
106
107    If a handler for the context being thrown from can't be found,
108    __throw is responsible for unwinding the stack, determining the
109    address of the caller of the current function (which will be used
110    as the new context to throw from), and then restarting the process
111    of searching for a handler for the new context. __throw may also
112    call abort if it is unable to unwind the stack, and can also
113    call an external library function named __terminate if it reaches
114    the top of the stack without finding an appropriate handler. (By
115    default __terminate invokes abort, but this behavior can be
116    changed by the user to perform some sort of cleanup behavior before
117    exiting).
118
119    Internal implementation details:
120
121    To associate a user-defined handler with a block of statements, the
122    function expand_start_try_stmts is used to mark the start of the
123    block of statements with which the handler is to be associated
124    (which is known as a "try block"). All statements that appear
125    afterwards will be associated with the try block.
126
127    A call to expand_start_all_catch marks the end of the try block,
128    and also marks the start of the "catch block" (the user-defined
129    handler) associated with the try block.
130
131    This user-defined handler will be invoked for *every* exception
132    thrown with the context of the try block. It is up to the handler
133    to decide whether or not it wishes to handle any given exception,
134    as there is currently no mechanism in this implementation for doing
135    this. (There are plans for conditionally processing an exception
136    based on its "type", which will provide a language-independent
137    mechanism).
138
139    If the handler chooses not to process the exception (perhaps by
140    looking at an "exception type" or some other additional data
141    supplied with the exception), it can fall through to the end of the
142    handler. expand_end_all_catch and expand_leftover_cleanups
143    add additional code to the end of each handler to take care of
144    rethrowing to the outer exception handler.
145
146    The handler also has the option to continue with "normal flow of
147    code", or in other words to resume executing at the statement
148    immediately after the end of the exception region. The variable
149    caught_return_label_stack contains a stack of labels, and jumping
150    to the topmost entry's label via expand_goto will resume normal
151    flow to the statement immediately after the end of the exception
152    region. If the handler falls through to the end, the exception will
153    be rethrown to the outer exception region.
154
155    The instructions for the catch block are kept as a separate
156    sequence, and will be emitted at the end of the function along with
157    the handlers specified via expand_eh_region_end. The end of the
158    catch block is marked with expand_end_all_catch.
159
160    Any data associated with the exception must currently be handled by
161    some external mechanism maintained in the frontend.  For example,
162    the C++ exception mechanism passes an arbitrary value along with
163    the exception, and this is handled in the C++ frontend by using a
164    global variable to hold the value. (This will be changing in the
165    future.)
166
167    The mechanism in C++ for handling data associated with the
168    exception is clearly not thread-safe. For a thread-based
169    environment, another mechanism must be used (possibly using a
170    per-thread allocation mechanism if the size of the area that needs
171    to be allocated isn't known at compile time.)
172
173    Internally-generated exception regions (cleanups) are marked by
174    calling expand_eh_region_start to mark the start of the region,
175    and expand_eh_region_end (handler) is used to both designate the
176    end of the region and to associate a specified handler/cleanup with
177    the region. The rtl code in HANDLER will be invoked whenever an
178    exception occurs in the region between the calls to
179    expand_eh_region_start and expand_eh_region_end. After HANDLER is
180    executed, additional code is emitted to handle rethrowing the
181    exception to the outer exception handler. The code for HANDLER will
182    be emitted at the end of the function.
183
184    TARGET_EXPRs can also be used to designate exception regions. A
185    TARGET_EXPR gives an unwind-protect style interface commonly used
186    in functional languages such as LISP. The associated expression is
187    evaluated, and whether or not it (or any of the functions that it
188    calls) throws an exception, the protect expression is always
189    invoked. This implementation takes care of the details of
190    associating an exception table entry with the expression and
191    generating the necessary code (it actually emits the protect
192    expression twice, once for normal flow and once for the exception
193    case). As for the other handlers, the code for the exception case
194    will be emitted at the end of the function.
195
196    Cleanups can also be specified by using add_partial_entry (handler)
197    and end_protect_partials. add_partial_entry creates the start of
198    a new exception region; HANDLER will be invoked if an exception is
199    thrown with the context of the region between the calls to
200    add_partial_entry and end_protect_partials. end_protect_partials is
201    used to mark the end of these regions. add_partial_entry can be
202    called as many times as needed before calling end_protect_partials.
203    However, end_protect_partials should only be invoked once for each
204    group of calls to add_partial_entry as the entries are queued
205    and all of the outstanding entries are processed simultaneously
206    when end_protect_partials is invoked. Similarly to the other
207    handlers, the code for HANDLER will be emitted at the end of the
208    function.
209
210    The generated RTL for an exception region includes
211    NOTE_INSN_EH_REGION_BEG and NOTE_INSN_EH_REGION_END notes that mark
212    the start and end of the exception region. A unique label is also
213    generated at the start of the exception region, which is available
214    by looking at the ehstack variable. The topmost entry corresponds
215    to the current region.
216
217    In the current implementation, an exception can only be thrown from
218    a function call (since the mechanism used to actually throw an
219    exception involves calling __throw).  If an exception region is
220    created but no function calls occur within that region, the region
221    can be safely optimized away (along with its exception handlers)
222    since no exceptions can ever be caught in that region.  This
223    optimization is performed unless -fasynchronous-exceptions is
224    given.  If the user wishes to throw from a signal handler, or other
225    asynchronous place, -fasynchronous-exceptions should be used when
226    compiling for maximally correct code, at the cost of additional
227    exception regions.  Using -fasynchronous-exceptions only produces
228    code that is reasonably safe in such situations, but a correct
229    program cannot rely upon this working.  It can be used in failsafe
230    code, where trying to continue on, and proceeding with potentially
231    incorrect results is better than halting the program.
232
233
234    Unwinding the stack:
235
236    The details of unwinding the stack to the next frame can be rather
237    complex. While in many cases a generic __unwind_function routine
238    can be used by the generated exception handling code to do this, it
239    is often necessary to generate inline code to do the unwinding.
240
241    Whether or not these inlined unwinders are necessary is
242    target-specific.
243
244    By default, if the target-specific backend doesn't supply a
245    definition for __unwind_function, inlined unwinders will be used
246    instead. The main tradeoff here is in text space utilization.
247    Obviously, if inline unwinders have to be generated repeatedly,
248    this uses much more space than if a single routine is used.
249
250    However, it is simply not possible on some platforms to write a
251    generalized routine for doing stack unwinding without having some
252    form of additional data associated with each function. The current
253    implementation encodes this data in the form of additional machine
254    instructions. This is clearly not desirable, as it is extremely
255    inefficient. The next implementation will provide a set of metadata
256    for each function that will provide the needed information.
257
258    The backend macro DOESNT_NEED_UNWINDER is used to conditionalize
259    whether or not per-function unwinders are needed. If DOESNT_NEED_UNWINDER
260    is defined and has a non-zero value, a per-function unwinder is
261    not emitted for the current function.
262
263    On some platforms it is possible that neither __unwind_function
264    nor inlined unwinders are available. For these platforms it is not
265    possible to throw through a function call, and abort will be
266    invoked instead of performing the throw. 
267
268    Future directions:
269
270    Currently __throw makes no differentiation between cleanups and
271    user-defined exception regions. While this makes the implementation
272    simple, it also implies that it is impossible to determine if a
273    user-defined exception handler exists for a given exception without
274    completely unwinding the stack in the process. This is undesirable
275    from the standpoint of debugging, as ideally it would be possible
276    to trap unhandled exceptions in the debugger before the process of
277    unwinding has even started.
278
279    This problem can be solved by marking user-defined handlers in a
280    special way (probably by adding additional bits to exception_table_list).
281    A two-pass scheme could then be used by __throw to iterate
282    through the table. The first pass would search for a relevant
283    user-defined handler for the current context of the throw, and if
284    one is found, the second pass would then invoke all needed cleanups
285    before jumping to the user-defined handler.
286
287    Many languages (including C++ and Ada) make execution of a
288    user-defined handler conditional on the "type" of the exception
289    thrown. (The type of the exception is actually the type of the data
290    that is thrown with the exception.) It will thus be necessary for
291    __throw to be able to determine if a given user-defined
292    exception handler will actually be executed, given the type of
293    exception.
294
295    One scheme is to add additional information to exception_table_list
296    as to the types of exceptions accepted by each handler. __throw
297    can do the type comparisons and then determine if the handler is
298    actually going to be executed.
299
300    There is currently no significant level of debugging support
301    available, other than to place a breakpoint on __throw. While
302    this is sufficient in most cases, it would be helpful to be able to
303    know where a given exception was going to be thrown to before it is
304    actually thrown, and to be able to choose between stopping before
305    every exception region (including cleanups), or just user-defined
306    exception regions. This should be possible to do in the two-pass
307    scheme by adding additional labels to __throw for appropriate
308    breakpoints, and additional debugger commands could be added to
309    query various state variables to determine what actions are to be
310    performed next.
311
312    Another major problem that is being worked on is the issue with
313    stack unwinding on various platforms. Currently the only platform
314    that has support for __unwind_function is the Sparc; all other
315    ports require per-function unwinders, which causes large amounts of
316    code bloat.
317
318    Ideally it would be possible to store a small set of metadata with
319    each function that would then make it possible to write a
320    __unwind_function for every platform. This would eliminate the
321    need for per-function unwinders.
322
323    The main reason the data is needed is that on some platforms the
324    order and types of data stored on the stack can vary depending on
325    the type of function, its arguments and returned values, and the
326    compilation options used (optimization versus non-optimization,
327    -fomit-frame-pointer, processor variations, etc).
328
329    Unfortunately, this also means that throwing through functions that
330    aren't compiled with exception handling support will still not be
331    possible on some platforms. This problem is currently being
332    investigated, but no solutions have been found that do not imply
333    some unacceptable performance penalties.
334
335    For setjmp/longjmp based exception handling, some of the details
336    are as above, but there are some additional details.  This section
337    discusses the details.
338
339    We don't use NOTE_INSN_EH_REGION_{BEG,END} pairs.  We don't
340    optimize EH regions yet.  We don't have to worry about machine
341    specific issues with unwinding the stack, as we rely upon longjmp
342    for all the machine specific details.  There is no variable context
343    of a throw, just the one implied by the dynamic handler stack
344    pointed to by the dynamic handler chain.  There is no exception
345    table, and no calls to __register_excetpions.  __sjthrow is used
346    instead of __throw, and it works by using the dynamic handler
347    chain, and longjmp.  -fasynchronous-exceptions has no effect, as
348    the elimination of trivial exception regions is not yet performed.
349
350    A frontend can set protect_cleanup_actions_with_terminate when all
351    the cleanup actions should be protected with an EH region that
352    calls terminate when an unhandled exception is throw.  C++ does
353    this, Ada does not.  */
354
355
356 #include "config.h"
357 #include <stdio.h>
358 #include "rtl.h"
359 #include "tree.h"
360 #include "flags.h"
361 #include "except.h"
362 #include "function.h"
363 #include "insn-flags.h"
364 #include "expr.h"
365 #include "insn-codes.h"
366 #include "regs.h"
367 #include "hard-reg-set.h"
368 #include "insn-config.h"
369 #include "recog.h"
370 #include "output.h"
371 #include "assert.h"
372
373 /* One to use setjmp/longjmp method of generating code for exception
374    handling.  */
375
376 int exceptions_via_longjmp = 1;
377
378 /* One to enable asynchronous exception support.  */
379
380 int asynchronous_exceptions = 0;
381
382 /* One to protect cleanup actions with a handler that calls
383    __terminate, zero otherwise.  */
384
385 int protect_cleanup_actions_with_terminate = 0;
386
387 /* A list of labels used for exception handlers.  Created by
388    find_exception_handler_labels for the optimization passes.  */
389
390 rtx exception_handler_labels;
391
392 /* Nonzero means that __throw was invoked. 
393
394    This is used by the C++ frontend to know if code needs to be emitted
395    for __throw or not.  */
396
397 int throw_used;
398
399 /* The dynamic handler chain.  Nonzero if the function has already
400    fetched a pointer to the dynamic handler chain for exception
401    handling.  */
402
403 rtx current_function_dhc;
404
405 /* The dynamic cleanup chain.  Nonzero if the function has already
406    fetched a pointer to the dynamic cleanup chain for exception
407    handling.  */
408
409 rtx current_function_dcc;
410
411 /* A stack used for keeping track of the currectly active exception
412    handling region.  As each exception region is started, an entry
413    describing the region is pushed onto this stack.  The current
414    region can be found by looking at the top of the stack, and as we
415    exit regions, the corresponding entries are popped. 
416
417    Entries cannot overlap; they can be nested. So there is only one
418    entry at most that corresponds to the current instruction, and that
419    is the entry on the top of the stack.  */
420
421 static struct eh_stack ehstack;
422
423 /* A queue used for tracking which exception regions have closed but
424    whose handlers have not yet been expanded. Regions are emitted in
425    groups in an attempt to improve paging performance.
426
427    As we exit a region, we enqueue a new entry. The entries are then
428    dequeued during expand_leftover_cleanups and expand_start_all_catch,
429
430    We should redo things so that we either take RTL for the handler,
431    or we expand the handler expressed as a tree immediately at region
432    end time.  */
433
434 static struct eh_queue ehqueue;
435
436 /* Insns for all of the exception handlers for the current function.
437    They are currently emitted by the frontend code.  */
438
439 rtx catch_clauses;
440
441 /* A TREE_CHAINed list of handlers for regions that are not yet
442    closed. The TREE_VALUE of each entry contains the handler for the
443    corresponding entry on the ehstack.  */
444
445 static tree protect_list;
446
447 /* Stacks to keep track of various labels.  */
448
449 /* Keeps track of the label to resume to should one want to resume
450    normal control flow out of a handler (instead of, say, returning to
451    the caller of the current function or exiting the program).  Also
452    used as the context of a throw to rethrow an exception to the outer
453    exception region.  */
454
455 struct label_node *caught_return_label_stack = NULL;
456
457 /* A random data area for the front end's own use.  */
458
459 struct label_node *false_label_stack = NULL;
460
461 /* The rtx and the tree for the saved PC value.  */
462
463 rtx eh_saved_pc_rtx;
464 tree eh_saved_pc;
465
466 rtx expand_builtin_return_addr  PROTO((enum built_in_function, int, rtx));
467 \f
468 /* Various support routines to manipulate the various data structures
469    used by the exception handling code.  */
470
471 /* Push a label entry onto the given STACK.  */
472
473 void
474 push_label_entry (stack, rlabel, tlabel)
475      struct label_node **stack;
476      rtx rlabel;
477      tree tlabel;
478 {
479   struct label_node *newnode
480     = (struct label_node *) xmalloc (sizeof (struct label_node));
481
482   if (rlabel)
483     newnode->u.rlabel = rlabel;
484   else
485     newnode->u.tlabel = tlabel;
486   newnode->chain = *stack;
487   *stack = newnode;
488 }
489
490 /* Pop a label entry from the given STACK.  */
491
492 rtx
493 pop_label_entry (stack)
494      struct label_node **stack;
495 {
496   rtx label;
497   struct label_node *tempnode;
498
499   if (! *stack)
500     return NULL_RTX;
501
502   tempnode = *stack;
503   label = tempnode->u.rlabel;
504   *stack = (*stack)->chain;
505   free (tempnode);
506
507   return label;
508 }
509
510 /* Return the top element of the given STACK.  */
511
512 tree
513 top_label_entry (stack)
514      struct label_node **stack;
515 {
516   if (! *stack)
517     return NULL_TREE;
518
519   return (*stack)->u.tlabel;
520 }
521
522 /* Make a copy of ENTRY using xmalloc to allocate the space.  */
523
524 static struct eh_entry *
525 copy_eh_entry (entry)
526      struct eh_entry *entry;
527 {
528   struct eh_entry *newentry;
529
530   newentry = (struct eh_entry *) xmalloc (sizeof (struct eh_entry));
531   bcopy ((char *) entry, (char *) newentry, sizeof (struct eh_entry));
532
533   return newentry;
534 }
535
536 /* Push a new eh_node entry onto STACK, and return the start label for
537    the entry.  */
538
539 static rtx
540 push_eh_entry (stack)
541      struct eh_stack *stack;
542 {
543   struct eh_node *node = (struct eh_node *) xmalloc (sizeof (struct eh_node));
544   struct eh_entry *entry = (struct eh_entry *) xmalloc (sizeof (struct eh_entry));
545
546   entry->start_label = gen_label_rtx ();
547   entry->end_label = gen_label_rtx ();
548   entry->exception_handler_label = gen_label_rtx ();
549   entry->finalization = NULL_TREE;
550
551   node->entry = entry;
552   node->chain = stack->top;
553   stack->top = node;
554
555   return entry->start_label;
556 }
557
558 /* Pop an entry from the given STACK.  */
559
560 static struct eh_entry *
561 pop_eh_entry (stack)
562      struct eh_stack *stack;
563 {
564   struct eh_node *tempnode;
565   struct eh_entry *tempentry;
566   
567   tempnode = stack->top;
568   tempentry = tempnode->entry;
569   stack->top = stack->top->chain;
570   free (tempnode);
571
572   return tempentry;
573 }
574
575 /* Enqueue an ENTRY onto the given QUEUE.  */
576
577 static void
578 enqueue_eh_entry (queue, entry)
579      struct eh_queue *queue;
580      struct eh_entry *entry;
581 {
582   struct eh_node *node = (struct eh_node *) xmalloc (sizeof (struct eh_node));
583
584   node->entry = entry;
585   node->chain = NULL;
586
587   if (queue->head == NULL)
588     {
589       queue->head = node;
590     }
591   else
592     {
593       queue->tail->chain = node;
594     }
595   queue->tail = node;
596 }
597
598 /* Dequeue an entry from the given QUEUE.  */
599
600 static struct eh_entry *
601 dequeue_eh_entry (queue)
602      struct eh_queue *queue;
603 {
604   struct eh_node *tempnode;
605   struct eh_entry *tempentry;
606
607   if (queue->head == NULL)
608     return NULL;
609
610   tempnode = queue->head;
611   queue->head = queue->head->chain;
612
613   tempentry = tempnode->entry;
614   free (tempnode);
615
616   return tempentry;
617 }
618 \f
619 /* Routine to see if exception exception handling is turned on.
620    DO_WARN is non-zero if we want to inform the user that exception
621    handling is turned off. 
622
623    This is used to ensure that -fexceptions has been specified if the
624    compiler tries to use any exception-specific functions.  */
625
626 int
627 doing_eh (do_warn)
628      int do_warn;
629 {
630   if (! flag_exceptions)
631     {
632       static int warned = 0;
633       if (! warned && do_warn)
634         {
635           error ("exception handling disabled, use -fexceptions to enable");
636           warned = 1;
637         }
638       return 0;
639     }
640   return 1;
641 }
642
643 /* Given a return address in ADDR, determine the address we should use
644    to find the corresponding EH region.  */
645
646 rtx
647 eh_outer_context (addr)
648      rtx addr;
649 {
650   /* First mask out any unwanted bits.  */
651 #ifdef MASK_RETURN_ADDR
652   emit_insn (gen_rtx (SET, Pmode,
653                       addr,
654                       gen_rtx (AND, Pmode,
655                                addr, MASK_RETURN_ADDR)));
656 #endif
657
658   /* Then subtract out enough to get into the appropriate region.  If
659      this is defined, assume we don't need to subtract anything as it
660      is already within the correct region.  */
661 #if ! defined (RETURN_ADDR_OFFSET)
662   addr = plus_constant (addr, -1);
663 #endif
664
665   return addr;
666 }
667
668 /* Start a new exception region for a region of code that has a
669    cleanup action and push the HANDLER for the region onto
670    protect_list. All of the regions created with add_partial_entry
671    will be ended when end_protect_partials is invoked.  */
672
673 void
674 add_partial_entry (handler)
675      tree handler;
676 {
677   expand_eh_region_start ();
678
679   /* Make sure the entry is on the correct obstack.  */
680   push_obstacks_nochange ();
681   resume_temporary_allocation ();
682
683   /* Because this is a cleanup action, we may have to protect the handler
684      with __terminate.  */
685   handler = protect_with_terminate (handler);
686
687   protect_list = tree_cons (NULL_TREE, handler, protect_list);
688   pop_obstacks ();
689 }
690
691 /* Get a reference to the dynamic handler chain.  It points to the
692    pointer to the next element in the dynamic handler chain.  It ends
693    when there are no more elements in the dynamic handler chain, when
694    the value is &top_elt from libgcc2.c.  Immediately after the
695    pointer, is an area suitable for setjmp/longjmp when
696    USE_BUILTIN_SETJMP isn't defined, and an area suitable for
697    __builtin_setjmp/__builtin_longjmp when USE_BUILTIN_SETJMP is
698    defined.
699
700    This routine is here to facilitate the porting of this code to
701    systems with threads.  One can either replace the routine we emit a
702    call for here in libgcc2.c, or one can modify this routine to work
703    with their thread system.  */
704
705 rtx
706 get_dynamic_handler_chain ()
707 {
708 #if 0
709   /* Do this once we figure out how to get this to the front of the
710      function, and we really only want one per real function, not one
711      per inlined function.  */
712   if (current_function_dhc == 0)
713     {
714       rtx dhc, insns;
715       start_sequence ();
716
717       dhc = emit_library_call_value (get_dynamic_handler_chain_libfunc,
718                                      NULL_RTX, 1,
719                                      Pmode, 0);
720       current_function_dhc = copy_to_reg (dhc);
721       insns = get_insns ();
722       end_sequence ();
723       emit_insns_before (insns, get_first_nonparm_insn ());
724     }
725 #else
726   rtx dhc;
727   dhc = emit_library_call_value (get_dynamic_handler_chain_libfunc,
728                                  NULL_RTX, 1,
729                                  Pmode, 0);
730   current_function_dhc = copy_to_reg (dhc);
731 #endif
732
733   /* We don't want a copy of the dhc, but rather, the single dhc.  */
734   return gen_rtx (MEM, Pmode, current_function_dhc);
735 }
736
737 /* Get a reference to the dynamic cleanup chain.  It points to the
738    pointer to the next element in the dynamic cleanup chain.
739    Immediately after the pointer, are two Pmode variables, one for a
740    pointer to a function that performs the cleanup action, and the
741    second, the argument to pass to that function.  */
742
743 rtx
744 get_dynamic_cleanup_chain ()
745 {
746   rtx dhc, dcc;
747
748   dhc = get_dynamic_handler_chain ();
749   dcc = plus_constant (dhc, GET_MODE_SIZE (Pmode));
750
751   current_function_dcc = copy_to_reg (dcc);
752
753   /* We don't want a copy of the dcc, but rather, the single dcc.  */
754   return gen_rtx (MEM, Pmode, current_function_dcc);
755 }
756
757 /* Generate code to evaluate X and jump to LABEL if the value is nonzero.
758    LABEL is an rtx of code CODE_LABEL, in this function.  */
759
760 void
761 jumpif_rtx (x, label)
762      rtx x;
763      rtx label;
764 {
765   jumpif (make_tree (type_for_mode (GET_MODE (x), 0), x), label);
766 }
767
768 /* Generate code to evaluate X and jump to LABEL if the value is zero.
769    LABEL is an rtx of code CODE_LABEL, in this function.  */
770
771 void
772 jumpifnot_rtx (x, label)
773      rtx x;
774      rtx label;
775 {
776   jumpifnot (make_tree (type_for_mode (GET_MODE (x), 0), x), label);
777 }
778
779 /* Start a dynamic cleanup on the EH runtime dynamic cleanup stack.
780    We just need to create an element for the cleanup list, and push it
781    into the chain.
782
783    A dynamic cleanup is a cleanup action implied by the presence of an
784    element on the EH runtime dynamic cleanup stack that is to be
785    performed when an exception is thrown.  The cleanup action is
786    performed by __sjthrow when an exception is thrown.  Only certain
787    actions can be optimized into dynamic cleanup actions.  For the
788    restrictions on what actions can be performed using this routine,
789    see expand_eh_region_start_tree.  */
790
791 static void
792 start_dynamic_cleanup (func, arg)
793      tree func;
794      tree arg;
795 {
796   rtx dhc, dcc;
797   rtx new_func, new_arg;
798   rtx x, buf;
799   int size;
800
801   /* We allocate enough room for a pointer to the function, and
802      one argument.  */
803   size = 2;
804
805   /* XXX, FIXME: The stack space allocated this way is too long lived,
806      but there is no allocation routine that allocates at the level of
807      the last binding contour.  */
808   buf = assign_stack_local (BLKmode,
809                             GET_MODE_SIZE (Pmode)*(size+1),
810                             0);
811
812   buf = change_address (buf, Pmode, NULL_RTX);
813
814   /* Store dcc into the first word of the newly allocated buffer.  */
815
816   dcc = get_dynamic_cleanup_chain ();
817   emit_move_insn (buf, dcc);
818
819   /* Store func and arg into the cleanup list element.  */
820
821   new_func = gen_rtx (MEM, Pmode, plus_constant (XEXP (buf, 0),
822                                                  GET_MODE_SIZE (Pmode)));
823   new_arg = gen_rtx (MEM, Pmode, plus_constant (XEXP (buf, 0),
824                                                 GET_MODE_SIZE (Pmode)*2));
825   x = expand_expr (func, new_func, Pmode, 0);
826   if (x != new_func)
827     emit_move_insn (new_func, x);
828
829   x = expand_expr (arg, new_arg, Pmode, 0);
830   if (x != new_arg)
831     emit_move_insn (new_arg, x);
832
833   /* Update the cleanup chain.  */
834
835   emit_move_insn (dcc, XEXP (buf, 0));
836 }
837
838 /* Emit RTL to start a dynamic handler on the EH runtime dynamic
839    handler stack.  This should only be used by expand_eh_region_start
840    or expand_eh_region_start_tree.  */
841
842 static void
843 start_dynamic_handler ()
844 {
845   rtx dhc, dcc;
846   rtx x, arg;
847   int size;
848
849 #ifdef USE_BUILTIN_SETJMP
850   /* The number of Pmode words for the setjmp buffer, when using the
851      builtin setjmp/longjmp, see expand_builtin, case
852      BUILT_IN_LONGJMP.  */
853   size = 5;
854 #else
855 #ifdef JMP_BUF_SIZE
856   size = JMP_BUF_SIZE;
857 #else
858   /* Should be large enough for most systems, if it is not,
859      JMP_BUF_SIZE should be defined with the proper value.  It will
860      also tend to be larger than necessary for most systems, a more
861      optimal port will define JMP_BUF_SIZE.  */
862   size = FIRST_PSEUDO_REGISTER+2;
863 #endif
864 #endif
865   /* XXX, FIXME: The stack space allocated this way is too long lived,
866      but there is no allocation routine that allocates at the level of
867      the last binding contour.  */
868   arg = assign_stack_local (BLKmode,
869                             GET_MODE_SIZE (Pmode)*(size+1),
870                             0);
871
872   arg = change_address (arg, Pmode, NULL_RTX);
873
874   /* Store dhc into the first word of the newly allocated buffer.  */
875
876   dhc = get_dynamic_handler_chain ();
877   dcc = gen_rtx (MEM, Pmode, plus_constant (XEXP (arg, 0),
878                                             GET_MODE_SIZE (Pmode)));
879   emit_move_insn (arg, dhc);
880
881   /* Zero out the start of the cleanup chain.  */
882   emit_move_insn (dcc, const0_rtx);
883
884   /* The jmpbuf starts two words into the area allocated.  */
885
886   x = emit_library_call_value (setjmp_libfunc, NULL_RTX, 1, SImode, 1,
887                                plus_constant (XEXP (arg, 0), GET_MODE_SIZE (Pmode)*2),
888                                Pmode);
889
890   /* If we come back here for a catch, transfer control to the
891      handler.  */
892
893   jumpif_rtx (x, ehstack.top->entry->exception_handler_label);
894
895   /* We are committed to this, so update the handler chain.  */
896
897   emit_move_insn (dhc, XEXP (arg, 0));
898 }
899
900 /* Start an exception handling region for the given cleanup action.
901    All instructions emitted after this point are considered to be part
902    of the region until expand_eh_region_end is invoked.  CLEANUP is
903    the cleanup action to perform.  The return value is true if the
904    exception region was optimized away.  If that case,
905    expand_eh_region_end does not need to be called for this cleanup,
906    nor should it be.
907
908    This routine notices one particular common case in C++ code
909    generation, and optimizes it so as to not need the exception
910    region.  It works by creating a dynamic cleanup action, instead of
911    of a using an exception region.  */
912
913 int
914 expand_eh_region_start_tree (decl, cleanup)
915      tree decl;
916      tree cleanup;
917 {
918   rtx note;
919
920   /* This is the old code.  */
921   if (! doing_eh (0))
922     return 0;
923
924   /* The optimization only applies to actions protected with
925      terminate, and only applies if we are using the setjmp/longjmp
926      codegen method.  */
927   if (exceptions_via_longjmp
928       && protect_cleanup_actions_with_terminate)
929     {
930       tree func, arg;
931       tree args;
932
933       /* Ignore any UNSAVE_EXPR.  */
934       if (TREE_CODE (cleanup) == UNSAVE_EXPR)
935         cleanup = TREE_OPERAND (cleanup, 0);
936       
937       /* Further, it only applies if the action is a call, if there
938          are 2 arguments, and if the second argument is 2.  */
939
940       if (TREE_CODE (cleanup) == CALL_EXPR
941           && (args = TREE_OPERAND (cleanup, 1))
942           && (func = TREE_OPERAND (cleanup, 0))
943           && (arg = TREE_VALUE (args))
944           && (args = TREE_CHAIN (args))
945
946           /* is the second argument 2?  */
947           && TREE_CODE (TREE_VALUE (args)) == INTEGER_CST
948           && TREE_INT_CST_LOW (TREE_VALUE (args)) == 2
949           && TREE_INT_CST_HIGH (TREE_VALUE (args)) == 0
950
951           /* Make sure there are no other arguments.  */
952           && TREE_CHAIN (args) == NULL_TREE)
953         {
954           /* Arrange for returns and gotos to pop the entry we make on the
955              dynamic cleanup stack.  */
956           expand_dcc_cleanup (decl);
957           start_dynamic_cleanup (func, arg);
958           return 1;
959         }
960     }
961
962   expand_eh_region_start_for_decl (decl);
963
964   return 0;
965 }
966
967 /* Just like expand_eh_region_start, except if a cleanup action is
968    entered on the cleanup chain, the TREE_PURPOSE of the element put
969    on the chain is DECL.  DECL should be the associated VAR_DECL, if
970    any, otherwise it should be NULL_TREE.  */
971
972 void
973 expand_eh_region_start_for_decl (decl)
974      tree decl;
975 {
976   rtx note;
977
978   /* This is the old code.  */
979   if (! doing_eh (0))
980     return;
981
982   if (exceptions_via_longjmp)
983     {
984       /* We need a new block to record the start and end of the
985          dynamic handler chain.  We could always do this, but we
986          really want to permit jumping into such a block, and we want
987          to avoid any errors or performance impact in the SJ EH code
988          for now.  */
989       expand_start_bindings (0);
990
991       /* But we don't need or want a new temporary level.  */
992       pop_temp_slots ();
993
994       /* Mark this block as created by expand_eh_region_start.  This
995          is so that we can pop the block with expand_end_bindings
996          automatically.  */
997       mark_block_as_eh_region ();
998
999       /* Arrange for returns and gotos to pop the entry we make on the
1000          dynamic handler stack.  */
1001       expand_dhc_cleanup (decl);
1002     }
1003
1004   if (exceptions_via_longjmp == 0)
1005     note = emit_note (NULL_PTR, NOTE_INSN_EH_REGION_BEG);
1006   emit_label (push_eh_entry (&ehstack));
1007   if (exceptions_via_longjmp == 0)
1008     NOTE_BLOCK_NUMBER (note)
1009       = CODE_LABEL_NUMBER (ehstack.top->entry->exception_handler_label);
1010   if (exceptions_via_longjmp)
1011     start_dynamic_handler ();
1012 }
1013
1014 /* Start an exception handling region.  All instructions emitted after
1015    this point are considered to be part of the region until
1016    expand_eh_region_end is invoked.  */
1017
1018 void
1019 expand_eh_region_start ()
1020 {
1021   expand_eh_region_start_for_decl (NULL_TREE);
1022 }
1023
1024 /* End an exception handling region.  The information about the region
1025    is found on the top of ehstack.
1026
1027    HANDLER is either the cleanup for the exception region, or if we're
1028    marking the end of a try block, HANDLER is integer_zero_node.
1029
1030    HANDLER will be transformed to rtl when expand_leftover_cleanups
1031    is invoked.  */
1032
1033 void
1034 expand_eh_region_end (handler)
1035      tree handler;
1036 {
1037   struct eh_entry *entry;
1038
1039   if (! doing_eh (0))
1040     return;
1041
1042   entry = pop_eh_entry (&ehstack);
1043
1044   if (exceptions_via_longjmp == 0)
1045     {
1046       rtx note = emit_note (NULL_PTR, NOTE_INSN_EH_REGION_END);
1047       NOTE_BLOCK_NUMBER (note) = CODE_LABEL_NUMBER (entry->exception_handler_label);
1048     }
1049
1050   /* Emit a label marking the end of this exception region.  */
1051   emit_label (entry->end_label);
1052
1053   if (exceptions_via_longjmp == 0)
1054     {
1055       /* Put in something that takes up space, as otherwise the end
1056          address for this EH region could have the exact same address as
1057          its outer region. This would cause us to miss the fact that
1058          resuming exception handling with this PC value would be inside
1059          the outer region.  */
1060       emit_insn (gen_nop ());
1061     }
1062
1063   entry->finalization = handler;
1064
1065   enqueue_eh_entry (&ehqueue, entry);
1066
1067   /* If we have already started ending the bindings, don't recurse.
1068      This only happens when exceptions_via_longjmp is true.  */
1069   if (is_eh_region ())
1070     {
1071       /* Because we don't need or want a new temporary level and
1072          because we didn't create one in expand_eh_region_start,
1073          create a fake one now to avoid removing one in
1074          expand_end_bindings.  */
1075       push_temp_slots ();
1076
1077       mark_block_as_not_eh_region ();
1078
1079       /* Maybe do this to prevent jumping in and so on...  */
1080       expand_end_bindings (NULL_TREE, 0, 0);
1081     }
1082 }
1083
1084 /* If we are using the setjmp/longjmp EH codegen method, we emit a
1085    call to __sjthrow.
1086
1087    Otherwise, we emit a call to __throw and note that we threw
1088    something, so we know we need to generate the necessary code for
1089    __throw.
1090
1091    Before invoking throw, the __eh_pc variable must have been set up
1092    to contain the PC being thrown from. This address is used by
1093    __throw to determine which exception region (if any) is
1094    responsible for handling the exception.  */
1095
1096 void
1097 emit_throw ()
1098 {
1099   if (exceptions_via_longjmp)
1100     {
1101       emit_library_call (sjthrow_libfunc, 0, VOIDmode, 0);
1102     }
1103   else
1104     {
1105 #ifdef JUMP_TO_THROW
1106       emit_indirect_jump (throw_libfunc);
1107 #else
1108       SYMBOL_REF_USED (throw_libfunc) = 1;
1109       emit_library_call (throw_libfunc, 0, VOIDmode, 0);
1110 #endif
1111       throw_used = 1;
1112     }
1113   emit_barrier ();
1114 }
1115
1116 /* An internal throw with an indirect CONTEXT we want to throw from.
1117    CONTEXT evaluates to the context of the throw.  */
1118
1119 static void
1120 expand_internal_throw_indirect (context)
1121      rtx context;
1122 {
1123   assemble_external (eh_saved_pc);
1124   emit_move_insn (eh_saved_pc_rtx, context);
1125   emit_throw ();
1126 }
1127
1128 /* An internal throw with a direct CONTEXT we want to throw from.
1129    CONTEXT must be a label; its address will be used as the context of
1130    the throw.  */
1131
1132 void
1133 expand_internal_throw (context)
1134      rtx context;
1135 {
1136   expand_internal_throw_indirect (gen_rtx (LABEL_REF, Pmode, context));
1137 }
1138
1139 /* Called from expand_exception_blocks and expand_end_catch_block to
1140    emit any pending handlers/cleanups queued from expand_eh_region_end.  */
1141
1142 void
1143 expand_leftover_cleanups ()
1144 {
1145   struct eh_entry *entry;
1146
1147   while ((entry = dequeue_eh_entry (&ehqueue)) != 0)
1148     {
1149       rtx prev;
1150
1151       /* A leftover try block. Shouldn't be one here.  */
1152       if (entry->finalization == integer_zero_node)
1153         abort ();
1154
1155       /* Output the label for the start of the exception handler.  */
1156       emit_label (entry->exception_handler_label);
1157
1158       /* And now generate the insns for the handler.  */
1159       expand_expr (entry->finalization, const0_rtx, VOIDmode, 0);
1160
1161       prev = get_last_insn ();
1162       if (prev == NULL || GET_CODE (prev) != BARRIER)
1163         {
1164           if (exceptions_via_longjmp)
1165             emit_throw ();
1166           else
1167             {
1168               /* The below can be optimized away, and we could just fall into the
1169                  next EH handler, if we are certain they are nested.  */
1170               /* Emit code to throw to the outer context if we fall off
1171                  the end of the handler.  */
1172               expand_internal_throw (entry->end_label);
1173             }
1174         }
1175
1176       free (entry);
1177     }
1178 }
1179
1180 /* Called at the start of a block of try statements.  */
1181 void
1182 expand_start_try_stmts ()
1183 {
1184   if (! doing_eh (1))
1185     return;
1186
1187   expand_eh_region_start ();
1188 }
1189
1190 /* Generate RTL for the start of a group of catch clauses. 
1191
1192    It is responsible for starting a new instruction sequence for the
1193    instructions in the catch block, and expanding the handlers for the
1194    internally-generated exception regions nested within the try block
1195    corresponding to this catch block.  */
1196
1197 void
1198 expand_start_all_catch ()
1199 {
1200   struct eh_entry *entry;
1201   tree label;
1202
1203   if (! doing_eh (1))
1204     return;
1205
1206   /* End the try block.  */
1207   expand_eh_region_end (integer_zero_node);
1208
1209   emit_line_note (input_filename, lineno);
1210   label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
1211
1212   /* The label for the exception handling block that we will save.
1213      This is Lresume in the documention.  */
1214   expand_label (label);
1215   
1216   if (exceptions_via_longjmp == 0)
1217     {
1218       /* Put in something that takes up space, as otherwise the end
1219          address for the EH region could have the exact same address as
1220          the outer region, causing us to miss the fact that resuming
1221          exception handling with this PC value would be inside the outer
1222          region.  */
1223       emit_insn (gen_nop ());
1224     }
1225
1226   /* Push the label that points to where normal flow is resumed onto
1227      the top of the label stack.  */
1228   push_label_entry (&caught_return_label_stack, NULL_RTX, label);
1229
1230   /* Start a new sequence for all the catch blocks.  We will add this
1231      to the global sequence catch_clauses when we have completed all
1232      the handlers in this handler-seq.  */
1233   start_sequence ();
1234
1235   while (1)
1236     {
1237       rtx prev;
1238
1239       entry = dequeue_eh_entry (&ehqueue);
1240       /* Emit the label for the exception handler for this region, and
1241          expand the code for the handler. 
1242
1243          Note that a catch region is handled as a side-effect here;
1244          for a try block, entry->finalization will contain
1245          integer_zero_node, so no code will be generated in the
1246          expand_expr call below. But, the label for the handler will
1247          still be emitted, so any code emitted after this point will
1248          end up being the handler.  */
1249       emit_label (entry->exception_handler_label);
1250
1251       /* When we get down to the matching entry for this try block, stop.  */
1252       if (entry->finalization == integer_zero_node)
1253         {
1254           /* Don't forget to free this entry.  */
1255           free (entry);
1256           break;
1257         }
1258
1259       /* And now generate the insns for the handler.  */
1260       expand_expr (entry->finalization, const0_rtx, VOIDmode, 0);
1261
1262       prev = get_last_insn ();
1263       if (prev == NULL || GET_CODE (prev) != BARRIER)
1264         {
1265           if (exceptions_via_longjmp)
1266             emit_throw ();
1267           else
1268             {
1269               /* Code to throw out to outer context when we fall off end
1270                  of the handler. We can't do this here for catch blocks,
1271                  so it's done in expand_end_all_catch instead.
1272
1273                  The below can be optimized away (and we could just fall
1274                  into the next EH handler) if we are certain they are
1275                  nested.  */
1276
1277               expand_internal_throw (entry->end_label);
1278             }
1279         }
1280       free (entry);
1281     }
1282 }
1283
1284 /* Finish up the catch block.  At this point all the insns for the
1285    catch clauses have already been generated, so we only have to add
1286    them to the catch_clauses list. We also want to make sure that if
1287    we fall off the end of the catch clauses that we rethrow to the
1288    outer EH region.  */
1289
1290 void
1291 expand_end_all_catch ()
1292 {
1293   rtx new_catch_clause;
1294
1295   if (! doing_eh (1))
1296     return;
1297
1298   if (exceptions_via_longjmp)
1299     emit_throw ();
1300   else
1301     {
1302       /* Code to throw out to outer context, if we fall off end of catch
1303          handlers.  This is rethrow (Lresume, same id, same obj) in the
1304          documentation. We use Lresume because we know that it will throw
1305          to the correct context.
1306
1307          In other words, if the catch handler doesn't exit or return, we
1308          do a "throw" (using the address of Lresume as the point being
1309          thrown from) so that the outer EH region can then try to process
1310          the exception.  */
1311
1312       expand_internal_throw (DECL_RTL (top_label_entry (&caught_return_label_stack)));
1313     }
1314
1315   /* Now we have the complete catch sequence.  */
1316   new_catch_clause = get_insns ();
1317   end_sequence ();
1318   
1319   /* This level of catch blocks is done, so set up the successful
1320      catch jump label for the next layer of catch blocks.  */
1321   pop_label_entry (&caught_return_label_stack);
1322
1323   /* Add the new sequence of catches to the main one for this function.  */
1324   push_to_sequence (catch_clauses);
1325   emit_insns (new_catch_clause);
1326   catch_clauses = get_insns ();
1327   end_sequence ();
1328   
1329   /* Here we fall through into the continuation code.  */
1330 }
1331
1332 /* End all the pending exception regions on protect_list. The handlers
1333    will be emitted when expand_leftover_cleanups is invoked.  */
1334
1335 void
1336 end_protect_partials ()
1337 {
1338   while (protect_list)
1339     {
1340       expand_eh_region_end (TREE_VALUE (protect_list));
1341       protect_list = TREE_CHAIN (protect_list);
1342     }
1343 }
1344
1345 /* Arrange for __terminate to be called if there is an unhandled throw
1346    from within E.  */
1347
1348 tree
1349 protect_with_terminate (e)
1350      tree e;
1351 {
1352   /* We only need to do this when using setjmp/longjmp EH and the
1353      language requires it, as otherwise we protect all of the handlers
1354      at once, if we need to.  */
1355   if (exceptions_via_longjmp && protect_cleanup_actions_with_terminate)
1356     {
1357       tree handler, result;
1358
1359       /* All cleanups must be on the function_obstack.  */
1360       push_obstacks_nochange ();
1361       resume_temporary_allocation ();
1362
1363       handler = make_node (RTL_EXPR);
1364       TREE_TYPE (handler) = void_type_node;
1365       RTL_EXPR_RTL (handler) = const0_rtx;
1366       TREE_SIDE_EFFECTS (handler) = 1;
1367       start_sequence_for_rtl_expr (handler);
1368
1369       emit_library_call (terminate_libfunc, 0, VOIDmode, 0);
1370       emit_barrier ();
1371
1372       RTL_EXPR_SEQUENCE (handler) = get_insns ();
1373       end_sequence ();
1374         
1375       result = build (TRY_CATCH_EXPR, TREE_TYPE (e), e, handler);
1376       TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
1377       TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
1378       TREE_READONLY (result) = TREE_READONLY (e);
1379
1380       pop_obstacks ();
1381
1382       e = result;
1383     }
1384
1385   return e;
1386 }
1387 \f
1388 /* The exception table that we build that is used for looking up and
1389    dispatching exceptions, the current number of entries, and its
1390    maximum size before we have to extend it. 
1391
1392    The number in eh_table is the code label number of the exception
1393    handler for the region. This is added by add_eh_table_entry and
1394    used by output_exception_table_entry.  */
1395
1396 static int *eh_table;
1397 static int eh_table_size;
1398 static int eh_table_max_size;
1399
1400 /* Note the need for an exception table entry for region N.  If we
1401    don't need to output an explicit exception table, avoid all of the
1402    extra work.
1403
1404    Called from final_scan_insn when a NOTE_INSN_EH_REGION_BEG is seen.
1405    N is the NOTE_BLOCK_NUMBER of the note, which comes from the code
1406    label number of the exception handler for the region.  */
1407
1408 void
1409 add_eh_table_entry (n)
1410      int n;
1411 {
1412 #ifndef OMIT_EH_TABLE
1413   if (eh_table_size >= eh_table_max_size)
1414     {
1415       if (eh_table)
1416         {
1417           eh_table_max_size += eh_table_max_size>>1;
1418
1419           if (eh_table_max_size < 0)
1420             abort ();
1421
1422           if ((eh_table = (int *) realloc (eh_table,
1423                                            eh_table_max_size * sizeof (int)))
1424               == 0)
1425             fatal ("virtual memory exhausted");
1426         }
1427       else
1428         {
1429           eh_table_max_size = 252;
1430           eh_table = (int *) xmalloc (eh_table_max_size * sizeof (int));
1431         }
1432     }
1433   eh_table[eh_table_size++] = n;
1434 #endif
1435 }
1436
1437 /* Return a non-zero value if we need to output an exception table.
1438
1439    On some platforms, we don't have to output a table explicitly.
1440    This routine doesn't mean we don't have one.  */
1441
1442 int
1443 exception_table_p ()
1444 {
1445   if (eh_table)
1446     return 1;
1447
1448   return 0;
1449 }
1450
1451 /* Output the entry of the exception table corresponding to to the
1452    exception region numbered N to file FILE. 
1453
1454    N is the code label number corresponding to the handler of the
1455    region.  */
1456
1457 static void
1458 output_exception_table_entry (file, n)
1459      FILE *file;
1460      int n;
1461 {
1462   char buf[256];
1463   rtx sym;
1464
1465   ASM_GENERATE_INTERNAL_LABEL (buf, "LEHB", n);
1466   sym = gen_rtx (SYMBOL_REF, Pmode, buf);
1467   assemble_integer (sym, POINTER_SIZE / BITS_PER_UNIT, 1);
1468
1469   ASM_GENERATE_INTERNAL_LABEL (buf, "LEHE", n);
1470   sym = gen_rtx (SYMBOL_REF, Pmode, buf);
1471   assemble_integer (sym, POINTER_SIZE / BITS_PER_UNIT, 1);
1472
1473   ASM_GENERATE_INTERNAL_LABEL (buf, "L", n);
1474   sym = gen_rtx (SYMBOL_REF, Pmode, buf);
1475   assemble_integer (sym, POINTER_SIZE / BITS_PER_UNIT, 1);
1476
1477   putc ('\n', file);            /* blank line */
1478 }
1479
1480 /* Output the exception table if we have and need one.  */
1481
1482 void
1483 output_exception_table ()
1484 {
1485   int i;
1486   extern FILE *asm_out_file;
1487
1488   if (! doing_eh (0))
1489     return;
1490
1491   exception_section ();
1492
1493   /* Beginning marker for table.  */
1494   assemble_align (GET_MODE_ALIGNMENT (ptr_mode));
1495   assemble_label ("__EXCEPTION_TABLE__");
1496
1497   assemble_integer (const0_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
1498   assemble_integer (const0_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
1499   assemble_integer (const0_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
1500   putc ('\n', asm_out_file);            /* blank line */
1501
1502   for (i = 0; i < eh_table_size; ++i)
1503     output_exception_table_entry (asm_out_file, eh_table[i]);
1504
1505   free (eh_table);
1506
1507   /* Ending marker for table.  */
1508   assemble_label ("__EXCEPTION_END__");
1509   assemble_integer (constm1_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
1510   assemble_integer (constm1_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
1511   assemble_integer (constm1_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
1512   putc ('\n', asm_out_file);            /* blank line */
1513 }
1514
1515 /* Generate code to initialize the exception table at program startup
1516    time.  */
1517
1518 void
1519 register_exception_table ()
1520 {
1521   emit_library_call (gen_rtx (SYMBOL_REF, Pmode, "__register_exceptions"), 0,
1522                      VOIDmode, 1,
1523                      gen_rtx (SYMBOL_REF, Pmode, "__EXCEPTION_TABLE__"),
1524                      Pmode);
1525 }
1526 \f
1527 /* Emit the RTL for the start of the per-function unwinder for the
1528    current function. See emit_unwinder for further information.
1529
1530    DOESNT_NEED_UNWINDER is a target-specific macro that determines if
1531    the current function actually needs a per-function unwinder or not.
1532    By default, all functions need one.  */
1533
1534 void
1535 start_eh_unwinder ()
1536 {
1537 #ifdef DOESNT_NEED_UNWINDER
1538   if (DOESNT_NEED_UNWINDER)
1539     return;
1540 #endif
1541
1542   /* If we are using the setjmp/longjmp implementation, we don't need a
1543      per function unwinder.  */
1544
1545   if (exceptions_via_longjmp)
1546     return;
1547
1548   expand_eh_region_start ();
1549 }
1550
1551 /* Emit insns for the end of the per-function unwinder for the
1552    current function.  */
1553
1554 void
1555 end_eh_unwinder ()
1556 {
1557   tree expr;
1558   rtx return_val_rtx, ret_val, label, end, insns;
1559
1560   if (! doing_eh (0))
1561     return;
1562
1563 #ifdef DOESNT_NEED_UNWINDER
1564   if (DOESNT_NEED_UNWINDER)
1565     return;
1566 #endif
1567
1568   /* If we are using the setjmp/longjmp implementation, we don't need a
1569      per function unwinder.  */
1570
1571   if (exceptions_via_longjmp)
1572     return;
1573
1574   assemble_external (eh_saved_pc);
1575
1576   expr = make_node (RTL_EXPR);
1577   TREE_TYPE (expr) = void_type_node;
1578   RTL_EXPR_RTL (expr) = const0_rtx;
1579   TREE_SIDE_EFFECTS (expr) = 1;
1580   start_sequence_for_rtl_expr (expr);
1581
1582   /* ret_val will contain the address of the code where the call
1583      to the current function occurred.  */
1584   ret_val = expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
1585                                         0, hard_frame_pointer_rtx);
1586   return_val_rtx = copy_to_reg (ret_val);
1587
1588   /* Get the address we need to use to determine what exception
1589      handler should be invoked, and store it in __eh_pc.  */
1590   return_val_rtx = eh_outer_context (return_val_rtx);
1591   emit_move_insn (eh_saved_pc_rtx, return_val_rtx);
1592   
1593   /* Either set things up so we do a return directly to __throw, or
1594      we return here instead.  */
1595 #ifdef JUMP_TO_THROW
1596   emit_move_insn (ret_val, throw_libfunc);
1597 #else
1598   label = gen_label_rtx ();
1599   emit_move_insn (ret_val, gen_rtx (LABEL_REF, Pmode, label));
1600 #endif
1601
1602 #ifdef RETURN_ADDR_OFFSET
1603   return_val_rtx = plus_constant (ret_val, -RETURN_ADDR_OFFSET);
1604   if (return_val_rtx != ret_val)
1605     emit_move_insn (ret_val, return_val_rtx);
1606 #endif
1607   
1608   end = gen_label_rtx ();
1609   emit_jump (end);  
1610
1611   RTL_EXPR_SEQUENCE (expr) = get_insns ();
1612   end_sequence ();
1613
1614   expand_eh_region_end (expr);
1615
1616   emit_jump (end);
1617
1618 #ifndef JUMP_TO_THROW
1619   emit_label (label);
1620   emit_throw ();
1621 #endif
1622   
1623   expand_leftover_cleanups ();
1624
1625   emit_label (end);
1626 }
1627
1628 /* If necessary, emit insns for the per function unwinder for the
1629    current function.  Called after all the code that needs unwind
1630    protection is output.  
1631
1632    The unwinder takes care of catching any exceptions that have not
1633    been previously caught within the function, unwinding the stack to
1634    the next frame, and rethrowing using the address of the current
1635    function's caller as the context of the throw.
1636
1637    On some platforms __throw can do this by itself (or with the help
1638    of __unwind_function) so the per-function unwinder is
1639    unnecessary.
1640   
1641    We cannot place the unwinder into the function until after we know
1642    we are done inlining, as we don't want to have more than one
1643    unwinder per non-inlined function.  */
1644
1645 void
1646 emit_unwinder ()
1647 {
1648   rtx insns, insn;
1649
1650   start_sequence ();
1651   start_eh_unwinder ();
1652   insns = get_insns ();
1653   end_sequence ();
1654
1655   /* We place the start of the exception region associated with the
1656      per function unwinder at the top of the function.  */
1657   if (insns)
1658     emit_insns_after (insns, get_insns ());
1659
1660   start_sequence ();
1661   end_eh_unwinder ();
1662   insns = get_insns ();
1663   end_sequence ();
1664
1665   /* And we place the end of the exception region before the USE and
1666      CLOBBER insns that may come at the end of the function.  */
1667   if (insns == 0)
1668     return;
1669
1670   insn = get_last_insn ();
1671   while (GET_CODE (insn) == NOTE
1672          || (GET_CODE (insn) == INSN
1673              && (GET_CODE (PATTERN (insn)) == USE
1674                  || GET_CODE (PATTERN (insn)) == CLOBBER)))
1675     insn = PREV_INSN (insn);
1676
1677   if (GET_CODE (insn) == CODE_LABEL
1678       && GET_CODE (PREV_INSN (insn)) == BARRIER)
1679     {
1680       insn = PREV_INSN (insn);
1681     }
1682   else
1683     {
1684       rtx label = gen_label_rtx ();
1685       emit_label_after (label, insn);
1686       insn = emit_jump_insn_after (gen_jump (label), insn);
1687       insn = emit_barrier_after (insn);
1688     }
1689     
1690   emit_insns_after (insns, insn);
1691 }
1692
1693 /* Scan the current insns and build a list of handler labels. The
1694    resulting list is placed in the global variable exception_handler_labels.
1695
1696    It is called after the last exception handling region is added to
1697    the current function (when the rtl is almost all built for the
1698    current function) and before the jump optimization pass.  */
1699
1700 void
1701 find_exception_handler_labels ()
1702 {
1703   rtx insn;
1704   int max_labelno = max_label_num ();
1705   int min_labelno = get_first_label_num ();
1706   rtx *labels;
1707
1708   exception_handler_labels = NULL_RTX;
1709
1710   /* If we aren't doing exception handling, there isn't much to check.  */
1711   if (! doing_eh (0))
1712     return;
1713
1714   /* Generate a handy reference to each label.  */
1715
1716   labels = (rtx *) alloca ((max_labelno - min_labelno) * sizeof (rtx));
1717   bzero ((char *) labels, (max_labelno - min_labelno) * sizeof (rtx));
1718
1719   /* Arrange for labels to be indexed directly by CODE_LABEL_NUMBER.  */
1720   labels -= min_labelno;
1721
1722   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
1723     {
1724       if (GET_CODE (insn) == CODE_LABEL)
1725         if (CODE_LABEL_NUMBER (insn) >= min_labelno
1726             && CODE_LABEL_NUMBER (insn) < max_labelno)
1727           labels[CODE_LABEL_NUMBER (insn)] = insn;
1728     }
1729
1730   /* For each start of a region, add its label to the list.  */
1731
1732   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
1733     {
1734       if (GET_CODE (insn) == NOTE
1735           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
1736         {
1737           rtx label = NULL_RTX;
1738
1739           if (NOTE_BLOCK_NUMBER (insn) >= min_labelno
1740               && NOTE_BLOCK_NUMBER (insn) < max_labelno)
1741             {
1742               label = labels[NOTE_BLOCK_NUMBER (insn)];
1743
1744               if (label)
1745                 exception_handler_labels
1746                   = gen_rtx (EXPR_LIST, VOIDmode,
1747                              label, exception_handler_labels);
1748               else
1749                 warning ("didn't find handler for EH region %d",
1750                          NOTE_BLOCK_NUMBER (insn));
1751             }
1752           else
1753             warning ("mismatched EH region %d", NOTE_BLOCK_NUMBER (insn));
1754         }
1755     }
1756 }
1757
1758 /* Perform sanity checking on the exception_handler_labels list.
1759
1760    Can be called after find_exception_handler_labels is called to
1761    build the list of exception handlers for the current function and
1762    before we finish processing the current function.  */
1763
1764 void
1765 check_exception_handler_labels ()
1766 {
1767   rtx insn, handler;
1768
1769   /* If we aren't doing exception handling, there isn't much to check.  */
1770   if (! doing_eh (0))
1771     return;
1772
1773   /* Ensure that the CODE_LABEL_NUMBER for the CODE_LABEL entry point
1774      in each handler corresponds to the CODE_LABEL_NUMBER of the
1775      handler.  */
1776
1777   for (handler = exception_handler_labels;
1778        handler;
1779        handler = XEXP (handler, 1))
1780     {
1781       for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
1782         {
1783           if (GET_CODE (insn) == CODE_LABEL)
1784             {
1785               if (CODE_LABEL_NUMBER (insn)
1786                   == CODE_LABEL_NUMBER (XEXP (handler, 0)))
1787                 {
1788                   if (insn != XEXP (handler, 0))
1789                     warning ("mismatched handler %d",
1790                              CODE_LABEL_NUMBER (insn));
1791                   break;
1792                 }
1793             }
1794         }
1795       if (insn == NULL_RTX)
1796         warning ("handler not found %d",
1797                  CODE_LABEL_NUMBER (XEXP (handler, 0)));
1798     }
1799
1800   /* Now go through and make sure that for each region there is a
1801      corresponding label.  */
1802   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
1803     {
1804       if (GET_CODE (insn) == NOTE
1805           && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG
1806               || NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END))
1807         {
1808           for (handler = exception_handler_labels;
1809                handler;
1810                handler = XEXP (handler, 1))
1811             {
1812               if (CODE_LABEL_NUMBER (XEXP (handler, 0))
1813                   == NOTE_BLOCK_NUMBER (insn))
1814                 break;
1815             }
1816           if (handler == NULL_RTX)
1817             warning ("region exists, no handler %d",
1818                      NOTE_BLOCK_NUMBER (insn));
1819         }
1820     }
1821 }
1822 \f
1823 /* This group of functions initializes the exception handling data
1824    structures at the start of the compilation, initializes the data
1825    structures at the start of a function, and saves and restores the
1826    exception handling data structures for the start/end of a nested
1827    function.  */
1828
1829 /* Toplevel initialization for EH things.  */ 
1830
1831 void
1832 init_eh ()
1833 {
1834   /* Generate rtl to reference the variable in which the PC of the
1835      current context is saved.  */
1836   tree type = build_pointer_type (make_node (VOID_TYPE));
1837
1838   eh_saved_pc = build_decl (VAR_DECL, get_identifier ("__eh_pc"), type);
1839   DECL_EXTERNAL (eh_saved_pc) = 1;
1840   TREE_PUBLIC (eh_saved_pc) = 1;
1841   make_decl_rtl (eh_saved_pc, NULL_PTR, 1);
1842   eh_saved_pc_rtx = DECL_RTL (eh_saved_pc);
1843 }
1844
1845 /* Initialize the per-function EH information.  */
1846
1847 void
1848 init_eh_for_function ()
1849 {
1850   ehstack.top = 0;
1851   ehqueue.head = ehqueue.tail = 0;
1852   catch_clauses = NULL_RTX;
1853   false_label_stack = 0;
1854   caught_return_label_stack = 0;
1855   protect_list = NULL_TREE;
1856   current_function_dhc = NULL_RTX;
1857   current_function_dcc = NULL_RTX;
1858 }
1859
1860 /* Save some of the per-function EH info into the save area denoted by
1861    P. 
1862
1863    This is currently called from save_stmt_status.  */
1864
1865 void
1866 save_eh_status (p)
1867      struct function *p;
1868 {
1869   assert (p != NULL);
1870
1871   p->ehstack = ehstack;
1872   p->ehqueue = ehqueue;
1873   p->catch_clauses = catch_clauses;
1874   p->false_label_stack = false_label_stack;
1875   p->caught_return_label_stack = caught_return_label_stack;
1876   p->protect_list = protect_list;
1877   p->dhc = current_function_dhc;
1878   p->dcc = current_function_dcc;
1879
1880   init_eh ();
1881 }
1882
1883 /* Restore the per-function EH info saved into the area denoted by P.  
1884
1885    This is currently called from restore_stmt_status.  */
1886
1887 void
1888 restore_eh_status (p)
1889      struct function *p;
1890 {
1891   assert (p != NULL);
1892
1893   protect_list = p->protect_list;
1894   caught_return_label_stack = p->caught_return_label_stack;
1895   false_label_stack = p->false_label_stack;
1896   catch_clauses = p->catch_clauses;
1897   ehqueue = p->ehqueue;
1898   ehstack = p->ehstack;
1899   current_function_dhc = p->dhc;
1900   current_function_dcc = p->dcc;
1901 }
1902 \f
1903 /* This section is for the exception handling specific optimization
1904    pass.  First are the internal routines, and then the main
1905    optimization pass.  */
1906
1907 /* Determine if the given INSN can throw an exception.  */
1908
1909 static int
1910 can_throw (insn)
1911      rtx insn;
1912 {
1913   /* Calls can always potentially throw exceptions.  */
1914   if (GET_CODE (insn) == CALL_INSN)
1915     return 1;
1916
1917   if (asynchronous_exceptions)
1918     {
1919       /* If we wanted asynchronous exceptions, then everything but NOTEs
1920          and CODE_LABELs could throw.  */
1921       if (GET_CODE (insn) != NOTE && GET_CODE (insn) != CODE_LABEL)
1922         return 1;
1923     }
1924
1925   return 0;
1926 }
1927
1928 /* Scan a exception region looking for the matching end and then
1929    remove it if possible. INSN is the start of the region, N is the
1930    region number, and DELETE_OUTER is to note if anything in this
1931    region can throw.
1932
1933    Regions are removed if they cannot possibly catch an exception.
1934    This is determined by invoking can_throw on each insn within the
1935    region; if can_throw returns true for any of the instructions, the
1936    region can catch an exception, since there is an insn within the
1937    region that is capable of throwing an exception.
1938
1939    Returns the NOTE_INSN_EH_REGION_END corresponding to this region, or
1940    calls abort if it can't find one.
1941
1942    Can abort if INSN is not a NOTE_INSN_EH_REGION_BEGIN, or if N doesn't
1943    correspond to the region number, or if DELETE_OUTER is NULL.  */
1944
1945 static rtx
1946 scan_region (insn, n, delete_outer)
1947      rtx insn;
1948      int n;
1949      int *delete_outer;
1950 {
1951   rtx start = insn;
1952
1953   /* Assume we can delete the region.  */
1954   int delete = 1;
1955
1956   assert (insn != NULL_RTX
1957           && GET_CODE (insn) == NOTE
1958           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG
1959           && NOTE_BLOCK_NUMBER (insn) == n
1960           && delete_outer != NULL);
1961
1962   insn = NEXT_INSN (insn);
1963
1964   /* Look for the matching end.  */
1965   while (! (GET_CODE (insn) == NOTE
1966             && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END))
1967     {
1968       /* If anything can throw, we can't remove the region.  */
1969       if (delete && can_throw (insn))
1970         {
1971           delete = 0;
1972         }
1973
1974       /* Watch out for and handle nested regions.  */
1975       if (GET_CODE (insn) == NOTE
1976           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
1977         {
1978           insn = scan_region (insn, NOTE_BLOCK_NUMBER (insn), &delete);
1979         }
1980
1981       insn = NEXT_INSN (insn);
1982     }
1983
1984   /* The _BEG/_END NOTEs must match and nest.  */
1985   if (NOTE_BLOCK_NUMBER (insn) != n)
1986     abort ();
1987
1988   /* If anything in this exception region can throw, we can throw.  */
1989   if (! delete)
1990     *delete_outer = 0;
1991   else
1992     {
1993       /* Delete the start and end of the region.  */
1994       delete_insn (start);
1995       delete_insn (insn);
1996
1997       /* Only do this part if we have built the exception handler
1998          labels.  */
1999       if (exception_handler_labels)
2000         {
2001           rtx x, *prev = &exception_handler_labels;
2002
2003           /* Find it in the list of handlers.  */
2004           for (x = exception_handler_labels; x; x = XEXP (x, 1))
2005             {
2006               rtx label = XEXP (x, 0);
2007               if (CODE_LABEL_NUMBER (label) == n)
2008                 {
2009                   /* If we are the last reference to the handler,
2010                      delete it.  */
2011                   if (--LABEL_NUSES (label) == 0)
2012                     delete_insn (label);
2013
2014                   if (optimize)
2015                     {
2016                       /* Remove it from the list of exception handler
2017                          labels, if we are optimizing.  If we are not, then
2018                          leave it in the list, as we are not really going to
2019                          remove the region.  */
2020                       *prev = XEXP (x, 1);
2021                       XEXP (x, 1) = 0;
2022                       XEXP (x, 0) = 0;
2023                     }
2024
2025                   break;
2026                 }
2027               prev = &XEXP (x, 1);
2028             }
2029         }
2030     }
2031   return insn;
2032 }
2033
2034 /* Perform various interesting optimizations for exception handling
2035    code.
2036
2037    We look for empty exception regions and make them go (away). The
2038    jump optimization code will remove the handler if nothing else uses
2039    it.  */
2040
2041 void
2042 exception_optimize ()
2043 {
2044   rtx insn, regions = NULL_RTX;
2045   int n;
2046
2047   /* The below doesn't apply to setjmp/longjmp EH.  */
2048   if (exceptions_via_longjmp)
2049     return;
2050
2051   /* Remove empty regions.  */
2052   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2053     {
2054       if (GET_CODE (insn) == NOTE
2055           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
2056         {
2057           /* Since scan_region will return the NOTE_INSN_EH_REGION_END
2058              insn, we will indirectly skip through all the insns
2059              inbetween. We are also guaranteed that the value of insn
2060              returned will be valid, as otherwise scan_region won't
2061              return.  */
2062           insn = scan_region (insn, NOTE_BLOCK_NUMBER (insn), &n);
2063         }
2064     }
2065 }