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-p1:16:16:16-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-LABEL: @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-LABEL: @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-LABEL: @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-LABEL: @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-LABEL: @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.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* nocapture, i8* nocapture, i32, i32, i1) nounwind
 408 declare void @llvm.memmove.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind
 409 declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i32, i1) nounwind
 410
 411 define i16 @test5() {
 412 ; CHECK-LABEL: @test5(
 413 ; CHECK-NOT: alloca float
 414 ; CHECK:      %[[cast:.*]] = bitcast float 0.0{{.*}} to i32
 415 ; CHECK-NEXT: %[[shr:.*]] = lshr i32 %[[cast]], 16
 416 ; CHECK-NEXT: %[[trunc:.*]] = trunc i32 %[[shr]] to i16
 417 ; CHECK-NEXT: ret i16 %[[trunc]]
 418
 419 entry:
 420   %a = alloca [4 x i8]
 421   %fptr = bitcast [4 x i8]* %a to float*
 422   store float 0.0, float* %fptr
 423   %ptr = getelementptr [4 x i8]* %a, i32 0, i32 2
 424   %iptr = bitcast i8* %ptr to i16*
 425   %val = load i16* %iptr
 426   ret i16 %val
 427 }
 428
 429 define i32 @test6() {
 430 ; CHECK-LABEL: @test6(
 431 ; CHECK: alloca i32
 432 ; CHECK-NEXT: store volatile i32
 433 ; CHECK-NEXT: load i32*
 434 ; CHECK-NEXT: ret i32
 435
 436 entry:
 437   %a = alloca [4 x i8]
 438   %ptr = getelementptr [4 x i8]* %a, i32 0, i32 0
 439   call void @llvm.memset.p0i8.i32(i8* %ptr, i8 42, i32 4, i32 1, i1 true)
 440   %iptr = bitcast i8* %ptr to i32*
 441   %val = load i32* %iptr
 442   ret i32 %val
 443 }
 444
 445 define void @test7(i8* %src, i8* %dst) {
 446 ; CHECK-LABEL: @test7(
 447 ; CHECK: alloca i32
 448 ; CHECK-NEXT: bitcast i8* %src to i32*
 449 ; CHECK-NEXT: load volatile i32*
 450 ; CHECK-NEXT: store volatile i32
 451 ; CHECK-NEXT: bitcast i8* %dst to i32*
 452 ; CHECK-NEXT: load volatile i32*
 453 ; CHECK-NEXT: store volatile i32
 454 ; CHECK-NEXT: ret
 455
 456 entry:
 457   %a = alloca [4 x i8]
 458   %ptr = getelementptr [4 x i8]* %a, i32 0, i32 0
 459   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %src, i32 4, i32 1, i1 true)
 460   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr, i32 4, i32 1, i1 true)
 461   ret void
 462 }
 463
 464
 465 %S1 = type { i32, i32, [16 x i8] }
 466 %S2 = type { %S1*, %S2* }
 467
 468 define %S2 @test8(%S2* %s2) {
 469 ; CHECK-LABEL: @test8(
 470 entry:
 471   %new = alloca %S2
 472 ; CHECK-NOT: alloca
 473
 474   %s2.next.ptr = getelementptr %S2* %s2, i64 0, i32 1
 475   %s2.next = load %S2** %s2.next.ptr
 476 ; CHECK:      %[[gep:.*]] = getelementptr %S2* %s2, i64 0, i32 1
 477 ; CHECK-NEXT: %[[next:.*]] = load %S2** %[[gep]]
 478
 479   %s2.next.s1.ptr = getelementptr %S2* %s2.next, i64 0, i32 0
 480   %s2.next.s1 = load %S1** %s2.next.s1.ptr
 481   %new.s1.ptr = getelementptr %S2* %new, i64 0, i32 0
 482   store %S1* %s2.next.s1, %S1** %new.s1.ptr
 483   %s2.next.next.ptr = getelementptr %S2* %s2.next, i64 0, i32 1
 484   %s2.next.next = load %S2** %s2.next.next.ptr
 485   %new.next.ptr = getelementptr %S2* %new, i64 0, i32 1
 486   store %S2* %s2.next.next, %S2** %new.next.ptr
 487 ; CHECK-NEXT: %[[gep:.*]] = getelementptr %S2* %[[next]], i64 0, i32 0
 488 ; CHECK-NEXT: %[[next_s1:.*]] = load %S1** %[[gep]]
 489 ; CHECK-NEXT: %[[gep:.*]] = getelementptr %S2* %[[next]], i64 0, i32 1
 490 ; CHECK-NEXT: %[[next_next:.*]] = load %S2** %[[gep]]
 491
 492   %new.s1 = load %S1** %new.s1.ptr
 493   %result1 = insertvalue %S2 undef, %S1* %new.s1, 0
 494 ; CHECK-NEXT: %[[result1:.*]] = insertvalue %S2 undef, %S1* %[[next_s1]], 0
 495   %new.next = load %S2** %new.next.ptr
 496   %result2 = insertvalue %S2 %result1, %S2* %new.next, 1
 497 ; CHECK-NEXT: %[[result2:.*]] = insertvalue %S2 %[[result1]], %S2* %[[next_next]], 1
 498   ret %S2 %result2
 499 ; CHECK-NEXT: ret %S2 %[[result2]]
 500 }
 501
 502 define i64 @test9() {
 503 ; Ensure we can handle loads off the end of an alloca even when wrapped in
 504 ; weird bit casts and types. This is valid IR due to the alignment and masking
 505 ; off the bits past the end of the alloca.
 506 ;
 507 ; CHECK-LABEL: @test9(
 508 ; CHECK-NOT: alloca
 509 ; CHECK:      %[[b2:.*]] = zext i8 26 to i64
 510 ; CHECK-NEXT: %[[s2:.*]] = shl i64 %[[b2]], 16
 511 ; CHECK-NEXT: %[[m2:.*]] = and i64 undef, -16711681
 512 ; CHECK-NEXT: %[[i2:.*]] = or i64 %[[m2]], %[[s2]]
 513 ; CHECK-NEXT: %[[b1:.*]] = zext i8 0 to i64
 514 ; CHECK-NEXT: %[[s1:.*]] = shl i64 %[[b1]], 8
 515 ; CHECK-NEXT: %[[m1:.*]] = and i64 %[[i2]], -65281
 516 ; CHECK-NEXT: %[[i1:.*]] = or i64 %[[m1]], %[[s1]]
 517 ; CHECK-NEXT: %[[b0:.*]] = zext i8 0 to i64
 518 ; CHECK-NEXT: %[[m0:.*]] = and i64 %[[i1]], -256
 519 ; CHECK-NEXT: %[[i0:.*]] = or i64 %[[m0]], %[[b0]]
 520 ; CHECK-NEXT: %[[result:.*]] = and i64 %[[i0]], 16777215
 521 ; CHECK-NEXT: ret i64 %[[result]]
 522
 523 entry:
 524   %a = alloca { [3 x i8] }, align 8
 525   %gep1 = getelementptr inbounds { [3 x i8] }* %a, i32 0, i32 0, i32 0
 526   store i8 0, i8* %gep1, align 1
 527   %gep2 = getelementptr inbounds { [3 x i8] }* %a, i32 0, i32 0, i32 1
 528   store i8 0, i8* %gep2, align 1
 529   %gep3 = getelementptr inbounds { [3 x i8] }* %a, i32 0, i32 0, i32 2
 530   store i8 26, i8* %gep3, align 1
 531   %cast = bitcast { [3 x i8] }* %a to { i64 }*
 532   %elt = getelementptr inbounds { i64 }* %cast, i32 0, i32 0
 533   %load = load i64* %elt
 534   %result = and i64 %load, 16777215
 535   ret i64 %result
 536 }
 537
 538 define %S2* @test10() {
 539 ; CHECK-LABEL: @test10(
 540 ; CHECK-NOT: alloca %S2*
 541 ; CHECK: ret %S2* null
 542
 543 entry:
 544   %a = alloca [8 x i8]
 545   %ptr = getelementptr [8 x i8]* %a, i32 0, i32 0
 546   call void @llvm.memset.p0i8.i32(i8* %ptr, i8 0, i32 8, i32 1, i1 false)
 547   %s2ptrptr = bitcast i8* %ptr to %S2**
 548   %s2ptr = load %S2** %s2ptrptr
 549   ret %S2* %s2ptr
 550 }
 551
 552 define i32 @test11() {
 553 ; CHECK-LABEL: @test11(
 554 ; CHECK-NOT: alloca
 555 ; CHECK: ret i32 0
 556
 557 entry:
 558   %X = alloca i32
 559   br i1 undef, label %good, label %bad
 560
 561 good:
 562   %Y = getelementptr i32* %X, i64 0
 563   store i32 0, i32* %Y
 564   %Z = load i32* %Y
 565   ret i32 %Z
 566
 567 bad:
 568   %Y2 = getelementptr i32* %X, i64 1
 569   store i32 0, i32* %Y2
 570   %Z2 = load i32* %Y2
 571   ret i32 %Z2
 572 }
 573
 574 define i8 @test12() {
 575 ; We promote these to three SSA values which fold away immediately.
 576 ;
 577 ; CHECK-LABEL: @test12(
 578
 579 entry:
 580   %a = alloca [3 x i8]
 581   %b = alloca [3 x i8]
 582 ; CHECK-NOT: alloca
 583
 584   %a0ptr = getelementptr [3 x i8]* %a, i64 0, i32 0
 585   store i8 0, i8* %a0ptr
 586   %a1ptr = getelementptr [3 x i8]* %a, i64 0, i32 1
 587   store i8 0, i8* %a1ptr
 588   %a2ptr = getelementptr [3 x i8]* %a, i64 0, i32 2
 589   store i8 0, i8* %a2ptr
 590   %aiptr = bitcast [3 x i8]* %a to i24*
 591   %ai = load i24* %aiptr
 592 ; CHECK-NOT: store
 593 ; CHECK-NOT: load
 594
 595   %biptr = bitcast [3 x i8]* %b to i24*
 596   store i24 %ai, i24* %biptr
 597   %b0ptr = getelementptr [3 x i8]* %b, i64 0, i32 0
 598   %b0 = load i8* %b0ptr
 599   %b1ptr = getelementptr [3 x i8]* %b, i64 0, i32 1
 600   %b1 = load i8* %b1ptr
 601   %b2ptr = getelementptr [3 x i8]* %b, i64 0, i32 2
 602   %b2 = load i8* %b2ptr
 603 ; CHECK-NOT: store
 604 ; CHECK-NOT: load
 605
 606   %bsum0 = add i8 %b0, %b1
 607   %bsum1 = add i8 %bsum0, %b2
 608   ret i8 %bsum1
 609 ; CHECK:      %[[sum0:.*]] = add i8 0, 0
 610 ; CHECK-NEXT: %[[sum1:.*]] = add i8 %[[sum0]], 0
 611 ; CHECK-NEXT: ret i8 %[[sum1]]
 612 }
 613
 614 define i32 @test13() {
 615 ; Ensure we don't crash and handle undefined loads that straddle the end of the
 616 ; allocation.
 617 ; CHECK-LABEL: @test13(
 618 ; CHECK:      %[[value:.*]] = zext i8 0 to i16
 619 ; CHECK-NEXT: %[[ret:.*]] = zext i16 %[[value]] to i32
 620 ; CHECK-NEXT: ret i32 %[[ret]]
 621
 622 entry:
 623   %a = alloca [3 x i8], align 2
 624   %b0ptr = getelementptr [3 x i8]* %a, i64 0, i32 0
 625   store i8 0, i8* %b0ptr
 626   %b1ptr = getelementptr [3 x i8]* %a, i64 0, i32 1
 627   store i8 0, i8* %b1ptr
 628   %b2ptr = getelementptr [3 x i8]* %a, i64 0, i32 2
 629   store i8 0, i8* %b2ptr
 630   %iptrcast = bitcast [3 x i8]* %a to i16*
 631   %iptrgep = getelementptr i16* %iptrcast, i64 1
 632   %i = load i16* %iptrgep
 633   %ret = zext i16 %i to i32
 634   ret i32 %ret
 635 }
 636
 637 %test14.struct = type { [3 x i32] }
 638
 639 define void @test14(...) nounwind uwtable {
 640 ; This is a strange case where we split allocas into promotable partitions, but
 641 ; also gain enough data to prove they must be dead allocas due to GEPs that walk
 642 ; across two adjacent allocas. Test that we don't try to promote or otherwise
 643 ; do bad things to these dead allocas, they should just be removed.
 644 ; CHECK-LABEL: @test14(
 645 ; CHECK-NEXT: entry:
 646 ; CHECK-NEXT: ret void
 647
 648 entry:
 649   %a = alloca %test14.struct
 650   %p = alloca %test14.struct*
 651   %0 = bitcast %test14.struct* %a to i8*
 652   %1 = getelementptr i8* %0, i64 12
 653   %2 = bitcast i8* %1 to %test14.struct*
 654   %3 = getelementptr inbounds %test14.struct* %2, i32 0, i32 0
 655   %4 = getelementptr inbounds %test14.struct* %a, i32 0, i32 0
 656   %5 = bitcast [3 x i32]* %3 to i32*
 657   %6 = bitcast [3 x i32]* %4 to i32*
 658   %7 = load i32* %6, align 4
 659   store i32 %7, i32* %5, align 4
 660   %8 = getelementptr inbounds i32* %5, i32 1
 661   %9 = getelementptr inbounds i32* %6, i32 1
 662   %10 = load i32* %9, align 4
 663   store i32 %10, i32* %8, align 4
 664   %11 = getelementptr inbounds i32* %5, i32 2
 665   %12 = getelementptr inbounds i32* %6, i32 2
 666   %13 = load i32* %12, align 4
 667   store i32 %13, i32* %11, align 4
 668   ret void
 669 }
 670
 671 define i32 @test15(i1 %flag) nounwind uwtable {
 672 ; Ensure that when there are dead instructions using an alloca that are not
 673 ; loads or stores we still delete them during partitioning and rewriting.
 674 ; Otherwise we'll go to promote them while thy still have unpromotable uses.
 675 ; CHECK-LABEL: @test15(
 676 ; CHECK-NEXT: entry:
 677 ; CHECK-NEXT:   br label %loop
 678 ; CHECK:      loop:
 679 ; CHECK-NEXT:   br label %loop
 680
 681 entry:
 682   %l0 = alloca i64
 683   %l1 = alloca i64
 684   %l2 = alloca i64
 685   %l3 = alloca i64
 686   br label %loop
 687
 688 loop:
 689   %dead3 = phi i8* [ %gep3, %loop ], [ null, %entry ]
 690
 691   store i64 1879048192, i64* %l0, align 8
 692   %bc0 = bitcast i64* %l0 to i8*
 693   %gep0 = getelementptr i8* %bc0, i64 3
 694   %dead0 = bitcast i8* %gep0 to i64*
 695
 696   store i64 1879048192, i64* %l1, align 8
 697   %bc1 = bitcast i64* %l1 to i8*
 698   %gep1 = getelementptr i8* %bc1, i64 3
 699   %dead1 = getelementptr i8* %gep1, i64 1
 700
 701   store i64 1879048192, i64* %l2, align 8
 702   %bc2 = bitcast i64* %l2 to i8*
 703   %gep2.1 = getelementptr i8* %bc2, i64 1
 704   %gep2.2 = getelementptr i8* %bc2, i64 3
 705   ; Note that this select should get visited multiple times due to using two
 706   ; different GEPs off the same alloca. We should only delete it once.
 707   %dead2 = select i1 %flag, i8* %gep2.1, i8* %gep2.2
 708
 709   store i64 1879048192, i64* %l3, align 8
 710   %bc3 = bitcast i64* %l3 to i8*
 711   %gep3 = getelementptr i8* %bc3, i64 3
 712
 713   br label %loop
 714 }
 715
 716 define void @test16(i8* %src, i8* %dst) {
 717 ; Ensure that we can promote an alloca of [3 x i8] to an i24 SSA value.
 718 ; CHECK-LABEL: @test16(
 719 ; CHECK-NOT: alloca
 720 ; CHECK:      %[[srccast:.*]] = bitcast i8* %src to i24*
 721 ; CHECK-NEXT: load i24* %[[srccast]]
 722 ; CHECK-NEXT: %[[dstcast:.*]] = bitcast i8* %dst to i24*
 723 ; CHECK-NEXT: store i24 0, i24* %[[dstcast]]
 724 ; CHECK-NEXT: ret void
 725
 726 entry:
 727   %a = alloca [3 x i8]
 728   %ptr = getelementptr [3 x i8]* %a, i32 0, i32 0
 729   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %src, i32 4, i32 1, i1 false)
 730   %cast = bitcast i8* %ptr to i24*
 731   store i24 0, i24* %cast
 732   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr, i32 4, i32 1, i1 false)
 733   ret void
 734 }
 735
 736 define void @test17(i8* %src, i8* %dst) {
 737 ; Ensure that we can rewrite unpromotable memcpys which extend past the end of
 738 ; the alloca.
 739 ; CHECK-LABEL: @test17(
 740 ; CHECK:      %[[a:.*]] = alloca [3 x i8]
 741 ; CHECK-NEXT: %[[ptr:.*]] = getelementptr [3 x i8]* %[[a]], i32 0, i32 0
 742 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[ptr]], i8* %src,
 743 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %[[ptr]],
 744 ; CHECK-NEXT: ret void
 745
 746 entry:
 747   %a = alloca [3 x i8]
 748   %ptr = getelementptr [3 x i8]* %a, i32 0, i32 0
 749   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %src, i32 4, i32 1, i1 true)
 750   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr, i32 4, i32 1, i1 true)
 751   ret void
 752 }
 753
 754 define void @test18(i8* %src, i8* %dst, i32 %size) {
 755 ; Preserve transfer instrinsics with a variable size, even if they overlap with
 756 ; fixed size operations. Further, continue to split and promote allocas preceding
 757 ; the variable sized intrinsic.
 758 ; CHECK-LABEL: @test18(
 759 ; CHECK:      %[[a:.*]] = alloca [34 x i8]
 760 ; CHECK:      %[[srcgep1:.*]] = getelementptr inbounds i8* %src, i64 4
 761 ; CHECK-NEXT: %[[srccast1:.*]] = bitcast i8* %[[srcgep1]] to i32*
 762 ; CHECK-NEXT: %[[srcload:.*]] = load i32* %[[srccast1]]
 763 ; CHECK-NEXT: %[[agep1:.*]] = getelementptr inbounds [34 x i8]* %[[a]], i64 0, i64 0
 764 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[agep1]], i8* %src, i32 %size,
 765 ; CHECK-NEXT: %[[agep2:.*]] = getelementptr inbounds [34 x i8]* %[[a]], i64 0, i64 0
 766 ; CHECK-NEXT: call void @llvm.memset.p0i8.i32(i8* %[[agep2]], i8 42, i32 %size,
 767 ; CHECK-NEXT: %[[dstcast1:.*]] = bitcast i8* %dst to i32*
 768 ; CHECK-NEXT: store i32 42, i32* %[[dstcast1]]
 769 ; CHECK-NEXT: %[[dstgep1:.*]] = getelementptr inbounds i8* %dst, i64 4
 770 ; CHECK-NEXT: %[[dstcast2:.*]] = bitcast i8* %[[dstgep1]] to i32*
 771 ; CHECK-NEXT: store i32 %[[srcload]], i32* %[[dstcast2]]
 772 ; CHECK-NEXT: %[[agep3:.*]] = getelementptr inbounds [34 x i8]* %[[a]], i64 0, i64 0
 773 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %[[agep3]], i32 %size,
 774 ; CHECK-NEXT: ret void
 775
 776 entry:
 777   %a = alloca [42 x i8]
 778   %ptr = getelementptr [42 x i8]* %a, i32 0, i32 0
 779   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %src, i32 8, i32 1, i1 false)
 780   %ptr2 = getelementptr [42 x i8]* %a, i32 0, i32 8
 781   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr2, i8* %src, i32 %size, i32 1, i1 false)
 782   call void @llvm.memset.p0i8.i32(i8* %ptr2, i8 42, i32 %size, i32 1, i1 false)
 783   %cast = bitcast i8* %ptr to i32*
 784   store i32 42, i32* %cast
 785   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr, i32 8, i32 1, i1 false)
 786   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr2, i32 %size, i32 1, i1 false)
 787   ret void
 788 }
 789
 790 %opaque = type opaque
 791
 792 define i32 @test19(%opaque* %x) {
 793 ; This input will cause us to try to compute a natural GEP when rewriting
 794 ; pointers in such a way that we try to GEP through the opaque type. Previously,
 795 ; a check for an unsized type was missing and this crashed. Ensure it behaves
 796 ; reasonably now.
 797 ; CHECK-LABEL: @test19(
 798 ; CHECK-NOT: alloca
 799 ; CHECK: ret i32 undef
 800
 801 entry:
 802   %a = alloca { i64, i8* }
 803   %cast1 = bitcast %opaque* %x to i8*
 804   %cast2 = bitcast { i64, i8* }* %a to i8*
 805   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %cast2, i8* %cast1, i32 16, i32 1, i1 false)
 806   %gep = getelementptr inbounds { i64, i8* }* %a, i32 0, i32 0
 807   %val = load i64* %gep
 808   ret i32 undef
 809 }
 810
 811 define i32 @test20() {
 812 ; Ensure we can track negative offsets (before the beginning of the alloca) and
 813 ; negative relative offsets from offsets starting past the end of the alloca.
 814 ; CHECK-LABEL: @test20(
 815 ; CHECK-NOT: alloca
 816 ; CHECK: %[[sum1:.*]] = add i32 1, 2
 817 ; CHECK: %[[sum2:.*]] = add i32 %[[sum1]], 3
 818 ; CHECK: ret i32 %[[sum2]]
 819
 820 entry:
 821   %a = alloca [3 x i32]
 822   %gep1 = getelementptr [3 x i32]* %a, i32 0, i32 0
 823   store i32 1, i32* %gep1
 824   %gep2.1 = getelementptr [3 x i32]* %a, i32 0, i32 -2
 825   %gep2.2 = getelementptr i32* %gep2.1, i32 3
 826   store i32 2, i32* %gep2.2
 827   %gep3.1 = getelementptr [3 x i32]* %a, i32 0, i32 14
 828   %gep3.2 = getelementptr i32* %gep3.1, i32 -12
 829   store i32 3, i32* %gep3.2
 830
 831   %load1 = load i32* %gep1
 832   %load2 = load i32* %gep2.2
 833   %load3 = load i32* %gep3.2
 834   %sum1 = add i32 %load1, %load2
 835   %sum2 = add i32 %sum1, %load3
 836   ret i32 %sum2
 837 }
 838
 839 declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1) nounwind
 840
 841 define i8 @test21() {
 842 ; Test allocations and offsets which border on overflow of the int64_t used
 843 ; internally. This is really awkward to really test as LLVM doesn't really
 844 ; support such extreme constructs cleanly.
 845 ; CHECK-LABEL: @test21(
 846 ; CHECK-NOT: alloca
 847 ; CHECK: or i8 -1, -1
 848
 849 entry:
 850   %a = alloca [2305843009213693951 x i8]
 851   %gep0 = getelementptr [2305843009213693951 x i8]* %a, i64 0, i64 2305843009213693949
 852   store i8 255, i8* %gep0
 853   %gep1 = getelementptr [2305843009213693951 x i8]* %a, i64 0, i64 -9223372036854775807
 854   %gep2 = getelementptr i8* %gep1, i64 -1
 855   call void @llvm.memset.p0i8.i64(i8* %gep2, i8 0, i64 18446744073709551615, i32 1, i1 false)
 856   %gep3 = getelementptr i8* %gep1, i64 9223372036854775807
 857   %gep4 = getelementptr i8* %gep3, i64 9223372036854775807
 858   %gep5 = getelementptr i8* %gep4, i64 -6917529027641081857
 859   store i8 255, i8* %gep5
 860   %cast1 = bitcast i8* %gep4 to i32*
 861   store i32 0, i32* %cast1
 862   %load = load i8* %gep0
 863   %gep6 = getelementptr i8* %gep0, i32 1
 864   %load2 = load i8* %gep6
 865   %result = or i8 %load, %load2
 866   ret i8 %result
 867 }
 868
 869 %PR13916.struct = type { i8 }
 870
 871 define void @PR13916.1() {
 872 ; Ensure that we handle overlapping memcpy intrinsics correctly, especially in
 873 ; the case where there is a directly identical value for both source and dest.
 874 ; CHECK: @PR13916.1
 875 ; CHECK-NOT: alloca
 876 ; CHECK: ret void
 877
 878 entry:
 879   %a = alloca i8
 880   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a, i8* %a, i32 1, i32 1, i1 false)
 881   %tmp2 = load i8* %a
 882   ret void
 883 }
 884
 885 define void @PR13916.2() {
 886 ; Check whether we continue to handle them correctly when they start off with
 887 ; different pointer value chains, but during rewriting we coalesce them into the
 888 ; same value.
 889 ; CHECK: @PR13916.2
 890 ; CHECK-NOT: alloca
 891 ; CHECK: ret void
 892
 893 entry:
 894   %a = alloca %PR13916.struct, align 1
 895   br i1 undef, label %if.then, label %if.end
 896
 897 if.then:
 898   %tmp0 = bitcast %PR13916.struct* %a to i8*
 899   %tmp1 = bitcast %PR13916.struct* %a to i8*
 900   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %tmp0, i8* %tmp1, i32 1, i32 1, i1 false)
 901   br label %if.end
 902
 903 if.end:
 904   %gep = getelementptr %PR13916.struct* %a, i32 0, i32 0
 905   %tmp2 = load i8* %gep
 906   ret void
 907 }
 908
 909 define void @PR13990() {
 910 ; Ensure we can handle cases where processing one alloca causes the other
 911 ; alloca to become dead and get deleted. This might crash or fail under
 912 ; Valgrind if we regress.
 913 ; CHECK-LABEL: @PR13990(
 914 ; CHECK-NOT: alloca
 915 ; CHECK: unreachable
 916 ; CHECK: unreachable
 917
 918 entry:
 919   %tmp1 = alloca i8*
 920   %tmp2 = alloca i8*
 921   br i1 undef, label %bb1, label %bb2
 922
 923 bb1:
 924   store i8* undef, i8** %tmp2
 925   br i1 undef, label %bb2, label %bb3
 926
 927 bb2:
 928   %tmp50 = select i1 undef, i8** %tmp2, i8** %tmp1
 929   br i1 undef, label %bb3, label %bb4
 930
 931 bb3:
 932   unreachable
 933
 934 bb4:
 935   unreachable
 936 }
 937
 938 define double @PR13969(double %x) {
 939 ; Check that we detect when promotion will un-escape an alloca and iterate to
 940 ; re-try running SROA over that alloca. Without that, the two allocas that are
 941 ; stored into a dead alloca don't get rewritten and promoted.
 942 ; CHECK-LABEL: @PR13969(
 943
 944 entry:
 945   %a = alloca double
 946   %b = alloca double*
 947   %c = alloca double
 948 ; CHECK-NOT: alloca
 949
 950   store double %x, double* %a
 951   store double* %c, double** %b
 952   store double* %a, double** %b
 953   store double %x, double* %c
 954   %ret = load double* %a
 955 ; CHECK-NOT: store
 956 ; CHECK-NOT: load
 957
 958   ret double %ret
 959 ; CHECK: ret double %x
 960 }
 961
 962 %PR14034.struct = type { { {} }, i32, %PR14034.list }
 963 %PR14034.list = type { %PR14034.list*, %PR14034.list* }
 964
 965 define void @PR14034() {
 966 ; This test case tries to form GEPs into the empty leading struct members, and
 967 ; subsequently crashed (under valgrind) before we fixed the PR. The important
 968 ; thing is to handle empty structs gracefully.
 969 ; CHECK-LABEL: @PR14034(
 970
 971 entry:
 972   %a = alloca %PR14034.struct
 973   %list = getelementptr %PR14034.struct* %a, i32 0, i32 2
 974   %prev = getelementptr %PR14034.list* %list, i32 0, i32 1
 975   store %PR14034.list* undef, %PR14034.list** %prev
 976   %cast0 = bitcast %PR14034.struct* undef to i8*
 977   %cast1 = bitcast %PR14034.struct* %a to i8*
 978   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %cast0, i8* %cast1, i32 12, i32 0, i1 false)
 979   ret void
 980 }
 981
 982 define i32 @test22(i32 %x) {
 983 ; Test that SROA and promotion is not confused by a grab bax mixture of pointer
 984 ; types involving wrapper aggregates and zero-length aggregate members.
 985 ; CHECK-LABEL: @test22(
 986
 987 entry:
 988   %a1 = alloca { { [1 x { i32 }] } }
 989   %a2 = alloca { {}, { float }, [0 x i8] }
 990   %a3 = alloca { [0 x i8], { [0 x double], [1 x [1 x <4 x i8>]], {} }, { { {} } } }
 991 ; CHECK-NOT: alloca
 992
 993   %wrap1 = insertvalue [1 x { i32 }] undef, i32 %x, 0, 0
 994   %gep1 = getelementptr { { [1 x { i32 }] } }* %a1, i32 0, i32 0, i32 0
 995   store [1 x { i32 }] %wrap1, [1 x { i32 }]* %gep1
 996
 997   %gep2 = getelementptr { { [1 x { i32 }] } }* %a1, i32 0, i32 0
 998   %ptrcast1 = bitcast { [1 x { i32 }] }* %gep2 to { [1 x { float }] }*
 999   %load1 = load { [1 x { float }] }* %ptrcast1
1000   %unwrap1 = extractvalue { [1 x { float }] } %load1, 0, 0
1001
1002   %wrap2 = insertvalue { {}, { float }, [0 x i8] } undef, { float } %unwrap1, 1
1003   store { {}, { float }, [0 x i8] } %wrap2, { {}, { float }, [0 x i8] }* %a2
1004
1005   %gep3 = getelementptr { {}, { float }, [0 x i8] }* %a2, i32 0, i32 1, i32 0
1006   %ptrcast2 = bitcast float* %gep3 to <4 x i8>*
1007   %load3 = load <4 x i8>* %ptrcast2
1008   %valcast1 = bitcast <4 x i8> %load3 to i32
1009
1010   %wrap3 = insertvalue [1 x [1 x i32]] undef, i32 %valcast1, 0, 0
1011   %wrap4 = insertvalue { [1 x [1 x i32]], {} } undef, [1 x [1 x i32]] %wrap3, 0
1012   %gep4 = getelementptr { [0 x i8], { [0 x double], [1 x [1 x <4 x i8>]], {} }, { { {} } } }* %a3, i32 0, i32 1
1013   %ptrcast3 = bitcast { [0 x double], [1 x [1 x <4 x i8>]], {} }* %gep4 to { [1 x [1 x i32]], {} }*
1014   store { [1 x [1 x i32]], {} } %wrap4, { [1 x [1 x i32]], {} }* %ptrcast3
1015
1016   %gep5 = getelementptr { [0 x i8], { [0 x double], [1 x [1 x <4 x i8>]], {} }, { { {} } } }* %a3, i32 0, i32 1, i32 1, i32 0
1017   %ptrcast4 = bitcast [1 x <4 x i8>]* %gep5 to { {}, float, {} }*
1018   %load4 = load { {}, float, {} }* %ptrcast4
1019   %unwrap2 = extractvalue { {}, float, {} } %load4, 1
1020   %valcast2 = bitcast float %unwrap2 to i32
1021
1022   ret i32 %valcast2
1023 ; CHECK: ret i32
1024 }
1025
1026 define void @PR14059.1(double* %d) {
1027 ; In PR14059 a peculiar construct was identified as something that is used
1028 ; pervasively in ARM's ABI-calling-convention lowering: the passing of a struct
1029 ; of doubles via an array of i32 in order to place the data into integer
1030 ; registers. This in turn was missed as an optimization by SROA due to the
1031 ; partial loads and stores of integers to the double alloca we were trying to
1032 ; form and promote. The solution is to widen the integer operations to be
1033 ; whole-alloca operations, and perform the appropriate bitcasting on the
1034 ; *values* rather than the pointers. When this works, partial reads and writes
1035 ; via integers can be promoted away.
1036 ; CHECK: @PR14059.1
1037 ; CHECK-NOT: alloca
1038 ; CHECK: ret void
1039
1040 entry:
1041   %X.sroa.0.i = alloca double, align 8
1042   %0 = bitcast double* %X.sroa.0.i to i8*
1043   call void @llvm.lifetime.start(i64 -1, i8* %0)
1044
1045   ; Store to the low 32-bits...
1046   %X.sroa.0.0.cast2.i = bitcast double* %X.sroa.0.i to i32*
1047   store i32 0, i32* %X.sroa.0.0.cast2.i, align 8
1048
1049   ; Also use a memset to the middle 32-bits for fun.
1050   %X.sroa.0.2.raw_idx2.i = getelementptr inbounds i8* %0, i32 2
1051   call void @llvm.memset.p0i8.i64(i8* %X.sroa.0.2.raw_idx2.i, i8 0, i64 4, i32 1, i1 false)
1052
1053   ; Or a memset of the whole thing.
1054   call void @llvm.memset.p0i8.i64(i8* %0, i8 0, i64 8, i32 1, i1 false)
1055
1056   ; Write to the high 32-bits with a memcpy.
1057   %X.sroa.0.4.raw_idx4.i = getelementptr inbounds i8* %0, i32 4
1058   %d.raw = bitcast double* %d to i8*
1059   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %X.sroa.0.4.raw_idx4.i, i8* %d.raw, i32 4, i32 1, i1 false)
1060
1061   ; Store to the high 32-bits...
1062   %X.sroa.0.4.cast5.i = bitcast i8* %X.sroa.0.4.raw_idx4.i to i32*
1063   store i32 1072693248, i32* %X.sroa.0.4.cast5.i, align 4
1064
1065   ; Do the actual math...
1066   %X.sroa.0.0.load1.i = load double* %X.sroa.0.i, align 8
1067   %accum.real.i = load double* %d, align 8
1068   %add.r.i = fadd double %accum.real.i, %X.sroa.0.0.load1.i
1069   store double %add.r.i, double* %d, align 8
1070   call void @llvm.lifetime.end(i64 -1, i8* %0)
1071   ret void
1072 }
1073
1074 define i64 @PR14059.2({ float, float }* %phi) {
1075 ; Check that SROA can split up alloca-wide integer loads and stores where the
1076 ; underlying alloca has smaller components that are accessed independently. This
1077 ; shows up particularly with ABI lowering patterns coming out of Clang that rely
1078 ; on the particular register placement of a single large integer return value.
1079 ; CHECK: @PR14059.2
1080
1081 entry:
1082   %retval = alloca { float, float }, align 4
1083   ; CHECK-NOT: alloca
1084
1085   %0 = bitcast { float, float }* %retval to i64*
1086   store i64 0, i64* %0
1087   ; CHECK-NOT: store
1088
1089   %phi.realp = getelementptr inbounds { float, float }* %phi, i32 0, i32 0
1090   %phi.real = load float* %phi.realp
1091   %phi.imagp = getelementptr inbounds { float, float }* %phi, i32 0, i32 1
1092   %phi.imag = load float* %phi.imagp
1093   ; CHECK:      %[[realp:.*]] = getelementptr inbounds { float, float }* %phi, i32 0, i32 0
1094   ; CHECK-NEXT: %[[real:.*]] = load float* %[[realp]]
1095   ; CHECK-NEXT: %[[imagp:.*]] = getelementptr inbounds { float, float }* %phi, i32 0, i32 1
1096   ; CHECK-NEXT: %[[imag:.*]] = load float* %[[imagp]]
1097
1098   %real = getelementptr inbounds { float, float }* %retval, i32 0, i32 0
1099   %imag = getelementptr inbounds { float, float }* %retval, i32 0, i32 1
1100   store float %phi.real, float* %real
1101   store float %phi.imag, float* %imag
1102   ; CHECK-NEXT: %[[real_convert:.*]] = bitcast float %[[real]] to i32
1103   ; CHECK-NEXT: %[[imag_convert:.*]] = bitcast float %[[imag]] to i32
1104   ; CHECK-NEXT: %[[imag_ext:.*]] = zext i32 %[[imag_convert]] to i64
1105   ; CHECK-NEXT: %[[imag_shift:.*]] = shl i64 %[[imag_ext]], 32
1106   ; CHECK-NEXT: %[[imag_mask:.*]] = and i64 undef, 4294967295
1107   ; CHECK-NEXT: %[[imag_insert:.*]] = or i64 %[[imag_mask]], %[[imag_shift]]
1108   ; CHECK-NEXT: %[[real_ext:.*]] = zext i32 %[[real_convert]] to i64
1109   ; CHECK-NEXT: %[[real_mask:.*]] = and i64 %[[imag_insert]], -4294967296
1110   ; CHECK-NEXT: %[[real_insert:.*]] = or i64 %[[real_mask]], %[[real_ext]]
1111
1112   %1 = load i64* %0, align 1
1113   ret i64 %1
1114   ; CHECK-NEXT: ret i64 %[[real_insert]]
1115 }
1116
1117 define void @PR14105({ [16 x i8] }* %ptr) {
1118 ; Ensure that when rewriting the GEP index '-1' for this alloca we preserve is
1119 ; sign as negative. We use a volatile memcpy to ensure promotion never actually
1120 ; occurs.
1121 ; CHECK-LABEL: @PR14105(
1122
1123 entry:
1124   %a = alloca { [16 x i8] }, align 8
1125 ; CHECK: alloca [16 x i8], align 8
1126
1127   %gep = getelementptr inbounds { [16 x i8] }* %ptr, i64 -1
1128 ; CHECK-NEXT: getelementptr inbounds { [16 x i8] }* %ptr, i64 -1, i32 0, i64 0
1129
1130   %cast1 = bitcast { [16 x i8 ] }* %gep to i8*
1131   %cast2 = bitcast { [16 x i8 ] }* %a to i8*
1132   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %cast1, i8* %cast2, i32 16, i32 8, i1 true)
1133   ret void
1134 ; CHECK: ret
1135 }
1136
1137 define void @PR14105_as1({ [16 x i8] } addrspace(1)* %ptr) {
1138 ; Make sure this the right address space pointer is used for type check.
1139 ; CHECK-LABEL: @PR14105_as1(
1140
1141 entry:
1142   %a = alloca { [16 x i8] }, align 8
1143 ; CHECK: alloca [16 x i8], align 8
1144
1145   %gep = getelementptr inbounds { [16 x i8] } addrspace(1)* %ptr, i64 -1
1146 ; CHECK-NEXT: getelementptr inbounds { [16 x i8] } addrspace(1)* %ptr, i16 -1, i32 0, i16 0
1147
1148   %cast1 = bitcast { [16 x i8 ] } addrspace(1)* %gep to i8 addrspace(1)*
1149   %cast2 = bitcast { [16 x i8 ] }* %a to i8*
1150   call void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* %cast1, i8* %cast2, i32 16, i32 8, i1 true)
1151   ret void
1152 ; CHECK: ret
1153 }
1154
1155 define void @PR14465() {
1156 ; Ensure that we don't crash when analyzing a alloca larger than the maximum
1157 ; integer type width (MAX_INT_BITS) supported by llvm (1048576*32 > (1<<23)-1).
1158 ; CHECK-LABEL: @PR14465(
1159
1160   %stack = alloca [1048576 x i32], align 16
1161 ; CHECK: alloca [1048576 x i32]
1162   %cast = bitcast [1048576 x i32]* %stack to i8*
1163   call void @llvm.memset.p0i8.i64(i8* %cast, i8 -2, i64 4194304, i32 16, i1 false)
1164   ret void
1165 ; CHECK: ret
1166 }
1167
1168 define void @PR14548(i1 %x) {
1169 ; Handle a mixture of i1 and i8 loads and stores to allocas. This particular
1170 ; pattern caused crashes and invalid output in the PR, and its nature will
1171 ; trigger a mixture in several permutations as we resolve each alloca
1172 ; iteratively.
1173 ; Note that we don't do a particularly good *job* of handling these mixtures,
1174 ; but the hope is that this is very rare.
1175 ; CHECK-LABEL: @PR14548(
1176
1177 entry:
1178   %a = alloca <{ i1 }>, align 8
1179   %b = alloca <{ i1 }>, align 8
1180 ; CHECK:      %[[a:.*]] = alloca i8, align 8
1181
1182   %b.i1 = bitcast <{ i1 }>* %b to i1*
1183   store i1 %x, i1* %b.i1, align 8
1184   %b.i8 = bitcast <{ i1 }>* %b to i8*
1185   %foo = load i8* %b.i8, align 1
1186 ; CHECK-NEXT: %[[ext:.*]] = zext i1 %x to i8
1187 ; CHECK-NEXT: store i8 %[[ext]], i8* %[[a]], align 8
1188 ; CHECK-NEXT: {{.*}} = load i8* %[[a]], align 8
1189
1190   %a.i8 = bitcast <{ i1 }>* %a to i8*
1191   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a.i8, i8* %b.i8, i32 1, i32 1, i1 false) nounwind
1192   %bar = load i8* %a.i8, align 1
1193   %a.i1 = getelementptr inbounds <{ i1 }>* %a, i32 0, i32 0
1194   %baz = load i1* %a.i1, align 1
1195 ; CHECK-NEXT: %[[a_cast:.*]] = bitcast i8* %[[a]] to i1*
1196 ; CHECK-NEXT: {{.*}} = load i1* %[[a_cast]], align 8
1197
1198   ret void
1199 }
1200
1201 define <3 x i8> @PR14572.1(i32 %x) {
1202 ; Ensure that a split integer store which is wider than the type size of the
1203 ; alloca (relying on the alloc size padding) doesn't trigger an assert.
1204 ; CHECK: @PR14572.1
1205
1206 entry:
1207   %a = alloca <3 x i8>, align 4
1208 ; CHECK-NOT: alloca
1209
1210   %cast = bitcast <3 x i8>* %a to i32*
1211   store i32 %x, i32* %cast, align 1
1212   %y = load <3 x i8>* %a, align 4
1213   ret <3 x i8> %y
1214 ; CHECK: ret <3 x i8>
1215 }
1216
1217 define i32 @PR14572.2(<3 x i8> %x) {
1218 ; Ensure that a split integer load which is wider than the type size of the
1219 ; alloca (relying on the alloc size padding) doesn't trigger an assert.
1220 ; CHECK: @PR14572.2
1221
1222 entry:
1223   %a = alloca <3 x i8>, align 4
1224 ; CHECK-NOT: alloca
1225
1226   store <3 x i8> %x, <3 x i8>* %a, align 1
1227   %cast = bitcast <3 x i8>* %a to i32*
1228   %y = load i32* %cast, align 4
1229   ret i32 %y
1230 ; CHECK: ret i32
1231 }
1232
1233 define i32 @PR14601(i32 %x) {
1234 ; Don't try to form a promotable integer alloca when there is a variable length
1235 ; memory intrinsic.
1236 ; CHECK-LABEL: @PR14601(
1237
1238 entry:
1239   %a = alloca i32
1240 ; CHECK: alloca
1241
1242   %a.i8 = bitcast i32* %a to i8*
1243   call void @llvm.memset.p0i8.i32(i8* %a.i8, i8 0, i32 %x, i32 1, i1 false)
1244   %v = load i32* %a
1245   ret i32 %v
1246 }
1247
1248 define void @PR15674(i8* %data, i8* %src, i32 %size) {
1249 ; Arrange (via control flow) to have unmerged stores of a particular width to
1250 ; an alloca where we incrementally store from the end of the array toward the
1251 ; beginning of the array. Ensure that the final integer store, despite being
1252 ; convertable to the integer type that we end up promoting this alloca toward,
1253 ; doesn't get widened to a full alloca store.
1254 ; CHECK-LABEL: @PR15674(
1255
1256 entry:
1257   %tmp = alloca [4 x i8], align 1
1258 ; CHECK: alloca i32
1259
1260   switch i32 %size, label %end [
1261     i32 4, label %bb4
1262     i32 3, label %bb3
1263     i32 2, label %bb2
1264     i32 1, label %bb1
1265   ]
1266
1267 bb4:
1268   %src.gep3 = getelementptr inbounds i8* %src, i32 3
1269   %src.3 = load i8* %src.gep3
1270   %tmp.gep3 = getelementptr inbounds [4 x i8]* %tmp, i32 0, i32 3
1271   store i8 %src.3, i8* %tmp.gep3
1272 ; CHECK: store i8
1273
1274   br label %bb3
1275
1276 bb3:
1277   %src.gep2 = getelementptr inbounds i8* %src, i32 2
1278   %src.2 = load i8* %src.gep2
1279   %tmp.gep2 = getelementptr inbounds [4 x i8]* %tmp, i32 0, i32 2
1280   store i8 %src.2, i8* %tmp.gep2
1281 ; CHECK: store i8
1282
1283   br label %bb2
1284
1285 bb2:
1286   %src.gep1 = getelementptr inbounds i8* %src, i32 1
1287   %src.1 = load i8* %src.gep1
1288   %tmp.gep1 = getelementptr inbounds [4 x i8]* %tmp, i32 0, i32 1
1289   store i8 %src.1, i8* %tmp.gep1
1290 ; CHECK: store i8
1291
1292   br label %bb1
1293
1294 bb1:
1295   %src.gep0 = getelementptr inbounds i8* %src, i32 0
1296   %src.0 = load i8* %src.gep0
1297   %tmp.gep0 = getelementptr inbounds [4 x i8]* %tmp, i32 0, i32 0
1298   store i8 %src.0, i8* %tmp.gep0
1299 ; CHECK: store i8
1300
1301   br label %end
1302
1303 end:
1304   %tmp.raw = bitcast [4 x i8]* %tmp to i8*
1305   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %data, i8* %tmp.raw, i32 %size, i32 1, i1 false)
1306   ret void
1307 ; CHECK: ret void
1308 }
1309
1310 define void @PR15805(i1 %a, i1 %b) {
1311 ; CHECK-LABEL: @PR15805(
1312 ; CHECK-NOT: alloca
1313 ; CHECK: ret void
1314
1315   %c = alloca i64, align 8
1316   %p.0.c = select i1 undef, i64* %c, i64* %c
1317   %cond.in = select i1 undef, i64* %p.0.c, i64* %c
1318   %cond = load i64* %cond.in, align 8
1319   ret void
1320 }
1321
1322 define void @PR15805.1(i1 %a, i1 %b) {
1323 ; Same as the normal PR15805, but rigged to place the use before the def inside
1324 ; of looping unreachable code. This helps ensure that we aren't sensitive to the
1325 ; order in which the uses of the alloca are visited.
1326 ;
1327 ; CHECK-LABEL: @PR15805.1(
1328 ; CHECK-NOT: alloca
1329 ; CHECK: ret void
1330
1331   %c = alloca i64, align 8
1332   br label %exit
1333
1334 loop:
1335   %cond.in = select i1 undef, i64* %c, i64* %p.0.c
1336   %p.0.c = select i1 undef, i64* %c, i64* %c
1337   %cond = load i64* %cond.in, align 8
1338   br i1 undef, label %loop, label %exit
1339
1340 exit:
1341   ret void
1342 }
1343
1344 define void @PR16651.1(i8* %a) {
1345 ; This test case caused a crash due to the volatile memcpy in combination with
1346 ; lowering to integer loads and stores of a width other than that of the original
1347 ; memcpy.
1348 ;
1349 ; CHECK-LABEL: @PR16651.1(
1350 ; CHECK: alloca i16
1351 ; CHECK: alloca i8
1352 ; CHECK: alloca i8
1353 ; CHECK: unreachable
1354
1355 entry:
1356   %b = alloca i32, align 4
1357   %b.cast = bitcast i32* %b to i8*
1358   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %b.cast, i8* %a, i32 4, i32 4, i1 true)
1359   %b.gep = getelementptr inbounds i8* %b.cast, i32 2
1360   load i8* %b.gep, align 2
1361   unreachable
1362 }
1363
1364 define void @PR16651.2() {
1365 ; This test case caused a crash due to failing to promote given a select that
1366 ; can't be speculated. It shouldn't be promoted, but we missed that fact when
1367 ; analyzing whether we could form a vector promotion because that code didn't
1368 ; bail on select instructions.
1369 ;
1370 ; CHECK-LABEL: @PR16651.2(
1371 ; CHECK: alloca <2 x float>
1372 ; CHECK: ret void
1373
1374 entry:
1375   %tv1 = alloca { <2 x float>, <2 x float> }, align 8
1376   %0 = getelementptr { <2 x float>, <2 x float> }* %tv1, i64 0, i32 1
1377   store <2 x float> undef, <2 x float>* %0, align 8
1378   %1 = getelementptr inbounds { <2 x float>, <2 x float> }* %tv1, i64 0, i32 1, i64 0
1379   %cond105.in.i.i = select i1 undef, float* null, float* %1
1380   %cond105.i.i = load float* %cond105.in.i.i, align 8
1381   ret void
1382 }
1383
1384 define void @test23(i32 %x) {
1385 ; CHECK-LABEL: @test23(
1386 ; CHECK-NOT: alloca
1387 ; CHECK: ret void
1388 entry:
1389   %a = alloca i32, align 4
1390   store i32 %x, i32* %a, align 4
1391   %gep1 = getelementptr inbounds i32* %a, i32 1
1392   %gep0 = getelementptr inbounds i32* %a, i32 0
1393   %cast1 = bitcast i32* %gep1 to i8*
1394   %cast0 = bitcast i32* %gep0 to i8*
1395   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %cast1, i8* %cast0, i32 4, i32 1, i1 false)
1396   ret void
1397 }
1398
1399 define void @PR18615() {
1400 ; CHECK-LABEL: @PR18615(
1401 ; CHECK-NOT: alloca
1402 ; CHECK: ret void
1403 entry:
1404   %f = alloca i8
1405   %gep = getelementptr i8* %f, i64 -1
1406   call void @llvm.memcpy.p0i8.p0i8.i32(i8* undef, i8* %gep, i32 1, i32 1, i1 false)
1407   ret void
1408 }
1409
1410 define void @test24(i8* %src, i8* %dst) {
1411 ; CHECK-LABEL: @test24(
1412 ; CHECK: alloca i64, align 16
1413 ; CHECK: load volatile i64* %{{[^,]*}}, align 1
1414 ; CHECK: store volatile i64 %{{[^,]*}}, i64* %{{[^,]*}}, align 16
1415 ; CHECK: load volatile i64* %{{[^,]*}}, align 16
1416 ; CHECK: store volatile i64 %{{[^,]*}}, i64* %{{[^,]*}}, align 1
1417
1418 entry:
1419   %a = alloca i64, align 16
1420   %ptr = bitcast i64* %a to i8*
1421   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %src, i32 8, i32 1, i1 true)
1422   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr, i32 8, i32 1, i1 true)
1423   ret void
1424 }
1425
1426 define float @test25() {
1427 ; Check that we split up stores in order to promote the smaller SSA values.. These types
1428 ; of patterns can arise because LLVM maps small memcpy's to integer load and
1429 ; stores. If we get a memcpy of an aggregate (such as C and C++ frontends would
1430 ; produce, but so might any language frontend), this will in many cases turn into
1431 ; an integer load and store. SROA needs to be extremely powerful to correctly
1432 ; handle these cases and form splitable and promotable SSA values.
1433 ;
1434 ; CHECK-LABEL: @test25(
1435 ; CHECK-NOT: alloca
1436 ; CHECK: %[[F1:.*]] = bitcast i32 0 to float
1437 ; CHECK: %[[F2:.*]] = bitcast i32 1065353216 to float
1438 ; CHECK: %[[SUM:.*]] = fadd float %[[F1]], %[[F2]]
1439 ; CHECK: ret float %[[SUM]]
1440
1441 entry:
1442   %a = alloca i64
1443   %b = alloca i64
1444   %a.cast = bitcast i64* %a to [2 x float]*
1445   %a.gep1 = getelementptr [2 x float]* %a.cast, i32 0, i32 0
1446   %a.gep2 = getelementptr [2 x float]* %a.cast, i32 0, i32 1
1447   %b.cast = bitcast i64* %b to [2 x float]*
1448   %b.gep1 = getelementptr [2 x float]* %b.cast, i32 0, i32 0
1449   %b.gep2 = getelementptr [2 x float]* %b.cast, i32 0, i32 1
1450   store float 0.0, float* %a.gep1
1451   store float 1.0, float* %a.gep2
1452   %v = load i64* %a
1453   store i64 %v, i64* %b
1454   %f1 = load float* %b.gep1
1455   %f2 = load float* %b.gep2
1456   %ret = fadd float %f1, %f2
1457   ret float %ret
1458 }