[flang] Use faster path for default formatted character input

[klausler]

Summary

Rather than reading default character variables in formatted
input one byte at a time via NextInField(), skip and read
them via blocks of available buffer data. This eliminates
a bottleneck that affected reads of large character values.
(It also exposed a problem with sequential reads with RECL=
set on the OPEN statement, so that's fixed too.)

flang/runtime/edit-input.cpp

default:
     io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
         "Data edit descriptor '%c' may not be used with a CHARACTER data item",
         edit.descriptor);
     return false;
   }
   if (io.GetConnectionState().IsAtEOF()) {
     return false;
   }
-  std::optional<int> remaining{length};
+  std::size_t remaining{length};
   if (edit.width && *edit.width > 0) {
     remaining = *edit.width;
   }
   // When the field is wider than the variable, we drop the leading
   // characters.  When the variable is wider than the field, there's
   // trailing padding.
-  std::int64_t skip{*remaining - static_cast<std::int64_t>(length)};
-  while (std::optional<char32_t> next{io.NextInField(remaining, edit)}) {
-    if (skip > 0) {
-      --skip;
-      io.GotChar(-1);
-    } else {
-      *x++ = *next;
-      --length;
+  const char *input{nullptr};
+  std::size_t ready{0};
+  bool hitEnd{false};
+  if (remaining > length) {
+    // Discard leading bytes.
+    // These bytes don't count towards INQUIRE(IOLENGTH=).
+    std::size_t skip{remaining - length};
+    do {
+      if (ready == 0) {
+        ready = io.GetNextInputBytes(input);
+        if (ready == 0) {
+          hitEnd = true;
+          break;
         }
       }
-  std::fill_n(x, length, ' ');
+      std::size_t chunk{std::min<std::size_t>(skip, ready)};
+      io.HandleRelativePosition(chunk);
+      ready -= chunk;
+      input += chunk;
+      skip -= chunk;
+    } while (skip > 0);
+    remaining = length;
+  }
+  // Transfer payload bytes; these do count.
+  while (remaining > 0) {
+    if (ready == 0) {
+      ready = io.GetNextInputBytes(input);
+      if (ready == 0) {
+        hitEnd = true;
+        break;
+      }
+    }
+    std::size_t chunk{std::min<std::size_t>(remaining, ready)};
+    std::memcpy(x, input, chunk);
+    x += chunk;
+    input += chunk;
+    io.GotChar(chunk);
+    io.HandleRelativePosition(chunk);
+    ready -= chunk;
+    remaining -= chunk;
+    length -= chunk;
+  }
+  // Pad the remainder of the input variable, if any.
+  std::memset(x, ' ', length);
+  if (hitEnd) {
+    io.CheckForEndOfRecord(); // signal any needed error
+  }
   return true;
 }
 
 template bool EditRealInput<2>(IoStatementState &, const DataEdit &, void *);
 template bool EditRealInput<3>(IoStatementState &, const DataEdit &, void *);
 template bool EditRealInput<4>(IoStatementState &, const DataEdit &, void *);
 template bool EditRealInput<8>(IoStatementState &, const DataEdit &, void *);
 template bool EditRealInput<10>(IoStatementState &, const DataEdit &, void *);
 // TODO: double/double
 template bool EditRealInput<16>(IoStatementState &, const DataEdit &, void *);
 } // namespace Fortran::runtime::io

flang/runtime/io-stmt.h

std::optional<char32_t> SkipSpaces(std::optional<int> &remaining) {
     return std::nullopt;
   }
 
   // Acquires the next input character, respecting any applicable field width
   // or separator character.
   std::optional<char32_t> NextInField(
       std::optional<int> &remaining, const DataEdit &);
 
+  // Detect and signal any end-of-record condition after input.
+  // Returns true if at EOR and remaining input should be padded with blanks.
+  bool CheckForEndOfRecord();
+
   // Skips spaces, advances records, and ignores NAMELIST comments
   std::optional<char32_t> GetNextNonBlank() {
     auto ch{GetCurrentChar()};
     bool inNamelist{mutableModes().inNamelist};
     while (!ch || *ch == ' ' || *ch == '\t' || (inNamelist && *ch == '!')) {
       if (ch && (*ch == ' ' || *ch == '\t')) {
         HandleRelativePosition(1);
       } else if (!AdvanceRecord()) {

flang/runtime/io-stmt.cpp

if (!remaining) { // Stream, list-directed, or NAMELIST
     }
   } else if (*remaining > 0) {
     if (auto next{GetCurrentChar()}) {
       --*remaining;
       HandleRelativePosition(1);
       GotChar();
       return next;
     }
-    const ConnectionState &connection{GetConnectionState()};
-    if (!connection.IsAtEOF()) {
-      if (auto length{connection.EffectiveRecordLength()}) {
-        if (connection.positionInRecord >= *length) {
-          IoErrorHandler &handler{GetIoErrorHandler()};
-          if (mutableModes().nonAdvancing) {
-            handler.SignalEor();
-          } else if (connection.openRecl && !connection.modes.pad) {
-            handler.SignalError(IostatRecordReadOverrun);
-          }
-          if (connection.modes.pad) { // PAD='YES'
-            --*remaining;
-            return std::optional<char32_t>{' '};
-          }
-        }
-      }
-    }
-  }
-  return std::nullopt;
+    if (CheckForEndOfRecord()) { // do padding
+      --*remaining;
+      return std::optional<char32_t>{' '};
+    }
+  }
+  return std::nullopt;
+}
+
+bool IoStatementState::CheckForEndOfRecord() {
+        return connection.modes.pad; // PAD='YES'
+  return false;
 }
 
 bool IoStatementState::Inquire(
     InquiryKeywordHash inquiry, char *out, std::size_t chars) {
   return std::visit(
       [&](auto &x) { return x.get().Inquire(inquiry, out, chars); }, u_);
 }
 

flang/runtime/unit.cpp

#endif
     if (furthestAfter > extra + *openRecl) {
       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 - header),
           static_cast<std::intmax_t>(*openRecl));
       return false;
     }
-  } else if (recordLength) {
+  }
+  if (recordLength) {
     // It is possible for recordLength to have a value now for a
     // variable-length output record if the previous operation
     // was a BACKSPACE or non advancing input statement.
     recordLength.reset();
     beganReadingRecord_ = false;
   }
   if (IsAfterEndfile()) {
     handler.SignalError(IostatWriteAfterEndfile);