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