gcc/stmt.c

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