[flang][driver] Rename `flang-new` as `flang`

[awarzynski]

Summary

This patch _conditionally_ renames flang-new as flang. This is controlled with the FLANG_USE_LEGACY_NAME Cmake option, which by default is set to ON. This means that by default, the driver executable will still be called flang-new. If you want to use the updated name, flang, set FLANG_USE_LEGACY_NAME to OFF when configuring LLVM Flang. No other set-up is required.

Similarly to Clang, Flang's driver executable will be called flang{-new}-<MAJOR_VERSION> and flang{-new} will be a symlink to flang{-new}-<MAJOR_VERSION>.

[DavidSpickett]

Do you know how this will work with the llvm-testsuite runs that currrently use gfortran for codegen? Here is one we have: https://lab.llvm.org/buildbot/#/builders/179/builds/3694

Currently:

2022-05-17 13:06:53 INFO: Execute: /usr/bin/cmake -DCMAKE_C_COMPILER:FILEPATH=/home/tcwg-buildbot/worker/clang-aarch64-full-2stage/stage2.install/bin/clang -DCMAKE_CXX_COMPILER:FILEPATH=/home/tcwg-buildbot/worker/clang-aarch64-full-2stage/stage2.install/bin/clang++ /home/tcwg-buildbot/worker/clang-aarch64-full-2stage/test/test-suite -DCMAKE_C_FLAGS=-mcpu=cortex-a57 -DCMAKE_C_FLAGS_DEBUG= -DCMAKE_C_FLAGS_MINSIZEREL= -DCMAKE_C_FLAGS_RELEASE= -DCMAKE_C_FLAGS_RELWITHDEBINFO= -DCMAKE_CXX_FLAGS=-mcpu=cortex-a57 -DCMAKE_CXX_FLAGS_DEBUG= -DCMAKE_CXX_FLAGS_MINSIZEREL= -DCMAKE_CXX_FLAGS_RELEASE= -DCMAKE_CXX_FLAGS_RELWITHDEBINFO= -DTEST_SUITE_FORTRAN:STRING=ON -DCMAKE_Fortran_COMPILER=/home/tcwg-buildbot/worker/clang-aarch64-full-2stage/stage2.install/bin/flang
<...>
-- The Fortran compiler identification is unknown
-- Check for working Fortran compiler: /home/tcwg-buildbot/worker/clang-aarch64-full-2stage/stage2.install/bin/flang
-- Check for working Fortran compiler: /home/tcwg-buildbot/worker/clang-aarch64-full-2stage/stage2.install/bin/flang  -- works
-- Detecting Fortran compiler ABI info
-- Detecting Fortran compiler ABI info - failed
-- Checking whether /home/tcwg-buildbot/worker/clang-aarch64-full-2stage/stage2.install/bin/flang supports Fortran 90
-- Checking whether /home/tcwg-buildbot/worker/clang-aarch64-full-2stage/stage2.install/bin/flang supports Fortran 90 -- yes

Can we expect the current flang-new, soon to be flang to also cope with these tests (I have no expectations myself here, fine if not) or should we move the bots to use flang-to-gfortran?

[awarzynski]

In D125788#3519297, @DavidSpickett wrote:

Can we expect the current flang-new, soon to be flang to also cope with these tests (I have no expectations myself here, fine if not) or should we move the bots to use flang-to-gfortran?

Great point, thank for highlighting it! Moving the bots to flang-to-gfortran would make most sense. I can split this change into two patches so that there's no disruption from the buildbot perspective:

• patch 1: rename flang as flang-to-gfortran, but keep flang as an alias for flang-to-gfortran,
• patch 2: all the remaining changes from this patch.

Once "patch 1" is merged, we can update the buildbot config to use flang-to-gfortran. After that, we could land "patch 2".

[DavidSpickett]

Sounds good to me. https://reviews.llvm.org/D125796 for the bot side, let me know if/when the first half of the change goes in.

I'll leave it to others to approve the change overall. I do think being able to do ./bin/flang and get the right flang will save a lot of confusion but I'm not a user of either of them myself.

[h-vetinari]

Very happy to see this finally happening! :)

[kiranchandramohan]

LGTM. In the call on Monday, it was mentioned that the original users of the flang script have moved on to using a custom driver.

It will be a good idea to,
-> wait for the author of the original script and the throwaway driver, @sscalpone.
-> clarify that execution is still restricted to developers via a flag. We hope to open it to users later in the year.

My personal preference for the renaming is flang-to-external-fc since it is not specific to gfortran.

flang/tools/flang-driver/CMakeLists.txt

51

Nit: backwords -> backwards

[awarzynski]

In D125788#3519403, @DavidSpickett wrote:

Sounds good to me. https://reviews.llvm.org/D125796 for the bot side, let me know if/when the first half of the change goes in.

https://reviews.llvm.org/D125832 for "patch 1".

In D125788#3521487, @kiranchandramohan wrote:

It will be a good idea to,
-> wait for the author of the original script and the throwaway driver, @sscalpone.

👍🏻

-> clarify that execution is still restricted to developers via a flag.

👍🏻 Nothing changes with regard to the compiler flags (there are no functional changes here, just the renaming).

My personal preference for the renaming is flang-to-external-fc since it is not specific to gfortran.

Makes sense, I can rename it.

[awarzynski]

Rename flang-to-gfortran as flang-to-external-fc

I will also make this change depend on https://reviews.llvm.org/D125832

[shraiysh]

clarify that execution is still restricted to developers via a flag.

Just confirming what this means: After this patch, would flang sample.f90 generate an executable? If not, how to generate an executable using flang-new? If yes, does this mean that if I just replace classic-flang with new llvm flang (along with library and include paths), I should be able to find and report bugs (expected) or run the application (best case)?

[kiranchandramohan]

In D125788#3523259, @shraiysh wrote:

clarify that execution is still restricted to developers via a flag.

Just confirming what this means: After this patch, would flang sample.f90 generate an executable? If not, how to generate an executable using flang-new? If yes, does this mean that if I just replace classic-flang with new llvm flang (along with library and include paths), I should be able to find and report bugs (expected) or run the application (best case)?

Sorry, the point I was trying to say here is that till now the flang script will parse, unparse and call an external compiler to do the codegen/generate executable. With this change the flang driver will not generate an executable unless it is built with an option. This default behaviour might be seen as a regression from the point of view of a flang script user.

[shraiysh]

With this change the flang driver will not generate an executable unless it is built with an option.

Okay, thank you for the clarification. Is this a cmake option and? Are we documenting this somewhere except this patch summary, like on the flang documentation or something? Apologies if this a repetition to what you meant by clarifying that it is available via a flag.

[rouson]

I think this is an exciting step. I hope it gets approved. Although it's technically true that this could appear to be a regression for current flang script users, the ultimate compilation currently happens by invoking an external compiler so most current flang script users can eliminate the regression by simply calling the external compiler. The exception would be if the current flang script user specifically wants flang's parsing capabilities for checking code correctness (do we know if anyone is using the flang script that way?) or for testing the parser (which I presume can still happen by other means). It might be nice to simply rename the current script so those who want it can simply change the name they use to invoke it.

[kiranchandramohan]

In D125788#3523408, @shraiysh wrote:

With this change the flang driver will not generate an executable unless it is built with an option.

Okay, thank you for the clarification. Is this a cmake option and? Are we documenting this somewhere except this patch summary, like on the flang documentation or something? Apologies if this a repetition to what you meant by clarifying that it is available via a flag.

I think it is a driver flag -flang-experimental-exec. I was only requesting the add this information to the patch summary. If you feel it should be present somewhere else then please add a separate comment.

Some users might have been blindly running flang before without being aware that the script was calling an external compiler to generated code/executable. This change introduces the lowering flow and the users might see different results,
-> TODO messages for 2003 and above features.
-> Unexpected ICEs or miscomparisons.
-> Not producing an executable.

In D125788#3523443, @rouson wrote:

I think this is an exciting step. I hope it gets approved. Although it's technically true that this could appear to be a regression for current flang script users, the ultimate compilation currently happens by invoking an external compiler so most current flang script users can eliminate the regression by simply calling the external compiler. The exception would be if the current flang script user specifically wants flang's parsing capabilities for checking code correctness (do we know if anyone is using the flang script that way?) or for testing the parser (which I presume can still happen by other means). It might be nice to simply rename the current script so those who want it can simply change the name they use to invoke it.

Yes, the user can use flang-to-external-fc if they want the old flow. But this change might be a surprise for the user hence the request to add the relevant information to the summary.

[awarzynski]

Update documentation

[awarzynski]

Summary updated :)

In D125788#3524338, @kiranchandramohan wrote:

I think it is a driver flag -flang-experimental-exec. I was only requesting the add this information to the patch summary. If you feel it should be present somewhere else then please add a separate comment.

The flag is deliberately not being "advertised" - that was the compromise that we agreed on in https://reviews.llvm.org/D122008. Personally, I would really like to document it and make it more visible, but I don't want anyone to feel that their reservations are being ignored.

In D125788#3524338, @kiranchandramohan wrote:

Some users might have been blindly running flang before without being aware that the script was calling an external compiler to generated code/executable.

A while back we added documentation to clarify this. The bash script (which is the most confusing part) is documented here (that's being updated here). I'm not sure whether there's anything else that we could improve 🤔.

In D125788#3523443, @rouson wrote:

I think this is an exciting step.

Thank you!

Although it's technically true that this could appear to be a regression for current flang script users, the ultimate compilation currently happens by invoking an external compiler so most current flang script users can eliminate the regression by simply calling the external compiler.

I agree :)

[sscalpone]

My belief is that we should wait until f18 hits a reasonable quality bar for executables before making flang-new the default. My reasoning seems not to have carried the day.

[rouson]

In D125788#3534482, @sscalpone wrote:

My belief is that we should wait until f18 hits a reasonable quality bar for executables before making flang-new the default. My reasoning seems not to have carried the day.

It would hep to have a well-defined quality bar, e.g., a standards-based test suite or a collection of application test suites or the progress bar on the relevant GitHub project pages. We could then discuss and vote on which point on the quality bar suffices.

[sscalpone]

My proposal is:

If the compiler compiles it, it ought to run.
If the compiler can't compile it, it ought to clearly say why.

1. All tests of legal Fortran that compile & link must also execute correctly (which excludes tests that expect to catch a problem at runtime)
2. For all tests with unsupported features, the compiler must issues an error message and the message references the source-location of the unsupported feature

My preference is to use the NAG test suite. It is not freely available.

[peixin]

In D125788#3535199, @sscalpone wrote:

My proposal is:

If the compiler compiles it, it ought to run.
If the compiler can't compile it, it ought to clearly say why.

1. All tests of legal Fortran that compile & link must also execute correctly (which excludes tests that expect to catch a problem at runtime)
2. For all tests with unsupported features, the compiler must issues an error message and the message references the source-location of the unsupported feature

My preference is to use the NAG test suite. It is not freely available.

I tested a lot of test cases (mostly Fortran 95 code) and have several detailed questions about the reasonable quality bar.

1. Should some incorrect execution results be changed into one TODO if there is no plan to support it soon? One example is derived type array in forall (https://github.com/flang-compiler/f18-llvm-project/issues/1598).

2. What if the case fails in lowering with a "fatal internal error", but the real reason is the incorrect semantic analysis? Should it either be supported, or be turned from the "fatal internal error" into TODO?

3. What about the edge cases? For those with incorrect execution results, turn them into TODO? One example is D125632.

4. What about some dangerous usage? Usually, gfortran can report a lot of warnings for the dangerous scenarios such as string length mismatch, external procedure type kind mismatch, the test case in D125891, etc. Maybe this is not in priority.

5. Are the rules also applied to Fortran 2003, 2008 and 2018 code, or only restricted to Fortran 95 code?

[kiranchandramohan]

In D125788#3535199, @sscalpone wrote:

My proposal is:

If the compiler compiles it, it ought to run.
If the compiler can't compile it, it ought to clearly say why.

1. All tests of legal Fortran that compile & link must also execute correctly (which excludes tests that expect to catch a problem at runtime)
2. For all tests with unsupported features, the compiler must issues an error message and the message references the source-location of the unsupported feature

My preference is to use the NAG test suite. It is not freely available.

I strongly suspect that you might be able to win over some of the folks by sharing the status/list of failures/list of issues to be fixed for getting the NAG test suite to pass. As I have mentioned before, at least the companies involved have access to the NAG testsuite. The community can probably help you achieve the outlined goals faster. It can also help focus our efforts. Some of our engineers have now worked with f18/flang for some time. While some issues might require a fix by the experts, many can be fixed by others.

A separate issue we have is that it is not clear which branch is it that is being used for testing with NAG. Since many fixes have landed in llvm-project/flang, I assume that fir-dev is now out of date. While most of upstreaming is complete there is still a bit of things left to upstream, should not take much time though.

[rouson]

+1 @kiranchandramohan

I have access to the NAG Fortran compiler and find it very helpful for checking standard conformance. I was unaware of the NAG test suite and don't see any mention of it online. Is it an official product that can be purchased?

[sscalpone]

Recommend that you contact NAG for more info on the test suite. Here's the only reference that I could find: https://fortran-lang.discourse.group/t/fortran-compiler-testing-framework/1573/10

[awarzynski]

Thank you all for your comments and apologies for going radio silent - I was away for a few days.

I've identified 2 threads emerging from your comments:

1. flang vs flang-new
@sscalpone, if I understand correctly, you are suggesting that any tool named flang in "LLVM Flang" should satisfy the following condition:

2. For all tests with unsupported features, the compiler must issues an error message and the message references the source-location of the unsupported feature

Indeed, flang-new does not satisfy this yet, but neither does flang, the bash wrapper script. flang, the bash script, calls flang-new to run parsing and semantic analysis. Basically, it's the same Fortran frontend as far as these initial phases are concerned. So, if "LLVM Flang" is missing diagnostics for e.g. unsupported language features, both flang and flang-new will fail to report these. I don't see how defaulting to flang (the bash script) instead of flang-new (the compiler driver) helps here.

Put differently, if the above condition is to be considered a requirement for any tool called flang, then the bash wrapper script should be renamed as it does not satisfy it.

2. NAG test suite
From what I recall, we did discuss renaming flang-new as flang in the past and it was decided that we would wait for flang-new to be able to generate executables. I couldn't find this written down, so perhaps I'm misremembering? In any case, I don't follow why a test-suite conformance should determine what name is used for a compiler driver in "LLVM Flang". We should definitely work towards 100% pass rate, but to me that's orthogonal to how our tools are called. The level of Language support in "LLVM Flang" should be communicated through the documentation (including release notes) instead of misleading tool names.

As for NAG test-suite specifically:

My preference is to use the NAG test suite. It is not freely available.

If we take this path, we will effectively be introducing yet another dependency on an external project in "LLVM Flang" (libpgmath being the first one). While most (perhaps all?) salaried "LLVM Flang" developers will have access to the NAG test suite, community volunteers will effectively have their ability to contribute severely limited. I'm against this, but also don't have a counter-proposal (I'm not aware of any freely accessible Fortran test suites that we could use here).

@peixin, you raised some really good points, thank you! I agree that even if it is decided that the NAG test suite is used as the benchmark for "LLVM Flang", it's still unclear how to deal with all these tricky corner cases (there will be platform dependencies too). As for the following one:

5. Are the rules also applied to Fortran 2003, 2008 and 2018 code, or only restricted to Fortran 95 code?

I think that we should limit ourselves to Fortran 95 for now - there's no code-gen support beyond that.

NEXT STEPS
Based on the above, how would you feel about the following:

1. Lets rename flang as flang-to-external-fc regardless of what's decided for flang-new. That would already be a huge step forward (and would reflect accurately what the bash wrapper script actually does).
2. As for the NAG test suite, I hope that we can agree not to use it as the condition for renaming flang-new. If it's decided that that's a valid requirement, then I agree with @kiranchandramohan that we should find a way to openly track the progress towards the required pass rate (and how that's defined).

Perhaps we could discuss more in the call today?

[sscalpone]

I'm fine with removing or renaming the existing flang shell script.

My proposal is not to wait for a 100% pass rate. My proposal is to wait until the messages for unimplemented features are converted to TODOs that reference the program's source line and that legal programs which compile and link will execute without error. In short, what flang compiles should work, and what flang doesn't compile should offer a reasonable message to the user to understand the limitation.

This proposal is not restricted to F95 but to any source that someone might attempt to compile.

[rouson]

On Mon, May 30, 2022 at 2:39 AM Andrzej Warzynski via Phabricator <[e-mail]> wrote:

1. Lets rename flang as flang-to-external-fc regardless of what's decided for flang-new. That would already be a huge step forward (and > would reflect accurately what the bash wrapper script actually does).

I support this. I think the proposed new name is better reflects what the current flang script currently does and thereby reduces the likelihood of surprise when a user sees an error message from an external compiler.

2. As for the NAG test suite, I hope that we can agree not to use it as the condition for renaming flang-new. If it's decided that that's a valid > equirement, then I agree with @kiranchandramohan that we should find a way to openly track the progress towards the required pass rate

(and how that's defined).

I agree.

Perhaps we could discuss more in the call today?

Any news from the call?

Damian

[awarzynski]

In D125788#3547494, @sscalpone wrote:

I'm fine with removing or renaming the existing flang shell script.

In D125788#3547656, @rouson wrote:

On Mon, May 30, 2022 at 2:39 AM Andrzej Warzynski via Phabricator <[e-mail]> wrote:
I support this.

Great, thank you both! "Step 1" merged: https://reviews.llvm.org/D125832. This leaves us with flang as a symlink pointing to flang-to-external-fc, which I will be removing once buildbots are reconfigured: https://reviews.llvm.org/D125796. I'd like this to happen soon.

In D125788#3547494, @sscalpone wrote:

This proposal is not restricted to F95 but to any source that someone might attempt to compile.

I would really appreciate if we could agree on more specific criteria. IMHO, "any source" leaves too much room for interpretation.

In D125788#3547656, @rouson wrote:

Any news from the call?

Not much - it was a very quiet call (Memorial Day for some folks, ISC 2022 for others, unexpected hiccup with Teams for the rest ). We decided to re-visit in the next call.

Next steps
Just to avoid any confusion:

• flang, the bash script, will be renamed as flang-to-external-fc (see D125832)
• flang-new won't be renamed just yet - perhaps we could discuss more in the forthcoming call(s)?

[awarzynski]

In the call yesterday it was proposed that we add a CMake option that will control the name of the driver. I suggest adding FLANG_USE_LEGACY_NAME:

• when set to ON, the driver binary will be called flang-new,
• when set to OFF, the driver binary will be called flang.

With this approach, everyone will be able to select the preferred driver name. Note that:

• this will affect both the build and installation targets,
• LLVM's testing infrastructure will automatically choose between flang and flang-new (based on FLANG_USE_LEGACY_NAME),
• you won't be required to perform any extra steps (in fact, you will be able to continue with your current workflows).

It was requested that the default value is set to ON (i.e. the default name for the driver executable in LLVM Flang will remain flang-new).

Later today I will upload a new version of this patch that implements the above. As for changing the default to flang (i.e. setting the default for FLANG_USE_LEGACY_NAME to OFF), the following remains a blocker:

In D125788#3535199, @sscalpone wrote:

My proposal is:

If the compiler compiles it, it ought to run.
If the compiler can't compile it, it ought to clearly say why.

1. All tests of legal Fortran that compile & link must also execute correctly (which excludes tests that expect to catch a problem at runtime)
2. For all tests with unsupported features, the compiler must issues an error message and the message references the source-location of the unsupported feature

My preference is to use the NAG test suite. It is not freely available.

We did discuss replacing NAG with e.g. SNAP + SPEC, but we run out of time and haven't concluded that part.

As always, please comment if I missed or misread anything!

Next steps
I will update this patch by introducing FLANG_USE_LEGACY_NAME CMake option - it will control the name of the generated driver executable.

[awarzynski]

Add the FLANG_USE_LEGACY_NAME cmake option that will control the name of the driver executable.

[peixin]

In summary:

If you want to use the updated name, flang, set FLANG_USE_LEGACY_NAME to ON when configuring LLVM Flang.

OFF?

[awarzynski]

In D125788#3612533, @peixin wrote:

In summary:

If you want to use the updated name, flang, set FLANG_USE_LEGACY_NAME to ON when configuring LLVM Flang.

OFF?

Updated, thanks!

[clementval]

clang/lib/Driver/ToolChain.cpp

185 ↗

(On Diff #435564)

Why do we need two lines here? Shouldn't we have a single line with the name chosen by the cmake option?

clang/lib/Driver/ToolChains/Flang.cpp

132

flang/CMakeLists.txt

411 ↗

(On Diff #435564)

Maybe add a comment that says what is the legacy name.

flang/test/lit.cfg.py

82

Is this the correct indentation?

[awarzynski]

clang/lib/Driver/ToolChain.cpp

185 ↗

(On Diff #435564)

That would require making this file "configurable" by CMake. That would be quite an intrusive design change, which IMO we should avoid.

Unless there's some easy way that I'm missing here?

[awarzynski]

Incorporate @clementval 's suggestions

[clementval]

Overall the patch looks ok from a technical point. Shouldn't we just wait until we can make the permanent renaming so we do not add unnecessary cmake option?

[awarzynski]

Thank your for reviewing @clementval !

In D125788#3621585, @clementval wrote:

Shouldn't we just wait until we can make the permanent renaming so we do not add unnecessary cmake option?

This was discussed in one of our calls. As we weren't able to agree on any specific time-frames, the CMake route was proposed instead. This was suggested by @sscalpone as an acceptable compromise. From what I recall, there were no objections to this.

flang-new has always been intended as a temporary name for the compiler driver. That's because flang was reserved for the bash script. The bash script has recently been renamed as flang-to-external-fc ( D125832) so we are free to repurpose that name. As I tried to explain earlier, these names (flang-new vs flang) have always been very confusing to people and we are trying to improve and to clarify that, step by step. While this approach is not ideal, it gives us the flexibility to choose our preferred name sooner rather than later. If you feel that we should keep flang-new, you can continue using/building LLVM Flang as you have been so far. If you are ready to update the driver name, the CMake option enables that for you.

We discussed this in our call on Monday and agreed to go ahead provided that this change is technically sound. IIUC, this has now been confirmed:

Overall the patch looks ok from a technical point.

As always, please correct me if I missed or misinterpreted something!

[clementval]

clang/lib/Driver/ToolChain.cpp

185 ↗

(On Diff #440283)

This is counter intuitive. We rename flang-new but we add flang-new here. It should be configurable.

[richard.barton.arm]

clang/lib/Driver/ToolChain.cpp

185 ↗

(On Diff #440283)

This is a list of all the valid prefixes of binaries that the driver supports. With this change, an additional one will be supported so I don't think it's an issue to have both flang and flang-new here.

The thing that confuses me is how flang-new works today without this change, given that "flang" is not a suffix of "flang-new"? @awarzynski , do you know why that is? Perhaps the line here is not needed at all? Or is this a bug fix for flang-new that is actually unrelated to this change?

[awarzynski]

clang/lib/Driver/ToolChain.cpp

185 ↗

(On Diff #440283)

This is counter intuitive.

I can add a comment to clarify this.

It should be configurable.

It is, in Flang's driver.cpp. Originally, the suffix was hard-coded as:

clang::driver::ParsedClangName targetandMode("flang", "--driver-mode=flang");

(i.e. the clangDriver library used flang internally despite the actual name being flang-new). This is now being replaced with (see in "driver.cpp"):

clang::driver::ParsedClangName targetandMode =
     clang::driver::ToolChain::getTargetAndModeFromProgramName(argv[0]);

But the change in "driver.cpp" means that we can no longer make assumptions about the suffix and hence the update here.

Like I mentioned earlier, we should not make this file build-time configurable. One possible option would be to try to update Clang's config.h.cmake, but that's would lead to more Flang-specific changes in Clang's core set-up. Also, I'm not convinced it would work here.

@awarzynski , do you know why that is?

Yeah, check Flang's "driver.cpp". We should've captured this earlier. The original set-up from ToolChain.cpp predates flang-new. And then in "driver.cpp" we just matched what was here. There was a lot of confusion around naming back then and this has slipped in.

[clementval]

clang/lib/Driver/ToolChain.cpp

185 ↗

(On Diff #440283)

This is counter intuitive.

I can add a comment to clarify this.

There should be at least a comment here.

Like I mentioned earlier, we should not make this file build-time configurable. One possible option would be to try to update Clang's config.h.cmake, but that's would lead to more Flang-specific changes in Clang's core set-up. Also, I'm not convinced it would work here.

If it cannot be configurable I think this is a good reason to wait a bit and make a direct renaming without all the options and duplicate.

[clementval]

In D125788#3621744, @awarzynski wrote:

We discussed this in our call on Monday and agreed to go ahead provided that this change is technically sound. IIUC, this has now been confirmed:

Overall the patch looks ok from a technical point.

As always, please correct me if I missed or misinterpreted something!

I still have reserved on this patch so please do not take my "Overall the patch looks ok from a technical point." as an approval. There are open discussion so wait for other to confirm or not.

[awarzynski]

Add a comment

[awarzynski]

In D125788#3622274, @clementval wrote:

There are open discussion so wait for other to confirm or not.

I was under the impression that we did discuss this extensively in our community calls and agreed to proceed with it. At least that's how I recall it.

I am abandoning this change as I'm distracted with other tasks at the moment, but I am still strongly in favor of this. Please, feel free to commandeer this patch and continue the discussion. I will try my best to help with reviews.

[MaskRay]

If you continue this work, consider landing this rename in multiple phases, e.g.

• Use lit substitutions instead of flang-new and other preparatory stuff so that the next step has very little change
• (lightweight) change flang-new to flang and add flang-new as a symlink for compatibility
• perform other post-migration cleanup
• (lightweight) remove the symlink flang-new, when it is no longer used both in-tree and for significant downstream users that need time for migration

Many build bots can fail in weird ways and ensuring that we will not revert a large change prevents causing churn to the tests.

[awarzynski]

In D125788#4556324, @MaskRay wrote:

If you continue this work, consider landing this rename in multiple phases, e.g.

• Use lit substitutions instead of flang-new and other preparatory stuff so that the next step has very little change
• change flang-new to flang and add flang-new as a symlink for compatibility
• remove the symlink flang-new, when it is no longer used.

Many build bots can fail in weird ways and ensuring that we will not revert a large change prevents causing churn to the tests.

Thank you, these are great pointers! CC @everythingfunctional

clang/lib/Driver/Driver.cpp

void Driver::PrintHelp(bool ShowHidden) const {
   std::string Usage = llvm::formatv("{0} [options] file...", Name).str();
   getOpts().printHelp(llvm::outs(), Usage.c_str(), DriverTitle.c_str(),
                       IncludedFlagsBitmask, ExcludedFlagsBitmask,
                       /*ShowAllAliases=*/false);
 }
 
 void Driver::PrintVersion(const Compilation &C, raw_ostream &OS) const {
   if (IsFlangMode()) {
-    OS << getClangToolFullVersion("flang-new") << '\n';
+    OS << getClangToolFullVersion("flang") << '\n';
   } else {
     // FIXME: The following handlers should use a callback mechanism, we don't
     // know what the client would like to do.
     OS << getClangFullVersion() << '\n';
   }
   const ToolChain &TC = C.getDefaultToolChain();
   OS << "Target: " << TC.getTripleString() << '\n';
 

clang/lib/Driver/ToolChains/Flang.cpp

void Flang::ConstructJob(Compilation &C, const JobAction &JA,
   } else {
     assert(Output.isNothing() && "Invalid output.");
   }
 
   assert(Input.isFilename() && "Invalid input.");
   CmdArgs.push_back(Input.getFilename());
 
   const auto& D = C.getDriver();
-  // TODO: Replace flang-new with flang once the new driver replaces the
-  // throwaway driver
-  const char *Exec = Args.MakeArgString(D.GetProgramPath("flang-new", TC));
+  const char *Exec = Args.MakeArgString(D.GetProgramPath("flang", TC));
   C.addCommand(std::make_unique<Command>(JA, *this,
                                          ResponseFileSupport::AtFileUTF8(),
                                          Exec, CmdArgs, Inputs, Output));
 }
 
-Flang::Flang(const ToolChain &TC) : Tool("flang-new", "flang frontend", TC) {}
+Flang::Flang(const ToolChain &TC) : Tool("flang", "flang frontend", TC) {}
 
 Flang::~Flang() {}

clang/test/Driver/flang/flang.f90

 ! Check that flang -fc1 is invoked when in --driver-mode=flang.
 
 ! This is a copy of flang_ucase.F90 because the driver has logic in it which
 ! differentiates between F90 and f90 files. Flang will not treat these files
 ! differently.
 
 ! Test various output types:
 ! * -E
 ! * -fsyntax-only
 ! * -emit-llvm -S
 ! * -emit-llvm
 ! * -S
 ! * (no type specified, resulting in an object file)
 
 ! All invocations should begin with flang -fc1, consume up to here.
-! ALL-LABEL: "{{[^"]*}}flang-new" "-fc1"
+! ALL-LABEL: "{{[^"]*}}flang" "-fc1"
 
 ! Check that f90 files are not treated as "previously preprocessed"
 ! ... in --driver-mode=flang.
 ! RUN: %clang --driver-mode=flang -### -E                  %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-E %s
 ! CHECK-E-NOT: previously preprocessed input
 ! CHECK-E-DAG: "-E"
 ! CHECK-E-DAG: "-o" "-"
 

clang/test/Driver/flang/flang_ucase.F90

 ! Check that flang -fc1 is invoked when in --driver-mode=flang.
 
 ! This is a copy of flang.f90 because the driver has logic in it which
 ! differentiates between F90 and f90 files. Flang will not treat these files
 ! differently.
 
 ! Test various output types:
 ! * -E
 ! * -fsyntax-only
 ! * -emit-llvm -S
 ! * -emit-llvm
 ! * -S
 ! * (no type specified, resulting in an object file)
 
 ! All invocations should begin with flang -fc1, consume up to here.
-! ALL-LABEL: "{{[^"]*}}flang-new" "-fc1"
+! ALL-LABEL: "{{[^"]*}}flang" "-fc1"
 
 ! Check that f90 files are not treated as "previously preprocessed"
 ! ... in --driver-mode=flang.
 ! RUN: %clang --driver-mode=flang -### -E                  %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-E %s
 ! CHECK-E-NOT: previously preprocessed input
 ! CHECK-E-DAG: "-E"
 ! CHECK-E-DAG: "-o" "-"
 

clang/test/Driver/flang/multiple-inputs-mixed.f90

 ! Check that flang can handle mixed C and fortran inputs.
 
 ! RUN: %clang --driver-mode=flang -### -fsyntax-only %S/Inputs/one.f90 %S/Inputs/other.c 2>&1 | FileCheck --check-prefixes=CHECK-SYNTAX-ONLY %s
-! CHECK-SYNTAX-ONLY-LABEL: "{{[^"]*}}flang-new{{[^"/]*}}" "-fc1"
+! CHECK-SYNTAX-ONLY-LABEL: "{{[^"]*}}flang{{[^"/]*}}" "-fc1"
 ! CHECK-SYNTAX-ONLY: "{{[^"]*}}/Inputs/one.f90"
 ! CHECK-SYNTAX-ONLY-LABEL: "{{[^"]*}}clang{{[^"/]*}}" "-cc1"
 ! CHECK-SYNTAX-ONLY: "{{[^"]*}}/Inputs/other.c"

clang/test/Driver/flang/multiple-inputs.f90

 ! Check that flang driver can handle multiple inputs at once.
 
 ! RUN: %clang --driver-mode=flang -### -fsyntax-only %S/Inputs/one.f90 %S/Inputs/two.f90 2>&1 | FileCheck --check-prefixes=CHECK-SYNTAX-ONLY %s
-! CHECK-SYNTAX-ONLY-LABEL: "{{[^"]*}}flang-new" "-fc1"
+! CHECK-SYNTAX-ONLY-LABEL: "{{[^"]*}}flang" "-fc1"
 ! CHECK-SYNTAX-ONLY: "{{[^"]*}}/Inputs/one.f90"
-! CHECK-SYNTAX-ONLY-LABEL: "{{[^"]*}}flang-new" "-fc1"
+! CHECK-SYNTAX-ONLY-LABEL: "{{[^"]*}}flang" "-fc1"
 ! CHECK-SYNTAX-ONLY: "{{[^"]*}}/Inputs/two.f90"

flang/examples/FlangOmpReport/FlangOmpReport.cpp

 //===-- examples/flang-omp-report-plugin/flang-omp-report.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
 //
 //===----------------------------------------------------------------------===//
 // This plugin parses a Fortran source file and generates a YAML report with
 // all the OpenMP constructs and clauses and which line they're located on.
 //
 // The plugin may be invoked as:
-// ./bin/flang-new -fc1 -load lib/flangOmpReport.so -plugin flang-omp-report
+// ./bin/flang -fc1 -load lib/flangOmpReport.so -plugin flang-omp-report
 // -fopenmp
 //
 //===----------------------------------------------------------------------===//
 
 #include "FlangOmpReportVisitor.h"
 
 #include "flang/Frontend/FrontendActions.h"
 #include "flang/Frontend/FrontendPluginRegistry.h"

flang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

createFrontendAction(CompilerInstance &ci) {
   }
 
   llvm_unreachable("Invalid program action!");
 }
 
 bool executeCompilerInvocation(CompilerInstance *flang) {
   // Honor -help.
   if (flang->getFrontendOpts().showHelp) {
-    clang::driver::getDriverOptTable().printHelp(llvm::outs(),
-        "flang-new -fc1 [options] file...", "LLVM 'Flang' Compiler",
+    clang::driver::getDriverOptTable().printHelp(
+        llvm::outs(), "flang -fc1 [options] file...", "LLVM 'Flang' Compiler",
         /*Include=*/clang::driver::options::FC1Option,
         /*Exclude=*/llvm::opt::DriverFlag::HelpHidden,
         /*ShowAllAliases=*/false);
     return true;
   }
 
   // Honor -version.
   if (flang->getFrontendOpts().showVersion) {

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
-  flang-new
+  flang
   llvm-config
   FileCheck
   count
   not
   module_files
   fir-opt
   tco
   bbc

flang/test/Driver/disable-ext-name-interop.f90

-! Test that we can disable the ExternalNameConversion pass in flang-new.
+! Test that we can disable the ExternalNameConversion pass in flang.
 
 ! RUN: %flang_fc1 -S %s -o - 2>&1 | FileCheck %s --check-prefix=EXTNAMES
 ! RUN: %flang_fc1 -S -mmlir -disable-external-name-interop %s -o - 2>&1 | FileCheck %s --check-prefix=INTNAMES
 
 ! EXTNAMES: test_ext_names_
 ! INTNAMES: _QPtest_ext_names
 subroutine test_ext_names
 end subroutine

flang/test/Driver/driver-help-hidden.f90

 
 !--------------------------
-! FLANG DRIVER (flang-new)
+! FLANG DRIVER (flang)
 !--------------------------
 ! RUN: %flang --help-hidden 2>&1 | FileCheck %s
 ! RUN: not %flang  -help-hidden 2>&1 | FileCheck %s --check-prefix=ERROR-FLANG
 
 !----------------------------------------
-! FLANG FRONTEND DRIVER (flang-new -fc1)
+! FLANG FRONTEND DRIVER (flang -fc1)
 !----------------------------------------
 ! RUN: not %flang_fc1 --help-hidden 2>&1 | FileCheck %s --check-prefix=ERROR-FLANG-FC1
 ! RUN: not %flang_fc1  -help-hidden 2>&1 | FileCheck %s --check-prefix=ERROR-FLANG-FC1
 
 !----------------------------------------------------
-! EXPECTED OUTPUT FOR FLANG DRIVER (flang-new)
+! EXPECTED OUTPUT FOR FLANG DRIVER (flang)
 !----------------------------------------------------
-! CHECK:USAGE: flang-new
+! CHECK:USAGE: flang
 ! CHECK-EMPTY:
 ! CHECK-NEXT:OPTIONS:
 ! CHECK-NEXT: -###      Print (but do not run) the commands to run for this compilation
 ! CHECK-NEXT: -cpp      Enable predefined and command line preprocessor macros
 ! CHECK-NEXT: -c        Only run preprocess, compile, and assemble steps
 ! CHECK-NEXT: -D <macro>=<value>     Define <macro> to <value> (or 1 if <value> omitted)
 ! CHECK-NEXT: -emit-llvm             Use the LLVM representation for assembler and object files
 ! CHECK-NEXT: -E        Only run the preprocessor

 ! CHECK-NEXT: -S                     Only run preprocess and compilation steps
 ! CHECK-NEXT: --target=<value>        Generate code for the given target
 ! CHECK-NEXT: -U <macro>             Undefine macro <macro>
 ! CHECK-NEXT: --version Print version information
 ! CHECK-NEXT: -W<warning>            Enable the specified warning
 ! CHECK-NEXT: -Xflang <arg>          Pass <arg> to the flang compiler
 
 !-------------------------------------------------------------
-! EXPECTED OUTPUT FOR FLANG DRIVER (flang-new)
+! EXPECTED OUTPUT FOR FLANG DRIVER (flang)
 !-------------------------------------------------------------
 ! ERROR-FLANG: error: unknown argument '-help-hidden'; did you mean '--help-hidden'?
 
 !-------------------------------------------------------------
-! EXPECTED OUTPUT FOR FLANG FRONTEND DRIVER (flang-new -fc1)
+! EXPECTED OUTPUT FOR FLANG FRONTEND DRIVER (flang -fc1)
 !-------------------------------------------------------------
 ! Frontend driver -help-hidden is not supported
 ! ERROR-FLANG-FC1: error: unknown argument: '{{.*}}'
 

flang/test/Driver/driver-version.f90

 
 !-----------
 ! RUN LINES
 !-----------
 ! RUN: %flang --version 2>&1 | FileCheck %s --check-prefix=VERSION
 ! RUN: not %flang --versions 2>&1 | FileCheck %s --check-prefix=ERROR
 ! RUN: %flang_fc1 -version 2>&1 | FileCheck %s --check-prefix=VERSION-FC1
 ! RUN: not %flang_fc1 --version 2>&1 | FileCheck %s --check-prefix=ERROR-FC1
 
 !-----------------------
 ! EXPECTED OUTPUT
 !-----------------------
-! VERSION: flang-new version
+! VERSION: flang version
 ! VERSION-NEXT: Target:
 ! VERSION-NEXT: Thread model:
 ! VERSION-NEXT: InstalledDir:
 
-! ERROR: flang-new: error: unsupported option '--versions'; did you mean '--version'?
+! ERROR: error: unsupported option '--versions'; did you mean '--version'?
 
 ! VERSION-FC1: LLVM version
 
 ! ERROR-FC1: error: unknown argument '--version'; did you mean '-version'?

flang/test/Driver/escaped-backslash.f90

 ! Ensure argument -fbackslash works as expected.
 
 !--------------------------
-! FLANG DRIVER (flang-new)
+! FLANG DRIVER (flang)
 !--------------------------
 ! RUN: %flang -E %s  2>&1 | FileCheck %s --check-prefix=ESCAPED
 ! RUN: %flang -E -fbackslash -fno-backslash %s  2>&1 | FileCheck %s --check-prefix=ESCAPED
 ! RUN: %flang -E -fbackslash %s  2>&1 | FileCheck %s --check-prefix=UNESCAPED
 
 !-----------------------------------------
-! FRONTEND FLANG DRIVER (flang-new -fc1)
+! FRONTEND FLANG DRIVER (flang -fc1)
 !-----------------------------------------
 ! RUN: %flang_fc1 -E %s  2>&1 | FileCheck %s --check-prefix=ESCAPED
 ! RUN: %flang_fc1 -E -fbackslash -fno-backslash %s  2>&1 | FileCheck %s --check-prefix=ESCAPED
 ! RUN: %flang_fc1 -E -fbackslash %s  2>&1 | FileCheck %s --check-prefix=UNESCAPED
 
 !-----------------------------------------
 ! EXPECTED OUTPUT FOR ESCAPED BACKSLASHES
 !-----------------------------------------

flang/test/Driver/fdefault.f90

 ! Ensure argument -fdefault* work as expected.
 ! TODO: Add checks when actual codegen is possible for this family
 
 !--------------------------
-! FLANG DRIVER (flang-new)
+! FLANG DRIVER (flang)
 !--------------------------
-! RUN: rm -rf %t/dir-flang-new  && mkdir -p %t/dir-flang-new && %flang -fsyntax-only -module-dir %t/dir-flang-new %s  2>&1
-! RUN: cat %t/dir-flang-new/m.mod | FileCheck %s --check-prefix=NOOPTION
-! RUN: rm -rf %t/dir-flang-new  && mkdir -p %t/dir-flang-new && %flang -fsyntax-only -fdefault-real-8 -module-dir %t/dir-flang-new %s  2>&1
-! RUN: cat %t/dir-flang-new/m.mod | FileCheck %s --check-prefix=REAL8
-! RUN: rm -rf %t/dir-flang-new  && mkdir -p %t/dir-flang-new && %flang -fsyntax-only -fdefault-real-8 -fdefault-double-8 -module-dir %t/dir-flang-new %s  2>&1
-! RUN: cat %t/dir-flang-new/m.mod | FileCheck %s --check-prefix=DOUBLE8
+! RUN: rm -rf %t/dir-flang  && mkdir -p %t/dir-flang && %flang -fsyntax-only -module-dir %t/dir-flang %s  2>&1
+! RUN: cat %t/dir-flang/m.mod | FileCheck %s --check-prefix=NOOPTION
+! RUN: rm -rf %t/dir-flang  && mkdir -p %t/dir-flang && %flang -fsyntax-only -fdefault-real-8 -module-dir %t/dir-flang %s  2>&1
+! RUN: cat %t/dir-flang/m.mod | FileCheck %s --check-prefix=REAL8
+! RUN: rm -rf %t/dir-flang  && mkdir -p %t/dir-flang && %flang -fsyntax-only -fdefault-real-8 -fdefault-double-8 -module-dir %t/dir-flang %s  2>&1
+! RUN: cat %t/dir-flang/m.mod | FileCheck %s --check-prefix=DOUBLE8
 ! RUN: not %flang -fsyntax-only -fdefault-double-8 %s  2>&1 | FileCheck %s --check-prefix=ERROR
 
 !-----------------------------------------
-! FRONTEND FLANG DRIVER (flang-new -fc1)
+! FRONTEND FLANG DRIVER (flang -fc1)
 !-----------------------------------------
-! RUN: rm -rf %t/dir-flang-new  && mkdir -p %t/dir-flang-new && %flang_fc1 -fsyntax-only -module-dir %t/dir-flang-new %s  2>&1
-! RUN: cat %t/dir-flang-new/m.mod | FileCheck %s --check-prefix=NOOPTION
-! RUN: rm -rf %t/dir-flang-new  && mkdir -p %t/dir-flang-new && %flang_fc1 -fsyntax-only -fdefault-real-8 -module-dir %t/dir-flang-new %s  2>&1
-! RUN: cat %t/dir-flang-new/m.mod | FileCheck %s --check-prefix=REAL8
-! RUN: rm -rf %t/dir-flang-new  && mkdir -p %t/dir-flang-new && %flang_fc1 -fsyntax-only -fdefault-real-8 -fdefault-double-8 -module-dir %t/dir-flang-new %s  2>&1
-! RUN: cat %t/dir-flang-new/m.mod | FileCheck %s --check-prefix=DOUBLE8
+! RUN: rm -rf %t/dir-flang  && mkdir -p %t/dir-flang && %flang_fc1 -fsyntax-only -module-dir %t/dir-flang %s  2>&1
+! RUN: cat %t/dir-flang/m.mod | FileCheck %s --check-prefix=NOOPTION
+! RUN: rm -rf %t/dir-flang  && mkdir -p %t/dir-flang && %flang_fc1 -fsyntax-only -fdefault-real-8 -module-dir %t/dir-flang %s  2>&1
+! RUN: cat %t/dir-flang/m.mod | FileCheck %s --check-prefix=REAL8
+! RUN: rm -rf %t/dir-flang  && mkdir -p %t/dir-flang && %flang_fc1 -fsyntax-only -fdefault-real-8 -fdefault-double-8 -module-dir %t/dir-flang %s  2>&1
+! RUN: cat %t/dir-flang/m.mod | FileCheck %s --check-prefix=DOUBLE8
 ! RUN: not %flang_fc1 -fsyntax-only -fdefault-double-8 %s  2>&1 | FileCheck %s --check-prefix=ERROR
 
 !-----------------------------------------
 ! EXPECTED OUTPUT FOR NO SPECIFICATION
 !-----------------------------------------
 ! NOOPTION: integer(4),parameter::real_kind=4_4
 ! NOOPTION-NEXT: intrinsic::kind
 ! NOOPTION-NEXT: integer(4),parameter::double_kind=8_4

flang/test/Driver/flarge-sizes.f90

 ! Ensure argument -flarge-sizes works as expected.
 ! TODO: Add checks when actual codegen is possible.
 
 !--------------------------
-! FLANG DRIVER (flang-new)
+! FLANG DRIVER (flang)
 !--------------------------
-! RUN: rm -rf %t/dir-flang-new  && mkdir -p %t/dir-flang-new && %flang -fsyntax-only -module-dir %t/dir-flang-new %s  2>&1
-! RUN: cat %t/dir-flang-new/m.mod | FileCheck %s --check-prefix=NOLARGE
-! RUN: rm -rf %t/dir-flang-new  && mkdir -p %t/dir-flang-new && %flang -fsyntax-only -flarge-sizes -module-dir %t/dir-flang-new %s  2>&1
-! RUN: cat %t/dir-flang-new/m.mod | FileCheck %s --check-prefix=LARGE
+! RUN: rm -rf %t/dir-flang  && mkdir -p %t/dir-flang && %flang -fsyntax-only -module-dir %t/dir-flang %s  2>&1
+! RUN: cat %t/dir-flang/m.mod | FileCheck %s --check-prefix=NOLARGE
+! RUN: rm -rf %t/dir-flang  && mkdir -p %t/dir-flang && %flang -fsyntax-only -flarge-sizes -module-dir %t/dir-flang %s  2>&1
+! RUN: cat %t/dir-flang/m.mod | FileCheck %s --check-prefix=LARGE
 
 !-----------------------------------------
-! FRONTEND FLANG DRIVER (flang-new -fc1)
+! FRONTEND FLANG DRIVER (flang -fc1)
 !-----------------------------------------
-! RUN: rm -rf %t/dir-flang-new  && mkdir -p %t/dir-flang-new && %flang_fc1 -fsyntax-only -module-dir %t/dir-flang-new %s  2>&1
-! RUN: cat %t/dir-flang-new/m.mod | FileCheck %s --check-prefix=NOLARGE
-! RUN: rm -rf %t/dir-flang-new  && mkdir -p %t/dir-flang-new && %flang_fc1 -fsyntax-only -flarge-sizes -module-dir %t/dir-flang-new %s  2>&1
-! RUN: cat %t/dir-flang-new/m.mod | FileCheck %s --check-prefix=LARGE
+! RUN: rm -rf %t/dir-flang  && mkdir -p %t/dir-flang && %flang_fc1 -fsyntax-only -module-dir %t/dir-flang %s  2>&1
+! RUN: cat %t/dir-flang/m.mod | FileCheck %s --check-prefix=NOLARGE
+! RUN: rm -rf %t/dir-flang  && mkdir -p %t/dir-flang && %flang_fc1 -fsyntax-only -flarge-sizes -module-dir %t/dir-flang %s  2>&1
+! RUN: cat %t/dir-flang/m.mod | FileCheck %s --check-prefix=LARGE
 
 !-----------------------------------------
 ! EXPECTED OUTPUT WITHOUT -flarge-sizes
 !-----------------------------------------
 ! NOLARGE: real(4)::z(1_8:10_8)
 ! NOLARGE-NEXT: integer(4),parameter::size_kind=4_4
 
 !-----------------------------------------

flang/test/Driver/frontend-forwarding.f90

-! Test that flang-new forwards Flang frontend
-! options to flang-new -fc1 as expected.
+! Test that flang forwards Flang frontend
+! options to flang -fc1 as expected.
 
 ! RUN: %flang -fsyntax-only -### %s -o %t 2>&1 \
 ! RUN:     -finput-charset=utf-8 \
 ! RUN:     -fdefault-double-8 \
 ! RUN:     -fdefault-integer-8 \
 ! RUN:     -fdefault-real-8 \
 ! RUN:     -flarge-sizes \
 ! RUN:     -mllvm -print-before-all\

flang/test/Driver/intrinsic-module-path.f90

 ! Ensure argument -fintrinsic-modules-path works as expected.
 ! WITHOUT the option, the default location for the module is checked and no error generated.
 ! With the option GIVEN, the module with the same name is PREPENDED, and considered over the
 ! default one, causing a CHECKSUM error.
 
 !-----------------------------------------
-! FRONTEND FLANG DRIVER (flang-new -fc1)
+! FRONTEND FLANG DRIVER (flang -fc1)
 !-----------------------------------------
 ! RUN: %flang_fc1 -fsyntax-only %s  2>&1 | FileCheck %s --allow-empty --check-prefix=WITHOUT
 ! RUN: not %flang_fc1 -fsyntax-only -fintrinsic-modules-path %S/Inputs/ %s  2>&1 | FileCheck %s --check-prefix=GIVEN
 
 !-----------------------------------------
 ! EXPECTED OUTPUT WITHOUT
 !-----------------------------------------
 ! WITHOUT-NOT: 'ieee_arithmetic.mod' was not found

flang/test/Driver/macro-def-undef.F90

 ! Ensure arguments -D and -U work as expected.
 
 !--------------------------
-! FLANG DRIVER (flang-new)
+! FLANG DRIVER (flang)
 !--------------------------
 ! RUN: %flang -E -P %s  2>&1 | FileCheck %s --check-prefix=UNDEFINED
 ! RUN: %flang -E -P -DX=A %s  2>&1 | FileCheck %s --check-prefix=DEFINED
 ! RUN: %flang -E -P -DX=A -UX %s  2>&1 | FileCheck %s --check-prefix=UNDEFINED
 
 !-----------------------------------------
-! FRONTEND FLANG DRIVER (flang-new -fc1)
+! FRONTEND FLANG DRIVER (flang -fc1)
 !-----------------------------------------
 ! RUN: %flang_fc1 -E -P %s  2>&1 | FileCheck %s --check-prefix=UNDEFINED
 ! RUN: %flang_fc1 -E -P -DX=A %s  2>&1 | FileCheck %s --check-prefix=DEFINED
 ! RUN: %flang_fc1 -E -P -DX -UX %s  2>&1 | FileCheck %s --check-prefix=UNDEFINED
 
 !--------------------------------------------
 ! EXPECTED OUTPUT FOR AN UNDEFINED MACRO
 !--------------------------------------------

flang/test/Driver/missing-input.f90

 ! Test the behaviour of the driver when input is missing or is invalid. Note
-! that with the compiler driver (flang-new), the input _has_ to be specified.
+! that with the compiler driver (flang), the input _has_ to be specified.
 ! Indeed, the driver decides what "job/command" to create based on the input
 ! file's extension. No input file means that it doesn't know what to do
-! (compile?  preprocess? link?). The frontend driver (flang-new -fc1) simply
+! (compile?  preprocess? link?). The frontend driver (flang -fc1) simply
 ! assumes that "no explicit input == read from stdin"
 
 !--------------------------
-! FLANG DRIVER (flang-new)
+! FLANG DRIVER (flang)
 !--------------------------
 ! RUN: not %flang  2>&1 | FileCheck %s --check-prefix=FLANG-NO-FILE
 ! RUN: not %flang %t.f90 2>&1 | FileCheck %s --check-prefix=FLANG-NONEXISTENT-FILE
 
 !-----------------------------------------
-! FLANG FRONTEND DRIVER (flang-new -fc1)
+! FLANG FRONTEND DRIVER (flang -fc1)
 !-----------------------------------------
 ! RUN: not %flang_fc1 %t.f90 2>&1  | FileCheck %s --check-prefix=FLANG-FC1-NONEXISTENT-FILE
 ! RUN: not %flang_fc1 %S 2>&1  | FileCheck %s --check-prefix=FLANG-FC1-DIR
 
 !-----------------------
 ! EXPECTED OUTPUT
 !-----------------------
-! FLANG-NO-FILE: flang-new: error: no input files
+! FLANG-NO-FILE: error: no input files
 
-! FLANG-NONEXISTENT-FILE: flang-new: error: no such file or directory: {{.*}}
-! FLANG-NONEXISTENT-FILE: flang-new: error: no input files
+! FLANG-NONEXISTENT-FILE: error: no such file or directory: {{.*}}
+! FLANG-NONEXISTENT-FILE: error: no input files
 
 ! FLANG-FC1-NONEXISTENT-FILE: error: {{.*}} does not exist
 ! FLANG-FC1-DIR: error: {{.*}} is not a regular file

flang/test/Driver/predefined-macros-compiler-version.F90

 ! Check that the driver correctly defines macros with the compiler version
 
 !--------------------------
-! FLANG DRIVER (flang-new)
+! FLANG DRIVER (flang)
 !--------------------------
 ! RUN: %flang_fc1 -E %s  2>&1 | FileCheck %s --ignore-case
 
 !-----------------------------------------
-! FRONTEND FLANG DRIVER (flang-new -fc1)
+! FRONTEND FLANG DRIVER (flang -fc1)
 !-----------------------------------------
 ! RUN: %flang_fc1 -E %s  2>&1 | FileCheck %s --ignore-case
 
 !-----------------
 ! EXPECTED OUTPUT
 !-----------------
 ! CHECK: flang = 1
 ! CHECK: flang_major = {{[1-9][0-9]*$}}
 ! CHECK: flang_minor = {{[0-9]+$}}
 ! CHECK: flang_patchlevel = {{[0-9]+$}}
 
 integer, parameter :: flang = __flang__
 integer, parameter :: flang_major = __flang_major__
 integer, parameter :: flang_minor = __flang_minor__
 integer, parameter :: flang_patchlevel = __flang_patchlevel__

flang/test/Driver/std2018-wrong.f90

 ! Ensure argument -std=f2018 works as expected.
 
 !-----------------------------------------
-! FRONTEND FLANG DRIVER (flang-new -fc1)
+! FRONTEND FLANG DRIVER (flang -fc1)
 !-----------------------------------------
 ! RUN: not %flang_fc1 -std=90 %s  2>&1 | FileCheck %s --check-prefix=WRONG
 
 !-----------------------------------------
 ! EXPECTED OUTPUT WITH WRONG
 !-----------------------------------------
 ! WRONG: Only -std=f2018 is allowed currently.

flang/test/Driver/std2018.f90

 ! Ensure argument -std=f2018 works as expected.
 
 !-----------------------------------------
-! FRONTEND FLANG DRIVER (flang-new -fc1)
+! FRONTEND FLANG DRIVER (flang -fc1)
 !-----------------------------------------
 ! RUN: %flang_fc1 -fsyntax-only %s  2>&1 | FileCheck %s --allow-empty --check-prefix=WITHOUT
 ! RUN: %flang_fc1 -fsyntax-only -std=f2018 %s  2>&1 | FileCheck %s --check-prefix=GIVEN
 ! RUN: %flang_fc1 -fsyntax-only -pedantic %s  2>&1 | FileCheck %s --check-prefix=GIVEN
 
 !-----------------------------------------
 ! EXPECTED OUTPUT WITHOUT
 !-----------------------------------------

flang/test/Driver/use-module-error.f90

 ! Ensure that multiple module directories are not allowed
 
 !--------------------------
-! FLANG DRIVER (flang-new)
+! FLANG DRIVER (flang)
 !--------------------------
 ! RUN: not %flang -fsyntax-only -J %S/Inputs/module-dir -J %S/Inputs/ %s  2>&1 | FileCheck %s --check-prefix=DOUBLEINCLUDE
 ! RUN: not %flang -fsyntax-only -J %S/Inputs/module-dir -module-dir %S/Inputs/ %s 2>&1 | FileCheck %s --check-prefix=DOUBLEINCLUDE
 ! RUN: not %flang -fsyntax-only -module-dir %S/Inputs/module-dir -J%S/Inputs/ %s 2>&1 | FileCheck %s --check-prefix=DOUBLEINCLUDE
 
 !-----------------------------------------
-! FRONTEND FLANG DRIVER (flang-new -fc1)
+! FRONTEND FLANG DRIVER (flang -fc1)
 !-----------------------------------------
 ! RUN: not %flang_fc1 -fsyntax-only -J %S/Inputs/module-dir -J %S/Inputs/ %s 2>&1 | FileCheck %s --check-prefix=DOUBLEINCLUDE
 ! RUN: not %flang_fc1 -fsyntax-only -J %S/Inputs/module-dir -module-dir %S/Inputs/ %s 2>&1 | FileCheck %s --check-prefix=DOUBLEINCLUDE
 ! RUN: not %flang_fc1 -fsyntax-only -module-dir %S/Inputs/module-dir -J%S/Inputs/ %s 2>&1 | FileCheck %s --check-prefix=DOUBLEINCLUDE
 
 !-----------------------------------------
 ! EXPECTED OUTPUT FOR MISSING MODULE FILE
 !-----------------------------------------
 ! DOUBLEINCLUDE:error: Only one '-module-dir/-J' option allowed
 
 program too_many_module_dirs
 end

flang/test/Driver/use-module.f90

 ! Checks that module search directories specified with `-J/-module-dir` and `-I` are handled correctly
 
 !--------------------------
-! FLANG DRIVER (flang-new)
+! FLANG DRIVER (flang)
 !--------------------------
 ! RUN: %flang -fsyntax-only -I %S/Inputs -I %S/Inputs/module-dir %s  2>&1 | FileCheck %s --check-prefix=INCLUDED --allow-empty
 ! RUN: %flang -fsyntax-only -I %S/Inputs -J %S/Inputs/module-dir %s 2>&1 | FileCheck %s --check-prefix=INCLUDED --allow-empty
 ! RUN: %flang -fsyntax-only -I %S/Inputs -module-dir %S/Inputs/module-dir %s  2>&1 | FileCheck %s --check-prefix=INCLUDED --allow-empty
 
 ! RUN: not %flang -fsyntax-only -I %S/Inputs %s  2>&1 | FileCheck %s --check-prefix=MISSING_MOD2
 ! RUN: not %flang -fsyntax-only -J %S/Inputs %s  2>&1 | FileCheck %s --check-prefix=MISSING_MOD2
 ! RUN: not %flang -fsyntax-only -module-dir %S/Inputs %s  2>&1 | FileCheck %s --check-prefix=MISSING_MOD2
 
 ! RUN: not %flang -fsyntax-only -I %S/Inputs/module-dir %s  2>&1 | FileCheck %s --check-prefix=SINGLEINCLUDE
 ! RUN: not %flang -fsyntax-only -J %S/Inputs/module-dir %s  2>&1 | FileCheck %s --check-prefix=SINGLEINCLUDE
 ! RUN: not %flang -fsyntax-only -module-dir %S/Inputs/module-dir %s  2>&1 | FileCheck %s --check-prefix=SINGLEINCLUDE
 
 !-----------------------------------------
-! FRONTEND FLANG DRIVER (flang-new -fc1)
+! FRONTEND FLANG DRIVER (flang -fc1)
 !-----------------------------------------
 ! RUN: %flang_fc1 -fsyntax-only -I %S/Inputs -I %S/Inputs/module-dir %s  2>&1 | FileCheck %s --check-prefix=INCLUDED --allow-empty
 ! RUN: %flang_fc1 -fsyntax-only -I %S/Inputs -J %S/Inputs/module-dir %s 2>&1 | FileCheck %s --check-prefix=INCLUDED --allow-empty
 ! RUN: %flang_fc1 -fsyntax-only -I %S/Inputs -module-dir %S/Inputs/module-dir %s  2>&1 | FileCheck %s --check-prefix=INCLUDED --allow-empty
 
 ! RUN: not %flang_fc1 -fsyntax-only -I %S/Inputs %s  2>&1 | FileCheck %s --check-prefix=MISSING_MOD2
 ! RUN: not %flang_fc1 -fsyntax-only -J %S/Inputs %s  2>&1 | FileCheck %s --check-prefix=MISSING_MOD2
 ! RUN: not %flang_fc1 -fsyntax-only -module-dir %S/Inputs %s  2>&1 | FileCheck %s --check-prefix=MISSING_MOD2

flang/test/Frontend/multiple-input-files.f90

 
 !--------------------------
 ! FLANG DRIVER (flang)
 !--------------------------
 ! NOTE: Use `-E` so that the compiler driver stops after the 1st compilation phase, preprocessing. That's all we need.
 
 ! TEST 1: Both input files are processed (output is printed to stdout)
 ! RUN: %flang -E %s %S/Inputs/hello-world.f90 | FileCheck %s --match-full-lines -check-prefix=FLANG
 
 ! TEST 2: None of the files is processed (not possible to specify the output file when multiple input files are present)
-! RUN: not %flang -E -o - %S/Inputs/hello-world.f90 %s  2>&1 | FileCheck %s --match-full-lines -check-prefix=ERROR
-! RUN: not %flang -E -o %t %S/Inputs/hello-world.f90 %s 2>&1 | FileCheck %s --match-full-lines -check-prefix=ERROR
+! RUN: not %flang -E -o - %S/Inputs/hello-world.f90 %s  2>&1 | FileCheck %s -check-prefix=ERROR
+! RUN: not %flang -E -o %t %S/Inputs/hello-world.f90 %s 2>&1 | FileCheck %s -check-prefix=ERROR
 
 !----------------------------------------
 ! FLANG FRONTEND DRIVER (flang -fc1)
 !----------------------------------------
 ! TEST 3: Both input files are processed
 ! This particular test case generates output files in the same directory as the input files. We need to copy the input files into a
 ! temporary directory to avoid polluting the source directory.
 ! RUN: rm -rf %t-dir && mkdir -p %t-dir && cd %t-dir

 ! FLANG-NEXT:  End Program arithmetic
 
 ! FLANG-LABEL: program hello
 ! FLANG-NEXT:  implicit none
 ! FLANG-NEXT:  write(*,*) 'Hello world!'
 ! FLANG-NEXT:end program hello
 
 ! TEST 2: `-o` does not when multiple input files are present
-! ERROR: flang-new: error: cannot specify -o when generating multiple output files
+! ERROR: error: cannot specify -o when generating multiple output files
 
 ! TEST 3: The output file _was not_ specified - `flang_fc1` will process all
 ! input files and generate one output file for every input file.
 ! FC1-OUTPUT1-LABEL: Program arithmetic
 ! FC1-OUTPUT1-NEXT:    Integer :: i, j
 ! FC1-OUTPUT1-NEXT:    i = 2; j = 3; i= i * j;
 ! FC1-OUTPUT1-NEXT:  End Program arithmetic
 

flang/test/Lower/Intrinsics/command_argument_count.f90

 ! RUN: bbc -emit-fir %s -o - | FileCheck %s
-! bbc doesn't have a way to set the default kinds so we use flang-new driver
-! RUN: flang-new -fc1 -fdefault-integer-8 -emit-fir %s -o - | FileCheck --check-prefixes=CHECK,CHECK-64  %s
+! bbc doesn't have a way to set the default kinds so we use flang driver
+! RUN: flang -fc1 -fdefault-integer-8 -emit-fir %s -o - | FileCheck --check-prefixes=CHECK,CHECK-64  %s
 
 ! CHECK-LABEL: argument_count_test
 subroutine argument_count_test()
 integer :: arg_count_test
 arg_count_test = command_argument_count()
 ! CHECK: %[[argumentCount:.*]] = fir.call @_FortranAArgumentCount() : () -> i32
 ! CHECK-64: %{{[0-9]+}} = fir.convert %[[argumentCount]] : (i32) -> i64
 end subroutine argument_count_test

flang/test/Lower/Intrinsics/exit.f90

 ! RUN: bbc -emit-fir %s -o - | FileCheck --check-prefixes=CHECK,CHECK-32 -DDEFAULT_INTEGER_SIZE=32 %s
-! bbc doesn't have a way to set the default kinds so we use flang-new driver
-! RUN: flang-new -fc1 -fdefault-integer-8 -emit-fir %s -o - | FileCheck --check-prefixes=CHECK,CHECK-64 -DDEFAULT_INTEGER_SIZE=64 %s
+! bbc doesn't have a way to set the default kinds so we use flang driver
+! RUN: flang -fc1 -fdefault-integer-8 -emit-fir %s -o - | FileCheck --check-prefixes=CHECK,CHECK-64 -DDEFAULT_INTEGER_SIZE=64 %s
 
 ! CHECK-LABEL: func @_QPexit_test1() {
 subroutine exit_test1
     call exit()
   ! CHECK: %[[status:.*]] = arith.constant 0 : i[[DEFAULT_INTEGER_SIZE]]
   ! CHECK-64: %[[statusConvert:.*]] = fir.convert %[[status]] : (i64) -> i32
   ! CHECK-32: %{{[0-9]+}} = fir.call @_FortranAExit(%[[status]]) : (i32) -> none
   ! CHECK-64: %{{[0-9]+}} = fir.call @_FortranAExit(%[[statusConvert]]) : (i32) -> none

flang/test/Lower/Intrinsics/get_command_argument.f90

 ! RUN: bbc -emit-fir %s -o - | FileCheck --check-prefixes=CHECK,CHECK-32 -DDEFAULT_INTEGER_SIZE=32 %s
-! RUN: flang-new -fc1 -fdefault-integer-8 -emit-fir %s -o - | FileCheck --check-prefixes=CHECK,CHECK-64 -DDEFAULT_INTEGER_SIZE=64 %s
+! RUN: flang -fc1 -fdefault-integer-8 -emit-fir %s -o - | FileCheck --check-prefixes=CHECK,CHECK-64 -DDEFAULT_INTEGER_SIZE=64 %s
 
 ! CHECK-LABEL: func @_QPnumber_only(
 ! CHECK-SAME: %[[num:.*]]: !fir.ref<i[[DEFAULT_INTEGER_SIZE]]>{{.*}}) {
 subroutine number_only(num)
     integer :: num
     call get_command_argument(num)
 ! CHECK-NOT: fir.call @_FortranAArgumentValue
 ! CHECK-NOT: fir.call @_FortranAArgumentLength

flang/test/Lower/Intrinsics/get_environment_variable.f90

 ! RUN: bbc -emit-fir %s -o - | FileCheck --check-prefixes=CHECK,CHECK-32 -DDEFAULT_INTEGER_SIZE=32 %s
-! RUN: flang-new -fc1 -fdefault-integer-8 -emit-fir %s -o - | FileCheck --check-prefixes=CHECK,CHECK-64 -DDEFAULT_INTEGER_SIZE=64 %s
+! RUN: flang -fc1 -fdefault-integer-8 -emit-fir %s -o - | FileCheck --check-prefixes=CHECK,CHECK-64 -DDEFAULT_INTEGER_SIZE=64 %s
 
 ! CHECK-LABEL: func @_QPnumber_only(
 ! CHECK-SAME: %[[nameArg:.*]]: !fir.boxchar<1> {fir.bindc_name = "name"}) {
 subroutine number_only(name)
     character(len=32) :: name
     call get_environment_variable(name)
 ! CHECK-NOT: fir.call @_FortranAEnvVariableValue
 ! CHECK-NOT: fir.call @_FortranAEnvVariableLength

flang/test/Lower/OpenACC/Todo/acc-declare.f90

 ! This test checks lowering of OpenACC declare Directive.
 
-// RUN: not flang-new -fc1 -emit-fir -fopenacc %s 2>&1 | FileCheck %s
+// RUN: not flang -fc1 -emit-fir -fopenacc %s 2>&1 | FileCheck %s
 
 program main
   real, dimension(10) :: aa, bb
 
   // CHECK: not yet implemented: OpenACC Standalone Declarative construct
   !$acc declare present(aa, bb)
 end

flang/test/Lower/OpenACC/Todo/acc-routine.f90

 ! This test checks lowering of OpenACC routine Directive.
 
-// RUN: not flang-new -fc1 -emit-fir -fopenacc %s 2>&1 | FileCheck %s
+// RUN: not flang -fc1 -emit-fir -fopenacc %s 2>&1 | FileCheck %s
 
 program main
   // CHECK: not yet implemented: OpenACC Routine construct not lowered yet!
   !$acc routine(sub) seq
 contains
   subroutine sub(a)
     real :: a(:)
   end
 end

flang/test/Lower/OpenMP/Todo/omp-declarative-allocate.f90

 ! This test checks lowering of OpenMP allocate Directive.
 
-// RUN: not flang-new -fc1 -emit-fir -fopenmp %s 2>&1 | FileCheck %s
+// RUN: not flang -fc1 -emit-fir -fopenmp %s 2>&1 | FileCheck %s
 
 program main
   integer :: x, y
 
   // CHECK: not yet implemented: OpenMPDeclarativeAllocate
   !$omp allocate(x, y)
 end

flang/test/Lower/OpenMP/Todo/omp-declare-reduction.f90

 ! This test checks lowering of OpenMP declare reduction Directive.
 
-// RUN: not flang-new -fc1 -emit-fir -fopenmp %s 2>&1 | FileCheck %s
+// RUN: not flang -fc1 -emit-fir -fopenmp %s 2>&1 | FileCheck %s
 
 subroutine declare_red()
   integer :: my_var
   // CHECK: not yet implemented: OpenMPDeclareReductionConstruct
   !$omp declare reduction (my_red : integer : omp_out = omp_in) initializer (omp_priv = 0)
   my_var = 0
 end subroutine declare_red

flang/test/Lower/OpenMP/Todo/omp-declare-simd.f90

 ! This test checks lowering of OpenMP declare simd Directive.
 
-// RUN: not flang-new -fc1 -emit-fir -fopenmp %s 2>&1 | FileCheck %s
+// RUN: not flang -fc1 -emit-fir -fopenmp %s 2>&1 | FileCheck %s
 
 subroutine sub(x, y)
   real, intent(inout) :: x, y
 
   // CHECK: not yet implemented: OpenMPDeclareSimdConstruct
   !$omp declare simd(sub) aligned(x)
   x = 3.14 + y
 end

flang/test/Lower/OpenMP/Todo/omp-declare-target.f90

 ! This test checks lowering of OpenMP declare target Directive.
 
-// RUN: not flang-new -fc1 -emit-fir -fopenmp %s 2>&1 | FileCheck %s
+// RUN: not flang -fc1 -emit-fir -fopenmp %s 2>&1 | FileCheck %s
 
 module mod1
 contains
   subroutine sub()
     integer :: x, y
     // CHECK: not yet implemented: OpenMPDeclareTargetConstruct
     !$omp declare target
   end
 end module

flang/test/Lower/OpenMP/Todo/omp-threadprivate.f90

 ! This test checks lowering of OpenMP threadprivate Directive.
 
-// RUN: not flang-new -fc1 -emit-fir -fopenmp %s 2>&1 | FileCheck %s
+// RUN: not flang -fc1 -emit-fir -fopenmp %s 2>&1 | FileCheck %s
 
 program main
   integer, save :: x, y
 
 // CHECK: not yet implemented: OpenMPThreadprivate
   !$omp threadprivate(x, y)
 end

flang/test/lit.cfg.py

if config.flang_standalone_build:
     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 = [
-        ToolSubst('%flang', command=FindTool('flang-new'), unresolved='fatal'),
-    ToolSubst('%flang_fc1', command=FindTool('flang-new'), extra_args=['-fc1'],
+        ToolSubst('%flang', command=FindTool('flang'), unresolved='fatal'),
+    ToolSubst('%flang_fc1', command=FindTool('flang'), extra_args=['-fc1'],
         unresolved='fatal')]
 
 # Flang has several unimplemented features. TODO messages are used to mark and fail if these
 # features are exercised. TODOs exit with an error in non-assert builds but in assert builds
 # it aborts. To catch aborts, the `--crash` option for the `not` command has to be used.
 if 'asserts' in config.available_features:
     tools.append(ToolSubst('%not_todo_cmd', command=FindTool('not'), extra_args=['--crash'],
         unresolved='fatal'))

flang/tools/f18/CMakeLists.txt

else()
     endif()
     if(${filename} STREQUAL "ieee_arithmetic" OR
        ${filename} STREQUAL "ieee_exceptions")
       set(depends ${FLANG_INTRINSIC_MODULES_DIR}/__fortran_ieee_exceptions.mod)
     endif()
   endif()
   add_custom_command(OUTPUT ${base}.mod
     COMMAND ${CMAKE_COMMAND} -E make_directory ${FLANG_INTRINSIC_MODULES_DIR}
-    COMMAND flang-new -fc1 -fsyntax-only -module-dir ${FLANG_INTRINSIC_MODULES_DIR}
+    COMMAND flang -fc1 -fsyntax-only -module-dir ${FLANG_INTRINSIC_MODULES_DIR}
       ${FLANG_SOURCE_DIR}/module/${filename}.f90
-    DEPENDS flang-new ${FLANG_SOURCE_DIR}/module/${filename}.f90 ${depends}
+    DEPENDS flang ${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 "${CMAKE_INSTALL_INCLUDEDIR}/flang")
 endforeach()
 
 add_custom_target(module_files ALL DEPENDS ${MODULE_FILES})
 
-# This flang shell script will only work in a POSIX shell.
+# The flang-to-gfortan shell script will only work in a POSIX shell.
 if (NOT WIN32)
   add_custom_command(
-    OUTPUT ${CMAKE_BINARY_DIR}/bin/flang
-    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/flang
-    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/flang ${CMAKE_BINARY_DIR}/bin)
-  add_custom_target(flang ALL DEPENDS ${CMAKE_BINARY_DIR}/bin/flang)
-  install(PROGRAMS ${CMAKE_BINARY_DIR}/bin/flang DESTINATION "${CMAKE_INSTALL_BINDIR}")
+    OUTPUT ${CMAKE_BINARY_DIR}/bin/flang-to-gfortran
+    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/flang-to-gfortran
+    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/flang-to-gfortran ${CMAKE_BINARY_DIR}/bin)
+  add_custom_target(flang-to-gfortran ALL DEPENDS ${CMAKE_BINARY_DIR}/bin/flang-to-gfortran)
+  install(PROGRAMS ${CMAKE_BINARY_DIR}/bin/flang-to-gfortran DESTINATION "${CMAKE_INSTALL_BINDIR}")
 endif()
 
 # TODO Move this to a more suitable location
 file(COPY ${FLANG_SOURCE_DIR}/module/omp_lib.h DESTINATION "${CMAKE_BINARY_DIR}/include/flang/OpenMP/" FILE_PERMISSIONS OWNER_READ OWNER_WRITE)

flang/tools/f18/flang-to-gfortran

 #! /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 FLANG_FC environment variable) to
 #   compile the unparsed source files
 #
 # Tested with Bash 4.4. This script will exit immediately if you use an
 # older version of Bash.
 #===------------------------------------------------------------------------===#
 set -euo pipefail
 
 # Global variables to make the parsing of input arguments a bit easier
 INPUT_FILES=()
 OPTIONS=()
 OUTPUT_FILE=""
 MODULE_DIR=""
 INTRINSICS_MOD_DIR=""
 COMPILE_ONLY="False"
 PREPROCESS_ONLY="False"
 PRINT_VERSION="False"
 
 # === check_bash_version ======================================================
 #
 # Checks the Bash version that's used to run this script. Exits immediately
 # with a non-zero return code if it's lower than 4.4. Otherwise returns 0
 # (success).
 # =============================================================================
 check_bash_version() {
   message="Error: Your Bash is too old. Please use Bash >= 4.4"
   # Major version
   [[ "${BASH_VERSINFO[0]:-0}" -lt 4 ]] && echo $message && exit 1
 
   # Minor version
   if [[ "${BASH_VERSINFO[0]}" == 4 ]]; then
     [[ "${BASH_VERSINFO[1]:-0}" -lt 4 ]] && echo $message && exit 1
   fi
 
   return 0
 }
 
 # === parse_args ==============================================================
 #
 # Parse the input arguments passed to this script. Sets the global variables
 # declared at the top.
 #
 # INPUTS:
 #   $1 - all input arguments
 # OUTPUTS:
 #  Saved in the global variables for this script
 # =============================================================================
 parse_args()
 {
   while [ "${1:-}" != "" ]; do
       # CASE 1: Compiler option
       if [[ "${1:0:1}" == "-" ]] ; then
         # Output file - extract it into a global variable
         if [[ "$1" == "-o" ]] ; then
           shift
           OUTPUT_FILE="$1"
           shift
           continue
         fi
 
         # Module directory - extract it into a global variable
         if [[ "$1" == "-module-dir" ]]; then
           shift
           MODULE_DIR="$1"
           shift
           continue
         fi
 
         # Intrinsics module dir - extract it into a global var
         if [[ "$1" == "-intrinsics-module-directory" ]]; then shift
           INTRINSICS_MOD_DIR=$1
           shift
           continue
         fi
 
         # Module suffix cannot be modified - this script defines it before
         # calling the driver.
         if [[ "$1" == "-module-suffix" ]]; then
           echo "ERROR: \'-module-suffix\' is not available when using the \'flang\' script"
           exit 1
         fi
 
         # Special treatment for `J <dir>` and `-I <dir>`. We translate these
         # into `J<dir>` and `-I<dir>` respectively.
         if [[ "$1" == "-J" ]] || [[ "$1" == "-I" ]]; then
           opt=$1
           shift
           OPTIONS+=("$opt$1")
           shift
           continue
         fi
 
         # This is a regular option - just add it to the list.
         OPTIONS+=($1)
         if [[ $1 == "-c" ]]; then
           COMPILE_ONLY="True"
         fi
 
         if [[ $1 == "-E" ]]; then
           PREPROCESS_ONLY="True"
         fi
 
         if [[ $1 == "-v" || $1 == "--version" ]]; then
           PRINT_VERSION="True"
         fi
 
         shift
         continue
 
       # CASE 2: A regular file (either source or a library file)
       elif [[ -f "$1" ]]; then
         INPUT_FILES+=($1)
         shift
         continue
 
       else
         # CASE 3: Unsupported
         echo "ERROR: unrecognised option format: \`$1\`. Perhaps non-existent file?"
         exit 1
       fi
   done
 }
 
 # === categorise_files ========================================================
 #
 # Categorises input files into:
 #   * Fortran source files (to be compiled)
 #   * library files (to be linked into the final executable)
 #
 # INPUTS:
 #   $1 - all input files to be categorised (array, name reference)
 # OUTPUTS:
 #   $2 - Fortran source files extracted from $1 (array, name reference)
 #   $3 - other source files extracted from $1 (array, name reference)
 #   $4 - object files extracted from $1 (array, name reference)
 #   $5 - lib files extracted from $1 (array, name reference)
 # =============================================================================
 categorise_files()
 {
   local -n -r all_files=$1
   local -n fortran_sources=$2
   local -n other_sources=$3
   local -n objects=$4
   local -n libs=$5
 
   for current_file in "${all_files[@]}"; do
     file_ext=${current_file##*.}
     if [[ $file_ext == "f" ]] || [[ $file_ext == "f90" ]] ||
        [[ $file_ext == "f" ]] || [[ $file_ext == "F" ]] || [[ $file_ext == "ff" ]] ||
        [[ $file_ext == "f90" ]] || [[ $file_ext == "F90" ]] || [[ $file_ext == "ff90" ]] ||
        [[ $file_ext == "f95" ]] || [[ $file_ext == "F95" ]] || [[ $file_ext == "ff95" ]] ||
        [[ $file_ext == "cuf" ]] || [[ $file_ext == "CUF" ]] || [[ $file_ext == "f18" ]] ||
        [[ $file_ext == "F18" ]] || [[ $file_ext == "ff18" ]]; then
       fortran_sources+=($current_file)
     elif [[ $file_ext == "a" ]] || [[ $file_ext == "so" ]]; then
       libs+=($current_file)
     elif [[ $file_ext == "o" ]]; then
       objects+=($current_file)
     else
       other_sources+=($current_file)
     fi
   done
 }
 
 # === categorise_opts ==========================================================
 #
 # Categorises compiler options into options for:
 #   * the Flang driver (either new or the "throwaway" driver)
 #   * the external Fortran driver that will generate the code
 # Most options accepted by Flang will be claimed by it. The only exceptions are
 # `-I` and `-J`.
 #
 # INPUTS:
 #   $1 - all compiler options (array, name reference)
 # OUTPUTS:
 #   $2 - compiler options for the Flang driver (array, name reference)
 #   $3 - compiler options for the external driver (array, name reference)
 # =============================================================================
 categorise_opts()
 {
   local -n all_opts=$1
   local -n flang_opts=$2
   local -n fc_opts=$3
 
   for opt in "${all_opts[@]}"; do
     # These options are claimed by Flang, but should've been dealt with in parse_args.
     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`).
       [[ $opt == "-cpp" ]] ||
       [[ $opt =~ ^-D.* ]] ||
       [[ $opt == "-E" ]] ||
       [[ $opt == "-falternative-parameter-statement" ]] ||
       [[ $opt == "-fbackslash" ]] ||
       [[ $opt == "-fcolor-diagnostics" ]] ||
       [[ $opt == "-fdefault-double-8" ]] ||
       [[ $opt == "-fdefault-integer-8" ]] ||
       [[ $opt == "-fdefault-real-8" ]] ||
       [[ $opt == "-ffixed-form" ]] ||
       [[ $opt =~ ^-ffixed-line-length=.* ]] ||
       [[ $opt == "-ffree-form" ]] ||
       [[ $opt == "-fimplicit-none" ]] ||
       [[ $opt =~ ^-finput-charset=.* ]] ||
       [[ $opt == "-flarge-sizes" ]] ||
       [[ $opt == "-flogical-abbreviations" ]] ||
       [[ $opt == "-fno-color-diagnostics" ]] ||
       [[ $opt == "-fxor-operator" ]] ||
       [[ $opt == "-help" ]] ||
       [[ $opt == "-nocpp" ]] ||
       [[ $opt == "-pedantic" ]] ||
       [[ $opt =~ ^-std=.* ]] ||
       [[ $opt =~ ^-U.* ]] ||
       [[ $opt == "-Werror" ]]; then
       flang_opts+=($opt)
     elif
       # We translate the following into equivalents understood by `flang-new`
       [[ $opt == "-Mfixed" ]] || [[ $opt == "-Mfree" ]]; then
         case $opt in
           -Mfixed)
             flang_opts+=("-ffixed-form")
           ;;
 
           -Mfree)
             flang_opts+=("-ffree-form")
           ;;
 
         *)
           echo "ERROR: $opt has no equivalent in 'flang-new'"
           exit 1
           ;;
       esac
     elif
       # Options that are needed for both Flang and the external driver.
       [[ $opt =~ -I.* ]] ||
       [[ $opt =~ -J.* ]] ||
       [[ $opt == "-fopenmp" ]] ||
       [[ $opt == "-fopenacc" ]]; then
       flang_opts+=($opt)
       fc_opts+=($opt)
     else
       # All other options are claimed for the external driver.
       fc_opts+=($opt)
     fi
   done
 }
 
 # === get_external_fc_name ====================================================
 #
 # Returns the name of external Fortran compiler based on values of
 # environment variables.
 # =============================================================================
 get_external_fc_name() {
   if [[ -v FLANG_FC ]]; then
     echo ${FLANG_FC}
   elif [[ -v F18_FC ]]; then
     # We support F18_FC for backwards compatibility.
     echo ${F18_FC}
   else
     echo gfortran
   fi
 }
 
 # === preprocess ==============================================================
 #
 # Runs the preprocessing. Fortran files are preprocessed using Flang. Other
 # files are preprocessed using the external Fortran compiler.
 #
 # INPUTS:
 #   $1 - Fortran source files (array, name reference)
 #   $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 ext_fc="$(get_external_fc_name)"
 
   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-new" -E "${opts[@]}" "${fortran_srcs[$idx]}" ${output_definition:+$output_definition}
     then status=$?
          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=$?
          echo flang: in "$PWD", flang-new failed with exit status $status: "$wd/bin/flang-new" "${opts[@]}" "$@" >&2
          exit $status
     fi
   done
 }
 
 # === get_relocatable_name ======================================================
 # This method generates the name of the output file for the compilation phase
 # (triggered with `-c`). If the user of this script is only interested in
 # compilation (`flang -c`), use $OUTPUT_FILE provided that it was defined.
 # Otherwise, use the usual heuristics:
 #   * file.f --> file.o
 #   * file.c --> file.o
 #
 # INPUTS:
 #   $1 - input source file for which to generate the output name
 # =============================================================================
 get_relocatable_name() {
   local -r src_file=$1
 
   if [[ $COMPILE_ONLY == "True" ]] && [[ ! -z ${OUTPUT_FILE:+x} ]]; then
     out_file="$OUTPUT_FILE"
   else
     current_ext=${src_file##*.}
     new_ext="o"
 
     out_file=$(basename "${src_file}" "$current_ext")${new_ext}
   fi
 
   echo "$out_file"
 }
 
 # === main ====================================================================
 # Main entry point for this script
 # =============================================================================
 main() {
   check_bash_version
   parse_args "$@"
 
   if [[ $PRINT_VERSION == "True" ]]; then
     echo "flang version @FLANG_VERSION@"
     exit 0
   fi
 
   # Source, object and library files provided by the user
   local fortran_source_files=()
   local other_source_files=()
   local object_files=()
   local lib_files=()
   categorise_files INPUT_FILES fortran_source_files other_source_files object_files lib_files
 
   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).
   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)
 
   # uuidgen is common but not installed by default on some distros
   if ! command -v uuidgen &> /dev/null
   then
     echo "uuidgen is required for generating unparsed file names."
     exit 1
   fi
 
   # 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-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-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
   local ext_fc="$(get_external_fc_name)"
   # Temporary object files generated by this script. To be deleted at the end.
   local temp_object_files=()
   for idx in "${!fortran_source_files[@]}"; do
     # We always have to specify the output name with `-o <out_obj_file>`. This
     # is because we are using the unparsed rather than the original source file
     # below. As a result, we cannot rely on the compiler-generated output name.
     out_obj_file=$(get_relocatable_name "${fortran_source_files[$idx]}")
 
     set +e
     $ext_fc "-c" "${ext_fc_options[@]}" "${unparsed_file_base}_${idx}.f90" "-o" "${out_obj_file}"
     ret_status=$?
     set -e
     if [[ $ret_status != 0 ]]; then
       echo flang: in "$PWD", "$ext_fc" failed with exit status "$ret_status": "$ext_fc" "${ext_fc_options[@]}" "$@" >&2
          exit "$ret_status"
     fi
     temp_object_files+=(${out_obj_file})
   done
 
   # Delete the unparsed files
   for idx in "${!fortran_source_files[@]}"; do
     rm "${unparsed_file_base}_${idx}.f90"
   done
 
   # STEP 3: Compile Other Source Files
   for idx in "${!other_source_files[@]}"; do
     # We always specify the output name with `-o <out_obj_file>`. The user
     # might have used `-o`, but we never add it to $OPTIONS (or
     # $ext_fc_options). Hence we need to use `get_relocatable_name`.
     out_obj_file=$(get_relocatable_name "${other_source_files[$idx]}")
 
     set +e
     $ext_fc "-c" "${ext_fc_options[@]}" "${other_source_files[${idx}]}" "-o" "${out_obj_file}"
     ret_status=$?
     set -e
     if [[ $ret_status != 0 ]]; then
       echo flang: in "$PWD", "$ext_fc" failed with exit status "$ret_status": "$ext_fc" "${ext_fc_options[@]}" "$@" >&2
          exit "$ret_status"
     fi
     temp_object_files+=(${out_obj_file})
   done
 
   # STEP 4: Link
   if [[ $COMPILE_ONLY == "True" ]]; then
     exit 0;
   fi
 
   if [[ ${#temp_object_files[@]} -ge 1 ]] || [[ ${#object_files[@]} -ge 1 ]] ; then
     # If $OUTPUT_FILE was specified, use it for the output name.
     if [[ ! -z ${OUTPUT_FILE:+x} ]]; then
       output_definition="-o $OUTPUT_FILE"
     else
       output_definition=""
     fi
 
     set +e
     $ext_fc "${ext_fc_options[@]}" "${object_files[@]}" "${temp_object_files[@]}" "${lib_files[@]}" ${output_definition:+$output_definition}
     ret_status=$?
     set -e
     if [[ $ret_status != 0 ]]; then
          echo flang: in "$PWD", "$ext_fc" failed with exit status "$ret_status": "$ext_fc" "${ext_fc_options[@]}" "$@" >&2
          exit "$ret_status"
     fi
   fi
 
   # Delete intermediate object files
   for idx in "${!fortran_source_files[@]}"; do
     rm "${temp_object_files[$idx]}"
   done
 }
 
 main "${@}"

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
 )
 
-add_flang_tool(flang-new
+add_flang_tool(flang
   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
+target_link_libraries(flang
   PRIVATE
   flangFrontend
   flangFrontendTool
 )
 
-clang_target_link_libraries(flang-new
+clang_target_link_libraries(flang
   PRIVATE
   clangDriver
   clangBasic
 )
 
+if(WIN32 AND NOT CYGWIN)
+  # Prevent versioning if the buildhost is targeting for Win32.
+else()
+  set_target_properties(flang PROPERTIES VERSION ${FLANG_EXECUTABLE_VERSION})
+endif()
+
 option(FLANG_PLUGIN_SUPPORT "Build Flang with plugin support." ON)
 
-# Enable support for plugins, which need access to symbols from flang-new
+# Enable support for plugins, which need access to symbols from flang
 if(FLANG_PLUGIN_SUPPORT)
-  export_executable_symbols_for_plugins(flang-new)
+  export_executable_symbols_for_plugins(flang)
 endif()
 
-install(TARGETS flang-new DESTINATION "${CMAKE_INSTALL_BINDIR}")
+# For backwords compatibility
+add_flang_symlink(flang-new flang)
+
+install(TARGETS flang DESTINATION "${CMAKE_INSTALL_BINDIR}")

flang/tools/flang-driver/driver.cpp

int main(int argc, const char **argv) {
 
   // Initialize variables to call the driver
   llvm::InitLLVM x(argc, argv);
   llvm::SmallVector<const char *, 256> args(argv, argv + argc);
 
   clang::driver::ParsedClangName targetandMode("flang", "--driver-mode=flang");
   std::string driverPath = getExecutablePath(args[0]);
 
-  // Check if flang-new is in the frontend mode
+  // Check if flang is in the frontend mode
   auto firstArg = std::find_if(
       args.begin() + 1, args.end(), [](const char *a) { return a != nullptr; });
   if (firstArg != args.end()) {
     if (llvm::StringRef(args[1]).startswith("-cc1")) {
       llvm::errs() << "error: unknown integrated tool '" << args[1] << "'. "
                    << "Valid tools include '-fc1'.\n";
       return 1;
     }
-    // Call flang-new frontend
+    // Call flang frontend
     if (llvm::StringRef(args[1]).startswith("-fc1")) {
       return executeFC1Tool(args);
     }
   }
 
   // Not in the frontend mode - continue in the compiler driver mode.
 
   // Create DiagnosticsEngine for the compiler driver