Loading...
Searching...
No Matches
Halide::Internal::IRMatcher Namespace Reference

An alternative template-metaprogramming approach to expression matching. More...

## Classes

struct | MatcherState
| To save stack space, the matcher objects are largely stateless and immutable. More...
struct | enable_if_pattern
struct | bindings
struct | SpecificExpr
struct | WildConstInt
struct | WildConstUInt
struct | WildConstFloat
struct | WildConst
struct | Wild
struct | IntLiteral
struct | BinOp
struct | CmpOp
struct | OptionalIntrinType
struct | OptionalIntrinType< Call::saturating_cast >
struct | Intrin
struct | NotOp
struct | SelectOp
struct | BroadcastOp
struct | RampOp
struct | VectorReduceOp
struct | NegateOp
struct | CastOp
struct | WidenOp
struct | SliceOp
struct | Fold
struct | Overflows
struct | Overflow
struct | IsConst
struct | CanProve
struct | IsFloat
struct | IsInt
struct | IsUInt
struct | IsScalar
struct | IsMaxValue
struct | IsMinValue
struct | LanesOf
struct | Rewriter

## Functions

HALIDE_NEVER_INLINE Expr | make_const_special_expr (halide_type_t ty)
HALIDE_ALWAYS_INLINE Expr | make_const_expr (halide_scalar_value_t val, halide_type_t ty)
std::ostream & | operator<< (std::ostream &s, const SpecificExpr &e)
template<int i>
std::ostream & | operator<< (std::ostream &s, const WildConstInt< i > &c)
template<int i>
std::ostream & | operator<< (std::ostream &s, const WildConstUInt< i > &c)
template<int i>
std::ostream & | operator<< (std::ostream &s, const WildConstFloat< i > &c)
template<int i>
std::ostream & | operator<< (std::ostream &s, const WildConst< i > &c)
template<int i>
std::ostream & | operator<< (std::ostream &s, const Wild< i > &op)
HALIDE_ALWAYS_INLINE int64_t | unwrap (IntLiteral t)
template<typename T, typename = typename std::decay<T>::type::pattern_tag>
HALIDE_ALWAYS_INLINE T | pattern_arg (T t)
HALIDE_ALWAYS_INLINE IntLiteral | pattern_arg (int64_t x)
template<typename T>
HALIDE_ALWAYS_INLINE void | assert_is_lvalue_if_expr ()
HALIDE_ALWAYS_INLINE SpecificExpr | pattern_arg (const Expr &e)
template<typename T, typename = typename std::decay<T>::type::pattern_tag, typename = typename std::enable_if<!std::is_same<typename std::decay<T>::type, SpecificExpr>::value>::type>
HALIDE_ALWAYS_INLINE T | unwrap (T t)
HALIDE_ALWAYS_INLINE const BaseExprNode & | unwrap (const SpecificExpr &e)
std::ostream & | operator<< (std::ostream &s, const IntLiteral &op)
template<typename Op>
int64_t | constant_fold_bin_op (halide_type_t &, int64_t, int64_t) noexcept
template<typename Op>
uint64_t | constant_fold_bin_op (halide_type_t &, uint64_t, uint64_t) noexcept
template<typename Op>
double | constant_fold_bin_op (halide_type_t &, double, double) noexcept
constexpr bool | commutative (IRNodeType t)
template<typename Op>
uint64_t | constant_fold_cmp_op (int64_t, int64_t) noexcept
template<typename Op>
uint64_t | constant_fold_cmp_op (uint64_t, uint64_t) noexcept
template<typename Op>
uint64_t | constant_fold_cmp_op (double, double) noexcept
template<typename A, typename B>
std::ostream & | operator<< (std::ostream &s, const BinOp< Add, A, B > &op)
template<typename A, typename B>
std::ostream & | operator<< (std::ostream &s, const BinOp< Sub, A, B > &op)
template<typename A, typename B>
std::ostream & | operator<< (std::ostream &s, const BinOp< Mul, A, B > &op)
template<typename A, typename B>
std::ostream & | operator<< (std::ostream &s, const BinOp< Div, A, B > &op)
template<typename A, typename B>
std::ostream & | operator<< (std::ostream &s, const BinOp< And, A, B > &op)
template<typename A, typename B>
std::ostream & | operator<< (std::ostream &s, const BinOp< Or, A, B > &op)
template<typename A, typename B>
std::ostream & | operator<< (std::ostream &s, const BinOp< Min, A, B > &op)
template<typename A, typename B>
std::ostream & | operator<< (std::ostream &s, const BinOp< Max, A, B > &op)
template<typename A, typename B>
std::ostream & | operator<< (std::ostream &s, const CmpOp< LE, A, B > &op)
template<typename A, typename B>
std::ostream & | operator<< (std::ostream &s, const CmpOp< LT, A, B > &op)
template<typename A, typename B>
std::ostream & | operator<< (std::ostream &s, const CmpOp< GE, A, B > &op)
template<typename A, typename B>
std::ostream & | operator<< (std::ostream &s, const CmpOp< GT, A, B > &op)
template<typename A, typename B>
std::ostream & | operator<< (std::ostream &s, const CmpOp< EQ, A, B > &op)
template<typename A, typename B>
std::ostream & | operator<< (std::ostream &s, const CmpOp< NE, A, B > &op)
template<typename A, typename B>
std::ostream & | operator<< (std::ostream &s, const BinOp< Mod, A, B > &op)
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | operator+ (A &&a, B &&b) noexcept -> BinOp< Add, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | add (A &&a, B &&b) -> decltype(IRMatcher::operator+(a, b))
template<>
HALIDE_ALWAYS_INLINE int64_t | constant_fold_bin_op< Add > (halide_type_t &t, int64_t a, int64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_bin_op< Add > (halide_type_t &t, uint64_t a, uint64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE double | constant_fold_bin_op< Add > (halide_type_t &t, double a, double b) noexcept
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | operator- (A &&a, B &&b) noexcept -> BinOp< Sub, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | sub (A &&a, B &&b) -> decltype(IRMatcher::operator-(a, b))
template<>
HALIDE_ALWAYS_INLINE int64_t | constant_fold_bin_op< Sub > (halide_type_t &t, int64_t a, int64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_bin_op< Sub > (halide_type_t &t, uint64_t a, uint64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE double | constant_fold_bin_op< Sub > (halide_type_t &t, double a, double b) noexcept
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | operator* (A &&a, B &&b) noexcept -> BinOp< Mul, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | mul (A &&a, B &&b) -> decltype(IRMatcher::operator*(a, b))
template<>
HALIDE_ALWAYS_INLINE int64_t | constant_fold_bin_op< Mul > (halide_type_t &t, int64_t a, int64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_bin_op< Mul > (halide_type_t &t, uint64_t a, uint64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE double | constant_fold_bin_op< Mul > (halide_type_t &t, double a, double b) noexcept
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | operator/ (A &&a, B &&b) noexcept -> BinOp< Div, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | div (A &&a, B &&b) -> decltype(IRMatcher::operator/(a, b))
template<>
HALIDE_ALWAYS_INLINE int64_t | constant_fold_bin_op< Div > (halide_type_t &t, int64_t a, int64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_bin_op< Div > (halide_type_t &t, uint64_t a, uint64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE double | constant_fold_bin_op< Div > (halide_type_t &t, double a, double b) noexcept
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | operator% (A &&a, B &&b) noexcept -> BinOp< Mod, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | mod (A &&a, B &&b) -> decltype(IRMatcher::operator%(a, b))
template<>
HALIDE_ALWAYS_INLINE int64_t | constant_fold_bin_op< Mod > (halide_type_t &t, int64_t a, int64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_bin_op< Mod > (halide_type_t &t, uint64_t a, uint64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE double | constant_fold_bin_op< Mod > (halide_type_t &t, double a, double b) noexcept
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | min (A &&a, B &&b) noexcept -> BinOp< Min, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<>
HALIDE_ALWAYS_INLINE int64_t | constant_fold_bin_op< Min > (halide_type_t &t, int64_t a, int64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_bin_op< Min > (halide_type_t &t, uint64_t a, uint64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE double | constant_fold_bin_op< Min > (halide_type_t &t, double a, double b) noexcept
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | max (A &&a, B &&b) noexcept -> BinOp< Max, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<>
HALIDE_ALWAYS_INLINE int64_t | constant_fold_bin_op< Max > (halide_type_t &t, int64_t a, int64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_bin_op< Max > (halide_type_t &t, uint64_t a, uint64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE double | constant_fold_bin_op< Max > (halide_type_t &t, double a, double b) noexcept
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | operator< (A &&a, B &&b) noexcept -> CmpOp< LT, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | lt (A &&a, B &&b) -> decltype(IRMatcher::operator<(a, b))
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_cmp_op< LT > (int64_t a, int64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_cmp_op< LT > (uint64_t a, uint64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_cmp_op< LT > (double a, double b) noexcept
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | operator> (A &&a, B &&b) noexcept -> CmpOp< GT, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | gt (A &&a, B &&b) -> decltype(IRMatcher::operator>(a, b))
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_cmp_op< GT > (int64_t a, int64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_cmp_op< GT > (uint64_t a, uint64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_cmp_op< GT > (double a, double b) noexcept
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | operator<= (A &&a, B &&b) noexcept -> CmpOp< LE, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | le (A &&a, B &&b) -> decltype(IRMatcher::operator<=(a, b))
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_cmp_op< LE > (int64_t a, int64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_cmp_op< LE > (uint64_t a, uint64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_cmp_op< LE > (double a, double b) noexcept
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | operator>= (A &&a, B &&b) noexcept -> CmpOp< GE, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | ge (A &&a, B &&b) -> decltype(IRMatcher::operator>=(a, b))
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_cmp_op< GE > (int64_t a, int64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_cmp_op< GE > (uint64_t a, uint64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_cmp_op< GE > (double a, double b) noexcept
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | operator== (A &&a, B &&b) noexcept -> CmpOp< EQ, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | eq (A &&a, B &&b) -> decltype(IRMatcher::operator==(a, b))
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_cmp_op< EQ > (int64_t a, int64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_cmp_op< EQ > (uint64_t a, uint64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_cmp_op< EQ > (double a, double b) noexcept
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | operator!= (A &&a, B &&b) noexcept -> CmpOp< NE, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | ne (A &&a, B &&b) -> decltype(IRMatcher::operator!=(a, b))
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_cmp_op< NE > (int64_t a, int64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_cmp_op< NE > (uint64_t a, uint64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_cmp_op< NE > (double a, double b) noexcept
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | operator|| (A &&a, B &&b) noexcept -> BinOp< Or, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | or_op (A &&a, B &&b) -> decltype(IRMatcher::operator||(a, b))
template<>
HALIDE_ALWAYS_INLINE int64_t | constant_fold_bin_op< Or > (halide_type_t &t, int64_t a, int64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_bin_op< Or > (halide_type_t &t, uint64_t a, uint64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE double | constant_fold_bin_op< Or > (halide_type_t &t, double a, double b) noexcept
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | operator&& (A &&a, B &&b) noexcept -> BinOp< And, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | and_op (A &&a, B &&b) -> decltype(IRMatcher::operator&&(a, b))
template<>
HALIDE_ALWAYS_INLINE int64_t | constant_fold_bin_op< And > (halide_type_t &t, int64_t a, int64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE uint64_t | constant_fold_bin_op< And > (halide_type_t &t, uint64_t a, uint64_t b) noexcept
template<>
HALIDE_ALWAYS_INLINE double | constant_fold_bin_op< And > (halide_type_t &t, double a, double b) noexcept
constexpr uint32_t | bitwise_or_reduce ()
template<typename... Args>
constexpr uint32_t | bitwise_or_reduce (uint32_t first, Args... rest)
constexpr bool | and_reduce ()
template<typename... Args>
constexpr bool | and_reduce (bool first, Args... rest)
template<Call::IntrinsicOp intrin, typename... Args>
std::ostream & | operator<< (std::ostream &s, const Intrin< intrin, Args... > &op)
template<typename A, typename B>
auto | widen_right_add (A &&a, B &&b) noexcept -> Intrin< Call::widen_right_add, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
auto | widen_right_mul (A &&a, B &&b) noexcept -> Intrin< Call::widen_right_mul, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
auto | widen_right_sub (A &&a, B &&b) noexcept -> Intrin< Call::widen_right_sub, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
auto | widening_add (A &&a, B &&b) noexcept -> Intrin< Call::widening_add, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
auto | widening_sub (A &&a, B &&b) noexcept -> Intrin< Call::widening_sub, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
auto | widening_mul (A &&a, B &&b) noexcept -> Intrin< Call::widening_mul, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
auto | saturating_add (A &&a, B &&b) noexcept -> Intrin< Call::saturating_add, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
auto | saturating_sub (A &&a, B &&b) noexcept -> Intrin< Call::saturating_sub, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A>
auto | saturating_cast (const Type &t, A &&a) noexcept -> Intrin< Call::saturating_cast, decltype(pattern_arg(a))>
template<typename A, typename B>
auto | halving_add (A &&a, B &&b) noexcept -> Intrin< Call::halving_add, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
auto | halving_sub (A &&a, B &&b) noexcept -> Intrin< Call::halving_sub, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
auto | rounding_halving_add (A &&a, B &&b) noexcept -> Intrin< Call::rounding_halving_add, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
auto | shift_left (A &&a, B &&b) noexcept -> Intrin< Call::shift_left, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
auto | shift_right (A &&a, B &&b) noexcept -> Intrin< Call::shift_right, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
auto | rounding_shift_left (A &&a, B &&b) noexcept -> Intrin< Call::rounding_shift_left, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B>
auto | rounding_shift_right (A &&a, B &&b) noexcept -> Intrin< Call::rounding_shift_right, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A, typename B, typename C>
auto | mul_shift_right (A &&a, B &&b, C &&c) noexcept -> Intrin< Call::mul_shift_right, decltype(pattern_arg(a)), decltype(pattern_arg(b)), decltype(pattern_arg(c))>
template<typename A, typename B, typename C>
auto | rounding_mul_shift_right (A &&a, B &&b, C &&c) noexcept -> Intrin< Call::rounding_mul_shift_right, decltype(pattern_arg(a)), decltype(pattern_arg(b)), decltype(pattern_arg(c))>
template<typename A>
auto | abs (A &&a) noexcept -> Intrin< Call::abs, decltype(pattern_arg(a))>
template<typename A, typename B>
auto | absd (A &&a, B &&b) noexcept -> Intrin< Call::absd, decltype(pattern_arg(a)), decltype(pattern_arg(b))>
template<typename A>
auto | likely (A &&a) noexcept -> Intrin< Call::likely, decltype(pattern_arg(a))>
template<typename A>
auto | likely_if_innermost (A &&a) noexcept -> Intrin< Call::likely_if_innermost, decltype(pattern_arg(a))>
template<typename A>
HALIDE_ALWAYS_INLINE auto | operator! (A &&a) noexcept -> NotOp< decltype(pattern_arg(a))>
template<typename A>
HALIDE_ALWAYS_INLINE auto | not_op (A &&a) -> decltype(IRMatcher::operator!(a))
template<typename A>
std::ostream & | operator<< (std::ostream &s, const NotOp< A > &op)
template<typename C, typename T, typename F>
std::ostream & | operator<< (std::ostream &s, const SelectOp< C, T, F > &op)
template<typename C, typename T, typename F>
HALIDE_ALWAYS_INLINE auto | select (C &&c, T &&t, F &&f) noexcept -> SelectOp< decltype(pattern_arg(c)), decltype(pattern_arg(t)), decltype(pattern_arg(f))>
template<typename A, typename B>
std::ostream & | operator<< (std::ostream &s, const BroadcastOp< A, B > &op)
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | broadcast (A &&a, B lanes) noexcept -> BroadcastOp< decltype(pattern_arg(a)), decltype(pattern_arg(lanes))>
template<typename A, typename B, typename C>
std::ostream & | operator<< (std::ostream &s, const RampOp< A, B, C > &op)
template<typename A, typename B, typename C>
HALIDE_ALWAYS_INLINE auto | ramp (A &&a, B &&b, C &&c) noexcept -> RampOp< decltype(pattern_arg(a)), decltype(pattern_arg(b)), decltype(pattern_arg(c))>
template<typename A, typename B, VectorReduce::Operator reduce_op>
std::ostream & | operator<< (std::ostream &s, const VectorReduceOp< A, B, reduce_op > &op)
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | h_add (A &&a, B lanes) noexcept -> VectorReduceOp< decltype(pattern_arg(a)), decltype(pattern_arg(lanes)), VectorReduce::Add >
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | h_min (A &&a, B lanes) noexcept -> VectorReduceOp< decltype(pattern_arg(a)), decltype(pattern_arg(lanes)), VectorReduce::Min >
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | h_max (A &&a, B lanes) noexcept -> VectorReduceOp< decltype(pattern_arg(a)), decltype(pattern_arg(lanes)), VectorReduce::Max >
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | h_and (A &&a, B lanes) noexcept -> VectorReduceOp< decltype(pattern_arg(a)), decltype(pattern_arg(lanes)), VectorReduce::And >
template<typename A, typename B>
HALIDE_ALWAYS_INLINE auto | h_or (A &&a, B lanes) noexcept -> VectorReduceOp< decltype(pattern_arg(a)), decltype(pattern_arg(lanes)), VectorReduce::Or >
template<typename A>
std::ostream & | operator<< (std::ostream &s, const NegateOp< A > &op)
template<typename A>
HALIDE_ALWAYS_INLINE auto | operator- (A &&a) noexcept -> NegateOp< decltype(pattern_arg(a))>
template<typename A>
HALIDE_ALWAYS_INLINE auto | negate (A &&a) -> decltype(IRMatcher::operator-(a))
template<typename A>
std::ostream & | operator<< (std::ostream &s, const CastOp< A > &op)
template<typename A>
HALIDE_ALWAYS_INLINE auto | cast (halide_type_t t, A &&a) noexcept -> CastOp< decltype(pattern_arg(a))>
template<typename A>
std::ostream & | operator<< (std::ostream &s, const WidenOp< A > &op)
template<typename A>
HALIDE_ALWAYS_INLINE auto | widen (A &&a) noexcept -> WidenOp< decltype(pattern_arg(a))>
template<typename Vec, typename Base, typename Stride, typename Lanes>
std::ostream & | operator<< (std::ostream &s, const SliceOp< Vec, Base, Stride, Lanes > &op)
template<typename Vec, typename Base, typename Stride, typename Lanes>
HALIDE_ALWAYS_INLINE auto | slice (Vec vec, Base base, Stride stride, Lanes lanes) noexcept -> SliceOp< decltype(pattern_arg(vec)), decltype(pattern_arg(base)), decltype(pattern_arg(stride)), decltype(pattern_arg(lanes))>
template<typename A>
HALIDE_ALWAYS_INLINE auto | fold (A &&a) noexcept -> Fold< decltype(pattern_arg(a))>
template<typename A>
std::ostream & | operator<< (std::ostream &s, const Fold< A > &op)
template<typename A>
HALIDE_ALWAYS_INLINE auto | overflows (A &&a) noexcept -> Overflows< decltype(pattern_arg(a))>
template<typename A>
std::ostream & | operator<< (std::ostream &s, const Overflows< A > &op)
std::ostream & | operator<< (std::ostream &s, const Overflow &op)
template<typename A>
HALIDE_ALWAYS_INLINE auto | is_const (A &&a) noexcept -> IsConst< decltype(pattern_arg(a))>
template<typename A>
HALIDE_ALWAYS_INLINE auto | is_const (A &&a, int64_t value) noexcept -> IsConst< decltype(pattern_arg(a))>
template<typename A>
std::ostream & | operator<< (std::ostream &s, const IsConst< A > &op)
template<typename A, typename Prover>
HALIDE_ALWAYS_INLINE auto | can_prove (A &&a, Prover *p) noexcept -> CanProve< decltype(pattern_arg(a)), Prover >
template<typename A, typename Prover>
std::ostream & | operator<< (std::ostream &s, const CanProve< A, Prover > &op)
template<typename A>
HALIDE_ALWAYS_INLINE auto | is_float (A &&a) noexcept -> IsFloat< decltype(pattern_arg(a))>
template<typename A>
std::ostream & | operator<< (std::ostream &s, const IsFloat< A > &op)
template<typename A>
HALIDE_ALWAYS_INLINE auto | is_int (A &&a, uint8_t bits=0, uint16_t lanes=0) noexcept -> IsInt< decltype(pattern_arg(a))>
template<typename A>
std::ostream & | operator<< (std::ostream &s, const IsInt< A > &op)
template<typename A>
HALIDE_ALWAYS_INLINE auto | is_uint (A &&a, uint8_t bits=0, uint16_t lanes=0) noexcept -> IsUInt< decltype(pattern_arg(a))>
template<typename A>
std::ostream & | operator<< (std::ostream &s, const IsUInt< A > &op)
template<typename A>
HALIDE_ALWAYS_INLINE auto | is_scalar (A &&a) noexcept -> IsScalar< decltype(pattern_arg(a))>
template<typename A>
std::ostream & | operator<< (std::ostream &s, const IsScalar< A > &op)
template<typename A>
HALIDE_ALWAYS_INLINE auto | is_max_value (A &&a) noexcept -> IsMaxValue< decltype(pattern_arg(a))>
template<typename A>
std::ostream & | operator<< (std::ostream &s, const IsMaxValue< A > &op)
template<typename A>
HALIDE_ALWAYS_INLINE auto | is_min_value (A &&a) noexcept -> IsMinValue< decltype(pattern_arg(a))>
template<typename A>
std::ostream & | operator<< (std::ostream &s, const IsMinValue< A > &op)
template<typename A>
HALIDE_ALWAYS_INLINE auto | lanes_of (A &&a) noexcept -> LanesOf< decltype(pattern_arg(a))>
template<typename A>
std::ostream & | operator<< (std::ostream &s, const LanesOf< A > &op)
template<typename Before, typename After, typename Predicate, typename = typename std::enable_if<std::decay<Before>::type::foldable && std::decay<After>::type::foldable>::type>
HALIDE_NEVER_INLINE void | fuzz_test_rule (Before &&before, After &&after, Predicate &&pred, halide_type_t wildcard_type, halide_type_t output_type) noexcept
template<typename Before, typename After, typename Predicate, typename = typename std::enable_if<!(std::decay<Before>::type::foldable && std::decay<After>::type::foldable)>::type>
HALIDE_ALWAYS_INLINE void | fuzz_test_rule (Before &&before, After &&after, Predicate &&pred, halide_type_t, halide_type_t, int dummy=0) noexcept
HALIDE_ALWAYS_INLINE bool | evaluate_predicate (bool x, MatcherState &) noexcept
template<typename Pattern, typename = typename enable_if_pattern<Pattern>::type>
HALIDE_ALWAYS_INLINE bool | evaluate_predicate (Pattern p, MatcherState &state)
template<typename Instance, typename = typename enable_if_pattern<Instance>::type>
HALIDE_ALWAYS_INLINE auto | rewriter (Instance instance, halide_type_t output_type, halide_type_t wildcard_type) noexcept -> Rewriter< decltype(pattern_arg(instance))>
| Construct a rewriter for the given instance, which may be a pattern with concrete expressions as leaves, or just an expression.
template<typename Instance, typename = typename enable_if_pattern<Instance>::type>
HALIDE_ALWAYS_INLINE auto | rewriter (Instance instance, halide_type_t output_type) noexcept -> Rewriter< decltype(pattern_arg(instance))>
HALIDE_ALWAYS_INLINE auto | rewriter (const Expr &e, halide_type_t wildcard_type) noexcept -> Rewriter< decltype(pattern_arg(e))>
HALIDE_ALWAYS_INLINE auto | rewriter (const Expr &e) noexcept -> Rewriter< decltype(pattern_arg(e))>

## Variables

constexpr int | max_wild = 6

## Detailed Description

An alternative template-metaprogramming approach to expression matching.

Potentially more efficient. We lift the expression pattern into a type, and then use force-inlined functions to generate efficient matching and reconstruction code for any pattern. Pattern elements are either one of the classes in the namespace IRMatcher, or are non-null Exprs (represented as BaseExprNode &).

Pattern elements that are fully specified by their pattern can be built into an expression using the make method. Some patterns, such as a broadcast that matches any number of lanes, don't have enough information to recreate an Expr.

## Function Documentation

## make_const_special_expr()

HALIDE_NEVER_INLINE Expr Halide::Internal::IRMatcher::make_const_special_expr | ( | halide_type_t | ty | ) |

inline

Definition at line 149 of file IRMatch.h.

References HALIDE_NEVER_INLINE, halide_type_t::lanes, Halide::Internal::make_signed_integer_overflow(), Halide::Internal::IRMatcher::MatcherState::signed_integer_overflow, and Halide::Internal::IRMatcher::MatcherState::special_values_mask.

Referenced by Halide::Internal::IRMatcher::Overflow::make(), and make_const_expr().

## make_const_expr()

HALIDE_ALWAYS_INLINE Expr Halide::Internal::IRMatcher::make_const_expr | ( | halide_scalar_value_t | val,
|  | halide_type_t | ty )

Definition at line 160 of file IRMatch.h.

References halide_type_t::code, halide_scalar_value_t::f64, halide_type_bfloat, halide_type_float, halide_type_int, halide_type_uint, halide_scalar_value_t::i64, halide_type_t::lanes, Halide::Internal::Broadcast::make(), Halide::Internal::FloatImm::make(), Halide::Internal::IntImm::make(), Halide::Internal::UIntImm::make(), make_const_special_expr(), Halide::Internal::IRMatcher::MatcherState::special_values_mask, halide_scalar_value_t::u, and halide_scalar_value_t::u64.

Referenced by fuzz_test_rule(), Halide::Internal::IRMatcher::Fold< A >::make(), Halide::Internal::IRMatcher::WildConst< i >::make(), Halide::Internal::IRMatcher::WildConstFloat< i >::make(), Halide::Internal::IRMatcher::WildConstInt< i >::make(), and Halide::Internal::IRMatcher::WildConstUInt< i >::make().

## operator<<() [1/44]

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const SpecificExpr & | e )

inline

Definition at line 217 of file IRMatch.h.

References Halide::Internal::IRMatcher::SpecificExpr::expr.

## operator<<() [2/44]

template<int i>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const WildConstInt< i > & | c )

Definition at line 283 of file IRMatch.h.

## operator<<() [3/44]

template<int i>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const WildConstUInt< i > & | c )

Definition at line 336 of file IRMatch.h.

## operator<<() [4/44]

template<int i>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const WildConstFloat< i > & | c )

Definition at line 389 of file IRMatch.h.

## operator<<() [5/44]

template<int i>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const WildConst< i > & | c )

Definition at line 447 of file IRMatch.h.

## operator<<() [6/44]

template<int i>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const Wild< i > & | op )

Definition at line 481 of file IRMatch.h.

## unwrap() [1/3]

HALIDE_ALWAYS_INLINE int64_t Halide::Internal::IRMatcher::unwrap | ( | IntLiteral | t | ) |

Definition at line 559 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and Halide::Internal::IRMatcher::IntLiteral::v.

Referenced by Halide::Internal::IRMatcher::BinOp< Op, A, B >::match(), Halide::Internal::IRMatcher::BroadcastOp< A, B >::match(), Halide::Internal::IRMatcher::CastOp< A >::match(), Halide::Internal::IRMatcher::CmpOp< Op, A, B >::match(), Halide::Internal::IRMatcher::NegateOp< A >::match(), Halide::Internal::IRMatcher::NotOp< A >::match(), Halide::Internal::IRMatcher::RampOp< A, B, C >::match(), Halide::Internal::IRMatcher::SelectOp< C, T, F >::match(), Halide::Internal::IRMatcher::VectorReduceOp< A, B, reduce_op >::match(), Halide::Internal::IRMatcher::WidenOp< A >::match(), Halide::Internal::IRMatcher::Rewriter< Instance >::operator()(), Halide::Internal::IRMatcher::Rewriter< Instance >::operator()(), Halide::Internal::IRMatcher::Rewriter< Instance >::operator()(), Halide::Internal::IRMatcher::Rewriter< Instance >::operator()(), Halide::Internal::IRMatcher::Rewriter< Instance >::operator()(), and Halide::Internal::IRMatcher::Rewriter< Instance >::operator()().

## pattern_arg() [1/3]

template<typename T, typename = typename std::decay<T>::type::pattern_tag>

HALIDE_ALWAYS_INLINE T Halide::Internal::IRMatcher::pattern_arg | ( | T | t | ) |

Definition at line 567 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

Referenced by abs(), absd(), broadcast(), can_prove(), cast(), fold(), h_add(), h_and(), h_max(), h_min(), h_or(), halving_add(), halving_sub(), is_const(), is_const(), is_float(), is_int(), is_max_value(), is_min_value(), is_scalar(), is_uint(), lanes_of(), likely(), likely_if_innermost(), max(), min(), mul_shift_right(), operator!(), operator!=(), operator%(), operator&&(), operator*(), operator+(), operator-(), operator-(), operator/(), operator<(), operator<=(), operator==(), operator>(), operator>=(), operator||(), overflows(), ramp(), rewriter(), rewriter(), rewriter(), rewriter(), rounding_halving_add(), rounding_mul_shift_right(), rounding_shift_left(), rounding_shift_right(), saturating_add(), saturating_cast(), saturating_sub(), select(), shift_left(), shift_right(), slice(), widen(), widen_right_add(), widen_right_mul(), widen_right_sub(), widening_add(), widening_mul(), and widening_sub().

## pattern_arg() [2/3]

HALIDE_ALWAYS_INLINE IntLiteral Halide::Internal::IRMatcher::pattern_arg | ( | int64_t | x | ) |

Definition at line 571 of file IRMatch.h.

## assert_is_lvalue_if_expr()

template<typename T>

HALIDE_ALWAYS_INLINE void Halide::Internal::IRMatcher::assert_is_lvalue_if_expr | ( |  | ) |

Definition at line 576 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

Referenced by add(), broadcast(), can_prove(), cast(), fold(), h_add(), h_and(), h_max(), h_min(), h_or(), is_const(), is_const(), is_float(), is_int(), is_max_value(), is_min_value(), is_scalar(), is_uint(), lanes_of(), max(), min(), mod(), mul(), negate(), not_op(), operator!(), operator%(), operator*(), operator+(), operator-(), operator-(), operator/(), overflows(), ramp(), select(), sub(), and widen().

## pattern_arg() [3/3]

HALIDE_ALWAYS_INLINE SpecificExpr Halide::Internal::IRMatcher::pattern_arg | ( | const Expr & | e | ) |

Definition at line 581 of file IRMatch.h.

References Halide::Expr::get(), and HALIDE_ALWAYS_INLINE.

## unwrap() [2/3]

template<typename T, typename = typename std::decay<T>::type::pattern_tag, typename = typename std::enable_if<!std::is_same<typename std::decay<T>::type, SpecificExpr>::value>::type>

HALIDE_ALWAYS_INLINE T Halide::Internal::IRMatcher::unwrap | ( | T | t | ) |

Definition at line 592 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## unwrap() [3/3]

HALIDE_ALWAYS_INLINE const BaseExprNode & Halide::Internal::IRMatcher::unwrap | ( | const SpecificExpr & | e | ) |

Definition at line 597 of file IRMatch.h.

References Halide::Internal::IRMatcher::SpecificExpr::expr.

## operator<<() [7/44]

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const IntLiteral & | op )

inline

Definition at line 601 of file IRMatch.h.

References Halide::Internal::IRMatcher::IntLiteral::v.

## constant_fold_bin_op() [1/3]

template<typename Op>

int64_t Halide::Internal::IRMatcher::constant_fold_bin_op | ( | halide_type_t & | ,
|  | int64_t | ,
|  | int64_t | )

noexcept

Referenced by Halide::Internal::IRMatcher::BinOp< Op, A, B >::make_folded_const().

## constant_fold_bin_op() [2/3]

template<typename Op>

uint64_t Halide::Internal::IRMatcher::constant_fold_bin_op | ( | halide_type_t & | ,
|  | uint64_t | ,
|  | uint64_t | )

noexcept

## constant_fold_bin_op() [3/3]

template<typename Op>

double Halide::Internal::IRMatcher::constant_fold_bin_op | ( | halide_type_t & | ,
|  | double | ,
|  | double | )

noexcept

## commutative()

bool Halide::Internal::IRMatcher::commutative | ( | IRNodeType | t | ) |

constexpr

Definition at line 615 of file IRMatch.h.

References Halide::Internal::Add, Halide::Internal::And, Halide::Internal::EQ, Halide::Internal::Max, Halide::Internal::Min, Halide::Internal::Mul, Halide::Internal::NE, and Halide::Internal::Or.

## constant_fold_cmp_op() [1/3]

template<typename Op>

uint64_t Halide::Internal::IRMatcher::constant_fold_cmp_op | ( | int64_t | ,
|  | int64_t | )

noexcept

Referenced by Halide::Internal::IRMatcher::CmpOp< Op, A, B >::make_folded_const().

## constant_fold_cmp_op() [2/3]

template<typename Op>

uint64_t Halide::Internal::IRMatcher::constant_fold_cmp_op | ( | uint64_t | ,
|  | uint64_t | )

noexcept

## constant_fold_cmp_op() [3/3]

template<typename Op>

uint64_t Halide::Internal::IRMatcher::constant_fold_cmp_op | ( | double | ,
|  | double | )

noexcept

## operator<<() [8/44]

template<typename A, typename B>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const BinOp< Add, A, B > & | op )

Definition at line 815 of file IRMatch.h.

References Halide::Internal::IRMatcher::BinOp< Op, A, B >::a, and Halide::Internal::IRMatcher::BinOp< Op, A, B >::b.

## operator<<() [9/44]

template<typename A, typename B>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const BinOp< Sub, A, B > & | op )

Definition at line 821 of file IRMatch.h.

References Halide::Internal::IRMatcher::BinOp< Op, A, B >::a, and Halide::Internal::IRMatcher::BinOp< Op, A, B >::b.

## operator<<() [10/44]

template<typename A, typename B>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const BinOp< Mul, A, B > & | op )

Definition at line 827 of file IRMatch.h.

References Halide::Internal::IRMatcher::BinOp< Op, A, B >::a, and Halide::Internal::IRMatcher::BinOp< Op, A, B >::b.

## operator<<() [11/44]

template<typename A, typename B>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const BinOp< Div, A, B > & | op )

Definition at line 833 of file IRMatch.h.

References Halide::Internal::IRMatcher::BinOp< Op, A, B >::a, and Halide::Internal::IRMatcher::BinOp< Op, A, B >::b.

## operator<<() [12/44]

template<typename A, typename B>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const BinOp< And, A, B > & | op )

Definition at line 839 of file IRMatch.h.

References Halide::Internal::IRMatcher::BinOp< Op, A, B >::a, and Halide::Internal::IRMatcher::BinOp< Op, A, B >::b.

## operator<<() [13/44]

template<typename A, typename B>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const BinOp< Or, A, B > & | op )

Definition at line 845 of file IRMatch.h.

References Halide::Internal::IRMatcher::BinOp< Op, A, B >::a, and Halide::Internal::IRMatcher::BinOp< Op, A, B >::b.

## operator<<() [14/44]

template<typename A, typename B>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const BinOp< Min, A, B > & | op )

Definition at line 851 of file IRMatch.h.

References Halide::Internal::IRMatcher::BinOp< Op, A, B >::a, and Halide::Internal::IRMatcher::BinOp< Op, A, B >::b.

## operator<<() [15/44]

template<typename A, typename B>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const BinOp< Max, A, B > & | op )

Definition at line 857 of file IRMatch.h.

References Halide::Internal::IRMatcher::BinOp< Op, A, B >::a, and Halide::Internal::IRMatcher::BinOp< Op, A, B >::b.

## operator<<() [16/44]

template<typename A, typename B>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const CmpOp< LE, A, B > & | op )

Definition at line 863 of file IRMatch.h.

References Halide::Internal::IRMatcher::CmpOp< Op, A, B >::a, and Halide::Internal::IRMatcher::CmpOp< Op, A, B >::b.

## operator<<() [17/44]

template<typename A, typename B>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const CmpOp< LT, A, B > & | op )

Definition at line 869 of file IRMatch.h.

References Halide::Internal::IRMatcher::CmpOp< Op, A, B >::a, and Halide::Internal::IRMatcher::CmpOp< Op, A, B >::b.

## operator<<() [18/44]

template<typename A, typename B>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const CmpOp< GE, A, B > & | op )

Definition at line 875 of file IRMatch.h.

References Halide::Internal::IRMatcher::CmpOp< Op, A, B >::a, and Halide::Internal::IRMatcher::CmpOp< Op, A, B >::b.

## operator<<() [19/44]

template<typename A, typename B>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const CmpOp< GT, A, B > & | op )

Definition at line 881 of file IRMatch.h.

References Halide::Internal::IRMatcher::CmpOp< Op, A, B >::a, and Halide::Internal::IRMatcher::CmpOp< Op, A, B >::b.

## operator<<() [20/44]

template<typename A, typename B>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const CmpOp< EQ, A, B > & | op )

Definition at line 887 of file IRMatch.h.

References Halide::Internal::IRMatcher::CmpOp< Op, A, B >::a, and Halide::Internal::IRMatcher::CmpOp< Op, A, B >::b.

## operator<<() [21/44]

template<typename A, typename B>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const CmpOp< NE, A, B > & | op )

Definition at line 893 of file IRMatch.h.

References Halide::Internal::IRMatcher::CmpOp< Op, A, B >::a, and Halide::Internal::IRMatcher::CmpOp< Op, A, B >::b.

## operator<<() [22/44]

template<typename A, typename B>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const BinOp< Mod, A, B > & | op )

Definition at line 899 of file IRMatch.h.

References Halide::Internal::IRMatcher::BinOp< Op, A, B >::a, and Halide::Internal::IRMatcher::BinOp< Op, A, B >::b.

## operator+()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::operator+ | ( | A && | a,
|  | B && | b )->BinOp< Add, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 905 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

Referenced by add().

## add()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::add | ( | A && | a,
|  | B && | b )->decltype(IRMatcher::operator+(a, b))

Definition at line 912 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and operator+().

## constant_fold_bin_op< Add >() [1/3]

template<>

HALIDE_ALWAYS_INLINE int64_t Halide::Internal::IRMatcher::constant_fold_bin_op< Add > | ( | halide_type_t & | t,
|  | int64_t | a,
|  | int64_t | b )

noexcept

Definition at line 919 of file IRMatch.h.

References Halide::Internal::add_would_overflow(), HALIDE_ALWAYS_INLINE, and Halide::Internal::IRMatcher::MatcherState::signed_integer_overflow.

Referenced by fuzz_test_rule().

## constant_fold_bin_op< Add >() [2/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_bin_op< Add > | ( | halide_type_t & | t,
|  | uint64_t | a,
|  | uint64_t | b )

noexcept

Definition at line 927 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## constant_fold_bin_op< Add >() [3/3]

template<>

HALIDE_ALWAYS_INLINE double Halide::Internal::IRMatcher::constant_fold_bin_op< Add > | ( | halide_type_t & | t,
|  | double | a,
|  | double | b )

noexcept

Definition at line 933 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## operator-() [1/2]

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::operator- | ( | A && | a,
|  | B && | b )->BinOp< Sub, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 938 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

Referenced by negate(), and sub().

## sub()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::sub | ( | A && | a,
|  | B && | b )->decltype(IRMatcher::operator-(a, b))

Definition at line 945 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and operator-().

## constant_fold_bin_op< Sub >() [1/3]

template<>

HALIDE_ALWAYS_INLINE int64_t Halide::Internal::IRMatcher::constant_fold_bin_op< Sub > | ( | halide_type_t & | t,
|  | int64_t | a,
|  | int64_t | b )

noexcept

Definition at line 952 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, Halide::Internal::IRMatcher::MatcherState::signed_integer_overflow, and Halide::Internal::sub_would_overflow().

## constant_fold_bin_op< Sub >() [2/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_bin_op< Sub > | ( | halide_type_t & | t,
|  | uint64_t | a,
|  | uint64_t | b )

noexcept

Definition at line 960 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## constant_fold_bin_op< Sub >() [3/3]

template<>

HALIDE_ALWAYS_INLINE double Halide::Internal::IRMatcher::constant_fold_bin_op< Sub > | ( | halide_type_t & | t,
|  | double | a,
|  | double | b )

noexcept

Definition at line 966 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## operator*()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::operator* | ( | A && | a,
|  | B && | b )->BinOp< Mul, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 971 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

Referenced by mul().

## mul()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::mul | ( | A && | a,
|  | B && | b )->decltype(IRMatcher::operator*(a, b))

Definition at line 978 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and operator*().

## constant_fold_bin_op< Mul >() [1/3]

template<>

HALIDE_ALWAYS_INLINE int64_t Halide::Internal::IRMatcher::constant_fold_bin_op< Mul > | ( | halide_type_t & | t,
|  | int64_t | a,
|  | int64_t | b )

noexcept

Definition at line 985 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, Halide::Internal::mul_would_overflow(), and Halide::Internal::IRMatcher::MatcherState::signed_integer_overflow.

## constant_fold_bin_op< Mul >() [2/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_bin_op< Mul > | ( | halide_type_t & | t,
|  | uint64_t | a,
|  | uint64_t | b )

noexcept

Definition at line 993 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## constant_fold_bin_op< Mul >() [3/3]

template<>

HALIDE_ALWAYS_INLINE double Halide::Internal::IRMatcher::constant_fold_bin_op< Mul > | ( | halide_type_t & | t,
|  | double | a,
|  | double | b )

noexcept

Definition at line 999 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## operator/()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::operator/ | ( | A && | a,
|  | B && | b )->BinOp< Div, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1004 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

Referenced by div().

## div()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::div | ( | A && | a,
|  | B && | b )->decltype(IRMatcher::operator/(a, b))

Definition at line 1011 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and operator/().

## constant_fold_bin_op< Div >() [1/3]

template<>

HALIDE_ALWAYS_INLINE int64_t Halide::Internal::IRMatcher::constant_fold_bin_op< Div > | ( | halide_type_t & | t,
|  | int64_t | a,
|  | int64_t | b )

noexcept

Definition at line 1016 of file IRMatch.h.

References Halide::Internal::div_imp(), and HALIDE_ALWAYS_INLINE.

## constant_fold_bin_op< Div >() [2/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_bin_op< Div > | ( | halide_type_t & | t,
|  | uint64_t | a,
|  | uint64_t | b )

noexcept

Definition at line 1021 of file IRMatch.h.

References Halide::Internal::div_imp(), and HALIDE_ALWAYS_INLINE.

## constant_fold_bin_op< Div >() [3/3]

template<>

HALIDE_ALWAYS_INLINE double Halide::Internal::IRMatcher::constant_fold_bin_op< Div > | ( | halide_type_t & | t,
|  | double | a,
|  | double | b )

noexcept

Definition at line 1026 of file IRMatch.h.

References Halide::Internal::div_imp(), and HALIDE_ALWAYS_INLINE.

## operator%()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::operator% | ( | A && | a,
|  | B && | b )->BinOp< Mod, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1031 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

Referenced by mod().

## mod()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::mod | ( | A && | a,
|  | B && | b )->decltype(IRMatcher::operator%(a, b))

Definition at line 1038 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and operator%().

## constant_fold_bin_op< Mod >() [1/3]

template<>

HALIDE_ALWAYS_INLINE int64_t Halide::Internal::IRMatcher::constant_fold_bin_op< Mod > | ( | halide_type_t & | t,
|  | int64_t | a,
|  | int64_t | b )

noexcept

Definition at line 1045 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and Halide::Internal::mod_imp().

## constant_fold_bin_op< Mod >() [2/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_bin_op< Mod > | ( | halide_type_t & | t,
|  | uint64_t | a,
|  | uint64_t | b )

noexcept

Definition at line 1050 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and Halide::Internal::mod_imp().

## constant_fold_bin_op< Mod >() [3/3]

template<>

HALIDE_ALWAYS_INLINE double Halide::Internal::IRMatcher::constant_fold_bin_op< Mod > | ( | halide_type_t & | t,
|  | double | a,
|  | double | b )

noexcept

Definition at line 1055 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and Halide::Internal::mod_imp().

## min()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::min | ( | A && | a,
|  | B && | b )->BinOp< Min, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1060 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

## constant_fold_bin_op< Min >() [1/3]

template<>

HALIDE_ALWAYS_INLINE int64_t Halide::Internal::IRMatcher::constant_fold_bin_op< Min > | ( | halide_type_t & | t,
|  | int64_t | a,
|  | int64_t | b )

noexcept

Definition at line 1067 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## constant_fold_bin_op< Min >() [2/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_bin_op< Min > | ( | halide_type_t & | t,
|  | uint64_t | a,
|  | uint64_t | b )

noexcept

Definition at line 1072 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## constant_fold_bin_op< Min >() [3/3]

template<>

HALIDE_ALWAYS_INLINE double Halide::Internal::IRMatcher::constant_fold_bin_op< Min > | ( | halide_type_t & | t,
|  | double | a,
|  | double | b )

noexcept

Definition at line 1077 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## max()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::max | ( | A && | a,
|  | B && | b )->BinOp< Max, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1082 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

## constant_fold_bin_op< Max >() [1/3]

template<>

HALIDE_ALWAYS_INLINE int64_t Halide::Internal::IRMatcher::constant_fold_bin_op< Max > | ( | halide_type_t & | t,
|  | int64_t | a,
|  | int64_t | b )

noexcept

Definition at line 1089 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## constant_fold_bin_op< Max >() [2/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_bin_op< Max > | ( | halide_type_t & | t,
|  | uint64_t | a,
|  | uint64_t | b )

noexcept

Definition at line 1094 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## constant_fold_bin_op< Max >() [3/3]

template<>

HALIDE_ALWAYS_INLINE double Halide::Internal::IRMatcher::constant_fold_bin_op< Max > | ( | halide_type_t & | t,
|  | double | a,
|  | double | b )

noexcept

Definition at line 1099 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## operator<()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::operator< | ( | A && | a,
|  | B && | b )->CmpOp< LT, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1104 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and pattern_arg().

Referenced by lt().

## lt()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::lt | ( | A && | a,
|  | B && | b )->decltype(IRMatcher::operator<(a, b))

Definition at line 1109 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and operator<().

## constant_fold_cmp_op< LT >() [1/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_cmp_op< LT > | ( | int64_t | a,
|  | int64_t | b )

noexcept

Definition at line 1114 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## constant_fold_cmp_op< LT >() [2/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_cmp_op< LT > | ( | uint64_t | a,
|  | uint64_t | b )

noexcept

Definition at line 1119 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## constant_fold_cmp_op< LT >() [3/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_cmp_op< LT > | ( | double | a,
|  | double | b )

noexcept

Definition at line 1124 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## operator>()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::operator> | ( | A && | a,
|  | B && | b )->CmpOp< GT, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1129 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and pattern_arg().

Referenced by gt().

## gt()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::gt | ( | A && | a,
|  | B && | b )->decltype(IRMatcher::operator>(a, b))

Definition at line 1134 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and operator>().

## constant_fold_cmp_op< GT >() [1/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_cmp_op< GT > | ( | int64_t | a,
|  | int64_t | b )

noexcept

Definition at line 1139 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## constant_fold_cmp_op< GT >() [2/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_cmp_op< GT > | ( | uint64_t | a,
|  | uint64_t | b )

noexcept

Definition at line 1144 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## constant_fold_cmp_op< GT >() [3/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_cmp_op< GT > | ( | double | a,
|  | double | b )

noexcept

Definition at line 1149 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## operator<=()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::operator<= | ( | A && | a,
|  | B && | b )->CmpOp< LE, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1154 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and pattern_arg().

Referenced by le().

## le()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::le | ( | A && | a,
|  | B && | b )->decltype(IRMatcher::operator<=(a, b))

Definition at line 1159 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and operator<=().

## constant_fold_cmp_op< LE >() [1/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_cmp_op< LE > | ( | int64_t | a,
|  | int64_t | b )

noexcept

Definition at line 1164 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## constant_fold_cmp_op< LE >() [2/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_cmp_op< LE > | ( | uint64_t | a,
|  | uint64_t | b )

noexcept

Definition at line 1169 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## constant_fold_cmp_op< LE >() [3/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_cmp_op< LE > | ( | double | a,
|  | double | b )

noexcept

Definition at line 1174 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## operator>=()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::operator>= | ( | A && | a,
|  | B && | b )->CmpOp< GE, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1179 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and pattern_arg().

Referenced by ge().

## ge()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::ge | ( | A && | a,
|  | B && | b )->decltype(IRMatcher::operator>=(a, b))

Definition at line 1184 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and operator>=().

## constant_fold_cmp_op< GE >() [1/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_cmp_op< GE > | ( | int64_t | a,
|  | int64_t | b )

noexcept

Definition at line 1189 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## constant_fold_cmp_op< GE >() [2/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_cmp_op< GE > | ( | uint64_t | a,
|  | uint64_t | b )

noexcept

Definition at line 1194 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## constant_fold_cmp_op< GE >() [3/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_cmp_op< GE > | ( | double | a,
|  | double | b )

noexcept

Definition at line 1199 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## operator==()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::operator== | ( | A && | a,
|  | B && | b )->CmpOp< EQ, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1204 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and pattern_arg().

Referenced by eq().

## eq()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::eq | ( | A && | a,
|  | B && | b )->decltype(IRMatcher::operator==(a, b))

Definition at line 1209 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and operator==().

## constant_fold_cmp_op< EQ >() [1/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_cmp_op< EQ > | ( | int64_t | a,
|  | int64_t | b )

noexcept

Definition at line 1214 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## constant_fold_cmp_op< EQ >() [2/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_cmp_op< EQ > | ( | uint64_t | a,
|  | uint64_t | b )

noexcept

Definition at line 1219 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## constant_fold_cmp_op< EQ >() [3/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_cmp_op< EQ > | ( | double | a,
|  | double | b )

noexcept

Definition at line 1224 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## operator!=()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::operator!= | ( | A && | a,
|  | B && | b )->CmpOp< NE, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1229 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and pattern_arg().

Referenced by ne().

## ne()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::ne | ( | A && | a,
|  | B && | b )->decltype(IRMatcher::operator!=(a, b))

Definition at line 1234 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and operator!=().

## constant_fold_cmp_op< NE >() [1/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_cmp_op< NE > | ( | int64_t | a,
|  | int64_t | b )

noexcept

Definition at line 1239 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## constant_fold_cmp_op< NE >() [2/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_cmp_op< NE > | ( | uint64_t | a,
|  | uint64_t | b )

noexcept

Definition at line 1244 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## constant_fold_cmp_op< NE >() [3/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_cmp_op< NE > | ( | double | a,
|  | double | b )

noexcept

Definition at line 1249 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## operator||()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::operator|| | ( | A && | a,
|  | B && | b )->BinOp< Or, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1254 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and pattern_arg().

Referenced by or_op().

## or_op()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::or_op | ( | A && | a,
|  | B && | b )->decltype(IRMatcher::operator||(a, b))

Definition at line 1259 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and operator||().

## constant_fold_bin_op< Or >() [1/3]

template<>

HALIDE_ALWAYS_INLINE int64_t Halide::Internal::IRMatcher::constant_fold_bin_op< Or > | ( | halide_type_t & | t,
|  | int64_t | a,
|  | int64_t | b )

noexcept

Definition at line 1264 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## constant_fold_bin_op< Or >() [2/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_bin_op< Or > | ( | halide_type_t & | t,
|  | uint64_t | a,
|  | uint64_t | b )

noexcept

Definition at line 1269 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## constant_fold_bin_op< Or >() [3/3]

template<>

HALIDE_ALWAYS_INLINE double Halide::Internal::IRMatcher::constant_fold_bin_op< Or > | ( | halide_type_t & | t,
|  | double | a,
|  | double | b )

noexcept

Definition at line 1274 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## operator&&()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::operator&& | ( | A && | a,
|  | B && | b )->BinOp< And, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1280 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and pattern_arg().

Referenced by and_op().

## and_op()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::and_op | ( | A && | a,
|  | B && | b )->decltype(IRMatcher::operator&&(a, b))

Definition at line 1285 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and operator&&().

## constant_fold_bin_op< And >() [1/3]

template<>

HALIDE_ALWAYS_INLINE int64_t Halide::Internal::IRMatcher::constant_fold_bin_op< And > | ( | halide_type_t & | t,
|  | int64_t | a,
|  | int64_t | b )

noexcept

Definition at line 1290 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## constant_fold_bin_op< And >() [2/3]

template<>

HALIDE_ALWAYS_INLINE uint64_t Halide::Internal::IRMatcher::constant_fold_bin_op< And > | ( | halide_type_t & | t,
|  | uint64_t | a,
|  | uint64_t | b )

noexcept

Definition at line 1295 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## constant_fold_bin_op< And >() [3/3]

template<>

HALIDE_ALWAYS_INLINE double Halide::Internal::IRMatcher::constant_fold_bin_op< And > | ( | halide_type_t & | t,
|  | double | a,
|  | double | b )

noexcept

Definition at line 1300 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## bitwise_or_reduce() [1/2]

uint32_t Halide::Internal::IRMatcher::bitwise_or_reduce | ( |  | ) |

constexpr

Definition at line 1305 of file IRMatch.h.

Referenced by bitwise_or_reduce().

## bitwise_or_reduce() [2/2]

template<typename... Args>

uint32_t Halide::Internal::IRMatcher::bitwise_or_reduce | ( | uint32_t | first,
|  | Args... | rest )

constexpr

Definition at line 1310 of file IRMatch.h.

References bitwise_or_reduce().

## and_reduce() [1/2]

bool Halide::Internal::IRMatcher::and_reduce | ( |  | ) |

constexpr

Definition at line 1314 of file IRMatch.h.

Referenced by and_reduce().

## and_reduce() [2/2]

template<typename... Args>

bool Halide::Internal::IRMatcher::and_reduce | ( | bool | first,
|  | Args... | rest )

constexpr

Definition at line 1319 of file IRMatch.h.

References and_reduce().

## operator<<() [23/44]

template<Call::IntrinsicOp intrin, typename... Args>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const Intrin< intrin, Args... > & | op )

Definition at line 1508 of file IRMatch.h.

References Halide::Internal::IRMatcher::Intrin< intrin, Args >::print_args().

## widen_right_add()

template<typename A, typename B>

auto Halide::Internal::IRMatcher::widen_right_add | ( | A && | a,
|  | B && | b )->Intrin< Call::widen_right_add, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1516 of file IRMatch.h.

References pattern_arg(), and Halide::Internal::Call::widen_right_add.

Referenced by Halide::Internal::IRMatcher::Intrin< intrin, Args >::make().

## widen_right_mul()

template<typename A, typename B>

auto Halide::Internal::IRMatcher::widen_right_mul | ( | A && | a,
|  | B && | b )->Intrin< Call::widen_right_mul, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1520 of file IRMatch.h.

References pattern_arg(), and Halide::Internal::Call::widen_right_mul.

Referenced by Halide::Internal::IRMatcher::Intrin< intrin, Args >::make().

## widen_right_sub()

template<typename A, typename B>

auto Halide::Internal::IRMatcher::widen_right_sub | ( | A && | a,
|  | B && | b )->Intrin< Call::widen_right_sub, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1524 of file IRMatch.h.

References pattern_arg(), and Halide::Internal::Call::widen_right_sub.

Referenced by Halide::Internal::IRMatcher::Intrin< intrin, Args >::make().

## widening_add()

template<typename A, typename B>

auto Halide::Internal::IRMatcher::widening_add | ( | A && | a,
|  | B && | b )->Intrin< Call::widening_add, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1529 of file IRMatch.h.

References pattern_arg(), and Halide::Internal::Call::widening_add.

Referenced by Halide::Internal::IRMatcher::Intrin< intrin, Args >::make().

## widening_sub()

template<typename A, typename B>

auto Halide::Internal::IRMatcher::widening_sub | ( | A && | a,
|  | B && | b )->Intrin< Call::widening_sub, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1533 of file IRMatch.h.

References pattern_arg(), and Halide::Internal::Call::widening_sub.

Referenced by Halide::Internal::IRMatcher::Intrin< intrin, Args >::make().

## widening_mul()

template<typename A, typename B>

auto Halide::Internal::IRMatcher::widening_mul | ( | A && | a,
|  | B && | b )->Intrin< Call::widening_mul, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1537 of file IRMatch.h.

References pattern_arg(), and Halide::Internal::Call::widening_mul.

Referenced by Halide::Internal::IRMatcher::Intrin< intrin, Args >::make().

## saturating_add()

template<typename A, typename B>

auto Halide::Internal::IRMatcher::saturating_add | ( | A && | a,
|  | B && | b )->Intrin< Call::saturating_add, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1541 of file IRMatch.h.

References pattern_arg(), and Halide::Internal::Call::saturating_add.

Referenced by Halide::Internal::IRMatcher::Intrin< intrin, Args >::make().

## saturating_sub()

template<typename A, typename B>

auto Halide::Internal::IRMatcher::saturating_sub | ( | A && | a,
|  | B && | b )->Intrin< Call::saturating_sub, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1545 of file IRMatch.h.

References pattern_arg(), and Halide::Internal::Call::saturating_sub.

Referenced by Halide::Internal::IRMatcher::Intrin< intrin, Args >::make().

## saturating_cast()

template<typename A>

auto Halide::Internal::IRMatcher::saturating_cast | ( | const Type & | t,
|  | A && | a )->Intrin< Call::saturating_cast, decltype(pattern_arg(a))>

noexcept

Definition at line 1549 of file IRMatch.h.

References pattern_arg(), and Halide::Internal::Call::saturating_cast.

Referenced by Halide::Internal::IRMatcher::Intrin< intrin, Args >::make().

## halving_add()

template<typename A, typename B>

auto Halide::Internal::IRMatcher::halving_add | ( | A && | a,
|  | B && | b )->Intrin< Call::halving_add, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1555 of file IRMatch.h.

References Halide::Internal::Call::halving_add, and pattern_arg().

Referenced by Halide::Internal::IRMatcher::Intrin< intrin, Args >::make().

## halving_sub()

template<typename A, typename B>

auto Halide::Internal::IRMatcher::halving_sub | ( | A && | a,
|  | B && | b )->Intrin< Call::halving_sub, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1559 of file IRMatch.h.

References Halide::Internal::Call::halving_sub, and pattern_arg().

Referenced by Halide::Internal::IRMatcher::Intrin< intrin, Args >::make().

## rounding_halving_add()

template<typename A, typename B>

auto Halide::Internal::IRMatcher::rounding_halving_add | ( | A && | a,
|  | B && | b )->Intrin< Call::rounding_halving_add, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1563 of file IRMatch.h.

References pattern_arg(), and Halide::Internal::Call::rounding_halving_add.

Referenced by Halide::Internal::IRMatcher::Intrin< intrin, Args >::make().

## shift_left()

template<typename A, typename B>

auto Halide::Internal::IRMatcher::shift_left | ( | A && | a,
|  | B && | b )->Intrin< Call::shift_left, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1567 of file IRMatch.h.

References pattern_arg(), and Halide::Internal::Call::shift_left.

## shift_right()

template<typename A, typename B>

auto Halide::Internal::IRMatcher::shift_right | ( | A && | a,
|  | B && | b )->Intrin< Call::shift_right, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1571 of file IRMatch.h.

References pattern_arg(), and Halide::Internal::Call::shift_right.

## rounding_shift_left()

template<typename A, typename B>

auto Halide::Internal::IRMatcher::rounding_shift_left | ( | A && | a,
|  | B && | b )->Intrin< Call::rounding_shift_left, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1575 of file IRMatch.h.

References pattern_arg(), and Halide::Internal::Call::rounding_shift_left.

Referenced by Halide::Internal::IRMatcher::Intrin< intrin, Args >::make().

## rounding_shift_right()

template<typename A, typename B>

auto Halide::Internal::IRMatcher::rounding_shift_right | ( | A && | a,
|  | B && | b )->Intrin< Call::rounding_shift_right, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1579 of file IRMatch.h.

References pattern_arg(), and Halide::Internal::Call::rounding_shift_right.

Referenced by Halide::Internal::IRMatcher::Intrin< intrin, Args >::make().

## mul_shift_right()

template<typename A, typename B, typename C>

auto Halide::Internal::IRMatcher::mul_shift_right | ( | A && | a,
|  | B && | b,
|  | C && | c )->Intrin< Call::mul_shift_right, decltype(pattern_arg(a)), decltype(pattern_arg(b)), decltype(pattern_arg(c))>

noexcept

Definition at line 1583 of file IRMatch.h.

References Halide::Internal::Call::mul_shift_right, and pattern_arg().

Referenced by Halide::Internal::IRMatcher::Intrin< intrin, Args >::make().

## rounding_mul_shift_right()

template<typename A, typename B, typename C>

auto Halide::Internal::IRMatcher::rounding_mul_shift_right | ( | A && | a,
|  | B && | b,
|  | C && | c )->Intrin< Call::rounding_mul_shift_right, decltype(pattern_arg(a)), decltype(pattern_arg(b)), decltype(pattern_arg(c))>

noexcept

Definition at line 1587 of file IRMatch.h.

References pattern_arg(), and Halide::Internal::Call::rounding_mul_shift_right.

Referenced by Halide::Internal::IRMatcher::Intrin< intrin, Args >::make().

## abs()

template<typename A>

auto Halide::Internal::IRMatcher::abs | ( | A && | a | ) | ->Intrin< Call::abs, decltype(pattern_arg(a))>

noexcept

Definition at line 1592 of file IRMatch.h.

References Halide::Internal::Call::abs, and pattern_arg().

Referenced by Halide::Internal::IRMatcher::Intrin< intrin, Args >::make().

## absd()

template<typename A, typename B>

auto Halide::Internal::IRMatcher::absd | ( | A && | a,
|  | B && | b )->Intrin< Call::absd, decltype(pattern_arg(a)), decltype(pattern_arg(b))>

noexcept

Definition at line 1597 of file IRMatch.h.

References Halide::Internal::Call::absd, and pattern_arg().

Referenced by Halide::Internal::IRMatcher::Intrin< intrin, Args >::make().

## likely()

template<typename A>

auto Halide::Internal::IRMatcher::likely | ( | A && | a | ) | ->Intrin< Call::likely, decltype(pattern_arg(a))>

noexcept

Definition at line 1602 of file IRMatch.h.

References Halide::Internal::Call::likely, and pattern_arg().

Referenced by Halide::Internal::IRMatcher::Intrin< intrin, Args >::make().

## likely_if_innermost()

template<typename A>

auto Halide::Internal::IRMatcher::likely_if_innermost | ( | A && | a | ) | ->Intrin< Call::likely_if_innermost, decltype(pattern_arg(a))>

noexcept

Definition at line 1607 of file IRMatch.h.

References Halide::Internal::Call::likely_if_innermost, and pattern_arg().

Referenced by Halide::Internal::IRMatcher::Intrin< intrin, Args >::make().

## operator!()

template<typename A>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::operator! | ( | A && | a | ) | ->NotOp< decltype(pattern_arg(a))>

noexcept

Definition at line 1652 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

Referenced by not_op().

## not_op()

template<typename A>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::not_op | ( | A && | a | ) | ->decltype(IRMatcher::operator!(a))

Definition at line 1658 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and operator!().

## operator<<() [24/44]

template<typename A>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const NotOp< A > & | op )

inline

Definition at line 1664 of file IRMatch.h.

References Halide::Internal::IRMatcher::NotOp< A >::a.

## operator<<() [25/44]

template<typename C, typename T, typename F>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const SelectOp< C, T, F > & | op )

Definition at line 1722 of file IRMatch.h.

References Halide::Internal::IRMatcher::SelectOp< C, T, F >::c, Halide::Internal::IRMatcher::SelectOp< C, T, F >::f, and Halide::Internal::IRMatcher::SelectOp< C, T, F >::t.

## select()

template<typename C, typename T, typename F>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::select | ( | C && | c,
|  | T && | t,
|  | F && | f )->SelectOp< decltype(pattern_arg(c)), decltype(pattern_arg(t)), decltype(pattern_arg(f))>

noexcept

Definition at line 1728 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

## operator<<() [26/44]

template<typename A, typename B>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const BroadcastOp< A, B > & | op )

inline

Definition at line 1795 of file IRMatch.h.

References Halide::Internal::IRMatcher::BroadcastOp< A, B >::a, and Halide::Internal::IRMatcher::BroadcastOp< A, B >::lanes.

## broadcast()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::broadcast | ( | A && | a,
|  | B | lanes )->BroadcastOp< decltype(pattern_arg(a)), decltype(pattern_arg(lanes))>

noexcept

Definition at line 1801 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

## operator<<() [27/44]

template<typename A, typename B, typename C>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const RampOp< A, B, C > & | op )

Definition at line 1859 of file IRMatch.h.

References Halide::Internal::IRMatcher::RampOp< A, B, C >::a, Halide::Internal::IRMatcher::RampOp< A, B, C >::b, and Halide::Internal::IRMatcher::RampOp< A, B, C >::lanes.

## ramp()

template<typename A, typename B, typename C>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::ramp | ( | A && | a,
|  | B && | b,
|  | C && | c )->RampOp< decltype(pattern_arg(a)), decltype(pattern_arg(b)), decltype(pattern_arg(c))>

noexcept

Definition at line 1865 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

## operator<<() [28/44]

template<typename A, typename B, VectorReduce::Operator reduce_op>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const VectorReduceOp< A, B, reduce_op > & | op )

inline

Definition at line 1917 of file IRMatch.h.

References Halide::Internal::IRMatcher::VectorReduceOp< A, B, reduce_op >::a, and Halide::Internal::IRMatcher::VectorReduceOp< A, B, reduce_op >::lanes.

## h_add()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::h_add | ( | A && | a,
|  | B | lanes )->VectorReduceOp< decltype(pattern_arg(a)), decltype(pattern_arg(lanes)), VectorReduce::Add >

noexcept

Definition at line 1923 of file IRMatch.h.

References Halide::Internal::VectorReduce::Add, assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

## h_min()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::h_min | ( | A && | a,
|  | B | lanes )->VectorReduceOp< decltype(pattern_arg(a)), decltype(pattern_arg(lanes)), VectorReduce::Min >

noexcept

Definition at line 1929 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, Halide::Internal::VectorReduce::Min, and pattern_arg().

## h_max()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::h_max | ( | A && | a,
|  | B | lanes )->VectorReduceOp< decltype(pattern_arg(a)), decltype(pattern_arg(lanes)), VectorReduce::Max >

noexcept

Definition at line 1935 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, Halide::Internal::VectorReduce::Max, and pattern_arg().

## h_and()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::h_and | ( | A && | a,
|  | B | lanes )->VectorReduceOp< decltype(pattern_arg(a)), decltype(pattern_arg(lanes)), VectorReduce::And >

noexcept

Definition at line 1941 of file IRMatch.h.

References Halide::Internal::VectorReduce::And, assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

## h_or()

template<typename A, typename B>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::h_or | ( | A && | a,
|  | B | lanes )->VectorReduceOp< decltype(pattern_arg(a)), decltype(pattern_arg(lanes)), VectorReduce::Or >

noexcept

Definition at line 1947 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, Halide::Internal::VectorReduce::Or, and pattern_arg().

## operator<<() [29/44]

template<typename A>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const NegateOp< A > & | op )

Definition at line 2017 of file IRMatch.h.

References Halide::Internal::IRMatcher::NegateOp< A >::a.

## operator-() [2/2]

template<typename A>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::operator- | ( | A && | a | ) | ->NegateOp< decltype(pattern_arg(a))>

noexcept

Definition at line 2023 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

## negate()

template<typename A>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::negate | ( | A && | a | ) | ->decltype(IRMatcher::operator-(a))

Definition at line 2029 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and operator-().

## operator<<() [30/44]

template<typename A>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const CastOp< A > & | op )

Definition at line 2069 of file IRMatch.h.

References Halide::Internal::IRMatcher::CastOp< A >::a, and Halide::Internal::IRMatcher::CastOp< A >::t.

## cast()

template<typename A>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::cast | ( | halide_type_t | t,
|  | A && | a )->CastOp< decltype(pattern_arg(a))>

noexcept

Definition at line 2075 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

Referenced by Halide::Internal::IRMatcher::CastOp< A >::make(), and Halide::Internal::IRMatcher::WidenOp< A >::make().

## operator<<() [31/44]

template<typename A>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const WidenOp< A > & | op )

Definition at line 2116 of file IRMatch.h.

References Halide::Internal::IRMatcher::WidenOp< A >::a.

## widen()

template<typename A>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::widen | ( | A && | a | ) | ->WidenOp< decltype(pattern_arg(a))>

noexcept

Definition at line 2122 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

## operator<<() [32/44]

template<typename Vec, typename Base, typename Stride, typename Lanes>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const SliceOp< Vec, Base, Stride, Lanes > & | op )

Definition at line 2180 of file IRMatch.h.

References Halide::Internal::IRMatcher::SliceOp< Vec, Base, Stride, Lanes >::base, Halide::Internal::IRMatcher::SliceOp< Vec, Base, Stride, Lanes >::lanes, Halide::Internal::IRMatcher::SliceOp< Vec, Base, Stride, Lanes >::stride, and Halide::Internal::IRMatcher::SliceOp< Vec, Base, Stride, Lanes >::vec.

## slice()

template<typename Vec, typename Base, typename Stride, typename Lanes>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::slice | ( | Vec | vec,
|  | Base | base,
|  | Stride | stride,
|  | Lanes | lanes )->SliceOp< decltype(pattern_arg(vec)), decltype(pattern_arg(base)), decltype(pattern_arg(stride)), decltype(pattern_arg(lanes))>

noexcept

Definition at line 2186 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and pattern_arg().

## fold()

template<typename A>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::fold | ( | A && | a | ) | ->Fold< decltype(pattern_arg(a))>

noexcept

Definition at line 2234 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

## operator<<() [33/44]

template<typename A>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const Fold< A > & | op )

Definition at line 2240 of file IRMatch.h.

References Halide::Internal::IRMatcher::Fold< A >::a.

## overflows()

template<typename A>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::overflows | ( | A && | a | ) | ->Overflows< decltype(pattern_arg(a))>

noexcept

Definition at line 2271 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

## operator<<() [34/44]

template<typename A>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const Overflows< A > & | op )

Definition at line 2277 of file IRMatch.h.

References Halide::Internal::IRMatcher::Overflows< A >::a.

## operator<<() [35/44]

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const Overflow & | op )

inline

Definition at line 2316 of file IRMatch.h.

## is_const() [1/2]

template<typename A>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::is_const | ( | A && | a | ) | ->IsConst< decltype(pattern_arg(a))>

noexcept

Definition at line 2353 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

## is_const() [2/2]

template<typename A>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::is_const | ( | A && | a,
|  | int64_t | value )->IsConst< decltype(pattern_arg(a))>

noexcept

Definition at line 2359 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

## operator<<() [36/44]

template<typename A>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const IsConst< A > & | op )

Definition at line 2365 of file IRMatch.h.

References Halide::Internal::IRMatcher::IsConst< A >::a, Halide::Internal::IRMatcher::IsConst< A >::check_v, and Halide::Internal::IRMatcher::IsConst< A >::v.

## can_prove()

template<typename A, typename Prover>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::can_prove | ( | A && | a,
|  | Prover * | p )->CanProve< decltype(pattern_arg(a)), Prover >

noexcept

Definition at line 2401 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

## operator<<() [37/44]

template<typename A, typename Prover>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const CanProve< A, Prover > & | op )

Definition at line 2407 of file IRMatch.h.

References Halide::Internal::IRMatcher::CanProve< A, Prover >::a.

## is_float()

template<typename A>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::is_float | ( | A && | a | ) | ->IsFloat< decltype(pattern_arg(a))>

noexcept

Definition at line 2438 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

## operator<<() [38/44]

template<typename A>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const IsFloat< A > & | op )

Definition at line 2444 of file IRMatch.h.

References Halide::Internal::IRMatcher::IsFloat< A >::a.

## is_int()

template<typename A>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::is_int | ( | A && | a,
|  | uint8_t | bits = 0,
|  | uint16_t | lanes = 0 )->IsInt< decltype(pattern_arg(a))>

noexcept

Definition at line 2477 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

## operator<<() [39/44]

template<typename A>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const IsInt< A > & | op )

Definition at line 2483 of file IRMatch.h.

References Halide::Internal::IRMatcher::IsInt< A >::a, Halide::Internal::IRMatcher::IsInt< A >::bits, and Halide::Internal::IRMatcher::IsInt< A >::lanes.

## is_uint()

template<typename A>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::is_uint | ( | A && | a,
|  | uint8_t | bits = 0,
|  | uint16_t | lanes = 0 )->IsUInt< decltype(pattern_arg(a))>

noexcept

Definition at line 2523 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

## operator<<() [40/44]

template<typename A>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const IsUInt< A > & | op )

Definition at line 2529 of file IRMatch.h.

References Halide::Internal::IRMatcher::IsUInt< A >::a, Halide::Internal::IRMatcher::IsUInt< A >::bits, and Halide::Internal::IRMatcher::IsUInt< A >::lanes.

## is_scalar()

template<typename A>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::is_scalar | ( | A && | a | ) | ->IsScalar< decltype(pattern_arg(a))>

noexcept

Definition at line 2567 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

## operator<<() [41/44]

template<typename A>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const IsScalar< A > & | op )

Definition at line 2573 of file IRMatch.h.

References Halide::Internal::IRMatcher::IsScalar< A >::a.

## is_max_value()

template<typename A>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::is_max_value | ( | A && | a | ) | ->IsMaxValue< decltype(pattern_arg(a))>

noexcept

Definition at line 2608 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

## operator<<() [42/44]

template<typename A>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const IsMaxValue< A > & | op )

Definition at line 2614 of file IRMatch.h.

References Halide::Internal::IRMatcher::IsMaxValue< A >::a.

## is_min_value()

template<typename A>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::is_min_value | ( | A && | a | ) | ->IsMinValue< decltype(pattern_arg(a))>

noexcept

Definition at line 2651 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

## operator<<() [43/44]

template<typename A>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const IsMinValue< A > & | op )

Definition at line 2657 of file IRMatch.h.

References Halide::Internal::IRMatcher::IsMinValue< A >::a.

## lanes_of()

template<typename A>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::lanes_of | ( | A && | a | ) | ->LanesOf< decltype(pattern_arg(a))>

noexcept

Definition at line 2688 of file IRMatch.h.

References assert_is_lvalue_if_expr(), HALIDE_ALWAYS_INLINE, and pattern_arg().

## operator<<() [44/44]

template<typename A>

std::ostream & Halide::Internal::IRMatcher::operator<< | ( | std::ostream & | s,
|  | const LanesOf< A > & | op )

Definition at line 2694 of file IRMatch.h.

References Halide::Internal::IRMatcher::LanesOf< A >::a.

## fuzz_test_rule() [1/2]

template<typename Before, typename After, typename Predicate, typename = typename std::enable_if<std::decay<Before>::type::foldable && std::decay<After>::type::foldable>::type>

HALIDE_NEVER_INLINE void Halide::Internal::IRMatcher::fuzz_test_rule | ( | Before && | before,
|  | After && | after,
|  | Predicate && | pred,
|  | halide_type_t | wildcard_type,
|  | halide_type_t | output_type )

noexcept

Definition at line 2705 of file IRMatch.h.

References constant_fold_bin_op< Add >(), debug, evaluate_predicate(), halide_scalar_value_t::f64, Halide::Internal::IRMatcher::MatcherState::get_binding(), Halide::Internal::IRMatcher::MatcherState::get_bound_const(), HALIDE_NEVER_INLINE, halide_type_bfloat, halide_type_float, halide_type_int, halide_type_uint, halide_scalar_value_t::i64, internal_error, halide_type_t::lanes, Halide::Internal::make_const(), make_const_expr(), max_wild, Halide::Internal::reinterpret_bits(), Halide::Internal::IRMatcher::MatcherState::set_binding(), Halide::Internal::IRMatcher::MatcherState::set_bound_const(), Halide::Internal::IRMatcher::MatcherState::special_values_mask, Halide::Internal::Type, halide_scalar_value_t::u, and halide_scalar_value_t::u64.

Referenced by Halide::Internal::IRMatcher::Rewriter< Instance >::operator()(), Halide::Internal::IRMatcher::Rewriter< Instance >::operator()(), Halide::Internal::IRMatcher::Rewriter< Instance >::operator()(), and Halide::Internal::IRMatcher::Rewriter< Instance >::operator()().

## fuzz_test_rule() [2/2]

template<typename Before, typename After, typename Predicate, typename = typename std::enable_if<!(std::decay<Before>::type::foldable && std::decay<After>::type::foldable)>::type>

HALIDE_ALWAYS_INLINE void Halide::Internal::IRMatcher::fuzz_test_rule | ( | Before && | before,
|  | After && | after,
|  | Predicate && | pred,
|  | halide_type_t | ,
|  | halide_type_t | ,
|  | int | dummy = 0 )

noexcept

Definition at line 2830 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE.

## evaluate_predicate() [1/2]

HALIDE_ALWAYS_INLINE bool Halide::Internal::IRMatcher::evaluate_predicate | ( | bool | x,
|  | MatcherState & | )

noexcept

Definition at line 2836 of file IRMatch.h.

Referenced by fuzz_test_rule(), Halide::Internal::IRMatcher::Rewriter< Instance >::operator()(), Halide::Internal::IRMatcher::Rewriter< Instance >::operator()(), and Halide::Internal::IRMatcher::Rewriter< Instance >::operator()().

## evaluate_predicate() [2/2]

template<typename Pattern, typename = typename enable_if_pattern<Pattern>::type>

HALIDE_ALWAYS_INLINE bool Halide::Internal::IRMatcher::evaluate_predicate | ( | Pattern | p,
|  | MatcherState & | state )

Definition at line 2842 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, halide_type_t::lanes, Halide::Internal::IRMatcher::MatcherState::special_values_mask, halide_scalar_value_t::u, and halide_scalar_value_t::u64.

## rewriter() [1/4]

template<typename Instance, typename = typename enable_if_pattern<Instance>::type>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::rewriter | ( | Instance | instance,
|  | halide_type_t | output_type,
|  | halide_type_t | wildcard_type )->Rewriter< decltype(pattern_arg(instance))>

noexcept

Construct a rewriter for the given instance, which may be a pattern with concrete expressions as leaves, or just an expression.

The second optional argument (wildcard_type) is a hint as to what the type of the wildcards is likely to be. If omitted it uses the same type as the expression itself. They are not required to be this type, but the rule will only be tested for wildcards of that type when testing is enabled.

The rewriter can be used to check to see if the instance is one of some number of patterns and if so rewrite it into another form, using its operator() method. See Simplify.cpp for a bunch of example usage.

Important: Any Exprs in patterns are captured by reference, not by value, so ensure they outlive the rewriter.

Definition at line 3046 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and pattern_arg().

## rewriter() [2/4]

template<typename Instance, typename = typename enable_if_pattern<Instance>::type>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::rewriter | ( | Instance | instance,
|  | halide_type_t | output_type )->Rewriter< decltype(pattern_arg(instance))>

noexcept

Definition at line 3052 of file IRMatch.h.

References HALIDE_ALWAYS_INLINE, and pattern_arg().

## rewriter() [3/4]

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::rewriter | ( | const Expr & | e,
|  | halide_type_t | wildcard_type )->Rewriter< decltype(pattern_arg(e))>

noexcept

Definition at line 3057 of file IRMatch.h.

References pattern_arg().

## rewriter() [4/4]

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::rewriter | ( | const Expr & | e | ) | ->Rewriter< decltype(pattern_arg(e))>

noexcept

Definition at line 3062 of file IRMatch.h.

References pattern_arg().

## Variable Documentation

## max_wild

int Halide::Internal::IRMatcher::max_wild = 6

constexpr

Definition at line 74 of file IRMatch.h.

Referenced by fuzz_test_rule(), Halide::Internal::IRMatcher::WildConst< i >::match(), Halide::Internal::IRMatcher::WildConst< i >::match(), Halide::Internal::IRMatcher::WildConstFloat< i >::match(), Halide::Internal::IRMatcher::WildConstInt< i >::match(), Halide::Internal::IRMatcher::WildConstInt< i >::match(), and Halide::Internal::IRMatcher::WildConstUInt< i >::match().