Matchers.h

Go to the documentation of this file.

//===-- Matchers.h ----------------------------------------------*- C++ -*-===//
//
// Part of the LLZK Project, under the Apache License v2.0.
// See LICENSE.txt for license information.
// Copyright 2025 Veridise Inc.
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
 
#pragma once
 
#include "llzk/Dialect/Felt/IR/Ops.h"
#include "llzk/Dialect/Struct/IR/Ops.h"
 
#include <mlir/IR/Matchers.h>
#include <mlir/IR/Operation.h>
#include <mlir/IR/Value.h>
 
namespace llzk {

template <typename LhsMatcher, typename RhsMatcher, typename... OpTypes> struct CommutativeMatcher {
 
  CommutativeMatcher(LhsMatcher lhs, RhsMatcher rhs) : lhsMatcher(lhs), rhsMatcher(rhs) {}
 
  bool match(mlir::Operation *op) {
    using namespace mlir::detail;
    if (!isa<OpTypes...>(op) || op->getNumOperands() != 2) {
      return false;
    }
    bool res = matchOperandOrValueAtIndex(op, 0, lhsMatcher) &&
               matchOperandOrValueAtIndex(op, 1, rhsMatcher);
    if (!res) {
      res = matchOperandOrValueAtIndex(op, 1, lhsMatcher) &&
            matchOperandOrValueAtIndex(op, 0, rhsMatcher);
    }
    return res;
  }
 
  LhsMatcher lhsMatcher;
  RhsMatcher rhsMatcher;
};
 
template <typename OpType, typename LhsMatcher, typename RhsMatcher>
auto m_CommutativeOp(LhsMatcher lhs, RhsMatcher rhs) {
  return CommutativeMatcher<LhsMatcher, RhsMatcher, OpType>(lhs, rhs);
}

struct RefValueCapture {
  mlir::Value *what;
  RefValueCapture(mlir::Value *capture) : what(capture) {}
 
  bool match(mlir::Value v) {
    if (isa<mlir::BlockArgument>(v) ||
        isa_and_present<component::MemberReadOp>(v.getDefiningOp())) {
      if (what) {
        *what = v;
      }
      return true;
    }
    return false;
  }
};
 
inline RefValueCapture m_RefValue() { return RefValueCapture(nullptr); }
 
inline RefValueCapture m_RefValue(mlir::Value *capture) { return RefValueCapture(capture); }

struct ConstantCapture {
  felt::FeltConstantOp *what;
  ConstantCapture(felt::FeltConstantOp *capture) : what(capture) {}
 
  bool match(mlir::Value v) {
    if (auto match = dyn_cast_if_present<felt::FeltConstantOp>(v.getDefiningOp())) {
      if (what) {
        *what = match;
      }
      return true;
    }
    return false;
  }
};
 
inline ConstantCapture m_Constant() { return ConstantCapture(nullptr); }
 
inline ConstantCapture m_Constant(felt::FeltConstantOp *capture) {
  return ConstantCapture(capture);
}
 
} // namespace llzk