gcc/except.c

   1 /* Implements exception handling.
   2    Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000 Free Software Foundation, Inc.
   4    Contributed by Mike Stump <mrs@cygnus.com>.
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23
  24 /* An exception is an event that can be signaled from within a
  25    function. This event can then be "caught" or "trapped" by the
  26    callers of this function. This potentially allows program flow to
  27    be transferred to any arbitrary code associated with a function call
  28    several levels up the stack.
  29
  30    The intended use for this mechanism is for signaling "exceptional
  31    events" in an out-of-band fashion, hence its name. The C++ language
  32    (and many other OO-styled or functional languages) practically
  33    requires such a mechanism, as otherwise it becomes very difficult
  34    or even impossible to signal failure conditions in complex
  35    situations.  The traditional C++ example is when an error occurs in
  36    the process of constructing an object; without such a mechanism, it
  37    is impossible to signal that the error occurs without adding global
  38    state variables and error checks around every object construction.
  39
  40    The act of causing this event to occur is referred to as "throwing
  41    an exception". (Alternate terms include "raising an exception" or
  42    "signaling an exception".) The term "throw" is used because control
  43    is returned to the callers of the function that is signaling the
  44    exception, and thus there is the concept of "throwing" the
  45    exception up the call stack.
  46
  47    There are two major codegen options for exception handling.  The
  48    flag -fsjlj-exceptions can be used to select the setjmp/longjmp
  49    approach, which is the default.  -fno-sjlj-exceptions can be used to
  50    get the PC range table approach.  While this is a compile time
  51    flag, an entire application must be compiled with the same codegen
  52    option.  The first is a PC range table approach, the second is a
  53    setjmp/longjmp based scheme.  We will first discuss the PC range
  54    table approach, after that, we will discuss the setjmp/longjmp
  55    based approach.
  56
  57    It is appropriate to speak of the "context of a throw". This
  58    context refers to the address where the exception is thrown from,
  59    and is used to determine which exception region will handle the
  60    exception.
  61
  62    Regions of code within a function can be marked such that if it
  63    contains the context of a throw, control will be passed to a
  64    designated "exception handler". These areas are known as "exception
  65    regions".  Exception regions cannot overlap, but they can be nested
  66    to any arbitrary depth. Also, exception regions cannot cross
  67    function boundaries.
  68
  69    Exception handlers can either be specified by the user (which we
  70    will call a "user-defined handler") or generated by the compiler
  71    (which we will designate as a "cleanup"). Cleanups are used to
  72    perform tasks such as destruction of objects allocated on the
  73    stack.
  74
  75    In the current implementation, cleanups are handled by allocating an
  76    exception region for the area that the cleanup is designated for,
  77    and the handler for the region performs the cleanup and then
  78    rethrows the exception to the outer exception region. From the
  79    standpoint of the current implementation, there is little
  80    distinction made between a cleanup and a user-defined handler, and
  81    the phrase "exception handler" can be used to refer to either one
  82    equally well. (The section "Future Directions" below discusses how
  83    this will change).
  84
  85    Each object file that is compiled with exception handling contains
  86    a static array of exception handlers named __EXCEPTION_TABLE__.
  87    Each entry contains the starting and ending addresses of the
  88    exception region, and the address of the handler designated for
  89    that region.
  90
  91    If the target does not use the DWARF 2 frame unwind information, at
  92    program startup each object file invokes a function named
  93    __register_exceptions with the address of its local
  94    __EXCEPTION_TABLE__. __register_exceptions is defined in libgcc2.c, and
  95    is responsible for recording all of the exception regions into one list
  96    (which is kept in a static variable named exception_table_list).
  97
  98    On targets that support crtstuff.c, the unwind information
  99    is stored in a section named .eh_frame and the information for the
 100    entire shared object or program is registered with a call to
 101    __register_frame_info.  On other targets, the information for each
 102    translation unit is registered from the file generated by collect2.
 103    __register_frame_info is defined in frame.c, and is responsible for
 104    recording all of the unwind regions into one list (which is kept in a
 105    static variable named unwind_table_list).
 106
 107    The function __throw is actually responsible for doing the
 108    throw. On machines that have unwind info support, __throw is generated
 109    by code in libgcc2.c, otherwise __throw is generated on a
 110    per-object-file basis for each source file compiled with
 111    -fexceptions by the C++ frontend.  Before __throw is invoked,
 112    the current context of the throw needs to be placed in the global
 113    variable __eh_pc.
 114
 115    __throw attempts to find the appropriate exception handler for the
 116    PC value stored in __eh_pc by calling __find_first_exception_table_match
 117    (which is defined in libgcc2.c). If __find_first_exception_table_match
 118    finds a relevant handler, __throw transfers control directly to it.
 119
 120    If a handler for the context being thrown from can't be found, __throw
 121    walks (see Walking the stack below) the stack up the dynamic call chain to
 122    continue searching for an appropriate exception handler based upon the
 123    caller of the function it last sought a exception handler for.  It stops
 124    then either an exception handler is found, or when the top of the
 125    call chain is reached.
 126
 127    If no handler is found, an external library function named
 128    __terminate is called.  If a handler is found, then we restart
 129    our search for a handler at the end of the call chain, and repeat
 130    the search process, but instead of just walking up the call chain,
 131    we unwind the call chain as we walk up it.
 132
 133    Internal implementation details:
 134
 135    To associate a user-defined handler with a block of statements, the
 136    function expand_start_try_stmts is used to mark the start of the
 137    block of statements with which the handler is to be associated
 138    (which is known as a "try block"). All statements that appear
 139    afterwards will be associated with the try block.
 140
 141    A call to expand_start_all_catch marks the end of the try block,
 142    and also marks the start of the "catch block" (the user-defined
 143    handler) associated with the try block.
 144
 145    This user-defined handler will be invoked for *every* exception
 146    thrown with the context of the try block. It is up to the handler
 147    to decide whether or not it wishes to handle any given exception,
 148    as there is currently no mechanism in this implementation for doing
 149    this. (There are plans for conditionally processing an exception
 150    based on its "type", which will provide a language-independent
 151    mechanism).
 152
 153    If the handler chooses not to process the exception (perhaps by
 154    looking at an "exception type" or some other additional data
 155    supplied with the exception), it can fall through to the end of the
 156    handler. expand_end_all_catch and expand_leftover_cleanups
 157    add additional code to the end of each handler to take care of
 158    rethrowing to the outer exception handler.
 159
 160    The handler also has the option to continue with "normal flow of
 161    code", or in other words to resume executing at the statement
 162    immediately after the end of the exception region. The variable
 163    caught_return_label_stack contains a stack of labels, and jumping
 164    to the topmost entry's label via expand_goto will resume normal
 165    flow to the statement immediately after the end of the exception
 166    region. If the handler falls through to the end, the exception will
 167    be rethrown to the outer exception region.
 168
 169    The instructions for the catch block are kept as a separate
 170    sequence, and will be emitted at the end of the function along with
 171    the handlers specified via expand_eh_region_end. The end of the
 172    catch block is marked with expand_end_all_catch.
 173
 174    Any data associated with the exception must currently be handled by
 175    some external mechanism maintained in the frontend.  For example,
 176    the C++ exception mechanism passes an arbitrary value along with
 177    the exception, and this is handled in the C++ frontend by using a
 178    global variable to hold the value. (This will be changing in the
 179    future.)
 180
 181    The mechanism in C++ for handling data associated with the
 182    exception is clearly not thread-safe. For a thread-based
 183    environment, another mechanism must be used (possibly using a
 184    per-thread allocation mechanism if the size of the area that needs
 185    to be allocated isn't known at compile time.)
 186
 187    Internally-generated exception regions (cleanups) are marked by
 188    calling expand_eh_region_start to mark the start of the region,
 189    and expand_eh_region_end (handler) is used to both designate the
 190    end of the region and to associate a specified handler/cleanup with
 191    the region. The rtl code in HANDLER will be invoked whenever an
 192    exception occurs in the region between the calls to
 193    expand_eh_region_start and expand_eh_region_end. After HANDLER is
 194    executed, additional code is emitted to handle rethrowing the
 195    exception to the outer exception handler. The code for HANDLER will
 196    be emitted at the end of the function.
 197
 198    TARGET_EXPRs can also be used to designate exception regions. A
 199    TARGET_EXPR gives an unwind-protect style interface commonly used
 200    in functional languages such as LISP. The associated expression is
 201    evaluated, and whether or not it (or any of the functions that it
 202    calls) throws an exception, the protect expression is always
 203    invoked. This implementation takes care of the details of
 204    associating an exception table entry with the expression and
 205    generating the necessary code (it actually emits the protect
 206    expression twice, once for normal flow and once for the exception
 207    case). As for the other handlers, the code for the exception case
 208    will be emitted at the end of the function.
 209
 210    Cleanups can also be specified by using add_partial_entry (handler)
 211    and end_protect_partials. add_partial_entry creates the start of
 212    a new exception region; HANDLER will be invoked if an exception is
 213    thrown with the context of the region between the calls to
 214    add_partial_entry and end_protect_partials. end_protect_partials is
 215    used to mark the end of these regions. add_partial_entry can be
 216    called as many times as needed before calling end_protect_partials.
 217    However, end_protect_partials should only be invoked once for each
 218    group of calls to add_partial_entry as the entries are queued
 219    and all of the outstanding entries are processed simultaneously
 220    when end_protect_partials is invoked. Similarly to the other
 221    handlers, the code for HANDLER will be emitted at the end of the
 222    function.
 223
 224    The generated RTL for an exception region includes
 225    NOTE_INSN_EH_REGION_BEG and NOTE_INSN_EH_REGION_END notes that mark
 226    the start and end of the exception region. A unique label is also
 227    generated at the start of the exception region, which is available
 228    by looking at the ehstack variable. The topmost entry corresponds
 229    to the current region.
 230
 231    In the current implementation, an exception can only be thrown from
 232    a function call (since the mechanism used to actually throw an
 233    exception involves calling __throw).  If an exception region is
 234    created but no function calls occur within that region, the region
 235    can be safely optimized away (along with its exception handlers)
 236    since no exceptions can ever be caught in that region.  This
 237    optimization is performed unless -fasynchronous-exceptions is
 238    given.  If the user wishes to throw from a signal handler, or other
 239    asynchronous place, -fasynchronous-exceptions should be used when
 240    compiling for maximally correct code, at the cost of additional
 241    exception regions.  Using -fasynchronous-exceptions only produces
 242    code that is reasonably safe in such situations, but a correct
 243    program cannot rely upon this working.  It can be used in failsafe
 244    code, where trying to continue on, and proceeding with potentially
 245    incorrect results is better than halting the program.
 246
 247
 248    Walking the stack:
 249
 250    The stack is walked by starting with a pointer to the current
 251    frame, and finding the pointer to the callers frame.  The unwind info
 252    tells __throw how to find it.
 253
 254    Unwinding the stack:
 255
 256    When we use the term unwinding the stack, we mean undoing the
 257    effects of the function prologue in a controlled fashion so that we
 258    still have the flow of control.  Otherwise, we could just return
 259    (jump to the normal end of function epilogue).
 260
 261    This is done in __throw in libgcc2.c when we know that a handler exists
 262    in a frame higher up the call stack than its immediate caller.
 263
 264    To unwind, we find the unwind data associated with the frame, if any.
 265    If we don't find any, we call the library routine __terminate.  If we do
 266    find it, we use the information to copy the saved register values from
 267    that frame into the register save area in the frame for __throw, return
 268    into a stub which updates the stack pointer, and jump to the handler.
 269    The normal function epilogue for __throw handles restoring the saved
 270    values into registers.
 271
 272    When unwinding, we use this method if we know it will
 273    work (if DWARF2_UNWIND_INFO is defined).  Otherwise, we know that
 274    an inline unwinder will have been emitted for any function that
 275    __unwind_function cannot unwind.  The inline unwinder appears as a
 276    normal exception handler for the entire function, for any function
 277    that we know cannot be unwound by __unwind_function.  We inform the
 278    compiler of whether a function can be unwound with
 279    __unwind_function by having DOESNT_NEED_UNWINDER evaluate to true
 280    when the unwinder isn't needed.  __unwind_function is used as an
 281    action of last resort.  If no other method can be used for
 282    unwinding, __unwind_function is used.  If it cannot unwind, it
 283    should call __terminate.
 284
 285    By default, if the target-specific backend doesn't supply a definition
 286    for __unwind_function and doesn't support DWARF2_UNWIND_INFO, inlined
 287    unwinders will be used instead. The main tradeoff here is in text space
 288    utilization.  Obviously, if inline unwinders have to be generated
 289    repeatedly, this uses much more space than if a single routine is used.
 290
 291    However, it is simply not possible on some platforms to write a
 292    generalized routine for doing stack unwinding without having some
 293    form of additional data associated with each function.  The current
 294    implementation can encode this data in the form of additional
 295    machine instructions or as static data in tabular form.  The later
 296    is called the unwind data.
 297
 298    The backend macro DOESNT_NEED_UNWINDER is used to conditionalize whether
 299    or not per-function unwinders are needed. If DOESNT_NEED_UNWINDER is
 300    defined and has a non-zero value, a per-function unwinder is not emitted
 301    for the current function.  If the static unwind data is supported, then
 302    a per-function unwinder is not emitted.
 303
 304    On some platforms it is possible that neither __unwind_function
 305    nor inlined unwinders are available. For these platforms it is not
 306    possible to throw through a function call, and abort will be
 307    invoked instead of performing the throw.
 308
 309    The reason the unwind data may be needed is that on some platforms
 310    the order and types of data stored on the stack can vary depending
 311    on the type of function, its arguments and returned values, and the
 312    compilation options used (optimization versus non-optimization,
 313    -fomit-frame-pointer, processor variations, etc).
 314
 315    Unfortunately, this also means that throwing through functions that
 316    aren't compiled with exception handling support will still not be
 317    possible on some platforms. This problem is currently being
 318    investigated, but no solutions have been found that do not imply
 319    some unacceptable performance penalties.
 320
 321    Future directions:
 322
 323    Currently __throw makes no differentiation between cleanups and
 324    user-defined exception regions. While this makes the implementation
 325    simple, it also implies that it is impossible to determine if a
 326    user-defined exception handler exists for a given exception without
 327    completely unwinding the stack in the process. This is undesirable
 328    from the standpoint of debugging, as ideally it would be possible
 329    to trap unhandled exceptions in the debugger before the process of
 330    unwinding has even started.
 331
 332    This problem can be solved by marking user-defined handlers in a
 333    special way (probably by adding additional bits to exception_table_list).
 334    A two-pass scheme could then be used by __throw to iterate
 335    through the table. The first pass would search for a relevant
 336    user-defined handler for the current context of the throw, and if
 337    one is found, the second pass would then invoke all needed cleanups
 338    before jumping to the user-defined handler.
 339
 340    Many languages (including C++ and Ada) make execution of a
 341    user-defined handler conditional on the "type" of the exception
 342    thrown. (The type of the exception is actually the type of the data
 343    that is thrown with the exception.) It will thus be necessary for
 344    __throw to be able to determine if a given user-defined
 345    exception handler will actually be executed, given the type of
 346    exception.
 347
 348    One scheme is to add additional information to exception_table_list
 349    as to the types of exceptions accepted by each handler. __throw
 350    can do the type comparisons and then determine if the handler is
 351    actually going to be executed.
 352
 353    There is currently no significant level of debugging support
 354    available, other than to place a breakpoint on __throw. While
 355    this is sufficient in most cases, it would be helpful to be able to
 356    know where a given exception was going to be thrown to before it is
 357    actually thrown, and to be able to choose between stopping before
 358    every exception region (including cleanups), or just user-defined
 359    exception regions. This should be possible to do in the two-pass
 360    scheme by adding additional labels to __throw for appropriate
 361    breakpoints, and additional debugger commands could be added to
 362    query various state variables to determine what actions are to be
 363    performed next.
 364
 365    Another major problem that is being worked on is the issue with stack
 366    unwinding on various platforms. Currently the only platforms that have
 367    support for the generation of a generic unwinder are the SPARC and MIPS.
 368    All other ports require per-function unwinders, which produce large
 369    amounts of code bloat.
 370
 371    For setjmp/longjmp based exception handling, some of the details
 372    are as above, but there are some additional details.  This section
 373    discusses the details.
 374
 375    We don't use NOTE_INSN_EH_REGION_{BEG,END} pairs.  We don't
 376    optimize EH regions yet.  We don't have to worry about machine
 377    specific issues with unwinding the stack, as we rely upon longjmp
 378    for all the machine specific details.  There is no variable context
 379    of a throw, just the one implied by the dynamic handler stack
 380    pointed to by the dynamic handler chain.  There is no exception
 381    table, and no calls to __register_exceptions.  __sjthrow is used
 382    instead of __throw, and it works by using the dynamic handler
 383    chain, and longjmp.  -fasynchronous-exceptions has no effect, as
 384    the elimination of trivial exception regions is not yet performed.
 385
 386    A frontend can set protect_cleanup_actions_with_terminate when all
 387    the cleanup actions should be protected with an EH region that
 388    calls terminate when an unhandled exception is throw.  C++ does
 389    this, Ada does not.  */
 390
 391
 392 #include "config.h"
 393 #include "defaults.h"
 394 #include "eh-common.h"
 395 #include "system.h"
 396 #include "rtl.h"
 397 #include "tree.h"
 398 #include "flags.h"
 399 #include "except.h"
 400 #include "function.h"
 401 #include "insn-flags.h"
 402 #include "expr.h"
 403 #include "insn-codes.h"
 404 #include "regs.h"
 405 #include "hard-reg-set.h"
 406 #include "insn-config.h"
 407 #include "recog.h"
 408 #include "output.h"
 409 #include "toplev.h"
 410 #include "intl.h"
 411 #include "obstack.h"
 412 #include "ggc.h"
 413 #include "tm_p.h"
 414
 415 /* One to use setjmp/longjmp method of generating code for exception
 416    handling.  */
 417
 418 int exceptions_via_longjmp = 2;
 419
 420 /* One to enable asynchronous exception support.  */
 421
 422 int asynchronous_exceptions = 0;
 423
 424 /* One to protect cleanup actions with a handler that calls
 425    __terminate, zero otherwise.  */
 426
 427 int protect_cleanup_actions_with_terminate;
 428
 429 /* A list of labels used for exception handlers.  Created by
 430    find_exception_handler_labels for the optimization passes.  */
 431
 432 rtx exception_handler_labels;
 433
 434 /* Keeps track of the label used as the context of a throw to rethrow an
 435    exception to the outer exception region.  */
 436
 437 struct label_node *outer_context_label_stack = NULL;
 438
 439 /* Pseudos used to hold exception return data in the interim between
 440    __builtin_eh_return and the end of the function.  */
 441
 442 static rtx eh_return_context;
 443 static rtx eh_return_stack_adjust;
 444 static rtx eh_return_handler;
 445
 446 /* This is used for targets which can call rethrow with an offset instead
 447    of an address. This is subtracted from the rethrow label we are
 448    interested in. */
 449
 450 static rtx first_rethrow_symbol = NULL_RTX;
 451 static rtx final_rethrow = NULL_RTX;
 452 static rtx last_rethrow_symbol = NULL_RTX;
 453
 454
 455 /* Prototypes for local functions.  */
 456
 457 static void push_eh_entry       PARAMS ((struct eh_stack *));
 458 static struct eh_entry * pop_eh_entry   PARAMS ((struct eh_stack *));
 459 static void enqueue_eh_entry    PARAMS ((struct eh_queue *, struct eh_entry *));
 460 static struct eh_entry * dequeue_eh_entry       PARAMS ((struct eh_queue *));
 461 static rtx call_get_eh_context  PARAMS ((void));
 462 static void start_dynamic_cleanup       PARAMS ((tree, tree));
 463 static void start_dynamic_handler       PARAMS ((void));
 464 static void expand_rethrow      PARAMS ((rtx));
 465 static void output_exception_table_entry        PARAMS ((FILE *, int));
 466 static rtx scan_region          PARAMS ((rtx, int, int *));
 467 static void eh_regs             PARAMS ((rtx *, rtx *, rtx *, int));
 468 static void set_insn_eh_region  PARAMS ((rtx *, int));
 469 #ifdef DONT_USE_BUILTIN_SETJMP
 470 static void jumpif_rtx          PARAMS ((rtx, rtx));
 471 #endif
 472 static void find_exception_handler_labels_1 PARAMS ((rtx));
 473 static void mark_eh_node        PARAMS ((struct eh_node *));
 474 static void mark_eh_stack       PARAMS ((struct eh_stack *));
 475 static void mark_eh_queue       PARAMS ((struct eh_queue *));
 476 static void mark_tree_label_node PARAMS ((struct label_node *));
 477 static void mark_func_eh_entry  PARAMS ((void *));
 478 static rtx create_rethrow_ref   PARAMS ((int));
 479 static void push_entry          PARAMS ((struct eh_stack *, struct eh_entry*));
 480 static void receive_exception_label PARAMS ((rtx));
 481 static int new_eh_region_entry  PARAMS ((int, rtx));
 482 static int find_func_region     PARAMS ((int));
 483 static int find_func_region_from_symbol PARAMS ((rtx));
 484 static void clear_function_eh_region PARAMS ((void));
 485 static void process_nestinfo    PARAMS ((int, eh_nesting_info *, int *));
 486 rtx expand_builtin_return_addr  PARAMS ((enum built_in_function, int, rtx));
 487 static void emit_cleanup_handler PARAMS ((struct eh_entry *));
 488 static int eh_region_from_symbol PARAMS ((rtx));
 489
 490 \f
 491 /* Various support routines to manipulate the various data structures
 492    used by the exception handling code.  */
 493
 494 extern struct obstack permanent_obstack;
 495
 496 /* Generate a SYMBOL_REF for rethrow to use */
 497
 498 static rtx
 499 create_rethrow_ref (region_num)
 500      int region_num;
 501 {
 502   rtx def;
 503   char *ptr;
 504   char buf[60];
 505
 506   push_obstacks_nochange ();
 507   end_temporary_allocation ();
 508
 509   ASM_GENERATE_INTERNAL_LABEL (buf, "LRTH", region_num);
 510   ptr = ggc_alloc_string (buf, -1);
 511   def = gen_rtx_SYMBOL_REF (Pmode, ptr);
 512   SYMBOL_REF_NEED_ADJUST (def) = 1;
 513
 514   pop_obstacks ();
 515   return def;
 516 }
 517
 518 /* Push a label entry onto the given STACK.  */
 519
 520 void
 521 push_label_entry (stack, rlabel, tlabel)
 522      struct label_node **stack;
 523      rtx rlabel;
 524      tree tlabel;
 525 {
 526   struct label_node *newnode
 527     = (struct label_node *) xmalloc (sizeof (struct label_node));
 528
 529   if (rlabel)
 530     newnode->u.rlabel = rlabel;
 531   else
 532     newnode->u.tlabel = tlabel;
 533   newnode->chain = *stack;
 534   *stack = newnode;
 535 }
 536
 537 /* Pop a label entry from the given STACK.  */
 538
 539 rtx
 540 pop_label_entry (stack)
 541      struct label_node **stack;
 542 {
 543   rtx label;
 544   struct label_node *tempnode;
 545
 546   if (! *stack)
 547     return NULL_RTX;
 548
 549   tempnode = *stack;
 550   label = tempnode->u.rlabel;
 551   *stack = (*stack)->chain;
 552   free (tempnode);
 553
 554   return label;
 555 }
 556
 557 /* Return the top element of the given STACK.  */
 558
 559 tree
 560 top_label_entry (stack)
 561      struct label_node **stack;
 562 {
 563   if (! *stack)
 564     return NULL_TREE;
 565
 566   return (*stack)->u.tlabel;
 567 }
 568
 569 /* Get an exception label.  */
 570
 571 rtx
 572 gen_exception_label ()
 573 {
 574   rtx lab;
 575   lab = gen_label_rtx ();
 576   return lab;
 577 }
 578
 579 /* Push a new eh_node entry onto STACK.  */
 580
 581 static void
 582 push_eh_entry (stack)
 583      struct eh_stack *stack;
 584 {
 585   struct eh_node *node = (struct eh_node *) xmalloc (sizeof (struct eh_node));
 586   struct eh_entry *entry = (struct eh_entry *) xmalloc (sizeof (struct eh_entry));
 587
 588   rtx rlab = gen_exception_label ();
 589   entry->finalization = NULL_TREE;
 590   entry->label_used = 0;
 591   entry->exception_handler_label = rlab;
 592   entry->false_label = NULL_RTX;
 593   if (! flag_new_exceptions)
 594     entry->outer_context = gen_label_rtx ();
 595   else
 596     entry->outer_context = create_rethrow_ref (CODE_LABEL_NUMBER (rlab));
 597   entry->rethrow_label = entry->outer_context;
 598   entry->goto_entry_p = 0;
 599
 600   node->entry = entry;
 601   node->chain = stack->top;
 602   stack->top = node;
 603 }
 604
 605 /* Push an existing entry onto a stack.  */
 606
 607 static void
 608 push_entry (stack, entry)
 609      struct eh_stack *stack;
 610      struct eh_entry *entry;
 611 {
 612   struct eh_node *node = (struct eh_node *) xmalloc (sizeof (struct eh_node));
 613   node->entry = entry;
 614   node->chain = stack->top;
 615   stack->top = node;
 616 }
 617
 618 /* Pop an entry from the given STACK.  */
 619
 620 static struct eh_entry *
 621 pop_eh_entry (stack)
 622      struct eh_stack *stack;
 623 {
 624   struct eh_node *tempnode;
 625   struct eh_entry *tempentry;
 626
 627   tempnode = stack->top;
 628   tempentry = tempnode->entry;
 629   stack->top = stack->top->chain;
 630   free (tempnode);
 631
 632   return tempentry;
 633 }
 634
 635 /* Enqueue an ENTRY onto the given QUEUE.  */
 636
 637 static void
 638 enqueue_eh_entry (queue, entry)
 639      struct eh_queue *queue;
 640      struct eh_entry *entry;
 641 {
 642   struct eh_node *node = (struct eh_node *) xmalloc (sizeof (struct eh_node));
 643
 644   node->entry = entry;
 645   node->chain = NULL;
 646
 647   if (queue->head == NULL)
 648     queue->head = node;
 649   else
 650     queue->tail->chain = node;
 651   queue->tail = node;
 652 }
 653
 654 /* Dequeue an entry from the given QUEUE.  */
 655
 656 static struct eh_entry *
 657 dequeue_eh_entry (queue)
 658      struct eh_queue *queue;
 659 {
 660   struct eh_node *tempnode;
 661   struct eh_entry *tempentry;
 662
 663   if (queue->head == NULL)
 664     return NULL;
 665
 666   tempnode = queue->head;
 667   queue->head = queue->head->chain;
 668
 669   tempentry = tempnode->entry;
 670   free (tempnode);
 671
 672   return tempentry;
 673 }
 674
 675 static void
 676 receive_exception_label (handler_label)
 677      rtx handler_label;
 678 {
 679   emit_label (handler_label);
 680
 681 #ifdef HAVE_exception_receiver
 682   if (! exceptions_via_longjmp)
 683     if (HAVE_exception_receiver)
 684       emit_insn (gen_exception_receiver ());
 685 #endif
 686
 687 #ifdef HAVE_nonlocal_goto_receiver
 688   if (! exceptions_via_longjmp)
 689     if (HAVE_nonlocal_goto_receiver)
 690       emit_insn (gen_nonlocal_goto_receiver ());
 691 #endif
 692 }
 693
 694
 695 struct func_eh_entry
 696 {
 697   int range_number;   /* EH region number from EH NOTE insn's.  */
 698   rtx rethrow_label;  /* Label for rethrow.  */
 699   int rethrow_ref;    /* Is rethrow_label referenced?  */
 700   int emitted;        /* 1 if this entry has been emitted in assembly file.  */
 701   struct handler_info *handlers;
 702 };
 703
 704
 705 /* table of function eh regions */
 706 static struct func_eh_entry *function_eh_regions = NULL;
 707 static int num_func_eh_entries = 0;
 708 static int current_func_eh_entry = 0;
 709
 710 #define SIZE_FUNC_EH(X)   (sizeof (struct func_eh_entry) * X)
 711
 712 /* Add a new eh_entry for this function.  The number returned is an
 713    number which uniquely identifies this exception range. */
 714
 715 static int
 716 new_eh_region_entry (note_eh_region, rethrow)
 717      int note_eh_region;
 718      rtx rethrow;
 719 {
 720   if (current_func_eh_entry == num_func_eh_entries)
 721     {
 722       if (num_func_eh_entries == 0)
 723         {
 724           function_eh_regions =
 725                         (struct func_eh_entry *) xmalloc (SIZE_FUNC_EH (50));
 726           num_func_eh_entries = 50;
 727         }
 728       else
 729         {
 730           num_func_eh_entries  = num_func_eh_entries * 3 / 2;
 731           function_eh_regions = (struct func_eh_entry *)
 732             xrealloc (function_eh_regions, SIZE_FUNC_EH (num_func_eh_entries));
 733         }
 734     }
 735   function_eh_regions[current_func_eh_entry].range_number = note_eh_region;
 736   if (rethrow == NULL_RTX)
 737     function_eh_regions[current_func_eh_entry].rethrow_label =
 738                                           create_rethrow_ref (note_eh_region);
 739   else
 740     function_eh_regions[current_func_eh_entry].rethrow_label = rethrow;
 741   function_eh_regions[current_func_eh_entry].handlers = NULL;
 742   function_eh_regions[current_func_eh_entry].emitted = 0;
 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   int r = find_func_region (region);
 916   if (r == -1)
 917     abort ();
 918   return function_eh_regions[r].handlers;
 919 }
 920
 921 /* Clean out the function_eh_region table and free all memory */
 922
 923 static void
 924 clear_function_eh_region ()
 925 {
 926   int x;
 927   struct handler_info *ptr, *next;
 928   for (x = 0; x < current_func_eh_entry; x++)
 929     for (ptr = function_eh_regions[x].handlers; ptr != NULL; ptr = next)
 930       {
 931         next = ptr->next;
 932         free (ptr);
 933       }
 934   if (function_eh_regions)
 935     free (function_eh_regions);
 936   num_func_eh_entries  = 0;
 937   current_func_eh_entry = 0;
 938 }
 939
 940 /* Make a duplicate of an exception region by copying all the handlers
 941    for an exception region. Return the new handler index. The final
 942    parameter is a routine which maps old labels to new ones. */
 943
 944 int
 945 duplicate_eh_handlers (old_note_eh_region, new_note_eh_region, map)
 946      int old_note_eh_region, new_note_eh_region;
 947      rtx (*map) PARAMS ((rtx));
 948 {
 949   struct handler_info *ptr, *new_ptr;
 950   int new_region, region;
 951
 952   region = find_func_region (old_note_eh_region);
 953   if (region == -1)
 954     fatal ("Cannot duplicate non-existant exception region.");
 955
 956   /* duplicate_eh_handlers may have been called during a symbol remap. */
 957   new_region = find_func_region (new_note_eh_region);
 958   if (new_region != -1)
 959     return (new_region);
 960
 961   new_region = new_eh_region_entry (new_note_eh_region, NULL_RTX);
 962
 963   ptr = function_eh_regions[region].handlers;
 964
 965   for ( ; ptr; ptr = ptr->next)
 966     {
 967       new_ptr = get_new_handler (map (ptr->handler_label), ptr->type_info);
 968       add_new_handler (new_region, new_ptr);
 969     }
 970
 971   return new_region;
 972 }
 973
 974
 975 /* Given a rethrow symbol, find the EH region number this is for. */
 976
 977 static int
 978 eh_region_from_symbol (sym)
 979      rtx sym;
 980 {
 981   int x;
 982   if (sym == last_rethrow_symbol)
 983     return 1;
 984   for (x = 0; x < current_func_eh_entry; x++)
 985     if (function_eh_regions[x].rethrow_label == sym)
 986       return function_eh_regions[x].range_number;
 987   return -1;
 988 }
 989
 990 /* Like find_func_region, but using the rethrow symbol for the region
 991    rather than the region number itself.  */
 992
 993 static int
 994 find_func_region_from_symbol (sym)
 995      rtx sym;
 996 {
 997   return find_func_region (eh_region_from_symbol (sym));
 998 }
 999
1000 /* When inlining/unrolling, we have to map the symbols passed to
1001    __rethrow as well. This performs the remap. If a symbol isn't foiund,
1002    the original one is returned. This is not an efficient routine,
1003    so don't call it on everything!! */
1004
1005 rtx
1006 rethrow_symbol_map (sym, map)
1007      rtx sym;
1008      rtx (*map) PARAMS ((rtx));
1009 {
1010   int x, y;
1011
1012   if (! flag_new_exceptions)
1013     return sym;
1014
1015   for (x = 0; x < current_func_eh_entry; x++)
1016     if (function_eh_regions[x].rethrow_label == sym)
1017       {
1018         /* We've found the original region, now lets determine which region
1019            this now maps to. */
1020         rtx l1 = function_eh_regions[x].handlers->handler_label;
1021         rtx l2 = map (l1);
1022         y = CODE_LABEL_NUMBER (l2); /* This is the new region number */
1023         x = find_func_region (y);  /* Get the new permanent region */
1024         if (x == -1)  /* Hmm, Doesn't exist yet */
1025           {
1026             x = duplicate_eh_handlers (CODE_LABEL_NUMBER (l1), y, map);
1027             /* Since we're mapping it, it must be used. */
1028             function_eh_regions[x].rethrow_ref = 1;
1029           }
1030         return function_eh_regions[x].rethrow_label;
1031       }
1032   return sym;
1033 }
1034
1035 /* Returns nonzero if the rethrow label for REGION is referenced
1036    somewhere (i.e. we rethrow out of REGION or some other region
1037    masquerading as REGION).  */
1038
1039 int
1040 rethrow_used (region)
1041      int region;
1042 {
1043   if (flag_new_exceptions)
1044     {
1045       int ret = function_eh_regions[find_func_region (region)].rethrow_ref;
1046       return ret;
1047     }
1048   return 0;
1049 }
1050
1051 \f
1052 /* Routine to see if exception handling is turned on.
1053    DO_WARN is non-zero if we want to inform the user that exception
1054    handling is turned off.
1055
1056    This is used to ensure that -fexceptions has been specified if the
1057    compiler tries to use any exception-specific functions.  */
1058
1059 int
1060 doing_eh (do_warn)
1061      int do_warn;
1062 {
1063   if (! flag_exceptions)
1064     {
1065       static int warned = 0;
1066       if (! warned && do_warn)
1067         {
1068           error ("exception handling disabled, use -fexceptions to enable");
1069           warned = 1;
1070         }
1071       return 0;
1072     }
1073   return 1;
1074 }
1075
1076 /* Given a return address in ADDR, determine the address we should use
1077    to find the corresponding EH region.  */
1078
1079 rtx
1080 eh_outer_context (addr)
1081      rtx addr;
1082 {
1083   /* First mask out any unwanted bits.  */
1084 #ifdef MASK_RETURN_ADDR
1085   expand_and (addr, MASK_RETURN_ADDR, addr);
1086 #endif
1087
1088   /* Then adjust to find the real return address.  */
1089 #if defined (RETURN_ADDR_OFFSET)
1090   addr = plus_constant (addr, RETURN_ADDR_OFFSET);
1091 #endif
1092
1093   return addr;
1094 }
1095
1096 /* Start a new exception region for a region of code that has a
1097    cleanup action and push the HANDLER for the region onto
1098    protect_list. All of the regions created with add_partial_entry
1099    will be ended when end_protect_partials is invoked.  */
1100
1101 void
1102 add_partial_entry (handler)
1103      tree handler;
1104 {
1105   expand_eh_region_start ();
1106
1107   /* Make sure the entry is on the correct obstack.  */
1108   push_obstacks_nochange ();
1109   resume_temporary_allocation ();
1110
1111   /* Because this is a cleanup action, we may have to protect the handler
1112      with __terminate.  */
1113   handler = protect_with_terminate (handler);
1114
1115   /* For backwards compatibility, we allow callers to omit calls to
1116      begin_protect_partials for the outermost region.  So, we must
1117      explicitly do so here.  */
1118   if (!protect_list)
1119     begin_protect_partials ();
1120
1121   /* Add this entry to the front of the list.  */
1122   TREE_VALUE (protect_list)
1123     = tree_cons (NULL_TREE, handler, TREE_VALUE (protect_list));
1124   pop_obstacks ();
1125 }
1126
1127 /* Emit code to get EH context to current function.  */
1128
1129 static rtx
1130 call_get_eh_context ()
1131 {
1132   static tree fn;
1133   tree expr;
1134
1135   if (fn == NULL_TREE)
1136     {
1137       tree fntype;
1138       fn = get_identifier ("__get_eh_context");
1139       push_obstacks_nochange ();
1140       end_temporary_allocation ();
1141       fntype = build_pointer_type (build_pointer_type
1142                                    (build_pointer_type (void_type_node)));
1143       fntype = build_function_type (fntype, NULL_TREE);
1144       fn = build_decl (FUNCTION_DECL, fn, fntype);
1145       DECL_EXTERNAL (fn) = 1;
1146       TREE_PUBLIC (fn) = 1;
1147       DECL_ARTIFICIAL (fn) = 1;
1148       TREE_READONLY (fn) = 1;
1149       make_decl_rtl (fn, NULL_PTR, 1);
1150       assemble_external (fn);
1151       pop_obstacks ();
1152
1153       ggc_add_tree_root (&fn, 1);
1154     }
1155
1156   expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
1157   expr = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
1158                 expr, NULL_TREE, NULL_TREE);
1159   TREE_SIDE_EFFECTS (expr) = 1;
1160
1161   return copy_to_reg (expand_expr (expr, NULL_RTX, VOIDmode, 0));
1162 }
1163
1164 /* Get a reference to the EH context.
1165    We will only generate a register for the current function EH context here,
1166    and emit a USE insn to mark that this is a EH context register.
1167
1168    Later, emit_eh_context will emit needed call to __get_eh_context
1169    in libgcc2, and copy the value to the register we have generated. */
1170
1171 rtx
1172 get_eh_context ()
1173 {
1174   if (current_function_ehc == 0)
1175     {
1176       rtx insn;
1177
1178       current_function_ehc = gen_reg_rtx (Pmode);
1179
1180       insn = gen_rtx_USE (GET_MODE (current_function_ehc),
1181                           current_function_ehc);
1182       insn = emit_insn_before (insn, get_first_nonparm_insn ());
1183
1184       REG_NOTES (insn)
1185         = gen_rtx_EXPR_LIST (REG_EH_CONTEXT, current_function_ehc,
1186                              REG_NOTES (insn));
1187     }
1188   return current_function_ehc;
1189 }
1190
1191 /* Get a reference to the dynamic handler chain.  It points to the
1192    pointer to the next element in the dynamic handler chain.  It ends
1193    when there are no more elements in the dynamic handler chain, when
1194    the value is &top_elt from libgcc2.c.  Immediately after the
1195    pointer, is an area suitable for setjmp/longjmp when
1196    DONT_USE_BUILTIN_SETJMP is defined, and an area suitable for
1197    __builtin_setjmp/__builtin_longjmp when DONT_USE_BUILTIN_SETJMP
1198    isn't defined. */
1199
1200 rtx
1201 get_dynamic_handler_chain ()
1202 {
1203   rtx ehc, dhc, result;
1204
1205   ehc = get_eh_context ();
1206
1207   /* This is the offset of dynamic_handler_chain in the eh_context struct
1208      declared in eh-common.h. If its location is change, change this offset */
1209   dhc = plus_constant (ehc, POINTER_SIZE / BITS_PER_UNIT);
1210
1211   result = copy_to_reg (dhc);
1212
1213   /* We don't want a copy of the dcc, but rather, the single dcc.  */
1214   return gen_rtx_MEM (Pmode, result);
1215 }
1216
1217 /* Get a reference to the dynamic cleanup chain.  It points to the
1218    pointer to the next element in the dynamic cleanup chain.
1219    Immediately after the pointer, are two Pmode variables, one for a
1220    pointer to a function that performs the cleanup action, and the
1221    second, the argument to pass to that function.  */
1222
1223 rtx
1224 get_dynamic_cleanup_chain ()
1225 {
1226   rtx dhc, dcc, result;
1227
1228   dhc = get_dynamic_handler_chain ();
1229   dcc = plus_constant (dhc, POINTER_SIZE / BITS_PER_UNIT);
1230
1231   result = copy_to_reg (dcc);
1232
1233   /* We don't want a copy of the dcc, but rather, the single dcc.  */
1234   return gen_rtx_MEM (Pmode, result);
1235 }
1236
1237 #ifdef DONT_USE_BUILTIN_SETJMP
1238 /* Generate code to evaluate X and jump to LABEL if the value is nonzero.
1239    LABEL is an rtx of code CODE_LABEL, in this function.  */
1240
1241 static void
1242 jumpif_rtx (x, label)
1243      rtx x;
1244      rtx label;
1245 {
1246   jumpif (make_tree (type_for_mode (GET_MODE (x), 0), x), label);
1247 }
1248 #endif
1249
1250 /* Start a dynamic cleanup on the EH runtime dynamic cleanup stack.
1251    We just need to create an element for the cleanup list, and push it
1252    into the chain.
1253
1254    A dynamic cleanup is a cleanup action implied by the presence of an
1255    element on the EH runtime dynamic cleanup stack that is to be
1256    performed when an exception is thrown.  The cleanup action is
1257    performed by __sjthrow when an exception is thrown.  Only certain
1258    actions can be optimized into dynamic cleanup actions.  For the
1259    restrictions on what actions can be performed using this routine,
1260    see expand_eh_region_start_tree.  */
1261
1262 static void
1263 start_dynamic_cleanup (func, arg)
1264      tree func;
1265      tree arg;
1266 {
1267   rtx dcc;
1268   rtx new_func, new_arg;
1269   rtx x, buf;
1270   int size;
1271
1272   /* We allocate enough room for a pointer to the function, and
1273      one argument.  */
1274   size = 2;
1275
1276   /* XXX, FIXME: The stack space allocated this way is too long lived,
1277      but there is no allocation routine that allocates at the level of
1278      the last binding contour.  */
1279   buf = assign_stack_local (BLKmode,
1280                             GET_MODE_SIZE (Pmode)*(size+1),
1281                             0);
1282
1283   buf = change_address (buf, Pmode, NULL_RTX);
1284
1285   /* Store dcc into the first word of the newly allocated buffer.  */
1286
1287   dcc = get_dynamic_cleanup_chain ();
1288   emit_move_insn (buf, dcc);
1289
1290   /* Store func and arg into the cleanup list element.  */
1291
1292   new_func = gen_rtx_MEM (Pmode, plus_constant (XEXP (buf, 0),
1293                                                 GET_MODE_SIZE (Pmode)));
1294   new_arg = gen_rtx_MEM (Pmode, plus_constant (XEXP (buf, 0),
1295                                                GET_MODE_SIZE (Pmode)*2));
1296   x = expand_expr (func, new_func, Pmode, 0);
1297   if (x != new_func)
1298     emit_move_insn (new_func, x);
1299
1300   x = expand_expr (arg, new_arg, Pmode, 0);
1301   if (x != new_arg)
1302     emit_move_insn (new_arg, x);
1303
1304   /* Update the cleanup chain.  */
1305
1306   x = force_operand (XEXP (buf, 0), dcc);
1307   if (x != dcc)
1308     emit_move_insn (dcc, x);
1309 }
1310
1311 /* Emit RTL to start a dynamic handler on the EH runtime dynamic
1312    handler stack.  This should only be used by expand_eh_region_start
1313    or expand_eh_region_start_tree.  */
1314
1315 static void
1316 start_dynamic_handler ()
1317 {
1318   rtx dhc, dcc;
1319   rtx x, arg, buf;
1320   int size;
1321
1322 #ifndef DONT_USE_BUILTIN_SETJMP
1323   /* The number of Pmode words for the setjmp buffer, when using the
1324      builtin setjmp/longjmp, see expand_builtin, case BUILT_IN_LONGJMP.  */
1325   /* We use 2 words here before calling expand_builtin_setjmp.
1326      expand_builtin_setjmp uses 2 words, and then calls emit_stack_save.
1327      emit_stack_save needs space of size STACK_SAVEAREA_MODE (SAVE_NONLOCAL).
1328      Subtract one, because the assign_stack_local call below adds 1.  */
1329   size = (2 + 2 + (GET_MODE_SIZE (STACK_SAVEAREA_MODE (SAVE_NONLOCAL))
1330                    / GET_MODE_SIZE (Pmode))
1331           - 1);
1332 #else
1333 #ifdef JMP_BUF_SIZE
1334   size = JMP_BUF_SIZE;
1335 #else
1336   /* Should be large enough for most systems, if it is not,
1337      JMP_BUF_SIZE should be defined with the proper value.  It will
1338      also tend to be larger than necessary for most systems, a more
1339      optimal port will define JMP_BUF_SIZE.  */
1340   size = FIRST_PSEUDO_REGISTER+2;
1341 #endif
1342 #endif
1343   /* XXX, FIXME: The stack space allocated this way is too long lived,
1344      but there is no allocation routine that allocates at the level of
1345      the last binding contour.  */
1346   arg = assign_stack_local (BLKmode,
1347                             GET_MODE_SIZE (Pmode)*(size+1),
1348                             0);
1349
1350   arg = change_address (arg, Pmode, NULL_RTX);
1351
1352   /* Store dhc into the first word of the newly allocated buffer.  */
1353
1354   dhc = get_dynamic_handler_chain ();
1355   dcc = gen_rtx_MEM (Pmode, plus_constant (XEXP (arg, 0),
1356                                            GET_MODE_SIZE (Pmode)));
1357   emit_move_insn (arg, dhc);
1358
1359   /* Zero out the start of the cleanup chain.  */
1360   emit_move_insn (dcc, const0_rtx);
1361
1362   /* The jmpbuf starts two words into the area allocated.  */
1363   buf = plus_constant (XEXP (arg, 0), GET_MODE_SIZE (Pmode)*2);
1364
1365 #ifdef DONT_USE_BUILTIN_SETJMP
1366   x = emit_library_call_value (setjmp_libfunc, NULL_RTX, LCT_CONST,
1367                                TYPE_MODE (integer_type_node), 1,
1368                                buf, Pmode);
1369   /* If we come back here for a catch, transfer control to the handler.  */
1370   jumpif_rtx (x, ehstack.top->entry->exception_handler_label);
1371 #else
1372   {
1373     /* A label to continue execution for the no exception case.  */
1374     rtx noex = gen_label_rtx();
1375     x = expand_builtin_setjmp (buf, NULL_RTX, noex,
1376                                ehstack.top->entry->exception_handler_label);
1377     emit_label (noex);
1378   }
1379 #endif
1380
1381   /* We are committed to this, so update the handler chain.  */
1382
1383   emit_move_insn (dhc, force_operand (XEXP (arg, 0), NULL_RTX));
1384 }
1385
1386 /* Start an exception handling region for the given cleanup action.
1387    All instructions emitted after this point are considered to be part
1388    of the region until expand_eh_region_end is invoked.  CLEANUP is
1389    the cleanup action to perform.  The return value is true if the
1390    exception region was optimized away.  If that case,
1391    expand_eh_region_end does not need to be called for this cleanup,
1392    nor should it be.
1393
1394    This routine notices one particular common case in C++ code
1395    generation, and optimizes it so as to not need the exception
1396    region.  It works by creating a dynamic cleanup action, instead of
1397    a using an exception region.  */
1398
1399 int
1400 expand_eh_region_start_tree (decl, cleanup)
1401      tree decl;
1402      tree cleanup;
1403 {
1404   /* This is the old code.  */
1405   if (! doing_eh (0))
1406     return 0;
1407
1408   /* The optimization only applies to actions protected with
1409      terminate, and only applies if we are using the setjmp/longjmp
1410      codegen method.  */
1411   if (exceptions_via_longjmp
1412       && protect_cleanup_actions_with_terminate)
1413     {
1414       tree func, arg;
1415       tree args;
1416
1417       /* Ignore any UNSAVE_EXPR.  */
1418       if (TREE_CODE (cleanup) == UNSAVE_EXPR)
1419         cleanup = TREE_OPERAND (cleanup, 0);
1420
1421       /* Further, it only applies if the action is a call, if there
1422          are 2 arguments, and if the second argument is 2.  */
1423
1424       if (TREE_CODE (cleanup) == CALL_EXPR
1425           && (args = TREE_OPERAND (cleanup, 1))
1426           && (func = TREE_OPERAND (cleanup, 0))
1427           && (arg = TREE_VALUE (args))
1428           && (args = TREE_CHAIN (args))
1429
1430           /* is the second argument 2?  */
1431           && TREE_CODE (TREE_VALUE (args)) == INTEGER_CST
1432           && compare_tree_int (TREE_VALUE (args), 2) == 0
1433
1434           /* Make sure there are no other arguments.  */
1435           && TREE_CHAIN (args) == NULL_TREE)
1436         {
1437           /* Arrange for returns and gotos to pop the entry we make on the
1438              dynamic cleanup stack.  */
1439           expand_dcc_cleanup (decl);
1440           start_dynamic_cleanup (func, arg);
1441           return 1;
1442         }
1443     }
1444
1445   expand_eh_region_start_for_decl (decl);
1446   ehstack.top->entry->finalization = cleanup;
1447
1448   return 0;
1449 }
1450
1451 /* Just like expand_eh_region_start, except if a cleanup action is
1452    entered on the cleanup chain, the TREE_PURPOSE of the element put
1453    on the chain is DECL.  DECL should be the associated VAR_DECL, if
1454    any, otherwise it should be NULL_TREE.  */
1455
1456 void
1457 expand_eh_region_start_for_decl (decl)
1458      tree decl;
1459 {
1460   rtx note;
1461
1462   /* This is the old code.  */
1463   if (! doing_eh (0))
1464     return;
1465
1466   /* We need a new block to record the start and end of the
1467      dynamic handler chain.  We also want to prevent jumping into
1468      a try block.  */
1469   expand_start_bindings (2);
1470
1471   /* But we don't need or want a new temporary level.  */
1472   pop_temp_slots ();
1473
1474   /* Mark this block as created by expand_eh_region_start.  This
1475      is so that we can pop the block with expand_end_bindings
1476      automatically.  */
1477   mark_block_as_eh_region ();
1478
1479   if (exceptions_via_longjmp)
1480     {
1481       /* Arrange for returns and gotos to pop the entry we make on the
1482          dynamic handler stack.  */
1483       expand_dhc_cleanup (decl);
1484     }
1485
1486   push_eh_entry (&ehstack);
1487   note = emit_note (NULL_PTR, NOTE_INSN_EH_REGION_BEG);
1488   NOTE_EH_HANDLER (note)
1489     = CODE_LABEL_NUMBER (ehstack.top->entry->exception_handler_label);
1490   if (exceptions_via_longjmp)
1491     start_dynamic_handler ();
1492 }
1493
1494 /* Start an exception handling region.  All instructions emitted after
1495    this point are considered to be part of the region until
1496    expand_eh_region_end is invoked.  */
1497
1498 void
1499 expand_eh_region_start ()
1500 {
1501   expand_eh_region_start_for_decl (NULL_TREE);
1502 }
1503
1504 /* End an exception handling region.  The information about the region
1505    is found on the top of ehstack.
1506
1507    HANDLER is either the cleanup for the exception region, or if we're
1508    marking the end of a try block, HANDLER is integer_zero_node.
1509
1510    HANDLER will be transformed to rtl when expand_leftover_cleanups
1511    is invoked.  */
1512
1513 void
1514 expand_eh_region_end (handler)
1515      tree handler;
1516 {
1517   struct eh_entry *entry;
1518   struct eh_node *node;
1519   rtx note;
1520   int ret, r;
1521
1522   if (! doing_eh (0))
1523     return;
1524
1525   entry = pop_eh_entry (&ehstack);
1526
1527   note = emit_note (NULL_PTR, NOTE_INSN_EH_REGION_END);
1528   ret = NOTE_EH_HANDLER (note)
1529     = CODE_LABEL_NUMBER (entry->exception_handler_label);
1530   if (exceptions_via_longjmp == 0 && ! flag_new_exceptions
1531       /* We share outer_context between regions; only emit it once.  */
1532       && INSN_UID (entry->outer_context) == 0)
1533     {
1534       rtx label;
1535
1536       label = gen_label_rtx ();
1537       emit_jump (label);
1538
1539       /* Emit a label marking the end of this exception region that
1540          is used for rethrowing into the outer context.  */
1541       emit_label (entry->outer_context);
1542       expand_internal_throw ();
1543
1544       emit_label (label);
1545     }
1546
1547   entry->finalization = handler;
1548
1549   /* create region entry in final exception table */
1550   r = new_eh_region_entry (NOTE_EH_HANDLER (note), entry->rethrow_label);
1551
1552   enqueue_eh_entry (ehqueue, entry);
1553
1554   /* If we have already started ending the bindings, don't recurse.  */
1555   if (is_eh_region ())
1556     {
1557       /* Because we don't need or want a new temporary level and
1558          because we didn't create one in expand_eh_region_start,
1559          create a fake one now to avoid removing one in
1560          expand_end_bindings.  */
1561       push_temp_slots ();
1562
1563       mark_block_as_not_eh_region ();
1564
1565       expand_end_bindings (NULL_TREE, 0, 0);
1566     }
1567
1568   /* Go through the goto handlers in the queue, emitting their
1569      handlers if we now have enough information to do so.  */
1570   for (node = ehqueue->head; node; node = node->chain)
1571     if (node->entry->goto_entry_p
1572         && node->entry->outer_context == entry->rethrow_label)
1573       emit_cleanup_handler (node->entry);
1574
1575   /* We can't emit handlers for goto entries until their scopes are
1576      complete because we don't know where they need to rethrow to,
1577      yet.  */
1578   if (entry->finalization != integer_zero_node
1579       && (!entry->goto_entry_p
1580           || find_func_region_from_symbol (entry->outer_context) != -1))
1581     emit_cleanup_handler (entry);
1582 }
1583
1584 /* End the EH region for a goto fixup.  We only need them in the region-based
1585    EH scheme.  */
1586
1587 void
1588 expand_fixup_region_start ()
1589 {
1590   if (! doing_eh (0) || exceptions_via_longjmp)
1591     return;
1592
1593   expand_eh_region_start ();
1594   /* Mark this entry as the entry for a goto.  */
1595   ehstack.top->entry->goto_entry_p = 1;
1596 }
1597
1598 /* End the EH region for a goto fixup.  CLEANUP is the cleanup we just
1599    expanded; to avoid running it twice if it throws, we look through the
1600    ehqueue for a matching region and rethrow from its outer_context.  */
1601
1602 void
1603 expand_fixup_region_end (cleanup)
1604      tree cleanup;
1605 {
1606   struct eh_node *node;
1607   int dont_issue;
1608
1609   if (! doing_eh (0) || exceptions_via_longjmp)
1610     return;
1611
1612   for (node = ehstack.top; node && node->entry->finalization != cleanup; )
1613     node = node->chain;
1614   if (node == 0)
1615     for (node = ehqueue->head; node && node->entry->finalization != cleanup; )
1616       node = node->chain;
1617   if (node == 0)
1618     abort ();
1619
1620   /* If the outer context label has not been issued yet, we don't want
1621      to issue it as a part of this region, unless this is the
1622      correct region for the outer context. If we did, then the label for
1623      the outer context will be WITHIN the begin/end labels,
1624      and we could get an infinte loop when it tried to rethrow, or just
1625      generally incorrect execution following a throw. */
1626
1627   if (flag_new_exceptions)
1628     dont_issue = 0;
1629   else
1630     dont_issue = ((INSN_UID (node->entry->outer_context) == 0)
1631                   && (ehstack.top->entry != node->entry));
1632
1633   ehstack.top->entry->outer_context = node->entry->outer_context;
1634
1635   /* Since we are rethrowing to the OUTER region, we know we don't need
1636      a jump around sequence for this region, so we'll pretend the outer
1637      context label has been issued by setting INSN_UID to 1, then clearing
1638      it again afterwards. */
1639
1640   if (dont_issue)
1641     INSN_UID (node->entry->outer_context) = 1;
1642
1643   /* Just rethrow.  size_zero_node is just a NOP.  */
1644   expand_eh_region_end (size_zero_node);
1645
1646   if (dont_issue)
1647     INSN_UID (node->entry->outer_context) = 0;
1648 }
1649
1650 /* If we are using the setjmp/longjmp EH codegen method, we emit a
1651    call to __sjthrow.  Otherwise, we emit a call to __throw.  */
1652
1653 void
1654 emit_throw ()
1655 {
1656   if (exceptions_via_longjmp)
1657     {
1658       emit_library_call (sjthrow_libfunc, 0, VOIDmode, 0);
1659     }
1660   else
1661     {
1662 #ifdef JUMP_TO_THROW
1663       emit_indirect_jump (throw_libfunc);
1664 #else
1665       emit_library_call (throw_libfunc, 0, VOIDmode, 0);
1666 #endif
1667     }
1668   emit_barrier ();
1669 }
1670
1671 /* Throw the current exception.  If appropriate, this is done by jumping
1672    to the next handler.  */
1673
1674 void
1675 expand_internal_throw ()
1676 {
1677   emit_throw ();
1678 }
1679
1680 /* Called from expand_exception_blocks and expand_end_catch_block to
1681    emit any pending handlers/cleanups queued from expand_eh_region_end.  */
1682
1683 void
1684 expand_leftover_cleanups ()
1685 {
1686   struct eh_entry *entry;
1687
1688   for (entry = dequeue_eh_entry (ehqueue);
1689        entry;
1690        entry = dequeue_eh_entry (ehqueue))
1691     {
1692       /* A leftover try block.  Shouldn't be one here.  */
1693       if (entry->finalization == integer_zero_node)
1694         abort ();
1695
1696       free (entry);
1697     }
1698 }
1699
1700 /* Called at the start of a block of try statements.  */
1701 void
1702 expand_start_try_stmts ()
1703 {
1704   if (! doing_eh (1))
1705     return;
1706
1707   expand_eh_region_start ();
1708 }
1709
1710 /* Called to begin a catch clause. The parameter is the object which
1711    will be passed to the runtime type check routine. */
1712 void
1713 start_catch_handler (rtime)
1714      tree rtime;
1715 {
1716   rtx handler_label;
1717   int insn_region_num;
1718   int eh_region_entry;
1719
1720   if (! doing_eh (1))
1721     return;
1722
1723   handler_label = catchstack.top->entry->exception_handler_label;
1724   insn_region_num = CODE_LABEL_NUMBER (handler_label);
1725   eh_region_entry = find_func_region (insn_region_num);
1726
1727   /* If we've already issued this label, pick a new one */
1728   if (catchstack.top->entry->label_used)
1729     handler_label = gen_exception_label ();
1730   else
1731     catchstack.top->entry->label_used = 1;
1732
1733   receive_exception_label (handler_label);
1734
1735   add_new_handler (eh_region_entry, get_new_handler (handler_label, rtime));
1736
1737   if (flag_new_exceptions && ! exceptions_via_longjmp)
1738     return;
1739
1740   /* Under the old mechanism, as well as setjmp/longjmp, we need to
1741      issue code to compare 'rtime' to the value in eh_info, via the
1742      matching function in eh_info. If its is false, we branch around
1743      the handler we are about to issue. */
1744
1745   if (rtime != NULL_TREE && rtime != CATCH_ALL_TYPE)
1746     {
1747       rtx call_rtx, rtime_address;
1748
1749       if (catchstack.top->entry->false_label != NULL_RTX)
1750         {
1751           error ("Never issued previous false_label");
1752           abort ();
1753         }
1754       catchstack.top->entry->false_label = gen_exception_label ();
1755
1756       rtime_address = expand_expr (rtime, NULL_RTX, Pmode, EXPAND_INITIALIZER);
1757 #ifdef POINTERS_EXTEND_UNSIGNED
1758       rtime_address = convert_memory_address (Pmode, rtime_address);
1759 #endif
1760       rtime_address = force_reg (Pmode, rtime_address);
1761
1762       /* Now issue the call, and branch around handler if needed */
1763       call_rtx = emit_library_call_value (eh_rtime_match_libfunc, NULL_RTX,
1764                                           LCT_NORMAL,
1765                                           TYPE_MODE (integer_type_node),
1766                                           1, rtime_address, Pmode);
1767
1768       /* Did the function return true? */
1769       emit_cmp_and_jump_insns (call_rtx, const0_rtx, EQ, NULL_RTX,
1770                                GET_MODE (call_rtx), 0, 0,
1771                                catchstack.top->entry->false_label);
1772     }
1773 }
1774
1775 /* Called to end a catch clause. If we aren't using the new exception
1776    model tabel mechanism, we need to issue the branch-around label
1777    for the end of the catch block. */
1778
1779 void
1780 end_catch_handler ()
1781 {
1782   if (! doing_eh (1))
1783     return;
1784
1785   if (flag_new_exceptions && ! exceptions_via_longjmp)
1786     {
1787       emit_barrier ();
1788       return;
1789     }
1790
1791   /* A NULL label implies the catch clause was a catch all or cleanup */
1792   if (catchstack.top->entry->false_label == NULL_RTX)
1793     return;
1794
1795   emit_label (catchstack.top->entry->false_label);
1796   catchstack.top->entry->false_label = NULL_RTX;
1797 }
1798
1799 /* Save away the current ehqueue.  */
1800
1801 void
1802 push_ehqueue ()
1803 {
1804   struct eh_queue *q;
1805   q = (struct eh_queue *) xcalloc (1, sizeof (struct eh_queue));
1806   q->next = ehqueue;
1807   ehqueue = q;
1808 }
1809
1810 /* Restore a previously pushed ehqueue.  */
1811
1812 void
1813 pop_ehqueue ()
1814 {
1815   struct eh_queue *q;
1816   expand_leftover_cleanups ();
1817   q = ehqueue->next;
1818   free (ehqueue);
1819   ehqueue = q;
1820 }
1821
1822 /* Emit the handler specified by ENTRY.  */
1823
1824 static void
1825 emit_cleanup_handler (entry)
1826   struct eh_entry *entry;
1827 {
1828   rtx prev;
1829   rtx handler_insns;
1830
1831   /* Since the cleanup could itself contain try-catch blocks, we
1832      squirrel away the current queue and replace it when we are done
1833      with this function.  */
1834   push_ehqueue ();
1835
1836   /* Put these handler instructions in a sequence.  */
1837   do_pending_stack_adjust ();
1838   start_sequence ();
1839
1840   /* Emit the label for the cleanup handler for this region, and
1841      expand the code for the handler.
1842
1843      Note that a catch region is handled as a side-effect here; for a
1844      try block, entry->finalization will contain integer_zero_node, so
1845      no code will be generated in the expand_expr call below. But, the
1846      label for the handler will still be emitted, so any code emitted
1847      after this point will end up being the handler.  */
1848
1849   receive_exception_label (entry->exception_handler_label);
1850
1851   /* register a handler for this cleanup region */
1852   add_new_handler (find_func_region (CODE_LABEL_NUMBER (entry->exception_handler_label)),
1853                    get_new_handler (entry->exception_handler_label, NULL));
1854
1855   /* And now generate the insns for the cleanup handler.  */
1856   expand_expr (entry->finalization, const0_rtx, VOIDmode, 0);
1857
1858   prev = get_last_insn ();
1859   if (prev == NULL || GET_CODE (prev) != BARRIER)
1860     /* Code to throw out to outer context when we fall off end of the
1861        handler. We can't do this here for catch blocks, so it's done
1862        in expand_end_all_catch instead.  */
1863     expand_rethrow (entry->outer_context);
1864
1865   /* Finish this sequence.  */
1866   do_pending_stack_adjust ();
1867   handler_insns = get_insns ();
1868   end_sequence ();
1869
1870   /* And add it to the CATCH_CLAUSES.  */
1871   push_to_full_sequence (catch_clauses, catch_clauses_last);
1872   emit_insns (handler_insns);
1873   end_full_sequence (&catch_clauses, &catch_clauses_last);
1874
1875   /* Now we've left the handler.  */
1876   pop_ehqueue ();
1877 }
1878
1879 /* Generate RTL for the start of a group of catch clauses.
1880
1881    It is responsible for starting a new instruction sequence for the
1882    instructions in the catch block, and expanding the handlers for the
1883    internally-generated exception regions nested within the try block
1884    corresponding to this catch block.  */
1885
1886 void
1887 expand_start_all_catch ()
1888 {
1889   struct eh_entry *entry;
1890   tree label;
1891   rtx outer_context;
1892
1893   if (! doing_eh (1))
1894     return;
1895
1896   outer_context = ehstack.top->entry->outer_context;
1897
1898   /* End the try block.  */
1899   expand_eh_region_end (integer_zero_node);
1900
1901   emit_line_note (input_filename, lineno);
1902   label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
1903
1904   /* The label for the exception handling block that we will save.
1905      This is Lresume in the documentation.  */
1906   expand_label (label);
1907
1908   /* Push the label that points to where normal flow is resumed onto
1909      the top of the label stack.  */
1910   push_label_entry (&caught_return_label_stack, NULL_RTX, label);
1911
1912   /* Start a new sequence for all the catch blocks.  We will add this
1913      to the global sequence catch_clauses when we have completed all
1914      the handlers in this handler-seq.  */
1915   start_sequence ();
1916
1917   /* Throw away entries in the queue that we won't need anymore.  We
1918      need entries for regions that have ended but to which there might
1919      still be gotos pending.  */
1920   for (entry = dequeue_eh_entry (ehqueue);
1921        entry->finalization != integer_zero_node;
1922        entry = dequeue_eh_entry (ehqueue))
1923     free (entry);
1924
1925   /* At this point, all the cleanups are done, and the ehqueue now has
1926      the current exception region at its head. We dequeue it, and put it
1927      on the catch stack. */
1928   push_entry (&catchstack, entry);
1929
1930   /* If we are not doing setjmp/longjmp EH, because we are reordered
1931      out of line, we arrange to rethrow in the outer context.  We need to
1932      do this because we are not physically within the region, if any, that
1933      logically contains this catch block.  */
1934   if (! exceptions_via_longjmp)
1935     {
1936       expand_eh_region_start ();
1937       ehstack.top->entry->outer_context = outer_context;
1938     }
1939
1940 }
1941
1942 /* Finish up the catch block.  At this point all the insns for the
1943    catch clauses have already been generated, so we only have to add
1944    them to the catch_clauses list. We also want to make sure that if
1945    we fall off the end of the catch clauses that we rethrow to the
1946    outer EH region.  */
1947
1948 void
1949 expand_end_all_catch ()
1950 {
1951   rtx new_catch_clause;
1952   struct eh_entry *entry;
1953
1954   if (! doing_eh (1))
1955     return;
1956
1957   /* Dequeue the current catch clause region. */
1958   entry = pop_eh_entry (&catchstack);
1959   free (entry);
1960
1961   if (! exceptions_via_longjmp)
1962     {
1963       rtx outer_context = ehstack.top->entry->outer_context;
1964
1965       /* Finish the rethrow region.  size_zero_node is just a NOP.  */
1966       expand_eh_region_end (size_zero_node);
1967       /* New exceptions handling models will never have a fall through
1968          of a catch clause */
1969       if (!flag_new_exceptions)
1970         expand_rethrow (outer_context);
1971     }
1972   else
1973     expand_rethrow (NULL_RTX);
1974
1975   /* Code to throw out to outer context, if we fall off end of catch
1976      handlers.  This is rethrow (Lresume, same id, same obj) in the
1977      documentation. We use Lresume because we know that it will throw
1978      to the correct context.
1979
1980      In other words, if the catch handler doesn't exit or return, we
1981      do a "throw" (using the address of Lresume as the point being
1982      thrown from) so that the outer EH region can then try to process
1983      the exception.  */
1984
1985   /* Now we have the complete catch sequence.  */
1986   new_catch_clause = get_insns ();
1987   end_sequence ();
1988
1989   /* This level of catch blocks is done, so set up the successful
1990      catch jump label for the next layer of catch blocks.  */
1991   pop_label_entry (&caught_return_label_stack);
1992   pop_label_entry (&outer_context_label_stack);
1993
1994   /* Add the new sequence of catches to the main one for this function.  */
1995   push_to_full_sequence (catch_clauses, catch_clauses_last);
1996   emit_insns (new_catch_clause);
1997   end_full_sequence (&catch_clauses, &catch_clauses_last);
1998
1999   /* Here we fall through into the continuation code.  */
2000 }
2001
2002 /* Rethrow from the outer context LABEL.  */
2003
2004 static void
2005 expand_rethrow (label)
2006      rtx label;
2007 {
2008   if (exceptions_via_longjmp)
2009     emit_throw ();
2010   else
2011     if (flag_new_exceptions)
2012       {
2013         rtx insn;
2014         int region;
2015         if (label == NULL_RTX)
2016           label = last_rethrow_symbol;
2017         emit_library_call (rethrow_libfunc, 0, VOIDmode, 1, label, Pmode);
2018         region = find_func_region (eh_region_from_symbol (label));
2019         /* If the region is -1, it doesn't exist yet.  We shouldn't be
2020            trying to rethrow there yet.  */
2021         if (region == -1)
2022           abort ();
2023         function_eh_regions[region].rethrow_ref = 1;
2024
2025         /* Search backwards for the actual call insn.  */
2026         insn = get_last_insn ();
2027         while (GET_CODE (insn) != CALL_INSN)
2028           insn = PREV_INSN (insn);
2029         delete_insns_since (insn);
2030
2031         /* Mark the label/symbol on the call. */
2032         REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EH_RETHROW, label,
2033                                               REG_NOTES (insn));
2034         emit_barrier ();
2035       }
2036     else
2037       emit_jump (label);
2038 }
2039
2040 /* Begin a region that will contain entries created with
2041    add_partial_entry.  */
2042
2043 void
2044 begin_protect_partials ()
2045 {
2046   /* Put the entry on the function obstack.  */
2047   push_obstacks_nochange ();
2048   resume_temporary_allocation ();
2049
2050   /* Push room for a new list.  */
2051   protect_list = tree_cons (NULL_TREE, NULL_TREE, protect_list);
2052
2053   /* We're done with the function obstack now.  */
2054   pop_obstacks ();
2055 }
2056
2057 /* End all the pending exception regions on protect_list. The handlers
2058    will be emitted when expand_leftover_cleanups is invoked.  */
2059
2060 void
2061 end_protect_partials ()
2062 {
2063   tree t;
2064
2065   /* For backwards compatibility, we allow callers to omit the call to
2066      begin_protect_partials for the outermost region.  So,
2067      PROTECT_LIST may be NULL.  */
2068   if (!protect_list)
2069     return;
2070
2071   /* End all the exception regions.  */
2072   for (t = TREE_VALUE (protect_list); t; t = TREE_CHAIN (t))
2073     expand_eh_region_end (TREE_VALUE (t));
2074
2075   /* Pop the topmost entry.  */
2076   protect_list = TREE_CHAIN (protect_list);
2077
2078 }
2079
2080 /* Arrange for __terminate to be called if there is an unhandled throw
2081    from within E.  */
2082
2083 tree
2084 protect_with_terminate (e)
2085      tree e;
2086 {
2087   /* We only need to do this when using setjmp/longjmp EH and the
2088      language requires it, as otherwise we protect all of the handlers
2089      at once, if we need to.  */
2090   if (exceptions_via_longjmp && protect_cleanup_actions_with_terminate)
2091     {
2092       tree handler, result;
2093
2094       /* All cleanups must be on the function_obstack.  */
2095       push_obstacks_nochange ();
2096       resume_temporary_allocation ();
2097
2098       handler = make_node (RTL_EXPR);
2099       TREE_TYPE (handler) = void_type_node;
2100       RTL_EXPR_RTL (handler) = const0_rtx;
2101       TREE_SIDE_EFFECTS (handler) = 1;
2102       start_sequence_for_rtl_expr (handler);
2103
2104       emit_library_call (terminate_libfunc, 0, VOIDmode, 0);
2105       emit_barrier ();
2106
2107       RTL_EXPR_SEQUENCE (handler) = get_insns ();
2108       end_sequence ();
2109
2110       result = build (TRY_CATCH_EXPR, TREE_TYPE (e), e, handler);
2111       TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
2112       TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
2113       TREE_READONLY (result) = TREE_READONLY (e);
2114
2115       pop_obstacks ();
2116
2117       e = result;
2118     }
2119
2120   return e;
2121 }
2122 \f
2123 /* The exception table that we build that is used for looking up and
2124    dispatching exceptions, the current number of entries, and its
2125    maximum size before we have to extend it.
2126
2127    The number in eh_table is the code label number of the exception
2128    handler for the region. This is added by add_eh_table_entry and
2129    used by output_exception_table_entry.  */
2130
2131 static int *eh_table = NULL;
2132 static int eh_table_size = 0;
2133 static int eh_table_max_size = 0;
2134
2135 /* Note the need for an exception table entry for region N.  If we
2136    don't need to output an explicit exception table, avoid all of the
2137    extra work.
2138
2139    Called from final_scan_insn when a NOTE_INSN_EH_REGION_BEG is seen.
2140    (Or NOTE_INSN_EH_REGION_END sometimes)
2141    N is the NOTE_EH_HANDLER of the note, which comes from the code
2142    label number of the exception handler for the region.  */
2143
2144 void
2145 add_eh_table_entry (n)
2146      int n;
2147 {
2148 #ifndef OMIT_EH_TABLE
2149   if (eh_table_size >= eh_table_max_size)
2150     {
2151       if (eh_table)
2152         {
2153           eh_table_max_size += eh_table_max_size>>1;
2154
2155           if (eh_table_max_size < 0)
2156             abort ();
2157
2158           eh_table = (int *) xrealloc (eh_table,
2159                                        eh_table_max_size * sizeof (int));
2160         }
2161       else
2162         {
2163           eh_table_max_size = 252;
2164           eh_table = (int *) xmalloc (eh_table_max_size * sizeof (int));
2165         }
2166     }
2167   eh_table[eh_table_size++] = n;
2168
2169   if (flag_new_exceptions)
2170     {
2171       /* We will output the exception table late in the compilation. That
2172          references type_info objects which should have already been output
2173          by that time. We explicitly mark those objects as being
2174          referenced now so we know to emit them.  */
2175       struct handler_info *handler = get_first_handler (n);
2176
2177       for (; handler; handler = handler->next)
2178         if (handler->type_info && handler->type_info != CATCH_ALL_TYPE)
2179           {
2180             tree tinfo = (tree)handler->type_info;
2181
2182             tinfo = TREE_OPERAND (tinfo, 0);
2183             TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo)) = 1;
2184           }
2185     }
2186 #endif
2187 }
2188
2189 /* Return a non-zero value if we need to output an exception table.
2190
2191    On some platforms, we don't have to output a table explicitly.
2192    This routine doesn't mean we don't have one.  */
2193
2194 int
2195 exception_table_p ()
2196 {
2197   if (eh_table)
2198     return 1;
2199
2200   return 0;
2201 }
2202
2203 /* Output the entry of the exception table corresponding to the
2204    exception region numbered N to file FILE.
2205
2206    N is the code label number corresponding to the handler of the
2207    region.  */
2208
2209 static void
2210 output_exception_table_entry (file, n)
2211      FILE *file;
2212      int n;
2213 {
2214   char buf[256];
2215   rtx sym;
2216   struct handler_info *handler = get_first_handler (n);
2217   int index = find_func_region (n);
2218   rtx rethrow;
2219
2220   /* Form and emit the rethrow label, if needed  */
2221   if (flag_new_exceptions
2222       && (handler || function_eh_regions[index].rethrow_ref))
2223     rethrow = function_eh_regions[index].rethrow_label;
2224   else
2225     rethrow = NULL_RTX;
2226
2227   if (function_eh_regions[index].emitted)
2228     return;
2229   function_eh_regions[index].emitted  = 1;
2230
2231   for ( ; handler != NULL || rethrow != NULL_RTX; handler = handler->next)
2232     {
2233       /* rethrow label should indicate the LAST entry for a region */
2234       if (rethrow != NULL_RTX && (handler == NULL || handler->next == NULL))
2235         {
2236           ASM_GENERATE_INTERNAL_LABEL (buf, "LRTH", n);
2237           assemble_eh_label(buf);
2238           rethrow = NULL_RTX;
2239         }
2240
2241       ASM_GENERATE_INTERNAL_LABEL (buf, "LEHB", n);
2242       sym = gen_rtx_SYMBOL_REF (Pmode, buf);
2243       assemble_eh_integer (sym, POINTER_SIZE / BITS_PER_UNIT, 1);
2244
2245       ASM_GENERATE_INTERNAL_LABEL (buf, "LEHE", n);
2246       sym = gen_rtx_SYMBOL_REF (Pmode, buf);
2247       assemble_eh_integer (sym, POINTER_SIZE / BITS_PER_UNIT, 1);
2248
2249       if (handler == NULL)
2250         assemble_eh_integer (GEN_INT (0), POINTER_SIZE / BITS_PER_UNIT, 1);
2251       else
2252         {
2253           ASM_GENERATE_INTERNAL_LABEL (buf, "L", handler->handler_number);
2254           sym = gen_rtx_SYMBOL_REF (Pmode, buf);
2255           assemble_eh_integer (sym, POINTER_SIZE / BITS_PER_UNIT, 1);
2256         }
2257
2258       if (flag_new_exceptions)
2259         {
2260           if (handler == NULL || handler->type_info == NULL)
2261             assemble_eh_integer (const0_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
2262           else
2263             if (handler->type_info == CATCH_ALL_TYPE)
2264               assemble_eh_integer (GEN_INT (CATCH_ALL_TYPE),
2265                                              POINTER_SIZE / BITS_PER_UNIT, 1);
2266             else
2267               output_constant ((tree)(handler->type_info),
2268                                                 POINTER_SIZE / BITS_PER_UNIT);
2269         }
2270       putc ('\n', file);                /* blank line */
2271       /* We only output the first label under the old scheme */
2272       if (! flag_new_exceptions || handler == NULL)
2273         break;
2274     }
2275 }
2276
2277 /* Output the exception table if we have and need one.  */
2278
2279 static short language_code = 0;
2280 static short version_code = 0;
2281
2282 /* This routine will set the language code for exceptions. */
2283 void
2284 set_exception_lang_code (code)
2285      int code;
2286 {
2287   language_code = code;
2288 }
2289
2290 /* This routine will set the language version code for exceptions. */
2291 void
2292 set_exception_version_code (code)
2293      int code;
2294 {
2295   version_code = code;
2296 }
2297
2298 /* Free the EH table structures.  */
2299 void
2300 free_exception_table ()
2301 {
2302   if (eh_table)
2303     free (eh_table);
2304   clear_function_eh_region ();
2305 }
2306
2307 /* Output the common content of an exception table.  */
2308 void
2309 output_exception_table_data ()
2310 {
2311   int i;
2312   char buf[256];
2313   extern FILE *asm_out_file;
2314
2315   if (flag_new_exceptions)
2316     {
2317       assemble_eh_integer (GEN_INT (NEW_EH_RUNTIME),
2318                                         POINTER_SIZE / BITS_PER_UNIT, 1);
2319       assemble_eh_integer (GEN_INT (language_code), 2 , 1);
2320       assemble_eh_integer (GEN_INT (version_code), 2 , 1);
2321
2322       /* Add enough padding to make sure table aligns on a pointer boundry. */
2323       i = GET_MODE_ALIGNMENT (ptr_mode) / BITS_PER_UNIT - 4;
2324       for ( ; i < 0; i = i + GET_MODE_ALIGNMENT (ptr_mode) / BITS_PER_UNIT)
2325         ;
2326       if (i != 0)
2327         assemble_eh_integer (const0_rtx, i , 1);
2328
2329       /* Generate the label for offset calculations on rethrows.  */
2330       ASM_GENERATE_INTERNAL_LABEL (buf, "LRTH", 0);
2331       assemble_eh_label(buf);
2332     }
2333
2334   for (i = 0; i < eh_table_size; ++i)
2335     output_exception_table_entry (asm_out_file, eh_table[i]);
2336
2337 }
2338
2339 /* Output an exception table for the entire compilation unit.  */
2340 void
2341 output_exception_table ()
2342 {
2343   char buf[256];
2344   extern FILE *asm_out_file;
2345
2346   if (! doing_eh (0) || ! eh_table)
2347     return;
2348
2349   exception_section ();
2350
2351   /* Beginning marker for table.  */
2352   assemble_eh_align (GET_MODE_ALIGNMENT (ptr_mode));
2353   assemble_eh_label ("__EXCEPTION_TABLE__");
2354
2355   output_exception_table_data ();
2356
2357   /* Ending marker for table.  */
2358   /* Generate the label for end of table. */
2359   ASM_GENERATE_INTERNAL_LABEL (buf, "LRTH", CODE_LABEL_NUMBER (final_rethrow));
2360   assemble_eh_label(buf);
2361   assemble_eh_integer (constm1_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
2362
2363   /* For binary compatibility, the old __throw checked the second
2364      position for a -1, so we should output at least 2 -1's */
2365   if (! flag_new_exceptions)
2366     assemble_eh_integer (constm1_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
2367
2368   putc ('\n', asm_out_file);            /* blank line */
2369 }
2370
2371 /* Used by the ia64 unwind format to output data for an individual
2372    function.  */
2373 void
2374 output_function_exception_table ()
2375 {
2376   extern FILE *asm_out_file;
2377
2378   if (! doing_eh (0) || ! eh_table)
2379     return;
2380
2381 #ifdef HANDLER_SECTION
2382   HANDLER_SECTION;
2383 #endif
2384
2385   output_exception_table_data ();
2386
2387   /* Ending marker for table.  */
2388   assemble_eh_integer (constm1_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
2389
2390   putc ('\n', asm_out_file);           /* blank line */
2391 }
2392
2393 \f
2394 /* Emit code to get EH context.
2395
2396    We have to scan thru the code to find possible EH context registers.
2397    Inlined functions may use it too, and thus we'll have to be able
2398    to change them too.
2399
2400    This is done only if using exceptions_via_longjmp. */
2401
2402 void
2403 emit_eh_context ()
2404 {
2405   rtx insn;
2406   rtx ehc = 0;
2407
2408   if (! doing_eh (0))
2409     return;
2410
2411   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2412     if (GET_CODE (insn) == INSN
2413         && GET_CODE (PATTERN (insn)) == USE)
2414       {
2415         rtx reg = find_reg_note (insn, REG_EH_CONTEXT, 0);
2416         if (reg)
2417           {
2418             rtx insns;
2419
2420             start_sequence ();
2421
2422             /* If this is the first use insn, emit the call here.  This
2423                will always be at the top of our function, because if
2424                expand_inline_function notices a REG_EH_CONTEXT note, it
2425                adds a use insn to this function as well.  */
2426             if (ehc == 0)
2427               ehc = call_get_eh_context ();
2428
2429             emit_move_insn (XEXP (reg, 0), ehc);
2430             insns = get_insns ();
2431             end_sequence ();
2432
2433             emit_insns_before (insns, insn);
2434           }
2435       }
2436 }
2437
2438 /* Scan the insn chain F and build a list of handler labels. The
2439    resulting list is placed in the global variable exception_handler_labels.  */
2440
2441 static void
2442 find_exception_handler_labels_1 (f)
2443      rtx f;
2444 {
2445   rtx insn;
2446
2447   /* For each start of a region, add its label to the list.  */
2448
2449   for (insn = f; insn; insn = NEXT_INSN (insn))
2450     {
2451       struct handler_info* ptr;
2452       if (GET_CODE (insn) == NOTE
2453           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
2454         {
2455           ptr = get_first_handler (NOTE_EH_HANDLER (insn));
2456           for ( ; ptr; ptr = ptr->next)
2457             {
2458               /* make sure label isn't in the list already */
2459               rtx x;
2460               for (x = exception_handler_labels; x; x = XEXP (x, 1))
2461                 if (XEXP (x, 0) == ptr->handler_label)
2462                   break;
2463               if (! x)
2464                 exception_handler_labels = gen_rtx_EXPR_LIST (VOIDmode,
2465                                ptr->handler_label, exception_handler_labels);
2466             }
2467         }
2468       else if (GET_CODE (insn) == CALL_INSN
2469                && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
2470         {
2471           find_exception_handler_labels_1 (XEXP (PATTERN (insn), 0));
2472           find_exception_handler_labels_1 (XEXP (PATTERN (insn), 1));
2473           find_exception_handler_labels_1 (XEXP (PATTERN (insn), 2));
2474         }
2475     }
2476 }
2477
2478 /* Scan the current insns and build a list of handler labels. The
2479    resulting list is placed in the global variable exception_handler_labels.
2480
2481    It is called after the last exception handling region is added to
2482    the current function (when the rtl is almost all built for the
2483    current function) and before the jump optimization pass.  */
2484 void
2485 find_exception_handler_labels ()
2486 {
2487   exception_handler_labels = NULL_RTX;
2488
2489   /* If we aren't doing exception handling, there isn't much to check.  */
2490   if (! doing_eh (0))
2491     return;
2492
2493   find_exception_handler_labels_1 (get_insns ());
2494 }
2495
2496 /* Return a value of 1 if the parameter label number is an exception handler
2497    label. Return 0 otherwise. */
2498
2499 int
2500 is_exception_handler_label (lab)
2501      int lab;
2502 {
2503   rtx x;
2504   for (x = exception_handler_labels ; x ; x = XEXP (x, 1))
2505     if (lab == CODE_LABEL_NUMBER (XEXP (x, 0)))
2506       return 1;
2507   return 0;
2508 }
2509
2510 /* Perform sanity checking on the exception_handler_labels list.
2511
2512    Can be called after find_exception_handler_labels is called to
2513    build the list of exception handlers for the current function and
2514    before we finish processing the current function.  */
2515
2516 void
2517 check_exception_handler_labels ()
2518 {
2519   rtx insn, insn2;
2520
2521   /* If we aren't doing exception handling, there isn't much to check.  */
2522   if (! doing_eh (0))
2523     return;
2524
2525   /* Make sure there is no more than 1 copy of a label */
2526   for (insn = exception_handler_labels; insn; insn = XEXP (insn, 1))
2527     {
2528       int count = 0;
2529       for (insn2 = exception_handler_labels; insn2; insn2 = XEXP (insn2, 1))
2530         if (XEXP (insn, 0) == XEXP (insn2, 0))
2531           count++;
2532       if (count != 1)
2533        warning ("Counted %d copies of EH region %d in list.\n", count,
2534                                         CODE_LABEL_NUMBER (insn));
2535     }
2536
2537 }
2538
2539 /* Mark the children of NODE for GC.  */
2540
2541 static void
2542 mark_eh_node (node)
2543      struct eh_node *node;
2544 {
2545   while (node)
2546     {
2547       if (node->entry)
2548         {
2549           ggc_mark_rtx (node->entry->outer_context);
2550           ggc_mark_rtx (node->entry->exception_handler_label);
2551           ggc_mark_tree (node->entry->finalization);
2552           ggc_mark_rtx (node->entry->false_label);
2553           ggc_mark_rtx (node->entry->rethrow_label);
2554         }
2555       node = node ->chain;
2556     }
2557 }
2558
2559 /* Mark S for GC.  */
2560
2561 static void
2562 mark_eh_stack (s)
2563      struct eh_stack *s;
2564 {
2565   if (s)
2566     mark_eh_node (s->top);
2567 }
2568
2569 /* Mark Q for GC.  */
2570
2571 static void
2572 mark_eh_queue (q)
2573      struct eh_queue *q;
2574 {
2575   while (q)
2576     {
2577       mark_eh_node (q->head);
2578       q = q->next;
2579     }
2580 }
2581
2582 /* Mark NODE for GC.  A label_node contains a union containing either
2583    a tree or an rtx.  This label_node will contain a tree.  */
2584
2585 static void
2586 mark_tree_label_node (node)
2587      struct label_node *node;
2588 {
2589   while (node)
2590     {
2591       ggc_mark_tree (node->u.tlabel);
2592       node = node->chain;
2593     }
2594 }
2595
2596 /* Mark EH for GC.  */
2597
2598 void
2599 mark_eh_status (eh)
2600      struct eh_status *eh;
2601 {
2602   if (eh == 0)
2603     return;
2604
2605   mark_eh_stack (&eh->x_ehstack);
2606   mark_eh_stack (&eh->x_catchstack);
2607   mark_eh_queue (eh->x_ehqueue);
2608   ggc_mark_rtx (eh->x_catch_clauses);
2609
2610   if (lang_mark_false_label_stack)
2611     (*lang_mark_false_label_stack) (eh->x_false_label_stack);
2612   mark_tree_label_node (eh->x_caught_return_label_stack);
2613
2614   ggc_mark_tree (eh->x_protect_list);
2615   ggc_mark_rtx (eh->ehc);
2616   ggc_mark_rtx (eh->x_eh_return_stub_label);
2617 }
2618
2619 /* Mark ARG (which is really a struct func_eh_entry**) for GC.  */
2620
2621 static void
2622 mark_func_eh_entry (arg)
2623      void *arg;
2624 {
2625   struct func_eh_entry *fee;
2626   struct handler_info *h;
2627   int i;
2628
2629   fee = *((struct func_eh_entry **) arg);
2630
2631   for (i = 0; i < current_func_eh_entry; ++i)
2632     {
2633       ggc_mark_rtx (fee->rethrow_label);
2634       for (h = fee->handlers; h; h = h->next)
2635         {
2636           ggc_mark_rtx (h->handler_label);
2637           if (h->type_info != CATCH_ALL_TYPE)
2638             ggc_mark_tree ((tree) h->type_info);
2639         }
2640
2641       /* Skip to the next entry in the array.  */
2642       ++fee;
2643     }
2644 }
2645
2646 /* This group of functions initializes the exception handling data
2647    structures at the start of the compilation, initializes the data
2648    structures at the start of a function, and saves and restores the
2649    exception handling data structures for the start/end of a nested
2650    function.  */
2651
2652 /* Toplevel initialization for EH things.  */
2653
2654 void
2655 init_eh ()
2656 {
2657   first_rethrow_symbol = create_rethrow_ref (0);
2658   final_rethrow = gen_exception_label ();
2659   last_rethrow_symbol = create_rethrow_ref (CODE_LABEL_NUMBER (final_rethrow));
2660
2661   ggc_add_rtx_root (&exception_handler_labels, 1);
2662   ggc_add_rtx_root (&eh_return_context, 1);
2663   ggc_add_rtx_root (&eh_return_stack_adjust, 1);
2664   ggc_add_rtx_root (&eh_return_handler, 1);
2665   ggc_add_rtx_root (&first_rethrow_symbol, 1);
2666   ggc_add_rtx_root (&final_rethrow, 1);
2667   ggc_add_rtx_root (&last_rethrow_symbol, 1);
2668   ggc_add_root (&function_eh_regions, 1, sizeof (function_eh_regions),
2669                 mark_func_eh_entry);
2670 }
2671
2672 /* Initialize the per-function EH information.  */
2673
2674 void
2675 init_eh_for_function ()
2676 {
2677   cfun->eh = (struct eh_status *) xcalloc (1, sizeof (struct eh_status));
2678   ehqueue = (struct eh_queue *) xcalloc (1, sizeof (struct eh_queue));
2679   eh_return_context = NULL_RTX;
2680   eh_return_stack_adjust = NULL_RTX;
2681   eh_return_handler = NULL_RTX;
2682 }
2683
2684 void
2685 free_eh_status (f)
2686      struct function *f;
2687 {
2688   free (f->eh->x_ehqueue);
2689   free (f->eh);
2690   f->eh = NULL;
2691 }
2692 \f
2693 /* This section is for the exception handling specific optimization
2694    pass.  */
2695
2696 /* Determine if the given INSN can throw an exception.  */
2697
2698 int
2699 can_throw (insn)
2700      rtx insn;
2701 {
2702   if (GET_CODE (insn) == INSN
2703       && GET_CODE (PATTERN (insn)) == SEQUENCE)
2704     insn = XVECEXP (PATTERN (insn), 0, 0);
2705
2706   /* Calls can always potentially throw exceptions, unless they have
2707      a REG_EH_REGION note with a value of 0 or less.  */
2708   if (GET_CODE (insn) == CALL_INSN)
2709     {
2710       rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
2711       if (!note || INTVAL (XEXP (note, 0)) > 0)
2712         return 1;
2713     }
2714
2715   if (asynchronous_exceptions)
2716     {
2717       /* If we wanted asynchronous exceptions, then everything but NOTEs
2718          and CODE_LABELs could throw.  */
2719       if (GET_CODE (insn) != NOTE && GET_CODE (insn) != CODE_LABEL)
2720         return 1;
2721     }
2722
2723   return 0;
2724 }
2725
2726 /* Return nonzero if nothing in this function can throw.  */
2727
2728 int
2729 nothrow_function_p ()
2730 {
2731   rtx insn;
2732
2733   if (! flag_exceptions)
2734     return 1;
2735
2736   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2737     if (can_throw (insn))
2738       return 0;
2739   for (insn = current_function_epilogue_delay_list; insn;
2740        insn = XEXP (insn, 1))
2741     if (can_throw (insn))
2742       return 0;
2743
2744   return 1;
2745 }
2746
2747 /* Scan a exception region looking for the matching end and then
2748    remove it if possible. INSN is the start of the region, N is the
2749    region number, and DELETE_OUTER is to note if anything in this
2750    region can throw.
2751
2752    Regions are removed if they cannot possibly catch an exception.
2753    This is determined by invoking can_throw on each insn within the
2754    region; if can_throw returns true for any of the instructions, the
2755    region can catch an exception, since there is an insn within the
2756    region that is capable of throwing an exception.
2757
2758    Returns the NOTE_INSN_EH_REGION_END corresponding to this region, or
2759    calls abort if it can't find one.
2760
2761    Can abort if INSN is not a NOTE_INSN_EH_REGION_BEGIN, or if N doesn't
2762    correspond to the region number, or if DELETE_OUTER is NULL.  */
2763
2764 static rtx
2765 scan_region (insn, n, delete_outer)
2766      rtx insn;
2767      int n;
2768      int *delete_outer;
2769 {
2770   rtx start = insn;
2771
2772   /* Assume we can delete the region.  */
2773   int delete = 1;
2774
2775   /* Can't delete something which is rethrown from. */
2776   if (rethrow_used (n))
2777     delete = 0;
2778
2779   if (insn == NULL_RTX
2780       || GET_CODE (insn) != NOTE
2781       || NOTE_LINE_NUMBER (insn) != NOTE_INSN_EH_REGION_BEG
2782       || NOTE_EH_HANDLER (insn) != n
2783       || delete_outer == NULL)
2784     abort ();
2785
2786   insn = NEXT_INSN (insn);
2787
2788   /* Look for the matching end.  */
2789   while (! (GET_CODE (insn) == NOTE
2790             && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END))
2791     {
2792       /* If anything can throw, we can't remove the region.  */
2793       if (delete && can_throw (insn))
2794         {
2795           delete = 0;
2796         }
2797
2798       /* Watch out for and handle nested regions.  */
2799       if (GET_CODE (insn) == NOTE
2800           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
2801         {
2802           insn = scan_region (insn, NOTE_EH_HANDLER (insn), &delete);
2803         }
2804
2805       insn = NEXT_INSN (insn);
2806     }
2807
2808   /* The _BEG/_END NOTEs must match and nest.  */
2809   if (NOTE_EH_HANDLER (insn) != n)
2810     abort ();
2811
2812   /* If anything in this exception region can throw, we can throw.  */
2813   if (! delete)
2814     *delete_outer = 0;
2815   else
2816     {
2817       /* Delete the start and end of the region.  */
2818       delete_insn (start);
2819       delete_insn (insn);
2820
2821 /* We no longer removed labels here, since flow will now remove any
2822    handler which cannot be called any more. */
2823
2824 #if 0
2825       /* Only do this part if we have built the exception handler
2826          labels.  */
2827       if (exception_handler_labels)
2828         {
2829           rtx x, *prev = &exception_handler_labels;
2830
2831           /* Find it in the list of handlers.  */
2832           for (x = exception_handler_labels; x; x = XEXP (x, 1))
2833             {
2834               rtx label = XEXP (x, 0);
2835               if (CODE_LABEL_NUMBER (label) == n)
2836                 {
2837                   /* If we are the last reference to the handler,
2838                      delete it.  */
2839                   if (--LABEL_NUSES (label) == 0)
2840                     delete_insn (label);
2841
2842                   if (optimize)
2843                     {
2844                       /* Remove it from the list of exception handler
2845                          labels, if we are optimizing.  If we are not, then
2846                          leave it in the list, as we are not really going to
2847                          remove the region.  */
2848                       *prev = XEXP (x, 1);
2849                       XEXP (x, 1) = 0;
2850                       XEXP (x, 0) = 0;
2851                     }
2852
2853                   break;
2854                 }
2855               prev = &XEXP (x, 1);
2856             }
2857         }
2858 #endif
2859     }
2860   return insn;
2861 }
2862
2863 /* Perform various interesting optimizations for exception handling
2864    code.
2865
2866    We look for empty exception regions and make them go (away). The
2867    jump optimization code will remove the handler if nothing else uses
2868    it.  */
2869
2870 void
2871 exception_optimize ()
2872 {
2873   rtx insn;
2874   int n;
2875
2876   /* Remove empty regions.  */
2877   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2878     {
2879       if (GET_CODE (insn) == NOTE
2880           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
2881         {
2882           /* Since scan_region will return the NOTE_INSN_EH_REGION_END
2883              insn, we will indirectly skip through all the insns
2884              inbetween. We are also guaranteed that the value of insn
2885              returned will be valid, as otherwise scan_region won't
2886              return.  */
2887           insn = scan_region (insn, NOTE_EH_HANDLER (insn), &n);
2888         }
2889     }
2890 }
2891
2892 /* This function determines whether the rethrow labels for any of the
2893    exception regions in the current function are used or not, and set
2894    the reference flag according.  */
2895
2896 void
2897 update_rethrow_references ()
2898 {
2899   rtx insn;
2900   int x, region;
2901   int *saw_region, *saw_rethrow;
2902
2903   if (!flag_new_exceptions)
2904     return;
2905
2906   saw_region = (int *) xcalloc (current_func_eh_entry, sizeof (int));
2907   saw_rethrow = (int *) xcalloc (current_func_eh_entry, sizeof (int));
2908
2909   /* Determine what regions exist, and whether there are any rethrows
2910      from those regions or not.  */
2911   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2912     if (GET_CODE (insn) == CALL_INSN)
2913       {
2914         rtx note = find_reg_note (insn, REG_EH_RETHROW, NULL_RTX);
2915         if (note)
2916           {
2917             region = eh_region_from_symbol (XEXP (note, 0));
2918             region = find_func_region  (region);
2919             saw_rethrow[region] = 1;
2920           }
2921       }
2922     else
2923       if (GET_CODE (insn) == NOTE)
2924         {
2925           if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
2926             {
2927               region = find_func_region (NOTE_EH_HANDLER (insn));
2928               saw_region[region] = 1;
2929             }
2930         }
2931
2932   /* For any regions we did see, set the referenced flag.  */
2933   for (x = 0; x < current_func_eh_entry; x++)
2934     if (saw_region[x])
2935       function_eh_regions[x].rethrow_ref = saw_rethrow[x];
2936
2937   /* Clean up.  */
2938   free (saw_region);
2939   free (saw_rethrow);
2940 }
2941 \f
2942 /* Various hooks for the DWARF 2 __throw routine.  */
2943
2944 /* Do any necessary initialization to access arbitrary stack frames.
2945    On the SPARC, this means flushing the register windows.  */
2946
2947 void
2948 expand_builtin_unwind_init ()
2949 {
2950   /* Set this so all the registers get saved in our frame; we need to be
2951      able to copy the saved values for any registers from frames we unwind. */
2952   current_function_has_nonlocal_label = 1;
2953
2954 #ifdef SETUP_FRAME_ADDRESSES
2955   SETUP_FRAME_ADDRESSES ();
2956 #endif
2957 }
2958
2959 /* Given a value extracted from the return address register or stack slot,
2960    return the actual address encoded in that value.  */
2961
2962 rtx
2963 expand_builtin_extract_return_addr (addr_tree)
2964      tree addr_tree;
2965 {
2966   rtx addr = expand_expr (addr_tree, NULL_RTX, Pmode, 0);
2967   return eh_outer_context (addr);
2968 }
2969
2970 /* Given an actual address in addr_tree, do any necessary encoding
2971    and return the value to be stored in the return address register or
2972    stack slot so the epilogue will return to that address.  */
2973
2974 rtx
2975 expand_builtin_frob_return_addr (addr_tree)
2976      tree addr_tree;
2977 {
2978   rtx addr = expand_expr (addr_tree, NULL_RTX, Pmode, 0);
2979 #ifdef RETURN_ADDR_OFFSET
2980   addr = plus_constant (addr, -RETURN_ADDR_OFFSET);
2981 #endif
2982   return addr;
2983 }
2984
2985 /* Choose three registers for communication between the main body of
2986    __throw and the epilogue (or eh stub) and the exception handler.
2987    We must do this with hard registers because the epilogue itself
2988    will be generated after reload, at which point we may not reference
2989    pseudos at all.
2990
2991    The first passes the exception context to the handler.  For this
2992    we use the return value register for a void*.
2993
2994    The second holds the stack pointer value to be restored.  For this
2995    we use the static chain register if it exists, is different from
2996    the previous, and is call-clobbered; otherwise some arbitrary
2997    call-clobbered register.
2998
2999    The third holds the address of the handler itself.  Here we use
3000    some arbitrary call-clobbered register.  */
3001
3002 static void
3003 eh_regs (pcontext, psp, pra, outgoing)
3004      rtx *pcontext, *psp, *pra;
3005      int outgoing ATTRIBUTE_UNUSED;
3006 {
3007   rtx rcontext, rsp, rra;
3008   unsigned int i;
3009
3010 #ifdef FUNCTION_OUTGOING_VALUE
3011   if (outgoing)
3012     rcontext = FUNCTION_OUTGOING_VALUE (build_pointer_type (void_type_node),
3013                                         current_function_decl);
3014   else
3015 #endif
3016     rcontext = FUNCTION_VALUE (build_pointer_type (void_type_node),
3017                                current_function_decl);
3018
3019 #ifdef STATIC_CHAIN_REGNUM
3020   if (outgoing)
3021     rsp = static_chain_incoming_rtx;
3022   else
3023     rsp = static_chain_rtx;
3024   if (REGNO (rsp) == REGNO (rcontext)
3025       || ! call_used_regs [REGNO (rsp)])
3026 #endif /* STATIC_CHAIN_REGNUM */
3027     rsp = NULL_RTX;
3028
3029   if (rsp == NULL_RTX)
3030     {
3031       for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
3032         if (call_used_regs[i] && ! fixed_regs[i] && i != REGNO (rcontext))
3033           break;
3034       if (i == FIRST_PSEUDO_REGISTER)
3035         abort();
3036
3037       rsp = gen_rtx_REG (Pmode, i);
3038     }
3039
3040   for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
3041     if (call_used_regs[i] && ! fixed_regs[i]
3042         && i != REGNO (rcontext) && i != REGNO (rsp))
3043       break;
3044   if (i == FIRST_PSEUDO_REGISTER)
3045     abort();
3046
3047   rra = gen_rtx_REG (Pmode, i);
3048
3049   *pcontext = rcontext;
3050   *psp = rsp;
3051   *pra = rra;
3052 }
3053
3054 /* Retrieve the register which contains the pointer to the eh_context
3055    structure set the __throw. */
3056
3057 #if 0
3058 rtx
3059 get_reg_for_handler ()
3060 {
3061   rtx reg1;
3062   reg1 = FUNCTION_VALUE (build_pointer_type (void_type_node),
3063                            current_function_decl);
3064   return reg1;
3065 }
3066 #endif
3067
3068 /* Set up the epilogue with the magic bits we'll need to return to the
3069    exception handler.  */
3070
3071 void
3072 expand_builtin_eh_return (context, stack, handler)
3073     tree context, stack, handler;
3074 {
3075   if (eh_return_context)
3076     error("Duplicate call to __builtin_eh_return");
3077
3078   eh_return_context
3079     = copy_to_reg (expand_expr (context, NULL_RTX, VOIDmode, 0));
3080   eh_return_stack_adjust
3081     = copy_to_reg (expand_expr (stack, NULL_RTX, VOIDmode, 0));
3082   eh_return_handler
3083     = copy_to_reg (expand_expr (handler, NULL_RTX, VOIDmode, 0));
3084 }
3085
3086 void
3087 expand_eh_return ()
3088 {
3089   rtx reg1, reg2, reg3;
3090   rtx stub_start, after_stub;
3091   rtx ra, tmp;
3092
3093   if (!eh_return_context)
3094     return;
3095
3096   current_function_cannot_inline = N_("function uses __builtin_eh_return");
3097
3098   eh_regs (&reg1, &reg2, &reg3, 1);
3099 #ifdef POINTERS_EXTEND_UNSIGNED
3100   eh_return_context = convert_memory_address (Pmode, eh_return_context);
3101   eh_return_stack_adjust =
3102       convert_memory_address (Pmode, eh_return_stack_adjust);
3103   eh_return_handler = convert_memory_address (Pmode, eh_return_handler);
3104 #endif
3105   emit_move_insn (reg1, eh_return_context);
3106   emit_move_insn (reg2, eh_return_stack_adjust);
3107   emit_move_insn (reg3, eh_return_handler);
3108
3109   /* Talk directly to the target's epilogue code when possible.  */
3110
3111 #ifdef HAVE_eh_epilogue
3112   if (HAVE_eh_epilogue)
3113     {
3114       emit_insn (gen_eh_epilogue (reg1, reg2, reg3));
3115       return;
3116     }
3117 #endif
3118
3119   /* Otherwise, use the same stub technique we had before.  */
3120
3121   eh_return_stub_label = stub_start = gen_label_rtx ();
3122   after_stub = gen_label_rtx ();
3123
3124   /* Set the return address to the stub label.  */
3125
3126   ra = expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
3127                                    0, hard_frame_pointer_rtx);
3128   if (GET_CODE (ra) == REG && REGNO (ra) >= FIRST_PSEUDO_REGISTER)
3129     abort();
3130
3131   tmp = memory_address (Pmode, gen_rtx_LABEL_REF (Pmode, stub_start));
3132 #ifdef RETURN_ADDR_OFFSET
3133   tmp = plus_constant (tmp, -RETURN_ADDR_OFFSET);
3134 #endif
3135   tmp = force_operand (tmp, ra);
3136   if (tmp != ra)
3137     emit_move_insn (ra, tmp);
3138
3139   /* Indicate that the registers are in fact used.  */
3140   emit_insn (gen_rtx_USE (VOIDmode, reg1));
3141   emit_insn (gen_rtx_USE (VOIDmode, reg2));
3142   emit_insn (gen_rtx_USE (VOIDmode, reg3));
3143   if (GET_CODE (ra) == REG)
3144     emit_insn (gen_rtx_USE (VOIDmode, ra));
3145
3146   /* Generate the stub.  */
3147
3148   emit_jump (after_stub);
3149   emit_label (stub_start);
3150
3151   eh_regs (&reg1, &reg2, &reg3, 0);
3152   adjust_stack (reg2);
3153   emit_indirect_jump (reg3);
3154
3155   emit_label (after_stub);
3156 }
3157 \f
3158
3159 /* This contains the code required to verify whether arbitrary instructions
3160    are in the same exception region. */
3161
3162 static int *insn_eh_region = (int *)0;
3163 static int maximum_uid;
3164
3165 static void
3166 set_insn_eh_region (first, region_num)
3167      rtx *first;
3168      int region_num;
3169 {
3170   rtx insn;
3171   int rnum;
3172
3173   for (insn = *first; insn; insn = NEXT_INSN (insn))
3174     {
3175       if ((GET_CODE (insn) == NOTE)
3176           && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG))
3177         {
3178           rnum = NOTE_EH_HANDLER (insn);
3179           insn_eh_region[INSN_UID (insn)] =  rnum;
3180           insn = NEXT_INSN (insn);
3181           set_insn_eh_region (&insn, rnum);
3182           /* Upon return, insn points to the EH_REGION_END of nested region */
3183           continue;
3184         }
3185       insn_eh_region[INSN_UID (insn)] = region_num;
3186       if ((GET_CODE (insn) == NOTE) &&
3187             (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END))
3188         break;
3189     }
3190   *first = insn;
3191 }
3192
3193 /* Free the insn table, an make sure it cannot be used again. */
3194
3195 void
3196 free_insn_eh_region ()
3197 {
3198   if (!doing_eh (0))
3199     return;
3200
3201   if (insn_eh_region)
3202     {
3203       free (insn_eh_region);
3204       insn_eh_region = (int *)0;
3205     }
3206 }
3207
3208 /* Initialize the table. max_uid must be calculated and handed into
3209    this routine. If it is unavailable, passing a value of 0 will
3210    cause this routine to calculate it as well. */
3211
3212 void
3213 init_insn_eh_region (first, max_uid)
3214      rtx first;
3215      int max_uid;
3216 {
3217   rtx insn;
3218
3219   if (!doing_eh (0))
3220     return;
3221
3222   if (insn_eh_region)
3223     free_insn_eh_region();
3224
3225   if (max_uid == 0)
3226     for (insn = first; insn; insn = NEXT_INSN (insn))
3227       if (INSN_UID (insn) > max_uid)       /* find largest UID */
3228         max_uid = INSN_UID (insn);
3229
3230   maximum_uid = max_uid;
3231   insn_eh_region = (int *) xmalloc ((max_uid + 1) * sizeof (int));
3232   insn = first;
3233   set_insn_eh_region (&insn, 0);
3234 }
3235
3236
3237 /* Check whether 2 instructions are within the same region. */
3238
3239 int
3240 in_same_eh_region (insn1, insn2)
3241      rtx insn1, insn2;
3242 {
3243   int ret, uid1, uid2;
3244
3245   /* If no exceptions, instructions are always in same region. */
3246   if (!doing_eh (0))
3247     return 1;
3248
3249   /* If the table isn't allocated, assume the worst. */
3250   if (!insn_eh_region)
3251     return 0;
3252
3253   uid1 = INSN_UID (insn1);
3254   uid2 = INSN_UID (insn2);
3255
3256   /* if instructions have been allocated beyond the end, either
3257      the table is out of date, or this is a late addition, or
3258      something... Assume the worst. */
3259   if (uid1 > maximum_uid || uid2 > maximum_uid)
3260     return 0;
3261
3262   ret = (insn_eh_region[uid1] == insn_eh_region[uid2]);
3263   return ret;
3264 }
3265 \f
3266
3267 /* This function will initialize the handler list for a specified block.
3268    It may recursively call itself if the outer block hasn't been processed
3269    yet.  At some point in the future we can trim out handlers which we
3270    know cannot be called. (ie, if a block has an INT type handler,
3271    control will never be passed to an outer INT type handler).  */
3272
3273 static void
3274 process_nestinfo (block, info, nested_eh_region)
3275      int block;
3276      eh_nesting_info *info;
3277      int *nested_eh_region;
3278 {
3279   handler_info *ptr, *last_ptr = NULL;
3280   int x, y, count = 0;
3281   int extra = 0;
3282   handler_info **extra_handlers = 0;
3283   int index = info->region_index[block];
3284
3285   /* If we've already processed this block, simply return. */
3286   if (info->num_handlers[index] > 0)
3287     return;
3288
3289   for (ptr = get_first_handler (block); ptr; last_ptr = ptr, ptr = ptr->next)
3290     count++;
3291
3292  /* pick up any information from the next outer region.  It will already
3293     contain a summary of itself and all outer regions to it.  */
3294
3295   if (nested_eh_region [block] != 0)
3296     {
3297       int nested_index = info->region_index[nested_eh_region[block]];
3298       process_nestinfo (nested_eh_region[block], info, nested_eh_region);
3299       extra = info->num_handlers[nested_index];
3300       extra_handlers = info->handlers[nested_index];
3301       info->outer_index[index] = nested_index;
3302     }
3303
3304   /* If the last handler is either a CATCH_ALL or a cleanup, then we
3305      won't use the outer ones since we know control will not go past the
3306      catch-all or cleanup.  */
3307
3308   if (last_ptr != NULL && (last_ptr->type_info == NULL
3309                            || last_ptr->type_info == CATCH_ALL_TYPE))
3310     extra = 0;
3311
3312   info->num_handlers[index] = count + extra;
3313   info->handlers[index] = (handler_info **) xmalloc ((count + extra)
3314                                                     * sizeof (handler_info **));
3315
3316   /* First put all our handlers into the list.  */
3317   ptr = get_first_handler (block);
3318   for (x = 0; x < count; x++)
3319     {
3320       info->handlers[index][x] = ptr;
3321       ptr = ptr->next;
3322     }
3323
3324   /* Now add all the outer region handlers, if they aren't they same as
3325      one of the types in the current block.  We won't worry about
3326      derived types yet, we'll just look for the exact type.  */
3327   for (y =0, x = 0; x < extra ; x++)
3328     {
3329       int i, ok;
3330       ok = 1;
3331       /* Check to see if we have a type duplication.  */
3332       for (i = 0; i < count; i++)
3333         if (info->handlers[index][i]->type_info == extra_handlers[x]->type_info)
3334           {
3335             ok = 0;
3336             /* Record one less handler.  */
3337             (info->num_handlers[index])--;
3338             break;
3339           }
3340       if (ok)
3341         {
3342           info->handlers[index][y + count] = extra_handlers[x];
3343           y++;
3344         }
3345     }
3346 }
3347
3348 /* This function will allocate and initialize an eh_nesting_info structure.
3349    It returns a pointer to the completed data structure.  If there are
3350    no exception regions, a NULL value is returned.  */
3351
3352 eh_nesting_info *
3353 init_eh_nesting_info ()
3354 {
3355   int *nested_eh_region;
3356   int region_count = 0;
3357   rtx eh_note = NULL_RTX;
3358   eh_nesting_info *info;
3359   rtx insn;
3360   int x;
3361
3362   if (! flag_exceptions)
3363     return 0;
3364
3365   info = (eh_nesting_info *) xmalloc (sizeof (eh_nesting_info));
3366   info->region_index = (int *) xcalloc ((max_label_num () + 1), sizeof (int));
3367   nested_eh_region = (int *) xcalloc (max_label_num () + 1, sizeof (int));
3368
3369   /* Create the nested_eh_region list.  If indexed with a block number, it
3370      returns the block number of the next outermost region, if any.
3371      We can count the number of regions and initialize the region_index
3372      vector at the same time.  */
3373   for (insn = get_insns(); insn; insn = NEXT_INSN (insn))
3374     {
3375       if (GET_CODE (insn) == NOTE)
3376         {
3377           if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
3378             {
3379               int block = NOTE_EH_HANDLER (insn);
3380               region_count++;
3381               info->region_index[block] = region_count;
3382               if (eh_note)
3383                 nested_eh_region [block] =
3384                                      NOTE_EH_HANDLER (XEXP (eh_note, 0));
3385               else
3386                 nested_eh_region [block] = 0;
3387               eh_note = gen_rtx_EXPR_LIST (VOIDmode, insn, eh_note);
3388             }
3389           else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END)
3390             eh_note = XEXP (eh_note, 1);
3391         }
3392     }
3393
3394   /* If there are no regions, wrap it up now.  */
3395   if (region_count == 0)
3396     {
3397       free (info->region_index);
3398       free (info);
3399       free (nested_eh_region);
3400       return NULL;
3401     }
3402
3403   region_count++;
3404   info->handlers = (handler_info ***) xcalloc (region_count,
3405                                                sizeof (handler_info ***));
3406   info->num_handlers = (int *) xcalloc (region_count, sizeof (int));
3407   info->outer_index = (int *) xcalloc (region_count, sizeof (int));
3408
3409  /* Now initialize the handler lists for all exception blocks.  */
3410   for (x = 0; x <= max_label_num (); x++)
3411     {
3412       if (info->region_index[x] != 0)
3413         process_nestinfo (x, info, nested_eh_region);
3414     }
3415   info->region_count = region_count;
3416
3417   /* Clean up.  */
3418   free (nested_eh_region);
3419
3420   return info;
3421 }
3422
3423
3424 /* This function is used to retreive the vector of handlers which
3425    can be reached by a given insn in a given exception region.
3426    BLOCK is the exception block the insn is in.
3427    INFO is the eh_nesting_info structure.
3428    INSN is the (optional) insn within the block.  If insn is not NULL_RTX,
3429    it may contain reg notes which modify its throwing behavior, and
3430    these will be obeyed.  If NULL_RTX is passed, then we simply return the
3431    handlers for block.
3432    HANDLERS is the address of a pointer to a vector of handler_info pointers.
3433    Upon return, this will have the handlers which can be reached by block.
3434    This function returns the number of elements in the handlers vector.  */
3435
3436 int
3437 reachable_handlers (block, info, insn, handlers)
3438      int block;
3439      eh_nesting_info *info;
3440      rtx insn ;
3441      handler_info ***handlers;
3442 {
3443   int index = 0;
3444   *handlers = NULL;
3445
3446   if (info == NULL)
3447     return 0;
3448   if (block > 0)
3449     index = info->region_index[block];
3450
3451   if (insn && GET_CODE (insn) == CALL_INSN)
3452     {
3453       /* RETHROWs specify a region number from which we are going to rethrow.
3454          This means we won't pass control to handlers in the specified
3455          region, but rather any region OUTSIDE the specified region.
3456          We accomplish this by setting block to the outer_index of the
3457          specified region.  */
3458       rtx note = find_reg_note (insn, REG_EH_RETHROW, NULL_RTX);
3459       if (note)
3460         {
3461           index = eh_region_from_symbol (XEXP (note, 0));
3462           index = info->region_index[index];
3463           if (index)
3464             index = info->outer_index[index];
3465         }
3466       else
3467         {
3468           /* If there is no rethrow, we look for a REG_EH_REGION, and
3469              we'll throw from that block.  A value of 0 or less
3470              indicates that this insn cannot throw.  */
3471           note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
3472           if (note)
3473             {
3474               int b = INTVAL (XEXP (note, 0));
3475               if (b <= 0)
3476                 index = 0;
3477               else
3478                 index = info->region_index[b];
3479             }
3480         }
3481     }
3482   /* If we reach this point, and index is 0, there is no throw.  */
3483   if (index == 0)
3484     return 0;
3485
3486   *handlers = info->handlers[index];
3487   return info->num_handlers[index];
3488 }
3489
3490
3491 /* This function will free all memory associated with the eh_nesting info.  */
3492
3493 void
3494 free_eh_nesting_info (info)
3495      eh_nesting_info *info;
3496 {
3497   int x;
3498   if (info != NULL)
3499     {
3500       if (info->region_index)
3501         free (info->region_index);
3502       if (info->num_handlers)
3503         free (info->num_handlers);
3504       if (info->outer_index)
3505         free (info->outer_index);
3506       if (info->handlers)
3507         {
3508           for (x = 0; x < info->region_count; x++)
3509             if (info->handlers[x])
3510               free (info->handlers[x]);
3511           free (info->handlers);
3512         }
3513       free (info);
3514     }
3515 }