PaddlePaddle
diff --git a/‎paddle/cinn/hlir/dialect/operator/ir/manual_op.cc
Copy file name to clipboard
+6-2Lines changed: 6 additions & 2 deletions b/‎paddle/cinn/hlir/dialect/operator/ir/manual_op.cc
Copy file name to clipboard
+6-2Lines changed: 6 additions & 2 deletions
diff --git a/‎paddle/cinn/hlir/dialect/runtime/ir/jit_kernel_op.cc
Copy file name to clipboard
+5-5Lines changed: 5 additions & 5 deletions b/‎paddle/cinn/hlir/dialect/runtime/ir/jit_kernel_op.cc
Copy file name to clipboard
+5-5Lines changed: 5 additions & 5 deletions
diff --git a/‎paddle/common/array.h
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎paddle/common/array.h
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎paddle/common/ddim.cc
Copy file name to clipboard
+14-13Lines changed: 14 additions & 13 deletions b/‎paddle/common/ddim.cc
Copy file name to clipboard
+14-13Lines changed: 14 additions & 13 deletions
diff --git a/‎paddle/common/enforce.cc
Copy file name to clipboard
+15-2Lines changed: 15 additions & 2 deletions b/‎paddle/common/enforce.cc
Copy file name to clipboard
+15-2Lines changed: 15 additions & 2 deletions
@@ -62,7 +62,8 @@ void GroupOp::Build(pir::Builder& builder,             // NOLINT
                     std::unique_ptr<pir::Block>&& block) {
   VLOG(4) << "Start build GroupOp";
   if (block && !block->empty()) {
-    IR_ENFORCE(block->back().isa<pir::YieldOp>());
+    // IR_ENFORCE(block->back().isa<pir::YieldOp>());
+    PADDLE_ENFORCE_EQ(block->back().isa<pir::YieldOp>(), true);
     auto& op = block->back();
     for (size_t i = 0; i < op.num_operands(); ++i) {
       argument.AddOutput(op.operand(i).type());
@@ -169,7 +170,10 @@ void ConcatOp::Build(pir::Builder& builder,             // NOLINT
   argument.inputs = inputs;
   std::vector<pir::Type> inputs_type(inputs.size());
 
-  IR_ENFORCE(inputs.size() > 0);
+  PADDLE_ENFORCE_GT(inputs.size(),
+                    0,
+                    phi::errors::InvalidArgument(
+                        "input size [%d] is less than 0", inputs.size()));
 
   auto first_ele =
       inputs[0].type().dyn_cast<paddle::dialect::DenseTensorType>();
 
@@ -45,11 +45,11 @@ void JitKernelOp::VerifySig() {
   VLOG(4) << "Verifying inputs, outputs and attributes for: JitKernelOp.";
 
   auto& attributes = this->attributes();
-
-  IR_ENFORCE(attributes.count(kAttrName) > 0 &&
-                 attributes.at(kAttrName)
-                     .isa<cinn::dialect::CINNKernelInfoAttribute>(),
-             "Type of attribute: instruction is not right.");
+  PADDLE_ENFORCE_EQ(attributes.count(kAttrName) > 0 &&
+                        attributes.at(kAttrName)
+                            .isa<cinn::dialect::CINNKernelInfoAttribute>(),
+                    true,
+                    "Type of attribute: instruction is not right.");
 }
 
 const hlir::framework::pir::CINNKernelInfo& JitKernelOp::cinn_kernel_info() {
 
@@ -55,15 +55,15 @@ class Array {
 
   HOSTDEVICE inline T &at(size_t i) {
 #if !defined(__CUDA_ARCH__) && !defined(__HIPCC__)
-    COMMON_ENFORCE_LT(
+    PADDLE_ENFORCE_LT(
         i, N, common::errors::OutOfRange("Array index out of bounds."));
 #endif
     return (*this)[i];
   }
 
   HOSTDEVICE inline const T &at(size_t i) const {
 #if !defined(__CUDA_ARCH__) && !defined(__HIPCC__)
-    COMMON_ENFORCE_LT(
+    PADDLE_ENFORCE_LT(
         i, N, common::errors::OutOfRange("Array index out of bounds."));
 #endif
     return (*this)[i];
 
@@ -34,14 +34,14 @@ DDim::DDim(std::initializer_list<int64_t> init_list)
     : DDim(init_list.begin(), init_list.size()) {}
 
 int64_t& DDim::at(int idx) {
-  COMMON_ENFORCE_GE(idx,
+  PADDLE_ENFORCE_GE(idx,
                     0,
                     common::errors::InvalidArgument(
                         "Invalid DDim index to be accessed. The valid index "
                         "is between 0 and %d, but received index is %d.",
                         rank_,
                         idx));
-  COMMON_ENFORCE_LT(idx,
+  PADDLE_ENFORCE_LT(idx,
                     rank_,
                     common::errors::InvalidArgument(
                         "Invalid DDim index to be accessed. The valid index "
@@ -52,14 +52,14 @@ int64_t& DDim::at(int idx) {
 }
 
 int64_t DDim::at(int idx) const {
-  COMMON_ENFORCE_GE(idx,
+  PADDLE_ENFORCE_GE(idx,
                     0,
                     common::errors::InvalidArgument(
                         "Invalid DDim index to be accessed. The valid index "
                         "is between 0 and %d, but received index is %d.",
                         rank_,
                         idx));
-  COMMON_ENFORCE_LT(idx,
+  PADDLE_ENFORCE_LT(idx,
                     rank_,
                     common::errors::InvalidArgument(
                         "Invalid DDim index to be accessed. The valid index "
@@ -140,7 +140,7 @@ bool contain_unknown_dim(const DDim& ddim) {
 }
 
 DDim slice_ddim(const DDim& dim, int begin, int end) {
-  COMMON_ENFORCE_EQ(
+  PADDLE_ENFORCE_EQ(
       (begin >= 0 && end <= dim.size()),
       true,
       common::errors::InvalidArgument(
@@ -173,27 +173,27 @@ std::ostream& operator<<(std::ostream& os, const DDim& ddim) {
 }
 
 DDim flatten_to_3d(const DDim& src, int num_row_dims, int num_col_dims) {
-  COMMON_ENFORCE_GE(src.size(),
+  PADDLE_ENFORCE_GE(src.size(),
                     3,
                     common::errors::InvalidArgument(
                         "The rank of src dim should be at least 3 "
                         "in flatten_to_3d, but received %d.",
                         src.size()));
-  COMMON_ENFORCE_EQ((num_row_dims >= 1 && num_row_dims < src.size()),
+  PADDLE_ENFORCE_EQ((num_row_dims >= 1 && num_row_dims < src.size()),
                     true,
                     common::errors::InvalidArgument(
                         "The num_row_dims should be inside [1, %d] "
                         "in flatten_to_3d, but received %d.",
                         src.size() - 1,
                         num_row_dims));
-  COMMON_ENFORCE_EQ((num_col_dims >= 2 && num_col_dims <= src.size()),
+  PADDLE_ENFORCE_EQ((num_col_dims >= 2 && num_col_dims <= src.size()),
                     true,
                     common::errors::InvalidArgument(
                         "The num_col_dims should be inside [2, %d] "
                         "in flatten_to_3d, but received %d.",
                         src.size(),
                         num_col_dims));
-  COMMON_ENFORCE_GE(
+  PADDLE_ENFORCE_GE(
       num_col_dims,
       num_row_dims,
       common::errors::InvalidArgument(
@@ -266,10 +266,11 @@ DDim DDim::transpose(const std::vector<int>& axis) const {
 }
 
 DDim ComputeCompatibleDim(const DDim& dim1, const DDim& dim2) {
-  IR_ENFORCE(dim1.size() == dim2.size(),
-             "Does not support rank inconsistency: rank1=%d, rank2=%d",
-             dim1.size(),
-             dim2.size());
+  PADDLE_ENFORCE_EQ(dim1.size() == dim2.size(),
+                    true,
+                    "Does not support rank inconsistency: rank1=%d, rank2=%d",
+                    dim1.size(),
+                    dim2.size());
   std::vector<int64_t> result;
   for (int i = 0; i < dim1.size(); ++i) {
     if (dim1[i] != dim2[i]) {
 
@@ -13,14 +13,14 @@ See the License for the specific language governing permissions and
 limitations under the License. */
 
 #include "paddle/common/enforce.h"
-
 #include <array>
 #include <map>
 #include <string>
 #include <vector>
+#include "paddle/common/flags.h"
 
 REGISTER_LOG_SIMPLY_STR(std::string);
-
+COMMON_DECLARE_int32(call_stack_level);
 namespace {
 class StrSizeCmp {
  public:
@@ -52,7 +52,20 @@ std::string SimplifyDemangleStr(std::string str) {
 
 namespace common {
 namespace enforce {
+TEST_API int GetCallStackLevel() { return FLAGS_call_stack_level; }
 
+TEST_API std::string SimplifyErrorTypeFormat(const std::string& str) {
+  std::ostringstream sout;
+  size_t type_end_pos = str.find(':', 0);
+  if (type_end_pos == std::string::npos) {
+    sout << str;
+  } else {
+    // Remove "Error:", add "()""
+    sout << "(" << str.substr(0, type_end_pos - 5) << ")"
+         << str.substr(type_end_pos + 1);
+  }
+  return sout.str();
+}
 bool RegisterLogSimplyStr(const std::string& type_name,
                           const std::string& simply_name) {
   return GetLogStrSimplyMap()