contrib/gcc-4.4/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, 2008
   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 (const_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 (const_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 (const_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 = XALLOCAVEC (rtx, XVECLEN (body, 0));
 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_rtx;
 717
 718   note_link = &REG_NOTES (insn);
 719   for (this_rtx = *note_link; this_rtx; this_rtx = XEXP (this_rtx, 1))
 720     if (REG_NOTE_KIND (this_rtx) == note
 721         && REG_P (XEXP (this_rtx, 0)) && REGNO (XEXP (this_rtx, 0)) == regno)
 722       {
 723         *note_link = XEXP (this_rtx, 1);
 724         return;
 725       }
 726     else
 727       note_link = &XEXP (this_rtx, 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   add_reg_note (pop_insn, REG_DEAD, FP_MODE_REG (FIRST_STACK_REG, DFmode));
 792
 793   regstack->reg[regstack->top - (hard_regno - FIRST_STACK_REG)]
 794     = regstack->reg[regstack->top];
 795   regstack->top -= 1;
 796   CLEAR_HARD_REG_BIT (regstack->reg_set, REGNO (reg));
 797
 798   return pop_insn;
 799 }
 800 \f
 801 /* Emit an insn before or after INSN to swap virtual register REG with
 802    the top of stack.  REGSTACK is the stack state before the swap, and
 803    is updated to reflect the swap.  A swap insn is represented as a
 804    PARALLEL of two patterns: each pattern moves one reg to the other.
 805
 806    If REG is already at the top of the stack, no insn is emitted.  */
 807
 808 static void
 809 emit_swap_insn (rtx insn, stack regstack, rtx reg)
 810 {
 811   int hard_regno;
 812   rtx swap_rtx;
 813   int tmp, other_reg;           /* swap regno temps */
 814   rtx i1;                       /* the stack-reg insn prior to INSN */
 815   rtx i1set = NULL_RTX;         /* the SET rtx within I1 */
 816
 817   hard_regno = get_hard_regnum (regstack, reg);
 818
 819   if (hard_regno == FIRST_STACK_REG)
 820     return;
 821   if (hard_regno == -1)
 822     {
 823       /* Something failed if the register wasn't on the stack.  If we had
 824          malformed asms, we zapped the instruction itself, but that didn't
 825          produce the same pattern of register sets as before.  To prevent
 826          further failure, adjust REGSTACK to include REG at TOP.  */
 827       gcc_assert (any_malformed_asm);
 828       regstack->reg[++regstack->top] = REGNO (reg);
 829       return;
 830     }
 831   gcc_assert (hard_regno >= FIRST_STACK_REG);
 832
 833   other_reg = regstack->top - (hard_regno - FIRST_STACK_REG);
 834
 835   tmp = regstack->reg[other_reg];
 836   regstack->reg[other_reg] = regstack->reg[regstack->top];
 837   regstack->reg[regstack->top] = tmp;
 838
 839   /* Find the previous insn involving stack regs, but don't pass a
 840      block boundary.  */
 841   i1 = NULL;
 842   if (current_block && insn != BB_HEAD (current_block))
 843     {
 844       rtx tmp = PREV_INSN (insn);
 845       rtx limit = PREV_INSN (BB_HEAD (current_block));
 846       while (tmp != limit)
 847         {
 848           if (LABEL_P (tmp)
 849               || CALL_P (tmp)
 850               || NOTE_INSN_BASIC_BLOCK_P (tmp)
 851               || (NONJUMP_INSN_P (tmp)
 852                   && stack_regs_mentioned (tmp)))
 853             {
 854               i1 = tmp;
 855               break;
 856             }
 857           tmp = PREV_INSN (tmp);
 858         }
 859     }
 860
 861   if (i1 != NULL_RTX
 862       && (i1set = single_set (i1)) != NULL_RTX)
 863     {
 864       rtx i1src = *get_true_reg (&SET_SRC (i1set));
 865       rtx i1dest = *get_true_reg (&SET_DEST (i1set));
 866
 867       /* If the previous register stack push was from the reg we are to
 868          swap with, omit the swap.  */
 869
 870       if (REG_P (i1dest) && REGNO (i1dest) == FIRST_STACK_REG
 871           && REG_P (i1src)
 872           && REGNO (i1src) == (unsigned) hard_regno - 1
 873           && find_regno_note (i1, REG_DEAD, FIRST_STACK_REG) == NULL_RTX)
 874         return;
 875
 876       /* If the previous insn wrote to the reg we are to swap with,
 877          omit the swap.  */
 878
 879       if (REG_P (i1dest) && REGNO (i1dest) == (unsigned) hard_regno
 880           && REG_P (i1src) && REGNO (i1src) == FIRST_STACK_REG
 881           && find_regno_note (i1, REG_DEAD, FIRST_STACK_REG) == NULL_RTX)
 882         return;
 883     }
 884
 885   /* Avoid emitting the swap if this is the first register stack insn
 886      of the current_block.  Instead update the current_block's stack_in
 887      and let compensate edges take care of this for us.  */
 888   if (current_block && starting_stack_p)
 889     {
 890       BLOCK_INFO (current_block)->stack_in = *regstack;
 891       starting_stack_p = false;
 892       return;
 893     }
 894
 895   swap_rtx = gen_swapxf (FP_MODE_REG (hard_regno, XFmode),
 896                          FP_MODE_REG (FIRST_STACK_REG, XFmode));
 897
 898   if (i1)
 899     emit_insn_after (swap_rtx, i1);
 900   else if (current_block)
 901     emit_insn_before (swap_rtx, BB_HEAD (current_block));
 902   else
 903     emit_insn_before (swap_rtx, insn);
 904 }
 905 \f
 906 /* Emit an insns before INSN to swap virtual register SRC1 with
 907    the top of stack and virtual register SRC2 with second stack
 908    slot. REGSTACK is the stack state before the swaps, and
 909    is updated to reflect the swaps.  A swap insn is represented as a
 910    PARALLEL of two patterns: each pattern moves one reg to the other.
 911
 912    If SRC1 and/or SRC2 are already at the right place, no swap insn
 913    is emitted.  */
 914
 915 static void
 916 swap_to_top (rtx insn, stack regstack, rtx src1, rtx src2)
 917 {
 918   struct stack_def temp_stack;
 919   int regno, j, k, temp;
 920
 921   temp_stack = *regstack;
 922
 923   /* Place operand 1 at the top of stack.  */
 924   regno = get_hard_regnum (&temp_stack, src1);
 925   gcc_assert (regno >= 0);
 926   if (regno != FIRST_STACK_REG)
 927     {
 928       k = temp_stack.top - (regno - FIRST_STACK_REG);
 929       j = temp_stack.top;
 930
 931       temp = temp_stack.reg[k];
 932       temp_stack.reg[k] = temp_stack.reg[j];
 933       temp_stack.reg[j] = temp;
 934     }
 935
 936   /* Place operand 2 next on the stack.  */
 937   regno = get_hard_regnum (&temp_stack, src2);
 938   gcc_assert (regno >= 0);
 939   if (regno != FIRST_STACK_REG + 1)
 940     {
 941       k = temp_stack.top - (regno - FIRST_STACK_REG);
 942       j = temp_stack.top - 1;
 943
 944       temp = temp_stack.reg[k];
 945       temp_stack.reg[k] = temp_stack.reg[j];
 946       temp_stack.reg[j] = temp;
 947     }
 948
 949   change_stack (insn, regstack, &temp_stack, EMIT_BEFORE);
 950 }
 951 \f
 952 /* Handle a move to or from a stack register in PAT, which is in INSN.
 953    REGSTACK is the current stack.  Return whether a control flow insn
 954    was deleted in the process.  */
 955
 956 static bool
 957 move_for_stack_reg (rtx insn, stack regstack, rtx pat)
 958 {
 959   rtx *psrc =  get_true_reg (&SET_SRC (pat));
 960   rtx *pdest = get_true_reg (&SET_DEST (pat));
 961   rtx src, dest;
 962   rtx note;
 963   bool control_flow_insn_deleted = false;
 964
 965   src = *psrc; dest = *pdest;
 966
 967   if (STACK_REG_P (src) && STACK_REG_P (dest))
 968     {
 969       /* Write from one stack reg to another.  If SRC dies here, then
 970          just change the register mapping and delete the insn.  */
 971
 972       note = find_regno_note (insn, REG_DEAD, REGNO (src));
 973       if (note)
 974         {
 975           int i;
 976
 977           /* If this is a no-op move, there must not be a REG_DEAD note.  */
 978           gcc_assert (REGNO (src) != REGNO (dest));
 979
 980           for (i = regstack->top; i >= 0; i--)
 981             if (regstack->reg[i] == REGNO (src))
 982               break;
 983
 984           /* The destination must be dead, or life analysis is borked.  */
 985           gcc_assert (get_hard_regnum (regstack, dest) < FIRST_STACK_REG);
 986
 987           /* If the source is not live, this is yet another case of
 988              uninitialized variables.  Load up a NaN instead.  */
 989           if (i < 0)
 990             return move_nan_for_stack_reg (insn, regstack, dest);
 991
 992           /* It is possible that the dest is unused after this insn.
 993              If so, just pop the src.  */
 994
 995           if (find_regno_note (insn, REG_UNUSED, REGNO (dest)))
 996             emit_pop_insn (insn, regstack, src, EMIT_AFTER);
 997           else
 998             {
 999               regstack->reg[i] = REGNO (dest);
1000               SET_HARD_REG_BIT (regstack->reg_set, REGNO (dest));
1001               CLEAR_HARD_REG_BIT (regstack->reg_set, REGNO (src));
1002             }
1003
1004           control_flow_insn_deleted |= control_flow_insn_p (insn);
1005           delete_insn (insn);
1006           return control_flow_insn_deleted;
1007         }
1008
1009       /* The source reg does not die.  */
1010
1011       /* If this appears to be a no-op move, delete it, or else it
1012          will confuse the machine description output patterns. But if
1013          it is REG_UNUSED, we must pop the reg now, as per-insn processing
1014          for REG_UNUSED will not work for deleted insns.  */
1015
1016       if (REGNO (src) == REGNO (dest))
1017         {
1018           if (find_regno_note (insn, REG_UNUSED, REGNO (dest)))
1019             emit_pop_insn (insn, regstack, dest, EMIT_AFTER);
1020
1021           control_flow_insn_deleted |= control_flow_insn_p (insn);
1022           delete_insn (insn);
1023           return control_flow_insn_deleted;
1024         }
1025
1026       /* The destination ought to be dead.  */
1027       gcc_assert (get_hard_regnum (regstack, dest) < FIRST_STACK_REG);
1028
1029       replace_reg (psrc, get_hard_regnum (regstack, src));
1030
1031       regstack->reg[++regstack->top] = REGNO (dest);
1032       SET_HARD_REG_BIT (regstack->reg_set, REGNO (dest));
1033       replace_reg (pdest, FIRST_STACK_REG);
1034     }
1035   else if (STACK_REG_P (src))
1036     {
1037       /* Save from a stack reg to MEM, or possibly integer reg.  Since
1038          only top of stack may be saved, emit an exchange first if
1039          needs be.  */
1040
1041       emit_swap_insn (insn, regstack, src);
1042
1043       note = find_regno_note (insn, REG_DEAD, REGNO (src));
1044       if (note)
1045         {
1046           replace_reg (&XEXP (note, 0), FIRST_STACK_REG);
1047           regstack->top--;
1048           CLEAR_HARD_REG_BIT (regstack->reg_set, REGNO (src));
1049         }
1050       else if ((GET_MODE (src) == XFmode)
1051                && regstack->top < REG_STACK_SIZE - 1)
1052         {
1053           /* A 387 cannot write an XFmode value to a MEM without
1054              clobbering the source reg.  The output code can handle
1055              this by reading back the value from the MEM.
1056              But it is more efficient to use a temp register if one is
1057              available.  Push the source value here if the register
1058              stack is not full, and then write the value to memory via
1059              a pop.  */
1060           rtx push_rtx;
1061           rtx top_stack_reg = FP_MODE_REG (FIRST_STACK_REG, GET_MODE (src));
1062
1063           push_rtx = gen_movxf (top_stack_reg, top_stack_reg);
1064           emit_insn_before (push_rtx, insn);
1065           add_reg_note (insn, REG_DEAD, top_stack_reg);
1066         }
1067
1068       replace_reg (psrc, FIRST_STACK_REG);
1069     }
1070   else
1071     {
1072       rtx pat = PATTERN (insn);
1073
1074       gcc_assert (STACK_REG_P (dest));
1075
1076       /* Load from MEM, or possibly integer REG or constant, into the
1077          stack regs.  The actual target is always the top of the
1078          stack. The stack mapping is changed to reflect that DEST is
1079          now at top of stack.  */
1080
1081       /* The destination ought to be dead.  However, there is a
1082          special case with i387 UNSPEC_TAN, where destination is live
1083          (an argument to fptan) but inherent load of 1.0 is modelled
1084          as a load from a constant.  */
1085       if (GET_CODE (pat) == PARALLEL
1086           && XVECLEN (pat, 0) == 2
1087           && GET_CODE (XVECEXP (pat, 0, 1)) == SET
1088           && GET_CODE (SET_SRC (XVECEXP (pat, 0, 1))) == UNSPEC
1089           && XINT (SET_SRC (XVECEXP (pat, 0, 1)), 1) == UNSPEC_TAN)
1090         emit_swap_insn (insn, regstack, dest);
1091       else
1092         gcc_assert (get_hard_regnum (regstack, dest) < FIRST_STACK_REG);
1093
1094       gcc_assert (regstack->top < REG_STACK_SIZE);
1095
1096       regstack->reg[++regstack->top] = REGNO (dest);
1097       SET_HARD_REG_BIT (regstack->reg_set, REGNO (dest));
1098       replace_reg (pdest, FIRST_STACK_REG);
1099     }
1100
1101   return control_flow_insn_deleted;
1102 }
1103
1104 /* A helper function which replaces INSN with a pattern that loads up
1105    a NaN into DEST, then invokes move_for_stack_reg.  */
1106
1107 static bool
1108 move_nan_for_stack_reg (rtx insn, stack regstack, rtx dest)
1109 {
1110   rtx pat;
1111
1112   dest = FP_MODE_REG (REGNO (dest), SFmode);
1113   pat = gen_rtx_SET (VOIDmode, dest, not_a_num);
1114   PATTERN (insn) = pat;
1115   INSN_CODE (insn) = -1;
1116
1117   return move_for_stack_reg (insn, regstack, pat);
1118 }
1119 \f
1120 /* Swap the condition on a branch, if there is one.  Return true if we
1121    found a condition to swap.  False if the condition was not used as
1122    such.  */
1123
1124 static int
1125 swap_rtx_condition_1 (rtx pat)
1126 {
1127   const char *fmt;
1128   int i, r = 0;
1129
1130   if (COMPARISON_P (pat))
1131     {
1132       PUT_CODE (pat, swap_condition (GET_CODE (pat)));
1133       r = 1;
1134     }
1135   else
1136     {
1137       fmt = GET_RTX_FORMAT (GET_CODE (pat));
1138       for (i = GET_RTX_LENGTH (GET_CODE (pat)) - 1; i >= 0; i--)
1139         {
1140           if (fmt[i] == 'E')
1141             {
1142               int j;
1143
1144               for (j = XVECLEN (pat, i) - 1; j >= 0; j--)
1145                 r |= swap_rtx_condition_1 (XVECEXP (pat, i, j));
1146             }
1147           else if (fmt[i] == 'e')
1148             r |= swap_rtx_condition_1 (XEXP (pat, i));
1149         }
1150     }
1151
1152   return r;
1153 }
1154
1155 static int
1156 swap_rtx_condition (rtx insn)
1157 {
1158   rtx pat = PATTERN (insn);
1159
1160   /* We're looking for a single set to cc0 or an HImode temporary.  */
1161
1162   if (GET_CODE (pat) == SET
1163       && REG_P (SET_DEST (pat))
1164       && REGNO (SET_DEST (pat)) == FLAGS_REG)
1165     {
1166       insn = next_flags_user (insn);
1167       if (insn == NULL_RTX)
1168         return 0;
1169       pat = PATTERN (insn);
1170     }
1171
1172   /* See if this is, or ends in, a fnstsw.  If so, we're not doing anything
1173      with the cc value right now.  We may be able to search for one
1174      though.  */
1175
1176   if (GET_CODE (pat) == SET
1177       && GET_CODE (SET_SRC (pat)) == UNSPEC
1178       && XINT (SET_SRC (pat), 1) == UNSPEC_FNSTSW)
1179     {
1180       rtx dest = SET_DEST (pat);
1181
1182       /* Search forward looking for the first use of this value.
1183          Stop at block boundaries.  */
1184       while (insn != BB_END (current_block))
1185         {
1186           insn = NEXT_INSN (insn);
1187           if (INSN_P (insn) && reg_mentioned_p (dest, insn))
1188             break;
1189           if (CALL_P (insn))
1190             return 0;
1191         }
1192
1193       /* We haven't found it.  */
1194       if (insn == BB_END (current_block))
1195         return 0;
1196
1197       /* So we've found the insn using this value.  If it is anything
1198          other than sahf or the value does not die (meaning we'd have
1199          to search further), then we must give up.  */
1200       pat = PATTERN (insn);
1201       if (GET_CODE (pat) != SET
1202           || GET_CODE (SET_SRC (pat)) != UNSPEC
1203           || XINT (SET_SRC (pat), 1) != UNSPEC_SAHF
1204           || ! dead_or_set_p (insn, dest))
1205         return 0;
1206
1207       /* Now we are prepared to handle this as a normal cc0 setter.  */
1208       insn = next_flags_user (insn);
1209       if (insn == NULL_RTX)
1210         return 0;
1211       pat = PATTERN (insn);
1212     }
1213
1214   if (swap_rtx_condition_1 (pat))
1215     {
1216       int fail = 0;
1217       INSN_CODE (insn) = -1;
1218       if (recog_memoized (insn) == -1)
1219         fail = 1;
1220       /* In case the flags don't die here, recurse to try fix
1221          following user too.  */
1222       else if (! dead_or_set_p (insn, ix86_flags_rtx))
1223         {
1224           insn = next_flags_user (insn);
1225           if (!insn || !swap_rtx_condition (insn))
1226             fail = 1;
1227         }
1228       if (fail)
1229         {
1230           swap_rtx_condition_1 (pat);
1231           return 0;
1232         }
1233       return 1;
1234     }
1235   return 0;
1236 }
1237
1238 /* Handle a comparison.  Special care needs to be taken to avoid
1239    causing comparisons that a 387 cannot do correctly, such as EQ.
1240
1241    Also, a pop insn may need to be emitted.  The 387 does have an
1242    `fcompp' insn that can pop two regs, but it is sometimes too expensive
1243    to do this - a `fcomp' followed by a `fstpl %st(0)' may be easier to
1244    set up.  */
1245
1246 static void
1247 compare_for_stack_reg (rtx insn, stack regstack, rtx pat_src)
1248 {
1249   rtx *src1, *src2;
1250   rtx src1_note, src2_note;
1251
1252   src1 = get_true_reg (&XEXP (pat_src, 0));
1253   src2 = get_true_reg (&XEXP (pat_src, 1));
1254
1255   /* ??? If fxch turns out to be cheaper than fstp, give priority to
1256      registers that die in this insn - move those to stack top first.  */
1257   if ((! STACK_REG_P (*src1)
1258        || (STACK_REG_P (*src2)
1259            && get_hard_regnum (regstack, *src2) == FIRST_STACK_REG))
1260       && swap_rtx_condition (insn))
1261     {
1262       rtx temp;
1263       temp = XEXP (pat_src, 0);
1264       XEXP (pat_src, 0) = XEXP (pat_src, 1);
1265       XEXP (pat_src, 1) = temp;
1266
1267       src1 = get_true_reg (&XEXP (pat_src, 0));
1268       src2 = get_true_reg (&XEXP (pat_src, 1));
1269
1270       INSN_CODE (insn) = -1;
1271     }
1272
1273   /* We will fix any death note later.  */
1274
1275   src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
1276
1277   if (STACK_REG_P (*src2))
1278     src2_note = find_regno_note (insn, REG_DEAD, REGNO (*src2));
1279   else
1280     src2_note = NULL_RTX;
1281
1282   emit_swap_insn (insn, regstack, *src1);
1283
1284   replace_reg (src1, FIRST_STACK_REG);
1285
1286   if (STACK_REG_P (*src2))
1287     replace_reg (src2, get_hard_regnum (regstack, *src2));
1288
1289   if (src1_note)
1290     {
1291       pop_stack (regstack, REGNO (XEXP (src1_note, 0)));
1292       replace_reg (&XEXP (src1_note, 0), FIRST_STACK_REG);
1293     }
1294
1295   /* If the second operand dies, handle that.  But if the operands are
1296      the same stack register, don't bother, because only one death is
1297      needed, and it was just handled.  */
1298
1299   if (src2_note
1300       && ! (STACK_REG_P (*src1) && STACK_REG_P (*src2)
1301             && REGNO (*src1) == REGNO (*src2)))
1302     {
1303       /* As a special case, two regs may die in this insn if src2 is
1304          next to top of stack and the top of stack also dies.  Since
1305          we have already popped src1, "next to top of stack" is really
1306          at top (FIRST_STACK_REG) now.  */
1307
1308       if (get_hard_regnum (regstack, XEXP (src2_note, 0)) == FIRST_STACK_REG
1309           && src1_note)
1310         {
1311           pop_stack (regstack, REGNO (XEXP (src2_note, 0)));
1312           replace_reg (&XEXP (src2_note, 0), FIRST_STACK_REG + 1);
1313         }
1314       else
1315         {
1316           /* The 386 can only represent death of the first operand in
1317              the case handled above.  In all other cases, emit a separate
1318              pop and remove the death note from here.  */
1319
1320           /* link_cc0_insns (insn); */
1321
1322           remove_regno_note (insn, REG_DEAD, REGNO (XEXP (src2_note, 0)));
1323
1324           emit_pop_insn (insn, regstack, XEXP (src2_note, 0),
1325                          EMIT_AFTER);
1326         }
1327     }
1328 }
1329 \f
1330 /* Substitute new registers in PAT, which is part of INSN.  REGSTACK
1331    is the current register layout.  Return whether a control flow insn
1332    was deleted in the process.  */
1333
1334 static bool
1335 subst_stack_regs_pat (rtx insn, stack regstack, rtx pat)
1336 {
1337   rtx *dest, *src;
1338   bool control_flow_insn_deleted = false;
1339
1340   switch (GET_CODE (pat))
1341     {
1342     case USE:
1343       /* Deaths in USE insns can happen in non optimizing compilation.
1344          Handle them by popping the dying register.  */
1345       src = get_true_reg (&XEXP (pat, 0));
1346       if (STACK_REG_P (*src)
1347           && find_regno_note (insn, REG_DEAD, REGNO (*src)))
1348         {
1349           /* USEs are ignored for liveness information so USEs of dead
1350              register might happen.  */
1351           if (TEST_HARD_REG_BIT (regstack->reg_set, REGNO (*src)))
1352             emit_pop_insn (insn, regstack, *src, EMIT_AFTER);
1353           return control_flow_insn_deleted;
1354         }
1355       /* Uninitialized USE might happen for functions returning uninitialized
1356          value.  We will properly initialize the USE on the edge to EXIT_BLOCK,
1357          so it is safe to ignore the use here. This is consistent with behavior
1358          of dataflow analyzer that ignores USE too.  (This also imply that
1359          forcibly initializing the register to NaN here would lead to ICE later,
1360          since the REG_DEAD notes are not issued.)  */
1361       break;
1362
1363     case CLOBBER:
1364       {
1365         rtx note;
1366
1367         dest = get_true_reg (&XEXP (pat, 0));
1368         if (STACK_REG_P (*dest))
1369           {
1370             note = find_reg_note (insn, REG_DEAD, *dest);
1371
1372             if (pat != PATTERN (insn))
1373               {
1374                 /* The fix_truncdi_1 pattern wants to be able to
1375                    allocate its own scratch register.  It does this by
1376                    clobbering an fp reg so that it is assured of an
1377                    empty reg-stack register.  If the register is live,
1378                    kill it now.  Remove the DEAD/UNUSED note so we
1379                    don't try to kill it later too.
1380
1381                    In reality the UNUSED note can be absent in some
1382                    complicated cases when the register is reused for
1383                    partially set variable.  */
1384
1385                 if (note)
1386                   emit_pop_insn (insn, regstack, *dest, EMIT_BEFORE);
1387                 else
1388                   note = find_reg_note (insn, REG_UNUSED, *dest);
1389                 if (note)
1390                   remove_note (insn, note);
1391                 replace_reg (dest, FIRST_STACK_REG + 1);
1392               }
1393             else
1394               {
1395                 /* A top-level clobber with no REG_DEAD, and no hard-regnum
1396                    indicates an uninitialized value.  Because reload removed
1397                    all other clobbers, this must be due to a function
1398                    returning without a value.  Load up a NaN.  */
1399
1400                 if (!note)
1401                   {
1402                     rtx t = *dest;
1403                     if (COMPLEX_MODE_P (GET_MODE (t)))
1404                       {
1405                         rtx u = FP_MODE_REG (REGNO (t) + 1, SFmode);
1406                         if (get_hard_regnum (regstack, u) == -1)
1407                           {
1408                             rtx pat2 = gen_rtx_CLOBBER (VOIDmode, u);
1409                             rtx insn2 = emit_insn_before (pat2, insn);
1410                             control_flow_insn_deleted
1411                               |= move_nan_for_stack_reg (insn2, regstack, u);
1412                           }
1413                       }
1414                     if (get_hard_regnum (regstack, t) == -1)
1415                       control_flow_insn_deleted
1416                         |= move_nan_for_stack_reg (insn, regstack, t);
1417                   }
1418               }
1419           }
1420         break;
1421       }
1422
1423     case SET:
1424       {
1425         rtx *src1 = (rtx *) 0, *src2;
1426         rtx src1_note, src2_note;
1427         rtx pat_src;
1428
1429         dest = get_true_reg (&SET_DEST (pat));
1430         src  = get_true_reg (&SET_SRC (pat));
1431         pat_src = SET_SRC (pat);
1432
1433         /* See if this is a `movM' pattern, and handle elsewhere if so.  */
1434         if (STACK_REG_P (*src)
1435             || (STACK_REG_P (*dest)
1436                 && (REG_P (*src) || MEM_P (*src)
1437                     || GET_CODE (*src) == CONST_DOUBLE)))
1438           {
1439             control_flow_insn_deleted |= move_for_stack_reg (insn, regstack, pat);
1440             break;
1441           }
1442
1443         switch (GET_CODE (pat_src))
1444           {
1445           case COMPARE:
1446             compare_for_stack_reg (insn, regstack, pat_src);
1447             break;
1448
1449           case CALL:
1450             {
1451               int count;
1452               for (count = hard_regno_nregs[REGNO (*dest)][GET_MODE (*dest)];
1453                    --count >= 0;)
1454                 {
1455                   regstack->reg[++regstack->top] = REGNO (*dest) + count;
1456                   SET_HARD_REG_BIT (regstack->reg_set, REGNO (*dest) + count);
1457                 }
1458             }
1459             replace_reg (dest, FIRST_STACK_REG);
1460             break;
1461
1462           case REG:
1463             /* This is a `tstM2' case.  */
1464             gcc_assert (*dest == cc0_rtx);
1465             src1 = src;
1466
1467             /* Fall through.  */
1468
1469           case FLOAT_TRUNCATE:
1470           case SQRT:
1471           case ABS:
1472           case NEG:
1473             /* These insns only operate on the top of the stack. DEST might
1474                be cc0_rtx if we're processing a tstM pattern. Also, it's
1475                possible that the tstM case results in a REG_DEAD note on the
1476                source.  */
1477
1478             if (src1 == 0)
1479               src1 = get_true_reg (&XEXP (pat_src, 0));
1480
1481             emit_swap_insn (insn, regstack, *src1);
1482
1483             src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
1484
1485             if (STACK_REG_P (*dest))
1486               replace_reg (dest, FIRST_STACK_REG);
1487
1488             if (src1_note)
1489               {
1490                 replace_reg (&XEXP (src1_note, 0), FIRST_STACK_REG);
1491                 regstack->top--;
1492                 CLEAR_HARD_REG_BIT (regstack->reg_set, REGNO (*src1));
1493               }
1494
1495             replace_reg (src1, FIRST_STACK_REG);
1496             break;
1497
1498           case MINUS:
1499           case DIV:
1500             /* On i386, reversed forms of subM3 and divM3 exist for
1501                MODE_FLOAT, so the same code that works for addM3 and mulM3
1502                can be used.  */
1503           case MULT:
1504           case PLUS:
1505             /* These insns can accept the top of stack as a destination
1506                from a stack reg or mem, or can use the top of stack as a
1507                source and some other stack register (possibly top of stack)
1508                as a destination.  */
1509
1510             src1 = get_true_reg (&XEXP (pat_src, 0));
1511             src2 = get_true_reg (&XEXP (pat_src, 1));
1512
1513             /* We will fix any death note later.  */
1514
1515             if (STACK_REG_P (*src1))
1516               src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
1517             else
1518               src1_note = NULL_RTX;
1519             if (STACK_REG_P (*src2))
1520               src2_note = find_regno_note (insn, REG_DEAD, REGNO (*src2));
1521             else
1522               src2_note = NULL_RTX;
1523
1524             /* If either operand is not a stack register, then the dest
1525                must be top of stack.  */
1526
1527             if (! STACK_REG_P (*src1) || ! STACK_REG_P (*src2))
1528               emit_swap_insn (insn, regstack, *dest);
1529             else
1530               {
1531                 /* Both operands are REG.  If neither operand is already
1532                    at the top of stack, choose to make the one that is the
1533                    dest the new top of stack.  */
1534
1535                 int src1_hard_regnum, src2_hard_regnum;
1536
1537                 src1_hard_regnum = get_hard_regnum (regstack, *src1);
1538                 src2_hard_regnum = get_hard_regnum (regstack, *src2);
1539
1540                 /* If the source is not live, this is yet another case of
1541                    uninitialized variables.  Load up a NaN instead.  */
1542                 if (src1_hard_regnum == -1)
1543                   {
1544                     rtx pat2 = gen_rtx_CLOBBER (VOIDmode, *src1);
1545                     rtx insn2 = emit_insn_before (pat2, insn);
1546                     control_flow_insn_deleted
1547                       |= move_nan_for_stack_reg (insn2, regstack, *src1);
1548                   }
1549                 if (src2_hard_regnum == -1)
1550                   {
1551                     rtx pat2 = gen_rtx_CLOBBER (VOIDmode, *src2);
1552                     rtx insn2 = emit_insn_before (pat2, insn);
1553                     control_flow_insn_deleted
1554                       |= move_nan_for_stack_reg (insn2, regstack, *src2);
1555                   }
1556
1557                 if (src1_hard_regnum != FIRST_STACK_REG
1558                     && src2_hard_regnum != FIRST_STACK_REG)
1559                   emit_swap_insn (insn, regstack, *dest);
1560               }
1561
1562             if (STACK_REG_P (*src1))
1563               replace_reg (src1, get_hard_regnum (regstack, *src1));
1564             if (STACK_REG_P (*src2))
1565               replace_reg (src2, get_hard_regnum (regstack, *src2));
1566
1567             if (src1_note)
1568               {
1569                 rtx src1_reg = XEXP (src1_note, 0);
1570
1571                 /* If the register that dies is at the top of stack, then
1572                    the destination is somewhere else - merely substitute it.
1573                    But if the reg that dies is not at top of stack, then
1574                    move the top of stack to the dead reg, as though we had
1575                    done the insn and then a store-with-pop.  */
1576
1577                 if (REGNO (src1_reg) == regstack->reg[regstack->top])
1578                   {
1579                     SET_HARD_REG_BIT (regstack->reg_set, REGNO (*dest));
1580                     replace_reg (dest, get_hard_regnum (regstack, *dest));
1581                   }
1582                 else
1583                   {
1584                     int regno = get_hard_regnum (regstack, src1_reg);
1585
1586                     SET_HARD_REG_BIT (regstack->reg_set, REGNO (*dest));
1587                     replace_reg (dest, regno);
1588
1589                     regstack->reg[regstack->top - (regno - FIRST_STACK_REG)]
1590                       = regstack->reg[regstack->top];
1591                   }
1592
1593                 CLEAR_HARD_REG_BIT (regstack->reg_set,
1594                                     REGNO (XEXP (src1_note, 0)));
1595                 replace_reg (&XEXP (src1_note, 0), FIRST_STACK_REG);
1596                 regstack->top--;
1597               }
1598             else if (src2_note)
1599               {
1600                 rtx src2_reg = XEXP (src2_note, 0);
1601                 if (REGNO (src2_reg) == regstack->reg[regstack->top])
1602                   {
1603                     SET_HARD_REG_BIT (regstack->reg_set, REGNO (*dest));
1604                     replace_reg (dest, get_hard_regnum (regstack, *dest));
1605                   }
1606                 else
1607                   {
1608                     int regno = get_hard_regnum (regstack, src2_reg);
1609
1610                     SET_HARD_REG_BIT (regstack->reg_set, REGNO (*dest));
1611                     replace_reg (dest, regno);
1612
1613                     regstack->reg[regstack->top - (regno - FIRST_STACK_REG)]
1614                       = regstack->reg[regstack->top];
1615                   }
1616
1617                 CLEAR_HARD_REG_BIT (regstack->reg_set,
1618                                     REGNO (XEXP (src2_note, 0)));
1619                 replace_reg (&XEXP (src2_note, 0), FIRST_STACK_REG);
1620                 regstack->top--;
1621               }
1622             else
1623               {
1624                 SET_HARD_REG_BIT (regstack->reg_set, REGNO (*dest));
1625                 replace_reg (dest, get_hard_regnum (regstack, *dest));
1626               }
1627
1628             /* Keep operand 1 matching with destination.  */
1629             if (COMMUTATIVE_ARITH_P (pat_src)
1630                 && REG_P (*src1) && REG_P (*src2)
1631                 && REGNO (*src1) != REGNO (*dest))
1632              {
1633                 int tmp = REGNO (*src1);
1634                 replace_reg (src1, REGNO (*src2));
1635                 replace_reg (src2, tmp);
1636              }
1637             break;
1638
1639           case UNSPEC:
1640             switch (XINT (pat_src, 1))
1641               {
1642               case UNSPEC_FIST:
1643
1644               case UNSPEC_FIST_FLOOR:
1645               case UNSPEC_FIST_CEIL:
1646
1647                 /* These insns only operate on the top of the stack.  */
1648
1649                 src1 = get_true_reg (&XVECEXP (pat_src, 0, 0));
1650                 emit_swap_insn (insn, regstack, *src1);
1651
1652                 src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
1653
1654                 if (STACK_REG_P (*dest))
1655                   replace_reg (dest, FIRST_STACK_REG);
1656
1657                 if (src1_note)
1658                   {
1659                     replace_reg (&XEXP (src1_note, 0), FIRST_STACK_REG);
1660                     regstack->top--;
1661                     CLEAR_HARD_REG_BIT (regstack->reg_set, REGNO (*src1));
1662                   }
1663
1664                 replace_reg (src1, FIRST_STACK_REG);
1665                 break;
1666
1667               case UNSPEC_FXAM:
1668
1669                 /* This insn only operate on the top of the stack.  */
1670
1671                 src1 = get_true_reg (&XVECEXP (pat_src, 0, 0));
1672                 emit_swap_insn (insn, regstack, *src1);
1673
1674                 src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
1675
1676                 replace_reg (src1, FIRST_STACK_REG);
1677
1678                 if (src1_note)
1679                   {
1680                     remove_regno_note (insn, REG_DEAD,
1681                                        REGNO (XEXP (src1_note, 0)));
1682                     emit_pop_insn (insn, regstack, XEXP (src1_note, 0),
1683                                    EMIT_AFTER);
1684                   }
1685
1686                 break;
1687
1688               case UNSPEC_SIN:
1689               case UNSPEC_COS:
1690               case UNSPEC_FRNDINT:
1691               case UNSPEC_F2XM1:
1692
1693               case UNSPEC_FRNDINT_FLOOR:
1694               case UNSPEC_FRNDINT_CEIL:
1695               case UNSPEC_FRNDINT_TRUNC:
1696               case UNSPEC_FRNDINT_MASK_PM:
1697
1698                 /* Above insns operate on the top of the stack.  */
1699
1700               case UNSPEC_SINCOS_COS:
1701               case UNSPEC_XTRACT_FRACT:
1702
1703                 /* Above insns operate on the top two stack slots,
1704                    first part of one input, double output insn.  */
1705
1706                 src1 = get_true_reg (&XVECEXP (pat_src, 0, 0));
1707
1708                 emit_swap_insn (insn, regstack, *src1);
1709
1710                 /* Input should never die, it is replaced with output.  */
1711                 src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
1712                 gcc_assert (!src1_note);
1713
1714                 if (STACK_REG_P (*dest))
1715                   replace_reg (dest, FIRST_STACK_REG);
1716
1717                 replace_reg (src1, FIRST_STACK_REG);
1718                 break;
1719
1720               case UNSPEC_SINCOS_SIN:
1721               case UNSPEC_XTRACT_EXP:
1722
1723                 /* These insns operate on the top two stack slots,
1724                    second part of one input, double output insn.  */
1725
1726                 regstack->top++;
1727                 /* FALLTHRU */
1728
1729               case UNSPEC_TAN:
1730
1731                 /* For UNSPEC_TAN, regstack->top is already increased
1732                    by inherent load of constant 1.0.  */
1733
1734                 /* Output value is generated in the second stack slot.
1735                    Move current value from second slot to the top.  */
1736                 regstack->reg[regstack->top]
1737                   = regstack->reg[regstack->top - 1];
1738
1739                 gcc_assert (STACK_REG_P (*dest));
1740
1741                 regstack->reg[regstack->top - 1] = REGNO (*dest);
1742                 SET_HARD_REG_BIT (regstack->reg_set, REGNO (*dest));
1743                 replace_reg (dest, FIRST_STACK_REG + 1);
1744
1745                 src1 = get_true_reg (&XVECEXP (pat_src, 0, 0));
1746
1747                 replace_reg (src1, FIRST_STACK_REG);
1748                 break;
1749
1750               case UNSPEC_FPATAN:
1751               case UNSPEC_FYL2X:
1752               case UNSPEC_FYL2XP1:
1753                 /* These insns operate on the top two stack slots.  */
1754
1755                 src1 = get_true_reg (&XVECEXP (pat_src, 0, 0));
1756                 src2 = get_true_reg (&XVECEXP (pat_src, 0, 1));
1757
1758                 src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
1759                 src2_note = find_regno_note (insn, REG_DEAD, REGNO (*src2));
1760
1761                 swap_to_top (insn, regstack, *src1, *src2);
1762
1763                 replace_reg (src1, FIRST_STACK_REG);
1764                 replace_reg (src2, FIRST_STACK_REG + 1);
1765
1766                 if (src1_note)
1767                   replace_reg (&XEXP (src1_note, 0), FIRST_STACK_REG);
1768                 if (src2_note)
1769                   replace_reg (&XEXP (src2_note, 0), FIRST_STACK_REG + 1);
1770
1771                 /* Pop both input operands from the stack.  */
1772                 CLEAR_HARD_REG_BIT (regstack->reg_set,
1773                                     regstack->reg[regstack->top]);
1774                 CLEAR_HARD_REG_BIT (regstack->reg_set,
1775                                     regstack->reg[regstack->top - 1]);
1776                 regstack->top -= 2;
1777
1778                 /* Push the result back onto the stack.  */
1779                 regstack->reg[++regstack->top] = REGNO (*dest);
1780                 SET_HARD_REG_BIT (regstack->reg_set, REGNO (*dest));
1781                 replace_reg (dest, FIRST_STACK_REG);
1782                 break;
1783
1784               case UNSPEC_FSCALE_FRACT:
1785               case UNSPEC_FPREM_F:
1786               case UNSPEC_FPREM1_F:
1787                 /* These insns operate on the top two stack slots,
1788                    first part of double input, double output insn.  */
1789
1790                 src1 = get_true_reg (&XVECEXP (pat_src, 0, 0));
1791                 src2 = get_true_reg (&XVECEXP (pat_src, 0, 1));
1792
1793                 src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
1794                 src2_note = find_regno_note (insn, REG_DEAD, REGNO (*src2));
1795
1796                 /* Inputs should never die, they are
1797                    replaced with outputs.  */
1798                 gcc_assert (!src1_note);
1799                 gcc_assert (!src2_note);
1800
1801                 swap_to_top (insn, regstack, *src1, *src2);
1802
1803                 /* Push the result back onto stack. Empty stack slot
1804                    will be filled in second part of insn.  */
1805                 if (STACK_REG_P (*dest))
1806                   {
1807                     regstack->reg[regstack->top] = REGNO (*dest);
1808                     SET_HARD_REG_BIT (regstack->reg_set, REGNO (*dest));
1809                     replace_reg (dest, FIRST_STACK_REG);
1810                   }
1811
1812                 replace_reg (src1, FIRST_STACK_REG);
1813                 replace_reg (src2, FIRST_STACK_REG + 1);
1814                 break;
1815
1816               case UNSPEC_FSCALE_EXP:
1817               case UNSPEC_FPREM_U:
1818               case UNSPEC_FPREM1_U:
1819                 /* These insns operate on the top two stack slots,
1820                    second part of double input, double output insn.  */
1821
1822                 src1 = get_true_reg (&XVECEXP (pat_src, 0, 0));
1823                 src2 = get_true_reg (&XVECEXP (pat_src, 0, 1));
1824
1825                 /* Push the result back onto stack. Fill empty slot from
1826                    first part of insn and fix top of stack pointer.  */
1827                 if (STACK_REG_P (*dest))
1828                   {
1829                     regstack->reg[regstack->top - 1] = REGNO (*dest);
1830                     SET_HARD_REG_BIT (regstack->reg_set, REGNO (*dest));
1831                     replace_reg (dest, FIRST_STACK_REG + 1);
1832                   }
1833
1834                 replace_reg (src1, FIRST_STACK_REG);
1835                 replace_reg (src2, FIRST_STACK_REG + 1);
1836                 break;
1837
1838               case UNSPEC_C2_FLAG:
1839                 /* This insn operates on the top two stack slots,
1840                    third part of C2 setting double input insn.  */
1841
1842                 src1 = get_true_reg (&XVECEXP (pat_src, 0, 0));
1843                 src2 = get_true_reg (&XVECEXP (pat_src, 0, 1));
1844
1845                 replace_reg (src1, FIRST_STACK_REG);
1846                 replace_reg (src2, FIRST_STACK_REG + 1);
1847                 break;
1848
1849               case UNSPEC_SAHF:
1850                 /* (unspec [(unspec [(compare)] UNSPEC_FNSTSW)] UNSPEC_SAHF)
1851                    The combination matches the PPRO fcomi instruction.  */
1852
1853                 pat_src = XVECEXP (pat_src, 0, 0);
1854                 gcc_assert (GET_CODE (pat_src) == UNSPEC);
1855                 gcc_assert (XINT (pat_src, 1) == UNSPEC_FNSTSW);
1856                 /* Fall through.  */
1857
1858               case UNSPEC_FNSTSW:
1859                 /* Combined fcomp+fnstsw generated for doing well with
1860                    CSE.  When optimizing this would have been broken
1861                    up before now.  */
1862
1863                 pat_src = XVECEXP (pat_src, 0, 0);
1864                 gcc_assert (GET_CODE (pat_src) == COMPARE);
1865
1866                 compare_for_stack_reg (insn, regstack, pat_src);
1867                 break;
1868
1869               default:
1870                 gcc_unreachable ();
1871               }
1872             break;
1873
1874           case IF_THEN_ELSE:
1875             /* This insn requires the top of stack to be the destination.  */
1876
1877             src1 = get_true_reg (&XEXP (pat_src, 1));
1878             src2 = get_true_reg (&XEXP (pat_src, 2));
1879
1880             src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
1881             src2_note = find_regno_note (insn, REG_DEAD, REGNO (*src2));
1882
1883             /* If the comparison operator is an FP comparison operator,
1884                it is handled correctly by compare_for_stack_reg () who
1885                will move the destination to the top of stack. But if the
1886                comparison operator is not an FP comparison operator, we
1887                have to handle it here.  */
1888             if (get_hard_regnum (regstack, *dest) >= FIRST_STACK_REG
1889                 && REGNO (*dest) != regstack->reg[regstack->top])
1890               {
1891                 /* In case one of operands is the top of stack and the operands
1892                    dies, it is safe to make it the destination operand by
1893                    reversing the direction of cmove and avoid fxch.  */
1894                 if ((REGNO (*src1) == regstack->reg[regstack->top]
1895                      && src1_note)
1896                     || (REGNO (*src2) == regstack->reg[regstack->top]
1897                         && src2_note))
1898                   {
1899                     int idx1 = (get_hard_regnum (regstack, *src1)
1900                                 - FIRST_STACK_REG);
1901                     int idx2 = (get_hard_regnum (regstack, *src2)
1902                                 - FIRST_STACK_REG);
1903
1904                     /* Make reg-stack believe that the operands are already
1905                        swapped on the stack */
1906                     regstack->reg[regstack->top - idx1] = REGNO (*src2);
1907                     regstack->reg[regstack->top - idx2] = REGNO (*src1);
1908
1909                     /* Reverse condition to compensate the operand swap.
1910                        i386 do have comparison always reversible.  */
1911                     PUT_CODE (XEXP (pat_src, 0),
1912                               reversed_comparison_code (XEXP (pat_src, 0), insn));
1913                   }
1914                 else
1915                   emit_swap_insn (insn, regstack, *dest);
1916               }
1917
1918             {
1919               rtx src_note [3];
1920               int i;
1921
1922               src_note[0] = 0;
1923               src_note[1] = src1_note;
1924               src_note[2] = src2_note;
1925
1926               if (STACK_REG_P (*src1))
1927                 replace_reg (src1, get_hard_regnum (regstack, *src1));
1928               if (STACK_REG_P (*src2))
1929                 replace_reg (src2, get_hard_regnum (regstack, *src2));
1930
1931               for (i = 1; i <= 2; i++)
1932                 if (src_note [i])
1933                   {
1934                     int regno = REGNO (XEXP (src_note[i], 0));
1935
1936                     /* If the register that dies is not at the top of
1937                        stack, then move the top of stack to the dead reg.
1938                        Top of stack should never die, as it is the
1939                        destination.  */
1940                     gcc_assert (regno != regstack->reg[regstack->top]);
1941                     remove_regno_note (insn, REG_DEAD, regno);
1942                     emit_pop_insn (insn, regstack, XEXP (src_note[i], 0),
1943                                     EMIT_AFTER);
1944                   }
1945             }
1946
1947             /* Make dest the top of stack.  Add dest to regstack if
1948                not present.  */
1949             if (get_hard_regnum (regstack, *dest) < FIRST_STACK_REG)
1950               regstack->reg[++regstack->top] = REGNO (*dest);
1951             SET_HARD_REG_BIT (regstack->reg_set, REGNO (*dest));
1952             replace_reg (dest, FIRST_STACK_REG);
1953             break;
1954
1955           default:
1956             gcc_unreachable ();
1957           }
1958         break;
1959       }
1960
1961     default:
1962       break;
1963     }
1964
1965   return control_flow_insn_deleted;
1966 }
1967 \f
1968 /* Substitute hard regnums for any stack regs in INSN, which has
1969    N_INPUTS inputs and N_OUTPUTS outputs.  REGSTACK is the stack info
1970    before the insn, and is updated with changes made here.
1971
1972    There are several requirements and assumptions about the use of
1973    stack-like regs in asm statements.  These rules are enforced by
1974    record_asm_stack_regs; see comments there for details.  Any
1975    asm_operands left in the RTL at this point may be assume to meet the
1976    requirements, since record_asm_stack_regs removes any problem asm.  */
1977
1978 static void
1979 subst_asm_stack_regs (rtx insn, stack regstack)
1980 {
1981   rtx body = PATTERN (insn);
1982   int alt;
1983
1984   rtx *note_reg;                /* Array of note contents */
1985   rtx **note_loc;               /* Address of REG field of each note */
1986   enum reg_note *note_kind;     /* The type of each note */
1987
1988   rtx *clobber_reg = 0;
1989   rtx **clobber_loc = 0;
1990
1991   struct stack_def temp_stack;
1992   int n_notes;
1993   int n_clobbers;
1994   rtx note;
1995   int i;
1996   int n_inputs, n_outputs;
1997
1998   if (! check_asm_stack_operands (insn))
1999     return;
2000
2001   /* Find out what the constraints required.  If no constraint
2002      alternative matches, that is a compiler bug: we should have caught
2003      such an insn in check_asm_stack_operands.  */
2004   extract_insn (insn);
2005   constrain_operands (1);
2006   alt = which_alternative;
2007
2008   preprocess_constraints ();
2009
2010   n_inputs = get_asm_operand_n_inputs (body);
2011   n_outputs = recog_data.n_operands - n_inputs;
2012
2013   gcc_assert (alt >= 0);
2014
2015   /* Strip SUBREGs here to make the following code simpler.  */
2016   for (i = 0; i < recog_data.n_operands; i++)
2017     if (GET_CODE (recog_data.operand[i]) == SUBREG
2018         && REG_P (SUBREG_REG (recog_data.operand[i])))
2019       {
2020         recog_data.operand_loc[i] = & SUBREG_REG (recog_data.operand[i]);
2021         recog_data.operand[i] = SUBREG_REG (recog_data.operand[i]);
2022       }
2023
2024   /* Set up NOTE_REG, NOTE_LOC and NOTE_KIND.  */
2025
2026   for (i = 0, note = REG_NOTES (insn); note; note = XEXP (note, 1))
2027     i++;
2028
2029   note_reg = XALLOCAVEC (rtx, i);
2030   note_loc = XALLOCAVEC (rtx *, i);
2031   note_kind = XALLOCAVEC (enum reg_note, i);
2032
2033   n_notes = 0;
2034   for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
2035     {
2036       rtx reg = XEXP (note, 0);
2037       rtx *loc = & XEXP (note, 0);
2038
2039       if (GET_CODE (reg) == SUBREG && REG_P (SUBREG_REG (reg)))
2040         {
2041           loc = & SUBREG_REG (reg);
2042           reg = SUBREG_REG (reg);
2043         }
2044
2045       if (STACK_REG_P (reg)
2046           && (REG_NOTE_KIND (note) == REG_DEAD
2047               || REG_NOTE_KIND (note) == REG_UNUSED))
2048         {
2049           note_reg[n_notes] = reg;
2050           note_loc[n_notes] = loc;
2051           note_kind[n_notes] = REG_NOTE_KIND (note);
2052           n_notes++;
2053         }
2054     }
2055
2056   /* Set up CLOBBER_REG and CLOBBER_LOC.  */
2057
2058   n_clobbers = 0;
2059
2060   if (GET_CODE (body) == PARALLEL)
2061     {
2062       clobber_reg = XALLOCAVEC (rtx, XVECLEN (body, 0));
2063       clobber_loc = XALLOCAVEC (rtx *, XVECLEN (body, 0));
2064
2065       for (i = 0; i < XVECLEN (body, 0); i++)
2066         if (GET_CODE (XVECEXP (body, 0, i)) == CLOBBER)
2067           {
2068             rtx clobber = XVECEXP (body, 0, i);
2069             rtx reg = XEXP (clobber, 0);
2070             rtx *loc = & XEXP (clobber, 0);
2071
2072             if (GET_CODE (reg) == SUBREG && REG_P (SUBREG_REG (reg)))
2073               {
2074                 loc = & SUBREG_REG (reg);
2075                 reg = SUBREG_REG (reg);
2076               }
2077
2078             if (STACK_REG_P (reg))
2079               {
2080                 clobber_reg[n_clobbers] = reg;
2081                 clobber_loc[n_clobbers] = loc;
2082                 n_clobbers++;
2083               }
2084           }
2085     }
2086
2087   temp_stack = *regstack;
2088
2089   /* Put the input regs into the desired place in TEMP_STACK.  */
2090
2091   for (i = n_outputs; i < n_outputs + n_inputs; i++)
2092     if (STACK_REG_P (recog_data.operand[i])
2093         && reg_class_subset_p (recog_op_alt[i][alt].cl,
2094                                FLOAT_REGS)
2095         && recog_op_alt[i][alt].cl != FLOAT_REGS)
2096       {
2097         /* If an operand needs to be in a particular reg in
2098            FLOAT_REGS, the constraint was either 't' or 'u'.  Since
2099            these constraints are for single register classes, and
2100            reload guaranteed that operand[i] is already in that class,
2101            we can just use REGNO (recog_data.operand[i]) to know which
2102            actual reg this operand needs to be in.  */
2103
2104         int regno = get_hard_regnum (&temp_stack, recog_data.operand[i]);
2105
2106         gcc_assert (regno >= 0);
2107
2108         if ((unsigned int) regno != REGNO (recog_data.operand[i]))
2109           {
2110             /* recog_data.operand[i] is not in the right place.  Find
2111                it and swap it with whatever is already in I's place.
2112                K is where recog_data.operand[i] is now.  J is where it
2113                should be.  */
2114             int j, k, temp;
2115
2116             k = temp_stack.top - (regno - FIRST_STACK_REG);
2117             j = (temp_stack.top
2118                  - (REGNO (recog_data.operand[i]) - FIRST_STACK_REG));
2119
2120             temp = temp_stack.reg[k];
2121             temp_stack.reg[k] = temp_stack.reg[j];
2122             temp_stack.reg[j] = temp;
2123           }
2124       }
2125
2126   /* Emit insns before INSN to make sure the reg-stack is in the right
2127      order.  */
2128
2129   change_stack (insn, regstack, &temp_stack, EMIT_BEFORE);
2130
2131   /* Make the needed input register substitutions.  Do death notes and
2132      clobbers too, because these are for inputs, not outputs.  */
2133
2134   for (i = n_outputs; i < n_outputs + n_inputs; i++)
2135     if (STACK_REG_P (recog_data.operand[i]))
2136       {
2137         int regnum = get_hard_regnum (regstack, recog_data.operand[i]);
2138
2139         gcc_assert (regnum >= 0);
2140
2141         replace_reg (recog_data.operand_loc[i], regnum);
2142       }
2143
2144   for (i = 0; i < n_notes; i++)
2145     if (note_kind[i] == REG_DEAD)
2146       {
2147         int regnum = get_hard_regnum (regstack, note_reg[i]);
2148
2149         gcc_assert (regnum >= 0);
2150
2151         replace_reg (note_loc[i], regnum);
2152       }
2153
2154   for (i = 0; i < n_clobbers; i++)
2155     {
2156       /* It's OK for a CLOBBER to reference a reg that is not live.
2157          Don't try to replace it in that case.  */
2158       int regnum = get_hard_regnum (regstack, clobber_reg[i]);
2159
2160       if (regnum >= 0)
2161         {
2162           /* Sigh - clobbers always have QImode.  But replace_reg knows
2163              that these regs can't be MODE_INT and will assert.  Just put
2164              the right reg there without calling replace_reg.  */
2165
2166           *clobber_loc[i] = FP_MODE_REG (regnum, DFmode);
2167         }
2168     }
2169
2170   /* Now remove from REGSTACK any inputs that the asm implicitly popped.  */
2171
2172   for (i = n_outputs; i < n_outputs + n_inputs; i++)
2173     if (STACK_REG_P (recog_data.operand[i]))
2174       {
2175         /* An input reg is implicitly popped if it is tied to an
2176            output, or if there is a CLOBBER for it.  */
2177         int j;
2178
2179         for (j = 0; j < n_clobbers; j++)
2180           if (operands_match_p (clobber_reg[j], recog_data.operand[i]))
2181             break;
2182
2183         if (j < n_clobbers || recog_op_alt[i][alt].matches >= 0)
2184           {
2185             /* recog_data.operand[i] might not be at the top of stack.
2186                But that's OK, because all we need to do is pop the
2187                right number of regs off of the top of the reg-stack.
2188                record_asm_stack_regs guaranteed that all implicitly
2189                popped regs were grouped at the top of the reg-stack.  */
2190
2191             CLEAR_HARD_REG_BIT (regstack->reg_set,
2192                                 regstack->reg[regstack->top]);
2193             regstack->top--;
2194           }
2195       }
2196
2197   /* Now add to REGSTACK any outputs that the asm implicitly pushed.
2198      Note that there isn't any need to substitute register numbers.
2199      ???  Explain why this is true.  */
2200
2201   for (i = LAST_STACK_REG; i >= FIRST_STACK_REG; i--)
2202     {
2203       /* See if there is an output for this hard reg.  */
2204       int j;
2205
2206       for (j = 0; j < n_outputs; j++)
2207         if (STACK_REG_P (recog_data.operand[j])
2208             && REGNO (recog_data.operand[j]) == (unsigned) i)
2209           {
2210             regstack->reg[++regstack->top] = i;
2211             SET_HARD_REG_BIT (regstack->reg_set, i);
2212             break;
2213           }
2214     }
2215
2216   /* Now emit a pop insn for any REG_UNUSED output, or any REG_DEAD
2217      input that the asm didn't implicitly pop.  If the asm didn't
2218      implicitly pop an input reg, that reg will still be live.
2219
2220      Note that we can't use find_regno_note here: the register numbers
2221      in the death notes have already been substituted.  */
2222
2223   for (i = 0; i < n_outputs; i++)
2224     if (STACK_REG_P (recog_data.operand[i]))
2225       {
2226         int j;
2227
2228         for (j = 0; j < n_notes; j++)
2229           if (REGNO (recog_data.operand[i]) == REGNO (note_reg[j])
2230               && note_kind[j] == REG_UNUSED)
2231             {
2232               insn = emit_pop_insn (insn, regstack, recog_data.operand[i],
2233                                     EMIT_AFTER);
2234               break;
2235             }
2236       }
2237
2238   for (i = n_outputs; i < n_outputs + n_inputs; i++)
2239     if (STACK_REG_P (recog_data.operand[i]))
2240       {
2241         int j;
2242
2243         for (j = 0; j < n_notes; j++)
2244           if (REGNO (recog_data.operand[i]) == REGNO (note_reg[j])
2245               && note_kind[j] == REG_DEAD
2246               && TEST_HARD_REG_BIT (regstack->reg_set,
2247                                     REGNO (recog_data.operand[i])))
2248             {
2249               insn = emit_pop_insn (insn, regstack, recog_data.operand[i],
2250                                     EMIT_AFTER);
2251               break;
2252             }
2253       }
2254 }
2255 \f
2256 /* Substitute stack hard reg numbers for stack virtual registers in
2257    INSN.  Non-stack register numbers are not changed.  REGSTACK is the
2258    current stack content.  Insns may be emitted as needed to arrange the
2259    stack for the 387 based on the contents of the insn.  Return whether
2260    a control flow insn was deleted in the process.  */
2261
2262 static bool
2263 subst_stack_regs (rtx insn, stack regstack)
2264 {
2265   rtx *note_link, note;
2266   bool control_flow_insn_deleted = false;
2267   int i;
2268
2269   if (CALL_P (insn))
2270     {
2271       int top = regstack->top;
2272
2273       /* If there are any floating point parameters to be passed in
2274          registers for this call, make sure they are in the right
2275          order.  */
2276
2277       if (top >= 0)
2278         {
2279           straighten_stack (insn, regstack);
2280
2281           /* Now mark the arguments as dead after the call.  */
2282
2283           while (regstack->top >= 0)
2284             {
2285               CLEAR_HARD_REG_BIT (regstack->reg_set, FIRST_STACK_REG + regstack->top);
2286               regstack->top--;
2287             }
2288         }
2289     }
2290
2291   /* Do the actual substitution if any stack regs are mentioned.
2292      Since we only record whether entire insn mentions stack regs, and
2293      subst_stack_regs_pat only works for patterns that contain stack regs,
2294      we must check each pattern in a parallel here.  A call_value_pop could
2295      fail otherwise.  */
2296
2297   if (stack_regs_mentioned (insn))
2298     {
2299       int n_operands = asm_noperands (PATTERN (insn));
2300       if (n_operands >= 0)
2301         {
2302           /* This insn is an `asm' with operands.  Decode the operands,
2303              decide how many are inputs, and do register substitution.
2304              Any REG_UNUSED notes will be handled by subst_asm_stack_regs.  */
2305
2306           subst_asm_stack_regs (insn, regstack);
2307           return control_flow_insn_deleted;
2308         }
2309
2310       if (GET_CODE (PATTERN (insn)) == PARALLEL)
2311         for (i = 0; i < XVECLEN (PATTERN (insn), 0); i++)
2312           {
2313             if (stack_regs_mentioned_p (XVECEXP (PATTERN (insn), 0, i)))
2314               {
2315                 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == CLOBBER)
2316                    XVECEXP (PATTERN (insn), 0, i)
2317                      = shallow_copy_rtx (XVECEXP (PATTERN (insn), 0, i));
2318                 control_flow_insn_deleted
2319                   |= subst_stack_regs_pat (insn, regstack,
2320                                            XVECEXP (PATTERN (insn), 0, i));
2321               }
2322           }
2323       else
2324         control_flow_insn_deleted
2325           |= subst_stack_regs_pat (insn, regstack, PATTERN (insn));
2326     }
2327
2328   /* subst_stack_regs_pat may have deleted a no-op insn.  If so, any
2329      REG_UNUSED will already have been dealt with, so just return.  */
2330
2331   if (NOTE_P (insn) || INSN_DELETED_P (insn))
2332     return control_flow_insn_deleted;
2333
2334   /* If this a noreturn call, we can't insert pop insns after it.
2335      Instead, reset the stack state to empty.  */
2336   if (CALL_P (insn)
2337       && find_reg_note (insn, REG_NORETURN, NULL))
2338     {
2339       regstack->top = -1;
2340       CLEAR_HARD_REG_SET (regstack->reg_set);
2341       return control_flow_insn_deleted;
2342     }
2343
2344   /* If there is a REG_UNUSED note on a stack register on this insn,
2345      the indicated reg must be popped.  The REG_UNUSED note is removed,
2346      since the form of the newly emitted pop insn references the reg,
2347      making it no longer `unset'.  */
2348
2349   note_link = &REG_NOTES (insn);
2350   for (note = *note_link; note; note = XEXP (note, 1))
2351     if (REG_NOTE_KIND (note) == REG_UNUSED && STACK_REG_P (XEXP (note, 0)))
2352       {
2353         *note_link = XEXP (note, 1);
2354         insn = emit_pop_insn (insn, regstack, XEXP (note, 0), EMIT_AFTER);
2355       }
2356     else
2357       note_link = &XEXP (note, 1);
2358
2359   return control_flow_insn_deleted;
2360 }
2361 \f
2362 /* Change the organization of the stack so that it fits a new basic
2363    block.  Some registers might have to be popped, but there can never be
2364    a register live in the new block that is not now live.
2365
2366    Insert any needed insns before or after INSN, as indicated by
2367    WHERE.  OLD is the original stack layout, and NEW is the desired
2368    form.  OLD is updated to reflect the code emitted, i.e., it will be
2369    the same as NEW upon return.
2370
2371    This function will not preserve block_end[].  But that information
2372    is no longer needed once this has executed.  */
2373
2374 static void
2375 change_stack (rtx insn, stack old, stack new_stack, enum emit_where where)
2376 {
2377   int reg;
2378   int update_end = 0;
2379   int i;
2380
2381   /* Stack adjustments for the first insn in a block update the
2382      current_block's stack_in instead of inserting insns directly.
2383      compensate_edges will add the necessary code later.  */
2384   if (current_block
2385       && starting_stack_p
2386       && where == EMIT_BEFORE)
2387     {
2388       BLOCK_INFO (current_block)->stack_in = *new_stack;
2389       starting_stack_p = false;
2390       *old = *new_stack;
2391       return;
2392     }
2393
2394   /* We will be inserting new insns "backwards".  If we are to insert
2395      after INSN, find the next insn, and insert before it.  */
2396
2397   if (where == EMIT_AFTER)
2398     {
2399       if (current_block && BB_END (current_block) == insn)
2400         update_end = 1;
2401       insn = NEXT_INSN (insn);
2402     }
2403
2404   /* Initialize partially dead variables.  */
2405   for (i = FIRST_STACK_REG; i < LAST_STACK_REG + 1; i++)
2406     if (TEST_HARD_REG_BIT (new_stack->reg_set, i)
2407         && !TEST_HARD_REG_BIT (old->reg_set, i))
2408       {
2409         old->reg[++old->top] = i;
2410         SET_HARD_REG_BIT (old->reg_set, i);
2411         emit_insn_before (gen_rtx_SET (VOIDmode,
2412                                        FP_MODE_REG (i, SFmode), not_a_num), insn);
2413       }
2414
2415   /* Pop any registers that are not needed in the new block.  */
2416
2417   /* If the destination block's stack already has a specified layout
2418      and contains two or more registers, use a more intelligent algorithm
2419      to pop registers that minimizes the number number of fxchs below.  */
2420   if (new_stack->top > 0)
2421     {
2422       bool slots[REG_STACK_SIZE];
2423       int pops[REG_STACK_SIZE];
2424       int next, dest, topsrc;
2425
2426       /* First pass to determine the free slots.  */
2427       for (reg = 0; reg <= new_stack->top; reg++)
2428         slots[reg] = TEST_HARD_REG_BIT (new_stack->reg_set, old->reg[reg]);
2429
2430       /* Second pass to allocate preferred slots.  */
2431       topsrc = -1;
2432       for (reg = old->top; reg > new_stack->top; reg--)
2433         if (TEST_HARD_REG_BIT (new_stack->reg_set, old->reg[reg]))
2434           {
2435             dest = -1;
2436             for (next = 0; next <= new_stack->top; next++)
2437               if (!slots[next] && new_stack->reg[next] == old->reg[reg])
2438                 {
2439                   /* If this is a preference for the new top of stack, record
2440                      the fact by remembering it's old->reg in topsrc.  */
2441                   if (next == new_stack->top)
2442                     topsrc = reg;
2443                   slots[next] = true;
2444                   dest = next;
2445                   break;
2446                 }
2447             pops[reg] = dest;
2448           }
2449         else
2450           pops[reg] = reg;
2451
2452       /* Intentionally, avoid placing the top of stack in it's correct
2453          location, if we still need to permute the stack below and we
2454          can usefully place it somewhere else.  This is the case if any
2455          slot is still unallocated, in which case we should place the
2456          top of stack there.  */
2457       if (topsrc != -1)
2458         for (reg = 0; reg < new_stack->top; reg++)
2459           if (!slots[reg])
2460             {
2461               pops[topsrc] = reg;
2462               slots[new_stack->top] = false;
2463               slots[reg] = true;
2464               break;
2465             }
2466
2467       /* Third pass allocates remaining slots and emits pop insns.  */
2468       next = new_stack->top;
2469       for (reg = old->top; reg > new_stack->top; reg--)
2470         {
2471           dest = pops[reg];
2472           if (dest == -1)
2473             {
2474               /* Find next free slot.  */
2475               while (slots[next])
2476                 next--;
2477               dest = next--;
2478             }
2479           emit_pop_insn (insn, old, FP_MODE_REG (old->reg[dest], DFmode),
2480                          EMIT_BEFORE);
2481         }
2482     }
2483   else
2484     {
2485       /* The following loop attempts to maximize the number of times we
2486          pop the top of the stack, as this permits the use of the faster
2487          ffreep instruction on platforms that support it.  */
2488       int live, next;
2489
2490       live = 0;
2491       for (reg = 0; reg <= old->top; reg++)
2492         if (TEST_HARD_REG_BIT (new_stack->reg_set, old->reg[reg]))
2493           live++;
2494
2495       next = live;
2496       while (old->top >= live)
2497         if (TEST_HARD_REG_BIT (new_stack->reg_set, old->reg[old->top]))
2498           {
2499             while (TEST_HARD_REG_BIT (new_stack->reg_set, old->reg[next]))
2500               next--;
2501             emit_pop_insn (insn, old, FP_MODE_REG (old->reg[next], DFmode),
2502                            EMIT_BEFORE);
2503           }
2504         else
2505           emit_pop_insn (insn, old, FP_MODE_REG (old->reg[old->top], DFmode),
2506                          EMIT_BEFORE);
2507     }
2508
2509   if (new_stack->top == -2)
2510     {
2511       /* If the new block has never been processed, then it can inherit
2512          the old stack order.  */
2513
2514       new_stack->top = old->top;
2515       memcpy (new_stack->reg, old->reg, sizeof (new_stack->reg));
2516     }
2517   else
2518     {
2519       /* This block has been entered before, and we must match the
2520          previously selected stack order.  */
2521
2522       /* By now, the only difference should be the order of the stack,
2523          not their depth or liveliness.  */
2524
2525       gcc_assert (hard_reg_set_equal_p (old->reg_set, new_stack->reg_set));
2526       gcc_assert (old->top == new_stack->top);
2527
2528       /* If the stack is not empty (new_stack->top != -1), loop here emitting
2529          swaps until the stack is correct.
2530
2531          The worst case number of swaps emitted is N + 2, where N is the
2532          depth of the stack.  In some cases, the reg at the top of
2533          stack may be correct, but swapped anyway in order to fix
2534          other regs.  But since we never swap any other reg away from
2535          its correct slot, this algorithm will converge.  */
2536
2537       if (new_stack->top != -1)
2538         do
2539           {
2540             /* Swap the reg at top of stack into the position it is
2541                supposed to be in, until the correct top of stack appears.  */
2542
2543             while (old->reg[old->top] != new_stack->reg[new_stack->top])
2544               {
2545                 for (reg = new_stack->top; reg >= 0; reg--)
2546                   if (new_stack->reg[reg] == old->reg[old->top])
2547                     break;
2548
2549                 gcc_assert (reg != -1);
2550
2551                 emit_swap_insn (insn, old,
2552                                 FP_MODE_REG (old->reg[reg], DFmode));
2553               }
2554
2555             /* See if any regs remain incorrect.  If so, bring an
2556              incorrect reg to the top of stack, and let the while loop
2557              above fix it.  */
2558
2559             for (reg = new_stack->top; reg >= 0; reg--)
2560               if (new_stack->reg[reg] != old->reg[reg])
2561                 {
2562                   emit_swap_insn (insn, old,
2563                                   FP_MODE_REG (old->reg[reg], DFmode));
2564                   break;
2565                 }
2566           } while (reg >= 0);
2567
2568       /* At this point there must be no differences.  */
2569
2570       for (reg = old->top; reg >= 0; reg--)
2571         gcc_assert (old->reg[reg] == new_stack->reg[reg]);
2572     }
2573
2574   if (update_end)
2575     BB_END (current_block) = PREV_INSN (insn);
2576 }
2577 \f
2578 /* Print stack configuration.  */
2579
2580 static void
2581 print_stack (FILE *file, stack s)
2582 {
2583   if (! file)
2584     return;
2585
2586   if (s->top == -2)
2587     fprintf (file, "uninitialized\n");
2588   else if (s->top == -1)
2589     fprintf (file, "empty\n");
2590   else
2591     {
2592       int i;
2593       fputs ("[ ", file);
2594       for (i = 0; i <= s->top; ++i)
2595         fprintf (file, "%d ", s->reg[i]);
2596       fputs ("]\n", file);
2597     }
2598 }
2599 \f
2600 /* This function was doing life analysis.  We now let the regular live
2601    code do it's job, so we only need to check some extra invariants
2602    that reg-stack expects.  Primary among these being that all registers
2603    are initialized before use.
2604
2605    The function returns true when code was emitted to CFG edges and
2606    commit_edge_insertions needs to be called.  */
2607
2608 static int
2609 convert_regs_entry (void)
2610 {
2611   int inserted = 0;
2612   edge e;
2613   edge_iterator ei;
2614
2615   /* Load something into each stack register live at function entry.
2616      Such live registers can be caused by uninitialized variables or
2617      functions not returning values on all paths.  In order to keep
2618      the push/pop code happy, and to not scrog the register stack, we
2619      must put something in these registers.  Use a QNaN.
2620
2621      Note that we are inserting converted code here.  This code is
2622      never seen by the convert_regs pass.  */
2623
2624   FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
2625     {
2626       basic_block block = e->dest;
2627       block_info bi = BLOCK_INFO (block);
2628       int reg, top = -1;
2629
2630       for (reg = LAST_STACK_REG; reg >= FIRST_STACK_REG; --reg)
2631         if (TEST_HARD_REG_BIT (bi->stack_in.reg_set, reg))
2632           {
2633             rtx init;
2634
2635             bi->stack_in.reg[++top] = reg;
2636
2637             init = gen_rtx_SET (VOIDmode,
2638                                 FP_MODE_REG (FIRST_STACK_REG, SFmode),
2639                                 not_a_num);
2640             insert_insn_on_edge (init, e);
2641             inserted = 1;
2642           }
2643
2644       bi->stack_in.top = top;
2645     }
2646
2647   return inserted;
2648 }
2649
2650 /* Construct the desired stack for function exit.  This will either
2651    be `empty', or the function return value at top-of-stack.  */
2652
2653 static void
2654 convert_regs_exit (void)
2655 {
2656   int value_reg_low, value_reg_high;
2657   stack output_stack;
2658   rtx retvalue;
2659
2660   retvalue = stack_result (current_function_decl);
2661   value_reg_low = value_reg_high = -1;
2662   if (retvalue)
2663     {
2664       value_reg_low = REGNO (retvalue);
2665       value_reg_high = END_HARD_REGNO (retvalue) - 1;
2666     }
2667
2668   output_stack = &BLOCK_INFO (EXIT_BLOCK_PTR)->stack_in;
2669   if (value_reg_low == -1)
2670     output_stack->top = -1;
2671   else
2672     {
2673       int reg;
2674
2675       output_stack->top = value_reg_high - value_reg_low;
2676       for (reg = value_reg_low; reg <= value_reg_high; ++reg)
2677         {
2678           output_stack->reg[value_reg_high - reg] = reg;
2679           SET_HARD_REG_BIT (output_stack->reg_set, reg);
2680         }
2681     }
2682 }
2683
2684 /* Copy the stack info from the end of edge E's source block to the
2685    start of E's destination block.  */
2686
2687 static void
2688 propagate_stack (edge e)
2689 {
2690   stack src_stack = &BLOCK_INFO (e->src)->stack_out;
2691   stack dest_stack = &BLOCK_INFO (e->dest)->stack_in;
2692   int reg;
2693
2694   /* Preserve the order of the original stack, but check whether
2695      any pops are needed.  */
2696   dest_stack->top = -1;
2697   for (reg = 0; reg <= src_stack->top; ++reg)
2698     if (TEST_HARD_REG_BIT (dest_stack->reg_set, src_stack->reg[reg]))
2699       dest_stack->reg[++dest_stack->top] = src_stack->reg[reg];
2700
2701   /* Push in any partially dead values.  */
2702   for (reg = FIRST_STACK_REG; reg < LAST_STACK_REG + 1; reg++)
2703     if (TEST_HARD_REG_BIT (dest_stack->reg_set, reg)
2704         && !TEST_HARD_REG_BIT (src_stack->reg_set, reg))
2705       dest_stack->reg[++dest_stack->top] = reg;
2706 }
2707
2708
2709 /* Adjust the stack of edge E's source block on exit to match the stack
2710    of it's target block upon input.  The stack layouts of both blocks
2711    should have been defined by now.  */
2712
2713 static bool
2714 compensate_edge (edge e)
2715 {
2716   basic_block source = e->src, target = e->dest;
2717   stack target_stack = &BLOCK_INFO (target)->stack_in;
2718   stack source_stack = &BLOCK_INFO (source)->stack_out;
2719   struct stack_def regstack;
2720   int reg;
2721
2722   if (dump_file)
2723     fprintf (dump_file, "Edge %d->%d: ", source->index, target->index);
2724
2725   gcc_assert (target_stack->top != -2);
2726
2727   /* Check whether stacks are identical.  */
2728   if (target_stack->top == source_stack->top)
2729     {
2730       for (reg = target_stack->top; reg >= 0; --reg)
2731         if (target_stack->reg[reg] != source_stack->reg[reg])
2732           break;
2733
2734       if (reg == -1)
2735         {
2736           if (dump_file)
2737             fprintf (dump_file, "no changes needed\n");
2738           return false;
2739         }
2740     }
2741
2742   if (dump_file)
2743     {
2744       fprintf (dump_file, "correcting stack to ");
2745       print_stack (dump_file, target_stack);
2746     }
2747
2748   /* Abnormal calls may appear to have values live in st(0), but the
2749      abnormal return path will not have actually loaded the values.  */
2750   if (e->flags & EDGE_ABNORMAL_CALL)
2751     {
2752       /* Assert that the lifetimes are as we expect -- one value
2753          live at st(0) on the end of the source block, and no
2754          values live at the beginning of the destination block.
2755          For complex return values, we may have st(1) live as well.  */
2756       gcc_assert (source_stack->top == 0 || source_stack->top == 1);
2757       gcc_assert (target_stack->top == -1);
2758       return false;
2759     }
2760
2761   /* Handle non-call EH edges specially.  The normal return path have
2762      values in registers.  These will be popped en masse by the unwind
2763      library.  */
2764   if (e->flags & EDGE_EH)
2765     {
2766       gcc_assert (target_stack->top == -1);
2767       return false;
2768     }
2769
2770   /* We don't support abnormal edges.  Global takes care to
2771      avoid any live register across them, so we should never
2772      have to insert instructions on such edges.  */
2773   gcc_assert (! (e->flags & EDGE_ABNORMAL));
2774
2775   /* Make a copy of source_stack as change_stack is destructive.  */
2776   regstack = *source_stack;
2777
2778   /* It is better to output directly to the end of the block
2779      instead of to the edge, because emit_swap can do minimal
2780      insn scheduling.  We can do this when there is only one
2781      edge out, and it is not abnormal.  */
2782   if (EDGE_COUNT (source->succs) == 1)
2783     {
2784       current_block = source;
2785       change_stack (BB_END (source), &regstack, target_stack,
2786                     (JUMP_P (BB_END (source)) ? EMIT_BEFORE : EMIT_AFTER));
2787     }
2788   else
2789     {
2790       rtx seq, after;
2791
2792       current_block = NULL;
2793       start_sequence ();
2794
2795       /* ??? change_stack needs some point to emit insns after.  */
2796       after = emit_note (NOTE_INSN_DELETED);
2797
2798       change_stack (after, &regstack, target_stack, EMIT_BEFORE);
2799
2800       seq = get_insns ();
2801       end_sequence ();
2802
2803       insert_insn_on_edge (seq, e);
2804       return true;
2805     }
2806   return false;
2807 }
2808
2809 /* Traverse all non-entry edges in the CFG, and emit the necessary
2810    edge compensation code to change the stack from stack_out of the
2811    source block to the stack_in of the destination block.  */
2812
2813 static bool
2814 compensate_edges (void)
2815 {
2816   bool inserted = false;
2817   basic_block bb;
2818
2819   starting_stack_p = false;
2820
2821   FOR_EACH_BB (bb)
2822     if (bb != ENTRY_BLOCK_PTR)
2823       {
2824         edge e;
2825         edge_iterator ei;
2826
2827         FOR_EACH_EDGE (e, ei, bb->succs)
2828           inserted |= compensate_edge (e);
2829       }
2830   return inserted;
2831 }
2832
2833 /* Select the better of two edges E1 and E2 to use to determine the
2834    stack layout for their shared destination basic block.  This is
2835    typically the more frequently executed.  The edge E1 may be NULL
2836    (in which case E2 is returned), but E2 is always non-NULL.  */
2837
2838 static edge
2839 better_edge (edge e1, edge e2)
2840 {
2841   if (!e1)
2842     return e2;
2843
2844   if (EDGE_FREQUENCY (e1) > EDGE_FREQUENCY (e2))
2845     return e1;
2846   if (EDGE_FREQUENCY (e1) < EDGE_FREQUENCY (e2))
2847     return e2;
2848
2849   if (e1->count > e2->count)
2850     return e1;
2851   if (e1->count < e2->count)
2852     return e2;
2853
2854   /* Prefer critical edges to minimize inserting compensation code on
2855      critical edges.  */
2856
2857   if (EDGE_CRITICAL_P (e1) != EDGE_CRITICAL_P (e2))
2858     return EDGE_CRITICAL_P (e1) ? e1 : e2;
2859
2860   /* Avoid non-deterministic behavior.  */
2861   return (e1->src->index < e2->src->index) ? e1 : e2;
2862 }
2863
2864 /* Convert stack register references in one block.  */
2865
2866 static void
2867 convert_regs_1 (basic_block block)
2868 {
2869   struct stack_def regstack;
2870   block_info bi = BLOCK_INFO (block);
2871   int reg;
2872   rtx insn, next;
2873   bool control_flow_insn_deleted = false;
2874
2875   any_malformed_asm = false;
2876
2877   /* Choose an initial stack layout, if one hasn't already been chosen.  */
2878   if (bi->stack_in.top == -2)
2879     {
2880       edge e, beste = NULL;
2881       edge_iterator ei;
2882
2883       /* Select the best incoming edge (typically the most frequent) to
2884          use as a template for this basic block.  */
2885       FOR_EACH_EDGE (e, ei, block->preds)
2886         if (BLOCK_INFO (e->src)->done)
2887           beste = better_edge (beste, e);
2888
2889       if (beste)
2890         propagate_stack (beste);
2891       else
2892         {
2893           /* No predecessors.  Create an arbitrary input stack.  */
2894           bi->stack_in.top = -1;
2895           for (reg = LAST_STACK_REG; reg >= FIRST_STACK_REG; --reg)
2896             if (TEST_HARD_REG_BIT (bi->stack_in.reg_set, reg))
2897               bi->stack_in.reg[++bi->stack_in.top] = reg;
2898         }
2899     }
2900
2901   if (dump_file)
2902     {
2903       fprintf (dump_file, "\nBasic block %d\nInput stack: ", block->index);
2904       print_stack (dump_file, &bi->stack_in);
2905     }
2906
2907   /* Process all insns in this block.  Keep track of NEXT so that we
2908      don't process insns emitted while substituting in INSN.  */
2909   current_block = block;
2910   next = BB_HEAD (block);
2911   regstack = bi->stack_in;
2912   starting_stack_p = true;
2913
2914   do
2915     {
2916       insn = next;
2917       next = NEXT_INSN (insn);
2918
2919       /* Ensure we have not missed a block boundary.  */
2920       gcc_assert (next);
2921       if (insn == BB_END (block))
2922         next = NULL;
2923
2924       /* Don't bother processing unless there is a stack reg
2925          mentioned or if it's a CALL_INSN.  */
2926       if (stack_regs_mentioned (insn)
2927           || CALL_P (insn))
2928         {
2929           if (dump_file)
2930             {
2931               fprintf (dump_file, "  insn %d input stack: ",
2932                        INSN_UID (insn));
2933               print_stack (dump_file, &regstack);
2934             }
2935           control_flow_insn_deleted |= subst_stack_regs (insn, &regstack);
2936           starting_stack_p = false;
2937         }
2938     }
2939   while (next);
2940
2941   if (dump_file)
2942     {
2943       fprintf (dump_file, "Expected live registers [");
2944       for (reg = FIRST_STACK_REG; reg <= LAST_STACK_REG; ++reg)
2945         if (TEST_HARD_REG_BIT (bi->out_reg_set, reg))
2946           fprintf (dump_file, " %d", reg);
2947       fprintf (dump_file, " ]\nOutput stack: ");
2948       print_stack (dump_file, &regstack);
2949     }
2950
2951   insn = BB_END (block);
2952   if (JUMP_P (insn))
2953     insn = PREV_INSN (insn);
2954
2955   /* If the function is declared to return a value, but it returns one
2956      in only some cases, some registers might come live here.  Emit
2957      necessary moves for them.  */
2958
2959   for (reg = FIRST_STACK_REG; reg <= LAST_STACK_REG; ++reg)
2960     {
2961       if (TEST_HARD_REG_BIT (bi->out_reg_set, reg)
2962           && ! TEST_HARD_REG_BIT (regstack.reg_set, reg))
2963         {
2964           rtx set;
2965
2966           if (dump_file)
2967             fprintf (dump_file, "Emitting insn initializing reg %d\n", reg);
2968
2969           set = gen_rtx_SET (VOIDmode, FP_MODE_REG (reg, SFmode), not_a_num);
2970           insn = emit_insn_after (set, insn);
2971           control_flow_insn_deleted |= subst_stack_regs (insn, &regstack);
2972         }
2973     }
2974
2975   /* Amongst the insns possibly deleted during the substitution process above,
2976      might have been the only trapping insn in the block.  We purge the now
2977      possibly dead EH edges here to avoid an ICE from fixup_abnormal_edges,
2978      called at the end of convert_regs.  The order in which we process the
2979      blocks ensures that we never delete an already processed edge.
2980
2981      Note that, at this point, the CFG may have been damaged by the emission
2982      of instructions after an abnormal call, which moves the basic block end
2983      (and is the reason why we call fixup_abnormal_edges later).  So we must
2984      be sure that the trapping insn has been deleted before trying to purge
2985      dead edges, otherwise we risk purging valid edges.
2986
2987      ??? We are normally supposed not to delete trapping insns, so we pretend
2988      that the insns deleted above don't actually trap.  It would have been
2989      better to detect this earlier and avoid creating the EH edge in the first
2990      place, still, but we don't have enough information at that time.  */
2991
2992   if (control_flow_insn_deleted)
2993     purge_dead_edges (block);
2994
2995   /* Something failed if the stack lives don't match.  If we had malformed
2996      asms, we zapped the instruction itself, but that didn't produce the
2997      same pattern of register kills as before.  */
2998
2999   gcc_assert (hard_reg_set_equal_p (regstack.reg_set, bi->out_reg_set)
3000               || any_malformed_asm);
3001   bi->stack_out = regstack;
3002   bi->done = true;
3003 }
3004
3005 /* Convert registers in all blocks reachable from BLOCK.  */
3006
3007 static void
3008 convert_regs_2 (basic_block block)
3009 {
3010   basic_block *stack, *sp;
3011
3012   /* We process the blocks in a top-down manner, in a way such that one block
3013      is only processed after all its predecessors.  The number of predecessors
3014      of every block has already been computed.  */
3015
3016   stack = XNEWVEC (basic_block, n_basic_blocks);
3017   sp = stack;
3018
3019   *sp++ = block;
3020
3021   do
3022     {
3023       edge e;
3024       edge_iterator ei;
3025
3026       block = *--sp;
3027
3028       /* Processing BLOCK is achieved by convert_regs_1, which may purge
3029          some dead EH outgoing edge after the deletion of the trapping
3030          insn inside the block.  Since the number of predecessors of
3031          BLOCK's successors was computed based on the initial edge set,
3032          we check the necessity to process some of these successors
3033          before such an edge deletion may happen.  However, there is
3034          a pitfall: if BLOCK is the only predecessor of a successor and
3035          the edge between them happens to be deleted, the successor
3036          becomes unreachable and should not be processed.  The problem
3037          is that there is no way to preventively detect this case so we
3038          stack the successor in all cases and hand over the task of
3039          fixing up the discrepancy to convert_regs_1.  */
3040
3041       FOR_EACH_EDGE (e, ei, block->succs)
3042         if (! (e->flags & EDGE_DFS_BACK))
3043           {
3044             BLOCK_INFO (e->dest)->predecessors--;
3045             if (!BLOCK_INFO (e->dest)->predecessors)
3046               *sp++ = e->dest;
3047           }
3048
3049       convert_regs_1 (block);
3050     }
3051   while (sp != stack);
3052
3053   free (stack);
3054 }
3055
3056 /* Traverse all basic blocks in a function, converting the register
3057    references in each insn from the "flat" register file that gcc uses,
3058    to the stack-like registers the 387 uses.  */
3059
3060 static void
3061 convert_regs (void)
3062 {
3063   int inserted;
3064   basic_block b;
3065   edge e;
3066   edge_iterator ei;
3067
3068   /* Initialize uninitialized registers on function entry.  */
3069   inserted = convert_regs_entry ();
3070
3071   /* Construct the desired stack for function exit.  */
3072   convert_regs_exit ();
3073   BLOCK_INFO (EXIT_BLOCK_PTR)->done = 1;
3074
3075   /* ??? Future: process inner loops first, and give them arbitrary
3076      initial stacks which emit_swap_insn can modify.  This ought to
3077      prevent double fxch that often appears at the head of a loop.  */
3078
3079   /* Process all blocks reachable from all entry points.  */
3080   FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
3081     convert_regs_2 (e->dest);
3082
3083   /* ??? Process all unreachable blocks.  Though there's no excuse
3084      for keeping these even when not optimizing.  */
3085   FOR_EACH_BB (b)
3086     {
3087       block_info bi = BLOCK_INFO (b);
3088
3089       if (! bi->done)
3090         convert_regs_2 (b);
3091     }
3092
3093   inserted |= compensate_edges ();
3094
3095   clear_aux_for_blocks ();
3096
3097   fixup_abnormal_edges ();
3098   if (inserted)
3099     commit_edge_insertions ();
3100
3101   if (dump_file)
3102     fputc ('\n', dump_file);
3103 }
3104 \f
3105 /* Convert register usage from "flat" register file usage to a "stack
3106    register file.  FILE is the dump file, if used.
3107
3108    Construct a CFG and run life analysis.  Then convert each insn one
3109    by one.  Run a last cleanup_cfg pass, if optimizing, to eliminate
3110    code duplication created when the converter inserts pop insns on
3111    the edges.  */
3112
3113 static bool
3114 reg_to_stack (void)
3115 {
3116   basic_block bb;
3117   int i;
3118   int max_uid;
3119
3120   /* Clean up previous run.  */
3121   if (stack_regs_mentioned_data != NULL)
3122     VEC_free (char, heap, stack_regs_mentioned_data);
3123
3124   /* See if there is something to do.  Flow analysis is quite
3125      expensive so we might save some compilation time.  */
3126   for (i = FIRST_STACK_REG; i <= LAST_STACK_REG; i++)
3127     if (df_regs_ever_live_p (i))
3128       break;
3129   if (i > LAST_STACK_REG)
3130     return false;
3131
3132   df_note_add_problem ();
3133   df_analyze ();
3134
3135   mark_dfs_back_edges ();
3136
3137   /* Set up block info for each basic block.  */
3138   alloc_aux_for_blocks (sizeof (struct block_info_def));
3139   FOR_EACH_BB (bb)
3140     {
3141       block_info bi = BLOCK_INFO (bb);
3142       edge_iterator ei;
3143       edge e;
3144       int reg;
3145
3146       FOR_EACH_EDGE (e, ei, bb->preds)
3147         if (!(e->flags & EDGE_DFS_BACK)
3148             && e->src != ENTRY_BLOCK_PTR)
3149           bi->predecessors++;
3150
3151       /* Set current register status at last instruction `uninitialized'.  */
3152       bi->stack_in.top = -2;
3153
3154       /* Copy live_at_end and live_at_start into temporaries.  */
3155       for (reg = FIRST_STACK_REG; reg <= LAST_STACK_REG; reg++)
3156         {
3157           if (REGNO_REG_SET_P (DF_LR_OUT (bb), reg))
3158             SET_HARD_REG_BIT (bi->out_reg_set, reg);
3159           if (REGNO_REG_SET_P (DF_LR_IN (bb), reg))
3160             SET_HARD_REG_BIT (bi->stack_in.reg_set, reg);
3161         }
3162     }
3163
3164   /* Create the replacement registers up front.  */
3165   for (i = FIRST_STACK_REG; i <= LAST_STACK_REG; i++)
3166     {
3167       enum machine_mode mode;
3168       for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
3169            mode != VOIDmode;
3170            mode = GET_MODE_WIDER_MODE (mode))
3171         FP_MODE_REG (i, mode) = gen_rtx_REG (mode, i);
3172       for (mode = GET_CLASS_NARROWEST_MODE (MODE_COMPLEX_FLOAT);
3173            mode != VOIDmode;
3174            mode = GET_MODE_WIDER_MODE (mode))
3175         FP_MODE_REG (i, mode) = gen_rtx_REG (mode, i);
3176     }
3177
3178   ix86_flags_rtx = gen_rtx_REG (CCmode, FLAGS_REG);
3179
3180   /* A QNaN for initializing uninitialized variables.
3181
3182      ??? We can't load from constant memory in PIC mode, because
3183      we're inserting these instructions before the prologue and
3184      the PIC register hasn't been set up.  In that case, fall back
3185      on zero, which we can get from `fldz'.  */
3186
3187   if ((flag_pic && !TARGET_64BIT)
3188       || ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC)
3189     not_a_num = CONST0_RTX (SFmode);
3190   else
3191     {
3192       REAL_VALUE_TYPE r;
3193
3194       real_nan (&r, "", 1, SFmode);
3195       not_a_num = CONST_DOUBLE_FROM_REAL_VALUE (r, SFmode);
3196       not_a_num = force_const_mem (SFmode, not_a_num);
3197     }
3198
3199   /* Allocate a cache for stack_regs_mentioned.  */
3200   max_uid = get_max_uid ();
3201   stack_regs_mentioned_data = VEC_alloc (char, heap, max_uid + 1);
3202   memset (VEC_address (char, stack_regs_mentioned_data),
3203           0, sizeof (char) * (max_uid + 1));
3204
3205   convert_regs ();
3206
3207   free_aux_for_blocks ();
3208   return true;
3209 }
3210 #endif /* STACK_REGS */
3211 \f
3212 static bool
3213 gate_handle_stack_regs (void)
3214 {
3215 #ifdef STACK_REGS
3216   return 1;
3217 #else
3218   return 0;
3219 #endif
3220 }
3221
3222 struct rtl_opt_pass pass_stack_regs =
3223 {
3224  {
3225   RTL_PASS,
3226   NULL,                                 /* name */
3227   gate_handle_stack_regs,               /* gate */
3228   NULL,                                 /* execute */
3229   NULL,                                 /* sub */
3230   NULL,                                 /* next */
3231   0,                                    /* static_pass_number */
3232   TV_REG_STACK,                         /* tv_id */
3233   0,                                    /* properties_required */
3234   0,                                    /* properties_provided */
3235   0,                                    /* properties_destroyed */
3236   0,                                    /* todo_flags_start */
3237   0                                     /* todo_flags_finish */
3238  }
3239 };
3240
3241 /* Convert register usage from flat register file usage to a stack
3242    register file.  */
3243 static unsigned int
3244 rest_of_handle_stack_regs (void)
3245 {
3246 #ifdef STACK_REGS
3247   reg_to_stack ();
3248   regstack_completed = 1;
3249 #endif
3250   return 0;
3251 }
3252
3253 struct rtl_opt_pass pass_stack_regs_run =
3254 {
3255  {
3256   RTL_PASS,
3257   "stack",                              /* name */
3258   NULL,                                 /* gate */
3259   rest_of_handle_stack_regs,            /* execute */
3260   NULL,                                 /* sub */
3261   NULL,                                 /* next */
3262   0,                                    /* static_pass_number */
3263   TV_REG_STACK,                         /* tv_id */
3264   0,                                    /* properties_required */
3265   0,                                    /* properties_provided */
3266   0,                                    /* properties_destroyed */
3267   0,                                    /* todo_flags_start */
3268   TODO_df_finish | TODO_verify_rtl_sharing |
3269   TODO_dump_func |
3270   TODO_ggc_collect                      /* todo_flags_finish */
3271  }
3272 };