gcc/except.c

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