Skip to content

[InstCombinePHI] Enhance PHI CSE to remove redundant phis #163453

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 6 commits into from
Oct 21, 2025
+334 −1
Merged

[InstCombinePHI] Enhance PHI CSE to remove redundant phis #163453

Show file tree
Hide file tree
Changes from 5 commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
4715789
[InstCombinePHI] Enhance PHI CSE to remove redundant phis
CongzheUalberta Oct 14, 2025
fbc4a5f
address reviewer's comments
CongzheUalberta Oct 15, 2025
4cfc7bf
Address reviewer's comments and simplify the code.
CongzheUalberta Oct 17, 2025
ee823bc
Re-implemented in InstSimplify.
CongzheUalberta Oct 20, 2025
60777d5
Address reviewer's comments made on Oct 21st.
CongzheUalberta Oct 21, 2025
4d8a564
Address reviewer's comments made on Oct 21st, 2nd part.
CongzheUalberta Oct 21, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
92 changes: 91 additions & 1 deletion llvm/lib/Analysis/InstructionSimplify.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4866,6 +4866,89 @@ static Value *simplifySelectWithFCmp(Value *Cond, Value *T, Value *F,
return nullptr;
}

/// Look for the following pattern and simplify %1 to %identicalPhi.
/// Here %phi, %1 and %phi.next perform the same functionality as
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

It would be better to give %1 a meaningful name.

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I've changed %1 to %to_fold.

/// %identicalPhi and hence the select instruction %1 can be folded
/// into %identicalPhi.
///
/// BB1:
/// %identicalPhi = phi [ X, %BB0 ], [ %identicalPhi.next, %BB1 ]
/// %phi = phi [ X, %BB0 ], [ %phi.next, %BB1 ]
/// ...
/// %identicalPhi.next = select %cmp, %val, %identicalPhi
/// (or select %cmp, %identicalPhi, %val)
/// %1 = select %cmp2, %identicalPhi, %phi
/// %phi.next = select %cmp, %val, %1
/// (or select %cmp, %1, %val)
///
/// Prove that %phi and %identicalPhi are the same by induction:
///
/// Base case: Both %phi and %identicalPhi are equal on entry to the loop.
/// Inductive case:
/// Suppose %phi and %identicalPhi are equal at iteration i.
/// We look at their values at iteration i+1 which are %phi.next and
/// %identicalPhi.next. They would have become different only when %cmp is
/// false and the corresponding values %1 and %identicalPhi differ
/// (similar reason for the other "or" case in the bracket).
///
/// The only condition when %1 and %identicalPh could differ is when %cmp2
/// is false and %1 is %phi, which contradicts our inductive hypothesis
/// that %phi and %identicalPhi are equal. Thus %phi and %identicalPhi are
/// always equal at iteration i+1.
bool isSimplifierIdenticalPHI(PHINode &PN, PHINode &IdenticalPN) {
if (PN.getParent() != IdenticalPN.getParent())
return false;
if (PN.getNumIncomingValues() != 2)
return false;

// Check that only the backedge incoming value is different.
unsigned DiffVals = 0;
BasicBlock *DiffValBB = nullptr;
for (unsigned i = 0; i < 2; i++) {
BasicBlock *PredBB = PN.getIncomingBlock(i);
if (PN.getIncomingValueForBlock(PredBB) !=
IdenticalPN.getIncomingValueForBlock(PredBB)) {
DiffVals++;
DiffValBB = PredBB;
}
}
if (DiffVals != 1)
return false;
// Now check that the backedge incoming values are two select
// instructions with the same condition. Either their true
// values are the same, or their false values are the same.
auto *SI = dyn_cast<SelectInst>(PN.getIncomingValueForBlock(DiffValBB));
auto *IdenticalSI =
dyn_cast<SelectInst>(IdenticalPN.getIncomingValueForBlock(DiffValBB));
if (!SI || !IdenticalSI)
return false;
if (SI->getCondition() != IdenticalSI->getCondition())
return false;

SelectInst *SIOtherVal = nullptr;
Value *IdenticalSIOtherVal = nullptr;
if (SI->getTrueValue() == IdenticalSI->getTrueValue()) {
SIOtherVal = dyn_cast<SelectInst>(SI->getFalseValue());
IdenticalSIOtherVal = IdenticalSI->getFalseValue();
} else if (SI->getFalseValue() == IdenticalSI->getFalseValue()) {
SIOtherVal = dyn_cast<SelectInst>(SI->getTrueValue());
IdenticalSIOtherVal = IdenticalSI->getTrueValue();
} else {
return false;
}
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Suggested change
}
} else {
return false;
}

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Updated accordingly.


// Now check that the other values in select, i.e., %1 and %identicalPhi,
// are essentially the same value within the same BB.
if (!SIOtherVal || IdenticalSIOtherVal != &IdenticalPN)
return false;
if (!(SIOtherVal->getTrueValue() == &IdenticalPN &&
SIOtherVal->getFalseValue() == &PN) &&
!(SIOtherVal->getTrueValue() == &PN &&
SIOtherVal->getFalseValue() == &IdenticalPN))
return false;
return true;
}

/// Given operands for a SelectInst, see if we can fold the result.
/// If not, this returns null.
static Value *simplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal,
Expand Down Expand Up @@ -5041,7 +5124,14 @@ static Value *simplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal,
std::optional<bool> Imp = isImpliedByDomCondition(Cond, Q.CxtI, Q.DL);
if (Imp)
return *Imp ? TrueVal : FalseVal;

// Look for same PHIs in the true and false values.
if (auto *TruePHI = dyn_cast<PHINode>(TrueVal))
if (auto *FalsePHI = dyn_cast<PHINode>(FalseVal)) {
if (isSimplifierIdenticalPHI(*TruePHI, *FalsePHI))
return FalseVal;
if (isSimplifierIdenticalPHI(*FalsePHI, *TruePHI))
return TrueVal;
}
return nullptr;
}

Expand Down
243 changes: 243 additions & 0 deletions llvm/test/Transforms/InstCombine/select_with_identical_phi.ll
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,243 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -S -passes=instcombine | FileCheck %s
@A = extern_weak global float, align 4

; %same.as.v1 is a select with two phis %v1 and %phi.to.remove as the true
; and false values, while %v1 and %phi.to.remove are actually the same.
; Fold the selection instruction %same.as.v1 to %v1.
define void @select_with_identical_phi(ptr %m, ptr %n, i32 %count) {
; CHECK-LABEL: @select_with_identical_phi(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[FOR_BODY:%.*]]
; CHECK: for.body:
; CHECK-NEXT: [[V0:%.*]] = phi float [ 0x4415AF1D80000000, [[ENTRY:%.*]] ], [ [[V0_1:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[V1:%.*]] = phi float [ 0xC415AF1D80000000, [[ENTRY]] ], [ [[V1_1:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[I:%.*]] = phi i32 [ 0, [[ENTRY]] ], [ [[INC_I:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[Q:%.*]] = phi ptr [ [[M:%.*]], [[ENTRY]] ], [ [[Q_NEXT:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[C:%.*]] = phi ptr [ [[N:%.*]], [[ENTRY]] ], [ [[C_NEXT:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[Q_LOAD:%.*]] = load float, ptr [[Q]], align 4
; CHECK-NEXT: [[C_LOAD:%.*]] = load float, ptr [[C]], align 4
; CHECK-NEXT: [[SUB:%.*]] = fsub float [[Q_LOAD]], [[C_LOAD]]
; CHECK-NEXT: [[CMP1:%.*]] = fcmp olt float [[SUB]], [[V0]]
; CHECK-NEXT: [[V0_1]] = select i1 [[CMP1]], float [[SUB]], float [[V0]]
; CHECK-NEXT: [[CMP2:%.*]] = fcmp ogt float [[SUB]], [[V1]]
; CHECK-NEXT: [[V1_1]] = select i1 [[CMP2]], float [[SUB]], float [[V1]]
; CHECK-NEXT: [[INC_I]] = add nuw nsw i32 [[I]], 1
; CHECK-NEXT: [[Q_NEXT]] = getelementptr inbounds nuw i8, ptr [[Q]], i64 4
; CHECK-NEXT: [[C_NEXT]] = getelementptr inbounds nuw i8, ptr [[C]], i64 4
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp eq i32 [[INC_I]], [[COUNT:%.*]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[EXIT:%.*]], label [[FOR_BODY]]
; CHECK: exit:
; CHECK-NEXT: store float [[V1_1]], ptr @A, align 4
; CHECK-NEXT: ret void
;
entry:
br label %for.body

for.body: ; preds = %entry, %for.body
%v0 = phi float [ 0x4415AF1D80000000, %entry ], [ %v0.1, %for.body ]
%v1 = phi float [ 0xC415AF1D80000000, %entry ], [ %v1.1, %for.body ]
%phi.to.remove = phi float [ 0xC415AF1D80000000, %entry ], [ %phi.to.remove.next, %for.body ]
%i = phi i32 [ 0, %entry ], [ %inc.i, %for.body ]
%q = phi ptr [ %m, %entry ], [ %q.next, %for.body ]
%c = phi ptr [ %n, %entry ], [ %c.next, %for.body ]
%q.load = load float, ptr %q
%c.load = load float, ptr %c
%sub = fsub float %q.load, %c.load
%cmp1 = fcmp olt float %sub, %v0
%v0.1 = select i1 %cmp1, float %sub, float %v0
%same.as.v1 = select i1 %cmp1, float %v1, float %phi.to.remove
%cmp2 = fcmp ogt float %sub, %same.as.v1
%v1.1 = select i1 %cmp2, float %sub, float %v1
%phi.to.remove.next = select i1 %cmp2, float %sub, float %same.as.v1
%inc.i = add nuw nsw i32 %i, 1
%q.next = getelementptr inbounds i8, ptr %q, i64 4
%c.next = getelementptr inbounds i8, ptr %c, i64 4
%exitcond = icmp eq i32 %inc.i, %count
br i1 %exitcond, label %exit, label %for.body

exit:
%vl.1.lcssa = phi float [ %v1.1, %for.body ]
store float %vl.1.lcssa, ptr @A
ret void
}

; The difference from select_with_identical_phi() is that the true and false values in
; %phi.to.remove.next and %v1.1 are swapped.
; Check that %same.as.v1 can be folded.
define void @select_with_identical_phi_2(ptr %m, ptr %n, i32 %count) {
; CHECK-LABEL: @select_with_identical_phi_2(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[FOR_BODY:%.*]]
; CHECK: for.body:
; CHECK-NEXT: [[V0:%.*]] = phi float [ 0x4415AF1D80000000, [[ENTRY:%.*]] ], [ [[V0_1:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[V1:%.*]] = phi float [ 0xC415AF1D80000000, [[ENTRY]] ], [ [[V1_1:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[I:%.*]] = phi i32 [ 0, [[ENTRY]] ], [ [[INC_I:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[Q:%.*]] = phi ptr [ [[M:%.*]], [[ENTRY]] ], [ [[Q_NEXT:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[C:%.*]] = phi ptr [ [[N:%.*]], [[ENTRY]] ], [ [[C_NEXT:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[Q_LOAD:%.*]] = load float, ptr [[Q]], align 4
; CHECK-NEXT: [[C_LOAD:%.*]] = load float, ptr [[C]], align 4
; CHECK-NEXT: [[SUB:%.*]] = fsub float [[Q_LOAD]], [[C_LOAD]]
; CHECK-NEXT: [[CMP1:%.*]] = fcmp olt float [[SUB]], [[V0]]
; CHECK-NEXT: [[V0_1]] = select i1 [[CMP1]], float [[SUB]], float [[V0]]
; CHECK-NEXT: [[CMP2:%.*]] = fcmp ogt float [[SUB]], [[V1]]
; CHECK-NEXT: [[V1_1]] = select i1 [[CMP2]], float [[V1]], float [[SUB]]
; CHECK-NEXT: [[INC_I]] = add nuw nsw i32 [[I]], 1
; CHECK-NEXT: [[Q_NEXT]] = getelementptr inbounds nuw i8, ptr [[Q]], i64 4
; CHECK-NEXT: [[C_NEXT]] = getelementptr inbounds nuw i8, ptr [[C]], i64 4
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp eq i32 [[INC_I]], [[COUNT:%.*]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[EXIT:%.*]], label [[FOR_BODY]]
; CHECK: exit:
; CHECK-NEXT: store float [[V1_1]], ptr @A, align 4
; CHECK-NEXT: ret void
;
entry:
br label %for.body

for.body: ; preds = %entry, %for.body
%v0 = phi float [ 0x4415AF1D80000000, %entry ], [ %v0.1, %for.body ]
%v1 = phi float [ 0xC415AF1D80000000, %entry ], [ %v1.1, %for.body ]
%phi.to.remove = phi float [ 0xC415AF1D80000000, %entry ], [ %phi.to.remove.next, %for.body ]
%i = phi i32 [ 0, %entry ], [ %inc.i, %for.body ]
%q = phi ptr [ %m, %entry ], [ %q.next, %for.body ]
%c = phi ptr [ %n, %entry ], [ %c.next, %for.body ]
%q.load = load float, ptr %q
%c.load = load float, ptr %c
%sub = fsub float %q.load, %c.load
%cmp1 = fcmp olt float %sub, %v0
%v0.1 = select i1 %cmp1, float %sub, float %v0
%same.as.v1 = select i1 %cmp1, float %v1, float %phi.to.remove
%cmp2 = fcmp ogt float %sub, %same.as.v1
%v1.1 = select i1 %cmp2, float %v1, float %sub
%phi.to.remove.next = select i1 %cmp2, float %same.as.v1, float %sub
%inc.i = add nuw nsw i32 %i, 1
%q.next = getelementptr inbounds i8, ptr %q, i64 4
%c.next = getelementptr inbounds i8, ptr %c, i64 4
%exitcond = icmp eq i32 %inc.i, %count
br i1 %exitcond, label %exit, label %for.body

exit:
%vl.1.lcssa = phi float [ %v1.1, %for.body ]
store float %vl.1.lcssa, ptr @A
ret void
}

; The difference from select_with_identical_phi() is that the true and false values in
; same.as.v1 are swapped.
; Check that %same.as.v1 can be folded.
define void @select_with_identical_phi_3(ptr %m, ptr %n, i32 %count) {
; CHECK-LABEL: @select_with_identical_phi_3(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[FOR_BODY:%.*]]
; CHECK: for.body:
; CHECK-NEXT: [[V0:%.*]] = phi float [ 0x4415AF1D80000000, [[ENTRY:%.*]] ], [ [[V0_1:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[V1:%.*]] = phi float [ 0xC415AF1D80000000, [[ENTRY]] ], [ [[V1_1:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[I:%.*]] = phi i32 [ 0, [[ENTRY]] ], [ [[INC_I:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[Q:%.*]] = phi ptr [ [[M:%.*]], [[ENTRY]] ], [ [[Q_NEXT:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[C:%.*]] = phi ptr [ [[N:%.*]], [[ENTRY]] ], [ [[C_NEXT:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[Q_LOAD:%.*]] = load float, ptr [[Q]], align 4
; CHECK-NEXT: [[C_LOAD:%.*]] = load float, ptr [[C]], align 4
; CHECK-NEXT: [[SUB:%.*]] = fsub float [[Q_LOAD]], [[C_LOAD]]
; CHECK-NEXT: [[CMP1:%.*]] = fcmp olt float [[SUB]], [[V0]]
; CHECK-NEXT: [[V0_1]] = select i1 [[CMP1]], float [[SUB]], float [[V0]]
; CHECK-NEXT: [[CMP2:%.*]] = fcmp ogt float [[SUB]], [[V1]]
; CHECK-NEXT: [[V1_1]] = select i1 [[CMP2]], float [[SUB]], float [[V1]]
; CHECK-NEXT: [[INC_I]] = add nuw nsw i32 [[I]], 1
; CHECK-NEXT: [[Q_NEXT]] = getelementptr inbounds nuw i8, ptr [[Q]], i64 4
; CHECK-NEXT: [[C_NEXT]] = getelementptr inbounds nuw i8, ptr [[C]], i64 4
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp eq i32 [[INC_I]], [[COUNT:%.*]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[EXIT:%.*]], label [[FOR_BODY]]
; CHECK: exit:
; CHECK-NEXT: store float [[V1_1]], ptr @A, align 4
; CHECK-NEXT: ret void
;
entry:
br label %for.body

for.body: ; preds = %entry, %for.body
%v0 = phi float [ 0x4415AF1D80000000, %entry ], [ %v0.1, %for.body ]
%v1 = phi float [ 0xC415AF1D80000000, %entry ], [ %v1.1, %for.body ]
%phi.to.remove = phi float [ 0xC415AF1D80000000, %entry ], [ %phi.to.remove.next, %for.body ]
%i = phi i32 [ 0, %entry ], [ %inc.i, %for.body ]
%q = phi ptr [ %m, %entry ], [ %q.next, %for.body ]
%c = phi ptr [ %n, %entry ], [ %c.next, %for.body ]
%q.load = load float, ptr %q
%c.load = load float, ptr %c
%sub = fsub float %q.load, %c.load
%cmp1 = fcmp olt float %sub, %v0
%v0.1 = select i1 %cmp1, float %sub, float %v0
%same.as.v1 = select i1 %cmp1, float %phi.to.remove, float %v1
%cmp2 = fcmp ogt float %sub, %same.as.v1
%v1.1 = select i1 %cmp2, float %sub, float %v1
%phi.to.remove.next = select i1 %cmp2, float %sub, float %same.as.v1
%inc.i = add nuw nsw i32 %i, 1
%q.next = getelementptr inbounds i8, ptr %q, i64 4
%c.next = getelementptr inbounds i8, ptr %c, i64 4
%exitcond = icmp eq i32 %inc.i, %count
br i1 %exitcond, label %exit, label %for.body

exit:
%vl.1.lcssa = phi float [ %v1.1, %for.body ]
store float %vl.1.lcssa, ptr @A
ret void
}

; The difference from select_with_identical_phi() is that the true and false values in
; %same.as.v1, %phi.to.remove.next and %v1.1 are swapped.
; Check that %same.as.v1 can be folded.
define void @select_with_identical_phi_4(ptr %m, ptr %n, i32 %count) {
; CHECK-LABEL: @select_with_identical_phi_4(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[FOR_BODY:%.*]]
; CHECK: for.body:
; CHECK-NEXT: [[V0:%.*]] = phi float [ 0x4415AF1D80000000, [[ENTRY:%.*]] ], [ [[V0_1:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[V1:%.*]] = phi float [ 0xC415AF1D80000000, [[ENTRY]] ], [ [[V1_1:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[I:%.*]] = phi i32 [ 0, [[ENTRY]] ], [ [[INC_I:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[Q:%.*]] = phi ptr [ [[M:%.*]], [[ENTRY]] ], [ [[Q_NEXT:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[C:%.*]] = phi ptr [ [[N:%.*]], [[ENTRY]] ], [ [[C_NEXT:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[Q_LOAD:%.*]] = load float, ptr [[Q]], align 4
; CHECK-NEXT: [[C_LOAD:%.*]] = load float, ptr [[C]], align 4
; CHECK-NEXT: [[SUB:%.*]] = fsub float [[Q_LOAD]], [[C_LOAD]]
; CHECK-NEXT: [[CMP1:%.*]] = fcmp olt float [[SUB]], [[V0]]
; CHECK-NEXT: [[V0_1]] = select i1 [[CMP1]], float [[SUB]], float [[V0]]
; CHECK-NEXT: [[CMP2:%.*]] = fcmp ogt float [[SUB]], [[V1]]
; CHECK-NEXT: [[V1_1]] = select i1 [[CMP2]], float [[V1]], float [[SUB]]
; CHECK-NEXT: [[INC_I]] = add nuw nsw i32 [[I]], 1
; CHECK-NEXT: [[Q_NEXT]] = getelementptr inbounds nuw i8, ptr [[Q]], i64 4
; CHECK-NEXT: [[C_NEXT]] = getelementptr inbounds nuw i8, ptr [[C]], i64 4
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp eq i32 [[INC_I]], [[COUNT:%.*]]
; CHECK-NEXT: br i1 [[EXITCOND]], label [[EXIT:%.*]], label [[FOR_BODY]]
; CHECK: exit:
; CHECK-NEXT: store float [[V1_1]], ptr @A, align 4
; CHECK-NEXT: ret void
;
entry:
br label %for.body

for.body: ; preds = %entry, %for.body
%v0 = phi float [ 0x4415AF1D80000000, %entry ], [ %v0.1, %for.body ]
%v1 = phi float [ 0xC415AF1D80000000, %entry ], [ %v1.1, %for.body ]
%phi.to.remove = phi float [ 0xC415AF1D80000000, %entry ], [ %phi.to.remove.next, %for.body ]
%i = phi i32 [ 0, %entry ], [ %inc.i, %for.body ]
%q = phi ptr [ %m, %entry ], [ %q.next, %for.body ]
%c = phi ptr [ %n, %entry ], [ %c.next, %for.body ]
%q.load = load float, ptr %q
%c.load = load float, ptr %c
%sub = fsub float %q.load, %c.load
%cmp1 = fcmp olt float %sub, %v0
%v0.1 = select i1 %cmp1, float %sub, float %v0
%same.as.v1 = select i1 %cmp1, float %phi.to.remove, float %v1
%cmp2 = fcmp ogt float %sub, %same.as.v1
%v1.1 = select i1 %cmp2, float %v1, float %sub
%phi.to.remove.next = select i1 %cmp2, float %same.as.v1, float %sub
%inc.i = add nuw nsw i32 %i, 1
%q.next = getelementptr inbounds i8, ptr %q, i64 4
%c.next = getelementptr inbounds i8, ptr %c, i64 4
%exitcond = icmp eq i32 %inc.i, %count
br i1 %exitcond, label %exit, label %for.body

exit:
%vl.1.lcssa = phi float [ %v1.1, %for.body ]
store float %vl.1.lcssa, ptr @A
ret void
}
Loading