gcc/except.c

   1 /* Implements exception handling.
   2    Copyright (C) 1989, 1992-1999, 2000 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 #include "intl.h"
 410 #include "obstack.h"
 411 #include "ggc.h"
 412 #include "tm_p.h"
 413
 414 /* One to use setjmp/longjmp method of generating code for exception
 415    handling.  */
 416
 417 int exceptions_via_longjmp = 2;
 418
 419 /* One to enable asynchronous exception support.  */
 420
 421 int asynchronous_exceptions = 0;
 422
 423 /* One to protect cleanup actions with a handler that calls
 424    __terminate, zero otherwise.  */
 425
 426 int protect_cleanup_actions_with_terminate;
 427
 428 /* A list of labels used for exception handlers.  Created by
 429    find_exception_handler_labels for the optimization passes.  */
 430
 431 rtx exception_handler_labels;
 432
 433 /* Keeps track of the label used as the context of a throw to rethrow an
 434    exception to the outer exception region.  */
 435
 436 struct label_node *outer_context_label_stack = NULL;
 437
 438 /* Pseudos used to hold exception return data in the interim between
 439    __builtin_eh_return and the end of the function.  */
 440
 441 static rtx eh_return_context;
 442 static rtx eh_return_stack_adjust;
 443 static rtx eh_return_handler;
 444
 445 /* This is used for targets which can call rethrow with an offset instead
 446    of an address. This is subtracted from the rethrow label we are
 447    interested in. */
 448
 449 static rtx first_rethrow_symbol = NULL_RTX;
 450 static rtx final_rethrow = NULL_RTX;
 451 static rtx last_rethrow_symbol = NULL_RTX;
 452
 453
 454 /* Prototypes for local functions.  */
 455
 456 static void push_eh_entry       PARAMS ((struct eh_stack *));
 457 static struct eh_entry * pop_eh_entry   PARAMS ((struct eh_stack *));
 458 static void enqueue_eh_entry    PARAMS ((struct eh_queue *, struct eh_entry *));
 459 static struct eh_entry * dequeue_eh_entry       PARAMS ((struct eh_queue *));
 460 static rtx call_get_eh_context  PARAMS ((void));
 461 static void start_dynamic_cleanup       PARAMS ((tree, tree));
 462 static void start_dynamic_handler       PARAMS ((void));
 463 static void expand_rethrow      PARAMS ((rtx));
 464 static void output_exception_table_entry        PARAMS ((FILE *, int));
 465 static int can_throw            PARAMS ((rtx));
 466 static rtx scan_region          PARAMS ((rtx, int, int *));
 467 static void eh_regs             PARAMS ((rtx *, rtx *, rtx *, int));
 468 static void set_insn_eh_region  PARAMS ((rtx *, int));
 469 #ifdef DONT_USE_BUILTIN_SETJMP
 470 static void jumpif_rtx          PARAMS ((rtx, rtx));
 471 #endif
 472 static void mark_eh_node        PARAMS ((struct eh_node *));
 473 static void mark_eh_stack       PARAMS ((struct eh_stack *));
 474 static void mark_eh_queue       PARAMS ((struct eh_queue *));
 475 static void mark_tree_label_node PARAMS ((struct label_node *));
 476 static void mark_func_eh_entry  PARAMS ((void *));
 477 static rtx create_rethrow_ref   PARAMS ((int));
 478 static void push_entry          PARAMS ((struct eh_stack *, struct eh_entry*));
 479 static void receive_exception_label PARAMS ((rtx));
 480 static int new_eh_region_entry  PARAMS ((int, rtx));
 481 static int find_func_region     PARAMS ((int));
 482 static int find_func_region_from_symbol PARAMS ((rtx));
 483 static void clear_function_eh_region PARAMS ((void));
 484 static void process_nestinfo    PARAMS ((int, eh_nesting_info *, int *));
 485
 486 rtx expand_builtin_return_addr  PARAMS ((enum built_in_function, int, rtx));
 487 static void emit_cleanup_handler PARAMS ((struct eh_entry *));
 488 static int eh_region_from_symbol PARAMS ((rtx));
 489
 490 \f
 491 /* Various support routines to manipulate the various data structures
 492    used by the exception handling code.  */
 493
 494 extern struct obstack permanent_obstack;
 495
 496 /* Generate a SYMBOL_REF for rethrow to use */
 497 static rtx
 498 create_rethrow_ref (region_num)
 499      int region_num;
 500 {
 501   rtx def;
 502   char *ptr;
 503   char buf[60];
 504
 505   push_obstacks_nochange ();
 506   end_temporary_allocation ();
 507
 508   ASM_GENERATE_INTERNAL_LABEL (buf, "LRTH", region_num);
 509   ptr = ggc_alloc_string (buf, -1);
 510   def = gen_rtx_SYMBOL_REF (Pmode, ptr);
 511   SYMBOL_REF_NEED_ADJUST (def) = 1;
 512
 513   pop_obstacks ();
 514   return def;
 515 }
 516
 517 /* Push a label entry onto the given STACK.  */
 518
 519 void
 520 push_label_entry (stack, rlabel, tlabel)
 521      struct label_node **stack;
 522      rtx rlabel;
 523      tree tlabel;
 524 {
 525   struct label_node *newnode
 526     = (struct label_node *) xmalloc (sizeof (struct label_node));
 527
 528   if (rlabel)
 529     newnode->u.rlabel = rlabel;
 530   else
 531     newnode->u.tlabel = tlabel;
 532   newnode->chain = *stack;
 533   *stack = newnode;
 534 }
 535
 536 /* Pop a label entry from the given STACK.  */
 537
 538 rtx
 539 pop_label_entry (stack)
 540      struct label_node **stack;
 541 {
 542   rtx label;
 543   struct label_node *tempnode;
 544
 545   if (! *stack)
 546     return NULL_RTX;
 547
 548   tempnode = *stack;
 549   label = tempnode->u.rlabel;
 550   *stack = (*stack)->chain;
 551   free (tempnode);
 552
 553   return label;
 554 }
 555
 556 /* Return the top element of the given STACK.  */
 557
 558 tree
 559 top_label_entry (stack)
 560      struct label_node **stack;
 561 {
 562   if (! *stack)
 563     return NULL_TREE;
 564
 565   return (*stack)->u.tlabel;
 566 }
 567
 568 /* get an exception label. These must be on the permanent obstack */
 569
 570 rtx
 571 gen_exception_label ()
 572 {
 573   rtx lab;
 574   lab = gen_label_rtx ();
 575   return lab;
 576 }
 577
 578 /* Push a new eh_node entry onto STACK.  */
 579
 580 static void
 581 push_eh_entry (stack)
 582      struct eh_stack *stack;
 583 {
 584   struct eh_node *node = (struct eh_node *) xmalloc (sizeof (struct eh_node));
 585   struct eh_entry *entry = (struct eh_entry *) xmalloc (sizeof (struct eh_entry));
 586
 587   rtx rlab = gen_exception_label ();
 588   entry->finalization = NULL_TREE;
 589   entry->label_used = 0;
 590   entry->exception_handler_label = rlab;
 591   entry->false_label = NULL_RTX;
 592   if (! flag_new_exceptions)
 593     entry->outer_context = gen_label_rtx ();
 594   else
 595     entry->outer_context = create_rethrow_ref (CODE_LABEL_NUMBER (rlab));
 596   entry->rethrow_label = entry->outer_context;
 597   entry->goto_entry_p = 0;
 598
 599   node->entry = entry;
 600   node->chain = stack->top;
 601   stack->top = node;
 602 }
 603
 604 /* push an existing entry onto a stack. */
 605 static void
 606 push_entry (stack, entry)
 607      struct eh_stack *stack;
 608      struct eh_entry *entry;
 609 {
 610   struct eh_node *node = (struct eh_node *) xmalloc (sizeof (struct eh_node));
 611   node->entry = entry;
 612   node->chain = stack->top;
 613   stack->top = node;
 614 }
 615
 616 /* Pop an entry from the given STACK.  */
 617
 618 static struct eh_entry *
 619 pop_eh_entry (stack)
 620      struct eh_stack *stack;
 621 {
 622   struct eh_node *tempnode;
 623   struct eh_entry *tempentry;
 624
 625   tempnode = stack->top;
 626   tempentry = tempnode->entry;
 627   stack->top = stack->top->chain;
 628   free (tempnode);
 629
 630   return tempentry;
 631 }
 632
 633 /* Enqueue an ENTRY onto the given QUEUE.  */
 634
 635 static void
 636 enqueue_eh_entry (queue, entry)
 637      struct eh_queue *queue;
 638      struct eh_entry *entry;
 639 {
 640   struct eh_node *node = (struct eh_node *) xmalloc (sizeof (struct eh_node));
 641
 642   node->entry = entry;
 643   node->chain = NULL;
 644
 645   if (queue->head == NULL)
 646     queue->head = node;
 647   else
 648     queue->tail->chain = node;
 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   rtx rethrow_label;  /* Label for rethrow.  */
 697   int rethrow_ref;    /* Is rethrow referenced?  */
 698   struct handler_info *handlers;
 699 };
 700
 701
 702 /* table of function eh regions */
 703 static struct func_eh_entry *function_eh_regions = NULL;
 704 static int num_func_eh_entries = 0;
 705 static int current_func_eh_entry = 0;
 706
 707 #define SIZE_FUNC_EH(X)   (sizeof (struct func_eh_entry) * X)
 708
 709 /* Add a new eh_entry for this function.  The number returned is an
 710    number which uniquely identifies this exception range. */
 711
 712 static int
 713 new_eh_region_entry (note_eh_region, rethrow)
 714      int note_eh_region;
 715      rtx rethrow;
 716 {
 717   if (current_func_eh_entry == num_func_eh_entries)
 718     {
 719       if (num_func_eh_entries == 0)
 720         {
 721           function_eh_regions =
 722                         (struct func_eh_entry *) xmalloc (SIZE_FUNC_EH (50));
 723           num_func_eh_entries = 50;
 724         }
 725       else
 726         {
 727           num_func_eh_entries  = num_func_eh_entries * 3 / 2;
 728           function_eh_regions = (struct func_eh_entry *)
 729             xrealloc (function_eh_regions, SIZE_FUNC_EH (num_func_eh_entries));
 730         }
 731     }
 732   function_eh_regions[current_func_eh_entry].range_number = note_eh_region;
 733   if (rethrow == NULL_RTX)
 734     function_eh_regions[current_func_eh_entry].rethrow_label =
 735                                           create_rethrow_ref (note_eh_region);
 736   else
 737     function_eh_regions[current_func_eh_entry].rethrow_label = rethrow;
 738   function_eh_regions[current_func_eh_entry].handlers = NULL;
 739
 740   return current_func_eh_entry++;
 741 }
 742
 743 /* Add new handler information to an exception range. The  first parameter
 744    specifies the range number (returned from new_eh_entry()). The second
 745    parameter specifies the handler.  By default the handler is inserted at
 746    the end of the list. A handler list may contain only ONE NULL_TREE
 747    typeinfo entry. Regardless where it is positioned, a NULL_TREE entry
 748    is always output as the LAST handler in the exception table for a region. */
 749
 750 void
 751 add_new_handler (region, newhandler)
 752      int region;
 753      struct handler_info *newhandler;
 754 {
 755   struct handler_info *last;
 756
 757   /* If find_func_region returns -1, callers might attempt to pass us
 758      this region number.  If that happens, something has gone wrong;
 759      -1 is never a valid region.  */
 760   if (region == -1)
 761     abort ();
 762
 763   newhandler->next = NULL;
 764   last = function_eh_regions[region].handlers;
 765   if (last == NULL)
 766     function_eh_regions[region].handlers = newhandler;
 767   else
 768     {
 769       for ( ; ; last = last->next)
 770         {
 771           if (last->type_info == CATCH_ALL_TYPE)
 772             pedwarn ("additional handler after ...");
 773           if (last->next == NULL)
 774             break;
 775         }
 776       last->next = newhandler;
 777     }
 778 }
 779
 780 /* Remove a handler label. The handler label is being deleted, so all
 781    regions which reference this handler should have it removed from their
 782    list of possible handlers. Any region which has the final handler
 783    removed can be deleted. */
 784
 785 void remove_handler (removing_label)
 786      rtx removing_label;
 787 {
 788   struct handler_info *handler, *last;
 789   int x;
 790   for (x = 0 ; x < current_func_eh_entry; ++x)
 791     {
 792       last = NULL;
 793       handler = function_eh_regions[x].handlers;
 794       for ( ; handler; last = handler, handler = handler->next)
 795         if (handler->handler_label == removing_label)
 796           {
 797             if (last)
 798               {
 799                 last->next = handler->next;
 800                 handler = last;
 801               }
 802             else
 803               function_eh_regions[x].handlers = handler->next;
 804           }
 805     }
 806 }
 807
 808 /* This function will return a malloc'd pointer to an array of
 809    void pointer representing the runtime match values that
 810    currently exist in all regions. */
 811
 812 int
 813 find_all_handler_type_matches (array)
 814   void ***array;
 815 {
 816   struct handler_info *handler, *last;
 817   int x,y;
 818   void *val;
 819   void **ptr;
 820   int max_ptr;
 821   int n_ptr = 0;
 822
 823   *array = NULL;
 824
 825   if (!doing_eh (0) || ! flag_new_exceptions)
 826     return 0;
 827
 828   max_ptr = 100;
 829   ptr = (void **) xmalloc (max_ptr * sizeof (void *));
 830
 831   for (x = 0 ; x < current_func_eh_entry; x++)
 832     {
 833       last = NULL;
 834       handler = function_eh_regions[x].handlers;
 835       for ( ; handler; last = handler, handler = handler->next)
 836         {
 837           val = handler->type_info;
 838           if (val != NULL && val != CATCH_ALL_TYPE)
 839             {
 840               /* See if this match value has already been found. */
 841               for (y = 0; y < n_ptr; y++)
 842                 if (ptr[y] == val)
 843                   break;
 844
 845               /* If we break early, we already found this value. */
 846               if (y < n_ptr)
 847                 continue;
 848
 849               /* Do we need to allocate more space? */
 850               if (n_ptr >= max_ptr)
 851                 {
 852                   max_ptr += max_ptr / 2;
 853                   ptr = (void **) xrealloc (ptr, max_ptr * sizeof (void *));
 854                 }
 855               ptr[n_ptr] = val;
 856               n_ptr++;
 857             }
 858         }
 859     }
 860
 861   if (n_ptr == 0)
 862     {
 863       free (ptr);
 864       ptr = NULL;
 865     }
 866   *array = ptr;
 867   return n_ptr;
 868 }
 869
 870 /* Create a new handler structure initialized with the handler label and
 871    typeinfo fields passed in. */
 872
 873 struct handler_info *
 874 get_new_handler (handler, typeinfo)
 875      rtx handler;
 876      void *typeinfo;
 877 {
 878   struct handler_info* ptr;
 879   ptr = (struct handler_info *) xmalloc (sizeof (struct handler_info));
 880   ptr->handler_label = handler;
 881   ptr->handler_number = CODE_LABEL_NUMBER (handler);
 882   ptr->type_info = typeinfo;
 883   ptr->next = NULL;
 884
 885   return ptr;
 886 }
 887
 888
 889
 890 /* Find the index in function_eh_regions associated with a NOTE region. If
 891    the region cannot be found, a -1 is returned.  */
 892
 893 static int
 894 find_func_region (insn_region)
 895      int insn_region;
 896 {
 897   int x;
 898   for (x = 0; x < current_func_eh_entry; x++)
 899     if (function_eh_regions[x].range_number == insn_region)
 900       return x;
 901
 902   return -1;
 903 }
 904
 905 /* Get a pointer to the first handler in an exception region's list. */
 906
 907 struct handler_info *
 908 get_first_handler (region)
 909      int region;
 910 {
 911   int r = find_func_region (region);
 912   if (r == -1)
 913     abort ();
 914   return function_eh_regions[r].handlers;
 915 }
 916
 917 /* Clean out the function_eh_region table and free all memory */
 918
 919 static void
 920 clear_function_eh_region ()
 921 {
 922   int x;
 923   struct handler_info *ptr, *next;
 924   for (x = 0; x < current_func_eh_entry; x++)
 925     for (ptr = function_eh_regions[x].handlers; ptr != NULL; ptr = next)
 926       {
 927         next = ptr->next;
 928         free (ptr);
 929       }
 930   free (function_eh_regions);
 931   num_func_eh_entries  = 0;
 932   current_func_eh_entry = 0;
 933 }
 934
 935 /* Make a duplicate of an exception region by copying all the handlers
 936    for an exception region. Return the new handler index. The final
 937    parameter is a routine which maps old labels to new ones. */
 938
 939 int
 940 duplicate_eh_handlers (old_note_eh_region, new_note_eh_region, map)
 941      int old_note_eh_region, new_note_eh_region;
 942      rtx (*map) PARAMS ((rtx));
 943 {
 944   struct handler_info *ptr, *new_ptr;
 945   int new_region, region;
 946
 947   region = find_func_region (old_note_eh_region);
 948   if (region == -1)
 949     fatal ("Cannot duplicate non-existant exception region.");
 950
 951   /* duplicate_eh_handlers may have been called during a symbol remap. */
 952   new_region = find_func_region (new_note_eh_region);
 953   if (new_region != -1)
 954     return (new_region);
 955
 956   new_region = new_eh_region_entry (new_note_eh_region, NULL_RTX);
 957
 958   ptr = function_eh_regions[region].handlers;
 959
 960   for ( ; ptr; ptr = ptr->next)
 961     {
 962       new_ptr = get_new_handler (map (ptr->handler_label), ptr->type_info);
 963       add_new_handler (new_region, new_ptr);
 964     }
 965
 966   return new_region;
 967 }
 968
 969
 970 /* Given a rethrow symbol, find the EH region number this is for. */
 971 static int
 972 eh_region_from_symbol (sym)
 973      rtx sym;
 974 {
 975   int x;
 976   if (sym == last_rethrow_symbol)
 977     return 1;
 978   for (x = 0; x < current_func_eh_entry; x++)
 979     if (function_eh_regions[x].rethrow_label == sym)
 980       return function_eh_regions[x].range_number;
 981   return -1;
 982 }
 983
 984 /* Like find_func_region, but using the rethrow symbol for the region
 985    rather than the region number itself.  */
 986 static int
 987 find_func_region_from_symbol (sym)
 988      rtx sym;
 989 {
 990   return find_func_region (eh_region_from_symbol (sym));
 991 }
 992
 993 /* When inlining/unrolling, we have to map the symbols passed to
 994    __rethrow as well. This performs the remap. If a symbol isn't foiund,
 995    the original one is returned. This is not an efficient routine,
 996    so don't call it on everything!! */
 997 rtx
 998 rethrow_symbol_map (sym, map)
 999      rtx sym;
1000      rtx (*map) PARAMS ((rtx));
1001 {
1002   int x, y;
1003   for (x = 0; x < current_func_eh_entry; x++)
1004     if (function_eh_regions[x].rethrow_label == sym)
1005       {
1006         /* We've found the original region, now lets determine which region
1007            this now maps to. */
1008         rtx l1 = function_eh_regions[x].handlers->handler_label;
1009         rtx l2 = map (l1);
1010         y = CODE_LABEL_NUMBER (l2); /* This is the new region number */
1011         x = find_func_region (y);  /* Get the new permanent region */
1012         if (x == -1)  /* Hmm, Doesn't exist yet */
1013           {
1014             x = duplicate_eh_handlers (CODE_LABEL_NUMBER (l1), y, map);
1015             /* Since we're mapping it, it must be used. */
1016             function_eh_regions[x].rethrow_ref = 1;
1017           }
1018         return function_eh_regions[x].rethrow_label;
1019       }
1020   return sym;
1021 }
1022
1023 int
1024 rethrow_used (region)
1025      int region;
1026 {
1027   if (flag_new_exceptions)
1028     {
1029       int ret = function_eh_regions[find_func_region (region)].rethrow_ref;
1030       return ret;
1031     }
1032   return 0;
1033 }
1034
1035 \f
1036 /* Routine to see if exception handling is turned on.
1037    DO_WARN is non-zero if we want to inform the user that exception
1038    handling is turned off.
1039
1040    This is used to ensure that -fexceptions has been specified if the
1041    compiler tries to use any exception-specific functions.  */
1042
1043 int
1044 doing_eh (do_warn)
1045      int do_warn;
1046 {
1047   if (! flag_exceptions)
1048     {
1049       static int warned = 0;
1050       if (! warned && do_warn)
1051         {
1052           error ("exception handling disabled, use -fexceptions to enable");
1053           warned = 1;
1054         }
1055       return 0;
1056     }
1057   return 1;
1058 }
1059
1060 /* Given a return address in ADDR, determine the address we should use
1061    to find the corresponding EH region.  */
1062
1063 rtx
1064 eh_outer_context (addr)
1065      rtx addr;
1066 {
1067   /* First mask out any unwanted bits.  */
1068 #ifdef MASK_RETURN_ADDR
1069   expand_and (addr, MASK_RETURN_ADDR, addr);
1070 #endif
1071
1072   /* Then adjust to find the real return address.  */
1073 #if defined (RETURN_ADDR_OFFSET)
1074   addr = plus_constant (addr, RETURN_ADDR_OFFSET);
1075 #endif
1076
1077   return addr;
1078 }
1079
1080 /* Start a new exception region for a region of code that has a
1081    cleanup action and push the HANDLER for the region onto
1082    protect_list. All of the regions created with add_partial_entry
1083    will be ended when end_protect_partials is invoked.  */
1084
1085 void
1086 add_partial_entry (handler)
1087      tree handler;
1088 {
1089   expand_eh_region_start ();
1090
1091   /* Make sure the entry is on the correct obstack.  */
1092   push_obstacks_nochange ();
1093   resume_temporary_allocation ();
1094
1095   /* Because this is a cleanup action, we may have to protect the handler
1096      with __terminate.  */
1097   handler = protect_with_terminate (handler);
1098
1099   /* For backwards compatibility, we allow callers to omit calls to
1100      begin_protect_partials for the outermost region.  So, we must
1101      explicitly do so here.  */
1102   if (!protect_list)
1103     begin_protect_partials ();
1104
1105   /* Add this entry to the front of the list.  */
1106   TREE_VALUE (protect_list)
1107     = tree_cons (NULL_TREE, handler, TREE_VALUE (protect_list));
1108   pop_obstacks ();
1109 }
1110
1111 /* Emit code to get EH context to current function.  */
1112
1113 static rtx
1114 call_get_eh_context ()
1115 {
1116   static tree fn;
1117   tree expr;
1118
1119   if (fn == NULL_TREE)
1120     {
1121       tree fntype;
1122       fn = get_identifier ("__get_eh_context");
1123       push_obstacks_nochange ();
1124       end_temporary_allocation ();
1125       fntype = build_pointer_type (build_pointer_type
1126                                    (build_pointer_type (void_type_node)));
1127       fntype = build_function_type (fntype, NULL_TREE);
1128       fn = build_decl (FUNCTION_DECL, fn, fntype);
1129       DECL_EXTERNAL (fn) = 1;
1130       TREE_PUBLIC (fn) = 1;
1131       DECL_ARTIFICIAL (fn) = 1;
1132       TREE_READONLY (fn) = 1;
1133       make_decl_rtl (fn, NULL_PTR, 1);
1134       assemble_external (fn);
1135       pop_obstacks ();
1136
1137       ggc_add_tree_root (&fn, 1);
1138     }
1139
1140   expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
1141   expr = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
1142                 expr, NULL_TREE, NULL_TREE);
1143   TREE_SIDE_EFFECTS (expr) = 1;
1144
1145   return copy_to_reg (expand_expr (expr, NULL_RTX, VOIDmode, 0));
1146 }
1147
1148 /* Get a reference to the EH context.
1149    We will only generate a register for the current function EH context here,
1150    and emit a USE insn to mark that this is a EH context register.
1151
1152    Later, emit_eh_context will emit needed call to __get_eh_context
1153    in libgcc2, and copy the value to the register we have generated. */
1154
1155 rtx
1156 get_eh_context ()
1157 {
1158   if (current_function_ehc == 0)
1159     {
1160       rtx insn;
1161
1162       current_function_ehc = gen_reg_rtx (Pmode);
1163
1164       insn = gen_rtx_USE (GET_MODE (current_function_ehc),
1165                           current_function_ehc);
1166       insn = emit_insn_before (insn, get_first_nonparm_insn ());
1167
1168       REG_NOTES (insn)
1169         = gen_rtx_EXPR_LIST (REG_EH_CONTEXT, current_function_ehc,
1170                              REG_NOTES (insn));
1171     }
1172   return current_function_ehc;
1173 }
1174
1175 /* Get a reference to the dynamic handler chain.  It points to the
1176    pointer to the next element in the dynamic handler chain.  It ends
1177    when there are no more elements in the dynamic handler chain, when
1178    the value is &top_elt from libgcc2.c.  Immediately after the
1179    pointer, is an area suitable for setjmp/longjmp when
1180    DONT_USE_BUILTIN_SETJMP is defined, and an area suitable for
1181    __builtin_setjmp/__builtin_longjmp when DONT_USE_BUILTIN_SETJMP
1182    isn't defined. */
1183
1184 rtx
1185 get_dynamic_handler_chain ()
1186 {
1187   rtx ehc, dhc, result;
1188
1189   ehc = get_eh_context ();
1190
1191   /* This is the offset of dynamic_handler_chain in the eh_context struct
1192      declared in eh-common.h. If its location is change, change this offset */
1193   dhc = plus_constant (ehc, POINTER_SIZE / BITS_PER_UNIT);
1194
1195   result = copy_to_reg (dhc);
1196
1197   /* We don't want a copy of the dcc, but rather, the single dcc.  */
1198   return gen_rtx_MEM (Pmode, result);
1199 }
1200
1201 /* Get a reference to the dynamic cleanup chain.  It points to the
1202    pointer to the next element in the dynamic cleanup chain.
1203    Immediately after the pointer, are two Pmode variables, one for a
1204    pointer to a function that performs the cleanup action, and the
1205    second, the argument to pass to that function.  */
1206
1207 rtx
1208 get_dynamic_cleanup_chain ()
1209 {
1210   rtx dhc, dcc, result;
1211
1212   dhc = get_dynamic_handler_chain ();
1213   dcc = plus_constant (dhc, POINTER_SIZE / BITS_PER_UNIT);
1214
1215   result = copy_to_reg (dcc);
1216
1217   /* We don't want a copy of the dcc, but rather, the single dcc.  */
1218   return gen_rtx_MEM (Pmode, result);
1219 }
1220
1221 #ifdef DONT_USE_BUILTIN_SETJMP
1222 /* Generate code to evaluate X and jump to LABEL if the value is nonzero.
1223    LABEL is an rtx of code CODE_LABEL, in this function.  */
1224
1225 static void
1226 jumpif_rtx (x, label)
1227      rtx x;
1228      rtx label;
1229 {
1230   jumpif (make_tree (type_for_mode (GET_MODE (x), 0), x), label);
1231 }
1232 #endif
1233
1234 /* Start a dynamic cleanup on the EH runtime dynamic cleanup stack.
1235    We just need to create an element for the cleanup list, and push it
1236    into the chain.
1237
1238    A dynamic cleanup is a cleanup action implied by the presence of an
1239    element on the EH runtime dynamic cleanup stack that is to be
1240    performed when an exception is thrown.  The cleanup action is
1241    performed by __sjthrow when an exception is thrown.  Only certain
1242    actions can be optimized into dynamic cleanup actions.  For the
1243    restrictions on what actions can be performed using this routine,
1244    see expand_eh_region_start_tree.  */
1245
1246 static void
1247 start_dynamic_cleanup (func, arg)
1248      tree func;
1249      tree arg;
1250 {
1251   rtx dcc;
1252   rtx new_func, new_arg;
1253   rtx x, buf;
1254   int size;
1255
1256   /* We allocate enough room for a pointer to the function, and
1257      one argument.  */
1258   size = 2;
1259
1260   /* XXX, FIXME: The stack space allocated this way is too long lived,
1261      but there is no allocation routine that allocates at the level of
1262      the last binding contour.  */
1263   buf = assign_stack_local (BLKmode,
1264                             GET_MODE_SIZE (Pmode)*(size+1),
1265                             0);
1266
1267   buf = change_address (buf, Pmode, NULL_RTX);
1268
1269   /* Store dcc into the first word of the newly allocated buffer.  */
1270
1271   dcc = get_dynamic_cleanup_chain ();
1272   emit_move_insn (buf, dcc);
1273
1274   /* Store func and arg into the cleanup list element.  */
1275
1276   new_func = gen_rtx_MEM (Pmode, plus_constant (XEXP (buf, 0),
1277                                                 GET_MODE_SIZE (Pmode)));
1278   new_arg = gen_rtx_MEM (Pmode, plus_constant (XEXP (buf, 0),
1279                                                GET_MODE_SIZE (Pmode)*2));
1280   x = expand_expr (func, new_func, Pmode, 0);
1281   if (x != new_func)
1282     emit_move_insn (new_func, x);
1283
1284   x = expand_expr (arg, new_arg, Pmode, 0);
1285   if (x != new_arg)
1286     emit_move_insn (new_arg, x);
1287
1288   /* Update the cleanup chain.  */
1289
1290   x = force_operand (XEXP (buf, 0), dcc);
1291   if (x != dcc)
1292     emit_move_insn (dcc, x);
1293 }
1294
1295 /* Emit RTL to start a dynamic handler on the EH runtime dynamic
1296    handler stack.  This should only be used by expand_eh_region_start
1297    or expand_eh_region_start_tree.  */
1298
1299 static void
1300 start_dynamic_handler ()
1301 {
1302   rtx dhc, dcc;
1303   rtx x, arg, buf;
1304   int size;
1305
1306 #ifndef DONT_USE_BUILTIN_SETJMP
1307   /* The number of Pmode words for the setjmp buffer, when using the
1308      builtin setjmp/longjmp, see expand_builtin, case BUILT_IN_LONGJMP.  */
1309   /* We use 2 words here before calling expand_builtin_setjmp.
1310      expand_builtin_setjmp uses 2 words, and then calls emit_stack_save.
1311      emit_stack_save needs space of size STACK_SAVEAREA_MODE (SAVE_NONLOCAL).
1312      Subtract one, because the assign_stack_local call below adds 1.  */
1313   size = (2 + 2 + (GET_MODE_SIZE (STACK_SAVEAREA_MODE (SAVE_NONLOCAL))
1314                    / GET_MODE_SIZE (Pmode))
1315           - 1);
1316 #else
1317 #ifdef JMP_BUF_SIZE
1318   size = JMP_BUF_SIZE;
1319 #else
1320   /* Should be large enough for most systems, if it is not,
1321      JMP_BUF_SIZE should be defined with the proper value.  It will
1322      also tend to be larger than necessary for most systems, a more
1323      optimal port will define JMP_BUF_SIZE.  */
1324   size = FIRST_PSEUDO_REGISTER+2;
1325 #endif
1326 #endif
1327   /* XXX, FIXME: The stack space allocated this way is too long lived,
1328      but there is no allocation routine that allocates at the level of
1329      the last binding contour.  */
1330   arg = assign_stack_local (BLKmode,
1331                             GET_MODE_SIZE (Pmode)*(size+1),
1332                             0);
1333
1334   arg = change_address (arg, Pmode, NULL_RTX);
1335
1336   /* Store dhc into the first word of the newly allocated buffer.  */
1337
1338   dhc = get_dynamic_handler_chain ();
1339   dcc = gen_rtx_MEM (Pmode, plus_constant (XEXP (arg, 0),
1340                                            GET_MODE_SIZE (Pmode)));
1341   emit_move_insn (arg, dhc);
1342
1343   /* Zero out the start of the cleanup chain.  */
1344   emit_move_insn (dcc, const0_rtx);
1345
1346   /* The jmpbuf starts two words into the area allocated.  */
1347   buf = plus_constant (XEXP (arg, 0), GET_MODE_SIZE (Pmode)*2);
1348
1349 #ifdef DONT_USE_BUILTIN_SETJMP
1350   x = emit_library_call_value (setjmp_libfunc, NULL_RTX, 1, SImode, 1,
1351                                buf, Pmode);
1352   /* If we come back here for a catch, transfer control to the handler.  */
1353   jumpif_rtx (x, ehstack.top->entry->exception_handler_label);
1354 #else
1355   {
1356     /* A label to continue execution for the no exception case.  */
1357     rtx noex = gen_label_rtx();
1358     x = expand_builtin_setjmp (buf, NULL_RTX, noex,
1359                                ehstack.top->entry->exception_handler_label);
1360     emit_label (noex);
1361   }
1362 #endif
1363
1364   /* We are committed to this, so update the handler chain.  */
1365
1366   emit_move_insn (dhc, force_operand (XEXP (arg, 0), NULL_RTX));
1367 }
1368
1369 /* Start an exception handling region for the given cleanup action.
1370    All instructions emitted after this point are considered to be part
1371    of the region until expand_eh_region_end is invoked.  CLEANUP is
1372    the cleanup action to perform.  The return value is true if the
1373    exception region was optimized away.  If that case,
1374    expand_eh_region_end does not need to be called for this cleanup,
1375    nor should it be.
1376
1377    This routine notices one particular common case in C++ code
1378    generation, and optimizes it so as to not need the exception
1379    region.  It works by creating a dynamic cleanup action, instead of
1380    a using an exception region.  */
1381
1382 int
1383 expand_eh_region_start_tree (decl, cleanup)
1384      tree decl;
1385      tree cleanup;
1386 {
1387   /* This is the old code.  */
1388   if (! doing_eh (0))
1389     return 0;
1390
1391   /* The optimization only applies to actions protected with
1392      terminate, and only applies if we are using the setjmp/longjmp
1393      codegen method.  */
1394   if (exceptions_via_longjmp
1395       && protect_cleanup_actions_with_terminate)
1396     {
1397       tree func, arg;
1398       tree args;
1399
1400       /* Ignore any UNSAVE_EXPR.  */
1401       if (TREE_CODE (cleanup) == UNSAVE_EXPR)
1402         cleanup = TREE_OPERAND (cleanup, 0);
1403
1404       /* Further, it only applies if the action is a call, if there
1405          are 2 arguments, and if the second argument is 2.  */
1406
1407       if (TREE_CODE (cleanup) == CALL_EXPR
1408           && (args = TREE_OPERAND (cleanup, 1))
1409           && (func = TREE_OPERAND (cleanup, 0))
1410           && (arg = TREE_VALUE (args))
1411           && (args = TREE_CHAIN (args))
1412
1413           /* is the second argument 2?  */
1414           && TREE_CODE (TREE_VALUE (args)) == INTEGER_CST
1415           && TREE_INT_CST_LOW (TREE_VALUE (args)) == 2
1416           && TREE_INT_CST_HIGH (TREE_VALUE (args)) == 0
1417
1418           /* Make sure there are no other arguments.  */
1419           && TREE_CHAIN (args) == NULL_TREE)
1420         {
1421           /* Arrange for returns and gotos to pop the entry we make on the
1422              dynamic cleanup stack.  */
1423           expand_dcc_cleanup (decl);
1424           start_dynamic_cleanup (func, arg);
1425           return 1;
1426         }
1427     }
1428
1429   expand_eh_region_start_for_decl (decl);
1430   ehstack.top->entry->finalization = cleanup;
1431
1432   return 0;
1433 }
1434
1435 /* Just like expand_eh_region_start, except if a cleanup action is
1436    entered on the cleanup chain, the TREE_PURPOSE of the element put
1437    on the chain is DECL.  DECL should be the associated VAR_DECL, if
1438    any, otherwise it should be NULL_TREE.  */
1439
1440 void
1441 expand_eh_region_start_for_decl (decl)
1442      tree decl;
1443 {
1444   rtx note;
1445
1446   /* This is the old code.  */
1447   if (! doing_eh (0))
1448     return;
1449
1450   /* We need a new block to record the start and end of the
1451      dynamic handler chain.  We also want to prevent jumping into
1452      a try block.  */
1453   expand_start_bindings (2);
1454
1455   /* But we don't need or want a new temporary level.  */
1456   pop_temp_slots ();
1457
1458   /* Mark this block as created by expand_eh_region_start.  This
1459      is so that we can pop the block with expand_end_bindings
1460      automatically.  */
1461   mark_block_as_eh_region ();
1462
1463   if (exceptions_via_longjmp)
1464     {
1465       /* Arrange for returns and gotos to pop the entry we make on the
1466          dynamic handler stack.  */
1467       expand_dhc_cleanup (decl);
1468     }
1469
1470   push_eh_entry (&ehstack);
1471   note = emit_note (NULL_PTR, NOTE_INSN_EH_REGION_BEG);
1472   NOTE_EH_HANDLER (note)
1473     = CODE_LABEL_NUMBER (ehstack.top->entry->exception_handler_label);
1474   if (exceptions_via_longjmp)
1475     start_dynamic_handler ();
1476 }
1477
1478 /* Start an exception handling region.  All instructions emitted after
1479    this point are considered to be part of the region until
1480    expand_eh_region_end is invoked.  */
1481
1482 void
1483 expand_eh_region_start ()
1484 {
1485   expand_eh_region_start_for_decl (NULL_TREE);
1486 }
1487
1488 /* End an exception handling region.  The information about the region
1489    is found on the top of ehstack.
1490
1491    HANDLER is either the cleanup for the exception region, or if we're
1492    marking the end of a try block, HANDLER is integer_zero_node.
1493
1494    HANDLER will be transformed to rtl when expand_leftover_cleanups
1495    is invoked.  */
1496
1497 void
1498 expand_eh_region_end (handler)
1499      tree handler;
1500 {
1501   struct eh_entry *entry;
1502   struct eh_node *node;
1503   rtx note;
1504   int ret, r;
1505
1506   if (! doing_eh (0))
1507     return;
1508
1509   entry = pop_eh_entry (&ehstack);
1510
1511   note = emit_note (NULL_PTR, NOTE_INSN_EH_REGION_END);
1512   ret = NOTE_EH_HANDLER (note)
1513     = CODE_LABEL_NUMBER (entry->exception_handler_label);
1514   if (exceptions_via_longjmp == 0 && ! flag_new_exceptions
1515       /* We share outer_context between regions; only emit it once.  */
1516       && INSN_UID (entry->outer_context) == 0)
1517     {
1518       rtx label;
1519
1520       label = gen_label_rtx ();
1521       emit_jump (label);
1522
1523       /* Emit a label marking the end of this exception region that
1524          is used for rethrowing into the outer context.  */
1525       emit_label (entry->outer_context);
1526       expand_internal_throw ();
1527
1528       emit_label (label);
1529     }
1530
1531   entry->finalization = handler;
1532
1533   /* create region entry in final exception table */
1534   r = new_eh_region_entry (NOTE_EH_HANDLER (note), entry->rethrow_label);
1535
1536   enqueue_eh_entry (ehqueue, entry);
1537
1538   /* If we have already started ending the bindings, don't recurse.  */
1539   if (is_eh_region ())
1540     {
1541       /* Because we don't need or want a new temporary level and
1542          because we didn't create one in expand_eh_region_start,
1543          create a fake one now to avoid removing one in
1544          expand_end_bindings.  */
1545       push_temp_slots ();
1546
1547       mark_block_as_not_eh_region ();
1548
1549       expand_end_bindings (NULL_TREE, 0, 0);
1550     }
1551
1552   /* Go through the goto handlers in the queue, emitting their
1553      handlers if we now have enough information to do so.  */
1554   for (node = ehqueue->head; node; node = node->chain)
1555     if (node->entry->goto_entry_p
1556         && node->entry->outer_context == entry->rethrow_label)
1557       emit_cleanup_handler (node->entry);
1558
1559   /* We can't emit handlers for goto entries until their scopes are
1560      complete because we don't know where they need to rethrow to,
1561      yet.  */
1562   if (entry->finalization != integer_zero_node
1563       && (!entry->goto_entry_p
1564           || find_func_region_from_symbol (entry->outer_context) != -1))
1565     emit_cleanup_handler (entry);
1566 }
1567
1568 /* End the EH region for a goto fixup.  We only need them in the region-based
1569    EH scheme.  */
1570
1571 void
1572 expand_fixup_region_start ()
1573 {
1574   if (! doing_eh (0) || exceptions_via_longjmp)
1575     return;
1576
1577   expand_eh_region_start ();
1578   /* Mark this entry as the entry for a goto.  */
1579   ehstack.top->entry->goto_entry_p = 1;
1580 }
1581
1582 /* End the EH region for a goto fixup.  CLEANUP is the cleanup we just
1583    expanded; to avoid running it twice if it throws, we look through the
1584    ehqueue for a matching region and rethrow from its outer_context.  */
1585
1586 void
1587 expand_fixup_region_end (cleanup)
1588      tree cleanup;
1589 {
1590   struct eh_node *node;
1591   int dont_issue;
1592
1593   if (! doing_eh (0) || exceptions_via_longjmp)
1594     return;
1595
1596   for (node = ehstack.top; node && node->entry->finalization != cleanup; )
1597     node = node->chain;
1598   if (node == 0)
1599     for (node = ehqueue->head; node && node->entry->finalization != cleanup; )
1600       node = node->chain;
1601   if (node == 0)
1602     abort ();
1603
1604   /* If the outer context label has not been issued yet, we don't want
1605      to issue it as a part of this region, unless this is the
1606      correct region for the outer context. If we did, then the label for
1607      the outer context will be WITHIN the begin/end labels,
1608      and we could get an infinte loop when it tried to rethrow, or just
1609      generally incorrect execution following a throw. */
1610
1611   if (flag_new_exceptions)
1612     dont_issue = 0;
1613   else
1614     dont_issue = ((INSN_UID (node->entry->outer_context) == 0)
1615                   && (ehstack.top->entry != node->entry));
1616
1617   ehstack.top->entry->outer_context = node->entry->outer_context;
1618
1619   /* Since we are rethrowing to the OUTER region, we know we don't need
1620      a jump around sequence for this region, so we'll pretend the outer
1621      context label has been issued by setting INSN_UID to 1, then clearing
1622      it again afterwards. */
1623
1624   if (dont_issue)
1625     INSN_UID (node->entry->outer_context) = 1;
1626
1627   /* Just rethrow.  size_zero_node is just a NOP.  */
1628   expand_eh_region_end (size_zero_node);
1629
1630   if (dont_issue)
1631     INSN_UID (node->entry->outer_context) = 0;
1632 }
1633
1634 /* If we are using the setjmp/longjmp EH codegen method, we emit a
1635    call to __sjthrow.
1636
1637    Otherwise, we emit a call to __throw and note that we threw
1638    something, so we know we need to generate the necessary code for
1639    __throw.
1640
1641    Before invoking throw, the __eh_pc variable must have been set up
1642    to contain the PC being thrown from. This address is used by
1643    __throw to determine which exception region (if any) is
1644    responsible for handling the exception.  */
1645
1646 void
1647 emit_throw ()
1648 {
1649   if (exceptions_via_longjmp)
1650     {
1651       emit_library_call (sjthrow_libfunc, 0, VOIDmode, 0);
1652     }
1653   else
1654     {
1655 #ifdef JUMP_TO_THROW
1656       emit_indirect_jump (throw_libfunc);
1657 #else
1658       emit_library_call (throw_libfunc, 0, VOIDmode, 0);
1659 #endif
1660     }
1661   emit_barrier ();
1662 }
1663
1664 /* Throw the current exception.  If appropriate, this is done by jumping
1665    to the next handler.  */
1666
1667 void
1668 expand_internal_throw ()
1669 {
1670   emit_throw ();
1671 }
1672
1673 /* Called from expand_exception_blocks and expand_end_catch_block to
1674    emit any pending handlers/cleanups queued from expand_eh_region_end.  */
1675
1676 void
1677 expand_leftover_cleanups ()
1678 {
1679   struct eh_entry *entry;
1680
1681   for (entry = dequeue_eh_entry (ehqueue);
1682        entry;
1683        entry = dequeue_eh_entry (ehqueue))
1684     {
1685       /* A leftover try block.  Shouldn't be one here.  */
1686       if (entry->finalization == integer_zero_node)
1687         abort ();
1688
1689       free (entry);
1690     }
1691 }
1692
1693 /* Called at the start of a block of try statements.  */
1694 void
1695 expand_start_try_stmts ()
1696 {
1697   if (! doing_eh (1))
1698     return;
1699
1700   expand_eh_region_start ();
1701 }
1702
1703 /* Called to begin a catch clause. The parameter is the object which
1704    will be passed to the runtime type check routine. */
1705 void
1706 start_catch_handler (rtime)
1707      tree rtime;
1708 {
1709   rtx handler_label;
1710   int insn_region_num;
1711   int eh_region_entry;
1712
1713   if (! doing_eh (1))
1714     return;
1715
1716   handler_label = catchstack.top->entry->exception_handler_label;
1717   insn_region_num = CODE_LABEL_NUMBER (handler_label);
1718   eh_region_entry = find_func_region (insn_region_num);
1719
1720   /* If we've already issued this label, pick a new one */
1721   if (catchstack.top->entry->label_used)
1722     handler_label = gen_exception_label ();
1723   else
1724     catchstack.top->entry->label_used = 1;
1725
1726   receive_exception_label (handler_label);
1727
1728   add_new_handler (eh_region_entry, get_new_handler (handler_label, rtime));
1729
1730   if (flag_new_exceptions && ! exceptions_via_longjmp)
1731     return;
1732
1733   /* Under the old mechanism, as well as setjmp/longjmp, we need to
1734      issue code to compare 'rtime' to the value in eh_info, via the
1735      matching function in eh_info. If its is false, we branch around
1736      the handler we are about to issue. */
1737
1738   if (rtime != NULL_TREE && rtime != CATCH_ALL_TYPE)
1739     {
1740       rtx call_rtx, rtime_address;
1741
1742       if (catchstack.top->entry->false_label != NULL_RTX)
1743         {
1744           error ("Never issued previous false_label");
1745           abort ();
1746         }
1747       catchstack.top->entry->false_label = gen_exception_label ();
1748
1749       rtime_address = expand_expr (rtime, NULL_RTX, Pmode, EXPAND_INITIALIZER);
1750 #ifdef POINTERS_EXTEND_UNSIGNED
1751       rtime_address = convert_memory_address (Pmode, rtime_address);
1752 #endif
1753       rtime_address = force_reg (Pmode, rtime_address);
1754
1755       /* Now issue the call, and branch around handler if needed */
1756       call_rtx = emit_library_call_value (eh_rtime_match_libfunc, NULL_RTX,
1757                                           0, SImode, 1, rtime_address, Pmode);
1758
1759       /* Did the function return true? */
1760       emit_cmp_and_jump_insns (call_rtx, const0_rtx, EQ, NULL_RTX,
1761                                GET_MODE (call_rtx), 0, 0,
1762                                catchstack.top->entry->false_label);
1763     }
1764 }
1765
1766 /* Called to end a catch clause. If we aren't using the new exception
1767    model tabel mechanism, we need to issue the branch-around label
1768    for the end of the catch block. */
1769
1770 void
1771 end_catch_handler ()
1772 {
1773   if (! doing_eh (1))
1774     return;
1775
1776   if (flag_new_exceptions && ! exceptions_via_longjmp)
1777     {
1778       emit_barrier ();
1779       return;
1780     }
1781
1782   /* A NULL label implies the catch clause was a catch all or cleanup */
1783   if (catchstack.top->entry->false_label == NULL_RTX)
1784     return;
1785
1786   emit_label (catchstack.top->entry->false_label);
1787   catchstack.top->entry->false_label = NULL_RTX;
1788 }
1789
1790 /* Save away the current ehqueue.  */
1791
1792 void
1793 push_ehqueue ()
1794 {
1795   struct eh_queue *q;
1796   q = (struct eh_queue *) xcalloc (1, sizeof (struct eh_queue));
1797   q->next = ehqueue;
1798   ehqueue = q;
1799 }
1800
1801 /* Restore a previously pushed ehqueue.  */
1802
1803 void
1804 pop_ehqueue ()
1805 {
1806   struct eh_queue *q;
1807   expand_leftover_cleanups ();
1808   q = ehqueue->next;
1809   free (ehqueue);
1810   ehqueue = q;
1811 }
1812
1813 /* Emit the handler specified by ENTRY.  */
1814
1815 static void
1816 emit_cleanup_handler (entry)
1817   struct eh_entry *entry;
1818 {
1819   rtx prev;
1820   rtx handler_insns;
1821
1822   /* Since the cleanup could itself contain try-catch blocks, we
1823      squirrel away the current queue and replace it when we are done
1824      with this function.  */
1825   push_ehqueue ();
1826
1827   /* Put these handler instructions in a sequence.  */
1828   do_pending_stack_adjust ();
1829   start_sequence ();
1830
1831   /* Emit the label for the cleanup handler for this region, and
1832      expand the code for the handler.
1833
1834      Note that a catch region is handled as a side-effect here; for a
1835      try block, entry->finalization will contain integer_zero_node, so
1836      no code will be generated in the expand_expr call below. But, the
1837      label for the handler will still be emitted, so any code emitted
1838      after this point will end up being the handler.  */
1839
1840   receive_exception_label (entry->exception_handler_label);
1841
1842   /* register a handler for this cleanup region */
1843   add_new_handler (find_func_region (CODE_LABEL_NUMBER (entry->exception_handler_label)),
1844                    get_new_handler (entry->exception_handler_label, NULL));
1845
1846   /* And now generate the insns for the cleanup handler.  */
1847   expand_expr (entry->finalization, const0_rtx, VOIDmode, 0);
1848
1849   prev = get_last_insn ();
1850   if (prev == NULL || GET_CODE (prev) != BARRIER)
1851     /* Code to throw out to outer context when we fall off end of the
1852        handler. We can't do this here for catch blocks, so it's done
1853        in expand_end_all_catch instead.  */
1854     expand_rethrow (entry->outer_context);
1855
1856   /* Finish this sequence.  */
1857   do_pending_stack_adjust ();
1858   handler_insns = get_insns ();
1859   end_sequence ();
1860
1861   /* And add it to the CATCH_CLAUSES.  */
1862   push_to_sequence (catch_clauses);
1863   emit_insns (handler_insns);
1864   catch_clauses = get_insns ();
1865   end_sequence ();
1866
1867   /* Now we've left the handler.  */
1868   pop_ehqueue ();
1869 }
1870
1871 /* Generate RTL for the start of a group of catch clauses.
1872
1873    It is responsible for starting a new instruction sequence for the
1874    instructions in the catch block, and expanding the handlers for the
1875    internally-generated exception regions nested within the try block
1876    corresponding to this catch block.  */
1877
1878 void
1879 expand_start_all_catch ()
1880 {
1881   struct eh_entry *entry;
1882   tree label;
1883   rtx outer_context;
1884
1885   if (! doing_eh (1))
1886     return;
1887
1888   outer_context = ehstack.top->entry->outer_context;
1889
1890   /* End the try block.  */
1891   expand_eh_region_end (integer_zero_node);
1892
1893   emit_line_note (input_filename, lineno);
1894   label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
1895
1896   /* The label for the exception handling block that we will save.
1897      This is Lresume in the documentation.  */
1898   expand_label (label);
1899
1900   /* Push the label that points to where normal flow is resumed onto
1901      the top of the label stack.  */
1902   push_label_entry (&caught_return_label_stack, NULL_RTX, label);
1903
1904   /* Start a new sequence for all the catch blocks.  We will add this
1905      to the global sequence catch_clauses when we have completed all
1906      the handlers in this handler-seq.  */
1907   start_sequence ();
1908
1909   /* Throw away entries in the queue that we won't need anymore.  We
1910      need entries for regions that have ended but to which there might
1911      still be gotos pending.  */
1912   for (entry = dequeue_eh_entry (ehqueue);
1913        entry->finalization != integer_zero_node;
1914        entry = dequeue_eh_entry (ehqueue))
1915     free (entry);
1916
1917   /* At this point, all the cleanups are done, and the ehqueue now has
1918      the current exception region at its head. We dequeue it, and put it
1919      on the catch stack. */
1920   push_entry (&catchstack, entry);
1921
1922   /* If we are not doing setjmp/longjmp EH, because we are reordered
1923      out of line, we arrange to rethrow in the outer context.  We need to
1924      do this because we are not physically within the region, if any, that
1925      logically contains this catch block.  */
1926   if (! exceptions_via_longjmp)
1927     {
1928       expand_eh_region_start ();
1929       ehstack.top->entry->outer_context = outer_context;
1930     }
1931
1932 }
1933
1934 /* Finish up the catch block.  At this point all the insns for the
1935    catch clauses have already been generated, so we only have to add
1936    them to the catch_clauses list. We also want to make sure that if
1937    we fall off the end of the catch clauses that we rethrow to the
1938    outer EH region.  */
1939
1940 void
1941 expand_end_all_catch ()
1942 {
1943   rtx new_catch_clause;
1944   struct eh_entry *entry;
1945
1946   if (! doing_eh (1))
1947     return;
1948
1949   /* Dequeue the current catch clause region. */
1950   entry = pop_eh_entry (&catchstack);
1951   free (entry);
1952
1953   if (! exceptions_via_longjmp)
1954     {
1955       rtx outer_context = ehstack.top->entry->outer_context;
1956
1957       /* Finish the rethrow region.  size_zero_node is just a NOP.  */
1958       expand_eh_region_end (size_zero_node);
1959       /* New exceptions handling models will never have a fall through
1960          of a catch clause */
1961       if (!flag_new_exceptions)
1962         expand_rethrow (outer_context);
1963     }
1964   else
1965     expand_rethrow (NULL_RTX);
1966
1967   /* Code to throw out to outer context, if we fall off end of catch
1968      handlers.  This is rethrow (Lresume, same id, same obj) in the
1969      documentation. We use Lresume because we know that it will throw
1970      to the correct context.
1971
1972      In other words, if the catch handler doesn't exit or return, we
1973      do a "throw" (using the address of Lresume as the point being
1974      thrown from) so that the outer EH region can then try to process
1975      the exception.  */
1976
1977   /* Now we have the complete catch sequence.  */
1978   new_catch_clause = get_insns ();
1979   end_sequence ();
1980
1981   /* This level of catch blocks is done, so set up the successful
1982      catch jump label for the next layer of catch blocks.  */
1983   pop_label_entry (&caught_return_label_stack);
1984   pop_label_entry (&outer_context_label_stack);
1985
1986   /* Add the new sequence of catches to the main one for this function.  */
1987   push_to_sequence (catch_clauses);
1988   emit_insns (new_catch_clause);
1989   catch_clauses = get_insns ();
1990   end_sequence ();
1991
1992   /* Here we fall through into the continuation code.  */
1993 }
1994
1995 /* Rethrow from the outer context LABEL.  */
1996
1997 static void
1998 expand_rethrow (label)
1999      rtx label;
2000 {
2001   if (exceptions_via_longjmp)
2002     emit_throw ();
2003   else
2004     if (flag_new_exceptions)
2005       {
2006         rtx insn;
2007         int region;
2008         if (label == NULL_RTX)
2009           label = last_rethrow_symbol;
2010         emit_library_call (rethrow_libfunc, 0, VOIDmode, 1, label, Pmode);
2011         region = find_func_region (eh_region_from_symbol (label));
2012         /* If the region is -1, it doesn't exist yet.  We should be
2013            trying to rethrow there yet.  */
2014         if (region == -1)
2015           abort ();
2016         function_eh_regions[region].rethrow_ref = 1;
2017
2018         /* Search backwards for the actual call insn.  */
2019         insn = get_last_insn ();
2020         while (GET_CODE (insn) != CALL_INSN)
2021           insn = PREV_INSN (insn);
2022         delete_insns_since (insn);
2023
2024         /* Mark the label/symbol on the call. */
2025         REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EH_RETHROW, label,
2026                                               REG_NOTES (insn));
2027         emit_barrier ();
2028       }
2029     else
2030       emit_jump (label);
2031 }
2032
2033 /* Begin a region that will contain entries created with
2034    add_partial_entry.  */
2035
2036 void
2037 begin_protect_partials ()
2038 {
2039   /* Put the entry on the function obstack.  */
2040   push_obstacks_nochange ();
2041   resume_temporary_allocation ();
2042
2043   /* Push room for a new list.  */
2044   protect_list = tree_cons (NULL_TREE, NULL_TREE, protect_list);
2045
2046   /* We're done with the function obstack now.  */
2047   pop_obstacks ();
2048 }
2049
2050 /* End all the pending exception regions on protect_list. The handlers
2051    will be emitted when expand_leftover_cleanups is invoked.  */
2052
2053 void
2054 end_protect_partials ()
2055 {
2056   tree t;
2057
2058   /* For backwards compatibility, we allow callers to omit the call to
2059      begin_protect_partials for the outermost region.  So,
2060      PROTECT_LIST may be NULL.  */
2061   if (!protect_list)
2062     return;
2063
2064   /* End all the exception regions.  */
2065   for (t = TREE_VALUE (protect_list); t; t = TREE_CHAIN (t))
2066     expand_eh_region_end (TREE_VALUE (t));
2067
2068   /* Pop the topmost entry.  */
2069   protect_list = TREE_CHAIN (protect_list);
2070
2071 }
2072
2073 /* Arrange for __terminate to be called if there is an unhandled throw
2074    from within E.  */
2075
2076 tree
2077 protect_with_terminate (e)
2078      tree e;
2079 {
2080   /* We only need to do this when using setjmp/longjmp EH and the
2081      language requires it, as otherwise we protect all of the handlers
2082      at once, if we need to.  */
2083   if (exceptions_via_longjmp && protect_cleanup_actions_with_terminate)
2084     {
2085       tree handler, result;
2086
2087       /* All cleanups must be on the function_obstack.  */
2088       push_obstacks_nochange ();
2089       resume_temporary_allocation ();
2090
2091       handler = make_node (RTL_EXPR);
2092       TREE_TYPE (handler) = void_type_node;
2093       RTL_EXPR_RTL (handler) = const0_rtx;
2094       TREE_SIDE_EFFECTS (handler) = 1;
2095       start_sequence_for_rtl_expr (handler);
2096
2097       emit_library_call (terminate_libfunc, 0, VOIDmode, 0);
2098       emit_barrier ();
2099
2100       RTL_EXPR_SEQUENCE (handler) = get_insns ();
2101       end_sequence ();
2102
2103       result = build (TRY_CATCH_EXPR, TREE_TYPE (e), e, handler);
2104       TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
2105       TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
2106       TREE_READONLY (result) = TREE_READONLY (e);
2107
2108       pop_obstacks ();
2109
2110       e = result;
2111     }
2112
2113   return e;
2114 }
2115 \f
2116 /* The exception table that we build that is used for looking up and
2117    dispatching exceptions, the current number of entries, and its
2118    maximum size before we have to extend it.
2119
2120    The number in eh_table is the code label number of the exception
2121    handler for the region. This is added by add_eh_table_entry and
2122    used by output_exception_table_entry.  */
2123
2124 static int *eh_table = NULL;
2125 static int eh_table_size = 0;
2126 static int eh_table_max_size = 0;
2127
2128 /* Note the need for an exception table entry for region N.  If we
2129    don't need to output an explicit exception table, avoid all of the
2130    extra work.
2131
2132    Called from final_scan_insn when a NOTE_INSN_EH_REGION_BEG is seen.
2133    (Or NOTE_INSN_EH_REGION_END sometimes)
2134    N is the NOTE_EH_HANDLER of the note, which comes from the code
2135    label number of the exception handler for the region.  */
2136
2137 void
2138 add_eh_table_entry (n)
2139      int n;
2140 {
2141 #ifndef OMIT_EH_TABLE
2142   if (eh_table_size >= eh_table_max_size)
2143     {
2144       if (eh_table)
2145         {
2146           eh_table_max_size += eh_table_max_size>>1;
2147
2148           if (eh_table_max_size < 0)
2149             abort ();
2150
2151           eh_table = (int *) xrealloc (eh_table,
2152                                        eh_table_max_size * sizeof (int));
2153         }
2154       else
2155         {
2156           eh_table_max_size = 252;
2157           eh_table = (int *) xmalloc (eh_table_max_size * sizeof (int));
2158         }
2159     }
2160   eh_table[eh_table_size++] = n;
2161 #endif
2162 }
2163
2164 /* Return a non-zero value if we need to output an exception table.
2165
2166    On some platforms, we don't have to output a table explicitly.
2167    This routine doesn't mean we don't have one.  */
2168
2169 int
2170 exception_table_p ()
2171 {
2172   if (eh_table)
2173     return 1;
2174
2175   return 0;
2176 }
2177
2178 /* Output the entry of the exception table corresponding to the
2179    exception region numbered N to file FILE.
2180
2181    N is the code label number corresponding to the handler of the
2182    region.  */
2183
2184 static void
2185 output_exception_table_entry (file, n)
2186      FILE *file;
2187      int n;
2188 {
2189   char buf[256];
2190   rtx sym;
2191   struct handler_info *handler = get_first_handler (n);
2192   int index = find_func_region (n);
2193   rtx rethrow;
2194
2195  /* form and emit the rethrow label, if needed  */
2196   rethrow = function_eh_regions[index].rethrow_label;
2197   if (rethrow != NULL_RTX && !flag_new_exceptions)
2198       rethrow = NULL_RTX;
2199   if (rethrow != NULL_RTX && handler == NULL)
2200     if (! function_eh_regions[index].rethrow_ref)
2201       rethrow = NULL_RTX;
2202
2203
2204   for ( ; handler != NULL || rethrow != NULL_RTX; handler = handler->next)
2205     {
2206       /* rethrow label should indicate the LAST entry for a region */
2207       if (rethrow != NULL_RTX && (handler == NULL || handler->next == NULL))
2208         {
2209           ASM_GENERATE_INTERNAL_LABEL (buf, "LRTH", n);
2210           assemble_label(buf);
2211           rethrow = NULL_RTX;
2212         }
2213
2214       ASM_GENERATE_INTERNAL_LABEL (buf, "LEHB", n);
2215       sym = gen_rtx_SYMBOL_REF (Pmode, buf);
2216       assemble_integer (sym, POINTER_SIZE / BITS_PER_UNIT, 1);
2217
2218       ASM_GENERATE_INTERNAL_LABEL (buf, "LEHE", n);
2219       sym = gen_rtx_SYMBOL_REF (Pmode, buf);
2220       assemble_integer (sym, POINTER_SIZE / BITS_PER_UNIT, 1);
2221
2222       if (handler == NULL)
2223         assemble_integer (GEN_INT (0), POINTER_SIZE / BITS_PER_UNIT, 1);
2224       else
2225         {
2226           ASM_GENERATE_INTERNAL_LABEL (buf, "L", handler->handler_number);
2227           sym = gen_rtx_SYMBOL_REF (Pmode, buf);
2228           assemble_integer (sym, POINTER_SIZE / BITS_PER_UNIT, 1);
2229         }
2230
2231       if (flag_new_exceptions)
2232         {
2233           if (handler == NULL || handler->type_info == NULL)
2234             assemble_integer (const0_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
2235           else
2236             if (handler->type_info == CATCH_ALL_TYPE)
2237               assemble_integer (GEN_INT (CATCH_ALL_TYPE),
2238                                              POINTER_SIZE / BITS_PER_UNIT, 1);
2239             else
2240               output_constant ((tree)(handler->type_info),
2241                                                 POINTER_SIZE / BITS_PER_UNIT);
2242         }
2243       putc ('\n', file);                /* blank line */
2244       /* We only output the first label under the old scheme */
2245       if (! flag_new_exceptions || handler == NULL)
2246         break;
2247     }
2248 }
2249
2250 /* Output the exception table if we have and need one.  */
2251
2252 static short language_code = 0;
2253 static short version_code = 0;
2254
2255 /* This routine will set the language code for exceptions. */
2256 void
2257 set_exception_lang_code (code)
2258      int code;
2259 {
2260   language_code = code;
2261 }
2262
2263 /* This routine will set the language version code for exceptions. */
2264 void
2265 set_exception_version_code (code)
2266      int code;
2267 {
2268   version_code = code;
2269 }
2270
2271
2272 void
2273 output_exception_table ()
2274 {
2275   int i;
2276   char buf[256];
2277   extern FILE *asm_out_file;
2278
2279   if (! doing_eh (0) || ! eh_table)
2280     return;
2281
2282   exception_section ();
2283
2284   /* Beginning marker for table.  */
2285   assemble_align (GET_MODE_ALIGNMENT (ptr_mode));
2286   assemble_label ("__EXCEPTION_TABLE__");
2287
2288   if (flag_new_exceptions)
2289     {
2290       assemble_integer (GEN_INT (NEW_EH_RUNTIME),
2291                                         POINTER_SIZE / BITS_PER_UNIT, 1);
2292       assemble_integer (GEN_INT (language_code), 2 , 1);
2293       assemble_integer (GEN_INT (version_code), 2 , 1);
2294
2295       /* Add enough padding to make sure table aligns on a pointer boundry. */
2296       i = GET_MODE_ALIGNMENT (ptr_mode) / BITS_PER_UNIT - 4;
2297       for ( ; i < 0; i = i + GET_MODE_ALIGNMENT (ptr_mode) / BITS_PER_UNIT)
2298         ;
2299       if (i != 0)
2300         assemble_integer (const0_rtx, i , 1);
2301
2302       /* Generate the label for offset calculations on rethrows */
2303       ASM_GENERATE_INTERNAL_LABEL (buf, "LRTH", 0);
2304       assemble_label(buf);
2305     }
2306
2307   for (i = 0; i < eh_table_size; ++i)
2308     output_exception_table_entry (asm_out_file, eh_table[i]);
2309
2310   free (eh_table);
2311   clear_function_eh_region ();
2312
2313   /* Ending marker for table.  */
2314   /* Generate the label for end of table. */
2315   ASM_GENERATE_INTERNAL_LABEL (buf, "LRTH", CODE_LABEL_NUMBER (final_rethrow));
2316   assemble_label(buf);
2317   assemble_integer (constm1_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
2318
2319   /* for binary compatability, the old __throw checked the second
2320      position for a -1, so we should output at least 2 -1's */
2321   if (! flag_new_exceptions)
2322     assemble_integer (constm1_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
2323
2324   putc ('\n', asm_out_file);            /* blank line */
2325 }
2326 \f
2327 /* Emit code to get EH context.
2328
2329    We have to scan thru the code to find possible EH context registers.
2330    Inlined functions may use it too, and thus we'll have to be able
2331    to change them too.
2332
2333    This is done only if using exceptions_via_longjmp. */
2334
2335 void
2336 emit_eh_context ()
2337 {
2338   rtx insn;
2339   rtx ehc = 0;
2340
2341   if (! doing_eh (0))
2342     return;
2343
2344   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2345     if (GET_CODE (insn) == INSN
2346         && GET_CODE (PATTERN (insn)) == USE)
2347       {
2348         rtx reg = find_reg_note (insn, REG_EH_CONTEXT, 0);
2349         if (reg)
2350           {
2351             rtx insns;
2352
2353             start_sequence ();
2354
2355             /* If this is the first use insn, emit the call here.  This
2356                will always be at the top of our function, because if
2357                expand_inline_function notices a REG_EH_CONTEXT note, it
2358                adds a use insn to this function as well.  */
2359             if (ehc == 0)
2360               ehc = call_get_eh_context ();
2361
2362             emit_move_insn (XEXP (reg, 0), ehc);
2363             insns = get_insns ();
2364             end_sequence ();
2365
2366             emit_insns_before (insns, insn);
2367           }
2368       }
2369 }
2370
2371 /* Scan the current insns and build a list of handler labels. The
2372    resulting list is placed in the global variable exception_handler_labels.
2373
2374    It is called after the last exception handling region is added to
2375    the current function (when the rtl is almost all built for the
2376    current function) and before the jump optimization pass.  */
2377
2378 void
2379 find_exception_handler_labels ()
2380 {
2381   rtx insn;
2382
2383   exception_handler_labels = NULL_RTX;
2384
2385   /* If we aren't doing exception handling, there isn't much to check.  */
2386   if (! doing_eh (0))
2387     return;
2388
2389   /* For each start of a region, add its label to the list.  */
2390
2391   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2392     {
2393       struct handler_info* ptr;
2394       if (GET_CODE (insn) == NOTE
2395           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
2396         {
2397           ptr = get_first_handler (NOTE_EH_HANDLER (insn));
2398           for ( ; ptr; ptr = ptr->next)
2399             {
2400               /* make sure label isn't in the list already */
2401               rtx x;
2402               for (x = exception_handler_labels; x; x = XEXP (x, 1))
2403                 if (XEXP (x, 0) == ptr->handler_label)
2404                   break;
2405               if (! x)
2406                 exception_handler_labels = gen_rtx_EXPR_LIST (VOIDmode,
2407                                ptr->handler_label, exception_handler_labels);
2408             }
2409         }
2410     }
2411 }
2412
2413 /* Return a value of 1 if the parameter label number is an exception handler
2414    label. Return 0 otherwise. */
2415
2416 int
2417 is_exception_handler_label (lab)
2418      int lab;
2419 {
2420   rtx x;
2421   for (x = exception_handler_labels ; x ; x = XEXP (x, 1))
2422     if (lab == CODE_LABEL_NUMBER (XEXP (x, 0)))
2423       return 1;
2424   return 0;
2425 }
2426
2427 /* Perform sanity checking on the exception_handler_labels list.
2428
2429    Can be called after find_exception_handler_labels is called to
2430    build the list of exception handlers for the current function and
2431    before we finish processing the current function.  */
2432
2433 void
2434 check_exception_handler_labels ()
2435 {
2436   rtx insn, insn2;
2437
2438   /* If we aren't doing exception handling, there isn't much to check.  */
2439   if (! doing_eh (0))
2440     return;
2441
2442   /* Make sure there is no more than 1 copy of a label */
2443   for (insn = exception_handler_labels; insn; insn = XEXP (insn, 1))
2444     {
2445       int count = 0;
2446       for (insn2 = exception_handler_labels; insn2; insn2 = XEXP (insn2, 1))
2447         if (XEXP (insn, 0) == XEXP (insn2, 0))
2448           count++;
2449       if (count != 1)
2450        warning ("Counted %d copies of EH region %d in list.\n", count,
2451                                         CODE_LABEL_NUMBER (insn));
2452     }
2453
2454 }
2455
2456 /* Mark the children of NODE for GC.  */
2457
2458 static void
2459 mark_eh_node (node)
2460      struct eh_node *node;
2461 {
2462   while (node)
2463     {
2464       if (node->entry)
2465         {
2466           ggc_mark_rtx (node->entry->outer_context);
2467           ggc_mark_rtx (node->entry->exception_handler_label);
2468           ggc_mark_tree (node->entry->finalization);
2469           ggc_mark_rtx (node->entry->false_label);
2470           ggc_mark_rtx (node->entry->rethrow_label);
2471         }
2472       node = node ->chain;
2473     }
2474 }
2475
2476 /* Mark S for GC.  */
2477
2478 static void
2479 mark_eh_stack (s)
2480      struct eh_stack *s;
2481 {
2482   if (s)
2483     mark_eh_node (s->top);
2484 }
2485
2486 /* Mark Q for GC.  */
2487
2488 static void
2489 mark_eh_queue (q)
2490      struct eh_queue *q;
2491 {
2492   while (q)
2493     {
2494       mark_eh_node (q->head);
2495       q = q->next;
2496     }
2497 }
2498
2499 /* Mark NODE for GC.  A label_node contains a union containing either
2500    a tree or an rtx.  This label_node will contain a tree.  */
2501
2502 static void
2503 mark_tree_label_node (node)
2504      struct label_node *node;
2505 {
2506   while (node)
2507     {
2508       ggc_mark_tree (node->u.tlabel);
2509       node = node->chain;
2510     }
2511 }
2512
2513 /* Mark EH for GC.  */
2514
2515 void
2516 mark_eh_status (eh)
2517      struct eh_status *eh;
2518 {
2519   if (eh == 0)
2520     return;
2521
2522   mark_eh_stack (&eh->x_ehstack);
2523   mark_eh_stack (&eh->x_catchstack);
2524   mark_eh_queue (eh->x_ehqueue);
2525   ggc_mark_rtx (eh->x_catch_clauses);
2526
2527   lang_mark_false_label_stack (eh->x_false_label_stack);
2528   mark_tree_label_node (eh->x_caught_return_label_stack);
2529
2530   ggc_mark_tree (eh->x_protect_list);
2531   ggc_mark_rtx (eh->ehc);
2532   ggc_mark_rtx (eh->x_eh_return_stub_label);
2533 }
2534
2535 /* Mark ARG (which is really a struct func_eh_entry**) for GC.  */
2536
2537 static void
2538 mark_func_eh_entry (arg)
2539      void *arg;
2540 {
2541   struct func_eh_entry *fee;
2542   struct handler_info *h;
2543   int i;
2544
2545   fee = *((struct func_eh_entry **) arg);
2546
2547   for (i = 0; i < current_func_eh_entry; ++i)
2548     {
2549       ggc_mark_rtx (fee->rethrow_label);
2550       for (h = fee->handlers; h; h = h->next)
2551         {
2552           ggc_mark_rtx (h->handler_label);
2553           if (h->type_info != CATCH_ALL_TYPE)
2554             ggc_mark_tree ((tree) h->type_info);
2555         }
2556
2557       /* Skip to the next entry in the array.  */
2558       ++fee;
2559     }
2560 }
2561
2562 /* This group of functions initializes the exception handling data
2563    structures at the start of the compilation, initializes the data
2564    structures at the start of a function, and saves and restores the
2565    exception handling data structures for the start/end of a nested
2566    function.  */
2567
2568 /* Toplevel initialization for EH things.  */
2569
2570 void
2571 init_eh ()
2572 {
2573   first_rethrow_symbol = create_rethrow_ref (0);
2574   final_rethrow = gen_exception_label ();
2575   last_rethrow_symbol = create_rethrow_ref (CODE_LABEL_NUMBER (final_rethrow));
2576
2577   ggc_add_rtx_root (&exception_handler_labels, 1);
2578   ggc_add_rtx_root (&eh_return_context, 1);
2579   ggc_add_rtx_root (&eh_return_stack_adjust, 1);
2580   ggc_add_rtx_root (&eh_return_handler, 1);
2581   ggc_add_rtx_root (&first_rethrow_symbol, 1);
2582   ggc_add_rtx_root (&final_rethrow, 1);
2583   ggc_add_rtx_root (&last_rethrow_symbol, 1);
2584   ggc_add_root (&function_eh_regions, 1, sizeof (function_eh_regions),
2585                 mark_func_eh_entry);
2586 }
2587
2588 /* Initialize the per-function EH information.  */
2589
2590 void
2591 init_eh_for_function ()
2592 {
2593   cfun->eh = (struct eh_status *) xcalloc (1, sizeof (struct eh_status));
2594   ehqueue = (struct eh_queue *) xcalloc (1, sizeof (struct eh_queue));
2595   eh_return_context = NULL_RTX;
2596   eh_return_stack_adjust = NULL_RTX;
2597   eh_return_handler = NULL_RTX;
2598 }
2599
2600 void
2601 free_eh_status (f)
2602      struct function *f;
2603 {
2604   free (f->eh->x_ehqueue);
2605   free (f->eh);
2606   f->eh = NULL;
2607 }
2608 \f
2609 /* This section is for the exception handling specific optimization
2610    pass.  First are the internal routines, and then the main
2611    optimization pass.  */
2612
2613 /* Determine if the given INSN can throw an exception.  */
2614
2615 static int
2616 can_throw (insn)
2617      rtx insn;
2618 {
2619   /* Calls can always potentially throw exceptions, unless they have
2620      a REG_EH_REGION note with a value of 0 or less.  */
2621   if (GET_CODE (insn) == CALL_INSN)
2622     {
2623       rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
2624       if (!note || XINT (XEXP (note, 0), 0) > 0)
2625         return 1;
2626     }
2627
2628   if (asynchronous_exceptions)
2629     {
2630       /* If we wanted asynchronous exceptions, then everything but NOTEs
2631          and CODE_LABELs could throw.  */
2632       if (GET_CODE (insn) != NOTE && GET_CODE (insn) != CODE_LABEL)
2633         return 1;
2634     }
2635
2636   return 0;
2637 }
2638
2639 /* Scan a exception region looking for the matching end and then
2640    remove it if possible. INSN is the start of the region, N is the
2641    region number, and DELETE_OUTER is to note if anything in this
2642    region can throw.
2643
2644    Regions are removed if they cannot possibly catch an exception.
2645    This is determined by invoking can_throw on each insn within the
2646    region; if can_throw returns true for any of the instructions, the
2647    region can catch an exception, since there is an insn within the
2648    region that is capable of throwing an exception.
2649
2650    Returns the NOTE_INSN_EH_REGION_END corresponding to this region, or
2651    calls abort if it can't find one.
2652
2653    Can abort if INSN is not a NOTE_INSN_EH_REGION_BEGIN, or if N doesn't
2654    correspond to the region number, or if DELETE_OUTER is NULL.  */
2655
2656 static rtx
2657 scan_region (insn, n, delete_outer)
2658      rtx insn;
2659      int n;
2660      int *delete_outer;
2661 {
2662   rtx start = insn;
2663
2664   /* Assume we can delete the region.  */
2665   int delete = 1;
2666
2667   /* Can't delete something which is rethrown to. */
2668   if (rethrow_used (n))
2669     delete = 0;
2670
2671   if (insn == NULL_RTX
2672       || GET_CODE (insn) != NOTE
2673       || NOTE_LINE_NUMBER (insn) != NOTE_INSN_EH_REGION_BEG
2674       || NOTE_EH_HANDLER (insn) != n
2675       || delete_outer == NULL)
2676     abort ();
2677
2678   insn = NEXT_INSN (insn);
2679
2680   /* Look for the matching end.  */
2681   while (! (GET_CODE (insn) == NOTE
2682             && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END))
2683     {
2684       /* If anything can throw, we can't remove the region.  */
2685       if (delete && can_throw (insn))
2686         {
2687           delete = 0;
2688         }
2689
2690       /* Watch out for and handle nested regions.  */
2691       if (GET_CODE (insn) == NOTE
2692           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
2693         {
2694           insn = scan_region (insn, NOTE_EH_HANDLER (insn), &delete);
2695         }
2696
2697       insn = NEXT_INSN (insn);
2698     }
2699
2700   /* The _BEG/_END NOTEs must match and nest.  */
2701   if (NOTE_EH_HANDLER (insn) != n)
2702     abort ();
2703
2704   /* If anything in this exception region can throw, we can throw.  */
2705   if (! delete)
2706     *delete_outer = 0;
2707   else
2708     {
2709       /* Delete the start and end of the region.  */
2710       delete_insn (start);
2711       delete_insn (insn);
2712
2713 /* We no longer removed labels here, since flow will now remove any
2714    handler which cannot be called any more. */
2715
2716 #if 0
2717       /* Only do this part if we have built the exception handler
2718          labels.  */
2719       if (exception_handler_labels)
2720         {
2721           rtx x, *prev = &exception_handler_labels;
2722
2723           /* Find it in the list of handlers.  */
2724           for (x = exception_handler_labels; x; x = XEXP (x, 1))
2725             {
2726               rtx label = XEXP (x, 0);
2727               if (CODE_LABEL_NUMBER (label) == n)
2728                 {
2729                   /* If we are the last reference to the handler,
2730                      delete it.  */
2731                   if (--LABEL_NUSES (label) == 0)
2732                     delete_insn (label);
2733
2734                   if (optimize)
2735                     {
2736                       /* Remove it from the list of exception handler
2737                          labels, if we are optimizing.  If we are not, then
2738                          leave it in the list, as we are not really going to
2739                          remove the region.  */
2740                       *prev = XEXP (x, 1);
2741                       XEXP (x, 1) = 0;
2742                       XEXP (x, 0) = 0;
2743                     }
2744
2745                   break;
2746                 }
2747               prev = &XEXP (x, 1);
2748             }
2749         }
2750 #endif
2751     }
2752   return insn;
2753 }
2754
2755 /* Perform various interesting optimizations for exception handling
2756    code.
2757
2758    We look for empty exception regions and make them go (away). The
2759    jump optimization code will remove the handler if nothing else uses
2760    it.  */
2761
2762 void
2763 exception_optimize ()
2764 {
2765   rtx insn;
2766   int n;
2767
2768   /* Remove empty regions.  */
2769   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2770     {
2771       if (GET_CODE (insn) == NOTE
2772           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
2773         {
2774           /* Since scan_region will return the NOTE_INSN_EH_REGION_END
2775              insn, we will indirectly skip through all the insns
2776              inbetween. We are also guaranteed that the value of insn
2777              returned will be valid, as otherwise scan_region won't
2778              return.  */
2779           insn = scan_region (insn, NOTE_EH_HANDLER (insn), &n);
2780         }
2781     }
2782 }
2783
2784 /* This function determines whether any of the exception regions in the
2785    current function are targets of a rethrow or not, and set the
2786    reference flag according.  */
2787 void
2788 update_rethrow_references ()
2789 {
2790   rtx insn;
2791   int x, region;
2792   int *saw_region, *saw_rethrow;
2793
2794   if (!flag_new_exceptions)
2795     return;
2796
2797   saw_region = (int *) xcalloc (current_func_eh_entry, sizeof (int));
2798   saw_rethrow = (int *) xcalloc (current_func_eh_entry, sizeof (int));
2799
2800   /* Determine what regions exist, and whether there are any rethrows
2801      to those regions or not.  */
2802   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2803     if (GET_CODE (insn) == CALL_INSN)
2804       {
2805         rtx note = find_reg_note (insn, REG_EH_RETHROW, NULL_RTX);
2806         if (note)
2807           {
2808             region = eh_region_from_symbol (XEXP (note, 0));
2809             region = find_func_region  (region);
2810             saw_rethrow[region] = 1;
2811           }
2812       }
2813     else
2814       if (GET_CODE (insn) == NOTE)
2815         {
2816           if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
2817             {
2818               region = find_func_region (NOTE_EH_HANDLER (insn));
2819               saw_region[region] = 1;
2820             }
2821         }
2822
2823   /* For any regions we did see, set the referenced flag.  */
2824   for (x = 0; x < current_func_eh_entry; x++)
2825     if (saw_region[x])
2826       function_eh_regions[x].rethrow_ref = saw_rethrow[x];
2827
2828   /* Clean up.  */
2829   free (saw_region);
2830   free (saw_rethrow);
2831 }
2832 \f
2833 /* Various hooks for the DWARF 2 __throw routine.  */
2834
2835 /* Do any necessary initialization to access arbitrary stack frames.
2836    On the SPARC, this means flushing the register windows.  */
2837
2838 void
2839 expand_builtin_unwind_init ()
2840 {
2841   /* Set this so all the registers get saved in our frame; we need to be
2842      able to copy the saved values for any registers from frames we unwind. */
2843   current_function_has_nonlocal_label = 1;
2844
2845 #ifdef SETUP_FRAME_ADDRESSES
2846   SETUP_FRAME_ADDRESSES ();
2847 #endif
2848 }
2849
2850 /* Given a value extracted from the return address register or stack slot,
2851    return the actual address encoded in that value.  */
2852
2853 rtx
2854 expand_builtin_extract_return_addr (addr_tree)
2855      tree addr_tree;
2856 {
2857   rtx addr = expand_expr (addr_tree, NULL_RTX, Pmode, 0);
2858   return eh_outer_context (addr);
2859 }
2860
2861 /* Given an actual address in addr_tree, do any necessary encoding
2862    and return the value to be stored in the return address register or
2863    stack slot so the epilogue will return to that address.  */
2864
2865 rtx
2866 expand_builtin_frob_return_addr (addr_tree)
2867      tree addr_tree;
2868 {
2869   rtx addr = expand_expr (addr_tree, NULL_RTX, Pmode, 0);
2870 #ifdef RETURN_ADDR_OFFSET
2871   addr = plus_constant (addr, -RETURN_ADDR_OFFSET);
2872 #endif
2873   return addr;
2874 }
2875
2876 /* Choose three registers for communication between the main body of
2877    __throw and the epilogue (or eh stub) and the exception handler.
2878    We must do this with hard registers because the epilogue itself
2879    will be generated after reload, at which point we may not reference
2880    pseudos at all.
2881
2882    The first passes the exception context to the handler.  For this
2883    we use the return value register for a void*.
2884
2885    The second holds the stack pointer value to be restored.  For
2886    this we use the static chain register if it exists and is different
2887    from the previous, otherwise some arbitrary call-clobbered register.
2888
2889    The third holds the address of the handler itself.  Here we use
2890    some arbitrary call-clobbered register.  */
2891
2892 static void
2893 eh_regs (pcontext, psp, pra, outgoing)
2894      rtx *pcontext, *psp, *pra;
2895      int outgoing ATTRIBUTE_UNUSED;
2896 {
2897   rtx rcontext, rsp, rra;
2898   int i;
2899
2900 #ifdef FUNCTION_OUTGOING_VALUE
2901   if (outgoing)
2902     rcontext = FUNCTION_OUTGOING_VALUE (build_pointer_type (void_type_node),
2903                                         current_function_decl);
2904   else
2905 #endif
2906     rcontext = FUNCTION_VALUE (build_pointer_type (void_type_node),
2907                                current_function_decl);
2908
2909 #ifdef STATIC_CHAIN_REGNUM
2910   if (outgoing)
2911     rsp = static_chain_incoming_rtx;
2912   else
2913     rsp = static_chain_rtx;
2914   if (REGNO (rsp) == REGNO (rcontext))
2915 #endif /* STATIC_CHAIN_REGNUM */
2916     rsp = NULL_RTX;
2917
2918   if (rsp == NULL_RTX)
2919     {
2920       for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
2921         if (call_used_regs[i] && ! fixed_regs[i] && i != REGNO (rcontext))
2922           break;
2923       if (i == FIRST_PSEUDO_REGISTER)
2924         abort();
2925
2926       rsp = gen_rtx_REG (Pmode, i);
2927     }
2928
2929   for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
2930     if (call_used_regs[i] && ! fixed_regs[i]
2931         && i != REGNO (rcontext) && i != REGNO (rsp))
2932       break;
2933   if (i == FIRST_PSEUDO_REGISTER)
2934     abort();
2935
2936   rra = gen_rtx_REG (Pmode, i);
2937
2938   *pcontext = rcontext;
2939   *psp = rsp;
2940   *pra = rra;
2941 }
2942
2943 /* Retrieve the register which contains the pointer to the eh_context
2944    structure set the __throw. */
2945
2946 #if 0
2947 rtx
2948 get_reg_for_handler ()
2949 {
2950   rtx reg1;
2951   reg1 = FUNCTION_VALUE (build_pointer_type (void_type_node),
2952                            current_function_decl);
2953   return reg1;
2954 }
2955 #endif
2956
2957 /* Set up the epilogue with the magic bits we'll need to return to the
2958    exception handler.  */
2959
2960 void
2961 expand_builtin_eh_return (context, stack, handler)
2962     tree context, stack, handler;
2963 {
2964   if (eh_return_context)
2965     error("Duplicate call to __builtin_eh_return");
2966
2967   eh_return_context
2968     = copy_to_reg (expand_expr (context, NULL_RTX, VOIDmode, 0));
2969   eh_return_stack_adjust
2970     = copy_to_reg (expand_expr (stack, NULL_RTX, VOIDmode, 0));
2971   eh_return_handler
2972     = copy_to_reg (expand_expr (handler, NULL_RTX, VOIDmode, 0));
2973 }
2974
2975 void
2976 expand_eh_return ()
2977 {
2978   rtx reg1, reg2, reg3;
2979   rtx stub_start, after_stub;
2980   rtx ra, tmp;
2981
2982   if (!eh_return_context)
2983     return;
2984
2985   current_function_cannot_inline = N_("function uses __builtin_eh_return");
2986
2987   eh_regs (&reg1, &reg2, &reg3, 1);
2988 #ifdef POINTERS_EXTEND_UNSIGNED
2989   eh_return_context = convert_memory_address (Pmode, eh_return_context);
2990   eh_return_stack_adjust =
2991       convert_memory_address (Pmode, eh_return_stack_adjust);
2992   eh_return_handler = convert_memory_address (Pmode, eh_return_handler);
2993 #endif
2994   emit_move_insn (reg1, eh_return_context);
2995   emit_move_insn (reg2, eh_return_stack_adjust);
2996   emit_move_insn (reg3, eh_return_handler);
2997
2998   /* Talk directly to the target's epilogue code when possible.  */
2999
3000 #ifdef HAVE_eh_epilogue
3001   if (HAVE_eh_epilogue)
3002     {
3003       emit_insn (gen_eh_epilogue (reg1, reg2, reg3));
3004       return;
3005     }
3006 #endif
3007
3008   /* Otherwise, use the same stub technique we had before.  */
3009
3010   eh_return_stub_label = stub_start = gen_label_rtx ();
3011   after_stub = gen_label_rtx ();
3012
3013   /* Set the return address to the stub label.  */
3014
3015   ra = expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
3016                                    0, hard_frame_pointer_rtx);
3017   if (GET_CODE (ra) == REG && REGNO (ra) >= FIRST_PSEUDO_REGISTER)
3018     abort();
3019
3020   tmp = memory_address (Pmode, gen_rtx_LABEL_REF (Pmode, stub_start));
3021 #ifdef RETURN_ADDR_OFFSET
3022   tmp = plus_constant (tmp, -RETURN_ADDR_OFFSET);
3023 #endif
3024   tmp = force_operand (tmp, ra);
3025   if (tmp != ra)
3026     emit_move_insn (ra, tmp);
3027
3028   /* Indicate that the registers are in fact used.  */
3029   emit_insn (gen_rtx_USE (VOIDmode, reg1));
3030   emit_insn (gen_rtx_USE (VOIDmode, reg2));
3031   emit_insn (gen_rtx_USE (VOIDmode, reg3));
3032   if (GET_CODE (ra) == REG)
3033     emit_insn (gen_rtx_USE (VOIDmode, ra));
3034
3035   /* Generate the stub.  */
3036
3037   emit_jump (after_stub);
3038   emit_label (stub_start);
3039
3040   eh_regs (&reg1, &reg2, &reg3, 0);
3041   adjust_stack (reg2);
3042   emit_indirect_jump (reg3);
3043
3044   emit_label (after_stub);
3045 }
3046 \f
3047
3048 /* This contains the code required to verify whether arbitrary instructions
3049    are in the same exception region. */
3050
3051 static int *insn_eh_region = (int *)0;
3052 static int maximum_uid;
3053
3054 static void
3055 set_insn_eh_region (first, region_num)
3056      rtx *first;
3057      int region_num;
3058 {
3059   rtx insn;
3060   int rnum;
3061
3062   for (insn = *first; insn; insn = NEXT_INSN (insn))
3063     {
3064       if ((GET_CODE (insn) == NOTE)
3065           && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG))
3066         {
3067           rnum = NOTE_EH_HANDLER (insn);
3068           insn_eh_region[INSN_UID (insn)] =  rnum;
3069           insn = NEXT_INSN (insn);
3070           set_insn_eh_region (&insn, rnum);
3071           /* Upon return, insn points to the EH_REGION_END of nested region */
3072           continue;
3073         }
3074       insn_eh_region[INSN_UID (insn)] = region_num;
3075       if ((GET_CODE (insn) == NOTE) &&
3076             (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END))
3077         break;
3078     }
3079   *first = insn;
3080 }
3081
3082 /* Free the insn table, an make sure it cannot be used again. */
3083
3084 void
3085 free_insn_eh_region ()
3086 {
3087   if (!doing_eh (0))
3088     return;
3089
3090   if (insn_eh_region)
3091     {
3092       free (insn_eh_region);
3093       insn_eh_region = (int *)0;
3094     }
3095 }
3096
3097 /* Initialize the table. max_uid must be calculated and handed into
3098    this routine. If it is unavailable, passing a value of 0 will
3099    cause this routine to calculate it as well. */
3100
3101 void
3102 init_insn_eh_region (first, max_uid)
3103      rtx first;
3104      int max_uid;
3105 {
3106   rtx insn;
3107
3108   if (!doing_eh (0))
3109     return;
3110
3111   if (insn_eh_region)
3112     free_insn_eh_region();
3113
3114   if (max_uid == 0)
3115     for (insn = first; insn; insn = NEXT_INSN (insn))
3116       if (INSN_UID (insn) > max_uid)       /* find largest UID */
3117         max_uid = INSN_UID (insn);
3118
3119   maximum_uid = max_uid;
3120   insn_eh_region = (int *) xmalloc ((max_uid + 1) * sizeof (int));
3121   insn = first;
3122   set_insn_eh_region (&insn, 0);
3123 }
3124
3125
3126 /* Check whether 2 instructions are within the same region. */
3127
3128 int
3129 in_same_eh_region (insn1, insn2)
3130      rtx insn1, insn2;
3131 {
3132   int ret, uid1, uid2;
3133
3134   /* If no exceptions, instructions are always in same region. */
3135   if (!doing_eh (0))
3136     return 1;
3137
3138   /* If the table isn't allocated, assume the worst. */
3139   if (!insn_eh_region)
3140     return 0;
3141
3142   uid1 = INSN_UID (insn1);
3143   uid2 = INSN_UID (insn2);
3144
3145   /* if instructions have been allocated beyond the end, either
3146      the table is out of date, or this is a late addition, or
3147      something... Assume the worst. */
3148   if (uid1 > maximum_uid || uid2 > maximum_uid)
3149     return 0;
3150
3151   ret = (insn_eh_region[uid1] == insn_eh_region[uid2]);
3152   return ret;
3153 }
3154 \f
3155
3156 /* This function will initialize the handler list for a specified block.
3157    It may recursively call itself if the outer block hasn't been processed
3158    yet.  At some point in the future we can trim out handlers which we
3159    know cannot be called. (ie, if a block has an INT type handler,
3160    control will never be passed to an outer INT type handler).  */
3161 static void
3162 process_nestinfo (block, info, nested_eh_region)
3163      int block;
3164      eh_nesting_info *info;
3165      int *nested_eh_region;
3166 {
3167   handler_info *ptr, *last_ptr = NULL;
3168   int x, y, count = 0;
3169   int extra = 0;
3170   handler_info **extra_handlers = 0;
3171   int index = info->region_index[block];
3172
3173   /* If we've already processed this block, simply return. */
3174   if (info->num_handlers[index] > 0)
3175     return;
3176
3177   for (ptr = get_first_handler (block); ptr; last_ptr = ptr, ptr = ptr->next)
3178     count++;
3179
3180  /* pick up any information from the next outer region.  It will already
3181     contain a summary of itself and all outer regions to it.  */
3182
3183   if (nested_eh_region [block] != 0)
3184     {
3185       int nested_index = info->region_index[nested_eh_region[block]];
3186       process_nestinfo (nested_eh_region[block], info, nested_eh_region);
3187       extra = info->num_handlers[nested_index];
3188       extra_handlers = info->handlers[nested_index];
3189       info->outer_index[index] = nested_index;
3190     }
3191
3192   /* If the last handler is either a CATCH_ALL or a cleanup, then we
3193      won't use the outer ones since we know control will not go past the
3194      catch-all or cleanup.  */
3195
3196   if (last_ptr != NULL && (last_ptr->type_info == NULL
3197                            || last_ptr->type_info == CATCH_ALL_TYPE))
3198     extra = 0;
3199
3200   info->num_handlers[index] = count + extra;
3201   info->handlers[index] = (handler_info **) xmalloc ((count + extra)
3202                                                     * sizeof (handler_info **));
3203
3204   /* First put all our handlers into the list.  */
3205   ptr = get_first_handler (block);
3206   for (x = 0; x < count; x++)
3207     {
3208       info->handlers[index][x] = ptr;
3209       ptr = ptr->next;
3210     }
3211
3212   /* Now add all the outer region handlers, if they aren't they same as
3213      one of the types in the current block.  We won't worry about
3214      derived types yet, we'll just look for the exact type.  */
3215   for (y =0, x = 0; x < extra ; x++)
3216     {
3217       int i, ok;
3218       ok = 1;
3219       /* Check to see if we have a type duplication.  */
3220       for (i = 0; i < count; i++)
3221         if (info->handlers[index][i]->type_info == extra_handlers[x]->type_info)
3222           {
3223             ok = 0;
3224             /* Record one less handler.  */
3225             (info->num_handlers[index])--;
3226             break;
3227           }
3228       if (ok)
3229         {
3230           info->handlers[index][y + count] = extra_handlers[x];
3231           y++;
3232         }
3233     }
3234 }
3235
3236 /* This function will allocate and initialize an eh_nesting_info structure.
3237    It returns a pointer to the completed data structure.  If there are
3238    no exception regions, a NULL value is returned.  */
3239 eh_nesting_info *
3240 init_eh_nesting_info ()
3241 {
3242   int *nested_eh_region;
3243   int region_count = 0;
3244   rtx eh_note = NULL_RTX;
3245   eh_nesting_info *info;
3246   rtx insn;
3247   int x;
3248
3249   info = (eh_nesting_info *) xmalloc (sizeof (eh_nesting_info));
3250   info->region_index = (int *) xcalloc ((max_label_num () + 1), sizeof (int));
3251   nested_eh_region = (int *) xcalloc (max_label_num () + 1, sizeof (int));
3252
3253   /* Create the nested_eh_region list.  If indexed with a block number, it
3254      returns the block number of the next outermost region, if any.
3255      We can count the number of regions and initialize the region_index
3256      vector at the same time.  */
3257   for (insn = get_insns(); insn; insn = NEXT_INSN (insn))
3258     {
3259       if (GET_CODE (insn) == NOTE)
3260         {
3261           if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
3262             {
3263               int block = NOTE_EH_HANDLER (insn);
3264               region_count++;
3265               info->region_index[block] = region_count;
3266               if (eh_note)
3267                 nested_eh_region [block] =
3268                                      NOTE_EH_HANDLER (XEXP (eh_note, 0));
3269               else
3270                 nested_eh_region [block] = 0;
3271               eh_note = gen_rtx_EXPR_LIST (VOIDmode, insn, eh_note);
3272             }
3273           else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END)
3274             eh_note = XEXP (eh_note, 1);
3275         }
3276     }
3277
3278   /* If there are no regions, wrap it up now.  */
3279   if (region_count == 0)
3280     {
3281       free (info->region_index);
3282       free (info);
3283       free (nested_eh_region);
3284       return NULL;
3285     }
3286
3287   region_count++;
3288   info->handlers = (handler_info ***) xcalloc (region_count,
3289                                                sizeof (handler_info ***));
3290   info->num_handlers = (int *) xcalloc (region_count, sizeof (int));
3291   info->outer_index = (int *) xcalloc (region_count, sizeof (int));
3292
3293  /* Now initialize the handler lists for all exception blocks.  */
3294   for (x = 0; x <= max_label_num (); x++)
3295     {
3296       if (info->region_index[x] != 0)
3297         process_nestinfo (x, info, nested_eh_region);
3298     }
3299   info->region_count = region_count;
3300
3301   /* Clean up.  */
3302   free (nested_eh_region);
3303
3304   return info;
3305 }
3306
3307
3308 /* This function is used to retreive the vector of handlers which
3309    can be reached by a given insn in a given exception region.
3310    BLOCK is the exception block the insn is in.
3311    INFO is the eh_nesting_info structure.
3312    INSN is the (optional) insn within the block.  If insn is not NULL_RTX,
3313    it may contain reg notes which modify its throwing behavior, and
3314    these will be obeyed.  If NULL_RTX is passed, then we simply return the
3315    handlers for block.
3316    HANDLERS is the address of a pointer to a vector of handler_info pointers.
3317    Upon return, this will have the handlers which can be reached by block.
3318    This function returns the number of elements in the handlers vector.  */
3319 int
3320 reachable_handlers (block, info, insn, handlers)
3321      int block;
3322      eh_nesting_info *info;
3323      rtx insn ;
3324      handler_info ***handlers;
3325 {
3326   int index = 0;
3327   *handlers = NULL;
3328
3329   if (info == NULL)
3330     return 0;
3331   if (block > 0)
3332     index = info->region_index[block];
3333
3334   if (insn && GET_CODE (insn) == CALL_INSN)
3335     {
3336       /* RETHROWs specify a region number from which we are going to rethrow.
3337          This means we wont pass control to handlers in the specified
3338          region, but rather any region OUTSIDE the specified region.
3339          We accomplish this by setting block to the outer_index of the
3340          specified region.  */
3341       rtx note = find_reg_note (insn, REG_EH_RETHROW, NULL_RTX);
3342       if (note)
3343         {
3344           index = eh_region_from_symbol (XEXP (note, 0));
3345           index = info->region_index[index];
3346           if (index)
3347             index = info->outer_index[index];
3348         }
3349       else
3350         {
3351           /* If there is no rethrow, we look for a REG_EH_REGION, and
3352              we'll throw from that block.  A value of 0 or less
3353              indicates that this insn cannot throw.  */
3354           note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
3355           if (note)
3356             {
3357               int b = XINT (XEXP (note, 0), 0);
3358               if (b <= 0)
3359                 index = 0;
3360               else
3361                 index = info->region_index[b];
3362             }
3363         }
3364     }
3365   /* If we reach this point, and index is 0, there is no throw.  */
3366   if (index == 0)
3367     return 0;
3368
3369   *handlers = info->handlers[index];
3370   return info->num_handlers[index];
3371 }
3372
3373
3374 /* This function will free all memory associated with the eh_nesting info.  */
3375
3376 void
3377 free_eh_nesting_info (info)
3378      eh_nesting_info *info;
3379 {
3380   int x;
3381   if (info != NULL)
3382     {
3383       if (info->region_index)
3384         free (info->region_index);
3385       if (info->num_handlers)
3386         free (info->num_handlers);
3387       if (info->outer_index)
3388         free (info->outer_index);
3389       if (info->handlers)
3390         {
3391           for (x = 0; x < info->region_count; x++)
3392             if (info->handlers[x])
3393               free (info->handlers[x]);
3394           free (info->handlers);
3395         }
3396       free (info);
3397     }
3398 }