[InlineCost] add visitSelectInst()

[haicheng]

Summary

This patch adds visitSelectInst() to find free Select IRs and continue the propagation of SimplifiedValues, ConstantOffsetPtrs, and SROAArgValues.

We don't need all operands of Select IR to be constants to fold it, so I don't use the generic CallAnalyzer::simplifyInstruction().

The impact on SPEC20xx is below

Benchmark	Code Size (%)	Perf (%)
	(+ is bigger)	(+ is faster)
spec2000/gcc	0.01	1.08
spec2000/mesa	0.04	2.2
spec2000/twolf	-0.15	-0.01
spec2006/gcc	0.02	-0.19
spec2006/h264ref	0.33	0.18
spec2017/blender	0.01	0.5
spec2017/gcc	0.01	0.09
spec2017/imagick	0.02	0.01
spec2017/parest	0	-0.05
spec2017/perlbench	0.1	0.56

[mcrosier]

Overall, the logic of the patch is in good shape. However, I'd suggest some minor refactoring to delineate the select of constants/values vs. GEPs for SROA.

Maybe something like this:

bool CallAnalyzer::visitSelectInst(SelectInst &SI) {
  Value *TrueVal = SI.getTrueValue();
  Value *FalseVal = SI.getFalseValue();

  Constant *TrueC = isa<Constant>(TrueVal) ? cast<Constant>(TrueVal)
                                           : SimplifiedValues.lookup(TrueVal);
  Constant *FalseC = isa<Constant>(FalseVal)
                         ? cast<Constant>(FalseVal)
                         : SimplifiedValues.lookup(FalseVal);
  // Select C, X, X => X
  if (TrueC && FalseC && TrueC == FalseC) {
    SimplifiedValues[&SI] = TrueC;
    return true;
  }

  Type *ValTy = FalseVal->getType();
  assert(TrueVal->getType() == FalseVal->getType() &&
         "Expected matching types.");

  Constant *CondC =
      dyn_cast_or_null<Constant>(SimplifiedValues.lookup(SI.getCondition()));
  // Select condition is a constant.
  if (CondC && !ValTy->isPointerTy()) {
    // Select True, X, Y => X
    if (CondC->isAllOnesValue() && TrueC)
      SimplifiedValues[&SI] = TrueC;
    // Select False, X, Y => Y
    if (CondC->isNullValue() && FalseC)
      SimplifiedValues[&SI] = FalseC;
    // If all operands are constants.  ConstantExpr::getSelect() can handle
    // rest cases such as select vectors.
    if (TrueC && FalseC)
      if (Constant *C = ConstantExpr::getSelect(CondC, TrueC, FalseC))
        SimplifiedValues[&SI] = C;
    return true;
  }

  // Logic for SROA follows
  // Select C, X, X => X
  // Select True, X, Y => X
  // Select False, X, Y => Y

  return Base::visitSelectInst(SI);
}

IMHO this is a little easier to read.

[haicheng]

Move code around as suggested by Chad. Thank you.

[haicheng]

Kindly PIng

[mcrosier]

lib/Analysis/InlineCost.cpp

1221

Not sure it matters a great deal, but this could also be written as

if ((TrueC || FalseC) && TrueC == FalseC) {

Feel free to take it or leave it; either way is probably fine.

1242

can handle the rest of the cases, such as select vectors.

1251

toi -> to

[eraman]

lib/Analysis/InlineCost.cpp

1213

I added simplifyInstruction to handle instruction simplification with constant values. Now, it handles cases only when all the operands are constants - either as such or after looking up SimplifiedValues. It can be extended to handle cases like this where you don't need all operands to be constants. May be add a bool to indicate whether it should call the Callable even if all operands are not constants and use that here?

[haicheng]

Extend simplifyInstruction() to handle the cases that not all operands are constants. Use SimplifySelectInst() to process Select.

Thank you.

Haicheng

[eraman]

lib/Analysis/InlineCost.cpp

496

Sorry, I should have thought through this carefully. My bad. I feel this version is worse than before. Most callers of simplifyInstruction pass a callable that takes a vector of Value * and implicitly treats it as a vector of Constant *. Feel free to go back the the previous version or come up with a better way to refactor simplifyInstruction. My main motivation for the refactoring was to keep accesses to SimplifiedValues in one location, so that we can get data on how often does inlining actually simplifies a value to a constant.

[chandlerc]

Just wanted to say thanks so much for working on this -- its a huge improvement to the inline cost.

lib/Analysis/InlineCost.cpp

496

FWIW, I agree. I looked at both versions, and I think the custom select handling is better. It's hard to tell ahead of time, so still, thanks for exploring whether this helps.

1232

No need to separately test for true and false once you know the condition is a constant. Just check isNullValue(). It's either false, or true. =]

1243–1248

I feel like we should handle this above when handling TrueC == FalseC.

1253–1280

I think this code will be substantially simpler if you refactor it in the following way.

First, check if the condition is a constant. If *not* a constant, then handle the only cases we can handle in that world: equal (or constant expr-able) inputs, or matching SROA args like here. Then return.

Rest of the function only handling when it *is* a constant. Then assign the input the constant will select to a variable, and only do all the checks on that one variable rather on both true and false variants.

[haicheng]

Thank you, Chandler. I will update the patch shortly.

lib/Analysis/InlineCost.cpp

1232

The vector constant condition can be <i1 true, i1 false>. It is neither AllOnesValue or NullValue.

[chandlerc]

lib/Analysis/InlineCost.cpp

1232

Ah, I see.

But if you have a constant condition, even if a vector with a mixture of true and false elements, you can fully simulate the select (and we should). The test should be "is it a constant". Once we know that it is, we should be able to get at each element and test whether that element is a null value or not. And then the scalar case will just be the same as a 1-element vector.

[haicheng]

Back to the customized implementation, reorganized the code, rewrote the test cases.

Please take a look. Thank you.

[chandlerc]

Mostly minor suggestions below...

lib/Analysis/InlineCost.cpp

1214–1218

I'd still use dyn_cast here:

Constant *TrueC = dyn_cast<Constant>(TrueVal);
if (!TrueC)
  TrueC = SimplifiedValues.lookup(TrueVal);

1224

I'd simplify this as: TrueC == FalseC && TrueC.

1258

auto?

1266–1267

I think just dyn_cast<Constant>(SelectedV) is easier to read and no more expensive.

[haicheng]

Address Chandler's comments. Please take a look. Thank you.

[chandlerc]

This is looking pretty good. Some nit-picky improvements below. I'd love for Easwaran to get another chance to look at this too though...

lib/Analysis/InlineCost.cpp

1230

Prefer early exit here, and below:

if (!CheckSROA)
  return Base::visitSelectInst(SI);

1235–1236

Similar to the above, this can be:

if (TrueBaseAndOffset == FalseBaseAndOffset && TrueBaseAndOffset.first)

1273

Early return here as well.

[haicheng]

Address Chandler's comments. Please take a look. Thank you.

[eraman]

LGTM

[chandlerc]

(Marking as accepted now that Easwaran has had a chance to look as well)

lib/Analysis/InlineCost.cpp

class CallAnalyzer : public InstVisitor<CallAnalyzer, bool> {
   void disableSROA(DenseMap<Value *, int>::iterator CostIt);
   void disableSROA(Value *V);
   void accumulateSROACost(DenseMap<Value *, int>::iterator CostIt,
                           int InstructionCost);
   bool isGEPFree(GetElementPtrInst &GEP);
   bool accumulateGEPOffset(GEPOperator &GEP, APInt &Offset);
   bool simplifyCallSite(Function *F, CallSite CS);
   template <typename Callable>
-  bool simplifyInstruction(Instruction &I, Callable Evaluate);
+  bool simplifyInstruction(Instruction &I, Callable Evaluate,
+                           bool AllConstants = true);
   ConstantInt *stripAndComputeInBoundsConstantOffsets(Value *&V);
 
   /// Return true if the given argument to the function being considered for
   /// inlining has the given attribute set either at the call site or the
   /// function declaration.  Primarily used to inspect call site specific
   /// attributes since these can be more precise than the ones on the callee
   /// itself.
   bool paramHasAttr(Argument *A, Attribute::AttrKind Attr);
class CallAnalyzer : public InstVisitor<CallAnalyzer, bool> {
   bool visitBinaryOperator(BinaryOperator &I);
   bool visitLoad(LoadInst &I);
   bool visitStore(StoreInst &I);
   bool visitExtractValue(ExtractValueInst &I);
   bool visitInsertValue(InsertValueInst &I);
   bool visitCallSite(CallSite CS);
   bool visitReturnInst(ReturnInst &RI);
   bool visitBranchInst(BranchInst &BI);
+  bool visitSelectInst(SelectInst &SI);
   bool visitSwitchInst(SwitchInst &SI);
   bool visitIndirectBrInst(IndirectBrInst &IBI);
   bool visitResumeInst(ResumeInst &RI);
   bool visitCleanupReturnInst(CleanupReturnInst &RI);
   bool visitCatchReturnInst(CatchReturnInst &RI);
   bool visitUnreachableInst(UnreachableInst &I);
 
 public:
bool CallAnalyzer::visitGetElementPtr(GetElementPtrInst &I) {
   }
 
   // Variable GEPs will require math and will disable SROA.
   if (SROACandidate)
     disableSROA(CostIt);
   return isGEPFree(I);
 }
 
-/// Simplify \p I if its operands are constants and update SimplifiedValues.
-/// \p Evaluate is a callable specific to instruction type that evaluates the
-/// instruction when all the operands are constants.
+/// Simplify \p I and update lists such as SimplifiedValues.  \p Evaluate is a
+/// callable specific to instruction type that evaluates the instruction.  If \p
+/// AllConstants is set to true, this function tries to map all constant
+/// operands to a constant.  Otherwise, it tries to fold the instruction to a
+/// simplified value.
 template <typename Callable>
-bool CallAnalyzer::simplifyInstruction(Instruction &I, Callable Evaluate) {
-  SmallVector<Constant *, 2> COps;
+bool CallAnalyzer::simplifyInstruction(Instruction &I, Callable Evaluate,
+                                       bool AllConstants) {
+  SmallVector<Value *, 2> Ops;
   for (Value *Op : I.operands()) {
-    Constant *COp = dyn_cast<Constant>(Op);
-    if (!COp)
-      COp = SimplifiedValues.lookup(Op);
-    if (!COp)
+    Constant *COp =
+        isa<Constant>(Op) ? cast<Constant>(Op) : SimplifiedValues.lookup(Op);
+    if (COp)
+      Ops.push_back(COp);
+    else {
+      if (AllConstants)
         return false;
-    COps.push_back(COp);
+      else
+        Ops.push_back(Op);
     }
-  auto *C = Evaluate(COps);
-  if (!C)
+  }
+  auto *V = Evaluate(Ops);
+  if (!V)
     return false;
+  if (Constant *C = dyn_cast_or_null<Constant>(V)) {
     SimplifiedValues[&I] = C;
     return true;
   }
 
+  // We cannot simplify the instruction into a constant.
+  if (AllConstants)
+    return false;
+
+  if (I.getType()->isPointerTy()) {
+    std::pair<Value *, APInt> BaseAndOffset = ConstantOffsetPtrs.lookup(V);
+    if (BaseAndOffset.first)
+      ConstantOffsetPtrs[&I] = BaseAndOffset;
+    Value *SROAArg;
+    DenseMap<Value *, int>::iterator CostIt;
+    if (lookupSROAArgAndCost(V, SROAArg, CostIt))
+      SROAArgValues[&I] = SROAArg;
+  }
+
+  return true;
+}
+
 bool CallAnalyzer::visitBitCast(BitCastInst &I) {
   // Propagate constants through bitcasts.
-  if (simplifyInstruction(I, [&](SmallVectorImpl<Constant *> &COps) {
-        return ConstantExpr::getBitCast(COps[0], I.getType());
+  if (simplifyInstruction(I, [&](SmallVectorImpl<Value *> &COps) {
+        return ConstantExpr::getBitCast(cast<Constant>(COps[0]), I.getType());
       }))
     return true;
 
   // Track base/offsets through casts
   std::pair<Value *, APInt> BaseAndOffset =
       ConstantOffsetPtrs.lookup(I.getOperand(0));
   // Casts don't change the offset, just wrap it up.
   if (BaseAndOffset.first)
     ConstantOffsetPtrs[&I] = BaseAndOffset;
 
   // Also look for SROA candidates here.
   Value *SROAArg;
   DenseMap<Value *, int>::iterator CostIt;
   if (lookupSROAArgAndCost(I.getOperand(0), SROAArg, CostIt))
     SROAArgValues[&I] = SROAArg;
 
   // Bitcasts are always zero cost.
   return true;
 }
 
 bool CallAnalyzer::visitPtrToInt(PtrToIntInst &I) {
   // Propagate constants through ptrtoint.
-  if (simplifyInstruction(I, [&](SmallVectorImpl<Constant *> &COps) {
-        return ConstantExpr::getPtrToInt(COps[0], I.getType());
+  if (simplifyInstruction(I, [&](SmallVectorImpl<Value *> &COps) {
+        return ConstantExpr::getPtrToInt(cast<Constant>(COps[0]), I.getType());
       }))
     return true;
 
   // Track base/offset pairs when converted to a plain integer provided the
   // integer is large enough to represent the pointer.
   unsigned IntegerSize = I.getType()->getScalarSizeInBits();
   if (IntegerSize >= DL.getPointerSizeInBits()) {
     std::pair<Value *, APInt> BaseAndOffset =
bool CallAnalyzer::visitPtrToInt(PtrToIntInst &I) {
   if (lookupSROAArgAndCost(I.getOperand(0), SROAArg, CostIt))
     SROAArgValues[&I] = SROAArg;
 
   return TargetTransformInfo::TCC_Free == TTI.getUserCost(&I);
 }
 
 bool CallAnalyzer::visitIntToPtr(IntToPtrInst &I) {
   // Propagate constants through ptrtoint.
-  if (simplifyInstruction(I, [&](SmallVectorImpl<Constant *> &COps) {
-        return ConstantExpr::getIntToPtr(COps[0], I.getType());
+  if (simplifyInstruction(I, [&](SmallVectorImpl<Value *> &COps) {
+        return ConstantExpr::getIntToPtr(cast<Constant>(COps[0]), I.getType());
       }))
     return true;
 
   // Track base/offset pairs when round-tripped through a pointer without
   // modifications provided the integer is not too large.
   Value *Op = I.getOperand(0);
   unsigned IntegerSize = Op->getType()->getScalarSizeInBits();
   if (IntegerSize <= DL.getPointerSizeInBits()) {
     std::pair<Value *, APInt> BaseAndOffset = ConstantOffsetPtrs.lookup(Op);
     if (BaseAndOffset.first)
       ConstantOffsetPtrs[&I] = BaseAndOffset;
   }
 
   // "Propagate" SROA here in the same manner as we do for ptrtoint above.
   Value *SROAArg;
   DenseMap<Value *, int>::iterator CostIt;
   if (lookupSROAArgAndCost(Op, SROAArg, CostIt))
     SROAArgValues[&I] = SROAArg;
 
   return TargetTransformInfo::TCC_Free == TTI.getUserCost(&I);
 }
 
 bool CallAnalyzer::visitCastInst(CastInst &I) {
   // Propagate constants through ptrtoint.
-  if (simplifyInstruction(I, [&](SmallVectorImpl<Constant *> &COps) {
-        return ConstantExpr::getCast(I.getOpcode(), COps[0], I.getType());
+  if (simplifyInstruction(I, [&](SmallVectorImpl<Value *> &COps) {
+        return ConstantExpr::getCast(I.getOpcode(), cast<Constant>(COps[0]),
+                                     I.getType());
       }))
     return true;
 
   // Disable SROA in the face of arbitrary casts we don't whitelist elsewhere.
   disableSROA(I.getOperand(0));
 
   return TargetTransformInfo::TCC_Free == TTI.getUserCost(&I);
 }
 
 bool CallAnalyzer::visitUnaryInstruction(UnaryInstruction &I) {
   Value *Operand = I.getOperand(0);
-  if (simplifyInstruction(I, [&](SmallVectorImpl<Constant *> &COps) {
-        return ConstantFoldInstOperands(&I, COps[0], DL);
+  if (simplifyInstruction(I, [&](SmallVectorImpl<Value *> &COps) {
+        return ConstantFoldInstOperands(&I, cast<Constant>(COps[0]), DL);
       }))
     return true;
 
   // Disable any SROA on the argument to arbitrary unary operators.
   disableSROA(Operand);
 
   return false;
 }
void CallAnalyzer::updateThreshold(CallSite CS, Function &Callee) {
   // Cost in updateThreshold, but the bonus depends on the logic in this method.
   if (OnlyOneCallAndLocalLinkage)
     Cost -= LastCallToStaticBonus;
 }
 
 bool CallAnalyzer::visitCmpInst(CmpInst &I) {
   Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
   // First try to handle simplified comparisons.
-  if (simplifyInstruction(I, [&](SmallVectorImpl<Constant *> &COps) {
-        return ConstantExpr::getCompare(I.getPredicate(), COps[0], COps[1]);
+  if (simplifyInstruction(I, [&](SmallVectorImpl<Value *> &COps) {
+        return ConstantExpr::getCompare(
+            I.getPredicate(), cast<Constant>(COps[0]), cast<Constant>(COps[1]));
       }))
     return true;
 
   if (I.getOpcode() == Instruction::FCmp)
     return false;
 
   // Otherwise look for a comparison between constant offset pointers with
   // a common base.
bool CallAnalyzer::visitSub(BinaryOperator &I) {
 
   // Otherwise, fall back to the generic logic for simplifying and handling
   // instructions.
   return Base::visitSub(I);
 }
 
 bool CallAnalyzer::visitBinaryOperator(BinaryOperator &I) {
   Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
-  auto Evaluate = [&](SmallVectorImpl<Constant *> &COps) {
+  auto Evaluate = [&](SmallVectorImpl<Value *> &COps) {
     Value *SimpleV = nullptr;
     if (auto FI = dyn_cast<FPMathOperator>(&I))
-      SimpleV = SimplifyFPBinOp(I.getOpcode(), COps[0], COps[1],
-                                FI->getFastMathFlags(), DL);
+      SimpleV =
+          SimplifyFPBinOp(I.getOpcode(), cast<Constant>(COps[0]),
+                          cast<Constant>(COps[1]), FI->getFastMathFlags(), DL);
     else
-      SimpleV = SimplifyBinOp(I.getOpcode(), COps[0], COps[1], DL);
+      SimpleV = SimplifyBinOp(I.getOpcode(), cast<Constant>(COps[0]),
+                              cast<Constant>(COps[1]), DL);
     return dyn_cast_or_null<Constant>(SimpleV);
   };
 
   if (simplifyInstruction(I, Evaluate))
     return true;
 
   // Disable any SROA on arguments to arbitrary, unsimplified binary operators.
   disableSROA(LHS);
if (lookupSROAArgAndCost(I.getPointerOperand(), SROAArg, CostIt)) {
     disableSROA(CostIt);
   }
 
   return false;
 }
 
 bool CallAnalyzer::visitExtractValue(ExtractValueInst &I) {
   // Constant folding for extract value is trivial.
-  if (simplifyInstruction(I, [&](SmallVectorImpl<Constant *> &COps) {
-        return ConstantExpr::getExtractValue(COps[0], I.getIndices());
+  if (simplifyInstruction(I, [&](SmallVectorImpl<Value *> &COps) {
+        return ConstantExpr::getExtractValue(cast<Constant>(COps[0]),
+                                             I.getIndices());
       }))
     return true;
 
   // SROA can look through these but give them a cost.
   return false;
 }
 
 bool CallAnalyzer::visitInsertValue(InsertValueInst &I) {
   // Constant folding for insert value is trivial.
-  if (simplifyInstruction(I, [&](SmallVectorImpl<Constant *> &COps) {
-        return ConstantExpr::getInsertValue(/*AggregateOperand*/ COps[0],
-                                            /*InsertedValueOperand*/ COps[1],
-                                            I.getIndices());
+  if (simplifyInstruction(I, [&](SmallVectorImpl<Value *> &COps) {
+        return ConstantExpr::getInsertValue(
+            /*AggregateOperand*/ cast<Constant>(COps[0]),
+            /*InsertedValueOperand*/ cast<Constant>(COps[1]), I.getIndices());
       }))
     return true;
 
   // SROA can look through these but give them a cost.
   return false;
 }
 
 /// \brief Try to simplify a call site.
bool CallAnalyzer::visitBranchInst(BranchInst &BI) {
   // shouldn't exist at all, but handling them makes the behavior of the
   // inliner more regular and predictable. Interestingly, conditional branches
   // which will fold away are also free.
   return BI.isUnconditional() || isa<ConstantInt>(BI.getCondition()) ||
          dyn_cast_or_null<ConstantInt>(
              SimplifiedValues.lookup(BI.getCondition()));
 }
 
+bool CallAnalyzer::visitSelectInst(SelectInst &SI) {
+  if (simplifyInstruction(SI,
+                          [&](SmallVectorImpl<Value *> &Ops) {
+                            return SimplifySelectInst(Ops[0], Ops[1], Ops[2],
+                                                      DL);
+                          },
+                          false))
+    return true;
+
+  return Base::visitSelectInst(SI);
+}
+
 bool CallAnalyzer::visitSwitchInst(SwitchInst &SI) {
   // We model unconditional switches as free, see the comments on handling
   // branches.
   if (isa<ConstantInt>(SI.getCondition()))
     return true;
   if (Value *V = SimplifiedValues.lookup(SI.getCondition()))
     if (isa<ConstantInt>(V))
       return true;
 
   // Assume the most general case where the switch is lowered into
   // either a jump table, bit test, or a balanced binary tree consisting of
   // case clusters without merging adjacent clusters with the same
   // destination. We do not consider the switches that are lowered with a mix
   // of jump table/bit test/binary search tree. The cost of the switch is
   // proportional to the size of the tree or the size of jump table range.
   //
   // NB: We convert large switches which are just used to initialize large phi
   // nodes to lookup tables instead in simplify-cfg, so this shouldn't prevent
   // inlining those. It will prevent inlining in cases where the optimization
   // does not (yet) fire.
 
   // Maximum valid cost increased in this function.
   int CostUpperBound = INT_MAX - InlineConstants::InstrCost - 1;
 
   // Exit early for a large switch, assuming one case needs at least one
   // instruction.
   // FIXME: This is not true for a bit test, but ignore such case for now to
   // save compile-time.
   int64_t CostLowerBound =
       std::min((int64_t)CostUpperBound,
                (int64_t)SI.getNumCases() * InlineConstants::InstrCost + Cost);
 
   if (CostLowerBound > Threshold && !ComputeFullInlineCost) {
     Cost = CostLowerBound;
     return false;
   }
 
   unsigned JumpTableSize = 0;
   unsigned NumCaseCluster =
       TTI.getEstimatedNumberOfCaseClusters(SI, JumpTableSize);
 
   // If suitable for a jump table, consider the cost for the table size and
   // branch to destination.
   if (JumpTableSize) {
     int64_t JTCost = (int64_t)JumpTableSize * InlineConstants::InstrCost +
                      4 * InlineConstants::InstrCost;
 
     Cost = std::min((int64_t)CostUpperBound, JTCost + Cost);
     return false;
   }
 
   // Considering forming a binary search, we should find the number of nodes
   // which is same as the number of comparisons when lowered. For a given
   // number of clusters, n, we can define a recursive function, f(n), to find
   // the number of nodes in the tree. The recursion is :
   // f(n) = 1 + f(n/2) + f (n - n/2), when n > 3,
   // and f(n) = n, when n <= 3.
   // This will lead a binary tree where the leaf should be either f(2) or f(3)
   // when n > 3.  So, the number of comparisons from leaves should be n, while
   // the number of non-leaf should be :
   //   2^(log2(n) - 1) - 1
   //   = 2^log2(n) * 2^-1 - 1
   //   = n / 2 - 1.
   // Considering comparisons from leaf and non-leaf nodes, we can estimate the
   // number of comparisons in a simple closed form :
   //   n + n / 2 - 1 = n * 3 / 2 - 1
   if (NumCaseCluster <= 3) {
     // Suppose a comparison includes one compare and one conditional branch.

test/Transforms/Inline/AArch64/select.ll

+; REQUIRES: asserts
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %s 2>&1 | FileCheck %s
+
+target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
+target triple = "aarch64--linux-gnu"
+
+define i32 @outer1(i1 %cond) {
+  %C = call i32 @inner1(i1 %cond, i32 1)
+  ret i32 %C
+}
+
+; CHECK: Analyzing call of inner1
+; CHECK: NumInstructionsSimplified: 2
+; CHECK: NumInstructions: 2
+define i32 @inner1(i1 %cond, i32 %val) {
+  %select = select i1 %cond, i32 1, i32 %val       ; Simplified to 1
+  ret i32 %select                                  ; Simplifies to ret i32 1
+}
+
+
+define i32 @outer2(i32 %val) {
+  %C = call i32 @inner2(i1 true, i32 %val)
+  ret i32 %C
+}
+
+; CHECK: Analyzing call of inner2
+; CHECK: NumInstructionsSimplified: 2
+; CHECK: NumInstructions: 2
+define i32 @inner2(i1 %cond, i32 %val) {
+  %select = select i1 %cond, i32 1, i32 %val       ; Simplifies to 1
+  ret i32 %select                                  ; Simplifies to ret i32 1
+}
+
+
+define i32 @outer3(i32 %val) {
+  %C = call i32 @inner3(i1 false, i32 %val)
+  ret i32 %C
+}
+
+; CHECK: Analyzing call of inner3
+; CHECK: NumInstructionsSimplified: 2
+; CHECK: NumInstructions: 2
+define i32 @inner3(i1 %cond, i32 %val) {
+  %select = select i1 %cond, i32 %val, i32 -1      ; Simplifies to -1
+  ret i32 %select                                  ; Simplifies to ret i32 -1
+}
+
+
+define i32 @outer4() {
+  %C = call i32 @inner4(i1 true, i32 1, i32 -1)
+  ret i32 %C
+}
+
+; CHECK: Analyzing call of inner4
+; CHECK: NumInstructionsSimplified: 2
+; CHECK: NumInstructions: 2
+define i32 @inner4(i1 %cond, i32 %val1, i32 %val2) {
+  %select = select i1 %cond, i32 %val1, i32 %val2  ; Simplifies to 1
+  ret i32 %select                                  ; Simplifies to ret i32 1
+}
+
+
+define i1 @outer5() {
+  %C = call i1 @inner5(i1 true, i1 true, i1 false)
+  ret i1 %C
+}
+
+; CHECK: Analyzing call of inner5
+; CHECK: NumInstructionsSimplified: 3
+; CHECK: NumInstructions: 3
+define i1 @inner5(i1 %cond, i1 %val1, i1 %val2) {
+  %select = select i1 %cond, i1 %val1, i1 %val2    ; Simplifies to true
+  br i1 %select, label %exit, label %isfalse       ; Simplifies to br label %end
+
+isfalse:                                           ; This block is unreachable once inlined
+  call void @dead()
+  call void @dead()
+  call void @dead()
+  call void @dead()
+  call void @dead()
+  br label %exit
+
+exit:
+  ret i1 %select                                   ; Simplifies to ret i1 true
+}
+
+declare void @dead()
+
+
+define i32 @outer6(i32* %ptr) {
+  %A = alloca i32
+  %C = call i32 @inner6(i1 true, i32* %A, i32* %ptr)
+  ret i32 %C
+}
+
+; CHECK: Analyzing call of inner6
+; CHECK: NumInstructionsSimplified: 3
+; CHECK: NumInstructions: 3
+define i32 @inner6(i1 %cond, i32* %p1, i32* %p2) {
+  %select = select i1 %cond, i32* %p1, i32* %p2    ; Simplifies to %A
+  %load = load i32, i32* %select                   ; SROA'ed
+  ret i32 %load                                    ; Simplified
+}
+
+
+define i32 @outer7(i32* %ptr) {
+  %A = alloca i32
+  %C = call i32 @inner7(i1 false, i32* %ptr, i32* %A)
+  ret i32 %C
+}
+
+; CHECK: Analyzing call of inner7
+; CHECK: NumInstructionsSimplified: 3
+; CHECK: NumInstructions: 3
+define i32 @inner7(i1 %cond, i32* %p1, i32* %p2) {
+  %select = select i1 %cond, i32* %p1, i32* %p2    ; Simplifies to %A
+  %load = load i32, i32* %select                   ; SROA'ed
+  ret i32 %load                                    ; Simplified
+}
+
+
+define <2 x i32> @outer8(<2 x i32> %val) {
+  %C = call <2 x i32> @inner8(<2 x i1> <i1 true, i1 true>, <2 x i32> %val)
+  ret <2 x i32> %C
+}
+
+; CHECK: Analyzing call of inner8
+; CHECK: NumInstructionsSimplified: 2
+; CHECK: NumInstructions: 2
+define <2 x i32> @inner8(<2 x i1> %cond, <2 x i32> %val) {
+  %select = select <2 x i1> %cond, <2 x i32> <i32 1, i32 1>, <2 x i32> %val              ; Simplifies to <1, 1>
+  ret <2 x i32> %select                                                                  ; Simplifies to ret <2 x i32> <1, 1>
+}
+
+
+define <2 x i32> @outer9(<2 x i32> %val) {
+  %C = call <2 x i32> @inner9(<2 x i1> <i1 false, i1 false>, <2 x i32> %val)
+  ret <2 x i32> %C
+}
+
+; CHECK: Analyzing call of inner9
+; CHECK: NumInstructionsSimplified: 2
+; CHECK: NumInstructions: 2
+define <2 x i32> @inner9(<2 x i1> %cond, <2 x i32> %val) {
+  %select = select <2 x i1> %cond, < 2 x i32> %val, <2 x i32> <i32 -1, i32 -1>           ; Simplifies to <-1, -1>
+  ret <2 x i32> %select                                                                  ; Simplifies to ret <2 x i32> <-1, -1>
+}
+
+
+@glbl = external global i32
+
+define i1 @outer10(i32* %ptr) {
+  %C = call i1 @inner10(i1 true, i32* @glbl, i32* %ptr)
+  ret i1 %C
+}
+
+; CHECK: Analyzing call of inner10
+; CHECK: NumInstructionsSimplified: 3
+; CHECK: NumInstructions: 3
+define i1 @inner10(i1 %cond, i32* %ptr1, i32* %ptr2) {
+  %select = select i1 %cond, i32* %ptr1, i32* %ptr2 ; Simplified to @glbl
+  %cmp = icmp eq i32* %select, @glbl                ; Simplified to true
+  ret i1 %cmp                                       ; Simplifies to ret i1 true
+}
+
+
+define <2 x i32> @outer11(<2 x i32> %val1, <2 x i32> %val2) {
+  %C = call <2 x i32> @inner11(<2 x i1> <i1 true, i1 false>, <2 x i32> %val1, <2 x i32> %val2)
+  ret <2 x i32> %C
+}
+
+; CHECK: Analyzing call of inner11
+; CHECK: NumInstructionsSimplified: 1
+; CHECK: NumInstructions: 2
+define <2 x i32> @inner11(<2 x i1> %cond, <2 x i32> %val1, < 2 x i32> %val2) {
+  %select = select <2 x i1> %cond, <2 x i32> %val1, < 2 x i32> %val2 ; Cannot be Simplified
+  ret <2 x i32> %select                                              ; Simplified
+}
+
+
+define i32 @outer12(i32 %val1, i32 %val2) {
+  %C = call i32 @inner12(i1 true, i32 %val1, i32 %val2)
+  ret i32 %C
+}
+
+; CHECK: Analyzing call of inner12
+; CHECK: NumInstructionsSimplified: 2
+; CHECK: NumInstructions: 2
+define i32 @inner12(i1 %cond, i32 %val1, i32 %val2) {
+  %select = select i1 %cond, i32 %val1, i32 %val2   ; Simplified to %val1
+  ret i32 %select                                   ; Simplifies to ret i32 %val1
+}
+
+
+define i32 @outer13(i32 %val1, i32 %val2) {
+  %C = call i32 @inner13(i1 false, i32 %val1, i32 %val2)
+  ret i32 %C
+}
+
+; CHECK: Analyzing call of inner13
+; CHECK: NumInstructionsSimplified: 2
+; CHECK: NumInstructions: 2
+define i32 @inner13(i1 %cond, i32 %val1, i32 %val2) {
+  %select = select i1 %cond, i32 %val1, i32 %val2   ; Simplified to %val2
+  ret i32 %select                                   ; Simplifies to ret i32 %val2
+}

test/Transforms/Inline/alloca-bonus.ll

 ; %D poisons this call, scalar-repl can't handle that instruction.
 define void @inner2(i32 *%ptr) {
   %A = load i32, i32* %ptr
   store i32 0, i32* %ptr
   %C = getelementptr inbounds i32, i32* %ptr, i32 0
   %D = getelementptr inbounds i32, i32* %ptr, i32 %A
   %E = bitcast i32* %ptr to i8*
   %F = select i1 false, i32* %ptr, i32* @glbl
+  %L = load i32, i32* %F
   call void @llvm.lifetime.start.p0i8(i64 0, i8* %E)
   call void @extern()
   ret void
 }
 
 define void @outer3() {
 ; CHECK-LABEL: @outer3(
 ; CHECK-NOT: call void @inner3