gcc/except.c

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