[flang][runtime] Catch OPEN of connected file

[klausler]

Summary

Diagnose OPEN(FILE=f) when f is already connected by the same name to
a distinct external I/O unit.

flang/include/flang/Runtime/iostat.h

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

flang/runtime/file.h

 enum class Position { AsIs, Rewind, Append };
 enum class Action { Read, Write, ReadWrite };
 
 class OpenFile {
 public:
   using FileOffset = std::int64_t;
 
   const char *path() const { return path_.get(); }
-  void set_path(OwningPtr<char> &&, std::size_t bytes);
   std::size_t pathLength() const { return pathLength_; }
+  void set_path(OwningPtr<char> &&, std::size_t bytes);
   bool mayRead() const { return mayRead_; }
   bool mayWrite() const { return mayWrite_; }
   bool mayPosition() const { return mayPosition_; }
   bool mayAsynchronous() const { return mayAsynchronous_; }
   void set_mayAsynchronous(bool yes) { mayAsynchronous_ = yes; }
   bool isTerminal() const { return isTerminal_; }
   bool isWindowsTextFile() const { return isWindowsTextFile_; }
   std::optional<FileOffset> knownSize() const { return knownSize_; }

flang/runtime/file.cpp

 
 bool OpenFile::Seek(FileOffset at, IoErrorHandler &handler) {
   if (at == position_) {
     return true;
   } else if (RawSeek(at)) {
     SetPosition(at);
     return true;
   } else {
-    handler.SignalErrno();
+    handler.SignalError(IostatCannotReposition);
     return false;
   }
 }
 
 bool OpenFile::RawSeek(FileOffset at) {
 #ifdef _LARGEFILE64_SOURCE
   return ::lseek64(fd_, at, SEEK_SET) == at;
 #else

flang/runtime/io-api.cpp

Cookie IONAME(BeginInquireUnit)(
   }
 }
 
 Cookie IONAME(BeginInquireFile)(const char *path, std::size_t pathLength,
     const char *sourceFile, int sourceLine) {
   Terminator oom{sourceFile, sourceLine};
   auto trimmed{
       SaveDefaultCharacter(path, TrimTrailingSpaces(path, pathLength), oom)};
-  if (ExternalFileUnit * unit{ExternalFileUnit::LookUp(trimmed.get())}) {
+  if (ExternalFileUnit *
+      unit{ExternalFileUnit::LookUp(
+          trimmed.get(), std::strlen(trimmed.get()))}) {
     // INQUIRE(FILE=) to a connected unit
     return &unit->BeginIoStatement<InquireUnitState>(
         *unit, sourceFile, sourceLine);
   } else {
     return &New<InquireUnconnectedFileState>{oom}(
         std::move(trimmed), sourceFile, sourceLine)
                 .release()
                 ->ioStatementState();

flang/runtime/iostat.cpp

const char *IostatErrorString(int iostat) {
   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";
   case IostatRealInputOverflow:
     return "Real or complex input value overflows type";
+  case IostatCannotReposition:
+    return "Attempt to reposition a unit which is connected to a file that can "
+           "only be processed sequentially";
+  case IostatOpenAlreadyConnected:
+    return "OPEN of file already connected to another unit";
   default:
     return nullptr;
   }
 }
 
 } // namespace Fortran::runtime::io

flang/runtime/unit-map.h

ExternalFileUnit &LookUpOrCreate(
       int n, const Terminator &terminator, bool &wasExtant) {
     CriticalSection critical{lock_};
     auto *p{Find(n)};
     wasExtant = p != nullptr;
     return p ? *p : Create(n, terminator);
   }
 
   // Unit look-up by name is needed for INQUIRE(FILE="...")
-  ExternalFileUnit *LookUp(const char *path) {
+  ExternalFileUnit *LookUp(const char *path, std::size_t pathLen) {
     CriticalSection critical{lock_};
-    return Find(path);
+    return Find(path, pathLen);
   }
 
   ExternalFileUnit &NewUnit(const Terminator &);
 
   // To prevent races, the unit is removed from the map if it exists,
   // and put on the closing_ list until DestroyClosed() is called.
   ExternalFileUnit *LookUpForClose(int);
 
for (Chain *p{bucket_[hash].get()}; p; previous = p, p = p->next.get()) {
           previous->next.swap(p->next); // now p->next.get() == p
           bucket_[hash].swap(p->next); // now bucket_[hash].get() == p
         }
         return &p->unit;
       }
     }
     return nullptr;
   }
-  ExternalFileUnit *Find(const char *path);
+  ExternalFileUnit *Find(const char *path, std::size_t pathLen);
 
   ExternalFileUnit &Create(int, const Terminator &);
 
   Lock lock_;
   bool isInitialized_{false};
   OwningPtr<Chain> bucket_[buckets_]{}; // all owned by *this
   OwningPtr<Chain> closing_{nullptr}; // units during CLOSE statement
   common::FastIntSet<maxNewUnits_> freeNewUnits_;
   int emergencyNewUnit_{maxNewUnits_}; // not recycled
 };
 } // namespace Fortran::runtime::io
 #endif // FORTRAN_RUNTIME_UNIT_MAP_H_

flang/runtime/unit-map.cpp

void UnitMap::FlushAll(IoErrorHandler &handler) {
   CriticalSection critical{lock_};
   for (int j{0}; j < buckets_; ++j) {
     for (Chain *p{bucket_[j].get()}; p; p = p->next.get()) {
       p->unit.FlushOutput(handler);
     }
   }
 }
 
-ExternalFileUnit *UnitMap::Find(const char *path) {
+ExternalFileUnit *UnitMap::Find(const char *path, std::size_t pathLen) {
   if (path) {
     // TODO: Faster data structure
     for (int j{0}; j < buckets_; ++j) {
       for (Chain *p{bucket_[j].get()}; p; p = p->next.get()) {
-        if (p->unit.path() && std::strcmp(p->unit.path(), path) == 0) {
+        if (p->unit.path() && p->unit.pathLength() == pathLen &&
+            std::memcmp(p->unit.path(), path, pathLen) == 0) {
           return &p->unit;
         }
       }
     }
   }
   return nullptr;
 }
 
 ExternalFileUnit &UnitMap::Create(int n, const Terminator &terminator) {
   Chain &chain{*New<Chain>{terminator}(n).release()};
   chain.next.reset(&chain);
   bucket_[Hash(n)].swap(chain.next); // pushes new node as list head
   return chain.unit;
 }
 
 } // namespace Fortran::runtime::io

flang/runtime/unit.h

public:
   bool createdForInternalChildIo() const { return createdForInternalChildIo_; }
 
   static ExternalFileUnit *LookUp(int unit);
   static ExternalFileUnit &LookUpOrCrash(int unit, const Terminator &);
   static ExternalFileUnit &LookUpOrCreate(
       int unit, const Terminator &, bool &wasExtant);
   static ExternalFileUnit &LookUpOrCreateAnonymous(int unit, Direction,
       std::optional<bool> isUnformatted, const Terminator &);
-  static ExternalFileUnit *LookUp(const char *path);
+  static ExternalFileUnit *LookUp(const char *path, std::size_t pathLen);
   static ExternalFileUnit &CreateNew(int unit, const Terminator &);
   static ExternalFileUnit *LookUpForClose(int unit);
   static ExternalFileUnit &NewUnit(const Terminator &, bool forChildIo);
   static void CloseAll(IoErrorHandler &);
   static void FlushAll(IoErrorHandler &);
 
   void OpenUnit(std::optional<OpenStatus>, std::optional<Action>, Position,
       OwningPtr<char> &&path, std::size_t pathLength, Convert,

flang/runtime/unit.cpp

if (!exists) {
     result.OpenAnonymousUnit(
         dir == Direction::Input ? OpenStatus::Unknown : OpenStatus::Replace,
         Action::ReadWrite, Position::Rewind, Convert::Native, handler);
     result.isUnformatted = isUnformatted;
   }
   return result;
 }
 
-ExternalFileUnit *ExternalFileUnit::LookUp(const char *path) {
-  return GetUnitMap().LookUp(path);
+ExternalFileUnit *ExternalFileUnit::LookUp(
+    const char *path, std::size_t pathLen) {
+  return GetUnitMap().LookUp(path, pathLen);
 }
 
 ExternalFileUnit &ExternalFileUnit::CreateNew(
     int unit, const Terminator &terminator) {
   bool wasExtant{false};
   ExternalFileUnit &result{
       GetUnitMap().LookUpOrCreate(unit, terminator, wasExtant)};
   RUNTIME_CHECK(terminator, !wasExtant);
if (!newPath.get() || isSamePath) {
       newPath.reset();
       return;
     }
     // Otherwise, OPEN on open unit with new FILE= implies CLOSE
     DoImpliedEndfile(handler);
     FlushOutput(handler);
     Close(CloseStatus::Keep, handler);
   }
+  if (newPath.get() && newPathLength > 0) {
+    if (const auto *already{
+            GetUnitMap().LookUp(newPath.get(), newPathLength)}) {
+      handler.SignalError(IostatOpenAlreadyConnected,
+          "OPEN(UNIT=%d,FILE='%.*s'): file is already connected to unit %d",
+          unitNumber_, static_cast<int>(newPathLength), newPath.get(),
+          already->unitNumber_);
+      return;
+    }
+  }
   set_path(std::move(newPath), newPathLength);
   Open(status.value_or(OpenStatus::Unknown), action, position, handler);
   auto totalBytes{knownSize()};
   if (access == Access::Direct) {
     if (!openRecl) {
       handler.SignalError(IostatOpenBadRecl,
           "OPEN(UNIT=%d,ACCESS='DIRECT'): record length is not known",
           unitNumber());