[flang] Roll up small fixes to runtime bugs found in testing

[klausler]

Summary

Fix several bugs in the Fortran runtime found in initial
testing.

[PeteSteinfeld]

All builds, tests, and looks good.

[MaskRay]

@klausler

Hi, several people are tired of seeing arcanist boilerplate in commits. You can drop Reviewers: Subscribers: Tags: and the text Summary: from the git commit with the following script:

arcfilter () {
        arc amend
        git log -1 --pretty=%B | awk '/Reviewers:|Subscribers:/{p=1} /Reviewed By:|Differential Revision:/{p=0} !p && !/^Summary:$/ {sub(/^Summary: /,"");print}' | git commit --amend --date=now -F -
}

Reviewed By: is considered important by some people. Please keep the tag. (I have updated my script to use --date=now (setting author date to committer date))

https://reviews.llvm.org/D80978 contains a git pre-push hook to automate this.

flang/runtime/connection.h

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);
 
   // 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(positionInRecord)
+  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
 
   // currentRecordNumber value captured after ENDFILE/REWIND/BACKSPACE statement
   // or an end-of-file READ condition on a sequential access file
   std::optional<std::int64_t> endfileRecordNumber;
 
   // Mutable modes set at OPEN() that can be overridden in READ/WRITE & FORMAT
   MutableModes modes; // BLANK=, DECIMAL=, SIGN=, ROUND=, PAD=, DELIM=, kP
 };
 } // namespace Fortran::runtime::io
 #endif // FORTRAN_RUNTIME_IO_CONNECTION_H_

flang/runtime/format-implementation.h

 // Generally assumes that the format string has survived the common
 // format validator gauntlet.
 template <typename CONTEXT>
 int FormatControl<CONTEXT>::CueUpNextDataEdit(Context &context, bool stop) {
   int unlimitedLoopCheck{-1};
   while (true) {
     std::optional<int> repeat;
     bool unlimited{false};
-    CharType ch{Capitalize(GetNextChar(context))};
+    CharType ch{GetNextChar(context)};
     while (ch == ',' || ch == ':') {
       // Skip commas, and don't complain if they're missing; the format
       // validator does that.
       if (stop && ch == ':') {
         return 0;
       }
-      ch = Capitalize(GetNextChar(context));
+      ch = GetNextChar(context);
     }
     if (ch == '-' || ch == '+' || (ch >= '0' && ch <= '9')) {
       repeat = GetIntField(context, ch);
       ch = GetNextChar(context);
     } else if (ch == '*') {
       unlimited = true;
       ch = GetNextChar(context);
       if (ch != '(') {
         context.SignalError(IostatErrorInFormat,
             "Invalid FORMAT: '*' may appear only before '('");
         return 0;
       }
     }
+    ch = Capitalize(ch);
     if (ch == '(') {
       if (height_ >= maxHeight_) {
         context.SignalError(IostatErrorInFormat,
             "FORMAT stack overflow: too many nested parentheses");
         return 0;
       }
       stack_[height_].start = offset_ - 1; // the '('
       if (unlimited || height_ == 0) {

flang/runtime/stop.cpp

if (excepts & FE_OVERFLOW) {
       std::fputs(" OVERFLOW", stderr);
     }
     if (excepts & FE_UNDERFLOW) {
       std::fputs(" UNDERFLOW", stderr);
     }
   }
 }
 
+static void CloseAllExternalUnits(const char *why) {
+  Fortran::runtime::io::IoErrorHandler handler{why};
+  Fortran::runtime::io::ExternalFileUnit::CloseAll(handler);
+}
+
 [[noreturn]] void RTNAME(StopStatement)(
     int code, bool isErrorStop, bool quiet) {
+  CloseAllExternalUnits("STOP statement");
   if (!quiet) {
     if (code != EXIT_SUCCESS) {
       std::fprintf(stderr, "Fortran %s: code %d\n",
           isErrorStop ? "ERROR STOP" : "STOP", code);
     }
     DescribeIEEESignaledExceptions();
   }
   std::exit(code);
 }
 
 [[noreturn]] void RTNAME(StopStatementText)(
     const char *code, bool isErrorStop, bool quiet) {
+  CloseAllExternalUnits("STOP statement");
   if (!quiet) {
     std::fprintf(
         stderr, "Fortran %s: %s\n", isErrorStop ? "ERROR STOP" : "STOP", code);
     DescribeIEEESignaledExceptions();
   }
   std::exit(EXIT_FAILURE);
 }
 
 [[noreturn]] void RTNAME(FailImageStatement)() {
   Fortran::runtime::NotifyOtherImagesOfFailImageStatement();
+  CloseAllExternalUnits("FAIL IMAGE statement");
   std::exit(EXIT_FAILURE);
 }
 
 [[noreturn]] void RTNAME(ProgramEndStatement)() {
-  Fortran::runtime::io::IoErrorHandler handler{"END statement"};
-  Fortran::runtime::io::ExternalFileUnit::CloseAll(handler);
+  CloseAllExternalUnits("END statement");
   std::exit(EXIT_SUCCESS);
 }
 }

flang/runtime/unit.cpp

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);
     return false;
   }
   WriteFrame(frameOffsetInFile_, recordOffsetInFrame_ + furthestAfter, handler);
+  if (positionInRecord > furthestPositionInRecord) {
+    std::memset(Frame() + furthestPositionInRecord, ' ',
+        positionInRecord - furthestPositionInRecord);
+  }
   std::memcpy(Frame() + positionInRecord, data, bytes);
   positionInRecord += bytes;
   furthestPositionInRecord = furthestAfter;
   return true;
 }
 
 std::optional<char32_t> ExternalFileUnit::GetCurrentChar(
     IoErrorHandler &handler) {
if (isReading_) {
     if (recordLength.has_value()) {
       // fill fixed-size record
       if (furthestPositionInRecord < *recordLength) {
         WriteFrame(frameOffsetInFile_, *recordLength, handler);
         std::memset(Frame() + recordOffsetInFrame_ + furthestPositionInRecord,
             ' ', *recordLength - furthestPositionInRecord);
       }
     } else {
-      positionInRecord = furthestPositionInRecord + 1;
+      positionInRecord = furthestPositionInRecord;
       ok &= Emit("\n", 1, handler); // TODO: Windows CR+LF
       frameOffsetInFile_ += recordOffsetInFrame_ + furthestPositionInRecord;
       recordOffsetInFrame_ = 0;
     }
   }
   ++currentRecordNumber;
   positionInRecord = 0;
   furthestPositionInRecord = 0;