gcc/except.c

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