MLIR  19.0.0git
SCF.h
Go to the documentation of this file.
1 //===- SCFOps.h - Structured Control Flow -----------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines structured control flow operations.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef MLIR_DIALECT_SCF_SCF_H
14 #define MLIR_DIALECT_SCF_SCF_H
15 
18 #include "mlir/IR/Builders.h"
19 #include "mlir/IR/BuiltinTypes.h"
28 
29 namespace mlir {
30 namespace scf {
31 void buildTerminatedBody(OpBuilder &builder, Location loc);
32 } // namespace scf
33 } // namespace mlir
34 
35 #include "mlir/Dialect/SCF/IR/SCFOpsDialect.h.inc"
36 
37 #define GET_OP_CLASSES
38 #include "mlir/Dialect/SCF/IR/SCFOps.h.inc"
39 
40 namespace mlir {
41 namespace scf {
42 
43 // Insert `loop.yield` at the end of the only region's only block if it
44 // does not have a terminator already. If a new `loop.yield` is inserted,
45 // the location is specified by `loc`. If the region is empty, insert a new
46 // block first.
47 void ensureLoopTerminator(Region &region, Builder &builder, Location loc);
48 
49 /// Returns the loop parent of an induction variable. If the provided value is
50 /// not an induction variable, then return nullptr.
52 
53 /// Returns the parallel loop parent of an induction variable. If the provided
54 /// value is not an induction variable, then return nullptr.
56 
57 /// Returns the ForallOp parent of an thread index variable.
58 /// If the provided value is not a thread index variable, then return nullptr.
60 
61 /// Return true if ops a and b (or their ancestors) are in mutually exclusive
62 /// regions/blocks of an IfOp.
63 // TODO: Consider moving this functionality to RegionBranchOpInterface.
65 
66 /// Promotes the loop body of a scf::ForallOp to its containing block.
67 void promote(RewriterBase &rewriter, scf::ForallOp forallOp);
68 
69 /// An owning vector of values, handy to return from functions.
72 struct LoopNest {
75 };
76 
77 /// Creates a perfect nest of "for" loops, i.e. all loops but the innermost
78 /// contain only another loop and a terminator. The lower, upper bounds and
79 /// steps are provided as `lbs`, `ubs` and `steps`, which are expected to be of
80 /// the same size. `iterArgs` points to the initial values of the loop iteration
81 /// arguments, which will be forwarded through the nest to the innermost loop.
82 /// The body of the loop is populated using `bodyBuilder`, which accepts an
83 /// ordered list of induction variables of all loops, followed by a list of
84 /// iteration arguments of the innermost loop, in the same order as provided to
85 /// `iterArgs`. This function is expected to return as many values as
86 /// `iterArgs`, of the same type and in the same order, that will be treated as
87 /// yielded from the loop body and forwarded back through the loop nest. If the
88 /// function is not provided, the loop nest is not expected to have iteration
89 /// arguments, the body of the innermost loop will be left empty, containing
90 /// only the zero-operand terminator. Returns the LoopNest containing the list
91 /// of perfectly nest scf::ForOp build during the call.
92 /// If bound arrays are empty, the body builder will be called
93 /// once to construct the IR outside of the loop with an empty list of induction
94 /// variables.
96  OpBuilder &builder, Location loc, ValueRange lbs, ValueRange ubs,
97  ValueRange steps, ValueRange iterArgs,
99  bodyBuilder = nullptr);
100 
101 /// A convenience version for building loop nests without iteration arguments
102 /// (like for reductions). Does not take the initial value of reductions or
103 /// expect the body building functions to return their current value.
104 /// The built nested scf::For are captured in `capturedLoops` when non-null.
106  ValueRange ubs, ValueRange steps,
108  bodyBuilder = nullptr);
109 
110 } // namespace scf
111 } // namespace mlir
112 #endif // MLIR_DIALECT_SCF_SCF_H
This class is a general helper class for creating context-global objects like types,...
Definition: Builders.h:50
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
Definition: Location.h:63
This class helps build Operations.
Definition: Builders.h:209
Operation is the basic unit of execution within MLIR.
Definition: Operation.h:88
This class contains a list of basic blocks and a link to the parent operation it is attached to.
Definition: Region.h:26
This class coordinates the application of a rewrite on a set of IR, providing a way for clients to tr...
Definition: PatternMatch.h:400
This class provides an abstraction over the different types of ranges over Values.
Definition: ValueRange.h:381
This class represents an instance of an SSA value in the MLIR system, representing a computable value...
Definition: Value.h:96
ParallelOp getParallelForInductionVarOwner(Value val)
Returns the parallel loop parent of an induction variable.
Definition: SCF.cpp:3025
SmallVector< scf::ForOp > LoopVector
Definition: SCF.h:71
void buildTerminatedBody(OpBuilder &builder, Location loc)
Default callback for IfOp builders. Inserts a yield without arguments.
Definition: SCF.cpp:85
LoopNest buildLoopNest(OpBuilder &builder, Location loc, ValueRange lbs, ValueRange ubs, ValueRange steps, ValueRange iterArgs, function_ref< ValueVector(OpBuilder &, Location, ValueRange, ValueRange)> bodyBuilder=nullptr)
Creates a perfect nest of "for" loops, i.e.
Definition: SCF.cpp:687
bool insideMutuallyExclusiveBranches(Operation *a, Operation *b)
Return true if ops a and b (or their ancestors) are in mutually exclusive regions/blocks of an IfOp.
Definition: SCF.cpp:1952
void promote(RewriterBase &rewriter, scf::ForallOp forallOp)
Promotes the loop body of a scf::ForallOp to its containing block.
Definition: SCF.cpp:644
ForOp getForInductionVarOwner(Value val)
Returns the loop parent of an induction variable.
Definition: SCF.cpp:597
void ensureLoopTerminator(Region &region, Builder &builder, Location loc)
ForallOp getForallOpThreadIndexOwner(Value val)
Returns the ForallOp parent of an thread index variable.
Definition: SCF.cpp:1453
SmallVector< Value > ValueVector
An owning vector of values, handy to return from functions.
Definition: SCF.h:70
Include the generated interface declarations.
ValueVector results
Definition: SCF.h:74
LoopVector loops
Definition: SCF.h:73