WIP: thread AnalysisManager through verifier

[ftynse]

Summary

https://discourse.llvm.org/t/connecting-op-verifiers-to-analyses/3553

[ftynse]

Rebase

mlir/include/mlir/IR/OpDefinition.h

public:
   static void populateDefaultAttrs(const RegisteredOperationName &,
                                    NamedAttrList &) {}
 
 protected:
   /// If the concrete type didn't implement a custom verifier hook, just fall
   /// back to this one which accepts everything.
   LogicalResult verify() { return success(); }
   LogicalResult verifyRegions() { return success(); }
+  LogicalResult verifyAnalyzed(AnalysisManager *analysisManager) {
+    return success();
+  }
 
-  /// Parse the custom form of an operation. Unless overridden, this method will
-  /// first try to get an operation parser from the op's dialect. Otherwise the
-  /// custom assembly form of an op is always rejected. Op implementations
-  /// should implement this to return failure. On success, they should fill in
-  /// result with the fields to use.
+  /// Unless overridden, the custom assembly form of an op is always rejected.
+  /// Op implementations should implement this to return failure.
+  /// On success, they should fill in result with the fields to use.
   static ParseResult parse(OpAsmParser &parser, OperationState &result);
 
   /// Print the operation. Unless overridden, this method will first try to get
   /// an operation printer from the dialect. Otherwise, it prints the operation
   /// in generic form.
   static void print(Operation *op, OpAsmPrinter &p, StringRef defaultDialect);
 
   /// Print an operation name, eliding the dialect prefix if necessary.
static OperationName::PrintAssemblyFn getPrintAssemblyFn() {
     };
   }
 
   /// Implementation of `PopulateDefaultAttrsFn` OperationName hook.
   static OperationName::PopulateDefaultAttrsFn getPopulateDefaultAttrsFn() {
     return ConcreteType::populateDefaultAttrs;
   }
   /// Implementation of `VerifyInvariantsFn` OperationName hook.
-  static LogicalResult verifyInvariants(Operation *op) {
+  static LogicalResult verifyInvariants(Operation *op,
+                                        AnalysisManager *analysisManager) {
     static_assert(hasNoDataMembers(),
                   "Op class shouldn't define new data members");
     return failure(
         failed(op_definition_impl::verifyTraits<Traits<ConcreteType>...>(op)) ||
-        failed(cast<ConcreteType>(op).verify()));
+        failed(cast<ConcreteType>(op).verify()) ||
+        failed(cast<ConcreteType>(op).verifyAnalyzed(analysisManager)));
   }
   static OperationName::VerifyInvariantsFn getVerifyInvariantsFn() {
-    return static_cast<LogicalResult (*)(Operation *)>(&verifyInvariants);
+    return static_cast<LogicalResult (*)(Operation *, AnalysisManager *)>(
+        &verifyInvariants);
   }
   /// Implementation of `VerifyRegionInvariantsFn` OperationName hook.
   static LogicalResult verifyRegionInvariants(Operation *op) {
     static_assert(hasNoDataMembers(),
                   "Op class shouldn't define new data members");
     return failure(
         failed(op_definition_impl::verifyRegionTraits<Traits<ConcreteType>...>(
             op)) ||

mlir/include/mlir/IR/OperationSupport.h

 #include "llvm/Support/TrailingObjects.h"
 #include <memory>
 
 namespace llvm {
 class BitVector;
 } // namespace llvm
 
 namespace mlir {
+class AnalysisManager;
 class Dialect;
 class DictionaryAttr;
 class ElementsAttr;
 class MutableOperandRangeRange;
 class NamedAttrList;
 class Operation;
 struct OperationState;
 class OpAsmParser;
public:
   using ParseAssemblyFn =
       llvm::unique_function<ParseResult(OpAsmParser &, OperationState &) const>;
   // Note: RegisteredOperationName is passed as reference here as the derived
   // class is defined below.
   using PopulateDefaultAttrsFn = llvm::unique_function<void(
       const RegisteredOperationName &, NamedAttrList &) const>;
   using PrintAssemblyFn =
       llvm::unique_function<void(Operation *, OpAsmPrinter &, StringRef) const>;
-  using VerifyInvariantsFn =
-      llvm::unique_function<LogicalResult(Operation *) const>;
+  using VerifyInvariantsFn = llvm::unique_function<LogicalResult(
+      Operation *, AnalysisManager *) const>;
   using VerifyRegionInvariantsFn =
       llvm::unique_function<LogicalResult(Operation *) const>;
 
 protected:
   /// This class represents a type erased version of an operation. It contains
   /// all of the components necessary for opaquely interacting with an
   /// operation. If the operation is not registered, some of these components
   /// may not be populated.
public:
   void printAssembly(Operation *op, OpAsmPrinter &p,
                      StringRef defaultDialect) const {
     return impl->printAssemblyFn(op, p, defaultDialect);
   }
 
   /// These hooks implement the verifiers for this operation.  It should emits
   /// an error message and returns failure if a problem is detected, or returns
   /// success if everything is ok.
-  LogicalResult verifyInvariants(Operation *op) const {
-    return impl->verifyInvariantsFn(op);
+  LogicalResult verifyInvariants(Operation *op,
+                                 AnalysisManager *analysisManager) const {
+    return impl->verifyInvariantsFn(op, analysisManager);
   }
   LogicalResult verifyRegionInvariants(Operation *op) const {
     return impl->verifyRegionInvariantsFn(op);
   }
 
   /// This hook implements a generalized folder for this operation.  Operations
   /// can implement this to provide simplifications rules that are applied by
   /// the Builder::createOrFold API and the canonicalization pass.

mlir/include/mlir/IR/Verifier.h

 //===- Verifier.h - Verifier analysis for MLIR structures -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_VERIFIER_H
 #define MLIR_IR_VERIFIER_H
 
 namespace mlir {
+class AnalysisManager;
 struct LogicalResult;
 class Operation;
 
 /// Perform (potentially expensive) checks of invariants, used to detect
 /// compiler bugs, on this operation and any nested operations. On error, this
 /// reports the error through the MLIRContext and returns failure. If
 /// `verifyRecursively` is false, this assumes that nested operations have
 /// already been properly verified, and does not recursively invoke the verifier
 /// on nested operations.
-LogicalResult verify(Operation *op, bool verifyRecursively = true);
+LogicalResult verify(Operation *op, bool verifyRecursively = true,
+                     AnalysisManager *analysisManager = nullptr);
 
 } // namespace mlir
 
 #endif

mlir/lib/IR/ExtensibleDialect.cpp

return DynamicOpDefinition::get(name, dialect, std::move(verifyFn),
                                   std::move(printFn), std::move(foldHookFn),
                                   std::move(getCanonicalizationPatternsFn),
                                   std::move(populateDefaultAttrsFn));
 }
 
 std::unique_ptr<DynamicOpDefinition> DynamicOpDefinition::get(
     StringRef name, ExtensibleDialect *dialect,
     OperationName::VerifyInvariantsFn &&verifyFn,
-    OperationName::VerifyInvariantsFn &&verifyRegionFn,
+    OperationName::VerifyRegionInvariantsFn &&verifyRegionFn,
     OperationName::ParseAssemblyFn &&parseFn,
     OperationName::PrintAssemblyFn &&printFn,
     OperationName::FoldHookFn &&foldHookFn,
     OperationName::GetCanonicalizationPatternsFn
         &&getCanonicalizationPatternsFn,
     OperationName::PopulateDefaultAttrsFn &&populateDefaultAttrsFn) {
   return std::unique_ptr<DynamicOpDefinition>(new DynamicOpDefinition(
       name, dialect, std::move(verifyFn), std::move(verifyRegionFn),

mlir/lib/IR/Verifier.cpp

 using namespace mlir;
 
 namespace {
 /// This class encapsulates all the state used to verify an operation region.
 class OperationVerifier {
 public:
   /// If `verifyRecursively` is true, then this will also recursively verify
   /// nested operations.
-  explicit OperationVerifier(bool verifyRecursively)
-      : verifyRecursively(verifyRecursively) {}
+  OperationVerifier(bool verifyRecursively, AnalysisManager *analysisManager)
+      : analysisManager(analysisManager), verifyRecursively(verifyRecursively) {
+  }
 
   /// Verify the given operation.
   LogicalResult verifyOpAndDominance(Operation &op);
 
 private:
   /// Any ops that have regions and are marked as "isolated from above" will be
   /// returned in the opsWithIsolatedRegions vector.
   LogicalResult
   verifyBlock(Block &block,
               SmallVectorImpl<Operation *> &opsWithIsolatedRegions);
 
   /// Verify the properties and dominance relationships of this operation.
   LogicalResult verifyOperation(Operation &op);
 
   /// Verify the dominance property of regions contained within the given
   /// Operation.
   LogicalResult verifyDominanceOfContainedRegions(Operation &op,
                                                   DominanceInfo &domInfo);
 
+  AnalysisManager *analysisManager;
+
   /// A flag indicating if this verifier should recursively verify nested
   /// operations.
   bool verifyRecursively;
 };
 } // namespace
 
 LogicalResult OperationVerifier::verifyOpAndDominance(Operation &op) {
   // Verify the operation first, collecting any IsolatedFromAbove operations.
for (auto attr : op.getAttrs()) {
     if (auto *dialect = attr.getNameDialect())
       if (failed(dialect->verifyOperationAttribute(&op, attr)))
         return failure();
   }
 
   // If we can get operation info for this, check the custom hook.
   OperationName opName = op.getName();
   Optional<RegisteredOperationName> registeredInfo = opName.getRegisteredInfo();
-  if (registeredInfo && failed(registeredInfo->verifyInvariants(&op)))
+  if (registeredInfo &&
+      failed(registeredInfo->verifyInvariants(&op, analysisManager)))
     return failure();
 
   SmallVector<Operation *> opsWithIsolatedRegions;
 
   if (unsigned numRegions = op.getNumRegions()) {
     auto kindInterface = dyn_cast<RegionKindInterface>(op);
 
     // Verify that all child regions are ok.
OperationVerifier::verifyDominanceOfContainedRegions(Operation &op,
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Entrypoint
 //===----------------------------------------------------------------------===//
 
-LogicalResult mlir::verify(Operation *op, bool verifyRecursively) {
-  OperationVerifier verifier(verifyRecursively);
+LogicalResult mlir::verify(Operation *op, bool verifyRecursively,
+                           AnalysisManager *analysisManager) {
+  OperationVerifier verifier(verifyRecursively, analysisManager);
   return verifier.verifyOpAndDominance(*op);
 }

mlir/lib/Pass/Pass.cpp

if (!passFailed && verifyPasses) {
     //  1) If the pass said that it preserved all analyses then it can't have
     //     permuted the IR.
     //
     // We run these checks in EXPENSIVE_CHECKS mode out of caution.
 #ifndef EXPENSIVE_CHECKS
     runVerifierNow = !pass->passState->preservedAnalyses.isAll();
 #endif
     if (runVerifierNow)
-      passFailed = failed(verify(op, runVerifierRecursively));
+      passFailed = failed(verify(op, runVerifierRecursively, &am));
   }
 
   // Instrument after the pass has run.
   if (pi) {
     if (passFailed)
       pi->runAfterPassFailed(pass, op);
     else
       pi->runAfterPass(pass, op);

mlir/test/lib/Dialect/Test/TestDialect.h

 //===- TestDialect.h - MLIR Dialect for testing -----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a fake 'test' dialect that can be used for testing things
 // that do not have a respective counterpart in the main source directories.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TESTDIALECT_H
 #define MLIR_TESTDIALECT_H
 
-#include "TestTypes.h"
 #include "TestAttributes.h"
 #include "TestInterfaces.h"
+#include "TestTypes.h"
+#include "mlir/Analysis/DataLayoutAnalysis.h"
 #include "mlir/Dialect/DLTI/DLTI.h"
 #include "mlir/Dialect/DLTI/Traits.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Traits.h"
 #include "mlir/IR/AsmState.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/DialectResourceBlobManager.h"
 #include "mlir/IR/ExtensibleDialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/RegionKindInterface.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/Interfaces/CallInterfaces.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/CopyOpInterface.h"
 #include "mlir/Interfaces/DerivedAttributeOpInterface.h"
 #include "mlir/Interfaces/InferIntRangeInterface.h"
 #include "mlir/Interfaces/InferTypeOpInterface.h"
 #include "mlir/Interfaces/LoopLikeInterface.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Interfaces/ViewLikeInterface.h"
+#include "mlir/Pass/AnalysisManager.h"
 
 namespace mlir {
 class DLTIDialect;
 class RewritePatternSet;
 } // namespace mlir
 
 //===----------------------------------------------------------------------===//
 // TestDialect

mlir/test/lib/Dialect/Test/TestDialect.cpp

 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Dynamic operations
 //===----------------------------------------------------------------------===//
 
 std::unique_ptr<DynamicOpDefinition> getDynamicGenericOp(TestDialect *dialect) {
   return DynamicOpDefinition::get(
-      "dynamic_generic", dialect, [](Operation *op) { return success(); },
+      "dynamic_generic", dialect,
+      [](Operation *op, AnalysisManager *am) { return success(); },
       [](Operation *op) { return success(); });
 }
 
 std::unique_ptr<DynamicOpDefinition>
 getDynamicOneOperandTwoResultsOp(TestDialect *dialect) {
   return DynamicOpDefinition::get(
       "dynamic_one_operand_two_results", dialect,
-      [](Operation *op) {
+      [](Operation *op, AnalysisManager *am) {
         if (op->getNumOperands() != 1) {
           op->emitOpError()
               << "expected 1 operand, but had " << op->getNumOperands();
           return failure();
         }
         if (op->getNumResults() != 2) {
           op->emitOpError()
               << "expected 2 results, but had " << op->getNumResults();
           return failure();
         }
         return success();
       },
       [](Operation *op) { return success(); });
 }
 
 std::unique_ptr<DynamicOpDefinition>
 getDynamicCustomParserPrinterOp(TestDialect *dialect) {
-  auto verifier = [](Operation *op) {
+  auto verifier = [](Operation *op, AnalysisManager *am) {
     if (op->getNumOperands() == 0 && op->getNumResults() == 0)
       return success();
     op->emitError() << "operation should have no operands and no results";
     return failure();
   };
   auto regionVerifier = [](Operation *op) { return success(); };
 
   auto parser = [](OpAsmParser &parser, OperationState &state) {

mlir/test/lib/Dialect/Test/TestOps.td

def TestLocationDstNoResOp : TEST_Op<"loc_dst_no_res"> {
   let arguments = (ins I32:$input);
   let results = (outs);
 }
 
 //===----------------------------------------------------------------------===//
 // Test Patterns
 //===----------------------------------------------------------------------===//
 
+def OpWithAMVerifier : TEST_Op<"op_with_am_verifier"> {
+  let extraClassDeclaration = [{
+    ::mlir::LogicalResult verifyAnalyzed(::mlir::AnalysisManager *am) {
+      if (am) {
+        llvm::errs() << "has analysis manager\n";
+        llvm::errs() << &am->getAnalysis<::mlir::DataLayoutAnalysis>() << "\n";
+      } else {
+        llvm::errs() << "no analysis manager\n";
+      }
+      return ::mlir::success();
+    }
+  }];
+}
+
 def OpA : TEST_Op<"op_a"> {
   let arguments = (ins I32, I32Attr:$attr);
   let results = (outs I32);
 }
 
 def OpB : TEST_Op<"op_b"> {
   let arguments = (ins I32, I32Attr:$attr);
   let results = (outs I32);

mlir/test/lib/Dialect/TestDyn/TestDynDialect.cpp

 #include "mlir/IR/ExtensibleDialect.h"
 
 using namespace mlir;
 
 namespace test {
 void registerTestDynDialect(DialectRegistry &registry) {
   registry.insertDynamic(
       "test_dyn", [](MLIRContext *ctx, DynamicDialect *testDyn) {
-        auto opVerifier = [](Operation *op) -> LogicalResult {
+        auto opVerifier = [](Operation *op,
+                             AnalysisManager *am) -> LogicalResult {
           if (op->getNumOperands() == 0 && op->getNumResults() == 1 &&
               op->getNumRegions() == 0)
             return success();
           return op->emitError(
               "expected a single result, no operands and no regions");
         };
 
         auto opRegionVerifier = [](Operation *op) { return success(); };
 
         testDyn->registerDynamicOp(DynamicOpDefinition::get(
             "one_result", testDyn, opVerifier, opRegionVerifier));
       });
 }
 } // namespace test

utils/bazel/llvm-project-overlay/mlir/test/BUILD.bazel

cc_library(
     deps = [
         ":TestAttrDefsIncGen",
         ":TestEnumDefsIncGen",
         ":TestInterfacesIncGen",
         ":TestOpsIncGen",
         ":TestTypeDefsIncGen",
         "//llvm:Support",
         "//mlir:ArithDialect",
+        "//mlir:Analysis",
         "//mlir:ControlFlowInterfaces",
         "//mlir:CopyOpInterface",
         "//mlir:DLTIDialect",
         "//mlir:DataLayoutInterfaces",
         "//mlir:DerivedAttributeOpInterface",
         "//mlir:DestinationStyleOpInterface",
         "//mlir:Dialect",
         "//mlir:DialectUtils",