[flang][fir][NFC] Merge tablegen files.

[schweitz]

Summary

NFC to get these files synched.

flang/include/flang/Optimizer/Dialect/FIRDialect.td

+//===-- FIRDialect.td - FIR dialect definition -------------*- 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// Definition of the FIR dialect
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_DIALECT_FIR_DIALECT
+#define FORTRAN_DIALECT_FIR_DIALECT
+
+def fir_Dialect : Dialect {
+  let name = "fir";
+  let cppNamespace = "::fir";
+}
+
+#endif // FORTRAN_DIALECT_FIR_DIALECT

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

 #define FORTRAN_DIALECT_FIR_OPS
 
 include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/LoopLikeInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
-def fir_Dialect : Dialect {
-  let name = "fir";
-  let cppNamespace = "::fir";
-}
-
 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

 // Reference to a POINTER attribute type
 def fir_PointerType : Type<CPred<"$_self.isa<fir::PointerType>()">,
     "pointer type">;
 
 // Reference types
 def AnyReferenceLike : TypeConstraint<Or<[fir_ReferenceType.predicate,
     fir_HeapType.predicate, fir_PointerType.predicate]>, "any reference">;
 
-def AnyBoxLike : TypeConstraint<Or<[BoxType.predicate,
+def AnyBoxLike : TypeConstraint<Or<[fir_BoxType.predicate,
     fir_BoxCharType.predicate, fir_BoxProcType.predicate]>, "any box">;
 
 def AnyRefOrBox : TypeConstraint<Or<[fir_ReferenceType.predicate,
-    fir_HeapType.predicate, fir_PointerType.predicate, BoxType.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 AnyShapeLike : TypeConstraint<Or<[fir_ShapeType.predicate,
+    fir_ShapeShiftType.predicate]>, "any legal shape type">;
 def AnyShapeType : Type<AnyShapeLike.predicate, "any legal shape type">;
 def fir_SliceType : Type<CPred<"$_self.isa<fir::SliceType>()">, "slice type">;
 
 def AnyEmboxLike : TypeConstraint<Or<[AnySignlessInteger.predicate,
     Index.predicate, fir_IntegerType.predicate]>,
     "any legal embox argument type">;
 def AnyEmboxArg : Type<AnyEmboxLike.predicate, "embox argument type">;
 
let description = [{
     ```
 
     The descriptor tuple may contain additional implementation-specific
     information through the use of additional attributes.
   }];
 
   let arguments = (ins AnyReferenceLike:$memref, Variadic<AnyEmboxArg>:$args);
 
-  let results = (outs BoxType);
+  let results = (outs fir_BoxType);
 
   let parser = "return parseEmboxOp(parser, result);";
 
   let printer = [{
     p << getOperationName() << ' ';
     p.printOperand(memref());
     if (hasLenParams()) {
       p << '(';
let description = [{
     size rank).
 
     ```mlir
       %40   = ... : !fir.box<!fir.type<T>>
       %41:6 = fir.unbox %40 : (!fir.box<!fir.type<T>>) -> (!fir.ref<!fir.type<T>>, i32, i32, !fir.tdesc<!fir.type<T>>, i32, !fir.dims<4>)
     ```
   }];
 
-  let arguments = (ins BoxType:$box);
+  let arguments = (ins fir_BoxType:$box);
 
   let results = (outs
     fir_ReferenceType,  // pointer to data
     AnyIntegerLike,     // size of a data element
     AnyIntegerLike,     // rank of data
     fir_TypeDescType,   // abstract type descriptor
     AnyIntegerLike,     // attribute flags (bitfields)
     fir_SequenceType    // dimension information (if any)
let description = [{
 
     ```mlir
       %51 = fir.box_addr %box : (!fir.box<f64>) -> !fir.ref<f64>
       %52 = fir.box_addr %boxchar : (!fir.boxchar<1>) -> !fir.ref<!fir.char<1>>
       %53 = fir.box_addr %boxproc : (!fir.boxproc<!P>) -> !fir.ref<!P>
     ```
   }];
 
-  let arguments = (ins BoxType:$val);
+  let arguments = (ins fir_BoxType:$val);
 
   let results = (outs AnyReferenceLike);
 
   let hasFolder = 1;
 }
 
 def fir_BoxCharLenOp : fir_SimpleOp<"boxchar_len", [NoSideEffect]> {
   let summary = "return the LEN type parameter from a boxchar value";
```mlir
       %c1   = constant 0 : i32
       %52:3 = fir.box_dims %40, %c1 : (!fir.box<!fir.array<*:f64>>, i32) -> (i32, i32, i32)
     ```
 
     The above is a request to return the left most row (at index 0) triple from
     the box. The triple will be the lower bound, upper bound, and stride.
   }];
 
-  let arguments = (ins BoxType:$val, AnyIntegerLike:$dim);
+  let arguments = (ins fir_BoxType:$val, AnyIntegerLike:$dim);
 
   let results = (outs AnyIntegerLike, AnyIntegerLike, AnyIntegerLike);
 
   let assemblyFormat = [{
     $val `,` $dim attr-dict `:` functional-type(operands, results)
   }];
 
   let extraClassDeclaration = [{
```mlir
       %53 = fir.box_elesize %40 : (!fir.box<f32>, i32) -> i32  // size=4
       %54 = fir.box_elesize %40 : (!fir.box<!fir.array<*:f32>>, i32) -> i32
     ```
 
     In the above example, `%53` may box an array of REAL values while `%54`
     must box an array of REAL values (with dynamic rank and extent).
   }];
 
-  let arguments = (ins BoxType:$val);
+  let arguments = (ins fir_BoxType:$val);
 
   let results = (outs AnyIntegerLike);
 }
 
 def fir_BoxIsAllocOp : fir_SimpleOp<"box_isalloc", [NoSideEffect]> {
   let summary = "is the boxed value an ALLOCATABLE?";
 
   let description = [{
     Determine if the boxed value was from an ALLOCATABLE entity. This will
     return true if the originating box value was from a `fir.embox` op
     with a mem-ref value that had the type !fir.heap<T>.
 
     ```mlir
       %r = ... : !fir.heap<i64>
       %b = fir.embox %r : (!fir.heap<i64>) -> !fir.box<i64>
       %a = fir.box_isalloc %b : (!fir.box<i64>) -> i1  // true
     ```
 
     The canonical descriptor implementation will carry a flag to record if the
     variable is an `ALLOCATABLE`.
   }];
 
-  let arguments = (ins BoxType:$val);
+  let arguments = (ins fir_BoxType:$val);
 
   let results = (outs BoolLike);
 }
 
 def fir_BoxIsArrayOp : fir_SimpleOp<"box_isarray", [NoSideEffect]> {
   let summary = "is the boxed value an array?";
 
   let description = [{
     Determine if the boxed value has a positive (> 0) rank. This will return
     true if the originating box value was from a fir.embox with a memory
     reference value that had the type !fir.array<T> and/or a dims argument.
 
     ```mlir
       %r = ... : !fir.ref<i64>
       %d = fir.gendims(1, 100, 1) : (i32, i32, i32) -> !fir.dims<1>
       %b = fir.embox %r, %d : (!fir.ref<i64>, !fir.dims<1>) -> !fir.box<i64>
       %a = fir.box_isarray %b : (!fir.box<i64>) -> i1  // true
     ```
   }];
 
-  let arguments = (ins BoxType:$val);
+  let arguments = (ins fir_BoxType:$val);
 
   let results = (outs BoolLike);
 }
 
 def fir_BoxIsPtrOp : fir_SimpleOp<"box_isptr", [NoSideEffect]> {
   let summary = "is the boxed value a POINTER?";
 
   let description = [{
     Determine if the boxed value was from a POINTER entity.
 
     ```mlir
       %p = ... : !fir.ptr<i64>
       %b = fir.embox %p : (!fir.ptr<i64>) -> !fir.box<i64>
       %a = fir.box_isptr %b : (!fir.box<i64>) -> i1  // true
     ```
   }];
 
-  let arguments = (ins BoxType:$val);
+  let arguments = (ins fir_BoxType:$val);
 
   let results = (outs BoolLike);
 }
 
 def fir_BoxProcHostOp : fir_SimpleOp<"boxproc_host", [NoSideEffect]> {
   let summary = "returns the host instance pointer (or null)";
 
   let description = [{
```mlir
       %58 = fir.box_rank %41 : (!fir.box<f64>) -> i32
     ```
 
     The example `%57` shows how one would determine the rank of an array that
     has deferred rank at runtime. This rank should be at least 1. In %58, the
     descriptor may be either an array or a scalar, so the value is nonnegative.
   }];
 
-  let arguments = (ins BoxType:$val);
+  let arguments = (ins fir_BoxType:$val);
 
   let results = (outs AnyIntegerType);
 }
 
 def fir_BoxTypeDescOp : fir_SimpleOneResultOp<"box_tdesc", [NoSideEffect]> {
   let summary = "return the type descriptor for the boxed value";
 
   let description = [{
     Return the opaque type descriptor of a value of `box` type. A type
     descriptor is an implementation defined value that fully describes a type
     to the Fortran runtime.
 
     ```mlir
       %7 = fir.box_tdesc %41 : (!fir.box<f64>) -> !fir.tdesc<f64>
     ```
   }];
 
-  let arguments = (ins BoxType:$val);
+  let arguments = (ins fir_BoxType:$val);
 
   let results = (outs fir_TypeDescType);
 }
 
 // Record and array type operations
 
 def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]> {
   let summary = "Finds the coordinate (location) of a value in memory";
if (fir::isa_ref_type(refTy)) {
           return emitOpError("cannot find coordinate with unknown extents");
       }
     }
     // Recovering a LEN type parameter only makes sense from a boxed value
     for (auto co : coor())
       if (dyn_cast_or_null<LenParamIndexOp>(co.getDefiningOp())) {
         if (getNumOperands() != 2)
           return emitOpError("len_param_index must be last argument");
-        if (!ref().getType().dyn_cast<BoxType>())
+        if (!ref().getType().dyn_cast<fir::BoxType>())
           return emitOpError("len_param_index must be used on box type");
       }
     if (auto attr = (*this)->getAttr(CoordinateOp::baseType())) {
       if (!attr.isa<mlir::TypeAttr>())
         return emitOpError("improperly constructed");
     } else {
       return emitOpError("must have base type");
     }
let description = [{
 
     ```mlir
       %r = fir.dispatch methodA(%o) : (!fir.box<none>) -> i32
     ```
   }];
 
   let arguments = (ins
     StrAttr:$method,
-    BoxType:$object,
+    fir_BoxType:$object,
     Variadic<AnyType>:$args
   );
 
   let results = (outs Variadic<AnyType>);
 
   let parser = [{
     mlir::FunctionType calleeType;
     llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> operands;

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

 //===- FIRTypes.td - FIR types -----------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the FIR dialect types.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FIR_DIALECT_FIR_TYPES
 #define FIR_DIALECT_FIR_TYPES
 
+include "flang/Optimizer/Dialect/FIRDialect.td"
+
 //===----------------------------------------------------------------------===//
 // FIR Types
 //===----------------------------------------------------------------------===//
 
 class FIR_Type<string name, string typeMnemonic> : TypeDef<fir_Dialect, name> {
   let mnemonic = typeMnemonic;
 }
 
+def fir_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;
+  }];
+}
+
 def fir_BoxProcType : FIR_Type<"BoxProc", "boxproc"> {
   let summary = "";
 
   let description = [{
     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.
   }];
 
   let parameters = (ins "mlir::Type":$eleTy);
 
   let printer = [{
     $_printer << "boxproc<";
     $_printer.printType(getEleTy());
     $_printer << '>';
   }];
 
   let genAccessors = 1;
-
   let genVerifyInvariantsDecl = 1;
 }
 
-def BoxType : FIR_Type<"Box", "box"> {
+def fir_BoxType : FIR_Type<"Box", "box"> {
   let summary = "The type of a Fortran descriptor";
 
   let description = [{
     Descriptors are tuples of information that describe an entity being passed
     from a calling context. This information might include (but is not limited
     to) whether the entity is an array, its size, or what type it has.
   }];
 
   let parameters = (ins "mlir::Type":$eleTy, "mlir::AffineMapAttr":$map);
 
   let extraClassDeclaration = [{
     mlir::Type getElementType() const { return getEleTy(); }
     mlir::AffineMapAttr getLayoutMap() const { return getMap(); }
     static BoxType get(mlir::Type eleTy, mlir::AffineMapAttr map = {}) {
       return get(eleTy.getContext(), eleTy, map);
     }
   }];
 
   let genAccessors = 1;
-
   let genVerifyInvariantsDecl = 1;
 }
 
-def fir_FieldType : FIR_Type<"Field", "field"> {
-  let summary = "A field (in a RecordType) argument's type";
+def fir_CharacterType : FIR_Type<"Character", "char"> {
+  let summary = "FIR character type";
 
   let description = [{
-    The type of a field name. Implementations may defer the layout of a Fortran
-    derived type until runtime. This implies that the runtime must be able to
-    determine the offset of fields within the entity.
+    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 printer = [{
-    $_printer << "field";
-  }];
+  let parameters = (ins "KindTy":$FKind, "CharacterType::LenType":$len);
 
-  let parser = [{
-    return get(context);
+  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 fir_ComplexType : FIR_Type<"Complex", "complex"> {
   let summary = "Complex type";
 
   let description = [{
     Model of a Fortran COMPLEX intrinsic type, including the KIND type
def fir_ComplexType : FIR_Type<"Complex", "complex"> {
 
   let extraClassDeclaration = [{
     using KindTy = unsigned;
 
     mlir::Type getElementType() const;
   }];
 }
 
-def ShapeType : FIR_Type<"Shape", "shape"> {
+def fir_FieldType : FIR_Type<"Field", "field"> {
+  let summary = "A field (in a RecordType) argument's type";
+
+  let description = [{
+    The type of a field name. Implementations may defer the layout of a Fortran
+    derived type until runtime. This implies that the runtime must be able to
+    determine the offset of fields within the entity.
+  }];
+
+  let printer = [{
+    $_printer << "field";
+  }];
+
+  let parser = [{
+    return get(context);
+  }];
+}
+
+def fir_ShapeType : FIR_Type<"Shape", "shape"> {
   let summary = "shape of a multidimensional array object";
 
   let description = [{
     Type of a vector of runtime values that define the shape of a
     multidimensional array object. The vector is the extents of each array
     dimension. The rank of a ShapeType must be at least 1.
   }];
 
   let parameters = (ins "unsigned":$rank);
 
   let printer = [{
     $_printer << "shape<" << getImpl()->rank << ">";
   }];
 
   let parser = [{
     int rank;
     if ($_parser.parseLess() || $_parser.parseInteger(rank) ||
         $_parser.parseGreater())
       return Type();
     return get(context, rank);
   }];
 }
 
-def ShapeShiftType : FIR_Type<"ShapeShift", "shapeshift"> {
+def fir_ShapeShiftType : FIR_Type<"ShapeShift", "shapeshift"> {
   let summary = "shape and origin of a multidimensional array object";
 
   let description = [{
     Type of a vector of runtime values that define the shape and the origin of a
     multidimensional array object. The vector is of pairs, origin offset and
     extent, of each array dimension. The rank of a ShapeShiftType must be at
     least 1.
   }];
 
   let parameters = (ins "unsigned":$rank);
 
   let printer = [{
     $_printer << "shapeshift<" << getImpl()->rank << ">";
   }];
 
   let parser = [{
-    if ($_parser.parseLess())
-      return Type();
     int rank;
-    if ($_parser.parseInteger(rank))
-      return Type();
-    if ($_parser.parseGreater())
+    if ($_parser.parseLess() || $_parser.parseInteger(rank) ||
+        $_parser.parseGreater())
       return Type();
     return get(context, rank);
   }];
 }
 
-def fir_CharacterType : FIR_Type<"Character", "char"> {
-  let summary = "FIR character type";
+def fir_ShiftType : FIR_Type<"Shift", "shift"> {
+  let summary = "lower bounds of a multidimensional array object";
 
   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.
+    Type of a vector of runtime values that define the lower bounds of a
+    multidimensional array object. The vector is the lower bounds of each array
+    dimension. The rank of a ShiftType must be at least 1.
   }];
 
-  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 fir_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 parameters = (ins "unsigned":$rank);
 
   let printer = [{
-    $_printer << "boxchar<" << getImpl()->kind << ">";
+    $_printer << "shift<" << getImpl()->rank << ">";
   }];
 
-  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;
+  let parser = [{
+    int rank;
+    if ($_parser.parseLess() || $_parser.parseInteger(rank) ||
+        $_parser.parseGreater())
+      return Type();
+    return get(context, rank);
   }];
 }
 
 #endif // FIR_DIALECT_FIR_TYPES