Halide 19.0.0
Halide compiler and libraries
|
Defines a method to match a fragment of IR against a pattern containing wildcards. More...
#include <map>
#include <random>
#include <set>
#include <vector>
#include "IR.h"
#include "IREquality.h"
#include "IROperator.h"
Go to the source code of this file.
Namespaces | |
namespace | Halide |
This file defines the class FunctionDAG, which is our representation of a Halide pipeline, and contains methods to using Halide's bounds tools to query properties of it. | |
namespace | Halide::Internal |
namespace | Halide::Internal::IRMatcher |
An alternative template-metaprogramming approach to expression matching. | |
Macros | |
#define | HALIDE_DEBUG_MATCHED_RULES 0 |
#define | HALIDE_DEBUG_UNMATCHED_RULES 0 |
#define | HALIDE_FUZZ_TEST_RULES 0 |
Functions | |
bool | Halide::Internal::expr_match (const Expr &pattern, const Expr &expr, std::vector< Expr > &result) |
Does the first expression have the same structure as the second? Variables in the first expression with the name * are interpreted as wildcards, and their matching equivalent in the second expression is placed in the vector give as the third argument. | |
bool | Halide::Internal::expr_match (const Expr &pattern, const Expr &expr, std::map< std::string, Expr > &result) |
Does the first expression have the same structure as the second? Variables are matched consistently. | |
Expr | Halide::Internal::with_lanes (const Expr &x, int lanes) |
Rewrite the expression x to have lanes lanes. | |
void | Halide::Internal::expr_match_test () |
HALIDE_NEVER_INLINE Expr | Halide::Internal::IRMatcher::make_const_special_expr (halide_type_t ty) |
HALIDE_ALWAYS_INLINE Expr | Halide::Internal::IRMatcher::make_const_expr (halide_scalar_value_t val, halide_type_t ty) |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const SpecificExpr &e) |
template<int i> | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const WildConstInt< i > &c) |
template<int i> | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const WildConstUInt< i > &c) |
template<int i> | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const WildConstFloat< i > &c) |
template<int i> | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const WildConst< i > &c) |
template<int i> | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const Wild< i > &op) |
HALIDE_ALWAYS_INLINE int64_t | Halide::Internal::IRMatcher::unwrap (IntLiteral t) |
template<typename T , typename = typename std::decay<T>::type::pattern_tag> | |
HALIDE_ALWAYS_INLINE T | Halide::Internal::IRMatcher::pattern_arg (T t) |
HALIDE_ALWAYS_INLINE IntLiteral | Halide::Internal::IRMatcher::pattern_arg (int64_t x) |
template<typename T > | |
HALIDE_ALWAYS_INLINE void | Halide::Internal::IRMatcher::assert_is_lvalue_if_expr () |
HALIDE_ALWAYS_INLINE SpecificExpr | Halide::Internal::IRMatcher::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 | Halide::Internal::IRMatcher::unwrap (T t) |
HALIDE_ALWAYS_INLINE const BaseExprNode & | Halide::Internal::IRMatcher::unwrap (const SpecificExpr &e) |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const IntLiteral &op) |
template<typename Op > | |
int64_t | Halide::Internal::IRMatcher::constant_fold_bin_op (halide_type_t &, int64_t, int64_t) noexcept |
template<typename Op > | |
uint64_t | Halide::Internal::IRMatcher::constant_fold_bin_op (halide_type_t &, uint64_t, uint64_t) noexcept |
template<typename Op > | |
double | Halide::Internal::IRMatcher::constant_fold_bin_op (halide_type_t &, double, double) noexcept |
constexpr bool | Halide::Internal::IRMatcher::commutative (IRNodeType t) |
template<typename Op > | |
uint64_t | Halide::Internal::IRMatcher::constant_fold_cmp_op (int64_t, int64_t) noexcept |
template<typename Op > | |
uint64_t | Halide::Internal::IRMatcher::constant_fold_cmp_op (uint64_t, uint64_t) noexcept |
template<typename Op > | |
uint64_t | Halide::Internal::IRMatcher::constant_fold_cmp_op (double, double) noexcept |
template<typename A , typename B > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const BinOp< Add, A, B > &op) |
template<typename A , typename B > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const BinOp< Sub, A, B > &op) |
template<typename A , typename B > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const BinOp< Mul, A, B > &op) |
template<typename A , typename B > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const BinOp< Div, A, B > &op) |
template<typename A , typename B > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const BinOp< And, A, B > &op) |
template<typename A , typename B > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const BinOp< Or, A, B > &op) |
template<typename A , typename B > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const BinOp< Min, A, B > &op) |
template<typename A , typename B > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const BinOp< Max, A, B > &op) |
template<typename A , typename B > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const CmpOp< LE, A, B > &op) |
template<typename A , typename B > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const CmpOp< LT, A, B > &op) |
template<typename A , typename B > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const CmpOp< GE, A, B > &op) |
template<typename A , typename B > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const CmpOp< GT, A, B > &op) |
template<typename A , typename B > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const CmpOp< EQ, A, B > &op) |
template<typename A , typename B > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const CmpOp< NE, A, B > &op) |
template<typename A , typename B > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const BinOp< Mod, A, B > &op) |
template<typename A , typename B > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::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 | Halide::Internal::IRMatcher::add (A &&a, B &&b) -> decltype(IRMatcher::operator+(a, b)) |
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 |
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 |
template<> | |
HALIDE_ALWAYS_INLINE double | Halide::Internal::IRMatcher::constant_fold_bin_op< Add > (halide_type_t &t, double a, double b) noexcept |
template<typename A , typename B > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::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 | Halide::Internal::IRMatcher::sub (A &&a, B &&b) -> decltype(IRMatcher::operator-(a, b)) |
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 |
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 |
template<> | |
HALIDE_ALWAYS_INLINE double | Halide::Internal::IRMatcher::constant_fold_bin_op< Sub > (halide_type_t &t, double a, double b) noexcept |
template<typename A , typename B > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::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 | Halide::Internal::IRMatcher::mul (A &&a, B &&b) -> decltype(IRMatcher::operator*(a, b)) |
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 |
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 |
template<> | |
HALIDE_ALWAYS_INLINE double | Halide::Internal::IRMatcher::constant_fold_bin_op< Mul > (halide_type_t &t, double a, double b) noexcept |
template<typename A , typename B > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::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 | Halide::Internal::IRMatcher::div (A &&a, B &&b) -> decltype(IRMatcher::operator/(a, b)) |
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 |
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 |
template<> | |
HALIDE_ALWAYS_INLINE double | Halide::Internal::IRMatcher::constant_fold_bin_op< Div > (halide_type_t &t, double a, double b) noexcept |
template<typename A , typename B > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::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 | Halide::Internal::IRMatcher::mod (A &&a, B &&b) -> decltype(IRMatcher::operator%(a, b)) |
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 |
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 |
template<> | |
HALIDE_ALWAYS_INLINE double | Halide::Internal::IRMatcher::constant_fold_bin_op< Mod > (halide_type_t &t, double a, double b) noexcept |
template<typename A , typename B > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::min (A &&a, B &&b) noexcept -> BinOp< Min, decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
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 |
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 |
template<> | |
HALIDE_ALWAYS_INLINE double | Halide::Internal::IRMatcher::constant_fold_bin_op< Min > (halide_type_t &t, double a, double b) noexcept |
template<typename A , typename B > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::max (A &&a, B &&b) noexcept -> BinOp< Max, decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
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 |
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 |
template<> | |
HALIDE_ALWAYS_INLINE double | Halide::Internal::IRMatcher::constant_fold_bin_op< Max > (halide_type_t &t, double a, double b) noexcept |
template<typename A , typename B > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::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 | Halide::Internal::IRMatcher::lt (A &&a, B &&b) -> decltype(IRMatcher::operator<(a, b)) |
template<> | |
HALIDE_ALWAYS_INLINE uint64_t | Halide::Internal::IRMatcher::constant_fold_cmp_op< LT > (int64_t a, int64_t b) noexcept |
template<> | |
HALIDE_ALWAYS_INLINE uint64_t | Halide::Internal::IRMatcher::constant_fold_cmp_op< LT > (uint64_t a, uint64_t b) noexcept |
template<> | |
HALIDE_ALWAYS_INLINE uint64_t | Halide::Internal::IRMatcher::constant_fold_cmp_op< LT > (double a, double b) noexcept |
template<typename A , typename B > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::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 | Halide::Internal::IRMatcher::gt (A &&a, B &&b) -> decltype(IRMatcher::operator>(a, b)) |
template<> | |
HALIDE_ALWAYS_INLINE uint64_t | Halide::Internal::IRMatcher::constant_fold_cmp_op< GT > (int64_t a, int64_t b) noexcept |
template<> | |
HALIDE_ALWAYS_INLINE uint64_t | Halide::Internal::IRMatcher::constant_fold_cmp_op< GT > (uint64_t a, uint64_t b) noexcept |
template<> | |
HALIDE_ALWAYS_INLINE uint64_t | Halide::Internal::IRMatcher::constant_fold_cmp_op< GT > (double a, double b) noexcept |
template<typename A , typename B > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::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 | Halide::Internal::IRMatcher::le (A &&a, B &&b) -> decltype(IRMatcher::operator<=(a, b)) |
template<> | |
HALIDE_ALWAYS_INLINE uint64_t | Halide::Internal::IRMatcher::constant_fold_cmp_op< LE > (int64_t a, int64_t b) noexcept |
template<> | |
HALIDE_ALWAYS_INLINE uint64_t | Halide::Internal::IRMatcher::constant_fold_cmp_op< LE > (uint64_t a, uint64_t b) noexcept |
template<> | |
HALIDE_ALWAYS_INLINE uint64_t | Halide::Internal::IRMatcher::constant_fold_cmp_op< LE > (double a, double b) noexcept |
template<typename A , typename B > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::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 | Halide::Internal::IRMatcher::ge (A &&a, B &&b) -> decltype(IRMatcher::operator>=(a, b)) |
template<> | |
HALIDE_ALWAYS_INLINE uint64_t | Halide::Internal::IRMatcher::constant_fold_cmp_op< GE > (int64_t a, int64_t b) noexcept |
template<> | |
HALIDE_ALWAYS_INLINE uint64_t | Halide::Internal::IRMatcher::constant_fold_cmp_op< GE > (uint64_t a, uint64_t b) noexcept |
template<> | |
HALIDE_ALWAYS_INLINE uint64_t | Halide::Internal::IRMatcher::constant_fold_cmp_op< GE > (double a, double b) noexcept |
template<typename A , typename B > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::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 | Halide::Internal::IRMatcher::eq (A &&a, B &&b) -> decltype(IRMatcher::operator==(a, b)) |
template<> | |
HALIDE_ALWAYS_INLINE uint64_t | Halide::Internal::IRMatcher::constant_fold_cmp_op< EQ > (int64_t a, int64_t b) noexcept |
template<> | |
HALIDE_ALWAYS_INLINE uint64_t | Halide::Internal::IRMatcher::constant_fold_cmp_op< EQ > (uint64_t a, uint64_t b) noexcept |
template<> | |
HALIDE_ALWAYS_INLINE uint64_t | Halide::Internal::IRMatcher::constant_fold_cmp_op< EQ > (double a, double b) noexcept |
template<typename A , typename B > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::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 | Halide::Internal::IRMatcher::ne (A &&a, B &&b) -> decltype(IRMatcher::operator!=(a, b)) |
template<> | |
HALIDE_ALWAYS_INLINE uint64_t | Halide::Internal::IRMatcher::constant_fold_cmp_op< NE > (int64_t a, int64_t b) noexcept |
template<> | |
HALIDE_ALWAYS_INLINE uint64_t | Halide::Internal::IRMatcher::constant_fold_cmp_op< NE > (uint64_t a, uint64_t b) noexcept |
template<> | |
HALIDE_ALWAYS_INLINE uint64_t | Halide::Internal::IRMatcher::constant_fold_cmp_op< NE > (double a, double b) noexcept |
template<typename A , typename B > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::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 | Halide::Internal::IRMatcher::or_op (A &&a, B &&b) -> decltype(IRMatcher::operator||(a, b)) |
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 |
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 |
template<> | |
HALIDE_ALWAYS_INLINE double | Halide::Internal::IRMatcher::constant_fold_bin_op< Or > (halide_type_t &t, double a, double b) noexcept |
template<typename A , typename B > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::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 | Halide::Internal::IRMatcher::and_op (A &&a, B &&b) -> decltype(IRMatcher::operator&&(a, b)) |
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 |
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 |
template<> | |
HALIDE_ALWAYS_INLINE double | Halide::Internal::IRMatcher::constant_fold_bin_op< And > (halide_type_t &t, double a, double b) noexcept |
constexpr uint32_t | Halide::Internal::IRMatcher::bitwise_or_reduce () |
template<typename... Args> | |
constexpr uint32_t | Halide::Internal::IRMatcher::bitwise_or_reduce (uint32_t first, Args... rest) |
constexpr bool | Halide::Internal::IRMatcher::and_reduce () |
template<typename... Args> | |
constexpr bool | Halide::Internal::IRMatcher::and_reduce (bool first, Args... rest) |
constexpr int | Halide::Internal::IRMatcher::const_min (int a, int b) |
template<typename... Args> | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const Intrin< Args... > &op) |
template<typename... Args> | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::intrin (Call::IntrinsicOp intrinsic_op, Args... args) noexcept -> Intrin< decltype(pattern_arg(args))... > |
template<typename A , typename B > | |
auto | Halide::Internal::IRMatcher::widen_right_add (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
template<typename A , typename B > | |
auto | Halide::Internal::IRMatcher::widen_right_mul (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
template<typename A , typename B > | |
auto | Halide::Internal::IRMatcher::widen_right_sub (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
template<typename A , typename B > | |
auto | Halide::Internal::IRMatcher::widening_add (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
template<typename A , typename B > | |
auto | Halide::Internal::IRMatcher::widening_sub (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
template<typename A , typename B > | |
auto | Halide::Internal::IRMatcher::widening_mul (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
template<typename A , typename B > | |
auto | Halide::Internal::IRMatcher::saturating_add (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
template<typename A , typename B > | |
auto | Halide::Internal::IRMatcher::saturating_sub (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
template<typename A > | |
auto | Halide::Internal::IRMatcher::saturating_cast (const Type &t, A &&a) noexcept -> Intrin< decltype(pattern_arg(a))> |
template<typename A , typename B > | |
auto | Halide::Internal::IRMatcher::halving_add (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
template<typename A , typename B > | |
auto | Halide::Internal::IRMatcher::halving_sub (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
template<typename A , typename B > | |
auto | Halide::Internal::IRMatcher::rounding_halving_add (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
template<typename A , typename B > | |
auto | Halide::Internal::IRMatcher::shift_left (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
template<typename A , typename B > | |
auto | Halide::Internal::IRMatcher::shift_right (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
template<typename A , typename B > | |
auto | Halide::Internal::IRMatcher::rounding_shift_left (A &&a, B &&b) noexcept -> Intrin< decltype(pattern_arg(a)), decltype(pattern_arg(b))> |
template<typename A , typename B > | |
auto | Halide::Internal::IRMatcher::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 | Halide::Internal::IRMatcher::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 | Halide::Internal::IRMatcher::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 | Halide::Internal::IRMatcher::operator! (A &&a) noexcept -> NotOp< decltype(pattern_arg(a))> |
template<typename A > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::not_op (A &&a) -> decltype(IRMatcher::operator!(a)) |
template<typename A > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const NotOp< A > &op) |
template<typename C , typename T , typename F > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const SelectOp< C, T, F > &op) |
template<typename C , typename T , typename F > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::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 & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const BroadcastOp< A, B > &op) |
template<typename A , typename B > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::broadcast (A &&a, B lanes) noexcept -> BroadcastOp< decltype(pattern_arg(a)), decltype(pattern_arg(lanes))> |
template<typename A , typename B , typename C > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const RampOp< A, B, C > &op) |
template<typename A , typename B , typename C > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::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 & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const VectorReduceOp< A, B, reduce_op > &op) |
template<typename A , typename B > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::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 | Halide::Internal::IRMatcher::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 | Halide::Internal::IRMatcher::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 | Halide::Internal::IRMatcher::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 | Halide::Internal::IRMatcher::h_or (A &&a, B lanes) noexcept -> VectorReduceOp< decltype(pattern_arg(a)), decltype(pattern_arg(lanes)), VectorReduce::Or > |
template<typename A > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const NegateOp< A > &op) |
template<typename A > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::operator- (A &&a) noexcept -> NegateOp< decltype(pattern_arg(a))> |
template<typename A > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::negate (A &&a) -> decltype(IRMatcher::operator-(a)) |
template<typename A > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const CastOp< A > &op) |
template<typename A > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::cast (halide_type_t t, A &&a) noexcept -> CastOp< decltype(pattern_arg(a))> |
template<typename A > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const WidenOp< A > &op) |
template<typename A > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::widen (A &&a) noexcept -> WidenOp< decltype(pattern_arg(a))> |
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) |
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) 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 | Halide::Internal::IRMatcher::fold (A &&a) noexcept -> Fold< decltype(pattern_arg(a))> |
template<typename A > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const Fold< A > &op) |
template<typename A > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::overflows (A &&a) noexcept -> Overflows< decltype(pattern_arg(a))> |
template<typename A > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const Overflows< A > &op) |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const Overflow &op) |
template<typename A > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::is_const (A &&a) noexcept -> IsConst< decltype(pattern_arg(a))> |
template<typename A > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::is_const (A &&a, int64_t value) noexcept -> IsConst< decltype(pattern_arg(a))> |
template<typename A > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const IsConst< A > &op) |
template<typename A , typename Prover > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::can_prove (A &&a, Prover *p) noexcept -> CanProve< decltype(pattern_arg(a)), Prover > |
template<typename A , typename Prover > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const CanProve< A, Prover > &op) |
template<typename A > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::is_float (A &&a) noexcept -> IsFloat< decltype(pattern_arg(a))> |
template<typename A > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const IsFloat< A > &op) |
template<typename A > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::is_int (A &&a, int bits=0, int lanes=0) noexcept -> IsInt< decltype(pattern_arg(a))> |
template<typename A > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const IsInt< A > &op) |
template<typename A > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::is_uint (A &&a, int bits=0, int lanes=0) noexcept -> IsUInt< decltype(pattern_arg(a))> |
template<typename A > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const IsUInt< A > &op) |
template<typename A > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::is_scalar (A &&a) noexcept -> IsScalar< decltype(pattern_arg(a))> |
template<typename A > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const IsScalar< A > &op) |
template<typename A > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::is_max_value (A &&a) noexcept -> IsMaxValue< decltype(pattern_arg(a))> |
template<typename A > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const IsMaxValue< A > &op) |
template<typename A > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::is_min_value (A &&a) noexcept -> IsMinValue< decltype(pattern_arg(a))> |
template<typename A > | |
std::ostream & | Halide::Internal::IRMatcher::operator<< (std::ostream &s, const IsMinValue< A > &op) |
template<typename A > | |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::lanes_of (A &&a) noexcept -> LanesOf< decltype(pattern_arg(a))> |
template<typename A > | |
std::ostream & | Halide::Internal::IRMatcher::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 | Halide::Internal::IRMatcher::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 | Halide::Internal::IRMatcher::fuzz_test_rule (Before &&before, After &&after, Predicate &&pred, halide_type_t, halide_type_t, int dummy=0) noexcept |
HALIDE_ALWAYS_INLINE bool | Halide::Internal::IRMatcher::evaluate_predicate (bool x, MatcherState &) noexcept |
template<typename Pattern , typename = typename enable_if_pattern<Pattern>::type> | |
HALIDE_ALWAYS_INLINE bool | Halide::Internal::IRMatcher::evaluate_predicate (Pattern p, MatcherState &state) |
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) 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 | Halide::Internal::IRMatcher::rewriter (Instance instance, halide_type_t output_type) noexcept -> Rewriter< decltype(pattern_arg(instance))> |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::rewriter (const Expr &e, halide_type_t wildcard_type) noexcept -> Rewriter< decltype(pattern_arg(e))> |
HALIDE_ALWAYS_INLINE auto | Halide::Internal::IRMatcher::rewriter (const Expr &e) noexcept -> Rewriter< decltype(pattern_arg(e))> |
Variables | |
constexpr int | Halide::Internal::IRMatcher::max_wild = 6 |
Defines a method to match a fragment of IR against a pattern containing wildcards.
Definition in file IRMatch.h.