【pir】add ir name for save (#62977)

xiaoguoguo626807 · web-flow · commit b28cbe8d5265 · 2024-03-25T19:16:17.000+08:00
* modify if nest pop_to_push_map

* modify paddledectation

* modify utf-8 bug

* modify IR
diff --git a/paddle/pir/include/core/block.h b/paddle/pir/include/core/block.h
@@ -61,6 +61,7 @@ class IR_API Block {
   ConstReverseIterator rend() const { return ops_.rend(); }
   ReverseIterator rbegin() { return ops_.rbegin(); }
   ReverseIterator rend() { return ops_.rend(); }
+  const OpListType &ops() const { return ops_; }
 
   Operation &back() { return *ops_.back(); }
   Operation &front() { return *ops_.front(); }
diff --git a/paddle/pir/include/core/builtin_attribute.h b/paddle/pir/include/core/builtin_attribute.h
@@ -26,6 +26,7 @@ class IR_API BoolAttribute : public Attribute {
 
   DECLARE_ATTRIBUTE_UTILITY_FUNCTOR(BoolAttribute, BoolAttributeStorage);
 
+  static std::string name() { return "a_bool"; }
   bool data() const;
 };
 
@@ -36,6 +37,7 @@ class IR_API Complex64Attribute : public Attribute {
   DECLARE_ATTRIBUTE_UTILITY_FUNCTOR(Complex64Attribute,
                                     Complex64AttributeStorage);
 
+  static std::string name() { return "a_c64"; }
   phi::dtype::complex<float> data() const;
 };
 
@@ -46,6 +48,7 @@ class IR_API Complex128Attribute : public Attribute {
   DECLARE_ATTRIBUTE_UTILITY_FUNCTOR(Complex128Attribute,
                                     Complex128AttributeStorage);
 
+  static std::string name() { return "a_c128"; }
   phi::dtype::complex<double> data() const;
 };
 
@@ -55,6 +58,7 @@ class IR_API FloatAttribute : public Attribute {
 
   DECLARE_ATTRIBUTE_UTILITY_FUNCTOR(FloatAttribute, FloatAttributeStorage);
 
+  static std::string name() { return "a_f32"; }
   float data() const;
 };
 
@@ -64,6 +68,7 @@ class IR_API DoubleAttribute : public Attribute {
 
   DECLARE_ATTRIBUTE_UTILITY_FUNCTOR(DoubleAttribute, DoubleAttributeStorage);
 
+  static std::string name() { return "a_f64"; }
   double data() const;
 };
 
@@ -73,6 +78,7 @@ class IR_API Int32Attribute : public Attribute {
 
   DECLARE_ATTRIBUTE_UTILITY_FUNCTOR(Int32Attribute, Int32AttributeStorage);
 
+  static std::string name() { return "a_i32"; }
   int32_t data() const;
 };
 
@@ -82,6 +88,7 @@ class IR_API IndexAttribute : public Attribute {
 
   DECLARE_ATTRIBUTE_UTILITY_FUNCTOR(IndexAttribute, IndexAttributeStorage);
 
+  static std::string name() { return "a_index"; }
   int64_t data() const;
 };
 
@@ -91,6 +98,7 @@ class IR_API Int64Attribute : public Attribute {
 
   DECLARE_ATTRIBUTE_UTILITY_FUNCTOR(Int64Attribute, Int64AttributeStorage);
 
+  static std::string name() { return "a_i64"; }
   int64_t data() const;
 };
 
@@ -100,6 +108,7 @@ class IR_API PointerAttribute : public Attribute {
 
   DECLARE_ATTRIBUTE_UTILITY_FUNCTOR(PointerAttribute, PointerAttributeStorage);
 
+  static std::string name() { return "a_pointer"; }
   void* data() const;
 };
 
@@ -109,6 +118,7 @@ class IR_API TypeAttribute : public Attribute {
 
   DECLARE_ATTRIBUTE_UTILITY_FUNCTOR(TypeAttribute, TypeAttributeStorage);
 
+  static std::string name() { return "a_type"; }
   Type data() const;
 };
 
@@ -122,6 +132,7 @@ class IR_API StrAttribute : public Attribute {
 
   std::string AsString() const;
 
+  static std::string name() { return "a_str"; }
   size_t size() const;
 
   static StrAttribute get(IrContext* ctx, const std::string& value);
@@ -134,6 +145,7 @@ class IR_API ArrayAttribute : public Attribute {
   DECLARE_ATTRIBUTE_UTILITY_FUNCTOR(ArrayAttribute, ArrayAttributeStorage);
 
   std::vector<Attribute> AsVector() const;
+  static std::string name() { return "a_array"; }
 
   size_t size() const;
 
@@ -156,7 +168,7 @@ class IR_API TensorNameAttribute : public Attribute {
   DECLARE_ATTRIBUTE_UTILITY_FUNCTOR(TensorNameAttribute, StrAttributeStorage);
 
   bool operator<(const TensorNameAttribute& right) const;
-
+  static std::string name() { return "a_tensorname"; }
   std::string data() const;
 
   size_t size() const;
diff --git a/paddle/pir/include/core/builtin_type.h b/paddle/pir/include/core/builtin_type.h
@@ -44,6 +44,7 @@ class IR_API VectorType
   using Base::Base;
 
   std::vector<Type> data() const;
+  static std::string name() { return "t_vec"; }
 
   size_t size() const { return data().size(); }
 
@@ -66,7 +67,7 @@ class IR_API DenseTensorType : public Type::TypeBase<DenseTensorType,
   DataLayout data_layout() const;
   const LoD &lod() const;
   size_t offset() const;
-
+  static std::string name() { return "t_dtensor"; }
   ///
   /// \brief Implementation of 'classof' that compares the type id of
   /// the provided value with the concrete type id.
@@ -85,28 +86,28 @@ class IR_API DenseTensorType : public Type::TypeBase<DenseTensorType,
   }
 };
 
-#define DECLARE_BUILTIN_TYPE(__name)                                       \
+#define DECLARE_BUILTIN_TYPE(__name, s_name)                               \
   class IR_API __name : public Type::TypeBase<__name, Type, TypeStorage> { \
    public:                                                                 \
     using Base::Base;                                                      \
     static __name get(IrContext *context);                                 \
+    static std::string name() { return s_name; }                           \
   };
 
 #define FOREACH_BUILTIN_TYPE(__macro) \
-  __macro(BFloat16Type);              \
-  __macro(Float16Type);               \
-  __macro(Float32Type);               \
-  __macro(Float64Type);               \
-  __macro(Int8Type);                  \
-  __macro(UInt8Type);                 \
-  __macro(Int16Type);                 \
-  __macro(Int32Type);                 \
-  __macro(Int64Type);                 \
-  __macro(IndexType);                 \
-  __macro(BoolType);                  \
-  __macro(Complex64Type);             \
-  __macro(Complex128Type);
-
+  __macro(BFloat16Type, "t_bf16");    \
+  __macro(Float16Type, "t_f16");      \
+  __macro(Float32Type, "t_f32");      \
+  __macro(Float64Type, "t_f64");      \
+  __macro(Int8Type, "t_i8");          \
+  __macro(UInt8Type, "t_ui8");        \
+  __macro(Int16Type, "t_i16");        \
+  __macro(Int32Type, "t_i32");        \
+  __macro(Int64Type, "t_i64");        \
+  __macro(IndexType, "t_index");      \
+  __macro(BoolType, "t_bool");        \
+  __macro(Complex64Type, "t_c64");    \
+  __macro(Complex128Type, "t_c128");
 FOREACH_BUILTIN_TYPE(DECLARE_BUILTIN_TYPE)
 
 #undef FOREACH_BUILTIN_TYPE
diff --git a/paddle/pir/include/core/operation.h b/paddle/pir/include/core/operation.h
@@ -133,7 +133,7 @@ class IR_API alignas(8) Operation final
   ///
   uint32_t num_operands() const { return num_operands_; }
   OpOperand operand(uint32_t index) const { return op_operand_impl(index); }
-  std::vector<OpOperand> operands();
+  std::vector<OpOperand> operands() const;
   Value operand_source(uint32_t index) const;
   std::vector<Value> operands_source() const;
   Type operand_type(uint32_t index) const { return operand(index).type(); }
diff --git a/paddle/pir/include/core/region.h b/paddle/pir/include/core/region.h
@@ -53,12 +53,12 @@ class IR_API Region {
   ReverseIterator rend() { return blocks_.rend(); }
   ConstReverseIterator rbegin() const { return blocks_.rbegin(); }
   ConstReverseIterator rend() const { return blocks_.rend(); }
+  const std::list<Block *> &blocks() const { return blocks_; }
 
   Block &front() { return *blocks_.front(); }
   Block &back() { return *blocks_.back(); }
   const Block &front() const { return *blocks_.front(); }
   const Block &back() const { return *blocks_.back(); }
-
   void push_back(Block *block);
   Block &emplace_back();
   void push_front(Block *block);
diff --git a/paddle/pir/src/core/operation.cc b/paddle/pir/src/core/operation.cc
@@ -264,7 +264,7 @@ std::vector<Value> Operation::results() const {
 ///
 /// \brief op input related public interfaces
 ///
-std::vector<OpOperand> Operation::operands() {
+std::vector<OpOperand> Operation::operands() const {
   std::vector<OpOperand> res;
   for (uint32_t i = 0; i < num_operands(); ++i) {
     res.push_back(operand(i));
