[mlir][Parser] Use APFloat instead of FloatAttr when parsing DenseElementsAttrs.

[rriddle]

Summary

DenseElementsAttr stores float values as raw bits internally, so creating attributes just to have them unwrapped is extremely inefficient.

[jpienaar]

A benchmark showing impact would be nice ;-)

[rriddle]

In D74818#1882681, @jpienaar wrote:

A benchmark showing impact would be nice ;-)

We don't really have any open benchmarks to run at this point which is unfortunate. Though internally this knocked about 17 seconds off of parsing a .mlir blob with a large number of floating point constants.

mlir/lib/Parser/Parser.cpp

Attribute Parser::parseFloatAttr(Type type, bool isNegative) {
   }
   if (!type.isa<FloatType>())
     return (emitError("floating point value not valid for specified type"),
             nullptr);
   return FloatAttr::get(type, isNegative ? -val.getValue() : val.getValue());
 }
 
 /// Construct a float attribute bitwise equivalent to the integer literal.
-static FloatAttr buildHexadecimalFloatLiteral(Parser *p, FloatType type,
+static Optional<APFloat> buildHexadecimalFloatLiteral(Parser *p, FloatType type,
                                                       uint64_t value) {
   // FIXME: bfloat is currently stored as a double internally because it doesn't
   // have valid APFloat semantics.
-  if (type.isF64() || type.isBF16()) {
-    APFloat apFloat(type.getFloatSemantics(), APInt(/*numBits=*/64, value));
-    return p->builder.getFloatAttr(type, apFloat);
-  }
+  if (type.isF64() || type.isBF16())
+    return APFloat(type.getFloatSemantics(), APInt(/*numBits=*/64, value));
 
   APInt apInt(type.getWidth(), value);
   if (apInt != value) {
     p->emitError("hexadecimal float constant out of range for type");
-    return nullptr;
+    return llvm::None;
   }
-  APFloat apFloat(type.getFloatSemantics(), apInt);
-  return p->builder.getFloatAttr(type, apFloat);
+  return APFloat(type.getFloatSemantics(), apInt);
 }
 
 /// Parse a decimal or a hexadecimal literal, which can be either an integer
 /// or a float attribute.
 Attribute Parser::parseDecOrHexAttr(Type type, bool isNegative) {
   auto val = getToken().getUInt64IntegerValue();
   if (!val.hasValue())
     return (emitError("integer constant out of range for attribute"), nullptr);
if (auto floatType = type.dyn_cast<FloatType>()) {
     if (!isHex) {
       emitError(loc, "unexpected decimal integer literal for a float attribute")
               .attachNote()
           << "add a trailing dot to make the literal a float";
       return nullptr;
     }
 
     // Construct a float attribute bitwise equivalent to the integer literal.
-    return buildHexadecimalFloatLiteral(this, floatType, *val);
+    Optional<APFloat> apVal =
+        buildHexadecimalFloatLiteral(this, floatType, *val);
+    return apVal ? FloatAttr::get(floatType, *apVal) : Attribute();
   }
 
   if (!type.isIntOrIndex())
     return emitError(loc, "integer literal not valid for specified type"),
            nullptr;
 
   // Parse the integer literal.
   int width = type.isIndex() ? 64 : type.getIntOrFloatBitWidth();
DenseElementsAttr TensorLiteralParser::getIntAttr(llvm::SMLoc loc,
 
   return DenseElementsAttr::get(type, intElements);
 }
 
 /// Build a Dense Float attribute for the given type.
 DenseElementsAttr TensorLiteralParser::getFloatAttr(llvm::SMLoc loc,
                                                     ShapedType type,
                                                     FloatType eltTy) {
-  std::vector<Attribute> floatValues;
+  std::vector<APFloat> floatValues;
   floatValues.reserve(storage.size());
   for (const auto &signAndToken : storage) {
     bool isNegative = signAndToken.first;
     const Token &token = signAndToken.second;
 
     // Handle hexadecimal float literals.
     if (token.is(Token::integer) && token.getSpelling().startswith("0x")) {
       if (isNegative) {
         p.emitError(token.getLoc())
             << "hexadecimal float literal should not have a leading minus";
         return nullptr;
       }
       auto val = token.getUInt64IntegerValue();
       if (!val.hasValue()) {
         p.emitError("hexadecimal float constant out of range for attribute");
         return nullptr;
       }
-      FloatAttr attr = buildHexadecimalFloatLiteral(&p, eltTy, *val);
-      if (!attr)
+      Optional<APFloat> apVal = buildHexadecimalFloatLiteral(&p, eltTy, *val);
+      if (!apVal)
         return nullptr;
-      floatValues.push_back(attr);
+      floatValues.push_back(*apVal);
       continue;
     }
 
     // Check to see if any decimal integers or booleans were parsed.
     if (!token.is(Token::floatliteral)) {
       p.emitError() << "expected floating-point elements, but parsed integer";
       return nullptr;
     }
 
     // Build the float values from tokens.
     auto val = token.getFloatingPointValue();
     if (!val.hasValue()) {
       p.emitError("floating point value too large for attribute");
       return nullptr;
     }
-    floatValues.push_back(FloatAttr::get(eltTy, isNegative ? -*val : *val));
+    // Treat BF16 as double because it is not supported in LLVM's APFloat.
+    APFloat apVal(isNegative ? -*val : *val);
+    if (!eltTy.isBF16() && !eltTy.isF64()) {
+      bool unused;
+      apVal.convert(eltTy.getFloatSemantics(), APFloat::rmNearestTiesToEven,
+                    &unused);
+    }
+    floatValues.push_back(apVal);
   }
 
   return DenseElementsAttr::get(type, floatValues);
 }
 
 ParseResult TensorLiteralParser::parseElement() {
   switch (p.getToken().getKind()) {
   // Parse a boolean element.