IntervalAnalysisPass.cpp

Go to the documentation of this file.

//===-- IntervalAnalysisPass.cpp --------------------------------*- 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
//
//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//
 
#include "llzk/Analysis/AnalysisPasses.h"
#include "llzk/Analysis/IntervalAnalysis.h"
#include "llzk/Dialect/Bool/IR/Ops.h"
#include "llzk/Util/Constants.h"
#include "llzk/Util/SymbolHelper.h"
 
#include <llvm/ADT/STLExtras.h>
#include <llvm/ADT/SmallVector.h>
#include <llvm/Support/Debug.h>
#include <llvm/Support/ErrorHandling.h>
 
namespace llzk {
 
#define DEBUG_TYPE "llzk-interval-analysis-pass"
 
#define GEN_PASS_DECL_INTERVALANALYSISPRINTERPASS
#define GEN_PASS_DEF_INTERVALANALYSISPRINTERPASS
#include "llzk/Analysis/AnalysisPasses.h.inc"
 
using namespace component;
 
class IntervalAnalysisPrinterPass
    : public impl::IntervalAnalysisPrinterPassBase<IntervalAnalysisPrinterPass> {
  llvm::raw_ostream &os;
 
public:
  explicit IntervalAnalysisPrinterPass(llvm::raw_ostream &ostream)
      : impl::IntervalAnalysisPrinterPassBase<IntervalAnalysisPrinterPass>(), os(ostream) {}
 
protected:
  void runOnOperation() override {
    markAllAnalysesPreserved();
 
    // Suppress false positive from `clang-tidy`
    // NOLINTNEXTLINE(clang-analyzer-core.NonNullParamChecker)
    auto modOp = llvm::dyn_cast<mlir::ModuleOp>(getOperation());
    if (!modOp) {
      constexpr const char *msg = "IntervalAnalysisPrinterPass error: should be run on ModuleOp!";
      getOperation()->emitError(msg).report();
      return;
    }
 
    // Initialize to the fallback field value
    FieldRef selectedField = Field::getField("bn128");
    if (!fieldName.empty()) {
      auto fieldLookupRes = Field::tryGetField(fieldName.c_str());
      if (mlir::failed(fieldLookupRes)) {
        modOp->emitError()
            .append(
                "IntervalAnalysisPrinterPass error: unknown field \"", fieldName, "\" specified"
            )
            .report();
        return;
      }
      selectedField = fieldLookupRes.value();
      LLVM_DEBUG(
          llvm::dbgs() << "[IntervalAnalysisPrinterPass] using explicit -field override '"
                       << selectedField.get().name() << "'\n";
      );
    } else if (auto detectedField = tryDetectSpecifiedField(modOp)) {
      selectedField = detectedField.value();
      LLVM_DEBUG(
          llvm::dbgs() << "[IntervalAnalysisPrinterPass] detected module field '"
                       << selectedField.get().name() << "' from module felt usage\n";
      );
    } else {
      modOp->emitWarning() << "could not detect a unique module field; falling back to '"
                           << selectedField.get().name() << "'";
      LLVM_DEBUG(
          llvm::dbgs() << "[IntervalAnalysisPrinterPass] no explicit or detectable module field; "
                          "falling back to '"
                       << selectedField.get().name() << "'\n";
      );
    }
 
    auto &mia = getAnalysis<ModuleIntervalAnalysis>();
    mia.setField(selectedField);
    mia.setPropagateInputConstraints(propagateInputConstraints);
    auto am = getAnalysisManager();
    mia.ensureAnalysisRun(am);
 
    for (const auto &[s, si] : mia.getCurrentResults()) {
      auto &structDef = const_cast<StructDefOp &>(s);
      auto fullName = getPathFromTopRoot(structDef);
      ensure(
          mlir::succeeded(fullName),
          "could not resolve fully qualified name of struct " + mlir::Twine(structDef.getName())
      );
      os << fullName.value() << ' ';
      si.get().print(os, printSolverConstraints, printComputeIntervals);
    }
  }
};
 
std::unique_ptr<mlir::Pass>
createIntervalAnalysisPrinterPass(llvm::raw_ostream &os = llvm::errs()) {
  return std::make_unique<IntervalAnalysisPrinterPass>(os);
}
 
} // namespace llzk