[flang][driver] Delete `f18` (i.e. the old Flang driver)

[awarzynski]

Summary

This patch removes f18, a.k.a. the old driver. It is being replaced
with the new driver, flang-new, which has reached feature parity with
f18 a while ago. This was discussed in [1] and also in [2].

With this change, FLANG_BUILD_NEW_DRIVER is no longer needed is deleted
as well. This means that we are making the dependency on Clang permanent
(i.e. it cannot be disabled with a CMake flag).

LIT set-up is updated accordingly. All references to f18 or f18.cpp
are either updated or removed.

[1] https://lists.llvm.org/pipermail/flang-dev/2021-June/000742.html
[2] https://reviews.llvm.org/D103177

[kiranchandramohan]

I get some build errors like the following with this patch.

c++ -DGTEST_HAS_RTTI=0 -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Itools/flang/lib/Frontend -I/home/kircha02/llvm-project/flang/lib/Frontend -I/home/kircha02/llvm-project/flang/include -Itools/flang/include -Iinclude -I/home/kircha02/llvm-project/llvm/include -isystem /home/kircha02/llvm-project/llvm/../mlir/include -isystem tools/mlir/include -isystem tools/clang/include -isystem /home/kircha02/llvm-project/llvm/../clang/include -fPIC -fno-semantic-interposition -fvisibility-inlines-hidden -Werror=date-time -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wno-missing-field-initializers -pedantic -Wno-long-long -Wimplicit-fallthrough -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wdelete-non-virtual-dtor -Wsuggest-override -Wno-comment -Wmisleading-indentation -fdiagnostics-color -ffunction-sections -fdata-sections -Wno-deprecated-copy -fno-strict-aliasing -fno-semantic-interposition -O3 -DNDEBUG  -fno-exceptions -fno-rtti -std=c++17 -MD -MT tools/flang/lib/Frontend/CMakeFiles/obj.flangFrontend.dir/CompilerInvocation.cpp.o -MF tools/flang/lib/Frontend/CMakeFiles/obj.flangFrontend.dir/CompilerInvocation.cpp.o.d -o tools/flang/lib/Frontend/CMakeFiles/obj.flangFrontend.dir/CompilerInvocation.cpp.o -c /home/kircha02/llvm-project/flang/lib/Frontend/CompilerInvocation.cpp
/home/kircha02/llvm-project/flang/lib/Frontend/CompilerInvocation.cpp: In function 'bool ParseFrontendArgs(Fortran::frontend::FrontendOptions&, llvm::opt::ArgList&, clang::DiagnosticsEngine&)':
/home/kircha02/llvm-project/flang/lib/Frontend/CompilerInvocation.cpp:105:36: error: 'class clang::DiagnosticsEngine' has no member named 'getNumErrors'; did you mean 'unsigned int clang::DiagnosticsEngine::NumErrors'? (not accessible from this context)
  105 |   unsigned numErrorsBefore = diags.getNumErrors();

Build steps used,

cmake -G Ninja ../llvm -DLLVM_ENABLE_PROJECTS="flang;clang;mlir;openmp" -DLLVM_TARGETS_TO_BUILD=AArch64 -DCMAKE_BUILD_TYPE=Release
nice -n 10 ninja

Since @sscalpone is the original author of the throw-away driver. It would be great to get his opinion before deleting f18.cpp. @klausler expressed some reservations in removing f18.cpp but subsequently said it is OK to delete it in the llvm-project/flang repo.

Regarding the dependency on Clang:

1. AMD engineers raised some issues in slack regarding build time in flang-compiler slack. Could @kiranktp let us know whether they have issues or whether they are OK?
2. I am guessing the default assumption is that the dependency on Clang will be permanent and there are no plans to remove the dependency.
3. One of the reasons for making the dependency on Clang permanent is some requirement for OpenMP that @jdoerfert mentioned in the call. I am personally not aware of any dependencies as of now for OpenMP on clang. I am assuming that this has something to do with offloading. Will this cause MLIR to have a dependency on Clang too (which might run into issues with the MLIR team)? Or is this again a driver induced dependency?

flang/include/flang/Frontend/CompilerInvocation.h

187

spelling: predefined

flang/test/lit.cfg.py

43

Is this required?

[awarzynski]

In D105811#2891108, @kiranchandramohan wrote:

I get some build errors like the following with this patch.

c++ -DGTEST_HAS_RTTI=0 -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Itools/flang/lib/Frontend -I/home/kircha02/llvm-project/flang/lib/Frontend -I/home/kircha02/llvm-project/flang/include -Itools/flang/include -Iinclude -I/home/kircha02/llvm-project/llvm/include -isystem /home/kircha02/llvm-project/llvm/../mlir/include -isystem tools/mlir/include -isystem tools/clang/include -isystem /home/kircha02/llvm-project/llvm/../clang/include -fPIC -fno-semantic-interposition -fvisibility-inlines-hidden -Werror=date-time -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wno-missing-field-initializers -pedantic -Wno-long-long -Wimplicit-fallthrough -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wdelete-non-virtual-dtor -Wsuggest-override -Wno-comment -Wmisleading-indentation -fdiagnostics-color -ffunction-sections -fdata-sections -Wno-deprecated-copy -fno-strict-aliasing -fno-semantic-interposition -O3 -DNDEBUG  -fno-exceptions -fno-rtti -std=c++17 -MD -MT tools/flang/lib/Frontend/CMakeFiles/obj.flangFrontend.dir/CompilerInvocation.cpp.o -MF tools/flang/lib/Frontend/CMakeFiles/obj.flangFrontend.dir/CompilerInvocation.cpp.o.d -o tools/flang/lib/Frontend/CMakeFiles/obj.flangFrontend.dir/CompilerInvocation.cpp.o -c /home/kircha02/llvm-project/flang/lib/Frontend/CompilerInvocation.cpp
/home/kircha02/llvm-project/flang/lib/Frontend/CompilerInvocation.cpp: In function 'bool ParseFrontendArgs(Fortran::frontend::FrontendOptions&, llvm::opt::ArgList&, clang::DiagnosticsEngine&)':
/home/kircha02/llvm-project/flang/lib/Frontend/CompilerInvocation.cpp:105:36: error: 'class clang::DiagnosticsEngine' has no member named 'getNumErrors'; did you mean 'unsigned int clang::DiagnosticsEngine::NumErrors'? (not accessible from this context)
  105 |   unsigned numErrorsBefore = diags.getNumErrors();

Build steps used,

cmake -G Ninja ../llvm -DLLVM_ENABLE_PROJECTS="flang;clang;mlir;openmp" -DLLVM_TARGETS_TO_BUILD=AArch64 -DCMAKE_BUILD_TYPE=Release
nice -n 10 ninja

@kiranchandramohan I am not able to reproduce this :/ Also, the pre-merge CI seems fine and this patch does not modify flang/lib/Frontend/CompilerInvocation.cpp. Very odd! The error message seems incorrect though:

• the failing line of code: https://github.com/llvm/llvm-project/blob/main/flang/lib/Frontend/CompilerInvocation.cpp#L105 (calls clang::DiagnosticsEngine::getNumErrors)
• the declaration of clang::DiagnosticsEngine::getNumErrors (public member method): https://github.com/llvm/llvm-project/blob/main/clang/include/clang/Basic/Diagnostic.h#L1716

Perhaps there was another error earlier?

1. I am guessing the default assumption is that the dependency on Clang will be permanent and there are no plans to remove the dependency.

No. Lifting clangDriver would be good for both Flang and Clang, but it will require a non-trivial amount of effort. It's been deprioritised in favour of other work items that are likely to bring comparable benefits at a lower cost (e.g. code-gen support).

1. Will this cause MLIR to have a dependency on Clang too (which might run into issues with the MLIR team)? Or is this again a driver induced dependency?

I am not too familiar with Flang's dependency on MLIR, but I don't see why Flang's dependency on Clang would make MLIR require Clang to build. As long as MLIR does not require Flang to build, all should be fine :) Perhaps I misunderstood your question?

[kiranchandramohan]

In D105811#2892928, @awarzynski wrote:

In D105811#2891108, @kiranchandramohan wrote:

I get some build errors like the following with this patch.

c++ -DGTEST_HAS_RTTI=0 -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Itools/flang/lib/Frontend -I/home/kircha02/llvm-project/flang/lib/Frontend -I/home/kircha02/llvm-project/flang/include -Itools/flang/include -Iinclude -I/home/kircha02/llvm-project/llvm/include -isystem /home/kircha02/llvm-project/llvm/../mlir/include -isystem tools/mlir/include -isystem tools/clang/include -isystem /home/kircha02/llvm-project/llvm/../clang/include -fPIC -fno-semantic-interposition -fvisibility-inlines-hidden -Werror=date-time -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wno-missing-field-initializers -pedantic -Wno-long-long -Wimplicit-fallthrough -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wdelete-non-virtual-dtor -Wsuggest-override -Wno-comment -Wmisleading-indentation -fdiagnostics-color -ffunction-sections -fdata-sections -Wno-deprecated-copy -fno-strict-aliasing -fno-semantic-interposition -O3 -DNDEBUG  -fno-exceptions -fno-rtti -std=c++17 -MD -MT tools/flang/lib/Frontend/CMakeFiles/obj.flangFrontend.dir/CompilerInvocation.cpp.o -MF tools/flang/lib/Frontend/CMakeFiles/obj.flangFrontend.dir/CompilerInvocation.cpp.o.d -o tools/flang/lib/Frontend/CMakeFiles/obj.flangFrontend.dir/CompilerInvocation.cpp.o -c /home/kircha02/llvm-project/flang/lib/Frontend/CompilerInvocation.cpp
/home/kircha02/llvm-project/flang/lib/Frontend/CompilerInvocation.cpp: In function 'bool ParseFrontendArgs(Fortran::frontend::FrontendOptions&, llvm::opt::ArgList&, clang::DiagnosticsEngine&)':
/home/kircha02/llvm-project/flang/lib/Frontend/CompilerInvocation.cpp:105:36: error: 'class clang::DiagnosticsEngine' has no member named 'getNumErrors'; did you mean 'unsigned int clang::DiagnosticsEngine::NumErrors'? (not accessible from this context)
  105 |   unsigned numErrorsBefore = diags.getNumErrors();

Build steps used,

cmake -G Ninja ../llvm -DLLVM_ENABLE_PROJECTS="flang;clang;mlir;openmp" -DLLVM_TARGETS_TO_BUILD=AArch64 -DCMAKE_BUILD_TYPE=Release
nice -n 10 ninja

@kiranchandramohan I am not able to reproduce this :/ Also, the pre-merge CI seems fine and this patch does not modify flang/lib/Frontend/CompilerInvocation.cpp. Very odd! The error message seems incorrect though:

• the failing line of code: https://github.com/llvm/llvm-project/blob/main/flang/lib/Frontend/CompilerInvocation.cpp#L105 (calls clang::DiagnosticsEngine::getNumErrors)
• the declaration of clang::DiagnosticsEngine::getNumErrors (public member method): https://github.com/llvm/llvm-project/blob/main/clang/include/clang/Basic/Diagnostic.h#L1716

Perhaps there was another error earlier?

Works fine on a fresh build.

1. I am guessing the default assumption is that the dependency on Clang will be permanent and there are no plans to remove the dependency.

No. Lifting clangDriver would be good for both Flang and Clang, but it will require a non-trivial amount of effort. It's been deprioritised in favour of other work items that are likely to bring comparable benefits at a lower cost (e.g. code-gen support).

I am guessing that upstreaming flang, feature-parity with classic-flang (Fortran + OpenMP) and productisation of llvm/flang are always going to be more important than removing the dependency. So the dependency is likely to stay.

1. Will this cause MLIR to have a dependency on Clang too (which might run into issues with the MLIR team)? Or is this again a driver induced dependency?

I am not too familiar with Flang's dependency on MLIR, but I don't see why Flang's dependency on Clang would make MLIR require Clang to build. As long as MLIR does not require Flang to build, all should be fine :) Perhaps I misunderstood your question?

Flang and MLIR have OpenMP support through the OpenMP dialect. If for OpenMP based offloading, flang has a dependency on clang then it might be the case that MLIR has as well.

[Meinersbur]

flang/docs/Overview.md

41

Shouldn't the docs refer to flang instead of flang-new? AFAIU flang will eventually be replaced by a proper executable that does not call gfortran anymore and flang-new go away.

flang/tools/f18/flang

185

247–258

Is F18_FC still defined?

336–337

llvm/CMakeLists.txt

84–85

[awarzynski]

flang/docs/Overview.md

41

I think that this document should only refer to the frontend driver rather than the compiler driver. In our case, that's either f18 (compiler driver + frontend driver) or flang-new -fc1 (new frontend driver). In fact, some options referred here are only available in flang-new -fc1 (i..e. these options are frontend-specific).

Currently, flang is a yet another tool - it's neither a compiler nor a frontend driver, so I don't want to use it here. IMO, we should first rename it as e.g. flang-to-gfortran (or something similar) to clarify what it actually does. Then, we can claim flang for the actual driver and update all the docs accordingly.

flang/test/lit.cfg.py

43

Some tests use it, e.g.: https://github.com/llvm/llvm-project/blob/main/flang/test/Driver/missing-arg.f90#L4

Technically speaking, this patch makes it irrelevant. However, I wanted to keep this change relatively small and easy to review. If I do remove new-flang-driver, I will have to update further 20 files. I'm fine with that, but I can also remove it in a subsequent NFC patch. What do you recommend?

flang/tools/f18/flang

247–258

Only here: https://github.com/llvm/llvm-project/blob/main/flang/docs/ReleaseNotes.md#using-flang. I think that we do want to support compilers other than gfortran (so we need to keep this variable).

336–337

This last sentence only applies to f18. I am deleting it.

[awarzynski]

Address comments from @Meinersbur and @kiranchandramohan

[Meinersbur]

flang/docs/Overview.md

41

Indeed this document is in the "Design Document" section of https://flang.llvm.org/docs/. However, could you still add a note that this is developer, not end-user documentation. Seems that we don't have and-user documentation yet.

If we follow the analogy of clang, then the eventual goal is that flang would be the primary user command and gfortran-compatible wrapper. flang -fc1 An implementation detail, but still accessible with -Xflang. Where does flang-new fit in here?

flang/tools/f18/flang

247–258

Maybe flang-new should have used FLANG_FC instead, but we can keep it as a (temporary?) compatibility option.

[awarzynski]

Mark Overview.md as developer rather than end-user doc. Replace F18_FC with FLANG_FC.

[awarzynski]

flang/docs/Overview.md

41

I'll update the documentation shortly.

As for flang vs flang-new vs flang -fc1, the plan is to first rename flang as e.g. flang-to-gfortran. We still need to decide when to do this. Once flang is renamed, flang-new can be renamed as flang and flang-new -fc1 becomes flang -fc1 (we don't really have flang -fc1 right now).

flang-new is a rather confusing and an enigmatic name. One big benefit of renaming flang (the bash script) sooner rather than later is that flang-new would become flang and the weird name would be gone.

flang/tools/f18/flang

247–258

Good point, updated.

[Meinersbur]

flang/docs/Overview.md

41

I'll update the documentation shortly.

Still working on this?

[Meinersbur]

LGTM

[awarzynski]

flang/docs/Overview.md

41

Are you referring to flang-new -fc1 here? I would like to keep it for now. This document is intended for developers, so I'm hoping that that's fine.

flang (the bash script) would need some extra logic for flang -fc1 to work as expected. We could add it, but would it be worth it? I'd rather limit the script to the required minimum.

[Meinersbur]

flang/docs/Overview.md

41

It just looked like you were planning to add more documentation (that you want me to review). I think that state as it is is fine.

[awarzynski]

flang/docs/Overview.md

41

I got distracted and then forgot about it, sorry. So, I would like to merge this change as is. For extra documentation, please see https://reviews.llvm.org/D107543. We can continue the discussion there.

[kiranchandramohan]

AFAIU there have been no objections to merging this patch either in the review here or in the calls.

With this patch, we will have a dependency on Clang. Removing the dependency requires some large scale refactoring in Clang. As @awarzynski says, at the moment, enabling code generation is more important so we will not immediately pursue refactoring. Removing the dependency on Clang is captured in the ticket below.
https://bugs.llvm.org/show_bug.cgi?id=50185

Future dependencies on Clang can come while implementing OpenMP offloading (https://clang.llvm.org/docs/ClangOffloadBundler.html). We should try to avoid new dependencies by refactoring or if that is not possible only have the dependency when the offloading feature is enabled.

I am accepting this path with a promise to spend some time to help remove the dependency on Clang.

[mehdi_amini]

llvm/CMakeLists.txt

86

A few lines above, we enable MLIR automatically as a dependency of clang instead of erroring out, any reason you didn't just apply the same logic here?

[awarzynski]

llvm/CMakeLists.txt

86

This came up before. LLVM_ENABLE_PROJECTS is a CACHE variable (i.e. user variable), so we shouldn't modify it here. In https://reviews.llvm.org/D101842, @Meinersbur suggested tweaking LLVM_TOOL_*_BUILD instead. See also this comment.

The lack of consistency in how the MLIR and CLang dependencies are treated is not great, but I've not had the bandwidth to fix this. Do you have a preferred approach here? I'm not a CMake expert - suggestions are very welcome! Btw, apologies for the delay, I was AFK for a couple of weeks.

[Meinersbur]

llvm/CMakeLists.txt

86

To reiterate, CACHE variables are considered user-controlled and IMHO should not be modified by the script. Interaction is complicated and the CMake manual warns at several places. What may happen after the initial set(LLVM_ENABLE_PROJECTS CACHE):

• set(LLVM_ENABLE_PROJECTS): Creates a new variable in the current scope that shadows the CACHE variable. When leaving the scope, the CACHE variable becomes visible again. Note that lines 75 and 81 do exactly this.
• set(LLVM_ENABLE_PROJECTS CACHE): Ignored, but may or may not remove any shadowing local scope variable again, such as those set at lines 75 and 81 (see change in CMake 3.21)
• set(LLVM_ENABLE_PROJECTS CACHE FORCE): Overwrites the user-set CACHE variable (probably what you expected to happen), possibly also removing the local scope variable.

Re-setting a cached variable may also cause the cmake configure script to run again at make after the initial run. Now the value of the cached value has the overwritten value from the beginning, which may change script behaviour before it was overwritten.

I suggested to make better use of LLVM_TOOL_*_BUILD instead, whose default value currently is just derived from LLVM_ENABLE_PROJECTS, but could also take dependencies into account.

flang/CMakeLists.txt

 
 # Check for a standalone build and configure as appropriate from
 # there.
 if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
   message("Building Flang as a standalone project.")
   project(Flang)
   set(FLANG_STANDALONE_BUILD ON)
 
-  # For in-tree builds, this variable is inherited from
-  # llvm-project/llvm/CMakeLists.txt. For out-of-tree builds, we need a
-  # separate definition.
-  option(FLANG_BUILD_NEW_DRIVER "Build the flang compiler driver" ON)
-
   set(FLANG_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
   if (NOT MSVC_IDE)
     set(LLVM_ENABLE_ASSERTIONS ${ENABLE_ASSERTIONS}
       CACHE BOOL "Enable assertions")
     # Assertions follow llvm's configuration.
     mark_as_advanced(LLVM_ENABLE_ASSERTIONS)
   endif()
 
   # We need a pre-built/installed version of LLVM.
   find_package(LLVM REQUIRED HINTS "${LLVM_CMAKE_PATH}")
   # 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})
 
-  if(FLANG_BUILD_NEW_DRIVER)
-    # Users might specify a path to CLANG_DIR that's:
-    #   * a full path, or
-    #   * a path relative to the path of this script.
-    # Append the absolute path to CLANG_DIR so that find_package works in both
-    # cases.
-    get_filename_component(
-      CLANG_DIR_ABSOLUTE
-      ${CLANG_DIR}
-      REALPATH
-      ${CMAKE_CURRENT_SOURCE_DIR})
-    list(APPEND CMAKE_MODULE_PATH ${CLANG_DIR_ABSOLUTE})
 
-    # TODO: Remove when libclangDriver is lifted out of Clang
-    find_package(Clang REQUIRED PATHS "${CLANG_DIR_ABSOLUTE}" NO_DEFAULT_PATH)
-    if (NOT Clang_FOUND)
-      message(FATAL_ERROR "Failed to find Clang")
-    endif()
-  endif()
 
   # If LLVM links to zlib we need the imported targets so we can too.
   if(LLVM_ENABLE_ZLIB)
     find_package(ZLIB REQUIRED)
   endif()
   option(LLVM_ENABLE_PEDANTIC "Compile with pedantic enabled." ON)
   if(CMAKE_COMPILER_IS_GNUCXX)
     set(USE_NO_MAYBE_UNINITIALIZED 1)
   endif()
 
   include(CMakeParseArguments)
   include(AddLLVM)
   include(HandleLLVMOptions)
   include(VersionFromVCS)
 
-  if(FLANG_BUILD_NEW_DRIVER)
-    include(AddClang)
-  endif()
 
   include(TableGen)
   find_package(MLIR REQUIRED CONFIG)
   # Use SYSTEM for the same reasons as for LLVM includes
   include_directories(SYSTEM ${MLIR_INCLUDE_DIRS})
   # If the user specifies a relative path to MLIR_DIR, the calls to include
   # MLIR modules fail. Append the absolute path to MLIR_DIR instead.
   get_filename_component(MLIR_DIR_ABSOLUTE ${MLIR_DIR} REALPATH)
else()
   set(MLIR_TABLEGEN_OUTPUT_DIR ${CMAKE_BINARY_DIR}/tools/mlir/include)
   set(MLIR_TABLEGEN_EXE $<TARGET_FILE:mlir-tblgen>)
   include_directories(SYSTEM ${MLIR_INCLUDE_DIR})
   include_directories(SYSTEM ${MLIR_TABLEGEN_OUTPUT_DIR})
 endif()
 set(FLANG_INTRINSIC_MODULES_DIR ${CMAKE_BINARY_DIR}/include/flang)
 set(FLANG_INCLUDE_DIR ${FLANG_BINARY_DIR}/include)
 
-if(FLANG_BUILD_NEW_DRIVER)
-    # TODO: Remove when libclangDriver is lifted out of Clang
-    if(FLANG_STANDALONE_BUILD)
-      set(CLANG_INCLUDE_DIR ${CLANG_INCLUDE_DIRS} )
-      # No need to specify TableGen output dir as that's embedded in CLANG_DIR
-    else()
-      set(CLANG_INCLUDE_DIR ${LLVM_MAIN_SRC_DIR}/../clang/include )
-      # Specify TableGen output dir for things like DiagnosticCommonKinds.inc,
-      # DiagnosticDriverKinds.inc (required for reporting diagnostics)
-      set(CLANG_TABLEGEN_OUTPUT_DIR ${CMAKE_BINARY_DIR}/tools/clang/include)
-      include_directories(SYSTEM ${CLANG_TABLEGEN_OUTPUT_DIR})
-    endif()
-    include_directories(SYSTEM ${CLANG_INCLUDE_DIR})
-endif()
 
 # tco tool and FIR lib output directories
 if(FLANG_STANDALONE_BUILD)
   set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/bin)
   set(LLVM_LIBRARY_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/lib)
 endif()
 # Always build tco tool
 set(LLVM_BUILD_TOOLS ON)

flang/docs/ImplementingASemanticCheck.md

 <!--===- docs/ImplementingASemanticCheck.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
   
 -->
 # How to implement a Sematic Check in Flang
 
 ```eval_rst
 .. contents::
    :local:
 ```
 
-I recently added a semantic check to the f18 compiler front end.  This document
+I recently added a semantic check to the Flang compiler front end.  This document
 describes my thought process and the resulting implementation.
 
 For more information about the compiler, start with the 
 [compiler overview](Overview.md).
 
 ## Problem definition
 
 In the 2018 Fortran standard, section 11.1.7.4.3, paragraph 2, states that:

 
 ```fortran
       jvar = intentOutFunc(ivar) ! Error since ivar is a DO variable
 ```
 
 
 I also used this program to produce a parse tree for the program using the command:
 ```bash
-  f18 -fdebug-dump-parse-tree -fsyntax-only testfun.f90
+  flang-new -fc1 -fdebug-dump-parse-tree testfun.f90
 ```
 
 Here's the relevant fragment of the parse tree produced by the compiler:
 
 ```
 | | ExecutionPartConstruct -> ExecutableConstruct -> DoConstruct
 | | | NonLabelDoStmt
 | | | | LoopControl -> LoopBounds
```C++
   void DoChecker::Leave(const parser::Expr &) {
     std::cout << "In Leave for parser::Expr\n";
   }
 ```
 
 I then built the compiler with these changes and ran it on my test program.
 This time, I made sure to invoke semantic checking.  Here's the command I used:
 ```bash
-  f18 -fdebug-resolve-names -fdebug-dump-parse-tree -funparse-with-symbols testfun.f90
+  flang-new -fc1 -fdebug-unparse-with-symbols testfun.f90
 ```
 
 This produced the output:
 
 ```
   In Leave for parser::Expr
   In Leave for parser::Expr
   In Leave for parser::Expr
if (const auto *expr{GetExpr(parsedExpr)}) {
       for (const Symbol &symbol : evaluate::CollectSymbols(*expr)) {
 ```
 
 I noted that a `SymbolSet` did not actually contain an
 `std::set<Symbol>`.  This wasn't surprising since we don't want to put the
 full `semantics::Symbol` objects into the set.  Ideally, we would be able to create an
 `std::set<Symbol &>` (a set of C++ references to symbols).  But C++ doesn't
 support sets that contain references.  This limitation is part of the rationale
-for the f18 implementation of type `common::Reference`, which is defined in
+for the Flang implementation of type `common::Reference`, which is defined in
   `include/flang/Common/reference.h`.
 
 `SymbolRef`, the specialization of the template `common::Reference` for
 `semantics::Symbol`, is declared in the file
 `include/flang/Semantics/symbol.h`:
 
 ```C++
   using SymbolRef = common::Reference<const Symbol>;

flang/docs/Overview.md

 <!--===- docs/Overview.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
   
 -->
 
+# Intro
+This document goes briefly over compiler phases in Flang. It focuses on the
+internal implementation and as such, it is intended for Flang developers rather
+than end-users.
+
 # Overview of Compiler Phases
 
 ```eval_rst
 .. contents::
    :local:
 ```
 
 Each phase produces either correct output or fatal errors.
- A "cooked" character stream: the entire program as a contiguous stream of
   normalized Fortran source.
   Extraneous whitespace and comments are removed (except comments that are
   compiler directives that are not disabled) and case is normalized.
 - Provenance information mapping each character back to the source it came from.
   This is used in subsequent phases to issue errors messages that refer to source locations.
 
 **Entry point:** `parser::Parsing::Prescan`
 
-**Command:** `f18 -E src.f90` dumps the cooked character stream
+**Command:** `flang-new -fc1 -E src.f90` dumps the cooked character stream
 
 ## Parse
 
 **Input:** Cooked character stream.
 
 **Output:** A parse tree representing a syntactically correct program,
   rooted at a `parser::Program`.
   See: [Parsing.md](Parsing.md) and [ParserCombinators.md](ParserCombinators.md).
 
 **Entry point:** `parser::Parsing::Parse`
 
 **Command:**
-  - `f18 -fdebug-dump-parse-tree -fsyntax-only src.f90` dumps the parse tree
-  - `f18 -funparse src.f90` converts the parse tree to normalized Fortran
+  - `flang-new -fc1 -fdebug-dump-parse-tree src.f90` dumps the parse tree
+  - `flang-new -fc1 -fdebug-unparse src.f90` converts the parse tree to normalized Fortran
 
 ## Validate Labels and Canonicalize Do Statements
 
 **Input:** Parse tree.
 
 **Output:** The parse tree with label constraints and construct names checked,
   and each `LabelDoStmt` converted to a `NonLabelDoStmt`.
   See: [LabelResolution.md](LabelResolution.md).

 - Parse tree with some refinements:
   - each `parser::Name::symbol` field points to one of the symbols
   - each `parser::TypeSpec::declTypeSpec` field points to one of the types
   - array element references that were parsed as function references or
     statement functions are corrected
 
 **Entry points:** `semantics::ResolveNames`, `semantics::RewriteParseTree`
 
-**Command:** `f18 -fdebug-dump-symbols -fsyntax-only src.f90` dumps the
+**Command:** `flang-new -fc1 -fdebug-dump-symbols src.f90` dumps the
   tree of scopes and symbols in each scope
 
 ## Check DO CONCURRENT Constraints
 
 **Input:** Parse tree with names resolved.
 
 **Output:** Parse tree with semantically correct DO CONCURRENT loops.
 

flang/include/flang/Frontend/CompilerInvocation.h

public:
   void SetDebugModuleDir(bool flag) { debugModuleDir_ = flag; }
 
   void SetWarnAsErr(bool flag) { warnAsErr_ = flag; }
 
   void SetUseAnalyzedObjectsForUnparse(bool flag) {
     useAnalyzedObjectsForUnparse_ = flag;
   }
 
-  /// Set the Fortran options to predifined defaults. These defaults are
-  /// consistend with f18/f18.cpp.
+  /// Set the Fortran options to predefined defaults.
   // TODO: We should map frontendOpts_ to parserOpts_ instead. For that, we
   // need to extend frontendOpts_ first. Next, we need to add the corresponding
   // compiler driver options in libclangDriver.
   void SetDefaultFortranOpts();
 
   /// Set the default predefinitions.
   void setDefaultPredefinitions();
 

flang/include/flang/Frontend/FrontendOptions.h

enum ActionKind {
   /// TODO: RunPreprocessor, EmitLLVM, EmitLLVMOnly,
   /// EmitCodeGenOnly, EmitAssembly, (...)
 };
 
 /// \param suffix The file extension
 /// \return True if the file extension should be processed as fixed form
 bool isFixedFormSuffix(llvm::StringRef suffix);
 
-// TODO: Find a more suitable location for this. Added for compability with
-// f18.cpp (this is equivalent to `asFortran` defined there).
-Fortran::parser::AnalyzedObjectsAsFortran getBasicAsFortran();
-
 /// \param suffix The file extension
 /// \return True if the file extension should be processed as free form
 bool isFreeFormSuffix(llvm::StringRef suffix);
 
 /// \param suffix The file extension
 /// \return True if the file should be preprocessed
 bool mustBePreprocessed(llvm::StringRef suffix);
 

flang/lib/CMakeLists.txt

 add_subdirectory(Common)
 add_subdirectory(Evaluate)
 add_subdirectory(Decimal)
 add_subdirectory(Lower)
 add_subdirectory(Parser)
 add_subdirectory(Semantics)
-
-if(FLANG_BUILD_NEW_DRIVER)
-  add_subdirectory(Frontend)
-  add_subdirectory(FrontendTool)
-endif()
 
 add_subdirectory(Optimizer)

flang/lib/Frontend/CompilerInvocation.cpp

for (unsigned i = 0, n = ppOpts.macros.size(); i != n; ++i) {
     parserOpts_.predefinitions.emplace_back(
         macroName, std::optional<std::string>(macroBody.str()));
   }
 }
 
 void CompilerInvocation::SetDefaultFortranOpts() {
   auto &fortranOptions = fortranOpts();
 
-  // These defaults are based on the defaults in f18/f18.cpp.
   std::vector<std::string> searchDirectories{"."s};
   fortranOptions.searchDirectories = searchDirectories;
   fortranOptions.isFixedForm = false;
 }
 
 // TODO: When expanding this method, consider creating a dedicated API for
 // this. Also at some point we will need to differentiate between different
 // targets and add dedicated predefines for each.

flang/test/CMakeLists.txt

configure_lit_site_cfg(
   MAIN_CONFIG
   ${CMAKE_CURRENT_SOURCE_DIR}/NonGtestUnit/lit.cfg.py
 )
 
 set(FLANG_TEST_PARAMS
   flang_site_config=${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg.py)
 
 set(FLANG_TEST_DEPENDS
-  f18 FileCheck count not module_files fir-opt tco
+  flang-new FileCheck count not module_files fir-opt tco
 )
 
-if (FLANG_BUILD_NEW_DRIVER)
-  list(APPEND FLANG_TEST_DEPENDS flang-new)
-endif()
-
 if (FLANG_INCLUDE_TESTS)
   if (FLANG_GTEST_AVAIL)
     list(APPEND FLANG_TEST_DEPENDS FlangUnitTests)
   endif()
 endif()
 
 add_custom_target(flang-test-depends DEPENDS ${FLANG_TEST_DEPENDS})
 

flang/test/Driver/help-f18.f90

-! REQUIRES: old-flang-driver
-
-! RUN: %flang -h 2>&1 | FileCheck %s
-! RUN: %flang -help 2>&1 | FileCheck %s
-! RUN: %flang --help 2>&1 | FileCheck %s
-! RUN: %flang -? 2>&1 | FileCheck %s
-
-! CHECK: f18: LLVM Fortran compiler
-
-! CHECK:   -help                print this again
-! CHECK: Unrecognised options are passed through to the external compiler
-! CHECK: set by F18_FC (see defaults).

flang/test/lit.cfg.py

 
 # 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 new Flang driver is enabled, add the corresponding feature to
 # config.
-if config.include_flang_new_driver_test:
-  config.available_features.add('new-flang-driver')
-else:
-  config.available_features.add('old-flang-driver')
 
 # 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')
 
 # 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)
 
 # For each occurrence of a flang tool name, replace it with the full path to
 # the build directory holding that tool.
-tools = []
-if config.include_flang_new_driver_test:
-   tools.append(ToolSubst('%flang', command=FindTool('flang-new'), unresolved='fatal'))
-   tools.append(ToolSubst('%flang_fc1', command=FindTool('flang-new'),
-    extra_args=['-fc1'], unresolved='fatal'))
-else:
-   tools.append(ToolSubst('%flang', command=FindTool('f18'),
-    unresolved='fatal'))
-   tools.append(ToolSubst('%flang_fc1', command=FindTool('f18'),
-    unresolved='fatal'))
+tools = [
+        ToolSubst('%flang', command=FindTool('flang-new'), unresolved='fatal'),
+    ToolSubst('%flang_fc1', command=FindTool('flang-new'), extra_args=['-fc1'],
+        unresolved='fatal')]
 
 # Define some variables to help us test that the flang runtime doesn't depend on
 # the C++ runtime libraries. For this we need a C compiler. If for some reason
 # we don't have one, we can just disable the test.
 if config.cc:
     libruntime = os.path.join(config.flang_lib_dir, 'libFortranRuntime.a')
     includes = os.path.join(config.flang_src_dir, 'runtime')
 

flang/test/lit.site.cfg.py.in

 @LIT_SITE_CFG_IN_HEADER@
 
 import sys
 
 config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
 config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@"
 config.flang_obj_root = "@FLANG_BINARY_DIR@"
 config.flang_src_dir = "@FLANG_SOURCE_DIR@"
 config.flang_tools_dir = "@FLANG_TOOLS_DIR@"
 config.flang_intrinsic_modules_dir = "@FLANG_INTRINSIC_MODULES_DIR@"
 config.flang_llvm_tools_dir = "@CMAKE_BINARY_DIR@/bin"
 config.flang_lib_dir = "@CMAKE_BINARY_DIR@/lib"
 config.python_executable = "@PYTHON_EXECUTABLE@"
 config.flang_standalone_build = @FLANG_STANDALONE_BUILD@
 config.cc = "@CMAKE_C_COMPILER@"
 
-# Control the regression test for flang-new driver
-import lit.util
-config.include_flang_new_driver_test = \
-    lit.util.pythonize_bool("@FLANG_BUILD_NEW_DRIVER@")
-
 # Support substitution of the tools_dir with user parameters. This is
 # used when we can't determine the tool dir at configuration time.
 try:
     config.llvm_tools_dir = config.llvm_tools_dir % lit_config.params
     config.flang_tools_dir = config.flang_tools_dir % lit_config.params
 except KeyError:
     e = sys.exc_info()[1]
     key, = e.args
     lit_config.fatal("unable to find %r parameter, use '--param=%s=VALUE'" % (key,key))
 
 import lit.llvm
 lit.llvm.initialize(lit_config, config)
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@FLANG_SOURCE_DIR@/test/lit.cfg.py")

flang/tools/CMakeLists.txt

 #===-- tools/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
 #
 #===------------------------------------------------------------------------===#
 
 add_subdirectory(f18)
-if(FLANG_BUILD_NEW_DRIVER)
-  add_subdirectory(flang-driver)
-endif()
 add_subdirectory(tco)
 add_subdirectory(f18-parse-demo)
 add_subdirectory(fir-opt)

flang/tools/f18/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   FrontendOpenACC
   FrontendOpenMP
   Support
   )
-add_flang_tool(f18
-  dump.cpp
-  f18.cpp
-  )
-
-target_link_libraries(f18
-  PRIVATE
-  FortranCommon
-  FortranParser
-  FortranEvaluate
-  FortranSemantics
-  FortranLower
-)
 
 set(MODULES
   "__fortran_builtins"
   "__fortran_type_info"
   "ieee_arithmetic"
   "ieee_exceptions"
   "ieee_features"
   "iso_c_binding"
   "iso_fortran_env"
   "omp_lib"
   "__fortran_builtins"
   "__fortran_type_info"
 )
 
-target_include_directories(f18
-  PRIVATE
-  ${CMAKE_CURRENT_BINARY_DIR}
-)
-
 # Create module files directly from the top-level module source directory
 foreach(filename ${MODULES})
   set(base ${FLANG_INTRINSIC_MODULES_DIR}/${filename})
   if(${filename} MATCHES "__fortran_type_info")
     set(depends "")
   elseif(${filename} MATCHES "__fortran_builtins")
     set(depends ${FLANG_INTRINSIC_MODULES_DIR}/__fortran_type_info.mod)
   else()
     set(depends ${FLANG_INTRINSIC_MODULES_DIR}/__fortran_builtins.mod)
   endif()
   add_custom_command(OUTPUT ${base}.mod
     COMMAND ${CMAKE_COMMAND} -E make_directory ${FLANG_INTRINSIC_MODULES_DIR}
-    COMMAND f18 -fsyntax-only -module-dir ${FLANG_INTRINSIC_MODULES_DIR}
+    COMMAND flang-new -fc1 -fsyntax-only -module-dir ${FLANG_INTRINSIC_MODULES_DIR}
       ${FLANG_SOURCE_DIR}/module/${filename}.f90
-    DEPENDS f18 ${FLANG_SOURCE_DIR}/module/${filename}.f90 ${depends}
+    DEPENDS flang-new ${FLANG_SOURCE_DIR}/module/${filename}.f90 ${depends}
   )
   add_custom_command(OUTPUT ${base}.f18.mod
     DEPENDS ${base}.mod
     COMMAND ${CMAKE_COMMAND} -E copy ${base}.mod ${base}.f18.mod)
   list(APPEND MODULE_FILES ${base}.mod ${base}.f18.mod)
   install(FILES ${base}.mod ${base}.f18.mod DESTINATION include/flang)
 endforeach()
 
 add_custom_target(module_files ALL DEPENDS ${MODULE_FILES})
 
-install(TARGETS f18 DESTINATION bin)
-
-set(FLANG_DEFAULT_DRIVER "flang-new")
-if (NOT FLANG_BUILD_NEW_DRIVER)
-  set(FLANG_DEFAULT_DRIVER "f18")
-endif()
-
 # This flang shell script will only work in a POSIX shell.
 if (NOT WIN32)
-  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/flang.in ${CMAKE_BINARY_DIR}/bin/flang @ONLY)
+  file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/flang
+    DESTINATION ${CMAKE_BINARY_DIR}/bin
+    FILE_PERMISSIONS OWNER_EXECUTE OWNER_READ OWNER_WRITE)
   install(PROGRAMS ${CMAKE_BINARY_DIR}/bin/flang DESTINATION bin)
 endif()

flang/tools/f18/f18.cpp

-//===-- tools/f18/f18.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
-//
-//===----------------------------------------------------------------------===//
-
-// Temporary Fortran front end driver main program for development scaffolding.
-
-#include "flang/Common/Fortran-features.h"
-#include "flang/Common/default-kinds.h"
-#include "flang/Evaluate/expression.h"
-#include "flang/Lower/PFTBuilder.h"
-#include "flang/Parser/characters.h"
-#include "flang/Parser/dump-parse-tree.h"
-#include "flang/Parser/message.h"
-#include "flang/Parser/parse-tree-visitor.h"
-#include "flang/Parser/parse-tree.h"
-#include "flang/Parser/parsing.h"
-#include "flang/Parser/provenance.h"
-#include "flang/Parser/unparse.h"
-#include "flang/Semantics/expression.h"
-#include "flang/Semantics/runtime-type-info.h"
-#include "flang/Semantics/semantics.h"
-#include "flang/Semantics/unparse-with-symbols.h"
-#include "flang/Version.inc"
-#include "llvm/Support/Errno.h"
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/FileUtilities.h"
-#include "llvm/Support/Program.h"
-#include "llvm/Support/Signals.h"
-#include "llvm/Support/raw_ostream.h"
-#include <cstdio>
-#include <cstring>
-#include <fstream>
-#include <list>
-#include <memory>
-#include <optional>
-#include <stdlib.h>
-#include <string>
-#include <vector>
-
-static std::list<std::string> argList(int argc, char *const argv[]) {
-  std::list<std::string> result;
-  for (int j = 0; j < argc; ++j) {
-    result.emplace_back(argv[j]);
-  }
-  return result;
-}
-
-struct MeasurementVisitor {
-  template <typename A> bool Pre(const A &) { return true; }
-  template <typename A> void Post(const A &) {
-    ++objects;
-    bytes += sizeof(A);
-  }
-  size_t objects{0}, bytes{0};
-};
-
-void MeasureParseTree(const Fortran::parser::Program &program) {
-  MeasurementVisitor visitor;
-  Fortran::parser::Walk(program, visitor);
-  llvm::outs() << "Parse tree comprises " << visitor.objects
-               << " objects and occupies " << visitor.bytes
-               << " total bytes.\n";
-}
-
-std::vector<std::string> filesToDelete;
-
-void CleanUpAtExit() {
-  for (const auto &path : filesToDelete) {
-    if (!path.empty()) {
-      llvm::sys::fs::remove(path);
-    }
-  }
-}
-
-struct GetDefinitionArgs {
-  int line, startColumn, endColumn;
-};
-
-struct DriverOptions {
-  DriverOptions() {}
-  bool verbose{false}; // -v
-  bool compileOnly{false}; // -c
-  std::string outputPath; // -o path
-  std::vector<std::string> searchDirectories; // -I dir
-  std::string moduleDirectory{"."s}; // -module dir
-  std::string moduleFileSuffix{".mod"}; // -moduleSuffix suff
-  bool forcedForm{false}; // -Mfixed or -Mfree appeared
-  bool warnOnNonstandardUsage{false}; // -Mstandard
-  bool warningsAreErrors{false}; // -Werror
-  bool byteswapio{false}; // -byteswapio
-  Fortran::parser::Encoding encoding{Fortran::parser::Encoding::UTF_8};
-  bool lineDirectives{true}; // -P disables
-  bool syntaxOnly{false};
-  bool dumpProvenance{false};
-  bool noReformat{false}; // -E -fno-reformat
-  bool dumpUnparse{false};
-  bool dumpUnparseWithSymbols{false};
-  bool dumpParseTree{false};
-  bool dumpPreFirTree{false};
-  bool dumpSymbols{false};
-  bool debugNoSemantics{false};
-  bool debugModuleWriter{false};
-  bool defaultReal8{false};
-  bool measureTree{false};
-  bool useAnalyzedObjectsForUnparse{true};
-  std::vector<std::string> F18_FCArgs;
-  const char *prefix{nullptr};
-  bool getDefinition{false};
-  GetDefinitionArgs getDefinitionArgs{0, 0, 0};
-  bool getSymbolsSources{false};
-  std::optional<bool> forcePreprocessing; // -cpp & -nocpp
-};
-
-void Exec(std::vector<llvm::StringRef> &argv, bool verbose = false) {
-  if (verbose) {
-    for (size_t j{0}; j < argv.size(); ++j) {
-      llvm::errs() << (j > 0 ? " " : "") << argv[j];
-    }
-    llvm::errs() << '\n';
-  }
-  std::string ErrMsg;
-  llvm::ErrorOr<std::string> Program = llvm::sys::findProgramByName(argv[0]);
-  if (!Program)
-    ErrMsg = Program.getError().message();
-  if (!Program ||
-      llvm::sys::ExecuteAndWait(
-          Program.get(), argv, llvm::None, {}, 0, 0, &ErrMsg)) {
-    llvm::errs() << "execvp(" << argv[0] << ") failed: " << ErrMsg << '\n';
-    exit(EXIT_FAILURE);
-  }
-}
-
-void RunOtherCompiler(DriverOptions &driver, char *source, char *relo) {
-  std::vector<llvm::StringRef> argv;
-  for (size_t j{0}; j < driver.F18_FCArgs.size(); ++j) {
-    argv.push_back(driver.F18_FCArgs[j]);
-  }
-  char dashC[3] = "-c", dashO[3] = "-o";
-  argv.push_back(dashC);
-  argv.push_back(dashO);
-  argv.push_back(relo);
-  argv.push_back(source);
-  Exec(argv, driver.verbose);
-}
-
-std::string RelocatableName(const DriverOptions &driver, std::string path) {
-  if (driver.compileOnly && !driver.outputPath.empty()) {
-    return driver.outputPath;
-  }
-  std::string base{path};
-  auto slash{base.rfind("/")};
-  if (slash != std::string::npos) {
-    base = base.substr(slash + 1);
-  }
-  std::string relo{base};
-  auto dot{base.rfind(".")};
-  if (dot != std::string::npos) {
-    relo = base.substr(0, dot);
-  }
-  relo += ".o";
-  return relo;
-}
-
-int exitStatus{EXIT_SUCCESS};
-
-static Fortran::parser::AnalyzedObjectsAsFortran asFortran{
-    [](llvm::raw_ostream &o, const Fortran::evaluate::GenericExprWrapper &x) {
-      if (x.v) {
-        x.v->AsFortran(o);
-      } else {
-        o << "(bad expression)";
-      }
-    },
-    [](llvm::raw_ostream &o,
-        const Fortran::evaluate::GenericAssignmentWrapper &x) {
-      if (x.v) {
-        x.v->AsFortran(o);
-      } else {
-        o << "(bad assignment)";
-      }
-    },
-    [](llvm::raw_ostream &o, const Fortran::evaluate::ProcedureRef &x) {
-      x.AsFortran(o << "CALL ");
-    },
-};
-
-std::string CompileFortran(std::string path, Fortran::parser::Options options,
-    DriverOptions &driver,
-    const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds) {
-  Fortran::parser::AllSources allSources;
-  Fortran::parser::AllCookedSources allCookedSources{allSources};
-  allSources.set_encoding(driver.encoding);
-  Fortran::semantics::SemanticsContext semanticsContext{
-      defaultKinds, options.features, allCookedSources};
-  semanticsContext.set_moduleDirectory(driver.moduleDirectory)
-      .set_moduleFileSuffix(driver.moduleFileSuffix)
-      .set_searchDirectories(driver.searchDirectories)
-      .set_warnOnNonstandardUsage(driver.warnOnNonstandardUsage)
-      .set_warningsAreErrors(driver.warningsAreErrors);
-  if (!driver.forcedForm) {
-    auto dot{path.rfind(".")};
-    if (dot != std::string::npos) {
-      std::string suffix{path.substr(dot + 1)};
-      options.isFixedForm = suffix == "f" || suffix == "F" || suffix == "ff";
-    }
-  }
-  options.searchDirectories = driver.searchDirectories;
-  Fortran::parser::Parsing parsing{allCookedSources};
-  parsing.Prescan(path, options);
-  if (!parsing.messages().empty() &&
-      (driver.warningsAreErrors || parsing.messages().AnyFatalError())) {
-    llvm::errs() << driver.prefix << "Could not scan " << path << '\n';
-    parsing.messages().Emit(llvm::errs(), allCookedSources);
-    exitStatus = EXIT_FAILURE;
-    return {};
-  }
-  if (driver.dumpProvenance) {
-    parsing.DumpProvenance(llvm::outs());
-    return {};
-  }
-  if (options.prescanAndReformat) {
-    parsing.messages().Emit(llvm::errs(), allCookedSources);
-    if (driver.noReformat) {
-      parsing.DumpCookedChars(llvm::outs());
-    } else {
-      parsing.EmitPreprocessedSource(llvm::outs(), driver.lineDirectives);
-    }
-    return {};
-  }
-  parsing.Parse(llvm::outs());
-  if (options.instrumentedParse) {
-    parsing.DumpParsingLog(llvm::outs());
-    return {};
-  }
-  parsing.ClearLog();
-  parsing.messages().Emit(llvm::errs(), allCookedSources);
-  if (!parsing.consumedWholeFile()) {
-    parsing.EmitMessage(llvm::errs(), parsing.finalRestingPlace(),
-        "Parser FAIL (final position)");
-    exitStatus = EXIT_FAILURE;
-    return {};
-  }
-  if ((!parsing.messages().empty() &&
-          (driver.warningsAreErrors || parsing.messages().AnyFatalError())) ||
-      !parsing.parseTree()) {
-    llvm::errs() << driver.prefix << "Could not parse " << path << '\n';
-    exitStatus = EXIT_FAILURE;
-    return {};
-  }
-  auto &parseTree{*parsing.parseTree()};
-  if (driver.measureTree) {
-    MeasureParseTree(parseTree);
-  }
-  if (!driver.debugNoSemantics || driver.dumpSymbols ||
-      driver.dumpUnparseWithSymbols || driver.getDefinition ||
-      driver.getSymbolsSources) {
-    Fortran::semantics::Semantics semantics{
-        semanticsContext, parseTree, driver.debugModuleWriter};
-    semantics.Perform();
-    Fortran::semantics::RuntimeDerivedTypeTables tables;
-    if (!semantics.AnyFatalError()) {
-      tables =
-          Fortran::semantics::BuildRuntimeDerivedTypeTables(semanticsContext);
-      if (!tables.schemata) {
-        llvm::errs() << driver.prefix
-                     << "could not find module file for __fortran_type_info\n";
-      }
-    }
-    semantics.EmitMessages(llvm::errs());
-    if (semantics.AnyFatalError()) {
-      if (driver.dumpSymbols) {
-        semantics.DumpSymbols(llvm::outs());
-      }
-      llvm::errs() << driver.prefix << "Semantic errors in " << path << '\n';
-      exitStatus = EXIT_FAILURE;
-      if (driver.dumpParseTree) {
-        Fortran::parser::DumpTree(llvm::outs(), parseTree, &asFortran);
-      }
-      return {};
-    }
-    if (driver.dumpSymbols) {
-      semantics.DumpSymbols(llvm::outs());
-    }
-    if (driver.dumpUnparseWithSymbols) {
-      Fortran::semantics::UnparseWithSymbols(
-          llvm::outs(), parseTree, driver.encoding);
-      return {};
-    }
-    if (driver.getSymbolsSources) {
-      semantics.DumpSymbolsSources(llvm::outs());
-      return {};
-    }
-    if (driver.getDefinition) {
-      if (auto cb{allCookedSources.GetCharBlockFromLineAndColumns(
-              driver.getDefinitionArgs.line,
-              driver.getDefinitionArgs.startColumn,
-              driver.getDefinitionArgs.endColumn)}) {
-        llvm::errs() << "String range: >" << cb->ToString() << "<\n";
-        if (auto symbol{semanticsContext.FindScope(*cb).FindSymbol(*cb)}) {
-          llvm::errs() << "Found symbol name: " << symbol->name().ToString()
-                       << "\n";
-          if (auto sourceInfo{
-                  allCookedSources.GetSourcePositionRange(symbol->name())}) {
-            llvm::outs() << symbol->name().ToString() << ": "
-                         << sourceInfo->first.file.path() << ", "
-                         << sourceInfo->first.line << ", "
-                         << sourceInfo->first.column << "-"
-                         << sourceInfo->second.column << "\n";
-            exitStatus = EXIT_SUCCESS;
-            return {};
-          }
-        }
-      }
-      llvm::errs() << "Symbol not found.\n";
-      exitStatus = EXIT_FAILURE;
-      return {};
-    }
-  }
-  if (driver.dumpParseTree) {
-    Fortran::parser::DumpTree(llvm::outs(), parseTree, &asFortran);
-  }
-  if (driver.dumpUnparse) {
-    // Prepare the output stream
-    std::unique_ptr<llvm::raw_fd_ostream> os;
-    std::string outputFile = "-";
-    if (!driver.outputPath.empty()) {
-      outputFile = driver.outputPath;
-    }
-
-    std::error_code EC;
-    os.reset(new llvm::raw_fd_ostream(
-        outputFile, EC, llvm::sys::fs::OF_TextWithCRLF));
-    if (EC) {
-      llvm::errs() << EC.message() << "\n";
-      std::exit(EXIT_FAILURE);
-    }
-
-    Unparse(*os, parseTree, driver.encoding, true /*capitalize*/,
-        options.features.IsEnabled(
-            Fortran::common::LanguageFeature::BackslashEscapes),
-        nullptr /* action before each statement */,
-        driver.useAnalyzedObjectsForUnparse ? &asFortran : nullptr);
-    return {};
-  }
-  if (driver.dumpPreFirTree) {
-    if (auto ast{Fortran::lower::createPFT(parseTree, semanticsContext)}) {
-      Fortran::lower::dumpPFT(llvm::outs(), *ast);
-    } else {
-      llvm::errs() << "Pre FIR Tree is NULL.\n";
-      exitStatus = EXIT_FAILURE;
-    }
-  }
-  if (driver.syntaxOnly) {
-    return {};
-  }
-
-  std::string relo{RelocatableName(driver, path)};
-
-  llvm::SmallString<32> tmpSourcePath;
-  {
-    int fd;
-    std::error_code EC =
-        llvm::sys::fs::createUniqueFile("f18-%%%%.f90", fd, tmpSourcePath);
-    if (EC) {
-      llvm::errs() << EC.message() << "\n";
-      std::exit(EXIT_FAILURE);
-    }
-    llvm::raw_fd_ostream tmpSource(fd, /*shouldClose*/ true);
-    Unparse(tmpSource, parseTree, driver.encoding, true /*capitalize*/,
-        options.features.IsEnabled(
-            Fortran::common::LanguageFeature::BackslashEscapes),
-        nullptr /* action before each statement */,
-        driver.useAnalyzedObjectsForUnparse ? &asFortran : nullptr);
-  }
-
-  RunOtherCompiler(driver, tmpSourcePath.data(), relo.data());
-  filesToDelete.emplace_back(tmpSourcePath);
-  if (!driver.compileOnly && driver.outputPath.empty()) {
-    filesToDelete.push_back(relo);
-  }
-  return relo;
-}
-
-std::string CompileOtherLanguage(std::string path, DriverOptions &driver) {
-  std::string relo{RelocatableName(driver, path)};
-  RunOtherCompiler(driver, path.data(), relo.data());
-  if (!driver.compileOnly && driver.outputPath.empty()) {
-    filesToDelete.push_back(relo);
-  }
-  return relo;
-}
-
-void Link(std::vector<std::string> &liblist, std::vector<std::string> &objects,
-    DriverOptions &driver) {
-  std::vector<llvm::StringRef> argv;
-  for (size_t j{0}; j < driver.F18_FCArgs.size(); ++j) {
-    argv.push_back(driver.F18_FCArgs[j].data());
-  }
-  for (auto &obj : objects) {
-    argv.push_back(obj.data());
-  }
-  if (!driver.outputPath.empty()) {
-    char dashO[3] = "-o";
-    argv.push_back(dashO);
-    argv.push_back(driver.outputPath.data());
-  }
-  for (auto &lib : liblist) {
-    argv.push_back(lib.data());
-  }
-  Exec(argv, driver.verbose);
-}
-
-int printVersion() {
-  llvm::errs() << "\nf18 compiler (under development), version "
-               << FLANG_VERSION_STRING << "\n";
-  return exitStatus;
-}
-
-// Generate the path to look for intrinsic modules
-static std::string getIntrinsicDir() {
-  // TODO: Find a system independent API
-  llvm::SmallString<128> driverPath;
-  driverPath.assign(llvm::sys::fs::getMainExecutable(nullptr, nullptr));
-  llvm::sys::path::remove_filename(driverPath);
-  driverPath.append("/../include/flang/");
-  return std::string(driverPath);
-}
-
-int main(int argc, char *const argv[]) {
-
-  atexit(CleanUpAtExit);
-
-  DriverOptions driver;
-  const char *F18_FC{getenv("F18_FC")};
-  driver.F18_FCArgs.push_back(F18_FC ? F18_FC : "gfortran");
-  bool isPGF90{driver.F18_FCArgs.back().rfind("pgf90") != std::string::npos};
-
-  std::list<std::string> args{argList(argc, argv)};
-  std::vector<std::string> objlist, liblist;
-  std::string prefix{args.front()};
-  args.pop_front();
-  prefix += ": ";
-  driver.prefix = prefix.data();
-
-  Fortran::parser::Options options;
-  std::vector<Fortran::parser::Options::Predefinition> predefinitions;
-  predefinitions.emplace_back("__F18", "1");
-  predefinitions.emplace_back("__F18_MAJOR__", "1");
-  predefinitions.emplace_back("__F18_MINOR__", "1");
-  predefinitions.emplace_back("__F18_PATCHLEVEL__", "1");
-  predefinitions.emplace_back("__flang__", FLANG_VERSION_STRING);
-  predefinitions.emplace_back("__flang_major__", FLANG_VERSION_MAJOR_STRING);
-  predefinitions.emplace_back("__flang_minor__", FLANG_VERSION_MINOR_STRING);
-  predefinitions.emplace_back(
-      "__flang_patchlevel__", FLANG_VERSION_PATCHLEVEL_STRING);
-#if __x86_64__
-  predefinitions.emplace_back("__x86_64__", "1");
-#endif
-
-  Fortran::common::IntrinsicTypeDefaultKinds defaultKinds;
-
-  std::vector<std::string> fortranSources, otherSources;
-  bool anyFiles{false};
-
-  // Add the default intrinsic module directory to the list of search
-  // directories
-  driver.searchDirectories.push_back(getIntrinsicDir());
-
-  while (!args.empty()) {
-    std::string arg{std::move(args.front())};
-    auto dot{arg.rfind(".")};
-    std::string suffix{arg.substr(dot + 1)};
-    std::string prefix{arg.substr(0, 2)};
-    args.pop_front();
-    if (arg.empty() || arg == "-Xflang") {
-    } else if (arg.at(0) != '-') {
-      anyFiles = true;
-      if (dot == std::string::npos) {
-        driver.F18_FCArgs.push_back(arg);
-      } else {
-        if (suffix == "f" || suffix == "F" || suffix == "ff" ||
-            suffix == "f90" || suffix == "F90" || suffix == "ff90" ||
-            suffix == "f95" || suffix == "F95" || suffix == "ff95" ||
-            suffix == "cuf" || suffix == "CUF" || suffix == "f18" ||
-            suffix == "F18" || suffix == "ff18") {
-          fortranSources.push_back(arg);
-        } else if (suffix == "o" || suffix == "so") {
-          objlist.push_back(arg);
-        } else if (suffix == "a") {
-          liblist.push_back(arg);
-        } else {
-          otherSources.push_back(arg);
-        }
-      }
-    } else if (prefix == "-l" || suffix == "a") {
-      liblist.push_back(arg);
-    } else if (arg == "-") {
-      fortranSources.push_back("-");
-    } else if (arg == "--") {
-      while (!args.empty()) {
-        fortranSources.emplace_back(std::move(args.front()));
-        args.pop_front();
-      }
-      break;
-    } else if (arg == "-Mfixed" || arg == "-ffixed-form") {
-      driver.forcedForm = true;
-      options.isFixedForm = true;
-    } else if (arg == "-Mfree" || arg == "-ffree-form") {
-      driver.forcedForm = true;
-      options.isFixedForm = false;
-    } else if (arg == "-Mextend" || arg == "-ffixed-line-length-132") {
-      options.fixedFormColumns = 132;
-    } else if (arg == "-Munlimited" || arg == "-ffree-line-length-none" ||
-        arg == "-ffree-line-length-0" || arg == "-ffixed-line-length-none" ||
-        arg == "-ffixed-line-length-0") {
-      // For reparsing f18's -E -fno-reformat output of fixed-form
-      // cooked character stream
-      options.fixedFormColumns = 1000000;
-    } else if (arg == "-Mbackslash") {
-      options.features.Enable(
-          Fortran::common::LanguageFeature::BackslashEscapes, false);
-    } else if (arg == "-Mnobackslash") {
-      options.features.Enable(
-          Fortran::common::LanguageFeature::BackslashEscapes, true);
-    } else if (arg == "-Mstandard" || arg == "-std=f95" ||
-        arg == "-std=f2003" || arg == "-std=f2008" || arg == "-std=legacy" ||
-        arg == "-std=f2018" || arg == "-pedantic") {
-      driver.warnOnNonstandardUsage = true;
-    } else if (arg == "-fopenacc") {
-      options.features.Enable(Fortran::common::LanguageFeature::OpenACC);
-      predefinitions.emplace_back("_OPENACC", "202011");
-    } else if (arg == "-fopenmp") {
-      options.features.Enable(Fortran::common::LanguageFeature::OpenMP);
-      predefinitions.emplace_back("_OPENMP", "201511");
-    } else if (arg.find("-W") != std::string::npos) {
-      if (arg == "-Werror")
-        driver.warningsAreErrors = true;
-    } else if (arg == "-ed") {
-      options.features.Enable(Fortran::common::LanguageFeature::OldDebugLines);
-    } else if (arg == "-E") {
-      options.prescanAndReformat = true;
-    } else if (arg == "-P") {
-      driver.lineDirectives = false;
-    } else if (arg == "-fno-reformat") {
-      driver.noReformat = true;
-    } else if (arg == "-fbackslash" || arg == "-fno-backslash") {
-      options.features.Enable(
-          Fortran::common::LanguageFeature::BackslashEscapes,
-          arg == "-fbackslash");
-    } else if (arg == "-fxor-operator" || arg == "-fno-xor-operator") {
-      options.features.Enable(Fortran::common::LanguageFeature::XOROperator,
-          arg == "-fxor-operator");
-    } else if (arg == "-flogical-abbreviations" ||
-        arg == "-fno-logical-abbreviations") {
-      options.features.Enable(
-          Fortran::parser::LanguageFeature::LogicalAbbreviations,
-          arg == "-flogical-abbreviations");
-    } else if (arg == "-fimplicit-none-type-always" ||
-        arg == "-fimplicit-none") {
-      options.features.Enable(
-          Fortran::common::LanguageFeature::ImplicitNoneTypeAlways);
-    } else if (arg == "-fno-implicit-none") {
-      options.features.Enable(
-          Fortran::common::LanguageFeature::ImplicitNoneTypeAlways, false);
-    } else if (arg == "-fimplicit-none-type-never") {
-      options.features.Enable(
-          Fortran::common::LanguageFeature::ImplicitNoneTypeNever);
-    } else if (arg == "-falternative-parameter-statement") {
-      options.features.Enable(
-          Fortran::common::LanguageFeature::OldStyleParameter, true);
-    } else if (arg == "-fdebug-dump-provenance") {
-      driver.dumpProvenance = true;
-      options.needProvenanceRangeToCharBlockMappings = true;
-    } else if (arg == "-fdebug-dump-parse-tree") {
-      driver.dumpParseTree = true;
-      driver.syntaxOnly = true;
-    } else if (arg == "-fdebug-pre-fir-tree") {
-      driver.dumpPreFirTree = true;
-    } else if (arg == "-fdebug-dump-symbols") {
-      driver.dumpSymbols = true;
-      driver.syntaxOnly = true;
-    } else if (arg == "-fdebug-module-writer") {
-      driver.debugModuleWriter = true;
-    } else if (arg == "-fdebug-measure-parse-tree") {
-      driver.measureTree = true;
-    } else if (arg == "-fdebug-instrumented-parse" ||
-        arg == "-fdebug-dump-parsing-log") {
-      options.instrumentedParse = true;
-    } else if (arg == "-fdebug-no-semantics") {
-      driver.debugNoSemantics = true;
-    } else if (arg == "-fdebug-unparse-no-sema") {
-      driver.debugNoSemantics = true;
-      driver.dumpUnparse = true;
-    } else if (arg == "-fdebug-dump-parse-tree-no-sema") {
-      driver.debugNoSemantics = true;
-      driver.dumpParseTree = true;
-      driver.syntaxOnly = true;
-    } else if (arg == "-funparse" || arg == "-fdebug-unparse") {
-      driver.dumpUnparse = true;
-    } else if (arg == "-funparse-with-symbols" ||
-        arg == "-fdebug-unparse-with-symbols") {
-      driver.dumpUnparseWithSymbols = true;
-    } else if (arg == "-fno-analyzed-objects-for-unparse") {
-      driver.useAnalyzedObjectsForUnparse = false;
-    } else if (arg == "-fparse-only" || arg == "-fsyntax-only") {
-      driver.syntaxOnly = true;
-    } else if (arg == "-c") {
-      driver.compileOnly = true;
-    } else if (arg == "-o") {
-      driver.outputPath = args.front();
-      args.pop_front();
-    } else if (arg.substr(0, 2) == "-D") {
-      auto eq{arg.find('=')};
-      if (eq == std::string::npos) {
-        predefinitions.emplace_back(arg.substr(2), "1");
-      } else {
-        predefinitions.emplace_back(arg.substr(2, eq - 2), arg.substr(eq + 1));
-      }
-    } else if (arg.substr(0, 2) == "-U") {
-      predefinitions.emplace_back(arg.substr(2), std::optional<std::string>{});
-    } else if (arg == "-r8" || arg == "-fdefault-real-8") {
-      driver.defaultReal8 = true;
-      defaultKinds.set_defaultRealKind(8);
-      defaultKinds.set_doublePrecisionKind(16);
-    } else if (arg == "-fdefault-double-8") {
-      if (!driver.defaultReal8) {
-        // -fdefault-double-8 has to be used with -fdefault-real-8
-        // to be compatible with gfortran. See:
-        // https://gcc.gnu.org/onlinedocs/gfortran/Fortran-Dialect-Options.html
-        llvm::errs()
-            << "Use of `-fdefault-double-8` requires `-fdefault-real-8`\n";
-        return EXIT_FAILURE;
-      }
-      defaultKinds.set_doublePrecisionKind(8);
-    } else if (arg == "-i8" || arg == "-fdefault-integer-8") {
-      defaultKinds.set_defaultIntegerKind(8);
-      defaultKinds.set_subscriptIntegerKind(8);
-      defaultKinds.set_sizeIntegerKind(8);
-      if (isPGF90) {
-        driver.F18_FCArgs.push_back("-i8");
-      } else {
-        driver.F18_FCArgs.push_back("-fdefault-integer-8");
-      }
-    } else if (arg == "-flarge-sizes") {
-      defaultKinds.set_sizeIntegerKind(8);
-    } else if (arg == "-fno-large-sizes") {
-      defaultKinds.set_sizeIntegerKind(4);
-    } else if (arg == "-module") {
-      driver.moduleDirectory = args.front();
-      args.pop_front();
-    } else if (arg == "-module-dir") {
-      driver.moduleDirectory = args.front();
-      driver.searchDirectories.push_back(driver.moduleDirectory);
-      args.pop_front();
-    } else if (arg == "-module-suffix") {
-      driver.moduleFileSuffix = args.front();
-      args.pop_front();
-    } else if (arg == "-intrinsic-module-directory" ||
-        arg == "-fintrinsic-modules-path") {
-      // prepend to the list of search directories
-      driver.searchDirectories.insert(
-          driver.searchDirectories.begin(), args.front());
-      args.pop_front();
-    } else if (arg == "-futf-8") {
-      driver.encoding = Fortran::parser::Encoding::UTF_8;
-    } else if (arg == "-flatin") {
-      driver.encoding = Fortran::parser::Encoding::LATIN_1;
-    } else if (arg == "-fget-definition") {
-      // Receives 3 arguments: line, startColumn, endColumn.
-      options.needProvenanceRangeToCharBlockMappings = true;
-      driver.getDefinition = true;
-      char *endptr;
-      int arguments[3];
-      for (int i = 0; i < 3; i++) {
-        if (args.empty()) {
-          llvm::errs() << "Must provide 3 arguments for -fget-definitions.\n";
-          return EXIT_FAILURE;
-        }
-        arguments[i] = std::strtol(args.front().c_str(), &endptr, 10);
-        if (*endptr != '\0') {
-          llvm::errs() << "error: invalid value '" << args.front()
-                       << "' in 'fget-definition'" << '\n';
-          return EXIT_FAILURE;
-        }
-        args.pop_front();
-      }
-      driver.getDefinitionArgs = {arguments[0], arguments[1], arguments[2]};
-    } else if (arg == "-fget-symbols-sources") {
-      driver.getSymbolsSources = true;
-    } else if (arg == "-byteswapio") {
-      driver.byteswapio = true; // TODO: Pass to lowering, generate call
-    } else if (arg == "-cpp") {
-      driver.forcePreprocessing = true;
-    } else if (arg == "-nocpp") {
-      driver.forcePreprocessing = false;
-    } else if (arg == "-h" || arg == "-help" || arg == "--help" ||
-        arg == "-?") {
-      llvm::errs()
-          << "f18: LLVM Fortran compiler\n"
-          << "\n"
-          << "Usage: f18 [options] <input files>\n"
-          << "\n"
-          << "Defaults:\n"
-          << "  When invoked with input files, and no options to tell\n"
-          << "  it otherwise, f18 will unparse its input and pass that on to "
-             "an\n"
-          << "  external compiler to continue the compilation.\n"
-          << "  The external compiler is specified by the F18_FC environment\n"
-          << "  variable. The default is 'gfortran'.\n"
-          << "  If invoked with no input files, f18 reads source code from\n"
-          << "  stdin and runs with -fdebug-measure-parse-tree -funparse.\n"
-          << "\n"
-          << "f18 options:\n"
-          << "  -Mfixed | -Mfree | -ffixed-form | -ffree-form   force the "
-             "source form\n"
-          << "  -Mextend | -ffixed-line-length-132   132-column fixed form\n"
-          << "  -f[no-]backslash     enable[disable] \\escapes in literals\n"
-          << "  -M[no]backslash      disable[enable] \\escapes in literals\n"
-          << "  -Mstandard           enable conformance warnings\n"
-          << "  -std=<standard>      enable conformance warnings\n"
-          << "  -r8 | -fdefault-real-8 | -i8 | -fdefault-integer-8 | "
-             "-fdefault-double-8   change default kinds of intrinsic types\n"
-          << "  -Werror              treat warnings as errors\n"
-          << "  -ed                  enable fixed form D lines\n"
-          << "  -E                   prescan & preprocess only\n"
-          << "  -module dir          module output directory (default .)\n"
-          << "  -module-dir/-J <dir> Put MODULE files in <dir>\n"
-          << "  -flatin              interpret source as Latin-1 (ISO 8859-1) "
-             "rather than UTF-8\n"
-          << "  -fsyntax-only        parsing and semantics only, no output "
-             "except messages\n"
-          << "  -funparse            parse & reformat only, no code "
-             "generation\n"
-          << "  -funparse-with-symbols  parse, resolve symbols, and unparse\n"
-          << "  -fdebug-measure-parse-tree\n"
-          << "  -fdebug-dump-provenance\n"
-          << "  -fdebug-dump-parse-tree\n"
-          << "  -fdebug-dump-symbols\n"
-          << "  -fdebug-instrumented-parse\n"
-          << "  -fdebug-no-semantics  disable semantic checks\n"
-          << "  -fget-definition\n"
-          << "  -fget-symbols-sources\n"
-          << "  -v -c -o -I -D -U    have their usual meanings\n"
-          << "  -cpp / -nocpp        force / inhibit macro replacement\n"
-          << "  -help                print this again\n"
-          << "Unrecognised options are passed through to the external "
-             "compiler\n"
-          << "set by F18_FC (see defaults).\n";
-      return exitStatus;
-    } else if (arg == "-V" || arg == "--version") {
-      return printVersion();
-    } else if (arg == "-fdebug-stack-trace") {
-      llvm::sys::PrintStackTraceOnErrorSignal(llvm::StringRef{}, true);
-    } else {
-      driver.F18_FCArgs.push_back(arg);
-      if (arg == "-v") {
-        if (args.size() > 1) {
-          driver.verbose = true;
-        } else {
-          return printVersion();
-        }
-      } else if (arg == "-I") {
-        driver.F18_FCArgs.push_back(args.front());
-        driver.searchDirectories.push_back(args.front());
-        args.pop_front();
-      } else if (arg.substr(0, 2) == "-I") {
-        driver.searchDirectories.push_back(arg.substr(2));
-      } else if (arg == "-J") {
-        driver.F18_FCArgs.push_back(args.front());
-        driver.moduleDirectory = args.front();
-        driver.searchDirectories.push_back(driver.moduleDirectory);
-        args.pop_front();
-      } else if (arg.substr(0, 2) == "-J") {
-        driver.moduleDirectory = arg.substr(2);
-        driver.searchDirectories.push_back(driver.moduleDirectory);
-      }
-    }
-  }
-
-  if (driver.warnOnNonstandardUsage) {
-    options.features.WarnOnAllNonstandard();
-  }
-  if (isPGF90) {
-    if (!options.features.IsEnabled(
-            Fortran::common::LanguageFeature::BackslashEscapes)) {
-      driver.F18_FCArgs.push_back(
-          "-Mbackslash"); // yes, this *disables* them in pgf90
-    }
-    if (options.features.IsEnabled(Fortran::common::LanguageFeature::OpenMP)) {
-      driver.F18_FCArgs.push_back("-mp");
-    }
-
-    Fortran::parser::useHexadecimalEscapeSequences = false;
-  } else {
-    if (options.features.IsEnabled(
-            Fortran::common::LanguageFeature::BackslashEscapes)) {
-      driver.F18_FCArgs.push_back("-fbackslash");
-    }
-    if (options.features.IsEnabled(Fortran::common::LanguageFeature::OpenMP)) {
-      driver.F18_FCArgs.push_back("-fopenmp");
-    }
-
-    Fortran::parser::useHexadecimalEscapeSequences = true;
-  }
-
-  if (!anyFiles) {
-    driver.measureTree = true;
-    driver.dumpUnparse = true;
-    llvm::outs() << "Enter Fortran source\n"
-                 << "Use EOF character (^D) to end file\n";
-    CompileFortran("-", options, driver, defaultKinds);
-    return exitStatus;
-  }
-  for (const auto &path : fortranSources) {
-    options.predefinitions.clear();
-    if (driver.forcePreprocessing) {
-      if (*driver.forcePreprocessing) {
-        options.predefinitions = predefinitions;
-      }
-    } else {
-      auto dot{path.rfind(".")};
-      if (dot != std::string::npos) {
-        std::string suffix{path.substr(dot + 1)};
-        if (suffix == "F" || suffix == "F90" || suffix == "F95" ||
-            suffix == "CUF" || suffix == "F18") {
-          options.predefinitions = predefinitions;
-        }
-      }
-    }
-    std::string relo{CompileFortran(path, options, driver, defaultKinds)};
-    if (!driver.compileOnly && !relo.empty()) {
-      objlist.push_back(relo);
-    }
-  }
-  for (const auto &path : otherSources) {
-    std::string relo{CompileOtherLanguage(path, driver)};
-    if (!driver.compileOnly && !relo.empty()) {
-      objlist.push_back(relo);
-    }
-  }
-  if (!driver.compileOnly && !objlist.empty()) {
-    Link(liblist, objlist, driver);
-  }
-  return exitStatus;
-}

flang/tools/f18/flang

 #! /usr/bin/env bash
 #===-- tools/f18/flang.sh -----------------------------------------*- sh -*-===#
 #
 # 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
 #
 #===------------------------------------------------------------------------===#
 # A wrapper script for Flang's compiler driver that was developed for testing and
 # experimenting. You should be able to use it as a regular compiler driver. It
 # will:
 #   * run Flang's compiler driver to unparse the input source files
-#   * use the external compiler (defined via F18_FC environment variable) to
+#   * use the external compiler (defined via FLANG_FC environment variable) to
 #   compile the unparsed source files
 #===------------------------------------------------------------------------===#
 set -euo pipefail
 
 # Global variables to make the parsing of input arguments a bit easier
 INPUT_FILES=()
 OPTIONS=()
 OUTPUT_FILE=""
if  [[ $opt == "-module-dir" ]] ||
       [[ $opt == "-o" ]] ||
       [[ $opt == "-fintrinsic-modules-path" ]] ; then
       echo "ERROR: $opt should've been fully processed by \`parse_args\`"
       exit 1
     fi
 
     if
       # The options claimed by Flang. This list needs to be compatible with
-      # what's supported by Flang's compiler driver (i.e. `flang-new` and f18).
+      # what's supported by Flang's compiler driver (i.e. `flang-new`).
       [[ $opt == "-cpp" ]] ||
       [[ $opt =~ ^-D.* ]] ||
       [[ $opt == "-E" ]] ||
       [[ $opt == "-falternative-parameter-statement" ]] ||
       [[ $opt == "-fbackslash" ]] ||
       [[ $opt == "-fcolor-diagnostics" ]] ||
       [[ $opt == "-fdefault-double-8" ]] ||
       [[ $opt == "-fdefault-integer-8" ]] ||

 #   $2 - other source files (array, name reference)
 #   $3 - compiler flags (array, name reference)
 # =============================================================================
 preprocess() {
   local -n fortran_srcs=$1
   local -n other_srcs=$2
   local -n opts=$3
 
-  local -r ext_fc="${F18_FC:-gfortran}"
+  local ext_fc=""
+  if [[ -v $FLANG_FC ]]; then
+    ext_fc="${FLANG_FC}"
+  elif [[ -v $F18_FC ]]; then
+    # We support F18_FC for backwards compatibility.
+    ext_fc="${F18_FC}"
+  else
+    ext_fc=gfortran
+  fi
+
+
+  local ext_fc="${FLANG_FC:-gfortran}"
   local -r wd=$(cd "$(dirname "$0")/.." && pwd)
 
   # Use the provided output file name.
   if [[ ! -z ${OUTPUT_FILE:+x} ]]; then
     output_definition="-o $OUTPUT_FILE"
   fi
 
   # Preprocess fortran sources using Flang
   for idx in "${!fortran_srcs[@]}"; do
-    if ! "$wd/bin/@FLANG_DEFAULT_DRIVER@" -E "${opts[@]}" "${fortran_srcs[$idx]}" ${output_definition:+$output_definition}
+    if ! "$wd/bin/flang-new" -E "${opts[@]}" "${fortran_srcs[$idx]}" ${output_definition:+$output_definition}
     then status=$?
-         echo flang: in "$PWD", @FLANG_DEFAULT_DRIVER@ failed with exit status $status: "$wd/bin/@FLANG_DEFAULT_DRIVER@" "${opts[@]}" "$@" >&2
+         echo flang: in "$PWD", flang-new failed with exit status $status: "$wd/bin/flang-new" "${opts[@]}" "$@" >&2
          exit $status
     fi
   done
 
   # Preprocess other sources using Flang
   for idx in "${!other_srcs[@]}"; do
     if ! $ext_fc -E "${opts[@]}" "${other_srcs[$idx]}" ${output_definition:+$output_definition}
     then status=$?
main() {
   if [[ $PREPROCESS_ONLY == "True" ]]; then
     preprocess fortran_source_files other_source_files OPTIONS
     exit 0
   fi
 
   # Options for the Flang driver.
   # NOTE: We need `-fc1` to make sure that the frontend driver rather than
   # compiler driver is used. We also need to make sure that that's the first
   # flag that the driver will see (otherwise it assumes compiler/toolchain
-  # driver mode).`f18` will just ignore this flag when uparsing, so it's fine
-  # to add it here unconditionally.
+  # driver mode).
   local flang_options=("-fc1")
   # Options for the external Fortran Compiler
   local ext_fc_options=()
   categorise_opts OPTIONS flang_options ext_fc_options
 
   local -r wd=$(cd "$(dirname "$0")/.." && pwd)
 
   # STEP 1: Unparse
   # Base-name for the unparsed files. These are just temporary files that are
   # first generated and then deleted by this script.
   # NOTE: We need to make sure that the base-name is unique to every
   # invocation. Otherwise we can't use this script in parallel.
   local -r unique_id=$(uuidgen | cut -b25-36)
   local -r unparsed_file_base="flang_unparsed_file_$unique_id"
 
   flang_options+=("-module-suffix")
   flang_options+=(".f18.mod")
   flang_options+=("-fdebug-unparse")
   flang_options+=("-fno-analyzed-objects-for-unparse")
 
   [[ ! -z ${MODULE_DIR} ]] && flang_options+=("-module-dir ${MODULE_DIR}")
   [[ ! -z ${INTRINSICS_MOD_DIR} ]] && flang_options+=("-intrinsics-module-directory ${INTRINSICS_MOD_DIR}")
   for idx in "${!fortran_source_files[@]}"; do
     set +e
-    "$wd/bin/@FLANG_DEFAULT_DRIVER@" "${flang_options[@]}" "${fortran_source_files[$idx]}" -o "${unparsed_file_base}_${idx}.f90"
+    "$wd/bin/flang-new" "${flang_options[@]}" "${fortran_source_files[$idx]}" -o "${unparsed_file_base}_${idx}.f90"
     ret_status=$?
     set -e
     if [[ $ret_status != 0 ]]; then
-         echo flang: in "$PWD", @FLANG_DEFAULT_DRIVER@ failed with exit status "$ret_status": "$wd/bin/@FLANG_DEFAULT_DRIVER@" "${flang_options[@]}" "$@" >&2
+         echo flang: in "$PWD", flang-new failed with exit status "$ret_status": "$wd/bin/flang-new" "${flang_options[@]}" "$@" >&2
          exit "$ret_status"
     fi
   done
 
   # STEP 2: Compile Fortran Source Files
   readonly ext_fc="${F18_FC:-gfortran}"
   for idx in "${!fortran_source_files[@]}"; do
     # We always have to specify the output name with `-o <out_obj_file>`. This

flang/unittests/CMakeLists.txt

if(NOT ARG_SLOW_TEST)
     add_dependencies(FlangUnitTests ${test_name}${suffix})
   endif()
 endfunction()
 
 add_subdirectory(Optimizer)
 add_subdirectory(Decimal)
 add_subdirectory(Evaluate)
 add_subdirectory(Runtime)
-
-if (FLANG_BUILD_NEW_DRIVER)
-  add_subdirectory(Frontend)
-endif()

llvm/CMakeLists.txt

 endif()
 
 if ("flang" IN_LIST LLVM_ENABLE_PROJECTS)
   if (NOT "mlir" IN_LIST LLVM_ENABLE_PROJECTS)
     message(STATUS "Enabling MLIR as a dependency to flang")
     list(APPEND LLVM_ENABLE_PROJECTS "mlir")
   endif()
 
-  option(FLANG_BUILD_NEW_DRIVER "Build the flang compiler driver" ON)
-  if (FLANG_BUILD_NEW_DRIVER AND NOT "clang" IN_LIST LLVM_ENABLE_PROJECTS)
-    message(FATAL_ERROR "Clang is not enabled, but it's required by the new Flang driver")
+  if (NOT "clang" IN_LIST LLVM_ENABLE_PROJECTS)
+    message(FATAL_ERROR "Clang is not enabled, but is required for the Flang driver")
   endif()
 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