[flang] Add support for creating unique internal names.

[schweitz]

Summary

Support for a bijective unique name creation scheme that allows both
the creation of unique names and to decode those names back to symbols.

[vjayathirtha-nv]

LGTM.

[jeanPerier]

Would it make sens to also upstream https://github.com/flang-compiler/f18-llvm-project/blob/fir-dev/flang/documentation/BijectiveInternalNameUniquing.md in this patch. It explains the rational of this mangling.
Otherwise looks good to me.

flang/include/flang/Optimizer/Dialect/FIRDialect.h

 //===-- Optimizer/Dialect/FIRDialect.h -- FIR dialect -----------*- 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_FIRDIALECT_H
 #define OPTIMIZER_DIALECT_FIRDIALECT_H
 
 #include "mlir/IR/Dialect.h"
 #include "mlir/InitAllDialects.h"
 #include "mlir/InitAllPasses.h"
 
-namespace llvm {
-class raw_ostream;
-class StringRef;
-} // namespace llvm
-
-namespace mlir {
-class Attribute;
-class DialectAsmParser;
-class DialectAsmPrinter;
-class Location;
-class MLIRContext;
-class Type;
-} // namespace mlir
-
 namespace fir {
 
 /// FIR dialect
 class FIROpsDialect final : public mlir::Dialect {
 public:
   explicit FIROpsDialect(mlir::MLIRContext *ctx);
   virtual ~FIROpsDialect();
 

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 "mlir/Dialect/StandardOps/IR/Ops.h"
+#include "mlir/Interfaces/LoopLikeInterface.h"
+#include "mlir/Interfaces/SideEffects.h"
 
 using namespace mlir;
 
 namespace fir {
 
 class FirEndOp;
 class LoopOp;
 class RealAttr;

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

 /// Definition of the FIR dialect operations
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef FIR_DIALECT_FIR_OPS
 #define FIR_DIALECT_FIR_OPS
 
 include "mlir/Interfaces/ControlFlowInterfaces.td"
+include "mlir/Interfaces/LoopLikeInterface.td"
 include "mlir/Interfaces/SideEffects.td"
 
 def fir_Dialect : Dialect {
   let name = "fir";
 }
 
 // Types and predicates
 

 class fir_AllocatableBaseOp<string mnemonic, list<OpTrait> traits = []> :
     fir_Op<mnemonic, traits>, Results<(outs fir_Type:$res)> {
   let arguments = (ins
     OptionalAttr<StrAttr>:$name,
     OptionalAttr<BoolAttr>:$target
   );
 }
 
-class fir_AllocatableOp<string mnemonic, list<OpTrait> traits =[]> :
-    fir_AllocatableBaseOp<mnemonic, !listconcat([NoSideEffect], traits)>,
+class fir_AllocatableOp<string mnemonic, list<OpTrait> traits = []> :
+    fir_AllocatableBaseOp<mnemonic,
+  !listconcat(traits, [MemoryEffects<[MemAlloc]>])>,
     fir_TwoBuilders<fir_AllocateOpBuilder, fir_NamedAllocateOpBuilder>,
     Arguments<(ins TypeAttr:$in_type, Variadic<AnyIntegerType>:$args)> {
 
   let parser = [{
     mlir::Type intype;
     if (parser.parseType(intype))
       return mlir::failure();
     auto &builder = parser.getBuilder();
let printer = [{
     }
     p.printOptionalAttrDict(getAttrs(), {inType(), lenpName()});
   }];
 
   string extraAllocClassDeclaration = [{
     static constexpr llvm::StringRef inType() { return "in_type"; }
     static constexpr llvm::StringRef lenpName() { return "len_param_count"; }
     mlir::Type getAllocatedType();
+    
     bool hasLenParams() { return bool{getAttr(lenpName())}; }
+    
     unsigned numLenParams() {
       if (auto val = getAttrOfType<mlir::IntegerAttr>(lenpName()))
         return val.getInt();
       return 0;
     }
+    
     operand_range getLenParams() {
       return {operand_begin(), operand_begin() + numLenParams()};
     }
+    
+    unsigned numShapeOperands() {
+      return operand_end() - operand_begin() + numLenParams();
+    }
+    
     operand_range getShapeOperands() {
       return {operand_begin() + numLenParams(), operand_end()};
     }
+    
     static mlir::Type getRefTy(mlir::Type ty);
 
     /// Get the input type of the allocation
     mlir::Type getInType() {
       return getAttrOfType<mlir::TypeAttr>(inType()).getValue();
     }
   }];
 
   // Verify checks common to all allocation operations
   string allocVerify = [{
     llvm::SmallVector<llvm::StringRef, 8> visited;
-    if (verifyInType(getInType(), visited))
+    if (verifyInType(getInType(), visited, numShapeOperands()))
       return emitOpError("invalid type for allocation");
     if (verifyRecordLenParams(getInType(), numLenParams()))
       return emitOpError("LEN params do not correspond to type");
   }];
 }
 
+//===----------------------------------------------------------------------===//
 // Memory SSA operations
+//===----------------------------------------------------------------------===//
 
 def fir_AllocaOp : fir_AllocatableOp<"alloca"> {
   let summary = "allocate storage for a temporary on the stack given a type";
   let description = [{
     This primitive operation is used to allocate an object on the stack.  A
     reference to the object of type `!fir.ref<T>` is returned.  The returned
     object has an undefined/uninitialized state.  The allocation can be given
     an optional name.  The allocation may have a dynamic repetition count
let verifier = allocVerify#[{
     return mlir::success();
   }];
 
   let extraClassDeclaration = extraAllocClassDeclaration#[{
     static mlir::Type wrapResultType(mlir::Type intype);
   }];
 }
 
-def fir_LoadOp : fir_OneResultOp<"load", []> {
+def fir_LoadOp : fir_OneResultOp<"load", [MemoryEffects<[MemRead]>]> {
   let summary = "load a value from a memory reference";
   let description = [{
     Load a value from a memory reference into an ssa-value (virtual register).
     Produces an immutable ssa-value of the referent type. A memory reference
     has type `!fir.ref<T>`, `!fir.heap<T>`, or `!fir.ptr<T>`.
 
     ```mlir
       %a = fir.alloca i32
let printer = [{
     p << " : " << memref().getType();
   }];
 
   let extraClassDeclaration = [{
     static mlir::ParseResult getElementOf(mlir::Type &ele, mlir::Type ref);
   }];
 }
 
-def fir_StoreOp : fir_Op<"store", []> {
+def fir_StoreOp : fir_Op<"store", [MemoryEffects<[MemWrite]>]> {
   let summary = "store an SSA-value to a memory location";
 
   let description = [{
     Store an ssa-value (virtual register) to a memory reference.  The stored
     value must be of the same type as the referent type of the memory
     reference.
 
     ```mlir
let description = [{
     10, and each element has type `!fir.type<T>`.
   }];
 
   let results = (outs AnyType:$intype);
 
   let assemblyFormat = "type($intype) attr-dict";
 
   let verifier = [{
-    if (auto ref = getType().dyn_cast<fir::ReferenceType>())
-      return emitOpError("undefined values of type !fir.ref not allowed");
+    // allow `undef : ref<T>` since it is a possible from transformations
     return mlir::success();
   }];
 }
 
 def fir_AllocMemOp : fir_AllocatableOp<"allocmem"> {
   let summary = "allocate storage on the heap for an object of a given type";
 
   let description = [{
let verifier = allocVerify#[{
     return mlir::success();
   }];
 
   let extraClassDeclaration = extraAllocClassDeclaration#[{
     static mlir::Type wrapResultType(mlir::Type intype);
   }];
 }
 
-def fir_FreeMemOp : fir_Op<"freemem", []> {
+def fir_FreeMemOp : fir_Op<"freemem", [MemoryEffects<[MemFree]>]> {
   let summary = "free a heap object";
 
   let description = [{
     Deallocates a heap memory reference that was allocated by an `allocmem`.
     The memory object that is deallocated is placed in an undefined state
     after `fir.freemem`.  Optimizations may treat the loading of an object
     in the undefined state as undefined behavior.  This includes aliasing
     references, such as the result of an `fir.embox`.
 
     ```mlir
       %21 = fir.allocmem !fir.type<ZT(p:i32){field:i32}>
       ...
       fir.freemem %21 : !fir.heap<!fir.type<ZT>>
     ```
   }];
 
   let arguments = (ins fir_HeapType:$heapref);
 
   let assemblyFormat = "$heapref attr-dict `:` type($heapref)";
 }
 
-//===----------------------------------------------------------------------===//// Terminator operations
+//===----------------------------------------------------------------------===//
+// Terminator operations
 //===----------------------------------------------------------------------===//
 
 class fir_SwitchTerminatorOp<string mnemonic, list<OpTrait> traits = []> :
     fir_Op<mnemonic, !listconcat(traits, [AttrSizedOperandSegments,
     DeclareOpInterfaceMethods<BranchOpInterface>, Terminator])> {
 
   let arguments = (ins
     AnyType:$selector,
     Variadic<AnyType>:$compareArgs,
     Variadic<AnyType>:$targetArgs
   );
 
   let results = (outs);
 
   let successors = (successor VariadicSuccessor<AnySuccessor>:$targets);
 
-  let builders = [OpBuilder<
-    "Builder *, OperationState &result, Value selector,"
-    "ValueRange properOperands, ArrayRef<Block *> destinations,"
-    "ArrayRef<ValueRange> operands = {},"
-    "ArrayRef<NamedAttribute> attributes = {}",
-    [{
-      result.addOperands(selector);
-      result.addOperands(properOperands);
-      for (auto kvp : llvm::zip(destinations, operands)) {
-        result.addSuccessors(std::get<0>(kvp));
-        result.addOperands(std::get<1>(kvp));
-      }
-      result.addAttributes(attributes);
-    }]
-  >];
-
   string extraSwitchClassDeclaration = [{
     using Conditions = mlir::Value;
 
     static constexpr llvm::StringRef getCasesAttr() { return "case_tags"; }
 
     // The number of destination conditions that may be tested
-    unsigned getNumConditions() { return getNumDest(); }
+    unsigned getNumConditions() {
+      return getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).size();
+    }
 
     // The selector is the value being tested to determine the destination
     mlir::Value getSelector() { return selector(); }
     mlir::Value getSelector(llvm::ArrayRef<mlir::Value> operands) {
       return operands[0];
     }
 
     // The number of blocks that may be branched to
string extraSwitchClassDeclaration = [{
     void printSuccessorAtIndex(mlir::OpAsmPrinter &p, unsigned i) {
       auto *succ = getSuccessor(i);
       auto ops = getSuccessorOperands(i);
       if (ops.hasValue())
         p.printSuccessorAndUseList(succ, ops.getValue());
       else
         p.printSuccessor(succ);
     }
+
+    unsigned targetOffsetSize();
   }];
 }
 
 class fir_IntegralSwitchTerminatorOp<string mnemonic,
     list<OpTrait> traits = []> : fir_SwitchTerminatorOp<mnemonic, traits> {
 
+  let skipDefaultBuilders = 1;
+  let builders = [OpBuilder<
+    "Builder *builder, OperationState &result, Value selector,"
+    "ArrayRef<int64_t> compareOperands, ArrayRef<Block *> destinations,"
+    "ArrayRef<ValueRange> destOperands = {},"
+    "ArrayRef<NamedAttribute> attributes = {}",
+    [{
+      result.addOperands(selector);
+      llvm::SmallVector<mlir::Attribute, 8> ivalues;
+      for (auto iv : compareOperands)
+        ivalues.push_back(builder->getI64IntegerAttr(iv));
+      ivalues.push_back(builder->getUnitAttr());
+      result.addAttribute(getCasesAttr(), builder->getArrayAttr(ivalues));
+      const auto count = destinations.size();
+      for (auto d : destinations)
+        result.addSuccessors(d);
+      const auto opCount = destOperands.size();
+      llvm::SmallVector<int32_t, 8> argOffs;
+      int32_t sumArgs = 0;
+      for (std::remove_const_t<decltype(count)> i = 0; i != count; ++i) {
+        if (i < opCount) {
+          result.addOperands(destOperands[i]);
+          const auto argSz = destOperands[i].size();
+          argOffs.push_back(argSz);
+          sumArgs += argSz;
+        } else {
+          argOffs.push_back(0);
+        }
+      }
+      result.addAttribute(getOperandSegmentSizeAttr(),
+                          builder->getI32VectorAttr({1, 0, sumArgs}));
+      result.addAttribute(getTargetOffsetAttr(),
+                          builder->getI32VectorAttr(argOffs));
+      result.addAttributes(attributes);
+    }]
+  >];
+
   let parser = [{
     mlir::OpAsmParser::OperandType selector;
     mlir::Type type;
     if (parseSelector(parser, result, selector, type))
       return mlir::failure();
 
     llvm::SmallVector<mlir::Attribute, 8> ivalues;
     llvm::SmallVector<mlir::Block *, 8> dests;
class fir_IntegralSwitchTerminatorOp<string mnemonic,
   }];
 
   let verifier = [{
     if (!(getSelector().getType().isa<mlir::IntegerType>() ||
           getSelector().getType().isa<mlir::IndexType>() ||
           getSelector().getType().isa<fir::IntType>()))
       return emitOpError("must be an integer");
     auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
-    auto count = getNumConditions();
+    auto count = getNumDest();
+    if (count == 0)
+      return emitOpError("must have at least one successor");
+    if (getNumConditions() != count)
+      return emitOpError("number of cases and targets don't match");
+    if (targetOffsetSize() != count)
+      return emitOpError("incorrect number of successor operand groups");
     for (decltype(count) i = 0; i != count; ++i) {
       auto &attr = cases[i];
-      if (attr.isa<mlir::IntegerAttr>() || attr.isa<mlir::UnitAttr>()) {
-        // ok
-      } else {
+      if (!(attr.isa<mlir::IntegerAttr>() || attr.isa<mlir::UnitAttr>()))
         return emitOpError("invalid case alternative");
-      }
-    }
     return mlir::success();
   }];
 
   let extraClassDeclaration = extraSwitchClassDeclaration;
 }
 
 def fir_SelectOp : fir_IntegralSwitchTerminatorOp<"select"> {
   let summary = "a multiway branch";
```mlir
             #fir.point, %0, ^bb1(%0 : i32),
             #fir.lower, %1, ^bb2(%2,%arg,%arg2,%1 : i32,i32,i32,i32),
             #fir.interval, %2, %3, ^bb3(%2,%arg2 : i32,i32),
             #fir.upper, %arg, ^bb4(%1 : i32),
             unit, ^bb5]
     ```
   }];
 
+  let skipDefaultBuilders = 1;
+  let builders = [
+    OpBuilder<"Builder *builder, OperationState &result, Value selector,"
+    "ArrayRef<mlir::Attribute> compareAttrs, ArrayRef<ValueRange> cmpOperands,"
+    "ArrayRef<Block *> destinations, ArrayRef<ValueRange> destOperands = {},"
+    "ArrayRef<NamedAttribute> attributes = {}">,
+    OpBuilder<"Builder *builder, OperationState &result, Value selector,"
+    "ArrayRef<mlir::Attribute> compareAttrs, ArrayRef<Value> cmpOpList,"
+    "ArrayRef<Block *> destinations, ArrayRef<ValueRange> destOperands = {},"
+    "ArrayRef<NamedAttribute> attributes = {}">];
+
   let parser = "return parseSelectCase(parser, result);";
 
   let printer = [{
     p << getOperationName() << ' ';
     p.printOperand(getSelector());
     p << " : " << getSelector().getType() << " [";
     auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
     auto count = getNumConditions();
def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
   let verifier = [{
     if (!(getSelector().getType().isa<mlir::IntegerType>() ||
           getSelector().getType().isa<mlir::IndexType>() ||
           getSelector().getType().isa<fir::IntType>() ||
           getSelector().getType().isa<fir::LogicalType>() ||
           getSelector().getType().isa<fir::CharacterType>()))
       return emitOpError("must be an integer, character, or logical");
     auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
-    auto count = getNumConditions();
+    auto count = getNumDest();
+    if (count == 0)
+      return emitOpError("must have at least one successor");
+    if (getNumConditions() != count)
+      return emitOpError("number of conditions and successors don't match");
+    if (compareOffsetSize() != count)
+      return emitOpError("incorrect number of compare operand groups");
+    if (targetOffsetSize() != count)
+      return emitOpError("incorrect number of successor operand groups");
     for (decltype(count) i = 0; i != count; ++i) {
       auto &attr = cases[i];
-      if (attr.isa<fir::PointIntervalAttr>() ||
+      if (!(attr.isa<fir::PointIntervalAttr>() ||
             attr.isa<fir::LowerBoundAttr>() ||
             attr.isa<fir::UpperBoundAttr>() ||
             attr.isa<fir::ClosedIntervalAttr>() ||
-          attr.isa<mlir::UnitAttr>()) {
-        // ok
-      } else {
+            attr.isa<mlir::UnitAttr>()))
         return emitOpError("incorrect select case attribute type");
-      }
-    }
     return mlir::success();
   }];
 
-  let extraClassDeclaration = extraSwitchClassDeclaration;
+  let extraClassDeclaration = extraSwitchClassDeclaration#[{
+    unsigned compareOffsetSize();
+  }];
 }
 
 def fir_SelectTypeOp : fir_SwitchTerminatorOp<"select_type"> {
   let summary = "Fortran's SELECT TYPE statement";
 
   let description = [{
     Similar to `select`, `select_type` provides a way to express Fortran's
     SELECT TYPE construct.  In this case, the type of the selector value
     is matched against a list of type descriptors.  The structure is the
     same as `select`, but `select_type` determines the type of the selector
     variable at runtime to determine the best match.
 
     ```mlir
       fir.select_type %arg : !fir.box<()> [
           #fir.instance<!fir.type<type1>>, ^bb1(%0 : i32),
           #fir.instance<!fir.type<type2>>, ^bb2(%2 : i32),
           #fir.subsumed<!fir.type<type3>>, ^bb3(%2 : i32),
           #fir.instance<!fir.type<type4>>, ^bb4(%1,%3 : i32,f32),
           unit, ^bb5]
     ```
   }];
 
+  let skipDefaultBuilders = 1;
+  let builders = [OpBuilder<
+    "Builder *builder, OperationState &result, Value selector,"
+    "ArrayRef<mlir::Attribute> typeOperands,"
+    "ArrayRef<Block *> destinations, ArrayRef<ValueRange> destOperands = {},"
+    "ArrayRef<NamedAttribute> attributes = {}",
+    [{
+      result.addOperands(selector);
+      result.addAttribute(getCasesAttr(), builder->getArrayAttr(typeOperands));
+      const auto count = destinations.size();
+      for (auto d : destinations)
+        result.addSuccessors(d);
+      const auto opCount = destOperands.size();
+      llvm::SmallVector<int32_t, 8> argOffs;
+      int32_t sumArgs = 0;
+      for (std::remove_const_t<decltype(count)> i = 0; i != count; ++i) {
+        if (i < opCount) {
+          result.addOperands(destOperands[i]);
+          const auto argSz = destOperands[i].size();
+          argOffs.push_back(argSz);
+          sumArgs += argSz;
+        } else {
+          argOffs.push_back(0);
+        }
+      }
+      result.addAttribute(getOperandSegmentSizeAttr(),
+                          builder->getI32VectorAttr({1, 0, sumArgs}));
+      result.addAttribute(getTargetOffsetAttr(),
+                          builder->getI32VectorAttr(argOffs));
+      result.addAttributes(attributes);
+    }]
+  >];
+
   let parser = "return parseSelectType(parser, result);";
 
   let printer = [{
     p << getOperationName() << ' ';
     p.printOperand(getSelector());
     p << " : " << getSelector().getType() << " [";
     auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
     auto count = getNumConditions();
     for (decltype(count) i = 0; i != count; ++i) {
       if (i)
         p << ", ";
       p << cases[i] << ", ";
       printSuccessorAtIndex(p, i);
     }
     p << ']';
     p.printOptionalAttrDict(getAttrs(), {getCasesAttr(), getCompareOffsetAttr(),
         getTargetOffsetAttr(), getOperandSegmentSizeAttr()});
   }];
 
   let verifier = [{
     if (!(getSelector().getType().isa<fir::BoxType>()))
       return emitOpError("must be a boxed type");
     auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
-    auto count = getNumConditions();
+    auto count = getNumDest();
+    if (count == 0)
+      return emitOpError("must have at least one successor");
+    if (getNumConditions() != count)
+      return emitOpError("number of conditions and successors don't match");
+    if (targetOffsetSize() != count)
+      return emitOpError("incorrect number of successor operand groups");
     for (decltype(count) i = 0; i != count; ++i) {
       auto &attr = cases[i];
-      if (attr.isa<fir::ExactTypeAttr>() || attr.isa<fir::SubclassAttr>() ||
-          attr.isa<mlir::UnitAttr>()) {
-        // ok
-      } else {
+      if (!(attr.isa<fir::ExactTypeAttr>() || attr.isa<fir::SubclassAttr>() ||
+            attr.isa<mlir::UnitAttr>()))
         return emitOpError("invalid type-case alternative");
-      }
-    }
     return mlir::success();
   }];
 
   let extraClassDeclaration = extraSwitchClassDeclaration;
 }
 
 def fir_UnreachableOp : fir_Op<"unreachable", [Terminator]> {
   let summary = "the unreachable instruction";
let extraClassDeclaration = [{
     }
     operand_range dims() {
       return {operand_begin() + numLenParams() + 1, operand_end()};
     }
   }];
 }
 
 def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]> {
-  let arguments = (ins AnyReferenceLike:$memref, AnyIntegerLike:$len);
-  let results = (outs fir_BoxCharType);
-
   let summary = "boxes a given CHARACTER reference and its LEN parameter";
 
   let description = [{
     Create a boxed CHARACTER value. The CHARACTER type has the LEN type
     parameter, the value of which may only be known at runtime.  Therefore,
     a variable of type CHARACTER has both its data reference as well as a
     LEN type parameter.
 
     ```fortran
       CHARACTER(LEN=10) :: var
     ```
     ```mlir
       %4 = ...         : !fir.ref<!fir.array<10 x !fir.char<1>>>
       %5 = constant 10 : i32
       %6 = fir.emboxchar %4, %5 : (!fir.ref<!fir.array<10 x !fir.char<1>>>, i32) -> !fir.boxchar<1>
     ```
 
     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 assemblyFormat = [{
     $memref `,` $len attr-dict `:` functional-type(operands, results)
   }];
 
   let verifier = [{
     auto eleTy = elementTypeOf(memref().getType());
     if (!eleTy.dyn_cast<CharacterType>())
       return mlir::failure();
     return mlir::success();
   }];
 }
 
 def fir_EmboxProcOp : fir_Op<"emboxproc", [NoSideEffect]> {
-
   let summary = "boxes a given procedure and optional host context";
 
   let description = [{
     Creates an abstract encapsulation of a PROCEDURE POINTER along with an
     optional pointer to a host instance context. If the pointer is not to an
     internal procedure or the internal procedure does not need a host context
     then the form takes only the procedure's symbol.
 
```mlir
       %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 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";
 
   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 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";
 
   let description = [{
     Returns the triple of lower bound, extent, and stride for `dim` dimension
     of `val`, which must have a `box` type.  The dimensions are enumerated from
let description = [{
 
     This operation will apply the access map from a boxed value implicitly.
 
     Unlike LLVM's GEP instruction, one cannot stride over the outermost
     reference; therefore, the leading 0 index must be omitted.
 
     ```mlir
       %i = ... : index
-      %h = ... : !fir.heap<!fir.array<?:f32>>
-      %p = fir.coordinate_of %h, %i : (!fir.heap<!fir.array<?:f32>>, index) -> !fir.ref<f32>
+      %h = ... : !fir.heap<!fir.array<100 x f32>>
+      %p = fir.coordinate_of %h, %i : (!fir.heap<!fir.array<100 x f32>>, index) -> !fir.ref<f32>
     ```
 
     In the example, `%p` will be a pointer to the `%i`-th f32 value in the
     array `%h`.
   }];
 
   let arguments = (ins AnyRefOrBox:$ref, Variadic<AnyCoordinateType>:$coor);
 
   let results = (outs fir_ReferenceType);
 
-  let assemblyFormat = [{
-    operands attr-dict `:` functional-type(operands, results)
+  let parser = "return parseCoordinateOp(parser, result);";
+
+  let printer = [{
+    p << getOperationName() << ' ' << getOperation()->getOperands();
+    p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{baseType()});
+    p << " : ";
+    p.printFunctionalType(getOperation()->getOperandTypes(),
+        getOperation()->getResultTypes());
   }];
   
   let verifier = [{
+    auto refTy = ref().getType();
+    if (fir::isa_ref_type(refTy)) {
+      auto eleTy = fir::dyn_cast_ptrEleTy(refTy);
+      if (auto arrTy = eleTy.dyn_cast<fir::SequenceType>()) {
+        if (arrTy.hasUnknownShape())
+          return emitOpError("cannot find coordinate in unknown shape");
+        if (arrTy.getConstantRows() < arrTy.getDimension() - 1)
+          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>())
           return emitOpError("len_param_index must be used on box type");
       }
+    if (auto attr = getAttr(CoordinateOp::baseType())) {
+      if (!attr.isa<mlir::TypeAttr>())
+        return emitOpError("improperly constructed");
+    } else {
+      return emitOpError("must have base type");
+    }
     return mlir::success();
   }];
+
+  let skipDefaultBuilders = 1;
+  let builders = [
+    OpBuilder<"mlir::Builder *builder, OperationState &result,"
+              "Type type, Value ref, ValueRange coor,"
+        "ArrayRef<NamedAttribute> attrs = {}">,
+    OpBuilder<"mlir::Builder *builder, OperationState &result,"
+              "Type type, ValueRange operands,"
+        "ArrayRef<NamedAttribute> attrs = {}">];
+        
+  let extraClassDeclaration = [{
+    static constexpr llvm::StringRef baseType() { return "base_type"; }
+    mlir::Type getBaseType();
+  }];
 }
 
 def fir_ExtractValueOp : fir_OneResultOp<"extract_value", [NoSideEffect]> {
   let summary = "Extract a value from an aggregate SSA-value";
 
   let description = [{
     Extract a value from an entity with a type composed of tuples, arrays,
     and/or derived types. Returns the value from entity with the type of the
let description = [{
     multiple of 3 in length.  Each such triple is defined as: the lower
     index, the extent, and the stride for that dimension. The dimension
     information is given in the same row-to-column order as Fortran. This
     abstract dimension value must describe a reified object, so all dimension
     information must be specified.  The extent must be nonnegative and the
     stride must not be zero.
 
     ```mlir
-      %d = fir.gendims %l, %u, %s : (index, index, index) -> !fir.dims<1>
+      %d = fir.gendims %lo, %ext, %str : (index, index, index) -> !fir.dims<1>
     ```
   }];
 
   let arguments = (ins Variadic<AnyIntegerType>:$triples);
 
   let results = (outs fir_DimsType);
 
   let assemblyFormat = [{
let extraClassDeclaration = [{
     static constexpr llvm::StringRef fieldAttrName() { return "field_id"; }
     static constexpr llvm::StringRef typeAttrName() { return "on_type"; }
     mlir::Type getOnType() {
       return getAttrOfType<TypeAttr>(typeAttrName()).getValue();
     }
   }];
 }
 
+//===----------------------------------------------------------------------===//
 // Fortran loops
+//===----------------------------------------------------------------------===//
 
-def ImplicitFirTerminator : SingleBlockImplicitTerminator<"FirEndOp">;
+def fir_ResultOp : fir_Op<"result", [Terminator]> {
+  let summary = "special terminator for use in fir region operations";
+
+  let description = [{
+    Result takes a list of ssa-values produced in the block and forwards them
+    as a result to the operation that owns the region of the block. The
+    operation can retain the values or return them to its parent block
+    depending upon its semantics.
+  }];
+
+  let arguments = (ins Variadic<AnyType>:$results);
+  let builders = [
+    OpBuilder<"Builder *builder, OperationState &result", "/* do nothing */">
+  ];
+  let printer = [{ return ::print(p, *this); }];
+  let verifier = [{ return ::verify(*this); }];
+  let parser = [{ return ::parse$cppClass(parser, result); }];
+}
+
+def FirRegionTerminator : SingleBlockImplicitTerminator<"ResultOp">;
+
+class region_Op<string mnemonic, list<OpTrait> traits = []> :
+    fir_Op<mnemonic,
+    !listconcat(traits, [FirRegionTerminator, RecursiveSideEffects])> {
+  let printer = [{ return ::print(p, *this); }];
+  let verifier = [{ return ::verify(*this); }];
+  let parser = [{ return ::parse$cppClass(parser, result); }];
+}
 
-def fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
+def fir_LoopOp : region_Op<"do_loop",
+    [DeclareOpInterfaceMethods<LoopLikeOpInterface>]> {
   let summary = "generalized loop operation";
   let description = [{
     Generalized high-level looping construct. This operation is similar to
-    MLIR's `loop.for`. An ordered loop will return the final value of `%i`.
+    MLIR's `loop.for`.
 
     ```mlir
       %l = constant 0 : index
       %u = constant 9 : index
-      fir.loop %i = %l to %u unordered {
+      %s = constant 1 : index
+      fir.do_loop %i = %l to %u step %s unordered {
         %x = fir.convert %i : (index) -> i32
         %v = fir.call @compute(%x) : (i32) -> f32
         %p = fir.coordinate_of %A, %i : (!fir.ref<f32>, index) -> !fir.ref<f32>
         fir.store %v to %p : !fir.ref<f32>
       }
     ```
 
     The above example iterates over the interval `[%l, %u]`. The unordered
     keyword indicates that the iterations can be executed in any order.
   }];
 
   let arguments = (ins
     Index:$lowerBound,
     Index:$upperBound,
-    Variadic<Index>:$optStep,
-    OptionalAttr<I64Attr>:$constantStep,
+    Index:$step,
+    Variadic<AnyType>:$initArgs,
     OptionalAttr<UnitAttr>:$unordered
   );
-
-  let results = (outs Variadic<Index>:$lastVal);
-
+  let results = (outs
+    Variadic<AnyType>:$results
+  );
   let regions = (region SizedRegion<1>:$region);
 
   let skipDefaultBuilders = 1;
   let builders = [
     OpBuilder<"mlir::Builder *builder, OperationState &result,"
               "mlir::Value lowerBound, mlir::Value upperBound,"
-              "ValueRange step = {}, ArrayRef<NamedAttribute> attributes = {}">
+              "mlir::Value step, bool unordered = false,"
+              "ValueRange iterArgs = llvm::None,"
+              "ArrayRef<NamedAttribute> attributes = {}">
   ];
 
-  let parser = "return parseLoopOp(parser, result);";
-
-  let printer = [{
-    p << getOperationName() << ' ' << getInductionVar() << " = "
-      << lowerBound() << " to " << upperBound();
-    auto s = optStep();
-    if (s.begin() != s.end()) {
-      p << " step ";
-      p.printOperand(*s.begin());
-    }
-    if (unordered())
-      p << " unordered";
-    p.printRegion(region(), /*printEntryBlockArgs=*/false,
-                            /*printBlockTerminators=*/false);
-    p.printOptionalAttrDict(getAttrs(), {unorderedAttrName(), stepAttrName()});
-  }];
-
-  let verifier = [{
-    auto step = optStep();
-    if (step.begin() != step.end()) {
-      // FIXME: size of step must be 1
-      auto *s = (*step.begin()).getDefiningOp();
-      if (auto cst = dyn_cast_or_null<mlir::ConstantIndexOp>(s))
-        if (cst.getValue() == 0)
-          return emitOpError("constant step operand must be nonzero");
-    }
-
-    // Check that the body defines as single block argument for the induction
-    // variable.
-    auto *body = getBody();
-    if (body->getNumArguments() != 1 ||
-        !body->getArgument(0).getType().isIndex())
-      return emitOpError("expected body to have a single index argument for "
-                         "the induction variable");
-    if (lastVal().size() > 1)
-      return emitOpError("can only return one final value of iterator");
-    return mlir::success();
-  }];
-
   let extraClassDeclaration = [{
-    static constexpr const char *unorderedAttrName() { return "unordered"; }
-    static constexpr const char *stepAttrName() { return "step"; }
-
-    /// Is this an unordered loop?
-    bool isUnordered() { return getAttr(unorderedAttrName()).isa<UnitAttr>(); }
-
-    /// Does loop set (and return) the final value of the control variable?
-    bool hasLastValue() { return lastVal().size(); }
+    static constexpr llvm::StringRef unorderedAttrName() { return "unordered"; }
 
-    /// Get the body of the loop
-    mlir::Block *getBody() { return &region().front(); }
-
-    /// Get the block argument corresponding to the loop control value (PHI)
     mlir::Value getInductionVar() { return getBody()->getArgument(0); }
-
-    /// Get a builder to insert operations into the LoopOp
     mlir::OpBuilder getBodyBuilder() {
-      return mlir::OpBuilder(getBody(), std::prev(getBody()->end()));
+      return OpBuilder(getBody(), std::prev(getBody()->end()));
     }
-
-    void setLowerBound(mlir::Value bound) {
-      getOperation()->setOperand(0, bound);
+    mlir::Block::BlockArgListType getRegionIterArgs() {
+      return getBody()->getArguments().drop_front();
     }
+    mlir::Operation::operand_range getIterOperands() {
+      return getOperands().drop_front(getNumControlOperands());
+    }
+
+    void setLowerBound(Value bound) { getOperation()->setOperand(0, bound); }
+    void setUpperBound(Value bound) { getOperation()->setOperand(1, bound); }
+    void setStep(Value step) { getOperation()->setOperand(2, step); }
 
-    void setUpperBound(mlir::Value bound) {
-      getOperation()->setOperand(1, bound);
+    /// Number of region arguments for loop-carried values
+    unsigned getNumRegionIterArgs() {
+      return getBody()->getNumArguments() - 1;
     }
+    /// Number of operands controlling the loop: lb, ub, step
+    unsigned getNumControlOperands() { return 3; }
+    /// Does the operation hold operands for loop-carried values
+    bool hasIterOperands() {
+      return getOperation()->getNumOperands() > getNumControlOperands();
+    }
+    /// Get Number of loop-carried values
+    unsigned getNumIterOperands() {
+      return getOperation()->getNumOperands() - getNumControlOperands();
+    }
+
+    /// Get the body of the loop
+    mlir::Block *getBody() { return &region().front(); }
 
-    void setStep(mlir::Value step) {
-      getOperation()->setOperand(2, step);
+    void setUnordered() {
+      getOperation()->setAttr(unorderedAttrName(),
+                              mlir::UnitAttr::get(getContext()));
     }
   }];
 }
 
-def fir_WhereOp : fir_Op<"where", [ImplicitFirTerminator]> {
-  let summary = "generalized conditional operation";
+def fir_WhereOp : region_Op<"if"> {
+  let summary = "if-then-else conditional operation";
   let description = [{
-    To conditionally execute operations (typically) within the body of a
-    `fir.loop` operation. This operation is similar to `loop.if`.
+    Used to conditionally execute operations. This operation is the FIR
+    dialect's version of `loop.if`.
 
     ```mlir
       %56 = ... : i1
       %78 = ... : !fir.ref<!T>
-      fir.where %56 {
+      fir.if %56 {
         fir.store %76 to %78 : !fir.ref<!T>
-      } otherwise {
+      } else {
         fir.store %77 to %78 : !fir.ref<!T>
       }
     ```
   }];
 
   let arguments = (ins I1:$condition);
+  let results = (outs Variadic<AnyType>:$results);
 
-  let regions = (region SizedRegion<1>:$whereRegion, AnyRegion:$otherRegion);
+  let regions = (region
+    SizedRegion<1>:$whereRegion,
+    AnyRegion:$otherRegion
+  );
 
   let skipDefaultBuilders = 1;
   let builders = [
     OpBuilder<"Builder *builder, OperationState &result, "
-              "Value cond, bool withOtherRegion">
+              "Value cond, bool withOtherRegion">,
+    OpBuilder<"Builder *builder, OperationState &result, "
+              "TypeRange resultTypes, Value cond, bool withOtherRegion">
   ];
 
-  let parser = [{ return parseWhereOp(parser, result); }];
-
-  let printer = [{
-    p << getOperationName() << ' ' << condition();
-    p.printRegion(whereRegion(), /*printEntryBlockArgs=*/false,
-        /*printBlockTerminators=*/false);
-
-    // Print the 'else' regions if it exists and has a block.
-    auto &otherReg = otherRegion();
-    if (!otherReg.empty()) {
-      p << " otherwise";
-      p.printRegion(otherReg, /*printEntryBlockArgs=*/false,
-          /*printBlockTerminators=*/false);
-    }
-    p.printOptionalAttrDict(getAttrs());
-  }];
-
-  let verifier = [{
-    for (auto &region : getOperation()->getRegions()) {
-      if (region.empty())
-        continue;
-      for (auto &b : region)
-        if (b.getNumArguments() != 0)
-          return emitOpError("requires that child entry blocks have no args");
-    }
-    return mlir::success();
-  }];
-
   let extraClassDeclaration = [{
     mlir::OpBuilder getWhereBodyBuilder() {
       assert(!whereRegion().empty() && "Unexpected empty 'where' region.");
       mlir::Block &body = whereRegion().front();
       return mlir::OpBuilder(&body, std::prev(body.end()));
     }
     mlir::OpBuilder getOtherBodyBuilder() {
       assert(!otherRegion().empty() && "Unexpected empty 'other' region.");
       mlir::Block &body = otherRegion().front();
       return mlir::OpBuilder(&body, std::prev(body.end()));
     }
   }];
+
+  let hasFolder = 1;
 }
 
+def fir_IterWhileOp : region_Op<"iterate_while",
+    [DeclareOpInterfaceMethods<LoopLikeOpInterface>]> {
+  let summary = "DO loop with early exit condition";
+  let description = [{
+    This construct is useful for lowering implied-DO loops. It is very similar
+    to `fir::LoopOp` with the addition that it requires a single loop-carried
+    bool value that signals an early exit condition to the operation. A `true`
+    disposition means the next loop iteration should proceed. A `false`
+    indicates that the `fir.iterate_while` operation should terminate and
+    return its iteration arguments.
+  }];
+
+  let arguments = (ins
+    Index:$lowerBound,
+    Index:$upperBound,
+    Index:$step,
+    I1:$iterateIn,
+    Variadic<AnyType>:$initArgs
+  );
+  let results = (outs
+    I1:$iterateResult,
+    Variadic<AnyType>:$results
+  );
+  let regions = (region SizedRegion<1>:$region);
+
+  let skipDefaultBuilders = 1;
+  let builders = [
+    OpBuilder<"mlir::Builder *builder, OperationState &result,"
+              "mlir::Value lowerBound, mlir::Value upperBound,"
+        "mlir::Value step, mlir::Value iterate,"
+              "ValueRange iterArgs = llvm::None,"
+              "ArrayRef<NamedAttribute> attributes = {}">
+  ];
+  
+  let extraClassDeclaration = [{
+    mlir::Block *getBody() { return &region().front(); }
+    mlir::Value getIterateVar() { return getBody()->getArgument(1); }
+    mlir::Value getInductionVar() { return getBody()->getArgument(0); }
+    mlir::OpBuilder getBodyBuilder() {
+      return mlir::OpBuilder(getBody(), std::prev(getBody()->end()));
+    }
+    mlir::Block::BlockArgListType getRegionIterArgs() {
+      return getBody()->getArguments().drop_front();
+    }
+    mlir::Operation::operand_range getIterOperands() {
+      return getOperands().drop_front(getNumControlOperands());
+    }
+
+    void setLowerBound(Value bound) { getOperation()->setOperand(0, bound); }
+    void setUpperBound(Value bound) { getOperation()->setOperand(1, bound); }
+    void setStep(mlir::Value step) { getOperation()->setOperand(2, step); }
+
+    /// Number of region arguments for loop-carried values
+    unsigned getNumRegionIterArgs() {
+      return getBody()->getNumArguments() - 1;
+    }
+    /// Number of operands controlling the loop
+    unsigned getNumControlOperands() { return 3; }
+    /// Does the operation hold operands for loop-carried values
+    bool hasIterOperands() {
+      return getOperation()->getNumOperands() > getNumControlOperands();
+    }
+    /// Get Number of loop-carried values
+    unsigned getNumIterOperands() {
+      return getOperation()->getNumOperands() - getNumControlOperands();
+    }
+  }];
+}
+
+//===----------------------------------------------------------------------===//
 // Procedure call operations
+//===----------------------------------------------------------------------===//
 
-def fir_CallOp : fir_Op<"call", []> {
+def fir_CallOp : fir_Op<"call",
+    [MemoryEffects<[MemAlloc, MemFree, MemRead, MemWrite]>]> {
   let summary = "call a procedure";
 
   let description = [{
     Call the specified function or function reference.
 
     Provides a custom parser and pretty printer to allow a more readable syntax
     in the FIR dialect, e.g. `fir.call @sub(%12)` or `fir.call %20(%22,%23)`.
 
def fir_CallOp : fir_Op<"call",
   let parser = "return parseCallOp(parser, result);";
   let printer = "printCallOp(p, *this);";
 
   let extraClassDeclaration = [{
     static constexpr StringRef calleeAttrName() { return "callee"; }
   }];
 }
 
-def fir_DispatchOp : fir_Op<"dispatch", []> {
+def fir_DispatchOp : fir_Op<"dispatch",
+    [MemoryEffects<[MemAlloc, MemFree, MemRead, MemWrite]>]> {
   let summary = "call a type-bound procedure";
 
   let description = [{
     Perform a dynamic dispatch on the method name via the dispatch table
     associated with the first argument.  The attribute 'pass_arg_pos' can be
     used to select a dispatch argument other than the first one.
 
     ```mlir
let parser = [{
     llvm::SmallVector<mlir::NamedAttribute, 2> attrs;
     if (parser.parseAttribute(val, "fake", attrs))
       return mlir::failure();
     if (auto v = val.dyn_cast<mlir::StringAttr>())
       result.attributes.push_back(builder.getNamedAttr(value(), v));
     else if (auto v = val.dyn_cast<mlir::ArrayAttr>())
       result.attributes.push_back(builder.getNamedAttr(xlist(), v));
     else
-      return mlir::failure();
+      return parser.emitError(parser.getCurrentLocation(),
+                              "found an invalid constant");
     mlir::IntegerAttr sz;
     mlir::Type type;
     if (parser.parseLParen() ||
         parser.parseAttribute(sz, size(), result.attributes) ||
         parser.parseRParen() ||
         parser.parseColonType(type))
       return mlir::failure();
+    if (!(type.isa<fir::CharacterType>() || type.isa<mlir::IntegerType>()))
+      return parser.emitError(parser.getCurrentLocation(),
+                              "must have character type");
     type = fir::SequenceType::get({sz.getInt()}, type);
-    if (!type ||
-        parser.addTypesToList(type, result.types))
+    if (!type || parser.addTypesToList(type, result.types))
       return mlir::failure();
     return mlir::success();
   }];
 
   let printer = [{
     p << getOperationName() << ' ' << getValue() << '(';
     p << getSize().cast<mlir::IntegerAttr>().getValue() << ") : ";
     p.printType(getType().cast<fir::SequenceType>().getEleTy());
let extraClassDeclaration = [{
     bool isWideValue();
   }];
 }
 
 // Complex operations
 
 class fir_ArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
     fir_Op<mnemonic,
            !listconcat(traits, [NoSideEffect, SameOperandsAndResultType])>,
     Results<(outs AnyType)> {
   let parser = [{
     return impl::parseOneResultSameOperandTypeOp(parser, result);
   }];
 
   let printer = [{ return printBinaryOp(this->getOperation(), p); }];
 }
 
 class fir_UnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
       fir_Op<mnemonic,
              !listconcat(traits, [NoSideEffect, SameOperandsAndResultType])>,
       Results<(outs AnyType)> {
   let parser = [{
     return impl::parseOneResultSameOperandTypeOp(parser, result);
   }];
 
   let printer = [{ return printUnaryOp(this->getOperation(), p); }];
 }
 
class RealUnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
       Arguments<(ins AnyRealLike:$operand)>;
 
 def fir_NegfOp : RealUnaryArithmeticOp<"negf">;
 
 class RealArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
       fir_ArithmeticOp<mnemonic, traits>,
       Arguments<(ins AnyRealLike:$lhs, AnyRealLike:$rhs)>;
 
-def fir_AddfOp : RealArithmeticOp<"addf", [Commutative]>;
-def fir_SubfOp : RealArithmeticOp<"subf">;
-def fir_MulfOp : RealArithmeticOp<"mulf", [Commutative]>;
+def fir_AddfOp : RealArithmeticOp<"addf", [Commutative]> {
+  let hasFolder = 1;
+}
+def fir_SubfOp : RealArithmeticOp<"subf"> {
+  let hasFolder = 1;
+}
+def fir_MulfOp : RealArithmeticOp<"mulf", [Commutative]> {
+  let hasFolder = 1;
+}
 def fir_DivfOp : RealArithmeticOp<"divf">;
 def fir_ModfOp : RealArithmeticOp<"modf">;
 // Pow is a builtin call and not a primitive
 
 def fir_CmpfOp : fir_Op<"cmpf",
     [NoSideEffect, SameTypeOperands, SameOperandsAndResultShape]> {
   let summary = "floating-point comparison operator";
 
let extraClassDeclaration = [{
 
     CmpFPredicate getPredicate() {
       return (CmpFPredicate)getAttrOfType<mlir::IntegerAttr>(
           getPredicateAttrName()).getInt();
     }
   }];
 }
 
-def fir_ConstcOp : fir_Op<"constc", [NoSideEffect]>,
-    Results<(outs fir_ComplexType)> {
+def fir_ConstcOp : fir_Op<"constc", [NoSideEffect]> {
   let summary = "create a complex constant";
 
   let description = [{
     A complex constant. Similar to the standard dialect complex type, but this
     extension allows constants with APFloat values that are not supported in
     the standard dialect.
   }];
 
+  let results = (outs fir_ComplexType);
+  
   let parser = [{
     fir::RealAttr realp;
     fir::RealAttr imagp;
     mlir::Type type;
     if (parser.parseLParen() ||
         parser.parseAttribute(realp, realAttrName(), result.attributes) ||
         parser.parseComma() ||
         parser.parseAttribute(imagp, imagAttrName(), result.attributes) ||
let extraClassDeclaration = [{
     }
   }];
 }
 
 // Other misc. operations
 
 def fir_AddrOfOp : fir_OneResultOp<"address_of", [NoSideEffect]> {
   let summary = "convert a symbol to an SSA value";
+  
   let description = [{
     Convert a symbol (a function or global reference) to an SSA-value to be
     used in other Operations.
 
     ```mlir
       %p = fir.address_of(@symbol) : !fir.ref<f64>
     ```
   }];
 
   let arguments = (ins SymbolRefAttr:$symbol);
 
   let results = (outs fir_ReferenceType:$resTy);
 
   let assemblyFormat = "`(` $symbol `)` attr-dict `:` type($resTy)";
 }
 
 def fir_ConvertOp : fir_OneResultOp<"convert", [NoSideEffect]> {
   let summary = "encapsulates all Fortran scalar type conversions";
+  
   let description = [{
     Generalized type conversion. Convert the ssa value from type T to type U.
     Not all pairs of types have conversions. When types T and U are the same
     type, this instruction is a NOP and may be folded away.
 
     ```mlir
       %v = ... : i64
       %w = fir.convert %v : (i64) -> i32
     ```
 
     The example truncates the value `%v` from an i64 to an i32.
   }];
 
   let arguments = (ins AnyType:$value);
 
   let assemblyFormat = [{
     $value attr-dict `:` functional-type($value, results)
   }];
+
+  let hasFolder = 1;
+
+  let verifier = [{
+    auto inType = value().getType();
+    auto outType = getType();
+    if (inType == outType)
+      return mlir::success();
+    if ((isPointerCompatible(inType) && isPointerCompatible(outType)) ||
+        (isIntegerCompatible(inType) && isIntegerCompatible(outType)) ||
+        (isIntegerCompatible(inType) && isFloatCompatible(outType)) ||
+        (isFloatCompatible(inType) && isIntegerCompatible(outType)) ||
+        (isFloatCompatible(inType) && isFloatCompatible(outType)) ||
+        (isIntegerCompatible(inType) && isPointerCompatible(outType)) ||
+        (isPointerCompatible(inType) && isIntegerCompatible(outType)) ||
+        (inType.isa<fir::BoxType>() && outType.isa<fir::BoxType>()) ||
+        (fir::isa_complex(inType) && fir::isa_complex(outType)))
+      return mlir::success();
+    return emitOpError("invalid type conversion");
+  }];
+
+  let extraClassDeclaration = [{
+    static bool isIntegerCompatible(mlir::Type ty);
+    static bool isFloatCompatible(mlir::Type ty);
+    static bool isPointerCompatible(mlir::Type ty);
+  }];
 }
 
 def FortranTypeAttr : Attr<And<[CPred<"$_self.isa<TypeAttr>()">,
     Or<[CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::CharacterType>()">,
         CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::CplxType>()">,
         CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::IntType>()">,
         CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::LogicalType>()">,
         CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::RealType>()">,
let extraClassDeclaration = [{
     mlir::Type getInType() {
       // get the type that the type descriptor describes
       return getAttrOfType<mlir::TypeAttr>("in_type").getValue();
     }
   }];
 }
 
 def fir_NoReassocOp : fir_OneResultOp<"no_reassoc",
-    [SameOperandsAndResultType]> {
+    [NoSideEffect, SameOperandsAndResultType]> {
   let summary = "synthetic op to prevent reassociation";
   let description = [{
     Primitive operation meant to intrusively prevent operator reassociation.
     The operation is otherwise a nop and the value returned is the same as the
     argument.
 
     The presence of this operation prevents any local optimizations. In the
     example below, this would prevent possibly replacing the multiply and add
let description = [{
     ```mlir
       fir.global @_QV_Mquark_Vvarble : tuple<i32, f32> {
         %1 = constant 1 : i32
         %2 = constant 2.0 : f32
         %3 = fir.undefined tuple<i32, f32>
         %z = constant 0 : index
         %o = constant 1 : index
         %4 = fir.insert_value %3, %1, %z : (tuple<i32, f32>, i32, index) -> tuple<i32, f32>
-        %5 = fir.insert_value %4, %1, %o : (tuple<i32, f32>, f32, index) -> tuple<i32, f32>
-        return %5
+        %5 = fir.insert_value %4, %2, %o : (tuple<i32, f32>, f32, index) -> tuple<i32, f32>
+        fir.has_value %5 : tuple<i32, f32>
       }
     ```
   }];
 
   let arguments = (ins
     StrAttr:$sym_name,
-    OptionalAttr<AnyAttr>:$initval,
-    UnitAttr:$constant,
-    TypeAttr:$type
+    SymbolRefAttr:$symref,
+    TypeAttr:$type,
+    OptionalAttr<AnyAttr>:$initVal,
+    OptionalAttr<UnitAttr>:$constant,
+    OptionalAttr<StrAttr>:$linkName
   );
 
   let regions = (region AtMostRegion<1>:$region);
 
-  let parser = [{
-    // Parse the name as a symbol reference attribute.
-    SymbolRefAttr nameAttr;
-    if (parser.parseAttribute(nameAttr, mlir::SymbolTable::getSymbolAttrName(),
-                              result.attributes))
-      return failure();
-
-    auto &builder = parser.getBuilder();
-    auto name = nameAttr.getRootReference();
-    result.attributes.back().second = builder.getStringAttr(name);
-
-    bool simpleInitializer = false;
-    if (!parser.parseOptionalLParen()) {
-      Attribute attr;
-      if (parser.parseAttribute(attr, initValAttrName(), result.attributes) ||
-          parser.parseRParen())
-        return failure();
-      simpleInitializer = true;
-    }
-
-    if (succeeded(parser.parseOptionalKeyword(constantAttrName()))) {
-      // if "constant" keyword then mark this as a constant, not a variable
-      result.addAttribute(constantAttrName(), builder.getUnitAttr());
-    }
-
-    mlir::Type globalType;
-    if (parser.parseColonType(globalType))
-      return failure();
-
-    result.addAttribute(typeAttrName(), mlir::TypeAttr::get(globalType));
-
-    if (!simpleInitializer) {
-      // Parse the optional initializer body.
-      if (parser.parseRegion(*result.addRegion(), llvm::None, llvm::None))
-        return failure();
-    }
-
-    return success();
-  }];
+  let parser = "return parseGlobalOp(parser, result);";
 
   let printer = [{
-    auto varName = getAttrOfType<StringAttr>(
-      mlir::SymbolTable::getSymbolAttrName()).getValue();
-    p << getOperationName() << " @" << varName;
-    if (auto iv = initval().getValueOr(Attribute())) {
-      p << '(';
-      p.printAttribute(iv);
-      p << ')';
-    }
+    p << getOperationName();
+    if (linkName().hasValue())
+      p << ' ' << linkName().getValue();
+    p << ' ';
+    p.printAttributeWithoutType(getAttr(symbolAttrName()));
+    if (auto val = getValueOrNull())
+      p << '(' << val << ')';
     if (getAttr(constantAttrName()))
-      p << ' ' << constantAttrName();
+      p << " constant";
     p << " : ";
     p.printType(getType());
-    Region &body = getOperation()->getRegion(0);
-    if (!body.empty())
-      p.printRegion(body, /*printEntryBlockArgs=*/false,
-                          /*printBlockTerminators=*/true);
+    if (hasInitializationBody())
+      p.printRegion(getOperation()->getRegion(0), /*printEntryBlockArgs=*/false,
   }];
 
   let skipDefaultBuilders = 1;
   let builders = [
     OpBuilder<"mlir::Builder *builder, OperationState &result,"
-              "StringRef name, Type type, ArrayRef<NamedAttribute> attrs = {}",
-    [{
-      result.addAttribute(typeAttrName(), mlir::TypeAttr::get(type));
-      result.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
-                          builder->getStringAttr(name));
-      result.addAttributes(attrs);
-    }]>
+              "StringRef name, Type type, ArrayRef<NamedAttribute> attrs = {}">,
+    OpBuilder<"mlir::Builder *builder, OperationState &result,"
+              "StringRef name, bool isConstant, Type type,"
+        "ArrayRef<NamedAttribute> attrs = {}">,
+    OpBuilder<"mlir::Builder *builder, OperationState &result,"
+              "StringRef name, Type type, StringAttr linkage = {},"
+        "ArrayRef<NamedAttribute> attrs = {}">,
+    OpBuilder<"mlir::Builder *builder, OperationState &result,"
+              "StringRef name, bool isConstant, Type type,"
+        "StringAttr linkage = {},"
+        "ArrayRef<NamedAttribute> attrs = {}">,
+    OpBuilder<"mlir::Builder *builder, OperationState &result,"
+              "StringRef name, Type type, Attribute initVal,"
+        "StringAttr linkage = {},"
+        "ArrayRef<NamedAttribute> attrs = {}">,
+    OpBuilder<"mlir::Builder *builder, OperationState &result,"
+              "StringRef name, bool isConstant, Type type,"
+        "Attribute initVal, StringAttr linkage = {},"
+        "ArrayRef<NamedAttribute> attrs = {}">,
   ];
 
   let extraClassDeclaration = [{
+    static constexpr llvm::StringRef symbolAttrName() { return "symref"; }
     static constexpr llvm::StringRef constantAttrName() { return "constant"; }
-    static constexpr llvm::StringRef initValAttrName() { return "initval"; }
+    static constexpr llvm::StringRef initValAttrName() { return "initVal"; }
+    static constexpr llvm::StringRef linkageAttrName() { return "linkName"; }
     static constexpr llvm::StringRef typeAttrName() { return "type"; }
 
+    /// The printable type of the global
     mlir::Type getType() {
       return getAttrOfType<TypeAttr>(typeAttrName()).getValue();
     }
 
+    /// The semantic type of the global
+    mlir::Type resultType() {
+      return fir::AllocaOp::wrapResultType(getType());
+    }
+    
+    /// Return the initializer attribute if it exists, or a null attribute.
+    Attribute getValueOrNull() { return initVal().getValueOr(Attribute()); }
+
     /// Append the next initializer value to the `GlobalOp` to construct
     /// the variable's initial value.
     void appendInitialValue(mlir::Operation *op);
 
     /// A GlobalOp has one region.
     mlir::Region &getRegion() { return getOperation()->getRegion(0); }
 
     /// A GlobalOp has one block.
     mlir::Block &getBlock() { return getRegion().front(); }
+
+    /// Determine if `linkage` is a supported keyword
+    static mlir::ParseResult verifyValidLinkage(StringRef linkage);
+
+    bool hasInitializationBody() {
+      return (getOperation()->getNumRegions() == 1) && !getRegion().empty() &&
+        !isa<fir::FirEndOp>(getBlock().front());
+    }
+
+    mlir::FlatSymbolRefAttr getSymbol() {
+      return mlir::FlatSymbolRefAttr::get(getAttrOfType<mlir::StringAttr>(
+          mlir::SymbolTable::getSymbolAttrName()).getValue(), getContext());
+    }
   }];
 }
 
 def fir_GlobalLenOp : fir_Op<"global_len", []> {
   let summary = "map a LEN parameter to a global";
   let description = [{
     A global entity (that is not an automatic data object) can have extra LEN
     parameter (compile-time) constants associated with the instance's type.
def fir_GlobalLenOp : fir_Op<"global_len", []> {
   }];
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef lenParamAttrName() { return "lenparam"; }
     static constexpr llvm::StringRef intAttrName() { return "intval"; }
   }];
 }
 
-def fir_DispatchTableOp : fir_Op<"dispatch_table", [IsolatedFromAbove, Symbol,
-                                 ImplicitFirTerminator]> {
+def ImplicitFirTerminator : SingleBlockImplicitTerminator<"FirEndOp">;
+
+def fir_DispatchTableOp : fir_Op<"dispatch_table",
+    [IsolatedFromAbove, Symbol, ImplicitFirTerminator]> {
   let summary = "Dispatch table definition";
 
   let description = [{
     Define a dispatch table for a derived type with type-bound procedures.
 
     A dispatch table is an untyped symbol that contains a list of associations
     between method identifiers and corresponding `FuncOp` symbols.
 

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

 //===-- Optimizer/Dialect/FIRType.h -- FIR types ----------------*- 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
 //
 //===----------------------------------------------------------------------===//
 

 template <typename>
 class ArrayRef;
 class hash_code;
 } // namespace llvm
 
 namespace mlir {
 class DialectAsmParser;
 class DialectAsmPrinter;
+class ComplexType;
+class FloatType;
 } // namespace mlir
 
 namespace fir {
 
 class FIROpsDialect;
 
 using KindTy = int;
 

 bool isa_std_type(mlir::Type t);
 
 /// Is `t` any of the FIR dialect or Standard dialect types?
 bool isa_fir_or_std_type(mlir::Type t);
 
 /// Is `t` a FIR dialect type that implies a memory (de)reference?
 bool isa_ref_type(mlir::Type t);
 
+/// Is `t` a type that is always trivially pass-by-reference?
+bool isa_passbyref_type(mlir::Type t);
+
+/// Is `t` a boxed type?
+bool isa_box_type(mlir::Type t);
+
+/// Is `t` a type that can conform to be pass-by-reference? Depending on the
+/// context, these types may simply demote to pass-by-reference or a reference
+/// to them may have to be passed instead.
+inline bool conformsWithPassByRef(mlir::Type t) {
+  return isa_ref_type(t) || isa_box_type(t);
+}
+
 /// Is `t` a FIR dialect aggregate type?
 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);
 
 /// Boilerplate mixin template

 /// parameter. COMPLEX is a floating point type with a real and imaginary
 /// member.
 class CplxType : public mlir::Type::TypeBase<CplxType, mlir::Type,
                                              detail::CplxTypeStorage>,
                  public IntrinsicTypeMixin<CplxType, TypeKind::FIR_COMPLEX> {
 public:
   using Base::Base;
   static CplxType get(mlir::MLIRContext *ctxt, KindTy kind);
+
+  /// Get the corresponding fir.real<k> type.
+  mlir::Type getElementType() const;
+
   KindTy getFKind() const;
 };
 
 /// Model of a Fortran INTEGER intrinsic type, including the KIND type
 /// parameter.
 class IntType
     : public mlir::Type::TypeBase<IntType, mlir::Type, detail::IntTypeStorage>,
       public IntrinsicTypeMixin<IntType, TypeKind::FIR_INT> {
public:
   /// returned will be empty.
   Shape getShape() const;
 
   mlir::AffineMapAttr getLayoutMap() const;
 
   /// The number of dimensions of the sequence
   unsigned getDimension() const { return getShape().size(); }
 
+  /// Number of rows of constant extent
+  unsigned getConstantRows() const;
+
+  /// Is the shape of the sequence constant?
+  bool hasConstantShape() const { return getConstantRows() == getDimension(); }
+
+  /// Does the sequence have unknown shape? (`array<* x T>`)
+  bool hasUnknownShape() const { return getShape().empty(); }
+
+  /// Is the interior of the sequence constant? Check if the array is
+  /// one of constant shape (`array<C...xCxT>`), unknown shape
+  /// (`array<*xT>`), or rows with shape and ending with column(s) of
+  /// unknown extent (`array<C...xCx?...x?xT>`).
+  bool hasConstantInterior() const;
+
   /// The value `-1` represents an unknown extent for a dimension
   static constexpr Extent getUnknownExtent() { return -1; }
 
   static bool kindof(unsigned kind) { return kind == TypeKind::FIR_SEQUENCE; }
 
   static mlir::LogicalResult
   verifyConstructionInvariants(mlir::Location loc, const Shape &shape,
                                mlir::Type eleTy, mlir::AffineMapAttr map);
public:
   static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
                                                           llvm::StringRef name);
 };
 
 mlir::Type parseFirType(FIROpsDialect *, mlir::DialectAsmParser &parser);
 
 void printFirType(FIROpsDialect *, mlir::Type ty, mlir::DialectAsmPrinter &p);
 
+/// Guarantee `type` is a scalar integral type (standard Integer, standard
+/// Index, or FIR Int). Aborts execution if condition is false.
+void verifyIntegralType(mlir::Type type);
+
+/// Is `t` a FIR Real or MLIR Float type?
+inline bool isa_real(mlir::Type t) {
+  return t.isa<fir::RealType>() || t.isa<mlir::FloatType>();
+}
+
+/// Is `t` a FIR or MLIR Complex type?
+inline bool isa_complex(mlir::Type t) {
+  return t.isa<fir::CplxType>() || t.isa<mlir::ComplexType>();
+}
+
 } // namespace fir
 
 #endif // OPTIMIZER_DIALECT_FIRTYPE_H

flang/include/flang/Optimizer/Support/InternalNames.h

+//===-- Optimizer/Support/InternalNames.h -----------------------*- 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_SUPPORT_INTERNALNAMES_H
+#define OPTIMIZER_SUPPORT_INTERNALNAMES_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringRef.h"
+#include <cstdint>
+
+namespace fir {
+
+/// Internal name mangling of identifiers
+///
+/// In order to generate symbolically referencable artifacts in a ModuleOp,
+/// it is required that those symbols be uniqued.  This is a simple interface
+/// for converting Fortran symbols into unique names.
+///
+/// This is intentionally bijective. Given a symbol's parse name, type, and
+/// scope-like information, we can generate a uniqued (mangled) name.  Given a
+/// uniqued name, we can return the symbol parse name, type of the symbol, and
+/// any scope-like information for that symbol.
+struct NameUniquer {
+  enum class IntrinsicType { CHARACTER, COMPLEX, INTEGER, LOGICAL, REAL };
+
+  /// The sort of the unique name
+  enum class NameKind {
+    NOT_UNIQUED,
+    COMMON,
+    CONSTANT,
+    DERIVED_TYPE,
+    DISPATCH_TABLE,
+    GENERATED,
+    INTRINSIC_TYPE_DESC,
+    PROCEDURE,
+    TYPE_DESC,
+    VARIABLE
+  };
+
+  /// Components of an unparsed unique name
+  struct DeconstructedName {
+    DeconstructedName(llvm::StringRef name) : name{name} {}
+    DeconstructedName(llvm::ArrayRef<std::string> modules,
+                      llvm::Optional<std::string> host, llvm::StringRef name,
+                      llvm::ArrayRef<std::int64_t> kinds)
+        : modules{modules.begin(), modules.end()}, host{host}, name{name},
+          kinds{kinds.begin(), kinds.end()} {}
+
+    llvm::SmallVector<std::string, 2> modules;
+    llvm::Optional<std::string> host;
+    std::string name;
+    llvm::SmallVector<std::int64_t, 4> kinds;
+  };
+
+  NameUniquer() = default;
+
+  /// Unique a common block name
+  std::string doCommonBlock(llvm::StringRef name);
+
+  /// Unique a (global) constant name
+  std::string doConstant(llvm::ArrayRef<llvm::StringRef> modules,
+                         llvm::StringRef name);
+
+  /// Unique a dispatch table name
+  std::string doDispatchTable(llvm::ArrayRef<llvm::StringRef> modules,
+                              llvm::Optional<llvm::StringRef> host,
+                              llvm::StringRef name,
+                              llvm::ArrayRef<std::int64_t> kinds);
+
+  /// Unique a compiler generated name
+  std::string doGenerated(llvm::StringRef name);
+
+  /// Unique an intrinsic type descriptor
+  std::string doIntrinsicTypeDescriptor(llvm::ArrayRef<llvm::StringRef> modules,
+                                        llvm::Optional<llvm::StringRef> host,
+                                        IntrinsicType type, std::int64_t kind);
+
+  /// Unique a procedure name
+  std::string doProcedure(llvm::ArrayRef<llvm::StringRef> modules,
+                          llvm::Optional<llvm::StringRef> host,
+                          llvm::StringRef name);
+
+  /// Unique a derived type name
+  std::string doType(llvm::ArrayRef<llvm::StringRef> modules,
+                     llvm::Optional<llvm::StringRef> host, llvm::StringRef name,
+                     llvm::ArrayRef<std::int64_t> kinds);
+
+  /// Unique a (derived) type descriptor name
+  std::string doTypeDescriptor(llvm::ArrayRef<llvm::StringRef> modules,
+                               llvm::Optional<llvm::StringRef> host,
+                               llvm::StringRef name,
+                               llvm::ArrayRef<std::int64_t> kinds);
+  std::string doTypeDescriptor(llvm::ArrayRef<std::string> modules,
+                               llvm::Optional<std::string> host,
+                               llvm::StringRef name,
+                               llvm::ArrayRef<std::int64_t> kinds);
+
+  /// Unique a (global) variable name. A variable with save attribute
+  /// defined inside a subprogram also needs to be handled here
+  std::string doVariable(llvm::ArrayRef<llvm::StringRef> modules,
+                         llvm::Optional<llvm::StringRef> host,
+                         llvm::StringRef name);
+
+  /// Entry point for the PROGRAM (called by the runtime)
+  /// Can be overridden with the `--main-entry-name=<name>` option.
+  static llvm::StringRef doProgramEntry();
+
+  /// Decompose `uniquedName` into the parse name, symbol type, and scope info
+  static std::pair<NameKind, DeconstructedName>
+  deconstruct(llvm::StringRef uniquedName);
+
+private:
+  std::string intAsString(std::int64_t i);
+  std::string doKind(std::int64_t kind);
+  std::string doKinds(llvm::ArrayRef<std::int64_t> kinds);
+  std::string toLower(llvm::StringRef name);
+};
+
+} // namespace fir
+
+#endif // OPTIMIZER_SUPPORT_INTERNALNAMES_H

flang/lib/Optimizer/Dialect/FIRAttr.cpp

 //===-- FIRAttr.cpp -------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Optimizer/Dialect/FIRAttr.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
-#include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Support/KindMapping.h"
 #include "mlir/IR/AttributeSupport.h"
-#include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/Types.h"
-#include "mlir/Parser.h"
 #include "llvm/ADT/SmallString.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Twine.h"
 
 using namespace fir;
 
 namespace fir {
 namespace detail {
 
 struct RealAttributeStorage : public mlir::AttributeStorage {
   using KeyTy = std::pair<int, llvm::APFloat>;

flang/lib/Optimizer/Dialect/FIRDialect.cpp

 //===-- FIRDialect.cpp ----------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIRAttr.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
-#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
-#include "mlir/IR/StandardTypes.h"
 
 using namespace fir;
 
 fir::FIROpsDialect::FIROpsDialect(mlir::MLIRContext *ctx)
     : mlir::Dialect("fir", ctx) {
   addTypes<BoxType, BoxCharType, BoxProcType, CharacterType, CplxType, DimsType,
            FieldType, HeapType, IntType, LenType, LogicalType, PointerType,
            RealType, RecordType, ReferenceType, SequenceType, TypeDescType>();

flang/lib/Optimizer/Dialect/FIROps.cpp

 //===-- FIROps.cpp --------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRAttr.h"
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
+#include "mlir/Dialect/CommonFolders.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Function.h"
+#include "mlir/IR/Matchers.h"
 #include "mlir/IR/Module.h"
-#include "mlir/IR/StandardTypes.h"
-#include "mlir/IR/SymbolTable.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/TypeSwitch.h"
 
 using namespace fir;
 
-/// return true if the sequence type is abstract or the record type is malformed
-/// or contains an abstract sequence type
+/// Return true if a sequence type is of some incomplete size or a record type
+/// is malformed or contains an incomplete sequence type. An incomplete sequence
+/// type is one with more unknown extents in the type than have been provided
+/// via `dynamicExtents`. Sequence types with an unknown rank are incomplete by
+/// definition.
 static bool verifyInType(mlir::Type inType,
-                         llvm::SmallVectorImpl<llvm::StringRef> &visited) {
+                         llvm::SmallVectorImpl<llvm::StringRef> &visited,
+                         unsigned dynamicExtents = 0) {
   if (auto st = inType.dyn_cast<fir::SequenceType>()) {
     auto shape = st.getShape();
     if (shape.size() == 0)
       return true;
-    for (auto ext : shape)
-      if (ext < 0)
+    for (std::size_t i = 0, end{shape.size()}; i < end; ++i) {
+      if (shape[i] != fir::SequenceType::getUnknownExtent())
+        continue;
+      if (dynamicExtents-- == 0)
         return true;
+    }
   } else if (auto rt = inType.dyn_cast<fir::RecordType>()) {
     // don't recurse if we're already visiting this one
     if (llvm::is_contained(visited, rt.getName()))
       return false;
     // keep track of record types currently being visited
     visited.push_back(rt.getName());
     for (auto &field : rt.getTypeList())
       if (verifyInType(field.second, visited))
if (numLenParams > 0) {
     if (auto rt = inType.dyn_cast<fir::RecordType>())
       return numLenParams != rt.getNumLenParams();
     return true;
   }
   return false;
 }
 
 //===----------------------------------------------------------------------===//
+// AddfOp
+//===----------------------------------------------------------------------===//
+
+mlir::OpFoldResult fir::AddfOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
+  return mlir::constFoldBinaryOp<FloatAttr>(
+      opnds, [](APFloat a, APFloat b) { return a + b; });
+}
+
+//===----------------------------------------------------------------------===//
 // AllocaOp
 //===----------------------------------------------------------------------===//
 
 mlir::Type fir::AllocaOp::getAllocatedType() {
   return getType().cast<ReferenceType>().getEleTy();
 }
 
 /// Create a legal memory reference as return type
mlir::Type fir::AllocMemOp::wrapResultType(mlir::Type intype) {
   // FIR semantics: one may not allocate a memory reference value
   if (intype.isa<ReferenceType>() || intype.isa<HeapType>() ||
       intype.isa<PointerType>() || intype.isa<FunctionType>())
     return {};
   return HeapType::get(intype);
 }
 
 //===----------------------------------------------------------------------===//
+// BoxAddrOp
+//===----------------------------------------------------------------------===//
+
+mlir::OpFoldResult fir::BoxAddrOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
+  if (auto v = val().getDefiningOp()) {
+    if (auto box = dyn_cast<fir::EmboxOp>(v))
+      return box.memref();
+    if (auto box = dyn_cast<fir::EmboxCharOp>(v))
+      return box.memref();
+  }
+  return {};
+}
+
+//===----------------------------------------------------------------------===//
+// BoxCharLenOp
+//===----------------------------------------------------------------------===//
+
+mlir::OpFoldResult
+fir::BoxCharLenOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
+  if (auto v = val().getDefiningOp()) {
+    if (auto box = dyn_cast<fir::EmboxCharOp>(v))
+      return box.len();
+  }
+  return {};
+}
+
+//===----------------------------------------------------------------------===//
 // BoxDimsOp
 //===----------------------------------------------------------------------===//
 
 /// Get the result types packed in a tuple tuple
 mlir::Type fir::BoxDimsOp::getTupleType() {
   // note: triple, but 4 is nearest power of 2
   llvm::SmallVector<mlir::Type, 4> triple{
       getResult(0).getType(), getResult(1).getType(), getResult(2).getType()};

 static void printCmpcOp(OpAsmPrinter &p, fir::CmpcOp op) { printCmpOp(p, op); }
 
 mlir::ParseResult fir::parseCmpcOp(mlir::OpAsmParser &parser,
                                    mlir::OperationState &result) {
   return parseCmpOp<fir::CmpcOp>(parser, result);
 }
 
 //===----------------------------------------------------------------------===//
+// ConvertOp
+//===----------------------------------------------------------------------===//
+
+mlir::OpFoldResult fir::ConvertOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
+  if (value().getType() == getType())
+    return value();
+  if (matchPattern(value(), m_Op<fir::ConvertOp>())) {
+    auto inner = cast<fir::ConvertOp>(value().getDefiningOp());
+    // (convert (convert 'a : logical -> i1) : i1 -> logical) ==> forward 'a
+    if (auto toTy = getType().dyn_cast<fir::LogicalType>())
+      if (auto fromTy = inner.value().getType().dyn_cast<fir::LogicalType>())
+        if (inner.getType().isa<mlir::IntegerType>() && (toTy == fromTy))
+          return inner.value();
+    // (convert (convert 'a : i1 -> logical) : logical -> i1) ==> forward 'a
+    if (auto toTy = getType().dyn_cast<mlir::IntegerType>())
+      if (auto fromTy = inner.value().getType().dyn_cast<mlir::IntegerType>())
+        if (inner.getType().isa<fir::LogicalType>() && (toTy == fromTy) &&
+            (fromTy.getWidth() == 1))
+          return inner.value();
+  }
+  return {};
+}
+
+bool fir::ConvertOp::isIntegerCompatible(mlir::Type ty) {
+  return ty.isa<mlir::IntegerType>() || ty.isa<mlir::IndexType>() ||
+         ty.isa<fir::IntType>() || ty.isa<fir::LogicalType>() ||
+         ty.isa<fir::CharacterType>();
+}
+
+bool fir::ConvertOp::isFloatCompatible(mlir::Type ty) {
+  return ty.isa<mlir::FloatType>() || ty.isa<fir::RealType>();
+}
+
+bool fir::ConvertOp::isPointerCompatible(mlir::Type ty) {
+  return ty.isa<fir::ReferenceType>() || ty.isa<fir::PointerType>() ||
+         ty.isa<fir::HeapType>() || ty.isa<mlir::MemRefType>() ||
+         ty.isa<fir::TypeDescType>();
+}
+
+//===----------------------------------------------------------------------===//
+// CoordinateOp
+//===----------------------------------------------------------------------===//
+
+static mlir::ParseResult parseCoordinateOp(mlir::OpAsmParser &parser,
+                                           mlir::OperationState &result) {
+  llvm::ArrayRef<mlir::Type> allOperandTypes;
+  llvm::ArrayRef<mlir::Type> allResultTypes;
+  llvm::SMLoc allOperandLoc = parser.getCurrentLocation();
+  llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> allOperands;
+  if (parser.parseOperandList(allOperands))
+    return failure();
+  if (parser.parseOptionalAttrDict(result.attributes))
+    return failure();
+  if (parser.parseColon())
+    return failure();
+
+  mlir::FunctionType funcTy;
+  if (parser.parseType(funcTy))
+    return failure();
+  allOperandTypes = funcTy.getInputs();
+  allResultTypes = funcTy.getResults();
+  result.addTypes(allResultTypes);
+  if (parser.resolveOperands(allOperands, allOperandTypes, allOperandLoc,
+                             result.operands))
+    return failure();
+  if (funcTy.getNumInputs()) {
+    // No inputs handled by verify
+    result.addAttribute(fir::CoordinateOp::baseType(),
+                        mlir::TypeAttr::get(funcTy.getInput(0)));
+  }
+  return success();
+}
+
+mlir::Type fir::CoordinateOp::getBaseType() {
+  return getAttr(CoordinateOp::baseType()).cast<mlir::TypeAttr>().getValue();
+}
+
+void fir::CoordinateOp::build(Builder *, OperationState &result,
+                              mlir::Type resType, ValueRange operands,
+                              ArrayRef<NamedAttribute> attrs) {
+  assert(operands.size() >= 1u && "mismatched number of parameters");
+  result.addOperands(operands);
+  result.addAttribute(fir::CoordinateOp::baseType(),
+                      mlir::TypeAttr::get(operands[0].getType()));
+  result.attributes.append(attrs.begin(), attrs.end());
+  result.addTypes({resType});
+}
+
+void fir::CoordinateOp::build(Builder *builder, OperationState &result,
+                              mlir::Type resType, mlir::Value ref,
+                              ValueRange coor, ArrayRef<NamedAttribute> attrs) {
+  llvm::SmallVector<mlir::Value, 16> operands{ref};
+  operands.append(coor.begin(), coor.end());
+  build(builder, result, resType, operands, attrs);
+}
+
+//===----------------------------------------------------------------------===//
 // DispatchOp
 //===----------------------------------------------------------------------===//
 
 mlir::FunctionType fir::DispatchOp::getFunctionType() {
   auto attr = getAttr("fn_type").cast<mlir::TypeAttr>();
   return attr.getValue().cast<mlir::FunctionType>();
 }
 
void fir::GenTypeDescOp::build(Builder *, OperationState &result,
   result.addAttribute("in_type", inty);
   result.addTypes(TypeDescType::get(inty.getValue()));
 }
 
 //===----------------------------------------------------------------------===//
 // GlobalOp
 //===----------------------------------------------------------------------===//
 
+static ParseResult parseGlobalOp(OpAsmParser &parser, OperationState &result) {
+  // Parse the optional linkage
+  llvm::StringRef linkage;
+  auto &builder = parser.getBuilder();
+  if (mlir::succeeded(parser.parseOptionalKeyword(&linkage))) {
+    if (fir::GlobalOp::verifyValidLinkage(linkage))
+      return failure();
+    mlir::StringAttr linkAttr = builder.getStringAttr(linkage);
+    result.addAttribute(fir::GlobalOp::linkageAttrName(), linkAttr);
+  }
+
+  // Parse the name as a symbol reference attribute.
+  mlir::SymbolRefAttr nameAttr;
+  if (parser.parseAttribute(nameAttr, fir::GlobalOp::symbolAttrName(),
+                            result.attributes))
+    return failure();
+  result.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
+                      builder.getStringAttr(nameAttr.getRootReference()));
+
+  bool simpleInitializer = false;
+  if (mlir::succeeded(parser.parseOptionalLParen())) {
+    Attribute attr;
+    if (parser.parseAttribute(attr, fir::GlobalOp::initValAttrName(),
+                              result.attributes) ||
+        parser.parseRParen())
+      return failure();
+    simpleInitializer = true;
+  }
+
+  if (succeeded(parser.parseOptionalKeyword("constant"))) {
+    // if "constant" keyword then mark this as a constant, not a variable
+    result.addAttribute(fir::GlobalOp::constantAttrName(),
+                        builder.getUnitAttr());
+  }
+
+  mlir::Type globalType;
+  if (parser.parseColonType(globalType))
+    return failure();
+
+  result.addAttribute(fir::GlobalOp::typeAttrName(),
+                      mlir::TypeAttr::get(globalType));
+
+  if (simpleInitializer) {
+    result.addRegion();
+  } else {
+    // Parse the optional initializer body.
+    if (parser.parseRegion(*result.addRegion(), llvm::None, llvm::None))
+      return failure();
+  }
+
+  return success();
+}
+
 void fir::GlobalOp::appendInitialValue(mlir::Operation *op) {
   getBlock().getOperations().push_back(op);
 }
 
+void fir::GlobalOp::build(mlir::Builder *builder, OperationState &result,
+                          StringRef name, bool isConstant, Type type,
+                          Attribute initialVal, StringAttr linkage,
+                          ArrayRef<NamedAttribute> attrs) {
+  result.addRegion();
+  result.addAttribute(typeAttrName(), mlir::TypeAttr::get(type));
+  result.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
+                      builder->getStringAttr(name));
+  result.addAttribute(symbolAttrName(), builder->getSymbolRefAttr(name));
+  if (isConstant)
+    result.addAttribute(constantAttrName(), builder->getUnitAttr());
+  if (initialVal)
+    result.addAttribute(initValAttrName(), initialVal);
+  if (linkage)
+    result.addAttribute(linkageAttrName(), linkage);
+  result.attributes.append(attrs.begin(), attrs.end());
+}
+
+void fir::GlobalOp::build(mlir::Builder *builder, OperationState &result,
+                          StringRef name, Type type, Attribute initialVal,
+                          StringAttr linkage, ArrayRef<NamedAttribute> attrs) {
+  build(builder, result, name, /*isConstant=*/false, type, {}, linkage, attrs);
+}
+
+void fir::GlobalOp::build(mlir::Builder *builder, OperationState &result,
+                          StringRef name, bool isConstant, Type type,
+                          StringAttr linkage, ArrayRef<NamedAttribute> attrs) {
+  build(builder, result, name, isConstant, type, {}, linkage, attrs);
+}
+
+void fir::GlobalOp::build(mlir::Builder *builder, OperationState &result,
+                          StringRef name, Type type, StringAttr linkage,
+                          ArrayRef<NamedAttribute> attrs) {
+  build(builder, result, name, /*isConstant=*/false, type, {}, linkage, attrs);
+}
+
+void fir::GlobalOp::build(mlir::Builder *builder, OperationState &result,
+                          StringRef name, bool isConstant, Type type,
+                          ArrayRef<NamedAttribute> attrs) {
+  build(builder, result, name, isConstant, type, StringAttr{}, attrs);
+}
+
+void fir::GlobalOp::build(mlir::Builder *builder, OperationState &result,
+                          StringRef name, Type type,
+                          ArrayRef<NamedAttribute> attrs) {
+  build(builder, result, name, /*isConstant=*/false, type, attrs);
+}
+
+mlir::ParseResult fir::GlobalOp::verifyValidLinkage(StringRef linkage) {
+  // Supporting only a subset of the LLVM linkage types for now
+  static const llvm::SmallVector<const char *, 3> validNames = {
+      "internal", "common", "weak"};
+  if (llvm::any_of(validNames,
+                   [&](const char *name) { return linkage == name; }))
+    return success();
+  return failure();
+}
+
+//===----------------------------------------------------------------------===//
+// IterWhileOp
+//===----------------------------------------------------------------------===//
+
+void fir::IterWhileOp::build(mlir::Builder *builder,
+                             mlir::OperationState &result, mlir::Value lb,
+                             mlir::Value ub, mlir::Value step,
+                             mlir::Value iterate, mlir::ValueRange iterArgs,
+                             llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+  result.addOperands({lb, ub, step, iterate});
+  result.addTypes(iterate.getType());
+  result.addOperands(iterArgs);
+  for (auto v : iterArgs)
+    result.addTypes(v.getType());
+  mlir::Region *bodyRegion = result.addRegion();
+  bodyRegion->push_back(new Block{});
+  bodyRegion->front().addArgument(builder->getIndexType());
+  bodyRegion->front().addArgument(iterate.getType());
+  for (auto v : iterArgs)
+    bodyRegion->front().addArgument(v.getType());
+  result.addAttributes(attributes);
+}
+
+static mlir::ParseResult parseIterWhileOp(mlir::OpAsmParser &parser,
+                                          mlir::OperationState &result) {
+  auto &builder = parser.getBuilder();
+  mlir::OpAsmParser::OperandType inductionVariable, lb, ub, step;
+  if (parser.parseLParen() || parser.parseRegionArgument(inductionVariable) ||
+      parser.parseEqual())
+    return mlir::failure();
+
+  // Parse loop bounds.
+  auto indexType = builder.getIndexType();
+  auto i1Type = builder.getIntegerType(1);
+  if (parser.parseOperand(lb) ||
+      parser.resolveOperand(lb, indexType, result.operands) ||
+      parser.parseKeyword("to") || parser.parseOperand(ub) ||
+      parser.resolveOperand(ub, indexType, result.operands) ||
+      parser.parseKeyword("step") || parser.parseOperand(step) ||
+      parser.parseRParen() ||
+      parser.resolveOperand(step, indexType, result.operands))
+    return mlir::failure();
+
+  mlir::OpAsmParser::OperandType iterateVar, iterateInput;
+  if (parser.parseKeyword("and") || parser.parseLParen() ||
+      parser.parseRegionArgument(iterateVar) || parser.parseEqual() ||
+      parser.parseOperand(iterateInput) || parser.parseRParen() ||
+      parser.resolveOperand(iterateInput, i1Type, result.operands))
+    return mlir::failure();
+
+  // Parse the initial iteration arguments.
+  llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> regionArgs;
+  // Induction variable.
+  regionArgs.push_back(inductionVariable);
+  regionArgs.push_back(iterateVar);
+  result.addTypes(i1Type);
+
+  if (mlir::succeeded(parser.parseOptionalKeyword("iter_args"))) {
+    llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> operands;
+    llvm::SmallVector<mlir::Type, 4> regionTypes;
+    // Parse assignment list and results type list.
+    if (parser.parseAssignmentList(regionArgs, operands) ||
+        parser.parseArrowTypeList(regionTypes))
+      return mlir::failure();
+    // Resolve input operands.
+    for (auto operand_type : llvm::zip(operands, regionTypes))
+      if (parser.resolveOperand(std::get<0>(operand_type),
+                                std::get<1>(operand_type), result.operands))
+        return mlir::failure();
+    result.addTypes(regionTypes);
+  }
+
+  if (parser.parseOptionalAttrDictWithKeyword(result.attributes))
+    return mlir::failure();
+
+  llvm::SmallVector<mlir::Type, 4> argTypes;
+  // Induction variable (hidden)
+  argTypes.push_back(indexType);
+  // Loop carried variables (including iterate)
+  argTypes.append(result.types.begin(), result.types.end());
+  // Parse the body region.
+  auto *body = result.addRegion();
+  if (regionArgs.size() != argTypes.size())
+    return parser.emitError(
+        parser.getNameLoc(),
+        "mismatch in number of loop-carried values and defined values");
+
+  if (parser.parseRegion(*body, regionArgs, argTypes))
+    return failure();
+
+  fir::IterWhileOp::ensureTerminator(*body, builder, result.location);
+
+  return mlir::success();
+}
+
+static mlir::LogicalResult verify(fir::IterWhileOp op) {
+  if (auto cst = dyn_cast_or_null<ConstantIndexOp>(op.step().getDefiningOp()))
+    if (cst.getValue() <= 0)
+      return op.emitOpError("constant step operand must be positive");
+
+  // Check that the body defines as single block argument for the induction
+  // variable.
+  auto *body = op.getBody();
+  if (!body->getArgument(1).getType().isInteger(1))
+    return op.emitOpError(
+        "expected body second argument to be an index argument for "
+        "the induction variable");
+  if (!body->getArgument(0).getType().isIndex())
+    return op.emitOpError(
+        "expected body first argument to be an index argument for "
+        "the induction variable");
+
+  auto opNumResults = op.getNumResults();
+  if (opNumResults == 0)
+    return mlir::failure();
+  if (op.getNumIterOperands() != opNumResults)
+    return op.emitOpError(
+        "mismatch in number of loop-carried values and defined values");
+  if (op.getNumRegionIterArgs() != opNumResults)
+    return op.emitOpError(
+        "mismatch in number of basic block args and defined values");
+  auto iterOperands = op.getIterOperands();
+  auto iterArgs = op.getRegionIterArgs();
+  auto opResults = op.getResults();
+  unsigned i = 0;
+  for (auto e : llvm::zip(iterOperands, iterArgs, opResults)) {
+    if (std::get<0>(e).getType() != std::get<2>(e).getType())
+      return op.emitOpError() << "types mismatch between " << i
+                              << "th iter operand and defined value";
+    if (std::get<1>(e).getType() != std::get<2>(e).getType())
+      return op.emitOpError() << "types mismatch between " << i
+                              << "th iter region arg and defined value";
+
+    i++;
+  }
+  return mlir::success();
+}
+
+static void print(mlir::OpAsmPrinter &p, fir::IterWhileOp op) {
+  p << fir::IterWhileOp::getOperationName() << " (" << op.getInductionVar()
+    << " = " << op.lowerBound() << " to " << op.upperBound() << " step "
+    << op.step() << ") and (";
+  assert(op.hasIterOperands());
+  auto regionArgs = op.getRegionIterArgs();
+  auto operands = op.getIterOperands();
+  p << regionArgs.front() << " = " << *operands.begin() << ")";
+  if (regionArgs.size() > 1) {
+    p << " iter_args(";
+    llvm::interleaveComma(
+        llvm::zip(regionArgs.drop_front(), operands.drop_front()), p,
+        [&](auto it) { p << std::get<0>(it) << " = " << std::get<1>(it); });
+    p << ") -> (" << op.getResultTypes().drop_front() << ')';
+  }
+  p.printOptionalAttrDictWithKeyword(op.getAttrs(), {});
+  p.printRegion(op.region(), /*printEntryBlockArgs=*/false,
+                /*printBlockTerminators=*/true);
+}
+
+mlir::Region &fir::IterWhileOp::getLoopBody() { return region(); }
+
+bool fir::IterWhileOp::isDefinedOutsideOfLoop(mlir::Value value) {
+  return !region().isAncestor(value.getParentRegion());
+}
+
+mlir::LogicalResult
+fir::IterWhileOp::moveOutOfLoop(llvm::ArrayRef<mlir::Operation *> ops) {
+  for (auto op : ops)
+    op->moveBefore(*this);
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // LoadOp
 //===----------------------------------------------------------------------===//
 
 /// Get the element type of a reference like type; otherwise null
 static mlir::Type elementTypeOf(mlir::Type ref) {
   return llvm::TypeSwitch<mlir::Type, mlir::Type>(ref)
       .Case<ReferenceType, PointerType, HeapType>(
           [](auto type) { return type.getEleTy(); })
       .Default([](mlir::Type) { return mlir::Type{}; });
 }
 
 mlir::ParseResult fir::LoadOp::getElementOf(mlir::Type &ele, mlir::Type ref) {
   if ((ele = elementTypeOf(ref)))
     return mlir::success();
   return mlir::failure();
 }
 
 //===----------------------------------------------------------------------===//
 // LoopOp
 //===----------------------------------------------------------------------===//
 
-void fir::LoopOp::build(mlir::Builder *builder, OperationState &result,
-                        mlir::Value lb, mlir::Value ub, ValueRange step,
-                        ArrayRef<NamedAttribute> attributes) {
-  if (step.empty())
-    result.addOperands({lb, ub});
-  else
-    result.addOperands({lb, ub, step[0]});
+void fir::LoopOp::build(mlir::Builder *builder, mlir::OperationState &result,
+                        mlir::Value lb, mlir::Value ub, mlir::Value step,
+                        bool unordered, mlir::ValueRange iterArgs,
+                        llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+  result.addOperands({lb, ub, step});
+  result.addOperands(iterArgs);
+  for (auto v : iterArgs)
+    result.addTypes(v.getType());
   mlir::Region *bodyRegion = result.addRegion();
+  bodyRegion->push_back(new Block{});
+  if (iterArgs.empty())
     LoopOp::ensureTerminator(*bodyRegion, *builder, result.location);
   bodyRegion->front().addArgument(builder->getIndexType());
+  for (auto v : iterArgs)
+    bodyRegion->front().addArgument(v.getType());
+  if (unordered)
+    result.addAttribute(unorderedAttrName(), builder->getUnitAttr());
   result.addAttributes(attributes);
-  NamedAttributeList attrs(attributes);
-  if (!attrs.get(unorderedAttrName()))
-    result.addTypes(builder->getIndexType());
 }
 
 static mlir::ParseResult parseLoopOp(mlir::OpAsmParser &parser,
                                      mlir::OperationState &result) {
   auto &builder = parser.getBuilder();
-  OpAsmParser::OperandType inductionVariable, lb, ub, step;
+  mlir::OpAsmParser::OperandType inductionVariable, lb, ub, step;
   // Parse the induction variable followed by '='.
   if (parser.parseRegionArgument(inductionVariable) || parser.parseEqual())
     return mlir::failure();
 
   // Parse loop bounds.
-  mlir::Type indexType = builder.getIndexType();
+  auto indexType = builder.getIndexType();
   if (parser.parseOperand(lb) ||
       parser.resolveOperand(lb, indexType, result.operands) ||
       parser.parseKeyword("to") || parser.parseOperand(ub) ||
-      parser.resolveOperand(ub, indexType, result.operands))
-    return mlir::failure();
+      parser.resolveOperand(ub, indexType, result.operands) ||
+      parser.parseKeyword("step") || parser.parseOperand(step) ||
+      parser.resolveOperand(step, indexType, result.operands))
+    return failure();
 
-  if (parser.parseOptionalKeyword(fir::LoopOp::stepAttrName())) {
-    result.addAttribute(fir::LoopOp::stepAttrName(),
-                        builder.getIntegerAttr(builder.getIndexType(), 1));
-  } else if (parser.parseOperand(step) ||
-             parser.resolveOperand(step, indexType, result.operands)) {
-    return mlir::failure();
+  if (mlir::succeeded(parser.parseOptionalKeyword("unordered")))
+    result.addAttribute(fir::LoopOp::unorderedAttrName(),
+                        builder.getUnitAttr());
+
+  // Parse the optional initial iteration arguments.
+  llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> regionArgs, operands;
+  llvm::SmallVector<mlir::Type, 4> argTypes;
+  regionArgs.push_back(inductionVariable);
+
+  if (succeeded(parser.parseOptionalKeyword("iter_args"))) {
+    // Parse assignment list and results type list.
+    if (parser.parseAssignmentList(regionArgs, operands) ||
+        parser.parseArrowTypeList(result.types))
+      return failure();
+    // Resolve input operands.
+    for (auto operand_type : llvm::zip(operands, result.types))
+      if (parser.resolveOperand(std::get<0>(operand_type),
+                                std::get<1>(operand_type), result.operands))
+        return failure();
   }
 
-  // Parse the optional `unordered` keyword
-  bool isUnordered = false;
-  if (!parser.parseOptionalKeyword(LoopOp::unorderedAttrName())) {
-    result.addAttribute(LoopOp::unorderedAttrName(), builder.getUnitAttr());
-    isUnordered = true;
-  }
+  if (parser.parseOptionalAttrDictWithKeyword(result.attributes))
+    return mlir::failure();
 
+  // Induction variable.
+  argTypes.push_back(indexType);
+  // Loop carried variables
+  argTypes.append(result.types.begin(), result.types.end());
   // Parse the body region.
-  mlir::Region *body = result.addRegion();
-  if (parser.parseRegion(*body, inductionVariable, indexType))
-    return mlir::failure();
+  auto *body = result.addRegion();
+  if (regionArgs.size() != argTypes.size())
+    return parser.emitError(
+        parser.getNameLoc(),
+        "mismatch in number of loop-carried values and defined values");
+
+  if (parser.parseRegion(*body, regionArgs, argTypes))
+    return failure();
 
   fir::LoopOp::ensureTerminator(*body, builder, result.location);
 
-  // Parse the optional attribute list.
-  if (parser.parseOptionalAttrDict(result.attributes))
-    return mlir::failure();
-  if (!isUnordered)
-    result.addTypes(builder.getIndexType());
   return mlir::success();
 }
 
 fir::LoopOp fir::getForInductionVarOwner(mlir::Value val) {
   auto ivArg = val.dyn_cast<mlir::BlockArgument>();
   if (!ivArg)
     return {};
   assert(ivArg.getOwner() && "unlinked block argument");
   auto *containingInst = ivArg.getOwner()->getParentOp();
   return dyn_cast_or_null<fir::LoopOp>(containingInst);
 }
 
+// Lifted from loop.loop
+static mlir::LogicalResult verify(fir::LoopOp op) {
+  if (auto cst = dyn_cast_or_null<ConstantIndexOp>(op.step().getDefiningOp()))
+    if (cst.getValue() <= 0)
+      return op.emitOpError("constant step operand must be positive");
+
+  // Check that the body defines as single block argument for the induction
+  // variable.
+  auto *body = op.getBody();
+  if (!body->getArgument(0).getType().isIndex())
+    return op.emitOpError(
+        "expected body first argument to be an index argument for "
+        "the induction variable");
+
+  auto opNumResults = op.getNumResults();
+  if (opNumResults == 0)
+    return success();
+  if (op.getNumIterOperands() != opNumResults)
+    return op.emitOpError(
+        "mismatch in number of loop-carried values and defined values");
+  if (op.getNumRegionIterArgs() != opNumResults)
+    return op.emitOpError(
+        "mismatch in number of basic block args and defined values");
+  auto iterOperands = op.getIterOperands();
+  auto iterArgs = op.getRegionIterArgs();
+  auto opResults = op.getResults();
+  unsigned i = 0;
+  for (auto e : llvm::zip(iterOperands, iterArgs, opResults)) {
+    if (std::get<0>(e).getType() != std::get<2>(e).getType())
+      return op.emitOpError() << "types mismatch between " << i
+                              << "th iter operand and defined value";
+    if (std::get<1>(e).getType() != std::get<2>(e).getType())
+      return op.emitOpError() << "types mismatch between " << i
+                              << "th iter region arg and defined value";
+
+    i++;
+  }
+  return success();
+}
+
+static void print(mlir::OpAsmPrinter &p, fir::LoopOp op) {
+  bool printBlockTerminators = false;
+  p << fir::LoopOp::getOperationName() << ' ' << op.getInductionVar() << " = "
+    << op.lowerBound() << " to " << op.upperBound() << " step " << op.step();
+  if (op.unordered())
+    p << " unordered";
+  if (op.hasIterOperands()) {
+    p << " iter_args(";
+    auto regionArgs = op.getRegionIterArgs();
+    auto operands = op.getIterOperands();
+    llvm::interleaveComma(llvm::zip(regionArgs, operands), p, [&](auto it) {
+      p << std::get<0>(it) << " = " << std::get<1>(it);
+    });
+    p << ") -> (" << op.getResultTypes() << ')';
+    printBlockTerminators = true;
+  }
+  p.printOptionalAttrDictWithKeyword(op.getAttrs(),
+                                     {fir::LoopOp::unorderedAttrName()});
+  p.printRegion(op.region(), /*printEntryBlockArgs=*/false,
+                printBlockTerminators);
+}
+
+mlir::Region &fir::LoopOp::getLoopBody() { return region(); }
+
+bool fir::LoopOp::isDefinedOutsideOfLoop(mlir::Value value) {
+  return !region().isAncestor(value.getParentRegion());
+}
+
+mlir::LogicalResult
+fir::LoopOp::moveOutOfLoop(llvm::ArrayRef<mlir::Operation *> ops) {
+  for (auto op : ops)
+    op->moveBefore(*this);
+  return success();
+}
+
+//===----------------------------------------------------------------------===//
+// MulfOp
+//===----------------------------------------------------------------------===//
+
+mlir::OpFoldResult fir::MulfOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
+  return mlir::constFoldBinaryOp<FloatAttr>(
+      opnds, [](APFloat a, APFloat b) { return a * b; });
+}
+
+//===----------------------------------------------------------------------===//
+// ResultOp
+//===----------------------------------------------------------------------===//
+
+static mlir::LogicalResult verify(fir::ResultOp op) {
+  auto parentOp = op.getParentOp();
+  auto results = parentOp->getResults();
+  auto operands = op.getOperands();
+
+  if (isa<fir::WhereOp>(parentOp) || isa<fir::LoopOp>(parentOp) ||
+      isa<fir::IterWhileOp>(parentOp)) {
+    if (parentOp->getNumResults() != op.getNumOperands())
+      return op.emitOpError() << "parent of result must have same arity";
+    for (auto e : llvm::zip(results, operands)) {
+      if (std::get<0>(e).getType() != std::get<1>(e).getType())
+        return op.emitOpError()
+               << "types mismatch between result op and its parent";
+    }
+  } else {
+    return op.emitOpError()
+           << "result only terminates if, do_loop, or iterate_while regions";
+  }
+  return success();
+}
+
+static mlir::ParseResult parseResultOp(mlir::OpAsmParser &parser,
+                                       mlir::OperationState &result) {
+  llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> operands;
+  llvm::SmallVector<mlir::Type, 4> types;
+  llvm::SMLoc loc = parser.getCurrentLocation();
+  if (parser.parseOperandList(operands) ||
+      parser.parseOptionalColonTypeList(types) ||
+      parser.resolveOperands(operands, types, loc, result.operands))
+    return failure();
+  return success();
+}
+
+static void print(mlir::OpAsmPrinter &p, fir::ResultOp op) {
+  p << op.getOperationName();
+  if (op.getNumOperands() != 0)
+    p << ' ' << op.getOperands() << " : " << op.getOperandTypes();
+}
+
 //===----------------------------------------------------------------------===//
 // SelectOp
 //===----------------------------------------------------------------------===//
 
 static constexpr llvm::StringRef getCompareOffsetAttr() {
   return "compare_operand_offsets";
 }
 
 static constexpr llvm::StringRef getTargetOffsetAttr() {
   return "target_operand_offsets";
 }
 
 template <typename A>
 static A getSubOperands(unsigned pos, A allArgs,
                         mlir::DenseIntElementsAttr ranges) {
   unsigned start = 0;
   for (unsigned i = 0; i < pos; ++i)
     start += (*(ranges.begin() + i)).getZExtValue();
   unsigned end = start + (*(ranges.begin() + pos)).getZExtValue();
   return {std::next(allArgs.begin(), start), std::next(allArgs.begin(), end)};
 }
 
+static unsigned denseElementsSize(mlir::DenseIntElementsAttr attr) {
+  unsigned count = 0;
+  for (auto x : attr)
+    ++count;
+  return count;
+}
+
 llvm::Optional<mlir::OperandRange> fir::SelectOp::getCompareOperands(unsigned) {
   return {};
 }
 
 llvm::Optional<llvm::ArrayRef<mlir::Value>>
 fir::SelectOp::getCompareOperands(llvm::ArrayRef<mlir::Value>, unsigned) {
   return {};
 }
fir::SelectOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
   auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
   auto segments =
       getAttrOfType<mlir::DenseIntElementsAttr>(getOperandSegmentSizeAttr());
   return {getSubOperands(oper, getSubOperands(2, operands, segments), a)};
 }
 
 bool fir::SelectOp::canEraseSuccessorOperand() { return true; }
 
+unsigned fir::SelectOp::targetOffsetSize() {
+  return denseElementsSize(
+      getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr()));
+}
+
 //===----------------------------------------------------------------------===//
 // SelectCaseOp
 //===----------------------------------------------------------------------===//
 
 llvm::Optional<mlir::OperandRange>
 fir::SelectCaseOp::getCompareOperands(unsigned cond) {
   auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getCompareOffsetAttr());
   return {getSubOperands(cond, compareArgs(), a)};
static mlir::ParseResult parseSelectCase(mlir::OpAsmParser &parser,
   auto &bld = parser.getBuilder();
   result.addAttribute(fir::SelectCaseOp::getOperandSegmentSizeAttr(),
                       bld.getI32VectorAttr({1, offSize, toffSize}));
   result.addAttribute(getCompareOffsetAttr(), bld.getI32VectorAttr(argOffs));
   result.addAttribute(getTargetOffsetAttr(), bld.getI32VectorAttr(targOffs));
   return mlir::success();
 }
 
+unsigned fir::SelectCaseOp::compareOffsetSize() {
+  return denseElementsSize(
+      getAttrOfType<mlir::DenseIntElementsAttr>(getCompareOffsetAttr()));
+}
+
+unsigned fir::SelectCaseOp::targetOffsetSize() {
+  return denseElementsSize(
+      getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr()));
+}
+
+void fir::SelectCaseOp::build(mlir::Builder *builder,
+                              mlir::OperationState &result,
+                              mlir::Value selector,
+                              llvm::ArrayRef<mlir::Attribute> compareAttrs,
+                              llvm::ArrayRef<mlir::ValueRange> cmpOperands,
+                              llvm::ArrayRef<mlir::Block *> destinations,
+                              llvm::ArrayRef<mlir::ValueRange> destOperands,
+                              llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+  result.addOperands(selector);
+  result.addAttribute(getCasesAttr(), builder->getArrayAttr(compareAttrs));
+  llvm::SmallVector<int32_t, 8> operOffs;
+  int32_t operSize = 0;
+  for (auto attr : compareAttrs) {
+    if (attr.isa<fir::ClosedIntervalAttr>()) {
+      operOffs.push_back(2);
+      operSize += 2;
+    } else if (attr.isa<mlir::UnitAttr>()) {
+      operOffs.push_back(0);
+    } else {
+      operOffs.push_back(1);
+      ++operSize;
+    }
+  }
+  for (auto ops : cmpOperands)
+    result.addOperands(ops);
+  result.addAttribute(getCompareOffsetAttr(),
+                      builder->getI32VectorAttr(operOffs));
+  const auto count = destinations.size();
+  for (auto d : destinations)
+    result.addSuccessors(d);
+  const auto opCount = destOperands.size();
+  llvm::SmallVector<int32_t, 8> argOffs;
+  int32_t sumArgs = 0;
+  for (std::remove_const_t<decltype(count)> i = 0; i != count; ++i) {
+    if (i < opCount) {
+      result.addOperands(destOperands[i]);
+      const auto argSz = destOperands[i].size();
+      argOffs.push_back(argSz);
+      sumArgs += argSz;
+    } else {
+      argOffs.push_back(0);
+    }
+  }
+  result.addAttribute(getOperandSegmentSizeAttr(),
+                      builder->getI32VectorAttr({1, operSize, sumArgs}));
+  result.addAttribute(getTargetOffsetAttr(),
+                      builder->getI32VectorAttr(argOffs));
+  result.addAttributes(attributes);
+}
+
+/// This builder has a slightly simplified interface in that the list of
+/// operands need not be partitioned by the builder. Instead the operands are
+/// partitioned here, before being passed to the default builder. This
+/// partitioning is unchecked, so can go awry on bad input.
+void fir::SelectCaseOp::build(mlir::Builder *builder,
+                              mlir::OperationState &result,
+                              mlir::Value selector,
+                              llvm::ArrayRef<mlir::Attribute> compareAttrs,
+                              llvm::ArrayRef<mlir::Value> cmpOpList,
+                              llvm::ArrayRef<mlir::Block *> destinations,
+                              llvm::ArrayRef<mlir::ValueRange> destOperands,
+                              llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+  llvm::SmallVector<mlir::ValueRange, 16> cmpOpers;
+  auto iter = cmpOpList.begin();
+  for (auto &attr : compareAttrs) {
+    if (attr.isa<fir::ClosedIntervalAttr>()) {
+      cmpOpers.push_back(mlir::ValueRange({iter, iter + 2}));
+      iter += 2;
+    } else if (attr.isa<UnitAttr>()) {
+      cmpOpers.push_back(mlir::ValueRange{});
+    } else {
+      cmpOpers.push_back(mlir::ValueRange({iter, iter + 1}));
+      ++iter;
+    }
+  }
+  build(builder, result, selector, compareAttrs, cmpOpers, destinations,
+        destOperands, attributes);
+}
+
 //===----------------------------------------------------------------------===//
 // SelectRankOp
 //===----------------------------------------------------------------------===//
 
 llvm::Optional<mlir::OperandRange>
 fir::SelectRankOp::getCompareOperands(unsigned) {
   return {};
 }
fir::SelectRankOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
   auto a = getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
   auto segments =
       getAttrOfType<mlir::DenseIntElementsAttr>(getOperandSegmentSizeAttr());
   return {getSubOperands(oper, getSubOperands(2, operands, segments), a)};
 }
 
 bool fir::SelectRankOp::canEraseSuccessorOperand() { return true; }
 
+unsigned fir::SelectRankOp::targetOffsetSize() {
+  return denseElementsSize(
+      getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr()));
+}
+
 //===----------------------------------------------------------------------===//
 // SelectTypeOp
 //===----------------------------------------------------------------------===//
 
 llvm::Optional<mlir::OperandRange>
 fir::SelectTypeOp::getCompareOperands(unsigned) {
   return {};
 }
for (std::remove_const_t<decltype(count)> i = 0; i != count; ++i) {
     offSize += argSize;
   }
   result.addAttribute(fir::SelectTypeOp::getOperandSegmentSizeAttr(),
                       bld.getI32VectorAttr({1, 0, offSize}));
   result.addAttribute(getTargetOffsetAttr(), bld.getI32VectorAttr(argOffs));
   return mlir::success();
 }
 
+unsigned fir::SelectTypeOp::targetOffsetSize() {
+  return denseElementsSize(
+      getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr()));
+}
+
 //===----------------------------------------------------------------------===//
 // StoreOp
 //===----------------------------------------------------------------------===//
 
 mlir::Type fir::StoreOp::elementType(mlir::Type refType) {
   if (auto ref = refType.dyn_cast<ReferenceType>())
     return ref.getEleTy();
   if (auto ref = refType.dyn_cast<PointerType>())
     return ref.getEleTy();
   if (auto ref = refType.dyn_cast<HeapType>())
     return ref.getEleTy();
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // StringLitOp
 //===----------------------------------------------------------------------===//
 
 bool fir::StringLitOp::isWideValue() {
   auto eleTy = getType().cast<fir::SequenceType>().getEleTy();
   return eleTy.cast<fir::CharacterType>().getFKind() != 1;
 }
 
 //===----------------------------------------------------------------------===//
+// SubfOp
+//===----------------------------------------------------------------------===//
+
+mlir::OpFoldResult fir::SubfOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
+  return mlir::constFoldBinaryOp<FloatAttr>(
+      opnds, [](APFloat a, APFloat b) { return a - b; });
+}
+
+//===----------------------------------------------------------------------===//
 // WhereOp
 //===----------------------------------------------------------------------===//
 
 void fir::WhereOp::build(mlir::Builder *builder, OperationState &result,
                          mlir::Value cond, bool withElseRegion) {
   result.addOperands(cond);
   mlir::Region *thenRegion = result.addRegion();
   mlir::Region *elseRegion = result.addRegion();
if (parser.parseOperand(cond) ||
       parser.resolveOperand(cond, i1Type, result.operands))
     return mlir::failure();
 
   if (parser.parseRegion(*thenRegion, {}, {}))
     return mlir::failure();
 
   WhereOp::ensureTerminator(*thenRegion, parser.getBuilder(), result.location);
 
-  if (!parser.parseOptionalKeyword("otherwise")) {
+  if (!parser.parseOptionalKeyword("else")) {
     if (parser.parseRegion(*elseRegion, {}, {}))
       return mlir::failure();
     WhereOp::ensureTerminator(*elseRegion, parser.getBuilder(),
                               result.location);
   }
 
   // Parse the optional attribute list.
   if (parser.parseOptionalAttrDict(result.attributes))
     return mlir::failure();
 
   return mlir::success();
 }
 
+mlir::LogicalResult
+fir::WhereOp::fold(llvm::ArrayRef<mlir::Attribute> opnds,
+                   llvm::SmallVectorImpl<mlir::OpFoldResult> &results) {
+  // If the WhereOp has no body, then just delete it
+  if ((whereRegion().empty() || whereRegion().front().empty() ||
+       isa<fir::FirEndOp>(whereRegion().front().front())) &&
+      (otherRegion().empty() || otherRegion().front().empty() ||
+       isa<fir::FirEndOp>(otherRegion().front().front()))) {
+    results.clear();
+    return mlir::success();
+  }
+  return mlir::failure();
+}
+
+static LogicalResult verify(fir::WhereOp op) {
+  // Verify that the entry of each child region does not have arguments.
+  for (auto &region : op.getOperation()->getRegions()) {
+    if (region.empty())
+      continue;
+
+    for (auto &b : region)
+      if (b.getNumArguments() != 0)
+        return op.emitOpError(
+            "requires that child entry blocks have no arguments");
+  }
+  if (op.getNumResults() != 0 && op.otherRegion().empty())
+    return op.emitOpError("must have an else block if defining values");
+
+  return mlir::success();
+}
+
+static void print(mlir::OpAsmPrinter &p, fir::WhereOp op) {
+  bool printBlockTerminators = false;
+  p << fir::WhereOp::getOperationName() << ' ' << op.condition();
+  if (!op.results().empty()) {
+    p << " -> (" << op.getResultTypes() << ')';
+    printBlockTerminators = true;
+  }
+  p.printRegion(op.whereRegion(), /*printEntryBlockArgs=*/false,
+                printBlockTerminators);
+
+  // Print the 'else' regions if it exists and has a block.
+  auto &otherReg = op.otherRegion();
+  if (!otherReg.empty()) {
+    p << " else";
+    p.printRegion(otherReg, /*printEntryBlockArgs=*/false,
+                  printBlockTerminators);
+  }
+  p.printOptionalAttrDict(op.getAttrs());
+}
+
 //===----------------------------------------------------------------------===//
 
 mlir::ParseResult fir::isValidCaseAttr(mlir::Attribute attr) {
   if (attr.dyn_cast_or_null<mlir::UnitAttr>() ||
       attr.dyn_cast_or_null<ClosedIntervalAttr>() ||
       attr.dyn_cast_or_null<PointIntervalAttr>() ||
       attr.dyn_cast_or_null<LowerBoundAttr>() ||
       attr.dyn_cast_or_null<UpperBoundAttr>())

 }
 
 mlir::FuncOp fir::createFuncOp(mlir::Location loc, mlir::ModuleOp module,
                                StringRef name, mlir::FunctionType type,
                                llvm::ArrayRef<mlir::NamedAttribute> attrs) {
   if (auto f = module.lookupSymbol<mlir::FuncOp>(name))
     return f;
   mlir::OpBuilder modBuilder(module.getBodyRegion());
+  modBuilder.setInsertionPoint(module.getBody()->getTerminator());
   return modBuilder.create<mlir::FuncOp>(loc, name, type, attrs);
 }
 
 fir::GlobalOp fir::createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
                                   StringRef name, mlir::Type type,
                                   llvm::ArrayRef<mlir::NamedAttribute> attrs) {
   if (auto g = module.lookupSymbol<fir::GlobalOp>(name))
     return g;

flang/lib/Optimizer/Dialect/FIRType.cpp

 //===-- FIRType.cpp -------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
-#include "mlir/IR/Builders.h"
 #include "mlir/IR/Diagnostics.h"
-#include "mlir/IR/Dialect.h"
 #include "mlir/IR/DialectImplementation.h"
-#include "mlir/IR/StandardTypes.h"
-#include "mlir/Parser.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/TypeSwitch.h"
+#include "llvm/Support/ErrorHandling.h"
 
 using namespace fir;
 
 namespace {
 
 template <typename TYPE>
 TYPE parseIntSingleton(mlir::DialectAsmParser &parser) {
   int kind = 0;
SequenceType parseSequence(mlir::DialectAsmParser &parser, mlir::Location) {
   if (!parser.parseOptionalComma())
     if (parser.parseAttribute(map)) {
       parser.emitError(parser.getNameLoc(), "expecting affine map");
       return {};
     }
   return SequenceType::get(shape, eleTy, map);
 }
 
-bool verifyIntegerType(mlir::Type ty) {
+static bool verifyIntegerType(mlir::Type ty) {
   return ty.isa<mlir::IntegerType>() || ty.isa<IntType>();
 }
 
 bool verifyRecordMemberType(mlir::Type ty) {
   return !(ty.isa<BoxType>() || ty.isa<BoxCharType>() ||
            ty.isa<BoxProcType>() || ty.isa<DimsType>() || ty.isa<FieldType>() ||
            ty.isa<LenType>() || ty.isa<ReferenceType>() ||
            ty.isa<TypeDescType>());

 bool isa_fir_or_std_type(mlir::Type t) {
   return isa_fir_type(t) || isa_std_type(t);
 }
 
 bool isa_ref_type(mlir::Type t) {
   return t.isa<ReferenceType>() || t.isa<PointerType>() || t.isa<HeapType>();
 }
 
+bool isa_box_type(mlir::Type t) {
+  return t.isa<BoxType>() || t.isa<BoxCharType>() || t.isa<BoxProcType>();
+}
+
+bool isa_passbyref_type(mlir::Type t) {
+  return t.isa<ReferenceType>() || isa_box_type(t);
+}
+
 bool isa_aggregate(mlir::Type t) {
   return t.isa<SequenceType>() || t.isa<RecordType>();
 }
 
 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(); })

 int fir::IntType::getFKind() const { return getImpl()->getFKind(); }
 
 // COMPLEX
 
 CplxType fir::CplxType::get(mlir::MLIRContext *ctxt, KindTy kind) {
   return Base::get(ctxt, FIR_COMPLEX, kind);
 }
 
+mlir::Type fir::CplxType::getElementType() const {
+  return fir::RealType::get(getContext(), getFKind());
+}
+
 KindTy fir::CplxType::getFKind() const { return getImpl()->getFKind(); }
 
 // REAL
 
 RealType fir::RealType::get(mlir::MLIRContext *ctxt, KindTy kind) {
   return Base::get(ctxt, FIR_REAL, kind);
 }
 

 mlir::AffineMapAttr fir::SequenceType::getLayoutMap() const {
   return getImpl()->getLayoutMap();
 }
 
 SequenceType::Shape fir::SequenceType::getShape() const {
   return getImpl()->getShape();
 }
 
+unsigned fir::SequenceType::getConstantRows() const {
+  auto shape = getShape();
+  unsigned count = 0;
+  for (auto d : shape) {
+    if (d < 0)
+      break;
+    ++count;
+  }
+  return count;
+}
+
+// This test helps us determine if we can degenerate an array to a
+// pointer to some interior section (possibly a single element) of the
+// sequence. This is used to determine if we can lower to the LLVM IR.
+bool fir::SequenceType::hasConstantInterior() const {
+  if (hasUnknownShape())
+    return true;
+  auto rows = getConstantRows();
+  auto dim = getDimension();
+  if (rows == dim)
+    return true;
+  auto shape = getShape();
+  for (unsigned i{rows}, size{dim}; i < size; ++i)
+    if (shape[i] != getUnknownExtent())
+      return false;
+  return true;
+}
+
 mlir::LogicalResult fir::SequenceType::verifyConstructionInvariants(
     mlir::Location loc, const SequenceType::Shape &shape, mlir::Type eleTy,
     mlir::AffineMapAttr map) {
   // DIMENSION attribute can only be applied to an intrinsic or record type
   if (eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
       eleTy.isa<BoxProcType>() || eleTy.isa<DimsType>() ||
       eleTy.isa<FieldType>() || eleTy.isa<LenType>() || eleTy.isa<HeapType>() ||
       eleTy.isa<PointerType>() || eleTy.isa<ReferenceType>() ||
for (auto &b : bounds) {
     }
   }
 }
 
 llvm::SmallPtrSet<detail::RecordTypeStorage const *, 4> recordTypeVisited;
 
 } // namespace
 
+void fir::verifyIntegralType(mlir::Type type) {
+  if (verifyIntegerType(type) || type.isa<mlir::IndexType>())
+    return;
+  llvm_unreachable("expected integral type");
+}
+
 void fir::printFirType(FIROpsDialect *, mlir::Type ty,
                        mlir::DialectAsmPrinter &p) {
   auto &os = p.getStream();
   switch (ty.getKind()) {
   case fir::FIR_BOX: {
     auto type = ty.cast<BoxType>();
     os << "box<";
     p.printType(type.getEleTy());

flang/lib/Optimizer/Support/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 
 add_flang_library(FIRSupport
+  InternalNames.cpp
   KindMapping.cpp
 
   DEPENDS
   ${dialect_libs}
   LINK_LIBS
   ${dialect_libs}
 )

flang/lib/Optimizer/Support/InternalNames.cpp

+//===-- InternalNames.cpp -------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "flang/Optimizer/Support/InternalNames.h"
+#include "mlir/IR/Diagnostics.h"
+#include "llvm/Support/CommandLine.h"
+
+static llvm::cl::opt<std::string> mainEntryName(
+    "main-entry-name",
+    llvm::cl::desc("override the name of the default PROGRAM entry (may be "
+                   "helpful for using other runtimes)"));
+
+constexpr std::int64_t BAD_VALUE = -1;
+
+inline std::string prefix() { return "_Q"; }
+
+static std::string doModules(llvm::ArrayRef<llvm::StringRef> mods) {
+  std::string result;
+  auto *token = "M";
+  for (auto mod : mods) {
+    result.append(token).append(mod);
+    token = "S";
+  }
+  return result;
+}
+
+static std::string doModulesHost(llvm::ArrayRef<llvm::StringRef> mods,
+                                 llvm::Optional<llvm::StringRef> host) {
+  std::string result = doModules(mods);
+  if (host.hasValue())
+    result.append("F").append(*host);
+  return result;
+}
+
+inline llvm::SmallVector<llvm::StringRef, 2>
+convertToStringRef(llvm::ArrayRef<std::string> from) {
+  return {from.begin(), from.end()};
+}
+
+inline llvm::Optional<llvm::StringRef>
+convertToStringRef(const llvm::Optional<std::string> &from) {
+  llvm::Optional<llvm::StringRef> to;
+  if (from.hasValue())
+    to = from.getValue();
+  return to;
+}
+
+static std::string readName(llvm::StringRef uniq, std::size_t &i,
+                            std::size_t init, std::size_t end) {
+  for (i = init; i < end && uniq[i] >= 'a' && uniq[i] <= 'z'; ++i) {
+    // do nothing
+  }
+  return uniq.substr(init, i).str();
+}
+
+static std::int64_t readInt(llvm::StringRef uniq, std::size_t &i,
+                            std::size_t init, std::size_t end) {
+  for (i = init; i < end && uniq[i] >= '0' && uniq[i] <= '9'; ++i) {
+    // do nothing
+  }
+  std::int64_t result = BAD_VALUE;
+  if (uniq.substr(init, i).getAsInteger(10, result))
+    return BAD_VALUE;
+  return result;
+}
+
+std::string fir::NameUniquer::toLower(llvm::StringRef name) {
+  return name.lower();
+}
+
+std::string fir::NameUniquer::intAsString(std::int64_t i) {
+  assert(i >= 0);
+  return std::to_string(i);
+}
+
+std::string fir::NameUniquer::doKind(std::int64_t kind) {
+  std::string result = "K";
+  if (kind < 0)
+    return result.append("N").append(intAsString(-kind));
+  return result.append(intAsString(kind));
+}
+
+std::string fir::NameUniquer::doKinds(llvm::ArrayRef<std::int64_t> kinds) {
+  std::string result;
+  for (auto i : kinds)
+    result.append(doKind(i));
+  return result;
+}
+
+std::string fir::NameUniquer::doCommonBlock(llvm::StringRef name) {
+  std::string result = prefix();
+  return result.append("B").append(toLower(name));
+}
+
+std::string
+fir::NameUniquer::doConstant(llvm::ArrayRef<llvm::StringRef> modules,
+                             llvm::StringRef name) {
+  std::string result = prefix();
+  return result.append(doModules(modules)).append("EC").append(toLower(name));
+}
+
+std::string
+fir::NameUniquer::doDispatchTable(llvm::ArrayRef<llvm::StringRef> modules,
+                                  llvm::Optional<llvm::StringRef> host,
+                                  llvm::StringRef name,
+                                  llvm::ArrayRef<std::int64_t> kinds) {
+  std::string result = prefix();
+  result.append(doModulesHost(modules, host)).append("DT");
+  return result.append(toLower(name)).append(doKinds(kinds));
+}
+
+std::string fir::NameUniquer::doGenerated(llvm::StringRef name) {
+  std::string result = prefix();
+  return result.append("Q").append(name);
+}
+
+std::string fir::NameUniquer::doIntrinsicTypeDescriptor(
+    llvm::ArrayRef<llvm::StringRef> modules,
+    llvm::Optional<llvm::StringRef> host, IntrinsicType type,
+    std::int64_t kind) {
+  const char *name = nullptr;
+  switch (type) {
+  case IntrinsicType::CHARACTER:
+    name = "character";
+    break;
+  case IntrinsicType::COMPLEX:
+    name = "complex";
+    break;
+  case IntrinsicType::INTEGER:
+    name = "integer";
+    break;
+  case IntrinsicType::LOGICAL:
+    name = "logical";
+    break;
+  case IntrinsicType::REAL:
+    name = "real";
+    break;
+  }
+  assert(name && "unknown intrinsic type");
+  std::string result = prefix();
+  result.append(doModulesHost(modules, host)).append("C");
+  return result.append(name).append(doKind(kind));
+}
+
+std::string
+fir::NameUniquer::doProcedure(llvm::ArrayRef<llvm::StringRef> modules,
+                              llvm::Optional<llvm::StringRef> host,
+                              llvm::StringRef name) {
+  std::string result = prefix();
+  result.append(doModulesHost(modules, host)).append("P");
+  return result.append(toLower(name));
+}
+
+std::string fir::NameUniquer::doType(llvm::ArrayRef<llvm::StringRef> modules,
+                                     llvm::Optional<llvm::StringRef> host,
+                                     llvm::StringRef name,
+                                     llvm::ArrayRef<std::int64_t> kinds) {
+  std::string result = prefix();
+  result.append(doModulesHost(modules, host)).append("T");
+  return result.append(toLower(name)).append(doKinds(kinds));
+}
+
+std::string
+fir::NameUniquer::doTypeDescriptor(llvm::ArrayRef<llvm::StringRef> modules,
+                                   llvm::Optional<llvm::StringRef> host,
+                                   llvm::StringRef name,
+                                   llvm::ArrayRef<std::int64_t> kinds) {
+  std::string result = prefix();
+  result.append(doModulesHost(modules, host)).append("CT");
+  return result.append(toLower(name)).append(doKinds(kinds));
+}
+
+std::string fir::NameUniquer::doTypeDescriptor(
+    llvm::ArrayRef<std::string> modules, llvm::Optional<std::string> host,
+    llvm::StringRef name, llvm::ArrayRef<std::int64_t> kinds) {
+  auto rmodules = convertToStringRef(modules);
+  auto rhost = convertToStringRef(host);
+  return doTypeDescriptor(rmodules, rhost, name, kinds);
+}
+
+std::string
+fir::NameUniquer::doVariable(llvm::ArrayRef<llvm::StringRef> modules,
+                             llvm::Optional<llvm::StringRef> host,
+                             llvm::StringRef name) {
+  std::string result = prefix();
+  result.append(doModulesHost(modules, host)).append("E");
+  return result.append(toLower(name));
+}
+
+llvm::StringRef fir::NameUniquer::doProgramEntry() {
+  if (mainEntryName.size())
+    return mainEntryName;
+  return "_QQmain";
+}
+
+std::pair<fir::NameUniquer::NameKind, fir::NameUniquer::DeconstructedName>
+fir::NameUniquer::deconstruct(llvm::StringRef uniq) {
+  if (uniq.startswith("_Q")) {
+    llvm::SmallVector<std::string, 4> modules;
+    llvm::Optional<std::string> host;
+    std::string name;
+    llvm::SmallVector<std::int64_t, 8> kinds;
+    NameKind nk = NameKind::NOT_UNIQUED;
+    for (std::size_t i = 2, end{uniq.size()}; i != end;) {
+      switch (uniq[i]) {
+      case 'B':
+        nk = NameKind::COMMON;
+        name = readName(uniq, i, i + 1, end);
+        break;
+      case 'C':
+        if (uniq[i + 1] == 'T') {
+          nk = NameKind::TYPE_DESC;
+          name = readName(uniq, i, i + 2, end);
+        } else {
+          nk = NameKind::INTRINSIC_TYPE_DESC;
+          name = readName(uniq, i, i + 1, end);
+        }
+        break;
+      case 'D':
+        nk = NameKind::DISPATCH_TABLE;
+        assert(uniq[i + 1] == 'T');
+        name = readName(uniq, i, i + 2, end);
+        break;
+      case 'E':
+        if (uniq[i + 1] == 'C') {
+          nk = NameKind::CONSTANT;
+          name = readName(uniq, i, i + 2, end);
+        } else {
+          nk = NameKind::VARIABLE;
+          name = readName(uniq, i, i + 1, end);
+        }
+        break;
+      case 'P':
+        nk = NameKind::PROCEDURE;
+        name = readName(uniq, i, i + 1, end);
+        break;
+      case 'Q':
+        nk = NameKind::GENERATED;
+        name = uniq;
+        i = end;
+        break;
+      case 'T':
+        nk = NameKind::DERIVED_TYPE;
+        name = readName(uniq, i, i + 1, end);
+        break;
+
+      case 'M':
+      case 'S':
+        modules.push_back(readName(uniq, i, i + 1, end));
+        break;
+      case 'F':
+        host = readName(uniq, i, i + 1, end);
+        break;
+      case 'K':
+        if (uniq[i + 1] == 'N')
+          kinds.push_back(-readInt(uniq, i, i + 2, end));
+        else
+          kinds.push_back(readInt(uniq, i, i + 1, end));
+        break;
+
+      default:
+        assert(false && "unknown uniquing code");
+        break;
+      }
+    }
+    return {nk, DeconstructedName(modules, host, name, kinds)};
+  }
+  return {NameKind::NOT_UNIQUED, DeconstructedName(uniq)};
+}

flang/test/Fir/fir-ops.fir

 // Test the FIR operations
 
 // RUN: tco -emit-fir %s | tco -emit-fir | FileCheck %s
 // UNSUPPORTED: !fir
 
 // CHECK-LABEL: func @it1() -> !fir.int<4>
+// CHECK: func @box1() -> !fir.boxchar<2>
+// CHECK: func @box2() -> !fir.boxproc<(i32, i32) -> i64>
+// CHECK: func @box3() -> !fir.box<!fir.type<derived3{f:f32}>>
 func @it1() -> !fir.int<4>
-// CHECK-LABEL: func @box1() -> !fir.boxchar<2>
 func @box1() -> !fir.boxchar<2>
-// CHECK-LABEL: func @box2() -> !fir.boxproc<(i32, i32) -> i64>
 func @box2() -> !fir.boxproc<(i32, i32) -> i64>
-// CHECK-LABEL: func @box3() -> !fir.box<!fir.type<derived3{f:f32}>>
 func @box3() -> !fir.box<!fir.type<derived3{f:f32}>>
 
 // Fortran SUBROUTINE and FUNCTION
 // CHECK-LABEL: func @print_index3(index, index, index)
-// CHECK-LABEL: func @user_i64(i64)
-// CHECK-LABEL: func @user_tdesc(!fir.tdesc<!fir.type<x>>)
+// CHECK: func @user_i64(i64)
+// CHECK: func @user_tdesc(!fir.tdesc<!fir.type<x>>)
 func @print_index3(index, index, index)
 func @user_i64(i64)
 func @user_tdesc(!fir.tdesc<!fir.type<x>>)
 
 // expect the void return to be omitted
 // CHECK-LABEL: func @store_tuple(tuple<!fir.type<qq1{f1:i32}>>)
+// CHECK: func @get_method_box() -> !fir.box<!fir.type<derived3{f:f32}>>
+// CHECK: func @method_impl(!fir.box<!fir.type<derived3{f:f32}>>)
 func @store_tuple(tuple<!fir.type<qq1{f1:i32}>>) -> ()
-
-// CHECK-LABEL: func @get_method_box() -> !fir.box<!fir.type<derived3{f:f32}>>
-// CHECK-LABEL: func @method_impl(!fir.box<!fir.type<derived3{f:f32}>>)
 func @get_method_box() -> !fir.box<!fir.type<derived3{f:f32}>>
 func @method_impl(!fir.box<!fir.type<derived3{f:f32}>>)
 
 // CHECK-LABEL: func @nop()
-func @nop()
-
 // CHECK-LABEL: func @get_func() -> (() -> ())
+func @nop()
 func @get_func() -> (() -> ())
 
-// CHECK-LABEL: @instructions
+// CHECK-LABEL:       func @instructions() {
 func @instructions() {
-  // CHECK: %[[A0:.*]] = fir.alloca !fir.array<10xi32>
+// CHECK: [[VAL_0:%.*]] = fir.alloca !fir.array<10xi32>
+// CHECK: [[VAL_1:%.*]] = fir.load [[VAL_0]] : !fir.ref<!fir.array<10xi32>>
+// CHECK: [[VAL_2:%.*]] = fir.alloca i32
+// CHECK: [[VAL_3:%.*]] = constant 22 : i32
   %0 = fir.alloca !fir.array<10xi32>
-  // CHECK: fir.load %[[A0]] : !fir.ref<!fir.array<10xi32>>
   %1 = fir.load %0 : !fir.ref<!fir.array<10xi32>>
   %2 = fir.alloca i32
   %3 = constant 22 : i32
-  // CHECK: fir.store %{{.*}} to %{{.*}} : !fir.ref<i32>
+
+// CHECK: fir.store [[VAL_3]] to [[VAL_2]] : !fir.ref<i32>
+// CHECK: [[VAL_4:%.*]] = fir.undefined i32
+// CHECK: [[VAL_5:%.*]] = fir.allocmem !fir.array<100xf32>
+// CHECK: [[VAL_6:%.*]] = fir.embox [[VAL_5]] : (!fir.heap<!fir.array<100xf32>>) -> !fir.box<!fir.array<100xf32>>
   fir.store %3 to %2 : !fir.ref<i32>
-  // CHECK: fir.undefined i32
   %4 = fir.undefined i32
-  // CHECK: %[[A5:.*]] = fir.allocmem !fir.array<100xf32>
   %5 = fir.allocmem !fir.array<100xf32>
-  // CHECK: %[[A6:.*]] = fir.embox %[[A5]] : (!fir.heap<!fir.array<100xf32>>) -> !fir.box<!fir.array<100xf32>>
   %6 = fir.embox %5 : (!fir.heap<!fir.array<100xf32>>) -> !fir.box<!fir.array<100xf32>>
-  // CHECK: fir.box_addr %{{.*}} : (!fir.box<!fir.array<100xf32>>) -> !fir.ref<!fir.array<100xf32>>
+
+// CHECK: [[VAL_7:%.*]] = fir.box_addr [[VAL_6]] : (!fir.box<!fir.array<100xf32>>) -> !fir.ref<!fir.array<100xf32>>
+// CHECK: [[VAL_8:%.*]] = constant 0 : index
+// CHECK: [[VAL_9:%.*]]:3 = fir.box_dims [[VAL_6]], [[VAL_8]] : (!fir.box<!fir.array<100xf32>>, index) -> (index, index, index)
+// CHECK: fir.call @print_index3([[VAL_9]]#0, [[VAL_9]]#1, [[VAL_9]]#2) : (index, index, index) -> ()
+// CHECK: [[VAL_10:%.*]] = fir.call @it1() : () -> !fir.int<4>
   %7 = fir.box_addr %6 : (!fir.box<!fir.array<100xf32>>) -> !fir.ref<!fir.array<100xf32>>
   %c0 = constant 0 : index
-  // CHECK: %[[A8:.*]]:3 = fir.box_dims %{{.*}}, %{{.*}} : (!fir.box<!fir.array<100xf32>>, index) -> (index, index, index)
   %d1:3 = fir.box_dims %6, %c0 : (!fir.box<!fir.array<100xf32>>, index) -> (index, index, index)
-  // CHECK: fir.call @print_index3(%[[A8]]#0, %[[A8]]#1, %[[A8]]#2) : (index, index, index)
   fir.call @print_index3(%d1#0, %d1#1, %d1#2) : (index, index, index) -> ()
   %8 = fir.call @it1() : () -> !fir.int<4>
-  // CHECK: fir.box_elesize %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> i64
+
+// CHECK: [[VAL_11:%.*]] = fir.box_elesize [[VAL_6]] : (!fir.box<!fir.array<100xf32>>) -> i64
+// CHECK: [[VAL_12:%.*]] = fir.box_isalloc [[VAL_6]] : (!fir.box<!fir.array<100xf32>>) -> i1
+// CHECK: [[VAL_13:%.*]] = fir.box_isarray [[VAL_6]] : (!fir.box<!fir.array<100xf32>>) -> i1
+// CHECK: [[VAL_14:%.*]] = fir.box_isptr [[VAL_6]] : (!fir.box<!fir.array<100xf32>>) -> i1
+// CHECK: [[VAL_15:%.*]] = fir.box_rank [[VAL_6]] : (!fir.box<!fir.array<100xf32>>) -> i64
   %9 = fir.box_elesize %6 : (!fir.box<!fir.array<100xf32>>) -> i64
-  // CHECK: fir.box_isalloc %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> i1
   %10 = fir.box_isalloc %6 : (!fir.box<!fir.array<100xf32>>) -> i1
-  // CHECK: fir.box_isarray %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> i1
   %11 = fir.box_isarray %6 : (!fir.box<!fir.array<100xf32>>) -> i1
-  // CHECK: fir.box_isptr %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> i1
   %12 = fir.box_isptr %6 : (!fir.box<!fir.array<100xf32>>) -> i1
-  // CHECK: fir.box_rank %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> i64
   %13 = fir.box_rank %6 : (!fir.box<!fir.array<100xf32>>) -> i64
-  // CHECK: fir.box_tdesc %[[A6]] : (!fir.box<!fir.array<100xf32>>) -> !fir.tdesc<!fir.array<100xf32>>
+
+// CHECK: [[VAL_16:%.*]] = fir.box_tdesc [[VAL_6]] : (!fir.box<!fir.array<100xf32>>) -> !fir.tdesc<!fir.array<100xf32>>
+// CHECK: [[VAL_17:%.*]] = fir.call @box1() : () -> !fir.boxchar<2>
+// CHECK: [[VAL_18:%.*]] = fir.boxchar_len [[VAL_17]] : (!fir.boxchar<2>) -> i32
+// CHECK: [[VAL_19:%.*]] = fir.call @box2() : () -> !fir.boxproc<(i32, i32) -> i64>
+// CHECK: [[VAL_20:%.*]] = fir.boxproc_host [[VAL_19]] : (!fir.boxproc<(i32, i32) -> i64>) -> !fir.ref<i32>
   %14 = fir.box_tdesc %6 : (!fir.box<!fir.array<100xf32>>) -> !fir.tdesc<!fir.array<100xf32>>
   %15 = fir.call @box1() : () -> !fir.boxchar<2>
-  // CHECK: fir.boxchar_len %{{.*}} : (!fir.boxchar<2>) -> i32
   %16 = fir.boxchar_len %15 : (!fir.boxchar<2>) -> i32
   %17 = fir.call @box2() : () -> !fir.boxproc<(i32, i32) -> i64>
-  // CHECK: fir.boxproc_host %{{.*}} : (!fir.boxproc<(i32, i32) -> i64>) -> !fir.ref<i32>
   %18 = fir.boxproc_host %17 : (!fir.boxproc<(i32, i32) -> i64>) -> !fir.ref<i32>
+
+// CHECK: [[VAL_21:%.*]] = constant 10 : i32
+// CHECK: [[VAL_22:%.*]] = fir.coordinate_of [[VAL_5]], [[VAL_21]] : (!fir.heap<!fir.array<100xf32>>, i32) -> !fir.ref<f32>
+// CHECK: [[VAL_23:%.*]] = fir.field_index f, !fir.type<derived{f:f32}>
+// CHECK: [[VAL_24:%.*]] = fir.undefined !fir.type<derived{f:f32}>
+// CHECK: [[VAL_25:%.*]] = fir.extract_value [[VAL_24]], [[VAL_23]] : (!fir.type<derived{f:f32}>, !fir.field) -> f32
   %19 = constant 10 : i32
-  // CHECK: fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.heap<!fir.array<100xf32>>, i32) -> !fir.ref<f32>
   %20 = fir.coordinate_of %5, %19 : (!fir.heap<!fir.array<100xf32>>, i32) -> !fir.ref<f32>
-  // CHECK: fir.field_index f, !fir.type<derived{f:f32}>
   %21 = fir.field_index f, !fir.type<derived{f:f32}>
-  // CHECK: fir.undefined !fir.type<derived{f:f32}>
   %22 = fir.undefined !fir.type<derived{f:f32}>
-  // CHECK: fir.extract_value %{{.*}}, %{{.*}} : (!fir.type<derived{f:f32}>, !fir.field) -> f32
   %23 = fir.extract_value %22, %21 : (!fir.type<derived{f:f32}>, !fir.field) -> f32
+
+// CHECK: [[VAL_26:%.*]] = constant 1 : i32
+// CHECK: [[VAL_27:%.*]] = fir.gendims [[VAL_26]], [[VAL_21]], [[VAL_26]] : (i32, i32, i32) -> !fir.dims<1>
+// CHECK: [[VAL_28:%.*]] = constant 1.0
+// CHECK: [[VAL_29:%.*]] = fir.insert_value [[VAL_24]], [[VAL_28]], [[VAL_23]] : (!fir.type<derived{f:f32}>, f32, !fir.field) -> !fir.type<derived{f:f32}>
+// CHECK: [[VAL_30:%.*]] = fir.len_param_index f, !fir.type<derived3{f:f32}>
   %c1 = constant 1 : i32
-  // CHECK: fir.gendims %{{.*}}, %{{.*}}, %{{.*}} : (i32, i32, i32) -> !fir.dims<1>
   %24 = fir.gendims %c1, %19, %c1 : (i32, i32, i32) -> !fir.dims<1>
   %cf1 = constant 1.0 : f32
-  // CHECK: fir.insert_value %{{.*}}, %{{.*}}, %{{.*}} : (!fir.type<derived{f:f32}>, f32, !fir.field) -> !fir.type<derived{f:f32}>
   %25 = fir.insert_value %22, %cf1, %21 : (!fir.type<derived{f:f32}>, f32, !fir.field) -> !fir.type<derived{f:f32}>
-  // CHECK: fir.len_param_index f, !fir.type<derived3{f:f32}>
   %26 = fir.len_param_index f, !fir.type<derived3{f:f32}>
+
+// CHECK: [[VAL_31:%.*]] = fir.call @box3() : () -> !fir.box<!fir.type<derived3{f:f32}>>
+// CHECK: [[VAL_32:%.*]] = fir.dispatch "method"([[VAL_31]]) : (!fir.box<!fir.type<derived3{f:f32}>>) -> i32
+// CHECK: [[VAL_33:%.*]] = fir.convert [[VAL_32]] : (i32) -> i64
+// CHECK: [[VAL_34:%.*]] = fir.gentypedesc !fir.type<x>
+// CHECK: fir.call @user_tdesc([[VAL_34]]) : (!fir.tdesc<!fir.type<x>>) -> ()
+// CHECK: [[VAL_35:%.*]] = fir.no_reassoc [[VAL_33]] : i64
   %27 = fir.call @box3() : () -> !fir.box<!fir.type<derived3{f:f32}>>
-  // CHECK: fir.dispatch "method"(%{{.*}}) : (!fir.box<!fir.type<derived3{f:f32}>>) -> i32
   %28 = fir.dispatch "method"(%27) : (!fir.box<!fir.type<derived3{f:f32}>>) -> i32
-  // CHECK: fir.convert %{{.*}} : (i32) -> i64
   %29 = fir.convert %28 : (i32) -> i64
-  // CHECK: fir.gentypedesc !fir.type<x>
   %30 = fir.gentypedesc !fir.type<x>
   fir.call @user_tdesc(%30) : (!fir.tdesc<!fir.type<x>>) -> ()
-  // CHECK: fir.no_reassoc %{{.*}} : i64
   %31 = fir.no_reassoc %29 : i64
+
+// CHECK: fir.call @user_i64([[VAL_35]]) : (i64) -> ()
+// CHECK: fir.freemem [[VAL_5]] : !fir.heap<!fir.array<100xf32>>
+// CHECK: [[VAL_36:%.*]] = fir.call @get_func() : () -> (() -> ())
+// CHECK: fir.call [[VAL_36]]() : () -> ()
+// CHECK: [[VAL_37:%.*]] = fir.address_of(@it1) : !fir.ref<() -> !fir.int<4>>
+// CHECK: return
+// CHECK: }
   fir.call @user_i64(%31) : (i64) -> ()
-  // CHECK: fir.freemem %{{.*}} : !fir.heap<!fir.array<100xf32>>
   fir.freemem %5 : !fir.heap<!fir.array<100xf32>>
   %32 = fir.call @get_func() : () -> (() -> ())
   fir.call %32() : () -> ()
-  // CHECK: fir.address_of(@it1) : !fir.ref<() -> !fir.int<4>>
   %33 = fir.address_of (@it1) : !fir.ref<() -> !fir.int<4>>
   return
 }
 
-// CHECK-LABEL: @boxing_match
+// CHECK-LABEL: func @boxing_match() {
 func @boxing_match() {
+// CHECK: [[VAL_38:%.*]] = fir.alloca i32
+// CHECK: [[VAL_39:%.*]] = fir.alloca !fir.type<qq2{f1:i32,f2:f64}>
+// CHECK: [[VAL_40:%.*]] = fir.alloca !fir.char<1>
+// CHECK: [[VAL_41:%.*]] = fir.alloca tuple<i32, f64>
+// CHECK: [[VAL_42:%.*]] = fir.embox [[VAL_38]] : (!fir.ref<i32>) -> !fir.box<i32>
+// CHECK: [[VAL_43:%.*]]:6 = fir.unbox [[VAL_42]] : (!fir.box<i32>) -> (!fir.ref<i32>, i32, i32, !fir.tdesc<i32>, i32, !fir.dims<0>)
+// CHECK: [[VAL_44:%.*]] = constant 8 : i32
+// CHECK: [[VAL_45:%.*]] = fir.undefined !fir.char<1>
+// CHECK: [[VAL_46:%.*]] = fir.emboxchar [[VAL_40]], [[VAL_44]] : (!fir.ref<!fir.char<1>>, i32) -> !fir.boxchar<1>
+// CHECK: [[VAL_47:%.*]]:2 = fir.unboxchar [[VAL_46]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i32)
+// CHECK: [[VAL_48:%.*]] = fir.undefined !fir.type<qq2{f1:i32,f2:f64}>
+// CHECK: [[VAL_49:%.*]] = constant 0 : i32
+// CHECK: [[VAL_50:%.*]] = constant 12 : i32
+// CHECK: [[VAL_51:%.*]] = fir.insert_value [[VAL_48]], [[VAL_50]], [[VAL_49]] : (!fir.type<qq2{f1:i32,f2:f64}>, i32, i32) -> !fir.type<qq2{f1:i32,f2:f64}>
+// CHECK: [[VAL_52:%.*]] = constant 1 : i32
+// CHECK: [[VAL_53:%.*]] = constant 4.213000e+01 : f64
+// CHECK: [[VAL_54:%.*]] = fir.insert_value [[VAL_48]], [[VAL_53]], [[VAL_52]] : (!fir.type<qq2{f1:i32,f2:f64}>, f64, i32) -> !fir.type<qq2{f1:i32,f2:f64}>
+// CHECK: fir.store [[VAL_54]] to [[VAL_39]] : !fir.ref<!fir.type<qq2{f1:i32,f2:f64}>>
+// CHECK: [[VAL_55:%.*]] = fir.emboxproc @method_impl, [[VAL_41]] : ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<i32, f64>>) -> !fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>
+// CHECK: [[VAL_56:%.*]], [[VAL_57:%.*]] = fir.unboxproc [[VAL_55]] : (!fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>) -> ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<!fir.type<qq2{f1:i32,f2:f64}>>>)
+// CHECK: [[VAL_58:%.*]] = fir.call @box2() : () -> !fir.boxproc<(i32, i32) -> i64>
+// CHECK: [[VAL_59:%.*]], [[VAL_60:%.*]] = fir.unboxproc [[VAL_58]] : (!fir.boxproc<(i32, i32) -> i64>) -> ((i32, i32) -> i64, !fir.ref<tuple<!fir.type<qq1{f1:i32}>>>)
+// CHECK: [[VAL_61:%.*]] = fir.load [[VAL_60]] : !fir.ref<tuple<!fir.type<qq1{f1:i32}>>>
+// CHECK: fir.call @store_tuple([[VAL_61]]) : (tuple<!fir.type<qq1{f1:i32}>>) -> ()
+// CHECK: return
+// CHECK: }
   %0 = fir.alloca i32
   %d6 = fir.alloca !fir.type<qq2{f1:i32,f2:f64}>
   %d3 = fir.alloca !fir.char<1>
   %e6 = fir.alloca tuple<i32,f64>
   %1 = fir.embox %0 : (!fir.ref<i32>) -> !fir.box<i32>
-  // CHECK: fir.unbox %{{.*}} : (!fir.box<i32>) -> (!fir.ref<i32>, i32, i32, !fir.tdesc<i32>, i32, !fir.dims<0>)
   %2:6 = fir.unbox %1 : (!fir.box<i32>) -> (!fir.ref<i32>,i32,i32,!fir.tdesc<i32>,i32,!fir.dims<0>)
   %c8 = constant 8 : i32
   %3 = fir.undefined !fir.char<1>
-  // CHECK: fir.emboxchar %{{.*}}, %{{.*}} : (!fir.ref<!fir.char<1>>, i32) -> !fir.boxchar<1>
-  // CHECK: fir.unboxchar %{{.*}} : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i32)
   %4 = fir.emboxchar %d3, %c8 : (!fir.ref<!fir.char<1>>, i32) -> !fir.boxchar<1>
   %5:2 = fir.unboxchar %4 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i32)
   %6 = fir.undefined !fir.type<qq2{f1:i32,f2:f64}>
   %z = constant 0 : i32
   %c12 = constant 12 : i32
   %a2 = fir.insert_value %6, %c12, %z : (!fir.type<qq2{f1:i32,f2:f64}>, i32, i32) -> !fir.type<qq2{f1:i32,f2:f64}>
   %z1 = constant 1 : i32
   %c42 = constant 42.13 : f64
   %a3 = fir.insert_value %6, %c42, %z1 : (!fir.type<qq2{f1:i32,f2:f64}>, f64, i32) -> !fir.type<qq2{f1:i32,f2:f64}>
   fir.store %a3 to %d6 : !fir.ref<!fir.type<qq2{f1:i32,f2:f64}>>
   %7 = fir.emboxproc @method_impl, %e6 : ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<i32,f64>>) -> !fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>
   %8:2 = fir.unboxproc %7 : (!fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>) -> ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<!fir.type<qq2{f1:i32,f2:f64}>>>)
-  // CHECK: fir.emboxproc @method_impl, %{{.*}} : ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<i32, f64>>) -> !fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>
-  // CHECK: fir.unboxproc %{{.*}} : (!fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>) -> ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<!fir.type<qq2{f1:i32,f2:f64}>>>)
   %9 = fir.call @box2() : () -> !fir.boxproc<(i32, i32) -> i64>
   %10:2 = fir.unboxproc %9 : (!fir.boxproc<(i32, i32) -> i64>) -> ((i32, i32) -> i64, !fir.ref<tuple<!fir.type<qq1{f1:i32}>>>)
   %11 = fir.load %10#1 : !fir.ref<tuple<!fir.type<qq1{f1:i32}>>>
   fir.call @store_tuple(%11) : (tuple<!fir.type<qq1{f1:i32}>>) -> ()
   return
 }
 
-// CHECK-LABEL: @loop
+// CHECK-LABEL: func @loop() {
 func @loop() {
+// CHECK: [[VAL_62:%.*]] = constant 1 : index
+// CHECK: [[VAL_63:%.*]] = constant 10 : index
+// CHECK: [[VAL_64:%.*]] = constant true
   %c1 = constant 1 : index
   %c10 = constant 10 : index
   %ct = constant true
-  // CHECK: fir.loop %{{.*}} = %{{.*}} to %{{.*}} {
-  %i = fir.loop %i = %c1 to %c10 {
-    // CHECK: fir.where %{{.*}} {
-    fir.where %ct {
+
+// CHECK: fir.do_loop [[VAL_65:%.*]] = [[VAL_62]] to [[VAL_63]] step [[VAL_62]] {
+// CHECK: fir.if [[VAL_64]] {
+// CHECK: fir.call @nop() : () -> ()
+// CHECK: } else {
+// CHECK: fir.call @nop() : () -> ()
+// CHECK: }
+// CHECK: }
+// CHECK: fir.unreachable
+// CHECK: }
+  fir.do_loop %i = %c1 to %c10 step %c1 {
+    fir.if %ct {
       fir.call @nop() : () -> ()
-    // CHECK: } otherwise {
-    } otherwise {
+    } else {
       fir.call @nop() : () -> ()
     }
   }
-  // CHECK: fir.unreachable
   fir.unreachable
 }
 
-// CHECK-LABEL: @bar_select
+// CHECK: func @bar_select([[VAL_66:%.*]]: i32, [[VAL_67:%.*]]: i32) -> i32 {
 func @bar_select(%arg : i32, %arg2 : i32) -> i32 {
+// CHECK: [[VAL_68:%.*]] = constant 1 : i32
+// CHECK: [[VAL_69:%.*]] = constant 2 : i32
+// CHECK: [[VAL_70:%.*]] = constant 3 : i32
+// CHECK: [[VAL_71:%.*]] = constant 4 : i32
   %0 = constant 1 : i32
   %1 = constant 2 : i32
   %2 = constant 3 : i32
   %3 = constant 4 : i32
-  // CHECK: fir.select %{{.*}} : i32 [1, ^bb1(%{{.*}} : i32), 2, ^bb2(%{{.*}}, %{{.*}}, %{{.*}} : i32, i32, i32), -3, ^bb3(%{{.*}}, %{{.*}} : i32, i32), 4, ^bb4(%{{.*}} : i32), unit, ^bb5]
+
+// CHECK: fir.select [[VAL_66]] : i32 [1, ^bb1([[VAL_68]] : i32), 2, ^bb2([[VAL_70]], [[VAL_66]], [[VAL_67]] : i32, i32, i32), -3, ^bb3([[VAL_67]], [[VAL_70]] : i32, i32), 4, ^bb4([[VAL_69]] : i32), unit, ^bb5]
+// CHECK: ^bb1([[VAL_72:%.*]]: i32):
+// CHECK: return [[VAL_72]] : i32
+// CHECK: ^bb2([[VAL_73:%.*]]: i32, [[VAL_74:%.*]]: i32, [[VAL_75:%.*]]: i32):
+// CHECK: [[VAL_76:%.*]] = addi [[VAL_73]], [[VAL_74]] : i32
+// CHECK: [[VAL_77:%.*]] = addi [[VAL_76]], [[VAL_75]] : i32
+// CHECK: return [[VAL_77]] : i32
+// CHECK: ^bb3([[VAL_78:%.*]]: i32, [[VAL_79:%.*]]: i32):
+// CHECK: [[VAL_80:%.*]] = addi [[VAL_78]], [[VAL_79]] : i32
+// CHECK: return [[VAL_80]] : i32
+// CHECK: ^bb4([[VAL_81:%.*]]: i32):
+// CHECK: return [[VAL_81]] : i32
+// CHECK: ^bb5:
+// CHECK: [[VAL_82:%.*]] = constant 0 : i32
+// CHECK: return [[VAL_82]] : i32
+// CHECK: }
   fir.select %arg:i32 [ 1,^bb1(%0:i32), 2,^bb2(%2,%arg,%arg2:i32,i32,i32), -3,^bb3(%arg2,%2:i32,i32), 4,^bb4(%1:i32), unit,^bb5 ]
 ^bb1(%a : i32) :
   return %a : i32
 ^bb2(%b : i32, %b2 : i32, %b3:i32) :
   %4 = addi %b, %b2 : i32
   %5 = addi %4, %b3 : i32
   return %5 : i32
 ^bb3(%c:i32, %c2:i32) :
   %6 = addi %c, %c2 : i32
   return %6 : i32
 ^bb4(%d : i32) :
   return %d : i32
 ^bb5 :
   %zero = constant 0 : i32
   return %zero : i32
 }
 
-// CHECK-LABEL: @bar_select_rank
+// CHECK-LABEL: func @bar_select_rank(
+// CHECK-SAME: [[VAL_83:%.*]]: i32, [[VAL_84:%.*]]: i32) -> i32 {
 func @bar_select_rank(%arg : i32, %arg2 : i32) -> i32 {
+// CHECK: [[VAL_85:%.*]] = constant 1 : i32
+// CHECK: [[VAL_86:%.*]] = constant 2 : i32
+// CHECK: [[VAL_87:%.*]] = constant 3 : i32
+// CHECK: [[VAL_88:%.*]] = constant 4 : i32
   %0 = constant 1 : i32
   %1 = constant 2 : i32
   %2 = constant 3 : i32
   %3 = constant 4 : i32
-  // CHECK: fir.select_rank %{{.*}} : i32 [1, ^bb1(%{{.*}} : i32), 2, ^bb2(%{{.*}}, %{{.*}}, %{{.*}} : i32, i32, i32), 3, ^bb3(%{{.*}}, %{{.*}} : i32, i32), -1, ^bb4(%{{.*}} : i32), unit, ^bb5]
+
+// CHECK: fir.select_rank [[VAL_83]] : i32 [1, ^bb1([[VAL_85]] : i32), 2, ^bb2([[VAL_87]], [[VAL_83]], [[VAL_84]] : i32, i32, i32), 3, ^bb3([[VAL_84]], [[VAL_87]] : i32, i32), -1, ^bb4([[VAL_86]] : i32), unit, ^bb5]
+// CHECK: ^bb1([[VAL_89:%.*]]: i32):
+// CHECK: return [[VAL_89]] : i32
+// CHECK: ^bb2([[VAL_90:%.*]]: i32, [[VAL_91:%.*]]: i32, [[VAL_92:%.*]]: i32):
+// CHECK: [[VAL_93:%.*]] = addi [[VAL_90]], [[VAL_91]] : i32
+// CHECK: [[VAL_94:%.*]] = addi [[VAL_93]], [[VAL_92]] : i32
+// CHECK: return [[VAL_94]] : i32
   fir.select_rank %arg:i32 [ 1,^bb1(%0:i32), 2,^bb2(%2,%arg,%arg2:i32,i32,i32), 3,^bb3(%arg2,%2:i32,i32), -1,^bb4(%1:i32), unit,^bb5 ]
 ^bb1(%a : i32) :
   return %a : i32
 ^bb2(%b : i32, %b2 : i32, %b3:i32) :
   %4 = addi %b, %b2 : i32
   %5 = addi %4, %b3 : i32
   return %5 : i32
+
+// CHECK: ^bb3([[VAL_95:%.*]]: i32, [[VAL_96:%.*]]: i32):
+// CHECK: [[VAL_97:%.*]] = addi [[VAL_95]], [[VAL_96]] : i32
+// CHECK: return [[VAL_97]] : i32
+// CHECK: ^bb4([[VAL_98:%.*]]: i32):
+// CHECK: return [[VAL_98]] : i32
 ^bb3(%c:i32, %c2:i32) :
   %6 = addi %c, %c2 : i32
   return %6 : i32
 ^bb4(%d : i32) :
   return %d : i32
+
+// CHECK: ^bb5:
+// CHECK: [[VAL_99:%.*]] = constant 0 : i32
+// CHECK: [[VAL_100:%.*]] = fir.call @get_method_box() : () -> !fir.box<!fir.type<derived3{f:f32}>>
+// CHECK: fir.dispatch "method"([[VAL_100]]) : (!fir.box<!fir.type<derived3{f:f32}>>) -> ()
 ^bb5 :
   %zero = constant 0 : i32
   %7 = fir.call @get_method_box() : () -> !fir.box<!fir.type<derived3{f:f32}>>
   fir.dispatch method(%7) : (!fir.box<!fir.type<derived3{f:f32}>>) -> ()
+
+// CHECK: return [[VAL_99]] : i32
+// CHECK: }
   return %zero : i32
 }
 
-// CHECK-LABEL: @bar_select_type
+// CHECK-LABEL: func @bar_select_type(
+// CHECK-SAME: [[VAL_101:%.*]]: !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>>) -> i32 {
 func @bar_select_type(%arg : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>>) -> i32 {
+
+// CHECK: [[VAL_102:%.*]] = constant 1 : i32
+// CHECK: [[VAL_103:%.*]] = constant 2 : i32
+// CHECK: [[VAL_104:%.*]] = constant 3 : i32
+// CHECK: [[VAL_105:%.*]] = constant 4 : i32
   %0 = constant 1 : i32
   %1 = constant 2 : i32
   %2 = constant 3 : i32
   %3 = constant 4 : i32
-  // CHECK: fir.select_type %{{.*}} : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>> [#fir.instance<!fir.int<4>>, ^bb1(%{{.*}} : i32), #fir.instance<!fir.int<8>>, ^bb2(%{{.*}} : i32), #fir.subsumed<!fir.int<2>>, ^bb3(%{{.*}} : i32), #fir.instance<!fir.int<1>>, ^bb4(%{{.*}} : i32), unit, ^bb5]
+
+// CHECK: fir.select_type [[VAL_101]] : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>> [#fir.instance<!fir.int<4>>, ^bb1([[VAL_102]] : i32), #fir.instance<!fir.int<8>>, ^bb2([[VAL_104]] : i32), #fir.subsumed<!fir.int<2>>, ^bb3([[VAL_104]] : i32), #fir.instance<!fir.int<1>>, ^bb4([[VAL_103]] : i32), unit, ^bb5]
   fir.select_type %arg : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>> [ #fir.instance<!fir.int<4>>,^bb1(%0:i32), #fir.instance<!fir.int<8>>,^bb2(%2:i32), #fir.subsumed<!fir.int<2>>,^bb3(%2:i32), #fir.instance<!fir.int<1>>,^bb4(%1:i32), unit,^bb5 ]
+
+// CHECK: ^bb1([[VAL_106:%.*]]: i32):
+// CHECK: return [[VAL_106]] : i32
+// CHECK: ^bb2([[VAL_107:%.*]]: i32):
+// CHECK: return [[VAL_107]] : i32
+// CHECK: ^bb3([[VAL_108:%.*]]: i32):
+// CHECK: return [[VAL_108]] : i32
+// CHECK: ^bb4([[VAL_109:%.*]]: i32):
+// CHECK: return [[VAL_109]] : i32
 ^bb1(%a : i32) :
   return %a : i32
 ^bb2(%b : i32) :
   return %b : i32
 ^bb3(%c : i32) :
   return %c : i32
 ^bb4(%d : i32) :
   return %d : i32
+
+// CHECK: ^bb5:
+// CHECK: [[VAL_110:%.*]] = constant 0 : i32
+// CHECK: return [[VAL_110]] : i32
+// CHECK: }
 ^bb5 :
   %zero = constant 0 : i32
   return %zero : i32
 }
 
-// CHECK-LABEL: @bar_select_case
+// CHECK-LABEL: func @bar_select_case(
+// CHECK-SAME: [[VAL_111:%.*]]: i32, [[VAL_112:%.*]]: i32) -> i32 {
+// CHECK: [[VAL_113:%.*]] = constant 1 : i32
+// CHECK: [[VAL_114:%.*]] = constant 2 : i32
+// CHECK: [[VAL_115:%.*]] = constant 3 : i32
+// CHECK: [[VAL_116:%.*]] = constant 4 : i32
 func @bar_select_case(%arg : i32, %arg2 : i32) -> i32 {
   %0 = constant 1 : i32
   %1 = constant 2 : i32
   %2 = constant 3 : i32
   %3 = constant 4 : i32
-  // CHECK: fir.select_case %{{.*}} : i32 [#fir.point, %{{.*}}, ^bb1(%{{.*}} : i32), #fir.lower, %{{.*}}, ^bb2(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : i32, i32, i32, i32), #fir.interval, %{{.*}}, %{{.*}}, ^bb3(%{{.*}}, %{{.*}} : i32, i32), #fir.upper, %{{.*}}, ^bb4(%{{.*}} : i32), unit, ^bb5]
+
+// CHECK: fir.select_case [[VAL_111]] : i32 [#fir.point, [[VAL_113]], ^bb1([[VAL_113]] : i32), #fir.lower, [[VAL_114]], ^bb2([[VAL_115]], [[VAL_111]], [[VAL_112]], [[VAL_114]] : i32, i32, i32, i32), #fir.interval, [[VAL_115]], [[VAL_116]], ^bb3([[VAL_115]], [[VAL_112]] : i32, i32), #fir.upper, [[VAL_111]], ^bb4([[VAL_114]] : i32), unit, ^bb5]
   fir.select_case %arg : i32 [#fir.point, %0, ^bb1(%0:i32), #fir.lower, %1, ^bb2(%2,%arg,%arg2,%1:i32,i32,i32,i32), #fir.interval, %2, %3, ^bb3(%2,%arg2:i32,i32), #fir.upper, %arg, ^bb4(%1:i32), unit, ^bb5]
+
+// CHECK: ^bb1([[VAL_117:%.*]]: i32):
+// CHECK: return [[VAL_117]] : i32
+// CHECK: ^bb2([[VAL_118:%.*]]: i32, [[VAL_119:%.*]]: i32, [[VAL_120:%.*]]: i32, [[VAL_121:%.*]]: i32):
+// CHECK: [[VAL_122:%.*]] = addi [[VAL_118]], [[VAL_119]] : i32
+// CHECK: [[VAL_123:%.*]] = muli [[VAL_122]], [[VAL_120]] : i32
+// CHECK: [[VAL_124:%.*]] = addi [[VAL_123]], [[VAL_121]] : i32
+// CHECK: return [[VAL_124]] : i32
+// CHECK: ^bb3([[VAL_125:%.*]]: i32, [[VAL_126:%.*]]: i32):
+// CHECK: [[VAL_127:%.*]] = addi [[VAL_125]], [[VAL_126]] : i32
+// CHECK: return [[VAL_127]] : i32
+// CHECK: ^bb4([[VAL_128:%.*]]: i32):
+// CHECK: return [[VAL_128]] : i32
 ^bb1(%a : i32) :
   return %a : i32
 ^bb2(%b : i32, %b2:i32, %b3:i32, %b4:i32) :
   %4 = addi %b, %b2 : i32
   %5 = muli %4, %b3 : i32
   %6 = addi %5, %b4 : i32
   return %6 : i32
 ^bb3(%c : i32, %c2 : i32) :
   %7 = addi %c, %c2 : i32
   return %7 : i32
 ^bb4(%d : i32) :
   return %d : i32
+
+// CHECK: ^bb5:
+// CHECK: [[VAL_129:%.*]] = constant 0 : i32
+// CHECK: return [[VAL_129]] : i32
+// CHECK: }
 ^bb5 :
   %zero = constant 0 : i32
   return %zero : i32
 }
 
-// CHECK-LABEL: @global_var
+// CHECK-LABEL: fir.global @global_var : i32 {
+// CHECK: [[VAL_130:%.*]] = constant 1 : i32
+// CHECK: fir.has_value [[VAL_130]] : i32
+// CHECK: }
 fir.global @global_var : i32 {
   %0 = constant 1 : i32
   fir.has_value %0 : i32
 }
 
-// CHECK-LABEL: @global_constant
+// CHECK-LABEL: fir.global @global_constant constant : i32 {
+// CHECK: [[VAL_131:%.*]] = constant 934 : i32
+// CHECK: fir.has_value [[VAL_131]] : i32
+// CHECK: }
 fir.global @global_constant constant : i32 {
   %0 = constant 934 : i32
   fir.has_value %0 : i32
 }
 
-// CHECK-LABEL: @global_derived
-fir.global @global_derived : !fir.type<minez(f:i32)> {
-  // CHECK: fir.global_len "f", 1 : i32
+// CHECK-LABEL: fir.global @global_derived : !fir.type<minez(f:i32)> {
+// CHECK: [[VAL_132:%.*]] = fir.undefined !fir.type<minez(f:i32)>
+// CHECK: fir.has_value [[VAL_132]] : !fir.type<minez(f:i32)>
+// CHECK: }
+fir.global @global_derived : !fir.type<minez(f:i32)> {
   fir.global_len f, 1 : i32
   %0 = fir.undefined !fir.type<minez>
   fir.has_value %0 : !fir.type<minez>
 }
 
-// CHECK-LABEL: @dispatch_tbl
-fir.dispatch_table @dispatch_tbl {
-  // CHECK: fir.dt_entry "method", @method_impl
+// CHECK-LABEL: fir.dispatch_table @dispatch_tbl {
+// CHECK: }
+fir.dispatch_table @dispatch_tbl {
   fir.dt_entry "method", @method_impl
 }
 
-// CHECK-LABEL: @compare_real
+// CHECK-LABEL: func @compare_real(
+// CHECK-SAME: [[VAL_133:%.*]]: !fir.real<16>, [[VAL_134:%.*]]: !fir.real<16>) {
 func @compare_real(%a : !fir.real<16>, %b : !fir.real<16>) {
-  // CHECK: fir.cmpf "false", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "oeq", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "ogt", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "oge", %{{.*}}, %{{.*}} : !fir.real<16>
+
+// CHECK: [[VAL_135:%.*]] = fir.cmpf "false", [[VAL_133]], [[VAL_134]] : !fir.real<16>
+// CHECK: [[VAL_136:%.*]] = fir.cmpf "oeq", [[VAL_133]], [[VAL_134]] : !fir.real<16>
+// CHECK: [[VAL_137:%.*]] = fir.cmpf "ogt", [[VAL_133]], [[VAL_134]] : !fir.real<16>
+// CHECK: [[VAL_138:%.*]] = fir.cmpf "oge", [[VAL_133]], [[VAL_134]] : !fir.real<16>
   %d0 = fir.cmpf "false", %a, %b : !fir.real<16>
   %d1 = fir.cmpf "oeq", %a, %b : !fir.real<16>
   %d2 = fir.cmpf "ogt", %a, %b : !fir.real<16>
   %d3 = fir.cmpf "oge", %a, %b : !fir.real<16>
-  // CHECK: fir.cmpf "olt", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "ole", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "one", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "ord", %{{.*}}, %{{.*}} : !fir.real<16>
+
+// CHECK: [[VAL_139:%.*]] = fir.cmpf "olt", [[VAL_133]], [[VAL_134]] : !fir.real<16>
+// CHECK: [[VAL_140:%.*]] = fir.cmpf "ole", [[VAL_133]], [[VAL_134]] : !fir.real<16>
+// CHECK: [[VAL_141:%.*]] = fir.cmpf "one", [[VAL_133]], [[VAL_134]] : !fir.real<16>
+// CHECK: [[VAL_142:%.*]] = fir.cmpf "ord", [[VAL_133]], [[VAL_134]] : !fir.real<16>
   %a0 = fir.cmpf "olt", %a, %b : !fir.real<16>
   %a1 = fir.cmpf "ole", %a, %b : !fir.real<16>
   %a2 = fir.cmpf "one", %a, %b : !fir.real<16>
   %a3 = fir.cmpf "ord", %a, %b : !fir.real<16>
-  // CHECK: fir.cmpf "ueq", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "ugt", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "uge", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "ult", %{{.*}}, %{{.*}} : !fir.real<16>
+
+// CHECK: [[VAL_143:%.*]] = fir.cmpf "ueq", [[VAL_133]], [[VAL_134]] : !fir.real<16>
+// CHECK: [[VAL_144:%.*]] = fir.cmpf "ugt", [[VAL_133]], [[VAL_134]] : !fir.real<16>
+// CHECK: [[VAL_145:%.*]] = fir.cmpf "uge", [[VAL_133]], [[VAL_134]] : !fir.real<16>
+// CHECK: [[VAL_146:%.*]] = fir.cmpf "ult", [[VAL_133]], [[VAL_134]] : !fir.real<16>
   %b0 = fir.cmpf "ueq", %a, %b : !fir.real<16>
   %b1 = fir.cmpf "ugt", %a, %b : !fir.real<16>
   %b2 = fir.cmpf "uge", %a, %b : !fir.real<16>
   %b3 = fir.cmpf "ult", %a, %b : !fir.real<16>
-  // CHECK: fir.cmpf "ule", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "une", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "uno", %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.cmpf "true", %{{.*}}, %{{.*}} : !fir.real<16>
+
+// CHECK: [[VAL_147:%.*]] = fir.cmpf "ule", [[VAL_133]], [[VAL_134]] : !fir.real<16>
+// CHECK: [[VAL_148:%.*]] = fir.cmpf "une", [[VAL_133]], [[VAL_134]] : !fir.real<16>
+// CHECK: [[VAL_149:%.*]] = fir.cmpf "uno", [[VAL_133]], [[VAL_134]] : !fir.real<16>
+// CHECK: [[VAL_150:%.*]] = fir.cmpf "true", [[VAL_133]], [[VAL_134]] : !fir.real<16>
   %c0 = fir.cmpf "ule", %a, %b : !fir.real<16>
   %c1 = fir.cmpf "une", %a, %b : !fir.real<16>
   %c2 = fir.cmpf "uno", %a, %b : !fir.real<16>
   %c3 = fir.cmpf "true", %a, %b : !fir.real<16>
+
+// CHECK: return
+// CHECK: }
   return
 }
 
-// CHECK-LABEL: @compare_complex
+// CHECK-LABEL: func @compare_complex(
+// CHECK-SAME: [[VAL_151:%.*]]: !fir.complex<16>, [[VAL_152:%.*]]: !fir.complex<16>) {
 func @compare_complex(%a : !fir.complex<16>, %b : !fir.complex<16>) {
-  // CHECK: fir.cmpc "false", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "oeq", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "ogt", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "oge", %{{.*}}, %{{.*}} : !fir.complex<16>
+
+// CHECK: [[VAL_153:%.*]] = fir.cmpc "false", [[VAL_151]], [[VAL_152]] : !fir.complex<16>
+// CHECK: [[VAL_154:%.*]] = fir.cmpc "oeq", [[VAL_151]], [[VAL_152]] : !fir.complex<16>
+// CHECK: [[VAL_155:%.*]] = fir.cmpc "ogt", [[VAL_151]], [[VAL_152]] : !fir.complex<16>
+// CHECK: [[VAL_156:%.*]] = fir.cmpc "oge", [[VAL_151]], [[VAL_152]] : !fir.complex<16>
   %d0 = fir.cmpc "false", %a, %b : !fir.complex<16>
   %d1 = fir.cmpc "oeq", %a, %b : !fir.complex<16>
   %d2 = fir.cmpc "ogt", %a, %b : !fir.complex<16>
   %d3 = fir.cmpc "oge", %a, %b : !fir.complex<16>
-  // CHECK: fir.cmpc "olt", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "ole", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "one", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "ord", %{{.*}}, %{{.*}} : !fir.complex<16>
+
+// CHECK: [[VAL_157:%.*]] = fir.cmpc "olt", [[VAL_151]], [[VAL_152]] : !fir.complex<16>
+// CHECK: [[VAL_158:%.*]] = fir.cmpc "ole", [[VAL_151]], [[VAL_152]] : !fir.complex<16>
+// CHECK: [[VAL_159:%.*]] = fir.cmpc "one", [[VAL_151]], [[VAL_152]] : !fir.complex<16>
+// CHECK: [[VAL_160:%.*]] = fir.cmpc "ord", [[VAL_151]], [[VAL_152]] : !fir.complex<16>
   %a0 = fir.cmpc "olt", %a, %b : !fir.complex<16>
   %a1 = fir.cmpc "ole", %a, %b : !fir.complex<16>
   %a2 = fir.cmpc "one", %a, %b : !fir.complex<16>
   %a3 = fir.cmpc "ord", %a, %b : !fir.complex<16>
-  // CHECK: fir.cmpc "ueq", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "ugt", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "uge", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "ult", %{{.*}}, %{{.*}} : !fir.complex<16>
+
+// CHECK: [[VAL_161:%.*]] = fir.cmpc "ueq", [[VAL_151]], [[VAL_152]] : !fir.complex<16>
+// CHECK: [[VAL_162:%.*]] = fir.cmpc "ugt", [[VAL_151]], [[VAL_152]] : !fir.complex<16>
+// CHECK: [[VAL_163:%.*]] = fir.cmpc "uge", [[VAL_151]], [[VAL_152]] : !fir.complex<16>
+// CHECK: [[VAL_164:%.*]] = fir.cmpc "ult", [[VAL_151]], [[VAL_152]] : !fir.complex<16>
   %b0 = fir.cmpc "ueq", %a, %b : !fir.complex<16>
   %b1 = fir.cmpc "ugt", %a, %b : !fir.complex<16>
   %b2 = fir.cmpc "uge", %a, %b : !fir.complex<16>
   %b3 = fir.cmpc "ult", %a, %b : !fir.complex<16>
-  // CHECK: fir.cmpc "ule", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "une", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "uno", %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.cmpc "true", %{{.*}}, %{{.*}} : !fir.complex<16>
+
+// CHECK: [[VAL_165:%.*]] = fir.cmpc "ule", [[VAL_151]], [[VAL_152]] : !fir.complex<16>
+// CHECK: [[VAL_166:%.*]] = fir.cmpc "une", [[VAL_151]], [[VAL_152]] : !fir.complex<16>
+// CHECK: [[VAL_167:%.*]] = fir.cmpc "uno", [[VAL_151]], [[VAL_152]] : !fir.complex<16>
+// CHECK: [[VAL_168:%.*]] = fir.cmpc "true", [[VAL_151]], [[VAL_152]] : !fir.complex<16>
   %c0 = fir.cmpc "ule", %a, %b : !fir.complex<16>
   %c1 = fir.cmpc "une", %a, %b : !fir.complex<16>
   %c2 = fir.cmpc "uno", %a, %b : !fir.complex<16>
   %c3 = fir.cmpc "true", %a, %b : !fir.complex<16>
+// CHECK: return
+// CHECK: }
   return
 }
 
-// CHECK-LABEL: @arith_real
+// CHECK-LABEL: func @arith_real(
+// CHECK-SAME: [[VAL_169:%.*]]: !fir.real<16>, [[VAL_170:%.*]]: !fir.real<16>) -> !fir.real<16> {
 func @arith_real(%a : !fir.real<16>, %b : !fir.real<16>) -> !fir.real<16> {
+
+// CHECK: [[VAL_171:%.*]] = constant 1.0
+// CHECK: [[VAL_172:%.*]] = fir.convert [[VAL_171]] : (f32) -> !fir.real<16>
+// CHECK: [[VAL_173:%.*]] = fir.negf [[VAL_169]] : !fir.real<16>
+// CHECK: [[VAL_174:%.*]] = fir.addf [[VAL_172]], [[VAL_173]] : !fir.real<16>
+// CHECK: [[VAL_175:%.*]] = fir.subf [[VAL_174]], [[VAL_170]] : !fir.real<16>
+// CHECK: [[VAL_176:%.*]] = fir.mulf [[VAL_173]], [[VAL_175]] : !fir.real<16>
+// CHECK: [[VAL_177:%.*]] = fir.divf [[VAL_176]], [[VAL_169]] : !fir.real<16>
   %c1 = constant 1.0 : f32
   %0 = fir.convert %c1 : (f32) -> !fir.real<16>
-  // CHECK: %[[R1:.*]] = fir.negf %{{.*}} : !fir.real<16>
-  // CHECK: fir.addf %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: %[[R3:.*]] = fir.subf %{{.*}}, %{{.*}} : !fir.real<16>
-  // CHECK: fir.mulf %[[R1]], %[[R3]] : !fir.real<16>
-  // CHECK: fir.divf %{{.*}}, %{{.*}} : !fir.real<16>
   %1 = fir.negf %a : !fir.real<16>
   %2 = fir.addf %0, %1 : !fir.real<16>
   %3 = fir.subf %2, %b : !fir.real<16>
   %4 = fir.mulf %1, %3 : !fir.real<16>
   %5 = fir.divf %4, %a : !fir.real<16>
+// CHECK: return [[VAL_177]] : !fir.real<16>
+// CHECK: }
   return %5 : !fir.real<16>
 }
 
-// CHECK-LABEL: @arith_complex
+// CHECK-LABEL: func @arith_complex(
+// CHECK-SAME: [[VAL_178:%.*]]: !fir.complex<16>, [[VAL_179:%.*]]: !fir.complex<16>) -> !fir.complex<16> {
 func @arith_complex(%a : !fir.complex<16>, %b : !fir.complex<16>) -> !fir.complex<16> {
-  // CHECK: fir.negc %{{.*}} : !fir.complex<16>
-  // CHECK: fir.addc %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.subc %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.mulc %{{.*}}, %{{.*}} : !fir.complex<16>
-  // CHECK: fir.divc %{{.*}}, %{{.*}} : !fir.complex<16>
+// CHECK: [[VAL_180:%.*]] = fir.negc [[VAL_178]] : !fir.complex<16>
+// CHECK: [[VAL_181:%.*]] = fir.addc [[VAL_179]], [[VAL_180]] : !fir.complex<16>
+// CHECK: [[VAL_182:%.*]] = fir.subc [[VAL_181]], [[VAL_179]] : !fir.complex<16>
+// CHECK: [[VAL_183:%.*]] = fir.mulc [[VAL_180]], [[VAL_182]] : !fir.complex<16>
+// CHECK: [[VAL_184:%.*]] = fir.divc [[VAL_183]], [[VAL_178]] : !fir.complex<16>
   %1 = fir.negc %a : !fir.complex<16>
   %2 = fir.addc %b, %1 : !fir.complex<16>
   %3 = fir.subc %2, %b : !fir.complex<16>
   %4 = fir.mulc %1, %3 : !fir.complex<16>
   %5 = fir.divc %4, %a : !fir.complex<16>
+// CHECK: return [[VAL_184]] : !fir.complex<16>
+// CHECK: }
   return %5 : !fir.complex<16>
 }
 
-// CHECK-LABEL: @character_literal
+// CHECK-LABEL: func @character_literal() -> !fir.array<13x!fir.char<1>> {
 func @character_literal() -> !fir.array<13 x !fir.char<1>> {
-  // CHECK: fir.string_lit "Hello, World!"(13) : !fir.char<1>
+// CHECK: [[VAL_185:%.*]] = fir.string_lit "Hello, World!"(13) : !fir.char<1>
   %0 = fir.string_lit "Hello, World!"(13) : !fir.char<1>
+// CHECK: return [[VAL_185]] : !fir.array<13x!fir.char<1>>
   return %0 : !fir.array<13 x !fir.char<1>>
+// CHECK: }
+}
+
+// CHECK-LABEL: func @earlyexit2(i32) -> i1
+func @earlyexit2(%a : i32) -> i1
+
+// CHECK-LABEL: func @early_exit(
+// CHECK-SAME: [[VAL_186:%.*]]: i1, [[VAL_187:%.*]]: i32) -> i1 {
+func @early_exit(%ok : i1, %k : i32) -> i1 {
+// CHECK: [[VAL_188:%.*]] = constant 1 : index
+// CHECK: [[VAL_189:%.*]] = constant 100 : index
+  %c1 = constant 1 : index
+  %c100 = constant 100 : index
+
+// CHECK: [[VAL_190:%.*]], [[VAL_191:%.*]] = fir.iterate_while ([[VAL_192:%.*]] = [[VAL_188]] to [[VAL_189]] step [[VAL_188]]) and ([[VAL_193:%.*]] = [[VAL_186]]) iter_args([[VAL_194:%.*]] = [[VAL_187]]) -> (i32) {
+// CHECK: [[VAL_195:%.*]] = call @earlyexit2([[VAL_194]]) : (i32) -> i1
+// CHECK: fir.result [[VAL_195]], [[VAL_194]] : i1, i32
+// CHECK: }
+  %newOk:2 = fir.iterate_while (%i = %c1 to %c100 step %c1) and (%ok_ = %ok) iter_args(%v = %k) -> (i32) {
+    %stop = call @earlyexit2(%v) : (i32) -> i1
+    fir.result %stop, %v : i1, i32
+  }
+// CHECK: return [[VAL_190]] : i1
+// CHECK: }
+  return %newOk#0 : i1
 }