[IR] add verify api for new ir (#54922)

paddle/ir/core/operation.cc

@@ -238,4 +238,10 @@ void Operation::ReplaceAllUsesWith(const std::vector<Value> &values) {
   }
 }
 
+void Operation::Verify() {
+  if (info_) {
+    info_.Verify(this);
+  }
+}
+
 }  // namespace ir

paddle/ir/core/operation.h

@@ -112,6 +112,8 @@ class IR_API alignas(8) Operation final {
     ReplaceAllUsesWith(std::vector<Value>{value});
   }
 
+  void Verify();
+
  private:
   Operation(const AttributeMap &attribute,
             ir::OpInfo op_info,

paddle/ir/core/verify.cc

+// Copyright (c) 2023 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "paddle/ir/core/verify.h"
+#include "paddle/ir/core/operation.h"
+namespace ir {
+void Verify(Operation *op, bool verify_recursively) {
+  op->Verify();
+  if (!verify_recursively) return;
+  for (size_t index = 0; index < op->num_regions(); ++index) {
+    auto &region = op->region(index);
+    for (auto iter = region.begin(); iter != region.end(); ++iter) {
+      auto block = *iter;
+      for (auto op_iter = block->begin(); op_iter != block->end(); ++op_iter) {
+        Verify(*op_iter, verify_recursively);
+      }
+    }
+  }
+}
+}  // namespace ir

paddle/ir/core/verify.h

+// Copyright (c) 2023 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include "paddle/ir/core/dll_decl.h"
+
+namespace ir {
+
+class Operation;
+
+/// Perform (potentially expensive) checks of invariants, used to detect
+/// compiler bugs, on this operation and any nested operations. On error, It
+/// will throw exception. `verifyRecursively` is false, this assumes that nested
+/// operations have already been properly verified, and does not recursively
+/// invoke the verifier on nested operations.
+IR_API void Verify(Operation *op, bool verifyRecursively = true);
+
+}  // namespace ir

test/cpp/ir/core/op_info_test.cc

@@ -21,6 +21,7 @@
 #include "paddle/ir/core/builtin_type.h"
 #include "paddle/ir/core/ir_context.h"
 #include "paddle/ir/core/program.h"
+#include "paddle/ir/core/verify.h"
 
 TEST(ir_op_info_test, op_op_info_test) {
   ir::IrContext* context = ir::IrContext::Instance();
@@ -41,4 +42,5 @@ TEST(ir_op_info_test, op_op_info_test) {
   void* info_1 = op->info().AsOpaquePointer();
   auto info_2 = ir::OpInfo::RecoverFromOpaquePointer(info_1);
   EXPECT_EQ(op->info(), info_2);
+  ir::Verify(program.module_op());
 }