flang][runtime] Catch decimal integer input overflow

[klausler]

Summary

[B/O/Z input overflow is already caught, and real input overflow
is signalled as an IEEE arithmetic exception, but regular decimal
integer overflow was silent.

flang/include/flang/Runtime/iostat.h

enum Iostat {
   IostatMissingTerminator,
   IostatBadUnformattedRecord,
   IostatUTF8Decoding,
   IostatUnitOverflow,
   IostatBadRealInput,
   IostatBadScaleFactor,
   IostatBadAsynchronous,
   IostatBadWaitUnit,
+  IostatBOZInputOverflow,
+  IostatIntegerInputOverflow,
 };
 
 const char *IostatErrorString(int);
 
 } // namespace Fortran::runtime::io
 #endif // FORTRAN_RUNTIME_IOSTAT_H_

flang/runtime/edit-input.cpp

if (ch >= '0' && ch <= '1') {
       io.GetIoErrorHandler().SignalError(
           "Bad character '%lc' in B/O/Z input field", ch);
       return false;
     }
     ++digits;
   }
   auto significantBytes{static_cast<std::size_t>(digits * LOG2_BASE + 7) / 8};
   if (significantBytes > bytes) {
-    io.GetIoErrorHandler().SignalError(
+    io.GetIoErrorHandler().SignalError(IostatBOZInputOverflow,
         "B/O/Z input of %d digits overflows %zd-byte variable", digits, bytes);
     return false;
   }
   // Reset to start of significant digits
   io.HandleRelativePosition(-digits);
   remaining.reset();
   // Make a second pass now that the digit count is known
   std::memset(n, 0, bytes);
io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
         edit.descriptor);
     return false;
   }
   std::optional<int> remaining;
   std::optional<char32_t> next;
   bool negate{ScanNumericPrefix(io, edit, next, remaining)};
   common::UnsignedInt128 value{0};
   bool any{negate};
+  bool overflow{false};
   for (; next; next = io.NextInField(remaining, edit)) {
     char32_t ch{*next};
     if (ch == ' ' || ch == '\t') {
       if (edit.modes.editingFlags & blankZero) {
         ch = '0'; // BZ mode - treat blank as if it were zero
       } else {
         continue;
       }
     }
     int digit{0};
     if (ch >= '0' && ch <= '9') {
       digit = ch - '0';
     } else {
       io.GetIoErrorHandler().SignalError(
           "Bad character '%lc' in INTEGER input field", ch);
       return false;
     }
+    static constexpr auto maxu128{~common::UnsignedInt128{0}};
+    static constexpr auto maxu128OverTen{maxu128 / 10};
+    static constexpr int maxLastDigit{
+        static_cast<int>(maxu128 - (maxu128OverTen * 10))};
+    overflow |= value >= maxu128OverTen &&
+        (value > maxu128OverTen || digit > maxLastDigit);
     value *= 10;
     value += digit;
     any = true;
   }
+  auto maxForKind{common::UnsignedInt128{1} << ((8 * kind) - 1)};
+  overflow |= value >= maxForKind && (value > maxForKind || !negate);
+  if (overflow) {
+    io.GetIoErrorHandler().SignalError(IostatIntegerInputOverflow,
+        "Decimal input overflows INTEGER(%d) variable", kind);
+    return false;
+  }
   if (negate) {
     value = -value;
   }
   if (any || !io.GetConnectionState().IsAtEOF()) {
     std::memcpy(n, &value, kind); // a blank field means zero
   }
   return any;
 }

flang/runtime/iostat.cpp

case IostatBadRealInput:
     return "Bad REAL input value";
   case IostatBadScaleFactor:
     return "Bad REAL output scale factor (kP)";
   case IostatBadAsynchronous:
     return "READ/WRITE(ASYNCHRONOUS='YES') on unit without "
            "OPEN(ASYNCHRONOUS='YES')";
   case IostatBadWaitUnit:
     return "WAIT(ID=nonzero) for a bad unit number";
+  case IostatBOZInputOverflow:
+    return "B/O/Z input value overflows variable";
+  case IostatIntegerInputOverflow:
+    return "Integer input value overflows variable";
   default:
     return nullptr;
   }
 }
 
 } // namespace Fortran::runtime::io