gcc/reg-stack.c

   1 /* Register to Stack convert for GNU compiler.
   2    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002, 2003, 2004, 2005, 2006, 2007
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GCC.
   7
   8    GCC is free software; you can redistribute it and/or modify it
   9    under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3, or (at your option)
  11    any later version.
  12
  13    GCC is distributed in the hope that it will be useful, but WITHOUT
  14    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  15    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  16    License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with GCC; see the file COPYING3.  If not see
  20    <http://www.gnu.org/licenses/>.  */
  21
  22 /* This pass converts stack-like registers from the "flat register
  23    file" model that gcc uses, to a stack convention that the 387 uses.
  24
  25    * The form of the input:
  26
  27    On input, the function consists of insn that have had their
  28    registers fully allocated to a set of "virtual" registers.  Note that
  29    the word "virtual" is used differently here than elsewhere in gcc: for
  30    each virtual stack reg, there is a hard reg, but the mapping between
  31    them is not known until this pass is run.  On output, hard register
  32    numbers have been substituted, and various pop and exchange insns have
  33    been emitted.  The hard register numbers and the virtual register
  34    numbers completely overlap - before this pass, all stack register
  35    numbers are virtual, and afterward they are all hard.
  36
  37    The virtual registers can be manipulated normally by gcc, and their
  38    semantics are the same as for normal registers.  After the hard
  39    register numbers are substituted, the semantics of an insn containing
  40    stack-like regs are not the same as for an insn with normal regs: for
  41    instance, it is not safe to delete an insn that appears to be a no-op
  42    move.  In general, no insn containing hard regs should be changed
  43    after this pass is done.
  44
  45    * The form of the output:
  46
  47    After this pass, hard register numbers represent the distance from
  48    the current top of stack to the desired register.  A reference to
  49    FIRST_STACK_REG references the top of stack, FIRST_STACK_REG + 1,
  50    represents the register just below that, and so forth.  Also, REG_DEAD
  51    notes indicate whether or not a stack register should be popped.
  52
  53    A "swap" insn looks like a parallel of two patterns, where each
  54    pattern is a SET: one sets A to B, the other B to A.
  55
  56    A "push" or "load" insn is a SET whose SET_DEST is FIRST_STACK_REG
  57    and whose SET_DEST is REG or MEM.  Any other SET_DEST, such as PLUS,
  58    will replace the existing stack top, not push a new value.
  59
  60    A store insn is a SET whose SET_DEST is FIRST_STACK_REG, and whose
  61    SET_SRC is REG or MEM.
  62
  63    The case where the SET_SRC and SET_DEST are both FIRST_STACK_REG
  64    appears ambiguous.  As a special case, the presence of a REG_DEAD note
  65    for FIRST_STACK_REG differentiates between a load insn and a pop.
  66
  67    If a REG_DEAD is present, the insn represents a "pop" that discards
  68    the top of the register stack.  If there is no REG_DEAD note, then the
  69    insn represents a "dup" or a push of the current top of stack onto the
  70    stack.
  71
  72    * Methodology:
  73
  74    Existing REG_DEAD and REG_UNUSED notes for stack registers are
  75    deleted and recreated from scratch.  REG_DEAD is never created for a
  76    SET_DEST, only REG_UNUSED.
  77
  78    * asm_operands:
  79
  80    There are several rules on the usage of stack-like regs in
  81    asm_operands insns.  These rules apply only to the operands that are
  82    stack-like regs:
  83
  84    1. Given a set of input regs that die in an asm_operands, it is
  85       necessary to know which are implicitly popped by the asm, and
  86       which must be explicitly popped by gcc.
  87
  88         An input reg that is implicitly popped by the asm must be
  89         explicitly clobbered, unless it is constrained to match an
  90         output operand.
  91
  92    2. For any input reg that is implicitly popped by an asm, it is
  93       necessary to know how to adjust the stack to compensate for the pop.
  94       If any non-popped input is closer to the top of the reg-stack than
  95       the implicitly popped reg, it would not be possible to know what the
  96       stack looked like - it's not clear how the rest of the stack "slides
  97       up".
  98
  99         All implicitly popped input regs must be closer to the top of
 100         the reg-stack than any input that is not implicitly popped.
 101
 102    3. It is possible that if an input dies in an insn, reload might
 103       use the input reg for an output reload.  Consider this example:
 104
 105                 asm ("foo" : "=t" (a) : "f" (b));
 106
 107       This asm says that input B is not popped by the asm, and that
 108       the asm pushes a result onto the reg-stack, i.e., the stack is one
 109       deeper after the asm than it was before.  But, it is possible that
 110       reload will think that it can use the same reg for both the input and
 111       the output, if input B dies in this insn.
 112
 113         If any input operand uses the "f" constraint, all output reg
 114         constraints must use the "&" earlyclobber.
 115
 116       The asm above would be written as
 117
 118                 asm ("foo" : "=&t" (a) : "f" (b));
 119
 120    4. Some operands need to be in particular places on the stack.  All
 121       output operands fall in this category - there is no other way to
 122       know which regs the outputs appear in unless the user indicates
 123       this in the constraints.
 124
 125         Output operands must specifically indicate which reg an output
 126         appears in after an asm.  "=f" is not allowed: the operand
 127         constraints must select a class with a single reg.
 128
 129    5. Output operands may not be "inserted" between existing stack regs.
 130       Since no 387 opcode uses a read/write operand, all output operands
 131       are dead before the asm_operands, and are pushed by the asm_operands.
 132       It makes no sense to push anywhere but the top of the reg-stack.
 133
 134         Output operands must start at the top of the reg-stack: output
 135         operands may not "skip" a reg.
 136
 137    6. Some asm statements may need extra stack space for internal
 138       calculations.  This can be guaranteed by clobbering stack registers
 139       unrelated to the inputs and outputs.
 140
 141    Here are a couple of reasonable asms to want to write.  This asm
 142    takes one input, which is internally popped, and produces two outputs.
 143
 144         asm ("fsincos" : "=t" (cos), "=u" (sin) : "0" (inp));
 145
 146    This asm takes two inputs, which are popped by the fyl2xp1 opcode,
 147    and replaces them with one output.  The user must code the "st(1)"
 148    clobber for reg-stack.c to know that fyl2xp1 pops both inputs.
 149
 150         asm ("fyl2xp1" : "=t" (result) : "0" (x), "u" (y) : "st(1)");
 151
 152 */
 153 \f
 154 #include "config.h"
 155 #include "system.h"
 156 #include "coretypes.h"
 157 #include "tm.h"
 158 #include "tree.h"
 159 #include "rtl.h"
 160 #include "tm_p.h"
 161 #include "function.h"
 162 #include "insn-config.h"
 163 #include "regs.h"
 164 #include "hard-reg-set.h"
 165 #include "flags.h"
 166 #include "toplev.h"
 167 #include "recog.h"
 168 #include "output.h"
 169 #include "basic-block.h"
 170 #include "cfglayout.h"
 171 #include "varray.h"
 172 #include "reload.h"
 173 #include "ggc.h"
 174 #include "timevar.h"
 175 #include "tree-pass.h"
 176 #include "target.h"
 177 #include "df.h"
 178 #include "vecprim.h"
 179
 180 #ifdef STACK_REGS
 181
 182 /* We use this array to cache info about insns, because otherwise we
 183    spend too much time in stack_regs_mentioned_p.
 184
 185    Indexed by insn UIDs.  A value of zero is uninitialized, one indicates
 186    the insn uses stack registers, two indicates the insn does not use
 187    stack registers.  */
 188 static VEC(char,heap) *stack_regs_mentioned_data;
 189
 190 #define REG_STACK_SIZE (LAST_STACK_REG - FIRST_STACK_REG + 1)
 191
 192 int regstack_completed = 0;
 193
 194 /* This is the basic stack record.  TOP is an index into REG[] such
 195    that REG[TOP] is the top of stack.  If TOP is -1 the stack is empty.
 196
 197    If TOP is -2, REG[] is not yet initialized.  Stack initialization
 198    consists of placing each live reg in array `reg' and setting `top'
 199    appropriately.
 200
 201    REG_SET indicates which registers are live.  */
 202
 203 typedef struct stack_def
 204 {
 205   int top;                      /* index to top stack element */
 206   HARD_REG_SET reg_set;         /* set of live registers */
 207   unsigned char reg[REG_STACK_SIZE];/* register - stack mapping */
 208 } *stack;
 209
 210 /* This is used to carry information about basic blocks.  It is
 211    attached to the AUX field of the standard CFG block.  */
 212
 213 typedef struct block_info_def
 214 {
 215   struct stack_def stack_in;    /* Input stack configuration.  */
 216   struct stack_def stack_out;   /* Output stack configuration.  */
 217   HARD_REG_SET out_reg_set;     /* Stack regs live on output.  */
 218   int done;                     /* True if block already converted.  */
 219   int predecessors;             /* Number of predecessors that need
 220                                    to be visited.  */
 221 } *block_info;
 222
 223 #define BLOCK_INFO(B)   ((block_info) (B)->aux)
 224
 225 /* Passed to change_stack to indicate where to emit insns.  */
 226 enum emit_where
 227 {
 228   EMIT_AFTER,
 229   EMIT_BEFORE
 230 };
 231
 232 /* The block we're currently working on.  */
 233 static basic_block current_block;
 234
 235 /* In the current_block, whether we're processing the first register
 236    stack or call instruction, i.e. the regstack is currently the
 237    same as BLOCK_INFO(current_block)->stack_in.  */
 238 static bool starting_stack_p;
 239
 240 /* This is the register file for all register after conversion.  */
 241 static rtx
 242   FP_mode_reg[LAST_STACK_REG+1-FIRST_STACK_REG][(int) MAX_MACHINE_MODE];
 243
 244 #define FP_MODE_REG(regno,mode) \
 245   (FP_mode_reg[(regno)-FIRST_STACK_REG][(int) (mode)])
 246
 247 /* Used to initialize uninitialized registers.  */
 248 static rtx not_a_num;
 249
 250 /* Forward declarations */
 251
 252 static int stack_regs_mentioned_p (rtx pat);
 253 static void pop_stack (stack, int);
 254 static rtx *get_true_reg (rtx *);
 255
 256 static int check_asm_stack_operands (rtx);
 257 static int get_asm_operand_n_inputs (rtx);
 258 static rtx stack_result (tree);
 259 static void replace_reg (rtx *, int);
 260 static void remove_regno_note (rtx, enum reg_note, unsigned int);
 261 static int get_hard_regnum (stack, rtx);
 262 static rtx emit_pop_insn (rtx, stack, rtx, enum emit_where);
 263 static void swap_to_top(rtx, stack, rtx, rtx);
 264 static bool move_for_stack_reg (rtx, stack, rtx);
 265 static bool move_nan_for_stack_reg (rtx, stack, rtx);
 266 static int swap_rtx_condition_1 (rtx);
 267 static int swap_rtx_condition (rtx);
 268 static void compare_for_stack_reg (rtx, stack, rtx);
 269 static bool subst_stack_regs_pat (rtx, stack, rtx);
 270 static void subst_asm_stack_regs (rtx, stack);
 271 static bool subst_stack_regs (rtx, stack);
 272 static void change_stack (rtx, stack, stack, enum emit_where);
 273 static void print_stack (FILE *, stack);
 274 static rtx next_flags_user (rtx);
 275 \f
 276 /* Return nonzero if any stack register is mentioned somewhere within PAT.  */
 277
 278 static int
 279 stack_regs_mentioned_p (rtx pat)
 280 {
 281   const char *fmt;
 282   int i;
 283
 284   if (STACK_REG_P (pat))
 285     return 1;
 286
 287   fmt = GET_RTX_FORMAT (GET_CODE (pat));
 288   for (i = GET_RTX_LENGTH (GET_CODE (pat)) - 1; i >= 0; i--)
 289     {
 290       if (fmt[i] == 'E')
 291         {
 292           int j;
 293
 294           for (j = XVECLEN (pat, i) - 1; j >= 0; j--)
 295             if (stack_regs_mentioned_p (XVECEXP (pat, i, j)))
 296               return 1;
 297         }
 298       else if (fmt[i] == 'e' && stack_regs_mentioned_p (XEXP (pat, i)))
 299         return 1;
 300     }
 301
 302   return 0;
 303 }
 304
 305 /* Return nonzero if INSN mentions stacked registers, else return zero.  */
 306
 307 int
 308 stack_regs_mentioned (rtx insn)
 309 {
 310   unsigned int uid, max;
 311   int test;
 312
 313   if (! INSN_P (insn) || !stack_regs_mentioned_data)
 314     return 0;
 315
 316   uid = INSN_UID (insn);
 317   max = VEC_length (char, stack_regs_mentioned_data);
 318   if (uid >= max)
 319     {
 320       /* Allocate some extra size to avoid too many reallocs, but
 321          do not grow too quickly.  */
 322       max = uid + uid / 20 + 1;
 323       VEC_safe_grow_cleared (char, heap, stack_regs_mentioned_data, max);
 324     }
 325
 326   test = VEC_index (char, stack_regs_mentioned_data, uid);
 327   if (test == 0)
 328     {
 329       /* This insn has yet to be examined.  Do so now.  */
 330       test = stack_regs_mentioned_p (PATTERN (insn)) ? 1 : 2;
 331       VEC_replace (char, stack_regs_mentioned_data, uid, test);
 332     }
 333
 334   return test == 1;
 335 }
 336 \f
 337 static rtx ix86_flags_rtx;
 338
 339 static rtx
 340 next_flags_user (rtx insn)
 341 {
 342   /* Search forward looking for the first use of this value.
 343      Stop at block boundaries.  */
 344
 345   while (insn != BB_END (current_block))
 346     {
 347       insn = NEXT_INSN (insn);
 348
 349       if (INSN_P (insn) && reg_mentioned_p (ix86_flags_rtx, PATTERN (insn)))
 350         return insn;
 351
 352       if (CALL_P (insn))
 353         return NULL_RTX;
 354     }
 355   return NULL_RTX;
 356 }
 357 \f
 358 /* Reorganize the stack into ascending numbers, before this insn.  */
 359
 360 static void
 361 straighten_stack (rtx insn, stack regstack)
 362 {
 363   struct stack_def temp_stack;
 364   int top;
 365
 366   /* If there is only a single register on the stack, then the stack is
 367      already in increasing order and no reorganization is needed.
 368
 369      Similarly if the stack is empty.  */
 370   if (regstack->top <= 0)
 371     return;
 372
 373   COPY_HARD_REG_SET (temp_stack.reg_set, regstack->reg_set);
 374
 375   for (top = temp_stack.top = regstack->top; top >= 0; top--)
 376     temp_stack.reg[top] = FIRST_STACK_REG + temp_stack.top - top;
 377
 378   change_stack (insn, regstack, &temp_stack, EMIT_BEFORE);
 379 }
 380
 381 /* Pop a register from the stack.  */
 382
 383 static void
 384 pop_stack (stack regstack, int regno)
 385 {
 386   int top = regstack->top;
 387
 388   CLEAR_HARD_REG_BIT (regstack->reg_set, regno);
 389   regstack->top--;
 390   /* If regno was not at the top of stack then adjust stack.  */
 391   if (regstack->reg [top] != regno)
 392     {
 393       int i;
 394       for (i = regstack->top; i >= 0; i--)
 395         if (regstack->reg [i] == regno)
 396           {
 397             int j;
 398             for (j = i; j < top; j++)
 399               regstack->reg [j] = regstack->reg [j + 1];
 400             break;
 401           }
 402     }
 403 }
 404 \f
 405 /* Return a pointer to the REG expression within PAT.  If PAT is not a
 406    REG, possible enclosed by a conversion rtx, return the inner part of
 407    PAT that stopped the search.  */
 408
 409 static rtx *
 410 get_true_reg (rtx *pat)
 411 {
 412   for (;;)
 413     switch (GET_CODE (*pat))
 414       {
 415       case SUBREG:
 416         /* Eliminate FP subregister accesses in favor of the
 417            actual FP register in use.  */
 418         {
 419           rtx subreg;
 420           if (FP_REG_P (subreg = SUBREG_REG (*pat)))
 421             {
 422               int regno_off = subreg_regno_offset (REGNO (subreg),
 423                                                    GET_MODE (subreg),
 424                                                    SUBREG_BYTE (*pat),
 425                                                    GET_MODE (*pat));
 426               *pat = FP_MODE_REG (REGNO (subreg) + regno_off,
 427                                   GET_MODE (subreg));
 428               return pat;
 429             }
 430         }
 431       case FLOAT:
 432       case FIX:
 433       case FLOAT_EXTEND:
 434         pat = & XEXP (*pat, 0);
 435         break;
 436
 437       case UNSPEC:
 438         if (XINT (*pat, 1) == UNSPEC_TRUNC_NOOP)
 439           pat = & XVECEXP (*pat, 0, 0);
 440         return pat;
 441
 442       case FLOAT_TRUNCATE:
 443         if (!flag_unsafe_math_optimizations)
 444           return pat;
 445         pat = & XEXP (*pat, 0);
 446         break;
 447
 448       default:
 449         return pat;
 450       }
 451 }
 452 \f
 453 /* Set if we find any malformed asms in a block.  */
 454 static bool any_malformed_asm;
 455
 456 /* There are many rules that an asm statement for stack-like regs must
 457    follow.  Those rules are explained at the top of this file: the rule
 458    numbers below refer to that explanation.  */
 459
 460 static int
 461 check_asm_stack_operands (rtx insn)
 462 {
 463   int i;
 464   int n_clobbers;
 465   int malformed_asm = 0;
 466   rtx body = PATTERN (insn);
 467
 468   char reg_used_as_output[FIRST_PSEUDO_REGISTER];
 469   char implicitly_dies[FIRST_PSEUDO_REGISTER];
 470   int alt;
 471
 472   rtx *clobber_reg = 0;
 473   int n_inputs, n_outputs;
 474
 475   /* Find out what the constraints require.  If no constraint
 476      alternative matches, this asm is malformed.  */
 477   extract_insn (insn);
 478   constrain_operands (1);
 479   alt = which_alternative;
 480
 481   preprocess_constraints ();
 482
 483   n_inputs = get_asm_operand_n_inputs (body);
 484   n_outputs = recog_data.n_operands - n_inputs;
 485
 486   if (alt < 0)
 487     {
 488       malformed_asm = 1;
 489       /* Avoid further trouble with this insn.  */
 490       PATTERN (insn) = gen_rtx_USE (VOIDmode, const0_rtx);
 491       return 0;
 492     }
 493
 494   /* Strip SUBREGs here to make the following code simpler.  */
 495   for (i = 0; i < recog_data.n_operands; i++)
 496     if (GET_CODE (recog_data.operand[i]) == SUBREG
 497         && REG_P (SUBREG_REG (recog_data.operand[i])))
 498       recog_data.operand[i] = SUBREG_REG (recog_data.operand[i]);
 499
 500   /* Set up CLOBBER_REG.  */
 501
 502   n_clobbers = 0;
 503
 504   if (GET_CODE (body) == PARALLEL)
 505     {
 506       clobber_reg = alloca (XVECLEN (body, 0) * sizeof (rtx));
 507
 508       for (i = 0; i < XVECLEN (body, 0); i++)
 509         if (GET_CODE (XVECEXP (body, 0, i)) == CLOBBER)
 510           {
 511             rtx clobber = XVECEXP (body, 0, i);
 512             rtx reg = XEXP (clobber, 0);
 513
 514             if (GET_CODE (reg) == SUBREG && REG_P (SUBREG_REG (reg)))
 515               reg = SUBREG_REG (reg);
 516
 517             if (STACK_REG_P (reg))
 518               {
 519                 clobber_reg[n_clobbers] = reg;
 520                 n_clobbers++;
 521               }
 522           }
 523     }
 524
 525   /* Enforce rule #4: Output operands must specifically indicate which
 526      reg an output appears in after an asm.  "=f" is not allowed: the
 527      operand constraints must select a class with a single reg.
 528
 529      Also enforce rule #5: Output operands must start at the top of
 530      the reg-stack: output operands may not "skip" a reg.  */
 531
 532   memset (reg_used_as_output, 0, sizeof (reg_used_as_output));
 533   for (i = 0; i < n_outputs; i++)
 534     if (STACK_REG_P (recog_data.operand[i]))
 535       {
 536         if (reg_class_size[(int) recog_op_alt[i][alt].cl] != 1)
 537           {
 538             error_for_asm (insn, "output constraint %d must specify a single register", i);
 539             malformed_asm = 1;
 540           }
 541         else
 542           {
 543             int j;
 544
 545             for (j = 0; j < n_clobbers; j++)
 546               if (REGNO (recog_data.operand[i]) == REGNO (clobber_reg[j]))
 547                 {
 548                   error_for_asm (insn, "output constraint %d cannot be specified together with \"%s\" clobber",
 549                                  i, reg_names [REGNO (clobber_reg[j])]);
 550                   malformed_asm = 1;
 551                   break;
 552                 }
 553             if (j == n_clobbers)
 554               reg_used_as_output[REGNO (recog_data.operand[i])] = 1;
 555           }
 556       }
 557
 558
 559   /* Search for first non-popped reg.  */
 560   for (i = FIRST_STACK_REG; i < LAST_STACK_REG + 1; i++)
 561     if (! reg_used_as_output[i])
 562       break;
 563
 564   /* If there are any other popped regs, that's an error.  */
 565   for (; i < LAST_STACK_REG + 1; i++)
 566     if (reg_used_as_output[i])
 567       break;
 568
 569   if (i != LAST_STACK_REG + 1)
 570     {
 571       error_for_asm (insn, "output regs must be grouped at top of stack");
 572       malformed_asm = 1;
 573     }
 574
 575   /* Enforce rule #2: All implicitly popped input regs must be closer
 576      to the top of the reg-stack than any input that is not implicitly
 577      popped.  */
 578
 579   memset (implicitly_dies, 0, sizeof (implicitly_dies));
 580   for (i = n_outputs; i < n_outputs + n_inputs; i++)
 581     if (STACK_REG_P (recog_data.operand[i]))
 582       {
 583         /* An input reg is implicitly popped if it is tied to an
 584            output, or if there is a CLOBBER for it.  */
 585         int j;
 586
 587         for (j = 0; j < n_clobbers; j++)
 588           if (operands_match_p (clobber_reg[j], recog_data.operand[i]))
 589             break;
 590
 591         if (j < n_clobbers || recog_op_alt[i][alt].matches >= 0)
 592           implicitly_dies[REGNO (recog_data.operand[i])] = 1;
 593       }
 594
 595   /* Search for first non-popped reg.  */
 596   for (i = FIRST_STACK_REG; i < LAST_STACK_REG + 1; i++)
 597     if (! implicitly_dies[i])
 598       break;
 599
 600   /* If there are any other popped regs, that's an error.  */
 601   for (; i < LAST_STACK_REG + 1; i++)
 602     if (implicitly_dies[i])
 603       break;
 604
 605   if (i != LAST_STACK_REG + 1)
 606     {
 607       error_for_asm (insn,
 608                      "implicitly popped regs must be grouped at top of stack");
 609       malformed_asm = 1;
 610     }
 611
 612   /* Enforce rule #3: If any input operand uses the "f" constraint, all
 613      output constraints must use the "&" earlyclobber.
 614
 615      ??? Detect this more deterministically by having constrain_asm_operands
 616      record any earlyclobber.  */
 617
 618   for (i = n_outputs; i < n_outputs + n_inputs; i++)
 619     if (recog_op_alt[i][alt].matches == -1)
 620       {
 621         int j;
 622
 623         for (j = 0; j < n_outputs; j++)
 624           if (operands_match_p (recog_data.operand[j], recog_data.operand[i]))
 625             {
 626               error_for_asm (insn,
 627                              "output operand %d must use %<&%> constraint", j);
 628               malformed_asm = 1;
 629             }
 630       }
 631
 632   if (malformed_asm)
 633     {
 634       /* Avoid further trouble with this insn.  */
 635       PATTERN (insn) = gen_rtx_USE (VOIDmode, const0_rtx);
 636       any_malformed_asm = true;
 637       return 0;
 638     }
 639
 640   return 1;
 641 }
 642 \f
 643 /* Calculate the number of inputs and outputs in BODY, an
 644    asm_operands.  N_OPERANDS is the total number of operands, and
 645    N_INPUTS and N_OUTPUTS are pointers to ints into which the results are
 646    placed.  */
 647
 648 static int
 649 get_asm_operand_n_inputs (rtx body)
 650 {
 651   switch (GET_CODE (body))
 652     {
 653     case SET:
 654       gcc_assert (GET_CODE (SET_SRC (body)) == ASM_OPERANDS);
 655       return ASM_OPERANDS_INPUT_LENGTH (SET_SRC (body));
 656
 657     case ASM_OPERANDS:
 658       return ASM_OPERANDS_INPUT_LENGTH (body);
 659
 660     case PARALLEL:
 661       return get_asm_operand_n_inputs (XVECEXP (body, 0, 0));
 662
 663     default:
 664       gcc_unreachable ();
 665     }
 666 }
 667
 668 /* If current function returns its result in an fp stack register,
 669    return the REG.  Otherwise, return 0.  */
 670
 671 static rtx
 672 stack_result (tree decl)
 673 {
 674   rtx result;
 675
 676   /* If the value is supposed to be returned in memory, then clearly
 677      it is not returned in a stack register.  */
 678   if (aggregate_value_p (DECL_RESULT (decl), decl))
 679     return 0;
 680
 681   result = DECL_RTL_IF_SET (DECL_RESULT (decl));
 682   if (result != 0)
 683     result = targetm.calls.function_value (TREE_TYPE (DECL_RESULT (decl)),
 684                                            decl, true);
 685
 686   return result != 0 && STACK_REG_P (result) ? result : 0;
 687 }
 688 \f
 689
 690 /*
 691  * This section deals with stack register substitution, and forms the second
 692  * pass over the RTL.
 693  */
 694
 695 /* Replace REG, which is a pointer to a stack reg RTX, with an RTX for
 696    the desired hard REGNO.  */
 697
 698 static void
 699 replace_reg (rtx *reg, int regno)
 700 {
 701   gcc_assert (IN_RANGE (regno, FIRST_STACK_REG, LAST_STACK_REG));
 702   gcc_assert (STACK_REG_P (*reg));
 703
 704   gcc_assert (SCALAR_FLOAT_MODE_P (GET_MODE (*reg))
 705               || GET_MODE_CLASS (GET_MODE (*reg)) == MODE_COMPLEX_FLOAT);
 706
 707   *reg = FP_MODE_REG (regno, GET_MODE (*reg));
 708 }
 709
 710 /* Remove a note of type NOTE, which must be found, for register
 711    number REGNO from INSN.  Remove only one such note.  */
 712
 713 static void
 714 remove_regno_note (rtx insn, enum reg_note note, unsigned int regno)
 715 {
 716   rtx *note_link, this;
 717
 718   note_link = &REG_NOTES (insn);
 719   for (this = *note_link; this; this = XEXP (this, 1))
 720     if (REG_NOTE_KIND (this) == note
 721         && REG_P (XEXP (this, 0)) && REGNO (XEXP (this, 0)) == regno)
 722       {
 723         *note_link = XEXP (this, 1);
 724         return;
 725       }
 726     else
 727       note_link = &XEXP (this, 1);
 728
 729   gcc_unreachable ();
 730 }
 731
 732 /* Find the hard register number of virtual register REG in REGSTACK.
 733    The hard register number is relative to the top of the stack.  -1 is
 734    returned if the register is not found.  */
 735
 736 static int
 737 get_hard_regnum (stack regstack, rtx reg)
 738 {
 739   int i;
 740
 741   gcc_assert (STACK_REG_P (reg));
 742
 743   for (i = regstack->top; i >= 0; i--)
 744     if (regstack->reg[i] == REGNO (reg))
 745       break;
 746
 747   return i >= 0 ? (FIRST_STACK_REG + regstack->top - i) : -1;
 748 }
 749 \f
 750 /* Emit an insn to pop virtual register REG before or after INSN.
 751    REGSTACK is the stack state after INSN and is updated to reflect this
 752    pop.  WHEN is either emit_insn_before or emit_insn_after.  A pop insn
 753    is represented as a SET whose destination is the register to be popped
 754    and source is the top of stack.  A death note for the top of stack
 755    cases the movdf pattern to pop.  */
 756
 757 static rtx
 758 emit_pop_insn (rtx insn, stack regstack, rtx reg, enum emit_where where)
 759 {
 760   rtx pop_insn, pop_rtx;
 761   int hard_regno;
 762
 763   /* For complex types take care to pop both halves.  These may survive in
 764      CLOBBER and USE expressions.  */
 765   if (COMPLEX_MODE_P (GET_MODE (reg)))
 766     {
 767       rtx reg1 = FP_MODE_REG (REGNO (reg), DFmode);
 768       rtx reg2 = FP_MODE_REG (REGNO (reg) + 1, DFmode);
 769
 770       pop_insn = NULL_RTX;
 771       if (get_hard_regnum (regstack, reg1) >= 0)
 772         pop_insn = emit_pop_insn (insn, regstack, reg1, where);
 773       if (get_hard_regnum (regstack, reg2) >= 0)
 774         pop_insn = emit_pop_insn (insn, regstack, reg2, where);
 775       gcc_assert (pop_insn);
 776       return pop_insn;
 777     }
 778
 779   hard_regno = get_hard_regnum (regstack, reg);
 780
 781   gcc_assert (hard_regno >= FIRST_STACK_REG);
 782
 783   pop_rtx = gen_rtx_SET (VOIDmode, FP_MODE_REG (hard_regno, DFmode),
 784                          FP_MODE_REG (FIRST_STACK_REG, DFmode));
 785
 786   if (where == EMIT_AFTER)
 787     pop_insn = emit_insn_after (pop_rtx, insn);
 788   else
 789     pop_insn = emit_insn_before (pop_rtx, insn);
 790
 791   REG_NOTES (pop_insn)
 792     = gen_rtx_EXPR_LIST (REG_DEAD, FP_MODE_REG (FIRST_STACK_REG, DFmode),
 793                          REG_NOTES (pop_insn));
 794
 795   regstack->reg[regstack->top - (hard_regno - FIRST_STACK_REG)]
 796     = regstack->reg[regstack->top];
 797   regstack->top -= 1;
 798   CLEAR_HARD_REG_BIT (regstack->reg_set, REGNO (reg));
 799
 800   return pop_insn;
 801 }
 802 \f
 803 /* Emit an insn before or after INSN to swap virtual register REG with
 804    the top of stack.  REGSTACK is the stack state before the swap, and
 805    is updated to reflect the swap.  A swap insn is represented as a
 806    PARALLEL of two patterns: each pattern moves one reg to the other.
 807
 808    If REG is already at the top of the stack, no insn is emitted.  */
 809
 810 static void
 811 emit_swap_insn (rtx insn, stack regstack, rtx reg)
 812 {
 813   int hard_regno;
 814   rtx swap_rtx;
 815   int tmp, other_reg;           /* swap regno temps */
 816   rtx i1;                       /* the stack-reg insn prior to INSN */
 817   rtx i1set = NULL_RTX;         /* the SET rtx within I1 */
 818
 819   hard_regno = get_hard_regnum (regstack, reg);
 820
 821   if (hard_regno == FIRST_STACK_REG)
 822     return;
 823   if (hard_regno == -1)
 824     {
 825       /* Something failed if the register wasn't on the stack.  If we had
 826          malformed asms, we zapped the instruction itself, but that didn't
 827          produce the same pattern of register sets as before.  To prevent
 828          further failure, adjust REGSTACK to include REG at TOP.  */
 829       gcc_assert (any_malformed_asm);
 830       regstack->reg[++regstack->top] = REGNO (reg);
 831       return;
 832     }
 833   gcc_assert (hard_regno >= FIRST_STACK_REG);
 834
 835   other_reg = regstack->top - (hard_regno - FIRST_STACK_REG);
 836
 837   tmp = regstack->reg[other_reg];
 838   regstack->reg[other_reg] = regstack->reg[regstack->top];
 839   regstack->reg[regstack->top] = tmp;
 840
 841   /* Find the previous insn involving stack regs, but don't pass a
 842      block boundary.  */
 843   i1 = NULL;
 844   if (current_block && insn != BB_HEAD (current_block))
 845     {
 846       rtx tmp = PREV_INSN (insn);
 847       rtx limit = PREV_INSN (BB_HEAD (current_block));
 848       while (tmp != limit)
 849         {
 850           if (LABEL_P (tmp)
 851               || CALL_P (tmp)
 852               || NOTE_INSN_BASIC_BLOCK_P (tmp)
 853               || (NONJUMP_INSN_P (tmp)
 854                   && stack_regs_mentioned (tmp)))
 855             {
 856               i1 = tmp;
 857               break;
 858             }
 859           tmp = PREV_INSN (tmp);
 860         }
 861     }
 862
 863   if (i1 != NULL_RTX
 864       && (i1set = single_set (i1)) != NULL_RTX)
 865     {
 866       rtx i1src = *get_true_reg (&SET_SRC (i1set));
 867       rtx i1dest = *get_true_reg (&SET_DEST (i1set));
 868
 869       /* If the previous register stack push was from the reg we are to
 870          swap with, omit the swap.  */
 871
 872       if (REG_P (i1dest) && REGNO (i1dest) == FIRST_STACK_REG
 873           && REG_P (i1src)
 874           && REGNO (i1src) == (unsigned) hard_regno - 1
 875           && find_regno_note (i1, REG_DEAD, FIRST_STACK_REG) == NULL_RTX)
 876         return;
 877
 878       /* If the previous insn wrote to the reg we are to swap with,
 879          omit the swap.  */
 880
 881       if (REG_P (i1dest) && REGNO (i1dest) == (unsigned) hard_regno
 882           && REG_P (i1src) && REGNO (i1src) == FIRST_STACK_REG
 883           && find_regno_note (i1, REG_DEAD, FIRST_STACK_REG) == NULL_RTX)
 884         return;
 885     }
 886
 887   /* Avoid emitting the swap if this is the first register stack insn
 888      of the current_block.  Instead update the current_block's stack_in
 889      and let compensate edges take care of this for us.  */
 890   if (current_block && starting_stack_p)
 891     {
 892       BLOCK_INFO (current_block)->stack_in = *regstack;
 893       starting_stack_p = false;
 894       return;
 895     }
 896
 897   swap_rtx = gen_swapxf (FP_MODE_REG (hard_regno, XFmode),
 898                          FP_MODE_REG (FIRST_STACK_REG, XFmode));
 899
 900   if (i1)
 901     emit_insn_after (swap_rtx, i1);
 902   else if (current_block)
 903     emit_insn_before (swap_rtx, BB_HEAD (current_block));
 904   else
 905     emit_insn_before (swap_rtx, insn);
 906 }
 907 \f
 908 /* Emit an insns before INSN to swap virtual register SRC1 with
 909    the top of stack and virtual register SRC2 with second stack
 910    slot. REGSTACK is the stack state before the swaps, and
 911    is updated to reflect the swaps.  A swap insn is represented as a
 912    PARALLEL of two patterns: each pattern moves one reg to the other.
 913
 914    If SRC1 and/or SRC2 are already at the right place, no swap insn
 915    is emitted.  */
 916
 917 static void
 918 swap_to_top (rtx insn, stack regstack, rtx src1, rtx src2)
 919 {
 920   struct stack_def temp_stack;
 921   int regno, j, k, temp;
 922
 923   temp_stack = *regstack;
 924
 925   /* Place operand 1 at the top of stack.  */
 926   regno = get_hard_regnum (&temp_stack, src1);
 927   gcc_assert (regno >= 0);
 928   if (regno != FIRST_STACK_REG)
 929     {
 930       k = temp_stack.top - (regno - FIRST_STACK_REG);
 931       j = temp_stack.top;
 932
 933       temp = temp_stack.reg[k];
 934       temp_stack.reg[k] = temp_stack.reg[j];
 935       temp_stack.reg[j] = temp;
 936     }
 937
 938   /* Place operand 2 next on the stack.  */
 939   regno = get_hard_regnum (&temp_stack, src2);
 940   gcc_assert (regno >= 0);
 941   if (regno != FIRST_STACK_REG + 1)
 942     {
 943       k = temp_stack.top - (regno - FIRST_STACK_REG);
 944       j = temp_stack.top - 1;
 945
 946       temp = temp_stack.reg[k];
 947       temp_stack.reg[k] = temp_stack.reg[j];
 948       temp_stack.reg[j] = temp;
 949     }
 950
 951   change_stack (insn, regstack, &temp_stack, EMIT_BEFORE);
 952 }
 953 \f
 954 /* Handle a move to or from a stack register in PAT, which is in INSN.
 955    REGSTACK is the current stack.  Return whether a control flow insn
 956    was deleted in the process.  */
 957
 958 static bool
 959 move_for_stack_reg (rtx insn, stack regstack, rtx pat)
 960 {
 961   rtx *psrc =  get_true_reg (&SET_SRC (pat));
 962   rtx *pdest = get_true_reg (&SET_DEST (pat));
 963   rtx src, dest;
 964   rtx note;
 965   bool control_flow_insn_deleted = false;
 966
 967   src = *psrc; dest = *pdest;
 968
 969   if (STACK_REG_P (src) && STACK_REG_P (dest))
 970     {
 971       /* Write from one stack reg to another.  If SRC dies here, then
 972          just change the register mapping and delete the insn.  */
 973
 974       note = find_regno_note (insn, REG_DEAD, REGNO (src));
 975       if (note)
 976         {
 977           int i;
 978
 979           /* If this is a no-op move, there must not be a REG_DEAD note.  */
 980           gcc_assert (REGNO (src) != REGNO (dest));
 981
 982           for (i = regstack->top; i >= 0; i--)
 983             if (regstack->reg[i] == REGNO (src))
 984               break;
 985
 986           /* The destination must be dead, or life analysis is borked.  */
 987           gcc_assert (get_hard_regnum (regstack, dest) < FIRST_STACK_REG);
 988
 989           /* If the source is not live, this is yet another case of
 990              uninitialized variables.  Load up a NaN instead.  */
 991           if (i < 0)
 992             return move_nan_for_stack_reg (insn, regstack, dest);
 993
 994           /* It is possible that the dest is unused after this insn.
 995              If so, just pop the src.  */
 996
 997           if (find_regno_note (insn, REG_UNUSED, REGNO (dest)))
 998             emit_pop_insn (insn, regstack, src, EMIT_AFTER);
 999           else
1000             {
1001               regstack->reg[i] = REGNO (dest);
1002               SET_HARD_REG_BIT (regstack->reg_set, REGNO (dest));
1003               CLEAR_HARD_REG_BIT (regstack->reg_set, REGNO (src));
1004             }
1005
1006           control_flow_insn_deleted |= control_flow_insn_p (insn);
1007           delete_insn (insn);
1008           return control_flow_insn_deleted;
1009         }
1010
1011       /* The source reg does not die.  */
1012
1013       /* If this appears to be a no-op move, delete it, or else it
1014          will confuse the machine description output patterns. But if
1015          it is REG_UNUSED, we must pop the reg now, as per-insn processing
1016          for REG_UNUSED will not work for deleted insns.  */
1017
1018       if (REGNO (src) == REGNO (dest))
1019         {
1020           if (find_regno_note (insn, REG_UNUSED, REGNO (dest)))
1021             emit_pop_insn (insn, regstack, dest, EMIT_AFTER);
1022
1023           control_flow_insn_deleted |= control_flow_insn_p (insn);
1024           delete_insn (insn);
1025           return control_flow_insn_deleted;
1026         }
1027
1028       /* The destination ought to be dead.  */
1029       gcc_assert (get_hard_regnum (regstack, dest) < FIRST_STACK_REG);
1030
1031       replace_reg (psrc, get_hard_regnum (regstack, src));
1032
1033       regstack->reg[++regstack->top] = REGNO (dest);
1034       SET_HARD_REG_BIT (regstack->reg_set, REGNO (dest));
1035       replace_reg (pdest, FIRST_STACK_REG);
1036     }
1037   else if (STACK_REG_P (src))
1038     {
1039       /* Save from a stack reg to MEM, or possibly integer reg.  Since
1040          only top of stack may be saved, emit an exchange first if
1041          needs be.  */
1042
1043       emit_swap_insn (insn, regstack, src);
1044
1045       note = find_regno_note (insn, REG_DEAD, REGNO (src));
1046       if (note)
1047         {
1048           replace_reg (&XEXP (note, 0), FIRST_STACK_REG);
1049           regstack->top--;
1050           CLEAR_HARD_REG_BIT (regstack->reg_set, REGNO (src));
1051         }
1052       else if ((GET_MODE (src) == XFmode)
1053                && regstack->top < REG_STACK_SIZE - 1)
1054         {
1055           /* A 387 cannot write an XFmode value to a MEM without
1056              clobbering the source reg.  The output code can handle
1057              this by reading back the value from the MEM.
1058              But it is more efficient to use a temp register if one is
1059              available.  Push the source value here if the register
1060              stack is not full, and then write the value to memory via
1061              a pop.  */
1062           rtx push_rtx;
1063           rtx top_stack_reg = FP_MODE_REG (FIRST_STACK_REG, GET_MODE (src));
1064
1065           push_rtx = gen_movxf (top_stack_reg, top_stack_reg);
1066           emit_insn_before (push_rtx, insn);
1067           REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_DEAD, top_stack_reg,
1068                                                 REG_NOTES (insn));
1069         }
1070
1071       replace_reg (psrc, FIRST_STACK_REG);
1072     }
1073   else
1074     {
1075       rtx pat = PATTERN (insn);
1076
1077       gcc_assert (STACK_REG_P (dest));
1078
1079       /* Load from MEM, or possibly integer REG or constant, into the
1080          stack regs.  The actual target is always the top of the
1081          stack. The stack mapping is changed to reflect that DEST is
1082          now at top of stack.  */
1083
1084       /* The destination ought to be dead.  However, there is a
1085          special case with i387 UNSPEC_TAN, where destination is live
1086          (an argument to fptan) but inherent load of 1.0 is modelled
1087          as a load from a constant.  */
1088       if (! (GET_CODE (pat) == PARALLEL
1089              && XVECLEN (pat, 0) == 2
1090              && GET_CODE (XVECEXP (pat, 0, 1)) == SET
1091              && GET_CODE (SET_SRC (XVECEXP (pat, 0, 1))) == UNSPEC
1092              && XINT (SET_SRC (XVECEXP (pat, 0, 1)), 1) == UNSPEC_TAN))
1093         gcc_assert (get_hard_regnum (regstack, dest) < FIRST_STACK_REG);
1094
1095       gcc_assert (regstack->top < REG_STACK_SIZE);
1096
1097       regstack->reg[++regstack->top] = REGNO (dest);
1098       SET_HARD_REG_BIT (regstack->reg_set, REGNO (dest));
1099       replace_reg (pdest, FIRST_STACK_REG);
1100     }
1101
1102   return control_flow_insn_deleted;
1103 }
1104
1105 /* A helper function which replaces INSN with a pattern that loads up
1106    a NaN into DEST, then invokes move_for_stack_reg.  */
1107
1108 static bool
1109 move_nan_for_stack_reg (rtx insn, stack regstack, rtx dest)
1110 {
1111   rtx pat;
1112
1113   dest = FP_MODE_REG (REGNO (dest), SFmode);
1114   pat = gen_rtx_SET (VOIDmode, dest, not_a_num);
1115   PATTERN (insn) = pat;
1116   INSN_CODE (insn) = -1;
1117
1118   return move_for_stack_reg (insn, regstack, pat);
1119 }
1120 \f
1121 /* Swap the condition on a branch, if there is one.  Return true if we
1122    found a condition to swap.  False if the condition was not used as
1123    such.  */
1124
1125 static int
1126 swap_rtx_condition_1 (rtx pat)
1127 {
1128   const char *fmt;
1129   int i, r = 0;
1130
1131   if (COMPARISON_P (pat))
1132     {
1133       PUT_CODE (pat, swap_condition (GET_CODE (pat)));
1134       r = 1;
1135     }
1136   else
1137     {
1138       fmt = GET_RTX_FORMAT (GET_CODE (pat));
1139       for (i = GET_RTX_LENGTH (GET_CODE (pat)) - 1; i >= 0; i--)
1140         {
1141           if (fmt[i] == 'E')
1142             {
1143               int j;
1144
1145               for (j = XVECLEN (pat, i) - 1; j >= 0; j--)
1146                 r |= swap_rtx_condition_1 (XVECEXP (pat, i, j));
1147             }
1148           else if (fmt[i] == 'e')
1149             r |= swap_rtx_condition_1 (XEXP (pat, i));
1150         }
1151     }
1152
1153   return r;
1154 }
1155
1156 static int
1157 swap_rtx_condition (rtx insn)
1158 {
1159   rtx pat = PATTERN (insn);
1160
1161   /* We're looking for a single set to cc0 or an HImode temporary.  */
1162
1163   if (GET_CODE (pat) == SET
1164       && REG_P (SET_DEST (pat))
1165       && REGNO (SET_DEST (pat)) == FLAGS_REG)
1166     {
1167       insn = next_flags_user (insn);
1168       if (insn == NULL_RTX)
1169         return 0;
1170       pat = PATTERN (insn);
1171     }
1172
1173   /* See if this is, or ends in, a fnstsw.  If so, we're not doing anything
1174      with the cc value right now.  We may be able to search for one
1175      though.  */
1176
1177   if (GET_CODE (pat) == SET
1178       && GET_CODE (SET_SRC (pat)) == UNSPEC
1179       && XINT (SET_SRC (pat), 1) == UNSPEC_FNSTSW)
1180     {
1181       rtx dest = SET_DEST (pat);
1182
1183       /* Search forward looking for the first use of this value.
1184          Stop at block boundaries.  */
1185       while (insn != BB_END (current_block))
1186         {
1187           insn = NEXT_INSN (insn);
1188           if (INSN_P (insn) && reg_mentioned_p (dest, insn))
1189             break;
1190           if (CALL_P (insn))
1191             return 0;
1192         }
1193
1194       /* We haven't found it.  */
1195       if (insn == BB_END (current_block))
1196         return 0;
1197
1198       /* So we've found the insn using this value.  If it is anything
1199          other than sahf or the value does not die (meaning we'd have
1200          to search further), then we must give up.  */
1201       pat = PATTERN (insn);
1202       if (GET_CODE (pat) != SET
1203           || GET_CODE (SET_SRC (pat)) != UNSPEC
1204           || XINT (SET_SRC (pat), 1) != UNSPEC_SAHF
1205           || ! dead_or_set_p (insn, dest))
1206         return 0;
1207
1208       /* Now we are prepared to handle this as a normal cc0 setter.  */
1209       insn = next_flags_user (insn);
1210       if (insn == NULL_RTX)
1211         return 0;
1212       pat = PATTERN (insn);
1213     }
1214
1215   if (swap_rtx_condition_1 (pat))
1216     {
1217       int fail = 0;
1218       INSN_CODE (insn) = -1;
1219       if (recog_memoized (insn) == -1)
1220         fail = 1;
1221       /* In case the flags don't die here, recurse to try fix
1222          following user too.  */
1223       else if (! dead_or_set_p (insn, ix86_flags_rtx))
1224         {
1225           insn = next_flags_user (insn);
1226           if (!insn || !swap_rtx_condition (insn))
1227             fail = 1;
1228         }
1229       if (fail)
1230         {
1231           swap_rtx_condition_1 (pat);
1232           return 0;
1233         }
1234       return 1;
1235     }
1236   return 0;
1237 }
1238
1239 /* Handle a comparison.  Special care needs to be taken to avoid
1240    causing comparisons that a 387 cannot do correctly, such as EQ.
1241
1242    Also, a pop insn may need to be emitted.  The 387 does have an
1243    `fcompp' insn that can pop two regs, but it is sometimes too expensive
1244    to do this - a `fcomp' followed by a `fstpl %st(0)' may be easier to
1245    set up.  */
1246
1247 static void
1248 compare_for_stack_reg (rtx insn, stack regstack, rtx pat_src)
1249 {
1250   rtx *src1, *src2;
1251   rtx src1_note, src2_note;
1252
1253   src1 = get_true_reg (&XEXP (pat_src, 0));
1254   src2 = get_true_reg (&XEXP (pat_src, 1));
1255
1256   /* ??? If fxch turns out to be cheaper than fstp, give priority to
1257      registers that die in this insn - move those to stack top first.  */
1258   if ((! STACK_REG_P (*src1)
1259        || (STACK_REG_P (*src2)
1260            && get_hard_regnum (regstack, *src2) == FIRST_STACK_REG))
1261       && swap_rtx_condition (insn))
1262     {
1263       rtx temp;
1264       temp = XEXP (pat_src, 0);
1265       XEXP (pat_src, 0) = XEXP (pat_src, 1);
1266       XEXP (pat_src, 1) = temp;
1267
1268       src1 = get_true_reg (&XEXP (pat_src, 0));
1269       src2 = get_true_reg (&XEXP (pat_src, 1));
1270
1271       INSN_CODE (insn) = -1;
1272     }
1273
1274   /* We will fix any death note later.  */
1275
1276   src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
1277
1278   if (STACK_REG_P (*src2))
1279     src2_note = find_regno_note (insn, REG_DEAD, REGNO (*src2));
1280   else
1281     src2_note = NULL_RTX;
1282
1283   emit_swap_insn (insn, regstack, *src1);
1284
1285   replace_reg (src1, FIRST_STACK_REG);
1286
1287   if (STACK_REG_P (*src2))
1288     replace_reg (src2, get_hard_regnum (regstack, *src2));
1289
1290   if (src1_note)
1291     {
1292       pop_stack (regstack, REGNO (XEXP (src1_note, 0)));
1293       replace_reg (&XEXP (src1_note, 0), FIRST_STACK_REG);
1294     }
1295
1296   /* If the second operand dies, handle that.  But if the operands are
1297      the same stack register, don't bother, because only one death is
1298      needed, and it was just handled.  */
1299
1300   if (src2_note
1301       && ! (STACK_REG_P (*src1) && STACK_REG_P (*src2)
1302             && REGNO (*src1) == REGNO (*src2)))
1303     {
1304       /* As a special case, two regs may die in this insn if src2 is
1305          next to top of stack and the top of stack also dies.  Since
1306          we have already popped src1, "next to top of stack" is really
1307          at top (FIRST_STACK_REG) now.  */
1308
1309       if (get_hard_regnum (regstack, XEXP (src2_note, 0)) == FIRST_STACK_REG
1310           && src1_note)
1311         {
1312           pop_stack (regstack, REGNO (XEXP (src2_note, 0)));
1313           replace_reg (&XEXP (src2_note, 0), FIRST_STACK_REG + 1);
1314         }
1315       else
1316         {
1317           /* The 386 can only represent death of the first operand in
1318              the case handled above.  In all other cases, emit a separate
1319              pop and remove the death note from here.  */
1320
1321           /* link_cc0_insns (insn); */
1322
1323           remove_regno_note (insn, REG_DEAD, REGNO (XEXP (src2_note, 0)));
1324
1325           emit_pop_insn (insn, regstack, XEXP (src2_note, 0),
1326                          EMIT_AFTER);
1327         }
1328     }
1329 }
1330 \f
1331 /* Substitute new registers in PAT, which is part of INSN.  REGSTACK
1332    is the current register layout.  Return whether a control flow insn
1333    was deleted in the process.  */
1334
1335 static bool
1336 subst_stack_regs_pat (rtx insn, stack regstack, rtx pat)
1337 {
1338   rtx *dest, *src;
1339   bool control_flow_insn_deleted = false;
1340
1341   switch (GET_CODE (pat))
1342     {
1343     case USE:
1344       /* Deaths in USE insns can happen in non optimizing compilation.
1345          Handle them by popping the dying register.  */
1346       src = get_true_reg (&XEXP (pat, 0));
1347       if (STACK_REG_P (*src)
1348           && find_regno_note (insn, REG_DEAD, REGNO (*src)))
1349         {
1350           /* USEs are ignored for liveness information so USEs of dead
1351              register might happen.  */
1352           if (TEST_HARD_REG_BIT (regstack->reg_set, REGNO (*src)))
1353             emit_pop_insn (insn, regstack, *src, EMIT_AFTER);
1354           return control_flow_insn_deleted;
1355         }
1356       /* Uninitialized USE might happen for functions returning uninitialized
1357          value.  We will properly initialize the USE on the edge to EXIT_BLOCK,
1358          so it is safe to ignore the use here. This is consistent with behavior
1359          of dataflow analyzer that ignores USE too.  (This also imply that
1360          forcibly initializing the register to NaN here would lead to ICE later,
1361          since the REG_DEAD notes are not issued.)  */
1362       break;
1363
1364     case CLOBBER:
1365       {
1366         rtx note;
1367
1368         dest = get_true_reg (&XEXP (pat, 0));
1369         if (STACK_REG_P (*dest))
1370           {
1371             note = find_reg_note (insn, REG_DEAD, *dest);
1372
1373             if (pat != PATTERN (insn))
1374               {
1375                 /* The fix_truncdi_1 pattern wants to be able to allocate
1376                    its own scratch register.  It does this by clobbering
1377                    an fp reg so that it is assured of an empty reg-stack
1378                    register.  If the register is live, kill it now.
1379                    Remove the DEAD/UNUSED note so we don't try to kill it
1380                    later too.  */
1381
1382                 if (note)
1383                   emit_pop_insn (insn, regstack, *dest, EMIT_BEFORE);
1384                 else
1385                   {
1386                     note = find_reg_note (insn, REG_UNUSED, *dest);
1387                     gcc_assert (note);
1388                   }
1389                 remove_note (insn, note);
1390                 replace_reg (dest, FIRST_STACK_REG + 1);
1391               }
1392             else
1393               {
1394                 /* A top-level clobber with no REG_DEAD, and no hard-regnum
1395                    indicates an uninitialized value.  Because reload removed
1396                    all other clobbers, this must be due to a function
1397                    returning without a value.  Load up a NaN.  */
1398
1399                 if (!note)
1400                   {
1401                     rtx t = *dest;
1402                     if (COMPLEX_MODE_P (GET_MODE (t)))
1403                       {
1404                         rtx u = FP_MODE_REG (REGNO (t) + 1, SFmode);
1405                         if (get_hard_regnum (regstack, u) == -1)
1406                           {
1407                             rtx pat2 = gen_rtx_CLOBBER (VOIDmode, u);
1408                             rtx insn2 = emit_insn_before (pat2, insn);
1409                             control_flow_insn_deleted
1410                               |= move_nan_for_stack_reg (insn2, regstack, u);
1411                           }
1412                       }
1413                     if (get_hard_regnum (regstack, t) == -1)
1414                       control_flow_insn_deleted
1415                         |= move_nan_for_stack_reg (insn, regstack, t);
1416                   }
1417               }
1418           }
1419         break;
1420       }
1421
1422     case SET:
1423       {
1424         rtx *src1 = (rtx *) 0, *src2;
1425         rtx src1_note, src2_note;
1426         rtx pat_src;
1427
1428         dest = get_true_reg (&SET_DEST (pat));
1429         src  = get_true_reg (&SET_SRC (pat));
1430         pat_src = SET_SRC (pat);
1431
1432         /* See if this is a `movM' pattern, and handle elsewhere if so.  */
1433         if (STACK_REG_P (*src)
1434             || (STACK_REG_P (*dest)
1435                 && (REG_P (*src) || MEM_P (*src)
1436                     || GET_CODE (*src) == CONST_DOUBLE)))
1437           {
1438             control_flow_insn_deleted |= move_for_stack_reg (insn, regstack, pat);
1439             break;
1440           }
1441
1442         switch (GET_CODE (pat_src))
1443           {
1444           case COMPARE:
1445             compare_for_stack_reg (insn, regstack, pat_src);
1446             break;
1447
1448           case CALL:
1449             {
1450               int count;
1451               for (count = hard_regno_nregs[REGNO (*dest)][GET_MODE (*dest)];
1452                    --count >= 0;)
1453                 {
1454                   regstack->reg[++regstack->top] = REGNO (*dest) + count;
1455                   SET_HARD_REG_BIT (regstack->reg_set, REGNO (*dest) + count);
1456                 }
1457             }
1458             replace_reg (dest, FIRST_STACK_REG);
1459             break;
1460
1461           case REG:
1462             /* This is a `tstM2' case.  */
1463             gcc_assert (*dest == cc0_rtx);
1464             src1 = src;
1465
1466             /* Fall through.  */
1467
1468           case FLOAT_TRUNCATE:
1469           case SQRT:
1470           case ABS:
1471           case NEG:
1472             /* These insns only operate on the top of the stack. DEST might
1473                be cc0_rtx if we're processing a tstM pattern. Also, it's
1474                possible that the tstM case results in a REG_DEAD note on the
1475                source.  */
1476
1477             if (src1 == 0)
1478               src1 = get_true_reg (&XEXP (pat_src, 0));
1479
1480             emit_swap_insn (insn, regstack, *src1);
1481
1482             src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
1483
1484             if (STACK_REG_P (*dest))
1485               replace_reg (dest, FIRST_STACK_REG);
1486
1487             if (src1_note)
1488               {
1489                 replace_reg (&XEXP (src1_note, 0), FIRST_STACK_REG);
1490                 regstack->top--;
1491                 CLEAR_HARD_REG_BIT (regstack->reg_set, REGNO (*src1));
1492               }
1493
1494             replace_reg (src1, FIRST_STACK_REG);
1495             break;
1496
1497           case MINUS:
1498           case DIV:
1499             /* On i386, reversed forms of subM3 and divM3 exist for
1500                MODE_FLOAT, so the same code that works for addM3 and mulM3
1501                can be used.  */
1502           case MULT:
1503           case PLUS:
1504             /* These insns can accept the top of stack as a destination
1505                from a stack reg or mem, or can use the top of stack as a
1506                source and some other stack register (possibly top of stack)
1507                as a destination.  */
1508
1509             src1 = get_true_reg (&XEXP (pat_src, 0));
1510             src2 = get_true_reg (&XEXP (pat_src, 1));
1511
1512             /* We will fix any death note later.  */
1513
1514             if (STACK_REG_P (*src1))
1515               src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
1516             else
1517               src1_note = NULL_RTX;
1518             if (STACK_REG_P (*src2))
1519               src2_note = find_regno_note (insn, REG_DEAD, REGNO (*src2));
1520             else
1521               src2_note = NULL_RTX;
1522
1523             /* If either operand is not a stack register, then the dest
1524                must be top of stack.  */
1525
1526             if (! STACK_REG_P (*src1) || ! STACK_REG_P (*src2))
1527               emit_swap_insn (insn, regstack, *dest);
1528             else
1529               {
1530                 /* Both operands are REG.  If neither operand is already
1531                    at the top of stack, choose to make the one that is the dest
1532                    the new top of stack.  */
1533
1534                 int src1_hard_regnum, src2_hard_regnum;
1535
1536                 src1_hard_regnum = get_hard_regnum (regstack, *src1);
1537                 src2_hard_regnum = get_hard_regnum (regstack, *src2);
1538                 gcc_assert (src1_hard_regnum != -1);
1539                 gcc_assert (src2_hard_regnum != -1);
1540
1541                 if (src1_hard_regnum != FIRST_STACK_REG
1542                     && src2_hard_regnum != FIRST_STACK_REG)
1543                   emit_swap_insn (insn, regstack, *dest);
1544               }
1545
1546             if (STACK_REG_P (*src1))
1547               replace_reg (src1, get_hard_regnum (regstack, *src1));
1548             if (STACK_REG_P (*src2))
1549               replace_reg (src2, get_hard_regnum (regstack, *src2));
1550
1551             if (src1_note)
1552               {
1553                 rtx src1_reg = XEXP (src1_note, 0);
1554
1555                 /* If the register that dies is at the top of stack, then
1556                    the destination is somewhere else - merely substitute it.
1557                    But if the reg that dies is not at top of stack, then
1558                    move the top of stack to the dead reg, as though we had
1559                    done the insn and then a store-with-pop.  */
1560
1561                 if (REGNO (src1_reg) == regstack->reg[regstack->top])
1562                   {
1563                     SET_HARD_REG_BIT (regstack->reg_set, REGNO (*dest));
1564                     replace_reg (dest, get_hard_regnum (regstack, *dest));
1565                   }
1566                 else
1567                   {
1568                     int regno = get_hard_regnum (regstack, src1_reg);
1569
1570                     SET_HARD_REG_BIT (regstack->reg_set, REGNO (*dest));
1571                     replace_reg (dest, regno);
1572
1573                     regstack->reg[regstack->top - (regno - FIRST_STACK_REG)]
1574                       = regstack->reg[regstack->top];
1575                   }
1576
1577                 CLEAR_HARD_REG_BIT (regstack->reg_set,
1578                                     REGNO (XEXP (src1_note, 0)));
1579                 replace_reg (&XEXP (src1_note, 0), FIRST_STACK_REG);
1580                 regstack->top--;
1581               }
1582             else if (src2_note)
1583               {
1584                 rtx src2_reg = XEXP (src2_note, 0);
1585                 if (REGNO (src2_reg) == regstack->reg[regstack->top])
1586                   {
1587                     SET_HARD_REG_BIT (regstack->reg_set, REGNO (*dest));
1588                     replace_reg (dest, get_hard_regnum (regstack, *dest));
1589                   }
1590                 else
1591                   {
1592                     int regno = get_hard_regnum (regstack, src2_reg);
1593
1594                     SET_HARD_REG_BIT (regstack->reg_set, REGNO (*dest));
1595                     replace_reg (dest, regno);
1596
1597                     regstack->reg[regstack->top - (regno - FIRST_STACK_REG)]
1598                       = regstack->reg[regstack->top];
1599                   }
1600
1601                 CLEAR_HARD_REG_BIT (regstack->reg_set,
1602                                     REGNO (XEXP (src2_note, 0)));
1603                 replace_reg (&XEXP (src2_note, 0), FIRST_STACK_REG);
1604                 regstack->top--;
1605               }
1606             else
1607               {
1608                 SET_HARD_REG_BIT (regstack->reg_set, REGNO (*dest));
1609                 replace_reg (dest, get_hard_regnum (regstack, *dest));
1610               }
1611
1612             /* Keep operand 1 matching with destination.  */
1613             if (COMMUTATIVE_ARITH_P (pat_src)
1614                 && REG_P (*src1) && REG_P (*src2)
1615                 && REGNO (*src1) != REGNO (*dest))
1616              {
1617                 int tmp = REGNO (*src1);
1618                 replace_reg (src1, REGNO (*src2));
1619                 replace_reg (src2, tmp);
1620              }
1621             break;
1622
1623           case UNSPEC:
1624             switch (XINT (pat_src, 1))
1625               {
1626               case UNSPEC_FIST:
1627
1628               case UNSPEC_FIST_FLOOR:
1629               case UNSPEC_FIST_CEIL:
1630
1631                 /* These insns only operate on the top of the stack.  */
1632
1633                 src1 = get_true_reg (&XVECEXP (pat_src, 0, 0));
1634                 emit_swap_insn (insn, regstack, *src1);
1635
1636                 src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
1637
1638                 if (STACK_REG_P (*dest))
1639                   replace_reg (dest, FIRST_STACK_REG);
1640
1641                 if (src1_note)
1642                   {
1643                     replace_reg (&XEXP (src1_note, 0), FIRST_STACK_REG);
1644                     regstack->top--;
1645                     CLEAR_HARD_REG_BIT (regstack->reg_set, REGNO (*src1));
1646                   }
1647
1648                 replace_reg (src1, FIRST_STACK_REG);
1649                 break;
1650
1651               case UNSPEC_FXAM:
1652
1653                 /* This insn only operate on the top of the stack.  */
1654
1655                 src1 = get_true_reg (&XVECEXP (pat_src, 0, 0));
1656                 emit_swap_insn (insn, regstack, *src1);
1657
1658                 src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
1659
1660                 replace_reg (src1, FIRST_STACK_REG);
1661
1662                 if (src1_note)
1663                   {
1664                     remove_regno_note (insn, REG_DEAD,
1665                                        REGNO (XEXP (src1_note, 0)));
1666                     emit_pop_insn (insn, regstack, XEXP (src1_note, 0),
1667                                    EMIT_AFTER);
1668                   }
1669
1670                 break;
1671
1672               case UNSPEC_SIN:
1673               case UNSPEC_COS:
1674               case UNSPEC_FRNDINT:
1675               case UNSPEC_F2XM1:
1676
1677               case UNSPEC_FRNDINT_FLOOR:
1678               case UNSPEC_FRNDINT_CEIL:
1679               case UNSPEC_FRNDINT_TRUNC:
1680               case UNSPEC_FRNDINT_MASK_PM:
1681
1682                 /* Above insns operate on the top of the stack.  */
1683
1684               case UNSPEC_SINCOS_COS:
1685               case UNSPEC_XTRACT_FRACT:
1686
1687                 /* Above insns operate on the top two stack slots,
1688                    first part of one input, double output insn.  */
1689
1690                 src1 = get_true_reg (&XVECEXP (pat_src, 0, 0));
1691
1692                 emit_swap_insn (insn, regstack, *src1);
1693
1694                 /* Input should never die, it is replaced with output.  */
1695                 src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
1696                 gcc_assert (!src1_note);
1697
1698                 if (STACK_REG_P (*dest))
1699                   replace_reg (dest, FIRST_STACK_REG);
1700
1701                 replace_reg (src1, FIRST_STACK_REG);
1702                 break;
1703
1704               case UNSPEC_SINCOS_SIN:
1705               case UNSPEC_XTRACT_EXP:
1706
1707                 /* These insns operate on the top two stack slots,
1708                    second part of one input, double output insn.  */
1709
1710                 regstack->top++;
1711                 /* FALLTHRU */
1712
1713               case UNSPEC_TAN:
1714
1715                 /* For UNSPEC_TAN, regstack->top is already increased
1716                    by inherent load of constant 1.0.  */
1717
1718                 /* Output value is generated in the second stack slot.
1719                    Move current value from second slot to the top.  */
1720                 regstack->reg[regstack->top]
1721                   = regstack->reg[regstack->top - 1];
1722
1723                 gcc_assert (STACK_REG_P (*dest));
1724
1725                 regstack->reg[regstack->top - 1] = REGNO (*dest);
1726                 SET_HARD_REG_BIT (regstack->reg_set, REGNO (*dest));
1727                 replace_reg (dest, FIRST_STACK_REG + 1);
1728
1729                 src1 = get_true_reg (&XVECEXP (pat_src, 0, 0));
1730
1731                 replace_reg (src1, FIRST_STACK_REG);
1732                 break;
1733
1734               case UNSPEC_FPATAN:
1735               case UNSPEC_FYL2X:
1736               case UNSPEC_FYL2XP1:
1737                 /* These insns operate on the top two stack slots.  */
1738
1739                 src1 = get_true_reg (&XVECEXP (pat_src, 0, 0));
1740                 src2 = get_true_reg (&XVECEXP (pat_src, 0, 1));
1741
1742                 src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
1743                 src2_note = find_regno_note (insn, REG_DEAD, REGNO (*src2));
1744
1745                 swap_to_top (insn, regstack, *src1, *src2);
1746
1747                 replace_reg (src1, FIRST_STACK_REG);
1748                 replace_reg (src2, FIRST_STACK_REG + 1);
1749
1750                 if (src1_note)
1751                   replace_reg (&XEXP (src1_note, 0), FIRST_STACK_REG);
1752                 if (src2_note)
1753                   replace_reg (&XEXP (src2_note, 0), FIRST_STACK_REG + 1);
1754
1755                 /* Pop both input operands from the stack.  */
1756                 CLEAR_HARD_REG_BIT (regstack->reg_set,
1757                                     regstack->reg[regstack->top]);
1758                 CLEAR_HARD_REG_BIT (regstack->reg_set,
1759                                     regstack->reg[regstack->top - 1]);
1760                 regstack->top -= 2;
1761
1762                 /* Push the result back onto the stack.  */
1763                 regstack->reg[++regstack->top] = REGNO (*dest);
1764                 SET_HARD_REG_BIT (regstack->reg_set, REGNO (*dest));
1765                 replace_reg (dest, FIRST_STACK_REG);
1766                 break;
1767
1768               case UNSPEC_FSCALE_FRACT:
1769               case UNSPEC_FPREM_F:
1770               case UNSPEC_FPREM1_F:
1771                 /* These insns operate on the top two stack slots,
1772                    first part of double input, double output insn.  */
1773
1774                 src1 = get_true_reg (&XVECEXP (pat_src, 0, 0));
1775                 src2 = get_true_reg (&XVECEXP (pat_src, 0, 1));
1776
1777                 src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
1778                 src2_note = find_regno_note (insn, REG_DEAD, REGNO (*src2));
1779
1780                 /* Inputs should never die, they are
1781                    replaced with outputs.  */
1782                 gcc_assert (!src1_note);
1783                 gcc_assert (!src2_note);
1784
1785                 swap_to_top (insn, regstack, *src1, *src2);
1786
1787                 /* Push the result back onto stack. Empty stack slot
1788                    will be filled in second part of insn.  */
1789                 if (STACK_REG_P (*dest))
1790                   {
1791                     regstack->reg[regstack->top] = REGNO (*dest);
1792                     SET_HARD_REG_BIT (regstack->reg_set, REGNO (*dest));
1793                     replace_reg (dest, FIRST_STACK_REG);
1794                   }
1795
1796                 replace_reg (src1, FIRST_STACK_REG);
1797                 replace_reg (src2, FIRST_STACK_REG + 1);
1798                 break;
1799
1800               case UNSPEC_FSCALE_EXP:
1801               case UNSPEC_FPREM_U:
1802               case UNSPEC_FPREM1_U:
1803                 /* These insns operate on the top two stack slots,
1804                    second part of double input, double output insn.  */
1805
1806                 src1 = get_true_reg (&XVECEXP (pat_src, 0, 0));
1807                 src2 = get_true_reg (&XVECEXP (pat_src, 0, 1));
1808
1809                 /* Push the result back onto stack. Fill empty slot from
1810                    first part of insn and fix top of stack pointer.  */
1811                 if (STACK_REG_P (*dest))
1812                   {
1813                     regstack->reg[regstack->top - 1] = REGNO (*dest);
1814                     SET_HARD_REG_BIT (regstack->reg_set, REGNO (*dest));
1815                     replace_reg (dest, FIRST_STACK_REG + 1);
1816                   }
1817
1818                 replace_reg (src1, FIRST_STACK_REG);
1819                 replace_reg (src2, FIRST_STACK_REG + 1);
1820                 break;
1821
1822               case UNSPEC_C2_FLAG:
1823                 /* This insn operates on the top two stack slots,
1824                    third part of C2 setting double input insn.  */
1825
1826                 src1 = get_true_reg (&XVECEXP (pat_src, 0, 0));
1827                 src2 = get_true_reg (&XVECEXP (pat_src, 0, 1));
1828
1829                 replace_reg (src1, FIRST_STACK_REG);
1830                 replace_reg (src2, FIRST_STACK_REG + 1);
1831                 break;
1832
1833               case UNSPEC_SAHF:
1834                 /* (unspec [(unspec [(compare)] UNSPEC_FNSTSW)] UNSPEC_SAHF)
1835                    The combination matches the PPRO fcomi instruction.  */
1836
1837                 pat_src = XVECEXP (pat_src, 0, 0);
1838                 gcc_assert (GET_CODE (pat_src) == UNSPEC);
1839                 gcc_assert (XINT (pat_src, 1) == UNSPEC_FNSTSW);
1840                 /* Fall through.  */
1841
1842               case UNSPEC_FNSTSW:
1843                 /* Combined fcomp+fnstsw generated for doing well with
1844                    CSE.  When optimizing this would have been broken
1845                    up before now.  */
1846
1847                 pat_src = XVECEXP (pat_src, 0, 0);
1848                 gcc_assert (GET_CODE (pat_src) == COMPARE);
1849
1850                 compare_for_stack_reg (insn, regstack, pat_src);
1851                 break;
1852
1853               default:
1854                 gcc_unreachable ();
1855               }
1856             break;
1857
1858           case IF_THEN_ELSE:
1859             /* This insn requires the top of stack to be the destination.  */
1860
1861             src1 = get_true_reg (&XEXP (pat_src, 1));
1862             src2 = get_true_reg (&XEXP (pat_src, 2));
1863
1864             src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
1865             src2_note = find_regno_note (insn, REG_DEAD, REGNO (*src2));
1866
1867             /* If the comparison operator is an FP comparison operator,
1868                it is handled correctly by compare_for_stack_reg () who
1869                will move the destination to the top of stack. But if the
1870                comparison operator is not an FP comparison operator, we
1871                have to handle it here.  */
1872             if (get_hard_regnum (regstack, *dest) >= FIRST_STACK_REG
1873                 && REGNO (*dest) != regstack->reg[regstack->top])
1874               {
1875                 /* In case one of operands is the top of stack and the operands
1876                    dies, it is safe to make it the destination operand by
1877                    reversing the direction of cmove and avoid fxch.  */
1878                 if ((REGNO (*src1) == regstack->reg[regstack->top]
1879                      && src1_note)
1880                     || (REGNO (*src2) == regstack->reg[regstack->top]
1881                         && src2_note))
1882                   {
1883                     int idx1 = (get_hard_regnum (regstack, *src1)
1884                                 - FIRST_STACK_REG);
1885                     int idx2 = (get_hard_regnum (regstack, *src2)
1886                                 - FIRST_STACK_REG);
1887
1888                     /* Make reg-stack believe that the operands are already
1889                        swapped on the stack */
1890                     regstack->reg[regstack->top - idx1] = REGNO (*src2);
1891                     regstack->reg[regstack->top - idx2] = REGNO (*src1);
1892
1893                     /* Reverse condition to compensate the operand swap.
1894                        i386 do have comparison always reversible.  */
1895                     PUT_CODE (XEXP (pat_src, 0),
1896                               reversed_comparison_code (XEXP (pat_src, 0), insn));
1897                   }
1898                 else
1899                   emit_swap_insn (insn, regstack, *dest);
1900               }
1901
1902             {
1903               rtx src_note [3];
1904               int i;
1905
1906               src_note[0] = 0;
1907               src_note[1] = src1_note;
1908               src_note[2] = src2_note;
1909
1910               if (STACK_REG_P (*src1))
1911                 replace_reg (src1, get_hard_regnum (regstack, *src1));
1912               if (STACK_REG_P (*src2))
1913                 replace_reg (src2, get_hard_regnum (regstack, *src2));
1914
1915               for (i = 1; i <= 2; i++)
1916                 if (src_note [i])
1917                   {
1918                     int regno = REGNO (XEXP (src_note[i], 0));
1919
1920                     /* If the register that dies is not at the top of
1921                        stack, then move the top of stack to the dead reg.
1922                        Top of stack should never die, as it is the
1923                        destination.  */
1924                     gcc_assert (regno != regstack->reg[regstack->top]);
1925                     remove_regno_note (insn, REG_DEAD, regno);
1926                     emit_pop_insn (insn, regstack, XEXP (src_note[i], 0),
1927                                     EMIT_AFTER);
1928                   }
1929             }
1930
1931             /* Make dest the top of stack.  Add dest to regstack if
1932                not present.  */
1933             if (get_hard_regnum (regstack, *dest) < FIRST_STACK_REG)
1934               regstack->reg[++regstack->top] = REGNO (*dest);
1935             SET_HARD_REG_BIT (regstack->reg_set, REGNO (*dest));
1936             replace_reg (dest, FIRST_STACK_REG);
1937             break;
1938
1939           default:
1940             gcc_unreachable ();
1941           }
1942         break;
1943       }
1944
1945     default:
1946       break;
1947     }
1948
1949   return control_flow_insn_deleted;
1950 }
1951 \f
1952 /* Substitute hard regnums for any stack regs in INSN, which has
1953    N_INPUTS inputs and N_OUTPUTS outputs.  REGSTACK is the stack info
1954    before the insn, and is updated with changes made here.
1955
1956    There are several requirements and assumptions about the use of
1957    stack-like regs in asm statements.  These rules are enforced by
1958    record_asm_stack_regs; see comments there for details.  Any
1959    asm_operands left in the RTL at this point may be assume to meet the
1960    requirements, since record_asm_stack_regs removes any problem asm.  */
1961
1962 static void
1963 subst_asm_stack_regs (rtx insn, stack regstack)
1964 {
1965   rtx body = PATTERN (insn);
1966   int alt;
1967
1968   rtx *note_reg;                /* Array of note contents */
1969   rtx **note_loc;               /* Address of REG field of each note */
1970   enum reg_note *note_kind;     /* The type of each note */
1971
1972   rtx *clobber_reg = 0;
1973   rtx **clobber_loc = 0;
1974
1975   struct stack_def temp_stack;
1976   int n_notes;
1977   int n_clobbers;
1978   rtx note;
1979   int i;
1980   int n_inputs, n_outputs;
1981
1982   if (! check_asm_stack_operands (insn))
1983     return;
1984
1985   /* Find out what the constraints required.  If no constraint
1986      alternative matches, that is a compiler bug: we should have caught
1987      such an insn in check_asm_stack_operands.  */
1988   extract_insn (insn);
1989   constrain_operands (1);
1990   alt = which_alternative;
1991
1992   preprocess_constraints ();
1993
1994   n_inputs = get_asm_operand_n_inputs (body);
1995   n_outputs = recog_data.n_operands - n_inputs;
1996
1997   gcc_assert (alt >= 0);
1998
1999   /* Strip SUBREGs here to make the following code simpler.  */
2000   for (i = 0; i < recog_data.n_operands; i++)
2001     if (GET_CODE (recog_data.operand[i]) == SUBREG
2002         && REG_P (SUBREG_REG (recog_data.operand[i])))
2003       {
2004         recog_data.operand_loc[i] = & SUBREG_REG (recog_data.operand[i]);
2005         recog_data.operand[i] = SUBREG_REG (recog_data.operand[i]);
2006       }
2007
2008   /* Set up NOTE_REG, NOTE_LOC and NOTE_KIND.  */
2009
2010   for (i = 0, note = REG_NOTES (insn); note; note = XEXP (note, 1))
2011     i++;
2012
2013   note_reg = alloca (i * sizeof (rtx));
2014   note_loc = alloca (i * sizeof (rtx *));
2015   note_kind = alloca (i * sizeof (enum reg_note));
2016
2017   n_notes = 0;
2018   for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
2019     {
2020       rtx reg = XEXP (note, 0);
2021       rtx *loc = & XEXP (note, 0);
2022
2023       if (GET_CODE (reg) == SUBREG && REG_P (SUBREG_REG (reg)))
2024         {
2025           loc = & SUBREG_REG (reg);
2026           reg = SUBREG_REG (reg);
2027         }
2028
2029       if (STACK_REG_P (reg)
2030           && (REG_NOTE_KIND (note) == REG_DEAD
2031               || REG_NOTE_KIND (note) == REG_UNUSED))
2032         {
2033           note_reg[n_notes] = reg;
2034           note_loc[n_notes] = loc;
2035           note_kind[n_notes] = REG_NOTE_KIND (note);
2036           n_notes++;
2037         }
2038     }
2039
2040   /* Set up CLOBBER_REG and CLOBBER_LOC.  */
2041
2042   n_clobbers = 0;
2043
2044   if (GET_CODE (body) == PARALLEL)
2045     {
2046       clobber_reg = alloca (XVECLEN (body, 0) * sizeof (rtx));
2047       clobber_loc = alloca (XVECLEN (body, 0) * sizeof (rtx *));
2048
2049       for (i = 0; i < XVECLEN (body, 0); i++)
2050         if (GET_CODE (XVECEXP (body, 0, i)) == CLOBBER)
2051           {
2052             rtx clobber = XVECEXP (body, 0, i);
2053             rtx reg = XEXP (clobber, 0);
2054             rtx *loc = & XEXP (clobber, 0);
2055
2056             if (GET_CODE (reg) == SUBREG && REG_P (SUBREG_REG (reg)))
2057               {
2058                 loc = & SUBREG_REG (reg);
2059                 reg = SUBREG_REG (reg);
2060               }
2061
2062             if (STACK_REG_P (reg))
2063               {
2064                 clobber_reg[n_clobbers] = reg;
2065                 clobber_loc[n_clobbers] = loc;
2066                 n_clobbers++;
2067               }
2068           }
2069     }
2070
2071   temp_stack = *regstack;
2072
2073   /* Put the input regs into the desired place in TEMP_STACK.  */
2074
2075   for (i = n_outputs; i < n_outputs + n_inputs; i++)
2076     if (STACK_REG_P (recog_data.operand[i])
2077         && reg_class_subset_p (recog_op_alt[i][alt].cl,
2078                                FLOAT_REGS)
2079         && recog_op_alt[i][alt].cl != FLOAT_REGS)
2080       {
2081         /* If an operand needs to be in a particular reg in
2082            FLOAT_REGS, the constraint was either 't' or 'u'.  Since
2083            these constraints are for single register classes, and
2084            reload guaranteed that operand[i] is already in that class,
2085            we can just use REGNO (recog_data.operand[i]) to know which
2086            actual reg this operand needs to be in.  */
2087
2088         int regno = get_hard_regnum (&temp_stack, recog_data.operand[i]);
2089
2090         gcc_assert (regno >= 0);
2091
2092         if ((unsigned int) regno != REGNO (recog_data.operand[i]))
2093           {
2094             /* recog_data.operand[i] is not in the right place.  Find
2095                it and swap it with whatever is already in I's place.
2096                K is where recog_data.operand[i] is now.  J is where it
2097                should be.  */
2098             int j, k, temp;
2099
2100             k = temp_stack.top - (regno - FIRST_STACK_REG);
2101             j = (temp_stack.top
2102                  - (REGNO (recog_data.operand[i]) - FIRST_STACK_REG));
2103
2104             temp = temp_stack.reg[k];
2105             temp_stack.reg[k] = temp_stack.reg[j];
2106             temp_stack.reg[j] = temp;
2107           }
2108       }
2109
2110   /* Emit insns before INSN to make sure the reg-stack is in the right
2111      order.  */
2112
2113   change_stack (insn, regstack, &temp_stack, EMIT_BEFORE);
2114
2115   /* Make the needed input register substitutions.  Do death notes and
2116      clobbers too, because these are for inputs, not outputs.  */
2117
2118   for (i = n_outputs; i < n_outputs + n_inputs; i++)
2119     if (STACK_REG_P (recog_data.operand[i]))
2120       {
2121         int regnum = get_hard_regnum (regstack, recog_data.operand[i]);
2122
2123         gcc_assert (regnum >= 0);
2124
2125         replace_reg (recog_data.operand_loc[i], regnum);
2126       }
2127
2128   for (i = 0; i < n_notes; i++)
2129     if (note_kind[i] == REG_DEAD)
2130       {
2131         int regnum = get_hard_regnum (regstack, note_reg[i]);
2132
2133         gcc_assert (regnum >= 0);
2134
2135         replace_reg (note_loc[i], regnum);
2136       }
2137
2138   for (i = 0; i < n_clobbers; i++)
2139     {
2140       /* It's OK for a CLOBBER to reference a reg that is not live.
2141          Don't try to replace it in that case.  */
2142       int regnum = get_hard_regnum (regstack, clobber_reg[i]);
2143
2144       if (regnum >= 0)
2145         {
2146           /* Sigh - clobbers always have QImode.  But replace_reg knows
2147              that these regs can't be MODE_INT and will assert.  Just put
2148              the right reg there without calling replace_reg.  */
2149
2150           *clobber_loc[i] = FP_MODE_REG (regnum, DFmode);
2151         }
2152     }
2153
2154   /* Now remove from REGSTACK any inputs that the asm implicitly popped.  */
2155
2156   for (i = n_outputs; i < n_outputs + n_inputs; i++)
2157     if (STACK_REG_P (recog_data.operand[i]))
2158       {
2159         /* An input reg is implicitly popped if it is tied to an
2160            output, or if there is a CLOBBER for it.  */
2161         int j;
2162
2163         for (j = 0; j < n_clobbers; j++)
2164           if (operands_match_p (clobber_reg[j], recog_data.operand[i]))
2165             break;
2166
2167         if (j < n_clobbers || recog_op_alt[i][alt].matches >= 0)
2168           {
2169             /* recog_data.operand[i] might not be at the top of stack.
2170                But that's OK, because all we need to do is pop the
2171                right number of regs off of the top of the reg-stack.
2172                record_asm_stack_regs guaranteed that all implicitly
2173                popped regs were grouped at the top of the reg-stack.  */
2174
2175             CLEAR_HARD_REG_BIT (regstack->reg_set,
2176                                 regstack->reg[regstack->top]);
2177             regstack->top--;
2178           }
2179       }
2180
2181   /* Now add to REGSTACK any outputs that the asm implicitly pushed.
2182      Note that there isn't any need to substitute register numbers.
2183      ???  Explain why this is true.  */
2184
2185   for (i = LAST_STACK_REG; i >= FIRST_STACK_REG; i--)
2186     {
2187       /* See if there is an output for this hard reg.  */
2188       int j;
2189
2190       for (j = 0; j < n_outputs; j++)
2191         if (STACK_REG_P (recog_data.operand[j])
2192             && REGNO (recog_data.operand[j]) == (unsigned) i)
2193           {
2194             regstack->reg[++regstack->top] = i;
2195             SET_HARD_REG_BIT (regstack->reg_set, i);
2196             break;
2197           }
2198     }
2199
2200   /* Now emit a pop insn for any REG_UNUSED output, or any REG_DEAD
2201      input that the asm didn't implicitly pop.  If the asm didn't
2202      implicitly pop an input reg, that reg will still be live.
2203
2204      Note that we can't use find_regno_note here: the register numbers
2205      in the death notes have already been substituted.  */
2206
2207   for (i = 0; i < n_outputs; i++)
2208     if (STACK_REG_P (recog_data.operand[i]))
2209       {
2210         int j;
2211
2212         for (j = 0; j < n_notes; j++)
2213           if (REGNO (recog_data.operand[i]) == REGNO (note_reg[j])
2214               && note_kind[j] == REG_UNUSED)
2215             {
2216               insn = emit_pop_insn (insn, regstack, recog_data.operand[i],
2217                                     EMIT_AFTER);
2218               break;
2219             }
2220       }
2221
2222   for (i = n_outputs; i < n_outputs + n_inputs; i++)
2223     if (STACK_REG_P (recog_data.operand[i]))
2224       {
2225         int j;
2226
2227         for (j = 0; j < n_notes; j++)
2228           if (REGNO (recog_data.operand[i]) == REGNO (note_reg[j])
2229               && note_kind[j] == REG_DEAD
2230               && TEST_HARD_REG_BIT (regstack->reg_set,
2231                                     REGNO (recog_data.operand[i])))
2232             {
2233               insn = emit_pop_insn (insn, regstack, recog_data.operand[i],
2234                                     EMIT_AFTER);
2235               break;
2236             }
2237       }
2238 }
2239 \f
2240 /* Substitute stack hard reg numbers for stack virtual registers in
2241    INSN.  Non-stack register numbers are not changed.  REGSTACK is the
2242    current stack content.  Insns may be emitted as needed to arrange the
2243    stack for the 387 based on the contents of the insn.  Return whether
2244    a control flow insn was deleted in the process.  */
2245
2246 static bool
2247 subst_stack_regs (rtx insn, stack regstack)
2248 {
2249   rtx *note_link, note;
2250   bool control_flow_insn_deleted = false;
2251   int i;
2252
2253   if (CALL_P (insn))
2254     {
2255       int top = regstack->top;
2256
2257       /* If there are any floating point parameters to be passed in
2258          registers for this call, make sure they are in the right
2259          order.  */
2260
2261       if (top >= 0)
2262         {
2263           straighten_stack (insn, regstack);
2264
2265           /* Now mark the arguments as dead after the call.  */
2266
2267           while (regstack->top >= 0)
2268             {
2269               CLEAR_HARD_REG_BIT (regstack->reg_set, FIRST_STACK_REG + regstack->top);
2270               regstack->top--;
2271             }
2272         }
2273     }
2274
2275   /* Do the actual substitution if any stack regs are mentioned.
2276      Since we only record whether entire insn mentions stack regs, and
2277      subst_stack_regs_pat only works for patterns that contain stack regs,
2278      we must check each pattern in a parallel here.  A call_value_pop could
2279      fail otherwise.  */
2280
2281   if (stack_regs_mentioned (insn))
2282     {
2283       int n_operands = asm_noperands (PATTERN (insn));
2284       if (n_operands >= 0)
2285         {
2286           /* This insn is an `asm' with operands.  Decode the operands,
2287              decide how many are inputs, and do register substitution.
2288              Any REG_UNUSED notes will be handled by subst_asm_stack_regs.  */
2289
2290           subst_asm_stack_regs (insn, regstack);
2291           return control_flow_insn_deleted;
2292         }
2293
2294       if (GET_CODE (PATTERN (insn)) == PARALLEL)
2295         for (i = 0; i < XVECLEN (PATTERN (insn), 0); i++)
2296           {
2297             if (stack_regs_mentioned_p (XVECEXP (PATTERN (insn), 0, i)))
2298               {
2299                 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == CLOBBER)
2300                    XVECEXP (PATTERN (insn), 0, i)
2301                      = shallow_copy_rtx (XVECEXP (PATTERN (insn), 0, i));
2302                 control_flow_insn_deleted
2303                   |= subst_stack_regs_pat (insn, regstack,
2304                                            XVECEXP (PATTERN (insn), 0, i));
2305               }
2306           }
2307       else
2308         control_flow_insn_deleted
2309           |= subst_stack_regs_pat (insn, regstack, PATTERN (insn));
2310     }
2311
2312   /* subst_stack_regs_pat may have deleted a no-op insn.  If so, any
2313      REG_UNUSED will already have been dealt with, so just return.  */
2314
2315   if (NOTE_P (insn) || INSN_DELETED_P (insn))
2316     return control_flow_insn_deleted;
2317
2318   /* If this a noreturn call, we can't insert pop insns after it.
2319      Instead, reset the stack state to empty.  */
2320   if (CALL_P (insn)
2321       && find_reg_note (insn, REG_NORETURN, NULL))
2322     {
2323       regstack->top = -1;
2324       CLEAR_HARD_REG_SET (regstack->reg_set);
2325       return control_flow_insn_deleted;
2326     }
2327
2328   /* If there is a REG_UNUSED note on a stack register on this insn,
2329      the indicated reg must be popped.  The REG_UNUSED note is removed,
2330      since the form of the newly emitted pop insn references the reg,
2331      making it no longer `unset'.  */
2332
2333   note_link = &REG_NOTES (insn);
2334   for (note = *note_link; note; note = XEXP (note, 1))
2335     if (REG_NOTE_KIND (note) == REG_UNUSED && STACK_REG_P (XEXP (note, 0)))
2336       {
2337         *note_link = XEXP (note, 1);
2338         insn = emit_pop_insn (insn, regstack, XEXP (note, 0), EMIT_AFTER);
2339       }
2340     else
2341       note_link = &XEXP (note, 1);
2342
2343   return control_flow_insn_deleted;
2344 }
2345 \f
2346 /* Change the organization of the stack so that it fits a new basic
2347    block.  Some registers might have to be popped, but there can never be
2348    a register live in the new block that is not now live.
2349
2350    Insert any needed insns before or after INSN, as indicated by
2351    WHERE.  OLD is the original stack layout, and NEW is the desired
2352    form.  OLD is updated to reflect the code emitted, i.e., it will be
2353    the same as NEW upon return.
2354
2355    This function will not preserve block_end[].  But that information
2356    is no longer needed once this has executed.  */
2357
2358 static void
2359 change_stack (rtx insn, stack old, stack new, enum emit_where where)
2360 {
2361   int reg;
2362   int update_end = 0;
2363   int i;
2364
2365   /* Stack adjustments for the first insn in a block update the
2366      current_block's stack_in instead of inserting insns directly.
2367      compensate_edges will add the necessary code later.  */
2368   if (current_block
2369       && starting_stack_p
2370       && where == EMIT_BEFORE)
2371     {
2372       BLOCK_INFO (current_block)->stack_in = *new;
2373       starting_stack_p = false;
2374       *old = *new;
2375       return;
2376     }
2377
2378   /* We will be inserting new insns "backwards".  If we are to insert
2379      after INSN, find the next insn, and insert before it.  */
2380
2381   if (where == EMIT_AFTER)
2382     {
2383       if (current_block && BB_END (current_block) == insn)
2384         update_end = 1;
2385       insn = NEXT_INSN (insn);
2386     }
2387
2388   /* Initialize partially dead variables.  */
2389   for (i = FIRST_STACK_REG; i < LAST_STACK_REG + 1; i++)
2390     if (TEST_HARD_REG_BIT (new->reg_set, i)
2391         && !TEST_HARD_REG_BIT (old->reg_set, i))
2392       {
2393         old->reg[++old->top] = i;
2394         SET_HARD_REG_BIT (old->reg_set, i);
2395         emit_insn_before (gen_rtx_SET (VOIDmode,
2396                                        FP_MODE_REG (i, SFmode), not_a_num), insn);
2397       }
2398
2399   /* Pop any registers that are not needed in the new block.  */
2400
2401   /* If the destination block's stack already has a specified layout
2402      and contains two or more registers, use a more intelligent algorithm
2403      to pop registers that minimizes the number number of fxchs below.  */
2404   if (new->top > 0)
2405     {
2406       bool slots[REG_STACK_SIZE];
2407       int pops[REG_STACK_SIZE];
2408       int next, dest, topsrc;
2409
2410       /* First pass to determine the free slots.  */
2411       for (reg = 0; reg <= new->top; reg++)
2412         slots[reg] = TEST_HARD_REG_BIT (new->reg_set, old->reg[reg]);
2413
2414       /* Second pass to allocate preferred slots.  */
2415       topsrc = -1;
2416       for (reg = old->top; reg > new->top; reg--)
2417         if (TEST_HARD_REG_BIT (new->reg_set, old->reg[reg]))
2418           {
2419             dest = -1;
2420             for (next = 0; next <= new->top; next++)
2421               if (!slots[next] && new->reg[next] == old->reg[reg])
2422                 {
2423                   /* If this is a preference for the new top of stack, record
2424                      the fact by remembering it's old->reg in topsrc.  */
2425                   if (next == new->top)
2426                     topsrc = reg;
2427                   slots[next] = true;
2428                   dest = next;
2429                   break;
2430                 }
2431             pops[reg] = dest;
2432           }
2433         else
2434           pops[reg] = reg;
2435
2436       /* Intentionally, avoid placing the top of stack in it's correct
2437          location, if we still need to permute the stack below and we
2438          can usefully place it somewhere else.  This is the case if any
2439          slot is still unallocated, in which case we should place the
2440          top of stack there.  */
2441       if (topsrc != -1)
2442         for (reg = 0; reg < new->top; reg++)
2443           if (!slots[reg])
2444             {
2445               pops[topsrc] = reg;
2446               slots[new->top] = false;
2447               slots[reg] = true;
2448               break;
2449             }
2450
2451       /* Third pass allocates remaining slots and emits pop insns.  */
2452       next = new->top;
2453       for (reg = old->top; reg > new->top; reg--)
2454         {
2455           dest = pops[reg];
2456           if (dest == -1)
2457             {
2458               /* Find next free slot.  */
2459               while (slots[next])
2460                 next--;
2461               dest = next--;
2462             }
2463           emit_pop_insn (insn, old, FP_MODE_REG (old->reg[dest], DFmode),
2464                          EMIT_BEFORE);
2465         }
2466     }
2467   else
2468     {
2469       /* The following loop attempts to maximize the number of times we
2470          pop the top of the stack, as this permits the use of the faster
2471          ffreep instruction on platforms that support it.  */
2472       int live, next;
2473
2474       live = 0;
2475       for (reg = 0; reg <= old->top; reg++)
2476         if (TEST_HARD_REG_BIT (new->reg_set, old->reg[reg]))
2477           live++;
2478
2479       next = live;
2480       while (old->top >= live)
2481         if (TEST_HARD_REG_BIT (new->reg_set, old->reg[old->top]))
2482           {
2483             while (TEST_HARD_REG_BIT (new->reg_set, old->reg[next]))
2484               next--;
2485             emit_pop_insn (insn, old, FP_MODE_REG (old->reg[next], DFmode),
2486                            EMIT_BEFORE);
2487           }
2488         else
2489           emit_pop_insn (insn, old, FP_MODE_REG (old->reg[old->top], DFmode),
2490                          EMIT_BEFORE);
2491     }
2492
2493   if (new->top == -2)
2494     {
2495       /* If the new block has never been processed, then it can inherit
2496          the old stack order.  */
2497
2498       new->top = old->top;
2499       memcpy (new->reg, old->reg, sizeof (new->reg));
2500     }
2501   else
2502     {
2503       /* This block has been entered before, and we must match the
2504          previously selected stack order.  */
2505
2506       /* By now, the only difference should be the order of the stack,
2507          not their depth or liveliness.  */
2508
2509       gcc_assert (hard_reg_set_equal_p (old->reg_set, new->reg_set));
2510       gcc_assert (old->top == new->top);
2511
2512       /* If the stack is not empty (new->top != -1), loop here emitting
2513          swaps until the stack is correct.
2514
2515          The worst case number of swaps emitted is N + 2, where N is the
2516          depth of the stack.  In some cases, the reg at the top of
2517          stack may be correct, but swapped anyway in order to fix
2518          other regs.  But since we never swap any other reg away from
2519          its correct slot, this algorithm will converge.  */
2520
2521       if (new->top != -1)
2522         do
2523           {
2524             /* Swap the reg at top of stack into the position it is
2525                supposed to be in, until the correct top of stack appears.  */
2526
2527             while (old->reg[old->top] != new->reg[new->top])
2528               {
2529                 for (reg = new->top; reg >= 0; reg--)
2530                   if (new->reg[reg] == old->reg[old->top])
2531                     break;
2532
2533                 gcc_assert (reg != -1);
2534
2535                 emit_swap_insn (insn, old,
2536                                 FP_MODE_REG (old->reg[reg], DFmode));
2537               }
2538
2539             /* See if any regs remain incorrect.  If so, bring an
2540              incorrect reg to the top of stack, and let the while loop
2541              above fix it.  */
2542
2543             for (reg = new->top; reg >= 0; reg--)
2544               if (new->reg[reg] != old->reg[reg])
2545                 {
2546                   emit_swap_insn (insn, old,
2547                                   FP_MODE_REG (old->reg[reg], DFmode));
2548                   break;
2549                 }
2550           } while (reg >= 0);
2551
2552       /* At this point there must be no differences.  */
2553
2554       for (reg = old->top; reg >= 0; reg--)
2555         gcc_assert (old->reg[reg] == new->reg[reg]);
2556     }
2557
2558   if (update_end)
2559     BB_END (current_block) = PREV_INSN (insn);
2560 }
2561 \f
2562 /* Print stack configuration.  */
2563
2564 static void
2565 print_stack (FILE *file, stack s)
2566 {
2567   if (! file)
2568     return;
2569
2570   if (s->top == -2)
2571     fprintf (file, "uninitialized\n");
2572   else if (s->top == -1)
2573     fprintf (file, "empty\n");
2574   else
2575     {
2576       int i;
2577       fputs ("[ ", file);
2578       for (i = 0; i <= s->top; ++i)
2579         fprintf (file, "%d ", s->reg[i]);
2580       fputs ("]\n", file);
2581     }
2582 }
2583 \f
2584 /* This function was doing life analysis.  We now let the regular live
2585    code do it's job, so we only need to check some extra invariants
2586    that reg-stack expects.  Primary among these being that all registers
2587    are initialized before use.
2588
2589    The function returns true when code was emitted to CFG edges and
2590    commit_edge_insertions needs to be called.  */
2591
2592 static int
2593 convert_regs_entry (void)
2594 {
2595   int inserted = 0;
2596   edge e;
2597   edge_iterator ei;
2598
2599   /* Load something into each stack register live at function entry.
2600      Such live registers can be caused by uninitialized variables or
2601      functions not returning values on all paths.  In order to keep
2602      the push/pop code happy, and to not scrog the register stack, we
2603      must put something in these registers.  Use a QNaN.
2604
2605      Note that we are inserting converted code here.  This code is
2606      never seen by the convert_regs pass.  */
2607
2608   FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
2609     {
2610       basic_block block = e->dest;
2611       block_info bi = BLOCK_INFO (block);
2612       int reg, top = -1;
2613
2614       for (reg = LAST_STACK_REG; reg >= FIRST_STACK_REG; --reg)
2615         if (TEST_HARD_REG_BIT (bi->stack_in.reg_set, reg))
2616           {
2617             rtx init;
2618
2619             bi->stack_in.reg[++top] = reg;
2620
2621             init = gen_rtx_SET (VOIDmode,
2622                                 FP_MODE_REG (FIRST_STACK_REG, SFmode),
2623                                 not_a_num);
2624             insert_insn_on_edge (init, e);
2625             inserted = 1;
2626           }
2627
2628       bi->stack_in.top = top;
2629     }
2630
2631   return inserted;
2632 }
2633
2634 /* Construct the desired stack for function exit.  This will either
2635    be `empty', or the function return value at top-of-stack.  */
2636
2637 static void
2638 convert_regs_exit (void)
2639 {
2640   int value_reg_low, value_reg_high;
2641   stack output_stack;
2642   rtx retvalue;
2643
2644   retvalue = stack_result (current_function_decl);
2645   value_reg_low = value_reg_high = -1;
2646   if (retvalue)
2647     {
2648       value_reg_low = REGNO (retvalue);
2649       value_reg_high = END_HARD_REGNO (retvalue) - 1;
2650     }
2651
2652   output_stack = &BLOCK_INFO (EXIT_BLOCK_PTR)->stack_in;
2653   if (value_reg_low == -1)
2654     output_stack->top = -1;
2655   else
2656     {
2657       int reg;
2658
2659       output_stack->top = value_reg_high - value_reg_low;
2660       for (reg = value_reg_low; reg <= value_reg_high; ++reg)
2661         {
2662           output_stack->reg[value_reg_high - reg] = reg;
2663           SET_HARD_REG_BIT (output_stack->reg_set, reg);
2664         }
2665     }
2666 }
2667
2668 /* Copy the stack info from the end of edge E's source block to the
2669    start of E's destination block.  */
2670
2671 static void
2672 propagate_stack (edge e)
2673 {
2674   stack src_stack = &BLOCK_INFO (e->src)->stack_out;
2675   stack dest_stack = &BLOCK_INFO (e->dest)->stack_in;
2676   int reg;
2677
2678   /* Preserve the order of the original stack, but check whether
2679      any pops are needed.  */
2680   dest_stack->top = -1;
2681   for (reg = 0; reg <= src_stack->top; ++reg)
2682     if (TEST_HARD_REG_BIT (dest_stack->reg_set, src_stack->reg[reg]))
2683       dest_stack->reg[++dest_stack->top] = src_stack->reg[reg];
2684
2685   /* Push in any partially dead values.  */
2686   for (reg = FIRST_STACK_REG; reg < LAST_STACK_REG + 1; reg++)
2687     if (TEST_HARD_REG_BIT (dest_stack->reg_set, reg)
2688         && !TEST_HARD_REG_BIT (src_stack->reg_set, reg))
2689       dest_stack->reg[++dest_stack->top] = reg;
2690 }
2691
2692
2693 /* Adjust the stack of edge E's source block on exit to match the stack
2694    of it's target block upon input.  The stack layouts of both blocks
2695    should have been defined by now.  */
2696
2697 static bool
2698 compensate_edge (edge e)
2699 {
2700   basic_block source = e->src, target = e->dest;
2701   stack target_stack = &BLOCK_INFO (target)->stack_in;
2702   stack source_stack = &BLOCK_INFO (source)->stack_out;
2703   struct stack_def regstack;
2704   int reg;
2705
2706   if (dump_file)
2707     fprintf (dump_file, "Edge %d->%d: ", source->index, target->index);
2708
2709   gcc_assert (target_stack->top != -2);
2710
2711   /* Check whether stacks are identical.  */
2712   if (target_stack->top == source_stack->top)
2713     {
2714       for (reg = target_stack->top; reg >= 0; --reg)
2715         if (target_stack->reg[reg] != source_stack->reg[reg])
2716           break;
2717
2718       if (reg == -1)
2719         {
2720           if (dump_file)
2721             fprintf (dump_file, "no changes needed\n");
2722           return false;
2723         }
2724     }
2725
2726   if (dump_file)
2727     {
2728       fprintf (dump_file, "correcting stack to ");
2729       print_stack (dump_file, target_stack);
2730     }
2731
2732   /* Abnormal calls may appear to have values live in st(0), but the
2733      abnormal return path will not have actually loaded the values.  */
2734   if (e->flags & EDGE_ABNORMAL_CALL)
2735     {
2736       /* Assert that the lifetimes are as we expect -- one value
2737          live at st(0) on the end of the source block, and no
2738          values live at the beginning of the destination block.
2739          For complex return values, we may have st(1) live as well.  */
2740       gcc_assert (source_stack->top == 0 || source_stack->top == 1);
2741       gcc_assert (target_stack->top == -1);
2742       return false;
2743     }
2744
2745   /* Handle non-call EH edges specially.  The normal return path have
2746      values in registers.  These will be popped en masse by the unwind
2747      library.  */
2748   if (e->flags & EDGE_EH)
2749     {
2750       gcc_assert (target_stack->top == -1);
2751       return false;
2752     }
2753
2754   /* We don't support abnormal edges.  Global takes care to
2755      avoid any live register across them, so we should never
2756      have to insert instructions on such edges.  */
2757   gcc_assert (! (e->flags & EDGE_ABNORMAL));
2758
2759   /* Make a copy of source_stack as change_stack is destructive.  */
2760   regstack = *source_stack;
2761
2762   /* It is better to output directly to the end of the block
2763      instead of to the edge, because emit_swap can do minimal
2764      insn scheduling.  We can do this when there is only one
2765      edge out, and it is not abnormal.  */
2766   if (EDGE_COUNT (source->succs) == 1)
2767     {
2768       current_block = source;
2769       change_stack (BB_END (source), &regstack, target_stack,
2770                     (JUMP_P (BB_END (source)) ? EMIT_BEFORE : EMIT_AFTER));
2771     }
2772   else
2773     {
2774       rtx seq, after;
2775
2776       current_block = NULL;
2777       start_sequence ();
2778
2779       /* ??? change_stack needs some point to emit insns after.  */
2780       after = emit_note (NOTE_INSN_DELETED);
2781
2782       change_stack (after, &regstack, target_stack, EMIT_BEFORE);
2783
2784       seq = get_insns ();
2785       end_sequence ();
2786
2787       insert_insn_on_edge (seq, e);
2788       return true;
2789     }
2790   return false;
2791 }
2792
2793 /* Traverse all non-entry edges in the CFG, and emit the necessary
2794    edge compensation code to change the stack from stack_out of the
2795    source block to the stack_in of the destination block.  */
2796
2797 static bool
2798 compensate_edges (void)
2799 {
2800   bool inserted = false;
2801   basic_block bb;
2802
2803   starting_stack_p = false;
2804
2805   FOR_EACH_BB (bb)
2806     if (bb != ENTRY_BLOCK_PTR)
2807       {
2808         edge e;
2809         edge_iterator ei;
2810
2811         FOR_EACH_EDGE (e, ei, bb->succs)
2812           inserted |= compensate_edge (e);
2813       }
2814   return inserted;
2815 }
2816
2817 /* Select the better of two edges E1 and E2 to use to determine the
2818    stack layout for their shared destination basic block.  This is
2819    typically the more frequently executed.  The edge E1 may be NULL
2820    (in which case E2 is returned), but E2 is always non-NULL.  */
2821
2822 static edge
2823 better_edge (edge e1, edge e2)
2824 {
2825   if (!e1)
2826     return e2;
2827
2828   if (EDGE_FREQUENCY (e1) > EDGE_FREQUENCY (e2))
2829     return e1;
2830   if (EDGE_FREQUENCY (e1) < EDGE_FREQUENCY (e2))
2831     return e2;
2832
2833   if (e1->count > e2->count)
2834     return e1;
2835   if (e1->count < e2->count)
2836     return e2;
2837
2838   /* Prefer critical edges to minimize inserting compensation code on
2839      critical edges.  */
2840
2841   if (EDGE_CRITICAL_P (e1) != EDGE_CRITICAL_P (e2))
2842     return EDGE_CRITICAL_P (e1) ? e1 : e2;
2843
2844   /* Avoid non-deterministic behavior.  */
2845   return (e1->src->index < e2->src->index) ? e1 : e2;
2846 }
2847
2848 /* Convert stack register references in one block.  */
2849
2850 static void
2851 convert_regs_1 (basic_block block)
2852 {
2853   struct stack_def regstack;
2854   block_info bi = BLOCK_INFO (block);
2855   int reg;
2856   rtx insn, next;
2857   bool control_flow_insn_deleted = false;
2858
2859   any_malformed_asm = false;
2860
2861   /* Choose an initial stack layout, if one hasn't already been chosen.  */
2862   if (bi->stack_in.top == -2)
2863     {
2864       edge e, beste = NULL;
2865       edge_iterator ei;
2866
2867       /* Select the best incoming edge (typically the most frequent) to
2868          use as a template for this basic block.  */
2869       FOR_EACH_EDGE (e, ei, block->preds)
2870         if (BLOCK_INFO (e->src)->done)
2871           beste = better_edge (beste, e);
2872
2873       if (beste)
2874         propagate_stack (beste);
2875       else
2876         {
2877           /* No predecessors.  Create an arbitrary input stack.  */
2878           bi->stack_in.top = -1;
2879           for (reg = LAST_STACK_REG; reg >= FIRST_STACK_REG; --reg)
2880             if (TEST_HARD_REG_BIT (bi->stack_in.reg_set, reg))
2881               bi->stack_in.reg[++bi->stack_in.top] = reg;
2882         }
2883     }
2884
2885   if (dump_file)
2886     {
2887       fprintf (dump_file, "\nBasic block %d\nInput stack: ", block->index);
2888       print_stack (dump_file, &bi->stack_in);
2889     }
2890
2891   /* Process all insns in this block.  Keep track of NEXT so that we
2892      don't process insns emitted while substituting in INSN.  */
2893   current_block = block;
2894   next = BB_HEAD (block);
2895   regstack = bi->stack_in;
2896   starting_stack_p = true;
2897
2898   do
2899     {
2900       insn = next;
2901       next = NEXT_INSN (insn);
2902
2903       /* Ensure we have not missed a block boundary.  */
2904       gcc_assert (next);
2905       if (insn == BB_END (block))
2906         next = NULL;
2907
2908       /* Don't bother processing unless there is a stack reg
2909          mentioned or if it's a CALL_INSN.  */
2910       if (stack_regs_mentioned (insn)
2911           || CALL_P (insn))
2912         {
2913           if (dump_file)
2914             {
2915               fprintf (dump_file, "  insn %d input stack: ",
2916                        INSN_UID (insn));
2917               print_stack (dump_file, &regstack);
2918             }
2919           control_flow_insn_deleted |= subst_stack_regs (insn, &regstack);
2920           starting_stack_p = false;
2921         }
2922     }
2923   while (next);
2924
2925   if (dump_file)
2926     {
2927       fprintf (dump_file, "Expected live registers [");
2928       for (reg = FIRST_STACK_REG; reg <= LAST_STACK_REG; ++reg)
2929         if (TEST_HARD_REG_BIT (bi->out_reg_set, reg))
2930           fprintf (dump_file, " %d", reg);
2931       fprintf (dump_file, " ]\nOutput stack: ");
2932       print_stack (dump_file, &regstack);
2933     }
2934
2935   insn = BB_END (block);
2936   if (JUMP_P (insn))
2937     insn = PREV_INSN (insn);
2938
2939   /* If the function is declared to return a value, but it returns one
2940      in only some cases, some registers might come live here.  Emit
2941      necessary moves for them.  */
2942
2943   for (reg = FIRST_STACK_REG; reg <= LAST_STACK_REG; ++reg)
2944     {
2945       if (TEST_HARD_REG_BIT (bi->out_reg_set, reg)
2946           && ! TEST_HARD_REG_BIT (regstack.reg_set, reg))
2947         {
2948           rtx set;
2949
2950           if (dump_file)
2951             fprintf (dump_file, "Emitting insn initializing reg %d\n", reg);
2952
2953           set = gen_rtx_SET (VOIDmode, FP_MODE_REG (reg, SFmode), not_a_num);
2954           insn = emit_insn_after (set, insn);
2955           control_flow_insn_deleted |= subst_stack_regs (insn, &regstack);
2956         }
2957     }
2958
2959   /* Amongst the insns possibly deleted during the substitution process above,
2960      might have been the only trapping insn in the block.  We purge the now
2961      possibly dead EH edges here to avoid an ICE from fixup_abnormal_edges,
2962      called at the end of convert_regs.  The order in which we process the
2963      blocks ensures that we never delete an already processed edge.
2964
2965      Note that, at this point, the CFG may have been damaged by the emission
2966      of instructions after an abnormal call, which moves the basic block end
2967      (and is the reason why we call fixup_abnormal_edges later).  So we must
2968      be sure that the trapping insn has been deleted before trying to purge
2969      dead edges, otherwise we risk purging valid edges.
2970
2971      ??? We are normally supposed not to delete trapping insns, so we pretend
2972      that the insns deleted above don't actually trap.  It would have been
2973      better to detect this earlier and avoid creating the EH edge in the first
2974      place, still, but we don't have enough information at that time.  */
2975
2976   if (control_flow_insn_deleted)
2977     purge_dead_edges (block);
2978
2979   /* Something failed if the stack lives don't match.  If we had malformed
2980      asms, we zapped the instruction itself, but that didn't produce the
2981      same pattern of register kills as before.  */
2982
2983   gcc_assert (hard_reg_set_equal_p (regstack.reg_set, bi->out_reg_set)
2984               || any_malformed_asm);
2985   bi->stack_out = regstack;
2986   bi->done = true;
2987 }
2988
2989 /* Convert registers in all blocks reachable from BLOCK.  */
2990
2991 static void
2992 convert_regs_2 (basic_block block)
2993 {
2994   basic_block *stack, *sp;
2995
2996   /* We process the blocks in a top-down manner, in a way such that one block
2997      is only processed after all its predecessors.  The number of predecessors
2998      of every block has already been computed.  */
2999
3000   stack = XNEWVEC (basic_block, n_basic_blocks);
3001   sp = stack;
3002
3003   *sp++ = block;
3004
3005   do
3006     {
3007       edge e;
3008       edge_iterator ei;
3009
3010       block = *--sp;
3011
3012       /* Processing BLOCK is achieved by convert_regs_1, which may purge
3013          some dead EH outgoing edge after the deletion of the trapping
3014          insn inside the block.  Since the number of predecessors of
3015          BLOCK's successors was computed based on the initial edge set,
3016          we check the necessity to process some of these successors
3017          before such an edge deletion may happen.  However, there is
3018          a pitfall: if BLOCK is the only predecessor of a successor and
3019          the edge between them happens to be deleted, the successor
3020          becomes unreachable and should not be processed.  The problem
3021          is that there is no way to preventively detect this case so we
3022          stack the successor in all cases and hand over the task of
3023          fixing up the discrepancy to convert_regs_1.  */
3024
3025       FOR_EACH_EDGE (e, ei, block->succs)
3026         if (! (e->flags & EDGE_DFS_BACK))
3027           {
3028             BLOCK_INFO (e->dest)->predecessors--;
3029             if (!BLOCK_INFO (e->dest)->predecessors)
3030               *sp++ = e->dest;
3031           }
3032
3033       convert_regs_1 (block);
3034     }
3035   while (sp != stack);
3036
3037   free (stack);
3038 }
3039
3040 /* Traverse all basic blocks in a function, converting the register
3041    references in each insn from the "flat" register file that gcc uses,
3042    to the stack-like registers the 387 uses.  */
3043
3044 static void
3045 convert_regs (void)
3046 {
3047   int inserted;
3048   basic_block b;
3049   edge e;
3050   edge_iterator ei;
3051
3052   /* Initialize uninitialized registers on function entry.  */
3053   inserted = convert_regs_entry ();
3054
3055   /* Construct the desired stack for function exit.  */
3056   convert_regs_exit ();
3057   BLOCK_INFO (EXIT_BLOCK_PTR)->done = 1;
3058
3059   /* ??? Future: process inner loops first, and give them arbitrary
3060      initial stacks which emit_swap_insn can modify.  This ought to
3061      prevent double fxch that often appears at the head of a loop.  */
3062
3063   /* Process all blocks reachable from all entry points.  */
3064   FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
3065     convert_regs_2 (e->dest);
3066
3067   /* ??? Process all unreachable blocks.  Though there's no excuse
3068      for keeping these even when not optimizing.  */
3069   FOR_EACH_BB (b)
3070     {
3071       block_info bi = BLOCK_INFO (b);
3072
3073       if (! bi->done)
3074         convert_regs_2 (b);
3075     }
3076
3077   inserted |= compensate_edges ();
3078
3079   clear_aux_for_blocks ();
3080
3081   fixup_abnormal_edges ();
3082   if (inserted)
3083     commit_edge_insertions ();
3084
3085   if (dump_file)
3086     fputc ('\n', dump_file);
3087 }
3088 \f
3089 /* Convert register usage from "flat" register file usage to a "stack
3090    register file.  FILE is the dump file, if used.
3091
3092    Construct a CFG and run life analysis.  Then convert each insn one
3093    by one.  Run a last cleanup_cfg pass, if optimizing, to eliminate
3094    code duplication created when the converter inserts pop insns on
3095    the edges.  */
3096
3097 static bool
3098 reg_to_stack (void)
3099 {
3100   basic_block bb;
3101   int i;
3102   int max_uid;
3103
3104   /* Clean up previous run.  */
3105   if (stack_regs_mentioned_data != NULL)
3106     VEC_free (char, heap, stack_regs_mentioned_data);
3107
3108   /* See if there is something to do.  Flow analysis is quite
3109      expensive so we might save some compilation time.  */
3110   for (i = FIRST_STACK_REG; i <= LAST_STACK_REG; i++)
3111     if (df_regs_ever_live_p (i))
3112       break;
3113   if (i > LAST_STACK_REG)
3114     return false;
3115
3116   df_note_add_problem ();
3117   df_analyze ();
3118
3119   mark_dfs_back_edges ();
3120
3121   /* Set up block info for each basic block.  */
3122   alloc_aux_for_blocks (sizeof (struct block_info_def));
3123   FOR_EACH_BB (bb)
3124     {
3125       block_info bi = BLOCK_INFO (bb);
3126       edge_iterator ei;
3127       edge e;
3128       int reg;
3129
3130       FOR_EACH_EDGE (e, ei, bb->preds)
3131         if (!(e->flags & EDGE_DFS_BACK)
3132             && e->src != ENTRY_BLOCK_PTR)
3133           bi->predecessors++;
3134
3135       /* Set current register status at last instruction `uninitialized'.  */
3136       bi->stack_in.top = -2;
3137
3138       /* Copy live_at_end and live_at_start into temporaries.  */
3139       for (reg = FIRST_STACK_REG; reg <= LAST_STACK_REG; reg++)
3140         {
3141           if (REGNO_REG_SET_P (DF_LR_OUT (bb), reg))
3142             SET_HARD_REG_BIT (bi->out_reg_set, reg);
3143           if (REGNO_REG_SET_P (DF_LR_IN (bb), reg))
3144             SET_HARD_REG_BIT (bi->stack_in.reg_set, reg);
3145         }
3146     }
3147
3148   /* Create the replacement registers up front.  */
3149   for (i = FIRST_STACK_REG; i <= LAST_STACK_REG; i++)
3150     {
3151       enum machine_mode mode;
3152       for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
3153            mode != VOIDmode;
3154            mode = GET_MODE_WIDER_MODE (mode))
3155         FP_MODE_REG (i, mode) = gen_rtx_REG (mode, i);
3156       for (mode = GET_CLASS_NARROWEST_MODE (MODE_COMPLEX_FLOAT);
3157            mode != VOIDmode;
3158            mode = GET_MODE_WIDER_MODE (mode))
3159         FP_MODE_REG (i, mode) = gen_rtx_REG (mode, i);
3160     }
3161
3162   ix86_flags_rtx = gen_rtx_REG (CCmode, FLAGS_REG);
3163
3164   /* A QNaN for initializing uninitialized variables.
3165
3166      ??? We can't load from constant memory in PIC mode, because
3167      we're inserting these instructions before the prologue and
3168      the PIC register hasn't been set up.  In that case, fall back
3169      on zero, which we can get from `ldz'.  */
3170
3171   if ((flag_pic && !TARGET_64BIT)
3172       || ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC)
3173     not_a_num = CONST0_RTX (SFmode);
3174   else
3175     {
3176       not_a_num = gen_lowpart (SFmode, GEN_INT (0x7fc00000));
3177       not_a_num = force_const_mem (SFmode, not_a_num);
3178     }
3179
3180   /* Allocate a cache for stack_regs_mentioned.  */
3181   max_uid = get_max_uid ();
3182   stack_regs_mentioned_data = VEC_alloc (char, heap, max_uid + 1);
3183   memset (VEC_address (char, stack_regs_mentioned_data),
3184           0, sizeof (char) * max_uid + 1);
3185
3186   convert_regs ();
3187
3188   free_aux_for_blocks ();
3189   return true;
3190 }
3191 #endif /* STACK_REGS */
3192 \f
3193 static bool
3194 gate_handle_stack_regs (void)
3195 {
3196 #ifdef STACK_REGS
3197   return 1;
3198 #else
3199   return 0;
3200 #endif
3201 }
3202
3203 struct tree_opt_pass pass_stack_regs =
3204 {
3205   NULL,                                 /* name */
3206   gate_handle_stack_regs,               /* gate */
3207   NULL,                                 /* execute */
3208   NULL,                                 /* sub */
3209   NULL,                                 /* next */
3210   0,                                    /* static_pass_number */
3211   TV_REG_STACK,                         /* tv_id */
3212   0,                                    /* properties_required */
3213   0,                                    /* properties_provided */
3214   0,                                    /* properties_destroyed */
3215   0,                                    /* todo_flags_start */
3216   0,                                    /* todo_flags_finish */
3217   0                                     /* letter */
3218 };
3219
3220 /* Convert register usage from flat register file usage to a stack
3221    register file.  */
3222 static unsigned int
3223 rest_of_handle_stack_regs (void)
3224 {
3225 #ifdef STACK_REGS
3226   reg_to_stack ();
3227   regstack_completed = 1;
3228 #endif
3229   return 0;
3230 }
3231
3232 struct tree_opt_pass pass_stack_regs_run =
3233 {
3234   "stack",                              /* name */
3235   NULL,                                 /* gate */
3236   rest_of_handle_stack_regs,            /* execute */
3237   NULL,                                 /* sub */
3238   NULL,                                 /* next */
3239   0,                                    /* static_pass_number */
3240   TV_REG_STACK,                         /* tv_id */
3241   0,                                    /* properties_required */
3242   0,                                    /* properties_provided */
3243   0,                                    /* properties_destroyed */
3244   0,                                    /* todo_flags_start */
3245   TODO_df_finish |
3246   TODO_dump_func |
3247   TODO_ggc_collect,                     /* todo_flags_finish */
3248   'k'                                   /* letter */
3249 };