test/Transforms/ScalarRepl/copy-aggregate.ll

   1 ; RUN: opt < %s -scalarrepl -S | FileCheck %s
   2 ; PR3290
   3 target datalayout = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64"
   4
   5 ;; Store of integer to whole alloca struct.
   6 define i32 @test1(i64 %V) nounwind {
   7 ; CHECK: test1
   8 ; CHECK-NOT: alloca
   9         %X = alloca {{i32, i32}}
  10         %Y = bitcast {{i32,i32}}* %X to i64*
  11         store i64 %V, i64* %Y
  12
  13         %A = getelementptr {{i32,i32}}* %X, i32 0, i32 0, i32 0
  14         %B = getelementptr {{i32,i32}}* %X, i32 0, i32 0, i32 1
  15         %a = load i32* %A
  16         %b = load i32* %B
  17         %c = add i32 %a, %b
  18         ret i32 %c
  19 }
  20
  21 ;; Store of integer to whole struct/array alloca.
  22 define float @test2(i128 %V) nounwind {
  23 ; CHECK: test2
  24 ; CHECK-NOT: alloca
  25         %X = alloca {[4 x float]}
  26         %Y = bitcast {[4 x float]}* %X to i128*
  27         store i128 %V, i128* %Y
  28
  29         %A = getelementptr {[4 x float]}* %X, i32 0, i32 0, i32 0
  30         %B = getelementptr {[4 x float]}* %X, i32 0, i32 0, i32 3
  31         %a = load float* %A
  32         %b = load float* %B
  33         %c = fadd float %a, %b
  34         ret float %c
  35 }
  36
  37 ;; Load of whole alloca struct as integer
  38 define i64 @test3(i32 %a, i32 %b) nounwind {
  39 ; CHECK: test3
  40 ; CHECK-NOT: alloca
  41         %X = alloca {{i32, i32}}
  42
  43         %A = getelementptr {{i32,i32}}* %X, i32 0, i32 0, i32 0
  44         %B = getelementptr {{i32,i32}}* %X, i32 0, i32 0, i32 1
  45         store i32 %a, i32* %A
  46         store i32 %b, i32* %B
  47
  48         %Y = bitcast {{i32,i32}}* %X to i64*
  49         %Z = load i64* %Y
  50         ret i64 %Z
  51 }
  52
  53 ;; load of integer from whole struct/array alloca.
  54 define i128 @test4(float %a, float %b) nounwind {
  55 ; CHECK: test4
  56 ; CHECK-NOT: alloca
  57         %X = alloca {[4 x float]}
  58         %A = getelementptr {[4 x float]}* %X, i32 0, i32 0, i32 0
  59         %B = getelementptr {[4 x float]}* %X, i32 0, i32 0, i32 3
  60         store float %a, float* %A
  61         store float %b, float* %B
  62
  63         %Y = bitcast {[4 x float]}* %X to i128*
  64         %V = load i128* %Y
  65         ret i128 %V
  66 }
  67
  68 ;; If the elements of a struct or array alloca contain padding, SROA can still
  69 ;; split up the alloca as long as there is no padding between the elements.
  70 %padded = type { i16, i8 }
  71 %arr = type [4 x %padded]
  72 define void @test5(%arr* %p, %arr* %q) {
  73 entry:
  74 ; CHECK: test5
  75 ; CHECK-NOT: i128
  76   %var = alloca %arr, align 4
  77   %vari8 = bitcast %arr* %var to i8*
  78   %pi8 = bitcast %arr* %p to i8*
  79   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %vari8, i8* %pi8, i32 16, i32 4, i1 false)
  80   %qi8 = bitcast %arr* %q to i8*
  81   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %qi8, i8* %vari8, i32 16, i32 4, i1 false)
  82   ret void
  83 }
  84
  85 ;; Check that an array alloca can be split up when it is also accessed with
  86 ;; a load or store as a homogeneous structure with the same element type and
  87 ;; number of elements as the array.
  88 %homogeneous = type { <8 x i16>, <8 x i16>, <8 x i16> }
  89 %wrapped_array = type { [3 x <8 x i16>] }
  90 define void @test6(i8* %p, %wrapped_array* %arr) {
  91 entry:
  92 ; CHECK: test6
  93 ; CHECK: store <8 x i16>
  94 ; CHECK: store <8 x i16>
  95 ; CHECK: store <8 x i16>
  96   %var = alloca %wrapped_array, align 16
  97   %res = call %homogeneous @test6callee(i8* %p)
  98   %varcast = bitcast %wrapped_array* %var to %homogeneous*
  99   store %homogeneous %res, %homogeneous* %varcast
 100   %tmp1 = bitcast %wrapped_array* %arr to i8*
 101   %tmp2 = bitcast %wrapped_array* %var to i8*
 102   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %tmp1, i8* %tmp2, i32 48, i32 16, i1 false)
 103   ret void
 104 }
 105
 106 declare %homogeneous @test6callee(i8* nocapture) nounwind
 107
 108 declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind