[flang][fir][NFC] Move CharacterType and BoxCharType to TableGen type definition

[clementval]

Summary

This patch is a follow up of D96422 and move CharacterType and BoxCharType to
TableGen.

[clementval]

flang/include/flang/Optimizer/Dialect/FIRTypes.td

76

@mehdi_amini @rriddle I'm currently forcing this type to be generated before BoxCharType because it depends on it. Is there a better way to achieve this than adding a prefix (A_)?

[mehdi_amini]

flang/include/flang/Optimizer/Dialect/FIRTypes.td

76

Is this a matter of updating the TableGen backend to forward declare all classes before emitting the content?
I had to do this with operations a while ago for a similar reason.

141

you have a non negligible amount of C++ here, consider replacing this with simple calls to static functions implemented in the cpp file. TableGen files don't have all the C++ IDE features...

[rriddle]

flang/include/flang/Optimizer/Dialect/FIRTypes.td

88

Can you move the printer/parser to C++ instead? You just have to remove these fields and then you can provide your own definition for CharacterType::parse and CharacterType::print.

[clementval]

flang/include/flang/Optimizer/Dialect/FIRTypes.td

76

Moving the definitions in the .cpp files does the trick.

[clementval]

Address review comment + rebase

[clementval]

Rebase

[clementval]

Keep fir_ prefix

[clementval]

Rebase

flang/include/flang/Optimizer/Dialect/FIROps.h

 //===-- Optimizer/Dialect/FIROps.h - FIR operations -------------*- C++ -*-===//
 //
 // 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 OPTIMIZER_DIALECT_FIROPS_H
 #define OPTIMIZER_DIALECT_FIROPS_H
 
+#include "flang/Optimizer/Dialect/FIRType.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Interfaces/LoopLikeInterface.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
 using namespace mlir;
 
 namespace fir {
 

flang/include/flang/Optimizer/Dialect/FIROps.td

 include "flang/Optimizer/Dialect/FIRTypes.td"
 
 // Types and predicates
 
 def fir_Type : Type<CPred<"fir::isa_fir_or_std_type($_self)">,
     "FIR dialect type">;
 
 // Fortran intrinsic types
-def fir_CharacterType : Type<CPred<"$_self.isa<fir::CharacterType>()">,
-    "FIR character type">;
 def fir_ComplexType : Type<CPred<"$_self.isa<fir::ComplexType>()">,
     "FIR complex type">;
 def fir_IntegerType : Type<CPred<"$_self.isa<fir::IntegerType>()">,
     "FIR integer type">;
 def fir_LogicalType : Type<CPred<"$_self.isa<fir::LogicalType>()">,
     "FIR logical type">;
 def fir_RealType : Type<CPred<"$_self.isa<fir::RealType>()">,
     "FIR real type">;

 
 // Reference types
 def AnyReferenceLike : TypeConstraint<Or<[fir_ReferenceType.predicate,
     fir_HeapType.predicate, fir_PointerType.predicate]>, "any reference">;
 
 // A descriptor tuple (captures a reference to an entity and other information)
 def fir_BoxType : Type<CPred<"$_self.isa<fir::BoxType>()">, "box type">;
 
-// CHARACTER type descriptor. A pair of a data reference and a LEN value.
-def fir_BoxCharType : Type<CPred<"$_self.isa<fir::BoxCharType>()">,
-    "box character type">;
-
 // PROCEDURE POINTER descriptor. A pair that can capture a host closure.
 def fir_BoxProcType : Type<CPred<"$_self.isa<fir::BoxProcType>()">,
     "box procedure type">;
 
 def AnyBoxLike : TypeConstraint<Or<[fir_BoxType.predicate,
-    fir_BoxCharType.predicate, fir_BoxProcType.predicate]>, "any box">;
+    BoxCharType.predicate, fir_BoxProcType.predicate]>, "any box">;
 
 def AnyRefOrBox : TypeConstraint<Or<[fir_ReferenceType.predicate,
     fir_HeapType.predicate, fir_PointerType.predicate, fir_BoxType.predicate]>,
     "any reference or box">;
 
 def AnyShapeLike : TypeConstraint<Or<[ShapeType.predicate,
     ShapeShiftType.predicate]>, "any legal shape type">;
 def AnyShapeType : Type<AnyShapeLike.predicate, "any legal shape type">;
let description = [{
     ```
 
     In the above `%4` is a memory reference to a buffer of 10 CHARACTER units.
     This buffer and its LEN value (10) are wrapped into a pair in `%6`.
   }];
 
   let arguments = (ins AnyReferenceLike:$memref, AnyIntegerLike:$len);
 
-  let results = (outs fir_BoxCharType);
+  let results = (outs BoxCharType);
 
   let assemblyFormat = [{
     $memref `,` $len attr-dict `:` functional-type(operands, results)
   }];
 
   let verifier = [{
     auto eleTy = elementTypeOf(memref().getType());
     if (!eleTy.dyn_cast<CharacterType>())
let description = [{
     reference to the CHARACTER data and the LEN type parameter.
 
     ```mlir
       %45   = ... : !fir.boxchar<1>
       %46:2 = fir.unboxchar %45 : (!fir.boxchar<1>) -> (!fir.ref<!fir.character<1>>, i32)
     ```
   }];
 
-  let arguments = (ins fir_BoxCharType:$boxchar);
+  let arguments = (ins BoxCharType:$boxchar);
 
   let results = (outs fir_ReferenceType, AnyIntegerLike);
 }
 
 def fir_UnboxProcOp : fir_SimpleOp<"unboxproc", [NoSideEffect]> {
   let summary = "unbox a boxproc value into a pair value";
 
   let description = [{
let description = [{
     Extracts the LEN type parameter from a `boxchar` value.
 
     ```mlir
       %45 = ... : !boxchar<1>  // CHARACTER(20)
       %59 = fir.boxchar_len %45 : (!fir.boxchar<1>) -> i64  // len=20
     ```
   }];
 
-  let arguments = (ins fir_BoxCharType:$val);
+  let arguments = (ins BoxCharType:$val);
 
   let results = (outs AnyIntegerLike);
 
   let hasFolder = 1;
 }
 
 def fir_BoxDimsOp : fir_Op<"box_dims", [NoSideEffect]> {
   let summary = "return the dynamic dimension information for the boxed value";

flang/include/flang/Optimizer/Dialect/FIRType.h

 namespace fir {
 
 class FIROpsDialect;
 
 using KindTy = unsigned;
 
 namespace detail {
 struct BoxTypeStorage;
-struct BoxCharTypeStorage;
 struct BoxProcTypeStorage;
-struct CharacterTypeStorage;
 struct ComplexTypeStorage;
 struct FieldTypeStorage;
 struct HeapTypeStorage;
 struct IntegerTypeStorage;
 struct LenTypeStorage;
 struct LogicalTypeStorage;
 struct PointerTypeStorage;
 struct RealTypeStorage;

 bool isa_aggregate(mlir::Type t);
 
 /// Extract the `Type` pointed to from a FIR memory reference type. If `t` is
 /// not a memory reference type, then returns a null `Type`.
 mlir::Type dyn_cast_ptrEleTy(mlir::Type t);
 
 // Intrinsic types
 
-/// Model of the Fortran CHARACTER intrinsic type, including the KIND type
-/// parameter. The model optionally includes a LEN type parameter. A
-/// CharacterType is thus the type of both a single character value and a
-/// character with a LEN parameter.
-class CharacterType
-    : public mlir::Type::TypeBase<CharacterType, mlir::Type,
-                                  detail::CharacterTypeStorage> {
-public:
-  using Base::Base;
-  using LenType = std::int64_t;
-
-  static CharacterType get(mlir::MLIRContext *ctxt, KindTy kind, LenType len);
-  /// Return unknown length CHARACTER type.
-  static CharacterType getUnknownLen(mlir::MLIRContext *ctxt, KindTy kind) {
-    return get(ctxt, kind, unknownLen());
-  }
-  /// Return length 1 CHARACTER type.
-  static CharacterType getSingleton(mlir::MLIRContext *ctxt, KindTy kind) {
-    return get(ctxt, kind, singleton());
-  }
-  KindTy getFKind() const;
-
-  /// CHARACTER is a singleton and has a LEN of 1.
-  static constexpr LenType singleton() { return 1; }
-  /// CHARACTER has an unknown LEN property.
-  static constexpr LenType unknownLen() { return -1; }
-
-  /// Access to a CHARACTER's LEN property. Defaults to 1.
-  LenType getLen() const;
-};
-
 /// Model of a Fortran COMPLEX intrinsic type, including the KIND type
 /// parameter. COMPLEX is a floating point type with a real and imaginary
 /// member.
 class ComplexType : public mlir::Type::TypeBase<fir::ComplexType, mlir::Type,
                                                 detail::ComplexTypeStorage> {
 public:
   using Base::Base;
   static fir::ComplexType get(mlir::MLIRContext *ctxt, KindTy kind);
public:
   mlir::Type getEleTy() const;
   mlir::AffineMapAttr getLayoutMap() const;
 
   static mlir::LogicalResult
   verifyConstructionInvariants(mlir::Location, mlir::Type eleTy,
                                mlir::AffineMapAttr map);
 };
 
-/// The type of a pair that describes a CHARACTER variable. Specifically, a
-/// CHARACTER consists of a reference to a buffer (the string value) and a LEN
-/// type parameter (the runtime length of the buffer).
-class BoxCharType : public mlir::Type::TypeBase<BoxCharType, mlir::Type,
-                                                detail::BoxCharTypeStorage> {
-public:
-  using Base::Base;
-  static BoxCharType get(mlir::MLIRContext *ctxt, KindTy kind);
-  CharacterType getEleTy() const;
-};
-
 /// The type of a pair that describes a PROCEDURE reference. Pointers to
 /// internal procedures must carry an additional reference to the host's
 /// variables that are referenced.
 class BoxProcType : public mlir::Type::TypeBase<BoxProcType, mlir::Type,
                                                 detail::BoxProcTypeStorage> {
 public:
   using Base::Base;
   static BoxProcType get(mlir::Type eleTy);

flang/include/flang/Optimizer/Dialect/FIRTypes.td

let parser = [{
     if ($_parser.parseInteger(rank))
       return Type();
     if ($_parser.parseGreater())
       return Type();
     return get(context, rank);
   }];
 }
 
+def CharacterType : FIR_Type<"Character", "char"> {
+  let summary = "FIR character type";
+
+  let description = [{
+    Model of the Fortran CHARACTER intrinsic type, including the KIND type
+    parameter. The model optionally includes a LEN type parameter. A
+    CharacterType is thus the type of both a single character value and a
+    character with a LEN parameter.
+  }];
+
+  let parameters = (ins "KindTy":$FKind, "CharacterType::LenType":$len);
+
+  let extraClassDeclaration = [{
+    using KindTy = unsigned;
+    using LenType = std::int64_t;
+
+    // Return unknown length CHARACTER type.
+    static CharacterType getUnknownLen(mlir::MLIRContext *ctxt, KindTy kind) {
+      return get(ctxt, kind, unknownLen());
+    }
+
+    // Return length 1 CHARACTER type.
+    static CharacterType getSingleton(mlir::MLIRContext *ctxt, KindTy kind) {
+      return get(ctxt, kind, singleton());
+    }
+
+    // CHARACTER is a singleton and has a LEN of 1.
+    static constexpr LenType singleton() { return 1; }
+    // CHARACTER has an unknown LEN property.
+    static constexpr LenType unknownLen() { return -1; }
+  }];
+}
+
+def BoxCharType : FIR_Type<"BoxChar", "boxchar"> {
+  let summary = "CHARACTER type descriptor.";
+
+  let description = [{
+    The type of a pair that describes a CHARACTER variable. Specifically, a
+    CHARACTER consists of a reference to a buffer (the string value) and a LEN
+    type parameter (the runtime length of the buffer).
+  }];
+
+  let parameters = (ins "KindTy":$kind);
+
+  let printer = [{
+    $_printer << "boxchar<" << getImpl()->kind << ">";
+  }];
+
+  let genAccessors = 1;
+
+  let extraClassDeclaration = [{
+    using KindTy = unsigned;
+
+    // a !fir.boxchar<k> always wraps a !fir.char<k, ?>
+    CharacterType getElementType(mlir::MLIRContext *context) const;
+
+    CharacterType getEleTy() const;
+  }];
+}
+
 #endif // FIR_DIALECT_FIR_TYPES

flang/lib/Optimizer/Dialect/FIRType.cpp

if (!parser.parseOptionalComma())
     }
   if (parser.parseGreater()) {
     parser.emitError(parser.getCurrentLocation(), "expected '>'");
     return {};
   }
   return BoxType::get(ofTy, map);
 }
 
-// `boxchar` `<` kind `>`
-BoxCharType parseBoxChar(mlir::DialectAsmParser &parser) {
-  return parseKindSingleton<BoxCharType>(parser);
-}
-
 // `boxproc` `<` return-type `>`
 BoxProcType parseBoxProc(mlir::DialectAsmParser &parser, mlir::Location loc) {
   return parseTypeSingleton<BoxProcType>(parser, loc);
 }
 
-// `char` `<` kind [`,` `len`] `>`
-CharacterType parseCharacter(mlir::DialectAsmParser &parser) {
-  int kind = 0;
-  if (parser.parseLess() || parser.parseInteger(kind)) {
-    parser.emitError(parser.getCurrentLocation(), "kind value expected");
-    return {};
-  }
-  CharacterType::LenType len = 1;
-  if (mlir::succeeded(parser.parseOptionalComma())) {
-    if (mlir::succeeded(parser.parseOptionalQuestion())) {
-      len = fir::CharacterType::unknownLen();
-    } else if (!mlir::succeeded(parser.parseInteger(len))) {
-      parser.emitError(parser.getCurrentLocation(), "len value expected");
-      return {};
-    }
-  }
-  if (parser.parseGreater())
-    return {};
-  return CharacterType::get(parser.getBuilder().getContext(), kind, len);
-}
-
 // `complex` `<` kind `>`
 fir::ComplexType parseComplex(mlir::DialectAsmParser &parser) {
   return parseKindSingleton<fir::ComplexType>(parser);
 }
 
 // `slice` `<` rank `>`
 SliceType parseSlice(mlir::DialectAsmParser &parser) {
   return parseRankSingleton<SliceType>(parser);

 // Implementation of the thin interface from dialect to type parser
 
 mlir::Type fir::parseFirType(FIROpsDialect *dialect,
                              mlir::DialectAsmParser &parser) {
   llvm::StringRef typeNameLit;
   if (mlir::failed(parser.parseKeyword(&typeNameLit)))
     return {};
 
+  // TODO all TYPE::parse can be move to generatedTypeParser when all types
+  // have been moved
+
   auto loc = parser.getEncodedSourceLoc(parser.getNameLoc());
   if (typeNameLit == "array")
     return parseSequence(parser, loc);
   if (typeNameLit == "box")
     return parseBox(parser, loc);
   if (typeNameLit == "boxchar")
-    return parseBoxChar(parser);
+    return generatedTypeParser(dialect->getContext(), parser, typeNameLit);
   if (typeNameLit == "boxproc")
     return parseBoxProc(parser, loc);
   if (typeNameLit == "char")
-    return parseCharacter(parser);
+    return generatedTypeParser(dialect->getContext(), parser, typeNameLit);
   if (typeNameLit == "complex")
     return parseComplex(parser);
   if (typeNameLit == "field")
     return parseField(parser);
   if (typeNameLit == "heap")
     return parseHeap(parser, loc);
   if (typeNameLit == "int")
     return parseInteger(parser);
mlir::Type fir::parseFirType(FIROpsDialect *dialect,
   return {};
 }
 
 namespace fir {
 namespace detail {
 
 // Type storage classes
 
-/// `CHARACTER` storage
-struct CharacterTypeStorage : public mlir::TypeStorage {
-  using KeyTy = std::tuple<KindTy, CharacterType::LenType>;
-
-  static unsigned hashKey(const KeyTy &key) {
-    auto hashVal = llvm::hash_combine(std::get<0>(key));
-    return llvm::hash_combine(hashVal, llvm::hash_combine(std::get<1>(key)));
-  }
-
-  bool operator==(const KeyTy &key) const {
-    return key == KeyTy{getFKind(), getLen()};
-  }
-
-  static CharacterTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
-                                         const KeyTy &key) {
-    auto *storage = allocator.allocate<CharacterTypeStorage>();
-    return new (storage)
-        CharacterTypeStorage{std::get<0>(key), std::get<1>(key)};
-  }
-
-  KindTy getFKind() const { return kind; }
-  CharacterType::LenType getLen() const { return len; }
-
-protected:
-  KindTy kind;
-  CharacterType::LenType len;
-
-private:
-  CharacterTypeStorage() = delete;
-  explicit CharacterTypeStorage(KindTy kind, CharacterType::LenType len)
-      : kind{kind}, len{len} {}
-};
-
 struct SliceTypeStorage : public mlir::TypeStorage {
   using KeyTy = unsigned;
 
   static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
 
   bool operator==(const KeyTy &key) const { return key == getRank(); }
 
   static SliceTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
protected:
   mlir::AffineMapAttr map;
 
 private:
   BoxTypeStorage() = delete;
   explicit BoxTypeStorage(mlir::Type eleTy, mlir::AffineMapAttr map)
       : eleTy{eleTy}, map{map} {}
 };
 
-/// Boxed CHARACTER object type
-struct BoxCharTypeStorage : public mlir::TypeStorage {
-  using KeyTy = KindTy;
-
-  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
-
-  bool operator==(const KeyTy &key) const { return key == getFKind(); }
-
-  static BoxCharTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
-                                       KindTy kind) {
-    auto *storage = allocator.allocate<BoxCharTypeStorage>();
-    return new (storage) BoxCharTypeStorage{kind};
-  }
-
-  KindTy getFKind() const { return kind; }
-
-  // a !fir.boxchar<k> always wraps a !fir.char<k, ?>
-  CharacterType getElementType(mlir::MLIRContext *ctxt) const {
-    return CharacterType::getUnknownLen(ctxt, getFKind());
-  }
-
-protected:
-  KindTy kind;
-
-private:
-  BoxCharTypeStorage() = delete;
-  explicit BoxCharTypeStorage(KindTy kind) : kind{kind} {}
-};
-
 /// Boxed PROCEDURE POINTER object type
 struct BoxProcTypeStorage : public mlir::TypeStorage {
   using KeyTy = mlir::Type;
 
   static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
 
   bool operator==(const KeyTy &key) const { return key == getElementType(); }
 
mlir::Type dyn_cast_ptrEleTy(mlir::Type t) {
   return llvm::TypeSwitch<mlir::Type, mlir::Type>(t)
       .Case<fir::ReferenceType, fir::PointerType, fir::HeapType>(
           [](auto p) { return p.getEleTy(); })
       .Default([](mlir::Type) { return mlir::Type{}; });
 }
 
 } // namespace fir
 
-// CHARACTER
-
-CharacterType fir::CharacterType::get(mlir::MLIRContext *ctxt, KindTy kind,
-                                      CharacterType::LenType len) {
-  return Base::get(ctxt, kind, len);
-}
-
-KindTy fir::CharacterType::getFKind() const { return getImpl()->getFKind(); }
-
-CharacterType::LenType fir::CharacterType::getLen() const {
-  return getImpl()->getLen();
-}
-
 // Field
 
 FieldType fir::FieldType::get(mlir::MLIRContext *ctxt) {
   return Base::get(ctxt, 0);
 }
 
 // Len
 

 
 mlir::LogicalResult
 fir::BoxType::verifyConstructionInvariants(mlir::Location, mlir::Type eleTy,
                                            mlir::AffineMapAttr map) {
   // TODO
   return mlir::success();
 }
 
-// BoxChar<C>
-
-BoxCharType fir::BoxCharType::get(mlir::MLIRContext *ctxt, KindTy kind) {
-  return Base::get(ctxt, kind);
-}
-
-CharacterType fir::BoxCharType::getEleTy() const {
-  return getImpl()->getElementType(getContext());
-}
-
 // BoxProc<T>
 
 BoxProcType fir::BoxProcType::get(mlir::Type elementType) {
   return Base::get(elementType.getContext(), elementType);
 }
 
 mlir::Type fir::BoxProcType::getEleTy() const {
   return getImpl()->getElementType();
if (auto type = ty.dyn_cast<BoxType>()) {
     p.printType(type.getEleTy());
     if (auto map = type.getLayoutMap()) {
       os << ", ";
       p.printAttribute(map);
     }
     os << '>';
     return;
   }
-  if (auto type = ty.dyn_cast<BoxCharType>()) {
-    os << "boxchar<" << type.getEleTy().cast<fir::CharacterType>().getFKind()
-       << '>';
-    return;
-  }
   if (auto type = ty.dyn_cast<BoxProcType>()) {
     os << "boxproc<";
     p.printType(type.getEleTy());
     os << '>';
     return;
   }
-  if (auto chTy = ty.dyn_cast<CharacterType>()) {
-    // Fortran intrinsic type CHARACTER
-    os << "char<" << chTy.getFKind();
-    auto len = chTy.getLen();
-    if (len != fir::CharacterType::singleton()) {
-      os << ',';
-      if (len == fir::CharacterType::unknownLen())
-        os << '?';
-      else
-        os << len;
-    }
-    os << '>';
-    return;
-  }
   if (auto type = ty.dyn_cast<fir::ComplexType>()) {
     // Fortran intrinsic type COMPLEX
     os << "complex<" << type.getFKind() << '>';
     return;
   }
   if (auto type = ty.dyn_cast<RecordType>()) {
     // Fortran derived type
     os << "type<" << type.getName();
if (auto boxTy = t.dyn_cast<fir::BoxType>()) {
     if (eleTy.isa<mlir::NoneType>())
       return true;
     if (auto seqTy = eleTy.dyn_cast<fir::SequenceType>())
       if (seqTy.hasUnknownShape())
         return true;
   }
   return false;
 }
+
+namespace fir {
+
+//===----------------------------------------------------------------------===//
+// BoxCharType
+//===----------------------------------------------------------------------===//
+
+mlir::Type BoxCharType::parse(mlir::MLIRContext *context,
+                              mlir::DialectAsmParser &parser) {
+  int kind = 0;
+  if (parser.parseLess() || parser.parseInteger(kind) ||
+      parser.parseGreater()) {
+    parser.emitError(parser.getCurrentLocation(), "kind value expected");
+    return Type();
+  }
+  return get(context, kind);
+}
+
+CharacterType BoxCharType::getElementType(mlir::MLIRContext *context) const {
+  return CharacterType::getUnknownLen(context, getKind());
+}
+
+CharacterType BoxCharType::getEleTy() const {
+  return getElementType(getContext());
+}
+
+//===----------------------------------------------------------------------===//
+// CharacterType
+//===----------------------------------------------------------------------===//
+
+// `char` `<` kind [`,` `len`] `>`
+mlir::Type CharacterType::parse(mlir::MLIRContext *context,
+                                mlir::DialectAsmParser &parser) {
+  int kind = 0;
+  if (parser.parseLess() || parser.parseInteger(kind)) {
+    parser.emitError(parser.getCurrentLocation(), "kind value expected");
+    return Type();
+  }
+  CharacterType::LenType len = 1;
+  if (mlir::succeeded(parser.parseOptionalComma())) {
+    if (mlir::succeeded(parser.parseOptionalQuestion())) {
+      len = fir::CharacterType::unknownLen();
+    } else if (!mlir::succeeded(parser.parseInteger(len))) {
+      parser.emitError(parser.getCurrentLocation(), "len value expected");
+      return Type();
+    }
+  }
+  if (parser.parseGreater())
+    return Type();
+  return get(context, kind, len);
+}
+
+void CharacterType::print(::mlir::DialectAsmPrinter &printer) const {
+  printer << "char<" << getFKind();
+  auto len = getLen();
+  if (len != fir::CharacterType::singleton()) {
+    printer << ',';
+    if (len == fir::CharacterType::unknownLen())
+      printer << '?';
+    else
+      printer << len;
+  }
+  printer << '>';
+}
+
+} // namespace fir