gcc/except.c

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