[LVI] Fix LVI compile time regression around constantFoldUser()

[hjyamauchi]

Summary

Avoid checking each operand and calling getValueFromCondition() before calling
constantFoldUser() when the instruction type isn't supported by
constantFoldUser().

This fixes a large compile time regression in an internal build.

[hjyamauchi]

Cleaned up.

[sanjoy]

lib/Analysis/LazyValueInfo.cpp

1408

Please add an assert in constantFolderUser that this is true for its input. Also please s/Value *Val/User *U/

1494

Don't you need to guard this too?

[hjyamauchi]

Addressed comments.

[sanjoy]

lib/Analysis/LazyValueInfo.cpp

1496

Shouldn't this be canConstantFoldUser(Usr) && usesOperand(Usr, Condition)? Otherwise we're not really short-circuiting anything.

[hjyamauchi]

Addressed comment.

[sanjoy]

lgtm

lib/Analysis/LazyValueInfo.cpp

1377

I'd call this isOperationFoldable since we're not checking if Usr is foldable or not but only looking at its operation to see if it could possibly be constant folded.

1445–1447

s/checking the operands/linearly iterating over the operands unnecessarily/

s/large phi/instructions with many operands/ (I don't think "phi" is relevant here -- this could also have happened with a large call, invoke or GEP instruction).

1490

s/ValUsesConditionAndFoldable/ValUsesConditionAndMayBeFoldable/

[hjyamauchi]

Done.

lib/Analysis/LazyValueInfo.cpp

 static bool usesOperand(User *Usr, Value *Op) {
   return find(Usr->operands(), Op) != Usr->op_end();
 }
 
 // Check if Val can be simplified to an integer constant when the value of one
 // of its operands Op is an integer constant OpConstVal. If so, return it as an
 // lattice value range with a single element or otherwise return an overdefined
 // lattice value.
 static LVILatticeVal constantFoldUser(Value *Val, Value *Op,
                                       const APInt &OpConstVal,
                                       const DataLayout &DL) {
   Constant* OpConst = Constant::getIntegerValue(Op->getType(), OpConstVal);
   // Check if Val can be simplified to a constant.
   if (auto *CI = dyn_cast<CastInst>(Val)) {
     assert(CI->getOperand(0) == Op && "Operand 0 isn't Op");
     if (auto *C = dyn_cast_or_null<ConstantInt>(
             SimplifyCastInst(CI->getOpcode(), OpConst,
if (auto *CI = dyn_cast<CastInst>(Val)) {
     if (auto *C = dyn_cast_or_null<ConstantInt>(
             SimplifyBinOp(BO->getOpcode(), LHS, RHS, DL))) {
       return LVILatticeVal::getRange(ConstantRange(C->getValue()));
     }
   }
   return LVILatticeVal::getOverdefined();
 }
 
+// Return true if the instruction type of Val is supported by
+// constantFoldUser(). Currently CastInst and BinaryOperator only.  Call this
+// before calling constantFoldUser() to find out if it's even worth attempting
+// to call it.
+static bool canConstantFoldUser(Value *Val) {
+  return isa<CastInst>(Val) || isa<BinaryOperator>(Val);
+}
+
 /// \brief Compute the value of Val on the edge BBFrom -> BBTo. Returns false if
 /// Val is not constrained on the edge.  Result is unspecified if return value
 /// is false.
 static bool getEdgeValueLocal(Value *Val, BasicBlock *BBFrom,
                               BasicBlock *BBTo, LVILatticeVal &Result) {
   // TODO: Handle more complex conditionals. If (v == 0 || v2 < 1) is false, we
   // know that v != 0.
   if (BranchInst *BI = dyn_cast<BranchInst>(BBFrom->getTerminator())) {
if (BI->isConditional() &&
       // If the condition of the branch is an equality comparison, we may be
       // able to infer the value.
       Result = getValueFromCondition(Val, Condition, isTrueDest);
       if (!Result.isOverdefined())
         return true;
 
       if (User *Usr = dyn_cast<User>(Val)) {
         assert(Result.isOverdefined() && "Result isn't overdefined");
-        if (isa<IntegerType>(Val->getType())) {
+        // Check with canConstantFoldUser() first to avoid checking the operands
+        // which can be expensive for a large phi, etc.
+        if (isa<IntegerType>(Val->getType()) && canConstantFoldUser(Val)) {
           const DataLayout &DL = BBTo->getModule()->getDataLayout();
           if (usesOperand(Usr, Condition)) {
             // If Val has Condition as an operand and Val can be folded into a
             // constant with either Condition == true or Condition == false,
             // propagate the constant.
             // eg.
             //   ; %Val is true on the edge to %then.
             //   %Val = and i1 %Condition, true.
static bool getEdgeValueLocal(Value *Val, BasicBlock *BBFrom,
   }
 
   // If the edge was formed by a switch on the value, then we may know exactly
   // what it is.
   if (SwitchInst *SI = dyn_cast<SwitchInst>(BBFrom->getTerminator())) {
     Value *Condition = SI->getCondition();
     if (!isa<IntegerType>(Val->getType()))
       return false;
     bool ValUsesCondition = false;
     if (Condition != Val) {
       // Check if Val has Condition as an operand.
       if (User *Usr = dyn_cast<User>(Val))
         ValUsesCondition = usesOperand(Usr, Condition);
       if (!ValUsesCondition)
         return false;
     }
     assert((Condition == Val || ValUsesCondition) &&
            "Condition != Val nor Val doesn't use Condition");
 
     bool DefaultCase = SI->getDefaultDest() == BBTo;
     unsigned BitWidth = Val->getType()->getIntegerBitWidth();
     ConstantRange EdgesVals(BitWidth, DefaultCase/*isFullSet*/);