Lines Matching refs:State
487 /// operations if \p BlockInMask is non-null. Use \p State to translate given
489 void vectorizeInterleaveGroup(Instruction *Instr, VPTransformState &State,
494 /// non-null. Use \p State to translate given VPValues to IR values in the
496 void vectorizeMemoryInstruction(Instruction *Instr, VPTransformState &State,
2170 VPTransformState &State,
2206 Value *AddrPart = State.get(Addr, {Part, 0});
2253 Value *BlockInMaskPart = State.get(BlockInMask, Part);
2338 Value *BlockInMaskPart = State.get(BlockInMask, Part);
2355 VPTransformState &State,
2369 return vectorizeInterleaveGroup(Instr, State, Addr, BlockInMask);
2397 BlockInMaskParts[Part] = State.get(BlockInMask, Part);
2437 Value *VectorGep = State.get(Addr, Part);
2448 auto *VecPtr = CreateVecPtr(Part, State.get(Addr, {0, 0}));
2468 Value *VectorGep = State.get(Addr, Part);
2473 auto *VecPtr = CreateVecPtr(Part, State.get(Addr, {0, 0}));
6561 VPTransformState State{BestVF, BestUF, LI,
6564 State.CFG.PrevBB = ILV.createVectorizedLoopSkeleton();
6565 State.TripCount = ILV.getOrCreateTripCount(nullptr);
6577 VPlans.front()->execute(&State);
7355 void VPWidenRecipe::execute(VPTransformState &State) {
7357 State.ILV->widenInstruction(Instr);
7360 void VPWidenGEPRecipe::execute(VPTransformState &State) {
7361 State.ILV->widenGEP(GEP, State.UF, State.VF, IsPtrLoopInvariant,
7365 void VPWidenIntOrFpInductionRecipe::execute(VPTransformState &State) {
7366 assert(!State.Instance && "Int or FP induction being replicated.");
7367 State.ILV->widenIntOrFpInduction(IV, Trunc);
7370 void VPWidenPHIRecipe::execute(VPTransformState &State) {
7371 State.ILV->widenPHIInstruction(Phi, State.UF, State.VF);
7374 void VPBlendRecipe::execute(VPTransformState &State) {
7375 State.ILV->setDebugLocFromInst(State.Builder, Phi);
7391 InnerLoopVectorizer::VectorParts Entry(State.UF);
7393 for (unsigned Part = 0; Part < State.UF; ++Part) {
7397 State.ILV->getOrCreateVectorValue(Phi->getIncomingValue(In), Part);
7403 Value *Cond = State.get(User->getOperand(In), Part);
7405 State.Builder.CreateSelect(Cond, In0, Entry[Part], "predphi");
7409 for (unsigned Part = 0; Part < State.UF; ++Part)
7410 State.ValueMap.setVectorValue(Phi, Part, Entry[Part]);
7413 void VPInterleaveRecipe::execute(VPTransformState &State) {
7414 assert(!State.Instance && "Interleave group being replicated.");
7415 State.ILV->vectorizeInterleaveGroup(IG->getInsertPos(), State, getAddr(),
7419 void VPReplicateRecipe::execute(VPTransformState &State) {
7420 if (State.Instance) { // Generate a single instance.
7421 State.ILV->scalarizeInstruction(Ingredient, *State.Instance, IsPredicated);
7423 if (AlsoPack && State.VF > 1) {
7425 if (State.Instance->Lane == 0) {
7427 UndefValue::get(VectorType::get(Ingredient->getType(), State.VF));
7428 State.ValueMap.setVectorValue(Ingredient, State.Instance->Part, Undef);
7430 State.ILV->packScalarIntoVectorValue(Ingredient, *State.Instance);
7438 unsigned EndLane = IsUniform ? 1 : State.VF;
7439 for (unsigned Part = 0; Part < State.UF; ++Part)
7441 State.ILV->scalarizeInstruction(Ingredient, {Part, Lane}, IsPredicated);
7444 void VPBranchOnMaskRecipe::execute(VPTransformState &State) {
7445 assert(State.Instance && "Branch on Mask works only on single instance.");
7447 unsigned Part = State.Instance->Part;
7448 unsigned Lane = State.Instance->Lane;
7452 ConditionBit = State.Builder.getTrue();
7455 ConditionBit = State.get(BlockInMask, Part);
7457 ConditionBit = State.Builder.CreateExtractElement(
7458 ConditionBit, State.Builder.getInt32(Lane));
7463 auto *CurrentTerminator = State.CFG.PrevBB->getTerminator();
7466 auto *CondBr = BranchInst::Create(State.CFG.PrevBB, nullptr, ConditionBit);
7471 void VPPredInstPHIRecipe::execute(VPTransformState &State) {
7472 assert(State.Instance && "Predicated instruction PHI works per instance.");
7474 State.ValueMap.getScalarValue(PredInst, *State.Instance));
7485 unsigned Part = State.Instance->Part;
7486 if (State.ValueMap.hasVectorValue(PredInst, Part)) {
7487 Value *VectorValue = State.ValueMap.getVectorValue(PredInst, Part);
7489 PHINode *VPhi = State.Builder.CreatePHI(IEI->getType(), 2);
7492 State.ValueMap.resetVectorValue(PredInst, Part, VPhi); // Update cache.
7495 PHINode *Phi = State.Builder.CreatePHI(PredInstType, 2);
7498 State.ValueMap.resetScalarValue(PredInst, *State.Instance, Phi);
7502 void VPWidenMemoryInstructionRecipe::execute(VPTransformState &State) {
7503 State.ILV->vectorizeMemoryInstruction(&Instr, State, getAddr(), getMask());