Test source: git
Comments: LLVM bug: memcpy -> load/store
Source: <stdin>
ERROR: Unsupported instruction: %B = addrspacecast [8 x i8]* %A to i64 addrspace(1)*
ERROR: Unsupported instruction: %B = addrspacecast [256 x i8]* %A to i64 addrspace(1)*
ERROR: Unsupported instruction: %B = addrspacecast [256 x i8]* %A to i64 addrspace(1)*
ERROR: Unsupported metadata: 1
ERROR: Unsupported metadata: 1
ERROR: Unsupported instruction: %fptr.as1 = addrspacecast float* %fptr to float addrspace(1)*
ERROR: Unsupported metadata: 1
ERROR: Unsupported metadata: 1
ERROR: Unsupported metadata: 1
ERROR: Unsupported metadata: 1
ERROR: Unsupported metadata: 1
ERROR: Unsupported instruction: %cast1 = addrspacecast %opaque* %x to i8 addrspace(1)*
ERROR: Unsupported instruction: %cond.in = select i1 %a, i64* %c, i64* %p.0.c
ERROR: Unsupported metadata: 1
ERROR: Unsupported instruction: store volatile i16 42, i16* %a.cast, align 2
ERROR: Unsupported instruction: store volatile i16 42, i16* %a.cast2, align 2
ERROR: Unsupported instruction: store atomic volatile i64 0, i64* %ptr seq_cst, align 8
----------------------------------------
define i32 @test0() {
%entry:
%a1 = alloca i64 4, align 4, dead
%a2 = alloca i64 4, align 4, dead
%a1.i8 = bitcast ptr %a1 to ptr
start_lifetime ptr %a1.i8
store i32 0, ptr %a1, align 4
%v1 = load i32, ptr %a1, align 4
free ptr %a1.i8 unconstrained
%a2.i8 = bitcast ptr %a2 to ptr
start_lifetime ptr %a2.i8
store float 0.000000, ptr %a2, align 4
%v2 = load float, ptr %a2, align 4
%v2.int = bitcast float %v2 to i32
%sum1 = add i32 %v1, %v2.int
free ptr %a2.i8 unconstrained
ret i32 %sum1
}
=>
define i32 @test0() {
%entry:
%v2.int = bitcast float 0.000000 to i32
%sum1 = add i32 0, %v2.int
ret i32 %sum1
}
Transformation seems to be correct!
----------------------------------------
define i32 @test1() {
%entry:
%X = alloca i64 8, align 8
%Y = gep ptr %X, 8 x i64 0, 1 x i64 0
store i32 0, ptr %Y, align 4
%Z = load i32, ptr %Y, align 4
ret i32 %Z
}
=>
define i32 @test1() {
%entry:
ret i32 0
}
Transformation seems to be correct!
----------------------------------------
define i64 @test2(i64 %X) {
%entry:
%A = alloca i64 8, align 1
%B = bitcast ptr %A to ptr
store i64 %X, ptr %B, align 4
br label %L2
%L2:
%Z = load i64, ptr %B, align 4
ret i64 %Z
}
=>
define i64 @test2(i64 %X) {
%entry:
br label %L2
%L2:
ret i64 %X
}
Transformation seems to be correct!
ERROR: Unsupported instruction: %A.sroa.0.2.gepB.sroa_cast = addrspacecast i8* %A.sroa.0.2.gepB.sroa_idx to i64 addrspace(1)*
ERROR: Unsupported metadata: 1
ERROR: Unsupported metadata: 1
----------------------------------------
define i16 @test5() {
%entry:
%a = alloca i64 4, align 1
%fptr = bitcast ptr %a to ptr
store float 0.000000, ptr %fptr, align 4
%ptr = gep ptr %a, 4 x i32 0, 1 x i32 2
%iptr = bitcast ptr %ptr to ptr
%val = load i16, ptr %iptr, align 2
ret i16 %val
}
=>
define i16 @test5() {
%entry:
%0 = bitcast float 0.000000 to i32
%a.sroa.0.2.extract.shift = lshr i32 %0, 16
%a.sroa.0.2.extract.trunc = trunc i32 %a.sroa.0.2.extract.shift to i16
ret i16 %a.sroa.0.2.extract.trunc
}
Transformation seems to be correct!
ERROR: Unsupported instruction: store volatile i32 707406378, i32* %a.sroa.0, align 4
ERROR: Unsupported instruction: %a.sroa.0.0.copyload = load volatile i32, i32* %a.sroa.0.0.src.sroa_cast, align 1, !tbaa !0
ERROR: Unsupported metadata: 1
----------------------------------------
define i64 @test9() {
%entry:
%a = alloca i64 3, align 8
%gep1 = gep inbounds ptr %a, 3 x i32 0, 1 x i64 0, 1 x i32 0
store i8 0, ptr %gep1, align 1
%gep2 = gep inbounds ptr %a, 3 x i32 0, 1 x i64 0, 1 x i32 1
store i8 0, ptr %gep2, align 1
%gep3 = gep inbounds ptr %a, 3 x i32 0, 1 x i64 0, 1 x i32 2
store i8 26, ptr %gep3, align 1
%cast = bitcast ptr %a to ptr
%elt = gep inbounds ptr %cast, 8 x i32 0, 1 x i64 0
%load = load i64, ptr %elt, align 4
%result = and i64 %load, 16777215
ret i64 %result
}
=>
define i64 @test9() {
%entry:
%a.sroa.3.0.insert.ext = zext i8 26 to i64
%a.sroa.3.0.insert.shift = shl i64 %a.sroa.3.0.insert.ext, 16
%a.sroa.3.0.insert.mask = and i64 undef, -16711681
%a.sroa.3.0.insert.insert = or i64 %a.sroa.3.0.insert.mask, %a.sroa.3.0.insert.shift
%a.sroa.2.0.insert.ext = zext i8 0 to i64
%a.sroa.2.0.insert.shift = shl i64 %a.sroa.2.0.insert.ext, 8
%a.sroa.2.0.insert.mask = and i64 %a.sroa.3.0.insert.insert, -65281
%a.sroa.2.0.insert.insert = or i64 %a.sroa.2.0.insert.mask, %a.sroa.2.0.insert.shift
%a.sroa.0.0.insert.ext = zext i8 0 to i64
%a.sroa.0.0.insert.mask = and i64 %a.sroa.2.0.insert.insert, -256
%a.sroa.0.0.insert.insert = or i64 %a.sroa.0.0.insert.mask, %a.sroa.0.0.insert.ext
%result = and i64 %a.sroa.0.0.insert.insert, 16777215
ret i64 %result
}
Transformation seems to be correct!
----------------------------------------
define ptr @test10() {
%entry:
%a = alloca i64 8, align 1
%ptr = gep ptr %a, 8 x i32 0, 1 x i32 0
memset ptr %ptr align 1, i8 0, i32 8
%s2ptrptr = bitcast ptr %ptr to ptr
%s2ptr = load ptr, ptr %s2ptrptr, align 8
ret ptr %s2ptr
}
=>
define ptr @test10() {
%entry:
ret ptr null
}
Transformation seems to be correct!
----------------------------------------
define i32 @test11(i1 %c1) {
%entry:
%X = alloca i64 4, align 4
br i1 %c1, label %good, label %bad
%bad:
%Y2 = gep ptr %X, 4 x i64 1
store i32 0, ptr %Y2, align 4
%Z2 = load i32, ptr %Y2, align 4
ret i32 %Z2
%good:
%Y = gep ptr %X, 4 x i64 0
store i32 0, ptr %Y, align 4
%Z = load i32, ptr %Y, align 4
ret i32 %Z
}
=>
define i32 @test11(i1 %c1) {
%entry:
br i1 %c1, label %good, label %bad
%bad:
ret i32 poison
%good:
ret i32 0
}
Transformation seems to be correct!
----------------------------------------
define i8 @test12() {
%entry:
%a = alloca i64 3, align 1
%b = alloca i64 3, align 1
%a0ptr = gep ptr %a, 3 x i64 0, 1 x i32 0
store i8 0, ptr %a0ptr, align 1
%a1ptr = gep ptr %a, 3 x i64 0, 1 x i32 1
store i8 0, ptr %a1ptr, align 1
%a2ptr = gep ptr %a, 3 x i64 0, 1 x i32 2
store i8 0, ptr %a2ptr, align 1
%aiptr = bitcast ptr %a to ptr
%ai = load i24, ptr %aiptr, align 4
%biptr = bitcast ptr %b to ptr
store i24 %ai, ptr %biptr, align 4
%b0ptr = gep ptr %b, 3 x i64 0, 1 x i32 0
%b0 = load i8, ptr %b0ptr, align 1
%b1ptr = gep ptr %b, 3 x i64 0, 1 x i32 1
%b1 = load i8, ptr %b1ptr, align 1
%b2ptr = gep ptr %b, 3 x i64 0, 1 x i32 2
%b2 = load i8, ptr %b2ptr, align 1
%bsum0 = add i8 %b0, %b1
%bsum1 = add i8 %bsum0, %b2
ret i8 %bsum1
}
=>
define i8 @test12() {
%entry:
%a.sroa.3.0.insert.ext = zext i8 0 to i24
%a.sroa.3.0.insert.shift = shl i24 %a.sroa.3.0.insert.ext, 16
%a.sroa.3.0.insert.mask = and i24 undef, 65535
%a.sroa.3.0.insert.insert = or i24 %a.sroa.3.0.insert.mask, %a.sroa.3.0.insert.shift
%a.sroa.2.0.insert.ext = zext i8 0 to i24
%a.sroa.2.0.insert.shift = shl i24 %a.sroa.2.0.insert.ext, 8
%a.sroa.2.0.insert.mask = and i24 %a.sroa.3.0.insert.insert, 16711935
%a.sroa.2.0.insert.insert = or i24 %a.sroa.2.0.insert.mask, %a.sroa.2.0.insert.shift
%a.sroa.0.0.insert.ext = zext i8 0 to i24
%a.sroa.0.0.insert.mask = and i24 %a.sroa.2.0.insert.insert, 16776960
%a.sroa.0.0.insert.insert = or i24 %a.sroa.0.0.insert.mask, %a.sroa.0.0.insert.ext
%b.sroa.0.0.extract.trunc = trunc i24 %a.sroa.0.0.insert.insert to i8
%b.sroa.2.0.extract.shift = lshr i24 %a.sroa.0.0.insert.insert, 8
%b.sroa.2.0.extract.trunc = trunc i24 %b.sroa.2.0.extract.shift to i8
%b.sroa.3.0.extract.shift = lshr i24 %a.sroa.0.0.insert.insert, 16
%b.sroa.3.0.extract.trunc = trunc i24 %b.sroa.3.0.extract.shift to i8
%bsum0 = add i8 %b.sroa.0.0.extract.trunc, %b.sroa.2.0.extract.trunc
%bsum1 = add i8 %bsum0, %b.sroa.3.0.extract.trunc
ret i8 %bsum1
}
Transformation seems to be correct!
----------------------------------------
define i32 @test13() {
%entry:
%a = alloca i64 3, align 2
%b0ptr = gep ptr %a, 3 x i64 0, 1 x i32 0
store i8 0, ptr %b0ptr, align 1
%b1ptr = gep ptr %a, 3 x i64 0, 1 x i32 1
store i8 0, ptr %b1ptr, align 1
%b2ptr = gep ptr %a, 3 x i64 0, 1 x i32 2
store i8 0, ptr %b2ptr, align 1
%iptrcast = bitcast ptr %a to ptr
%iptrgep = gep ptr %iptrcast, 2 x i64 1
%i = load i16, ptr %iptrgep, align 2
%ret = zext i16 %i to i32
ret i32 %ret
}
=>
define i32 @test13() {
%entry:
%a.sroa.2.2.load.ext = zext i8 0 to i16
%ret = zext i16 %a.sroa.2.2.load.ext to i32
ret i32 %ret
}
Transformation seems to be correct!
----------------------------------------
define void @test14(...) {
%entry:
%a = alloca i64 12, align 8
%p = alloca i64 8, align 8
%0 = bitcast ptr %a to ptr
%1 = gep ptr %0, 1 x i64 12
%2 = bitcast ptr %1 to ptr
%3 = gep inbounds ptr %2, 12 x i32 0, 1 x i64 0
%4 = gep inbounds ptr %a, 12 x i32 0, 1 x i64 0
%5 = bitcast ptr %3 to ptr
%6 = bitcast ptr %4 to ptr
%7 = load i32, ptr %6, align 4
store i32 %7, ptr %5, align 4
%8 = gep inbounds ptr %5, 4 x i32 1
%9 = gep inbounds ptr %6, 4 x i32 1
%10 = load i32, ptr %9, align 4
store i32 %10, ptr %8, align 4
%11 = gep inbounds ptr %5, 4 x i32 2
%12 = gep inbounds ptr %6, 4 x i32 2
%13 = load i32, ptr %12, align 4
store i32 %13, ptr %11, align 4
ret void
}
=>
define void @test14(...) {
%entry:
ret void
}
Transformation seems to be correct!
----------------------------------------
define i32 @test15(i1 %flag) {
%entry:
%l0 = alloca i64 8, align 8
%l1 = alloca i64 8, align 8
%l2 = alloca i64 8, align 8
%l3 = alloca i64 8, align 8
br label %loop
%loop:
%dead3 = phi ptr [ %gep3, %loop ], [ null, %entry ]
store i64 1879048192, ptr %l0, align 8
store i64 1879048192, ptr %l1, align 8
store i64 1879048192, ptr %l2, align 8
%bc2 = bitcast ptr %l2 to ptr
%gep2.1 = gep ptr %bc2, 1 x i64 1
%gep2.2 = gep ptr %bc2, 1 x i64 3
%dead2 = select i1 %flag, ptr %gep2.1, ptr %gep2.2
store i64 1879048192, ptr %l3, align 8
%bc3 = bitcast ptr %l3 to ptr
%gep3 = gep ptr %bc3, 1 x i64 3
br label %loop
}
=>
define i32 @test15(i1 %flag) {
%entry:
br label %loop
%loop:
br label %loop
}
Transformation seems to be correct!
ERROR: Unsupported metadata: 1
ERROR: Unsupported metadata: 1
ERROR: Unsupported metadata: 1
----------------------------------------
define i64 @test19(ptr %x) {
%entry:
%a = alloca i64 16, align 8
%cast1 = bitcast ptr %x to ptr
%cast2 = bitcast ptr %a to ptr
memcpy ptr %cast2 align 1, ptr %cast1 align 1, i32 16
%gep = gep inbounds ptr %a, 16 x i32 0, 1 x i64 0
%val = load i64, ptr %gep, align 4
ret i64 %val
}
=>
define i64 @test19(ptr %x) {
%entry:
%cast1 = bitcast ptr %x to ptr
%a.sroa.0.0.cast1.sroa_cast = bitcast ptr %cast1 to ptr
%a.sroa.0.0.copyload = load i64, ptr %a.sroa.0.0.cast1.sroa_cast, align 1
%a.sroa.2.0.cast1.sroa_idx = gep inbounds ptr %cast1, 1 x i64 8
%a.sroa.2.0.cast1.sroa_cast = bitcast ptr %a.sroa.2.0.cast1.sroa_idx to ptr
%a.sroa.2.0.copyload = load ptr, ptr %a.sroa.2.0.cast1.sroa_cast, align 1
ret i64 %a.sroa.0.0.copyload
}
Transformation seems to be correct!
ERROR: Unsupported instruction: %cast1 = addrspacecast %opaque* %x to i8 addrspace(1)*
----------------------------------------
define i32 @test20() {
%entry:
%a = alloca i64 12, align 4
%gep1 = gep ptr %a, 12 x i32 0, 4 x i32 0
store i32 1, ptr %gep1, align 4
%gep2.1 = gep ptr %a, 12 x i32 0, 4 x i32 4294967294
%gep2.2 = gep ptr %gep2.1, 4 x i32 3
store i32 2, ptr %gep2.2, align 4
%gep3.1 = gep ptr %a, 12 x i32 0, 4 x i32 14
%gep3.2 = gep ptr %gep3.1, 4 x i32 4294967284
store i32 3, ptr %gep3.2, align 4
%load1 = load i32, ptr %gep1, align 4
%load2 = load i32, ptr %gep2.2, align 4
%load3 = load i32, ptr %gep3.2, align 4
%sum1 = add i32 %load1, %load2
%sum2 = add i32 %sum1, %load3
ret i32 %sum2
}
=>
define i32 @test20() {
%entry:
%sum1 = add i32 1, 2
%sum2 = add i32 %sum1, 3
ret i32 %sum2
}
Transformation seems to be correct!
----------------------------------------
define i8 @test21() {
%entry:
%a = alloca i64 2305843009213693951, align 1
%gep0 = gep ptr %a, 2305843009213693951 x i64 0, 1 x i64 2305843009213693949
store i8 255, ptr %gep0, align 1
%gep1 = gep ptr %a, 2305843009213693951 x i64 0, 1 x i64 -9223372036854775807
%gep2 = gep ptr %gep1, 1 x i64 -1
memset ptr %gep2 align 1, i8 0, i64 -1
%gep3 = gep ptr %gep1, 1 x i64 9223372036854775807
%gep4 = gep ptr %gep3, 1 x i64 9223372036854775807
%gep5 = gep ptr %gep4, 1 x i64 -6917529027641081857
store i8 255, ptr %gep5, align 1
%cast1 = bitcast ptr %gep4 to ptr
store i32 0, ptr %cast1, align 4
%load = load i8, ptr %gep0, align 1
%gep6 = gep ptr %gep0, 1 x i32 1
%load2 = load i8, ptr %gep6, align 1
%result = or i8 %load, %load2
ret i8 %result
}
=>
define i8 @test21() {
%entry:
%result = or i8 255, 255
ret i8 %result
}
Transformation seems to be correct!
----------------------------------------
define void @PR13916.1() {
%entry:
%a = alloca i64 1, align 1
memcpy ptr %a align 1, ptr %a align 1, i32 1
%tmp2 = load i8, ptr %a, align 1
ret void
}
=>
define void @PR13916.1() {
%entry:
ret void
}
Transformation seems to be correct!
----------------------------------------
define void @PR13916.2(i1 %c1) {
%entry:
%a = alloca i64 1, align 1
br i1 %c1, label %if.then, label %if.end
%if.then:
%tmp0 = bitcast ptr %a to ptr
%tmp1 = bitcast ptr %a to ptr
memcpy ptr %tmp0 align 1, ptr %tmp1 align 1, i32 1
br label %if.end
%if.end:
%gep = gep ptr %a, 1 x i32 0, 1 x i64 0
%tmp2 = load i8, ptr %gep, align 1
ret void
}
=>
define void @PR13916.2(i1 %c1) {
%entry:
br i1 %c1, label %if.then, label %if.end
%if.then:
br label %if.end
%if.end:
ret void
}
Transformation seems to be correct!
----------------------------------------
define void @PR13990(i1 %c1, i1 %c2, i1 %c3, i1 %c4, ptr %ptr) {
%entry:
%tmp1 = alloca i64 8, align 8
%tmp2 = alloca i64 8, align 8
br i1 %c1, label %bb1, label %bb2
%bb1:
store ptr %ptr, ptr %tmp2, align 8
br i1 %c2, label %bb2, label %bb3
%bb2:
%tmp50 = select i1 %c3, ptr %tmp2, ptr %tmp1
br i1 %c4, label %bb3, label %bb4
%bb4:
assume i1 0
%bb3:
assume i1 0
}
=>
define void @PR13990(i1 %c1, i1 %c2, i1 %c3, i1 %c4, ptr %ptr) {
%entry:
br i1 %c1, label %bb1, label %bb2
%bb1:
br i1 %c2, label %bb2, label %bb3
%bb2:
br i1 %c4, label %bb3, label %bb4
%bb4:
assume i1 0
%bb3:
assume i1 0
}
Transformation seems to be correct!
----------------------------------------
define double @PR13969(double %x) {
%entry:
%a = alloca i64 8, align 8
%b = alloca i64 8, align 8
%c = alloca i64 8, align 8
store double %x, ptr %a, align 8
store ptr %c, ptr %b, align 8
store ptr %a, ptr %b, align 8
store double %x, ptr %c, align 8
%ret = load double, ptr %a, align 8
ret double %ret
}
=>
define double @PR13969(double %x) {
%entry:
ret double %x
}
Transformation seems to be correct!
----------------------------------------
define void @PR14034(ptr %ptr, ptr %ptr2) {
%entry:
%a = alloca i64 24, align 8
%list = gep ptr %a, 24 x i32 0, 1 x i64 8
%prev = gep ptr %list, 16 x i32 0, 1 x i64 8
store ptr %ptr, ptr %prev, align 8
%cast0 = bitcast ptr %ptr2 to ptr
%cast1 = bitcast ptr %a to ptr
memcpy ptr %cast0 align 1, ptr %cast1 align 1, i32 12
ret void
}
=>
define void @PR14034(ptr %ptr, ptr %ptr2) {
%entry:
%a.sroa.0 = alloca i64 12, align 8
%a.sroa.0.0.cast0.sroa_cast = bitcast ptr %ptr2 to ptr
%a.sroa.0.0.cast1.sroa_idx = gep inbounds ptr %a.sroa.0, 12 x i64 0, 1 x i64 0
memcpy ptr %a.sroa.0.0.cast0.sroa_cast align 1, ptr %a.sroa.0.0.cast1.sroa_idx align 8, i32 12
ret void
}
Transformation seems to be correct!
----------------------------------------
define i32 @test22(i32 %x) {
%entry:
%a1 = alloca i64 4, align 8
%a2 = alloca i64 4, align 8
%a3 = alloca i64 8, align 8
%wrap1 = insertvalue [1 x {i32}] poison, i32 %x, 0, 0
%gep1 = gep ptr %a1, 4 x i32 0, 1 x i64 0, 1 x i64 0
store [1 x {i32}] %wrap1, ptr %gep1, align 4
%gep2 = gep ptr %a1, 4 x i32 0, 1 x i64 0
%ptrcast1 = bitcast ptr %gep2 to ptr
%load1 = load {[1 x {float}]}, ptr %ptrcast1, align 4
%unwrap1 = extractvalue {[1 x {float}]} %load1, 0, 0
%wrap2 = insertvalue {{}, {float}, (empty array)} poison, {float} %unwrap1, 1
store {{}, {float}, (empty array)} %wrap2, ptr %a2, align 4
%gep3 = gep ptr %a2, 4 x i32 0, 1 x i64 0, 1 x i64 0
%ptrcast2 = bitcast ptr %gep3 to ptr
%load3 = load <4 x i8>, ptr %ptrcast2, align 4
%valcast1 = bitcast <4 x i8> %load3 to i32
%wrap3 = insertvalue [1 x [1 x i32]] poison, i32 %valcast1, 0, 0
%wrap4 = insertvalue {[1 x [1 x i32]], {}} poison, [1 x [1 x i32]] %wrap3, 0
%gep4 = gep ptr %a3, 8 x i32 0, 1 x i64 0
%ptrcast3 = bitcast ptr %gep4 to ptr
store {[1 x [1 x i32]], {}} %wrap4, ptr %ptrcast3, align 4
%gep5 = gep ptr %a3, 8 x i32 0, 1 x i64 0, 1 x i64 0, 4 x i32 0
%ptrcast4 = bitcast ptr %gep5 to ptr
%load4 = load {{}, float, {}}, ptr %ptrcast4, align 4
%unwrap2 = extractvalue {{}, float, {}} %load4, 1
%valcast2 = bitcast float %unwrap2 to i32
ret i32 %valcast2
}
=>
define i32 @test22(i32 %x) {
%entry:
%wrap1 = insertvalue [1 x {i32}] poison, i32 %x, 0, 0
%wrap1.fca.0.0.extract = extractvalue [1 x {i32}] %wrap1, 0, 0
%0 = bitcast i32 %wrap1.fca.0.0.extract to float
%load1.fca.0.0.0.insert = insertvalue {[1 x {float}]} poison, float %0, 0, 0, 0
%unwrap1 = extractvalue {[1 x {float}]} %load1.fca.0.0.0.insert, 0, 0
%wrap2 = insertvalue {{}, {float}, (empty array)} poison, {float} %unwrap1, 1
%wrap2.fca.1.0.extract = extractvalue {{}, {float}, (empty array)} %wrap2, 1, 0
%1 = bitcast float %wrap2.fca.1.0.extract to <4 x i8>
%valcast1 = bitcast <4 x i8> %1 to i32
%wrap3 = insertvalue [1 x [1 x i32]] poison, i32 %valcast1, 0, 0
%wrap4 = insertvalue {[1 x [1 x i32]], {}} poison, [1 x [1 x i32]] %wrap3, 0
%wrap4.fca.0.0.0.extract = extractvalue {[1 x [1 x i32]], {}} %wrap4, 0, 0, 0
%2 = bitcast i32 %wrap4.fca.0.0.0.extract to <4 x i8>
%3 = bitcast <4 x i8> %2 to float
%load4.fca.1.insert = insertvalue {{}, float, {}} poison, float %3, 1
%unwrap2 = extractvalue {{}, float, {}} %load4.fca.1.insert, 1
%valcast2 = bitcast float %unwrap2 to i32
ret i32 %valcast2
}
Transformation seems to be correct!
----------------------------------------
define void @PR14059.1(ptr %d) {
%entry:
%X.sroa.0.i = alloca i64 8, align 8, dead
%0 = bitcast ptr %X.sroa.0.i to ptr
start_lifetime ptr %0
%X.sroa.0.0.cast2.i = bitcast ptr %X.sroa.0.i to ptr
store i32 0, ptr %X.sroa.0.0.cast2.i, align 8
%X.sroa.0.2.raw_idx2.i = gep inbounds ptr %0, 1 x i32 2
memset ptr %X.sroa.0.2.raw_idx2.i align 1, i8 0, i64 4
memset ptr %0 align 1, i8 0, i64 8
%X.sroa.0.4.raw_idx4.i = gep inbounds ptr %0, 1 x i32 4
%d.raw = bitcast ptr %d to ptr
memcpy ptr %X.sroa.0.4.raw_idx4.i align 1, ptr %d.raw align 1, i32 4
%X.sroa.0.4.cast5.i = bitcast ptr %X.sroa.0.4.raw_idx4.i to ptr
store i32 1072693248, ptr %X.sroa.0.4.cast5.i, align 4
%X.sroa.0.0.load1.i = load double, ptr %X.sroa.0.i, align 8
%accum.real.i = load double, ptr %d, align 8
%add.r.i = fadd double %accum.real.i, %X.sroa.0.0.load1.i, exceptions=ignore
store double %add.r.i, ptr %d, align 8
free ptr %0 unconstrained
ret void
}
=>
define void @PR14059.1(ptr %d) {
%entry:
%0 = bitcast double undef to i64
%X.sroa.0.i.0.insert.mask = and i64 %0, -4294967296
%X.sroa.0.i.0.insert.insert = or i64 %X.sroa.0.i.0.insert.mask, 0
%1 = bitcast i64 %X.sroa.0.i.0.insert.insert to double
%2 = bitcast double %1 to i64
%X.sroa.0.i.2.insert.mask = and i64 %2, -281474976645121
%X.sroa.0.i.2.insert.insert = or i64 %X.sroa.0.i.2.insert.mask, 0
%X.sroa.0.i.4.d.raw.sroa_cast = bitcast ptr %d to ptr
%X.sroa.0.i.4.copyload = load i32, ptr %X.sroa.0.i.4.d.raw.sroa_cast, align 1
%5 = bitcast double 0.000000 to i64
%X.sroa.0.i.4.insert.ext = zext i32 %X.sroa.0.i.4.copyload to i64
%X.sroa.0.i.4.insert.shift = shl i64 %X.sroa.0.i.4.insert.ext, 32
%X.sroa.0.i.4.insert.mask4 = and i64 %5, 4294967295
%X.sroa.0.i.4.insert.insert5 = or i64 %X.sroa.0.i.4.insert.mask4, %X.sroa.0.i.4.insert.shift
%6 = bitcast i64 %X.sroa.0.i.4.insert.insert5 to double
%7 = bitcast double %6 to i64
%X.sroa.0.i.4.insert.mask = and i64 %7, 4294967295
%X.sroa.0.i.4.insert.insert = or i64 %X.sroa.0.i.4.insert.mask, 4607182418800017408
%8 = bitcast i64 %X.sroa.0.i.4.insert.insert to double
%accum.real.i = load double, ptr %d, align 8
%add.r.i = fadd double %accum.real.i, %8, exceptions=ignore
store double %add.r.i, ptr %d, align 8
ret void
}
Transformation doesn't verify!
ERROR: Mismatch in memory
Example:
ptr %d = pointer(non-local, block_id=1, offset=0)
Source:
ptr %X.sroa.0.i = pointer(local, block_id=2, offset=0)
ptr %0 = pointer(local, block_id=2, offset=0)
ptr %X.sroa.0.0.cast2.i = pointer(local, block_id=2, offset=0)
ptr %X.sroa.0.2.raw_idx2.i = pointer(local, block_id=2, offset=2)
ptr %X.sroa.0.4.raw_idx4.i = pointer(local, block_id=2, offset=4)
ptr %d.raw = pointer(non-local, block_id=1, offset=0)
ptr %X.sroa.0.4.cast5.i = pointer(local, block_id=2, offset=4)
double %X.sroa.0.0.load1.i = #x3ff0000000000000 (1)
double %accum.real.i = #x3ff02087fff00003 (1.007942199474?)
double %add.r.i = #x40001043fff80002 (2.007942199474?)
SOURCE MEMORY STATE
===================
NON-LOCAL BLOCKS:
Block 0 > size: 0 align: 1 alloc type: 0
Block 1 > size: 32 align: 256 alloc type: 0
LOCAL BLOCKS:
Block 2 > size: 8 align: 8 alloc type: 1
Target:
i64 %0 = #x7fffffffffffffff (9223372036854775807) [based on undef value]
i64 %X.sroa.0.i.0.insert.mask = #x7fffffff00000000 (9223372032559808512)
i64 %X.sroa.0.i.0.insert.insert = #x7fffffff00000000 (9223372032559808512)
double %1 = NaN
i64 %2 = #x7fffffffffffffff (9223372036854775807)
i64 %X.sroa.0.i.2.insert.mask = #x7fff00000000ffff (9223090561878130687)
i64 %X.sroa.0.i.2.insert.insert = #x7fff00000000ffff (9223090561878130687)
ptr %X.sroa.0.i.4.d.raw.sroa_cast = pointer(non-local, block_id=1, offset=0)
i32 %X.sroa.0.i.4.copyload = #xfff00003 (4293918723, -1048573)
i64 %5 = #x0000000000000000 (0)
i64 %X.sroa.0.i.4.insert.ext = #x00000000fff00003 (4293918723)
i64 %X.sroa.0.i.4.insert.shift = #xfff0000300000000 (18442240486967083008, -4503586742468608)
i64 %X.sroa.0.i.4.insert.mask4 = #x0000000000000000 (0)
i64 %X.sroa.0.i.4.insert.insert5 = #xfff0000300000000 (18442240486967083008, -4503586742468608)
double %6 = NaN
i64 %7 = #x7ff00000000ffffd (9218868437228453885)
i64 %X.sroa.0.i.4.insert.mask = #x00000000000ffffd (1048573)
i64 %X.sroa.0.i.4.insert.insert = #x3ff00000000ffffd (4607182418801065981)
double %8 = #x3ff00000000ffffd (1.000000000232?)
double %accum.real.i = #x3ff02087fff00003 (1.007942199474?)
double %add.r.i = #x4000104400000000 (2.007942199707?)
Mismatch in pointer(non-local, block_id=1, offset=4)
Source value: #x43
Target value: #x44
------------------- SMT STATS -------------------
Num queries: 71
Num invalid: 0
Num skips: 0
Num trivial: 148 (67.6%)
Num timeout: 0 (0.0%)
Num errors: 0 (0.0%)
Num SAT: 62 (87.3%)
Num UNSAT: 9 (12.7%)
Alive2: Transform doesn't verify; aborting!
+ : 'RUN: at line 2' + /home/nlopes/alive2/build/opt-alive.sh -passes=sroa -S + /tmp/nlopes/llvm/build/bin/FileCheck /tmp/nlopes/llvm/llvm/test/Transforms/SROA/basictest.ll FileCheck error: '<stdin>' is empty. FileCheck command line: /tmp/nlopes/llvm/build/bin/FileCheck /tmp/nlopes/llvm/llvm/test/Transforms/SROA/basictest.ll