gcc/stmt.c

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