Move LLVM::FMFAttr definition to TableGen (NFC)

[mehdi_amini]

Summary

This is using the new Attribute storage generation support in
TableGen to define the LLVM FastMathFlags.

mlir/include/mlir/Dialect/LLVMIR/CMakeLists.txt

 add_subdirectory(Transforms)
 
+set(LLVM_TARGET_DEFINITIONS LLVMAttrDefs.td)
+mlir_tablegen(LLVMOpsAttrDefs.h.inc -gen-attrdef-decls)
+mlir_tablegen(LLVMOpsAttrDefs.cpp.inc -gen-attrdef-defs)
+add_public_tablegen_target(MLIRLLVMAttrsIncGen)
+
 set(LLVM_TARGET_DEFINITIONS LLVMOps.td)
 mlir_tablegen(LLVMOps.h.inc -gen-op-decls)
 mlir_tablegen(LLVMOps.cpp.inc -gen-op-defs)
 mlir_tablegen(LLVMOpsDialect.h.inc -gen-dialect-decls)
 mlir_tablegen(LLVMOpsEnums.h.inc -gen-enum-decls)
 mlir_tablegen(LLVMOpsEnums.cpp.inc -gen-enum-defs)
 add_public_tablegen_target(MLIRLLVMOpsIncGen)
 

mlir/include/mlir/Dialect/LLVMIR/LLVMAttrDefs.td

+//===-- LLVMAttrDefs.td - LLVM Attributes definition file --*- tablegen -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVMIR_ATTRDEFS
+#define LLVMIR_ATTRDEFS
+
+include "mlir/Dialect/LLVMIR/LLVMOpBase.td"
+
+
+// All of the attributes will extend this class.
+class LLVM_Attr<string name> : AttrDef<LLVM_Dialect, name>;
+
+// The "FastMath" flags associated with floating point LLVM instructions.
+def FastmathFlagsAttr : LLVM_Attr<"FMF"> {
+  let mnemonic = "fastmath";
+
+  // List of type parameters.
+  let parameters = (
+    ins
+    "FastmathFlags":$flags
+  );
+}
+
+#endif // LLVMIR_ATTRDEFS

mlir/include/mlir/Dialect/LLVMIR/LLVMDialect.h

 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 
 #include "mlir/Dialect/LLVMIR/LLVMOpsEnums.h.inc"
 #include "mlir/Dialect/LLVMIR/LLVMOpsInterfaces.h.inc"
+#define GET_ATTRDEF_CLASSES
+#include "mlir/Dialect/LLVMIR/LLVMOpsAttrDefs.h.inc"
 
 namespace llvm {
 class Type;
 class LLVMContext;
 namespace sys {
 template <bool mt_only>
 class SmartMutex;
 } // end namespace sys
 } // end namespace llvm
 
 namespace mlir {
 namespace LLVM {
 class LLVMDialect;
 
 namespace detail {
 struct LLVMTypeStorage;
 struct LLVMDialectImpl;
-struct BitmaskEnumStorage;
 struct LoopOptionAttrStorage;
 } // namespace detail
 
-/// An attribute that specifies LLVM instruction fastmath flags.
-class FMFAttr : public Attribute::AttrBase<FMFAttr, Attribute,
-                                           detail::BitmaskEnumStorage> {
-public:
-  using Base::Base;
-
-  static FMFAttr get(FastmathFlags flags, MLIRContext *context);
-
-  FastmathFlags getFlags() const;
-
-  void print(DialectAsmPrinter &p) const;
-  static Attribute parse(DialectAsmParser &parser);
-};
-
 /// An attribute that specifies LLVM loop codegen options.
 class LoopOptionAttr
     : public Attribute::AttrBase<LoopOptionAttr, Attribute,
                                  detail::LoopOptionAttrStorage> {
 public:
   using Base::Base;
 
   /// Specifies the llvm.loop.unroll.disable metadata.

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

 def LLVM_FMFAttr : DialectAttr<
     LLVM_Dialect,
     CPred<"$_self.isa<::mlir::LLVM::FMFAttr>()">,
     "LLVM fastmath flags"> {
   let storageType = "::mlir::LLVM::FMFAttr";
   let returnType = "::mlir::LLVM::FastmathFlags";
   let convertFromStorage = "$_self.getFlags()";
   let constBuilderCall =
-          "::mlir::LLVM::FMFAttr::get($0, $_builder.getContext())";
+          "::mlir::LLVM::FMFAttr::get($_builder.getContext(), $0)";
 }
 
 def LOptDisableUnroll : I32EnumAttrCase<"disable_unroll", 1>;
 def LOptDisableLICM : I32EnumAttrCase<"disable_licm", 2>;
 def LOptInterleaveCount : I32EnumAttrCase<"interleave_count", 3>;
 
 def LoopOptionCase : I32EnumAttr<
     "LoopOptionCase",
let llvmBuilder = [{
     $res = builder.CreateFCmp(getLLVMCmpPredicate($predicate), $lhs, $rhs);
   }];
   let builders = [
     OpBuilder<(ins "FCmpPredicate":$predicate, "Value":$lhs, "Value":$rhs,
                   CArg<"FastmathFlags", "{}">:$fmf),
     [{
       build($_builder, $_state, IntegerType::get(lhs.getType().getContext(), 1),
             $_builder.getI64IntegerAttr(static_cast<int64_t>(predicate)), lhs, rhs,
-            ::mlir::LLVM::FMFAttr::get(fmf, $_builder.getContext()));
+            ::mlir::LLVM::FMFAttr::get($_builder.getContext(), fmf));
     }]>];
   let parser = [{ return parseCmpOp<FCmpPredicate>(parser, result); }];
   let printer = [{ printFCmpOp(p, *this); }];
 }
 
 // Floating point binary operations.
 def LLVM_FAddOp : LLVM_FloatArithmeticOp<"fadd", "CreateFAdd">;
 def LLVM_FSubOp : LLVM_FloatArithmeticOp<"fsub", "CreateFSub">;

mlir/lib/Conversion/ComplexToLLVM/ComplexToLLVM.cpp

matchAndRewrite(complex::AbsOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     complex::AbsOp::Adaptor transformed(operands);
     auto loc = op.getLoc();
 
     ComplexStructBuilder complexStruct(transformed.complex());
     Value real = complexStruct.real(rewriter, op.getLoc());
     Value imag = complexStruct.imaginary(rewriter, op.getLoc());
 
-    auto fmf = LLVM::FMFAttr::get({}, op.getContext());
+    auto fmf = LLVM::FMFAttr::get(op.getContext(), {});
     Value sqNorm = rewriter.create<LLVM::FAddOp>(
         loc, rewriter.create<LLVM::FMulOp>(loc, real, real, fmf),
         rewriter.create<LLVM::FMulOp>(loc, imag, imag, fmf), fmf);
 
     rewriter.replaceOpWithNewOp<LLVM::SqrtOp>(op, sqNorm);
     return success();
   }
 };
matchAndRewrite(complex::AddOp op, ArrayRef<Value> operands,
     BinaryComplexOperands arg =
         unpackBinaryComplexOperands<complex::AddOp>(op, operands, rewriter);
 
     // Initialize complex number struct for result.
     auto structType = typeConverter->convertType(op.getType());
     auto result = ComplexStructBuilder::undef(rewriter, loc, structType);
 
     // Emit IR to add complex numbers.
-    auto fmf = LLVM::FMFAttr::get({}, op.getContext());
+    auto fmf = LLVM::FMFAttr::get(op.getContext(), {});
     Value real =
         rewriter.create<LLVM::FAddOp>(loc, arg.lhs.real(), arg.rhs.real(), fmf);
     Value imag =
         rewriter.create<LLVM::FAddOp>(loc, arg.lhs.imag(), arg.rhs.imag(), fmf);
     result.setReal(rewriter, loc, real);
     result.setImaginary(rewriter, loc, imag);
 
     rewriter.replaceOp(op, {result});
matchAndRewrite(complex::DivOp op, ArrayRef<Value> operands,
     BinaryComplexOperands arg =
         unpackBinaryComplexOperands<complex::DivOp>(op, operands, rewriter);
 
     // Initialize complex number struct for result.
     auto structType = typeConverter->convertType(op.getType());
     auto result = ComplexStructBuilder::undef(rewriter, loc, structType);
 
     // Emit IR to add complex numbers.
-    auto fmf = LLVM::FMFAttr::get({}, op.getContext());
+    auto fmf = LLVM::FMFAttr::get(op.getContext(), {});
     Value rhsRe = arg.rhs.real();
     Value rhsIm = arg.rhs.imag();
     Value lhsRe = arg.lhs.real();
     Value lhsIm = arg.lhs.imag();
 
     Value rhsSqNorm = rewriter.create<LLVM::FAddOp>(
         loc, rewriter.create<LLVM::FMulOp>(loc, rhsRe, rhsRe, fmf),
         rewriter.create<LLVM::FMulOp>(loc, rhsIm, rhsIm, fmf), fmf);
matchAndRewrite(complex::MulOp op, ArrayRef<Value> operands,
     BinaryComplexOperands arg =
         unpackBinaryComplexOperands<complex::MulOp>(op, operands, rewriter);
 
     // Initialize complex number struct for result.
     auto structType = typeConverter->convertType(op.getType());
     auto result = ComplexStructBuilder::undef(rewriter, loc, structType);
 
     // Emit IR to add complex numbers.
-    auto fmf = LLVM::FMFAttr::get({}, op.getContext());
+    auto fmf = LLVM::FMFAttr::get(op.getContext(), {});
     Value rhsRe = arg.rhs.real();
     Value rhsIm = arg.rhs.imag();
     Value lhsRe = arg.lhs.real();
     Value lhsIm = arg.lhs.imag();
 
     Value real = rewriter.create<LLVM::FSubOp>(
         loc, rewriter.create<LLVM::FMulOp>(loc, rhsRe, lhsRe, fmf),
         rewriter.create<LLVM::FMulOp>(loc, rhsIm, lhsIm, fmf), fmf);
matchAndRewrite(complex::SubOp op, ArrayRef<Value> operands,
     BinaryComplexOperands arg =
         unpackBinaryComplexOperands<complex::SubOp>(op, operands, rewriter);
 
     // Initialize complex number struct for result.
     auto structType = typeConverter->convertType(op.getType());
     auto result = ComplexStructBuilder::undef(rewriter, loc, structType);
 
     // Emit IR to substract complex numbers.
-    auto fmf = LLVM::FMFAttr::get({}, op.getContext());
+    auto fmf = LLVM::FMFAttr::get(op.getContext(), {});
     Value real =
         rewriter.create<LLVM::FSubOp>(loc, arg.lhs.real(), arg.rhs.real(), fmf);
     Value imag =
         rewriter.create<LLVM::FSubOp>(loc, arg.lhs.imag(), arg.rhs.imag(), fmf);
     result.setReal(rewriter, loc, real);
     result.setImaginary(rewriter, loc, imag);
 
     rewriter.replaceOp(op, {result});

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp

matchAndRewrite(SPIRVOp operation, ArrayRef<Value> operands,
     auto dstType = this->typeConverter.convertType(operation.getType());
     if (!dstType)
       return failure();
 
     rewriter.template replaceOpWithNewOp<LLVM::FCmpOp>(
         operation, dstType,
         rewriter.getI64IntegerAttr(static_cast<int64_t>(predicate)),
         operation.operand1(), operation.operand2(),
-        LLVM::FMFAttr::get({}, operation.getContext()));
+        LLVM::FMFAttr::get(operation.getContext(), {}));
     return success();
   }
 };
 
 /// Converts SPIR-V integer comparisons to llvm.icmp "predicate"
 template <typename SPIRVOp, LLVM::ICmpPredicate predicate>
 class IComparePattern : public SPIRVToLLVMConversion<SPIRVOp> {
 public:

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

 struct CmpFOpLowering : public ConvertOpToLLVMPattern<CmpFOp> {
   using ConvertOpToLLVMPattern<CmpFOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(CmpFOp cmpfOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     CmpFOpAdaptor transformed(operands);
 
-    auto fmf = LLVM::FMFAttr::get({}, cmpfOp.getContext());
+    auto fmf = LLVM::FMFAttr::get(cmpfOp.getContext(), {});
     rewriter.replaceOpWithNewOp<LLVM::FCmpOp>(
         cmpfOp, typeConverter->convertType(cmpfOp.getResult().getType()),
         rewriter.getI64IntegerAttr(static_cast<int64_t>(
             convertCmpPredicate<LLVM::FCmpPredicate>(cmpfOp.getPredicate()))),
         transformed.lhs(), transformed.rhs(), fmf);
 
     return success();
   }

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

 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/FunctionImplementation.h"
 #include "mlir/IR/MLIRContext.h"
 
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/ADT/TypeSwitch.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/SourceMgr.h"
 
 using namespace mlir;
 using namespace mlir::LLVM;
 
 static constexpr const char kVolatileAttrName[] = "volatile_";
 static constexpr const char kNonTemporalAttrName[] = "nontemporal";
 
 #include "mlir/Dialect/LLVMIR/LLVMOpsEnums.cpp.inc"
 #include "mlir/Dialect/LLVMIR/LLVMOpsInterfaces.cpp.inc"
+#define GET_ATTRDEF_CLASSES
+#include "mlir/Dialect/LLVMIR/LLVMOpsAttrDefs.cpp.inc"
 
 namespace mlir {
 namespace LLVM {
 namespace detail {
-struct BitmaskEnumStorage : public AttributeStorage {
-  using KeyTy = uint64_t;
-
-  BitmaskEnumStorage(KeyTy val) : value(val) {}
-
-  bool operator==(const KeyTy &key) const { return value == key; }
-
-  static BitmaskEnumStorage *construct(AttributeStorageAllocator &allocator,
-                                       const KeyTy &key) {
-    return new (allocator.allocate<BitmaskEnumStorage>())
-        BitmaskEnumStorage(key);
-  }
-
-  KeyTy value = 0;
-};
 
 struct LoopOptionAttrStorage : public AttributeStorage {
   using KeyTy = std::pair<uint64_t, int32_t>;
 
   explicit LoopOptionAttrStorage(uint64_t option, int32_t value)
       : option(option), value(value) {}
 
   bool operator==(const KeyTy &key) const {

 } // namespace detail
 } // namespace LLVM
 } // namespace mlir
 
 static auto processFMFAttr(ArrayRef<NamedAttribute> attrs) {
   SmallVector<NamedAttribute, 8> filteredAttrs(
       llvm::make_filter_range(attrs, [&](NamedAttribute attr) {
         if (attr.first == "fastmathFlags") {
-          auto defAttr = FMFAttr::get({}, attr.second.getContext());
+          auto defAttr = FMFAttr::get(attr.second.getContext(), {});
           return defAttr != attr.second;
         }
         return true;
       }));
   return filteredAttrs;
 }
 
 static ParseResult parseLLVMOpAttrs(OpAsmParser &parser,
return builder.create<LLVM::GEPOp>(
       ValueRange{cst0, cst0});
 }
 
 bool mlir::LLVM::satisfiesLLVMModule(Operation *op) {
   return op->hasTrait<OpTrait::SymbolTable>() &&
          op->hasTrait<OpTrait::IsIsolatedFromAbove>();
 }
 
-FMFAttr FMFAttr::get(FastmathFlags flags, MLIRContext *context) {
-  return Base::get(context, static_cast<uint64_t>(flags));
-}
-
-FastmathFlags FMFAttr::getFlags() const {
-  return static_cast<FastmathFlags>(getImpl()->value);
-}
-
 static constexpr const FastmathFlags FastmathFlagsList[] = {
     // clang-format off
     FastmathFlags::nnan,
     FastmathFlags::ninf,
     FastmathFlags::nsz,
     FastmathFlags::arcp,
     FastmathFlags::contract,
     FastmathFlags::afn,
     FastmathFlags::reassoc,
     FastmathFlags::fast,
     // clang-format on
 };
 
 void FMFAttr::print(DialectAsmPrinter &printer) const {
   printer << "fastmath<";
   auto flags = llvm::make_filter_range(FastmathFlagsList, [&](auto flag) {
     return bitEnumContains(this->getFlags(), flag);
   });
   llvm::interleaveComma(flags, printer,
                         [&](auto flag) { printer << stringifyEnum(flag); });
   printer << ">";
 }
 
-Attribute FMFAttr::parse(DialectAsmParser &parser) {
+Attribute FMFAttr::parse(MLIRContext *context, DialectAsmParser &parser,
+                         Type type) {
   if (failed(parser.parseLess()))
     return {};
 
   FastmathFlags flags = {};
   if (failed(parser.parseOptionalGreater())) {
     do {
       StringRef elemName;
       if (failed(parser.parseKeyword(&elemName)))
         return {};
 
       auto elem = symbolizeFastmathFlags(elemName);
       if (!elem) {
         parser.emitError(parser.getNameLoc(), "Unknown fastmath flag: ")
             << elemName;
         return {};
       }
 
       flags = flags | *elem;
     } while (succeeded(parser.parseOptionalComma()));
 
     if (failed(parser.parseGreater()))
       return {};
   }
 
-  return FMFAttr::get(flags, parser.getBuilder().getContext());
+  return FMFAttr::get(parser.getBuilder().getContext(), flags);
 }
 
 LoopOptionAttr LoopOptionAttr::getDisableUnroll(MLIRContext *context,
                                                 bool disable) {
   auto option = LoopOptionCase::disable_unroll;
   return Base::get(context, static_cast<uint64_t>(option),
                    static_cast<int32_t>(disable));
 }
Attribute LLVMDialect::parseAttribute(DialectAsmParser &parser,
                                       Type type) const {
   if (type) {
     parser.emitError(parser.getNameLoc(), "unexpected type");
     return {};
   }
   StringRef attrKind;
   if (parser.parseKeyword(&attrKind))
     return {};
-
-  if (attrKind == "fastmath")
-    return FMFAttr::parse(parser);
+  if (auto attr =
+          generatedAttributeParser(getContext(), parser, attrKind, type))
+    return attr;
 
   if (attrKind == "loopopt")
     return LoopOptionAttr::parse(parser);
 
   parser.emitError(parser.getNameLoc(), "Unknown attribute type: ") << attrKind;
   return {};
 }
 
 void LLVMDialect::printAttribute(Attribute attr, DialectAsmPrinter &os) const {
-  if (auto fmf = attr.dyn_cast<FMFAttr>())
-    fmf.print(os);
-  else if (auto lopt = attr.dyn_cast<LoopOptionAttr>())
+  if (succeeded(generatedAttributePrinter(attr, os)))
+    return;
+  if (auto lopt = attr.dyn_cast<LoopOptionAttr>())
     lopt.print(os);
   else
     llvm_unreachable("Unknown attribute type");
 }