Test Failure: Transforms/LICM/scalar-promote.ll

Test source: git

Comments: LLVM PR51906

Log:

Source: <stdin>
ERROR: Unsupported instruction:   %x = load volatile i32, ptr @X, align 4
ERROR: Unsupported instruction:   store volatile i32 %x2, ptr @X, align 4
ERROR: Unsupported attribute: noalias
ERROR: Unsupported metadata: 1
ERROR: Unsupported instruction:   %x = load atomic i32, ptr @X unordered, align 4
ERROR: Unsupported attribute: noalias
ERROR: Unsupported attribute: sret(i32)

----------------------------------------
@X = global 4 bytes, align 4

define void @test1(i32 %i) {
%Entry:
  br label %Loop

%Loop:
  %j = phi i32 [ 0, %Entry ], [ %Next, %Loop ]
  %x = load i32, ptr @X, align 4
  %x2 = add i32 %x, 1
  store i32 %x2, ptr @X, align 4
  %Next = add i32 %j, 1
  %cond = icmp eq i32 %Next, 0
  br i1 %cond, label %Out, label %Loop

%Out:
  ret void
}
=>
@X = global 4 bytes, align 4

define void @test1(i32 %i) {
%Entry:
  %X.promoted = load i32, ptr @X, align 4
  br label %Loop

%Loop:
  %x21 = phi i32 [ %X.promoted, %Entry ], [ %x2, %Loop ]
  %j = phi i32 [ 0, %Entry ], [ %Next, %Loop ]
  %x2 = add i32 %x21, 1
  %Next = add i32 %j, 1
  %cond = icmp eq i32 %Next, 0
  br i1 %cond, label %Out, label %Loop

%Out:
  %x2.lcssa = phi i32 [ %x2, %Loop ]
  store i32 %x2.lcssa, ptr @X, align 4
  ret void
}
Transformation seems to be correct!


----------------------------------------
@X = global 4 bytes, align 4

define void @test2(i32 %i) {
%Entry:
  br label %Loop

%Loop:
  %X1 = gep ptr @X, 4 x i64 1
  %A = load i32, ptr %X1, align 4
  %V = add i32 %A, 1
  %X2 = gep ptr @X, 4 x i64 1
  store i32 %V, ptr %X2, align 4
  br i1 0, label %Loop, label %Exit

%Exit:
  ret void
}
=>
@X = global 4 bytes, align 4

define void @test2(i32 %i) {
%Entry:
  %__constexpr_0 = gep inbounds ptr @X, 4 x i64 1
  %.promoted = load i32, ptr %__constexpr_0, align 4
  br label %Loop

%Loop:
  %V1 = phi i32 [ %V, %Loop ], [ %.promoted, %Entry ]
  %V = add i32 %V1, 1
  br i1 0, label %Loop, label %Exit

%Exit:
  %V.lcssa = phi i32 [ %V, %Loop ]
  %__constexpr_1 = gep inbounds ptr @X, 4 x i64 1
  store i32 %V.lcssa, ptr %__constexpr_1, align 4
  ret void
}
Transformation seems to be correct!

ERROR: Unsupported instruction:   %x = load volatile i32, ptr @X, align 4
ERROR: Unsupported instruction:   store volatile i32 %x2, ptr @X, align 4

----------------------------------------
define void @test4(ptr %x, i8 %n) {
%0:
  %handle1 = alloca i64 8, align 8
  %handle2 = alloca i64 8, align 8
  store ptr %x, ptr %handle1, align 8
  br label %loop

%loop:
  %tmp = gep ptr %x, 1 x i64 8
  store ptr %tmp, ptr %handle2, align 8
  br label %subloop

%subloop:
  %count = phi i8 [ 0, %loop ], [ %nextcount, %subloop ]
  %offsetx2 = load ptr, ptr %handle2, align 8
  store i8 %n, ptr %offsetx2, align 1
  %newoffsetx2 = gep ptr %offsetx2, 1 x i64 -1
  store ptr %newoffsetx2, ptr %handle2, align 8
  %nextcount = add i8 %count, 1
  %innerexitcond = icmp sge i8 %nextcount, 8
  br i1 %innerexitcond, label %innerexit, label %subloop

%innerexit:
  %offsetx1 = load ptr, ptr %handle1, align 8
  %val = load i8, ptr %offsetx1, align 1
  %cond = icmp eq i8 %val, %n
  br i1 %cond, label %exit, label %loop

%exit:
  ret void
}
=>
define void @test4(ptr %x, i8 %n) {
%0:
  %handle1 = alloca i64 8, align 8
  %handle2 = alloca i64 8, align 8
  store ptr %x, ptr %handle1, align 8
  %tmp = gep ptr %x, 1 x i64 8
  %offsetx1 = load ptr, ptr %handle1, align 8
  br label %loop

%loop:
  br label %subloop

%subloop:
  %newoffsetx21 = phi ptr [ %tmp, %loop ], [ %newoffsetx2, %subloop ]
  %count = phi i8 [ 0, %loop ], [ %nextcount, %subloop ]
  store i8 %n, ptr %newoffsetx21, align 1
  %newoffsetx2 = gep ptr %newoffsetx21, 1 x i64 -1
  %nextcount = add i8 %count, 1
  %innerexitcond = icmp sge i8 %nextcount, 8
  br i1 %innerexitcond, label %innerexit, label %subloop

%innerexit:
  %newoffsetx2.lcssa = phi ptr [ %newoffsetx2, %subloop ]
  %val = load i8, ptr %offsetx1, align 1
  %cond = icmp eq i8 %val, %n
  br i1 %cond, label %exit, label %loop

%exit:
  %newoffsetx2.lcssa.lcssa = phi ptr [ %newoffsetx2.lcssa, %innerexit ]
  store ptr %newoffsetx2.lcssa.lcssa, ptr %handle2, align 8
  ret void
}
Transformation seems to be correct!

ERROR: Unsupported attribute: noalias
ERROR: Unsupported metadata: 1

----------------------------------------
define i32 @test7() {
%entry:
  %local = alloca i64 4, align 4
  call void @capture(ptr %local)
  br label %loop

%loop:
  %j = phi i32 [ 0, %entry ], [ %next, %loop ]
  %x = load i32, ptr %local, align 4
  %x2 = call i32 @opaque(i32 %x) memory(argmem: readwrite)
  store i32 %x2, ptr %local, align 4
  %next = add i32 %j, 1
  %cond = icmp eq i32 %next, 0
  br i1 %cond, label %exit, label %loop

%exit:
  %ret = load i32, ptr %local, align 4
  ret i32 %ret
}
=>
define i32 @test7() {
%entry:
  %local = alloca i64 4, align 4
  call void @capture(ptr %local)
  %local.promoted = load i32, ptr %local, align 4
  br label %loop

%loop:
  %x21 = phi i32 [ %local.promoted, %entry ], [ %x2, %loop ]
  %j = phi i32 [ 0, %entry ], [ %next, %loop ]
  %x2 = call i32 @opaque(i32 %x21) memory(argmem: readwrite)
  %next = add i32 %j, 1
  %cond = icmp eq i32 %next, 0
  br i1 %cond, label %exit, label %loop

%exit:
  %x2.lcssa = phi i32 [ %x2, %loop ]
  store i32 %x2.lcssa, ptr %local, align 4
  %ret = load i32, ptr %local, align 4
  ret i32 %ret
}
Transformation seems to be correct!


----------------------------------------
define i32 @test7bad() {
%entry:
  %local = alloca i64 4, align 4
  call void @capture(ptr %local)
  br label %loop

%loop:
  %j = phi i32 [ 0, %entry ], [ %next, %else ]
  %x = load i32, ptr %local, align 4
  %x2 = call i32 @opaque(i32 %x) memory(argmem: readwrite)
  %cmp = icmp eq i32 %x2, 0
  br i1 %cmp, label %if, label %else

%if:
  store i32 %x2, ptr %local, align 4
  br label %else

%else:
  %next = add i32 %j, 1
  %cond = icmp eq i32 %next, 0
  br i1 %cond, label %exit, label %loop

%exit:
  %ret = load i32, ptr %local, align 4
  ret i32 %ret
}
=>
define i32 @test7bad() {
%entry:
  %local = alloca i64 4, align 4
  call void @capture(ptr %local)
  %local.promoted = load i32, ptr %local, align 4
  br label %loop

%loop:
  %x22 = phi i32 [ %local.promoted, %entry ], [ %x21, %else ]
  %j = phi i32 [ 0, %entry ], [ %next, %else ]
  %x2 = call i32 @opaque(i32 %x22) memory(argmem: readwrite)
  %cmp = icmp eq i32 %x2, 0
  br i1 %cmp, label %if, label %else

%if:
  store i32 %x2, ptr %local, align 4
  br label %else

%else:
  %x21 = phi i32 [ %x2, %if ], [ %x22, %loop ]
  %next = add i32 %j, 1
  %cond = icmp eq i32 %next, 0
  br i1 %cond, label %exit, label %loop

%exit:
  %ret = load i32, ptr %local, align 4
  ret i32 %ret
}
Transformation seems to be correct!


----------------------------------------
define i32 @test8() {
%entry:
  %local = alloca i64 4, align 4
  call void @capture(ptr %local)
  br label %loop

%loop:
  %j = phi i32 [ 0, %entry ], [ %next, %loop ]
  %throwaway = call i32 @opaque(i32 %j) memory(argmem: readwrite)
  %x = load i32, ptr %local, align 4
  %x2 = call i32 @opaque(i32 %x) memory(argmem: readwrite)
  store i32 %x2, ptr %local, align 4
  %next = add i32 %j, 1
  %cond = icmp eq i32 %next, 0
  br i1 %cond, label %exit, label %loop

%exit:
  %ret = load i32, ptr %local, align 4
  ret i32 %ret
}
=>
define i32 @test8() {
%entry:
  %local = alloca i64 4, align 4
  call void @capture(ptr %local)
  %local.promoted = load i32, ptr %local, align 4
  br label %loop

%loop:
  %x21 = phi i32 [ %local.promoted, %entry ], [ %x2, %loop ]
  %j = phi i32 [ 0, %entry ], [ %next, %loop ]
  %throwaway = call i32 @opaque(i32 %j) memory(argmem: readwrite)
  %x2 = call i32 @opaque(i32 %x21) memory(argmem: readwrite)
  %next = add i32 %j, 1
  %cond = icmp eq i32 %next, 0
  br i1 %cond, label %exit, label %loop

%exit:
  %x2.lcssa = phi i32 [ %x2, %loop ]
  store i32 %x2.lcssa, ptr %local, align 4
  %ret = load i32, ptr %local, align 4
  ret i32 %ret
}
Transformation seems to be correct!


----------------------------------------
define i32 @test9() {
%entry:
  %local = alloca i64 4, align 4
  call void @capture(ptr %local)
  br label %loop

%loop:
  %j = phi i32 [ 0, %entry ], [ %next, %else ]
  %j2 = call i32 @opaque(i32 %j) memory(argmem: readwrite)
  %cmp = icmp eq i32 %j2, 0
  br i1 %cmp, label %if, label %else

%if:
  %x = load i32, ptr %local, align 4
  br label %else

%else:
  %x2 = phi i32 [ 0, %loop ], [ %x, %if ]
  store i32 %x2, ptr %local, align 4
  %next = add i32 %j, 1
  %cond = icmp eq i32 %next, 0
  br i1 %cond, label %exit, label %loop

%exit:
  %ret = load i32, ptr %local, align 4
  ret i32 %ret
}
=>
define i32 @test9() {
%entry:
  %local = alloca i64 4, align 4
  call void @capture(ptr %local)
  %local.promoted = load i32, ptr %local, align 4
  br label %loop

%loop:
  %x21 = phi i32 [ %local.promoted, %entry ], [ %x2, %else ]
  %j = phi i32 [ 0, %entry ], [ %next, %else ]
  %j2 = call i32 @opaque(i32 %j) memory(argmem: readwrite)
  %cmp = icmp eq i32 %j2, 0
  br i1 %cmp, label %if, label %else

%if:
  br label %else

%else:
  %x2 = phi i32 [ 0, %loop ], [ %x21, %if ]
  %next = add i32 %j, 1
  %cond = icmp eq i32 %next, 0
  br i1 %cond, label %exit, label %loop

%exit:
  %x2.lcssa = phi i32 [ %x2, %else ]
  store i32 %x2.lcssa, ptr %local, align 4
  %ret = load i32, ptr %local, align 4
  ret i32 %ret
}
Transformation seems to be correct!


----------------------------------------
define i32 @test9bad(i32 %i) {
%entry:
  %local = alloca i64 4, align 4
  call void @capture(ptr %local)
  %notderef = gep ptr %local, 4 x i32 %i
  br label %loop

%loop:
  %j = phi i32 [ 0, %entry ], [ %next, %else ]
  %j2 = call i32 @opaque(i32 %j) memory(argmem: readwrite)
  %cmp = icmp eq i32 %j2, 0
  br i1 %cmp, label %if, label %else

%if:
  %x = load i32, ptr %notderef, align 4
  br label %else

%else:
  %x2 = phi i32 [ 0, %loop ], [ %x, %if ]
  store i32 %x2, ptr %notderef, align 4
  %next = add i32 %j, 1
  %cond = icmp eq i32 %next, 0
  br i1 %cond, label %exit, label %loop

%exit:
  %ret = load i32, ptr %notderef, align 4
  ret i32 %ret
}
=>
define i32 @test9bad(i32 %i) {
%entry:
  %local = alloca i64 4, align 4
  call void @capture(ptr %local)
  %notderef = gep ptr %local, 4 x i32 %i
  br label %loop

%loop:
  %j = phi i32 [ 0, %entry ], [ %next, %else ]
  %j2 = call i32 @opaque(i32 %j) memory(argmem: readwrite)
  %cmp = icmp eq i32 %j2, 0
  br i1 %cmp, label %if, label %else

%if:
  %x = load i32, ptr %notderef, align 4
  br label %else

%else:
  %x2 = phi i32 [ 0, %loop ], [ %x, %if ]
  store i32 %x2, ptr %notderef, align 4
  %next = add i32 %j, 1
  %cond = icmp eq i32 %next, 0
  br i1 %cond, label %exit, label %loop

%exit:
  %ret = load i32, ptr %notderef, align 4
  ret i32 %ret
}
Transformation seems to be correct! (syntactically equal)

ERROR: Unsupported instruction:   %X.promoted = load atomic i32, ptr @X unordered, align 4

----------------------------------------
@X = global 4 bytes, align 4

define void @test11(i32 %i) {
%Entry:
  br label %Loop

%Loop:
  %j = phi i32 [ 0, %Entry ], [ %Next, %body ]
  %early.test = icmp ult i32 %j, 32
  br i1 %early.test, label %body, label %Early

%body:
  %x = load i32, ptr @X, align 4
  %x2 = add i32 %x, 1
  store i32 %x2, ptr @X, align 4
  %Next = add i32 %j, 1
  %cond = icmp eq i32 %Next, 0
  br i1 %cond, label %Out, label %Loop

%Out:
  ret void

%Early:
  ret void
}
=>
@X = global 4 bytes, align 4

define void @test11(i32 %i) {
%Entry:
  %X.promoted = load i32, ptr @X, align 4
  br label %Loop

%Loop:
  %x21 = phi i32 [ %X.promoted, %Entry ], [ %x2, %body ]
  %j = phi i32 [ 0, %Entry ], [ %Next, %body ]
  %early.test = icmp ult i32 %j, 32
  br i1 %early.test, label %body, label %Early

%body:
  %x2 = add i32 %x21, 1
  %Next = add i32 %j, 1
  %cond = icmp eq i32 %Next, 0
  br i1 %cond, label %Out, label %Loop

%Out:
  %x2.lcssa = phi i32 [ %x2, %body ]
  store i32 %x2.lcssa, ptr @X, align 4
  ret void

%Early:
  %x21.lcssa = phi i32 [ %x21, %Loop ]
  store i32 %x21.lcssa, ptr @X, align 4
  ret void
}
Transformation seems to be correct!


----------------------------------------
define i8 @test_hoistable_existing_load_sinkable_store_writeonly(ptr dereferenceable(8) %ptr, i8 %start) memory(write) {
%entry:
  br label %loop.header

%loop.header:
  %i = phi i8 [ %start, %entry ], [ %add, %loop.latch ]
  %cmp = icmp ult i8 %i, 4
  br i1 %cmp, label %loop.latch, label %exit

%loop.latch:
  %div = sdiv i8 %i, 3
  %inc = load i8, ptr dereferenceable(8) %ptr, align 1
  store i8 %inc, ptr dereferenceable(8) %ptr, align 1
  %add = add i8 %i, %inc
  br label %loop.header

%exit:
  ret i8 %i
}
=>
define i8 @test_hoistable_existing_load_sinkable_store_writeonly(ptr dereferenceable(8) %ptr, i8 %start) memory(write) {
%entry:
  %ptr.promoted = load i8, ptr dereferenceable(8) %ptr, align 1
  br label %loop.header

%loop.header:
  %inc1 = phi i8 [ %ptr.promoted, %entry ], [ %inc1, %loop.latch ]
  %i = phi i8 [ %start, %entry ], [ %add, %loop.latch ]
  %cmp = icmp ult i8 %i, 4
  br i1 %cmp, label %loop.latch, label %exit

%loop.latch:
  store i8 %inc1, ptr dereferenceable(8) %ptr, align 1
  %add = add i8 %i, %inc1
  br label %loop.header

%exit:
  %i.lcssa = phi i8 [ %i, %loop.header ]
  ret i8 %i.lcssa
}
Transformation doesn't verify! (unsound)
ERROR: Source is more defined than target

Example:
ptr dereferenceable(8) %ptr = pointer(non-local, block_id=1, offset=105)
i8 %start = #xfc (252, -4)

Source:
  >> Jump to %loop.header
i8 %i = #xfc (252, -4)
i1 %cmp = #x0 (0)
  >> Jump to %exit

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

Target:
i8 %ptr.promoted = UB triggered!


Pass: ModuleToFunctionPassAdaptor
Command line: '/home/nlopes/llvm/build/bin/opt' '-load=/home/nlopes/alive2/build/tv/tv.so' '-load-pass-plugin=/home/nlopes/alive2/build/tv/tv.so' '-tv-exit-on-error' '-tv' '-licm' '-S' '-tv' '-tv-smt-to=20000' '-tv-report-dir=/home/nlopes/alive2/build/logs' '-tv-smt-stats'


------------------- SMT STATS -------------------
Num queries: 14
Num invalid: 0
Num skips:   0
Num trivial: 52 (78.8%)
Num timeout: 0 (0.0%)
Num errors:  0 (0.0%)
Num SAT:     14 (100.0%)
Num UNSAT:   0 (0.0%)
Alive2: Transform doesn't verify; aborting!

stderr:

+ : 'RUN: at line 2'
+ /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/LICM/scalar-promote.ll
+ /home/nlopes/alive2/build/opt-alive.sh -licm -S

FileCheck error: '<stdin>' is empty.
FileCheck command line:  /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/LICM/scalar-promote.ll

<-- Back