|
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) |
|
constexpr int | const_min (int a, int b) |
|
template<typename... Args> |
std::ostream & | operator<< (std::ostream &s, const Intrin< Args... > &op) |
|
template<typename... Args> |
HALIDE_ALWAYS_INLINE auto | intrin (Call::IntrinsicOp intrinsic_op, Args... args) noexcept -> Intrin< decltype(pattern_arg(args))... > |
|
template<typename A , typename B > |
auto | widen_right_add (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
|
template<typename A , typename B > |
auto | widen_right_mul (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
|
template<typename A , typename B > |
auto | widen_right_sub (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
|
template<typename A , typename B > |
auto | widening_add (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
|
template<typename A , typename B > |
auto | widening_sub (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
|
template<typename A , typename B > |
auto | widening_mul (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
|
template<typename A , typename B > |
auto | saturating_add (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
|
template<typename A , typename B > |
auto | saturating_sub (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
|
template<typename A > |
auto | saturating_cast (const Type &t, A &&a) noexcept -> Intrin< decltype(pattern_arg(a))> |
|
template<typename A , typename B > |
auto | halving_add (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
|
template<typename A , typename B > |
auto | halving_sub (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
|
template<typename A , typename B > |
auto | rounding_halving_add (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
|
template<typename A , typename B > |
auto | shift_left (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
|
template<typename A , typename B > |
auto | shift_right (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
|
template<typename A , typename B > |
auto | rounding_shift_left (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
|
template<typename A , typename B > |
auto | rounding_shift_right (A &&a, B &&b) noexcept -> Intrin< 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< 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< decltype(pattern_arg(a)), decltype(pattern_arg(b)), decltype(pattern_arg(c))> |
|
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, int bits=0, int 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, int bits=0, int 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))> |
|