diff --git a/flang/include/flang/Optimizer/Transforms/Passes.h b/flang/include/flang/Optimizer/Transforms/Passes.h index 5dc784ff0b505..bdcd6fc9f7cb5 100644 --- a/flang/include/flang/Optimizer/Transforms/Passes.h +++ b/flang/include/flang/Optimizer/Transforms/Passes.h @@ -28,6 +28,7 @@ namespace fir { std::unique_ptr createAbstractResultOptPass(); std::unique_ptr createAffineDemotionPass(); +std::unique_ptr createFirToCfgPass(); std::unique_ptr createCharacterConversionPass(); std::unique_ptr createExternalNameConversionPass(); std::unique_ptr createPromoteToAffinePass(); diff --git a/flang/include/flang/Optimizer/Transforms/Passes.td b/flang/include/flang/Optimizer/Transforms/Passes.td index 309ef43d766d3..64cee129c18ee 100644 --- a/flang/include/flang/Optimizer/Transforms/Passes.td +++ b/flang/include/flang/Optimizer/Transforms/Passes.td @@ -92,6 +92,26 @@ def CharacterConversion : Pass<"character-conversion"> { ]; } +def CFGConversion : FunctionPass<"cfg-conversion"> { + let summary = "Convert FIR structured control flow ops to CFG ops."; + let description = [{ + Transform the `fir.do_loop`, `fir.if`, and `fir.iterate_while` ops into + plain old test and branch operations. Removing the high-level control + structures can enable other optimizations. + + This pass is required before code gen to the LLVM IR dialect. + }]; + let constructor = "::fir::createFirToCfgPass()"; + let dependentDialects = [ + "fir::FIROpsDialect", "mlir::StandardOpsDialect" + ]; + let options = [ + Option<"forceLoopToExecuteOnce", "always-execute-loop-body", "bool", + /*default=*/"false", + "force the body of a loop to execute at least once"> + ]; +} + def ExternalNameConversion : Pass<"external-name-interop", "mlir::ModuleOp"> { let summary = "Convert name for external interoperability"; let description = [{ diff --git a/flang/lib/Optimizer/Transforms/CMakeLists.txt b/flang/lib/Optimizer/Transforms/CMakeLists.txt index 9d3448aa1be4c..b2a91f20f3094 100644 --- a/flang/lib/Optimizer/Transforms/CMakeLists.txt +++ b/flang/lib/Optimizer/Transforms/CMakeLists.txt @@ -5,6 +5,7 @@ add_flang_library(FIRTransforms CharacterConversion.cpp Inliner.cpp ExternalNameConversion.cpp + RewriteLoop.cpp DEPENDS FIRDialect diff --git a/flang/lib/Optimizer/Transforms/RewriteLoop.cpp b/flang/lib/Optimizer/Transforms/RewriteLoop.cpp new file mode 100644 index 0000000000000..da229d5d40b16 --- /dev/null +++ b/flang/lib/Optimizer/Transforms/RewriteLoop.cpp @@ -0,0 +1,330 @@ +//===-- RewriteLoop.cpp ---------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "PassDetail.h" +#include "flang/Optimizer/Dialect/FIRDialect.h" +#include "flang/Optimizer/Dialect/FIROps.h" +#include "flang/Optimizer/Transforms/Passes.h" +#include "mlir/Dialect/Affine/IR/AffineOps.h" +#include "mlir/Dialect/StandardOps/IR/Ops.h" +#include "mlir/Pass/Pass.h" +#include "mlir/Transforms/DialectConversion.h" +#include "llvm/Support/CommandLine.h" + +using namespace fir; + +namespace { + +// Conversion of fir control ops to more primitive control-flow. +// +// FIR loops that cannot be converted to the affine dialect will remain as +// `fir.do_loop` operations. These can be converted to control-flow operations. + +/// Convert `fir.do_loop` to CFG +class CfgLoopConv : public mlir::OpRewritePattern { +public: + using OpRewritePattern::OpRewritePattern; + + CfgLoopConv(mlir::MLIRContext *ctx, bool forceLoopToExecuteOnce) + : mlir::OpRewritePattern(ctx), + forceLoopToExecuteOnce(forceLoopToExecuteOnce) {} + + mlir::LogicalResult + matchAndRewrite(DoLoopOp loop, + mlir::PatternRewriter &rewriter) const override { + auto loc = loop.getLoc(); + + // Create the start and end blocks that will wrap the DoLoopOp with an + // initalizer and an end point + auto *initBlock = rewriter.getInsertionBlock(); + auto initPos = rewriter.getInsertionPoint(); + auto *endBlock = rewriter.splitBlock(initBlock, initPos); + + // Split the first DoLoopOp block in two parts. The part before will be the + // conditional block since it already has the induction variable and + // loop-carried values as arguments. + auto *conditionalBlock = &loop.region().front(); + conditionalBlock->addArgument(rewriter.getIndexType()); + auto *firstBlock = + rewriter.splitBlock(conditionalBlock, conditionalBlock->begin()); + auto *lastBlock = &loop.region().back(); + + // Move the blocks from the DoLoopOp between initBlock and endBlock + rewriter.inlineRegionBefore(loop.region(), endBlock); + + // Get loop values from the DoLoopOp + auto low = loop.lowerBound(); + auto high = loop.upperBound(); + assert(low && high && "must be a Value"); + auto step = loop.step(); + + // Initalization block + rewriter.setInsertionPointToEnd(initBlock); + auto diff = rewriter.create(loc, high, low); + auto distance = rewriter.create(loc, diff, step); + mlir::Value iters = + rewriter.create(loc, distance, step); + + if (forceLoopToExecuteOnce) { + auto zero = rewriter.create(loc, 0); + auto cond = + rewriter.create(loc, CmpIPredicate::sle, iters, zero); + auto one = rewriter.create(loc, 1); + iters = rewriter.create(loc, cond, one, iters); + } + + llvm::SmallVector loopOperands; + loopOperands.push_back(low); + auto operands = loop.getIterOperands(); + loopOperands.append(operands.begin(), operands.end()); + loopOperands.push_back(iters); + + rewriter.create(loc, conditionalBlock, loopOperands); + + // Last loop block + auto *terminator = lastBlock->getTerminator(); + rewriter.setInsertionPointToEnd(lastBlock); + auto iv = conditionalBlock->getArgument(0); + mlir::Value steppedIndex = rewriter.create(loc, iv, step); + assert(steppedIndex && "must be a Value"); + auto lastArg = conditionalBlock->getNumArguments() - 1; + auto itersLeft = conditionalBlock->getArgument(lastArg); + auto one = rewriter.create(loc, 1); + mlir::Value itersMinusOne = + rewriter.create(loc, itersLeft, one); + + llvm::SmallVector loopCarried; + loopCarried.push_back(steppedIndex); + auto begin = loop.finalValue() ? std::next(terminator->operand_begin()) + : terminator->operand_begin(); + loopCarried.append(begin, terminator->operand_end()); + loopCarried.push_back(itersMinusOne); + rewriter.create(loc, conditionalBlock, loopCarried); + rewriter.eraseOp(terminator); + + // Conditional block + rewriter.setInsertionPointToEnd(conditionalBlock); + auto zero = rewriter.create(loc, 0); + auto comparison = + rewriter.create(loc, CmpIPredicate::sgt, itersLeft, zero); + + rewriter.create(loc, comparison, firstBlock, + llvm::ArrayRef(), endBlock, + llvm::ArrayRef()); + + // The result of the loop operation is the values of the condition block + // arguments except the induction variable on the last iteration. + auto args = loop.finalValue() + ? conditionalBlock->getArguments() + : conditionalBlock->getArguments().drop_front(); + rewriter.replaceOp(loop, args.drop_back()); + return success(); + } + +private: + bool forceLoopToExecuteOnce; +}; + +/// Convert `fir.if` to control-flow +class CfgIfConv : public mlir::OpRewritePattern { +public: + using OpRewritePattern::OpRewritePattern; + + CfgIfConv(mlir::MLIRContext *ctx, bool forceLoopToExecuteOnce) + : mlir::OpRewritePattern(ctx), + forceLoopToExecuteOnce(forceLoopToExecuteOnce) {} + + mlir::LogicalResult + matchAndRewrite(IfOp ifOp, mlir::PatternRewriter &rewriter) const override { + auto loc = ifOp.getLoc(); + + // Split the block containing the 'fir.if' into two parts. The part before + // will contain the condition, the part after will be the continuation + // point. + auto *condBlock = rewriter.getInsertionBlock(); + auto opPosition = rewriter.getInsertionPoint(); + auto *remainingOpsBlock = rewriter.splitBlock(condBlock, opPosition); + mlir::Block *continueBlock; + if (ifOp.getNumResults() == 0) { + continueBlock = remainingOpsBlock; + } else { + continueBlock = + rewriter.createBlock(remainingOpsBlock, ifOp.getResultTypes()); + rewriter.create(loc, remainingOpsBlock); + } + + // Move blocks from the "then" region to the region containing 'fir.if', + // place it before the continuation block, and branch to it. + auto &ifOpRegion = ifOp.thenRegion(); + auto *ifOpBlock = &ifOpRegion.front(); + auto *ifOpTerminator = ifOpRegion.back().getTerminator(); + auto ifOpTerminatorOperands = ifOpTerminator->getOperands(); + rewriter.setInsertionPointToEnd(&ifOpRegion.back()); + rewriter.create(loc, continueBlock, ifOpTerminatorOperands); + rewriter.eraseOp(ifOpTerminator); + rewriter.inlineRegionBefore(ifOpRegion, continueBlock); + + // Move blocks from the "else" region (if present) to the region containing + // 'fir.if', place it before the continuation block and branch to it. It + // will be placed after the "then" regions. + auto *otherwiseBlock = continueBlock; + auto &otherwiseRegion = ifOp.elseRegion(); + if (!otherwiseRegion.empty()) { + otherwiseBlock = &otherwiseRegion.front(); + auto *otherwiseTerm = otherwiseRegion.back().getTerminator(); + auto otherwiseTermOperands = otherwiseTerm->getOperands(); + rewriter.setInsertionPointToEnd(&otherwiseRegion.back()); + rewriter.create(loc, continueBlock, + otherwiseTermOperands); + rewriter.eraseOp(otherwiseTerm); + rewriter.inlineRegionBefore(otherwiseRegion, continueBlock); + } + + rewriter.setInsertionPointToEnd(condBlock); + rewriter.create( + loc, ifOp.condition(), ifOpBlock, llvm::ArrayRef(), + otherwiseBlock, llvm::ArrayRef()); + rewriter.replaceOp(ifOp, continueBlock->getArguments()); + return success(); + } + +private: + bool forceLoopToExecuteOnce; +}; + +/// Convert `fir.iter_while` to control-flow. +class CfgIterWhileConv : public mlir::OpRewritePattern { +public: + using OpRewritePattern::OpRewritePattern; + + CfgIterWhileConv(mlir::MLIRContext *ctx, bool forceLoopToExecuteOnce) + : mlir::OpRewritePattern(ctx), + forceLoopToExecuteOnce(forceLoopToExecuteOnce) {} + + mlir::LogicalResult + matchAndRewrite(fir::IterWhileOp whileOp, + mlir::PatternRewriter &rewriter) const override { + auto loc = whileOp.getLoc(); + + // Start by splitting the block containing the 'fir.do_loop' into two parts. + // The part before will get the init code, the part after will be the end + // point. + auto *initBlock = rewriter.getInsertionBlock(); + auto initPosition = rewriter.getInsertionPoint(); + auto *endBlock = rewriter.splitBlock(initBlock, initPosition); + + // Use the first block of the loop body as the condition block since it is + // the block that has the induction variable and loop-carried values as + // arguments. Split out all operations from the first block into a new + // block. Move all body blocks from the loop body region to the region + // containing the loop. + auto *conditionBlock = &whileOp.region().front(); + auto *firstBodyBlock = + rewriter.splitBlock(conditionBlock, conditionBlock->begin()); + auto *lastBodyBlock = &whileOp.region().back(); + rewriter.inlineRegionBefore(whileOp.region(), endBlock); + auto iv = conditionBlock->getArgument(0); + auto iterateVar = conditionBlock->getArgument(1); + + // Append the induction variable stepping logic to the last body block and + // branch back to the condition block. Loop-carried values are taken from + // operands of the loop terminator. + auto *terminator = lastBodyBlock->getTerminator(); + rewriter.setInsertionPointToEnd(lastBodyBlock); + auto step = whileOp.step(); + mlir::Value stepped = rewriter.create(loc, iv, step); + assert(stepped && "must be a Value"); + + llvm::SmallVector loopCarried; + loopCarried.push_back(stepped); + auto begin = whileOp.finalValue() ? std::next(terminator->operand_begin()) + : terminator->operand_begin(); + loopCarried.append(begin, terminator->operand_end()); + rewriter.create(loc, conditionBlock, loopCarried); + rewriter.eraseOp(terminator); + + // Compute loop bounds before branching to the condition. + rewriter.setInsertionPointToEnd(initBlock); + auto lowerBound = whileOp.lowerBound(); + auto upperBound = whileOp.upperBound(); + assert(lowerBound && upperBound && "must be a Value"); + + // The initial values of loop-carried values is obtained from the operands + // of the loop operation. + llvm::SmallVector destOperands; + destOperands.push_back(lowerBound); + auto iterOperands = whileOp.getIterOperands(); + destOperands.append(iterOperands.begin(), iterOperands.end()); + rewriter.create(loc, conditionBlock, destOperands); + + // With the body block done, we can fill in the condition block. + rewriter.setInsertionPointToEnd(conditionBlock); + // The comparison depends on the sign of the step value. We fully expect + // this expression to be folded by the optimizer or LLVM. This expression + // is written this way so that `step == 0` always returns `false`. + auto zero = rewriter.create(loc, 0); + auto compl0 = + rewriter.create(loc, CmpIPredicate::slt, zero, step); + auto compl1 = + rewriter.create(loc, CmpIPredicate::sle, iv, upperBound); + auto compl2 = + rewriter.create(loc, CmpIPredicate::slt, step, zero); + auto compl3 = + rewriter.create(loc, CmpIPredicate::sle, upperBound, iv); + auto cmp0 = rewriter.create(loc, compl0, compl1); + auto cmp1 = rewriter.create(loc, compl2, compl3); + auto cmp2 = rewriter.create(loc, cmp0, cmp1); + // Remember to AND in the early-exit bool. + auto comparison = rewriter.create(loc, iterateVar, cmp2); + rewriter.create(loc, comparison, firstBodyBlock, + llvm::ArrayRef(), endBlock, + llvm::ArrayRef()); + // The result of the loop operation is the values of the condition block + // arguments except the induction variable on the last iteration. + auto args = whileOp.finalValue() + ? conditionBlock->getArguments() + : conditionBlock->getArguments().drop_front(); + rewriter.replaceOp(whileOp, args); + return success(); + } + +private: + bool forceLoopToExecuteOnce; +}; + +/// Convert FIR structured control flow ops to CFG ops. +class CfgConversion : public CFGConversionBase { +public: + void runOnFunction() override { + auto *context = &getContext(); + mlir::OwningRewritePatternList patterns(context); + patterns.insert( + context, forceLoopToExecuteOnce); + mlir::ConversionTarget target(*context); + target.addLegalDialect(); + + // apply the patterns + target.addIllegalOp(); + target.markUnknownOpDynamicallyLegal([](Operation *) { return true; }); + if (mlir::failed(mlir::applyPartialConversion(getFunction(), target, + std::move(patterns)))) { + mlir::emitError(mlir::UnknownLoc::get(context), + "error in converting to CFG\n"); + signalPassFailure(); + } + } +}; +} // namespace + +/// Convert FIR's structured control flow ops to CFG ops. This +/// conversion enables the `createLowerToCFGPass` to transform these to CFG +/// form. +std::unique_ptr fir::createFirToCfgPass() { + return std::make_unique(); +} diff --git a/flang/test/Fir/loop01.fir b/flang/test/Fir/loop01.fir new file mode 100644 index 0000000000000..a1d7179a4dc54 --- /dev/null +++ b/flang/test/Fir/loop01.fir @@ -0,0 +1,333 @@ +// RUN: fir-opt --split-input-file --cfg-conversion %s | FileCheck %s + +func @x(%lb : index, %ub : index, %step : index, %b : i1, %addr : !fir.ref) { + fir.do_loop %iv = %lb to %ub step %step unordered { + // expect following conditional blocks to get fused + fir.if %b { + fir.store %iv to %addr : !fir.ref + } else { + %zero = constant 0 : index + fir.store %zero to %addr : !fir.ref + } + } + return +} + +func private @f2() -> i1 + +// CHECK: func @x(%[[VAL_0:.*]]: index, %[[VAL_1:.*]]: index, %[[VAL_2:.*]]: index, %[[VAL_3:.*]]: i1, %[[VAL_4:.*]]: !fir.ref) { +// CHECK: %[[VAL_5:.*]] = subi %[[VAL_1]], %[[VAL_0]] : index +// CHECK: %[[VAL_6:.*]] = addi %[[VAL_5]], %[[VAL_2]] : index +// CHECK: %[[VAL_7:.*]] = divi_signed %[[VAL_6]], %[[VAL_2]] : index +// CHECK: br ^bb1(%[[VAL_0]], %[[VAL_7]] : index, index) +// CHECK: ^bb1(%[[VAL_8:.*]]: index, %[[VAL_9:.*]]: index): +// CHECK: %[[VAL_10:.*]] = constant 0 : index +// CHECK: %[[VAL_11:.*]] = cmpi sgt, %[[VAL_9]], %[[VAL_10]] : index +// CHECK: cond_br %[[VAL_11]], ^bb2, ^bb6 +// CHECK: ^bb2: +// CHECK: cond_br %[[VAL_3]], ^bb3, ^bb4 +// CHECK: ^bb3: +// CHECK: fir.store %[[VAL_8]] to %[[VAL_4]] : !fir.ref +// CHECK: br ^bb5 +// CHECK: ^bb4: +// CHECK: %[[VAL_12:.*]] = constant 0 : index +// CHECK: fir.store %[[VAL_12]] to %[[VAL_4]] : !fir.ref +// CHECK: br ^bb5 +// CHECK: ^bb5: +// CHECK: %[[VAL_13:.*]] = addi %[[VAL_8]], %[[VAL_2]] : index +// CHECK: %[[VAL_14:.*]] = constant 1 : index +// CHECK: %[[VAL_15:.*]] = subi %[[VAL_9]], %[[VAL_14]] : index +// CHECK: br ^bb1(%[[VAL_13]], %[[VAL_15]] : index, index) +// CHECK: ^bb6: +// CHECK: return +// CHECK: } +// CHECK: func private @f2() -> i1 + +// ----- + +func @x2(%lo : index, %up : index, %ok : i1) { + %c1 = constant 1 : index + %unused = fir.iterate_while (%i = %lo to %up step %c1) and (%ok1 = %ok) { + %ok2 = fir.call @f2() : () -> i1 + fir.result %ok2 : i1 + } + return +} + +func private @f3(i16) + +// CHECK: func @x2(%[[VAL_0:.*]]: index, %[[VAL_1:.*]]: index, %[[VAL_2:.*]]: i1) { +// CHECK: %[[VAL_3:.*]] = constant 1 : index +// CHECK: br ^bb1(%[[VAL_0]], %[[VAL_2]] : index, i1) +// CHECK: ^bb1(%[[VAL_4:.*]]: index, %[[VAL_5:.*]]: i1): +// CHECK: %[[VAL_6:.*]] = constant 0 : index +// CHECK: %[[VAL_7:.*]] = cmpi slt, %[[VAL_6]], %[[VAL_3]] : index +// CHECK: %[[VAL_8:.*]] = cmpi sle, %[[VAL_4]], %[[VAL_1]] : index +// CHECK: %[[VAL_9:.*]] = cmpi slt, %[[VAL_3]], %[[VAL_6]] : index +// CHECK: %[[VAL_10:.*]] = cmpi sle, %[[VAL_1]], %[[VAL_4]] : index +// CHECK: %[[VAL_11:.*]] = and %[[VAL_7]], %[[VAL_8]] : i1 +// CHECK: %[[VAL_12:.*]] = and %[[VAL_9]], %[[VAL_10]] : i1 +// CHECK: %[[VAL_13:.*]] = or %[[VAL_11]], %[[VAL_12]] : i1 +// CHECK: %[[VAL_14:.*]] = and %[[VAL_5]], %[[VAL_13]] : i1 +// CHECK: cond_br %[[VAL_14]], ^bb2, ^bb3 +// CHECK: ^bb2: +// CHECK: %[[VAL_15:.*]] = fir.call @f2() : () -> i1 +// CHECK: %[[VAL_16:.*]] = addi %[[VAL_4]], %[[VAL_3]] : index +// CHECK: br ^bb1(%[[VAL_16]], %[[VAL_15]] : index, i1) +// CHECK: ^bb3: +// CHECK: return +// CHECK: } +// CHECK: func private @f3(i16) + +// ----- + +// do_loop with an extra loop-carried value +func @x3(%lo : index, %up : index) -> i1 { + %c1 = constant 1 : index + %ok1 = constant true + %ok2 = fir.do_loop %i = %lo to %up step %c1 iter_args(%j = %ok1) -> i1 { + %ok = fir.call @f2() : () -> i1 + fir.result %ok : i1 + } + return %ok2 : i1 +} + +// CHECK-LABEL: func @x3( +// CHECK-SAME: %[[VAL_0:.*]]: index, +// CHECK-SAME: %[[VAL_1:.*]]: index) -> i1 { +// CHECK: %[[VAL_2:.*]] = constant 1 : index +// CHECK: %[[VAL_3:.*]] = constant true +// CHECK: %[[VAL_4:.*]] = subi %[[VAL_1]], %[[VAL_0]] : index +// CHECK: %[[VAL_5:.*]] = addi %[[VAL_4]], %[[VAL_2]] : index +// CHECK: %[[VAL_6:.*]] = divi_signed %[[VAL_5]], %[[VAL_2]] : index +// CHECK: br ^bb1(%[[VAL_0]], %[[VAL_3]], %[[VAL_6]] : index, i1, index) +// CHECK: ^bb1(%[[VAL_7:.*]]: index, %[[VAL_8:.*]]: i1, %[[VAL_9:.*]]: index): +// CHECK: %[[VAL_10:.*]] = constant 0 : index +// CHECK: %[[VAL_11:.*]] = cmpi sgt, %[[VAL_9]], %[[VAL_10]] : index +// CHECK: cond_br %[[VAL_11]], ^bb2, ^bb3 +// CHECK: ^bb2: +// CHECK: %[[VAL_12:.*]] = fir.call @f2() : () -> i1 +// CHECK: %[[VAL_13:.*]] = addi %[[VAL_7]], %[[VAL_2]] : index +// CHECK: %[[VAL_14:.*]] = constant 1 : index +// CHECK: %[[VAL_15:.*]] = subi %[[VAL_9]], %[[VAL_14]] : index +// CHECK: br ^bb1(%[[VAL_13]], %[[VAL_12]], %[[VAL_15]] : index, i1, index) +// CHECK: ^bb3: +// CHECK: return %[[VAL_8]] : i1 +// CHECK: } + +// ----- + +// iterate_while with an extra loop-carried value +func @y3(%lo : index, %up : index) -> i1 { + %c1 = constant 1 : index + %ok1 = constant true + %ok4 = fir.call @f2() : () -> i1 + %ok2:2 = fir.iterate_while (%i = %lo to %up step %c1) and (%ok3 = %ok1) iter_args(%j = %ok4) -> i1 { + %ok = fir.call @f2() : () -> i1 + fir.result %ok3, %ok : i1, i1 + } + %andok = and %ok2#0, %ok2#1 : i1 + return %andok : i1 +} + +func private @f4(i32) -> i1 + +// CHECK-LABEL: func @y3( +// CHECK-SAME: %[[VAL_0:.*]]: index, +// CHECK-SAME: %[[VAL_1:.*]]: index) -> i1 { +// CHECK: %[[VAL_2:.*]] = constant 1 : index +// CHECK: %[[VAL_3:.*]] = constant true +// CHECK: %[[VAL_4:.*]] = fir.call @f2() : () -> i1 +// CHECK: br ^bb1(%[[VAL_0]], %[[VAL_3]], %[[VAL_4]] : index, i1, i1) +// CHECK: ^bb1(%[[VAL_5:.*]]: index, %[[VAL_6:.*]]: i1, %[[VAL_7:.*]]: i1): +// CHECK: %[[VAL_8:.*]] = constant 0 : index +// CHECK: %[[VAL_9:.*]] = cmpi slt, %[[VAL_8]], %[[VAL_2]] : index +// CHECK: %[[VAL_10:.*]] = cmpi sle, %[[VAL_5]], %[[VAL_1]] : index +// CHECK: %[[VAL_11:.*]] = cmpi slt, %[[VAL_2]], %[[VAL_8]] : index +// CHECK: %[[VAL_12:.*]] = cmpi sle, %[[VAL_1]], %[[VAL_5]] : index +// CHECK: %[[VAL_13:.*]] = and %[[VAL_9]], %[[VAL_10]] : i1 +// CHECK: %[[VAL_14:.*]] = and %[[VAL_11]], %[[VAL_12]] : i1 +// CHECK: %[[VAL_15:.*]] = or %[[VAL_13]], %[[VAL_14]] : i1 +// CHECK: %[[VAL_16:.*]] = and %[[VAL_6]], %[[VAL_15]] : i1 +// CHECK: cond_br %[[VAL_16]], ^bb2, ^bb3 +// CHECK: ^bb2: +// CHECK: %[[VAL_17:.*]] = fir.call @f2() : () -> i1 +// CHECK: %[[VAL_18:.*]] = addi %[[VAL_5]], %[[VAL_2]] : index +// CHECK: br ^bb1(%[[VAL_18]], %[[VAL_6]], %[[VAL_17]] : index, i1, i1) +// CHECK: ^bb3: +// CHECK: %[[VAL_19:.*]] = and %[[VAL_6]], %[[VAL_7]] : i1 +// CHECK: return %[[VAL_19]] : i1 +// CHECK: } +// CHECK: func private @f4(i32) -> i1 + +// ----- + +// do_loop that returns the final value of the induction +func @x4(%lo : index, %up : index) -> index { + %c1 = constant 1 : index + %v = fir.do_loop %i = %lo to %up step %c1 -> index { + %i1 = fir.convert %i : (index) -> i32 + %ok = fir.call @f4(%i1) : (i32) -> i1 + fir.result %i : index + } + return %v : index +} + +// CHECK-LABEL: func @x4( +// CHECK-SAME: %[[VAL_0:.*]]: index, +// CHECK-SAME: %[[VAL_1:.*]]: index) -> index { +// CHECK: %[[VAL_2:.*]] = constant 1 : index +// CHECK: %[[VAL_3:.*]] = subi %[[VAL_1]], %[[VAL_0]] : index +// CHECK: %[[VAL_4:.*]] = addi %[[VAL_3]], %[[VAL_2]] : index +// CHECK: %[[VAL_5:.*]] = divi_signed %[[VAL_4]], %[[VAL_2]] : index +// CHECK: br ^bb1(%[[VAL_0]], %[[VAL_5]] : index, index) +// CHECK: ^bb1(%[[VAL_6:.*]]: index, %[[VAL_7:.*]]: index): +// CHECK: %[[VAL_8:.*]] = constant 0 : index +// CHECK: %[[VAL_9:.*]] = cmpi sgt, %[[VAL_7]], %[[VAL_8]] : index +// CHECK: cond_br %[[VAL_9]], ^bb2, ^bb3 +// CHECK: ^bb2: +// CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_6]] : (index) -> i32 +// CHECK: %[[VAL_11:.*]] = fir.call @f4(%[[VAL_10]]) : (i32) -> i1 +// CHECK: %[[VAL_12:.*]] = addi %[[VAL_6]], %[[VAL_2]] : index +// CHECK: %[[VAL_13:.*]] = constant 1 : index +// CHECK: %[[VAL_14:.*]] = subi %[[VAL_7]], %[[VAL_13]] : index +// CHECK: br ^bb1(%[[VAL_12]], %[[VAL_14]] : index, index) +// CHECK: ^bb3: +// CHECK: return %[[VAL_6]] : index +// CHECK: } + +// ----- + +// iterate_while that returns the final value of both inductions +func @y4(%lo : index, %up : index) -> index { + %c1 = constant 1 : index + %ok1 = constant true + %v:2 = fir.iterate_while (%i = %lo to %up step %c1) and (%ok2 = %ok1) -> (index, i1) { + %i1 = fir.convert %i : (index) -> i32 + %ok = fir.call @f4(%i1) : (i32) -> i1 + fir.result %i, %ok : index, i1 + } + return %v#0 : index +} + +// CHECK-LABEL: func @y4( +// CHECK-SAME: %[[VAL_0:.*]]: index, +// CHECK-SAME: %[[VAL_1:.*]]: index) -> index { +// CHECK: %[[VAL_2:.*]] = constant 1 : index +// CHECK: %[[VAL_3:.*]] = constant true +// CHECK: br ^bb1(%[[VAL_0]], %[[VAL_3]] : index, i1) +// CHECK: ^bb1(%[[VAL_4:.*]]: index, %[[VAL_5:.*]]: i1): +// CHECK: %[[VAL_6:.*]] = constant 0 : index +// CHECK: %[[VAL_7:.*]] = cmpi slt, %[[VAL_6]], %[[VAL_2]] : index +// CHECK: %[[VAL_8:.*]] = cmpi sle, %[[VAL_4]], %[[VAL_1]] : index +// CHECK: %[[VAL_9:.*]] = cmpi slt, %[[VAL_2]], %[[VAL_6]] : index +// CHECK: %[[VAL_10:.*]] = cmpi sle, %[[VAL_1]], %[[VAL_4]] : index +// CHECK: %[[VAL_11:.*]] = and %[[VAL_7]], %[[VAL_8]] : i1 +// CHECK: %[[VAL_12:.*]] = and %[[VAL_9]], %[[VAL_10]] : i1 +// CHECK: %[[VAL_13:.*]] = or %[[VAL_11]], %[[VAL_12]] : i1 +// CHECK: %[[VAL_14:.*]] = and %[[VAL_5]], %[[VAL_13]] : i1 +// CHECK: cond_br %[[VAL_14]], ^bb2, ^bb3 +// CHECK: ^bb2: +// CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_4]] : (index) -> i32 +// CHECK: %[[VAL_16:.*]] = fir.call @f4(%[[VAL_15]]) : (i32) -> i1 +// CHECK: %[[VAL_17:.*]] = addi %[[VAL_4]], %[[VAL_2]] : index +// CHECK: br ^bb1(%[[VAL_17]], %[[VAL_16]] : index, i1) +// CHECK: ^bb3: +// CHECK: return %[[VAL_4]] : index +// CHECK: } + +// ----- + +// do_loop that returns the final induction value +// and an extra loop-carried value +func @x5(%lo : index, %up : index) -> index { + %c1 = constant 1 : index + %s1 = constant 42 : i16 + %v:2 = fir.do_loop %i = %lo to %up step %c1 iter_args(%s = %s1) -> (index, i16) { + %ok = fir.call @f2() : () -> i1 + %s2 = fir.convert %ok : (i1) -> i16 + fir.result %i, %s2 : index, i16 + } + fir.call @f3(%v#1) : (i16) -> () + return %v#0 : index +} + +// CHECK-LABEL: func @x5( +// CHECK-SAME: %[[VAL_0:.*]]: index, +// CHECK-SAME: %[[VAL_1:.*]]: index) -> index { +// CHECK: %[[VAL_2:.*]] = constant 1 : index +// CHECK: %[[VAL_3:.*]] = constant 42 : i16 +// CHECK: %[[VAL_4:.*]] = subi %[[VAL_1]], %[[VAL_0]] : index +// CHECK: %[[VAL_5:.*]] = addi %[[VAL_4]], %[[VAL_2]] : index +// CHECK: %[[VAL_6:.*]] = divi_signed %[[VAL_5]], %[[VAL_2]] : index +// CHECK: br ^bb1(%[[VAL_0]], %[[VAL_3]], %[[VAL_6]] : index, i16, index) +// CHECK: ^bb1(%[[VAL_7:.*]]: index, %[[VAL_8:.*]]: i16, %[[VAL_9:.*]]: index): +// CHECK: %[[VAL_10:.*]] = constant 0 : index +// CHECK: %[[VAL_11:.*]] = cmpi sgt, %[[VAL_9]], %[[VAL_10]] : index +// CHECK: cond_br %[[VAL_11]], ^bb2, ^bb3 +// CHECK: ^bb2: +// CHECK: %[[VAL_12:.*]] = fir.call @f2() : () -> i1 +// CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_12]] : (i1) -> i16 +// CHECK: %[[VAL_14:.*]] = addi %[[VAL_7]], %[[VAL_2]] : index +// CHECK: %[[VAL_15:.*]] = constant 1 : index +// CHECK: %[[VAL_16:.*]] = subi %[[VAL_9]], %[[VAL_15]] : index +// CHECK: br ^bb1(%[[VAL_14]], %[[VAL_13]], %[[VAL_16]] : index, i16, index) +// CHECK: ^bb3: +// CHECK: fir.call @f3(%[[VAL_8]]) : (i16) -> () +// CHECK: return %[[VAL_7]] : index +// CHECK: } + +// ----- + +// iterate_while that returns the both induction values +// and an extra loop-carried value +func @y5(%lo : index, %up : index) -> index { + %c1 = constant 1 : index + %s1 = constant 42 : i16 + %ok1 = constant true + %v:3 = fir.iterate_while (%i = %lo to %up step %c1) and (%ok2 = %ok1) iter_args(%s = %s1) -> (index, i1, i16) { + %ok = fir.call @f2() : () -> i1 + %s2 = fir.convert %ok : (i1) -> i16 + fir.result %i, %ok, %s2 : index, i1, i16 + } + fir.if %v#1 { + %arg = constant 0 : i32 + %ok4 = fir.call @f4(%arg) : (i32) -> i1 + } + fir.call @f3(%v#2) : (i16) -> () + return %v#0 : index +} + +// CHECK-LABEL: func @y5( +// CHECK-SAME: %[[VAL_0:.*]]: index, +// CHECK-SAME: %[[VAL_1:.*]]: index) -> index { +// CHECK: %[[VAL_2:.*]] = constant 1 : index +// CHECK: %[[VAL_3:.*]] = constant 42 : i16 +// CHECK: %[[VAL_4:.*]] = constant true +// CHECK: br ^bb1(%[[VAL_0]], %[[VAL_4]], %[[VAL_3]] : index, i1, i16) +// CHECK: ^bb1(%[[VAL_5:.*]]: index, %[[VAL_6:.*]]: i1, %[[VAL_7:.*]]: i16): +// CHECK: %[[VAL_8:.*]] = constant 0 : index +// CHECK: %[[VAL_9:.*]] = cmpi slt, %[[VAL_8]], %[[VAL_2]] : index +// CHECK: %[[VAL_10:.*]] = cmpi sle, %[[VAL_5]], %[[VAL_1]] : index +// CHECK: %[[VAL_11:.*]] = cmpi slt, %[[VAL_2]], %[[VAL_8]] : index +// CHECK: %[[VAL_12:.*]] = cmpi sle, %[[VAL_1]], %[[VAL_5]] : index +// CHECK: %[[VAL_13:.*]] = and %[[VAL_9]], %[[VAL_10]] : i1 +// CHECK: %[[VAL_14:.*]] = and %[[VAL_11]], %[[VAL_12]] : i1 +// CHECK: %[[VAL_15:.*]] = or %[[VAL_13]], %[[VAL_14]] : i1 +// CHECK: %[[VAL_16:.*]] = and %[[VAL_6]], %[[VAL_15]] : i1 +// CHECK: cond_br %[[VAL_16]], ^bb2, ^bb3 +// CHECK: ^bb2: +// CHECK: %[[VAL_17:.*]] = fir.call @f2() : () -> i1 +// CHECK: %[[VAL_18:.*]] = fir.convert %[[VAL_17]] : (i1) -> i16 +// CHECK: %[[VAL_19:.*]] = addi %[[VAL_5]], %[[VAL_2]] : index +// CHECK: br ^bb1(%[[VAL_19]], %[[VAL_17]], %[[VAL_18]] : index, i1, i16) +// CHECK: ^bb3: +// CHECK: cond_br %[[VAL_6]], ^bb4, ^bb5 +// CHECK: ^bb4: +// CHECK: %[[VAL_20:.*]] = constant 0 : i32 +// CHECK: %[[VAL_21:.*]] = fir.call @f4(%[[VAL_20]]) : (i32) -> i1 +// CHECK: br ^bb5 +// CHECK: ^bb5: +// CHECK: fir.call @f3(%[[VAL_7]]) : (i16) -> () +// CHECK: return %[[VAL_5]] : index +// CHECK: } diff --git a/flang/test/Fir/loop02.fir b/flang/test/Fir/loop02.fir new file mode 100644 index 0000000000000..3948a58a7a33c --- /dev/null +++ b/flang/test/Fir/loop02.fir @@ -0,0 +1,64 @@ +// RUN: fir-opt --cfg-conversion="always-execute-loop-body=true" %s | FileCheck %s +// RUN: fir-opt --cfg-conversion %s | FileCheck %s --check-prefix=NOOPT + +func @x(%addr : !fir.ref) { + %bound = constant 452 : index + %step = constant 1 : index + fir.do_loop %iv = %bound to %bound step %step { + fir.call @y(%addr) : (!fir.ref) -> () + } + return +} + +func private @y(%addr : !fir.ref) + + +// CHECK-LABEL: func @x( +// CHECK-SAME: %[[VAL_0:.*]]: !fir.ref) { +// CHECK: %[[VAL_1:.*]] = constant 452 : index +// CHECK: %[[VAL_2:.*]] = constant 1 : index +// CHECK: %[[VAL_3:.*]] = subi %[[VAL_1]], %[[VAL_1]] : index +// CHECK: %[[VAL_4:.*]] = addi %[[VAL_3]], %[[VAL_2]] : index +// CHECK: %[[VAL_5:.*]] = divi_signed %[[VAL_4]], %[[VAL_2]] : index +// CHECK: %[[VAL_6:.*]] = constant 0 : index +// CHECK: %[[VAL_7:.*]] = cmpi sle, %[[VAL_5]], %[[VAL_6]] : index +// CHECK: %[[VAL_8:.*]] = constant 1 : index +// CHECK: %[[VAL_9:.*]] = select %[[VAL_7]], %[[VAL_8]], %[[VAL_5]] : index +// CHECK: br ^bb1(%[[VAL_1]], %[[VAL_9]] : index, index) +// CHECK: ^bb1(%[[VAL_10:.*]]: index, %[[VAL_11:.*]]: index): +// CHECK: %[[VAL_12:.*]] = constant 0 : index +// CHECK: %[[VAL_13:.*]] = cmpi sgt, %[[VAL_11]], %[[VAL_12]] : index +// CHECK: cond_br %[[VAL_13]], ^bb2, ^bb3 +// CHECK: ^bb2: +// CHECK: fir.call @y(%[[VAL_0]]) : (!fir.ref) -> () +// CHECK: %[[VAL_14:.*]] = addi %[[VAL_10]], %[[VAL_2]] : index +// CHECK: %[[VAL_15:.*]] = constant 1 : index +// CHECK: %[[VAL_16:.*]] = subi %[[VAL_11]], %[[VAL_15]] : index +// CHECK: br ^bb1(%[[VAL_14]], %[[VAL_16]] : index, index) +// CHECK: ^bb3: +// CHECK: return +// CHECK: } +// CHECK: func private @y(!fir.ref) + +// NOOPT-LABEL: func @x( +// NOOPT-SAME: %[[VAL_0:.*]]: !fir.ref) { +// NOOPT: %[[VAL_1:.*]] = constant 452 : index +// NOOPT: %[[VAL_2:.*]] = constant 1 : index +// NOOPT: %[[VAL_3:.*]] = subi %[[VAL_1]], %[[VAL_1]] : index +// NOOPT: %[[VAL_4:.*]] = addi %[[VAL_3]], %[[VAL_2]] : index +// NOOPT: %[[VAL_5:.*]] = divi_signed %[[VAL_4]], %[[VAL_2]] : index +// NOOPT: br ^bb1(%[[VAL_1]], %[[VAL_5]] : index, index) +// NOOPT: ^bb1(%[[VAL_6:.*]]: index, %[[VAL_7:.*]]: index): +// NOOPT: %[[VAL_8:.*]] = constant 0 : index +// NOOPT: %[[VAL_9:.*]] = cmpi sgt, %[[VAL_7]], %[[VAL_8]] : index +// NOOPT: cond_br %[[VAL_9]], ^bb2, ^bb3 +// NOOPT: ^bb2: +// NOOPT: fir.call @y(%[[VAL_0]]) : (!fir.ref) -> () +// NOOPT: %[[VAL_10:.*]] = addi %[[VAL_6]], %[[VAL_2]] : index +// NOOPT: %[[VAL_11:.*]] = constant 1 : index +// NOOPT: %[[VAL_12:.*]] = subi %[[VAL_7]], %[[VAL_11]] : index +// NOOPT: br ^bb1(%[[VAL_10]], %[[VAL_12]] : index, index) +// NOOPT: ^bb3: +// NOOPT: return +// NOOPT: } +// NOOPT: func private @y(!fir.ref)