llvm/test/Transforms/MemCpyOpt/memcpy.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -passes=memcpyopt,dse -S -verify-memoryssa | FileCheck %s
   3
   4 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
   5 target triple = "i686-apple-darwin9"
   6
   7 %0 = type { x86_fp80, x86_fp80 }
   8 %1 = type { i32, i32 }
   9
  10 @C = external constant [0 x i8]
  11
  12 declare void @llvm.memcpy.p1.p0.i64(ptr addrspace(1) nocapture, ptr nocapture, i64, i1) nounwind
  13 declare void @llvm.memcpy.p0.p1.i64(ptr nocapture, ptr addrspace(1) nocapture, i64, i1) nounwind
  14 declare void @llvm.memcpy.p1.p1.i64(ptr addrspace(1) nocapture, ptr addrspace(1) nocapture, i64, i1) nounwind
  15 declare void @llvm.memcpy.p0.p0.i32(ptr nocapture, ptr nocapture, i32, i1) nounwind
  16 declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind
  17 declare void @llvm.memcpy.inline.p0.p0.i32(ptr nocapture, ptr nocapture, i32, i1) nounwind
  18 declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i1) nounwind
  19
  20 ; Check that one of the memcpy's are removed.
  21 ;; FIXME: PR 8643 We should be able to eliminate the last memcpy here.
  22 define void @test1(ptr sret(%0)  %agg.result, x86_fp80 %z.0, x86_fp80 %z.1) nounwind  {
  23 ; CHECK-LABEL: @test1(
  24 ; CHECK-NEXT:  entry:
  25 ; CHECK-NEXT:    [[TMP2:%.*]] = alloca [[TMP0:%.*]], align 16
  26 ; CHECK-NEXT:    [[MEMTMP:%.*]] = alloca [[TMP0]], align 16
  27 ; CHECK-NEXT:    [[TMP5:%.*]] = fsub x86_fp80 0xK80000000000000000000, [[Z_1:%.*]]
  28 ; CHECK-NEXT:    call void @ccoshl(ptr sret([[TMP0]]) [[TMP2]], x86_fp80 [[TMP5]], x86_fp80 [[Z_0:%.*]]) #[[ATTR2:[0-9]+]]
  29 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i32(ptr align 16 [[AGG_RESULT:%.*]], ptr align 16 [[TMP2]], i32 32, i1 false)
  30 ; CHECK-NEXT:    ret void
  31 ;
  32 entry:
  33   %tmp2 = alloca %0
  34   %memtmp = alloca %0, align 16
  35   %tmp5 = fsub x86_fp80 0xK80000000000000000000, %z.1
  36   call void @ccoshl(ptr sret(%0) %memtmp, x86_fp80 %tmp5, x86_fp80 %z.0) nounwind
  37   call void @llvm.memcpy.p0.p0.i32(ptr align 16 %tmp2, ptr align 16 %memtmp, i32 32, i1 false)
  38   call void @llvm.memcpy.p0.p0.i32(ptr align 16 %agg.result, ptr align 16 %tmp2, i32 32, i1 false)
  39   ret void
  40 }
  41
  42 declare void @ccoshl(ptr nocapture sret(%0), x86_fp80, x86_fp80) nounwind
  43
  44
  45 ; The intermediate alloca and one of the memcpy's should be eliminated, the
  46 ; other should be related with a memmove.
  47 define void @test2(ptr %P, ptr %Q) nounwind  {
  48 ; CHECK-LABEL: @test2(
  49 ; CHECK-NEXT:    call void @llvm.memmove.p0.p0.i32(ptr align 16 [[Q:%.*]], ptr align 16 [[P:%.*]], i32 32, i1 false)
  50 ; CHECK-NEXT:    ret void
  51 ;
  52   %memtmp = alloca %0, align 16
  53   call void @llvm.memcpy.p0.p0.i32(ptr align 16 %memtmp, ptr align 16 %P, i32 32, i1 false)
  54   call void @llvm.memcpy.p0.p0.i32(ptr align 16 %Q, ptr align 16 %memtmp, i32 32, i1 false)
  55   ret void
  56
  57 }
  58
  59 ; The intermediate alloca and one of the memcpy's should be eliminated, the
  60 ; other should be related with a memcpy.
  61 define void @test2_constant(ptr %Q) nounwind  {
  62 ; CHECK-LABEL: @test2_constant(
  63 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i32(ptr align 16 [[Q:%.*]], ptr align 16 @C, i32 32, i1 false)
  64 ; CHECK-NEXT:    ret void
  65 ;
  66   %memtmp = alloca %0, align 16
  67   call void @llvm.memcpy.p0.p0.i32(ptr align 16 %memtmp, ptr align 16 @C, i32 32, i1 false)
  68   call void @llvm.memcpy.p0.p0.i32(ptr align 16 %Q, ptr align 16 %memtmp, i32 32, i1 false)
  69   ret void
  70
  71 }
  72
  73 ; The intermediate alloca and one of the memcpy's should be eliminated, the
  74 ; other should be related with a memcpy.
  75 define void @test2_memcpy(ptr noalias %P, ptr noalias %Q) nounwind  {
  76 ; CHECK-LABEL: @test2_memcpy(
  77 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i32(ptr align 16 [[Q:%.*]], ptr align 16 [[P:%.*]], i32 32, i1 false)
  78 ; CHECK-NEXT:    ret void
  79 ;
  80   %memtmp = alloca %0, align 16
  81   call void @llvm.memcpy.p0.p0.i32(ptr align 16 %memtmp, ptr align 16 %P, i32 32, i1 false)
  82   call void @llvm.memcpy.p0.p0.i32(ptr align 16 %Q, ptr align 16 %memtmp, i32 32, i1 false)
  83   ret void
  84
  85 }
  86
  87 ; Same as @test2_memcpy, but the remaining memcpy should remain non-inline even
  88 ; if the one eliminated was inline.
  89 define void @test3_memcpy(ptr noalias %P, ptr noalias %Q) nounwind  {
  90 ; CHECK-LABEL: @test3_memcpy(
  91 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i32(ptr align 16 [[Q:%.*]], ptr align 16 [[P:%.*]], i32 32, i1 false)
  92 ; CHECK-NEXT:    ret void
  93 ;
  94   %memtmp = alloca %0, align 16
  95   call void @llvm.memcpy.inline.p0.p0.i32(ptr align 16 %memtmp, ptr align 16 %P, i32 32, i1 false)
  96   call void @llvm.memcpy.p0.p0.i32(ptr align 16 %Q, ptr align 16 %memtmp, i32 32, i1 false)
  97   ret void
  98
  99 }
 100
 101 ; Same as @test2_memcpy, but the remaining memcpy should remain inline even
 102 ; if the one eliminated was not inline.
 103 define void @test4_memcpy(ptr noalias %P, ptr noalias %Q) nounwind  {
 104 ; CHECK-LABEL: @test4_memcpy(
 105 ; CHECK-NEXT:    call void @llvm.memcpy.inline.p0.p0.i32(ptr align 16 [[Q:%.*]], ptr align 16 [[P:%.*]], i32 32, i1 false)
 106 ; CHECK-NEXT:    ret void
 107 ;
 108   %memtmp = alloca %0, align 16
 109   call void @llvm.memcpy.p0.p0.i32(ptr align 16 %memtmp, ptr align 16 %P, i32 32, i1 false)
 110   call void @llvm.memcpy.inline.p0.p0.i32(ptr align 16 %Q, ptr align 16 %memtmp, i32 32, i1 false)
 111   ret void
 112
 113 }
 114
 115 ; Same as @test2_memcpy, and the inline-ness should be preserved.
 116 define void @test5_memcpy(ptr noalias %P, ptr noalias %Q) nounwind  {
 117 ; CHECK-LABEL: @test5_memcpy(
 118 ; CHECK-NEXT:    call void @llvm.memcpy.inline.p0.p0.i32(ptr align 16 [[Q:%.*]], ptr align 16 [[P:%.*]], i32 32, i1 false)
 119 ; CHECK-NEXT:    ret void
 120 ;
 121   %memtmp = alloca %0, align 16
 122   call void @llvm.memcpy.inline.p0.p0.i32(ptr align 16 %memtmp, ptr align 16 %P, i32 32, i1 false)
 123   call void @llvm.memcpy.inline.p0.p0.i32(ptr align 16 %Q, ptr align 16 %memtmp, i32 32, i1 false)
 124   ret void
 125
 126 }
 127
 128 ; Similar to test5_memcpy, but without noalias; check that memcpy.inline is not folded into memmove.
 129 define void @test6_memcpy(ptr %src, ptr %dest) nounwind {
 130 ; CHECK-LABEL: @test6_memcpy(
 131 ; CHECK-NEXT:    [[TMP:%.*]] = alloca [16 x i8], align 1
 132 ; CHECK-NEXT:    call void @llvm.memcpy.inline.p0.p0.i32(ptr align 1 [[TMP]], ptr align 1 [[DEST:%.*]], i32 16, i1 false)
 133 ; CHECK-NEXT:    call void @llvm.memcpy.inline.p0.p0.i32(ptr align 1 [[DEST]], ptr align 1 [[TMP]], i32 16, i1 false)
 134 ; CHECK-NEXT:    ret void
 135 ;
 136   %tmp = alloca [16 x i8], align 1
 137   call void @llvm.memcpy.inline.p0.p0.i32(ptr align 1 %tmp, ptr align 1 %dest, i32 16, i1 false)
 138   call void @llvm.memcpy.inline.p0.p0.i32(ptr align 1 %dest, ptr align 1 %tmp, i32 16, i1 false)
 139   ret void
 140 }
 141
 142
 143 @x = external global %0
 144
 145 define void @test3(ptr noalias writable sret(%0) %agg.result) nounwind  {
 146 ; CHECK-LABEL: @test3(
 147 ; CHECK-NEXT:    [[X_0:%.*]] = alloca [[TMP0:%.*]], align 16
 148 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i32(ptr align 16 [[AGG_RESULT:%.*]], ptr align 16 @x, i32 32, i1 false)
 149 ; CHECK-NEXT:    ret void
 150 ;
 151   %x.0 = alloca %0
 152   call void @llvm.memcpy.p0.p0.i32(ptr align 16 %x.0, ptr align 16 @x, i32 32, i1 false)
 153   call void @llvm.memcpy.p0.p0.i32(ptr align 16 %agg.result, ptr align 16 %x.0, i32 32, i1 false)
 154   ret void
 155 }
 156
 157
 158 ; PR8644
 159 define void @test4(ptr %P) {
 160 ; CHECK-LABEL: @test4(
 161 ; CHECK-NEXT:    call void @test4a(ptr byval(i8) align 1 [[P:%.*]])
 162 ; CHECK-NEXT:    ret void
 163 ;
 164   %A = alloca %1
 165   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %A, ptr align 4 %P, i64 8, i1 false)
 166   call void @test4a(ptr align 1 byval(i8) %A)
 167   ret void
 168 }
 169
 170 ; Make sure we don't remove the memcpy if the source address space doesn't match the byval argument
 171 define void @test4_addrspace(ptr addrspace(1) %P) {
 172 ; CHECK-LABEL: @test4_addrspace(
 173 ; CHECK-NEXT:    [[A1:%.*]] = alloca [[TMP1:%.*]], align 8
 174 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p1.i64(ptr align 4 [[A1]], ptr addrspace(1) align 4 [[P:%.*]], i64 8, i1 false)
 175 ; CHECK-NEXT:    call void @test4a(ptr byval(i8) align 1 [[A1]])
 176 ; CHECK-NEXT:    ret void
 177 ;
 178   %a1 = alloca %1
 179   call void @llvm.memcpy.p0.p1.i64(ptr align 4 %a1, ptr addrspace(1) align 4 %P, i64 8, i1 false)
 180   call void @test4a(ptr align 1 byval(i8) %a1)
 181   ret void
 182 }
 183
 184 define void @test4_write_between(ptr %P) {
 185 ; CHECK-LABEL: @test4_write_between(
 186 ; CHECK-NEXT:    [[A1:%.*]] = alloca [[TMP1:%.*]], align 8
 187 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[A1]], ptr align 4 [[P:%.*]], i64 8, i1 false)
 188 ; CHECK-NEXT:    store i8 0, ptr [[A1]], align 1
 189 ; CHECK-NEXT:    call void @test4a(ptr byval(i8) align 1 [[A1]])
 190 ; CHECK-NEXT:    ret void
 191 ;
 192   %a1 = alloca %1
 193   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %a1, ptr align 4 %P, i64 8, i1 false)
 194   store i8 0, ptr %a1
 195   call void @test4a(ptr align 1 byval(i8) %a1)
 196   ret void
 197 }
 198
 199 define i8 @test4_read_between(ptr %P) {
 200 ; CHECK-LABEL: @test4_read_between(
 201 ; CHECK-NEXT:    [[A1:%.*]] = alloca [[TMP1:%.*]], align 8
 202 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[A1]], ptr align 4 [[P:%.*]], i64 8, i1 false)
 203 ; CHECK-NEXT:    [[X:%.*]] = load i8, ptr [[A1]], align 1
 204 ; CHECK-NEXT:    call void @test4a(ptr byval(i8) align 1 [[P]])
 205 ; CHECK-NEXT:    ret i8 [[X]]
 206 ;
 207   %a1 = alloca %1
 208   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %a1, ptr align 4 %P, i64 8, i1 false)
 209   %x = load i8, ptr %a1
 210   call void @test4a(ptr align 1 byval(i8) %a1)
 211   ret i8 %x
 212 }
 213
 214 define void @test4_non_local(ptr %P, i1 %c) {
 215 ; CHECK-LABEL: @test4_non_local(
 216 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[CALL:%.*]], label [[EXIT:%.*]]
 217 ; CHECK:       call:
 218 ; CHECK-NEXT:    call void @test4a(ptr byval(i8) align 1 [[P:%.*]])
 219 ; CHECK-NEXT:    br label [[EXIT]]
 220 ; CHECK:       exit:
 221 ; CHECK-NEXT:    ret void
 222 ;
 223   %a1 = alloca %1
 224   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %a1, ptr align 4 %P, i64 8, i1 false)
 225   br i1 %c, label %call, label %exit
 226
 227 call:
 228   call void @test4a(ptr align 1 byval(i8) %a1)
 229   br label %exit
 230
 231 exit:
 232   ret void
 233 }
 234
 235 declare void @test4a(ptr align 1 byval(i8))
 236
 237 %struct.S = type { i128, [4 x i8]}
 238
 239 @sS = external global %struct.S, align 16
 240
 241 declare void @test5a(ptr align 16 byval(%struct.S)) nounwind ssp
 242
 243
 244 ; rdar://8713376 - This memcpy can't be eliminated.
 245 define i32 @test5(i32 %x) nounwind ssp {
 246 ; CHECK-LABEL: @test5(
 247 ; CHECK-NEXT:  entry:
 248 ; CHECK-NEXT:    [[Y:%.*]] = alloca [[STRUCT_S:%.*]], align 16
 249 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr align 16 [[Y]], ptr align 16 @sS, i64 32, i1 false)
 250 ; CHECK-NEXT:    [[A:%.*]] = getelementptr [[STRUCT_S]], ptr [[Y]], i64 0, i32 1, i64 0
 251 ; CHECK-NEXT:    store i8 4, ptr [[A]], align 1
 252 ; CHECK-NEXT:    call void @test5a(ptr byval([[STRUCT_S]]) align 16 [[Y]])
 253 ; CHECK-NEXT:    ret i32 0
 254 ;
 255 entry:
 256   %y = alloca %struct.S, align 16
 257   call void @llvm.memcpy.p0.p0.i64(ptr align 16 %y, ptr align 16 @sS, i64 32, i1 false)
 258   %a = getelementptr %struct.S, ptr %y, i64 0, i32 1, i64 0
 259   store i8 4, ptr %a
 260   call void @test5a(ptr align 16 byval(%struct.S) %y)
 261   ret i32 0
 262 }
 263
 264 ;; Noop memcpy should be zapped.
 265 define void @test6(ptr %P) {
 266 ; CHECK-LABEL: @test6(
 267 ; CHECK-NEXT:    ret void
 268 ;
 269   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %P, ptr align 4 %P, i64 8, i1 false)
 270   ret void
 271 }
 272
 273
 274 ; PR9794 - Should forward memcpy into byval argument even though the memcpy
 275 ; isn't itself 8 byte aligned.
 276 %struct.p = type { i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }
 277
 278 define i32 @test7(ptr nocapture align 8 byval(%struct.p) %q) nounwind ssp {
 279 ; CHECK-LABEL: @test7(
 280 ; CHECK-NEXT:  entry:
 281 ; CHECK-NEXT:    [[CALL:%.*]] = call i32 @g(ptr byval([[STRUCT_P:%.*]]) align 8 [[Q:%.*]]) #[[ATTR2]]
 282 ; CHECK-NEXT:    ret i32 [[CALL]]
 283 ;
 284 entry:
 285   %agg.tmp = alloca %struct.p, align 4
 286   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %agg.tmp, ptr align 4 %q, i64 48, i1 false)
 287   %call = call i32 @g(ptr align 8 byval(%struct.p) %agg.tmp) nounwind
 288   ret i32 %call
 289 }
 290
 291 declare i32 @g(ptr align 8 byval(%struct.p))
 292
 293
 294 ; PR11142 - When looking for a memcpy-memcpy dependency, don't get stuck on
 295 ; instructions between the memcpy's that only affect the destination pointer.
 296 @test8.str = internal constant [7 x i8] c"ABCDEF\00"
 297
 298 define void @test8() {
 299 ; CHECK-LABEL: @test8(
 300 ; CHECK-NEXT:    ret void
 301 ;
 302   %A = tail call ptr @malloc(i32 10)
 303   %B = getelementptr inbounds i8, ptr %A, i64 2
 304   tail call void @llvm.memcpy.p0.p0.i32(ptr %B, ptr @test8.str, i32 7, i1 false)
 305   %C = tail call ptr @malloc(i32 10)
 306   %D = getelementptr inbounds i8, ptr %C, i64 2
 307   tail call void @llvm.memcpy.p0.p0.i32(ptr %D, ptr %B, i32 7, i1 false)
 308   ret void
 309 }
 310
 311 declare noalias ptr @malloc(i32) willreturn allockind("alloc,uninitialized") allocsize(0)
 312
 313 ; rdar://11341081
 314 %struct.big = type { [50 x i32] }
 315
 316 define void @test9_addrspacecast() nounwind ssp uwtable {
 317 ; CHECK-LABEL: @test9_addrspacecast(
 318 ; CHECK-NEXT:  entry:
 319 ; CHECK-NEXT:    [[B:%.*]] = alloca [[STRUCT_BIG:%.*]], align 4
 320 ; CHECK-NEXT:    [[TMP:%.*]] = alloca [[STRUCT_BIG]], align 4
 321 ; CHECK-NEXT:    call void @f1(ptr sret([[STRUCT_BIG]]) [[B]])
 322 ; CHECK-NEXT:    [[TMP0:%.*]] = addrspacecast ptr [[B]] to ptr addrspace(1)
 323 ; CHECK-NEXT:    [[TMP1:%.*]] = addrspacecast ptr [[TMP]] to ptr addrspace(1)
 324 ; CHECK-NEXT:    call void @f2(ptr [[B]])
 325 ; CHECK-NEXT:    ret void
 326 ;
 327 entry:
 328   %b = alloca %struct.big, align 4
 329   %tmp = alloca %struct.big, align 4
 330   call void @f1(ptr sret(%struct.big) %tmp)
 331   %0 = addrspacecast ptr %b to ptr addrspace(1)
 332   %1 = addrspacecast ptr %tmp to ptr addrspace(1)
 333   call void @llvm.memcpy.p1.p1.i64(ptr addrspace(1) align 4 %0, ptr addrspace(1) align 4 %1, i64 200, i1 false)
 334   call void @f2(ptr %b)
 335   ret void
 336 }
 337
 338 define void @test9() nounwind ssp uwtable {
 339 ; CHECK-LABEL: @test9(
 340 ; CHECK-NEXT:  entry:
 341 ; CHECK-NEXT:    [[B:%.*]] = alloca [[STRUCT_BIG:%.*]], align 4
 342 ; CHECK-NEXT:    [[TMP:%.*]] = alloca [[STRUCT_BIG]], align 4
 343 ; CHECK-NEXT:    call void @f1(ptr sret([[STRUCT_BIG]]) [[B]])
 344 ; CHECK-NEXT:    call void @f2(ptr [[B]])
 345 ; CHECK-NEXT:    ret void
 346 ;
 347 entry:
 348   %b = alloca %struct.big, align 4
 349   %tmp = alloca %struct.big, align 4
 350   call void @f1(ptr sret(%struct.big) %tmp)
 351   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %b, ptr align 4 %tmp, i64 200, i1 false)
 352   call void @f2(ptr %b)
 353   ret void
 354 }
 355
 356 ; rdar://14073661.
 357 ; Test10 triggered assertion when the compiler try to get the size of the
 358 ; opaque type of *x, where the x is the formal argument with attribute 'sret'.
 359
 360 %opaque = type opaque
 361 declare void @foo(ptr noalias nocapture)
 362
 363 define void @test10(ptr noalias nocapture sret(%opaque) %x, i32 %y) {
 364 ; CHECK-LABEL: @test10(
 365 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 366 ; CHECK-NEXT:    store i32 [[Y:%.*]], ptr [[A]], align 4
 367 ; CHECK-NEXT:    call void @foo(ptr noalias nocapture [[A]])
 368 ; CHECK-NEXT:    [[C:%.*]] = load i32, ptr [[A]], align 4
 369 ; CHECK-NEXT:    store i32 [[C]], ptr [[X:%.*]], align 4
 370 ; CHECK-NEXT:    ret void
 371 ;
 372   %a = alloca i32, align 4
 373   store i32 %y, ptr %a
 374   call void @foo(ptr noalias nocapture %a)
 375   %c = load i32, ptr %a
 376   store i32 %c, ptr %x
 377   ret void
 378 }
 379
 380 ; don't create new addressspacecasts when we don't know they're safe for the target
 381 define void @test11(ptr addrspace(1) nocapture dereferenceable(80) %P) {
 382 ; CHECK-LABEL: @test11(
 383 ; CHECK-NEXT:    call void @llvm.memset.p1.i64(ptr addrspace(1) align 4 [[P:%.*]], i8 0, i64 80, i1 false)
 384 ; CHECK-NEXT:    ret void
 385 ;
 386   %A = alloca [20 x i32], align 4
 387   call void @llvm.memset.p0.i64(ptr align 4 %A, i8 0, i64 80, i1 false)
 388   call void @llvm.memcpy.p1.p0.i64(ptr addrspace(1) align 4 %P, ptr align 4 %A, i64 80, i1 false)
 389   ret void
 390 }
 391
 392 declare void @f1(ptr nocapture sret(%struct.big))
 393 declare void @f2(ptr)
 394
 395 declare void @f(ptr)
 396 declare void @f_byval(ptr byval(i32))
 397 declare void @f_full_readonly(ptr nocapture noalias readonly)
 398
 399 define void @immut_param(ptr align 4 noalias %val) {
 400 ; CHECK-LABEL: @immut_param(
 401 ; CHECK-NEXT:    call void @f(ptr noalias nocapture readonly align 4 [[VAL:%.*]])
 402 ; CHECK-NEXT:    ret void
 403 ;
 404   %val1 = alloca i8, align 4
 405   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %val1, ptr align 4 %val, i64 1, i1 false)
 406   call void @f(ptr align 4 nocapture noalias readonly %val1)
 407   ret void
 408 }
 409
 410 ; Can't remove memcpy because dest may be captured.
 411 define void @immut_param_maycapture(ptr align 4 noalias %val) {
 412 ; CHECK-LABEL: @immut_param_maycapture(
 413 ; CHECK-NEXT:    [[VAL1:%.*]] = alloca i8, align 4
 414 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[VAL1]], ptr align 4 [[VAL:%.*]], i64 1, i1 false)
 415 ; CHECK-NEXT:    call void @f(ptr noalias readonly align 4 [[VAL1]])
 416 ; CHECK-NEXT:    ret void
 417 ;
 418   %val1 = alloca i8, align 4
 419   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %val1, ptr align 4 %val, i64 1, i1 false)
 420   call void @f(ptr align 4 noalias readonly %val1)
 421   ret void
 422 }
 423
 424 ; Can't remove memcpy because dest may be aliased.
 425 define void @immut_param_mayalias(ptr align 4 noalias %val) {
 426 ; CHECK-LABEL: @immut_param_mayalias(
 427 ; CHECK-NEXT:    [[VAL1:%.*]] = alloca i8, align 4
 428 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[VAL1]], ptr align 4 [[VAL:%.*]], i64 1, i1 false)
 429 ; CHECK-NEXT:    call void @f(ptr nocapture readonly align 4 [[VAL1]])
 430 ; CHECK-NEXT:    ret void
 431 ;
 432   %val1 = alloca i8, align 4
 433   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %val1, ptr align 4 %val, i64 1, i1 false)
 434   call void @f(ptr align 4 nocapture readonly %val1)
 435   ret void
 436 }
 437
 438 ; Can't remove memcpy because dest may be written.
 439 define void @immut_param_maywrite(ptr align 4 noalias %val) {
 440 ; CHECK-LABEL: @immut_param_maywrite(
 441 ; CHECK-NEXT:    [[VAL1:%.*]] = alloca i8, align 4
 442 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[VAL1]], ptr align 4 [[VAL:%.*]], i64 1, i1 false)
 443 ; CHECK-NEXT:    call void @f(ptr noalias nocapture align 4 [[VAL1]])
 444 ; CHECK-NEXT:    ret void
 445 ;
 446   %val1 = alloca i8, align 4
 447   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %val1, ptr align 4 %val, i64 1, i1 false)
 448   call void @f(ptr align 4 nocapture noalias %val1)
 449   ret void
 450 }
 451
 452 define void @immut_param_readonly(ptr align 4 noalias %val) {
 453 ; CHECK-LABEL: @immut_param_readonly(
 454 ; CHECK-NEXT:    call void @f_full_readonly(ptr align 4 [[VAL:%.*]])
 455 ; CHECK-NEXT:    ret void
 456 ;
 457   %val1 = alloca i8, align 4
 458   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %val1, ptr align 4 %val, i64 1, i1 false)
 459   call void @f_full_readonly(ptr align 4 %val1)
 460   ret void
 461 }
 462
 463 define void @immut_param_no_align(ptr align 4 noalias %val) {
 464 ; CHECK-LABEL: @immut_param_no_align(
 465 ; CHECK-NEXT:    call void @f(ptr noalias nocapture readonly [[VAL:%.*]])
 466 ; CHECK-NEXT:    ret void
 467 ;
 468   %val1 = alloca i8, align 4
 469   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %val1, ptr align 4 %val, i64 1, i1 false)
 470   call void @f(ptr nocapture noalias readonly %val1)
 471   ret void
 472 }
 473
 474 @gp = external constant [0 x i8]
 475 ; Can't remove memcpy because dest is not unescaped alloca, so cpying is meaningfull.
 476 define void @immut_param_global(ptr align 4 noalias %val) {
 477 ; CHECK-LABEL: @immut_param_global(
 478 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr align 4 @gp, ptr align 4 [[VAL:%.*]], i64 1, i1 false)
 479 ; CHECK-NEXT:    call void @f(ptr noalias nocapture readonly align 4 @gp)
 480 ; CHECK-NEXT:    ret void
 481 ;
 482   call void @llvm.memcpy.p0.p0.i64(ptr align 4 @gp, ptr align 4 %val, i64 1, i1 false)
 483   call void @f(ptr nocapture align 4 noalias readonly @gp)
 484   ret void
 485 }
 486
 487 ; Can't remove memcpy for VLA because of unknown size and alignment.
 488 define void @immut_param_vla(ptr align 4 noalias %val, i64 %n) {
 489 ; CHECK-LABEL: @immut_param_vla(
 490 ; CHECK-NEXT:    [[VAL1:%.*]] = alloca ptr, i64 [[N:%.*]], align 4
 491 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[VAL1]], ptr align 4 [[VAL:%.*]], i64 1, i1 false)
 492 ; CHECK-NEXT:    call void @f(ptr noalias nocapture readonly align 4 [[VAL1]])
 493 ; CHECK-NEXT:    ret void
 494 ;
 495   %val1 = alloca ptr, i64 %n
 496   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %val1, ptr align 4 %val, i64 1, i1 false)
 497   call void @f(ptr nocapture align 4 noalias readonly %val1)
 498   ret void
 499 }
 500
 501 ; Can't remove memcpy for scalable vector, because of memcpy size sufficiency is unknown
 502 define void @immut_param_scalable_vector(ptr align 4 noalias %val) {
 503 ; CHECK-LABEL: @immut_param_scalable_vector(
 504 ; CHECK-NEXT:    [[VAL1:%.*]] = alloca <vscale x 2 x i32>, align 8
 505 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[VAL1]], ptr align 4 [[VAL:%.*]], i64 2, i1 false)
 506 ; CHECK-NEXT:    call void @f(ptr noalias nocapture readonly align 4 [[VAL1]])
 507 ; CHECK-NEXT:    ret void
 508 ;
 509   %val1 = alloca <vscale x 2 x i32>
 510   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %val1, ptr align 4 %val, i64 2, i1 false)
 511   call void @f(ptr nocapture align 4 noalias readonly %val1)
 512   ret void
 513 }
 514
 515 ; Can't remove memcpy because dst is modified between call and memcpy
 516 define void @immut_param_modified_dst(ptr align 4 noalias %val) {
 517 ; CHECK-LABEL: @immut_param_modified_dst(
 518 ; CHECK-NEXT:    [[VAL1:%.*]] = alloca i8, align 4
 519 ; CHECK-NEXT:    store i32 13, ptr [[VAL1]], align 4
 520 ; CHECK-NEXT:    call void @f(ptr noalias nocapture readonly align 4 [[VAL1]])
 521 ; CHECK-NEXT:    ret void
 522 ;
 523   %val1 = alloca i8, align 4
 524   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %val1, ptr align 4 %val, i64 1, i1 false)
 525   store i32 13, ptr %val1
 526   call void @f(ptr nocapture align 4 noalias readonly %val1)
 527   ret void
 528 }
 529
 530 ; Can't remove memcpy because src is modified between call and memcpy
 531 define void @immut_param_modified_src(ptr align 4 noalias %val) {
 532 ; CHECK-LABEL: @immut_param_modified_src(
 533 ; CHECK-NEXT:    [[VAL1:%.*]] = alloca i8, align 4
 534 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[VAL1]], ptr align 4 [[VAL:%.*]], i64 1, i1 false)
 535 ; CHECK-NEXT:    store i32 13, ptr [[VAL]], align 4
 536 ; CHECK-NEXT:    call void @f(ptr noalias nocapture readonly align 4 [[VAL1]])
 537 ; CHECK-NEXT:    ret void
 538 ;
 539   %val1 = alloca i8, align 4
 540   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %val1, ptr align 4 %val, i64 1, i1 false)
 541   store i32 13, ptr %val
 542   call void @f(ptr nocapture align 4 noalias readonly %val1)
 543   ret void
 544 }
 545
 546 ; Can't remove memcpy because memcpy is volatile
 547 define void @immut_param_volatile(ptr align 4 noalias %val) {
 548 ; CHECK-LABEL: @immut_param_volatile(
 549 ; CHECK-NEXT:    [[VAL1:%.*]] = alloca i8, align 4
 550 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[VAL1]], ptr align 4 [[VAL:%.*]], i64 1, i1 true)
 551 ; CHECK-NEXT:    call void @f(ptr noalias nocapture readonly align 4 [[VAL1]])
 552 ; CHECK-NEXT:    ret void
 553 ;
 554   %val1 = alloca i8, align 4
 555   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %val1, ptr align 4 %val, i64 1, i1 true)
 556   call void @f(ptr nocapture align 4 noalias readonly %val1)
 557   ret void
 558 }
 559
 560 ; Can't remove memcpy because address spaces are different.
 561 define void @immut_param_different_addrespace(ptr addrspace(1) align 4 noalias %val) {
 562 ; CHECK-LABEL: @immut_param_different_addrespace(
 563 ; CHECK-NEXT:    [[VAL1:%.*]] = alloca i8, align 4
 564 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p1.i64(ptr align 4 [[VAL1]], ptr addrspace(1) align 4 [[VAL:%.*]], i64 1, i1 false)
 565 ; CHECK-NEXT:    call void @f(ptr noalias nocapture readonly align 4 [[VAL1]])
 566 ; CHECK-NEXT:    ret void
 567 ;
 568   %val1 = alloca i8, align 4
 569   call void @llvm.memcpy.p0.p1.i64(ptr align 4 %val1, ptr addrspace(1) align 4 %val, i64 1, i1 false)
 570   call void @f(ptr nocapture align 4 noalias readonly %val1)
 571   ret void
 572 }
 573
 574 define void @immut_param_bigger_align(ptr align 16 noalias %val) {
 575 ; CHECK-LABEL: @immut_param_bigger_align(
 576 ; CHECK-NEXT:    call void @f(ptr noalias nocapture readonly [[VAL:%.*]])
 577 ; CHECK-NEXT:    ret void
 578 ;
 579   %val1 = alloca i8, align 4
 580   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %val1, ptr %val, i64 1, i1 false)
 581   call void @f(ptr nocapture noalias readonly %val1)
 582   ret void
 583 }
 584
 585 ; Can't remove memcpy if we remove, the bigger alignment couldn't replaced by smaller one.
 586 define void @immut_param_smaller_align(ptr align 4 noalias %val) {
 587 ; CHECK-LABEL: @immut_param_smaller_align(
 588 ; CHECK-NEXT:    [[VAL1:%.*]] = alloca i8, align 16
 589 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr align 16 [[VAL1]], ptr [[VAL:%.*]], i64 1, i1 false)
 590 ; CHECK-NEXT:    call void @f(ptr noalias nocapture readonly [[VAL1]])
 591 ; CHECK-NEXT:    ret void
 592 ;
 593   %val1 = alloca i8, align 16
 594   call void @llvm.memcpy.p0.p0.i64(ptr align 16 %val1, ptr %val, i64 1, i1 false)
 595   call void @f(ptr nocapture noalias readonly %val1)
 596   ret void
 597 }
 598
 599 define void @immut_param_enforced_alignment() {
 600 ; CHECK-LABEL: @immut_param_enforced_alignment(
 601 ; CHECK-NEXT:    [[VAL:%.*]] = alloca i8, align 4
 602 ; CHECK-NEXT:    store i32 42, ptr [[VAL]], align 4
 603 ; CHECK-NEXT:    call void @f(ptr noalias nocapture readonly [[VAL]])
 604 ; CHECK-NEXT:    ret void
 605 ;
 606   %val = alloca i8, align 1
 607   store i32 42, ptr %val
 608   %val1 = alloca i8, align 4
 609   call void @llvm.memcpy.p0.p0.i64(ptr %val1, ptr %val, i64 1, i1 false)
 610   call void @f(ptr nocapture noalias readonly %val1)
 611   ret void
 612 }
 613
 614 ; Can't remove memcpy, because if the %val directly passed to @f,
 615 ; alignment of ptr to f's argument will be different.
 616 define void @immut_invalid_align_branched(i1 %c, ptr noalias %val) {
 617 ; CHECK-LABEL: @immut_invalid_align_branched(
 618 ; CHECK-NEXT:    [[VAL1:%.*]] = alloca [4 x i8], align 4
 619 ; CHECK-NEXT:    [[VAL2:%.*]] = alloca [16 x i8], align 16
 620 ; CHECK-NEXT:    [[VAL3:%.*]] = select i1 [[C:%.*]], ptr [[VAL1]], ptr [[VAL2]]
 621 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[VAL3]], ptr align 4 [[VAL:%.*]], i64 4, i1 false)
 622 ; CHECK-NEXT:    call void @f(ptr noalias nocapture readonly [[VAL3]])
 623 ; CHECK-NEXT:    ret void
 624 ;
 625   %val1 = alloca [4 x i8], align 4
 626   %val2 = alloca [16 x i8], align 16
 627   %val3 = select i1 %c, ptr %val1, ptr %val2
 628   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %val3, ptr align 4 %val, i64 4, i1 false)
 629   call void @f(ptr nocapture noalias readonly %val3)
 630   ret void
 631 }
 632
 633 ; Can't remove memcpy, because alias might modify the src.
 634 define void @immut_but_alias_src(ptr %val) {
 635 ; CHECK-LABEL: @immut_but_alias_src(
 636 ; CHECK-NEXT:    [[VAL1:%.*]] = alloca i8, align 4
 637 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[VAL1]], ptr align 4 [[VAL:%.*]], i64 1, i1 false)
 638 ; CHECK-NEXT:    call void @f(ptr noalias nocapture readonly [[VAL1]])
 639 ; CHECK-NEXT:    ret void
 640 ;
 641   %val1 = alloca i8, align 4
 642   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %val1, ptr align 4 %val, i64 1, i1 false)
 643   call void @f(ptr nocapture noalias readonly %val1)
 644   ret void
 645 }
 646
 647 define void @immut_unescaped_alloca() {
 648 ; CHECK-LABEL: @immut_unescaped_alloca(
 649 ; CHECK-NEXT:    [[VAL:%.*]] = alloca i8, align 4
 650 ; CHECK-NEXT:    store i32 42, ptr [[VAL]], align 4
 651 ; CHECK-NEXT:    call void @f_full_readonly(ptr [[VAL]])
 652 ; CHECK-NEXT:    ret void
 653 ;
 654   %val = alloca i8, align 4
 655   store i32 42, ptr %val
 656   %val1 = alloca i8, align 4
 657   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %val1, ptr align 4 %val, i64 1, i1 false)
 658   call void @f_full_readonly(ptr %val1)
 659   ret void
 660 }
 661
 662 ; Can't remove memcpy, because alloca src is modified
 663 define void @immut_unescaped_alloca_modified() {
 664 ; CHECK-LABEL: @immut_unescaped_alloca_modified(
 665 ; CHECK-NEXT:    [[VAL:%.*]] = alloca i8, align 4
 666 ; CHECK-NEXT:    store i32 42, ptr [[VAL]], align 4
 667 ; CHECK-NEXT:    [[VAL1:%.*]] = alloca i8, align 4
 668 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[VAL1]], ptr align 4 [[VAL]], i64 1, i1 false)
 669 ; CHECK-NEXT:    call void @f_full_readonly(ptr [[VAL1]])
 670 ; CHECK-NEXT:    ret void
 671 ;
 672   %val = alloca i8, align 4
 673   store i32 42, ptr %val
 674   %val1 = alloca i8, align 4
 675   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %val1, ptr align 4 %val, i64 1, i1 false)
 676   store i32 13, ptr %val
 677   call void @f_full_readonly(ptr %val1)
 678   ret void
 679 }
 680
 681 ; TODO: Remove memcpy
 682 define void @immut_valid_align_branched(i1 %c, ptr noalias align 4 %val) {
 683 ; CHECK-LABEL: @immut_valid_align_branched(
 684 ; CHECK-NEXT:    [[VAL1:%.*]] = alloca [4 x i8], align 4
 685 ; CHECK-NEXT:    [[VAL2:%.*]] = alloca [16 x i8], align 4
 686 ; CHECK-NEXT:    [[VAL3:%.*]] = select i1 [[C:%.*]], ptr [[VAL1]], ptr [[VAL2]]
 687 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[VAL3]], ptr align 4 [[VAL:%.*]], i64 4, i1 false)
 688 ; CHECK-NEXT:    call void @f(ptr noalias nocapture readonly [[VAL3]])
 689 ; CHECK-NEXT:    ret void
 690 ;
 691   %val1 = alloca [4 x i8], align 4
 692   %val2 = alloca [16 x i8], align 4
 693   %val3 = select i1 %c, ptr %val1, ptr %val2
 694   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %val3, ptr align 4 %val, i64 4, i1 false)
 695   call void @f(ptr nocapture noalias readonly %val3)
 696   ret void
 697 }
 698
 699 ; Merge/drop noalias metadata when replacing parameter.
 700 define void @immut_param_noalias_metadata(ptr align 4 byval(i32) %ptr) {
 701 ; CHECK-LABEL: @immut_param_noalias_metadata(
 702 ; CHECK-NEXT:    store i32 1, ptr [[PTR:%.*]], align 4, !noalias !0
 703 ; CHECK-NEXT:    call void @f(ptr noalias nocapture readonly [[PTR]])
 704 ; CHECK-NEXT:    ret void
 705 ;
 706   %tmp = alloca i32, align 4
 707   store i32 1, ptr %ptr, !noalias !2
 708   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %tmp, ptr align 4 %ptr, i64 4, i1 false)
 709   call void @f(ptr nocapture noalias readonly %tmp), !alias.scope !2
 710   ret void
 711 }
 712
 713 define void @byval_param_noalias_metadata(ptr align 4 byval(i32) %ptr) {
 714 ; CHECK-LABEL: @byval_param_noalias_metadata(
 715 ; CHECK-NEXT:    store i32 1, ptr [[PTR:%.*]], align 4, !noalias !0
 716 ; CHECK-NEXT:    call void @f_byval(ptr byval(i32) align 4 [[PTR]])
 717 ; CHECK-NEXT:    ret void
 718 ;
 719   %tmp = alloca i32, align 4
 720   store i32 1, ptr %ptr, !noalias !2
 721   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %tmp, ptr align 4 %ptr, i64 4, i1 false)
 722   call void @f_byval(ptr align 4 byval(i32) %tmp), !alias.scope !2
 723   ret void
 724 }
 725
 726 define void @memcpy_memory_none(ptr %p, ptr %p2, i64 %size) {
 727 ; CHECK-LABEL: @memcpy_memory_none(
 728 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr [[P:%.*]], ptr [[P2:%.*]], i64 [[SIZE:%.*]], i1 false) #[[ATTR6:[0-9]+]]
 729 ; CHECK-NEXT:    ret void
 730 ;
 731   call void @llvm.memcpy.p0.p0.i64(ptr %p, ptr %p2, i64 %size, i1 false) memory(none)
 732   ret void
 733 }
 734
 735 !0 = !{!0}
 736 !1 = !{!1, !0}
 737 !2 = !{!1}