[flang] Error recovery improvement in runtime (IOMSG=)

[klausler]

Summary

Some refactoring and related fixes for more accurate
user program error recovery in the I/O runtime, especially
for error recovery with IOMSG= character values.

1. Move any work in an EndIoStatement() implementation

that may raise an error into a new CompleteOperation()
member function. This allows error handling APIs like
GetIoMsg() to complete a pending I/O statement and harvest
any errors that may result.

2. Move the pending error code from ErroneousIoStatementState

to a new pendingError_ data member in IoErrorHandler.
This allows IoErrorHandler::InError() to return a correct
result when there is a pending error that will be recovered
from so that I/O list data transfers don't crash in the meantime.

3. Don't create and leak a unit for a failed OPEN(NEWUNIT=n)

with error recovery, and don't modify 'n'. (Depends on
changes to API call ordering in lowering, in a separate patch;
code was added to ensure that OPEN statement control list
specifiers, e.g. SetFile(), must be passed before GetNewUnit().)

4. Fix the code that calls a form of strerror to fill an

IOMSG= variable so that it actually works for Fortran's
character type: blank fill with no null or newline termination.

flang/runtime/descriptor-io.h

if (descriptor.IsContiguous()) { // contiguous unformatted I/O
       }
       return true;
     }
   }
 }
 
 template <Direction DIR>
 static bool DescriptorIO(IoStatementState &io, const Descriptor &descriptor) {
+  IoErrorHandler &handler{io.GetIoErrorHandler()};
+  if (handler.InError()) {
+    return false;
+  }
   if (!io.get_if<IoDirectionState<DIR>>()) {
     io.GetIoErrorHandler().Crash(
         "DescriptorIO() called for wrong I/O direction");
     return false;
   }
   if constexpr (DIR == Direction::Input) {
     if (!io.BeginReadingRecord()) {
       return false;
     }
   }
   if (!io.get_if<FormattedIoStatementState<DIR>>()) {
     return UnformattedDescriptorIO<DIR>(io, descriptor);
   }
-  IoErrorHandler &handler{io.GetIoErrorHandler()};
   if (auto catAndKind{descriptor.type().GetCategoryAndKind()}) {
     TypeCategory cat{catAndKind->first};
     int kind{catAndKind->second};
     switch (cat) {
     case TypeCategory::Integer:
       switch (kind) {
       case 1:
         return FormattedIntegerIO<1, DIR>(io, descriptor);

flang/runtime/io-api.cpp

 }
 
 bool IONAME(SetAccess)(Cookie cookie, const char *keyword, std::size_t length) {
   IoStatementState &io{*cookie};
   auto *open{io.get_if<OpenStatementState>()};
   if (!open) {
     io.GetIoErrorHandler().Crash(
         "SetAccess() called when not in an OPEN statement");
+  } else if (open->completedOperation()) {
+    io.GetIoErrorHandler().Crash(
+        "SetAccess() called after GetNewUnit() for an OPEN statement");
   }
   static const char *keywords[]{
       "SEQUENTIAL", "DIRECT", "STREAM", "APPEND", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
   case 0:
     open->set_access(Access::Sequential);
     break;
   case 1:

 }
 
 bool IONAME(SetAction)(Cookie cookie, const char *keyword, std::size_t length) {
   IoStatementState &io{*cookie};
   auto *open{io.get_if<OpenStatementState>()};
   if (!open) {
     io.GetIoErrorHandler().Crash(
         "SetAction() called when not in an OPEN statement");
+  } else if (open->completedOperation()) {
+    io.GetIoErrorHandler().Crash(
+        "SetAction() called after GetNewUnit() for an OPEN statement");
   }
   std::optional<Action> action;
   static const char *keywords[]{"READ", "WRITE", "READWRITE", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
   case 0:
     action = Action::Read;
     break;
   case 1:

 
 bool IONAME(SetAsynchronous)(
     Cookie cookie, const char *keyword, std::size_t length) {
   IoStatementState &io{*cookie};
   auto *open{io.get_if<OpenStatementState>()};
   if (!open) {
     io.GetIoErrorHandler().Crash(
         "SetAsynchronous() called when not in an OPEN statement");
+  } else if (open->completedOperation()) {
+    io.GetIoErrorHandler().Crash(
+        "SetAsynchronous() called after GetNewUnit() for an OPEN statement");
   }
   static const char *keywords[]{"YES", "NO", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
   case 0:
     open->unit().set_mayAsynchronous(true);
     return true;
   case 1:
     open->unit().set_mayAsynchronous(false);
     return true;
   default:
     open->SignalError(IostatErrorInKeyword, "Invalid ASYNCHRONOUS='%.*s'",
         static_cast<int>(length), keyword);
     return false;
   }
 }
 
 bool IONAME(SetCarriagecontrol)(
     Cookie cookie, const char *keyword, std::size_t length) {
   IoStatementState &io{*cookie};
   auto *open{io.get_if<OpenStatementState>()};
   if (!open) {
     io.GetIoErrorHandler().Crash(
         "SetCarriageControl() called when not in an OPEN statement");
+  } else if (open->completedOperation()) {
+    io.GetIoErrorHandler().Crash(
+        "SetCarriageControl() called after GetNewUnit() for an OPEN statement");
   }
   static const char *keywords[]{"LIST", "FORTRAN", "NONE", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
   case 0:
     return true;
   case 1:
   case 2:
     open->SignalError(IostatErrorInKeyword,

 
 bool IONAME(SetConvert)(
     Cookie cookie, const char *keyword, std::size_t length) {
   IoStatementState &io{*cookie};
   auto *open{io.get_if<OpenStatementState>()};
   if (!open) {
     io.GetIoErrorHandler().Crash(
         "SetConvert() called when not in an OPEN statement");
+  } else if (open->completedOperation()) {
+    io.GetIoErrorHandler().Crash(
+        "SetConvert() called after GetNewUnit() for an OPEN statement");
   }
   if (auto convert{GetConvertFromString(keyword, length)}) {
     open->set_convert(*convert);
     return true;
   } else {
     open->SignalError(IostatErrorInKeyword, "Invalid CONVERT='%.*s'",
         static_cast<int>(length), keyword);
     return false;
   }
 }
 
 bool IONAME(SetEncoding)(
     Cookie cookie, const char *keyword, std::size_t length) {
   IoStatementState &io{*cookie};
   auto *open{io.get_if<OpenStatementState>()};
   if (!open) {
     io.GetIoErrorHandler().Crash(
         "SetEncoding() called when not in an OPEN statement");
+  } else if (open->completedOperation()) {
+    io.GetIoErrorHandler().Crash(
+        "SetEncoding() called after GetNewUnit() for an OPEN statement");
   }
   bool isUTF8{false};
   static const char *keywords[]{"UTF-8", "DEFAULT", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
   case 0:
     isUTF8 = true;
     break;
   case 1:

 }
 
 bool IONAME(SetForm)(Cookie cookie, const char *keyword, std::size_t length) {
   IoStatementState &io{*cookie};
   auto *open{io.get_if<OpenStatementState>()};
   if (!open) {
     io.GetIoErrorHandler().Crash(
         "SetForm() called when not in an OPEN statement");
+  } else if (open->completedOperation()) {
+    io.GetIoErrorHandler().Crash(
+        "SetForm() called after GetNewUnit() for an OPEN statement");
   }
   static const char *keywords[]{"FORMATTED", "UNFORMATTED", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
   case 0:
     open->set_isUnformatted(false);
     break;
   case 1:
     open->set_isUnformatted(true);
     break;
   default:
     open->SignalError(IostatErrorInKeyword, "Invalid FORM='%.*s'",
         static_cast<int>(length), keyword);
   }
   return true;
 }
 
 bool IONAME(SetPosition)(
     Cookie cookie, const char *keyword, std::size_t length) {
   IoStatementState &io{*cookie};
   auto *open{io.get_if<OpenStatementState>()};
   if (!open) {
     io.GetIoErrorHandler().Crash(
         "SetPosition() called when not in an OPEN statement");
+  } else if (open->completedOperation()) {
+    io.GetIoErrorHandler().Crash(
+        "SetPosition() called after GetNewUnit() for an OPEN statement");
   }
   static const char *positions[]{"ASIS", "REWIND", "APPEND", nullptr};
   switch (IdentifyValue(keyword, length, positions)) {
   case 0:
     open->set_position(Position::AsIs);
     return true;
   case 1:
     open->set_position(Position::Rewind);

 }
 
 bool IONAME(SetRecl)(Cookie cookie, std::size_t n) {
   IoStatementState &io{*cookie};
   auto *open{io.get_if<OpenStatementState>()};
   if (!open) {
     io.GetIoErrorHandler().Crash(
         "SetRecl() called when not in an OPEN statement");
+  } else if (open->completedOperation()) {
+    io.GetIoErrorHandler().Crash(
+        "SetRecl() called after GetNewUnit() for an OPEN statement");
   }
   if (n <= 0) {
     io.GetIoErrorHandler().SignalError("RECL= must be greater than zero");
     return false;
   } else if (open->wasExtant() &&
       open->unit().openRecl.value_or(0) != static_cast<std::int64_t>(n)) {
     open->SignalError("RECL= may not be changed for an open unit");
     return false;
   } else {
     open->unit().openRecl = 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>()}) {
+    if (open->completedOperation()) {
+      io.GetIoErrorHandler().Crash(
+          "SetStatus() called after GetNewUnit() for an OPEN statement");
+    }
     static const char *statuses[]{
         "OLD", "NEW", "SCRATCH", "REPLACE", "UNKNOWN", nullptr};
     switch (IdentifyValue(keyword, length, statuses)) {
     case 0:
       open->set_status(OpenStatus::Old);
       return true;
     case 1:
       open->set_status(OpenStatus::New);
bool IONAME(SetStatus)(Cookie cookie, const char *keyword, std::size_t length) {
   }
   io.GetIoErrorHandler().Crash(
       "SetStatus() called when not in an OPEN or CLOSE statement");
 }
 
 bool IONAME(SetFile)(Cookie cookie, const char *path, std::size_t chars) {
   IoStatementState &io{*cookie};
   if (auto *open{io.get_if<OpenStatementState>()}) {
+    if (open->completedOperation()) {
+      io.GetIoErrorHandler().Crash(
+          "SetFile() called after GetNewUnit() for an OPEN statement");
+    }
     open->set_path(path, chars);
     return true;
   }
   io.GetIoErrorHandler().Crash(
       "SetFile() called when not in an OPEN statement");
   return false;
 }
 
 bool IONAME(GetNewUnit)(Cookie cookie, int &unit, int kind) {
   IoStatementState &io{*cookie};
   auto *open{io.get_if<OpenStatementState>()};
   if (!open) {
     io.GetIoErrorHandler().Crash(
         "GetNewUnit() called when not in an OPEN statement");
+  } else if (!open->InError()) {
+    open->CompleteOperation();
+  }
+  if (open->InError()) {
+    // A failed OPEN(NEWUNIT=n) does not modify 'n'
+    return false;
   }
   std::int64_t result{open->unit().unitNumber()};
   if (!SetInteger(unit, kind, result)) {
     open->SignalError("GetNewUnit(): bad INTEGER kind(%d) or out-of-range "
                       "value(%jd) for result",
         kind, static_cast<std::intmax_t>(result));
   }
   return true;
bool IONAME(OutputUnformattedBlock)(Cookie cookie, const char *x,
   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, std::size_t elementBytes) {
   IoStatementState &io{*cookie};
+  IoErrorHandler &handler{io.GetIoErrorHandler()};
   io.BeginReadingRecord();
-  if (io.GetIoErrorHandler().InError()) {
+  if (handler.InError()) {
     return false;
   }
   if (auto *unf{
           io.get_if<ExternalUnformattedIoStatementState<Direction::Input>>()}) {
     return unf->Receive(x, length, elementBytes);
   }
-  io.GetIoErrorHandler().Crash("InputUnformattedBlock() called for an I/O "
-                               "statement that is not unformatted output");
+  handler.Crash("InputUnformattedBlock() called for an I/O statement that is "
+                "not unformatted input");
   return false;
 }
 
 bool IONAME(OutputInteger8)(Cookie cookie, std::int8_t n) {
   cookie->CheckFormattedStmtType<Direction::Output>("OutputInteger8");
   StaticDescriptor staticDescriptor;
   Descriptor &descriptor{staticDescriptor.descriptor()};
   descriptor.Establish(
bool IONAME(InputLogical)(Cookie cookie, bool &truth) {
   Descriptor &descriptor{staticDescriptor.descriptor()};
   descriptor.Establish(
       TypeCategory::Logical, sizeof truth, reinterpret_cast<void *>(&truth), 0);
   return descr::DescriptorIO<Direction::Input>(*cookie, descriptor);
 }
 
 std::size_t IONAME(GetSize)(Cookie cookie) {
   IoStatementState &io{*cookie};
+  IoErrorHandler &handler{io.GetIoErrorHandler()};
+  if (!handler.InError()) {
+    io.CompleteOperation();
+  }
   if (const auto *formatted{
           io.get_if<FormattedIoStatementState<Direction::Input>>()}) {
     return formatted->GetEditDescriptorChars();
   }
-  io.GetIoErrorHandler().Crash(
+  handler.Crash(
       "GetIoSize() called for an I/O statement that is not a formatted READ()");
   return 0;
 }
 
 std::size_t IONAME(GetIoLength)(Cookie cookie) {
   IoStatementState &io{*cookie};
+  IoErrorHandler &handler{io.GetIoErrorHandler()};
+  if (!handler.InError()) {
+    io.CompleteOperation();
+  }
   if (const auto *inq{io.get_if<InquireIOLengthState>()}) {
     return inq->bytes();
   }
-  io.GetIoErrorHandler().Crash("GetIoLength() called for an I/O statement that "
-                               "is not INQUIRE(IOLENGTH=)");
+  handler.Crash("GetIoLength() called for an I/O statement that is not "
+                "INQUIRE(IOLENGTH=)");
   return 0;
 }
 
 void IONAME(GetIoMsg)(Cookie cookie, char *msg, std::size_t length) {
-  IoErrorHandler &handler{cookie->GetIoErrorHandler()};
+  IoStatementState &io{*cookie};
+  IoErrorHandler &handler{io.GetIoErrorHandler()};
+  if (!handler.InError()) {
+    io.CompleteOperation();
+  }
   if (handler.InError()) { // leave "msg" alone when no error
     handler.GetIoMsg(msg, length);
   }
 }
 
 bool IONAME(InquireCharacter)(Cookie cookie, InquiryKeywordHash inquiry,
     char *result, std::size_t length) {
   IoStatementState &io{*cookie};

flang/runtime/io-error.h

public:
   void HasErrLabel() { flags_ |= hasErr; }
   void HasEndLabel() { flags_ |= hasEnd; }
   void HasEorLabel() { flags_ |= hasEor; }
   void HasIoMsg() { flags_ |= hasIoMsg; }
   void HandleAnything() {
     flags_ = hasIoStat | hasErr | hasEnd | hasEor | hasIoMsg;
   }
 
-  bool InError() const { return ioStat_ != IostatOk; }
+  bool InError() const {
+    return ioStat_ != IostatOk || pendingError_ != IostatOk;
+  }
+
+  // For I/O statements that detect fatal errors in their
+  // Begin...() API routines before it is known whether they
+  // have error handling control list items.  Such statements
+  // have an ErroneousIoStatementState with a pending error.
+  void SetPendingError(int iostat) { pendingError_ = iostat; }
 
   void SignalError(int iostatOrErrno, const char *msg, ...);
   void SignalError(int iostatOrErrno);
   template <typename... X> void SignalError(const char *msg, X &&...xs) {
     SignalError(IostatGenericError, msg, std::forward<X>(xs)...);
   }
 
   void Forward(int iostatOrErrno, const char *, std::size_t);
 
   void SignalErrno(); // SignalError(errno)
   void SignalEnd(); // input only; EOF on internal write is an error
   void SignalEor(); // non-advancing input only; EOR on write is an error
+  void SignalPendingError();
 
   int GetIoStat() const { return ioStat_; }
   bool GetIoMsg(char *, std::size_t);
 
 private:
   enum Flag : std::uint8_t {
     hasIoStat = 1, // IOSTAT=
     hasErr = 2, // ERR=
     hasEnd = 4, // END=
     hasEor = 8, // EOR=
     hasIoMsg = 16, // IOMSG=
   };
   std::uint8_t flags_{0};
   int ioStat_{IostatOk};
   OwningPtr<char> ioMsg_;
+  int pendingError_{IostatOk};
 };
 
 } // namespace Fortran::runtime::io
 #endif // FORTRAN_RUNTIME_IO_ERROR_H_

flang/runtime/io-error.cpp

if (iostatOrErrno == IostatEnd && (flags_ & hasEnd)) {
     if (ioStat_ == IostatOk || ioStat_ < IostatEnd) {
       ioStat_ = IostatEnd;
     }
   } else if (iostatOrErrno == IostatEor && (flags_ & hasEor)) {
     if (ioStat_ == IostatOk || ioStat_ < IostatEor) {
       ioStat_ = IostatEor; // least priority
     }
   } else if (iostatOrErrno != IostatOk) {
-    if (flags_ & (hasIoStat | hasErr)) {
+    if (flags_ & (hasIoStat | hasIoMsg | hasErr)) {
       if (ioStat_ <= 0) {
         ioStat_ = iostatOrErrno; // priority over END=/EOR=
         if (msg && (flags_ & hasIoMsg)) {
           char buffer[256];
           va_list ap;
           va_start(ap, msg);
           std::vsnprintf(buffer, sizeof buffer, msg, ap);
           ioMsg_ = SaveDefaultCharacter(buffer, std::strlen(buffer) + 1, *this);

 }
 
 void IoErrorHandler::SignalErrno() { SignalError(errno); }
 
 void IoErrorHandler::SignalEnd() { SignalError(IostatEnd); }
 
 void IoErrorHandler::SignalEor() { SignalError(IostatEor); }
 
+void IoErrorHandler::SignalPendingError() {
+  int error{pendingError_};
+  pendingError_ = IostatOk;
+  SignalError(error);
+}
+
 bool IoErrorHandler::GetIoMsg(char *buffer, std::size_t bufferLength) {
   const char *msg{ioMsg_.get()};
   if (!msg) {
-    msg = IostatErrorString(ioStat_);
+    msg = IostatErrorString(ioStat_ == IostatOk ? pendingError_ : ioStat_);
   }
   if (msg) {
     ToFortranDefaultCharacter(buffer, bufferLength, msg);
     return true;
   }
 
-  char *newBuf;
   // Following code is taken from llvm/lib/Support/Errno.cpp
-  // in LLVM v9.0.1
+  // in LLVM v9.0.1 with inadequate modification for Fortran,
+  // since rectified.
+  bool ok{false};
 #if HAVE_STRERROR_R
   // strerror_r is thread-safe.
 #if defined(__GLIBC__) && defined(_GNU_SOURCE)
   // glibc defines its own incompatible version of strerror_r
   // which may not use the buffer supplied.
-  newBuf = ::strerror_r(ioStat_, buffer, bufferLength);
+  msg = ::strerror_r(ioStat_, buffer, bufferLength);
 #else
-  return ::strerror_r(ioStat_, buffer, bufferLength) == 0;
+  ok = ::strerror_r(ioStat_, buffer, bufferLength) == 0;
 #endif
 #elif HAVE_DECL_STRERROR_S // "Windows Secure API"
-  return ::strerror_s(buffer, bufferLength, ioStat_) == 0;
+  ok = ::strerror_s(buffer, bufferLength, ioStat_) == 0;
 #elif HAVE_STRERROR
   // Copy the thread un-safe result of strerror into
   // the buffer as fast as possible to minimize impact
   // of collision of strerror in multiple threads.
-  newBuf = strerror(ioStat_);
+  msg = strerror(ioStat_);
 #else
   // Strange that this system doesn't even have strerror
   return false;
 #endif
-  ::strncpy(buffer, newBuf, bufferLength - 1);
-  buffer[bufferLength - 1] = '\n';
+  if (msg) {
+    ToFortranDefaultCharacter(buffer, bufferLength, msg);
     return true;
+  } else if (ok) {
+    std::size_t copied{std::strlen(buffer)};
+    if (copied < bufferLength) {
+      std::memset(buffer + copied, ' ', bufferLength - copied);
+    }
+    return true;
+  } else {
+    return false;
+  }
 }
 } // namespace Fortran::runtime::io

flang/runtime/io-stmt.h

 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)
   // to interact with the state of the I/O statement in progress.
   // This design avoids virtual member functions and function pointers,
   // which may not have good support in some runtime environments.
+
+  // CompleteOperation() is the last opportunity to raise an I/O error.
+  // It is called by EndIoStatement(), but it can be invoked earlier to
+  // catch errors for (e.g.) GetIoMsg() and GetNewUnit().  If called
+  // more than once, it is a no-op.
+  void CompleteOperation();
+  // Completes an I/O statement and reclaims storage.
   int EndIoStatement();
+
   bool Emit(const char *, std::size_t, std::size_t elementBytes);
   bool Emit(const char *, std::size_t);
   bool Emit(const char16_t *, std::size_t chars);
   bool Emit(const char32_t *, std::size_t chars);
   bool Receive(char *, std::size_t, std::size_t elementBytes = 0);
   std::size_t GetNextInputBytes(const char *&);
   bool AdvanceRecord(int = 1);
   void BackspaceRecord();
std::variant<std::reference_wrapper<OpenStatementState>,
       std::reference_wrapper<InquireUnconnectedFileState>,
       std::reference_wrapper<InquireIOLengthState>,
       std::reference_wrapper<ExternalMiscIoStatementState>,
       std::reference_wrapper<ErroneousIoStatementState>>
       u_;
 };
 
 // Base class for all per-I/O statement state classes.
-struct IoStatementBase : public IoErrorHandler {
+class IoStatementBase : public IoErrorHandler {
+public:
   using IoErrorHandler::IoErrorHandler;
 
+  bool completedOperation() const { return completedOperation_; }
+
+  void CompleteOperation() { completedOperation_ = true; }
+  int EndIoStatement() { return GetIoStat(); }
+
   // These are default no-op backstops that can be overridden by descendants.
-  int EndIoStatement();
   bool Emit(const char *, std::size_t, std::size_t elementBytes);
   bool Emit(const char *, std::size_t);
   bool Emit(const char16_t *, std::size_t chars);
   bool Emit(const char32_t *, std::size_t chars);
   bool Receive(char *, std::size_t, std::size_t elementBytes = 0);
   std::size_t GetNextInputBytes(const char *&);
   bool AdvanceRecord(int);
   void BackspaceRecord();
   void HandleRelativePosition(std::int64_t);
   void HandleAbsolutePosition(std::int64_t);
   std::optional<DataEdit> GetNextDataEdit(
       IoStatementState &, int maxRepeat = 1);
   ExternalFileUnit *GetExternalFileUnit() const;
   bool BeginReadingRecord();
   void FinishReadingRecord();
   bool Inquire(InquiryKeywordHash, char *, std::size_t);
   bool Inquire(InquiryKeywordHash, bool &);
   bool Inquire(InquiryKeywordHash, std::int64_t, bool &);
   bool Inquire(InquiryKeywordHash, std::int64_t &);
 
   void BadInquiryKeywordHashCrash(InquiryKeywordHash);
+
+protected:
+  bool completedOperation_{false};
 };
 
 // Common state for list-directed & NAMELIST I/O, both internal & external
 template <Direction> class ListDirectedStatementState;
 template <>
 class ListDirectedStatementState<Direction::Output>
     : public FormattedIoStatementState<Direction::Output> {
 public:
public:
   using typename InternalIoStatementState<DIR, CharType>::Buffer;
   InternalFormattedIoStatementState(Buffer internal, std::size_t internalLength,
       const CharType *format, std::size_t formatLength,
       const char *sourceFile = nullptr, int sourceLine = 0);
   InternalFormattedIoStatementState(const Descriptor &, const CharType *format,
       std::size_t formatLength, const char *sourceFile = nullptr,
       int sourceLine = 0);
   IoStatementState &ioStatementState() { return ioStatementState_; }
+  void CompleteOperation();
   int EndIoStatement();
   std::optional<DataEdit> GetNextDataEdit(
       IoStatementState &, int maxRepeat = 1) {
     return format_.GetNextDataEdit(*this, maxRepeat);
   }
 
 private:
   IoStatementState ioStatementState_; // points to *this

 
 class ExternalIoStatementBase : public IoStatementBase {
 public:
   ExternalIoStatementBase(
       ExternalFileUnit &, const char *sourceFile = nullptr, int sourceLine = 0);
   ExternalFileUnit &unit() { return unit_; }
   MutableModes &mutableModes();
   ConnectionState &GetConnectionState();
+  void CompleteOperation();
   int EndIoStatement();
   ExternalFileUnit *GetExternalFileUnit() const { return &unit_; }
 
 private:
   ExternalFileUnit &unit_;
 };
 
 template <Direction DIR>
 class ExternalIoStatementState : public ExternalIoStatementBase,
                                  public IoDirectionState<DIR> {
 public:
   ExternalIoStatementState(
       ExternalFileUnit &, const char *sourceFile = nullptr, int sourceLine = 0);
   MutableModes &mutableModes() { return mutableModes_; }
+  void CompleteOperation();
   int EndIoStatement();
   bool Emit(const char *, std::size_t, std::size_t elementBytes);
   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::size_t GetNextInputBytes(const char *&);
   bool AdvanceRecord(int = 1);
   void BackspaceRecord();

 class ExternalFormattedIoStatementState
     : public ExternalIoStatementState<DIR>,
       public FormattedIoStatementState<DIR> {
 public:
   using CharType = CHAR;
   ExternalFormattedIoStatementState(ExternalFileUnit &, const CharType *format,
       std::size_t formatLength, const char *sourceFile = nullptr,
       int sourceLine = 0);
+  void CompleteOperation();
   int EndIoStatement();
   std::optional<DataEdit> GetNextDataEdit(
       IoStatementState &, int maxRepeat = 1) {
     return format_.GetNextDataEdit(*this, maxRepeat);
   }
 
 private:
   FormatControl<ExternalFormattedIoStatementState> format_;
class ChildIoStatementState : public IoStatementBase,
                               public IoDirectionState<DIR> {
 public:
   ChildIoStatementState(
       ChildIo &, const char *sourceFile = nullptr, int sourceLine = 0);
   ChildIo &child() { return child_; }
   MutableModes &mutableModes();
   ConnectionState &GetConnectionState();
   ExternalFileUnit *GetExternalFileUnit() const;
+  void CompleteOperation();
   int EndIoStatement();
   bool Emit(const char *, std::size_t, std::size_t elementBytes);
   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::size_t GetNextInputBytes(const char *&);
   void HandleRelativePosition(std::int64_t);
   void HandleAbsolutePosition(std::int64_t);
 
 private:
   ChildIo &child_;
 };
 
 template <Direction DIR, typename CHAR>
 class ChildFormattedIoStatementState : public ChildIoStatementState<DIR>,
                                        public FormattedIoStatementState<DIR> {
 public:
   using CharType = CHAR;
   ChildFormattedIoStatementState(ChildIo &, const CharType *format,
       std::size_t formatLength, const char *sourceFile = nullptr,
       int sourceLine = 0);
   MutableModes &mutableModes() { return mutableModes_; }
+  void CompleteOperation();
   int EndIoStatement();
   bool AdvanceRecord(int = 1);
   std::optional<DataEdit> GetNextDataEdit(
       IoStatementState &, int maxRepeat = 1) {
     return format_.GetNextDataEdit(*this, maxRepeat);
   }
 
 private:
public:
   bool wasExtant() const { return wasExtant_; }
   void set_status(OpenStatus status) { status_ = status; } // STATUS=
   void set_path(const char *, std::size_t); // FILE=
   void set_position(Position position) { position_ = position; } // POSITION=
   void set_action(Action action) { action_ = action; } // ACTION=
   void set_convert(Convert convert) { convert_ = convert; } // CONVERT=
   void set_access(Access access) { access_ = access; } // ACCESS=
   void set_isUnformatted(bool yes = true) { isUnformatted_ = yes; } // FORM=
+
+  void CompleteOperation();
   int EndIoStatement();
 
 private:
   bool wasExtant_;
   std::optional<OpenStatus> status_;
   std::optional<Position> position_;
   std::optional<Action> action_;
   Convert convert_{Convert::Native};

 };
 
 // For CLOSE(bad unit) and INQUIRE(unconnected unit)
 class NoUnitIoStatementState : public IoStatementBase {
 public:
   IoStatementState &ioStatementState() { return ioStatementState_; }
   MutableModes &mutableModes() { return connection_.modes; }
   ConnectionState &GetConnectionState() { return connection_; }
+  void CompleteOperation();
   int EndIoStatement();
 
 protected:
   template <typename A>
   NoUnitIoStatementState(const char *sourceFile, int sourceLine, A &stmt)
       : IoStatementBase{sourceFile, sourceLine}, ioStatementState_{stmt} {}
 
 private:

 };
 
 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} {}
+  void CompleteOperation();
   int EndIoStatement();
 
 private:
   Which which_;
 };
 
 class ErroneousIoStatementState : public IoStatementBase {
 public:
   explicit ErroneousIoStatementState(
       Iostat iostat, const char *sourceFile = nullptr, int sourceLine = 0)
-      : IoStatementBase{sourceFile, sourceLine}, iostat_{iostat} {}
+      : IoStatementBase{sourceFile, sourceLine} {
+    SetPendingError(iostat);
+  }
   int EndIoStatement();
   ConnectionState &GetConnectionState() { return connection_; }
   MutableModes &mutableModes() { return connection_.modes; }
 
 private:
-  Iostat iostat_;
   ConnectionState connection_;
 };
 
 } // namespace Fortran::runtime::io
 #endif // FORTRAN_RUNTIME_IO_STMT_H_

flang/runtime/io-stmt.cpp

 #include "flang/Runtime/memory.h"
 #include <algorithm>
 #include <cstdio>
 #include <cstring>
 #include <limits>
 
 namespace Fortran::runtime::io {
 
-int IoStatementBase::EndIoStatement() { return GetIoStat(); }
-
 bool IoStatementBase::Emit(const char *, std::size_t, std::size_t) {
   return false;
 }
 
 bool IoStatementBase::Emit(const char *, std::size_t) { return false; }
 
 bool IoStatementBase::Emit(const char16_t *, std::size_t) { return false; }
 

 template <Direction DIR, typename CHAR>
 InternalFormattedIoStatementState<DIR, CHAR>::InternalFormattedIoStatementState(
     const Descriptor &d, const CHAR *format, std::size_t formatLength,
     const char *sourceFile, int sourceLine)
     : InternalIoStatementState<DIR, CHAR>{d, sourceFile, sourceLine},
       ioStatementState_{*this}, format_{*this, format, formatLength} {}
 
 template <Direction DIR, typename CHAR>
-int InternalFormattedIoStatementState<DIR, CHAR>::EndIoStatement() {
+void InternalFormattedIoStatementState<DIR, CHAR>::CompleteOperation() {
+  if (!this->completedOperation()) {
     if constexpr (DIR == Direction::Output) {
       format_.Finish(*this); // ignore any remaining input positioning actions
     }
+    IoStatementBase::CompleteOperation();
+  }
+}
+
+template <Direction DIR, typename CHAR>
+int InternalFormattedIoStatementState<DIR, CHAR>::EndIoStatement() {
+  CompleteOperation();
   return InternalIoStatementState<DIR, CHAR>::EndIoStatement();
 }
 
 template <Direction DIR, typename CHAR>
 InternalListIoStatementState<DIR, CHAR>::InternalListIoStatementState(
     Buffer buffer, std::size_t length, const char *sourceFile, int sourceLine)
     : InternalIoStatementState<DIR, CharType>{buffer, length, sourceFile,
           sourceLine},
       ioStatementState_{*this} {}
 
 template <Direction DIR, typename CHAR>
 InternalListIoStatementState<DIR, CHAR>::InternalListIoStatementState(
     const Descriptor &d, const char *sourceFile, int sourceLine)
     : InternalIoStatementState<DIR, CharType>{d, sourceFile, sourceLine},
       ioStatementState_{*this} {}
 
 ExternalIoStatementBase::ExternalIoStatementBase(
     ExternalFileUnit &unit, const char *sourceFile, int sourceLine)
     : IoStatementBase{sourceFile, sourceLine}, unit_{unit} {}
 
 MutableModes &ExternalIoStatementBase::mutableModes() { return unit_.modes; }
 
 ConnectionState &ExternalIoStatementBase::GetConnectionState() { return unit_; }
 
-int ExternalIoStatementBase::EndIoStatement() {
+void ExternalIoStatementBase::CompleteOperation() {
+  if (!completedOperation()) {
     if (mutableModes().nonAdvancing) {
       unit_.leftTabLimit = unit_.furthestPositionInRecord;
     } else {
       unit_.leftTabLimit.reset();
     }
+    IoStatementBase::CompleteOperation();
+  }
+}
+
+int ExternalIoStatementBase::EndIoStatement() {
+  CompleteOperation();
   auto result{IoStatementBase::EndIoStatement()};
   unit_.EndIoStatement(); // annihilates *this in unit_.u_
   return result;
 }
 
 void OpenStatementState::set_path(const char *path, std::size_t length) {
   pathLength_ = TrimTrailingSpaces(path, length);
   path_ = SaveDefaultCharacter(path, pathLength_, *this);
 }
 
-int OpenStatementState::EndIoStatement() {
+void OpenStatementState::CompleteOperation() {
+  if (completedOperation()) {
+    return;
+  }
   if (position_) {
     if (access_ && *access_ == Access::Direct) {
       SignalError("POSITION= may not be set with ACCESS='DIRECT'");
       position_.reset();
     }
   }
   if (path_.get() || wasExtant_ ||
       (status_ && *status_ == OpenStatus::Scratch)) {
if (wasExtant_) {
       SignalError("FORM= may not be changed on an open unit");
     }
     unit().isUnformatted = *isUnformatted_;
   }
   if (!unit().isUnformatted) {
     // Set default format (C.7.4 point 2).
     unit().isUnformatted = unit().access != Access::Sequential;
   }
+  if (!wasExtant_ && InError()) {
+    // Release the new unit on failure
+    unit().CloseUnit(CloseStatus::Delete, *this);
+    unit().DestroyClosed();
+  }
+  IoStatementBase::CompleteOperation();
+}
+
+int OpenStatementState::EndIoStatement() {
+  CompleteOperation();
   return ExternalIoStatementBase::EndIoStatement();
 }
 
 int CloseStatementState::EndIoStatement() {
+  CompleteOperation();
   int result{ExternalIoStatementBase::EndIoStatement()};
   unit().CloseUnit(status_, *this);
   unit().DestroyClosed();
   return result;
 }
 
+void NoUnitIoStatementState::CompleteOperation() {
+  IoStatementBase::CompleteOperation();
+}
+
 int NoUnitIoStatementState::EndIoStatement() {
+  CompleteOperation();
   auto result{IoStatementBase::EndIoStatement()};
   FreeMemory(this);
   return result;
 }
 
 template <Direction DIR>
 ExternalIoStatementState<DIR>::ExternalIoStatementState(
     ExternalFileUnit &unit, const char *sourceFile, int sourceLine)
     : ExternalIoStatementBase{unit, sourceFile, sourceLine}, mutableModes_{
                                                                  unit.modes} {
   if constexpr (DIR == Direction::Output) {
     // If the last statement was a non-advancing IO input statement, the unit
     // furthestPositionInRecord was not advanced, but the positionInRecord may
     // have been advanced. Advance furthestPositionInRecord here to avoid
     // overwriting the part of the record that has been read with blanks.
     unit.furthestPositionInRecord =
         std::max(unit.furthestPositionInRecord, unit.positionInRecord);
   }
 }
 
-template <Direction DIR> int ExternalIoStatementState<DIR>::EndIoStatement() {
+template <Direction DIR>
+void ExternalIoStatementState<DIR>::CompleteOperation() {
+  if (completedOperation()) {
+    return;
+  }
   if constexpr (DIR == Direction::Input) {
     BeginReadingRecord(); // in case there were no I/O items
     if (!mutableModes().nonAdvancing || GetIoStat() == IostatEor) {
       FinishReadingRecord();
     }
   } else {
     if (!mutableModes().nonAdvancing) {
       unit().AdvanceRecord(*this);
     }
     unit().FlushIfTerminal(*this);
   }
+  return ExternalIoStatementBase::CompleteOperation();
+}
+
+template <Direction DIR> int ExternalIoStatementState<DIR>::EndIoStatement() {
+  CompleteOperation();
   return ExternalIoStatementBase::EndIoStatement();
 }
 
 template <Direction DIR>
 bool ExternalIoStatementState<DIR>::Emit(
     const char *data, std::size_t bytes, std::size_t elementBytes) {
   if constexpr (DIR == Direction::Input) {
     Crash("ExternalIoStatementState::Emit(char) called for input statement");

 template <Direction DIR, typename CHAR>
 ExternalFormattedIoStatementState<DIR, CHAR>::ExternalFormattedIoStatementState(
     ExternalFileUnit &unit, const CHAR *format, std::size_t formatLength,
     const char *sourceFile, int sourceLine)
     : ExternalIoStatementState<DIR>{unit, sourceFile, sourceLine},
       format_{*this, format, formatLength} {}
 
 template <Direction DIR, typename CHAR>
-int ExternalFormattedIoStatementState<DIR, CHAR>::EndIoStatement() {
+void ExternalFormattedIoStatementState<DIR, CHAR>::CompleteOperation() {
+  if (this->completedOperation()) {
+    return;
+  }
   if constexpr (DIR == Direction::Input) {
     this->BeginReadingRecord(); // in case there were no I/O items
   }
   format_.Finish(*this);
+  return ExternalIoStatementState<DIR>::CompleteOperation();
+}
+
+template <Direction DIR, typename CHAR>
+int ExternalFormattedIoStatementState<DIR, CHAR>::EndIoStatement() {
+  CompleteOperation();
   return ExternalIoStatementState<DIR>::EndIoStatement();
 }
 
 std::optional<DataEdit> IoStatementState::GetNextDataEdit(int n) {
   return std::visit(
       [&](auto &x) { return x.get().GetNextDataEdit(*this, n); }, u_);
 }
 

 void IoStatementState::HandleRelativePosition(std::int64_t n) {
   std::visit([=](auto &x) { x.get().HandleRelativePosition(n); }, u_);
 }
 
 void IoStatementState::HandleAbsolutePosition(std::int64_t n) {
   std::visit([=](auto &x) { x.get().HandleAbsolutePosition(n); }, u_);
 }
 
+void IoStatementState::CompleteOperation() {
+  std::visit([](auto &x) { x.get().CompleteOperation(); }, u_);
+}
+
 int IoStatementState::EndIoStatement() {
   return std::visit([](auto &x) { return x.get().EndIoStatement(); }, u_);
 }
 
 ConnectionState &IoStatementState::GetConnectionState() {
   return std::visit(
       [](auto &x) -> ConnectionState & { return x.get().GetConnectionState(); },
       u_);
ConnectionState &ChildIoStatementState<DIR>::GetConnectionState() {
   return child_.parent().GetConnectionState();
 }
 
 template <Direction DIR>
 ExternalFileUnit *ChildIoStatementState<DIR>::GetExternalFileUnit() const {
   return child_.parent().GetExternalFileUnit();
 }
 
+template <Direction DIR> void ChildIoStatementState<DIR>::CompleteOperation() {
+  IoStatementBase::CompleteOperation();
+}
+
 template <Direction DIR> int ChildIoStatementState<DIR>::EndIoStatement() {
+  CompleteOperation();
   auto result{IoStatementBase::EndIoStatement()};
   child_.EndIoStatement(); // annihilates *this in child_.u_
   return result;
 }
 
 template <Direction DIR>
 bool ChildIoStatementState<DIR>::Emit(
     const char *data, std::size_t bytes, std::size_t elementBytes) {

 ChildFormattedIoStatementState<DIR, CHAR>::ChildFormattedIoStatementState(
     ChildIo &child, const CHAR *format, std::size_t formatLength,
     const char *sourceFile, int sourceLine)
     : ChildIoStatementState<DIR>{child, sourceFile, sourceLine},
       mutableModes_{child.parent().mutableModes()}, format_{*this, format,
                                                         formatLength} {}
 
 template <Direction DIR, typename CHAR>
-int ChildFormattedIoStatementState<DIR, CHAR>::EndIoStatement() {
+void ChildFormattedIoStatementState<DIR, CHAR>::CompleteOperation() {
+  if (!this->completedOperation()) {
     format_.Finish(*this);
+    ChildIoStatementState<DIR>::CompleteOperation();
+  }
+}
+
+template <Direction DIR, typename CHAR>
+int ChildFormattedIoStatementState<DIR, CHAR>::EndIoStatement() {
+  CompleteOperation();
   return ChildIoStatementState<DIR>::EndIoStatement();
 }
 
 template <Direction DIR, typename CHAR>
 bool ChildFormattedIoStatementState<DIR, CHAR>::AdvanceRecord(int) {
   return false; // no can do in a child I/O
 }
 

 template class ChildIoStatementState<Direction::Input>;
 template class ChildFormattedIoStatementState<Direction::Output>;
 template class ChildFormattedIoStatementState<Direction::Input>;
 template class ChildListIoStatementState<Direction::Output>;
 template class ChildListIoStatementState<Direction::Input>;
 template class ChildUnformattedIoStatementState<Direction::Output>;
 template class ChildUnformattedIoStatementState<Direction::Input>;
 
-int ExternalMiscIoStatementState::EndIoStatement() {
+void ExternalMiscIoStatementState::CompleteOperation() {
+  if (completedOperation()) {
+    return;
+  }
   ExternalFileUnit &ext{unit()};
   switch (which_) {
   case Flush:
     ext.FlushOutput(*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::CompleteOperation();
+}
+
+int ExternalMiscIoStatementState::EndIoStatement() {
+  CompleteOperation();
   return ExternalIoStatementBase::EndIoStatement();
 }
 
 InquireUnitState::InquireUnitState(
     ExternalFileUnit &unit, const char *sourceFile, int sourceLine)
     : ExternalIoStatementBase{unit, sourceFile, sourceLine} {}
 
 bool InquireUnitState::Inquire(

 }
 
 bool InquireIOLengthState::Emit(const char32_t *p, std::size_t n) {
   bytes_ += sizeof *p * n;
   return true;
 }
 
 int ErroneousIoStatementState::EndIoStatement() {
-  SignalError(iostat_);
+  SignalPendingError();
   return IoStatementBase::EndIoStatement();
 }
 
 } // namespace Fortran::runtime::io