aboutsummaryrefslogtreecommitdiff
path: root/gcc/ch/except.c
blob: 7870a397b11b6ca948bec4bdb5fb660d46a2dc49 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
/* Exception support for GNU CHILL.
   WARNING:  Only works for native (needs setjmp.h)!  FIXME!
   Copyright (C) 1992, 93, 1994, 1998 Free Software Foundation, Inc.

This file is part of GNU CC.

GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING.  If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */

#include "config.h"
#include "system.h"

/* On Suns this can get you to the right definition if you
   set the right value for TARGET.  */
#include <setjmp.h>
#ifdef sequent
/* Can you believe they forgot this?  */
#ifndef _JBLEN
#define _JBLEN 11
#endif
#endif

#ifndef _JBLEN
#define _JBLEN (sizeof(jmp_buf)/sizeof(int))
#define _JBLEN_2 _JBLEN+20
#else
/* if we use i.e. posix threads, this buffer must be longer */
#define _JBLEN_2 _JBLEN+20
#endif

/* On Linux setjmp is __setjmp FIXME: what is for CROSS */
#ifndef SETJMP_LIBRARY_NAME
#ifdef __linux__
#define SETJMP_LIBRARY_NAME "__setjmp"
#else
#define SETJMP_LIBRARY_NAME "setjmp"
#endif
#endif

#include "tree.h"
#include "ch-tree.h"
#include "rtl.h"
#include "toplev.h"

extern int  expand_exit_needed;

static tree link_handler_decl;
static tree handler_link_pointer_type;
static tree unlink_handler_decl;
static int exceptions_initialized = 0;
static void emit_setup_handler PROTO((void));
static void initialize_exceptions PROTO((void));
static tree start_handler_array PROTO((void));
static void finish_handler_array PROTO((void));
static tree char_pointer_type_for_handler;

/* If this is 1, operations to push and pop on the __exceptionStack
   are inline.  The default is is to use a function call, to
   allow for a per-thread exception stack. */
static int inline_exception_stack_ops = 0;

struct handler_state
{
  struct handler_state *next;

  /* Starts at 0, then incremented for every <on-alternative>. */
  int prev_on_alternative;

  /* If > 0: handler number for ELSE handler. */
  int else_handler;

  int action_number;

  char do_pushlevel;

  tree on_alt_list;
  tree setjmp_expr;

  /* A decl for the static handler array (used to map exception name to int).*/
  tree handler_array_decl;

  rtx end_label;

  /* Used to pass a tree from emit_setup_handler to chill_start_on. */
  tree handler_ref;

  tree unlink_cleanup;

  tree function;

  /* flag to indicate that we are currently compiling this handler.
     is_handled will need this to determine an unhandled exception */
  int compiling;
};

/* This is incremented by one each time we start an action which
   might have an ON-handler.  It is reset between passes. */
static int action_number = 0;

int action_nesting_level = 0;

/* The global_handler_list is constructed in pass 1.  It is not sorted.
   It contains one element for each action that actually had an ON-handler.
   An element's ACTION_NUMBER matches the action_number
   of that action.  The global_handler_list is eaten up during pass 2. */
#define ACTION_NUMBER(HANDLER) ((HANDLER)->action_number)
struct handler_state *global_handler_list = NULL;

/* This is a stack of handlers, one for each nested ON-handler. */
static struct handler_state *current_handler = NULL;

static struct handler_state *free_handlers = NULL; /* freelist */

static tree handler_element_type;
static tree handler_link_type;
static tree BISJ;
static tree jbuf_ident, prev_ident, handlers_ident;
static tree exception_stack_decl = 0;

/* Chain of cleanups assocated with exception handlers.
   The TREE_PURPOSE is an INTEGER_CST whose value is the
   DECL_ACTION_NESTING_LEVEL (when the handled actions was entered).
   The TREE_VALUE is an expression to expand when we exit that action. */

static tree cleanup_chain = NULL_TREE;

#if 0
/* Merge the current sequence onto the tail of the previous one. */

void
pop_sequence ()
{
  rtx sequence_first = get_insns ();

  end_sequence ();
  emit_insns (sequence_first);
  
}
#endif

/* Things we need to do at the beginning of pass 2. */

void
except_init_pass_2 ()
{
  /* First sort the global_handler_list on ACTION_NUMBER.
     This will already be in close to reverse order (the exception being
     nested ON-handlers), so insertion sort should essentially linear. */

  register struct handler_state *old_list = global_handler_list;

  /* First add a dummy final element. */
  if (free_handlers)
    global_handler_list = free_handlers;
  else
    global_handler_list
      = (struct handler_state*) permalloc (sizeof (struct handler_state));
  /* Make the final dummy "larger" than any other element. */
  ACTION_NUMBER (global_handler_list) = action_number + 1;
  /* Now move all the elements in old_list over to global_handler_list. */
  while (old_list != NULL)
    {
      register struct handler_state **ptr = &global_handler_list;
      /* Unlink from old_list. */
      register struct handler_state *current = old_list;
      old_list = old_list->next;

      while (ACTION_NUMBER (current) > ACTION_NUMBER (*ptr))
	ptr = &(*ptr)->next;
      /* Link into proper place in global_handler_list (new list). */
      current->next = *ptr;
      *ptr = current;
    }
     
  /* Don't forget to reset action_number. */
  action_number = 0;
}

/* This function is called at the beginning of an action that might be
   followed by an ON-handler.  Chill syntax doesn't let us know if
   we actually have an ON-handler until we see the ON, so we save
   away during pass 1 that information for use during pass 2. */

void
push_handler ()
{
  register struct handler_state *hstate;

  action_number++;
  action_nesting_level++;

  if (pass == 1)
    {
      if (free_handlers)
	{
	  hstate = free_handlers;
	  free_handlers = hstate->next;
	}
      else
	{
	  hstate =
	    (struct handler_state*) permalloc (sizeof (struct handler_state));
	}

      hstate->next = current_handler;
      current_handler = hstate;
      hstate->prev_on_alternative = 0;
      hstate->else_handler = 0;
      hstate->on_alt_list = NULL_TREE;
      hstate->compiling = 0;

      ACTION_NUMBER (hstate) = action_number;
      return;
    }

  if (ACTION_NUMBER (global_handler_list) != action_number)
    return;

  /* OK.  This action actually has an ON-handler.
     Pop it from global_handler_list, and use it. */

  hstate = global_handler_list;
  global_handler_list = hstate->next;

  /* Since this is pass 2, let's generate prologue code for that. */

  hstate->next = current_handler;
  current_handler = hstate;

  hstate->prev_on_alternative = 0;
  hstate->function = current_function_decl;

  emit_setup_handler ();
}

static tree
start_handler_array ()
{
  tree handler_array_type, decl;

  push_obstacks_nochange ();
  end_temporary_allocation ();
  handler_array_type = build_array_type (handler_element_type, NULL_TREE);
  decl = build_lang_decl (VAR_DECL,
			  get_unique_identifier ("handler_table"),
			  handler_array_type);

/*  TREE_TYPE (decl) = handler_array_type;*/
  TREE_READONLY (decl) = 1;
  TREE_STATIC (decl) = 1;
  DECL_INITIAL (decl) = error_mark_node;
  
  pushdecl (decl);
  make_decl_rtl (decl, NULL_PTR, 0);
  current_handler->handler_array_decl = decl;
  return decl;
}

static void
finish_handler_array ()
{
  tree decl = current_handler->handler_array_decl;
  tree t;
  tree handler_array_init = NULL_TREE;
  int handlers_count = 1;
  int nelts;

  /* Build the table mapping exceptions to handler(-number)s.
     This is done in reverse order. */
  
  /* First push the end of the list.  This is either the ELSE
     handler (current_handler->else_handler>0) or NULL handler to indicate
     the end of the list (if current_handler->else-handler == 0).
     The following works either way. */
  handler_array_init = build_tree_list
    (NULL_TREE, chill_expand_tuple
     (handler_element_type,
      build_nt (CONSTRUCTOR, NULL_TREE,
		tree_cons (NULL_TREE,
			   null_pointer_node,
			   build_tree_list (NULL_TREE,
					    build_int_2 (current_handler->else_handler,
							     0))))));
  
  for (t = current_handler->on_alt_list; t != NULL_TREE; t = TREE_CHAIN (t))
    { tree handler_number = TREE_PURPOSE(t);
      tree elist = TREE_VALUE (t);
      for ( ; elist != NULL_TREE; elist = TREE_CHAIN (elist))
	{
	  tree ex_decl =
	    build_chill_exception_decl (IDENTIFIER_POINTER(TREE_VALUE(elist)));
	  tree ex_addr = build1 (ADDR_EXPR,
				 char_pointer_type_for_handler,
				 ex_decl);
	  tree el = build_nt (CONSTRUCTOR, NULL_TREE,
			      tree_cons (NULL_TREE,
					 ex_addr,
					 build_tree_list (NULL_TREE,
							  handler_number)));
	  mark_addressable (ex_decl);
	  TREE_CONSTANT (ex_addr) = 1;
	  handler_array_init =
	    tree_cons (NULL_TREE,
		       chill_expand_tuple (handler_element_type, el),
		       handler_array_init);
	  handlers_count++;
	}
    }

#if 1
  nelts = list_length (handler_array_init);
  TYPE_DOMAIN (TREE_TYPE (decl))
    = build_index_type (build_int_2 (nelts - 1, - (nelts == 0)));
  layout_type (TREE_TYPE (decl));
  DECL_INITIAL (decl)
    = convert (TREE_TYPE (decl),
	       build_nt (CONSTRUCTOR, NULL_TREE, handler_array_init));

  /* Pop back to the obstack that is current for this binding level.
     This is because MAXINDEX, rtl, etc. to be made below
     must go in the permanent obstack.  But don't discard the
     temporary data yet.  */
  pop_obstacks ();
  layout_decl (decl, 0);
  /* To prevent make_decl_rtl (called indiectly by rest_of_decl_compilation)
     throwing the existing RTL (which has already been used). */
  PUT_MODE (DECL_RTL (decl), DECL_MODE (decl));
  rest_of_decl_compilation (decl, (char*)0, 0, 0);
  expand_decl_init (decl);
#else
  /* To prevent make_decl_rtl (called indirectly by finish_decl)
     altering the existing RTL. */
  GET_MODE (DECL_RTL (current_handler->handler_array_decl)) =
    DECL_MODE (current_handler->handler_array_decl);

  finish_decl (current_handler->handler_array_decl,
	       build_nt (CONSTRUCTOR, NULL_TREE, handler_array_init),
	       NULL_TREE);
#endif
}


void
pop_handler (used)
     int used;
{
  action_nesting_level--;
  if (pass == 1)
    {
      struct handler_state *old = current_handler;
      if (old == NULL)
	fatal ("internal error: on stack out of sync");
      current_handler = old->next;

      if (used)
	{ /* Push unto global_handler_list. */
	  old->next = global_handler_list;
	  global_handler_list = old;
	}
      else
	{
	  /* Push onto free_handlers free list. */
	  old->next = free_handlers;
	  free_handlers = old;
	}
    }
  else if (used)
    {
      current_handler = current_handler->next;
    }
}

/* Emit code before an action that has an ON-handler. */

static void
emit_setup_handler ()
{
  tree handler_decl, handler_addr, t;

  /* Field references. */
  tree jbuf_ref, handlers_ref,prev_ref;
  if (!exceptions_initialized)
    {
      /* We temporarily reset the maximum_field_alignment to zero so the
	 compiler's exception data structures can be compatible with the
	 run-time system, even when we're compiling with -fpack. */
      extern int maximum_field_alignment;
      int save_maximum_field_alignment = maximum_field_alignment;
      maximum_field_alignment = 0;
      push_obstacks_nochange ();
      end_temporary_allocation ();
      initialize_exceptions ();
      pop_obstacks ();
      maximum_field_alignment = save_maximum_field_alignment;
    }

  push_momentary ();

  handler_decl = build_lang_decl (VAR_DECL,
				  get_unique_identifier ("handler"),
				  handler_link_type);
  push_obstacks_nochange ();
  pushdecl(handler_decl);
  expand_decl (handler_decl);
  finish_decl (handler_decl);

  jbuf_ref = build_component_ref (handler_decl, jbuf_ident);
  jbuf_ref = build_chill_arrow_expr (jbuf_ref, 1);
  handlers_ref = build_component_ref (handler_decl, handlers_ident);
  prev_ref = build_component_ref (handler_decl, prev_ident);

  /* Emit code to link in handler in __exceptionStack chain. */
  mark_addressable (handler_decl);
  handler_addr = build1 (ADDR_EXPR, handler_link_pointer_type, handler_decl);
  if (inline_exception_stack_ops)
    {
      expand_expr_stmt (build_chill_modify_expr (prev_ref,
						 exception_stack_decl));
      expand_expr_stmt (build_chill_modify_expr (exception_stack_decl,
						 handler_addr));
      current_handler->handler_ref = prev_ref;
    }
  else
    {
      expand_expr_stmt (build_chill_function_call (link_handler_decl,
					     build_tree_list (NULL_TREE,
							      handler_addr)));
      current_handler->handler_ref = handler_addr;
    }

  /* Expand:  handler->__handlers = { <<array mapping names to ints } */
  t =  build1 (NOP_EXPR, build_pointer_type (handler_element_type),
	       build_chill_arrow_expr (start_handler_array (), 1));
  expand_expr_stmt (build_chill_modify_expr (handlers_ref, t));

  /* Emit code to unlink handler. */
  if (inline_exception_stack_ops)
    current_handler->unlink_cleanup
      = build_chill_modify_expr (exception_stack_decl,
				 current_handler->handler_ref);
  else
    current_handler->unlink_cleanup
      = build_chill_function_call (unlink_handler_decl,
				   build_tree_list(NULL_TREE,
					       current_handler->handler_ref));
  cleanup_chain = tree_cons (build_int_2 (action_nesting_level, 0),
			     current_handler->unlink_cleanup,
			     cleanup_chain);

  /* Emit code for setjmp. */
  
  current_handler->setjmp_expr =
    build_chill_function_call (BISJ, build_tree_list (NULL_TREE, jbuf_ref));
  expand_start_case (1, current_handler->setjmp_expr,
		     integer_type_node, "on handler");

  chill_handle_case_label (integer_zero_node, current_handler->setjmp_expr);
}

/* Start emitting code for: <actions> ON <handlers> END.
   Assume we've parsed <actions>, and the setup needed for it. */

void
chill_start_on ()
{
  expand_expr_stmt (current_handler->unlink_cleanup);

  /* Emit code to jump past the handlers. */
  current_handler->end_label = gen_label_rtx ();
  current_handler->compiling = 1;
  emit_jump (current_handler->end_label);
}

void
chill_finish_on ()
{
  expand_end_case (current_handler->setjmp_expr);
  
  finish_handler_array ();

  emit_label (current_handler->end_label);

  pop_momentary ();

  cleanup_chain = TREE_CHAIN (cleanup_chain);
}

void
chill_handle_on_labels (labels)
     tree labels;
{
  int alternative = ++current_handler->prev_on_alternative;
  if (pass == 1)
    {
      tree handler_number = build_int_2 (alternative, 0);
      current_handler->on_alt_list =
	tree_cons (handler_number, labels, current_handler->on_alt_list);
    }
  else
    {
      /* Find handler_number saved in pass 1. */
      tree tmp = current_handler->on_alt_list;
      while (TREE_INT_CST_LOW (TREE_PURPOSE (tmp)) != alternative)
	tmp = TREE_CHAIN (tmp);
      if (expand_exit_needed)
	expand_exit_something (), expand_exit_needed = 0;
      chill_handle_case_label (TREE_PURPOSE (tmp),
			       current_handler->setjmp_expr);
    }
}

void
chill_start_default_handler ()
{
  current_handler->else_handler = ++current_handler->prev_on_alternative;
  if (!ignoring)
    {
      chill_handle_case_default ();
    }
}

void
chill_check_no_handlers ()
{
  if (current_handler != NULL)
    fatal ("internal error: on stack not empty when done");
}

static void
initialize_exceptions ()
{
  tree jmp_buf_type = build_array_type (integer_type_node,
					build_index_type (build_int_2 (_JBLEN_2-1, 0)));
  tree setjmp_fndecl, link_ftype;
  tree parmtypes
    = tree_cons (NULL_TREE, build_pointer_type (jmp_buf_type), void_list_node);

  setjmp_fndecl = builtin_function ("setjmp",
				    build_function_type (integer_type_node,
							 parmtypes),
				    0, NOT_BUILT_IN,
				    SETJMP_LIBRARY_NAME);
  BISJ = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (setjmp_fndecl)),
		 setjmp_fndecl);
 
  char_pointer_type_for_handler
    = build_pointer_type (build_type_variant (char_type_node, 1, 0));
  handler_element_type =
    build_chill_struct_type (chainon
			     (build_decl (FIELD_DECL,
					  get_identifier("__exceptid"),
					  char_pointer_type_for_handler),
			      build_decl (FIELD_DECL,
					  get_identifier("__handlerno"),
					  integer_type_node)));

  jbuf_ident = get_identifier("__jbuf");
  prev_ident = get_identifier("__prev");
  handlers_ident = get_identifier("__handlers");

  handler_link_type =
    build_chill_struct_type
      (chainon
       (build_decl (FIELD_DECL, prev_ident, ptr_type_node),
	chainon
	(build_decl (FIELD_DECL, handlers_ident,
		     build_pointer_type (handler_element_type)),
	 build_decl (FIELD_DECL, jbuf_ident, jmp_buf_type))));

  handler_link_pointer_type = build_pointer_type (handler_link_type);

  if (inline_exception_stack_ops)
    {
      exception_stack_decl =
	build_lang_decl (VAR_DECL,
			 get_identifier("__exceptionStack"),
			 handler_link_pointer_type);
      TREE_STATIC (exception_stack_decl) = 1;
      TREE_PUBLIC (exception_stack_decl) = 1;
      DECL_EXTERNAL (exception_stack_decl) = 1;
      push_obstacks_nochange ();
      pushdecl(exception_stack_decl);
      make_decl_rtl (exception_stack_decl, NULL_PTR, 1);
      finish_decl (exception_stack_decl);
    }

  link_ftype = build_function_type (void_type_node,
				    tree_cons (NULL_TREE,
					       handler_link_pointer_type,
					       void_list_node));
  link_handler_decl = builtin_function ("__ch_link_handler", link_ftype,
					0, NOT_BUILT_IN, NULL_PTR);
  unlink_handler_decl = builtin_function ("__ch_unlink_handler", link_ftype,
					  0, NOT_BUILT_IN, NULL_PTR);

  exceptions_initialized = 1;
}

/* Do the cleanup(s) needed for a GOTO label.
   We only need to do the last of the cleanups. */

void
expand_goto_except_cleanup (label_level)
     int label_level;
{
  tree list = cleanup_chain;
  tree last = NULL_TREE;
  for ( ; list != NULL_TREE; list = TREE_CHAIN (list))
    {
      if (TREE_INT_CST_LOW (TREE_PURPOSE (list)) > label_level)
	last = list;
      else
	break;
    }
  if (last)
    expand_expr_stmt (TREE_VALUE (last));
}

/* Returns true if there is a valid handler for EXCEPT_NAME
   in the current static scope.
   0 ... no handler found
   1 ... local handler available
   2 ... function may propagate this exception
*/

int
is_handled (except_name)
     tree except_name;
{
  tree t;
  struct handler_state *h = current_handler;

  /* if we are are currently compiling this handler
     we have to start at the next level */
  if (h && h->compiling)
    h = h->next;
  while (h != NULL)
    {
      if (h->function != current_function_decl)
	break;
      if (h->else_handler > 0)
	return 1;
      for (t = h->on_alt_list; t != NULL_TREE; t = TREE_CHAIN (t))
	{
	  if (value_member (except_name, TREE_VALUE (t)))
	    return 1;
	}
      h = h->next;
    }

  t = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl));

  if (value_member (except_name, t))
    return 2;
  return 0;
}

/* function generates code to reraise exceptions
   for PROC's propagating exceptions. */

void
chill_reraise_exceptions (exceptions)
     tree exceptions;
{
  tree wrk;

  if (exceptions == NULL_TREE)
    return; /* just in case */

  if (pass == 1)
    {
      for (wrk = exceptions; wrk != NULL_TREE; wrk = TREE_CHAIN (wrk))
	chill_handle_on_labels (build_tree_list (NULL_TREE, TREE_VALUE (wrk)));
    }
  else /* pass == 2 */
    {
      chill_start_on ();
      expand_exit_needed = 0;

      for (wrk = exceptions; wrk != NULL_TREE; wrk = TREE_CHAIN (wrk))
	{
	  chill_handle_on_labels (TREE_VALUE (wrk));
	  /* do a CAUSE exception */
	  expand_expr_stmt (build_cause_exception (TREE_VALUE (wrk), 0));
	  expand_exit_needed = 1;
	}
      chill_finish_on ();
    }
  pop_handler (1);
}