Add symbolic expression

.clang-tidy

@@ -6,7 +6,7 @@ CheckOptions:
   - key:             bugprone-unused-return-value.AllowCastToVoid
     value:           true
   - key:             cppcoreguidelines-macro-usage.AllowedRegexp
-    value:           'DEBUG|ASSERT|ASSUME|UNREACHABLE|FALLTHROUGH|DEPRECATED|STRINGIZE|_HAS_|_THROW|_REQUIRES|_DECLARE_|_VISIT_|_REGISTER_|_GENERATE_|_DETAIL_|_TIDY_|_MANAGE_PTR|_MATCHER|DEVICE_SHARED|_WORKAROUND_|_PP_'
+    value:           'DEBUG|ASSERT|ASSUME|UNREACHABLE|FALLTHROUGH|DEPRECATED|STRINGIZE|_HAS_|_THROW|_REQUIRES|_DECLARE_|_DEFINE_|_VISIT_|_REGISTER_|_GENERATE_|_DETAIL_|_TIDY_|_MANAGE_PTR|_MATCHER|DEVICE_SHARED|_WORKAROUND_|_PP_'
   - key:             modernize-loop-convert.MinConfidence
     value:           risky   
   - key:             modernize-loop-convert.NamingStyle

src/CMakeLists.txt

@@ -137,11 +137,11 @@ add_library(migraphx
     serialize.cpp
     shape.cpp
     shape_transform_descriptor.cpp
-    sym.cpp
     simplify_algebra.cpp
     simplify_dyn_ops.cpp
     simplify_reshapes.cpp
     split_single_dyn_dim.cpp
+    sym.cpp
     target.cpp
     tmp_dir.cpp
     truncate_float.cpp

src/include/migraphx/ranges.hpp

@@ -269,6 +269,10 @@ struct iterator_range
     Iterator start;
     Iterator last;
 
+    bool empty() const { return start == last; }
+
+    std::size_t size() const { return std::distance(start, last); }
+
     Iterator begin() const { return start; }
 
     Iterator end() const { return last; }

src/include/migraphx/simple_parser.hpp

@@ -0,0 +1,229 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+#ifndef MIGRAPHX_GUARD_MIGRAPHX_SIMPLE_PARSER_HPP
+#define MIGRAPHX_GUARD_MIGRAPHX_SIMPLE_PARSER_HPP
+
+#include <migraphx/config.hpp>
+#include <migraphx/ranges.hpp>
+#include <migraphx/errors.hpp>
+#include <migraphx/stringutils.hpp>
+#include <type_traits>
+#include <vector>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+namespace parser {
+
+template <class Iterator, bool AutoSkipWhitespace = true, class View = iterator_range<Iterator>>
+struct simple_parser
+{
+    View buffer;
+    Iterator pos = buffer.begin();
+
+    static View make_view(Iterator begin, Iterator end)
+    {
+        if constexpr(std::is_constructible<View, decltype(std::addressof(*begin)), std::size_t>{})
+        {
+            auto n = std::distance(begin, end);
+            if(n == 0)
+                return {};
+            return {std::addressof(*begin), static_cast<std::size_t>(n)};
+        }
+        else
+        {
+            return {begin, end};
+        }
+    }
+
+    View peek() const
+    {
+        if(pos >= buffer.end())
+            return {};
+        return make_view(pos, buffer.end());
+    }
+
+    void advance(std::size_t n)
+    {
+        pos += n;
+        if(pos > buffer.end())
+            MIGRAPHX_THROW("Parser advanced past end of buffer");
+        if constexpr(AutoSkipWhitespace)
+        {
+            pos = std::find_if(
+                pos, buffer.end(), [](unsigned char c) { return not std::isspace(c); });
+        }
+    }
+
+    template <class Pred>
+    View parse_while(Pred p)
+    {
+        auto start = pos;
+        auto it    = std::find_if(pos, buffer.end(), [&](auto c) { return not p(c); });
+        auto n     = std::distance(pos, it);
+        advance(n);
+        return make_view(start, it);
+    }
+
+    bool starts_with(const View& prefix) const
+    {
+        auto tail = peek();
+        if(prefix.size() > tail.size())
+            return false;
+        else
+            return std::equal(prefix.begin(), prefix.end(), tail.begin());
+    }
+
+    bool done() const { return pos >= buffer.end(); }
+
+    bool match(const View& prefix)
+    {
+        if(not starts_with(prefix))
+            return false;
+        advance(prefix.size());
+        return true;
+    }
+
+    void expect(const View& str)
+    {
+        if(not starts_with(str))
+            MIGRAPHX_THROW(error_message("'" + std::string{str} + "'"));
+        advance(str.size());
+    }
+
+    char peek_char() const
+    {
+        if(done())
+            return '\0';
+        return *pos;
+    }
+
+    std::string error_message(std::string_view expected) const
+    {
+        auto offset = std::distance(buffer.begin(), pos);
+        return "Expected " + std::string(expected) + " at position " + std::to_string(offset) +
+               " in '" + std::string(buffer) + "'";
+    }
+
+    template <class F>
+    bool try_parse(F f)
+    {
+        auto copy = *this;
+        f(*this);
+        if(copy.pos != pos)
+            return true;
+        *this = copy;
+        return false;
+    }
+
+    View first_of(View view)
+    {
+        if(match(view))
+            return view;
+        return {};
+    }
+
+    template <class... Views>
+    View first_of(View view, Views... views)
+    {
+        if(match(view))
+            return view;
+        return first_of(views...);
+    }
+
+    template <class F>
+    auto first_of(F f) -> decltype(f(*this))
+    {
+        return f(*this);
+    }
+
+    template <class F, class G, class... Fs>
+    auto first_of(F f, G g, Fs... fs) -> decltype(f(*this))
+    {
+        auto copy   = *this;
+        auto result = f(*this);
+        if(copy.pos != pos)
+            return result;
+        *this = copy;
+        return first_of(g, fs...);
+    }
+
+    template <class F>
+    auto repeat(F f)
+    {
+        using result_type = decltype(f(*this));
+        std::vector<result_type> results;
+        for(;;)
+        {
+            auto copy = *this;
+            results.push_back(f(*this));
+            if(copy.pos == pos)
+            {
+                results.pop_back();
+                break;
+            }
+        }
+        return results;
+    }
+};
+
+template <class F>
+struct parser_action
+{
+    F fn;
+
+    template <class Parser>
+    auto operator()(Parser& p) const -> decltype(fn(p))
+    {
+        return fn(p);
+    }
+};
+
+template <class F>
+parser_action<std::decay_t<F>> action(F&& f)
+{
+    return {std::forward<F>(f)};
+}
+
+template <class F1, class F2>
+auto operator|(parser_action<F1> a, parser_action<F2> b)
+{
+    return action([a = std::move(a), b = std::move(b)](auto& p) -> decltype(a(p)) {
+        return p.first_of(a, b);
+    });
+}
+
+template <class F>
+auto operator*(parser_action<F> a)
+{
+    return action([a = std::move(a)](auto& p) { return p.repeat(a); });
+}
+
+using simple_string_view_skip_parser =
+    simple_parser<std::string_view::const_iterator, true, std::string_view>;
+
+} // namespace parser
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+#endif // MIGRAPHX_GUARD_MIGRAPHX_SIMPLE_PARSER_HPP