gcc/except.c

   1 /* Implements exception handling.
   2    Copyright (C) 1989, 92-97, 1998 Free Software Foundation, Inc.
   3    Contributed by Mike Stump <mrs@cygnus.com>.
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22
  23 /* An exception is an event that can be signaled from within a
  24    function. This event can then be "caught" or "trapped" by the
  25    callers of this function. This potentially allows program flow to
  26    be transferred to any arbitrary code associated with a function call
  27    several levels up the stack.
  28
  29    The intended use for this mechanism is for signaling "exceptional
  30    events" in an out-of-band fashion, hence its name. The C++ language
  31    (and many other OO-styled or functional languages) practically
  32    requires such a mechanism, as otherwise it becomes very difficult
  33    or even impossible to signal failure conditions in complex
  34    situations.  The traditional C++ example is when an error occurs in
  35    the process of constructing an object; without such a mechanism, it
  36    is impossible to signal that the error occurs without adding global
  37    state variables and error checks around every object construction.
  38
  39    The act of causing this event to occur is referred to as "throwing
  40    an exception". (Alternate terms include "raising an exception" or
  41    "signaling an exception".) The term "throw" is used because control
  42    is returned to the callers of the function that is signaling the
  43    exception, and thus there is the concept of "throwing" the
  44    exception up the call stack.
  45
  46    There are two major codegen options for exception handling.  The
  47    flag -fsjlj-exceptions can be used to select the setjmp/longjmp
  48    approach, which is the default.  -fno-sjlj-exceptions can be used to
  49    get the PC range table approach.  While this is a compile time
  50    flag, an entire application must be compiled with the same codegen
  51    option.  The first is a PC range table approach, the second is a
  52    setjmp/longjmp based scheme.  We will first discuss the PC range
  53    table approach, after that, we will discuss the setjmp/longjmp
  54    based approach.
  55
  56    It is appropriate to speak of the "context of a throw". This
  57    context refers to the address where the exception is thrown from,
  58    and is used to determine which exception region will handle the
  59    exception.
  60
  61    Regions of code within a function can be marked such that if it
  62    contains the context of a throw, control will be passed to a
  63    designated "exception handler". These areas are known as "exception
  64    regions".  Exception regions cannot overlap, but they can be nested
  65    to any arbitrary depth. Also, exception regions cannot cross
  66    function boundaries.
  67
  68    Exception handlers can either be specified by the user (which we
  69    will call a "user-defined handler") or generated by the compiler
  70    (which we will designate as a "cleanup"). Cleanups are used to
  71    perform tasks such as destruction of objects allocated on the
  72    stack.
  73
  74    In the current implementation, cleanups are handled by allocating an
  75    exception region for the area that the cleanup is designated for,
  76    and the handler for the region performs the cleanup and then
  77    rethrows the exception to the outer exception region. From the
  78    standpoint of the current implementation, there is little
  79    distinction made between a cleanup and a user-defined handler, and
  80    the phrase "exception handler" can be used to refer to either one
  81    equally well. (The section "Future Directions" below discusses how
  82    this will change).
  83
  84    Each object file that is compiled with exception handling contains
  85    a static array of exception handlers named __EXCEPTION_TABLE__.
  86    Each entry contains the starting and ending addresses of the
  87    exception region, and the address of the handler designated for
  88    that region.
  89
  90    If the target does not use the DWARF 2 frame unwind information, at
  91    program startup each object file invokes a function named
  92    __register_exceptions with the address of its local
  93    __EXCEPTION_TABLE__. __register_exceptions is defined in libgcc2.c, and
  94    is responsible for recording all of the exception regions into one list
  95    (which is kept in a static variable named exception_table_list).
  96
  97    On targets that support crtstuff.c, the unwind information
  98    is stored in a section named .eh_frame and the information for the
  99    entire shared object or program is registered with a call to
 100    __register_frame_info.  On other targets, the information for each
 101    translation unit is registered from the file generated by collect2.
 102    __register_frame_info is defined in frame.c, and is responsible for
 103    recording all of the unwind regions into one list (which is kept in a
 104    static variable named unwind_table_list).
 105
 106    The function __throw is actually responsible for doing the
 107    throw. On machines that have unwind info support, __throw is generated
 108    by code in libgcc2.c, otherwise __throw is generated on a
 109    per-object-file basis for each source file compiled with
 110    -fexceptions by the C++ frontend.  Before __throw is invoked,
 111    the current context of the throw needs to be placed in the global
 112    variable __eh_pc.
 113
 114    __throw attempts to find the appropriate exception handler for the
 115    PC value stored in __eh_pc by calling __find_first_exception_table_match
 116    (which is defined in libgcc2.c). If __find_first_exception_table_match
 117    finds a relevant handler, __throw transfers control directly to it.
 118
 119    If a handler for the context being thrown from can't be found, __throw
 120    walks (see Walking the stack below) the stack up the dynamic call chain to
 121    continue searching for an appropriate exception handler based upon the
 122    caller of the function it last sought a exception handler for.  It stops
 123    then either an exception handler is found, or when the top of the
 124    call chain is reached.
 125
 126    If no handler is found, an external library function named
 127    __terminate is called.  If a handler is found, then we restart
 128    our search for a handler at the end of the call chain, and repeat
 129    the search process, but instead of just walking up the call chain,
 130    we unwind the call chain as we walk up it.
 131
 132    Internal implementation details:
 133
 134    To associate a user-defined handler with a block of statements, the
 135    function expand_start_try_stmts is used to mark the start of the
 136    block of statements with which the handler is to be associated
 137    (which is known as a "try block"). All statements that appear
 138    afterwards will be associated with the try block.
 139
 140    A call to expand_start_all_catch marks the end of the try block,
 141    and also marks the start of the "catch block" (the user-defined
 142    handler) associated with the try block.
 143
 144    This user-defined handler will be invoked for *every* exception
 145    thrown with the context of the try block. It is up to the handler
 146    to decide whether or not it wishes to handle any given exception,
 147    as there is currently no mechanism in this implementation for doing
 148    this. (There are plans for conditionally processing an exception
 149    based on its "type", which will provide a language-independent
 150    mechanism).
 151
 152    If the handler chooses not to process the exception (perhaps by
 153    looking at an "exception type" or some other additional data
 154    supplied with the exception), it can fall through to the end of the
 155    handler. expand_end_all_catch and expand_leftover_cleanups
 156    add additional code to the end of each handler to take care of
 157    rethrowing to the outer exception handler.
 158
 159    The handler also has the option to continue with "normal flow of
 160    code", or in other words to resume executing at the statement
 161    immediately after the end of the exception region. The variable
 162    caught_return_label_stack contains a stack of labels, and jumping
 163    to the topmost entry's label via expand_goto will resume normal
 164    flow to the statement immediately after the end of the exception
 165    region. If the handler falls through to the end, the exception will
 166    be rethrown to the outer exception region.
 167
 168    The instructions for the catch block are kept as a separate
 169    sequence, and will be emitted at the end of the function along with
 170    the handlers specified via expand_eh_region_end. The end of the
 171    catch block is marked with expand_end_all_catch.
 172
 173    Any data associated with the exception must currently be handled by
 174    some external mechanism maintained in the frontend.  For example,
 175    the C++ exception mechanism passes an arbitrary value along with
 176    the exception, and this is handled in the C++ frontend by using a
 177    global variable to hold the value. (This will be changing in the
 178    future.)
 179
 180    The mechanism in C++ for handling data associated with the
 181    exception is clearly not thread-safe. For a thread-based
 182    environment, another mechanism must be used (possibly using a
 183    per-thread allocation mechanism if the size of the area that needs
 184    to be allocated isn't known at compile time.)
 185
 186    Internally-generated exception regions (cleanups) are marked by
 187    calling expand_eh_region_start to mark the start of the region,
 188    and expand_eh_region_end (handler) is used to both designate the
 189    end of the region and to associate a specified handler/cleanup with
 190    the region. The rtl code in HANDLER will be invoked whenever an
 191    exception occurs in the region between the calls to
 192    expand_eh_region_start and expand_eh_region_end. After HANDLER is
 193    executed, additional code is emitted to handle rethrowing the
 194    exception to the outer exception handler. The code for HANDLER will
 195    be emitted at the end of the function.
 196
 197    TARGET_EXPRs can also be used to designate exception regions. A
 198    TARGET_EXPR gives an unwind-protect style interface commonly used
 199    in functional languages such as LISP. The associated expression is
 200    evaluated, and whether or not it (or any of the functions that it
 201    calls) throws an exception, the protect expression is always
 202    invoked. This implementation takes care of the details of
 203    associating an exception table entry with the expression and
 204    generating the necessary code (it actually emits the protect
 205    expression twice, once for normal flow and once for the exception
 206    case). As for the other handlers, the code for the exception case
 207    will be emitted at the end of the function.
 208
 209    Cleanups can also be specified by using add_partial_entry (handler)
 210    and end_protect_partials. add_partial_entry creates the start of
 211    a new exception region; HANDLER will be invoked if an exception is
 212    thrown with the context of the region between the calls to
 213    add_partial_entry and end_protect_partials. end_protect_partials is
 214    used to mark the end of these regions. add_partial_entry can be
 215    called as many times as needed before calling end_protect_partials.
 216    However, end_protect_partials should only be invoked once for each
 217    group of calls to add_partial_entry as the entries are queued
 218    and all of the outstanding entries are processed simultaneously
 219    when end_protect_partials is invoked. Similarly to the other
 220    handlers, the code for HANDLER will be emitted at the end of the
 221    function.
 222
 223    The generated RTL for an exception region includes
 224    NOTE_INSN_EH_REGION_BEG and NOTE_INSN_EH_REGION_END notes that mark
 225    the start and end of the exception region. A unique label is also
 226    generated at the start of the exception region, which is available
 227    by looking at the ehstack variable. The topmost entry corresponds
 228    to the current region.
 229
 230    In the current implementation, an exception can only be thrown from
 231    a function call (since the mechanism used to actually throw an
 232    exception involves calling __throw).  If an exception region is
 233    created but no function calls occur within that region, the region
 234    can be safely optimized away (along with its exception handlers)
 235    since no exceptions can ever be caught in that region.  This
 236    optimization is performed unless -fasynchronous-exceptions is
 237    given.  If the user wishes to throw from a signal handler, or other
 238    asynchronous place, -fasynchronous-exceptions should be used when
 239    compiling for maximally correct code, at the cost of additional
 240    exception regions.  Using -fasynchronous-exceptions only produces
 241    code that is reasonably safe in such situations, but a correct
 242    program cannot rely upon this working.  It can be used in failsafe
 243    code, where trying to continue on, and proceeding with potentially
 244    incorrect results is better than halting the program.
 245
 246
 247    Walking the stack:
 248
 249    The stack is walked by starting with a pointer to the current
 250    frame, and finding the pointer to the callers frame.  The unwind info
 251    tells __throw how to find it.
 252
 253    Unwinding the stack:
 254
 255    When we use the term unwinding the stack, we mean undoing the
 256    effects of the function prologue in a controlled fashion so that we
 257    still have the flow of control.  Otherwise, we could just return
 258    (jump to the normal end of function epilogue).
 259
 260    This is done in __throw in libgcc2.c when we know that a handler exists
 261    in a frame higher up the call stack than its immediate caller.
 262
 263    To unwind, we find the unwind data associated with the frame, if any.
 264    If we don't find any, we call the library routine __terminate.  If we do
 265    find it, we use the information to copy the saved register values from
 266    that frame into the register save area in the frame for __throw, return
 267    into a stub which updates the stack pointer, and jump to the handler.
 268    The normal function epilogue for __throw handles restoring the saved
 269    values into registers.
 270
 271    When unwinding, we use this method if we know it will
 272    work (if DWARF2_UNWIND_INFO is defined).  Otherwise, we know that
 273    an inline unwinder will have been emitted for any function that
 274    __unwind_function cannot unwind.  The inline unwinder appears as a
 275    normal exception handler for the entire function, for any function
 276    that we know cannot be unwound by __unwind_function.  We inform the
 277    compiler of whether a function can be unwound with
 278    __unwind_function by having DOESNT_NEED_UNWINDER evaluate to true
 279    when the unwinder isn't needed.  __unwind_function is used as an
 280    action of last resort.  If no other method can be used for
 281    unwinding, __unwind_function is used.  If it cannot unwind, it
 282    should call __terminate.
 283
 284    By default, if the target-specific backend doesn't supply a definition
 285    for __unwind_function and doesn't support DWARF2_UNWIND_INFO, inlined
 286    unwinders will be used instead. The main tradeoff here is in text space
 287    utilization.  Obviously, if inline unwinders have to be generated
 288    repeatedly, this uses much more space than if a single routine is used.
 289
 290    However, it is simply not possible on some platforms to write a
 291    generalized routine for doing stack unwinding without having some
 292    form of additional data associated with each function.  The current
 293    implementation can encode this data in the form of additional
 294    machine instructions or as static data in tabular form.  The later
 295    is called the unwind data.
 296
 297    The backend macro DOESNT_NEED_UNWINDER is used to conditionalize whether
 298    or not per-function unwinders are needed. If DOESNT_NEED_UNWINDER is
 299    defined and has a non-zero value, a per-function unwinder is not emitted
 300    for the current function.  If the static unwind data is supported, then
 301    a per-function unwinder is not emitted.
 302
 303    On some platforms it is possible that neither __unwind_function
 304    nor inlined unwinders are available. For these platforms it is not
 305    possible to throw through a function call, and abort will be
 306    invoked instead of performing the throw.
 307
 308    The reason the unwind data may be needed is that on some platforms
 309    the order and types of data stored on the stack can vary depending
 310    on the type of function, its arguments and returned values, and the
 311    compilation options used (optimization versus non-optimization,
 312    -fomit-frame-pointer, processor variations, etc).
 313
 314    Unfortunately, this also means that throwing through functions that
 315    aren't compiled with exception handling support will still not be
 316    possible on some platforms. This problem is currently being
 317    investigated, but no solutions have been found that do not imply
 318    some unacceptable performance penalties.
 319
 320    Future directions:
 321
 322    Currently __throw makes no differentiation between cleanups and
 323    user-defined exception regions. While this makes the implementation
 324    simple, it also implies that it is impossible to determine if a
 325    user-defined exception handler exists for a given exception without
 326    completely unwinding the stack in the process. This is undesirable
 327    from the standpoint of debugging, as ideally it would be possible
 328    to trap unhandled exceptions in the debugger before the process of
 329    unwinding has even started.
 330
 331    This problem can be solved by marking user-defined handlers in a
 332    special way (probably by adding additional bits to exception_table_list).
 333    A two-pass scheme could then be used by __throw to iterate
 334    through the table. The first pass would search for a relevant
 335    user-defined handler for the current context of the throw, and if
 336    one is found, the second pass would then invoke all needed cleanups
 337    before jumping to the user-defined handler.
 338
 339    Many languages (including C++ and Ada) make execution of a
 340    user-defined handler conditional on the "type" of the exception
 341    thrown. (The type of the exception is actually the type of the data
 342    that is thrown with the exception.) It will thus be necessary for
 343    __throw to be able to determine if a given user-defined
 344    exception handler will actually be executed, given the type of
 345    exception.
 346
 347    One scheme is to add additional information to exception_table_list
 348    as to the types of exceptions accepted by each handler. __throw
 349    can do the type comparisons and then determine if the handler is
 350    actually going to be executed.
 351
 352    There is currently no significant level of debugging support
 353    available, other than to place a breakpoint on __throw. While
 354    this is sufficient in most cases, it would be helpful to be able to
 355    know where a given exception was going to be thrown to before it is
 356    actually thrown, and to be able to choose between stopping before
 357    every exception region (including cleanups), or just user-defined
 358    exception regions. This should be possible to do in the two-pass
 359    scheme by adding additional labels to __throw for appropriate
 360    breakpoints, and additional debugger commands could be added to
 361    query various state variables to determine what actions are to be
 362    performed next.
 363
 364    Another major problem that is being worked on is the issue with stack
 365    unwinding on various platforms. Currently the only platforms that have
 366    support for the generation of a generic unwinder are the SPARC and MIPS.
 367    All other ports require per-function unwinders, which produce large
 368    amounts of code bloat.
 369
 370    For setjmp/longjmp based exception handling, some of the details
 371    are as above, but there are some additional details.  This section
 372    discusses the details.
 373
 374    We don't use NOTE_INSN_EH_REGION_{BEG,END} pairs.  We don't
 375    optimize EH regions yet.  We don't have to worry about machine
 376    specific issues with unwinding the stack, as we rely upon longjmp
 377    for all the machine specific details.  There is no variable context
 378    of a throw, just the one implied by the dynamic handler stack
 379    pointed to by the dynamic handler chain.  There is no exception
 380    table, and no calls to __register_exceptions.  __sjthrow is used
 381    instead of __throw, and it works by using the dynamic handler
 382    chain, and longjmp.  -fasynchronous-exceptions has no effect, as
 383    the elimination of trivial exception regions is not yet performed.
 384
 385    A frontend can set protect_cleanup_actions_with_terminate when all
 386    the cleanup actions should be protected with an EH region that
 387    calls terminate when an unhandled exception is throw.  C++ does
 388    this, Ada does not.  */
 389
 390
 391 #include "config.h"
 392 #include "defaults.h"
 393 #include "eh-common.h"
 394 #include "system.h"
 395 #include "rtl.h"
 396 #include "tree.h"
 397 #include "flags.h"
 398 #include "except.h"
 399 #include "function.h"
 400 #include "insn-flags.h"
 401 #include "expr.h"
 402 #include "insn-codes.h"
 403 #include "regs.h"
 404 #include "hard-reg-set.h"
 405 #include "insn-config.h"
 406 #include "recog.h"
 407 #include "output.h"
 408 #include "toplev.h"
 409
 410 /* One to use setjmp/longjmp method of generating code for exception
 411    handling.  */
 412
 413 int exceptions_via_longjmp = 2;
 414
 415 /* One to enable asynchronous exception support.  */
 416
 417 int asynchronous_exceptions = 0;
 418
 419 /* One to protect cleanup actions with a handler that calls
 420    __terminate, zero otherwise.  */
 421
 422 int protect_cleanup_actions_with_terminate;
 423
 424 /* A list of labels used for exception handlers.  Created by
 425    find_exception_handler_labels for the optimization passes.  */
 426
 427 rtx exception_handler_labels;
 428
 429 /* The EH context.  Nonzero if the function has already
 430    fetched a pointer to the EH context  for exception handling.  */
 431
 432 rtx current_function_ehc;
 433
 434 /* A stack used for keeping track of the currently active exception
 435    handling region.  As each exception region is started, an entry
 436    describing the region is pushed onto this stack.  The current
 437    region can be found by looking at the top of the stack, and as we
 438    exit regions, the corresponding entries are popped.
 439
 440    Entries cannot overlap; they can be nested. So there is only one
 441    entry at most that corresponds to the current instruction, and that
 442    is the entry on the top of the stack.  */
 443
 444 static struct eh_stack ehstack;
 445
 446
 447 /* This stack is used to represent what the current eh region is
 448    for the catch blocks beings processed */
 449
 450 static struct eh_stack catchstack;
 451
 452 /* A queue used for tracking which exception regions have closed but
 453    whose handlers have not yet been expanded. Regions are emitted in
 454    groups in an attempt to improve paging performance.
 455
 456    As we exit a region, we enqueue a new entry. The entries are then
 457    dequeued during expand_leftover_cleanups and expand_start_all_catch,
 458
 459    We should redo things so that we either take RTL for the handler,
 460    or we expand the handler expressed as a tree immediately at region
 461    end time.  */
 462
 463 static struct eh_queue ehqueue;
 464
 465 /* Insns for all of the exception handlers for the current function.
 466    They are currently emitted by the frontend code.  */
 467
 468 rtx catch_clauses;
 469
 470 /* A TREE_CHAINed list of handlers for regions that are not yet
 471    closed. The TREE_VALUE of each entry contains the handler for the
 472    corresponding entry on the ehstack.  */
 473
 474 static tree protect_list;
 475
 476 /* Stacks to keep track of various labels.  */
 477
 478 /* Keeps track of the label to resume to should one want to resume
 479    normal control flow out of a handler (instead of, say, returning to
 480    the caller of the current function or exiting the program).  */
 481
 482 struct label_node *caught_return_label_stack = NULL;
 483
 484 /* Keeps track of the label used as the context of a throw to rethrow an
 485    exception to the outer exception region.  */
 486
 487 struct label_node *outer_context_label_stack = NULL;
 488
 489 /* A random data area for the front end's own use.  */
 490
 491 struct label_node *false_label_stack = NULL;
 492
 493 /* Pseudos used to hold exception return data in the interim between
 494    __builtin_eh_return and the end of the function.  */
 495
 496 static rtx eh_return_context;
 497 static rtx eh_return_stack_adjust;
 498 static rtx eh_return_handler;
 499
 500 /* Used to mark the eh return stub for flow, so that the Right Thing
 501    happens with the values for the hardregs therin.  */
 502
 503 rtx eh_return_stub_label;
 504
 505 /* Prototypes for local functions.  */
 506
 507 static void push_eh_entry       PROTO((struct eh_stack *));
 508 static struct eh_entry * pop_eh_entry           PROTO((struct eh_stack *));
 509 static void enqueue_eh_entry    PROTO((struct eh_queue *, struct eh_entry *));
 510 static struct eh_entry * dequeue_eh_entry       PROTO((struct eh_queue *));
 511 static rtx call_get_eh_context  PROTO((void));
 512 static void start_dynamic_cleanup               PROTO((tree, tree));
 513 static void start_dynamic_handler               PROTO((void));
 514 static void expand_rethrow      PROTO((rtx));
 515 static void output_exception_table_entry        PROTO((FILE *, int));
 516 static int can_throw            PROTO((rtx));
 517 static rtx scan_region          PROTO((rtx, int, int *));
 518 static void eh_regs             PROTO((rtx *, rtx *, rtx *, int));
 519 static void set_insn_eh_region  PROTO((rtx *, int));
 520 #ifdef DONT_USE_BUILTIN_SETJMP
 521 static void jumpif_rtx          PROTO((rtx, rtx));
 522 #endif
 523
 524 rtx expand_builtin_return_addr  PROTO((enum built_in_function, int, rtx));
 525 \f
 526 /* Various support routines to manipulate the various data structures
 527    used by the exception handling code.  */
 528
 529 /* Push a label entry onto the given STACK.  */
 530
 531 void
 532 push_label_entry (stack, rlabel, tlabel)
 533      struct label_node **stack;
 534      rtx rlabel;
 535      tree tlabel;
 536 {
 537   struct label_node *newnode
 538     = (struct label_node *) xmalloc (sizeof (struct label_node));
 539
 540   if (rlabel)
 541     newnode->u.rlabel = rlabel;
 542   else
 543     newnode->u.tlabel = tlabel;
 544   newnode->chain = *stack;
 545   *stack = newnode;
 546 }
 547
 548 /* Pop a label entry from the given STACK.  */
 549
 550 rtx
 551 pop_label_entry (stack)
 552      struct label_node **stack;
 553 {
 554   rtx label;
 555   struct label_node *tempnode;
 556
 557   if (! *stack)
 558     return NULL_RTX;
 559
 560   tempnode = *stack;
 561   label = tempnode->u.rlabel;
 562   *stack = (*stack)->chain;
 563   free (tempnode);
 564
 565   return label;
 566 }
 567
 568 /* Return the top element of the given STACK.  */
 569
 570 tree
 571 top_label_entry (stack)
 572      struct label_node **stack;
 573 {
 574   if (! *stack)
 575     return NULL_TREE;
 576
 577   return (*stack)->u.tlabel;
 578 }
 579
 580 /* get an exception label. These must be on the permanent obstack */
 581
 582 rtx
 583 gen_exception_label ()
 584 {
 585   rtx lab;
 586
 587   push_obstacks_nochange ();
 588   end_temporary_allocation ();
 589   lab = gen_label_rtx ();
 590   pop_obstacks ();
 591   return lab;
 592 }
 593
 594 /* Push a new eh_node entry onto STACK.  */
 595
 596 static void
 597 push_eh_entry (stack)
 598      struct eh_stack *stack;
 599 {
 600   struct eh_node *node = (struct eh_node *) xmalloc (sizeof (struct eh_node));
 601   struct eh_entry *entry = (struct eh_entry *) xmalloc (sizeof (struct eh_entry));
 602
 603   entry->outer_context = gen_label_rtx ();
 604   entry->finalization = NULL_TREE;
 605   entry->label_used = 0;
 606   entry->exception_handler_label = gen_exception_label ();
 607   entry->false_label = NULL_RTX;
 608
 609   node->entry = entry;
 610   node->chain = stack->top;
 611   stack->top = node;
 612 }
 613
 614 /* push an existing entry onto a stack. */
 615 static void
 616 push_entry (stack, entry)
 617      struct eh_stack *stack;
 618      struct eh_entry *entry;
 619 {
 620   struct eh_node *node = (struct eh_node *) xmalloc (sizeof (struct eh_node));
 621   node->entry = entry;
 622   node->chain = stack->top;
 623   stack->top = node;
 624 }
 625
 626 /* Pop an entry from the given STACK.  */
 627
 628 static struct eh_entry *
 629 pop_eh_entry (stack)
 630      struct eh_stack *stack;
 631 {
 632   struct eh_node *tempnode;
 633   struct eh_entry *tempentry;
 634
 635   tempnode = stack->top;
 636   tempentry = tempnode->entry;
 637   stack->top = stack->top->chain;
 638   free (tempnode);
 639
 640   return tempentry;
 641 }
 642
 643 /* Enqueue an ENTRY onto the given QUEUE.  */
 644
 645 static void
 646 enqueue_eh_entry (queue, entry)
 647      struct eh_queue *queue;
 648      struct eh_entry *entry;
 649 {
 650   struct eh_node *node = (struct eh_node *) xmalloc (sizeof (struct eh_node));
 651
 652   node->entry = entry;
 653   node->chain = NULL;
 654
 655   if (queue->head == NULL)
 656     {
 657       queue->head = node;
 658     }
 659   else
 660     {
 661       queue->tail->chain = node;
 662     }
 663   queue->tail = node;
 664 }
 665
 666 /* Dequeue an entry from the given QUEUE.  */
 667
 668 static struct eh_entry *
 669 dequeue_eh_entry (queue)
 670      struct eh_queue *queue;
 671 {
 672   struct eh_node *tempnode;
 673   struct eh_entry *tempentry;
 674
 675   if (queue->head == NULL)
 676     return NULL;
 677
 678   tempnode = queue->head;
 679   queue->head = queue->head->chain;
 680
 681   tempentry = tempnode->entry;
 682   free (tempnode);
 683
 684   return tempentry;
 685 }
 686
 687 static void
 688 receive_exception_label (handler_label)
 689      rtx handler_label;
 690 {
 691   emit_label (handler_label);
 692
 693 #ifdef HAVE_exception_receiver
 694   if (! exceptions_via_longjmp)
 695     if (HAVE_exception_receiver)
 696       emit_insn (gen_exception_receiver ());
 697 #endif
 698
 699 #ifdef HAVE_nonlocal_goto_receiver
 700   if (! exceptions_via_longjmp)
 701     if (HAVE_nonlocal_goto_receiver)
 702       emit_insn (gen_nonlocal_goto_receiver ());
 703 #endif
 704 }
 705
 706
 707 struct func_eh_entry
 708 {
 709   int range_number;   /* EH region number from EH NOTE insn's */
 710   struct handler_info *handlers;
 711 };
 712
 713
 714 /* table of function eh regions */
 715 static struct func_eh_entry *function_eh_regions = NULL;
 716 static int num_func_eh_entries = 0;
 717 static int current_func_eh_entry = 0;
 718
 719 #define SIZE_FUNC_EH(X)   (sizeof (struct func_eh_entry) * X)
 720
 721 /* Add a new eh_entry for this function, and base it off of the information
 722    in the EH_ENTRY parameter. A NULL parameter is invalid. The number
 723    returned is an number which uniquely identifies this exception range. */
 724
 725 int
 726 new_eh_region_entry (note_eh_region)
 727      int note_eh_region;
 728 {
 729   if (current_func_eh_entry == num_func_eh_entries)
 730     {
 731       if (num_func_eh_entries == 0)
 732         {
 733           function_eh_regions =
 734                         (struct func_eh_entry *) malloc (SIZE_FUNC_EH (50));
 735           num_func_eh_entries = 50;
 736         }
 737       else
 738         {
 739           num_func_eh_entries  = num_func_eh_entries * 3 / 2;
 740           function_eh_regions = (struct func_eh_entry *)
 741             realloc (function_eh_regions, SIZE_FUNC_EH (num_func_eh_entries));
 742         }
 743     }
 744   function_eh_regions[current_func_eh_entry].range_number = note_eh_region;
 745   function_eh_regions[current_func_eh_entry].handlers = NULL;
 746
 747   return current_func_eh_entry++;
 748 }
 749
 750 /* Add new handler information to an exception range. The  first parameter
 751    specifies the range number (returned from new_eh_entry()). The second
 752    parameter specifies the handler.  By default the handler is inserted at
 753    the end of the list. A handler list may contain only ONE NULL_TREE
 754    typeinfo entry. Regardless where it is positioned, a NULL_TREE entry
 755    is always output as the LAST handler in the exception table for a region. */
 756
 757 void
 758 add_new_handler (region, newhandler)
 759      int region;
 760      struct handler_info *newhandler;
 761 {
 762   struct handler_info *last;
 763
 764   newhandler->next = NULL;
 765   last = function_eh_regions[region].handlers;
 766   if (last == NULL)
 767     function_eh_regions[region].handlers = newhandler;
 768   else
 769     {
 770       for ( ; ; last = last->next)
 771         {
 772           if (last->type_info == CATCH_ALL_TYPE)
 773             pedwarn ("additional handler after ...");
 774           if (last->next == NULL)
 775             break;
 776         }
 777       last->next = newhandler;
 778     }
 779 }
 780
 781 /* Remove a handler label. The handler label is being deleted, so all
 782    regions which reference this handler should have it removed from their
 783    list of possible handlers. Any region which has the final handler
 784    removed can be deleted. */
 785
 786 void remove_handler (removing_label)
 787      rtx removing_label;
 788 {
 789   struct handler_info *handler, *last;
 790   int x;
 791   for (x = 0 ; x < current_func_eh_entry; ++x)
 792     {
 793       last = NULL;
 794       handler = function_eh_regions[x].handlers;
 795       for ( ; handler; last = handler, handler = handler->next)
 796         if (handler->handler_label == removing_label)
 797           {
 798             if (last)
 799               {
 800                 last->next = handler->next;
 801                 handler = last;
 802               }
 803             else
 804               function_eh_regions[x].handlers = handler->next;
 805           }
 806     }
 807 }
 808
 809 /* This function will return a malloc'd pointer to an array of
 810    void pointer representing the runtime match values that
 811    currently exist in all regions. */
 812
 813 int
 814 find_all_handler_type_matches (array)
 815   void ***array;
 816 {
 817   struct handler_info *handler, *last;
 818   int x,y;
 819   void *val;
 820   void **ptr;
 821   int max_ptr;
 822   int n_ptr = 0;
 823
 824   *array = NULL;
 825
 826   if (!doing_eh (0) || ! flag_new_exceptions)
 827     return 0;
 828
 829   max_ptr = 100;
 830   ptr = (void **)malloc (max_ptr * sizeof (void *));
 831
 832   if (ptr == NULL)
 833     return 0;
 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 **)realloc (ptr, max_ptr * sizeof (void *));
 858                   if (ptr == NULL)
 859                     return 0;
 860                 }
 861               ptr[n_ptr] = val;
 862               n_ptr++;
 863             }
 864         }
 865     }
 866   *array = ptr;
 867   return n_ptr;
 868 }
 869
 870 /* Create a new handler structure initialized with the handler label and
 871    typeinfo fields passed in. */
 872
 873 struct handler_info *
 874 get_new_handler (handler, typeinfo)
 875      rtx handler;
 876      void *typeinfo;
 877 {
 878   struct handler_info* ptr;
 879   ptr = (struct handler_info *) malloc (sizeof (struct handler_info));
 880   ptr->handler_label = handler;
 881   ptr->type_info = typeinfo;
 882   ptr->next = NULL;
 883
 884   return ptr;
 885 }
 886
 887
 888
 889 /* Find the index in function_eh_regions associated with a NOTE region. If
 890    the region cannot be found, a -1 is returned. This should never happen! */
 891
 892 int
 893 find_func_region (insn_region)
 894      int insn_region;
 895 {
 896   int x;
 897   for (x = 0; x < current_func_eh_entry; x++)
 898     if (function_eh_regions[x].range_number == insn_region)
 899       return x;
 900
 901   return -1;
 902 }
 903
 904 /* Get a pointer to the first handler in an exception region's list. */
 905
 906 struct handler_info *
 907 get_first_handler (region)
 908      int region;
 909 {
 910   return function_eh_regions[find_func_region (region)].handlers;
 911 }
 912
 913 /* Clean out the function_eh_region table and free all memory */
 914
 915 static void
 916 clear_function_eh_region ()
 917 {
 918   int x;
 919   struct handler_info *ptr, *next;
 920   for (x = 0; x < current_func_eh_entry; x++)
 921     for (ptr = function_eh_regions[x].handlers; ptr != NULL; ptr = next)
 922       {
 923         next = ptr->next;
 924         free (ptr);
 925       }
 926   free (function_eh_regions);
 927   num_func_eh_entries  = 0;
 928   current_func_eh_entry = 0;
 929 }
 930
 931 /* Make a duplicate of an exception region by copying all the handlers
 932    for an exception region. Return the new handler index. */
 933
 934 int
 935 duplicate_handlers (old_note_eh_region, new_note_eh_region)
 936      int old_note_eh_region, new_note_eh_region;
 937 {
 938   struct handler_info *ptr, *new_ptr;
 939   int new_region, region;
 940
 941   region = find_func_region (old_note_eh_region);
 942   if (region == -1)
 943     error ("Cannot duplicate non-existant exception region.");
 944
 945   if (find_func_region (new_note_eh_region) != -1)
 946     error ("Cannot duplicate EH region because new note region already exists");
 947
 948   new_region = new_eh_region_entry (new_note_eh_region);
 949   ptr = function_eh_regions[region].handlers;
 950
 951   for ( ; ptr; ptr = ptr->next)
 952     {
 953       new_ptr = get_new_handler (ptr->handler_label, ptr->type_info);
 954       add_new_handler (new_region, new_ptr);
 955     }
 956
 957   return new_region;
 958 }
 959
 960 \f
 961 /* Routine to see if exception handling is turned on.
 962    DO_WARN is non-zero if we want to inform the user that exception
 963    handling is turned off.
 964
 965    This is used to ensure that -fexceptions has been specified if the
 966    compiler tries to use any exception-specific functions.  */
 967
 968 int
 969 doing_eh (do_warn)
 970      int do_warn;
 971 {
 972   if (! flag_exceptions)
 973     {
 974       static int warned = 0;
 975       if (! warned && do_warn)
 976         {
 977           error ("exception handling disabled, use -fexceptions to enable");
 978           warned = 1;
 979         }
 980       return 0;
 981     }
 982   return 1;
 983 }
 984
 985 /* Given a return address in ADDR, determine the address we should use
 986    to find the corresponding EH region.  */
 987
 988 rtx
 989 eh_outer_context (addr)
 990      rtx addr;
 991 {
 992   /* First mask out any unwanted bits.  */
 993 #ifdef MASK_RETURN_ADDR
 994   expand_and (addr, MASK_RETURN_ADDR, addr);
 995 #endif
 996
 997   /* Then adjust to find the real return address.  */
 998 #if defined (RETURN_ADDR_OFFSET)
 999   addr = plus_constant (addr, RETURN_ADDR_OFFSET);
1000 #endif
1001
1002   return addr;
1003 }
1004
1005 /* Start a new exception region for a region of code that has a
1006    cleanup action and push the HANDLER for the region onto
1007    protect_list. All of the regions created with add_partial_entry
1008    will be ended when end_protect_partials is invoked.  */
1009
1010 void
1011 add_partial_entry (handler)
1012      tree handler;
1013 {
1014   expand_eh_region_start ();
1015
1016   /* Make sure the entry is on the correct obstack.  */
1017   push_obstacks_nochange ();
1018   resume_temporary_allocation ();
1019
1020   /* Because this is a cleanup action, we may have to protect the handler
1021      with __terminate.  */
1022   handler = protect_with_terminate (handler);
1023
1024   protect_list = tree_cons (NULL_TREE, handler, protect_list);
1025   pop_obstacks ();
1026 }
1027
1028 /* Emit code to get EH context to current function.  */
1029
1030 static rtx
1031 call_get_eh_context ()
1032 {
1033   static tree fn;
1034   tree expr;
1035
1036   if (fn == NULL_TREE)
1037     {
1038       tree fntype;
1039       fn = get_identifier ("__get_eh_context");
1040       push_obstacks_nochange ();
1041       end_temporary_allocation ();
1042       fntype = build_pointer_type (build_pointer_type
1043                                    (build_pointer_type (void_type_node)));
1044       fntype = build_function_type (fntype, NULL_TREE);
1045       fn = build_decl (FUNCTION_DECL, fn, fntype);
1046       DECL_EXTERNAL (fn) = 1;
1047       TREE_PUBLIC (fn) = 1;
1048       DECL_ARTIFICIAL (fn) = 1;
1049       TREE_READONLY (fn) = 1;
1050       make_decl_rtl (fn, NULL_PTR, 1);
1051       assemble_external (fn);
1052       pop_obstacks ();
1053     }
1054
1055   expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
1056   expr = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
1057                 expr, NULL_TREE, NULL_TREE);
1058   TREE_SIDE_EFFECTS (expr) = 1;
1059
1060   return copy_to_reg (expand_expr (expr, NULL_RTX, VOIDmode, 0));
1061 }
1062
1063 /* Get a reference to the EH context.
1064    We will only generate a register for the current function EH context here,
1065    and emit a USE insn to mark that this is a EH context register.
1066
1067    Later, emit_eh_context will emit needed call to __get_eh_context
1068    in libgcc2, and copy the value to the register we have generated. */
1069
1070 rtx
1071 get_eh_context ()
1072 {
1073   if (current_function_ehc == 0)
1074     {
1075       rtx insn;
1076
1077       current_function_ehc = gen_reg_rtx (Pmode);
1078
1079       insn = gen_rtx_USE (GET_MODE (current_function_ehc),
1080                           current_function_ehc);
1081       insn = emit_insn_before (insn, get_first_nonparm_insn ());
1082
1083       REG_NOTES (insn)
1084         = gen_rtx_EXPR_LIST (REG_EH_CONTEXT, current_function_ehc,
1085                              REG_NOTES (insn));
1086     }
1087   return current_function_ehc;
1088 }
1089
1090 /* Get a reference to the dynamic handler chain.  It points to the
1091    pointer to the next element in the dynamic handler chain.  It ends
1092    when there are no more elements in the dynamic handler chain, when
1093    the value is &top_elt from libgcc2.c.  Immediately after the
1094    pointer, is an area suitable for setjmp/longjmp when
1095    DONT_USE_BUILTIN_SETJMP is defined, and an area suitable for
1096    __builtin_setjmp/__builtin_longjmp when DONT_USE_BUILTIN_SETJMP
1097    isn't defined. */
1098
1099 rtx
1100 get_dynamic_handler_chain ()
1101 {
1102   rtx ehc, dhc, result;
1103
1104   ehc = get_eh_context ();
1105
1106   /* This is the offset of dynamic_handler_chain in the eh_context struct
1107      declared in eh-common.h. If its location is change, change this offset */
1108   dhc = plus_constant (ehc, POINTER_SIZE / BITS_PER_UNIT);
1109
1110   result = copy_to_reg (dhc);
1111
1112   /* We don't want a copy of the dcc, but rather, the single dcc.  */
1113   return gen_rtx_MEM (Pmode, result);
1114 }
1115
1116 /* Get a reference to the dynamic cleanup chain.  It points to the
1117    pointer to the next element in the dynamic cleanup chain.
1118    Immediately after the pointer, are two Pmode variables, one for a
1119    pointer to a function that performs the cleanup action, and the
1120    second, the argument to pass to that function.  */
1121
1122 rtx
1123 get_dynamic_cleanup_chain ()
1124 {
1125   rtx dhc, dcc, result;
1126
1127   dhc = get_dynamic_handler_chain ();
1128   dcc = plus_constant (dhc, POINTER_SIZE / BITS_PER_UNIT);
1129
1130   result = copy_to_reg (dcc);
1131
1132   /* We don't want a copy of the dcc, but rather, the single dcc.  */
1133   return gen_rtx_MEM (Pmode, result);
1134 }
1135
1136 #ifdef DONT_USE_BUILTIN_SETJMP
1137 /* Generate code to evaluate X and jump to LABEL if the value is nonzero.
1138    LABEL is an rtx of code CODE_LABEL, in this function.  */
1139
1140 static void
1141 jumpif_rtx (x, label)
1142      rtx x;
1143      rtx label;
1144 {
1145   jumpif (make_tree (type_for_mode (GET_MODE (x), 0), x), label);
1146 }
1147 #endif
1148
1149 /* Start a dynamic cleanup on the EH runtime dynamic cleanup stack.
1150    We just need to create an element for the cleanup list, and push it
1151    into the chain.
1152
1153    A dynamic cleanup is a cleanup action implied by the presence of an
1154    element on the EH runtime dynamic cleanup stack that is to be
1155    performed when an exception is thrown.  The cleanup action is
1156    performed by __sjthrow when an exception is thrown.  Only certain
1157    actions can be optimized into dynamic cleanup actions.  For the
1158    restrictions on what actions can be performed using this routine,
1159    see expand_eh_region_start_tree.  */
1160
1161 static void
1162 start_dynamic_cleanup (func, arg)
1163      tree func;
1164      tree arg;
1165 {
1166   rtx dcc;
1167   rtx new_func, new_arg;
1168   rtx x, buf;
1169   int size;
1170
1171   /* We allocate enough room for a pointer to the function, and
1172      one argument.  */
1173   size = 2;
1174
1175   /* XXX, FIXME: The stack space allocated this way is too long lived,
1176      but there is no allocation routine that allocates at the level of
1177      the last binding contour.  */
1178   buf = assign_stack_local (BLKmode,
1179                             GET_MODE_SIZE (Pmode)*(size+1),
1180                             0);
1181
1182   buf = change_address (buf, Pmode, NULL_RTX);
1183
1184   /* Store dcc into the first word of the newly allocated buffer.  */
1185
1186   dcc = get_dynamic_cleanup_chain ();
1187   emit_move_insn (buf, dcc);
1188
1189   /* Store func and arg into the cleanup list element.  */
1190
1191   new_func = gen_rtx_MEM (Pmode, plus_constant (XEXP (buf, 0),
1192                                                 GET_MODE_SIZE (Pmode)));
1193   new_arg = gen_rtx_MEM (Pmode, plus_constant (XEXP (buf, 0),
1194                                                GET_MODE_SIZE (Pmode)*2));
1195   x = expand_expr (func, new_func, Pmode, 0);
1196   if (x != new_func)
1197     emit_move_insn (new_func, x);
1198
1199   x = expand_expr (arg, new_arg, Pmode, 0);
1200   if (x != new_arg)
1201     emit_move_insn (new_arg, x);
1202
1203   /* Update the cleanup chain.  */
1204
1205   emit_move_insn (dcc, XEXP (buf, 0));
1206 }
1207
1208 /* Emit RTL to start a dynamic handler on the EH runtime dynamic
1209    handler stack.  This should only be used by expand_eh_region_start
1210    or expand_eh_region_start_tree.  */
1211
1212 static void
1213 start_dynamic_handler ()
1214 {
1215   rtx dhc, dcc;
1216   rtx x, arg, buf;
1217   int size;
1218
1219 #ifndef DONT_USE_BUILTIN_SETJMP
1220   /* The number of Pmode words for the setjmp buffer, when using the
1221      builtin setjmp/longjmp, see expand_builtin, case
1222      BUILT_IN_LONGJMP.  */
1223   size = 5;
1224 #else
1225 #ifdef JMP_BUF_SIZE
1226   size = JMP_BUF_SIZE;
1227 #else
1228   /* Should be large enough for most systems, if it is not,
1229      JMP_BUF_SIZE should be defined with the proper value.  It will
1230      also tend to be larger than necessary for most systems, a more
1231      optimal port will define JMP_BUF_SIZE.  */
1232   size = FIRST_PSEUDO_REGISTER+2;
1233 #endif
1234 #endif
1235   /* XXX, FIXME: The stack space allocated this way is too long lived,
1236      but there is no allocation routine that allocates at the level of
1237      the last binding contour.  */
1238   arg = assign_stack_local (BLKmode,
1239                             GET_MODE_SIZE (Pmode)*(size+1),
1240                             0);
1241
1242   arg = change_address (arg, Pmode, NULL_RTX);
1243
1244   /* Store dhc into the first word of the newly allocated buffer.  */
1245
1246   dhc = get_dynamic_handler_chain ();
1247   dcc = gen_rtx_MEM (Pmode, plus_constant (XEXP (arg, 0),
1248                                            GET_MODE_SIZE (Pmode)));
1249   emit_move_insn (arg, dhc);
1250
1251   /* Zero out the start of the cleanup chain.  */
1252   emit_move_insn (dcc, const0_rtx);
1253
1254   /* The jmpbuf starts two words into the area allocated.  */
1255   buf = plus_constant (XEXP (arg, 0), GET_MODE_SIZE (Pmode)*2);
1256
1257 #ifdef DONT_USE_BUILTIN_SETJMP
1258   x = emit_library_call_value (setjmp_libfunc, NULL_RTX, 1, SImode, 1,
1259                                buf, Pmode);
1260   /* If we come back here for a catch, transfer control to the handler.  */
1261   jumpif_rtx (x, ehstack.top->entry->exception_handler_label);
1262 #else
1263   {
1264     /* A label to continue execution for the no exception case.  */
1265     rtx noex = gen_label_rtx();
1266     x = expand_builtin_setjmp (buf, NULL_RTX, noex,
1267                                ehstack.top->entry->exception_handler_label);
1268     emit_label (noex);
1269   }
1270 #endif
1271
1272   /* We are committed to this, so update the handler chain.  */
1273
1274   emit_move_insn (dhc, XEXP (arg, 0));
1275 }
1276
1277 /* Start an exception handling region for the given cleanup action.
1278    All instructions emitted after this point are considered to be part
1279    of the region until expand_eh_region_end is invoked.  CLEANUP is
1280    the cleanup action to perform.  The return value is true if the
1281    exception region was optimized away.  If that case,
1282    expand_eh_region_end does not need to be called for this cleanup,
1283    nor should it be.
1284
1285    This routine notices one particular common case in C++ code
1286    generation, and optimizes it so as to not need the exception
1287    region.  It works by creating a dynamic cleanup action, instead of
1288    a using an exception region.  */
1289
1290 int
1291 expand_eh_region_start_tree (decl, cleanup)
1292      tree decl;
1293      tree cleanup;
1294 {
1295   /* This is the old code.  */
1296   if (! doing_eh (0))
1297     return 0;
1298
1299   /* The optimization only applies to actions protected with
1300      terminate, and only applies if we are using the setjmp/longjmp
1301      codegen method.  */
1302   if (exceptions_via_longjmp
1303       && protect_cleanup_actions_with_terminate)
1304     {
1305       tree func, arg;
1306       tree args;
1307
1308       /* Ignore any UNSAVE_EXPR.  */
1309       if (TREE_CODE (cleanup) == UNSAVE_EXPR)
1310         cleanup = TREE_OPERAND (cleanup, 0);
1311
1312       /* Further, it only applies if the action is a call, if there
1313          are 2 arguments, and if the second argument is 2.  */
1314
1315       if (TREE_CODE (cleanup) == CALL_EXPR
1316           && (args = TREE_OPERAND (cleanup, 1))
1317           && (func = TREE_OPERAND (cleanup, 0))
1318           && (arg = TREE_VALUE (args))
1319           && (args = TREE_CHAIN (args))
1320
1321           /* is the second argument 2?  */
1322           && TREE_CODE (TREE_VALUE (args)) == INTEGER_CST
1323           && TREE_INT_CST_LOW (TREE_VALUE (args)) == 2
1324           && TREE_INT_CST_HIGH (TREE_VALUE (args)) == 0
1325
1326           /* Make sure there are no other arguments.  */
1327           && TREE_CHAIN (args) == NULL_TREE)
1328         {
1329           /* Arrange for returns and gotos to pop the entry we make on the
1330              dynamic cleanup stack.  */
1331           expand_dcc_cleanup (decl);
1332           start_dynamic_cleanup (func, arg);
1333           return 1;
1334         }
1335     }
1336
1337   expand_eh_region_start_for_decl (decl);
1338   ehstack.top->entry->finalization = cleanup;
1339
1340   return 0;
1341 }
1342
1343 /* Just like expand_eh_region_start, except if a cleanup action is
1344    entered on the cleanup chain, the TREE_PURPOSE of the element put
1345    on the chain is DECL.  DECL should be the associated VAR_DECL, if
1346    any, otherwise it should be NULL_TREE.  */
1347
1348 void
1349 expand_eh_region_start_for_decl (decl)
1350      tree decl;
1351 {
1352   rtx note;
1353
1354   /* This is the old code.  */
1355   if (! doing_eh (0))
1356     return;
1357
1358   if (exceptions_via_longjmp)
1359     {
1360       /* We need a new block to record the start and end of the
1361          dynamic handler chain.  We could always do this, but we
1362          really want to permit jumping into such a block, and we want
1363          to avoid any errors or performance impact in the SJ EH code
1364          for now.  */
1365       expand_start_bindings (0);
1366
1367       /* But we don't need or want a new temporary level.  */
1368       pop_temp_slots ();
1369
1370       /* Mark this block as created by expand_eh_region_start.  This
1371          is so that we can pop the block with expand_end_bindings
1372          automatically.  */
1373       mark_block_as_eh_region ();
1374
1375       /* Arrange for returns and gotos to pop the entry we make on the
1376          dynamic handler stack.  */
1377       expand_dhc_cleanup (decl);
1378     }
1379
1380   push_eh_entry (&ehstack);
1381   note = emit_note (NULL_PTR, NOTE_INSN_EH_REGION_BEG);
1382   NOTE_BLOCK_NUMBER (note)
1383     = CODE_LABEL_NUMBER (ehstack.top->entry->exception_handler_label);
1384   if (exceptions_via_longjmp)
1385     start_dynamic_handler ();
1386 }
1387
1388 /* Start an exception handling region.  All instructions emitted after
1389    this point are considered to be part of the region until
1390    expand_eh_region_end is invoked.  */
1391
1392 void
1393 expand_eh_region_start ()
1394 {
1395   expand_eh_region_start_for_decl (NULL_TREE);
1396 }
1397
1398 /* End an exception handling region.  The information about the region
1399    is found on the top of ehstack.
1400
1401    HANDLER is either the cleanup for the exception region, or if we're
1402    marking the end of a try block, HANDLER is integer_zero_node.
1403
1404    HANDLER will be transformed to rtl when expand_leftover_cleanups
1405    is invoked.  */
1406
1407 void
1408 expand_eh_region_end (handler)
1409      tree handler;
1410 {
1411   struct eh_entry *entry;
1412   rtx note;
1413
1414   if (! doing_eh (0))
1415     return;
1416
1417   entry = pop_eh_entry (&ehstack);
1418
1419   note = emit_note (NULL_PTR, NOTE_INSN_EH_REGION_END);
1420   NOTE_BLOCK_NUMBER (note)
1421     = CODE_LABEL_NUMBER (entry->exception_handler_label);
1422   if (exceptions_via_longjmp == 0
1423       /* We share outer_context between regions; only emit it once.  */
1424       && INSN_UID (entry->outer_context) == 0)
1425     {
1426       rtx label;
1427
1428       label = gen_label_rtx ();
1429       emit_jump (label);
1430
1431       /* Emit a label marking the end of this exception region that
1432          is used for rethrowing into the outer context.  */
1433       emit_label (entry->outer_context);
1434       expand_internal_throw ();
1435
1436       emit_label (label);
1437     }
1438
1439   entry->finalization = handler;
1440
1441   /* create region entry in final exception table */
1442   new_eh_region_entry (NOTE_BLOCK_NUMBER (note));
1443
1444   enqueue_eh_entry (&ehqueue, entry);
1445
1446   /* If we have already started ending the bindings, don't recurse.
1447      This only happens when exceptions_via_longjmp is true.  */
1448   if (is_eh_region ())
1449     {
1450       /* Because we don't need or want a new temporary level and
1451          because we didn't create one in expand_eh_region_start,
1452          create a fake one now to avoid removing one in
1453          expand_end_bindings.  */
1454       push_temp_slots ();
1455
1456       mark_block_as_not_eh_region ();
1457
1458       /* Maybe do this to prevent jumping in and so on...  */
1459       expand_end_bindings (NULL_TREE, 0, 0);
1460     }
1461 }
1462
1463 /* End the EH region for a goto fixup.  We only need them in the region-based
1464    EH scheme.  */
1465
1466 void
1467 expand_fixup_region_start ()
1468 {
1469   if (! doing_eh (0) || exceptions_via_longjmp)
1470     return;
1471
1472   expand_eh_region_start ();
1473 }
1474
1475 /* End the EH region for a goto fixup.  CLEANUP is the cleanup we just
1476    expanded; to avoid running it twice if it throws, we look through the
1477    ehqueue for a matching region and rethrow from its outer_context.  */
1478
1479 void
1480 expand_fixup_region_end (cleanup)
1481      tree cleanup;
1482 {
1483   struct eh_node *node;
1484   int dont_issue;
1485
1486   if (! doing_eh (0) || exceptions_via_longjmp)
1487     return;
1488
1489   for (node = ehstack.top; node && node->entry->finalization != cleanup; )
1490     node = node->chain;
1491   if (node == 0)
1492     for (node = ehqueue.head; node && node->entry->finalization != cleanup; )
1493       node = node->chain;
1494   if (node == 0)
1495     abort ();
1496
1497   /* If the outer context label has not been issued yet, we don't want
1498      to issue it as a part of this region, unless this is the
1499      correct region for the outer context. If we did, then the label for
1500      the outer context will be WITHIN the begin/end labels,
1501      and we could get an infinte loop when it tried to rethrow, or just
1502      generally incorrect execution following a throw. */
1503
1504   dont_issue = ((INSN_UID (node->entry->outer_context) == 0)
1505             && (ehstack.top->entry != node->entry));
1506
1507   ehstack.top->entry->outer_context = node->entry->outer_context;
1508
1509   /* Since we are rethrowing to the OUTER region, we know we don't need
1510      a jump around sequence for this region, so we'll pretend the outer
1511      context label has been issued by setting INSN_UID to 1, then clearing
1512      it again afterwards. */
1513
1514   if (dont_issue)
1515     INSN_UID (node->entry->outer_context) = 1;
1516
1517   /* Just rethrow.  size_zero_node is just a NOP.  */
1518   expand_eh_region_end (size_zero_node);
1519
1520   if (dont_issue)
1521     INSN_UID (node->entry->outer_context) = 0;
1522 }
1523
1524 /* If we are using the setjmp/longjmp EH codegen method, we emit a
1525    call to __sjthrow.
1526
1527    Otherwise, we emit a call to __throw and note that we threw
1528    something, so we know we need to generate the necessary code for
1529    __throw.
1530
1531    Before invoking throw, the __eh_pc variable must have been set up
1532    to contain the PC being thrown from. This address is used by
1533    __throw to determine which exception region (if any) is
1534    responsible for handling the exception.  */
1535
1536 void
1537 emit_throw ()
1538 {
1539   if (exceptions_via_longjmp)
1540     {
1541       emit_library_call (sjthrow_libfunc, 0, VOIDmode, 0);
1542     }
1543   else
1544     {
1545 #ifdef JUMP_TO_THROW
1546       emit_indirect_jump (throw_libfunc);
1547 #else
1548       emit_library_call (throw_libfunc, 0, VOIDmode, 0);
1549 #endif
1550     }
1551   emit_barrier ();
1552 }
1553
1554 /* Throw the current exception.  If appropriate, this is done by jumping
1555    to the next handler.  */
1556
1557 void
1558 expand_internal_throw ()
1559 {
1560   emit_throw ();
1561 }
1562
1563 /* Called from expand_exception_blocks and expand_end_catch_block to
1564    emit any pending handlers/cleanups queued from expand_eh_region_end.  */
1565
1566 void
1567 expand_leftover_cleanups ()
1568 {
1569   struct eh_entry *entry;
1570
1571   while ((entry = dequeue_eh_entry (&ehqueue)) != 0)
1572     {
1573       rtx prev;
1574
1575       /* A leftover try block. Shouldn't be one here.  */
1576       if (entry->finalization == integer_zero_node)
1577         abort ();
1578
1579       /* Output the label for the start of the exception handler.  */
1580
1581       receive_exception_label (entry->exception_handler_label);
1582
1583       /* register a handler for this cleanup region */
1584       add_new_handler (
1585         find_func_region (CODE_LABEL_NUMBER (entry->exception_handler_label)),
1586         get_new_handler (entry->exception_handler_label, NULL));
1587
1588       /* And now generate the insns for the handler.  */
1589       expand_expr (entry->finalization, const0_rtx, VOIDmode, 0);
1590
1591       prev = get_last_insn ();
1592       if (prev == NULL || GET_CODE (prev) != BARRIER)
1593         /* Emit code to throw to the outer context if we fall off
1594            the end of the handler.  */
1595         expand_rethrow (entry->outer_context);
1596
1597       do_pending_stack_adjust ();
1598       free (entry);
1599     }
1600 }
1601
1602 /* Called at the start of a block of try statements.  */
1603 void
1604 expand_start_try_stmts ()
1605 {
1606   if (! doing_eh (1))
1607     return;
1608
1609   expand_eh_region_start ();
1610 }
1611
1612 /* Called to begin a catch clause. The parameter is the object which
1613    will be passed to the runtime type check routine. */
1614 void
1615 start_catch_handler (rtime)
1616      tree rtime;
1617 {
1618   rtx handler_label;
1619   int insn_region_num;
1620   int eh_region_entry;
1621
1622   if (! doing_eh (1))
1623     return;
1624
1625   handler_label = catchstack.top->entry->exception_handler_label;
1626   insn_region_num = CODE_LABEL_NUMBER (handler_label);
1627   eh_region_entry = find_func_region (insn_region_num);
1628
1629   /* If we've already issued this label, pick a new one */
1630   if (catchstack.top->entry->label_used)
1631     handler_label = gen_exception_label ();
1632   else
1633     catchstack.top->entry->label_used = 1;
1634
1635   receive_exception_label (handler_label);
1636
1637   add_new_handler (eh_region_entry, get_new_handler (handler_label, rtime));
1638
1639   if (flag_new_exceptions && ! exceptions_via_longjmp)
1640     return;
1641
1642   /* Under the old mechanism, as well as setjmp/longjmp, we need to
1643      issue code to compare 'rtime' to the value in eh_info, via the
1644      matching function in eh_info. If its is false, we branch around
1645      the handler we are about to issue. */
1646
1647   if (rtime != NULL_TREE && rtime != CATCH_ALL_TYPE)
1648     {
1649       rtx call_rtx, rtime_address;
1650
1651       if (catchstack.top->entry->false_label != NULL_RTX)
1652         fatal ("Compiler Bug: Never issued previous false_label");
1653       catchstack.top->entry->false_label = gen_exception_label ();
1654
1655       rtime_address = expand_expr (rtime, NULL_RTX, Pmode, EXPAND_INITIALIZER);
1656       rtime_address = force_reg (Pmode, rtime_address);
1657
1658       /* Now issue the call, and branch around handler if needed */
1659       call_rtx = emit_library_call_value (eh_rtime_match_libfunc, NULL_RTX,
1660                                           0, SImode, 1, rtime_address, Pmode);
1661
1662       /* Did the function return true? */
1663       emit_cmp_insn (call_rtx, const0_rtx, EQ, NULL_RTX,
1664                                                 GET_MODE (call_rtx), 0 ,0);
1665       emit_jump_insn (gen_beq (catchstack.top->entry->false_label));
1666     }
1667 }
1668
1669 /* Called to end a catch clause. If we aren't using the new exception
1670    model tabel mechanism, we need to issue the branch-around label
1671    for the end of the catch block. */
1672
1673 void
1674 end_catch_handler ()
1675 {
1676   if (! doing_eh (1) || (flag_new_exceptions && ! exceptions_via_longjmp))
1677     return;
1678
1679   /* A NULL label implies the catch clause was a catch all or cleanup */
1680   if (catchstack.top->entry->false_label == NULL_RTX)
1681     return;
1682
1683   emit_label (catchstack.top->entry->false_label);
1684   catchstack.top->entry->false_label = NULL_RTX;
1685 }
1686
1687 /* Generate RTL for the start of a group of catch clauses.
1688
1689    It is responsible for starting a new instruction sequence for the
1690    instructions in the catch block, and expanding the handlers for the
1691    internally-generated exception regions nested within the try block
1692    corresponding to this catch block.  */
1693
1694 void
1695 expand_start_all_catch ()
1696 {
1697   struct eh_entry *entry;
1698   tree label;
1699   rtx outer_context;
1700
1701   if (! doing_eh (1))
1702     return;
1703
1704   outer_context = ehstack.top->entry->outer_context;
1705
1706   /* End the try block.  */
1707   expand_eh_region_end (integer_zero_node);
1708
1709   emit_line_note (input_filename, lineno);
1710   label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
1711
1712   /* The label for the exception handling block that we will save.
1713      This is Lresume in the documentation.  */
1714   expand_label (label);
1715
1716   /* Push the label that points to where normal flow is resumed onto
1717      the top of the label stack.  */
1718   push_label_entry (&caught_return_label_stack, NULL_RTX, label);
1719
1720   /* Start a new sequence for all the catch blocks.  We will add this
1721      to the global sequence catch_clauses when we have completed all
1722      the handlers in this handler-seq.  */
1723   start_sequence ();
1724
1725   entry = dequeue_eh_entry (&ehqueue);
1726   for ( ; entry->finalization != integer_zero_node;
1727                                  entry = dequeue_eh_entry (&ehqueue))
1728     {
1729       rtx prev;
1730
1731       /* Emit the label for the cleanup handler for this region, and
1732          expand the code for the handler.
1733
1734          Note that a catch region is handled as a side-effect here;
1735          for a try block, entry->finalization will contain
1736          integer_zero_node, so no code will be generated in the
1737          expand_expr call below. But, the label for the handler will
1738          still be emitted, so any code emitted after this point will
1739          end up being the handler.  */
1740
1741       receive_exception_label (entry->exception_handler_label);
1742
1743       /* register a handler for this cleanup region */
1744       add_new_handler (
1745         find_func_region (CODE_LABEL_NUMBER (entry->exception_handler_label)),
1746         get_new_handler (entry->exception_handler_label, NULL));
1747
1748       /* And now generate the insns for the cleanup handler.  */
1749       expand_expr (entry->finalization, const0_rtx, VOIDmode, 0);
1750
1751       prev = get_last_insn ();
1752       if (prev == NULL || GET_CODE (prev) != BARRIER)
1753         /* Code to throw out to outer context when we fall off end
1754            of the handler. We can't do this here for catch blocks,
1755            so it's done in expand_end_all_catch instead.  */
1756         expand_rethrow (entry->outer_context);
1757
1758       do_pending_stack_adjust ();
1759       free (entry);
1760     }
1761
1762   /* At this point, all the cleanups are done, and the ehqueue now has
1763      the current exception region at its head. We dequeue it, and put it
1764      on the catch stack. */
1765
1766     push_entry (&catchstack, entry);
1767
1768   /* If we are not doing setjmp/longjmp EH, because we are reordered
1769      out of line, we arrange to rethrow in the outer context.  We need to
1770      do this because we are not physically within the region, if any, that
1771      logically contains this catch block.  */
1772   if (! exceptions_via_longjmp)
1773     {
1774       expand_eh_region_start ();
1775       ehstack.top->entry->outer_context = outer_context;
1776     }
1777
1778 }
1779
1780 /* Finish up the catch block.  At this point all the insns for the
1781    catch clauses have already been generated, so we only have to add
1782    them to the catch_clauses list. We also want to make sure that if
1783    we fall off the end of the catch clauses that we rethrow to the
1784    outer EH region.  */
1785
1786 void
1787 expand_end_all_catch ()
1788 {
1789   rtx new_catch_clause, outer_context = NULL_RTX;
1790   struct eh_entry *entry;
1791
1792   if (! doing_eh (1))
1793     return;
1794
1795   /* Dequeue the current catch clause region. */
1796   entry = pop_eh_entry (&catchstack);
1797   free (entry);
1798
1799   if (! exceptions_via_longjmp)
1800     {
1801       outer_context = ehstack.top->entry->outer_context;
1802
1803       /* Finish the rethrow region.  size_zero_node is just a NOP.  */
1804       expand_eh_region_end (size_zero_node);
1805     }
1806
1807   /* Code to throw out to outer context, if we fall off end of catch
1808      handlers.  This is rethrow (Lresume, same id, same obj) in the
1809      documentation. We use Lresume because we know that it will throw
1810      to the correct context.
1811
1812      In other words, if the catch handler doesn't exit or return, we
1813      do a "throw" (using the address of Lresume as the point being
1814      thrown from) so that the outer EH region can then try to process
1815      the exception.  */
1816   expand_rethrow (outer_context);
1817
1818   /* Now we have the complete catch sequence.  */
1819   new_catch_clause = get_insns ();
1820   end_sequence ();
1821
1822   /* This level of catch blocks is done, so set up the successful
1823      catch jump label for the next layer of catch blocks.  */
1824   pop_label_entry (&caught_return_label_stack);
1825   pop_label_entry (&outer_context_label_stack);
1826
1827   /* Add the new sequence of catches to the main one for this function.  */
1828   push_to_sequence (catch_clauses);
1829   emit_insns (new_catch_clause);
1830   catch_clauses = get_insns ();
1831   end_sequence ();
1832
1833   /* Here we fall through into the continuation code.  */
1834 }
1835
1836 /* Rethrow from the outer context LABEL.  */
1837
1838 static void
1839 expand_rethrow (label)
1840      rtx label;
1841 {
1842   if (exceptions_via_longjmp)
1843     emit_throw ();
1844   else
1845     emit_jump (label);
1846 }
1847
1848 /* End all the pending exception regions on protect_list. The handlers
1849    will be emitted when expand_leftover_cleanups is invoked.  */
1850
1851 void
1852 end_protect_partials ()
1853 {
1854   while (protect_list)
1855     {
1856       expand_eh_region_end (TREE_VALUE (protect_list));
1857       protect_list = TREE_CHAIN (protect_list);
1858     }
1859 }
1860
1861 /* Arrange for __terminate to be called if there is an unhandled throw
1862    from within E.  */
1863
1864 tree
1865 protect_with_terminate (e)
1866      tree e;
1867 {
1868   /* We only need to do this when using setjmp/longjmp EH and the
1869      language requires it, as otherwise we protect all of the handlers
1870      at once, if we need to.  */
1871   if (exceptions_via_longjmp && protect_cleanup_actions_with_terminate)
1872     {
1873       tree handler, result;
1874
1875       /* All cleanups must be on the function_obstack.  */
1876       push_obstacks_nochange ();
1877       resume_temporary_allocation ();
1878
1879       handler = make_node (RTL_EXPR);
1880       TREE_TYPE (handler) = void_type_node;
1881       RTL_EXPR_RTL (handler) = const0_rtx;
1882       TREE_SIDE_EFFECTS (handler) = 1;
1883       start_sequence_for_rtl_expr (handler);
1884
1885       emit_library_call (terminate_libfunc, 0, VOIDmode, 0);
1886       emit_barrier ();
1887
1888       RTL_EXPR_SEQUENCE (handler) = get_insns ();
1889       end_sequence ();
1890
1891       result = build (TRY_CATCH_EXPR, TREE_TYPE (e), e, handler);
1892       TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
1893       TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
1894       TREE_READONLY (result) = TREE_READONLY (e);
1895
1896       pop_obstacks ();
1897
1898       e = result;
1899     }
1900
1901   return e;
1902 }
1903 \f
1904 /* The exception table that we build that is used for looking up and
1905    dispatching exceptions, the current number of entries, and its
1906    maximum size before we have to extend it.
1907
1908    The number in eh_table is the code label number of the exception
1909    handler for the region. This is added by add_eh_table_entry and
1910    used by output_exception_table_entry.  */
1911
1912 static int *eh_table = NULL;
1913 static int eh_table_size = 0;
1914 static int eh_table_max_size = 0;
1915
1916 /* Note the need for an exception table entry for region N.  If we
1917    don't need to output an explicit exception table, avoid all of the
1918    extra work.
1919
1920    Called from final_scan_insn when a NOTE_INSN_EH_REGION_BEG is seen.
1921    (Or NOTE_INSN_EH_REGION_END sometimes)
1922    N is the NOTE_BLOCK_NUMBER of the note, which comes from the code
1923    label number of the exception handler for the region.  */
1924
1925 void
1926 add_eh_table_entry (n)
1927      int n;
1928 {
1929 #ifndef OMIT_EH_TABLE
1930   if (eh_table_size >= eh_table_max_size)
1931     {
1932       if (eh_table)
1933         {
1934           eh_table_max_size += eh_table_max_size>>1;
1935
1936           if (eh_table_max_size < 0)
1937             abort ();
1938
1939           eh_table = (int *) xrealloc (eh_table,
1940                                        eh_table_max_size * sizeof (int));
1941         }
1942       else
1943         {
1944           eh_table_max_size = 252;
1945           eh_table = (int *) xmalloc (eh_table_max_size * sizeof (int));
1946         }
1947     }
1948   eh_table[eh_table_size++] = n;
1949 #endif
1950 }
1951
1952 /* Return a non-zero value if we need to output an exception table.
1953
1954    On some platforms, we don't have to output a table explicitly.
1955    This routine doesn't mean we don't have one.  */
1956
1957 int
1958 exception_table_p ()
1959 {
1960   if (eh_table)
1961     return 1;
1962
1963   return 0;
1964 }
1965
1966 /* Output the entry of the exception table corresponding to the
1967    exception region numbered N to file FILE.
1968
1969    N is the code label number corresponding to the handler of the
1970    region.  */
1971
1972 static void
1973 output_exception_table_entry (file, n)
1974      FILE *file;
1975      int n;
1976 {
1977   char buf[256];
1978   rtx sym;
1979   struct handler_info *handler;
1980
1981   handler = get_first_handler (n);
1982
1983   for ( ; handler != NULL; handler = handler->next)
1984     {
1985       ASM_GENERATE_INTERNAL_LABEL (buf, "LEHB", n);
1986       sym = gen_rtx_SYMBOL_REF (Pmode, buf);
1987       assemble_integer (sym, POINTER_SIZE / BITS_PER_UNIT, 1);
1988
1989       ASM_GENERATE_INTERNAL_LABEL (buf, "LEHE", n);
1990       sym = gen_rtx_SYMBOL_REF (Pmode, buf);
1991       assemble_integer (sym, POINTER_SIZE / BITS_PER_UNIT, 1);
1992
1993       assemble_integer (handler->handler_label,
1994                                          POINTER_SIZE / BITS_PER_UNIT, 1);
1995
1996       if (flag_new_exceptions)
1997         {
1998           if (handler->type_info == NULL)
1999             assemble_integer (const0_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
2000           else
2001             if (handler->type_info == CATCH_ALL_TYPE)
2002               assemble_integer (GEN_INT (CATCH_ALL_TYPE),
2003                                              POINTER_SIZE / BITS_PER_UNIT, 1);
2004             else
2005               output_constant ((tree)(handler->type_info),
2006                                                 POINTER_SIZE / BITS_PER_UNIT);
2007         }
2008       putc ('\n', file);                /* blank line */
2009       /* We only output the first label under the old scheme */
2010       if (! flag_new_exceptions)
2011         break;
2012     }
2013 }
2014
2015 /* Output the exception table if we have and need one.  */
2016
2017 static short language_code = 0;
2018 static short version_code = 0;
2019
2020 /* This routine will set the language code for exceptions. */
2021 void
2022 set_exception_lang_code (code)
2023      int code;
2024 {
2025   language_code = code;
2026 }
2027
2028 /* This routine will set the language version code for exceptions. */
2029 void
2030 set_exception_version_code (code)
2031      int code;
2032 {
2033   version_code = code;
2034 }
2035
2036
2037 void
2038 output_exception_table ()
2039 {
2040   int i;
2041   extern FILE *asm_out_file;
2042
2043   if (! doing_eh (0) || ! eh_table)
2044     return;
2045
2046   exception_section ();
2047
2048   /* Beginning marker for table.  */
2049   assemble_align (GET_MODE_ALIGNMENT (ptr_mode));
2050   assemble_label ("__EXCEPTION_TABLE__");
2051
2052   if (flag_new_exceptions)
2053     {
2054       assemble_integer (GEN_INT (NEW_EH_RUNTIME),
2055                                         POINTER_SIZE / BITS_PER_UNIT, 1);
2056       assemble_integer (GEN_INT (language_code), 2 , 1);
2057       assemble_integer (GEN_INT (version_code), 2 , 1);
2058
2059       /* Add enough padding to make sure table aligns on a pointer boundry. */
2060       i = GET_MODE_ALIGNMENT (ptr_mode) / BITS_PER_UNIT - 4;
2061       for ( ; i < 0; i = i + GET_MODE_ALIGNMENT (ptr_mode) / BITS_PER_UNIT)
2062         ;
2063       if (i != 0)
2064         assemble_integer (const0_rtx, i , 1);
2065     }
2066
2067   for (i = 0; i < eh_table_size; ++i)
2068     output_exception_table_entry (asm_out_file, eh_table[i]);
2069
2070   free (eh_table);
2071   clear_function_eh_region ();
2072
2073   /* Ending marker for table.  */
2074   assemble_integer (constm1_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
2075
2076   /* for binary compatability, the old __throw checked the second
2077      position for a -1, so we should output at least 2 -1's */
2078   if (! flag_new_exceptions)
2079     assemble_integer (constm1_rtx, POINTER_SIZE / BITS_PER_UNIT, 1);
2080
2081   putc ('\n', asm_out_file);            /* blank line */
2082 }
2083 \f
2084 /* Emit code to get EH context.
2085
2086    We have to scan thru the code to find possible EH context registers.
2087    Inlined functions may use it too, and thus we'll have to be able
2088    to change them too.
2089
2090    This is done only if using exceptions_via_longjmp. */
2091
2092 void
2093 emit_eh_context ()
2094 {
2095   rtx insn;
2096   rtx ehc = 0;
2097
2098   if (! doing_eh (0))
2099     return;
2100
2101   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2102     if (GET_CODE (insn) == INSN
2103         && GET_CODE (PATTERN (insn)) == USE)
2104       {
2105         rtx reg = find_reg_note (insn, REG_EH_CONTEXT, 0);
2106         if (reg)
2107           {
2108             rtx insns;
2109
2110             start_sequence ();
2111
2112             /* If this is the first use insn, emit the call here.  This
2113                will always be at the top of our function, because if
2114                expand_inline_function notices a REG_EH_CONTEXT note, it
2115                adds a use insn to this function as well.  */
2116             if (ehc == 0)
2117               ehc = call_get_eh_context ();
2118
2119             emit_move_insn (XEXP (reg, 0), ehc);
2120             insns = get_insns ();
2121             end_sequence ();
2122
2123             emit_insns_before (insns, insn);
2124
2125             /* At -O0, we must make the context register stay alive so
2126                that the stupid.c register allocator doesn't get confused. */
2127             if (obey_regdecls != 0)
2128               {
2129                 insns = gen_rtx_USE (GET_MODE (XEXP (reg,0)), XEXP (reg,0));
2130                 emit_insn_before (insns, get_last_insn ());
2131               }
2132           }
2133       }
2134 }
2135
2136 /* Scan the current insns and build a list of handler labels. The
2137    resulting list is placed in the global variable exception_handler_labels.
2138
2139    It is called after the last exception handling region is added to
2140    the current function (when the rtl is almost all built for the
2141    current function) and before the jump optimization pass.  */
2142
2143 void
2144 find_exception_handler_labels ()
2145 {
2146   rtx insn;
2147
2148   exception_handler_labels = NULL_RTX;
2149
2150   /* If we aren't doing exception handling, there isn't much to check.  */
2151   if (! doing_eh (0))
2152     return;
2153
2154   /* For each start of a region, add its label to the list.  */
2155
2156   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2157     {
2158       struct handler_info* ptr;
2159       if (GET_CODE (insn) == NOTE
2160           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
2161         {
2162           ptr = get_first_handler (NOTE_BLOCK_NUMBER (insn));
2163           for ( ; ptr; ptr = ptr->next)
2164             {
2165               /* make sure label isn't in the list already */
2166               rtx x;
2167               for (x = exception_handler_labels; x; x = XEXP (x, 1))
2168                 if (XEXP (x, 0) == ptr->handler_label)
2169                   break;
2170               if (! x)
2171                 exception_handler_labels = gen_rtx_EXPR_LIST (VOIDmode,
2172                                ptr->handler_label, exception_handler_labels);
2173             }
2174         }
2175     }
2176 }
2177
2178 /* Return a value of 1 if the parameter label number is an exception handler
2179    label. Return 0 otherwise. */
2180
2181 int
2182 is_exception_handler_label (lab)
2183      int lab;
2184 {
2185   rtx x;
2186   for (x = exception_handler_labels ; x ; x = XEXP (x, 1))
2187     if (lab == CODE_LABEL_NUMBER (XEXP (x, 0)))
2188       return 1;
2189   return 0;
2190 }
2191
2192 /* Perform sanity checking on the exception_handler_labels list.
2193
2194    Can be called after find_exception_handler_labels is called to
2195    build the list of exception handlers for the current function and
2196    before we finish processing the current function.  */
2197
2198 void
2199 check_exception_handler_labels ()
2200 {
2201   rtx insn, insn2;
2202
2203   /* If we aren't doing exception handling, there isn't much to check.  */
2204   if (! doing_eh (0))
2205     return;
2206
2207   /* Make sure there is no more than 1 copy of a label */
2208   for (insn = exception_handler_labels; insn; insn = XEXP (insn, 1))
2209     {
2210       int count = 0;
2211       for (insn2 = exception_handler_labels; insn2; insn2 = XEXP (insn2, 1))
2212         if (XEXP (insn, 0) == XEXP (insn2, 0))
2213           count++;
2214       if (count != 1)
2215        warning ("Counted %d copies of EH region %d in list.\n", count,
2216                                         CODE_LABEL_NUMBER (insn));
2217     }
2218
2219 }
2220 \f
2221 /* This group of functions initializes the exception handling data
2222    structures at the start of the compilation, initializes the data
2223    structures at the start of a function, and saves and restores the
2224    exception handling data structures for the start/end of a nested
2225    function.  */
2226
2227 /* Toplevel initialization for EH things.  */
2228
2229 void
2230 init_eh ()
2231 {
2232 }
2233
2234 /* Initialize the per-function EH information.  */
2235
2236 void
2237 init_eh_for_function ()
2238 {
2239   ehstack.top = 0;
2240   catchstack.top = 0;
2241   ehqueue.head = ehqueue.tail = 0;
2242   catch_clauses = NULL_RTX;
2243   false_label_stack = 0;
2244   caught_return_label_stack = 0;
2245   protect_list = NULL_TREE;
2246   current_function_ehc = NULL_RTX;
2247   eh_return_context = NULL_RTX;
2248   eh_return_stack_adjust = NULL_RTX;
2249   eh_return_handler = NULL_RTX;
2250   eh_return_stub_label = NULL_RTX;
2251 }
2252
2253 /* Save some of the per-function EH info into the save area denoted by
2254    P.
2255
2256    This is currently called from save_stmt_status.  */
2257
2258 void
2259 save_eh_status (p)
2260      struct function *p;
2261 {
2262   if (p == NULL)
2263     abort ();
2264
2265   p->ehstack = ehstack;
2266   p->catchstack = catchstack;
2267   p->ehqueue = ehqueue;
2268   p->catch_clauses = catch_clauses;
2269   p->false_label_stack = false_label_stack;
2270   p->caught_return_label_stack = caught_return_label_stack;
2271   p->protect_list = protect_list;
2272   p->ehc = current_function_ehc;
2273
2274   init_eh_for_function ();
2275 }
2276
2277 /* Restore the per-function EH info saved into the area denoted by P.
2278
2279    This is currently called from restore_stmt_status.  */
2280
2281 void
2282 restore_eh_status (p)
2283      struct function *p;
2284 {
2285   if (p == NULL)
2286     abort ();
2287
2288   protect_list = p->protect_list;
2289   caught_return_label_stack = p->caught_return_label_stack;
2290   false_label_stack = p->false_label_stack;
2291   catch_clauses = p->catch_clauses;
2292   ehqueue = p->ehqueue;
2293   ehstack = p->ehstack;
2294   catchstack = p->catchstack;
2295   current_function_ehc = p->ehc;
2296 }
2297 \f
2298 /* This section is for the exception handling specific optimization
2299    pass.  First are the internal routines, and then the main
2300    optimization pass.  */
2301
2302 /* Determine if the given INSN can throw an exception.  */
2303
2304 static int
2305 can_throw (insn)
2306      rtx insn;
2307 {
2308   /* Calls can always potentially throw exceptions.  */
2309   if (GET_CODE (insn) == CALL_INSN)
2310     return 1;
2311
2312   if (asynchronous_exceptions)
2313     {
2314       /* If we wanted asynchronous exceptions, then everything but NOTEs
2315          and CODE_LABELs could throw.  */
2316       if (GET_CODE (insn) != NOTE && GET_CODE (insn) != CODE_LABEL)
2317         return 1;
2318     }
2319
2320   return 0;
2321 }
2322
2323 /* Scan a exception region looking for the matching end and then
2324    remove it if possible. INSN is the start of the region, N is the
2325    region number, and DELETE_OUTER is to note if anything in this
2326    region can throw.
2327
2328    Regions are removed if they cannot possibly catch an exception.
2329    This is determined by invoking can_throw on each insn within the
2330    region; if can_throw returns true for any of the instructions, the
2331    region can catch an exception, since there is an insn within the
2332    region that is capable of throwing an exception.
2333
2334    Returns the NOTE_INSN_EH_REGION_END corresponding to this region, or
2335    calls abort if it can't find one.
2336
2337    Can abort if INSN is not a NOTE_INSN_EH_REGION_BEGIN, or if N doesn't
2338    correspond to the region number, or if DELETE_OUTER is NULL.  */
2339
2340 static rtx
2341 scan_region (insn, n, delete_outer)
2342      rtx insn;
2343      int n;
2344      int *delete_outer;
2345 {
2346   rtx start = insn;
2347
2348   /* Assume we can delete the region.  */
2349   int delete = 1;
2350
2351   if (insn == NULL_RTX
2352       || GET_CODE (insn) != NOTE
2353       || NOTE_LINE_NUMBER (insn) != NOTE_INSN_EH_REGION_BEG
2354       || NOTE_BLOCK_NUMBER (insn) != n
2355       || delete_outer == NULL)
2356     abort ();
2357
2358   insn = NEXT_INSN (insn);
2359
2360   /* Look for the matching end.  */
2361   while (! (GET_CODE (insn) == NOTE
2362             && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END))
2363     {
2364       /* If anything can throw, we can't remove the region.  */
2365       if (delete && can_throw (insn))
2366         {
2367           delete = 0;
2368         }
2369
2370       /* Watch out for and handle nested regions.  */
2371       if (GET_CODE (insn) == NOTE
2372           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
2373         {
2374           insn = scan_region (insn, NOTE_BLOCK_NUMBER (insn), &delete);
2375         }
2376
2377       insn = NEXT_INSN (insn);
2378     }
2379
2380   /* The _BEG/_END NOTEs must match and nest.  */
2381   if (NOTE_BLOCK_NUMBER (insn) != n)
2382     abort ();
2383
2384   /* If anything in this exception region can throw, we can throw.  */
2385   if (! delete)
2386     *delete_outer = 0;
2387   else
2388     {
2389       /* Delete the start and end of the region.  */
2390       delete_insn (start);
2391       delete_insn (insn);
2392
2393 /* We no longer removed labels here, since flow will now remove any
2394    handler which cannot be called any more. */
2395
2396 #if 0
2397       /* Only do this part if we have built the exception handler
2398          labels.  */
2399       if (exception_handler_labels)
2400         {
2401           rtx x, *prev = &exception_handler_labels;
2402
2403           /* Find it in the list of handlers.  */
2404           for (x = exception_handler_labels; x; x = XEXP (x, 1))
2405             {
2406               rtx label = XEXP (x, 0);
2407               if (CODE_LABEL_NUMBER (label) == n)
2408                 {
2409                   /* If we are the last reference to the handler,
2410                      delete it.  */
2411                   if (--LABEL_NUSES (label) == 0)
2412                     delete_insn (label);
2413
2414                   if (optimize)
2415                     {
2416                       /* Remove it from the list of exception handler
2417                          labels, if we are optimizing.  If we are not, then
2418                          leave it in the list, as we are not really going to
2419                          remove the region.  */
2420                       *prev = XEXP (x, 1);
2421                       XEXP (x, 1) = 0;
2422                       XEXP (x, 0) = 0;
2423                     }
2424
2425                   break;
2426                 }
2427               prev = &XEXP (x, 1);
2428             }
2429         }
2430 #endif
2431     }
2432   return insn;
2433 }
2434
2435 /* Perform various interesting optimizations for exception handling
2436    code.
2437
2438    We look for empty exception regions and make them go (away). The
2439    jump optimization code will remove the handler if nothing else uses
2440    it.  */
2441
2442 void
2443 exception_optimize ()
2444 {
2445   rtx insn;
2446   int n;
2447
2448   /* Remove empty regions.  */
2449   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2450     {
2451       if (GET_CODE (insn) == NOTE
2452           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
2453         {
2454           /* Since scan_region will return the NOTE_INSN_EH_REGION_END
2455              insn, we will indirectly skip through all the insns
2456              inbetween. We are also guaranteed that the value of insn
2457              returned will be valid, as otherwise scan_region won't
2458              return.  */
2459           insn = scan_region (insn, NOTE_BLOCK_NUMBER (insn), &n);
2460         }
2461     }
2462 }
2463 \f
2464 /* Various hooks for the DWARF 2 __throw routine.  */
2465
2466 /* Do any necessary initialization to access arbitrary stack frames.
2467    On the SPARC, this means flushing the register windows.  */
2468
2469 void
2470 expand_builtin_unwind_init ()
2471 {
2472   /* Set this so all the registers get saved in our frame; we need to be
2473      able to copy the saved values for any registers from frames we unwind. */
2474   current_function_has_nonlocal_label = 1;
2475
2476 #ifdef SETUP_FRAME_ADDRESSES
2477   SETUP_FRAME_ADDRESSES ();
2478 #endif
2479 }
2480
2481 /* Given a value extracted from the return address register or stack slot,
2482    return the actual address encoded in that value.  */
2483
2484 rtx
2485 expand_builtin_extract_return_addr (addr_tree)
2486      tree addr_tree;
2487 {
2488   rtx addr = expand_expr (addr_tree, NULL_RTX, Pmode, 0);
2489   return eh_outer_context (addr);
2490 }
2491
2492 /* Given an actual address in addr_tree, do any necessary encoding
2493    and return the value to be stored in the return address register or
2494    stack slot so the epilogue will return to that address.  */
2495
2496 rtx
2497 expand_builtin_frob_return_addr (addr_tree)
2498      tree addr_tree;
2499 {
2500   rtx addr = expand_expr (addr_tree, NULL_RTX, Pmode, 0);
2501 #ifdef RETURN_ADDR_OFFSET
2502   addr = plus_constant (addr, -RETURN_ADDR_OFFSET);
2503 #endif
2504   return addr;
2505 }
2506
2507 /* Choose three registers for communication between the main body of
2508    __throw and the epilogue (or eh stub) and the exception handler.
2509    We must do this with hard registers because the epilogue itself
2510    will be generated after reload, at which point we may not reference
2511    pseudos at all.
2512
2513    The first passes the exception context to the handler.  For this
2514    we use the return value register for a void*.
2515
2516    The second holds the stack pointer value to be restored.  For
2517    this we use the static chain register if it exists and is different
2518    from the previous, otherwise some arbitrary call-clobbered register.
2519
2520    The third holds the address of the handler itself.  Here we use
2521    some arbitrary call-clobbered register.  */
2522
2523 static void
2524 eh_regs (pcontext, psp, pra, outgoing)
2525      rtx *pcontext, *psp, *pra;
2526      int outgoing;
2527 {
2528   rtx rcontext, rsp, rra;
2529   int i;
2530
2531 #ifdef FUNCTION_OUTGOING_VALUE
2532   if (outgoing)
2533     rcontext = FUNCTION_OUTGOING_VALUE (build_pointer_type (void_type_node),
2534                                         current_function_decl);
2535   else
2536 #endif
2537     rcontext = FUNCTION_VALUE (build_pointer_type (void_type_node),
2538                                current_function_decl);
2539
2540 #ifdef STATIC_CHAIN_REGNUM
2541   if (outgoing)
2542     rsp = static_chain_incoming_rtx;
2543   else
2544     rsp = static_chain_rtx;
2545   if (REGNO (rsp) == REGNO (rcontext))
2546 #endif /* STATIC_CHAIN_REGNUM */
2547     rsp = NULL_RTX;
2548
2549   if (rsp == NULL_RTX)
2550     {
2551       for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
2552         if (call_used_regs[i] && ! fixed_regs[i] && i != REGNO (rcontext))
2553           break;
2554       if (i == FIRST_PSEUDO_REGISTER)
2555         abort();
2556
2557       rsp = gen_rtx_REG (Pmode, i);
2558     }
2559
2560   for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
2561     if (call_used_regs[i] && ! fixed_regs[i]
2562         && i != REGNO (rcontext) && i != REGNO (rsp))
2563       break;
2564   if (i == FIRST_PSEUDO_REGISTER)
2565     abort();
2566
2567   rra = gen_rtx_REG (Pmode, i);
2568
2569   *pcontext = rcontext;
2570   *psp = rsp;
2571   *pra = rra;
2572 }
2573
2574 /* Retrieve the register which contains the pointer to the eh_context
2575    structure set the __throw. */
2576
2577 rtx
2578 get_reg_for_handler ()
2579 {
2580   rtx reg1;
2581   reg1 = FUNCTION_VALUE (build_pointer_type (void_type_node),
2582                            current_function_decl);
2583   return reg1;
2584 }
2585
2586 /* Set up the epilogue with the magic bits we'll need to return to the
2587    exception handler.  */
2588
2589 void
2590 expand_builtin_eh_return (context, stack, handler)
2591     tree context, stack, handler;
2592 {
2593   if (eh_return_context)
2594     error("Duplicate call to __builtin_eh_return");
2595
2596   eh_return_context
2597     = copy_to_reg (expand_expr (context, NULL_RTX, VOIDmode, 0));
2598   eh_return_stack_adjust
2599     = copy_to_reg (expand_expr (stack, NULL_RTX, VOIDmode, 0));
2600   eh_return_handler
2601     = copy_to_reg (expand_expr (handler, NULL_RTX, VOIDmode, 0));
2602 }
2603
2604 void
2605 expand_eh_return ()
2606 {
2607   rtx reg1, reg2, reg3;
2608   rtx stub_start, after_stub;
2609   rtx ra, tmp;
2610
2611   if (!eh_return_context)
2612     return;
2613
2614   eh_regs (&reg1, &reg2, &reg3, 1);
2615   emit_move_insn (reg1, eh_return_context);
2616   emit_move_insn (reg2, eh_return_stack_adjust);
2617   emit_move_insn (reg3, eh_return_handler);
2618
2619   /* Talk directly to the target's epilogue code when possible.  */
2620
2621 #ifdef HAVE_eh_epilogue
2622   if (HAVE_eh_epilogue)
2623     {
2624       emit_insn (gen_eh_epilogue (reg1, reg2, reg3));
2625       return;
2626     }
2627 #endif
2628
2629   /* Otherwise, use the same stub technique we had before.  */
2630
2631   eh_return_stub_label = stub_start = gen_label_rtx ();
2632   after_stub = gen_label_rtx ();
2633
2634   /* Set the return address to the stub label.  */
2635
2636   ra = expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
2637                                    0, hard_frame_pointer_rtx);
2638   if (GET_CODE (ra) == REG && REGNO (ra) >= FIRST_PSEUDO_REGISTER)
2639     abort();
2640
2641   tmp = memory_address (Pmode, gen_rtx_LABEL_REF (Pmode, stub_start));
2642 #ifdef RETURN_ADDR_OFFSET
2643   tmp = plus_constant (tmp, -RETURN_ADDR_OFFSET);
2644 #endif
2645   tmp = force_operand (tmp, ra);
2646   if (tmp != ra)
2647     emit_move_insn (ra, tmp);
2648
2649   /* Indicate that the registers are in fact used.  */
2650   emit_insn (gen_rtx_USE (VOIDmode, reg1));
2651   emit_insn (gen_rtx_USE (VOIDmode, reg2));
2652   emit_insn (gen_rtx_USE (VOIDmode, reg3));
2653   if (GET_CODE (ra) == REG)
2654     emit_insn (gen_rtx_USE (VOIDmode, ra));
2655
2656   /* Generate the stub.  */
2657
2658   emit_jump (after_stub);
2659   emit_label (stub_start);
2660
2661   eh_regs (&reg1, &reg2, &reg3, 0);
2662   adjust_stack (reg2);
2663   emit_indirect_jump (reg3);
2664
2665   emit_label (after_stub);
2666 }
2667 \f
2668
2669 /* This contains the code required to verify whether arbitrary instructions
2670    are in the same exception region. */
2671
2672 static int *insn_eh_region = (int *)0;
2673 static int maximum_uid;
2674
2675 static void
2676 set_insn_eh_region (first, region_num)
2677      rtx *first;
2678      int region_num;
2679 {
2680   rtx insn;
2681   int rnum;
2682
2683   for (insn = *first; insn; insn = NEXT_INSN (insn))
2684     {
2685       if ((GET_CODE (insn) == NOTE) &&
2686                         (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG))
2687         {
2688           rnum = NOTE_BLOCK_NUMBER (insn);
2689           insn_eh_region[INSN_UID (insn)] =  rnum;
2690           insn = NEXT_INSN (insn);
2691           set_insn_eh_region (&insn, rnum);
2692           /* Upon return, insn points to the EH_REGION_END of nested region */
2693           continue;
2694         }
2695       insn_eh_region[INSN_UID (insn)] = region_num;
2696       if ((GET_CODE (insn) == NOTE) &&
2697             (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END))
2698         break;
2699     }
2700   *first = insn;
2701 }
2702
2703 /* Free the insn table, an make sure it cannot be used again. */
2704
2705 void
2706 free_insn_eh_region ()
2707 {
2708   if (!doing_eh (0))
2709     return;
2710
2711   if (insn_eh_region)
2712     {
2713       free (insn_eh_region);
2714       insn_eh_region = (int *)0;
2715     }
2716 }
2717
2718 /* Initialize the table. max_uid must be calculated and handed into
2719    this routine. If it is unavailable, passing a value of 0 will
2720    cause this routine to calculate it as well. */
2721
2722 void
2723 init_insn_eh_region (first, max_uid)
2724      rtx first;
2725      int max_uid;
2726 {
2727   rtx insn;
2728
2729   if (!doing_eh (0))
2730     return;
2731
2732   if (insn_eh_region)
2733     free_insn_eh_region();
2734
2735   if (max_uid == 0)
2736     for (insn = first; insn; insn = NEXT_INSN (insn))
2737       if (INSN_UID (insn) > max_uid)       /* find largest UID */
2738         max_uid = INSN_UID (insn);
2739
2740   maximum_uid = max_uid;
2741   insn_eh_region = (int *) malloc ((max_uid + 1) * sizeof (int));
2742   insn = first;
2743   set_insn_eh_region (&insn, 0);
2744 }
2745
2746
2747 /* Check whether 2 instructions are within the same region. */
2748
2749 int
2750 in_same_eh_region (insn1, insn2)
2751      rtx insn1, insn2;
2752 {
2753   int ret, uid1, uid2;
2754
2755   /* If no exceptions, instructions are always in same region. */
2756   if (!doing_eh (0))
2757     return 1;
2758
2759   /* If the table isn't allocated, assume the worst. */
2760   if (!insn_eh_region)
2761     return 0;
2762
2763   uid1 = INSN_UID (insn1);
2764   uid2 = INSN_UID (insn2);
2765
2766   /* if instructions have been allocated beyond the end, either
2767      the table is out of date, or this is a late addition, or
2768      something... Assume the worst. */
2769   if (uid1 > maximum_uid || uid2 > maximum_uid)
2770     return 0;
2771
2772   ret = (insn_eh_region[uid1] == insn_eh_region[uid2]);
2773   return ret;
2774 }
2775