[ValueLattice] Remove unused DataLayout parameter of mergeIn

[fhahn]

Nice cleanup, thanks! LGTM.

llvm/include/llvm/Analysis/ValueLattice.h

bool markConstantRange(ConstantRange NewR, bool MayIncludeUndef = false) {
 
     Tag = NewTag;
     new (&Range) ConstantRange(std::move(NewR));
     return true;
   }
 
   /// Updates this object to approximate both this object and RHS. Returns
   /// true if this object has been changed.
-  bool mergeIn(const ValueLatticeElement &RHS, const DataLayout &DL) {
+  bool mergeIn(const ValueLatticeElement &RHS) {
     if (RHS.isUnknown() || isOverdefined())
       return false;
     if (RHS.isOverdefined()) {
       markOverdefined();
       return true;
     }
 
     if (isUndef()) {

llvm/lib/Analysis/LazyValueInfo.cpp

bool LazyValueInfoImpl::solveBlockValueNonLocal(ValueLatticeElement &BBLV,
   // canonicalizing to make this true rather than relying on this happy
   // accident.
   for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
     ValueLatticeElement EdgeResult;
     if (!getEdgeValue(Val, *PI, BB, EdgeResult))
       // Explore that input, then return here
       return false;
 
-    Result.mergeIn(EdgeResult, DL);
+    Result.mergeIn(EdgeResult);
 
     // If we hit overdefined, exit early.  The BlockVals entry is already set
     // to overdefined.
     if (Result.isOverdefined()) {
       LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()
                         << "' - overdefined because of pred (non local).\n");
       // Before giving up, see if we can prove the pointer non-null local to
       // this particular block.
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
     ValueLatticeElement EdgeResult;
     // Note that we can provide PN as the context value to getEdgeValue, even
     // though the results will be cached, because PN is the value being used as
     // the cache key in the caller.
     if (!getEdgeValue(PhiVal, PhiBB, BB, EdgeResult, PN))
       // Explore that input, then return here
       return false;
 
-    Result.mergeIn(EdgeResult, DL);
+    Result.mergeIn(EdgeResult);
 
     // If we hit overdefined, exit early.  The BlockVals entry is already set
     // to overdefined.
     if (Result.isOverdefined()) {
       LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()
                         << "' - overdefined because of pred (local).\n");
 
       BBLV = Result;
if (ConstantInt *CIBase = dyn_cast<ConstantInt>(ICI->getOperand(1))) {
                               ValueLatticeElement::getNot(ResNot));
         }
         break;
       };
     }
   }
 
   ValueLatticeElement Result;  // Start Undefined.
-  Result.mergeIn(TrueVal, DL);
-  Result.mergeIn(FalseVal, DL);
+  Result.mergeIn(TrueVal);
+  Result.mergeIn(FalseVal);
   BBLV = Result;
   return true;
 }
 
 Optional<ConstantRange> LazyValueInfoImpl::getRangeForOperand(unsigned Op,
                                                               Instruction *I,
                                                               BasicBlock *BB) {
   if (!hasBlockValue(I->getOperand(Op), BB))

llvm/lib/Transforms/Scalar/SCCP.cpp

bool mergeInValue(ValueLatticeElement &IV, Value *V,
     // Do a simple form of widening, to avoid extending a range repeatedly in a
     // loop. If IV is a constant range, it means we already set it once. If
     // MergeWithV would extend IV, mark V as overdefined.
     if (Widen && IV.isConstantRange() && MergeWithV.isConstantRange() &&
         !IV.getConstantRange().contains(MergeWithV.getConstantRange())) {
       markOverdefined(IV, V);
       return true;
     }
-    if (IV.mergeIn(MergeWithV, DL)) {
+    if (IV.mergeIn(MergeWithV)) {
       pushToWorkList(IV, V);
       LLVM_DEBUG(dbgs() << "Merged " << MergeWithV << " into " << *V << " : "
                         << IV << "\n");
       return true;
     }
     return false;
   }
 
void SCCPSolver::visitPHINode(PHINode &PN) {
   // If there are no executable operands, the PHI remains unknown.
   bool Changed = false;
   for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i) {
     ValueLatticeElement IV = getValueState(PN.getIncomingValue(i));
     if (!isEdgeFeasible(PN.getIncomingBlock(i), PN.getParent()))
       continue;
 
     ValueLatticeElement &Res = getValueState(&PN);
-    Changed |= Res.mergeIn(IV, DL);
+    Changed |= Res.mergeIn(IV);
     if (Res.isOverdefined())
       break;
   }
   if (Changed)
     pushToWorkListMsg(ValueState[&PN], &PN);
 }
 
 void SCCPSolver::visitReturnInst(ReturnInst &I) {
void SCCPSolver::visitSelectInst(SelectInst &I) {
   }
 
   // Otherwise, the condition is overdefined or a constant we can't evaluate.
   // See if we can produce something better than overdefined based on the T/F
   // value.
   ValueLatticeElement TVal = getValueState(I.getTrueValue());
   ValueLatticeElement FVal = getValueState(I.getFalseValue());
 
-  bool Changed = ValueState[&I].mergeIn(TVal, DL);
-  Changed |= ValueState[&I].mergeIn(FVal, DL);
+  bool Changed = ValueState[&I].mergeIn(TVal);
+  Changed |= ValueState[&I].mergeIn(FVal);
   if (Changed)
     pushToWorkListMsg(ValueState[&I], &I);
 }
 
 // Handle Unary Operators.
 void SCCPSolver::visitUnaryOperator(Instruction &I) {
   ValueLatticeElement V0State = getValueState(I.getOperand(0));
 

llvm/unittests/Analysis/ValueLatticeTest.cpp

 namespace llvm {
 namespace {
 
 // We use this fixture to ensure that we clean up ScalarEvolution before
 // deleting the PassManager.
 class ValueLatticeTest : public testing::Test {
 protected:
   LLVMContext Context;
-  Module M;
-
-  ValueLatticeTest() : M("", Context) {}
 };
 
 TEST_F(ValueLatticeTest, ValueLatticeGetters) {
   auto I32Ty = IntegerType::get(Context, 32);
   auto *C1 = ConstantInt::get(I32Ty, 1);
 
   EXPECT_TRUE(ValueLatticeElement::get(C1).isConstantRange());
   EXPECT_TRUE(

 }
 
 TEST_F(ValueLatticeTest, MergeIn) {
   auto I32Ty = IntegerType::get(Context, 32);
   auto *C1 = ConstantInt::get(I32Ty, 1);
 
   // Merge to lattice values with equal integer constant.
   auto LV1 = ValueLatticeElement::get(C1);
-  EXPECT_FALSE(LV1.mergeIn(ValueLatticeElement::get(C1), M.getDataLayout()));
+  EXPECT_FALSE(LV1.mergeIn(ValueLatticeElement::get(C1)));
   EXPECT_TRUE(LV1.isConstantRange());
   EXPECT_EQ(LV1.asConstantInteger().getValue().getLimitedValue(), 1U);
 
   // Merge LV1 with different integer constant.
-  EXPECT_TRUE(LV1.mergeIn(ValueLatticeElement::get(ConstantInt::get(I32Ty, 99)),
-                          M.getDataLayout()));
+  EXPECT_TRUE(
+      LV1.mergeIn(ValueLatticeElement::get(ConstantInt::get(I32Ty, 99))));
   EXPECT_TRUE(LV1.isConstantRange());
   EXPECT_EQ(LV1.getConstantRange().getLower().getLimitedValue(), 1U);
   EXPECT_EQ(LV1.getConstantRange().getUpper().getLimitedValue(), 100U);
 
   // Merge constant range with same constant range.
-  EXPECT_FALSE(LV1.mergeIn(LV1, M.getDataLayout()));
+  EXPECT_FALSE(LV1.mergeIn(LV1));
   EXPECT_TRUE(LV1.isConstantRange());
   EXPECT_EQ(LV1.getConstantRange().getLower().getLimitedValue(), 1U);
   EXPECT_EQ(LV1.getConstantRange().getUpper().getLimitedValue(), 100U);
 
   // Merge LV1 in undefined value.
   ValueLatticeElement LV2;
-  EXPECT_TRUE(LV2.mergeIn(LV1, M.getDataLayout()));
+  EXPECT_TRUE(LV2.mergeIn(LV1));
   EXPECT_TRUE(LV1.isConstantRange());
   EXPECT_EQ(LV1.getConstantRange().getLower().getLimitedValue(), 1U);
   EXPECT_EQ(LV1.getConstantRange().getUpper().getLimitedValue(), 100U);
   EXPECT_TRUE(LV2.isConstantRange());
   EXPECT_EQ(LV2.getConstantRange().getLower().getLimitedValue(), 1U);
   EXPECT_EQ(LV2.getConstantRange().getUpper().getLimitedValue(), 100U);
 
   // Merge LV1 with overdefined.
-  EXPECT_TRUE(
-      LV1.mergeIn(ValueLatticeElement::getOverdefined(), M.getDataLayout()));
+  EXPECT_TRUE(LV1.mergeIn(ValueLatticeElement::getOverdefined()));
   EXPECT_TRUE(LV1.isOverdefined());
 
   // Merge overdefined with overdefined.
-  EXPECT_FALSE(
-      LV1.mergeIn(ValueLatticeElement::getOverdefined(), M.getDataLayout()));
+  EXPECT_FALSE(LV1.mergeIn(ValueLatticeElement::getOverdefined()));
   EXPECT_TRUE(LV1.isOverdefined());
 }
 
 TEST_F(ValueLatticeTest, getCompareIntegers) {
   auto *I32Ty = IntegerType::get(Context, 32);
   auto *I1Ty = IntegerType::get(Context, 1);
   auto *C1 = ConstantInt::get(I32Ty, 1);
   auto LV1 = ValueLatticeElement::get(C1);
TEST_F(ValueLatticeTest, getCompareFloat) {
   EXPECT_TRUE(LV1.getCompare(CmpInst::FCMP_OEQ, I1Ty, LV2)->isOneValue());
   EXPECT_TRUE(LV1.getCompare(CmpInst::FCMP_OGE, I1Ty, LV2)->isOneValue());
   EXPECT_TRUE(LV1.getCompare(CmpInst::FCMP_OLE, I1Ty, LV2)->isOneValue());
   EXPECT_TRUE(LV1.getCompare(CmpInst::FCMP_ONE, I1Ty, LV2)->isZeroValue());
   EXPECT_TRUE(LV1.getCompare(CmpInst::FCMP_OLT, I1Ty, LV2)->isZeroValue());
   EXPECT_TRUE(LV1.getCompare(CmpInst::FCMP_OGT, I1Ty, LV2)->isZeroValue());
 
   EXPECT_TRUE(
-      LV1.mergeIn(ValueLatticeElement::get(ConstantFP::get(FloatTy, 2.2)),
-                  M.getDataLayout()));
+      LV1.mergeIn(ValueLatticeElement::get(ConstantFP::get(FloatTy, 2.2))));
   EXPECT_EQ(LV1.getCompare(CmpInst::FCMP_OEQ, I1Ty, LV2), nullptr);
   EXPECT_EQ(LV1.getCompare(CmpInst::FCMP_OGE, I1Ty, LV2), nullptr);
   EXPECT_EQ(LV1.getCompare(CmpInst::FCMP_OLE, I1Ty, LV2), nullptr);
   EXPECT_EQ(LV1.getCompare(CmpInst::FCMP_ONE, I1Ty, LV2), nullptr);
   EXPECT_EQ(LV1.getCompare(CmpInst::FCMP_OLT, I1Ty, LV2), nullptr);
   EXPECT_EQ(LV1.getCompare(CmpInst::FCMP_OGT, I1Ty, LV2), nullptr);
 }