Field.h

Go to the documentation of this file.

//===-- Field.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/Util/DynamicAPIntHelper.h"
#include "llzk/Util/ErrorHelper.h"
 
#include <mlir/IR/BuiltinAttributes.h>
#include <mlir/IR/BuiltinOps.h>
#include <mlir/Support/LLVM.h>
 
#include <llvm/ADT/DenseMap.h>
#include <llvm/ADT/DynamicAPInt.h>
#include <llvm/ADT/SmallSet.h>
#include <llvm/Support/LogicalResult.h>
#include <llvm/Support/SMTAPI.h>
 
#include <functional>
#include <optional>
#include <string_view>
 
namespace llzk {

class Field {
public:
  inline static void
  addField(llvm::StringRef fieldName, const llvm::DynamicAPInt &prime, EmitErrorFn errFn) {
    return addField(Field(prime, fieldName), errFn);
  }
  static void addField(llvm::StringRef fieldName, llvm::StringRef primeStr, EmitErrorFn errFn);

  static llvm::FailureOr<std::reference_wrapper<const Field>>
  tryGetField(llvm::StringRef fieldName);

  static llvm::LogicalResult verifyFieldDefined(llvm::StringRef fieldName, EmitErrorFn errFn);

  static const Field &getField(llvm::StringRef fieldName, EmitErrorFn errFn);
  inline static const Field &getField(llvm::StringRef fieldName) {
    return getField(fieldName, nullptr);
  }
 
  Field() = delete;
  Field(const Field &) = default;
  Field(Field &&) noexcept = default;
  Field &operator=(const Field &) = default;

  llvm::DynamicAPInt prime() const { return primeMod; }

  llvm::DynamicAPInt half() const { return halfPrime; }

  inline llvm::DynamicAPInt felt(int i) const { return reduce(i); }

  inline llvm::DynamicAPInt zero() const { return felt(0); }

  inline llvm::DynamicAPInt one() const { return felt(1); }

  inline llvm::DynamicAPInt maxVal() const { return prime() - one(); }

  llvm::DynamicAPInt inv(const llvm::DynamicAPInt &i) const;

  llvm::DynamicAPInt reduce(const llvm::DynamicAPInt &i) const;
  inline llvm::DynamicAPInt reduce(int64_t i) const { return reduce(llvm::DynamicAPInt(i)); }

  llvm::DynamicAPInt toSigned(const llvm::DynamicAPInt &i) const;

  inline unsigned bitWidth() const { return bitwidth; }
 
  inline llvm::StringRef name() const { return primeName; }

  llvm::SMTExprRef createSymbol(const llvm::SMTSolverRef &solver, const char *name) const {
    return solver->mkSymbol(name, solver->getBitvectorSort(bitWidth()));
  }

  mlir::IntegerAttr getPrimeAttr(mlir::MLIRContext *context, unsigned bitWidth) const;
 
  friend bool operator==(const Field &lhs, const Field &rhs) {
    return lhs.primeMod == rhs.primeMod;
  }

  struct Hash {
    size_t operator()(const Field &field) const { return hashDynamicAPInt(field.primeMod); }
  };
 
  friend bool operator<(const Field &lhs, const Field &rhs) {
    return std::tie(lhs.primeMod, lhs.primeName, lhs.bitwidth, lhs.halfPrime) <
           std::tie(rhs.primeMod, rhs.primeName, rhs.bitwidth, rhs.halfPrime);
  }
 
private:
  Field(std::string_view primeStr, llvm::StringRef name);
  Field(const llvm::DynamicAPInt &primeInt, llvm::StringRef name);

  llvm::StringRef primeName;
  llvm::DynamicAPInt primeMod, halfPrime;
  unsigned bitwidth;

  static void initKnownFields();

  static void addField(Field &&f, EmitErrorFn errFn);
  inline static void addField(Field &&f) { addField(std::move(f), nullptr); }
};

llvm::LogicalResult addSpecifiedFields(mlir::ModuleOp modOp);

using FieldRef = std::reference_wrapper<const Field>;

using FieldSet = llvm::SmallSet<FieldRef, 2>;

mlir::LogicalResult collectFields(mlir::Operation *root, FieldSet &fields, bool silent = true);

std::optional<std::reference_wrapper<const Field>> tryDetectSpecifiedField(mlir::Operation *root);
 
} // namespace llzk