Halide 19.0.0
Halide compiler and libraries
Loading...
Searching...
No Matches
IRMutator.h
Go to the documentation of this file.
1#ifndef HALIDE_IR_MUTATOR_H
2#define HALIDE_IR_MUTATOR_H
3
4/** \file
5 * Defines a base class for passes over the IR that modify it
6 */
7
8#include <map>
9
10#include "IR.h"
11
12namespace Halide {
13namespace Internal {
14
15/** A base class for passes over the IR which modify it
16 * (e.g. replacing a variable with a value (Substitute.h), or
17 * constant-folding).
18 *
19 * Your mutator should override the visit() methods you care about and return
20 * the new expression or stmt. The default implementations recursively
21 * mutate their children. To mutate sub-expressions and sub-statements you
22 * should override the mutate() method, which will dispatch to
23 * the appropriate visit() method and then return the value of expr or
24 * stmt after the call to visit.
25 */
26class IRMutator {
27public:
28 IRMutator() = default;
29 virtual ~IRMutator() = default;
30
31 /** This is the main interface for using a mutator. Also call
32 * these in your subclass to mutate sub-expressions and
33 * sub-statements.
34 */
35 virtual Expr mutate(const Expr &expr);
36 virtual Stmt mutate(const Stmt &stmt);
37
38 // Mutate all the Exprs and return the new list in ret, along with
39 // a flag that is true iff at least one item in the list changed.
40 std::pair<std::vector<Expr>, bool> mutate_with_changes(const std::vector<Expr> &);
41
42 // Like mutate_with_changes, but discard the changes flag.
43 std::vector<Expr> mutate(const std::vector<Expr> &exprs) {
44 return mutate_with_changes(exprs).first;
45 }
46
47protected:
48 // ExprNode<> and StmtNode<> are allowed to call visit (to implement mutate_expr/mutate_stmt())
49 template<typename T>
50 friend struct ExprNode;
51 template<typename T>
52 friend struct StmtNode;
53
54 virtual Expr visit(const IntImm *);
55 virtual Expr visit(const UIntImm *);
56 virtual Expr visit(const FloatImm *);
57 virtual Expr visit(const StringImm *);
58 virtual Expr visit(const Cast *);
59 virtual Expr visit(const Reinterpret *);
60 virtual Expr visit(const Variable *);
61 virtual Expr visit(const Add *);
62 virtual Expr visit(const Sub *);
63 virtual Expr visit(const Mul *);
64 virtual Expr visit(const Div *);
65 virtual Expr visit(const Mod *);
66 virtual Expr visit(const Min *);
67 virtual Expr visit(const Max *);
68 virtual Expr visit(const EQ *);
69 virtual Expr visit(const NE *);
70 virtual Expr visit(const LT *);
71 virtual Expr visit(const LE *);
72 virtual Expr visit(const GT *);
73 virtual Expr visit(const GE *);
74 virtual Expr visit(const And *);
75 virtual Expr visit(const Or *);
76 virtual Expr visit(const Not *);
77 virtual Expr visit(const Select *);
78 virtual Expr visit(const Load *);
79 virtual Expr visit(const Ramp *);
80 virtual Expr visit(const Broadcast *);
81 virtual Expr visit(const Call *);
82 virtual Expr visit(const Let *);
83 virtual Expr visit(const Shuffle *);
84 virtual Expr visit(const VectorReduce *);
85
86 virtual Stmt visit(const LetStmt *);
87 virtual Stmt visit(const AssertStmt *);
88 virtual Stmt visit(const ProducerConsumer *);
89 virtual Stmt visit(const For *);
90 virtual Stmt visit(const Store *);
91 virtual Stmt visit(const Provide *);
92 virtual Stmt visit(const Allocate *);
93 virtual Stmt visit(const Free *);
94 virtual Stmt visit(const Realize *);
95 virtual Stmt visit(const Block *);
96 virtual Stmt visit(const IfThenElse *);
97 virtual Stmt visit(const Evaluate *);
98 virtual Stmt visit(const Prefetch *);
99 virtual Stmt visit(const Acquire *);
100 virtual Stmt visit(const Fork *);
101 virtual Stmt visit(const Atomic *);
102 virtual Stmt visit(const HoistedStorage *);
103};
104
105/** A mutator that caches and reapplies previously-done mutations, so
106 * that it can handle graphs of IR that have not had CSE done to
107 * them. */
108class IRGraphMutator : public IRMutator {
109protected:
110 std::map<Expr, Expr, ExprCompare> expr_replacements;
111 std::map<Stmt, Stmt, Stmt::Compare> stmt_replacements;
112
113public:
114 Stmt mutate(const Stmt &s) override;
115 Expr mutate(const Expr &e) override;
116
117 std::vector<Expr> mutate(const std::vector<Expr> &exprs) {
118 return IRMutator::mutate(exprs);
119 }
120};
121
122/** A helper function for mutator-like things to mutate regions */
123template<typename Mutator, typename... Args>
124std::pair<Region, bool> mutate_region(Mutator *mutator, const Region &bounds, Args &&...args) {
125 Region new_bounds(bounds.size());
126 bool bounds_changed = false;
127
128 for (size_t i = 0; i < bounds.size(); i++) {
129 Expr old_min = bounds[i].min;
130 Expr old_extent = bounds[i].extent;
131 Expr new_min = mutator->mutate(old_min, args...);
132 Expr new_extent = mutator->mutate(old_extent, args...);
133 if (!new_min.same_as(old_min)) {
134 bounds_changed = true;
135 }
136 if (!new_extent.same_as(old_extent)) {
137 bounds_changed = true;
138 }
139 new_bounds[i] = Range(new_min, new_extent);
140 }
141 return {new_bounds, bounds_changed};
142}
143
144} // namespace Internal
145} // namespace Halide
146
147#endif
Subtypes for Halide expressions (Halide::Expr) and statements (Halide::Internal::Stmt)
A mutator that caches and reapplies previously-done mutations, so that it can handle graphs of IR tha...
Definition IRMutator.h:108
std::map< Expr, Expr, ExprCompare > expr_replacements
Definition IRMutator.h:110
Expr mutate(const Expr &e) override
This is the main interface for using a mutator.
Stmt mutate(const Stmt &s) override
std::vector< Expr > mutate(const std::vector< Expr > &exprs)
Definition IRMutator.h:117
std::map< Stmt, Stmt, Stmt::Compare > stmt_replacements
Definition IRMutator.h:111
A base class for passes over the IR which modify it (e.g.
Definition IRMutator.h:26
std::vector< Expr > mutate(const std::vector< Expr > &exprs)
Definition IRMutator.h:43
virtual Stmt visit(const Free *)
virtual Expr visit(const Broadcast *)
virtual Expr visit(const VectorReduce *)
virtual Expr visit(const Call *)
virtual Stmt visit(const Atomic *)
virtual Expr visit(const Let *)
virtual Stmt visit(const Provide *)
virtual Expr visit(const Ramp *)
virtual Expr visit(const Mod *)
virtual Expr visit(const LE *)
virtual Expr visit(const Reinterpret *)
virtual Stmt visit(const Store *)
virtual Expr visit(const Max *)
virtual Stmt visit(const HoistedStorage *)
virtual Expr visit(const Cast *)
virtual Stmt mutate(const Stmt &stmt)
virtual Stmt visit(const Block *)
virtual Expr visit(const Load *)
virtual Stmt visit(const Fork *)
virtual Stmt visit(const Allocate *)
virtual Stmt visit(const LetStmt *)
virtual Expr visit(const Or *)
virtual Expr visit(const And *)
virtual Stmt visit(const Acquire *)
std::pair< std::vector< Expr >, bool > mutate_with_changes(const std::vector< Expr > &)
virtual Stmt visit(const ProducerConsumer *)
virtual Expr visit(const Variable *)
virtual Expr visit(const Shuffle *)
virtual Expr visit(const LT *)
virtual Stmt visit(const For *)
virtual ~IRMutator()=default
virtual Expr visit(const Min *)
virtual Stmt visit(const AssertStmt *)
virtual Expr visit(const EQ *)
virtual Expr visit(const GT *)
virtual Expr visit(const Not *)
virtual Expr visit(const Add *)
virtual Expr visit(const NE *)
virtual Expr visit(const Div *)
virtual Expr visit(const Sub *)
virtual Stmt visit(const Evaluate *)
virtual Stmt visit(const Prefetch *)
virtual Stmt visit(const Realize *)
virtual Expr visit(const IntImm *)
virtual Expr mutate(const Expr &expr)
This is the main interface for using a mutator.
virtual Expr visit(const GE *)
virtual Expr visit(const UIntImm *)
virtual Stmt visit(const IfThenElse *)
virtual Expr visit(const FloatImm *)
virtual Expr visit(const Select *)
virtual Expr visit(const Mul *)
virtual Expr visit(const StringImm *)
std::pair< Region, bool > mutate_region(Mutator *mutator, const Region &bounds, Args &&...args)
A helper function for mutator-like things to mutate regions.
Definition IRMutator.h:124
This file defines the class FunctionDAG, which is our representation of a Halide pipeline,...
@ Internal
Not visible externally, similar to 'static' linkage in C.
std::vector< Range > Region
A multi-dimensional box.
Definition Expr.h:350
A fragment of Halide syntax.
Definition Expr.h:258
The sum of two expressions.
Definition IR.h:56
Allocate a scratch area called with the given name, type, and size.
Definition IR.h:371
Logical and - are both expressions true.
Definition IR.h:175
If the 'condition' is false, then evaluate and return the message, which should be a call to an error...
Definition IR.h:294
Lock all the Store nodes in the body statement.
Definition IR.h:961
A sequence of statements to be executed in-order.
Definition IR.h:442
A vector with 'lanes' elements, in which every element is 'value'.
Definition IR.h:259
A function call.
Definition IR.h:490
The actual IR nodes begin here.
Definition IR.h:30
The ratio of two expressions.
Definition IR.h:83
Is the first expression equal to the second.
Definition IR.h:121
Evaluate and discard an expression, presumably because it has some side-effect.
Definition IR.h:476
We use the "curiously recurring template pattern" to avoid duplicated code in the IR Nodes.
Definition Expr.h:158
Floating point constants.
Definition Expr.h:236
A for loop.
Definition IR.h:819
A pair of statements executed concurrently.
Definition IR.h:457
Free the resources associated with the given buffer.
Definition IR.h:413
Is the first expression greater than or equal to the second.
Definition IR.h:166
Is the first expression greater than the second.
Definition IR.h:157
Represents a location where storage will be hoisted to for a Func / Realize node with a given name.
Definition IR.h:945
An if-then-else block.
Definition IR.h:466
Integer constants.
Definition Expr.h:218
HALIDE_ALWAYS_INLINE bool same_as(const IntrusivePtr &other) const
Is the first expression less than or equal to the second.
Definition IR.h:148
Is the first expression less than the second.
Definition IR.h:139
A let expression, like you might find in a functional language.
Definition IR.h:271
The statement form of a let node.
Definition IR.h:282
Load a value from a named symbol if predicate is true.
Definition IR.h:217
The greater of two values.
Definition IR.h:112
The lesser of two values.
Definition IR.h:103
The remainder of a / b.
Definition IR.h:94
The product of two expressions.
Definition IR.h:74
Is the first expression not equal to the second.
Definition IR.h:130
Logical not - true if the expression false.
Definition IR.h:193
Logical or - is at least one of the expression true.
Definition IR.h:184
Represent a multi-dimensional region of a Func or an ImageParam that needs to be prefetched.
Definition IR.h:923
This node is a helpful annotation to do with permissions.
Definition IR.h:315
This defines the value of a function at a multi-dimensional location.
Definition IR.h:354
A linear ramp vector node.
Definition IR.h:247
Allocate a multi-dimensional buffer of the given type and size.
Definition IR.h:427
Reinterpret value as another type, without affecting any of the bits (on little-endian systems).
Definition IR.h:47
A ternary operator.
Definition IR.h:204
Construct a new vector by taking elements from another sequence of vectors.
Definition IR.h:855
A reference-counted handle to a statement node.
Definition Expr.h:427
Store a 'value' to the buffer called 'name' at a given 'index' if 'predicate' is true.
Definition IR.h:333
String constants.
Definition Expr.h:245
The difference of two expressions.
Definition IR.h:65
Unsigned integer constants.
Definition Expr.h:227
A named variable.
Definition IR.h:772
Horizontally reduce a vector to a scalar or narrower vector using the given commutative and associati...
Definition IR.h:979
A single-dimensional span.
Definition Expr.h:342