[flang][driver] Add options for unparsing

[awarzynski]

Summary

This patch adds the following compiler frontend driver options:

• -fdebug-unparse (f18 spelling: -funparse)
• -fdebug-unparse-with-symbols (f18 spelling: -funparse-with-symbols)

The new driver will only accept the new spelling. f18 will accept both
the original and the new spelling.

A new base class for frontend actions is added: PrescanAndSemaAction.
This is added to reduce code duplication that otherwise these new
options would lead to. Implementation from

• ParseSyntaxOnlyAction::ExecutionAction

is moved to:

• PrescanAndSemaAction::BeginSourceFileAction

This implementation is now shared between:

• PrescanAndSemaAction
• ParseSyntaxOnlyAction
• DebugUnparseAction
• DebugUnparseWithSymbolsAction

All tests that don't require other yet unimplemented options are
updated. This way flang-new -fc1 is used instead of f18 when
FLANG_BUILD_NEW_DRIVER is set to On. In order to facilitate this,
%flang_fc1 is added in the LIT configuration (lit.cfg.py).

asFortran from f18.cpp is duplicated as getBasicAsFortran in
FrontendOptions.cpp. At this stage it's hard to find a good place to
share this method. I suggest that we revisit this once a switch from
f18 to flang-new is complete.

[tskeith]

flang/tools/f18/f18.cpp

543

This should be "-fdebug-unparse" (with a hyphen). That may be why all those tests are failing.

[awarzynski]

Fix typo in f18.cpp

flang/tools/f18/f18.cpp

543

Fixed, thank you!

[FarisRehman]

Thanks for working on this @awarzynski
Do you know what the use of GetActionKindName in FrontendOptions.h is, as it is currently not being called anywhere and whilst this patch currently does not update that method with the 2 new cases, even if it did no change would be visible.
Other than that, looks good to me!

flang/test/lit.cfg.py

87

[nit] Is there a reason to have this as a separate if-else instead of merging with the existing if-else

[awarzynski]

Updated lit.cfg.py

[awarzynski]

In D96483#2563323, @FarisRehman wrote:

Do you know what the use of GetActionKindName in FrontendOptions.h is, as it is currently not being called anywhere and whilst this patch currently does not update that method with the 2 new cases, even if it did no change would be visible.

I'm not sure why this method is there TBH :) Perhaps @CarolineConcatto would know? I suspect that C&P error. I suggest removing it in a separate NFC patch. Thank you for pointing that out!

flang/test/lit.cfg.py

87

Good point, updated!

[FarisRehman]

Thanks for clarifying

clang/include/clang/Driver/Options.td

 file}]>;
 def ffixed_line_length_VALUE : Joined<["-"], "ffixed-line-length-">, Group<f_Group>, Alias<ffixed_line_length_EQ>;
 def fopenacc : Flag<["-"], "fopenacc">, Group<f_Group>,
   HelpText<"Enable OpenACC">;
 
 }
 
 //===----------------------------------------------------------------------===//
+// FC1 Options
+//===----------------------------------------------------------------------===//
+let Flags = [FC1Option, FlangOnlyOption] in {
+
+def fdebug_unparse : Flag<["-"], "fdebug-unparse">, Group<Action_Group>,
+  HelpText<"Unparse and stop.">;
+def fdebug_unparse_with_symbols : Flag<["-"], "fdebug-unparse-with-symbols">, Group<Action_Group>,
+  HelpText<"Unparse and stop.">;
+
+}
+
+//===----------------------------------------------------------------------===//
 // CC1 Options
 //===----------------------------------------------------------------------===//
 
 let Flags = [CC1Option, NoDriverOption] in {
 
 //===----------------------------------------------------------------------===//
 // Target Options
 //===----------------------------------------------------------------------===//

flang/include/flang/Frontend/FrontendActions.h

class PrescanAction : public FrontendAction {
   void ExecuteAction() override = 0;
   bool BeginSourceFileAction(CompilerInstance &ci) override;
 };
 
 class PrintPreprocessedAction : public PrescanAction {
   void ExecuteAction() override;
 };
 
-class ParseSyntaxOnlyAction : public PrescanAction {
+//===----------------------------------------------------------------------===//
+// PrescanAndSema Actions
+//===----------------------------------------------------------------------===//
+class PrescanAndSemaAction : public FrontendAction {
+  void ExecuteAction() override = 0;
+  bool BeginSourceFileAction(CompilerInstance &ci) override;
+};
+
+class DebugUnparseWithSymbolsAction : public PrescanAndSemaAction {
+  void ExecuteAction() override;
+};
+
+class DebugUnparseAction : public PrescanAndSemaAction {
+  void ExecuteAction() override;
+};
+
+class ParseSyntaxOnlyAction : public PrescanAndSemaAction {
   void ExecuteAction() override;
 };
 
 } // namespace Fortran::frontend
 
 #endif // LLVM_FLANG_FRONTEND_FRONTENDACTIONS_H

flang/include/flang/Frontend/FrontendOptions.h

 //===- FrontendOptions.h ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_FLANG_FRONTEND_FRONTENDOPTIONS_H
 #define LLVM_FLANG_FRONTEND_FRONTENDOPTIONS_H
 
 #include "flang/Common/Fortran-features.h"
+#include "flang/Parser/unparse.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 #include <cstdint>
 #include <string>
 
 namespace Fortran::frontend {
 
 enum ActionKind {
   InvalidAction = 0,
 
   /// -test-io mode
   InputOutputTest,
 
   /// -E mode.
   PrintPreprocessedInput,
 
   /// -fsyntax-only
   ParseSyntaxOnly,
 
   /// Emit a .o file.
   EmitObj,
 
+  /// Parse, unparse the parse-tree and output a Fortran source file
+  DebugUnparse,
+
+  /// Parse, resolve the sybmols, unparse the parse-tree and then output a
+  /// Fortran source file
+  DebugUnparseWithSymbols,
+
   /// TODO: RunPreprocessor, EmitLLVM, EmitLLVMOnly,
   /// EmitCodeGenOnly, EmitAssembly, (...)
 };
 
 /// \param suffix The file extension
 /// \return True if the file extension should be processed as fixed form
 bool isFixedFormSuffix(llvm::StringRef suffix);
 
+// TODO: Find a more suitable location for this. Added for compability with
+// f18.cpp (this is equivalent to `asFortran` defined there).
+Fortran::parser::AnalyzedObjectsAsFortran getBasicAsFortran();
+
 /// \param suffix The file extension
 /// \return True if the file extension should be processed as free form
 bool isFreeFormSuffix(llvm::StringRef suffix);
 
 inline const char *GetActionKindName(const ActionKind ak) {
   switch (ak) {
   case InputOutputTest:
     return "InputOutputTest";

flang/lib/Frontend/CMakeLists.txt

 add_flang_library(flangFrontend
   CompilerInstance.cpp
   CompilerInvocation.cpp
   FrontendAction.cpp
   FrontendActions.cpp
   FrontendOptions.cpp
   TextDiagnosticPrinter.cpp
   TextDiagnosticBuffer.cpp
   TextDiagnostic.cpp
 
   DEPENDS
   clangBasic
 
   LINK_LIBS
   FortranParser
   FortranSemantics
+  FortranEvaluate
   FortranCommon
   clangBasic
   clangDriver
 
   LINK_COMPONENTS
   Option
   Support
 )

flang/lib/Frontend/CompilerInvocation.cpp

case clang::driver::options::OPT_E:
       opts.programAction_ = PrintPreprocessedInput;
       break;
     case clang::driver::options::OPT_fsyntax_only:
       opts.programAction_ = ParseSyntaxOnly;
       break;
     case clang::driver::options::OPT_emit_obj:
       opts.programAction_ = EmitObj;
       break;
+    case clang::driver::options::OPT_fdebug_unparse:
+      opts.programAction_ = DebugUnparse;
+      break;
+    case clang::driver::options::OPT_fdebug_unparse_with_symbols:
+      opts.programAction_ = DebugUnparseWithSymbols;
+      break;
 
       // TODO:
       // case calng::driver::options::OPT_emit_llvm:
       // case clang::driver::options::OPT_emit_llvm_only:
       // case clang::driver::options::OPT_emit_codegen_only:
       // case clang::driver::options::OPT_emit_module:
       // (...)
     }

flang/lib/Frontend/FrontendActions.cpp

 //===--- FrontendActions.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
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Frontend/FrontendActions.h"
 #include "flang/Common/default-kinds.h"
 #include "flang/Frontend/CompilerInstance.h"
+#include "flang/Frontend/FrontendOptions.h"
 #include "flang/Parser/parsing.h"
 #include "flang/Parser/provenance.h"
 #include "flang/Parser/source.h"
+#include "flang/Parser/unparse.h"
 #include "flang/Semantics/semantics.h"
+#include "flang/Semantics/unparse-with-symbols.h"
 
 using namespace Fortran::frontend;
 
 bool PrescanAction::BeginSourceFileAction(CompilerInstance &c1) {
   CompilerInstance &ci = this->instance();
 
   std::string currentInputPath{GetCurrentFileOrBufferName()};
 
if (ci.parsing().messages().AnyFatalError()) {
     ci.parsing().messages().Emit(llvm::errs(), ci.allCookedSources());
 
     return false;
   }
 
   return true;
 }
 
+bool PrescanAndSemaAction::BeginSourceFileAction(CompilerInstance &c1) {
+  CompilerInstance &ci = this->instance();
+
+  std::string currentInputPath{GetCurrentFileOrBufferName()};
+
+  Fortran::parser::Options parserOptions = ci.invocation().fortranOpts();
+
+  if (ci.invocation().frontendOpts().fortranForm_ == FortranForm::Unknown) {
+    // Switch between fixed and free form format based on the input file
+    // extension.
+    //
+    // Ideally we should have all Fortran options set before entering this
+    // method (i.e. before processing any specific input files). However, we
+    // can't decide between fixed and free form based on the file extension
+    // earlier than this.
+    parserOptions.isFixedForm = currentInput().IsFixedForm();
+  }
+
+  // Prescan. In case of failure, report and return.
+  ci.parsing().Prescan(currentInputPath, parserOptions);
+
+  if (ci.parsing().messages().AnyFatalError()) {
+    const unsigned diagID = ci.diagnostics().getCustomDiagID(
+        clang::DiagnosticsEngine::Error, "Could not scan %0");
+    ci.diagnostics().Report(diagID) << GetCurrentFileOrBufferName();
+    ci.parsing().messages().Emit(llvm::errs(), ci.allCookedSources());
+
+    return false;
+  }
+
+  // Parse. In case of failure, report and return.
+  ci.parsing().Parse(llvm::outs());
+
+  if (ci.parsing().messages().AnyFatalError()) {
+    unsigned diagID = ci.diagnostics().getCustomDiagID(
+        clang::DiagnosticsEngine::Error, "Could not parse %0");
+    ci.diagnostics().Report(diagID) << GetCurrentFileOrBufferName();
+
+    ci.parsing().messages().Emit(
+        llvm::errs(), this->instance().allCookedSources());
+    return false;
+  }
+
+  // Report the diagnostics from parsing
+  ci.parsing().messages().Emit(llvm::errs(), ci.allCookedSources());
+
+  auto &parseTree{*ci.parsing().parseTree()};
+
+  // Prepare semantics
+  Fortran::semantics::Semantics semantics{ci.invocation().semanticsContext(),
+      parseTree, ci.parsing().cooked().AsCharBlock()};
+
+  // Run semantic checks
+  semantics.Perform();
+
+  // Report the diagnostics from the semantic checks
+  semantics.EmitMessages(ci.semaOutputStream());
+
+  if (semantics.AnyFatalError()) {
+    unsigned DiagID = ci.diagnostics().getCustomDiagID(
+        clang::DiagnosticsEngine::Error, "Semantic errors in %0");
+    ci.diagnostics().Report(DiagID) << GetCurrentFileOrBufferName();
+
+    return false;
+  }
+
+  return true;
+}
+
 void InputOutputTestAction::ExecuteAction() {
   CompilerInstance &ci = instance();
 
   // Create a stream for errors
   std::string buf;
   llvm::raw_string_ostream error_stream{buf};
 
   // Read the input file
if (auto os{ci.CreateDefaultOutputFile(
           /*Binary=*/true, /*InFile=*/GetCurrentFileOrBufferName())}) {
     (*os) << outForPP.str();
   } else {
     llvm::errs() << "Unable to create the output file\n";
     return;
   }
 }
 
-void ParseSyntaxOnlyAction::ExecuteAction() {
-  CompilerInstance &ci = this->instance();
+void ParseSyntaxOnlyAction::ExecuteAction() {}
 
-  // Parse. In case of failure, report and return.
-  ci.parsing().Parse(llvm::outs());
+void DebugUnparseAction::ExecuteAction() {
+  auto &parseTree{instance().parsing().parseTree()};
+  Fortran::parser::AnalyzedObjectsAsFortran asFortran =
+      Fortran::frontend::getBasicAsFortran();
 
-  if (ci.parsing().messages().AnyFatalError()) {
-    unsigned diagID = ci.diagnostics().getCustomDiagID(
-        clang::DiagnosticsEngine::Error, "Could not parse %0");
-    ci.diagnostics().Report(diagID) << GetCurrentFileOrBufferName();
-
-    ci.parsing().messages().Emit(
-        llvm::errs(), this->instance().allCookedSources());
-    return;
-  }
+  // TODO: Options should come from CompilerInvocation
+  Unparse(llvm::outs(), *parseTree,
+      /*encoding=*/Fortran::parser::Encoding::UTF_8,
+      /*capitalizeKeywords=*/true, /*backslashEscapes=*/false,
+      /*preStatement=*/nullptr, &asFortran);
 
-  // Report the diagnostics from parsing
-  ci.parsing().messages().Emit(llvm::errs(), ci.allCookedSources());
-
-  auto &parseTree{*ci.parsing().parseTree()};
-
-  // Prepare semantics
-  Fortran::semantics::Semantics semantics{ci.invocation().semanticsContext(),
-      parseTree, ci.parsing().cooked().AsCharBlock()};
-
-  // Run semantic checks
-  semantics.Perform();
-
-  // Report the diagnostics from the semantic checks
-  semantics.EmitMessages(ci.semaOutputStream());
+void DebugUnparseWithSymbolsAction::ExecuteAction() {
+  auto &parseTree{*instance().parsing().parseTree()};
 
-  if (semantics.AnyFatalError()) {
-    unsigned DiagID = ci.diagnostics().getCustomDiagID(
-        clang::DiagnosticsEngine::Error, "Semantic errors in %0");
-    ci.diagnostics().Report(DiagID) << GetCurrentFileOrBufferName();
-  }
+  Fortran::semantics::UnparseWithSymbols(
+      llvm::outs(), parseTree, /*encoding=*/Fortran::parser::Encoding::UTF_8);
 }
 
 void EmitObjAction::ExecuteAction() {
   CompilerInstance &ci = this->instance();
   unsigned DiagID = ci.diagnostics().getCustomDiagID(
       clang::DiagnosticsEngine::Error, "code-generation is not available yet");
   ci.diagnostics().Report(DiagID);
 }

flang/lib/Frontend/FrontendOptions.cpp

 //===- FrontendOptions.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
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Frontend/FrontendOptions.h"
+#include "flang/Evaluate/expression.h"
 
 using namespace Fortran::frontend;
 
 bool Fortran::frontend::isFixedFormSuffix(llvm::StringRef suffix) {
   // Note: Keep this list in-sync with flang/test/lit.cfg.py
   return suffix == "f" || suffix == "F" || suffix == "ff" || suffix == "for" ||
       suffix == "FOR" || suffix == "fpp" || suffix == "FPP";
 }
 
 bool Fortran::frontend::isFreeFormSuffix(llvm::StringRef suffix) {
   // Note: Keep this list in-sync with flang/test/lit.cfg.py
   // TODO: Add Cuda Fortan files (i.e. `*.cuf` and `*.CUF`).
   return suffix == "f77" || suffix == "f90" || suffix == "F90" ||
       suffix == "ff90" || suffix == "f95" || suffix == "F95" ||
       suffix == "ff95" || suffix == "f03" || suffix == "F03" ||
       suffix == "f08" || suffix == "F08" || suffix == "f18" || suffix == "F18";
 }
 
+// TODO: This is a copy of `asFortran` from f18.cpp and is added here for
+// compatiblity. It doesn't really belong here, but I couldn't find a better
+// place. We should decide whether to add it to the Evaluate or Parse/Unparse
+// APIs or some dedicated utility library in the driver.
+Fortran::parser::AnalyzedObjectsAsFortran
+Fortran::frontend::getBasicAsFortran() {
+  return Fortran::parser::AnalyzedObjectsAsFortran{
+      [](llvm::raw_ostream &o, const Fortran::evaluate::GenericExprWrapper &x) {
+        if (x.v) {
+          x.v->AsFortran(o);
+        } else {
+          o << "(bad expression)";
+        }
+      },
+      [](llvm::raw_ostream &o,
+          const Fortran::evaluate::GenericAssignmentWrapper &x) {
+        if (x.v) {
+          x.v->AsFortran(o);
+        } else {
+          o << "(bad assignment)";
+        }
+      },
+      [](llvm::raw_ostream &o, const Fortran::evaluate::ProcedureRef &x) {
+        x.AsFortran(o << "CALL ");
+      },
+  };
+}
+
 InputKind FrontendOptions::GetInputKindForExtension(llvm::StringRef extension) {
   if (isFixedFormSuffix(extension) || isFreeFormSuffix(extension)) {
     return Language::Fortran;
   }
   return Language::Unknown;
 }

flang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

static std::unique_ptr<FrontendAction> CreateFrontendBaseAction(
   case PrintPreprocessedInput:
     return std::make_unique<PrintPreprocessedAction>();
     break;
   case ParseSyntaxOnly:
     return std::make_unique<ParseSyntaxOnlyAction>();
   case EmitObj:
     return std::make_unique<EmitObjAction>();
     break;
+  case DebugUnparse:
+    return std::make_unique<DebugUnparseAction>();
+    break;
+  case DebugUnparseWithSymbols:
+    return std::make_unique<DebugUnparseWithSymbolsAction>();
+    break;
   default:
     break;
     // TODO:
     // case RunPreprocessor:
     // case ParserSyntaxOnly:
     // case EmitLLVM:
     // case EmitLLVMOnly:
     // case EmitCodeGenOnly:

flang/lib/Parser/CMakeLists.txt

-
 add_flang_library(FortranParser
   Fortran-parsers.cpp
   char-buffer.cpp
   char-block.cpp
   char-set.cpp
   characters.cpp
   debug-parser.cpp
   executable-parsers.cpp

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

 ! EXPECTED OUTPUT FOR FLANG FRONTEND DRIVER (flang-new -fc1)
 !-------------------------------------------------------------
 ! HELP-FC1:USAGE: flang-new
 ! HELP-FC1-EMPTY:
 ! HELP-FC1-NEXT:OPTIONS:
 ! HELP-FC1-NEXT: -D <macro>=<value>     Define <macro> to <value> (or 1 if <value> omitted)
 ! HELP-FC1-NEXT: -emit-obj Emit native object files
 ! HELP-FC1-NEXT: -E                     Only run the preprocessor
+! HELP-FC1-NEXT: -fdebug-unparse-with-symbols
+! HELP-FC1-NEXT:                        Unparse and stop.
+! HELP-FC1-NEXT: -fdebug-unparse        Unparse and stop.
 ! HELP-FC1-NEXT: -ffixed-form           Process source files in fixed form
 ! HELP-FC1-NEXT: -ffixed-line-length=<value>
 ! HELP-FC1-NEXT: Use <value> as character line width in fixed mode
 ! HELP-FC1-NEXT: -ffree-form            Process source files in free form
 ! HELP-FC1-NEXT: -fopenacc              Enable OpenACC
 ! HELP-FC1-NEXT: -fopenmp               Parse OpenMP pragmas and generate parallel code.
 ! HELP-FC1-NEXT: -help                  Display available options
 ! HELP-FC1-NEXT: -I <dir>               Add directory to the end of the list of include search paths

flang/test/Parser/continuation-in-if.f

-! RUN: %f18 -funparse %s 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -fdebug-unparse %s 2>&1 | FileCheck %s
 ! CHECK: CALL foo("N","N")
 #ifdef transpose
       call foo('T',
 #else
       call foo('N',
 #endif
      $     'N')
       end

flang/test/Parser/pp-dir-comments.f90

-! RUN: %f18 -funparse %s 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -fdebug-unparse %s 2>&1 | FileCheck %s
 
 #define pmk
 #ifdef pmk // comment
 ! CHECK: t1
 real t1
 #endif // comment
 #undef pmk ! comment
 #ifndef pmk ! comment

flang/test/Semantics/canondo01.f90

 
-! RUN: %f18 -funparse-with-symbols %s 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -fdebug-unparse-with-symbols %s 2>&1 | FileCheck %s
 ! CHECK: end do
 
 SUBROUTINE sub00(a,b,n,m)
   INTEGER n,m
   REAL a(n,m), b(n,m)
 
   DO 10 j = 1,m
      DO 10 i = 1,n
         g = a(i,j) - b(i,j)
 10      PRINT *, g
 END SUBROUTINE sub00

flang/test/Semantics/canondo02.f90

 
-! RUN: %f18 -funparse-with-symbols %s 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -fdebug-unparse-with-symbols %s 2>&1 | FileCheck %s
 ! CHECK: end do
 
 SUBROUTINE sub00(a,b,n,m)
   INTEGER n,m
   REAL a(n,m), b(n,m)
 
   i = n-1
   DO 10 j = 1,m
      g = a(i,j) - b(i,j)
 10   PRINT *, g
 END SUBROUTINE sub00

flang/test/Semantics/canondo03.f90

 
-! RUN: %f18 -funparse-with-symbols %s 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -fdebug-unparse-with-symbols %s 2>&1 | FileCheck %s
 ! CHECK: 10 continue
 ! CHECK: end do
 
 SUBROUTINE sub00(a,b,n,m)
   INTEGER n,m
   REAL a(n,m), b(n,m)
 
   i = n-1
   DO 10 j = 1,m
      g = a(i,j) - b(i,j)
      PRINT *, g
 10 END DO
 END SUBROUTINE sub00

flang/test/Semantics/canondo04.f90

-! RUN: %f18 -funparse-with-symbols %s 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -fdebug-unparse-with-symbols %s 2>&1 | FileCheck %s
 ! CHECK-NOT: do [1-9]
 
 ! Figure out how to also execute this test.
 
 program main
   integer :: results(100)
   integer :: count
   count = 0

flang/test/Semantics/canondo05.f90

-! RUN: %f18 -funparse-with-symbols %s 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -fdebug-unparse-with-symbols %s 2>&1 | FileCheck %s
 ! RUN: %f18 -fopenmp -funparse-with-symbols %s 2>&1 | FileCheck %s
 ! CHECK-NOT: do *[1-9]
 
 program P
 implicit none
 integer OMP_GET_NUM_THREADS, OMP_GET_THREAD_NUM
 integer NUMTHRDS, TID
 integer N, CSZ, CNUM, I

flang/test/Semantics/critical04.f90

-! RUN: %f18 -funparse-with-symbols %s 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -fdebug-unparse-with-symbols %s 2>&1 | FileCheck %s
 ! CHECK-NOT: Control flow escapes from CRITICAL
 
 subroutine test1(a, i)
   integer i
   real a(10)
   critical
     if (a(i) < 0.0) then
       a(i) = 20.20

flang/test/Semantics/defined-ops.f90

-! RUN: %f18 -funparse %s 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -fdebug-unparse %s 2>&1 | FileCheck %s
 
 ! Check the analyzed form of a defined operator or assignment.
 
 ! Type-bound defined assignment
 module m1
   type :: t
   contains
     procedure :: b1 => s1

flang/test/Semantics/doconcurrent02.f90

 ! when the loops are not DO CONCURRENT
 
-! RUN: not %f18 -funparse-with-symbols %s 2>&1 | FileCheck %s
+! RUN: not %flang_fc1 -fdebug-unparse-with-symbols %s 2>&1 | FileCheck %s
 ! CHECK-NOT: image control statement not allowed in DO CONCURRENT
 ! CHECK-NOT: RETURN not allowed in DO CONCURRENT
 ! CHECK-NOT: call to impure procedure in DO CONCURRENT not allowed
 ! CHECK-NOT: IEEE_GET_FLAG not allowed in DO CONCURRENT
 ! CHECK-NOT: ADVANCE specifier not allowed in DO CONCURRENT
 ! CHECK-NOT: SYNC ALL
 ! CHECK-NOT: SYNC IMAGES
 

flang/test/Semantics/doconcurrent03.f90

-! RUN: not %f18 -funparse-with-symbols %s 2>&1 | FileCheck %s
+! RUN: not %flang_fc1 -fdebug-unparse-with-symbols %s 2>&1 | FileCheck %s
 ! CHECK: Control flow escapes from DO CONCURRENT
 ! CHECK: branch into loop body from outside
 ! CHECK: the loop branched into
 
 subroutine s(a)
   integer i
   real a(10)
   do 10 concurrent (i = 1:10)

flang/test/Semantics/doconcurrent04.f90

 ! C1122 The index-name shall be a named scalar variable of type integer.
-! RUN: not %f18 -funparse-with-symbols %s 2>&1 | FileCheck %s
+! RUN: not %flang_fc1 -fdebug-unparse-with-symbols %s 2>&1 | FileCheck %s
 ! CHECK: Must have INTEGER type, but is REAL(4)
 
 subroutine do_concurrent_test1(n)
   implicit none
   integer :: n
   real :: j
   do 20 concurrent (j = 1:n)
 20 enddo
 end subroutine do_concurrent_test1

flang/test/Semantics/doconcurrent07.f90

-! RUN: %f18 -funparse-with-symbols %s 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -fdebug-unparse-with-symbols %s 2>&1 | FileCheck %s
 ! CHECK-NOT: exit from DO CONCURRENT construct
 
 subroutine do_concurrent_test1(n)
   implicit none
   integer :: j,k,l,n
   mytest: if (n>0) then
   mydoc:    do concurrent(j=1:n)
               mydo: do k=1,n

flang/test/Semantics/label02.f90

 
-! RUN: not %f18 -funparse-with-symbols %s 2>&1 | FileCheck %s
+! RUN: not %flang_fc1 -fdebug-unparse-with-symbols %s 2>&1 | FileCheck %s
 ! CHECK: Label '0' is out of range
 ! CHECK: Label '100000' is out of range
 ! CHECK: Label '123456' is out of range
 ! CHECK: Label '123456' was not found
 ! CHECK: Label '1000' is not distinct
 
 subroutine sub00(a,b,n,m)
   real a(n)
   real :: b(m)
 0 print *, "error"
 100000 print *, n
   goto 123456
 1000 print *, m
 1000 print *, m+1
 end subroutine sub00

flang/test/Semantics/label03.f90

 
-! RUN: not %f18 -funparse-with-symbols %s 2>&1 | FileCheck %s
+! RUN: not %flang_fc1 -fdebug-unparse-with-symbols %s 2>&1 | FileCheck %s
 ! CHECK: DO loop doesn't properly nest
 ! CHECK: DO loop conflicts
 ! CHECK: Label '30' cannot be found
 ! CHECK: Label '40' cannot be found
 ! CHECK: Label '50' doesn't lexically follow DO stmt
 
 subroutine sub00(a,b,n,m)
   real a(n,m)

flang/test/Semantics/label04.f90

 
-! RUN: %f18 -funparse-with-symbols %s 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -fdebug-unparse-with-symbols %s 2>&1 | FileCheck %s
 ! CHECK: branch into loop body from outside
 ! CHECK: do 10 i = 1, m
 ! CHECK: the loop branched into
 ! CHECK: do 20 j = 1, n
 
 subroutine sub00(a,b,n,m)
   real a(n,m)
   real b(n,m)

flang/test/Semantics/label05.f90

 
-! RUN: not %f18 -funparse-with-symbols %s 2>&1 | FileCheck %s
+! RUN: not %flang_fc1 -fdebug-unparse-with-symbols %s 2>&1 | FileCheck %s
 ! CHECK: Label '50' was not found
 ! CHECK: Label '55' is not in scope
 ! CHECK: Label '70' is not a branch target
 ! CHECK: Control flow use of '70'
 
 subroutine sub00(a,b,n,m)
   real a(n,m)
   real b(n,m)

flang/test/Semantics/label06.f90

 
-! RUN: not %f18 -funparse-with-symbols %s 2>&1 | FileCheck %s
+! RUN: not %flang_fc1 -fdebug-unparse-with-symbols %s 2>&1 | FileCheck %s
 ! CHECK: Label '10' is not in scope
 ! CHECK: Label '20' was not found
 ! CHECK: Label '30' is not a branch target
 ! CHECK: Control flow use of '30'
 ! CHECK: Label '40' is not in scope
 ! CHECK: Label '50' is not in scope
 
 subroutine sub00(n)

flang/test/Semantics/label07.f90

 
-! RUN: not %f18 -funparse-with-symbols %s 2>&1 | FileCheck %s
+! RUN: not %flang_fc1 -fdebug-unparse-with-symbols %s 2>&1 | FileCheck %s
 ! CHECK: Label '30' is not a branch target
 ! CHECK: Control flow use of '30'
 ! CHECK: Label '10' is not in scope
 ! CHECK: Label '20' was not found
 ! CHECK: Label '60' was not found
 
 subroutine sub00(n,m)
 30 format (i6,f6.2)
   if (n .eq. m) then
 10   print *,"equal"
   end if
   call sub01(n,*10,*20,*30)
   write (*,60) n, m
 end subroutine sub00

flang/test/Semantics/label08.f90

 
-! RUN: not %f18 -funparse-with-symbols %s 2>&1 | FileCheck %s
+! RUN: not %flang_fc1 -fdebug-unparse-with-symbols %s 2>&1 | FileCheck %s
 ! CHECK: CYCLE construct-name is not in scope
 ! CHECK: IF construct name unexpected
 ! CHECK: unnamed IF statement
 ! CHECK: DO construct name mismatch
 ! CHECK: should be
 
 subroutine sub00(a,b,n,m)
   real a(n,m)

flang/test/Semantics/label09.f90

-! RUN: not %f18 -funparse-with-symbols %s 2>&1 | FileCheck %s
+! RUN: not %flang_fc1 -fdebug-unparse-with-symbols %s 2>&1 | FileCheck %s
 ! CHECK: Label '60' was not found
 
 subroutine s(a)
   real a(10)
   write(*,60) "Hi there"
 end subroutine s

flang/test/Semantics/label10.f90

-! RUN: not %f18 -funparse-with-symbols %s 2>&1 | FileCheck %s
+! RUN: not %flang_fc1 -fdebug-unparse-with-symbols %s 2>&1 | FileCheck %s
 ! CHECK: '60' not a FORMAT
 ! CHECK: data transfer use of '60'
 
 subroutine s(a)
   real a(10)
   write(*,60) "Hi there"
 60 continue
 70 format (i8)
 end subroutine s

flang/test/Semantics/label12.f90

-! RUN: not %f18 -funparse-with-symbols %s 2>&1 | FileCheck %s
+! RUN: not %flang_fc1 -fdebug-unparse-with-symbols %s 2>&1 | FileCheck %s
 ! CHECK: expected end of statement
 
 subroutine s
   do 10 i = 1, 10
 5  end do
 10 end do
 end subroutine s

flang/test/Semantics/label13.f90

-! RUN: %f18 -funparse-with-symbols %s 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -fdebug-unparse-with-symbols %s 2>&1 | FileCheck %s
 ! CHECK: branch into loop body from outside
 ! CHECK: the loop branched into
 
 subroutine s(a)
   integer i
   real a(10)
   do 10 i = 1,10
      if (a(i) < 0.0) then

flang/test/Semantics/label15.f90

-! RUN: %f18 -funparse %s 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -fdebug-unparse %s 2>&1 | FileCheck %s
 
 !CHECK-NOT: error:
 module mm
    interface
       module subroutine m(n)
       end
    end interface
 end module mm

flang/test/lit.cfg.py

tools = [
   ToolSubst('%f18', command=FindTool('f18'),
     extra_args=["-intrinsic-module-directory "+config.flang_intrinsic_modules_dir],
     unresolved='fatal')
 ]
 
 if config.include_flang_new_driver_test:
    tools.append(ToolSubst('%flang-new', command=FindTool('flang-new'), unresolved='fatal'))
    tools.append(ToolSubst('%flang', command=FindTool('flang-new'), unresolved='fatal'))
+   tools.append(ToolSubst('%flang_fc1', command=FindTool('flang-new'),
+    extra_args=['-fc1'], unresolved='fatal'))
 else:
    tools.append(ToolSubst('%flang', command=FindTool('f18'),
     extra_args=["-intrinsic-module-directory "+config.flang_intrinsic_modules_dir],
     unresolved='fatal'))
+   tools.append(ToolSubst('%flang_fc1', command=FindTool('f18'),
+    extra_args=["-intrinsic-module-directory "+config.flang_intrinsic_modules_dir],
+    unresolved='fatal'))
 
 if config.flang_standalone_build:
     llvm_config.add_tool_substitutions(tools, [config.flang_llvm_tools_dir])
 else:
     llvm_config.add_tool_substitutions(tools, config.llvm_tools_dir)
 
 # Enable libpgmath testing
 result = lit_config.params.get("LIBPGMATH")
 if result:
     config.environment["LIBPGMATH"] = True

flang/tools/f18/f18.cpp

while (!args.empty()) {
     } else if (arg == "-fdebug-module-writer") {
       driver.debugModuleWriter = true;
     } else if (arg == "-fdebug-measure-parse-tree") {
       driver.measureTree = true;
     } else if (arg == "-fdebug-instrumented-parse") {
       options.instrumentedParse = true;
     } else if (arg == "-fdebug-no-semantics") {
       driver.debugNoSemantics = true;
-    } else if (arg == "-funparse") {
+    } else if (arg == "-funparse" || arg == "-fdebug-unparse") {
       driver.dumpUnparse = true;
-    } else if (arg == "-funparse-with-symbols") {
+    } else if (arg == "-funparse-with-symbols" ||
+        arg == "-fdebug-unparse-with-symbols") {
       driver.dumpUnparseWithSymbols = true;
     } else if (arg == "-funparse-typed-exprs-to-f18-fc") {
       driver.unparseTypedExprsToF18_FC = true;
     } else if (arg == "-fparse-only" || arg == "-fsyntax-only") {
       driver.syntaxOnly = true;
     } else if (arg == "-c") {
       driver.compileOnly = true;
     } else if (arg == "-o") {