Test Failure: Transforms/DeadStoreElimination/noop-stores.ll

Test source: git

Log:

Source: <stdin>
ERROR: Unsupported instruction:   %a = load volatile i32, i32* %Q, align 4
ERROR: Unsupported instruction:   store volatile i32 %a, i32* %Q, align 4
ERROR: Unsupported attribute: noalias
ERROR: Unsupported attribute: noalias
ERROR: Unsupported instruction:   %call1 = call i8* %notmalloc(i64 %size)
ERROR: Unsupported instruction:   %a = load volatile i32, i32* %Q, align 4
ERROR: Unsupported instruction:   store volatile i32 %a, i32* %Q, align 4

----------------------------------------
define void @test12(ptr %x) {
%0:
  %temp4 = gep ptr %x, 8 x i32 0, 1 x i64 0
  %temp5 = load i32, ptr %temp4, align 4
  %temp7 = gep ptr %x, 8 x i32 0, 1 x i64 4
  %temp8 = load i32, ptr %temp7, align 4
  %temp17 = sub i32 0, %temp8
  store i32 %temp5, ptr %temp4, align 4
  store i32 %temp17, ptr %temp7, align 4
  ret void
}
=>
define void @test12(ptr %x) {
%0:
  %temp7 = gep ptr %x, 8 x i32 0, 1 x i64 4
  %temp8 = load i32, ptr %temp7, align 4
  %temp17 = sub i32 0, %temp8
  store i32 %temp17, ptr %temp7, align 4
  ret void
}
Transformation seems to be correct!


----------------------------------------
define i32 @test26(i1 %c, ptr %p) {
%entry:
  %v = load i32, ptr %p, align 4
  br i1 %c, label %bb1, label %bb2

%bb2:
  store i32 %v, ptr %p, align 4
  br label %bb3

%bb1:
  br label %bb3

%bb3:
  ret i32 0
}
=>
define i32 @test26(i1 %c, ptr %p) {
%entry:
  br i1 %c, label %bb1, label %bb2

%bb2:
  br label %bb3

%bb1:
  br label %bb3

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


----------------------------------------
define i32 @test27(i1 %c, ptr %p) {
%entry:
  %v = load i32, ptr %p, align 4
  br i1 %c, label %bb1, label %bb2

%bb2:
  br label %bb3

%bb1:
  br label %bb3

%bb3:
  store i32 %v, ptr %p, align 4
  ret i32 0
}
=>
define i32 @test27(i1 %c, ptr %p) {
%entry:
  br i1 %c, label %bb1, label %bb2

%bb2:
  br label %bb3

%bb1:
  br label %bb3

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


----------------------------------------
define i32 @test31(i1 %c, ptr %p, i32 %i) {
%entry:
  %v = load i32, ptr %p, align 4
  br label %bb1

%bb1:
  store i32 %v, ptr %p, align 4
  br i1 %c, label %bb1, label %bb2

%bb2:
  ret i32 0
}
=>
define i32 @test31(i1 %c, ptr %p, i32 %i) {
%entry:
  br label %bb1

%bb1:
  br i1 %c, label %bb1, label %bb2

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


----------------------------------------
define i32 @test46(i1 %c, ptr %p, ptr %p2, i32 %i) {
%entry:
  %v = load i32, ptr %p, align 4
  br label %bb1

%bb1:
  store i32 %v, ptr %p, align 4
  br i1 %c, label %bb1, label %bb2

%bb2:
  store i32 0, ptr %p2, align 4
  br i1 %c, label %bb3, label %bb1

%bb3:
  ret i32 0
}
=>
define i32 @test46(i1 %c, ptr %p, ptr %p2, i32 %i) {
%entry:
  %v = load i32, ptr %p, align 4
  br label %bb1

%bb1:
  store i32 %v, ptr %p, align 4
  br i1 %c, label %bb1, label %bb2

%bb2:
  store i32 0, ptr %p2, align 4
  br i1 %c, label %bb3, label %bb1

%bb3:
  ret i32 0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i32 @test33(i1 %c, ptr %p, i32 %i) {
%entry:
  br label %bb1

%bb1:
  %v = load i32, ptr %p, align 4
  br label %bb2

%bb2:
  store i32 %v, ptr %p, align 4
  call void @unknown_func()
  br i1 %c, label %bb1, label %bb3

%bb3:
  ret i32 0
}
=>
define i32 @test33(i1 %c, ptr %p, i32 %i) {
%entry:
  br label %bb1

%bb1:
  br label %bb2

%bb2:
  call void @unknown_func()
  br i1 %c, label %bb1, label %bb3

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


----------------------------------------
define void @test43(ptr %Q) {
%0:
  %a = load i32, ptr %Q, align 4
  call void @unkown_write(ptr %Q)
  store i32 %a, ptr %Q, align 4
  ret void
}
=>
define void @test43(ptr %Q) {
%0:
  %a = load i32, ptr %Q, align 4
  call void @unkown_write(ptr %Q)
  store i32 %a, ptr %Q, align 4
  ret void
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @test44(ptr %Q) {
%0:
  %a = load i32, ptr %Q, align 4
  store i32 %a, ptr %Q, align 4
  call void @unkown_write(ptr %Q)
  ret void
}
=>
define void @test44(ptr %Q) {
%0:
  call void @unkown_write(ptr %Q)
  ret void
}
Transformation seems to be correct!


----------------------------------------
define void @test45(ptr %Q) {
%0:
  %a = load i32, ptr %Q, align 4
  store i32 10, ptr %Q, align 4
  store i32 %a, ptr %Q, align 4
  ret void
}
=>
define void @test45(ptr %Q) {
%0:
  ret void
}
Transformation seems to be correct!


----------------------------------------
define i32 @test48(i1 %c, ptr %p) {
%entry:
  %v = load i32, ptr %p, align 4
  br i1 %c, label %bb0, label %bb0.0

%bb0.0:
  br label %bb1

%bb0:
  store i32 0, ptr %p, align 4
  br i1 %c, label %bb1, label %bb2

%bb1:
  store i32 %v, ptr %p, align 4
  br i1 %c, label %bb2, label %bb0

%bb2:
  ret i32 0
}
=>
define i32 @test48(i1 %c, ptr %p) {
%entry:
  %v = load i32, ptr %p, align 4
  br i1 %c, label %bb0, label %bb0.0

%bb0.0:
  br label %bb1

%bb0:
  store i32 0, ptr %p, align 4
  br i1 %c, label %bb1, label %bb2

%bb1:
  store i32 %v, ptr %p, align 4
  br i1 %c, label %bb2, label %bb0

%bb2:
  ret i32 0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i32 @test47(i1 %c, ptr %p, i32 %i) {
%entry:
  %v = load i32, ptr %p, align 4
  br label %bb1

%bb1:
  store i32 %v, ptr %p, align 4
  br i1 %c, label %bb1, label %bb2

%bb2:
  store i32 %v, ptr %p, align 4
  br i1 %c, label %bb3, label %bb1

%bb3:
  ret i32 0
}
=>
define i32 @test47(i1 %c, ptr %p, i32 %i) {
%entry:
  br label %bb1

%bb1:
  br i1 %c, label %bb1, label %bb2

%bb2:
  br i1 %c, label %bb3, label %bb1

%bb3:
  ret i32 0
}
Transformation doesn't verify!
ERROR: The source program doesn't reach a return instruction.
Consider increasing the unroll factor if it has loops

ERROR: Unsupported attribute: noalias
ERROR: Unsupported attribute: noalias

----------------------------------------
define ptr @zero_memset_after_malloc(i64 %size) {
%0:
  %call = malloc i64 %size
  memset ptr %call align 1, i8 0, i64 %size
  ret ptr %call
}
=>
define ptr @zero_memset_after_malloc(i64 %size) {
%0:
  %calloc = calloc i64 1, i64 %size
  ret ptr %calloc
}
Transformation seems to be correct!


----------------------------------------
define ptr @zero_memset_after_malloc_with_intermediate_clobbering(i64 %size) {
%0:
  %call = malloc i64 %size
  %bc = bitcast ptr %call to ptr
  call void @clobber_memory(ptr %bc)
  memset ptr %call align 1, i8 0, i64 %size
  ret ptr %call
}
=>
define ptr @zero_memset_after_malloc_with_intermediate_clobbering(i64 %size) {
%0:
  %call = malloc i64 %size
  %bc = bitcast ptr %call to ptr
  call void @clobber_memory(ptr %bc)
  memset ptr %call align 1, i8 0, i64 %size
  ret ptr %call
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @zero_memset_after_malloc_with_different_sizes(i64 %size) {
%0:
  %call = malloc i64 %size
  %size2 = add nsw i64 %size, -1
  memset ptr %call align 1, i8 0, i64 %size2
  ret ptr %call
}
=>
define ptr @zero_memset_after_malloc_with_different_sizes(i64 %size) {
%0:
  %call = malloc i64 %size
  %size2 = add nsw i64 %size, -1
  memset ptr %call align 1, i8 0, i64 %size2
  ret ptr %call
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @zero_memset_after_new(i64 %size) {
%0:
  %call = malloc i64 %size
  memset ptr %call align 1, i8 0, i64 %size
  ret ptr %call
}
=>
define ptr @zero_memset_after_new(i64 %size) {
%0:
  %call = malloc i64 %size
  memset ptr %call align 1, i8 0, i64 %size
  ret ptr %call
}
Transformation seems to be correct! (syntactically equal)

ERROR: Unsupported instruction:   %call1 = call i8* %notmalloc(i64 %size)

----------------------------------------
define ptr @calloc(i64 %nmemb, i64 %size) inaccessiblememonly {
%entry:
  %mul = mul i64 %size, %nmemb
  %call = malloc i64 %mul, align 16
  %tobool.not = icmp eq ptr %call, null, use_provenance
  br i1 %tobool.not, label %if.end, label %if.then

%if.then:
  memset ptr %call align 16, i8 0, i64 %mul
  br label %if.end

%if.end:
  ret ptr %call
}
=>
define ptr @calloc(i64 noundef %nmemb, i64 noundef %size) nofree noundef noalias willreturn inaccessiblememonly {
%entry:
  %mul = mul i64 noundef %size, noundef %nmemb
  %call = malloc i64 %mul, align 16
  %tobool.not = icmp eq ptr %call, null, use_provenance
  br i1 %tobool.not, label %if.end, label %if.then

%if.then:
  memset ptr %call align 16, i8 0, i64 %mul
  br label %if.end

%if.end:
  ret ptr %call
}
Transformation doesn't verify!
ERROR: Parameter attributes not refined


------------------- SMT STATS -------------------
Num queries: 37
Num invalid: 0
Num skips:   0
Num trivial: 36 (49.3%)
Num timeout: 0 (0.0%)
Num errors:  0 (0.0%)
Num SAT:     24 (64.9%)
Num UNSAT:   13 (35.1%)
Alive2: Transform doesn't verify; aborting!

stderr:

+ : 'RUN: at line 2'
+ /home/nlopes/llvm/build/bin/FileCheck /home/nlopes/llvm/llvm/test/Transforms/DeadStoreElimination/noop-stores.ll
+ /home/nlopes/alive2/build/opt-alive.sh -basic-aa -dse -S

FileCheck error: '<stdin>' is empty.
FileCheck command line:  /home/nlopes/llvm/build/bin/FileCheck /home/nlopes/llvm/llvm/test/Transforms/DeadStoreElimination/noop-stores.ll

 

<-- Back