Skip to content

Commit 06eb10d

Browse files
everythingfunctionalh-vetinaribanach-space
authored
[flang][driver] rename flang-new to flang (#110023)
This does a global rename from `flang-new` to `flang`. I also removed/changed any TODOs that I found related to making this change. --------- Co-authored-by: H. Vetinari <[email protected]> Co-authored-by: Andrzej Warzynski <[email protected]>
1 parent f1eac77 commit 06eb10d

File tree

70 files changed

+249
-228
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

70 files changed

+249
-228
lines changed

.github/workflows/release-binaries.yml

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -328,7 +328,7 @@ jobs:
328328
run: |
329329
# Build some of the mlir tools that take a long time to link
330330
if [ "${{ needs.prepare.outputs.build-flang }}" = "true" ]; then
331-
ninja -C ${{ steps.setup-stage.outputs.build-prefix }}/build/tools/clang/stage2-bins/ -j2 flang-new bbc
331+
ninja -C ${{ steps.setup-stage.outputs.build-prefix }}/build/tools/clang/stage2-bins/ -j2 flang bbc
332332
fi
333333
ninja -C ${{ steps.setup-stage.outputs.build-prefix }}/build/tools/clang/stage2-bins/ \
334334
mlir-bytecode-parser-fuzzer \

clang/include/clang/Basic/DiagnosticDriverKinds.td

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -147,6 +147,9 @@ def warn_drv_unsupported_option_for_processor : Warning<
147147
def warn_drv_unsupported_openmp_library : Warning<
148148
"the library '%0=%1' is not supported, OpenMP will not be enabled">,
149149
InGroup<OptionIgnored>;
150+
def warn_openmp_experimental : Warning<
151+
"OpenMP support in flang is still experimental">,
152+
InGroup<ExperimentalOption>;
150153

151154
def err_drv_invalid_thread_model_for_target : Error<
152155
"invalid thread model '%0' in '%1' for this target">;

clang/include/clang/Basic/DiagnosticGroups.td

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1583,3 +1583,7 @@ def ExtractAPIMisuse : DiagGroup<"extractapi-misuse">;
15831583
// Warnings about using the non-standard extension having an explicit specialization
15841584
// with a storage class specifier.
15851585
def ExplicitSpecializationStorageClass : DiagGroup<"explicit-specialization-storage-class">;
1586+
1587+
// A warning for options that enable a feature that is not yet complete
1588+
def ExperimentalOption : DiagGroup<"experimental-option">;
1589+

clang/include/clang/Driver/Options.td

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -6077,7 +6077,7 @@ def _sysroot_EQ : Joined<["--"], "sysroot=">, Visibility<[ClangOption, FlangOpti
60776077
def _sysroot : Separate<["--"], "sysroot">, Alias<_sysroot_EQ>;
60786078

60796079
//===----------------------------------------------------------------------===//
6080-
// pie/pic options (clang + flang-new)
6080+
// pie/pic options (clang + flang)
60816081
//===----------------------------------------------------------------------===//
60826082
let Visibility = [ClangOption, FlangOption] in {
60836083

@@ -6093,7 +6093,7 @@ def fno_pie : Flag<["-"], "fno-pie">, Group<f_Group>;
60936093
} // let Vis = [Default, FlangOption]
60946094

60956095
//===----------------------------------------------------------------------===//
6096-
// Target Options (clang + flang-new)
6096+
// Target Options (clang + flang)
60976097
//===----------------------------------------------------------------------===//
60986098
let Flags = [TargetSpecific] in {
60996099
let Visibility = [ClangOption, FlangOption] in {

clang/lib/Driver/Driver.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2029,7 +2029,7 @@ void Driver::PrintHelp(bool ShowHidden) const {
20292029

20302030
void Driver::PrintVersion(const Compilation &C, raw_ostream &OS) const {
20312031
if (IsFlangMode()) {
2032-
OS << getClangToolFullVersion("flang-new") << '\n';
2032+
OS << getClangToolFullVersion("flang") << '\n';
20332033
} else {
20342034
// FIXME: The following handlers should use a callback mechanism, we don't
20352035
// know what the client would like to do.

clang/lib/Driver/ToolChain.cpp

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -386,6 +386,9 @@ static const DriverSuffix *FindDriverSuffix(StringRef ProgName, size_t &Pos) {
386386
{"cl", "--driver-mode=cl"},
387387
{"++", "--driver-mode=g++"},
388388
{"flang", "--driver-mode=flang"},
389+
// For backwards compatibility, we create a symlink for `flang` called
390+
// `flang-new`. This will be removed in the future.
391+
{"flang-new", "--driver-mode=flang"},
389392
{"clang-dxc", "--driver-mode=dxc"},
390393
};
391394

clang/lib/Driver/ToolChains/Flang.cpp

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -787,6 +787,9 @@ void Flang::ConstructJob(Compilation &C, const JobAction &JA,
787787

788788
if (Args.hasArg(options::OPT_fopenmp_force_usm))
789789
CmdArgs.push_back("-fopenmp-force-usm");
790+
// TODO: OpenMP support isn't "done" yet, so for now we warn that it
791+
// is experimental.
792+
D.Diag(diag::warn_openmp_experimental);
790793

791794
// FIXME: Clang supports a whole bunch more flags here.
792795
break;
@@ -881,14 +884,12 @@ void Flang::ConstructJob(Compilation &C, const JobAction &JA,
881884

882885
CmdArgs.push_back(Input.getFilename());
883886

884-
// TODO: Replace flang-new with flang once the new driver replaces the
885-
// throwaway driver
886-
const char *Exec = Args.MakeArgString(D.GetProgramPath("flang-new", TC));
887+
const char *Exec = Args.MakeArgString(D.GetProgramPath("flang", TC));
887888
C.addCommand(std::make_unique<Command>(JA, *this,
888889
ResponseFileSupport::AtFileUTF8(),
889890
Exec, CmdArgs, Inputs, Output));
890891
}
891892

892-
Flang::Flang(const ToolChain &TC) : Tool("flang-new", "flang frontend", TC) {}
893+
Flang::Flang(const ToolChain &TC) : Tool("flang", "flang frontend", TC) {}
893894

894895
Flang::~Flang() {}

clang/test/Driver/flang/flang.f90

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@
1313
! * (no type specified, resulting in an object file)
1414

1515
! All invocations should begin with flang -fc1, consume up to here.
16-
! ALL-LABEL: "{{[^"]*}}flang-new{{[^"/]*}}" "-fc1"
16+
! ALL-LABEL: "{{[^"]*}}flang{{[^"/]*}}" "-fc1"
1717

1818
! Check that f90 files are not treated as "previously preprocessed"
1919
! ... in --driver-mode=flang.

clang/test/Driver/flang/flang_ucase.F90

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@
1313
! * (no type specified, resulting in an object file)
1414

1515
! All invocations should begin with flang -fc1, consume up to here.
16-
! ALL-LABEL: "{{[^"]*}}flang-new{{[^"/]*}}" "-fc1"
16+
! ALL-LABEL: "{{[^"]*}}flang{{[^"/]*}}" "-fc1"
1717

1818
! Check that f90 files are not treated as "previously preprocessed"
1919
! ... in --driver-mode=flang.
Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
! Check that flang can handle mixed C and fortran inputs.
22

33
! RUN: %clang --driver-mode=flang -### -fsyntax-only %S/Inputs/one.f90 %S/Inputs/other.c 2>&1 | FileCheck --check-prefixes=CHECK-SYNTAX-ONLY %s
4-
! CHECK-SYNTAX-ONLY-LABEL: "{{[^"]*}}flang-new{{[^"/]*}}" "-fc1"
4+
! CHECK-SYNTAX-ONLY-LABEL: "{{[^"]*}}flang{{[^"/]*}}" "-fc1"
55
! CHECK-SYNTAX-ONLY: "{{[^"]*}}/Inputs/one.f90"
66
! CHECK-SYNTAX-ONLY-LABEL: "{{[^"]*}}clang{{[^"/]*}}" "-cc1"
77
! CHECK-SYNTAX-ONLY: "{{[^"]*}}/Inputs/other.c"
Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
! Check that flang driver can handle multiple inputs at once.
22

33
! RUN: %clang --driver-mode=flang -### -fsyntax-only %S/Inputs/one.f90 %S/Inputs/two.f90 2>&1 | FileCheck --check-prefixes=CHECK-SYNTAX-ONLY %s
4-
! CHECK-SYNTAX-ONLY-LABEL: "{{[^"]*}}flang-new{{[^"/]*}}" "-fc1"
4+
! CHECK-SYNTAX-ONLY-LABEL: "{{[^"]*}}flang{{[^"/]*}}" "-fc1"
55
! CHECK-SYNTAX-ONLY: "{{[^"]*}}/Inputs/one.f90"
6-
! CHECK-SYNTAX-ONLY-LABEL: "{{[^"]*}}flang-new{{[^"/]*}}" "-fc1"
6+
! CHECK-SYNTAX-ONLY-LABEL: "{{[^"]*}}flang{{[^"/]*}}" "-fc1"
77
! CHECK-SYNTAX-ONLY: "{{[^"]*}}/Inputs/two.f90"

flang/docs/FlangDriver.md

Lines changed: 36 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -15,17 +15,13 @@ local:
1515
```
1616

1717
There are two main drivers in Flang:
18-
* the compiler driver, `flang-new`
19-
* the frontend driver, `flang-new -fc1`
20-
21-
> **_NOTE:_** The diagrams in this document refer to `flang` as opposed to
22-
> `flang-new`. Eventually, `flang-new` will be renamed as `flang` and the
23-
> diagrams reflect the final design that we are still working towards.
18+
* the compiler driver, `flang`
19+
* the frontend driver, `flang -fc1`
2420

2521
The **compiler driver** will allow you to control all compilation phases (e.g.
2622
preprocessing, semantic checks, code-generation, code-optimisation, lowering
2723
and linking). For frontend specific tasks, the compiler driver creates a
28-
Fortran compilation job and delegates it to `flang-new -fc1`, the frontend
24+
Fortran compilation job and delegates it to `flang -fc1`, the frontend
2925
driver. For linking, it creates a linker job and calls an external linker (e.g.
3026
LLVM's [`lld`](https://lld.llvm.org/)). It can also call other tools such as
3127
external assemblers (e.g. [`as`](https://www.gnu.org/software/binutils/)). In
@@ -47,7 +43,7 @@ frontend. It uses MLIR and LLVM for code-generation and can be viewed as a
4743
driver for Flang, LLVM and MLIR libraries. Contrary to the compiler driver, it
4844
is not capable of calling any external tools (including linkers). It is aware
4945
of all the frontend internals that are "hidden" from the compiler driver. It
50-
accepts many frontend-specific options not available in `flang-new` and as such
46+
accepts many frontend-specific options not available in `flang` and as such
5147
it provides a finer control over the frontend. Note that this tool is mostly
5248
intended for Flang developers. In particular, there are no guarantees about the
5349
stability of its interface and compiler developers can use it to experiment
@@ -62,30 +58,30 @@ frontend specific flag from the _compiler_ directly to the _frontend_ driver,
6258
e.g.:
6359

6460
```bash
65-
flang-new -Xflang -fdebug-dump-parse-tree input.f95
61+
flang -Xflang -fdebug-dump-parse-tree input.f95
6662
```
6763

68-
In the invocation above, `-fdebug-dump-parse-tree` is forwarded to `flang-new
64+
In the invocation above, `-fdebug-dump-parse-tree` is forwarded to `flang
6965
-fc1`. Without the forwarding flag, `-Xflang`, you would see the following
7066
warning:
7167

7268
```bash
73-
flang-new: warning: argument unused during compilation:
69+
flang: warning: argument unused during compilation:
7470
```
7571

76-
As `-fdebug-dump-parse-tree` is only supported by `flang-new -fc1`, `flang-new`
72+
As `-fdebug-dump-parse-tree` is only supported by `flang -fc1`, `flang`
7773
will ignore it when used without `Xflang`.
7874

7975
## Why Do We Need Two Drivers?
80-
As hinted above, `flang-new` and `flang-new -fc1` are two separate tools. The
81-
fact that these tools are accessed through one binary, `flang-new`, is just an
76+
As hinted above, `flang` and `flang -fc1` are two separate tools. The
77+
fact that these tools are accessed through one binary, `flang`, is just an
8278
implementation detail. Each tool has a separate list of options, albeit defined
8379
in the same file: `clang/include/clang/Driver/Options.td`.
8480

8581
The separation helps us split various tasks and allows us to implement more
86-
specialised tools. In particular, `flang-new` is not aware of various
82+
specialised tools. In particular, `flang` is not aware of various
8783
compilation phases within the frontend (e.g. scanning, parsing or semantic
88-
checks). It does not have to be. Conversely, the frontend driver, `flang-new
84+
checks). It does not have to be. Conversely, the frontend driver, `flang
8985
-fc1`, needs not to be concerned with linkers or other external tools like
9086
assemblers. Nor does it need to know where to look for various systems
9187
libraries, which is usually OS and platform specific.
@@ -104,7 +100,7 @@ GCC](https://en.wikibooks.org/wiki/GNU_C_Compiler_Internals/GNU_C_Compiler_Archi
104100
In fact, Flang needs to adhere to this model in order to be able to re-use
105101
Clang's driver library. If you are more familiar with the [architecture of
106102
GFortran](https://gcc.gnu.org/onlinedocs/gcc-4.7.4/gfortran/About-GNU-Fortran.html)
107-
than Clang, then `flang-new` corresponds to `gfortran` and `flang-new -fc1` to
103+
than Clang, then `flang` corresponds to `gfortran` and `flang -fc1` to
108104
`f951`.
109105

110106
## Compiler Driver
@@ -135,15 +131,15 @@ output from one action is the input for the subsequent one. You can use the
135131
`-ccc-print-phases` flag to see the sequence of actions that the driver will
136132
create for your compiler invocation:
137133
```bash
138-
flang-new -ccc-print-phases -E file.f
134+
flang -ccc-print-phases -E file.f
139135
+- 0: input, "file.f", f95-cpp-input
140136
1: preprocessor, {0}, f95
141137
```
142138
As you can see, for `-E` the driver creates only two jobs and stops immediately
143139
after preprocessing. The first job simply prepares the input. For `-c`, the
144140
pipeline of the created jobs is more complex:
145141
```bash
146-
flang-new -ccc-print-phases -c file.f
142+
flang -ccc-print-phases -c file.f
147143
+- 0: input, "file.f", f95-cpp-input
148144
+- 1: preprocessor, {0}, f95
149145
+- 2: compiler, {1}, ir
@@ -158,7 +154,7 @@ command to call the frontend driver is generated (more specifically, an
158154
instance of `clang::driver::Command`). Every command is bound to an instance of
159155
`clang::driver::Tool`. For Flang we introduced a specialisation of this class:
160156
`clang::driver::Flang`. This class implements the logic to either translate or
161-
forward compiler options to the frontend driver, `flang-new -fc1`.
157+
forward compiler options to the frontend driver, `flang -fc1`.
162158

163159
You can read more on the design of `clangDriver` in Clang's [Driver Design &
164160
Internals](https://clang.llvm.org/docs/DriverInternals.html).
@@ -232,12 +228,12 @@ driver, `clang -cc1` and consists of the following classes:
232228
This list is not exhaustive and only covers the main classes that implement the
233229
driver. The main entry point for the frontend driver, `fc1_main`, is
234230
implemented in `flang/tools/flang-driver/driver.cpp`. It can be accessed by
235-
invoking the compiler driver, `flang-new`, with the `-fc1` flag.
231+
invoking the compiler driver, `flang`, with the `-fc1` flag.
236232

237233
The frontend driver will only run one action at a time. If you specify multiple
238234
action flags, only the last one will be taken into account. The default action
239235
is `ParseSyntaxOnlyAction`, which corresponds to `-fsyntax-only`. In other
240-
words, `flang-new -fc1 <input-file>` is equivalent to `flang-new -fc1 -fsyntax-only
236+
words, `flang -fc1 <input-file>` is equivalent to `flang -fc1 -fsyntax-only
241237
<input-file>`.
242238

243239
## Adding new Compiler Options
@@ -262,8 +258,8 @@ similar semantics to your new option and start by copying that.
262258
For every new option, you will also have to define the visibility of the new
263259
option. This is controlled through the `Visibility` field. You can use the
264260
following Flang specific visibility flags to control this:
265-
* `FlangOption` - this option will be available in the `flang-new` compiler driver,
266-
* `FC1Option` - this option will be available in the `flang-new -fc1` frontend driver,
261+
* `FlangOption` - this option will be available in the `flang` compiler driver,
262+
* `FC1Option` - this option will be available in the `flang -fc1` frontend driver,
267263

268264
Options that are supported by clang should explicitly specify `ClangOption` in
269265
`Visibility`, and options that are only supported in Flang should not specify
@@ -290,10 +286,10 @@ The parsing will depend on the semantics encoded in the TableGen definition.
290286

291287
When adding a compiler driver option (i.e. an option that contains
292288
`FlangOption` among in it's `Visibility`) that you also intend to be understood
293-
by the frontend, make sure that it is either forwarded to `flang-new -fc1` or
289+
by the frontend, make sure that it is either forwarded to `flang -fc1` or
294290
translated into some other option that is accepted by the frontend driver. In
295291
the case of options that contain both `FlangOption` and `FC1Option` among its
296-
flags, we usually just forward from `flang-new` to `flang-new -fc1`. This is
292+
flags, we usually just forward from `flang` to `flang -fc1`. This is
297293
then tested in `flang/test/Driver/frontend-forward.F90`.
298294

299295
What follows is usually very dependant on the meaning of the corresponding
@@ -339,11 +335,11 @@ just added using your new frontend option.
339335

340336
## CMake Support
341337
As of [#7246](https://gitlab.kitware.com/cmake/cmake/-/merge_requests/7246)
342-
(and soon to be released CMake 3.24.0), `cmake` can detect `flang-new` as a
338+
(CMake 3.28.0), `cmake` can detect `flang` as a
343339
supported Fortran compiler. You can configure your CMake projects to use
344-
`flang-new` as follows:
340+
`flang` as follows:
345341
```bash
346-
cmake -DCMAKE_Fortran_COMPILER=<path/to/flang-new> <src/dir>
342+
cmake -DCMAKE_Fortran_COMPILER=<path/to/flang> <src/dir>
347343
```
348344
You should see the following in the output:
349345
```
@@ -353,14 +349,14 @@ where `<version>` corresponds to the LLVM Flang version.
353349

354350
## Testing
355351
In LIT, we define two variables that you can use to invoke Flang's drivers:
356-
* `%flang` is expanded as `flang-new` (i.e. the compiler driver)
357-
* `%flang_fc1` is expanded as `flang-new -fc1` (i.e. the frontend driver)
352+
* `%flang` is expanded as `flang` (i.e. the compiler driver)
353+
* `%flang_fc1` is expanded as `flang -fc1` (i.e. the frontend driver)
358354

359355
For most regression tests for the frontend, you will want to use `%flang_fc1`.
360356
In some cases, the observable behaviour will be identical regardless of whether
361357
`%flang` or `%flang_fc1` is used. However, when you are using `%flang` instead
362358
of `%flang_fc1`, the compiler driver will add extra flags to the frontend
363-
driver invocation (i.e. `flang-new -fc1 -<extra-flags>`). In some cases that might
359+
driver invocation (i.e. `flang -fc1 -<extra-flags>`). In some cases that might
364360
be exactly what you want to test. In fact, you can check these additional
365361
flags by using the `-###` compiler driver command line option.
366362

@@ -380,7 +376,7 @@ plugins. The process for using plugins includes:
380376
* [Creating a plugin](#creating-a-plugin)
381377
* [Loading and running a plugin](#loading-and-running-a-plugin)
382378

383-
Flang plugins are limited to `flang-new -fc1` and are currently only available /
379+
Flang plugins are limited to `flang -fc1` and are currently only available /
384380
been tested on Linux.
385381

386382
### Creating a Plugin
@@ -465,14 +461,14 @@ static FrontendPluginRegistry::Add<PrintFunctionNamesAction> X(
465461

466462
### Loading and Running a Plugin
467463
In order to use plugins, there are 2 command line options made available to the
468-
frontend driver, `flang-new -fc1`:
464+
frontend driver, `flang -fc1`:
469465
* [`-load <dsopath>`](#the--load-dsopath-option) for loading the dynamic shared
470466
object of the plugin
471467
* [`-plugin <name>`](#the--plugin-name-option) for calling the registered plugin
472468

473469
Invocation of the example plugin is done through:
474470
```bash
475-
flang-new -fc1 -load flangPrintFunctionNames.so -plugin print-fns file.f90
471+
flang -fc1 -load flangPrintFunctionNames.so -plugin print-fns file.f90
476472
```
477473

478474
Both these options are parsed in `flang/lib/Frontend/CompilerInvocation.cpp` and
@@ -493,7 +489,7 @@ reports an error diagnostic and returns `nullptr`.
493489

494490
### Enabling In-Tree Plugins
495491
For in-tree plugins, there is the CMake flag `FLANG_PLUGIN_SUPPORT`, enabled by
496-
default, that controls the exporting of executable symbols from `flang-new`,
492+
default, that controls the exporting of executable symbols from `flang`,
497493
which plugins need access to. Additionally, there is the CMake flag
498494
`LLVM_BUILD_EXAMPLES`, turned off by default, that is used to control if the
499495
example programs are built. This includes plugins that are in the
@@ -526,7 +522,7 @@ invocations `invokeFIROptEarlyEPCallbacks`, `invokeFIRInlinerCallback`, and
526522
`invokeFIROptLastEPCallbacks` for Flang drivers to be able to insert additonal
527523
passes at different points of the default pass pipeline. An example use of these
528524
extension point callbacks is shown in `registerDefaultInlinerPass` to invoke the
529-
default inliner pass in `flang-new`.
525+
default inliner pass in `flang`.
530526

531527
## LLVM Pass Plugins
532528

@@ -539,15 +535,15 @@ documentation for
539535
[`llvm::PassBuilder`](https://llvm.org/doxygen/classllvm_1_1PassBuilder.html)
540536
for details.
541537

542-
The framework to enable pass plugins in `flang-new` uses the exact same
538+
The framework to enable pass plugins in `flang` uses the exact same
543539
machinery as that used by `clang` and thus has the same capabilities and
544540
limitations.
545541

546542
In order to use a pass plugin, the pass(es) must be compiled into a dynamic
547543
shared object which is then loaded using the `-fpass-plugin` option.
548544

549545
```
550-
flang-new -fpass-plugin=/path/to/plugin.so <file.f90>
546+
flang -fpass-plugin=/path/to/plugin.so <file.f90>
551547
```
552548

553549
This option is available in both the compiler driver and the frontend driver.
@@ -559,7 +555,7 @@ Pass extensions are similar to plugins, except that they can also be linked
559555
statically. Setting `-DLLVM_${NAME}_LINK_INTO_TOOLS` to `ON` in the cmake
560556
command turns the project into a statically linked extension. An example would
561557
be Polly, e.g., using `-DLLVM_POLLY_LINK_INTO_TOOLS=ON` would link Polly passes
562-
into `flang-new` as built-in middle-end passes.
558+
into `flang` as built-in middle-end passes.
563559

564560
See the
565561
[`WritingAnLLVMNewPMPass`](https://llvm.org/docs/WritingAnLLVMNewPMPass.html#id9)

flang/docs/ImplementingASemanticCheck.md

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -68,7 +68,7 @@ of the call to `intentOutFunc()`:
6868

6969
I also used this program to produce a parse tree for the program using the command:
7070
```bash
71-
flang-new -fc1 -fdebug-dump-parse-tree testfun.f90
71+
flang -fc1 -fdebug-dump-parse-tree testfun.f90
7272
```
7373

7474
Here's the relevant fragment of the parse tree produced by the compiler:
@@ -296,7 +296,7 @@ In `lib/Semantics/check-do.cpp`, I added an (almost empty) implementation:
296296
I then built the compiler with these changes and ran it on my test program.
297297
This time, I made sure to invoke semantic checking. Here's the command I used:
298298
```bash
299-
flang-new -fc1 -fdebug-unparse-with-symbols testfun.f90
299+
flang -fc1 -fdebug-unparse-with-symbols testfun.f90
300300
```
301301

302302
This produced the output:

0 commit comments

Comments
 (0)