Test Failure: Transforms/SimpleLoopUnswitch/inject-invariant-conditions.ll

Test source: git

Log:

Source: <stdin>
-- 1. ModuleToFunctionPassAdaptor
-- 1. PassManager<Function> : Skipping NOP
-- 2. FunctionToLoopPassAdaptor

----------------------------------------
define i32 @test_01(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 3. PassManager<Function> : Skipping NOP
-- 4. LoopSimplifyPass

----------------------------------------
define i32 @test_01(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 5. LoopSimplifyPass

----------------------------------------
define i32 @test_01(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 6. LCSSAPass

----------------------------------------
define i32 @test_01(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 7. LCSSAPass

----------------------------------------
define i32 @test_01(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 8. PassManager<Function> : Skipping NOP
-- 9. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 10. SimpleLoopUnswitchPass

----------------------------------------
define i32 @test_01(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 11. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 12. SimpleLoopUnswitchPass

----------------------------------------
define i32 @test_01(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
=>
define i32 @test_01(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  %injected.cond = icmp ule i32 noundef %limit, %x
  br i1 %injected.cond, label %entry.split.us, label %entry.split

%entry.split:
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry.split ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed.split

%guarded:
  %range_check = icmp ult i32 %el, %x
  br label %guarded.check

%guarded.check:
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit.split

%exit.split:
  br label %exit

%range_check_failed:
  ret i32 4294967294

%bound_check_failed.split:
  br label %bound_check_failed

%entry.split.us:
  br label %loop.us

%loop.us:
  %iv.us = phi i32 [ 0, %entry.split.us ], [ %iv.next.us, %backedge.us ]
  %el.ptr.us = gep ptr noundef %p, 4 x i32 %iv.us
  %el.us = load i32, ptr %el.ptr.us, align 4
  %bound_check.us = icmp ult i32 %el.us, noundef %limit
  br i1 %bound_check.us, label %guarded.us, label %bound_check_failed.split.us

%guarded.us:
  br label %backedge.us

%backedge.us:
  %arr.ptr.us = gep ptr noundef %arr, 4 x i32 %el.us
  store i32 %iv.us, ptr %arr.ptr.us, align 4
  %iv.next.us = add i32 %iv.us, 1
  %loop_cond.us = icmp slt i32 %iv.next.us, noundef %n
  br i1 %loop_cond.us, label %loop.us, label %exit.split.us

%exit.split.us:
  br label %exit

%exit:
  ret i32 0

%bound_check_failed.split.us:
  br label %bound_check_failed

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct!

ERROR: Unsupported metadata: 40
-- 13. SimpleLoopUnswitchPass
ERROR: Unsupported metadata: 40
-- 14. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
ERROR: Unsupported metadata: 40
-- 15. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
ERROR: Unsupported metadata: 40
-- 16. SimpleLoopUnswitchPass
ERROR: Unsupported metadata: 40
-- 17. SimpleLoopUnswitchPass
ERROR: Unsupported metadata: 40
-- 18. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
ERROR: Unsupported metadata: 40
-- 19. FunctionToLoopPassAdaptor
ERROR: Unsupported metadata: 40
-- 20. SimplifyCFGPass
ERROR: Unsupported metadata: 40
-- 21. SimplifyCFGPass
ERROR: Unsupported metadata: 40
-- 22. PassManager<Function> : Skipping NOP
ERROR: Unsupported metadata: 40
-- 23. PassManager<Function> : Skipping NOP
-- 24. FunctionToLoopPassAdaptor

----------------------------------------
define i32 @test_01_neg_void_profile(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 25. PassManager<Function> : Skipping NOP
-- 26. LoopSimplifyPass

----------------------------------------
define i32 @test_01_neg_void_profile(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 27. LoopSimplifyPass

----------------------------------------
define i32 @test_01_neg_void_profile(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 28. LCSSAPass

----------------------------------------
define i32 @test_01_neg_void_profile(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 29. LCSSAPass

----------------------------------------
define i32 @test_01_neg_void_profile(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 30. PassManager<Function> : Skipping NOP
-- 31. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 32. SimpleLoopUnswitchPass

----------------------------------------
define i32 @test_01_neg_void_profile(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 33. SimpleLoopUnswitchPass

----------------------------------------
define i32 @test_01_neg_void_profile(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 34. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 35. FunctionToLoopPassAdaptor

----------------------------------------
define i32 @test_01_neg_void_profile(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 36. SimplifyCFGPass

----------------------------------------
define i32 @test_01_neg_void_profile(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 37. SimplifyCFGPass

----------------------------------------
define i32 @test_01_neg_void_profile(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
=>
define i32 @test_01_neg_void_profile(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %common.ret

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %common.ret

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %common.ret

%common.ret:
  %common.ret.op = phi i32 [ 0, %backedge ], [ 4294967295, %loop ], [ 4294967294, %guarded ]
  ret i32 %common.ret.op
}
Transformation seems to be correct!

-- 38. PassManager<Function> : Skipping NOP
-- 39. PassManager<Function> : Skipping NOP
-- 40. FunctionToLoopPassAdaptor

----------------------------------------
define i32 @test_01_constants(ptr noundef %p, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, 200
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, 300
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, 1000
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 41. PassManager<Function> : Skipping NOP
-- 42. LoopSimplifyPass

----------------------------------------
define i32 @test_01_constants(ptr noundef %p, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, 200
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, 300
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, 1000
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 43. LoopSimplifyPass

----------------------------------------
define i32 @test_01_constants(ptr noundef %p, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, 200
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, 300
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, 1000
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 44. LCSSAPass

----------------------------------------
define i32 @test_01_constants(ptr noundef %p, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, 200
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, 300
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, 1000
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 45. LCSSAPass

----------------------------------------
define i32 @test_01_constants(ptr noundef %p, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, 200
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, 300
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, 1000
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 46. PassManager<Function> : Skipping NOP
-- 47. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 48. SimpleLoopUnswitchPass

----------------------------------------
define i32 @test_01_constants(ptr noundef %p, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, 200
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, 300
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, 1000
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 49. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 50. SimpleLoopUnswitchPass

----------------------------------------
define i32 @test_01_constants(ptr noundef %p, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, 200
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, 300
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, 1000
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
=>
define i32 @test_01_constants(ptr noundef %p, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  %injected.cond = icmp ule i32 200, 300
  br i1 %injected.cond, label %entry.split.us, label %entry.split

%entry.split:
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry.split ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, 200
  br i1 %bound_check, label %guarded, label %bound_check_failed.split

%guarded:
  %range_check = icmp ult i32 %el, 300
  br label %guarded.check

%guarded.check:
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, 1000
  br i1 %loop_cond, label %loop, label %exit.split

%exit.split:
  br label %exit

%range_check_failed:
  ret i32 4294967294

%bound_check_failed.split:
  br label %bound_check_failed

%entry.split.us:
  br label %loop.us

%loop.us:
  %iv.us = phi i32 [ 0, %entry.split.us ], [ %iv.next.us, %backedge.us ]
  %el.ptr.us = gep ptr noundef %p, 4 x i32 %iv.us
  %el.us = load i32, ptr %el.ptr.us, align 4
  %bound_check.us = icmp ult i32 %el.us, 200
  br i1 %bound_check.us, label %guarded.us, label %bound_check_failed.split.us

%guarded.us:
  br label %backedge.us

%backedge.us:
  %arr.ptr.us = gep ptr noundef %arr, 4 x i32 %el.us
  store i32 %iv.us, ptr %arr.ptr.us, align 4
  %iv.next.us = add i32 %iv.us, 1
  %loop_cond.us = icmp slt i32 %iv.next.us, 1000
  br i1 %loop_cond.us, label %loop.us, label %exit.split.us

%exit.split.us:
  br label %exit

%exit:
  ret i32 0

%bound_check_failed.split.us:
  br label %bound_check_failed

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct!

ERROR: Unsupported metadata: 40
-- 51. SimpleLoopUnswitchPass
ERROR: Unsupported metadata: 40
-- 52. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
ERROR: Unsupported metadata: 40
-- 53. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
ERROR: Unsupported metadata: 40
-- 54. SimpleLoopUnswitchPass
ERROR: Unsupported metadata: 40
-- 55. SimpleLoopUnswitchPass
ERROR: Unsupported metadata: 40
-- 56. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
ERROR: Unsupported metadata: 40
-- 57. FunctionToLoopPassAdaptor
ERROR: Unsupported metadata: 40
-- 58. SimplifyCFGPass
ERROR: Unsupported metadata: 40
-- 59. SimplifyCFGPass
-- 60. PassManager<Function> : Skipping NOP
-- 61. PassManager<Function> : Skipping NOP
-- 62. FunctionToLoopPassAdaptor

----------------------------------------
define i32 @test_01_neg_degenerate_profile(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 63. PassManager<Function> : Skipping NOP
-- 64. LoopSimplifyPass

----------------------------------------
define i32 @test_01_neg_degenerate_profile(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 65. LoopSimplifyPass

----------------------------------------
define i32 @test_01_neg_degenerate_profile(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 66. LCSSAPass

----------------------------------------
define i32 @test_01_neg_degenerate_profile(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 67. LCSSAPass

----------------------------------------
define i32 @test_01_neg_degenerate_profile(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 68. PassManager<Function> : Skipping NOP
-- 69. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 70. SimpleLoopUnswitchPass

----------------------------------------
define i32 @test_01_neg_degenerate_profile(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 71. SimpleLoopUnswitchPass

----------------------------------------
define i32 @test_01_neg_degenerate_profile(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 72. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 73. FunctionToLoopPassAdaptor

----------------------------------------
define i32 @test_01_neg_degenerate_profile(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 74. SimplifyCFGPass

----------------------------------------
define i32 @test_01_neg_degenerate_profile(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 75. SimplifyCFGPass

----------------------------------------
define i32 @test_01_neg_degenerate_profile(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
=>
define i32 @test_01_neg_degenerate_profile(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %common.ret

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %common.ret

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %common.ret

%common.ret:
  %common.ret.op = phi i32 [ 0, %backedge ], [ 4294967295, %loop ], [ 4294967294, %guarded ]
  ret i32 %common.ret.op
}
Transformation seems to be correct!

-- 76. PassManager<Function> : Skipping NOP
-- 77. PassManager<Function> : Skipping NOP
-- 78. FunctionToLoopPassAdaptor

----------------------------------------
define i32 @test_01_neg_cold(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 79. PassManager<Function> : Skipping NOP
-- 80. LoopSimplifyPass

----------------------------------------
define i32 @test_01_neg_cold(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 81. LoopSimplifyPass

----------------------------------------
define i32 @test_01_neg_cold(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 82. LCSSAPass

----------------------------------------
define i32 @test_01_neg_cold(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 83. LCSSAPass

----------------------------------------
define i32 @test_01_neg_cold(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 84. PassManager<Function> : Skipping NOP
-- 85. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 86. SimpleLoopUnswitchPass

----------------------------------------
define i32 @test_01_neg_cold(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 87. SimpleLoopUnswitchPass

----------------------------------------
define i32 @test_01_neg_cold(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 88. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 89. FunctionToLoopPassAdaptor

----------------------------------------
define i32 @test_01_neg_cold(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 90. SimplifyCFGPass

----------------------------------------
define i32 @test_01_neg_cold(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 91. SimplifyCFGPass

----------------------------------------
define i32 @test_01_neg_cold(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
=>
define i32 @test_01_neg_cold(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %common.ret

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %common.ret

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %common.ret

%common.ret:
  %common.ret.op = phi i32 [ 0, %backedge ], [ 4294967295, %loop ], [ 4294967294, %guarded ]
  ret i32 %common.ret.op
}
Transformation seems to be correct!

-- 92. PassManager<Function> : Skipping NOP
-- 93. PassManager<Function> : Skipping NOP
-- 94. FunctionToLoopPassAdaptor

----------------------------------------
define i32 @test_01_neg_overflowing_metadata(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 95. PassManager<Function> : Skipping NOP
-- 96. LoopSimplifyPass

----------------------------------------
define i32 @test_01_neg_overflowing_metadata(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 97. LoopSimplifyPass

----------------------------------------
define i32 @test_01_neg_overflowing_metadata(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 98. LCSSAPass

----------------------------------------
define i32 @test_01_neg_overflowing_metadata(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 99. LCSSAPass

----------------------------------------
define i32 @test_01_neg_overflowing_metadata(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 100. PassManager<Function> : Skipping NOP
-- 101. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 102. SimpleLoopUnswitchPass

----------------------------------------
define i32 @test_01_neg_overflowing_metadata(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 103. SimpleLoopUnswitchPass

----------------------------------------
define i32 @test_01_neg_overflowing_metadata(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 104. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 105. FunctionToLoopPassAdaptor

----------------------------------------
define i32 @test_01_neg_overflowing_metadata(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 106. SimplifyCFGPass

----------------------------------------
define i32 @test_01_neg_overflowing_metadata(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 107. SimplifyCFGPass

----------------------------------------
define i32 @test_01_neg_overflowing_metadata(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
=>
define i32 @test_01_neg_overflowing_metadata(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp ult i32 %el, noundef %limit
  br i1 %bound_check, label %guarded, label %common.ret

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %common.ret

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %common.ret

%common.ret:
  %common.ret.op = phi i32 [ 0, %backedge ], [ 4294967295, %loop ], [ 4294967294, %guarded ]
  ret i32 %common.ret.op
}
Transformation seems to be correct!

-- 108. PassManager<Function> : Skipping NOP
-- 109. PassManager<Function> : Skipping NOP
-- 110. FunctionToLoopPassAdaptor

----------------------------------------
define i32 @test_02(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp sge i32 %el, 0
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 111. PassManager<Function> : Skipping NOP
-- 112. LoopSimplifyPass

----------------------------------------
define i32 @test_02(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp sge i32 %el, 0
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 113. LoopSimplifyPass

----------------------------------------
define i32 @test_02(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp sge i32 %el, 0
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 114. LCSSAPass

----------------------------------------
define i32 @test_02(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp sge i32 %el, 0
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 115. LCSSAPass

----------------------------------------
define i32 @test_02(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp sge i32 %el, 0
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 116. PassManager<Function> : Skipping NOP
-- 117. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 118. SimpleLoopUnswitchPass

----------------------------------------
define i32 @test_02(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp sge i32 %el, 0
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 119. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 120. SimpleLoopUnswitchPass

----------------------------------------
define i32 @test_02(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp sge i32 %el, 0
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp ult i32 %el, %x
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%range_check_failed:
  ret i32 4294967294

%bound_check_failed:
  ret i32 4294967295
}
=>
define i32 @test_02(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  %injected.cond = icmp ule i32 2147483648, %x
  br i1 %injected.cond, label %entry.split.us, label %entry.split

%entry.split:
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry.split ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp sge i32 %el, 0
  br i1 %bound_check, label %guarded, label %bound_check_failed.split

%guarded:
  %range_check = icmp ult i32 %el, %x
  br label %guarded.check

%guarded.check:
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit.split

%exit.split:
  br label %exit

%range_check_failed:
  ret i32 4294967294

%bound_check_failed.split:
  br label %bound_check_failed

%entry.split.us:
  br label %loop.us

%loop.us:
  %iv.us = phi i32 [ 0, %entry.split.us ], [ %iv.next.us, %backedge.us ]
  %el.ptr.us = gep ptr noundef %p, 4 x i32 %iv.us
  %el.us = load i32, ptr %el.ptr.us, align 4
  %bound_check.us = icmp sge i32 %el.us, 0
  br i1 %bound_check.us, label %guarded.us, label %bound_check_failed.split.us

%guarded.us:
  br label %backedge.us

%backedge.us:
  %arr.ptr.us = gep ptr noundef %arr, 4 x i32 %el.us
  store i32 %iv.us, ptr %arr.ptr.us, align 4
  %iv.next.us = add i32 %iv.us, 1
  %loop_cond.us = icmp slt i32 %iv.next.us, noundef %n
  br i1 %loop_cond.us, label %loop.us, label %exit.split.us

%exit.split.us:
  br label %exit

%exit:
  ret i32 0

%bound_check_failed.split.us:
  br label %bound_check_failed

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct!

ERROR: Unsupported metadata: 40
-- 121. SimpleLoopUnswitchPass
ERROR: Unsupported metadata: 40
-- 122. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
ERROR: Unsupported metadata: 40
-- 123. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
ERROR: Unsupported metadata: 40
-- 124. SimpleLoopUnswitchPass
ERROR: Unsupported metadata: 40
-- 125. SimpleLoopUnswitchPass
ERROR: Unsupported metadata: 40
-- 126. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
ERROR: Unsupported metadata: 40
-- 127. FunctionToLoopPassAdaptor
ERROR: Unsupported metadata: 40
-- 128. SimplifyCFGPass
ERROR: Unsupported metadata: 40
-- 129. SimplifyCFGPass
ERROR: Unsupported metadata: 40
-- 130. PassManager<Function> : Skipping NOP
ERROR: Unsupported metadata: 40
-- 131. PassManager<Function> : Skipping NOP
-- 132. FunctionToLoopPassAdaptor

----------------------------------------
define i32 @test_02_inverse(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp sge i32 %el, 0
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp uge i32 %el, %x
  br i1 %range_check, label %range_check_failed, label %backedge

%range_check_failed:
  ret i32 4294967294

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 133. PassManager<Function> : Skipping NOP
-- 134. LoopSimplifyPass

----------------------------------------
define i32 @test_02_inverse(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp sge i32 %el, 0
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp uge i32 %el, %x
  br i1 %range_check, label %range_check_failed, label %backedge

%range_check_failed:
  ret i32 4294967294

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 135. LoopSimplifyPass

----------------------------------------
define i32 @test_02_inverse(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp sge i32 %el, 0
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp uge i32 %el, %x
  br i1 %range_check, label %range_check_failed, label %backedge

%range_check_failed:
  ret i32 4294967294

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 136. LCSSAPass

----------------------------------------
define i32 @test_02_inverse(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp sge i32 %el, 0
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp uge i32 %el, %x
  br i1 %range_check, label %range_check_failed, label %backedge

%range_check_failed:
  ret i32 4294967294

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 137. LCSSAPass

----------------------------------------
define i32 @test_02_inverse(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp sge i32 %el, 0
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp uge i32 %el, %x
  br i1 %range_check, label %range_check_failed, label %backedge

%range_check_failed:
  ret i32 4294967294

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 138. PassManager<Function> : Skipping NOP
-- 139. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 140. SimpleLoopUnswitchPass

----------------------------------------
define i32 @test_02_inverse(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp sge i32 %el, 0
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp uge i32 %el, %x
  br i1 %range_check, label %range_check_failed, label %backedge

%range_check_failed:
  ret i32 4294967294

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%bound_check_failed:
  ret i32 4294967295
}
Transformation seems to be correct! (syntactically equal)

-- 141. PassManager<Loop, AnalysisManager<Loop, LoopStandardAnalysisResults&>, LoopStandardAnalysisResults&, LPMUpdater&> : Skipping NOP
-- 142. SimpleLoopUnswitchPass

----------------------------------------
define i32 @test_02_inverse(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp sge i32 %el, 0
  br i1 %bound_check, label %guarded, label %bound_check_failed

%guarded:
  %range_check = icmp uge i32 %el, %x
  br i1 %range_check, label %range_check_failed, label %backedge

%range_check_failed:
  ret i32 4294967294

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit

%exit:
  ret i32 0

%bound_check_failed:
  ret i32 4294967295
}
=>
define i32 @test_02_inverse(ptr noundef %p, i32 noundef %n, i32 noundef %limit, ptr noundef %arr, ptr noundef %x_p) {
%entry:
  %x = load i32, ptr noundef %x_p, align 4
  assume_welldefined i32 %x
  %injected.cond = icmp ule i32 2147483648, %x
  br i1 %injected.cond, label %entry.split.us, label %entry.split

%entry.split:
  br label %loop

%loop:
  %iv = phi i32 [ 0, %entry.split ], [ %iv.next, %backedge ]
  %el.ptr = gep ptr noundef %p, 4 x i32 %iv
  %el = load i32, ptr %el.ptr, align 4
  %bound_check = icmp sge i32 %el, 0
  br i1 %bound_check, label %guarded, label %bound_check_failed.split

%guarded:
  %range_check = icmp uge i32 %el, %x
  br label %guarded.check

%guarded.check:
  br i1 %range_check, label %backedge, label %range_check_failed

%backedge:
  %arr.ptr = gep ptr noundef %arr, 4 x i32 %el
  store i32 %iv, ptr %arr.ptr, align 4
  %iv.next = add i32 %iv, 1
  %loop_cond = icmp slt i32 %iv.next, noundef %n
  br i1 %loop_cond, label %loop, label %exit.split

%exit.split:
  br label %exit

%range_check_failed:
  ret i32 4294967294

%bound_check_failed.split:
  br label %bound_check_failed

%entry.split.us:
  br label %loop.us

%loop.us:
  %iv.us = phi i32 [ 0, %entry.split.us ], [ %iv.next.us, %backedge.us ]
  %el.ptr.us = gep ptr noundef %p, 4 x i32 %iv.us
  %el.us = load i32, ptr %el.ptr.us, align 4
  %bound_check.us = icmp sge i32 %el.us, 0
  br i1 %bound_check.us, label %guarded.us, label %bound_check_failed.split.us

%guarded.us:
  br label %backedge.us

%backedge.us:
  %arr.ptr.us = gep ptr noundef %arr, 4 x i32 %el.us
  store i32 %iv.us, ptr %arr.ptr.us, align 4
  %iv.next.us = add i32 %iv.us, 1
  %loop_cond.us = icmp slt i32 %iv.next.us, noundef %n
  br i1 %loop_cond.us, label %loop.us, label %exit.split.us

%exit.split.us:
  br label %exit

%exit:
  ret i32 0

%bound_check_failed.split.us:
  br label %bound_check_failed

%bound_check_failed:
  ret i32 4294967295
}
Transformation doesn't verify! (unsound)
ERROR: Source is more defined than target

Example:
ptr noundef %p = pointer(non-local, block_id=1, offset=549755813883)
i32 noundef %n = #x00000001 (1)
i32 noundef %limit = #x00000000 (0)
ptr noundef %arr = pointer(non-local, block_id=0, offset=4)
ptr noundef %x_p = pointer(non-local, block_id=1, offset=274877906943)

Source:
i32 %x = #x00000000 (0)
  >> Jump to %loop
i32 %iv = #x00000000 (0)
ptr %el.ptr = pointer(non-local, block_id=1, offset=549755813883)
i32 %el = #x00000000 (0)
i1 %bound_check = #x1 (1)
  >> Jump to %guarded
i1 %range_check = #x1 (1)
  >> Jump to %range_check_failed

SOURCE MEMORY STATE
===================
NON-LOCAL BLOCKS:
Block 0 >	size: 0	align: 4	alloc type: 0	address: 0
Block 1 >	size: 549755817984	align: 2	alloc type: 0	address: 1
Block 2 >	size: 17179869698	align: 4	alloc type: 0	address: 979252544000
Block 3 >	size: 294207455771	align: 2	alloc type: 0	address: 584115552256

Target:
i32 %x = #x00000000 (0)
i1 %injected.cond = #x0 (0)
  >> Jump to %entry.split
  >> Jump to %loop
i32 %iv = #x00000000 (0)
ptr %el.ptr = pointer(non-local, block_id=1, offset=549755813883)
i32 %el = #x00000000 (0)
i1 %bound_check = #x1 (1)
  >> Jump to %guarded
i1 %range_check = #x1 (1)
  >> Jump to %guarded.check
  >> Jump to %backedge
ptr %arr.ptr = pointer(non-local, block_id=0, offset=4)
void = UB triggered!


Pass: SimpleLoopUnswitchPass
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' '-S' '-simple-loop-unswitch-inject-invariant-conditions=true' '-passes=loop(simple-loop-unswitch<nontrivial>),simplifycfg' '-tv-smt-to=20000' '-tv-report-dir=/home/nlopes/alive2/build/logs' '-tv-smt-stats'
Wrote bitcode to: "/home/nlopes/alive2/build/logs/in_eXA2prm4_ACJ8.bc"


------------------- SMT STATS -------------------
Num queries: 37
Num invalid: 0
Num skips:   0
Num trivial: 49 (57.0%)
Num timeout: 0 (0.0%)
Num errors:  0 (0.0%)
Num SAT:     25 (67.6%)
Num UNSAT:   12 (32.4%)
Alive2: Transform doesn't verify; aborting!

stderr:

+ : 'RUN: at line 2'
+ /home/nlopes/alive2/build/opt-alive.sh -S -simple-loop-unswitch-inject-invariant-conditions=true '-passes=loop(simple-loop-unswitch<nontrivial>),simplifycfg'
+ /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/SimpleLoopUnswitch/inject-invariant-conditions.ll

FileCheck error: '<stdin>' is empty.
FileCheck command line:  /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/SimpleLoopUnswitch/inject-invariant-conditions.ll

<-- Back