Lines Matching full:live
11 // pseudo registers into register stack instructions. This pass uses live
17 // partitioned into bundles where the same FP registers must be live in
19 // block to rearrange the live registers to match the outgoing bundle.
22 // live register shuffling instructions when critical edges are present.
79 // LiveBundle. It represents a set of CFG edges where the live FP stack
86 // The set of live FP registers in a LiveBundle is calculated by bundleCFG,
89 // Bit mask of live FP registers. Bit 0 = FP0, bit 1 = FP1, &c.
92 // Number of pre-assigned live registers in FixStack. This is 0 when the
96 // Assigned stack order for live-in registers.
102 // Have the live registers been assigned a stack order yet?
107 // with no live FP registers.
113 // Return a bitmask of FP registers in block's live-in list.
130 // The hardware keeps track of how many FP registers are live, so we have
131 // to model that exactly. Usually, each live register corresponds to an
133 // assembly, it is sometimes neccesary to have live scratch registers.
141 // For each live FP<n> register, point to its Stack[] entry.
143 // used when we need slightly different live registers than what the
157 // It can happen that we need an ST register to be live when no FP register
163 // value. That means every register in PendingST must be live.
171 // Shuffle live registers to match the expectations of successor blocks.
192 /// isLive - Is RegNo currently live in the stack?
293 /// Adjust the live registers to be the set in Mask.
382 /// bundleCFG - Scan all the basic blocks to determine consistent live-in and
383 /// live-out sets for the FP registers. Consistent means that the set of
384 /// registers live-out from a block is identical to the live-in set of all
385 /// successors. This is not enforced by the normal live-in lists since
391 // Gather the actual live-in masks for all MBBs.
492 /// setupBlockStack - Use the live bundles to set up our model of the stack
493 /// to match predecessors' live out stack.
495 DEBUG(dbgs() << "\nSetting up live-ins for BB#" << MBB->getNumber()
498 // Get the live-in bundle for MBB.
503 DEBUG(dbgs() << "Block has no FP live-ins.\n");
510 // Push the fixed live-in registers.
513 DEBUG(dbgs() << "Live-in st(" << (i-1) << "): %FP"
518 // Kill off unwanted live-ins. This can happen with a critical edge.
519 // FIXME: We could keep these live registers around as zombies. They may need
525 /// finishBlockStack - Revive live-outs that are implicitly defined out of
526 /// MBB. Shuffle live registers to match the expected fixed stack of any
534 DEBUG(dbgs() << "Setting up live-outs for BB#" << MBB->getNumber()
537 // Get MBB's live-out bundle.
547 DEBUG(dbgs() << "No live-outs.\n");
877 /// registers with a bit in Mask are live.
884 // This register is live, but we don't want it.
887 // We don't need to imp-def this live register.
933 // Now we should have the correct registers live.
935 assert(StackTop == CountPopulation_32(Mask) && "Live count mismatch");
1184 // All of the operands are live after this instruction executes, so we
1335 // STi could still be live from a previous inline asm.
1360 assert(!isLive(DstFP) && "Cannot copy ST to live FP register");
1409 // to mean that there is one more live register on the stack than we
1548 // if the FP register needs to be live after the instruction, or if it is
1561 // Make sure we have a unique live register for every fixed use. Some of
1589 // Now we can rearrange the live registers to match what was requested.
1689 "Ret only defs operands, and values aren't live beyond it");
1704 // We may have been carrying spurious live-ins, so make sure only the returned
1705 // registers are left live.
1740 assert(StackTop == 2 && "Must have two values live!");
1745 assert(getStackEntry(1) == FirstFPRegOp && "Unknown regs live");
1751 assert(getStackEntry(0) == FirstFPRegOp && "Unknown regs live");
1752 assert(getStackEntry(1) == SecondFPRegOp && "Unknown regs live");
