Lines Matching defs:phi

435     // Adjust the computations below when the phi and the loop definition
639       // requires a phi in the epilog for the last definition from either
796 ///   v1 = phi(a, v2)     v1 = phi(a, v2)
797 ///   v2 = phi(b, v3)     v2 = phi(b, v3)
1100       // The loop value is another phi, which has not been scheduled.
1103       // The loop value is another phi, which has been scheduled.
1273   // Map from <LoopReg, InitReg> to phi register for all created phis. Note that
1276   // Map from LoopReg to phi register where the InitReg is undef.
1282   // Insert a phi that carries LoopReg from the loop body and InitReg otherwise.
1284   // or will be chosen so as to share another phi.
1285   Register phi(Register LoopReg, std::optional<Register> InitReg = {},
1326   // and the end of the block. Kill from the first non-phi to FirstMI.
1346   // Ensure a phi exists for all instructions that are either referenced by
1347   // an illegal phi or by an instruction outside the loop. This allows us to
1353       phi(R);
1360           phi(Def.getReg());
1375     // Non-phi producers are simple to remap. Insert as many phis as the
1387       Reg = phi(Reg);
1391   // First, dive through the phi chain to find the defaults for the generated
1419     // Peel off the first phi from Defaults and insert a phi between producer
1420     // and consumer. This phi will not be at the front of the block so we
1442   // Now we know the number of stages to jump back, insert the phi chain.
1445     LoopReg = phi(LoopReg, *DefaultI++, MRI.getRegClass(Reg));
1451     // by embedding a phi in the middle of the block. We will fix this up
1461     // Illegal phi should belong to the producer stage so that it can be
1470 Register KernelRewriter::phi(Register LoopReg, std::optional<Register> InitReg,
1472   // If the init register is not undef, try and find an existing phi.
1484   // InitReg is either undef or no existing phi takes InitReg as input. Try and
1485   // find a phi that takes undef as input.
1490       // Found a phi taking undef as input, and this input is undef so return
1493     // Found a phi taking undef as input, so rewrite it to take InitReg.
1505   // Failed to find any existing phi to reuse, so create a new one.
1566       // If this is an illegal phi, don't count it in distance.
1653         // The legal Phi is not necessary if the illegal phi's stage
1679     // If the instruction referenced by the phi is moved inside the block
1680     // we don't need the phi anymore.
1716         // If we are using a phi from the source block we need to add a new phi
1789     // Keep track at which iteration each phi belongs to. We need it to know
1824           // If the use comes from a phi we need to skip as many phi as the
1825           // distance between the epilogue and the kernel. Trace through the phi
2362 /// Return a phi if Reg is referenced by the phi.
2363 /// canApply() guarantees that at most only one such phi exists.
2389   // Examples that show which stages are merged by phi.
2651         // canApply() guarantees that DefMI is not phi and is an instruction in
2715                            << "Can not apply MVE expander: A phi result is "
2716                               "referenced outside of the loop or by phi.\n";);
2721     // A register defined inside the loop must be referenced by only one phi at
2728           dbgs() << "Can not apply MVE expander: A phi source value coming "