[flang] system_clock intrinsic calls with dynamically optional arguments

[clementval]

Summary

system_clock intrinsic calls with dynamically optional arguments

Modify intrinsic system_clock calls to allow for an argument that is optional
or a disassociated pointer or an unallocated allocatable. A call with such an
argument is the same as a call that does not specify that argument.

Rename (genIsNotNull -> genIsNotNullAddr) and (genIsNull -> genIsNullAddr)
and add a use of genIsNotNullAddr.

This patch is part of the upstreaming effort from fir-dev branch.

Co-authored-by: V Donaldson <[e-mail]>

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/include/flang/Optimizer/Builder/FIRBuilder.h

public:
   /// Create an IfOp with an "else" region, and no result values.
   /// Usage: genIfThenElse(loc, cdt).genThen(lambda).genElse(lambda).end();
   IfBuilder genIfThenElse(mlir::Location loc, mlir::Value cdt) {
     auto op = create<fir::IfOp>(loc, llvm::None, cdt, true);
     return IfBuilder(op, *this);
   }
 
   /// Generate code testing \p addr is not a null address.
-  mlir::Value genIsNotNull(mlir::Location loc, mlir::Value addr);
+  mlir::Value genIsNotNullAddr(mlir::Location loc, mlir::Value addr);
 
   /// Generate code testing \p addr is a null address.
-  mlir::Value genIsNull(mlir::Location loc, mlir::Value addr);
+  mlir::Value genIsNullAddr(mlir::Location loc, mlir::Value addr);
 
   /// Compute the extent of (lb:ub:step) as max((ub-lb+step)/step, 0). See
   /// Fortran 2018 9.5.3.3.2 section for more details.
   mlir::Value genExtentFromTriplet(mlir::Location loc, mlir::Value lb,
                                    mlir::Value ub, mlir::Value step,
                                    mlir::Type type);
 
   /// Dump the current function. (debug)

flang/lib/Lower/CustomIntrinsicCall.cpp

static bool isIshftcWithDynamicallyOptionalArg(
   if (name != "ishftc" || procRef.arguments().size() < 3)
     return false;
   auto *expr = Fortran::evaluate::UnwrapExpr<Fortran::lower::SomeExpr>(
       procRef.arguments()[2]);
   return expr &&
          Fortran::evaluate::MayBePassedAsAbsentOptional(*expr, foldingContex);
 }
 
-/// Is this a call to SYSTEM_CLOCK or RANDOM_SEED intrinsic with arguments that
-/// may be absent at runtime? This are special cases because that aspect cannot
+/// Is this a call to the RANDOM_SEED intrinsic with arguments that may be
+/// absent at runtime? This is a special case because that aspect cannot
 /// be delegated to the runtime via a null fir.box or address given the current
 /// runtime entry point.
-static bool isSystemClockOrRandomSeedWithOptionalArg(
+static bool isRandomSeedWithDynamicallyOptionalArg(
     llvm::StringRef name, const Fortran::evaluate::ProcedureRef &procRef,
     Fortran::evaluate::FoldingContext &foldingContex) {
-  if (name != "system_clock" && name != "random_seed")
+  if (name != "random_seed")
     return false;
   for (const auto &arg : procRef.arguments()) {
     auto *expr = Fortran::evaluate::UnwrapExpr<Fortran::lower::SomeExpr>(arg);
     if (expr &&
         Fortran::evaluate::MayBePassedAsAbsentOptional(*expr, foldingContex))
       return true;
   }
   return false;
 }
 
 bool Fortran::lower::intrinsicRequiresCustomOptionalHandling(
     const Fortran::evaluate::ProcedureRef &procRef,
     const Fortran::evaluate::SpecificIntrinsic &intrinsic,
     AbstractConverter &converter) {
   llvm::StringRef name = intrinsic.name;
   Fortran::evaluate::FoldingContext &fldCtx = converter.getFoldingContext();
   return isMinOrMaxWithDynamicallyOptionalArg(name, procRef, fldCtx) ||
          isIshftcWithDynamicallyOptionalArg(name, procRef, fldCtx) ||
-         isSystemClockOrRandomSeedWithOptionalArg(name, procRef, fldCtx);
+         isRandomSeedWithDynamicallyOptionalArg(name, procRef, fldCtx);
 }
 
 static void prepareMinOrMaxArguments(
     const Fortran::evaluate::ProcedureRef &procRef,
     const Fortran::evaluate::SpecificIntrinsic &intrinsic,
     llvm::Optional<mlir::Type> retTy,
     const Fortran::lower::OperandPrepare &prepareOptionalArgument,
     const Fortran::lower::OperandPrepare &prepareOtherArgument,

flang/lib/Lower/HostAssociations.cpp

if (canReadCapturedBoxValue(converter, sym)) {
       // (absent boxes are null descriptor addresses, not descriptors containing
       // a null base address).
       if (Fortran::semantics::IsOptional(sym)) {
         auto boxTy = box.getType().cast<fir::BoxType>();
         auto eleTy = boxTy.getEleTy();
         if (!fir::isa_ref_type(eleTy))
           eleTy = builder.getRefType(eleTy);
         auto addr = builder.create<fir::BoxAddrOp>(loc, eleTy, box);
-        mlir::Value isPresent = builder.genIsNotNull(loc, addr);
+        mlir::Value isPresent = builder.genIsNotNullAddr(loc, addr);
         auto absentBox = builder.create<fir::AbsentOp>(loc, boxTy);
         box = builder.create<mlir::arith::SelectOp>(loc, isPresent, box,
                                                     absentBox);
       }
       fir::BoxValue boxValue(box, lbounds, /*explicitParams=*/llvm::None);
       args.symMap.addSymbol(sym, boxValue);
     }
   }

flang/lib/Lower/IntrinsicCall.cpp

if (isStaticallyPresent(value) || isStaticallyPresent(status) ||
     mlir::Value errBox =
         isStaticallyPresent(errmsg)
             ? fir::getBase(errmsg)
             : builder.create<fir::AbsentOp>(loc, boxNoneTy).getResult();
     mlir::Value stat =
         fir::runtime::genArgumentValue(builder, loc, number, valBox, errBox);
     if (isStaticallyPresent(status)) {
       mlir::Value statAddr = fir::getBase(status);
-      mlir::Value statIsPresentAtRuntime = builder.genIsNotNull(loc, statAddr);
+      mlir::Value statIsPresentAtRuntime =
+          builder.genIsNotNullAddr(loc, statAddr);
       builder.genIfThen(loc, statIsPresentAtRuntime)
           .genThen(
               [&]() { builder.createStoreWithConvert(loc, stat, statAddr); })
           .end();
     }
   }
   if (isStaticallyPresent(length)) {
     mlir::Value lenAddr = fir::getBase(length);
-    mlir::Value lenIsPresentAtRuntime = builder.genIsNotNull(loc, lenAddr);
+    mlir::Value lenIsPresentAtRuntime = builder.genIsNotNullAddr(loc, lenAddr);
     builder.genIfThen(loc, lenIsPresentAtRuntime)
         .genThen([&]() {
           mlir::Value len =
               fir::runtime::genArgumentLength(builder, loc, number);
           builder.createStoreWithConvert(loc, len, lenAddr);
         })
         .end();
   }
void IntrinsicLibrary::genGetEnvironmentVariable(
   // Handle optional TRIM_NAME argument
   mlir::Value trim;
   if (isStaticallyAbsent(trimName)) {
     trim = builder.createBool(loc, true);
   } else {
     mlir::Type i1Ty = builder.getI1Type();
     mlir::Value trimNameAddr = fir::getBase(trimName);
     mlir::Value trimNameIsPresentAtRuntime =
-        builder.genIsNotNull(loc, trimNameAddr);
+        builder.genIsNotNullAddr(loc, trimNameAddr);
     trim = builder
                .genIfOp(loc, {i1Ty}, trimNameIsPresentAtRuntime,
                         /*withElseRegion=*/true)
                .genThen([&]() {
                  auto trimLoad = builder.create<fir::LoadOp>(loc, trimNameAddr);
                  mlir::Value cast = builder.createConvert(loc, i1Ty, trimLoad);
                  builder.create<fir::ResultOp>(loc, cast);
                })
if (isStaticallyPresent(value) || isStaticallyPresent(status) ||
     mlir::Value errBox =
         isStaticallyPresent(errmsg)
             ? fir::getBase(errmsg)
             : builder.create<fir::AbsentOp>(loc, boxNoneTy).getResult();
     mlir::Value stat = fir::runtime::genEnvVariableValue(builder, loc, name,
                                                          valBox, trim, errBox);
     if (isStaticallyPresent(status)) {
       mlir::Value statAddr = fir::getBase(status);
-      mlir::Value statIsPresentAtRuntime = builder.genIsNotNull(loc, statAddr);
+      mlir::Value statIsPresentAtRuntime =
+          builder.genIsNotNullAddr(loc, statAddr);
       builder.genIfThen(loc, statIsPresentAtRuntime)
           .genThen(
               [&]() { builder.createStoreWithConvert(loc, stat, statAddr); })
           .end();
     }
   }
 
   if (isStaticallyPresent(length)) {
     mlir::Value lenAddr = fir::getBase(length);
-    mlir::Value lenIsPresentAtRuntime = builder.genIsNotNull(loc, lenAddr);
+    mlir::Value lenIsPresentAtRuntime = builder.genIsNotNullAddr(loc, lenAddr);
     builder.genIfThen(loc, lenIsPresentAtRuntime)
         .genThen([&]() {
           mlir::Value len =
               fir::runtime::genEnvVariableLength(builder, loc, name, trim);
           builder.createStoreWithConvert(loc, len, lenAddr);
         })
         .end();
   }
return builder.createConvert(loc, resultType,
                                  fir::runtime::genSize(builder, loc, array));
 
   // Get the DIM argument.
   mlir::Value dim = fir::getBase(args[1]);
   if (!fir::isa_ref_type(dim.getType()))
     return builder.createConvert(
         loc, resultType, fir::runtime::genSizeDim(builder, loc, array, dim));
 
-  mlir::Value isDynamicallyAbsent = builder.genIsNull(loc, dim);
+  mlir::Value isDynamicallyAbsent = builder.genIsNullAddr(loc, dim);
   return builder
       .genIfOp(loc, {resultType}, isDynamicallyAbsent,
                /*withElseRegion=*/true)
       .genThen([&]() {
         mlir::Value size = builder.createConvert(
             loc, resultType, fir::runtime::genSize(builder, loc, array));
         builder.create<fir::ResultOp>(loc, size);
       })

flang/lib/Lower/Runtime.cpp

 //===-- Runtime.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/Lower/Runtime.h"
 #include "flang/Lower/Bridge.h"
 #include "flang/Lower/StatementContext.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/Runtime/RTBuilder.h"
 #include "flang/Optimizer/Builder/Todo.h"
+#include "flang/Optimizer/Dialect/FIROpsSupport.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Runtime/misc-intrinsic.h"
 #include "flang/Runtime/pointer.h"
 #include "flang/Runtime/random.h"
 #include "flang/Runtime/stop.h"
 #include "flang/Runtime/time-intrinsic.h"
 #include "flang/Semantics/tools.h"
 #include "llvm/Support/Debug.h"

 }
 
 /// generate system_clock runtime call/s
 /// all intrinsic arguments are optional and may appear here as mlir::Value{}
 void Fortran::lower::genSystemClock(fir::FirOpBuilder &builder,
                                     mlir::Location loc, mlir::Value count,
                                     mlir::Value rate, mlir::Value max) {
   auto makeCall = [&](mlir::func::FuncOp func, mlir::Value arg) {
+    mlir::Type type = arg.getType();
+    fir::IfOp ifOp{};
+    const bool isOptionalArg =
+        fir::valueHasFirAttribute(arg, fir::getOptionalAttrName());
+    if (type.dyn_cast<fir::PointerType>() || type.dyn_cast<fir::HeapType>()) {
+      // Check for a disassociated pointer or an unallocated allocatable.
+      assert(!isOptionalArg && "invalid optional argument");
+      ifOp = builder.create<fir::IfOp>(loc, builder.genIsNotNullAddr(loc, arg),
+                                       /*withElseRegion=*/false);
+    } else if (isOptionalArg) {
+      ifOp = builder.create<fir::IfOp>(
+          loc, builder.create<fir::IsPresentOp>(loc, builder.getI1Type(), arg),
+          /*withElseRegion=*/false);
+    }
+    if (ifOp)
+      builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
     mlir::Type kindTy = func.getFunctionType().getInput(0);
     int integerKind = 8;
-    if (auto intType =
-            fir::unwrapRefType(arg.getType()).dyn_cast<mlir::IntegerType>())
+    if (auto intType = fir::unwrapRefType(type).dyn_cast<mlir::IntegerType>())
       integerKind = intType.getWidth() / 8;
     mlir::Value kind = builder.createIntegerConstant(loc, kindTy, integerKind);
     mlir::Value res =
         builder.create<fir::CallOp>(loc, func, mlir::ValueRange{kind})
             .getResult(0);
     mlir::Value castRes =
-        builder.createConvert(loc, fir::dyn_cast_ptrEleTy(arg.getType()), res);
+        builder.createConvert(loc, fir::dyn_cast_ptrEleTy(type), res);
     builder.create<fir::StoreOp>(loc, castRes, arg);
+    if (ifOp)
+      builder.setInsertionPointAfter(ifOp);
   };
   using fir::runtime::getRuntimeFunc;
   if (count)
     makeCall(getRuntimeFunc<mkRTKey(SystemClockCount)>(loc, builder), count);
   if (rate)
     makeCall(getRuntimeFunc<mkRTKey(SystemClockCountRate)>(loc, builder), rate);
   if (max)
     makeCall(getRuntimeFunc<mkRTKey(SystemClockCountMax)>(loc, builder), max);
 }

flang/lib/Optimizer/Builder/FIRBuilder.cpp

genNullPointerComparison(fir::FirOpBuilder &builder, mlir::Location loc,
                          mlir::Value addr,
                          mlir::arith::CmpIPredicate condition) {
   auto intPtrTy = builder.getIntPtrType();
   auto ptrToInt = builder.createConvert(loc, intPtrTy, addr);
   auto c0 = builder.createIntegerConstant(loc, intPtrTy, 0);
   return builder.create<mlir::arith::CmpIOp>(loc, condition, ptrToInt, c0);
 }
 
-mlir::Value fir::FirOpBuilder::genIsNotNull(mlir::Location loc,
+mlir::Value fir::FirOpBuilder::genIsNotNullAddr(mlir::Location loc,
                                                 mlir::Value addr) {
   return genNullPointerComparison(*this, loc, addr,
                                   mlir::arith::CmpIPredicate::ne);
 }
 
-mlir::Value fir::FirOpBuilder::genIsNull(mlir::Location loc, mlir::Value addr) {
+mlir::Value fir::FirOpBuilder::genIsNullAddr(mlir::Location loc,
+                                             mlir::Value addr) {
   return genNullPointerComparison(*this, loc, addr,
                                   mlir::arith::CmpIPredicate::eq);
 }
 
 mlir::Value fir::FirOpBuilder::genExtentFromTriplet(mlir::Location loc,
                                                     mlir::Value lb,
                                                     mlir::Value ub,
                                                     mlir::Value step,

flang/lib/Optimizer/Builder/MutableBox.cpp

fir::factory::genMutableBoxRead(fir::FirOpBuilder &builder, mlir::Location loc,
   return addr;
 }
 
 mlir::Value
 fir::factory::genIsAllocatedOrAssociatedTest(fir::FirOpBuilder &builder,
                                              mlir::Location loc,
                                              const fir::MutableBoxValue &box) {
   auto addr = MutablePropertyReader(builder, loc, box).readBaseAddress();
-  return builder.genIsNotNull(loc, addr);
+  return builder.genIsNotNullAddr(loc, addr);
 }
 
 /// Generate finalizer call and inlined free. This does not check that the
 /// address was allocated.
 static void genFinalizeAndFree(fir::FirOpBuilder &builder, mlir::Location loc,
                                mlir::Value addr) {
   // TODO: call finalizer if any.
 
   // A heap (ALLOCATABLE) object may have been converted to a ptr (POINTER),
   // so make sure the heap type is restored before deallocation.
   auto cast = builder.createConvert(
       loc, fir::HeapType::get(fir::dyn_cast_ptrEleTy(addr.getType())), addr);
   builder.create<fir::FreeMemOp>(loc, cast);
 }
 
 void fir::factory::genFinalization(fir::FirOpBuilder &builder,
                                    mlir::Location loc,
                                    const fir::MutableBoxValue &box) {
   auto addr = MutablePropertyReader(builder, loc, box).readBaseAddress();
-  auto isAllocated = builder.genIsNotNull(loc, addr);
+  auto isAllocated = builder.genIsNotNullAddr(loc, addr);
   auto ifOp = builder.create<fir::IfOp>(loc, isAllocated,
                                         /*withElseRegion=*/false);
   auto insPt = builder.saveInsertionPoint();
   builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
   genFinalizeAndFree(builder, loc, addr);
   builder.restoreInsertionPoint(insPt);
 }
 
fir::factory::genReallocIfNeeded(fir::FirOpBuilder &builder, mlir::Location loc,
                                  const fir::MutableBoxValue &box,
                                  mlir::ValueRange shape,
                                  mlir::ValueRange lengthParams) {
   // Implement 10.2.1.3 point 3 logic when lhs is an array.
   auto reader = MutablePropertyReader(builder, loc, box);
   auto addr = reader.readBaseAddress();
   auto i1Type = builder.getI1Type();
   auto addrType = addr.getType();
-  auto isAllocated = builder.genIsNotNull(loc, addr);
+  auto isAllocated = builder.genIsNotNullAddr(loc, addr);
   auto ifOp =
       builder
           .genIfOp(loc, {i1Type, addrType}, isAllocated,
                    /*withElseRegion=*/true)
           .genThen([&]() {
             // The box is allocated. Check if it must be reallocated and
             // reallocate.
             auto mustReallocate = builder.createBool(loc, false);

flang/lib/Optimizer/Builder/Runtime/Ragged.cpp

void fir::runtime::genRaggedArrayAllocate(mlir::Location loc,
   auto extentTy = fir::SequenceType::get(shape, i64Ty);
   auto refTy = fir::ReferenceType::get(i64Ty);
   // Position of the bufferPointer in the header struct.
   auto one = builder.createIntegerConstant(loc, i32Ty, 1);
   auto eleTy = fir::unwrapSequenceType(fir::unwrapRefType(header.getType()));
   auto ptrTy = builder.getRefType(eleTy.cast<mlir::TupleType>().getType(1));
   auto ptr = builder.create<fir::CoordinateOp>(loc, ptrTy, header, one);
   auto heap = builder.create<fir::LoadOp>(loc, ptr);
-  auto cmp = builder.genIsNull(loc, heap);
+  auto cmp = builder.genIsNullAddr(loc, heap);
   builder.genIfThen(loc, cmp)
       .genThen([&]() {
         auto asHeadersVal = builder.createIntegerConstant(loc, i1Ty, asHeaders);
         auto rankVal = builder.createIntegerConstant(loc, i64Ty, rank);
         auto buff = builder.create<fir::AllocMemOp>(loc, extentTy);
         // Convert all the extents to i64 and pack them in a buffer on the heap.
         for (auto i : llvm::enumerate(extents)) {
           auto offset = builder.createIntegerConstant(loc, i32Ty, i.index());

flang/test/Lower/Intrinsics/system_clock.f90

! print*, c, r, m
   ! CHECK-NOT: fir.call
   ! CHECK: %[[c8_3:.*]] = arith.constant 8 : i32
   ! CHECK: %[[Rate:.*]] = fir.call @_FortranASystemClockCountRate(%[[c8_3]]) : (i32) -> i64
   ! CHECK: fir.store %[[Rate]] to %[[m]] : !fir.ref<i64>
   call system_clock(count_rate=m)
   ! CHECK-NOT: fir.call
 ! print*, m
 end subroutine
+
+! CHECK-LABEL: @_QPss
+subroutine ss(count)
+  ! CHECK:   %[[V_0:[0-9]+]] = fir.alloca !fir.box<!fir.heap<i64>> {bindc_name = "count_max", uniq_name = "_QFssEcount_max"}
+  ! CHECK:   %[[V_1:[0-9]+]] = fir.alloca !fir.heap<i64> {uniq_name = "_QFssEcount_max.addr"}
+  ! CHECK:   %[[V_2:[0-9]+]] = fir.zero_bits !fir.heap<i64>
+  ! CHECK:   fir.store %[[V_2]] to %[[V_1]] : !fir.ref<!fir.heap<i64>>
+  ! CHECK:   %[[V_3:[0-9]+]] = fir.alloca !fir.box<!fir.ptr<i64>> {bindc_name = "count_rate", uniq_name = "_QFssEcount_rate"}
+  ! CHECK:   %[[V_4:[0-9]+]] = fir.alloca !fir.ptr<i64> {uniq_name = "_QFssEcount_rate.addr"}
+  ! CHECK:   %[[V_5:[0-9]+]] = fir.zero_bits !fir.ptr<i64>
+  ! CHECK:   fir.store %[[V_5]] to %[[V_4]] : !fir.ref<!fir.ptr<i64>>
+  ! CHECK:   %[[V_6:[0-9]+]] = fir.alloca i64 {bindc_name = "count_rate_", fir.target, uniq_name = "_QFssEcount_rate_"}
+  ! CHECK:   %[[V_7:[0-9]+]] = fir.convert %[[V_6]] : (!fir.ref<i64>) -> !fir.ptr<i64>
+  ! CHECK:   fir.store %[[V_7]] to %[[V_4]] : !fir.ref<!fir.ptr<i64>>
+  ! CHECK:   %[[V_8:[0-9]+]] = fir.allocmem i64 {uniq_name = "_QFssEcount_max.alloc"}
+  ! CHECK:   fir.store %[[V_8]] to %[[V_1]] : !fir.ref<!fir.heap<i64>>
+  ! CHECK:   %[[V_9:[0-9]+]] = fir.load %[[V_4]] : !fir.ref<!fir.ptr<i64>>
+  ! CHECK:   %[[V_10:[0-9]+]] = fir.load %[[V_1]] : !fir.ref<!fir.heap<i64>>
+  ! CHECK:   %[[V_11:[0-9]+]] = fir.is_present %arg0 : (!fir.ref<i64>) -> i1
+  ! CHECK:   fir.if %[[V_11]] {
+  ! CHECK:     %[[V_29:[0-9]+]] = fir.call @_FortranASystemClockCount(%c8{{.*}}_i32) : (i32) -> i64
+  ! CHECK:     fir.store %[[V_29]] to %arg0 : !fir.ref<i64>
+  ! CHECK:   }
+  ! CHECK:   %[[V_12:[0-9]+]] = fir.convert %[[V_9]] : (!fir.ptr<i64>) -> i64
+  ! CHECK:   %[[V_13:[0-9]+]] = arith.cmpi ne, %[[V_12]], %c0{{.*}}_i64 : i64
+  ! CHECK:   fir.if %[[V_13]] {
+  ! CHECK:     %[[V_29]] = fir.call @_FortranASystemClockCountRate(%c8{{.*}}_i32) : (i32) -> i64
+  ! CHECK:     fir.store %[[V_29]] to %[[V_9]] : !fir.ptr<i64>
+  ! CHECK:   }
+  ! CHECK:   %[[V_14:[0-9]+]] = fir.convert %[[V_10]] : (!fir.heap<i64>) -> i64
+  ! CHECK:   %[[V_15:[0-9]+]] = arith.cmpi ne, %[[V_14]], %c0{{.*}}_i64_0 : i64
+  ! CHECK:   fir.if %[[V_15]] {
+  ! CHECK:     %[[V_29]] = fir.call @_FortranASystemClockCountMax(%c8{{.*}}_i32) : (i32) -> i64
+  ! CHECK:     fir.store %[[V_29]] to %[[V_10]] : !fir.heap<i64>
+  ! CHECK:   }
+  ! CHECK:   %[[V_16:[0-9]+]] = fir.is_present %arg0 : (!fir.ref<i64>) -> i1
+  ! CHECK:   fir.if %[[V_16]] {
+  ! CHECK:     %[[V_31:[0-9]+]] = fir.call @_FortranAioBeginExternalListOutput
+  ! CHECK:     %[[V_32:[0-9]+]] = fir.load %arg0 : !fir.ref<i64>
+  ! CHECK:     %[[V_33:[0-9]+]] = fir.call @_FortranAioOutputInteger64(%[[V_31]], %[[V_32]]) : (!fir.ref<i8>, i64) -> i1
+  ! CHECK:     %[[V_34:[0-9]+]] = fir.load %[[V_4]] : !fir.ref<!fir.ptr<i64>>
+  ! CHECK:     %[[V_35:[0-9]+]] = fir.load %[[V_34]] : !fir.ptr<i64>
+  ! CHECK:     %[[V_36:[0-9]+]] = fir.call @_FortranAioOutputInteger64(%[[V_31]], %[[V_35]]) : (!fir.ref<i8>, i64) -> i1
+  ! CHECK:     %[[V_37:[0-9]+]] = fir.load %[[V_1]] : !fir.ref<!fir.heap<i64>>
+  ! CHECK:     %[[V_38:[0-9]+]] = fir.load %[[V_37]] : !fir.heap<i64>
+  ! CHECK:     %[[V_39:[0-9]+]] = fir.call @_FortranAioOutputInteger64(%[[V_31]], %[[V_38]]) : (!fir.ref<i8>, i64) -> i1
+  ! CHECK:     %[[V_40:[0-9]+]] = fir.call @_FortranAioEndIoStatement(%[[V_31]]) : (!fir.ref<i8>) -> i32
+  ! CHECK:   } else {
+  ! CHECK:     %[[V_29]] = fir.load %[[V_4]] : !fir.ref<!fir.ptr<i64>>
+  ! CHECK:     %[[V_30:[0-9]+]] = fir.load %[[V_1]] : !fir.ref<!fir.heap<i64>>
+  ! CHECK:     %[[V_31]] = fir.convert %[[V_29]] : (!fir.ptr<i64>) -> i64
+  ! CHECK:     %[[V_32]] = arith.cmpi ne, %[[V_31]], %c0{{.*}}_i64_3 : i64
+  ! CHECK:     fir.if %[[V_32]] {
+  ! CHECK:       %[[V_45:[0-9]+]] = fir.call @_FortranASystemClockCountRate(%c8{{.*}}_i32) : (i32) -> i64
+  ! CHECK:       fir.store %[[V_45]] to %[[V_29]] : !fir.ptr<i64>
+  ! CHECK:     }
+  ! CHECK:     %[[V_33]] = fir.convert %[[V_30]] : (!fir.heap<i64>) -> i64
+  ! CHECK:     %[[V_34]] = arith.cmpi ne, %[[V_33]], %c0{{.*}}_i64_4 : i64
+  ! CHECK:     fir.if %[[V_34]] {
+  ! CHECK:       %[[V_45]] = fir.call @_FortranASystemClockCountMax(%c8{{.*}}_i32) : (i32) -> i64
+  ! CHECK:       fir.store %[[V_45]] to %[[V_30]] : !fir.heap<i64>
+  ! CHECK:     }
+  ! CHECK:     %[[V_37]] = fir.call @_FortranAioBeginExternalListOutput
+  ! CHECK:     %[[V_38]] = fir.load %[[V_4]] : !fir.ref<!fir.ptr<i64>>
+  ! CHECK:     %[[V_39]] = fir.load %[[V_38]] : !fir.ptr<i64>
+  ! CHECK:     %[[V_40]] = fir.call @_FortranAioOutputInteger64(%[[V_37]], %[[V_39]]) : (!fir.ref<i8>, i64) -> i1
+  ! CHECK:     %[[V_41:[0-9]+]] = fir.load %[[V_1]] : !fir.ref<!fir.heap<i64>>
+  ! CHECK:     %[[V_42:[0-9]+]] = fir.load %[[V_41]] : !fir.heap<i64>
+  ! CHECK:     %[[V_43:[0-9]+]] = fir.call @_FortranAioOutputInteger64(%[[V_37]], %[[V_42]]) : (!fir.ref<i8>, i64) -> i1
+  ! CHECK:     %[[V_44:[0-9]+]] = fir.call @_FortranAioEndIoStatement(%[[V_37]]) : (!fir.ref<i8>) -> i32
+  ! CHECK:   }
+  ! CHECK:   %[[V_17:[0-9]+]] = fir.is_present %arg0 : (!fir.ref<i64>) -> i1
+  ! CHECK:   fir.if %[[V_17]] {
+  ! CHECK:     %[[V_29]] = fir.convert %c0{{.*}}_i32 : (i32) -> i64
+  ! CHECK:     fir.store %[[V_29]] to %arg0 : !fir.ref<i64>
+  ! CHECK:   } else {
+  ! CHECK:   }
+  ! CHECK:   %[[V_18:[0-9]+]] = fir.zero_bits !fir.ptr<i64>
+  ! CHECK:   fir.store %[[V_18]] to %[[V_4]] : !fir.ref<!fir.ptr<i64>>
+  ! CHECK:   %[[V_19:[0-9]+]] = fir.load %[[V_1]] : !fir.ref<!fir.heap<i64>>
+  ! CHECK:   fir.freemem %[[V_19]] : !fir.heap<i64>
+  ! CHECK:   %[[V_20:[0-9]+]] = fir.zero_bits !fir.heap<i64>
+  ! CHECK:   fir.store %[[V_20]] to %[[V_1]] : !fir.ref<!fir.heap<i64>>
+  ! CHECK:   %[[V_21:[0-9]+]] = fir.load %[[V_4]] : !fir.ref<!fir.ptr<i64>>
+  ! CHECK:   %[[V_22:[0-9]+]] = fir.load %[[V_1]] : !fir.ref<!fir.heap<i64>>
+  ! CHECK:   %[[V_23:[0-9]+]] = fir.is_present %arg0 : (!fir.ref<i64>) -> i1
+  ! CHECK:   fir.if %[[V_23]] {
+  ! CHECK:     %[[V_29]] = fir.call @_FortranASystemClockCount(%c8{{.*}}_i32) : (i32) -> i64
+  ! CHECK:     fir.store %[[V_29]] to %arg0 : !fir.ref<i64>
+  ! CHECK:   }
+  ! CHECK:   %[[V_24:[0-9]+]] = fir.convert %[[V_21]] : (!fir.ptr<i64>) -> i64
+  ! CHECK:   %[[V_25:[0-9]+]] = arith.cmpi ne, %[[V_24]], %c0{{.*}}_i64_1 : i64
+  ! CHECK:   fir.if %[[V_25]] {
+  ! CHECK:     %[[V_29]] = fir.call @_FortranASystemClockCountRate(%c8{{.*}}_i32) : (i32) -> i64
+  ! CHECK:     fir.store %[[V_29]] to %[[V_21]] : !fir.ptr<i64>
+  ! CHECK:   }
+  ! CHECK:   %[[V_26:[0-9]+]] = fir.convert %[[V_22]] : (!fir.heap<i64>) -> i64
+  ! CHECK:   %[[V_27:[0-9]+]] = arith.cmpi ne, %[[V_26]], %c0{{.*}}_i64_2 : i64
+  ! CHECK:   fir.if %[[V_27]] {
+  ! CHECK:     %[[V_29]] = fir.call @_FortranASystemClockCountMax(%c8{{.*}}_i32) : (i32) -> i64
+  ! CHECK:     fir.store %[[V_29]] to %[[V_22]] : !fir.heap<i64>
+  ! CHECK:   }
+  ! CHECK:   %[[V_28:[0-9]+]] = fir.is_present %arg0 : (!fir.ref<i64>) -> i1
+  ! CHECK:   fir.if %[[V_28]] {
+  ! CHECK:     %[[V_31]] = fir.call @_FortranAioBeginExternalListOutput
+  ! CHECK:     %[[V_32]] = fir.load %arg0 : !fir.ref<i64>
+  ! CHECK:     %[[V_33]] = fir.call @_FortranAioOutputInteger64(%[[V_31]], %[[V_32]]) : (!fir.ref<i8>, i64) -> i1
+  ! CHECK:     %[[V_34]] = fir.call @_FortranAioEndIoStatement(%[[V_31]]) : (!fir.ref<i8>) -> i32
+  ! CHECK:   } else {
+  ! CHECK:   }
+  ! CHECK:   return
+  ! CHECK: }
+
+  integer(8), optional :: count
+  integer(8), target :: count_rate_
+  integer(8), pointer :: count_rate
+  integer(8), allocatable :: count_max
+
+  count_rate => count_rate_
+  allocate(count_max)
+  call system_clock(count, count_rate, count_max)
+  if (present(count)) then
+    print*, count, count_rate, count_max
+  else
+    call system_clock(count_rate=count_rate, count_max=count_max)
+    print*, count_rate, count_max
+  endif
+
+  if (present(count)) count = 0
+  count_rate => null()
+  deallocate(count_max)
+  call system_clock(count, count_rate, count_max)
+  if (present(count)) print*, count
+end

flang/unittests/Optimizer/Builder/FIRBuilderTest.cpp

TEST_F(FIRBuilderTest, genIfWithThenAndElse) {
   EXPECT_FALSE(ifBuilder.getIfOp().getThenRegion().empty());
   EXPECT_FALSE(ifBuilder.getIfOp().getElseRegion().empty());
 }
 
 //===----------------------------------------------------------------------===//
 // Helper functions tests
 //===----------------------------------------------------------------------===//
 
-TEST_F(FIRBuilderTest, genIsNotNull) {
+TEST_F(FIRBuilderTest, genIsNotNullAddr) {
   auto builder = getBuilder();
   auto loc = builder.getUnknownLoc();
   auto dummyValue =
       builder.createIntegerConstant(loc, builder.getIndexType(), 0);
-  auto res = builder.genIsNotNull(loc, dummyValue);
+  auto res = builder.genIsNotNullAddr(loc, dummyValue);
   EXPECT_TRUE(mlir::isa<arith::CmpIOp>(res.getDefiningOp()));
   auto cmpOp = dyn_cast<arith::CmpIOp>(res.getDefiningOp());
   EXPECT_EQ(arith::CmpIPredicate::ne, cmpOp.getPredicate());
 }
 
-TEST_F(FIRBuilderTest, genIsNull) {
+TEST_F(FIRBuilderTest, genIsNullAddr) {
   auto builder = getBuilder();
   auto loc = builder.getUnknownLoc();
   auto dummyValue =
       builder.createIntegerConstant(loc, builder.getIndexType(), 0);
-  auto res = builder.genIsNull(loc, dummyValue);
+  auto res = builder.genIsNullAddr(loc, dummyValue);
   EXPECT_TRUE(mlir::isa<arith::CmpIOp>(res.getDefiningOp()));
   auto cmpOp = dyn_cast<arith::CmpIOp>(res.getDefiningOp());
   EXPECT_EQ(arith::CmpIPredicate::eq, cmpOp.getPredicate());
 }
 
 TEST_F(FIRBuilderTest, createZeroConstant) {
   auto builder = getBuilder();
   auto loc = builder.getUnknownLoc();