gcc/reg-stack.c

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