VPTransformState &State);
/// Widen a single select instruction within the innermost loop.
- void widenSelectInstruction(SelectInst &I, VPValue *VPDef, VPUser &Operands,
+ void widenSelectInstruction(SelectInst &I, 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, VPValue *VPDef,
+void InnerLoopVectorizer::widenSelectInstruction(SelectInst &I,
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);
- State.set(VPDef, &I, Sel, Part);
+ VectorLoopValueMap.setVectorValue(&I, Part, Sel);
addMetadata(Sel, &I);
}
}
NeedDef.insert(Legal->getPrimaryInduction());
for (auto &Reduction : Legal->getReductionVars()) {
NeedDef.insert(Reduction.first);
- // 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());
+ NeedDef.insert(Reduction.second.getLoopExitInstr());
}
}
}
void VPWidenSelectRecipe::execute(VPTransformState &State) {
- State.ILV->widenSelectInstruction(*cast<SelectInst>(getUnderlyingInstr()),
- this, *this, InvariantCond, State);
+ State.ILV->widenSelectInstruction(Ingredient, *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 ";
- 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)" : "");
+ O << "\"WIDEN-SELECT" << VPlanIngredient(&Ingredient)
+ << (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 VPValue, public VPUser {
+class VPWidenSelectRecipe : public VPRecipeBase, public VPUser {
+private:
+ /// Hold the select to be widened.
+ SelectInst &Ingredient;
/// Is the condition of the select loop invariant?
bool InvariantCond;
template <typename IterT>
VPWidenSelectRecipe(SelectInst &I, iterator_range<IterT> Operands,
bool InvariantCond)
- : VPRecipeBase(VPRecipeBase::VPWidenSelectSC),
- VPValue(VPValue::VPVWidenSelectSC, &I), VPUser(Operands),
+ : VPRecipeBase(VPWidenSelectSC), VPUser(Operands), Ingredient(I),
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,
- VPVWidenSelectSC
- };
+ enum { VPValueSC, VPInstructionSC, VPMemoryInstructionSC, VPVWidenCallSC };
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 ir<%s> = select ir<%cond0>, ir<10>, ir<20>\l"
+; CHECK-NEXT: "WIDEN-SELECT%s = select %cond0, 10, 20\l"
; CHECK-NEXT: ]
define void @test() {
entry: