Add more foldings and support in CVP

Signed-off-by: Vladimir Radosavljevic <[email protected]>

Author: vladimirradosavljevic

llvm/lib/Target/EVM/EVMTargetTransformInfo.cpp

@@ -49,13 +49,74 @@ static std::optional<Instruction *> foldSignExtendToConst(InstCombiner &IC,
 
 static std::optional<Instruction *> instCombineSignExtend(InstCombiner &IC,
                                                           IntrinsicInst &II) {
+  constexpr unsigned BitWidth = 256;
+  if (!II.getType()->isIntegerTy(BitWidth))
+    return std::nullopt;
+
   // Fold signextend(b, signextend(b, x)) -> signextend(b, x)
   Value *B = nullptr, *X = nullptr;
   if (match(&II, m_Intrinsic<Intrinsic::evm_signextend>(
                      m_Value(B), m_Intrinsic<Intrinsic::evm_signextend>(
                                      m_Deferred(B), m_Value(X)))))
     return IC.replaceInstUsesWith(II, II.getArgOperand(1));
 
+  // From now on, we only handle signextend with constant byte index.
+  const auto *ByteIdxC = dyn_cast<ConstantInt>(II.getArgOperand(0));
+  if (!ByteIdxC)
+    return std::nullopt;
+
+  // ByteIdx must be in range [0, 31].
+  uint64_t ByteIdx = ByteIdxC->getZExtValue();
+  if (ByteIdx >= BitWidth / 8)
+    return std::nullopt;
+
+  unsigned Width = (ByteIdx + 1) * 8;
+
+  // Fold signextend into shifts, if second operand or the result is shift
+  // with constant. LLVM will fuse those shifts, and will replace signextend
+  // with a shift, which is cheaper.
+  if (match(II.getArgOperand(1),
+            m_OneUse(m_Shift(m_Value(), m_ConstantInt()))) ||
+      (II.hasOneUse() &&
+       match(II.user_back(), m_Shift(m_Specific(&II), m_ConstantInt())))) {
+    unsigned ShiftAmt = BitWidth - Width;
+    auto *Shl = IC.Builder.CreateShl(II.getArgOperand(1), ShiftAmt);
+    auto *Ashr = IC.Builder.CreateAShr(Shl, ShiftAmt);
+    return IC.replaceInstUsesWith(II, Ashr);
+  }
+
+  const APInt *AndVal = nullptr;
+  // Match signextend(b, and(x, C))
+  if (match(II.getArgOperand(1), m_And(m_Value(X), m_APInt(AndVal)))) {
+    APInt LowMask = APInt::getLowBitsSet(BitWidth, Width);
+
+    // signextend(b, x & C) -> signextend(b, x)
+    // If and fully preservs low bits, we can drop it.
+    if ((*AndVal & LowMask) == LowMask)
+      return IC.replaceOperand(II, 1, X);
+
+    // signextend(b, x & C) -> (x & C)
+    // If and doesn't touch upper bits, and clears sign bit, we can drop
+    // signextend.
+    APInt SignBit = APInt(BitWidth, 1).shl(Width - 1);
+    if ((*AndVal & ~LowMask).isZero() && (*AndVal & SignBit).isZero())
+      return IC.replaceInstUsesWith(II, II.getArgOperand(1));
+
+    // signextend(b, x & C) -> 0
+    // If and clears all low bits, result is always 0.
+    if ((*AndVal & LowMask).isZero())
+      return IC.replaceInstUsesWith(II,
+                                    ConstantInt::getNullValue(II.getType()));
+  }
+
+  // and(signextend(b, x), C) -> and(x, C)
+  // If and doesn't touch upper bits, we can drop signextend.
+  if (II.hasOneUse() &&
+      match(II.user_back(), m_And(m_Specific(&II), m_APInt(AndVal)))) {
+    APInt LowMask = APInt::getLowBitsSet(BitWidth, Width);
+    if ((*AndVal & ~LowMask).isZero())
+      return IC.replaceInstUsesWith(II, II.getArgOperand(1));
+  }
   return foldSignExtendToConst(IC, II);
 }
 

llvm/lib/Transforms/Scalar/CorrelatedValuePropagation.cpp

@@ -32,6 +32,7 @@
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
+#include "llvm/IR/IntrinsicsEVM.h"
 #include "llvm/IR/Module.h" // EraVM local
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/PatternMatch.h"
@@ -654,13 +655,51 @@ static bool processSaturatingInst(SaturatingInst *SI, LazyValueInfo *LVI) {
   return true;
 }
 
+static bool processEVMSignExtend(IntrinsicInst *II, LazyValueInfo *LVI) {
+  constexpr unsigned BitWidth = 256;
+  if (!II->getType()->isIntegerTy(BitWidth))
+    return false;
+
+  const auto *ByteIdxC = dyn_cast<ConstantInt>(II->getArgOperand(0));
+  if (!ByteIdxC)
+    return false;
+
+  // ByteIdx must be in range [0, 31].
+  uint64_t ByteIdx = ByteIdxC->getZExtValue();
+  if (ByteIdx >= BitWidth / 8)
+    return false;
+
+  ConstantRange RRange =
+      LVI->getConstantRangeAtUse(II->getOperandUse(1), /*UndefAllowed*/ false);
+  if (RRange.isEmptySet())
+    return false;
+
+  // Range that signextend produces is:
+  //  [ -2^(width-1), 2^(width-1)-1 ] in signed space
+  // Since ConstantRange is [Min, Max), and Max is exclusive, we need to add 1.
+  unsigned Width = (ByteIdx + 1) * 8;
+  ConstantRange Range = ConstantRange::getNonEmpty(
+      APInt::getSignedMinValue(Width).sext(BitWidth),
+      APInt::getSignedMaxValue(Width).sext(BitWidth) + 1);
+
+  if (!Range.contains(RRange))
+    return false;
+
+  II->replaceAllUsesWith(II->getArgOperand(1));
+  II->eraseFromParent();
+  return true;
+}
+
 /// Infer nonnull attributes for the arguments at the specified callsite.
 static bool processCallSite(CallBase &CB, LazyValueInfo *LVI) {
 
   if (CB.getIntrinsicID() == Intrinsic::abs) {
     return processAbsIntrinsic(&cast<IntrinsicInst>(CB), LVI);
   }
 
+  if (CB.getIntrinsicID() == Intrinsic::evm_signextend)
+    return processEVMSignExtend(&cast<IntrinsicInst>(CB), LVI);
+
   if (auto *CI = dyn_cast<CmpIntrinsic>(&CB)) {
     return processCmpIntrinsic(CI, LVI);
   }