Loading...
Searching...
No Matches
IRPrinter.h
Go to the documentation of this file.
#ifndef HALIDE_IR_PRINTER_H
#define HALIDE_IR_PRINTER_H
/** \file
* This header file defines operators that let you dump a Halide
* expression, statement, or type directly into an output stream
* in a human readable form.
* E.g:
\code
Expr foo = ...
std::cout << "Foo is " << foo << "\n";
\endcode
*
* These operators are implemented using \ref Halide::Internal::IRPrinter
*/
#include <ostream>
#include "IRVisitor.h"
#include "Module.h"
#include "Scope.h"
namespace Halide {
/** Emit an expression on an output stream (such as std::cout) in
* human-readable form */
std::ostream &operator<<(std::ostream &stream, const Expr &);
/** Emit a halide type on an output stream (such as std::cout) in
* human-readable form */
std::ostream &operator<<(std::ostream &stream, const Type &);
/** Emit a halide Module on an output stream (such as std::cout) in
* human-readable form */
std::ostream &operator<<(std::ostream &stream, const Module &);
/** Emit a halide device api type in human-readable form */
std::ostream &operator<<(std::ostream &stream, const DeviceAPI &);
/** Emit a halide memory type in human-readable form */
std::ostream &operator<<(std::ostream &stream, const MemoryType &);
/** Emit a halide tail strategy in human-readable form */
std::ostream &operator<<(std::ostream &stream, const TailStrategy &);
/** Emit a halide loop partitioning policy in human-readable form */
std::ostream &operator<<(std::ostream &stream, const Partition &);
/** Emit a halide LoopLevel in human-readable form */
std::ostream &operator<<(std::ostream &stream, const LoopLevel &);
struct Target;
/** Emit a halide Target in a human readable form */
std::ostream &operator<<(std::ostream &stream, const Target &);
namespace Internal {
struct AssociativePattern;
struct AssociativeOp;
class Closure;
struct Interval;
struct ConstantInterval;
struct ModulusRemainder;
enum class IRNodeType;
/** Emit a halide node type on an output stream (such as std::cout) in
* human-readable form */
std::ostream &operator<<(std::ostream &stream, IRNodeType);
/** Emit a halide associative pattern on an output stream (such as std::cout)
* in a human-readable form */
std::ostream &operator<<(std::ostream &stream, const AssociativePattern &);
/** Emit a halide associative op on an output stream (such as std::cout) in a
* human-readable form */
std::ostream &operator<<(std::ostream &stream, const AssociativeOp &);
/** Emit a halide statement on an output stream (such as std::cout) in
* a human-readable form */
std::ostream &operator<<(std::ostream &stream, const Stmt &);
/** Emit a halide for loop type (vectorized, serial, etc) in a human
* readable form */
std::ostream &operator<<(std::ostream &stream, const ForType &);
/** Emit a horizontal vector reduction op in human-readable form. */
std::ostream &operator<<(std::ostream &stream, const VectorReduce::Operator &);
/** Emit a halide name mangling value in a human readable format */
std::ostream &operator<<(std::ostream &stream, const NameMangling &);
/** Emit a halide LoweredFunc in a human readable format */
std::ostream &operator<<(std::ostream &stream, const LoweredFunc &);
/** Emit a halide linkage value in a human readable format */
std::ostream &operator<<(std::ostream &stream, const LinkageType &);
/** Emit a halide dimension type in human-readable format */
std::ostream &operator<<(std::ostream &stream, const DimType &);
/** Emit a Closure in human-readable form */
std::ostream &operator<<(std::ostream &out, const Closure &c);
/** Emit an Interval in human-readable form */
std::ostream &operator<<(std::ostream &out, const Interval &c);
/** Emit a ConstantInterval in human-readable form */
std::ostream &operator<<(std::ostream &out, const ConstantInterval &c);
/** Emit a ModulusRemainder in human-readable form */
std::ostream &operator<<(std::ostream &out, const ModulusRemainder &c);
struct Indentation {
int indent;
};
std::ostream &operator<<(std::ostream &stream, const Indentation &);
template<typename T>
struct Ansi {
const T &cnt;
const char *open, *close;
};
template<typename T>
std::ostream &operator<<(std::ostream &out, const Ansi<T> &a) {
if (a.open) {
out << a.open;
}
out << a.cnt;
if (a.close) {
out << a.close;
}
return out;
}
/** An IRVisitor that emits IR to the given output stream in a human
* readable form. Can be subclassed if you want to modify the way in
* which it prints.
*/
class IRPrinter : public IRVisitor {
public:
/** Construct an IRPrinter pointed at a given output stream
* (e.g. std::cout, or a std::ofstream) */
explicit IRPrinter(std::ostream &);
/** emit an expression on the output stream */
void print(const Expr &);
/** Emit an expression on the output stream without enclosing parens */
void print_no_parens(const Expr &);
/** emit a statement on the output stream */
void print(const Stmt &);
/** emit a statement summary on the output stream */
void print_summary(const Stmt &);
/** emit a comma delimited list of exprs, without any leading or
* trailing punctuation. */
void print_list(const std::vector<Expr> &exprs);
static void test();
protected:
Indentation get_indent() const {
return Indentation{indent};
}
/** The stream on which we're outputting */
std::ostream &stream;
/** The current indentation level, useful for pretty-printing
* statements */
int indent = 0;
/** Certain expressions do not need parens around them, e.g. the
* args to a call are already separated by commas and a
* surrounding set of parens. */
bool implicit_parens = false;
/** Print only a summary of a statement, with sub-statements replaced by
* ellipses (...). */
bool is_summary = false;
bool ansi = false;
int paren_depth = 0;
const char *ansi_hl = "";
const char *ansi_dim = "";
const char *ansi_kw = "";
const char *ansi_imm_int = "";
const char *ansi_imm_float = "";
const char *ansi_imm_str = "";
const char *ansi_var = "";
const char *ansi_buf = "";
const char *ansi_fn = "";
const char *ansi_type = "";
const char *ansi_reset_col = "";
const char *ansi_reset = "";
// clang-format off
template<typename T> Ansi<T> hl(const T &t);
template<typename T> Ansi<T> kw(const T &t);
template<typename T> Ansi<T> imm_int(const T &t);
template<typename T> Ansi<T> imm_float(const T &t);
template<typename T> Ansi<T> imm_str(const T &t);
template<typename T> Ansi<T> var(const T &t);
template<typename T> Ansi<T> buf(const T &t);
template<typename T> Ansi<T> fn(const T &t);
template<typename T> Ansi<T> type(const T &t);
template<typename T> Ansi<T> typep(const T &t);
template<typename T> Ansi<T> paren(const T &t, bool bold = true, int d = -1);
// clang-format on
/** Either emits "(" or "", depending on the value of implicit_parens */
void open();
/** Either emits ")" or "", depending on the value of implicit_parens */
void close();
/** Emits "(" always */
void openf();
/** Emits "name(" always */
void openf(const char *name);
/** Emits ")" always */
void closef();
/** The symbols whose types can be inferred from values printed
* already. */
Scope<> known_type;
/** A helper for printing a chain of lets with line breaks */
void print_lets(const Let *let);
/** A helper for printing a braced statement */
void print_braced_stmt(const Stmt &, int extra_indent = 2);
void visit(const IntImm *) override;
void visit(const UIntImm *) override;
void visit(const FloatImm *) override;
void visit(const StringImm *) override;
void visit(const Cast *) override;
void visit(const Reinterpret *) override;
void visit(const Variable *) override;
void visit(const Add *) override;
void visit(const Sub *) override;
void visit(const Mul *) override;
void visit(const Div *) override;
void visit(const Mod *) override;
void visit(const Min *) override;
void visit(const Max *) override;
void visit(const EQ *) override;
void visit(const NE *) override;
void visit(const LT *) override;
void visit(const LE *) override;
void visit(const GT *) override;
void visit(const GE *) override;
void visit(const And *) override;
void visit(const Or *) override;
void visit(const Not *) override;
void visit(const Select *) override;
void visit(const Load *) override;
void visit(const Ramp *) override;
void visit(const Broadcast *) override;
void visit(const Call *) override;
void visit(const Let *) override;
void visit(const LetStmt *) override;
void visit(const AssertStmt *) override;
void visit(const ProducerConsumer *) override;
void visit(const For *) override;
void visit(const Acquire *) override;
void visit(const Store *) override;
void visit(const Provide *) override;
void visit(const Allocate *) override;
void visit(const Free *) override;
void visit(const Realize *) override;
void visit(const Block *) override;
void visit(const Fork *) override;
void visit(const IfThenElse *) override;
void visit(const Evaluate *) override;
void visit(const Shuffle *) override;
void visit(const VectorReduce *) override;
void visit(const Prefetch *) override;
void visit(const Atomic *) override;
void visit(const HoistedStorage *) override;
};
/** Debugging helpers for LLDB */
/// @{
std::string lldb_string(const Expr &);
std::string lldb_string(const Internal::BaseExprNode *);
std::string lldb_string(const Stmt &);
/// @}
} // namespace Internal
} // namespace Halide
#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::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:232
Halide::Internal::IRPrinter::visit
void visit(const GE *) override
Halide::Internal::IRPrinter::ansi_reset_col
const char * ansi_reset_col
Definition IRPrinter.h:198
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:174
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:194
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:195
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:197
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:192
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:199
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:185
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:165
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:189
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:179
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:190
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:191
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:170
Halide::Internal::IRPrinter::ansi_hl
const char * ansi_hl
Definition IRPrinter.h:188
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:183
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:186
Halide::Internal::IRPrinter::visit
void visit(const Mod *) override
Halide::Internal::IRPrinter::ansi_fn
const char * ansi_fn
Definition IRPrinter.h:196
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:193
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::IRVisitor
IRVisitor()=default
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::Internal
Definition AbstractGenerator.h:24
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::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:872
Halide::Internal::Add
The sum of two expressions.
Definition IR.h:56
Halide::Internal::Allocate
Allocate a scratch area called with the given name, type, and size.
Definition IR.h:371
Halide::Internal::And
Logical and - are both expressions true.
Definition IR.h:175
Halide::Internal::Ansi
Definition IRPrinter.h:119
Halide::Internal::Ansi::close
const char * close
Definition IRPrinter.h:121
Halide::Internal::Ansi::cnt
const T & cnt
Definition IRPrinter.h:120
Halide::Internal::Ansi::open
const char * open
Definition IRPrinter.h:121
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:294
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:994
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:442
Halide::Internal::Broadcast
A vector with 'lanes' elements, in which every element is 'value'.
Definition IR.h:259
Halide::Internal::Call
A function call.
Definition IR.h:490
Halide::Internal::Cast
The actual IR nodes begin here.
Definition IR.h:30
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:83
Halide::Internal::EQ
Is the first expression equal to the second.
Definition IR.h:121
Halide::Internal::Evaluate
Evaluate and discard an expression, presumably because it has some side-effect.
Definition IR.h:476
Halide::Internal::FloatImm
Floating point constants.
Definition Expr.h:236
Halide::Internal::For
A for loop.
Definition IR.h:848
Halide::Internal::Fork
A pair of statements executed concurrently.
Definition IR.h:457
Halide::Internal::Free
Free the resources associated with the given buffer.
Definition IR.h:413
Halide::Internal::GE
Is the first expression greater than or equal to the second.
Definition IR.h:166
Halide::Internal::GT
Is the first expression greater than the second.
Definition IR.h:157
Halide::Internal::HoistedStorage
Represents a location where storage will be hoisted to for a Func / Realize node with a given name.
Definition IR.h:978
Halide::Internal::IfThenElse
An if-then-else block.
Definition IR.h:466
Halide::Internal::Indentation
Definition IRPrinter.h:113
Halide::Internal::Indentation::indent
int indent
Definition IRPrinter.h:114
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:148
Halide::Internal::LT
Is the first expression less than the second.
Definition IR.h:139
Halide::Internal::Let
A let expression, like you might find in a functional language.
Definition IR.h:271
Halide::Internal::LetStmt
The statement form of a let node.
Definition IR.h:282
Halide::Internal::Load
Load a value from a named symbol if predicate is true.
Definition IR.h:217
Halide::Internal::LoweredFunc
Definition of a lowered function.
Definition Module.h:101
Halide::Internal::Max
The greater of two values.
Definition IR.h:112
Halide::Internal::Min
The lesser of two values.
Definition IR.h:103
Halide::Internal::Mod
The remainder of a / b.
Definition IR.h:94
Halide::Internal::ModulusRemainder
The result of modulus_remainder analysis.
Definition ModulusRemainder.h:33
Halide::Internal::Mul
The product of two expressions.
Definition IR.h:74
Halide::Internal::NE
Is the first expression not equal to the second.
Definition IR.h:130
Halide::Internal::Not
Logical not - true if the expression false.
Definition IR.h:193
Halide::Internal::Or
Logical or - is at least one of the expression true.
Definition IR.h:184
Halide::Internal::Prefetch
Represent a multi-dimensional region of a Func or an ImageParam that needs to be prefetched.
Definition IR.h:956
Halide::Internal::ProducerConsumer
This node is a helpful annotation to do with permissions.
Definition IR.h:315
Halide::Internal::Provide
This defines the value of a function at a multi-dimensional location.
Definition IR.h:354
Halide::Internal::Ramp
A linear ramp vector node.
Definition IR.h:247
Halide::Internal::Realize
Allocate a multi-dimensional buffer of the given type and size.
Definition IR.h:427
Halide::Internal::Reinterpret
Reinterpret value as another type, without affecting any of the bits (on little-endian systems).
Definition IR.h:47
Halide::Internal::Select
A ternary operator.
Definition IR.h:204
Halide::Internal::Shuffle
Construct a new vector by taking elements from another sequence of vectors.
Definition IR.h:884
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:333
Halide::Internal::StringImm
String constants.
Definition Expr.h:245
Halide::Internal::Sub
The difference of two expressions.
Definition IR.h:65
Halide::Internal::UIntImm
Unsigned integer constants.
Definition Expr.h:227
Halide::Internal::Variable
A named variable.
Definition IR.h:801
Halide::Internal::VectorReduce
Horizontally reduce a vector to a scalar or narrower vector using the given commutative and associati...
Definition IR.h:1012
Halide::Internal::VectorReduce::Operator
Operator
Definition IR.h:1016
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:283