[flang] Make the frontend driver error out when requesting multiple actions

[awarzynski]

Summary

With this change, the following invocations are treated as errors
(multiple actions are specified):

$ flang-new -fc1 -E -fsyntax-only file.95
$ flang-new -fc1 -fsyntax-only -fsyntax-only file.95

[awarzynski]

NOTE: : Please see the discussion on flang-dev for more context.

Is this the right approach? Shall we ping cfe-dev and see whether they would be interested in something similar?

[awarzynski]

Make sure that all tests pass

• Update RUN lines that specified multiple frontend actions (with this patch, only one action can be used)
• Refine hasMultipleArgs. Previously it returned true for any number of action options !=1. This should be >=1 instead.

[PeteSteinfeld]

This generally looks good. Another possibility would be to allow the specification of the default option.

[awarzynski]

I've just added reviewers that recently touched llvm/include/llvm/Option/ArgList.h. For a bit of context, this patch addresses some concerns raised here:

• [flang-dev]: https://lists.llvm.org/pipermail/flang-dev/2021-October/000822.html (the original thread)
• [cfe-dev]: https://lists.llvm.org/pipermail/cfe-dev/2021-October/069132.html (a separate thread that focuses on this particular behavior in the context of clang -cc1).

I'm not suggesting that a similar change is made in clang -cc1, but I definitely wouldn't mind extending this patch so that it covers both flang-new -cc1 and clang -cc1.

Thank you for taking a look!

[jansvoboda11]

In D111781#3108253, @awarzynski wrote:

I've just added reviewers that recently touched llvm/include/llvm/Option/ArgList.h. For a bit of context, this patch addresses some concerns raised here:

• [flang-dev]: https://lists.llvm.org/pipermail/cfe-dev/2021-October/069132.html (the original thread)
• [cfe-dev]: https://lists.llvm.org/pipermail/cfe-dev/2021-October/069132.html (a separate thread that focuses on this particular behavior in the context of clang -cc1).

Both of those links point to the cfe-dev mailing list.

I'm not suggesting that a similar change is made in clang -cc1, but I definitely wouldn't mind extending this patch so that it covers both flang-new -cc1 and clang -cc1.

Personally, I don't think this is something we'd want for clang -cc1. The end users only interact with the driver interface (which will never generate multiple actions) and never see/modify the -cc1 invocation.
On the other hand, when hacking on Clang, I often grab a -cc1 invocation and append -Eonly to only run the preprocessor. If that resulted in an error and forced me to go through the whole command-line and remove -c, I'd be very frustrated.

If the Flang community is okay with this change, I don't have any objections.

[awarzynski]

In D111781#3108401, @jansvoboda11 wrote:

Both of those links point to the cfe-dev mailing list.

Sorry for that, updated in the original comment!

Personally, I don't think this is something we'd want for clang -cc1.

Sure thing. And it's helpful to know that people are happy with the "status quo" (for good reasons, as you note below).

On the other hand, when hacking on Clang, I often grab a -cc1 invocation and append -Eonly to only run the preprocessor. If that resulted in an error and forced me to go through the whole command-line and remove -c, I'd be very frustrated.

That's a very interesting perspective. We don't hit this use-case just yet, because our feature list is still very limited. But we *are* heading in the similar direction (in terms of our workflows).

[awarzynski]

Rebase on top of main

[awarzynski]

This change will mostly affect Flang compiler developers who use flang-new -fc1 for their work or end-users who want to play with the internals. I know that @PeteSteinfeld is in favor and we have also discussed this on the mailing list and in Flang community calls. AFAIK, people are OK with this change. It does mean that flang-new -fc1 and clang -cc1 will behave a bit differently here, but it's nothing major. If there are no further comments, I will merge this tomorrow.

flang/lib/Frontend/CompilerInvocation.cpp

 
 static bool ParseFrontendArgs(FrontendOptions &opts, llvm::opt::ArgList &args,
     clang::DiagnosticsEngine &diags) {
   unsigned numErrorsBefore = diags.getNumErrors();
 
   // By default the frontend driver creates a ParseSyntaxOnly action.
   opts.programAction = ParseSyntaxOnly;
 
+  // Treat multiple action options as an invocation error. Note that `clang
+  // -cc1` does accept multiple action options, but will only consider the
+  // rightmost one.
+  if (args.hasMultipleArgs(clang::driver::options::OPT_Action_Group)) {
+    const unsigned diagID = diags.getCustomDiagID(
+        clang::DiagnosticsEngine::Error, "Only one action option is allowed");
+    diags.Report(diagID);
+    return false;
+  }
+
   // Identify the action (i.e. opts.ProgramAction)
   if (const llvm::opt::Arg *a =
           args.getLastArg(clang::driver::options::OPT_Action_Group)) {
     switch (a->getOption().getID()) {
     default: {
       llvm_unreachable("Invalid option in group!");
     }
     case clang::driver::options::OPT_test_io:

flang/test/Driver/debug-measure-parse-tree.f90

 ! Ensure argument -fdebug-measure-parse-tree works as expected.
 
 !----------
 ! RUN LINE
 !----------
-! RUN: %flang_fc1 -fsyntax-only -fdebug-measure-parse-tree %s  2>&1 | FileCheck %s --check-prefix=FRONTEND
+! RUN: %flang_fc1 -fdebug-measure-parse-tree %s  2>&1 | FileCheck %s --check-prefix=FRONTEND
 
 !-----------------
 ! EXPECTED OUTPUT
 !-----------------
 ! FRONTEND:Parse tree comprises {{[0-9]+}} objects and occupies {{[0-9]+}} total bytes.
 
 program A
 end

flang/test/Driver/get-definition.f90

 ! Verify that the driver correctly rejects invalid values for -fget-definition
 
 !-----------
 ! RUN LINES
 !-----------
-! RUN: not %flang_fc1 -fsyntax-only -fget-definition 45 1 2 %s 2>&1 | FileCheck --check-prefix=OK %s
-! RUN: not %flang_fc1 -fsyntax-only -fget-definition a 1 1 %s 2>&1 | FileCheck --check-prefix=ERROR-a %s
-! RUN: not %flang_fc1 -fsyntax-only -fget-definition 1 b 1 %s 2>&1 | FileCheck --check-prefix=ERROR-b %s
-! RUN: not %flang_fc1 -fsyntax-only -fget-definition 1 1 c %s 2>&1 | FileCheck --check-prefix=ERROR-c %s
-! RUN: not %flang_fc1 -fsyntax-only -fget-definition a b 1 %s 2>&1 | FileCheck --check-prefix=ERROR-ab %s
-! RUN: not %flang_fc1 -fsyntax-only -fget-definition a b c %s 2>&1 | FileCheck --check-prefix=ERROR-abc %s
-! RUN: not %flang_fc1 -fsyntax-only -fget-definition 1 b c %s 2>&1 | FileCheck --check-prefix=ERROR-bc %s
-! RUN: not %flang_fc1 -fsyntax-only -fget-definition a 1 c %s 2>&1 | FileCheck --check-prefix=ERROR-ac %s
+! RUN: not %flang_fc1 -fget-definition 45 1 2 %s 2>&1 | FileCheck --check-prefix=OK %s
+! RUN: not %flang_fc1 -fget-definition a 1 1 %s 2>&1 | FileCheck --check-prefix=ERROR-a %s
+! RUN: not %flang_fc1 -fget-definition 1 b 1 %s 2>&1 | FileCheck --check-prefix=ERROR-b %s
+! RUN: not %flang_fc1 -fget-definition 1 1 c %s 2>&1 | FileCheck --check-prefix=ERROR-c %s
+! RUN: not %flang_fc1 -fget-definition a b 1 %s 2>&1 | FileCheck --check-prefix=ERROR-ab %s
+! RUN: not %flang_fc1 -fget-definition a b c %s 2>&1 | FileCheck --check-prefix=ERROR-abc %s
+! RUN: not %flang_fc1 -fget-definition 1 b c %s 2>&1 | FileCheck --check-prefix=ERROR-bc %s
+! RUN: not %flang_fc1 -fget-definition a 1 c %s 2>&1 | FileCheck --check-prefix=ERROR-ac %s
 
 !-----------------
 ! EXPECTED OUTPUT
 !-----------------
 ! OK: String range: >m<
 ! OK-NOT: error
 
 ! ERROR-a: error: invalid value 'a' in 'fget-definition'

flang/test/Driver/multiple-actions-error.f95

+! Verify that the frontend driver error-out if multiple actions are specified
+
+! RUN: not %flang_fc1 -E -fsyntax-only %s 2>&1 | FileCheck %s --check-prefix=ERROR
+! RUN: not %flang_fc1 -fsyntax-only -fsyntax-only %s 2>&1 | FileCheck %s --check-prefix=ERROR
+
+! ERROR: error: Only one action option is allowed
+
+end progream

flang/test/Driver/werror-parse.f

 ! Ensure argument -Werror work as expected, this file checks for the functional correctness for
 ! actions that extend the PrescanAndSemaAction, particularly for Semantic warnings/errors.
 ! Multiple RUN lines are added to make sure that the behavior is consistent across multiple actions.
 
 ! RUN: not %flang_fc1 -fsyntax-only -std=f2018 -Werror %s  2>&1 | FileCheck %s --check-prefix=WITH
-! RUN: not %flang_fc1 -fsyntax-only -std=f2018 -Werror -fdebug-dump-parse-tree %s  2>&1 | FileCheck %s --check-prefix=WITH
-! RUN: not %flang_fc1 -fsyntax-only -std=f2018 -Werror -fdebug-unparse-with-symbols %s  2>&1 | FileCheck %s --check-prefix=WITH
-! RUN: not %flang_fc1 -fsyntax-only -std=f2018 -Werror -fdebug-unparse %s  2>&1 | FileCheck %s --check-prefix=WITH
-! RUN: not %flang_fc1 -fsyntax-only -std=f2018 -Werror -fdebug-dump-symbols %s  2>&1 | FileCheck %s --check-prefix=WITH
+! RUN: not %flang_fc1 -std=f2018 -Werror -fdebug-dump-parse-tree %s  2>&1 | FileCheck %s --check-prefix=WITH
+! RUN: not %flang_fc1 -std=f2018 -Werror -fdebug-unparse-with-symbols %s  2>&1 | FileCheck %s --check-prefix=WITH
+! RUN: not %flang_fc1 -std=f2018 -Werror -fdebug-unparse %s  2>&1 | FileCheck %s --check-prefix=WITH
+! RUN: not %flang_fc1 -std=f2018 -Werror -fdebug-dump-symbols %s  2>&1 | FileCheck %s --check-prefix=WITH
 
 
 ! RUN: %flang_fc1 -fsyntax-only -std=f2018 %s  2>&1 | FileCheck %s --allow-empty --check-prefix=WITHOUT
-! RUN: %flang_fc1 -fsyntax-only -std=f2018 -fdebug-dump-parse-tree %s  2>&1 | FileCheck %s --allow-empty --check-prefix=WITHOUT
-! RUN: %flang_fc1 -fsyntax-only -std=f2018 -fdebug-unparse-with-symbols %s  2>&1 | FileCheck %s --allow-empty --check-prefix=WITHOUT
-! RUN: %flang_fc1 -fsyntax-only -std=f2018 -fdebug-unparse %s  2>&1 | FileCheck %s --allow-empty --check-prefix=WITHOUT
-! RUN: %flang_fc1 -fsyntax-only -std=f2018 -fdebug-dump-symbols %s  2>&1 | FileCheck %s --allow-empty --check-prefix=WITHOUT
+! RUN: %flang_fc1 -std=f2018 -fdebug-dump-parse-tree %s  2>&1 | FileCheck %s --allow-empty --check-prefix=WITHOUT
+! RUN: %flang_fc1 -std=f2018 -fdebug-unparse-with-symbols %s  2>&1 | FileCheck %s --allow-empty --check-prefix=WITHOUT
+! RUN: %flang_fc1 -std=f2018 -fdebug-unparse %s  2>&1 | FileCheck %s --allow-empty --check-prefix=WITHOUT
+! RUN: %flang_fc1 -std=f2018 -fdebug-dump-symbols %s  2>&1 | FileCheck %s --allow-empty --check-prefix=WITHOUT
 
 !-----------------------------------------
 ! EXPECTED OUTPUT WITH -Werror
 !-----------------------------------------
 ! WITH: Could not parse
 
 !-----------------------------------------
 ! EXPECTED OUTPUT WITHOUT -Werror

flang/test/Driver/werror-scan.f

 ! Ensure argument -Werror work as expected, this file checks for the functional correctness for
 ! actions that extend the PrescanAction
 ! Multiple RUN lines are added to make sure that the behavior is consistent across multiple actions.
 
-! RUN: not %flang_fc1 -fsyntax-only -E -Werror %s  2>&1 | FileCheck %s --check-prefix=WITH
-! RUN: not %flang_fc1 -fsyntax-only -fdebug-dump-parsing-log -Werror %s  2>&1 | FileCheck %s --check-prefix=WITH
-! RUN: not %flang_fc1 -fsyntax-only -fdebug-dump-provenance -Werror %s  2>&1 | FileCheck %s --check-prefix=WITH
-! RUN: not %flang_fc1 -fsyntax-only -fdebug-measure-parse-tree -Werror %s  2>&1 | FileCheck %s --check-prefix=WITH
-! RUN: %flang_fc1 -fsyntax-only -E %s  2>&1 | FileCheck %s --allow-empty --check-prefix=WITHOUT
-! RUN: %flang_fc1 -fsyntax-only -fdebug-dump-parsing-log %s  2>&1 | FileCheck %s --check-prefix=WITHOUT
-! RUN: %flang_fc1 -fsyntax-only -fdebug-dump-provenance %s  2>&1 | FileCheck %s --check-prefix=WITHOUT
-! RUN: %flang_fc1 -fsyntax-only -fdebug-measure-parse-tree %s  2>&1 | FileCheck %s --check-prefix=WITHOUT
+! RUN: not %flang_fc1 -E -Werror %s  2>&1 | FileCheck %s --check-prefix=WITH
+! RUN: not %flang_fc1 -fdebug-dump-parsing-log -Werror %s  2>&1 | FileCheck %s --check-prefix=WITH
+! RUN: not %flang_fc1 -fdebug-dump-provenance -Werror %s  2>&1 | FileCheck %s --check-prefix=WITH
+! RUN: not %flang_fc1 -fdebug-measure-parse-tree -Werror %s  2>&1 | FileCheck %s --check-prefix=WITH
+! RUN: %flang_fc1 -E %s  2>&1 | FileCheck %s --allow-empty --check-prefix=WITHOUT
+! RUN: %flang_fc1 -fdebug-dump-parsing-log %s  2>&1 | FileCheck %s --check-prefix=WITHOUT
+! RUN: %flang_fc1 -fdebug-dump-provenance %s  2>&1 | FileCheck %s --check-prefix=WITHOUT
+! RUN: %flang_fc1 -fdebug-measure-parse-tree %s  2>&1 | FileCheck %s --check-prefix=WITHOUT
 
 !-----------------------------------------
 ! EXPECTED OUTPUT WITH -Werror
 !-----------------------------------------
 ! WITH: Could not scan
 
 !-----------------------------------------
 ! EXPECTED OUTPUT WITHOUT -Werror
 !-----------------------------------------
 ! WITHOUT-NOT: Could not scan
 
 1 continue
 end

flang/test/Driver/werror-sema.f90

 ! Ensure argument -Werror work as expected, this file checks for the functional correctness for
 ! actions that extend the PrescanAndSemaAction, particularly for Semantic warnings/errors.
 ! Multiple RUN lines are added to make sure that the behavior is consistent across multiple actions.
 
 ! RUN: not %flang_fc1 -fsyntax-only -Werror %s  2>&1 | FileCheck %s --check-prefix=WITH
-! RUN: not %flang_fc1 -fsyntax-only -Werror -fdebug-dump-parse-tree %s  2>&1 | FileCheck %s --check-prefix=WITH
-! RUN: not %flang_fc1 -fsyntax-only -Werror -fdebug-unparse-with-symbols %s  2>&1 | FileCheck %s --check-prefix=WITH
-! RUN: not %flang_fc1 -fsyntax-only -Werror -fdebug-unparse %s  2>&1 | FileCheck %s --check-prefix=WITH
-! RUN: not %flang_fc1 -fsyntax-only -Werror -fdebug-dump-symbols %s  2>&1 | FileCheck %s --check-prefix=WITH
+! RUN: not %flang_fc1 -Werror -fdebug-dump-parse-tree %s  2>&1 | FileCheck %s --check-prefix=WITH
+! RUN: not %flang_fc1 -Werror -fdebug-unparse-with-symbols %s  2>&1 | FileCheck %s --check-prefix=WITH
+! RUN: not %flang_fc1 -Werror -fdebug-unparse %s  2>&1 | FileCheck %s --check-prefix=WITH
+! RUN: not %flang_fc1 -Werror -fdebug-dump-symbols %s  2>&1 | FileCheck %s --check-prefix=WITH
 
 
 ! RUN: %flang_fc1 -fsyntax-only %s  2>&1 | FileCheck %s --allow-empty --check-prefix=WITHOUT
-! RUN: %flang_fc1 -fsyntax-only -fdebug-dump-parse-tree %s  2>&1 | FileCheck %s --allow-empty --check-prefix=WITHOUT
-! RUN: %flang_fc1 -fsyntax-only -fdebug-unparse-with-symbols %s  2>&1 | FileCheck %s --allow-empty --check-prefix=WITHOUT
-! RUN: %flang_fc1 -fsyntax-only -fdebug-unparse %s  2>&1 | FileCheck %s --allow-empty --check-prefix=WITHOUT
-! RUN: %flang_fc1 -fsyntax-only -fdebug-dump-symbols %s  2>&1 | FileCheck %s --allow-empty --check-prefix=WITHOUT
+! RUN: %flang_fc1 -fdebug-dump-parse-tree %s  2>&1 | FileCheck %s --allow-empty --check-prefix=WITHOUT
+! RUN: %flang_fc1 -fdebug-unparse-with-symbols %s  2>&1 | FileCheck %s --allow-empty --check-prefix=WITHOUT
+! RUN: %flang_fc1 -fdebug-unparse %s  2>&1 | FileCheck %s --allow-empty --check-prefix=WITHOUT
+! RUN: %flang_fc1 -fdebug-dump-symbols %s  2>&1 | FileCheck %s --allow-empty --check-prefix=WITHOUT
 
 !-----------------------------------------
 ! EXPECTED OUTPUT WITH -Werror
 !-----------------------------------------
 ! WITH: Semantic errors in
 
 !-----------------------------------------
 ! EXPECTED OUTPUT WITHOUT -Werror
 !-----------------------------------------
 ! WITHOUT-NOT: Semantic errors in
 
 PROGRAM werror
 REAL, DIMENSION(20, 10) :: A
 FORALL (J=1:N)  A(I, I) = 1
 END PROGRAM werror

flang/test/Frontend/input-output-file.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: Print to stdout (implicit)
-! RUN: %flang -E -Xflang -test-io %s  2>&1 | FileCheck %s --match-full-lines
+! RUN: %flang -E %s  2>&1 | FileCheck %s --match-full-lines
 
 ! TEST 2: Print to stdout (explicit)
-! RUN: %flang -E -Xflang -test-io -o - %s  2>&1 | FileCheck %s --match-full-lines
+! RUN: %flang -E -o - %s  2>&1 | FileCheck %s --match-full-lines
 
 ! TEST 3: Print to a file
-! RUN: %flang -E -Xflang -test-io -o %t %s 2>&1 && FileCheck %s --match-full-lines --input-file=%t
+! RUN: %flang -E -o %t %s 2>&1 && FileCheck %s --match-full-lines --input-file=%t
 
 !----------------------------------------
 ! FLANG FRONTEND DRIVER (flang -fc1)
 !----------------------------------------
 ! TEST 4: Write to a file (implicit)
 ! This particular test case generates an output file in the same directory as the input file. We need to copy the input file into a
 ! temporary directory to avoid polluting the source directory.
 ! RUN: rm -rf %t-dir && mkdir -p %t-dir && cd %t-dir

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 -Xflang -test-io %s %S/Inputs/hello-world.f90 | FileCheck %s --match-full-lines -check-prefix=FLANG
+! 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 -Xflang -test-io -o - %S/Inputs/hello-world.f90 %s  2>&1 | FileCheck %s --match-full-lines -check-prefix=ERROR
-! RUN: not %flang -E -Xflang -test-io -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 --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
 
 !----------------------------------------
 ! 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

 ! EXPECTED OUTPUT
 !-----------------------
 ! TEST 1: By default, `flang` prints the output from all input files to
 ! stdout
 ! FLANG-LABEL: Program arithmetic
 ! FLANG-NEXT:    Integer :: i, j
 ! FLANG-NEXT:    i = 2; j = 3; i= i * j;
 ! FLANG-NEXT:  End Program arithmetic
-! FLANG-NEXT:!This is a test file with a hello world in Fortran
-! FLANG-NEXT:program hello
+
+! FLANG-LABEL: program hello
 ! FLANG-NEXT:  implicit none
 ! FLANG-NEXT:  write(*,*) 'Hello world!'
 ! FLANG-NEXT:end program hello
 
-! TEST 2: `-o` does not work for `flang` when multiple input files are present
+! TEST 2: `-o` does not when multiple input files are present
 ! ERROR: flang-new: 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
 
-! FC1-OUTPUT2-LABEL:!This is a test file with a hello world in Fortran
-! FC1-OUTPUT2-NEXT:program hello
+! FC1-OUTPUT2-LABEL:program hello
 ! FC1-OUTPUT2-NEXT:  implicit none
 ! FC1-OUTPUT2-NEXT:  write(*,*) 'Hello world!'
 ! FC1-OUTPUT2-NEXT:end program hello
 
 ! TEST 4: The output file _was_ specified - `flang_fc1` will process only
 ! the last input file and generate the corresponding output.
-! FC1-OUTPUT3-LABEL:!This is a test file with a hello world in Fortran
-! FC1-OUTPUT3-NEXT:program hello
+! FC1-OUTPUT3-LABEL:program hello
 ! FC1-OUTPUT3-NEXT:  implicit none
 ! FC1-OUTPUT3-NEXT:  write(*,*) 'Hello world!'
 ! FC1-OUTPUT3-NEXT:end program hello
 
 
 Program arithmetic
   Integer :: i, j
   i = 2; j = 3; i= i * j;
 End Program arithmetic

flang/test/Lower/pre-fir-tree01.f90

-! RUN: %flang_fc1 -fsyntax-only -fdebug-pre-fir-tree %s | FileCheck %s
+! RUN: %flang_fc1 -fdebug-pre-fir-tree %s | FileCheck %s
 
 ! Test structure of the Pre-FIR tree
 
 ! CHECK: Subroutine foo
 subroutine foo()
   ! CHECK: <<DoConstruct>>
   ! CHECK: NonLabelDoStmt
   do i=1,5

flang/test/Lower/pre-fir-tree02.f90

-! RUN: %flang_fc1 -fsyntax-only -fdebug-pre-fir-tree %s | FileCheck %s
+! RUN: %flang_fc1 -fdebug-pre-fir-tree %s | FileCheck %s
 
 ! Test Pre-FIR Tree captures all the intended nodes from the parse-tree
 ! Coarray and OpenMP related nodes are tested in other files.
 
 ! CHECK: Program test_prog
 program test_prog
   ! Check specification part is not part of the tree.
   interface

flang/test/Lower/pre-fir-tree03.f90

-! RUN: %flang_fc1 -fsyntax-only -fdebug-pre-fir-tree -fopenmp %s | FileCheck %s
+! RUN: %flang_fc1 -fdebug-pre-fir-tree -fopenmp %s | FileCheck %s
 
 ! Test Pre-FIR Tree captures OpenMP related constructs
 
 ! CHECK: Program test_omp
 program test_omp
   ! CHECK: PrintStmt
   print *, "sequential"
 

flang/test/Lower/pre-fir-tree04.f90

-! RUN: %flang_fc1 -fsyntax-only -fdebug-pre-fir-tree %s | FileCheck %s
+! RUN: %flang_fc1 -fdebug-pre-fir-tree %s | FileCheck %s
 
 ! Test Pre-FIR Tree captures all the coarray related statements
 
 ! CHECK: Subroutine test_coarray
 Subroutine test_coarray
   use iso_fortran_env, only: team_type, event_type, lock_type
   type(team_type) :: t
   type(event_type) :: done

flang/test/Lower/pre-fir-tree05.f90

-! RUN: %flang_fc1 -fsyntax-only -fdebug-pre-fir-tree -fopenacc %s | FileCheck %s
+! RUN: %flang_fc1 -fdebug-pre-fir-tree -fopenacc %s | FileCheck %s
 
 ! Test structure of the Pre-FIR tree with OpenACC construct
 
 ! CHECK: Subroutine foo
 subroutine foo()
   ! CHECK-NEXT: <<OpenACCConstruct>>
   ! CHECK-NEXT: <<OpenACCConstruct>>
   !$acc parallel

flang/test/Semantics/data09.f90

-! RUN: %flang_fc1 -fsyntax-only -fdebug-dump-symbols %s 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -fdebug-dump-symbols %s 2>&1 | FileCheck %s
 ! CHECK: init:[INTEGER(4)::1065353216_4,1073741824_4,1077936128_4,1082130432_4]
 ! Verify that the closure of EQUIVALENCE'd symbols with any DATA
 ! initialization produces a combined initializer.
 real :: a(2), b(2), c(2)
 equivalence(a(2),b(1)),(b(2),c(1))
 data a(1)/1./,b(1)/2./,c/3.,4./
 common /block/ a
 end

flang/test/Semantics/data11.f90

-! RUN: %flang_fc1 -fsyntax-only -fdebug-dump-symbols %s 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -fdebug-dump-symbols %s 2>&1 | FileCheck %s
 ! CHECK:  Implied DO index 'j' uses an object of the same name in its bounds expressions
 ! CHECK: ObjectEntity type: REAL(4) shape: 1_8:5_8 init:[REAL(4)::1._4,2._4,3._4,4._4,5._4]
 ! Verify that the scope of a DATA statement implied DO loop index does
 ! not include the bounds expressions (language extension, with warning)
 integer, parameter :: j = 5
 real, save :: a(j)
 data (a(j),j=1,j)/1,2,3,4,5/
 end

flang/test/Semantics/data13.f90

-! RUN: %flang_fc1 -fsyntax-only -fdebug-dump-symbols %s 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -fdebug-dump-symbols %s 2>&1 | FileCheck %s
 ! Verify that the closure of EQUIVALENCE'd symbols with any DATA
 ! initialization produces a combined initializer, with explicit
 ! initialization overriding any default component initialization.
 ! CHECK: .F18.0, SAVE (CompilerCreated) size=8 offset=0: ObjectEntity type: INTEGER(4) shape: 1_8:2_8 init:[INTEGER(4)::456_4,234_4]
 ! CHECK: ja (InDataStmt) size=8 offset=0: ObjectEntity type: INTEGER(4) shape: 1_8:2_8
 ! CHECK-NOT: x0, SAVE size=8 offset=8: ObjectEntity type: TYPE(t1) init:t1(m=123_4,n=234_4)
 ! CHECK: x1 size=8 offset=16: ObjectEntity type: TYPE(t1) init:t1(m=345_4,n=234_4)
 ! CHECK: x2 size=8 offset=0: ObjectEntity type: TYPE(t1)

flang/test/Semantics/getdefinition01.f90

  end subroutine
  recursive pure function f() result(x)
   real, allocatable :: x
   x = 1.0
  end function
 end module
 
 ! RUN and CHECK lines at the bottom as this test is sensitive to line numbers
-! RUN: %flang_fc1 -fsyntax-only -fget-definition 6 17 18 %s | FileCheck --check-prefix=CHECK1 %s
-! RUN: %flang_fc1 -fsyntax-only -fget-definition 7 20 23 %s | FileCheck --check-prefix=CHECK2 %s
-! RUN: %flang_fc1 -fsyntax-only -fget-definition 14 3 4 %s | FileCheck --check-prefix=CHECK3 %s
+! RUN: %flang_fc1 -fget-definition 6 17 18 %s | FileCheck --check-prefix=CHECK1 %s
+! RUN: %flang_fc1 -fget-definition 7 20 23 %s | FileCheck --check-prefix=CHECK2 %s
+! RUN: %flang_fc1 -fget-definition 14 3 4 %s | FileCheck --check-prefix=CHECK3 %s
 ! CHECK1: x:{{.*}}getdefinition01.f90, 5, 21-22
 ! CHECK2: yyy:{{.*}}getdefinition01.f90, 5, 24-27
 ! CHECK3: x:{{.*}}getdefinition01.f90, 13, 24-25

flang/test/Semantics/getdefinition02.f

*  x
        end subroutine
        recursive pure function f() result(x)
         real, allocatable :: x
         x = 1.0
        end function
       end module
 
 ! RUN and CHECK lines here as test is sensitive to line numbers
-! RUN: %flang_fc1 -fsyntax-only -fget-definition 7 9 10 %s 2>&1 | FileCheck --check-prefix=CHECK1 %s
-! RUN: %flang_fc1 -fsyntax-only -fget-definition 8 26 29 %s 2>&1 | FileCheck --check-prefix=CHECK2 %s
-! RUN: %flang_fc1 -fsyntax-only -fget-definition 15 9 10 %s 2>&1 | FileCheck --check-prefix=CHECK3 %s
+! RUN: %flang_fc1 -fget-definition 7 9 10 %s 2>&1 | FileCheck --check-prefix=CHECK1 %s
+! RUN: %flang_fc1 -fget-definition 8 26 29 %s 2>&1 | FileCheck --check-prefix=CHECK2 %s
+! RUN: %flang_fc1 -fget-definition 15 9 10 %s 2>&1 | FileCheck --check-prefix=CHECK3 %s
 ! CHECK1: x:{{.*}}getdefinition02.f, 5, 27-28
 ! CHECK2: yyy:{{.*}}getdefinition02.f, 5, 30-33
 ! CHECK3: x:{{.*}}getdefinition02.f, 14, 30-31

flang/test/Semantics/getdefinition03-a.f90

 ! Tests -fget-definition with INCLUDE
 INCLUDE "Inputs/getdefinition03-b.f90"
 
 program main
  use m3
  integer :: x
  x = f
 end program
 
-! RUN: %flang_fc1 -fsyntax-only -fget-definition 7 6 7 %s | FileCheck --check-prefix=CHECK1 %s
-! RUN: %flang_fc1 -fsyntax-only -fget-definition 7 2 3 %s | FileCheck --check-prefix=CHECK2 %s
+! RUN: %flang_fc1 -fget-definition 7 6 7 %s | FileCheck --check-prefix=CHECK1 %s
+! RUN: %flang_fc1 -fget-definition 7 2 3 %s | FileCheck --check-prefix=CHECK2 %s
 ! CHECK1: f:{{.*}}getdefinition03-b.f90, 2, 12-13
 ! CHECK2: x:{{.*}}getdefinition03-a.f90, 6, 13-14

flang/test/Semantics/getdefinition04.f90

 ! Tests -fget-definition with COMMON block with same name as variable.
 program main
   integer :: x
   integer :: y
   common /x/ y
   x = y
 end program
 
-! RUN: %flang_fc1 -fsyntax-only -fget-definition 6 3 4 %s | FileCheck %s
+! RUN: %flang_fc1 -fget-definition 6 3 4 %s | FileCheck %s
 ! CHECK: x:{{.*}}getdefinition04.f90, 3, 14-15

flang/test/Semantics/getdefinition05.f90

 ! Tests -fget-symbols-sources with BLOCK that contains same variable name as 
 ! another in an outer scope.
 program main
   integer :: x
   integer :: y
   block
     integer :: x
     integer :: y
     x = y
   end block
   x = y
 end program
 
 !! Inner x
-! RUN: %flang_fc1 -fsyntax-only -fget-definition 9 5 6 %s | FileCheck --check-prefix=CHECK1 %s
+! RUN: %flang_fc1 -fget-definition 9 5 6 %s | FileCheck --check-prefix=CHECK1 %s
 ! CHECK1: x:{{.*}}getdefinition05.f90, 7, 16-17
 !! Outer y
-! RUN: %flang_fc1 -fsyntax-only -fget-definition 11 7 8 %s | FileCheck --check-prefix=CHECK2 %s
+! RUN: %flang_fc1 -fget-definition 11 7 8 %s | FileCheck --check-prefix=CHECK2 %s
 ! CHECK2: y:{{.*}}getdefinition05.f90, 5, 14-15

flang/test/Semantics/getsymbols01.f90

contains
   end subroutine
  end subroutine
  recursive pure function f() result(x)
   real, allocatable :: x
   x = 1.0
  end function
 end module
 
-! RUN: %flang_fc1 -fsyntax-only -fget-symbols-sources %s 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -fget-symbols-sources %s 2>&1 | FileCheck %s
 ! CHECK-COUNT-1:f:{{.*}}getsymbols01.f90, 12, 26-27
 ! CHECK-COUNT-1:mm1:{{.*}}getsymbols01.f90, 2, 8-11
 ! CHECK-COUNT-1:s:{{.*}}getsymbols01.f90, 5, 18-19
 ! CHECK-COUNT-1:ss:{{.*}}getsymbols01.f90, 9, 19-21
 ! CHECK-COUNT-1:x:{{.*}}getsymbols01.f90, 5, 21-22
 ! CHECK-COUNT-1:x:{{.*}}getsymbols01.f90, 13, 24-25
 ! CHECK-COUNT-1:y:{{.*}}getsymbols01.f90, 5, 24-25

flang/test/Semantics/getsymbols02.f90

 ! Tests -fget-symbols-sources with modules.
 
 PROGRAM helloworld
     use mm2b
     implicit none
     integer::i
     i = callget5()
 ENDPROGRAM
 
 ! RUN: %flang_fc1 -fsyntax-only %S/Inputs/getsymbols02-a.f90
 ! RUN: %flang_fc1 -fsyntax-only %S/Inputs/getsymbols02-b.f90
-! RUN: %flang_fc1 -fsyntax-only -fget-symbols-sources %s 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -fget-symbols-sources %s 2>&1 | FileCheck %s
 ! CHECK: callget5: .{{[/\\]}}mm2b.mod,
 ! CHECK: get5: .{{[/\\]}}mm2a.mod,

flang/test/Semantics/getsymbols03-a.f90

 ! Tests -fget-symbols with INCLUDE
 INCLUDE "Inputs/getsymbols03-b.f90"
 
 program main
  use mm3
  integer :: x
  x = f
 end program
 
-! RUN: %flang_fc1 -fsyntax-only -fget-symbols-sources %s 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -fget-symbols-sources %s 2>&1 | FileCheck %s
 ! CHECK:f:{{.*}}getsymbols03-b.f90, 2, 12-13
 ! CHECK:main:{{.*}}getsymbols03-a.f90, 4, 9-13
 ! CHECK:mm3:{{.*}}getsymbols03-a.f90, 5, 6-9
 ! CHECK:x:{{.*}}getsymbols03-a.f90, 6, 13-14

flang/test/Semantics/getsymbols04.f90

 ! Tests -fget-symbols-sources with COMMON.
 program main
   integer :: x
   integer :: y
   common /x/ y
   x = y
 end program
 
-! RUN: %flang_fc1 -fsyntax-only -fget-symbols-sources %s 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -fget-symbols-sources %s 2>&1 | FileCheck %s
 ! CHECK:x:{{.*}}getsymbols04.f90, 3, 14-15
 ! CHECK:x:{{.*}}getsymbols04.f90, 5, 11-12
 ! CHECK:y:{{.*}}getsymbols04.f90, 4, 14-15

flang/test/Semantics/getsymbols05.f90

 ! Tests -fget-symbols-sources with COMMON.
 program main
   integer :: x
   integer :: y
   block
     integer :: x
     x = y
   end block
   x = y
 end program
 
-! RUN: %flang_fc1 -fsyntax-only -fget-symbols-sources %s 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -fget-symbols-sources %s 2>&1 | FileCheck %s
 ! CHECK:x:{{.*}}getsymbols05.f90, 3, 14-15
 ! CHECK:x:{{.*}}getsymbols05.f90, 6, 16-17
 ! CHECK:y:{{.*}}getsymbols05.f90, 4, 14-15

llvm/include/llvm/Option/ArgList.h

public:
   bool hasArgNoClaim(OptSpecifiers ...Ids) const {
     return getLastArgNoClaim(Ids...) != nullptr;
   }
   template<typename ...OptSpecifiers>
   bool hasArg(OptSpecifiers ...Ids) const {
     return getLastArg(Ids...) != nullptr;
   }
 
+  /// Return true if the arg list contains multiple arguments matching \p Id.
+  bool hasMultipleArgs(OptSpecifier Id) const {
+    auto Args = filtered(Id);
+    return (Args.begin() != Args.end()) && (++Args.begin()) != Args.end();
+  }
+
   /// Return the last argument matching \p Id, or null.
   template<typename ...OptSpecifiers>
   Arg *getLastArg(OptSpecifiers ...Ids) const {
     Arg *Res = nullptr;
     for (Arg *A : filtered(Ids...)) {
       Res = A;
       Res->claim();
     }