Revert "[IR] Initial introduction of llvm.experimental.memset_pattern (#97583)"

This reverts commit 7ff3a9a.

Recent scheduling changes means tests need to be re-generated. Reverting
to green while I do that.

Author: asb

llvm/docs/LangRef.rst

@@ -15430,63 +15430,6 @@ The behavior of '``llvm.memset.inline.*``' is equivalent to the behavior of
 '``llvm.memset.*``', but the generated code is guaranteed not to call any
 external functions.
 
-.. _int_experimental_memset_pattern:
-
-'``llvm.experimental.memset.pattern``' Intrinsic
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Syntax:
-"""""""
-
-This is an overloaded intrinsic. You can use
-``llvm.experimental.memset.pattern`` on any integer bit width and for
-different address spaces. Not all targets support all bit widths however.
-
-::
-
-      declare void @llvm.experimental.memset.pattern.p0.i128.i64(ptr <dest>, i128 <val>,
-                                                                 i64 <count>, i1 <isvolatile>)
-
-Overview:
-"""""""""
-
-The '``llvm.experimental.memset.pattern.*``' intrinsics fill a block of memory
-with a particular value. This may be expanded to an inline loop, a sequence of
-stores, or a libcall depending on what is available for the target and the
-expected performance and code size impact.
-
-Arguments:
-""""""""""
-
-The first argument is a pointer to the destination to fill, the second
-is the value with which to fill it, the third argument is an integer
-argument specifying the number of times to fill the value, and the fourth is a
-boolean indicating a volatile access.
-
-The :ref:`align <attr_align>` parameter attribute can be provided
-for the first argument.
-
-If the ``isvolatile`` parameter is ``true``, the
-``llvm.experimental.memset.pattern`` call is a :ref:`volatile operation
-<volatile>`. The detailed access behavior is not very cleanly specified and it
-is unwise to depend on it.
-
-Semantics:
-""""""""""
-
-The '``llvm.experimental.memset.pattern*``' intrinsic fills memory starting at
-the destination location with the given pattern ``<count>`` times,
-incrementing by the allocation size of the type each time. The stores follow
-the usual semantics of store instructions, including regarding endianness and
-padding. If the argument is known to be aligned to some boundary, this can be
-specified as an attribute on the argument.
-
-If ``<count>`` is 0, it is no-op modulo the behavior of attributes attached to
-the arguments.
-If ``<count>`` is not a well-defined value, the behavior is undefined.
-If ``<count>`` is not zero, ``<dest>`` should be well-defined, otherwise the
-behavior is undefined.
-
 .. _int_sqrt:
 
 '``llvm.sqrt.*``' Intrinsic

llvm/include/llvm/IR/InstVisitor.h

@@ -208,9 +208,6 @@ class InstVisitor {
   RetTy visitDbgInfoIntrinsic(DbgInfoIntrinsic &I){ DELEGATE(IntrinsicInst); }
   RetTy visitMemSetInst(MemSetInst &I)            { DELEGATE(MemIntrinsic); }
   RetTy visitMemSetInlineInst(MemSetInlineInst &I){ DELEGATE(MemSetInst); }
-  RetTy visitMemSetPatternInst(MemSetPatternInst &I) {
-    DELEGATE(IntrinsicInst);
-  }
   RetTy visitMemCpyInst(MemCpyInst &I)            { DELEGATE(MemTransferInst); }
   RetTy visitMemCpyInlineInst(MemCpyInlineInst &I){ DELEGATE(MemCpyInst); }
   RetTy visitMemMoveInst(MemMoveInst &I)          { DELEGATE(MemTransferInst); }
@@ -298,8 +295,6 @@ class InstVisitor {
       case Intrinsic::memset:      DELEGATE(MemSetInst);
       case Intrinsic::memset_inline:
         DELEGATE(MemSetInlineInst);
-      case Intrinsic::experimental_memset_pattern:
-        DELEGATE(MemSetPatternInst);
       case Intrinsic::vastart:     DELEGATE(VAStartInst);
       case Intrinsic::vaend:       DELEGATE(VAEndInst);
       case Intrinsic::vacopy:      DELEGATE(VACopyInst);

llvm/include/llvm/IR/IntrinsicInst.h

@@ -1263,41 +1263,6 @@ class MemSetInlineInst : public MemSetInst {
   }
 };
 
-/// This is the base class for llvm.experimental.memset.pattern
-class MemSetPatternIntrinsic : public MemIntrinsicBase<MemIntrinsic> {
-private:
-  enum { ARG_VOLATILE = 3 };
-
-public:
-  ConstantInt *getVolatileCst() const {
-    return cast<ConstantInt>(const_cast<Value *>(getArgOperand(ARG_VOLATILE)));
-  }
-
-  bool isVolatile() const { return !getVolatileCst()->isZero(); }
-
-  void setVolatile(Constant *V) { setArgOperand(ARG_VOLATILE, V); }
-
-  // Methods for support of type inquiry through isa, cast, and dyn_cast:
-  static bool classof(const IntrinsicInst *I) {
-    return I->getIntrinsicID() == Intrinsic::experimental_memset_pattern;
-  }
-  static bool classof(const Value *V) {
-    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-  }
-};
-
-/// This class wraps the llvm.experimental.memset.pattern intrinsic.
-class MemSetPatternInst : public MemSetBase<MemSetPatternIntrinsic> {
-public:
-  // Methods for support type inquiry through isa, cast, and dyn_cast:
-  static bool classof(const IntrinsicInst *I) {
-    return I->getIntrinsicID() == Intrinsic::experimental_memset_pattern;
-  }
-  static bool classof(const Value *V) {
-    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-  }
-};
-
 /// This class wraps the llvm.memcpy/memmove intrinsics.
 class MemTransferInst : public MemTransferBase<MemIntrinsic> {
 public:

llvm/include/llvm/IR/Intrinsics.td

@@ -1006,17 +1006,6 @@ def int_memset_inline
        NoCapture<ArgIndex<0>>, WriteOnly<ArgIndex<0>>,
        ImmArg<ArgIndex<3>>]>;
 
-// Memset variant that writes a given pattern.
-def int_experimental_memset_pattern
-    : Intrinsic<[],
-      [llvm_anyptr_ty, // Destination.
-       llvm_anyint_ty, // Pattern value.
-       llvm_anyint_ty, // Count (number of times to fill value).
-       llvm_i1_ty],    // IsVolatile.
-      [IntrWriteMem, IntrArgMemOnly, IntrWillReturn, IntrNoFree, IntrNoCallback,
-       NoCapture<ArgIndex<0>>, WriteOnly<ArgIndex<0>>,
-       ImmArg<ArgIndex<3>>]>;
-
 // FIXME: Add version of these floating point intrinsics which allow non-default
 // rounding modes and FP exception handling.
 

llvm/include/llvm/Transforms/Utils/LowerMemIntrinsics.h

@@ -25,7 +25,6 @@ class Instruction;
 class MemCpyInst;
 class MemMoveInst;
 class MemSetInst;
-class MemSetPatternInst;
 class ScalarEvolution;
 class TargetTransformInfo;
 class Value;
@@ -58,9 +57,6 @@ bool expandMemMoveAsLoop(MemMoveInst *MemMove, const TargetTransformInfo &TTI);
 /// Expand \p MemSet as a loop. \p MemSet is not deleted.
 void expandMemSetAsLoop(MemSetInst *MemSet);
 
-/// Expand \p MemSetPattern as a loop. \p MemSet is not deleted.
-void expandMemSetPatternAsLoop(MemSetPatternInst *MemSet);
-
 /// Expand \p AtomicMemCpy as a loop. \p AtomicMemCpy is not deleted.
 void expandAtomicMemCpyAsLoop(AtomicMemCpyInst *AtomicMemCpy,
                               const TargetTransformInfo &TTI,

llvm/lib/CodeGen/PreISelIntrinsicLowering.cpp

@@ -320,13 +320,6 @@ bool PreISelIntrinsicLowering::expandMemIntrinsicUses(Function &F) const {
       Memset->eraseFromParent();
       break;
     }
-    case Intrinsic::experimental_memset_pattern: {
-      auto *Memset = cast<MemSetPatternInst>(Inst);
-      expandMemSetPatternAsLoop(Memset);
-      Changed = true;
-      Memset->eraseFromParent();
-      break;
-    }
     default:
       llvm_unreachable("unhandled intrinsic");
     }
@@ -346,7 +339,6 @@ bool PreISelIntrinsicLowering::lowerIntrinsics(Module &M) const {
     case Intrinsic::memmove:
     case Intrinsic::memset:
     case Intrinsic::memset_inline:
-    case Intrinsic::experimental_memset_pattern:
       Changed |= expandMemIntrinsicUses(F);
       break;
     case Intrinsic::load_relative:

llvm/lib/IR/Verifier.cpp

@@ -5519,8 +5519,7 @@ void Verifier::visitIntrinsicCall(Intrinsic::ID ID, CallBase &Call) {
   case Intrinsic::memcpy_inline:
   case Intrinsic::memmove:
   case Intrinsic::memset:
-  case Intrinsic::memset_inline:
-  case Intrinsic::experimental_memset_pattern: {
+  case Intrinsic::memset_inline: {
     break;
   }
   case Intrinsic::memcpy_element_unordered_atomic:

llvm/lib/Transforms/Utils/LowerMemIntrinsics.cpp

@@ -970,15 +970,6 @@ void llvm::expandMemSetAsLoop(MemSetInst *Memset) {
                    Memset->isVolatile());
 }
 
-void llvm::expandMemSetPatternAsLoop(MemSetPatternInst *Memset) {
-  createMemSetLoop(/* InsertBefore=*/Memset,
-                   /* DstAddr=*/Memset->getRawDest(),
-                   /* CopyLen=*/Memset->getLength(),
-                   /* SetValue=*/Memset->getValue(),
-                   /* Alignment=*/Memset->getDestAlign().valueOrOne(),
-                   Memset->isVolatile());
-}
-
 void llvm::expandAtomicMemCpyAsLoop(AtomicMemCpyInst *AtomicMemcpy,
                                     const TargetTransformInfo &TTI,
                                     ScalarEvolution *SE) {