llvm/test/CodeGen/SystemZ/memset-01.ll

   1 ; Test memset in cases where the set value is variable.
   2 ;
   3 ; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s
   4
   5 declare void @llvm.memset.p0.i32(ptr nocapture, i8, i32, i1) nounwind
   6 declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i1) nounwind
   7
   8 ; No bytes, i32 version.
   9 define void @f1(ptr %dest, i8 %val) {
  10 ; CHECK-LABEL: f1:
  11 ; CHECK-NOT: %r2
  12 ; CHECK-NOT: %r3
  13 ; CHECK: br %r14
  14   call void @llvm.memset.p0.i32(ptr %dest, i8 %val, i32 0, i1 false)
  15   ret void
  16 }
  17
  18 ; No bytes, i64 version.
  19 define void @f2(ptr %dest, i8 %val) {
  20 ; CHECK-LABEL: f2:
  21 ; CHECK-NOT: %r2
  22 ; CHECK-NOT: %r3
  23 ; CHECK: br %r14
  24   call void @llvm.memset.p0.i64(ptr %dest, i8 %val, i64 0, i1 false)
  25   ret void
  26 }
  27
  28 ; 1 byte, i32 version.
  29 define void @f3(ptr %dest, i8 %val) {
  30 ; CHECK-LABEL: f3:
  31 ; CHECK: stc %r3, 0(%r2)
  32 ; CHECK: br %r14
  33   call void @llvm.memset.p0.i32(ptr %dest, i8 %val, i32 1, i1 false)
  34   ret void
  35 }
  36
  37 ; 1 byte, i64 version.
  38 define void @f4(ptr %dest, i8 %val) {
  39 ; CHECK-LABEL: f4:
  40 ; CHECK: stc %r3, 0(%r2)
  41 ; CHECK: br %r14
  42   call void @llvm.memset.p0.i64(ptr %dest, i8 %val, i64 1, i1 false)
  43   ret void
  44 }
  45
  46 ; 2 bytes, i32 version.
  47 define void @f5(ptr %dest, i8 %val) {
  48 ; CHECK-LABEL: f5:
  49 ; CHECK-DAG: stc %r3, 0(%r2)
  50 ; CHECK-DAG: stc %r3, 1(%r2)
  51 ; CHECK: br %r14
  52   call void @llvm.memset.p0.i32(ptr %dest, i8 %val, i32 2, i1 false)
  53   ret void
  54 }
  55
  56 ; 2 bytes, i64 version.
  57 define void @f6(ptr %dest, i8 %val) {
  58 ; CHECK-LABEL: f6:
  59 ; CHECK-DAG: stc %r3, 0(%r2)
  60 ; CHECK-DAG: stc %r3, 1(%r2)
  61 ; CHECK: br %r14
  62   call void @llvm.memset.p0.i64(ptr %dest, i8 %val, i64 2, i1 false)
  63   ret void
  64 }
  65
  66 ; 3 bytes, i32 version.
  67 define void @f7(ptr %dest, i8 %val) {
  68 ; CHECK-LABEL: f7:
  69 ; CHECK: stc %r3, 0(%r2)
  70 ; CHECK: mvc 1(2,%r2), 0(%r2)
  71 ; CHECK: br %r14
  72   call void @llvm.memset.p0.i32(ptr %dest, i8 %val, i32 3, i1 false)
  73   ret void
  74 }
  75
  76 ; 3 bytes, i64 version.
  77 define void @f8(ptr %dest, i8 %val) {
  78 ; CHECK-LABEL: f8:
  79 ; CHECK: stc %r3, 0(%r2)
  80 ; CHECK: mvc 1(2,%r2), 0(%r2)
  81 ; CHECK: br %r14
  82   call void @llvm.memset.p0.i64(ptr %dest, i8 %val, i64 3, i1 false)
  83   ret void
  84 }
  85
  86 ; 257 bytes, i32 version.
  87 define void @f9(ptr %dest, i8 %val) {
  88 ; CHECK-LABEL: f9:
  89 ; CHECK: stc %r3, 0(%r2)
  90 ; CHECK: mvc 1(255,%r2), 0(%r2)
  91 ; CHECK: stc %r3, 256(%r2)
  92 ; CHECK: br %r14
  93   call void @llvm.memset.p0.i32(ptr %dest, i8 %val, i32 257, i1 false)
  94   ret void
  95 }
  96
  97 ; 257 bytes, i64 version.
  98 define void @f10(ptr %dest, i8 %val) {
  99 ; CHECK-LABEL: f10:
 100 ; CHECK: stc %r3, 0(%r2)
 101 ; CHECK: mvc 1(255,%r2), 0(%r2)
 102 ; CHECK: stc %r3, 256(%r2)
 103 ; CHECK: br %r14
 104   call void @llvm.memset.p0.i64(ptr %dest, i8 %val, i64 257, i1 false)
 105   ret void
 106 }
 107
 108 ; 258 bytes, i32 version.  We need two MVCs.
 109 define void @f11(ptr %dest, i8 %val) {
 110 ; CHECK-LABEL: f11:
 111 ; CHECK: stc %r3, 0(%r2)
 112 ; CHECK: mvc 1(255,%r2), 0(%r2)
 113 ; CHECK: stc %r3, 256(%r2)
 114 ; CHECK: mvc 257(1,%r2), 256(%r2)
 115 ; CHECK: br %r14
 116   call void @llvm.memset.p0.i32(ptr %dest, i8 %val, i32 258, i1 false)
 117   ret void
 118 }
 119
 120 ; 258 bytes, i64 version.
 121 define void @f12(ptr %dest, i8 %val) {
 122 ; CHECK-LABEL: f12:
 123 ; CHECK: stc %r3, 0(%r2)
 124 ; CHECK: mvc 1(255,%r2), 0(%r2)
 125 ; CHECK: stc %r3, 256(%r2)
 126 ; CHECK: mvc 257(1,%r2), 256(%r2)
 127 ; CHECK: br %r14
 128   call void @llvm.memset.p0.i64(ptr %dest, i8 %val, i64 258, i1 false)
 129   ret void
 130 }
 131
 132 ; Test the largest case for which straight-line code is used.
 133 define void @f13(ptr %dest, i8 %val) {
 134 ; CHECK-LABEL: f13:
 135 ; CHECK: stc %r3, 0(%r2)
 136 ; CHECK: mvc 1(255,%r2), 0(%r2)
 137 ; CHECK: stc %r3, 256(%r2)
 138 ; CHECK: mvc 257(255,%r2), 256(%r2)
 139 ; CHECK: stc %r3, 512(%r2)
 140 ; CHECK: mvc 513(255,%r2), 512(%r2)
 141 ; CHECK: stc %r3, 768(%r2)
 142 ; CHECK: mvc 769(255,%r2), 768(%r2)
 143 ; CHECK: stc %r3, 1024(%r2)
 144 ; CHECK: mvc 1025(255,%r2), 1024(%r2)
 145 ; CHECK: stc %r3, 1280(%r2)
 146 ; CHECK: mvc 1281(255,%r2), 1280(%r2)
 147 ; CHECK: br %r14
 148   call void @llvm.memset.p0.i64(ptr %dest, i8 %val, i64 1536, i1 false)
 149   ret void
 150 }
 151
 152 ; Test the next size up, which uses a loop.  We leave the other corner
 153 ; cases to memcpy-01.ll and memset-07.ll.
 154 define void @f14(ptr %dest, i8 %val) {
 155 ; CHECK-LABEL: f14:
 156 ; CHECK: lghi [[COUNT:%r[0-5]]], 6
 157 ; CHECK: [[LABEL:\.L[^:]*]]:
 158 ; CHECK: pfd 2, 768(%r2)
 159 ; CHECK: stc %r3, 0(%r2)
 160 ; CHECK: mvc 1(255,%r2), 0(%r2)
 161 ; CHECK: la %r2, 256(%r2)
 162 ; CHECK: brctg [[COUNT]], [[LABEL]]
 163 ; CHECK: stc %r3, 0(%r2)
 164 ; CHECK-NEXT: br %r14
 165   call void @llvm.memset.p0.i64(ptr %dest, i8 %val, i64 1537, i1 false)
 166   ret void
 167 }
 168
 169 ; Test (no) folding of displacement: Begins with max(uint12) - 1.
 170 define void @f15(ptr %dest, i8 %val) {
 171 ; CHECK-LABEL: f15:
 172 ; CHECK-NOT: la {{.*}}%r2
 173   %addr = getelementptr i8, ptr %dest, i64 4094
 174   call void @llvm.memset.p0.i64(ptr %addr, i8 %val, i64 256, i1 false)
 175   ret void
 176 }
 177
 178 ; Test folding of displacement: Begins with max(uint12).
 179 define void @f16(ptr %dest, i8 %val) {
 180 ; CHECK-LABEL: f16:
 181 ; CHECK-DAG: lay %r1, 4096(%r2)
 182 ; CHECK-DAG: stc %r3, 4095(%r2)
 183   %addr = getelementptr i8, ptr %dest, i64 4095
 184   call void @llvm.memset.p0.i64(ptr %addr, i8 %val, i64 256, i1 false)
 185   ret void
 186 }
 187
 188 ; Test folding of displacement with LA: First two ops are in range.
 189 define void @f17(ptr %dest, i8 %val) {
 190 ; CHECK-LABEL: f17:
 191 ; CHECK:      stc %r3, 3583(%r2)
 192 ; CHECK-NEXT: mvc 3584(255,%r2), 3583(%r2)
 193 ; CHECK-NEXT: stc %r3, 3839(%r2)
 194 ; CHECK-NEXT: mvc 3840(255,%r2), 3839(%r2)
 195 ; CHECK-NEXT: lay %r1, 4096(%r2)
 196 ; CHECK-NEXT: stc %r3, 4095(%r2)
 197 ; CHECK-NEXT: mvc 0(1,%r1), 4095(%r2)
 198 ; CHECK-NEXT: br %r14
 199   %addr = getelementptr i8, ptr %dest, i64 3583
 200   call void @llvm.memset.p0.i64(ptr %addr, i8 %val, i64 514, i1 false)
 201   ret void
 202 }
 203
 204 ; Test folding of displacement with LAY: First two ops are in range.
 205 define void @f18(ptr %dest, i8 %val) {
 206 ; CHECK-LABEL: f18:
 207 ; CHECK:      stc %r3, 3584(%r2)
 208 ; CHECK-NEXT: mvc 3585(255,%r2), 3584(%r2)
 209 ; CHECK-NEXT: stc %r3, 3840(%r2)
 210 ; CHECK-NEXT: mvc 3841(255,%r2), 3840(%r2)
 211 ; CHECK-NEXT: lay %r1, 4097(%r2)
 212 ; CHECK-NEXT: lay %r2, 4096(%r2)
 213 ; CHECK-NEXT: stc %r3, 0(%r2)
 214 ; CHECK-NEXT: mvc 0(1,%r1), 0(%r2)
 215 ; CHECK-NEXT: br %r14
 216   %addr = getelementptr i8, ptr %dest, i64 3584
 217   call void @llvm.memset.p0.i64(ptr %addr, i8 %val, i64 514, i1 false)
 218   ret void
 219 }
 220