[flang][driver] Add support for -fopenmp and -fopenacc

[FarisRehman]

Summary

Add support for the following Fortran dialect options:

• -fopenmp
• -fopenacc

Update OpenMP and OpenACC semantics tests to use the new driver if it is built, otherwise use f18.
OpenMP tests that include use omp_lib or run test_symbols.sh have not been updated as they require options -intrinsic-module-directory and -funparse-with-symbols which are currently not implemented in the new driver.
Similarly OpenACC tests that run test_symbols.sh have not been updated.

This patch also moves semanticsContext to CompilerInvocation and created in CompilerInvocation#setSemanticsOpts so that the semantics context can use Fortran::parser::Options#features.

Summary of changes:

• Move semanticsContext to CompilerInvocation.h
• Update OpenMP and OpenACC semantics tests that do not rely on -intrinsic-module-directory and -funparse-with-symbols to use %flang

Depends on: D95448

[FarisRehman]

Rebase off main

Rebase off main as patch D95448, which this patch depends on, has been merged into main.

[awarzynski]

Thank you for this patch @FarisRehman , it's great to see more tests being ported to the new driver!

Although this patches touches many files, it mostly just generalizes the RUN lines. With this change we can easily switch between f18 and flang-new (depending on FLANG_BUILD_NEW_DRIVER), which is very helpful!

LGTM (could you moving options::OPT_fopenmp, options::OPT_fopenacc do a dedicated method before merging?)

clang/include/clang/Driver/Options.td

4219–4220

Could we follow gcc here:

gcc --help=fortran | grep openacc
  -fopenacc                   Enable OpenACC.

clang/lib/Driver/ToolChains/Flang.cpp

25–26

-fopenmp and -fopenacc enable extensions, so they are not dialect options.

flang/lib/Frontend/CompilerInvocation.cpp

350

[nit] language -> extensions

[FarisRehman]

Address review comment

Address review comment by @awarzynski

clang/lib/Driver/ToolChains/Flang.cpp

25–26

I decided to add this here as it is listed under "Fortran Dialect Options" in the gfortran documentation: https://gcc.gnu.org/onlinedocs/gfortran/Fortran-Dialect-Options.html

[awarzynski]

clang/lib/Driver/ToolChains/Flang.cpp

25–26

Makes sense, thanks for clarifying!

clang/include/clang/Driver/Options.td

def fobjc_runtime_EQ : Joined<["-"], "fobjc-runtime=">, Group<f_Group>, Flags<[CC1Option, CoreOption]>,
   HelpText<"Specify the target Objective-C runtime kind and version">;
 def fobjc_abi_version_EQ : Joined<["-"], "fobjc-abi-version=">, Group<f_Group>;
 def fobjc_nonfragile_abi_version_EQ : Joined<["-"], "fobjc-nonfragile-abi-version=">, Group<f_Group>;
 def fobjc_nonfragile_abi : Flag<["-"], "fobjc-nonfragile-abi">, Group<f_Group>;
 def fno_objc_nonfragile_abi : Flag<["-"], "fno-objc-nonfragile-abi">, Group<f_Group>;
 
 def fobjc_sender_dependent_dispatch : Flag<["-"], "fobjc-sender-dependent-dispatch">, Group<f_Group>;
 def fomit_frame_pointer : Flag<["-"], "fomit-frame-pointer">, Group<f_Group>;
-def fopenmp : Flag<["-"], "fopenmp">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>,
+def fopenmp : Flag<["-"], "fopenmp">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused, FlangOption, FC1Option]>,
   HelpText<"Parse OpenMP pragmas and generate parallel code.">,
   MarshallingInfoFlag<LangOpts<"OpenMP">, "0u">, Normalizer<"makeFlagToValueNormalizer(50u)">;
 def fno_openmp : Flag<["-"], "fno-openmp">, Group<f_Group>, Flags<[NoArgumentUnused]>;
 def fopenmp_version_EQ : Joined<["-"], "fopenmp-version=">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>;
 def fopenmp_EQ : Joined<["-"], "fopenmp=">, Group<f_Group>;
 def fopenmp_use_tls : Flag<["-"], "fopenmp-use-tls">, Group<f_Group>,
   Flags<[NoArgumentUnused, HelpHidden]>;
 def fnoopenmp_use_tls : Flag<["-"], "fnoopenmp-use-tls">, Group<f_Group>,
def ffixed_form : Flag<["-"], "ffixed-form">, Group<f_Group>,
   HelpText<"Process source files in fixed form">;
 def ffree_form : Flag<["-"], "ffree-form">, Group<f_Group>,
   HelpText<"Process source files in free form">;
 def ffixed_line_length_EQ : Joined<["-"], "ffixed-line-length=">, Group<f_Group>,
   HelpText<"Use <value> as character line width in fixed mode">,
   DocBrief<[{Set column after which characters are ignored in typical fixed-form lines in the source
 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<"Parse OpenACC pragmas and generate parallel code.">;
 
 }
 
 //===----------------------------------------------------------------------===//
 // CC1 Options
 //===----------------------------------------------------------------------===//
 
 let Flags = [CC1Option, NoDriverOption] in {

clang/lib/Driver/ToolChains/Flang.cpp

 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
 void Flang::AddFortranDialectOptions(const ArgList &Args,
                                      ArgStringList &CmdArgs) const {
   Args.AddAllArgs(CmdArgs, {options::OPT_ffixed_form, options::OPT_ffree_form,
-                            options::OPT_ffixed_line_length_EQ});
+                            options::OPT_ffixed_line_length_EQ,
+                            +options::OPT_fopenmp, options::OPT_fopenacc});
 }
 
 void Flang::AddPreprocessingOptions(const ArgList &Args,
                                     ArgStringList &CmdArgs) const {
   Args.AddAllArgs(CmdArgs, {options::OPT_D, options::OPT_U, options::OPT_I});
 }
 
 void Flang::AddOtherOptions(const ArgList &Args,

flang/include/flang/Frontend/CompilerInstance.h

class CompilerInstance {
 
   /// Flang file  manager.
   std::shared_ptr<Fortran::parser::AllSources> allSources_;
 
   std::shared_ptr<Fortran::parser::AllCookedSources> allCookedSources_;
 
   std::shared_ptr<Fortran::parser::Parsing> parsing_;
 
-  std::unique_ptr<Fortran::semantics::SemanticsContext> semanticsContext_;
-
   /// The stream for diagnostics from Semantics
   llvm::raw_ostream *semaOutputStream_ = &llvm::errs();
 
   /// The stream for diagnostics from Semantics if owned, otherwise nullptr.
   std::unique_ptr<llvm::raw_ostream> ownedSemaOutputStream_;
 
   /// The diagnostics engine instance.
   llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diagnostics_;
public:
   /// {
 
   /// Return parsing to be used by Actions.
   Fortran::parser::Parsing &parsing() const { return *parsing_; }
 
   /// }
   /// @name Semantic analysis
   /// {
-  Fortran::semantics::SemanticsContext &semanticsContext() const { return *semanticsContext_; }
 
   /// Replace the current stream for verbose output.
   void set_semaOutputStream(llvm::raw_ostream &Value);
 
   /// Replace the current stream for verbose output.
   void set_semaOutputStream(std::unique_ptr<llvm::raw_ostream> Value);
 
   /// Get the current stream for verbose output.

flang/include/flang/Frontend/CompilerInvocation.h

class CompilerInvocation : public CompilerInvocationBase {
   // options.
   FrontendOptions frontendOpts_;
 
   /// Options for Flang parser
   // TODO: Merge with or translate to frontendOpts_. We shouldn't need two sets
   // of options.
   Fortran::parser::Options parserOpts_;
 
+  // Semantics context
+  std::unique_ptr<Fortran::semantics::SemanticsContext> semanticsContext_;
+
   /// Semantic options
   // TODO: Merge with or translate to frontendOpts_. We shouldn't need two sets
   // of options.
   std::string moduleDir_ = "."; 
 
 public:
   CompilerInvocation() = default;
 
   FrontendOptions &frontendOpts() { return frontendOpts_; }
   const FrontendOptions &frontendOpts() const { return frontendOpts_; }
 
   Fortran::parser::Options &fortranOpts() { return parserOpts_; }
   const Fortran::parser::Options &fortranOpts() const { return parserOpts_; }
 
+  Fortran::semantics::SemanticsContext &semanticsContext() {
+    return *semanticsContext_;
+  }
+  const Fortran::semantics::SemanticsContext &semanticsContext() const {
+    return *semanticsContext_;
+  }
+
   std::string &moduleDir() { return moduleDir_; }
   const std::string &moduleDir() const { return moduleDir_; }
 
   /// Create a compiler invocation from a list of input options.
   /// \returns true on success.
   /// \returns false if an error was encountered while parsing the arguments
   /// \param [out] res - The resulting invocation.
   static bool CreateFromArgs(CompilerInvocation &res,
       llvm::ArrayRef<const char *> commandLineArgs,
       clang::DiagnosticsEngine &diags);
 
   /// Set the Fortran options to predifined defaults. These defaults are
   /// consistend with f18/f18.cpp.
   // TODO: We should map frontendOpts_ to parserOpts_ instead. For that, we
   // need to extend frontendOpts_ first. Next, we need to add the corresponding
   // compiler driver options in libclangDriver.
   void SetDefaultFortranOpts();
 
+  /// Set the default predefinitions.
+  void setDefaultPredefinitions();
+
   /// Set the Fortran options to user-specified values.
   /// These values are found in the preprocessor options.
   void setFortranOpts();
 
   /// Set the Semantic Options
-  void setSemanticsOpts(Fortran::semantics::SemanticsContext &);
+  void setSemanticsOpts(Fortran::parser::AllCookedSources &);
 };
 
 } // end namespace Fortran::frontend
 #endif // LLVM_FLANG_FRONTEND_COMPILERINVOCATION_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 "llvm/ADT/StringRef.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 #include <cstdint>
 #include <string>
 
 namespace Fortran::frontend {
 
public:
 
   // The form to process files in, if specified.
   FortranForm fortranForm_ = FortranForm::Unknown;
 
   // The column after which characters are ignored in fixed form lines in the
   // source file.
   int fixedFormColumns_ = 72;
 
+  // Language features
+  common::LanguageFeatureControl features_;
+
 public:
   FrontendOptions() : showHelp_(false), showVersion_(false) {}
 
   // Return the appropriate input kind for a file extension. For example,
   /// "*.f" would return Language::Fortran.
   ///
   /// \return The input kind for the extension, or Language::Unknown if the
   /// extension is not recognized.
   static InputKind GetInputKindForExtension(llvm::StringRef extension);
 };
 } // namespace Fortran::frontend
 
 #endif // LLVM_FLANG_FRONTEND_FRONTENDOPTIONS_H

flang/lib/Frontend/CompilerInstance.cpp

 //===--- CompilerInstance.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/CompilerInstance.h"
+#include "flang/Common/Fortran-features.h"
 #include "flang/Frontend/CompilerInvocation.h"
 #include "flang/Frontend/TextDiagnosticPrinter.h"
 #include "flang/Parser/parsing.h"
 #include "flang/Parser/provenance.h"
 #include "flang/Semantics/semantics.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace Fortran::frontend;
 
 CompilerInstance::CompilerInstance()
     : invocation_(new CompilerInvocation()),
       allSources_(new Fortran::parser::AllSources()),
       allCookedSources_(new Fortran::parser::AllCookedSources(*allSources_)),
-      parsing_(new Fortran::parser::Parsing(*allCookedSources_)),
-      semanticsContext_(new Fortran::semantics::SemanticsContext(*(new  Fortran::common::IntrinsicTypeDefaultKinds()),*(new common::LanguageFeatureControl()),
-                 *allCookedSources_)) {
+      parsing_(new Fortran::parser::Parsing(*allCookedSources_)) {
   // TODO: This is a good default during development, but ultimately we should
   // give the user the opportunity to specify this.
   allSources_->set_encoding(Fortran::parser::Encoding::UTF_8);
 }
 
 CompilerInstance::~CompilerInstance() {
   assert(outputFiles_.empty() && "Still output files in flight?");
 }
void CompilerInstance::ClearOutputFiles(bool eraseFiles) {
   nonSeekStream_.reset();
 }
 
 bool CompilerInstance::ExecuteAction(FrontendAction &act) {
   auto &invoc = this->invocation();
 
   // Set some sane defaults for the frontend.
   invoc.SetDefaultFortranOpts();
+  invoc.setDefaultPredefinitions();
   // Update the fortran options based on user-based input.
   invoc.setFortranOpts();
-  // Set semantic options
-  invoc.setSemanticsOpts(this->semanticsContext());
+  // Create the semantics context and set semantic options.
+  invoc.setSemanticsOpts(*this->allCookedSources_);
 
   // Run the frontend action `act` for every input file.
   for (const FrontendInputFile &fif : frontendOpts().inputs_) {
     if (act.BeginSourceFile(*this, fif)) {
       if (invoc.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 loop (i.e. processing any input files). However, we

flang/lib/Frontend/CompilerInvocation.cpp

 //===- CompilerInvocation.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/CompilerInvocation.h"
+#include "flang/Common/Fortran-features.h"
 #include "flang/Frontend/PreprocessorOptions.h"
+#include "flang/Semantics/semantics.h"
 #include "flang/Version.inc"
 #include "clang/Basic/AllDiagnostics.h"
 #include "clang/Basic/DiagnosticDriver.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/raw_ostream.h"
+#include <memory>
 
 using namespace Fortran::frontend;
 
 //===----------------------------------------------------------------------===//
 // Initialization.
 //===----------------------------------------------------------------------===//
 CompilerInvocationBase::CompilerInvocationBase()
     : diagnosticOpts_(new clang::DiagnosticOptions()),
if (const auto *arg =
     } else if (columns < 7) {
       diags.Report(clang::diag::err_drv_invalid_value_with_suggestion)
           << arg->getOption().getName() << arg->getValue()
           << "value must be at least seven";
     } else {
       opts.fixedFormColumns_ = columns;
     }
   }
+
+  // Fortran dialect options
+  if (args.hasArg(clang::driver::options::OPT_fopenacc)) {
+    opts.features_.Enable(Fortran::common::LanguageFeature::OpenACC);
+  }
+  if (args.hasArg(clang::driver::options::OPT_fopenmp)) {
+    opts.features_.Enable(Fortran::common::LanguageFeature::OpenMP);
+  }
   return dashX;
 }
 
 /// Parses all preprocessor input arguments and populates the preprocessor
 /// options accordingly.
 ///
 /// \param [in] opts The preprocessor options instance
 /// \param [out] args The list of input arguments
void CompilerInvocation::SetDefaultFortranOpts() {
   std::vector<std::string> searchDirectories{"."s};
   fortranOptions.searchDirectories = searchDirectories;
   fortranOptions.isFixedForm = false;
 
   // Populate the macro list with version numbers and other predefinitions.
   // TODO: When expanding this list of standard predefinitions, consider
   // creating a dedicated API for this. Also at some point we will need to
   // differentiate between different targets.
+  // TODO: Move to setDefaultPredefinitions
   fortranOptions.predefinitions.emplace_back("__flang__", "1");
   fortranOptions.predefinitions.emplace_back(
       "__flang_major__", FLANG_VERSION_MAJOR_STRING);
   fortranOptions.predefinitions.emplace_back(
       "__flang_minor__", FLANG_VERSION_MINOR_STRING);
   fortranOptions.predefinitions.emplace_back(
       "__flang_patchlevel__", FLANG_VERSION_PATCHLEVEL_STRING);
 }
 
+void CompilerInvocation::setDefaultPredefinitions() {
+  auto &fortranOptions = fortranOpts();
+  const auto &frontendOptions = frontendOpts();
+
+  // Add predefinitions based on language features enabled
+  if (frontendOptions.features_.IsEnabled(
+          Fortran::common::LanguageFeature::OpenACC)) {
+    fortranOptions.predefinitions.emplace_back("_OPENACC", "202011");
+  }
+  if (frontendOptions.features_.IsEnabled(
+          Fortran::common::LanguageFeature::OpenMP)) {
+    fortranOptions.predefinitions.emplace_back("_OPENMP", "201511");
+  }
+}
+
 void CompilerInvocation::setFortranOpts() {
   auto &fortranOptions = fortranOpts();
   const auto &frontendOptions = frontendOpts();
   const auto &preprocessorOptions = preprocessorOpts();
   auto &moduleDirJ = moduleDir();
 
   if (frontendOptions.fortranForm_ != FortranForm::Unknown) {
     fortranOptions.isFixedForm =
         frontendOptions.fortranForm_ == FortranForm::FixedForm;
   }
   fortranOptions.fixedFormColumns = frontendOptions.fixedFormColumns_;
 
+  fortranOptions.features = frontendOptions.features_;
+
   collectMacroDefinitions(preprocessorOptions, fortranOptions);
 
   fortranOptions.searchDirectories.insert(
       fortranOptions.searchDirectories.end(),
       preprocessorOptions.searchDirectoriesFromDashI.begin(),
       preprocessorOptions.searchDirectoriesFromDashI.end());
   // Add the directory supplied through -J/-module-dir to the list of search
   // directories
   if (moduleDirJ.compare(".") != 0)
     fortranOptions.searchDirectories.emplace_back(moduleDirJ);
 }
 
-void CompilerInvocation::setSemanticsOpts(Fortran::semantics::SemanticsContext &semaCtxt) {
-  auto &fortranOptions = fortranOpts();
+void CompilerInvocation::setSemanticsOpts(
+    Fortran::parser::AllCookedSources &allCookedSources) {
+  const auto &fortranOptions = fortranOpts();
+
+  semanticsContext_ = std::make_unique<semantics::SemanticsContext>(
+      *(new Fortran::common::IntrinsicTypeDefaultKinds()),
+      fortranOptions.features, allCookedSources);
+
   auto &moduleDirJ = moduleDir();
-  semaCtxt.set_moduleDirectory(moduleDirJ)
-          .set_searchDirectories(fortranOptions.searchDirectories);
-  return;
+  semanticsContext_->set_moduleDirectory(moduleDirJ)
 }

flang/lib/Frontend/FrontendActions.cpp

void ParseSyntaxOnlyAction::ExecuteAction() {
   }
 
   // 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.semanticsContext(), parseTree, ci.parsing().cooked().AsCharBlock()};
+  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()) {

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

 ! CHECK-NEXT: -D <macro>=<value>     Define <macro> to <value> (or 1 if <value> omitted)
 ! CHECK-NEXT: -E        Only run the preprocessor
 ! CHECK-NEXT: -fcolor-diagnostics    Enable colors in diagnostics
 ! CHECK-NEXT: -ffixed-form           Process source files in fixed form
 ! CHECK-NEXT: -ffixed-line-length=<value>
 ! CHECK-NEXT: Use <value> as character line width in fixed mode
 ! CHECK-NEXT: -ffree-form            Process source files in free form
 ! CHECK-NEXT: -fno-color-diagnostics Disable colors in diagnostics
+! CHECK-NEXT: -fopenacc              Parse OpenACC pragmas and generate parallel code.
+! CHECK-NEXT: -fopenmp               Parse OpenMP pragmas and generate parallel code.
 ! CHECK-NEXT: -help     Display available options
 ! CHECK-NEXT: -I <dir>               Add directory to the end of the list of include search paths
 ! CHECK-NEXT: -module-dir <dir>      Put MODULE files in 'dir'
 ! CHECK-NEXT: -o <file> Write output to <file>
 ! CHECK-NEXT: -test-io  Run the InputOuputTest action. Use for development and testing only.
 ! CHECK-NEXT: -U <macro>             Undefine macro <macro>
 ! CHECK-NEXT: --version Print version information
 

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

 ! HELP-NEXT: -D <macro>=<value>     Define <macro> to <value> (or 1 if <value> omitted)
 ! HELP-NEXT: -E                     Only run the preprocessor
 ! HELP-NEXT: -fcolor-diagnostics    Enable colors in diagnostics
 ! HELP-NEXT: -ffixed-form           Process source files in fixed form
 ! HELP-NEXT: -ffixed-line-length=<value>
 ! HELP-NEXT: Use <value> as character line width in fixed mode
 ! HELP-NEXT: -ffree-form            Process source files in free form
 ! HELP-NEXT: -fno-color-diagnostics Disable colors in diagnostics
+! HELP-NEXT: -fopenacc              Parse OpenACC pragmas and generate parallel code.
+! HELP-NEXT: -fopenmp               Parse OpenMP pragmas and generate parallel code.
 ! HELP-NEXT: -help                  Display available options
 ! HELP-NEXT: -I <dir>               Add directory to the end of the list of include search paths
 ! HELP-NEXT: -module-dir <dir>      Put MODULE files in 'dir'
 ! HELP-NEXT: -o <file>              Write output to <file>
 ! HELP-NEXT: -U <macro>             Undefine macro <macro>
 ! HELP-NEXT: --version              Print version information
 
 !-------------------------------------------------------------
 ! 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: -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              Parse OpenACC pragmas and generate parallel code.
+! 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
 ! HELP-FC1-NEXT: -module-dir <dir>      Put MODULE files in 'dir'
 ! HELP-FC1-NEXT: -o <file>              Write output to <file>
 ! HELP-FC1-NEXT: -U <macro>             Undefine macro <macro>
 ! HELP-FC1-NEXT: --version              Print version information
 
 !---------------
 ! EXPECTED ERROR
 !---------------
 ! ERROR: error: unknown argument '-helps'; did you mean '-help'

flang/test/Semantics/OpenACC/acc-atomic-validity.f90

-! RUN: %S/../test_errors.sh %s %t %f18 -fopenacc
+! RUN: %S/../test_errors.sh %s %t %flang -fopenacc
 
 ! Check OpenACC clause validity for the following construct and directive:
 !   2.12 Atomic
 
 program openacc_atomic_validity
 
   implicit none
 

flang/test/Semantics/OpenACC/acc-branch.f90

-! RUN: %S/../test_errors.sh %s %t %f18 -fopenacc
+! RUN: %S/../test_errors.sh %s %t %flang -fopenacc
 
 ! Check OpenACC restruction in branch in and out of some construct
 !
 program openacc_clause_validity
 
   implicit none
 
   integer :: i, j, k

flang/test/Semantics/OpenACC/acc-cache-validity.f90

-! RUN: %S/../test_errors.sh %s %t %f18 -fopenacc
+! RUN: %S/../test_errors.sh %s %t %flang -fopenacc
 
 ! Check OpenACC clause validity for the following construct and directive:
 !   2.10 Cache
 
 program openacc_cache_validity
 
   implicit none
 

flang/test/Semantics/OpenACC/acc-canonicalization-validity.f90

-! RUN: %S/../test_errors.sh %s %t %f18 -fopenacc
+! RUN: %S/../test_errors.sh %s %t %flang -fopenacc
 
 ! Check OpenACC canonalization validity for the construct defined below:
 !   2.9 Loop
 !   2.11 Parallel Loop
 !   2.11 Kernels Loop
 !   2.11 Serial Loop
 
 program openacc_clause_validity

flang/test/Semantics/OpenACC/acc-data.f90

-! RUN: %S/../test_errors.sh %s %t %f18 -fopenacc
+! RUN: %S/../test_errors.sh %s %t %flang -fopenacc
 
 ! Check OpenACC clause validity for the following construct and directive:
 !   2.6.5 Data
 !   2.14.6 Enter Data
 !   2.14.7 Exit Data
 
 program openacc_data_validity
 

flang/test/Semantics/OpenACC/acc-declare-validity.f90

-! RUN: %S/../test_errors.sh %s %t %f18 -fopenacc
+! RUN: %S/../test_errors.sh %s %t %flang -fopenacc
 
 ! Check OpenACC clause validity for the following construct and directive:
 !   2.13 Declare
 
 module openacc_declare_validity
 
   implicit none
 

flang/test/Semantics/OpenACC/acc-host-data.f90

-! RUN: %S/../test_errors.sh %s %t %f18 -fopenacc
+! RUN: %S/../test_errors.sh %s %t %flang -fopenacc
 
 ! Check OpenACC clause validity for the following construct and directive:
 !   2.8 host_data
 
 program openacc_host_data_validity
 
   implicit none
 

flang/test/Semantics/OpenACC/acc-init-validity.f90

-! RUN: %S/../test_errors.sh %s %t %f18 -fopenacc
+! RUN: %S/../test_errors.sh %s %t %flang -fopenacc
 
 ! Check OpenACC clause validity for the following construct and directive:
 !   2.14.1 Init
 
 program openacc_init_validity
 
   implicit none
 

flang/test/Semantics/OpenACC/acc-kernels-loop.f90

-! RUN: %S/../test_errors.sh %s %t %f18 -fopenacc
+! RUN: %S/../test_errors.sh %s %t %flang -fopenacc
 
 ! Check OpenACC clause validity for the following construct and directive:
 !   2.11 Kernels Loop
 
 program openacc_kernels_loop_validity
 
   implicit none
 

flang/test/Semantics/OpenACC/acc-kernels.f90

-! RUN: %S/../test_errors.sh %s %t %f18 -fopenacc
+! RUN: %S/../test_errors.sh %s %t %flang -fopenacc
 
 ! Check OpenACC clause validity for the following construct and directive:
 !   2.5.3 Kernels
 
 program openacc_kernels_validity
 
   implicit none
 

flang/test/Semantics/OpenACC/acc-loop.f90

-! RUN: %S/../test_errors.sh %s %t %f18 -fopenacc
+! RUN: %S/../test_errors.sh %s %t %flang -fopenacc
 
 ! Check OpenACC clause validity for the following construct and directive:
 !   2.9 Loop
 
 program openacc_loop_validity
 
   implicit none
 

flang/test/Semantics/OpenACC/acc-parallel-loop-validity.f90

-! RUN: %S/../test_errors.sh %s %t %f18 -fopenacc
+! RUN: %S/../test_errors.sh %s %t %flang -fopenacc
 
 ! Check OpenACC clause validity for the following construct and directive:
 !   2.11 Parallel Loop
 
 program openacc_parallel_loop_validity
 
   implicit none
 

flang/test/Semantics/OpenACC/acc-parallel.f90

-! RUN: %S/../test_errors.sh %s %t %f18 -fopenacc
+! RUN: %S/../test_errors.sh %s %t %flang -fopenacc
 
 ! Check OpenACC clause validity for the following construct and directive:
 !   2.5.1 Parallel
 
 program openacc_parallel_validity
 
   implicit none
 

flang/test/Semantics/OpenACC/acc-resolve01.f90

-! RUN: %S/../test_errors.sh %s %t %f18 -fopenacc
+! RUN: %S/../test_errors.sh %s %t %flang -fopenacc
 
 ! Data-Mapping Attribute Clauses
 ! 2.15.14 default Clause
 
 subroutine default_none()
   integer a(3)
 
   A = 1

flang/test/Semantics/OpenACC/acc-resolve02.f90

-! RUN: %S/../test_errors.sh %s %t %f18 -fopenacc
+! RUN: %S/../test_errors.sh %s %t %flang -fopenacc
 
 subroutine compute()
   integer :: a(3), c, i
 
   a = 1
   !ERROR: 'c' appears in more than one data-sharing clause on the same OpenACC directive
   !$acc parallel firstprivate(c) private(c)
   do i = 1, 3
     a(i) = c
   end do
   !$acc end parallel
 end subroutine compute
 
 program mm
   call compute()
 end

flang/test/Semantics/OpenACC/acc-routine-validity.f90

-! RUN: %S/../test_errors.sh %s %t %f18 -fopenacc
+! RUN: %S/../test_errors.sh %s %t %flang -fopenacc
 
 ! Check OpenACC clause validity for the following construct and directive:
 !   2.15.1 routine
 
 module openacc_routine_validity
   implicit none
 
   !$acc routine(sub3) seq

flang/test/Semantics/OpenACC/acc-serial-loop.f90

-! RUN: %S/../test_errors.sh %s %t %f18 -fopenacc
+! RUN: %S/../test_errors.sh %s %t %flang -fopenacc
 
 ! Check OpenACC clause validity for the following construct and directive:
 !   2.11 Serial Loop
 
 program openacc_serial_loop_validity
 
   implicit none
 

flang/test/Semantics/OpenACC/acc-serial.f90

-! RUN: %S/../test_errors.sh %s %t %f18 -fopenacc
+! RUN: %S/../test_errors.sh %s %t %flang -fopenacc
 
 ! Check OpenACC clause validity for the following construct and directive:
 !   2.5.2 Serial
 
 program openacc_serial_validity
 
   implicit none
 

flang/test/Semantics/OpenACC/acc-set-validity.f90

-! RUN: %S/../test_errors.sh %s %t %f18 -fopenacc
+! RUN: %S/../test_errors.sh %s %t %flang -fopenacc
 
 ! Check OpenACC clause validity for the following construct and directive:
 !   2.14.3 Set
 
 program openacc_clause_validity
 
   implicit none
 

flang/test/Semantics/OpenACC/acc-shutdown-validity.f90

-! RUN: %S/../test_errors.sh %s %t %f18 -fopenacc
+! RUN: %S/../test_errors.sh %s %t %flang -fopenacc
 
 ! Check OpenACC clause validity for the following construct and directive:
 !   2.14.2 Shutdown
 
 program openacc_shutdown_validity
 
   implicit none
 

flang/test/Semantics/OpenACC/acc-update-validity.f90

-! RUN: %S/../test_errors.sh %s %t %f18 -fopenacc
+! RUN: %S/../test_errors.sh %s %t %flang -fopenacc
 
 ! Check OpenACC clause validity for the following construct and directive:
 !   2.14.4 Update
 
 program openacc_update_validity
 
   implicit none
 

flang/test/Semantics/OpenACC/acc-wait-validity.f90

-! RUN: %S/../test_errors.sh %s %t %f18 -fopenacc
+! RUN: %S/../test_errors.sh %s %t %flang -fopenacc
 
 ! Check OpenACC clause validity for the following construct and directive:
 !   2.16.13 Wait
 
 program openacc_wait_validity
 
   implicit none
 

flang/test/Semantics/omp-atomic.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 use omp_lib
 ! Check OpenMP 2.13.6 atomic Construct
 
   a = 1.0
   !$omp parallel num_threads(4)
   !$omp atomic seq_cst, read
   b = a
 

flang/test/Semantics/omp-combined-constructs.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 
 program main
   implicit none
   integer :: N
   integer :: i
   real(8) :: a(256), b(256)
   N = 256
 

flang/test/Semantics/omp-copyin01.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.15.4.1 copyin Clause
 ! A list item that appears in a copyin clause must be threadprivate
 
 program omp_copyin
 
   integer :: i
   integer, save :: k

flang/test/Semantics/omp-copyin02.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.15.4.1 copyin Clause
 ! A common block name that appears in a copyin clause must be declared to be
 ! a common block in the same scoping unit in which the copyin clause appears.
 
 subroutine copyin()
   integer :: a = 10
   common /cmn/ a

flang/test/Semantics/omp-copyin03.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.15.4.1 copyin Clause
 ! A list item that appears in a copyin clause must be threadprivate.
 ! Named variables appearing in a threadprivate common block may be specified
 ! It is not necessary to specify the whole common block.
 
 program omp_copyin
 

flang/test/Semantics/omp-copyin04.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.15.4.1 copyin Clause
 ! A list item that appears in a copyin clause must be threadprivate
 
 program omp_copyin
 
   integer :: i
   integer, save :: j, k

flang/test/Semantics/omp-copyin05.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.15.4.1 copyin Clause
 ! A common block name that appears in a copyin clause must be declared to be
 ! a common block in the same scoping unit in which the copyin clause appears.
 
 subroutine copyin()
   call copyin_clause()
 

flang/test/Semantics/omp-declarative-directive.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 
 ! Check OpenMP declarative directives
 
 !TODO: all internal errors
 !      enable declare-reduction example after name resolution
 
 ! 2.8.2 declare-simd
 

flang/test/Semantics/omp-default.f90

-!RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+!RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.15.3.1 default Clause
 program omp_default
   integer :: a(10), b(10), c(10),i,k
   !ERROR: At most one DEFAULT clause can appear on the PARALLEL directive
   !$omp parallel default(shared), default(private)
   do i = 1, 10
     c(i) = a(i) + b(i) + k

flang/test/Semantics/omp-default02.f90

-!RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+!RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.15.3.1 default Clause - a positive test case.
 
 !DEF: /omp_default MainProgram
 program omp_default
  !DEF: /omp_default/a ObjectEntity INTEGER(4)
  !DEF: /omp_default/b ObjectEntity INTEGER(4)
  !DEF: /omp_default/c ObjectEntity INTEGER(4)

flang/test/Semantics/omp-depend01.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.13.9 Depend Clause
 ! List items used in depend clauses cannot be zero-length array sections.
 
 program omp_depend
   integer :: a(10) , b(10,10)
   a = 10
   b = 20

flang/test/Semantics/omp-depend02.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.13.9 Depend Clause
 ! A variable that is part of another variable
 ! (such as an element of a structure) but is not an array element or
 ! an array section cannot appear in a DEPEND clause
 
 subroutine vec_mult(N)
   implicit none

flang/test/Semantics/omp-depend03.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.13.9 Depend Clause
 ! Coarrays are not supported in depend clause
 
 program omp_depend_coarray
   integer :: a(3)[*], b(3) , k
 
   a(:) = this_image()

flang/test/Semantics/omp-device-constructs.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! Check OpenMP clause validity for the following directives:
 !     2.10 Device constructs
 program main
 
   real(8) :: arrayA(256), arrayB(256)
   integer :: N
 
   arrayA = 1.414

flang/test/Semantics/omp-do-collapse-positivecases.f90

-!RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+!RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.7.1 Collapse Clause Positive cases
 
 !DEF: /omp_docollapse MainProgram
 program omp_docollapse
   !DEF: /omp_docollapse/i ObjectEntity INTEGER(4)
   !DEF: /omp_docollapse/j ObjectEntity INTEGER(4)
   !DEF: /omp_docollapse/k ObjectEntity INTEGER(4)

flang/test/Semantics/omp-do-collapse.f90

-!RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+!RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.7.1 Collapse Clause
 program omp_doCollapse
   integer:: i,j
   !ERROR: The value of the parameter in the COLLAPSE or ORDERED clause must not be larger than the number of nested loops following the construct.
   !$omp do collapse(3)
   do i = 1,10
     do j = 1, 10

flang/test/Semantics/omp-do-cycle.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! Check for cycle statements leaving an OpenMP structured block
 
 program omp_do
   integer i, j, k
 
   !$omp parallel
   foo: do i = 0, 10

flang/test/Semantics/omp-do-ordered-positivecases.f90

-!RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+!RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.7.1 Ordered Clause positive cases.
 
 !DEF: /omp_doordered MainProgram
 program omp_doordered
   !DEF: /omp_doordered/i ObjectEntity INTEGER(4)
   !DEF: /omp_doordered/j ObjectEntity INTEGER(4)
   integer i, j

flang/test/Semantics/omp-do-ordered.f90

-!RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+!RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.7.1 Ordered Clause
 
 program omp_doOrdered
   integer:: i,j
   !ERROR: The value of the parameter in the COLLAPSE or ORDERED clause must not be larger than the number of nested loops following the construct.
   !$omp do ordered(3)
   do i = 1,10

flang/test/Semantics/omp-do-schedule01.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.7.1 Schedule Clause
 program omp_doSchedule
   integer :: i,n
   real ::  a(100), y(100), z(100)
   !ERROR: The chunk size of the SCHEDULE clause must be a positive integer expression
   !$omp do schedule(static, -1)
   do i=2,n+1
     y(i) = z(i-1) + a(i)
   end do
   !$omp end do
 end program omp_doSchedule

flang/test/Semantics/omp-do-schedule02.f90

-!RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+!RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.7.1 Schedule Clause
 program omp_doSchedule
   integer :: i,n
   real ::  a(100), y(100), z(100)
   integer,parameter :: b = 10
   integer,parameter :: c = 11
   !ERROR: The chunk size of the SCHEDULE clause must be a positive integer expression
   !$omp do schedule(static,b-c)
   do i=2,n+1
     y(i) = z(i-1) + a(i)
   end do
   !$omp end do
 end program omp_doSchedule

flang/test/Semantics/omp-do01.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.7.1 Loop Construct
 ! The loop iteration variable may not appear in a firstprivate directive.
 
 program omp_do
   integer i, j, k
 
   !ERROR: DO iteration variable i is not allowed in FIRSTPRIVATE clause.

flang/test/Semantics/omp-do02.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! XFAIL: *
 
 ! OpenMP Version 4.5
 ! 2.7.1 Loop Construct
 ! Exit statement terminating !$OMP DO loop
 
 program omp_do
   integer i, j, k

flang/test/Semantics/omp-do03.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 
 ! OpenMP Version 4.5
 ! 2.7.1 Loop Construct
 ! Semantic error for correct test case
 
 program omp_do
   integer i, j, k
   integer :: a(10), b(10)

flang/test/Semantics/omp-do04.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! XFAIL: *
 
 ! OpenMP Version 4.5
 ! 2.7.1 Loop Construct
 ! The loop iteration variable may not appear in a threadprivate directive.
 
 program omp_do
   integer i, j, k

flang/test/Semantics/omp-do05.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.7.1 Loop Construct restrictions on single directive.
 
 
 program omp_do
 
   integer n
   integer i,j

flang/test/Semantics/omp-do06.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! XFAIL:*
 
 ! OpenMP Version 4.5
 ! 2.7.1 Loop Construct
 ! The ordered clause must be present on the loop construct if any ordered
 ! region ever binds to a loop region arising from the loop construct.
 
 program omp_do

flang/test/Semantics/omp-do07.f90

-! RUN: not %f18 -fparse-only -fopenmp %s 2>&1 | FileCheck %s
+! RUN: not %flang -fsyntax-only -fopenmp %s 2>&1 | FileCheck %s
 ! OpenMP Version 4.5
 ! 2.7.1 Loop Construct
 ! No statement in the associated loops other than the DO statements
 ! can cause a branch out of the loops
 
 program omp_do
   integer i, j, k
 

flang/test/Semantics/omp-do08.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! XFAIL: *
 
 ! OpenMP Version 4.5
 ! 2.7.1 Loop Construct
 
 program omp_do
   integer i, j, k
   !$omp do collapse(2)

flang/test/Semantics/omp-do09.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! XFAIL: *
 
 ! OpenMP Version 4.5
 ! 2.7.1 Loop Construct
 ! The do-loop cannot be a DO WHILE or a DO loop without loop control.
 
 program omp_do
   integer i, j, k

flang/test/Semantics/omp-do10.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! XFAIL: *
 
 ! OpenMP Version 4.5
 ! 2.7.1 Loop Construct
 ! The do-loop iteration variable must be of type integer.
 
 program omp_do
   real i, j, k

flang/test/Semantics/omp-flush01.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 
 ! 2.17.8 Flush construct [OpenMP 5.0]
 !        memory-order-clause ->
 !                               acq_rel
 !                               release
 !                               acquire
 use omp_lib
   implicit none

flang/test/Semantics/omp-invalid-branch.f90

-! RUN: not %f18 -fparse-only -fopenmp %s 2>&1 | FileCheck %s
+! RUN: not %flang -fsyntax-only -fopenmp %s 2>&1 | FileCheck %s
 ! OpenMP Version 4.5
 ! Check invalid branches into or out of OpenMP structured blocks.
 
 subroutine omp_err_end_eor(a, b, x)
   integer x
 
   !$omp parallel
   !CHECK: invalid branch into an OpenMP structured block

flang/test/Semantics/omp-loop-association.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 
 ! Check the association between OpenMPLoopConstruct and DoConstruct
 
   integer :: b = 128
   integer :: c = 32
   integer, parameter :: num = 16
   N = 1024
 

flang/test/Semantics/omp-loop-simd01.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 
 ! OpenMP Version 4.5
 ! 2.8.3 Loop simd Construct
 ! Semantic error for correct test case.
 
 program omp_loop_simd
   integer i, j, k, l
   k = 0;

flang/test/Semantics/omp-nested01.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 
 ! Check OpenMP 2.17 Nesting of Regions
 
   N = 1024
   !$omp do
   do i = 1, N
      !ERROR: A worksharing region may not be closely nested inside a worksharing, explicit task, taskloop, critical, ordered, atomic, or master region
      !$omp do
      do j = 1, N
         a = 3.14
      enddo
   enddo
 end

flang/test/Semantics/omp-no-dowhile-in-parallel.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 
 subroutine bug48308(x,i)
   real :: x(:)
   integer :: i
   !$omp parallel firstprivate(i)
     do while (i>0)
       x(i) = i
       i = i - 1

flang/test/Semantics/omp-parallel-private01.f90

-!RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+!RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.15.3.3 parallel private Clause
 program omp_parallel_private
   integer :: i, j, a(10), b(10), c(10)
   integer :: k = 10
   type my_type
     integer :: array(10)
   end type my_type

flang/test/Semantics/omp-parallel-private02.f90

-!RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+!RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.15.3.3 parallel private Clause
 program omp_parallel_private
   integer :: i, j, a(10), b(10), c(10)
   integer :: k = 10
   integer :: array(10)
 
   do i = 1, 10

flang/test/Semantics/omp-parallel-private03.f90

-!RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+!RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.15.3.3 parallel private Clause
 program omp_parallel_private
   integer :: i, j, a(10), b(10), c(10)
   integer :: k = 10
   type my_type
     integer :: array(10)
   end type my_type

flang/test/Semantics/omp-parallel-private04.f90

-!RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+!RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.15.3.3 parallel private Clause
 program omp_parallel_private
   integer :: i, j, a(10), b(10), c(10)
   integer :: k = 10
   type my_type
     integer :: array(10)
   end type my_type

flang/test/Semantics/omp-parallel-shared01.f90

-!RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+!RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.15.3.2 parallel shared Clause
 program omp_parallel_shared
   integer :: i, j, a(10), b(10), c(10)
   integer :: k = 10
   type my_type
   integer :: array(10)
   end type my_type

flang/test/Semantics/omp-parallel-shared02.f90

-!RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+!RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.15.3.2 parallel shared Clause
 program omp_parallel_shared
   integer :: i, j, a(10), b(10), c(10)
   integer :: k = 10
   integer :: array(10)
 
   do i = 1, 10

flang/test/Semantics/omp-parallel-shared03.f90

-!RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+!RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.15.3.2 parallel shared Clause
 program omp_parallel_shared
   integer :: i, j, a(10), b(10), c(10)
   integer :: k = 10
   type my_type
     integer :: array(10)
   end type my_type

flang/test/Semantics/omp-parallel-shared04.f90

-!RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+!RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.15.3.2 parallel shared Clause
 program omp_parallel_shared
   integer :: i, j, a(10), b(10), c(10)
   integer :: k = 10
   type my_type
     integer :: array(10)
   end type my_type

flang/test/Semantics/omp-parallel01.f90

-! RUN: not %f18 -fparse-only -fopenmp %s 2>&1 | FileCheck %s
+! RUN: not %flang -fsyntax-only -fopenmp %s 2>&1 | FileCheck %s
 ! OpenMP Version 4.5
 ! 2.5 parallel construct.
 ! A program that branches into or out of a parallel region
 ! is non-conforming.
 
 program omp_parallel
   integer i, j, k
 

flang/test/Semantics/omp-parallel02.f90

-! RUN: not %f18 -fparse-only -fopenmp %s 2>&1 | FileCheck %s
+! RUN: not %flang -fsyntax-only -fopenmp %s 2>&1 | FileCheck %s
 ! OpenMP Version 4.5
 ! 2.5 parallel construct.
 ! A program that branches into or out of a parallel region
 ! is non-conforming.
 
 program omp_parallel
   integer i, j, k
 

flang/test/Semantics/omp-private01.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.15.3.3 private Clause
 ! Pointers with the INTENT(IN) attribute may not appear in a private clause.
 
 subroutine omp_private(p)
   integer :: a(10), b(10), c(10)
   integer, pointer, intent(in) :: p
 

flang/test/Semantics/omp-private02.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.15.3.3 private Clause
 ! Variables that appear in namelist statements may not appear in a private clause.
 
 module test
   integer :: a, b, c
   namelist /nlist1/ a, b
 end module

flang/test/Semantics/omp-private03.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! Variables that appear in expressions for statement function definitions
 ! may not appear in private, firstprivate or lastprivate clauses.
 
 subroutine stmt_function(temp)
 
   integer :: i, p, q, r
   real :: c, f, s, v, t(10)

flang/test/Semantics/omp-resolve01.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 
 ! 2.4 An array section designates a subset of the elements in an array. Although
 ! Substring shares similar syntax but cannot be treated as valid array section.
 
   character*8 c, b
   character a
 
   b = "HIFROMPGI"
   c = b(2:7)
   !ERROR: Substrings are not allowed on OpenMP directives or clauses
   !$omp parallel private(c(1:3))
   a = c(1:1)
   !$omp end parallel
 end

flang/test/Semantics/omp-resolve02.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 
 ! Test the effect to name resolution from illegal clause
 
   !a = 1.0
   b = 2
   !$omp parallel private(a) shared(b)
   a = 3.
   b = 4

flang/test/Semantics/omp-resolve03.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 
 ! 2.15.3 Although variables in common blocks can be accessed by use association
 ! or host association, common block names cannot. As a result, a common block
 ! name specified in a data-sharing attribute clause must be declared to be a
 ! common block in the same scoping unit in which the data-sharing attribute
 ! clause appears.
 
   common /c/ a, b

flang/test/Semantics/omp-resolve04.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 
 ! 2.15.3 Data-Sharing Attribute Clauses
 ! A list item that specifies a given variable may not appear in more than
 ! one clause on the same directive, except that a variable may be specified
 ! in both firstprivate and lastprivate clauses.
 
   common /c/ a, b
   integer a(3), b

flang/test/Semantics/omp-resolve05.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 
 ! 2.15.3 Data-Sharing Attribute Clauses
 ! 2.15.3.1 default Clause
 
 subroutine default_none()
   integer a(3)
 
   A = 1

flang/test/Semantics/omp-sections01.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 
 ! OpenMP Version 4.5
 ! 2.7.2 sections Construct
 ! Only a single nowait clause can appear on a sections directive.
 
 program omp_sections
 
   !$omp sections
     !$omp section
     print *, "omp section"
   !ERROR: At most one NOWAIT clause can appear on the END SECTIONS directive
   !$omp end sections nowait nowait
 
 end program omp_sections

flang/test/Semantics/omp-simd01.f90

-! RUN: not %f18 -fparse-only -fopenmp %s 2>&1 | FileCheck %s
+! RUN: not %flang -fsyntax-only -fopenmp %s 2>&1 | FileCheck %s
 ! OpenMP Version 4.5
 ! 2.8.1 simd Construct
 ! A program that branches into or out of a simd region is non-conforming.
 
 program omp_simd
   integer i, j
 
   !$omp simd

flang/test/Semantics/omp-simd02.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 
 ! OpenMP Version 4.5
 ! 2.8.1 simd Construct
 ! Semantic error for correct test case
 
 program omp_simd
   integer i, j, k
   integer, allocatable :: a(:)

flang/test/Semantics/omp-simd03.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! XFAIL: *
 
 ! OpenMP Version 4.5
 ! 2.8.1 simd Construct
 ! An ordered construct with the simd clause is the only OpenMP construct
 ! that can be encountered during execution of a simd region.
 
 program omp_simd

flang/test/Semantics/omp-single01.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! XFAIL: *
 
 ! OpenMP Version 4.5
 ! 2.7.3 single Construct
 ! Symbol present on multiple clauses
 
 program omp_single
   integer i
   i = 10
 
   !$omp single private(i)
   print *, "omp single", i
   !ERROR: Symbol ‘i’ present on multiple clauses
   !$omp end single copyprivate(i)
 
 end program omp_single

flang/test/Semantics/omp-single02.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! XFAIL: *
 
 ! OpenMP Version 4.5
 ! 2.7.3 single Construct
 ! Copyprivate variable is not thread private or private in outer context
 
 program omp_single
   integer i

flang/test/Semantics/omp-task01.f90

-! RUN: not %f18 -fparse-only -fopenmp %s 2>&1 | FileCheck %s
+! RUN: not %flang -fsyntax-only -fopenmp %s 2>&1 | FileCheck %s
 ! OpenMP Version 4.5
 ! 2.9.1 task Construct
 ! Invalid entry to OpenMP structured block.
 
 recursive subroutine traverse ( P )
   type Node
     type(Node), pointer :: left, right
   end type Node

flang/test/Semantics/omp-taskloop-simd01.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! XFAIL: *
 
 ! OpenMP Version 4.5
 ! 2.9.3 taskloop simd Construct
 ! No reduction clause may be specified for !$omp taskloop simd.
 
 program omp_taskloop_simd
   integer i , j , k

flang/test/Semantics/omp-taskloop01.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.9.2 taskloop Construct
 
 subroutine parallel_work
   integer i
   integer j
 
   !$omp taskgroup

flang/test/Semantics/omp-taskloop02.f90

-! RUN: not %f18 -fparse-only -fopenmp %s 2>&1 | FileCheck %s
+! RUN: not %flang -fsyntax-only -fopenmp %s 2>&1 | FileCheck %s
 ! OpenMP Version 4.5
 ! 2.9.2 taskloop Construct
 ! Invalid entry to OpenMP structured block.
 
 program omp_taskloop
   integer i , j
 
   !CHECK: invalid branch into an OpenMP structured block

flang/test/Semantics/omp-taskloop03.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! XFAIL: *
 
 ! OpenMP Version 4.5
 ! 2.9.2 taskloop Construct
 ! All loops associated with the taskloop construct must be perfectly nested,
 ! there must be no intervening code or any OpenMP directive between
 ! any two loops
 

flang/test/Semantics/omp-workshare01.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.7.4 workshare Construct
 ! Invalid do construct inside !$omp workshare
 
 subroutine workshare(aa, bb, cc, dd, ee, ff, n)
   integer n, i
   real aa(n,n), bb(n,n), cc(n,n), dd(n,n), ee(n,n), ff(n,n)
 

flang/test/Semantics/omp-workshare02.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.7.4 workshare Construct
 ! The !omp workshare construct must not contain any user defined
 ! function calls unless the function is ELEMENTAL.
 
 module my_mod
   contains
   integer function my_func()

flang/test/Semantics/omp-workshare03.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.7.4 workshare Construct
 ! All array assignments, scalar assignments, and masked array assignments
 ! must be intrinsic assignments.
 
 module defined_assign
   interface assignment(=)
     module procedure work_assign

flang/test/Semantics/omp-workshare04.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.7.4 workshare Construct
 ! Checks for OpenMP Workshare construct
 
 subroutine omp_workshare(aa, bb, cc, dd, ee, ff, n)
   integer i, j, n, a(10), b(10)
   integer, pointer :: p
   integer, target :: t

flang/test/Semantics/omp-workshare05.f90

-! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! RUN: %S/test_errors.sh %s %t %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.7.4 workshare Construct
 ! Checks for OpenMP Parallel constructs enclosed in Workshare constructs
 
 module workshare_mod
   interface assignment(=)
     module procedure work_assign
   end interface