[flang] Roll up work on external I/O runtime library

[klausler]

Summary

• Clean up formatted input path
• Add PAUSE, FLUSH, REWIND, ENDFILE, BACKSPACE statements
• Address small bugs and TODOs in I/O runtime
• Add external I/O runtime test
• Fix exposed bugs

[klausler]

Rebased to current llvm-project/master branch.

[PeteSteinfeld]

I assume that this is code that's already been reviewed on GitLab. I've verified that everything builds and tests correctly.

[richard.barton.arm]

Please can this patch be split up into separate patches for each of the separate types changes? Roll-up patches are not good practice and against the developer policy.
@PeteSteinfeld The patches should also be code reviewed for LLVM master. Prior review on some other project is not relevant and should not be given as justification for approving patches to LLVM master.
The clang-tidy linting errors also need fixing up.

Thanks
Rich

[klausler]

In D82695#2119300, @richard.barton.arm wrote:

Please can this patch be split up into separate patches for each of the separate types changes? Roll-up patches are not good practice and against the developer policy.
@PeteSteinfeld The patches should also be code reviewed for LLVM master. Prior review on some other project is not relevant and should not be given as justification for approving patches to LLVM master.
The clang-tidy linting errors also need fixing up.

Thanks

I'm happy to not push this code if you don't want it.

[richard.barton.arm]

In D82695#2120042, @klausler wrote:

In D82695#2119300, @richard.barton.arm wrote:

Please can this patch be split up into separate patches for each of the separate types changes? Roll-up patches are not good practice and against the developer policy.
@PeteSteinfeld The patches should also be code reviewed for LLVM master. Prior review on some other project is not relevant and should not be given as justification for approving patches to LLVM master.
The clang-tidy linting errors also need fixing up.

Thanks

I'm happy to not push this code if you don't want it.

That is not the situation at all. I do very much want the code.

What I am asking for is for the code to be submitted in incremental patches, with each patch addressing a single concern rather than as one big patch. Submitting code in this way helps the quality of the codebase in a number of ways: it makes the changes easier to review; if a particular subset of the whole change causes a regression then it can easily be reverted by itself rather than requiring the whole change to be reverted; the commit messages can be better and it generally makes the commit history easier to understand in the future if single commits do single things - particularly valuable when inspecting regression test provenance.

I would gladly review the code in smaller increments. A good starting point would be one increment per bullet point in your summary.

[klausler]

In D82695#2125841, @richard.barton.arm wrote:

In D82695#2120042, @klausler wrote:

In D82695#2119300, @richard.barton.arm wrote:

Please can this patch be split up into separate patches for each of the separate types changes? Roll-up patches are not good practice and against the developer policy.
@PeteSteinfeld The patches should also be code reviewed for LLVM master. Prior review on some other project is not relevant and should not be given as justification for approving patches to LLVM master.
The clang-tidy linting errors also need fixing up.

Thanks

I'm happy to not push this code if you don't want it.

That is not the situation at all. I do very much want the code.

What I am asking for is for the code to be submitted in incremental patches, with each patch addressing a single concern rather than as one big patch. Submitting code in this way helps the quality of the codebase in a number of ways: it makes the changes easier to review; if a particular subset of the whole change causes a regression then it can easily be reverted by itself rather than requiring the whole change to be reverted; the commit messages can be better and it generally makes the commit history easier to understand in the future if single commits do single things - particularly valuable when inspecting regression test provenance.

I would gladly review the code in smaller increments. A good starting point would be one increment per bullet point in your summary.

I wasted a few days trying to disentangle all of this interlocked work on the external I/O runtime into smaller chunks, but it's a big reworking with many iterations of many provisional function implementations and some data structures. Carving it up isn't hard; carving it up into incremental patches that each continue to build successfully is difficult to do in a way that doesn't look completely artificial. I have many other things to do at the moment, but maybe I'll take another attempt at repackaging this runtime work later this month.

flang/runtime/connection.h

 enum class Access { Sequential, Direct, Stream };
 
 inline bool IsRecordFile(Access a) { return a != Access::Stream; }
 
 // These characteristics of a connection are immutable after being
 // established in an OPEN statement.
 struct ConnectionAttributes {
   Access access{Access::Sequential}; // ACCESS='SEQUENTIAL', 'DIRECT', 'STREAM'
-  std::optional<std::int64_t> recordLength; // RECL= when fixed-length
   bool isUnformatted{false}; // FORM='UNFORMATTED'
   bool isUTF8{false}; // ENCODING='UTF-8'
+  bool isFixedRecordLength{false}; // RECL= on OPEN
+  std::optional<std::int64_t> recordLength; // RECL= or current record
 };
 
 struct ConnectionState : public ConnectionAttributes {
   bool IsAtEOF() const; // true when read has hit EOF or endfile record
   std::size_t RemainingSpaceInRecord() const;
   void HandleAbsolutePosition(std::int64_t);
   void HandleRelativePosition(std::int64_t);
 
+  void BeginRecord() {
+    positionInRecord = 0;
+    furthestPositionInRecord = 0;
+    leftTabLimit.reset();
+  }
+
   // Positions in a record file (sequential or direct, not stream)
   std::int64_t currentRecordNumber{1}; // 1 is first
   std::int64_t positionInRecord{0}; // offset in current record
   std::int64_t furthestPositionInRecord{0}; // max(position+bytes)
   bool nonAdvancing{false}; // ADVANCE='NO'
 
   // Set at end of non-advancing I/O data transfer
   std::optional<std::int64_t> leftTabLimit; // offset in current record

flang/runtime/edit-input.cpp

 //===-- runtime/edit-input.cpp ----------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "edit-input.h"
 #include "flang/Common/real.h"
 #include "flang/Common/uint128.h"
 #include <algorithm>
 
 namespace Fortran::runtime::io {
 
+static std::optional<char32_t> PrepareInput(
+    IoStatementState &io, const DataEdit &edit, std::optional<int> &remaining) {
+  remaining.reset();
+  if (edit.descriptor == DataEdit::ListDirected) {
+    io.GetNextNonBlank();
+  } else {
+    if (edit.width.value_or(0) > 0) {
+      remaining = *edit.width;
+    }
+    io.SkipSpaces(remaining);
+  }
+  return io.NextInField(remaining);
+}
+
 static bool EditBOZInput(IoStatementState &io, const DataEdit &edit, void *n,
     int base, int totalBitSize) {
   std::optional<int> remaining;
-  if (edit.width) {
-    remaining = std::max(0, *edit.width);
-  }
-  io.SkipSpaces(remaining);
-  std::optional<char32_t> next{io.NextInField(remaining)};
+  std::optional<char32_t> next{PrepareInput(io, edit, remaining)};
   common::UnsignedInt128 value{0};
   for (; next; next = io.NextInField(remaining)) {
     char32_t ch{*next};
     if (ch == ' ') {
       continue;
     }
     int digit{0};
     if (ch >= '0' && ch <= '1') {
static bool EditBOZInput(IoStatementState &io, const DataEdit &edit, void *n,
   // TODO: check for overflow
   std::memcpy(n, &value, totalBitSize >> 3);
   return true;
 }
 
 // Returns false if there's a '-' sign
 static bool ScanNumericPrefix(IoStatementState &io, const DataEdit &edit,
     std::optional<char32_t> &next, std::optional<int> &remaining) {
-  if (edit.descriptor != DataEdit::ListDirected && edit.width) {
-    remaining = std::max(0, *edit.width);
-  } else {
-    // list-directed, namelist, or (nonstandard) 0-width input editing
-    remaining.reset();
-  }
-  io.SkipSpaces(remaining);
-  next = io.NextInField(remaining);
+  next = PrepareInput(io, edit, remaining);
   bool negative{false};
   if (next) {
     negative = *next == '-';
     if (negative || *next == '+') {
       next = io.NextInField(remaining);
     }
   }
   return negative;
case 'G':
     break;
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
         "Data edit descriptor '%c' may not be used for LOGICAL input",
         edit.descriptor);
     return false;
   }
   std::optional<int> remaining;
-  if (edit.width) {
-    remaining = std::max(0, *edit.width);
-  }
-  io.SkipSpaces(remaining);
-  std::optional<char32_t> next{io.NextInField(remaining)};
+  std::optional<char32_t> next{PrepareInput(io, edit, remaining)};
   if (next && *next == '.') { // skip optional period
     next = io.NextInField(remaining);
   }
   if (!next) {
     io.GetIoErrorHandler().SignalError("Empty LOGICAL input field");
     return false;
   }
   switch (*next) {

flang/runtime/file.h

public:
   bool mayWrite() const { return mayWrite_; }
   void set_mayWrite(bool yes) { mayWrite_ = yes; }
   bool mayAsynchronous() const { return mayAsynchronous_; }
   void set_mayAsynchronous(bool yes) { mayAsynchronous_ = yes; }
   bool mayPosition() const { return mayPosition_; }
   void set_mayPosition(bool yes) { mayPosition_ = yes; }
   FileOffset position() const { return position_; }
   bool isTerminal() const { return isTerminal_; }
+  std::optional<FileOffset> knownSize() const { return knownSize_; }
 
   bool IsOpen() const { return fd_ >= 0; }
   void Open(OpenStatus, Position, IoErrorHandler &);
   void Predefine(int fd);
   void Close(CloseStatus, IoErrorHandler &);
 
   // Reads data into memory; returns amount acquired.  Synchronous.
   // Partial reads (less than minBytes) signify end-of-file.  If the
private:
   bool mayAsynchronous_{false};
   FileOffset position_{0};
   std::optional<FileOffset> knownSize_;
   bool isTerminal_{false};
 
   int nextId_;
   OwningPtr<Pending> pending_;
 };
+
+bool IsATerminal(int fd);
 } // namespace Fortran::runtime::io
 #endif // FORTRAN_RUNTIME_FILE_H_

flang/runtime/file.cpp

 void OpenFile::Open(
     OpenStatus status, Position position, IoErrorHandler &handler) {
   int flags{mayRead_ ? mayWrite_ ? O_RDWR : O_RDONLY : O_WRONLY};
   switch (status) {
   case OpenStatus::Old:
     if (fd_ >= 0) {
       return;
     }
+    knownSize_.reset();
     break;
   case OpenStatus::New:
     flags |= O_CREAT | O_EXCL;
+    knownSize_ = 0;
     break;
   case OpenStatus::Scratch:
     if (path_.get()) {
       handler.SignalError("FILE= must not appear with STATUS='SCRATCH'");
       path_.reset();
     }
     fd_ = openfile_mkstemp(handler);
+    knownSize_ = 0;
     return;
   case OpenStatus::Replace:
     flags |= O_CREAT | O_TRUNC;
+    knownSize_ = 0;
     break;
   case OpenStatus::Unknown:
     if (fd_ >= 0) {
       return;
     }
     flags |= O_CREAT;
+    knownSize_.reset();
     break;
   }
   // If we reach this point, we're opening a new file.
   // TODO: Fortran shouldn't create a new file until the first WRITE.
   if (fd_ >= 0) {
     if (fd_ <= 2) {
       // don't actually close a standard file descriptor, we might need it
     } else if (::close(fd_) != 0) {
       handler.SignalErrno();
     }
   }
   if (!path_.get()) {
     handler.SignalError(
         "FILE= is required unless STATUS='OLD' and unit is connected");
     return;
   }
   fd_ = ::open(path_.get(), flags, 0600);
   if (fd_ < 0) {
     handler.SignalErrno();
   }
   pending_.reset();
-  knownSize_.reset();
   if (position == Position::Append && !RawSeekToEnd()) {
     handler.SignalErrno();
   }
   isTerminal_ = ::isatty(fd_) == 1;
 }
 
 void OpenFile::Predefine(int fd) {
   fd_ = fd;
std::size_t OpenFile::Read(FileOffset at, char *buffer, std::size_t minBytes,
     std::size_t maxBytes, IoErrorHandler &handler) {
   if (maxBytes == 0) {
     return 0;
   }
   CheckOpen(handler);
   if (!Seek(at, handler)) {
     return 0;
   }
-  if (maxBytes < minBytes) {
-    minBytes = maxBytes;
-  }
+  minBytes = std::min(minBytes, maxBytes);
   std::size_t got{0};
   while (got < minBytes) {
     auto chunk{::read(fd_, buffer + got, maxBytes - got)};
     if (chunk == 0) {
       handler.SignalEnd();
       break;
-    }
-    if (chunk < 0) {
+    } else if (chunk < 0) {
       auto err{errno};
       if (err != EAGAIN && err != EWOULDBLOCK && err != EINTR) {
         handler.SignalError(err);
         break;
       }
     } else {
       position_ += chunk;
       got += chunk;
if (at >= 0) {
     return true;
   } else {
     return false;
   }
 }
 
 int OpenFile::PendingResult(const Terminator &terminator, int iostat) {
   int id{nextId_++};
-  pending_.reset(&New<Pending>{}(terminator, id, iostat, std::move(pending_)));
+  pending_ = New<Pending>{terminator}(id, iostat, std::move(pending_));
   return id;
 }
+
+bool IsATerminal(int fd) { return ::isatty(fd); }
 } // namespace Fortran::runtime::io

flang/runtime/internal-unit.cpp

 #include <algorithm>
 #include <type_traits>
 
 namespace Fortran::runtime::io {
 
 template <Direction DIR>
 InternalDescriptorUnit<DIR>::InternalDescriptorUnit(
     Scalar scalar, std::size_t length) {
+  isFixedRecordLength = true;
   recordLength = length;
   endfileRecordNumber = 2;
   void *pointer{reinterpret_cast<void *>(const_cast<char *>(scalar))};
   descriptor().Establish(TypeCode{CFI_type_char}, length, pointer, 0, nullptr,
       CFI_attribute_pointer);
 }
 
 template <Direction DIR>
 InternalDescriptorUnit<DIR>::InternalDescriptorUnit(
     const Descriptor &that, const Terminator &terminator) {
   RUNTIME_CHECK(terminator, that.type().IsCharacter());
   Descriptor &d{descriptor()};
   RUNTIME_CHECK(
       terminator, that.SizeInBytes() <= d.SizeInBytes(maxRank, true, 0));
   new (&d) Descriptor{that};
   d.Check();
+  isFixedRecordLength = true;
   recordLength = d.ElementBytes();
   endfileRecordNumber = d.Elements() + 1;
 }
 
 template <Direction DIR> void InternalDescriptorUnit<DIR>::EndIoStatement() {
   if constexpr (DIR == Direction::Output) { // blank fill
     while (char *record{CurrentRecord()}) {
       if (furthestPositionInRecord <
if (furthestPositionInRecord <
         recordLength.value_or(furthestPositionInRecord)) {
       char *record{CurrentRecord()};
       RUNTIME_CHECK(handler, record != nullptr);
       std::fill_n(record + furthestPositionInRecord,
           *recordLength - furthestPositionInRecord, ' ');
     }
   }
   ++currentRecordNumber;
-  positionInRecord = 0;
-  furthestPositionInRecord = 0;
+  BeginRecord();
   return true;
 }
 
 template <Direction DIR>
 void InternalDescriptorUnit<DIR>::BackspaceRecord(IoErrorHandler &handler) {
   RUNTIME_CHECK(handler, currentRecordNumber > 1);
   --currentRecordNumber;
-  positionInRecord = 0;
-  furthestPositionInRecord = 0;
+  BeginRecord();
 }
 
 template class InternalDescriptorUnit<Direction::Output>;
 template class InternalDescriptorUnit<Direction::Input>;
 } // namespace Fortran::runtime::io

flang/runtime/io-api.cpp

 
 namespace Fortran::runtime::io {
 
 template <Direction DIR>
 Cookie BeginInternalArrayListIO(const Descriptor &descriptor,
     void ** /*scratchArea*/, std::size_t /*scratchBytes*/,
     const char *sourceFile, int sourceLine) {
   Terminator oom{sourceFile, sourceLine};
-  return &New<InternalListIoStatementState<DIR>>{}(
-      oom, descriptor, sourceFile, sourceLine)
-              .ioStatementState();
+  return &New<InternalListIoStatementState<DIR>>{oom}(
+      descriptor, sourceFile, sourceLine)
+              .release()
+              ->ioStatementState();
 }
 
 Cookie IONAME(BeginInternalArrayListOutput)(const Descriptor &descriptor,
     void **scratchArea, std::size_t scratchBytes, const char *sourceFile,
     int sourceLine) {
   return BeginInternalArrayListIO<Direction::Output>(
       descriptor, scratchArea, scratchBytes, sourceFile, sourceLine);
 }
 
 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) {
   Terminator oom{sourceFile, sourceLine};
-  return &New<InternalFormattedIoStatementState<DIR>>{}(
-      oom, descriptor, format, formatLength, sourceFile, sourceLine)
-              .ioStatementState();
+  return &New<InternalFormattedIoStatementState<DIR>>{oom}(
+      descriptor, format, formatLength, 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) {
   return BeginInternalArrayFormattedIO<Direction::Output>(descriptor, format,
       formatLength, 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) {
   return BeginInternalArrayFormattedIO<Direction::Input>(descriptor, format,
       formatLength, 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) {
   Terminator oom{sourceFile, sourceLine};
-  return &New<InternalFormattedIoStatementState<DIR>>{}(oom, internal,
-      internalLength, format, formatLength, sourceFile, sourceLine)
-              .ioStatementState();
+  return &New<InternalFormattedIoStatementState<DIR>>{oom}(
+      internal, internalLength, format, formatLength, 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) {
   Terminator oom{sourceFile, sourceLine};
   return BeginInternalFormattedIO<Direction::Output>(internal, internalLength,
Cookie BeginExternalListIO(
   if (unit.access == Access::Direct) {
     terminator.Crash("List-directed I/O attempted on direct access file");
     return nullptr;
   }
   if (unit.isUnformatted) {
     terminator.Crash("List-directed I/O attempted on unformatted file");
     return nullptr;
   }
+  IoErrorHandler handler{terminator};
+  unit.SetDirection(DIR, handler);
   IoStatementState &io{unit.BeginIoStatement<ExternalListIoStatementState<DIR>>(
       unit, sourceFile, sourceLine)};
   if constexpr (DIR == Direction::Input) {
-    io.AdvanceRecord();
+    unit.BeginReadingRecord(handler);
   }
   return &io;
 }
 
 Cookie IONAME(BeginExternalListOutput)(
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   return BeginExternalListIO<Direction::Output>(
       unitNumber, sourceFile, sourceLine);
if (unitNumber == DefaultUnit) {
     unitNumber = DIR == Direction::Input ? 5 : 6;
   }
   ExternalFileUnit &unit{
       ExternalFileUnit::LookUpOrCrash(unitNumber, terminator)};
   if (unit.isUnformatted) {
     terminator.Crash("Formatted I/O attempted on unformatted file");
     return nullptr;
   }
+  IoErrorHandler handler{terminator};
+  unit.SetDirection(DIR, handler);
   IoStatementState &io{
       unit.BeginIoStatement<ExternalFormattedIoStatementState<DIR>>(
           unit, format, formatLength, sourceFile, sourceLine)};
   if constexpr (DIR == Direction::Input) {
-    io.AdvanceRecord();
+    unit.BeginReadingRecord(handler);
   }
   return &io;
 }
 
 Cookie IONAME(BeginExternalFormattedOutput)(const char *format,
     std::size_t formatLength, ExternalUnit unitNumber, const char *sourceFile,
     int sourceLine) {
   return BeginExternalFormattedIO<Direction::Output>(
       format, formatLength, unitNumber, sourceFile, sourceLine);
 }
 
 Cookie IONAME(BeginExternalFormattedInput)(const char *format,
     std::size_t formatLength, ExternalUnit unitNumber, const char *sourceFile,
     int sourceLine) {
   return BeginExternalFormattedIO<Direction::Input>(
       format, formatLength, unitNumber, sourceFile, sourceLine);
 }
 
 template <Direction DIR>
 Cookie BeginUnformattedIO(
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
-  ExternalFileUnit &file{
+  ExternalFileUnit &unit{
       ExternalFileUnit::LookUpOrCrash(unitNumber, terminator)};
-  if (!file.isUnformatted) {
+  if (!unit.isUnformatted) {
     terminator.Crash("Unformatted output attempted on formatted file");
   }
-  IoStatementState &io{file.BeginIoStatement<UnformattedIoStatementState<DIR>>(
-      file, sourceFile, sourceLine)};
+  IoStatementState &io{unit.BeginIoStatement<UnformattedIoStatementState<DIR>>(
+      unit, sourceFile, sourceLine)};
+  IoErrorHandler handler{terminator};
+  unit.SetDirection(DIR, handler);
   if constexpr (DIR == Direction::Input) {
-    io.AdvanceRecord();
+    unit.BeginReadingRecord(handler);
   } else {
-    if (file.access == Access::Sequential && !file.recordLength.has_value()) {
+    if (unit.access == Access::Sequential && !unit.isFixedRecordLength) {
       // Create space for (sub)record header to be completed by
       // UnformattedIoStatementState<Direction::Output>::EndIoStatement()
       io.Emit("\0\0\0\0", 4); // placeholder for record length header
     }
   }
   return &io;
 }
 
ExternalFileUnit &unit{
       ExternalFileUnit::LookUpOrCreate(unitNumber, terminator, &wasExtant)};
   return &unit.BeginIoStatement<OpenStatementState>(
       unit, wasExtant, sourceFile, sourceLine);
 }
 
 Cookie IONAME(BeginOpenNewUnit)( // OPEN(NEWUNIT=j)
     const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
-  return IONAME(BeginOpenUnit)(
-      ExternalFileUnit::NewUnit(terminator), sourceFile, sourceLine);
+  ExternalFileUnit &unit{ExternalFileUnit::LookUpOrCreate(
+      ExternalFileUnit::NewUnit(terminator), terminator)};
+  return &unit.BeginIoStatement<OpenStatementState>(
+      unit, false /*wasExtant*/, sourceFile, sourceLine);
 }
 
 Cookie IONAME(BeginClose)(
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   if (ExternalFileUnit * unit{ExternalFileUnit::LookUpForClose(unitNumber)}) {
     return &unit->BeginIoStatement<CloseStatementState>(
         *unit, sourceFile, sourceLine);
   } else {
     // CLOSE(UNIT=bad unit) is just a no-op
     Terminator oom{sourceFile, sourceLine};
-    return &New<NoopCloseStatementState>{}(oom, sourceFile, sourceLine)
-                .ioStatementState();
+    return &New<NoopCloseStatementState>{oom}(sourceFile, sourceLine)
+                .release()
+                ->ioStatementState();
   }
 }
 
+Cookie IONAME(BeginFlush)(
+    ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
+  Terminator terminator{sourceFile, sourceLine};
+  ExternalFileUnit &unit{
+      ExternalFileUnit::LookUpOrCrash(unitNumber, terminator)};
+  return &unit.BeginIoStatement<ExternalMiscIoStatementState>(
+      unit, ExternalMiscIoStatementState::Flush, sourceFile, sourceLine);
+}
+
+Cookie IONAME(BeginBackspace)(
+    ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
+  Terminator terminator{sourceFile, sourceLine};
+  ExternalFileUnit &unit{
+      ExternalFileUnit::LookUpOrCrash(unitNumber, terminator)};
+  return &unit.BeginIoStatement<ExternalMiscIoStatementState>(
+      unit, ExternalMiscIoStatementState::Backspace, sourceFile, sourceLine);
+}
+
+Cookie IONAME(BeginEndfile)(
+    ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
+  Terminator terminator{sourceFile, sourceLine};
+  ExternalFileUnit &unit{
+      ExternalFileUnit::LookUpOrCrash(unitNumber, terminator)};
+  return &unit.BeginIoStatement<ExternalMiscIoStatementState>(
+      unit, ExternalMiscIoStatementState::Endfile, sourceFile, sourceLine);
+}
+
+Cookie IONAME(BeginRewind)(
+    ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
+  Terminator terminator{sourceFile, sourceLine};
+  ExternalFileUnit &unit{
+      ExternalFileUnit::LookUpOrCrash(unitNumber, terminator)};
+  return &unit.BeginIoStatement<ExternalMiscIoStatementState>(
+      unit, ExternalMiscIoStatementState::Rewind, sourceFile, sourceLine);
+}
+
 // Control list items
 
 void IONAME(EnableHandlers)(Cookie cookie, bool hasIoStat, bool hasErr,
     bool hasEnd, bool hasEor, bool hasIoMsg) {
   IoErrorHandler &handler{cookie->GetIoErrorHandler()};
   if (hasIoStat) {
     handler.HasIoStat();
   }

 bool IONAME(SetRec)(Cookie cookie, std::int64_t rec) {
   IoStatementState &io{*cookie};
   ConnectionState &connection{io.GetConnectionState()};
   if (connection.access != Access::Direct) {
     io.GetIoErrorHandler().SignalError(
         "REC= may not appear unless ACCESS='DIRECT'");
     return false;
   }
-  if (!connection.recordLength) {
+  if (!connection.isFixedRecordLength || !connection.recordLength) {
     io.GetIoErrorHandler().SignalError("RECL= was not specified");
     return false;
   }
   if (rec < 1) {
     io.GetIoErrorHandler().SignalError(
         "REC=%zd is invalid", static_cast<std::intmax_t>(rec));
     return false;
   }
bool IONAME(SetRecl)(Cookie cookie, std::size_t n) {
   auto *open{io.get_if<OpenStatementState>()};
   if (!open) {
     io.GetIoErrorHandler().Crash(
         "SetRecl() called when not in an OPEN statement");
   }
   if (n <= 0) {
     io.GetIoErrorHandler().SignalError("RECL= must be greater than zero");
   }
-  if (open->wasExtant() && open->unit().recordLength.has_value() &&
-      *open->unit().recordLength != static_cast<std::int64_t>(n)) {
+  if (open->wasExtant() && open->unit().isFixedRecordLength &&
+      open->unit().recordLength.value_or(n) != static_cast<std::int64_t>(n)) {
     open->SignalError("RECL= may not be changed for an open unit");
   }
+  open->unit().isFixedRecordLength = true;
   open->unit().recordLength = n;
   return true;
 }
 
 bool IONAME(SetStatus)(Cookie cookie, const char *keyword, std::size_t length) {
   IoStatementState &io{*cookie};
   if (auto *open{io.get_if<OpenStatementState>()}) {
     static const char *statuses[]{

 }
 
 bool IONAME(OutputUnformattedBlock)(
     Cookie cookie, const char *x, std::size_t length) {
   IoStatementState &io{*cookie};
   if (auto *unf{io.get_if<UnformattedIoStatementState<Direction::Output>>()}) {
     return unf->Emit(x, length);
   }
-  io.GetIoErrorHandler().Crash("OutputUnformatted() called for an I/O "
+  io.GetIoErrorHandler().Crash("OutputUnformattedBlock() called for an I/O "
+                               "statement that is not unformatted output");
+  return false;
+}
+
+bool IONAME(InputUnformattedBlock)(Cookie cookie, char *x, std::size_t length) {
+  IoStatementState &io{*cookie};
+  if (auto *unf{io.get_if<UnformattedIoStatementState<Direction::Input>>()}) {
+    return unf->Receive(x, length);
+  }
+  io.GetIoErrorHandler().Crash("InputUnformattedBlock() called for an I/O "
                                "statement that is not unformatted output");
   return false;
 }
 
 bool IONAME(OutputInteger64)(Cookie cookie, std::int64_t n) {
   IoStatementState &io{*cookie};
   if (!io.get_if<OutputStatementState>()) {
     io.GetIoErrorHandler().Crash(

flang/runtime/io-stmt.h

 
 template <Direction, typename CHAR = char>
 class InternalFormattedIoStatementState;
 template <Direction, typename CHAR = char> class InternalListIoStatementState;
 template <Direction, typename CHAR = char>
 class ExternalFormattedIoStatementState;
 template <Direction> class ExternalListIoStatementState;
 template <Direction> class UnformattedIoStatementState;
+class ExternalMiscIoStatementState;
 
 // The Cookie type in the I/O API is a pointer (for C) to this class.
 class IoStatementState {
 public:
   template <typename A> explicit IoStatementState(A &x) : u_{x} {}
 
   // These member functions each project themselves into the active alternative.
   // They're used by per-data-item routines in the I/O API (e.g., OutputReal64)
return std::visit(
           }
           return nullptr;
         },
         u_);
   }
 
   bool EmitRepeated(char, std::size_t);
   bool EmitField(const char *, std::size_t length, std::size_t width);
-  void SkipSpaces(std::optional<int> &remaining);
+
+  std::optional<char32_t> SkipSpaces(std::optional<int> &remaining);
   std::optional<char32_t> NextInField(std::optional<int> &remaining);
   std::optional<char32_t> GetNextNonBlank(); // can advance record
 
 private:
   std::variant<std::reference_wrapper<OpenStatementState>,
       std::reference_wrapper<CloseStatementState>,
       std::reference_wrapper<NoopCloseStatementState>,
       std::reference_wrapper<
           InternalFormattedIoStatementState<Direction::Output>>,
       std::reference_wrapper<
           InternalFormattedIoStatementState<Direction::Input>>,
       std::reference_wrapper<InternalListIoStatementState<Direction::Output>>,
       std::reference_wrapper<InternalListIoStatementState<Direction::Input>>,
       std::reference_wrapper<
           ExternalFormattedIoStatementState<Direction::Output>>,
       std::reference_wrapper<
           ExternalFormattedIoStatementState<Direction::Input>>,
       std::reference_wrapper<ExternalListIoStatementState<Direction::Output>>,
       std::reference_wrapper<ExternalListIoStatementState<Direction::Input>>,
       std::reference_wrapper<UnformattedIoStatementState<Direction::Output>>,
-      std::reference_wrapper<UnformattedIoStatementState<Direction::Input>>>
+      std::reference_wrapper<UnformattedIoStatementState<Direction::Input>>,
+      std::reference_wrapper<ExternalMiscIoStatementState>>
       u_;
 };
 
 // Base class for all per-I/O statement state classes.
 // Inherits IoErrorHandler from its base.
 struct IoStatementBase : public DefaultFormatControlCallbacks {
   using DefaultFormatControlCallbacks::DefaultFormatControlCallbacks;
   int EndIoStatement();

 };
 
 template <Direction DIR>
 class ExternalIoStatementState : public ExternalIoStatementBase,
                                  public IoDirectionState<DIR> {
 public:
   using ExternalIoStatementBase::ExternalIoStatementBase;
   int EndIoStatement();
-  bool Emit(const char *, std::size_t chars /* not bytes */);
+  bool Emit(const char *, std::size_t);
   bool Emit(const char16_t *, std::size_t chars /* not bytes */);
   bool Emit(const char32_t *, std::size_t chars /* not bytes */);
   std::optional<char32_t> GetCurrentChar();
   bool AdvanceRecord(int = 1);
   void BackspaceRecord();
   void HandleRelativePosition(std::int64_t);
   void HandleAbsolutePosition(std::int64_t);
 };
public:
   using ExternalIoStatementState<DIR>::ExternalIoStatementState;
   using ListDirectedStatementState<DIR>::GetNextDataEdit;
 };
 
 template <Direction DIR>
 class UnformattedIoStatementState : public ExternalIoStatementState<DIR> {
 public:
   using ExternalIoStatementState<DIR>::ExternalIoStatementState;
+  bool Receive(char *, std::size_t);
   int EndIoStatement();
 };
 
 class OpenStatementState : public ExternalIoStatementBase {
 public:
   OpenStatementState(ExternalFileUnit &unit, bool wasExtant,
       const char *sourceFile = nullptr, int sourceLine = 0)
       : ExternalIoStatementBase{unit, sourceFile, sourceLine}, wasExtant_{
extern template class FormatControl<
     InternalFormattedIoStatementState<Direction::Output>>;
 extern template class FormatControl<
     InternalFormattedIoStatementState<Direction::Input>>;
 extern template class FormatControl<
     ExternalFormattedIoStatementState<Direction::Output>>;
 extern template class FormatControl<
     ExternalFormattedIoStatementState<Direction::Input>>;
 
+class ExternalMiscIoStatementState : public ExternalIoStatementBase {
+public:
+  enum Which { Flush, Backspace, Endfile, Rewind };
+  ExternalMiscIoStatementState(ExternalFileUnit &unit, Which which,
+      const char *sourceFile = nullptr, int sourceLine = 0)
+      : ExternalIoStatementBase{unit, sourceFile, sourceLine}, which_{which} {}
+  int EndIoStatement();
+
+private:
+  Which which_;
+};
+
 } // namespace Fortran::runtime::io
 #endif // FORTRAN_RUNTIME_IO_STMT_H_

flang/runtime/io-stmt.cpp

 //===-- runtime/io-stmt.cpp -------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "io-stmt.h"
 #include "connection.h"
 #include "format.h"
 #include "memory.h"
 #include "tools.h"
 #include "unit.h"
 #include <algorithm>
+#include <cstdio>
 #include <cstring>
 #include <limits>
 
 namespace Fortran::runtime::io {
 
 int IoStatementBase::EndIoStatement() { return GetIoStat(); }
 
 std::optional<DataEdit> IoStatementBase::GetNextDataEdit(

 
 int NoopCloseStatementState::EndIoStatement() {
   auto result{IoStatementBase::EndIoStatement()};
   FreeMemory(this);
   return result;
 }
 
 template <Direction DIR> int ExternalIoStatementState<DIR>::EndIoStatement() {
-  if constexpr (DIR == Direction::Output) {
-    if (!unit().nonAdvancing) {
-      unit().AdvanceRecord(*this);
-    }
+  if constexpr (DIR == Direction::Output) {
     unit().FlushIfTerminal(*this);
   }
   return ExternalIoStatementBase::EndIoStatement();
 }
 
 template <Direction DIR>
 bool ExternalIoStatementState<DIR>::Emit(const char *data, std::size_t chars) {
   if constexpr (DIR == Direction::Input) {
bool IoStatementState::AdvanceRecord(int n) {
   return std::visit([=](auto &x) { return x.get().AdvanceRecord(n); }, u_);
 }
 
 void IoStatementState::BackspaceRecord() {
   std::visit([](auto &x) { x.get().BackspaceRecord(); }, u_);
 }
 
 void IoStatementState::HandleRelativePosition(std::int64_t n) {
-  return std::visit([=](auto &x) { x.get().HandleRelativePosition(n); }, u_);
+  std::visit([=](auto &x) { x.get().HandleRelativePosition(n); }, u_);
 }
 
 int IoStatementState::EndIoStatement() {
   return std::visit([](auto &x) { return x.get().EndIoStatement(); }, u_);
 }
 
 ConnectionState &IoStatementState::GetConnectionState() {
   return std::visit(
bool IoStatementState::EmitField(
   if (length > static_cast<std::size_t>(width)) {
     return EmitRepeated('*', width);
   } else {
     return EmitRepeated(' ', static_cast<int>(width - length)) &&
         Emit(p, length);
   }
 }
 
-void IoStatementState::SkipSpaces(std::optional<int> &remaining) {
-  if (!remaining || *remaining > 0) {
-    for (auto ch{GetCurrentChar()}; ch && ch == ' '; ch = GetCurrentChar()) {
+std::optional<char32_t> IoStatementState::SkipSpaces(
+    std::optional<int> &remaining) {
+  while (!remaining || *remaining > 0) {
+    if (auto ch{GetCurrentChar()}) {
+      if (*ch != ' ') {
+        return ch;
+      }
       HandleRelativePosition(1);
-      if (remaining && !--*remaining) {
-        break;
+      if (remaining) {
+        --*remaining;
       }
+    } else {
+      break;
     }
   }
+  return std::nullopt;
 }
 
 std::optional<char32_t> IoStatementState::NextInField(
     std::optional<int> &remaining) {
   if (!remaining) { // list-directed or namelist: check for separators
     if (auto next{GetCurrentChar()}) {
       switch (*next) {
       case ' ':
       case ',':
       case ';':
       case '/':
       case '(':
       case ')':
       case '\'':
       case '"':
       case '*':
+      case '\n': // for stream access
         break;
       default:
         HandleRelativePosition(1);
         return next;
       }
     }
   } else if (*remaining > 0) {
     if (auto next{GetCurrentChar()}) {
       --*remaining;
       HandleRelativePosition(1);
       return next;
     }
     const ConnectionState &connection{GetConnectionState()};
-    if (!connection.IsAtEOF() && connection.recordLength &&
+    if (!connection.IsAtEOF() && connection.isFixedRecordLength &&
+        connection.recordLength &&
         connection.positionInRecord >= *connection.recordLength) {
       if (connection.modes.pad) { // PAD='YES'
         --*remaining;
         return std::optional<char32_t>{' '};
       }
       IoErrorHandler &handler{GetIoErrorHandler()};
       if (connection.nonAdvancing) {
         handler.SignalEor();
ListDirectedStatementState<Direction::Input>::GetNextDataEdit(
   if (!imaginaryPart_ && ch && *ch == '(') {
     realPart_ = true;
     io.HandleRelativePosition(1);
   }
   return edit;
 }
 
 template <Direction DIR>
+bool UnformattedIoStatementState<DIR>::Receive(char *data, std::size_t bytes) {
+  if constexpr (DIR == Direction::Output) {
+    this->Crash(
+        "UnformattedIoStatementState::Receive() called for output statement");
+  }
+  return this->unit().Receive(data, bytes, *this);
+}
+
+template <Direction DIR>
 int UnformattedIoStatementState<DIR>::EndIoStatement() {
-  auto &ext{static_cast<ExternalIoStatementState<DIR> &>(*this)};
-  ExternalFileUnit &unit{ext.unit()};
-  if (unit.access == Access::Sequential && !unit.recordLength.has_value()) {
-    // Overwrite the first four bytes of the record with its length,
-    // and also append the length.  These four bytes were skipped over
-    // in BeginUnformattedOutput().
+  ExternalFileUnit &unit{this->unit()};
+  if constexpr (DIR == Direction::Output) {
+    if (unit.access == Access::Sequential && !unit.isFixedRecordLength) {
+      // Append the length of a sequential unformatted variable-length record
+      // as its footer, then overwrite the reserved first four bytes of the
+      // record with its length as its header.  These four bytes were skipped
+      // over in BeginUnformattedOutput().
       // TODO: Break very large records up into subrecords with negative
       // headers &/or footers
       union {
         std::uint32_t u;
         char c[sizeof u];
       } u;
-    u.u = unit.furthestPositionInRecord - sizeof u.c;
+      u.u = unit.furthestPositionInRecord - sizeof u;
       // TODO: Convert record length to little-endian on big-endian host?
-    if (!(ext.Emit(u.c, sizeof u.c) &&
-            (ext.HandleAbsolutePosition(0), ext.Emit(u.c, sizeof u.c)) &&
-            ext.AdvanceRecord())) {
+      if (!(this->Emit(u.c, sizeof u) &&
+              (this->HandleAbsolutePosition(0), this->Emit(u.c, sizeof u)))) {
         return false;
       }
     }
-  return ext.EndIoStatement();
+  }
+  return ExternalIoStatementState<DIR>::EndIoStatement();
 }
 
 template class InternalIoStatementState<Direction::Output>;
 template class InternalIoStatementState<Direction::Input>;
 template class InternalFormattedIoStatementState<Direction::Output>;
 template class InternalFormattedIoStatementState<Direction::Input>;
 template class InternalListIoStatementState<Direction::Output>;
 template class InternalListIoStatementState<Direction::Input>;
 template class ExternalIoStatementState<Direction::Output>;
 template class ExternalIoStatementState<Direction::Input>;
 template class ExternalFormattedIoStatementState<Direction::Output>;
 template class ExternalFormattedIoStatementState<Direction::Input>;
 template class ExternalListIoStatementState<Direction::Output>;
 template class ExternalListIoStatementState<Direction::Input>;
 template class UnformattedIoStatementState<Direction::Output>;
 template class UnformattedIoStatementState<Direction::Input>;
+
+int ExternalMiscIoStatementState::EndIoStatement() {
+  ExternalFileUnit &ext{unit()};
+  switch (which_) {
+  case Flush:
+    ext.Flush(*this);
+    std::fflush(nullptr); // flushes C stdio output streams (12.9(2))
+    break;
+  case Backspace:
+    ext.BackspaceRecord(*this);
+    break;
+  case Endfile:
+    ext.Endfile(*this);
+    break;
+  case Rewind:
+    ext.Rewind(*this);
+    break;
+  }
+  return ExternalIoStatementBase::EndIoStatement();
+}
+
 } // namespace Fortran::runtime::io

flang/runtime/iostat.h

enum Iostat {
 
   // The remaining error codes are not exported.
   IostatGenericError = 1001, // see IOMSG= for details
   IostatRecordWriteOverrun,
   IostatRecordReadOverrun,
   IostatInternalWriteOverrun,
   IostatErrorInFormat,
   IostatErrorInKeyword,
+  IostatEndfileNonSequential,
+  IostatEndfileUnwritable,
+  IostatOpenBadRecl,
+  IostatOpenUnknownSize,
+  IostatOpenBadAppend,
+  IostatWriteToReadOnly,
+  IostatReadFromWriteOnly,
+  IostatBackspaceNonSequential,
+  IostatBackspaceAtFirstRecord,
+  IostatRewindNonSequential,
 };
 
 const char *IostatErrorString(int);
 
 } // namespace Fortran::runtime::io
 #endif // FORTRAN_RUNTIME_IOSTAT_H_

flang/runtime/iostat.cpp

const char *IostatErrorString(int iostat) {
   case IostatRecordReadOverrun:
     return "Excessive input from fixed-size record";
   case IostatInternalWriteOverrun:
     return "Internal write overran available records";
   case IostatErrorInFormat:
     return "Invalid FORMAT";
   case IostatErrorInKeyword:
     return "Bad keyword argument value";
+  case IostatEndfileNonSequential:
+    return "ENDFILE on non-sequential file";
+  case IostatEndfileUnwritable:
+    return "ENDFILE on read-only file";
+  case IostatOpenBadRecl:
+    return "OPEN with bad RECL= value";
+  case IostatOpenUnknownSize:
+    return "OPEN of file of unknown size";
+  case IostatOpenBadAppend:
+    return "OPEN(POSITION='APPEND') of unpositionable file";
+  case IostatWriteToReadOnly:
+    return "Attempted output to read-only file";
+  case IostatReadFromWriteOnly:
+    return "Attempted input from write-only file";
+  case IostatBackspaceNonSequential:
+    return "BACKSPACE on non-sequential file";
+  case IostatBackspaceAtFirstRecord:
+    return "BACKSPACE at first record";
+  case IostatRewindNonSequential:
+    return "REWIND on non-sequential file";
   default:
     return nullptr;
   }
 }
 
 } // namespace Fortran::runtime::io

flang/runtime/memory.h

 template <typename A> void FreeMemory(A *p) {
   FreeMemory(reinterpret_cast<void *>(p));
 }
 template <typename A> void FreeMemoryAndNullify(A *&p) {
   FreeMemory(p);
   p = nullptr;
 }
 
-template <typename A> struct New {
-  template <typename... X>
-  [[nodiscard]] A &operator()(const Terminator &terminator, X &&... x) {
-    return *new (AllocateMemoryOrCrash(terminator, sizeof(A)))
-        A{std::forward<X>(x)...};
-  }
-};
-
 template <typename A> struct OwningPtrDeleter {
   void operator()(A *p) { FreeMemory(p); }
 };
 
 template <typename A> using OwningPtr = std::unique_ptr<A, OwningPtrDeleter<A>>;
 
+template <typename A> class SizedNew {
+public:
+  explicit SizedNew(const Terminator &terminator) : terminator_{terminator} {}
+  template <typename... X>
+  [[nodiscard]] OwningPtr<A> operator()(std::size_t bytes, X &&... x) {
+    return OwningPtr<A>{new (AllocateMemoryOrCrash(terminator_, bytes))
+            A{std::forward<X>(x)...}};
+  }
+
+private:
+  const Terminator &terminator_;
+};
+
+template <typename A> struct New : public SizedNew<A> {
+  using SizedNew<A>::SizedNew;
+  template <typename... X> [[nodiscard]] OwningPtr<A> operator()(X &&... x) {
+    return SizedNew<A>::operator()(sizeof(A), std::forward<X>(x)...);
+  }
+};
+
 template <typename A> struct Allocator {
   using value_type = A;
   explicit Allocator(const Terminator &t) : terminator{t} {}
   template <typename B>
   explicit constexpr Allocator(const Allocator<B> &that) noexcept
       : terminator{that.terminator} {}
   Allocator(const Allocator &) = default;
   Allocator(Allocator &&) = default;

flang/runtime/stop.h

 
 FORTRAN_EXTERN_C_BEGIN
 
 // Program-initiated image stop
 NORETURN void RTNAME(StopStatement)(int code DEFAULT_VALUE(EXIT_SUCCESS),
     bool isErrorStop DEFAULT_VALUE(false), bool quiet DEFAULT_VALUE(false));
 NORETURN void RTNAME(StopStatementText)(const char *,
     bool isErrorStop DEFAULT_VALUE(false), bool quiet DEFAULT_VALUE(false));
+void RTNAME(PauseStatement)(NO_ARGUMENTS);
 NORETURN void RTNAME(FailImageStatement)(NO_ARGUMENTS);
 NORETURN void RTNAME(ProgramEndStatement)(NO_ARGUMENTS);
 
 FORTRAN_EXTERN_C_END
 
 #endif // FORTRAN_RUNTIME_STOP_H_

flang/runtime/stop.cpp

 //===-- runtime/stop.cpp ----------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "stop.h"
+#include "file.h"
 #include "io-error.h"
 #include "terminator.h"
 #include "unit.h"
 #include <cfenv>
 #include <cstdio>
 #include <cstdlib>
 
 extern "C" {
[[noreturn]] void RTNAME(StopStatementText)(
   if (!quiet) {
     std::fprintf(
         stderr, "Fortran %s: %s\n", isErrorStop ? "ERROR STOP" : "STOP", code);
     DescribeIEEESignaledExceptions();
   }
   std::exit(EXIT_FAILURE);
 }
 
+void RTNAME(PauseStatement)() {
+  if (Fortran::runtime::io::IsATerminal(0)) {
+    Fortran::runtime::io::IoErrorHandler handler{"PAUSE statement"};
+    Fortran::runtime::io::ExternalFileUnit::FlushAll(handler);
+    std::fputs("Fortran PAUSE: hit RETURN to continue:", stderr);
+    std::fflush(nullptr);
+    if (std::fgetc(stdin) == EOF) {
+      CloseAllExternalUnits("PAUSE statement");
+      std::exit(EXIT_SUCCESS);
+    }
+  }
+}
+
 [[noreturn]] void RTNAME(FailImageStatement)() {
   Fortran::runtime::NotifyOtherImagesOfFailImageStatement();
   CloseAllExternalUnits("FAIL IMAGE statement");
   std::exit(EXIT_FAILURE);
 }
 
 [[noreturn]] void RTNAME(ProgramEndStatement)() {
   CloseAllExternalUnits("END statement");
   std::exit(EXIT_SUCCESS);
 }
 }

flang/runtime/terminator.h

void SetLocation(const char *sourceFileName = nullptr, int sourceLine = 0) {
     sourceLine_ = sourceLine;
   }
   [[noreturn]] void Crash(const char *message, ...) const;
   [[noreturn]] void CrashArgs(const char *message, va_list &) const;
   [[noreturn]] void CheckFailed(
       const char *predicate, const char *file, int line) const;
 
   // For test harnessing - overrides CrashArgs().
-  static void RegisterCrashHandler(void (*)(const char *, va_list &));
+  static void RegisterCrashHandler(void (*)(const char *sourceFile,
+      int sourceLine, const char *message, va_list &ap));
 
 private:
   const char *sourceFileName_{nullptr};
   int sourceLine_{0};
 };
 
 // RUNTIME_CHECK() guarantees evaluation of its predicate.
 #define RUNTIME_CHECK(terminator, pred) \

flang/runtime/terminator.cpp

 namespace Fortran::runtime {
 
 [[noreturn]] void Terminator::Crash(const char *message, ...) const {
   va_list ap;
   va_start(ap, message);
   CrashArgs(message, ap);
 }
 
-static void (*crashHandler)(const char *, va_list &){nullptr};
+static void (*crashHandler)(const char *, int, const char *, va_list &){
+    nullptr};
 
 void Terminator::RegisterCrashHandler(
-    void (*handler)(const char *, va_list &)) {
+    void (*handler)(const char *, int, const char *, va_list &)) {
   crashHandler = handler;
 }
 
 [[noreturn]] void Terminator::CrashArgs(
     const char *message, va_list &ap) const {
   if (crashHandler) {
-    crashHandler(message, ap);
+    crashHandler(sourceFileName_, sourceLine_, message, ap);
   }
   std::fputs("\nfatal Fortran runtime error", stderr);
   if (sourceFileName_) {
     std::fprintf(stderr, "(%s", sourceFileName_);
     if (sourceLine_) {
       std::fprintf(stderr, ":%d", sourceLine_);
     }
     fputc(')', stderr);

flang/runtime/unit-map.h

public:
   }
 
   // To prevent races, the unit is removed from the map if it exists,
   // and put on the closing_ list until DestroyClosed() is called.
   ExternalFileUnit *LookUpForClose(int);
 
   void DestroyClosed(ExternalFileUnit &);
   void CloseAll(IoErrorHandler &);
+  void FlushAll(IoErrorHandler &);
 
 private:
   struct Chain {
     explicit Chain(int n) : unit{n} {}
     ExternalFileUnit unit;
     OwningPtr<Chain> next{nullptr};
   };
 

flang/runtime/unit-map.cpp

while (Chain * p{bucket_[j].get()}) {
       bucket_[j].swap(p->next); // pops p from head of list
       p->unit.CloseUnit(CloseStatus::Keep, handler);
       p->unit.~ExternalFileUnit();
       FreeMemory(p);
     }
   }
 }
 
+void UnitMap::FlushAll(IoErrorHandler &handler) {
+  CriticalSection critical{lock_};
+  for (int j{0}; j < buckets_; ++j) {
+    for (Chain *p{bucket_[j].get()}; p; p = p->next.get()) {
+      p->unit.Flush(handler);
+    }
+  }
+}
+
 ExternalFileUnit &UnitMap::Create(int n, const Terminator &terminator) {
-  Chain &chain{New<Chain>{}(terminator, n)};
+  Chain &chain{*New<Chain>{terminator}(n).release()};
   chain.next.reset(&chain);
   bucket_[Hash(n)].swap(chain.next); // pushes new node as list head
   return chain.unit;
 }
 } // namespace Fortran::runtime::io

flang/runtime/unit.h

public:
 
   static ExternalFileUnit *LookUp(int unit);
   static ExternalFileUnit &LookUpOrCrash(int unit, const Terminator &);
   static ExternalFileUnit &LookUpOrCreate(
       int unit, const Terminator &, bool *wasExtant = nullptr);
   static ExternalFileUnit *LookUpForClose(int unit);
   static int NewUnit(const Terminator &);
   static void CloseAll(IoErrorHandler &);
+  static void FlushAll(IoErrorHandler &);
 
   void OpenUnit(OpenStatus, Position, OwningPtr<char> &&path,
       std::size_t pathLength, IoErrorHandler &);
   void CloseUnit(CloseStatus, IoErrorHandler &);
   void DestroyClosed();
 
+  bool SetDirection(Direction, IoErrorHandler &);
+
   template <typename A, typename... X>
   IoStatementState &BeginIoStatement(X &&... xs) {
     // TODO: Child data transfer statements vs. locking
     lock_.Take(); // dropped in EndIoStatement()
     A &state{u_.emplace<A>(std::forward<X>(xs)...)};
     if constexpr (!std::is_same_v<A, OpenStatementState>) {
       state.mutableModes() = ConnectionState::modes;
     }
     io_.emplace(state);
     return *io_;
   }
 
-  bool Emit(const char *, std::size_t bytes, IoErrorHandler &);
+  bool Emit(const char *, std::size_t, IoErrorHandler &);
+  bool Receive(char *, std::size_t, IoErrorHandler &);
   std::optional<char32_t> GetCurrentChar(IoErrorHandler &);
   void SetLeftTabLimit();
+  void BeginReadingRecord(IoErrorHandler &);
   bool AdvanceRecord(IoErrorHandler &);
   void BackspaceRecord(IoErrorHandler &);
   void FlushIfTerminal(IoErrorHandler &);
+  void Endfile(IoErrorHandler &);
+  void Rewind(IoErrorHandler &);
   void EndIoStatement();
   void SetPosition(std::int64_t pos) {
     frameOffsetInFile_ = pos;
     recordOffsetInFrame_ = 0;
+    BeginRecord();
   }
 
 private:
   static UnitMap &GetUnitMap();
-  void NextSequentialUnformattedInputRecord(IoErrorHandler &);
-  void NextSequentialFormattedInputRecord(IoErrorHandler &);
-  void BackspaceSequentialUnformattedRecord(IoErrorHandler &);
-  void BackspaceSequentialFormattedRecord(IoErrorHandler &);
+  const char *FrameNextInput(IoErrorHandler &, std::size_t);
+  void BeginSequentialVariableUnformattedInputRecord(IoErrorHandler &);
+  void BeginSequentialVariableFormattedInputRecord(IoErrorHandler &);
+  void BackspaceFixedRecord(IoErrorHandler &);
+  void BackspaceVariableUnformattedRecord(IoErrorHandler &);
+  void BackspaceVariableFormattedRecord(IoErrorHandler &);
+  bool SetSequentialVariableFormattedRecordLength();
+  void DoImpliedEndfile(IoErrorHandler &);
+  void DoEndfile(IoErrorHandler &);
 
   int unitNumber_{-1};
-  bool isReading_{false};
+  Direction direction_{Direction::Output};
+  bool impliedEndfile_{false}; // seq. output has taken place
 
   Lock lock_;
 
   // When an I/O statement is in progress on this unit, holds its state.
   std::variant<std::monostate, OpenStatementState, CloseStatementState,
       ExternalFormattedIoStatementState<Direction::Output>,
       ExternalFormattedIoStatementState<Direction::Input>,
       ExternalListIoStatementState<Direction::Output>,
       ExternalListIoStatementState<Direction::Input>,
       UnformattedIoStatementState<Direction::Output>,
-      UnformattedIoStatementState<Direction::Input>>
+      UnformattedIoStatementState<Direction::Input>,
+      ExternalMiscIoStatementState>
       u_;
 
   // Points to the active alternative (if any) in u_ for use as a Cookie
   std::optional<IoStatementState> io_;
 
   // Subtle: The beginning of the frame can't be allowed to advance
   // during a single list-directed READ due to the possibility of a
-  // multi-record CHARACTER value with a "r*" repeat count.
+  // multi-record CHARACTER value with a "r*" repeat count.  So we
+  // manage the frame and the current record therein separately.
   std::int64_t frameOffsetInFile_{0};
-  std::int64_t recordOffsetInFrame_{0}; // of currentRecordNumber
+  std::size_t recordOffsetInFrame_{0}; // of currentRecordNumber
 };
 
 } // namespace Fortran::runtime::io
 #endif // FORTRAN_RUNTIME_IO_UNIT_H_

flang/runtime/unit.cpp

 #include "unit-map.h"
 
 namespace Fortran::runtime::io {
 
 // The per-unit data structures are created on demand so that Fortran I/O
 // should work without a Fortran main program.
 static Lock unitMapLock;
 static UnitMap *unitMap{nullptr};
+static ExternalFileUnit *defaultInput{nullptr};
 static ExternalFileUnit *defaultOutput{nullptr};
 
 void FlushOutputOnCrash(const Terminator &terminator) {
   if (!defaultOutput) {
     return;
   }
   CriticalSection critical{unitMapLock};
   if (defaultOutput) {
if (status == OpenStatus::Old &&
         (!newPath.get() ||
             (path() && pathLength() == newPathLength &&
                 std::memcmp(path(), newPath.get(), newPathLength) == 0))) {
       // OPEN of existing unit, STATUS='OLD', not new FILE=
       newPath.reset();
       return;
     }
     // Otherwise, OPEN on open unit with new FILE= implies CLOSE
+    DoImpliedEndfile(handler);
     Flush(handler);
     Close(CloseStatus::Keep, handler);
   }
   set_path(std::move(newPath), newPathLength);
   Open(status, position, handler);
+  auto totalBytes{knownSize()};
+  if (access == Access::Direct) {
+    if (!isFixedRecordLength || !recordLength) {
+      handler.SignalError(IostatOpenBadRecl,
+          "OPEN(UNIT=%d,ACCESS='DIRECT'): record length is not known",
+          unitNumber());
+    } else if (*recordLength <= 0) {
+      handler.SignalError(IostatOpenBadRecl,
+          "OPEN(UNIT=%d,ACCESS='DIRECT',RECL=%jd): record length is invalid",
+          unitNumber(), static_cast<std::intmax_t>(*recordLength));
+    } else if (!totalBytes) {
+      handler.SignalError(IostatOpenUnknownSize,
+          "OPEN(UNIT=%d,ACCESS='DIRECT'): file size is not known");
+    } else if (*totalBytes % *recordLength != 0) {
+      handler.SignalError(IostatOpenBadAppend,
+          "OPEN(UNIT=%d,ACCESS='DIRECT',RECL=%jd): record length is not an "
+          "even divisor of the file size %jd",
+          unitNumber(), static_cast<std::intmax_t>(*recordLength),
+          static_cast<std::intmax_t>(*totalBytes));
+    }
+  }
+  if (position == Position::Append) {
+    if (*totalBytes && recordLength && *recordLength) {
+      endfileRecordNumber = 1 + (*totalBytes / *recordLength);
+    } else {
+      // Fake it so that we can backspace relative from the end
+      endfileRecordNumber = std::numeric_limits<std::int64_t>::max() - 1;
+    }
+    currentRecordNumber = *endfileRecordNumber;
+  } else {
+    currentRecordNumber = 1;
+  }
 }
 
 void ExternalFileUnit::CloseUnit(CloseStatus status, IoErrorHandler &handler) {
+  DoImpliedEndfile(handler);
   Flush(handler);
   Close(status, handler);
 }
 
 void ExternalFileUnit::DestroyClosed() {
   GetUnitMap().DestroyClosed(*this); // destroys *this
 }
 
+bool ExternalFileUnit::SetDirection(
+    Direction direction, IoErrorHandler &handler) {
+  if (direction == Direction::Input) {
+    if (mayRead()) {
+      direction_ = Direction::Input;
+      return true;
+    } else {
+      handler.SignalError(IostatReadFromWriteOnly,
+          "READ(UNIT=%d) with ACTION='WRITE'", unitNumber());
+      return false;
+    }
+  } else {
+    if (mayWrite()) {
+      direction_ = Direction::Output;
+      return true;
+    } else {
+      handler.SignalError(IostatWriteToReadOnly,
+          "WRITE(UNIT=%d) with ACTION='READ'", unitNumber());
+      return false;
+    }
+  }
+}
+
 UnitMap &ExternalFileUnit::GetUnitMap() {
   if (unitMap) {
     return *unitMap;
   }
   CriticalSection critical{unitMapLock};
   if (unitMap) {
     return *unitMap;
   }
   Terminator terminator{__FILE__, __LINE__};
-  unitMap = &New<UnitMap>{}(terminator);
+  IoErrorHandler handler{terminator};
+  unitMap = New<UnitMap>{terminator}().release();
   ExternalFileUnit &out{ExternalFileUnit::LookUpOrCreate(6, terminator)};
   out.Predefine(1);
   out.set_mayRead(false);
   out.set_mayWrite(true);
   out.set_mayPosition(false);
+  out.SetDirection(Direction::Output, handler);
   defaultOutput = &out;
   ExternalFileUnit &in{ExternalFileUnit::LookUpOrCreate(5, terminator)};
   in.Predefine(0);
   in.set_mayRead(true);
   in.set_mayWrite(false);
   in.set_mayPosition(false);
+  in.SetDirection(Direction::Input, handler);
+  defaultInput = &in;
   // TODO: Set UTF-8 mode from the environment
   return *unitMap;
 }
 
 void ExternalFileUnit::CloseAll(IoErrorHandler &handler) {
   CriticalSection critical{unitMapLock};
   if (unitMap) {
     unitMap->CloseAll(handler);
     FreeMemoryAndNullify(unitMap);
   }
   defaultOutput = nullptr;
 }
 
+void ExternalFileUnit::FlushAll(IoErrorHandler &handler) {
+  CriticalSection critical{unitMapLock};
+  if (unitMap) {
+    unitMap->FlushAll(handler);
+  }
+}
+
 bool ExternalFileUnit::Emit(
     const char *data, std::size_t bytes, IoErrorHandler &handler) {
   auto furthestAfter{std::max(furthestPositionInRecord,
       positionInRecord + static_cast<std::int64_t>(bytes))};
   if (furthestAfter > recordLength.value_or(furthestAfter)) {
-    handler.SignalError(IostatRecordWriteOverrun);
+    handler.SignalError(IostatRecordWriteOverrun,
+        "Attempt to write %zd bytes to position %jd in a fixed-size record of "
+        "%jd bytes",
+        bytes, static_cast<std::intmax_t>(positionInRecord),
+        static_cast<std::intmax_t>(*recordLength));
     return false;
   }
   WriteFrame(frameOffsetInFile_, recordOffsetInFrame_ + furthestAfter, handler);
   if (positionInRecord > furthestPositionInRecord) {
-    std::memset(Frame() + furthestPositionInRecord, ' ',
+    std::memset(Frame() + recordOffsetInFrame_ + furthestPositionInRecord, ' ',
         positionInRecord - furthestPositionInRecord);
   }
-  std::memcpy(Frame() + positionInRecord, data, bytes);
+  std::memcpy(Frame() + recordOffsetInFrame_ + positionInRecord, data, bytes);
   positionInRecord += bytes;
   furthestPositionInRecord = furthestAfter;
   return true;
 }
 
+bool ExternalFileUnit::Receive(
+    char *data, std::size_t bytes, IoErrorHandler &handler) {
+  RUNTIME_CHECK(handler, direction_ == Direction::Input);
+  auto furthestAfter{std::max(furthestPositionInRecord,
+      positionInRecord + static_cast<std::int64_t>(bytes))};
+  if (furthestAfter > recordLength.value_or(furthestAfter)) {
+    handler.SignalError(IostatRecordReadOverrun,
+        "Attempt to read %zd bytes at position %jd in a record of %jd bytes",
+        bytes, static_cast<std::intmax_t>(positionInRecord),
+        static_cast<std::intmax_t>(*recordLength));
+    return false;
+  }
+  auto need{recordOffsetInFrame_ + furthestAfter};
+  auto got{ReadFrame(frameOffsetInFile_, need, handler)};
+  if (got >= need) {
+    std::memcpy(data, Frame() + recordOffsetInFrame_ + positionInRecord, bytes);
+    positionInRecord += bytes;
+    furthestPositionInRecord = furthestAfter;
+    return true;
+  } else {
+    handler.SignalEnd();
+    endfileRecordNumber = currentRecordNumber;
+    return false;
+  }
+}
+
 std::optional<char32_t> ExternalFileUnit::GetCurrentChar(
     IoErrorHandler &handler) {
-  isReading_ = true; // TODO: manage read/write transitions
-  if (isUnformatted) {
-    handler.Crash("GetCurrentChar() called for unformatted input");
-    return std::nullopt;
+  RUNTIME_CHECK(handler, direction_ == Direction::Input);
+  if (const char *p{FrameNextInput(handler, 1)}) {
+    // TODO: UTF-8 decoding; may have to get more bytes in a loop
+    return *p;
   }
-  std::size_t chunk{256}; // for stream input
-  if (recordLength.has_value()) {
-    if (positionInRecord >= *recordLength) {
-      return std::nullopt;
-    }
-    chunk = *recordLength - positionInRecord;
-  }
+
+const char *ExternalFileUnit::FrameNextInput(
+    IoErrorHandler &handler, std::size_t bytes) {
+  RUNTIME_CHECK(handler, !isUnformatted);
+  if (static_cast<std::int64_t>(positionInRecord + bytes) <=
+      recordLength.value_or(positionInRecord + bytes)) {
     auto at{recordOffsetInFrame_ + positionInRecord};
-  std::size_t need{static_cast<std::size_t>(at + 1)};
-  std::size_t want{need + chunk};
-  auto got{ReadFrame(frameOffsetInFile_, want, handler)};
-  if (got <= need) {
-    endfileRecordNumber = currentRecordNumber;
+    auto need{static_cast<std::size_t>(at + bytes)};
+    auto got{ReadFrame(frameOffsetInFile_, need, handler)};
+    SetSequentialVariableFormattedRecordLength();
+    if (got >= need) {
+      return Frame() + at;
+    }
     handler.SignalEnd();
-    return std::nullopt;
+    endfileRecordNumber = currentRecordNumber;
   }
-  const char *p{Frame() + at};
-  if (isUTF8) {
-    // TODO: UTF-8 decoding
-  }
-  return *p;
+  return nullptr;
+
+bool ExternalFileUnit::SetSequentialVariableFormattedRecordLength() {
+  if (recordLength || access != Access::Sequential) {
+    return true;
+  }
+  if (FrameLength() > recordOffsetInFrame_) {
+    const char *record{Frame() + recordOffsetInFrame_};
+    if (const char *nl{reinterpret_cast<const char *>(
+            std::memchr(record, '\n', FrameLength() - recordOffsetInFrame_))}) {
+      recordLength = nl - record;
+      if (*recordLength > 0 && record[*recordLength - 1] == '\r') {
+        --*recordLength;
+      }
+      return true;
+    }
+  }
+  return false;
 }
 
 void ExternalFileUnit::SetLeftTabLimit() {
   leftTabLimit = furthestPositionInRecord;
   positionInRecord = furthestPositionInRecord;
 }
 
+void ExternalFileUnit::BeginReadingRecord(IoErrorHandler &handler) {
+  RUNTIME_CHECK(handler, direction_ == Direction::Input);
+  if (access == Access::Sequential) {
+    if (endfileRecordNumber && currentRecordNumber >= *endfileRecordNumber) {
+      handler.SignalEnd();
+    } else if (isFixedRecordLength) {
+      RUNTIME_CHECK(handler, recordLength.has_value());
+      auto need{static_cast<std::size_t>(recordOffsetInFrame_ + *recordLength)};
+      auto got{ReadFrame(frameOffsetInFile_, need, handler)};
+      if (got < need) {
+        handler.SignalEnd();
+      }
+    } else if (isUnformatted) {
+      BeginSequentialVariableUnformattedInputRecord(handler);
+    } else { // formatted
+      BeginSequentialVariableFormattedInputRecord(handler);
+    }
+  }
+}
+
 bool ExternalFileUnit::AdvanceRecord(IoErrorHandler &handler) {
   bool ok{true};
-  if (isReading_) {
+  if (direction_ == Direction::Input) {
     if (access == Access::Sequential) {
-      if (isUnformatted) {
-        NextSequentialUnformattedInputRecord(handler);
-      } else {
-        NextSequentialFormattedInputRecord(handler);
+      RUNTIME_CHECK(handler, recordLength.has_value());
+      if (isFixedRecordLength) {
+        frameOffsetInFile_ += recordOffsetInFrame_ + *recordLength;
+        recordOffsetInFrame_ = 0;
+      } else if (isUnformatted) {
+        // Retain footer in frame for more efficient BACKSPACE
+        frameOffsetInFile_ += recordOffsetInFrame_ + *recordLength;
+        recordOffsetInFrame_ = sizeof(std::uint32_t);
+        recordLength.reset();
+      } else { // formatted
+        if (Frame()[recordOffsetInFrame_ + *recordLength] == '\r') {
+          ++recordOffsetInFrame_;
+        }
+        recordOffsetInFrame_ += *recordLength + 1;
+        RUNTIME_CHECK(handler, Frame()[recordOffsetInFrame_ - 1] == '\n');
+        recordLength.reset();
       }
     }
-  } else if (!isUnformatted) {
-    if (recordLength.has_value()) {
-      // fill fixed-size record
+  } else { // Direction::Output
+    if (!isUnformatted) {
+      if (isFixedRecordLength && recordLength) {
         if (furthestPositionInRecord < *recordLength) {
           WriteFrame(frameOffsetInFile_, *recordLength, handler);
           std::memset(Frame() + recordOffsetInFrame_ + furthestPositionInRecord,
               ' ', *recordLength - furthestPositionInRecord);
         }
       } else {
         positionInRecord = furthestPositionInRecord;
         ok &= Emit("\n", 1, handler); // TODO: Windows CR+LF
-      frameOffsetInFile_ += recordOffsetInFrame_ + furthestPositionInRecord;
-      recordOffsetInFrame_ = 0;
       }
     }
+    frameOffsetInFile_ +=
+        recordOffsetInFrame_ + recordLength.value_or(furthestPositionInRecord);
+    recordOffsetInFrame_ = 0;
+    impliedEndfile_ = true;
+  }
   ++currentRecordNumber;
-  positionInRecord = 0;
-  furthestPositionInRecord = 0;
-  leftTabLimit.reset();
+  BeginRecord();
   return ok;
 }
 
 void ExternalFileUnit::BackspaceRecord(IoErrorHandler &handler) {
-  if (!isReading_) {
-    handler.Crash("ExternalFileUnit::BackspaceRecord() called during writing");
-    // TODO: create endfile record, &c.
-  }
-  if (access == Access::Sequential) {
-    if (isUnformatted) {
-      BackspaceSequentialUnformattedRecord(handler);
-    } else {
-      BackspaceSequentialFormattedRecord(handler);
-    }
+  if (access != Access::Sequential) {
+    handler.SignalError(IostatBackspaceNonSequential,
+        "BACKSPACE(UNIT=%d) on non-sequential file", unitNumber());
+    DoImpliedEndfile(handler);
+    --currentRecordNumber;
+    BeginRecord();
+    if (isFixedRecordLength) {
+      BackspaceFixedRecord(handler);
+    } else if (isUnformatted) {
+      BackspaceVariableUnformattedRecord(handler);
     } else {
-    // TODO
+      BackspaceVariableFormattedRecord(handler);
+    }
   }
-  positionInRecord = 0;
-  furthestPositionInRecord = 0;
-  leftTabLimit.reset();
 }
 
 void ExternalFileUnit::FlushIfTerminal(IoErrorHandler &handler) {
   if (isTerminal()) {
     Flush(handler);
   }
 }
 
+void ExternalFileUnit::Endfile(IoErrorHandler &handler) {
+  if (access != Access::Sequential) {
+    handler.SignalError(IostatEndfileNonSequential,
+        "ENDFILE(UNIT=%d) on non-sequential file", unitNumber());
+  } else if (!mayWrite()) {
+    handler.SignalError(IostatEndfileUnwritable,
+        "ENDFILE(UNIT=%d) on read-only file", unitNumber());
+  } else {
+    DoEndfile(handler);
+  }
+}
+
+void ExternalFileUnit::Rewind(IoErrorHandler &handler) {
+  if (access == Access::Direct) {
+    handler.SignalError(IostatRewindNonSequential,
+        "REWIND(UNIT=%d) on non-sequential file", unitNumber());
+  } else {
+    DoImpliedEndfile(handler);
+    SetPosition(0);
+    currentRecordNumber = 1;
+    // TODO: reset endfileRecordNumber?
+  }
+}
+
 void ExternalFileUnit::EndIoStatement() {
   frameOffsetInFile_ += recordOffsetInFrame_;
   recordOffsetInFrame_ = 0;
   io_.reset();
   u_.emplace<std::monostate>();
   lock_.Drop();
 }
 
-void ExternalFileUnit::NextSequentialUnformattedInputRecord(
+void ExternalFileUnit::BeginSequentialVariableUnformattedInputRecord(
     IoErrorHandler &handler) {
   std::int32_t header{0}, footer{0};
-  // Retain previous footer (if any) in frame for more efficient BACKSPACE
-  std::size_t retain{sizeof header};
-  if (recordLength) { // not first record - advance to next
-    ++currentRecordNumber;
-    if (endfileRecordNumber && currentRecordNumber >= *endfileRecordNumber) {
-      handler.SignalEnd();
-      return;
-    }
-    frameOffsetInFile_ +=
-        recordOffsetInFrame_ + *recordLength + 2 * sizeof header;
-    recordOffsetInFrame_ = 0;
-  } else {
-    retain = 0;
-  }
-  std::size_t need{retain + sizeof header};
-  std::size_t got{ReadFrame(frameOffsetInFile_ - retain, need, handler)};
+  std::size_t need{recordOffsetInFrame_ + sizeof header};
+  std::size_t got{ReadFrame(frameOffsetInFile_, need, handler)};
   // Try to emit informative errors to help debug corrupted files.
   const char *error{nullptr};
   if (got < need) {
-    if (got == retain) {
+    if (got == recordOffsetInFrame_) {
       handler.SignalEnd();
     } else {
-      error = "Unformatted sequential file input failed at record #%jd (file "
-              "offset %jd): truncated record header";
+      error = "Unformatted variable-length sequential file input failed at "
+              "record #%jd (file offset %jd): truncated record header";
     }
   } else {
-    std::memcpy(&header, Frame() + retain, sizeof header);
-    need = retain + header + 2 * sizeof header;
-    got = ReadFrame(frameOffsetInFile_ - retain,
-        need + sizeof header /* next one */, handler);
+    std::memcpy(&header, Frame() + recordOffsetInFrame_, sizeof header);
+    recordLength = sizeof header + header; // does not include footer
+    need = recordOffsetInFrame_ + *recordLength + sizeof footer;
+    got = ReadFrame(frameOffsetInFile_, need, handler);
     if (got < need) {
-      error = "Unformatted sequential file input failed at record #%jd (file "
-              "offset %jd): hit EOF reading record with length %jd bytes";
+      error = "Unformatted variable-length sequential file input failed at "
+              "record #%jd (file offset %jd): hit EOF reading record with "
+              "length %jd bytes";
     } else {
-      const char *start{Frame() + retain + sizeof header};
-      std::memcpy(&footer, start + header, sizeof footer);
+      std::memcpy(&footer, Frame() + recordOffsetInFrame_ + *recordLength,
+          sizeof footer);
       if (footer != header) {
-        error = "Unformatted sequential file input failed at record #%jd (file "
-                "offset %jd): record header has length %jd that does not match "
-                "record footer (%jd)";
-      } else {
-        recordLength = header;
+        error = "Unformatted variable-length sequential file input failed at "
+                "record #%jd (file offset %jd): record header has length %jd "
+                "that does not match record footer (%jd)";
       }
     }
   }
   if (error) {
     handler.SignalError(error, static_cast<std::intmax_t>(currentRecordNumber),
         static_cast<std::intmax_t>(frameOffsetInFile_),
         static_cast<std::intmax_t>(header), static_cast<std::intmax_t>(footer));
+    // TODO: error recovery
   }
   positionInRecord = sizeof header;
 }
 
-void ExternalFileUnit::NextSequentialFormattedInputRecord(
+void ExternalFileUnit::BeginSequentialVariableFormattedInputRecord(
     IoErrorHandler &handler) {
-  static constexpr std::size_t chunk{256};
-  std::size_t length{0};
-  if (recordLength.has_value()) {
-    // not first record - advance to next
-    ++currentRecordNumber;
-    if (endfileRecordNumber && currentRecordNumber >= *endfileRecordNumber) {
-      handler.SignalEnd();
-      return;
-    }
-    if (Frame()[*recordLength] == '\r') {
-      ++*recordLength;
-    }
-    recordOffsetInFrame_ += *recordLength + 1;
+  if (this == defaultInput && defaultOutput) {
+    defaultOutput->Flush(handler);
   }
-  while (true) {
-    std::size_t got{ReadFrame(
-        frameOffsetInFile_, recordOffsetInFrame_ + length + chunk, handler)};
-    if (got <= recordOffsetInFrame_ + length) {
+  std::size_t length{0};
+  do {
+    std::size_t need{recordOffsetInFrame_ + length + 1};
+    length = ReadFrame(frameOffsetInFile_, need, handler);
+    if (length < need) {
       handler.SignalEnd();
       break;
     }
-    const char *frame{Frame() + recordOffsetInFrame_};
-    if (const char *nl{reinterpret_cast<const char *>(
-            std::memchr(frame + length, '\n', chunk))}) {
-      recordLength = nl - (frame + length) + 1;
-      if (*recordLength > 0 && frame[*recordLength - 1] == '\r') {
-        --*recordLength;
-      }
-      return;
-    }
-    length += got;
+  } while (!SetSequentialVariableFormattedRecordLength());
+
+void ExternalFileUnit::BackspaceFixedRecord(IoErrorHandler &handler) {
+  RUNTIME_CHECK(handler, recordLength.has_value());
+  if (frameOffsetInFile_ < *recordLength) {
+    handler.SignalError(IostatBackspaceAtFirstRecord);
+  } else {
+    frameOffsetInFile_ -= *recordLength;
   }
 }
 
-void ExternalFileUnit::BackspaceSequentialUnformattedRecord(
+void ExternalFileUnit::BackspaceVariableUnformattedRecord(
     IoErrorHandler &handler) {
   std::int32_t header{0}, footer{0};
-  RUNTIME_CHECK(handler, currentRecordNumber > 1);
-  --currentRecordNumber;
-  int overhead{static_cast<int>(2 * sizeof header)};
+  auto headerBytes{static_cast<std::int64_t>(sizeof header)};
+  frameOffsetInFile_ += recordOffsetInFrame_;
+  recordOffsetInFrame_ = 0;
+  if (frameOffsetInFile_ <= headerBytes) {
+    handler.SignalError(IostatBackspaceAtFirstRecord);
+    return;
+  }
   // Error conditions here cause crashes, not file format errors, because the
   // validity of the file structure before the current record will have been
-  // checked informatively in NextSequentialUnformattedInputRecord().
-  RUNTIME_CHECK(handler, frameOffsetInFile_ >= overhead);
+  // checked informatively in NextSequentialVariableUnformattedInputRecord().
   std::size_t got{
-      ReadFrame(frameOffsetInFile_ - sizeof footer, sizeof footer, handler)};
+      ReadFrame(frameOffsetInFile_ - headerBytes, headerBytes, handler)};
   RUNTIME_CHECK(handler, got >= sizeof footer);
   std::memcpy(&footer, Frame(), sizeof footer);
-  RUNTIME_CHECK(handler, frameOffsetInFile_ >= footer + overhead);
-  frameOffsetInFile_ -= footer + 2 * sizeof footer;
-  auto extra{std::max<std::size_t>(sizeof footer, frameOffsetInFile_)};
-  std::size_t want{extra + footer + 2 * sizeof footer};
-  got = ReadFrame(frameOffsetInFile_ - extra, want, handler);
-  RUNTIME_CHECK(handler, got >= want);
-  std::memcpy(&header, Frame() + extra, sizeof header);
-  RUNTIME_CHECK(handler, header == footer);
-  positionInRecord = sizeof header;
   recordLength = footer;
+  RUNTIME_CHECK(handler, frameOffsetInFile_ >= *recordLength + 2 * headerBytes);
+  frameOffsetInFile_ -= *recordLength + 2 * headerBytes;
+  if (frameOffsetInFile_ >= headerBytes) {
+    frameOffsetInFile_ -= headerBytes;
+    recordOffsetInFrame_ = headerBytes;
+  }
+  auto need{static_cast<std::size_t>(
+      recordOffsetInFrame_ + sizeof header + *recordLength)};
+  got = ReadFrame(frameOffsetInFile_, need, handler);
+  RUNTIME_CHECK(handler, got >= need);
+  std::memcpy(&header, Frame() + recordOffsetInFrame_, sizeof header);
+  RUNTIME_CHECK(handler, header == *recordLength);
 }
 
 // There's no portable memrchr(), unfortunately, and strrchr() would
 // fail on a record with a NUL, so we have to do it the hard way.
 static const char *FindLastNewline(const char *str, std::size_t length) {
   for (const char *p{str + length}; p-- > str;) {
     if (*p == '\n') {
       return p;
     }
   }
   return nullptr;
 }
 
-void ExternalFileUnit::BackspaceSequentialFormattedRecord(
+void ExternalFileUnit::BackspaceVariableFormattedRecord(
     IoErrorHandler &handler) {
-  std::int64_t start{frameOffsetInFile_ + recordOffsetInFrame_};
-  --currentRecordNumber;
-  RUNTIME_CHECK(handler, currentRecordNumber > 0);
-  if (currentRecordNumber == 1) {
-    // To simplify the code below, treat a backspace to the first record
-    // as a special case;
-    RUNTIME_CHECK(handler, start > 0);
-    *recordLength = start - 1;
-    frameOffsetInFile_ = 0;
-    recordOffsetInFrame_ = 0;
-    ReadFrame(0, *recordLength + 1, handler);
-  } else {
-    RUNTIME_CHECK(handler, start > 1);
-    std::int64_t at{start - 2}; // byte before previous record's newline
-    while (true) {
+  // File offset of previous record's newline
+  auto prevNL{
+      frameOffsetInFile_ + static_cast<std::int64_t>(recordOffsetInFrame_) - 1};
+  if (prevNL < 0) {
+    handler.SignalError(IostatBackspaceAtFirstRecord);
+    return;
+  }
+    if (frameOffsetInFile_ < prevNL) {
       if (const char *p{
-              FindLastNewline(Frame(), at - frameOffsetInFile_ + 1)}) {
-        // This is the newline that ends the record before the previous one.
+              FindLastNewline(Frame(), prevNL - 1 - frameOffsetInFile_)}) {
         recordOffsetInFrame_ = p - Frame() + 1;
-        *recordLength = start - 1 - (frameOffsetInFile_ + recordOffsetInFrame_);
-        break;
-      }
-      RUNTIME_CHECK(handler, frameOffsetInFile_ > 0);
-      at = frameOffsetInFile_ - 1;
-      if (auto bytesBefore{BytesBufferedBeforeFrame()}) {
-        frameOffsetInFile_ = FrameAt() - bytesBefore;
-      } else {
-        static constexpr int chunk{1024};
-        frameOffsetInFile_ = std::max<std::int64_t>(0, at - chunk);
-      }
-      std::size_t want{static_cast<std::size_t>(start - frameOffsetInFile_)};
-      std::size_t got{ReadFrame(frameOffsetInFile_, want, handler)};
-      RUNTIME_CHECK(handler, got >= want);
-    }
-  }
-  std::size_t want{
-      static_cast<std::size_t>(recordOffsetInFrame_ + *recordLength + 1)};
-  RUNTIME_CHECK(handler, FrameLength() >= want);
+        *recordLength = prevNL - (frameOffsetInFile_ + recordOffsetInFrame_);
+        break;
+      }
+    }
+    if (frameOffsetInFile_ == 0) {
+      recordOffsetInFrame_ = 0;
+      *recordLength = prevNL;
+    frameOffsetInFile_ -= std::min<std::int64_t>(frameOffsetInFile_, 1024);
+    auto need{static_cast<std::size_t>(prevNL + 1 - frameOffsetInFile_)};
+    auto got{ReadFrame(frameOffsetInFile_, need, handler)};
+    RUNTIME_CHECK(handler, got >= need);
+  }
   RUNTIME_CHECK(handler, Frame()[recordOffsetInFrame_ + *recordLength] == '\n');
   if (*recordLength > 0 &&
       Frame()[recordOffsetInFrame_ + *recordLength - 1] == '\r') {
     --*recordLength;
   }
 }
+
+void ExternalFileUnit::DoImpliedEndfile(IoErrorHandler &handler) {
+  if (impliedEndfile_) {
+    impliedEndfile_ = false;
+    if (access == Access::Sequential && mayPosition()) {
+      DoEndfile(handler);
+    }
+  }
+}
+
+void ExternalFileUnit::DoEndfile(IoErrorHandler &handler) {
+  endfileRecordNumber = currentRecordNumber;
+  Truncate(frameOffsetInFile_ + recordOffsetInFrame_, handler);
+  BeginRecord();
+  impliedEndfile_ = false;
+}
 } // namespace Fortran::runtime::io

flang/unittests/Runtime/CMakeLists.txt

add_executable(external-hello-world
   external-hello.cpp
 )
 
 target_link_libraries(external-hello-world
   FortranRuntime
   LLVMSupport
 )
 
+add_executable(external-io
+  external-io.cpp
+)
+
+target_link_libraries(external-io
+  RuntimeTesting
+  FortranRuntime
+  LLVMSupport
+)
+
+add_test(NAME ExternalIO COMMAND external-io)
+
 add_executable(list-input-test
   list-input.cpp
 )
 
 target_link_libraries(list-input-test
   RuntimeTesting
   FortranRuntime
   LLVMSupport

flang/unittests/Runtime/external-hello.cpp

 #include "../../runtime/io-api.h"
 #include "../../runtime/main.h"
 #include "../../runtime/stop.h"
 #include <cstring>
 
 using namespace Fortran::runtime::io;
 
-int main(int argc, const char *argv[], const char *envp[]) {
-  RTNAME(ProgramStart)(argc, argv, envp);
-  auto *io{IONAME(BeginExternalListOutput)()};
+void output1() {
+  auto io{IONAME(BeginExternalListOutput)()};
   const char str[]{"Hello, world!"};
   IONAME(OutputAscii)(io, str, std::strlen(str));
   IONAME(OutputInteger64)(io, 678);
   IONAME(OutputReal64)(io, 0.0);
   IONAME(OutputReal64)(io, 2.0 / 3.0);
   IONAME(OutputReal64)(io, 1.0e99);
   IONAME(OutputReal64)(io, 1.0 / 0.0);
   IONAME(OutputReal64)(io, -1.0 / 0.0);
   IONAME(OutputReal64)(io, 0.0 / 0.0);
   IONAME(OutputComplex64)(io, 123.0, -234.0);
   IONAME(OutputLogical)(io, false);
   IONAME(OutputLogical)(io, true);
   IONAME(EndIoStatement)(io);
+}
+
+void input1() {
+  auto io{IONAME(BeginExternalListOutput)()};
+  const char prompt[]{"Enter an integer value:"};
+  IONAME(OutputAscii)(io, prompt, std::strlen(prompt));
+  IONAME(EndIoStatement)(io);
+
+  io = IONAME(BeginExternalListInput)();
+  std::int64_t n{-666};
+  IONAME(InputInteger)(io, n);
+  IONAME(EndIoStatement)(io);
+
+  io = IONAME(BeginExternalListOutput)();
+  const char str[]{"Result:"};
+  IONAME(OutputAscii)(io, str, std::strlen(str));
+  IONAME(OutputInteger64)(io, n);
+  IONAME(EndIoStatement)(io);
+}
+
+int main(int argc, const char *argv[], const char *envp[]) {
+  RTNAME(ProgramStart)(argc, argv, envp);
+  output1();
+  input1();
+  RTNAME(PauseStatement)();
   RTNAME(ProgramEndStatement)();
   return 0;
 }

flang/unittests/Runtime/external-io.cpp

+// Sanity test for all external I/O modes
+
+#include "testing.h"
+#include "../../runtime/io-api.h"
+#include "../../runtime/main.h"
+#include "../../runtime/stop.h"
+#include "llvm/Support/raw_ostream.h"
+#include <cstring>
+
+using namespace Fortran::runtime::io;
+
+void TestDirectUnformatted() {
+  llvm::errs() << "begin TestDirectUnformatted()\n";
+  // OPEN(NEWUNIT=unit,ACCESS='DIRECT',ACTION='READWRITE',&
+  //   FORM='UNFORMATTED',RECL=8,STATUS='SCRATCH')
+  auto io{IONAME(BeginOpenNewUnit)(__FILE__, __LINE__)};
+  IONAME(SetAccess)(io, "DIRECT", 6) || (Fail() << "SetAccess(DIRECT)", 0);
+  IONAME(SetAction)
+  (io, "READWRITE", 9) || (Fail() << "SetAction(READWRITE)", 0);
+  IONAME(SetForm)
+  (io, "UNFORMATTED", 11) || (Fail() << "SetForm(UNFORMATTED)", 0);
+  std::int64_t buffer;
+  static constexpr std::size_t recl{sizeof buffer};
+  IONAME(SetRecl)(io, recl) || (Fail() << "SetRecl()", 0);
+  IONAME(SetStatus)(io, "SCRATCH", 7) || (Fail() << "SetStatus(SCRATCH)", 0);
+  int unit{-1};
+  IONAME(GetNewUnit)(io, unit) || (Fail() << "GetNewUnit()", 0);
+  llvm::errs() << "unit=" << unit << '\n';
+  IONAME(EndIoStatement)
+  (io) == IostatOk || (Fail() << "EndIoStatement() for OpenNewUnit", 0);
+  static constexpr int records{10};
+  for (int j{1}; j <= records; ++j) {
+    // WRITE(UNIT=unit,REC=j) j
+    io = IONAME(BeginUnformattedOutput)(unit, __FILE__, __LINE__);
+    IONAME(SetRec)(io, j) || (Fail() << "SetRec(" << j << ')', 0);
+    buffer = j;
+    IONAME(OutputUnformattedBlock)
+    (io, reinterpret_cast<const char *>(&buffer), recl) ||
+        (Fail() << "OutputUnformattedBlock()", 0);
+    IONAME(EndIoStatement)
+    (io) == IostatOk ||
+        (Fail() << "EndIoStatement() for OutputUnformattedBlock", 0);
+  }
+  for (int j{records}; j >= 1; --j) {
+    // READ(UNIT=unit,REC=j) n
+    io = IONAME(BeginUnformattedInput)(unit, __FILE__, __LINE__);
+    IONAME(SetRec)
+    (io, j) || (Fail() << "SetRec(" << j << ')', 0);
+    IONAME(InputUnformattedBlock)
+    (io, reinterpret_cast<char *>(&buffer), recl) ||
+        (Fail() << "InputUnformattedBlock()", 0);
+    IONAME(EndIoStatement)
+    (io) == IostatOk ||
+        (Fail() << "EndIoStatement() for InputUnformattedBlock", 0);
+    if (buffer != j) {
+      Fail() << "Read back " << buffer << " from direct unformatted record "
+             << j << ", expected " << j << '\n';
+    }
+  }
+  // CLOSE(UNIT=unit,STATUS='DELETE')
+  io = IONAME(BeginClose)(unit, __FILE__, __LINE__);
+  IONAME(SetStatus)(io, "DELETE", 6) || (Fail() << "SetStatus(DELETE)", 0);
+  IONAME(EndIoStatement)
+  (io) == IostatOk || (Fail() << "EndIoStatement() for Close", 0);
+  llvm::errs() << "end TestDirectUnformatted()\n";
+}
+
+void TestSequentialFixedUnformatted() {
+  llvm::errs() << "begin TestSequentialFixedUnformatted()\n";
+  // OPEN(NEWUNIT=unit,ACCESS='SEQUENTIAL',ACTION='READWRITE',&
+  //   FORM='UNFORMATTED',RECL=8,STATUS='SCRATCH')
+  auto io{IONAME(BeginOpenNewUnit)(__FILE__, __LINE__)};
+  IONAME(SetAccess)
+  (io, "SEQUENTIAL", 10) || (Fail() << "SetAccess(SEQUENTIAL)", 0);
+  IONAME(SetAction)
+  (io, "READWRITE", 9) || (Fail() << "SetAction(READWRITE)", 0);
+  IONAME(SetForm)
+  (io, "UNFORMATTED", 11) || (Fail() << "SetForm(UNFORMATTED)", 0);
+  std::int64_t buffer;
+  static constexpr std::size_t recl{sizeof buffer};
+  IONAME(SetRecl)(io, recl) || (Fail() << "SetRecl()", 0);
+  IONAME(SetStatus)(io, "SCRATCH", 7) || (Fail() << "SetStatus(SCRATCH)", 0);
+  int unit{-1};
+  IONAME(GetNewUnit)(io, unit) || (Fail() << "GetNewUnit()", 0);
+  llvm::errs() << "unit=" << unit << '\n';
+  IONAME(EndIoStatement)
+  (io) == IostatOk || (Fail() << "EndIoStatement() for OpenNewUnit", 0);
+  static const int records{10};
+  for (int j{1}; j <= records; ++j) {
+    // DO J=1,RECORDS; WRITE(UNIT=unit) j; END DO
+    io = IONAME(BeginUnformattedOutput)(unit, __FILE__, __LINE__);
+    buffer = j;
+    IONAME(OutputUnformattedBlock)
+    (io, reinterpret_cast<const char *>(&buffer), recl) ||
+        (Fail() << "OutputUnformattedBlock()", 0);
+    IONAME(EndIoStatement)
+    (io) == IostatOk ||
+        (Fail() << "EndIoStatement() for OutputUnformattedBlock", 0);
+  }
+  // REWIND(UNIT=unit)
+  io = IONAME(BeginRewind)(unit, __FILE__, __LINE__);
+  IONAME(EndIoStatement)
+  (io) == IostatOk || (Fail() << "EndIoStatement() for Rewind", 0);
+  for (int j{1}; j <= records; ++j) {
+    // DO J=1,RECORDS; READ(UNIT=unit) n; check n; END DO
+    io = IONAME(BeginUnformattedInput)(unit, __FILE__, __LINE__);
+    IONAME(InputUnformattedBlock)
+    (io, reinterpret_cast<char *>(&buffer), recl) ||
+        (Fail() << "InputUnformattedBlock()", 0);
+    IONAME(EndIoStatement)
+    (io) == IostatOk ||
+        (Fail() << "EndIoStatement() for InputUnformattedBlock", 0);
+    if (buffer != j) {
+      Fail() << "Read back " << buffer
+             << " from sequential fixed unformatted record " << j
+             << ", expected " << j << '\n';
+    }
+  }
+  for (int j{records}; j >= 1; --j) {
+    // BACKSPACE(UNIT=unit)
+    io = IONAME(BeginBackspace)(unit, __FILE__, __LINE__);
+    IONAME(EndIoStatement)
+    (io) == IostatOk ||
+        (Fail() << "EndIoStatement() for Backspace (before read)", 0);
+    // READ(UNIT=unit) n
+    io = IONAME(BeginUnformattedInput)(unit, __FILE__, __LINE__);
+    IONAME(InputUnformattedBlock)
+    (io, reinterpret_cast<char *>(&buffer), recl) ||
+        (Fail() << "InputUnformattedBlock()", 0);
+    IONAME(EndIoStatement)
+    (io) == IostatOk ||
+        (Fail() << "EndIoStatement() for InputUnformattedBlock", 0);
+    if (buffer != j) {
+      Fail() << "Read back " << buffer
+             << " from sequential fixed unformatted record " << j
+             << " after backspacing, expected " << j << '\n';
+    }
+    // BACKSPACE(UNIT=unit)
+    io = IONAME(BeginBackspace)(unit, __FILE__, __LINE__);
+    IONAME(EndIoStatement)
+    (io) == IostatOk ||
+        (Fail() << "EndIoStatement() for Backspace (after read)", 0);
+  }
+  // CLOSE(UNIT=unit,STATUS='DELETE')
+  io = IONAME(BeginClose)(unit, __FILE__, __LINE__);
+  IONAME(SetStatus)(io, "DELETE", 6) || (Fail() << "SetStatus(DELETE)", 0);
+  IONAME(EndIoStatement)
+  (io) == IostatOk || (Fail() << "EndIoStatement() for Close", 0);
+  llvm::errs() << "end TestSequentialFixedUnformatted()\n";
+}
+
+void TestSequentialVariableUnformatted() {
+  llvm::errs() << "begin TestSequentialVariableUnformatted()\n";
+  // OPEN(NEWUNIT=unit,ACCESS='SEQUENTIAL',ACTION='READWRITE',&
+  //   FORM='UNFORMATTED',STATUS='SCRATCH')
+  auto io{IONAME(BeginOpenNewUnit)(__FILE__, __LINE__)};
+  IONAME(SetAccess)
+  (io, "SEQUENTIAL", 10) || (Fail() << "SetAccess(SEQUENTIAL)", 0);
+  IONAME(SetAction)
+  (io, "READWRITE", 9) || (Fail() << "SetAction(READWRITE)", 0);
+  IONAME(SetForm)
+  (io, "UNFORMATTED", 11) || (Fail() << "SetForm(UNFORMATTED)", 0);
+  IONAME(SetStatus)(io, "SCRATCH", 7) || (Fail() << "SetStatus(SCRATCH)", 0);
+  int unit{-1};
+  IONAME(GetNewUnit)(io, unit) || (Fail() << "GetNewUnit()", 0);
+  llvm::errs() << "unit=" << unit << '\n';
+  IONAME(EndIoStatement)
+  (io) == IostatOk || (Fail() << "EndIoStatement() for OpenNewUnit", 0);
+  static const int records{10};
+  std::int64_t buffer[records]; // INTEGER*8 :: BUFFER(0:9) = [(j,j=0,9)]
+  for (int j{0}; j < records; ++j) {
+    buffer[j] = j;
+  }
+  for (int j{1}; j <= records; ++j) {
+    // DO J=1,RECORDS; WRITE(UNIT=unit) BUFFER(0:j); END DO
+    io = IONAME(BeginUnformattedOutput)(unit, __FILE__, __LINE__);
+    IONAME(OutputUnformattedBlock)
+    (io, reinterpret_cast<const char *>(&buffer), j * sizeof *buffer) ||
+        (Fail() << "OutputUnformattedBlock()", 0);
+    IONAME(EndIoStatement)
+    (io) == IostatOk ||
+        (Fail() << "EndIoStatement() for OutputUnformattedBlock", 0);
+  }
+  // REWIND(UNIT=unit)
+  io = IONAME(BeginRewind)(unit, __FILE__, __LINE__);
+  IONAME(EndIoStatement)
+  (io) == IostatOk || (Fail() << "EndIoStatement() for Rewind", 0);
+  for (int j{1}; j <= records; ++j) {
+    // DO J=1,RECORDS; READ(UNIT=unit) n; check n; END DO
+    io = IONAME(BeginUnformattedInput)(unit, __FILE__, __LINE__);
+    IONAME(InputUnformattedBlock)
+    (io, reinterpret_cast<char *>(&buffer), j * sizeof *buffer) ||
+        (Fail() << "InputUnformattedBlock()", 0);
+    IONAME(EndIoStatement)
+    (io) == IostatOk ||
+        (Fail() << "EndIoStatement() for InputUnformattedBlock", 0);
+    for (int k{0}; k < j; ++k) {
+      if (buffer[k] != k) {
+        Fail() << "Read back [" << k << "]=" << buffer[k]
+               << " from direct unformatted record " << j << ", expected " << k
+               << '\n';
+      }
+    }
+  }
+  for (int j{records}; j >= 1; --j) {
+    // BACKSPACE(unit)
+    io = IONAME(BeginBackspace)(unit, __FILE__, __LINE__);
+    IONAME(EndIoStatement)
+    (io) == IostatOk ||
+        (Fail() << "EndIoStatement() for Backspace (before read)", 0);
+    // READ(unit=unit) n; check
+    io = IONAME(BeginUnformattedInput)(unit, __FILE__, __LINE__);
+    IONAME(InputUnformattedBlock)
+    (io, reinterpret_cast<char *>(&buffer), j * sizeof *buffer) ||
+        (Fail() << "InputUnformattedBlock()", 0);
+    IONAME(EndIoStatement)
+    (io) == IostatOk ||
+        (Fail() << "EndIoStatement() for InputUnformattedBlock", 0);
+    for (int k{0}; k < j; ++k) {
+      if (buffer[k] != k) {
+        Fail() << "Read back [" << k << "]=" << buffer[k]
+               << " from sequential variable unformatted record " << j
+               << ", expected " << k << '\n';
+      }
+    }
+    // BACKSPACE(unit)
+    io = IONAME(BeginBackspace)(unit, __FILE__, __LINE__);
+    IONAME(EndIoStatement)
+    (io) == IostatOk ||
+        (Fail() << "EndIoStatement() for Backspace (after read)", 0);
+  }
+  // CLOSE(UNIT=unit,STATUS='DELETE')
+  io = IONAME(BeginClose)(unit, __FILE__, __LINE__);
+  IONAME(SetStatus)(io, "DELETE", 6) || (Fail() << "SetStatus(DELETE)", 0);
+  IONAME(EndIoStatement)
+  (io) == IostatOk || (Fail() << "EndIoStatement() for Close", 0);
+  llvm::errs() << "end TestSequentialVariableUnformatted()\n";
+}
+
+void TestDirectFormatted() {
+  llvm::errs() << "begin TestDirectFormatted()\n";
+  // OPEN(NEWUNIT=unit,ACCESS='DIRECT',ACTION='READWRITE',&
+  //   FORM='FORMATTED',RECL=8,STATUS='SCRATCH')
+  auto io{IONAME(BeginOpenNewUnit)(__FILE__, __LINE__)};
+  IONAME(SetAccess)(io, "DIRECT", 6) || (Fail() << "SetAccess(DIRECT)", 0);
+  IONAME(SetAction)
+  (io, "READWRITE", 9) || (Fail() << "SetAction(READWRITE)", 0);
+  IONAME(SetForm)
+  (io, "FORMATTED", 9) || (Fail() << "SetForm(FORMATTED)", 0);
+  static constexpr std::size_t recl{8};
+  IONAME(SetRecl)(io, recl) || (Fail() << "SetRecl()", 0);
+  IONAME(SetStatus)(io, "SCRATCH", 7) || (Fail() << "SetStatus(SCRATCH)", 0);
+  int unit{-1};
+  IONAME(GetNewUnit)(io, unit) || (Fail() << "GetNewUnit()", 0);
+  llvm::errs() << "unit=" << unit << '\n';
+  IONAME(EndIoStatement)
+  (io) == IostatOk || (Fail() << "EndIoStatement() for OpenNewUnit", 0);
+  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__);
+    IONAME(SetRec)(io, j) || (Fail() << "SetRec(" << j << ')', 0);
+    IONAME(OutputInteger64)(io, j) || (Fail() << "OutputInteger64()", 0);
+    IONAME(EndIoStatement)
+    (io) == IostatOk || (Fail() << "EndIoStatement() for OutputInteger64", 0);
+  }
+  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__);
+    IONAME(SetRec)(io, j) || (Fail() << "SetRec(" << j << ')', 0);
+    std::int64_t buffer;
+    IONAME(InputInteger)(io, buffer) || (Fail() << "InputInteger()", 0);
+    IONAME(EndIoStatement)
+    (io) == IostatOk || (Fail() << "EndIoStatement() for InputInteger", 0);
+    if (buffer != j) {
+      Fail() << "Read back " << buffer << " from direct formatted record " << j
+             << ", expected " << j << '\n';
+    }
+  }
+  // CLOSE(UNIT=unit,STATUS='DELETE')
+  io = IONAME(BeginClose)(unit, __FILE__, __LINE__);
+  IONAME(SetStatus)(io, "DELETE", 6) || (Fail() << "SetStatus(DELETE)", 0);
+  IONAME(EndIoStatement)
+  (io) == IostatOk || (Fail() << "EndIoStatement() for Close", 0);
+  llvm::errs() << "end TestDirectformatted()\n";
+}
+
+void TestSequentialVariableFormatted() {
+  llvm::errs() << "begin TestSequentialVariableFormatted()\n";
+  // OPEN(NEWUNIT=unit,ACCESS='SEQUENTIAL',ACTION='READWRITE',&
+  //   FORM='FORMATTED',STATUS='SCRATCH')
+  auto io{IONAME(BeginOpenNewUnit)(__FILE__, __LINE__)};
+  IONAME(SetAccess)
+  (io, "SEQUENTIAL", 10) || (Fail() << "SetAccess(SEQUENTIAL)", 0);
+  IONAME(SetAction)
+  (io, "READWRITE", 9) || (Fail() << "SetAction(READWRITE)", 0);
+  IONAME(SetForm)
+  (io, "FORMATTED", 9) || (Fail() << "SetForm(FORMATTED)", 0);
+  IONAME(SetStatus)(io, "SCRATCH", 7) || (Fail() << "SetStatus(SCRATCH)", 0);
+  int unit{-1};
+  IONAME(GetNewUnit)(io, unit) || (Fail() << "GetNewUnit()", 0);
+  llvm::errs() << "unit=" << unit << '\n';
+  IONAME(EndIoStatement)
+  (io) == IostatOk || (Fail() << "EndIoStatement() for OpenNewUnit", 0);
+  static const int records{10};
+  std::int64_t buffer[records]; // INTEGER*8 :: BUFFER(0:9) = [(j,j=0,9)]
+  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__);
+    for (int k{0}; k < j; ++k) {
+      IONAME(OutputInteger64)
+      (io, buffer[k]) || (Fail() << "OutputInteger64()", 0);
+    }
+    IONAME(EndIoStatement)
+    (io) == IostatOk || (Fail() << "EndIoStatement() for OutputInteger64", 0);
+  }
+  // REWIND(UNIT=unit)
+  io = IONAME(BeginRewind)(unit, __FILE__, __LINE__);
+  IONAME(EndIoStatement)
+  (io) == IostatOk || (Fail() << "EndIoStatement() for Rewind", 0);
+  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__);
+    std::int64_t check[records];
+    for (int k{0}; k < j; ++k) {
+      IONAME(InputInteger)(io, check[k]) || (Fail() << "InputInteger()", 0);
+    }
+    IONAME(EndIoStatement)
+    (io) == IostatOk || (Fail() << "EndIoStatement() for InputInteger", 0);
+    for (int k{0}; k < j; ++k) {
+      if (buffer[k] != check[k]) {
+        Fail() << "Read back [" << k << "]=" << check[k]
+               << " from sequential variable formatted record " << j
+               << ", expected " << buffer[k] << '\n';
+      }
+    }
+  }
+  for (int j{records}; j >= 1; --j) {
+    // BACKSPACE(unit)
+    io = IONAME(BeginBackspace)(unit, __FILE__, __LINE__);
+    IONAME(EndIoStatement)
+    (io) == IostatOk ||
+        (Fail() << "EndIoStatement() for Backspace (before read)", 0);
+    std::snprintf(fmt, sizeof fmt, "(%dI4)", j);
+    // READ(UNIT=unit,FMT=fmt) n; check
+    io = IONAME(BeginExternalFormattedInput)(
+        fmt, std::strlen(fmt), unit, __FILE__, __LINE__);
+    std::int64_t check[records];
+    for (int k{0}; k < j; ++k) {
+      IONAME(InputInteger)(io, check[k]) || (Fail() << "InputInteger()", 0);
+    }
+    IONAME(EndIoStatement)
+    (io) == IostatOk || (Fail() << "EndIoStatement() for InputInteger", 0);
+    for (int k{0}; k < j; ++k) {
+      if (buffer[k] != check[k]) {
+        Fail() << "Read back [" << k << "]=" << buffer[k]
+               << " from sequential variable formatted record " << j
+               << ", expected " << buffer[k] << '\n';
+      }
+    }
+    // BACKSPACE(unit)
+    io = IONAME(BeginBackspace)(unit, __FILE__, __LINE__);
+    IONAME(EndIoStatement)
+    (io) == IostatOk ||
+        (Fail() << "EndIoStatement() for Backspace (after read)", 0);
+  }
+  // CLOSE(UNIT=unit,STATUS='DELETE')
+  io = IONAME(BeginClose)(unit, __FILE__, __LINE__);
+  IONAME(SetStatus)(io, "DELETE", 6) || (Fail() << "SetStatus(DELETE)", 0);
+  IONAME(EndIoStatement)
+  (io) == IostatOk || (Fail() << "EndIoStatement() for Close", 0);
+  llvm::errs() << "end TestSequentialVariableFormatted()\n";
+}
+
+void TestStreamUnformatted() {
+  // TODO
+}
+
+int main() {
+  StartTests();
+  TestDirectUnformatted();
+  TestSequentialFixedUnformatted();
+  TestSequentialVariableUnformatted();
+  TestDirectFormatted();
+  TestSequentialVariableFormatted();
+  TestStreamUnformatted();
+  return EndTests();
+}

flang/unittests/Runtime/testing.h

 #ifndef FORTRAN_TEST_RUNTIME_TESTING_H_
 #define FORTRAN_TEST_RUNTIME_TESTING_H_
 
 #include "llvm/Support/raw_ostream.h"
 #include <cstddef>
 
 namespace llvm {
 class raw_ostream;
 }
 
 void StartTests();
 llvm::raw_ostream &Fail();
 int EndTests();
 
+// Defines a CHARACTER object with padding when needed
 void SetCharacter(char *, std::size_t, const char *);
 
 #endif // FORTRAN_TEST_RUNTIME_TESTING_H_

flang/unittests/Runtime/testing.cpp

 #include "testing.h"
 #include "../../runtime/terminator.h"
 #include <algorithm>
 #include <cstdarg>
 #include <cstdio>
 #include <cstring>
 #include <string>
 
 static int failures{0};
 
 // Override the Fortran runtime's Crash() for testing purposes
-[[noreturn]] static void CatchCrash(const char *message, va_list &ap) {
+[[noreturn]] static void CatchCrash(
+    const char *sourceFile, int sourceLine, const char *message, va_list &ap) {
   char buffer[1000];
   std::vsnprintf(buffer, sizeof buffer, message, ap);
   va_end(ap);
+  llvm::errs() << (sourceFile ? sourceFile : "unknown source file") << '('
+               << sourceLine << "): CRASH: " << buffer << '\n';
   throw std::string{buffer};
 }
 
 void StartTests() {
   Fortran::runtime::Terminator::RegisterCrashHandler(CatchCrash);
 }
 
 llvm::raw_ostream &Fail() {