Add more support for signextend

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

Author: vladimirradosavljevic

llvm/lib/Analysis/ValueTracking.cpp

@@ -1630,6 +1630,30 @@ static void computeKnownBitsFromOperator(const Operator *I,
       switch (II->getIntrinsicID()) {
       default:
         break;
+      case Intrinsic::evm_signextend: {
+        auto *Ty = dyn_cast<IntegerType>(II->getType());
+        if (!Ty)
+          break;
+
+        unsigned BitWidth = Ty->getIntegerBitWidth();
+        if (BitWidth != 256)
+          break;
+
+        const auto *ByteIdxC = dyn_cast<ConstantInt>(II->getArgOperand(0));
+        if (!ByteIdxC)
+          break;
+
+        // ByteIdx must be in range [0, 31].
+        uint64_t ByteIdx = ByteIdxC->getZExtValue();
+        if (ByteIdx >= BitWidth / 8)
+          break;
+
+        computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
+        unsigned Width = (ByteIdx + 1) * 8;
+        Known = Known2.trunc(Width).sext(BitWidth);
+        break;
+      }
+
       case Intrinsic::abs: {
         computeKnownBits(I->getOperand(0), DemandedElts, Known2, Depth + 1, Q);
         bool IntMinIsPoison = match(II->getArgOperand(1), m_One());
@@ -3185,6 +3209,8 @@ static bool isKnownNonZeroFromOperator(const Operator *I,
         return true;
       case Intrinsic::experimental_get_vector_length:
         return isKnownNonZero(I->getOperand(0), Q, Depth);
+      case Intrinsic::evm_signextend:
+        return isKnownNonZero(II->getArgOperand(1), DemandedElts, Q, Depth);
       default:
         break;
       }

llvm/lib/Target/EVM/EVMTargetTransformInfo.cpp

@@ -19,6 +19,34 @@ using namespace llvm::PatternMatch;
 
 #define DEBUG_TYPE "evmtti"
 
+static std::optional<Instruction *> foldSignExtendToConst(InstCombiner &IC,
+                                                          IntrinsicInst &II) {
+  constexpr unsigned BitWidth = 256;
+  if (!II.getType()->isIntegerTy(BitWidth))
+    return std::nullopt;
+
+  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;
+
+  // Compute known bits of the input.
+  KnownBits Known(BitWidth);
+  IC.computeKnownBits(II.getArgOperand(1), Known, 0, &II);
+
+  unsigned Width = (ByteIdx + 1) * 8;
+  APInt LowMask = APInt::getLowBitsSet(BitWidth, Width);
+  if (((Known.Zero | Known.One) & LowMask) == LowMask) {
+    APInt Folded = (Known.One & LowMask).trunc(Width).sext(BitWidth);
+    return IC.replaceInstUsesWith(II, ConstantInt::get(II.getType(), Folded));
+  }
+  return std::nullopt;
+}
+
 static std::optional<Instruction *> instCombineSignExtend(InstCombiner &IC,
                                                           IntrinsicInst &II) {
   // Fold signextend(b, signextend(b, x)) -> signextend(b, x)
@@ -28,7 +56,7 @@ static std::optional<Instruction *> instCombineSignExtend(InstCombiner &IC,
                                      m_Deferred(B), m_Value(X)))))
     return IC.replaceInstUsesWith(II, II.getArgOperand(1));
 
-  return std::nullopt;
+  return foldSignExtendToConst(IC, II);
 }
 
 std::optional<Instruction *>