This is an archive of the discontinued LLVM Phabricator instance.

Differential D123846

[RS4GC] Prune inputs of BDV if they are BDV themselves
ClosedPublic

Authored by dmakogon on Apr 15 2022, 1:42 AM.

Details

Reviewers
nikic
reames
mkazantsev
Commits
rGd03d2d8aeaa3: [RS4GC] Prune inputs of BDV if they are BDV themselves
Summary

There's a stage in RS4GC when we remove all nodes from the state list if all of their inputs are base pointers.
Consider the following PHI:

loop:
  %ph = phi i8* [ %ph, %loop ], [ %b, %block ]

Say %b is a base value. Then we should remove the %ph from the states list, because it's equal to %b.
This patch just skips all the input values if they are equal to the value currently being processed.

If in the example above we had a user of %ph for which we were asked to find a base value,
we'd clone that user and replaced %ph uses with the %b base value.
With the patch %ph is treated as a base pointer, so no cloning happens.

Diff Detail

Event Timeline

dmakogon created this revision.Apr 15 2022, 1:42 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 15 2022, 1:42 AM
Herald added a subscriber: hiraditya. · View Herald Transcript
dmakogon requested review of this revision.Apr 15 2022, 1:42 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 15 2022, 1:42 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
mkazantsev added inline comments.Apr 15 2022, 2:39 AM
llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
939

What if V->stripPointerCasts() == BDV, will this still return false?

mkazantsev added a comment.EditedApr 15 2022, 2:44 AM

Will this patch handle the following example:

loop: 
  %outer_phi = phi (%start, %inner_phi)
  br inner_loop

inner_loop:
  %inner_phi = phi(%start, %outer_phi)
  %inner.cond = <smth>
  br %inner.cond, inner_loop, outer_backedge

outer_backedge:
  outer_cond = ...
  br outer_cond, loop, exit

exit:
...

Here both inner_phi and outer_phi are in fact equal to one another (and both equal to start), but still different values. Will it work? If no, is there a plan to make it work?

mkazantsev added inline comments.Apr 15 2022, 2:49 AM
llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
939

One possible way to get that is

%ph = phi i8* [ %ph2, %loop ], [ %b, %block ]
%ph1 = bitcast %ph to i32*
%ph2 = bitcast %ph1 to i8*
Harbormaster completed remote builds in B159798: Diff 423042.Apr 15 2022, 2:49 AM
lebedev.ri removed a reviewer: lebedev.ri.Apr 15 2022, 4:50 AM
reames accepted this revision.Apr 16 2022, 8:30 AM

LGTM

llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
937–942

Please rephrase this comment to emphasize this is handling the phi case (as no other instruction can have itself as operand in reachable code).

This revision is now accepted and ready to land.Apr 16 2022, 8:30 AM
dmakogon added a comment.Apr 19 2022, 5:02 AM
In D123846#3453716, @mkazantsev wrote:

Will this patch handle the following example:

loop: 
  %outer_phi = phi (%start, %inner_phi)
  br inner_loop

inner_loop:
  %inner_phi = phi(%start, %outer_phi)
  %inner.cond = <smth>
  br %inner.cond, inner_loop, outer_backedge

outer_backedge:
  outer_cond = ...
  br outer_cond, loop, exit

exit:
...

Here both inner_phi and outer_phi are in fact equal to one another (and both equal to start), but still different values. Will it work? If no, is there a plan to make it work?

No, these PHIs won't be removed at this stage of RS4GC.
However there won't be any cloning here. During states meet phase we will figure out that they both have the %start base. Merging two equal bases is not a conflict state.

dmakogon updated this revision to Diff 423655.Apr 19 2022, 9:30 AM

Added more test cases with derived pointers.
Fixed comment message.

dmakogon marked 3 inline comments as done.Apr 19 2022, 9:31 AM
Harbormaster completed remote builds in B160260: Diff 423655.Apr 19 2022, 10:54 AM
mkazantsev accepted this revision.Apr 20 2022, 4:15 AM
This revision was landed with ongoing or failed builds.Apr 26 2022, 2:05 AM
Closed by commit rGd03d2d8aeaa3: [RS4GC] Prune inputs of BDV if they are BDV themselves (authored by dmakogon). · Explain Why
This revision was automatically updated to reflect the committed changes.
dmakogon added a commit: rGd03d2d8aeaa3: [RS4GC] Prune inputs of BDV if they are BDV themselves.

Revision Contents

PathSize
llvm/
lib/
Transforms/
Scalar/
10 lines
test/
Transforms/
RewriteStatepointsForGC/
58 lines

Diff 425155

llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

Show First 20 Lines • Show All 928 Lines • ▼ Show 20 Lines#endif
// a base pointer for happens to be a base pointer itself. (Or a sub-graph // a base pointer for happens to be a base pointer itself. (Or a sub-graph
// feeding it does.) // feeding it does.)
SmallVector<Value *> ToRemove; SmallVector<Value *> ToRemove;
do { do {
ToRemove.clear(); ToRemove.clear();
for (auto Pair : States) { for (auto Pair : States) {
Value *BDV = Pair.first; Value *BDV = Pair.first;
auto canPruneInput = [&](Value *V) { auto canPruneInput = [&](Value *V) {
Value *BDV = findBaseOrBDV(V, Cache); // If the input of the BDV is the BDV itself we can prune it. This is
if (V->stripPointerCasts() != BDV) // only possible if the BDV is a PHI node.
if (V->stripPointerCasts() == BDV)
mkazantsevUnsubmitted
Done
ReplyInline Actions

What if V->stripPointerCasts() == BDV, will this still return false?

mkazantsev: What if `V->stripPointerCasts() == BDV`, will this still return false?
mkazantsevUnsubmitted
Done
ReplyInline Actions

One possible way to get that is

%ph = phi i8* [ %ph2, %loop ], [ %b, %block ]
%ph1 = bitcast %ph to i32*
%ph2 = bitcast %ph1 to i8*
mkazantsev: One possible way to get that is ``` %ph = phi i8* [ %ph2, %loop ], [ %b, %block ] %ph1 =…
return true;
Value *VBDV = findBaseOrBDV(V, Cache);
if (V->stripPointerCasts() != VBDV)
reamesUnsubmitted
Done
ReplyInline Actions

Please rephrase this comment to emphasize this is handling the phi case (as no other instruction can have itself as operand in reachable code).

reames: Please rephrase this comment to emphasize this is handling the phi case (as no other…
return false; return false;
// The assumption is that anything not in the state list is // The assumption is that anything not in the state list is
// propagates a base pointer. // propagates a base pointer.
return States.count(BDV) == 0; return States.count(VBDV) == 0;
}; };
bool CanPrune = true; bool CanPrune = true;
visitBDVOperands(BDV, [&](Value *Op) { visitBDVOperands(BDV, [&](Value *Op) {
CanPrune = CanPrune && canPruneInput(Op); CanPrune = CanPrune && canPruneInput(Op);
}); });
if (CanPrune) if (CanPrune)
ToRemove.push_back(BDV); ToRemove.push_back(BDV);
▲ Show 20 Lines • Show All 2,234 Lines • Show Last 20 Lines

llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-14.ll

Show All 10 Lines
define i8 addrspace(1)* @test1(i1 %c, i8 addrspace(1)* %b1, i8 addrspace(1)* %b2) gc "statepoint-example" { define i8 addrspace(1)* @test1(i1 %c, i8 addrspace(1)* %b1, i8 addrspace(1)* %b2) gc "statepoint-example" {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: left: ; CHECK-NEXT: left:
; CHECK-NEXT: br i1 [[C:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]] ; CHECK-NEXT: br i1 [[C:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]]
; CHECK: loop: ; CHECK: loop:
; CHECK-NEXT: [[B5:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[LEFT:%.*]] ], [ [[B5]], [[LOOP]] ] ; CHECK-NEXT: [[B5:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[LEFT:%.*]] ], [ [[B5]], [[LOOP]] ]
; CHECK-NEXT: br i1 [[C]], label [[LOOP]], label [[MERGE2]] ; CHECK-NEXT: br i1 [[C]], label [[LOOP]], label [[MERGE2]]
; CHECK: merge2: ; CHECK: merge2:
; CHECK-NEXT: [[B6_BASE:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[LEFT]] ], [ [[B2]], [[LOOP]] ], !is_base_value !0 ; CHECK-NEXT: [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[LEFT]] ], [ [[B5]], [[LOOP]] ]
; CHECK-NEXT: [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1]], [[LEFT]] ], [ [[B5]], [[LOOP]] ] ; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B6]]) ]
; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B6]], i8 addrspace(1)* [[B6_BASE]]) ] ; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
; CHECK-NEXT: [[B6_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
; CHECK-NEXT: ret i8 addrspace(1)* [[B6_RELOCATED]] ; CHECK-NEXT: ret i8 addrspace(1)* [[B6_RELOCATED]]
; ;
left: left:
br i1 %c, label %loop, label %merge2 br i1 %c, label %loop, label %merge2
loop: loop:
%b5 = phi i8 addrspace(1)* [ %b2, %left ], [ %b5, %loop ] %b5 = phi i8 addrspace(1)* [ %b2, %left ], [ %b5, %loop ]
br i1 %c, label %loop, label %merge2 br i1 %c, label %loop, label %merge2
Show All 13 Lines
; CHECK: loop: ; CHECK: loop:
; CHECK-NEXT: [[B5:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[LEFT]] ], [ [[B5]], [[LOOP]] ], [ [[B5]], [[LOOP]] ] ; CHECK-NEXT: [[B5:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[LEFT]] ], [ [[B5]], [[LOOP]] ], [ [[B5]], [[LOOP]] ]
; CHECK-NEXT: switch i32 [[N:%.*]], label [[MERGE2]] [ ; CHECK-NEXT: switch i32 [[N:%.*]], label [[MERGE2]] [
; CHECK-NEXT: i32 0, label [[LOOP]] ; CHECK-NEXT: i32 0, label [[LOOP]]
; CHECK-NEXT: i32 1, label [[LOOP]] ; CHECK-NEXT: i32 1, label [[LOOP]]
; CHECK-NEXT: i32 2, label [[LEFT]] ; CHECK-NEXT: i32 2, label [[LEFT]]
; CHECK-NEXT: ] ; CHECK-NEXT: ]
; CHECK: merge2: ; CHECK: merge2:
; CHECK-NEXT: [[B6_BASE:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[LEFT]] ], [ [[B2]], [[LOOP]] ], !is_base_value !0 ; CHECK-NEXT: [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[LEFT]] ], [ [[B5]], [[LOOP]] ]
; CHECK-NEXT: [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1]], [[LEFT]] ], [ [[B5]], [[LOOP]] ] ; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B6]]) ]
; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B6]], i8 addrspace(1)* [[B6_BASE]]) ] ; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
; CHECK-NEXT: [[B6_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
; CHECK-NEXT: ret i8 addrspace(1)* [[B6_RELOCATED]] ; CHECK-NEXT: ret i8 addrspace(1)* [[B6_RELOCATED]]
; ;
entry: entry:
br label %left br label %left
left: left:
br i1 %c, label %loop, label %merge2 br i1 %c, label %loop, label %merge2
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
; CHECK-NEXT: left: ; CHECK-NEXT: left:
; CHECK-NEXT: br i1 [[C:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]] ; CHECK-NEXT: br i1 [[C:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]]
; CHECK: loop: ; CHECK: loop:
; CHECK-NEXT: [[B3:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[LEFT:%.*]] ], [ [[B5:%.*]], [[LOOP]] ] ; CHECK-NEXT: [[B3:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[LEFT:%.*]] ], [ [[B5:%.*]], [[LOOP]] ]
; CHECK-NEXT: [[B4:%.*]] = bitcast i8 addrspace(1)* [[B3]] to i32 addrspace(1)* ; CHECK-NEXT: [[B4:%.*]] = bitcast i8 addrspace(1)* [[B3]] to i32 addrspace(1)*
; CHECK-NEXT: [[B5]] = bitcast i32 addrspace(1)* [[B4]] to i8 addrspace(1)* ; CHECK-NEXT: [[B5]] = bitcast i32 addrspace(1)* [[B4]] to i8 addrspace(1)*
; CHECK-NEXT: br i1 [[C]], label [[LOOP]], label [[MERGE2]] ; CHECK-NEXT: br i1 [[C]], label [[LOOP]], label [[MERGE2]]
; CHECK: merge2: ; CHECK: merge2:
; CHECK-NEXT: [[B6_BASE:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[LEFT]] ], [ [[B2]], [[LOOP]] ], !is_base_value !0 ; CHECK-NEXT: [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[LEFT]] ], [ [[B5]], [[LOOP]] ]
; CHECK-NEXT: [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1]], [[LEFT]] ], [ [[B5]], [[LOOP]] ] ; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B6]]) ]
; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B6]], i8 addrspace(1)* [[B6_BASE]]) ] ; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
; CHECK-NEXT: [[B6_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
; CHECK-NEXT: ret i8 addrspace(1)* [[B6_RELOCATED]] ; CHECK-NEXT: ret i8 addrspace(1)* [[B6_RELOCATED]]
; ;
left: left:
br i1 %c, label %loop, label %merge2 br i1 %c, label %loop, label %merge2
loop: loop:
%b3 = phi i8 addrspace(1)* [ %b2, %left ], [ %b5, %loop ] %b3 = phi i8 addrspace(1)* [ %b2, %left ], [ %b5, %loop ]
%b4 = bitcast i8 addrspace(1)* %b3 to i32 addrspace(1)* %b4 = bitcast i8 addrspace(1)* %b3 to i32 addrspace(1)*
Show All 13 Lines
; CHECK: loop: ; CHECK: loop:
; CHECK-NEXT: [[B3:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[ENTRY:%.*]] ], [ [[B5:%.*]], [[LEFT:%.*]] ] ; CHECK-NEXT: [[B3:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[ENTRY:%.*]] ], [ [[B5:%.*]], [[LEFT:%.*]] ]
; CHECK-NEXT: [[B4:%.*]] = addrspacecast i8 addrspace(1)* [[B3]] to i8* ; CHECK-NEXT: [[B4:%.*]] = addrspacecast i8 addrspace(1)* [[B3]] to i8*
; CHECK-NEXT: br i1 [[C1]], label [[LEFT]], label [[MERGE2]] ; CHECK-NEXT: br i1 [[C1]], label [[LEFT]], label [[MERGE2]]
; CHECK: left: ; CHECK: left:
; CHECK-NEXT: [[B5]] = addrspacecast i8* [[B4]] to i8 addrspace(1)* ; CHECK-NEXT: [[B5]] = addrspacecast i8* [[B4]] to i8 addrspace(1)*
; CHECK-NEXT: br i1 [[C2:%.*]], label [[LOOP]], label [[MERGE2]] ; CHECK-NEXT: br i1 [[C2:%.*]], label [[LOOP]], label [[MERGE2]]
; CHECK: merge2: ; CHECK: merge2:
; CHECK-NEXT: [[B6_BASE:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[ENTRY]] ], [ [[B2]], [[LOOP]] ], [ [[B2]], [[LEFT]] ], !is_base_value !0 ; CHECK-NEXT: [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[ENTRY]] ], [ [[B3]], [[LOOP]] ], [ [[B5]], [[LEFT]] ]
; CHECK-NEXT: [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1]], [[ENTRY]] ], [ [[B3]], [[LOOP]] ], [ [[B5]], [[LEFT]] ] ; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B6]]) ]
; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B6]], i8 addrspace(1)* [[B6_BASE]]) ] ; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
; CHECK-NEXT: [[B6_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
; CHECK-NEXT: ret i8 addrspace(1)* [[B6_RELOCATED]] ; CHECK-NEXT: ret i8 addrspace(1)* [[B6_RELOCATED]]
; ;
entry: entry:
br i1 %c1, label %loop, label %merge2 br i1 %c1, label %loop, label %merge2
loop: loop:
%b3 = phi i8 addrspace(1)* [ %b2, %entry ], [ %b5, %left ] %b3 = phi i8 addrspace(1)* [ %b2, %entry ], [ %b5, %left ]
%b4 = addrspacecast i8 addrspace(1)* %b3 to i8* %b4 = addrspacecast i8 addrspace(1)* %b3 to i8*
Show All 14 Lines
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[C1:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]] ; CHECK-NEXT: br i1 [[C1:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]]
; CHECK: loop: ; CHECK: loop:
; CHECK-NEXT: [[B3:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[ENTRY:%.*]] ], [ [[B3]], [[LEFT:%.*]] ] ; CHECK-NEXT: [[B3:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[ENTRY:%.*]] ], [ [[B3]], [[LEFT:%.*]] ]
; CHECK-NEXT: br i1 [[C1]], label [[LEFT]], label [[MERGE2]] ; CHECK-NEXT: br i1 [[C1]], label [[LEFT]], label [[MERGE2]]
; CHECK: left: ; CHECK: left:
; CHECK-NEXT: br i1 [[C2:%.*]], label [[LOOP]], label [[MERGE2]] ; CHECK-NEXT: br i1 [[C2:%.*]], label [[LOOP]], label [[MERGE2]]
; CHECK: merge2: ; CHECK: merge2:
; CHECK-NEXT: [[B6_BASE:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[ENTRY]] ], [ [[B2]], [[LOOP]] ], [ [[B2]], [[LEFT]] ], !is_base_value !0 ; CHECK-NEXT: [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[ENTRY]] ], [ [[B3]], [[LOOP]] ], [ [[B3]], [[LEFT]] ]
; CHECK-NEXT: [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1]], [[ENTRY]] ], [ [[B3]], [[LOOP]] ], [ [[B3]], [[LEFT]] ] ; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B6]]) ]
; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B6]], i8 addrspace(1)* [[B6_BASE]]) ] ; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
; CHECK-NEXT: [[B6_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
; CHECK-NEXT: ret i8 addrspace(1)* [[B6_RELOCATED]] ; CHECK-NEXT: ret i8 addrspace(1)* [[B6_RELOCATED]]
; ;
entry: entry:
br i1 %c1, label %loop, label %merge2 br i1 %c1, label %loop, label %merge2
loop: loop:
%b3 = phi i8 addrspace(1)* [ %b2, %entry ], [ %b4, %left ] %b3 = phi i8 addrspace(1)* [ %b2, %entry ], [ %b4, %left ]
br i1 %c1, label %left, label %merge2 br i1 %c1, label %left, label %merge2
Show All 10 Lines
declare i8 addrspace(1)* @returned_arg(i8 addrspace(1)* returned %p) declare i8 addrspace(1)* @returned_arg(i8 addrspace(1)* returned %p)
define i8 addrspace(1)* @test7(i1 %c1, i1 %c2, i8 addrspace(1)* %b1, i8 addrspace(1)* %b2) gc "statepoint-example" { define i8 addrspace(1)* @test7(i1 %c1, i1 %c2, i8 addrspace(1)* %b1, i8 addrspace(1)* %b2) gc "statepoint-example" {
; CHECK-LABEL: @test7( ; CHECK-LABEL: @test7(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[C1:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]] ; CHECK-NEXT: br i1 [[C1:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]]
; CHECK: loop: ; CHECK: loop:
; CHECK-NEXT: [[B3_BASE:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[ENTRY:%.*]] ], [ [[B41:%.*]], [[LEFT:%.*]] ], !is_base_value !0 ; CHECK-NEXT: [[B3:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[ENTRY:%.*]] ], [ [[B41:%.*]], [[LEFT:%.*]] ]
; CHECK-NEXT: [[B3:%.*]] = phi i8 addrspace(1)* [ [[B2]], [[ENTRY]] ], [ [[B41]], [[LEFT]] ]
; CHECK-NEXT: br i1 [[C1]], label [[LEFT]], label [[MERGE2]] ; CHECK-NEXT: br i1 [[C1]], label [[LEFT]], label [[MERGE2]]
; CHECK: left: ; CHECK: left:
; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, i8 addrspace(1)* (i8 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i8p1i8f(i64 2882400000, i32 0, i8 addrspace(1)* (i8 addrspace(1)*)* elementtype(i8 addrspace(1)* (i8 addrspace(1)*)) @returned_arg, i32 1, i32 0, i8 addrspace(1)* [[B3]], i32 0, i32 0) [ "gc-live"(i8 addrspace(1)* [[B3_BASE]], i8 addrspace(1)* [[B3]]) ] ; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, i8 addrspace(1)* (i8 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i8p1i8f(i64 2882400000, i32 0, i8 addrspace(1)* (i8 addrspace(1)*)* elementtype(i8 addrspace(1)* (i8 addrspace(1)*)) @returned_arg, i32 1, i32 0, i8 addrspace(1)* [[B3]], i32 0, i32 0) [ "gc-live"(i8 addrspace(1)* [[B3]]) ]
; CHECK-NEXT: [[B41]] = call i8 addrspace(1)* @llvm.experimental.gc.result.p1i8(token [[STATEPOINT_TOKEN]]) ; CHECK-NEXT: [[B41]] = call i8 addrspace(1)* @llvm.experimental.gc.result.p1i8(token [[STATEPOINT_TOKEN]])
; CHECK-NEXT: [[B3_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0) ; CHECK-NEXT: [[B3_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
; CHECK-NEXT: [[B3_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 1)
; CHECK-NEXT: br i1 [[C2:%.*]], label [[LOOP]], label [[MERGE2]] ; CHECK-NEXT: br i1 [[C2:%.*]], label [[LOOP]], label [[MERGE2]]
; CHECK: merge2: ; CHECK: merge2:
; CHECK-NEXT: [[B6_BASE:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[ENTRY]] ], [ [[B3_BASE]], [[LOOP]] ], [ [[B41]], [[LEFT]] ], !is_base_value !0 ; CHECK-NEXT: [[B6_BASE:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[ENTRY]] ], [ [[B3]], [[LOOP]] ], [ [[B41]], [[LEFT]] ], !is_base_value !0
; CHECK-NEXT: [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1]], [[ENTRY]] ], [ [[B3]], [[LOOP]] ], [ [[B41]], [[LEFT]] ] ; CHECK-NEXT: [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1]], [[ENTRY]] ], [ [[B3]], [[LOOP]] ], [ [[B41]], [[LEFT]] ]
; CHECK-NEXT: [[STATEPOINT_TOKEN2:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B6]], i8 addrspace(1)* [[B6_BASE]]) ] ; CHECK-NEXT: [[STATEPOINT_TOKEN2:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B6]], i8 addrspace(1)* [[B6_BASE]]) ]
; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN2]], i32 1, i32 0) ; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN2]], i32 1, i32 0)
; CHECK-NEXT: [[B6_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN2]], i32 1, i32 1) ; CHECK-NEXT: [[B6_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN2]], i32 1, i32 1)
; CHECK-NEXT: ret i8 addrspace(1)* [[B6_RELOCATED]] ; CHECK-NEXT: ret i8 addrspace(1)* [[B6_RELOCATED]]
; ;
entry: entry:
br i1 %c1, label %loop, label %merge2 br i1 %c1, label %loop, label %merge2
Show All 23 Lines
; CHECK-NEXT: [[B4:%.*]] = bitcast i8 addrspace(1)* [[B3]] to i32 addrspace(1)* ; CHECK-NEXT: [[B4:%.*]] = bitcast i8 addrspace(1)* [[B3]] to i32 addrspace(1)*
; CHECK-NEXT: [[B5]] = bitcast i32 addrspace(1)* [[B4]] to i8 addrspace(1)* ; CHECK-NEXT: [[B5]] = bitcast i32 addrspace(1)* [[B4]] to i8 addrspace(1)*
; CHECK-NEXT: switch i32 [[N:%.*]], label [[MERGE2]] [ ; CHECK-NEXT: switch i32 [[N:%.*]], label [[MERGE2]] [
; CHECK-NEXT: i32 0, label [[LOOP]] ; CHECK-NEXT: i32 0, label [[LOOP]]
; CHECK-NEXT: i32 1, label [[LOOP]] ; CHECK-NEXT: i32 1, label [[LOOP]]
; CHECK-NEXT: i32 2, label [[LEFT]] ; CHECK-NEXT: i32 2, label [[LEFT]]
; CHECK-NEXT: ] ; CHECK-NEXT: ]
; CHECK: merge2: ; CHECK: merge2:
; CHECK-NEXT: [[B6_BASE:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[LEFT]] ], [ [[B2]], [[LOOP]] ], !is_base_value !0 ; CHECK-NEXT: [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[LEFT]] ], [ [[B5]], [[LOOP]] ]
; CHECK-NEXT: [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1]], [[LEFT]] ], [ [[B5]], [[LOOP]] ] ; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B6]]) ]
; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B6]], i8 addrspace(1)* [[B6_BASE]]) ] ; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
; CHECK-NEXT: [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
; CHECK-NEXT: [[B6_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
; CHECK-NEXT: ret i8 addrspace(1)* [[B6_RELOCATED]] ; CHECK-NEXT: ret i8 addrspace(1)* [[B6_RELOCATED]]
; ;
entry: entry:
br label %left br label %left
left: left:
br i1 %c, label %loop, label %merge2 br i1 %c, label %loop, label %merge2
Show All 13 Lines