[flang][fir] Add OpaqueAttr.

[schweitz]

Summary

Add the opaque attribute class used in flang.

https://github.com/flang-compiler/f18-llvm-project/pull/402

[mehdi_amini]

flang/include/flang/Optimizer/Dialect/FIRAttr.h

139

It seems critical to me that these are documented as only appropriate for non-semantic bearing content (debug help?) to preserve round-tripping of the IR and reproducibility. The use of such attribute should be exceptional I think.

Another aspect to document very clearly is that the pointer used to create such attribute must outlive any IR that would refer to this attribute.

[kiranchandramohan]

LGTM. Please consider Mehdi's comments before submitting.

[schweitz]

flang/include/flang/Optimizer/Dialect/FIRAttr.h

139

Will do.

flang/include/flang/Optimizer/Dialect/FIRAttr.h

 class DialectAsmPrinter;
 } // namespace mlir
 
 namespace fir {
 
 class FIROpsDialect;
 
 namespace detail {
+struct OpaqueAttributeStorage;
 struct RealAttributeStorage;
 struct TypeAttributeStorage;
 } // namespace detail
 
+using KindTy = unsigned;
+
 class ExactTypeAttr
     : public mlir::Attribute::AttrBase<ExactTypeAttr, mlir::Attribute,
                                        detail::TypeAttributeStorage> {
 public:
   using Base::Base;
   using ValueType = mlir::Type;
 
   static constexpr llvm::StringRef getAttrName() { return "instance"; }
: public mlir::Attribute::AttrBase<RealAttr, mlir::Attribute,
                                        detail::RealAttributeStorage> {
 public:
   using Base::Base;
   using ValueType = std::pair<int, llvm::APFloat>;
 
   static constexpr llvm::StringRef getAttrName() { return "real"; }
   static RealAttr get(mlir::MLIRContext *ctxt, const ValueType &key);
 
-  int getFKind() const;
+  KindTy getFKind() const;
   llvm::APFloat getValue() const;
 };
 
+/// An opaque attribute is used to provide dictionary lookups of pointers. The
+/// underlying type of the pointee object is left up to the client. Opaque
+/// attributes are always constructed as null pointers when parsing. Clearly,
+/// opaque attributes come with restrictions and must be used with care.
+/// 1. An opaque attribute should not refer to information of semantic
+/// significance, since the pointed-to object will not be a part of
+/// round-tripping the IR.
+/// 2. The lifetime of the pointed-to object must outlive any possible uses
+/// via the opaque attribute.
+class OpaqueAttr
+    : public mlir::Attribute::AttrBase<OpaqueAttr, mlir::Attribute,
+                                       detail::OpaqueAttributeStorage> {
+public:
+  using Base::Base;
+
+  static constexpr llvm::StringRef getAttrName() { return "opaque"; }
+  static OpaqueAttr get(mlir::MLIRContext *ctxt, void *pointer);
+
+  void *getPointer() const;
+};
+
 mlir::Attribute parseFirAttribute(FIROpsDialect *dialect,
                                   mlir::DialectAsmParser &parser,
                                   mlir::Type type);
 
 void printFirAttribute(FIROpsDialect *dialect, mlir::Attribute attr,
                        mlir::DialectAsmPrinter &p);
 
 } // namespace fir
 
 #endif // OPTIMIZER_DIALECT_FIRATTR_H

flang/lib/Optimizer/Dialect/FIRAttr.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Optimizer/Dialect/FIRAttr.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Support/KindMapping.h"
 #include "mlir/IR/AttributeSupport.h"
 #include "mlir/IR/DialectImplementation.h"
-#include "mlir/IR/Types.h"
+#include "mlir/IR/BuiltinTypes.h"
 #include "llvm/ADT/SmallString.h"
 
 using namespace fir;
 
-namespace fir {
-namespace detail {
+namespace fir::detail {
 
 struct RealAttributeStorage : public mlir::AttributeStorage {
   using KeyTy = std::pair<int, llvm::APFloat>;
 
   RealAttributeStorage(int kind, const llvm::APFloat &value)
       : kind(kind), value(value) {}
   RealAttributeStorage(const KeyTy &key)
       : RealAttributeStorage(key.first, key.second) {}
 
   static unsigned hashKey(const KeyTy &key) { return llvm::hash_value(key); }
 
   bool operator==(const KeyTy &key) const {
     return key.first == kind &&
            key.second.compare(value) == llvm::APFloatBase::cmpEqual;
   }
 
   static RealAttributeStorage *
   construct(mlir::AttributeStorageAllocator &allocator, const KeyTy &key) {
     return new (allocator.allocate<RealAttributeStorage>())
         RealAttributeStorage(key);
   }
 
-  int getFKind() const { return kind; }
+  KindTy getFKind() const { return kind; }
   llvm::APFloat getValue() const { return value; }
 
 private:
   int kind;
   llvm::APFloat value;
 };
 
 /// An attribute representing a reference to a type.
return new (allocator.allocate<TypeAttributeStorage>())
         TypeAttributeStorage(key);
   }
 
   mlir::Type getType() const { return value; }
 
 private:
   mlir::Type value;
 };
-} // namespace detail
 
-ExactTypeAttr ExactTypeAttr::get(mlir::Type value) {
+/// An attribute representing a raw pointer.
+struct OpaqueAttributeStorage : public mlir::AttributeStorage {
+  using KeyTy = void *;
+
+  OpaqueAttributeStorage(void *value) : value(value) {}
+
+  /// Key equality function.
+  bool operator==(const KeyTy &key) const { return key == value; }
+
+  /// Construct a new storage instance.
+  static OpaqueAttributeStorage *
+  construct(mlir::AttributeStorageAllocator &allocator, KeyTy key) {
+    return new (allocator.allocate<OpaqueAttributeStorage>())
+        OpaqueAttributeStorage(key);
+  }
+
+  void *getPointer() const { return value; }
+
+private:
+  void *value;
+};
+} // namespace fir::detail
+
+//===----------------------------------------------------------------------===//
+// Attributes for SELECT TYPE
+//===----------------------------------------------------------------------===//
+
+ExactTypeAttr fir::ExactTypeAttr::get(mlir::Type value) {
   return Base::get(value.getContext(), value);
 }
 
-mlir::Type ExactTypeAttr::getType() const { return getImpl()->getType(); }
+mlir::Type fir::ExactTypeAttr::getType() const { return getImpl()->getType(); }
 
-SubclassAttr SubclassAttr::get(mlir::Type value) {
+SubclassAttr fir::SubclassAttr::get(mlir::Type value) {
   return Base::get(value.getContext(), value);
 }
 
-mlir::Type SubclassAttr::getType() const { return getImpl()->getType(); }
+mlir::Type fir::SubclassAttr::getType() const { return getImpl()->getType(); }
+
+//===----------------------------------------------------------------------===//
+// Attributes for SELECT CASE
+//===----------------------------------------------------------------------===//
 
 using AttributeUniquer = mlir::detail::AttributeUniquer;
 
-ClosedIntervalAttr ClosedIntervalAttr::get(mlir::MLIRContext *ctxt) {
+ClosedIntervalAttr fir::ClosedIntervalAttr::get(mlir::MLIRContext *ctxt) {
   return AttributeUniquer::get<ClosedIntervalAttr>(ctxt);
 }
 
-UpperBoundAttr UpperBoundAttr::get(mlir::MLIRContext *ctxt) {
+UpperBoundAttr fir::UpperBoundAttr::get(mlir::MLIRContext *ctxt) {
   return AttributeUniquer::get<UpperBoundAttr>(ctxt);
 }
 
-LowerBoundAttr LowerBoundAttr::get(mlir::MLIRContext *ctxt) {
+LowerBoundAttr fir::LowerBoundAttr::get(mlir::MLIRContext *ctxt) {
   return AttributeUniquer::get<LowerBoundAttr>(ctxt);
 }
 
-PointIntervalAttr PointIntervalAttr::get(mlir::MLIRContext *ctxt) {
+PointIntervalAttr fir::PointIntervalAttr::get(mlir::MLIRContext *ctxt) {
   return AttributeUniquer::get<PointIntervalAttr>(ctxt);
 }
 
+//===----------------------------------------------------------------------===//
 // RealAttr
+//===----------------------------------------------------------------------===//
 
-RealAttr RealAttr::get(mlir::MLIRContext *ctxt,
+RealAttr fir::RealAttr::get(mlir::MLIRContext *ctxt,
                             const RealAttr::ValueType &key) {
   return Base::get(ctxt, key);
 }
 
-int RealAttr::getFKind() const { return getImpl()->getFKind(); }
+KindTy fir::RealAttr::getFKind() const { return getImpl()->getFKind(); }
+
+llvm::APFloat fir::RealAttr::getValue() const { return getImpl()->getValue(); }
+
+//===----------------------------------------------------------------------===//
+// OpaqueAttr
+//===----------------------------------------------------------------------===//
+
+OpaqueAttr fir::OpaqueAttr::get(mlir::MLIRContext *ctxt, void *key) {
+  return Base::get(ctxt, key);
+}
 
-llvm::APFloat RealAttr::getValue() const { return getImpl()->getValue(); }
+void *fir::OpaqueAttr::getPointer() const { return getImpl()->getPointer(); }
 
+//===----------------------------------------------------------------------===//
 // FIR attribute parsing
+//===----------------------------------------------------------------------===//
 
-namespace {
-mlir::Attribute parseFirRealAttr(FIROpsDialect *dialect,
+static mlir::Attribute parseFirRealAttr(FIROpsDialect *dialect,
                                         mlir::DialectAsmParser &parser,
                                         mlir::Type type) {
   int kind = 0;
   if (parser.parseLess() || parser.parseInteger(kind) || parser.parseComma()) {
     parser.emitError(parser.getNameLoc(), "expected '<' kind ','");
     return {};
   }
   KindMapping kindMap(dialect->getContext());
   llvm::APFloat value(0.);
   if (parser.parseOptionalKeyword("i")) {
if (parser.parseKeyword(&hex) || parser.parseGreater()) {
       parser.emitError(parser.getNameLoc(), "expected real constant '>'");
       return {};
     }
     auto bits = llvm::APInt(kind * 8, hex.drop_front(), 16);
     value = llvm::APFloat(kindMap.getFloatSemantics(kind), bits);
   }
   return RealAttr::get(dialect->getContext(), {kind, value});
 }
-} // namespace
 
-mlir::Attribute parseFirAttribute(FIROpsDialect *dialect,
+mlir::Attribute fir::parseFirAttribute(FIROpsDialect *dialect,
                                        mlir::DialectAsmParser &parser,
                                        mlir::Type type) {
   auto loc = parser.getNameLoc();
   llvm::StringRef attrName;
   if (parser.parseKeyword(&attrName)) {
     parser.emitError(loc, "expected an attribute name");
     return {};
   }
 
   if (attrName == ExactTypeAttr::getAttrName()) {
     mlir::Type type;
     if (parser.parseLess() || parser.parseType(type) || parser.parseGreater()) {
       parser.emitError(loc, "expected a type");
       return {};
     }
     return ExactTypeAttr::get(type);
   }
   if (attrName == SubclassAttr::getAttrName()) {
     mlir::Type type;
     if (parser.parseLess() || parser.parseType(type) || parser.parseGreater()) {
       parser.emitError(loc, "expected a subtype");
       return {};
     }
     return SubclassAttr::get(type);
   }
+  if (attrName == OpaqueAttr::getAttrName()) {
+    if (parser.parseLess() || parser.parseGreater()) {
+      parser.emitError(loc, "expected <>");
+      return {};
+    }
+    // NB: opaque pointers are always parsed in as nullptrs. The tool must
+    // rebuild the context.
+    return OpaqueAttr::get(dialect->getContext(), nullptr);
+  }
   if (attrName == PointIntervalAttr::getAttrName())
     return PointIntervalAttr::get(dialect->getContext());
   if (attrName == LowerBoundAttr::getAttrName())
     return LowerBoundAttr::get(dialect->getContext());
   if (attrName == UpperBoundAttr::getAttrName())
     return UpperBoundAttr::get(dialect->getContext());
   if (attrName == ClosedIntervalAttr::getAttrName())
     return ClosedIntervalAttr::get(dialect->getContext());
   if (attrName == RealAttr::getAttrName())
     return parseFirRealAttr(dialect, parser, type);
 
   parser.emitError(loc, "unknown FIR attribute: ") << attrName;
   return {};
 }
 
+//===----------------------------------------------------------------------===//
 // FIR attribute pretty printer
+//===----------------------------------------------------------------------===//
 
-void printFirAttribute(FIROpsDialect *dialect, mlir::Attribute attr,
+void fir::printFirAttribute(FIROpsDialect *dialect, mlir::Attribute attr,
                             mlir::DialectAsmPrinter &p) {
   auto &os = p.getStream();
   if (auto exact = attr.dyn_cast<fir::ExactTypeAttr>()) {
     os << fir::ExactTypeAttr::getAttrName() << '<';
     p.printType(exact.getType());
     os << '>';
   } else if (auto sub = attr.dyn_cast<fir::SubclassAttr>()) {
     os << fir::SubclassAttr::getAttrName() << '<';
     p.printType(sub.getType());
     os << '>';
   } else if (attr.dyn_cast_or_null<fir::PointIntervalAttr>()) {
     os << fir::PointIntervalAttr::getAttrName();
   } else if (attr.dyn_cast_or_null<fir::ClosedIntervalAttr>()) {
     os << fir::ClosedIntervalAttr::getAttrName();
   } else if (attr.dyn_cast_or_null<fir::LowerBoundAttr>()) {
     os << fir::LowerBoundAttr::getAttrName();
   } else if (attr.dyn_cast_or_null<fir::UpperBoundAttr>()) {
     os << fir::UpperBoundAttr::getAttrName();
   } else if (auto a = attr.dyn_cast_or_null<fir::RealAttr>()) {
     os << fir::RealAttr::getAttrName() << '<' << a.getFKind() << ", i x";
     llvm::SmallString<40> ss;
     a.getValue().bitcastToAPInt().toStringUnsigned(ss, 16);
     os << ss << '>';
+  } else if (attr.isa<fir::OpaqueAttr>()) {
+    os << fir::OpaqueAttr::getAttrName() << "<>";
   } else {
-    llvm_unreachable("attribute pretty-printer is not implemented");
+    // don't know how to print the attribute, so use a default
+    os << "<(unknown attribute)>";
   }
 }
-
-} // namespace fir

flang/lib/Optimizer/Dialect/FIRDialect.cpp

 using namespace fir;
 
 fir::FIROpsDialect::FIROpsDialect(mlir::MLIRContext *ctx)
     : mlir::Dialect("fir", ctx, mlir::TypeID::get<FIROpsDialect>()) {
   addTypes<BoxType, BoxCharType, BoxProcType, CharacterType, fir::ComplexType,
            FieldType, HeapType, fir::IntegerType, LenType, LogicalType,
            PointerType, RealType, RecordType, ReferenceType, SequenceType,
            TypeDescType, fir::VectorType>();
-  addAttributes<ClosedIntervalAttr, ExactTypeAttr, LowerBoundAttr,
+  addAttributes<ClosedIntervalAttr, ExactTypeAttr, LowerBoundAttr, OpaqueAttr,
                 PointIntervalAttr, RealAttr, SubclassAttr, UpperBoundAttr>();
   addOperations<
 #define GET_OP_LIST
 #include "flang/Optimizer/Dialect/FIROps.cpp.inc"
       >();
 }
 
 // anchor the class vtable to this compilation unit

flang/test/Fir/fir-ops.fir

 func private @get_method_box() -> !fir.box<!fir.type<derived3{f:f32}>>
 func private @method_impl(!fir.box<!fir.type<derived3{f:f32}>>)
 
 // CHECK-LABEL: func private @nop()
 // CHECK-LABEL: func private @get_func() -> (() -> ())
 func private @nop()
 func private @get_func() -> (() -> ())
 
+// CHECK-LABEL: func private @attr1() -> none attributes {a = #fir.opaque<>, b = #fir.opaque<>}
+func private @attr1() -> none attributes {a = #fir.opaque<>, b = #fir.opaque<>}
+
 // CHECK-LABEL:       func @instructions() {
 func @instructions() {
 // CHECK: [[VAL_0:%.*]] = fir.alloca !fir.array<10xi32>
 // CHECK: [[VAL_1:%.*]] = fir.load [[VAL_0]] : !fir.ref<!fir.array<10xi32>>
 // CHECK: [[VAL_2:%.*]] = fir.alloca i32
 // CHECK: [[VAL_3:%.*]] = constant 22 : i32
   %0 = fir.alloca !fir.array<10xi32>
   %1 = fir.load %0 : !fir.ref<!fir.array<10xi32>>