gcc/ch/except.c

   1 /* Exception support for GNU CHILL.
   2    WARNING:  Only works for native (needs setjmp.h)!  FIXME!
   3    Copyright (C) 1992, 93, 1994, 1998 Free Software Foundation, Inc.
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24
  25 /* On Suns this can get you to the right definition if you
  26    set the right value for TARGET.  */
  27 #include <setjmp.h>
  28 #ifdef sequent
  29 /* Can you believe they forgot this?  */
  30 #ifndef _JBLEN
  31 #define _JBLEN 11
  32 #endif
  33 #endif
  34
  35 #ifndef _JBLEN
  36 #define _JBLEN (sizeof(jmp_buf)/sizeof(int))
  37 #define _JBLEN_2 _JBLEN+20
  38 #else
  39 /* if we use i.e. posix threads, this buffer must be longer */
  40 #define _JBLEN_2 _JBLEN+20
  41 #endif
  42
  43 /* On Linux setjmp is __setjmp FIXME: what is for CROSS */
  44 #ifndef SETJMP_LIBRARY_NAME
  45 #ifdef __linux__
  46 #define SETJMP_LIBRARY_NAME "__setjmp"
  47 #else
  48 #define SETJMP_LIBRARY_NAME "setjmp"
  49 #endif
  50 #endif
  51
  52 #include "tree.h"
  53 #include "ch-tree.h"
  54 #include "rtl.h"
  55 #include "toplev.h"
  56
  57 extern int  expand_exit_needed;
  58
  59 static tree link_handler_decl;
  60 static tree handler_link_pointer_type;
  61 static tree unlink_handler_decl;
  62 static int exceptions_initialized = 0;
  63 static void emit_setup_handler PROTO((void));
  64 static void initialize_exceptions PROTO((void));
  65 static tree start_handler_array PROTO((void));
  66 static void finish_handler_array PROTO((void));
  67 static tree char_pointer_type_for_handler;
  68
  69 /* If this is 1, operations to push and pop on the __exceptionStack
  70    are inline.  The default is is to use a function call, to
  71    allow for a per-thread exception stack. */
  72 static int inline_exception_stack_ops = 0;
  73
  74 struct handler_state
  75 {
  76   struct handler_state *next;
  77
  78   /* Starts at 0, then incremented for every <on-alternative>. */
  79   int prev_on_alternative;
  80
  81   /* If > 0: handler number for ELSE handler. */
  82   int else_handler;
  83
  84   int action_number;
  85
  86   char do_pushlevel;
  87
  88   tree on_alt_list;
  89   tree setjmp_expr;
  90
  91   /* A decl for the static handler array (used to map exception name to int).*/
  92   tree handler_array_decl;
  93
  94   rtx end_label;
  95
  96   /* Used to pass a tree from emit_setup_handler to chill_start_on. */
  97   tree handler_ref;
  98
  99   tree unlink_cleanup;
 100
 101   tree function;
 102
 103   /* flag to indicate that we are currently compiling this handler.
 104      is_handled will need this to determine an unhandled exception */
 105   int compiling;
 106 };
 107
 108 /* This is incremented by one each time we start an action which
 109    might have an ON-handler.  It is reset between passes. */
 110 static int action_number = 0;
 111
 112 int action_nesting_level = 0;
 113
 114 /* The global_handler_list is constructed in pass 1.  It is not sorted.
 115    It contains one element for each action that actually had an ON-handler.
 116    An element's ACTION_NUMBER matches the action_number
 117    of that action.  The global_handler_list is eaten up during pass 2. */
 118 #define ACTION_NUMBER(HANDLER) ((HANDLER)->action_number)
 119 struct handler_state *global_handler_list = NULL;
 120
 121 /* This is a stack of handlers, one for each nested ON-handler. */
 122 static struct handler_state *current_handler = NULL;
 123
 124 static struct handler_state *free_handlers = NULL; /* freelist */
 125
 126 static tree handler_element_type;
 127 static tree handler_link_type;
 128 static tree BISJ;
 129 static tree jbuf_ident, prev_ident, handlers_ident;
 130 static tree exception_stack_decl = 0;
 131
 132 /* Chain of cleanups assocated with exception handlers.
 133    The TREE_PURPOSE is an INTEGER_CST whose value is the
 134    DECL_ACTION_NESTING_LEVEL (when the handled actions was entered).
 135    The TREE_VALUE is an expression to expand when we exit that action. */
 136
 137 static tree cleanup_chain = NULL_TREE;
 138 \f
 139 #if 0
 140 /* Merge the current sequence onto the tail of the previous one. */
 141
 142 void
 143 pop_sequence ()
 144 {
 145   rtx sequence_first = get_insns ();
 146
 147   end_sequence ();
 148   emit_insns (sequence_first);
 149
 150 }
 151 #endif
 152
 153 /* Things we need to do at the beginning of pass 2. */
 154
 155 void
 156 except_init_pass_2 ()
 157 {
 158   /* First sort the global_handler_list on ACTION_NUMBER.
 159      This will already be in close to reverse order (the exception being
 160      nested ON-handlers), so insertion sort should essentially linear. */
 161
 162   register struct handler_state *old_list = global_handler_list;
 163
 164   /* First add a dummy final element. */
 165   if (free_handlers)
 166     global_handler_list = free_handlers;
 167   else
 168     global_handler_list
 169       = (struct handler_state*) permalloc (sizeof (struct handler_state));
 170   /* Make the final dummy "larger" than any other element. */
 171   ACTION_NUMBER (global_handler_list) = action_number + 1;
 172   /* Now move all the elements in old_list over to global_handler_list. */
 173   while (old_list != NULL)
 174     {
 175       register struct handler_state **ptr = &global_handler_list;
 176       /* Unlink from old_list. */
 177       register struct handler_state *current = old_list;
 178       old_list = old_list->next;
 179
 180       while (ACTION_NUMBER (current) > ACTION_NUMBER (*ptr))
 181         ptr = &(*ptr)->next;
 182       /* Link into proper place in global_handler_list (new list). */
 183       current->next = *ptr;
 184       *ptr = current;
 185     }
 186
 187   /* Don't forget to reset action_number. */
 188   action_number = 0;
 189 }
 190
 191 /* This function is called at the beginning of an action that might be
 192    followed by an ON-handler.  Chill syntax doesn't let us know if
 193    we actually have an ON-handler until we see the ON, so we save
 194    away during pass 1 that information for use during pass 2. */
 195
 196 void
 197 push_handler ()
 198 {
 199   register struct handler_state *hstate;
 200
 201   action_number++;
 202   action_nesting_level++;
 203
 204   if (pass == 1)
 205     {
 206       if (free_handlers)
 207         {
 208           hstate = free_handlers;
 209           free_handlers = hstate->next;
 210         }
 211       else
 212         {
 213           hstate =
 214             (struct handler_state*) permalloc (sizeof (struct handler_state));
 215         }
 216
 217       hstate->next = current_handler;
 218       current_handler = hstate;
 219       hstate->prev_on_alternative = 0;
 220       hstate->else_handler = 0;
 221       hstate->on_alt_list = NULL_TREE;
 222       hstate->compiling = 0;
 223
 224       ACTION_NUMBER (hstate) = action_number;
 225       return;
 226     }
 227
 228   if (ACTION_NUMBER (global_handler_list) != action_number)
 229     return;
 230
 231   /* OK.  This action actually has an ON-handler.
 232      Pop it from global_handler_list, and use it. */
 233
 234   hstate = global_handler_list;
 235   global_handler_list = hstate->next;
 236
 237   /* Since this is pass 2, let's generate prologue code for that. */
 238
 239   hstate->next = current_handler;
 240   current_handler = hstate;
 241
 242   hstate->prev_on_alternative = 0;
 243   hstate->function = current_function_decl;
 244
 245   emit_setup_handler ();
 246 }
 247
 248 static tree
 249 start_handler_array ()
 250 {
 251   tree handler_array_type, decl;
 252
 253   push_obstacks_nochange ();
 254   end_temporary_allocation ();
 255   handler_array_type = build_array_type (handler_element_type, NULL_TREE);
 256   decl = build_lang_decl (VAR_DECL,
 257                           get_unique_identifier ("handler_table"),
 258                           handler_array_type);
 259
 260 /*  TREE_TYPE (decl) = handler_array_type;*/
 261   TREE_READONLY (decl) = 1;
 262   TREE_STATIC (decl) = 1;
 263   DECL_INITIAL (decl) = error_mark_node;
 264
 265   pushdecl (decl);
 266   make_decl_rtl (decl, NULL_PTR, 0);
 267   current_handler->handler_array_decl = decl;
 268   return decl;
 269 }
 270
 271 static void
 272 finish_handler_array ()
 273 {
 274   tree decl = current_handler->handler_array_decl;
 275   tree t;
 276   tree handler_array_init = NULL_TREE;
 277   int handlers_count = 1;
 278   int nelts;
 279
 280   /* Build the table mapping exceptions to handler(-number)s.
 281      This is done in reverse order. */
 282
 283   /* First push the end of the list.  This is either the ELSE
 284      handler (current_handler->else_handler>0) or NULL handler to indicate
 285      the end of the list (if current_handler->else-handler == 0).
 286      The following works either way. */
 287   handler_array_init = build_tree_list
 288     (NULL_TREE, chill_expand_tuple
 289      (handler_element_type,
 290       build_nt (CONSTRUCTOR, NULL_TREE,
 291                 tree_cons (NULL_TREE,
 292                            null_pointer_node,
 293                            build_tree_list (NULL_TREE,
 294                                             build_int_2 (current_handler->else_handler,
 295                                                              0))))));
 296
 297   for (t = current_handler->on_alt_list; t != NULL_TREE; t = TREE_CHAIN (t))
 298     { tree handler_number = TREE_PURPOSE(t);
 299       tree elist = TREE_VALUE (t);
 300       for ( ; elist != NULL_TREE; elist = TREE_CHAIN (elist))
 301         {
 302           tree ex_decl =
 303             build_chill_exception_decl (IDENTIFIER_POINTER(TREE_VALUE(elist)));
 304           tree ex_addr = build1 (ADDR_EXPR,
 305                                  char_pointer_type_for_handler,
 306                                  ex_decl);
 307           tree el = build_nt (CONSTRUCTOR, NULL_TREE,
 308                               tree_cons (NULL_TREE,
 309                                          ex_addr,
 310                                          build_tree_list (NULL_TREE,
 311                                                           handler_number)));
 312           mark_addressable (ex_decl);
 313           TREE_CONSTANT (ex_addr) = 1;
 314           handler_array_init =
 315             tree_cons (NULL_TREE,
 316                        chill_expand_tuple (handler_element_type, el),
 317                        handler_array_init);
 318           handlers_count++;
 319         }
 320     }
 321
 322 #if 1
 323   nelts = list_length (handler_array_init);
 324   TYPE_DOMAIN (TREE_TYPE (decl))
 325     = build_index_type (build_int_2 (nelts - 1, - (nelts == 0)));
 326   layout_type (TREE_TYPE (decl));
 327   DECL_INITIAL (decl)
 328     = convert (TREE_TYPE (decl),
 329                build_nt (CONSTRUCTOR, NULL_TREE, handler_array_init));
 330
 331   /* Pop back to the obstack that is current for this binding level.
 332      This is because MAXINDEX, rtl, etc. to be made below
 333      must go in the permanent obstack.  But don't discard the
 334      temporary data yet.  */
 335   pop_obstacks ();
 336   layout_decl (decl, 0);
 337   /* To prevent make_decl_rtl (called indiectly by rest_of_decl_compilation)
 338      throwing the existing RTL (which has already been used). */
 339   PUT_MODE (DECL_RTL (decl), DECL_MODE (decl));
 340   rest_of_decl_compilation (decl, (char*)0, 0, 0);
 341   expand_decl_init (decl);
 342 #else
 343   /* To prevent make_decl_rtl (called indirectly by finish_decl)
 344      altering the existing RTL. */
 345   GET_MODE (DECL_RTL (current_handler->handler_array_decl)) =
 346     DECL_MODE (current_handler->handler_array_decl);
 347
 348   finish_decl (current_handler->handler_array_decl,
 349                build_nt (CONSTRUCTOR, NULL_TREE, handler_array_init),
 350                NULL_TREE);
 351 #endif
 352 }
 353
 354
 355 void
 356 pop_handler (used)
 357      int used;
 358 {
 359   action_nesting_level--;
 360   if (pass == 1)
 361     {
 362       struct handler_state *old = current_handler;
 363       if (old == NULL)
 364         fatal ("internal error: on stack out of sync");
 365       current_handler = old->next;
 366
 367       if (used)
 368         { /* Push unto global_handler_list. */
 369           old->next = global_handler_list;
 370           global_handler_list = old;
 371         }
 372       else
 373         {
 374           /* Push onto free_handlers free list. */
 375           old->next = free_handlers;
 376           free_handlers = old;
 377         }
 378     }
 379   else if (used)
 380     {
 381       current_handler = current_handler->next;
 382     }
 383 }
 384
 385 /* Emit code before an action that has an ON-handler. */
 386
 387 static void
 388 emit_setup_handler ()
 389 {
 390   tree handler_decl, handler_addr, t;
 391
 392   /* Field references. */
 393   tree jbuf_ref, handlers_ref,prev_ref;
 394   if (!exceptions_initialized)
 395     {
 396       /* We temporarily reset the maximum_field_alignment to zero so the
 397          compiler's exception data structures can be compatible with the
 398          run-time system, even when we're compiling with -fpack. */
 399       extern int maximum_field_alignment;
 400       int save_maximum_field_alignment = maximum_field_alignment;
 401       maximum_field_alignment = 0;
 402       push_obstacks_nochange ();
 403       end_temporary_allocation ();
 404       initialize_exceptions ();
 405       pop_obstacks ();
 406       maximum_field_alignment = save_maximum_field_alignment;
 407     }
 408
 409   push_momentary ();
 410
 411   handler_decl = build_lang_decl (VAR_DECL,
 412                                   get_unique_identifier ("handler"),
 413                                   handler_link_type);
 414   push_obstacks_nochange ();
 415   pushdecl(handler_decl);
 416   expand_decl (handler_decl);
 417   finish_decl (handler_decl);
 418
 419   jbuf_ref = build_component_ref (handler_decl, jbuf_ident);
 420   jbuf_ref = build_chill_arrow_expr (jbuf_ref, 1);
 421   handlers_ref = build_component_ref (handler_decl, handlers_ident);
 422   prev_ref = build_component_ref (handler_decl, prev_ident);
 423
 424   /* Emit code to link in handler in __exceptionStack chain. */
 425   mark_addressable (handler_decl);
 426   handler_addr = build1 (ADDR_EXPR, handler_link_pointer_type, handler_decl);
 427   if (inline_exception_stack_ops)
 428     {
 429       expand_expr_stmt (build_chill_modify_expr (prev_ref,
 430                                                  exception_stack_decl));
 431       expand_expr_stmt (build_chill_modify_expr (exception_stack_decl,
 432                                                  handler_addr));
 433       current_handler->handler_ref = prev_ref;
 434     }
 435   else
 436     {
 437       expand_expr_stmt (build_chill_function_call (link_handler_decl,
 438                                              build_tree_list (NULL_TREE,
 439                                                               handler_addr)));
 440       current_handler->handler_ref = handler_addr;
 441     }
 442
 443   /* Expand:  handler->__handlers = { <<array mapping names to ints } */
 444   t =  build1 (NOP_EXPR, build_pointer_type (handler_element_type),
 445                build_chill_arrow_expr (start_handler_array (), 1));
 446   expand_expr_stmt (build_chill_modify_expr (handlers_ref, t));
 447
 448   /* Emit code to unlink handler. */
 449   if (inline_exception_stack_ops)
 450     current_handler->unlink_cleanup
 451       = build_chill_modify_expr (exception_stack_decl,
 452                                  current_handler->handler_ref);
 453   else
 454     current_handler->unlink_cleanup
 455       = build_chill_function_call (unlink_handler_decl,
 456                                    build_tree_list(NULL_TREE,
 457                                                current_handler->handler_ref));
 458   cleanup_chain = tree_cons (build_int_2 (action_nesting_level, 0),
 459                              current_handler->unlink_cleanup,
 460                              cleanup_chain);
 461
 462   /* Emit code for setjmp. */
 463
 464   current_handler->setjmp_expr =
 465     build_chill_function_call (BISJ, build_tree_list (NULL_TREE, jbuf_ref));
 466   expand_start_case (1, current_handler->setjmp_expr,
 467                      integer_type_node, "on handler");
 468
 469   chill_handle_case_label (integer_zero_node, current_handler->setjmp_expr);
 470 }
 471
 472 /* Start emitting code for: <actions> ON <handlers> END.
 473    Assume we've parsed <actions>, and the setup needed for it. */
 474
 475 void
 476 chill_start_on ()
 477 {
 478   expand_expr_stmt (current_handler->unlink_cleanup);
 479
 480   /* Emit code to jump past the handlers. */
 481   current_handler->end_label = gen_label_rtx ();
 482   current_handler->compiling = 1;
 483   emit_jump (current_handler->end_label);
 484 }
 485
 486 void
 487 chill_finish_on ()
 488 {
 489   expand_end_case (current_handler->setjmp_expr);
 490
 491   finish_handler_array ();
 492
 493   emit_label (current_handler->end_label);
 494
 495   pop_momentary ();
 496
 497   cleanup_chain = TREE_CHAIN (cleanup_chain);
 498 }
 499
 500 void
 501 chill_handle_on_labels (labels)
 502      tree labels;
 503 {
 504   int alternative = ++current_handler->prev_on_alternative;
 505   if (pass == 1)
 506     {
 507       tree handler_number = build_int_2 (alternative, 0);
 508       current_handler->on_alt_list =
 509         tree_cons (handler_number, labels, current_handler->on_alt_list);
 510     }
 511   else
 512     {
 513       /* Find handler_number saved in pass 1. */
 514       tree tmp = current_handler->on_alt_list;
 515       while (TREE_INT_CST_LOW (TREE_PURPOSE (tmp)) != alternative)
 516         tmp = TREE_CHAIN (tmp);
 517       if (expand_exit_needed)
 518         expand_exit_something (), expand_exit_needed = 0;
 519       chill_handle_case_label (TREE_PURPOSE (tmp),
 520                                current_handler->setjmp_expr);
 521     }
 522 }
 523
 524 void
 525 chill_start_default_handler ()
 526 {
 527   current_handler->else_handler = ++current_handler->prev_on_alternative;
 528   if (!ignoring)
 529     {
 530       chill_handle_case_default ();
 531     }
 532 }
 533
 534 void
 535 chill_check_no_handlers ()
 536 {
 537   if (current_handler != NULL)
 538     fatal ("internal error: on stack not empty when done");
 539 }
 540
 541 static void
 542 initialize_exceptions ()
 543 {
 544   tree jmp_buf_type = build_array_type (integer_type_node,
 545                                         build_index_type (build_int_2 (_JBLEN_2-1, 0)));
 546   tree setjmp_fndecl, link_ftype;
 547   tree parmtypes
 548     = tree_cons (NULL_TREE, build_pointer_type (jmp_buf_type), void_list_node);
 549
 550   setjmp_fndecl = builtin_function ("setjmp",
 551                                     build_function_type (integer_type_node,
 552                                                          parmtypes),
 553                                     0, NOT_BUILT_IN,
 554                                     SETJMP_LIBRARY_NAME);
 555   BISJ = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (setjmp_fndecl)),
 556                  setjmp_fndecl);
 557
 558   char_pointer_type_for_handler
 559     = build_pointer_type (build_type_variant (char_type_node, 1, 0));
 560   handler_element_type =
 561     build_chill_struct_type (chainon
 562                              (build_decl (FIELD_DECL,
 563                                           get_identifier("__exceptid"),
 564                                           char_pointer_type_for_handler),
 565                               build_decl (FIELD_DECL,
 566                                           get_identifier("__handlerno"),
 567                                           integer_type_node)));
 568
 569   jbuf_ident = get_identifier("__jbuf");
 570   prev_ident = get_identifier("__prev");
 571   handlers_ident = get_identifier("__handlers");
 572
 573   handler_link_type =
 574     build_chill_struct_type
 575       (chainon
 576        (build_decl (FIELD_DECL, prev_ident, ptr_type_node),
 577         chainon
 578         (build_decl (FIELD_DECL, handlers_ident,
 579                      build_pointer_type (handler_element_type)),
 580          build_decl (FIELD_DECL, jbuf_ident, jmp_buf_type))));
 581
 582   handler_link_pointer_type = build_pointer_type (handler_link_type);
 583
 584   if (inline_exception_stack_ops)
 585     {
 586       exception_stack_decl =
 587         build_lang_decl (VAR_DECL,
 588                          get_identifier("__exceptionStack"),
 589                          handler_link_pointer_type);
 590       TREE_STATIC (exception_stack_decl) = 1;
 591       TREE_PUBLIC (exception_stack_decl) = 1;
 592       DECL_EXTERNAL (exception_stack_decl) = 1;
 593       push_obstacks_nochange ();
 594       pushdecl(exception_stack_decl);
 595       make_decl_rtl (exception_stack_decl, NULL_PTR, 1);
 596       finish_decl (exception_stack_decl);
 597     }
 598
 599   link_ftype = build_function_type (void_type_node,
 600                                     tree_cons (NULL_TREE,
 601                                                handler_link_pointer_type,
 602                                                void_list_node));
 603   link_handler_decl = builtin_function ("__ch_link_handler", link_ftype,
 604                                         0, NOT_BUILT_IN, NULL_PTR);
 605   unlink_handler_decl = builtin_function ("__ch_unlink_handler", link_ftype,
 606                                           0, NOT_BUILT_IN, NULL_PTR);
 607
 608   exceptions_initialized = 1;
 609 }
 610
 611 /* Do the cleanup(s) needed for a GOTO label.
 612    We only need to do the last of the cleanups. */
 613
 614 void
 615 expand_goto_except_cleanup (label_level)
 616      int label_level;
 617 {
 618   tree list = cleanup_chain;
 619   tree last = NULL_TREE;
 620   for ( ; list != NULL_TREE; list = TREE_CHAIN (list))
 621     {
 622       if (TREE_INT_CST_LOW (TREE_PURPOSE (list)) > label_level)
 623         last = list;
 624       else
 625         break;
 626     }
 627   if (last)
 628     expand_expr_stmt (TREE_VALUE (last));
 629 }
 630
 631 /* Returns true if there is a valid handler for EXCEPT_NAME
 632    in the current static scope.
 633    0 ... no handler found
 634    1 ... local handler available
 635    2 ... function may propagate this exception
 636 */
 637
 638 int
 639 is_handled (except_name)
 640      tree except_name;
 641 {
 642   tree t;
 643   struct handler_state *h = current_handler;
 644
 645   /* if we are are currently compiling this handler
 646      we have to start at the next level */
 647   if (h && h->compiling)
 648     h = h->next;
 649   while (h != NULL)
 650     {
 651       if (h->function != current_function_decl)
 652         break;
 653       if (h->else_handler > 0)
 654         return 1;
 655       for (t = h->on_alt_list; t != NULL_TREE; t = TREE_CHAIN (t))
 656         {
 657           if (value_member (except_name, TREE_VALUE (t)))
 658             return 1;
 659         }
 660       h = h->next;
 661     }
 662
 663   t = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl));
 664
 665   if (value_member (except_name, t))
 666     return 2;
 667   return 0;
 668 }
 669
 670 /* function generates code to reraise exceptions
 671    for PROC's propagating exceptions. */
 672
 673 void
 674 chill_reraise_exceptions (exceptions)
 675      tree exceptions;
 676 {
 677   tree wrk;
 678
 679   if (exceptions == NULL_TREE)
 680     return; /* just in case */
 681
 682   if (pass == 1)
 683     {
 684       for (wrk = exceptions; wrk != NULL_TREE; wrk = TREE_CHAIN (wrk))
 685         chill_handle_on_labels (build_tree_list (NULL_TREE, TREE_VALUE (wrk)));
 686     }
 687   else /* pass == 2 */
 688     {
 689       chill_start_on ();
 690       expand_exit_needed = 0;
 691
 692       for (wrk = exceptions; wrk != NULL_TREE; wrk = TREE_CHAIN (wrk))
 693         {
 694           chill_handle_on_labels (TREE_VALUE (wrk));
 695           /* do a CAUSE exception */
 696           expand_expr_stmt (build_cause_exception (TREE_VALUE (wrk), 0));
 697           expand_exit_needed = 1;
 698         }
 699       chill_finish_on ();
 700     }
 701   pop_handler (1);
 702 }