Rename to llvm.experimental.memset.pattern

Author: asb

llvm/docs/LangRef.rst

@@ -15434,28 +15434,29 @@ 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_memset_pattern:
+.. _int_experimental_memset_pattern:
 
-'``llvm.memset.pattern``' Intrinsic
+'``llvm.experimental.memset.pattern``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
-This is an overloaded intrinsic. You can use ``llvm.memset.pattern`` on
-any integer bit width that is an integral number of bytes and for different
-address spaces. Not all targets support all bit widths however.
+This is an overloaded intrinsic. You can use
+``llvm.experimental.memset.pattern`` on any integer bit width that is an
+integral number of bytes and for different address spaces. Not all targets
+support all bit widths however.
 
 ::
 
-      declare void @llvm.memset.pattern.p0.i128.i64(ptr <dest>, i128 <val>,
-                                                    i64 <count>, i1 <isvolatile>)
+      declare void @llvm.experimental.memset.pattern.p0.i128.i64(ptr <dest>, i128 <val>,
+                                                                 i64 <count>, i1 <isvolatile>)
 
 Overview:
 """""""""
 
-The '``llvm.memset.pattern.*``' intrinsics fill a block of memory with
-a particular value. This may be expanded to an inline loop, a sequence of
+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.
 
@@ -15471,21 +15472,21 @@ The :ref:`align <attr_align>` parameter attribute can be provided
 for the first argument.
 
 If the ``isvolatile`` parameter is ``true``, the
-``llvm.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.
+``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.memset.pattern*``' intrinsic fills memory starting at the
-destination location with the given pattern ``<count>`` times. If the argument
-is known to be aligned to some boundary, this can be specified as an attribute
-on the argument. The pattern fills will respect the endianness of the target:
-i.e. on little endian targets, the least significant byte of the pattern is
-first in memory, while the most significant byte is first in memory for big
-endian targets. The memory address is incremented by the allocation size of
-the type.
+The '``llvm.experimental.memset.pattern*``' intrinsic fills memory starting at
+the destination location with the given pattern ``<count>`` times. If the
+argument is known to be aligned to some boundary, this can be specified as an
+attribute on the argument. The pattern fills will respect the endianness of
+the target: i.e. on little endian targets, the least significant byte of the
+pattern is first in memory, while the most significant byte is first in memory
+for big endian targets. The memory address is incremented by the allocation
+size of the type.
 
 If ``<count>`` is 0, it is no-op modulo the behavior of attributes attached to
 the arguments.

llvm/include/llvm/IR/InstVisitor.h

@@ -296,7 +296,7 @@ class InstVisitor {
       case Intrinsic::memset:      DELEGATE(MemSetInst);
       case Intrinsic::memset_inline:
         DELEGATE(MemSetInlineInst);
-      case Intrinsic::memset_pattern:
+      case Intrinsic::experimental_memset_pattern:
         DELEGATE(MemSetPatternInst);
       case Intrinsic::vastart:     DELEGATE(VAStartInst);
       case Intrinsic::vaend:       DELEGATE(VAEndInst);

llvm/include/llvm/IR/IntrinsicInst.h

@@ -1222,7 +1222,7 @@ class MemIntrinsic : public MemIntrinsicBase<MemIntrinsic> {
     case Intrinsic::memmove:
     case Intrinsic::memset:
     case Intrinsic::memset_inline:
-    case Intrinsic::memset_pattern:
+    case Intrinsic::experimental_memset_pattern:
     case Intrinsic::memcpy_inline:
       return true;
     default:
@@ -1235,15 +1235,15 @@ class MemIntrinsic : public MemIntrinsicBase<MemIntrinsic> {
 };
 
 /// This class wraps the llvm.memset, llvm.memset.inline, and
-/// llvm.memset.pattern intrinsics.
+/// llvm.experimental.memset.pattern intrinsics.
 class MemSetInst : public MemSetBase<MemIntrinsic> {
 public:
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const IntrinsicInst *I) {
     switch (I->getIntrinsicID()) {
     case Intrinsic::memset:
     case Intrinsic::memset_inline:
-    case Intrinsic::memset_pattern:
+    case Intrinsic::experimental_memset_pattern:
       return true;
     default:
       return false;
@@ -1266,12 +1266,12 @@ class MemSetInlineInst : public MemSetInst {
   }
 };
 
-/// This class wraps the llvm.memset.pattern intrinsic.
+/// This class wraps the llvm.experimental.memset.pattern intrinsic.
 class MemSetPatternInst : public MemSetInst {
 public:
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const IntrinsicInst *I) {
-    return I->getIntrinsicID() == Intrinsic::memset_pattern;
+    return I->getIntrinsicID() == Intrinsic::experimental_memset_pattern;
   }
   static bool classof(const Value *V) {
     return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
@@ -1354,7 +1354,7 @@ class AnyMemIntrinsic : public MemIntrinsicBase<AnyMemIntrinsic> {
     case Intrinsic::memmove:
     case Intrinsic::memset:
     case Intrinsic::memset_inline:
-    case Intrinsic::memset_pattern:
+    case Intrinsic::experimental_memset_pattern:
     case Intrinsic::memcpy_element_unordered_atomic:
     case Intrinsic::memmove_element_unordered_atomic:
     case Intrinsic::memset_element_unordered_atomic:
@@ -1377,7 +1377,7 @@ class AnyMemSetInst : public MemSetBase<AnyMemIntrinsic> {
     switch (I->getIntrinsicID()) {
     case Intrinsic::memset:
     case Intrinsic::memset_inline:
-    case Intrinsic::memset_pattern:
+    case Intrinsic::experimental_memset_pattern:
     case Intrinsic::memset_element_unordered_atomic:
       return true;
     default:

llvm/include/llvm/IR/Intrinsics.td

@@ -1007,7 +1007,7 @@ def int_memset_inline
        ImmArg<ArgIndex<3>>]>;
 
 // Memset variant that writes a given pattern.
-def int_memset_pattern
+def int_experimental_memset_pattern
     : Intrinsic<[],
       [llvm_anyptr_ty, // Destination.
        llvm_anyint_ty, // Pattern value.

llvm/lib/CodeGen/PreISelIntrinsicLowering.cpp

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

llvm/lib/IR/Verifier.cpp

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

llvm/test/CodeGen/RISCV/memset-pattern.ll

@@ -47,7 +47,7 @@ define void @memset_1(ptr %a, i128 %value) nounwind {
 ; RV64-BOTH-NEXT:    bne a0, a3, .LBB0_1
 ; RV64-BOTH-NEXT:  # %bb.2: # %split
 ; RV64-BOTH-NEXT:    ret
-  tail call void @llvm.memset.pattern(ptr align 8 %a, i128 %value, i64 1, i1 0)
+  tail call void @llvm.experimental.memset.pattern(ptr align 8 %a, i128 %value, i64 1, i1 0)
   ret void
 }
 
@@ -197,7 +197,7 @@ define void @memset_1_noalign(ptr %a, i128 %value) nounwind {
 ; RV64-FAST-NEXT:    bne a0, a3, .LBB1_1
 ; RV64-FAST-NEXT:  # %bb.2: # %split
 ; RV64-FAST-NEXT:    ret
-  tail call void @llvm.memset.pattern(ptr %a, i128 %value, i64 1, i1 0)
+  tail call void @llvm.experimental.memset.pattern(ptr %a, i128 %value, i64 1, i1 0)
   ret void
 }
 
@@ -239,7 +239,7 @@ define void @memset_4(ptr %a, i128 %value) nounwind {
 ; RV64-BOTH-NEXT:    bne a0, a3, .LBB2_1
 ; RV64-BOTH-NEXT:  # %bb.2: # %split
 ; RV64-BOTH-NEXT:    ret
-  tail call void @llvm.memset.pattern(ptr align 8 %a, i128 %value, i64 4, i1 0)
+  tail call void @llvm.experimental.memset.pattern(ptr align 8 %a, i128 %value, i64 4, i1 0)
   ret void
 }
 
@@ -292,6 +292,6 @@ define void @memset_x(ptr %a, i128 %value, i64 %x) nounwind {
 ; RV64-BOTH-NEXT:    bltu a4, a3, .LBB3_2
 ; RV64-BOTH-NEXT:  .LBB3_3: # %split
 ; RV64-BOTH-NEXT:    ret
-  tail call void @llvm.memset.pattern(ptr align 8 %a, i128 %value, i64 %x, i1 0)
+  tail call void @llvm.experimental.memset.pattern(ptr align 8 %a, i128 %value, i64 %x, i1 0)
   ret void
 }

llvm/test/Transforms/PreISelIntrinsicLowering/PowerPC/memset-pattern.ll

@@ -19,6 +19,6 @@ define void @memset.pattern(ptr %a, i128 %value, i64 %x) nounwind {
 ; CHECK:       [[SPLIT]]:
 ; CHECK-NEXT:    ret void
 ;
-  tail call void @llvm.memset.pattern(ptr %a, i128 %value, i64 %x, i1 0)
+  tail call void @llvm.experimental.memset.pattern(ptr %a, i128 %value, i64 %x, i1 0)
   ret void
 }

llvm/test/Transforms/PreISelIntrinsicLowering/RISCV/memset-pattern.ll

@@ -15,7 +15,7 @@ define void @memset_pattern_i128_1(ptr %a, i128 %value) nounwind {
 ; CHECK:       [[SPLIT]]:
 ; CHECK-NEXT:    ret void
 ;
-  tail call void @llvm.memset.pattern(ptr %a, i128 %value, i64 1, i1 0)
+  tail call void @llvm.experimental.memset.pattern(ptr %a, i128 %value, i64 1, i1 0)
   ret void
 }
 
@@ -33,7 +33,7 @@ define void @memset_pattern_i128_16(ptr %a, i128 %value) nounwind {
 ; CHECK:       [[SPLIT]]:
 ; CHECK-NEXT:    ret void
 ;
-  tail call void @llvm.memset.pattern(ptr %a, i128 %value, i64 16, i1 0)
+  tail call void @llvm.experimental.memset.pattern(ptr %a, i128 %value, i64 16, i1 0)
   ret void
 }
 
@@ -52,7 +52,7 @@ define void @memset_pattern_i127_x(ptr %a, i127 %value, i64 %x) nounwind {
 ; CHECK:       [[SPLIT]]:
 ; CHECK-NEXT:    ret void
 ;
-  tail call void @llvm.memset.pattern(ptr %a, i127 %value, i64 %x, i1 0)
+  tail call void @llvm.experimental.memset.pattern(ptr %a, i127 %value, i64 %x, i1 0)
   ret void
 }
 
@@ -71,7 +71,7 @@ define void @memset_pattern_i128_x(ptr %a, i128 %value, i64 %x) nounwind {
 ; CHECK:       [[SPLIT]]:
 ; CHECK-NEXT:    ret void
 ;
-  tail call void @llvm.memset.pattern(ptr %a, i128 %value, i64 %x, i1 0)
+  tail call void @llvm.experimental.memset.pattern(ptr %a, i128 %value, i64 %x, i1 0)
   ret void
 }
 
@@ -90,7 +90,7 @@ define void @memset_pattern_i256_x(ptr %a, i256 %value, i64 %x) nounwind {
 ; CHECK:       [[SPLIT]]:
 ; CHECK-NEXT:    ret void
 ;
-  tail call void @llvm.memset.pattern(ptr %a, i256 %value, i64 %x, i1 0)
+  tail call void @llvm.experimental.memset.pattern(ptr %a, i256 %value, i64 %x, i1 0)
   ret void
 }
 
@@ -121,7 +121,7 @@ define void @memset_pattern_i15_x_alignment(ptr %a, i15 %value, i64 %x) nounwind
 ; CHECK:       [[SPLIT1]]:
 ; CHECK-NEXT:    ret void
 ;
-  call void @llvm.memset.pattern(ptr align 1 %a, i15 %value, i64 %x, i1 0)
-  call void @llvm.memset.pattern(ptr align 2 %a, i15 %value, i64 %x, i1 0)
+  call void @llvm.experimental.memset.pattern(ptr align 1 %a, i15 %value, i64 %x, i1 0)
+  call void @llvm.experimental.memset.pattern(ptr align 2 %a, i15 %value, i64 %x, i1 0)
   ret void
 }

llvm/test/Verifier/intrinsic-immarg.ll

@@ -63,17 +63,15 @@ define void @memset_inline_is_volatile(ptr %dest, i8 %value, i1 %is.volatile) {
   ret void
 }
 
-
-declare void @llvm.memset.pattern.p0.i32.i32(ptr nocapture, i32, i32, i1)
+declare void @llvm.experimental.memset.pattern.p0.i32.i32(ptr nocapture, i32, i32, i1)
 define void @memset_pattern_is_volatile(ptr %dest, i32 %value, i1 %is.volatile) {
   ; CHECK: immarg operand has non-immediate parameter
   ; CHECK-NEXT: i1 %is.volatile
-  ; CHECK-NEXT: call void @llvm.memset.pattern.p0.i32.i32(ptr %dest, i32 %value, i32 8, i1 %is.volatile)
-  call void @llvm.memset.pattern.p0.i32.i32(ptr %dest, i32 %value, i32 8, i1 %is.volatile)
+  ; CHECK-NEXT: call void @llvm.experimental.memset.pattern.p0.i32.i32(ptr %dest, i32 %value, i32 8, i1 %is.volatile)
+  call void @llvm.experimental.memset.pattern.p0.i32.i32(ptr %dest, i32 %value, i32 8, i1 %is.volatile)
   ret void
 }
 
-
 declare i64 @llvm.objectsize.i64.p0(ptr, i1, i1, i1)
 define void @objectsize(ptr %ptr, i1 %a, i1 %b, i1 %c) {
   ; CHECK: immarg operand has non-immediate parameter