205 const T *
as()
const {
207 return (
const T *)
ptr;
std::vector< Range > Region
A multi-dimensional box.
Expr(float x)
Make an expression representing numeric constants of various types.
RefCount ref_count
These classes are all managed with intrusive reference counting, so we also track a reference count...
Unsigned integer constants.
bool is_unordered_parallel(ForType for_type)
Check if for_type executes for loop iterations in parallel and unordered.
A base class for algorithms that need to recursively walk over the IR.
A fragment of Halide syntax.
Expr(uint64_t x)
Make an expression representing numeric constants of various types.
A reference-counted handle to a statement node.
A single-dimensional span.
IR nodes are split into expressions and statements.
We use the "curiously recurring template pattern" to avoid duplicated code in the IR Nodes...
void accept(IRVisitor *v) const override
We use the visitor pattern to traverse IR nodes throughout the compiler, so we have a virtual accept ...
virtual ~IRNode()=default
Expr(int16_t x)
Make an expression representing numeric constants of various types.
Expr(uint16_t x)
Make an expression representing numeric constants of various types.
static const UIntImm * make(Type t, uint64_t value)
Floating point constants.
virtual Expr mutate_expr(IRMutator *v) const =0
signed __INT8_TYPE__ int8_t
Expr(float16_t x)
Make an expression representing numeric constants of various types.
Allocation is stored in GPU shared memory.
Intrusive shared pointers have a reference count (a RefCount object) stored in the class itself...
BaseExprNode(IRNodeType t)
HALIDE_ALWAYS_INLINE IRHandle()=default
This file defines the class FunctionDAG, which is our representation of a Halide pipeline, and contains methods to using Halide's bounds tools to query properties of it.
HALIDE_ALWAYS_INLINE Expr()=default
Make an undefined expression.
static const IRNodeType _node_type
~ExprNode() override=default
bool is_parallel(ForType for_type)
Returns true if for_type executes for loop iterations in parallel.
unsigned __INT8_TYPE__ uint8_t
Class that provides a type that implements half precision floating point using the bfloat16 format...
IRNodeType
All our IR node types get unique IDs for the purposes of RTTI.
A base class for expression nodes.
IR nodes are passed around opaque handles to them.
Expr(uint32_t x)
Make an expression representing numeric constants of various types.
BaseStmtNode(IRNodeType t)
static const IntImm * make(Type t, int64_t value)
Expr(double x)
Make an expression representing numeric constants of various types.
This lets you use a Stmt as a key in a map of the form map<Stmt, Foo, Stmt::Compare> ...
void destroy< IRNode >(const IRNode *t)
IRNodeType node_type
Each IR node subclass has a unique identifier.
HALIDE_ALWAYS_INLINE Type type() const
Get the type of this expression node.
bool operator()(const Stmt &a, const Stmt &b) const
Class that provides a type that implements half precision floating point (IEEE754 2008 binary16) in s...
static const StringImm * make(const std::string &val)
void accept(IRVisitor *v) const
Dispatch to the correct visitor method for this node.
AMX Tile register for X86.
const T * as() const
Downcast this ir node to its actual type (e.g.
Expr(int64_t x)
Make an expression representing numeric constants of various types.
Type BFloat(int bits, int lanes=1)
Construct a floating-point type in the bfloat format.
This lets you use an Expr as a key in a map of the form map<Expr, Foo, ExprCompare> ...
Let Halide select a storage type automatically.
Allocation is stored in GPU texture memory and accessed through hardware sampler. ...
unsigned __INT32_TYPE__ uint32_t
Not visible externally, similar to 'static' linkage in C.
Support classes for reference-counting via intrusive shared pointers.
signed __INT64_TYPE__ int64_t
Represents a location where storage will be hoisted to for a Func / Realize node with a given name...
Vector Tightly Coupled Memory.
static const IRNodeType _node_type
void accept(IRVisitor *v) const override
We use the visitor pattern to traverse IR nodes throughout the compiler, so we have a virtual accept ...
#define HALIDE_ALWAYS_INLINE
static const IRNodeType _node_type
static const FloatImm * make(Type t, double value)
Stmt mutate_stmt(IRMutator *v) const override
ForType
An enum describing a type of loop traversal.
HALIDE_ALWAYS_INLINE IRHandle(const IRNode *p)
constexpr IRNodeType StrongestExprNodeType
Stmt(const BaseStmtNode *n)
The abstract base classes for a node in the Halide IR.
IRNodeType node_type() const
Type UInt(int bits, int lanes=1)
Constructing an unsigned integer type.
HALIDE_ALWAYS_INLINE Expr(const Internal::BaseExprNode *n)
Make an expression from a concrete expression node pointer (e.g.
bool operator()(const Expr &a, const Expr &b) const
unsigned __INT16_TYPE__ uint16_t
Types in the halide type system.
Expr(uint8_t x)
Make an expression representing numeric constants of various types.
RefCount & ref_count< IRNode >(const IRNode *t) noexcept
Allocate Locked Cache Memory to act as local memory.
Expr(const std::string &s)
Make an expression representing a const string (i.e.
HALIDE_ALWAYS_INLINE const Internal::BaseExprNode * get() const
Override get() to return a BaseExprNode * instead of an IRNode *.
virtual void accept(IRVisitor *v) const =0
We use the visitor pattern to traverse IR nodes throughout the compiler, so we have a virtual accept ...
static const IRNodeType _node_type
A base class for passes over the IR which modify it (e.g.
Expr(int32_t x)
Make an expression representing numeric constants of various types.
unsigned __INT64_TYPE__ uint64_t
~StmtNode() override=default
A class representing a reference count to be used with IntrusivePtr.
signed __INT32_TYPE__ int32_t
Type Int(int bits, int lanes=1)
Constructing a signed integer type.
signed __INT16_TYPE__ int16_t
virtual Stmt mutate_stmt(IRMutator *v) const =0
Expr(bfloat16_t x)
Make an expression representing numeric constants of various types.
Type Float(int bits, int lanes=1)
Construct a floating-point type.
Expr(int8_t x)
Make an expression representing numeric constants of various types.
Expr mutate_expr(IRMutator *v) const override
MemoryType
An enum describing different address spaces to be used with Func::store_in.