[llvm] 48ef55c - [CGP] Update tests to use autogen scripts, and refresh check lines
Philip Reames via llvm-commits
llvm-commits at lists.llvm.org
Thu Jul 3 11:37:03 PDT 2025
Author: Philip Reames
Date: 2025-07-03T11:36:33-07:00
New Revision: 48ef55ce3e85a637c840189fe553d239f9f1f8f0
URL: https://github.com/llvm/llvm-project/commit/48ef55ce3e85a637c840189fe553d239f9f1f8f0
DIFF: https://github.com/llvm/llvm-project/commit/48ef55ce3e85a637c840189fe553d239f9f1f8f0.diff
LOG: [CGP] Update tests to use autogen scripts, and refresh check lines
Reducing manual update work required for an upcoming change.
Added:
Modified:
llvm/test/CodeGen/AArch64/memcpy-scoped-aa.ll
llvm/test/CodeGen/AMDGPU/partial-regcopy-and-spill-missed-at-regalloc.ll
llvm/test/Transforms/CodeGenPrepare/X86/sink-addrmode-base.ll
llvm/test/Transforms/CodeGenPrepare/X86/sink-addrmode-two-phi.ll
Removed:
################################################################################
diff --git a/llvm/test/CodeGen/AArch64/memcpy-scoped-aa.ll b/llvm/test/CodeGen/AArch64/memcpy-scoped-aa.ll
index 2271190963d16..7dde168024278 100644
--- a/llvm/test/CodeGen/AArch64/memcpy-scoped-aa.ll
+++ b/llvm/test/CodeGen/AArch64/memcpy-scoped-aa.ll
@@ -134,3 +134,5 @@ declare ptr @mempcpy(ptr, ptr, i64)
!2 = !{!1}
!3 = distinct !{!3, !0, !"bax: %q"}
!4 = !{!3}
+;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+; MIR: {{.*}}
diff --git a/llvm/test/CodeGen/AMDGPU/partial-regcopy-and-spill-missed-at-regalloc.ll b/llvm/test/CodeGen/AMDGPU/partial-regcopy-and-spill-missed-at-regalloc.ll
index 24677b60be6c2..663fd98b46bf7 100644
--- a/llvm/test/CodeGen/AMDGPU/partial-regcopy-and-spill-missed-at-regalloc.ll
+++ b/llvm/test/CodeGen/AMDGPU/partial-regcopy-and-spill-missed-at-regalloc.ll
@@ -6,6 +6,7 @@
; Partial reg copy and spill missed during regalloc handled later at frame lowering.
define amdgpu_kernel void @partial_copy(<4 x i32> %arg) #0 {
+
; REGALLOC-GFX908-LABEL: name: partial_copy
; REGALLOC-GFX908: bb.0 (%ir-block.0):
; REGALLOC-GFX908-NEXT: liveins: $sgpr4_sgpr5
@@ -13,7 +14,6 @@ define amdgpu_kernel void @partial_copy(<4 x i32> %arg) #0 {
; REGALLOC-GFX908-NEXT: INLINEASM &"; use $0", 1 /* sideeffect attdialect */, 2162697 /* reguse:AGPR_32 */, undef %6:agpr_32
; REGALLOC-GFX908-NEXT: INLINEASM &"; def $0", 1 /* sideeffect attdialect */, 6094858 /* regdef:VReg_128 */, def %7
; REGALLOC-GFX908-NEXT: INLINEASM &"; def $0", 1 /* sideeffect attdialect */, 3538954 /* regdef:VReg_64 */, def %8
-
; REGALLOC-GFX908-NEXT: GLOBAL_STORE_DWORDX4 undef %15:vreg_64, %7, 0, 0, implicit $exec :: (volatile store (s128) into `ptr addrspace(1) poison`, addrspace 1)
; REGALLOC-GFX908-NEXT: renamable $sgpr0_sgpr1_sgpr2_sgpr3 = S_LOAD_DWORDX4_IMM killed renamable $sgpr4_sgpr5, 0, 0 :: (dereferenceable invariant load (s128) from %ir.arg.kernarg.offset1, addrspace 4)
; REGALLOC-GFX908-NEXT: [[COPY:%[0-9]+]]:areg_128 = COPY killed renamable $sgpr0_sgpr1_sgpr2_sgpr3
@@ -21,8 +21,8 @@ define amdgpu_kernel void @partial_copy(<4 x i32> %arg) #0 {
; REGALLOC-GFX908-NEXT: [[V_MOV_B32_e32_1:%[0-9]+]]:vgpr_32 = V_MOV_B32_e32 2, implicit $exec
; REGALLOC-GFX908-NEXT: [[V_MFMA_I32_4X4X4I8_e64_:%[0-9]+]]:areg_128 = V_MFMA_I32_4X4X4I8_e64 [[V_MOV_B32_e32_]], [[V_MOV_B32_e32_1]], [[COPY]], 0, 0, 0, implicit $mode, implicit $exec
; REGALLOC-GFX908-NEXT: GLOBAL_STORE_DWORDX2 undef %17:vreg_64, %8, 0, 0, implicit $exec :: (volatile store (s64) into `ptr addrspace(1) poison`, addrspace 1)
- ; REGALLOC-GFX908-NEXT: [[COPY3:%[0-9]+]]:vreg_128 = COPY [[V_MFMA_I32_4X4X4I8_e64_]]
- ; REGALLOC-GFX908-NEXT: GLOBAL_STORE_DWORDX4 undef %19:vreg_64, [[COPY3]], 0, 0, implicit $exec :: (volatile store (s128) into `ptr addrspace(1) poison`, addrspace 1)
+ ; REGALLOC-GFX908-NEXT: [[COPY1:%[0-9]+]]:vreg_128 = COPY [[V_MFMA_I32_4X4X4I8_e64_]]
+ ; REGALLOC-GFX908-NEXT: GLOBAL_STORE_DWORDX4 undef %19:vreg_64, [[COPY1]], 0, 0, implicit $exec :: (volatile store (s128) into `ptr addrspace(1) poison`, addrspace 1)
; REGALLOC-GFX908-NEXT: S_ENDPGM 0
;
; PEI-GFX908-LABEL: name: partial_copy
diff --git a/llvm/test/Transforms/CodeGenPrepare/X86/sink-addrmode-base.ll b/llvm/test/Transforms/CodeGenPrepare/X86/sink-addrmode-base.ll
index 61107a9b70163..63fd1845594c6 100644
--- a/llvm/test/Transforms/CodeGenPrepare/X86/sink-addrmode-base.ll
+++ b/llvm/test/Transforms/CodeGenPrepare/X86/sink-addrmode-base.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
; RUN: opt -S -passes='require<profile-summary>,function(codegenprepare)' -disable-complex-addr-modes=false -addr-sink-new-phis=true -addr-sink-new-select=true -disable-cgp-delete-phis %s | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-YES
; RUN: opt -S -passes='require<profile-summary>,function(codegenprepare)' -disable-complex-addr-modes=false -addr-sink-new-phis=false -addr-sink-new-select=true -disable-cgp-delete-phis %s | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NO
target datalayout =
@@ -6,7 +7,31 @@ target triple = "x86_64-unknown-linux-gnu"
; Can we sink for
diff erent base if there is no phi for base?
define i32 @test1(i1 %cond, ptr %b1, ptr %b2) {
-; CHECK-LABEL: @test1
+; CHECK-YES-LABEL: define i32 @test1(
+; CHECK-YES-SAME: i1 [[COND:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]]) {
+; CHECK-YES-NEXT: [[ENTRY:.*]]:
+; CHECK-YES-NEXT: br i1 [[COND]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH:.*]]
+; CHECK-YES: [[IF_THEN]]:
+; CHECK-YES-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-YES: [[FALLTHROUGH]]:
+; CHECK-YES-NEXT: [[SUNK_PHI:%.*]] = phi ptr [ [[B2]], %[[IF_THEN]] ], [ [[B1]], %[[ENTRY]] ]
+; CHECK-YES-NEXT: [[SUNKADDR:%.*]] = getelementptr inbounds i8, ptr [[SUNK_PHI]], i64 40
+; CHECK-YES-NEXT: [[V:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-YES-NEXT: ret i32 [[V]]
+;
+; CHECK-NO-LABEL: define i32 @test1(
+; CHECK-NO-SAME: i1 [[COND:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]]) {
+; CHECK-NO-NEXT: [[ENTRY:.*]]:
+; CHECK-NO-NEXT: [[A1:%.*]] = getelementptr inbounds i64, ptr [[B1]], i64 5
+; CHECK-NO-NEXT: br i1 [[COND]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH:.*]]
+; CHECK-NO: [[IF_THEN]]:
+; CHECK-NO-NEXT: [[A2:%.*]] = getelementptr inbounds i64, ptr [[B2]], i64 5
+; CHECK-NO-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-NO: [[FALLTHROUGH]]:
+; CHECK-NO-NEXT: [[C:%.*]] = phi ptr [ [[A1]], %[[ENTRY]] ], [ [[A2]], %[[IF_THEN]] ]
+; CHECK-NO-NEXT: [[V:%.*]] = load i32, ptr [[C]], align 4
+; CHECK-NO-NEXT: ret i32 [[V]]
+;
entry:
%a1 = getelementptr inbounds i64, ptr %b1, i64 5
br i1 %cond, label %if.then, label %fallthrough
@@ -16,10 +41,6 @@ if.then:
br label %fallthrough
fallthrough:
-; CHECK-YES: sunk_phi
-; CHECK-NO-LABEL: fallthrough:
-; CHECK-NO: phi
-; CHECK-NO-NEXT: load
%c = phi ptr [%a1, %entry], [%a2, %if.then]
%v = load i32, ptr %c, align 4
ret i32 %v
@@ -27,7 +48,18 @@ fallthrough:
; Can we sink for
diff erent base if there is phi for base?
define i32 @test2(i1 %cond, ptr %b1, ptr %b2) {
-; CHECK-LABEL: @test2
+; CHECK-LABEL: define i32 @test2(
+; CHECK-SAME: i1 [[COND:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]]) {
+; CHECK-NEXT: [[ENTRY:.*]]:
+; CHECK-NEXT: br i1 [[COND]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH:.*]]
+; CHECK: [[IF_THEN]]:
+; CHECK-NEXT: br label %[[FALLTHROUGH]]
+; CHECK: [[FALLTHROUGH]]:
+; CHECK-NEXT: [[B:%.*]] = phi ptr [ [[B1]], %[[ENTRY]] ], [ [[B2]], %[[IF_THEN]] ]
+; CHECK-NEXT: [[SUNKADDR:%.*]] = getelementptr inbounds i8, ptr [[B]], i64 40
+; CHECK-NEXT: [[V:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-NEXT: ret i32 [[V]]
+;
entry:
%a1 = getelementptr inbounds i64, ptr %b1, i64 5
br i1 %cond, label %if.then, label %fallthrough
@@ -37,7 +69,6 @@ if.then:
br label %fallthrough
fallthrough:
-; CHECK: getelementptr inbounds i8, {{.+}} 40
%b = phi ptr [%b1, %entry], [%b2, %if.then]
%c = phi ptr [%a1, %entry], [%a2, %if.then]
%v = load i32, ptr %c, align 4
@@ -46,7 +77,33 @@ fallthrough:
; Can we sink for
diff erent base if there is phi for base but not valid one?
define i32 @test3(i1 %cond, ptr %b1, ptr %b2) {
-; CHECK-LABEL: @test3
+; CHECK-YES-LABEL: define i32 @test3(
+; CHECK-YES-SAME: i1 [[COND:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]]) {
+; CHECK-YES-NEXT: [[ENTRY:.*]]:
+; CHECK-YES-NEXT: br i1 [[COND]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH:.*]]
+; CHECK-YES: [[IF_THEN]]:
+; CHECK-YES-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-YES: [[FALLTHROUGH]]:
+; CHECK-YES-NEXT: [[B:%.*]] = phi ptr [ [[B2]], %[[ENTRY]] ], [ [[B1]], %[[IF_THEN]] ]
+; CHECK-YES-NEXT: [[SUNK_PHI:%.*]] = phi ptr [ [[B2]], %[[IF_THEN]] ], [ [[B1]], %[[ENTRY]] ]
+; CHECK-YES-NEXT: [[SUNKADDR:%.*]] = getelementptr inbounds i8, ptr [[SUNK_PHI]], i64 40
+; CHECK-YES-NEXT: [[V:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-YES-NEXT: ret i32 [[V]]
+;
+; CHECK-NO-LABEL: define i32 @test3(
+; CHECK-NO-SAME: i1 [[COND:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]]) {
+; CHECK-NO-NEXT: [[ENTRY:.*]]:
+; CHECK-NO-NEXT: [[A1:%.*]] = getelementptr inbounds i64, ptr [[B1]], i64 5
+; CHECK-NO-NEXT: br i1 [[COND]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH:.*]]
+; CHECK-NO: [[IF_THEN]]:
+; CHECK-NO-NEXT: [[A2:%.*]] = getelementptr inbounds i64, ptr [[B2]], i64 5
+; CHECK-NO-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-NO: [[FALLTHROUGH]]:
+; CHECK-NO-NEXT: [[B:%.*]] = phi ptr [ [[B2]], %[[ENTRY]] ], [ [[B1]], %[[IF_THEN]] ]
+; CHECK-NO-NEXT: [[C:%.*]] = phi ptr [ [[A1]], %[[ENTRY]] ], [ [[A2]], %[[IF_THEN]] ]
+; CHECK-NO-NEXT: [[V:%.*]] = load i32, ptr [[C]], align 4
+; CHECK-NO-NEXT: ret i32 [[V]]
+;
entry:
%a1 = getelementptr inbounds i64, ptr %b1, i64 5
br i1 %cond, label %if.then, label %fallthrough
@@ -56,11 +113,6 @@ if.then:
br label %fallthrough
fallthrough:
-; CHECK-YES: sunk_phi
-; CHECK-NO-LABEL: fallthrough:
-; CHECK-NO: phi
-; CHECK-NO: phi
-; CHECK-NO-NEXT: load
%b = phi ptr [%b2, %entry], [%b1, %if.then]
%c = phi ptr [%a1, %entry], [%a2, %if.then]
%v = load i32, ptr %c, align 4
@@ -69,7 +121,31 @@ fallthrough:
; Can we sink for
diff erent base if both addresses are in the same block?
define i32 @test4(i1 %cond, ptr %b1, ptr %b2) {
-; CHECK-LABEL: @test4
+; CHECK-YES-LABEL: define i32 @test4(
+; CHECK-YES-SAME: i1 [[COND:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]]) {
+; CHECK-YES-NEXT: [[ENTRY:.*]]:
+; CHECK-YES-NEXT: br i1 [[COND]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH:.*]]
+; CHECK-YES: [[IF_THEN]]:
+; CHECK-YES-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-YES: [[FALLTHROUGH]]:
+; CHECK-YES-NEXT: [[SUNK_PHI:%.*]] = phi ptr [ [[B2]], %[[IF_THEN]] ], [ [[B1]], %[[ENTRY]] ]
+; CHECK-YES-NEXT: [[SUNKADDR:%.*]] = getelementptr inbounds i8, ptr [[SUNK_PHI]], i64 40
+; CHECK-YES-NEXT: [[V:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-YES-NEXT: ret i32 [[V]]
+;
+; CHECK-NO-LABEL: define i32 @test4(
+; CHECK-NO-SAME: i1 [[COND:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]]) {
+; CHECK-NO-NEXT: [[ENTRY:.*]]:
+; CHECK-NO-NEXT: [[A1:%.*]] = getelementptr inbounds i64, ptr [[B1]], i64 5
+; CHECK-NO-NEXT: [[A2:%.*]] = getelementptr inbounds i64, ptr [[B2]], i64 5
+; CHECK-NO-NEXT: br i1 [[COND]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH:.*]]
+; CHECK-NO: [[IF_THEN]]:
+; CHECK-NO-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-NO: [[FALLTHROUGH]]:
+; CHECK-NO-NEXT: [[C:%.*]] = phi ptr [ [[A1]], %[[ENTRY]] ], [ [[A2]], %[[IF_THEN]] ]
+; CHECK-NO-NEXT: [[V:%.*]] = load i32, ptr [[C]], align 4
+; CHECK-NO-NEXT: ret i32 [[V]]
+;
entry:
%a1 = getelementptr inbounds i64, ptr %b1, i64 5
%a2 = getelementptr inbounds i64, ptr %b2, i64 5
@@ -79,10 +155,6 @@ if.then:
br label %fallthrough
fallthrough:
-; CHECK-YES: sunk_phi
-; CHECK-NO-LABEL: fallthrough:
-; CHECK-NO: phi
-; CHECK-NO-NEXT: load
%c = phi ptr [%a1, %entry], [%a2, %if.then]
%v = load i32, ptr %c, align 4
ret i32 %v
@@ -91,7 +163,18 @@ fallthrough:
; Can we sink for
diff erent base if there is phi for base?
; Both addresses are in the same block.
define i32 @test5(i1 %cond, ptr %b1, ptr %b2) {
-; CHECK-LABEL: @test5
+; CHECK-LABEL: define i32 @test5(
+; CHECK-SAME: i1 [[COND:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]]) {
+; CHECK-NEXT: [[ENTRY:.*]]:
+; CHECK-NEXT: br i1 [[COND]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH:.*]]
+; CHECK: [[IF_THEN]]:
+; CHECK-NEXT: br label %[[FALLTHROUGH]]
+; CHECK: [[FALLTHROUGH]]:
+; CHECK-NEXT: [[B:%.*]] = phi ptr [ [[B1]], %[[ENTRY]] ], [ [[B2]], %[[IF_THEN]] ]
+; CHECK-NEXT: [[SUNKADDR:%.*]] = getelementptr inbounds i8, ptr [[B]], i64 40
+; CHECK-NEXT: [[V:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-NEXT: ret i32 [[V]]
+;
entry:
%a1 = getelementptr inbounds i64, ptr %b1, i64 5
%a2 = getelementptr inbounds i64, ptr %b2, i64 5
@@ -101,7 +184,6 @@ if.then:
br label %fallthrough
fallthrough:
-; CHECK: getelementptr inbounds i8, {{.+}} 40
%b = phi ptr [%b1, %entry], [%b2, %if.then]
%c = phi ptr [%a1, %entry], [%a2, %if.then]
%v = load i32, ptr %c, align 4
@@ -111,7 +193,33 @@ fallthrough:
; Can we sink for
diff erent base if there is phi for base but not valid one?
; Both addresses are in the same block.
define i32 @test6(i1 %cond, ptr %b1, ptr %b2) {
-; CHECK-LABEL: @test6
+; CHECK-YES-LABEL: define i32 @test6(
+; CHECK-YES-SAME: i1 [[COND:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]]) {
+; CHECK-YES-NEXT: [[ENTRY:.*]]:
+; CHECK-YES-NEXT: br i1 [[COND]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH:.*]]
+; CHECK-YES: [[IF_THEN]]:
+; CHECK-YES-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-YES: [[FALLTHROUGH]]:
+; CHECK-YES-NEXT: [[B:%.*]] = phi ptr [ [[B2]], %[[ENTRY]] ], [ [[B1]], %[[IF_THEN]] ]
+; CHECK-YES-NEXT: [[SUNK_PHI:%.*]] = phi ptr [ [[B2]], %[[IF_THEN]] ], [ [[B1]], %[[ENTRY]] ]
+; CHECK-YES-NEXT: [[SUNKADDR:%.*]] = getelementptr inbounds i8, ptr [[SUNK_PHI]], i64 40
+; CHECK-YES-NEXT: [[V:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-YES-NEXT: ret i32 [[V]]
+;
+; CHECK-NO-LABEL: define i32 @test6(
+; CHECK-NO-SAME: i1 [[COND:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]]) {
+; CHECK-NO-NEXT: [[ENTRY:.*]]:
+; CHECK-NO-NEXT: [[A1:%.*]] = getelementptr inbounds i64, ptr [[B1]], i64 5
+; CHECK-NO-NEXT: [[A2:%.*]] = getelementptr inbounds i64, ptr [[B2]], i64 5
+; CHECK-NO-NEXT: br i1 [[COND]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH:.*]]
+; CHECK-NO: [[IF_THEN]]:
+; CHECK-NO-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-NO: [[FALLTHROUGH]]:
+; CHECK-NO-NEXT: [[B:%.*]] = phi ptr [ [[B2]], %[[ENTRY]] ], [ [[B1]], %[[IF_THEN]] ]
+; CHECK-NO-NEXT: [[C:%.*]] = phi ptr [ [[A1]], %[[ENTRY]] ], [ [[A2]], %[[IF_THEN]] ]
+; CHECK-NO-NEXT: [[V:%.*]] = load i32, ptr [[C]], align 4
+; CHECK-NO-NEXT: ret i32 [[V]]
+;
entry:
%a1 = getelementptr inbounds i64, ptr %b1, i64 5
%a2 = getelementptr inbounds i64, ptr %b2, i64 5
@@ -121,11 +229,6 @@ if.then:
br label %fallthrough
fallthrough:
-; CHECK-YES: sunk_phi
-; CHECK-NO-LABEL: fallthrough:
-; CHECK-NO: phi
-; CHECK-NO-NEXT: phi
-; CHECK-NO-NEXT: load
%b = phi ptr [%b2, %entry], [%b1, %if.then]
%c = phi ptr [%a1, %entry], [%a2, %if.then]
%v = load i32, ptr %c, align 4
@@ -134,14 +237,56 @@ fallthrough:
; case with a loop. No phi node.
define i32 @test7(i32 %N, i1 %cond, ptr %b1, ptr %b2) {
-; CHECK-LABEL: @test7
+; CHECK-YES-LABEL: define i32 @test7(
+; CHECK-YES-SAME: i32 [[N:%.*]], i1 [[COND:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]]) {
+; CHECK-YES-NEXT: [[ENTRY:.*]]:
+; CHECK-YES-NEXT: [[A1:%.*]] = getelementptr inbounds i64, ptr [[B1]], i64 5
+; CHECK-YES-NEXT: br label %[[LOOP:.*]]
+; CHECK-YES: [[LOOP]]:
+; CHECK-YES-NEXT: [[IV:%.*]] = phi i32 [ 0, %[[ENTRY]] ], [ [[IV_INC:%.*]], %[[FALLTHROUGH:.*]] ]
+; CHECK-YES-NEXT: [[SUNK_PHI1:%.*]] = phi ptr [ [[SUNK_PHI:%.*]], %[[FALLTHROUGH]] ], [ [[B1]], %[[ENTRY]] ]
+; CHECK-YES-NEXT: [[C3:%.*]] = phi ptr [ [[A1]], %[[ENTRY]] ], [ [[C:%.*]], %[[FALLTHROUGH]] ]
+; CHECK-YES-NEXT: br i1 [[COND]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH]]
+; CHECK-YES: [[IF_THEN]]:
+; CHECK-YES-NEXT: [[A2:%.*]] = getelementptr inbounds i64, ptr [[B2]], i64 5
+; CHECK-YES-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-YES: [[FALLTHROUGH]]:
+; CHECK-YES-NEXT: [[SUNK_PHI]] = phi ptr [ [[B2]], %[[IF_THEN]] ], [ [[SUNK_PHI1]], %[[LOOP]] ]
+; CHECK-YES-NEXT: [[C]] = phi ptr [ [[C3]], %[[LOOP]] ], [ [[A2]], %[[IF_THEN]] ]
+; CHECK-YES-NEXT: [[SUNKADDR:%.*]] = getelementptr inbounds i8, ptr [[SUNK_PHI]], i64 40
+; CHECK-YES-NEXT: [[V:%.*]] = load volatile i32, ptr [[SUNKADDR]], align 4
+; CHECK-YES-NEXT: [[IV_INC]] = add i32 [[IV]], 1
+; CHECK-YES-NEXT: [[CMP:%.*]] = icmp slt i32 [[IV_INC]], [[N]]
+; CHECK-YES-NEXT: br i1 [[CMP]], label %[[LOOP]], label %[[EXIT:.*]]
+; CHECK-YES: [[EXIT]]:
+; CHECK-YES-NEXT: ret i32 [[V]]
+;
+; CHECK-NO-LABEL: define i32 @test7(
+; CHECK-NO-SAME: i32 [[N:%.*]], i1 [[COND:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]]) {
+; CHECK-NO-NEXT: [[ENTRY:.*]]:
+; CHECK-NO-NEXT: [[A1:%.*]] = getelementptr inbounds i64, ptr [[B1]], i64 5
+; CHECK-NO-NEXT: br label %[[LOOP:.*]]
+; CHECK-NO: [[LOOP]]:
+; CHECK-NO-NEXT: [[IV:%.*]] = phi i32 [ 0, %[[ENTRY]] ], [ [[IV_INC:%.*]], %[[FALLTHROUGH:.*]] ]
+; CHECK-NO-NEXT: [[C3:%.*]] = phi ptr [ [[A1]], %[[ENTRY]] ], [ [[C:%.*]], %[[FALLTHROUGH]] ]
+; CHECK-NO-NEXT: br i1 [[COND]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH]]
+; CHECK-NO: [[IF_THEN]]:
+; CHECK-NO-NEXT: [[A2:%.*]] = getelementptr inbounds i64, ptr [[B2]], i64 5
+; CHECK-NO-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-NO: [[FALLTHROUGH]]:
+; CHECK-NO-NEXT: [[C]] = phi ptr [ [[C3]], %[[LOOP]] ], [ [[A2]], %[[IF_THEN]] ]
+; CHECK-NO-NEXT: [[V:%.*]] = load volatile i32, ptr [[C]], align 4
+; CHECK-NO-NEXT: [[IV_INC]] = add i32 [[IV]], 1
+; CHECK-NO-NEXT: [[CMP:%.*]] = icmp slt i32 [[IV_INC]], [[N]]
+; CHECK-NO-NEXT: br i1 [[CMP]], label %[[LOOP]], label %[[EXIT:.*]]
+; CHECK-NO: [[EXIT]]:
+; CHECK-NO-NEXT: ret i32 [[V]]
+;
entry:
%a1 = getelementptr inbounds i64, ptr %b1, i64 5
br label %loop
loop:
-; CHECK-LABEL: loop:
-; CHECK-YES: sunk_phi
%iv = phi i32 [0, %entry], [%iv.inc, %fallthrough]
%c3 = phi ptr [%a1, %entry], [%c, %fallthrough]
br i1 %cond, label %if.then, label %fallthrough
@@ -151,10 +296,6 @@ if.then:
br label %fallthrough
fallthrough:
-; CHECK-YES: sunk_phi
-; CHECK-NO-LABEL: fallthrough:
-; CHECK-NO: phi
-; CHECK-NO-NEXT: load
%c = phi ptr [%c3, %loop], [%a2, %if.then]
%v = load volatile i32, ptr %c, align 4
%iv.inc = add i32 %iv, 1
@@ -167,7 +308,30 @@ exit:
; case with a loop. There is phi node.
define i32 @test8(i32 %N, i1 %cond, ptr %b1, ptr %b2) {
-; CHECK-LABEL: @test8
+; CHECK-LABEL: define i32 @test8(
+; CHECK-SAME: i32 [[N:%.*]], i1 [[COND:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]]) {
+; CHECK-NEXT: [[ENTRY:.*]]:
+; CHECK-NEXT: [[A1:%.*]] = getelementptr inbounds i64, ptr [[B1]], i64 5
+; CHECK-NEXT: br label %[[LOOP:.*]]
+; CHECK: [[LOOP]]:
+; CHECK-NEXT: [[IV:%.*]] = phi i32 [ 0, %[[ENTRY]] ], [ [[IV_INC:%.*]], %[[FALLTHROUGH:.*]] ]
+; CHECK-NEXT: [[C3:%.*]] = phi ptr [ [[A1]], %[[ENTRY]] ], [ [[C:%.*]], %[[FALLTHROUGH]] ]
+; CHECK-NEXT: [[B3:%.*]] = phi ptr [ [[B1]], %[[ENTRY]] ], [ [[B:%.*]], %[[FALLTHROUGH]] ]
+; CHECK-NEXT: br i1 [[COND]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH]]
+; CHECK: [[IF_THEN]]:
+; CHECK-NEXT: [[A2:%.*]] = getelementptr inbounds i64, ptr [[B2]], i64 5
+; CHECK-NEXT: br label %[[FALLTHROUGH]]
+; CHECK: [[FALLTHROUGH]]:
+; CHECK-NEXT: [[C]] = phi ptr [ [[C3]], %[[LOOP]] ], [ [[A2]], %[[IF_THEN]] ]
+; CHECK-NEXT: [[B]] = phi ptr [ [[B3]], %[[LOOP]] ], [ [[B2]], %[[IF_THEN]] ]
+; CHECK-NEXT: [[SUNKADDR:%.*]] = getelementptr inbounds i8, ptr [[B]], i64 40
+; CHECK-NEXT: [[V:%.*]] = load volatile i32, ptr [[SUNKADDR]], align 4
+; CHECK-NEXT: [[IV_INC]] = add i32 [[IV]], 1
+; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 [[IV_INC]], [[N]]
+; CHECK-NEXT: br i1 [[CMP]], label %[[LOOP]], label %[[EXIT:.*]]
+; CHECK: [[EXIT]]:
+; CHECK-NEXT: ret i32 [[V]]
+;
entry:
%a1 = getelementptr inbounds i64, ptr %b1, i64 5
br label %loop
@@ -183,7 +347,6 @@ if.then:
br label %fallthrough
fallthrough:
-; CHECK: getelementptr inbounds i8, {{.+}} 40
%c = phi ptr [%c3, %loop], [%a2, %if.then]
%b = phi ptr [%b3, %loop], [%b2, %if.then]
%v = load volatile i32, ptr %c, align 4
@@ -197,14 +360,60 @@ exit:
; case with a loop. There is phi node but it does not fit.
define i32 @test9(i32 %N, i1 %cond, ptr %b1, ptr %b2) {
-; CHECK-LABEL: @test9
+; CHECK-YES-LABEL: define i32 @test9(
+; CHECK-YES-SAME: i32 [[N:%.*]], i1 [[COND:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]]) {
+; CHECK-YES-NEXT: [[ENTRY:.*]]:
+; CHECK-YES-NEXT: [[A1:%.*]] = getelementptr inbounds i64, ptr [[B1]], i64 5
+; CHECK-YES-NEXT: br label %[[LOOP:.*]]
+; CHECK-YES: [[LOOP]]:
+; CHECK-YES-NEXT: [[IV:%.*]] = phi i32 [ 0, %[[ENTRY]] ], [ [[IV_INC:%.*]], %[[FALLTHROUGH:.*]] ]
+; CHECK-YES-NEXT: [[SUNK_PHI1:%.*]] = phi ptr [ [[SUNK_PHI:%.*]], %[[FALLTHROUGH]] ], [ [[B1]], %[[ENTRY]] ]
+; CHECK-YES-NEXT: [[C3:%.*]] = phi ptr [ [[A1]], %[[ENTRY]] ], [ [[C:%.*]], %[[FALLTHROUGH]] ]
+; CHECK-YES-NEXT: [[B3:%.*]] = phi ptr [ [[B1]], %[[ENTRY]] ], [ [[B2]], %[[FALLTHROUGH]] ]
+; CHECK-YES-NEXT: br i1 [[COND]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH]]
+; CHECK-YES: [[IF_THEN]]:
+; CHECK-YES-NEXT: [[A2:%.*]] = getelementptr inbounds i64, ptr [[B2]], i64 5
+; CHECK-YES-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-YES: [[FALLTHROUGH]]:
+; CHECK-YES-NEXT: [[SUNK_PHI]] = phi ptr [ [[B2]], %[[IF_THEN]] ], [ [[SUNK_PHI1]], %[[LOOP]] ]
+; CHECK-YES-NEXT: [[C]] = phi ptr [ [[C3]], %[[LOOP]] ], [ [[A2]], %[[IF_THEN]] ]
+; CHECK-YES-NEXT: [[B:%.*]] = phi ptr [ [[B3]], %[[LOOP]] ], [ [[B2]], %[[IF_THEN]] ]
+; CHECK-YES-NEXT: [[SUNKADDR:%.*]] = getelementptr inbounds i8, ptr [[SUNK_PHI]], i64 40
+; CHECK-YES-NEXT: [[V:%.*]] = load volatile i32, ptr [[SUNKADDR]], align 4
+; CHECK-YES-NEXT: [[IV_INC]] = add i32 [[IV]], 1
+; CHECK-YES-NEXT: [[CMP:%.*]] = icmp slt i32 [[IV_INC]], [[N]]
+; CHECK-YES-NEXT: br i1 [[CMP]], label %[[LOOP]], label %[[EXIT:.*]]
+; CHECK-YES: [[EXIT]]:
+; CHECK-YES-NEXT: ret i32 [[V]]
+;
+; CHECK-NO-LABEL: define i32 @test9(
+; CHECK-NO-SAME: i32 [[N:%.*]], i1 [[COND:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]]) {
+; CHECK-NO-NEXT: [[ENTRY:.*]]:
+; CHECK-NO-NEXT: [[A1:%.*]] = getelementptr inbounds i64, ptr [[B1]], i64 5
+; CHECK-NO-NEXT: br label %[[LOOP:.*]]
+; CHECK-NO: [[LOOP]]:
+; CHECK-NO-NEXT: [[IV:%.*]] = phi i32 [ 0, %[[ENTRY]] ], [ [[IV_INC:%.*]], %[[FALLTHROUGH:.*]] ]
+; CHECK-NO-NEXT: [[C3:%.*]] = phi ptr [ [[A1]], %[[ENTRY]] ], [ [[C:%.*]], %[[FALLTHROUGH]] ]
+; CHECK-NO-NEXT: [[B3:%.*]] = phi ptr [ [[B1]], %[[ENTRY]] ], [ [[B2]], %[[FALLTHROUGH]] ]
+; CHECK-NO-NEXT: br i1 [[COND]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH]]
+; CHECK-NO: [[IF_THEN]]:
+; CHECK-NO-NEXT: [[A2:%.*]] = getelementptr inbounds i64, ptr [[B2]], i64 5
+; CHECK-NO-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-NO: [[FALLTHROUGH]]:
+; CHECK-NO-NEXT: [[C]] = phi ptr [ [[C3]], %[[LOOP]] ], [ [[A2]], %[[IF_THEN]] ]
+; CHECK-NO-NEXT: [[B:%.*]] = phi ptr [ [[B3]], %[[LOOP]] ], [ [[B2]], %[[IF_THEN]] ]
+; CHECK-NO-NEXT: [[V:%.*]] = load volatile i32, ptr [[C]], align 4
+; CHECK-NO-NEXT: [[IV_INC]] = add i32 [[IV]], 1
+; CHECK-NO-NEXT: [[CMP:%.*]] = icmp slt i32 [[IV_INC]], [[N]]
+; CHECK-NO-NEXT: br i1 [[CMP]], label %[[LOOP]], label %[[EXIT:.*]]
+; CHECK-NO: [[EXIT]]:
+; CHECK-NO-NEXT: ret i32 [[V]]
+;
entry:
%a1 = getelementptr inbounds i64, ptr %b1, i64 5
br label %loop
loop:
-; CHECK-LABEL: loop:
-; CHECK-YES: sunk_phi
%iv = phi i32 [0, %entry], [%iv.inc, %fallthrough]
%c3 = phi ptr [%a1, %entry], [%c, %fallthrough]
%b3 = phi ptr [%b1, %entry], [%b2, %fallthrough]
@@ -215,11 +424,6 @@ if.then:
br label %fallthrough
fallthrough:
-; CHECK-YES: sunk_phi
-; CHECK-NO-LABEL: fallthrough:
-; CHECK-NO: phi
-; CHECK-NO-NEXT: phi
-; CHECK-NO-NEXT: load
%c = phi ptr [%c3, %loop], [%a2, %if.then]
%b = phi ptr [%b3, %loop], [%b2, %if.then]
%v = load volatile i32, ptr %c, align 4
@@ -233,7 +437,45 @@ exit:
; Case through a loop. No phi node.
define i32 @test10(i32 %N, i1 %cond, ptr %b1, ptr %b2) {
-; CHECK-LABEL: @test10
+; CHECK-YES-LABEL: define i32 @test10(
+; CHECK-YES-SAME: i32 [[N:%.*]], i1 [[COND:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]]) {
+; CHECK-YES-NEXT: [[ENTRY:.*]]:
+; CHECK-YES-NEXT: br i1 [[COND]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH:.*]]
+; CHECK-YES: [[IF_THEN]]:
+; CHECK-YES-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-YES: [[FALLTHROUGH]]:
+; CHECK-YES-NEXT: [[SUNK_PHI:%.*]] = phi ptr [ [[B2]], %[[IF_THEN]] ], [ [[B1]], %[[ENTRY]] ]
+; CHECK-YES-NEXT: br label %[[LOOP:.*]]
+; CHECK-YES: [[LOOP]]:
+; CHECK-YES-NEXT: [[IV:%.*]] = phi i32 [ 0, %[[FALLTHROUGH]] ], [ [[IV_INC:%.*]], %[[LOOP]] ]
+; CHECK-YES-NEXT: [[IV_INC]] = add i32 [[IV]], 1
+; CHECK-YES-NEXT: [[CMP:%.*]] = icmp slt i32 [[IV_INC]], [[N]]
+; CHECK-YES-NEXT: br i1 [[CMP]], label %[[LOOP]], label %[[EXIT:.*]]
+; CHECK-YES: [[EXIT]]:
+; CHECK-YES-NEXT: [[SUNKADDR:%.*]] = getelementptr inbounds i8, ptr [[SUNK_PHI]], i64 40
+; CHECK-YES-NEXT: [[V:%.*]] = load volatile i32, ptr [[SUNKADDR]], align 4
+; CHECK-YES-NEXT: ret i32 [[V]]
+;
+; CHECK-NO-LABEL: define i32 @test10(
+; CHECK-NO-SAME: i32 [[N:%.*]], i1 [[COND:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]]) {
+; CHECK-NO-NEXT: [[ENTRY:.*]]:
+; CHECK-NO-NEXT: [[A1:%.*]] = getelementptr inbounds i64, ptr [[B1]], i64 5
+; CHECK-NO-NEXT: br i1 [[COND]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH:.*]]
+; CHECK-NO: [[IF_THEN]]:
+; CHECK-NO-NEXT: [[A2:%.*]] = getelementptr inbounds i64, ptr [[B2]], i64 5
+; CHECK-NO-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-NO: [[FALLTHROUGH]]:
+; CHECK-NO-NEXT: [[C:%.*]] = phi ptr [ [[A1]], %[[ENTRY]] ], [ [[A2]], %[[IF_THEN]] ]
+; CHECK-NO-NEXT: br label %[[LOOP:.*]]
+; CHECK-NO: [[LOOP]]:
+; CHECK-NO-NEXT: [[IV:%.*]] = phi i32 [ 0, %[[FALLTHROUGH]] ], [ [[IV_INC:%.*]], %[[LOOP]] ]
+; CHECK-NO-NEXT: [[IV_INC]] = add i32 [[IV]], 1
+; CHECK-NO-NEXT: [[CMP:%.*]] = icmp slt i32 [[IV_INC]], [[N]]
+; CHECK-NO-NEXT: br i1 [[CMP]], label %[[LOOP]], label %[[EXIT:.*]]
+; CHECK-NO: [[EXIT]]:
+; CHECK-NO-NEXT: [[V:%.*]] = load volatile i32, ptr [[C]], align 4
+; CHECK-NO-NEXT: ret i32 [[V]]
+;
entry:
%a1 = getelementptr inbounds i64, ptr %b1, i64 5
br i1 %cond, label %if.then, label %fallthrough
@@ -243,10 +485,6 @@ if.then:
br label %fallthrough
fallthrough:
-; CHECK-YES: sunk_phi
-; CHECK-NO-LABEL: fallthrough:
-; CHECK-NO-NEXT: phi
-; CHECK-NO-NEXT: br
%c = phi ptr [%a1, %entry], [%a2, %if.then]
br label %loop
@@ -257,14 +495,31 @@ loop:
br i1 %cmp, label %loop, label %exit
exit:
-; CHECK-YES: sunkaddr
%v = load volatile i32, ptr %c, align 4
ret i32 %v
}
; Case through a loop. There is a phi.
define i32 @test11(i32 %N, i1 %cond, ptr %b1, ptr %b2) {
-; CHECK-LABEL: @test11
+; CHECK-LABEL: define i32 @test11(
+; CHECK-SAME: i32 [[N:%.*]], i1 [[COND:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]]) {
+; CHECK-NEXT: [[ENTRY:.*]]:
+; CHECK-NEXT: br i1 [[COND]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH:.*]]
+; CHECK: [[IF_THEN]]:
+; CHECK-NEXT: br label %[[FALLTHROUGH]]
+; CHECK: [[FALLTHROUGH]]:
+; CHECK-NEXT: [[B:%.*]] = phi ptr [ [[B1]], %[[ENTRY]] ], [ [[B2]], %[[IF_THEN]] ]
+; CHECK-NEXT: br label %[[LOOP:.*]]
+; CHECK: [[LOOP]]:
+; CHECK-NEXT: [[IV:%.*]] = phi i32 [ 0, %[[FALLTHROUGH]] ], [ [[IV_INC:%.*]], %[[LOOP]] ]
+; CHECK-NEXT: [[IV_INC]] = add i32 [[IV]], 1
+; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 [[IV_INC]], [[N]]
+; CHECK-NEXT: br i1 [[CMP]], label %[[LOOP]], label %[[EXIT:.*]]
+; CHECK: [[EXIT]]:
+; CHECK-NEXT: [[SUNKADDR:%.*]] = getelementptr inbounds i8, ptr [[B]], i64 40
+; CHECK-NEXT: [[V:%.*]] = load volatile i32, ptr [[SUNKADDR]], align 4
+; CHECK-NEXT: ret i32 [[V]]
+;
entry:
%a1 = getelementptr inbounds i64, ptr %b1, i64 5
br i1 %cond, label %if.then, label %fallthrough
@@ -274,9 +529,6 @@ if.then:
br label %fallthrough
fallthrough:
-; CHECK: phi
-; CHECK: phi
-; CHECK: br
%c = phi ptr [%a1, %entry], [%a2, %if.then]
%b = phi ptr [%b1, %entry], [%b2, %if.then]
br label %loop
@@ -288,25 +540,80 @@ loop:
br i1 %cmp, label %loop, label %exit
exit:
-; CHECK: sunkaddr
%v = load volatile i32, ptr %c, align 4
ret i32 %v
}
; Complex case with address value from previous iteration.
define i32 @test12(i32 %N, i1 %cond, ptr %b1, ptr %b2, ptr %b3) {
-; CHECK-LABEL: @test12
+; CHECK-YES-LABEL: define i32 @test12(
+; CHECK-YES-SAME: i32 [[N:%.*]], i1 [[COND:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]], ptr [[B3:%.*]]) {
+; CHECK-YES-NEXT: [[ENTRY:.*]]:
+; CHECK-YES-NEXT: [[A1:%.*]] = getelementptr inbounds i64, ptr [[B1]], i64 5
+; CHECK-YES-NEXT: br label %[[LOOP:.*]]
+; CHECK-YES: [[LOOP]]:
+; CHECK-YES-NEXT: [[IV:%.*]] = phi i32 [ 0, %[[ENTRY]] ], [ [[IV_INC:%.*]], %[[BACKEDGE:.*]] ]
+; CHECK-YES-NEXT: [[SUNK_PHI1:%.*]] = phi ptr [ [[SUNK_PHI:%.*]], %[[BACKEDGE]] ], [ [[B1]], %[[ENTRY]] ]
+; CHECK-YES-NEXT: [[C3:%.*]] = phi ptr [ [[A1]], %[[ENTRY]] ], [ [[C:%.*]], %[[BACKEDGE]] ]
+; CHECK-YES-NEXT: [[B4:%.*]] = phi ptr [ [[B1]], %[[ENTRY]] ], [ [[B5:%.*]], %[[BACKEDGE]] ]
+; CHECK-YES-NEXT: br i1 [[COND]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH:.*]]
+; CHECK-YES: [[IF_THEN]]:
+; CHECK-YES-NEXT: [[A2:%.*]] = getelementptr inbounds i64, ptr [[B2]], i64 5
+; CHECK-YES-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-YES: [[FALLTHROUGH]]:
+; CHECK-YES-NEXT: [[SUNK_PHI]] = phi ptr [ [[B2]], %[[IF_THEN]] ], [ [[SUNK_PHI1]], %[[LOOP]] ]
+; CHECK-YES-NEXT: [[C]] = phi ptr [ [[C3]], %[[LOOP]] ], [ [[A2]], %[[IF_THEN]] ]
+; CHECK-YES-NEXT: [[B6:%.*]] = phi ptr [ [[B4]], %[[LOOP]] ], [ [[B2]], %[[IF_THEN]] ]
+; CHECK-YES-NEXT: [[SUNKADDR:%.*]] = getelementptr inbounds i8, ptr [[SUNK_PHI]], i64 40
+; CHECK-YES-NEXT: [[V:%.*]] = load volatile i32, ptr [[SUNKADDR]], align 4
+; CHECK-YES-NEXT: [[A4:%.*]] = getelementptr inbounds i64, ptr [[B4]], i64 5
+; CHECK-YES-NEXT: [[CMP:%.*]] = icmp slt i32 [[IV]], 20
+; CHECK-YES-NEXT: br i1 [[CMP]], label %[[BACKEDGE]], label %[[IF_THEN_2:.*]]
+; CHECK-YES: [[IF_THEN_2]]:
+; CHECK-YES-NEXT: br label %[[BACKEDGE]]
+; CHECK-YES: [[BACKEDGE]]:
+; CHECK-YES-NEXT: [[B5]] = phi ptr [ [[B4]], %[[FALLTHROUGH]] ], [ [[B6]], %[[IF_THEN_2]] ]
+; CHECK-YES-NEXT: [[IV_INC]] = add i32 [[IV]], 1
+; CHECK-YES-NEXT: [[CMP2:%.*]] = icmp slt i32 [[IV_INC]], [[N]]
+; CHECK-YES-NEXT: br i1 [[CMP2]], label %[[LOOP]], label %[[EXIT:.*]]
+; CHECK-YES: [[EXIT]]:
+; CHECK-YES-NEXT: ret i32 [[V]]
+;
+; CHECK-NO-LABEL: define i32 @test12(
+; CHECK-NO-SAME: i32 [[N:%.*]], i1 [[COND:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]], ptr [[B3:%.*]]) {
+; CHECK-NO-NEXT: [[ENTRY:.*]]:
+; CHECK-NO-NEXT: [[A1:%.*]] = getelementptr inbounds i64, ptr [[B1]], i64 5
+; CHECK-NO-NEXT: br label %[[LOOP:.*]]
+; CHECK-NO: [[LOOP]]:
+; CHECK-NO-NEXT: [[IV:%.*]] = phi i32 [ 0, %[[ENTRY]] ], [ [[IV_INC:%.*]], %[[BACKEDGE:.*]] ]
+; CHECK-NO-NEXT: [[C3:%.*]] = phi ptr [ [[A1]], %[[ENTRY]] ], [ [[C:%.*]], %[[BACKEDGE]] ]
+; CHECK-NO-NEXT: [[B4:%.*]] = phi ptr [ [[B1]], %[[ENTRY]] ], [ [[B5:%.*]], %[[BACKEDGE]] ]
+; CHECK-NO-NEXT: br i1 [[COND]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH:.*]]
+; CHECK-NO: [[IF_THEN]]:
+; CHECK-NO-NEXT: [[A2:%.*]] = getelementptr inbounds i64, ptr [[B2]], i64 5
+; CHECK-NO-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-NO: [[FALLTHROUGH]]:
+; CHECK-NO-NEXT: [[C]] = phi ptr [ [[C3]], %[[LOOP]] ], [ [[A2]], %[[IF_THEN]] ]
+; CHECK-NO-NEXT: [[B6:%.*]] = phi ptr [ [[B4]], %[[LOOP]] ], [ [[B2]], %[[IF_THEN]] ]
+; CHECK-NO-NEXT: [[V:%.*]] = load volatile i32, ptr [[C]], align 4
+; CHECK-NO-NEXT: [[A4:%.*]] = getelementptr inbounds i64, ptr [[B4]], i64 5
+; CHECK-NO-NEXT: [[CMP:%.*]] = icmp slt i32 [[IV]], 20
+; CHECK-NO-NEXT: br i1 [[CMP]], label %[[BACKEDGE]], label %[[IF_THEN_2:.*]]
+; CHECK-NO: [[IF_THEN_2]]:
+; CHECK-NO-NEXT: br label %[[BACKEDGE]]
+; CHECK-NO: [[BACKEDGE]]:
+; CHECK-NO-NEXT: [[B5]] = phi ptr [ [[B4]], %[[FALLTHROUGH]] ], [ [[B6]], %[[IF_THEN_2]] ]
+; CHECK-NO-NEXT: [[IV_INC]] = add i32 [[IV]], 1
+; CHECK-NO-NEXT: [[CMP2:%.*]] = icmp slt i32 [[IV_INC]], [[N]]
+; CHECK-NO-NEXT: br i1 [[CMP2]], label %[[LOOP]], label %[[EXIT:.*]]
+; CHECK-NO: [[EXIT]]:
+; CHECK-NO-NEXT: ret i32 [[V]]
+;
entry:
%a1 = getelementptr inbounds i64, ptr %b1, i64 5
br label %loop
loop:
-; CHECK-LABEL: loop:
-; CHECK-YES: sunk_phi
-; CHECK-NO: phi
-; CHECK-NO-NEXT: phi
-; CHECK-NO-NEXT: phi
-; CHECK-NO-NEXT: br
%iv = phi i32 [0, %entry], [%iv.inc, %backedge]
%c3 = phi ptr [%a1, %entry], [%c, %backedge]
%b4 = phi ptr [%b1, %entry], [%b5, %backedge]
@@ -317,11 +624,6 @@ if.then:
br label %fallthrough
fallthrough:
-; CHECK-LABEL: fallthrough:
-; CHECK-YES: sunk_phi
-; CHECK-NO: phi
-; CHECK-NO-NEXT: phi
-; CHECK-NO-NEXT: load
%c = phi ptr [%c3, %loop], [%a2, %if.then]
%b6 = phi ptr [%b4, %loop], [%b2, %if.then]
%v = load volatile i32, ptr %c, align 4
@@ -345,7 +647,35 @@ exit:
%struct.S = type {i32, i32}
; Case with index
define i32 @test13(i1 %cond, ptr %b1, ptr %b2, i64 %Index) {
-; CHECK-LABEL: @test13
+; CHECK-YES-LABEL: define i32 @test13(
+; CHECK-YES-SAME: i1 [[COND:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]], i64 [[INDEX:%.*]]) {
+; CHECK-YES-NEXT: [[ENTRY:.*]]:
+; CHECK-YES-NEXT: br i1 [[COND]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH:.*]]
+; CHECK-YES: [[IF_THEN]]:
+; CHECK-YES-NEXT: [[I2:%.*]] = mul i64 [[INDEX]], 2
+; CHECK-YES-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-YES: [[FALLTHROUGH]]:
+; CHECK-YES-NEXT: [[SUNK_PHI:%.*]] = phi ptr [ [[B2]], %[[IF_THEN]] ], [ [[B1]], %[[ENTRY]] ]
+; CHECK-YES-NEXT: [[SUNKADDR:%.*]] = mul i64 [[INDEX]], 8
+; CHECK-YES-NEXT: [[SUNKADDR1:%.*]] = getelementptr inbounds i8, ptr [[SUNK_PHI]], i64 [[SUNKADDR]]
+; CHECK-YES-NEXT: [[SUNKADDR2:%.*]] = getelementptr inbounds i8, ptr [[SUNKADDR1]], i64 4
+; CHECK-YES-NEXT: [[V:%.*]] = load i32, ptr [[SUNKADDR2]], align 4
+; CHECK-YES-NEXT: ret i32 [[V]]
+;
+; CHECK-NO-LABEL: define i32 @test13(
+; CHECK-NO-SAME: i1 [[COND:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]], i64 [[INDEX:%.*]]) {
+; CHECK-NO-NEXT: [[ENTRY:.*]]:
+; CHECK-NO-NEXT: [[A1:%.*]] = getelementptr inbounds [[STRUCT_S:%.*]], ptr [[B1]], i64 [[INDEX]], i32 1
+; CHECK-NO-NEXT: br i1 [[COND]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH:.*]]
+; CHECK-NO: [[IF_THEN]]:
+; CHECK-NO-NEXT: [[I2:%.*]] = mul i64 [[INDEX]], 2
+; CHECK-NO-NEXT: [[A2:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[B2]], i64 [[INDEX]], i32 1
+; CHECK-NO-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-NO: [[FALLTHROUGH]]:
+; CHECK-NO-NEXT: [[A:%.*]] = phi ptr [ [[A1]], %[[ENTRY]] ], [ [[A2]], %[[IF_THEN]] ]
+; CHECK-NO-NEXT: [[V:%.*]] = load i32, ptr [[A]], align 4
+; CHECK-NO-NEXT: ret i32 [[V]]
+;
entry:
%a1 = getelementptr inbounds %struct.S, ptr %b1, i64 %Index, i32 1
br i1 %cond, label %if.then, label %fallthrough
@@ -356,10 +686,6 @@ if.then:
br label %fallthrough
fallthrough:
-; CHECK-YES: sunk_phi
-; CHECK-NO-LABEL: fallthrough:
-; CHECK-NO-NEXT: phi
-; CHECK-NO-NEXT: load
%a = phi ptr [%a1, %entry], [%a2, %if.then]
%v = load i32, ptr %a, align 4
ret i32 %v
@@ -367,22 +693,55 @@ fallthrough:
; Select of Select case.
define i64 @test14(i1 %c1, i1 %c2, ptr %b1, ptr %b2, ptr %b3) {
-; CHECK-LABEL: @test14
+; CHECK-LABEL: define i64 @test14(
+; CHECK-SAME: i1 [[C1:%.*]], i1 [[C2:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]], ptr [[B3:%.*]]) {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[S12:%.*]] = select i1 [[C1]], ptr [[B1]], ptr [[B2]]
+; CHECK-NEXT: [[S21:%.*]] = select i1 [[C2]], ptr [[S12]], ptr [[B3]]
+; CHECK-NEXT: [[SUNKADDR:%.*]] = getelementptr inbounds i8, ptr [[S21]], i64 40
+; CHECK-NEXT: [[V:%.*]] = load i64, ptr [[SUNKADDR]], align 8
+; CHECK-NEXT: ret i64 [[V]]
+;
entry:
-; CHECK-LABEL: entry:
%g1 = getelementptr inbounds i64, ptr %b1, i64 5
%g2 = getelementptr inbounds i64, ptr %b2, i64 5
%g3 = getelementptr inbounds i64, ptr %b3, i64 5
%s1 = select i1 %c1, ptr %g1, ptr %g2
%s2 = select i1 %c2, ptr %s1, ptr %g3
-; CHECK: sunkaddr
%v = load i64 , ptr %s2, align 8
ret i64 %v
}
; Select of Phi case.
define i64 @test15(i1 %c1, i1 %c2, ptr %b1, ptr %b2, ptr %b3) {
-; CHECK-LABEL: @test15
+; CHECK-YES-LABEL: define i64 @test15(
+; CHECK-YES-SAME: i1 [[C1:%.*]], i1 [[C2:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]], ptr [[B3:%.*]]) {
+; CHECK-YES-NEXT: [[ENTRY:.*]]:
+; CHECK-YES-NEXT: br i1 [[C1]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH:.*]]
+; CHECK-YES: [[IF_THEN]]:
+; CHECK-YES-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-YES: [[FALLTHROUGH]]:
+; CHECK-YES-NEXT: [[SUNK_PHI:%.*]] = phi ptr [ [[B2]], %[[IF_THEN]] ], [ [[B1]], %[[ENTRY]] ]
+; CHECK-YES-NEXT: [[S11:%.*]] = select i1 [[C2]], ptr [[SUNK_PHI]], ptr [[B3]]
+; CHECK-YES-NEXT: [[SUNKADDR:%.*]] = getelementptr inbounds i8, ptr [[S11]], i64 40
+; CHECK-YES-NEXT: [[V:%.*]] = load i64, ptr [[SUNKADDR]], align 8
+; CHECK-YES-NEXT: ret i64 [[V]]
+;
+; CHECK-NO-LABEL: define i64 @test15(
+; CHECK-NO-SAME: i1 [[C1:%.*]], i1 [[C2:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]], ptr [[B3:%.*]]) {
+; CHECK-NO-NEXT: [[ENTRY:.*]]:
+; CHECK-NO-NEXT: [[G1:%.*]] = getelementptr inbounds i64, ptr [[B1]], i64 5
+; CHECK-NO-NEXT: [[G2:%.*]] = getelementptr inbounds i64, ptr [[B2]], i64 5
+; CHECK-NO-NEXT: [[G3:%.*]] = getelementptr inbounds i64, ptr [[B3]], i64 5
+; CHECK-NO-NEXT: br i1 [[C1]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH:.*]]
+; CHECK-NO: [[IF_THEN]]:
+; CHECK-NO-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-NO: [[FALLTHROUGH]]:
+; CHECK-NO-NEXT: [[P1:%.*]] = phi ptr [ [[G1]], %[[ENTRY]] ], [ [[G2]], %[[IF_THEN]] ]
+; CHECK-NO-NEXT: [[S1:%.*]] = select i1 [[C2]], ptr [[P1]], ptr [[G3]]
+; CHECK-NO-NEXT: [[V:%.*]] = load i64, ptr [[S1]], align 8
+; CHECK-NO-NEXT: ret i64 [[V]]
+;
entry:
%g1 = getelementptr inbounds i64, ptr %b1, i64 5
%g2 = getelementptr inbounds i64, ptr %b2, i64 5
@@ -393,20 +752,27 @@ if.then:
br label %fallthrough
fallthrough:
-; CHECK-LABEL: fallthrough:
%p1 = phi ptr [%g1, %entry], [%g2, %if.then]
%s1 = select i1 %c2, ptr %p1, ptr %g3
-; CHECK-YES: sunkaddr
-; CHECK-NO: phi
-; CHECK-NO-NEXT: select
-; CHECK-NO-NEXT: load
%v = load i64 , ptr %s1, align 8
ret i64 %v
}
; Select of Phi case. Phi exists
define i64 @test16(i1 %c1, i1 %c2, ptr %b1, ptr %b2, ptr %b3) {
-; CHECK-LABEL: @test16
+; CHECK-LABEL: define i64 @test16(
+; CHECK-SAME: i1 [[C1:%.*]], i1 [[C2:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]], ptr [[B3:%.*]]) {
+; CHECK-NEXT: [[ENTRY:.*]]:
+; CHECK-NEXT: br i1 [[C1]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH:.*]]
+; CHECK: [[IF_THEN]]:
+; CHECK-NEXT: br label %[[FALLTHROUGH]]
+; CHECK: [[FALLTHROUGH]]:
+; CHECK-NEXT: [[P:%.*]] = phi ptr [ [[B1]], %[[ENTRY]] ], [ [[B2]], %[[IF_THEN]] ]
+; CHECK-NEXT: [[S11:%.*]] = select i1 [[C2]], ptr [[P]], ptr [[B3]]
+; CHECK-NEXT: [[SUNKADDR:%.*]] = getelementptr inbounds i8, ptr [[S11]], i64 40
+; CHECK-NEXT: [[V:%.*]] = load i64, ptr [[SUNKADDR]], align 8
+; CHECK-NEXT: ret i64 [[V]]
+;
entry:
%g1 = getelementptr inbounds i64, ptr %b1, i64 5
%g2 = getelementptr inbounds i64, ptr %b2, i64 5
@@ -417,18 +783,43 @@ if.then:
br label %fallthrough
fallthrough:
-; CHECK-LABEL: fallthrough:
%p = phi ptr [%b1, %entry], [%b2, %if.then]
%p1 = phi ptr [%g1, %entry], [%g2, %if.then]
%s1 = select i1 %c2, ptr %p1, ptr %g3
-; CHECK: sunkaddr
%v = load i64 , ptr %s1, align 8
ret i64 %v
}
; Phi of Select case.
define i64 @test17(i1 %c1, i1 %c2, ptr %b1, ptr %b2, ptr %b3) {
-; CHECK-LABEL: @test17
+; CHECK-YES-LABEL: define i64 @test17(
+; CHECK-YES-SAME: i1 [[C1:%.*]], i1 [[C2:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]], ptr [[B3:%.*]]) {
+; CHECK-YES-NEXT: [[ENTRY:.*]]:
+; CHECK-YES-NEXT: [[S11:%.*]] = select i1 [[C2]], ptr [[B1]], ptr [[B2]]
+; CHECK-YES-NEXT: br i1 [[C1]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH:.*]]
+; CHECK-YES: [[IF_THEN]]:
+; CHECK-YES-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-YES: [[FALLTHROUGH]]:
+; CHECK-YES-NEXT: [[SUNK_PHI:%.*]] = phi ptr [ [[B3]], %[[IF_THEN]] ], [ [[S11]], %[[ENTRY]] ]
+; CHECK-YES-NEXT: [[SUNKADDR:%.*]] = getelementptr inbounds i8, ptr [[SUNK_PHI]], i64 40
+; CHECK-YES-NEXT: [[V:%.*]] = load i64, ptr [[SUNKADDR]], align 8
+; CHECK-YES-NEXT: ret i64 [[V]]
+;
+; CHECK-NO-LABEL: define i64 @test17(
+; CHECK-NO-SAME: i1 [[C1:%.*]], i1 [[C2:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]], ptr [[B3:%.*]]) {
+; CHECK-NO-NEXT: [[ENTRY:.*]]:
+; CHECK-NO-NEXT: [[G1:%.*]] = getelementptr inbounds i64, ptr [[B1]], i64 5
+; CHECK-NO-NEXT: [[G2:%.*]] = getelementptr inbounds i64, ptr [[B2]], i64 5
+; CHECK-NO-NEXT: [[G3:%.*]] = getelementptr inbounds i64, ptr [[B3]], i64 5
+; CHECK-NO-NEXT: [[S1:%.*]] = select i1 [[C2]], ptr [[G1]], ptr [[G2]]
+; CHECK-NO-NEXT: br i1 [[C1]], label %[[IF_THEN:.*]], label %[[FALLTHROUGH:.*]]
+; CHECK-NO: [[IF_THEN]]:
+; CHECK-NO-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-NO: [[FALLTHROUGH]]:
+; CHECK-NO-NEXT: [[P1:%.*]] = phi ptr [ [[S1]], %[[ENTRY]] ], [ [[G3]], %[[IF_THEN]] ]
+; CHECK-NO-NEXT: [[V:%.*]] = load i64, ptr [[P1]], align 8
+; CHECK-NO-NEXT: ret i64 [[V]]
+;
entry:
%g1 = getelementptr inbounds i64, ptr %b1, i64 5
%g2 = getelementptr inbounds i64, ptr %b2, i64 5
@@ -440,18 +831,48 @@ if.then:
br label %fallthrough
fallthrough:
-; CHECK-LABEL: fallthrough:
%p1 = phi ptr [%s1, %entry], [%g3, %if.then]
-; CHECK-YES: sunkaddr
-; CHECK-NO: phi
-; CHECK-NO-NEXT: load
%v = load i64 , ptr %p1, align 8
ret i64 %v
}
; The same two addr modes by
diff erent paths
define i32 @test18(i1 %cond1, i1 %cond2, ptr %b1, ptr %b2) {
-; CHECK-LABEL: @test18
+; CHECK-YES-LABEL: define i32 @test18(
+; CHECK-YES-SAME: i1 [[COND1:%.*]], i1 [[COND2:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]]) {
+; CHECK-YES-NEXT: [[ENTRY:.*:]]
+; CHECK-YES-NEXT: br i1 [[COND1]], label %[[IF_THEN1:.*]], label %[[IF_THEN2:.*]]
+; CHECK-YES: [[IF_THEN1]]:
+; CHECK-YES-NEXT: br label %[[FALLTHROUGH:.*]]
+; CHECK-YES: [[IF_THEN2]]:
+; CHECK-YES-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-YES: [[FALLTHROUGH]]:
+; CHECK-YES-NEXT: [[SUNK_PHI:%.*]] = phi ptr [ [[B2]], %[[IF_THEN2]] ], [ [[B1]], %[[IF_THEN1]] ]
+; CHECK-YES-NEXT: [[SUNKADDR:%.*]] = getelementptr inbounds i8, ptr [[SUNK_PHI]], i64 40
+; CHECK-YES-NEXT: [[V1:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-YES-NEXT: [[G1_1:%.*]] = getelementptr inbounds i64, ptr [[B2]], i64 5
+; CHECK-YES-NEXT: [[V2:%.*]] = load i32, ptr [[G1_1]], align 4
+; CHECK-YES-NEXT: [[V:%.*]] = add i32 [[V1]], [[V2]]
+; CHECK-YES-NEXT: ret i32 [[V]]
+;
+; CHECK-NO-LABEL: define i32 @test18(
+; CHECK-NO-SAME: i1 [[COND1:%.*]], i1 [[COND2:%.*]], ptr [[B1:%.*]], ptr [[B2:%.*]]) {
+; CHECK-NO-NEXT: [[ENTRY:.*:]]
+; CHECK-NO-NEXT: [[G1:%.*]] = getelementptr inbounds i64, ptr [[B2]], i64 5
+; CHECK-NO-NEXT: br i1 [[COND1]], label %[[IF_THEN1:.*]], label %[[IF_THEN2:.*]]
+; CHECK-NO: [[IF_THEN1]]:
+; CHECK-NO-NEXT: [[G2:%.*]] = getelementptr inbounds i64, ptr [[B1]], i64 5
+; CHECK-NO-NEXT: br label %[[FALLTHROUGH:.*]]
+; CHECK-NO: [[IF_THEN2]]:
+; CHECK-NO-NEXT: br label %[[FALLTHROUGH]]
+; CHECK-NO: [[FALLTHROUGH]]:
+; CHECK-NO-NEXT: [[C:%.*]] = phi ptr [ [[G2]], %[[IF_THEN1]] ], [ [[G1]], %[[IF_THEN2]] ]
+; CHECK-NO-NEXT: [[V1:%.*]] = load i32, ptr [[C]], align 4
+; CHECK-NO-NEXT: [[G1_1:%.*]] = getelementptr inbounds i64, ptr [[B2]], i64 5
+; CHECK-NO-NEXT: [[V2:%.*]] = load i32, ptr [[G1_1]], align 4
+; CHECK-NO-NEXT: [[V:%.*]] = add i32 [[V1]], [[V2]]
+; CHECK-NO-NEXT: ret i32 [[V]]
+;
entry:
%g1 = getelementptr inbounds i64, ptr %b2, i64 5
br i1 %cond1, label %if.then1, label %if.then2
@@ -467,10 +888,6 @@ if.then3:
br label %fallthrough
fallthrough:
-; CHECK-YES: sunk_phi
-; CHECK-NO-LABEL: fallthrough:
-; CHECK-NO: phi
-; CHECK-NO-NEXT: load
%c = phi ptr [%g2, %if.then1], [%g1, %if.then2], [%g1, %if.then3]
%v1 = load i32, ptr %c, align 4
%g1_1 = getelementptr inbounds i64, ptr %b2, i64 5
@@ -481,7 +898,31 @@ fallthrough:
; Different types but null is the first?
define i32 @test19(i1 %cond1, i1 %cond2, ptr %b2, ptr %b1) {
-; CHECK-LABEL: @test19
+; CHECK-LABEL: define i32 @test19(
+; CHECK-SAME: i1 [[COND1:%.*]], i1 [[COND2:%.*]], ptr [[B2:%.*]], ptr [[B1:%.*]]) {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: [[G1:%.*]] = getelementptr inbounds i64, ptr [[B2]], i64 5
+; CHECK-NEXT: br i1 [[COND1]], label %[[IF_THEN1:.*]], label %[[IF_THEN2:.*]]
+; CHECK: [[IF_THEN1]]:
+; CHECK-NEXT: [[G2:%.*]] = getelementptr inbounds i8, ptr [[B1]], i64 40
+; CHECK-NEXT: [[BC2:%.*]] = bitcast ptr [[G2]] to ptr
+; CHECK-NEXT: br label %[[FALLTHROUGH:.*]]
+; CHECK: [[IF_THEN2]]:
+; CHECK-NEXT: [[BC1_1:%.*]] = bitcast ptr [[G1]] to ptr
+; CHECK-NEXT: br i1 [[COND2]], label %[[FALLTHROUGH]], label %[[IF_THEN3:.*]]
+; CHECK: [[IF_THEN3]]:
+; CHECK-NEXT: [[G3:%.*]] = getelementptr inbounds i64, ptr null, i64 5
+; CHECK-NEXT: [[BC1_2:%.*]] = bitcast ptr [[G3]] to ptr
+; CHECK-NEXT: br label %[[FALLTHROUGH]]
+; CHECK: [[FALLTHROUGH]]:
+; CHECK-NEXT: [[C:%.*]] = phi ptr [ [[BC2]], %[[IF_THEN1]] ], [ [[BC1_1]], %[[IF_THEN2]] ], [ [[BC1_2]], %[[IF_THEN3]] ]
+; CHECK-NEXT: [[V1:%.*]] = load i32, ptr [[C]], align 4
+; CHECK-NEXT: [[G1_1:%.*]] = getelementptr inbounds i64, ptr [[B2]], i64 5
+; CHECK-NEXT: [[BC1_1_1:%.*]] = bitcast ptr [[G1_1]] to ptr
+; CHECK-NEXT: [[V2:%.*]] = load i32, ptr [[BC1_1_1]], align 4
+; CHECK-NEXT: [[V:%.*]] = add i32 [[V1]], [[V2]]
+; CHECK-NEXT: ret i32 [[V]]
+;
entry:
%g1 = getelementptr inbounds i64, ptr %b2, i64 5
%bc1 = bitcast ptr %g1 to ptr
@@ -502,7 +943,6 @@ if.then3:
br label %fallthrough
fallthrough:
-; CHECK-NOT: sunk_phi
%c = phi ptr [%bc2, %if.then1], [%bc1_1, %if.then2], [%bc1_2, %if.then3]
%v1 = load i32, ptr %c, align 4
%g1_1 = getelementptr inbounds i64, ptr %b2, i64 5
diff --git a/llvm/test/Transforms/CodeGenPrepare/X86/sink-addrmode-two-phi.ll b/llvm/test/Transforms/CodeGenPrepare/X86/sink-addrmode-two-phi.ll
index 6a6b029b67b51..2945a007bf578 100644
--- a/llvm/test/Transforms/CodeGenPrepare/X86/sink-addrmode-two-phi.ll
+++ b/llvm/test/Transforms/CodeGenPrepare/X86/sink-addrmode-two-phi.ll
@@ -1,9 +1,21 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
; RUN: opt -S -passes='require<profile-summary>,function(codegenprepare)' -disable-complex-addr-modes=false -disable-cgp-delete-phis %s | FileCheck %s --check-prefix=CHECK
target datalayout =
"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
target triple = "x86_64-unknown-linux-gnu"
define void @test() {
+; CHECK-LABEL: define void @test() {
+; CHECK-NEXT: [[ENTRY:.*]]:
+; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds i64, ptr null, i64 undef
+; CHECK-NEXT: br label %[[START:.*]]
+; CHECK: [[START]]:
+; CHECK-NEXT: [[VAL1:%.*]] = phi ptr [ [[TMP0]], %[[ENTRY]] ], [ [[VAL1]], %[[START]] ]
+; CHECK-NEXT: [[VAL2:%.*]] = phi ptr [ null, %[[ENTRY]] ], [ [[VAL2]], %[[START]] ]
+; CHECK-NEXT: [[SUNKADDR2:%.*]] = bitcast ptr [[VAL2]] to ptr
+; CHECK-NEXT: [[LOADX:%.*]] = load i64, ptr [[SUNKADDR2]], align 8
+; CHECK-NEXT: br label %[[START]]
+;
entry:
%0 = getelementptr inbounds i64, ptr null, i64 undef
br label %start
@@ -18,7 +30,6 @@ slowpath:
br label %exit
exit:
-; CHECK: sunkaddr
%val3 = phi ptr [ undef, %slowpath ], [ %val2, %start ]
%val4 = phi ptr [ %elem1, %slowpath ], [ %val1, %start ]
%val5 = phi ptr [ undef, %slowpath ], [ %val2, %start ]
More information about the llvm-commits
mailing list