Halide 22.0.0 Halide compiler and libraries

IRPrinter.h
Go to the documentation of this file.
1#ifndef HALIDE_IR_PRINTER_H
2#define HALIDE_IR_PRINTER_H
3
4/** \file
5 * This header file defines operators that let you dump a Halide
6 * expression, statement, or type directly into an output stream
7 * in a human readable form.
8 * E.g:
9 \code
10 Expr foo = ...
11 std::cout << "Foo is " << foo << "\n";
12 \endcode
13 *
14 * These operators are implemented using \ref Halide::Internal::IRPrinter
15 */
16
17#include <ostream>
18
19#include "IRVisitor.h"
20#include "Module.h"
21#include "Scope.h"
22
23 namespace Halide {
24
25/** Emit an expression on an output stream (such as std::cout) in
26 * human-readable form */
27std::ostream &operator<<(std::ostream &stream, const Expr &);
28
29/** Emit a tuple on an output stream (such as std::cout) in
30 * human-readable form */
31std::ostream &operator<<(std::ostream &stream, const Tuple &);
32
33/** Emit a halide type on an output stream (such as std::cout) in
34 * human-readable form */
35std::ostream &operator<<(std::ostream &stream, const Type &);
36
37/** Emit a halide Module on an output stream (such as std::cout) in
38 * human-readable form */
39std::ostream &operator<<(std::ostream &stream, const Module &);
40
41/** Emit a halide device api type in human-readable form */
42std::ostream &operator<<(std::ostream &stream, const DeviceAPI &);
43
44/** Emit a halide memory type in human-readable form */
45std::ostream &operator<<(std::ostream &stream, const MemoryType &);
46
47/** Emit a halide tail strategy in human-readable form */
48std::ostream &operator<<(std::ostream &stream, const TailStrategy &);
49
50/** Emit a halide loop partitioning policy in human-readable form */
51std::ostream &operator<<(std::ostream &stream, const Partition &);
52
53/** Emit a halide LoopLevel in human-readable form */
54std::ostream &operator<<(std::ostream &stream, const LoopLevel &);
55
56 struct Target;
57/** Emit a halide Target in a human readable form */
58std::ostream &operator<<(std::ostream &stream, const Target &);
59
60 namespace Internal {
61
62 struct AssociativePattern;
63 struct AssociativeOp;
64 class Closure;
65 struct Interval;
66 struct ConstantInterval;
67 struct ModulusRemainder;
68 enum class IRNodeType;
69
70/** Emit a halide node type on an output stream (such as std::cout) in
71 * human-readable form */
72std::ostream &operator<<(std::ostream &stream, IRNodeType);
73
74/** Emit a halide associative pattern on an output stream (such as std::cout)
75 * in a human-readable form */
76std::ostream &operator<<(std::ostream &stream, const AssociativePattern &);
77
78/** Emit a halide associative op on an output stream (such as std::cout) in a
79 * human-readable form */
80std::ostream &operator<<(std::ostream &stream, const AssociativeOp &);
81
82/** Emit a halide statement on an output stream (such as std::cout) in
83 * a human-readable form */
84std::ostream &operator<<(std::ostream &stream, const Stmt &);
85
86/** Emit a halide for loop type (vectorized, serial, etc) in a human
87 * readable form */
88std::ostream &operator<<(std::ostream &stream, const ForType &);
89
90/** Emit a horizontal vector reduction op in human-readable form. */
91std::ostream &operator<<(std::ostream &stream, const VectorReduce::Operator &);
92
93/** Emit a halide name mangling value in a human readable format */
94std::ostream &operator<<(std::ostream &stream, const NameMangling &);
95
96/** Emit a halide LoweredFunc in a human readable format */
97std::ostream &operator<<(std::ostream &stream, const LoweredFunc &);
98
99/** Emit a halide linkage value in a human readable format */
100std::ostream &operator<<(std::ostream &stream, const LinkageType &);
101
102/** Emit a halide dimension type in human-readable format */
103std::ostream &operator<<(std::ostream &stream, const DimType &);
104
105/** Emit a Closure in human-readable form */
106std::ostream &operator<<(std::ostream &out, const Closure &c);
107
108/** Emit an Interval in human-readable form */
109std::ostream &operator<<(std::ostream &out, const Interval &c);
110
111/** Emit a ConstantInterval in human-readable form */
112std::ostream &operator<<(std::ostream &out, const ConstantInterval &c);
113
114/** Emit a ModulusRemainder in human-readable form */
115std::ostream &operator<<(std::ostream &out, const ModulusRemainder &c);
116
117 struct Indentation {
118 int indent;
119};
120std::ostream &operator<<(std::ostream &stream, const Indentation &);
121
122 template<typename T>
123 struct Ansi {
124 const T &cnt;
125 const char *open, *close;
126};
127
128 template<typename T>
129std::ostream &operator<<(std::ostream &out, const Ansi<T> &a) {
130 if (a.open) {
131 out << a.open;
132 }
133 out << a.cnt;
134 if (a.close) {
135 out << a.close;
136 }
137 return out;
138}
139
140/** An IRVisitor that emits IR to the given output stream in a human
141 * readable form. Can be subclassed if you want to modify the way in
142 * which it prints.
143 */
144 class IRPrinter : public IRVisitor {
145 public:
146 /** Construct an IRPrinter pointed at a given output stream
147 * (e.g. std::cout, or a std::ofstream) */
148 explicit IRPrinter(std::ostream &);
149
150 /** emit an expression on the output stream */
151 void print(const Expr &);
152
153 /** Emit an expression on the output stream without enclosing parens */
154 void print_no_parens(const Expr &);
155
156 /** emit a statement on the output stream */
157 void print(const Stmt &);
158
159 /** emit a statement summary on the output stream */
160 void print_summary(const Stmt &);
161
162 /** emit a comma delimited list of exprs, without any leading or
163 * trailing punctuation. */
164 void print_list(const std::vector<Expr> &exprs);
165
166 static void test();
167
168 protected:
169 Indentation get_indent() const {
170 return Indentation{indent};
171 }
172
173 /** The stream on which we're outputting */
174 std::ostream &stream;
175
176 /** The current indentation level, useful for pretty-printing
177 * statements */
178 int indent = 0;
179
180 /** Certain expressions do not need parens around them, e.g. the
181 * args to a call are already separated by commas and a
182 * surrounding set of parens. */
183 bool implicit_parens = false;
184
185 /** Print only a summary of a statement, with sub-statements replaced by
186 * ellipses (...). */
187 bool is_summary = false;
188
189 bool ansi = false;
190 int paren_depth = 0;
191
192 const char *ansi_hl = "";
193 const char *ansi_dim = "";
194 const char *ansi_kw = "";
195 const char *ansi_imm_int = "";
196 const char *ansi_imm_float = "";
197 const char *ansi_imm_str = "";
198 const char *ansi_var = "";
199 const char *ansi_buf = "";
200 const char *ansi_fn = "";
201 const char *ansi_type = "";
202 const char *ansi_reset_col = "";
203 const char *ansi_reset = "";
204
205 // clang-format off
206 template<typename T> Ansi<T> hl(const T &t);
207 template<typename T> Ansi<T> kw(const T &t);
208 template<typename T> Ansi<T> imm_int(const T &t);
209 template<typename T> Ansi<T> imm_float(const T &t);
210 template<typename T> Ansi<T> imm_str(const T &t);
211 template<typename T> Ansi<T> var(const T &t);
212 template<typename T> Ansi<T> buf(const T &t);
213 template<typename T> Ansi<T> fn(const T &t);
214 template<typename T> Ansi<T> type(const T &t);
215 template<typename T> Ansi<T> typep(const T &t);
216 template<typename T> Ansi<T> paren(const T &t, bool bold = true, int d = -1);
217 // clang-format on
218
219 /** Either emits "(" or "", depending on the value of implicit_parens */
220 void open();
221
222 /** Either emits ")" or "", depending on the value of implicit_parens */
223 void close();
224
225 /** Emits "(" always */
226 void openf();
227
228 /** Emits "name(" always */
229 void openf(const char *name);
230
231 /** Emits ")" always */
232 void closef();
233
234 /** The symbols whose types can be inferred from values printed
235 * already. */
236 Scope<> known_type;
237
238 /** A helper for printing a chain of lets with line breaks */
239 void print_lets(const Let *let);
240
241 /** A helper for printing a braced statement */
242 void print_braced_stmt(const Stmt &, int extra_indent = 2);
243
244 void visit(const IntImm *) override;
245 void visit(const UIntImm *) override;
246 void visit(const FloatImm *) override;
247 void visit(const StringImm *) override;
248 void visit(const Cast *) override;
249 void visit(const Reinterpret *) override;
250 void visit(const Variable *) override;
251 void visit(const Add *) override;
252 void visit(const Sub *) override;
253 void visit(const Mul *) override;
254 void visit(const Div *) override;
255 void visit(const Mod *) override;
256 void visit(const Min *) override;
257 void visit(const Max *) override;
258 void visit(const EQ *) override;
259 void visit(const NE *) override;
260 void visit(const LT *) override;
261 void visit(const LE *) override;
262 void visit(const GT *) override;
263 void visit(const GE *) override;
264 void visit(const And *) override;
265 void visit(const Or *) override;
266 void visit(const Not *) override;
267 void visit(const Select *) override;
268 void visit(const Load *) override;
269 void visit(const Ramp *) override;
270 void visit(const Broadcast *) override;
271 void visit(const Call *) override;
272 void visit(const Let *) override;
273 void visit(const LetStmt *) override;
274 void visit(const AssertStmt *) override;
275 void visit(const ProducerConsumer *) override;
276 void visit(const For *) override;
277 void visit(const Acquire *) override;
278 void visit(const Store *) override;
279 void visit(const Provide *) override;
280 void visit(const Allocate *) override;
281 void visit(const Free *) override;
282 void visit(const Realize *) override;
283 void visit(const Block *) override;
284 void visit(const Fork *) override;
285 void visit(const IfThenElse *) override;
286 void visit(const Evaluate *) override;
287 void visit(const Shuffle *) override;
288 void visit(const VectorReduce *) override;
289 void visit(const Prefetch *) override;
290 void visit(const Atomic *) override;
291 void visit(const HoistedStorage *) override;
292};
293
294/** Debugging helpers for LLDB */
295/// @{
296 std::string lldb_string(const Expr &);
297std::string lldb_string(const Internal::BaseExprNode *);
298std::string lldb_string(const Stmt &);
299/// @}
300
301} // namespace Internal
302} // namespace Halide
303
304#endif
IRVisitor.h
Defines the base class for things that recursively walk over the IR.
Module.h
Defines Module, an IR container that fully describes a Halide program.
Scope.h
Defines the Scope class, which is used for keeping track of names in a scope while traversing IR.
Halide::Internal::Closure
A helper class to manage closures.
Definition: Closure.h:26
Halide::Internal::IRPrinter
An IRVisitor that emits IR to the given output stream in a human readable form.
Definition: IRPrinter.h:144
Halide::Internal::IRPrinter::visit
void visit(const EQ *) override
Halide::Internal::IRPrinter::var
Ansi< T > var(const T &t)
Halide::Internal::IRPrinter::visit
void visit(const Sub *) override
Halide::Internal::IRPrinter::buf
Ansi< T > buf(const T &t)
Halide::Internal::IRPrinter::visit
void visit(const Provide *) override
Halide::Internal::IRPrinter::visit
void visit(const And *) override
Halide::Internal::IRPrinter::known_type
Scope known_type
The symbols whose types can be inferred from values printed already.
Definition: IRPrinter.h:236
Halide::Internal::IRPrinter::visit
void visit(const GE *) override
Halide::Internal::IRPrinter::ansi_reset_col
const char * ansi_reset_col
Definition: IRPrinter.h:202
Halide::Internal::IRPrinter::visit
void visit(const Div *) override
Halide::Internal::IRPrinter::visit
void visit(const Free *) override
Halide::Internal::IRPrinter::visit
void visit(const Or *) override
Halide::Internal::IRPrinter::indent
int indent
The current indentation level, useful for pretty-printing statements.
Definition: IRPrinter.h:178
Halide::Internal::IRPrinter::imm_int
Ansi< T > imm_int(const T &t)
Halide::Internal::IRPrinter::type
Ansi< T > type(const T &t)
Halide::Internal::IRPrinter::ansi_var
const char * ansi_var
Definition: IRPrinter.h:198
Halide::Internal::IRPrinter::print
void print(const Expr &)
emit an expression on the output stream
Halide::Internal::IRPrinter::visit
void visit(const Load *) override
Halide::Internal::IRPrinter::visit
void visit(const UIntImm *) override
Halide::Internal::IRPrinter::print_no_parens
void print_no_parens(const Expr &)
Emit an expression on the output stream without enclosing parens.
Halide::Internal::IRPrinter::print_lets
void print_lets(const Let *let)
A helper for printing a chain of lets with line breaks.
Halide::Internal::IRPrinter::typep
Ansi< T > typep(const T &t)
Halide::Internal::IRPrinter::imm_str
Ansi< T > imm_str(const T &t)
Halide::Internal::IRPrinter::visit
void visit(const Variable *) override
Halide::Internal::IRPrinter::ansi_buf
const char * ansi_buf
Definition: IRPrinter.h:199
Halide::Internal::IRPrinter::visit
void visit(const Max *) override
Halide::Internal::IRPrinter::test
static void test()
Halide::Internal::IRPrinter::ansi_type
const char * ansi_type
Definition: IRPrinter.h:201
Halide::Internal::IRPrinter::visit
void visit(const Block *) override
Halide::Internal::IRPrinter::imm_float
Ansi< T > imm_float(const T &t)
Halide::Internal::IRPrinter::visit
void visit(const Reinterpret *) override
Halide::Internal::IRPrinter::ansi_imm_float
const char * ansi_imm_float
Definition: IRPrinter.h:196
Halide::Internal::IRPrinter::kw
Ansi< T > kw(const T &t)
Halide::Internal::IRPrinter::visit
void visit(const Add *) override
Halide::Internal::IRPrinter::fn
Ansi< T > fn(const T &t)
Halide::Internal::IRPrinter::visit
void visit(const Ramp *) override
Halide::Internal::IRPrinter::ansi_reset
const char * ansi_reset
Definition: IRPrinter.h:203
Halide::Internal::IRPrinter::print_list
void print_list(const std::vector< Expr > &exprs)
emit a comma delimited list of exprs, without any leading or trailing punctuation.
Halide::Internal::IRPrinter::visit
void visit(const Acquire *) override
Halide::Internal::IRPrinter::ansi
bool ansi
Definition: IRPrinter.h:189
Halide::Internal::IRPrinter::closef
void closef()
Emits ")" always.
Halide::Internal::IRPrinter::visit
void visit(const AssertStmt *) override
Halide::Internal::IRPrinter::get_indent
Indentation get_indent() const
Definition: IRPrinter.h:169
Halide::Internal::IRPrinter::visit
void visit(const Mul *) override
Halide::Internal::IRPrinter::print_summary
void print_summary(const Stmt &)
emit a statement summary on the output stream
Halide::Internal::IRPrinter::visit
void visit(const Prefetch *) override
Halide::Internal::IRPrinter::ansi_dim
const char * ansi_dim
Definition: IRPrinter.h:193
Halide::Internal::IRPrinter::openf
void openf(const char *name)
Emits "name(" always.
Halide::Internal::IRPrinter::visit
void visit(const Atomic *) override
Halide::Internal::IRPrinter::openf
void openf()
Emits "(" always.
Halide::Internal::IRPrinter::implicit_parens
bool implicit_parens
Certain expressions do not need parens around them, e.g.
Definition: IRPrinter.h:183
Halide::Internal::IRPrinter::visit
void visit(const Cast *) override
Halide::Internal::IRPrinter::visit
void visit(const VectorReduce *) override
Halide::Internal::IRPrinter::ansi_kw
const char * ansi_kw
Definition: IRPrinter.h:194
Halide::Internal::IRPrinter::visit
void visit(const LetStmt *) override
Halide::Internal::IRPrinter::visit
void visit(const StringImm *) override
Halide::Internal::IRPrinter::visit
void visit(const Realize *) override
Halide::Internal::IRPrinter::ansi_imm_int
const char * ansi_imm_int
Definition: IRPrinter.h:195
Halide::Internal::IRPrinter::visit
void visit(const LE *) override
Halide::Internal::IRPrinter::visit
void visit(const Broadcast *) override
Halide::Internal::IRPrinter::visit
void visit(const Evaluate *) override
Halide::Internal::IRPrinter::stream
std::ostream & stream
The stream on which we're outputting.
Definition: IRPrinter.h:174
Halide::Internal::IRPrinter::ansi_hl
const char * ansi_hl
Definition: IRPrinter.h:192
Halide::Internal::IRPrinter::visit
void visit(const Select *) override
Halide::Internal::IRPrinter::visit
void visit(const FloatImm *) override
Halide::Internal::IRPrinter::is_summary
bool is_summary
Print only a summary of a statement, with sub-statements replaced by ellipses (......
Definition: IRPrinter.h:187
Halide::Internal::IRPrinter::visit
void visit(const IntImm *) override
Halide::Internal::IRPrinter::hl
Ansi< T > hl(const T &t)
Halide::Internal::IRPrinter::IRPrinter
IRPrinter(std::ostream &)
Construct an IRPrinter pointed at a given output stream (e.g.
Halide::Internal::IRPrinter::visit
void visit(const LT *) override
Halide::Internal::IRPrinter::visit
void visit(const For *) override
Halide::Internal::IRPrinter::visit
void visit(const Store *) override
Halide::Internal::IRPrinter::paren_depth
int paren_depth
Definition: IRPrinter.h:190
Halide::Internal::IRPrinter::visit
void visit(const Mod *) override
Halide::Internal::IRPrinter::ansi_fn
const char * ansi_fn
Definition: IRPrinter.h:200
Halide::Internal::IRPrinter::print_braced_stmt
void print_braced_stmt(const Stmt &, int extra_indent=2)
A helper for printing a braced statement.
Halide::Internal::IRPrinter::close
void close()
Either emits ")" or "", depending on the value of implicit_parens.
Halide::Internal::IRPrinter::visit
void visit(const ProducerConsumer *) override
Halide::Internal::IRPrinter::visit
void visit(const HoistedStorage *) override
Halide::Internal::IRPrinter::visit
void visit(const Shuffle *) override
Halide::Internal::IRPrinter::visit
void visit(const Not *) override
Halide::Internal::IRPrinter::visit
void visit(const GT *) override
Halide::Internal::IRPrinter::visit
void visit(const NE *) override
Halide::Internal::IRPrinter::paren
Ansi< T > paren(const T &t, bool bold=true, int d=-1)
Halide::Internal::IRPrinter::print
void print(const Stmt &)
emit a statement on the output stream
Halide::Internal::IRPrinter::ansi_imm_str
const char * ansi_imm_str
Definition: IRPrinter.h:197
Halide::Internal::IRPrinter::visit
void visit(const Min *) override
Halide::Internal::IRPrinter::open
void open()
Either emits "(" or "", depending on the value of implicit_parens.
Halide::Internal::IRPrinter::visit
void visit(const IfThenElse *) override
Halide::Internal::IRPrinter::visit
void visit(const Call *) override
Halide::Internal::IRPrinter::visit
void visit(const Fork *) override
Halide::Internal::IRPrinter::visit
void visit(const Allocate *) override
Halide::Internal::IRPrinter::visit
void visit(const Let *) override
Halide::Internal::IRVisitor
A base class for algorithms that need to recursively walk over the IR.
Definition: IRVisitor.h:19
Halide::Internal::Scope
A common pattern when traversing Halide IR is that you need to keep track of stuff when you find a Le...
Definition: Scope.h:94
Halide::LoopLevel
A reference to a site in a Halide statement at the top of the body of a particular for loop.
Definition: Schedule.h:203
Halide::Module
A halide module.
Definition: Module.h:142
Halide::Tuple
Create a small array of Exprs for defining and calling functions with multiple outputs.
Definition: Tuple.h:18
Halide::Internal::DimType
DimType
Each Dim below has a dim_type, which tells you what transformations are legal on it.
Definition: Schedule.h:352
Halide::Internal::ForType
ForType
An enum describing a type of loop traversal.
Definition: Expr.h:406
Halide::Internal::lldb_string
std::string lldb_string(const Expr &)
Debugging helpers for LLDB.
Halide::Internal::operator<<
ConstantInterval operator<<(const ConstantInterval &a, const ConstantInterval &b)
Halide::Internal::IRNodeType
IRNodeType
All our IR node types get unique IDs for the purposes of RTTI.
Definition: Expr.h:25
Halide
This file defines the class FunctionDAG, which is our representation of a Halide pipeline,...
Definition: AbstractGenerator.h:19
Halide::LinkageType
LinkageType
Type of linkage a function in a lowered Halide module can have.
Definition: Module.h:52
Halide::LinkageType::Internal
@ Internal
Not visible externally, similar to 'static' linkage in C.
Halide::TailStrategy
TailStrategy
Different ways to handle a tail case in a split when the factor does not provably divide the extent.
Definition: Schedule.h:33
Halide::operator<<
std::ostream & operator<<(std::ostream &stream, const Expr &)
Emit an expression on an output stream (such as std::cout) in human-readable form.
Halide::NameMangling
NameMangling
An enum to specify calling convention for extern stages.
Definition: Function.h:26
Halide::DeviceAPI
DeviceAPI
An enum describing a type of device API.
Definition: DeviceAPI.h:15
Halide::MemoryType
MemoryType
An enum describing different address spaces to be used with Func::store_in.
Definition: Expr.h:353
Halide::Partition
Partition
Different ways to handle loops with a potentially optimizable boundary conditions.
Definition: LoopPartitioningDirective.h:16
Halide::Expr
A fragment of Halide syntax.
Definition: Expr.h:258
Halide::Internal::Acquire
Definition: IR.h:882
Halide::Internal::Add
The sum of two expressions.
Definition: IR.h:66
Halide::Internal::Allocate
Allocate a scratch area called with the given name, type, and size.
Definition: IR.h:381
Halide::Internal::And
Logical and - are both expressions true.
Definition: IR.h:185
Halide::Internal::Ansi
Definition: IRPrinter.h:123
Halide::Internal::Ansi::close
const char * close
Definition: IRPrinter.h:125
Halide::Internal::Ansi::cnt
const T & cnt
Definition: IRPrinter.h:124
Halide::Internal::Ansi::open
const char * open
Definition: IRPrinter.h:125
Halide::Internal::AssertStmt
If the 'condition' is false, then evaluate and return the message, which should be a call to an error...
Definition: IR.h:304
Halide::Internal::AssociativeOp
Represent the equivalent associative op of an update definition.
Definition: Associativity.h:61
Halide::Internal::AssociativePattern
Represent an associative op with its identity.
Definition: AssociativeOpsTable.h:31
Halide::Internal::Atomic
Lock all the Store nodes in the body statement.
Definition: IR.h:1004
Halide::Internal::BaseExprNode
A base class for expression nodes.
Definition: Expr.h:143
Halide::Internal::Block
A sequence of statements to be executed in-order.
Definition: IR.h:452
Halide::Internal::Broadcast
A vector with 'lanes' elements, in which every element is 'value'.
Definition: IR.h:269
Halide::Internal::Call
A function call.
Definition: IR.h:500
Halide::Internal::Cast
The actual IR nodes begin here.
Definition: IR.h:40
Halide::Internal::ConstantInterval
A class to represent ranges of integers.
Definition: ConstantInterval.h:18
Halide::Internal::Div
The ratio of two expressions.
Definition: IR.h:93
Halide::Internal::EQ
Is the first expression equal to the second.
Definition: IR.h:131
Halide::Internal::Evaluate
Evaluate and discard an expression, presumably because it has some side-effect.
Definition: IR.h:486
Halide::Internal::FloatImm
Floating point constants.
Definition: Expr.h:236
Halide::Internal::For
A for loop.
Definition: IR.h:858
Halide::Internal::Fork
A pair of statements executed concurrently.
Definition: IR.h:467
Halide::Internal::Free
Free the resources associated with the given buffer.
Definition: IR.h:423
Halide::Internal::GE
Is the first expression greater than or equal to the second.
Definition: IR.h:176
Halide::Internal::GT
Is the first expression greater than the second.
Definition: IR.h:167
Halide::Internal::HoistedStorage
Represents a location where storage will be hoisted to for a Func / Realize node with a given name.
Definition: IR.h:988
Halide::Internal::IfThenElse
An if-then-else block.
Definition: IR.h:476
Halide::Internal::Indentation
Definition: IRPrinter.h:117
Halide::Internal::Indentation::indent
int indent
Definition: IRPrinter.h:118
Halide::Internal::IntImm
Integer constants.
Definition: Expr.h:218
Halide::Internal::Interval
A class to represent ranges of Exprs.
Definition: Interval.h:14
Halide::Internal::LE
Is the first expression less than or equal to the second.
Definition: IR.h:158
Halide::Internal::LT
Is the first expression less than the second.
Definition: IR.h:149
Halide::Internal::Let
A let expression, like you might find in a functional language.
Definition: IR.h:281
Halide::Internal::LetStmt
The statement form of a let node.
Definition: IR.h:292
Halide::Internal::Load
Load a value from a named symbol if predicate is true.
Definition: IR.h:227
Halide::Internal::LoweredFunc
Definition of a lowered function.
Definition: Module.h:101
Halide::Internal::Max
The greater of two values.
Definition: IR.h:122
Halide::Internal::Min
The lesser of two values.
Definition: IR.h:113
Halide::Internal::Mod
The remainder of a / b.
Definition: IR.h:104
Halide::Internal::ModulusRemainder
The result of modulus_remainder analysis.
Definition: ModulusRemainder.h:33
Halide::Internal::Mul
The product of two expressions.
Definition: IR.h:84
Halide::Internal::NE
Is the first expression not equal to the second.
Definition: IR.h:140
Halide::Internal::Not
Logical not - true if the expression false.
Definition: IR.h:203
Halide::Internal::Or
Logical or - is at least one of the expression true.
Definition: IR.h:194
Halide::Internal::Prefetch
Represent a multi-dimensional region of a Func or an ImageParam that needs to be prefetched.
Definition: IR.h:966
Halide::Internal::ProducerConsumer
This node is a helpful annotation to do with permissions.
Definition: IR.h:325
Halide::Internal::Provide
This defines the value of a function at a multi-dimensional location.
Definition: IR.h:364
Halide::Internal::Ramp
A linear ramp vector node.
Definition: IR.h:257
Halide::Internal::Realize
Allocate a multi-dimensional buffer of the given type and size.
Definition: IR.h:437
Halide::Internal::Reinterpret
Reinterpret value as another type, without affecting any of the bits (on little-endian systems).
Definition: IR.h:57
Halide::Internal::Select
A ternary operator.
Definition: IR.h:214
Halide::Internal::Shuffle
Construct a new vector by taking elements from another sequence of vectors.
Definition: IR.h:894
Halide::Internal::Stmt
A reference-counted handle to a statement node.
Definition: Expr.h:427
Halide::Internal::Store
Store a 'value' to the buffer called 'name' at a given 'index' if 'predicate' is true.
Definition: IR.h:343
Halide::Internal::StringImm
String constants.
Definition: Expr.h:245
Halide::Internal::Sub
The difference of two expressions.
Definition: IR.h:75
Halide::Internal::UIntImm
Unsigned integer constants.
Definition: Expr.h:227
Halide::Internal::Variable
A named variable.
Definition: IR.h:811
Halide::Internal::VectorReduce
Horizontally reduce a vector to a scalar or narrower vector using the given commutative and associati...
Definition: IR.h:1022
Halide::Internal::VectorReduce::Operator
Operator
Definition: IR.h:1026
Halide::Target
A struct representing a target machine and os to generate code for.
Definition: Target.h:19
Halide::Type
Types in the halide type system.
Definition: Type.h:281