Remove alignment argument from memcpy/memmove/memset in favour of alignment attributes (Step 1)

Summary:
 This is a resurrection of work first proposed and discussed in Aug 2015:
   http://lists.llvm.org/pipermail/llvm-dev/2015-August/089384.html
and initially landed (but then backed out) in Nov 2015:
   http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20151109/312083.html

 The @llvm.memcpy/memmove/memset intrinsics currently have an explicit argument
which is required to be a constant integer. It represents the alignment of the
dest (and source), and so must be the minimum of the actual alignment of the
two.

 This change is the first in a series that allows source and dest to each
have their own alignments by using the alignment attribute on their arguments.

 In this change we:
1) Remove the alignment argument.
2) Add alignment attributes to the source & dest arguments. We, temporarily,
   require that the alignments for source & dest be equal.

 For example, code which used to read:
  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 100, i32 4, i1 false)
will now read
  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %dest, i8* align 4 %src, i32 100, i1 false)

 Downstream users may have to update their lit tests that check for
@llvm.memcpy/memmove/memset call/declaration patterns. The following extended sed script
may help with updating the majority of your tests, but it does not catch all possible
patterns so some manual checking and updating will be required.

s~declare void @llvm\.mem(set|cpy|move)\.p([^(]*)\((.*), i32, i1\)~declare void @llvm.mem\1.p\2(\3, i1)~g
s~call void @llvm\.memset\.p([^(]*)i8\(i8([^*]*)\* (.*), i8 (.*), i8 (.*), i32 [01], i1 ([^)]*)\)~call void @llvm.memset.p\1i8(i8\2* \3, i8 \4, i8 \5, i1 \6)~g
s~call void @llvm\.memset\.p([^(]*)i16\(i8([^*]*)\* (.*), i8 (.*), i16 (.*), i32 [01], i1 ([^)]*)\)~call void @llvm.memset.p\1i16(i8\2* \3, i8 \4, i16 \5, i1 \6)~g
s~call void @llvm\.memset\.p([^(]*)i32\(i8([^*]*)\* (.*), i8 (.*), i32 (.*), i32 [01], i1 ([^)]*)\)~call void @llvm.memset.p\1i32(i8\2* \3, i8 \4, i32 \5, i1 \6)~g
s~call void @llvm\.memset\.p([^(]*)i64\(i8([^*]*)\* (.*), i8 (.*), i64 (.*), i32 [01], i1 ([^)]*)\)~call void @llvm.memset.p\1i64(i8\2* \3, i8 \4, i64 \5, i1 \6)~g
s~call void @llvm\.memset\.p([^(]*)i128\(i8([^*]*)\* (.*), i8 (.*), i128 (.*), i32 [01], i1 ([^)]*)\)~call void @llvm.memset.p\1i128(i8\2* \3, i8 \4, i128 \5, i1 \6)~g
s~call void @llvm\.memset\.p([^(]*)i8\(i8([^*]*)\* (.*), i8 (.*), i8 (.*), i32 ([0-9]*), i1 ([^)]*)\)~call void @llvm.memset.p\1i8(i8\2* align \6 \3, i8 \4, i8 \5, i1 \7)~g
s~call void @llvm\.memset\.p([^(]*)i16\(i8([^*]*)\* (.*), i8 (.*), i16 (.*), i32 ([0-9]*), i1 ([^)]*)\)~call void @llvm.memset.p\1i16(i8\2* align \6 \3, i8 \4, i16 \5, i1 \7)~g
s~call void @llvm\.memset\.p([^(]*)i32\(i8([^*]*)\* (.*), i8 (.*), i32 (.*), i32 ([0-9]*), i1 ([^)]*)\)~call void @llvm.memset.p\1i32(i8\2* align \6 \3, i8 \4, i32 \5, i1 \7)~g
s~call void @llvm\.memset\.p([^(]*)i64\(i8([^*]*)\* (.*), i8 (.*), i64 (.*), i32 ([0-9]*), i1 ([^)]*)\)~call void @llvm.memset.p\1i64(i8\2* align \6 \3, i8 \4, i64 \5, i1 \7)~g
s~call void @llvm\.memset\.p([^(]*)i128\(i8([^*]*)\* (.*), i8 (.*), i128 (.*), i32 ([0-9]*), i1 ([^)]*)\)~call void @llvm.memset.p\1i128(i8\2* align \6 \3, i8 \4, i128 \5, i1 \7)~g
s~call void @llvm\.mem(cpy|move)\.p([^(]*)i8\(i8([^*]*)\* (.*), i8([^*]*)\* (.*), i8 (.*), i32 [01], i1 ([^)]*)\)~call void @llvm.mem\1.p\2i8(i8\3* \4, i8\5* \6, i8 \7, i1 \8)~g
s~call void @llvm\.mem(cpy|move)\.p([^(]*)i16\(i8([^*]*)\* (.*), i8([^*]*)\* (.*), i16 (.*), i32 [01], i1 ([^)]*)\)~call void @llvm.mem\1.p\2i16(i8\3* \4, i8\5* \6, i16 \7, i1 \8)~g
s~call void @llvm\.mem(cpy|move)\.p([^(]*)i32\(i8([^*]*)\* (.*), i8([^*]*)\* (.*), i32 (.*), i32 [01], i1 ([^)]*)\)~call void @llvm.mem\1.p\2i32(i8\3* \4, i8\5* \6, i32 \7, i1 \8)~g
s~call void @llvm\.mem(cpy|move)\.p([^(]*)i64\(i8([^*]*)\* (.*), i8([^*]*)\* (.*), i64 (.*), i32 [01], i1 ([^)]*)\)~call void @llvm.mem\1.p\2i64(i8\3* \4, i8\5* \6, i64 \7, i1 \8)~g
s~call void @llvm\.mem(cpy|move)\.p([^(]*)i128\(i8([^*]*)\* (.*), i8([^*]*)\* (.*), i128 (.*), i32 [01], i1 ([^)]*)\)~call void @llvm.mem\1.p\2i128(i8\3* \4, i8\5* \6, i128 \7, i1 \8)~g
s~call void @llvm\.mem(cpy|move)\.p([^(]*)i8\(i8([^*]*)\* (.*), i8([^*]*)\* (.*), i8 (.*), i32 ([0-9]*), i1 ([^)]*)\)~call void @llvm.mem\1.p\2i8(i8\3* align \8 \4, i8\5* align \8 \6, i8 \7, i1 \9)~g
s~call void @llvm\.mem(cpy|move)\.p([^(]*)i16\(i8([^*]*)\* (.*), i8([^*]*)\* (.*), i16 (.*), i32 ([0-9]*), i1 ([^)]*)\)~call void @llvm.mem\1.p\2i16(i8\3* align \8 \4, i8\5* align \8 \6, i16 \7, i1 \9)~g
s~call void @llvm\.mem(cpy|move)\.p([^(]*)i32\(i8([^*]*)\* (.*), i8([^*]*)\* (.*), i32 (.*), i32 ([0-9]*), i1 ([^)]*)\)~call void @llvm.mem\1.p\2i32(i8\3* align \8 \4, i8\5* align \8 \6, i32 \7, i1 \9)~g
s~call void @llvm\.mem(cpy|move)\.p([^(]*)i64\(i8([^*]*)\* (.*), i8([^*]*)\* (.*), i64 (.*), i32 ([0-9]*), i1 ([^)]*)\)~call void @llvm.mem\1.p\2i64(i8\3* align \8 \4, i8\5* align \8 \6, i64 \7, i1 \9)~g
s~call void @llvm\.mem(cpy|move)\.p([^(]*)i128\(i8([^*]*)\* (.*), i8([^*]*)\* (.*), i128 (.*), i32 ([0-9]*), i1 ([^)]*)\)~call void @llvm.mem\1.p\2i128(i8\3* align \8 \4, i8\5* align \8 \6, i128 \7, i1 \9)~g

 The remaining changes in the series will:
Step 2) Expand the IRBuilder API to allow creation of memcpy/memmove with differing
   source and dest alignments.
Step 3) Update Clang to use the new IRBuilder API.
Step 4) Update Polly to use the new IRBuilder API.
Step 5) Update LLVM passes that create memcpy/memmove calls to use the new IRBuilder API,
        and those that use use MemIntrinsicInst::[get|set]Alignment() to use
        getDestAlignment() and getSourceAlignment() instead.
Step 6) Remove the single-alignment IRBuilder API for memcpy/memmove, and the
        MemIntrinsicInst::[get|set]Alignment() methods.

Reviewers: pete, hfinkel, lhames, reames, bollu

Reviewed By: reames

Subscribers: niosHD, reames, jholewinski, qcolombet, jfb, sanjoy, arsenm, dschuff, dylanmckay, mehdi_amini, sdardis, nemanjai, david2050, nhaehnle, javed.absar, sbc100, jgravelle-google, eraman, aheejin, kbarton, JDevlieghere, asb, rbar, johnrusso, simoncook, jordy.potman.lists, apazos, sabuasal, llvm-commits

Differential Revision: https://reviews.llvm.org/D41675

llvm-svn: 322965

9 files changed, 282 insertions, 300 deletions

diff --git a/llvm/test/CodeGen/SystemZ/dag-combine-02.ll b/llvm/test/CodeGen/SystemZ/dag-combine-02.ll
index 2d96aafb938..c73b49029e8 100644
--- a/llvm/test/CodeGen/SystemZ/dag-combine-02.ll
+++ b/llvm/test/CodeGen/SystemZ/dag-combine-02.ll
@@ -18,7 +18,7 @@
 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #0
 
 ; Function Attrs: argmemonly nounwind
-declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32, i1) #0
+declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1) #0
 
 ; Function Attrs: argmemonly nounwind
 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #0
@@ -100,7 +100,7 @@ define signext i32 @main(i32 signext, i8** nocapture readonly) local_unnamed_add
   store i64 0, i64* @g_56, align 8
   %62 = bitcast [4 x [7 x i16*]]* %3 to i8*
   call void @llvm.lifetime.start.p0i8(i64 224, i8* nonnull %62) #5
-  call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull %62, i8* bitcast ([4 x [7 x i16*]]* @func_22.l_91 to i8*), i64 224, i32 8, i1 false) #5
+  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 nonnull %62, i8* align 8 bitcast ([4 x [7 x i16*]]* @func_22.l_91 to i8*), i64 224, i1 false) #5
   %63 = getelementptr inbounds [4 x [7 x i16*]], [4 x [7 x i16*]]* %3, i64 0, i64 0, i64 2
   store i16** %63, i16*** @g_102, align 8
   %64 = load i64, i64* @g_56, align 8
diff --git a/llvm/test/CodeGen/SystemZ/loop-01.ll b/llvm/test/CodeGen/SystemZ/loop-01.ll
index 79afc7f4198..262cda9f6d1 100644
--- a/llvm/test/CodeGen/SystemZ/loop-01.ll
+++ b/llvm/test/CodeGen/SystemZ/loop-01.ll
@@ -246,7 +246,7 @@ for.body:                           ; preds = %for.body.preheader, %for.body
 %2 = type <{ %3, i32, [4 x i8] }>
 %3 = type { i16*, i16*, i16* }
 
-declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32, i1) #0
+declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1) #0
 
 define void @f8() {
 ; CHECK-Z13-LABEL: f8:
@@ -274,22 +274,22 @@ bb5:                                              ; preds = %bb5, %bb2
   %tmp9 = getelementptr inbounds %0, %0* %tmp6, i64 -1
   %tmp10 = bitcast %0* %tmp9 to i8*
   %tmp11 = bitcast %0* %tmp8 to i8*
-  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %tmp10, i8* %tmp11, i64 24, i32 8, i1 false)
+  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %tmp10, i8* align 8 %tmp11, i64 24, i1 false)
   %tmp12 = getelementptr inbounds %0, %0* %tmp7, i64 -2
   %tmp13 = getelementptr inbounds %0, %0* %tmp6, i64 -2
   %tmp14 = bitcast %0* %tmp13 to i8*
   %tmp15 = bitcast %0* %tmp12 to i8*
-  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %tmp14, i8* %tmp15, i64 24, i32 8, i1 false)
+  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %tmp14, i8* align 8 %tmp15, i64 24, i1 false)
   %tmp16 = getelementptr inbounds %0, %0* %tmp7, i64 -3
   %tmp17 = getelementptr inbounds %0, %0* %tmp6, i64 -3
   %tmp18 = bitcast %0* %tmp17 to i8*
   %tmp19 = bitcast %0* %tmp16 to i8*
-  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %tmp18, i8* %tmp19, i64 24, i32 8, i1 false)
+  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %tmp18, i8* align 8 %tmp19, i64 24, i1 false)
   %tmp20 = getelementptr inbounds %0, %0* %tmp7, i64 -4
   %tmp21 = getelementptr inbounds %0, %0* %tmp6, i64 -4
   %tmp22 = bitcast %0* %tmp21 to i8*
   %tmp23 = bitcast %0* %tmp20 to i8*
-  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %tmp22, i8* %tmp23, i64 24, i32 8, i1 false)
+  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %tmp22, i8* align 8 %tmp23, i64 24, i1 false)
   br label %bb5
 }
 
diff --git a/llvm/test/CodeGen/SystemZ/loop-03.ll b/llvm/test/CodeGen/SystemZ/loop-03.ll
index 79bd23e6274..7ba7165cdff 100644
--- a/llvm/test/CodeGen/SystemZ/loop-03.ll
+++ b/llvm/test/CodeGen/SystemZ/loop-03.ll
@@ -15,7 +15,7 @@
 %7 = type { i64, i64, %8** }
 %8 = type { i64, i64*, i64*, %4*, i64, i32*, %5, i32, i64, i64 }
 
-declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32, i1)
+declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1)
 
 define void @fun0(%0*) {
 ; CHECK-LABEL: .LBB0_4
@@ -72,7 +72,7 @@ define void @fun0(%0*) {
 
 ; <label>:24:                                     ; preds = %24, %14
   %25 = phi i64 [ %23, %14 ], [ %27, %24 ]
-  call void @llvm.memcpy.p0i8.p0i8.i64(i8* undef, i8* nonnull undef, i64 %4, i32 1, i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i64(i8* undef, i8* nonnull undef, i64 %4, i1 false)
   %26 = getelementptr inbounds i8, i8* null, i64 %4
   store i8* %26, i8** undef, align 8
   %27 = add i64 %25, -4
@@ -83,7 +83,7 @@ define void @fun0(%0*) {
   br i1 undef, label %31, label %30
 
 ; <label>:30:                                     ; preds = %29
-  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %26, i8* nonnull undef, i64 %4, i32 1, i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %26, i8* nonnull undef, i64 %4, i1 false)
   br label %31
 
 ; <label>:31:                                     ; preds = %30, %29
diff --git a/llvm/test/CodeGen/SystemZ/memcpy-01.ll b/llvm/test/CodeGen/SystemZ/memcpy-01.ll
index 1d7b28e940b..ee4e71b53ce 100644
--- a/llvm/test/CodeGen/SystemZ/memcpy-01.ll
+++ b/llvm/test/CodeGen/SystemZ/memcpy-01.ll
@@ -2,107 +2,98 @@
 ;
 ; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s
 
-declare void @llvm.memcpy.p0i8.p0i8.i32(i8 *nocapture, i8 *nocapture, i32, i32, i1) nounwind
-declare void @llvm.memcpy.p0i8.p0i8.i64(i8 *nocapture, i8 *nocapture, i64, i32, i1) nounwind
+declare void @llvm.memcpy.p0i8.p0i8.i32(i8 *nocapture, i8 *nocapture, i32, i1) nounwind
+declare void @llvm.memcpy.p0i8.p0i8.i64(i8 *nocapture, i8 *nocapture, i64, i1) nounwind
 declare void @foo(i8 *, i8 *)
 
 ; Test a no-op move, i32 version.
-define void @f1(i8 *%dest, i8 *%src) {
+define void @f1(i8* %dest, i8* %src) {
 ; CHECK-LABEL: f1:
 ; CHECK-NOT: %r2
 ; CHECK-NOT: %r3
 ; CHECK: br %r14
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8 *%dest, i8 *%src, i32 0, i32 1,
-                                       i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 0, i1 false)
   ret void
 }
 
 ; Test a no-op move, i64 version.
-define void @f2(i8 *%dest, i8 *%src) {
+define void @f2(i8* %dest, i8* %src) {
 ; CHECK-LABEL: f2:
 ; CHECK-NOT: %r2
 ; CHECK-NOT: %r3
 ; CHECK: br %r14
-  call void @llvm.memcpy.p0i8.p0i8.i64(i8 *%dest, i8 *%src, i64 0, i32 1,
-                                       i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 0, i1 false)
   ret void
 }
 
 ; Test a 1-byte move, i32 version.
-define void @f3(i8 *%dest, i8 *%src) {
+define void @f3(i8* %dest, i8* %src) {
 ; CHECK-LABEL: f3:
 ; CHECK: mvc 0(1,%r2), 0(%r3)
 ; CHECK: br %r14
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8 *%dest, i8 *%src, i32 1, i32 1,
-                                       i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 1, i1 false)
   ret void
 }
 
 ; Test a 1-byte move, i64 version.
-define void @f4(i8 *%dest, i8 *%src) {
+define void @f4(i8* %dest, i8* %src) {
 ; CHECK-LABEL: f4:
 ; CHECK: mvc 0(1,%r2), 0(%r3)
 ; CHECK: br %r14
-  call void @llvm.memcpy.p0i8.p0i8.i64(i8 *%dest, i8 *%src, i64 1, i32 1,
-                                       i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 1, i1 false)
   ret void
 }
 
 ; Test the upper range of a single MVC, i32 version.
-define void @f5(i8 *%dest, i8 *%src) {
+define void @f5(i8* %dest, i8* %src) {
 ; CHECK-LABEL: f5:
 ; CHECK: mvc 0(256,%r2), 0(%r3)
 ; CHECK: br %r14
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8 *%dest, i8 *%src, i32 256, i32 1,
-                                       i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 256, i1 false)
   ret void
 }
 
 ; Test the upper range of a single MVC, i64 version.
-define void @f6(i8 *%dest, i8 *%src) {
+define void @f6(i8* %dest, i8* %src) {
 ; CHECK-LABEL: f6:
 ; CHECK: mvc 0(256,%r2), 0(%r3)
 ; CHECK: br %r14
-  call void @llvm.memcpy.p0i8.p0i8.i64(i8 *%dest, i8 *%src, i64 256, i32 1,
-                                       i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 256, i1 false)
   ret void
 }
 
 ; Test the first case that needs two MVCs.
-define void @f7(i8 *%dest, i8 *%src) {
+define void @f7(i8* %dest, i8* %src) {
 ; CHECK-LABEL: f7:
 ; CHECK: mvc 0(256,%r2), 0(%r3)
 ; CHECK: mvc 256(1,%r2), 256(%r3)
 ; CHECK: br %r14
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8 *%dest, i8 *%src, i32 257, i32 1,
-                                       i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 257, i1 false)
   ret void
 }
 
 ; Test the last-but-one case that needs two MVCs.
-define void @f8(i8 *%dest, i8 *%src) {
+define void @f8(i8* %dest, i8* %src) {
 ; CHECK-LABEL: f8:
 ; CHECK: mvc 0(256,%r2), 0(%r3)
 ; CHECK: mvc 256(255,%r2), 256(%r3)
 ; CHECK: br %r14
-  call void @llvm.memcpy.p0i8.p0i8.i64(i8 *%dest, i8 *%src, i64 511, i32 1,
-                                       i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 511, i1 false)
   ret void
 }
 
 ; Test the last case that needs two MVCs.
-define void @f9(i8 *%dest, i8 *%src) {
+define void @f9(i8* %dest, i8* %src) {
 ; CHECK-LABEL: f9:
 ; CHECK: mvc 0(256,%r2), 0(%r3)
 ; CHECK: mvc 256(256,%r2), 256(%r3)
 ; CHECK: br %r14
-  call void @llvm.memcpy.p0i8.p0i8.i64(i8 *%dest, i8 *%src, i64 512, i32 1,
-                                       i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 512, i1 false)
   ret void
 }
 
 ; Test an arbitrary value that uses straight-line code.
-define void @f10(i8 *%dest, i8 *%src) {
+define void @f10(i8* %dest, i8* %src) {
 ; CHECK-LABEL: f10:
 ; CHECK: mvc 0(256,%r2), 0(%r3)
 ; CHECK: mvc 256(256,%r2), 256(%r3)
@@ -110,13 +101,12 @@ define void @f10(i8 *%dest, i8 *%src) {
 ; CHECK: mvc 768(256,%r2), 768(%r3)
 ; CHECK: mvc 1024(255,%r2), 1024(%r3)
 ; CHECK: br %r14
-  call void @llvm.memcpy.p0i8.p0i8.i64(i8 *%dest, i8 *%src, i64 1279, i32 1,
-                                       i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 1279, i1 false)
   ret void
 }
 
 ; ...and again in cases where not all parts are in range of MVC.
-define void @f11(i8 *%srcbase, i8 *%destbase) {
+define void @f11(i8* %srcbase, i8* %destbase) {
 ; CHECK-LABEL: f11:
 ; CHECK: mvc 4000(256,%r2), 3500(%r3)
 ; CHECK: lay [[NEWDEST:%r[1-5]]], 4256(%r2)
@@ -126,10 +116,9 @@ define void @f11(i8 *%srcbase, i8 *%destbase) {
 ; CHECK: mvc 512(256,[[NEWDEST]]), 0([[NEWSRC]])
 ; CHECK: mvc 768(255,[[NEWDEST]]), 256([[NEWSRC]])
 ; CHECK: br %r14
-  %dest = getelementptr i8, i8 *%srcbase, i64 4000
+  %dest = getelementptr i8, i8* %srcbase, i64 4000
   %src = getelementptr i8, i8* %destbase, i64 3500
-  call void @llvm.memcpy.p0i8.p0i8.i64(i8 *%dest, i8 *%src, i64 1279, i32 1,
-                                       i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 1279, i1 false)
   ret void
 }
 
@@ -148,10 +137,9 @@ define void @f12() {
   %arr = alloca [6000 x i8]
   %dest = getelementptr [6000 x i8], [6000 x i8] *%arr, i64 0, i64 3900
   %src = getelementptr [6000 x i8], [6000 x i8] *%arr, i64 0, i64 1924
-  call void @foo(i8 *%dest, i8 *%src)
-  call void @llvm.memcpy.p0i8.p0i8.i64(i8 *%dest, i8 *%src, i64 1279, i32 1,
-                                       i1 false)
-  call void @foo(i8 *%dest, i8 *%src)
+  call void @foo(i8* %dest, i8* %src)
+  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 1279, i1 false)
+  call void @foo(i8* %dest, i8* %src)
   ret void
 }
 
@@ -170,15 +158,14 @@ define void @f13() {
   %arr = alloca [6000 x i8]
   %dest = getelementptr [6000 x i8], [6000 x i8] *%arr, i64 0, i64 24
   %src = getelementptr [6000 x i8], [6000 x i8] *%arr, i64 0, i64 3650
-  call void @foo(i8 *%dest, i8 *%src)
-  call void @llvm.memcpy.p0i8.p0i8.i64(i8 *%dest, i8 *%src, i64 1279, i32 1,
-                                       i1 false)
-  call void @foo(i8 *%dest, i8 *%src)
+  call void @foo(i8* %dest, i8* %src)
+  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 1279, i1 false)
+  call void @foo(i8* %dest, i8* %src)
   ret void
 }
 
 ; Test the last case that is done using straight-line code.
-define void @f14(i8 *%dest, i8 *%src) {
+define void @f14(i8* %dest, i8* %src) {
 ; CHECK-LABEL: f14:
 ; CHECK: mvc 0(256,%r2), 0(%r3)
 ; CHECK: mvc 256(256,%r2), 256(%r3)
@@ -187,13 +174,12 @@ define void @f14(i8 *%dest, i8 *%src) {
 ; CHECK: mvc 1024(256,%r2), 1024(%r3)
 ; CHECK: mvc 1280(256,%r2), 1280(%r3)
 ; CHECK: br %r14
-  call void @llvm.memcpy.p0i8.p0i8.i64(i8 *%dest, i8 *%src, i64 1536, i32 1,
-                                       i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 1536, i1 false)
   ret void
 }
 
 ; Test the first case that is done using a loop.
-define void @f15(i8 *%dest, i8 *%src) {
+define void @f15(i8* %dest, i8* %src) {
 ; CHECK-LABEL: f15:
 ; CHECK: lghi [[COUNT:%r[0-5]]], 6
 ; CHECK: [[LABEL:\.L[^:]*]]:
@@ -204,8 +190,7 @@ define void @f15(i8 *%dest, i8 *%src) {
 ; CHECK: brctg [[COUNT]], [[LABEL]]
 ; CHECK: mvc 0(1,%r2), 0(%r3)
 ; CHECK: br %r14
-  call void @llvm.memcpy.p0i8.p0i8.i64(i8 *%dest, i8 *%src, i64 1537, i32 1,
-                                       i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 1537, i1 false)
   ret void
 }
 
@@ -227,9 +212,8 @@ define void @f16() {
   %arr = alloca [3200 x i8]
   %dest = getelementptr [3200 x i8], [3200 x i8] *%arr, i64 0, i64 1600
   %src = getelementptr [3200 x i8], [3200 x i8] *%arr, i64 0, i64 0
-  call void @foo(i8 *%dest, i8 *%src)
-  call void @llvm.memcpy.p0i8.p0i8.i64(i8 *%dest, i8 *%src, i64 1537, i32 1,
-                                       i1 false)
-  call void @foo(i8 *%dest, i8 *%src)
+  call void @foo(i8* %dest, i8* %src)
+  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 1537, i1 false)
+  call void @foo(i8* %dest, i8* %src)
   ret void
 }
diff --git a/llvm/test/CodeGen/SystemZ/memset-01.ll b/llvm/test/CodeGen/SystemZ/memset-01.ll
index f17901cc73a..73b3ffa5b4a 100644
--- a/llvm/test/CodeGen/SystemZ/memset-01.ll
+++ b/llvm/test/CodeGen/SystemZ/memset-01.ll
@@ -2,131 +2,131 @@
 ;
 ; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s
 
-declare void @llvm.memset.p0i8.i32(i8 *nocapture, i8, i32, i32, i1) nounwind
-declare void @llvm.memset.p0i8.i64(i8 *nocapture, i8, i64, i32, i1) nounwind
+declare void @llvm.memset.p0i8.i32(i8 *nocapture, i8, i32, i1) nounwind
+declare void @llvm.memset.p0i8.i64(i8 *nocapture, i8, i64, i1) nounwind
 
 ; No bytes, i32 version.
-define void @f1(i8 *%dest, i8 %val) {
+define void @f1(i8* %dest, i8 %val) {
 ; CHECK-LABEL: f1:
 ; CHECK-NOT: %r2
 ; CHECK-NOT: %r3
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 %val, i32 0, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 %val, i32 0, i1 false)
   ret void
 }
 
 ; No bytes, i64 version.
-define void @f2(i8 *%dest, i8 %val) {
+define void @f2(i8* %dest, i8 %val) {
 ; CHECK-LABEL: f2:
 ; CHECK-NOT: %r2
 ; CHECK-NOT: %r3
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 %val, i64 0, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 %val, i64 0, i1 false)
   ret void
 }
 
 ; 1 byte, i32 version.
-define void @f3(i8 *%dest, i8 %val) {
+define void @f3(i8* %dest, i8 %val) {
 ; CHECK-LABEL: f3:
 ; CHECK: stc %r3, 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 %val, i32 1, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 %val, i32 1, i1 false)
   ret void
 }
 
 ; 1 byte, i64 version.
-define void @f4(i8 *%dest, i8 %val) {
+define void @f4(i8* %dest, i8 %val) {
 ; CHECK-LABEL: f4:
 ; CHECK: stc %r3, 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 %val, i64 1, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 %val, i64 1, i1 false)
   ret void
 }
 
 ; 2 bytes, i32 version.
-define void @f5(i8 *%dest, i8 %val) {
+define void @f5(i8* %dest, i8 %val) {
 ; CHECK-LABEL: f5:
 ; CHECK-DAG: stc %r3, 0(%r2)
 ; CHECK-DAG: stc %r3, 1(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 %val, i32 2, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 %val, i32 2, i1 false)
   ret void
 }
 
 ; 2 bytes, i64 version.
-define void @f6(i8 *%dest, i8 %val) {
+define void @f6(i8* %dest, i8 %val) {
 ; CHECK-LABEL: f6:
 ; CHECK-DAG: stc %r3, 0(%r2)
 ; CHECK-DAG: stc %r3, 1(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 %val, i64 2, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 %val, i64 2, i1 false)
   ret void
 }
 
 ; 3 bytes, i32 version.
-define void @f7(i8 *%dest, i8 %val) {
+define void @f7(i8* %dest, i8 %val) {
 ; CHECK-LABEL: f7:
 ; CHECK: stc %r3, 0(%r2)
 ; CHECK: mvc 1(2,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 %val, i32 3, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 %val, i32 3, i1 false)
   ret void
 }
 
 ; 3 bytes, i64 version.
-define void @f8(i8 *%dest, i8 %val) {
+define void @f8(i8* %dest, i8 %val) {
 ; CHECK-LABEL: f8:
 ; CHECK: stc %r3, 0(%r2)
 ; CHECK: mvc 1(2,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 %val, i64 3, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 %val, i64 3, i1 false)
   ret void
 }
 
 ; 257 bytes, i32 version.
-define void @f9(i8 *%dest, i8 %val) {
+define void @f9(i8* %dest, i8 %val) {
 ; CHECK-LABEL: f9:
 ; CHECK: stc %r3, 0(%r2)
 ; CHECK: mvc 1(256,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 %val, i32 257, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 %val, i32 257, i1 false)
   ret void
 }
 
 ; 257 bytes, i64 version.
-define void @f10(i8 *%dest, i8 %val) {
+define void @f10(i8* %dest, i8 %val) {
 ; CHECK-LABEL: f10:
 ; CHECK: stc %r3, 0(%r2)
 ; CHECK: mvc 1(256,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 %val, i64 257, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 %val, i64 257, i1 false)
   ret void
 }
 
 ; 258 bytes, i32 version.  We need two MVCs.
-define void @f11(i8 *%dest, i8 %val) {
+define void @f11(i8* %dest, i8 %val) {
 ; CHECK-LABEL: f11:
 ; CHECK: stc %r3, 0(%r2)
 ; CHECK: mvc 1(256,%r2), 0(%r2)
 ; CHECK: mvc 257(1,%r2), 256(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 %val, i32 258, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 %val, i32 258, i1 false)
   ret void
 }
 
 ; 258 bytes, i64 version.
-define void @f12(i8 *%dest, i8 %val) {
+define void @f12(i8* %dest, i8 %val) {
 ; CHECK-LABEL: f12:
 ; CHECK: stc %r3, 0(%r2)
 ; CHECK: mvc 1(256,%r2), 0(%r2)
 ; CHECK: mvc 257(1,%r2), 256(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 %val, i64 258, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 %val, i64 258, i1 false)
   ret void
 }
 
 ; Test the largest case for which straight-line code is used.
-define void @f13(i8 *%dest, i8 %val) {
+define void @f13(i8* %dest, i8 %val) {
 ; CHECK-LABEL: f13:
 ; CHECK: stc %r3, 0(%r2)
 ; CHECK: mvc 1(256,%r2), 0(%r2)
@@ -136,14 +136,13 @@ define void @f13(i8 *%dest, i8 %val) {
 ; CHECK: mvc 1025(256,%r2), 1024(%r2)
 ; CHECK: mvc 1281(256,%r2), 1280(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 %val, i64 1537, i32 1,
-                                  i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 %val, i64 1537, i1 false)
   ret void
 }
 
 ; Test the next size up, which uses a loop.  We leave the other corner
 ; cases to memcpy-01.ll.
-define void @f14(i8 *%dest, i8 %val) {
+define void @f14(i8* %dest, i8 %val) {
 ; CHECK-LABEL: f14:
 ; CHECK: stc %r3, 0(%r2)
 ; CHECK: lghi [[COUNT:%r[0-5]]], 6
@@ -154,7 +153,6 @@ define void @f14(i8 *%dest, i8 %val) {
 ; CHECK: brctg [[COUNT]], [[LABEL]]
 ; CHECK: mvc 1(1,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 %val, i64 1538, i32 1,
-                                  i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 %val, i64 1538, i1 false)
   ret void
 }
diff --git a/llvm/test/CodeGen/SystemZ/memset-02.ll b/llvm/test/CodeGen/SystemZ/memset-02.ll
index b4724c0b574..3f5ffca3398 100644
--- a/llvm/test/CodeGen/SystemZ/memset-02.ll
+++ b/llvm/test/CodeGen/SystemZ/memset-02.ll
@@ -2,161 +2,161 @@
 ;
 ; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s
 
-declare void @llvm.memset.p0i8.i32(i8 *nocapture, i8, i32, i32, i1) nounwind
-declare void @llvm.memset.p0i8.i64(i8 *nocapture, i8, i64, i32, i1) nounwind
+declare void @llvm.memset.p0i8.i32(i8 *nocapture, i8, i32, i1) nounwind
+declare void @llvm.memset.p0i8.i64(i8 *nocapture, i8, i64, i1) nounwind
 
 ; No bytes, i32 version.
-define void @f1(i8 *%dest) {
+define void @f1(i8* %dest) {
 ; CHECK-LABEL: f1:
 ; CHECK-NOT: %r2
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 128, i32 0, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 128, i32 0, i1 false)
   ret void
 }
 
 ; No bytes, i64 version.
-define void @f2(i8 *%dest) {
+define void @f2(i8* %dest) {
 ; CHECK-LABEL: f2:
 ; CHECK-NOT: %r2
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 128, i64 0, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 128, i64 0, i1 false)
   ret void
 }
 
 ; 1 byte, i32 version.
-define void @f3(i8 *%dest) {
+define void @f3(i8* %dest) {
 ; CHECK-LABEL: f3:
 ; CHECK: mvi 0(%r2), 128
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 128, i32 1, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 128, i32 1, i1 false)
   ret void
 }
 
 ; 1 byte, i64 version.
-define void @f4(i8 *%dest) {
+define void @f4(i8* %dest) {
 ; CHECK-LABEL: f4:
 ; CHECK: mvi 0(%r2), 128
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 128, i64 1, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 128, i64 1, i1 false)
   ret void
 }
 
 ; 2 bytes, i32 version.
-define void @f5(i8 *%dest) {
+define void @f5(i8* %dest) {
 ; CHECK-LABEL: f5:
 ; CHECK: mvhhi 0(%r2), -32640
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 128, i32 2, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 128, i32 2, i1 false)
   ret void
 }
 
 ; 2 bytes, i64 version.
-define void @f6(i8 *%dest) {
+define void @f6(i8* %dest) {
 ; CHECK-LABEL: f6:
 ; CHECK: mvhhi 0(%r2), -32640
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 128, i64 2, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 128, i64 2, i1 false)
   ret void
 }
 
 ; 3 bytes, i32 version.
-define void @f7(i8 *%dest) {
+define void @f7(i8* %dest) {
 ; CHECK-LABEL: f7:
 ; CHECK-DAG: mvhhi 0(%r2), -32640
 ; CHECK-DAG: mvi 2(%r2), 128
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 128, i32 3, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 128, i32 3, i1 false)
   ret void
 }
 
 ; 3 bytes, i64 version.
-define void @f8(i8 *%dest) {
+define void @f8(i8* %dest) {
 ; CHECK-LABEL: f8:
 ; CHECK-DAG: mvhhi 0(%r2), -32640
 ; CHECK-DAG: mvi 2(%r2), 128
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 128, i64 3, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 128, i64 3, i1 false)
   ret void
 }
 
 ; 4 bytes, i32 version.
-define void @f9(i8 *%dest) {
+define void @f9(i8* %dest) {
 ; CHECK-LABEL: f9:
 ; CHECK: iilf [[REG:%r[0-5]]], 2155905152
 ; CHECK: st [[REG]], 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 128, i32 4, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 128, i32 4, i1 false)
   ret void
 }
 
 ; 4 bytes, i64 version.
-define void @f10(i8 *%dest) {
+define void @f10(i8* %dest) {
 ; CHECK-LABEL: f10:
 ; CHECK: iilf [[REG:%r[0-5]]], 2155905152
 ; CHECK: st [[REG]], 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 128, i64 4, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 128, i64 4, i1 false)
   ret void
 }
 
 ; 5 bytes, i32 version.
-define void @f11(i8 *%dest) {
+define void @f11(i8* %dest) {
 ; CHECK-LABEL: f11:
 ; CHECK: mvi 0(%r2), 128
 ; CHECK: mvc 1(4,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 128, i32 5, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 128, i32 5, i1 false)
   ret void
 }
 
 ; 5 bytes, i64 version.
-define void @f12(i8 *%dest) {
+define void @f12(i8* %dest) {
 ; CHECK-LABEL: f12:
 ; CHECK: mvi 0(%r2), 128
 ; CHECK: mvc 1(4,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 128, i64 5, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 128, i64 5, i1 false)
   ret void
 }
 
 ; 257 bytes, i32 version.
-define void @f13(i8 *%dest) {
+define void @f13(i8* %dest) {
 ; CHECK-LABEL: f13:
 ; CHECK: mvi 0(%r2), 128
 ; CHECK: mvc 1(256,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 128, i32 257, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 128, i32 257, i1 false)
   ret void
 }
 
 ; 257 bytes, i64 version.
-define void @f14(i8 *%dest) {
+define void @f14(i8* %dest) {
 ; CHECK-LABEL: f14:
 ; CHECK: mvi 0(%r2), 128
 ; CHECK: mvc 1(256,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 128, i64 257, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 128, i64 257, i1 false)
   ret void
 }
 
 ; 258 bytes, i32 version.  We need two MVCs.
-define void @f15(i8 *%dest) {
+define void @f15(i8* %dest) {
 ; CHECK-LABEL: f15:
 ; CHECK: mvi 0(%r2), 128
 ; CHECK: mvc 1(256,%r2), 0(%r2)
 ; CHECK: mvc 257(1,%r2), 256(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 128, i32 258, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 128, i32 258, i1 false)
   ret void
 }
 
 ; 258 bytes, i64 version.
-define void @f16(i8 *%dest) {
+define void @f16(i8* %dest) {
 ; CHECK-LABEL: f16:
 ; CHECK: mvi 0(%r2), 128
 ; CHECK: mvc 1(256,%r2), 0(%r2)
 ; CHECK: mvc 257(1,%r2), 256(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 128, i64 258, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 128, i64 258, i1 false)
   ret void
 }
diff --git a/llvm/test/CodeGen/SystemZ/memset-03.ll b/llvm/test/CodeGen/SystemZ/memset-03.ll
index a95f89fc7c0..a6370f4ab10 100644
--- a/llvm/test/CodeGen/SystemZ/memset-03.ll
+++ b/llvm/test/CodeGen/SystemZ/memset-03.ll
@@ -2,381 +2,381 @@
 ;
 ; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s
 
-declare void @llvm.memset.p0i8.i32(i8 *nocapture, i8, i32, i32, i1) nounwind
-declare void @llvm.memset.p0i8.i64(i8 *nocapture, i8, i64, i32, i1) nounwind
+declare void @llvm.memset.p0i8.i32(i8 *nocapture, i8, i32, i1) nounwind
+declare void @llvm.memset.p0i8.i64(i8 *nocapture, i8, i64, i1) nounwind
 
 ; No bytes, i32 version.
-define void @f1(i8 *%dest) {
+define void @f1(i8* %dest) {
 ; CHECK-LABEL: f1:
 ; CHECK-NOT: %r2
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 0, i32 0, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 0, i1 false)
   ret void
 }
 
 ; No bytes, i64 version.
-define void @f2(i8 *%dest) {
+define void @f2(i8* %dest) {
 ; CHECK-LABEL: f2:
 ; CHECK-NOT: %r2
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 0, i64 0, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 0, i64 0, i1 false)
   ret void
 }
 
 ; 1 byte, i32 version.
-define void @f3(i8 *%dest) {
+define void @f3(i8* %dest) {
 ; CHECK-LABEL: f3:
 ; CHECK: mvi 0(%r2), 0
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 0, i32 1, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 1, i1 false)
   ret void
 }
 
 ; 1 byte, i64 version.
-define void @f4(i8 *%dest) {
+define void @f4(i8* %dest) {
 ; CHECK-LABEL: f4:
 ; CHECK: mvi 0(%r2), 0
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 0, i64 1, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 0, i64 1, i1 false)
   ret void
 }
 
 ; 2 bytes, i32 version.
-define void @f5(i8 *%dest) {
+define void @f5(i8* %dest) {
 ; CHECK-LABEL: f5:
 ; CHECK: mvhhi 0(%r2), 0
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 0, i32 2, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 2, i1 false)
   ret void
 }
 
 ; 2 bytes, i64 version.
-define void @f6(i8 *%dest) {
+define void @f6(i8* %dest) {
 ; CHECK-LABEL: f6:
 ; CHECK: mvhhi 0(%r2), 0
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 0, i64 2, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 0, i64 2, i1 false)
   ret void
 }
 
 ; 3 bytes, i32 version.
-define void @f7(i8 *%dest) {
+define void @f7(i8* %dest) {
 ; CHECK-LABEL: f7:
 ; CHECK-DAG: mvhhi 0(%r2), 0
 ; CHECK-DAG: mvi 2(%r2), 0
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 0, i32 3, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 3, i1 false)
   ret void
 }
 
 ; 3 bytes, i64 version.
-define void @f8(i8 *%dest) {
+define void @f8(i8* %dest) {
 ; CHECK-LABEL: f8:
 ; CHECK-DAG: mvhhi 0(%r2), 0
 ; CHECK-DAG: mvi 2(%r2), 0
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 0, i64 3, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 0, i64 3, i1 false)
   ret void
 }
 
 ; 4 bytes, i32 version.
-define void @f9(i8 *%dest) {
+define void @f9(i8* %dest) {
 ; CHECK-LABEL: f9:
 ; CHECK: mvhi 0(%r2), 0
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 0, i32 4, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 4, i1 false)
   ret void
 }
 
 ; 4 bytes, i64 version.
-define void @f10(i8 *%dest) {
+define void @f10(i8* %dest) {
 ; CHECK-LABEL: f10:
 ; CHECK: mvhi 0(%r2), 0
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 0, i64 4, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 0, i64 4, i1 false)
   ret void
 }
 
 ; 5 bytes, i32 version.
-define void @f11(i8 *%dest) {
+define void @f11(i8* %dest) {
 ; CHECK-LABEL: f11:
 ; CHECK-DAG: mvhi 0(%r2), 0
 ; CHECK-DAG: mvi 4(%r2), 0
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 0, i32 5, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 5, i1 false)
   ret void
 }
 
 ; 5 bytes, i64 version.
-define void @f12(i8 *%dest) {
+define void @f12(i8* %dest) {
 ; CHECK-LABEL: f12:
 ; CHECK-DAG: mvhi 0(%r2), 0
 ; CHECK-DAG: mvi 4(%r2), 0
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 0, i64 5, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 0, i64 5, i1 false)
   ret void
 }
 
 ; 6 bytes, i32 version.
-define void @f13(i8 *%dest) {
+define void @f13(i8* %dest) {
 ; CHECK-LABEL: f13:
 ; CHECK-DAG: mvhi 0(%r2), 0
 ; CHECK-DAG: mvhhi 4(%r2), 0
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 0, i32 6, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 6, i1 false)
   ret void
 }
 
 ; 6 bytes, i64 version.
-define void @f14(i8 *%dest) {
+define void @f14(i8* %dest) {
 ; CHECK-LABEL: f14:
 ; CHECK-DAG: mvhi 0(%r2), 0
 ; CHECK-DAG: mvhhi 4(%r2), 0
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 0, i64 6, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 0, i64 6, i1 false)
   ret void
 }
 
 ; 7 bytes, i32 version.
-define void @f15(i8 *%dest) {
+define void @f15(i8* %dest) {
 ; CHECK-LABEL: f15:
 ; CHECK: xc 0(7,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 0, i32 7, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 7, i1 false)
   ret void
 }
 
 ; 7 bytes, i64 version.
-define void @f16(i8 *%dest) {
+define void @f16(i8* %dest) {
 ; CHECK-LABEL: f16:
 ; CHECK: xc 0(7,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 0, i64 7, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 0, i64 7, i1 false)
   ret void
 }
 
 ; 8 bytes, i32 version.
-define void @f17(i8 *%dest) {
+define void @f17(i8* %dest) {
 ; CHECK-LABEL: f17:
 ; CHECK: mvghi 0(%r2), 0
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 0, i32 8, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 8, i1 false)
   ret void
 }
 
 ; 8 bytes, i64 version.
-define void @f18(i8 *%dest) {
+define void @f18(i8* %dest) {
 ; CHECK-LABEL: f18:
 ; CHECK: mvghi 0(%r2), 0
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 0, i64 8, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 0, i64 8, i1 false)
   ret void
 }
 
 ; 9 bytes, i32 version.
-define void @f19(i8 *%dest) {
+define void @f19(i8* %dest) {
 ; CHECK-LABEL: f19:
 ; CHECK-DAG: mvghi 0(%r2), 0
 ; CHECK-DAG: mvi 8(%r2), 0
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 0, i32 9, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 9, i1 false)
   ret void
 }
 
 ; 9 bytes, i64 version.
-define void @f20(i8 *%dest) {
+define void @f20(i8* %dest) {
 ; CHECK-LABEL: f20:
 ; CHECK-DAG: mvghi 0(%r2), 0
 ; CHECK-DAG: mvi 8(%r2), 0
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 0, i64 9, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 0, i64 9, i1 false)
   ret void
 }
 
 ; 10 bytes, i32 version.
-define void @f21(i8 *%dest) {
+define void @f21(i8* %dest) {
 ; CHECK-LABEL: f21:
 ; CHECK-DAG: mvghi 0(%r2), 0
 ; CHECK-DAG: mvhhi 8(%r2), 0
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 0, i32 10, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 10, i1 false)
   ret void
 }
 
 ; 10 bytes, i64 version.
-define void @f22(i8 *%dest) {
+define void @f22(i8* %dest) {
 ; CHECK-LABEL: f22:
 ; CHECK-DAG: mvghi 0(%r2), 0
 ; CHECK-DAG: mvhhi 8(%r2), 0
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 0, i64 10, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 0, i64 10, i1 false)
   ret void
 }
 
 ; 11 bytes, i32 version.
-define void @f23(i8 *%dest) {
+define void @f23(i8* %dest) {
 ; CHECK-LABEL: f23:
 ; CHECK: xc 0(11,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 0, i32 11, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 11, i1 false)
   ret void
 }
 
 ; 11 bytes, i64 version.
-define void @f24(i8 *%dest) {
+define void @f24(i8* %dest) {
 ; CHECK-LABEL: f24:
 ; CHECK: xc 0(11,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 0, i64 11, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 0, i64 11, i1 false)
   ret void
 }
 
 ; 12 bytes, i32 version.
-define void @f25(i8 *%dest) {
+define void @f25(i8* %dest) {
 ; CHECK-LABEL: f25:
 ; CHECK-DAG: mvghi 0(%r2), 0
 ; CHECK-DAG: mvhi 8(%r2), 0
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 0, i32 12, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 12, i1 false)
   ret void
 }
 
 ; 12 bytes, i64 version.
-define void @f26(i8 *%dest) {
+define void @f26(i8* %dest) {
 ; CHECK-LABEL: f26:
 ; CHECK-DAG: mvghi 0(%r2), 0
 ; CHECK-DAG: mvhi 8(%r2), 0
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 0, i32 12, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 12, i1 false)
   ret void
 }
 
 ; 13 bytes, i32 version.
-define void @f27(i8 *%dest) {
+define void @f27(i8* %dest) {
 ; CHECK-LABEL: f27:
 ; CHECK: xc 0(13,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 0, i32 13, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 13, i1 false)
   ret void
 }
 
 ; 13 bytes, i64 version.
-define void @f28(i8 *%dest) {
+define void @f28(i8* %dest) {
 ; CHECK-LABEL: f28:
 ; CHECK: xc 0(13,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 0, i64 13, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 0, i64 13, i1 false)
   ret void
 }
 
 ; 14 bytes, i32 version.
-define void @f29(i8 *%dest) {
+define void @f29(i8* %dest) {
 ; CHECK-LABEL: f29:
 ; CHECK: xc 0(14,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 0, i32 14, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 14, i1 false)
   ret void
 }
 
 ; 14 bytes, i64 version.
-define void @f30(i8 *%dest) {
+define void @f30(i8* %dest) {
 ; CHECK-LABEL: f30:
 ; CHECK: xc 0(14,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 0, i64 14, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 0, i64 14, i1 false)
   ret void
 }
 
 ; 15 bytes, i32 version.
-define void @f31(i8 *%dest) {
+define void @f31(i8* %dest) {
 ; CHECK-LABEL: f31:
 ; CHECK: xc 0(15,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 0, i32 15, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 15, i1 false)
   ret void
 }
 
 ; 15 bytes, i64 version.
-define void @f32(i8 *%dest) {
+define void @f32(i8* %dest) {
 ; CHECK-LABEL: f32:
 ; CHECK: xc 0(15,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 0, i64 15, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 0, i64 15, i1 false)
   ret void
 }
 
 ; 16 bytes, i32 version.
-define void @f33(i8 *%dest) {
+define void @f33(i8* %dest) {
 ; CHECK-LABEL: f33:
 ; CHECK-DAG: mvghi 0(%r2), 0
 ; CHECK-DAG: mvghi 8(%r2), 0
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 0, i32 16, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 16, i1 false)
   ret void
 }
 
 ; 16 bytes, i64 version.
-define void @f34(i8 *%dest) {
+define void @f34(i8* %dest) {
 ; CHECK-LABEL: f34:
 ; CHECK-DAG: mvghi 0(%r2), 0
 ; CHECK-DAG: mvghi 8(%r2), 0
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 0, i64 16, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 0, i64 16, i1 false)
   ret void
 }
 
 ; 17 bytes, i32 version.
-define void @f35(i8 *%dest) {
+define void @f35(i8* %dest) {
 ; CHECK-LABEL: f35:
 ; CHECK: xc 0(17,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 0, i32 17, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 17, i1 false)
   ret void
 }
 
 ; 17 bytes, i64 version.
-define void @f36(i8 *%dest) {
+define void @f36(i8* %dest) {
 ; CHECK-LABEL: f36:
 ; CHECK: xc 0(17,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 0, i64 17, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 0, i64 17, i1 false)
   ret void
 }
 
 ; 256 bytes, i32 version.
-define void @f37(i8 *%dest) {
+define void @f37(i8* %dest) {
 ; CHECK-LABEL: f37:
 ; CHECK: xc 0(256,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 0, i32 256, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 256, i1 false)
   ret void
 }
 
 ; 256 bytes, i64 version.
-define void @f38(i8 *%dest) {
+define void @f38(i8* %dest) {
 ; CHECK-LABEL: f38:
 ; CHECK: xc 0(256,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 0, i64 256, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 0, i64 256, i1 false)
   ret void
 }
 
 ; 257 bytes, i32 version.  We need two MVCs.
-define void @f39(i8 *%dest) {
+define void @f39(i8* %dest) {
 ; CHECK-LABEL: f39:
 ; CHECK: xc 0(256,%r2), 0(%r2)
 ; CHECK: xc 256(1,%r2), 256(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 0, i32 257, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 257, i1 false)
   ret void
 }
 
 ; 257 bytes, i64 version.
-define void @f40(i8 *%dest) {
+define void @f40(i8* %dest) {
 ; CHECK-LABEL: f40:
 ; CHECK: xc 0(256,%r2), 0(%r2)
 ; CHECK: xc 256(1,%r2), 256(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 0, i64 257, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 0, i64 257, i1 false)
   ret void
 }
diff --git a/llvm/test/CodeGen/SystemZ/memset-04.ll b/llvm/test/CodeGen/SystemZ/memset-04.ll
index 7906e8d10a1..dcb8b6bad81 100644
--- a/llvm/test/CodeGen/SystemZ/memset-04.ll
+++ b/llvm/test/CodeGen/SystemZ/memset-04.ll
@@ -2,397 +2,397 @@
 ;
 ; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s
 
-declare void @llvm.memset.p0i8.i32(i8 *nocapture, i8, i32, i32, i1) nounwind
-declare void @llvm.memset.p0i8.i64(i8 *nocapture, i8, i64, i32, i1) nounwind
+declare void @llvm.memset.p0i8.i32(i8 *nocapture, i8, i32, i1) nounwind
+declare void @llvm.memset.p0i8.i64(i8 *nocapture, i8, i64, i1) nounwind
 
 ; No bytes, i32 version.
-define void @f1(i8 *%dest) {
+define void @f1(i8* %dest) {
 ; CHECK-LABEL: f1:
 ; CHECK-NOT: %r2
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 -1, i32 0, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 -1, i32 0, i1 false)
   ret void
 }
 
 ; No bytes, i64 version.
-define void @f2(i8 *%dest) {
+define void @f2(i8* %dest) {
 ; CHECK-LABEL: f2:
 ; CHECK-NOT: %r2
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 -1, i64 0, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 -1, i64 0, i1 false)
   ret void
 }
 
 ; 1 byte, i32 version.
-define void @f3(i8 *%dest) {
+define void @f3(i8* %dest) {
 ; CHECK-LABEL: f3:
 ; CHECK: mvi 0(%r2), 255
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 -1, i32 1, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 -1, i32 1, i1 false)
   ret void
 }
 
 ; 1 byte, i64 version.
-define void @f4(i8 *%dest) {
+define void @f4(i8* %dest) {
 ; CHECK-LABEL: f4:
 ; CHECK: mvi 0(%r2), 255
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 -1, i64 1, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 -1, i64 1, i1 false)
   ret void
 }
 
 ; 2 bytes, i32 version.
-define void @f5(i8 *%dest) {
+define void @f5(i8* %dest) {
 ; CHECK-LABEL: f5:
 ; CHECK: mvhhi 0(%r2), -1
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 -1, i32 2, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 -1, i32 2, i1 false)
   ret void
 }
 
 ; 2 bytes, i64 version.
-define void @f6(i8 *%dest) {
+define void @f6(i8* %dest) {
 ; CHECK-LABEL: f6:
 ; CHECK: mvhhi 0(%r2), -1
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 -1, i64 2, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 -1, i64 2, i1 false)
   ret void
 }
 
 ; 3 bytes, i32 version.
-define void @f7(i8 *%dest) {
+define void @f7(i8* %dest) {
 ; CHECK-LABEL: f7:
 ; CHECK-DAG: mvhhi 0(%r2), -1
 ; CHECK-DAG: mvi 2(%r2), 255
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 -1, i32 3, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 -1, i32 3, i1 false)
   ret void
 }
 
 ; 3 bytes, i64 version.
-define void @f8(i8 *%dest) {
+define void @f8(i8* %dest) {
 ; CHECK-LABEL: f8:
 ; CHECK-DAG: mvhhi 0(%r2), -1
 ; CHECK-DAG: mvi 2(%r2), 255
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 -1, i64 3, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 -1, i64 3, i1 false)
   ret void
 }
 
 ; 4 bytes, i32 version.
-define void @f9(i8 *%dest) {
+define void @f9(i8* %dest) {
 ; CHECK-LABEL: f9:
 ; CHECK: mvhi 0(%r2), -1
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 -1, i32 4, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 -1, i32 4, i1 false)
   ret void
 }
 
 ; 4 bytes, i64 version.
-define void @f10(i8 *%dest) {
+define void @f10(i8* %dest) {
 ; CHECK-LABEL: f10:
 ; CHECK: mvhi 0(%r2), -1
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 -1, i64 4, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 -1, i64 4, i1 false)
   ret void
 }
 
 ; 5 bytes, i32 version.
-define void @f11(i8 *%dest) {
+define void @f11(i8* %dest) {
 ; CHECK-LABEL: f11:
 ; CHECK-DAG: mvhi 0(%r2), -1
 ; CHECK-DAG: mvi 4(%r2), 255
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 -1, i32 5, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 -1, i32 5, i1 false)
   ret void
 }
 
 ; 5 bytes, i64 version.
-define void @f12(i8 *%dest) {
+define void @f12(i8* %dest) {
 ; CHECK-LABEL: f12:
 ; CHECK-DAG: mvhi 0(%r2), -1
 ; CHECK-DAG: mvi 4(%r2), 255
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 -1, i64 5, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 -1, i64 5, i1 false)
   ret void
 }
 
 ; 6 bytes, i32 version.
-define void @f13(i8 *%dest) {
+define void @f13(i8* %dest) {
 ; CHECK-LABEL: f13:
 ; CHECK-DAG: mvhi 0(%r2), -1
 ; CHECK-DAG: mvhhi 4(%r2), -1
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 -1, i32 6, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 -1, i32 6, i1 false)
   ret void
 }
 
 ; 6 bytes, i64 version.
-define void @f14(i8 *%dest) {
+define void @f14(i8* %dest) {
 ; CHECK-LABEL: f14:
 ; CHECK-DAG: mvhi 0(%r2), -1
 ; CHECK-DAG: mvhhi 4(%r2), -1
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 -1, i64 6, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 -1, i64 6, i1 false)
   ret void
 }
 
 ; 7 bytes, i32 version.
-define void @f15(i8 *%dest) {
+define void @f15(i8* %dest) {
 ; CHECK-LABEL: f15:
 ; CHECK: mvi 0(%r2), 255
 ; CHECK: mvc 1(6,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 -1, i32 7, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 -1, i32 7, i1 false)
   ret void
 }
 
 ; 7 bytes, i64 version.
-define void @f16(i8 *%dest) {
+define void @f16(i8* %dest) {
 ; CHECK-LABEL: f16:
 ; CHECK: mvi 0(%r2), 255
 ; CHECK: mvc 1(6,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 -1, i64 7, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 -1, i64 7, i1 false)
   ret void
 }
 
 ; 8 bytes, i32 version.
-define void @f17(i8 *%dest) {
+define void @f17(i8* %dest) {
 ; CHECK-LABEL: f17:
 ; CHECK: mvghi 0(%r2), -1
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 -1, i32 8, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 -1, i32 8, i1 false)
   ret void
 }
 
 ; 8 bytes, i64 version.
-define void @f18(i8 *%dest) {
+define void @f18(i8* %dest) {
 ; CHECK-LABEL: f18:
 ; CHECK: mvghi 0(%r2), -1
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 -1, i64 8, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 -1, i64 8, i1 false)
   ret void
 }
 
 ; 9 bytes, i32 version.
-define void @f19(i8 *%dest) {
+define void @f19(i8* %dest) {
 ; CHECK-LABEL: f19:
 ; CHECK-DAG: mvghi 0(%r2), -1
 ; CHECK-DAG: mvi 8(%r2), 255
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 -1, i32 9, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 -1, i32 9, i1 false)
   ret void
 }
 
 ; 9 bytes, i64 version.
-define void @f20(i8 *%dest) {
+define void @f20(i8* %dest) {
 ; CHECK-LABEL: f20:
 ; CHECK-DAG: mvghi 0(%r2), -1
 ; CHECK-DAG: mvi 8(%r2), 255
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 -1, i64 9, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 -1, i64 9, i1 false)
   ret void
 }
 
 ; 10 bytes, i32 version.
-define void @f21(i8 *%dest) {
+define void @f21(i8* %dest) {
 ; CHECK-LABEL: f21:
 ; CHECK-DAG: mvghi 0(%r2), -1
 ; CHECK-DAG: mvhhi 8(%r2), -1
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 -1, i32 10, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 -1, i32 10, i1 false)
   ret void
 }
 
 ; 10 bytes, i64 version.
-define void @f22(i8 *%dest) {
+define void @f22(i8* %dest) {
 ; CHECK-LABEL: f22:
 ; CHECK-DAG: mvghi 0(%r2), -1
 ; CHECK-DAG: mvhhi 8(%r2), -1
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 -1, i64 10, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 -1, i64 10, i1 false)
   ret void
 }
 
 ; 11 bytes, i32 version.
-define void @f23(i8 *%dest) {
+define void @f23(i8* %dest) {
 ; CHECK-LABEL: f23:
 ; CHECK: mvi 0(%r2), 255
 ; CHECK: mvc 1(10,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 -1, i32 11, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 -1, i32 11, i1 false)
   ret void
 }
 
 ; 11 bytes, i64 version.
-define void @f24(i8 *%dest) {
+define void @f24(i8* %dest) {
 ; CHECK-LABEL: f24:
 ; CHECK: mvi 0(%r2), 255
 ; CHECK: mvc 1(10,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 -1, i64 11, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 -1, i64 11, i1 false)
   ret void
 }
 
 ; 12 bytes, i32 version.
-define void @f25(i8 *%dest) {
+define void @f25(i8* %dest) {
 ; CHECK-LABEL: f25:
 ; CHECK-DAG: mvghi 0(%r2), -1
 ; CHECK-DAG: mvhi 8(%r2), -1
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 -1, i32 12, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 -1, i32 12, i1 false)
   ret void
 }
 
 ; 12 bytes, i64 version.
-define void @f26(i8 *%dest) {
+define void @f26(i8* %dest) {
 ; CHECK-LABEL: f26:
 ; CHECK-DAG: mvghi 0(%r2), -1
 ; CHECK-DAG: mvhi 8(%r2), -1
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 -1, i64 12, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 -1, i64 12, i1 false)
   ret void
 }
 
 ; 13 bytes, i32 version.
-define void @f27(i8 *%dest) {
+define void @f27(i8* %dest) {
 ; CHECK-LABEL: f27:
 ; CHECK: mvi 0(%r2), 255
 ; CHECK: mvc 1(12,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 -1, i32 13, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 -1, i32 13, i1 false)
   ret void
 }
 
 ; 13 bytes, i64 version.
-define void @f28(i8 *%dest) {
+define void @f28(i8* %dest) {
 ; CHECK-LABEL: f28:
 ; CHECK: mvi 0(%r2), 255
 ; CHECK: mvc 1(12,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 -1, i64 13, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 -1, i64 13, i1 false)
   ret void
 }
 
 ; 14 bytes, i32 version.
-define void @f29(i8 *%dest) {
+define void @f29(i8* %dest) {
 ; CHECK-LABEL: f29:
 ; CHECK: mvi 0(%r2), 255
 ; CHECK: mvc 1(13,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 -1, i32 14, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 -1, i32 14, i1 false)
   ret void
 }
 
 ; 14 bytes, i64 version.
-define void @f30(i8 *%dest) {
+define void @f30(i8* %dest) {
 ; CHECK-LABEL: f30:
 ; CHECK: mvi 0(%r2), 255
 ; CHECK: mvc 1(13,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 -1, i64 14, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 -1, i64 14, i1 false)
   ret void
 }
 
 ; 15 bytes, i32 version.
-define void @f31(i8 *%dest) {
+define void @f31(i8* %dest) {
 ; CHECK-LABEL: f31:
 ; CHECK: mvi 0(%r2), 255
 ; CHECK: mvc 1(14,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 -1, i32 15, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 -1, i32 15, i1 false)
   ret void
 }
 
 ; 15 bytes, i64 version.
-define void @f32(i8 *%dest) {
+define void @f32(i8* %dest) {
 ; CHECK-LABEL: f32:
 ; CHECK: mvi 0(%r2), 255
 ; CHECK: mvc 1(14,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 -1, i64 15, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 -1, i64 15, i1 false)
   ret void
 }
 
 ; 16 bytes, i32 version.
-define void @f33(i8 *%dest) {
+define void @f33(i8* %dest) {
 ; CHECK-LABEL: f33:
 ; CHECK-DAG: mvghi 0(%r2), -1
 ; CHECK-DAG: mvghi 8(%r2), -1
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 -1, i32 16, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 -1, i32 16, i1 false)
   ret void
 }
 
 ; 16 bytes, i64 version.
-define void @f34(i8 *%dest) {
+define void @f34(i8* %dest) {
 ; CHECK-LABEL: f34:
 ; CHECK-DAG: mvghi 0(%r2), -1
 ; CHECK-DAG: mvghi 8(%r2), -1
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 -1, i64 16, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 -1, i64 16, i1 false)
   ret void
 }
 
 ; 17 bytes, i32 version.
-define void @f35(i8 *%dest) {
+define void @f35(i8* %dest) {
 ; CHECK-LABEL: f35:
 ; CHECK: mvi 0(%r2), 255
 ; CHECK: mvc 1(16,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 -1, i32 17, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 -1, i32 17, i1 false)
   ret void
 }
 
 ; 17 bytes, i64 version.
-define void @f36(i8 *%dest) {
+define void @f36(i8* %dest) {
 ; CHECK-LABEL: f36:
 ; CHECK: mvi 0(%r2), 255
 ; CHECK: mvc 1(16,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 -1, i64 17, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 -1, i64 17, i1 false)
   ret void
 }
 
 ; 257 bytes, i32 version.
-define void @f37(i8 *%dest) {
+define void @f37(i8* %dest) {
 ; CHECK-LABEL: f37:
 ; CHECK: mvi 0(%r2), 255
 ; CHECK: mvc 1(256,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 -1, i32 257, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 -1, i32 257, i1 false)
   ret void
 }
 
 ; 257 bytes, i64 version.
-define void @f38(i8 *%dest) {
+define void @f38(i8* %dest) {
 ; CHECK-LABEL: f38:
 ; CHECK: mvi 0(%r2), 255
 ; CHECK: mvc 1(256,%r2), 0(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 -1, i64 257, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 -1, i64 257, i1 false)
   ret void
 }
 
 ; 258 bytes, i32 version.  We need two MVCs.
-define void @f39(i8 *%dest) {
+define void @f39(i8* %dest) {
 ; CHECK-LABEL: f39:
 ; CHECK: mvi 0(%r2), 255
 ; CHECK: mvc 1(256,%r2), 0(%r2)
 ; CHECK: mvc 257(1,%r2), 256(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i32(i8 *%dest, i8 -1, i32 258, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i32(i8* %dest, i8 -1, i32 258, i1 false)
   ret void
 }
 
 ; 258 bytes, i64 version.
-define void @f40(i8 *%dest) {
+define void @f40(i8* %dest) {
 ; CHECK-LABEL: f40:
 ; CHECK: mvi 0(%r2), 255
 ; CHECK: mvc 1(256,%r2), 0(%r2)
 ; CHECK: mvc 257(1,%r2), 256(%r2)
 ; CHECK: br %r14
-  call void @llvm.memset.p0i8.i64(i8 *%dest, i8 -1, i64 258, i32 1, i1 false)
+  call void @llvm.memset.p0i8.i64(i8* %dest, i8 -1, i64 258, i1 false)
   ret void
 }
diff --git a/llvm/test/CodeGen/SystemZ/tail-call-mem-intrinsics.ll b/llvm/test/CodeGen/SystemZ/tail-call-mem-intrinsics.ll
index 65cc394f8a9..0290d425e57 100644
--- a/llvm/test/CodeGen/SystemZ/tail-call-mem-intrinsics.ll
+++ b/llvm/test/CodeGen/SystemZ/tail-call-mem-intrinsics.ll
@@ -4,7 +4,7 @@
 ; CHECK: jg memcpy
 define void @tail_memcpy(i8* nocapture %p, i8* nocapture readonly %q, i32 %n) #0 {
 entry:
-  tail call void @llvm.memcpy.p0i8.p0i8.i32(i8* %p, i8* %q, i32 %n, i32 1, i1 false)
+  tail call void @llvm.memcpy.p0i8.p0i8.i32(i8* %p, i8* %q, i32 %n, i1 false)
   ret void
 }
 
@@ -12,7 +12,7 @@ entry:
 ; CHECK: jg memmove
 define void @tail_memmove(i8* nocapture %p, i8* nocapture readonly %q, i32 %n) #0 {
 entry:
-  tail call void @llvm.memmove.p0i8.p0i8.i32(i8* %p, i8* %q, i32 %n, i32 1, i1 false)
+  tail call void @llvm.memmove.p0i8.p0i8.i32(i8* %p, i8* %q, i32 %n, i1 false)
   ret void
 }
 
@@ -20,12 +20,12 @@ entry:
 ; CHECK: jg memset
 define void @tail_memset(i8* nocapture %p, i8 %c, i32 %n) #0 {
 entry:
-  tail call void @llvm.memset.p0i8.i32(i8* %p, i8 %c, i32 %n, i32 1, i1 false)
+  tail call void @llvm.memset.p0i8.i32(i8* %p, i8 %c, i32 %n, i1 false)
   ret void
 }
 
-declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture readonly, i32, i32, i1) #0
-declare void @llvm.memmove.p0i8.p0i8.i32(i8* nocapture, i8* nocapture readonly, i32, i32, i1) #0
-declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i32, i1) #0
+declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture readonly, i32, i1) #0
+declare void @llvm.memmove.p0i8.p0i8.i32(i8* nocapture, i8* nocapture readonly, i32, i1) #0
+declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i1) #0
 
 attributes #0 = { nounwind }