[mlir] Add better support for f80 and f128

[clementval]

Summary

Add builtin f80 and f128 following @schweitz proposition
https://llvm.discourse.group/t/rfc-adding-better-support-for-higher-precision-floating-point/2526/5

[rriddle]

Did a pass through, and looks good to me.

mlir/test/Dialect/LLVMIR/types.mlir

15–18

Can you add a usage in IR/parser.mlir now that these are builtin types? All of these checks here look like they should go away now that the types have been replaced.

[clementval]

Add usage in IR/parser.mlir

mlir/test/Dialect/LLVMIR/types.mlir

15–18

Should we also remove the checks for f16, bf16, f32, f64?

[rriddle]

mlir/test/Dialect/LLVMIR/types.mlir

15–18

Yeah, I don't think any of those are useful anymore.

[clementval]

Remove useless checks now that types have been replaced

[clementval]

mlir/test/Dialect/LLVMIR/types.mlir

15–18

Ok. Thanks for the quick review. I just removed the checks.

[ftynse]

mlir/docs/Dialects/LLVM.md

217

Please add f80 and f128 here

[clementval]

Add f80 and f128 to LLVM.md

mlir/docs/ConversionToLLVMDialect.md

 Scalar types are converted to their LLVM counterparts if they exist. The
 following conversions are currently implemented:
 
 -   `i*` converts to `!llvm.i*`
 -   `bf16` converts to `bf16`
 -   `f16` converts to `f16`
 -   `f32` converts to `f32`
 -   `f64` converts to `f64`
+-   `f80` converts to `f80`
+-   `f128` converts to `f128`
 
 ### Index Type
 
 Index type is converted to an LLVM dialect integer type with bitwidth equal to
 the bitwidth of the pointer size as specified by the
 [data layout](Dialects/LLVM.md#data-layout-and-triple) of the closest module.
 For example, on x86-64 CPUs it converts to `i64`. This behavior can be
 overridden by the type converter configuration, which is often exposed as a pass

mlir/docs/Dialects/LLVM.md

 pointer to a 32-bit integer.
 
 ### Built-in Type Compatibility
 
 LLVM dialect accepts a subset of built-in types that are referred to as _LLVM
 dialect-compatible types_. The following types are compatible:
 
 -   Signless integers - `iN` (`IntegerType`).
 -   Floating point types - `bfloat`, `half`, `float`, `double` (`FloatType`).
 -   1D vectors of signless integers or floating point types - `vector<NxT>`
     (`VectorType`).
 
 Note that only a subset of types that can be represented by a given class is
 compatible. For example, signed and unsigned integers are not compatible. LLVM
 provides a function, `bool LLVM::isCompatibleType(Type)`, that can be used as a
 compatibility check.
 
 ### Additional Simple Types
 
 The following non-parametric types derived from the LLVM IR are available in the
 LLVM dialect:
 
--   `!llvm.fp128` (`LLVMFP128Type`) - 128-bit floating-point value as per
-    IEEE-754-2008.
--   `!llvm.x86_fp80` (`LLVMX86FP80Type`) - 80-bit floating-point value (x87).
 -   `!llvm.x86_mmx` (`LLVMX86MMXType`) - value held in an MMX register on x86
     machine.
 -   `!llvm.ppc_fp128` (`LLVMPPCFP128Type`) - 128-bit floating-point value (two
     64 bits).
 -   `!llvm.token` (`LLVMTokenType`) - a non-inspectable value associated with an
     operation.
 -   `!llvm.metadata` (`LLVMMetadataType`) - LLVM IR metadata, to be used only if
     the metadata cannot be represented as structured MLIR attributes.

mlir/docs/LangRef.md

 ```
 
 #### Floating Point Types
 
 Syntax:
 
 ```
 // Floating point.
-float-type ::= `f16` | `bf16` | `f32` | `f64`
+float-type ::= `f16` | `bf16` | `f32` | `f64` | `f80` | `f128`
 ```
 
 MLIR supports float types of certain widths that are widely used as indicated
 above.
 
 #### Function Type
 
 Syntax:

mlir/include/mlir/Dialect/LLVMIR/LLVMTypes.h

 
 namespace detail {
 struct LLVMFunctionTypeStorage;
 struct LLVMPointerTypeStorage;
 struct LLVMStructTypeStorage;
 struct LLVMTypeAndSizeStorage;
 } // namespace detail
 
-class LLVMFP128Type;
-class LLVMX86FP80Type;
-
 //===----------------------------------------------------------------------===//
 // Trivial types.
 //===----------------------------------------------------------------------===//
 
 // Batch-define trivial types.
 #define DEFINE_TRIVIAL_LLVM_TYPE(ClassName)                                    \
   class ClassName : public Type::TypeBase<ClassName, Type, TypeStorage> {      \
   public:                                                                      \
     using Base::Base;                                                          \
   }
 
 DEFINE_TRIVIAL_LLVM_TYPE(LLVMVoidType);
-DEFINE_TRIVIAL_LLVM_TYPE(LLVMFP128Type);
-DEFINE_TRIVIAL_LLVM_TYPE(LLVMX86FP80Type);
 DEFINE_TRIVIAL_LLVM_TYPE(LLVMPPCFP128Type);
 DEFINE_TRIVIAL_LLVM_TYPE(LLVMX86MMXType);
 DEFINE_TRIVIAL_LLVM_TYPE(LLVMTokenType);
 DEFINE_TRIVIAL_LLVM_TYPE(LLVMLabelType);
 DEFINE_TRIVIAL_LLVM_TYPE(LLVMMetadataType);
 
 #undef DEFINE_TRIVIAL_LLVM_TYPE
 

mlir/include/mlir/IR/Builders.h

public:
   Location getFusedLoc(ArrayRef<Location> locs,
                        Attribute metadata = Attribute());
 
   // Types.
   FloatType getBF16Type();
   FloatType getF16Type();
   FloatType getF32Type();
   FloatType getF64Type();
+  FloatType getF80Type();
+  FloatType getF128Type();
 
   IndexType getIndexType();
 
   IntegerType getI1Type();
   IntegerType getI32Type();
   IntegerType getI64Type();
   IntegerType getIntegerType(unsigned width);
   IntegerType getIntegerType(unsigned width, bool isSigned);

mlir/include/mlir/IR/BuiltinTypes.h

 public:
   using Type::Type;
 
   // Convenience factories.
   static FloatType getBF16(MLIRContext *ctx);
   static FloatType getF16(MLIRContext *ctx);
   static FloatType getF32(MLIRContext *ctx);
   static FloatType getF64(MLIRContext *ctx);
+  static FloatType getF80(MLIRContext *ctx);
+  static FloatType getF128(MLIRContext *ctx);
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
   static bool classof(Type type);
 
   /// Return the bitwidth of this float type.
   unsigned getWidth();
 
   /// Get or create a new FloatType with bitwidth scaled by `scale`.
inline bool BaseMemRefType::classof(Type type) {
   return type.isa<MemRefType, UnrankedMemRefType>();
 }
 
 inline bool BaseMemRefType::isValidElementType(Type type) {
   return type.isIntOrIndexOrFloat() || type.isa<ComplexType, VectorType>();
 }
 
 inline bool FloatType::classof(Type type) {
-  return type.isa<BFloat16Type, Float16Type, Float32Type, Float64Type>();
+  return type.isa<BFloat16Type, Float16Type, Float32Type, Float64Type,
+                  Float80Type, Float128Type>();
 }
 
 inline FloatType FloatType::getBF16(MLIRContext *ctx) {
   return BFloat16Type::get(ctx);
 }
 
 inline FloatType FloatType::getF16(MLIRContext *ctx) {
   return Float16Type::get(ctx);
 }
 
 inline FloatType FloatType::getF32(MLIRContext *ctx) {
   return Float32Type::get(ctx);
 }
 
 inline FloatType FloatType::getF64(MLIRContext *ctx) {
   return Float64Type::get(ctx);
 }
 
+inline FloatType FloatType::getF80(MLIRContext *ctx) {
+  return Float80Type::get(ctx);
+}
+
+inline FloatType FloatType::getF128(MLIRContext *ctx) {
+  return Float128Type::get(ctx);
+}
+
 inline bool ShapedType::classof(Type type) {
   return type.isa<RankedTensorType, VectorType, UnrankedTensorType,
                   UnrankedMemRefType, MemRefType>();
 }
 
 inline bool TensorType::classof(Type type) {
   return type.isa<RankedTensorType, UnrankedTensorType>();
 }

mlir/include/mlir/IR/BuiltinTypes.td

 //===----------------------------------------------------------------------===//
 // Float64Type
 
 def Builtin_Float64 : Builtin_FloatType<"Float64"> {
   let summary = "64-bit floating-point type";
 }
 
 //===----------------------------------------------------------------------===//
+// Float80Type
+
+def Builtin_Float80 : Builtin_FloatType<"Float80"> {
+  let summary = "80-bit floating-point type";
+}
+
+//===----------------------------------------------------------------------===//
+// Float128Type
+
+def Builtin_Float128 : Builtin_FloatType<"Float128"> {
+  let summary = "128-bit floating-point type";
+}
+
+//===----------------------------------------------------------------------===//
 // FunctionType
 //===----------------------------------------------------------------------===//
 
 def Builtin_Function : Builtin_Type<"Function"> {
   let summary = "Map from a list of inputs to a list of results";
   let description = [{
     Syntax:
 

mlir/include/mlir/IR/OpBase.td

 
 class FloatOfWidths<list<int> widths> :
     AnyTypeOf<!foreach(w, widths, F<w>),
               !interleave(widths, "/") # "-bit float">;
 
 def F16 : F<16>;
 def F32 : F<32>;
 def F64 : F<64>;
+def F80 : F<80>;
+def F128 : F<128>;
 
 def BF16 : Type<CPred<"$_self.isBF16()">, "bfloat16 type">,
            BuildableType<"$_builder.getBF16Type()">;
 
 class Complex<Type type>
     : Type<And<[
           CPred<"$_self.isa<::mlir::ComplexType>()">,
           SubstLeaves<"$_self",

mlir/include/mlir/IR/Types.h

public:
 
   // Convenience predicates.  This is only for floating point types,
   // derived types should use isa/dyn_cast.
   bool isIndex() const;
   bool isBF16() const;
   bool isF16() const;
   bool isF32() const;
   bool isF64() const;
+  bool isF80() const;
+  bool isF128() const;
 
   /// Return true if this is an integer type with the specified width.
   bool isInteger(unsigned width) const;
   /// Return true if this is a signless integer type (with the specified width).
   bool isSignlessInteger() const;
   bool isSignlessInteger(unsigned width) const;
   /// Return true if this is a signed integer type (with the specified width).
   bool isSignedInteger() const;

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

 // LLVMDialect initialization, type parsing, and registration.
 //===----------------------------------------------------------------------===//
 
 void LLVMDialect::initialize() {
   addAttributes<FMFAttr>();
 
   // clang-format off
   addTypes<LLVMVoidType,
-           LLVMFP128Type,
-           LLVMX86FP80Type,
            LLVMPPCFP128Type,
            LLVMX86MMXType,
            LLVMTokenType,
            LLVMLabelType,
            LLVMMetadataType,
            LLVMFunctionType,
            LLVMPointerType,
            LLVMFixedVectorType,

mlir/lib/Dialect/LLVMIR/IR/LLVMTypeSyntax.cpp

if (isCompatibleType(type) && !type.isa<IntegerType, FloatType, VectorType>())
     return mlir::LLVM::detail::printType(type, printer);
   printer.printType(type);
 }
 
 /// Returns the keyword to use for the given type.
 static StringRef getTypeKeyword(Type type) {
   return TypeSwitch<Type, StringRef>(type)
       .Case<LLVMVoidType>([&](Type) { return "void"; })
-      .Case<LLVMFP128Type>([&](Type) { return "fp128"; })
-      .Case<LLVMX86FP80Type>([&](Type) { return "x86_fp80"; })
       .Case<LLVMPPCFP128Type>([&](Type) { return "ppc_fp128"; })
       .Case<LLVMX86MMXType>([&](Type) { return "x86_mmx"; })
       .Case<LLVMTokenType>([&](Type) { return "token"; })
       .Case<LLVMLabelType>([&](Type) { return "label"; })
       .Case<LLVMMetadataType>([&](Type) { return "metadata"; })
       .Case<LLVMFunctionType>([&](Type) { return "func"; })
       .Case<LLVMPointerType>([&](Type) { return "ptr"; })
       .Case<LLVMFixedVectorType, LLVMScalableVectorType>(
return StringSwitch<function_ref<Type()>>(key)
               emitWarning(loc) << "deprecated syntax, use f32 instead";
               return Float32Type::get(ctx);
             })
       .Case("double",
             [&] {
               emitWarning(loc) << "deprecated syntax, use f64 instead";
               return Float64Type::get(ctx);
             })
-      .Case("fp128", [&] { return LLVMFP128Type::get(ctx); })
-      .Case("x86_fp80", [&] { return LLVMX86FP80Type::get(ctx); })
+      .Case("fp128",
+            [&] {
+              emitWarning(loc) << "deprecated syntax, use f128 instead";
+              return Float128Type::get(ctx);
+            })
+      .Case("x86_fp80",
+            [&] {
+              emitWarning(loc) << "deprecated syntax, use f80 instead";
+              return Float80Type::get(ctx);
+            })
       .Case("ppc_fp128", [&] { return LLVMPPCFP128Type::get(ctx); })
       .Case("x86_mmx", [&] { return LLVMX86MMXType::get(ctx); })
       .Case("token", [&] { return LLVMTokenType::get(ctx); })
       .Case("label", [&] { return LLVMLabelType::get(ctx); })
       .Case("metadata", [&] { return LLVMMetadataType::get(ctx); })
       .Case("func", [&] { return parseFunctionType(parser); })
       .Case("ptr", [&] { return parsePointerType(parser); })
       .Case("vec", [&] { return parseVectorType(parser); })

mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp

Type LLVMFixedVectorType::getElementType() {
   return static_cast<detail::LLVMTypeAndSizeStorage *>(impl)->elementType;
 }
 
 unsigned LLVMFixedVectorType::getNumElements() {
   return getImpl()->numElements;
 }
 
 bool LLVMFixedVectorType::isValidElementType(Type type) {
-  return type
-      .isa<LLVMPointerType, LLVMX86FP80Type, LLVMFP128Type, LLVMPPCFP128Type>();
+  return type.isa<LLVMPointerType, LLVMPPCFP128Type>();
 }
 
 LogicalResult LLVMFixedVectorType::verifyConstructionInvariants(
     Location loc, Type elementType, unsigned numElements) {
   return verifyVectorConstructionInvariants<LLVMFixedVectorType>(
       loc, elementType, numElements);
 }
 
if (auto vecType = type.dyn_cast<VectorType>())
     return vecType.getRank() == 1 && isCompatibleType(vecType.getElementType());
 
   // clang-format off
   return type.isa<
       BFloat16Type,
       Float16Type,
       Float32Type,
       Float64Type,
+      Float80Type,
+      Float128Type,
       LLVMArrayType,
-      LLVMFP128Type,
       LLVMFunctionType,
       LLVMLabelType,
       LLVMMetadataType,
       LLVMPPCFP128Type,
       LLVMPointerType,
       LLVMStructType,
       LLVMTokenType,
       LLVMFixedVectorType,
       LLVMScalableVectorType,
       LLVMVoidType,
-      LLVMX86FP80Type,
       LLVMX86MMXType
   >();
   // clang-format on
 }
 
 bool mlir::LLVM::isCompatibleFloatingPointType(Type type) {
   return type.isa<BFloat16Type, Float16Type, Float32Type, Float64Type,
-                  LLVMFP128Type, LLVMPPCFP128Type, LLVMX86FP80Type>();
+                  Float80Type, Float128Type, LLVMPPCFP128Type>();
 }
 
 bool mlir::LLVM::isCompatibleVectorType(Type type) {
   if (type.isa<LLVMFixedVectorType, LLVMScalableVectorType>())
     return true;
 
   if (auto vecType = type.dyn_cast<VectorType>()) {
     if (vecType.getRank() != 1)
       return false;
     Type elementType = vecType.getElementType();
     if (auto intType = elementType.dyn_cast<IntegerType>())
       return intType.isSignless();
-    return elementType
-        .isa<BFloat16Type, Float16Type, Float32Type, Float64Type>();
+    return elementType.isa<BFloat16Type, Float16Type, Float32Type, Float64Type,
+                           Float80Type, Float128Type>();
   }
   return false;
 }
 
 Type mlir::LLVM::getVectorElementType(Type type) {
   return llvm::TypeSwitch<Type, Type>(type)
       .Case<LLVMFixedVectorType, LLVMScalableVectorType, VectorType>(
           [](auto ty) { return ty.getElementType(); })
assert(isCompatibleType(type) &&
          "expected a type compatible with the LLVM dialect");
 
   return llvm::TypeSwitch<Type, llvm::TypeSize>(type)
       .Case<BFloat16Type, Float16Type>(
           [](Type) { return llvm::TypeSize::Fixed(16); })
       .Case<Float32Type>([](Type) { return llvm::TypeSize::Fixed(32); })
       .Case<Float64Type, LLVMX86MMXType>(
           [](Type) { return llvm::TypeSize::Fixed(64); })
+      .Case<Float80Type>([](Type) { return llvm::TypeSize::Fixed(80); })
+      .Case<Float128Type>([](Type) { return llvm::TypeSize::Fixed(128); })
       .Case<IntegerType>([](IntegerType intTy) {
         return llvm::TypeSize::Fixed(intTy.getWidth());
       })
-      .Case<LLVMX86FP80Type>([](Type) { return llvm::TypeSize::Fixed(80); })
-      .Case<LLVMPPCFP128Type, LLVMFP128Type>(
-          [](Type) { return llvm::TypeSize::Fixed(128); })
+      .Case<LLVMPPCFP128Type>([](Type) { return llvm::TypeSize::Fixed(128); })
       .Case<LLVMFixedVectorType>([](LLVMFixedVectorType t) {
         llvm::TypeSize elementSize =
             getPrimitiveTypeSizeInBits(t.getElementType());
         return llvm::TypeSize(elementSize.getFixedSize() * t.getNumElements(),
                               elementSize.isScalable());
       })
       .Case<VectorType>([](VectorType t) {
         assert(isCompatibleVectorType(t) &&

mlir/lib/IR/AsmPrinter.cpp

TypeSwitch<Type>(type)
         printDialectSymbol(os, "!", opaqueTy.getDialectNamespace(),
                            opaqueTy.getTypeData());
       })
       .Case<IndexType>([&](Type) { os << "index"; })
       .Case<BFloat16Type>([&](Type) { os << "bf16"; })
       .Case<Float16Type>([&](Type) { os << "f16"; })
       .Case<Float32Type>([&](Type) { os << "f32"; })
       .Case<Float64Type>([&](Type) { os << "f64"; })
+      .Case<Float80Type>([&](Type) { os << "f80"; })
+      .Case<Float128Type>([&](Type) { os << "f128"; })
       .Case<IntegerType>([&](IntegerType integerTy) {
         if (integerTy.isSigned())
           os << 's';
         else if (integerTy.isUnsigned())
           os << 'u';
         os << 'i' << integerTy.getWidth();
       })
       .Case<FunctionType>([&](FunctionType funcTy) {

mlir/lib/IR/Builders.cpp

 FloatType Builder::getBF16Type() { return FloatType::getBF16(context); }
 
 FloatType Builder::getF16Type() { return FloatType::getF16(context); }
 
 FloatType Builder::getF32Type() { return FloatType::getF32(context); }
 
 FloatType Builder::getF64Type() { return FloatType::getF64(context); }
 
+FloatType Builder::getF80Type() { return FloatType::getF80(context); }
+
+FloatType Builder::getF128Type() { return FloatType::getF128(context); }
+
 IndexType Builder::getIndexType() { return IndexType::get(context); }
 
 IntegerType Builder::getI1Type() { return IntegerType::get(context, 1); }
 
 IntegerType Builder::getI32Type() { return IntegerType::get(context, 32); }
 
 IntegerType Builder::getI64Type() { return IntegerType::get(context, 64); }
 

mlir/lib/IR/BuiltinDialect.cpp

LogicalResult getAlias(Attribute attr, raw_ostream &os) const override {
     }
     return failure();
   }
 };
 } // end anonymous namespace.
 
 void BuiltinDialect::initialize() {
   addTypes<ComplexType, BFloat16Type, Float16Type, Float32Type, Float64Type,
-           FunctionType, IndexType, IntegerType, MemRefType, UnrankedMemRefType,
-           NoneType, OpaqueType, RankedTensorType, TupleType,
-           UnrankedTensorType, VectorType>();
+           Float80Type, Float128Type, FunctionType, IndexType, IntegerType,
+           MemRefType, UnrankedMemRefType, NoneType, OpaqueType,
+           RankedTensorType, TupleType, UnrankedTensorType, VectorType>();
   addAttributes<AffineMapAttr, ArrayAttr, DenseIntOrFPElementsAttr,
                 DenseStringElementsAttr, DictionaryAttr, FloatAttr,
                 SymbolRefAttr, IntegerAttr, IntegerSetAttr, OpaqueAttr,
                 OpaqueElementsAttr, SparseElementsAttr, StringAttr, TypeAttr,
                 UnitAttr>();
   addAttributes<CallSiteLoc, FileLineColLoc, FusedLoc, NameLoc, OpaqueLoc,
                 UnknownLoc>();
   addOperations<

mlir/lib/IR/BuiltinTypes.cpp

 
 unsigned FloatType::getWidth() {
   if (isa<Float16Type, BFloat16Type>())
     return 16;
   if (isa<Float32Type>())
     return 32;
   if (isa<Float64Type>())
     return 64;
+  if (isa<Float80Type>())
+    return 80;
+  if (isa<Float128Type>())
+    return 128;
   llvm_unreachable("unexpected float type");
 }
 
 /// Returns the floating semantics for the given type.
 const llvm::fltSemantics &FloatType::getFloatSemantics() {
   if (isa<BFloat16Type>())
     return APFloat::BFloat();
   if (isa<Float16Type>())
     return APFloat::IEEEhalf();
   if (isa<Float32Type>())
     return APFloat::IEEEsingle();
   if (isa<Float64Type>())
     return APFloat::IEEEdouble();
+  if (isa<Float80Type>())
+    return APFloat::x87DoubleExtended();
+  if (isa<Float128Type>())
+    return APFloat::IEEEquad();
   llvm_unreachable("non-floating point type used");
 }
 
 FloatType FloatType::scaleElementBitwidth(unsigned scale) {
   if (!scale)
     return FloatType();
   MLIRContext *ctx = getContext();
   if (isF16() || isBF16()) {

mlir/lib/IR/MLIRContext.cpp

#endif
   DenseMap<TypeID, const AbstractType *> registeredTypes;
   StorageUniquer typeUniquer;
 
   /// Cached Type Instances.
   BFloat16Type bf16Ty;
   Float16Type f16Ty;
   Float32Type f32Ty;
   Float64Type f64Ty;
+  Float80Type f80Ty;
+  Float128Type f128Ty;
   IndexType indexTy;
   IntegerType int1Ty, int8Ty, int16Ty, int32Ty, int64Ty, int128Ty;
   NoneType noneType;
 
   //===--------------------------------------------------------------------===//
   // Attribute uniquing
   //===--------------------------------------------------------------------===//
 
MLIRContext::MLIRContext() : impl(new MLIRContextImpl()) {
   // the context when accessing them.
 
   //// Types.
   /// Floating-point Types.
   impl->bf16Ty = TypeUniquer::get<BFloat16Type>(this);
   impl->f16Ty = TypeUniquer::get<Float16Type>(this);
   impl->f32Ty = TypeUniquer::get<Float32Type>(this);
   impl->f64Ty = TypeUniquer::get<Float64Type>(this);
+  impl->f80Ty = TypeUniquer::get<Float80Type>(this);
+  impl->f128Ty = TypeUniquer::get<Float128Type>(this);
   /// Index Type.
   impl->indexTy = TypeUniquer::get<IndexType>(this);
   /// Integer Types.
   impl->int1Ty = TypeUniquer::get<IntegerType>(this, 1, IntegerType::Signless);
   impl->int8Ty = TypeUniquer::get<IntegerType>(this, 8, IntegerType::Signless);
   impl->int16Ty =
       TypeUniquer::get<IntegerType>(this, 16, IntegerType::Signless);
   impl->int32Ty =
Float16Type Float16Type::get(MLIRContext *context) {
   return context->getImpl().f16Ty;
 }
 Float32Type Float32Type::get(MLIRContext *context) {
   return context->getImpl().f32Ty;
 }
 Float64Type Float64Type::get(MLIRContext *context) {
   return context->getImpl().f64Ty;
 }
+Float80Type Float80Type::get(MLIRContext *context) {
+  return context->getImpl().f80Ty;
+}
+Float128Type Float128Type::get(MLIRContext *context) {
+  return context->getImpl().f128Ty;
+}
 
 /// Get an instance of the IndexType.
 IndexType IndexType::get(MLIRContext *context) {
   return context->getImpl().indexTy;
 }
 
 /// Return an existing integer type instance if one is cached within the
 /// context.

mlir/lib/IR/Types.cpp

 }
 
 MLIRContext *Type::getContext() const { return getDialect().getContext(); }
 
 bool Type::isBF16() const { return isa<BFloat16Type>(); }
 bool Type::isF16() const { return isa<Float16Type>(); }
 bool Type::isF32() const { return isa<Float32Type>(); }
 bool Type::isF64() const { return isa<Float64Type>(); }
+bool Type::isF80() const { return isa<Float80Type>(); }
+bool Type::isF128() const { return isa<Float128Type>(); }
 
 bool Type::isIndex() const { return isa<IndexType>(); }
 
 /// Return true if this is an integer type with the specified width.
 bool Type::isInteger(unsigned width) const {
   if (auto intTy = dyn_cast<IntegerType>())
     return intTy.getWidth() == width;
   return false;

mlir/lib/Parser/TokenKinds.def

 TOK_KEYWORD(attributes)
 TOK_KEYWORD(bf16)
 TOK_KEYWORD(ceildiv)
 TOK_KEYWORD(complex)
 TOK_KEYWORD(dense)
 TOK_KEYWORD(f16)
 TOK_KEYWORD(f32)
 TOK_KEYWORD(f64)
+TOK_KEYWORD(f80)
+TOK_KEYWORD(f128)
 TOK_KEYWORD(false)
 TOK_KEYWORD(floordiv)
 TOK_KEYWORD(for)
 TOK_KEYWORD(func)
 TOK_KEYWORD(index)
 TOK_KEYWORD(loc)
 TOK_KEYWORD(max)
 TOK_KEYWORD(memref)

mlir/lib/Parser/TypeParser.cpp

 ///                       | vector-type
 ///                       | tensor-type
 ///                       | memref-type
 ///                       | complex-type
 ///                       | tuple-type
 ///                       | none-type
 ///
 ///   index-type ::= `index`
-///   float-type ::= `f16` | `bf16` | `f32` | `f64`
+///   float-type ::= `f16` | `bf16` | `f32` | `f64` | `f80` | `f128`
 ///   none-type ::= `none`
 ///
 Type Parser::parseNonFunctionType() {
   switch (getToken().getKind()) {
   default:
     return (emitError("expected non-function type"), nullptr);
   case Token::kw_memref:
     return parseMemRefType();
case Token::kw_f16:
     consumeToken(Token::kw_f16);
     return builder.getF16Type();
   case Token::kw_f32:
     consumeToken(Token::kw_f32);
     return builder.getF32Type();
   case Token::kw_f64:
     consumeToken(Token::kw_f64);
     return builder.getF64Type();
+  case Token::kw_f80:
+    consumeToken(Token::kw_f80);
+    return builder.getF80Type();
+  case Token::kw_f128:
+    consumeToken(Token::kw_f128);
+    return builder.getF128Type();
 
   // index-type
   case Token::kw_index:
     consumeToken(Token::kw_index);
     return builder.getIndexType();
 
   // none-type
   case Token::kw_none:

mlir/lib/Target/LLVMIR/TypeTranslation.cpp

llvm::Type *translated =
             .Case([this](BFloat16Type) {
               return llvm::Type::getBFloatTy(context);
             })
             .Case(
                 [this](Float32Type) { return llvm::Type::getFloatTy(context); })
             .Case([this](Float64Type) {
               return llvm::Type::getDoubleTy(context);
             })
-            .Case([this](LLVM::LLVMFP128Type) {
-              return llvm::Type::getFP128Ty(context);
-            })
-            .Case([this](LLVM::LLVMX86FP80Type) {
+            .Case([this](Float80Type) {
               return llvm::Type::getX86_FP80Ty(context);
             })
+            .Case([this](Float128Type) {
+              return llvm::Type::getFP128Ty(context);
+            })
             .Case([this](LLVM::LLVMPPCFP128Type) {
               return llvm::Type::getPPC_FP128Ty(context);
             })
             .Case([this](LLVM::LLVMX86MMXType) {
               return llvm::Type::getX86_MMXTy(context);
             })
             .Case([this](LLVM::LLVMTokenType) {
               return llvm::Type::getTokenTy(context);
if (type->isHalfTy())
       return Float16Type::get(&context);
     if (type->isBFloatTy())
       return BFloat16Type::get(&context);
     if (type->isFloatTy())
       return Float32Type::get(&context);
     if (type->isDoubleTy())
       return Float64Type::get(&context);
     if (type->isFP128Ty())
-      return LLVM::LLVMFP128Type::get(&context);
+      return Float128Type::get(&context);
     if (type->isX86_FP80Ty())
-      return LLVM::LLVMX86FP80Type::get(&context);
+      return Float80Type::get(&context);
     if (type->isPPC_FP128Ty())
       return LLVM::LLVMPPCFP128Type::get(&context);
     if (type->isX86_MMXTy())
       return LLVM::LLVMX86MMXType::get(&context);
     if (type->isLabelTy())
       return LLVM::LLVMLabelType::get(&context);
     if (type->isMetadataTy())
       return LLVM::LLVMMetadataType::get(&context);

mlir/test/Dialect/LLVMIR/roundtrip.mlir

 //
 // CHECK: %[[PTR:.*]] = llvm.inttoptr %[[I32]] : i32 to !llvm.ptr<i32>
 // CHECK: %{{.*}} = llvm.ptrtoint %[[PTR]] : !llvm.ptr<i32> to i32
   %25 = llvm.inttoptr %arg0 : i32 to !llvm.ptr<i32>
   %26 = llvm.ptrtoint %25 : !llvm.ptr<i32> to i32
 
 // Extended and Quad floating point
 //
-// CHECK: %{{.*}} = llvm.fpext %[[FLOAT]] : f32 to !llvm.x86_fp80
-// CHECK: %{{.*}} = llvm.fpext %[[FLOAT]] : f32 to !llvm.fp128
-  %27 = llvm.fpext %arg1 : f32 to !llvm.x86_fp80
-  %28 = llvm.fpext %arg1 : f32 to !llvm.fp128
+// CHECK: %{{.*}} = llvm.fpext %[[FLOAT]] : f32 to f80
+// CHECK: %{{.*}} = llvm.fpext %[[FLOAT]] : f32 to f128
+  %27 = llvm.fpext %arg1 : f32 to f80
+  %28 = llvm.fpext %arg1 : f32 to f128
 
 // CHECK: %{{.*}} = llvm.fneg %[[FLOAT]] : f32
   %29 = llvm.fneg %arg1 : f32
 
 // CHECK: "llvm.intr.sin"(%[[FLOAT]]) : (f32) -> f32
   %30 = "llvm.intr.sin"(%arg1) : (f32) -> f32
 
 // CHECK: "llvm.intr.pow"(%[[FLOAT]], %[[FLOAT]]) : (f32, f32) -> f32

mlir/test/Dialect/LLVMIR/types.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file | mlir-opt -allow-unregistered-dialect | FileCheck %s
 
 // CHECK-LABEL: @primitive
 func @primitive() {
   // CHECK: !llvm.void
   "some.op"() : () -> !llvm.void
   // CHECK: f16
   "some.op"() : () -> f16
   // CHECK: bf16
   "some.op"() : () -> bf16
   // CHECK: f32
   "some.op"() : () -> f32
   // CHECK: f64
   "some.op"() : () -> f64
-  // CHECK: !llvm.fp128
-  "some.op"() : () -> !llvm.fp128
-  // CHECK: !llvm.x86_fp80
-  "some.op"() : () -> !llvm.x86_fp80
+  // CHECK: f128
+  "some.op"() : () -> f128
+  // CHECK: f80
+  "some.op"() : () -> f80
   // CHECK: !llvm.ppc_fp128
   "some.op"() : () -> !llvm.ppc_fp128
   // CHECK: !llvm.x86_mmx
   "some.op"() : () -> !llvm.x86_mmx
   // CHECK: !llvm.token
   "some.op"() : () -> !llvm.token
   // CHECK: !llvm.label
   "some.op"() : () -> !llvm.label

mlir/test/IR/parser.mlir

 func private @int_types(i0, i1, i2, i4, i7, i87) -> (i1, index, i19)
 
 // CHECK: func private @sint_types(si2, si4) -> (si7, si1023)
 func private @sint_types(si2, si4) -> (si7, si1023)
 
 // CHECK: func private @uint_types(ui2, ui4) -> (ui7, ui1023)
 func private @uint_types(ui2, ui4) -> (ui7, ui1023)
 
+// CHECK: func private @float_types(f80, f128)
+func private @float_types(f80, f128)
 
 // CHECK: func private @vectors(vector<1xf32>, vector<2x4xf32>)
 func private @vectors(vector<1 x f32>, vector<2x4xf32>)
 
 // CHECK: func private @tensors(tensor<*xf32>, tensor<*xvector<2x4xf32>>, tensor<1x?x4x?x?xi32>, tensor<i8>)
 func private @tensors(tensor<* x f32>, tensor<* x vector<2x4xf32>>,
                  tensor<1x?x4x?x?xi32>, tensor<i8>)
 

mlir/test/Target/llvmir-types.mlir

 llvm.func @return_half() -> f16
 // CHECK: declare bfloat @return_bfloat()
 llvm.func @return_bfloat() -> bf16
 // CHECK: declare float @return_float()
 llvm.func @return_float() -> f32
 // CHECK: declare double @return_double()
 llvm.func @return_double() -> f64
 // CHECK: declare fp128 @return_fp128()
-llvm.func @return_fp128() -> !llvm.fp128
+llvm.func @return_fp128() -> f128
 // CHECK: declare x86_fp80 @return_x86_fp80()
-llvm.func @return_x86_fp80() -> !llvm.x86_fp80
+llvm.func @return_x86_fp80() -> f80
 // CHECK: declare ppc_fp128 @return_ppc_fp128()
 llvm.func @return_ppc_fp128() -> !llvm.ppc_fp128
 // CHECK: declare x86_mmx @return_x86_mmx()
 llvm.func @return_x86_mmx() -> !llvm.x86_mmx
 
 //
 // Functions.
 //

mlir/utils/gdb-scripts/prettyprinters.py

for name in [
     'SparseElementsAttr',
     # mlir/IR/BuiltinTypes.h
     'ComplexType',
     'IndexType',
     'IntegerType',
     'Float16Type',
     'Float32Type',
     'Float64Type',
+    'Float80Type',
+    'Float128Type',
     'NoneType',
     'VectorType',
     'RankedTensorType',
     'UnrankedTensorType',
     'MemRefType',
     'UnrankedMemRefType',
     'TupleType',
     # mlir/IR/Location.h