[InstSimplify] Expose generic interface for replaced operand simplification

[jdoerfert]

Summary

Users, especially the Attributor, might replace multiple operands at
once. The actual implementation of simplifyWithOpReplaced is able to
handle that just fine, the interface was simply not allowing to replace
more than one operand at a time. This is exposing a more generic
interface without intended changes for existing code.

[jdoerfert]

Rename function, improve documentation, clang format

[lebedev.ri]

llvm/include/llvm/Analysis/InstructionSimplify.h

322–327

[lebedev.ri]

llvm/include/llvm/Analysis/InstructionSimplify.h

326

Should this be ArrayRef?

[jdoerfert]

Use ArrayRef

[nikic]

I don't think simplifyWithOpReplaced() is the right starting point for this. This function has a specific purpose and it has complex and dangerous semantics.

I think what you really want is something along the lines of ConstantFoldInstruction vs ConstantFoldInstOperands. That is, you should take SimplifyInstruction and rewrite it into a SimplifyInstOperands function that takes the operands as an explicit ArrayRef, and then call that from SimplifyInstruction. That will ensure that you can actually simplify all instructions that InstSimplify supports, rather than just the peculiar subset that simplifyWithOpReplaced deals with.

[lebedev.ri]

Seems straight-forward to me

[jdoerfert]

Working on the alternative

llvm/include/llvm/Analysis/InstructionSimplify.h

326

Yes.

[jdoerfert]

Change approach to use the SimplifyInstruction interface instead. Tests not updated yet.

[jdoerfert]

@nikic Like this?

I needed to use NewOps for load simplification to make it as powerful as the former approach. Also did the same to PHI simplification because it seemed easy.

[lebedev.ri]

simplifyInstruction*With*Operands

[nikic]

LG

llvm/lib/Analysis/InstructionSimplify.cpp

6068

make the load

6098

This fallback shouldn't be necessary, ConstantFoldInstruction bails on non-constant operands.

[jdoerfert]

Address comments

[lebedev.ri]

Not sure if it makes sense to commit some parts of this separately, maybe not.

llvm/lib/Analysis/InstructionSimplify.cpp

6252–6253

assert(NewOps.size() == I.getNumOperands() && "");

[jdoerfert]

Add assert

llvm/include/llvm/Analysis/InstructionSimplify.h

 
 /// See if V simplifies when its operand Op is replaced with RepOp. If not,
 /// return null.
 /// AllowRefinement specifies whether the simplification can be a refinement
 /// (e.g. 0 instead of poison), or whether it needs to be strictly identical.
 Value *simplifyWithOpReplaced(Value *V, Value *Op, Value *RepOp,
                               const SimplifyQuery &Q, bool AllowRefinement);
 
+/// See if V simplifies when its operands are replaced with \p NewOps. If not,
+/// return null.
+/// AllowRefinement specifies whether the simplification can be a refinement
+/// (e.g. 0 instead of poison), or whether it needs to be strictly identical.
+Value *simplifyWithOpsReplaced(Value *V, SmallVectorImpl<Value *> &NewOps,
+                               const SimplifyQuery &Q, bool AllowRefinement);
+
 /// Replace all uses of 'I' with 'SimpleV' and simplify the uses recursively.
 ///
 /// This first performs a normal RAUW of I with SimpleV. It then recursively
 /// attempts to simplify those users updated by the operation. The 'I'
 /// instruction must not be equal to the simplified value 'SimpleV'.
 /// If UnsimplifiedUsers is provided, instructions that could not be simplified
 /// are added to it.
 ///

llvm/lib/Analysis/InstructionSimplify.cpp

static Value *SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
   return nullptr;
 }
 
 Value *llvm::SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
                               FastMathFlags FMF, const SimplifyQuery &Q) {
   return ::SimplifyFCmpInst(Predicate, LHS, RHS, FMF, Q, RecursionLimit);
 }
 
-static Value *simplifyWithOpReplaced(Value *V, Value *Op, Value *RepOp,
+static Value *simplifyWithOpsReplaced(Instruction *I,
+                                      SmallVectorImpl<Value *> &NewOps,
                                       const SimplifyQuery &Q,
                                       bool AllowRefinement,
                                       unsigned MaxRecurse) {
-  assert(!Op->getType()->isVectorTy() && "This is not safe for vectors");
-
-  // Trivial replacement.
-  if (V == Op)
-    return RepOp;
-
-  // We cannot replace a constant, and shouldn't even try.
-  if (isa<Constant>(Op))
-    return nullptr;
-
-  auto *I = dyn_cast<Instruction>(V);
-  if (!I || !is_contained(I->operands(), Op))
-    return nullptr;
-
-  // Replace Op with RepOp in instruction operands.
-  SmallVector<Value *, 8> NewOps(I->getNumOperands());
-  transform(I->operands(), NewOps.begin(),
-            [&](Value *V) { return V == Op ? RepOp : V; });
 
   if (!AllowRefinement) {
     // General InstSimplify functions may refine the result, e.g. by returning
     // a constant for a potentially poison value. To avoid this, implement only
     // a few non-refining but profitable transforms here.
 
     if (auto *BO = dyn_cast<BinaryOperator>(I)) {
       unsigned Opcode = BO->getOpcode();
if (!AllowRefinement) {
     //   %div = udiv i32 %arg, %arg2
     //   %mul = mul nsw i32 %div, %arg2
     //   %cmp = icmp eq i32 %mul, %arg
     //   %sel = select i1 %cmp, i32 %div, i32 undef
     // Replacing %arg by %mul, %div becomes "udiv i32 %mul, %arg2", which
     // simplifies back to %arg. This can only happen because %mul does not
     // dominate %div. To ensure a consistent return value contract, we make sure
     // that this case returns nullptr as well.
-    auto PreventSelfSimplify = [V](Value *Simplified) {
-      return Simplified != V ? Simplified : nullptr;
+    auto PreventSelfSimplify = [I](Value *Simplified) {
+      return Simplified != I ? Simplified : nullptr;
     };
 
     if (auto *B = dyn_cast<BinaryOperator>(I))
       return PreventSelfSimplify(SimplifyBinOp(B->getOpcode(), NewOps[0],
                                                NewOps[1], Q, MaxRecurse - 1));
 
     if (CmpInst *C = dyn_cast<CmpInst>(I))
       return PreventSelfSimplify(SimplifyCmpInst(C->getPredicate(), NewOps[0],
static Value *simplifyWithOpsReplaced(Instruction *I,
 
   if (LoadInst *LI = dyn_cast<LoadInst>(I))
     if (!LI->isVolatile())
       return ConstantFoldLoadFromConstPtr(ConstOps[0], LI->getType(), Q.DL);
 
   return ConstantFoldInstOperands(I, ConstOps, Q.DL, Q.TLI);
 }
 
+static Value *simplifyWithOpReplaced(Value *V, Value *Op, Value *RepOp,
+                                     const SimplifyQuery &Q,
+                                     bool AllowRefinement,
+                                     unsigned MaxRecurse) {
+  assert(!Op->getType()->isVectorTy() && "This is not safe for vectors");
+
+  // Trivial replacement.
+  if (V == Op)
+    return RepOp;
+
+  // We cannot replace a constant, and shouldn't even try.
+  if (isa<Constant>(Op))
+    return nullptr;
+
+  auto *I = dyn_cast<Instruction>(V);
+  if (!I || !is_contained(I->operands(), Op))
+    return nullptr;
+
+  // Replace Op with RepOp in instruction operands.
+  SmallVector<Value *, 8> NewOps(I->getNumOperands());
+  transform(I->operands(), NewOps.begin(),
+            [&](Value *V) { return V == Op ? RepOp : V; });
+  return ::simplifyWithOpsReplaced(I, NewOps, Q, AllowRefinement,
+                                   RecursionLimit);
+}
+
 Value *llvm::simplifyWithOpReplaced(Value *V, Value *Op, Value *RepOp,
                                     const SimplifyQuery &Q,
                                     bool AllowRefinement) {
   return ::simplifyWithOpReplaced(V, Op, RepOp, Q, AllowRefinement,
                                   RecursionLimit);
 }
 
+Value *llvm::simplifyWithOpsReplaced(Value *V, SmallVectorImpl<Value *> &NewOps,
+                                     const SimplifyQuery &Q,
+                                     bool AllowRefinement) {
+  auto *I = dyn_cast<Instruction>(V);
+  if (!I)
+    return nullptr;
+
+  return ::simplifyWithOpsReplaced(I, NewOps, Q, AllowRefinement,
+                                   RecursionLimit);
+}
+
 /// Try to simplify a select instruction when its condition operand is an
 /// integer comparison where one operand of the compare is a constant.
 static Value *simplifySelectBitTest(Value *TrueVal, Value *FalseVal, Value *X,
                                     const APInt *Y, bool TrueWhenUnset) {
   const APInt *C;
 
   // (X & Y) == 0 ? X & ~Y : X  --> X
   // (X & Y) != 0 ? X & ~Y : X  --> X & ~Y
static Constant *ConstructLoadOperandConstant(Value *Op) {
   return NewOp;
 }
 
 static Value *SimplifyLoadInst(LoadInst *LI, const SimplifyQuery &Q) {
   if (LI->isVolatile())
     return nullptr;
 
   if (auto *C = ConstantFoldInstruction(LI, Q.DL))
     return C;
 
   // The following only catches more cases than ConstantFoldInstruction() if the
   // load operand wasn't a constant. Specifically, invariant.group intrinsics.
   if (isa<Constant>(LI->getPointerOperand()))
     return nullptr;
 
   if (auto *C = dyn_cast_or_null<Constant>(
           ConstructLoadOperandConstant(LI->getPointerOperand())))
Value *llvm::SimplifyInstruction(Instruction *I, const SimplifyQuery &SQ,
   switch (I->getOpcode()) {
   default:
     Result = ConstantFoldInstruction(I, Q.DL, Q.TLI);
     break;
   case Instruction::FNeg:
     Result = SimplifyFNegInst(I->getOperand(0), I->getFastMathFlags(), Q);
     break;
   case Instruction::FAdd:
     Result = SimplifyFAddInst(I->getOperand(0), I->getOperand(1),
                               I->getFastMathFlags(), Q);
     break;
   case Instruction::Add:
     Result =
         SimplifyAddInst(I->getOperand(0), I->getOperand(1),
                         Q.IIQ.hasNoSignedWrap(cast<BinaryOperator>(I)),
                         Q.IIQ.hasNoUnsignedWrap(cast<BinaryOperator>(I)), Q);
     break;
#undef HANDLE_CAST_INST
   /// instruction simplified to itself.  Make life easier for users by
   /// detecting that case here, returning a safe value instead.
   return Result == I ? UndefValue::get(I->getType()) : Result;
 }
 
 /// Implementation of recursive simplification through an instruction's
 /// uses.
 ///
 /// This is the common implementation of the recursive simplification routines.
 /// If we have a pre-simplified value in 'SimpleV', that is forcibly used to
 /// replace the instruction 'I'. Otherwise, we simply add 'I' to the list of
 /// instructions to process and attempt to simplify it using
 /// InstructionSimplify. Recursively visited users which could not be
 /// simplified themselves are to the optional UnsimplifiedUsers set for
 /// further processing by the caller.
 ///
 /// This routine returns 'true' only when *it* simplifies something. The passed
 /// in simplified value does not count toward this.