test/Transforms/SROA/basictest.ll

   1 ; RUN: opt < %s -sroa -S | FileCheck %s
   2 ; RUN: opt < %s -sroa -force-ssa-updater -S | FileCheck %s
   3
   4 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-n8:16:32:64"
   5
   6 declare void @llvm.lifetime.start(i64, i8* nocapture)
   7 declare void @llvm.lifetime.end(i64, i8* nocapture)
   8
   9 define i32 @test0() {
  10 ; CHECK: @test0
  11 ; CHECK-NOT: alloca
  12 ; CHECK: ret i32
  13
  14 entry:
  15   %a1 = alloca i32
  16   %a2 = alloca float
  17
  18   %a1.i8 = bitcast i32* %a1 to i8*
  19   call void @llvm.lifetime.start(i64 4, i8* %a1.i8)
  20
  21   store i32 0, i32* %a1
  22   %v1 = load i32* %a1
  23
  24   call void @llvm.lifetime.end(i64 4, i8* %a1.i8)
  25
  26   %a2.i8 = bitcast float* %a2 to i8*
  27   call void @llvm.lifetime.start(i64 4, i8* %a2.i8)
  28
  29   store float 0.0, float* %a2
  30   %v2 = load float * %a2
  31   %v2.int = bitcast float %v2 to i32
  32   %sum1 = add i32 %v1, %v2.int
  33
  34   call void @llvm.lifetime.end(i64 4, i8* %a2.i8)
  35
  36   ret i32 %sum1
  37 }
  38
  39 define i32 @test1() {
  40 ; CHECK: @test1
  41 ; CHECK-NOT: alloca
  42 ; CHECK: ret i32 0
  43
  44 entry:
  45   %X = alloca { i32, float }
  46   %Y = getelementptr { i32, float }* %X, i64 0, i32 0
  47   store i32 0, i32* %Y
  48   %Z = load i32* %Y
  49   ret i32 %Z
  50 }
  51
  52 define i64 @test2(i64 %X) {
  53 ; CHECK: @test2
  54 ; CHECK-NOT: alloca
  55 ; CHECK: ret i64 %X
  56
  57 entry:
  58   %A = alloca [8 x i8]
  59   %B = bitcast [8 x i8]* %A to i64*
  60   store i64 %X, i64* %B
  61   br label %L2
  62
  63 L2:
  64   %Z = load i64* %B
  65   ret i64 %Z
  66 }
  67
  68 define void @test3(i8* %dst, i8* %src) {
  69 ; CHECK: @test3
  70
  71 entry:
  72   %a = alloca [300 x i8]
  73 ; CHECK-NOT:  alloca
  74 ; CHECK:      %[[test3_a1:.*]] = alloca [42 x i8]
  75 ; CHECK-NEXT: %[[test3_a2:.*]] = alloca [99 x i8]
  76 ; CHECK-NEXT: %[[test3_a3:.*]] = alloca [16 x i8]
  77 ; CHECK-NEXT: %[[test3_a4:.*]] = alloca [42 x i8]
  78 ; CHECK-NEXT: %[[test3_a5:.*]] = alloca [7 x i8]
  79 ; CHECK-NEXT: %[[test3_a6:.*]] = alloca [7 x i8]
  80 ; CHECK-NEXT: %[[test3_a7:.*]] = alloca [85 x i8]
  81
  82   %b = getelementptr [300 x i8]* %a, i64 0, i64 0
  83   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %b, i8* %src, i32 300, i32 1, i1 false)
  84 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [42 x i8]* %[[test3_a1]], i64 0, i64 0
  85 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %src, i32 42
  86 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %src, i64 42
  87 ; CHECK-NEXT: %[[test3_r1:.*]] = load i8* %[[gep]]
  88 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 43
  89 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [99 x i8]* %[[test3_a2]], i64 0, i64 0
  90 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 99
  91 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 142
  92 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [16 x i8]* %[[test3_a3]], i64 0, i64 0
  93 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 16
  94 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 158
  95 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [42 x i8]* %[[test3_a4]], i64 0, i64 0
  96 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 42
  97 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 200
  98 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a5]], i64 0, i64 0
  99 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
 100 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %src, i64 207
 101 ; CHECK-NEXT: %[[test3_r2:.*]] = load i8* %[[gep]]
 102 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 208
 103 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a6]], i64 0, i64 0
 104 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
 105 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 215
 106 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [85 x i8]* %[[test3_a7]], i64 0, i64 0
 107 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 85
 108
 109   ; Clobber a single element of the array, this should be promotable.
 110   %c = getelementptr [300 x i8]* %a, i64 0, i64 42
 111   store i8 0, i8* %c
 112
 113   ; Make a sequence of overlapping stores to the array. These overlap both in
 114   ; forward strides and in shrinking accesses.
 115   %overlap.1.i8 = getelementptr [300 x i8]* %a, i64 0, i64 142
 116   %overlap.2.i8 = getelementptr [300 x i8]* %a, i64 0, i64 143
 117   %overlap.3.i8 = getelementptr [300 x i8]* %a, i64 0, i64 144
 118   %overlap.4.i8 = getelementptr [300 x i8]* %a, i64 0, i64 145
 119   %overlap.5.i8 = getelementptr [300 x i8]* %a, i64 0, i64 146
 120   %overlap.6.i8 = getelementptr [300 x i8]* %a, i64 0, i64 147
 121   %overlap.7.i8 = getelementptr [300 x i8]* %a, i64 0, i64 148
 122   %overlap.8.i8 = getelementptr [300 x i8]* %a, i64 0, i64 149
 123   %overlap.9.i8 = getelementptr [300 x i8]* %a, i64 0, i64 150
 124   %overlap.1.i16 = bitcast i8* %overlap.1.i8 to i16*
 125   %overlap.1.i32 = bitcast i8* %overlap.1.i8 to i32*
 126   %overlap.1.i64 = bitcast i8* %overlap.1.i8 to i64*
 127   %overlap.2.i64 = bitcast i8* %overlap.2.i8 to i64*
 128   %overlap.3.i64 = bitcast i8* %overlap.3.i8 to i64*
 129   %overlap.4.i64 = bitcast i8* %overlap.4.i8 to i64*
 130   %overlap.5.i64 = bitcast i8* %overlap.5.i8 to i64*
 131   %overlap.6.i64 = bitcast i8* %overlap.6.i8 to i64*
 132   %overlap.7.i64 = bitcast i8* %overlap.7.i8 to i64*
 133   %overlap.8.i64 = bitcast i8* %overlap.8.i8 to i64*
 134   %overlap.9.i64 = bitcast i8* %overlap.9.i8 to i64*
 135   store i8 1, i8* %overlap.1.i8
 136 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [16 x i8]* %[[test3_a3]], i64 0, i64 0
 137 ; CHECK-NEXT: store i8 1, i8* %[[gep]]
 138   store i16 1, i16* %overlap.1.i16
 139 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast [16 x i8]* %[[test3_a3]] to i16*
 140 ; CHECK-NEXT: store i16 1, i16* %[[bitcast]]
 141   store i32 1, i32* %overlap.1.i32
 142 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast [16 x i8]* %[[test3_a3]] to i32*
 143 ; CHECK-NEXT: store i32 1, i32* %[[bitcast]]
 144   store i64 1, i64* %overlap.1.i64
 145 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast [16 x i8]* %[[test3_a3]] to i64*
 146 ; CHECK-NEXT: store i64 1, i64* %[[bitcast]]
 147   store i64 2, i64* %overlap.2.i64
 148 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [16 x i8]* %[[test3_a3]], i64 0, i64 1
 149 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i64*
 150 ; CHECK-NEXT: store i64 2, i64* %[[bitcast]]
 151   store i64 3, i64* %overlap.3.i64
 152 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [16 x i8]* %[[test3_a3]], i64 0, i64 2
 153 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i64*
 154 ; CHECK-NEXT: store i64 3, i64* %[[bitcast]]
 155   store i64 4, i64* %overlap.4.i64
 156 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [16 x i8]* %[[test3_a3]], i64 0, i64 3
 157 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i64*
 158 ; CHECK-NEXT: store i64 4, i64* %[[bitcast]]
 159   store i64 5, i64* %overlap.5.i64
 160 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [16 x i8]* %[[test3_a3]], i64 0, i64 4
 161 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i64*
 162 ; CHECK-NEXT: store i64 5, i64* %[[bitcast]]
 163   store i64 6, i64* %overlap.6.i64
 164 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [16 x i8]* %[[test3_a3]], i64 0, i64 5
 165 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i64*
 166 ; CHECK-NEXT: store i64 6, i64* %[[bitcast]]
 167   store i64 7, i64* %overlap.7.i64
 168 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [16 x i8]* %[[test3_a3]], i64 0, i64 6
 169 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i64*
 170 ; CHECK-NEXT: store i64 7, i64* %[[bitcast]]
 171   store i64 8, i64* %overlap.8.i64
 172 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [16 x i8]* %[[test3_a3]], i64 0, i64 7
 173 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i64*
 174 ; CHECK-NEXT: store i64 8, i64* %[[bitcast]]
 175   store i64 9, i64* %overlap.9.i64
 176 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [16 x i8]* %[[test3_a3]], i64 0, i64 8
 177 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i64*
 178 ; CHECK-NEXT: store i64 9, i64* %[[bitcast]]
 179
 180   ; Make two sequences of overlapping stores with more gaps and irregularities.
 181   %overlap2.1.0.i8 = getelementptr [300 x i8]* %a, i64 0, i64 200
 182   %overlap2.1.1.i8 = getelementptr [300 x i8]* %a, i64 0, i64 201
 183   %overlap2.1.2.i8 = getelementptr [300 x i8]* %a, i64 0, i64 202
 184   %overlap2.1.3.i8 = getelementptr [300 x i8]* %a, i64 0, i64 203
 185
 186   %overlap2.2.0.i8 = getelementptr [300 x i8]* %a, i64 0, i64 208
 187   %overlap2.2.1.i8 = getelementptr [300 x i8]* %a, i64 0, i64 209
 188   %overlap2.2.2.i8 = getelementptr [300 x i8]* %a, i64 0, i64 210
 189   %overlap2.2.3.i8 = getelementptr [300 x i8]* %a, i64 0, i64 211
 190
 191   %overlap2.1.0.i16 = bitcast i8* %overlap2.1.0.i8 to i16*
 192   %overlap2.1.0.i32 = bitcast i8* %overlap2.1.0.i8 to i32*
 193   %overlap2.1.1.i32 = bitcast i8* %overlap2.1.1.i8 to i32*
 194   %overlap2.1.2.i32 = bitcast i8* %overlap2.1.2.i8 to i32*
 195   %overlap2.1.3.i32 = bitcast i8* %overlap2.1.3.i8 to i32*
 196   store i8 1,  i8*  %overlap2.1.0.i8
 197 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a5]], i64 0, i64 0
 198 ; CHECK-NEXT: store i8 1, i8* %[[gep]]
 199   store i16 1, i16* %overlap2.1.0.i16
 200 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast [7 x i8]* %[[test3_a5]] to i16*
 201 ; CHECK-NEXT: store i16 1, i16* %[[bitcast]]
 202   store i32 1, i32* %overlap2.1.0.i32
 203 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast [7 x i8]* %[[test3_a5]] to i32*
 204 ; CHECK-NEXT: store i32 1, i32* %[[bitcast]]
 205   store i32 2, i32* %overlap2.1.1.i32
 206 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a5]], i64 0, i64 1
 207 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i32*
 208 ; CHECK-NEXT: store i32 2, i32* %[[bitcast]]
 209   store i32 3, i32* %overlap2.1.2.i32
 210 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a5]], i64 0, i64 2
 211 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i32*
 212 ; CHECK-NEXT: store i32 3, i32* %[[bitcast]]
 213   store i32 4, i32* %overlap2.1.3.i32
 214 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a5]], i64 0, i64 3
 215 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i32*
 216 ; CHECK-NEXT: store i32 4, i32* %[[bitcast]]
 217
 218   %overlap2.2.0.i32 = bitcast i8* %overlap2.2.0.i8 to i32*
 219   %overlap2.2.1.i16 = bitcast i8* %overlap2.2.1.i8 to i16*
 220   %overlap2.2.1.i32 = bitcast i8* %overlap2.2.1.i8 to i32*
 221   %overlap2.2.2.i32 = bitcast i8* %overlap2.2.2.i8 to i32*
 222   %overlap2.2.3.i32 = bitcast i8* %overlap2.2.3.i8 to i32*
 223   store i32 1, i32* %overlap2.2.0.i32
 224 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast [7 x i8]* %[[test3_a6]] to i32*
 225 ; CHECK-NEXT: store i32 1, i32* %[[bitcast]]
 226   store i8 1,  i8*  %overlap2.2.1.i8
 227 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a6]], i64 0, i64 1
 228 ; CHECK-NEXT: store i8 1, i8* %[[gep]]
 229   store i16 1, i16* %overlap2.2.1.i16
 230 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a6]], i64 0, i64 1
 231 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i16*
 232 ; CHECK-NEXT: store i16 1, i16* %[[bitcast]]
 233   store i32 1, i32* %overlap2.2.1.i32
 234 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a6]], i64 0, i64 1
 235 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i32*
 236 ; CHECK-NEXT: store i32 1, i32* %[[bitcast]]
 237   store i32 3, i32* %overlap2.2.2.i32
 238 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a6]], i64 0, i64 2
 239 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i32*
 240 ; CHECK-NEXT: store i32 3, i32* %[[bitcast]]
 241   store i32 4, i32* %overlap2.2.3.i32
 242 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a6]], i64 0, i64 3
 243 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i32*
 244 ; CHECK-NEXT: store i32 4, i32* %[[bitcast]]
 245
 246   %overlap2.prefix = getelementptr i8* %overlap2.1.1.i8, i64 -4
 247   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %overlap2.prefix, i8* %src, i32 8, i32 1, i1 false)
 248 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [42 x i8]* %[[test3_a4]], i64 0, i64 39
 249 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %src, i32 3
 250 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 3
 251 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a5]], i64 0, i64 0
 252 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 5
 253
 254   ; Bridge between the overlapping areas
 255   call void @llvm.memset.p0i8.i32(i8* %overlap2.1.2.i8, i8 42, i32 8, i32 1, i1 false)
 256 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a5]], i64 0, i64 2
 257 ; CHECK-NEXT: call void @llvm.memset.p0i8.i32(i8* %[[gep]], i8 42, i32 5
 258 ; ...promoted i8 store...
 259 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a6]], i64 0, i64 0
 260 ; CHECK-NEXT: call void @llvm.memset.p0i8.i32(i8* %[[gep]], i8 42, i32 2
 261
 262   ; Entirely within the second overlap.
 263   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %overlap2.2.1.i8, i8* %src, i32 5, i32 1, i1 false)
 264 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a6]], i64 0, i64 1
 265 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep]], i8* %src, i32 5
 266
 267   ; Trailing past the second overlap.
 268   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %overlap2.2.2.i8, i8* %src, i32 8, i32 1, i1 false)
 269 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a6]], i64 0, i64 2
 270 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep]], i8* %src, i32 5
 271 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 5
 272 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [85 x i8]* %[[test3_a7]], i64 0, i64 0
 273 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 3
 274
 275   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %b, i32 300, i32 1, i1 false)
 276 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [42 x i8]* %[[test3_a1]], i64 0, i64 0
 277 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %[[gep]], i32 42
 278 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %dst, i64 42
 279 ; CHECK-NEXT: store i8 0, i8* %[[gep]]
 280 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds i8* %dst, i64 43
 281 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [99 x i8]* %[[test3_a2]], i64 0, i64 0
 282 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 99
 283 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds i8* %dst, i64 142
 284 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [16 x i8]* %[[test3_a3]], i64 0, i64 0
 285 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 16
 286 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds i8* %dst, i64 158
 287 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [42 x i8]* %[[test3_a4]], i64 0, i64 0
 288 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 42
 289 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds i8* %dst, i64 200
 290 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a5]], i64 0, i64 0
 291 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
 292 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %dst, i64 207
 293 ; CHECK-NEXT: store i8 42, i8* %[[gep]]
 294 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds i8* %dst, i64 208
 295 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a6]], i64 0, i64 0
 296 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
 297 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds i8* %dst, i64 215
 298 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [85 x i8]* %[[test3_a7]], i64 0, i64 0
 299 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 85
 300
 301   ret void
 302 }
 303
 304 define void @test4(i8* %dst, i8* %src) {
 305 ; CHECK: @test4
 306
 307 entry:
 308   %a = alloca [100 x i8]
 309 ; CHECK-NOT:  alloca
 310 ; CHECK:      %[[test4_a1:.*]] = alloca [20 x i8]
 311 ; CHECK-NEXT: %[[test4_a2:.*]] = alloca [7 x i8]
 312 ; CHECK-NEXT: %[[test4_a3:.*]] = alloca [10 x i8]
 313 ; CHECK-NEXT: %[[test4_a4:.*]] = alloca [7 x i8]
 314 ; CHECK-NEXT: %[[test4_a5:.*]] = alloca [7 x i8]
 315 ; CHECK-NEXT: %[[test4_a6:.*]] = alloca [40 x i8]
 316
 317   %b = getelementptr [100 x i8]* %a, i64 0, i64 0
 318   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %b, i8* %src, i32 100, i32 1, i1 false)
 319 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [20 x i8]* %[[test4_a1]], i64 0, i64 0
 320 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep]], i8* %src, i32 20
 321 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %src, i64 20
 322 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i16*
 323 ; CHECK-NEXT: %[[test4_r1:.*]] = load i16* %[[bitcast]]
 324 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %src, i64 22
 325 ; CHECK-NEXT: %[[test4_r2:.*]] = load i8* %[[gep]]
 326 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 23
 327 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [7 x i8]* %[[test4_a2]], i64 0, i64 0
 328 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
 329 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 30
 330 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [10 x i8]* %[[test4_a3]], i64 0, i64 0
 331 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 10
 332 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %src, i64 40
 333 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i16*
 334 ; CHECK-NEXT: %[[test4_r3:.*]] = load i16* %[[bitcast]]
 335 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %src, i64 42
 336 ; CHECK-NEXT: %[[test4_r4:.*]] = load i8* %[[gep]]
 337 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 43
 338 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [7 x i8]* %[[test4_a4]], i64 0, i64 0
 339 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
 340 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %src, i64 50
 341 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i16*
 342 ; CHECK-NEXT: %[[test4_r5:.*]] = load i16* %[[bitcast]]
 343 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %src, i64 52
 344 ; CHECK-NEXT: %[[test4_r6:.*]] = load i8* %[[gep]]
 345 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 53
 346 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [7 x i8]* %[[test4_a5]], i64 0, i64 0
 347 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
 348 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 60
 349 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [40 x i8]* %[[test4_a6]], i64 0, i64 0
 350 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 40
 351
 352   %a.src.1 = getelementptr [100 x i8]* %a, i64 0, i64 20
 353   %a.dst.1 = getelementptr [100 x i8]* %a, i64 0, i64 40
 354   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a.dst.1, i8* %a.src.1, i32 10, i32 1, i1 false)
 355 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [7 x i8]* %[[test4_a4]], i64 0, i64 0
 356 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [7 x i8]* %[[test4_a2]], i64 0, i64 0
 357 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
 358
 359   ; Clobber a single element of the array, this should be promotable, and be deleted.
 360   %c = getelementptr [100 x i8]* %a, i64 0, i64 42
 361   store i8 0, i8* %c
 362
 363   %a.src.2 = getelementptr [100 x i8]* %a, i64 0, i64 50
 364   call void @llvm.memmove.p0i8.p0i8.i32(i8* %a.dst.1, i8* %a.src.2, i32 10, i32 1, i1 false)
 365 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [7 x i8]* %[[test4_a4]], i64 0, i64 0
 366 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [7 x i8]* %[[test4_a5]], i64 0, i64 0
 367 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
 368
 369   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %b, i32 100, i32 1, i1 false)
 370 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [20 x i8]* %[[test4_a1]], i64 0, i64 0
 371 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %[[gep]], i32 20
 372 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %dst, i64 20
 373 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i16*
 374 ; CHECK-NEXT: store i16 %[[test4_r1]], i16* %[[bitcast]]
 375 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %dst, i64 22
 376 ; CHECK-NEXT: store i8 %[[test4_r2]], i8* %[[gep]]
 377 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds i8* %dst, i64 23
 378 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [7 x i8]* %[[test4_a2]], i64 0, i64 0
 379 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
 380 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds i8* %dst, i64 30
 381 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [10 x i8]* %[[test4_a3]], i64 0, i64 0
 382 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 10
 383 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %dst, i64 40
 384 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i16*
 385 ; CHECK-NEXT: store i16 %[[test4_r5]], i16* %[[bitcast]]
 386 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %dst, i64 42
 387 ; CHECK-NEXT: store i8 %[[test4_r6]], i8* %[[gep]]
 388 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds i8* %dst, i64 43
 389 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [7 x i8]* %[[test4_a4]], i64 0, i64 0
 390 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
 391 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %dst, i64 50
 392 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i16*
 393 ; CHECK-NEXT: store i16 %[[test4_r5]], i16* %[[bitcast]]
 394 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %dst, i64 52
 395 ; CHECK-NEXT: store i8 %[[test4_r6]], i8* %[[gep]]
 396 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds i8* %dst, i64 53
 397 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [7 x i8]* %[[test4_a5]], i64 0, i64 0
 398 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
 399 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds i8* %dst, i64 60
 400 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [40 x i8]* %[[test4_a6]], i64 0, i64 0
 401 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 40
 402
 403   ret void
 404 }
 405
 406 declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind
 407 declare void @llvm.memmove.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind
 408 declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i32, i1) nounwind
 409
 410 define i16 @test5() {
 411 ; CHECK: @test5
 412 ; CHECK: alloca float
 413 ; CHECK: ret i16 %
 414
 415 entry:
 416   %a = alloca [4 x i8]
 417   %fptr = bitcast [4 x i8]* %a to float*
 418   store float 0.0, float* %fptr
 419   %ptr = getelementptr [4 x i8]* %a, i32 0, i32 2
 420   %iptr = bitcast i8* %ptr to i16*
 421   %val = load i16* %iptr
 422   ret i16 %val
 423 }
 424
 425 define i32 @test6() {
 426 ; CHECK: @test6
 427 ; CHECK: alloca i32
 428 ; CHECK-NEXT: store volatile i32
 429 ; CHECK-NEXT: load i32*
 430 ; CHECK-NEXT: ret i32
 431
 432 entry:
 433   %a = alloca [4 x i8]
 434   %ptr = getelementptr [4 x i8]* %a, i32 0, i32 0
 435   call void @llvm.memset.p0i8.i32(i8* %ptr, i8 42, i32 4, i32 1, i1 true)
 436   %iptr = bitcast i8* %ptr to i32*
 437   %val = load i32* %iptr
 438   ret i32 %val
 439 }
 440
 441 define void @test7(i8* %src, i8* %dst) {
 442 ; CHECK: @test7
 443 ; CHECK: alloca i32
 444 ; CHECK-NEXT: bitcast i8* %src to i32*
 445 ; CHECK-NEXT: load volatile i32*
 446 ; CHECK-NEXT: store volatile i32
 447 ; CHECK-NEXT: bitcast i8* %dst to i32*
 448 ; CHECK-NEXT: load volatile i32*
 449 ; CHECK-NEXT: store volatile i32
 450 ; CHECK-NEXT: ret
 451
 452 entry:
 453   %a = alloca [4 x i8]
 454   %ptr = getelementptr [4 x i8]* %a, i32 0, i32 0
 455   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %src, i32 4, i32 1, i1 true)
 456   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr, i32 4, i32 1, i1 true)
 457   ret void
 458 }
 459
 460
 461 %S1 = type { i32, i32, [16 x i8] }
 462 %S2 = type { %S1*, %S2* }
 463
 464 define %S2 @test8(%S2* %s2) {
 465 ; CHECK: @test8
 466 entry:
 467   %new = alloca %S2
 468 ; CHECK-NOT: alloca
 469
 470   %s2.next.ptr = getelementptr %S2* %s2, i64 0, i32 1
 471   %s2.next = load %S2** %s2.next.ptr
 472 ; CHECK:      %[[gep:.*]] = getelementptr %S2* %s2, i64 0, i32 1
 473 ; CHECK-NEXT: %[[next:.*]] = load %S2** %[[gep]]
 474
 475   %s2.next.s1.ptr = getelementptr %S2* %s2.next, i64 0, i32 0
 476   %s2.next.s1 = load %S1** %s2.next.s1.ptr
 477   %new.s1.ptr = getelementptr %S2* %new, i64 0, i32 0
 478   store %S1* %s2.next.s1, %S1** %new.s1.ptr
 479   %s2.next.next.ptr = getelementptr %S2* %s2.next, i64 0, i32 1
 480   %s2.next.next = load %S2** %s2.next.next.ptr
 481   %new.next.ptr = getelementptr %S2* %new, i64 0, i32 1
 482   store %S2* %s2.next.next, %S2** %new.next.ptr
 483 ; CHECK-NEXT: %[[gep:.*]] = getelementptr %S2* %[[next]], i64 0, i32 0
 484 ; CHECK-NEXT: %[[next_s1:.*]] = load %S1** %[[gep]]
 485 ; CHECK-NEXT: %[[gep:.*]] = getelementptr %S2* %[[next]], i64 0, i32 1
 486 ; CHECK-NEXT: %[[next_next:.*]] = load %S2** %[[gep]]
 487
 488   %new.s1 = load %S1** %new.s1.ptr
 489   %result1 = insertvalue %S2 undef, %S1* %new.s1, 0
 490 ; CHECK-NEXT: %[[result1:.*]] = insertvalue %S2 undef, %S1* %[[next_s1]], 0
 491   %new.next = load %S2** %new.next.ptr
 492   %result2 = insertvalue %S2 %result1, %S2* %new.next, 1
 493 ; CHECK-NEXT: %[[result2:.*]] = insertvalue %S2 %[[result1]], %S2* %[[next_next]], 1
 494   ret %S2 %result2
 495 ; CHECK-NEXT: ret %S2 %[[result2]]
 496 }
 497
 498 define i64 @test9() {
 499 ; Ensure we can handle loads off the end of an alloca even when wrapped in
 500 ; weird bit casts and types. The result is undef, but this shouldn't crash
 501 ; anything.
 502 ; CHECK: @test9
 503 ; CHECK-NOT: alloca
 504 ; CHECK: ret i64 undef
 505
 506 entry:
 507   %a = alloca { [3 x i8] }
 508   %gep1 = getelementptr inbounds { [3 x i8] }* %a, i32 0, i32 0, i32 0
 509   store i8 0, i8* %gep1, align 1
 510   %gep2 = getelementptr inbounds { [3 x i8] }* %a, i32 0, i32 0, i32 1
 511   store i8 0, i8* %gep2, align 1
 512   %gep3 = getelementptr inbounds { [3 x i8] }* %a, i32 0, i32 0, i32 2
 513   store i8 26, i8* %gep3, align 1
 514   %cast = bitcast { [3 x i8] }* %a to { i64 }*
 515   %elt = getelementptr inbounds { i64 }* %cast, i32 0, i32 0
 516   %result = load i64* %elt
 517   ret i64 %result
 518 }
 519
 520 define %S2* @test10() {
 521 ; CHECK: @test10
 522 ; CHECK-NOT: alloca %S2*
 523 ; CHECK: ret %S2* null
 524
 525 entry:
 526   %a = alloca [8 x i8]
 527   %ptr = getelementptr [8 x i8]* %a, i32 0, i32 0
 528   call void @llvm.memset.p0i8.i32(i8* %ptr, i8 0, i32 8, i32 1, i1 false)
 529   %s2ptrptr = bitcast i8* %ptr to %S2**
 530   %s2ptr = load %S2** %s2ptrptr
 531   ret %S2* %s2ptr
 532 }
 533
 534 define i32 @test11() {
 535 ; CHECK: @test11
 536 ; CHECK-NOT: alloca
 537 ; CHECK: ret i32 0
 538
 539 entry:
 540   %X = alloca i32
 541   br i1 undef, label %good, label %bad
 542
 543 good:
 544   %Y = getelementptr i32* %X, i64 0
 545   store i32 0, i32* %Y
 546   %Z = load i32* %Y
 547   ret i32 %Z
 548
 549 bad:
 550   %Y2 = getelementptr i32* %X, i64 1
 551   store i32 0, i32* %Y2
 552   %Z2 = load i32* %Y2
 553   ret i32 %Z2
 554 }
 555
 556 define i8 @test12() {
 557 ; We fully promote these to the i24 load or store size, resulting in just masks
 558 ; and other operations that instcombine will fold, but no alloca.
 559 ;
 560 ; CHECK: @test12
 561
 562 entry:
 563   %a = alloca [3 x i8]
 564   %b = alloca [3 x i8]
 565 ; CHECK-NOT: alloca
 566
 567   %a0ptr = getelementptr [3 x i8]* %a, i64 0, i32 0
 568   store i8 0, i8* %a0ptr
 569   %a1ptr = getelementptr [3 x i8]* %a, i64 0, i32 1
 570   store i8 0, i8* %a1ptr
 571   %a2ptr = getelementptr [3 x i8]* %a, i64 0, i32 2
 572   store i8 0, i8* %a2ptr
 573   %aiptr = bitcast [3 x i8]* %a to i24*
 574   %ai = load i24* %aiptr
 575 ; CHCEK-NOT: store
 576 ; CHCEK-NOT: load
 577 ; CHECK:      %[[mask0:.*]] = and i24 undef, -256
 578 ; CHECK-NEXT: %[[mask1:.*]] = and i24 %[[mask0]], -65281
 579 ; CHECK-NEXT: %[[mask2:.*]] = and i24 %[[mask1]], 65535
 580
 581   %biptr = bitcast [3 x i8]* %b to i24*
 582   store i24 %ai, i24* %biptr
 583   %b0ptr = getelementptr [3 x i8]* %b, i64 0, i32 0
 584   %b0 = load i8* %b0ptr
 585   %b1ptr = getelementptr [3 x i8]* %b, i64 0, i32 1
 586   %b1 = load i8* %b1ptr
 587   %b2ptr = getelementptr [3 x i8]* %b, i64 0, i32 2
 588   %b2 = load i8* %b2ptr
 589 ; CHCEK-NOT: store
 590 ; CHCEK-NOT: load
 591 ; CHECK:      %[[trunc0:.*]] = trunc i24 %[[mask2]] to i8
 592 ; CHECK-NEXT: %[[shift1:.*]] = lshr i24 %[[mask2]], 8
 593 ; CHECK-NEXT: %[[trunc1:.*]] = trunc i24 %[[shift1]] to i8
 594 ; CHECK-NEXT: %[[shift2:.*]] = lshr i24 %[[mask2]], 16
 595 ; CHECK-NEXT: %[[trunc2:.*]] = trunc i24 %[[shift2]] to i8
 596
 597   %bsum0 = add i8 %b0, %b1
 598   %bsum1 = add i8 %bsum0, %b2
 599   ret i8 %bsum1
 600 ; CHECK:      %[[sum0:.*]] = add i8 %[[trunc0]], %[[trunc1]]
 601 ; CHECK-NEXT: %[[sum1:.*]] = add i8 %[[sum0]], %[[trunc2]]
 602 ; CHECK-NEXT: ret i8 %[[sum1]]
 603 }
 604
 605 define i32 @test13() {
 606 ; Ensure we don't crash and handle undefined loads that straddle the end of the
 607 ; allocation.
 608 ; CHECK: @test13
 609 ; CHECK: %[[ret:.*]] = zext i16 undef to i32
 610 ; CHECK: ret i32 %[[ret]]
 611
 612 entry:
 613   %a = alloca [3 x i8]
 614   %b0ptr = getelementptr [3 x i8]* %a, i64 0, i32 0
 615   store i8 0, i8* %b0ptr
 616   %b1ptr = getelementptr [3 x i8]* %a, i64 0, i32 1
 617   store i8 0, i8* %b1ptr
 618   %b2ptr = getelementptr [3 x i8]* %a, i64 0, i32 2
 619   store i8 0, i8* %b2ptr
 620   %iptrcast = bitcast [3 x i8]* %a to i16*
 621   %iptrgep = getelementptr i16* %iptrcast, i64 1
 622   %i = load i16* %iptrgep
 623   %ret = zext i16 %i to i32
 624   ret i32 %ret
 625 }
 626
 627 %test14.struct = type { [3 x i32] }
 628
 629 define void @test14(...) nounwind uwtable {
 630 ; This is a strange case where we split allocas into promotable partitions, but
 631 ; also gain enough data to prove they must be dead allocas due to GEPs that walk
 632 ; across two adjacent allocas. Test that we don't try to promote or otherwise
 633 ; do bad things to these dead allocas, they should just be removed.
 634 ; CHECK: @test14
 635 ; CHECK-NEXT: entry:
 636 ; CHECK-NEXT: ret void
 637
 638 entry:
 639   %a = alloca %test14.struct
 640   %p = alloca %test14.struct*
 641   %0 = bitcast %test14.struct* %a to i8*
 642   %1 = getelementptr i8* %0, i64 12
 643   %2 = bitcast i8* %1 to %test14.struct*
 644   %3 = getelementptr inbounds %test14.struct* %2, i32 0, i32 0
 645   %4 = getelementptr inbounds %test14.struct* %a, i32 0, i32 0
 646   %5 = bitcast [3 x i32]* %3 to i32*
 647   %6 = bitcast [3 x i32]* %4 to i32*
 648   %7 = load i32* %6, align 4
 649   store i32 %7, i32* %5, align 4
 650   %8 = getelementptr inbounds i32* %5, i32 1
 651   %9 = getelementptr inbounds i32* %6, i32 1
 652   %10 = load i32* %9, align 4
 653   store i32 %10, i32* %8, align 4
 654   %11 = getelementptr inbounds i32* %5, i32 2
 655   %12 = getelementptr inbounds i32* %6, i32 2
 656   %13 = load i32* %12, align 4
 657   store i32 %13, i32* %11, align 4
 658   ret void
 659 }
 660
 661 define i32 @test15(i1 %flag) nounwind uwtable {
 662 ; Ensure that when there are dead instructions using an alloca that are not
 663 ; loads or stores we still delete them during partitioning and rewriting.
 664 ; Otherwise we'll go to promote them while thy still have unpromotable uses.
 665 ; CHECK: @test15
 666 ; CHECK-NEXT: entry:
 667 ; CHECK-NEXT:   br label %loop
 668 ; CHECK:      loop:
 669 ; CHECK-NEXT:   br label %loop
 670
 671 entry:
 672   %l0 = alloca i64
 673   %l1 = alloca i64
 674   %l2 = alloca i64
 675   %l3 = alloca i64
 676   br label %loop
 677
 678 loop:
 679   %dead3 = phi i8* [ %gep3, %loop ], [ null, %entry ]
 680
 681   store i64 1879048192, i64* %l0, align 8
 682   %bc0 = bitcast i64* %l0 to i8*
 683   %gep0 = getelementptr i8* %bc0, i64 3
 684   %dead0 = bitcast i8* %gep0 to i64*
 685
 686   store i64 1879048192, i64* %l1, align 8
 687   %bc1 = bitcast i64* %l1 to i8*
 688   %gep1 = getelementptr i8* %bc1, i64 3
 689   %dead1 = getelementptr i8* %gep1, i64 1
 690
 691   store i64 1879048192, i64* %l2, align 8
 692   %bc2 = bitcast i64* %l2 to i8*
 693   %gep2.1 = getelementptr i8* %bc2, i64 1
 694   %gep2.2 = getelementptr i8* %bc2, i64 3
 695   ; Note that this select should get visited multiple times due to using two
 696   ; different GEPs off the same alloca. We should only delete it once.
 697   %dead2 = select i1 %flag, i8* %gep2.1, i8* %gep2.2
 698
 699   store i64 1879048192, i64* %l3, align 8
 700   %bc3 = bitcast i64* %l3 to i8*
 701   %gep3 = getelementptr i8* %bc3, i64 3
 702
 703   br label %loop
 704 }
 705
 706 define void @test16(i8* %src, i8* %dst) {
 707 ; Ensure that we can promote an alloca of [3 x i8] to an i24 SSA value.
 708 ; CHECK: @test16
 709 ; CHECK-NOT: alloca
 710 ; CHECK:      %[[srccast:.*]] = bitcast i8* %src to i24*
 711 ; CHECK-NEXT: load i24* %[[srccast]]
 712 ; CHECK-NEXT: %[[dstcast:.*]] = bitcast i8* %dst to i24*
 713 ; CHECK-NEXT: store i24 0, i24* %[[dstcast]]
 714 ; CHECK-NEXT: ret void
 715
 716 entry:
 717   %a = alloca [3 x i8]
 718   %ptr = getelementptr [3 x i8]* %a, i32 0, i32 0
 719   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %src, i32 4, i32 1, i1 false)
 720   %cast = bitcast i8* %ptr to i24*
 721   store i24 0, i24* %cast
 722   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr, i32 4, i32 1, i1 false)
 723   ret void
 724 }
 725
 726 define void @test17(i8* %src, i8* %dst) {
 727 ; Ensure that we can rewrite unpromotable memcpys which extend past the end of
 728 ; the alloca.
 729 ; CHECK: @test17
 730 ; CHECK:      %[[a:.*]] = alloca [3 x i8]
 731 ; CHECK-NEXT: %[[ptr:.*]] = getelementptr [3 x i8]* %[[a]], i32 0, i32 0
 732 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[ptr]], i8* %src,
 733 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %[[ptr]],
 734 ; CHECK-NEXT: ret void
 735
 736 entry:
 737   %a = alloca [3 x i8]
 738   %ptr = getelementptr [3 x i8]* %a, i32 0, i32 0
 739   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %src, i32 4, i32 1, i1 true)
 740   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr, i32 4, i32 1, i1 true)
 741   ret void
 742 }
 743
 744 define void @test18(i8* %src, i8* %dst, i32 %size) {
 745 ; Preserve transfer instrinsics with a variable size, even if they overlap with
 746 ; fixed size operations. Further, continue to split and promote allocas preceding
 747 ; the variable sized intrinsic.
 748 ; CHECK: @test18
 749 ; CHECK:      %[[a:.*]] = alloca [34 x i8]
 750 ; CHECK:      %[[srcgep1:.*]] = getelementptr inbounds i8* %src, i64 4
 751 ; CHECK-NEXT: %[[srccast1:.*]] = bitcast i8* %[[srcgep1]] to i32*
 752 ; CHECK-NEXT: %[[srcload:.*]] = load i32* %[[srccast1]]
 753 ; CHECK-NEXT: %[[agep1:.*]] = getelementptr inbounds [34 x i8]* %[[a]], i64 0, i64 0
 754 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[agep1]], i8* %src, i32 %size,
 755 ; CHECK-NEXT: %[[agep2:.*]] = getelementptr inbounds [34 x i8]* %[[a]], i64 0, i64 0
 756 ; CHECK-NEXT: call void @llvm.memset.p0i8.i32(i8* %[[agep2]], i8 42, i32 %size,
 757 ; CHECK-NEXT: %[[dstcast1:.*]] = bitcast i8* %dst to i32*
 758 ; CHECK-NEXT: store i32 42, i32* %[[dstcast1]]
 759 ; CHECK-NEXT: %[[dstgep1:.*]] = getelementptr inbounds i8* %dst, i64 4
 760 ; CHECK-NEXT: %[[dstcast2:.*]] = bitcast i8* %[[dstgep1]] to i32*
 761 ; CHECK-NEXT: store i32 %[[srcload]], i32* %[[dstcast2]]
 762 ; CHECK-NEXT: %[[agep3:.*]] = getelementptr inbounds [34 x i8]* %[[a]], i64 0, i64 0
 763 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %[[agep3]], i32 %size,
 764 ; CHECK-NEXT: ret void
 765
 766 entry:
 767   %a = alloca [42 x i8]
 768   %ptr = getelementptr [42 x i8]* %a, i32 0, i32 0
 769   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %src, i32 8, i32 1, i1 false)
 770   %ptr2 = getelementptr [42 x i8]* %a, i32 0, i32 8
 771   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr2, i8* %src, i32 %size, i32 1, i1 false)
 772   call void @llvm.memset.p0i8.i32(i8* %ptr2, i8 42, i32 %size, i32 1, i1 false)
 773   %cast = bitcast i8* %ptr to i32*
 774   store i32 42, i32* %cast
 775   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr, i32 8, i32 1, i1 false)
 776   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr2, i32 %size, i32 1, i1 false)
 777   ret void
 778 }
 779
 780 %opaque = type opaque
 781
 782 define i32 @test19(%opaque* %x) {
 783 ; This input will cause us to try to compute a natural GEP when rewriting
 784 ; pointers in such a way that we try to GEP through the opaque type. Previously,
 785 ; a check for an unsized type was missing and this crashed. Ensure it behaves
 786 ; reasonably now.
 787 ; CHECK: @test19
 788 ; CHECK-NOT: alloca
 789 ; CHECK: ret i32 undef
 790
 791 entry:
 792   %a = alloca { i64, i8* }
 793   %cast1 = bitcast %opaque* %x to i8*
 794   %cast2 = bitcast { i64, i8* }* %a to i8*
 795   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %cast2, i8* %cast1, i32 16, i32 1, i1 false)
 796   %gep = getelementptr inbounds { i64, i8* }* %a, i32 0, i32 0
 797   %val = load i64* %gep
 798   ret i32 undef
 799 }
 800
 801 define i32 @test20() {
 802 ; Ensure we can track negative offsets (before the beginning of the alloca) and
 803 ; negative relative offsets from offsets starting past the end of the alloca.
 804 ; CHECK: @test20
 805 ; CHECK-NOT: alloca
 806 ; CHECK: %[[sum1:.*]] = add i32 1, 2
 807 ; CHECK: %[[sum2:.*]] = add i32 %[[sum1]], 3
 808 ; CHECK: ret i32 %[[sum2]]
 809
 810 entry:
 811   %a = alloca [3 x i32]
 812   %gep1 = getelementptr [3 x i32]* %a, i32 0, i32 0
 813   store i32 1, i32* %gep1
 814   %gep2.1 = getelementptr [3 x i32]* %a, i32 0, i32 -2
 815   %gep2.2 = getelementptr i32* %gep2.1, i32 3
 816   store i32 2, i32* %gep2.2
 817   %gep3.1 = getelementptr [3 x i32]* %a, i32 0, i32 14
 818   %gep3.2 = getelementptr i32* %gep3.1, i32 -12
 819   store i32 3, i32* %gep3.2
 820
 821   %load1 = load i32* %gep1
 822   %load2 = load i32* %gep2.2
 823   %load3 = load i32* %gep3.2
 824   %sum1 = add i32 %load1, %load2
 825   %sum2 = add i32 %sum1, %load3
 826   ret i32 %sum2
 827 }
 828
 829 declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1) nounwind
 830
 831 define i8 @test21() {
 832 ; Test allocations and offsets which border on overflow of the int64_t used
 833 ; internally. This is really awkward to really test as LLVM doesn't really
 834 ; support such extreme constructs cleanly.
 835 ; CHECK: @test21
 836 ; CHECK-NOT: alloca
 837 ; CHECK: or i8 -1, -1
 838
 839 entry:
 840   %a = alloca [2305843009213693951 x i8]
 841   %gep0 = getelementptr [2305843009213693951 x i8]* %a, i64 0, i64 2305843009213693949
 842   store i8 255, i8* %gep0
 843   %gep1 = getelementptr [2305843009213693951 x i8]* %a, i64 0, i64 -9223372036854775807
 844   %gep2 = getelementptr i8* %gep1, i64 -1
 845   call void @llvm.memset.p0i8.i64(i8* %gep2, i8 0, i64 18446744073709551615, i32 1, i1 false)
 846   %gep3 = getelementptr i8* %gep1, i64 9223372036854775807
 847   %gep4 = getelementptr i8* %gep3, i64 9223372036854775807
 848   %gep5 = getelementptr i8* %gep4, i64 -6917529027641081857
 849   store i8 255, i8* %gep5
 850   %cast1 = bitcast i8* %gep4 to i32*
 851   store i32 0, i32* %cast1
 852   %load = load i8* %gep0
 853   %gep6 = getelementptr i8* %gep0, i32 1
 854   %load2 = load i8* %gep6
 855   %result = or i8 %load, %load2
 856   ret i8 %result
 857 }
 858
 859 %test22.struct = type { i8 }
 860
 861 define void @test22() {
 862 ; CHECK: @test22
 863 ; CHECK-NOT: alloca
 864 ; CHECK: ret void
 865 ; PR13916
 866 entry:
 867   %A = alloca %test22.struct
 868   br i1 undef, label %if.then, label %if.end
 869
 870 if.then:                                          ; preds = %entry
 871   %tmp = bitcast %test22.struct* %A to i8*
 872   %tmp1 = bitcast %test22.struct* %A to i8*
 873   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %tmp, i8* %tmp1, i32 1, i32 1, i1 false)
 874   unreachable
 875
 876 if.end:                                           ; preds = %entry
 877   %tmp2 = load %test22.struct* %A
 878   ret void
 879 }