@@ -1072,11 +1072,11 @@ static InstructionsState getSameOpcode(ArrayRef<Value *> VL,
10721072 if (!isTriviallyVectorizable(BaseID) && BaseMappings.empty())
10731073 return InstructionsState::invalid();
10741074 }
1075- <<<<<<< HEAD
1075+ bool AnyPoison = InstCnt != VL.size();
10761076 // Currently, this is only used for binary ops.
10771077 // TODO: support all instructions
10781078 SmallVector<InterchangeableInstruction> InterchangeableOpcode =
1079- getInterchangeableInstruction(cast<Instruction>(VL[BaseIndex] ));
1079+ getInterchangeableInstruction(cast<Instruction>(V ));
10801080 SmallVector<InterchangeableInstruction> AlternateInterchangeableOpcode;
10811081 auto UpdateInterchangeableOpcode =
10821082 [](SmallVector<InterchangeableInstruction> &LHS,
@@ -1089,9 +1089,6 @@ static InstructionsState getSameOpcode(ArrayRef<Value *> VL,
10891089 LHS.swap(NewInterchangeableOpcode);
10901090 return true;
10911091 };
1092- =======
1093- bool AnyPoison = InstCnt != VL.size();
1094- >>>>>>> upstream/main
10951092 for (int Cnt = 0, E = VL.size(); Cnt < E; Cnt++) {
10961093 auto *I = dyn_cast<Instruction>(VL[Cnt]);
10971094 if (!I)
@@ -1123,7 +1120,7 @@ static InstructionsState getSameOpcode(ArrayRef<Value *> VL,
11231120 }),
11241121 ThisInterchangeableOpcode.end());
11251122 if (InterchangeableOpcode.empty() || ThisInterchangeableOpcode.empty())
1126- return InstructionsState(VL[BaseIndex], nullptr, nullptr );
1123+ return InstructionsState::invalid( );
11271124 AlternateInterchangeableOpcode.swap(ThisInterchangeableOpcode);
11281125 continue;
11291126 }
@@ -1230,7 +1227,6 @@ static InstructionsState getSameOpcode(ArrayRef<Value *> VL,
12301227 return InstructionsState::invalid();
12311228 }
12321229
1233- <<<<<<< HEAD
12341230 if (IsBinOp) {
12351231 auto FindOp = [&](ArrayRef<InterchangeableInstruction> CandidateOp) {
12361232 for (Value *V : VL)
@@ -1244,12 +1240,9 @@ static InstructionsState getSameOpcode(ArrayRef<Value *> VL,
12441240 Instruction *AltOp = AlternateInterchangeableOpcode.empty()
12451241 ? MainOp
12461242 : FindOp(AlternateInterchangeableOpcode);
1247- return InstructionsState(VL[BaseIndex], MainOp, AltOp);
1243+ return InstructionsState(MainOp, AltOp);
12481244 }
1249- return InstructionsState(VL[BaseIndex], cast<Instruction>(VL[BaseIndex]),
1250- =======
12511245 return InstructionsState(cast<Instruction>(V),
1252- >>>>>>> upstream/main
12531246 cast<Instruction>(VL[AltIndex]));
12541247}
12551248
@@ -2593,11 +2586,18 @@ class BoUpSLP {
25932586 InstructionsState S = getSameOpcode(VL, TLI);
25942587 for (unsigned OpIdx : seq<unsigned>(NumOperands))
25952588 OpsVec[OpIdx].resize(NumLanes);
2596- <<<<<<< HEAD
2597- for (auto [I, V] : enumerate(VL)) {
2598- assert(isa<Instruction>(V) && "Expected instruction");
2589+ for (auto [Lane, V] : enumerate(VL)) {
2590+ assert((isa<Instruction>(V) || isa<PoisonValue>(V)) &&
2591+ "Expected instruction or poison value");
2592+ if (isa<PoisonValue>(V)) {
2593+ for (unsigned OpIdx : seq<unsigned>(NumOperands))
2594+ OpsVec[OpIdx][Lane] = {
2595+ PoisonValue::get(VL0->getOperand(OpIdx)->getType()), true,
2596+ false};
2597+ continue;
2598+ }
25992599 auto [SelectedOp, Ops] = getInterchangeableInstruction(
2600- cast<Instruction>(V), S.MainOp , S.AltOp );
2600+ cast<Instruction>(V), S.getMainOp() , S.getAltOp() );
26012601 // Our tree has just 3 nodes: the root and two operands.
26022602 // It is therefore trivial to get the APO. We only need to check the
26032603 // opcode of V and whether the operand at OpIdx is the LHS or RHS
@@ -2610,30 +2610,8 @@ class BoUpSLP {
26102610 // tell the inverse operations by checking commutativity.
26112611 bool IsInverseOperation = !isCommutative(cast<Instruction>(SelectedOp));
26122612 for (unsigned OpIdx : seq<unsigned>(NumOperands)) {
2613- =======
2614- for (unsigned Lane = 0; Lane != NumLanes; ++Lane) {
2615- assert((isa<Instruction>(VL[Lane]) || isa<PoisonValue>(VL[Lane])) &&
2616- "Expected instruction or poison value");
2617- // Our tree has just 3 nodes: the root and two operands.
2618- // It is therefore trivial to get the APO. We only need to check the
2619- // opcode of VL[Lane] and whether the operand at OpIdx is the LHS or
2620- // RHS operand. The LHS operand of both add and sub is never attached
2621- // to an inversese operation in the linearized form, therefore its APO
2622- // is false. The RHS is true only if VL[Lane] is an inverse operation.
2623-
2624- // Since operand reordering is performed on groups of commutative
2625- // operations or alternating sequences (e.g., +, -), we can safely
2626- // tell the inverse operations by checking commutativity.
2627- if (isa<PoisonValue>(VL[Lane])) {
2628- OpsVec[OpIdx][Lane] = {
2629- PoisonValue::get(VL0->getOperand(OpIdx)->getType()), true,
2630- false};
2631- continue;
2632- }
2633- bool IsInverseOperation = !isCommutative(cast<Instruction>(VL[Lane]));
2634- >>>>>>> upstream/main
26352613 bool APO = (OpIdx == 0) ? false : IsInverseOperation;
2636- OpsVec[OpIdx][I ] = {Ops[OpIdx], APO, false};
2614+ OpsVec[OpIdx][Lane ] = {Ops[OpIdx], APO, false};
26372615 }
26382616 }
26392617 }
@@ -3534,32 +3512,13 @@ class BoUpSLP {
35343512 copy(OpVL, Operands[OpIdx].begin());
35353513 }
35363514
3537- <<<<<<< HEAD
3538- /// Set the operands of this bundle in their original order.
3539- void setOperandsInOrder() {
3540- assert(Operands.empty() && "Already initialized?");
3541- auto *I0 = cast<Instruction>(Scalars[0]);
3542- Operands.resize(I0->getNumOperands());
3543- unsigned NumLanes = Scalars.size();
3544- unsigned NumOperands = I0->getNumOperands();
3545- for (unsigned OpIdx : seq<unsigned>(NumOperands))
3546- Operands[OpIdx].resize(NumLanes);
3547- for (auto [I, V] : enumerate(Scalars)) {
3548- auto [SelectedOp, Ops] =
3549- getInterchangeableInstruction(cast<Instruction>(V), MainOp, AltOp);
3550- assert(Ops.size() == NumOperands && "Expected same number of operands");
3551- for (auto [J, Op] : enumerate(Ops))
3552- Operands[J][I] = Op;
3553- }
3554- =======
35553515 /// Set this bundle's operand from Scalars.
35563516 void setOperand(const BoUpSLP &R, bool RequireReorder = false) {
35573517 VLOperands Ops(Scalars, MainOp, R);
35583518 if (RequireReorder)
35593519 Ops.reorder();
35603520 for (unsigned I : seq<unsigned>(MainOp->getNumOperands()))
35613521 setOperand(I, Ops.getVL(I));
3562- >>>>>>> upstream/main
35633522 }
35643523
35653524 /// Reorders operands of the node to the given mask \p Mask.
0 commit comments