Define a `cppAccessorType` to const-ref in APFloatParameter and update ODS emitter to use it for verifier signatures

[mehdi_amini]

Summary

This reduce an unnecessary amount of copy of non-trivial objects, like
APFloat.

[jpienaar]

Thanks!

[mehdi_amini]

I reverted because of an issue with gcc5: https://buildkite.com/mlir/mlir-core/builds/19348#c0e75c4f-5350-47d0-a85a-2690aa4e01c6/362-550

Can't construct a tuple containing a std::string from a StringRef there...

Which made me look a bit more into the Key: shouldn't we use a StringRef in the Key as well instead of using the storage type?

mlir/include/mlir/IR/OpBase.td

class StringRefParameter<string desc = ""> :
   let printer = [{$_printer << '"' << $_self << '"';}];
   let cppStorageType = "std::string";
 }
 
 // For APFloats, which require comparison.
 class APFloatParameter<string desc> :
     AttrOrTypeParameter<"::llvm::APFloat", desc> {
   let comparator = "$_lhs.bitwiseIsEqual($_rhs)";
+  let cppAccessorType = "const ::llvm::APFloat &";
 }
 
 // For standard ArrayRefs, which require allocation.
 class ArrayRefParameter<string arrayOf, string desc = ""> :
     AttrOrTypeParameter<"::llvm::ArrayRef<" # arrayOf # ">", desc> {
   let allocator = [{$_dst = $_allocator.copyInto($_self);}];
   let cppStorageType = "::llvm::SmallVector<" # arrayOf # ">";
 }

mlir/lib/IR/BuiltinAttributes.cpp

if (&value.getSemantics() != &APFloat::IEEEdouble()) {
     bool losesInfo = false;
     value.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
                   &losesInfo);
   }
   return value.convertToDouble();
 }
 
 LogicalResult FloatAttr::verify(function_ref<InFlightDiagnostic()> emitError,
-                                Type type, APFloat value) {
+                                Type type, const APFloat &value) {
   // Verify that the type is correct.
   if (!type.isa<FloatType>())
     return emitError() << "expected floating point type";
 
   // Verify that the type semantics match that of the value.
   if (&type.cast<FloatType>().getFloatSemantics() != &value.getSemantics()) {
     return emitError()
            << "FloatAttr type doesn't match the type implied by its value";

mlir/test/lib/Dialect/Test/TestAttributes.cpp

TestI64ElementsAttr::verify(function_ref<InFlightDiagnostic()> emitError,
   if (type.getRank() != 1 || !type.getElementType().isSignlessInteger(64))
     return emitError() << "expected single rank 64-bit shape type, but got: "
                        << type;
   return success();
 }
 
 LogicalResult
 TestAttrWithFormatAttr::verify(function_ref<InFlightDiagnostic()> emitError,
-                               int64_t one, std::string two, IntegerAttr three,
+                               int64_t one, StringRef two, IntegerAttr three,
                                ArrayRef<int> four) {
   if (four.size() != static_cast<unsigned>(one))
     return emitError() << "expected 'one' to equal 'four.size()'";
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Utility Functions for Generated Attributes

mlir/test/mlir-tblgen/attrdefs.td

let parameters = (
       APFloatParameter<"">: $apFloat,
       ArrayRefParameter<"int", "Matrix dimensions">:$dims,
       AttributeSelfTypeParameter<"">:$inner
   );
 
   let genVerifyDecl = 1;
 
 // DECL-LABEL: class CompoundAAttr : public ::mlir::Attribute
-// DECL: static CompoundAAttr getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, int widthOfSomething, ::test::SimpleTypeA exampleTdType, ::llvm::APFloat apFloat, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
-// DECL: static ::mlir::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, int widthOfSomething, ::test::SimpleTypeA exampleTdType, ::llvm::APFloat apFloat, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
+// DECL: static CompoundAAttr getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, int widthOfSomething, ::test::SimpleTypeA exampleTdType, const ::llvm::APFloat &apFloat, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
+// DECL: static ::mlir::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, int widthOfSomething, ::test::SimpleTypeA exampleTdType, const ::llvm::APFloat &apFloat, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
 // DECL: static constexpr ::llvm::StringLiteral getMnemonic() {
 // DECL:   return {"cmpnd_a"};
 // DECL: }
 // DECL: static ::mlir::Attribute parse(
 // DECL-SAME: ::mlir::AsmParser &parser, ::mlir::Type type);
 // DECL: void print(::mlir::AsmPrinter &printer) const;
 // DECL: int getWidthOfSomething() const;
 // DECL: ::test::SimpleTypeA getExampleTdType() const;
-// DECL: ::llvm::APFloat getApFloat() const;
+// DECL: const ::llvm::APFloat &getApFloat() const;
 
 // Check that AttributeSelfTypeParameter is handled properly.
 // DEF-LABEL: struct CompoundAAttrStorage
 // DEF: CompoundAAttrStorage(
 // DEF-SAME: : ::mlir::AttributeStorage(inner),
 
 // DEF: bool operator==(const KeyTy &tblgenKey) const {
 // DEF-NEXT: return

 
 def F_ParamWithAccessorTypeAttr : TestAttr<"ParamWithAccessorType"> {
   let parameters = (ins AttrParameter<"std::string", "", "StringRef">:$param);
 }
 
 // DECL-LABEL: class ParamWithAccessorTypeAttr
 // DECL: StringRef getParam()
 // DEF: ParamWithAccessorTypeAttrStorage
-// DEF: ParamWithAccessorTypeAttrStorage(std::string param)
+// DEF: ParamWithAccessorTypeAttrStorage(StringRef param)
 // DEF: StringRef ParamWithAccessorTypeAttr::getParam()

mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

 //===----------------------------------------------------------------------===//
 // Builder Emission
 
 SmallVector<MethodParameter>
 DefGen::getBuilderParams(std::initializer_list<MethodParameter> prefix) const {
   SmallVector<MethodParameter> builderParams;
   builderParams.append(prefix.begin(), prefix.end());
   for (auto &param : params)
-    builderParams.emplace_back(param.getCppType(), param.getName());
+    builderParams.emplace_back(param.getCppAccessorType(), param.getName());
   return builderParams;
 }
 
 void DefGen::emitDefaultBuilder() {
   Method *m = defCls.addStaticMethod(
       def.getCppClassName(), "get",
       getBuilderParams({{"::mlir::MLIRContext *", "context"}}));
   MethodBody &body = m->body().indent();