contrib/gcc/reg-stack.c

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,
58    will replace the existing stack top, not push a new value.
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
94       If any non-popped input is closer to the top of the reg-stack than
99 	All implicitly popped input regs must be closer to the top of
132       It makes no sense to push anywhere but the top of the reg-stack.
134 	Output operands must start at the top of the reg-stack: output
194    that REG[TOP] is the top of stack.  If TOP is -1 the stack is empty.
197    consists of placing each live reg in array `reg' and setting `top'
204   int top;			/* index to top stack element */
372   int top;
378   if (regstack->top <= 0)
383   for (top = temp_stack.top = regstack->top; top >= 0; top--)
384     temp_stack.reg[top] = FIRST_STACK_REG + temp_stack.top - top;
394   int top = regstack->top;
397   regstack->top--;
398   /* If regno was not at the top of stack then adjust stack.  */
399   if (regstack->reg [top] != regno)
402       for (i = regstack->top; i >= 0; i--)
406 	    for (j = i; j < top; j++)
460    follow.  Those rules are explained at the top of this file: the rule
532      Also enforce rule #5: Output operands must start at the top of
574       error_for_asm (insn, "output regs must be grouped at top of stack");
579      to the top of the reg-stack than any input that is not implicitly
611 		     "implicitly popped regs must be grouped at top of stack");
739    The hard register number is relative to the top of the stack.  -1 is
749   for (i = regstack->top; i >= 0; i--)
753   return i >= 0 ? (FIRST_STACK_REG + regstack->top - i) : -1;
761    and source is the top of stack.  A death note for the top of stack
802   regstack->reg[regstack->top - (hard_regno - FIRST_STACK_REG)]
803     = regstack->reg[regstack->top];
804   regstack->top -= 1;
812    the top of stack.  REGSTACK is the stack state before the swap, and
816    If REG is already at the top of the stack, no insn is emitted.  */
838       regstack->reg[++regstack->top] = REGNO (reg);
843   other_reg = regstack->top - (hard_regno - FIRST_STACK_REG);
846   regstack->reg[other_reg] = regstack->reg[regstack->top];
847   regstack->reg[regstack->top] = tmp;
918    the top of stack and virtual register SRC2 with second stack
934   /* Place operand 1 at the top of stack.  */
939       k = temp_stack.top - (regno - FIRST_STACK_REG);
940       j = temp_stack.top;
952       k = temp_stack.top - (regno - FIRST_STACK_REG);
953       j = temp_stack.top - 1;
992 	  for (i = regstack->top; i >= 0; i--)
1043       regstack->reg[++regstack->top] = REGNO (dest);
1050 	 only top of stack may be saved, emit an exchange first if
1059 	  regstack->top--;
1063 	       && regstack->top < REG_STACK_SIZE - 1)
1088 	 stack regs.  The actual target is always the top of the
1090 	 now at top of stack.  */
1095       gcc_assert (regstack->top < REG_STACK_SIZE);
1097       regstack->reg[++regstack->top] = REGNO (dest);
1258      registers that die in this insn - move those to stack top first.  */
1306 	 next to top of stack and the top of stack also dies.  Since
1307 	 we have already popped src1, "next to top of stack" is really
1308 	 at top (FIRST_STACK_REG) now.  */
1390 		/* A top-level clobber with no REG_DEAD, and no hard-regnum
1450 		  regstack->reg[++regstack->top] = REGNO (*dest) + count;
1468 	    /* These insns only operate on the top of the stack. DEST might
1486 		regstack->top--;
1500 	    /* These insns can accept the top of stack as a destination
1501 	       from a stack reg or mem, or can use the top of stack as a
1502 	       source and some other stack register (possibly top of stack)
1520 	       must be top of stack.  */
1527 		   at the top of stack, choose to make the one that is the dest
1528 		   the new top of stack.  */
1551 		/* If the register that dies is at the top of stack, then
1553 		   But if the reg that dies is not at top of stack, then
1554 		   move the top of stack to the dead reg, as though we had
1557 		if (REGNO (src1_reg) == regstack->reg[regstack->top])
1569 		    regstack->reg[regstack->top - (regno - FIRST_STACK_REG)]
1570 		      = regstack->reg[regstack->top];
1576 		regstack->top--;
1581 		if (REGNO (src2_reg) == regstack->reg[regstack->top])
1593 		    regstack->reg[regstack->top - (regno - FIRST_STACK_REG)]
1594 		      = regstack->reg[regstack->top];
1600 		regstack->top--;
1627 		/* These insns only operate on the top of the stack.  */
1640 		    regstack->top--;
1657 		/* These insns only operate on the top of the stack.  */
1677 		/* These insns operate on the top two stack slots.  */
1697 				    regstack->reg[regstack->top]);
1699 				    regstack->reg[regstack->top - 1]);
1700 		regstack->top -= 2;
1703 		regstack->reg[++regstack->top] = REGNO (*dest);
1711 		/* These insns operate on the top two stack slots.
1730 		  regstack->reg[regstack->top] = REGNO (*dest);
1742 		/* These insns operate on the top two stack slots./
1759 		   first part of insn and fix top of stack pointer.  */
1761 		  regstack->reg[regstack->top - 1] = REGNO (*dest);
1773 		/* These insns operate on the top two stack slots,
1788 		  regstack->reg[regstack->top + 1] = REGNO (*dest);
1799 		/* These insns operate on the top two stack slots,
1812 		   first part of insn and fix top of stack pointer.  */
1814 		  regstack->reg[regstack->top] = REGNO (*dest);
1818 		  regstack->top++;
1850 	    /* This insn requires the top of stack to be the destination.  */
1860 	       will move the destination to the top of stack. But if the
1864 		&& REGNO (*dest) != regstack->reg[regstack->top])
1866 		/* In case one of operands is the top of stack and the operands
1869 		if ((REGNO (*src1) == regstack->reg[regstack->top]
1871 		    || (REGNO (*src2) == regstack->reg[regstack->top]
1881 		    regstack->reg[regstack->top - idx1] = REGNO (*src2);
1882 		    regstack->reg[regstack->top - idx2] = REGNO (*src1);
1911 		    /* If the register that dies is not at the top of
1912 		       stack, then move the top of stack to the dead reg.
1915 		    gcc_assert (regno != regstack->reg[regstack->top]);
1922 	    /* Make dest the top of stack.  Add dest to regstack if
1925 	      regstack->reg[++regstack->top] = REGNO (*dest);
2092 	    k = temp_stack.top - (regno - FIRST_STACK_REG);
2093 	    j = (temp_stack.top
2161 	    /* recog_data.operand[i] might not be at the top of stack.
2163 	       right number of regs off of the top of the reg-stack.
2165 	       popped regs were grouped at the top of the reg-stack.  */
2168 				regstack->reg[regstack->top]);
2169 	    regstack->top--;
2186 	    regstack->reg[++regstack->top] = i;
2248       int top = regstack->top;
2254       if (top >= 0)
2260 	  while (regstack->top >= 0)
2262 	      CLEAR_HARD_REG_BIT (regstack->reg_set, FIRST_STACK_REG + regstack->top);
2263 	      regstack->top--;
2316       regstack->top = -1;
2386   if (new->top > 0)
2393       for (reg = 0; reg <= new->top; reg++)
2398       for (reg = old->top; reg > new->top; reg--)
2402 	    for (next = 0; next <= new->top; next++)
2405 		  /* If this is a preference for the new top of stack, record
2407                   if (next == new->top)
2418       /* Intentionally, avoid placing the top of stack in it's correct
2422 	 top of stack there.  */
2424 	for (reg = 0; reg < new->top; reg++)
2428 	      slots[new->top] = false;
2434       next = new->top;
2435       for (reg = old->top; reg > new->top; reg--)
2452 	 pop the top of the stack, as this permits the use of the faster
2457       for (reg = 0; reg <= old->top; reg++)
2462       while (old->top >= live)
2463         if (TEST_HARD_REG_BIT (new->reg_set, old->reg[old->top]))
2471 	  emit_pop_insn (insn, old, FP_MODE_REG (old->reg[old->top], DFmode),
2475   if (new->top == -2)
2480       new->top = old->top;
2494       gcc_assert (old->top == new->top);
2496       /* If the stack is not empty (new->top != -1), loop here emitting
2500 	 depth of the stack.  In some cases, the reg at the top of
2505       if (new->top != -1)
2508 	    /* Swap the reg at top of stack into the position it is
2509 	       supposed to be in, until the correct top of stack appears.  */
2511 	    while (old->reg[old->top] != new->reg[new->top])
2513 		for (reg = new->top; reg >= 0; reg--)
2514 		  if (new->reg[reg] == old->reg[old->top])
2524 	     incorrect reg to the top of stack, and let the while loop
2527 	    for (reg = new->top; reg >= 0; reg--)
2538       for (reg = old->top; reg >= 0; reg--)
2555   if (s->top == -2)
2557   else if (s->top == -1)
2563       for (i = 0; i <= s->top; ++i)
2598       int reg, top = -1;
2605 	    bi->stack_in.reg[++top] = reg;
2614       bi->stack_in.top = top;
2621    be `empty', or the function return value at top-of-stack.  */
2641     output_stack->top = -1;
2646       output_stack->top = value_reg_high - value_reg_low;
2667   dest_stack->top = -1;
2668   for (reg = 0; reg <= src_stack->top; ++reg)
2670       dest_stack->reg[++dest_stack->top] = src_stack->reg[reg];
2690   gcc_assert (target_stack->top != -2);
2693   if (target_stack->top == source_stack->top)
2695       for (reg = target_stack->top; reg >= 0; --reg)
2721       gcc_assert (source_stack->top == 0 || source_stack->top == 1);
2722       gcc_assert (target_stack->top == -1);
2731       gcc_assert (target_stack->top == -1);
2843   if (bi->stack_in.top == -2)
2859 	  bi->stack_in.top = -1;
2862 	      bi->stack_in.reg[++bi->stack_in.top] = reg;
2977   /* We process the blocks in a top-down manner, in a way such that one block
3126       bi->stack_in.top = -2;