Test Failure: Transforms/InstSimplify/ConstProp/loads.ll

Test source: git

Log:

Source: <stdin>
ERROR: Unsupported instruction:   %r = load i16, i16 addrspace(1)* addrspacecast (i16* bitcast ({ { i32, i8 }, i32 }* @g1 to i16*) to i16 addrspace(1)*), align 2
ERROR: Unsupported type: ppc_fp128
ERROR: Unsupported type: x86_fp80
ERROR: Unsupported constant: [2 x i8 addrspace(1)*] [i8 addrspace(1)* inttoptr (i16 1 to i8 addrspace(1)*), i8 addrspace(1)* inttoptr (i16 2 to i8 addrspace(1)*)]
ERROR: Unsupported constant: { [4294967295 x [0 x i32]], i64 } { [4294967295 x [0 x i32]] undef, i64 123 }
ERROR: Unsupported constant: [4294967295 x [0 x i32]] zeroinitializer
ERROR: Unsupported type: x86_mmx

----------------------------------------
@g1 = constant 12 bytes, align 8

define i32 @test1() {
#init:
  %__copy_0 = {{i32, i8, i24}, i32} { { 3735928559, 186, [padding] }, 3405691582 }
  store {{i32, i8, i24}, i32} %__copy_0, ptr @g1, align 8
  br label %0

%0:
  %__constexpr_0 = gep inbounds ptr @g1, 12 x i32 0, 1 x i64 0, 1 x i64 0
  %r = load i32, ptr %__constexpr_0, align 4
  ret i32 %r
}
=>
@g1 = constant 12 bytes, align 8

define i32 @test1() {
#init:
  %__copy_0 = {{i32, i8, i24}, i32} { { 3735928559, 186, [padding] }, 3405691582 }
  store {{i32, i8, i24}, i32} %__copy_0, ptr @g1, align 8
  br label %0

%0:
  ret i32 3735928559
}
Transformation seems to be correct!


----------------------------------------
@g1 = constant 12 bytes, align 8

define i16 @test2() {
#init:
  %__copy_0 = {{i32, i8, i24}, i32} { { 3735928559, 186, [padding] }, 3405691582 }
  store {{i32, i8, i24}, i32} %__copy_0, ptr @g1, align 8
  br label %0

%0:
  %__constexpr_0 = bitcast ptr @g1 to ptr
  %r = load i16, ptr %__constexpr_0, align 2
  ret i16 %r
}
=>
@g1 = constant 12 bytes, align 8

define i16 @test2() {
#init:
  %__copy_0 = {{i32, i8, i24}, i32} { { 3735928559, 186, [padding] }, 3405691582 }
  store {{i32, i8, i24}, i32} %__copy_0, ptr @g1, align 8
  br label %0

%0:
  ret i16 48879
}
Transformation seems to be correct!


----------------------------------------
@g1 = constant 12 bytes, align 8

define i16 @test3() {
#init:
  %__copy_0 = {{i32, i8, i24}, i32} { { 3735928559, 186, [padding] }, 3405691582 }
  store {{i32, i8, i24}, i32} %__copy_0, ptr @g1, align 8
  br label %0

%0:
  %__constexpr_1 = bitcast ptr @g1 to ptr
  %__constexpr_0 = gep ptr %__constexpr_1, 2 x i32 1
  %r = load i16, ptr %__constexpr_0, align 2
  ret i16 %r
}
=>
@g1 = constant 12 bytes, align 8

define i16 @test3() {
#init:
  %__copy_0 = {{i32, i8, i24}, i32} { { 3735928559, 186, [padding] }, 3405691582 }
  store {{i32, i8, i24}, i32} %__copy_0, ptr @g1, align 8
  br label %0

%0:
  ret i16 57005
}
Transformation seems to be correct!


----------------------------------------
@g1 = constant 12 bytes, align 8

define i16 @test4() {
#init:
  %__copy_0 = {{i32, i8, i24}, i32} { { 3735928559, 186, [padding] }, 3405691582 }
  store {{i32, i8, i24}, i32} %__copy_0, ptr @g1, align 8
  br label %0

%0:
  %__constexpr_1 = bitcast ptr @g1 to ptr
  %__constexpr_0 = gep ptr %__constexpr_1, 2 x i32 2
  %r = load i16, ptr %__constexpr_0, align 2
  ret i16 %r
}
=>
@g1 = constant 12 bytes, align 8

define i16 @test4() {
#init:
  %__copy_0 = {{i32, i8, i24}, i32} { { 3735928559, 186, [padding] }, 3405691582 }
  store {{i32, i8, i24}, i32} %__copy_0, ptr @g1, align 8
  br label %0

%0:
  ret i16 186
}
Transformation seems to be correct!


----------------------------------------
@g2 = constant 8 bytes, align 8

define i64 @test6() {
#init:
  store double 1.000000, ptr @g2, align 8
  br label %0

%0:
  %__constexpr_0 = bitcast ptr @g2 to ptr
  %r = load i64, ptr %__constexpr_0, align 8
  ret i64 %r
}
=>
@g2 = constant 8 bytes, align 8

define i64 @test6() {
#init:
  store double 1.000000, ptr @g2, align 8
  br label %0

%0:
  ret i64 4607182418800017408
}
Transformation seems to be correct!


----------------------------------------
@g2 = constant 8 bytes, align 8

define i16 @test7() {
#init:
  store double 1.000000, ptr @g2, align 8
  br label %0

%0:
  %__constexpr_0 = bitcast ptr @g2 to ptr
  %r = load i16, ptr %__constexpr_0, align 2
  ret i16 %r
}
=>
@g2 = constant 8 bytes, align 8

define i16 @test7() {
#init:
  store double 1.000000, ptr @g2, align 8
  br label %0

%0:
  ret i16 0
}
Transformation seems to be correct!


----------------------------------------
@g1 = constant 12 bytes, align 8

define double @test8() {
#init:
  %__copy_0 = {{i32, i8, i24}, i32} { { 3735928559, 186, [padding] }, 3405691582 }
  store {{i32, i8, i24}, i32} %__copy_0, ptr @g1, align 8
  br label %0

%0:
  %__constexpr_0 = bitcast ptr @g1 to ptr
  %r = load double, ptr %__constexpr_0, align 8
  ret double %r
}
=>
@g1 = constant 12 bytes, align 8

define double @test8() {
#init:
  %__copy_0 = {{i32, i8, i24}, i32} { { 3735928559, 186, [padding] }, 3405691582 }
  store {{i32, i8, i24}, i32} %__copy_0, ptr @g1, align 8
  br label %0

%0:
  ret double 0.000000
}
Transformation seems to be correct!


----------------------------------------
@g3 = constant 16 bytes, align 8

define i128 @test_i128() {
#init:
  store {i64, i64} { 123, 112312312 }, ptr @g3, align 8
  br label %0

%0:
  %__constexpr_0 = bitcast ptr @g3 to ptr
  %r = load i128, ptr %__constexpr_0, align 8
  ret i128 %r
}
=>
@g3 = constant 16 bytes, align 8

define i128 @test_i128() {
#init:
  store {i64, i64} { 123, 112312312 }, ptr @g3, align 8
  br label %0

%0:
  ret i128 2071796475790618158476296315
}
Transformation seems to be correct!


----------------------------------------
@g3 = constant 16 bytes, align 8

define fp128 @test_fp128() {
#init:
  store {i64, i64} { 123, 112312312 }, ptr @g3, align 8
  br label %0

%0:
  %__constexpr_0 = bitcast ptr @g3 to ptr
  %r = load fp128, ptr %__constexpr_0, align 16
  ret fp128 %r
}
=>
@g3 = constant 16 bytes, align 8

define fp128 @test_fp128() {
#init:
  store {i64, i64} { 123, 112312312 }, ptr @g3, align 8
  br label %0

%0:
  ret fp128 2071796475790618158476296315
}
Transformation seems to be correct!

ERROR: Unsupported type: ppc_fp128
ERROR: Unsupported type: x86_fp80

----------------------------------------
@g3 = constant 16 bytes, align 8

define bfloat @test_bfloat() {
#init:
  store {i64, i64} { 123, 112312312 }, ptr @g3, align 8
  br label %0

%0:
  %__constexpr_0 = bitcast ptr @g3 to ptr
  %r = load bfloat, ptr %__constexpr_0, align 2
  ret bfloat %r
}
=>
@g3 = constant 16 bytes, align 8

define bfloat @test_bfloat() {
#init:
  store {i64, i64} { 123, 112312312 }, ptr @g3, align 8
  br label %0

%0:
  ret bfloat 0.000000
}
Transformation seems to be correct!


----------------------------------------
@g3 = constant 16 bytes, align 8

define <2 x i64> @test10() {
#init:
  store {i64, i64} { 123, 112312312 }, ptr @g3, align 8
  br label %0

%0:
  %__constexpr_0 = bitcast ptr @g3 to ptr
  %r = load <2 x i64>, ptr %__constexpr_0, align 16
  ret <2 x i64> %r
}
=>
@g3 = constant 16 bytes, align 8

define <2 x i64> @test10() {
#init:
  store {i64, i64} { 123, 112312312 }, ptr @g3, align 8
  br label %0

%0:
  ret <2 x i64> { 123, 112312312 }
}
Transformation seems to be correct!


----------------------------------------
@g4 = constant 2 bytes, align 8

define i16 @test11() {
#init:
  store {i8, i8} { 161, 8 }, ptr @g4, align 8
  br label %entry

%entry:
  %__constexpr_0 = bitcast ptr @g4 to ptr
  %a = load i16, ptr %__constexpr_0, align 2
  ret i16 %a
}
=>
@g4 = constant 2 bytes, align 8

define i16 @test11() {
#init:
  store {i8, i8} { 161, 8 }, ptr @g4, align 8
  br label %entry

%entry:
  ret i16 2209
}
Transformation seems to be correct!


----------------------------------------
@test12g = constant 6 bytes, align 1

define i16 @test12() {
#init:
  store [6 x i8] { 97, 0, 98, 0, 0, 0 }, ptr @test12g, align 1
  br label %0

%0:
  %__constexpr_1 = bitcast ptr @test12g to ptr
  %__constexpr_0 = gep inbounds ptr %__constexpr_1, 6 x i32 0, 2 x i64 1
  %a = load i16, ptr %__constexpr_0, align 2
  ret i16 %a
}
=>
@test12g = constant 6 bytes, align 1

define i16 @test12() {
#init:
  store [6 x i8] { 97, 0, 98, 0, 0, 0 }, ptr @test12g, align 1
  br label %0

%0:
  ret i16 98
}
Transformation seems to be correct!


----------------------------------------
@g5 = constant 1 bytes, align 1

define i1 @test13() {
#init:
  store i8 4, ptr @g5, align 1
  br label %0

%0:
  %__constexpr_0 = bitcast ptr @g5 to ptr
  %A = load i1, ptr %__constexpr_0, align 1
  ret i1 %A
}
=>
@g5 = constant 1 bytes, align 1

define i1 @test13() {
#init:
  store i8 4, ptr @g5, align 1
  br label %0

%0:
  ret i1 0
}
Transformation seems to be correct!


----------------------------------------
@g6 = constant 16 bytes, align 8

define i64 @test14() {
#init:
  %__constexpr_1 = int2ptr i64 1 to ptr
  %__constexpr_2 = int2ptr i64 2 to ptr
  %__copy_0 = [2 x ptr] { %__constexpr_1, %__constexpr_2 }
  store [2 x ptr] %__copy_0, ptr @g6, align 8
  br label %entry

%entry:
  %__constexpr_0 = bitcast ptr @g6 to ptr
  %tmp = load i64, ptr %__constexpr_0, align 8
  ret i64 %tmp
}
=>
@g6 = constant 16 bytes, align 8

define i64 @test14() {
#init:
  %__constexpr_0 = int2ptr i64 1 to ptr
  %__constexpr_1 = int2ptr i64 2 to ptr
  %__copy_0 = [2 x ptr] { %__constexpr_0, %__constexpr_1 }
  store [2 x ptr] %__copy_0, ptr @g6, align 8
  br label %entry

%entry:
  ret i64 1
}
Transformation seems to be correct!


----------------------------------------
@g6 = constant 16 bytes, align 8

define i64 @test15() {
#init:
  %__constexpr_2 = int2ptr i64 1 to ptr
  %__constexpr_3 = int2ptr i64 2 to ptr
  %__copy_0 = [2 x ptr] { %__constexpr_2, %__constexpr_3 }
  store [2 x ptr] %__copy_0, ptr @g6, align 8
  br label %entry

%entry:
  %__constexpr_1 = gep inbounds ptr @g6, 16 x i32 0, 8 x i64 1
  %__constexpr_0 = bitcast ptr %__constexpr_1 to ptr
  %tmp = load i64, ptr %__constexpr_0, align 8
  ret i64 %tmp
}
=>
@g6 = constant 16 bytes, align 8

define i64 @test15() {
#init:
  %__constexpr_0 = int2ptr i64 1 to ptr
  %__constexpr_1 = int2ptr i64 2 to ptr
  %__copy_0 = [2 x ptr] { %__constexpr_0, %__constexpr_1 }
  store [2 x ptr] %__copy_0, ptr @g6, align 8
  br label %entry

%entry:
  ret i64 2
}
Transformation seems to be correct!


----------------------------------------
@gv7 = constant 32 bytes, align 16

define i64 @test16.1() {
#init:
  %__constexpr_1 = int2ptr i64 -14 to ptr
  %__copy_0 = [4 x ptr] { null, %__constexpr_1, null, null }
  store [4 x ptr] %__copy_0, ptr @gv7, align 16
  br label %0

%0:
  %__constexpr_0 = bitcast ptr @gv7 to ptr
  %v = load i64, ptr %__constexpr_0, align 8
  ret i64 %v
}
=>
@gv7 = constant 32 bytes, align 16

define i64 @test16.1() {
#init:
  %__constexpr_0 = int2ptr i64 -14 to ptr
  %__copy_0 = [4 x ptr] { null, %__constexpr_0, null, null }
  store [4 x ptr] %__copy_0, ptr @gv7, align 16
  br label %0

%0:
  ret i64 0
}
Transformation seems to be correct!


----------------------------------------
@gv7 = constant 32 bytes, align 16

define i64 @test16.2() {
#init:
  %__constexpr_2 = int2ptr i64 -14 to ptr
  %__copy_0 = [4 x ptr] { null, %__constexpr_2, null, null }
  store [4 x ptr] %__copy_0, ptr @gv7, align 16
  br label %0

%0:
  %__constexpr_1 = gep inbounds ptr @gv7, 32 x i64 0, 8 x i64 1
  %__constexpr_0 = bitcast ptr %__constexpr_1 to ptr
  %v = load i64, ptr %__constexpr_0, align 8
  ret i64 %v
}
=>
@gv7 = constant 32 bytes, align 16

define i64 @test16.2() {
#init:
  %__constexpr_0 = int2ptr i64 -14 to ptr
  %__copy_0 = [4 x ptr] { null, %__constexpr_0, null, null }
  store [4 x ptr] %__copy_0, ptr @gv7, align 16
  br label %0

%0:
  ret i64 -14
}
Transformation seems to be correct!


----------------------------------------
@gv7 = constant 32 bytes, align 16

define i64 @test16.3() {
#init:
  %__constexpr_2 = int2ptr i64 -14 to ptr
  %__copy_0 = [4 x ptr] { null, %__constexpr_2, null, null }
  store [4 x ptr] %__copy_0, ptr @gv7, align 16
  br label %0

%0:
  %__constexpr_1 = gep inbounds ptr @gv7, 32 x i64 0, 8 x i64 2
  %__constexpr_0 = bitcast ptr %__constexpr_1 to ptr
  %v = load i64, ptr %__constexpr_0, align 8
  ret i64 %v
}
=>
@gv7 = constant 32 bytes, align 16

define i64 @test16.3() {
#init:
  %__constexpr_0 = int2ptr i64 -14 to ptr
  %__copy_0 = [4 x ptr] { null, %__constexpr_0, null, null }
  store [4 x ptr] %__copy_0, ptr @gv7, align 16
  br label %0

%0:
  ret i64 0
}
Transformation seems to be correct!


----------------------------------------
@g7 = constant 8 bytes, align 8

define ptr @test_leading_zero_size_elems() {
#init:
  store {(empty array), (empty array), ptr} { undef, undef, null }, ptr @g7, align 8
  br label %0

%0:
  %__constexpr_0 = bitcast ptr @g7 to ptr
  %v = load ptr, ptr %__constexpr_0, align 8
  ret ptr %v
}
=>
@g7 = constant 8 bytes, align 8

define ptr @test_leading_zero_size_elems() {
#init:
  store {(empty array), (empty array), ptr} { undef, undef, null }, ptr @g7, align 8
  br label %0

%0:
  ret ptr null
}
Transformation seems to be correct!


----------------------------------------
@g_undef = constant 16 bytes, align 8

define ptr @test_undef_aggregate() {
#init:
  store {i128} undef, ptr @g_undef, align 8
  br label %0

%0:
  %__constexpr_0 = bitcast ptr @g_undef to ptr
  %v = load ptr, ptr %__constexpr_0, align 8
  ret ptr %v
}
=>
@g_undef = constant 16 bytes, align 8

define ptr @test_undef_aggregate() {
#init:
  store {i128} undef, ptr @g_undef, align 8
  br label %0

%0:
  ret ptr undef
}
Transformation seems to be correct!


----------------------------------------
@g_poison = constant 16 bytes, align 8

define ptr @test_poison_aggregate() {
#init:
  store {i128} poison, ptr @g_poison, align 8
  br label %0

%0:
  %__constexpr_0 = bitcast ptr @g_poison to ptr
  %v = load ptr, ptr %__constexpr_0, align 8
  ret ptr %v
}
=>
@g_poison = constant 16 bytes, align 8

define ptr @test_poison_aggregate() {
#init:
  store {i128} poison, ptr @g_poison, align 8
  br label %0

%0:
  ret ptr poison
}
Transformation seems to be correct!


----------------------------------------
@g11 = constant 16 bytes, align 4

define ptr @test_trailing_zero_gep_index() {
#init:
  store {[8 x i8], [8 x i8]} { undef, { 0, 0, 0, 0, 0, 0, 0, 0 } }, ptr @g11, align 4
  br label %0

%0:
  %__constexpr_1 = gep inbounds ptr @g11, 16 x i32 0, 1 x i64 8, 1 x i32 0
  %__constexpr_0 = bitcast ptr %__constexpr_1 to ptr
  %v = load ptr, ptr %__constexpr_0, align 4
  ret ptr %v
}
=>
@g11 = constant 16 bytes, align 4

define ptr @test_trailing_zero_gep_index() {
#init:
  store {[8 x i8], [8 x i8]} { undef, { 0, 0, 0, 0, 0, 0, 0, 0 } }, ptr @g11, align 4
  br label %0

%0:
  ret ptr null
}
Transformation seems to be correct!


----------------------------------------
@g3 = constant 16 bytes, align 8

define {i64, i64} @test_load_struct() {
#init:
  store {i64, i64} { 123, 112312312 }, ptr @g3, align 8
  br label %0

%0:
  %v = load {i64, i64}, ptr @g3, align 8
  ret {i64, i64} %v
}
=>
@g3 = constant 16 bytes, align 8

define {i64, i64} @test_load_struct() {
#init:
  store {i64, i64} { 123, 112312312 }, ptr @g3, align 8
  br label %0

%0:
  ret {i64, i64} { 123, 112312312 }
}
Transformation seems to be correct!

ERROR: Unsupported type: x86_mmx

----------------------------------------
@g_neg_one_vec = constant 4 bytes, align 4
@g_offset = global 8 bytes, align 8

define i8 @load_neg_one_at_unknown_offset() {
#init:
  store <4 x i8> { 255, 255, 255, 255 }, ptr @g_neg_one_vec, align 4
  br label %0

%0:
  %__constexpr_1 = ptrtoint ptr @g_offset to i64
  %__constexpr_0 = gep ptr @g_neg_one_vec, 4 x i64 0, 1 x i64 %__constexpr_1
  %v = load i8, ptr %__constexpr_0, align 1
  ret i8 %v
}
=>
@g_neg_one_vec = constant 4 bytes, align 4
@g_offset = global 8 bytes, align 8

define i8 @load_neg_one_at_unknown_offset() {
#init:
  store <4 x i8> { 255, 255, 255, 255 }, ptr @g_neg_one_vec, align 4
  br label %0

%0:
  ret i8 255
}
Transformation seems to be correct!


----------------------------------------
@g_with_padding = constant 8 bytes, align 8

define i32 @load_padding() {
#init:
  store {i32, [4 x i8]} { 0, undef }, ptr @g_with_padding, align 8
  br label %0

%0:
  %__constexpr_1 = gep inbounds ptr @g_with_padding, 8 x i32 0, 1 x i64 0
  %__constexpr_0 = gep ptr %__constexpr_1, 4 x i64 1
  %v = load i32, ptr %__constexpr_0, align 4
  ret i32 %v
}
=>
@g_with_padding = constant 8 bytes, align 8

define i32 @load_padding() {
#init:
  store {i32, [4 x i8]} { 0, undef }, ptr @g_with_padding, align 8
  br label %0

%0:
  ret i32 undef
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
@g_all_undef = constant 8 bytes, align 8

define i32 @load_all_undef() {
#init:
  store {i32, [4 x i8]} undef, ptr @g_all_undef, align 8
  br label %0

%0:
  %__constexpr_1 = gep inbounds ptr @g_all_undef, 8 x i32 0, 1 x i64 0
  %__constexpr_0 = gep ptr %__constexpr_1, 4 x i64 1
  %v = load i32, ptr %__constexpr_0, align 4
  ret i32 %v
}
=>
@g_all_undef = constant 8 bytes, align 8

define i32 @load_all_undef() {
#init:
  store {i32, [4 x i8]} undef, ptr @g_all_undef, align 8
  br label %0

%0:
  ret i32 undef
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
@g_i8_data = constant 16 bytes, align 1

define ptr @load_ptr_from_i8_data() {
#init:
  store [16 x i8] { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, ptr @g_i8_data, align 1
  br label %0

%0:
  %__constexpr_0 = bitcast ptr @g_i8_data to ptr
  %v = load ptr, ptr %__constexpr_0, align 8
  ret ptr %v
}
=>
@g_i8_data = constant 16 bytes, align 1

define ptr @load_ptr_from_i8_data() {
#init:
  store [16 x i8] { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, ptr @g_i8_data, align 1
  br label %0

%0:
  %__constexpr_0 = int2ptr i64 1 to ptr
  ret ptr %__constexpr_0
}
Transformation seems to be correct!


----------------------------------------
@g_i1 = constant 1 bytes, align 1

define i8 @load_i8_from_i1() {
#init:
  store i1 1, ptr @g_i1, align 1
  br label %0

%0:
  %__constexpr_0 = bitcast ptr @g_i1 to ptr
  %v = load i8, ptr %__constexpr_0, align 1
  ret i8 %v
}
=>
@g_i1 = constant 1 bytes, align 1

define i8 @load_i8_from_i1() {
#init:
  store i1 1, ptr @g_i1, align 1
  br label %0

%0:
  ret i8 255
}
Transformation doesn't verify!
ERROR: Mismatch in memory

Example:

Source:
  >> Jump to %0
ptr %__constexpr_0 = pointer(non-local, block_id=0, offset=0)
i8 %v = #x01 (1)

SOURCE MEMORY STATE
===================
NON-LOCAL BLOCKS:
Block 0 >	size: 1	align: 1	alloc type: 0

Target:
  >> Jump to %0

Mismatch in pointer(non-local, block_id=0, offset=0)
Source value: #x01
Target value: #x01


------------------- SMT STATS -------------------
Num queries: 97
Num invalid: 0
Num skips:   0
Num trivial: 164 (62.8%)
Num timeout: 2 (2.1%)
Num errors:  0 (0.0%)
Num SAT:     88 (90.7%)
Num UNSAT:   7 (7.2%)
Alive2: Transform doesn't verify; aborting!

stderr:

+ : 'RUN: at line 2'
+ /home/nlopes/llvm/build/bin/FileCheck /home/nlopes/llvm/llvm/test/Transforms/InstSimplify/ConstProp/loads.ll --check-prefixes=CHECK,LE
+ /home/nlopes/alive2/build/opt-alive.sh -data-layout=e-p:64:64:64-p1:16:16:16-p2:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-ni:2 -passes=instsimplify -S

FileCheck error: '<stdin>' is empty.
FileCheck command line:  /home/nlopes/llvm/build/bin/FileCheck /home/nlopes/llvm/llvm/test/Transforms/InstSimplify/ConstProp/loads.ll --check-prefixes=CHECK,LE

<-- Back