OSDN Git Service

* except.c (start_dynamic_handler): Fix so that we can use
[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    DONT_USE_BUILTIN_SETJMP is defined, and an area suitable for
697    __builtin_setjmp/__builtin_longjmp when DONT_USE_BUILTIN_SETJMP
698    isn't 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, buf;
847   int size;
848
849 #ifndef DONT_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   buf = plus_constant (XEXP (arg, 0), GET_MODE_SIZE (Pmode)*2);
886
887 #ifdef DONT_USE_BUILTIN_SETJMP
888   x = emit_library_call_value (setjmp_libfunc, NULL_RTX, 1, SImode, 1,
889                                buf, Pmode);
890 #else
891   x = expand_builtin_setjmp (buf, NULL_RTX);
892 #endif
893
894   /* If we come back here for a catch, transfer control to the
895      handler.  */
896
897   jumpif_rtx (x, ehstack.top->entry->exception_handler_label);
898
899   /* We are committed to this, so update the handler chain.  */
900
901   emit_move_insn (dhc, XEXP (arg, 0));
902 }
903
904 /* Start an exception handling region for the given cleanup action.
905    All instructions emitted after this point are considered to be part
906    of the region until expand_eh_region_end is invoked.  CLEANUP is
907    the cleanup action to perform.  The return value is true if the
908    exception region was optimized away.  If that case,
909    expand_eh_region_end does not need to be called for this cleanup,
910    nor should it be.
911
912    This routine notices one particular common case in C++ code
913    generation, and optimizes it so as to not need the exception
914    region.  It works by creating a dynamic cleanup action, instead of
915    of a using an exception region.  */
916
917 int
918 expand_eh_region_start_tree (decl, cleanup)
919      tree decl;
920      tree cleanup;
921 {
922   rtx note;
923
924   /* This is the old code.  */
925   if (! doing_eh (0))
926     return 0;
927
928   /* The optimization only applies to actions protected with
929      terminate, and only applies if we are using the setjmp/longjmp
930      codegen method.  */
931   if (exceptions_via_longjmp
932       && protect_cleanup_actions_with_terminate)
933     {
934       tree func, arg;
935       tree args;
936
937       /* Ignore any UNSAVE_EXPR.  */
938       if (TREE_CODE (cleanup) == UNSAVE_EXPR)
939         cleanup = TREE_OPERAND (cleanup, 0);
940       
941       /* Further, it only applies if the action is a call, if there
942          are 2 arguments, and if the second argument is 2.  */
943
944       if (TREE_CODE (cleanup) == CALL_EXPR
945           && (args = TREE_OPERAND (cleanup, 1))
946           && (func = TREE_OPERAND (cleanup, 0))
947           && (arg = TREE_VALUE (args))
948           && (args = TREE_CHAIN (args))
949
950           /* is the second argument 2?  */
951           && TREE_CODE (TREE_VALUE (args)) == INTEGER_CST
952           && TREE_INT_CST_LOW (TREE_VALUE (args)) == 2
953           && TREE_INT_CST_HIGH (TREE_VALUE (args)) == 0
954
955           /* Make sure there are no other arguments.  */
956           && TREE_CHAIN (args) == NULL_TREE)
957         {
958           /* Arrange for returns and gotos to pop the entry we make on the
959              dynamic cleanup stack.  */
960           expand_dcc_cleanup (decl);
961           start_dynamic_cleanup (func, arg);
962           return 1;
963         }
964     }
965
966   expand_eh_region_start_for_decl (decl);
967
968   return 0;
969 }
970
971 /* Just like expand_eh_region_start, except if a cleanup action is
972    entered on the cleanup chain, the TREE_PURPOSE of the element put
973    on the chain is DECL.  DECL should be the associated VAR_DECL, if
974    any, otherwise it should be NULL_TREE.  */
975
976 void
977 expand_eh_region_start_for_decl (decl)
978      tree decl;
979 {
980   rtx note;
981
982   /* This is the old code.  */
983   if (! doing_eh (0))
984     return;
985
986   if (exceptions_via_longjmp)
987     {
988       /* We need a new block to record the start and end of the
989          dynamic handler chain.  We could always do this, but we
990          really want to permit jumping into such a block, and we want
991          to avoid any errors or performance impact in the SJ EH code
992          for now.  */
993       expand_start_bindings (0);
994
995       /* But we don't need or want a new temporary level.  */
996       pop_temp_slots ();
997
998       /* Mark this block as created by expand_eh_region_start.  This
999          is so that we can pop the block with expand_end_bindings
1000          automatically.  */
1001       mark_block_as_eh_region ();
1002
1003       /* Arrange for returns and gotos to pop the entry we make on the
1004          dynamic handler stack.  */
1005       expand_dhc_cleanup (decl);
1006     }
1007
1008   if (exceptions_via_longjmp == 0)
1009     note = emit_note (NULL_PTR, NOTE_INSN_EH_REGION_BEG);
1010   emit_label (push_eh_entry (&ehstack));
1011   if (exceptions_via_longjmp == 0)
1012     NOTE_BLOCK_NUMBER (note)
1013       = CODE_LABEL_NUMBER (ehstack.top->entry->exception_handler_label);
1014   if (exceptions_via_longjmp)
1015     start_dynamic_handler ();
1016 }
1017
1018 /* Start an exception handling region.  All instructions emitted after
1019    this point are considered to be part of the region until
1020    expand_eh_region_end is invoked.  */
1021
1022 void
1023 expand_eh_region_start ()
1024 {
1025   expand_eh_region_start_for_decl (NULL_TREE);
1026 }
1027
1028 /* End an exception handling region.  The information about the region
1029    is found on the top of ehstack.
1030
1031    HANDLER is either the cleanup for the exception region, or if we're
1032    marking the end of a try block, HANDLER is integer_zero_node.
1033
1034    HANDLER will be transformed to rtl when expand_leftover_cleanups
1035    is invoked.  */
1036
1037 void
1038 expand_eh_region_end (handler)
1039      tree handler;
1040 {
1041   struct eh_entry *entry;
1042
1043   if (! doing_eh (0))
1044     return;
1045
1046   entry = pop_eh_entry (&ehstack);
1047
1048   if (exceptions_via_longjmp == 0)
1049     {
1050       rtx note = emit_note (NULL_PTR, NOTE_INSN_EH_REGION_END);
1051       NOTE_BLOCK_NUMBER (note) = CODE_LABEL_NUMBER (entry->exception_handler_label);
1052     }
1053
1054   /* Emit a label marking the end of this exception region.  */
1055   emit_label (entry->end_label);
1056
1057   if (exceptions_via_longjmp == 0)
1058     {
1059       /* Put in something that takes up space, as otherwise the end
1060          address for this EH region could have the exact same address as
1061          its outer region. This would cause us to miss the fact that
1062          resuming exception handling with this PC value would be inside
1063          the outer region.  */
1064       emit_insn (gen_nop ());
1065     }
1066
1067   entry->finalization = handler;
1068
1069   enqueue_eh_entry (&ehqueue, entry);
1070
1071   /* If we have already started ending the bindings, don't recurse.
1072      This only happens when exceptions_via_longjmp is true.  */
1073   if (is_eh_region ())
1074     {
1075       /* Because we don't need or want a new temporary level and
1076          because we didn't create one in expand_eh_region_start,
1077          create a fake one now to avoid removing one in
1078          expand_end_bindings.  */
1079       push_temp_slots ();
1080
1081       mark_block_as_not_eh_region ();
1082
1083       /* Maybe do this to prevent jumping in and so on...  */
1084       expand_end_bindings (NULL_TREE, 0, 0);
1085     }
1086 }
1087
1088 /* If we are using the setjmp/longjmp EH codegen method, we emit a
1089    call to __sjthrow.
1090
1091    Otherwise, we emit a call to __throw and note that we threw
1092    something, so we know we need to generate the necessary code for
1093    __throw.
1094
1095    Before invoking throw, the __eh_pc variable must have been set up
1096    to contain the PC being thrown from. This address is used by
1097    __throw to determine which exception region (if any) is
1098    responsible for handling the exception.  */
1099
1100 void
1101 emit_throw ()
1102 {
1103   if (exceptions_via_longjmp)
1104     {
1105       emit_library_call (sjthrow_libfunc, 0, VOIDmode, 0);
1106     }
1107   else
1108     {
1109 #ifdef JUMP_TO_THROW
1110       emit_indirect_jump (throw_libfunc);
1111 #else
1112       SYMBOL_REF_USED (throw_libfunc) = 1;
1113       emit_library_call (throw_libfunc, 0, VOIDmode, 0);
1114 #endif
1115       throw_used = 1;
1116     }
1117   emit_barrier ();
1118 }
1119
1120 /* An internal throw with an indirect CONTEXT we want to throw from.
1121    CONTEXT evaluates to the context of the throw.  */
1122
1123 static void
1124 expand_internal_throw_indirect (context)
1125      rtx context;
1126 {
1127   assemble_external (eh_saved_pc);
1128   emit_move_insn (eh_saved_pc_rtx, context);
1129   emit_throw ();
1130 }
1131
1132 /* An internal throw with a direct CONTEXT we want to throw from.
1133    CONTEXT must be a label; its address will be used as the context of
1134    the throw.  */
1135
1136 void
1137 expand_internal_throw (context)
1138      rtx context;
1139 {
1140   expand_internal_throw_indirect (gen_rtx (LABEL_REF, Pmode, context));
1141 }
1142
1143 /* Called from expand_exception_blocks and expand_end_catch_block to
1144    emit any pending handlers/cleanups queued from expand_eh_region_end.  */
1145
1146 void
1147 expand_leftover_cleanups ()
1148 {
1149   struct eh_entry *entry;
1150
1151   while ((entry = dequeue_eh_entry (&ehqueue)) != 0)
1152     {
1153       rtx prev;
1154
1155       /* A leftover try block. Shouldn't be one here.  */
1156       if (entry->finalization == integer_zero_node)
1157         abort ();
1158
1159       /* Output the label for the start of the exception handler.  */
1160       emit_label (entry->exception_handler_label);
1161
1162       /* And now generate the insns for the handler.  */
1163       expand_expr (entry->finalization, const0_rtx, VOIDmode, 0);
1164
1165       prev = get_last_insn ();
1166       if (prev == NULL || GET_CODE (prev) != BARRIER)
1167         {
1168           if (exceptions_via_longjmp)
1169             emit_throw ();
1170           else
1171             {
1172               /* The below can be optimized away, and we could just fall into the
1173                  next EH handler, if we are certain they are nested.  */
1174               /* Emit code to throw to the outer context if we fall off
1175                  the end of the handler.  */
1176               expand_internal_throw (entry->end_label);
1177             }
1178         }
1179
1180       free (entry);
1181     }
1182 }
1183
1184 /* Called at the start of a block of try statements.  */
1185 void
1186 expand_start_try_stmts ()
1187 {
1188   if (! doing_eh (1))
1189     return;
1190
1191   expand_eh_region_start ();
1192 }
1193
1194 /* Generate RTL for the start of a group of catch clauses. 
1195
1196    It is responsible for starting a new instruction sequence for the
1197    instructions in the catch block, and expanding the handlers for the
1198    internally-generated exception regions nested within the try block
1199    corresponding to this catch block.  */
1200
1201 void
1202 expand_start_all_catch ()
1203 {
1204   struct eh_entry *entry;
1205   tree label;
1206
1207   if (! doing_eh (1))
1208     return;
1209
1210   /* End the try block.  */
1211   expand_eh_region_end (integer_zero_node);
1212
1213   emit_line_note (input_filename, lineno);
1214   label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
1215
1216   /* The label for the exception handling block that we will save.
1217      This is Lresume in the documention.  */
1218   expand_label (label);
1219   
1220   if (exceptions_via_longjmp == 0)
1221     {
1222       /* Put in something that takes up space, as otherwise the end
1223          address for the EH region could have the exact same address as
1224          the outer region, causing us to miss the fact that resuming
1225          exception handling with this PC value would be inside the outer
1226          region.  */
1227       emit_insn (gen_nop ());
1228     }
1229
1230   /* Push the label that points to where normal flow is resumed onto
1231      the top of the label stack.  */
1232   push_label_entry (&caught_return_label_stack, NULL_RTX, label);
1233
1234   /* Start a new sequence for all the catch blocks.  We will add this
1235      to the global sequence catch_clauses when we have completed all
1236      the handlers in this handler-seq.  */
1237   start_sequence ();
1238
1239   while (1)
1240     {
1241       rtx prev;
1242
1243       entry = dequeue_eh_entry (&ehqueue);
1244       /* Emit the label for the exception handler for this region, and
1245          expand the code for the handler. 
1246
1247          Note that a catch region is handled as a side-effect here;
1248          for a try block, entry->finalization will contain
1249          integer_zero_node, so no code will be generated in the
1250          expand_expr call below. But, the label for the handler will
1251          still be emitted, so any code emitted after this point will
1252          end up being the handler.  */
1253       emit_label (entry->exception_handler_label);
1254
1255       /* When we get down to the matching entry for this try block, stop.  */
1256       if (entry->finalization == integer_zero_node)
1257         {
1258           /* Don't forget to free this entry.  */
1259           free (entry);
1260           break;
1261         }
1262
1263       /* And now generate the insns for the handler.  */
1264       expand_expr (entry->finalization, const0_rtx, VOIDmode, 0);
1265
1266       prev = get_last_insn ();
1267       if (prev == NULL || GET_CODE (prev) != BARRIER)
1268         {
1269           if (exceptions_via_longjmp)
1270             emit_throw ();
1271           else
1272             {
1273               /* Code to throw out to outer context when we fall off end
1274                  of the handler. We can't do this here for catch blocks,
1275                  so it's done in expand_end_all_catch instead.
1276
1277                  The below can be optimized away (and we could just fall
1278                  into the next EH handler) if we are certain they are
1279                  nested.  */
1280
1281               expand_internal_throw (entry->end_label);
1282             }
1283         }
1284       free (entry);
1285     }
1286 }
1287
1288 /* Finish up the catch block.  At this point all the insns for the
1289    catch clauses have already been generated, so we only have to add
1290    them to the catch_clauses list. We also want to make sure that if
1291    we fall off the end of the catch clauses that we rethrow to the
1292    outer EH region.  */
1293
1294 void
1295 expand_end_all_catch ()
1296 {
1297   rtx new_catch_clause;
1298
1299   if (! doing_eh (1))
1300     return;
1301
1302   if (exceptions_via_longjmp)
1303     emit_throw ();
1304   else
1305     {
1306       /* Code to throw out to outer context, if we fall off end of catch
1307          handlers.  This is rethrow (Lresume, same id, same obj) in the
1308          documentation. We use Lresume because we know that it will throw
1309          to the correct context.
1310
1311          In other words, if the catch handler doesn't exit or return, we
1312          do a "throw" (using the address of Lresume as the point being
1313          thrown from) so that the outer EH region can then try to process
1314          the exception.  */
1315
1316       expand_internal_throw (DECL_RTL (top_label_entry (&caught_return_label_stack)));
1317     }
1318
1319   /* Now we have the complete catch sequence.  */
1320   new_catch_clause = get_insns ();
1321   end_sequence ();
1322   
1323   /* This level of catch blocks is done, so set up the successful
1324      catch jump label for the next layer of catch blocks.  */
1325   pop_label_entry (&caught_return_label_stack);
1326
1327   /* Add the new sequence of catches to the main one for this function.  */
1328   push_to_sequence (catch_clauses);
1329   emit_insns (new_catch_clause);
1330   catch_clauses = get_insns ();
1331   end_sequence ();
1332   
1333   /* Here we fall through into the continuation code.  */
1334 }
1335
1336 /* End all the pending exception regions on protect_list. The handlers
1337    will be emitted when expand_leftover_cleanups is invoked.  */
1338
1339 void
1340 end_protect_partials ()
1341 {
1342   while (protect_list)
1343     {
1344       expand_eh_region_end (TREE_VALUE (protect_list));
1345       protect_list = TREE_CHAIN (protect_list);
1346     }
1347 }
1348
1349 /* Arrange for __terminate to be called if there is an unhandled throw
1350    from within E.  */
1351
1352 tree
1353 protect_with_terminate (e)
1354      tree e;
1355 {
1356   /* We only need to do this when using setjmp/longjmp EH and the
1357      language requires it, as otherwise we protect all of the handlers
1358      at once, if we need to.  */
1359   if (exceptions_via_longjmp && protect_cleanup_actions_with_terminate)
1360     {
1361       tree handler, result;
1362
1363       /* All cleanups must be on the function_obstack.  */
1364       push_obstacks_nochange ();
1365       resume_temporary_allocation ();
1366
1367       handler = make_node (RTL_EXPR);
1368       TREE_TYPE (handler) = void_type_node;
1369       RTL_EXPR_RTL (handler) = const0_rtx;
1370       TREE_SIDE_EFFECTS (handler) = 1;
1371       start_sequence_for_rtl_expr (handler);
1372
1373       emit_library_call (terminate_libfunc, 0, VOIDmode, 0);
1374       emit_barrier ();
1375
1376       RTL_EXPR_SEQUENCE (handler) = get_insns ();
1377       end_sequence ();
1378         
1379       result = build (TRY_CATCH_EXPR, TREE_TYPE (e), e, handler);
1380       TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
1381       TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
1382       TREE_READONLY (result) = TREE_READONLY (e);
1383
1384       pop_obstacks ();
1385
1386       e = result;
1387     }
1388
1389   return e;
1390 }
1391 \f
1392 /* The exception table that we build that is used for looking up and
1393    dispatching exceptions, the current number of entries, and its
1394    maximum size before we have to extend it. 
1395
1396    The number in eh_table is the code label number of the exception
1397    handler for the region. This is added by add_eh_table_entry and
1398    used by output_exception_table_entry.  */
1399
1400 static int *eh_table;
1401 static int eh_table_size;
1402 static int eh_table_max_size;
1403
1404 /* Note the need for an exception table entry for region N.  If we
1405    don't need to output an explicit exception table, avoid all of the
1406    extra work.
1407
1408    Called from final_scan_insn when a NOTE_INSN_EH_REGION_BEG is seen.
1409    N is the NOTE_BLOCK_NUMBER of the note, which comes from the code
1410    label number of the exception handler for the region.  */
1411
1412 void
1413 add_eh_table_entry (n)
1414      int n;
1415 {
1416 #ifndef OMIT_EH_TABLE
1417   if (eh_table_size >= eh_table_max_size)
1418     {
1419       if (eh_table)
1420         {
1421           eh_table_max_size += eh_table_max_size>>1;
1422
1423           if (eh_table_max_size < 0)
1424             abort ();
1425
1426           if ((eh_table = (int *) realloc (eh_table,
1427                                            eh_table_max_size * sizeof (int)))
1428               == 0)
1429             fatal ("virtual memory exhausted");
1430         }
1431       else
1432         {
1433           eh_table_max_size = 252;
1434           eh_table = (int *) xmalloc (eh_table_max_size * sizeof (int));
1435         }
1436     }
1437   eh_table[eh_table_size++] = n;
1438 #endif
1439 }
1440
1441 /* Return a non-zero value if we need to output an exception table.
1442
1443    On some platforms, we don't have to output a table explicitly.
1444    This routine doesn't mean we don't have one.  */
1445
1446 int
1447 exception_table_p ()
1448 {
1449   if (eh_table)
1450     return 1;
1451
1452   return 0;
1453 }
1454
1455 /* Output the entry of the exception table corresponding to to the
1456    exception region numbered N to file FILE. 
1457
1458    N is the code label number corresponding to the handler of the
1459    region.  */
1460
1461 static void
1462 output_exception_table_entry (file, n)
1463      FILE *file;
1464      int n;
1465 {
1466   char buf[256];
1467   rtx sym;
1468
1469   ASM_GENERATE_INTERNAL_LABEL (buf, "LEHB", 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, "LEHE", n);
1474   sym = gen_rtx (SYMBOL_REF, Pmode, buf);
1475   assemble_integer (sym, POINTER_SIZE / BITS_PER_UNIT, 1);
1476
1477   ASM_GENERATE_INTERNAL_LABEL (buf, "L", n);
1478   sym = gen_rtx (SYMBOL_REF, Pmode, buf);
1479   assemble_integer (sym, POINTER_SIZE / BITS_PER_UNIT, 1);
1480
1481   putc ('\n', file);            /* blank line */
1482 }
1483
1484 /* Output the exception table if we have and need one.  */
1485
1486 void
1487 output_exception_table ()
1488 {
1489   int i;
1490   extern FILE *asm_out_file;
1491
1492   if (! doing_eh (0))
1493     return;
1494
1495   exception_section ();
1496
1497   /* Beginning marker for table.  */
1498   assemble_align (GET_MODE_ALIGNMENT (ptr_mode));
1499   assemble_label ("__EXCEPTION_TABLE__");
1500
1501   assemble_integer (const0_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
1502   assemble_integer (const0_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
1503   assemble_integer (const0_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
1504   putc ('\n', asm_out_file);            /* blank line */
1505
1506   for (i = 0; i < eh_table_size; ++i)
1507     output_exception_table_entry (asm_out_file, eh_table[i]);
1508
1509   free (eh_table);
1510
1511   /* Ending marker for table.  */
1512   assemble_label ("__EXCEPTION_END__");
1513   assemble_integer (constm1_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
1514   assemble_integer (constm1_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
1515   assemble_integer (constm1_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
1516   putc ('\n', asm_out_file);            /* blank line */
1517 }
1518
1519 /* Generate code to initialize the exception table at program startup
1520    time.  */
1521
1522 void
1523 register_exception_table ()
1524 {
1525   emit_library_call (gen_rtx (SYMBOL_REF, Pmode, "__register_exceptions"), 0,
1526                      VOIDmode, 1,
1527                      gen_rtx (SYMBOL_REF, Pmode, "__EXCEPTION_TABLE__"),
1528                      Pmode);
1529 }
1530 \f
1531 /* Emit the RTL for the start of the per-function unwinder for the
1532    current function. See emit_unwinder for further information.
1533
1534    DOESNT_NEED_UNWINDER is a target-specific macro that determines if
1535    the current function actually needs a per-function unwinder or not.
1536    By default, all functions need one.  */
1537
1538 void
1539 start_eh_unwinder ()
1540 {
1541 #ifdef DOESNT_NEED_UNWINDER
1542   if (DOESNT_NEED_UNWINDER)
1543     return;
1544 #endif
1545
1546   /* If we are using the setjmp/longjmp implementation, we don't need a
1547      per function unwinder.  */
1548
1549   if (exceptions_via_longjmp)
1550     return;
1551
1552   expand_eh_region_start ();
1553 }
1554
1555 /* Emit insns for the end of the per-function unwinder for the
1556    current function.  */
1557
1558 void
1559 end_eh_unwinder ()
1560 {
1561   tree expr;
1562   rtx return_val_rtx, ret_val, label, end, insns;
1563
1564   if (! doing_eh (0))
1565     return;
1566
1567 #ifdef DOESNT_NEED_UNWINDER
1568   if (DOESNT_NEED_UNWINDER)
1569     return;
1570 #endif
1571
1572   /* If we are using the setjmp/longjmp implementation, we don't need a
1573      per function unwinder.  */
1574
1575   if (exceptions_via_longjmp)
1576     return;
1577
1578   assemble_external (eh_saved_pc);
1579
1580   expr = make_node (RTL_EXPR);
1581   TREE_TYPE (expr) = void_type_node;
1582   RTL_EXPR_RTL (expr) = const0_rtx;
1583   TREE_SIDE_EFFECTS (expr) = 1;
1584   start_sequence_for_rtl_expr (expr);
1585
1586   /* ret_val will contain the address of the code where the call
1587      to the current function occurred.  */
1588   ret_val = expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
1589                                         0, hard_frame_pointer_rtx);
1590   return_val_rtx = copy_to_reg (ret_val);
1591
1592   /* Get the address we need to use to determine what exception
1593      handler should be invoked, and store it in __eh_pc.  */
1594   return_val_rtx = eh_outer_context (return_val_rtx);
1595   emit_move_insn (eh_saved_pc_rtx, return_val_rtx);
1596   
1597   /* Either set things up so we do a return directly to __throw, or
1598      we return here instead.  */
1599 #ifdef JUMP_TO_THROW
1600   emit_move_insn (ret_val, throw_libfunc);
1601 #else
1602   label = gen_label_rtx ();
1603   emit_move_insn (ret_val, gen_rtx (LABEL_REF, Pmode, label));
1604 #endif
1605
1606 #ifdef RETURN_ADDR_OFFSET
1607   return_val_rtx = plus_constant (ret_val, -RETURN_ADDR_OFFSET);
1608   if (return_val_rtx != ret_val)
1609     emit_move_insn (ret_val, return_val_rtx);
1610 #endif
1611   
1612   end = gen_label_rtx ();
1613   emit_jump (end);  
1614
1615   RTL_EXPR_SEQUENCE (expr) = get_insns ();
1616   end_sequence ();
1617
1618   expand_eh_region_end (expr);
1619
1620   emit_jump (end);
1621
1622 #ifndef JUMP_TO_THROW
1623   emit_label (label);
1624   emit_throw ();
1625 #endif
1626   
1627   expand_leftover_cleanups ();
1628
1629   emit_label (end);
1630 }
1631
1632 /* If necessary, emit insns for the per function unwinder for the
1633    current function.  Called after all the code that needs unwind
1634    protection is output.  
1635
1636    The unwinder takes care of catching any exceptions that have not
1637    been previously caught within the function, unwinding the stack to
1638    the next frame, and rethrowing using the address of the current
1639    function's caller as the context of the throw.
1640
1641    On some platforms __throw can do this by itself (or with the help
1642    of __unwind_function) so the per-function unwinder is
1643    unnecessary.
1644   
1645    We cannot place the unwinder into the function until after we know
1646    we are done inlining, as we don't want to have more than one
1647    unwinder per non-inlined function.  */
1648
1649 void
1650 emit_unwinder ()
1651 {
1652   rtx insns, insn;
1653
1654   start_sequence ();
1655   start_eh_unwinder ();
1656   insns = get_insns ();
1657   end_sequence ();
1658
1659   /* We place the start of the exception region associated with the
1660      per function unwinder at the top of the function.  */
1661   if (insns)
1662     emit_insns_after (insns, get_insns ());
1663
1664   start_sequence ();
1665   end_eh_unwinder ();
1666   insns = get_insns ();
1667   end_sequence ();
1668
1669   /* And we place the end of the exception region before the USE and
1670      CLOBBER insns that may come at the end of the function.  */
1671   if (insns == 0)
1672     return;
1673
1674   insn = get_last_insn ();
1675   while (GET_CODE (insn) == NOTE
1676          || (GET_CODE (insn) == INSN
1677              && (GET_CODE (PATTERN (insn)) == USE
1678                  || GET_CODE (PATTERN (insn)) == CLOBBER)))
1679     insn = PREV_INSN (insn);
1680
1681   if (GET_CODE (insn) == CODE_LABEL
1682       && GET_CODE (PREV_INSN (insn)) == BARRIER)
1683     {
1684       insn = PREV_INSN (insn);
1685     }
1686   else
1687     {
1688       rtx label = gen_label_rtx ();
1689       emit_label_after (label, insn);
1690       insn = emit_jump_insn_after (gen_jump (label), insn);
1691       insn = emit_barrier_after (insn);
1692     }
1693     
1694   emit_insns_after (insns, insn);
1695 }
1696
1697 /* Scan the current insns and build a list of handler labels. The
1698    resulting list is placed in the global variable exception_handler_labels.
1699
1700    It is called after the last exception handling region is added to
1701    the current function (when the rtl is almost all built for the
1702    current function) and before the jump optimization pass.  */
1703
1704 void
1705 find_exception_handler_labels ()
1706 {
1707   rtx insn;
1708   int max_labelno = max_label_num ();
1709   int min_labelno = get_first_label_num ();
1710   rtx *labels;
1711
1712   exception_handler_labels = NULL_RTX;
1713
1714   /* If we aren't doing exception handling, there isn't much to check.  */
1715   if (! doing_eh (0))
1716     return;
1717
1718   /* Generate a handy reference to each label.  */
1719
1720   labels = (rtx *) alloca ((max_labelno - min_labelno) * sizeof (rtx));
1721   bzero ((char *) labels, (max_labelno - min_labelno) * sizeof (rtx));
1722
1723   /* Arrange for labels to be indexed directly by CODE_LABEL_NUMBER.  */
1724   labels -= min_labelno;
1725
1726   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
1727     {
1728       if (GET_CODE (insn) == CODE_LABEL)
1729         if (CODE_LABEL_NUMBER (insn) >= min_labelno
1730             && CODE_LABEL_NUMBER (insn) < max_labelno)
1731           labels[CODE_LABEL_NUMBER (insn)] = insn;
1732     }
1733
1734   /* For each start of a region, add its label to the list.  */
1735
1736   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
1737     {
1738       if (GET_CODE (insn) == NOTE
1739           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
1740         {
1741           rtx label = NULL_RTX;
1742
1743           if (NOTE_BLOCK_NUMBER (insn) >= min_labelno
1744               && NOTE_BLOCK_NUMBER (insn) < max_labelno)
1745             {
1746               label = labels[NOTE_BLOCK_NUMBER (insn)];
1747
1748               if (label)
1749                 exception_handler_labels
1750                   = gen_rtx (EXPR_LIST, VOIDmode,
1751                              label, exception_handler_labels);
1752               else
1753                 warning ("didn't find handler for EH region %d",
1754                          NOTE_BLOCK_NUMBER (insn));
1755             }
1756           else
1757             warning ("mismatched EH region %d", NOTE_BLOCK_NUMBER (insn));
1758         }
1759     }
1760 }
1761
1762 /* Perform sanity checking on the exception_handler_labels list.
1763
1764    Can be called after find_exception_handler_labels is called to
1765    build the list of exception handlers for the current function and
1766    before we finish processing the current function.  */
1767
1768 void
1769 check_exception_handler_labels ()
1770 {
1771   rtx insn, handler;
1772
1773   /* If we aren't doing exception handling, there isn't much to check.  */
1774   if (! doing_eh (0))
1775     return;
1776
1777   /* Ensure that the CODE_LABEL_NUMBER for the CODE_LABEL entry point
1778      in each handler corresponds to the CODE_LABEL_NUMBER of the
1779      handler.  */
1780
1781   for (handler = exception_handler_labels;
1782        handler;
1783        handler = XEXP (handler, 1))
1784     {
1785       for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
1786         {
1787           if (GET_CODE (insn) == CODE_LABEL)
1788             {
1789               if (CODE_LABEL_NUMBER (insn)
1790                   == CODE_LABEL_NUMBER (XEXP (handler, 0)))
1791                 {
1792                   if (insn != XEXP (handler, 0))
1793                     warning ("mismatched handler %d",
1794                              CODE_LABEL_NUMBER (insn));
1795                   break;
1796                 }
1797             }
1798         }
1799       if (insn == NULL_RTX)
1800         warning ("handler not found %d",
1801                  CODE_LABEL_NUMBER (XEXP (handler, 0)));
1802     }
1803
1804   /* Now go through and make sure that for each region there is a
1805      corresponding label.  */
1806   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
1807     {
1808       if (GET_CODE (insn) == NOTE
1809           && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG
1810               || NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END))
1811         {
1812           for (handler = exception_handler_labels;
1813                handler;
1814                handler = XEXP (handler, 1))
1815             {
1816               if (CODE_LABEL_NUMBER (XEXP (handler, 0))
1817                   == NOTE_BLOCK_NUMBER (insn))
1818                 break;
1819             }
1820           if (handler == NULL_RTX)
1821             warning ("region exists, no handler %d",
1822                      NOTE_BLOCK_NUMBER (insn));
1823         }
1824     }
1825 }
1826 \f
1827 /* This group of functions initializes the exception handling data
1828    structures at the start of the compilation, initializes the data
1829    structures at the start of a function, and saves and restores the
1830    exception handling data structures for the start/end of a nested
1831    function.  */
1832
1833 /* Toplevel initialization for EH things.  */ 
1834
1835 void
1836 init_eh ()
1837 {
1838   /* Generate rtl to reference the variable in which the PC of the
1839      current context is saved.  */
1840   tree type = build_pointer_type (make_node (VOID_TYPE));
1841
1842   eh_saved_pc = build_decl (VAR_DECL, get_identifier ("__eh_pc"), type);
1843   DECL_EXTERNAL (eh_saved_pc) = 1;
1844   TREE_PUBLIC (eh_saved_pc) = 1;
1845   make_decl_rtl (eh_saved_pc, NULL_PTR, 1);
1846   eh_saved_pc_rtx = DECL_RTL (eh_saved_pc);
1847 }
1848
1849 /* Initialize the per-function EH information.  */
1850
1851 void
1852 init_eh_for_function ()
1853 {
1854   ehstack.top = 0;
1855   ehqueue.head = ehqueue.tail = 0;
1856   catch_clauses = NULL_RTX;
1857   false_label_stack = 0;
1858   caught_return_label_stack = 0;
1859   protect_list = NULL_TREE;
1860   current_function_dhc = NULL_RTX;
1861   current_function_dcc = NULL_RTX;
1862 }
1863
1864 /* Save some of the per-function EH info into the save area denoted by
1865    P. 
1866
1867    This is currently called from save_stmt_status.  */
1868
1869 void
1870 save_eh_status (p)
1871      struct function *p;
1872 {
1873   assert (p != NULL);
1874
1875   p->ehstack = ehstack;
1876   p->ehqueue = ehqueue;
1877   p->catch_clauses = catch_clauses;
1878   p->false_label_stack = false_label_stack;
1879   p->caught_return_label_stack = caught_return_label_stack;
1880   p->protect_list = protect_list;
1881   p->dhc = current_function_dhc;
1882   p->dcc = current_function_dcc;
1883
1884   init_eh ();
1885 }
1886
1887 /* Restore the per-function EH info saved into the area denoted by P.  
1888
1889    This is currently called from restore_stmt_status.  */
1890
1891 void
1892 restore_eh_status (p)
1893      struct function *p;
1894 {
1895   assert (p != NULL);
1896
1897   protect_list = p->protect_list;
1898   caught_return_label_stack = p->caught_return_label_stack;
1899   false_label_stack = p->false_label_stack;
1900   catch_clauses = p->catch_clauses;
1901   ehqueue = p->ehqueue;
1902   ehstack = p->ehstack;
1903   current_function_dhc = p->dhc;
1904   current_function_dcc = p->dcc;
1905 }
1906 \f
1907 /* This section is for the exception handling specific optimization
1908    pass.  First are the internal routines, and then the main
1909    optimization pass.  */
1910
1911 /* Determine if the given INSN can throw an exception.  */
1912
1913 static int
1914 can_throw (insn)
1915      rtx insn;
1916 {
1917   /* Calls can always potentially throw exceptions.  */
1918   if (GET_CODE (insn) == CALL_INSN)
1919     return 1;
1920
1921   if (asynchronous_exceptions)
1922     {
1923       /* If we wanted asynchronous exceptions, then everything but NOTEs
1924          and CODE_LABELs could throw.  */
1925       if (GET_CODE (insn) != NOTE && GET_CODE (insn) != CODE_LABEL)
1926         return 1;
1927     }
1928
1929   return 0;
1930 }
1931
1932 /* Scan a exception region looking for the matching end and then
1933    remove it if possible. INSN is the start of the region, N is the
1934    region number, and DELETE_OUTER is to note if anything in this
1935    region can throw.
1936
1937    Regions are removed if they cannot possibly catch an exception.
1938    This is determined by invoking can_throw on each insn within the
1939    region; if can_throw returns true for any of the instructions, the
1940    region can catch an exception, since there is an insn within the
1941    region that is capable of throwing an exception.
1942
1943    Returns the NOTE_INSN_EH_REGION_END corresponding to this region, or
1944    calls abort if it can't find one.
1945
1946    Can abort if INSN is not a NOTE_INSN_EH_REGION_BEGIN, or if N doesn't
1947    correspond to the region number, or if DELETE_OUTER is NULL.  */
1948
1949 static rtx
1950 scan_region (insn, n, delete_outer)
1951      rtx insn;
1952      int n;
1953      int *delete_outer;
1954 {
1955   rtx start = insn;
1956
1957   /* Assume we can delete the region.  */
1958   int delete = 1;
1959
1960   assert (insn != NULL_RTX
1961           && GET_CODE (insn) == NOTE
1962           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG
1963           && NOTE_BLOCK_NUMBER (insn) == n
1964           && delete_outer != NULL);
1965
1966   insn = NEXT_INSN (insn);
1967
1968   /* Look for the matching end.  */
1969   while (! (GET_CODE (insn) == NOTE
1970             && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END))
1971     {
1972       /* If anything can throw, we can't remove the region.  */
1973       if (delete && can_throw (insn))
1974         {
1975           delete = 0;
1976         }
1977
1978       /* Watch out for and handle nested regions.  */
1979       if (GET_CODE (insn) == NOTE
1980           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
1981         {
1982           insn = scan_region (insn, NOTE_BLOCK_NUMBER (insn), &delete);
1983         }
1984
1985       insn = NEXT_INSN (insn);
1986     }
1987
1988   /* The _BEG/_END NOTEs must match and nest.  */
1989   if (NOTE_BLOCK_NUMBER (insn) != n)
1990     abort ();
1991
1992   /* If anything in this exception region can throw, we can throw.  */
1993   if (! delete)
1994     *delete_outer = 0;
1995   else
1996     {
1997       /* Delete the start and end of the region.  */
1998       delete_insn (start);
1999       delete_insn (insn);
2000
2001       /* Only do this part if we have built the exception handler
2002          labels.  */
2003       if (exception_handler_labels)
2004         {
2005           rtx x, *prev = &exception_handler_labels;
2006
2007           /* Find it in the list of handlers.  */
2008           for (x = exception_handler_labels; x; x = XEXP (x, 1))
2009             {
2010               rtx label = XEXP (x, 0);
2011               if (CODE_LABEL_NUMBER (label) == n)
2012                 {
2013                   /* If we are the last reference to the handler,
2014                      delete it.  */
2015                   if (--LABEL_NUSES (label) == 0)
2016                     delete_insn (label);
2017
2018                   if (optimize)
2019                     {
2020                       /* Remove it from the list of exception handler
2021                          labels, if we are optimizing.  If we are not, then
2022                          leave it in the list, as we are not really going to
2023                          remove the region.  */
2024                       *prev = XEXP (x, 1);
2025                       XEXP (x, 1) = 0;
2026                       XEXP (x, 0) = 0;
2027                     }
2028
2029                   break;
2030                 }
2031               prev = &XEXP (x, 1);
2032             }
2033         }
2034     }
2035   return insn;
2036 }
2037
2038 /* Perform various interesting optimizations for exception handling
2039    code.
2040
2041    We look for empty exception regions and make them go (away). The
2042    jump optimization code will remove the handler if nothing else uses
2043    it.  */
2044
2045 void
2046 exception_optimize ()
2047 {
2048   rtx insn, regions = NULL_RTX;
2049   int n;
2050
2051   /* The below doesn't apply to setjmp/longjmp EH.  */
2052   if (exceptions_via_longjmp)
2053     return;
2054
2055   /* Remove empty regions.  */
2056   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2057     {
2058       if (GET_CODE (insn) == NOTE
2059           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
2060         {
2061           /* Since scan_region will return the NOTE_INSN_EH_REGION_END
2062              insn, we will indirectly skip through all the insns
2063              inbetween. We are also guaranteed that the value of insn
2064              returned will be valid, as otherwise scan_region won't
2065              return.  */
2066           insn = scan_region (insn, NOTE_BLOCK_NUMBER (insn), &n);
2067         }
2068     }
2069 }