[flang] Noncontiguous formats

[vdonaldson]

Summary

Add the remaining pieces to support IO for noncontigous formats.
This is done by passing an array descriptor to IO calls. Scalar
formats continue to pass string and length arguments. IO calls
with formats are modified to place the new format descriptor
argument directly after the original string and length arguments.

[vdonaldson]

https://reviews.llvm.org/D132587

flang/include/flang/Runtime/io-api.h

 // requires a descriptor, which is copied.
 Cookie IONAME(BeginInternalArrayListOutput)(const Descriptor &,
     void **scratchArea = nullptr, std::size_t scratchBytes = 0,
     const char *sourceFile = nullptr, int sourceLine = 0);
 Cookie IONAME(BeginInternalArrayListInput)(const Descriptor &,
     void **scratchArea = nullptr, std::size_t scratchBytes = 0,
     const char *sourceFile = nullptr, int sourceLine = 0);
 Cookie IONAME(BeginInternalArrayFormattedOutput)(const Descriptor &,
-    const char *format, std::size_t formatLength, void **scratchArea = nullptr,
+    const char *format, std::size_t formatLength,
+    const Descriptor *formatDescriptor = nullptr, void **scratchArea = nullptr,
     std::size_t scratchBytes = 0, const char *sourceFile = nullptr,
-    int sourceLine = 0, const Descriptor *formatDescriptor = nullptr);
+    int sourceLine = 0);
 Cookie IONAME(BeginInternalArrayFormattedInput)(const Descriptor &,
-    const char *format, std::size_t formatLength, void **scratchArea = nullptr,
+    const char *format, std::size_t formatLength,
+    const Descriptor *formatDescriptor = nullptr, void **scratchArea = nullptr,
     std::size_t scratchBytes = 0, const char *sourceFile = nullptr,
-    int sourceLine = 0, const Descriptor *formatDescriptor = nullptr);
+    int sourceLine = 0);
 
 // Internal I/O to/from a default-kind character scalar can avoid a
 // descriptor.
 Cookie IONAME(BeginInternalListOutput)(char *internal,
     std::size_t internalLength, void **scratchArea = nullptr,
     std::size_t scratchBytes = 0, const char *sourceFile = nullptr,
     int sourceLine = 0);
 Cookie IONAME(BeginInternalListInput)(const char *internal,
     std::size_t internalLength, void **scratchArea = nullptr,
     std::size_t scratchBytes = 0, const char *sourceFile = nullptr,
     int sourceLine = 0);
 Cookie IONAME(BeginInternalFormattedOutput)(char *internal,
     std::size_t internalLength, const char *format, std::size_t formatLength,
-    void **scratchArea = nullptr, std::size_t scratchBytes = 0,
-    const char *sourceFile = nullptr, int sourceLine = 0,
-    const Descriptor *formatDescriptor = nullptr);
+    const Descriptor *formatDescriptor = nullptr, void **scratchArea = nullptr,
+    std::size_t scratchBytes = 0, const char *sourceFile = nullptr,
+    int sourceLine = 0);
 Cookie IONAME(BeginInternalFormattedInput)(const char *internal,
     std::size_t internalLength, const char *format, std::size_t formatLength,
-    void **scratchArea = nullptr, std::size_t scratchBytes = 0,
-    const char *sourceFile = nullptr, int sourceLine = 0,
-    const Descriptor *formatDescriptor = nullptr);
+    const Descriptor *formatDescriptor = nullptr, void **scratchArea = nullptr,
+    std::size_t scratchBytes = 0, const char *sourceFile = nullptr,
+    int sourceLine = 0);
 
 // External unit numbers must fit in default integers. When the integer
 // provided as UNIT is of a wider type than the default integer, it could
 // overflow when converted to a default integer.
 // CheckUnitNumberInRange should be called to verify that a unit number of a
 // wide integer type can fit in a default integer. Since it should be called
 // before the BeginXXX(unit, ...) call, it has its own error handling interface.
 // If handleError is false, and the unit number is out of range, the program
 // will be terminated. Otherwise, if unit is out of range, a nonzero Iostat
 // code is returned and ioMsg is set if it is not a nullptr.
 enum Iostat IONAME(CheckUnitNumberInRange64)(std::int64_t unit,
     bool handleError, char *ioMsg = nullptr, std::size_t ioMsgLength = 0,
     const char *sourceFile = nullptr, int sourceLine = 0);
 enum Iostat IONAME(CheckUnitNumberInRange128)(common::int128_t unit,
     bool handleError, char *ioMsg = nullptr, std::size_t ioMsgLength = 0,
     const char *sourceFile = nullptr, int sourceLine = 0);
 
 // External synchronous I/O initiation
 Cookie IONAME(BeginExternalListOutput)(ExternalUnit = DefaultUnit,
     const char *sourceFile = nullptr, int sourceLine = 0);
 Cookie IONAME(BeginExternalListInput)(ExternalUnit = DefaultUnit,
     const char *sourceFile = nullptr, int sourceLine = 0);
 Cookie IONAME(BeginExternalFormattedOutput)(const char *format, std::size_t,
-    ExternalUnit = DefaultUnit, const char *sourceFile = nullptr,
-    int sourceLine = 0, const Descriptor *formatDescriptor = nullptr);
+    const Descriptor *formatDescriptor = nullptr, ExternalUnit = DefaultUnit,
+    const char *sourceFile = nullptr, int sourceLine = 0);
 Cookie IONAME(BeginExternalFormattedInput)(const char *format, std::size_t,
-    ExternalUnit = DefaultUnit, const char *sourceFile = nullptr,
-    int sourceLine = 0, const Descriptor *formatDescriptor = nullptr);
+    const Descriptor *formatDescriptor = nullptr, ExternalUnit = DefaultUnit,
+    const char *sourceFile = nullptr, int sourceLine = 0);
 Cookie IONAME(BeginUnformattedOutput)(ExternalUnit = DefaultUnit,
     const char *sourceFile = nullptr, int sourceLine = 0);
 Cookie IONAME(BeginUnformattedInput)(ExternalUnit = DefaultUnit,
     const char *sourceFile = nullptr, int sourceLine = 0);
 
 // WAIT(ID=)
 Cookie IONAME(BeginWait)(ExternalUnit, AsynchronousId,
     const char *sourceFile = nullptr, int sourceLine = 0);

flang/lib/Lower/IO.cpp

if (const auto *label = std::get_if<Fortran::parser::Label>(&format.u)) {
     assert(eval && "FORMAT not found in PROCEDURE");
     return lowerSourceTextAsStringLit(
         converter, loc, toStringRef(eval->position), strTy, lenTy);
   }
   const auto *pExpr = std::get_if<Fortran::parser::Expr>(&format.u);
   assert(pExpr && "missing format expression");
   auto e = Fortran::semantics::GetExpr(*pExpr);
   if (Fortran::semantics::ExprHasTypeCategory(
-          *e, Fortran::common::TypeCategory::Character))
+          *e, Fortran::common::TypeCategory::Character)) {
     // character expression
+    if (e->Rank())
+      // Array: return address(descriptor) and no length (and no kind value).
+      return {fir::getBase(converter.genExprBox(loc, *e, stmtCtx)),
+              mlir::Value{}, mlir::Value{}};
+    // Scalar: return address(format) and format length (and no kind value).
     return lowerStringLit(converter, loc, stmtCtx, *pExpr, strTy, lenTy);
+  }
 
   if (Fortran::semantics::ExprHasTypeCategory(
           *e, Fortran::common::TypeCategory::Integer) &&
       e->Rank() == 0 && Fortran::evaluate::UnwrapWholeSymbolDataRef(*e)) {
     // Treat as a scalar integer variable containing an ASSIGN label.
     return lowerReferenceAsStringSelect(converter, loc, *e, strTy, lenTy,
                                         stmtCtx);
   }
void genBeginDataTransferCallArgs(
     bool isListOrNml, [[maybe_unused]] bool isInternal,
     [[maybe_unused]] bool isAsync,
     const llvm::Optional<fir::ExtendedValue> &descRef, ConditionSpecInfo &csi,
     Fortran::lower::StatementContext &stmtCtx) {
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   auto maybeGetFormatArgs = [&]() {
     if (!isFormatted || isListOrNml)
       return;
-    auto pair =
+    std::tuple triple =
         getFormat(converter, loc, stmt, ioFuncTy.getInput(ioArgs.size()),
                   ioFuncTy.getInput(ioArgs.size() + 1), stmtCtx);
-    ioArgs.push_back(std::get<0>(pair)); // format character string
-    ioArgs.push_back(std::get<1>(pair)); // format length
+    mlir::Value address = std::get<0>(triple);
+    mlir::Value length = std::get<1>(triple);
+    if (length) {
+      // Scalar format: string arg + length arg; no format descriptor arg
+      ioArgs.push_back(address); // format string
+      ioArgs.push_back(length);  // format length
+      ioArgs.push_back(
+          builder.createNullConstant(loc, ioFuncTy.getInput(ioArgs.size())));
+      return;
+    }
+    // Array format: no string arg, no length arg; format descriptor arg
+    ioArgs.push_back(
+        builder.createNullConstant(loc, ioFuncTy.getInput(ioArgs.size())));
+    ioArgs.push_back(
+        builder.createNullConstant(loc, ioFuncTy.getInput(ioArgs.size())));
+    ioArgs.push_back( // format descriptor
+        builder.createConvert(loc, ioFuncTy.getInput(ioArgs.size()), address));
   };
   if constexpr (hasIOCtrl) { // READ or WRITE
     if (isInternal) {
       // descriptor or scalar variable; maybe explicit format; scratch area
       if (descRef) {
         mlir::Value desc = builder.createBox(loc, *descRef);
         ioArgs.push_back(
             builder.createConvert(loc, ioFuncTy.getInput(ioArgs.size()), desc));
if (isInternal) {
                                  stmtCtx));
     }
   } else { // PRINT - maybe explicit format; default unit
     maybeGetFormatArgs();
     ioArgs.push_back(builder.create<mlir::arith::ConstantOp>(
         loc, builder.getIntegerAttr(ioFuncTy.getInput(ioArgs.size()),
                                     Fortran::runtime::io::DefaultUnit)));
   }
-  // File name and line number.
+  // File name and line number are always the last two arguments.
   ioArgs.push_back(
       locToFilename(converter, loc, ioFuncTy.getInput(ioArgs.size())));
   ioArgs.push_back(
       locToLineNo(converter, loc, ioFuncTy.getInput(ioArgs.size())));
-  // Placeholder for format passed as a descriptor.
-  if (isFormatted && !isListOrNml)
-    ioArgs.push_back(
-        builder.createNullConstant(loc, ioFuncTy.getInput(ioArgs.size())));
 }
 
 template <bool isInput, bool hasIOCtrl = true, typename A>
 static mlir::Value
 genDataTransferStmt(Fortran::lower::AbstractConverter &converter,
                     const A &stmt) {
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   Fortran::lower::StatementContext stmtCtx;

flang/runtime/format-implementation.h

 FormatControl<CONTEXT>::FormatControl(const Terminator &terminator,
     const CharType *format, std::size_t formatLength,
     const Descriptor *formatDescriptor, int maxHeight)
     : maxHeight_{static_cast<std::uint8_t>(maxHeight)}, format_{format},
       formatLength_{static_cast<int>(formatLength)} {
   RUNTIME_CHECK(terminator, maxHeight == maxHeight_);
   if (!format && formatDescriptor) {
     // The format is a character array passed via a descriptor.
-    formatLength = formatDescriptor->SizeInBytes() / sizeof(CharType);
+    std::size_t elements{formatDescriptor->Elements()};
+    std::size_t elementBytes{formatDescriptor->ElementBytes()};
+    formatLength = elements * elementBytes / sizeof(CharType);
     formatLength_ = static_cast<int>(formatLength);
     if (formatDescriptor->IsContiguous()) {
       // Treat the contiguous array as a single character value.
-      format = const_cast<const CharType *>(
+      format_ = const_cast<const CharType *>(
           reinterpret_cast<CharType *>(formatDescriptor->raw().base_addr));
     } else {
       // Concatenate its elements into a temporary array.
       char *p{reinterpret_cast<char *>(
           AllocateMemoryOrCrash(terminator, formatLength * sizeof(CharType)))};
-      format = p;
+      format_ = p;
       SubscriptValue at[maxRank];
       formatDescriptor->GetLowerBounds(at);
-      auto elementBytes{formatDescriptor->ElementBytes()};
-      for (std::size_t j{0}; j < formatLength; ++j) {
+      for (std::size_t j{0}; j < elements; ++j) {
         std::memcpy(p, formatDescriptor->Element<char>(at), elementBytes);
         p += elementBytes;
         formatDescriptor->IncrementSubscripts(at);
       }
       freeFormat_ = true;
     }
   }
   RUNTIME_CHECK(

flang/runtime/io-api.cpp

Cookie IONAME(BeginInternalArrayListInput)(const Descriptor &descriptor,
     void **scratchArea, std::size_t scratchBytes, const char *sourceFile,
     int sourceLine) {
   return BeginInternalArrayListIO<Direction::Input>(
       descriptor, scratchArea, scratchBytes, sourceFile, sourceLine);
 }
 
 template <Direction DIR>
 Cookie BeginInternalArrayFormattedIO(const Descriptor &descriptor,
-    const char *format, std::size_t formatLength, void ** /*scratchArea*/,
-    std::size_t /*scratchBytes*/, const char *sourceFile, int sourceLine,
-    const Descriptor *formatDescriptor) {
+    const char *format, std::size_t formatLength,
+    const Descriptor *formatDescriptor, void ** /*scratchArea*/,
+    std::size_t /*scratchBytes*/, const char *sourceFile, int sourceLine) {
   Terminator oom{sourceFile, sourceLine};
   return &New<InternalFormattedIoStatementState<DIR>>{oom}(descriptor, format,
-      formatLength, sourceFile, sourceLine, formatDescriptor)
+      formatLength, formatDescriptor, sourceFile, sourceLine)
               .release()
               ->ioStatementState();
 }
 
 Cookie IONAME(BeginInternalArrayFormattedOutput)(const Descriptor &descriptor,
-    const char *format, std::size_t formatLength, void **scratchArea,
-    std::size_t scratchBytes, const char *sourceFile, int sourceLine,
-    const Descriptor *formatDescriptor) {
+    const char *format, std::size_t formatLength,
+    const Descriptor *formatDescriptor, void **scratchArea,
+    std::size_t scratchBytes, const char *sourceFile, int sourceLine) {
   return BeginInternalArrayFormattedIO<Direction::Output>(descriptor, format,
-      formatLength, scratchArea, scratchBytes, sourceFile, sourceLine,
-      formatDescriptor);
+      formatLength, formatDescriptor, scratchArea, scratchBytes, sourceFile,
+      sourceLine);
 }
 
 Cookie IONAME(BeginInternalArrayFormattedInput)(const Descriptor &descriptor,
-    const char *format, std::size_t formatLength, void **scratchArea,
-    std::size_t scratchBytes, const char *sourceFile, int sourceLine,
-    const Descriptor *formatDescriptor) {
+    const char *format, std::size_t formatLength,
+    const Descriptor *formatDescriptor, void **scratchArea,
+    std::size_t scratchBytes, const char *sourceFile, int sourceLine) {
   return BeginInternalArrayFormattedIO<Direction::Input>(descriptor, format,
-      formatLength, scratchArea, scratchBytes, sourceFile, sourceLine,
-      formatDescriptor);
+      formatLength, formatDescriptor, scratchArea, scratchBytes, sourceFile,
+      sourceLine);
 }
 
 template <Direction DIR>
 Cookie BeginInternalListIO(
     std::conditional_t<DIR == Direction::Input, const char, char> *internal,
     std::size_t internalLength, void ** /*scratchArea*/,
     std::size_t /*scratchBytes*/, const char *sourceFile, int sourceLine) {
   Terminator oom{sourceFile, sourceLine};
Cookie IONAME(BeginInternalListInput)(const char *internal,
   return BeginInternalListIO<Direction::Input>(internal, internalLength,
       scratchArea, scratchBytes, sourceFile, sourceLine);
 }
 
 template <Direction DIR>
 Cookie BeginInternalFormattedIO(
     std::conditional_t<DIR == Direction::Input, const char, char> *internal,
     std::size_t internalLength, const char *format, std::size_t formatLength,
-    void ** /*scratchArea*/, std::size_t /*scratchBytes*/,
-    const char *sourceFile, int sourceLine,
-    const Descriptor *formatDescriptor) {
+    const Descriptor *formatDescriptor, void ** /*scratchArea*/,
+    std::size_t /*scratchBytes*/, const char *sourceFile, int sourceLine) {
   Terminator oom{sourceFile, sourceLine};
   return &New<InternalFormattedIoStatementState<DIR>>{oom}(internal,
-      internalLength, format, formatLength, sourceFile, sourceLine,
-      formatDescriptor)
+      internalLength, format, formatLength, formatDescriptor, sourceFile,
+      sourceLine)
               .release()
               ->ioStatementState();
 }
 
 Cookie IONAME(BeginInternalFormattedOutput)(char *internal,
     std::size_t internalLength, const char *format, std::size_t formatLength,
-    void **scratchArea, std::size_t scratchBytes, const char *sourceFile,
-    int sourceLine, const Descriptor *formatDescriptor) {
+    const Descriptor *formatDescriptor, void **scratchArea,
+    std::size_t scratchBytes, const char *sourceFile, int sourceLine) {
   return BeginInternalFormattedIO<Direction::Output>(internal, internalLength,
-      format, formatLength, scratchArea, scratchBytes, sourceFile, sourceLine,
-      formatDescriptor);
+      format, formatLength, formatDescriptor, scratchArea, scratchBytes,
+      sourceFile, sourceLine);
 }
 
 Cookie IONAME(BeginInternalFormattedInput)(const char *internal,
     std::size_t internalLength, const char *format, std::size_t formatLength,
-    void **scratchArea, std::size_t scratchBytes, const char *sourceFile,
-    int sourceLine, const Descriptor *formatDescriptor) {
+    const Descriptor *formatDescriptor, void **scratchArea,
+    std::size_t scratchBytes, const char *sourceFile, int sourceLine) {
   return BeginInternalFormattedIO<Direction::Input>(internal, internalLength,
-      format, formatLength, scratchArea, scratchBytes, sourceFile, sourceLine,
-      formatDescriptor);
+      format, formatLength, formatDescriptor, scratchArea, scratchBytes,
+      sourceFile, sourceLine);
 }
 
 static Cookie NoopUnit(const Terminator &terminator, int unitNumber,
     enum Iostat iostat = IostatOk) {
   Cookie cookie{&New<NoopStatementState>{terminator}(
       terminator.sourceFileName(), terminator.sourceLine(), unitNumber)
                      .release()
                      ->ioStatementState()};

 Cookie IONAME(BeginExternalListInput)(
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   return BeginExternalListIO<Direction::Input, ExternalListIoStatementState>(
       unitNumber, sourceFile, sourceLine);
 }
 
 template <Direction DIR>
 Cookie BeginExternalFormattedIO(const char *format, std::size_t formatLength,
-    ExternalUnit unitNumber, const char *sourceFile, int sourceLine,
-    const Descriptor *formatDescriptor) {
+    const Descriptor *formatDescriptor, ExternalUnit unitNumber,
+    const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
   if (unitNumber == DefaultUnit) {
     unitNumber = DIR == Direction::Input ? 5 : 6;
   }
   Cookie errorCookie{nullptr};
   ExternalFileUnit *unit{GetOrCreateUnit(
       unitNumber, DIR, false /*!unformatted*/, terminator, errorCookie)};
   if (!unit) {
     return errorCookie;
   }
   Iostat iostat{IostatOk};
   if (!unit->isUnformatted.has_value()) {
     unit->isUnformatted = false;
   }
   if (*unit->isUnformatted) {
     iostat = IostatFormattedIoOnUnformattedUnit;
   }
   if (ChildIo * child{unit->GetChildIo()}) {
     if (iostat == IostatOk) {
       iostat = child->CheckFormattingAndDirection(false, DIR);
     }
     if (iostat == IostatOk) {
       return &child->BeginIoStatement<ChildFormattedIoStatementState<DIR>>(
-          *child, format, formatLength, sourceFile, sourceLine,
-          formatDescriptor);
+          *child, format, formatLength, formatDescriptor, sourceFile,
+          sourceLine);
     } else {
       return &child->BeginIoStatement<ErroneousIoStatementState>(
           iostat, nullptr /* no unit */, sourceFile, sourceLine);
     }
   } else {
     if (iostat == IostatOk) {
       iostat = unit->SetDirection(DIR);
     }
     if (iostat == IostatOk) {
       return &unit->BeginIoStatement<ExternalFormattedIoStatementState<DIR>>(
-          terminator, *unit, format, formatLength, sourceFile, sourceLine,
-          formatDescriptor);
+          terminator, *unit, format, formatLength, formatDescriptor, sourceFile,
+          sourceLine);
     } else {
       return &unit->BeginIoStatement<ErroneousIoStatementState>(
           terminator, iostat, unit, sourceFile, sourceLine);
     }
   }
 }
 
 Cookie IONAME(BeginExternalFormattedOutput)(const char *format,
-    std::size_t formatLength, ExternalUnit unitNumber, const char *sourceFile,
-    int sourceLine, const Descriptor *formatDescriptor) {
+    std::size_t formatLength, const Descriptor *formatDescriptor,
+    ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   return BeginExternalFormattedIO<Direction::Output>(format, formatLength,
-      unitNumber, sourceFile, sourceLine, formatDescriptor);
+      formatDescriptor, unitNumber, sourceFile, sourceLine);
 }
 
 Cookie IONAME(BeginExternalFormattedInput)(const char *format,
-    std::size_t formatLength, ExternalUnit unitNumber, const char *sourceFile,
-    int sourceLine, const Descriptor *formatDescriptor) {
+    std::size_t formatLength, const Descriptor *formatDescriptor,
+    ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   return BeginExternalFormattedIO<Direction::Input>(format, formatLength,
-      unitNumber, sourceFile, sourceLine, formatDescriptor);
+      formatDescriptor, unitNumber, sourceFile, sourceLine);
 }
 
 template <Direction DIR>
 Cookie BeginUnformattedIO(
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
   Cookie errorCookie{nullptr};
   ExternalFileUnit *unit{GetOrCreateUnit(

flang/runtime/io-stmt.h

 class InternalFormattedIoStatementState
     : public InternalIoStatementState<DIR>,
       public FormattedIoStatementState<DIR> {
 public:
   using CharType = CHAR;
   using typename InternalIoStatementState<DIR>::Buffer;
   InternalFormattedIoStatementState(Buffer internal, std::size_t internalLength,
       const CharType *format, std::size_t formatLength,
-      const char *sourceFile = nullptr, int sourceLine = 0,
-      const Descriptor *formatDescriptor = nullptr);
+      const Descriptor *formatDescriptor = nullptr,
+      const char *sourceFile = nullptr, int sourceLine = 0);
   InternalFormattedIoStatementState(const Descriptor &, const CharType *format,
-      std::size_t formatLength, const char *sourceFile = nullptr,
-      int sourceLine = 0, const Descriptor *formatDescriptor = nullptr);
+      std::size_t formatLength, const Descriptor *formatDescriptor = nullptr,
+      const char *sourceFile = nullptr, int sourceLine = 0);
   IoStatementState &ioStatementState() { return ioStatementState_; }
   void CompleteOperation();
   int EndIoStatement();
   std::optional<DataEdit> GetNextDataEdit(
       IoStatementState &, int maxRepeat = 1) {
     return format_.GetNextDataEdit(*this, maxRepeat);
   }
 

 
 template <Direction DIR, typename CHAR>
 class ExternalFormattedIoStatementState
     : public ExternalIoStatementState<DIR>,
       public FormattedIoStatementState<DIR> {
 public:
   using CharType = CHAR;
   ExternalFormattedIoStatementState(ExternalFileUnit &, const CharType *format,
-      std::size_t formatLength, const char *sourceFile = nullptr,
-      int sourceLine = 0, const Descriptor *formatDescriptor = nullptr);
+      std::size_t formatLength, const Descriptor *formatDescriptor = nullptr,
+      const char *sourceFile = nullptr, int sourceLine = 0);
   void CompleteOperation();
   int EndIoStatement();
   std::optional<DataEdit> GetNextDataEdit(
       IoStatementState &, int maxRepeat = 1) {
     return format_.GetNextDataEdit(*this, maxRepeat);
   }
 
 private:

 };
 
 template <Direction DIR, typename CHAR>
 class ChildFormattedIoStatementState : public ChildIoStatementState<DIR>,
                                        public FormattedIoStatementState<DIR> {
 public:
   using CharType = CHAR;
   ChildFormattedIoStatementState(ChildIo &, const CharType *format,
-      std::size_t formatLength, const char *sourceFile = nullptr,
-      int sourceLine = 0, const Descriptor *formatDescriptor = nullptr);
+      std::size_t formatLength, const Descriptor *formatDescriptor = nullptr,
+      const char *sourceFile = nullptr, int sourceLine = 0);
   MutableModes &mutableModes() { return mutableModes_; }
   void CompleteOperation();
   int EndIoStatement();
   bool AdvanceRecord(int = 1);
   std::optional<DataEdit> GetNextDataEdit(
       IoStatementState &, int maxRepeat = 1) {
     return format_.GetNextDataEdit(*this, maxRepeat);
   }

flang/runtime/io-stmt.cpp

 template <Direction DIR>
 void InternalIoStatementState<DIR>::HandleRelativePosition(std::int64_t n) {
   return unit_.HandleRelativePosition(n);
 }
 
 template <Direction DIR, typename CHAR>
 InternalFormattedIoStatementState<DIR, CHAR>::InternalFormattedIoStatementState(
     Buffer buffer, std::size_t length, const CharType *format,
-    std::size_t formatLength, const char *sourceFile, int sourceLine,
-    const Descriptor *formatDescriptor)
+    std::size_t formatLength, const Descriptor *formatDescriptor,
+    const char *sourceFile, int sourceLine)
     : InternalIoStatementState<DIR>{buffer, length, sourceFile, sourceLine},
       ioStatementState_{*this}, format_{*this, format, formatLength,
                                     formatDescriptor} {}
 
 template <Direction DIR, typename CHAR>
 InternalFormattedIoStatementState<DIR, CHAR>::InternalFormattedIoStatementState(
     const Descriptor &d, const CharType *format, std::size_t formatLength,
-    const char *sourceFile, int sourceLine, const Descriptor *formatDescriptor)
+    const Descriptor *formatDescriptor, const char *sourceFile, int sourceLine)
     : InternalIoStatementState<DIR>{d, sourceFile, sourceLine},
       ioStatementState_{*this}, format_{*this, format, formatLength,
                                     formatDescriptor} {}
 
 template <Direction DIR, typename CHAR>
 void InternalFormattedIoStatementState<DIR, CHAR>::CompleteOperation() {
   if (!this->completedOperation()) {
     if constexpr (DIR == Direction::Output) {
if constexpr (DIR == Direction::Input) {
     Crash("ExternalIoStatementState<Direction::Output>::FinishReadingRecord() "
           "called");
   }
 }
 
 template <Direction DIR, typename CHAR>
 ExternalFormattedIoStatementState<DIR, CHAR>::ExternalFormattedIoStatementState(
     ExternalFileUnit &unit, const CHAR *format, std::size_t formatLength,
-    const char *sourceFile, int sourceLine, const Descriptor *formatDescriptor)
+    const Descriptor *formatDescriptor, const char *sourceFile, int sourceLine)
     : ExternalIoStatementState<DIR>{unit, sourceFile, sourceLine},
       format_{*this, format, formatLength, formatDescriptor} {}
 
 template <Direction DIR, typename CHAR>
 void ExternalFormattedIoStatementState<DIR, CHAR>::CompleteOperation() {
   if (this->completedOperation()) {
     return;
   }

 template <Direction DIR>
 void ChildIoStatementState<DIR>::HandleRelativePosition(std::int64_t n) {
   return child_.parent().HandleRelativePosition(n);
 }
 
 template <Direction DIR, typename CHAR>
 ChildFormattedIoStatementState<DIR, CHAR>::ChildFormattedIoStatementState(
     ChildIo &child, const CHAR *format, std::size_t formatLength,
-    const char *sourceFile, int sourceLine, const Descriptor *formatDescriptor)
+    const Descriptor *formatDescriptor, const char *sourceFile, int sourceLine)
     : ChildIoStatementState<DIR>{child, sourceFile, sourceLine},
       mutableModes_{child.parent().mutableModes()}, format_{*this, format,
                                                         formatLength,
                                                         formatDescriptor} {}
 
 template <Direction DIR, typename CHAR>
 void ChildFormattedIoStatementState<DIR, CHAR>::CompleteOperation() {
   if (!this->completedOperation()) {

flang/test/Lower/read-write-buffer.f90

 ! RUN: bbc -emit-fir %s -o - | FileCheck %s
 
 ! Test that we are passing the correct length when using character array as
 ! Format (Fortran 2018 12.6.2.2 point 3)
 ! CHECK-LABEL: func @_QPtest_array_format
 subroutine test_array_format
   ! CHECK-DAG: %[[c2:.*]] = arith.constant 2 : index
   ! CHECK-DAG: %[[c10:.*]] = arith.constant 10 : index
   ! CHECK-DAG: %[[mem:.*]] = fir.alloca !fir.array<2x!fir.char<1,10>>
   character(10) :: array(2)
   array(1) ="(15HThis i"
   array(2) ="s a test.)"
-  ! CHECK-DAG: %[[fmtLen:.*]] = arith.muli %[[c10]], %[[c2]] : index
-  ! CHECK-DAG: %[[scalarFmt:.*]] = fir.convert %[[mem]] : (!fir.ref<!fir.array<2x!fir.char<1,10>>>) -> !fir.ref<!fir.char<1,?>>
-  ! CHECK-DAG: %[[fmtArg:.*]] = fir.convert %[[scalarFmt]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
-  ! CHECK-DAG: %[[fmtLenArg:.*]] = fir.convert %[[fmtLen]] : (index) -> i64 
-  ! CHECK: fir.call @_FortranAioBeginExternalFormattedOutput(%[[fmtArg]], %[[fmtLenArg]], {{.*}}) 
+  ! CHECK: %[[shape:.*]] = fir.shape %c2{{.*}} (index) -> !fir.shape<1>
+  ! CHECK: %[[fmtBox:.*]] = fir.embox %[[mem]](%[[shape]]) : (!fir.ref<!fir.array<2x!fir.char<1,10>>>, !fir.shape<1>) -> !fir.box<!fir.array<2x!fir.char<1,10>>>
+  ! CHECK: %[[fmtArg:.*]] = fir.zero_bits !fir.ref<i8>
+  ! CHECK: %[[fmtLenArg:.*]] = fir.zero_bits i64
+  ! CHECK: %[[fmtDesc:.*]] = fir.convert %[[fmtBox]] : (!fir.box<!fir.array<2x!fir.char<1,10>>>) -> !fir.box<none>
+  ! CHECK: fir.call @_FortranAioBeginExternalFormattedOutput(%[[fmtArg]], %[[fmtLenArg]], %[[fmtDesc]], {{.*}}) 
   write(*, array) 
 end subroutine
 
 ! A test to check the buffer and it's length.
 ! CHECK-LABEL: @_QPsome
 subroutine some()
   character(LEN=255):: buffer
   character(LEN=255):: greeting

flang/unittests/Runtime/ExternalIOTest.cpp

TEST(ExternalIOTests, TestDirectFormatted) {
   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
       << "EndIoStatement() for OpenNewUnit";
 
   static constexpr int records{10};
   static const char fmt[]{"(I4)"};
   for (int j{1}; j <= records; ++j) {
     // WRITE(UNIT=unit,FMT=fmt,REC=j) j
     io = IONAME(BeginExternalFormattedOutput)(
-        fmt, sizeof fmt - 1, unit, __FILE__, __LINE__);
+        fmt, sizeof fmt - 1, nullptr, unit, __FILE__, __LINE__);
     ASSERT_TRUE(IONAME(SetRec)(io, j)) << "SetRec(" << j << ')';
     ASSERT_TRUE(IONAME(OutputInteger64)(io, j)) << "OutputInteger64()";
     ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
         << "EndIoStatement() for OutputInteger64";
   }
 
   for (int j{records}; j >= 1; --j) {
     // READ(UNIT=unit,FMT=fmt,REC=j) n
     io = IONAME(BeginExternalFormattedInput)(
-        fmt, sizeof fmt - 1, unit, __FILE__, __LINE__);
+        fmt, sizeof fmt - 1, nullptr, unit, __FILE__, __LINE__);
     ASSERT_TRUE(IONAME(SetRec)(io, j)) << "SetRec(" << j << ')';
     std::int64_t buffer;
     ASSERT_TRUE(IONAME(InputInteger)(io, buffer)) << "InputInteger()";
     ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
         << "EndIoStatement() for InputInteger";
 
     ASSERT_EQ(buffer, j) << "Read back " << buffer
                          << " from direct formatted record " << j
for (int j{0}; j < records; ++j) {
     buffer[j] = j;
   }
 
   char fmt[32];
   for (int j{1}; j <= records; ++j) {
     std::snprintf(fmt, sizeof fmt, "(%dI4)", j);
     // DO J=1,RECORDS; WRITE(UNIT=unit,FMT=fmt) BUFFER(0:j); END DO
     io = IONAME(BeginExternalFormattedOutput)(
-        fmt, std::strlen(fmt), unit, __FILE__, __LINE__);
+        fmt, std::strlen(fmt), nullptr, unit, __FILE__, __LINE__);
     for (int k{0}; k < j; ++k) {
       ASSERT_TRUE(IONAME(OutputInteger64)(io, buffer[k]))
           << "OutputInteger64()";
     }
     ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
         << "EndIoStatement() for OutputInteger64";
   }
 
   // REWIND(UNIT=unit)
   io = IONAME(BeginRewind)(unit, __FILE__, __LINE__);
   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
       << "EndIoStatement() for Rewind";
 
   for (int j{1}; j <= records; ++j) {
     std::snprintf(fmt, sizeof fmt, "(%dI4)", j);
     // DO J=1,RECORDS; READ(UNIT=unit,FMT=fmt) n; check n; END DO
     io = IONAME(BeginExternalFormattedInput)(
-        fmt, std::strlen(fmt), unit, __FILE__, __LINE__);
+        fmt, std::strlen(fmt), nullptr, unit, __FILE__, __LINE__);
 
     std::int64_t check[records];
     for (int k{0}; k < j; ++k) {
       ASSERT_TRUE(IONAME(InputInteger)(io, check[k])) << "InputInteger()";
     }
     ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
         << "EndIoStatement() for InputInteger";
 
for (int j{records}; j >= 1; --j) {
     // BACKSPACE(unit)
     io = IONAME(BeginBackspace)(unit, __FILE__, __LINE__);
     ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
         << "EndIoStatement() for Backspace (before read)";
 
     std::snprintf(fmt, sizeof fmt, "(%dI4)", j);
     // READ(UNIT=unit,FMT=fmt,SIZE=chars) n; check
     io = IONAME(BeginExternalFormattedInput)(
-        fmt, std::strlen(fmt), unit, __FILE__, __LINE__);
+        fmt, std::strlen(fmt), nullptr, unit, __FILE__, __LINE__);
 
     std::int64_t check[records];
     for (int k{0}; k < j; ++k) {
       ASSERT_TRUE(IONAME(InputInteger)(io, check[k])) << "InputInteger()";
     }
 
     std::size_t chars{IONAME(GetSize)(io)};
     ASSERT_EQ(chars, j * 4u)
TEST(ExternalIOTests, TestNonAvancingInput) {
 
   // Write the file to be used for the input test.
   static constexpr std::string_view records[] = {
       "ABCDEFGH", "IJKLMNOP", "QRSTUVWX"};
   static constexpr std::string_view fmt{"(A)"};
   for (const auto &record : records) {
     // WRITE(UNIT=unit,FMT=fmt) record
     io = IONAME(BeginExternalFormattedOutput)(
-        fmt.data(), fmt.length(), unit, __FILE__, __LINE__);
+        fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
     ASSERT_TRUE(IONAME(OutputAscii)(io, record.data(), record.length()))
         << "OutputAscii()";
     ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
         << "EndIoStatement() for OutputAscii";
   }
 
   // REWIND(UNIT=unit)
   io = IONAME(BeginRewind)(unit, __FILE__, __LINE__);
TestItems inputItems[]{
       {std::string(8, '+'), IostatEor, "KLMNOP  "},
       {std::string(10, '+'), IostatEor, "QRSTUVWX  "},
   };
 
   int j{0};
   for (auto &inputItem : inputItems) {
     // READ(UNIT=unit, FMT=fmt, ADVANCE='NO', IOSTAT=iostat) inputItem
     io = IONAME(BeginExternalFormattedInput)(
-        fmt.data(), fmt.length(), unit, __FILE__, __LINE__);
+        fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
     IONAME(EnableHandlers)(io, true, false, false, false, false);
     ASSERT_TRUE(IONAME(SetAdvance)(io, "NO", 2)) << "SetAdvance(NO)" << j;
     bool result{
         IONAME(InputAscii)(io, inputItem.item.data(), inputItem.item.length())};
     ASSERT_EQ(result, inputItem.expectedIoStat == IostatOk)
         << "InputAscii() " << j;
     ASSERT_EQ(IONAME(EndIoStatement)(io), inputItem.expectedIoStat)
         << "EndIoStatement() for Read " << j;
ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
       << "EndIoStatement() for OpenNewUnit";
 
   // Write the file to be used for the input test.
   static constexpr std::string_view records[] = {"ABCDEFGHIJKLMNOPQRST"};
   static constexpr std::string_view fmt{"(A)"};
   for (const auto &record : records) {
     // WRITE(UNIT=unit,FMT=fmt) record
     io = IONAME(BeginExternalFormattedOutput)(
-        fmt.data(), fmt.length(), unit, __FILE__, __LINE__);
+        fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
     ASSERT_TRUE(IONAME(OutputAscii)(io, record.data(), record.length()))
         << "OutputAscii()";
     ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
         << "EndIoStatement() for OutputAscii";
   }
 
   // REWIND(UNIT=unit)
   io = IONAME(BeginRewind)(unit, __FILE__, __LINE__);
TestItems inputItems[]{
       {std::string(4, '+'), IostatOk, "ABCD"},
       {std::string(4, '+'), IostatOk, "EFGH"},
   };
 
   int j{0};
   for (auto &inputItem : inputItems) {
     // READ(UNIT=unit, FMT=fmt, ADVANCE='NO', IOSTAT=iostat) inputItem
     io = IONAME(BeginExternalFormattedInput)(
-        fmt.data(), fmt.length(), unit, __FILE__, __LINE__);
+        fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
     IONAME(EnableHandlers)(io, true, false, false, false, false);
     ASSERT_TRUE(IONAME(SetAdvance)(io, "NO", 2)) << "SetAdvance(NO)" << j;
     ASSERT_TRUE(
         IONAME(InputAscii)(io, inputItem.item.data(), inputItem.item.length()))
         << "InputAscii() " << j;
     ASSERT_EQ(IONAME(EndIoStatement)(io), inputItem.expectedIoStat)
         << "EndIoStatement() for Read " << j;
     ASSERT_EQ(inputItem.item, inputItem.expectedItemValue)
         << "Input-item value after non advancing read " << j;
     j++;
   }
 
   // WRITE(UNIT=unit, FMT=fmt, IOSTAT=iostat) outputItem.
   static constexpr std::string_view outputItem{"XYZ"};
   // WRITE(UNIT=unit,FMT=fmt) record
   io = IONAME(BeginExternalFormattedOutput)(
-      fmt.data(), fmt.length(), unit, __FILE__, __LINE__);
+      fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
   ASSERT_TRUE(IONAME(OutputAscii)(io, outputItem.data(), outputItem.length()))
       << "OutputAscii()";
   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
       << "EndIoStatement() for OutputAscii";
 
   // Verify that the output was written in the record read in non advancing
   // mode, after the read part, and that the end was truncated.
 
   // REWIND(UNIT=unit)
   io = IONAME(BeginRewind)(unit, __FILE__, __LINE__);
   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
       << "EndIoStatement() for Rewind";
 
   std::string resultRecord(20, '+');
   std::string expectedRecord{"ABCDEFGHXYZ         "};
   // READ(UNIT=unit, FMT=fmt, IOSTAT=iostat) result
   io = IONAME(BeginExternalFormattedInput)(
-      fmt.data(), fmt.length(), unit, __FILE__, __LINE__);
+      fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
   IONAME(EnableHandlers)(io, true, false, false, false, false);
   ASSERT_TRUE(
       IONAME(InputAscii)(io, resultRecord.data(), resultRecord.length()))
       << "InputAscii() ";
   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
       << "EndIoStatement() for Read ";
   ASSERT_EQ(resultRecord, expectedRecord)
       << "Record after non advancing read followed by write";
TEST(ExternalIOTests, TestWriteAfterEndfile) {
   ASSERT_TRUE(IONAME(SetStatus)(io, "SCRATCH", 7)) << "SetStatus(SCRATCH)";
   int unit{-1};
   ASSERT_TRUE(IONAME(GetNewUnit)(io, unit)) << "GetNewUnit()";
   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
       << "EndIoStatement() for OpenNewUnit";
   // WRITE(unit,"(I8)") 1234
   static constexpr std::string_view format{"(I8)"};
   io = IONAME(BeginExternalFormattedOutput)(
-      format.data(), format.length(), unit, __FILE__, __LINE__);
+      format.data(), format.length(), nullptr, unit, __FILE__, __LINE__);
   ASSERT_TRUE(IONAME(OutputInteger64)(io, 1234)) << "OutputInteger64()";
   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
       << "EndIoStatement for WRITE before ENDFILE";
   // ENDFILE(unit)
   io = IONAME(BeginEndfile)(unit, __FILE__, __LINE__);
   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
       << "EndIoStatement for ENDFILE";
   // WRITE(unit,"(I8)",iostat=iostat) 5678
   io = IONAME(BeginExternalFormattedOutput)(
-      format.data(), format.length(), unit, __FILE__, __LINE__);
+      format.data(), format.length(), nullptr, unit, __FILE__, __LINE__);
   IONAME(EnableHandlers)(io, true /*IOSTAT=*/);
   ASSERT_FALSE(IONAME(OutputInteger64)(io, 5678)) << "OutputInteger64()";
   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatWriteAfterEndfile)
       << "EndIoStatement for WRITE after ENDFILE";
   // BACKSPACE(unit)
   io = IONAME(BeginBackspace)(unit, __FILE__, __LINE__);
   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
       << "EndIoStatement for BACKSPACE";
   // WRITE(unit,"(I8)") 3456
   io = IONAME(BeginExternalFormattedOutput)(
-      format.data(), format.length(), unit, __FILE__, __LINE__);
+      format.data(), format.length(), nullptr, unit, __FILE__, __LINE__);
   ASSERT_TRUE(IONAME(OutputInteger64)(io, 3456)) << "OutputInteger64()";
   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
       << "EndIoStatement for WRITE after BACKSPACE";
   // REWIND(unit)
   io = IONAME(BeginRewind)(unit, __FILE__, __LINE__);
   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
       << "EndIoStatement for REWIND";
   // READ(unit,"(I8)",END=) j, k
   std::int64_t j{-1}, k{-1}, eof{-1};
   io = IONAME(BeginExternalFormattedInput)(
-      format.data(), format.length(), unit, __FILE__, __LINE__);
+      format.data(), format.length(), nullptr, unit, __FILE__, __LINE__);
   IONAME(EnableHandlers)(io, false, false, true /*END=*/);
   ASSERT_TRUE(IONAME(InputInteger)(io, j)) << "InputInteger(j)";
   ASSERT_EQ(j, 1234) << "READ(j)";
   ASSERT_TRUE(IONAME(InputInteger)(io, k)) << "InputInteger(k)";
   ASSERT_EQ(k, 3456) << "READ(k)";
   ASSERT_FALSE(IONAME(InputInteger)(io, eof)) << "InputInteger(eof)";
   ASSERT_EQ(eof, -1) << "READ(eof)";
   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatEnd) << "EndIoStatement for READ";