This is an archive of the discontinued LLVM Phabricator instance.

Differential D126697

[Flang] Lower the infinite do loop
ClosedPublic

Authored by kiranchandramohan on May 31 2022, 6:26 AM.

Details

Reviewers
vdonaldson
schweitz
rovka
awarzynski
clementval
sscalpone
Commits
rG8c349d707ec2: [Flang] Lower the infinite do loop
Summary

The basic infinite loop is lowered to a branch to the body of the
loop, and the body containing a back edge as its terminator.

Note: This is part of upstreaming from the fir-dev branch of
https://github.com/flang-compiler/f18-llvm-project.

Co-authored-by: Eric Schweitz <eschweitz@nvidia.com>
Co-authored-by: V Donaldson <vdonaldson@nvidia.com>

Diff Detail

Event Timeline

kiranchandramohan created this revision.May 31 2022, 6:26 AM
Herald added a reviewer: sscalpone. · View Herald TranscriptMay 31 2022, 6:26 AM
Herald added projects: Restricted Project, Restricted Project. · View Herald Transcript
Herald added a subscriber: mehdi_amini. · View Herald Transcript
kiranchandramohan requested review of this revision.May 31 2022, 6:26 AM
Herald added a subscriber: jdoerfert. · View Herald TranscriptMay 31 2022, 6:26 AM
Harbormaster completed remote builds in B167031: Diff 433067.May 31 2022, 6:41 AM
rovka accepted this revision.Jun 1 2022, 3:56 AM

LGTM, thanks.

This revision is now accepted and ready to land.Jun 1 2022, 3:56 AM
Closed by commit rG8c349d707ec2: [Flang] Lower the infinite do loop (authored by kiranchandramohan). · Explain WhyJun 1 2022, 5:07 AM
This revision was automatically updated to reflect the committed changes.
kiranchandramohan added a commit: rG8c349d707ec2: [Flang] Lower the infinite do loop.

Revision Contents

PathSize
flang/
lib/
Lower/
18 lines
test/
Lower/
126 lines

Diff 433359

flang/lib/Lower/Bridge.cpp

Show First 20 Lines • Show All 977 Lines • ▼ Show 20 Lines auto createNextBeginBlock = [&]() {
return beginBlock = beginBlock->splitBlock(beginBlock->end()); return beginBlock = beginBlock->splitBlock(beginBlock->end());
}; };
mlir::Block *headerBlock = mlir::Block *headerBlock =
unstructuredContext ? createNextBeginBlock() : nullptr; unstructuredContext ? createNextBeginBlock() : nullptr;
mlir::Block *bodyBlock = doStmtEval.lexicalSuccessor->block; mlir::Block *bodyBlock = doStmtEval.lexicalSuccessor->block;
mlir::Block *exitBlock = doStmtEval.parentConstruct->constructExit->block; mlir::Block *exitBlock = doStmtEval.parentConstruct->constructExit->block;
IncrementLoopNestInfo incrementLoopNestInfo; IncrementLoopNestInfo incrementLoopNestInfo;
const Fortran::parser::ScalarLogicalExpr *whileCondition = nullptr; const Fortran::parser::ScalarLogicalExpr *whileCondition = nullptr;
if ((whileCondition = std::get_if<Fortran::parser::ScalarLogicalExpr>( bool infiniteLoop = !loopControl.has_value();
if (infiniteLoop) {
assert(unstructuredContext && "infinite loop must be unstructured");
startBlock(headerBlock);
} else if ((whileCondition =
std::get_if<Fortran::parser::ScalarLogicalExpr>(
&loopControl->u))) { &loopControl->u))) {
assert(unstructuredContext && "while loop must be unstructured"); assert(unstructuredContext && "while loop must be unstructured");
maybeStartBlock(preheaderBlock); // no block or empty block maybeStartBlock(preheaderBlock); // no block or empty block
startBlock(headerBlock); startBlock(headerBlock);
genFIRConditionalBranch(*whileCondition, bodyBlock, exitBlock); genFIRConditionalBranch(*whileCondition, bodyBlock, exitBlock);
} else if (const auto *bounds = } else if (const auto *bounds =
std::get_if<Fortran::parser::LoopControl::Bounds>( std::get_if<Fortran::parser::LoopControl::Bounds>(
&loopControl->u)) { &loopControl->u)) {
// Non-concurrent increment loop. // Non-concurrent increment loop.
IncrementLoopInfo &info = incrementLoopNestInfo.emplace_back( IncrementLoopInfo &info = incrementLoopNestInfo.emplace_back(
*bounds->name.thing.symbol, bounds->lower, bounds->upper, *bounds->name.thing.symbol, bounds->lower, bounds->upper,
bounds->step); bounds->step);
if (unstructuredContext) { if (unstructuredContext) {
maybeStartBlock(preheaderBlock); maybeStartBlock(preheaderBlock);
info.hasRealControl = info.loopVariableSym.GetType()->IsNumeric( info.hasRealControl = info.loopVariableSym.GetType()->IsNumeric(
Fortran::common::TypeCategory::Real); Fortran::common::TypeCategory::Real);
info.headerBlock = headerBlock; info.headerBlock = headerBlock;
info.bodyBlock = bodyBlock; info.bodyBlock = bodyBlock;
info.exitBlock = exitBlock; info.exitBlock = exitBlock;
} }
} else { } else {
TODO(toLocation(), "infinite/unstructured loop/concurrent loop"); TODO(toLocation(), "infinite/unstructured loop/concurrent loop");
} }
// Increment loop begin code. (TODO: Infinite/while code was already // Increment loop begin code. (Infinite/while code was already generated.)
// generated.) if (!infiniteLoop && !whileCondition)
if (!whileCondition)
genFIRIncrementLoopBegin(incrementLoopNestInfo); genFIRIncrementLoopBegin(incrementLoopNestInfo);
// Loop body code - NonLabelDoStmt and EndDoStmt code is generated here. // Loop body code - NonLabelDoStmt and EndDoStmt code is generated here.
// Their genFIR calls are nops except for block management in some cases. // Their genFIR calls are nops except for block management in some cases.
for (Fortran::lower::pft::Evaluation &e : eval.getNestedEvaluations()) for (Fortran::lower::pft::Evaluation &e : eval.getNestedEvaluations())
genFIR(e, unstructuredContext); genFIR(e, unstructuredContext);
// Loop end code. (TODO: infinite loop) // Loop end code.
if (whileCondition) if (infiniteLoop || whileCondition)
genFIRBranch(headerBlock); genFIRBranch(headerBlock);
else else
genFIRIncrementLoopEnd(incrementLoopNestInfo); genFIRIncrementLoopEnd(incrementLoopNestInfo);
} }
/// Generate FIR to begin a structured or unstructured increment loop nest. /// Generate FIR to begin a structured or unstructured increment loop nest.
void genFIRIncrementLoopBegin(IncrementLoopNestInfo &incrementLoopNestInfo) { void genFIRIncrementLoopBegin(IncrementLoopNestInfo &incrementLoopNestInfo) {
assert(!incrementLoopNestInfo.empty() && "empty loop nest"); assert(!incrementLoopNestInfo.empty() && "empty loop nest");
▲ Show 20 Lines • Show All 2,022 Lines • Show Last 20 Lines

flang/test/Lower/infinite_loop.f90

  • This file was added.
! RUN: bbc -emit-fir -o - %s | FileCheck %s
! RUN: %flang_fc1 -emit-fir -o - %s | FileCheck %s
! Tests for infinite loop.
subroutine empty_infinite()
do
end do
end subroutine
! CHECK-LABEL: empty_infinite
! CHECK: cf.br ^[[BODY:.*]]
! CHECK: ^[[BODY]]:
! CHECK: cf.br ^[[BODY]]
subroutine simple_infinite(i)
integer :: i
do
if (i .gt. 100) exit
end do
end subroutine
! CHECK-LABEL: simple_infinite
! CHECK-SAME: %[[I_REF:.*]]: !fir.ref<i32>
! CHECK: cf.br ^[[BODY1:.*]]
! CHECK: ^[[BODY1]]:
! CHECK: %[[I:.*]] = fir.load %[[I_REF]] : !fir.ref<i32>
! CHECK: %[[C100:.*]] = arith.constant 100 : i32
! CHECK: %[[COND:.*]] = arith.cmpi sgt, %[[I]], %[[C100]] : i32
! CHECK: cf.cond_br %[[COND]], ^[[EXIT:.*]], ^[[BODY1:.*]]
! CHECK: ^[[EXIT]]:
! CHECK: cf.br ^[[RETURN:.*]]
! CHECK: ^[[RETURN]]:
! CHECK: return
! CHECK: }
subroutine infinite_with_two_body_blocks(i)
integer :: i
do
i = i + 1
if (i .gt. 100) exit
i = i * 2
end do
end subroutine
! CHECK-LABEL: infinite_with_two_body_blocks
! CHECK-SAME: %[[I_REF:.*]]: !fir.ref<i32>
! CHECK: cf.br ^[[BODY1:.*]]
! CHECK: ^[[BODY1]]:
! CHECK: %[[I:.*]] = fir.load %[[I_REF]] : !fir.ref<i32>
! CHECK: %[[C1:.*]] = arith.constant 1 : i32
! CHECK: %[[I_NEXT:.*]] = arith.addi %[[I]], %[[C1]] : i32
! CHECK: fir.store %[[I_NEXT]] to %[[I_REF]] : !fir.ref<i32>
! CHECK: %[[I:.*]] = fir.load %[[I_REF]] : !fir.ref<i32>
! CHECK: %[[C100:.*]] = arith.constant 100 : i32
! CHECK: %[[COND:.*]] = arith.cmpi sgt, %[[I]], %[[C100]] : i32
! CHECK: cf.cond_br %[[COND]], ^[[EXIT:.*]], ^[[BODY2:.*]]
! CHECK: ^[[EXIT]]:
! CHECK: cf.br ^[[RETURN:.*]]
! CHECK: ^[[BODY2]]:
! CHECK: %[[C2:.*]] = arith.constant 2 : i32
! CHECK: %[[I:.*]] = fir.load %[[I_REF]] : !fir.ref<i32>
! CHECK: %[[I_NEXT:.*]] = arith.muli %[[C2]], %[[I]] : i32
! CHECK: fir.store %[[I_NEXT]] to %[[I_REF]] : !fir.ref<i32>
! CHECK: cf.br ^[[BODY1]]
! CHECK: ^[[RETURN]]:
! CHECK: return
! CHECK: }
subroutine structured_loop_in_infinite(i)
integer :: i
integer :: j
do
if (i .gt. 100) exit
do j=1,10
end do
end do
end subroutine
! CHECK-LABEL: structured_loop_in_infinite
! CHECK-SAME: %[[I_REF:.*]]: !fir.ref<i32>
! CHECK: %[[J_REF:.*]] = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFstructured_loop_in_infiniteEj"}
! CHECK: cf.br ^[[BODY1:.*]]
! CHECK: ^[[BODY1]]:
! CHECK: %[[I:.*]] = fir.load %[[I_REF]] : !fir.ref<i32>
! CHECK: %[[C100:.*]] = arith.constant 100 : i32
! CHECK: %[[COND:.*]] = arith.cmpi sgt, %[[I]], %[[C100]] : i32
! CHECK: cf.cond_br %[[COND]], ^[[EXIT:.*]], ^[[BODY2:.*]]
! CHECK: ^[[EXIT]]:
! CHECK: cf.br ^[[RETURN:.*]]
! CHECK: ^[[BODY2:.*]]:
! CHECK: %[[C1:.*]] = arith.constant 1 : i32
! CHECK: %[[C1_INDEX:.*]] = fir.convert %[[C1]] : (i32) -> index
! CHECK: %[[C10:.*]] = arith.constant 10 : i32
! CHECK: %[[C10_INDEX:.*]] = fir.convert %[[C10]] : (i32) -> index
! CHECK: %[[C1_1:.*]] = arith.constant 1 : index
! CHECK: %[[J_FINAL:.*]] = fir.do_loop %[[J:.*]] = %[[C1_INDEX]] to %[[C10_INDEX]] step %[[C1_1]] -> index {
! CHECK: %[[J_I32:.*]] = fir.convert %[[J]] : (index) -> i32
! CHECK: fir.store %[[J_I32]] to %[[J_REF]] : !fir.ref<i32>
! CHECK: %[[J_NEXT:.*]] = arith.addi %[[J]], %[[C1_1]] : index
! CHECK: fir.result %[[J_NEXT]] : index
! CHECK: }
! CHECK: %[[J_I32:.*]] = fir.convert %[[J_FINAL]] : (index) -> i32
! CHECK: fir.store %[[J_I32]] to %[[J_REF]] : !fir.ref<i32>
! CHECK: cf.br ^[[BODY1]]
! CHECK: ^[[RETURN]]:
! CHECK: return
subroutine empty_infinite_in_while(i)
integer :: i
do while (i .gt. 50)
do
end do
end do
end subroutine
! CHECK-LABEL: empty_infinite_in_while
! CHECK-SAME: %[[I_REF:.*]]: !fir.ref<i32>
! CHECK: cf.br ^bb1
! CHECK: ^bb1:
! CHECK: %[[I:.*]] = fir.load %[[I_REF]] : !fir.ref<i32>
! CHECK: %[[C50:.*]] = arith.constant 50 : i32
! CHECK: %[[COND:.*]] = arith.cmpi sgt, %[[I]], %[[C50]] : i32
! CHECK: cf.cond_br %[[COND]], ^[[INF_HEADER:.*]], ^[[EXIT:.*]]
! CHECK: ^[[INF_HEADER]]:
! CHECK: cf.br ^[[INF_BODY:.*]]
! CHECK: ^[[INF_BODY]]:
! CHECK: cf.br ^[[INF_HEADER]]
! CHECK: ^[[EXIT]]:
! CHECK: return