[flang] Move runtime API headers to flang/include/flang/Runtime

[klausler]

Summary

Move the closure of the subset of flang/runtime/*.h header files that
are referenced by source files outside flang/runtime (apart from unit tests)
into a new directory (flang/include/flang/Runtime) so that relative
include paths into ../runtime need not be used.

flang/runtime/pgmath.h.inc is moved to flang/include/flang/Evaluate;
it's not used by the runtime.

[jeanPerier]

flang/test/Runtime/no-cpp-dep.c

11

I could reproduce the buildbot failure for this test.

This file is different from the others because it is not built by CMAKE, it is built by LIT with the command in the RUN:. So the %runtimeincludes definition in lit.cfg.py needs to be fixed here.

I guess you can decide between leaving this test untouched and replacing runtime by include/flang/Runtime in the lit.cfg.py, or keeping this change and replacing runtime by include in the lit.cfg.py.

[klausler]

Update flang/test/lit.cfg.py to point to flang/include for flang/test/Runtime/*.c.

[klausler]

flang/test/Runtime/no-cpp-dep.c

11

Fixed.

flang/examples/external-hello.cpp

-#include "../runtime/io-api.h"
-#include "../runtime/main.h"
-#include "../runtime/stop.h"
+#include "flang/Runtime/io-api.h"
+#include "flang/Runtime/main.h"
+#include "flang/Runtime/stop.h"
 #include <cstring>
 #include <limits>
 
 using namespace Fortran::runtime::io;
 
 void output1() {
   auto io{IONAME(BeginExternalListOutput)()};
   const char str[]{"Hello, world!"};

flang/include/flang/Evaluate/pgmath.h.inc

-//===-- runtime/pgmath.h.inc -------------------------------===//
+//===-- include/flang/Evaluate/pgmath.h.inc -------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // This file defines the interface of libpgmath to be used for folding

flang/include/flang/Runtime/allocatable.h

-//===-- runtime/allocatable.h -----------------------------------*- C++ -*-===//
+//===-- include/flang/Runtime/allocatable.h ----------------
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // Defines APIs for Fortran runtime library support of code generated
 // to manipulate and query allocatable variables, dummy arguments, & components.
 #ifndef FORTRAN_RUNTIME_ALLOCATABLE_H_
 #define FORTRAN_RUNTIME_ALLOCATABLE_H_
 
-#include "descriptor.h"
-#include "entry-names.h"
+#include "flang/Runtime/descriptor.h"
+#include "flang/Runtime/entry-names.h"
 
 namespace Fortran::runtime {
 
 extern "C" {
 
 // Initializes the descriptor for an allocatable of intrinsic or derived type.
 // The incoming descriptor is treated as (and can be) uninitialized garbage.
 // Must be called for each allocatable variable as its scope comes into being.

flang/include/flang/Runtime/assign.h

-//===-- runtime/assign.h --------------------------------------------------===//
+//===-- include/flang/Runtime/assign.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
 //
 //===----------------------------------------------------------------------===//
 
 // External and internal APIs for data assignment (both intrinsic assignment
 // and TBP defined generic ASSIGNMENT(=)).  Should be called by lowering
 // for any assignments possibly needing special handling.  Intrinsic assignment
 // to non-allocatable variables whose types are intrinsic need not come through
 // here (though they may do so).  Assignments to allocatables, and assignments
 // whose types may be polymorphic or are monomorphic and of derived types with
 // finalization, allocatable components, or components with type-bound defined
 // assignments, in the original type or the types of its non-pointer components
 // (recursively) must arrive here.
 //
 // Non-type-bound generic INTERFACE ASSIGNMENT(=) is resolved in semantics and
 // need not be handled here in the runtime; ditto for type conversions on
 // intrinsic assignments.
 
-#ifndef FLANG_RUNTIME_ASSIGN_H_
-#define FLANG_RUNTIME_ASSIGN_H_
+#ifndef FORTRAN_RUNTIME_ASSIGN_H_
+#define FORTRAN_RUNTIME_ASSIGN_H_
 
-#include "entry-names.h"
+#include "flang/Runtime/entry-names.h"
 
 namespace Fortran::runtime {
 class Descriptor;
 class Terminator;
 
 // Assigns one object to another via intrinsic assignment (F'2018 10.2.1.3) or
 // type-bound (only!) defined assignment (10.2.1.4), as appropriate.  Performs
 // finalization, scalar expansion, & allocatable (re)allocation as needed.
 // Does not perform intrinsic assignment implicit type conversion.  Both
 // descriptors must be initialized.  Recurses as needed to handle components.
 void Assign(Descriptor &, const Descriptor &, Terminator &);
 
 extern "C" {
 // API for lowering assignment
 void RTNAME(Assign)(Descriptor &to, const Descriptor &from,
     const char *sourceFile = nullptr, int sourceLine = 0);
 } // extern "C"
 } // namespace Fortran::runtime
-#endif // FLANG_RUNTIME_ASSIGN_H_
+#endif // FORTRAN_RUNTIME_ASSIGN_H_

flang/include/flang/Runtime/c-or-cpp.h

-//===-- runtime/c-or-cpp.h --------------------------------------*- C++ -*-===//
+//===-- include/flang/Runtime/c-or-cpp.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_RUNTIME_C_OR_CPP_H_

flang/include/flang/Runtime/character.h

-//===-- runtime/character.h -------------------------------------*- C++ -*-===//
+//===-- include/flang/Runtime/character.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
 //
 //===----------------------------------------------------------------------===//
 
 // Defines API between compiled code and the CHARACTER
 // support functions in the runtime library.
 
 #ifndef FORTRAN_RUNTIME_CHARACTER_H_
 #define FORTRAN_RUNTIME_CHARACTER_H_
-#include "entry-names.h"
+#include "flang/Runtime/entry-names.h"
 #include <cstddef>
 
 namespace Fortran::runtime {
 
 class Descriptor;
 
 template <typename CHAR>
 int CharacterScalarCompare(

flang/include/flang/Runtime/command.h

-//===-- runtime/command.h ---------------------------------------*- C++ -*-===//
+//===-- include/flang/Runtime/command.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_RUNTIME_COMMAND_H_
 #define FORTRAN_RUNTIME_COMMAND_H_
 
-#include "cpp-type.h"
-#include "entry-names.h"
+#include "flang/Runtime/cpp-type.h"
+#include "flang/Runtime/entry-names.h"
 
 namespace Fortran::runtime {
 class Descriptor;
 
 extern "C" {
 // 16.9.51 COMMAND_ARGUMENT_COUNT
 //
 // Lowering may need to cast the result to match the precision of the default

flang/include/flang/Runtime/cpp-type.h

-//===-- runtime/cpp-type.h --------------------------------------*- C++ -*-===//
+//===-- include/flang/Runtime/cpp-type.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 intrinsic types to C++ types used in the runtime.

flang/include/flang/Runtime/derived-api.h

-//===-- runtime/derived-api.h ---------------------------------------------===//
+//===-- include/flang/Runtime/derived-api.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
 //
 //===----------------------------------------------------------------------===//
 
 // API for lowering to use for operations on derived type objects.
 // Initialiaztion and finalization are implied for pointer and allocatable
 // ALLOCATE()/DEALLOCATE() respectively, so these APIs should be used only for
 // local variables.  Whole allocatable assignment should use AllocatableAssign()
 // instead of this Assign().
 
-#ifndef FLANG_RUNTIME_DERIVED_API_H_
-#define FLANG_RUNTIME_DERIVED_API_H_
+#ifndef FORTRAN_RUNTIME_DERIVED_API_H_
+#define FORTRAN_RUNTIME_DERIVED_API_H_
 
-#include "entry-names.h"
+#include "flang/Runtime/entry-names.h"
 
 namespace Fortran::runtime {
 class Descriptor;
 
 extern "C" {
 
 // Initializes and allocates an object's components, if it has a derived type
 // with any default component initialization or automatic components.
 // The descriptor must be initialized and non-null.
 void RTNAME(Initialize)(
     const Descriptor &, const char *sourceFile = nullptr, int sourceLine = 0);
 
 // Finalizes an object and its components.  Deallocates any
 // allocatable/automatic components.  Does not deallocate the descriptor's
 // storage.
 void RTNAME(Destroy)(const Descriptor &);
 
 // Intrinsic or defined assignment, with scalar expansion but not type
 // conversion.
 void RTNAME(Assign)(const Descriptor &, const Descriptor &,
     const char *sourceFile = nullptr, int sourceLine = 0);
 
 } // extern "C"
 } // namespace Fortran::runtime
-#endif // FLANG_RUNTIME_DERIVED_API_H_
+#endif // FORTRAN_RUNTIME_DERIVED_API_H_

flang/include/flang/Runtime/descriptor.h

-//===-- runtime/descriptor.h ------------------------------------*- C++ -*-===//
+//===-- include/flang/Runtime/descriptor.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_RUNTIME_DESCRIPTOR_H_
 #define FORTRAN_RUNTIME_DESCRIPTOR_H_
 
 // Defines data structures used during execution of a Fortran program
 // to implement nontrivial dummy arguments, pointers, allocatables,
 // function results, and the special behaviors of instances of derived types.
 // This header file includes and extends the published language
 // interoperability header that is required by the Fortran 2018 standard
 // as a subset of definitions suitable for exposure to user C/C++ code.
 // User C code is welcome to depend on that ISO_Fortran_binding.h file,
 // but should never reference this internal header.
 
-#include "memory.h"
-#include "type-code.h"
 #include "flang/ISO_Fortran_binding.h"
+#include "flang/Runtime/memory.h"
+#include "flang/Runtime/type-code.h"
 #include <cassert>
 #include <cinttypes>
 #include <cstddef>
 #include <cstdio>
 #include <cstring>
 
 namespace Fortran::runtime::typeInfo {
 using TypeParameterValue = std::int64_t;

flang/include/flang/Runtime/entry-names.h

-/*===-- runtime/entry-names.h ---------------------------------------*- C -*-===
+/*===-- include/flang/Runtime/entry-names.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
  *
  *===------------------------------------------------------------------------===
  */
 

flang/include/flang/Runtime/io-api.h

-//===-- runtime/io-api.h ----------------------------------------*- C++ -*-===//
+//===-- include/flang/Runtime/io-api.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
 //
 //===----------------------------------------------------------------------===//
 
 // Defines API between compiled code and I/O runtime library.
 
 #ifndef FORTRAN_RUNTIME_IO_API_H_
 #define FORTRAN_RUNTIME_IO_API_H_
 
-#include "entry-names.h"
-#include "iostat.h"
+#include "flang/Runtime/entry-names.h"
+#include "flang/Runtime/iostat.h"
 #include <cinttypes>
 #include <cstddef>
 
 namespace Fortran::runtime {
 class Descriptor;
 } // namespace Fortran::runtime
 
 namespace Fortran::runtime::io {

flang/include/flang/Runtime/iostat.h

-//===-- runtime/iostat.h ----------------------------------------*- C++ -*-===//
+//===-- include/flang/Runtime/iostat.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
 //
 //===----------------------------------------------------------------------===//
 
 // Defines the values returned by the runtime for IOSTAT= specifiers
 // on I/O statements.
 
 #ifndef FORTRAN_RUNTIME_IOSTAT_H_
 #define FORTRAN_RUNTIME_IOSTAT_H_
-#include "magic-numbers.h"
+#include "flang/Runtime/magic-numbers.h"
 namespace Fortran::runtime::io {
 
 // The value of IOSTAT= is zero when no error, end-of-record,
 // or end-of-file condition has arisen; errors are positive values.
 // (See 12.11.5 in Fortran 2018 for the complete requirements;
 // these constants must match the values of their corresponding
 // named constants in the predefined module ISO_FORTRAN_ENV, so
 // they're actually defined in another magic-numbers.h header file

flang/include/flang/Runtime/magic-numbers.h

-#if 0 /*===-- runtime/magic-numbers.h -----------------------------------===*/
+#if 0 /*===-- include/flang/Runtime/magic-numbers.h \
+         -----------------------===*/
 /*
  * 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
  *
- *===--------------------------------------------------------------------===*/
+ *===----------------------------------------------------------------------===*/
 #endif
 #if 0
 This header can be included into both Fortran and C.
 
 This file defines various code values that need to be exported
 to predefined Fortran standard modules as well as to C/C++
 code in the compiler and runtime library.
 These include:

flang/include/flang/Runtime/main.h

-//===-- runtime/main.h ------------------------------------------*- C++ -*-===//
+//===-- include/flang/Runtime/main.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_RUNTIME_MAIN_H_
 #define FORTRAN_RUNTIME_MAIN_H_
 
-#include "c-or-cpp.h"
-#include "entry-names.h"
+#include "flang/Runtime/c-or-cpp.h"
+#include "flang/Runtime/entry-names.h"
 
 FORTRAN_EXTERN_C_BEGIN
 void RTNAME(ProgramStart)(int, const char *[], const char *[]);
 void RTNAME(ByteswapOption)(); // -byteswapio
 FORTRAN_EXTERN_C_END
 
 #endif // FORTRAN_RUNTIME_MAIN_H_

flang/include/flang/Runtime/matmul.h

-//===-- runtime/matmul.h ----------------------------------------*- C++ -*-===//
+//===-- include/flang/Runtime/matmul.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
 //
 //===----------------------------------------------------------------------===//
 
 // API for the transformational intrinsic function MATMUL.
 
 #ifndef FORTRAN_RUNTIME_MATMUL_H_
 #define FORTRAN_RUNTIME_MATMUL_H_
-#include "entry-names.h"
+#include "flang/Runtime/entry-names.h"
 namespace Fortran::runtime {
 class Descriptor;
 extern "C" {
 
 // The most general MATMUL.  All type and shape information is taken from the
 // arguments' descriptors, and the result is dynamically allocated.
 void RTNAME(Matmul)(Descriptor &, const Descriptor &, const Descriptor &,
     const char *sourceFile = nullptr, int line = 0);
 
 // A non-allocating variant; the result's descriptor must be established
 // and have a valid base address.
 void RTNAME(MatmulDirect)(const Descriptor &, const Descriptor &,
     const Descriptor &, const char *sourceFile = nullptr, int line = 0);
 } // extern "C"
 } // namespace Fortran::runtime
 #endif // FORTRAN_RUNTIME_MATMUL_H_

flang/include/flang/Runtime/memory.h

-//===-- runtime/memory.h ----------------------------------------*- C++ -*-===//
+//===-- include/flang/Runtime/memory.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
 //
 //===----------------------------------------------------------------------===//
 
 // Thin wrapper around malloc()/free() to isolate the dependency,

flang/include/flang/Runtime/misc-intrinsic.h

-//===-- runtime/misc-intrinsic.h --------------------------------*- C++ -*-===//
+//===-- include/flang/Runtime/misc-intrinsic.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
 //
 //===----------------------------------------------------------------------===//
 
 // Miscellaneous intrinsic procedures
 
 #ifndef FORTRAN_RUNTIME_MISC_INTRINSIC_H_
 #define FORTRAN_RUNTIME_MISC_INTRINSIC_H_
 
-#include "entry-names.h"
+#include "flang/Runtime/entry-names.h"
 #include <cstdint>
 
 namespace Fortran::runtime {
 
 class Descriptor;
 
 extern "C" {
 void RTNAME(Transfer)(Descriptor &result, const Descriptor &source,
     const Descriptor &mold, const char *sourceFile, int line);
 void RTNAME(TransferSize)(Descriptor &result, const Descriptor &source,
     const Descriptor &mold, const char *sourceFile, int line,
     std::int64_t size);
 } // extern "C"
 } // namespace Fortran::runtime
 #endif // FORTRAN_RUNTIME_MISC_INTRINSIC_H_

flang/include/flang/Runtime/numeric.h

-//===-- runtime/numeric.h ---------------------------------------*- C++ -*-===//
+//===-- include/flang/Runtime/numeric.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
 //
 //===----------------------------------------------------------------------===//
 
 // Defines API between compiled code and the implementations of various numeric
 // intrinsic functions in the runtime library.
 
 #ifndef FORTRAN_RUNTIME_NUMERIC_H_
 #define FORTRAN_RUNTIME_NUMERIC_H_
 
-#include "cpp-type.h"
-#include "entry-names.h"
+#include "flang/Runtime/cpp-type.h"
+#include "flang/Runtime/entry-names.h"
 
 namespace Fortran::runtime {
 extern "C" {
 
 // AINT
 CppTypeFor<TypeCategory::Real, 4> RTNAME(Aint4_4)(
     CppTypeFor<TypeCategory::Real, 4>);
 CppTypeFor<TypeCategory::Real, 8> RTNAME(Aint4_8)(

flang/include/flang/Runtime/pointer.h

-//===-- runtime/pointer.h ---------------------------------------*- C++ -*-===//
+//===-- include/flang/Runtime/pointer.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
 //
 //===----------------------------------------------------------------------===//
 
 // Defines APIs for Fortran runtime library support of code generated
 // to manipulate and query data pointers.
 
 #ifndef FORTRAN_RUNTIME_POINTER_H_
 #define FORTRAN_RUNTIME_POINTER_H_
 
-#include "descriptor.h"
-#include "entry-names.h"
+#include "flang/Runtime/descriptor.h"
+#include "flang/Runtime/entry-names.h"
 
 namespace Fortran::runtime {
 extern "C" {
 
 // Data pointer initialization for NULLIFY(), "p=>NULL()`, & for ALLOCATE().
 
 // Initializes a pointer to a disassociated state for NULLIFY() or "p=>NULL()".
 void RTNAME(PointerNullifyIntrinsic)(

flang/include/flang/Runtime/random.h

-//===-- runtime/random.h --------------------------------------------------===//
+//===-- include/flang/Runtime/random.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
 //
 //===----------------------------------------------------------------------===//
 
 // Intrinsic subroutines RANDOM_INIT, RANDOM_NUMBER, and RANDOM_SEED.
 
-#include "entry-names.h"
+#include "flang/Runtime/entry-names.h"
 #include <cstdint>
 
 namespace Fortran::runtime {
 class Descriptor;
 extern "C" {
 
 void RTNAME(RandomInit)(bool repeatable, bool image_distinct);
 

flang/include/flang/Runtime/reduction.h

-//===-- runtime/reduction.h -------------------------------------*- C++ -*-===//
+//===-- include/flang/Runtime/reduction.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
 //
 //===----------------------------------------------------------------------===//
 
 // Defines the API for the reduction transformational intrinsic functions.
 
 #ifndef FORTRAN_RUNTIME_REDUCTION_H_
 #define FORTRAN_RUNTIME_REDUCTION_H_
 
-#include "descriptor.h"
-#include "entry-names.h"
 #include "flang/Common/uint128.h"
+#include "flang/Runtime/descriptor.h"
+#include "flang/Runtime/entry-names.h"
 #include <complex>
 #include <cstdint>
 
 namespace Fortran::runtime {
 extern "C" {
 
 // Reductions that are known to return scalars have per-type entry
 // points.  These cover the cases that either have no DIM=

flang/include/flang/Runtime/stop.h

-//===-- runtime/stop.h ------------------------------------------*- C++ -*-===//
+//===-- include/flang/Runtime/stop.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_RUNTIME_STOP_H_
 #define FORTRAN_RUNTIME_STOP_H_
 
-#include "c-or-cpp.h"
-#include "entry-names.h"
+#include "flang/Runtime/c-or-cpp.h"
+#include "flang/Runtime/entry-names.h"
 #include <stdlib.h>
 
 FORTRAN_EXTERN_C_BEGIN
 
 // Program-initiated image stop
 NORETURN void RTNAME(StopStatement)(int code DEFAULT_VALUE(EXIT_SUCCESS),
     bool isErrorStop DEFAULT_VALUE(false), bool quiet DEFAULT_VALUE(false));
 NORETURN void RTNAME(StopStatementText)(const char *, size_t,

flang/include/flang/Runtime/time-intrinsic.h

-//===-- runtime/time-intrinsic.h --------------------------------*- C++ -*-===//
+//===-- include/flang/Runtime/time-intrinsic.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
 //
 //===----------------------------------------------------------------------===//
 
 // Defines the API between compiled code and the implementations of time-related
 // intrinsic subroutines in the runtime library.
 
 #ifndef FORTRAN_RUNTIME_TIME_INTRINSIC_H_
 #define FORTRAN_RUNTIME_TIME_INTRINSIC_H_
 
-#include "cpp-type.h"
-#include "entry-names.h"
+#include "flang/Runtime/cpp-type.h"
+#include "flang/Runtime/entry-names.h"
 
 namespace Fortran::runtime {
 
 class Descriptor;
 
 extern "C" {
 
 // Lowering may need to cast this result to match the precision of the default

flang/include/flang/Runtime/transformational.h

-//===-- runtime/transformational.h ------------------------------*- C++ -*-===//
+//===-- include/flang/Runtime/transformational.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
 //
 //===----------------------------------------------------------------------===//
 
 // Defines the API for the type-independent transformational intrinsic functions
 // that rearrange data in arrays: CSHIFT, EOSHIFT, PACK, RESHAPE, SPREAD,
 // TRANSPOSE, and UNPACK.
 // These are naive allocating implementations; optimized forms that manipulate
 // pointer descriptors or that supply functional views of arrays remain to
 // be defined and may instead be part of lowering (see docs/ArrayComposition.md)
 // for details).
 
 #ifndef FORTRAN_RUNTIME_TRANSFORMATIONAL_H_
 #define FORTRAN_RUNTIME_TRANSFORMATIONAL_H_
 
-#include "descriptor.h"
-#include "entry-names.h"
-#include "memory.h"
+#include "flang/Runtime/descriptor.h"
+#include "flang/Runtime/entry-names.h"
+#include "flang/Runtime/memory.h"
 
 namespace Fortran::runtime {
 
 extern "C" {
 
 void RTNAME(Reshape)(Descriptor &result, const Descriptor &source,
     const Descriptor &shape, const Descriptor *pad = nullptr,
     const Descriptor *order = nullptr, const char *sourceFile = nullptr,

flang/include/flang/Runtime/type-code.h

-//===-- runtime/type-code.h -------------------------------------*- C++ -*-===//
+//===-- include/flang/Runtime/type-code.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_RUNTIME_TYPE_CODE_H_

flang/lib/Evaluate/intrinsics-library.cpp

 };
 
 /// Define pgmath description
 #if LINK_WITH_LIBPGMATH
 // Only use libpgmath for folding if it is available.
 // First declare all libpgmaths functions
 #define PGMATH_LINKING
 #define PGMATH_DECLARE
-#include "../runtime/pgmath.h.inc"
+#include "flang/Evaluate/pgmath.h.inc"
 
 #define REAL_FOLDER(name, func) \
   FolderFactory<decltype(&func), &func>::Create(#name)
 template <> struct HostRuntimeLibrary<float, LibraryVersion::PgmathFast> {
   static constexpr HostRuntimeFunction table[]{
 #define PGMATH_FAST
 #define PGMATH_USE_S(name, func) REAL_FOLDER(name, func),
-#include "../runtime/pgmath.h.inc"
+#include "flang/Evaluate/pgmath.h.inc"
   };
   static constexpr HostRuntimeMap map{table};
   static_assert(map.Verify(), "map must be sorted");
 };
 template <> struct HostRuntimeLibrary<double, LibraryVersion::PgmathFast> {
   static constexpr HostRuntimeFunction table[]{
 #define PGMATH_FAST
 #define PGMATH_USE_D(name, func) REAL_FOLDER(name, func),
-#include "../runtime/pgmath.h.inc"
+#include "flang/Evaluate/pgmath.h.inc"
   };
   static constexpr HostRuntimeMap map{table};
   static_assert(map.Verify(), "map must be sorted");
 };
 template <> struct HostRuntimeLibrary<float, LibraryVersion::PgmathRelaxed> {
   static constexpr HostRuntimeFunction table[]{
 #define PGMATH_RELAXED
 #define PGMATH_USE_S(name, func) REAL_FOLDER(name, func),
-#include "../runtime/pgmath.h.inc"
+#include "flang/Evaluate/pgmath.h.inc"
   };
   static constexpr HostRuntimeMap map{table};
   static_assert(map.Verify(), "map must be sorted");
 };
 template <> struct HostRuntimeLibrary<double, LibraryVersion::PgmathRelaxed> {
   static constexpr HostRuntimeFunction table[]{
 #define PGMATH_RELAXED
 #define PGMATH_USE_D(name, func) REAL_FOLDER(name, func),
-#include "../runtime/pgmath.h.inc"
+#include "flang/Evaluate/pgmath.h.inc"
   };
   static constexpr HostRuntimeMap map{table};
   static_assert(map.Verify(), "map must be sorted");
 };
 template <> struct HostRuntimeLibrary<float, LibraryVersion::PgmathPrecise> {
   static constexpr HostRuntimeFunction table[]{
 #define PGMATH_PRECISE
 #define PGMATH_USE_S(name, func) REAL_FOLDER(name, func),
-#include "../runtime/pgmath.h.inc"
+#include "flang/Evaluate/pgmath.h.inc"
   };
   static constexpr HostRuntimeMap map{table};
   static_assert(map.Verify(), "map must be sorted");
 };
 template <> struct HostRuntimeLibrary<double, LibraryVersion::PgmathPrecise> {
   static constexpr HostRuntimeFunction table[]{
 #define PGMATH_PRECISE
 #define PGMATH_USE_D(name, func) REAL_FOLDER(name, func),
-#include "../runtime/pgmath.h.inc"
+#include "flang/Evaluate/pgmath.h.inc"
   };
   static constexpr HostRuntimeMap map{table};
   static_assert(map.Verify(), "map must be sorted");
 };
 
 // TODO: double _Complex/float _Complex have been removed from llvm flang
 // pgmath.h.inc because they caused warnings, they need to be added back
 // so that the complex pgmath versions can be used when requested.

flang/lib/Lower/CharacterRuntime.cpp

 //===-- CharacterRuntime.cpp -- runtime for CHARACTER type entities -------===//
 //
 // 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/Lower/CharacterRuntime.h"
-#include "../../runtime/character.h"
 #include "RTBuilder.h"
 #include "flang/Lower/Bridge.h"
 #include "flang/Lower/CharacterExpr.h"
 #include "flang/Lower/FIRBuilder.h"
+#include "flang/Runtime/character.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 
 using namespace Fortran::runtime;
 
 #define NAMIFY_HELPER(X) #X
 #define NAMIFY(X) NAMIFY_HELPER(IONAME(X))
 #define mkRTKey(X) mkKey(RTNAME(X))
 

flang/lib/Lower/IO.cpp

 //===-- IO.cpp -- I/O statement lowering ----------------------------------===//
 //
 // 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/Lower/IO.h"
-#include "../../runtime/io-api.h"
 #include "RTBuilder.h"
 #include "flang/Lower/Bridge.h"
 #include "flang/Lower/CharacterExpr.h"
 #include "flang/Lower/ComplexExpr.h"
 #include "flang/Lower/FIRBuilder.h"
 #include "flang/Lower/PFTBuilder.h"
 #include "flang/Lower/Runtime.h"
 #include "flang/Lower/Utils.h"
 #include "flang/Parser/parse-tree.h"
+#include "flang/Runtime/io-api.h"
 #include "flang/Semantics/tools.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 
 #define TODO() llvm_unreachable("not yet implemented")
 
 using namespace Fortran::runtime::io;
 
 #define NAMIFY_HELPER(X) #X

flang/lib/Lower/IntrinsicCall.cpp

 #include "flang/Lower/Runtime.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <algorithm>
 #include <string_view>
 #include <utility>
 
 #define PGMATH_DECLARE
-#include "../runtime/pgmath.h.inc"
+#include "flang/Evaluate/pgmath.h.inc"
 
 /// This file implements lowering of Fortran intrinsic procedures.
 /// Intrinsics are lowered to a mix of FIR and MLIR operations as
 /// well as call to runtime functions or LLVM intrinsics.
 
 /// Lowering of intrinsic procedure calls is based on a map that associates
 /// Fortran intrinsic generic names to FIR generator functions.
 /// All generator functions are member functions of the IntrinsicLibrary class

 };
 
 #define RUNTIME_STATIC_DESCRIPTION(name, func)                                 \
   {#name, #func,                                                               \
    Fortran::lower::RuntimeTableKey<decltype(func)>::getTypeModel()},
 static constexpr RuntimeFunction pgmathFast[] = {
 #define PGMATH_FAST
 #define PGMATH_USE_ALL_TYPES(name, func) RUNTIME_STATIC_DESCRIPTION(name, func)
-#include "../runtime/pgmath.h.inc"
+#include "flang/Evaluate/pgmath.h.inc"
 };
 static constexpr RuntimeFunction pgmathRelaxed[] = {
 #define PGMATH_RELAXED
 #define PGMATH_USE_ALL_TYPES(name, func) RUNTIME_STATIC_DESCRIPTION(name, func)
-#include "../runtime/pgmath.h.inc"
+#include "flang/Evaluate/pgmath.h.inc"
 };
 static constexpr RuntimeFunction pgmathPrecise[] = {
 #define PGMATH_PRECISE
 #define PGMATH_USE_ALL_TYPES(name, func) RUNTIME_STATIC_DESCRIPTION(name, func)
-#include "../runtime/pgmath.h.inc"
+#include "flang/Evaluate/pgmath.h.inc"
 };
 
 static mlir::FunctionType genF32F32FuncType(mlir::MLIRContext *context) {
   auto t = mlir::FloatType::getF32(context);
   return mlir::FunctionType::get(context, {t}, {t});
 }
 
 static mlir::FunctionType genF64F64FuncType(mlir::MLIRContext *context) {

flang/lib/Lower/RTBuilder.h

 #include "flang/Lower/ConvertType.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/MLIRContext.h"
 #include "llvm/ADT/SmallVector.h"
 #include <functional>
 
 // List the runtime headers we want to be able to dissect
-#include "../../runtime/io-api.h"
+#include "flang/Runtime/io-api.h"
 
 namespace Fortran::lower {
 
 using TypeBuilderFunc = mlir::Type (*)(mlir::MLIRContext *);
 using FuncTypeBuilderFunc = mlir::FunctionType (*)(mlir::MLIRContext *);
 
 //===----------------------------------------------------------------------===//
 // Type builder models

flang/lib/Semantics/compute-offsets.cpp

 //===-- lib/Semantics/compute-offsets.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 "compute-offsets.h"
-#include "../../runtime/descriptor.h"
 #include "flang/Evaluate/fold-designator.h"
 #include "flang/Evaluate/fold.h"
 #include "flang/Evaluate/shape.h"
 #include "flang/Evaluate/type.h"
+#include "flang/Runtime/descriptor.h"
 #include "flang/Semantics/scope.h"
 #include "flang/Semantics/semantics.h"
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/tools.h"
 #include "flang/Semantics/type.h"
 #include <algorithm>
 #include <vector>
 

flang/module/iso_fortran_env.f90

 !===-- module/iso_fortran_env.f90 ------------------------------------------===!
 !
 ! 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
 !
 !===------------------------------------------------------------------------===!
 
 ! See Fortran 2018, clause 16.10.2
 ! TODO: These are placeholder values so that some tests can be run.
 
-include '../runtime/magic-numbers.h' ! for IOSTAT= error/end code values
+include '../include/flang/Runtime/magic-numbers.h' ! for IOSTAT= error/end code values
 
 module iso_fortran_env
 
   use __Fortran_builtins, only: &
     event_type => __builtin_event_type, &
     lock_type => __builtin_lock_type, &
     team_type => __builtin_team_type
 

flang/runtime/ISO_Fortran_binding.cpp

 //===-- runtime/ISO_Fortran_binding.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
 //
 //===----------------------------------------------------------------------===//
 
 // Implements the required interoperability API from ISO_Fortran_binding.h
 // as specified in section 18.5.5 of Fortran 2018.
 
-#include "../include/flang/ISO_Fortran_binding.h"
-#include "descriptor.h"
+#include "flang/ISO_Fortran_binding.h"
+#include "flang/Runtime/descriptor.h"
 #include <cstdlib>
 
 namespace Fortran::ISO {
 extern "C" {
 
 static inline constexpr bool IsCharacterType(CFI_type_t ty) {
   return ty == CFI_type_char || ty == CFI_type_char16_t ||
       ty == CFI_type_char32_t;

flang/runtime/allocatable.cpp

 //===-- runtime/allocatable.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 "allocatable.h"
-#include "assign.h"
+#include "flang/Runtime/allocatable.h"
 #include "derived.h"
 #include "stat.h"
 #include "terminator.h"
 #include "type-info.h"
+#include "flang/Runtime/assign.h"
 
 namespace Fortran::runtime {
 extern "C" {
 
 void RTNAME(AllocatableInitIntrinsic)(Descriptor &descriptor,
     TypeCategory category, int kind, int rank, int corank) {
   INTERNAL_CHECK(corank == 0);
   descriptor.Establish(TypeCode{category, kind},

flang/runtime/assign.cpp

 //===-- runtime/assign.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 "assign.h"
+#include "flang/Runtime/assign.h"
 #include "derived.h"
-#include "descriptor.h"
 #include "stat.h"
 #include "terminator.h"
 #include "type-info.h"
+#include "flang/Runtime/descriptor.h"
 
 namespace Fortran::runtime {
 
 static void DoScalarDefinedAssignment(const Descriptor &to,
     const Descriptor &from, const typeInfo::SpecialBinding &special) {
   bool toIsDesc{special.IsArgDescriptor(0)};
   bool fromIsDesc{special.IsArgDescriptor(1)};
   if (toIsDesc) {

flang/runtime/buffer.h

 //===-- runtime/buffer.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
 //
 //===----------------------------------------------------------------------===//
 
 // External file buffering
 
 #ifndef FORTRAN_RUNTIME_BUFFER_H_
 #define FORTRAN_RUNTIME_BUFFER_H_
 
 #include "io-error.h"
-#include "memory.h"
+#include "flang/Runtime/memory.h"
 #include <algorithm>
 #include <cinttypes>
 #include <cstring>
 
 namespace Fortran::runtime::io {
 
 void LeftShiftBufferCircularly(char *, std::size_t bytes, std::size_t shift);
 

flang/runtime/character.cpp

 //===-- runtime/character.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 "character.h"
-#include "cpp-type.h"
-#include "descriptor.h"
+#include "flang/Runtime/character.h"
 #include "terminator.h"
 #include "tools.h"
 #include "flang/Common/bit-population-count.h"
 #include "flang/Common/uint128.h"
+#include "flang/Runtime/cpp-type.h"
+#include "flang/Runtime/descriptor.h"
 #include <algorithm>
 #include <cstring>
 
 namespace Fortran::runtime {
 
 template <typename CHAR>
 inline int CompareToBlankPadding(const CHAR *x, std::size_t chars) {
   for (; chars-- > 0; ++x) {

flang/runtime/command.cpp

 //===-- runtime/command.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 "command.h"
+#include "flang/Runtime/command.h"
 #include "environment.h"
 
 namespace Fortran::runtime {
 CppTypeFor<TypeCategory::Integer, 4> RTNAME(ArgumentCount)() {
   int argc{executionEnvironment.argc};
   if (argc > 1) {
     // C counts the command name as one of the arguments, but Fortran doesn't.
     return argc - 1;
   }
   return 0;
 }
 } // namespace Fortran::runtime

flang/runtime/complex-reduction.h

 /* Wraps the C++-coded complex-valued SUM and PRODUCT reductions with
  * C-coded wrapper functions returning _Complex values, to avoid problems
  * with C++ build compilers that don't support C's _Complex.
  */
 
 #ifndef FORTRAN_RUNTIME_COMPLEX_REDUCTION_H_
 #define FORTRAN_RUNTIME_COMPLEX_REDUCTION_H_
 
-#include "entry-names.h"
+#include "flang/Runtime/entry-names.h"
 #include <complex.h>
 
 struct CppDescriptor; /* dummy type name for Fortran::runtime::Descriptor */
 
 #ifdef _MSC_VER
 typedef _Fcomplex float_Complex_t;
 typedef _Dcomplex double_Complex_t;
 typedef _Lcomplex long_double_Complex_t;

flang/runtime/copy.h

-//===-- runtime/copy.h -----------------------------------------*- C++ -*-===//
+//===-- runtime/copy.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
 //
 //===----------------------------------------------------------------------===//
 
 // Utilities that copy data in a type-aware fashion, allocating & duplicating
 // allocatable/automatic components of derived types along the way.
 
 #ifndef FORTRAN_RUNTIME_COPY_H_
 #define FORTRAN_RUNTIME_COPY_H_
 
-#include "descriptor.h"
+#include "flang/Runtime/descriptor.h"
 
 namespace Fortran::runtime {
 
 // Assigns to uninitialized storage.
 // Duplicates allocatable & automatic components.
 void CopyElement(const Descriptor &to, const SubscriptValue toAt[],
     const Descriptor &from, const SubscriptValue fromAt[], Terminator &);
 
 // Copies data from one allocated descriptor's array to another.
 void CopyArray(const Descriptor &to, const Descriptor &from, Terminator &);
 
 } // namespace Fortran::runtime
 #endif // FORTRAN_RUNTIME_COPY_H_

flang/runtime/copy.cpp

 //===-- runtime/copy.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 "copy.h"
-#include "allocatable.h"
-#include "descriptor.h"
 #include "terminator.h"
 #include "type-info.h"
+#include "flang/Runtime/allocatable.h"
+#include "flang/Runtime/descriptor.h"
 #include <cstring>
 
 namespace Fortran::runtime {
 
 void CopyElement(const Descriptor &to, const SubscriptValue toAt[],
     const Descriptor &from, const SubscriptValue fromAt[],
     Terminator &terminator) {
   char *toPtr{to.Element<char>(toAt)};

flang/runtime/derived-api.cpp

 //===-- runtime/derived-api.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 "derived-api.h"
+#include "flang/Runtime/derived-api.h"
 #include "derived.h"
-#include "descriptor.h"
 #include "terminator.h"
 #include "type-info.h"
+#include "flang/Runtime/descriptor.h"
 
 namespace Fortran::runtime {
 
 extern "C" {
 
 void RTNAME(Initialize)(
     const Descriptor &descriptor, const char *sourceFile, int sourceLine) {
   if (const DescriptorAddendum * addendum{descriptor.Addendum()}) {

flang/runtime/derived.h

 //===-- runtime/derived.h -------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // Internal runtime utilities for derived type operations.
 
-#ifndef FLANG_RUNTIME_DERIVED_H_
-#define FLANG_RUNTIME_DERIVED_H_
+#ifndef FORTRAN_RUNTIME_DERIVED_H_
+#define FORTRAN_RUNTIME_DERIVED_H_
 
 namespace Fortran::runtime::typeInfo {
 class DerivedType;
 }
 
 namespace Fortran::runtime {
 class Descriptor;
 class Terminator;
 
 // Perform default component initialization, allocate automatic components.
 // Returns a STAT= code (0 when all's well).
 int Initialize(const Descriptor &, const typeInfo::DerivedType &, Terminator &,
     bool hasStat = false, const Descriptor *errMsg = nullptr);
 
 // Call FINAL subroutines, if any
 void Finalize(const Descriptor &, const typeInfo::DerivedType &derived);
 
 // Call FINAL subroutines, deallocate allocatable & automatic components.
 // Does not deallocate the original descriptor.
 void Destroy(const Descriptor &, bool finalize, const typeInfo::DerivedType &);
 
 } // namespace Fortran::runtime
-#endif // FLANG_RUNTIME_DERIVED_H_
+#endif // FORTRAN_RUNTIME_DERIVED_H_

flang/runtime/derived.cpp

 //===-- runtime/derived.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 "derived.h"
-#include "descriptor.h"
 #include "stat.h"
 #include "terminator.h"
 #include "type-info.h"
+#include "flang/Runtime/descriptor.h"
 
 namespace Fortran::runtime {
 
 int Initialize(const Descriptor &instance, const typeInfo::DerivedType &derived,
     Terminator &terminator, bool hasStat, const Descriptor *errMsg) {
   const Descriptor &componentDesc{derived.component()};
   std::size_t elements{instance.Elements()};
   std::size_t byteStride{instance.ElementBytes()};

flang/runtime/descriptor-io.h

 //===-- runtime/descriptor-io.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_RUNTIME_DESCRIPTOR_IO_H_
 #define FORTRAN_RUNTIME_DESCRIPTOR_IO_H_
 
 // Implementation of I/O data list item transfers based on descriptors.
 // (All I/O items come through here so that the code is exercised for test;
 // some scalar I/O data transfer APIs could be changed to bypass their use
 // of descriptors in the future for better efficiency.)
 
-#include "cpp-type.h"
-#include "descriptor.h"
 #include "edit-input.h"
 #include "edit-output.h"
 #include "io-stmt.h"
 #include "terminator.h"
 #include "type-info.h"
 #include "unit.h"
 #include "flang/Common/uint128.h"
+#include "flang/Runtime/cpp-type.h"
+#include "flang/Runtime/descriptor.h"
 
 namespace Fortran::runtime::io::descr {
 template <typename A>
 inline A &ExtractElement(IoStatementState &io, const Descriptor &descriptor,
     const SubscriptValue subscripts[]) {
   A *p{descriptor.Element<A>(subscripts)};
   if (!p) {
     io.GetIoErrorHandler().Crash(

flang/runtime/descriptor.cpp

 //===-- runtime/descriptor.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 "descriptor.h"
+#include "flang/Runtime/descriptor.h"
 #include "derived.h"
 #include "memory.h"
 #include "stat.h"
 #include "terminator.h"
 #include "type-info.h"
 #include <cassert>
 #include <cstdlib>
 #include <cstring>

flang/runtime/dot-product.cpp

 //===-- runtime/dot-product.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 "cpp-type.h"
-#include "descriptor.h"
-#include "reduction.h"
 #include "terminator.h"
 #include "tools.h"
+#include "flang/Runtime/cpp-type.h"
+#include "flang/Runtime/descriptor.h"
+#include "flang/Runtime/reduction.h"
 #include <cinttypes>
 
 namespace Fortran::runtime {
 
 template <typename RESULT, TypeCategory XCAT, typename XT, typename YT>
 class Accumulator {
 public:
   using Result = RESULT;

flang/runtime/extrema.cpp

 //===-- runtime/extrema.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
 //
 //===----------------------------------------------------------------------===//
 
 // Implements MAXLOC, MINLOC, MAXVAL, & MINVAL for all required operand types
 // and shapes and (for MAXLOC & MINLOC) result integer kinds.  Also implements
 // NORM2 using common infrastructure.
 
-#include "character.h"
 #include "reduction-templates.h"
-#include "reduction.h"
 #include "flang/Common/long-double.h"
+#include "flang/Runtime/character.h"
+#include "flang/Runtime/reduction.h"
 #include <algorithm>
 #include <cinttypes>
 #include <cmath>
 #include <optional>
 
 namespace Fortran::runtime {
 
 // MAXLOC & MINLOC

flang/runtime/file.h

 //===-- runtime/file.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
 //
 //===----------------------------------------------------------------------===//
 
 // Raw system I/O wrappers
 
 #ifndef FORTRAN_RUNTIME_FILE_H_
 #define FORTRAN_RUNTIME_FILE_H_
 
 #include "io-error.h"
-#include "memory.h"
+#include "flang/Runtime/memory.h"
 #include <cinttypes>
 #include <optional>
 
 namespace Fortran::runtime::io {
 
 enum class OpenStatus { Old, New, Scratch, Replace, Unknown };
 enum class CloseStatus { Keep, Delete };
 enum class Position { AsIs, Rewind, Append };

flang/runtime/file.cpp

 //===-- runtime/file.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 "file.h"
-#include "magic-numbers.h"
-#include "memory.h"
+#include "flang/Runtime/magic-numbers.h"
+#include "flang/Runtime/memory.h"
 #include <algorithm>
 #include <cerrno>
 #include <cstring>
 #include <fcntl.h>
 #include <stdlib.h>
 #include <sys/stat.h>
 #ifdef _WIN32
 #define NOMINMAX

flang/runtime/findloc.cpp

 //===-- runtime/findloc.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
 //
 //===----------------------------------------------------------------------===//
 
 // Implements FINDLOC for all required operand types and shapes and result
 // integer kinds.
 
-#include "character.h"
 #include "reduction-templates.h"
-#include "reduction.h"
 #include "flang/Common/long-double.h"
+#include "flang/Runtime/character.h"
+#include "flang/Runtime/reduction.h"
 #include <cinttypes>
 #include <complex>
 
 namespace Fortran::runtime {
 
 template <TypeCategory CAT1, int KIND1, TypeCategory CAT2, int KIND2>
 struct Equality {
   using Type1 = CppTypeFor<CAT1, KIND1>;

flang/runtime/format-implementation.h

 //===-- runtime/format-implementation.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 out-of-line member functions of template class FormatControl
 
 #ifndef FORTRAN_RUNTIME_FORMAT_IMPLEMENTATION_H_
 #define FORTRAN_RUNTIME_FORMAT_IMPLEMENTATION_H_
 
 #include "format.h"
 #include "io-stmt.h"
-#include "main.h"
 #include "flang/Common/format.h"
 #include "flang/Decimal/decimal.h"
+#include "flang/Runtime/main.h"
 #include <algorithm>
 #include <limits>
 
 namespace Fortran::runtime::io {
 
 template <typename CONTEXT>
 FormatControl<CONTEXT>::FormatControl(const Terminator &terminator,
     const CharType *format, std::size_t formatLength, int maxHeight)

flang/runtime/internal-unit.h

 //===-- runtime/internal-unit.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
 //
 //===----------------------------------------------------------------------===//
 
 // Fortran internal I/O "units"
 
 #ifndef FORTRAN_RUNTIME_IO_INTERNAL_UNIT_H_
 #define FORTRAN_RUNTIME_IO_INTERNAL_UNIT_H_
 
 #include "connection.h"
-#include "descriptor.h"
+#include "flang/Runtime/descriptor.h"
 #include <cinttypes>
 #include <type_traits>
 
 namespace Fortran::runtime::io {
 
 class IoErrorHandler;
 
 // Points to (but does not own) a CHARACTER scalar or array for internal I/O.

flang/runtime/internal-unit.cpp

 //===-- runtime/internal-unit.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 "internal-unit.h"
-#include "descriptor.h"
 #include "io-error.h"
+#include "flang/Runtime/descriptor.h"
 #include <algorithm>
 #include <type_traits>
 
 namespace Fortran::runtime::io {
 
 template <Direction DIR>
 InternalDescriptorUnit<DIR>::InternalDescriptorUnit(
     Scalar scalar, std::size_t length) {

flang/runtime/io-api.cpp

 //===-- runtime/io-api.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
 //
 //===----------------------------------------------------------------------===//
 
 // Implements the I/O statement API
 
-#include "io-api.h"
+#include "flang/Runtime/io-api.h"
 #include "descriptor-io.h"
-#include "descriptor.h"
 #include "edit-input.h"
 #include "edit-output.h"
 #include "environment.h"
 #include "format.h"
 #include "io-stmt.h"
-#include "memory.h"
 #include "terminator.h"
 #include "tools.h"
 #include "unit.h"
+#include "flang/Runtime/descriptor.h"
+#include "flang/Runtime/memory.h"
 #include <cstdlib>
 #include <memory>
 
 namespace Fortran::runtime::io {
 
 const char *InquiryKeywordHashDecode(
     char *buffer, std::size_t n, InquiryKeywordHash hash) {
   if (n < 1) {

flang/runtime/io-error.h

 // and those that the user program has chosen to handle are recorded
 // so that the highest-priority one can be returned as IOSTAT=.
 // IOSTAT error codes are raw errno values augmented with values for
 // Fortran-specific errors.
 
 #ifndef FORTRAN_RUNTIME_IO_ERROR_H_
 #define FORTRAN_RUNTIME_IO_ERROR_H_
 
-#include "iostat.h"
-#include "memory.h"
 #include "terminator.h"
+#include "flang/Runtime/iostat.h"
+#include "flang/Runtime/memory.h"
 #include <cinttypes>
 
 namespace Fortran::runtime::io {
 
 // See 12.11 in Fortran 2018
 class IoErrorHandler : public Terminator {
 public:
   using Terminator::Terminator;

flang/runtime/io-error.cpp

 //===-- runtime/io-error.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 "io-error.h"
 #include "config.h"
-#include "magic-numbers.h"
 #include "tools.h"
+#include "flang/Runtime/magic-numbers.h"
 #include <cerrno>
 #include <cstdarg>
 #include <cstdio>
 #include <cstring>
 
 namespace Fortran::runtime::io {
 
 void IoErrorHandler::SignalError(int iostatOrErrno, const char *msg, ...) {

flang/runtime/io-stmt.h

 //===-- runtime/io-stmt.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
 //
 //===----------------------------------------------------------------------===//
 
 // Representations of the state of an I/O statement in progress
 
 #ifndef FORTRAN_RUNTIME_IO_STMT_H_
 #define FORTRAN_RUNTIME_IO_STMT_H_
 
 #include "connection.h"
-#include "descriptor.h"
 #include "file.h"
 #include "format.h"
 #include "internal-unit.h"
-#include "io-api.h"
 #include "io-error.h"
+#include "flang/Runtime/descriptor.h"
+#include "flang/Runtime/io-api.h"
 #include <functional>
 #include <type_traits>
 #include <variant>
 
 namespace Fortran::runtime::io {
 
 class ExternalFileUnit;
 class ChildIo;

flang/runtime/io-stmt.cpp

 //===-- runtime/io-stmt.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 "io-stmt.h"
 #include "connection.h"
 #include "format.h"
-#include "memory.h"
 #include "tools.h"
 #include "unit.h"
+#include "flang/Runtime/memory.h"
 #include <algorithm>
 #include <cstdio>
 #include <cstring>
 #include <limits>
 
 namespace Fortran::runtime::io {
 
 int IoStatementBase::EndIoStatement() { return GetIoStat(); }

flang/runtime/iostat.cpp

 //===-- runtime/iostat.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 "iostat.h"
+#include "flang/Runtime/iostat.h"
 
 namespace Fortran::runtime::io {
 const char *IostatErrorString(int iostat) {
   switch (iostat) {
   case IostatOk:
     return "No error";
   case IostatEnd:
     return "End of file during input";

flang/runtime/main.cpp

 //===-- runtime/main.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 "main.h"
+#include "flang/Runtime/main.h"
 #include "environment.h"
 #include "terminator.h"
 #include <cfenv>
 #include <cstdio>
 #include <cstdlib>
 
 static void ConfigureFloatingPoint() {
 #ifdef feclearexcept // a macro in some environments; omit std::

flang/runtime/matmul.cpp

 //
 // This implementation must handle all combinations of numeric types and
 // kinds (100 - 165 cases depending on the target), plus all combinations
 // of logical kinds (16).  A single template undergoes many instantiations
 // to cover all of the valid possibilities.
 //
 // Places where BLAS routines could be called are marked as TODO items.
 
-#include "matmul.h"
-#include "cpp-type.h"
-#include "descriptor.h"
+#include "flang/Runtime/matmul.h"
 #include "terminator.h"
 #include "tools.h"
+#include "flang/Runtime/cpp-type.h"
+#include "flang/Runtime/descriptor.h"
 
 namespace Fortran::runtime {
 
 template <TypeCategory RCAT, int RKIND, typename XT, typename YT>
 class Accumulator {
 public:
   // Accumulate floating-point results in (at least) double precision
   using Result = CppTypeFor<RCAT,

flang/runtime/memory.cpp

 //===-- runtime/memory.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 "memory.h"
+#include "flang/Runtime/memory.h"
 #include "terminator.h"
 #include <cstdlib>
 
 namespace Fortran::runtime {
 
 void *AllocateMemoryOrCrash(const Terminator &terminator, std::size_t bytes) {
   if (void *p{std::malloc(bytes)}) {
     return p;

flang/runtime/misc-intrinsic.cpp

 //===-- runtime/misc-intrinsic.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 "misc-intrinsic.h"
-#include "descriptor.h"
+#include "flang/Runtime/misc-intrinsic.h"
 #include "terminator.h"
+#include "flang/Runtime/descriptor.h"
 #include <algorithm>
 #include <cstring>
 
 namespace Fortran::runtime {
 extern "C" {
 
 void RTNAME(Transfer)(Descriptor &result, const Descriptor &source,
     const Descriptor &mold, const char *sourceFile, int line) {

flang/runtime/namelist.cpp

 //===-- runtime/namelist.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 "namelist.h"
 #include "descriptor-io.h"
-#include "io-api.h"
 #include "io-stmt.h"
+#include "flang/Runtime/io-api.h"
 #include <cstring>
 #include <limits>
 
 namespace Fortran::runtime::io {
 
 // Max size of a group, symbol or component identifier that can appear in
 // NAMELIST input, plus a byte for NUL termination.
 static constexpr std::size_t nameBufferSize{201};

flang/runtime/numeric.cpp

 //===-- runtime/numeric.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 "numeric.h"
+#include "flang/Runtime/numeric.h"
 #include "flang/Common/long-double.h"
 #include <climits>
 #include <cmath>
 #include <limits>
 
 namespace Fortran::runtime {
 
 // AINT

flang/runtime/pointer.cpp

 //===-- runtime/pointer.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 "pointer.h"
+#include "flang/Runtime/pointer.h"
 #include "derived.h"
 #include "stat.h"
 #include "terminator.h"
 #include "tools.h"
 #include "type-info.h"
 
 namespace Fortran::runtime {
 extern "C" {

flang/runtime/product.cpp

 //===-- runtime/product.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
 //
 //===----------------------------------------------------------------------===//
 
 // Implements PRODUCT for all required operand types and shapes.
 
 #include "reduction-templates.h"
-#include "reduction.h"
 #include "flang/Common/long-double.h"
+#include "flang/Runtime/reduction.h"
 #include <cinttypes>
 #include <complex>
 
 namespace Fortran::runtime {
 template <typename INTERMEDIATE> class NonComplexProductAccumulator {
 public:
   explicit NonComplexProductAccumulator(const Descriptor &array)
       : array_{array} {}

flang/runtime/random.cpp

 //===-- runtime/random.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
 //
 //===----------------------------------------------------------------------===//
 
 // Implements the intrinsic subroutines RANDOM_INIT, RANDOM_NUMBER, and
 // RANDOM_SEED.
 
-#include "random.h"
-#include "cpp-type.h"
-#include "descriptor.h"
+#include "flang/Runtime/random.h"
 #include "lock.h"
 #include "flang/Common/leading-zero-bit-count.h"
 #include "flang/Common/uint128.h"
+#include "flang/Runtime/cpp-type.h"
+#include "flang/Runtime/descriptor.h"
 #include <algorithm>
 #include <cmath>
 #include <cstdint>
 #include <ctime>
 #include <limits>
 #include <memory>
 #include <random>
 

flang/runtime/reduction-templates.h

 //   return integer vectors of some kind, not scalars; a caller-supplied
 //   descriptor is used
 // * Character-valued reductions (MAXVAL & MINVAL) return arbitrary
 //   length results, dynamically allocated in a caller-supplied descriptor
 
 #ifndef FORTRAN_RUNTIME_REDUCTION_TEMPLATES_H_
 #define FORTRAN_RUNTIME_REDUCTION_TEMPLATES_H_
 
-#include "cpp-type.h"
-#include "descriptor.h"
 #include "terminator.h"
 #include "tools.h"
+#include "flang/Runtime/cpp-type.h"
+#include "flang/Runtime/descriptor.h"
 
 namespace Fortran::runtime {
 
 // Reductions are implemented with *accumulators*, which are instances of
 // classes that incrementally build up the result (or an element thereof) during
 // a traversal of the unmasked elements of an array.  Each accumulator class
 // supports a constructor (which captures a reference to the array), an
 // AccumulateAt() member function that applies supplied subscripts to the

flang/runtime/reduction.cpp

 //===-- runtime/reduction.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
 //
 //===----------------------------------------------------------------------===//
 
 // Implements ALL, ANY, COUNT, IALL, IANY, IPARITY, & PARITY for all required
 // operand types and shapes.
 //
 // DOT_PRODUCT, FINDLOC, MATMUL, SUM, and PRODUCT are in their own eponymous
 // source files.
 // NORM2, MAXLOC, MINLOC, MAXVAL, and MINVAL are in extrema.cpp.
-//
-// TODO: IALL, IANY
 
-#include "reduction.h"
+#include "flang/Runtime/reduction.h"
 #include "reduction-templates.h"
 #include <cinttypes>
 
 namespace Fortran::runtime {
 
 // IALL, IANY, IPARITY
 
 template <typename INTERMEDIATE> class IntegerAndAccumulator {

flang/runtime/stat.h

 //===-- runtime/stat.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
 //
 //===----------------------------------------------------------------------===//
 
 // Defines the values returned by the runtime for STAT= specifiers
 // on executable statements.
 
 #ifndef FORTRAN_RUNTIME_STAT_H_
 #define FORTRAN_RUNTIME_STAT_H_
-#include "magic-numbers.h"
 #include "flang/ISO_Fortran_binding.h"
+#include "flang/Runtime/magic-numbers.h"
 namespace Fortran::runtime {
 
 class Descriptor;
 class Terminator;
 
 // The value of STAT= is zero when no error condition has arisen.
 
 enum Stat {

flang/runtime/stat.cpp

 //===-- runtime/stat.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 "stat.h"
-#include "descriptor.h"
 #include "terminator.h"
+#include "flang/Runtime/descriptor.h"
 
 namespace Fortran::runtime {
 const char *StatErrorString(int stat) {
   switch (stat) {
   case StatOk:
     return "No error";
 
   case StatBaseNull:

flang/runtime/stop.cpp

 //===-- runtime/stop.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 "stop.h"
+#include "flang/Runtime/stop.h"
 #include "file.h"
 #include "io-error.h"
 #include "terminator.h"
 #include "unit.h"
 #include <cfenv>
 #include <cstdio>
 #include <cstdlib>
 

flang/runtime/sum.cpp

 //===-- runtime/sum.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
 //
 //===----------------------------------------------------------------------===//
 
 // Implements SUM for all required operand types and shapes.
 //
 // Real and complex SUM reductions attempt to reduce floating-point
 // cancellation on intermediate results by using "Kahan summation"
 // (basically the same as manual "double-double").
 
 #include "reduction-templates.h"
-#include "reduction.h"
 #include "flang/Common/long-double.h"
+#include "flang/Runtime/reduction.h"
 #include <cinttypes>
 #include <complex>
 
 namespace Fortran::runtime {
 
 template <typename INTERMEDIATE> class IntegerSumAccumulator {
 public:
   explicit IntegerSumAccumulator(const Descriptor &array) : array_{array} {}

flang/runtime/terminator.h

 //===-- runtime/terminator.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
 //
 //===----------------------------------------------------------------------===//
 
 // Termination of the image
 
 #ifndef FORTRAN_RUNTIME_TERMINATOR_H_
 #define FORTRAN_RUNTIME_TERMINATOR_H_
 
-#include "entry-names.h"
+#include "flang/Runtime/entry-names.h"
 #include <cstdarg>
 
 namespace Fortran::runtime {
 
 // A mixin class for statement-specific image error termination
 // for errors detected in the runtime library
 class Terminator {
 public:

flang/runtime/time-intrinsic.cpp

 //===-- runtime/time-intrinsic.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
 //
 //===----------------------------------------------------------------------===//
 
 // Implements time-related intrinsic subroutines.
 
-#include "time-intrinsic.h"
-
-#include "descriptor.h"
+#include "flang/Runtime/time-intrinsic.h"
 #include "terminator.h"
 #include "tools.h"
+#include "flang/Runtime/descriptor.h"
 #include <algorithm>
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <ctime>
 #ifndef _WIN32
 #include <sys/time.h> // gettimeofday

flang/runtime/tools.h

 //===-- 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_RUNTIME_TOOLS_H_
 #define FORTRAN_RUNTIME_TOOLS_H_
 
-#include "cpp-type.h"
-#include "descriptor.h"
-#include "memory.h"
 #include "terminator.h"
 #include "flang/Common/long-double.h"
+#include "flang/Runtime/cpp-type.h"
+#include "flang/Runtime/descriptor.h"
+#include "flang/Runtime/memory.h"
 #include <functional>
 #include <map>
 #include <type_traits>
 
 namespace Fortran::runtime {
 
 class Terminator;
 

flang/runtime/transformational.cpp

 // CSHIFT, EOSHIFT, PACK, RESHAPE, SPREAD, TRANSPOSE, and UNPACK.
 //
 // Many of these are defined in the 2018 standard with text that makes sense
 // only if argument arrays have lower bounds of one.  Rather than interpret
 // these cases as implying a hidden constraint, these implementations
 // work with arbitrary lower bounds.  This may be technically an extension
 // of the standard but it more likely to conform with its intent.
 
-#include "transformational.h"
+#include "flang/Runtime/transformational.h"
 #include "copy.h"
 #include "terminator.h"
 #include "tools.h"
 #include <algorithm>
 
 namespace Fortran::runtime {
 
 // Utility for CSHIFT & EOSHIFT rank > 1 cases that determines the shift count

flang/runtime/type-code.cpp

 //===-- runtime/type-code.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 "type-code.h"
+#include "flang/Runtime/type-code.h"
 
 namespace Fortran::runtime {
 
 TypeCode::TypeCode(TypeCategory f, int kind) {
   switch (f) {
   case TypeCategory::Integer:
     switch (kind) {
     case 1:

flang/runtime/type-info.h

 //===-- runtime/type-info.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_RUNTIME_TYPE_INFO_H_
 #define FORTRAN_RUNTIME_TYPE_INFO_H_
 
 // A C++ perspective of the derived type description schemata in
 // flang/module/__fortran_type_info.f90.
 
-#include "descriptor.h"
 #include "terminator.h"
 #include "flang/Common/Fortran.h"
 #include "flang/Common/bit-population-count.h"
+#include "flang/Runtime/descriptor.h"
 #include <cinttypes>
 #include <memory>
 #include <optional>
 
 namespace Fortran::runtime::typeInfo {
 
 class DerivedType;
 

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 "memory.h"
 #include "unit.h"
+#include "flang/Runtime/memory.h"
 #include <cstdlib>
 
 namespace Fortran::runtime::io {
 
 class UnitMap {
 public:
   ExternalFileUnit *LookUp(int n) {
     CriticalSection critical{lock_};

flang/runtime/unit.h

 
 #include "buffer.h"
 #include "connection.h"
 #include "file.h"
 #include "format.h"
 #include "io-error.h"
 #include "io-stmt.h"
 #include "lock.h"
-#include "memory.h"
 #include "terminator.h"
+#include "flang/Runtime/memory.h"
 #include <cstdlib>
 #include <cstring>
 #include <optional>
 #include <variant>
 
 namespace Fortran::runtime::io {
 
 class UnitMap;

flang/test/Runtime/no-cpp-dep.c

 /*
 This test makes sure that flang's runtime does not depend on the C++ runtime
 library. It tries to link this simple file against libFortranRuntime.a with
 a C compiler.
 
 REQUIRES: c-compiler
 
-RUN: %cc -std=c90 %s -I%runtimeincludes %libruntime %libdecimal -o /dev/null
+RUN: %cc -std=c90 %s -I%include %libruntime %libdecimal -o /dev/null
 */
 
-#include "entry-names.h"
+#include "flang/Runtime/entry-names.h"
 
 /*
 Manually add declarations for the runtime functions that we want to make sure
 we're testing. We can't include any headers directly since they likely contain
 C++ code that would explode here.
 */
 double RTNAME(CpuTime)();
 
 int main() {
   double x = RTNAME(CpuTime)();
   return x;
 }

flang/test/lit.cfg.py

ToolSubst('%flang_fc1', command=FindTool('flang-new'), extra_args=['-fc1'],
         unresolved='fatal')]
 
 # Define some variables to help us test that the flang runtime doesn't depend on
 # the C++ runtime libraries. For this we need a C compiler. If for some reason
 # we don't have one, we can just disable the test.
 if config.cc:
     libruntime = os.path.join(config.flang_lib_dir, 'libFortranRuntime.a')
     libdecimal = os.path.join(config.flang_lib_dir, 'libFortranDecimal.a')
-    includes = os.path.join(config.flang_src_dir, 'runtime')
+    include = os.path.join(config.flang_src_dir, 'include')
 
-    if os.path.isfile(libruntime) and os.path.isfile(libdecimal) and os.path.isdir(includes):
+    if os.path.isfile(libruntime) and os.path.isfile(libdecimal) and os.path.isdir(include):
         config.available_features.add('c-compiler')
         tools.append(ToolSubst('%cc', command=config.cc, unresolved='fatal'))
         tools.append(ToolSubst('%libruntime', command=libruntime,
             unresolved='fatal'))
         tools.append(ToolSubst('%libdecimal', command=libdecimal,
             unresolved='fatal'))
-        tools.append(ToolSubst('%runtimeincludes', command=includes,
+        tools.append(ToolSubst('%include', command=include,
             unresolved='fatal'))
 
 if config.flang_standalone_build:
     llvm_config.add_tool_substitutions(tools, [config.flang_llvm_tools_dir])
 else:
     llvm_config.add_tool_substitutions(tools, config.llvm_tools_dir)
 
 # Enable libpgmath testing
 result = lit_config.params.get("LIBPGMATH")
 if result:
     config.environment["LIBPGMATH"] = True

flang/unittests/Evaluate/ISO-Fortran-binding.cpp

 #include "testing.h"
-#include "../../include/flang/ISO_Fortran_binding.h"
-#include "../../runtime/descriptor.h"
+#include "flang/ISO_Fortran_binding.h"
+#include "flang/Runtime/descriptor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <type_traits>
 
 using namespace Fortran::runtime;
 using namespace Fortran::ISO;
 
 // CFI_CDESC_T test helpers
 template <int rank> class Test_CFI_CDESC_T {

flang/unittests/Evaluate/reshape.cpp

 #include "testing.h"
-#include "../../runtime/descriptor.h"
-#include "../../runtime/transformational.h"
+#include "flang/Runtime/descriptor.h"
+#include "flang/Runtime/transformational.h"
 #include <cinttypes>
 
 using namespace Fortran::common;
 using namespace Fortran::runtime;
 
 int main() {
   static const SubscriptValue sourceExtent[]{2, 3, 4};
   auto source{Descriptor::Create(TypeCategory::Integer, sizeof(std::int32_t),

flang/unittests/Runtime/CharacterTest.cpp

 //===-- flang/unittests/RuntimeGTest/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
 // in Fortran.
 
-#include "../../runtime/character.h"
+#include "flang/Runtime/character.h"
 #include "gtest/gtest.h"
-#include "../../runtime/descriptor.h"
+#include "flang/Runtime/descriptor.h"
 #include <cstring>
 #include <functional>
 #include <tuple>
 #include <vector>
 
 using namespace Fortran::runtime;
 
 using CharacterTypes = ::testing::Types<char, char16_t, char32_t>;

flang/unittests/Runtime/CommandTest.cpp

 //===-- flang/unittests/RuntimeGTest/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 "../../runtime/command.h"
+#include "flang/Runtime/command.h"
 #include "gtest/gtest.h"
-#include "../../runtime/descriptor.h"
-#include "../../runtime/main.h"
+#include "flang/Runtime/descriptor.h"
+#include "flang/Runtime/main.h"
 
 using namespace Fortran::runtime;
 
 TEST(ArgumentCount, ZeroArguments) {
   const char *argv[]{"aProgram"};
   RTNAME(ProgramStart)(1, argv, {});
   EXPECT_EQ(0, RTNAME(ArgumentCount)());
 }

flang/unittests/Runtime/ExternalIOTest.cpp

 //===-- flang/unittests/RuntimeGTest/ExternalIOTest.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
 //
 //===----------------------------------------------------------------------===//
 //
 // Sanity test for all external I/O modes
 //
 //===----------------------------------------------------------------------===//
 
 #include "CrashHandlerFixture.h"
 #include "gtest/gtest.h"
-#include "../../runtime/io-api.h"
-#include "../../runtime/main.h"
-#include "../../runtime/stop.h"
+#include "flang/Runtime/io-api.h"
+#include "flang/Runtime/main.h"
+#include "flang/Runtime/stop.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstring>
 
 using namespace Fortran::runtime::io;
 
 struct ExternalIOTests : public CrashHandlerFixture {};
 
 TEST(ExternalIOTests, TestDirectUnformatted) {

flang/unittests/Runtime/ListInputTest.cpp

 //===-- flang/unittests/RuntimeGTest/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"
-#include "../../runtime/descriptor.h"
-#include "../../runtime/io-api.h"
 #include "../../runtime/io-error.h"
+#include "flang/Runtime/descriptor.h"
+#include "flang/Runtime/io-api.h"
 
 using namespace Fortran::runtime;
 using namespace Fortran::runtime::io;
 
 // Pads characters with whitespace when needed
 void SetCharacter(char *to, std::size_t n, const char *from) {
   auto len{std::strlen(from)};
   std::memcpy(to, from, std::min(len, n));

flang/unittests/Runtime/Matmul.cpp

 //===-- flang/unittests/RuntimeGTest/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 "../../runtime/matmul.h"
+#include "flang/Runtime/matmul.h"
 #include "gtest/gtest.h"
 #include "tools.h"
-#include "../../runtime/allocatable.h"
-#include "../../runtime/cpp-type.h"
-#include "../../runtime/descriptor.h"
-#include "../../runtime/type-code.h"
+#include "flang/Runtime/allocatable.h"
+#include "flang/Runtime/cpp-type.h"
+#include "flang/Runtime/descriptor.h"
+#include "flang/Runtime/type-code.h"
 
 using namespace Fortran::runtime;
 using Fortran::common::TypeCategory;
 
 TEST(Matmul, Basic) {
   // X 0 2 4   Y 6  9   V -1 -2
   //   1 3 5     7 10
   //             8 11

flang/unittests/Runtime/MiscIntrinsic.cpp

 //===-- flang/unittests/RuntimeGTest/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"
 #include "tools.h"
-#include "../../runtime/allocatable.h"
-#include "../../runtime/cpp-type.h"
-#include "../../runtime/descriptor.h"
-#include "../../runtime/misc-intrinsic.h"
+#include "flang/Runtime//misc-intrinsic.h"
+#include "flang/Runtime/allocatable.h"
+#include "flang/Runtime/cpp-type.h"
+#include "flang/Runtime/descriptor.h"
 
 using namespace Fortran::runtime;
 
 // TRANSFER examples from Fortran 2018
 
 TEST(MiscIntrinsic, TransferScalar) {
   StaticDescriptor<2, true, 2> staticDesc[2];
   auto &result{staticDesc[0].descriptor()};

flang/unittests/Runtime/Namelist.cpp

 //===-- flang/unittests/RuntimeGTest/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"
 #include "CrashHandlerFixture.h"
 #include "tools.h"
-#include "../../runtime/descriptor.h"
-#include "../../runtime/io-api.h"
+#include "flang/Runtime/descriptor.h"
+#include "flang/Runtime/io-api.h"
 #include <algorithm>
 #include <cinttypes>
 #include <complex>
 #include <cstring>
 #include <gtest/gtest.h>
 #include <limits>
 #include <string>
 #include <vector>

flang/unittests/Runtime/Numeric.cpp

 //===-- flang/unittests/RuntimeGTest/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 "../../runtime/numeric.h"
+#include "flang/Runtime/numeric.h"
 #include "gtest/gtest.h"
 #include <cmath>
 #include <limits>
 
 using namespace Fortran::runtime;
 using Fortran::common::TypeCategory;
 template <int KIND> using Int = CppTypeFor<TypeCategory::Integer, KIND>;
 template <int KIND> using Real = CppTypeFor<TypeCategory::Real, KIND>;

flang/unittests/Runtime/NumericalFormatTest.cpp

 //===-- flang/unittests/RuntimeGTest/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"
-#include "../../runtime/descriptor.h"
-#include "../../runtime/io-api.h"
+#include "flang/Runtime/descriptor.h"
+#include "flang/Runtime/io-api.h"
 #include <algorithm>
 #include <array>
 #include <cstring>
 #include <gtest/gtest.h>
 #include <tuple>
 
 using namespace Fortran::runtime;
 using namespace Fortran::runtime::io;

flang/unittests/Runtime/Random.cpp

 //===-- flang/unittests/RuntimeGTest/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 "../../runtime/random.h"
+#include "flang/Runtime//random.h"
 #include "gtest/gtest.h"
-#include "../../runtime/descriptor.h"
-#include "../../runtime/type-code.h"
+#include "flang/Runtime/descriptor.h"
+#include "flang/Runtime/type-code.h"
 #include <cmath>
 
 using namespace Fortran::runtime;
 
 TEST(RandomNumber, Real4) {
   StaticDescriptor<1> statDesc;
   Descriptor &harvest{statDesc.descriptor()};
   static constexpr int n{10000};

flang/unittests/Runtime/Reduction.cpp

 //===-- flang/unittests/RuntimeGTest/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 "../../runtime/reduction.h"
+#include "flang/Runtime/reduction.h"
 #include "gtest/gtest.h"
 #include "tools.h"
-#include "../../runtime/allocatable.h"
-#include "../../runtime/cpp-type.h"
-#include "../../runtime/descriptor.h"
-#include "../../runtime/type-code.h"
+#include "flang/Runtime/allocatable.h"
+#include "flang/Runtime/cpp-type.h"
+#include "flang/Runtime/descriptor.h"
+#include "flang/Runtime/type-code.h"
 #include <cstdint>
 #include <cstring>
 #include <string>
 #include <vector>
 
 using namespace Fortran::runtime;
 using Fortran::common::TypeCategory;
 

flang/unittests/Runtime/RuntimeCrashTest.cpp

 //===-- flang/unittests/RuntimeGTest/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
 /// runtime components and ensure the test fixture handles crashes as we expect.
 //
 //===----------------------------------------------------------------------===//
 #include "CrashHandlerFixture.h"
-#include "../../runtime/io-api.h"
 #include "../../runtime/terminator.h"
+#include "flang/Runtime/io-api.h"
 #include <gtest/gtest.h>
 
 using namespace Fortran::runtime;
 using namespace Fortran::runtime::io;
 
 //------------------------------------------------------------------------------
 /// Test crashes through direct calls to terminator methods
 //------------------------------------------------------------------------------

flang/unittests/Runtime/Time.cpp

 //===-- flang/unittests/RuntimeGTest/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"
-#include "../../runtime/time-intrinsic.h"
+#include "flang/Runtime/time-intrinsic.h"
 #include <algorithm>
 #include <cctype>
 #include <charconv>
 #include <string>
 
 using namespace Fortran::runtime;
 
 TEST(TimeIntrinsics, CpuTime) {

flang/unittests/Runtime/Transformational.cpp

 //===-- flang/unittests/RuntimeGTest/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 "../../runtime/transformational.h"
+#include "flang/Runtime/transformational.h"
 #include "gtest/gtest.h"
 #include "tools.h"
-#include "../../runtime/type-code.h"
+#include "flang/Runtime/type-code.h"
 
 using namespace Fortran::runtime;
 using Fortran::common::TypeCategory;
 
 TEST(Transformational, Shifts) {
   // ARRAY  1 3 5
   //        2 4 6
   auto array{MakeArray<TypeCategory::Integer, 4>(

flang/unittests/Runtime/tools.h

 //===-- flang/unittests/RuntimeGTest/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_
 #define FORTRAN_UNITTESTS_RUNTIME_TOOLS_H_
 
 #include "gtest/gtest.h"
-#include "../../runtime/allocatable.h"
-#include "../../runtime/cpp-type.h"
-#include "../../runtime/descriptor.h"
-#include "../../runtime/type-code.h"
+#include "flang/Runtime/allocatable.h"
+#include "flang/Runtime/cpp-type.h"
+#include "flang/Runtime/descriptor.h"
+#include "flang/Runtime/type-code.h"
 #include <cstdint>
 #include <cstring>
 #include <vector>
 
 namespace Fortran::runtime {
 
 template <typename A>
 static void StoreElement(void *p, const A &x, std::size_t bytes) {