gcc/except.c

   1 /* Implements exception handling.
   2    Copyright (C) 1989, 92-97, 1998 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 associated 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 implementation, cleanups are handled by allocating an
  75    exception region for the area that the cleanup is designated for,
  76    and the handler for the region performs the cleanup and then
  77    rethrows the exception to the outer exception region. From the
  78    standpoint of the current implementation, there is little
  79    distinction made between a cleanup and a user-defined handler, and
  80    the phrase "exception handler" can be used to refer to either one
  81    equally well. (The section "Future Directions" below discusses how
  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_info.  On other targets, the information for each
 101    translation unit is registered from the file generated by collect2.
 102    __register_frame_info is defined in frame.c, and is responsible for
 103    recording all of the unwind regions into one list (which is kept in a
 104    static variable named unwind_table_list).
 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 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 __terminate.
 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_exceptions.  __sjthrow is used
 381    instead of __throw, and it works by using the dynamic handler
 382    chain, and longjmp.  -fasynchronous-exceptions has no effect, as
 383    the elimination of trivial exception regions is not yet performed.
 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 "eh-common.h"
 394 #include "system.h"
 395 #include "rtl.h"
 396 #include "tree.h"
 397 #include "flags.h"
 398 #include "except.h"
 399 #include "function.h"
 400 #include "insn-flags.h"
 401 #include "expr.h"
 402 #include "insn-codes.h"
 403 #include "regs.h"
 404 #include "hard-reg-set.h"
 405 #include "insn-config.h"
 406 #include "recog.h"
 407 #include "output.h"
 408 #include "toplev.h"
 409
 410 /* One to use setjmp/longjmp method of generating code for exception
 411    handling.  */
 412
 413 int exceptions_via_longjmp = 2;
 414
 415 /* One to enable asynchronous exception support.  */
 416
 417 int asynchronous_exceptions = 0;
 418
 419 /* One to protect cleanup actions with a handler that calls
 420    __terminate, zero otherwise.  */
 421
 422 int protect_cleanup_actions_with_terminate;
 423
 424 /* A list of labels used for exception handlers.  Created by
 425    find_exception_handler_labels for the optimization passes.  */
 426
 427 rtx exception_handler_labels;
 428
 429 /* The EH context.  Nonzero if the function has already
 430    fetched a pointer to the EH context  for exception handling.  */
 431
 432 rtx current_function_ehc;
 433
 434 /* A stack used for keeping track of the currently active exception
 435    handling region.  As each exception region is started, an entry
 436    describing the region is pushed onto this stack.  The current
 437    region can be found by looking at the top of the stack, and as we
 438    exit regions, the corresponding entries are popped.
 439
 440    Entries cannot overlap; they can be nested. So there is only one
 441    entry at most that corresponds to the current instruction, and that
 442    is the entry on the top of the stack.  */
 443
 444 static struct eh_stack ehstack;
 445
 446
 447 /* This stack is used to represent what the current eh region is
 448    for the catch blocks beings processed */
 449
 450 static struct eh_stack catchstack;
 451
 452 /* A queue used for tracking which exception regions have closed but
 453    whose handlers have not yet been expanded. Regions are emitted in
 454    groups in an attempt to improve paging performance.
 455
 456    As we exit a region, we enqueue a new entry. The entries are then
 457    dequeued during expand_leftover_cleanups and expand_start_all_catch,
 458
 459    We should redo things so that we either take RTL for the handler,
 460    or we expand the handler expressed as a tree immediately at region
 461    end time.  */
 462
 463 static struct eh_queue ehqueue;
 464
 465 /* Insns for all of the exception handlers for the current function.
 466    They are currently emitted by the frontend code.  */
 467
 468 rtx catch_clauses;
 469
 470 /* A TREE_CHAINed list of handlers for regions that are not yet
 471    closed. The TREE_VALUE of each entry contains the handler for the
 472    corresponding entry on the ehstack.  */
 473
 474 static tree protect_list;
 475
 476 /* Stacks to keep track of various labels.  */
 477
 478 /* Keeps track of the label to resume to should one want to resume
 479    normal control flow out of a handler (instead of, say, returning to
 480    the caller of the current function or exiting the program).  */
 481
 482 struct label_node *caught_return_label_stack = NULL;
 483
 484 /* Keeps track of the label used as the context of a throw to rethrow an
 485    exception to the outer exception region.  */
 486
 487 struct label_node *outer_context_label_stack = NULL;
 488
 489 /* A random data area for the front end's own use.  */
 490
 491 struct label_node *false_label_stack = NULL;
 492
 493 static void push_eh_entry       PROTO((struct eh_stack *));
 494 static struct eh_entry * pop_eh_entry           PROTO((struct eh_stack *));
 495 static void enqueue_eh_entry    PROTO((struct eh_queue *, struct eh_entry *));
 496 static struct eh_entry * dequeue_eh_entry       PROTO((struct eh_queue *));
 497 static rtx call_get_eh_context  PROTO((void));
 498 static void start_dynamic_cleanup               PROTO((tree, tree));
 499 static void start_dynamic_handler               PROTO((void));
 500 static void expand_rethrow      PROTO((rtx));
 501 static void output_exception_table_entry        PROTO((FILE *, int));
 502 static int can_throw            PROTO((rtx));
 503 static rtx scan_region          PROTO((rtx, int, int *));
 504 static void eh_regs             PROTO((rtx *, rtx *, int));
 505 static void set_insn_eh_region  PROTO((rtx *, int));
 506 #ifdef DONT_USE_BUILTIN_SETJMP
 507 static void jumpif_rtx          PROTO((rtx, rtx));
 508 #endif
 509
 510
 511 rtx expand_builtin_return_addr  PROTO((enum built_in_function, int, rtx));
 512 \f
 513 /* Various support routines to manipulate the various data structures
 514    used by the exception handling code.  */
 515
 516 /* Push a label entry onto the given STACK.  */
 517
 518 void
 519 push_label_entry (stack, rlabel, tlabel)
 520      struct label_node **stack;
 521      rtx rlabel;
 522      tree tlabel;
 523 {
 524   struct label_node *newnode
 525     = (struct label_node *) xmalloc (sizeof (struct label_node));
 526
 527   if (rlabel)
 528     newnode->u.rlabel = rlabel;
 529   else
 530     newnode->u.tlabel = tlabel;
 531   newnode->chain = *stack;
 532   *stack = newnode;
 533 }
 534
 535 /* Pop a label entry from the given STACK.  */
 536
 537 rtx
 538 pop_label_entry (stack)
 539      struct label_node **stack;
 540 {
 541   rtx label;
 542   struct label_node *tempnode;
 543
 544   if (! *stack)
 545     return NULL_RTX;
 546
 547   tempnode = *stack;
 548   label = tempnode->u.rlabel;
 549   *stack = (*stack)->chain;
 550   free (tempnode);
 551
 552   return label;
 553 }
 554
 555 /* Return the top element of the given STACK.  */
 556
 557 tree
 558 top_label_entry (stack)
 559      struct label_node **stack;
 560 {
 561   if (! *stack)
 562     return NULL_TREE;
 563
 564   return (*stack)->u.tlabel;
 565 }
 566
 567 /* get an exception label. These must be on the permanent obstack */
 568
 569 rtx
 570 gen_exception_label ()
 571 {
 572   rtx lab;
 573
 574   push_obstacks_nochange ();
 575   end_temporary_allocation ();
 576   lab = gen_label_rtx ();
 577   pop_obstacks ();
 578   return lab;
 579 }
 580
 581 /* Push a new eh_node entry onto STACK.  */
 582
 583 static void
 584 push_eh_entry (stack)
 585      struct eh_stack *stack;
 586 {
 587   struct eh_node *node = (struct eh_node *) xmalloc (sizeof (struct eh_node));
 588   struct eh_entry *entry = (struct eh_entry *) xmalloc (sizeof (struct eh_entry));
 589
 590   entry->outer_context = gen_label_rtx ();
 591   entry->finalization = NULL_TREE;
 592   entry->label_used = 0;
 593   entry->exception_handler_label = gen_exception_label ();
 594
 595   node->entry = entry;
 596   node->chain = stack->top;
 597   stack->top = node;
 598 }
 599
 600 /* push an existing entry onto a stack. */
 601 static void
 602 push_entry (stack, entry)
 603      struct eh_stack *stack;
 604      struct eh_entry *entry;
 605 {
 606   struct eh_node *node = (struct eh_node *) xmalloc (sizeof (struct eh_node));
 607   node->entry = entry;
 608   node->chain = stack->top;
 609   stack->top = node;
 610 }
 611
 612 /* Pop an entry from the given STACK.  */
 613
 614 static struct eh_entry *
 615 pop_eh_entry (stack)
 616      struct eh_stack *stack;
 617 {
 618   struct eh_node *tempnode;
 619   struct eh_entry *tempentry;
 620
 621   tempnode = stack->top;
 622   tempentry = tempnode->entry;
 623   stack->top = stack->top->chain;
 624   free (tempnode);
 625
 626   return tempentry;
 627 }
 628
 629 /* Enqueue an ENTRY onto the given QUEUE.  */
 630
 631 static void
 632 enqueue_eh_entry (queue, entry)
 633      struct eh_queue *queue;
 634      struct eh_entry *entry;
 635 {
 636   struct eh_node *node = (struct eh_node *) xmalloc (sizeof (struct eh_node));
 637
 638   node->entry = entry;
 639   node->chain = NULL;
 640
 641   if (queue->head == NULL)
 642     {
 643       queue->head = node;
 644     }
 645   else
 646     {
 647       queue->tail->chain = node;
 648     }
 649   queue->tail = node;
 650 }
 651
 652 /* Dequeue an entry from the given QUEUE.  */
 653
 654 static struct eh_entry *
 655 dequeue_eh_entry (queue)
 656      struct eh_queue *queue;
 657 {
 658   struct eh_node *tempnode;
 659   struct eh_entry *tempentry;
 660
 661   if (queue->head == NULL)
 662     return NULL;
 663
 664   tempnode = queue->head;
 665   queue->head = queue->head->chain;
 666
 667   tempentry = tempnode->entry;
 668   free (tempnode);
 669
 670   return tempentry;
 671 }
 672
 673 static void
 674 receive_exception_label (handler_label)
 675      rtx handler_label;
 676 {
 677   emit_label (handler_label);
 678
 679 #ifdef HAVE_exception_receiver
 680   if (! exceptions_via_longjmp)
 681     if (HAVE_exception_receiver)
 682       emit_insn (gen_exception_receiver ());
 683 #endif
 684
 685 #ifdef HAVE_nonlocal_goto_receiver
 686   if (! exceptions_via_longjmp)
 687     if (HAVE_nonlocal_goto_receiver)
 688       emit_insn (gen_nonlocal_goto_receiver ());
 689 #endif
 690 }
 691
 692
 693 struct func_eh_entry
 694 {
 695   int range_number;   /* EH region number from EH NOTE insn's */
 696   struct handler_info *handlers;
 697 };
 698
 699
 700 /* table of function eh regions */
 701 static struct func_eh_entry *function_eh_regions = NULL;
 702 static int num_func_eh_entries = 0;
 703 static int current_func_eh_entry = 0;
 704
 705 #define SIZE_FUNC_EH(X)   (sizeof (struct func_eh_entry) * X)
 706
 707 /* Add a new eh_entry for this function, and base it off of the information
 708    in the EH_ENTRY parameter. A NULL parameter is invalid. The number
 709    returned is an number which uniquely identifies this exception range. */
 710
 711 int
 712 new_eh_region_entry (note_eh_region)
 713      int note_eh_region;
 714 {
 715   if (current_func_eh_entry == num_func_eh_entries)
 716     {
 717       if (num_func_eh_entries == 0)
 718         {
 719           function_eh_regions =
 720                         (struct func_eh_entry *) malloc (SIZE_FUNC_EH (50));
 721           num_func_eh_entries = 50;
 722         }
 723       else
 724         {
 725           num_func_eh_entries  = num_func_eh_entries * 3 / 2;
 726           function_eh_regions = (struct func_eh_entry *)
 727             realloc (function_eh_regions, SIZE_FUNC_EH (num_func_eh_entries));
 728         }
 729     }
 730   function_eh_regions[current_func_eh_entry].range_number = note_eh_region;
 731   function_eh_regions[current_func_eh_entry].handlers = NULL;
 732
 733   return current_func_eh_entry++;
 734 }
 735
 736 /* Add new handler information to an exception range. The  first parameter
 737    specifies the range number (returned from new_eh_entry()). The second
 738    parameter specifies the handler.  By default the handler is inserted at
 739    the end of the list. A handler list may contain only ONE NULL_TREE
 740    typeinfo entry. Regardless where it is positioned, a NULL_TREE entry
 741    is always output as the LAST handler in the exception table for a region. */
 742
 743 void
 744 add_new_handler (region, newhandler)
 745      int region;
 746      struct handler_info *newhandler;
 747 {
 748   struct handler_info *last;
 749
 750   newhandler->next = NULL;
 751   last = function_eh_regions[region].handlers;
 752   if (last == NULL)
 753     function_eh_regions[region].handlers = newhandler;
 754   else
 755     {
 756       for ( ; last->next != NULL; last = last->next)
 757         ;
 758       last->next = newhandler;
 759     }
 760 }
 761
 762 /* Remove a handler label. The handler label is being deleted, so all
 763    regions which reference this handler should have it removed from their
 764    list of possible handlers. Any region which has the final handler
 765    removed can be deleted. */
 766
 767 void remove_handler (removing_label)
 768      rtx removing_label;
 769 {
 770   struct handler_info *handler, *last;
 771   int x;
 772   for (x = 0 ; x < current_func_eh_entry; ++x)
 773     {
 774       last = NULL;
 775       handler = function_eh_regions[x].handlers;
 776       for ( ; handler; last = handler, handler = handler->next)
 777         if (handler->handler_label == removing_label)
 778           {
 779             if (last)
 780               {
 781                 last->next = handler->next;
 782                 handler = last;
 783               }
 784             else
 785               function_eh_regions[x].handlers = handler->next;
 786           }
 787     }
 788 }
 789
 790 /* Create a new handler structure initialized with the handler label and
 791    typeinfo fields passed in. */
 792
 793 struct handler_info *
 794 get_new_handler (handler, typeinfo)
 795      rtx handler;
 796      void *typeinfo;
 797 {
 798   struct handler_info* ptr;
 799   ptr = (struct handler_info *) malloc (sizeof (struct handler_info));
 800   ptr->handler_label = handler;
 801   ptr->type_info = typeinfo;
 802   ptr->next = NULL;
 803
 804   return ptr;
 805 }
 806
 807
 808
 809 /* Find the index in function_eh_regions associated with a NOTE region. If
 810    the region cannot be found, a -1 is returned. This should never happen! */
 811
 812 int
 813 find_func_region (insn_region)
 814      int insn_region;
 815 {
 816   int x;
 817   for (x = 0; x < current_func_eh_entry; x++)
 818     if (function_eh_regions[x].range_number == insn_region)
 819       return x;
 820
 821   return -1;
 822 }
 823
 824 /* Get a pointer to the first handler in an exception region's list. */
 825
 826 struct handler_info *
 827 get_first_handler (region)
 828      int region;
 829 {
 830   return function_eh_regions[find_func_region (region)].handlers;
 831 }
 832
 833 /* Clean out the function_eh_region table and free all memory */
 834
 835 static void
 836 clear_function_eh_region ()
 837 {
 838   int x;
 839   struct handler_info *ptr, *next;
 840   for (x = 0; x < current_func_eh_entry; x++)
 841     for (ptr = function_eh_regions[x].handlers; ptr != NULL; ptr = next)
 842       {
 843         next = ptr->next;
 844         free (ptr);
 845       }
 846   free (function_eh_regions);
 847   num_func_eh_entries  = 0;
 848   current_func_eh_entry = 0;
 849 }
 850
 851 /* Make a duplicate of an exception region by copying all the handlers
 852    for an exception region. Return the new handler index. */
 853
 854 int
 855 duplicate_handlers (old_note_eh_region, new_note_eh_region)
 856      int old_note_eh_region, new_note_eh_region;
 857 {
 858   struct handler_info *ptr, *new_ptr;
 859   int new_region, region;
 860
 861   region = find_func_region (old_note_eh_region);
 862   if (region == -1)
 863     error ("Cannot duplicate non-existant exception region.");
 864
 865   if (find_func_region (new_note_eh_region) != -1)
 866     error ("Cannot duplicate EH region because new note region already exists");
 867
 868   new_region = new_eh_region_entry (new_note_eh_region);
 869   ptr = function_eh_regions[region].handlers;
 870
 871   for ( ; ptr; ptr = ptr->next)
 872     {
 873       new_ptr = get_new_handler (ptr->handler_label, ptr->type_info);
 874       add_new_handler (new_region, new_ptr);
 875     }
 876
 877   return new_region;
 878 }
 879
 880 \f
 881 /* Routine to see if exception handling is turned on.
 882    DO_WARN is non-zero if we want to inform the user that exception
 883    handling is turned off.
 884
 885    This is used to ensure that -fexceptions has been specified if the
 886    compiler tries to use any exception-specific functions.  */
 887
 888 int
 889 doing_eh (do_warn)
 890      int do_warn;
 891 {
 892   if (! flag_exceptions)
 893     {
 894       static int warned = 0;
 895       if (! warned && do_warn)
 896         {
 897           error ("exception handling disabled, use -fexceptions to enable");
 898           warned = 1;
 899         }
 900       return 0;
 901     }
 902   return 1;
 903 }
 904
 905 /* Given a return address in ADDR, determine the address we should use
 906    to find the corresponding EH region.  */
 907
 908 rtx
 909 eh_outer_context (addr)
 910      rtx addr;
 911 {
 912   /* First mask out any unwanted bits.  */
 913 #ifdef MASK_RETURN_ADDR
 914   expand_and (addr, MASK_RETURN_ADDR, addr);
 915 #endif
 916
 917   /* Then adjust to find the real return address.  */
 918 #if defined (RETURN_ADDR_OFFSET)
 919   addr = plus_constant (addr, RETURN_ADDR_OFFSET);
 920 #endif
 921
 922   return addr;
 923 }
 924
 925 /* Start a new exception region for a region of code that has a
 926    cleanup action and push the HANDLER for the region onto
 927    protect_list. All of the regions created with add_partial_entry
 928    will be ended when end_protect_partials is invoked.  */
 929
 930 void
 931 add_partial_entry (handler)
 932      tree handler;
 933 {
 934   expand_eh_region_start ();
 935
 936   /* Make sure the entry is on the correct obstack.  */
 937   push_obstacks_nochange ();
 938   resume_temporary_allocation ();
 939
 940   /* Because this is a cleanup action, we may have to protect the handler
 941      with __terminate.  */
 942   handler = protect_with_terminate (handler);
 943
 944   protect_list = tree_cons (NULL_TREE, handler, protect_list);
 945   pop_obstacks ();
 946 }
 947
 948 /* Emit code to get EH context to current function.  */
 949
 950 static rtx
 951 call_get_eh_context ()
 952 {
 953   static tree fn;
 954   tree expr;
 955
 956   if (fn == NULL_TREE)
 957     {
 958       tree fntype;
 959       fn = get_identifier ("__get_eh_context");
 960       push_obstacks_nochange ();
 961       end_temporary_allocation ();
 962       fntype = build_pointer_type (build_pointer_type
 963                                    (build_pointer_type (void_type_node)));
 964       fntype = build_function_type (fntype, NULL_TREE);
 965       fn = build_decl (FUNCTION_DECL, fn, fntype);
 966       DECL_EXTERNAL (fn) = 1;
 967       TREE_PUBLIC (fn) = 1;
 968       DECL_ARTIFICIAL (fn) = 1;
 969       TREE_READONLY (fn) = 1;
 970       make_decl_rtl (fn, NULL_PTR, 1);
 971       assemble_external (fn);
 972       pop_obstacks ();
 973     }
 974
 975   expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
 976   expr = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
 977                 expr, NULL_TREE, NULL_TREE);
 978   TREE_SIDE_EFFECTS (expr) = 1;
 979
 980   return copy_to_reg (expand_expr (expr, NULL_RTX, VOIDmode, 0));
 981 }
 982
 983 /* Get a reference to the EH context.
 984    We will only generate a register for the current function EH context here,
 985    and emit a USE insn to mark that this is a EH context register.
 986
 987    Later, emit_eh_context will emit needed call to __get_eh_context
 988    in libgcc2, and copy the value to the register we have generated. */
 989
 990 rtx
 991 get_eh_context ()
 992 {
 993   if (current_function_ehc == 0)
 994     {
 995       rtx insn;
 996
 997       current_function_ehc = gen_reg_rtx (Pmode);
 998
 999       insn = gen_rtx_USE (GET_MODE (current_function_ehc),
1000                           current_function_ehc);
1001       insn = emit_insn_before (insn, get_first_nonparm_insn ());
1002
1003       REG_NOTES (insn)
1004         = gen_rtx_EXPR_LIST (REG_EH_CONTEXT, current_function_ehc,
1005                              REG_NOTES (insn));
1006     }
1007   return current_function_ehc;
1008 }
1009
1010 /* Get a reference to the dynamic handler chain.  It points to the
1011    pointer to the next element in the dynamic handler chain.  It ends
1012    when there are no more elements in the dynamic handler chain, when
1013    the value is &top_elt from libgcc2.c.  Immediately after the
1014    pointer, is an area suitable for setjmp/longjmp when
1015    DONT_USE_BUILTIN_SETJMP is defined, and an area suitable for
1016    __builtin_setjmp/__builtin_longjmp when DONT_USE_BUILTIN_SETJMP
1017    isn't defined. */
1018
1019 rtx
1020 get_dynamic_handler_chain ()
1021 {
1022   rtx ehc, dhc, result;
1023
1024   ehc = get_eh_context ();
1025
1026   /* This is the offset of dynamic_handler_chain in the eh_context struct
1027      declared in eh-common.h. If its location is change, change this offset */
1028   dhc = plus_constant (ehc, POINTER_SIZE / BITS_PER_UNIT);
1029
1030   result = copy_to_reg (dhc);
1031
1032   /* We don't want a copy of the dcc, but rather, the single dcc.  */
1033   return gen_rtx_MEM (Pmode, result);
1034 }
1035
1036 /* Get a reference to the dynamic cleanup chain.  It points to the
1037    pointer to the next element in the dynamic cleanup chain.
1038    Immediately after the pointer, are two Pmode variables, one for a
1039    pointer to a function that performs the cleanup action, and the
1040    second, the argument to pass to that function.  */
1041
1042 rtx
1043 get_dynamic_cleanup_chain ()
1044 {
1045   rtx dhc, dcc, result;
1046
1047   dhc = get_dynamic_handler_chain ();
1048   dcc = plus_constant (dhc, POINTER_SIZE / BITS_PER_UNIT);
1049
1050   result = copy_to_reg (dcc);
1051
1052   /* We don't want a copy of the dcc, but rather, the single dcc.  */
1053   return gen_rtx_MEM (Pmode, result);
1054 }
1055
1056 #ifdef DONT_USE_BUILTIN_SETJMP
1057 /* Generate code to evaluate X and jump to LABEL if the value is nonzero.
1058    LABEL is an rtx of code CODE_LABEL, in this function.  */
1059
1060 static void
1061 jumpif_rtx (x, label)
1062      rtx x;
1063      rtx label;
1064 {
1065   jumpif (make_tree (type_for_mode (GET_MODE (x), 0), x), label);
1066 }
1067 #endif
1068
1069 /* Start a dynamic cleanup on the EH runtime dynamic cleanup stack.
1070    We just need to create an element for the cleanup list, and push it
1071    into the chain.
1072
1073    A dynamic cleanup is a cleanup action implied by the presence of an
1074    element on the EH runtime dynamic cleanup stack that is to be
1075    performed when an exception is thrown.  The cleanup action is
1076    performed by __sjthrow when an exception is thrown.  Only certain
1077    actions can be optimized into dynamic cleanup actions.  For the
1078    restrictions on what actions can be performed using this routine,
1079    see expand_eh_region_start_tree.  */
1080
1081 static void
1082 start_dynamic_cleanup (func, arg)
1083      tree func;
1084      tree arg;
1085 {
1086   rtx dcc;
1087   rtx new_func, new_arg;
1088   rtx x, buf;
1089   int size;
1090
1091   /* We allocate enough room for a pointer to the function, and
1092      one argument.  */
1093   size = 2;
1094
1095   /* XXX, FIXME: The stack space allocated this way is too long lived,
1096      but there is no allocation routine that allocates at the level of
1097      the last binding contour.  */
1098   buf = assign_stack_local (BLKmode,
1099                             GET_MODE_SIZE (Pmode)*(size+1),
1100                             0);
1101
1102   buf = change_address (buf, Pmode, NULL_RTX);
1103
1104   /* Store dcc into the first word of the newly allocated buffer.  */
1105
1106   dcc = get_dynamic_cleanup_chain ();
1107   emit_move_insn (buf, dcc);
1108
1109   /* Store func and arg into the cleanup list element.  */
1110
1111   new_func = gen_rtx_MEM (Pmode, plus_constant (XEXP (buf, 0),
1112                                                 GET_MODE_SIZE (Pmode)));
1113   new_arg = gen_rtx_MEM (Pmode, plus_constant (XEXP (buf, 0),
1114                                                GET_MODE_SIZE (Pmode)*2));
1115   x = expand_expr (func, new_func, Pmode, 0);
1116   if (x != new_func)
1117     emit_move_insn (new_func, x);
1118
1119   x = expand_expr (arg, new_arg, Pmode, 0);
1120   if (x != new_arg)
1121     emit_move_insn (new_arg, x);
1122
1123   /* Update the cleanup chain.  */
1124
1125   emit_move_insn (dcc, XEXP (buf, 0));
1126 }
1127
1128 /* Emit RTL to start a dynamic handler on the EH runtime dynamic
1129    handler stack.  This should only be used by expand_eh_region_start
1130    or expand_eh_region_start_tree.  */
1131
1132 static void
1133 start_dynamic_handler ()
1134 {
1135   rtx dhc, dcc;
1136   rtx x, arg, buf;
1137   int size;
1138
1139 #ifndef DONT_USE_BUILTIN_SETJMP
1140   /* The number of Pmode words for the setjmp buffer, when using the
1141      builtin setjmp/longjmp, see expand_builtin, case
1142      BUILT_IN_LONGJMP.  */
1143   size = 5;
1144 #else
1145 #ifdef JMP_BUF_SIZE
1146   size = JMP_BUF_SIZE;
1147 #else
1148   /* Should be large enough for most systems, if it is not,
1149      JMP_BUF_SIZE should be defined with the proper value.  It will
1150      also tend to be larger than necessary for most systems, a more
1151      optimal port will define JMP_BUF_SIZE.  */
1152   size = FIRST_PSEUDO_REGISTER+2;
1153 #endif
1154 #endif
1155   /* XXX, FIXME: The stack space allocated this way is too long lived,
1156      but there is no allocation routine that allocates at the level of
1157      the last binding contour.  */
1158   arg = assign_stack_local (BLKmode,
1159                             GET_MODE_SIZE (Pmode)*(size+1),
1160                             0);
1161
1162   arg = change_address (arg, Pmode, NULL_RTX);
1163
1164   /* Store dhc into the first word of the newly allocated buffer.  */
1165
1166   dhc = get_dynamic_handler_chain ();
1167   dcc = gen_rtx_MEM (Pmode, plus_constant (XEXP (arg, 0),
1168                                            GET_MODE_SIZE (Pmode)));
1169   emit_move_insn (arg, dhc);
1170
1171   /* Zero out the start of the cleanup chain.  */
1172   emit_move_insn (dcc, const0_rtx);
1173
1174   /* The jmpbuf starts two words into the area allocated.  */
1175   buf = plus_constant (XEXP (arg, 0), GET_MODE_SIZE (Pmode)*2);
1176
1177 #ifdef DONT_USE_BUILTIN_SETJMP
1178   x = emit_library_call_value (setjmp_libfunc, NULL_RTX, 1, SImode, 1,
1179                                buf, Pmode);
1180   /* If we come back here for a catch, transfer control to the handler.  */
1181   jumpif_rtx (x, ehstack.top->entry->exception_handler_label);
1182 #else
1183   {
1184     /* A label to continue execution for the no exception case.  */
1185     rtx noex = gen_label_rtx();
1186     x = expand_builtin_setjmp (buf, NULL_RTX, noex,
1187                                ehstack.top->entry->exception_handler_label);
1188     emit_label (noex);
1189   }
1190 #endif
1191
1192   /* We are committed to this, so update the handler chain.  */
1193
1194   emit_move_insn (dhc, XEXP (arg, 0));
1195 }
1196
1197 /* Start an exception handling region for the given cleanup action.
1198    All instructions emitted after this point are considered to be part
1199    of the region until expand_eh_region_end is invoked.  CLEANUP is
1200    the cleanup action to perform.  The return value is true if the
1201    exception region was optimized away.  If that case,
1202    expand_eh_region_end does not need to be called for this cleanup,
1203    nor should it be.
1204
1205    This routine notices one particular common case in C++ code
1206    generation, and optimizes it so as to not need the exception
1207    region.  It works by creating a dynamic cleanup action, instead of
1208    a using an exception region.  */
1209
1210 int
1211 expand_eh_region_start_tree (decl, cleanup)
1212      tree decl;
1213      tree cleanup;
1214 {
1215   /* This is the old code.  */
1216   if (! doing_eh (0))
1217     return 0;
1218
1219   /* The optimization only applies to actions protected with
1220      terminate, and only applies if we are using the setjmp/longjmp
1221      codegen method.  */
1222   if (exceptions_via_longjmp
1223       && protect_cleanup_actions_with_terminate)
1224     {
1225       tree func, arg;
1226       tree args;
1227
1228       /* Ignore any UNSAVE_EXPR.  */
1229       if (TREE_CODE (cleanup) == UNSAVE_EXPR)
1230         cleanup = TREE_OPERAND (cleanup, 0);
1231
1232       /* Further, it only applies if the action is a call, if there
1233          are 2 arguments, and if the second argument is 2.  */
1234
1235       if (TREE_CODE (cleanup) == CALL_EXPR
1236           && (args = TREE_OPERAND (cleanup, 1))
1237           && (func = TREE_OPERAND (cleanup, 0))
1238           && (arg = TREE_VALUE (args))
1239           && (args = TREE_CHAIN (args))
1240
1241           /* is the second argument 2?  */
1242           && TREE_CODE (TREE_VALUE (args)) == INTEGER_CST
1243           && TREE_INT_CST_LOW (TREE_VALUE (args)) == 2
1244           && TREE_INT_CST_HIGH (TREE_VALUE (args)) == 0
1245
1246           /* Make sure there are no other arguments.  */
1247           && TREE_CHAIN (args) == NULL_TREE)
1248         {
1249           /* Arrange for returns and gotos to pop the entry we make on the
1250              dynamic cleanup stack.  */
1251           expand_dcc_cleanup (decl);
1252           start_dynamic_cleanup (func, arg);
1253           return 1;
1254         }
1255     }
1256
1257   expand_eh_region_start_for_decl (decl);
1258   ehstack.top->entry->finalization = cleanup;
1259
1260   return 0;
1261 }
1262
1263 /* Just like expand_eh_region_start, except if a cleanup action is
1264    entered on the cleanup chain, the TREE_PURPOSE of the element put
1265    on the chain is DECL.  DECL should be the associated VAR_DECL, if
1266    any, otherwise it should be NULL_TREE.  */
1267
1268 void
1269 expand_eh_region_start_for_decl (decl)
1270      tree decl;
1271 {
1272   rtx note;
1273
1274   /* This is the old code.  */
1275   if (! doing_eh (0))
1276     return;
1277
1278   if (exceptions_via_longjmp)
1279     {
1280       /* We need a new block to record the start and end of the
1281          dynamic handler chain.  We could always do this, but we
1282          really want to permit jumping into such a block, and we want
1283          to avoid any errors or performance impact in the SJ EH code
1284          for now.  */
1285       expand_start_bindings (0);
1286
1287       /* But we don't need or want a new temporary level.  */
1288       pop_temp_slots ();
1289
1290       /* Mark this block as created by expand_eh_region_start.  This
1291          is so that we can pop the block with expand_end_bindings
1292          automatically.  */
1293       mark_block_as_eh_region ();
1294
1295       /* Arrange for returns and gotos to pop the entry we make on the
1296          dynamic handler stack.  */
1297       expand_dhc_cleanup (decl);
1298     }
1299
1300   push_eh_entry (&ehstack);
1301   note = emit_note (NULL_PTR, NOTE_INSN_EH_REGION_BEG);
1302   NOTE_BLOCK_NUMBER (note)
1303     = CODE_LABEL_NUMBER (ehstack.top->entry->exception_handler_label);
1304   if (exceptions_via_longjmp)
1305     start_dynamic_handler ();
1306 }
1307
1308 /* Start an exception handling region.  All instructions emitted after
1309    this point are considered to be part of the region until
1310    expand_eh_region_end is invoked.  */
1311
1312 void
1313 expand_eh_region_start ()
1314 {
1315   expand_eh_region_start_for_decl (NULL_TREE);
1316 }
1317
1318 /* End an exception handling region.  The information about the region
1319    is found on the top of ehstack.
1320
1321    HANDLER is either the cleanup for the exception region, or if we're
1322    marking the end of a try block, HANDLER is integer_zero_node.
1323
1324    HANDLER will be transformed to rtl when expand_leftover_cleanups
1325    is invoked.  */
1326
1327 void
1328 expand_eh_region_end (handler)
1329      tree handler;
1330 {
1331   struct eh_entry *entry;
1332   rtx note;
1333
1334   if (! doing_eh (0))
1335     return;
1336
1337   entry = pop_eh_entry (&ehstack);
1338
1339   note = emit_note (NULL_PTR, NOTE_INSN_EH_REGION_END);
1340   NOTE_BLOCK_NUMBER (note)
1341     = CODE_LABEL_NUMBER (entry->exception_handler_label);
1342   if (exceptions_via_longjmp == 0
1343       /* We share outer_context between regions; only emit it once.  */
1344       && INSN_UID (entry->outer_context) == 0)
1345     {
1346       rtx label;
1347
1348       label = gen_label_rtx ();
1349       emit_jump (label);
1350
1351       /* Emit a label marking the end of this exception region that
1352          is used for rethrowing into the outer context.  */
1353       emit_label (entry->outer_context);
1354       expand_internal_throw ();
1355
1356       emit_label (label);
1357     }
1358
1359   entry->finalization = handler;
1360
1361   /* create region entry in final exception table */
1362   new_eh_region_entry (NOTE_BLOCK_NUMBER (note));
1363
1364   enqueue_eh_entry (&ehqueue, entry);
1365
1366   /* If we have already started ending the bindings, don't recurse.
1367      This only happens when exceptions_via_longjmp is true.  */
1368   if (is_eh_region ())
1369     {
1370       /* Because we don't need or want a new temporary level and
1371          because we didn't create one in expand_eh_region_start,
1372          create a fake one now to avoid removing one in
1373          expand_end_bindings.  */
1374       push_temp_slots ();
1375
1376       mark_block_as_not_eh_region ();
1377
1378       /* Maybe do this to prevent jumping in and so on...  */
1379       expand_end_bindings (NULL_TREE, 0, 0);
1380     }
1381 }
1382
1383 /* End the EH region for a goto fixup.  We only need them in the region-based
1384    EH scheme.  */
1385
1386 void
1387 expand_fixup_region_start ()
1388 {
1389   if (! doing_eh (0) || exceptions_via_longjmp)
1390     return;
1391
1392   expand_eh_region_start ();
1393 }
1394
1395 /* End the EH region for a goto fixup.  CLEANUP is the cleanup we just
1396    expanded; to avoid running it twice if it throws, we look through the
1397    ehqueue for a matching region and rethrow from its outer_context.  */
1398
1399 void
1400 expand_fixup_region_end (cleanup)
1401      tree cleanup;
1402 {
1403   struct eh_node *node;
1404
1405   if (! doing_eh (0) || exceptions_via_longjmp)
1406     return;
1407
1408   for (node = ehstack.top; node && node->entry->finalization != cleanup; )
1409     node = node->chain;
1410   if (node == 0)
1411     for (node = ehqueue.head; node && node->entry->finalization != cleanup; )
1412       node = node->chain;
1413   if (node == 0)
1414     abort ();
1415
1416   ehstack.top->entry->outer_context = node->entry->outer_context;
1417
1418   /* Just rethrow.  size_zero_node is just a NOP.  */
1419   expand_eh_region_end (size_zero_node);
1420 }
1421
1422 /* If we are using the setjmp/longjmp EH codegen method, we emit a
1423    call to __sjthrow.
1424
1425    Otherwise, we emit a call to __throw and note that we threw
1426    something, so we know we need to generate the necessary code for
1427    __throw.
1428
1429    Before invoking throw, the __eh_pc variable must have been set up
1430    to contain the PC being thrown from. This address is used by
1431    __throw to determine which exception region (if any) is
1432    responsible for handling the exception.  */
1433
1434 void
1435 emit_throw ()
1436 {
1437   if (exceptions_via_longjmp)
1438     {
1439       emit_library_call (sjthrow_libfunc, 0, VOIDmode, 0);
1440     }
1441   else
1442     {
1443 #ifdef JUMP_TO_THROW
1444       emit_indirect_jump (throw_libfunc);
1445 #else
1446       emit_library_call (throw_libfunc, 0, VOIDmode, 0);
1447 #endif
1448     }
1449   emit_barrier ();
1450 }
1451
1452 /* Throw the current exception.  If appropriate, this is done by jumping
1453    to the next handler.  */
1454
1455 void
1456 expand_internal_throw ()
1457 {
1458   emit_throw ();
1459 }
1460
1461 /* Called from expand_exception_blocks and expand_end_catch_block to
1462    emit any pending handlers/cleanups queued from expand_eh_region_end.  */
1463
1464 void
1465 expand_leftover_cleanups ()
1466 {
1467   struct eh_entry *entry;
1468
1469   while ((entry = dequeue_eh_entry (&ehqueue)) != 0)
1470     {
1471       rtx prev;
1472
1473       /* A leftover try block. Shouldn't be one here.  */
1474       if (entry->finalization == integer_zero_node)
1475         abort ();
1476
1477       /* Output the label for the start of the exception handler.  */
1478
1479       receive_exception_label (entry->exception_handler_label);
1480
1481       /* register a handler for this cleanup region */
1482       add_new_handler (
1483         find_func_region (CODE_LABEL_NUMBER (entry->exception_handler_label)),
1484         get_new_handler (entry->exception_handler_label, NULL));
1485
1486       /* And now generate the insns for the handler.  */
1487       expand_expr (entry->finalization, const0_rtx, VOIDmode, 0);
1488
1489       prev = get_last_insn ();
1490       if (prev == NULL || GET_CODE (prev) != BARRIER)
1491         /* Emit code to throw to the outer context if we fall off
1492            the end of the handler.  */
1493         expand_rethrow (entry->outer_context);
1494
1495       do_pending_stack_adjust ();
1496       free (entry);
1497     }
1498 }
1499
1500 /* Called at the start of a block of try statements.  */
1501 void
1502 expand_start_try_stmts ()
1503 {
1504   if (! doing_eh (1))
1505     return;
1506
1507   expand_eh_region_start ();
1508 }
1509
1510 /* Called to begin a catch clause. The parameter is the object which
1511    will be passed to the runtime type check routine. */
1512 void
1513 start_catch_handler (rtime)
1514      tree rtime;
1515 {
1516   rtx handler_label = catchstack.top->entry->exception_handler_label;
1517   int insn_region_num = CODE_LABEL_NUMBER (handler_label);
1518   int eh_region_entry = find_func_region (insn_region_num);
1519
1520   /* If we've already issued this label, pick a new one */
1521   if (catchstack.top->entry->label_used)
1522     handler_label = gen_exception_label ();
1523   else
1524     catchstack.top->entry->label_used = 1;
1525
1526   receive_exception_label (handler_label);
1527
1528   add_new_handler (eh_region_entry, get_new_handler (handler_label, rtime));
1529 }
1530
1531 /* Generate RTL for the start of a group of catch clauses.
1532
1533    It is responsible for starting a new instruction sequence for the
1534    instructions in the catch block, and expanding the handlers for the
1535    internally-generated exception regions nested within the try block
1536    corresponding to this catch block.  */
1537
1538 void
1539 expand_start_all_catch ()
1540 {
1541   struct eh_entry *entry;
1542   tree label;
1543   rtx outer_context;
1544
1545   if (! doing_eh (1))
1546     return;
1547
1548   outer_context = ehstack.top->entry->outer_context;
1549
1550   /* End the try block.  */
1551   expand_eh_region_end (integer_zero_node);
1552
1553   emit_line_note (input_filename, lineno);
1554   label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
1555
1556   /* The label for the exception handling block that we will save.
1557      This is Lresume in the documentation.  */
1558   expand_label (label);
1559
1560   /* Push the label that points to where normal flow is resumed onto
1561      the top of the label stack.  */
1562   push_label_entry (&caught_return_label_stack, NULL_RTX, label);
1563
1564   /* Start a new sequence for all the catch blocks.  We will add this
1565      to the global sequence catch_clauses when we have completed all
1566      the handlers in this handler-seq.  */
1567   start_sequence ();
1568
1569   entry = dequeue_eh_entry (&ehqueue);
1570   for ( ; entry->finalization != integer_zero_node;
1571                                  entry = dequeue_eh_entry (&ehqueue))
1572     {
1573       rtx prev;
1574
1575       /* Emit the label for the cleanup handler for this region, and
1576          expand the code for the handler.
1577
1578          Note that a catch region is handled as a side-effect here;
1579          for a try block, entry->finalization will contain
1580          integer_zero_node, so no code will be generated in the
1581          expand_expr call below. But, the label for the handler will
1582          still be emitted, so any code emitted after this point will
1583          end up being the handler.  */
1584
1585       receive_exception_label (entry->exception_handler_label);
1586
1587       /* register a handler for this cleanup region */
1588       add_new_handler (
1589         find_func_region (CODE_LABEL_NUMBER (entry->exception_handler_label)),
1590         get_new_handler (entry->exception_handler_label, NULL));
1591
1592       /* And now generate the insns for the cleanup handler.  */
1593       expand_expr (entry->finalization, const0_rtx, VOIDmode, 0);
1594
1595       prev = get_last_insn ();
1596       if (prev == NULL || GET_CODE (prev) != BARRIER)
1597         /* Code to throw out to outer context when we fall off end
1598            of the handler. We can't do this here for catch blocks,
1599            so it's done in expand_end_all_catch instead.  */
1600         expand_rethrow (entry->outer_context);
1601
1602       do_pending_stack_adjust ();
1603       free (entry);
1604     }
1605
1606   /* At this point, all the cleanups are done, and the ehqueue now has
1607      the current exception region at its head. We dequeue it, and put it
1608      on the catch stack. */
1609
1610     push_entry (&catchstack, entry);
1611
1612   /* If we are not doing setjmp/longjmp EH, because we are reordered
1613      out of line, we arrange to rethrow in the outer context.  We need to
1614      do this because we are not physically within the region, if any, that
1615      logically contains this catch block.  */
1616   if (! exceptions_via_longjmp)
1617     {
1618       expand_eh_region_start ();
1619       ehstack.top->entry->outer_context = outer_context;
1620     }
1621
1622   /* We also have to start the handler if we aren't using the new model. */
1623   if (! flag_new_exceptions)
1624     start_catch_handler (NULL);
1625 }
1626
1627 /* Finish up the catch block.  At this point all the insns for the
1628    catch clauses have already been generated, so we only have to add
1629    them to the catch_clauses list. We also want to make sure that if
1630    we fall off the end of the catch clauses that we rethrow to the
1631    outer EH region.  */
1632
1633 void
1634 expand_end_all_catch ()
1635 {
1636   rtx new_catch_clause, outer_context = NULL_RTX;
1637   struct eh_entry *entry;
1638
1639   if (! doing_eh (1))
1640     return;
1641
1642   /* Dequeue the current catch clause region. */
1643   entry = pop_eh_entry (&catchstack);
1644   free (entry);
1645
1646   if (! exceptions_via_longjmp)
1647     {
1648       outer_context = ehstack.top->entry->outer_context;
1649
1650       /* Finish the rethrow region.  size_zero_node is just a NOP.  */
1651       expand_eh_region_end (size_zero_node);
1652     }
1653
1654   /* Code to throw out to outer context, if we fall off end of catch
1655      handlers.  This is rethrow (Lresume, same id, same obj) in the
1656      documentation. We use Lresume because we know that it will throw
1657      to the correct context.
1658
1659      In other words, if the catch handler doesn't exit or return, we
1660      do a "throw" (using the address of Lresume as the point being
1661      thrown from) so that the outer EH region can then try to process
1662      the exception.  */
1663   expand_rethrow (outer_context);
1664
1665   /* Now we have the complete catch sequence.  */
1666   new_catch_clause = get_insns ();
1667   end_sequence ();
1668
1669   /* This level of catch blocks is done, so set up the successful
1670      catch jump label for the next layer of catch blocks.  */
1671   pop_label_entry (&caught_return_label_stack);
1672   pop_label_entry (&outer_context_label_stack);
1673
1674   /* Add the new sequence of catches to the main one for this function.  */
1675   push_to_sequence (catch_clauses);
1676   emit_insns (new_catch_clause);
1677   catch_clauses = get_insns ();
1678   end_sequence ();
1679
1680   /* Here we fall through into the continuation code.  */
1681 }
1682
1683 /* Rethrow from the outer context LABEL.  */
1684
1685 static void
1686 expand_rethrow (label)
1687      rtx label;
1688 {
1689   if (exceptions_via_longjmp)
1690     emit_throw ();
1691   else
1692     emit_jump (label);
1693 }
1694
1695 /* End all the pending exception regions on protect_list. The handlers
1696    will be emitted when expand_leftover_cleanups is invoked.  */
1697
1698 void
1699 end_protect_partials ()
1700 {
1701   while (protect_list)
1702     {
1703       expand_eh_region_end (TREE_VALUE (protect_list));
1704       protect_list = TREE_CHAIN (protect_list);
1705     }
1706 }
1707
1708 /* Arrange for __terminate to be called if there is an unhandled throw
1709    from within E.  */
1710
1711 tree
1712 protect_with_terminate (e)
1713      tree e;
1714 {
1715   /* We only need to do this when using setjmp/longjmp EH and the
1716      language requires it, as otherwise we protect all of the handlers
1717      at once, if we need to.  */
1718   if (exceptions_via_longjmp && protect_cleanup_actions_with_terminate)
1719     {
1720       tree handler, result;
1721
1722       /* All cleanups must be on the function_obstack.  */
1723       push_obstacks_nochange ();
1724       resume_temporary_allocation ();
1725
1726       handler = make_node (RTL_EXPR);
1727       TREE_TYPE (handler) = void_type_node;
1728       RTL_EXPR_RTL (handler) = const0_rtx;
1729       TREE_SIDE_EFFECTS (handler) = 1;
1730       start_sequence_for_rtl_expr (handler);
1731
1732       emit_library_call (terminate_libfunc, 0, VOIDmode, 0);
1733       emit_barrier ();
1734
1735       RTL_EXPR_SEQUENCE (handler) = get_insns ();
1736       end_sequence ();
1737
1738       result = build (TRY_CATCH_EXPR, TREE_TYPE (e), e, handler);
1739       TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
1740       TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
1741       TREE_READONLY (result) = TREE_READONLY (e);
1742
1743       pop_obstacks ();
1744
1745       e = result;
1746     }
1747
1748   return e;
1749 }
1750 \f
1751 /* The exception table that we build that is used for looking up and
1752    dispatching exceptions, the current number of entries, and its
1753    maximum size before we have to extend it.
1754
1755    The number in eh_table is the code label number of the exception
1756    handler for the region. This is added by add_eh_table_entry and
1757    used by output_exception_table_entry.  */
1758
1759 static int *eh_table = NULL;
1760 static int eh_table_size = 0;
1761 static int eh_table_max_size = 0;
1762
1763 /* Note the need for an exception table entry for region N.  If we
1764    don't need to output an explicit exception table, avoid all of the
1765    extra work.
1766
1767    Called from final_scan_insn when a NOTE_INSN_EH_REGION_BEG is seen.
1768    (Or NOTE_INSN_EH_REGION_END sometimes)
1769    N is the NOTE_BLOCK_NUMBER of the note, which comes from the code
1770    label number of the exception handler for the region.  */
1771
1772 void
1773 add_eh_table_entry (n)
1774      int n;
1775 {
1776 #ifndef OMIT_EH_TABLE
1777   if (eh_table_size >= eh_table_max_size)
1778     {
1779       if (eh_table)
1780         {
1781           eh_table_max_size += eh_table_max_size>>1;
1782
1783           if (eh_table_max_size < 0)
1784             abort ();
1785
1786           eh_table = (int *) xrealloc (eh_table,
1787                                        eh_table_max_size * sizeof (int));
1788         }
1789       else
1790         {
1791           eh_table_max_size = 252;
1792           eh_table = (int *) xmalloc (eh_table_max_size * sizeof (int));
1793         }
1794     }
1795   eh_table[eh_table_size++] = n;
1796 #endif
1797 }
1798
1799 /* Return a non-zero value if we need to output an exception table.
1800
1801    On some platforms, we don't have to output a table explicitly.
1802    This routine doesn't mean we don't have one.  */
1803
1804 int
1805 exception_table_p ()
1806 {
1807   if (eh_table)
1808     return 1;
1809
1810   return 0;
1811 }
1812
1813 /* Output the entry of the exception table corresponding to the
1814    exception region numbered N to file FILE.
1815
1816    N is the code label number corresponding to the handler of the
1817    region.  */
1818
1819 static void
1820 output_exception_table_entry (file, n)
1821      FILE *file;
1822      int n;
1823 {
1824   char buf[256];
1825   rtx sym;
1826   struct handler_info *handler;
1827
1828   handler = get_first_handler (n);
1829
1830   for ( ; handler != NULL; handler = handler->next)
1831     {
1832       ASM_GENERATE_INTERNAL_LABEL (buf, "LEHB", n);
1833       sym = gen_rtx_SYMBOL_REF (Pmode, buf);
1834       assemble_integer (sym, POINTER_SIZE / BITS_PER_UNIT, 1);
1835
1836       ASM_GENERATE_INTERNAL_LABEL (buf, "LEHE", n);
1837       sym = gen_rtx_SYMBOL_REF (Pmode, buf);
1838       assemble_integer (sym, POINTER_SIZE / BITS_PER_UNIT, 1);
1839
1840       assemble_integer (handler->handler_label,
1841                                          POINTER_SIZE / BITS_PER_UNIT, 1);
1842
1843       if (flag_new_exceptions)
1844         {
1845           if (handler->type_info == NULL)
1846             assemble_integer (const0_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
1847           else
1848             output_constant ((tree)(handler->type_info),
1849                                                 POINTER_SIZE / BITS_PER_UNIT);
1850         }
1851       putc ('\n', file);                /* blank line */
1852     }
1853 }
1854
1855 /* Output the exception table if we have and need one.  */
1856
1857 static short language_code = 0;
1858 static short version_code = 0;
1859
1860 /* This routine will set the language code for exceptions. */
1861 void set_exception_lang_code (code)
1862      short code;
1863 {
1864   language_code = code;
1865 }
1866
1867 /* This routine will set the language version code for exceptions. */
1868 void set_exception_version_code (code)
1869      short code;
1870 {
1871   version_code = code;
1872 }
1873
1874
1875 void
1876 output_exception_table ()
1877 {
1878   int i;
1879   extern FILE *asm_out_file;
1880
1881   if (! doing_eh (0) || ! eh_table)
1882     return;
1883
1884   exception_section ();
1885
1886   /* Beginning marker for table.  */
1887   assemble_align (GET_MODE_ALIGNMENT (ptr_mode));
1888   assemble_label ("__EXCEPTION_TABLE__");
1889
1890   if (flag_new_exceptions)
1891     {
1892       assemble_integer (GEN_INT (NEW_EH_RUNTIME),
1893                                         POINTER_SIZE / BITS_PER_UNIT, 1);
1894       assemble_integer (GEN_INT (language_code), 2 , 1);
1895       assemble_integer (GEN_INT (version_code), 2 , 1);
1896
1897       /* Add enough padding to make sure table aligns on a pointer boundry. */
1898       i = GET_MODE_ALIGNMENT (ptr_mode) / BITS_PER_UNIT - 4;
1899       for ( ; i < 0; i = i + GET_MODE_ALIGNMENT (ptr_mode) / BITS_PER_UNIT)
1900         ;
1901       if (i != 0)
1902         assemble_integer (const0_rtx, i , 1);
1903     }
1904
1905   for (i = 0; i < eh_table_size; ++i)
1906     output_exception_table_entry (asm_out_file, eh_table[i]);
1907
1908   free (eh_table);
1909   clear_function_eh_region ();
1910
1911   /* Ending marker for table.  */
1912   assemble_integer (constm1_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
1913
1914   /* for binary compatability, the old __throw checked the second
1915      position for a -1, so we should output at least 2 -1's */
1916   if (! flag_new_exceptions)
1917     assemble_integer (constm1_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
1918
1919   putc ('\n', asm_out_file);            /* blank line */
1920 }
1921 \f
1922 /* Emit code to get EH context.
1923
1924    We have to scan thru the code to find possible EH context registers.
1925    Inlined functions may use it too, and thus we'll have to be able
1926    to change them too.
1927
1928    This is done only if using exceptions_via_longjmp. */
1929
1930 void
1931 emit_eh_context ()
1932 {
1933   rtx insn;
1934   rtx ehc = 0;
1935
1936   if (! doing_eh (0))
1937     return;
1938
1939   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
1940     if (GET_CODE (insn) == INSN
1941         && GET_CODE (PATTERN (insn)) == USE)
1942       {
1943         rtx reg = find_reg_note (insn, REG_EH_CONTEXT, 0);
1944         if (reg)
1945           {
1946             rtx insns;
1947
1948             start_sequence ();
1949
1950             /* If this is the first use insn, emit the call here.  This
1951                will always be at the top of our function, because if
1952                expand_inline_function notices a REG_EH_CONTEXT note, it
1953                adds a use insn to this function as well.  */
1954             if (ehc == 0)
1955               ehc = call_get_eh_context ();
1956
1957             emit_move_insn (XEXP (reg, 0), ehc);
1958             insns = get_insns ();
1959             end_sequence ();
1960
1961             emit_insns_before (insns, insn);
1962           }
1963       }
1964 }
1965
1966 /* Scan the current insns and build a list of handler labels. The
1967    resulting list is placed in the global variable exception_handler_labels.
1968
1969    It is called after the last exception handling region is added to
1970    the current function (when the rtl is almost all built for the
1971    current function) and before the jump optimization pass.  */
1972
1973 void
1974 find_exception_handler_labels ()
1975 {
1976   rtx insn;
1977
1978   exception_handler_labels = NULL_RTX;
1979
1980   /* If we aren't doing exception handling, there isn't much to check.  */
1981   if (! doing_eh (0))
1982     return;
1983
1984   /* For each start of a region, add its label to the list.  */
1985
1986   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
1987     {
1988       struct handler_info* ptr;
1989       if (GET_CODE (insn) == NOTE
1990           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
1991         {
1992           ptr = get_first_handler (NOTE_BLOCK_NUMBER (insn));
1993           for ( ; ptr; ptr = ptr->next)
1994             {
1995               /* make sure label isn't in the list already */
1996               rtx x;
1997               for (x = exception_handler_labels; x; x = XEXP (x, 1))
1998                 if (XEXP (x, 0) == ptr->handler_label)
1999                   break;
2000               if (! x)
2001                 exception_handler_labels = gen_rtx_EXPR_LIST (VOIDmode,
2002                                ptr->handler_label, exception_handler_labels);
2003             }
2004         }
2005     }
2006 }
2007
2008 /* Return a value of 1 if the parameter label number is an exception handler
2009    label. Return 0 otherwise. */
2010
2011 int
2012 is_exception_handler_label (lab)
2013      int lab;
2014 {
2015   rtx x;
2016   for (x = exception_handler_labels ; x ; x = XEXP (x, 1))
2017     if (lab == CODE_LABEL_NUMBER (XEXP (x, 0)))
2018       return 1;
2019   return 0;
2020 }
2021
2022 /* Perform sanity checking on the exception_handler_labels list.
2023
2024    Can be called after find_exception_handler_labels is called to
2025    build the list of exception handlers for the current function and
2026    before we finish processing the current function.  */
2027
2028 void
2029 check_exception_handler_labels ()
2030 {
2031   rtx insn, insn2;
2032
2033   /* If we aren't doing exception handling, there isn't much to check.  */
2034   if (! doing_eh (0))
2035     return;
2036
2037   /* Make sure there is no more than 1 copy of a label */
2038   for (insn = exception_handler_labels; insn; insn = XEXP (insn, 1))
2039     {
2040       int count = 0;
2041       for (insn2 = exception_handler_labels; insn2; insn2 = XEXP (insn2, 1))
2042         if (XEXP (insn, 0) == XEXP (insn2, 0))
2043           count++;
2044       if (count != 1)
2045        warning ("Counted %d copies of EH region %d in list.\n", count,
2046                                         CODE_LABEL_NUMBER (insn));
2047     }
2048
2049 }
2050 \f
2051 /* This group of functions initializes the exception handling data
2052    structures at the start of the compilation, initializes the data
2053    structures at the start of a function, and saves and restores the
2054    exception handling data structures for the start/end of a nested
2055    function.  */
2056
2057 /* Toplevel initialization for EH things.  */
2058
2059 void
2060 init_eh ()
2061 {
2062 }
2063
2064 /* Initialize the per-function EH information.  */
2065
2066 void
2067 init_eh_for_function ()
2068 {
2069   ehstack.top = 0;
2070   catchstack.top = 0;
2071   ehqueue.head = ehqueue.tail = 0;
2072   catch_clauses = NULL_RTX;
2073   false_label_stack = 0;
2074   caught_return_label_stack = 0;
2075   protect_list = NULL_TREE;
2076   current_function_ehc = NULL_RTX;
2077 }
2078
2079 /* Save some of the per-function EH info into the save area denoted by
2080    P.
2081
2082    This is currently called from save_stmt_status.  */
2083
2084 void
2085 save_eh_status (p)
2086      struct function *p;
2087 {
2088   if (p == NULL)
2089     abort ();
2090
2091   p->ehstack = ehstack;
2092   p->catchstack = catchstack;
2093   p->ehqueue = ehqueue;
2094   p->catch_clauses = catch_clauses;
2095   p->false_label_stack = false_label_stack;
2096   p->caught_return_label_stack = caught_return_label_stack;
2097   p->protect_list = protect_list;
2098   p->ehc = current_function_ehc;
2099
2100   init_eh_for_function ();
2101 }
2102
2103 /* Restore the per-function EH info saved into the area denoted by P.
2104
2105    This is currently called from restore_stmt_status.  */
2106
2107 void
2108 restore_eh_status (p)
2109      struct function *p;
2110 {
2111   if (p == NULL)
2112     abort ();
2113
2114   protect_list = p->protect_list;
2115   caught_return_label_stack = p->caught_return_label_stack;
2116   false_label_stack = p->false_label_stack;
2117   catch_clauses = p->catch_clauses;
2118   ehqueue = p->ehqueue;
2119   ehstack = p->ehstack;
2120   catchstack = p->catchstack;
2121   current_function_ehc = p->ehc;
2122 }
2123 \f
2124 /* This section is for the exception handling specific optimization
2125    pass.  First are the internal routines, and then the main
2126    optimization pass.  */
2127
2128 /* Determine if the given INSN can throw an exception.  */
2129
2130 static int
2131 can_throw (insn)
2132      rtx insn;
2133 {
2134   /* Calls can always potentially throw exceptions.  */
2135   if (GET_CODE (insn) == CALL_INSN)
2136     return 1;
2137
2138   if (asynchronous_exceptions)
2139     {
2140       /* If we wanted asynchronous exceptions, then everything but NOTEs
2141          and CODE_LABELs could throw.  */
2142       if (GET_CODE (insn) != NOTE && GET_CODE (insn) != CODE_LABEL)
2143         return 1;
2144     }
2145
2146   return 0;
2147 }
2148
2149 /* Scan a exception region looking for the matching end and then
2150    remove it if possible. INSN is the start of the region, N is the
2151    region number, and DELETE_OUTER is to note if anything in this
2152    region can throw.
2153
2154    Regions are removed if they cannot possibly catch an exception.
2155    This is determined by invoking can_throw on each insn within the
2156    region; if can_throw returns true for any of the instructions, the
2157    region can catch an exception, since there is an insn within the
2158    region that is capable of throwing an exception.
2159
2160    Returns the NOTE_INSN_EH_REGION_END corresponding to this region, or
2161    calls abort if it can't find one.
2162
2163    Can abort if INSN is not a NOTE_INSN_EH_REGION_BEGIN, or if N doesn't
2164    correspond to the region number, or if DELETE_OUTER is NULL.  */
2165
2166 static rtx
2167 scan_region (insn, n, delete_outer)
2168      rtx insn;
2169      int n;
2170      int *delete_outer;
2171 {
2172   rtx start = insn;
2173
2174   /* Assume we can delete the region.  */
2175   int delete = 1;
2176
2177   if (insn == NULL_RTX
2178       || GET_CODE (insn) != NOTE
2179       || NOTE_LINE_NUMBER (insn) != NOTE_INSN_EH_REGION_BEG
2180       || NOTE_BLOCK_NUMBER (insn) != n
2181       || delete_outer == NULL)
2182     abort ();
2183
2184   insn = NEXT_INSN (insn);
2185
2186   /* Look for the matching end.  */
2187   while (! (GET_CODE (insn) == NOTE
2188             && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END))
2189     {
2190       /* If anything can throw, we can't remove the region.  */
2191       if (delete && can_throw (insn))
2192         {
2193           delete = 0;
2194         }
2195
2196       /* Watch out for and handle nested regions.  */
2197       if (GET_CODE (insn) == NOTE
2198           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
2199         {
2200           insn = scan_region (insn, NOTE_BLOCK_NUMBER (insn), &delete);
2201         }
2202
2203       insn = NEXT_INSN (insn);
2204     }
2205
2206   /* The _BEG/_END NOTEs must match and nest.  */
2207   if (NOTE_BLOCK_NUMBER (insn) != n)
2208     abort ();
2209
2210   /* If anything in this exception region can throw, we can throw.  */
2211   if (! delete)
2212     *delete_outer = 0;
2213   else
2214     {
2215       /* Delete the start and end of the region.  */
2216       delete_insn (start);
2217       delete_insn (insn);
2218
2219 /* We no longer removed labels here, since flow will now remove any
2220    handler which cannot be called any more. */
2221
2222 #if 0
2223       /* Only do this part if we have built the exception handler
2224          labels.  */
2225       if (exception_handler_labels)
2226         {
2227           rtx x, *prev = &exception_handler_labels;
2228
2229           /* Find it in the list of handlers.  */
2230           for (x = exception_handler_labels; x; x = XEXP (x, 1))
2231             {
2232               rtx label = XEXP (x, 0);
2233               if (CODE_LABEL_NUMBER (label) == n)
2234                 {
2235                   /* If we are the last reference to the handler,
2236                      delete it.  */
2237                   if (--LABEL_NUSES (label) == 0)
2238                     delete_insn (label);
2239
2240                   if (optimize)
2241                     {
2242                       /* Remove it from the list of exception handler
2243                          labels, if we are optimizing.  If we are not, then
2244                          leave it in the list, as we are not really going to
2245                          remove the region.  */
2246                       *prev = XEXP (x, 1);
2247                       XEXP (x, 1) = 0;
2248                       XEXP (x, 0) = 0;
2249                     }
2250
2251                   break;
2252                 }
2253               prev = &XEXP (x, 1);
2254             }
2255         }
2256 #endif
2257     }
2258   return insn;
2259 }
2260
2261 /* Perform various interesting optimizations for exception handling
2262    code.
2263
2264    We look for empty exception regions and make them go (away). The
2265    jump optimization code will remove the handler if nothing else uses
2266    it.  */
2267
2268 void
2269 exception_optimize ()
2270 {
2271   rtx insn;
2272   int n;
2273
2274   /* Remove empty regions.  */
2275   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2276     {
2277       if (GET_CODE (insn) == NOTE
2278           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
2279         {
2280           /* Since scan_region will return the NOTE_INSN_EH_REGION_END
2281              insn, we will indirectly skip through all the insns
2282              inbetween. We are also guaranteed that the value of insn
2283              returned will be valid, as otherwise scan_region won't
2284              return.  */
2285           insn = scan_region (insn, NOTE_BLOCK_NUMBER (insn), &n);
2286         }
2287     }
2288 }
2289 \f
2290 /* Various hooks for the DWARF 2 __throw routine.  */
2291
2292 /* Do any necessary initialization to access arbitrary stack frames.
2293    On the SPARC, this means flushing the register windows.  */
2294
2295 void
2296 expand_builtin_unwind_init ()
2297 {
2298   /* Set this so all the registers get saved in our frame; we need to be
2299      able to copy the saved values for any registers from frames we unwind. */
2300   current_function_has_nonlocal_label = 1;
2301
2302 #ifdef SETUP_FRAME_ADDRESSES
2303   SETUP_FRAME_ADDRESSES ();
2304 #endif
2305 }
2306
2307 /* Given a value extracted from the return address register or stack slot,
2308    return the actual address encoded in that value.  */
2309
2310 rtx
2311 expand_builtin_extract_return_addr (addr_tree)
2312      tree addr_tree;
2313 {
2314   rtx addr = expand_expr (addr_tree, NULL_RTX, Pmode, 0);
2315   return eh_outer_context (addr);
2316 }
2317
2318 /* Given an actual address in addr_tree, do any necessary encoding
2319    and return the value to be stored in the return address register or
2320    stack slot so the epilogue will return to that address.  */
2321
2322 rtx
2323 expand_builtin_frob_return_addr (addr_tree)
2324      tree addr_tree;
2325 {
2326   rtx addr = expand_expr (addr_tree, NULL_RTX, Pmode, 0);
2327 #ifdef RETURN_ADDR_OFFSET
2328   addr = plus_constant (addr, -RETURN_ADDR_OFFSET);
2329 #endif
2330   return addr;
2331 }
2332
2333 /* Given an actual address in addr_tree, set the return address register up
2334    so the epilogue will return to that address.  If the return address is
2335    not in a register, do nothing.  */
2336
2337 void
2338 expand_builtin_set_return_addr_reg (addr_tree)
2339      tree addr_tree;
2340 {
2341   rtx tmp;
2342   rtx ra = expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
2343                                        0, hard_frame_pointer_rtx);
2344
2345   if (GET_CODE (ra) != REG || REGNO (ra) >= FIRST_PSEUDO_REGISTER)
2346     return;
2347
2348   tmp = force_operand (expand_builtin_frob_return_addr (addr_tree), ra);
2349   if (tmp != ra)
2350     emit_move_insn (ra, tmp);
2351 }
2352
2353 /* Choose two registers for communication between the main body of
2354    __throw and the stub for adjusting the stack pointer.  The first register
2355    is used to pass the address of the exception handler; the second register
2356    is used to pass the stack pointer offset.
2357
2358    For register 1 we use the return value register for a void *.
2359    For register 2 we use the static chain register if it exists and is
2360      different from register 1, otherwise some arbitrary call-clobbered
2361      register.  */
2362
2363 static void
2364 eh_regs (r1, r2, outgoing)
2365      rtx *r1, *r2;
2366      int outgoing;
2367 {
2368   rtx reg1, reg2;
2369
2370 #ifdef FUNCTION_OUTGOING_VALUE
2371   if (outgoing)
2372     reg1 = FUNCTION_OUTGOING_VALUE (build_pointer_type (void_type_node),
2373                                     current_function_decl);
2374   else
2375 #endif
2376     reg1 = FUNCTION_VALUE (build_pointer_type (void_type_node),
2377                            current_function_decl);
2378
2379 #ifdef STATIC_CHAIN_REGNUM
2380   if (outgoing)
2381     reg2 = static_chain_incoming_rtx;
2382   else
2383     reg2 = static_chain_rtx;
2384   if (REGNO (reg2) == REGNO (reg1))
2385 #endif /* STATIC_CHAIN_REGNUM */
2386     reg2 = NULL_RTX;
2387
2388   if (reg2 == NULL_RTX)
2389     {
2390       int i;
2391       for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
2392         if (call_used_regs[i] && ! fixed_regs[i] && i != REGNO (reg1))
2393           {
2394             reg2 = gen_rtx_REG (Pmode, i);
2395             break;
2396           }
2397
2398       if (reg2 == NULL_RTX)
2399         abort ();
2400     }
2401
2402   *r1 = reg1;
2403   *r2 = reg2;
2404 }
2405
2406
2407 /* Retrieve the register which contains the pointer to the eh_context
2408    structure set the __throw. */
2409
2410 rtx
2411 get_reg_for_handler ()
2412 {
2413   rtx reg1;
2414   reg1 = FUNCTION_VALUE (build_pointer_type (void_type_node),
2415                            current_function_decl);
2416   return reg1;
2417 }
2418
2419
2420 /* Emit inside of __throw a stub which adjusts the stack pointer and jumps
2421    to the exception handler.  __throw will set up the necessary values
2422    and then return to the stub.  */
2423
2424 rtx
2425 expand_builtin_eh_stub_old ()
2426 {
2427   rtx stub_start = gen_label_rtx ();
2428   rtx after_stub = gen_label_rtx ();
2429   rtx handler, offset;
2430
2431   emit_jump (after_stub);
2432   emit_label (stub_start);
2433
2434   eh_regs (&handler, &offset, 0);
2435
2436   adjust_stack (offset);
2437   emit_indirect_jump (handler);
2438   emit_label (after_stub);
2439   return gen_rtx_LABEL_REF (Pmode, stub_start);
2440 }
2441
2442 rtx
2443 expand_builtin_eh_stub ()
2444 {
2445   rtx stub_start = gen_label_rtx ();
2446   rtx after_stub = gen_label_rtx ();
2447   rtx handler, offset;
2448   rtx temp;
2449
2450   emit_jump (after_stub);
2451   emit_label (stub_start);
2452
2453   eh_regs (&handler, &offset, 0);
2454
2455   adjust_stack (offset);
2456
2457   /* Handler is in fact a pointer to the _eh_context structure, we need
2458      to pick out the handler field (first element), and jump to there,
2459      leaving the pointer to _eh_conext in the same hardware register. */
2460
2461   temp = gen_rtx_MEM (Pmode, handler);
2462   MEM_IN_STRUCT_P (temp) = 1;
2463   RTX_UNCHANGING_P (temp) = 1;
2464   emit_move_insn (offset, temp);
2465   emit_insn (gen_rtx_USE (Pmode, handler));
2466
2467   emit_indirect_jump (offset);
2468
2469   emit_label (after_stub);
2470   return gen_rtx_LABEL_REF (Pmode, stub_start);
2471 }
2472
2473 /* Set up the registers for passing the handler address and stack offset
2474    to the stub above.  */
2475
2476 void
2477 expand_builtin_set_eh_regs (handler, offset)
2478      tree handler, offset;
2479 {
2480   rtx reg1, reg2;
2481
2482   eh_regs (&reg1, &reg2, 1);
2483
2484   store_expr (offset,  reg2, 0);
2485   store_expr (handler, reg1, 0);
2486
2487   /* These will be used by the stub.  */
2488   emit_insn (gen_rtx_USE (VOIDmode, reg1));
2489   emit_insn (gen_rtx_USE (VOIDmode, reg2));
2490 }
2491
2492 \f
2493
2494 /* This contains the code required to verify whether arbitrary instructions
2495    are in the same exception region. */
2496
2497 static int *insn_eh_region = (int *)0;
2498 static int maximum_uid;
2499
2500 static void
2501 set_insn_eh_region (first, region_num)
2502      rtx *first;
2503      int region_num;
2504 {
2505   rtx insn;
2506   int rnum;
2507
2508   for (insn = *first; insn; insn = NEXT_INSN (insn))
2509     {
2510       if ((GET_CODE (insn) == NOTE) &&
2511                         (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG))
2512         {
2513           rnum = NOTE_BLOCK_NUMBER (insn);
2514           insn_eh_region[INSN_UID (insn)] =  rnum;
2515           insn = NEXT_INSN (insn);
2516           set_insn_eh_region (&insn, rnum);
2517           /* Upon return, insn points to the EH_REGION_END of nested region */
2518           continue;
2519         }
2520       insn_eh_region[INSN_UID (insn)] = region_num;
2521       if ((GET_CODE (insn) == NOTE) &&
2522             (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END))
2523         break;
2524     }
2525   *first = insn;
2526 }
2527
2528 /* Free the insn table, an make sure it cannot be used again. */
2529
2530 void
2531 free_insn_eh_region ()
2532 {
2533   if (!doing_eh (0))
2534     return;
2535
2536   if (insn_eh_region)
2537     {
2538       free (insn_eh_region);
2539       insn_eh_region = (int *)0;
2540     }
2541 }
2542
2543 /* Initialize the table. max_uid must be calculated and handed into
2544    this routine. If it is unavailable, passing a value of 0 will
2545    cause this routine to calculate it as well. */
2546
2547 void
2548 init_insn_eh_region (first, max_uid)
2549      rtx first;
2550      int max_uid;
2551 {
2552   rtx insn;
2553
2554   if (!doing_eh (0))
2555     return;
2556
2557   if (insn_eh_region)
2558     free_insn_eh_region();
2559
2560   if (max_uid == 0)
2561     for (insn = first; insn; insn = NEXT_INSN (insn))
2562       if (INSN_UID (insn) > max_uid)       /* find largest UID */
2563         max_uid = INSN_UID (insn);
2564
2565   maximum_uid = max_uid;
2566   insn_eh_region = (int *) malloc ((max_uid + 1) * sizeof (int));
2567   insn = first;
2568   set_insn_eh_region (&insn, 0);
2569 }
2570
2571
2572 /* Check whether 2 instructions are within the same region. */
2573
2574 int
2575 in_same_eh_region (insn1, insn2)
2576      rtx insn1, insn2;
2577 {
2578   int ret, uid1, uid2;
2579
2580   /* If no exceptions, instructions are always in same region. */
2581   if (!doing_eh (0))
2582     return 1;
2583
2584   /* If the table isn't allocated, assume the worst. */
2585   if (!insn_eh_region)
2586     return 0;
2587
2588   uid1 = INSN_UID (insn1);
2589   uid2 = INSN_UID (insn2);
2590
2591   /* if instructions have been allocated beyond the end, either
2592      the table is out of date, or this is a late addition, or
2593      something... Assume the worst. */
2594   if (uid1 > maximum_uid || uid2 > maximum_uid)
2595     return 0;
2596
2597   ret = (insn_eh_region[uid1] == insn_eh_region[uid2]);
2598   return ret;
2599 }
2600