Proto data dependent symbolics

src/include/migraphx/dim_like.hpp

@@ -24,14 +24,17 @@
 #ifndef MIGRAPHX_GUARD_MIGRAPHLIB_DIM_LIKE_HPP
 #define MIGRAPHX_GUARD_MIGRAPHLIB_DIM_LIKE_HPP
 
+#include <algorithm>
 #include <cstdint>
 #include <ostream>
 #include <type_traits>
+#include <vector>
 
 #include <migraphx/config.hpp>
 #include <migraphx/picked_variant.hpp>
 #include <migraphx/requires.hpp>
 #include <migraphx/shape.hpp>
+#include <migraphx/sym.hpp>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
@@ -59,6 +62,36 @@ inline std::ostream& operator<<(std::ostream& os, const dim_like& d)
     return os;
 }
 
+// Extracts the concrete int64_t from each entry; throws (via std::get) if any
+// entry holds a symbolic dynamic_dimension.
+inline std::vector<int64_t> to_ints(const std::vector<dim_like>& dims)
+{
+    std::vector<int64_t> result(dims.size());
+    std::transform(dims.begin(), dims.end(), result.begin(), [](const dim_like& d) {
+        return std::get<int64_t>(d);
+    });
+    return result;
+}
+
+inline std::vector<sym::expr> to_sym_exprs(const std::vector<dim_like>& dims)
+{
+    std::vector<sym::expr> result(dims.size());
+    std::transform(dims.begin(), dims.end(), result.begin(), [](const dim_like& d) -> sym::expr {
+        if(std::holds_alternative<shape::dynamic_dimension>(d))
+            return std::get<shape::dynamic_dimension>(d).sym_expr;
+        return sym::lit(std::get<int64_t>(d));
+    });
+    return result;
+}
+
+// Check if any of the dim_like are a shape::dynamic_dimension.
+inline bool any_sym(const std::vector<dim_like>& dims)
+{
+    return std::any_of(dims.begin(), dims.end(), [](const dim_like& d) {
+        return std::holds_alternative<shape::dynamic_dimension>(d);
+    });
+}
+
 MIGRAPHX_EXPORT void migraphx_to_value(value& v, const dim_like& d);
 MIGRAPHX_EXPORT void migraphx_from_value(const value& v, dim_like& d);
 

src/include/migraphx/enum.hpp

@@ -26,6 +26,7 @@
 
 #include <algorithm>
 #include <array>
+#include <cstdint>
 #include <iterator>
 #include <string>
 #include <type_traits>
@@ -141,6 +142,76 @@ struct is_named_enum<T, std::void_t<decltype(migraphx_enum_entries(std::declval<
 {
 };
 
+// Detects enums declared with MIGRAPHX_BIT_FLAG_ENUM: those provide a migraphx_is_bit_flag hook and
+// therefore support the type-safe bitwise operators below.
+template <class T, class = void>
+struct is_bit_flag : std::false_type
+{
+};
+
+template <class T>
+struct is_bit_flag<T, std::void_t<decltype(migraphx_is_bit_flag(std::declval<T>()))>>
+    : std::true_type
+{
+};
+
+// Type-safe bitwise operators for enums declared with MIGRAPHX_BIT_FLAG_ENUM. They operate on the
+// enum's underlying integer and return the enum type, so combining values never leaks to a raw
+// integer and different flag enums cannot be mixed.
+template <class E, MIGRAPHX_REQUIRES(is_bit_flag<E>{})>
+constexpr E operator|(E lhs, E rhs)
+{
+    using U = std::underlying_type_t<E>;
+    return static_cast<E>(static_cast<U>(lhs) | static_cast<U>(rhs));
+}
+
+template <class E, MIGRAPHX_REQUIRES(is_bit_flag<E>{})>
+constexpr E operator&(E lhs, E rhs)
+{
+    using U = std::underlying_type_t<E>;
+    return static_cast<E>(static_cast<U>(lhs) & static_cast<U>(rhs));
+}
+
+template <class E, MIGRAPHX_REQUIRES(is_bit_flag<E>{})>
+constexpr E operator^(E lhs, E rhs)
+{
+    using U = std::underlying_type_t<E>;
+    return static_cast<E>(static_cast<U>(lhs) ^ static_cast<U>(rhs));
+}
+
+template <class E, MIGRAPHX_REQUIRES(is_bit_flag<E>{})>
+constexpr E operator~(E val)
+{
+    using U = std::underlying_type_t<E>;
+    return static_cast<E>(~static_cast<U>(val));
+}
+
+template <class E, MIGRAPHX_REQUIRES(is_bit_flag<E>{})>
+constexpr E& operator|=(E& lhs, E rhs)
+{
+    return lhs = lhs | rhs;
+}
+
+template <class E, MIGRAPHX_REQUIRES(is_bit_flag<E>{})>
+constexpr E& operator&=(E& lhs, E rhs)
+{
+    return lhs = lhs & rhs;
+}
+
+template <class E, MIGRAPHX_REQUIRES(is_bit_flag<E>{})>
+constexpr E& operator^=(E& lhs, E rhs)
+{
+    return lhs = lhs ^ rhs;
+}
+
+// Returns true when every bit set in flag is also set in val.
+template <class E, MIGRAPHX_REQUIRES(is_bit_flag<E>{})>
+constexpr bool has_flag(E val, E flag)
+{
+    using U = std::underlying_type_t<E>;
+    return (static_cast<U>(val) & static_cast<U>(flag)) == static_cast<U>(flag);
+}
+
 // Returns the array of enumerator values for an enum declared with MIGRAPHX_ENUM.
 template <class Enum, MIGRAPHX_REQUIRES(is_named_enum<Enum>{})>
 auto enum_entries()
@@ -285,4 +356,43 @@ Enum from_string(const std::string& name)
     MIGRAPHX_DETAIL_ENUM_HELPERS(             \
         friend, name, MIGRAPHX_DETAIL_ENUM_CLASS_CAPTURE, using enum_scope = name;, __VA_ARGS__)
 
+// Emits the ADL hook that marks an enum as a bit flag, which is_bit_flag detects to enable the
+// bitwise operators. `linkage` is `inline` at namespace scope or `friend` at class scope, mirroring
+// MIGRAPHX_DETAIL_ENUM_HELPERS.
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define MIGRAPHX_DETAIL_BIT_FLAG_ENUM(linkage, name) \
+    linkage constexpr bool migraphx_is_bit_flag(name) { return true; }
+
+// Declares a scoped enum (enum class) with the given underlying type and enables the type-safe
+// bitwise operators |, &, ^, ~, |=, &=, ^= and has_flag() on it. Use it at namespace scope:
+//
+//     MIGRAPHX_BIT_FLAG_ENUM(access, std::uint8_t,
+//         none  = 0,
+//         read  = 1 << 0,
+//         write = 1 << 1)
+//
+//     auto rw = access::read | access::write;
+//     if(has_flag(rw, access::read)) { /* ... */ }
+//
+// Unlike MIGRAPHX_ENUM_CLASS, no to_string/from_string helpers are generated, so enumerator values
+// should be self-contained bit masks.
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define MIGRAPHX_BIT_FLAG_ENUM(name, type, ...) \
+    enum class name : type                      \
+    {                                           \
+        __VA_ARGS__                             \
+    };                                          \
+    MIGRAPHX_DETAIL_BIT_FLAG_ENUM(inline, name)
+
+// Like MIGRAPHX_BIT_FLAG_ENUM, but for a scoped enum declared inside a class or struct; the hook is
+// generated as a hidden friend so argument-dependent lookup still finds it. Use it inside the
+// class/struct body.
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define MIGRAPHX_NESTED_BIT_FLAG_ENUM(name, type, ...) \
+    enum class name : type                             \
+    {                                                  \
+        __VA_ARGS__                                    \
+    };                                                 \
+    MIGRAPHX_DETAIL_BIT_FLAG_ENUM(friend, name)
+
 #endif // MIGRAPHX_GUARD_MIGRAPHX_ENUM_HPP