1; RUN: opt < %s -sroa -S | FileCheck %s 2target 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-f80:128-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64" 3 4declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind 5declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i32, i1) nounwind 6 7define void @no_split_on_non_byte_width(i32) { 8; This tests that allocas are not split into slices that are not byte width multiple 9 %arg = alloca i32 , align 8 10 store i32 %0, i32* %arg 11 br label %load_i32 12 13load_i32: 14; CHECK-LABEL: load_i32: 15; CHECK-NOT: bitcast {{.*}} to i1 16; CHECK-NOT: zext i1 17 %r0 = load i32, i32* %arg 18 br label %load_i1 19 20load_i1: 21; CHECK-LABEL: load_i1: 22; CHECK: bitcast {{.*}} to i1 23 %p1 = bitcast i32* %arg to i1* 24 %t1 = load i1, i1* %p1 25 ret void 26} 27 28; PR18726: Check that we use memcpy and memset to fill out padding when we have 29; a slice with a simple single type whose store size is smaller than the slice 30; size. 31 32%union.Foo = type { x86_fp80, i64, i64 } 33 34@foo_copy_source = external constant %union.Foo 35@i64_sink = global i64 0 36 37define void @memcpy_fp80_padding() { 38 %x = alloca %union.Foo 39 40 ; Copy from a global. 41 %x_i8 = bitcast %union.Foo* %x to i8* 42 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %x_i8, i8* bitcast (%union.Foo* @foo_copy_source to i8*), i32 32, i32 16, i1 false) 43 44 ; Access a slice of the alloca to trigger SROA. 45 %mid_p = getelementptr %union.Foo, %union.Foo* %x, i32 0, i32 1 46 %elt = load i64, i64* %mid_p 47 store i64 %elt, i64* @i64_sink 48 ret void 49} 50; CHECK-LABEL: define void @memcpy_fp80_padding 51; CHECK: alloca x86_fp80 52; CHECK: call void @llvm.memcpy.p0i8.p0i8.i32 53; CHECK: load i64, i64* getelementptr inbounds (%union.Foo, %union.Foo* @foo_copy_source, i64 0, i32 1) 54; CHECK: load i64, i64* getelementptr inbounds (%union.Foo, %union.Foo* @foo_copy_source, i64 0, i32 2) 55 56define void @memset_fp80_padding() { 57 %x = alloca %union.Foo 58 59 ; Set to all ones. 60 %x_i8 = bitcast %union.Foo* %x to i8* 61 call void @llvm.memset.p0i8.i32(i8* %x_i8, i8 -1, i32 32, i32 16, i1 false) 62 63 ; Access a slice of the alloca to trigger SROA. 64 %mid_p = getelementptr %union.Foo, %union.Foo* %x, i32 0, i32 1 65 %elt = load i64, i64* %mid_p 66 store i64 %elt, i64* @i64_sink 67 ret void 68} 69; CHECK-LABEL: define void @memset_fp80_padding 70; CHECK: alloca x86_fp80 71; CHECK: call void @llvm.memset.p0i8.i32(i8* %{{.*}}, i8 -1, i32 16, i32 16, i1 false) 72; CHECK: store i64 -1, i64* @i64_sink 73 74%S.vec3float = type { float, float, float } 75%U.vec3float = type { <4 x float> } 76 77declare i32 @memcpy_vec3float_helper(%S.vec3float*) 78 79define i32 @memcpy_vec3float_widening(%S.vec3float* %x) { 80; CHECK-LABEL: @memcpy_vec3float_widening( 81; PR18726: Check that SROA does not rewrite a 12-byte memcpy into a 16-byte 82; vector store, hence accidentally putting gibberish onto the stack. 83entry: 84 ; Create a temporary variable %tmp1 and copy %x[0] into it 85 %tmp1 = alloca %S.vec3float, align 4 86 %0 = bitcast %S.vec3float* %tmp1 to i8* 87 %1 = bitcast %S.vec3float* %x to i8* 88 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %0, i8* %1, i32 12, i32 4, i1 false) 89 90 ; The following block does nothing; but appears to confuse SROA 91 %unused1 = bitcast %S.vec3float* %tmp1 to %U.vec3float* 92 %unused2 = getelementptr inbounds %U.vec3float, %U.vec3float* %unused1, i32 0, i32 0 93 %unused3 = load <4 x float>, <4 x float>* %unused2, align 1 94 95 ; Create a second temporary and copy %tmp1 into it 96 %tmp2 = alloca %S.vec3float, align 4 97 %2 = bitcast %S.vec3float* %tmp2 to i8* 98 %3 = bitcast %S.vec3float* %tmp1 to i8* 99; CHECK: alloca 100; CHECK-NOT: store <4 x float> 101 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %2, i8* %3, i32 12, i32 4, i1 false) 102 103 %result = call i32 @memcpy_vec3float_helper(%S.vec3float* %tmp2) 104 ret i32 %result 105; CHECK: ret i32 %result 106} 107