[flang] Predefine unit 0 connected to stderr

[klausler]

Summary

This is a near-universal language extension; external unit 0
is preconnected to the standard error output.

flang/docs/Extensions.md

* The definition of simple contiguity in 9.5.4 applies only to arrays;
   with bounds remapping.
 * We support some combinations of specific procedures in generic
   interfaces that a strict reading of the standard would preclude
   when their calls must nonetheless be distinguishable.
   Specifically, `ALLOCATABLE` dummy arguments are distinguishing
   if an actual argument acceptable to one could not be passed to
   the other & vice versa because exactly one is polymorphic or
   exactly one is unlimited polymorphic).
+* External unit 0 is predefined and connected to the standard error output,
+  and defined as `ERROR_UNIT` in the intrinsic `ISO_FORTRAN_ENV` module.
 
 ### Extensions supported when enabled by options
 
 * C-style backslash escape sequences in quoted CHARACTER literals
   (but not Hollerith) [-fbackslash]
 * Logical abbreviations `.T.`, `.F.`, `.N.`, `.A.`, `.O.`, and `.X.`
   [-flogical-abbreviations]
 * `.XOR.` as a synonym for `.NEQV.` [-fxor-operator]

flang/module/iso_fortran_env.f90

integer, parameter :: real_kinds(*) = [ &
     [(real64, integer :: j=1, count([real64 >= 0]))], &
     [(real80, integer :: j=1, count([real80 >= 0]))], &
     [(real64x2, integer :: j=1, count([real64x2 >= 0]))], &
     [(real128, integer :: j=1, count([real128 >= 0]))]]
 
   integer, parameter :: current_team = -1, initial_team = -2, parent_team = -3
 
   integer, parameter :: input_unit = 5, output_unit = 6
-  integer, parameter :: error_unit = output_unit
+  integer, parameter :: error_unit = 0
   integer, parameter :: iostat_end = -1, iostat_eor = -2
   integer, parameter :: iostat_inquire_internal_unit = -1
 
   integer, parameter :: character_storage_size = 8
   integer, parameter :: file_storage_size = 8
   integer, parameter :: numeric_storage_size = 32
 
   integer, parameter :: stat_failed_image = FORTRAN_RUNTIME_STAT_FAILED_IMAGE

flang/runtime/unit.cpp

 #include <utility>
 
 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};
+static ExternalFileUnit *defaultInput{nullptr}; // unit 5
+static ExternalFileUnit *defaultOutput{nullptr}; // unit 6
+static ExternalFileUnit *errorOutput{nullptr}; // unit 0 extension
 
 void FlushOutputOnCrash(const Terminator &terminator) {
-  if (!defaultOutput) {
+  if (!defaultOutput && !errorOutput) {
     return;
   }
-  CriticalSection critical{unitMapLock};
-  if (defaultOutput) {
-    IoErrorHandler handler{terminator};
-    handler.HasIoStat(); // prevent nested crash if flush has error
+  CriticalSection critical{unitMapLock};
+  if (defaultOutput) {
     defaultOutput->FlushOutput(handler);
   }
+  if (errorOutput) {
+    errorOutput->FlushOutput(handler);
+  }
 }
 
 ExternalFileUnit *ExternalFileUnit::LookUp(int unit) {
   return GetUnitMap().LookUp(unit);
 }
 
 ExternalFileUnit &ExternalFileUnit::LookUpOrCrash(
     int unit, const Terminator &terminator) {
UnitMap &ExternalFileUnit::GetUnitMap() {
   }
   CriticalSection critical{unitMapLock};
   if (unitMap) {
     return *unitMap;
   }
   Terminator terminator{__FILE__, __LINE__};
   IoErrorHandler handler{terminator};
   UnitMap *newUnitMap{New<UnitMap>{terminator}().release()};
+
   bool wasExtant{false};
   ExternalFileUnit &out{newUnitMap->LookUpOrCreate(6, terminator, wasExtant)};
   RUNTIME_CHECK(terminator, !wasExtant);
   out.Predefine(1);
   out.SetDirection(Direction::Output, handler);
   out.isUnformatted = false;
   defaultOutput = &out;
+
   ExternalFileUnit &in{newUnitMap->LookUpOrCreate(5, terminator, wasExtant)};
   RUNTIME_CHECK(terminator, !wasExtant);
   in.Predefine(0);
   in.SetDirection(Direction::Input, handler);
   in.isUnformatted = false;
   defaultInput = &in;
+
+  ExternalFileUnit &error{newUnitMap->LookUpOrCreate(0, terminator, wasExtant)};
+  RUNTIME_CHECK(terminator, !wasExtant);
+  error.Predefine(2);
+  error.SetDirection(Direction::Output, handler);
+  error.isUnformatted = false;
+  errorOutput = &error;
+
   // TODO: Set UTF-8 mode from the environment
   unitMap = newUnitMap;
   return *unitMap;
 }
 
 void ExternalFileUnit::CloseAll(IoErrorHandler &handler) {
   CriticalSection critical{unitMapLock};
   if (unitMap) {
     unitMap->CloseAll(handler);
     FreeMemoryAndNullify(unitMap);
   }
   defaultOutput = nullptr;
+  defaultInput = nullptr;
+  errorOutput = nullptr;
 }
 
 void ExternalFileUnit::FlushAll(IoErrorHandler &handler) {
   CriticalSection critical{unitMapLock};
   if (unitMap) {
     unitMap->FlushAll(handler);
   }
 }
handler.SignalError(error, static_cast<std::intmax_t>(currentRecordNumber),
         static_cast<std::intmax_t>(header), static_cast<std::intmax_t>(footer));
     // TODO: error recovery
   }
   positionInRecord = sizeof header;
 }
 
 void ExternalFileUnit::BeginSequentialVariableFormattedInputRecord(
     IoErrorHandler &handler) {
-  if (this == defaultInput && defaultOutput) {
+  if (this == defaultInput) {
+    if (defaultOutput) {
       defaultOutput->FlushOutput(handler);
     }
+    if (errorOutput) {
+      errorOutput->FlushOutput(handler);
+    }
+  }
   std::size_t length{0};
   do {
     std::size_t need{length + 1};
     length =
         ReadFrame(frameOffsetInFile_, recordOffsetInFrame_ + need, handler) -
         recordOffsetInFrame_;
     if (length < need) {
       if (length > 0) {