MLIR  21.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 /// Returns the loop parent of an induction variable. If the provided value is
44 /// not an induction variable, then return nullptr.
45 ForOp getForInductionVarOwner(Value val);
46 
47 /// Returns the parallel loop parent of an induction variable. If the provided
48 /// value is not an induction variable, then return nullptr.
49 ParallelOp getParallelForInductionVarOwner(Value val);
50 
51 /// Returns the ForallOp parent of an thread index variable.
52 /// If the provided value is not a thread index variable, then return nullptr.
53 ForallOp getForallOpThreadIndexOwner(Value val);
54 
55 /// Return true if ops a and b (or their ancestors) are in mutually exclusive
56 /// regions/blocks of an IfOp.
57 // TODO: Consider moving this functionality to RegionBranchOpInterface.
58 bool insideMutuallyExclusiveBranches(Operation *a, Operation *b);
59 
60 /// Promotes the loop body of a scf::ForallOp to its containing block.
61 void promote(RewriterBase &rewriter, scf::ForallOp forallOp);
62 
63 /// An owning vector of values, handy to return from functions.
66 struct LoopNest {
69 };
70 
71 /// Creates a perfect nest of "for" loops, i.e. all loops but the innermost
72 /// contain only another loop and a terminator. The lower, upper bounds and
73 /// steps are provided as `lbs`, `ubs` and `steps`, which are expected to be of
74 /// the same size. `iterArgs` points to the initial values of the loop iteration
75 /// arguments, which will be forwarded through the nest to the innermost loop.
76 /// The body of the loop is populated using `bodyBuilder`, which accepts an
77 /// ordered list of induction variables of all loops, followed by a list of
78 /// iteration arguments of the innermost loop, in the same order as provided to
79 /// `iterArgs`. This function is expected to return as many values as
80 /// `iterArgs`, of the same type and in the same order, that will be treated as
81 /// yielded from the loop body and forwarded back through the loop nest. If the
82 /// function is not provided, the loop nest is not expected to have iteration
83 /// arguments, the body of the innermost loop will be left empty, containing
84 /// only the zero-operand terminator. Returns the LoopNest containing the list
85 /// of perfectly nest scf::ForOp build during the call.
86 /// If bound arrays are empty, the body builder will be called
87 /// once to construct the IR outside of the loop with an empty list of induction
88 /// variables.
90  OpBuilder &builder, Location loc, ValueRange lbs, ValueRange ubs,
91  ValueRange steps, ValueRange iterArgs,
93  bodyBuilder = nullptr);
94 
95 /// A convenience version for building loop nests without iteration arguments
96 /// (like for reductions). Does not take the initial value of reductions or
97 /// expect the body building functions to return their current value.
98 /// The built nested scf::For are captured in `capturedLoops` when non-null.
100  ValueRange ubs, ValueRange steps,
102  bodyBuilder = nullptr);
103 
104 /// Perform a replacement of one iter OpOperand of an scf.for to the
105 /// `replacement` value with a different type. A callback is used to insert
106 /// cast ops inside the block to account for type differences.
110  scf::ForOp forOp,
111  OpOperand &operand,
112  Value replacement,
113  const ValueTypeCastFnTy &castFn);
114 
115 } // namespace scf
116 } // namespace mlir
117 #endif // MLIR_DIALECT_SCF_SCF_H
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
Definition: Location.h:66
This class helps build Operations.
Definition: Builders.h:205
This class represents an operand of an operation.
Definition: Value.h:267
This class coordinates the application of a rewrite on a set of IR, providing a way for clients to tr...
Definition: PatternMatch.h:400
Instances of the Type class are uniqued, have an immutable identifier and an optional mutable compone...
Definition: Types.h:74
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:3046
SmallVector< scf::ForOp > LoopVector
Definition: SCF.h:65
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:1973
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
ForallOp getForallOpThreadIndexOwner(Value val)
Returns the ForallOp parent of an thread index variable.
Definition: SCF.cpp:1447
SmallVector< Value > ValueVector
An owning vector of values, handy to return from functions.
Definition: SCF.h:64
SmallVector< Value > replaceAndCastForOpIterArg(RewriterBase &rewriter, scf::ForOp forOp, OpOperand &operand, Value replacement, const ValueTypeCastFnTy &castFn)
Definition: SCF.cpp:776
Include the generated interface declarations.
ValueVector results
Definition: SCF.h:68
LoopVector loops
Definition: SCF.h:67