VPTransformState &State);
/// Widen a single select instruction within the innermost loop.
- void widenSelectInstruction(SelectInst &I, VPUser &Operands,
+ void widenSelectInstruction(SelectInst &I, VPValue *VPDef, VPUser &Operands,
bool InvariantCond, VPTransformState &State);
/// Fix the vectorized code, taking care of header phi's, live-outs, and more.
}
}
-void InnerLoopVectorizer::widenSelectInstruction(SelectInst &I,
+void InnerLoopVectorizer::widenSelectInstruction(SelectInst &I, VPValue *VPDef,
VPUser &Operands,
bool InvariantCond,
VPTransformState &State) {
Value *Op0 = State.get(Operands.getOperand(1), Part);
Value *Op1 = State.get(Operands.getOperand(2), Part);
Value *Sel = Builder.CreateSelect(Cond, Op0, Op1);
- VectorLoopValueMap.setVectorValue(&I, Part, Sel);
+ State.set(VPDef, &I, Sel, Part);
addMetadata(Sel, &I);
}
}
NeedDef.insert(Legal->getPrimaryInduction());
for (auto &Reduction : Legal->getReductionVars()) {
NeedDef.insert(Reduction.first);
- NeedDef.insert(Reduction.second.getLoopExitInstr());
+ // VPWidenSelect is a VPValue already, there is no need to add a separate
+ // VPValue.
+ if (!isa<SelectInst>(Reduction.second.getLoopExitInstr()))
+ NeedDef.insert(Reduction.second.getLoopExitInstr());
}
}
}
void VPWidenSelectRecipe::execute(VPTransformState &State) {
- State.ILV->widenSelectInstruction(Ingredient, *this, InvariantCond, State);
+ State.ILV->widenSelectInstruction(*cast<SelectInst>(getUnderlyingInstr()),
+ this, *this, InvariantCond, State);
}
void VPWidenRecipe::execute(VPTransformState &State) {
return V;
if (auto *V = dyn_cast<VPWidenCallRecipe>(this))
return V;
+ if (auto *V = dyn_cast<VPWidenSelectRecipe>(this))
+ return V;
return nullptr;
}
return V;
if (auto *V = dyn_cast<VPWidenCallRecipe>(this))
return V;
+ if (auto *V = dyn_cast<VPWidenSelectRecipe>(this))
+ return V;
return nullptr;
}
void VPWidenSelectRecipe::print(raw_ostream &O, const Twine &Indent,
VPSlotTracker &SlotTracker) const {
- O << "\"WIDEN-SELECT" << VPlanIngredient(&Ingredient)
- << (InvariantCond ? " (condition is loop invariant)" : "");
+ O << "\"WIDEN-SELECT ";
+ printAsOperand(O, SlotTracker);
+ O << " = select ";
+ getOperand(0)->printAsOperand(O, SlotTracker);
+ O << ", ";
+ getOperand(1)->printAsOperand(O, SlotTracker);
+ O << ", ";
+ getOperand(2)->printAsOperand(O, SlotTracker);
+ O << (InvariantCond ? " (condition is loop invariant)" : "");
}
void VPWidenRecipe::print(raw_ostream &O, const Twine &Indent,
};
/// A recipe for widening select instructions.
-class VPWidenSelectRecipe : public VPRecipeBase, public VPUser {
-private:
- /// Hold the select to be widened.
- SelectInst &Ingredient;
+class VPWidenSelectRecipe : public VPRecipeBase, public VPValue, public VPUser {
/// Is the condition of the select loop invariant?
bool InvariantCond;
template <typename IterT>
VPWidenSelectRecipe(SelectInst &I, iterator_range<IterT> Operands,
bool InvariantCond)
- : VPRecipeBase(VPWidenSelectSC), VPUser(Operands), Ingredient(I),
+ : VPRecipeBase(VPRecipeBase::VPWidenSelectSC),
+ VPValue(VPValue::VPVWidenSelectSC, &I), VPUser(Operands),
InvariantCond(InvariantCond) {}
~VPWidenSelectRecipe() override = default;
/// are actually instantiated. Values of this enumeration are kept in the
/// SubclassID field of the VPValue objects. They are used for concrete
/// type identification.
- enum { VPValueSC, VPInstructionSC, VPMemoryInstructionSC, VPVWidenCallSC };
+ enum {
+ VPValueSC,
+ VPInstructionSC,
+ VPMemoryInstructionSC,
+ VPVWidenCallSC,
+ VPVWidenSelectSC
+ };
VPValue(Value *UV = nullptr) : VPValue(VPValueSC, UV) {}
VPValue(const VPValue &) = delete;
; CHECK-NEXT: "loop:\n" +
; CHECK-NEXT: "WIDEN-INDUCTION %iv = phi 0, %iv.next\l" +
; CHECK-NEXT: "WIDEN\l"" %cond0 = icmp %iv, 13\l" +
-; CHECK-NEXT: "WIDEN-SELECT%s = select %cond0, 10, 20\l"
+; CHECK-NEXT: "WIDEN-SELECT ir<%s> = select ir<%cond0>, ir<10>, ir<20>\l"
; CHECK-NEXT: ]
define void @test() {
entry: