[flang] Allow more concurrently open NEWUNIT= values, with recycling

[klausler]

Summary

Add a header-only implementation of Briggs & Torczon's fast small
integer set data structure to flang/include/flang/Common, and use
it in the runtime to manage a pool of Fortran unit numbers with
recycling. This replaces the bit set previously used for that
purpose. The set is initialized on demand with the negations of
all the NEWUNIT= unit numbers that can be returned to any kind
of integer variable.

For programs that require more concurrently open NEWUNIT= unit
numbers than the pool can hold, they are now allocated with a
non-recycling counter. This allows as many open units as the
operating system provides.

Many of the top-line comments in flang/unittests/Runtime had the
wrong path name. I noticed this while adding a unit test for the
fast integer set data structure, and cleaned them up.

flang/include/flang/Common/fast-int-set.h

+//===-- include/flang/Common/fast-int-set.h --------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// Implements a Briggs-Torczon fast set of integers in a fixed small range
+// [0..(n-1)] This is a data structure with no dynamic memory allocation and all
+// O(1) elemental operations.  It does not need to initialize its internal state
+// arrays, but you can call its InitializeState() member function to avoid
+// complaints from valgrind.
+
+// The set is implemented with two arrays and an element count.
+// 1) The distinct values in the set occupy the leading elements of
+//    value_[0 .. size_-1] in arbitrary order.  Their positions may change
+//    when other values are removed from the set with Remove().
+// 2) For 0 <= j < size_, index_[value_[j]] == j.
+// 3) If only Add() and PopValue() are used, the popped values will be the
+//    most recently Add()ed distinct unpopped values; i.e., the value_ array
+//    will function as a stack whose top is at (size_-1).
+
+#ifndef FORTRAN_COMMON_FAST_INT_SET_H_
+#define FORTRAN_COMMON_FAST_INT_SET_H_
+
+#include <optional>
+
+namespace Fortran::common {
+
+template <int N> class FastIntSet {
+public:
+  static_assert(N > 0);
+  static constexpr int maxValue{N - 1};
+
+  int size() const { return size_; }
+  const int *value() const { return &value_[0]; }
+
+  bool IsValidValue(int n) const { return n >= 0 && n <= maxValue; }
+
+  void Clear() { size_ = 0; }
+
+  bool IsEmpty() const { return size_ == 0; }
+
+  void InitializeState() {
+    if (!isFullyInitialized_) {
+      for (int j{size_}; j < N; ++j) {
+        value_[j] = index_[j] = 0;
+      }
+      isFullyInitialized_ = true;
+    }
+  }
+
+  bool Contains(int n) const {
+    if (IsValidValue(n)) {
+      int j{index_[n]};
+      return j >= 0 && j < size_ && value_[j] == n;
+    } else {
+      return false;
+    }
+  }
+
+  bool Add(int n) {
+    if (IsValidValue(n)) {
+      if (!UncheckedContains(n)) {
+        value_[index_[n] = size_++] = n;
+      }
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  bool Remove(int n) {
+    if (IsValidValue(n)) {
+      if (UncheckedContains(n)) {
+        int last{value_[--size_]};
+        value_[index_[last] = index_[n]] = last;
+      }
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  std::optional<int> PopValue() {
+    if (IsEmpty()) {
+      return std::nullopt;
+    } else {
+      return value_[--size_];
+    }
+  }
+
+private:
+  bool UncheckedContains(int n) const {
+    int j{index_[n]};
+    return j >= 0 && j < size_ && value_[j] == n;
+  }
+
+  int value_[N];
+  int index_[N];
+  int size_{0};
+  bool isFullyInitialized_{false}; // memory was cleared
+};
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_FAST_INT_SET_H_

flang/runtime/io-api.cpp

 
 bool IONAME(GetNewUnit)(Cookie cookie, int &unit, int kind) {
   IoStatementState &io{*cookie};
   auto *open{io.get_if<OpenStatementState>()};
   if (!open) {
     io.GetIoErrorHandler().Crash(
         "GetNewUnit() called when not in an OPEN statement");
   }
-  if (!SetInteger(unit, kind, open->unit().unitNumber())) {
-    open->SignalError("GetNewUnit(): Bad INTEGER kind(%d) for result");
+  std::int64_t result{open->unit().unitNumber()};
+  if (!SetInteger(unit, kind, result)) {
+    open->SignalError("GetNewUnit(): Bad INTEGER kind(%d) or out-of-range "
+                      "value(%jd) for result",
+        kind, static_cast<std::intmax_t>(result));
   }
   return true;
 }
 
 // Data transfers
 
 bool IONAME(OutputDescriptor)(Cookie cookie, const Descriptor &descriptor) {
   return descr::DescriptorIO<Direction::Output>(*cookie, descriptor);
bool IONAME(InquirePendingId)(Cookie cookie, std::int64_t id, bool &result) {
   return io.Inquire(HashInquiryKeyword("PENDING"), id, result);
 }
 
 bool IONAME(InquireInteger64)(
     Cookie cookie, InquiryKeywordHash inquiry, std::int64_t &result, int kind) {
   IoStatementState &io{*cookie};
   std::int64_t n;
   if (io.Inquire(inquiry, n)) {
-    SetInteger(result, kind, n);
+    if (SetInteger(result, kind, n)) {
       return true;
     }
+    io.GetIoErrorHandler().SignalError(
+        "InquireInteger64(): Bad INTEGER kind(%d) or out-of-range value(%jd) "
+        "for result",
+        kind, static_cast<std::intmax_t>(n));
+  }
   return false;
 }
 
 enum Iostat IONAME(EndIoStatement)(Cookie cookie) {
   IoStatementState &io{*cookie};
   return static_cast<enum Iostat>(io.EndIoStatement());
 }
 } // namespace Fortran::runtime::io

flang/runtime/tools.h

static inline std::int64_t GetInt64(
   }
 }
 
 template <typename INT>
 inline bool SetInteger(INT &x, int kind, std::int64_t value) {
   switch (kind) {
   case 1:
     reinterpret_cast<CppTypeFor<TypeCategory::Integer, 1> &>(x) = value;
-    return true;
+    return value == reinterpret_cast<CppTypeFor<TypeCategory::Integer, 1> &>(x);
   case 2:
     reinterpret_cast<CppTypeFor<TypeCategory::Integer, 2> &>(x) = value;
-    return true;
+    return value == reinterpret_cast<CppTypeFor<TypeCategory::Integer, 2> &>(x);
   case 4:
     reinterpret_cast<CppTypeFor<TypeCategory::Integer, 4> &>(x) = value;
-    return true;
+    return value == reinterpret_cast<CppTypeFor<TypeCategory::Integer, 4> &>(x);
   case 8:
     reinterpret_cast<CppTypeFor<TypeCategory::Integer, 8> &>(x) = value;
-    return true;
+    return value == reinterpret_cast<CppTypeFor<TypeCategory::Integer, 8> &>(x);
   default:
     return false;
   }
 }
 
 // Maps intrinsic runtime type category and kind values to the appropriate
 // instantiation of a function object template and calls it with the supplied
 // arguments.

flang/runtime/unit-map.h

 //===-- runtime/unit-map.h --------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Maps Fortran unit numbers to their ExternalFileUnit instances.
 // A simple hash table with forward-linked chains per bucket.
 
 #ifndef FORTRAN_RUNTIME_UNIT_MAP_H_
 #define FORTRAN_RUNTIME_UNIT_MAP_H_
 
 #include "lock.h"
 #include "unit.h"
-#include "flang/Common/constexpr-bitset.h"
+#include "flang/Common/fast-int-set.h"
 #include "flang/Runtime/memory.h"
 #include <cstdint>
 #include <cstdlib>
 
 namespace Fortran::runtime::io {
 
 class UnitMap {
 public:

 private:
   struct Chain {
     explicit Chain(int n) : unit{n} {}
     ExternalFileUnit unit;
     OwningPtr<Chain> next{nullptr};
   };
 
   static constexpr int buckets_{1031}; // must be prime
+
+  // The pool of recyclable new unit numbers uses the range that
+  // works even with INTEGER(kind=1).  0 and -1 are never used.
+  static constexpr int maxNewUnits_{129}; // [ -128 .. 0 ]
+
   int Hash(int n) { return std::abs(n) % buckets_; }
 
+  void Initialize();
+
   ExternalFileUnit *Find(int n) {
     Chain *previous{nullptr};
     int hash{Hash(n)};
     for (Chain *p{bucket_[hash].get()}; p; previous = p, p = p->next.get()) {
       if (p->unit.unitNumber() == n) {
         if (previous) {
           // Move found unit to front of chain for quicker lookup next time
           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 &Create(int, const Terminator &);
 
   Lock lock_;
+  bool isInitialized_{false};
   OwningPtr<Chain> bucket_[buckets_]{}; // all owned by *this
-  common::BitSet<64> busyNewUnits_;
   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

 //===-- runtime/unit-map.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "unit-map.h"
 
 namespace Fortran::runtime::io {
 
+void UnitMap::Initialize() {
+  if (!isInitialized_) {
+    freeNewUnits_.InitializeState();
+    // Unit number -1 is reserved.
+    // The unit numbers are pushed in reverse order so that the first
+    // ones to be popped will be small and suitable for use as kind=1
+    // integers.
+    for (int j{freeNewUnits_.maxValue}; j > 1; --j) {
+      freeNewUnits_.Add(j);
+    }
+    isInitialized_ = true;
+  }
+}
+
 // See 12.5.6.12 in Fortran 2018.  NEWUNIT= unit numbers are negative,
-// and not equal -1 (or ERROR_UNIT, if it were negative, which it isn't.)
+// and not equal to -1 (or ERROR_UNIT, if it were negative, which it isn't.)
 ExternalFileUnit &UnitMap::NewUnit(const Terminator &terminator) {
   CriticalSection critical{lock_};
-  std::optional<std::size_t> n;
-  n = (~busyNewUnits_).LeastElement();
-  if (!n.has_value()) {
-    terminator.Crash(
-        "No available unit number for NEWUNIT= or internal child I/O");
-  }
-  busyNewUnits_.set(*n);
-  // bit position 0 <-> unit -2; kind=1 units are in [-65..-2]
-  return Create(static_cast<int>(-2 - *n), terminator);
+  Initialize();
+  std::optional<int> n{freeNewUnits_.PopValue()};
+  if (!n) {
+    n = emergencyNewUnit_++;
+  }
+  return Create(-*n, terminator);
 }
 
 ExternalFileUnit *UnitMap::LookUpForClose(int n) {
   CriticalSection critical{lock_};
   Chain *previous{nullptr};
   int hash{Hash(n)};
   for (Chain *p{bucket_[hash].get()}; p; previous = p, p = p->next.get()) {
     if (p->unit.unitNumber() == n) {
void UnitMap::DestroyClosed(ExternalFileUnit &unit) {
   Chain *p{nullptr};
   {
     CriticalSection critical{lock_};
     Chain *previous{nullptr};
     for (p = closing_.get(); p; previous = p, p = p->next.get()) {
       if (&p->unit == &unit) {
         int n{unit.unitNumber()};
         if (n <= -2) {
-          busyNewUnits_.reset(static_cast<std::size_t>(-2 - n));
+          freeNewUnits_.Add(-n);
         }
         if (previous) {
           previous->next.swap(p->next);
         } else {
           closing_.swap(p->next);
         }
         break;
       }

flang/unittests/CMakeLists.txt

function(add_flang_nongtest_unittest test_name)
   target_link_libraries(${test_name}${suffix} ${llvm_libs} ${ARG_UNPARSED_ARGUMENTS})
 
   if(NOT ARG_SLOW_TEST)
     add_dependencies(FlangUnitTests ${test_name}${suffix})
   endif()
 endfunction()
 
 add_subdirectory(Optimizer)
+add_subdirectory(Common)
 add_subdirectory(Decimal)
 add_subdirectory(Evaluate)
 add_subdirectory(Runtime)
 add_subdirectory(Frontend)

flang/unittests/Common/CMakeLists.txt

+add_flang_unittest(FlangCommonTests
+  FastIntSetTest.cpp
+)

flang/unittests/Common/FastIntSetTest.cpp

+//===-- flang/unittests/Common/FastIntSetTest.cpp ---------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+#include "flang/Common/fast-int-set.h"
+#include <optional>
+
+TEST(FastIntSetTests, Sanity) {
+  static constexpr int N{100};
+  Fortran::common::FastIntSet<N> set;
+
+  ASSERT_FALSE(set.IsValidValue(-1));
+  ASSERT_TRUE(set.IsValidValue(0));
+  ASSERT_TRUE(set.IsValidValue(N - 1));
+  ASSERT_FALSE(set.IsValidValue(N));
+  ASSERT_TRUE(set.IsEmpty());
+  ASSERT_EQ(set.size(), 0);
+  ASSERT_FALSE(set.Contains(0));
+  ASSERT_FALSE(set.Contains(N - 1));
+
+  ASSERT_TRUE(set.Add(0));
+  ASSERT_FALSE(set.IsEmpty());
+  ASSERT_EQ(set.size(), 1);
+  ASSERT_TRUE(set.Contains(0));
+
+  ASSERT_TRUE(set.Add(0)); // duplicate
+  ASSERT_EQ(set.size(), 1);
+  ASSERT_TRUE(set.Contains(0));
+
+  ASSERT_TRUE(set.Remove(0));
+  ASSERT_TRUE(set.IsEmpty());
+  ASSERT_EQ(set.size(), 0);
+  ASSERT_FALSE(set.Contains(0));
+
+  ASSERT_FALSE(set.Add(N));
+  ASSERT_TRUE(set.IsEmpty());
+  ASSERT_EQ(set.size(), 0);
+  ASSERT_FALSE(set.Contains(N));
+
+  ASSERT_TRUE(set.Add(N - 1));
+  ASSERT_FALSE(set.IsEmpty());
+  ASSERT_EQ(set.size(), 1);
+  ASSERT_TRUE(set.Contains(N - 1));
+
+  std::optional<int> x;
+  x = set.PopValue();
+  ASSERT_TRUE(x.has_value());
+  ASSERT_EQ(*x, N - 1);
+  ASSERT_TRUE(set.IsEmpty());
+  ASSERT_EQ(set.size(), 0);
+
+  x = set.PopValue();
+  ASSERT_FALSE(x.has_value());
+
+  for (int j{0}; j < N; ++j) {
+    ASSERT_TRUE(set.Add(j)) << j;
+  }
+  ASSERT_FALSE(set.IsEmpty());
+  ASSERT_EQ(set.size(), N);
+  for (int j{0}; j < N; ++j) {
+    ASSERT_TRUE(set.Contains(j)) << j;
+  }
+
+  for (int j{0}; j < N; ++j) {
+    ASSERT_TRUE(set.Remove(j)) << j;
+    ASSERT_EQ(set.size(), N - j - 1) << j;
+    ASSERT_FALSE(set.Contains(j)) << j;
+  }
+
+  ASSERT_TRUE(set.IsEmpty());
+  ASSERT_EQ(set.size(), 0);
+
+  for (int j{N - 1}; j >= 0; --j) {
+    ASSERT_TRUE(set.Add(j)) << j;
+  }
+  for (int j{0}; j < N; j++) {
+    x = set.PopValue();
+    ASSERT_TRUE(x.has_value());
+    ASSERT_EQ(*x, j) << j;
+  }
+  ASSERT_TRUE(set.IsEmpty());
+  ASSERT_EQ(set.size(), 0);
+
+  for (int j{0}; j < N; j++) {
+    ASSERT_TRUE(set.Add(j)) << j;
+  }
+  ASSERT_FALSE(set.IsEmpty());
+  ASSERT_EQ(set.size(), N);
+  for (int j{0}; j < N; j += 2) {
+    ASSERT_TRUE(set.Remove(j)) << j;
+  }
+  ASSERT_FALSE(set.IsEmpty());
+  ASSERT_EQ(set.size(), N / 2);
+  for (int j{0}; j < N; j++) {
+    ASSERT_EQ(set.Contains(j), (j & 1) == 1);
+  }
+
+  set.Clear();
+  ASSERT_TRUE(set.IsEmpty());
+}

flang/unittests/Runtime/BufferTest.cpp

-//===-- flang/unittests/RuntimeGTest/BufferTest.cpp -------------*- C++ -*-===//
+//===-- flang/unittests/Runtime/BufferTest.cpp ------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "../../runtime/buffer.h"

flang/unittests/Runtime/CharacterTest.cpp

-//===-- flang/unittests/RuntimeGTest/CharacterTest.cpp ----------*- C++ -*-===//
+//===-- flang/unittests/Runtime/CharacterTest.cpp ---------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Basic sanity tests of CHARACTER API; exhaustive testing will be done

flang/unittests/Runtime/CommandTest.cpp

-//===-- flang/unittests/RuntimeGTest/CommandTest.cpp ----------------------===//
+//===-- flang/unittests/Runtime/CommandTest.cpp ---------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Runtime/command.h"

flang/unittests/Runtime/CrashHandlerFixture.h

-//===-- flang/unittests/RuntimeGTest/CrashHandlerFixture.h ------*- C++ -*-===//
+//===-- flang/unittests/Runtime/CrashHandlerFixture.h -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 /// Test fixture registers a custom crash handler to ensure death tests fail

flang/unittests/Runtime/CrashHandlerFixture.cpp

-//===-- flang/unittests/RuntimeGTest/CrashHandlerFixture.cpp ----*- C++ -*-===//
+//===-- flang/unittests/Runtime/CrashHandlerFixture.cpp ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #include "CrashHandlerFixture.h"
 #include "../../runtime/terminator.h"

flang/unittests/Runtime/Format.cpp

-//===-- flang/unittests/RuntimeGTest/Format.cpp -----------------*- C++ -*-===//
+//===-- flang/unittests/Runtime/Format.cpp ----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "CrashHandlerFixture.h"

flang/unittests/Runtime/Inquiry.cpp

-//===-- flang/unittests/RuntimeGTest/Inquiry.cpp -----------------===//
+//===-- flang/unittests/Runtime/Inquiry.cpp -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Runtime/inquiry.h"

flang/unittests/Runtime/ListInputTest.cpp

-//===-- flang/unittests/RuntimeGTest/ListInputTest.cpp ----------*- C++ -*-===//
+//===-- flang/unittests/Runtime/ListInputTest.cpp ---------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "CrashHandlerFixture.h"

flang/unittests/Runtime/Matmul.cpp

-//===-- flang/unittests/RuntimeGTest/Matmul.cpp---- -------------*- C++ -*-===//
+//===-- flang/unittests/Runtime/Matmul.cpp--------- -------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Runtime/matmul.h"

flang/unittests/Runtime/MiscIntrinsic.cpp

-//===-- flang/unittests/RuntimeGTest/MiscIntrinsic.cpp ----------*- C++ -*-===//
+//===-- flang/unittests/Runtime/MiscIntrinsic.cpp ---------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"

flang/unittests/Runtime/Namelist.cpp

-//===-- flang/unittests/RuntimeGTest/Namelist.cpp ---------------*- C++ -*-===//
+//===-- flang/unittests/Runtime/Namelist.cpp --------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "../../runtime/namelist.h"

flang/unittests/Runtime/Numeric.cpp

-//===-- flang/unittests/RuntimeGTest/Numeric.cpp ----------------*- C++ -*-===//
+//===-- flang/unittests/Runtime/Numeric.cpp ---------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Runtime/numeric.h"

flang/unittests/Runtime/NumericalFormatTest.cpp

-//===-- flang/unittests/RuntimeGTest/NumericalFormatTest.cpp ----*- C++ -*-===//
+//===-- flang/unittests/Runtime/NumericalFormatTest.cpp ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "CrashHandlerFixture.h"

flang/unittests/Runtime/Random.cpp

-//===-- flang/unittests/RuntimeGTest/Random.cpp -----------------*- C++ -*-===//
+//===-- flang/unittests/Runtime/Random.cpp ----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Runtime//random.h"

flang/unittests/Runtime/Reduction.cpp

-//===-- flang/unittests/RuntimeGTest/Reductions.cpp -----------------------===//
+//===-- flang/unittests/Runtime/Reductions.cpp ----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Runtime/reduction.h"

flang/unittests/Runtime/RuntimeCrashTest.cpp

-//===-- flang/unittests/RuntimeGTest/CrashHandlerFixture.cpp ----*- C++ -*-===//
+//===-- flang/unittests/Runtime/CrashHandlerFixture.cpp ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 /// Selected APIs are tested here to support development of unit tests for other

flang/unittests/Runtime/Time.cpp

-//===-- flang/unittests/RuntimeGTest/Time.cpp -----------------------===//
+//===-- flang/unittests/Runtime/Time.cpp ----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"

flang/unittests/Runtime/Transformational.cpp

-//===-- flang/unittests/RuntimeGTest/Transformational.cpp -----------------===//
+//===-- flang/unittests/Runtime/Transformational.cpp ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Runtime/transformational.h"

flang/unittests/Runtime/tools.h

-//===-- flang/unittests/RuntimeGTest/tools.h --------------------*- C++ -*-===//
+//===-- flang/unittests/Runtime/tools.h -------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_UNITTESTS_RUNTIME_TOOLS_H_