Halide 22.0.0 Halide compiler and libraries

Classes | Functions | Variables
Halide::Internal::IRMatcher Namespace Reference

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

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

## 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<T>::pattern_tag, typename = std::enable_if_t<!std::is_same_v<std::decay_t<T>, SpecificExpr>>>
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<int i>
HALIDE_ALWAYS_INLINE auto | neg (const Wild< i > &a) -> SimplifiedNegateOp< i >
template<int i>
std::ostream & | operator<< (std::ostream &s, const SimplifiedNegateOp< i > &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 = std::enable_if_t<std::decay_t<Before>::foldable && std::decay_t<After>::foldable>>
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 = std::enable_if_t<!(std::decay_t<Before>::foldable && std::decay_t<After>::foldable)>>
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. More...
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_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::WildConstInt< i >::make(), Halide::Internal::IRMatcher::WildConstUInt< i >::make(), Halide::Internal::IRMatcher::WildConstFloat< i >::make(), Halide::Internal::IRMatcher::WildConst< i >::make(), and Halide::Internal::IRMatcher::Fold< A >::make().

## ◆ operator<<() [1/45]

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/45]

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/45]

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/45]

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/45]

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/45]

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::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::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::NegateOp< A >::match(), 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.

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_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||(), overflows(), ramp(), 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.

## ◆ 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().

## ◆ unwrap() [2/3]

template<typename T , typename = typename std::decay_t<T>::pattern_tag, typename = std::enable_if_t<!std::is_same_v<std::decay_t<T>, SpecificExpr>>>

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

Definition at line 592 of file IRMatch.h.

## ◆ 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/45]

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

## ◆ 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()

constexpr 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

## ◆ 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/45]

template<typename A , typename B >

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

Definition at line 816 of file IRMatch.h.

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

## ◆ operator<<() [9/45]

template<typename A , typename B >

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

Definition at line 822 of file IRMatch.h.

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

## ◆ operator<<() [10/45]

template<typename A , typename B >

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

Definition at line 828 of file IRMatch.h.

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

## ◆ operator<<() [11/45]

template<typename A , typename B >

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

Definition at line 834 of file IRMatch.h.

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

## ◆ operator<<() [12/45]

template<typename A , typename B >

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

Definition at line 840 of file IRMatch.h.

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

## ◆ operator<<() [13/45]

template<typename A , typename B >

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

Definition at line 846 of file IRMatch.h.

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

## ◆ operator<<() [14/45]

template<typename A , typename B >

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

Definition at line 852 of file IRMatch.h.

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

## ◆ operator<<() [15/45]

template<typename A , typename B >

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

Definition at line 858 of file IRMatch.h.

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

## ◆ operator<<() [16/45]

template<typename A , typename B >

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

Definition at line 864 of file IRMatch.h.

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

## ◆ operator<<() [17/45]

template<typename A , typename B >

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

Definition at line 870 of file IRMatch.h.

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

## ◆ operator<<() [18/45]

template<typename A , typename B >

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

Definition at line 876 of file IRMatch.h.

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

## ◆ operator<<() [19/45]

template<typename A , typename B >

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

Definition at line 882 of file IRMatch.h.

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

## ◆ operator<<() [20/45]

template<typename A , typename B >

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

Definition at line 888 of file IRMatch.h.

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

## ◆ operator<<() [21/45]

template<typename A , typename B >

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

Definition at line 894 of file IRMatch.h.

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

## ◆ operator<<() [22/45]

template<typename A , typename B >

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

Definition at line 900 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 906 of file IRMatch.h.

References 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 913 of file IRMatch.h.

References 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 920 of file IRMatch.h.

References Halide::Internal::add_would_overflow(), 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 928 of file IRMatch.h.

## ◆ 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 934 of file IRMatch.h.

## ◆ 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 939 of file IRMatch.h.

References 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 946 of file IRMatch.h.

References 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 953 of file IRMatch.h.

References 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 961 of file IRMatch.h.

## ◆ 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 967 of file IRMatch.h.

## ◆ 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 972 of file IRMatch.h.

References 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 979 of file IRMatch.h.

References 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 986 of file IRMatch.h.

References 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 994 of file IRMatch.h.

## ◆ 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 1000 of file IRMatch.h.

## ◆ 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 1005 of file IRMatch.h.

References 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 1012 of file IRMatch.h.

References 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 1017 of file IRMatch.h.

References Halide::Internal::div_imp().

## ◆ 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 1022 of file IRMatch.h.

References Halide::Internal::div_imp().

## ◆ 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 1027 of file IRMatch.h.

References Halide::Internal::div_imp().

## ◆ 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 1032 of file IRMatch.h.

References 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 1039 of file IRMatch.h.

References operator%().

Referenced by Halide::Internal::GPUCompilationCache< ContextT, ModuleStateT >::kernel_state_setup(), and Halide::Internal::GPUCompilationCache< ContextT, ModuleStateT >::release_hold().

## ◆ 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 1046 of file IRMatch.h.

References 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 1051 of file IRMatch.h.

References 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 1056 of file IRMatch.h.

References 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 1061 of file IRMatch.h.

References pattern_arg().

Referenced by constant_fold_bin_op< Min >().

## ◆ 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 1068 of file IRMatch.h.

References min().

## ◆ 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 1073 of file IRMatch.h.

References min().

## ◆ 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 1078 of file IRMatch.h.

References min().

## ◆ 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 1083 of file IRMatch.h.

References pattern_arg().

Referenced by constant_fold_bin_op< Max >().

## ◆ 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 1090 of file IRMatch.h.

References max().

## ◆ 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 1095 of file IRMatch.h.

References max().

## ◆ 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 1100 of file IRMatch.h.

References max().

## ◆ 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 1105 of file IRMatch.h.

References 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 1110 of file IRMatch.h.

References 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 1115 of file IRMatch.h.

## ◆ 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 1120 of file IRMatch.h.

## ◆ 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 1125 of file IRMatch.h.

## ◆ 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 1130 of file IRMatch.h.

References 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 1135 of file IRMatch.h.

References 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 1140 of file IRMatch.h.

## ◆ 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 1145 of file IRMatch.h.

## ◆ 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 1150 of file IRMatch.h.

## ◆ 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 1155 of file IRMatch.h.

References 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 1160 of file IRMatch.h.

References 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 1165 of file IRMatch.h.

## ◆ 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 1170 of file IRMatch.h.

## ◆ 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 1175 of file IRMatch.h.

## ◆ 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 1180 of file IRMatch.h.

References 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 1185 of file IRMatch.h.

References 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 1190 of file IRMatch.h.

## ◆ 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 1195 of file IRMatch.h.

## ◆ 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 1200 of file IRMatch.h.

## ◆ 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 1205 of file IRMatch.h.

References 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 1210 of file IRMatch.h.

References 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 1215 of file IRMatch.h.

## ◆ 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 1220 of file IRMatch.h.

## ◆ 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 1225 of file IRMatch.h.

## ◆ 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 1230 of file IRMatch.h.

References 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 1235 of file IRMatch.h.

References 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 1240 of file IRMatch.h.

## ◆ 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 1245 of file IRMatch.h.

## ◆ 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 1250 of file IRMatch.h.

## ◆ 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 1255 of file IRMatch.h.

References 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 1260 of file IRMatch.h.

References 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 1265 of file IRMatch.h.

## ◆ 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 1270 of file IRMatch.h.

## ◆ 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 1275 of file IRMatch.h.

## ◆ 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 1281 of file IRMatch.h.

References 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 1286 of file IRMatch.h.

References 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 1291 of file IRMatch.h.

## ◆ 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 1296 of file IRMatch.h.

## ◆ 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 1301 of file IRMatch.h.

## ◆ bitwise_or_reduce() [1/2]

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

Definition at line 1306 of file IRMatch.h.

Referenced by bitwise_or_reduce().

## ◆ bitwise_or_reduce() [2/2]

template<typename... Args>

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

Definition at line 1311 of file IRMatch.h.

References bitwise_or_reduce().

## ◆ and_reduce() [1/2]

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

Definition at line 1315 of file IRMatch.h.

Referenced by and_reduce().

## ◆ and_reduce() [2/2]

template<typename... Args>

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

Definition at line 1320 of file IRMatch.h.

References and_reduce().

## ◆ operator<<() [23/45]

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

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

Definition at line 1509 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 1517 of file IRMatch.h.

References pattern_arg().

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 1521 of file IRMatch.h.

References pattern_arg().

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 1525 of file IRMatch.h.

References pattern_arg().

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 1530 of file IRMatch.h.

References pattern_arg().

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 1534 of file IRMatch.h.

References pattern_arg().

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 1538 of file IRMatch.h.

References pattern_arg().

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 1542 of file IRMatch.h.

References pattern_arg().

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 1546 of file IRMatch.h.

References pattern_arg().

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 1550 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 1556 of file IRMatch.h.

References 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 1560 of file IRMatch.h.

References 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 1564 of file IRMatch.h.

References pattern_arg().

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 1568 of file IRMatch.h.

References pattern_arg().

## ◆ 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 1572 of file IRMatch.h.

References pattern_arg().

## ◆ 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 1576 of file IRMatch.h.

References pattern_arg().

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 1580 of file IRMatch.h.

References pattern_arg().

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 1584 of file IRMatch.h.

References 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 1588 of file IRMatch.h.

References pattern_arg().

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 1593 of file IRMatch.h.

References pattern_arg().

Referenced by fuzz_test_rule(), and 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 1598 of file IRMatch.h.

References 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 1603 of file IRMatch.h.

References 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 1608 of file IRMatch.h.

References 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 1653 of file IRMatch.h.

References 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 1659 of file IRMatch.h.

References operator!().

## ◆ operator<<() [24/45]

template<typename A >

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

Definition at line 1665 of file IRMatch.h.

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

## ◆ neg()

template<int i>

HALIDE_ALWAYS_INLINE auto Halide::Internal::IRMatcher::neg | ( | const Wild< i > & | a | ) | -> SimplifiedNegateOp<i>

Definition at line 1720 of file IRMatch.h.

## ◆ operator<<() [25/45]

template<int i>

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

Definition at line 1725 of file IRMatch.h.

## ◆ operator<<() [26/45]

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 1783 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

Examples
  tutorial/lesson_13_tuples.cpp.

Definition at line 1789 of file IRMatch.h.

References pattern_arg().

## ◆ operator<<() [27/45]

template<typename A , typename B >

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

Definition at line 1856 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 1862 of file IRMatch.h.

References pattern_arg().

## ◆ operator<<() [28/45]

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 1920 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 1926 of file IRMatch.h.

References pattern_arg().

Referenced by Halide::Internal::HexagonAlignmentAnalyzer::is_aligned_impl().

## ◆ operator<<() [29/45]

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 1978 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 1984 of file IRMatch.h.

References 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 1990 of file IRMatch.h.

References 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 1996 of file IRMatch.h.

References 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 2002 of file IRMatch.h.

References 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 2008 of file IRMatch.h.

References pattern_arg().

## ◆ operator<<() [30/45]

template<typename A >

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

Definition at line 2078 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 2084 of file IRMatch.h.

References pattern_arg().

## ◆ negate()

template<typename A >

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

Definition at line 2090 of file IRMatch.h.

References operator-().

## ◆ operator<<() [31/45]

template<typename A >

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

Definition at line 2130 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 2136 of file IRMatch.h.

References pattern_arg().

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

## ◆ operator<<() [32/45]

template<typename A >

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

Definition at line 2177 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 2183 of file IRMatch.h.

References pattern_arg().

## ◆ operator<<() [33/45]

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 2241 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 2247 of file IRMatch.h.

References pattern_arg().

Referenced by Halide::Runtime::Buffer< T, Dims, InClassDimStorage >::slice().

## ◆ fold()

template<typename A >

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

Definition at line 2295 of file IRMatch.h.

References pattern_arg().

## ◆ operator<<() [34/45]

template<typename A >

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

Definition at line 2301 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 2332 of file IRMatch.h.

References pattern_arg().

## ◆ operator<<() [35/45]

template<typename A >

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

Definition at line 2338 of file IRMatch.h.

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

## ◆ operator<<() [36/45]

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

Definition at line 2377 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 2414 of file IRMatch.h.

References pattern_arg().

Referenced by halide_handle_cplusplus_type::make().

## ◆ 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 2420 of file IRMatch.h.

References pattern_arg().

Referenced by Halide::Internal::IRMatcher::IsConst< A >::make_folded_const().

## ◆ operator<<() [37/45]

template<typename A >

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

Definition at line 2426 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 2462 of file IRMatch.h.

References pattern_arg().

## ◆ operator<<() [38/45]

template<typename A , typename Prover >

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

Definition at line 2468 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 2499 of file IRMatch.h.

References pattern_arg().

## ◆ operator<<() [39/45]

template<typename A >

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

Definition at line 2505 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

Examples
  tutorial/lesson_14_types.cpp.

Definition at line 2538 of file IRMatch.h.

References pattern_arg().

## ◆ operator<<() [40/45]

template<typename A >

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

Definition at line 2544 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 2584 of file IRMatch.h.

References pattern_arg().

## ◆ operator<<() [41/45]

template<typename A >

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

Definition at line 2590 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 2628 of file IRMatch.h.

References pattern_arg().

## ◆ operator<<() [42/45]

template<typename A >

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

Definition at line 2634 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 2669 of file IRMatch.h.

References pattern_arg().

## ◆ operator<<() [43/45]

template<typename A >

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

Definition at line 2675 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 2712 of file IRMatch.h.

References pattern_arg().

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

template<typename A >

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

Definition at line 2718 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 2749 of file IRMatch.h.

References pattern_arg().

## ◆ operator<<() [45/45]

template<typename A >

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

Definition at line 2755 of file IRMatch.h.

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

## ◆ fuzz_test_rule() [1/2]

template<typename Before , typename After , typename Predicate , typename = std::enable_if_t<std::decay_t<Before>::foldable && std::decay_t<After>::foldable>>

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 2766 of file IRMatch.h.

References abs(), 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_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::IRMatcher::MatcherState::set_binding(), Halide::Internal::IRMatcher::MatcherState::set_bound_const(), Halide::Internal::IRMatcher::MatcherState::special_values_mask, halide_scalar_value_t::u, and halide_scalar_value_t::u64.

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

## ◆ fuzz_test_rule() [2/2]

template<typename Before , typename After , typename Predicate , typename = std::enable_if_t<!(std::decay_t<Before>::foldable && std::decay_t<After>::foldable)>>

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 2891 of file IRMatch.h.

## ◆ evaluate_predicate() [1/2]

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

Definition at line 2897 of file IRMatch.h.

Referenced by fuzz_test_rule(), 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 2903 of file IRMatch.h.

References 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 3107 of file IRMatch.h.

References 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 3113 of file IRMatch.h.

References 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 3118 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 3123 of file IRMatch.h.

References pattern_arg().

## Variable Documentation

## ◆ max_wild

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

Definition at line 74 of file IRMatch.h.

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