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