mirror of
https://github.com/intel/llvm.git
synced 2026-01-14 03:50:17 +08:00
[UTC] Support to test annotated IR (#165419)
Some analysis/transformation, e.g., predicate info/ mem ssa, insert instruction annotations as comments, referring to https://github.com/llvm/llvm-project/pull/165249#discussion_r2466200672. This PR makes UTC support checking these instruction annotations with an extra UTC option `-check-inst-comments`. E.g., Before: ```LLVM ; CHECK: [[Z_0:%.*]] = bitcast i1 [[Z]] to i1 ``` After: ```LLVM ; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[Z]] = and i1 [[XZ]], [[YZ]] Edge: [label [[TMP0:%.*]],label %nope], RenamedOp: [[Z]] } ; CHECK-NEXT: [[Z_0:%.*]] = bitcast i1 [[Z]] to i1 ``` This PR also regenerates all UTC-generated tests for PredicateInfo; No MemSSA test is updated, as there are no UTC-generated tests designated for `print<memoryssa>`.
This commit is contained in:
Kunqiu Chen
GitHub
@@ -1,4 +1,4 @@
|
||||
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
|
||||
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-inst-comments
|
||||
; RUN: opt -S -passes=print-predicateinfo < %s 2>&1 >/dev/null | FileCheck %s
|
||||
|
||||
; FIXME: RenamedOp should be %cmp or %x in all cases here,
|
||||
@@ -9,25 +9,25 @@ define i32 @test(i32 %x) {
|
||||
; CHECK-NEXT: br label [[BB1:%.*]]
|
||||
; CHECK: bb1:
|
||||
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[X:%.*]], 0
|
||||
; CHECK: RenamedOp: [[CMP]]
|
||||
; CHECK: [[CMP_0:%.*]] = bitcast i1 [[CMP]] to i1
|
||||
; CHECK: RenamedOp: [[X]]
|
||||
; CHECK: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[BB2:%.*]], label [[EXIT1:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP]] = icmp eq i32 [[X]], 0 Edge: [label [[BB1]],label [[BB2:%.*]]], RenamedOp: [[CMP]] }
|
||||
; CHECK-NEXT: [[CMP_0:%.*]] = bitcast i1 [[CMP]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP]] = icmp eq i32 [[X]], 0 Edge: [label [[BB1]],label [[BB2]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[BB2]], label [[EXIT1:%.*]]
|
||||
; CHECK: bb2:
|
||||
; CHECK: RenamedOp: [[CMP_0]]
|
||||
; CHECK: [[CMP_0_1:%.*]] = bitcast i1 [[CMP_0]] to i1
|
||||
; CHECK: RenamedOp: [[X]]
|
||||
; CHECK: [[X_0_1:%.*]] = bitcast i32 [[X_0]] to i32
|
||||
; CHECK: RenamedOp: [[X_0]]
|
||||
; CHECK: [[X_0_4:%.*]] = bitcast i32 [[X_0]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP_0]], label [[BB3:%.*]], label [[EXIT2:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP]] = icmp eq i32 [[X]], 0 Edge: [label [[BB2]],label [[BB3:%.*]]], RenamedOp: [[CMP_0]] }
|
||||
; CHECK-NEXT: [[CMP_0_1:%.*]] = bitcast i1 [[CMP_0]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP]] = icmp eq i32 [[X]], 0 Edge: [label [[BB2]],label [[BB3]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_0_1:%.*]] = bitcast i32 [[X_0]] to i32
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[CMP]] = icmp eq i32 [[X]], 0 Edge: [label [[BB2]],label [[EXIT2:%.*]]], RenamedOp: [[X_0]] }
|
||||
; CHECK-NEXT: [[X_0_4:%.*]] = bitcast i32 [[X_0]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP_0]], label [[BB3]], label [[EXIT2]]
|
||||
; CHECK: bb3:
|
||||
; CHECK: RenamedOp: [[X]]
|
||||
; CHECK: [[X_0_1_2:%.*]] = bitcast i32 [[X_0_1]] to i32
|
||||
; CHECK: RenamedOp: [[X_0_1]]
|
||||
; CHECK: [[X_0_1_3:%.*]] = bitcast i32 [[X_0_1]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP_0_1]], label [[EXIT3:%.*]], label [[EXIT4:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP]] = icmp eq i32 [[X]], 0 Edge: [label [[BB3]],label [[EXIT3:%.*]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_0_1_2:%.*]] = bitcast i32 [[X_0_1]] to i32
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[CMP]] = icmp eq i32 [[X]], 0 Edge: [label [[BB3]],label [[EXIT4:%.*]]], RenamedOp: [[X_0_1]] }
|
||||
; CHECK-NEXT: [[X_0_1_3:%.*]] = bitcast i32 [[X_0_1]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP_0_1]], label [[EXIT3]], label [[EXIT4]]
|
||||
; CHECK: exit1:
|
||||
; CHECK-NEXT: ret i32 0
|
||||
; CHECK: exit2:
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
|
||||
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-inst-comments
|
||||
; RUN: opt -passes=print-predicateinfo -disable-output < %s 2>&1 | FileCheck %s
|
||||
|
||||
@a = external global i32 ; <ptr> [#uses=7]
|
||||
@@ -98,12 +98,17 @@ define void @test3(i32 %x, i32 %y) {
|
||||
; CHECK-NEXT: [[XZ:%.*]] = icmp eq i32 [[X:%.*]], 0
|
||||
; CHECK-NEXT: [[YZ:%.*]] = icmp eq i32 [[Y:%.*]], 0
|
||||
; CHECK-NEXT: [[Z:%.*]] = and i1 [[XZ]], [[YZ]]
|
||||
; CHECK: [[Z_0:%.*]] = bitcast i1 [[Z]] to i1
|
||||
; CHECK: [[XZ_0:%.*]] = bitcast i1 [[XZ]] to i1
|
||||
; CHECK: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK: [[YZ_0:%.*]] = bitcast i1 [[YZ]] to i1
|
||||
; CHECK: [[Y_0:%.*]] = bitcast i32 [[Y]] to i32
|
||||
; CHECK-NEXT: br i1 [[Z]], label [[BOTH_ZERO:%.*]], label [[NOPE:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[Z]] = and i1 [[XZ]], [[YZ]] Edge: [label [[TMP0:%.*]],label [[NOPE:%.*]]], RenamedOp: [[Z]] }
|
||||
; CHECK-NEXT: [[Z_0:%.*]] = bitcast i1 [[Z]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[XZ]] = icmp eq i32 [[X]], 0 Edge: [label [[TMP0]],label [[BOTH_ZERO:%.*]]], RenamedOp: [[XZ]] }
|
||||
; CHECK-NEXT: [[XZ_0:%.*]] = bitcast i1 [[XZ]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[XZ]] = icmp eq i32 [[X]], 0 Edge: [label [[TMP0]],label [[BOTH_ZERO]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[YZ]] = icmp eq i32 [[Y]], 0 Edge: [label [[TMP0]],label [[BOTH_ZERO]]], RenamedOp: [[YZ]] }
|
||||
; CHECK-NEXT: [[YZ_0:%.*]] = bitcast i1 [[YZ]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[YZ]] = icmp eq i32 [[Y]], 0 Edge: [label [[TMP0]],label [[BOTH_ZERO]]], RenamedOp: [[Y]] }
|
||||
; CHECK-NEXT: [[Y_0:%.*]] = bitcast i32 [[Y]] to i32
|
||||
; CHECK-NEXT: br i1 [[Z]], label [[BOTH_ZERO]], label [[NOPE]]
|
||||
; CHECK: both_zero:
|
||||
; CHECK-NEXT: call void @foo(i1 [[XZ_0]])
|
||||
; CHECK-NEXT: call void @foo(i1 [[YZ_0]])
|
||||
@@ -133,10 +138,11 @@ define void @test4(i1 %b, i32 %x) {
|
||||
; CHECK-LABEL: @test4(
|
||||
; CHECK-NEXT: br i1 [[B:%.*]], label [[SW:%.*]], label [[CASE3:%.*]]
|
||||
; CHECK: sw:
|
||||
; CHECK: [[X_0:%.*]] = bitcast i32 [[X:%.*]] to i32
|
||||
; CHECK-NEXT: ; switch predicate info { CaseValue: i32 1 Edge: [label [[SW]],label [[CASE1:%.*]]], RenamedOp: [[X:%.*]] }
|
||||
; CHECK-NEXT: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: switch i32 [[X]], label [[DEFAULT:%.*]] [
|
||||
; CHECK-NEXT: i32 0, label [[CASE0:%.*]]
|
||||
; CHECK-NEXT: i32 1, label [[CASE1:%.*]]
|
||||
; CHECK-NEXT: i32 1, label [[CASE1]]
|
||||
; CHECK-NEXT: i32 2, label [[CASE0]]
|
||||
; CHECK-NEXT: i32 3, label [[CASE3]]
|
||||
; CHECK-NEXT: i32 4, label [[DEFAULT]]
|
||||
@@ -180,11 +186,15 @@ case3:
|
||||
define i1 @test5(i32 %x, i32 %y) {
|
||||
; CHECK-LABEL: @test5(
|
||||
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[X:%.*]], [[Y:%.*]]
|
||||
; CHECK: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK: [[X_1:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK: [[Y_0:%.*]] = bitcast i32 [[Y]] to i32
|
||||
; CHECK: [[Y_1:%.*]] = bitcast i32 [[Y]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[SAME:%.*]], label [[DIFFERENT:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP]] = icmp eq i32 [[X]], [[Y]] Edge: [label [[TMP0:%.*]],label [[SAME:%.*]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[CMP]] = icmp eq i32 [[X]], [[Y]] Edge: [label [[TMP0]],label [[DIFFERENT:%.*]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_1:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP]] = icmp eq i32 [[X]], [[Y]] Edge: [label [[TMP0]],label [[SAME]]], RenamedOp: [[Y]] }
|
||||
; CHECK-NEXT: [[Y_0:%.*]] = bitcast i32 [[Y]] to i32
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[CMP]] = icmp eq i32 [[X]], [[Y]] Edge: [label [[TMP0]],label [[DIFFERENT]]], RenamedOp: [[Y]] }
|
||||
; CHECK-NEXT: [[Y_1:%.*]] = bitcast i32 [[Y]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[SAME]], label [[DIFFERENT]]
|
||||
; CHECK: same:
|
||||
; CHECK-NEXT: [[CMP2:%.*]] = icmp ne i32 [[X_0]], [[Y_0]]
|
||||
; CHECK-NEXT: ret i1 [[CMP2]]
|
||||
@@ -253,11 +263,15 @@ different:
|
||||
define i1 @test7(i32 %x, i32 %y) {
|
||||
; CHECK-LABEL: @test7(
|
||||
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i32 [[X:%.*]], [[Y:%.*]]
|
||||
; CHECK: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK: [[X_1:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK: [[Y_0:%.*]] = bitcast i32 [[Y]] to i32
|
||||
; CHECK: [[Y_1:%.*]] = bitcast i32 [[Y]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[SAME:%.*]], label [[DIFFERENT:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP]] = icmp sgt i32 [[X]], [[Y]] Edge: [label [[TMP0:%.*]],label [[SAME:%.*]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[CMP]] = icmp sgt i32 [[X]], [[Y]] Edge: [label [[TMP0]],label [[DIFFERENT:%.*]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_1:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP]] = icmp sgt i32 [[X]], [[Y]] Edge: [label [[TMP0]],label [[SAME]]], RenamedOp: [[Y]] }
|
||||
; CHECK-NEXT: [[Y_0:%.*]] = bitcast i32 [[Y]] to i32
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[CMP]] = icmp sgt i32 [[X]], [[Y]] Edge: [label [[TMP0]],label [[DIFFERENT]]], RenamedOp: [[Y]] }
|
||||
; CHECK-NEXT: [[Y_1:%.*]] = bitcast i32 [[Y]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[SAME]], label [[DIFFERENT]]
|
||||
; CHECK: same:
|
||||
; CHECK-NEXT: [[CMP2:%.*]] = icmp sle i32 [[X_0]], [[Y_0]]
|
||||
; CHECK-NEXT: ret i1 [[CMP2]]
|
||||
@@ -280,11 +294,15 @@ different:
|
||||
define i1 @test7_fp(float %x, float %y) {
|
||||
; CHECK-LABEL: @test7_fp(
|
||||
; CHECK-NEXT: [[CMP:%.*]] = fcmp ogt float [[X:%.*]], [[Y:%.*]]
|
||||
; CHECK: [[X_0:%.*]] = bitcast float [[X]] to float
|
||||
; CHECK: [[X_1:%.*]] = bitcast float [[X]] to float
|
||||
; CHECK: [[Y_0:%.*]] = bitcast float [[Y]] to float
|
||||
; CHECK: [[Y_1:%.*]] = bitcast float [[Y]] to float
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[SAME:%.*]], label [[DIFFERENT:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP]] = fcmp ogt float [[X]], [[Y]] Edge: [label [[TMP0:%.*]],label [[SAME:%.*]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_0:%.*]] = bitcast float [[X]] to float
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[CMP]] = fcmp ogt float [[X]], [[Y]] Edge: [label [[TMP0]],label [[DIFFERENT:%.*]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_1:%.*]] = bitcast float [[X]] to float
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP]] = fcmp ogt float [[X]], [[Y]] Edge: [label [[TMP0]],label [[SAME]]], RenamedOp: [[Y]] }
|
||||
; CHECK-NEXT: [[Y_0:%.*]] = bitcast float [[Y]] to float
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[CMP]] = fcmp ogt float [[X]], [[Y]] Edge: [label [[TMP0]],label [[DIFFERENT]]], RenamedOp: [[Y]] }
|
||||
; CHECK-NEXT: [[Y_1:%.*]] = bitcast float [[Y]] to float
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[SAME]], label [[DIFFERENT]]
|
||||
; CHECK: same:
|
||||
; CHECK-NEXT: [[CMP2:%.*]] = fcmp ule float [[X_0]], [[Y_0]]
|
||||
; CHECK-NEXT: ret i1 [[CMP2]]
|
||||
@@ -353,9 +371,11 @@ different:
|
||||
define i32 @test9(i32 %i, i32 %j) {
|
||||
; CHECK-LABEL: @test9(
|
||||
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[I:%.*]], [[J:%.*]]
|
||||
; CHECK: [[I_0:%.*]] = bitcast i32 [[I]] to i32
|
||||
; CHECK: [[J_0:%.*]] = bitcast i32 [[J]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[RET:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP]] = icmp eq i32 [[I]], [[J]] Edge: [label [[TMP0:%.*]],label [[COND_TRUE:%.*]]], RenamedOp: [[I]] }
|
||||
; CHECK-NEXT: [[I_0:%.*]] = bitcast i32 [[I]] to i32
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP]] = icmp eq i32 [[I]], [[J]] Edge: [label [[TMP0]],label [[COND_TRUE]]], RenamedOp: [[J]] }
|
||||
; CHECK-NEXT: [[J_0:%.*]] = bitcast i32 [[J]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[COND_TRUE]], label [[RET:%.*]]
|
||||
; CHECK: cond_true:
|
||||
; CHECK-NEXT: [[DIFF:%.*]] = sub i32 [[I_0]], [[J_0]]
|
||||
; CHECK-NEXT: ret i32 [[DIFF]]
|
||||
@@ -376,9 +396,11 @@ ret:
|
||||
define i32 @test10(i32 %j, i32 %i) {
|
||||
; CHECK-LABEL: @test10(
|
||||
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[I:%.*]], [[J:%.*]]
|
||||
; CHECK: [[I_0:%.*]] = bitcast i32 [[I]] to i32
|
||||
; CHECK: [[J_0:%.*]] = bitcast i32 [[J]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[RET:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP]] = icmp eq i32 [[I]], [[J]] Edge: [label [[TMP0:%.*]],label [[COND_TRUE:%.*]]], RenamedOp: [[I]] }
|
||||
; CHECK-NEXT: [[I_0:%.*]] = bitcast i32 [[I]] to i32
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP]] = icmp eq i32 [[I]], [[J]] Edge: [label [[TMP0]],label [[COND_TRUE]]], RenamedOp: [[J]] }
|
||||
; CHECK-NEXT: [[J_0:%.*]] = bitcast i32 [[J]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[COND_TRUE]], label [[RET:%.*]]
|
||||
; CHECK: cond_true:
|
||||
; CHECK-NEXT: [[DIFF:%.*]] = sub i32 [[I_0]], [[J_0]]
|
||||
; CHECK-NEXT: ret i32 [[DIFF]]
|
||||
@@ -403,15 +425,18 @@ define i32 @test11(i32 %x) {
|
||||
; CHECK-NEXT: [[V0:%.*]] = call i32 @yogibar()
|
||||
; CHECK-NEXT: [[V1:%.*]] = call i32 @yogibar()
|
||||
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[V0]], [[V1]]
|
||||
; CHECK: [[V0_0:%.*]] = bitcast i32 [[V0]] to i32
|
||||
; CHECK: [[V1_0:%.*]] = bitcast i32 [[V1]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[NEXT:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[CMP]] = icmp eq i32 [[V0]], [[V1]] Edge: [label [[TMP0:%.*]],label [[NEXT:%.*]]], RenamedOp: [[V0]] }
|
||||
; CHECK-NEXT: [[V0_0:%.*]] = bitcast i32 [[V0]] to i32
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP]] = icmp eq i32 [[V0]], [[V1]] Edge: [label [[TMP0]],label [[COND_TRUE:%.*]]], RenamedOp: [[V1]] }
|
||||
; CHECK-NEXT: [[V1_0:%.*]] = bitcast i32 [[V1]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[COND_TRUE]], label [[NEXT]]
|
||||
; CHECK: cond_true:
|
||||
; CHECK-NEXT: ret i32 [[V1_0]]
|
||||
; CHECK: next:
|
||||
; CHECK-NEXT: [[CMP2:%.*]] = icmp eq i32 [[X:%.*]], [[V0_0]]
|
||||
; CHECK: [[V0_0_1:%.*]] = bitcast i32 [[V0_0]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP2]], label [[COND_TRUE2:%.*]], label [[NEXT2:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP2]] = icmp eq i32 [[X]], [[V0_0]] Edge: [label [[NEXT]],label [[COND_TRUE2:%.*]]], RenamedOp: [[V0_0]] }
|
||||
; CHECK-NEXT: [[V0_0_1:%.*]] = bitcast i32 [[V0_0]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP2]], label [[COND_TRUE2]], label [[NEXT2:%.*]]
|
||||
; CHECK: cond_true2:
|
||||
; CHECK-NEXT: ret i32 [[V0_0_1]]
|
||||
; CHECK: next2:
|
||||
@@ -439,9 +464,11 @@ next2:
|
||||
define i32 @test12(i32 %x) {
|
||||
; CHECK-LABEL: @test12(
|
||||
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[X:%.*]], 0
|
||||
; CHECK: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK: [[X_1:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP]] = icmp eq i32 [[X]], 0 Edge: [label [[TMP0:%.*]],label [[COND_TRUE:%.*]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[CMP]] = icmp eq i32 [[X]], 0 Edge: [label [[TMP0]],label [[COND_FALSE:%.*]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_1:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[COND_TRUE]], label [[COND_FALSE]]
|
||||
; CHECK: cond_true:
|
||||
; CHECK-NEXT: br label [[RET:%.*]]
|
||||
; CHECK: cond_false:
|
||||
|
||||
@@ -1,16 +1,18 @@
|
||||
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
|
||||
; RUN: opt -passes=print-predicateinfo < %s 2>&1 | FileCheck %s
|
||||
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-inst-comments
|
||||
; RUN: opt -passes=print-predicateinfo -disable-output < %s 2>&1 | FileCheck %s
|
||||
define i1 @f(i32 %x, i1 %y) {
|
||||
; CHECK-LABEL: @f(
|
||||
; CHECK-NEXT: br i1 [[Y:%.*]], label [[BB0:%.*]], label [[BB1:%.*]]
|
||||
; CHECK: bb0:
|
||||
; CHECK-NEXT: [[CMP:%.*]] = icmp sge i32 [[X:%.*]], 0
|
||||
; CHECK: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[BB2:%.*]], label [[BB3:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP]] = icmp sge i32 [[X]], 0 Edge: [label [[BB0]],label [[BB2:%.*]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[BB2]], label [[BB3:%.*]]
|
||||
; CHECK: bb1:
|
||||
; CHECK-NEXT: [[X2:%.*]] = add nuw nsw i32 [[X]], 1
|
||||
; CHECK-NEXT: [[CMP2:%.*]] = icmp sge i32 [[X2]], 2
|
||||
; CHECK: [[X2_0:%.*]] = bitcast i32 [[X2]] to i32
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP2]] = icmp sge i32 [[X2]], 2 Edge: [label [[BB1]],label [[BB2]]], RenamedOp: [[X2]] }
|
||||
; CHECK-NEXT: [[X2_0:%.*]] = bitcast i32 [[X2]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP2]], label [[BB2]], label [[BB3]]
|
||||
; CHECK: bb2:
|
||||
; CHECK-NEXT: [[X3:%.*]] = phi i32 [ [[X_0]], [[BB0]] ], [ [[X2_0]], [[BB1]] ]
|
||||
@@ -38,12 +40,14 @@ define i1 @g(i32 %x, i1 %y) {
|
||||
; CHECK-NEXT: br i1 [[Y:%.*]], label [[BB0:%.*]], label [[BB1:%.*]]
|
||||
; CHECK: bb0:
|
||||
; CHECK-NEXT: [[CMP:%.*]] = icmp sge i32 [[X:%.*]], 0
|
||||
; CHECK: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[BB3:%.*]], label [[BB2:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[CMP]] = icmp sge i32 [[X]], 0 Edge: [label [[BB0]],label [[BB2:%.*]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[BB3:%.*]], label [[BB2]]
|
||||
; CHECK: bb1:
|
||||
; CHECK-NEXT: [[X2:%.*]] = add nuw nsw i32 [[X]], 1
|
||||
; CHECK-NEXT: [[CMP2:%.*]] = icmp sge i32 [[X2]], 2
|
||||
; CHECK: [[X2_0:%.*]] = bitcast i32 [[X2]] to i32
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[CMP2]] = icmp sge i32 [[X2]], 2 Edge: [label [[BB1]],label [[BB2]]], RenamedOp: [[X2]] }
|
||||
; CHECK-NEXT: [[X2_0:%.*]] = bitcast i32 [[X2]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP2]], label [[BB3]], label [[BB2]]
|
||||
; CHECK: bb2:
|
||||
; CHECK-NEXT: [[X3:%.*]] = phi i32 [ [[X_0]], [[BB0]] ], [ [[X2_0]], [[BB1]] ]
|
||||
|
||||
@@ -1,16 +1,17 @@
|
||||
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
|
||||
; RUN: opt -passes=print-predicateinfo < %s 2>&1 | FileCheck %s
|
||||
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-inst-comments
|
||||
; RUN: opt -passes=print-predicateinfo -disable-output < %s 2>&1 | FileCheck %s
|
||||
|
||||
define i32 @f1(i32 %x) {
|
||||
; CHECK-LABEL: @f1(
|
||||
; CHECK-NEXT: bb0:
|
||||
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[X:%.*]], 0
|
||||
; CHECK: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[BB2:%.*]], label [[BB1:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP]] = icmp eq i32 [[X]], 0 Edge: [label [[BB0:%.*]],label [[BB2:%.*]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[BB2]], label [[BB1:%.*]]
|
||||
; CHECK: bb1:
|
||||
; CHECK-NEXT: br label [[BB2]]
|
||||
; CHECK: bb2:
|
||||
; CHECK-NEXT: [[COND:%.*]] = phi i32 [ [[X_0]], [[BB0:%.*]] ], [ 0, [[BB1]] ]
|
||||
; CHECK-NEXT: [[COND:%.*]] = phi i32 [ [[X_0]], [[BB0]] ], [ 0, [[BB1]] ]
|
||||
; CHECK-NEXT: [[FOO:%.*]] = add i32 [[COND]], [[X]]
|
||||
; CHECK-NEXT: ret i32 [[FOO]]
|
||||
;
|
||||
@@ -29,12 +30,13 @@ define i32 @f2(i32 %x) {
|
||||
; CHECK-LABEL: @f2(
|
||||
; CHECK-NEXT: bb0:
|
||||
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 [[X:%.*]], 0
|
||||
; CHECK: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[BB1:%.*]], label [[BB2:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[CMP]] = icmp ne i32 [[X]], 0 Edge: [label [[BB0:%.*]],label [[BB2:%.*]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[BB1:%.*]], label [[BB2]]
|
||||
; CHECK: bb1:
|
||||
; CHECK-NEXT: br label [[BB2]]
|
||||
; CHECK: bb2:
|
||||
; CHECK-NEXT: [[COND:%.*]] = phi i32 [ [[X_0]], [[BB0:%.*]] ], [ 0, [[BB1]] ]
|
||||
; CHECK-NEXT: [[COND:%.*]] = phi i32 [ [[X_0]], [[BB0]] ], [ 0, [[BB1]] ]
|
||||
; CHECK-NEXT: [[FOO:%.*]] = add i32 [[COND]], [[X]]
|
||||
; CHECK-NEXT: ret i32 [[FOO]]
|
||||
;
|
||||
@@ -52,14 +54,15 @@ bb2:
|
||||
define i32 @f3(i32 %x) {
|
||||
; CHECK-LABEL: @f3(
|
||||
; CHECK-NEXT: bb0:
|
||||
; CHECK: [[X_0:%.*]] = bitcast i32 [[X:%.*]] to i32
|
||||
; CHECK-NEXT: ; switch predicate info { CaseValue: i32 0 Edge: [label [[BB0:%.*]],label [[BB2:%.*]]], RenamedOp: [[X:%.*]] }
|
||||
; CHECK-NEXT: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: switch i32 [[X]], label [[BB1:%.*]] [
|
||||
; CHECK-NEXT: i32 0, label [[BB2:%.*]]
|
||||
; CHECK-NEXT: i32 0, label [[BB2]]
|
||||
; CHECK-NEXT: ]
|
||||
; CHECK: bb1:
|
||||
; CHECK-NEXT: br label [[BB2]]
|
||||
; CHECK: bb2:
|
||||
; CHECK-NEXT: [[COND:%.*]] = phi i32 [ [[X_0]], [[BB0:%.*]] ], [ 0, [[BB1]] ]
|
||||
; CHECK-NEXT: [[COND:%.*]] = phi i32 [ [[X_0]], [[BB0]] ], [ 0, [[BB1]] ]
|
||||
; CHECK-NEXT: [[FOO:%.*]] = add i32 [[COND]], [[X]]
|
||||
; CHECK-NEXT: ret i32 [[FOO]]
|
||||
;
|
||||
@@ -78,13 +81,14 @@ define double @fcmp_oeq_not_zero(double %x, double %y) {
|
||||
; CHECK-LABEL: @fcmp_oeq_not_zero(
|
||||
; CHECK-NEXT: entry:
|
||||
; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq double [[Y:%.*]], 2.000000e+00
|
||||
; CHECK: [[Y_0:%.*]] = bitcast double [[Y]] to double
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[IF:%.*]], label [[RETURN:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP]] = fcmp oeq double [[Y]], 2.000000e+00 Edge: [label [[ENTRY:%.*]],label [[IF:%.*]]], RenamedOp: [[Y]] }
|
||||
; CHECK-NEXT: [[Y_0:%.*]] = bitcast double [[Y]] to double
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[IF]], label [[RETURN:%.*]]
|
||||
; CHECK: if:
|
||||
; CHECK-NEXT: [[DIV:%.*]] = fdiv double [[X:%.*]], [[Y_0]]
|
||||
; CHECK-NEXT: br label [[RETURN]]
|
||||
; CHECK: return:
|
||||
; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[IF]] ], [ [[X]], [[ENTRY:%.*]] ]
|
||||
; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[IF]] ], [ [[X]], [[ENTRY]] ]
|
||||
; CHECK-NEXT: ret double [[RETVAL]]
|
||||
;
|
||||
entry:
|
||||
@@ -105,13 +109,14 @@ define double @fcmp_une_not_zero(double %x, double %y) {
|
||||
; CHECK-LABEL: @fcmp_une_not_zero(
|
||||
; CHECK-NEXT: entry:
|
||||
; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[Y:%.*]], 2.000000e+00
|
||||
; CHECK: [[Y_0:%.*]] = bitcast double [[Y]] to double
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[RETURN:%.*]], label [[ELSE:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[CMP]] = fcmp une double [[Y]], 2.000000e+00 Edge: [label [[ENTRY:%.*]],label [[ELSE:%.*]]], RenamedOp: [[Y]] }
|
||||
; CHECK-NEXT: [[Y_0:%.*]] = bitcast double [[Y]] to double
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[RETURN:%.*]], label [[ELSE]]
|
||||
; CHECK: else:
|
||||
; CHECK-NEXT: [[DIV:%.*]] = fdiv double [[X:%.*]], [[Y_0]]
|
||||
; CHECK-NEXT: br label [[RETURN]]
|
||||
; CHECK: return:
|
||||
; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[ELSE]] ], [ [[X]], [[ENTRY:%.*]] ]
|
||||
; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[ELSE]] ], [ [[X]], [[ENTRY]] ]
|
||||
; CHECK-NEXT: ret double [[RETVAL]]
|
||||
;
|
||||
entry:
|
||||
@@ -132,13 +137,14 @@ define double @fcmp_oeq_zero(double %x, double %y) {
|
||||
; CHECK-LABEL: @fcmp_oeq_zero(
|
||||
; CHECK-NEXT: entry:
|
||||
; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq double [[Y:%.*]], 0.000000e+00
|
||||
; CHECK: [[Y_0:%.*]] = bitcast double [[Y]] to double
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[IF:%.*]], label [[RETURN:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP]] = fcmp oeq double [[Y]], 0.000000e+00 Edge: [label [[ENTRY:%.*]],label [[IF:%.*]]], RenamedOp: [[Y]] }
|
||||
; CHECK-NEXT: [[Y_0:%.*]] = bitcast double [[Y]] to double
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[IF]], label [[RETURN:%.*]]
|
||||
; CHECK: if:
|
||||
; CHECK-NEXT: [[DIV:%.*]] = fdiv double [[X:%.*]], [[Y_0]]
|
||||
; CHECK-NEXT: br label [[RETURN]]
|
||||
; CHECK: return:
|
||||
; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[IF]] ], [ [[X]], [[ENTRY:%.*]] ]
|
||||
; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[IF]] ], [ [[X]], [[ENTRY]] ]
|
||||
; CHECK-NEXT: ret double [[RETVAL]]
|
||||
;
|
||||
entry:
|
||||
@@ -159,13 +165,14 @@ define double @fcmp_une_zero(double %x, double %y) {
|
||||
; CHECK-LABEL: @fcmp_une_zero(
|
||||
; CHECK-NEXT: entry:
|
||||
; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[Y:%.*]], -0.000000e+00
|
||||
; CHECK: [[Y_0:%.*]] = bitcast double [[Y]] to double
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[RETURN:%.*]], label [[ELSE:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[CMP]] = fcmp une double [[Y]], -0.000000e+00 Edge: [label [[ENTRY:%.*]],label [[ELSE:%.*]]], RenamedOp: [[Y]] }
|
||||
; CHECK-NEXT: [[Y_0:%.*]] = bitcast double [[Y]] to double
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[RETURN:%.*]], label [[ELSE]]
|
||||
; CHECK: else:
|
||||
; CHECK-NEXT: [[DIV:%.*]] = fdiv double [[X:%.*]], [[Y_0]]
|
||||
; CHECK-NEXT: br label [[RETURN]]
|
||||
; CHECK: return:
|
||||
; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[ELSE]] ], [ [[X]], [[ENTRY:%.*]] ]
|
||||
; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[ELSE]] ], [ [[X]], [[ENTRY]] ]
|
||||
; CHECK-NEXT: ret double [[RETVAL]]
|
||||
;
|
||||
entry:
|
||||
@@ -188,13 +195,14 @@ define double @fcmp_oeq_maybe_zero(double %x, double %y, double %z1, double %z2)
|
||||
; CHECK-NEXT: entry:
|
||||
; CHECK-NEXT: [[Z:%.*]] = fadd double [[Z1:%.*]], [[Z2:%.*]]
|
||||
; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq double [[Y:%.*]], [[Z]]
|
||||
; CHECK: [[Z_0:%.*]] = bitcast double [[Z]] to double
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[IF:%.*]], label [[RETURN:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[CMP]] = fcmp oeq double [[Y]], [[Z]] Edge: [label [[ENTRY:%.*]],label [[IF:%.*]]], RenamedOp: [[Z]] }
|
||||
; CHECK-NEXT: [[Z_0:%.*]] = bitcast double [[Z]] to double
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[IF]], label [[RETURN:%.*]]
|
||||
; CHECK: if:
|
||||
; CHECK-NEXT: [[DIV:%.*]] = fdiv double [[X:%.*]], [[Z_0]]
|
||||
; CHECK-NEXT: br label [[RETURN]]
|
||||
; CHECK: return:
|
||||
; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[IF]] ], [ [[X]], [[ENTRY:%.*]] ]
|
||||
; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[IF]] ], [ [[X]], [[ENTRY]] ]
|
||||
; CHECK-NEXT: ret double [[RETVAL]]
|
||||
;
|
||||
entry:
|
||||
@@ -217,13 +225,14 @@ define double @fcmp_une_maybe_zero(double %x, double %y, double %z1, double %z2)
|
||||
; CHECK-NEXT: entry:
|
||||
; CHECK-NEXT: [[Z:%.*]] = fadd double [[Z1:%.*]], [[Z2:%.*]]
|
||||
; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[Y:%.*]], [[Z]]
|
||||
; CHECK: [[Z_0:%.*]] = bitcast double [[Z]] to double
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[RETURN:%.*]], label [[ELSE:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[CMP]] = fcmp une double [[Y]], [[Z]] Edge: [label [[ENTRY:%.*]],label [[ELSE:%.*]]], RenamedOp: [[Z]] }
|
||||
; CHECK-NEXT: [[Z_0:%.*]] = bitcast double [[Z]] to double
|
||||
; CHECK-NEXT: br i1 [[CMP]], label [[RETURN:%.*]], label [[ELSE]]
|
||||
; CHECK: else:
|
||||
; CHECK-NEXT: [[DIV:%.*]] = fdiv double [[X:%.*]], [[Z_0]]
|
||||
; CHECK-NEXT: br label [[RETURN]]
|
||||
; CHECK: return:
|
||||
; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[ELSE]] ], [ [[X]], [[ENTRY:%.*]] ]
|
||||
; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[ELSE]] ], [ [[X]], [[ENTRY]] ]
|
||||
; CHECK-NEXT: ret double [[RETVAL]]
|
||||
;
|
||||
entry:
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
|
||||
; RUN: opt -passes=print-predicateinfo < %s 2>&1 | FileCheck %s
|
||||
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-inst-comments
|
||||
; RUN: opt -passes=print-predicateinfo -disable-output < %s 2>&1 | FileCheck %s
|
||||
; Don't insert predicate info for conditions with a single target.
|
||||
@a = global i32 1, align 4
|
||||
@d = common global i32 0, align 4
|
||||
@@ -12,22 +12,27 @@ define i32 @main() {
|
||||
; CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr @d, align 4
|
||||
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i32 [[TMP1]], 0
|
||||
; CHECK-NEXT: br i1 [[TMP2]], label [[TMP3:%.*]], label [[TMP13:%.*]]
|
||||
; CHECK: [[TMP4:%.*]] = load i32, ptr @a, align 4
|
||||
; CHECK: 3:
|
||||
; CHECK-NEXT: [[TMP4:%.*]] = load i32, ptr @a, align 4
|
||||
; CHECK-NEXT: [[TMP5:%.*]] = load i32, ptr @c, align 4
|
||||
; CHECK-NEXT: [[TMP6:%.*]] = icmp slt i32 [[TMP5]], 1
|
||||
; CHECK-NEXT: br i1 [[TMP6]], label [[TMP7:%.*]], label [[TMP9:%.*]]
|
||||
; CHECK: [[TMP8:%.*]] = icmp eq i32 [[TMP4]], 0
|
||||
; CHECK: 7:
|
||||
; CHECK-NEXT: [[TMP8:%.*]] = icmp eq i32 [[TMP4]], 0
|
||||
; CHECK-NEXT: br i1 [[TMP8]], label [[TMP9]], label [[TMP9]]
|
||||
; CHECK: [[DOT0:%.*]] = phi i32 [ [[TMP4]], [[TMP7]] ], [ [[TMP4]], [[TMP7]] ], [ [[DOT1:%.*]], [[TMP13]] ], [ [[TMP4]], [[TMP3]] ]
|
||||
; CHECK: 9:
|
||||
; CHECK-NEXT: [[DOT0:%.*]] = phi i32 [ [[TMP4]], [[TMP7]] ], [ [[TMP4]], [[TMP7]] ], [ [[DOT1:%.*]], [[TMP13]] ], [ [[TMP4]], [[TMP3]] ]
|
||||
; CHECK-NEXT: [[TMP10:%.*]] = load i32, ptr @b, align 4
|
||||
; CHECK-NEXT: [[TMP11:%.*]] = sdiv i32 [[TMP10]], [[DOT0]]
|
||||
; CHECK-NEXT: [[TMP12:%.*]] = icmp eq i32 [[TMP11]], 0
|
||||
; CHECK-NEXT: br i1 [[TMP12]], label [[TMP13]], label [[TMP13]]
|
||||
; CHECK: [[DOT1]] = phi i32 [ [[DOT0]], [[TMP9]] ], [ [[DOT0]], [[TMP9]] ], [ undef, [[TMP0:%.*]] ]
|
||||
; CHECK: 13:
|
||||
; CHECK-NEXT: [[DOT1]] = phi i32 [ [[DOT0]], [[TMP9]] ], [ [[DOT0]], [[TMP9]] ], [ undef, [[TMP0:%.*]] ]
|
||||
; CHECK-NEXT: [[TMP14:%.*]] = load i32, ptr @e, align 4
|
||||
; CHECK-NEXT: [[TMP15:%.*]] = icmp eq i32 [[TMP14]], 0
|
||||
; CHECK-NEXT: br i1 [[TMP15]], label [[TMP16:%.*]], label [[TMP9]]
|
||||
; CHECK: ret i32 0
|
||||
; CHECK: 16:
|
||||
; CHECK-NEXT: ret i32 0
|
||||
;
|
||||
%1 = load i32, ptr @d, align 4
|
||||
%2 = icmp eq i32 %1, 0
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
|
||||
; RUN: opt -passes=print-predicateinfo < %s 2>&1 | FileCheck %s
|
||||
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-inst-comments
|
||||
; RUN: opt -passes=print-predicateinfo -disable-output < %s 2>&1 | FileCheck %s
|
||||
; Don't insert predicate info for conditions with a single target.
|
||||
@a = global i32 6, align 4
|
||||
@c = global i32 -1, align 4
|
||||
@@ -13,26 +13,32 @@ define i32 @main() {
|
||||
; CHECK-LABEL: @main(
|
||||
; CHECK-NEXT: store i32 6, ptr @e, align 4
|
||||
; CHECK-NEXT: br label [[TMP1:%.*]]
|
||||
; CHECK: [[TMP2:%.*]] = load i32, ptr @d, align 4
|
||||
; CHECK: 1:
|
||||
; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr @d, align 4
|
||||
; CHECK-NEXT: [[TMP3:%.*]] = sext i32 [[TMP2]] to i64
|
||||
; CHECK-NEXT: [[TMP4:%.*]] = getelementptr inbounds [6 x i32], ptr @b, i64 0, i64 [[TMP3]]
|
||||
; CHECK-NEXT: [[TMP5:%.*]] = load i32, ptr [[TMP4]], align 4
|
||||
; CHECK-NEXT: [[TMP6:%.*]] = call i32 (ptr, ...) @printf(ptr @.str, i32 [[TMP5]])
|
||||
; CHECK-NEXT: [[TMP7:%.*]] = load i32, ptr @a, align 4
|
||||
; CHECK-NEXT: [[TMP8:%.*]] = icmp eq i32 [[TMP7]], 0
|
||||
; CHECK-NEXT: br i1 [[TMP8]], label %thread-pre-split, label [[TMP9:%.*]]
|
||||
; CHECK: [[TMP10:%.*]] = load i32, ptr @e, align 4
|
||||
; CHECK-NEXT: br i1 [[TMP8]], label [[THREAD_PRE_SPLIT:%.*]], label [[TMP9:%.*]]
|
||||
; CHECK: 9:
|
||||
; CHECK-NEXT: [[TMP10:%.*]] = load i32, ptr @e, align 4
|
||||
; CHECK-NEXT: [[TMP11:%.*]] = icmp eq i32 [[TMP10]], 0
|
||||
; CHECK-NEXT: br i1 [[TMP11]], label [[TMP12:%.*]], label [[TMP12]]
|
||||
; CHECK: thread-pre-split:
|
||||
; CHECK-NEXT: [[DOTPR:%.*]] = load i32, ptr @e, align 4
|
||||
; CHECK-NEXT: br label [[TMP12]]
|
||||
; CHECK: [[TMP13:%.*]] = phi i32 [ [[DOTPR]], %thread-pre-split ], [ [[TMP10]], [[TMP9]] ], [ [[TMP10]], [[TMP9]] ]
|
||||
; CHECK: 12:
|
||||
; CHECK-NEXT: [[TMP13:%.*]] = phi i32 [ [[DOTPR]], [[THREAD_PRE_SPLIT]] ], [ [[TMP10]], [[TMP9]] ], [ [[TMP10]], [[TMP9]] ]
|
||||
; CHECK-NEXT: [[TMP14:%.*]] = icmp ne i32 [[TMP13]], 0
|
||||
; CHECK-NEXT: br i1 [[TMP14]], label [[TMP15:%.*]], label [[TMP15]]
|
||||
; CHECK: br i1 [[TMP14]], label [[TMP16:%.*]], label [[TMP17:%.*]]
|
||||
; CHECK: br label [[TMP17]]
|
||||
; CHECK: [[DOT0:%.*]] = phi i32 [ 1, [[TMP16]] ], [ -1, [[TMP15]] ]
|
||||
; CHECK: 15:
|
||||
; CHECK-NEXT: br i1 [[TMP14]], label [[TMP16:%.*]], label [[TMP17:%.*]]
|
||||
; CHECK: 16:
|
||||
; CHECK-NEXT: br label [[TMP17]]
|
||||
; CHECK: 17:
|
||||
; CHECK-NEXT: [[DOT0:%.*]] = phi i32 [ 1, [[TMP16]] ], [ -1, [[TMP15]] ]
|
||||
; CHECK-NEXT: [[TMP18:%.*]] = and i32 [[DOT0]], 8693
|
||||
; CHECK-NEXT: [[TMP19:%.*]] = load i32, ptr @c, align 4
|
||||
; CHECK-NEXT: [[TMP20:%.*]] = xor i32 [[TMP18]], [[TMP19]]
|
||||
@@ -40,7 +46,8 @@ define i32 @main() {
|
||||
; CHECK-NEXT: store i32 [[TMP21]], ptr @d, align 4
|
||||
; CHECK-NEXT: [[TMP22:%.*]] = icmp slt i32 [[TMP20]], -2
|
||||
; CHECK-NEXT: br i1 [[TMP22]], label [[TMP1]], label [[TMP23:%.*]]
|
||||
; CHECK: ret i32 0
|
||||
; CHECK: 23:
|
||||
; CHECK-NEXT: ret i32 0
|
||||
;
|
||||
store i32 6, ptr @e, align 4
|
||||
br label %1
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
|
||||
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-inst-comments
|
||||
; RUN: opt -passes=print-predicateinfo -disable-output < %s 2>&1 | FileCheck %s
|
||||
|
||||
declare void @foo(i1)
|
||||
@@ -10,12 +10,17 @@ define void @test_or(i32 %x, i32 %y) {
|
||||
; CHECK-NEXT: [[XZ:%.*]] = icmp eq i32 [[X:%.*]], 0
|
||||
; CHECK-NEXT: [[YZ:%.*]] = icmp eq i32 [[Y:%.*]], 0
|
||||
; CHECK-NEXT: [[Z:%.*]] = or i1 [[XZ]], [[YZ]]
|
||||
; CHECK: [[Z_0:%.*]] = bitcast i1 [[Z]] to i1
|
||||
; CHECK: [[XZ_0:%.*]] = bitcast i1 [[XZ]] to i1
|
||||
; CHECK: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK: [[YZ_0:%.*]] = bitcast i1 [[YZ]] to i1
|
||||
; CHECK: [[Y_0:%.*]] = bitcast i32 [[Y]] to i32
|
||||
; CHECK-NEXT: br i1 [[Z]], label [[ONEOF:%.*]], label [[NEITHER:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[Z]] = or i1 [[XZ]], [[YZ]] Edge: [label [[TMP0:%.*]],label [[NEITHER:%.*]]], RenamedOp: [[Z]] }
|
||||
; CHECK-NEXT: [[Z_0:%.*]] = bitcast i1 [[Z]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[XZ]] = icmp eq i32 [[X]], 0 Edge: [label [[TMP0]],label [[NEITHER]]], RenamedOp: [[XZ]] }
|
||||
; CHECK-NEXT: [[XZ_0:%.*]] = bitcast i1 [[XZ]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[XZ]] = icmp eq i32 [[X]], 0 Edge: [label [[TMP0]],label [[NEITHER]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[YZ]] = icmp eq i32 [[Y]], 0 Edge: [label [[TMP0]],label [[NEITHER]]], RenamedOp: [[YZ]] }
|
||||
; CHECK-NEXT: [[YZ_0:%.*]] = bitcast i1 [[YZ]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[YZ]] = icmp eq i32 [[Y]], 0 Edge: [label [[TMP0]],label [[NEITHER]]], RenamedOp: [[Y]] }
|
||||
; CHECK-NEXT: [[Y_0:%.*]] = bitcast i32 [[Y]] to i32
|
||||
; CHECK-NEXT: br i1 [[Z]], label [[ONEOF:%.*]], label [[NEITHER]]
|
||||
; CHECK: oneof:
|
||||
; CHECK-NEXT: call void @foo(i1 [[XZ]])
|
||||
; CHECK-NEXT: call void @foo(i1 [[YZ]])
|
||||
@@ -55,12 +60,17 @@ define void @test_or_logical(i32 %x, i32 %y) {
|
||||
; CHECK-NEXT: [[XZ:%.*]] = icmp eq i32 [[X:%.*]], 0
|
||||
; CHECK-NEXT: [[YZ:%.*]] = icmp eq i32 [[Y:%.*]], 0
|
||||
; CHECK-NEXT: [[Z:%.*]] = select i1 [[XZ]], i1 true, i1 [[YZ]]
|
||||
; CHECK: [[Z_0:%.*]] = bitcast i1 [[Z]] to i1
|
||||
; CHECK: [[XZ_0:%.*]] = bitcast i1 [[XZ]] to i1
|
||||
; CHECK: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK: [[YZ_0:%.*]] = bitcast i1 [[YZ]] to i1
|
||||
; CHECK: [[Y_0:%.*]] = bitcast i32 [[Y]] to i32
|
||||
; CHECK-NEXT: br i1 [[Z]], label [[ONEOF:%.*]], label [[NEITHER:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[Z]] = select i1 [[XZ]], i1 true, i1 [[YZ]] Edge: [label [[TMP0:%.*]],label [[NEITHER:%.*]]], RenamedOp: [[Z]] }
|
||||
; CHECK-NEXT: [[Z_0:%.*]] = bitcast i1 [[Z]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[XZ]] = icmp eq i32 [[X]], 0 Edge: [label [[TMP0]],label [[NEITHER]]], RenamedOp: [[XZ]] }
|
||||
; CHECK-NEXT: [[XZ_0:%.*]] = bitcast i1 [[XZ]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[XZ]] = icmp eq i32 [[X]], 0 Edge: [label [[TMP0]],label [[NEITHER]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[YZ]] = icmp eq i32 [[Y]], 0 Edge: [label [[TMP0]],label [[NEITHER]]], RenamedOp: [[YZ]] }
|
||||
; CHECK-NEXT: [[YZ_0:%.*]] = bitcast i1 [[YZ]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[YZ]] = icmp eq i32 [[Y]], 0 Edge: [label [[TMP0]],label [[NEITHER]]], RenamedOp: [[Y]] }
|
||||
; CHECK-NEXT: [[Y_0:%.*]] = bitcast i32 [[Y]] to i32
|
||||
; CHECK-NEXT: br i1 [[Z]], label [[ONEOF:%.*]], label [[NEITHER]]
|
||||
; CHECK: oneof:
|
||||
; CHECK-NEXT: call void @foo(i1 [[XZ]])
|
||||
; CHECK-NEXT: call void @foo(i1 [[YZ]])
|
||||
@@ -100,12 +110,17 @@ define void @test_and(i32 %x, i32 %y) {
|
||||
; CHECK-NEXT: [[XZ:%.*]] = icmp eq i32 [[X:%.*]], 0
|
||||
; CHECK-NEXT: [[YZ:%.*]] = icmp eq i32 [[Y:%.*]], 0
|
||||
; CHECK-NEXT: [[Z:%.*]] = and i1 [[XZ]], [[YZ]]
|
||||
; CHECK: [[Z_0:%.*]] = bitcast i1 [[Z]] to i1
|
||||
; CHECK: [[XZ_0:%.*]] = bitcast i1 [[XZ]] to i1
|
||||
; CHECK: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK: [[YZ_0:%.*]] = bitcast i1 [[YZ]] to i1
|
||||
; CHECK: [[Y_0:%.*]] = bitcast i32 [[Y]] to i32
|
||||
; CHECK-NEXT: br i1 [[Z]], label [[BOTH:%.*]], label [[NOPE:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[Z]] = and i1 [[XZ]], [[YZ]] Edge: [label [[TMP0:%.*]],label [[NOPE:%.*]]], RenamedOp: [[Z]] }
|
||||
; CHECK-NEXT: [[Z_0:%.*]] = bitcast i1 [[Z]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[XZ]] = icmp eq i32 [[X]], 0 Edge: [label [[TMP0]],label [[BOTH:%.*]]], RenamedOp: [[XZ]] }
|
||||
; CHECK-NEXT: [[XZ_0:%.*]] = bitcast i1 [[XZ]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[XZ]] = icmp eq i32 [[X]], 0 Edge: [label [[TMP0]],label [[BOTH]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[YZ]] = icmp eq i32 [[Y]], 0 Edge: [label [[TMP0]],label [[BOTH]]], RenamedOp: [[YZ]] }
|
||||
; CHECK-NEXT: [[YZ_0:%.*]] = bitcast i1 [[YZ]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[YZ]] = icmp eq i32 [[Y]], 0 Edge: [label [[TMP0]],label [[BOTH]]], RenamedOp: [[Y]] }
|
||||
; CHECK-NEXT: [[Y_0:%.*]] = bitcast i32 [[Y]] to i32
|
||||
; CHECK-NEXT: br i1 [[Z]], label [[BOTH]], label [[NOPE]]
|
||||
; CHECK: both:
|
||||
; CHECK-NEXT: call void @foo(i1 [[XZ_0]])
|
||||
; CHECK-NEXT: call void @foo(i1 [[YZ_0]])
|
||||
@@ -145,12 +160,17 @@ define void @test_and_logical(i32 %x, i32 %y) {
|
||||
; CHECK-NEXT: [[XZ:%.*]] = icmp eq i32 [[X:%.*]], 0
|
||||
; CHECK-NEXT: [[YZ:%.*]] = icmp eq i32 [[Y:%.*]], 0
|
||||
; CHECK-NEXT: [[Z:%.*]] = select i1 [[XZ]], i1 [[YZ]], i1 false
|
||||
; CHECK: [[Z_0:%.*]] = bitcast i1 [[Z]] to i1
|
||||
; CHECK: [[XZ_0:%.*]] = bitcast i1 [[XZ]] to i1
|
||||
; CHECK: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK: [[YZ_0:%.*]] = bitcast i1 [[YZ]] to i1
|
||||
; CHECK: [[Y_0:%.*]] = bitcast i32 [[Y]] to i32
|
||||
; CHECK-NEXT: br i1 [[Z]], label [[BOTH:%.*]], label [[NOPE:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[Z]] = select i1 [[XZ]], i1 [[YZ]], i1 false Edge: [label [[TMP0:%.*]],label [[NOPE:%.*]]], RenamedOp: [[Z]] }
|
||||
; CHECK-NEXT: [[Z_0:%.*]] = bitcast i1 [[Z]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[XZ]] = icmp eq i32 [[X]], 0 Edge: [label [[TMP0]],label [[BOTH:%.*]]], RenamedOp: [[XZ]] }
|
||||
; CHECK-NEXT: [[XZ_0:%.*]] = bitcast i1 [[XZ]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[XZ]] = icmp eq i32 [[X]], 0 Edge: [label [[TMP0]],label [[BOTH]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[YZ]] = icmp eq i32 [[Y]], 0 Edge: [label [[TMP0]],label [[BOTH]]], RenamedOp: [[YZ]] }
|
||||
; CHECK-NEXT: [[YZ_0:%.*]] = bitcast i1 [[YZ]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[YZ]] = icmp eq i32 [[Y]], 0 Edge: [label [[TMP0]],label [[BOTH]]], RenamedOp: [[Y]] }
|
||||
; CHECK-NEXT: [[Y_0:%.*]] = bitcast i32 [[Y]] to i32
|
||||
; CHECK-NEXT: br i1 [[Z]], label [[BOTH]], label [[NOPE]]
|
||||
; CHECK: both:
|
||||
; CHECK-NEXT: call void @foo(i1 [[XZ_0]])
|
||||
; CHECK-NEXT: call void @foo(i1 [[YZ_0]])
|
||||
@@ -190,12 +210,17 @@ define void @testandsame(i32 %x, i32 %y) {
|
||||
; CHECK-NEXT: [[XGT:%.*]] = icmp sgt i32 [[X:%.*]], 0
|
||||
; CHECK-NEXT: [[XLT:%.*]] = icmp slt i32 [[X]], 100
|
||||
; CHECK-NEXT: [[Z:%.*]] = and i1 [[XGT]], [[XLT]]
|
||||
; CHECK: [[Z_0:%.*]] = bitcast i1 [[Z]] to i1
|
||||
; CHECK: [[XGT_0:%.*]] = bitcast i1 [[XGT]] to i1
|
||||
; CHECK: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK: [[X_0_1:%.*]] = bitcast i32 [[X_0]] to i32
|
||||
; CHECK: [[XLT_0:%.*]] = bitcast i1 [[XLT]] to i1
|
||||
; CHECK-NEXT: br i1 [[Z]], label [[BOTH:%.*]], label [[NOPE:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[Z]] = and i1 [[XGT]], [[XLT]] Edge: [label [[TMP0:%.*]],label [[NOPE:%.*]]], RenamedOp: [[Z]] }
|
||||
; CHECK-NEXT: [[Z_0:%.*]] = bitcast i1 [[Z]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[XGT]] = icmp sgt i32 [[X]], 0 Edge: [label [[TMP0]],label [[BOTH:%.*]]], RenamedOp: [[XGT]] }
|
||||
; CHECK-NEXT: [[XGT_0:%.*]] = bitcast i1 [[XGT]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[XGT]] = icmp sgt i32 [[X]], 0 Edge: [label [[TMP0]],label [[BOTH]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[XLT]] = icmp slt i32 [[X]], 100 Edge: [label [[TMP0]],label [[BOTH]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_0_1:%.*]] = bitcast i32 [[X_0]] to i32
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[XLT]] = icmp slt i32 [[X]], 100 Edge: [label [[TMP0]],label [[BOTH]]], RenamedOp: [[XLT]] }
|
||||
; CHECK-NEXT: [[XLT_0:%.*]] = bitcast i1 [[XLT]] to i1
|
||||
; CHECK-NEXT: br i1 [[Z]], label [[BOTH]], label [[NOPE]]
|
||||
; CHECK: both:
|
||||
; CHECK-NEXT: call void @foo(i1 [[XGT_0]])
|
||||
; CHECK-NEXT: call void @foo(i1 [[XLT_0]])
|
||||
@@ -229,17 +254,27 @@ define void @testandassume(i32 %x, i32 %y) {
|
||||
; CHECK-NEXT: [[YZ:%.*]] = icmp eq i32 [[Y:%.*]], 0
|
||||
; CHECK-NEXT: [[Z:%.*]] = and i1 [[XZ]], [[YZ]]
|
||||
; CHECK-NEXT: call void @llvm.assume(i1 [[Z]])
|
||||
; CHECK: [[TMP1:%.*]] = bitcast i32 [[Y]] to i32
|
||||
; CHECK: [[TMP2:%.*]] = bitcast i1 [[YZ]] to i1
|
||||
; CHECK: [[TMP3:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK: [[TMP4:%.*]] = bitcast i1 [[XZ]] to i1
|
||||
; CHECK: [[TMP5:%.*]] = bitcast i1 [[Z]] to i1
|
||||
; CHECK: [[DOT0:%.*]] = bitcast i1 [[TMP5]] to i1
|
||||
; CHECK: [[DOT01:%.*]] = bitcast i1 [[TMP4]] to i1
|
||||
; CHECK: [[DOT02:%.*]] = bitcast i32 [[TMP3]] to i32
|
||||
; CHECK: [[DOT03:%.*]] = bitcast i1 [[TMP2]] to i1
|
||||
; CHECK: [[DOT04:%.*]] = bitcast i32 [[TMP1]] to i32
|
||||
; CHECK-NEXT: br i1 [[TMP5]], label [[BOTH:%.*]], label [[NOPE:%.*]]
|
||||
; CHECK-NEXT: ; assume predicate info { Comparison: [[YZ]] = icmp eq i32 [[Y]], 0, RenamedOp: [[Y]] }
|
||||
; CHECK-NEXT: [[TMP1:%.*]] = bitcast i32 [[Y]] to i32
|
||||
; CHECK-NEXT: ; assume predicate info { Comparison: [[YZ]] = icmp eq i32 [[Y]], 0, RenamedOp: [[YZ]] }
|
||||
; CHECK-NEXT: [[TMP2:%.*]] = bitcast i1 [[YZ]] to i1
|
||||
; CHECK-NEXT: ; assume predicate info { Comparison: [[XZ]] = icmp eq i32 [[X]], 0, RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[TMP3:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: ; assume predicate info { Comparison: [[XZ]] = icmp eq i32 [[X]], 0, RenamedOp: [[XZ]] }
|
||||
; CHECK-NEXT: [[TMP4:%.*]] = bitcast i1 [[XZ]] to i1
|
||||
; CHECK-NEXT: ; assume predicate info { Comparison: [[Z]] = and i1 [[XZ]], [[YZ]], RenamedOp: [[Z]] }
|
||||
; CHECK-NEXT: [[TMP5:%.*]] = bitcast i1 [[Z]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[Z]] = and i1 [[XZ]], [[YZ]] Edge: [label [[TMP0:%.*]],label [[NOPE:%.*]]], RenamedOp: [[TMP5]] }
|
||||
; CHECK-NEXT: [[DOT0:%.*]] = bitcast i1 [[TMP5]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[XZ]] = icmp eq i32 [[X]], 0 Edge: [label [[TMP0]],label [[BOTH:%.*]]], RenamedOp: [[XZ]] }
|
||||
; CHECK-NEXT: [[DOT01:%.*]] = bitcast i1 [[TMP4]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[XZ]] = icmp eq i32 [[X]], 0 Edge: [label [[TMP0]],label [[BOTH]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[DOT02:%.*]] = bitcast i32 [[TMP3]] to i32
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[YZ]] = icmp eq i32 [[Y]], 0 Edge: [label [[TMP0]],label [[BOTH]]], RenamedOp: [[YZ]] }
|
||||
; CHECK-NEXT: [[DOT03:%.*]] = bitcast i1 [[TMP2]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[YZ]] = icmp eq i32 [[Y]], 0 Edge: [label [[TMP0]],label [[BOTH]]], RenamedOp: [[Y]] }
|
||||
; CHECK-NEXT: [[DOT04:%.*]] = bitcast i32 [[TMP1]] to i32
|
||||
; CHECK-NEXT: br i1 [[TMP5]], label [[BOTH]], label [[NOPE]]
|
||||
; CHECK: both:
|
||||
; CHECK-NEXT: call void @foo(i1 [[DOT01]])
|
||||
; CHECK-NEXT: call void @foo(i1 [[DOT03]])
|
||||
@@ -274,9 +309,11 @@ define void @testorassume(i32 %x, i32 %y) {
|
||||
; CHECK-NEXT: [[YZ:%.*]] = icmp eq i32 [[Y:%.*]], 0
|
||||
; CHECK-NEXT: [[Z:%.*]] = or i1 [[XZ]], [[YZ]]
|
||||
; CHECK-NEXT: call void @llvm.assume(i1 [[Z]])
|
||||
; CHECK: [[TMP1:%.*]] = bitcast i1 [[Z]] to i1
|
||||
; CHECK: [[DOT0:%.*]] = bitcast i1 [[TMP1]] to i1
|
||||
; CHECK-NEXT: br i1 [[TMP1]], label [[BOTH:%.*]], label [[NOPE:%.*]]
|
||||
; CHECK-NEXT: ; assume predicate info { Comparison: [[Z]] = or i1 [[XZ]], [[YZ]], RenamedOp: [[Z]] }
|
||||
; CHECK-NEXT: [[TMP1:%.*]] = bitcast i1 [[Z]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[Z]] = or i1 [[XZ]], [[YZ]] Edge: [label [[TMP0:%.*]],label [[NOPE:%.*]]], RenamedOp: [[TMP1]] }
|
||||
; CHECK-NEXT: [[DOT0:%.*]] = bitcast i1 [[TMP1]] to i1
|
||||
; CHECK-NEXT: br i1 [[TMP1]], label [[BOTH:%.*]], label [[NOPE]]
|
||||
; CHECK: both:
|
||||
; CHECK-NEXT: call void @foo(i1 [[XZ]])
|
||||
; CHECK-NEXT: call void @foo(i1 [[YZ]])
|
||||
@@ -307,12 +344,17 @@ define void @test_and_one_unknown_cond(i32 %x, i1 %c1) {
|
||||
; CHECK-LABEL: @test_and_one_unknown_cond(
|
||||
; CHECK-NEXT: [[C2:%.*]] = icmp eq i32 [[X:%.*]], 0
|
||||
; CHECK-NEXT: [[A:%.*]] = and i1 [[C1:%.*]], [[C2]]
|
||||
; CHECK: [[A_0:%.*]] = bitcast i1 [[A]] to i1
|
||||
; CHECK: [[A_1:%.*]] = bitcast i1 [[A]] to i1
|
||||
; CHECK: [[C1_0:%.*]] = bitcast i1 [[C1]] to i1
|
||||
; CHECK: [[C2_0:%.*]] = bitcast i1 [[C2]] to i1
|
||||
; CHECK: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: br i1 [[A]], label [[BOTH:%.*]], label [[NOPE:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[A]] = and i1 [[C1]], [[C2]] Edge: [label [[TMP0:%.*]],label [[BOTH:%.*]]], RenamedOp: [[A]] }
|
||||
; CHECK-NEXT: [[A_0:%.*]] = bitcast i1 [[A]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[A]] = and i1 [[C1]], [[C2]] Edge: [label [[TMP0]],label [[NOPE:%.*]]], RenamedOp: [[A]] }
|
||||
; CHECK-NEXT: [[A_1:%.*]] = bitcast i1 [[A]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison:i1 [[C1]] Edge: [label [[TMP0]],label [[BOTH]]], RenamedOp: [[C1]] }
|
||||
; CHECK-NEXT: [[C1_0:%.*]] = bitcast i1 [[C1]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[C2]] = icmp eq i32 [[X]], 0 Edge: [label [[TMP0]],label [[BOTH]]], RenamedOp: [[C2]] }
|
||||
; CHECK-NEXT: [[C2_0:%.*]] = bitcast i1 [[C2]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[C2]] = icmp eq i32 [[X]], 0 Edge: [label [[TMP0]],label [[BOTH]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: br i1 [[A]], label [[BOTH]], label [[NOPE]]
|
||||
; CHECK: both:
|
||||
; CHECK-NEXT: call void @bar(i32 [[X_0]])
|
||||
; CHECK-NEXT: call void @foo(i1 [[C1_0]])
|
||||
@@ -349,12 +391,17 @@ define void @test_or_one_unknown_cond(i32 %x, i1 %c1) {
|
||||
; CHECK-LABEL: @test_or_one_unknown_cond(
|
||||
; CHECK-NEXT: [[C2:%.*]] = icmp eq i32 [[X:%.*]], 0
|
||||
; CHECK-NEXT: [[A:%.*]] = or i1 [[C1:%.*]], [[C2]]
|
||||
; CHECK: [[A_0:%.*]] = bitcast i1 [[A]] to i1
|
||||
; CHECK: [[A_1:%.*]] = bitcast i1 [[A]] to i1
|
||||
; CHECK: [[C1_0:%.*]] = bitcast i1 [[C1]] to i1
|
||||
; CHECK: [[C2_0:%.*]] = bitcast i1 [[C2]] to i1
|
||||
; CHECK: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: br i1 [[A]], label [[NOPE:%.*]], label [[BOTH_INVERTED:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[A]] = or i1 [[C1]], [[C2]] Edge: [label [[TMP0:%.*]],label [[NOPE:%.*]]], RenamedOp: [[A]] }
|
||||
; CHECK-NEXT: [[A_0:%.*]] = bitcast i1 [[A]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[A]] = or i1 [[C1]], [[C2]] Edge: [label [[TMP0]],label [[BOTH_INVERTED:%.*]]], RenamedOp: [[A]] }
|
||||
; CHECK-NEXT: [[A_1:%.*]] = bitcast i1 [[A]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison:i1 [[C1]] Edge: [label [[TMP0]],label [[BOTH_INVERTED]]], RenamedOp: [[C1]] }
|
||||
; CHECK-NEXT: [[C1_0:%.*]] = bitcast i1 [[C1]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[C2]] = icmp eq i32 [[X]], 0 Edge: [label [[TMP0]],label [[BOTH_INVERTED]]], RenamedOp: [[C2]] }
|
||||
; CHECK-NEXT: [[C2_0:%.*]] = bitcast i1 [[C2]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[C2]] = icmp eq i32 [[X]], 0 Edge: [label [[TMP0]],label [[BOTH_INVERTED]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_0:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: br i1 [[A]], label [[NOPE]], label [[BOTH_INVERTED]]
|
||||
; CHECK: both_inverted:
|
||||
; CHECK-NEXT: call void @bar(i32 [[X_0]])
|
||||
; CHECK-NEXT: call void @foo(i1 [[C1_0]])
|
||||
@@ -391,13 +438,19 @@ define void @test_and_chain(i1 %a, i1 %b, i1 %c) {
|
||||
; CHECK-LABEL: @test_and_chain(
|
||||
; CHECK-NEXT: [[AND1:%.*]] = and i1 [[A:%.*]], [[B:%.*]]
|
||||
; CHECK-NEXT: [[AND2:%.*]] = and i1 [[AND1]], [[C:%.*]]
|
||||
; CHECK: [[AND2_0:%.*]] = bitcast i1 [[AND2]] to i1
|
||||
; CHECK: [[AND2_1:%.*]] = bitcast i1 [[AND2]] to i1
|
||||
; CHECK: [[AND1_0:%.*]] = bitcast i1 [[AND1]] to i1
|
||||
; CHECK: [[A_0:%.*]] = bitcast i1 [[A]] to i1
|
||||
; CHECK: [[B_0:%.*]] = bitcast i1 [[B]] to i1
|
||||
; CHECK: [[C_0:%.*]] = bitcast i1 [[C]] to i1
|
||||
; CHECK-NEXT: br i1 [[AND2]], label [[IF:%.*]], label [[ELSE:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[AND2]] = and i1 [[AND1]], [[C]] Edge: [label [[TMP0:%.*]],label [[IF:%.*]]], RenamedOp: [[AND2]] }
|
||||
; CHECK-NEXT: [[AND2_0:%.*]] = bitcast i1 [[AND2]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[AND2]] = and i1 [[AND1]], [[C]] Edge: [label [[TMP0]],label [[ELSE:%.*]]], RenamedOp: [[AND2]] }
|
||||
; CHECK-NEXT: [[AND2_1:%.*]] = bitcast i1 [[AND2]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[AND1]] = and i1 [[A]], [[B]] Edge: [label [[TMP0]],label [[IF]]], RenamedOp: [[AND1]] }
|
||||
; CHECK-NEXT: [[AND1_0:%.*]] = bitcast i1 [[AND1]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison:i1 [[A]] Edge: [label [[TMP0]],label [[IF]]], RenamedOp: [[A]] }
|
||||
; CHECK-NEXT: [[A_0:%.*]] = bitcast i1 [[A]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison:i1 [[B]] Edge: [label [[TMP0]],label [[IF]]], RenamedOp: [[B]] }
|
||||
; CHECK-NEXT: [[B_0:%.*]] = bitcast i1 [[B]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison:i1 [[C]] Edge: [label [[TMP0]],label [[IF]]], RenamedOp: [[C]] }
|
||||
; CHECK-NEXT: [[C_0:%.*]] = bitcast i1 [[C]] to i1
|
||||
; CHECK-NEXT: br i1 [[AND2]], label [[IF]], label [[ELSE]]
|
||||
; CHECK: if:
|
||||
; CHECK-NEXT: call void @foo(i1 [[A_0]])
|
||||
; CHECK-NEXT: call void @foo(i1 [[B_0]])
|
||||
@@ -438,13 +491,19 @@ define void @test_or_chain(i1 %a, i1 %b, i1 %c) {
|
||||
; CHECK-LABEL: @test_or_chain(
|
||||
; CHECK-NEXT: [[OR1:%.*]] = or i1 [[A:%.*]], [[B:%.*]]
|
||||
; CHECK-NEXT: [[OR2:%.*]] = or i1 [[OR1]], [[C:%.*]]
|
||||
; CHECK: [[OR2_0:%.*]] = bitcast i1 [[OR2]] to i1
|
||||
; CHECK: [[OR2_1:%.*]] = bitcast i1 [[OR2]] to i1
|
||||
; CHECK: [[OR1_0:%.*]] = bitcast i1 [[OR1]] to i1
|
||||
; CHECK: [[A_0:%.*]] = bitcast i1 [[A]] to i1
|
||||
; CHECK: [[B_0:%.*]] = bitcast i1 [[B]] to i1
|
||||
; CHECK: [[C_0:%.*]] = bitcast i1 [[C]] to i1
|
||||
; CHECK-NEXT: br i1 [[OR2]], label [[IF:%.*]], label [[ELSE:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[OR2]] = or i1 [[OR1]], [[C]] Edge: [label [[TMP0:%.*]],label [[IF:%.*]]], RenamedOp: [[OR2]] }
|
||||
; CHECK-NEXT: [[OR2_0:%.*]] = bitcast i1 [[OR2]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[OR2]] = or i1 [[OR1]], [[C]] Edge: [label [[TMP0]],label [[ELSE:%.*]]], RenamedOp: [[OR2]] }
|
||||
; CHECK-NEXT: [[OR2_1:%.*]] = bitcast i1 [[OR2]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[OR1]] = or i1 [[A]], [[B]] Edge: [label [[TMP0]],label [[ELSE]]], RenamedOp: [[OR1]] }
|
||||
; CHECK-NEXT: [[OR1_0:%.*]] = bitcast i1 [[OR1]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison:i1 [[A]] Edge: [label [[TMP0]],label [[ELSE]]], RenamedOp: [[A]] }
|
||||
; CHECK-NEXT: [[A_0:%.*]] = bitcast i1 [[A]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison:i1 [[B]] Edge: [label [[TMP0]],label [[ELSE]]], RenamedOp: [[B]] }
|
||||
; CHECK-NEXT: [[B_0:%.*]] = bitcast i1 [[B]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison:i1 [[C]] Edge: [label [[TMP0]],label [[ELSE]]], RenamedOp: [[C]] }
|
||||
; CHECK-NEXT: [[C_0:%.*]] = bitcast i1 [[C]] to i1
|
||||
; CHECK-NEXT: br i1 [[OR2]], label [[IF]], label [[ELSE]]
|
||||
; CHECK: if:
|
||||
; CHECK-NEXT: call void @foo(i1 [[A]])
|
||||
; CHECK-NEXT: call void @foo(i1 [[B]])
|
||||
@@ -485,11 +544,15 @@ define void @test_and_or_mixed(i1 %a, i1 %b, i1 %c) {
|
||||
; CHECK-LABEL: @test_and_or_mixed(
|
||||
; CHECK-NEXT: [[OR:%.*]] = or i1 [[A:%.*]], [[B:%.*]]
|
||||
; CHECK-NEXT: [[AND:%.*]] = and i1 [[OR]], [[C:%.*]]
|
||||
; CHECK: [[AND_0:%.*]] = bitcast i1 [[AND]] to i1
|
||||
; CHECK: [[AND_1:%.*]] = bitcast i1 [[AND]] to i1
|
||||
; CHECK: [[OR_0:%.*]] = bitcast i1 [[OR]] to i1
|
||||
; CHECK: [[C_0:%.*]] = bitcast i1 [[C]] to i1
|
||||
; CHECK-NEXT: br i1 [[AND]], label [[IF:%.*]], label [[ELSE:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[AND]] = and i1 [[OR]], [[C]] Edge: [label [[TMP0:%.*]],label [[IF:%.*]]], RenamedOp: [[AND]] }
|
||||
; CHECK-NEXT: [[AND_0:%.*]] = bitcast i1 [[AND]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[AND]] = and i1 [[OR]], [[C]] Edge: [label [[TMP0]],label [[ELSE:%.*]]], RenamedOp: [[AND]] }
|
||||
; CHECK-NEXT: [[AND_1:%.*]] = bitcast i1 [[AND]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[OR]] = or i1 [[A]], [[B]] Edge: [label [[TMP0]],label [[IF]]], RenamedOp: [[OR]] }
|
||||
; CHECK-NEXT: [[OR_0:%.*]] = bitcast i1 [[OR]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison:i1 [[C]] Edge: [label [[TMP0]],label [[IF]]], RenamedOp: [[C]] }
|
||||
; CHECK-NEXT: [[C_0:%.*]] = bitcast i1 [[C]] to i1
|
||||
; CHECK-NEXT: br i1 [[AND]], label [[IF]], label [[ELSE]]
|
||||
; CHECK: if:
|
||||
; CHECK-NEXT: call void @foo(i1 [[A]])
|
||||
; CHECK-NEXT: call void @foo(i1 [[B]])
|
||||
@@ -542,16 +605,25 @@ define void @test_deep_and_chain(i1 %a1) {
|
||||
; CHECK-NEXT: [[A13:%.*]] = and i1 [[A12]], true
|
||||
; CHECK-NEXT: [[A14:%.*]] = and i1 [[A13]], true
|
||||
; CHECK-NEXT: [[A15:%.*]] = and i1 [[A14]], true
|
||||
; CHECK: [[A15_0:%.*]] = bitcast i1 [[A15]] to i1
|
||||
; CHECK: [[A15_1:%.*]] = bitcast i1 [[A15]] to i1
|
||||
; CHECK: [[A14_0:%.*]] = bitcast i1 [[A14]] to i1
|
||||
; CHECK: [[A13_0:%.*]] = bitcast i1 [[A13]] to i1
|
||||
; CHECK: [[A12_0:%.*]] = bitcast i1 [[A12]] to i1
|
||||
; CHECK: [[A11_0:%.*]] = bitcast i1 [[A11]] to i1
|
||||
; CHECK: [[A10_0:%.*]] = bitcast i1 [[A10]] to i1
|
||||
; CHECK: [[A9_0:%.*]] = bitcast i1 [[A9]] to i1
|
||||
; CHECK: [[A8_0:%.*]] = bitcast i1 [[A8]] to i1
|
||||
; CHECK-NEXT: br i1 [[A15]], label [[IF:%.*]], label [[ELSE:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[A15]] = and i1 [[A14]], true Edge: [label [[TMP0:%.*]],label [[IF:%.*]]], RenamedOp: [[A15]] }
|
||||
; CHECK-NEXT: [[A15_0:%.*]] = bitcast i1 [[A15]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[A15]] = and i1 [[A14]], true Edge: [label [[TMP0]],label [[ELSE:%.*]]], RenamedOp: [[A15]] }
|
||||
; CHECK-NEXT: [[A15_1:%.*]] = bitcast i1 [[A15]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[A14]] = and i1 [[A13]], true Edge: [label [[TMP0]],label [[IF]]], RenamedOp: [[A14]] }
|
||||
; CHECK-NEXT: [[A14_0:%.*]] = bitcast i1 [[A14]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[A13]] = and i1 [[A12]], true Edge: [label [[TMP0]],label [[IF]]], RenamedOp: [[A13]] }
|
||||
; CHECK-NEXT: [[A13_0:%.*]] = bitcast i1 [[A13]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[A12]] = and i1 [[A11]], true Edge: [label [[TMP0]],label [[IF]]], RenamedOp: [[A12]] }
|
||||
; CHECK-NEXT: [[A12_0:%.*]] = bitcast i1 [[A12]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[A11]] = and i1 [[A10]], true Edge: [label [[TMP0]],label [[IF]]], RenamedOp: [[A11]] }
|
||||
; CHECK-NEXT: [[A11_0:%.*]] = bitcast i1 [[A11]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[A10]] = and i1 [[A9]], true Edge: [label [[TMP0]],label [[IF]]], RenamedOp: [[A10]] }
|
||||
; CHECK-NEXT: [[A10_0:%.*]] = bitcast i1 [[A10]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[A9]] = and i1 [[A8]], true Edge: [label [[TMP0]],label [[IF]]], RenamedOp: [[A9]] }
|
||||
; CHECK-NEXT: [[A9_0:%.*]] = bitcast i1 [[A9]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[A8]] = and i1 [[A7]], true Edge: [label [[TMP0]],label [[IF]]], RenamedOp: [[A8]] }
|
||||
; CHECK-NEXT: [[A8_0:%.*]] = bitcast i1 [[A8]] to i1
|
||||
; CHECK-NEXT: br i1 [[A15]], label [[IF]], label [[ELSE]]
|
||||
; CHECK: if:
|
||||
; CHECK-NEXT: call void @foo(i1 [[A1]])
|
||||
; CHECK-NEXT: call void @foo(i1 [[A2]])
|
||||
@@ -656,16 +728,25 @@ define void @test_deep_and_tree(i1 %a1) {
|
||||
; CHECK-NEXT: [[A13:%.*]] = and i1 [[A12]], [[A12]]
|
||||
; CHECK-NEXT: [[A14:%.*]] = and i1 [[A13]], [[A13]]
|
||||
; CHECK-NEXT: [[A15:%.*]] = and i1 [[A14]], [[A14]]
|
||||
; CHECK: [[A15_0:%.*]] = bitcast i1 [[A15]] to i1
|
||||
; CHECK: [[A15_1:%.*]] = bitcast i1 [[A15]] to i1
|
||||
; CHECK: [[A14_0:%.*]] = bitcast i1 [[A14]] to i1
|
||||
; CHECK: [[A13_0:%.*]] = bitcast i1 [[A13]] to i1
|
||||
; CHECK: [[A12_0:%.*]] = bitcast i1 [[A12]] to i1
|
||||
; CHECK: [[A11_0:%.*]] = bitcast i1 [[A11]] to i1
|
||||
; CHECK: [[A10_0:%.*]] = bitcast i1 [[A10]] to i1
|
||||
; CHECK: [[A9_0:%.*]] = bitcast i1 [[A9]] to i1
|
||||
; CHECK: [[A8_0:%.*]] = bitcast i1 [[A8]] to i1
|
||||
; CHECK-NEXT: br i1 [[A15]], label [[IF:%.*]], label [[ELSE:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[A15]] = and i1 [[A14]], [[A14]] Edge: [label [[TMP0:%.*]],label [[IF:%.*]]], RenamedOp: [[A15]] }
|
||||
; CHECK-NEXT: [[A15_0:%.*]] = bitcast i1 [[A15]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[A15]] = and i1 [[A14]], [[A14]] Edge: [label [[TMP0]],label [[ELSE:%.*]]], RenamedOp: [[A15]] }
|
||||
; CHECK-NEXT: [[A15_1:%.*]] = bitcast i1 [[A15]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[A14]] = and i1 [[A13]], [[A13]] Edge: [label [[TMP0]],label [[IF]]], RenamedOp: [[A14]] }
|
||||
; CHECK-NEXT: [[A14_0:%.*]] = bitcast i1 [[A14]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[A13]] = and i1 [[A12]], [[A12]] Edge: [label [[TMP0]],label [[IF]]], RenamedOp: [[A13]] }
|
||||
; CHECK-NEXT: [[A13_0:%.*]] = bitcast i1 [[A13]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[A12]] = and i1 [[A11]], [[A11]] Edge: [label [[TMP0]],label [[IF]]], RenamedOp: [[A12]] }
|
||||
; CHECK-NEXT: [[A12_0:%.*]] = bitcast i1 [[A12]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[A11]] = and i1 [[A10]], [[A10]] Edge: [label [[TMP0]],label [[IF]]], RenamedOp: [[A11]] }
|
||||
; CHECK-NEXT: [[A11_0:%.*]] = bitcast i1 [[A11]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[A10]] = and i1 [[A9]], [[A9]] Edge: [label [[TMP0]],label [[IF]]], RenamedOp: [[A10]] }
|
||||
; CHECK-NEXT: [[A10_0:%.*]] = bitcast i1 [[A10]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[A9]] = and i1 [[A8]], [[A8]] Edge: [label [[TMP0]],label [[IF]]], RenamedOp: [[A9]] }
|
||||
; CHECK-NEXT: [[A9_0:%.*]] = bitcast i1 [[A9]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[A8]] = and i1 [[A7]], [[A7]] Edge: [label [[TMP0]],label [[IF]]], RenamedOp: [[A8]] }
|
||||
; CHECK-NEXT: [[A8_0:%.*]] = bitcast i1 [[A8]] to i1
|
||||
; CHECK-NEXT: br i1 [[A15]], label [[IF]], label [[ELSE]]
|
||||
; CHECK: if:
|
||||
; CHECK-NEXT: call void @foo(i1 [[A1]])
|
||||
; CHECK-NEXT: call void @foo(i1 [[A2]])
|
||||
@@ -770,16 +851,25 @@ define void @test_deep_or_tree(i1 %a1) {
|
||||
; CHECK-NEXT: [[A13:%.*]] = or i1 [[A12]], [[A12]]
|
||||
; CHECK-NEXT: [[A14:%.*]] = or i1 [[A13]], [[A13]]
|
||||
; CHECK-NEXT: [[A15:%.*]] = or i1 [[A14]], [[A14]]
|
||||
; CHECK: [[A15_0:%.*]] = bitcast i1 [[A15]] to i1
|
||||
; CHECK: [[A15_1:%.*]] = bitcast i1 [[A15]] to i1
|
||||
; CHECK: [[A14_0:%.*]] = bitcast i1 [[A14]] to i1
|
||||
; CHECK: [[A13_0:%.*]] = bitcast i1 [[A13]] to i1
|
||||
; CHECK: [[A12_0:%.*]] = bitcast i1 [[A12]] to i1
|
||||
; CHECK: [[A11_0:%.*]] = bitcast i1 [[A11]] to i1
|
||||
; CHECK: [[A10_0:%.*]] = bitcast i1 [[A10]] to i1
|
||||
; CHECK: [[A9_0:%.*]] = bitcast i1 [[A9]] to i1
|
||||
; CHECK: [[A8_0:%.*]] = bitcast i1 [[A8]] to i1
|
||||
; CHECK-NEXT: br i1 [[A15]], label [[IF:%.*]], label [[ELSE:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[A15]] = or i1 [[A14]], [[A14]] Edge: [label [[TMP0:%.*]],label [[IF:%.*]]], RenamedOp: [[A15]] }
|
||||
; CHECK-NEXT: [[A15_0:%.*]] = bitcast i1 [[A15]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[A15]] = or i1 [[A14]], [[A14]] Edge: [label [[TMP0]],label [[ELSE:%.*]]], RenamedOp: [[A15]] }
|
||||
; CHECK-NEXT: [[A15_1:%.*]] = bitcast i1 [[A15]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[A14]] = or i1 [[A13]], [[A13]] Edge: [label [[TMP0]],label [[ELSE]]], RenamedOp: [[A14]] }
|
||||
; CHECK-NEXT: [[A14_0:%.*]] = bitcast i1 [[A14]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[A13]] = or i1 [[A12]], [[A12]] Edge: [label [[TMP0]],label [[ELSE]]], RenamedOp: [[A13]] }
|
||||
; CHECK-NEXT: [[A13_0:%.*]] = bitcast i1 [[A13]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[A12]] = or i1 [[A11]], [[A11]] Edge: [label [[TMP0]],label [[ELSE]]], RenamedOp: [[A12]] }
|
||||
; CHECK-NEXT: [[A12_0:%.*]] = bitcast i1 [[A12]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[A11]] = or i1 [[A10]], [[A10]] Edge: [label [[TMP0]],label [[ELSE]]], RenamedOp: [[A11]] }
|
||||
; CHECK-NEXT: [[A11_0:%.*]] = bitcast i1 [[A11]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[A10]] = or i1 [[A9]], [[A9]] Edge: [label [[TMP0]],label [[ELSE]]], RenamedOp: [[A10]] }
|
||||
; CHECK-NEXT: [[A10_0:%.*]] = bitcast i1 [[A10]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[A9]] = or i1 [[A8]], [[A8]] Edge: [label [[TMP0]],label [[ELSE]]], RenamedOp: [[A9]] }
|
||||
; CHECK-NEXT: [[A9_0:%.*]] = bitcast i1 [[A9]] to i1
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 0 Comparison: [[A8]] = or i1 [[A7]], [[A7]] Edge: [label [[TMP0]],label [[ELSE]]], RenamedOp: [[A8]] }
|
||||
; CHECK-NEXT: [[A8_0:%.*]] = bitcast i1 [[A8]] to i1
|
||||
; CHECK-NEXT: br i1 [[A15]], label [[IF]], label [[ELSE]]
|
||||
; CHECK: if:
|
||||
; CHECK-NEXT: call void @foo(i1 [[A1]])
|
||||
; CHECK-NEXT: call void @foo(i1 [[A2]])
|
||||
@@ -873,11 +963,16 @@ define void @test_assume_and_chain(i1 %a, i1 %b, i1 %c) {
|
||||
; CHECK-NEXT: [[AND1:%.*]] = and i1 [[A:%.*]], [[B:%.*]]
|
||||
; CHECK-NEXT: [[AND2:%.*]] = and i1 [[AND1]], [[C:%.*]]
|
||||
; CHECK-NEXT: call void @llvm.assume(i1 [[AND2]])
|
||||
; CHECK: [[TMP1:%.*]] = bitcast i1 [[C]] to i1
|
||||
; CHECK: [[TMP2:%.*]] = bitcast i1 [[B]] to i1
|
||||
; CHECK: [[TMP3:%.*]] = bitcast i1 [[A]] to i1
|
||||
; CHECK: [[TMP4:%.*]] = bitcast i1 [[AND1]] to i1
|
||||
; CHECK: [[TMP5:%.*]] = bitcast i1 [[AND2]] to i1
|
||||
; CHECK-NEXT: ; assume predicate info { Comparison:i1 [[C]], RenamedOp: [[C]] }
|
||||
; CHECK-NEXT: [[TMP1:%.*]] = bitcast i1 [[C]] to i1
|
||||
; CHECK-NEXT: ; assume predicate info { Comparison:i1 [[B]], RenamedOp: [[B]] }
|
||||
; CHECK-NEXT: [[TMP2:%.*]] = bitcast i1 [[B]] to i1
|
||||
; CHECK-NEXT: ; assume predicate info { Comparison:i1 [[A]], RenamedOp: [[A]] }
|
||||
; CHECK-NEXT: [[TMP3:%.*]] = bitcast i1 [[A]] to i1
|
||||
; CHECK-NEXT: ; assume predicate info { Comparison: [[AND1]] = and i1 [[A]], [[B]], RenamedOp: [[AND1]] }
|
||||
; CHECK-NEXT: [[TMP4:%.*]] = bitcast i1 [[AND1]] to i1
|
||||
; CHECK-NEXT: ; assume predicate info { Comparison: [[AND2]] = and i1 [[AND1]], [[C]], RenamedOp: [[AND2]] }
|
||||
; CHECK-NEXT: [[TMP5:%.*]] = bitcast i1 [[AND2]] to i1
|
||||
; CHECK-NEXT: call void @foo(i1 [[TMP3]])
|
||||
; CHECK-NEXT: call void @foo(i1 [[TMP2]])
|
||||
; CHECK-NEXT: call void @foo(i1 [[TMP1]])
|
||||
@@ -901,7 +996,8 @@ define void @test_assume_or_chain(i1 %a, i1 %b, i1 %c) {
|
||||
; CHECK-NEXT: [[OR1:%.*]] = or i1 [[A:%.*]], [[B:%.*]]
|
||||
; CHECK-NEXT: [[OR2:%.*]] = or i1 [[OR1]], [[C:%.*]]
|
||||
; CHECK-NEXT: call void @llvm.assume(i1 [[OR2]])
|
||||
; CHECK: [[TMP1:%.*]] = bitcast i1 [[OR2]] to i1
|
||||
; CHECK-NEXT: ; assume predicate info { Comparison: [[OR2]] = or i1 [[OR1]], [[C]], RenamedOp: [[OR2]] }
|
||||
; CHECK-NEXT: [[TMP1:%.*]] = bitcast i1 [[OR2]] to i1
|
||||
; CHECK-NEXT: call void @foo(i1 [[A]])
|
||||
; CHECK-NEXT: call void @foo(i1 [[B]])
|
||||
; CHECK-NEXT: call void @foo(i1 [[C]])
|
||||
@@ -937,14 +1033,22 @@ define void @test_assume_deep_and_tree(i1 %a1) {
|
||||
; CHECK-NEXT: [[A14:%.*]] = and i1 [[A13]], [[A13]]
|
||||
; CHECK-NEXT: [[A15:%.*]] = and i1 [[A14]], [[A14]]
|
||||
; CHECK-NEXT: call void @llvm.assume(i1 [[A15]])
|
||||
; CHECK: [[TMP1:%.*]] = bitcast i1 [[A8]] to i1
|
||||
; CHECK: [[TMP2:%.*]] = bitcast i1 [[A9]] to i1
|
||||
; CHECK: [[TMP3:%.*]] = bitcast i1 [[A10]] to i1
|
||||
; CHECK: [[TMP4:%.*]] = bitcast i1 [[A11]] to i1
|
||||
; CHECK: [[TMP5:%.*]] = bitcast i1 [[A12]] to i1
|
||||
; CHECK: [[TMP6:%.*]] = bitcast i1 [[A13]] to i1
|
||||
; CHECK: [[TMP7:%.*]] = bitcast i1 [[A14]] to i1
|
||||
; CHECK: [[TMP8:%.*]] = bitcast i1 [[A15]] to i1
|
||||
; CHECK-NEXT: ; assume predicate info { Comparison: [[A8]] = and i1 [[A7]], [[A7]], RenamedOp: [[A8]] }
|
||||
; CHECK-NEXT: [[TMP1:%.*]] = bitcast i1 [[A8]] to i1
|
||||
; CHECK-NEXT: ; assume predicate info { Comparison: [[A9]] = and i1 [[A8]], [[A8]], RenamedOp: [[A9]] }
|
||||
; CHECK-NEXT: [[TMP2:%.*]] = bitcast i1 [[A9]] to i1
|
||||
; CHECK-NEXT: ; assume predicate info { Comparison: [[A10]] = and i1 [[A9]], [[A9]], RenamedOp: [[A10]] }
|
||||
; CHECK-NEXT: [[TMP3:%.*]] = bitcast i1 [[A10]] to i1
|
||||
; CHECK-NEXT: ; assume predicate info { Comparison: [[A11]] = and i1 [[A10]], [[A10]], RenamedOp: [[A11]] }
|
||||
; CHECK-NEXT: [[TMP4:%.*]] = bitcast i1 [[A11]] to i1
|
||||
; CHECK-NEXT: ; assume predicate info { Comparison: [[A12]] = and i1 [[A11]], [[A11]], RenamedOp: [[A12]] }
|
||||
; CHECK-NEXT: [[TMP5:%.*]] = bitcast i1 [[A12]] to i1
|
||||
; CHECK-NEXT: ; assume predicate info { Comparison: [[A13]] = and i1 [[A12]], [[A12]], RenamedOp: [[A13]] }
|
||||
; CHECK-NEXT: [[TMP6:%.*]] = bitcast i1 [[A13]] to i1
|
||||
; CHECK-NEXT: ; assume predicate info { Comparison: [[A14]] = and i1 [[A13]], [[A13]], RenamedOp: [[A14]] }
|
||||
; CHECK-NEXT: [[TMP7:%.*]] = bitcast i1 [[A14]] to i1
|
||||
; CHECK-NEXT: ; assume predicate info { Comparison: [[A15]] = and i1 [[A14]], [[A14]], RenamedOp: [[A15]] }
|
||||
; CHECK-NEXT: [[TMP8:%.*]] = bitcast i1 [[A15]] to i1
|
||||
; CHECK-NEXT: call void @foo(i1 [[A1]])
|
||||
; CHECK-NEXT: call void @foo(i1 [[A2]])
|
||||
; CHECK-NEXT: call void @foo(i1 [[A3]])
|
||||
@@ -1001,13 +1105,15 @@ define i32 @test_and_with_phinode(i32 %x) {
|
||||
; CHECK-NEXT: [[XGE1:%.*]] = icmp uge i32 [[X:%.*]], 1
|
||||
; CHECK-NEXT: [[XLT2:%.*]] = icmp ult i32 [[X]], 2
|
||||
; CHECK-NEXT: [[AND:%.*]] = and i1 [[XGE1]], [[XLT2]]
|
||||
; CHECK: [[X_0_1:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK: [[X_0_2:%.*]] = bitcast i32 [[X_0_1]] to i32
|
||||
; CHECK-NEXT: br i1 [[AND]], label [[PHI:%.*]], label [[NOPE:%.*]]
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[XGE1]] = icmp uge i32 [[X]], 1 Edge: [label [[ENTRY:%.*]],label [[PHI:%.*]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_0_1:%.*]] = bitcast i32 [[X]] to i32
|
||||
; CHECK-NEXT: ; branch predicate info { TrueEdge: 1 Comparison: [[XLT2]] = icmp ult i32 [[X]], 2 Edge: [label [[ENTRY]],label [[PHI]]], RenamedOp: [[X]] }
|
||||
; CHECK-NEXT: [[X_0_2:%.*]] = bitcast i32 [[X_0_1]] to i32
|
||||
; CHECK-NEXT: br i1 [[AND]], label [[PHI]], label [[NOPE:%.*]]
|
||||
; CHECK: nope:
|
||||
; CHECK-NEXT: br label [[PHI]]
|
||||
; CHECK: phi:
|
||||
; CHECK-NEXT: [[RES:%.*]] = phi i32 [ [[X_0_2]], [[ENTRY:%.*]] ], [ 1, [[NOPE]] ]
|
||||
; CHECK-NEXT: [[RES:%.*]] = phi i32 [ [[X_0_2]], [[ENTRY]] ], [ 1, [[NOPE]] ]
|
||||
; CHECK-NEXT: ret i32 [[RES]]
|
||||
;
|
||||
entry:
|
||||
|
||||
@@ -607,7 +607,7 @@ MARCH_ARG_RE = re.compile(r"-march[= ]([^ ]+)")
|
||||
DEBUG_ONLY_ARG_RE = re.compile(r"-debug-only[= ]([^ ]+)")
|
||||
|
||||
IS_DEBUG_RECORD_RE = re.compile(r"^(\s+)#dbg_")
|
||||
IS_SWITCH_CASE_RE = re.compile(r"^\s+i\d+ \d+, label %\w+")
|
||||
IS_SWITCH_CASE_RE = re.compile(r"^\s+i\d+ \d+, label %\S+")
|
||||
|
||||
SCRUB_LEADING_WHITESPACE_RE = re.compile(r"^(\s+)")
|
||||
SCRUB_WHITESPACE_RE = re.compile(r"(?!^(| \w))[ \t]+", flags=re.M)
|
||||
@@ -1123,6 +1123,8 @@ class FunctionTestBuilder:
|
||||
##### Generator of LLVM IR CHECK lines
|
||||
|
||||
SCRUB_IR_COMMENT_RE = re.compile(r"\s*;.*")
|
||||
# Comments to indicate the predecessors of a block in the IR.
|
||||
SCRUB_PRED_COMMENT_RE = re.compile(r"\s*; preds = .*")
|
||||
SCRUB_IR_FUNC_META_RE = re.compile(r"((?:\!(?!dbg\b)[a-zA-Z_]\w*(?:\s+![0-9]+)?)\s*)+")
|
||||
|
||||
# TODO: We should also derive check lines for global, debug, loop declarations, etc..
|
||||
@@ -1361,7 +1363,7 @@ def make_ir_generalizer(version, no_meta_details):
|
||||
]
|
||||
|
||||
prefix = r"(\s*)"
|
||||
suffix = r"([,\s\(\)\}]|\Z)"
|
||||
suffix = r"([,\s\(\)\}\]]|\Z)"
|
||||
|
||||
# values = [
|
||||
# nameless_value
|
||||
@@ -1877,6 +1879,7 @@ def generalize_check_lines(
|
||||
*,
|
||||
unstable_globals_only=False,
|
||||
no_meta_details=False,
|
||||
ignore_all_comments=True, # If False, only ignore comments of predecessors
|
||||
):
|
||||
if unstable_globals_only:
|
||||
regexp = ginfo.get_unstable_globals_regexp()
|
||||
@@ -1904,8 +1907,12 @@ def generalize_check_lines(
|
||||
line,
|
||||
)
|
||||
break
|
||||
# Ignore any comments, since the check lines will too.
|
||||
scrubbed_line = SCRUB_IR_COMMENT_RE.sub(r"", line)
|
||||
if ignore_all_comments:
|
||||
# Ignore any comments, since the check lines will too.
|
||||
scrubbed_line = SCRUB_IR_COMMENT_RE.sub(r"", line)
|
||||
else:
|
||||
# Ignore comments of predecessors only.
|
||||
scrubbed_line = SCRUB_PRED_COMMENT_RE.sub(r"", line)
|
||||
# Ignore the metadata details if check global is none
|
||||
if no_meta_details:
|
||||
scrubbed_line = SCRUB_IR_FUNC_META_RE.sub(r"{{.*}}", scrubbed_line)
|
||||
@@ -2083,6 +2090,7 @@ def add_checks(
|
||||
global_tbaa_records_for_prefixes={},
|
||||
preserve_names=False,
|
||||
original_check_lines: Mapping[str, List[str]] = {},
|
||||
check_inst_comments=True,
|
||||
):
|
||||
# prefix_exclusions are prefixes we cannot use to print the function because it doesn't exist in run lines that use these prefixes as well.
|
||||
prefix_exclusions = set()
|
||||
@@ -2280,6 +2288,8 @@ def add_checks(
|
||||
global_tbaa_records,
|
||||
preserve_names,
|
||||
original_check_lines=original_check_lines.get(checkprefix),
|
||||
# IR output might require comments checks, e.g., print-predicate-info, print<memssa>
|
||||
ignore_all_comments=not check_inst_comments,
|
||||
)
|
||||
|
||||
# This could be selectively enabled with an optional invocation argument.
|
||||
@@ -2299,8 +2309,9 @@ def add_checks(
|
||||
if func_line.strip() == "":
|
||||
is_blank_line = True
|
||||
continue
|
||||
# Do not waste time checking IR comments.
|
||||
func_line = SCRUB_IR_COMMENT_RE.sub(r"", func_line)
|
||||
if not check_inst_comments:
|
||||
# Do not waste time checking IR comments unless necessary.
|
||||
func_line = SCRUB_IR_COMMENT_RE.sub(r"", func_line)
|
||||
|
||||
# Skip blank lines instead of checking them.
|
||||
if is_blank_line:
|
||||
@@ -2342,6 +2353,7 @@ def add_ir_checks(
|
||||
global_vars_seen_dict,
|
||||
global_tbaa_records_for_prefixes,
|
||||
is_filtered,
|
||||
check_inst_comments=False,
|
||||
original_check_lines={},
|
||||
):
|
||||
assert ginfo.is_ir()
|
||||
@@ -2368,6 +2380,7 @@ def add_ir_checks(
|
||||
global_tbaa_records_for_prefixes,
|
||||
preserve_names,
|
||||
original_check_lines=original_check_lines,
|
||||
check_inst_comments=check_inst_comments,
|
||||
)
|
||||
|
||||
|
||||
|
||||
@@ -197,6 +197,7 @@ def update_test(ti: common.TestInfo):
|
||||
global_tbaa_records_for_prefixes,
|
||||
is_filtered=builder.is_filtered(),
|
||||
original_check_lines=original_check_lines.get(func, {}),
|
||||
check_inst_comments=args.check_inst_comments,
|
||||
),
|
||||
)
|
||||
)
|
||||
@@ -230,6 +231,7 @@ def update_test(ti: common.TestInfo):
|
||||
global_tbaa_records_for_prefixes,
|
||||
is_filtered=builder.is_filtered(),
|
||||
original_check_lines=original_check_lines.get(func_name, {}),
|
||||
check_inst_comments=args.check_inst_comments,
|
||||
)
|
||||
)
|
||||
is_in_function_start = False
|
||||
@@ -362,6 +364,12 @@ def main():
|
||||
choices=["none", "smart", "all"],
|
||||
help="Check global entries (global variables, metadata, attribute sets, ...) for functions",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--check-inst-comments",
|
||||
action="store_true",
|
||||
default=False,
|
||||
help="Check the generated comments describing instructions (e.g., -print-predicate-info/print<memssa>)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--reset-variable-names",
|
||||
action="store_true",
|
||||
|
||||
Reference in New Issue
Block a user