gcc/stmt.c

   1 /* Expands front end tree to back end RTL for GNU C-Compiler
   2    Copyright (C) 1987, 88, 89, 92, 93, 94, 1995 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20
  21 /* This file handles the generation of rtl code from tree structure
  22    above the level of expressions, using subroutines in exp*.c and emit-rtl.c.
  23    It also creates the rtl expressions for parameters and auto variables
  24    and has full responsibility for allocating stack slots.
  25
  26    The functions whose names start with `expand_' are called by the
  27    parser to generate RTL instructions for various kinds of constructs.
  28
  29    Some control and binding constructs require calling several such
  30    functions at different times.  For example, a simple if-then
  31    is expanded by calling `expand_start_cond' (with the condition-expression
  32    as argument) before parsing the then-clause and calling `expand_end_cond'
  33    after parsing the then-clause.  */
  34
  35 #include "config.h"
  36
  37 #include <stdio.h>
  38 #include <ctype.h>
  39
  40 #include "rtl.h"
  41 #include "tree.h"
  42 #include "flags.h"
  43 #include "function.h"
  44 #include "insn-flags.h"
  45 #include "insn-config.h"
  46 #include "insn-codes.h"
  47 #include "expr.h"
  48 #include "hard-reg-set.h"
  49 #include "obstack.h"
  50 #include "loop.h"
  51 #include "recog.h"
  52 #include "machmode.h"
  53
  54 #include "bytecode.h"
  55 #include "bc-typecd.h"
  56 #include "bc-opcode.h"
  57 #include "bc-optab.h"
  58 #include "bc-emit.h"
  59
  60 #define obstack_chunk_alloc xmalloc
  61 #define obstack_chunk_free free
  62 struct obstack stmt_obstack;
  63
  64 /* Filename and line number of last line-number note,
  65    whether we actually emitted it or not.  */
  66 char *emit_filename;
  67 int emit_lineno;
  68
  69 /* Nonzero if within a ({...}) grouping, in which case we must
  70    always compute a value for each expr-stmt in case it is the last one.  */
  71
  72 int expr_stmts_for_value;
  73
  74 /* Each time we expand an expression-statement,
  75    record the expr's type and its RTL value here.  */
  76
  77 static tree last_expr_type;
  78 static rtx last_expr_value;
  79
  80 /* Each time we expand the end of a binding contour (in `expand_end_bindings')
  81    and we emit a new NOTE_INSN_BLOCK_END note, we save a pointer to it here.
  82    This is used by the `remember_end_note' function to record the endpoint
  83    of each generated block in its associated BLOCK node.  */
  84
  85 static rtx last_block_end_note;
  86
  87 /* Number of binding contours started so far in this function.  */
  88
  89 int block_start_count;
  90
  91 /* Nonzero if function being compiled needs to
  92    return the address of where it has put a structure value.  */
  93
  94 extern int current_function_returns_pcc_struct;
  95
  96 /* Label that will go on parm cleanup code, if any.
  97    Jumping to this label runs cleanup code for parameters, if
  98    such code must be run.  Following this code is the logical return label.  */
  99
 100 extern rtx cleanup_label;
 101
 102 /* Label that will go on function epilogue.
 103    Jumping to this label serves as a "return" instruction
 104    on machines which require execution of the epilogue on all returns.  */
 105
 106 extern rtx return_label;
 107
 108 /* List (chain of EXPR_LISTs) of pseudo-regs of SAVE_EXPRs.
 109    So we can mark them all live at the end of the function, if nonopt.  */
 110 extern rtx save_expr_regs;
 111
 112 /* Offset to end of allocated area of stack frame.
 113    If stack grows down, this is the address of the last stack slot allocated.
 114    If stack grows up, this is the address for the next slot.  */
 115 extern int frame_offset;
 116
 117 /* Label to jump back to for tail recursion, or 0 if we have
 118    not yet needed one for this function.  */
 119 extern rtx tail_recursion_label;
 120
 121 /* Place after which to insert the tail_recursion_label if we need one.  */
 122 extern rtx tail_recursion_reentry;
 123
 124 /* Location at which to save the argument pointer if it will need to be
 125    referenced.  There are two cases where this is done: if nonlocal gotos
 126    exist, or if vars whose is an offset from the argument pointer will be
 127    needed by inner routines.  */
 128
 129 extern rtx arg_pointer_save_area;
 130
 131 /* Chain of all RTL_EXPRs that have insns in them.  */
 132 extern tree rtl_expr_chain;
 133
 134 #if 0  /* Turned off because 0 seems to work just as well.  */
 135 /* Cleanup lists are required for binding levels regardless of whether
 136    that binding level has cleanups or not.  This node serves as the
 137    cleanup list whenever an empty list is required.  */
 138 static tree empty_cleanup_list;
 139 #endif
 140
 141 extern void (*interim_eh_hook)  PROTO((tree));
 142 \f
 143 /* Functions and data structures for expanding case statements.  */
 144
 145 /* Case label structure, used to hold info on labels within case
 146    statements.  We handle "range" labels; for a single-value label
 147    as in C, the high and low limits are the same.
 148
 149    A chain of case nodes is initially maintained via the RIGHT fields
 150    in the nodes.  Nodes with higher case values are later in the list.
 151
 152    Switch statements can be output in one of two forms.  A branch table
 153    is used if there are more than a few labels and the labels are dense
 154    within the range between the smallest and largest case value.  If a
 155    branch table is used, no further manipulations are done with the case
 156    node chain.
 157
 158    The alternative to the use of a branch table is to generate a series
 159    of compare and jump insns.  When that is done, we use the LEFT, RIGHT,
 160    and PARENT fields to hold a binary tree.  Initially the tree is
 161    totally unbalanced, with everything on the right.  We balance the tree
 162    with nodes on the left having lower case values than the parent
 163    and nodes on the right having higher values.  We then output the tree
 164    in order.  */
 165
 166 struct case_node
 167 {
 168   struct case_node      *left;  /* Left son in binary tree */
 169   struct case_node      *right; /* Right son in binary tree; also node chain */
 170   struct case_node      *parent; /* Parent of node in binary tree */
 171   tree                  low;    /* Lowest index value for this label */
 172   tree                  high;   /* Highest index value for this label */
 173   tree                  code_label; /* Label to jump to when node matches */
 174 };
 175
 176 typedef struct case_node case_node;
 177 typedef struct case_node *case_node_ptr;
 178
 179 /* These are used by estimate_case_costs and balance_case_nodes.  */
 180
 181 /* This must be a signed type, and non-ANSI compilers lack signed char.  */
 182 static short *cost_table;
 183 static int use_cost_table;
 184 \f
 185 /* Stack of control and binding constructs we are currently inside.
 186
 187    These constructs begin when you call `expand_start_WHATEVER'
 188    and end when you call `expand_end_WHATEVER'.  This stack records
 189    info about how the construct began that tells the end-function
 190    what to do.  It also may provide information about the construct
 191    to alter the behavior of other constructs within the body.
 192    For example, they may affect the behavior of C `break' and `continue'.
 193
 194    Each construct gets one `struct nesting' object.
 195    All of these objects are chained through the `all' field.
 196    `nesting_stack' points to the first object (innermost construct).
 197    The position of an entry on `nesting_stack' is in its `depth' field.
 198
 199    Each type of construct has its own individual stack.
 200    For example, loops have `loop_stack'.  Each object points to the
 201    next object of the same type through the `next' field.
 202
 203    Some constructs are visible to `break' exit-statements and others
 204    are not.  Which constructs are visible depends on the language.
 205    Therefore, the data structure allows each construct to be visible
 206    or not, according to the args given when the construct is started.
 207    The construct is visible if the `exit_label' field is non-null.
 208    In that case, the value should be a CODE_LABEL rtx.  */
 209
 210 struct nesting
 211 {
 212   struct nesting *all;
 213   struct nesting *next;
 214   int depth;
 215   rtx exit_label;
 216   union
 217     {
 218       /* For conds (if-then and if-then-else statements).  */
 219       struct
 220         {
 221           /* Label for the end of the if construct.
 222              There is none if EXITFLAG was not set
 223              and no `else' has been seen yet.  */
 224           rtx endif_label;
 225           /* Label for the end of this alternative.
 226              This may be the end of the if or the next else/elseif. */
 227           rtx next_label;
 228         } cond;
 229       /* For loops.  */
 230       struct
 231         {
 232           /* Label at the top of the loop; place to loop back to.  */
 233           rtx start_label;
 234           /* Label at the end of the whole construct.  */
 235           rtx end_label;
 236           /* Label before a jump that branches to the end of the whole
 237              construct.  This is where destructors go if any.  */
 238           rtx alt_end_label;
 239           /* Label for `continue' statement to jump to;
 240              this is in front of the stepper of the loop.  */
 241           rtx continue_label;
 242         } loop;
 243       /* For variable binding contours.  */
 244       struct
 245         {
 246           /* Sequence number of this binding contour within the function,
 247              in order of entry.  */
 248           int block_start_count;
 249           /* Nonzero => value to restore stack to on exit.  Complemented by
 250              bc_stack_level (see below) when generating bytecodes. */
 251           rtx stack_level;
 252           /* The NOTE that starts this contour.
 253              Used by expand_goto to check whether the destination
 254              is within each contour or not.  */
 255           rtx first_insn;
 256           /* Innermost containing binding contour that has a stack level.  */
 257           struct nesting *innermost_stack_block;
 258           /* List of cleanups to be run on exit from this contour.
 259              This is a list of expressions to be evaluated.
 260              The TREE_PURPOSE of each link is the ..._DECL node
 261              which the cleanup pertains to.  */
 262           tree cleanups;
 263           /* List of cleanup-lists of blocks containing this block,
 264              as they were at the locus where this block appears.
 265              There is an element for each containing block,
 266              ordered innermost containing block first.
 267              The tail of this list can be 0 (was empty_cleanup_list),
 268              if all remaining elements would be empty lists.
 269              The element's TREE_VALUE is the cleanup-list of that block,
 270              which may be null.  */
 271           tree outer_cleanups;
 272           /* Chain of labels defined inside this binding contour.
 273              For contours that have stack levels or cleanups.  */
 274           struct label_chain *label_chain;
 275           /* Number of function calls seen, as of start of this block.  */
 276           int function_call_count;
 277           /* Bytecode specific: stack level to restore stack to on exit.  */
 278           int bc_stack_level;
 279         } block;
 280       /* For switch (C) or case (Pascal) statements,
 281          and also for dummies (see `expand_start_case_dummy').  */
 282       struct
 283         {
 284           /* The insn after which the case dispatch should finally
 285              be emitted.  Zero for a dummy.  */
 286           rtx start;
 287           /* For bytecodes, the case table is in-lined right in the code.
 288              A label is needed for skipping over this block. It is only
 289              used when generating bytecodes. */
 290           rtx skip_label;
 291           /* A list of case labels, kept in ascending order by value
 292              as the list is built.
 293              During expand_end_case, this list may be rearranged into a
 294              nearly balanced binary tree.  */
 295           struct case_node *case_list;
 296           /* Label to jump to if no case matches.  */
 297           tree default_label;
 298           /* The expression to be dispatched on.  */
 299           tree index_expr;
 300           /* Type that INDEX_EXPR should be converted to.  */
 301           tree nominal_type;
 302           /* Number of range exprs in case statement.  */
 303           int num_ranges;
 304           /* Name of this kind of statement, for warnings.  */
 305           char *printname;
 306           /* Nonzero if a case label has been seen in this case stmt.  */
 307           char seenlabel;
 308         } case_stmt;
 309     } data;
 310 };
 311
 312 /* Chain of all pending binding contours.  */
 313 struct nesting *block_stack;
 314
 315 /* If any new stacks are added here, add them to POPSTACKS too.  */
 316
 317 /* Chain of all pending binding contours that restore stack levels
 318    or have cleanups.  */
 319 struct nesting *stack_block_stack;
 320
 321 /* Chain of all pending conditional statements.  */
 322 struct nesting *cond_stack;
 323
 324 /* Chain of all pending loops.  */
 325 struct nesting *loop_stack;
 326
 327 /* Chain of all pending case or switch statements.  */
 328 struct nesting *case_stack;
 329
 330 /* Separate chain including all of the above,
 331    chained through the `all' field.  */
 332 struct nesting *nesting_stack;
 333
 334 /* Number of entries on nesting_stack now.  */
 335 int nesting_depth;
 336
 337 /* Allocate and return a new `struct nesting'.  */
 338
 339 #define ALLOC_NESTING() \
 340  (struct nesting *) obstack_alloc (&stmt_obstack, sizeof (struct nesting))
 341
 342 /* Pop the nesting stack element by element until we pop off
 343    the element which is at the top of STACK.
 344    Update all the other stacks, popping off elements from them
 345    as we pop them from nesting_stack.  */
 346
 347 #define POPSTACK(STACK)                                 \
 348 do { struct nesting *target = STACK;                    \
 349      struct nesting *this;                              \
 350      do { this = nesting_stack;                         \
 351           if (loop_stack == this)                       \
 352             loop_stack = loop_stack->next;              \
 353           if (cond_stack == this)                       \
 354             cond_stack = cond_stack->next;              \
 355           if (block_stack == this)                      \
 356             block_stack = block_stack->next;            \
 357           if (stack_block_stack == this)                \
 358             stack_block_stack = stack_block_stack->next; \
 359           if (case_stack == this)                       \
 360             case_stack = case_stack->next;              \
 361           nesting_depth = nesting_stack->depth - 1;     \
 362           nesting_stack = this->all;                    \
 363           obstack_free (&stmt_obstack, this); }         \
 364      while (this != target); } while (0)
 365 \f
 366 /* In some cases it is impossible to generate code for a forward goto
 367    until the label definition is seen.  This happens when it may be necessary
 368    for the goto to reset the stack pointer: we don't yet know how to do that.
 369    So expand_goto puts an entry on this fixup list.
 370    Each time a binding contour that resets the stack is exited,
 371    we check each fixup.
 372    If the target label has now been defined, we can insert the proper code.  */
 373
 374 struct goto_fixup
 375 {
 376   /* Points to following fixup.  */
 377   struct goto_fixup *next;
 378   /* Points to the insn before the jump insn.
 379      If more code must be inserted, it goes after this insn.  */
 380   rtx before_jump;
 381   /* The LABEL_DECL that this jump is jumping to, or 0
 382      for break, continue or return.  */
 383   tree target;
 384   /* The BLOCK for the place where this goto was found.  */
 385   tree context;
 386   /* The CODE_LABEL rtx that this is jumping to.  */
 387   rtx target_rtl;
 388   /* Number of binding contours started in current function
 389      before the label reference.  */
 390   int block_start_count;
 391   /* The outermost stack level that should be restored for this jump.
 392      Each time a binding contour that resets the stack is exited,
 393      if the target label is *not* yet defined, this slot is updated.  */
 394   rtx stack_level;
 395   /* List of lists of cleanup expressions to be run by this goto.
 396      There is one element for each block that this goto is within.
 397      The tail of this list can be 0 (was empty_cleanup_list),
 398      if all remaining elements would be empty.
 399      The TREE_VALUE contains the cleanup list of that block as of the
 400      time this goto was seen.
 401      The TREE_ADDRESSABLE flag is 1 for a block that has been exited.  */
 402   tree cleanup_list_list;
 403
 404   /* Bytecode specific members follow */
 405
 406   /* The label that this jump is jumping to, or 0 for break, continue
 407      or return.  */
 408   struct bc_label *bc_target;
 409
 410   /* The label we use for the fixup patch */
 411   struct bc_label *label;
 412
 413   /* True (non-0) if fixup has been handled */
 414   int bc_handled:1;
 415
 416   /* Like stack_level above, except refers to the interpreter stack */
 417   int bc_stack_level;
 418 };
 419
 420 static struct goto_fixup *goto_fixup_chain;
 421
 422 /* Within any binding contour that must restore a stack level,
 423    all labels are recorded with a chain of these structures.  */
 424
 425 struct label_chain
 426 {
 427   /* Points to following fixup.  */
 428   struct label_chain *next;
 429   tree label;
 430 };
 431 static void expand_goto_internal        PROTO((tree, rtx, rtx));
 432 static void bc_expand_goto_internal     PROTO((enum bytecode_opcode,
 433                                                struct bc_label *, tree));
 434 static int expand_fixup                 PROTO((tree, rtx, rtx));
 435 static void bc_expand_fixup             PROTO((enum bytecode_opcode,
 436                                                struct bc_label *, int));
 437 static void fixup_gotos                 PROTO((struct nesting *, rtx, tree,
 438                                                rtx, int));
 439 static void bc_fixup_gotos              PROTO((struct nesting *, int, tree,
 440                                                rtx, int));
 441 static void bc_expand_start_cond        PROTO((tree, int));
 442 static void bc_expand_end_cond          PROTO((void));
 443 static void bc_expand_start_else        PROTO((void));
 444 static void bc_expand_end_loop          PROTO((void));
 445 static void bc_expand_end_bindings      PROTO((tree, int, int));
 446 static void bc_expand_decl              PROTO((tree, tree));
 447 static void bc_expand_variable_local_init PROTO((tree));
 448 static void bc_expand_decl_init         PROTO((tree));
 449 static void expand_null_return_1        PROTO((rtx, int));
 450 static void expand_value_return         PROTO((rtx));
 451 static int tail_recursion_args          PROTO((tree, tree));
 452 static void expand_cleanups             PROTO((tree, tree, int, int));
 453 static void bc_expand_start_case        PROTO((struct nesting *, tree,
 454                                                tree, char *));
 455 static int bc_pushcase                  PROTO((tree, tree));
 456 static void bc_check_for_full_enumeration_handling PROTO((tree));
 457 static void bc_expand_end_case          PROTO((tree));
 458 static void do_jump_if_equal            PROTO((rtx, rtx, rtx, int));
 459 static int estimate_case_costs          PROTO((case_node_ptr));
 460 static void group_case_nodes            PROTO((case_node_ptr));
 461 static void balance_case_nodes          PROTO((case_node_ptr *,
 462                                                case_node_ptr));
 463 static int node_has_low_bound           PROTO((case_node_ptr, tree));
 464 static int node_has_high_bound          PROTO((case_node_ptr, tree));
 465 static int node_is_bounded              PROTO((case_node_ptr, tree));
 466 static void emit_jump_if_reachable      PROTO((rtx));
 467 static void emit_case_nodes             PROTO((rtx, case_node_ptr, rtx, tree));
 468
 469 int bc_expand_exit_loop_if_false ();
 470 void bc_expand_start_cond ();
 471 void bc_expand_end_cond ();
 472 void bc_expand_start_else ();
 473 void bc_expand_end_bindings ();
 474 void bc_expand_start_case ();
 475 void bc_check_for_full_enumeration_handling ();
 476 void bc_expand_end_case ();
 477 void bc_expand_decl ();
 478
 479 extern rtx bc_allocate_local ();
 480 extern rtx bc_allocate_variable_array ();
 481 \f
 482 void
 483 init_stmt ()
 484 {
 485   gcc_obstack_init (&stmt_obstack);
 486 #if 0
 487   empty_cleanup_list = build_tree_list (NULL_TREE, NULL_TREE);
 488 #endif
 489 }
 490
 491 void
 492 init_stmt_for_function ()
 493 {
 494   /* We are not currently within any block, conditional, loop or case.  */
 495   block_stack = 0;
 496   stack_block_stack = 0;
 497   loop_stack = 0;
 498   case_stack = 0;
 499   cond_stack = 0;
 500   nesting_stack = 0;
 501   nesting_depth = 0;
 502
 503   block_start_count = 0;
 504
 505   /* No gotos have been expanded yet.  */
 506   goto_fixup_chain = 0;
 507
 508   /* We are not processing a ({...}) grouping.  */
 509   expr_stmts_for_value = 0;
 510   last_expr_type = 0;
 511 }
 512
 513 void
 514 save_stmt_status (p)
 515      struct function *p;
 516 {
 517   p->block_stack = block_stack;
 518   p->stack_block_stack = stack_block_stack;
 519   p->cond_stack = cond_stack;
 520   p->loop_stack = loop_stack;
 521   p->case_stack = case_stack;
 522   p->nesting_stack = nesting_stack;
 523   p->nesting_depth = nesting_depth;
 524   p->block_start_count = block_start_count;
 525   p->last_expr_type = last_expr_type;
 526   p->last_expr_value = last_expr_value;
 527   p->expr_stmts_for_value = expr_stmts_for_value;
 528   p->emit_filename = emit_filename;
 529   p->emit_lineno = emit_lineno;
 530   p->goto_fixup_chain = goto_fixup_chain;
 531 }
 532
 533 void
 534 restore_stmt_status (p)
 535      struct function *p;
 536 {
 537   block_stack = p->block_stack;
 538   stack_block_stack = p->stack_block_stack;
 539   cond_stack = p->cond_stack;
 540   loop_stack = p->loop_stack;
 541   case_stack = p->case_stack;
 542   nesting_stack = p->nesting_stack;
 543   nesting_depth = p->nesting_depth;
 544   block_start_count = p->block_start_count;
 545   last_expr_type = p->last_expr_type;
 546   last_expr_value = p->last_expr_value;
 547   expr_stmts_for_value = p->expr_stmts_for_value;
 548   emit_filename = p->emit_filename;
 549   emit_lineno = p->emit_lineno;
 550   goto_fixup_chain = p->goto_fixup_chain;
 551 }
 552 \f
 553 /* Emit a no-op instruction.  */
 554
 555 void
 556 emit_nop ()
 557 {
 558   rtx last_insn;
 559
 560   if (!output_bytecode)
 561     {
 562       last_insn = get_last_insn ();
 563       if (!optimize
 564           && (GET_CODE (last_insn) == CODE_LABEL
 565               || prev_real_insn (last_insn) == 0))
 566         emit_insn (gen_nop ());
 567     }
 568 }
 569 \f
 570 /* Return the rtx-label that corresponds to a LABEL_DECL,
 571    creating it if necessary.  */
 572
 573 rtx
 574 label_rtx (label)
 575      tree label;
 576 {
 577   if (TREE_CODE (label) != LABEL_DECL)
 578     abort ();
 579
 580   if (DECL_RTL (label))
 581     return DECL_RTL (label);
 582
 583   return DECL_RTL (label) = gen_label_rtx ();
 584 }
 585
 586 /* Add an unconditional jump to LABEL as the next sequential instruction.  */
 587
 588 void
 589 emit_jump (label)
 590      rtx label;
 591 {
 592   do_pending_stack_adjust ();
 593   emit_jump_insn (gen_jump (label));
 594   emit_barrier ();
 595 }
 596
 597 /* Emit code to jump to the address
 598    specified by the pointer expression EXP.  */
 599
 600 void
 601 expand_computed_goto (exp)
 602      tree exp;
 603 {
 604   if (output_bytecode)
 605     {
 606       bc_expand_expr (exp);
 607       bc_emit_instruction (jumpP);
 608     }
 609   else
 610     {
 611       rtx x = expand_expr (exp, NULL_RTX, VOIDmode, 0);
 612       emit_queue ();
 613
 614 #ifdef POINTERS_EXTEND_UNSIGNED
 615       x = convert_memory_address (Pmode, x);
 616 #endif
 617       emit_indirect_jump (x);
 618     }
 619 }
 620 \f
 621 /* Handle goto statements and the labels that they can go to.  */
 622
 623 /* Specify the location in the RTL code of a label LABEL,
 624    which is a LABEL_DECL tree node.
 625
 626    This is used for the kind of label that the user can jump to with a
 627    goto statement, and for alternatives of a switch or case statement.
 628    RTL labels generated for loops and conditionals don't go through here;
 629    they are generated directly at the RTL level, by other functions below.
 630
 631    Note that this has nothing to do with defining label *names*.
 632    Languages vary in how they do that and what that even means.  */
 633
 634 void
 635 expand_label (label)
 636      tree label;
 637 {
 638   struct label_chain *p;
 639
 640   if (output_bytecode)
 641     {
 642       if (! DECL_RTL (label))
 643         DECL_RTL (label) = bc_gen_rtx ((char *) 0, 0, bc_get_bytecode_label ());
 644       if (! bc_emit_bytecode_labeldef (BYTECODE_BC_LABEL (DECL_RTL (label))))
 645         error ("multiply defined label");
 646       return;
 647     }
 648
 649   do_pending_stack_adjust ();
 650   emit_label (label_rtx (label));
 651   if (DECL_NAME (label))
 652     LABEL_NAME (DECL_RTL (label)) = IDENTIFIER_POINTER (DECL_NAME (label));
 653
 654   if (stack_block_stack != 0)
 655     {
 656       p = (struct label_chain *) oballoc (sizeof (struct label_chain));
 657       p->next = stack_block_stack->data.block.label_chain;
 658       stack_block_stack->data.block.label_chain = p;
 659       p->label = label;
 660     }
 661 }
 662
 663 /* Declare that LABEL (a LABEL_DECL) may be used for nonlocal gotos
 664    from nested functions.  */
 665
 666 void
 667 declare_nonlocal_label (label)
 668      tree label;
 669 {
 670   nonlocal_labels = tree_cons (NULL_TREE, label, nonlocal_labels);
 671   LABEL_PRESERVE_P (label_rtx (label)) = 1;
 672   if (nonlocal_goto_handler_slot == 0)
 673     {
 674       nonlocal_goto_handler_slot
 675         = assign_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0);
 676       emit_stack_save (SAVE_NONLOCAL,
 677                        &nonlocal_goto_stack_level,
 678                        PREV_INSN (tail_recursion_reentry));
 679     }
 680 }
 681
 682 /* Generate RTL code for a `goto' statement with target label LABEL.
 683    LABEL should be a LABEL_DECL tree node that was or will later be
 684    defined with `expand_label'.  */
 685
 686 void
 687 expand_goto (label)
 688      tree label;
 689 {
 690   tree context;
 691
 692   if (output_bytecode)
 693     {
 694       expand_goto_internal (label, label_rtx (label), NULL_RTX);
 695       return;
 696     }
 697
 698   /* Check for a nonlocal goto to a containing function.  */
 699   context = decl_function_context (label);
 700   if (context != 0 && context != current_function_decl)
 701     {
 702       struct function *p = find_function_data (context);
 703       rtx label_ref = gen_rtx (LABEL_REF, Pmode, label_rtx (label));
 704       rtx temp;
 705
 706       p->has_nonlocal_label = 1;
 707       current_function_has_nonlocal_goto = 1;
 708       LABEL_REF_NONLOCAL_P (label_ref) = 1;
 709
 710       /* Copy the rtl for the slots so that they won't be shared in
 711          case the virtual stack vars register gets instantiated differently
 712          in the parent than in the child.  */
 713
 714 #if HAVE_nonlocal_goto
 715       if (HAVE_nonlocal_goto)
 716         emit_insn (gen_nonlocal_goto (lookup_static_chain (label),
 717                                       copy_rtx (p->nonlocal_goto_handler_slot),
 718                                       copy_rtx (p->nonlocal_goto_stack_level),
 719                                       label_ref));
 720       else
 721 #endif
 722         {
 723           rtx addr;
 724
 725           /* Restore frame pointer for containing function.
 726              This sets the actual hard register used for the frame pointer
 727              to the location of the function's incoming static chain info.
 728              The non-local goto handler will then adjust it to contain the
 729              proper value and reload the argument pointer, if needed.  */
 730           emit_move_insn (hard_frame_pointer_rtx, lookup_static_chain (label));
 731
 732           /* We have now loaded the frame pointer hardware register with
 733              the address of that corresponds to the start of the virtual
 734              stack vars.  So replace virtual_stack_vars_rtx in all
 735              addresses we use with stack_pointer_rtx.  */
 736
 737           /* Get addr of containing function's current nonlocal goto handler,
 738              which will do any cleanups and then jump to the label.  */
 739           addr = copy_rtx (p->nonlocal_goto_handler_slot);
 740           temp = copy_to_reg (replace_rtx (addr, virtual_stack_vars_rtx,
 741                                            hard_frame_pointer_rtx));
 742
 743           /* Restore the stack pointer.  Note this uses fp just restored.  */
 744           addr = p->nonlocal_goto_stack_level;
 745           if (addr)
 746             addr = replace_rtx (copy_rtx (addr),
 747                                 virtual_stack_vars_rtx,
 748                                 hard_frame_pointer_rtx);
 749
 750           emit_stack_restore (SAVE_NONLOCAL, addr, NULL_RTX);
 751
 752           /* Put in the static chain register the nonlocal label address.  */
 753           emit_move_insn (static_chain_rtx, label_ref);
 754           /* USE of hard_frame_pointer_rtx added for consistency; not clear if
 755              really needed.  */
 756           emit_insn (gen_rtx (USE, VOIDmode, hard_frame_pointer_rtx));
 757           emit_insn (gen_rtx (USE, VOIDmode, stack_pointer_rtx));
 758           emit_insn (gen_rtx (USE, VOIDmode, static_chain_rtx));
 759           emit_indirect_jump (temp);
 760         }
 761      }
 762   else
 763     expand_goto_internal (label, label_rtx (label), NULL_RTX);
 764 }
 765
 766 /* Generate RTL code for a `goto' statement with target label BODY.
 767    LABEL should be a LABEL_REF.
 768    LAST_INSN, if non-0, is the rtx we should consider as the last
 769    insn emitted (for the purposes of cleaning up a return).  */
 770
 771 static void
 772 expand_goto_internal (body, label, last_insn)
 773      tree body;
 774      rtx label;
 775      rtx last_insn;
 776 {
 777   struct nesting *block;
 778   rtx stack_level = 0;
 779
 780   /* NOTICE!  If a bytecode instruction other than `jump' is needed,
 781      then the caller has to call bc_expand_goto_internal()
 782      directly. This is rather an exceptional case, and there aren't
 783      that many places where this is necessary. */
 784   if (output_bytecode)
 785     {
 786       expand_goto_internal (body, label, last_insn);
 787       return;
 788     }
 789
 790   if (GET_CODE (label) != CODE_LABEL)
 791     abort ();
 792
 793   /* If label has already been defined, we can tell now
 794      whether and how we must alter the stack level.  */
 795
 796   if (PREV_INSN (label) != 0)
 797     {
 798       /* Find the innermost pending block that contains the label.
 799          (Check containment by comparing insn-uids.)
 800          Then restore the outermost stack level within that block,
 801          and do cleanups of all blocks contained in it.  */
 802       for (block = block_stack; block; block = block->next)
 803         {
 804           if (INSN_UID (block->data.block.first_insn) < INSN_UID (label))
 805             break;
 806           if (block->data.block.stack_level != 0)
 807             stack_level = block->data.block.stack_level;
 808           /* Execute the cleanups for blocks we are exiting.  */
 809           if (block->data.block.cleanups != 0)
 810             {
 811               expand_cleanups (block->data.block.cleanups, NULL_TREE, 1, 1);
 812               do_pending_stack_adjust ();
 813             }
 814         }
 815
 816       if (stack_level)
 817         {
 818           /* Ensure stack adjust isn't done by emit_jump, as this would clobber
 819              the stack pointer.  This one should be deleted as dead by flow. */
 820           clear_pending_stack_adjust ();
 821           do_pending_stack_adjust ();
 822           emit_stack_restore (SAVE_BLOCK, stack_level, NULL_RTX);
 823         }
 824
 825       if (body != 0 && DECL_TOO_LATE (body))
 826         error ("jump to `%s' invalidly jumps into binding contour",
 827                IDENTIFIER_POINTER (DECL_NAME (body)));
 828     }
 829   /* Label not yet defined: may need to put this goto
 830      on the fixup list.  */
 831   else if (! expand_fixup (body, label, last_insn))
 832     {
 833       /* No fixup needed.  Record that the label is the target
 834          of at least one goto that has no fixup.  */
 835       if (body != 0)
 836         TREE_ADDRESSABLE (body) = 1;
 837     }
 838
 839   emit_jump (label);
 840 }
 841 \f
 842 /* Generate a jump with OPCODE to the given bytecode LABEL which is
 843    found within BODY. */
 844
 845 static void
 846 bc_expand_goto_internal (opcode, label, body)
 847      enum bytecode_opcode opcode;
 848      struct bc_label *label;
 849      tree body;
 850 {
 851   struct nesting *block;
 852   int stack_level = -1;
 853
 854   /* If the label is defined, adjust the stack as necessary.
 855      If it's not defined, we have to push the reference on the
 856      fixup list. */
 857
 858   if (label->defined)
 859     {
 860
 861       /* Find the innermost pending block that contains the label.
 862          (Check containment by comparing bytecode uids.)  Then restore the
 863          outermost stack level within that block.  */
 864
 865       for (block = block_stack; block; block = block->next)
 866         {
 867           if (BYTECODE_BC_LABEL (block->data.block.first_insn)->uid < label->uid)
 868             break;
 869           if (block->data.block.bc_stack_level)
 870             stack_level = block->data.block.bc_stack_level;
 871
 872           /* Execute the cleanups for blocks we are exiting.  */
 873           if (block->data.block.cleanups != 0)
 874             {
 875               expand_cleanups (block->data.block.cleanups, NULL_TREE, 1, 1);
 876               do_pending_stack_adjust ();
 877             }
 878         }
 879
 880       /* Restore the stack level. If we need to adjust the stack, we
 881          must do so after the jump, since the jump may depend on
 882          what's on the stack.  Thus, any stack-modifying conditional
 883          jumps (these are the only ones that rely on what's on the
 884          stack) go into the fixup list. */
 885
 886       if (stack_level >= 0
 887           && stack_depth != stack_level
 888           && opcode != jump)
 889
 890         bc_expand_fixup (opcode, label, stack_level);
 891       else
 892         {
 893           if (stack_level >= 0)
 894             bc_adjust_stack (stack_depth - stack_level);
 895
 896           if (body && DECL_BIT_FIELD (body))
 897             error ("jump to `%s' invalidly jumps into binding contour",
 898                    IDENTIFIER_POINTER (DECL_NAME (body)));
 899
 900           /* Emit immediate jump */
 901           bc_emit_bytecode (opcode);
 902           bc_emit_bytecode_labelref (label);
 903
 904 #ifdef DEBUG_PRINT_CODE
 905           fputc ('\n', stderr);
 906 #endif
 907         }
 908     }
 909   else
 910     /* Put goto in the fixup list */
 911     bc_expand_fixup (opcode, label, stack_level);
 912 }
 913 \f
 914 /* Generate if necessary a fixup for a goto
 915    whose target label in tree structure (if any) is TREE_LABEL
 916    and whose target in rtl is RTL_LABEL.
 917
 918    If LAST_INSN is nonzero, we pretend that the jump appears
 919    after insn LAST_INSN instead of at the current point in the insn stream.
 920
 921    The fixup will be used later to insert insns just before the goto.
 922    Those insns will restore the stack level as appropriate for the
 923    target label, and will (in the case of C++) also invoke any object
 924    destructors which have to be invoked when we exit the scopes which
 925    are exited by the goto.
 926
 927    Value is nonzero if a fixup is made.  */
 928
 929 static int
 930 expand_fixup (tree_label, rtl_label, last_insn)
 931      tree tree_label;
 932      rtx rtl_label;
 933      rtx last_insn;
 934 {
 935   struct nesting *block, *end_block;
 936
 937   /* See if we can recognize which block the label will be output in.
 938      This is possible in some very common cases.
 939      If we succeed, set END_BLOCK to that block.
 940      Otherwise, set it to 0.  */
 941
 942   if (cond_stack
 943       && (rtl_label == cond_stack->data.cond.endif_label
 944           || rtl_label == cond_stack->data.cond.next_label))
 945     end_block = cond_stack;
 946   /* If we are in a loop, recognize certain labels which
 947      are likely targets.  This reduces the number of fixups
 948      we need to create.  */
 949   else if (loop_stack
 950       && (rtl_label == loop_stack->data.loop.start_label
 951           || rtl_label == loop_stack->data.loop.end_label
 952           || rtl_label == loop_stack->data.loop.continue_label))
 953     end_block = loop_stack;
 954   else
 955     end_block = 0;
 956
 957   /* Now set END_BLOCK to the binding level to which we will return.  */
 958
 959   if (end_block)
 960     {
 961       struct nesting *next_block = end_block->all;
 962       block = block_stack;
 963
 964       /* First see if the END_BLOCK is inside the innermost binding level.
 965          If so, then no cleanups or stack levels are relevant.  */
 966       while (next_block && next_block != block)
 967         next_block = next_block->all;
 968
 969       if (next_block)
 970         return 0;
 971
 972       /* Otherwise, set END_BLOCK to the innermost binding level
 973          which is outside the relevant control-structure nesting.  */
 974       next_block = block_stack->next;
 975       for (block = block_stack; block != end_block; block = block->all)
 976         if (block == next_block)
 977           next_block = next_block->next;
 978       end_block = next_block;
 979     }
 980
 981   /* Does any containing block have a stack level or cleanups?
 982      If not, no fixup is needed, and that is the normal case
 983      (the only case, for standard C).  */
 984   for (block = block_stack; block != end_block; block = block->next)
 985     if (block->data.block.stack_level != 0
 986         || block->data.block.cleanups != 0)
 987       break;
 988
 989   if (block != end_block)
 990     {
 991       /* Ok, a fixup is needed.  Add a fixup to the list of such.  */
 992       struct goto_fixup *fixup
 993         = (struct goto_fixup *) oballoc (sizeof (struct goto_fixup));
 994       /* In case an old stack level is restored, make sure that comes
 995          after any pending stack adjust.  */
 996       /* ?? If the fixup isn't to come at the present position,
 997          doing the stack adjust here isn't useful.  Doing it with our
 998          settings at that location isn't useful either.  Let's hope
 999          someone does it!  */
1000       if (last_insn == 0)
1001         do_pending_stack_adjust ();
1002       fixup->target = tree_label;
1003       fixup->target_rtl = rtl_label;
1004
1005       /* Create a BLOCK node and a corresponding matched set of
1006          NOTE_INSN_BEGIN_BLOCK and NOTE_INSN_END_BLOCK notes at
1007          this point.  The notes will encapsulate any and all fixup
1008          code which we might later insert at this point in the insn
1009          stream.  Also, the BLOCK node will be the parent (i.e. the
1010          `SUPERBLOCK') of any other BLOCK nodes which we might create
1011          later on when we are expanding the fixup code.  */
1012
1013       {
1014         register rtx original_before_jump
1015           = last_insn ? last_insn : get_last_insn ();
1016
1017         start_sequence ();
1018         pushlevel (0);
1019         fixup->before_jump = emit_note (NULL_PTR, NOTE_INSN_BLOCK_BEG);
1020         last_block_end_note = emit_note (NULL_PTR, NOTE_INSN_BLOCK_END);
1021         fixup->context = poplevel (1, 0, 0);  /* Create the BLOCK node now! */
1022         end_sequence ();
1023         emit_insns_after (fixup->before_jump, original_before_jump);
1024       }
1025
1026       fixup->block_start_count = block_start_count;
1027       fixup->stack_level = 0;
1028       fixup->cleanup_list_list
1029         = (((block->data.block.outer_cleanups
1030 #if 0
1031              && block->data.block.outer_cleanups != empty_cleanup_list
1032 #endif
1033              )
1034             || block->data.block.cleanups)
1035            ? tree_cons (NULL_TREE, block->data.block.cleanups,
1036                         block->data.block.outer_cleanups)
1037            : 0);
1038       fixup->next = goto_fixup_chain;
1039       goto_fixup_chain = fixup;
1040     }
1041
1042   return block != 0;
1043 }
1044
1045
1046 /* Generate bytecode jump with OPCODE to a fixup routine that links to LABEL.
1047    Make the fixup restore the stack level to STACK_LEVEL.  */
1048
1049 static void
1050 bc_expand_fixup (opcode, label, stack_level)
1051      enum bytecode_opcode opcode;
1052      struct bc_label *label;
1053      int stack_level;
1054 {
1055   struct goto_fixup *fixup
1056     = (struct goto_fixup *) oballoc (sizeof (struct goto_fixup));
1057
1058   fixup->label  = bc_get_bytecode_label ();
1059   fixup->bc_target = label;
1060   fixup->bc_stack_level = stack_level;
1061   fixup->bc_handled = FALSE;
1062
1063   fixup->next = goto_fixup_chain;
1064   goto_fixup_chain = fixup;
1065
1066   /* Insert a jump to the fixup code */
1067   bc_emit_bytecode (opcode);
1068   bc_emit_bytecode_labelref (fixup->label);
1069
1070 #ifdef DEBUG_PRINT_CODE
1071   fputc ('\n', stderr);
1072 #endif
1073 }
1074 \f
1075 /* Expand any needed fixups in the outputmost binding level of the
1076    function.  FIRST_INSN is the first insn in the function.  */
1077
1078 void
1079 expand_fixups (first_insn)
1080      rtx first_insn;
1081 {
1082   fixup_gotos (NULL_PTR, NULL_RTX, NULL_TREE, first_insn, 0);
1083 }
1084
1085 /* When exiting a binding contour, process all pending gotos requiring fixups.
1086    THISBLOCK is the structure that describes the block being exited.
1087    STACK_LEVEL is the rtx for the stack level to restore exiting this contour.
1088    CLEANUP_LIST is a list of expressions to evaluate on exiting this contour.
1089    FIRST_INSN is the insn that began this contour.
1090
1091    Gotos that jump out of this contour must restore the
1092    stack level and do the cleanups before actually jumping.
1093
1094    DONT_JUMP_IN nonzero means report error there is a jump into this
1095    contour from before the beginning of the contour.
1096    This is also done if STACK_LEVEL is nonzero.  */
1097
1098 static void
1099 fixup_gotos (thisblock, stack_level, cleanup_list, first_insn, dont_jump_in)
1100      struct nesting *thisblock;
1101      rtx stack_level;
1102      tree cleanup_list;
1103      rtx first_insn;
1104      int dont_jump_in;
1105 {
1106   register struct goto_fixup *f, *prev;
1107
1108   if (output_bytecode)
1109     {
1110       /* ??? The second arg is the bc stack level, which is not the same
1111          as STACK_LEVEL.  I have no idea what should go here, so I'll
1112          just pass 0.  */
1113       bc_fixup_gotos (thisblock, 0, cleanup_list, first_insn, dont_jump_in);
1114       return;
1115     }
1116
1117   /* F is the fixup we are considering; PREV is the previous one.  */
1118   /* We run this loop in two passes so that cleanups of exited blocks
1119      are run first, and blocks that are exited are marked so
1120      afterwards.  */
1121
1122   for (prev = 0, f = goto_fixup_chain; f; prev = f, f = f->next)
1123     {
1124       /* Test for a fixup that is inactive because it is already handled.  */
1125       if (f->before_jump == 0)
1126         {
1127           /* Delete inactive fixup from the chain, if that is easy to do.  */
1128           if (prev != 0)
1129             prev->next = f->next;
1130         }
1131       /* Has this fixup's target label been defined?
1132          If so, we can finalize it.  */
1133       else if (PREV_INSN (f->target_rtl) != 0)
1134         {
1135           register rtx cleanup_insns;
1136
1137           /* Get the first non-label after the label
1138              this goto jumps to.  If that's before this scope begins,
1139              we don't have a jump into the scope.  */
1140           rtx after_label = f->target_rtl;
1141           while (after_label != 0 && GET_CODE (after_label) == CODE_LABEL)
1142             after_label = NEXT_INSN (after_label);
1143
1144           /* If this fixup jumped into this contour from before the beginning
1145              of this contour, report an error.  */
1146           /* ??? Bug: this does not detect jumping in through intermediate
1147              blocks that have stack levels or cleanups.
1148              It detects only a problem with the innermost block
1149              around the label.  */
1150           if (f->target != 0
1151               && (dont_jump_in || stack_level || cleanup_list)
1152               /* If AFTER_LABEL is 0, it means the jump goes to the end
1153                  of the rtl, which means it jumps into this scope.  */
1154               && (after_label == 0
1155                   || INSN_UID (first_insn) < INSN_UID (after_label))
1156               && INSN_UID (first_insn) > INSN_UID (f->before_jump)
1157               && ! DECL_REGISTER (f->target))
1158             {
1159               error_with_decl (f->target,
1160                                "label `%s' used before containing binding contour");
1161               /* Prevent multiple errors for one label.  */
1162               DECL_REGISTER (f->target) = 1;
1163             }
1164
1165           /* We will expand the cleanups into a sequence of their own and
1166              then later on we will attach this new sequence to the insn
1167              stream just ahead of the actual jump insn.  */
1168
1169           start_sequence ();
1170
1171           /* Temporarily restore the lexical context where we will
1172              logically be inserting the fixup code.  We do this for the
1173              sake of getting the debugging information right.  */
1174
1175           pushlevel (0);
1176           set_block (f->context);
1177
1178           /* Expand the cleanups for blocks this jump exits.  */
1179           if (f->cleanup_list_list)
1180             {
1181               tree lists;
1182               for (lists = f->cleanup_list_list; lists; lists = TREE_CHAIN (lists))
1183                 /* Marked elements correspond to blocks that have been closed.
1184                    Do their cleanups.  */
1185                 if (TREE_ADDRESSABLE (lists)
1186                     && TREE_VALUE (lists) != 0)
1187                   {
1188                     expand_cleanups (TREE_VALUE (lists), NULL_TREE, 1, 1);
1189                     /* Pop any pushes done in the cleanups,
1190                        in case function is about to return.  */
1191                     do_pending_stack_adjust ();
1192                   }
1193             }
1194
1195           /* Restore stack level for the biggest contour that this
1196              jump jumps out of.  */
1197           if (f->stack_level)
1198             emit_stack_restore (SAVE_BLOCK, f->stack_level, f->before_jump);
1199
1200           /* Finish up the sequence containing the insns which implement the
1201              necessary cleanups, and then attach that whole sequence to the
1202              insn stream just ahead of the actual jump insn.  Attaching it
1203              at that point insures that any cleanups which are in fact
1204              implicit C++ object destructions (which must be executed upon
1205              leaving the block) appear (to the debugger) to be taking place
1206              in an area of the generated code where the object(s) being
1207              destructed are still "in scope".  */
1208
1209           cleanup_insns = get_insns ();
1210           poplevel (1, 0, 0);
1211
1212           end_sequence ();
1213           emit_insns_after (cleanup_insns, f->before_jump);
1214
1215
1216           f->before_jump = 0;
1217         }
1218     }
1219
1220   /* For any still-undefined labels, do the cleanups for this block now.
1221      We must do this now since items in the cleanup list may go out
1222      of scope when the block ends. */
1223   for (prev = 0, f = goto_fixup_chain; f; prev = f, f = f->next)
1224     if (f->before_jump != 0
1225         && PREV_INSN (f->target_rtl) == 0
1226         /* Label has still not appeared.  If we are exiting a block with
1227            a stack level to restore, that started before the fixup,
1228            mark this stack level as needing restoration
1229            when the fixup is later finalized.   */
1230         && thisblock != 0
1231         /* Note: if THISBLOCK == 0 and we have a label that hasn't appeared, it
1232            means the label is undefined.  That's erroneous, but possible.  */
1233         && (thisblock->data.block.block_start_count
1234             <= f->block_start_count))
1235       {
1236         tree lists = f->cleanup_list_list;
1237         rtx cleanup_insns;
1238
1239         for (; lists; lists = TREE_CHAIN (lists))
1240           /* If the following elt. corresponds to our containing block
1241              then the elt. must be for this block.  */
1242           if (TREE_CHAIN (lists) == thisblock->data.block.outer_cleanups)
1243             {
1244               start_sequence ();
1245               pushlevel (0);
1246               set_block (f->context);
1247               expand_cleanups (TREE_VALUE (lists), NULL_TREE, 1, 1);
1248               do_pending_stack_adjust ();
1249               cleanup_insns = get_insns ();
1250               poplevel (1, 0, 0);
1251               end_sequence ();
1252               f->before_jump
1253                 = emit_insns_after (cleanup_insns, f->before_jump);
1254
1255               TREE_VALUE (lists) = 0;
1256             }
1257
1258         if (stack_level)
1259           f->stack_level = stack_level;
1260       }
1261 }
1262
1263
1264 /* When exiting a binding contour, process all pending gotos requiring fixups.
1265    Note: STACK_DEPTH is not altered.
1266
1267    The arguments are currently not used in the bytecode compiler, but we may
1268    need them one day for languages other than C.
1269
1270    THISBLOCK is the structure that describes the block being exited.
1271    STACK_LEVEL is the rtx for the stack level to restore exiting this contour.
1272    CLEANUP_LIST is a list of expressions to evaluate on exiting this contour.
1273    FIRST_INSN is the insn that began this contour.
1274
1275    Gotos that jump out of this contour must restore the
1276    stack level and do the cleanups before actually jumping.
1277
1278    DONT_JUMP_IN nonzero means report error there is a jump into this
1279    contour from before the beginning of the contour.
1280    This is also done if STACK_LEVEL is nonzero.  */
1281
1282 static void
1283 bc_fixup_gotos (thisblock, stack_level, cleanup_list, first_insn, dont_jump_in)
1284      struct nesting *thisblock;
1285      int stack_level;
1286      tree cleanup_list;
1287      rtx first_insn;
1288      int dont_jump_in;
1289 {
1290   register struct goto_fixup *f, *prev;
1291   int saved_stack_depth;
1292
1293   /* F is the fixup we are considering; PREV is the previous one.  */
1294
1295   for (prev = 0, f = goto_fixup_chain; f; prev = f, f = f->next)
1296     {
1297       /* Test for a fixup that is inactive because it is already handled.  */
1298       if (f->before_jump == 0)
1299         {
1300           /* Delete inactive fixup from the chain, if that is easy to do.  */
1301           if (prev)
1302             prev->next = f->next;
1303         }
1304
1305       /* Emit code to restore the stack and continue */
1306       bc_emit_bytecode_labeldef (f->label);
1307
1308       /* Save stack_depth across call, since bc_adjust_stack () will alter
1309          the perceived stack depth via the instructions generated. */
1310
1311       if (f->bc_stack_level >= 0)
1312         {
1313           saved_stack_depth = stack_depth;
1314           bc_adjust_stack (stack_depth - f->bc_stack_level);
1315           stack_depth = saved_stack_depth;
1316         }
1317
1318       bc_emit_bytecode (jump);
1319       bc_emit_bytecode_labelref (f->bc_target);
1320
1321 #ifdef DEBUG_PRINT_CODE
1322   fputc ('\n', stderr);
1323 #endif
1324     }
1325
1326   goto_fixup_chain = NULL;
1327 }
1328 \f
1329 /* Generate RTL for an asm statement (explicit assembler code).
1330    BODY is a STRING_CST node containing the assembler code text,
1331    or an ADDR_EXPR containing a STRING_CST.  */
1332
1333 void
1334 expand_asm (body)
1335      tree body;
1336 {
1337   if (output_bytecode)
1338     {
1339       error ("`asm' is invalid when generating bytecode");
1340       return;
1341     }
1342
1343   if (TREE_CODE (body) == ADDR_EXPR)
1344     body = TREE_OPERAND (body, 0);
1345
1346   emit_insn (gen_rtx (ASM_INPUT, VOIDmode,
1347                       TREE_STRING_POINTER (body)));
1348   last_expr_type = 0;
1349 }
1350
1351 /* Generate RTL for an asm statement with arguments.
1352    STRING is the instruction template.
1353    OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
1354    Each output or input has an expression in the TREE_VALUE and
1355    a constraint-string in the TREE_PURPOSE.
1356    CLOBBERS is a list of STRING_CST nodes each naming a hard register
1357    that is clobbered by this insn.
1358
1359    Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
1360    Some elements of OUTPUTS may be replaced with trees representing temporary
1361    values.  The caller should copy those temporary values to the originally
1362    specified lvalues.
1363
1364    VOL nonzero means the insn is volatile; don't optimize it.  */
1365
1366 void
1367 expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
1368      tree string, outputs, inputs, clobbers;
1369      int vol;
1370      char *filename;
1371      int line;
1372 {
1373   rtvec argvec, constraints;
1374   rtx body;
1375   int ninputs = list_length (inputs);
1376   int noutputs = list_length (outputs);
1377   int nclobbers;
1378   tree tail;
1379   register int i;
1380   /* Vector of RTX's of evaluated output operands.  */
1381   rtx *output_rtx = (rtx *) alloca (noutputs * sizeof (rtx));
1382   /* The insn we have emitted.  */
1383   rtx insn;
1384
1385   if (output_bytecode)
1386     {
1387       error ("`asm' is invalid when generating bytecode");
1388       return;
1389     }
1390
1391   /* Count the number of meaningful clobbered registers, ignoring what
1392      we would ignore later.  */
1393   nclobbers = 0;
1394   for (tail = clobbers; tail; tail = TREE_CHAIN (tail))
1395     {
1396       char *regname = TREE_STRING_POINTER (TREE_VALUE (tail));
1397       i = decode_reg_name (regname);
1398       if (i >= 0 || i == -4)
1399         ++nclobbers;
1400       else if (i == -2)
1401         error ("unknown register name `%s' in `asm'", regname);
1402     }
1403
1404   last_expr_type = 0;
1405
1406   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
1407     {
1408       tree val = TREE_VALUE (tail);
1409       tree type = TREE_TYPE (val);
1410       tree val1;
1411       int j;
1412       int found_equal;
1413
1414       /* If there's an erroneous arg, emit no insn.  */
1415       if (TREE_TYPE (val) == error_mark_node)
1416         return;
1417
1418       /* Make sure constraint has `=' and does not have `+'.  */
1419
1420       found_equal = 0;
1421       for (j = 0; j < TREE_STRING_LENGTH (TREE_PURPOSE (tail)); j++)
1422         {
1423           if (TREE_STRING_POINTER (TREE_PURPOSE (tail))[j] == '+')
1424             {
1425               error ("output operand constraint contains `+'");
1426               return;
1427             }
1428           if (TREE_STRING_POINTER (TREE_PURPOSE (tail))[j] == '=')
1429             found_equal = 1;
1430         }
1431       if (! found_equal)
1432         {
1433           error ("output operand constraint lacks `='");
1434           return;
1435         }
1436
1437       /* If an output operand is not a decl or indirect ref,
1438          make a temporary to act as an intermediate.   Make the asm insn
1439          write into that, then our caller will copy it to the real output
1440          operand.  Likewise for promoted variables.  */
1441
1442       if (TREE_CODE (val) == INDIRECT_REF
1443           || (TREE_CODE_CLASS (TREE_CODE (val)) == 'd'
1444               && ! (GET_CODE (DECL_RTL (val)) == REG
1445                     && GET_MODE (DECL_RTL (val)) != TYPE_MODE (type))))
1446         output_rtx[i] = expand_expr (TREE_VALUE (tail), NULL_RTX, VOIDmode, 0);
1447       else
1448         {
1449           if (TYPE_MODE (type) == BLKmode)
1450             {
1451               output_rtx[i] = assign_stack_temp (BLKmode,
1452                                                  int_size_in_bytes (type), 0);
1453               MEM_IN_STRUCT_P (output_rtx[i]) = AGGREGATE_TYPE_P (type);
1454             }
1455           else
1456             output_rtx[i] = gen_reg_rtx (TYPE_MODE (type));
1457
1458           TREE_VALUE (tail) = make_tree (type, output_rtx[i]);
1459         }
1460     }
1461
1462   if (ninputs + noutputs > MAX_RECOG_OPERANDS)
1463     {
1464       error ("more than %d operands in `asm'", MAX_RECOG_OPERANDS);
1465       return;
1466     }
1467
1468   /* Make vectors for the expression-rtx and constraint strings.  */
1469
1470   argvec = rtvec_alloc (ninputs);
1471   constraints = rtvec_alloc (ninputs);
1472
1473   body = gen_rtx (ASM_OPERANDS, VOIDmode,
1474                   TREE_STRING_POINTER (string), "", 0, argvec, constraints,
1475                   filename, line);
1476   MEM_VOLATILE_P (body) = vol;
1477
1478   /* Eval the inputs and put them into ARGVEC.
1479      Put their constraints into ASM_INPUTs and store in CONSTRAINTS.  */
1480
1481   i = 0;
1482   for (tail = inputs; tail; tail = TREE_CHAIN (tail))
1483     {
1484       int j;
1485
1486       /* If there's an erroneous arg, emit no insn,
1487          because the ASM_INPUT would get VOIDmode
1488          and that could cause a crash in reload.  */
1489       if (TREE_TYPE (TREE_VALUE (tail)) == error_mark_node)
1490         return;
1491       if (TREE_PURPOSE (tail) == NULL_TREE)
1492         {
1493           error ("hard register `%s' listed as input operand to `asm'",
1494                  TREE_STRING_POINTER (TREE_VALUE (tail)) );
1495           return;
1496         }
1497
1498       /* Make sure constraint has neither `=' nor `+'.  */
1499
1500       for (j = 0; j < TREE_STRING_LENGTH (TREE_PURPOSE (tail)); j++)
1501         if (TREE_STRING_POINTER (TREE_PURPOSE (tail))[j] == '='
1502             || TREE_STRING_POINTER (TREE_PURPOSE (tail))[j] == '+')
1503           {
1504             error ("input operand constraint contains `%c'",
1505                    TREE_STRING_POINTER (TREE_PURPOSE (tail))[j]);
1506             return;
1507           }
1508
1509       XVECEXP (body, 3, i)      /* argvec */
1510         = expand_expr (TREE_VALUE (tail), NULL_RTX, VOIDmode, 0);
1511       if (CONSTANT_P (XVECEXP (body, 3, i))
1512           && ! general_operand (XVECEXP (body, 3, i),
1513                                 TYPE_MODE (TREE_TYPE (TREE_VALUE (tail)))))
1514         XVECEXP (body, 3, i)
1515           = force_reg (TYPE_MODE (TREE_TYPE (TREE_VALUE (tail))),
1516                        XVECEXP (body, 3, i));
1517       XVECEXP (body, 4, i)      /* constraints */
1518         = gen_rtx (ASM_INPUT, TYPE_MODE (TREE_TYPE (TREE_VALUE (tail))),
1519                    TREE_STRING_POINTER (TREE_PURPOSE (tail)));
1520       i++;
1521     }
1522
1523   /* Protect all the operands from the queue,
1524      now that they have all been evaluated.  */
1525
1526   for (i = 0; i < ninputs; i++)
1527     XVECEXP (body, 3, i) = protect_from_queue (XVECEXP (body, 3, i), 0);
1528
1529   for (i = 0; i < noutputs; i++)
1530     output_rtx[i] = protect_from_queue (output_rtx[i], 1);
1531
1532   /* Now, for each output, construct an rtx
1533      (set OUTPUT (asm_operands INSN OUTPUTNUMBER OUTPUTCONSTRAINT
1534                                ARGVEC CONSTRAINTS))
1535      If there is more than one, put them inside a PARALLEL.  */
1536
1537   if (noutputs == 1 && nclobbers == 0)
1538     {
1539       XSTR (body, 1) = TREE_STRING_POINTER (TREE_PURPOSE (outputs));
1540       insn = emit_insn (gen_rtx (SET, VOIDmode, output_rtx[0], body));
1541     }
1542   else if (noutputs == 0 && nclobbers == 0)
1543     {
1544       /* No output operands: put in a raw ASM_OPERANDS rtx.  */
1545       insn = emit_insn (body);
1546     }
1547   else
1548     {
1549       rtx obody = body;
1550       int num = noutputs;
1551       if (num == 0) num = 1;
1552       body = gen_rtx (PARALLEL, VOIDmode, rtvec_alloc (num + nclobbers));
1553
1554       /* For each output operand, store a SET.  */
1555
1556       for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
1557         {
1558           XVECEXP (body, 0, i)
1559             = gen_rtx (SET, VOIDmode,
1560                        output_rtx[i],
1561                        gen_rtx (ASM_OPERANDS, VOIDmode,
1562                                 TREE_STRING_POINTER (string),
1563                                 TREE_STRING_POINTER (TREE_PURPOSE (tail)),
1564                                 i, argvec, constraints,
1565                                 filename, line));
1566           MEM_VOLATILE_P (SET_SRC (XVECEXP (body, 0, i))) = vol;
1567         }
1568
1569       /* If there are no outputs (but there are some clobbers)
1570          store the bare ASM_OPERANDS into the PARALLEL.  */
1571
1572       if (i == 0)
1573         XVECEXP (body, 0, i++) = obody;
1574
1575       /* Store (clobber REG) for each clobbered register specified.  */
1576
1577       for (tail = clobbers; tail; tail = TREE_CHAIN (tail))
1578         {
1579           char *regname = TREE_STRING_POINTER (TREE_VALUE (tail));
1580           int j = decode_reg_name (regname);
1581
1582           if (j < 0)
1583             {
1584               if (j == -3)      /* `cc', which is not a register */
1585                 continue;
1586
1587               if (j == -4)      /* `memory', don't cache memory across asm */
1588                 {
1589                   XVECEXP (body, 0, i++)
1590                     = gen_rtx (CLOBBER, VOIDmode,
1591                                gen_rtx (MEM, BLKmode,
1592                                         gen_rtx (SCRATCH, VOIDmode, 0)));
1593                   continue;
1594                 }
1595
1596               /* Ignore unknown register, error already signalled.  */
1597               continue;
1598             }
1599
1600           /* Use QImode since that's guaranteed to clobber just one reg.  */
1601           XVECEXP (body, 0, i++)
1602             = gen_rtx (CLOBBER, VOIDmode, gen_rtx (REG, QImode, j));
1603         }
1604
1605       insn = emit_insn (body);
1606     }
1607
1608   free_temp_slots ();
1609 }
1610 \f
1611 /* Generate RTL to evaluate the expression EXP
1612    and remember it in case this is the VALUE in a ({... VALUE; }) constr.  */
1613
1614 void
1615 expand_expr_stmt (exp)
1616      tree exp;
1617 {
1618   if (output_bytecode)
1619     {
1620       int org_stack_depth = stack_depth;
1621
1622       bc_expand_expr (exp);
1623
1624       /* Restore stack depth */
1625       if (stack_depth < org_stack_depth)
1626         abort ();
1627
1628       bc_emit_instruction (drop);
1629
1630       last_expr_type = TREE_TYPE (exp);
1631       return;
1632     }
1633
1634   /* If -W, warn about statements with no side effects,
1635      except for an explicit cast to void (e.g. for assert()), and
1636      except inside a ({...}) where they may be useful.  */
1637   if (expr_stmts_for_value == 0 && exp != error_mark_node)
1638     {
1639       if (! TREE_SIDE_EFFECTS (exp) && (extra_warnings || warn_unused)
1640           && !(TREE_CODE (exp) == CONVERT_EXPR
1641                && TREE_TYPE (exp) == void_type_node))
1642         warning_with_file_and_line (emit_filename, emit_lineno,
1643                                     "statement with no effect");
1644       else if (warn_unused)
1645         warn_if_unused_value (exp);
1646     }
1647
1648   /* If EXP is of function type and we are expanding statements for
1649      value, convert it to pointer-to-function.  */
1650   if (expr_stmts_for_value && TREE_CODE (TREE_TYPE (exp)) == FUNCTION_TYPE)
1651     exp = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (exp)), exp);
1652
1653   last_expr_type = TREE_TYPE (exp);
1654   if (! flag_syntax_only)
1655     last_expr_value = expand_expr (exp,
1656                                    (expr_stmts_for_value
1657                                     ? NULL_RTX : const0_rtx),
1658                                    VOIDmode, 0);
1659
1660   /* If all we do is reference a volatile value in memory,
1661      copy it to a register to be sure it is actually touched.  */
1662   if (last_expr_value != 0 && GET_CODE (last_expr_value) == MEM
1663       && TREE_THIS_VOLATILE (exp))
1664     {
1665       if (TYPE_MODE (TREE_TYPE (exp)) == VOIDmode)
1666         ;
1667       else if (TYPE_MODE (TREE_TYPE (exp)) != BLKmode)
1668         copy_to_reg (last_expr_value);
1669       else
1670         {
1671           rtx lab = gen_label_rtx ();
1672
1673           /* Compare the value with itself to reference it.  */
1674           emit_cmp_insn (last_expr_value, last_expr_value, EQ,
1675                          expand_expr (TYPE_SIZE (last_expr_type),
1676                                       NULL_RTX, VOIDmode, 0),
1677                          BLKmode, 0,
1678                          TYPE_ALIGN (last_expr_type) / BITS_PER_UNIT);
1679           emit_jump_insn ((*bcc_gen_fctn[(int) EQ]) (lab));
1680           emit_label (lab);
1681         }
1682     }
1683
1684   /* If this expression is part of a ({...}) and is in memory, we may have
1685      to preserve temporaries.  */
1686   preserve_temp_slots (last_expr_value);
1687
1688   /* Free any temporaries used to evaluate this expression.  Any temporary
1689      used as a result of this expression will already have been preserved
1690      above.  */
1691   free_temp_slots ();
1692
1693   emit_queue ();
1694 }
1695
1696 /* Warn if EXP contains any computations whose results are not used.
1697    Return 1 if a warning is printed; 0 otherwise.  */
1698
1699 int
1700 warn_if_unused_value (exp)
1701      tree exp;
1702 {
1703   if (TREE_USED (exp))
1704     return 0;
1705
1706   switch (TREE_CODE (exp))
1707     {
1708     case PREINCREMENT_EXPR:
1709     case POSTINCREMENT_EXPR:
1710     case PREDECREMENT_EXPR:
1711     case POSTDECREMENT_EXPR:
1712     case MODIFY_EXPR:
1713     case INIT_EXPR:
1714     case TARGET_EXPR:
1715     case CALL_EXPR:
1716     case METHOD_CALL_EXPR:
1717     case RTL_EXPR:
1718     case WITH_CLEANUP_EXPR:
1719     case EXIT_EXPR:
1720       /* We don't warn about COND_EXPR because it may be a useful
1721          construct if either arm contains a side effect.  */
1722     case COND_EXPR:
1723       return 0;
1724
1725     case BIND_EXPR:
1726       /* For a binding, warn if no side effect within it.  */
1727       return warn_if_unused_value (TREE_OPERAND (exp, 1));
1728
1729     case SAVE_EXPR:
1730       return warn_if_unused_value (TREE_OPERAND (exp, 1));
1731
1732     case TRUTH_ORIF_EXPR:
1733     case TRUTH_ANDIF_EXPR:
1734       /* In && or ||, warn if 2nd operand has no side effect.  */
1735       return warn_if_unused_value (TREE_OPERAND (exp, 1));
1736
1737     case COMPOUND_EXPR:
1738       if (TREE_NO_UNUSED_WARNING (exp))
1739         return 0;
1740       if (warn_if_unused_value (TREE_OPERAND (exp, 0)))
1741         return 1;
1742       /* Let people do `(foo (), 0)' without a warning.  */
1743       if (TREE_CONSTANT (TREE_OPERAND (exp, 1)))
1744         return 0;
1745       return warn_if_unused_value (TREE_OPERAND (exp, 1));
1746
1747     case NOP_EXPR:
1748     case CONVERT_EXPR:
1749     case NON_LVALUE_EXPR:
1750       /* Don't warn about values cast to void.  */
1751       if (TREE_TYPE (exp) == void_type_node)
1752         return 0;
1753       /* Don't warn about conversions not explicit in the user's program.  */
1754       if (TREE_NO_UNUSED_WARNING (exp))
1755         return 0;
1756       /* Assignment to a cast usually results in a cast of a modify.
1757          Don't complain about that.  There can be an arbitrary number of
1758          casts before the modify, so we must loop until we find the first
1759          non-cast expression and then test to see if that is a modify.  */
1760       {
1761         tree tem = TREE_OPERAND (exp, 0);
1762
1763         while (TREE_CODE (tem) == CONVERT_EXPR || TREE_CODE (tem) == NOP_EXPR)
1764           tem = TREE_OPERAND (tem, 0);
1765
1766         if (TREE_CODE (tem) == MODIFY_EXPR || TREE_CODE (tem) == INIT_EXPR
1767             || TREE_CODE (tem) == CALL_EXPR)
1768           return 0;
1769       }
1770       goto warn;
1771
1772     case INDIRECT_REF:
1773       /* Don't warn about automatic dereferencing of references, since
1774          the user cannot control it.  */
1775       if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == REFERENCE_TYPE)
1776         return warn_if_unused_value (TREE_OPERAND (exp, 0));
1777       /* ... fall through ... */
1778
1779     default:
1780       /* Referencing a volatile value is a side effect, so don't warn.  */
1781       if ((TREE_CODE_CLASS (TREE_CODE (exp)) == 'd'
1782            || TREE_CODE_CLASS (TREE_CODE (exp)) == 'r')
1783           && TREE_THIS_VOLATILE (exp))
1784         return 0;
1785     warn:
1786       warning_with_file_and_line (emit_filename, emit_lineno,
1787                                   "value computed is not used");
1788       return 1;
1789     }
1790 }
1791
1792 /* Clear out the memory of the last expression evaluated.  */
1793
1794 void
1795 clear_last_expr ()
1796 {
1797   last_expr_type = 0;
1798 }
1799
1800 /* Begin a statement which will return a value.
1801    Return the RTL_EXPR for this statement expr.
1802    The caller must save that value and pass it to expand_end_stmt_expr.  */
1803
1804 tree
1805 expand_start_stmt_expr ()
1806 {
1807   int momentary;
1808   tree t;
1809
1810   /* When generating bytecode just note down the stack depth */
1811   if (output_bytecode)
1812     return (build_int_2 (stack_depth, 0));
1813
1814   /* Make the RTL_EXPR node temporary, not momentary,
1815      so that rtl_expr_chain doesn't become garbage.  */
1816   momentary = suspend_momentary ();
1817   t = make_node (RTL_EXPR);
1818   resume_momentary (momentary);
1819   start_sequence_for_rtl_expr (t);
1820   NO_DEFER_POP;
1821   expr_stmts_for_value++;
1822   return t;
1823 }
1824
1825 /* Restore the previous state at the end of a statement that returns a value.
1826    Returns a tree node representing the statement's value and the
1827    insns to compute the value.
1828
1829    The nodes of that expression have been freed by now, so we cannot use them.
1830    But we don't want to do that anyway; the expression has already been
1831    evaluated and now we just want to use the value.  So generate a RTL_EXPR
1832    with the proper type and RTL value.
1833
1834    If the last substatement was not an expression,
1835    return something with type `void'.  */
1836
1837 tree
1838 expand_end_stmt_expr (t)
1839      tree t;
1840 {
1841   if (output_bytecode)
1842     {
1843       int i;
1844       tree t;
1845
1846
1847       /* At this point, all expressions have been evaluated in order.
1848          However, all expression values have been popped when evaluated,
1849          which means we have to recover the last expression value.  This is
1850          the last value removed by means of a `drop' instruction.  Instead
1851          of adding code to inhibit dropping the last expression value, it
1852          is here recovered by undoing the `drop'.  Since `drop' is
1853          equivalent to `adjustackSI [1]', it can be undone with `adjstackSI
1854          [-1]'. */
1855
1856       bc_adjust_stack (-1);
1857
1858       if (!last_expr_type)
1859         last_expr_type = void_type_node;
1860
1861       t = make_node (RTL_EXPR);
1862       TREE_TYPE (t) = last_expr_type;
1863       RTL_EXPR_RTL (t) = NULL;
1864       RTL_EXPR_SEQUENCE (t) = NULL;
1865
1866       /* Don't consider deleting this expr or containing exprs at tree level.  */
1867       TREE_THIS_VOLATILE (t) = 1;
1868
1869       last_expr_type = 0;
1870       return t;
1871     }
1872
1873   OK_DEFER_POP;
1874
1875   if (last_expr_type == 0)
1876     {
1877       last_expr_type = void_type_node;
1878       last_expr_value = const0_rtx;
1879     }
1880   else if (last_expr_value == 0)
1881     /* There are some cases where this can happen, such as when the
1882        statement is void type.  */
1883     last_expr_value = const0_rtx;
1884   else if (GET_CODE (last_expr_value) != REG && ! CONSTANT_P (last_expr_value))
1885     /* Remove any possible QUEUED.  */
1886     last_expr_value = protect_from_queue (last_expr_value, 0);
1887
1888   emit_queue ();
1889
1890   TREE_TYPE (t) = last_expr_type;
1891   RTL_EXPR_RTL (t) = last_expr_value;
1892   RTL_EXPR_SEQUENCE (t) = get_insns ();
1893
1894   rtl_expr_chain = tree_cons (NULL_TREE, t, rtl_expr_chain);
1895
1896   end_sequence ();
1897
1898   /* Don't consider deleting this expr or containing exprs at tree level.  */
1899   TREE_SIDE_EFFECTS (t) = 1;
1900   /* Propagate volatility of the actual RTL expr.  */
1901   TREE_THIS_VOLATILE (t) = volatile_refs_p (last_expr_value);
1902
1903   last_expr_type = 0;
1904   expr_stmts_for_value--;
1905
1906   return t;
1907 }
1908 \f
1909 /* Generate RTL for the start of an if-then.  COND is the expression
1910    whose truth should be tested.
1911
1912    If EXITFLAG is nonzero, this conditional is visible to
1913    `exit_something'.  */
1914
1915 void
1916 expand_start_cond (cond, exitflag)
1917      tree cond;
1918      int exitflag;
1919 {
1920   struct nesting *thiscond = ALLOC_NESTING ();
1921
1922   /* Make an entry on cond_stack for the cond we are entering.  */
1923
1924   thiscond->next = cond_stack;
1925   thiscond->all = nesting_stack;
1926   thiscond->depth = ++nesting_depth;
1927   thiscond->data.cond.next_label = gen_label_rtx ();
1928   /* Before we encounter an `else', we don't need a separate exit label
1929      unless there are supposed to be exit statements
1930      to exit this conditional.  */
1931   thiscond->exit_label = exitflag ? gen_label_rtx () : 0;
1932   thiscond->data.cond.endif_label = thiscond->exit_label;
1933   cond_stack = thiscond;
1934   nesting_stack = thiscond;
1935
1936   if (output_bytecode)
1937     bc_expand_start_cond (cond, exitflag);
1938   else
1939     do_jump (cond, thiscond->data.cond.next_label, NULL_RTX);
1940 }
1941
1942 /* Generate RTL between then-clause and the elseif-clause
1943    of an if-then-elseif-....  */
1944
1945 void
1946 expand_start_elseif (cond)
1947      tree cond;
1948 {
1949   if (cond_stack->data.cond.endif_label == 0)
1950     cond_stack->data.cond.endif_label = gen_label_rtx ();
1951   emit_jump (cond_stack->data.cond.endif_label);
1952   emit_label (cond_stack->data.cond.next_label);
1953   cond_stack->data.cond.next_label = gen_label_rtx ();
1954   do_jump (cond, cond_stack->data.cond.next_label, NULL_RTX);
1955 }
1956
1957 /* Generate RTL between the then-clause and the else-clause
1958    of an if-then-else.  */
1959
1960 void
1961 expand_start_else ()
1962 {
1963   if (cond_stack->data.cond.endif_label == 0)
1964     cond_stack->data.cond.endif_label = gen_label_rtx ();
1965
1966   if (output_bytecode)
1967     {
1968       bc_expand_start_else ();
1969       return;
1970     }
1971
1972   emit_jump (cond_stack->data.cond.endif_label);
1973   emit_label (cond_stack->data.cond.next_label);
1974   cond_stack->data.cond.next_label = 0;  /* No more _else or _elseif calls. */
1975 }
1976
1977 /* After calling expand_start_else, turn this "else" into an "else if"
1978    by providing another condition.  */
1979
1980 void
1981 expand_elseif (cond)
1982      tree cond;
1983 {
1984   cond_stack->data.cond.next_label = gen_label_rtx ();
1985   do_jump (cond, cond_stack->data.cond.next_label, NULL_RTX);
1986 }
1987
1988 /* Generate RTL for the end of an if-then.
1989    Pop the record for it off of cond_stack.  */
1990
1991 void
1992 expand_end_cond ()
1993 {
1994   struct nesting *thiscond = cond_stack;
1995
1996   if (output_bytecode)
1997     bc_expand_end_cond ();
1998   else
1999     {
2000       do_pending_stack_adjust ();
2001       if (thiscond->data.cond.next_label)
2002         emit_label (thiscond->data.cond.next_label);
2003       if (thiscond->data.cond.endif_label)
2004         emit_label (thiscond->data.cond.endif_label);
2005     }
2006
2007   POPSTACK (cond_stack);
2008   last_expr_type = 0;
2009 }
2010
2011
2012 /* Generate code for the start of an if-then.  COND is the expression
2013    whose truth is to be tested; if EXITFLAG is nonzero this conditional
2014    is to be visible to exit_something.  It is assumed that the caller
2015    has pushed the previous context on the cond stack. */
2016
2017 static void
2018 bc_expand_start_cond (cond, exitflag)
2019      tree cond;
2020      int exitflag;
2021 {
2022   struct nesting *thiscond = cond_stack;
2023
2024   thiscond->data.case_stmt.nominal_type = cond;
2025   if (! exitflag)
2026     thiscond->exit_label = gen_label_rtx ();
2027   bc_expand_expr (cond);
2028   bc_emit_bytecode (xjumpifnot);
2029   bc_emit_bytecode_labelref (BYTECODE_BC_LABEL (thiscond->exit_label));
2030
2031 #ifdef DEBUG_PRINT_CODE
2032   fputc ('\n', stderr);
2033 #endif
2034 }
2035
2036 /* Generate the label for the end of an if with
2037    no else- clause.  */
2038
2039 static void
2040 bc_expand_end_cond ()
2041 {
2042   struct nesting *thiscond = cond_stack;
2043
2044   bc_emit_bytecode_labeldef (BYTECODE_BC_LABEL (thiscond->exit_label));
2045 }
2046
2047 /* Generate code for the start of the else- clause of
2048    an if-then-else.  */
2049
2050 static void
2051 bc_expand_start_else ()
2052 {
2053   struct nesting *thiscond = cond_stack;
2054
2055   thiscond->data.cond.endif_label = thiscond->exit_label;
2056   thiscond->exit_label = gen_label_rtx ();
2057   bc_emit_bytecode (jump);
2058   bc_emit_bytecode_labelref (BYTECODE_BC_LABEL (thiscond->exit_label));
2059
2060 #ifdef DEBUG_PRINT_CODE
2061   fputc ('\n', stderr);
2062 #endif
2063
2064   bc_emit_bytecode_labeldef (BYTECODE_BC_LABEL (thiscond->data.cond.endif_label));
2065 }
2066 \f
2067 /* Generate RTL for the start of a loop.  EXIT_FLAG is nonzero if this
2068    loop should be exited by `exit_something'.  This is a loop for which
2069    `expand_continue' will jump to the top of the loop.
2070
2071    Make an entry on loop_stack to record the labels associated with
2072    this loop.  */
2073
2074 struct nesting *
2075 expand_start_loop (exit_flag)
2076      int exit_flag;
2077 {
2078   register struct nesting *thisloop = ALLOC_NESTING ();
2079
2080   /* Make an entry on loop_stack for the loop we are entering.  */
2081
2082   thisloop->next = loop_stack;
2083   thisloop->all = nesting_stack;
2084   thisloop->depth = ++nesting_depth;
2085   thisloop->data.loop.start_label = gen_label_rtx ();
2086   thisloop->data.loop.end_label = gen_label_rtx ();
2087   thisloop->data.loop.alt_end_label = 0;
2088   thisloop->data.loop.continue_label = thisloop->data.loop.start_label;
2089   thisloop->exit_label = exit_flag ? thisloop->data.loop.end_label : 0;
2090   loop_stack = thisloop;
2091   nesting_stack = thisloop;
2092
2093   if (output_bytecode)
2094     {
2095       bc_emit_bytecode_labeldef (BYTECODE_BC_LABEL (thisloop->data.loop.start_label));
2096       return thisloop;
2097     }
2098
2099   do_pending_stack_adjust ();
2100   emit_queue ();
2101   emit_note (NULL_PTR, NOTE_INSN_LOOP_BEG);
2102   emit_label (thisloop->data.loop.start_label);
2103
2104   return thisloop;
2105 }
2106
2107 /* Like expand_start_loop but for a loop where the continuation point
2108    (for expand_continue_loop) will be specified explicitly.  */
2109
2110 struct nesting *
2111 expand_start_loop_continue_elsewhere (exit_flag)
2112      int exit_flag;
2113 {
2114   struct nesting *thisloop = expand_start_loop (exit_flag);
2115   loop_stack->data.loop.continue_label = gen_label_rtx ();
2116   return thisloop;
2117 }
2118
2119 /* Specify the continuation point for a loop started with
2120    expand_start_loop_continue_elsewhere.
2121    Use this at the point in the code to which a continue statement
2122    should jump.  */
2123
2124 void
2125 expand_loop_continue_here ()
2126 {
2127   if (output_bytecode)
2128     {
2129       bc_emit_bytecode_labeldef (BYTECODE_BC_LABEL (loop_stack->data.loop.continue_label));
2130       return;
2131     }
2132   do_pending_stack_adjust ();
2133   emit_note (NULL_PTR, NOTE_INSN_LOOP_CONT);
2134   emit_label (loop_stack->data.loop.continue_label);
2135 }
2136
2137 /* End a loop.  */
2138
2139 static void
2140 bc_expand_end_loop ()
2141 {
2142   struct nesting *thisloop = loop_stack;
2143
2144   bc_emit_bytecode (jump);
2145   bc_emit_bytecode_labelref (BYTECODE_BC_LABEL (thisloop->data.loop.start_label));
2146
2147 #ifdef DEBUG_PRINT_CODE
2148   fputc ('\n', stderr);
2149 #endif
2150
2151   bc_emit_bytecode_labeldef (BYTECODE_BC_LABEL (thisloop->exit_label));
2152   POPSTACK (loop_stack);
2153   last_expr_type = 0;
2154 }
2155
2156
2157 /* Finish a loop.  Generate a jump back to the top and the loop-exit label.
2158    Pop the block off of loop_stack.  */
2159
2160 void
2161 expand_end_loop ()
2162 {
2163   register rtx insn;
2164   register rtx start_label;
2165   rtx last_test_insn = 0;
2166   int num_insns = 0;
2167
2168   if (output_bytecode)
2169     {
2170       bc_expand_end_loop ();
2171       return;
2172     }
2173
2174   insn = get_last_insn ();
2175   start_label = loop_stack->data.loop.start_label;
2176
2177   /* Mark the continue-point at the top of the loop if none elsewhere.  */
2178   if (start_label == loop_stack->data.loop.continue_label)
2179     emit_note_before (NOTE_INSN_LOOP_CONT, start_label);
2180
2181   do_pending_stack_adjust ();
2182
2183   /* If optimizing, perhaps reorder the loop.  If the loop
2184      starts with a conditional exit, roll that to the end
2185      where it will optimize together with the jump back.
2186
2187      We look for the last conditional branch to the exit that we encounter
2188      before hitting 30 insns or a CALL_INSN.  If we see an unconditional
2189      branch to the exit first, use it.
2190
2191      We must also stop at NOTE_INSN_BLOCK_BEG and NOTE_INSN_BLOCK_END notes
2192      because moving them is not valid.  */
2193
2194   if (optimize
2195       &&
2196       ! (GET_CODE (insn) == JUMP_INSN
2197          && GET_CODE (PATTERN (insn)) == SET
2198          && SET_DEST (PATTERN (insn)) == pc_rtx
2199          && GET_CODE (SET_SRC (PATTERN (insn))) == IF_THEN_ELSE))
2200     {
2201       /* Scan insns from the top of the loop looking for a qualified
2202          conditional exit.  */
2203       for (insn = NEXT_INSN (loop_stack->data.loop.start_label); insn;
2204            insn = NEXT_INSN (insn))
2205         {
2206           if (GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == CODE_LABEL)
2207             break;
2208
2209           if (GET_CODE (insn) == NOTE
2210               && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG
2211                   || NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END))
2212             break;
2213
2214           if (GET_CODE (insn) == JUMP_INSN || GET_CODE (insn) == INSN)
2215             num_insns++;
2216
2217           if (last_test_insn && num_insns > 30)
2218             break;
2219
2220           if (GET_CODE (insn) == JUMP_INSN && GET_CODE (PATTERN (insn)) == SET
2221               && SET_DEST (PATTERN (insn)) == pc_rtx
2222               && GET_CODE (SET_SRC (PATTERN (insn))) == IF_THEN_ELSE
2223               && ((GET_CODE (XEXP (SET_SRC (PATTERN (insn)), 1)) == LABEL_REF
2224                    && ((XEXP (XEXP (SET_SRC (PATTERN (insn)), 1), 0)
2225                         == loop_stack->data.loop.end_label)
2226                        || (XEXP (XEXP (SET_SRC (PATTERN (insn)), 1), 0)
2227                            == loop_stack->data.loop.alt_end_label)))
2228                   || (GET_CODE (XEXP (SET_SRC (PATTERN (insn)), 2)) == LABEL_REF
2229                       && ((XEXP (XEXP (SET_SRC (PATTERN (insn)), 2), 0)
2230                            == loop_stack->data.loop.end_label)
2231                           || (XEXP (XEXP (SET_SRC (PATTERN (insn)), 2), 0)
2232                               == loop_stack->data.loop.alt_end_label)))))
2233             last_test_insn = insn;
2234
2235           if (last_test_insn == 0 && GET_CODE (insn) == JUMP_INSN
2236               && GET_CODE (PATTERN (insn)) == SET
2237               && SET_DEST (PATTERN (insn)) == pc_rtx
2238               && GET_CODE (SET_SRC (PATTERN (insn))) == LABEL_REF
2239               && ((XEXP (SET_SRC (PATTERN (insn)), 0)
2240                    == loop_stack->data.loop.end_label)
2241                   || (XEXP (SET_SRC (PATTERN (insn)), 0)
2242                       == loop_stack->data.loop.alt_end_label)))
2243             /* Include BARRIER.  */
2244             last_test_insn = NEXT_INSN (insn);
2245         }
2246
2247       if (last_test_insn != 0 && last_test_insn != get_last_insn ())
2248         {
2249           /* We found one.  Move everything from there up
2250              to the end of the loop, and add a jump into the loop
2251              to jump to there.  */
2252           register rtx newstart_label = gen_label_rtx ();
2253           register rtx start_move = start_label;
2254
2255           /* If the start label is preceded by a NOTE_INSN_LOOP_CONT note,
2256              then we want to move this note also.  */
2257           if (GET_CODE (PREV_INSN (start_move)) == NOTE
2258               && (NOTE_LINE_NUMBER (PREV_INSN (start_move))
2259                   == NOTE_INSN_LOOP_CONT))
2260             start_move = PREV_INSN (start_move);
2261
2262           emit_label_after (newstart_label, PREV_INSN (start_move));
2263           reorder_insns (start_move, last_test_insn, get_last_insn ());
2264           emit_jump_insn_after (gen_jump (start_label),
2265                                 PREV_INSN (newstart_label));
2266           emit_barrier_after (PREV_INSN (newstart_label));
2267           start_label = newstart_label;
2268         }
2269     }
2270
2271   emit_jump (start_label);
2272   emit_note (NULL_PTR, NOTE_INSN_LOOP_END);
2273   emit_label (loop_stack->data.loop.end_label);
2274
2275   POPSTACK (loop_stack);
2276
2277   last_expr_type = 0;
2278 }
2279
2280 /* Generate a jump to the current loop's continue-point.
2281    This is usually the top of the loop, but may be specified
2282    explicitly elsewhere.  If not currently inside a loop,
2283    return 0 and do nothing; caller will print an error message.  */
2284
2285 int
2286 expand_continue_loop (whichloop)
2287      struct nesting *whichloop;
2288 {
2289   last_expr_type = 0;
2290   if (whichloop == 0)
2291     whichloop = loop_stack;
2292   if (whichloop == 0)
2293     return 0;
2294   expand_goto_internal (NULL_TREE, whichloop->data.loop.continue_label,
2295                         NULL_RTX);
2296   return 1;
2297 }
2298
2299 /* Generate a jump to exit the current loop.  If not currently inside a loop,
2300    return 0 and do nothing; caller will print an error message.  */
2301
2302 int
2303 expand_exit_loop (whichloop)
2304      struct nesting *whichloop;
2305 {
2306   last_expr_type = 0;
2307   if (whichloop == 0)
2308     whichloop = loop_stack;
2309   if (whichloop == 0)
2310     return 0;
2311   expand_goto_internal (NULL_TREE, whichloop->data.loop.end_label, NULL_RTX);
2312   return 1;
2313 }
2314
2315 /* Generate a conditional jump to exit the current loop if COND
2316    evaluates to zero.  If not currently inside a loop,
2317    return 0 and do nothing; caller will print an error message.  */
2318
2319 int
2320 expand_exit_loop_if_false (whichloop, cond)
2321      struct nesting *whichloop;
2322      tree cond;
2323 {
2324   last_expr_type = 0;
2325   if (whichloop == 0)
2326     whichloop = loop_stack;
2327   if (whichloop == 0)
2328     return 0;
2329   if (output_bytecode)
2330     {
2331       bc_expand_expr (cond);
2332       bc_expand_goto_internal (xjumpifnot,
2333                                BYTECODE_BC_LABEL (whichloop->exit_label),
2334                                NULL_TREE);
2335     }
2336   else
2337     {
2338       /* In order to handle fixups, we actually create a conditional jump
2339          around a unconditional branch to exit the loop.  If fixups are
2340          necessary, they go before the unconditional branch.  */
2341
2342       rtx label = gen_label_rtx ();
2343       rtx last_insn;
2344
2345       do_jump (cond, NULL_RTX, label);
2346       last_insn = get_last_insn ();
2347       if (GET_CODE (last_insn) == CODE_LABEL)
2348         whichloop->data.loop.alt_end_label = last_insn;
2349       expand_goto_internal (NULL_TREE, whichloop->data.loop.end_label,
2350                             NULL_RTX);
2351       emit_label (label);
2352     }
2353
2354   return 1;
2355 }
2356
2357 /* Return non-zero if we should preserve sub-expressions as separate
2358    pseudos.  We never do so if we aren't optimizing.  We always do so
2359    if -fexpensive-optimizations.
2360
2361    Otherwise, we only do so if we are in the "early" part of a loop.  I.e.,
2362    the loop may still be a small one.  */
2363
2364 int
2365 preserve_subexpressions_p ()
2366 {
2367   rtx insn;
2368
2369   if (flag_expensive_optimizations)
2370     return 1;
2371
2372   if (optimize == 0 || loop_stack == 0)
2373     return 0;
2374
2375   insn = get_last_insn_anywhere ();
2376
2377   return (insn
2378           && (INSN_UID (insn) - INSN_UID (loop_stack->data.loop.start_label)
2379               < n_non_fixed_regs * 3));
2380
2381 }
2382
2383 /* Generate a jump to exit the current loop, conditional, binding contour
2384    or case statement.  Not all such constructs are visible to this function,
2385    only those started with EXIT_FLAG nonzero.  Individual languages use
2386    the EXIT_FLAG parameter to control which kinds of constructs you can
2387    exit this way.
2388
2389    If not currently inside anything that can be exited,
2390    return 0 and do nothing; caller will print an error message.  */
2391
2392 int
2393 expand_exit_something ()
2394 {
2395   struct nesting *n;
2396   last_expr_type = 0;
2397   for (n = nesting_stack; n; n = n->all)
2398     if (n->exit_label != 0)
2399       {
2400         expand_goto_internal (NULL_TREE, n->exit_label, NULL_RTX);
2401         return 1;
2402       }
2403
2404   return 0;
2405 }
2406 \f
2407 /* Generate RTL to return from the current function, with no value.
2408    (That is, we do not do anything about returning any value.)  */
2409
2410 void
2411 expand_null_return ()
2412 {
2413   struct nesting *block = block_stack;
2414   rtx last_insn = 0;
2415
2416   if (output_bytecode)
2417     {
2418       bc_emit_instruction (ret);
2419       return;
2420     }
2421
2422   /* Does any pending block have cleanups?  */
2423
2424   while (block && block->data.block.cleanups == 0)
2425     block = block->next;
2426
2427   /* If yes, use a goto to return, since that runs cleanups.  */
2428
2429   expand_null_return_1 (last_insn, block != 0);
2430 }
2431
2432 /* Generate RTL to return from the current function, with value VAL.  */
2433
2434 static void
2435 expand_value_return (val)
2436      rtx val;
2437 {
2438   struct nesting *block = block_stack;
2439   rtx last_insn = get_last_insn ();
2440   rtx return_reg = DECL_RTL (DECL_RESULT (current_function_decl));
2441
2442   /* Copy the value to the return location
2443      unless it's already there.  */
2444
2445   if (return_reg != val)
2446     {
2447 #ifdef PROMOTE_FUNCTION_RETURN
2448       tree type = TREE_TYPE (DECL_RESULT (current_function_decl));
2449       int unsignedp = TREE_UNSIGNED (type);
2450       enum machine_mode mode
2451         = promote_mode (type, DECL_MODE (DECL_RESULT (current_function_decl)),
2452                         &unsignedp, 1);
2453
2454       if (GET_MODE (val) != VOIDmode && GET_MODE (val) != mode)
2455         convert_move (return_reg, val, unsignedp);
2456       else
2457 #endif
2458         emit_move_insn (return_reg, val);
2459     }
2460   if (GET_CODE (return_reg) == REG
2461       && REGNO (return_reg) < FIRST_PSEUDO_REGISTER)
2462     emit_insn (gen_rtx (USE, VOIDmode, return_reg));
2463
2464   /* Does any pending block have cleanups?  */
2465
2466   while (block && block->data.block.cleanups == 0)
2467     block = block->next;
2468
2469   /* If yes, use a goto to return, since that runs cleanups.
2470      Use LAST_INSN to put cleanups *before* the move insn emitted above.  */
2471
2472   expand_null_return_1 (last_insn, block != 0);
2473 }
2474
2475 /* Output a return with no value.  If LAST_INSN is nonzero,
2476    pretend that the return takes place after LAST_INSN.
2477    If USE_GOTO is nonzero then don't use a return instruction;
2478    go to the return label instead.  This causes any cleanups
2479    of pending blocks to be executed normally.  */
2480
2481 static void
2482 expand_null_return_1 (last_insn, use_goto)
2483      rtx last_insn;
2484      int use_goto;
2485 {
2486   rtx end_label = cleanup_label ? cleanup_label : return_label;
2487
2488   clear_pending_stack_adjust ();
2489   do_pending_stack_adjust ();
2490   last_expr_type = 0;
2491
2492   /* PCC-struct return always uses an epilogue.  */
2493   if (current_function_returns_pcc_struct || use_goto)
2494     {
2495       if (end_label == 0)
2496         end_label = return_label = gen_label_rtx ();
2497       expand_goto_internal (NULL_TREE, end_label, last_insn);
2498       return;
2499     }
2500
2501   /* Otherwise output a simple return-insn if one is available,
2502      unless it won't do the job.  */
2503 #ifdef HAVE_return
2504   if (HAVE_return && use_goto == 0 && cleanup_label == 0)
2505     {
2506       emit_jump_insn (gen_return ());
2507       emit_barrier ();
2508       return;
2509     }
2510 #endif
2511
2512   /* Otherwise jump to the epilogue.  */
2513   expand_goto_internal (NULL_TREE, end_label, last_insn);
2514 }
2515 \f
2516 /* Generate RTL to evaluate the expression RETVAL and return it
2517    from the current function.  */
2518
2519 void
2520 expand_return (retval)
2521      tree retval;
2522 {
2523   /* If there are any cleanups to be performed, then they will
2524      be inserted following LAST_INSN.  It is desirable
2525      that the last_insn, for such purposes, should be the
2526      last insn before computing the return value.  Otherwise, cleanups
2527      which call functions can clobber the return value.  */
2528   /* ??? rms: I think that is erroneous, because in C++ it would
2529      run destructors on variables that might be used in the subsequent
2530      computation of the return value.  */
2531   rtx last_insn = 0;
2532   register rtx val = 0;
2533   register rtx op0;
2534   tree retval_rhs;
2535   int cleanups;
2536   struct nesting *block;
2537
2538   /* Bytecode returns are quite simple, just leave the result on the
2539      arithmetic stack. */
2540   if (output_bytecode)
2541     {
2542       bc_expand_expr (retval);
2543       bc_emit_instruction (ret);
2544       return;
2545     }
2546
2547   /* If function wants no value, give it none.  */
2548   if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl))) == VOID_TYPE)
2549     {
2550       expand_expr (retval, NULL_RTX, VOIDmode, 0);
2551       emit_queue ();
2552       expand_null_return ();
2553       return;
2554     }
2555
2556   /* Are any cleanups needed?  E.g. C++ destructors to be run?  */
2557   /* This is not sufficient.  We also need to watch for cleanups of the
2558      expression we are about to expand.  Unfortunately, we cannot know
2559      if it has cleanups until we expand it, and we want to change how we
2560      expand it depending upon if we need cleanups.  We can't win.  */
2561 #if 0
2562   cleanups = any_pending_cleanups (1);
2563 #else
2564   cleanups = 1;
2565 #endif
2566
2567   if (TREE_CODE (retval) == RESULT_DECL)
2568     retval_rhs = retval;
2569   else if ((TREE_CODE (retval) == MODIFY_EXPR || TREE_CODE (retval) == INIT_EXPR)
2570            && TREE_CODE (TREE_OPERAND (retval, 0)) == RESULT_DECL)
2571     retval_rhs = TREE_OPERAND (retval, 1);
2572   else if (TREE_TYPE (retval) == void_type_node)
2573     /* Recognize tail-recursive call to void function.  */
2574     retval_rhs = retval;
2575   else
2576     retval_rhs = NULL_TREE;
2577
2578   /* Only use `last_insn' if there are cleanups which must be run.  */
2579   if (cleanups || cleanup_label != 0)
2580     last_insn = get_last_insn ();
2581
2582   /* Distribute return down conditional expr if either of the sides
2583      may involve tail recursion (see test below).  This enhances the number
2584      of tail recursions we see.  Don't do this always since it can produce
2585      sub-optimal code in some cases and we distribute assignments into
2586      conditional expressions when it would help.  */
2587
2588   if (optimize && retval_rhs != 0
2589       && frame_offset == 0
2590       && TREE_CODE (retval_rhs) == COND_EXPR
2591       && (TREE_CODE (TREE_OPERAND (retval_rhs, 1)) == CALL_EXPR
2592           || TREE_CODE (TREE_OPERAND (retval_rhs, 2)) == CALL_EXPR))
2593     {
2594       rtx label = gen_label_rtx ();
2595       tree expr;
2596
2597       do_jump (TREE_OPERAND (retval_rhs, 0), label, NULL_RTX);
2598       expr = build (MODIFY_EXPR, TREE_TYPE (current_function_decl),
2599                     DECL_RESULT (current_function_decl),
2600                     TREE_OPERAND (retval_rhs, 1));
2601       TREE_SIDE_EFFECTS (expr) = 1;
2602       expand_return (expr);
2603       emit_label (label);
2604
2605       expr = build (MODIFY_EXPR, TREE_TYPE (current_function_decl),
2606                     DECL_RESULT (current_function_decl),
2607                     TREE_OPERAND (retval_rhs, 2));
2608       TREE_SIDE_EFFECTS (expr) = 1;
2609       expand_return (expr);
2610       return;
2611     }
2612
2613   /* For tail-recursive call to current function,
2614      just jump back to the beginning.
2615      It's unsafe if any auto variable in this function
2616      has its address taken; for simplicity,
2617      require stack frame to be empty.  */
2618   if (optimize && retval_rhs != 0
2619       && frame_offset == 0
2620       && TREE_CODE (retval_rhs) == CALL_EXPR
2621       && TREE_CODE (TREE_OPERAND (retval_rhs, 0)) == ADDR_EXPR
2622       && TREE_OPERAND (TREE_OPERAND (retval_rhs, 0), 0) == current_function_decl
2623       /* Finish checking validity, and if valid emit code
2624          to set the argument variables for the new call.  */
2625       && tail_recursion_args (TREE_OPERAND (retval_rhs, 1),
2626                               DECL_ARGUMENTS (current_function_decl)))
2627     {
2628       if (tail_recursion_label == 0)
2629         {
2630           tail_recursion_label = gen_label_rtx ();
2631           emit_label_after (tail_recursion_label,
2632                             tail_recursion_reentry);
2633         }
2634       emit_queue ();
2635       expand_goto_internal (NULL_TREE, tail_recursion_label, last_insn);
2636       emit_barrier ();
2637       return;
2638     }
2639 #ifdef HAVE_return
2640   /* This optimization is safe if there are local cleanups
2641      because expand_null_return takes care of them.
2642      ??? I think it should also be safe when there is a cleanup label,
2643      because expand_null_return takes care of them, too.
2644      Any reason why not?  */
2645   if (HAVE_return && cleanup_label == 0
2646       && ! current_function_returns_pcc_struct
2647       && BRANCH_COST <= 1)
2648     {
2649       /* If this is  return x == y;  then generate
2650          if (x == y) return 1; else return 0;
2651          if we can do it with explicit return insns and
2652          branches are cheap.  */
2653       if (retval_rhs)
2654         switch (TREE_CODE (retval_rhs))
2655           {
2656           case EQ_EXPR:
2657           case NE_EXPR:
2658           case GT_EXPR:
2659           case GE_EXPR:
2660           case LT_EXPR:
2661           case LE_EXPR:
2662           case TRUTH_ANDIF_EXPR:
2663           case TRUTH_ORIF_EXPR:
2664           case TRUTH_AND_EXPR:
2665           case TRUTH_OR_EXPR:
2666           case TRUTH_NOT_EXPR:
2667           case TRUTH_XOR_EXPR:
2668             op0 = gen_label_rtx ();
2669             jumpifnot (retval_rhs, op0);
2670             expand_value_return (const1_rtx);
2671             emit_label (op0);
2672             expand_value_return (const0_rtx);
2673             return;
2674           }
2675     }
2676 #endif /* HAVE_return */
2677
2678   /* If the result is an aggregate that is being returned in one (or more)
2679      registers, load the registers here.  The compiler currently can't handle
2680      copying a BLKmode value into registers.  We could put this code in a
2681      more general area (for use by everyone instead of just function
2682      call/return), but until this feature is generally usable it is kept here
2683      (and in expand_call).  */
2684
2685   if (retval_rhs != 0
2686       && TYPE_MODE (TREE_TYPE (retval_rhs)) == BLKmode
2687       && GET_CODE (DECL_RTL (DECL_RESULT (current_function_decl))) == REG)
2688     {
2689       int i;
2690       int big_endian_correction = 0;
2691       int bytes = int_size_in_bytes (TREE_TYPE (retval_rhs));
2692       int n_regs = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
2693       rtx *result_pseudos = (rtx *) alloca (sizeof (rtx) * n_regs);
2694       rtx result_reg = DECL_RTL (DECL_RESULT (current_function_decl));
2695       rtx result_val = expand_expr (retval_rhs, NULL_RTX, VOIDmode, 0);
2696       enum machine_mode tmpmode;
2697
2698       /* Structures smaller than a word are aligned to the least significant
2699          byte (to the right).  On a BYTES_BIG_ENDIAN machine, this means we
2700          must skip the empty high order bytes when calculating the bit
2701          offset.  */
2702       if (BYTES_BIG_ENDIAN && bytes < UNITS_PER_WORD)
2703         big_endian_correction = (BITS_PER_WORD - (bytes * BITS_PER_UNIT));
2704
2705       for (i = 0; i < n_regs; i++)
2706         {
2707           rtx reg = gen_reg_rtx (word_mode);
2708           rtx word = operand_subword_force (result_val, i, BLKmode);
2709           int bitsize = MIN (TYPE_ALIGN (TREE_TYPE (retval_rhs)),BITS_PER_WORD);
2710           int bitpos;
2711
2712           result_pseudos[i] = reg;
2713
2714           /* Clobber REG and move each partword into it.  Ensure we don't
2715              go past the end of the structure.  Note that the loop below
2716              works because we've already verified that padding and
2717              endianness are compatable.  */
2718           emit_insn (gen_rtx (CLOBBER, VOIDmode, reg));
2719
2720           for (bitpos = 0;
2721                bitpos < BITS_PER_WORD && bytes > 0;
2722                bitpos += bitsize, bytes -= bitsize / BITS_PER_UNIT)
2723             {
2724               int xbitpos = bitpos + big_endian_correction;
2725
2726               store_bit_field (reg, bitsize, xbitpos, word_mode,
2727                                extract_bit_field (word, bitsize, bitpos, 1,
2728                                                   NULL_RTX, word_mode,
2729                                                   word_mode,
2730                                                   bitsize / BITS_PER_UNIT,
2731                                                   BITS_PER_WORD),
2732                                bitsize / BITS_PER_UNIT, BITS_PER_WORD);
2733             }
2734         }
2735
2736       /* Now that the value is in pseudos, copy it to the result reg(s).  */
2737       emit_queue ();
2738       free_temp_slots ();
2739       for (i = 0; i < n_regs; i++)
2740         emit_move_insn (gen_rtx (REG, word_mode, REGNO (result_reg) + i),
2741                         result_pseudos[i]);
2742
2743       /* Find the smallest integer mode large enough to hold the
2744          entire structure and use that mode instead of BLKmode
2745          on the USE insn for the return register.   */
2746       bytes = int_size_in_bytes (TREE_TYPE (retval_rhs));
2747       for (tmpmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2748            tmpmode != MAX_MACHINE_MODE;
2749            tmpmode = GET_MODE_WIDER_MODE (tmpmode))
2750       {
2751         /* Have we found a large enough mode?  */
2752         if (GET_MODE_SIZE (tmpmode) >= bytes)
2753           break;
2754       }
2755
2756       /* No suitable mode found.  */
2757       if (tmpmode == MAX_MACHINE_MODE)
2758       abort ();
2759
2760       PUT_MODE (result_reg, tmpmode);
2761
2762       expand_value_return (result_reg);
2763     }
2764   else if (cleanups
2765       && retval_rhs != 0
2766       && TREE_TYPE (retval_rhs) != void_type_node
2767       && GET_CODE (DECL_RTL (DECL_RESULT (current_function_decl))) == REG)
2768     {
2769       /* Calculate the return value into a pseudo reg.  */
2770       val = expand_expr (retval_rhs, NULL_RTX, VOIDmode, 0);
2771       emit_queue ();
2772       /* All temporaries have now been used.  */
2773       free_temp_slots ();
2774       /* Return the calculated value, doing cleanups first.  */
2775       expand_value_return (val);
2776     }
2777   else
2778     {
2779       /* No cleanups or no hard reg used;
2780          calculate value into hard return reg.  */
2781       expand_expr (retval, const0_rtx, VOIDmode, 0);
2782       emit_queue ();
2783       free_temp_slots ();
2784       expand_value_return (DECL_RTL (DECL_RESULT (current_function_decl)));
2785     }
2786 }
2787
2788 /* Return 1 if the end of the generated RTX is not a barrier.
2789    This means code already compiled can drop through.  */
2790
2791 int
2792 drop_through_at_end_p ()
2793 {
2794   rtx insn = get_last_insn ();
2795   while (insn && GET_CODE (insn) == NOTE)
2796     insn = PREV_INSN (insn);
2797   return insn && GET_CODE (insn) != BARRIER;
2798 }
2799 \f
2800 /* Emit code to alter this function's formal parms for a tail-recursive call.
2801    ACTUALS is a list of actual parameter expressions (chain of TREE_LISTs).
2802    FORMALS is the chain of decls of formals.
2803    Return 1 if this can be done;
2804    otherwise return 0 and do not emit any code.  */
2805
2806 static int
2807 tail_recursion_args (actuals, formals)
2808      tree actuals, formals;
2809 {
2810   register tree a = actuals, f = formals;
2811   register int i;
2812   register rtx *argvec;
2813
2814   /* Check that number and types of actuals are compatible
2815      with the formals.  This is not always true in valid C code.
2816      Also check that no formal needs to be addressable
2817      and that all formals are scalars.  */
2818
2819   /* Also count the args.  */
2820
2821   for (a = actuals, f = formals, i = 0; a && f; a = TREE_CHAIN (a), f = TREE_CHAIN (f), i++)
2822     {
2823       if (TREE_TYPE (TREE_VALUE (a)) != TREE_TYPE (f))
2824         return 0;
2825       if (GET_CODE (DECL_RTL (f)) != REG || DECL_MODE (f) == BLKmode)
2826         return 0;
2827     }
2828   if (a != 0 || f != 0)
2829     return 0;
2830
2831   /* Compute all the actuals.  */
2832
2833   argvec = (rtx *) alloca (i * sizeof (rtx));
2834
2835   for (a = actuals, i = 0; a; a = TREE_CHAIN (a), i++)
2836     argvec[i] = expand_expr (TREE_VALUE (a), NULL_RTX, VOIDmode, 0);
2837
2838   /* Find which actual values refer to current values of previous formals.
2839      Copy each of them now, before any formal is changed.  */
2840
2841   for (a = actuals, i = 0; a; a = TREE_CHAIN (a), i++)
2842     {
2843       int copy = 0;
2844       register int j;
2845       for (f = formals, j = 0; j < i; f = TREE_CHAIN (f), j++)
2846         if (reg_mentioned_p (DECL_RTL (f), argvec[i]))
2847           { copy = 1; break; }
2848       if (copy)
2849         argvec[i] = copy_to_reg (argvec[i]);
2850     }
2851
2852   /* Store the values of the actuals into the formals.  */
2853
2854   for (f = formals, a = actuals, i = 0; f;
2855        f = TREE_CHAIN (f), a = TREE_CHAIN (a), i++)
2856     {
2857       if (GET_MODE (DECL_RTL (f)) == GET_MODE (argvec[i]))
2858         emit_move_insn (DECL_RTL (f), argvec[i]);
2859       else
2860         convert_move (DECL_RTL (f), argvec[i],
2861                       TREE_UNSIGNED (TREE_TYPE (TREE_VALUE (a))));
2862     }
2863
2864   free_temp_slots ();
2865   return 1;
2866 }
2867 \f
2868 /* Generate the RTL code for entering a binding contour.
2869    The variables are declared one by one, by calls to `expand_decl'.
2870
2871    EXIT_FLAG is nonzero if this construct should be visible to
2872    `exit_something'.  */
2873
2874 void
2875 expand_start_bindings (exit_flag)
2876      int exit_flag;
2877 {
2878   struct nesting *thisblock = ALLOC_NESTING ();
2879   rtx note = output_bytecode ? 0 : emit_note (NULL_PTR, NOTE_INSN_BLOCK_BEG);
2880
2881   /* Make an entry on block_stack for the block we are entering.  */
2882
2883   thisblock->next = block_stack;
2884   thisblock->all = nesting_stack;
2885   thisblock->depth = ++nesting_depth;
2886   thisblock->data.block.stack_level = 0;
2887   thisblock->data.block.cleanups = 0;
2888   thisblock->data.block.function_call_count = 0;
2889 #if 0
2890   if (block_stack)
2891     {
2892       if (block_stack->data.block.cleanups == NULL_TREE
2893           && (block_stack->data.block.outer_cleanups == NULL_TREE
2894               || block_stack->data.block.outer_cleanups == empty_cleanup_list))
2895         thisblock->data.block.outer_cleanups = empty_cleanup_list;
2896       else
2897         thisblock->data.block.outer_cleanups
2898           = tree_cons (NULL_TREE, block_stack->data.block.cleanups,
2899                        block_stack->data.block.outer_cleanups);
2900     }
2901   else
2902     thisblock->data.block.outer_cleanups = 0;
2903 #endif
2904 #if 1
2905   if (block_stack
2906       && !(block_stack->data.block.cleanups == NULL_TREE
2907            && block_stack->data.block.outer_cleanups == NULL_TREE))
2908     thisblock->data.block.outer_cleanups
2909       = tree_cons (NULL_TREE, block_stack->data.block.cleanups,
2910                    block_stack->data.block.outer_cleanups);
2911   else
2912     thisblock->data.block.outer_cleanups = 0;
2913 #endif
2914   thisblock->data.block.label_chain = 0;
2915   thisblock->data.block.innermost_stack_block = stack_block_stack;
2916   thisblock->data.block.first_insn = note;
2917   thisblock->data.block.block_start_count = ++block_start_count;
2918   thisblock->exit_label = exit_flag ? gen_label_rtx () : 0;
2919   block_stack = thisblock;
2920   nesting_stack = thisblock;
2921
2922   if (!output_bytecode)
2923     {
2924       /* Make a new level for allocating stack slots.  */
2925       push_temp_slots ();
2926     }
2927 }
2928
2929 /* Given a pointer to a BLOCK node, save a pointer to the most recently
2930    generated NOTE_INSN_BLOCK_END in the BLOCK_END_NOTE field of the given
2931    BLOCK node.  */
2932
2933 void
2934 remember_end_note (block)
2935      register tree block;
2936 {
2937   BLOCK_END_NOTE (block) = last_block_end_note;
2938   last_block_end_note = NULL_RTX;
2939 }
2940
2941 /* Generate RTL code to terminate a binding contour.
2942    VARS is the chain of VAR_DECL nodes
2943    for the variables bound in this contour.
2944    MARK_ENDS is nonzero if we should put a note at the beginning
2945    and end of this binding contour.
2946
2947    DONT_JUMP_IN is nonzero if it is not valid to jump into this contour.
2948    (That is true automatically if the contour has a saved stack level.)  */
2949
2950 void
2951 expand_end_bindings (vars, mark_ends, dont_jump_in)
2952      tree vars;
2953      int mark_ends;
2954      int dont_jump_in;
2955 {
2956   register struct nesting *thisblock = block_stack;
2957   register tree decl;
2958
2959   if (output_bytecode)
2960     {
2961       bc_expand_end_bindings (vars, mark_ends, dont_jump_in);
2962       return;
2963     }
2964
2965   if (warn_unused)
2966     for (decl = vars; decl; decl = TREE_CHAIN (decl))
2967       if (! TREE_USED (decl) && TREE_CODE (decl) == VAR_DECL
2968           && ! DECL_IN_SYSTEM_HEADER (decl))
2969         warning_with_decl (decl, "unused variable `%s'");
2970
2971   if (thisblock->exit_label)
2972     {
2973       do_pending_stack_adjust ();
2974       emit_label (thisblock->exit_label);
2975     }
2976
2977   /* If necessary, make a handler for nonlocal gotos taking
2978      place in the function calls in this block.  */
2979   if (function_call_count != thisblock->data.block.function_call_count
2980       && nonlocal_labels
2981       /* Make handler for outermost block
2982          if there were any nonlocal gotos to this function.  */
2983       && (thisblock->next == 0 ? current_function_has_nonlocal_label
2984           /* Make handler for inner block if it has something
2985              special to do when you jump out of it.  */
2986           : (thisblock->data.block.cleanups != 0
2987              || thisblock->data.block.stack_level != 0)))
2988     {
2989       tree link;
2990       rtx afterward = gen_label_rtx ();
2991       rtx handler_label = gen_label_rtx ();
2992       rtx save_receiver = gen_reg_rtx (Pmode);
2993       rtx insns;
2994
2995       /* Don't let jump_optimize delete the handler.  */
2996       LABEL_PRESERVE_P (handler_label) = 1;
2997
2998       /* Record the handler address in the stack slot for that purpose,
2999          during this block, saving and restoring the outer value.  */
3000       if (thisblock->next != 0)
3001         {
3002           emit_move_insn (nonlocal_goto_handler_slot, save_receiver);
3003
3004           start_sequence ();
3005           emit_move_insn (save_receiver, nonlocal_goto_handler_slot);
3006           insns = get_insns ();
3007           end_sequence ();
3008           emit_insns_before (insns, thisblock->data.block.first_insn);
3009         }
3010
3011       start_sequence ();
3012       emit_move_insn (nonlocal_goto_handler_slot,
3013                       gen_rtx (LABEL_REF, Pmode, handler_label));
3014       insns = get_insns ();
3015       end_sequence ();
3016       emit_insns_before (insns, thisblock->data.block.first_insn);
3017
3018       /* Jump around the handler; it runs only when specially invoked.  */
3019       emit_jump (afterward);
3020       emit_label (handler_label);
3021
3022 #ifdef HAVE_nonlocal_goto
3023       if (! HAVE_nonlocal_goto)
3024 #endif
3025         /* First adjust our frame pointer to its actual value.  It was
3026            previously set to the start of the virtual area corresponding to
3027            the stacked variables when we branched here and now needs to be
3028            adjusted to the actual hardware fp value.
3029
3030            Assignments are to virtual registers are converted by
3031            instantiate_virtual_regs into the corresponding assignment
3032            to the underlying register (fp in this case) that makes
3033            the original assignment true.
3034            So the following insn will actually be
3035            decrementing fp by STARTING_FRAME_OFFSET.  */
3036         emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
3037
3038 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
3039       if (fixed_regs[ARG_POINTER_REGNUM])
3040         {
3041 #ifdef ELIMINABLE_REGS
3042           /* If the argument pointer can be eliminated in favor of the
3043              frame pointer, we don't need to restore it.  We assume here
3044              that if such an elimination is present, it can always be used.
3045              This is the case on all known machines; if we don't make this
3046              assumption, we do unnecessary saving on many machines.  */
3047           static struct elims {int from, to;} elim_regs[] = ELIMINABLE_REGS;
3048           int i;
3049
3050           for (i = 0; i < sizeof elim_regs / sizeof elim_regs[0]; i++)
3051             if (elim_regs[i].from == ARG_POINTER_REGNUM
3052                 && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
3053               break;
3054
3055           if (i == sizeof elim_regs / sizeof elim_regs [0])
3056 #endif
3057             {
3058               /* Now restore our arg pointer from the address at which it
3059                  was saved in our stack frame.
3060                  If there hasn't be space allocated for it yet, make
3061                  some now.  */
3062               if (arg_pointer_save_area == 0)
3063                 arg_pointer_save_area
3064                   = assign_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0);
3065               emit_move_insn (virtual_incoming_args_rtx,
3066                               /* We need a pseudo here, or else
3067                                  instantiate_virtual_regs_1 complains.  */
3068                               copy_to_reg (arg_pointer_save_area));
3069             }
3070         }
3071 #endif
3072
3073       /* The handler expects the desired label address in the static chain
3074          register.  It tests the address and does an appropriate jump
3075          to whatever label is desired.  */
3076       for (link = nonlocal_labels; link; link = TREE_CHAIN (link))
3077         /* Skip any labels we shouldn't be able to jump to from here.  */
3078         if (! DECL_TOO_LATE (TREE_VALUE (link)))
3079           {
3080             rtx not_this = gen_label_rtx ();
3081             rtx this = gen_label_rtx ();
3082             do_jump_if_equal (static_chain_rtx,
3083                               gen_rtx (LABEL_REF, Pmode, DECL_RTL (TREE_VALUE (link))),
3084                               this, 0);
3085             emit_jump (not_this);
3086             emit_label (this);
3087             expand_goto (TREE_VALUE (link));
3088             emit_label (not_this);
3089           }
3090       /* If label is not recognized, abort.  */
3091       emit_library_call (gen_rtx (SYMBOL_REF, Pmode, "abort"), 0,
3092                          VOIDmode, 0);
3093       emit_label (afterward);
3094     }
3095
3096   /* Don't allow jumping into a block that has cleanups or a stack level.  */
3097   if (dont_jump_in
3098       || thisblock->data.block.stack_level != 0
3099       || thisblock->data.block.cleanups != 0)
3100     {
3101       struct label_chain *chain;
3102
3103       /* Any labels in this block are no longer valid to go to.
3104          Mark them to cause an error message.  */
3105       for (chain = thisblock->data.block.label_chain; chain; chain = chain->next)
3106         {
3107           DECL_TOO_LATE (chain->label) = 1;
3108           /* If any goto without a fixup came to this label,
3109              that must be an error, because gotos without fixups
3110              come from outside all saved stack-levels and all cleanups.  */
3111           if (TREE_ADDRESSABLE (chain->label))
3112             error_with_decl (chain->label,
3113                              "label `%s' used before containing binding contour");
3114         }
3115     }
3116
3117   /* Restore stack level in effect before the block
3118      (only if variable-size objects allocated).  */
3119   /* Perform any cleanups associated with the block.  */
3120
3121   if (thisblock->data.block.stack_level != 0
3122       || thisblock->data.block.cleanups != 0)
3123     {
3124       /* Only clean up here if this point can actually be reached.  */
3125       int reachable = GET_CODE (get_last_insn ()) != BARRIER;
3126
3127       /* Don't let cleanups affect ({...}) constructs.  */
3128       int old_expr_stmts_for_value = expr_stmts_for_value;
3129       rtx old_last_expr_value = last_expr_value;
3130       tree old_last_expr_type = last_expr_type;
3131       expr_stmts_for_value = 0;
3132
3133       /* Do the cleanups.  */
3134       expand_cleanups (thisblock->data.block.cleanups, NULL_TREE, 0, reachable);
3135       if (reachable)
3136         do_pending_stack_adjust ();
3137
3138       expr_stmts_for_value = old_expr_stmts_for_value;
3139       last_expr_value = old_last_expr_value;
3140       last_expr_type = old_last_expr_type;
3141
3142       /* Restore the stack level.  */
3143
3144       if (reachable && thisblock->data.block.stack_level != 0)
3145         {
3146           emit_stack_restore (thisblock->next ? SAVE_BLOCK : SAVE_FUNCTION,
3147                               thisblock->data.block.stack_level, NULL_RTX);
3148           if (nonlocal_goto_handler_slot != 0)
3149             emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level,
3150                              NULL_RTX);
3151         }
3152
3153       /* Any gotos out of this block must also do these things.
3154          Also report any gotos with fixups that came to labels in this
3155          level.  */
3156       fixup_gotos (thisblock,
3157                    thisblock->data.block.stack_level,
3158                    thisblock->data.block.cleanups,
3159                    thisblock->data.block.first_insn,
3160                    dont_jump_in);
3161     }
3162
3163   /* Mark the beginning and end of the scope if requested.
3164      We do this now, after running cleanups on the variables
3165      just going out of scope, so they are in scope for their cleanups.  */
3166
3167   if (mark_ends)
3168     last_block_end_note = emit_note (NULL_PTR, NOTE_INSN_BLOCK_END);
3169   else
3170     /* Get rid of the beginning-mark if we don't make an end-mark.  */
3171     NOTE_LINE_NUMBER (thisblock->data.block.first_insn) = NOTE_INSN_DELETED;
3172
3173   /* If doing stupid register allocation, make sure lives of all
3174      register variables declared here extend thru end of scope.  */
3175
3176   if (obey_regdecls)
3177     for (decl = vars; decl; decl = TREE_CHAIN (decl))
3178       {
3179         rtx rtl = DECL_RTL (decl);
3180         if (TREE_CODE (decl) == VAR_DECL && rtl != 0)
3181           use_variable (rtl);
3182       }
3183
3184   /* Restore block_stack level for containing block.  */
3185
3186   stack_block_stack = thisblock->data.block.innermost_stack_block;
3187   POPSTACK (block_stack);
3188
3189   /* Pop the stack slot nesting and free any slots at this level.  */
3190   pop_temp_slots ();
3191 }
3192
3193
3194 /* End a binding contour.
3195    VARS is the chain of VAR_DECL nodes for the variables bound
3196    in this contour.  MARK_ENDS is nonzer if we should put a note
3197    at the beginning and end of this binding contour.
3198    DONT_JUMP_IN is nonzero if it is not valid to jump into this
3199    contour.  */
3200
3201 static void
3202 bc_expand_end_bindings (vars, mark_ends, dont_jump_in)
3203      tree vars;
3204      int mark_ends;
3205      int dont_jump_in;
3206 {
3207   struct nesting *thisbind = nesting_stack;
3208   tree decl;
3209
3210   if (warn_unused)
3211     for (decl = vars; decl; decl = TREE_CHAIN (decl))
3212       if (! TREE_USED (TREE_VALUE (decl)) && TREE_CODE (TREE_VALUE (decl)) == VAR_DECL)
3213         warning_with_decl (decl, "unused variable `%s'");
3214
3215   if (thisbind->exit_label)
3216     bc_emit_bytecode_labeldef (BYTECODE_BC_LABEL (thisbind->exit_label));
3217
3218   /* Pop block/bindings off stack */
3219   POPSTACK (block_stack);
3220 }
3221 \f
3222 /* Generate RTL for the automatic variable declaration DECL.
3223    (Other kinds of declarations are simply ignored if seen here.)
3224    CLEANUP is an expression to be executed at exit from this binding contour;
3225    for example, in C++, it might call the destructor for this variable.
3226
3227    If CLEANUP contains any SAVE_EXPRs, then you must preevaluate them
3228    either before or after calling `expand_decl' but before compiling
3229    any subsequent expressions.  This is because CLEANUP may be expanded
3230    more than once, on different branches of execution.
3231    For the same reason, CLEANUP may not contain a CALL_EXPR
3232    except as its topmost node--else `preexpand_calls' would get confused.
3233
3234    If CLEANUP is nonzero and DECL is zero, we record a cleanup
3235    that is not associated with any particular variable.
3236
3237    There is no special support here for C++ constructors.
3238    They should be handled by the proper code in DECL_INITIAL.  */
3239
3240 void
3241 expand_decl (decl)
3242      register tree decl;
3243 {
3244   struct nesting *thisblock = block_stack;
3245   tree type;
3246
3247   if (output_bytecode)
3248     {
3249       bc_expand_decl (decl, 0);
3250       return;
3251     }
3252
3253   type = TREE_TYPE (decl);
3254
3255   /* Only automatic variables need any expansion done.
3256      Static and external variables, and external functions,
3257      will be handled by `assemble_variable' (called from finish_decl).
3258      TYPE_DECL and CONST_DECL require nothing.
3259      PARM_DECLs are handled in `assign_parms'.  */
3260
3261   if (TREE_CODE (decl) != VAR_DECL)
3262     return;
3263   if (TREE_STATIC (decl) || DECL_EXTERNAL (decl))
3264     return;
3265
3266   /* Create the RTL representation for the variable.  */
3267
3268   if (type == error_mark_node)
3269     DECL_RTL (decl) = gen_rtx (MEM, BLKmode, const0_rtx);
3270   else if (DECL_SIZE (decl) == 0)
3271     /* Variable with incomplete type.  */
3272     {
3273       if (DECL_INITIAL (decl) == 0)
3274         /* Error message was already done; now avoid a crash.  */
3275         DECL_RTL (decl) = assign_stack_temp (DECL_MODE (decl), 0, 1);
3276       else
3277         /* An initializer is going to decide the size of this array.
3278            Until we know the size, represent its address with a reg.  */
3279         DECL_RTL (decl) = gen_rtx (MEM, BLKmode, gen_reg_rtx (Pmode));
3280       MEM_IN_STRUCT_P (DECL_RTL (decl)) = AGGREGATE_TYPE_P (type);
3281     }
3282   else if (DECL_MODE (decl) != BLKmode
3283            /* If -ffloat-store, don't put explicit float vars
3284               into regs.  */
3285            && !(flag_float_store
3286                 && TREE_CODE (type) == REAL_TYPE)
3287            && ! TREE_THIS_VOLATILE (decl)
3288            && ! TREE_ADDRESSABLE (decl)
3289            && (DECL_REGISTER (decl) || ! obey_regdecls))
3290     {
3291       /* Automatic variable that can go in a register.  */
3292       int unsignedp = TREE_UNSIGNED (type);
3293       enum machine_mode reg_mode
3294         = promote_mode (type, DECL_MODE (decl), &unsignedp, 0);
3295
3296       if (TREE_CODE (type) == COMPLEX_TYPE)
3297         {
3298           rtx realpart, imagpart;
3299           enum machine_mode partmode = TYPE_MODE (TREE_TYPE (type));
3300
3301           /* For a complex type variable, make a CONCAT of two pseudos
3302              so that the real and imaginary parts
3303              can be allocated separately.  */
3304           realpart = gen_reg_rtx (partmode);
3305           REG_USERVAR_P (realpart) = 1;
3306           imagpart = gen_reg_rtx (partmode);
3307           REG_USERVAR_P (imagpart) = 1;
3308           DECL_RTL (decl) = gen_rtx (CONCAT, reg_mode, realpart, imagpart);
3309         }
3310       else
3311         {
3312           DECL_RTL (decl) = gen_reg_rtx (reg_mode);
3313           if (TREE_CODE (type) == POINTER_TYPE)
3314             mark_reg_pointer (DECL_RTL (decl));
3315           REG_USERVAR_P (DECL_RTL (decl)) = 1;
3316         }
3317     }
3318   else if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
3319     {
3320       /* Variable of fixed size that goes on the stack.  */
3321       rtx oldaddr = 0;
3322       rtx addr;
3323
3324       /* If we previously made RTL for this decl, it must be an array
3325          whose size was determined by the initializer.
3326          The old address was a register; set that register now
3327          to the proper address.  */
3328       if (DECL_RTL (decl) != 0)
3329         {
3330           if (GET_CODE (DECL_RTL (decl)) != MEM
3331               || GET_CODE (XEXP (DECL_RTL (decl), 0)) != REG)
3332             abort ();
3333           oldaddr = XEXP (DECL_RTL (decl), 0);
3334         }
3335
3336       DECL_RTL (decl)
3337         = assign_stack_temp (DECL_MODE (decl),
3338                              ((TREE_INT_CST_LOW (DECL_SIZE (decl))
3339                                + BITS_PER_UNIT - 1)
3340                               / BITS_PER_UNIT),
3341                              1);
3342       MEM_IN_STRUCT_P (DECL_RTL (decl)) = AGGREGATE_TYPE_P (TREE_TYPE (decl));
3343
3344       /* Set alignment we actually gave this decl.  */
3345       DECL_ALIGN (decl) = (DECL_MODE (decl) == BLKmode ? BIGGEST_ALIGNMENT
3346                            : GET_MODE_BITSIZE (DECL_MODE (decl)));
3347
3348       if (oldaddr)
3349         {
3350           addr = force_operand (XEXP (DECL_RTL (decl), 0), oldaddr);
3351           if (addr != oldaddr)
3352             emit_move_insn (oldaddr, addr);
3353         }
3354
3355       /* If this is a memory ref that contains aggregate components,
3356          mark it as such for cse and loop optimize.  */
3357       MEM_IN_STRUCT_P (DECL_RTL (decl)) = AGGREGATE_TYPE_P (TREE_TYPE (decl));
3358 #if 0
3359       /* If this is in memory because of -ffloat-store,
3360          set the volatile bit, to prevent optimizations from
3361          undoing the effects.  */
3362       if (flag_float_store && TREE_CODE (type) == REAL_TYPE)
3363         MEM_VOLATILE_P (DECL_RTL (decl)) = 1;
3364 #endif
3365     }
3366   else
3367     /* Dynamic-size object: must push space on the stack.  */
3368     {
3369       rtx address, size;
3370
3371       /* Record the stack pointer on entry to block, if have
3372          not already done so.  */
3373       if (thisblock->data.block.stack_level == 0)
3374         {
3375           do_pending_stack_adjust ();
3376           emit_stack_save (thisblock->next ? SAVE_BLOCK : SAVE_FUNCTION,
3377                            &thisblock->data.block.stack_level,
3378                            thisblock->data.block.first_insn);
3379           stack_block_stack = thisblock;
3380         }
3381
3382       /* Compute the variable's size, in bytes.  */
3383       size = expand_expr (size_binop (CEIL_DIV_EXPR,
3384                                       DECL_SIZE (decl),
3385                                       size_int (BITS_PER_UNIT)),
3386                           NULL_RTX, VOIDmode, 0);
3387       free_temp_slots ();
3388
3389       /* Allocate space on the stack for the variable.  */
3390       address = allocate_dynamic_stack_space (size, NULL_RTX,
3391                                               DECL_ALIGN (decl));
3392
3393       /* Reference the variable indirect through that rtx.  */
3394       DECL_RTL (decl) = gen_rtx (MEM, DECL_MODE (decl), address);
3395
3396       /* If this is a memory ref that contains aggregate components,
3397          mark it as such for cse and loop optimize.  */
3398       MEM_IN_STRUCT_P (DECL_RTL (decl)) = AGGREGATE_TYPE_P (TREE_TYPE (decl));
3399
3400       /* Indicate the alignment we actually gave this variable.  */
3401 #ifdef STACK_BOUNDARY
3402       DECL_ALIGN (decl) = STACK_BOUNDARY;
3403 #else
3404       DECL_ALIGN (decl) = BIGGEST_ALIGNMENT;
3405 #endif
3406     }
3407
3408   if (TREE_THIS_VOLATILE (decl))
3409     MEM_VOLATILE_P (DECL_RTL (decl)) = 1;
3410 #if 0 /* A variable is not necessarily unchanging
3411          just because it is const.  RTX_UNCHANGING_P
3412          means no change in the function,
3413          not merely no change in the variable's scope.
3414          It is correct to set RTX_UNCHANGING_P if the variable's scope
3415          is the whole function.  There's no convenient way to test that.  */
3416   if (TREE_READONLY (decl))
3417     RTX_UNCHANGING_P (DECL_RTL (decl)) = 1;
3418 #endif
3419
3420   /* If doing stupid register allocation, make sure life of any
3421      register variable starts here, at the start of its scope.  */
3422
3423   if (obey_regdecls)
3424     use_variable (DECL_RTL (decl));
3425 }
3426
3427
3428 /* Generate code for the automatic variable declaration DECL.  For
3429    most variables this just means we give it a stack offset.  The
3430    compiler sometimes emits cleanups without variables and we will
3431    have to deal with those too.  */
3432
3433 static void
3434 bc_expand_decl (decl, cleanup)
3435      tree decl;
3436      tree cleanup;
3437 {
3438   tree type;
3439
3440   if (!decl)
3441     {
3442       /* A cleanup with no variable.  */
3443       if (!cleanup)
3444         abort ();
3445
3446       return;
3447     }
3448
3449   /* Only auto variables need any work.  */
3450   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl) || DECL_EXTERNAL (decl))
3451     return;
3452
3453   type = TREE_TYPE (decl);
3454
3455   if (type == error_mark_node)
3456     DECL_RTL (decl) = bc_gen_rtx ((char *) 0, 0, (struct bc_label *) 0);
3457
3458   else if (DECL_SIZE (decl) == 0)
3459
3460     /* Variable with incomplete type.  The stack offset herein will be
3461        fixed later in expand_decl_init ().  */
3462     DECL_RTL (decl) = bc_gen_rtx ((char *) 0, 0, (struct bc_label *) 0);
3463
3464   else if (TREE_CONSTANT (DECL_SIZE (decl)))
3465     {
3466       DECL_RTL (decl) = bc_allocate_local (TREE_INT_CST_LOW (DECL_SIZE (decl)) / BITS_PER_UNIT,
3467                                            DECL_ALIGN (decl));
3468     }
3469   else
3470     DECL_RTL (decl) = bc_allocate_variable_array (DECL_SIZE (decl));
3471 }
3472 \f
3473 /* Emit code to perform the initialization of a declaration DECL.  */
3474
3475 void
3476 expand_decl_init (decl)
3477      tree decl;
3478 {
3479   int was_used = TREE_USED (decl);
3480
3481   if (output_bytecode)
3482     {
3483       bc_expand_decl_init (decl);
3484       return;
3485     }
3486
3487   /* If this is a CONST_DECL, we don't have to generate any code, but
3488      if DECL_INITIAL is a constant, call expand_expr to force TREE_CST_RTL
3489      to be set while in the obstack containing the constant.  If we don't
3490      do this, we can lose if we have functions nested three deep and the middle
3491      function makes a CONST_DECL whose DECL_INITIAL is a STRING_CST while
3492      the innermost function is the first to expand that STRING_CST.  */
3493   if (TREE_CODE (decl) == CONST_DECL)
3494     {
3495       if (DECL_INITIAL (decl) && TREE_CONSTANT (DECL_INITIAL (decl)))
3496         expand_expr (DECL_INITIAL (decl), NULL_RTX, VOIDmode,
3497                      EXPAND_INITIALIZER);
3498       return;
3499     }
3500
3501   if (TREE_STATIC (decl))
3502     return;
3503
3504   /* Compute and store the initial value now.  */
3505
3506   if (DECL_INITIAL (decl) == error_mark_node)
3507     {
3508       enum tree_code code = TREE_CODE (TREE_TYPE (decl));
3509       if (code == INTEGER_TYPE || code == REAL_TYPE || code == ENUMERAL_TYPE
3510           || code == POINTER_TYPE)
3511         expand_assignment (decl, convert (TREE_TYPE (decl), integer_zero_node),
3512                            0, 0);
3513       emit_queue ();
3514     }
3515   else if (DECL_INITIAL (decl) && TREE_CODE (DECL_INITIAL (decl)) != TREE_LIST)
3516     {
3517       emit_line_note (DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3518       expand_assignment (decl, DECL_INITIAL (decl), 0, 0);
3519       emit_queue ();
3520     }
3521
3522   /* Don't let the initialization count as "using" the variable.  */
3523   TREE_USED (decl) = was_used;
3524
3525   /* Free any temporaries we made while initializing the decl.  */
3526   free_temp_slots ();
3527 }
3528
3529 /* Expand initialization for variable-sized types. Allocate array
3530    using newlocalSI and set local variable, which is a pointer to the
3531    storage. */
3532
3533 static void
3534 bc_expand_variable_local_init (decl)
3535      tree decl;
3536 {
3537   /* Evaluate size expression and coerce to SI */
3538   bc_expand_expr (DECL_SIZE (decl));
3539
3540   /* Type sizes are always (?) of TREE_CODE INTEGER_CST, so
3541      no coercion is necessary (?) */
3542
3543 /*  emit_typecode_conversion (preferred_typecode (TYPE_MODE (DECL_SIZE (decl)),
3544                                                 TREE_UNSIGNED (DECL_SIZE (decl))), SIcode); */
3545
3546   /* Emit code to allocate array */
3547   bc_emit_instruction (newlocalSI);
3548
3549   /* Store array pointer in local variable. This is the only instance
3550      where we actually want the address of the pointer to the
3551      variable-size block, rather than the pointer itself.  We avoid
3552      using expand_address() since that would cause the pointer to be
3553      pushed rather than its address. Hence the hard-coded reference;
3554      notice also that the variable is always local (no global
3555      variable-size type variables). */
3556
3557   bc_load_localaddr (DECL_RTL (decl));
3558   bc_emit_instruction (storeP);
3559 }
3560
3561
3562 /* Emit code to initialize a declaration.  */
3563
3564 static void
3565 bc_expand_decl_init (decl)
3566      tree decl;
3567 {
3568   int org_stack_depth;
3569
3570   /* Statical initializers are handled elsewhere */
3571
3572   if (TREE_STATIC (decl))
3573     return;
3574
3575   /* Memory original stack depth */
3576   org_stack_depth = stack_depth;
3577
3578   /* If the type is variable-size, we first create its space (we ASSUME
3579      it CAN'T be static).  We do this regardless of whether there's an
3580      initializer assignment or not. */
3581
3582   if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
3583     bc_expand_variable_local_init (decl);
3584
3585   /* Expand initializer assignment */
3586   if (DECL_INITIAL (decl) == error_mark_node)
3587     {
3588       enum tree_code code = TREE_CODE (TREE_TYPE (decl));
3589
3590       if (code == INTEGER_TYPE || code == REAL_TYPE || code == ENUMERAL_TYPE
3591           || code == POINTER_TYPE)
3592
3593         expand_assignment (TREE_TYPE (decl), decl, 0, 0);
3594     }
3595   else if (DECL_INITIAL (decl))
3596     expand_assignment (TREE_TYPE (decl), decl, 0, 0);
3597
3598   /* Restore stack depth */
3599   if (org_stack_depth > stack_depth)
3600     abort ();
3601
3602   bc_adjust_stack (stack_depth - org_stack_depth);
3603 }
3604
3605
3606 /* CLEANUP is an expression to be executed at exit from this binding contour;
3607    for example, in C++, it might call the destructor for this variable.
3608
3609    If CLEANUP contains any SAVE_EXPRs, then you must preevaluate them
3610    either before or after calling `expand_decl' but before compiling
3611    any subsequent expressions.  This is because CLEANUP may be expanded
3612    more than once, on different branches of execution.
3613    For the same reason, CLEANUP may not contain a CALL_EXPR
3614    except as its topmost node--else `preexpand_calls' would get confused.
3615
3616    If CLEANUP is nonzero and DECL is zero, we record a cleanup
3617    that is not associated with any particular variable.   */
3618
3619 int
3620 expand_decl_cleanup (decl, cleanup)
3621      tree decl, cleanup;
3622 {
3623   struct nesting *thisblock = block_stack;
3624
3625   /* Error if we are not in any block.  */
3626   if (thisblock == 0)
3627     return 0;
3628
3629   /* Record the cleanup if there is one.  */
3630
3631   if (cleanup != 0)
3632     {
3633       thisblock->data.block.cleanups
3634         = temp_tree_cons (decl, cleanup, thisblock->data.block.cleanups);
3635       /* If this block has a cleanup, it belongs in stack_block_stack.  */
3636       stack_block_stack = thisblock;
3637       (*interim_eh_hook) (NULL_TREE);
3638     }
3639   return 1;
3640 }
3641 \f
3642 /* DECL is an anonymous union.  CLEANUP is a cleanup for DECL.
3643    DECL_ELTS is the list of elements that belong to DECL's type.
3644    In each, the TREE_VALUE is a VAR_DECL, and the TREE_PURPOSE a cleanup.  */
3645
3646 void
3647 expand_anon_union_decl (decl, cleanup, decl_elts)
3648      tree decl, cleanup, decl_elts;
3649 {
3650   struct nesting *thisblock = block_stack;
3651   rtx x;
3652
3653   expand_decl (decl, cleanup);
3654   x = DECL_RTL (decl);
3655
3656   while (decl_elts)
3657     {
3658       tree decl_elt = TREE_VALUE (decl_elts);
3659       tree cleanup_elt = TREE_PURPOSE (decl_elts);
3660       enum machine_mode mode = TYPE_MODE (TREE_TYPE (decl_elt));
3661
3662       /* Propagate the union's alignment to the elements.  */
3663       DECL_ALIGN (decl_elt) = DECL_ALIGN (decl);
3664
3665       /* If the element has BLKmode and the union doesn't, the union is
3666          aligned such that the element doesn't need to have BLKmode, so
3667          change the element's mode to the appropriate one for its size.  */
3668       if (mode == BLKmode && DECL_MODE (decl) != BLKmode)
3669         DECL_MODE (decl_elt) = mode
3670           = mode_for_size (TREE_INT_CST_LOW (DECL_SIZE (decl_elt)),
3671                            MODE_INT, 1);
3672
3673       /* (SUBREG (MEM ...)) at RTL generation time is invalid, so we
3674          instead create a new MEM rtx with the proper mode.  */
3675       if (GET_CODE (x) == MEM)
3676         {
3677           if (mode == GET_MODE (x))
3678             DECL_RTL (decl_elt) = x;
3679           else
3680             {
3681               DECL_RTL (decl_elt) = gen_rtx (MEM, mode, copy_rtx (XEXP (x, 0)));
3682               MEM_IN_STRUCT_P (DECL_RTL (decl_elt)) = MEM_IN_STRUCT_P (x);
3683               RTX_UNCHANGING_P (DECL_RTL (decl_elt)) = RTX_UNCHANGING_P (x);
3684             }
3685         }
3686       else if (GET_CODE (x) == REG)
3687         {
3688           if (mode == GET_MODE (x))
3689             DECL_RTL (decl_elt) = x;
3690           else
3691             DECL_RTL (decl_elt) = gen_rtx (SUBREG, mode, x, 0);
3692         }
3693       else
3694         abort ();
3695
3696       /* Record the cleanup if there is one.  */
3697
3698       if (cleanup != 0)
3699         thisblock->data.block.cleanups
3700           = temp_tree_cons (decl_elt, cleanup_elt,
3701                             thisblock->data.block.cleanups);
3702
3703       decl_elts = TREE_CHAIN (decl_elts);
3704     }
3705 }
3706 \f
3707 /* Expand a list of cleanups LIST.
3708    Elements may be expressions or may be nested lists.
3709
3710    If DONT_DO is nonnull, then any list-element
3711    whose TREE_PURPOSE matches DONT_DO is omitted.
3712    This is sometimes used to avoid a cleanup associated with
3713    a value that is being returned out of the scope.
3714
3715    If IN_FIXUP is non-zero, we are generating this cleanup for a fixup
3716    goto and handle protection regions specially in that case.
3717
3718    If REACHABLE, we emit code, otherwise just inform the exception handling
3719    code about this finalization.  */
3720
3721 static void
3722 expand_cleanups (list, dont_do, in_fixup, reachable)
3723      tree list;
3724      tree dont_do;
3725      int in_fixup;
3726      int reachable;
3727 {
3728   tree tail;
3729   for (tail = list; tail; tail = TREE_CHAIN (tail))
3730     if (dont_do == 0 || TREE_PURPOSE (tail) != dont_do)
3731       {
3732         if (TREE_CODE (TREE_VALUE (tail)) == TREE_LIST)
3733           expand_cleanups (TREE_VALUE (tail), dont_do, in_fixup, reachable);
3734         else
3735           {
3736             if (! in_fixup)
3737               (*interim_eh_hook) (TREE_VALUE (tail));
3738
3739             if (reachable)
3740               {
3741                 /* Cleanups may be run multiple times.  For example,
3742                    when exiting a binding contour, we expand the
3743                    cleanups associated with that contour.  When a goto
3744                    within that binding contour has a target outside that
3745                    contour, it will expand all cleanups from its scope to
3746                    the target.  Though the cleanups are expanded multiple
3747                    times, the control paths are non-overlapping so the
3748                    cleanups will not be executed twice.  */
3749                 expand_expr (TREE_VALUE (tail), const0_rtx, VOIDmode, 0);
3750                 free_temp_slots ();
3751               }
3752           }
3753       }
3754 }
3755
3756 /* Move all cleanups from the current block_stack
3757    to the containing block_stack, where they are assumed to
3758    have been created.  If anything can cause a temporary to
3759    be created, but not expanded for more than one level of
3760    block_stacks, then this code will have to change.  */
3761
3762 void
3763 move_cleanups_up ()
3764 {
3765   struct nesting *block = block_stack;
3766   struct nesting *outer = block->next;
3767
3768   outer->data.block.cleanups
3769     = chainon (block->data.block.cleanups,
3770                outer->data.block.cleanups);
3771   block->data.block.cleanups = 0;
3772 }
3773
3774 tree
3775 last_cleanup_this_contour ()
3776 {
3777   if (block_stack == 0)
3778     return 0;
3779
3780   return block_stack->data.block.cleanups;
3781 }
3782
3783 /* Return 1 if there are any pending cleanups at this point.
3784    If THIS_CONTOUR is nonzero, check the current contour as well.
3785    Otherwise, look only at the contours that enclose this one.  */
3786
3787 int
3788 any_pending_cleanups (this_contour)
3789      int this_contour;
3790 {
3791   struct nesting *block;
3792
3793   if (block_stack == 0)
3794     return 0;
3795
3796   if (this_contour && block_stack->data.block.cleanups != NULL)
3797     return 1;
3798   if (block_stack->data.block.cleanups == 0
3799       && (block_stack->data.block.outer_cleanups == 0
3800 #if 0
3801           || block_stack->data.block.outer_cleanups == empty_cleanup_list
3802 #endif
3803           ))
3804     return 0;
3805
3806   for (block = block_stack->next; block; block = block->next)
3807     if (block->data.block.cleanups != 0)
3808       return 1;
3809
3810   return 0;
3811 }
3812 \f
3813 /* Enter a case (Pascal) or switch (C) statement.
3814    Push a block onto case_stack and nesting_stack
3815    to accumulate the case-labels that are seen
3816    and to record the labels generated for the statement.
3817
3818    EXIT_FLAG is nonzero if `exit_something' should exit this case stmt.
3819    Otherwise, this construct is transparent for `exit_something'.
3820
3821    EXPR is the index-expression to be dispatched on.
3822    TYPE is its nominal type.  We could simply convert EXPR to this type,
3823    but instead we take short cuts.  */
3824
3825 void
3826 expand_start_case (exit_flag, expr, type, printname)
3827      int exit_flag;
3828      tree expr;
3829      tree type;
3830      char *printname;
3831 {
3832   register struct nesting *thiscase = ALLOC_NESTING ();
3833
3834   /* Make an entry on case_stack for the case we are entering.  */
3835
3836   thiscase->next = case_stack;
3837   thiscase->all = nesting_stack;
3838   thiscase->depth = ++nesting_depth;
3839   thiscase->exit_label = exit_flag ? gen_label_rtx () : 0;
3840   thiscase->data.case_stmt.case_list = 0;
3841   thiscase->data.case_stmt.index_expr = expr;
3842   thiscase->data.case_stmt.nominal_type = type;
3843   thiscase->data.case_stmt.default_label = 0;
3844   thiscase->data.case_stmt.num_ranges = 0;
3845   thiscase->data.case_stmt.printname = printname;
3846   thiscase->data.case_stmt.seenlabel = 0;
3847   case_stack = thiscase;
3848   nesting_stack = thiscase;
3849
3850   if (output_bytecode)
3851     {
3852       bc_expand_start_case (thiscase, expr, type, printname);
3853       return;
3854     }
3855
3856   do_pending_stack_adjust ();
3857
3858   /* Make sure case_stmt.start points to something that won't
3859      need any transformation before expand_end_case.  */
3860   if (GET_CODE (get_last_insn ()) != NOTE)
3861     emit_note (NULL_PTR, NOTE_INSN_DELETED);
3862
3863   thiscase->data.case_stmt.start = get_last_insn ();
3864 }
3865
3866
3867 /* Enter a case statement. It is assumed that the caller has pushed
3868    the current context onto the case stack. */
3869
3870 static void
3871 bc_expand_start_case (thiscase, expr, type, printname)
3872      struct nesting *thiscase;
3873      tree expr;
3874      tree type;
3875      char *printname;
3876 {
3877   bc_expand_expr (expr);
3878   bc_expand_conversion (TREE_TYPE (expr), type);
3879
3880   /* For cases, the skip is a place we jump to that's emitted after
3881      the size of the jump table is known.  */
3882
3883   thiscase->data.case_stmt.skip_label = gen_label_rtx ();
3884   bc_emit_bytecode (jump);
3885   bc_emit_bytecode_labelref (BYTECODE_BC_LABEL (thiscase->data.case_stmt.skip_label));
3886
3887 #ifdef DEBUG_PRINT_CODE
3888   fputc ('\n', stderr);
3889 #endif
3890 }
3891
3892
3893 /* Start a "dummy case statement" within which case labels are invalid
3894    and are not connected to any larger real case statement.
3895    This can be used if you don't want to let a case statement jump
3896    into the middle of certain kinds of constructs.  */
3897
3898 void
3899 expand_start_case_dummy ()
3900 {
3901   register struct nesting *thiscase = ALLOC_NESTING ();
3902
3903   /* Make an entry on case_stack for the dummy.  */
3904
3905   thiscase->next = case_stack;
3906   thiscase->all = nesting_stack;
3907   thiscase->depth = ++nesting_depth;
3908   thiscase->exit_label = 0;
3909   thiscase->data.case_stmt.case_list = 0;
3910   thiscase->data.case_stmt.start = 0;
3911   thiscase->data.case_stmt.nominal_type = 0;
3912   thiscase->data.case_stmt.default_label = 0;
3913   thiscase->data.case_stmt.num_ranges = 0;
3914   case_stack = thiscase;
3915   nesting_stack = thiscase;
3916 }
3917
3918 /* End a dummy case statement.  */
3919
3920 void
3921 expand_end_case_dummy ()
3922 {
3923   POPSTACK (case_stack);
3924 }
3925
3926 /* Return the data type of the index-expression
3927    of the innermost case statement, or null if none.  */
3928
3929 tree
3930 case_index_expr_type ()
3931 {
3932   if (case_stack)
3933     return TREE_TYPE (case_stack->data.case_stmt.index_expr);
3934   return 0;
3935 }
3936 \f
3937 /* Accumulate one case or default label inside a case or switch statement.
3938    VALUE is the value of the case (a null pointer, for a default label).
3939    The function CONVERTER, when applied to arguments T and V,
3940    converts the value V to the type T.
3941
3942    If not currently inside a case or switch statement, return 1 and do
3943    nothing.  The caller will print a language-specific error message.
3944    If VALUE is a duplicate or overlaps, return 2 and do nothing
3945    except store the (first) duplicate node in *DUPLICATE.
3946    If VALUE is out of range, return 3 and do nothing.
3947    If we are jumping into the scope of a cleaup or var-sized array, return 5.
3948    Return 0 on success.
3949
3950    Extended to handle range statements.  */
3951
3952 int
3953 pushcase (value, converter, label, duplicate)
3954      register tree value;
3955      tree (*converter) PROTO((tree, tree));
3956      register tree label;
3957      tree *duplicate;
3958 {
3959   register struct case_node **l;
3960   register struct case_node *n;
3961   tree index_type;
3962   tree nominal_type;
3963
3964   if (output_bytecode)
3965     return bc_pushcase (value, label);
3966
3967   /* Fail if not inside a real case statement.  */
3968   if (! (case_stack && case_stack->data.case_stmt.start))
3969     return 1;
3970
3971   if (stack_block_stack
3972       && stack_block_stack->depth > case_stack->depth)
3973     return 5;
3974
3975   index_type = TREE_TYPE (case_stack->data.case_stmt.index_expr);
3976   nominal_type = case_stack->data.case_stmt.nominal_type;
3977
3978   /* If the index is erroneous, avoid more problems: pretend to succeed.  */
3979   if (index_type == error_mark_node)
3980     return 0;
3981
3982   /* Convert VALUE to the type in which the comparisons are nominally done.  */
3983   if (value != 0)
3984     value = (*converter) (nominal_type, value);
3985
3986   /* If this is the first label, warn if any insns have been emitted.  */
3987   if (case_stack->data.case_stmt.seenlabel == 0)
3988     {
3989       rtx insn;
3990       for (insn = case_stack->data.case_stmt.start;
3991            insn;
3992            insn = NEXT_INSN (insn))
3993         {
3994           if (GET_CODE (insn) == CODE_LABEL)
3995             break;
3996           if (GET_CODE (insn) != NOTE
3997               && (GET_CODE (insn) != INSN || GET_CODE (PATTERN (insn)) != USE))
3998             {
3999               warning ("unreachable code at beginning of %s",
4000                        case_stack->data.case_stmt.printname);
4001               break;
4002             }
4003         }
4004     }
4005   case_stack->data.case_stmt.seenlabel = 1;
4006
4007   /* Fail if this value is out of range for the actual type of the index
4008      (which may be narrower than NOMINAL_TYPE).  */
4009   if (value != 0 && ! int_fits_type_p (value, index_type))
4010     return 3;
4011
4012   /* Fail if this is a duplicate or overlaps another entry.  */
4013   if (value == 0)
4014     {
4015       if (case_stack->data.case_stmt.default_label != 0)
4016         {
4017           *duplicate = case_stack->data.case_stmt.default_label;
4018           return 2;
4019         }
4020       case_stack->data.case_stmt.default_label = label;
4021     }
4022   else
4023     {
4024       /* Find the elt in the chain before which to insert the new value,
4025          to keep the chain sorted in increasing order.
4026          But report an error if this element is a duplicate.  */
4027       for (l = &case_stack->data.case_stmt.case_list;
4028            /* Keep going past elements distinctly less than VALUE.  */
4029            *l != 0 && tree_int_cst_lt ((*l)->high, value);
4030            l = &(*l)->right)
4031         ;
4032       if (*l)
4033         {
4034           /* Element we will insert before must be distinctly greater;
4035              overlap means error.  */
4036           if (! tree_int_cst_lt (value, (*l)->low))
4037             {
4038               *duplicate = (*l)->code_label;
4039               return 2;
4040             }
4041         }
4042
4043       /* Add this label to the chain, and succeed.
4044          Copy VALUE so it is on temporary rather than momentary
4045          obstack and will thus survive till the end of the case statement.  */
4046       n = (struct case_node *) oballoc (sizeof (struct case_node));
4047       n->left = 0;
4048       n->right = *l;
4049       n->high = n->low = copy_node (value);
4050       n->code_label = label;
4051       *l = n;
4052     }
4053
4054   expand_label (label);
4055   return 0;
4056 }
4057
4058 /* Like pushcase but this case applies to all values
4059    between VALUE1 and VALUE2 (inclusive).
4060    The return value is the same as that of pushcase
4061    but there is one additional error code:
4062    4 means the specified range was empty.  */
4063
4064 int
4065 pushcase_range (value1, value2, converter, label, duplicate)
4066      register tree value1, value2;
4067      tree (*converter) PROTO((tree, tree));
4068      register tree label;
4069      tree *duplicate;
4070 {
4071   register struct case_node **l;
4072   register struct case_node *n;
4073   tree index_type;
4074   tree nominal_type;
4075
4076   /* Fail if not inside a real case statement.  */
4077   if (! (case_stack && case_stack->data.case_stmt.start))
4078     return 1;
4079
4080   if (stack_block_stack
4081       && stack_block_stack->depth > case_stack->depth)
4082     return 5;
4083
4084   index_type = TREE_TYPE (case_stack->data.case_stmt.index_expr);
4085   nominal_type = case_stack->data.case_stmt.nominal_type;
4086
4087   /* If the index is erroneous, avoid more problems: pretend to succeed.  */
4088   if (index_type == error_mark_node)
4089     return 0;
4090
4091   /* If this is the first label, warn if any insns have been emitted.  */
4092   if (case_stack->data.case_stmt.seenlabel == 0)
4093     {
4094       rtx insn;
4095       for (insn = case_stack->data.case_stmt.start;
4096            insn;
4097            insn = NEXT_INSN (insn))
4098         {
4099           if (GET_CODE (insn) == CODE_LABEL)
4100             break;
4101           if (GET_CODE (insn) != NOTE
4102               && (GET_CODE (insn) != INSN || GET_CODE (PATTERN (insn)) != USE))
4103             {
4104               warning ("unreachable code at beginning of %s",
4105                        case_stack->data.case_stmt.printname);
4106               break;
4107             }
4108         }
4109     }
4110   case_stack->data.case_stmt.seenlabel = 1;
4111
4112   /* Convert VALUEs to type in which the comparisons are nominally done.  */
4113   if (value1 == 0)  /* Negative infinity. */
4114     value1 = TYPE_MIN_VALUE(index_type);
4115   value1 = (*converter) (nominal_type, value1);
4116
4117   if (value2 == 0)  /* Positive infinity. */
4118     value2 = TYPE_MAX_VALUE(index_type);
4119   value2 = (*converter) (nominal_type, value2);
4120
4121   /* Fail if these values are out of range.  */
4122   if (! int_fits_type_p (value1, index_type))
4123     return 3;
4124
4125   if (! int_fits_type_p (value2, index_type))
4126     return 3;
4127
4128   /* Fail if the range is empty.  */
4129   if (tree_int_cst_lt (value2, value1))
4130     return 4;
4131
4132   /* If the bounds are equal, turn this into the one-value case.  */
4133   if (tree_int_cst_equal (value1, value2))
4134     return pushcase (value1, converter, label, duplicate);
4135
4136   /* Find the elt in the chain before which to insert the new value,
4137      to keep the chain sorted in increasing order.
4138      But report an error if this element is a duplicate.  */
4139   for (l = &case_stack->data.case_stmt.case_list;
4140        /* Keep going past elements distinctly less than this range.  */
4141        *l != 0 && tree_int_cst_lt ((*l)->high, value1);
4142        l = &(*l)->right)
4143     ;
4144   if (*l)
4145     {
4146       /* Element we will insert before must be distinctly greater;
4147          overlap means error.  */
4148       if (! tree_int_cst_lt (value2, (*l)->low))
4149         {
4150           *duplicate = (*l)->code_label;
4151           return 2;
4152         }
4153     }
4154
4155   /* Add this label to the chain, and succeed.
4156      Copy VALUE1, VALUE2 so they are on temporary rather than momentary
4157      obstack and will thus survive till the end of the case statement.  */
4158
4159   n = (struct case_node *) oballoc (sizeof (struct case_node));
4160   n->left = 0;
4161   n->right = *l;
4162   n->low = copy_node (value1);
4163   n->high = copy_node (value2);
4164   n->code_label = label;
4165   *l = n;
4166
4167   expand_label (label);
4168
4169   case_stack->data.case_stmt.num_ranges++;
4170
4171   return 0;
4172 }
4173
4174
4175 /* Accumulate one case or default label; VALUE is the value of the
4176    case, or nil for a default label.  If not currently inside a case,
4177    return 1 and do nothing.  If VALUE is a duplicate or overlaps, return
4178    2 and do nothing.  If VALUE is out of range, return 3 and do nothing.
4179    Return 0 on success.  This function is a leftover from the earlier
4180    bytecode compiler, which was based on gcc 1.37.  It should be
4181    merged into pushcase. */
4182
4183 static int
4184 bc_pushcase (value, label)
4185      tree value;
4186      tree label;
4187 {
4188   struct nesting *thiscase = case_stack;
4189   struct case_node *case_label, *new_label;
4190
4191   if (! thiscase)
4192     return 1;
4193
4194   /* Fail if duplicate, overlap, or out of type range.  */
4195   if (value)
4196     {
4197       value = convert (thiscase->data.case_stmt.nominal_type, value);
4198       if (! int_fits_type_p (value, thiscase->data.case_stmt.nominal_type))
4199         return 3;
4200
4201       for (case_label = thiscase->data.case_stmt.case_list;
4202            case_label->left; case_label = case_label->left)
4203         if (! tree_int_cst_lt (case_label->left->high, value))
4204           break;
4205
4206       if (case_label != thiscase->data.case_stmt.case_list
4207           && ! tree_int_cst_lt (case_label->high, value)
4208           || case_label->left && ! tree_int_cst_lt (value, case_label->left->low))
4209         return 2;
4210
4211       new_label = (struct case_node *) oballoc (sizeof (struct case_node));
4212       new_label->low = new_label->high = copy_node (value);
4213       new_label->code_label = label;
4214       new_label->left = case_label->left;
4215
4216       case_label->left = new_label;
4217       thiscase->data.case_stmt.num_ranges++;
4218     }
4219   else
4220     {
4221       if (thiscase->data.case_stmt.default_label)
4222         return 2;
4223       thiscase->data.case_stmt.default_label = label;
4224     }
4225
4226   expand_label (label);
4227   return 0;
4228 }
4229 \f
4230 /* Returns the number of possible values of TYPE.
4231    Returns -1 if the number is unknown or variable.
4232    Returns -2 if the number does not fit in a HOST_WIDE_INT.
4233    Sets *SPARENESS to 2 if TYPE is an ENUMERAL_TYPE whose values
4234    do not increase monotonically (there may be duplicates);
4235    to 1 if the values increase monotonically, but not always by 1;
4236    otherwise sets it to 0.  */
4237
4238 HOST_WIDE_INT
4239 all_cases_count (type, spareness)
4240      tree type;
4241      int *spareness;
4242 {
4243   HOST_WIDE_INT count, count_high = 0;
4244   *spareness = 0;
4245
4246   switch (TREE_CODE (type))
4247     {
4248       tree t;
4249     case BOOLEAN_TYPE:
4250       count = 2;
4251       break;
4252     case CHAR_TYPE:
4253       count = 1 << BITS_PER_UNIT;
4254       break;
4255     default:
4256     case INTEGER_TYPE:
4257       if (TREE_CODE (TYPE_MIN_VALUE (type)) != INTEGER_CST
4258           || TREE_CODE (TYPE_MIN_VALUE (type)) != INTEGER_CST)
4259         return -1;
4260       else
4261         {
4262           /* count
4263              = TREE_INT_CST_LOW (TYPE_MAX_VALUE (type))
4264              - TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)) + 1
4265              but with overflow checking. */
4266           tree mint = TYPE_MIN_VALUE (type);
4267           tree maxt = TYPE_MAX_VALUE (type);
4268           HOST_WIDE_INT lo, hi;
4269           neg_double(TREE_INT_CST_LOW (mint), TREE_INT_CST_HIGH (mint),
4270                      &lo, &hi);
4271           add_double(TREE_INT_CST_LOW (maxt), TREE_INT_CST_HIGH (maxt),
4272                      lo, hi, &lo, &hi);
4273           add_double (lo, hi, 1, 0, &lo, &hi);
4274           if (hi != 0 || lo < 0)
4275             return -2;
4276           count = lo;
4277         }
4278       break;
4279     case ENUMERAL_TYPE:
4280       count = 0;
4281       for (t = TYPE_VALUES (type); t != NULL_TREE; t = TREE_CHAIN (t))
4282         {
4283           if (TREE_CODE (TYPE_MIN_VALUE (type)) != INTEGER_CST
4284               || TREE_CODE (TREE_VALUE (t)) != INTEGER_CST
4285               || TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)) + count
4286               != TREE_INT_CST_LOW (TREE_VALUE (t)))
4287             *spareness = 1;
4288           count++;
4289         }
4290       if (*spareness == 1)
4291         {
4292           tree prev = TREE_VALUE (TYPE_VALUES (type));
4293           for (t = TYPE_VALUES (type); t = TREE_CHAIN (t), t != NULL_TREE; )
4294             {
4295               if (! tree_int_cst_lt (prev, TREE_VALUE (t)))
4296                 {
4297                   *spareness = 2;
4298                   break;
4299                 }
4300               prev = TREE_VALUE (t);
4301             }
4302
4303         }
4304     }
4305   return count;
4306 }
4307
4308
4309 #define BITARRAY_TEST(ARRAY, INDEX) \
4310   ((ARRAY)[(unsigned)(INDEX) / HOST_BITS_PER_CHAR]\
4311                           & (1 << ((unsigned)(INDEX) % HOST_BITS_PER_CHAR)))
4312 #define BITARRAY_SET(ARRAY, INDEX) \
4313   ((ARRAY)[(unsigned)(INDEX) / HOST_BITS_PER_CHAR]\
4314                           |= 1 << ((unsigned)(INDEX) % HOST_BITS_PER_CHAR))
4315
4316 /* Set the elements of the bitstring CASES_SEEN (which has length COUNT),
4317    with the case values we have seen, assuming the case expression
4318    has the given TYPE.
4319    SPARSENESS is as determined by all_cases_count.
4320
4321    The time needed is propotional to COUNT, unless
4322    SPARSENESS is 2, in which case quadratic time is needed.  */
4323
4324 void
4325 mark_seen_cases (type, cases_seen, count, sparseness)
4326      tree type;
4327      unsigned char *cases_seen;
4328      long count;
4329      int sparseness;
4330 {
4331   long i;
4332
4333   tree next_node_to_try = NULL_TREE;
4334   long next_node_offset = 0;
4335
4336   register struct case_node *n;
4337   tree val = make_node (INTEGER_CST);
4338   TREE_TYPE (val) = type;
4339   for (n = case_stack->data.case_stmt.case_list; n;
4340        n = n->right)
4341     {
4342       TREE_INT_CST_LOW (val) = TREE_INT_CST_LOW (n->low);
4343       TREE_INT_CST_HIGH (val) = TREE_INT_CST_HIGH (n->low);
4344       while ( ! tree_int_cst_lt (n->high, val))
4345         {
4346           /* Calculate (into xlo) the "offset" of the integer (val).
4347              The element with lowest value has offset 0, the next smallest
4348              element has offset 1, etc.  */
4349
4350           HOST_WIDE_INT xlo, xhi;
4351           tree t;
4352           if (sparseness == 2)
4353             {
4354               /* This less efficient loop is only needed to handle
4355                  duplicate case values (multiple enum constants
4356                  with the same value).  */
4357               for (t = TYPE_VALUES (type), xlo = 0;  t != NULL_TREE;
4358                    t = TREE_CHAIN (t), xlo++)
4359                 {
4360                   if (tree_int_cst_equal (val, TREE_VALUE (t)))
4361                     BITARRAY_SET (cases_seen, xlo);
4362                 }
4363             }
4364           else
4365             {
4366               if (sparseness && TYPE_VALUES (type) != NULL_TREE)
4367                 {
4368                   /* The TYPE_VALUES will be in increasing order, so
4369                      starting searching where we last ended.  */
4370                   t = next_node_to_try;
4371                   xlo = next_node_offset;
4372                   xhi = 0;
4373                   for (;;)
4374                     {
4375                       if (t == NULL_TREE)
4376                         {
4377                           t = TYPE_VALUES (type);
4378                           xlo = 0;
4379                         }
4380                       if (tree_int_cst_equal (val, TREE_VALUE (t)))
4381                         {
4382                           next_node_to_try = TREE_CHAIN (t);
4383                           next_node_offset = xlo + 1;
4384                           break;
4385                         }
4386                       xlo++;
4387                       t = TREE_CHAIN (t);
4388                       if (t == next_node_to_try)
4389                         break;
4390                     }
4391                 }
4392               else
4393                 {
4394                   t = TYPE_MIN_VALUE (type);
4395                   if (t)
4396                     neg_double (TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t),
4397                                 &xlo, &xhi);
4398                   else
4399                     xlo = xhi = 0;
4400                   add_double (xlo, xhi,
4401                               TREE_INT_CST_LOW (val), TREE_INT_CST_HIGH (val),
4402                               &xlo, &xhi);
4403                 }
4404
4405               if (xhi == 0 && xlo >= 0 && xlo < count)
4406                 BITARRAY_SET (cases_seen, xlo);
4407             }
4408           add_double (TREE_INT_CST_LOW (val), TREE_INT_CST_HIGH (val),
4409                       1, 0,
4410                       &TREE_INT_CST_LOW (val), &TREE_INT_CST_HIGH (val));
4411         }
4412     }
4413 }
4414
4415 /* Called when the index of a switch statement is an enumerated type
4416    and there is no default label.
4417
4418    Checks that all enumeration literals are covered by the case
4419    expressions of a switch.  Also, warn if there are any extra
4420    switch cases that are *not* elements of the enumerated type.
4421
4422    If all enumeration literals were covered by the case expressions,
4423    turn one of the expressions into the default expression since it should
4424    not be possible to fall through such a switch.  */
4425
4426 void
4427 check_for_full_enumeration_handling (type)
4428      tree type;
4429 {
4430   register struct case_node *n;
4431   register struct case_node **l;
4432   register tree chain;
4433   int all_values = 1;
4434
4435   /* True iff the selector type is a numbered set mode. */
4436   int sparseness = 0;
4437
4438   /* The number of possible selector values. */
4439   HOST_WIDE_INT size;
4440
4441   /* For each possible selector value. a one iff it has been matched
4442      by a case value alternative. */
4443   unsigned char *cases_seen;
4444
4445   /* The allocated size of cases_seen, in chars. */
4446   long bytes_needed;
4447   tree t;
4448
4449   if (output_bytecode)
4450     {
4451       bc_check_for_full_enumeration_handling (type);
4452       return;
4453     }
4454
4455   if (! warn_switch)
4456     return;
4457
4458   size = all_cases_count (type, &sparseness);
4459   bytes_needed = (size + HOST_BITS_PER_CHAR) / HOST_BITS_PER_CHAR;
4460
4461   if (size > 0 && size < 600000
4462       /* We deliberately use malloc here - not xmalloc. */
4463       && (cases_seen = (unsigned char *) malloc (bytes_needed)) != NULL)
4464     {
4465       long i;
4466       tree v = TYPE_VALUES (type);
4467       bzero (cases_seen, bytes_needed);
4468
4469       /* The time complexity of this code is normally O(N), where
4470          N being the number of members in the enumerated type.
4471          However, if type is a ENUMERAL_TYPE whose values do not
4472          increase monotonically, quadratic time may be needed. */
4473
4474       mark_seen_cases (type, cases_seen, size, sparseness);
4475
4476       for (i = 0;  v != NULL_TREE && i < size; i++, v = TREE_CHAIN (v))
4477         {
4478           if (BITARRAY_TEST(cases_seen, i) == 0)
4479             warning ("enumeration value `%s' not handled in switch",
4480                      IDENTIFIER_POINTER (TREE_PURPOSE (v)));
4481         }
4482
4483       free (cases_seen);
4484     }
4485
4486   /* Now we go the other way around; we warn if there are case
4487      expressions that don't correspond to enumerators.  This can
4488      occur since C and C++ don't enforce type-checking of
4489      assignments to enumeration variables. */
4490
4491   if (warn_switch)
4492     for (n = case_stack->data.case_stmt.case_list; n; n = n->right)
4493       {
4494         for (chain = TYPE_VALUES (type);
4495              chain && !tree_int_cst_equal (n->low, TREE_VALUE (chain));
4496              chain = TREE_CHAIN (chain))
4497           ;
4498
4499         if (!chain)
4500           {
4501             if (TYPE_NAME (type) == 0)
4502               warning ("case value `%d' not in enumerated type",
4503                        TREE_INT_CST_LOW (n->low));
4504             else
4505               warning ("case value `%d' not in enumerated type `%s'",
4506                        TREE_INT_CST_LOW (n->low),
4507                        IDENTIFIER_POINTER ((TREE_CODE (TYPE_NAME (type))
4508                                             == IDENTIFIER_NODE)
4509                                            ? TYPE_NAME (type)
4510                                            : DECL_NAME (TYPE_NAME (type))));
4511           }
4512         if (!tree_int_cst_equal (n->low, n->high))
4513           {
4514             for (chain = TYPE_VALUES (type);
4515                  chain && !tree_int_cst_equal (n->high, TREE_VALUE (chain));
4516                  chain = TREE_CHAIN (chain))
4517               ;
4518
4519             if (!chain)
4520               {
4521                 if (TYPE_NAME (type) == 0)
4522                   warning ("case value `%d' not in enumerated type",
4523                            TREE_INT_CST_LOW (n->high));
4524                 else
4525                   warning ("case value `%d' not in enumerated type `%s'",
4526                            TREE_INT_CST_LOW (n->high),
4527                            IDENTIFIER_POINTER ((TREE_CODE (TYPE_NAME (type))
4528                                                 == IDENTIFIER_NODE)
4529                                                ? TYPE_NAME (type)
4530                                                : DECL_NAME (TYPE_NAME (type))));
4531               }
4532           }
4533       }
4534
4535 #if 0
4536   /* ??? This optimization is disabled because it causes valid programs to
4537      fail.  ANSI C does not guarantee that an expression with enum type
4538      will have a value that is the same as one of the enumation literals.  */
4539
4540   /* If all values were found as case labels, make one of them the default
4541      label.  Thus, this switch will never fall through.  We arbitrarily pick
4542      the last one to make the default since this is likely the most
4543      efficient choice.  */
4544
4545   if (all_values)
4546     {
4547       for (l = &case_stack->data.case_stmt.case_list;
4548            (*l)->right != 0;
4549            l = &(*l)->right)
4550         ;
4551
4552       case_stack->data.case_stmt.default_label = (*l)->code_label;
4553       *l = 0;
4554     }
4555 #endif /* 0 */
4556 }
4557
4558
4559 /* Check that all enumeration literals are covered by the case
4560    expressions of a switch.  Also warn if there are any cases
4561    that are not elements of the enumerated type.  */
4562
4563 static void
4564 bc_check_for_full_enumeration_handling (type)
4565      tree type;
4566 {
4567   struct nesting *thiscase = case_stack;
4568   struct case_node *c;
4569   tree e;
4570
4571   /* Check for enums not handled.  */
4572   for (e = TYPE_VALUES (type); e; e = TREE_CHAIN (e))
4573     {
4574       for (c = thiscase->data.case_stmt.case_list->left;
4575            c && tree_int_cst_lt (c->high, TREE_VALUE (e));
4576            c = c->left)
4577         ;
4578       if (! (c && tree_int_cst_equal (c->low, TREE_VALUE (e))))
4579         warning ("enumerated value `%s' not handled in switch",
4580                  IDENTIFIER_POINTER (TREE_PURPOSE (e)));
4581     }
4582
4583   /* Check for cases not in the enumeration.  */
4584   for (c = thiscase->data.case_stmt.case_list->left; c; c = c->left)
4585     {
4586       for (e = TYPE_VALUES (type);
4587            e && !tree_int_cst_equal (c->low, TREE_VALUE (e));
4588            e = TREE_CHAIN (e))
4589         ;
4590       if (! e)
4591         warning ("case value `%d' not in enumerated type `%s'",
4592                  TREE_INT_CST_LOW (c->low),
4593                  IDENTIFIER_POINTER (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
4594                                      ? TYPE_NAME (type)
4595                                      : DECL_NAME (TYPE_NAME (type))));
4596     }
4597 }
4598 \f
4599 /* Terminate a case (Pascal) or switch (C) statement
4600    in which ORIG_INDEX is the expression to be tested.
4601    Generate the code to test it and jump to the right place.  */
4602
4603 void
4604 expand_end_case (orig_index)
4605      tree orig_index;
4606 {
4607   tree minval, maxval, range, orig_minval;
4608   rtx default_label = 0;
4609   register struct case_node *n;
4610   int count;
4611   rtx index;
4612   rtx table_label;
4613   int ncases;
4614   rtx *labelvec;
4615   register int i;
4616   rtx before_case;
4617   register struct nesting *thiscase = case_stack;
4618   tree index_expr, index_type;
4619   int unsignedp;
4620
4621   if (output_bytecode)
4622     {
4623       bc_expand_end_case (orig_index);
4624       return;
4625     }
4626
4627   table_label = gen_label_rtx ();
4628   index_expr = thiscase->data.case_stmt.index_expr;
4629   index_type = TREE_TYPE (index_expr);
4630   unsignedp = TREE_UNSIGNED (index_type);
4631
4632   do_pending_stack_adjust ();
4633
4634   /* An ERROR_MARK occurs for various reasons including invalid data type.  */
4635   if (index_type != error_mark_node)
4636     {
4637       /* If switch expression was an enumerated type, check that all
4638          enumeration literals are covered by the cases.
4639          No sense trying this if there's a default case, however.  */
4640
4641       if (!thiscase->data.case_stmt.default_label
4642           && TREE_CODE (TREE_TYPE (orig_index)) == ENUMERAL_TYPE
4643           && TREE_CODE (index_expr) != INTEGER_CST)
4644         check_for_full_enumeration_handling (TREE_TYPE (orig_index));
4645
4646       /* If this is the first label, warn if any insns have been emitted.  */
4647       if (thiscase->data.case_stmt.seenlabel == 0)
4648         {
4649           rtx insn;
4650           for (insn = get_last_insn ();
4651                insn != case_stack->data.case_stmt.start;
4652                insn = PREV_INSN (insn))
4653             if (GET_CODE (insn) != NOTE
4654                 && (GET_CODE (insn) != INSN || GET_CODE (PATTERN (insn))!= USE))
4655               {
4656                 warning ("unreachable code at beginning of %s",
4657                          case_stack->data.case_stmt.printname);
4658                 break;
4659               }
4660         }
4661
4662       /* If we don't have a default-label, create one here,
4663          after the body of the switch.  */
4664       if (thiscase->data.case_stmt.default_label == 0)
4665         {
4666           thiscase->data.case_stmt.default_label
4667             = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
4668           expand_label (thiscase->data.case_stmt.default_label);
4669         }
4670       default_label = label_rtx (thiscase->data.case_stmt.default_label);
4671
4672       before_case = get_last_insn ();
4673
4674       /* Simplify the case-list before we count it.  */
4675       group_case_nodes (thiscase->data.case_stmt.case_list);
4676
4677       /* Get upper and lower bounds of case values.
4678          Also convert all the case values to the index expr's data type.  */
4679
4680       count = 0;
4681       for (n = thiscase->data.case_stmt.case_list; n; n = n->right)
4682         {
4683           /* Check low and high label values are integers.  */
4684           if (TREE_CODE (n->low) != INTEGER_CST)
4685             abort ();
4686           if (TREE_CODE (n->high) != INTEGER_CST)
4687             abort ();
4688
4689           n->low = convert (index_type, n->low);
4690           n->high = convert (index_type, n->high);
4691
4692           /* Count the elements and track the largest and smallest
4693              of them (treating them as signed even if they are not).  */
4694           if (count++ == 0)
4695             {
4696               minval = n->low;
4697               maxval = n->high;
4698             }
4699           else
4700             {
4701               if (INT_CST_LT (n->low, minval))
4702                 minval = n->low;
4703               if (INT_CST_LT (maxval, n->high))
4704                 maxval = n->high;
4705             }
4706           /* A range counts double, since it requires two compares.  */
4707           if (! tree_int_cst_equal (n->low, n->high))
4708             count++;
4709         }
4710
4711       orig_minval = minval;
4712
4713       /* Compute span of values.  */
4714       if (count != 0)
4715         range = fold (build (MINUS_EXPR, index_type, maxval, minval));
4716
4717       if (count == 0)
4718         {
4719           expand_expr (index_expr, const0_rtx, VOIDmode, 0);
4720           emit_queue ();
4721           emit_jump (default_label);
4722         }
4723
4724       /* If range of values is much bigger than number of values,
4725          make a sequence of conditional branches instead of a dispatch.
4726          If the switch-index is a constant, do it this way
4727          because we can optimize it.  */
4728
4729 #ifndef CASE_VALUES_THRESHOLD
4730 #ifdef HAVE_casesi
4731 #define CASE_VALUES_THRESHOLD (HAVE_casesi ? 4 : 5)
4732 #else
4733       /* If machine does not have a case insn that compares the
4734          bounds, this means extra overhead for dispatch tables
4735          which raises the threshold for using them.  */
4736 #define CASE_VALUES_THRESHOLD 5
4737 #endif /* HAVE_casesi */
4738 #endif /* CASE_VALUES_THRESHOLD */
4739
4740       else if (TREE_INT_CST_HIGH (range) != 0
4741                || count < CASE_VALUES_THRESHOLD
4742                || ((unsigned HOST_WIDE_INT) (TREE_INT_CST_LOW (range))
4743                    > 10 * count)
4744                || TREE_CODE (index_expr) == INTEGER_CST
4745                /* These will reduce to a constant.  */
4746                || (TREE_CODE (index_expr) == CALL_EXPR
4747                    && TREE_CODE (TREE_OPERAND (index_expr, 0)) == ADDR_EXPR
4748                    && TREE_CODE (TREE_OPERAND (TREE_OPERAND (index_expr, 0), 0)) == FUNCTION_DECL
4749                    && DECL_FUNCTION_CODE (TREE_OPERAND (TREE_OPERAND (index_expr, 0), 0)) == BUILT_IN_CLASSIFY_TYPE)
4750                || (TREE_CODE (index_expr) == COMPOUND_EXPR
4751                    && TREE_CODE (TREE_OPERAND (index_expr, 1)) == INTEGER_CST))
4752         {
4753           index = expand_expr (index_expr, NULL_RTX, VOIDmode, 0);
4754
4755           /* If the index is a short or char that we do not have
4756              an insn to handle comparisons directly, convert it to
4757              a full integer now, rather than letting each comparison
4758              generate the conversion.  */
4759
4760           if (GET_MODE_CLASS (GET_MODE (index)) == MODE_INT
4761               && (cmp_optab->handlers[(int) GET_MODE(index)].insn_code
4762                   == CODE_FOR_nothing))
4763             {
4764               enum machine_mode wider_mode;
4765               for (wider_mode = GET_MODE (index); wider_mode != VOIDmode;
4766                    wider_mode = GET_MODE_WIDER_MODE (wider_mode))
4767                 if (cmp_optab->handlers[(int) wider_mode].insn_code
4768                     != CODE_FOR_nothing)
4769                   {
4770                     index = convert_to_mode (wider_mode, index, unsignedp);
4771                     break;
4772                   }
4773             }
4774
4775           emit_queue ();
4776           do_pending_stack_adjust ();
4777
4778           index = protect_from_queue (index, 0);
4779           if (GET_CODE (index) == MEM)
4780             index = copy_to_reg (index);
4781           if (GET_CODE (index) == CONST_INT
4782               || TREE_CODE (index_expr) == INTEGER_CST)
4783             {
4784               /* Make a tree node with the proper constant value
4785                  if we don't already have one.  */
4786               if (TREE_CODE (index_expr) != INTEGER_CST)
4787                 {
4788                   index_expr
4789                     = build_int_2 (INTVAL (index),
4790                                    unsignedp || INTVAL (index) >= 0 ? 0 : -1);
4791                   index_expr = convert (index_type, index_expr);
4792                 }
4793
4794               /* For constant index expressions we need only
4795                  issue a unconditional branch to the appropriate
4796                  target code.  The job of removing any unreachable
4797                  code is left to the optimisation phase if the
4798                  "-O" option is specified.  */
4799               for (n = thiscase->data.case_stmt.case_list; n; n = n->right)
4800                 if (! tree_int_cst_lt (index_expr, n->low)
4801                     && ! tree_int_cst_lt (n->high, index_expr))
4802                   break;
4803
4804               if (n)
4805                 emit_jump (label_rtx (n->code_label));
4806               else
4807                 emit_jump (default_label);
4808             }
4809           else
4810             {
4811               /* If the index expression is not constant we generate
4812                  a binary decision tree to select the appropriate
4813                  target code.  This is done as follows:
4814
4815                  The list of cases is rearranged into a binary tree,
4816                  nearly optimal assuming equal probability for each case.
4817
4818                  The tree is transformed into RTL, eliminating
4819                  redundant test conditions at the same time.
4820
4821                  If program flow could reach the end of the
4822                  decision tree an unconditional jump to the
4823                  default code is emitted.  */
4824
4825               use_cost_table
4826                 = (TREE_CODE (TREE_TYPE (orig_index)) != ENUMERAL_TYPE
4827                    && estimate_case_costs (thiscase->data.case_stmt.case_list));
4828               balance_case_nodes (&thiscase->data.case_stmt.case_list,
4829                                   NULL_PTR);
4830               emit_case_nodes (index, thiscase->data.case_stmt.case_list,
4831                                default_label, index_type);
4832               emit_jump_if_reachable (default_label);
4833             }
4834         }
4835       else
4836         {
4837           int win = 0;
4838 #ifdef HAVE_casesi
4839           if (HAVE_casesi)
4840             {
4841               enum machine_mode index_mode = SImode;
4842               int index_bits = GET_MODE_BITSIZE (index_mode);
4843               rtx op1, op2;
4844               enum machine_mode op_mode;
4845
4846               /* Convert the index to SImode.  */
4847               if (GET_MODE_BITSIZE (TYPE_MODE (index_type))
4848                   > GET_MODE_BITSIZE (index_mode))
4849                 {
4850                   enum machine_mode omode = TYPE_MODE (index_type);
4851                   rtx rangertx = expand_expr (range, NULL_RTX, VOIDmode, 0);
4852
4853                   /* We must handle the endpoints in the original mode.  */
4854                   index_expr = build (MINUS_EXPR, index_type,
4855                                       index_expr, minval);
4856                   minval = integer_zero_node;
4857                   index = expand_expr (index_expr, NULL_RTX, VOIDmode, 0);
4858                   emit_cmp_insn (rangertx, index, LTU, NULL_RTX, omode, 1, 0);
4859                   emit_jump_insn (gen_bltu (default_label));
4860                   /* Now we can safely truncate.  */
4861                   index = convert_to_mode (index_mode, index, 0);
4862                 }
4863               else
4864                 {
4865                   if (TYPE_MODE (index_type) != index_mode)
4866                     {
4867                       index_expr = convert (type_for_size (index_bits, 0),
4868                                             index_expr);
4869                       index_type = TREE_TYPE (index_expr);
4870                     }
4871
4872                   index = expand_expr (index_expr, NULL_RTX, VOIDmode, 0);
4873                 }
4874               emit_queue ();
4875               index = protect_from_queue (index, 0);
4876               do_pending_stack_adjust ();
4877
4878               op_mode = insn_operand_mode[(int)CODE_FOR_casesi][0];
4879               if (! (*insn_operand_predicate[(int)CODE_FOR_casesi][0])
4880                   (index, op_mode))
4881                 index = copy_to_mode_reg (op_mode, index);
4882
4883               op1 = expand_expr (minval, NULL_RTX, VOIDmode, 0);
4884
4885               op_mode = insn_operand_mode[(int)CODE_FOR_casesi][1];
4886               if (! (*insn_operand_predicate[(int)CODE_FOR_casesi][1])
4887                   (op1, op_mode))
4888                 op1 = copy_to_mode_reg (op_mode, op1);
4889
4890               op2 = expand_expr (range, NULL_RTX, VOIDmode, 0);
4891
4892               op_mode = insn_operand_mode[(int)CODE_FOR_casesi][2];
4893               if (! (*insn_operand_predicate[(int)CODE_FOR_casesi][2])
4894                   (op2, op_mode))
4895                 op2 = copy_to_mode_reg (op_mode, op2);
4896
4897               emit_jump_insn (gen_casesi (index, op1, op2,
4898                                           table_label, default_label));
4899               win = 1;
4900             }
4901 #endif
4902 #ifdef HAVE_tablejump
4903           if (! win && HAVE_tablejump)
4904             {
4905               index_expr = convert (thiscase->data.case_stmt.nominal_type,
4906                                     fold (build (MINUS_EXPR, index_type,
4907                                                  index_expr, minval)));
4908               index_type = TREE_TYPE (index_expr);
4909               index = expand_expr (index_expr, NULL_RTX, VOIDmode, 0);
4910               emit_queue ();
4911               index = protect_from_queue (index, 0);
4912               do_pending_stack_adjust ();
4913
4914               do_tablejump (index, TYPE_MODE (index_type),
4915                             expand_expr (range, NULL_RTX, VOIDmode, 0),
4916                             table_label, default_label);
4917               win = 1;
4918             }
4919 #endif
4920           if (! win)
4921             abort ();
4922
4923           /* Get table of labels to jump to, in order of case index.  */
4924
4925           ncases = TREE_INT_CST_LOW (range) + 1;
4926           labelvec = (rtx *) alloca (ncases * sizeof (rtx));
4927           bzero ((char *) labelvec, ncases * sizeof (rtx));
4928
4929           for (n = thiscase->data.case_stmt.case_list; n; n = n->right)
4930             {
4931               register HOST_WIDE_INT i
4932                 = TREE_INT_CST_LOW (n->low) - TREE_INT_CST_LOW (orig_minval);
4933
4934               while (1)
4935                 {
4936                   labelvec[i]
4937                     = gen_rtx (LABEL_REF, Pmode, label_rtx (n->code_label));
4938                   if (i + TREE_INT_CST_LOW (orig_minval)
4939                       == TREE_INT_CST_LOW (n->high))
4940                     break;
4941                   i++;
4942                 }
4943             }
4944
4945           /* Fill in the gaps with the default.  */
4946           for (i = 0; i < ncases; i++)
4947             if (labelvec[i] == 0)
4948               labelvec[i] = gen_rtx (LABEL_REF, Pmode, default_label);
4949
4950           /* Output the table */
4951           emit_label (table_label);
4952
4953           /* This would be a lot nicer if CASE_VECTOR_PC_RELATIVE
4954              were an expression, instead of an #ifdef/#ifndef.  */
4955           if (
4956 #ifdef CASE_VECTOR_PC_RELATIVE
4957               1 ||
4958 #endif
4959               flag_pic)
4960             emit_jump_insn (gen_rtx (ADDR_DIFF_VEC, CASE_VECTOR_MODE,
4961                                      gen_rtx (LABEL_REF, Pmode, table_label),
4962                                      gen_rtvec_v (ncases, labelvec)));
4963           else
4964             emit_jump_insn (gen_rtx (ADDR_VEC, CASE_VECTOR_MODE,
4965                                      gen_rtvec_v (ncases, labelvec)));
4966
4967           /* If the case insn drops through the table,
4968              after the table we must jump to the default-label.
4969              Otherwise record no drop-through after the table.  */
4970 #ifdef CASE_DROPS_THROUGH
4971           emit_jump (default_label);
4972 #else
4973           emit_barrier ();
4974 #endif
4975         }
4976
4977       before_case = squeeze_notes (NEXT_INSN (before_case), get_last_insn ());
4978       reorder_insns (before_case, get_last_insn (),
4979                      thiscase->data.case_stmt.start);
4980     }
4981
4982   if (thiscase->exit_label)
4983     emit_label (thiscase->exit_label);
4984
4985   POPSTACK (case_stack);
4986
4987   free_temp_slots ();
4988 }
4989
4990
4991 /* Terminate a case statement.  EXPR is the original index
4992    expression.  */
4993
4994 static void
4995 bc_expand_end_case (expr)
4996      tree expr;
4997 {
4998   struct nesting *thiscase = case_stack;
4999   enum bytecode_opcode opcode;
5000   struct bc_label *jump_label;
5001   struct case_node *c;
5002
5003   bc_emit_bytecode (jump);
5004   bc_emit_bytecode_labelref (BYTECODE_BC_LABEL (thiscase->exit_label));
5005
5006 #ifdef DEBUG_PRINT_CODE
5007   fputc ('\n', stderr);
5008 #endif
5009
5010   /* Now that the size of the jump table is known, emit the actual
5011      indexed jump instruction.  */
5012   bc_emit_bytecode_labeldef (BYTECODE_BC_LABEL (thiscase->data.case_stmt.skip_label));
5013
5014   opcode = TYPE_MODE (thiscase->data.case_stmt.nominal_type) == SImode
5015     ? TREE_UNSIGNED (thiscase->data.case_stmt.nominal_type) ? caseSU : caseSI
5016       : TREE_UNSIGNED (thiscase->data.case_stmt.nominal_type) ? caseDU : caseDI;
5017
5018   bc_emit_bytecode (opcode);
5019
5020   /* Now emit the case instructions literal arguments, in order.
5021      In addition to the value on the stack, it uses:
5022      1.  The address of the jump table.
5023      2.  The size of the jump table.
5024      3.  The default label.  */
5025
5026   jump_label = bc_get_bytecode_label ();
5027   bc_emit_bytecode_labelref (jump_label);
5028   bc_emit_bytecode_const ((char *) &thiscase->data.case_stmt.num_ranges,
5029                           sizeof thiscase->data.case_stmt.num_ranges);
5030
5031   if (thiscase->data.case_stmt.default_label)
5032     bc_emit_bytecode_labelref (BYTECODE_BC_LABEL (DECL_RTL (thiscase->data.case_stmt.default_label)));
5033   else
5034     bc_emit_bytecode_labelref (BYTECODE_BC_LABEL (thiscase->exit_label));
5035
5036   /* Output the jump table.  */
5037
5038   bc_align_bytecode (3 /* PTR_ALIGN */);
5039   bc_emit_bytecode_labeldef (jump_label);
5040
5041   if (TYPE_MODE (thiscase->data.case_stmt.nominal_type) == SImode)
5042     for (c = thiscase->data.case_stmt.case_list->left; c; c = c->left)
5043       {
5044         opcode = TREE_INT_CST_LOW (c->low);
5045         bc_emit_bytecode_const ((char *) &opcode, sizeof opcode);
5046
5047         opcode = TREE_INT_CST_LOW (c->high);
5048         bc_emit_bytecode_const ((char *) &opcode, sizeof opcode);
5049
5050         bc_emit_bytecode_labelref (BYTECODE_BC_LABEL (DECL_RTL (c->code_label)));
5051       }
5052   else
5053     if (TYPE_MODE (thiscase->data.case_stmt.nominal_type) == DImode)
5054       for (c = thiscase->data.case_stmt.case_list->left; c; c = c->left)
5055         {
5056           bc_emit_bytecode_DI_const (c->low);
5057           bc_emit_bytecode_DI_const (c->high);
5058
5059           bc_emit_bytecode_labelref (BYTECODE_BC_LABEL (DECL_RTL (c->code_label)));
5060         }
5061     else
5062       /* Bad mode */
5063       abort ();
5064
5065
5066   bc_emit_bytecode_labeldef (BYTECODE_BC_LABEL (thiscase->exit_label));
5067
5068   /* Possibly issue enumeration warnings.  */
5069
5070   if (!thiscase->data.case_stmt.default_label
5071       && TREE_CODE (TREE_TYPE (expr)) == ENUMERAL_TYPE
5072       && TREE_CODE (expr) != INTEGER_CST
5073       && warn_switch)
5074     check_for_full_enumeration_handling (TREE_TYPE (expr));
5075
5076
5077 #ifdef DEBUG_PRINT_CODE
5078   fputc ('\n', stderr);
5079 #endif
5080
5081   POPSTACK (case_stack);
5082 }
5083
5084
5085 /* Return unique bytecode ID. */
5086
5087 int
5088 bc_new_uid ()
5089 {
5090   static int bc_uid = 0;
5091
5092   return (++bc_uid);
5093 }
5094
5095 /* Generate code to jump to LABEL if OP1 and OP2 are equal.  */
5096
5097 static void
5098 do_jump_if_equal (op1, op2, label, unsignedp)
5099      rtx op1, op2, label;
5100      int unsignedp;
5101 {
5102   if (GET_CODE (op1) == CONST_INT
5103       && GET_CODE (op2) == CONST_INT)
5104     {
5105       if (INTVAL (op1) == INTVAL (op2))
5106         emit_jump (label);
5107     }
5108   else
5109     {
5110       enum machine_mode mode = GET_MODE (op1);
5111       if (mode == VOIDmode)
5112         mode = GET_MODE (op2);
5113       emit_cmp_insn (op1, op2, EQ, NULL_RTX, mode, unsignedp, 0);
5114       emit_jump_insn (gen_beq (label));
5115     }
5116 }
5117 \f
5118 /* Not all case values are encountered equally.  This function
5119    uses a heuristic to weight case labels, in cases where that
5120    looks like a reasonable thing to do.
5121
5122    Right now, all we try to guess is text, and we establish the
5123    following weights:
5124
5125         chars above space:      16
5126         digits:                 16
5127         default:                12
5128         space, punct:           8
5129         tab:                    4
5130         newline:                2
5131         other "\" chars:        1
5132         remaining chars:        0
5133
5134    If we find any cases in the switch that are not either -1 or in the range
5135    of valid ASCII characters, or are control characters other than those
5136    commonly used with "\", don't treat this switch scanning text.
5137
5138    Return 1 if these nodes are suitable for cost estimation, otherwise
5139    return 0.  */
5140
5141 static int
5142 estimate_case_costs (node)
5143      case_node_ptr node;
5144 {
5145   tree min_ascii = build_int_2 (-1, -1);
5146   tree max_ascii = convert (TREE_TYPE (node->high), build_int_2 (127, 0));
5147   case_node_ptr n;
5148   int i;
5149
5150   /* If we haven't already made the cost table, make it now.  Note that the
5151      lower bound of the table is -1, not zero.  */
5152
5153   if (cost_table == NULL)
5154     {
5155       cost_table = ((short *) xmalloc (129 * sizeof (short))) + 1;
5156       bzero ((char *) (cost_table - 1), 129 * sizeof (short));
5157
5158       for (i = 0; i < 128; i++)
5159         {
5160           if (isalnum (i))
5161             cost_table[i] = 16;
5162           else if (ispunct (i))
5163             cost_table[i] = 8;
5164           else if (iscntrl (i))
5165             cost_table[i] = -1;
5166         }
5167
5168       cost_table[' '] = 8;
5169       cost_table['\t'] = 4;
5170       cost_table['\0'] = 4;
5171       cost_table['\n'] = 2;
5172       cost_table['\f'] = 1;
5173       cost_table['\v'] = 1;
5174       cost_table['\b'] = 1;
5175     }
5176
5177   /* See if all the case expressions look like text.  It is text if the
5178      constant is >= -1 and the highest constant is <= 127.  Do all comparisons
5179      as signed arithmetic since we don't want to ever access cost_table with a
5180      value less than -1.  Also check that none of the constants in a range
5181      are strange control characters.  */
5182
5183   for (n = node; n; n = n->right)
5184     {
5185       if ((INT_CST_LT (n->low, min_ascii)) || INT_CST_LT (max_ascii, n->high))
5186         return 0;
5187
5188       for (i = TREE_INT_CST_LOW (n->low); i <= TREE_INT_CST_LOW (n->high); i++)
5189         if (cost_table[i] < 0)
5190           return 0;
5191     }
5192
5193   /* All interesting values are within the range of interesting
5194      ASCII characters.  */
5195   return 1;
5196 }
5197
5198 /* Scan an ordered list of case nodes
5199    combining those with consecutive values or ranges.
5200
5201    Eg. three separate entries 1: 2: 3: become one entry 1..3:  */
5202
5203 static void
5204 group_case_nodes (head)
5205      case_node_ptr head;
5206 {
5207   case_node_ptr node = head;
5208
5209   while (node)
5210     {
5211       rtx lb = next_real_insn (label_rtx (node->code_label));
5212       case_node_ptr np = node;
5213
5214       /* Try to group the successors of NODE with NODE.  */
5215       while (((np = np->right) != 0)
5216              /* Do they jump to the same place?  */
5217              && next_real_insn (label_rtx (np->code_label)) == lb
5218              /* Are their ranges consecutive?  */
5219              && tree_int_cst_equal (np->low,
5220                                     fold (build (PLUS_EXPR,
5221                                                  TREE_TYPE (node->high),
5222                                                  node->high,
5223                                                  integer_one_node)))
5224              /* An overflow is not consecutive.  */
5225              && tree_int_cst_lt (node->high,
5226                                  fold (build (PLUS_EXPR,
5227                                               TREE_TYPE (node->high),
5228                                               node->high,
5229                                               integer_one_node))))
5230         {
5231           node->high = np->high;
5232         }
5233       /* NP is the first node after NODE which can't be grouped with it.
5234          Delete the nodes in between, and move on to that node.  */
5235       node->right = np;
5236       node = np;
5237     }
5238 }
5239
5240 /* Take an ordered list of case nodes
5241    and transform them into a near optimal binary tree,
5242    on the assumption that any target code selection value is as
5243    likely as any other.
5244
5245    The transformation is performed by splitting the ordered
5246    list into two equal sections plus a pivot.  The parts are
5247    then attached to the pivot as left and right branches.  Each
5248    branch is is then transformed recursively.  */
5249
5250 static void
5251 balance_case_nodes (head, parent)
5252      case_node_ptr *head;
5253      case_node_ptr parent;
5254 {
5255   register case_node_ptr np;
5256
5257   np = *head;
5258   if (np)
5259     {
5260       int cost = 0;
5261       int i = 0;
5262       int ranges = 0;
5263       register case_node_ptr *npp;
5264       case_node_ptr left;
5265
5266       /* Count the number of entries on branch.  Also count the ranges.  */
5267
5268       while (np)
5269         {
5270           if (!tree_int_cst_equal (np->low, np->high))
5271             {
5272               ranges++;
5273               if (use_cost_table)
5274                 cost += cost_table[TREE_INT_CST_LOW (np->high)];
5275             }
5276
5277           if (use_cost_table)
5278             cost += cost_table[TREE_INT_CST_LOW (np->low)];
5279
5280           i++;
5281           np = np->right;
5282         }
5283
5284       if (i > 2)
5285         {
5286           /* Split this list if it is long enough for that to help.  */
5287           npp = head;
5288           left = *npp;
5289           if (use_cost_table)
5290             {
5291               /* Find the place in the list that bisects the list's total cost,
5292                  Here I gets half the total cost.  */
5293               int n_moved = 0;
5294               i = (cost + 1) / 2;
5295               while (1)
5296                 {
5297                   /* Skip nodes while their cost does not reach that amount.  */
5298                   if (!tree_int_cst_equal ((*npp)->low, (*npp)->high))
5299                     i -= cost_table[TREE_INT_CST_LOW ((*npp)->high)];
5300                   i -= cost_table[TREE_INT_CST_LOW ((*npp)->low)];
5301                   if (i <= 0)
5302                     break;
5303                   npp = &(*npp)->right;
5304                   n_moved += 1;
5305                 }
5306               if (n_moved == 0)
5307                 {
5308                   /* Leave this branch lopsided, but optimize left-hand
5309                      side and fill in `parent' fields for right-hand side.  */
5310                   np = *head;
5311                   np->parent = parent;
5312                   balance_case_nodes (&np->left, np);
5313                   for (; np->right; np = np->right)
5314                     np->right->parent = np;
5315                   return;
5316                 }
5317             }
5318           /* If there are just three nodes, split at the middle one.  */
5319           else if (i == 3)
5320             npp = &(*npp)->right;
5321           else
5322             {
5323               /* Find the place in the list that bisects the list's total cost,
5324                  where ranges count as 2.
5325                  Here I gets half the total cost.  */
5326               i = (i + ranges + 1) / 2;
5327               while (1)
5328                 {
5329                   /* Skip nodes while their cost does not reach that amount.  */
5330                   if (!tree_int_cst_equal ((*npp)->low, (*npp)->high))
5331                     i--;
5332                   i--;
5333                   if (i <= 0)
5334                     break;
5335                   npp = &(*npp)->right;
5336                 }
5337             }
5338           *head = np = *npp;
5339           *npp = 0;
5340           np->parent = parent;
5341           np->left = left;
5342
5343           /* Optimize each of the two split parts.  */
5344           balance_case_nodes (&np->left, np);
5345           balance_case_nodes (&np->right, np);
5346         }
5347       else
5348         {
5349           /* Else leave this branch as one level,
5350              but fill in `parent' fields.  */
5351           np = *head;
5352           np->parent = parent;
5353           for (; np->right; np = np->right)
5354             np->right->parent = np;
5355         }
5356     }
5357 }
5358 \f
5359 /* Search the parent sections of the case node tree
5360    to see if a test for the lower bound of NODE would be redundant.
5361    INDEX_TYPE is the type of the index expression.
5362
5363    The instructions to generate the case decision tree are
5364    output in the same order as nodes are processed so it is
5365    known that if a parent node checks the range of the current
5366    node minus one that the current node is bounded at its lower
5367    span.  Thus the test would be redundant.  */
5368
5369 static int
5370 node_has_low_bound (node, index_type)
5371      case_node_ptr node;
5372      tree index_type;
5373 {
5374   tree low_minus_one;
5375   case_node_ptr pnode;
5376
5377   /* If the lower bound of this node is the lowest value in the index type,
5378      we need not test it.  */
5379
5380   if (tree_int_cst_equal (node->low, TYPE_MIN_VALUE (index_type)))
5381     return 1;
5382
5383   /* If this node has a left branch, the value at the left must be less
5384      than that at this node, so it cannot be bounded at the bottom and
5385      we need not bother testing any further.  */
5386
5387   if (node->left)
5388     return 0;
5389
5390   low_minus_one = fold (build (MINUS_EXPR, TREE_TYPE (node->low),
5391                                node->low, integer_one_node));
5392
5393   /* If the subtraction above overflowed, we can't verify anything.
5394      Otherwise, look for a parent that tests our value - 1.  */
5395
5396   if (! tree_int_cst_lt (low_minus_one, node->low))
5397     return 0;
5398
5399   for (pnode = node->parent; pnode; pnode = pnode->parent)
5400     if (tree_int_cst_equal (low_minus_one, pnode->high))
5401       return 1;
5402
5403   return 0;
5404 }
5405
5406 /* Search the parent sections of the case node tree
5407    to see if a test for the upper bound of NODE would be redundant.
5408    INDEX_TYPE is the type of the index expression.
5409
5410    The instructions to generate the case decision tree are
5411    output in the same order as nodes are processed so it is
5412    known that if a parent node checks the range of the current
5413    node plus one that the current node is bounded at its upper
5414    span.  Thus the test would be redundant.  */
5415
5416 static int
5417 node_has_high_bound (node, index_type)
5418      case_node_ptr node;
5419      tree index_type;
5420 {
5421   tree high_plus_one;
5422   case_node_ptr pnode;
5423
5424   /* If the upper bound of this node is the highest value in the type
5425      of the index expression, we need not test against it.  */
5426
5427   if (tree_int_cst_equal (node->high, TYPE_MAX_VALUE (index_type)))
5428     return 1;
5429
5430   /* If this node has a right branch, the value at the right must be greater
5431      than that at this node, so it cannot be bounded at the top and
5432      we need not bother testing any further.  */
5433
5434   if (node->right)
5435     return 0;
5436
5437   high_plus_one = fold (build (PLUS_EXPR, TREE_TYPE (node->high),
5438                                node->high, integer_one_node));
5439
5440   /* If the addition above overflowed, we can't verify anything.
5441      Otherwise, look for a parent that tests our value + 1.  */
5442
5443   if (! tree_int_cst_lt (node->high, high_plus_one))
5444     return 0;
5445
5446   for (pnode = node->parent; pnode; pnode = pnode->parent)
5447     if (tree_int_cst_equal (high_plus_one, pnode->low))
5448       return 1;
5449
5450   return 0;
5451 }
5452
5453 /* Search the parent sections of the
5454    case node tree to see if both tests for the upper and lower
5455    bounds of NODE would be redundant.  */
5456
5457 static int
5458 node_is_bounded (node, index_type)
5459      case_node_ptr node;
5460      tree index_type;
5461 {
5462   return (node_has_low_bound (node, index_type)
5463           && node_has_high_bound (node, index_type));
5464 }
5465
5466 /*  Emit an unconditional jump to LABEL unless it would be dead code.  */
5467
5468 static void
5469 emit_jump_if_reachable (label)
5470      rtx label;
5471 {
5472   if (GET_CODE (get_last_insn ()) != BARRIER)
5473     emit_jump (label);
5474 }
5475 \f
5476 /* Emit step-by-step code to select a case for the value of INDEX.
5477    The thus generated decision tree follows the form of the
5478    case-node binary tree NODE, whose nodes represent test conditions.
5479    INDEX_TYPE is the type of the index of the switch.
5480
5481    Care is taken to prune redundant tests from the decision tree
5482    by detecting any boundary conditions already checked by
5483    emitted rtx.  (See node_has_high_bound, node_has_low_bound
5484    and node_is_bounded, above.)
5485
5486    Where the test conditions can be shown to be redundant we emit
5487    an unconditional jump to the target code.  As a further
5488    optimization, the subordinates of a tree node are examined to
5489    check for bounded nodes.  In this case conditional and/or
5490    unconditional jumps as a result of the boundary check for the
5491    current node are arranged to target the subordinates associated
5492    code for out of bound conditions on the current node node.
5493
5494    We can assume that when control reaches the code generated here,
5495    the index value has already been compared with the parents
5496    of this node, and determined to be on the same side of each parent
5497    as this node is.  Thus, if this node tests for the value 51,
5498    and a parent tested for 52, we don't need to consider
5499    the possibility of a value greater than 51.  If another parent
5500    tests for the value 50, then this node need not test anything.  */
5501
5502 static void
5503 emit_case_nodes (index, node, default_label, index_type)
5504      rtx index;
5505      case_node_ptr node;
5506      rtx default_label;
5507      tree index_type;
5508 {
5509   /* If INDEX has an unsigned type, we must make unsigned branches.  */
5510   int unsignedp = TREE_UNSIGNED (index_type);
5511   typedef rtx rtx_function ();
5512   rtx_function *gen_bgt_pat = unsignedp ? gen_bgtu : gen_bgt;
5513   rtx_function *gen_bge_pat = unsignedp ? gen_bgeu : gen_bge;
5514   rtx_function *gen_blt_pat = unsignedp ? gen_bltu : gen_blt;
5515   rtx_function *gen_ble_pat = unsignedp ? gen_bleu : gen_ble;
5516   enum machine_mode mode = GET_MODE (index);
5517
5518   /* See if our parents have already tested everything for us.
5519      If they have, emit an unconditional jump for this node.  */
5520   if (node_is_bounded (node, index_type))
5521     emit_jump (label_rtx (node->code_label));
5522
5523   else if (tree_int_cst_equal (node->low, node->high))
5524     {
5525       /* Node is single valued.  First see if the index expression matches
5526          this node and then check our children, if any. */
5527
5528       do_jump_if_equal (index, expand_expr (node->low, NULL_RTX, VOIDmode, 0),
5529                         label_rtx (node->code_label), unsignedp);
5530
5531       if (node->right != 0 && node->left != 0)
5532         {
5533           /* This node has children on both sides.
5534              Dispatch to one side or the other
5535              by comparing the index value with this node's value.
5536              If one subtree is bounded, check that one first,
5537              so we can avoid real branches in the tree.  */
5538
5539           if (node_is_bounded (node->right, index_type))
5540             {
5541               emit_cmp_insn (index, expand_expr (node->high, NULL_RTX,
5542                                                  VOIDmode, 0),
5543                              GT, NULL_RTX, mode, unsignedp, 0);
5544
5545               emit_jump_insn ((*gen_bgt_pat) (label_rtx (node->right->code_label)));
5546               emit_case_nodes (index, node->left, default_label, index_type);
5547             }
5548
5549           else if (node_is_bounded (node->left, index_type))
5550             {
5551               emit_cmp_insn (index, expand_expr (node->high, NULL_RTX,
5552                                                  VOIDmode, 0),
5553                              LT, NULL_RTX, mode, unsignedp, 0);
5554               emit_jump_insn ((*gen_blt_pat) (label_rtx (node->left->code_label)));
5555               emit_case_nodes (index, node->right, default_label, index_type);
5556             }
5557
5558           else
5559             {
5560               /* Neither node is bounded.  First distinguish the two sides;
5561                  then emit the code for one side at a time.  */
5562
5563               tree test_label
5564                 = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5565
5566               /* See if the value is on the right.  */
5567               emit_cmp_insn (index, expand_expr (node->high, NULL_RTX,
5568                                                  VOIDmode, 0),
5569                              GT, NULL_RTX, mode, unsignedp, 0);
5570               emit_jump_insn ((*gen_bgt_pat) (label_rtx (test_label)));
5571
5572               /* Value must be on the left.
5573                  Handle the left-hand subtree.  */
5574               emit_case_nodes (index, node->left, default_label, index_type);
5575               /* If left-hand subtree does nothing,
5576                  go to default.  */
5577               emit_jump_if_reachable (default_label);
5578
5579               /* Code branches here for the right-hand subtree.  */
5580               expand_label (test_label);
5581               emit_case_nodes (index, node->right, default_label, index_type);
5582             }
5583         }
5584
5585       else if (node->right != 0 && node->left == 0)
5586         {
5587           /* Here we have a right child but no left so we issue conditional
5588              branch to default and process the right child.
5589
5590              Omit the conditional branch to default if we it avoid only one
5591              right child; it costs too much space to save so little time.  */
5592
5593           if (node->right->right || node->right->left
5594               || !tree_int_cst_equal (node->right->low, node->right->high))
5595             {
5596               if (!node_has_low_bound (node, index_type))
5597                 {
5598                   emit_cmp_insn (index, expand_expr (node->high, NULL_RTX,
5599                                                      VOIDmode, 0),
5600                                  LT, NULL_RTX, mode, unsignedp, 0);
5601                   emit_jump_insn ((*gen_blt_pat) (default_label));
5602                 }
5603
5604               emit_case_nodes (index, node->right, default_label, index_type);
5605             }
5606           else
5607             /* We cannot process node->right normally
5608                since we haven't ruled out the numbers less than
5609                this node's value.  So handle node->right explicitly.  */
5610             do_jump_if_equal (index,
5611                               expand_expr (node->right->low, NULL_RTX,
5612                                            VOIDmode, 0),
5613                               label_rtx (node->right->code_label), unsignedp);
5614         }
5615
5616       else if (node->right == 0 && node->left != 0)
5617         {
5618           /* Just one subtree, on the left.  */
5619
5620 #if 0 /* The following code and comment were formerly part
5621          of the condition here, but they didn't work
5622          and I don't understand what the idea was.  -- rms.  */
5623           /* If our "most probable entry" is less probable
5624              than the default label, emit a jump to
5625              the default label using condition codes
5626              already lying around.  With no right branch,
5627              a branch-greater-than will get us to the default
5628              label correctly.  */
5629           if (use_cost_table
5630                && cost_table[TREE_INT_CST_LOW (node->high)] < 12)
5631             ;
5632 #endif /* 0 */
5633           if (node->left->left || node->left->right
5634               || !tree_int_cst_equal (node->left->low, node->left->high))
5635             {
5636               if (!node_has_high_bound (node, index_type))
5637                 {
5638                   emit_cmp_insn (index, expand_expr (node->high, NULL_RTX,
5639                                                      VOIDmode, 0),
5640                                  GT, NULL_RTX, mode, unsignedp, 0);
5641                   emit_jump_insn ((*gen_bgt_pat) (default_label));
5642                 }
5643
5644               emit_case_nodes (index, node->left, default_label, index_type);
5645             }
5646           else
5647             /* We cannot process node->left normally
5648                since we haven't ruled out the numbers less than
5649                this node's value.  So handle node->left explicitly.  */
5650             do_jump_if_equal (index,
5651                               expand_expr (node->left->low, NULL_RTX,
5652                                            VOIDmode, 0),
5653                               label_rtx (node->left->code_label), unsignedp);
5654         }
5655     }
5656   else
5657     {
5658       /* Node is a range.  These cases are very similar to those for a single
5659          value, except that we do not start by testing whether this node
5660          is the one to branch to.  */
5661
5662       if (node->right != 0 && node->left != 0)
5663         {
5664           /* Node has subtrees on both sides.
5665              If the right-hand subtree is bounded,
5666              test for it first, since we can go straight there.
5667              Otherwise, we need to make a branch in the control structure,
5668              then handle the two subtrees.  */
5669           tree test_label = 0;
5670
5671           emit_cmp_insn (index, expand_expr (node->high, NULL_RTX,
5672                                              VOIDmode, 0),
5673                          GT, NULL_RTX, mode, unsignedp, 0);
5674
5675           if (node_is_bounded (node->right, index_type))
5676             /* Right hand node is fully bounded so we can eliminate any
5677                testing and branch directly to the target code.  */
5678             emit_jump_insn ((*gen_bgt_pat) (label_rtx (node->right->code_label)));
5679           else
5680             {
5681               /* Right hand node requires testing.
5682                  Branch to a label where we will handle it later.  */
5683
5684               test_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5685               emit_jump_insn ((*gen_bgt_pat) (label_rtx (test_label)));
5686             }
5687
5688           /* Value belongs to this node or to the left-hand subtree.  */
5689
5690           emit_cmp_insn (index, expand_expr (node->low, NULL_RTX, VOIDmode, 0),
5691                          GE, NULL_RTX, mode, unsignedp, 0);
5692           emit_jump_insn ((*gen_bge_pat) (label_rtx (node->code_label)));
5693
5694           /* Handle the left-hand subtree.  */
5695           emit_case_nodes (index, node->left, default_label, index_type);
5696
5697           /* If right node had to be handled later, do that now.  */
5698
5699           if (test_label)
5700             {
5701               /* If the left-hand subtree fell through,
5702                  don't let it fall into the right-hand subtree.  */
5703               emit_jump_if_reachable (default_label);
5704
5705               expand_label (test_label);
5706               emit_case_nodes (index, node->right, default_label, index_type);
5707             }
5708         }
5709
5710       else if (node->right != 0 && node->left == 0)
5711         {
5712           /* Deal with values to the left of this node,
5713              if they are possible.  */
5714           if (!node_has_low_bound (node, index_type))
5715             {
5716               emit_cmp_insn (index, expand_expr (node->low, NULL_RTX,
5717                                                  VOIDmode, 0),
5718                              LT, NULL_RTX, mode, unsignedp, 0);
5719               emit_jump_insn ((*gen_blt_pat) (default_label));
5720             }
5721
5722           /* Value belongs to this node or to the right-hand subtree.  */
5723
5724           emit_cmp_insn (index, expand_expr (node->high, NULL_RTX,
5725                                              VOIDmode, 0),
5726                          LE, NULL_RTX, mode, unsignedp, 0);
5727           emit_jump_insn ((*gen_ble_pat) (label_rtx (node->code_label)));
5728
5729           emit_case_nodes (index, node->right, default_label, index_type);
5730         }
5731
5732       else if (node->right == 0 && node->left != 0)
5733         {
5734           /* Deal with values to the right of this node,
5735              if they are possible.  */
5736           if (!node_has_high_bound (node, index_type))
5737             {
5738               emit_cmp_insn (index, expand_expr (node->high, NULL_RTX,
5739                                                  VOIDmode, 0),
5740                              GT, NULL_RTX, mode, unsignedp, 0);
5741               emit_jump_insn ((*gen_bgt_pat) (default_label));
5742             }
5743
5744           /* Value belongs to this node or to the left-hand subtree.  */
5745
5746           emit_cmp_insn (index, expand_expr (node->low, NULL_RTX, VOIDmode, 0),
5747                          GE, NULL_RTX, mode, unsignedp, 0);
5748           emit_jump_insn ((*gen_bge_pat) (label_rtx (node->code_label)));
5749
5750           emit_case_nodes (index, node->left, default_label, index_type);
5751         }
5752
5753       else
5754         {
5755           /* Node has no children so we check low and high bounds to remove
5756              redundant tests.  Only one of the bounds can exist,
5757              since otherwise this node is bounded--a case tested already.  */
5758
5759           if (!node_has_high_bound (node, index_type))
5760             {
5761               emit_cmp_insn (index, expand_expr (node->high, NULL_RTX,
5762                                                  VOIDmode, 0),
5763                              GT, NULL_RTX, mode, unsignedp, 0);
5764               emit_jump_insn ((*gen_bgt_pat) (default_label));
5765             }
5766
5767           if (!node_has_low_bound (node, index_type))
5768             {
5769               emit_cmp_insn (index, expand_expr (node->low, NULL_RTX,
5770                                                  VOIDmode, 0),
5771                              LT, NULL_RTX, mode, unsignedp, 0);
5772               emit_jump_insn ((*gen_blt_pat) (default_label));
5773             }
5774
5775           emit_jump (label_rtx (node->code_label));
5776         }
5777     }
5778 }
5779 \f
5780 /* These routines are used by the loop unrolling code.  They copy BLOCK trees
5781    so that the debugging info will be correct for the unrolled loop.  */
5782
5783 /* Indexed by block number, contains a pointer to the N'th block node.  */
5784
5785 static tree *block_vector;
5786
5787 void
5788 find_loop_tree_blocks ()
5789 {
5790   tree block = DECL_INITIAL (current_function_decl);
5791
5792   /* There first block is for the function body, and does not have
5793      corresponding block notes.  Don't include it in the block vector.  */
5794   block = BLOCK_SUBBLOCKS (block);
5795
5796   block_vector = identify_blocks (block, get_insns ());
5797 }
5798
5799 void
5800 unroll_block_trees ()
5801 {
5802   tree block = DECL_INITIAL (current_function_decl);
5803
5804   reorder_blocks (block_vector, block, get_insns ());
5805 }
5806