RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-25 20:23:11 +01:00
Code Issues Projects Releases Wiki Activity

Revert "Generalize getInvertibleOperand recurrence handling slightly"

Browse Source 
This reverts commit 0c01b37eeb18a51a7e9c9153330d8009de0f600e while a problem reported is investigated.
This commit is contained in:
Philip Reames 2021-04-29 13:06:26 -07:00
parent f58bb8a128
commit a17954e6f1
2 changed files with 38 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
lib/Analysis/ValueTracking.cpp
View File

@ -2521,31 +2521,26 @@ bool isKnownNonZero(const Value* V, unsigned Depth, const Query& Q) {
return isKnownNonZero(V, DemandedElts, Depth, Q);
}
/// If the pair of operators are the same invertible function, return the
/// the operands of the function corresponding to each input. Otherwise,
/// return None. An invertible function is one that is 1-to-1 and maps
/// every input value to exactly one output value. This is equivalent to
/// saying that Op1 and Op2 are equal exactly when the specified pair of
/// operands are equal, (except that Op1 and Op2 may be poison more often.)
static Optional<std::pair<Value*, Value*>>
getInvertibleOperands(const Operator *Op1,
const Operator *Op2) {
/// If the pair of operators are the same invertible function of a single
/// operand return the index of that operand. Otherwise, return None. An
/// invertible function is one that is 1-to-1 and maps every input value
/// to exactly one output value. This is equivalent to saying that Op1
/// and Op2 are equal exactly when the specified pair of operands are equal,
/// (except that Op1 and Op2 may be poison more often.)
static Optional<unsigned> getInvertibleOperand(const Operator *Op1,
const Operator *Op2) {
if (Op1->getOpcode() != Op2->getOpcode())
return None;
auto getOperands = [&](unsigned OpNum) -> auto {
return std::make_pair(Op1->getOperand(OpNum), Op2->getOperand(OpNum));
};
switch (Op1->getOpcode()) {
default:
break;
case Instruction::Add:
case Instruction::Sub:
if (Op1->getOperand(0) == Op2->getOperand(0))
return getOperands(1);
return 1;
if (Op1->getOperand(1) == Op2->getOperand(1))
return getOperands(0);
return 0;
break;
case Instruction::Mul: {
// invertible if A * B == (A * B) mod 2^N where A, and B are integers
@ -2561,7 +2556,7 @@ getInvertibleOperands(const Operator *Op1,
if (Op1->getOperand(1) == Op2->getOperand(1) &&
isa<ConstantInt>(Op1->getOperand(1)) &&
!cast<ConstantInt>(Op1->getOperand(1))->isZero())
return getOperands(0);
return 0;
break;
}
case Instruction::Shl: {
@ -2574,7 +2569,7 @@ getInvertibleOperands(const Operator *Op1,
break;
if (Op1->getOperand(1) == Op2->getOperand(1))
return getOperands(0);
return 0;
break;
}
case Instruction::AShr:
@ -2585,13 +2580,13 @@ getInvertibleOperands(const Operator *Op1,
break;
if (Op1->getOperand(1) == Op2->getOperand(1))
return getOperands(0);
return 0;
break;
}
case Instruction::SExt:
case Instruction::ZExt:
if (Op1->getOperand(0)->getType() == Op2->getOperand(0)->getType())
return getOperands(0);
return 0;
break;
case Instruction::PHI: {
const PHINode *PN1 = cast<PHINode>(Op1);
@ -2609,12 +2604,18 @@ getInvertibleOperands(const Operator *Op1,
!matchSimpleRecurrence(PN2, BO2, Start2, Step2))
break;
auto Values = getInvertibleOperands(cast<Operator>(BO1),
cast<Operator>(BO2));
if (!Values)
Optional<unsigned> Idx = getInvertibleOperand(cast<Operator>(BO1),
cast<Operator>(BO2));
if (!Idx || *Idx != 0)
break;
assert(Values->first == PN1 && Values->second == PN2);
return std::make_pair(Start1, Start2);
assert(BO1->getOperand(*Idx) == PN1 && BO2->getOperand(*Idx) == PN2);
// Phi operands might not be in the same order. TODO: generalize
// interface to return pair of operands.
if (PN1->getOperand(0) == BO1 && PN2->getOperand(0) == BO2)
return 1;
if (PN1->getOperand(1) == BO1 && PN2->getOperand(1) == BO2)
return 0;
}
}
return None;
@ -2711,9 +2712,11 @@ static bool isKnownNonEqual(const Value *V1, const Value *V2, unsigned Depth,
auto *O1 = dyn_cast<Operator>(V1);
auto *O2 = dyn_cast<Operator>(V2);
if (O1 && O2 && O1->getOpcode() == O2->getOpcode()) {
if (auto Values = getInvertibleOperands(O1, O2))
return isKnownNonEqual(Values->first, Values->second, Depth + 1, Q);
if (Optional<unsigned> Opt = getInvertibleOperand(O1, O2)) {
unsigned Idx = *Opt;
return isKnownNonEqual(O1->getOperand(Idx), O2->getOperand(Idx),
Depth + 1, Q);
}
if (const PHINode *PN1 = dyn_cast<PHINode>(V1)) {
const PHINode *PN2 = cast<PHINode>(V2);
// FIXME: This is missing a generalization to handle the case where one is

12
test/Analysis/ValueTracking/known-non-equal.ll
View File

@ -736,7 +736,8 @@ define i1 @recurrence_add_op_order(i8 %A) {
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i64 [[IV_NEXT]], 10
; CHECK-NEXT: br i1 [[CMP]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: exit:
; CHECK-NEXT: ret i1 false
; CHECK-NEXT: [[RES:%.*]] = icmp eq i8 [[A_IV]], [[B_IV]]
; CHECK-NEXT: ret i1 [[RES]]
;
entry:
%B = add i8 %A, 1
@ -807,7 +808,8 @@ define i1 @recurrence_add_phi_different_order1(i8 %A) {
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i64 [[IV_NEXT]], 10
; CHECK-NEXT: br i1 [[CMP]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: exit:
; CHECK-NEXT: ret i1 false
; CHECK-NEXT: [[RES:%.*]] = icmp eq i8 [[A_IV]], [[B_IV]]
; CHECK-NEXT: ret i1 [[RES]]
;
entry:
%B = add i8 %A, 1
@ -841,7 +843,8 @@ define i1 @recurrence_add_phi_different_order2(i8 %A) {
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i64 [[IV_NEXT]], 10
; CHECK-NEXT: br i1 [[CMP]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: exit:
; CHECK-NEXT: ret i1 false
; CHECK-NEXT: [[RES:%.*]] = icmp eq i8 [[A_IV]], [[B_IV]]
; CHECK-NEXT: ret i1 [[RES]]
;
entry:
%B = add i8 %A, 1
@ -976,7 +979,8 @@ define i1 @recurrence_sub_op_order(i8 %A) {
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i64 [[IV_NEXT]], 10
; CHECK-NEXT: br i1 [[CMP]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: exit:
; CHECK-NEXT: ret i1 false
; CHECK-NEXT: [[RES:%.*]] = icmp eq i8 [[A_IV]], [[B_IV]]
; CHECK-NEXT: ret i1 [[RES]]
;
entry:
%B = add i8 %A, 1