【Error Message No.5】paddle/pir/include/* (#62851)

enkilee · web-flow · commit ac0a57c09f76 · 2024-03-25T14:56:20.000+08:00
* fix

* fix

* fix
diff --git a/paddle/pir/include/core/builder.h b/paddle/pir/include/core/builder.h
@@ -107,7 +107,8 @@ class Builder {
 
   /// Set the insertion point to the end of the specified block.
   void SetInsertionPointToBlockEnd(Block *block) {
-    IR_ENFORCE(block != nullptr, "argument of block is nullptr");
+    PADDLE_ENFORCE_NOT_NULL(
+        block, phi::errors::PreconditionNotMet("argument of block is nullptr"));
     set_insertion_point(block, block->end());
   }
 
diff --git a/paddle/pir/include/core/builtin_attribute_storage.h b/paddle/pir/include/core/builtin_attribute_storage.h
@@ -138,10 +138,11 @@ struct ArrayAttributeStorage : public AttributeStorage {
   bool empty() const { return size_ == 0u; }
 
   Attribute at(size_t index) const {
-    IR_ENFORCE(index < size_,
-               "The index (%d) must be less than size (%d).",
-               index,
-               size_);
+    PADDLE_ENFORCE_LT(
+        index,
+        size_,
+        phi::errors::InvalidArgument(
+            "The index (%d) must be less than size (%d).", index, size_));
     return data_[index];
   }
   Attribute operator[](size_t index) const { return data_[index]; }
diff --git a/paddle/pir/include/core/builtin_type_interfaces.h b/paddle/pir/include/core/builtin_type_interfaces.h
@@ -80,7 +80,10 @@ class IR_API ShapedTypeInterface
   /// If this is a ranked type, return the rank. Otherwise, abort.
   ///
   int64_t GetRank() const {
-    IR_ENFORCE((*this).HasRank(), "Cannot query rank of unranked shaped type.");
+    PADDLE_ENFORCE_EQ((*this).HasRank(),
+                      true,
+                      phi::errors::InvalidArgument(
+                          "Cannot query rank of unranked shaped type."));
     return (*this).GetShape().size();
   }
 
@@ -110,7 +113,10 @@ class IR_API ShapedTypeInterface
   /// unranked types.
   ///
   bool IsDynamicDim(unsigned idx) const {
-    IR_ENFORCE(idx < GetRank(), "Invalid index for shaped type.");
+    PADDLE_ENFORCE_LT(
+        idx,
+        GetRank(),
+        phi::errors::InvalidArgument("Invalid index for shaped type."));
     return ShapedTypeInterface::IsDynamic((*this).GetShape()[idx]);
   }
 
@@ -129,7 +135,10 @@ class IR_API ShapedTypeInterface
   /// for unranked types.
   ///
   int64_t GetDimSize(unsigned idx) const {
-    IR_ENFORCE(idx < GetRank(), "Invalid index for shaped type.");
+    PADDLE_ENFORCE_LT(
+        idx,
+        GetRank(),
+        phi::errors::InvalidArgument("Invalid index for shaped type."));
     return (*this).GetShape()[idx];
   }
 
diff --git a/paddle/pir/include/core/interface_support.h b/paddle/pir/include/core/interface_support.h
@@ -43,9 +43,12 @@ class ConstructInterfacesOrTraits {
     InterfaceValue val =
         InterfaceValue::Get<T, typename T::template Model<ConcreteT>>();
     auto success = interface_set.insert(std::move(val)).second;
-    IR_ENFORCE(success,
-               "Interface: id[%u] is already registered. inset failed",
-               TypeId::get<T>());
+    PADDLE_ENFORCE_EQ(
+        success,
+        true,
+        phi::errors::PreconditionNotMet(
+            "Interface: id[%u] is already registered. inset failed",
+            TypeId::get<T>()));
   }
 
   /// Placement new trait.
diff --git a/paddle/pir/include/core/ir_mapping.h b/paddle/pir/include/core/ir_mapping.h
@@ -84,8 +84,10 @@ class IrMapping {
   template <typename T>
   IrType<T> Lookup(T from) const {
     if (!from) return static_cast<IrType<T>>(nullptr);
-    IR_ENFORCE(GetMap<IrType<T>>().count(from) > 0,
-               "Not found key in IRMapping.");
+    PADDLE_ENFORCE_GT(
+        GetMap<IrType<T>>().count(from),
+        0UL,
+        phi::errors::InvalidArgument("Not found key in IRMapping."));
     return GetMap<IrType<T>>().at(from);
   }
 
diff --git a/paddle/pir/include/core/op_base.h b/paddle/pir/include/core/op_base.h
@@ -32,7 +32,9 @@ class IR_API OpBase {
   explicit OpBase(Operation *operation = nullptr) : operation_(operation) {}
 
   Operation *operation() const {
-    IR_ENFORCE(operation_, "Can't use operation() in a null op.");
+    PADDLE_ENFORCE_NOT_NULL(
+        operation_,
+        phi::errors::InvalidArgument("Can't use operation() in a null op."));
     return operation_;
   }
 
diff --git a/paddle/pir/include/dialect/shape/utils/shape_or_data_expr.h b/paddle/pir/include/dialect/shape/utils/shape_or_data_expr.h
@@ -28,18 +28,25 @@ class ShapeOrData {
       : shape_(shape), data_(data) {
     // Valid check
     if (shape.size() == 0) {
-      IR_ENFORCE(data.size() == 1,
-                 "When shape is 0-D, size of data should be 1, but got %d.",
-                 data.size());
+      PADDLE_ENFORCE_EQ(
+          data.size(),
+          1UL,
+          phi::errors::InvalidArgument(
+              "When shape is 0-D, size of data should be 1, but got %d.",
+              data.size()));
     } else if (shape.size() == 1) {
-      IR_ENFORCE(shape[0].template Has<int64_t>(),
-                 "When shape is 1-D, value of shape should be int");
-      IR_ENFORCE(
+      PADDLE_ENFORCE_EQ(shape[0].template Has<int64_t>(),
+                        true,
+                        phi::errors::InvalidArgument(
+                            "When shape is 1-D, value of shape should be int"));
+      PADDLE_ENFORCE_EQ(
           shape[0].template Get<int64_t>() == static_cast<int64_t>(data.size()),
-          "When shape is 1-D, size of data should be the same as "
-          "value[%d] of shape, but got [%d].",
-          shape[0].template Get<std::int64_t>(),
-          data.size());
+          true,
+          phi::errors::InvalidArgument(
+              "When shape is 1-D, size of data should be the same as "
+              "value[%d] of shape, but got [%d].",
+              shape[0].template Get<std::int64_t>(),
+              data.size()));
     } else {
       IR_THROW("Size of shape should be 0 or 1, but got %d", shape.size());
     }
@@ -128,26 +135,32 @@ class ShapeOrDataDimExprs : public ShapeOrDataDimExprsBase {
   }
 
   const std::vector<DimExpr>& shape() const {
-    IR_ENFORCE(
+    PADDLE_ENFORCE_EQ(
         std::holds_alternative<TensorShapeOrDataDimExprs>(*this),
-        "Shape of ShapeOrData is not a vector, check whether the value is a "
-        "tensor-list or not.");
+        true,
+        phi::errors::PreconditionNotMet("Shape of ShapeOrData is not a vector, "
+                                        "check whether the value is a "
+                                        "tensor-list or not."));
     return std::get<TensorShapeOrDataDimExprs>(*this).shape();
   }
 
   const std::optional<std::vector<DimExpr>>& data() const {
-    IR_ENFORCE(
+    PADDLE_ENFORCE_EQ(
         std::holds_alternative<TensorShapeOrDataDimExprs>(*this),
-        "Data of ShapeOrData is not a vector, check whether the value is a "
-        "tensor-list or not.");
+        true,
+        phi::errors::PreconditionNotMet(
+            "Data of ShapeOrData is not a vector, check whether the value is a "
+            "tensor-list or not."));
     return std::get<TensorShapeOrDataDimExprs>(*this).data();
   }
 
   void SetData(const std::vector<DimExpr>& data) {
-    IR_ENFORCE(
+    PADDLE_ENFORCE_EQ(
         std::holds_alternative<TensorShapeOrDataDimExprs>(*this),
-        "Data of ShapeOrData is not a vector, check whether the value is a "
-        "tensor-list or not.");
+        true,
+        phi::errors::PreconditionNotMet(
+            "Data of ShapeOrData is not a vector, check whether the value is a "
+            "tensor-list or not."));
 
     std::get<TensorShapeOrDataDimExprs>(*this).SetData(data);
   }
diff --git a/paddle/pir/include/pass/pass.h b/paddle/pir/include/pass/pass.h
@@ -91,9 +91,10 @@ class IR_API Pass {
   // Get a reference to the attributed previously set.
   template <typename AttrType>
   AttrType& Get(const std::string& attr_name) const {
-    IR_ENFORCE(attrs_.find(attr_name) != attrs_.end(),
-               "Attribute %s not registered for pass.",
-               attr_name);
+    PADDLE_ENFORCE_EQ(attrs_.find(attr_name) != attrs_.end(),
+                      true,
+                      phi::errors::InvalidArgument(
+                          "Attribute %s not registered for pass.", attr_name));
     try {
       return *std::any_cast<AttrType*>(attrs_.at(attr_name));
     } catch (std::bad_any_cast&) {
@@ -148,8 +149,10 @@ class IR_API Pass {
   // should delete the attribute.
   template <typename AttrType>
   void SetNotOwned(const std::string& attr_name, AttrType* attr) {
-    IR_ENFORCE(
-        !Has(attr_name), "Attribute %s already set in the pass.", attr_name);
+    PADDLE_ENFORCE_EQ(!Has(attr_name),
+                      true,
+                      phi::errors::InvalidArgument(
+                          "Attribute %s already set in the pass.", attr_name));
     attrs_[attr_name] = attr;
   }
 
diff --git a/paddle/pir/include/pass/pass_registry.h b/paddle/pir/include/pass/pass_registry.h
@@ -34,14 +34,18 @@ class PassRegistry {
   }
 
   void Insert(const std::string &pass_type, const PassCreator &pass_creator) {
-    IR_ENFORCE(
-        Has(pass_type) != true, "Pass %s has been registered.", pass_type);
+    PADDLE_ENFORCE_NE(Has(pass_type),
+                      true,
+                      phi::errors::InvalidArgument(
+                          "Pass %s has been registered.", pass_type));
     pass_map_.insert({pass_type, pass_creator});
   }
 
   std::unique_ptr<Pass> Get(const std::string &pass_type) const {
-    IR_ENFORCE(
-        Has(pass_type) == true, "Pass %s has not been registered.", pass_type);
+    PADDLE_ENFORCE_EQ(Has(pass_type),
+                      true,
+                      phi::errors::InvalidArgument(
+                          "Pass %s has not been registered.", pass_type));
     return pass_map_.at(pass_type)();
   }
 

Original file line number	Diff line number	Diff line change
`@@ -107,7 +107,8 @@ class Builder {`
`107`	`107`
`108`	`108`	`/// Set the insertion point to the end of the specified block.`
`109`	`109`	`void SetInsertionPointToBlockEnd(Block *block) {`
`110`		`- IR_ENFORCE(block != nullptr, "argument of block is nullptr");`
	`110`	`+ PADDLE_ENFORCE_NOT_NULL(`
	`111`	`+ block, phi::errors::PreconditionNotMet("argument of block is nullptr"));`
`111`	`112`	`set_insertion_point(block, block->end());`
`112`	`113`	`}`
`113`	`114`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,9 @@ class IR_API OpBase {`
`32`	`32`	`explicit OpBase(Operation *operation = nullptr) : operation_(operation) {}`
`33`	`33`
`34`	`34`	`Operation *operation() const {`
`35`		`- IR_ENFORCE(operation_, "Can't use operation() in a null op.");`
	`35`	`+ PADDLE_ENFORCE_NOT_NULL(`
	`36`	`+ operation_,`
	`37`	`+ phi::errors::InvalidArgument("Can't use operation() in a null op."));`
`36`	`38`	`return operation_;`
`37`	`39`	`}`
`38`	`40`