[Flang] [FlangRT] Introduce FlangRT project as solution to Flang's runtime LLVM integration

[pscoro]

Summary

See discourse thread https://discourse.llvm.org/t/rfc-support-cmake-option-to-control-link-type-built-for-flang-runtime-libraries/71602/18 for full details.

Flang-rt is the new library target for the flang runtime libraries. It builds the Flang-rt library (which contains the sources of FortranRuntime and FortranDecimal) and the Fortran_main library. See documentation in this patch for detailed description (flang-rt/docs/GettingStarted.md).

This patch aims to:

• integrate Flang's runtime into existing llvm infrasturcture so that Flang's runtime can be built similarly to other runtimes via the runtimes target or via the llvm target as an enabled runtime
• decouple the FortranDecimal library sources that were used by both compiler and runtime so that different build configurations can be applied for compiler vs runtime
• add support for running flang-rt testsuites, which were created by migrating relevant tests from flang/test and flang/unittest to flang-rt/test and flang-rt/unittest, using a new check-flang-rt target.
• provide documentation on how to build and use the new FlangRT runtime

[pscoro]

flang/cmake/modules/AddFlang.cmake

68

This is something I am still investigating.

PIC is needed for the object libraries if FlangRT is being built as shared. I am thinking I will add a condition for this to only be enabled for FortranRuntime and FortranDecimalRT. Also, if my understanding is correct, if we build FlangRT as static this change may also not be needed (and keeping it may be slightly less optimal?), so I may ad a condition for this as well.

My understanding of PIC is limited so if anybody sees any problems with my understanding please let me know.

flang/include/flang/Runtime/float128.h

42 ↗

(On Diff #538736)

Entirely uncertain why this code was giving me issues during my testing. I commented it out for the time being but I will take a closer look later. I hope that it is related to my setup and not something about the patch itself, however I will have to investigate further before I can draw any conclusions.

flang/lib/Decimal/CMakeLists.txt

62

The code in AddFlang.cmake seems to build object libraries for calls to add_flang_library by default when STATIC argument is passed.

flang/runtime/CMakeLists.txt

283

The code in AddFlang.cmake seems to build object libraries for calls to add_flang_library by default when STATIC argument is passed.

[phosek]

flang-rt/CMakeLists.txt

18–24

I don't think we should support building FlangRT as a standalone project. We've been moving all runtimes to the runtimes build, the only leftover is compiler-rt and our hope is to address that soon.

42–52

None of this should be needed if building in the runtimes build.

[pscoro]

Comment out some code that irrelevant to current object library approach

[pscoro]

Some small changes, still non functional

[pscoro]

Small changes, flang-rt seems to work with the flang-new driver now.

[pscoro]

Fix driver usage of flang-rt

[pscoro]

Fix build failures

[vzakhari]

flang-rt/CMakeLists.txt

18–24

Hi @phosek, can you please explain what you mean by "We've been moving all runtimes to the runtimes build"? Can you please share references to the pipeline for the "runtimes build"?

[pscoro]

flang-rt/CMakeLists.txt

18–24

If i understood correctly, i think @phosek is talking about building the flang-rt target directly (cmake llvm-project/flang-rt) when he says standalone. Meanwhile a runtimes build is cmake llvm-project/runtimes -DLLVM_ENABLE_RUNTIMES=flang-rt. I chose not to change anything yet because I was focused on some other bugs and was waiting for see if anybody else had input on this first. Also, in case my understanding is incorrect @phosek please correct me.

[phosek]

flang-rt/CMakeLists.txt

18–24

Yes, that is correct.

[pscoro]

Decided to remove all the commented code related to the previous approach (wrapper library). The code that exists currently is for the object library approach and is functional.

Currently, on phabricator there is a failing x64 Windows build. The failure happens during building, the compiler seems to run out of heap space? I don't see how this error could be related to my patch but if I am wrong and it is, please let me know.

[awarzynski]

clang/lib/Driver/ToolChains/CommonArgs.cpp

982–992

Am I correct thinking that:

• "<driver-path>/../lib" is for Fortran_main.a, and
• "<driver-path>/../runtimes/runtimes-bins/lib " is for libflang-rt?

Could you document this? Thanks!

[pscoro]

Added documentation for Flang-rt.

[pscoro]

clang/lib/Driver/ToolChains/CommonArgs.cpp

982–992

Yep thats right, documentation added

[awarzynski]

clang/lib/Driver/ToolChains/CommonArgs.cpp

982–992

Yep thats right, documentation added

Could you document _where_ these libraries are located? Also, could you add some relevant comments here? For example:

// Add search path for XYZ
llvm::sys::path::append(BuildLibPath, "lib");

flang/docs/Flang-rt.md

15–16 ↗

(On Diff #541040)

This statement is not quite true - the driver can do a lot without requiring these libraries. I suspect that you wanted o say that generating executables requires these libraries.

[nit] flang dirver --> Flang driver

17 ↗

(On Diff #541040)

Motivation for ...? It's not clear what the following section aims to achieve.

I think that it would be good to take a step beck and decide who this documented is intended for. If it's the end-user then, imho, this section doesn't belong here. In documentation like this I'd focus on "what" and "how" as opposed to "why".

Even if this document is intended for developers, I wouldn't focus too much on the original motivations for this change and instead explain the design and its benefits:

• possibility to build the runtime independently of Flang (what's the benefit of that?)
• CMake set-up that's consistent with other sub-projects in LLVM,
• a convenient wrapper for multiple (i.e. 2) Flang runtime libraries,
• automated logic to build shared and static version of the runtime libs (to enable supporting e.g. -static?).

I hope that this makes sense.

30–31 ↗

(On Diff #541040)

Could you document "why"?

35 ↗

(On Diff #541040)

Perhaps turn this into a link to the CMake definition?

61–63 ↗

(On Diff #541040)

1. Please add an example.
2. "you must add its path to the environment variable LD_LIBRARY_PATH" <-- this is just one way to provide a search path for the dynamic linker. There are other ways too. It would be good to clarify that a) one has to make the dynamic linker aware _where_ to look and that b) LD_LIBRARY_PATH is one such mechanism that can be used. But I would be careful not to "endorse" it - mishandling LD_LIBRARY_PATH can lead to tricky surprises.

[pscoro]

Updated documentation to address all nits

[pscoro]

clang/lib/Driver/ToolChains/CommonArgs.cpp

982–992

Could you document _where_ these libraries are located?

I've made the information more explicit in the documentation and added clarification that the ../runtimes/runtimes-bins/lib path happens for runtimes built as part of an llvm target build, but during standalone runtimes builds ../lib is used. (I am not sure why this behavior is what it is, but I don't think we should by changing or overriding the existing infrastructure)

[pscoro]

Removed support for "fully standalone" Flang-rt builds (ie CMake builds targeting llvm-project/flang-rt).
Flang-rt is now buildable via the llvm target or the runtimes target. See documentation for more
information.

[pscoro]

flang-rt/CMakeLists.txt

18–24

I gave this a couple days in case anybody else in the community wanted to voice their opinion but since there was no contradictions, I have removed support for targeting flang-rt directly. Flang-rt is now only buildable via the llvm target or the runtimes target. See documentation for details.

42–52

I did some further testing and removed the module paths and include statements that were not needed. However, not all of the lines could be removed, clang and flang specific paths/includes were missing so they were left in here.

[vzakhari]

flang-rt/CMakeLists.txt

18–24

Thank you for the explanation!

[efriedma]

flang/lib/Decimal/CMakeLists.txt

54

I think it would make sense to use explicit CMake variables for the "if' statements (i.e. make flang/CMakeLists.txt define BUILDING_FLANG, and make flang-rt/CMakeLists define BUILDING_FLANGRT) .

flang/runtime/CMakeLists.txt

282

This "if" doesn't make sense to me. If we're not building flang-rt, we shouldn't be here, so I don't see why you need an "if" in the first place.

[pscoro]

flang/runtime/CMakeLists.txt

282

add_subdirectory(runtime) is a line that still exists in flang/CMakeLists.txt. This exists because Fortran_main is still being built at the same time as the compiler, and to do so, the runtime subdirectory still needs to be added to flang (flang/CMakeLists.txt -> add_subdirectory(runtime) -> flang/runtime/CMakeLists.txt -> add_subdirectory(FortranMain). The solution I had was to just add a check around the FortranRuntime library production so that it only happens for flang-rt.

If you have a better solution let me know. Overall, I'm not sure if Fortran_main is currently being handled in the best way (ie, its still being built at the same time as the compiler, which doesn't seem ideal), but am not sure what course of action to take with it since it doesn't really belong in flang-rt either (see documentation for details)

[efriedma]

flang/runtime/CMakeLists.txt

282

Fortran_main should be "part of" flang-rt in the sense that building flang-rt builds it. Most of the same reasons we want to build flang-rt.a as a runtime apply.

Since the output needs to be separate, building flang-rt should produce two libraries: flang-rt.a and FortranMain.a.

[pscoro]

flang/runtime/CMakeLists.txt

282

I agree with this idea and have been trying to make it work but in the process I discovered that my "fix" above (if (DEFINED LLVM_ENABLE_RUNTIMES AND "flang-rt" IN_LIST LLVM_ENABLE_RUNTIMES)) is worse than I thought.

By building the llvm target with flang-rt as an enabled runtime, we are essentially saying: build the flang compiler, and then invoke cmake again to build the runtimes project (externally), which builds flang-rt.

The problem is that check-all depends on check-flang which depends on the runtime. The if guard above was not actually doing what I thought it was, and the reason why configuring didnt fail with "flang-rt does not exist" is because the if guard was still evaluating to true. Basically, the guard ensured that FortranRuntime was only being built if flang-rt is built, but the add_library call was still being reached *during the configuration of the flang compiler*.

I am having trouble dealing with this dependency since runtimes get built externally (and after the compiler is built, which is when the check-all custom target gets built). I will have to investigate more closely how other runtimes handle this. My initial thought was perhaps the runtime testing should be decoupled from check-flang/check-all however I don't know if that's a good idea, and I also think that only helps with flang-rt, but if Fortran_main is required to build any executable I imagine that it should be needed for check-flang?

This is just an update of whats holding me back right now. If you have any tips please let me know. Thanks for bringing this to my attention.

[efriedma]

flang/runtime/CMakeLists.txt

282

For comparison, check-clang doesn't require any runtime libraries at all. All the checks only check the generated LLVM IR/driver commands/etc. Any tests that require runtime execution go into either the regression tests for the runtimes themselves, or into lllvm-test-suite.

Probably check-flang should do something similar. It probably makes sense to add a check-flang-rt target or something like that. (Not sure which existing flang tests are impacted.)

[pscoro]

flang/runtime/CMakeLists.txt

282

If we are decoupling the affected tests from flang-rt, then I think the only component left coupled (that I'd argue shouldn't be coupled) is the runtime source files. I'm seeing that for all the other runtimes in the llvm-project, the sources exist in a top level directory. Would it make sense and be feasible for flang-rt to act similarly?

Comparing to the infrastructure for compiler-rt, I've been entertaining the idea that FortranRuntime and FortranMain can be treated as a library with sources defined in flang-rt/lib/FortranRuntime and flang-rt/lib/FortranMain, similar to how compiler-rt has libraries like compiler-rt/lib/asan that are added to the final compiler-rt target.

FortranDecimalRT's sources would still be gathered from the Flang source directory, which would have to be known by flang-rt (also I see that multiple runtime files include flang/Common headers (but no sources get linked), so flang-rt would need to be aware of flang's directory for that reason too)

Do you think this idea worth pursuing or has the scope expanded way past the original intention?

[klausler]

flang/runtime/CMakeLists.txt

282

This would make life more difficult for people (okay, me) doing most of their flang development in an out-of-tree mode.

[efriedma]

flang/runtime/CMakeLists.txt

282

I think reorganizing the source-code makes sense... but I suspect it'll turn into its own giant discussion, and it'll make it harder to review the patches. So maybe avoid doing that for now if you can.

[pscoro]

Added testing support and reworked a lot of the existing patch. check-flang-rt now exists and flang-rt is more fully structured and finished. This update includes up-to-date documentation on building/usage.

I will update the community slack and the discourse thread to make everyone aware that this patch is ready to be revisited

[pscoro]

flang/runtime/CMakeLists.txt

282

It took a couple weeks but the support for testing in flang-rt now exists. I understand that the size of the patch has grown significantly as a result. I will work with the community closely to try to make this digestible and to address and comments or concerns.

flang/runtime/sum.cpp

141

@klausler I don't plan on including this in this patch. This is related to https://reviews.llvm.org/D127025. I get an error about line 51:

auto next{x + correction_};

when building flang-rt via the runtimes target. It complains because x is a __float128 and correction is a long double. I am unsure as to why as I am unfamiliar with what this code does. Looking at the patch linked above I saw code similar to my addition here in other files so I tried to add it here and it seemed to fix my issues. It is just a wild guess though. Please let me know if you have anymore information or intuitions regarding this bug.

[pscoro]

Some of the testcases have been reformatted by clang-format when I updated the patch with arcanist. If the community is against introducing extra changes like these I would be happy to re-update my patch without clang-formatting these files.

[pscoro]

In order to keep the scope of this patch manageable, and because further discussion is warranted first, no source files have been moved from flang into flang-rt. Although I would imagine that this may be something we would want to do in the future in order to continue our efforts at decoupling compiler and runtime.

[efriedma]

The test changes look good to me.

flang/lib/Decimal/CMakeLists.txt

52–67

This add_compile_options(-fPIC) shouldn't be necessary?

[pscoro]

flang/lib/Decimal/CMakeLists.txt

52–67

Pretty sure you're right, let me build/test without it to make sure and I'll update if everything is alright

[pscoro]

Removed a few unnecessary lines of cmake

[pscoro]

Updated docs on using runtimes target, specified that -DCMAKE_C_COMPILER=$BUILD_DIR/bin/clang should be set. It seems that a small set (4) of gtest unittests do not run if the default /usr/bin/cc compiler is used.

[pscoro]

Reverting change to docs, irrelevant.

[pscoro]

Ping

I will not be able to help out with flang (for a while) after the end of August so the sooner I can get this reviewed the smoother the landing process will be for myself and the community. So I would appreciate if I could get reviewers looking at this as soon as possible. Thanks

[klausler]

flang-rt/unittests/FortranEvaluate/testing.h

2

Why was this file (and testing.cpp) added instead of being moved, like other files were?

Why are the unit tests for the Evaluate library being moved into flang-rt? The Evaluate library is only used by the compiler for constant folding and expression processing; it is not part of the runtime.

[pscoro]

flang-rt/unittests/FortranEvaluate/testing.h

2

There are 2 unit tests (reshape and ISO-Fortran-Binding) that include runtime headers. Neither of these tests included headers from any other Flang libraries so I chose to move them under flang-rt. I preserved the testsuite name FortranEvaluate because thats where they came from. I am not too confident in this decision. Let me know if there is an alternative you prefer.

These testing files were copied because they are needed for other tests that remained in flang/unittests/FortranEvaluate and for these 2 unit tests that I moved to flang-rt

[pscoro]

Removed a todo

[madanial]

Pinging for review. I will be taking over this patch from Paul, but Paul will still be around to answer any questions.

[efriedma]

Maybe split the changes to reformat the unittests into a separate patch?

Otherwise, I'm happy with the current state of this patch, but probably someone more active in flang should approve.

[ldionne]

runtimes/CMakeLists.txt

20

This shouldn't be necessary, CMake already creates a Project_SOURCE_DIR variable for each declared project() IIRC.

[h-vetinari]

Any update on this patchset? With the migration away from phabricator, it'd be good to get this in soonish (otherwise it'll need to be moved to github).

[madanial]

Using the Project_SOURCE_DIR variable in cmake instead of setting a new variable

runtimes/CMakeLists.txt

20

Updated thanks for the review

[madanial]

In D154869#4628847, @efriedma wrote:

Maybe split the changes to reformat the unittests into a separate patch?

Otherwise, I'm happy with the current state of this patch, but probably someone more active in flang should approve.

I believe the changes are very trival to the unittests, would we be able to keep them as part of this patch and avoid moving it to github

[DanielCChen]

@all
It seems all the comments are addressed or explained. If there is no objection from the reviewers, we would like to land this patch in Phabricator before the deadline.
I will approve it now, but @madanial please wait until the EOD to see if other reviewers have further comments.

We will address any further suggestion of change as separate PRs.

[sylvestre.ledru]

With this patch, it started to fail with:
It would be nice to have a better error message suggesting what to do

-- Performing Test HAVE_DECL_STRERROR_S
-- Performing Test HAVE_DECL_STRERROR_S - Failed
CMake Error at /build/source/flang-rt/unittests/CMakeLists.txt:37 (message):
  Target llvm_gtest not found.


-- Configuring incomplete, errors occurred!

[pscoro]

In D154869#4652224, @sylvestre.ledru wrote:

With this patch, it started to fail with:
It would be nice to have a better error message suggesting what to do

-- Performing Test HAVE_DECL_STRERROR_S
-- Performing Test HAVE_DECL_STRERROR_S - Failed
CMake Error at /build/source/flang-rt/unittests/CMakeLists.txt:37 (message):
  Target llvm_gtest not found.


-- Configuring incomplete, errors occurred!

Hi, I originally authored this patch but I am no longer actively involved in Flang's development at the moment, however, I've been getting notifications that this patch has been landed yesterday and subsequently, the failing buildbots.
I believe all the gtest not found errors originate from a missing build flag, as per the documentation page for flang-rt in flang-rt/docs/GettingStarted.md:

# We need to enable GTest if we want to run Flang-rt's testsuites
-DLLVM_INSTALL_GTEST=On \

I believe I saw that clang buildbots also got inadvertently by this cmake change as well.
Wish I had time to investigate this further myself, hopefully @madanial can take a closer look. I believe what needs to be done is:

• flang buildbots need their build flags updated to include -DLLVM_INSTALL_GTEST=On
• The Target llvm_gtest not found. should be improved to offer better guidance
• The clang failures should be looked at closer; see if its possible to make a change to the cmake to limit the scope of builds needing the -DLLVM_INSTALL_GTEST=On flag update to just be flang builds. If there is no simple way to limit the scope, then updating the build flags for the clang builders is another solution
• I noticed at least one flang builder (https://lab.llvm.org/buildbot/#/builders/191/builds/24124) is failing build with:

FAILED: bin/external-hello-world 
: && /usr/local/bin/c++ -fPIC -fno-semantic-interposition -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wc++98-compat-extra-semi -Wimplicit-fallthrough -Wcovered-switch-default -Wno-noexcept-type -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wsuggest-override -Wstring-conversion -Wmisleading-indentation -Wctad-maybe-unsupported -fdiagnostics-color -ffunction-sections -fdata-sections -Wno-deprecated-copy -Wno-string-conversion -Wno-ctad-maybe-unsupported -Wno-unused-command-line-argument -Wstring-conversion           -Wcovered-switch-default -Wno-nested-anon-types -O3 -DNDEBUG -Wl,-rpath-link,/home/tcwg-buildbot/worker/flang-aarch64-rel-assert/build/./lib  -Wl,--gc-sections tools/flang/examples/ExternalHelloWorld/CMakeFiles/external-hello-world.dir/external-hello.cpp.o -o bin/external-hello-world  -Wl,-rpath,"\$ORIGIN/../lib:"  -lpthread  -lFortranRuntime && :
/usr/bin/ld: cannot find -lFortranRuntime

This looks to be a usage of the old FortranRuntime configuration that I overlooked and so it wasnt updated. This should be linking flang-rt instead of FortranRuntime

Hopefully addressing these small issues will get the buildbots green again, sorry for the disruptions.

[mizvekov]

This broke a buildbot, as a user reported on discord: https://buildkite.com/llvm-project/github-pull-requests/builds/5171#018aec0c-75ba-431a-a5c8-6a5cba51de28

[DavidSpickett]

I've reverted this https://github.com/llvm/llvm-project/commit/ffc67bb3602a6a9a4f886af362e1f2d7c9821570 as Linaro's flang and clang bots are red all over and we're also in an upgrade period for the build server (https://discourse.llvm.org/t/llvm-zorg-migration-to-the-buildbot-v3-9/73749) so getting a fix into zorg isn't going to happen for a few days at least.

Whoever decided to land this change please look at the remedies suggested by @pscoro and submit PRs to address those and eventually reland this. Happy to help on review.

[sylvestre.ledru]

Thanks for the revert!

[DanielCChen]

Sorry about the breakage and thanks to @DavidSpickett for reverting it.
We will reconsider all the input and bring it back as a PR in the future.

[sylvestre.ledru]

In D154869#4652703, @DanielCChen wrote:

Sorry about the breakage

This is why we have CI ;)

clang/lib/Driver/ToolChains/CommonArgs.cpp

bool tools::addOpenMPRuntime(ArgStringList &CmdArgs, const ToolChain &TC,
 
   return true;
 }
 
 void tools::addFortranRuntimeLibs(const ToolChain &TC,
                                   llvm::opt::ArgStringList &CmdArgs) {
   if (TC.getTriple().isKnownWindowsMSVCEnvironment()) {
     CmdArgs.push_back("Fortran_main.lib");
-    CmdArgs.push_back("FortranRuntime.lib");
-    CmdArgs.push_back("FortranDecimal.lib");
+    CmdArgs.push_back("flang-rt.lib");
   } else {
     CmdArgs.push_back("-lFortran_main");
-    CmdArgs.push_back("-lFortranRuntime");
-    CmdArgs.push_back("-lFortranDecimal");
+    CmdArgs.push_back("-lflang-rt");
   }
 }
 
 void tools::addFortranRuntimeLibraryPath(const ToolChain &TC,
                                          const llvm::opt::ArgList &Args,
                                          ArgStringList &CmdArgs) {
-  // Default to the <driver-path>/../lib directory. This works fine on the
-  // platforms that we have tested so far. We will probably have to re-fine
-  // this in the future. In particular, on some platforms, we may need to use
-  // lib64 instead of lib.
-  SmallString<256> DefaultLibPath =
+  // Default to the <driver-path>/../lib, <driver-path>/../flang-rt/lib, and
+  // <driver-path>/../runtimes/runtimes-bins/flang-rt/lib directories. This
+  // works fine on the platforms that we have tested so far. We will probably
+  // have to re-fine this in the future. In particular, on some platforms, we
+  // may need to use lib64 instead of lib.
+  SmallString<256> BuildLibPath =
       llvm::sys::path::parent_path(TC.getDriver().Dir);
-  llvm::sys::path::append(DefaultLibPath, "lib");
-  if (TC.getTriple().isKnownWindowsMSVCEnvironment())
-    CmdArgs.push_back(Args.MakeArgString("-libpath:" + DefaultLibPath));
-  else
-    CmdArgs.push_back(Args.MakeArgString("-L" + DefaultLibPath));
+  SmallString<256> FlangRTLibPath =
+      llvm::sys::path::parent_path(TC.getDriver().Dir);
+  SmallString<256> RuntimesLibPath =
+      llvm::sys::path::parent_path(TC.getDriver().Dir);
+  // Search path for Fortran_main and Flang-rt libraries.
+  llvm::sys::path::append(BuildLibPath, "lib");
+  llvm::sys::path::append(FlangRTLibPath, "flang-rt/lib");
+  llvm::sys::path::append(RuntimesLibPath,
+                          "runtimes/runtimes-bins/flang-rt/lib");
+  if (TC.getTriple().isKnownWindowsMSVCEnvironment()) {
+    CmdArgs.push_back(Args.MakeArgString("-libpath:" + BuildLibPath));
+    CmdArgs.push_back(Args.MakeArgString("-libpath:" + FlangRTLibPath));
+    CmdArgs.push_back(Args.MakeArgString("-libpath:" + RuntimesLibPath));
+  } else {
+    CmdArgs.push_back(Args.MakeArgString("-L" + BuildLibPath));
+    CmdArgs.push_back(Args.MakeArgString("-L" + FlangRTLibPath));
+    CmdArgs.push_back(Args.MakeArgString("-L" + RuntimesLibPath));
+  }
 }
 
 static void addSanitizerRuntime(const ToolChain &TC, const ArgList &Args,
                                 ArgStringList &CmdArgs, StringRef Sanitizer,
                                 bool IsShared, bool IsWhole) {
   // Wrap any static runtimes that must be forced into executable in
   // whole-archive.
   if (IsWhole) CmdArgs.push_back("--whole-archive");

flang-rt/CMakeLists.txt

+# CMake build for the Flang runtime libraries
+# The source for the flang runtime libraries (FortranDecimalRT, FortranRuntime)
+# exist in the flang top-level directory.
+# Flang-rt is only scaffolding and does not provide any additional source files.
+
+cmake_minimum_required(VERSION 3.20.0)
+
+#===============================================================================
+# Configure CMake
+#===============================================================================
+set(LLVM_COMMON_CMAKE_UTILS "${CMAKE_CURRENT_SOURCE_DIR}/../cmake")
+include(${LLVM_COMMON_CMAKE_UTILS}/Modules/CMakePolicy.cmake
+  NO_POLICY_SCOPE)
+
+set(CMAKE_BUILD_WITH_INSTALL_NAME_DIR ON)
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/flang-rt/bin)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY
+  ${CMAKE_BINARY_DIR}/flang-rt/lib)
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY
+  ${CMAKE_BINARY_DIR}/flang-rt/lib)
+set(CMAKE_CURRENT_BINARY_DIR ${CMAKE_BINARY_DIR}/flang-rt)
+
+set(FLANG_RT_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
+set(FLANG_RT_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}")
+
+#===============================================================================
+# Setup Options and Defaults
+#===============================================================================
+option(FLANG_RT_ENABLE_SHARED "Build flang-rt as a shared library." OFF)
+option(FLANG_RT_ENABLE_STATIC "Build flang-rt as a static library." OFF)
+
+option(FLANG_RT_INCLUDE_TESTS
+    "Generate build targets for the Flang-rt unit tests." ${LLVM_INCLUDE_TESTS})
+
+# MLIR_DIR must be passed on invocation of flang-rt because it is needed for the Flang package.
+if(NOT DEFINED MLIR_DIR OR MLIR_DIR STREQUAL "")
+  message(FATAL_ERROR "MLIR_DIR must be set to the directory of the MLIRConfig cmake file in order to find the MLIR package.")
+endif()
+# Flang-rt requires a pre-built/installed version of flang that requires MLIR.
+find_package(MLIR REQUIRED HINTS "${MLIR_DIR}")
+
+# FLANG_DIR must be passed on invocation of flang-rt.
+if(NOT DEFINED FLANG_DIR OR FLANG_DIR STREQUAL "")
+  message(FATAL_ERROR "FLANG_DIR must be set to the directory of the FlangConfig cmake file in order to find the Flang package.")
+endif()
+# Flang-rt requires a pre-built/installed version of flang.
+# Flang-rt uses flang/Common headers.
+# Finding this package exposes FLANG_SOURCE_DIR, FLANG_BINARY_DIR, and FLANG_INCLUDE_DIRS to Flang-rt
+find_package(Flang REQUIRED HINTS "${FLANG_DIR}")
+# If the user specifies a relative path to LLVM_DIR, the calls to include
+# LLVM modules fail. Append the absolute path to LLVM_DIR instead.
+get_filename_component(FLANG_DIR_ABSOLUTE ${FLANG_DIR} REALPATH)
+list(APPEND CMAKE_MODULE_PATH ${FLANG_DIR_ABSOLUTE})
+
+set(LLVM_COMMON_CMAKE_UTILS "${FLANG_RT_SOURCE_DIR}/../cmake")
+set(LLVM_CMAKE_UTILS "${LLVM_BUILD_MAIN_SOURCE_DIR}/cmake")
+set(CLANG_CMAKE_UTILS "${FLANG_RT_SOURCE_DIR}/../clang/cmake")
+
+if (FLANG_RT_INCLUDE_TESTS)
+  # LLVM_DIR must be passed on invocation of flang-rt when tests are enabled.
+  if(NOT DEFINED LLVM_DIR OR LLVM_DIR STREQUAL "")
+    message(FATAL_ERROR "LLVM_DIR must be set to the directory of the LLVMConfig cmake file in order to find the LLVM package.")
+  endif()
+  # We need a pre-built/installed version of LLVM for gtest.
+  find_package(LLVM REQUIRED HINTS "${LLVM_DIR}")
+  # If the user specifies a relative path to LLVM_DIR, the calls to include
+  # LLVM modules fail. Append the absolute path to LLVM_DIR instead.
+  get_filename_component(LLVM_DIR_ABSOLUTE ${LLVM_DIR} REALPATH)
+  list(APPEND CMAKE_MODULE_PATH ${LLVM_DIR_ABSOLUTE})
+
+  add_compile_definitions(FLANG_RT_INCLUDE_TESTS=1)
+
+  if (DEFINED FLANG_BINARY_DIR)
+    set(FLANG_BINARY_DIR ${FLANG_BINARY_DIR} CACHE PATH "Path to the Flang build directory" FORCE)
+  else()
+    message(FATAL_ERROR "FLANG_BINARY_DIR must be defined or passed by the user when building tests.")
+  endif()
+  set(FLANG_RT_TEST_COMPILER ${FLANG_BINARY_DIR}/bin/flang-new
+      CACHE PATH "Compiler to use for testing")
+  set(FLANG_RT_GTEST_AVAIL 1)
+endif()
+
+# Add path for custom modules
+list(INSERT CMAKE_MODULE_PATH 0
+  "${FLANG_SOURCE_DIR}/cmake"
+  "${FLANG_SOURCE_DIR}/cmake/modules"
+  "${CLANG_CMAKE_UTILS}/modules"
+  "${LLVM_CMAKE_UTILS}/modules"
+)
+
+include(AddClang)
+include(AddFlang)
+include(TestBigEndian)
+test_big_endian(IS_BIGENDIAN)
+if (IS_BIGENDIAN)
+  add_compile_definitions(FLANG_BIG_ENDIAN=1)
+else ()
+  add_compile_definitions(FLANG_LITTLE_ENDIAN=1)
+endif ()
+
+# Flang's include directories are needed for flang/Common.
+include_directories(SYSTEM ${FLANG_INCLUDE_DIRS})
+
+# LLVM's include directories are needed for gtest.
+include_directories(SYSTEM ${LLVM_INCLUDE_DIRS})
+
+#===============================================================================
+# Add Subdirectories
+#===============================================================================
+set(FORTRAN_DECIMAL_SRC "${FLANG_SOURCE_DIR}/lib/Decimal")
+set(FORTRAN_RUNTIME_SRC "${FLANG_SOURCE_DIR}/runtime")
+set(FORTRAN_MAIN_SRC "${FLANG_SOURCE_DIR}/runtime/FortranMain")
+
+add_subdirectory(${FORTRAN_DECIMAL_SRC} FortranDecimalRT)
+add_subdirectory(${FORTRAN_RUNTIME_SRC} FortranRuntime)
+add_subdirectory(${FORTRAN_MAIN_SRC} FortranMain)
+
+if (FLANG_RT_INCLUDE_TESTS)
+  add_subdirectory(test)
+  if (FLANG_RT_GTEST_AVAIL)
+    add_subdirectory(unittests)
+  endif()
+endif()
+
+#===============================================================================
+# Create Flang-rt wrapper library
+#===============================================================================
+# Build as shared by default if no linkage type option set.
+if (NOT FLANG_RT_ENABLE_SHARED AND NOT FLANG_RT_ENABLE_STATIC)
+  add_library(flang-rt SHARED $<TARGET_OBJECTS:obj.FortranDecimalRT>
+                              $<TARGET_OBJECTS:obj.FortranRuntime>)
+endif()
+if (FLANG_RT_ENABLE_SHARED)
+  add_library(flang-rt SHARED $<TARGET_OBJECTS:obj.FortranDecimalRT>
+                              $<TARGET_OBJECTS:obj.FortranRuntime>)
+endif()
+if (FLANG_RT_ENABLE_STATIC AND NOT FLANG_RT_ENABLE_SHARED)
+  add_library(flang-rt STATIC $<TARGET_OBJECTS:obj.FortranDecimalRT>
+                              $<TARGET_OBJECTS:obj.FortranRuntime>)
+endif()
+# When building both static and shared, we need to append _static to the name
+# to avoid naming conflicts.
+if (FLANG_RT_ENABLE_STATIC AND FLANG_RT_ENABLE_SHARED)
+  add_library(flang-rt_static STATIC $<TARGET_OBJECTS:obj.FortranDecimalRT>
+                                     $<TARGET_OBJECTS:obj.FortranRuntime>)
+endif()

flang-rt/docs/GettingStarted.md

+<!--===- docs/GettingStarted.md 
+  
+   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-rt Runtime Library
+
+```eval_rst
+.. contents::
+   :local:
+```
+## What is Flang-rt
+Flang-rt is the runtime library project for Flang. The Flang driver requires
+the Fortran_main and Flang-rt libraries at runtime in order to generate
+user executables. Building this Flang-rt project will build both Fortran_main
+and the Flang-rt library, which is comprised of the FortranRuntime and
+FortranDecimalRT libraries.
+
+### Fortran_main
+Fortran_main is left out of the Flang-rt library because it is required to
+always be static unlike the link type of the Flang-rt library which can be
+configured. Fortran_main implements the main entry point into Fortran's
+`PROGRAM` in Flang by being the bridge between object files generated by Flang 
+and the C runtime that takes care of program set-up at system-level. For
+every Fortran `PROGRAM`, Flang generates the `_QQmain` function.
+Fortran_main implements the C `main` function that simply calls
+`_QQmain`.
+
+### FortranDecimalRT
+In order to decouple the common dependency between compiler and runtime,
+[FortranDecimal's sources](../../flang/lib/Decimal/CMakeLists.txt) are built
+separately for the compiler and the runtime. When the library is built for
+Flang-rt, the name FortranDecimalRT is used to avoid naming conflicts and
+confusion.
+
+### FortranRuntime
+This is the core runtime library in Flang-rt. The sources for this library
+currently still exist in the
+[Flang source directory](../../flang/runtime/CMakeLists.txt). We hope to
+migrate the sources to the Flang-rt directory in the future in order to further
+decouple the runtime from the Flang compiler.
+
+## Building Flang-rt
+Like other LLVM runtimes, Flang-rt can be built by targetting the
+[runtimes LLVM target](../../runtimes/CMakelists.txt). It can also be built
+when targetting the [llvm target](../../llvm/CMakeLists.txt) as an enabled
+runtime. Flang-rt will implicitly be added as an enabled runtime when Flang
+is an enabled project built by llvm. Flang-rt does not support standalone
+builds.
+
+In the future, we may be interested in supporting in optionally building
+Flang-rt when doing a Flang standalone build.
+
+### Building with the llvm target
+Assuming you are building Flang-rt to use with Flang, see
+[Flang's Getting Started guide](../../flang/docs/GettingStarted.md) for more
+information. To build Flang-rt when building the Flang compiler, once you have
+the llvm-project source ready, make a clean build directory. Let root be the
+root directory that you cloned llvm-project into.
+```bash
+cd root
+rm -rf build
+mkdir build
+cd build
+```
+Now invoke the cmake configuration command for llvm that would build Flang with
+Flang-rt.
+```bash
+cmake \
+  -G Ninja \
+  -DLLVM_ENABLE_RUNTIMES="compiler-rt;flang-rt" \
+  -DCMAKE_CXX_STANDARD=17 \
+  -DLLVM_INSTALL_UTILS=On \
+  # New Flang-rt flags for enabled link types
+  -DFLANG_RT_ENABLE_STATIC=On \
+  -DFLANG_RT_ENABLE_SHARED=On \
+  # We need to enable GTest if we want to run Flang-rt's testsuites
+  -DLLVM_INSTALL_GTEST=On \
+  -DFLANG_ENABLE_WERROR=On \
+  -DLLVM_LIT_ARGS=-v \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DLLVM_ENABLE_PROJECTS="clang;flang;lld;mlir;openmp" \
+  ../llvm-project/llvm
+```
+Flang requires other llvm projects (see LLVM_ENABLE_PROJECTS and the [Flang
+Getting Started Guide](../../flang/docs/GettingStarted.md) for more specifics
+on building Flang.
+
+By targetting the LLVM project, we are letting LLVM infrastructure handle
+invoking the runtimes target that will build Flang-rt. This includes finding
+the cmake packages for Clang, LLVM, Flang and MLIR that Flang-rt depends on.
+
+### Building with the runtimes target
+If you already have a pre-built/installed version of LLVM, Flang, Clang and
+MLIR, and would like to build Flang-rt without rebuilding the sources for these
+other projects. You can simply target the runtimes project directly and passing
+the paths to the directories of these files. If you built LLVM as we did above
+with default build directories, your runtimes invocation should look something
+like:
+```bash
+cd build
+BUILDDIR=`pwd`
+
+cmake \
+  -G Ninja \
+  -DCMAKE_CXX_STANDARD=17 \
+  # New Flang-rt flags for enabled link types
+  -DFLANG_RT_ENABLE_SHARED=On \
+  -DFLANG_RT_ENABLE_STATIC=On \
+  -DLLVM_LIT_ARGS=-v \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DCMAKE_CXX_LINK_FLAGS="-Wl,-rpath,$LD_LIBRARY_PATH" \
+  -DLLVM_TARGETS_TO_BUILD=host \
+  -DLLVM_EXTERNAL_LIT=$BUILD_DIR/bin/llvm-lit \
+  # We need to specify the paths to the cmake packages of the dependencies
+  -DLLVM_DIR=$BUILD_DIR/lib/cmake/llvm \
+  -DMLIR_DIR=$BUILD_DIR/lib/cmake/mlir \
+  -DFLANG_DIR=$BUILD_DIR/lib/cmake/flang \
+  -DLLVM_ENABLE_RUNTIMES="flang-rt" \
+  ../llvm-project/runtimes/
+```
+
+## Library locations
+When building the llvm target with flang as an enabled project, the Flang-rt
+library will be built to `$BUILDDIR/runtimes/runtimes-bins/flang-rt/lib`. When
+building the runtimes target with flang-rt as an enabled runtime, the libraries
+will be built to `$BUILDDIR/flang-rt/lib` by default. In either configuration,
+the Fortran_main library will be built to `$BUILDDIR/lib` by default.
+
+## Using Flang-rt
+The two build paths mentioned above get implicitly added as library paths at the
+invocation of the driver. If Flang-rt is a shared library, you must make the
+dynamic linker aware of where to look. One method to do so is to set the
+environment variable `LD_LIBRARY_PATH` include the path to Flang-rt's directory.
+
+## Options
+Flang-rt introduces 2 CMake options used to configure the library's link type:
+```
+option(FLANG_RT_ENABLE_SHARED "Build flang-rt as a shared library." OFF)
+option(FLANG_RT_ENABLE_STATIC "Build flang-rt as a static library." OFF)
+```
+Both can be specified if you want to build both shared and static versions of
+the Flang-rt runtime. If both are specified, the static library will be named
+Flang-rt_static.a to avoid naming conflicts, as per the LLVM standard.
+
+## Usage Examples
+```bash
+# Example of using Flang with the shared Flang-rt runtime
+# First we need to explicitly tell the dynamic linker where to find Flang-rt
+# since it was built as shared.
+$ $ export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$BUILDDIR/runtimes/runtimes-bins/flang-rt/lib"
+$ flang-new -ffree-form hello.f95 -o hello
+```

flang-rt/test/CMakeLists.txt

+# Test runner infrastructure for Flang-rt. This configures the Flang-rt test
+# trees for use by Lit, and delegates to LLVM's lit test handlers.
+
+llvm_canonicalize_cmake_booleans(
+  FLANG_STANDALONE_BUILD
+  LLVM_BUILD_EXAMPLES
+  LLVM_BYE_LINK_INTO_TOOLS
+  LLVM_ENABLE_PLUGINS
+)
+
+set(FLANG_TOOLS_DIR ${FLANG_BINARY_DIR}/bin)
+
+configure_lit_site_cfg(
+  ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
+  ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg.py
+  MAIN_CONFIG
+  ${CMAKE_CURRENT_SOURCE_DIR}/lit.cfg.py
+  PATHS
+  ${PATHS_FOR_PLUGINS}
+)
+
+configure_lit_site_cfg(
+  ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.py.in
+  ${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg.py
+  MAIN_CONFIG
+  ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.cfg.py
+)
+
+configure_lit_site_cfg(
+  ${CMAKE_CURRENT_SOURCE_DIR}/NonGtestUnit/lit.site.cfg.py.in
+  ${CMAKE_CURRENT_BINARY_DIR}/NonGtestUnit/lit.site.cfg.py
+  MAIN_CONFIG
+  ${CMAKE_CURRENT_SOURCE_DIR}/NonGtestUnit/lit.cfg.py
+)
+
+set(FLANG_RT_TEST_PARAMS
+  flang_rt_site_config=${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg.py)
+
+set(FLANG_RT_TEST_DEPENDS
+  LLVMSupport
+  flang-rt
+  Fortran_main
+)
+if (LLVM_ENABLE_PLUGINS AND NOT WIN32)
+  list(APPEND FLANG_RT_TEST_DEPENDS Bye)
+endif()
+
+if (FLANG_RT_INCLUDE_TESTS)
+  if (FLANG_RT_GTEST_AVAIL)
+    list(APPEND FLANG_RT_TEST_DEPENDS FlangRTUnitTests)
+  endif()
+endif()
+
+add_custom_target(flang-rt-test-depends DEPENDS ${FLANG_RT_TEST_DEPENDS})
+
+add_lit_testsuite(check-flang-rt "Running the Flang-rt regression tests"
+  ${CMAKE_CURRENT_BINARY_DIR}
+  PARAMS ${FLANG_RT_TEST_PARAMS}
+  DEPENDS ${FLANG_RT_TEST_DEPENDS}
+)
+set_target_properties(check-flang-rt PROPERTIES FOLDER "Tests")
+
+add_lit_testsuites(FLANG_RT ${CMAKE_CURRENT_SOURCE_DIR}
+  PARAMS ${FLANG_RT_TEST_PARAMS}
+  DEPENDS ${FLANG_RT_TEST_DEPENDS})
+
+# To modify the default target triple for flang-rt tests.
+if (DEFINED FLANG_RT_TEST_TARGET_TRIPLE)
+  if (NOT DEFINED LLVM_TARGET_TRIPLE_ENV OR LLVM_TARGET_TRIPLE_ENV STREQUAL "")
+    message(FATAL_ERROR "LLVM_TARGET_TRIPLE_ENV must also be defined in order "
+                        "to use FLANG_RT_TEST_TARGET_TRIPLE.")
+  endif()
+endif()

flang-rt/test/FortranRuntime/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=c99 %s -I%include %libruntime -lm -o /dev/null
+*/
+
+#include "flang/Runtime/entry-names.h"
+#include <stdint.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.
+*/
+struct EnvironmentDefaultList;
+struct Descriptor;
+
+double RTNAME(CpuTime)();
+
+void RTNAME(ProgramStart)(
+    int, const char *[], const char *[], const struct EnvironmentDefaultList *);
+int32_t RTNAME(ArgumentCount)();
+int32_t RTNAME(GetCommandArgument)(int32_t, const struct Descriptor *,
+    const struct Descriptor *, const struct Descriptor *);
+int32_t RTNAME(GetEnvVariable)();
+
+int main() {
+  double x = RTNAME(CpuTime)();
+  RTNAME(ProgramStart)(0, 0, 0, 0);
+  int32_t c = RTNAME(ArgumentCount)();
+  int32_t v = RTNAME(GetCommandArgument)(0, 0, 0, 0);
+  int32_t e = RTNAME(GetEnvVariable)("FOO", 0, 0);
+  return x + c + v + e;
+}

flang-rt/test/NonGtestUnit/lit.cfg.py

+import os
+
+import lit.Test
+
+config.name = "flang-rt-OldUnit"
+
+config.suffixes = [".test"]
+
+config.test_source_root = os.path.join(config.flang_rt_obj_root, "unittests")
+config.test_exec_root = config.test_source_root
+
+config.test_format = lit.formats.ExecutableTest()
+
+path = os.path.pathsep.join(
+    (
+        config.flang_rt_lib_dir,
+        config.flang_bin_dir,
+        config.flang_libs_dir,
+        config.environment.get("LD_LIBRARY_PATH", ""),
+    )
+)
+config.environment["LD_LIBRARY_PATH"] = path

flang-rt/test/NonGtestUnit/lit.site.cfg.py.in

+@LIT_SITE_CFG_IN_HEADER@
+
+config.llvm_src_root = "@LLVM_SOURCE_DIR@"
+config.llvm_obj_root = "@LLVM_BINARY_DIR@"
+config.llvm_tools_dir = lit_config.substitute("@LLVM_TOOLS_DIR@")
+config.llvm_libs_dir = lit_config.substitute("@LLVM_LIBS_DIR@")
+config.llvm_build_mode = lit_config.substitute("@LLVM_BUILD_MODE@")
+config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@"
+config.flang_src_dir = "@FLANG_SOURCE_DIR@"
+config.flang_bin_dir = "@FLANG_BINARY_DIR@/bin"
+config.flang_libs_dir = "@FLANG_BINARY_DIR@/lib"
+config.flang_rt_obj_root = "@FLANG_RT_BINARY_DIR@"
+config.flang_tools_dir = lit_config.substitute("@FLANG_TOOLS_DIR@")
+config.flang_llvm_tools_dir = "@CMAKE_BINARY_DIR@/bin"
+config.flang_rt_src_dir = "@FLANG_RT_SOURCE_DIR@"
+config.flang_rt_lib_dir = "@FLANG_RT_BINARY_DIR@/lib"
+config.flang_rt_test_compiler = "@FLANG_RT_TEST_COMPILER@"
+config.flang_rt_test_triple = "@FLANG_RT_TEST_TARGET_TRIPLE@"
+config.target_triple = "@LLVM_TARGET_TRIPLE@"
+config.python_executable = "@Python3_EXECUTABLE@"
+
+# Let the main config do the real work.
+lit_config.load_config(config, "@FLANG_RT_SOURCE_DIR@/test/NonGtestUnit/lit.cfg.py")

flang-rt/test/Unit/lit.cfg.py

+# -*- Python -*-
+
+# Configuration file for the 'lit' test runner.
+
+import os
+import platform
+import re
+import subprocess
+import sys
+
+import lit.formats
+import lit.util
+
+from lit.llvm import llvm_config
+from lit.llvm.subst import ToolSubst
+from lit.llvm.subst import FindTool
+
+# name: The name of this test suite.
+config.name = "flang-rt-Unit"
+
+# suffixes: A list of file extensions to treat as test files.
+config.suffixes = []
+
+# test_source_root: The root path where unit test binaries are located.
+# test_exec_root: The root path where tests should be run.
+config.test_source_root = os.path.join(config.flang_rt_obj_root, "unittests")
+config.test_exec_root = config.test_source_root
+
+# testFormat: The test format to use to interpret tests.
+config.test_format = lit.formats.GoogleTest(config.llvm_build_mode, "Tests")
+
+# Tweak the PATH to include the flang bin and libs dirs.
+path = os.path.pathsep.join(
+    (
+        config.flang_bin_dir,
+        config.llvm_tools_dir,
+        config.environment["PATH"]
+    )
+)
+config.environment["PATH"] = path
+
+path = os.path.pathsep.join(
+    (
+        config.flang_rt_lib_dir,
+        config.flang_libs_dir,
+        config.flang_bin_dir,
+        config.environment.get("LD_LIBRARY_PATH", ""),
+    )
+)
+config.environment["LD_LIBRARY_PATH"] = path
+
+# Propagate PYTHON_EXECUTABLE into the environment
+# config.environment['PYTHON_EXECUTABLE'] = sys.executable
+
+# To modify the default target triple for flang-rt tests.
+if config.flang_rt_test_triple:
+    config.target_triple = config.flang_rt_test_triple
+    config.environment[config.llvm_target_triple_env] = config.flang_rt_test_triple

flang-rt/test/Unit/lit.site.cfg.py.in

+@LIT_SITE_CFG_IN_HEADER@
+
+config.llvm_src_root = "@LLVM_SOURCE_DIR@"
+config.llvm_obj_root = "@LLVM_BINARY_DIR@"
+config.llvm_target_triple_env = "@LLVM_TARGET_TRIPLE_ENV@"
+config.llvm_tools_dir = lit_config.substitute("@LLVM_TOOLS_DIR@")
+config.llvm_build_mode = lit_config.substitute("@LLVM_BUILD_MODE@")
+config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@"
+config.flang_bin_dir = "@FLANG_BINARY_DIR@/bin"
+config.flang_src_dir = "@FLANG_SOURCE_DIR@"
+config.flang_libs_dir = "@FLANG_BINARY_DIR@/lib"
+config.flang_rt_obj_root = "@FLANG_RT_BINARY_DIR@"
+config.flang_rt_src_dir = "@FLANG_RT_SOURCE_DIR@"
+config.flang_rt_lib_dir = "@FLANG_RT_BINARY_DIR@/lib"
+config.flang_rt_test_compiler = "@FLANG_RT_TEST_COMPILER@"
+config.flang_rt_test_triple = "@FLANG_RT_TEST_TARGET_TRIPLE@"
+config.flang_tools_dir = lit_config.substitute("@FLANG_TOOLS_DIR@")
+config.target_triple = "@LLVM_TARGET_TRIPLE@"
+config.python_executable = "@Python3_EXECUTABLE@"
+
+# Let the main config do the real work.
+lit_config.load_config(config, "@FLANG_RT_SOURCE_DIR@/test/Unit/lit.cfg.py")

flang-rt/test/lit.cfg.py

 
 from lit.llvm import llvm_config
 from lit.llvm.subst import ToolSubst
 from lit.llvm.subst import FindTool
 
 # Configuration file for the 'lit' test runner.
 
 # name: The name of this test suite.
-config.name = "Flang"
+config.name = "flang-rt"
 
 # testFormat: The test format to use to interpret tests.
 #
 # For now we require '&&' between commands, until they get globally killed and
 # the test runner updated.
 config.test_format = lit.formats.ShTest(not llvm_config.use_lit_shell)
 
 # suffixes: A list of file extensions to treat as test files.
config.suffixes = [
     ".f08",
     ".F08",
     ".ll",
     ".fir",
     ".mlir",
 ]
 
 config.substitutions.append(("%PATH%", config.environment["PATH"]))
-config.substitutions.append(("%llvmshlibdir", config.llvm_shlib_dir))
 config.substitutions.append(("%pluginext", config.llvm_plugin_ext))
 
 llvm_config.use_default_substitutions()
 
 # ask llvm-config about asserts
 llvm_config.feature_config([("--assertion-mode", {"ON": "asserts"})])
 
 # Targets
 config.targets = frozenset(config.targets_to_build.split())
 for arch in config.targets_to_build.split():
     config.available_features.add(arch.lower() + "-registered-target")
 
-# To modify the default target triple for flang tests.
-if config.flang_test_triple:
-    config.target_triple = config.flang_test_triple
-    config.environment[config.llvm_target_triple_env] = config.flang_test_triple
+# To modify the default target triple for flang-rt tests.
+if config.flang_rt_test_triple:
+    config.target_triple = config.flang_rt_test_triple
+    config.environment[config.llvm_target_triple_env] = config.flang_rt_test_triple
 
 # excludes: A list of directories to exclude from the testsuite. The 'Inputs'
 # subdirectories contain auxiliary inputs for various tests in their parent
 # directories.
 config.excludes = ["Inputs", "CMakeLists.txt", "README.txt", "LICENSE.txt"]
 
-# If the flang examples are built, add examples to the config
-if config.flang_examples:
-    config.available_features.add("examples")
-
 # Plugins (loadable modules)
 if config.has_plugins:
     config.available_features.add("plugins")
 
 if config.linked_bye_extension:
     config.substitutions.append(("%loadbye", ""))
 else:
     config.substitutions.append(
         (
             "%loadbye",
             "-fpass-plugin={}/Bye{}".format(
                 config.llvm_shlib_dir, config.llvm_plugin_ext
             ),
         )
     )
 
 # test_source_root: The root path where tests are located.
 config.test_source_root = os.path.dirname(__file__)
 
 # test_exec_root: The root path where tests should be run.
-config.test_exec_root = os.path.join(config.flang_obj_root, "test")
+config.test_exec_root = os.path.join(config.flang_rt_obj_root, "test")
 
-# Tweak the PATH to include the tools dir.
-llvm_config.with_environment("PATH", config.flang_tools_dir, append_path=True)
-llvm_config.with_environment("PATH", config.llvm_tools_dir, append_path=True)
-
-if config.flang_standalone_build:
-    # For builds with FIR, set path for tco and enable related tests
-    if config.flang_llvm_tools_dir != "":
-        config.available_features.add("fir")
-        if config.llvm_tools_dir != config.flang_llvm_tools_dir:
-            llvm_config.with_environment(
-                "PATH", config.flang_llvm_tools_dir, append_path=True
-            )
+llvm_config.with_environment("PATH", config.flang_bin_dir, append_path=True)
+llvm_config.with_environment("PATH", config.flang_rt_obj_root, append_path=True)
+llvm_config.with_environment("PATH", config.flang_libs_dir, append_path=True)
+llvm_config.with_environment("PATH", config.flang_rt_lib_dir, append_path=True)
 
 # For each occurrence of a flang tool name, replace it with the full path to
 # the build directory holding that tool.
 tools = [
     ToolSubst("%flang", command=FindTool("flang-new"), unresolved="fatal"),
     ToolSubst(
         "%flang_fc1",
         command=FindTool("flang-new"),
else:
     tools.append(
         ToolSubst("%not_todo_abort_cmd", command=FindTool("not"), 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")
+    libruntime_static = os.path.join(config.flang_rt_lib_dir, "libflang-rt.a")
+    libruntime_shared = os.path.join(config.flang_rt_lib_dir, "libflang-rt.so")
     include = os.path.join(config.flang_src_dir, "include")
 
     if (
-        os.path.isfile(libruntime)
-        and os.path.isfile(libdecimal)
+        os.path.isfile(libruntime_static)
         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("%libruntime", command=libruntime_static, unresolved="fatal"))
         tools.append(ToolSubst("%include", command=include, unresolved="fatal"))
 
+    elif (
+        os.path.isfile(libruntime_shared)
+        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_shared, unresolved="fatal"))
+        tools.append(ToolSubst("%include", command=include, unresolved="fatal"))
+
+
 # Add all the tools and their substitutions (if applicable). Use the search paths provided for
 # finding the tools.
-if config.flang_standalone_build:
-    llvm_config.add_tool_substitutions(
-        tools, [config.flang_llvm_tools_dir, config.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-rt/test/lit.site.cfg.py.in

+@LIT_SITE_CFG_IN_HEADER@
+
+import sys
+
+config.llvm_tools_dir = lit_config.substitute("@LLVM_TOOLS_DIR@")
+config.llvm_shlib_dir = lit_config.substitute(path(r"@SHLIBDIR@"))
+config.llvm_plugin_ext = "@LLVM_PLUGIN_EXT@"
+config.target_triple = "@LLVM_TARGET_TRIPLE@"
+config.llvm_target_triple_env = "@LLVM_TARGET_TRIPLE_ENV@"
+config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@"
+config.errc_messages = "@LLVM_LIT_ERRC_MESSAGES@"
+config.flang_src_dir = "@FLANG_SOURCE_DIR@"
+config.flang_bin_dir = "@FLANG_BINARY_DIR@/bin"
+config.flang_libs_dir = "@FLANG_BINARY_DIR@/lib"
+config.flang_tools_dir = lit_config.substitute("@FLANG_TOOLS_DIR@")
+config.flang_llvm_tools_dir = "@CMAKE_BINARY_DIR@/bin"
+config.flang_rt_obj_root = "@FLANG_RT_BINARY_DIR@"
+config.flang_rt_src_dir = "@FLANG_RT_SOURCE_DIR@"
+config.flang_rt_lib_dir = "@FLANG_RT_BINARY_DIR@/lib"
+config.flang_rt_test_triple = "@FLANG_RT_TEST_TARGET_TRIPLE@"
+config.python_executable = "@PYTHON_EXECUTABLE@"
+config.has_plugins = @LLVM_ENABLE_PLUGINS@
+config.linked_bye_extension = @LLVM_BYE_LINK_INTO_TOOLS@
+config.cc = "@CMAKE_C_COMPILER@"
+config.targets_to_build = "@TARGETS_TO_BUILD@"
+
+import lit.llvm
+lit.llvm.initialize(lit_config, config)
+
+# Let the main config do the real work.
+lit_config.load_config(config, "@FLANG_RT_SOURCE_DIR@/test/lit.cfg.py")

flang-rt/unittests/CMakeLists.txt

 if (FLANG_EXPERIMENTAL_CUDA_RUNTIME)
   # If Fortran runtime is built as CUDA library, the linking
   # of targets that link FortranRuntime must be done
   # with CUDA_RESOLVE_DEVICE_SYMBOLS.
   # CUDA language must be enabled for CUDA_RESOLVE_DEVICE_SYMBOLS
   # to take effect.
   enable_language(CUDA)
 endif()
 
-add_custom_target(FlangUnitTests)
-set_target_properties(FlangUnitTests PROPERTIES FOLDER "Flang Unit Tests")
+add_custom_target(FlangRTUnitTests)
+set_target_properties(FlangRTUnitTests PROPERTIES FOLDER "Flang-rt Unit Tests")
 
-function(add_flang_unittest_offload_properties target)
+function(add_flang_rt_unittest_offload_properties target)
   # Set CUDA_RESOLVE_DEVICE_SYMBOLS.
   if (FLANG_EXPERIMENTAL_CUDA_RUNTIME)
     set_target_properties(${target}
       PROPERTIES CUDA_RESOLVE_DEVICE_SYMBOLS ON
       )
   endif()
   # Enable OpenMP offload during linking. We may need to replace
   # LINK_OPTIONS with COMPILE_OPTIONS when there are OpenMP offload
   # unittests.
   #
   # FIXME: replace 'native' in --offload-arch option with the list
   #        of targets that Fortran Runtime was built for.
   #        Common code must be moved from flang/runtime/CMakeLists.txt.
+  # TODO: Revisit this because of Flang-rt. runtime is no longer an added subdirectory of flang.
   if (NOT FLANG_EXPERIMENTAL_OMP_OFFLOAD_BUILD STREQUAL "off")
     set_target_properties(${target}
         PROPERTIES LINK_OPTIONS
         "-fopenmp;--offload-arch=native"
-      )
   endif()
 endfunction()
 
-function(add_flang_unittest test_dirname)
-  add_unittest(FlangUnitTests ${test_dirname} ${ARGN})
-  add_flang_unittest_offload_properties(${test_dirname})
+if(NOT TARGET llvm_gtest)
+  message(FATAL_ERROR "Target llvm_gtest not found.")
+endif()
+
+function(add_flang_rt_unittest test_dirname)
+  add_unittest(FlangRTUnitTests ${test_dirname} ${ARGN})
+  add_flang_rt_unittest_offload_properties(${test_dirname})
 endfunction()
 
 if (CXX_SUPPORTS_SUGGEST_OVERRIDE_FLAG)
   add_compile_options("-Wno-suggest-override")
 endif()
 
-function(add_flang_nongtest_unittest test_name)
+function(add_flang_rt_nongtest_unittest test_name)
   cmake_parse_arguments(ARG
     "SLOW_TEST"
     ""
     ""
     ${ARGN})
 
+  list(APPEND LLVM_COMPILE_FLAGS "-L${LLVM_BINARY_DIR}/lib")
   if(ARG_SLOW_TEST)
       set(suffix .slow)
   else()
       set(suffix .test)
   endif()
 
   add_executable(${test_name}${suffix} ${test_name}.cpp)
 
   if (LLVM_LINK_LLVM_DYLIB AND NOT ARG_DISABLE_LLVM_LINK_LLVM_DYLIB)
     set(llvm_libs LLVM)
   else()
     llvm_map_components_to_libnames(llvm_libs Support)
   endif()
   target_link_libraries(${test_name}${suffix} ${llvm_libs} ${ARG_UNPARSED_ARGUMENTS})
 
   if(NOT ARG_SLOW_TEST)
-    add_dependencies(FlangUnitTests ${test_name}${suffix})
+    add_dependencies(FlangRTUnitTests ${test_name}${suffix})
   endif()
 
-  add_flang_unittest_offload_properties(${test_name}${suffix})
+  add_flang_rt_unittest_offload_properties(${test_name}${suffix})
 endfunction()
 
-add_subdirectory(Optimizer)
-add_subdirectory(Common)
-add_subdirectory(Decimal)
-add_subdirectory(Evaluate)
-add_subdirectory(Runtime)
-add_subdirectory(Frontend)
+add_subdirectory(FortranRuntime)
+# TODO: We may want to find a better location for these tests that use the runtime
+add_subdirectory(FortranEvaluate)

flang-rt/unittests/FortranEvaluate/CMakeLists.txt

+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+add_library(FlangRTFortranEvaluateTesting
+  testing.cpp
+)
+if (LLVM_LINK_LLVM_DYLIB)
+  set(llvm_libs LLVM)
+else()
+  llvm_map_components_to_libnames(llvm_libs Support)
+endif()
+target_link_libraries(FlangRTFortranEvaluateTesting
+    ${llvm_libs})
+
+add_flang_rt_nongtest_unittest(reshape
+  FlangRTFortranEvaluateTesting
+  flang-rt
+)
+
+add_flang_rt_nongtest_unittest(ISO-Fortran-binding
+  FlangRTFortranEvaluateTesting
+  flang-rt
+)

flang-rt/unittests/FortranEvaluate/testing.h

+#ifndef FORTRAN_EVALUATE_TESTING_H_
+#define FORTRAN_EVALUATE_TESTING_H_
+
+#include <cinttypes>
+#include <string>
+
+namespace testing {
+
+// Returns EXIT_SUCCESS or EXIT_FAILURE, so a test's main() should end
+// with "return testing::Complete()".
+int Complete();
+
+// Pass/fail testing.  These macros return a pointer to a printf-like
+// function that can be optionally called to print more detail, e.g.
+//   COMPARE(x, ==, y)("z is 0x%llx", z);
+// will also print z after the usual failure message if x != y.
+#define TEST(predicate)                                                        \
+  testing::Test(__FILE__, __LINE__, #predicate, (predicate))
+#define MATCH(want, got) testing::Match(__FILE__, __LINE__, (want), #got, (got))
+#define COMPARE(x, rel, y)                                                     \
+  testing::Compare(__FILE__, __LINE__, #x, #rel, #y, (x), (y))
+
+// Functions called by these macros; do not call directly.
+using FailureDetailPrinter = void (*)(const char *, ...);
+FailureDetailPrinter Test(const char *file, int line, const char *predicate,
+                          bool pass);
+FailureDetailPrinter Match(const char *file, int line, std::uint64_t want,
+                           const char *gots, std::uint64_t got);
+FailureDetailPrinter Match(const char *file, int line, const char *want,
+                           const char *gots, const std::string &got);
+FailureDetailPrinter Match(const char *file, int line, const std::string &want,
+                           const char *gots, const std::string &got);
+FailureDetailPrinter Compare(const char *file, int line, const char *xs,
+                             const char *rel, const char *ys, std::uint64_t x,
+                             std::uint64_t y);
+} // namespace testing
+#endif // FORTRAN_EVALUATE_TESTING_H_

flang-rt/unittests/FortranEvaluate/testing.cpp

+#include "testing.h"
+#include <cstdarg>
+#include <cstdio>
+#include <cstdlib>
+
+namespace testing {
+
+namespace {
+int passes{0};
+int failures{0};
+} // namespace
+
+static void BitBucket(const char *, ...) {}
+
+static void PrintFailureDetails(const char *format, ...) {
+  va_list ap;
+  va_start(ap, format);
+  fputs("\t", stderr);
+  vfprintf(stderr, format, ap);
+  va_end(ap);
+  fputc('\n', stderr);
+}
+
+FailureDetailPrinter Test(const char *file, int line, const char *predicate,
+                          bool pass) {
+  if (pass) {
+    ++passes;
+    return BitBucket;
+  } else {
+    ++failures;
+    fprintf(stderr, "%s:%d: FAIL: %s\n", file, line, predicate);
+    return PrintFailureDetails;
+  }
+}
+
+FailureDetailPrinter Match(const char *file, int line, std::uint64_t want,
+                           const char *gots, std::uint64_t got) {
+  if (want == got) {
+    ++passes;
+    return BitBucket;
+  } else {
+    ++failures;
+    fprintf(stderr, "%s:%d: FAIL: %s == 0x%jx, not 0x%jx\n", file, line, gots,
+            static_cast<std::uintmax_t>(got),
+            static_cast<std::uintmax_t>(want));
+    return PrintFailureDetails;
+  }
+}
+
+FailureDetailPrinter Match(const char *file, int line, const char *want,
+                           const char *gots, const std::string &got) {
+  if (want == got) {
+    ++passes;
+    return BitBucket;
+  } else {
+    ++failures;
+    fprintf(stderr, "%s:%d: FAIL: %s == \"%s\", not \"%s\"\n", file, line, gots,
+            got.data(), want);
+    return PrintFailureDetails;
+  }
+}
+
+FailureDetailPrinter Match(const char *file, int line, const std::string &want,
+                           const char *gots, const std::string &got) {
+  return Match(file, line, want.data(), gots, got);
+}
+
+FailureDetailPrinter Compare(const char *file, int line, const char *xs,
+                             const char *rel, const char *ys, std::uint64_t x,
+                             std::uint64_t y) {
+  while (*rel == ' ') {
+    ++rel;
+  }
+  bool pass{false};
+  if (*rel == '<') {
+    if (rel[1] == '=') {
+      pass = x <= y;
+    } else {
+      pass = x < y;
+    }
+  } else if (*rel == '>') {
+    if (rel[1] == '=') {
+      pass = x >= y;
+    } else {
+      pass = x > y;
+    }
+  } else if (*rel == '=') {
+    pass = x == y;
+  } else if (*rel == '!') {
+    pass = x != y;
+  }
+  if (pass) {
+    ++passes;
+    return BitBucket;
+  } else {
+    ++failures;
+    fprintf(stderr, "%s:%d: FAIL: %s[0x%jx] %s %s[0x%jx]\n", file, line, xs,
+            static_cast<std::uintmax_t>(x), rel, ys,
+            static_cast<std::uintmax_t>(y));
+    return PrintFailureDetails;
+  }
+}
+
+int Complete() {
+  if (failures == 0) {
+    if (passes == 1) {
+      fprintf(stdout, "single test PASSES\n");
+    } else {
+      fprintf(stdout, "all %d tests PASS\n", passes);
+    }
+    passes = 0;
+    return EXIT_SUCCESS;
+  } else {
+    if (passes == 1) {
+      fprintf(stderr, "1 test passes, ");
+    } else {
+      fprintf(stderr, "%d tests pass, ", passes);
+    }
+    if (failures == 1) {
+      fprintf(stderr, "1 test FAILS\n");
+    } else {
+      fprintf(stderr, "%d tests FAIL\n", failures);
+    }
+    passes = failures = 0;
+    return EXIT_FAILURE;
+  }
+}
+} // namespace testing

flang-rt/unittests/FortranRuntime/BufferTest.cpp

 //===-- flang/unittests/Runtime/BufferTest.cpp ------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "../../runtime/buffer.h"
+#include "flang/../../runtime/buffer.h"
 #include "CrashHandlerFixture.h"
 #include "gtest/gtest.h"
 #include <algorithm>
 #include <cstdint>
 #include <cstring>
 #include <memory>
 
 static constexpr std::size_t tinyBufferSize{32};
 using FileOffset = std::int64_t;
 using namespace Fortran::runtime;
 using namespace Fortran::runtime::io;
 
 class Store : public FileFrame<Store, tinyBufferSize> {
 public:
   explicit Store(std::size_t bytes = 65536) : bytes_{bytes} {
     data_.reset(new char[bytes]);
     std::memset(&data_[0], 0, bytes);
   }
   std::size_t bytes() const { return bytes_; }
   void set_enforceSequence(bool yes = true) { enforceSequence_ = yes; }
   void set_expect(FileOffset to) { expect_ = to; }
 
   std::size_t Read(FileOffset at, char *to, std::size_t minBytes,
                    std::size_t maxBytes, IoErrorHandler &handler) {
     if (enforceSequence_ && at != expect_) {
       handler.SignalError("Read(%d,%d,%d) not at expected %d",
                           static_cast<int>(at), static_cast<int>(minBytes),
-          static_cast<int>(maxBytes), static_cast<int>(expect_));
+                          static_cast<int>(maxBytes),
+                          static_cast<int>(expect_));
     } else if (at < 0 || at + minBytes > bytes_) {
       handler.SignalError("Read(%d,%d,%d) is out of bounds",
                           static_cast<int>(at), static_cast<int>(minBytes),
                           static_cast<int>(maxBytes));
     }
     auto result{std::min<std::size_t>(maxBytes, bytes_ - at)};
     std::memcpy(to, &data_[at], result);
     expect_ = at + result;
     return result;
   }
   std::size_t Write(FileOffset at, const char *from, std::size_t bytes,
                     IoErrorHandler &handler) {
     if (enforceSequence_ && at != expect_) {
       handler.SignalError("Write(%d,%d) not at expected %d",
                           static_cast<int>(at), static_cast<int>(bytes),
                           static_cast<int>(expect_));
     } else if (at < 0 || at + bytes > bytes_) {
       handler.SignalError("Write(%d,%d) is out of bounds", static_cast<int>(at),
                           static_cast<int>(bytes));
     }
     std::memcpy(&data_[at], from, bytes);
     expect_ = at + bytes;
     return bytes;
   }
 
 private:
   std::size_t bytes_;
   std::unique_ptr<char[]> data_;
   bool enforceSequence_{false};
   FileOffset expect_{0};
 };
 
 inline int ChunkSize(int j, int most) {
   // 31, 1, 29, 3, 27, ...
   j %= tinyBufferSize;
-  auto chunk{static_cast<int>(
-      ((j % 2) ? j : (tinyBufferSize - 1 - j)) % tinyBufferSize)};
+  auto chunk{static_cast<int>(((j % 2) ? j : (tinyBufferSize - 1 - j)) %
+                              tinyBufferSize)};
   return std::min(chunk, most);
 }
 
 inline int ValueFor(int at) { return (at ^ (at >> 8)) & 0xff; }
 
 struct BufferTests : CrashHandlerFixture {};
 
 TEST(BufferTests, TestFrameBufferReadAndWrite) {

flang-rt/unittests/FortranRuntime/CMakeLists.txt

-add_flang_unittest(FlangRuntimeTests
+add_flang_rt_unittest(FortranRuntimeTests
   Allocatable.cpp
   ArrayConstructor.cpp
   BufferTest.cpp
   CharacterTest.cpp
   CommandTest.cpp
   Complex.cpp
   CrashHandlerFixture.cpp
   Derived.cpp
add_flang_rt_unittest(FortranRuntimeTests
   Reduction.cpp
   RuntimeCrashTest.cpp
   Stop.cpp
   Time.cpp
   TemporaryStack.cpp
   Transformational.cpp
 )
 
-target_link_libraries(FlangRuntimeTests
+target_link_libraries(FortranRuntimeTests
   PRIVATE
-  FortranRuntime
+  flang-rt
 )

flang-rt/unittests/FortranRuntime/CrashHandlerFixture.cpp

 //===-- flang/unittests/Runtime/CrashHandlerFixture.cpp ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #include "CrashHandlerFixture.h"
-#include "../../runtime/terminator.h"
+#include "flang/../../runtime/terminator.h"
 #include <cstdarg>
 #include <cstdlib>
 
 // Replaces Fortran runtime's crash handler so we can verify the crash message
-[[noreturn]] static void CatchCrash(
-    const char *sourceFile, int sourceLine, const char *message, va_list &ap) {
+[[noreturn]] static void CatchCrash(const char *sourceFile, int sourceLine,
+                                    const char *message, va_list &ap) {
   char buffer[1000];
   std::vsnprintf(buffer, sizeof buffer, message, ap);
   va_end(ap);
   llvm::errs()
       << "Test "
       << ::testing::UnitTest::GetInstance()->current_test_info()->name()
       << " crashed in file "
       << (sourceFile ? sourceFile : "unknown source file") << '(' << sourceLine

flang-rt/unittests/FortranRuntime/ListInputTest.cpp

 //===-- flang/unittests/Runtime/ListInputTest.cpp ---------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "CrashHandlerFixture.h"
-#include "../../runtime/io-error.h"
+#include "flang/../../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) {
TEST(InputTest, TestListInputAlphabet) {
   char inputBuffers[numInputBuffers][maxInputBufferLength];
   const char expectedOutput[]{
       "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ "};
   int j{0};
 
   // Use _two_ input buffers and _three_ output buffers. Note the `3*` in the
   // _inputBuffers_.
   SetCharacter(inputBuffers[j++], maxInputBufferLength,
                "3*'abcdefghijklmnopqrstuvwxyzABC");
-  SetCharacter(
-      inputBuffers[j++], maxInputBufferLength, "DEFGHIJKLMNOPQRSTUVWXYZ'");
+  SetCharacter(inputBuffers[j++], maxInputBufferLength,
+               "DEFGHIJKLMNOPQRSTUVWXYZ'");
 
   StaticDescriptor<1> staticDescriptor;
   Descriptor &whole{staticDescriptor.descriptor()};
   SubscriptValue extent[]{numInputBuffers};
   whole.Establish(TypeCode{CFI_type_char}, maxInputBufferLength, &inputBuffers,
                   1, extent, CFI_attribute_pointer);
   whole.Check();
   auto *cookie{IONAME(BeginInternalArrayListInput)(whole)};
 
   constexpr int numOutputBuffers{3};
   constexpr int outputBufferLength{54};
   char outputBuffers[numOutputBuffers][outputBufferLength]{};
   for (j = 0; j < numOutputBuffers; ++j) {
     IONAME(InputAscii)(cookie, outputBuffers[j], outputBufferLength - 1);
TEST(InputTest, TestListInputIntegerList) {
   int j{0};
   SetCharacter(buffer[j++], maxBufferLength, "1 2 2*3  ,");
   SetCharacter(buffer[j++], maxBufferLength, ",6,,8,2*");
 
   StaticDescriptor<1> staticDescriptor;
   Descriptor &whole{staticDescriptor.descriptor()};
   SubscriptValue extent[]{numBuffers};
   whole.Establish(TypeCode{CFI_type_char}, maxBufferLength, &buffer, 1, extent,
                   CFI_attribute_pointer);
   whole.Check();
   auto *cookie{IONAME(BeginInternalArrayListInput)(whole)};
 
   constexpr int listInputLength{10};
 
   // Negative numbers will be overwritten by _expectedOutput_, and positive
   // numbers will not be as their indices are "Null values" of the Fortran 2018
   // standard 13.10.3.2 in the format strings _buffer_
-  std::int64_t actualOutput[listInputLength]{
-      -1, -2, -3, -4, 5, -6, 7, -8, 9, 10};
-  const std::int64_t expectedOutput[listInputLength]{
-      1, 2, 3, 3, 5, 6, 7, 8, 9, 10};
+  std::int64_t actualOutput[listInputLength]{-1, -2, -3, -4, 5,
+                                             -6, 7,  -8, 9,  10};
+  const std::int64_t expectedOutput[listInputLength]{1, 2, 3, 3, 5,
+                                                     6, 7, 8, 9, 10};
   for (j = 0; j < listInputLength; ++j) {
     IONAME(InputInteger)(cookie, actualOutput[j]);
   }
 
   const auto status{IONAME(EndIoStatement)(cookie)};
   ASSERT_EQ(status, 0) << "list-directed input failed, status "
                        << static_cast<int>(status) << '\n';
 
   // Verify the calls to _InputInteger_ resulted in _expectedOutput_
   for (j = 0; j < listInputLength; ++j) {
     ASSERT_EQ(actualOutput[j], expectedOutput[j])
         << "wanted actualOutput[" << j << "]==" << expectedOutput[j] << ", got "
         << actualOutput[j] << '\n';
   }
 }
 
 TEST(InputTest, TestListInputInvalidFormatWithSingleSuccess) {
   std::string formatBuffer{"1, g"};
   constexpr int numBuffers{1};
 
   StaticDescriptor<1> staticDescriptor;
   Descriptor &whole{staticDescriptor.descriptor()};
   SubscriptValue extent[]{numBuffers};
   whole.Establish(TypeCode{CFI_type_char}, formatBuffer.size(),
                   formatBuffer.data(), 1, extent, CFI_attribute_pointer);
   whole.Check();
 
   auto *cookie{IONAME(BeginInternalArrayListInput)(whole)};
   std::int64_t dummy;
 
   // Perform _InputInteger_ once successfully
   IONAME(InputInteger)(cookie, dummy);
 
   // Perform failing InputInteger
   ASSERT_DEATH(IONAME(InputInteger)(cookie, dummy),
                "Bad character 'g' in INTEGER input field");
 }
 
 // Same test as _TestListInputInvalidFormatWithSingleSuccess_, however no
 // successful call to _InputInteger_ is performed first.
 TEST(InputTest, TestListInputInvalidFormat) {
   std::string formatBuffer{"g"};
   constexpr int numBuffers{1};
 
   StaticDescriptor<1> staticDescriptor;
   Descriptor &whole{staticDescriptor.descriptor()};
   SubscriptValue extent[]{numBuffers};
   whole.Establish(TypeCode{CFI_type_char}, formatBuffer.size(),
                   formatBuffer.data(), 1, extent, CFI_attribute_pointer);
   whole.Check();
 
   auto *cookie{IONAME(BeginInternalArrayListInput)(whole)};
   std::int64_t dummy;
 
   // Perform failing InputInteger
   ASSERT_DEATH(IONAME(InputInteger)(cookie, dummy),
                "Bad character 'g' in INTEGER input field");
 }
 
 using ParamTy = std::tuple<std::string, std::vector<int>>;
 
 struct SimpleListInputTest : testing::TestWithParam<ParamTy> {};
 
 TEST_P(SimpleListInputTest, TestListInput) {
   auto [formatBuffer, expectedOutput] = GetParam();
   constexpr int numBuffers{1};
 
   StaticDescriptor<1> staticDescriptor;
   Descriptor &whole{staticDescriptor.descriptor()};
   SubscriptValue extent[]{numBuffers};
   whole.Establish(TypeCode{CFI_type_char}, formatBuffer.size(),
                   formatBuffer.data(), 1, extent, CFI_attribute_pointer);
   whole.Check();
   auto *cookie{IONAME(BeginInternalArrayListInput)(whole)};
 
   const auto listInputLength{expectedOutput.size()};
   std::vector<std::int64_t> actualOutput(listInputLength);
   for (std::size_t j = 0; j < listInputLength; ++j) {
     IONAME(InputInteger)(cookie, actualOutput[j]);
   }
 
   const auto status{IONAME(EndIoStatement)(cookie)};
   ASSERT_EQ(status, 0) << "list-directed input failed, status "
                        << static_cast<int>(status) << '\n';
 
   // Verify the calls to _InputInteger_ resulted in _expectedOutput_
   for (std::size_t j = 0; j < listInputLength; ++j) {
     ASSERT_EQ(actualOutput[j], expectedOutput[j])
         << "wanted actualOutput[" << j << "]==" << expectedOutput[j] << ", got "
         << actualOutput[j] << '\n';
   }
 }
 
-INSTANTIATE_TEST_SUITE_P(SimpleListInputTestInstantiation, SimpleListInputTest,
+INSTANTIATE_TEST_SUITE_P(
+    SimpleListInputTestInstantiation, SimpleListInputTest,
     testing::Values(std::make_tuple("", std::vector<int>{}),
                     std::make_tuple("0", std::vector<int>{}),
                     std::make_tuple("1", std::vector<int>{1}),
                     std::make_tuple("1, 2", std::vector<int>{1, 2}),
                     std::make_tuple("3*2", std::vector<int>{2, 2, 2})));

flang-rt/unittests/FortranRuntime/Namelist.cpp

 //===-- flang/unittests/Runtime/Namelist.cpp --------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "../../runtime/namelist.h"
+#include "flang/../../runtime/namelist.h"
 #include "CrashHandlerFixture.h"
-#include "tools.h"
 #include "flang/Runtime/descriptor.h"
 #include "flang/Runtime/io-api.h"
+#include "tools.h"
 #include <algorithm>
 #include <cinttypes>
 #include <complex>
 #include <cstring>
 #include <gtest/gtest.h>
 #include <limits>
 #include <string>
 #include <vector>
 
 using namespace Fortran::runtime;
 using namespace Fortran::runtime::io;
 
 struct NamelistTests : CrashHandlerFixture {};
 
 static void ClearDescriptorStorage(const Descriptor &descriptor) {
   std::memset(descriptor.raw().base_addr, 0,
               descriptor.Elements() * descriptor.ElementBytes());
 }
 
 TEST(NamelistTests, BasicSanity) {
   static constexpr int numLines{12};
   static constexpr int lineLength{32};
   static char buffer[numLines][lineLength];
   StaticDescriptor<1, true> statDescs[1];
   Descriptor &internalDesc{statDescs[0].descriptor()};
   SubscriptValue extent[]{numLines};
   internalDesc.Establish(TypeCode{CFI_type_char}, /*elementBytes=*/lineLength,
                          &buffer, 1, extent, CFI_attribute_pointer);
   // Set up data arrays
   std::vector<int> ints;
   for (int j{0}; j < 20; ++j) {
     ints.push_back(j % 2 == 0 ? (1 << j) : -(1 << j));
   }
-  std::vector<double> reals{0.0, -0.0, std::numeric_limits<double>::infinity(),
+  std::vector<double> reals{0.0,
+                            -0.0,
+                            std::numeric_limits<double>::infinity(),
                             -std::numeric_limits<double>::infinity(),
                             std::numeric_limits<double>::quiet_NaN(),
-      std::numeric_limits<double>::max(), std::numeric_limits<double>::lowest(),
+                            std::numeric_limits<double>::max(),
+                            std::numeric_limits<double>::lowest(),
                             std::numeric_limits<double>::epsilon()};
   std::vector<std::uint8_t> logicals;
   logicals.push_back(false);
   logicals.push_back(true);
   logicals.push_back(false);
   std::vector<std::complex<float>> complexes;
   complexes.push_back(std::complex<float>{123.0, -0.5});
   std::vector<std::string> characters;
   characters.emplace_back("aBcDeFgHiJkLmNoPqRsTuVwXyZ");
TEST(NamelistTests, BasicSanity) {
   OwningPtr<Descriptor> complexDesc{
       MakeArray<TypeCategory::Complex, static_cast<int>(sizeof(float))>(
           std::vector<int>{}, std::move(complexes))};
   OwningPtr<Descriptor> characterDesc{MakeArray<TypeCategory::Character, 1>(
       std::vector<int>{2}, std::move(characters), characters[0].size())};
   // Create a NAMELIST group
   static constexpr int items{5};
   const NamelistGroup::Item itemArray[items]{{"ints", *intDesc},
-      {"reals", *realDesc}, {"logicals", *logicalDesc},
-      {"complexes", *complexDesc}, {"characters", *characterDesc}};
+                                             {"reals", *realDesc},
+                                             {"logicals", *logicalDesc},
+                                             {"complexes", *complexDesc},
+                                             {"characters", *characterDesc}};
   const NamelistGroup group{"group1", items, itemArray};
   // Do an internal NAMELIST write and check results
-  auto outCookie1{IONAME(BeginInternalArrayListOutput)(
-      internalDesc, nullptr, 0, __FILE__, __LINE__)};
+  auto outCookie1{IONAME(BeginInternalArrayListOutput)(internalDesc, nullptr, 0,
+                                                       __FILE__, __LINE__)};
   ASSERT_TRUE(IONAME(SetDelim)(outCookie1, "APOSTROPHE", 10));
   ASSERT_TRUE(IONAME(OutputNamelist)(outCookie1, group));
   auto outStatus1{IONAME(EndIoStatement)(outCookie1)};
   ASSERT_EQ(outStatus1, 0) << "Failed namelist output sanity, status "
                            << static_cast<int>(outStatus1);
 
   static const std::string expect{"&GROUP1 INTS= 1 -2 4 -8 16 -32  "
                                   " 64 -128 256 -512 1024 -2048    "
TEST(NamelistTests, BasicSanity) {
   EXPECT_EQ(got, expect);
 
   // Clear the arrays, read them back, write out again, and compare
   ClearDescriptorStorage(*intDesc);
   ClearDescriptorStorage(*realDesc);
   ClearDescriptorStorage(*logicalDesc);
   ClearDescriptorStorage(*complexDesc);
   ClearDescriptorStorage(*characterDesc);
-  auto inCookie{IONAME(BeginInternalArrayListInput)(
-      internalDesc, nullptr, 0, __FILE__, __LINE__)};
+  auto inCookie{IONAME(BeginInternalArrayListInput)(internalDesc, nullptr, 0,
+                                                    __FILE__, __LINE__)};
   ASSERT_TRUE(IONAME(InputNamelist)(inCookie, group));
   auto inStatus{IONAME(EndIoStatement)(inCookie)};
   ASSERT_EQ(inStatus, 0) << "Failed namelist input sanity, status "
                          << static_cast<int>(inStatus);
-  auto outCookie2{IONAME(BeginInternalArrayListOutput)(
-      internalDesc, nullptr, 0, __FILE__, __LINE__)};
+  auto outCookie2{IONAME(BeginInternalArrayListOutput)(internalDesc, nullptr, 0,
+                                                       __FILE__, __LINE__)};
   ASSERT_TRUE(IONAME(SetDelim)(outCookie2, "APOSTROPHE", 10));
   ASSERT_TRUE(IONAME(OutputNamelist)(outCookie2, group));
   auto outStatus2{IONAME(EndIoStatement)(outCookie2)};
   ASSERT_EQ(outStatus2, 0) << "Failed namelist output sanity rewrite, status "
                            << static_cast<int>(outStatus2);
   std::string got2{buffer[0], sizeof buffer};
   EXPECT_EQ(got2, expect);
 }
 
 TEST(NamelistTests, Subscripts) {
   // INTEGER :: A(-1:0, -1:1)
   OwningPtr<Descriptor> aDesc{
       MakeArray<TypeCategory::Integer, static_cast<int>(sizeof(int))>(
           std::vector<int>{2, 3}, std::vector<int>(6, 0))};
   aDesc->GetDimension(0).SetBounds(-1, 0);
   aDesc->GetDimension(1).SetBounds(-1, 1);
   const NamelistGroup::Item items[]{{"a", *aDesc}};
   const NamelistGroup group{"justa", 1, items};
   static char t1[]{"&justa A(0,+1:-1:-2)=1 2/"};
   StaticDescriptor<1, true> statDesc;
   Descriptor &internalDesc{statDesc.descriptor()};
   internalDesc.Establish(TypeCode{CFI_type_char},
-      /*elementBytes=*/std::strlen(t1), t1, 0, nullptr, CFI_attribute_pointer);
-  auto inCookie{IONAME(BeginInternalArrayListInput)(
-      internalDesc, nullptr, 0, __FILE__, __LINE__)};
+                         /*elementBytes=*/std::strlen(t1), t1, 0, nullptr,
+                         CFI_attribute_pointer);
+  auto inCookie{IONAME(BeginInternalArrayListInput)(internalDesc, nullptr, 0,
+                                                    __FILE__, __LINE__)};
   ASSERT_TRUE(IONAME(InputNamelist)(inCookie, group));
   auto inStatus{IONAME(EndIoStatement)(inCookie)};
   ASSERT_EQ(inStatus, 0) << "Failed namelist input subscripts, status "
                          << static_cast<int>(inStatus);
   char out[40];
   internalDesc.Establish(TypeCode{CFI_type_char}, /*elementBytes=*/sizeof out,
                          out, 0, nullptr, CFI_attribute_pointer);
-  auto outCookie{IONAME(BeginInternalArrayListOutput)(
-      internalDesc, nullptr, 0, __FILE__, __LINE__)};
+  auto outCookie{IONAME(BeginInternalArrayListOutput)(internalDesc, nullptr, 0,
+                                                      __FILE__, __LINE__)};
   ASSERT_TRUE(IONAME(OutputNamelist)(outCookie, group));
   auto outStatus{IONAME(EndIoStatement)(outCookie)};
   ASSERT_EQ(outStatus, 0)
       << "Failed namelist output subscripts rewrite, status "
       << static_cast<int>(outStatus);
   std::string got{out, sizeof out};
   static const std::string expect{"&JUSTA A= 0 2 0 0 0 1/                  "};
   EXPECT_EQ(got, expect);
TEST(NamelistTests, ShortArrayInput) {
   const NamelistGroup group{"nl", 2, items};
   // Two 12-character lines of internal input
   static char t1[]{"&nl a = 1 b "
                    " = 2 /      "};
   StaticDescriptor<1, true> statDesc;
   Descriptor &internalDesc{statDesc.descriptor()};
   SubscriptValue shape{2};
   internalDesc.Establish(1, 12, t1, 1, &shape, CFI_attribute_pointer);
-  auto inCookie{IONAME(BeginInternalArrayListInput)(
-      internalDesc, nullptr, 0, __FILE__, __LINE__)};
+  auto inCookie{IONAME(BeginInternalArrayListInput)(internalDesc, nullptr, 0,
+                                                    __FILE__, __LINE__)};
   ASSERT_TRUE(IONAME(InputNamelist)(inCookie, group));
   auto inStatus{IONAME(EndIoStatement)(inCookie)};
   ASSERT_EQ(inStatus, 0) << "Failed namelist input subscripts, status "
                          << static_cast<int>(inStatus);
   EXPECT_EQ(*aDesc->ZeroBasedIndexedElement<int>(0), 1);
   EXPECT_EQ(*aDesc->ZeroBasedIndexedElement<int>(1), -1);
   EXPECT_EQ(*bDesc->ZeroBasedIndexedElement<int>(0), 2);
   EXPECT_EQ(*bDesc->ZeroBasedIndexedElement<int>(1), -2);
 }
 
 TEST(NamelistTests, ScalarSubstring) {
   OwningPtr<Descriptor> scDesc{MakeArray<TypeCategory::Character, 1>(
       std::vector<int>{}, std::vector<std::string>{"abcdefgh"}, 8)};
   const NamelistGroup::Item items[]{{"a", *scDesc}};
   const NamelistGroup group{"justa", 1, items};
   static char t1[]{"&justa A(2:5)='BCDE'/"};
   StaticDescriptor<1, true> statDesc;
   Descriptor &internalDesc{statDesc.descriptor()};
   internalDesc.Establish(TypeCode{CFI_type_char},
-      /*elementBytes=*/std::strlen(t1), t1, 0, nullptr, CFI_attribute_pointer);
-  auto inCookie{IONAME(BeginInternalArrayListInput)(
-      internalDesc, nullptr, 0, __FILE__, __LINE__)};
+                         /*elementBytes=*/std::strlen(t1), t1, 0, nullptr,
+                         CFI_attribute_pointer);
+  auto inCookie{IONAME(BeginInternalArrayListInput)(internalDesc, nullptr, 0,
+                                                    __FILE__, __LINE__)};
   ASSERT_TRUE(IONAME(InputNamelist)(inCookie, group));
   ASSERT_EQ(IONAME(EndIoStatement)(inCookie), IostatOk)
       << "namelist scalar substring input";
   char out[32];
   internalDesc.Establish(TypeCode{CFI_type_char}, /*elementBytes=*/sizeof out,
                          out, 0, nullptr, CFI_attribute_pointer);
-  auto outCookie{IONAME(BeginInternalArrayListOutput)(
-      internalDesc, nullptr, 0, __FILE__, __LINE__)};
+  auto outCookie{IONAME(BeginInternalArrayListOutput)(internalDesc, nullptr, 0,
+                                                      __FILE__, __LINE__)};
   ASSERT_TRUE(IONAME(SetDelim)(outCookie, "apostrophe", 10));
   ASSERT_TRUE(IONAME(OutputNamelist)(outCookie, group));
   ASSERT_EQ(IONAME(EndIoStatement)(outCookie), IostatOk) << "namelist output";
   std::string got{out, sizeof out};
   static const std::string expect{"&JUSTA A= 'aBCDEfgh'/           "};
   EXPECT_EQ(got, expect);
 }
 
 TEST(NamelistTests, ArraySubstring) {
-  OwningPtr<Descriptor> scDesc{
-      MakeArray<TypeCategory::Character, 1>(std::vector<int>{2},
-          std::vector<std::string>{"abcdefgh", "ijklmnop"}, 8)};
+  OwningPtr<Descriptor> scDesc{MakeArray<TypeCategory::Character, 1>(
+      std::vector<int>{2}, std::vector<std::string>{"abcdefgh", "ijklmnop"},
+      8)};
   const NamelistGroup::Item items[]{{"a", *scDesc}};
   const NamelistGroup group{"justa", 1, items};
   static char t1[]{"&justa A(:)(2:+5)='BCDE' 'JKLM'/"};
   StaticDescriptor<1, true> statDesc;
   Descriptor &internalDesc{statDesc.descriptor()};
   internalDesc.Establish(TypeCode{CFI_type_char},
-      /*elementBytes=*/std::strlen(t1), t1, 0, nullptr, CFI_attribute_pointer);
-  auto inCookie{IONAME(BeginInternalArrayListInput)(
-      internalDesc, nullptr, 0, __FILE__, __LINE__)};
+                         /*elementBytes=*/std::strlen(t1), t1, 0, nullptr,
+                         CFI_attribute_pointer);
+  auto inCookie{IONAME(BeginInternalArrayListInput)(internalDesc, nullptr, 0,
+                                                    __FILE__, __LINE__)};
   ASSERT_TRUE(IONAME(InputNamelist)(inCookie, group));
   ASSERT_EQ(IONAME(EndIoStatement)(inCookie), IostatOk)
       << "namelist scalar substring input";
   char out[40];
   internalDesc.Establish(TypeCode{CFI_type_char}, /*elementBytes=*/sizeof out,
                          out, 0, nullptr, CFI_attribute_pointer);
-  auto outCookie{IONAME(BeginInternalArrayListOutput)(
-      internalDesc, nullptr, 0, __FILE__, __LINE__)};
+  auto outCookie{IONAME(BeginInternalArrayListOutput)(internalDesc, nullptr, 0,
+                                                      __FILE__, __LINE__)};
   ASSERT_TRUE(IONAME(SetDelim)(outCookie, "apostrophe", 10));
   ASSERT_TRUE(IONAME(OutputNamelist)(outCookie, group));
   ASSERT_EQ(IONAME(EndIoStatement)(outCookie), IostatOk) << "namelist output";
   std::string got{out, sizeof out};
   static const std::string expect{"&JUSTA A= 'aBCDEfgh' 'iJKLMnop'/        "};
   EXPECT_EQ(got, expect);
 }
 
 TEST(NamelistTests, Skip) {
   OwningPtr<Descriptor> scDesc{
       MakeArray<TypeCategory::Integer, static_cast<int>(sizeof(int))>(
           std::vector<int>{}, std::vector<int>{-1})};
   const NamelistGroup::Item items[]{{"j", *scDesc}};
   const NamelistGroup group{"nml", 1, items};
   static char t1[]{"&skip a='str''ing'/&nml j=123/"};
   StaticDescriptor<1, true> statDesc;
   Descriptor &internalDesc{statDesc.descriptor()};
   internalDesc.Establish(TypeCode{CFI_type_char},
-      /*elementBytes=*/std::strlen(t1), t1, 0, nullptr, CFI_attribute_pointer);
-  auto inCookie{IONAME(BeginInternalArrayListInput)(
-      internalDesc, nullptr, 0, __FILE__, __LINE__)};
+                         /*elementBytes=*/std::strlen(t1), t1, 0, nullptr,
+                         CFI_attribute_pointer);
+  auto inCookie{IONAME(BeginInternalArrayListInput)(internalDesc, nullptr, 0,
+                                                    __FILE__, __LINE__)};
   ASSERT_TRUE(IONAME(InputNamelist)(inCookie, group));
   ASSERT_EQ(IONAME(EndIoStatement)(inCookie), IostatOk)
       << "namelist input with skipping";
   char out[20];
   internalDesc.Establish(TypeCode{CFI_type_char}, /*elementBytes=*/sizeof out,
                          out, 0, nullptr, CFI_attribute_pointer);
-  auto outCookie{IONAME(BeginInternalArrayListOutput)(
-      internalDesc, nullptr, 0, __FILE__, __LINE__)};
+  auto outCookie{IONAME(BeginInternalArrayListOutput)(internalDesc, nullptr, 0,
+                                                      __FILE__, __LINE__)};
   ASSERT_TRUE(IONAME(OutputNamelist)(outCookie, group));
   ASSERT_EQ(IONAME(EndIoStatement)(outCookie), IostatOk) << "namelist output";
   std::string got{out, sizeof out};
   static const std::string expect{"&NML J= 123/        "};
   EXPECT_EQ(got, expect);
 }
 
 // Tests DECIMAL=COMMA mode
 TEST(NamelistTests, Comma) {
   OwningPtr<Descriptor> scDesc{
       MakeArray<TypeCategory::Complex, static_cast<int>(sizeof(float))>(
           std::vector<int>{2}, std::vector<std::complex<float>>{{}, {}})};
   const NamelistGroup::Item items[]{{"z", *scDesc}};
   const NamelistGroup group{"nml", 1, items};
   static char t1[]{"&nml z=(-1,0;2,0);(-3,0;0,5)/"};
   StaticDescriptor<1, true> statDesc;
   Descriptor &internalDesc{statDesc.descriptor()};
   internalDesc.Establish(TypeCode{CFI_type_char},
-      /*elementBytes=*/std::strlen(t1), t1, 0, nullptr, CFI_attribute_pointer);
-  auto inCookie{IONAME(BeginInternalArrayListInput)(
-      internalDesc, nullptr, 0, __FILE__, __LINE__)};
+                         /*elementBytes=*/std::strlen(t1), t1, 0, nullptr,
+                         CFI_attribute_pointer);
+  auto inCookie{IONAME(BeginInternalArrayListInput)(internalDesc, nullptr, 0,
+                                                    __FILE__, __LINE__)};
   ASSERT_TRUE(IONAME(SetDecimal)(inCookie, "COMMA", 5));
   ASSERT_TRUE(IONAME(InputNamelist)(inCookie, group));
   ASSERT_EQ(IONAME(EndIoStatement)(inCookie), IostatOk)
       << "namelist input with skipping";
   char out[30];
   internalDesc.Establish(TypeCode{CFI_type_char}, /*elementBytes=*/sizeof out,
                          out, 0, nullptr, CFI_attribute_pointer);
-  auto outCookie{IONAME(BeginInternalArrayListOutput)(
-      internalDesc, nullptr, 0, __FILE__, __LINE__)};
+  auto outCookie{IONAME(BeginInternalArrayListOutput)(internalDesc, nullptr, 0,
+                                                      __FILE__, __LINE__)};
   ASSERT_TRUE(IONAME(SetDecimal)(outCookie, "COMMA", 5));
   ASSERT_TRUE(IONAME(OutputNamelist)(outCookie, group));
   ASSERT_EQ(IONAME(EndIoStatement)(outCookie), IostatOk) << "namelist output";
   std::string got{out, sizeof out};
   static const std::string expect{"&NML Z= (-1,;2,) (-3,;,5)/    "};
   EXPECT_EQ(got, expect);
 }
 
 // TODO: Internal NAMELIST error tests

flang-rt/unittests/FortranRuntime/RuntimeCrashTest.cpp

 //===-- flang/unittests/Runtime/CrashHandlerFixture.cpp ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 /// Selected APIs are tested here to support development of unit tests for other
 /// runtime components and ensure the test fixture handles crashes as we expect.
 //
 //===----------------------------------------------------------------------===//
 #include "CrashHandlerFixture.h"
-#include "tools.h"
-#include "../../runtime/terminator.h"
+#include "flang/../../runtime/terminator.h"
 #include "flang/Runtime/io-api.h"
 #include "flang/Runtime/transformational.h"
+#include "tools.h"
 #include <gtest/gtest.h>
 
 using namespace Fortran::runtime;
 using namespace Fortran::runtime::io;
 using Fortran::common::TypeCategory;
 
 //------------------------------------------------------------------------------
 /// Test crashes through direct calls to terminator methods
 //------------------------------------------------------------------------------
 struct TestTerminator : CrashHandlerFixture {};
 
-#define TEST_CRASH_HANDLER_MESSAGE \
+#define TEST_CRASH_HANDLER_MESSAGE                                             \
   "Intentionally crashing runtime for unit test"
 
 TEST(TestTerminator, CrashTest) {
   static Fortran::runtime::Terminator t;
   ASSERT_DEATH(t.Crash(TEST_CRASH_HANDLER_MESSAGE), TEST_CRASH_HANDLER_MESSAGE);
 }
 
 #undef TEST_CRASH_HANDLER_MESSAGE
 
 TEST(TestTerminator, CheckFailedLocationTest) {
   static Fortran::runtime::Terminator t;
   ASSERT_DEATH(t.CheckFailed("predicate", "someFileName", 789),
                "RUNTIME_CHECK\\(predicate\\) failed at someFileName\\(789\\)");
 }
 
 TEST(TestTerminator, CheckFailedTest) {
   static Fortran::runtime::Terminator t;
   ASSERT_DEATH(t.CheckFailed("predicate"),
                "RUNTIME_CHECK\\(predicate\\) failed at \\(null\\)\\(0\\)");
 }
 
 //------------------------------------------------------------------------------
 /// Test misuse of io api
 //------------------------------------------------------------------------------
 struct TestIOCrash : CrashHandlerFixture {};
 
 TEST(TestIOCrash, FormatDescriptorWriteMismatchTest) {
   static constexpr int bufferSize{4};
   static char buffer[bufferSize];
   static const char *format{"(A4)"};
-  auto *cookie{IONAME(BeginInternalFormattedOutput)(
-      buffer, bufferSize, format, std::strlen(format))};
-  ASSERT_DEATH(IONAME(OutputLogical)(cookie, true),
+  auto *cookie{IONAME(BeginInternalFormattedOutput)(buffer, bufferSize, format,
+                                                    std::strlen(format))};
+  ASSERT_DEATH(
+      IONAME(OutputLogical)(cookie, true),
       "Data edit descriptor 'A' may not be used with a LOGICAL data item");
 }
 
 TEST(TestIOCrash, InvalidFormatCharacterTest) {
   static constexpr int bufferSize{1};
   static char buffer[bufferSize];
   static const char *format{"(C1)"};
-  auto *cookie{IONAME(BeginInternalFormattedOutput)(
-      buffer, bufferSize, format, std::strlen(format))};
+  auto *cookie{IONAME(BeginInternalFormattedOutput)(buffer, bufferSize, format,
+                                                    std::strlen(format))};
   ASSERT_DEATH(IONAME(OutputInteger64)(cookie, 0xfeedface),
                "Unknown 'C' edit descriptor in FORMAT");
 }
 
 //------------------------------------------------------------------------------
 /// Test buffer overwrites with Output* functions
 /// Each test performs the tested IO operation correctly first, before causing
 /// an overwrite to demonstrate that the failure is caused by the overwrite and
 /// not a misuse of the API.
 //------------------------------------------------------------------------------
 TEST(TestIOCrash, OverwriteBufferAsciiTest) {
   static constexpr int bufferSize{4};
   static char buffer[bufferSize];
   static const char *format{"(A4)"};
-  auto *cookie{IONAME(BeginInternalFormattedOutput)(
-      buffer, bufferSize, format, std::strlen(format))};
+  auto *cookie{IONAME(BeginInternalFormattedOutput)(buffer, bufferSize, format,
+                                                    std::strlen(format))};
   IONAME(OutputAscii)(cookie, "four", bufferSize);
   ASSERT_DEATH(IONAME(OutputAscii)(cookie, "Too many characters!", 20),
                "Internal write overran available records");
 }
 
 TEST(TestIOCrash, OverwriteBufferCharacterTest) {
   static constexpr int bufferSize{1};
   static char buffer[bufferSize];
   static const char *format{"(A1)"};
-  auto *cookie{IONAME(BeginInternalFormattedOutput)(
-      buffer, bufferSize, format, std::strlen(format))};
+  auto *cookie{IONAME(BeginInternalFormattedOutput)(buffer, bufferSize, format,
+                                                    std::strlen(format))};
   IONAME(OutputCharacter)(cookie, "a", 1);
   ASSERT_DEATH(IONAME(OutputCharacter)(cookie, "a", 1),
                "Internal write overran available records");
 }
 
 TEST(TestIOCrash, OverwriteBufferLogicalTest) {
   static constexpr int bufferSize{1};
   static char buffer[bufferSize];
   static const char *format{"(L1)"};
-  auto *cookie{IONAME(BeginInternalFormattedOutput)(
-      buffer, bufferSize, format, std::strlen(format))};
+  auto *cookie{IONAME(BeginInternalFormattedOutput)(buffer, bufferSize, format,
+                                                    std::strlen(format))};
   IONAME(OutputLogical)(cookie, true);
   ASSERT_DEATH(IONAME(OutputLogical)(cookie, true),
                "Internal write overran available records");
 }
 
 TEST(TestIOCrash, OverwriteBufferRealTest) {
   static constexpr int bufferSize{1};
   static char buffer[bufferSize];
   static const char *format{"(F1)"};
-  auto *cookie{IONAME(BeginInternalFormattedOutput)(
-      buffer, bufferSize, format, std::strlen(format))};
+  auto *cookie{IONAME(BeginInternalFormattedOutput)(buffer, bufferSize, format,
+                                                    std::strlen(format))};
   IONAME(OutputReal32)(cookie, 1.);
   EXPECT_DEATH(IONAME(OutputReal32)(cookie, 1.),
                "Internal write overran available records");
 
   std::memset(buffer, '\0', bufferSize);
-  cookie = IONAME(BeginInternalFormattedOutput)(
-      buffer, bufferSize, format, std::strlen(format));
+  cookie = IONAME(BeginInternalFormattedOutput)(buffer, bufferSize, format,
+                                                std::strlen(format));
   IONAME(OutputReal64)(cookie, 1.);
   EXPECT_DEATH(IONAME(OutputReal64)(cookie, 1.),
                "Internal write overran available records");
 }
 
 TEST(TestIOCrash, OverwriteBufferComplexTest) {
   static constexpr int bufferSize{8};
   static char buffer[bufferSize];
   static const char *format{"(Z1,Z1)"};
-  auto *cookie{IONAME(BeginInternalFormattedOutput)(
-      buffer, bufferSize, format, std::strlen(format))};
+  auto *cookie{IONAME(BeginInternalFormattedOutput)(buffer, bufferSize, format,
+                                                    std::strlen(format))};
   IONAME(OutputComplex32)(cookie, 1., 1.);
   EXPECT_DEATH(IONAME(OutputComplex32)(cookie, 1., 1.),
                "Internal write overran available records");
 
   std::memset(buffer, '\0', bufferSize);
-  cookie = IONAME(BeginInternalFormattedOutput)(
-      buffer, bufferSize, format, std::strlen(format));
+  cookie = IONAME(BeginInternalFormattedOutput)(buffer, bufferSize, format,
+                                                std::strlen(format));
   IONAME(OutputComplex64)(cookie, 1., 1.);
   EXPECT_DEATH(IONAME(OutputComplex64)(cookie, 1., 1.),
                "Internal write overran available records");
 }
 
 TEST(TestIOCrash, OverwriteBufferIntegerTest) {
   static constexpr int bufferSize{1};
   static char buffer[bufferSize];
   static const char *format{"(I1)"};
-  auto *cookie{IONAME(BeginInternalFormattedOutput)(
-      buffer, bufferSize, format, std::strlen(format))};
+  auto *cookie{IONAME(BeginInternalFormattedOutput)(buffer, bufferSize, format,
+                                                    std::strlen(format))};
   IONAME(OutputInteger64)(cookie, 0xdeadbeef);
   ASSERT_DEATH(IONAME(OutputInteger64)(cookie, 0xdeadbeef),
                "Internal write overran available records");
 }
 
 //------------------------------------------------------------------------------
 /// Test conformity issue reports in transformational intrinsics
 //------------------------------------------------------------------------------
 struct TestIntrinsicCrash : CrashHandlerFixture {};
 
 TEST(TestIntrinsicCrash, ConformityErrors) {
   // ARRAY(2,3) and MASK(2,4) should trigger a runtime error.
   auto array{MakeArray<TypeCategory::Integer, 4>(
       std::vector<int>{2, 3}, std::vector<std::int32_t>{1, 2, 3, 4, 5, 6})};
-  auto mask{MakeArray<TypeCategory::Logical, 1>(std::vector<int>{2, 4},
-      std::vector<std::uint8_t>{
-          false, true, true, false, false, true, true, true})};
+  auto mask{MakeArray<TypeCategory::Logical, 1>(
+      std::vector<int>{2, 4},
+      std::vector<std::uint8_t>{false, true, true, false, false, true, true,
+                                true})};
   StaticDescriptor<1, true> statDesc;
   Descriptor &result{statDesc.descriptor()};
 
-  ASSERT_DEATH(RTNAME(Pack)(result, *array, *mask, nullptr, __FILE__, __LINE__),
+  ASSERT_DEATH(
+      RTNAME(Pack)(result, *array, *mask, nullptr, __FILE__, __LINE__),
       "Incompatible array arguments to PACK: dimension 2 of ARRAY= has extent "
       "3 but MASK= has extent 4");
 }

flang-rt/unittests/FortranRuntime/Stop.cpp

 //===-- flang/unittests/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
 //
 //===----------------------------------------------------------------------===//
 //
 /// Test runtime API for STOP statement and runtime API to kill the program.
 //
 //===----------------------------------------------------------------------===//
 #include "flang/Runtime/stop.h"
 #include "CrashHandlerFixture.h"
-#include "../../runtime/environment.h"
+#include "flang/../../runtime/environment.h"
 #include <cstdlib>
 #include <gtest/gtest.h>
 
 using namespace Fortran::runtime;
 
 struct TestProgramEnd : CrashHandlerFixture {};
 
 TEST(TestProgramEnd, StopTest) {
   EXPECT_EXIT(RTNAME(StopStatement)(), testing::ExitedWithCode(EXIT_SUCCESS),
               "Fortran STOP");
 }
 
 TEST(TestProgramEnd, StopTestNoStopMessage) {
   putenv(const_cast<char *>("NO_STOP_MESSAGE=1"));
-  Fortran::runtime::executionEnvironment.Configure(
-      0, nullptr, nullptr, nullptr);
-  EXPECT_EXIT(
-      RTNAME(StopStatement)(), testing::ExitedWithCode(EXIT_SUCCESS), "");
+  Fortran::runtime::executionEnvironment.Configure(0, nullptr, nullptr,
+                                                   nullptr);
+  EXPECT_EXIT(RTNAME(StopStatement)(), testing::ExitedWithCode(EXIT_SUCCESS),
+              "");
 }
 
 TEST(TestProgramEnd, StopMessageTest) {
   static const char *message{"bye bye"};
   EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
                                         /*isErrorStop=*/false, /*quiet=*/false),
               testing::ExitedWithCode(EXIT_SUCCESS), "Fortran STOP: bye bye");
 
   EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
                                         /*isErrorStop=*/false, /*quiet=*/true),
               testing::ExitedWithCode(EXIT_SUCCESS), "");
 
   EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
                                         /*isErrorStop=*/true, /*quiet=*/false),
-      testing::ExitedWithCode(EXIT_FAILURE), "Fortran ERROR STOP: bye bye");
+              testing::ExitedWithCode(EXIT_FAILURE),
+              "Fortran ERROR STOP: bye bye");
 
   EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
                                         /*isErrorStop=*/true, /*quiet=*/true),
               testing::ExitedWithCode(EXIT_FAILURE), "");
 }
 
 TEST(TestProgramEnd, NoStopMessageTest) {
   putenv(const_cast<char *>("NO_STOP_MESSAGE=1"));
-  Fortran::runtime::executionEnvironment.Configure(
-      0, nullptr, nullptr, nullptr);
+  Fortran::runtime::executionEnvironment.Configure(0, nullptr, nullptr,
+                                                   nullptr);
   static const char *message{"bye bye"};
   EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
                                         /*isErrorStop=*/false, /*quiet=*/false),
               testing::ExitedWithCode(EXIT_SUCCESS), "bye bye");
 
   EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
                                         /*isErrorStop=*/false, /*quiet=*/true),
               testing::ExitedWithCode(EXIT_SUCCESS), "");
 
   EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
                                         /*isErrorStop=*/true, /*quiet=*/false),
-      testing::ExitedWithCode(EXIT_FAILURE), "Fortran ERROR STOP: bye bye");
+              testing::ExitedWithCode(EXIT_FAILURE),
+              "Fortran ERROR STOP: bye bye");
 
   EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
                                         /*isErrorStop=*/true, /*quiet=*/true),
               testing::ExitedWithCode(EXIT_FAILURE), "");
 }
 
 TEST(TestProgramEnd, FailImageTest) {
-  EXPECT_EXIT(
-      RTNAME(FailImageStatement)(), testing::ExitedWithCode(EXIT_FAILURE), "");
+  EXPECT_EXIT(RTNAME(FailImageStatement)(),
+              testing::ExitedWithCode(EXIT_FAILURE), "");
 }
 
 TEST(TestProgramEnd, ExitTest) {
   EXPECT_EXIT(RTNAME(Exit)(), testing::ExitedWithCode(EXIT_SUCCESS), "");
-  EXPECT_EXIT(
-      RTNAME(Exit)(EXIT_FAILURE), testing::ExitedWithCode(EXIT_FAILURE), "");
+  EXPECT_EXIT(RTNAME(Exit)(EXIT_FAILURE), testing::ExitedWithCode(EXIT_FAILURE),
+              "");
 }
 
 TEST(TestProgramEnd, AbortTest) { EXPECT_DEATH(RTNAME(Abort)(), ""); }
 
 TEST(TestProgramEnd, CrashTest) {
   static const std::string crashMessage{"bad user code"};
   static const std::string fileName{"file name"};
   static const std::string headMessage{"fatal Fortran runtime error\\("};
   static const std::string tailMessage{":343\\): "};
-  static const std::string fullMessage{
-      headMessage + fileName + tailMessage + crashMessage};
+  static const std::string fullMessage{headMessage + fileName + tailMessage +
+                                       crashMessage};
   EXPECT_DEATH(
       RTNAME(ReportFatalUserError)(crashMessage.c_str(), fileName.c_str(), 343),
       fullMessage.c_str());
 }

flang/CMakeLists.txt

else()
       message(WARNING
       "Unit-tests will be skipped as LLVM install does not include google-test related headers and libraries.")
       set(FLANG_GTEST_AVAIL 0)
     endif()
   endif()
   if (FLANG_GTEST_AVAIL)
     add_custom_target(check-all DEPENDS check-flang FlangUnitTests)
   else()
-    add_custom_target(check-all DEPENDS check-flang )
+    add_custom_target(check-all DEPENDS check-flang)
   endif()
   if (LLVM_BUILD_DOCS)
     add_custom_target(doxygen ALL)
   endif()
 
 else()
   option(FLANG_INCLUDE_TESTS
          "Generate build targets for the Flang unit tests."

 
 include(CMakeParseArguments)
 include(AddFlang)
 
 if (FLANG_INCLUDE_TESTS)
   add_compile_definitions(FLANG_INCLUDE_TESTS=1)
 endif()
 
+# Add Flang subdirectories.
+# NOTE: The runtime subdirectory is no longer added here.
+# Sources for the runtime are added in Flang-rt.
+# TODO: Move the runtime sources to the flang-rt top level directory.
+
 add_subdirectory(include)
 add_subdirectory(lib)
 add_subdirectory(cmake/modules)
 
 option(FLANG_BUILD_TOOLS
   "Build the Flang tools. If OFF, just generate build targets." ON)
 if (FLANG_BUILD_TOOLS)
   add_subdirectory(tools)
 endif()
-add_subdirectory(runtime)
 
 if (LLVM_INCLUDE_EXAMPLES)
   add_subdirectory(examples)
 endif()
 
 if (FLANG_INCLUDE_TESTS)
   add_subdirectory(test)
   if (FLANG_GTEST_AVAIL)

flang/cmake/modules/AddFlang.cmake

macro(set_flang_windows_version_resource_properties name)
   endif()
 endmacro()
 
 macro(add_flang_subdirectory name)
   add_llvm_subdirectory(FLANG TOOL ${name})
 endmacro()
 
 function(add_flang_library name)
-  set(options SHARED STATIC INSTALL_WITH_TOOLCHAIN)
+  set(options SHARED STATIC INSTALL_WITH_TOOLCHAIN PIC)
   set(multiValueArgs ADDITIONAL_HEADERS CLANG_LIBS)
   cmake_parse_arguments(ARG
     "${options}"
     ""
     "${multiValueArgs}"
     ${ARGN})
 
   set(srcs)
if (BUILD_SHARED_LIBS AND NOT ARG_STATIC)
       set(LIBTYPE SHARED OBJECT)
     else()
       set(LIBTYPE STATIC OBJECT)
     endif()
     set_property(GLOBAL APPEND PROPERTY FLANG_STATIC_LIBS ${name})
   endif()
 
   llvm_add_library(${name} ${LIBTYPE} ${ARG_UNPARSED_ARGUMENTS} ${srcs})
+  if (ARG_PIC)
+    set_target_properties(${name} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+  endif()
 
   clang_target_link_libraries(${name} PRIVATE ${ARG_CLANG_LIBS})
 
   if (TARGET ${name})
 
     if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY OR ${name} STREQUAL "libflang"
         OR ARG_INSTALL_WITH_TOOLCHAIN)
       get_target_export_arg(${name} Flang export_to_flangtargets UMBRELLA flang-libraries)

flang/cmake/modules/FlangConfig.cmake.in

 # This file allows users to call find_package(Flang) and pick up our targets.
 
 @FLANG_CONFIG_CODE@
 
 set(LLVM_VERSION @LLVM_VERSION_MAJOR@.@LLVM_VERSION_MINOR@.@LLVM_VERSION_PATCH@)
 find_package(LLVM ${LLVM_VERSION} EXACT REQUIRED CONFIG
              HINTS "@FLANG_CONFIG_LLVM_CMAKE_DIR@")
 
 set(FLANG_EXPORTED_TARGETS "@FLANG_EXPORTS@")
 set(FLANG_CMAKE_DIR "@FLANG_CONFIG_CMAKE_DIR@")
 set(FLANG_INCLUDE_DIRS "@FLANG_CONFIG_INCLUDE_DIRS@")
+set(FLANG_SOURCE_DIR "@FLANG_SOURCE_DIR@")
+set(FLANG_BINARY_DIR "@FLANG_BINARY_DIR@")
 
 # Provide all our library targets to users.
 @FLANG_CONFIG_INCLUDE_EXPORTS@

flang/lib/Decimal/CMakeLists.txt

 if (FLANG_RUNTIME_HAS_FNO_LTO_FLAG)
   append("-fno-lto" CMAKE_CXX_FLAGS)
 endif()
 
 # Disable libstdc++ assertions, even in an LLVM_ENABLE_ASSERTIONS build, to
 # avoid an unwanted dependency on libstdc++.so.
 add_definitions(-U_GLIBCXX_ASSERTIONS)
 
-add_flang_library(FortranDecimal INSTALL_WITH_TOOLCHAIN
+# Build FortranDecimal when the build target is Flang or LLVM.
+if (CMAKE_SOURCE_DIR STREQUAL FLANG_SOURCE_DIR OR CMAKE_SOURCE_DIR STREQUAL LLVM_MAIN_SRC_DIR)
+  add_flang_library(FortranDecimal
     binary-to-decimal.cpp
     decimal-to-binary.cpp
   )
+# Build FortranDecimalRT for FlangRT when the build target is Runtimes.
+# Standalone builds of FlangRT is not supported.
+elseif (CMAKE_SOURCE_DIR STREQUAL Runtimes_SOURCE_DIR)
+  add_flang_library(FortranDecimalRT STATIC INSTALL_WITH_TOOLCHAIN PIC
+    binary-to-decimal.cpp
+    decimal-to-binary.cpp
+  )
+else()
+  message(FATAL_ERROR "CMAKE_SOURCE_DIR of target points to neither Flang or Flang-rt, no library added for FortranDecimal.")
+endif()

flang/runtime/CMakeLists.txt

 #===-- runtime/CMakeLists.txt ----------------------------------------------===#
 #
 # 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
 #
 #===------------------------------------------------------------------------===#
 
+# TODO: Maybe this file should still be added by flang/CMakeLists.txt and
+# when FLANG_STANDALONE_BUILD=On and a new variable FLANG_BUILD_RUNTIME=On
+# we should invoke an ExternalProject_Add(flang-rt ...) from here?
+
 if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
   cmake_minimum_required(VERSION 3.20.0)
 
-  project(FlangRuntime C CXX)
+  project(FortranRuntime C CXX)
 
   set(CMAKE_CXX_STANDARD 17)
   set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
   set(CMAKE_CXX_EXTENSIONS OFF)
 
   set(FLANG_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/..")
 
   set(LLVM_COMMON_CMAKE_UTILS "${FLANG_SOURCE_DIR}/../cmake")

 append(${NO_LTO_FLAGS} CMAKE_C_FLAGS)
 append(${NO_LTO_FLAGS} CMAKE_CXX_FLAGS)
 
 # Disable libstdc++/libc++ assertions, even in an LLVM_ENABLE_ASSERTIONS build,
 # to avoid an unwanted dependency on libstdc++/libc++.so.
 add_definitions(-U_GLIBCXX_ASSERTIONS)
 add_definitions(-U_LIBCPP_ENABLE_ASSERTIONS)
 
-add_subdirectory(FortranMain)
-
 set(sources
   ISO_Fortran_binding.cpp
   allocatable.cpp
   array-constructor.cpp
   assign.cpp
   buffer.cpp
   command.cpp
   complex-powi.cpp
if (NOT FLANG_EXPERIMENTAL_OMP_OFFLOAD_BUILD STREQUAL "off")
   else()
     message(FATAL_ERROR
       "Flang runtime build is not supported for these compilers:\n"
       "CMAKE_CXX_COMPILER_ID: ${CMAKE_CXX_COMPILER_ID}\n"
       "CMAKE_C_COMPILER_ID: ${CMAKE_C_COMPILER_ID}")
   endif()
 endif()
 
-add_flang_library(FortranRuntime
+add_compile_options(-fPIC)
+
+add_flang_library(FortranRuntime STATIC
   ${sources}
   LINK_LIBS
-  FortranDecimal
+  FortranDecimalRT
 
   INSTALL_WITH_TOOLCHAIN
+  PIC
 )

flang/runtime/sum.cpp

 #if LDBL_MANT_DIG == 64
 CppTypeFor<TypeCategory::Real, 10> RTNAME(SumReal10)(const Descriptor &x,
     const char *source, int line, int dim, const Descriptor *mask) {
   return GetTotalReduction<TypeCategory::Real, 10>(
       x, source, line, dim, mask, RealSumAccumulator<long double>{x}, "SUM");
 }
 #endif
 #if LDBL_MANT_DIG == 113 || HAS_FLOAT128
+#if HAS_FLOAT128
+using AccumType = __float128;
+#else // if LDBL_MANT_DIG == 113
+using AccumType = long double;
+#endif
 CppTypeFor<TypeCategory::Real, 16> RTNAME(SumReal16)(const Descriptor &x,
     const char *source, int line, int dim, const Descriptor *mask) {
   return GetTotalReduction<TypeCategory::Real, 16>(
-      x, source, line, dim, mask, RealSumAccumulator<long double>{x}, "SUM");
+      x, source, line, dim, mask, RealSumAccumulator<AccumType>{x}, "SUM");
 }
 #endif
 
 void RTNAME(CppSumComplex4)(CppTypeFor<TypeCategory::Complex, 4> &result,
     const Descriptor &x, const char *source, int line, int dim,
     const Descriptor *mask) {
   result = GetTotalReduction<TypeCategory::Complex, 4>(
       x, source, line, dim, mask, ComplexSumAccumulator<double>{x}, "SUM");

flang/test/CMakeLists.txt

set(FLANG_TEST_DEPENDS
   module_files
   fir-opt
   tco
   bbc
   llvm-dis
   llvm-objdump
   llvm-readobj
   split-file
-  FortranRuntime
-  Fortran_main
-  FortranDecimal
 )
 if (LLVM_ENABLE_PLUGINS AND NOT WIN32)
   list(APPEND FLANG_TEST_DEPENDS Bye)
 endif()
 
 if (FLANG_INCLUDE_TESTS)
   if (FLANG_GTEST_AVAIL)
     list(APPEND FLANG_TEST_DEPENDS FlangUnitTests)

flang/test/Driver/linker-flags.f90

 ! Linker invocation to generate the executable
 ! NOTE: Since we are cross-compiling, the host toolchain executables may
 !       run on any other platform, such as Windows that use a .exe
 !       suffix. Clang's driver will try to resolve the path to the ld
 !       executable and may find the GNU linker from MinGW or Cygwin.
 ! GNU-LABEL:  "{{.*}}ld{{(\.exe)?}}"
 ! GNU-SAME: "[[object_file]]"
 ! GNU-SAME: -lFortran_main
-! GNU-SAME: -lFortranRuntime
-! GNU-SAME: -lFortranDecimal
+! GNU-SAME: -lflang-rt
 ! GNU-SAME: -lm
 
 ! DARWIN-LABEL:  "{{.*}}ld{{(\.exe)?}}"
 ! DARWIN-SAME: "[[object_file]]"
 ! DARWIN-SAME: -lFortran_main
-! DARWIN-SAME: -lFortranRuntime
-! DARWIN-SAME: -lFortranDecimal
+! DARWIN-SAME: -lflang-rt
 
 ! MINGW-LABEL:  "{{.*}}ld{{(\.exe)?}}"
 ! MINGW-SAME: "[[object_file]]"
 ! MINGW-SAME: -lFortran_main
-! MINGW-SAME: -lFortranRuntime
-! MINGW-SAME: -lFortranDecimal
+! MINGW-SAME: -lflang-rt
 
 ! NOTE: This also matches lld-link (when CLANG_DEFAULT_LINKER=lld) and
 !       any .exe suffix that is added when resolving to the full path of
 !       (lld-)link.exe on Windows platforms. The suffix may not be added
 !       when the executable is not found or on non-Windows platforms.
 ! MSVC-LABEL: link
 ! MSVC-SAME: Fortran_main.lib
-! MSVC-SAME: FortranRuntime.lib
-! MSVC-SAME: FortranDecimal.lib
+! MSVC-SAME: flang-rt.lib
 ! MSVC-SAME: /subsystem:console
 ! MSVC-SAME: "[[object_file]]"

flang/test/lit.cfg.py

else:
     tools.append(
         ToolSubst("%not_todo_abort_cmd", command=FindTool("not"), 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")
+    libruntime = os.path.join(config.flang_lib_dir, "libflang-rt.a")
     include = os.path.join(config.flang_src_dir, "include")
 
     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("%include", command=include, unresolved="fatal"))
 
 # Add all the tools and their substitutions (if applicable). Use the search paths provided for
 # finding the tools.
 if config.flang_standalone_build:
     llvm_config.add_tool_substitutions(
         tools, [config.flang_llvm_tools_dir, config.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/tools/flang-driver/CMakeLists.txt

 # Infrastructure to build flang driver entry point. Flang driver depends on
 # LLVM libraries.
 
 # Set your project compile flags.
 link_directories(${LLVM_LIBRARY_DIR})
 
 set( LLVM_LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}
   Option
   Support
   TargetParser
 )
 
 add_flang_tool(flang-new
   driver.cpp
   fc1_main.cpp
-
-  DEPENDS
-  # These libraries are used in the linker invocation generated by the driver
-  # (i.e. when constructing the linker job). Without them the driver would be
-  # unable to generate executables.
-  FortranRuntime
-  FortranDecimal
-  Fortran_main
 )
 
 target_link_libraries(flang-new
   PRIVATE
   flangFrontend
   flangFrontendTool
 )
 

flang/unittests/CMakeLists.txt

function(add_flang_unittest_offload_properties target)
   endif()
   # Enable OpenMP offload during linking. We may need to replace
   # LINK_OPTIONS with COMPILE_OPTIONS when there are OpenMP offload
   # unittests.
   #
   # FIXME: replace 'native' in --offload-arch option with the list
   #        of targets that Fortran Runtime was built for.
   #        Common code must be moved from flang/runtime/CMakeLists.txt.
+  # TODO: Revisit this because of Flang-rt. runtime is no longer an added subdirectory of flang. So we temporarily duplicated the option definition to here. This is not a permanent solution.
+  set(FLANG_EXPERIMENTAL_OMP_OFFLOAD_BUILD "off" CACHE STRING
+    "Compile Fortran runtime as OpenMP target offload sources (experimental). Valid options are 'off', 'host_device', 'nohost'")
+
   if (NOT FLANG_EXPERIMENTAL_OMP_OFFLOAD_BUILD STREQUAL "off")
     set_target_properties(${target}
         PROPERTIES LINK_OPTIONS
         "-fopenmp;--offload-arch=native"
-      )
   endif()
 endfunction()
 
 function(add_flang_unittest test_dirname)
   add_unittest(FlangUnitTests ${test_dirname} ${ARGN})
   add_flang_unittest_offload_properties(${test_dirname})
 endfunction()
 
function(add_flang_nongtest_unittest test_name)
 
   add_flang_unittest_offload_properties(${test_name}${suffix})
 endfunction()
 
 add_subdirectory(Optimizer)
 add_subdirectory(Common)
 add_subdirectory(Decimal)
 add_subdirectory(Evaluate)
-add_subdirectory(Runtime)
 add_subdirectory(Frontend)

flang/unittests/Evaluate/CMakeLists.txt

 
 add_flang_nongtest_unittest(intrinsics
   FortranCommon
   FortranEvaluateTesting
   FortranEvaluate
   FortranDecimal
   FortranSemantics
   FortranParser
-  FortranRuntime
 )
 
 add_flang_nongtest_unittest(logical
   FortranEvaluateTesting
   FortranEvaluate
   FortranSemantics
 )
 
 # GCC -fno-exceptions breaks the fenv.h interfaces needed to capture
 # IEEE exception flags (different use of the word "exception")
 # in the actual hardware floating-point status register, so ensure that
 # C++ exceptions are enabled for this test.
 set(LLVM_REQUIRES_EH ON)
 set(LLVM_REQUIRES_RTTI ON)
 add_flang_nongtest_unittest(real
   FortranEvaluateTesting
   FortranEvaluate
   FortranDecimal
   FortranSemantics
 )
 llvm_update_compile_flags(real.test)
 
-add_flang_nongtest_unittest(reshape
-  FortranEvaluateTesting
-  FortranSemantics
-  FortranEvaluate
-  FortranRuntime
-)
-
-add_flang_nongtest_unittest(ISO-Fortran-binding
-  FortranEvaluateTesting
-  FortranEvaluate
-  FortranSemantics
-  FortranRuntime
-)
-
 add_flang_nongtest_unittest(folding
   FortranCommon
   FortranEvaluateTesting
   FortranEvaluate
   FortranSemantics
 )

flang/unittests/Optimizer/CMakeLists.txt

 )
 
 add_flang_unittest(FlangOptimizerTests
   Builder/CharacterTest.cpp
   Builder/ComplexTest.cpp
   Builder/DoLoopHelperTest.cpp
   Builder/FIRBuilderTest.cpp
   Builder/HLFIRToolsTest.cpp
-  Builder/Runtime/AllocatableTest.cpp
-  Builder/Runtime/AssignTest.cpp
-  Builder/Runtime/CommandTest.cpp
-  Builder/Runtime/CharacterTest.cpp
-  Builder/Runtime/DerivedTest.cpp
-  Builder/Runtime/NumericTest.cpp
-  Builder/Runtime/RaggedTest.cpp
-  Builder/Runtime/ReductionTest.cpp
-  Builder/Runtime/StopTest.cpp
-  Builder/Runtime/TransformationalTest.cpp
   FIRContextTest.cpp
   FIRTypesTest.cpp
   FortranVariableTest.cpp
   InternalNamesTest.cpp
   KindMappingTest.cpp
   RTBuilder.cpp
 DEPENDS
   FIRDialect
   FIRSupport
   HLFIRDialect
   ${dialect_libs})
 
 target_link_libraries(FlangOptimizerTests
   PRIVATE
   ${LIBS})

lld/COFF/MinGW.cpp

excludeLibs = {
       "libclang_rt.profile",
       "libclang_rt.profile-aarch64",
       "libclang_rt.profile-arm",
       "libclang_rt.profile-i386",
       "libclang_rt.profile-x86_64",
       "libc++",
       "libc++abi",
       "libFortran_main",
-      "libFortranRuntime",
-      "libFortranDecimal",
+      "libflang-rt",
       "libunwind",
       "libmsvcrt",
       "libucrtbase",
   };
 
   excludeObjects = {
       "crt0.o",    "crt1.o",  "crt1u.o", "crt2.o",  "crt2u.o",    "dllcrt1.o",
       "dllcrt2.o", "gcrt0.o", "gcrt1.o", "gcrt2.o", "crtbegin.o", "crtend.o",

llvm/CMakeLists.txt

if ("flang" IN_LIST LLVM_ENABLE_PROJECTS)
   endif()
 endif()
 
 # Select the runtimes to build
 #
 # As we migrate runtimes to using the bootstrapping build, the set of default runtimes
 # should grow as we remove those runtimes from LLVM_ENABLE_PROJECTS above.
 set(LLVM_DEFAULT_RUNTIMES "libcxx;libcxxabi;libunwind")
-set(LLVM_SUPPORTED_RUNTIMES "libc;libunwind;libcxxabi;pstl;libcxx;compiler-rt;openmp;llvm-libgcc")
+if ("flang" IN_LIST LLVM_ENABLE_PROJECTS)
+  set(LLVM_DEFAULT_RUNTIMES "libcxx;libcxxabi;libunwind;flang-rt")
+endif()
+set(LLVM_SUPPORTED_RUNTIMES "libc;libunwind;libcxxabi;pstl;libcxx;compiler-rt;openmp;llvm-libgcc;flang-rt")
 set(LLVM_ENABLE_RUNTIMES "" CACHE STRING
   "Semicolon-separated list of runtimes to build, or \"all\" (${LLVM_DEFAULT_RUNTIMES}). Supported runtimes are ${LLVM_SUPPORTED_RUNTIMES}.")
 if(LLVM_ENABLE_RUNTIMES STREQUAL "all")
   set(LLVM_ENABLE_RUNTIMES ${LLVM_DEFAULT_RUNTIMES})
 endif()
 foreach(proj IN LISTS LLVM_ENABLE_RUNTIMES)
   if (NOT "${proj}" IN_LIST LLVM_SUPPORTED_RUNTIMES)
     message(FATAL_ERROR "Runtime \"${proj}\" is not a supported runtime. Supported runtimes are: ${LLVM_SUPPORTED_RUNTIMES}")
   endif()
 endforeach()
 
 if ("libc" IN_LIST LLVM_ENABLE_RUNTIMES)
   # To build the libc runtime, we need to be able to build few libc build
   # tools from the "libc" project. So, we add it to the list of enabled
   # projects.
   if (NOT "libc" IN_LIST LLVM_ENABLE_PROJECTS)
     message(STATUS "Enabling libc project to build libc build tools")
     list(APPEND LLVM_ENABLE_PROJECTS "libc")
   endif()
 endif()
 
+if ("flang" IN_LIST LLVM_ENABLE_PROJECTS AND NOT "flang-rt" IN_LIST LLVM_ENABLE_RUNTIMES)
+  message(STATUS "Enabling Flang-rt to be built with the Flang project.")
+  list(APPEND LLVM_ENABLE_RUNTIMES "flang-rt")
+endif()
+
 # LLVM_ENABLE_PROJECTS_USED is `ON` if the user has ever used the
 # `LLVM_ENABLE_PROJECTS` CMake cache variable.  This exists for
 # several reasons:
 #
 # * As an indicator that the `LLVM_ENABLE_PROJECTS` list is now the single
 # source of truth for which projects to build. This means we will ignore user
 # supplied `LLVM_TOOL_<project>_BUILD` CMake cache variables and overwrite
 # them.

llvm/projects/CMakeLists.txt

 # Discover the projects that use CMake in the subdirectories.
 # Note that explicit cmake invocation is required every time a new project is
 # added or removed.
 file(GLOB entries *)
 foreach(entry ${entries})
   if(IS_DIRECTORY ${entry} AND EXISTS ${entry}/CMakeLists.txt)
     if((NOT ${entry} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR}/compiler-rt) AND
        (NOT ${entry} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR}/dragonegg) AND
+       (NOT ${entry} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR}/flang-rt) AND
        (NOT ${entry} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR}/libcxx) AND
        (NOT ${entry} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR}/libcxxabi) AND
        (NOT ${entry} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR}/libunwind) AND
        (NOT ${entry} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR}/test-suite) AND
        (NOT ${entry} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR}/openmp) AND
        (NOT ${entry} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR}/cross-project-tests))
       get_filename_component(entry_name "${entry}" NAME)
       add_llvm_external_project(${entry_name})
if(NOT MSVC OR LLVM_FORCE_BUILD_RUNTIME)
     add_llvm_external_project(pstl)
     add_llvm_external_project(libc)
     add_llvm_external_project(libcxxabi)
     add_llvm_external_project(libcxx)
   endif()
   if(NOT LLVM_BUILD_EXTERNAL_COMPILER_RT)
     add_llvm_external_project(compiler-rt)
   endif()
+
+  add_llvm_external_project(flang-rt)
 endif()
 
 add_llvm_external_project(dragonegg)
 add_llvm_external_project(openmp)
 
 if(LLVM_INCLUDE_TESTS)
   add_llvm_external_project(cross-project-tests)
 endif()

llvm/runtimes/CMakeLists.txt

if("libc" IN_LIST LLVM_ENABLE_RUNTIMES AND
     if(LIBC_GPU_BUILD OR LIBC_GPU_ARCHITECTURES)
       foreach(dep clang-offload-packager nvptx-arch amdgpu-arch)
         if(TARGET ${dep})
           list(APPEND extra_deps ${dep})
         endif()
       endforeach()
     endif()
   endif()
+  set(EXTRA_CMAKE_ARGS "")
+  if("flang-rt" IN_LIST LLVM_ENABLE_RUNTIMES)
+    list(APPEND EXTRA_CMAKE_ARGS "-DLLVM_DIR=${LLVM_BINARY_DIR}/lib/cmake/llvm")
+    list(APPEND EXTRA_CMAKE_ARGS "-DFLANG_DIR=${LLVM_BINARY_DIR}/lib/cmake/flang")
+    list(APPEND EXTRA_CMAKE_ARGS "-DCLANG_DIR=${LLVM_BINARY_DIR}/lib/cmake/clang")
+    list(APPEND EXTRA_CMAKE_ARGS "-DMLIR_DIR=${LLVM_BINARY_DIR}/lib/cmake/mlir")
+  endif()
   if(NOT LLVM_RUNTIME_TARGETS)
     runtime_default_target(
       DEPENDS ${builtins_dep} ${extra_deps}
-      CMAKE_ARGS ${libc_cmake_args}
+      CMAKE_ARGS ${libc_cmake_args} ${EXTRA_CMAKE_ARGS}
       PREFIXES ${prefixes})
     set(test_targets check-runtimes)
   else()
     if("default" IN_LIST LLVM_RUNTIME_TARGETS)
       runtime_default_target(
         DEPENDS ${builtins_dep} ${extra_deps}
-        CMAKE_ARGS ${libc_cmake_args}
+        CMAKE_ARGS ${libc_cmake_args} ${EXTRA_CMAKE_ARGS}
         PREFIXES ${prefixes})
       list(REMOVE_ITEM LLVM_RUNTIME_TARGETS "default")
     else()
       add_custom_target(runtimes)
       add_custom_target(runtimes-configure)
       add_custom_target(install-runtimes)
       add_custom_target(install-runtimes-stripped)
       if(LLVM_INCLUDE_TESTS)
foreach(name ${LLVM_RUNTIME_TARGETS})
           set(builtins_dep_name ${builtins_dep})
         endif()
       endif()
 
       check_apple_target(${name} runtime)
 
       runtime_register_target(${name}
         DEPENDS ${builtins_dep_name} ${libc_tools}
-        CMAKE_ARGS -DLLVM_DEFAULT_TARGET_TRIPLE=${name} ${libc_cmake_args}
+        CMAKE_ARGS -DLLVM_DEFAULT_TARGET_TRIPLE=${name} ${libc_cmake_args} ${EXTRA_CMAKE_ARGS}
         EXTRA_ARGS TARGET_TRIPLE ${name})
 
       add_dependencies(runtimes runtimes-${name})
       add_dependencies(runtimes-configure runtimes-${name}-configure)
       add_dependencies(install-runtimes install-runtimes-${name})
       add_dependencies(install-runtimes-stripped install-runtimes-${name}-stripped)
       if(LLVM_INCLUDE_TESTS)
         add_dependencies(check-runtimes check-runtimes-${name})
else()
 
     foreach(multilib ${LLVM_RUNTIME_MULTILIBS})
       foreach(name ${LLVM_RUNTIME_MULTILIB_${multilib}_TARGETS})
         runtime_register_target(${name}+${multilib}
           DEPENDS runtimes-${name}
           CMAKE_ARGS -DLLVM_DEFAULT_TARGET_TRIPLE=${name}
                      -DLLVM_RUNTIMES_PREFIX=${name}/
                      -DLLVM_RUNTIMES_LIBDIR_SUBDIR=${multilib}
+                     ${EXTRA_CMAKE_ARGS}
           BASE_NAME ${name}
           EXTRA_ARGS TARGET_TRIPLE ${name})
 
         add_dependencies(runtimes runtimes-${name}+${multilib})
         add_dependencies(runtimes-configure runtimes-${name}+${multilib}-configure)
         add_dependencies(install-runtimes install-runtimes-${name}+${multilib})
         add_dependencies(install-runtimes-stripped install-runtimes-${name}+${multilib}-stripped)
         foreach(runtime_name ${runtime_names})

runtimes/CMakeLists.txt

list(INSERT CMAKE_MODULE_PATH 0
   "${CMAKE_CURRENT_SOURCE_DIR}/cmake"
   "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules"
   "${LLVM_COMMON_CMAKE_UTILS}"
   "${LLVM_COMMON_CMAKE_UTILS}/Modules"
   "${CMAKE_CURRENT_SOURCE_DIR}/../llvm/cmake"
   "${CMAKE_CURRENT_SOURCE_DIR}/../llvm/cmake/modules"
 )
 
 # We order libraries to mirror roughly how they are layered, except that compiler-rt can depend
 # on libc++, so we put it after.
-set(LLVM_DEFAULT_RUNTIMES "libc;libunwind;libcxxabi;pstl;libcxx;compiler-rt;openmp")
+set(LLVM_DEFAULT_RUNTIMES "libc;libunwind;libcxxabi;pstl;libcxx;compiler-rt;openmp;flang-rt")
 set(LLVM_SUPPORTED_RUNTIMES "${LLVM_DEFAULT_RUNTIMES};llvm-libgcc")
 set(LLVM_ENABLE_RUNTIMES "" CACHE STRING
   "Semicolon-separated list of runtimes to build, or \"all\" (${LLVM_DEFAULT_RUNTIMES}). Supported runtimes are ${LLVM_SUPPORTED_RUNTIMES}.")
 if(LLVM_ENABLE_RUNTIMES STREQUAL "all" )
   set(LLVM_ENABLE_RUNTIMES ${LLVM_DEFAULT_RUNTIMES})
 endif()
 include(SortSubset)
 sort_subset("${LLVM_SUPPORTED_RUNTIMES}" "${LLVM_ENABLE_RUNTIMES}" LLVM_ENABLE_RUNTIMES)