[Flang][Driver] Implement OPT_R_Joined options

[victorkingi]

Summary

Add a BackendRemarkConsumer class, responsible for handling diagnostics
received from LLVM. The diagnostics being information on middle and
backend passes used or not used.

Clang by default has all remarks ignored but manually sets the severity of
R_Group to visible(clang::diag::clang::Severity::Remark). This patch does
the same for Flang.

Depends on D157410. That patch adds the R family of options to
FlangOption and FC1Option in
clang/include/clang/Driver/Options.td

[victorkingi]

In flang/lib/Frontend/FrontendActions.cpp removed
DiagnosticPrinter import, no longer needed.

[awarzynski]

flang/lib/Frontend/CompilerInvocation.cpp

223–228

Is this needed? I don't see any tests for -opt-record-passes.

245–256

IIUC, this is not needed in this patch.

[victorkingi]

flang/lib/Frontend/CompilerInvocation.cpp

223–228

This is present in main branch, it is not part of this patch, the reason it's marked green is because I moved its position just before

if (const llvm::opt::Arg *a =
         args.getLastArg(clang::driver::options::OPT_opt_record_format))
   opts.OptRecordFormat = a->getValue();

I'll move it back to its previous location to avoid the confusion

245–256

It is needed since we are implementing the 3 flags

[victorkingi]

To avoid green highlighting on code I did not edit, in
flang/lib/Frontend/CompilerInvocation.cpp, reordered if statement
handling fsave-optimization file record format and passes in line
224 and 231 back to what they were originally.

[kiranchandramohan]

flang/test/Driver/optimization-remark.f90

13

The warnings for unknown remarks is probably its own patch.

[awarzynski]

Thanks for extracting this, more comments inline.

flang/lib/Frontend/CompilerInvocation.cpp

156–158

Please document this method. Also, it looks like the list of valid values of name is limited? Can you add an assert for that?

158

llvm::opt::OptSpecifier optEq is not used

159

name of what? Please avoid such generic variable ... names :)

240–242

Regex is not yet supported. Same comment below.

[victorkingi]

Updated comments on opts.OptimizationRemark in line 235 in flang/lib/Frontend/CompilerInvocation.cpp
Removed warning handling in updateDiagEngineForOptRemark as well as the tests accompanying it.
Removed optEq argument from parseOptimizationRemark.

[victorkingi]

Documented the parseOptimizationRemark method
Renamed assertion message in line 163 in flang/lib/Frontend/CompilerInvocation.cpp

[awarzynski]

Thanks for all the updates, LG % some minor comments (please address before landing this). Great work!

[nit] You can safely drop this from the summary and focus on the contents of the patch itself:

It was created to address the comment about splitting into 4 patches in https://reviews.llvm.org/D156320#4594584

Here's a great intro on writing Git commit messages: https://cbea.ms/git-commit/#imperative

flang/lib/Frontend/CompilerInvocation.cpp

159–160

A "group" in Options.td has a bit special meaning. See e.g. R_Group. More specifically, -Rpass, -Rpass-analysis and -Rpass-missed belong to the R_Group group. So, instead of rGroupName, you probably meant something like remarkType or remarkTypeName or remarkOptName ;-)

172

[nit] Comment that this enables everything

178

[nit] Comment that this disables everything

flang/test/Driver/optimization-remark.f90

2

[nit] You can drop CHECK from custom prefixes. IMHO that's just noise.

25–26

Is there anything that could be checked with e.g. CHECK-REMARKS-MISSED-NOT and CHECK-REMARKS-ANALYSIS-NOT?

[victorkingi]

Removed unnecessary custom prefix CHECK in optimization-remark.f90 tests.
Added "disable and enable everything" comment to parseOptimizationRemark.

flang/test/Driver/optimization-remark.f90

25–26

Nothing comes to mind. Maybe checking if a successful pass was printed instead of a missed pass, but would that be redundant?

[victorkingi]

removed unused diags argument in parseOptimizationRemark.

[awarzynski]

flang/test/Driver/optimization-remark.f90

25–26

Output with -Rpass-missed:

remark: _FortranAioBeginExternalListOutput will not be inlined into _QQmain because its definition is unavailable
remark: _FortranAioOutputAscii will not be inlined into _QQmain because its definition is unavailable
remark: _FortranAioEndIoStatement will not be inlined into _QQmain because its definition is unavailable
remark: _FortranAioBeginExternalListOutput will not be inlined into _QQmain because its definition is unavailable
remark: _FortranAioOutputAscii will not be inlined into _QQmain because its definition is unavailable
remark: _FortranAioEndIoStatement will not be inlined into _QQmain because its definition is unavailable
remark: loop not vectorized

Output with -Rpass-analysis:

remark: loop not vectorized: call instruction cannot be vectorized
remark: loop not vectorized: instruction cannot be vectorized

So:

! CHECK-REMARKS-MISSED-NOT: instruction cannot be vectorized
! CHECK-REMARKS-ANALYSIS-NOT: will not be inlined into {{.*}} because its definition is unavailable

Wouldn't this work?

[victorkingi]

flang/test/Driver/optimization-remark.f90

25–26

I assumed flang might later add support for the missing definitions, causing the test to fail in the future. But now that I think of it, will cross the bridge when we get there :)

I'll update the patch to include that.

[victorkingi]

flang/test/Driver/optimization-remark.f90

25–26

I assumed flang might later add support for the missing definitions, causing the test to fail in the future. But now that I think of it, will cross the bridge when we get there :)

I'll update the patch to include that.

Ignore this comment, I misunderstood what you wanted me to do.

[victorkingi]

Added NOT test cases for REMARK-MISSED and REMARK-ANALYSIS in
optimization-remark.f90

[awarzynski]

flang/test/Driver/optimization-remark.f90

25–28

[nit] To make things easier for our future selves:

! REMARKS-MISSED-NOT: loop not vectorized: instruction cannot be vectorized
! REMARKS-MISSED: remark: loop not vectorized
! REMARKS-MISSED: {{.*}} will not be inlined into {{.*}} because its definition is unavailable

! REMARKS-ANALYSIS-NOT: {{.*}} will not be inlined into {{.*}} because its definition is unavailable
! REMARKS-ANALYSIS: remark: loop not vectorized: instruction cannot be vectorized

Does this make sense?

[victorkingi]

flang/test/Driver/optimization-remark.f90

25–28

yes it does. Since the patch landed, I've added as an NFC commit here https://reviews.llvm.org/D158599

flang/include/flang/Frontend/CodeGenOptions.h

public:
 
   /// The regex that filters the passes that should be saved to the optimization
   /// records.
   std::string OptRecordPasses;
 
   /// The format used for serializing remarks (default: YAML)
   std::string OptRecordFormat;
 
+  // The RemarkKind enum class and OptRemark struct are identical to what Clang
+  // has
+  // TODO: Share with clang instead of re-implementing here
+  enum class RemarkKind {
+    RK_Missing,  // Remark argument not present on the command line.
+    RK_Enabled,  // Remark enabled via '-Rgroup', i.e. -Rpass, -Rpass-missed,
+                 // -Rpass-analysis
+    RK_Disabled, // Remark disabled via '-Rno-group', i.e. -Rno-pass,
+                 // -Rno-pass-missed, -Rno-pass-analysis.
+  };
+
+  /// Optimization remark with an optional regular expression pattern.
+  struct OptRemark {
+    RemarkKind Kind = RemarkKind::RK_Missing;
+    std::string Pattern;
+    std::shared_ptr<llvm::Regex> Regex;
+
+    /// By default, optimization remark is missing.
+    OptRemark() = default;
+
+    /// Returns true iff the optimization remark holds a valid regular
+    /// expression.
+    bool hasValidPattern() const { return Regex != nullptr; }
+
+    /// Matches the given string against the regex, if there is some.
+    bool patternMatches(llvm::StringRef string) const {
+      return hasValidPattern() && Regex->match(string);
+    }
+  };
+
+  // The OptRemark fields provided here are identical to Clang.
+
+  /// Selected optimizations for which we should enable optimization remarks.
+  /// Transformation passes whose name matches the contained (optional) regular
+  /// expression (and support this feature), will emit a diagnostic whenever
+  /// they perform a transformation.
+  OptRemark OptimizationRemark;
+
+  /// Selected optimizations for which we should enable missed optimization
+  /// remarks. Transformation passes whose name matches the contained (optional)
+  /// regular expression (and support this feature), will emit a diagnostic
+  /// whenever they tried but failed to perform a transformation.
+  OptRemark OptimizationRemarkMissed;
+
+  /// Selected optimizations for which we should enable optimization analyses.
+  /// Transformation passes whose name matches the contained (optional) regular
+  /// expression (and support this feature), will emit a diagnostic whenever
+  /// they want to explain why they decided to apply or not apply a given
+  /// transformation.
+  OptRemark OptimizationRemarkAnalysis;
+
   // Define accessors/mutators for code generation options of enumeration type.
 #define CODEGENOPT(Name, Bits, Default)
 #define ENUM_CODEGENOPT(Name, Type, Bits, Default)                             \
   Type get##Name() const { return static_cast<Type>(Name); }                   \
   void set##Name(Type Value) { Name = static_cast<unsigned>(Value); }
 #include "flang/Frontend/CodeGenOptions.def"
 
   CodeGenOptions();
 };
 
 } // end namespace Fortran::frontend
 
 #endif

flang/lib/Frontend/CompilerInvocation.cpp

if (val != llvm::codegenoptions::DebugLineTablesOnly &&
       const auto debugWarning = diags.getCustomDiagID(
           clang::DiagnosticsEngine::Warning, "Unsupported debug option: %0");
       diags.Report(debugWarning) << arg->getValue();
     }
   }
   return true;
 }
 
+static CodeGenOptions::OptRemark
+parseOptimizationRemark(clang::DiagnosticsEngine &diags,
+                        llvm::opt::ArgList &args, llvm::opt::OptSpecifier optEq,
+                        llvm::StringRef name) {
+  CodeGenOptions::OptRemark result;
+
+  for (llvm::opt::Arg *a : args) {
+    if (a->getOption().matches(clang::driver::options::OPT_R_Joined)) {
+      llvm::StringRef value = a->getValue();
+
+      if (value == name) {
+        result.Kind = CodeGenOptions::RemarkKind::RK_Enabled;
+        result.Pattern = ".*";
+        result.Regex = std::make_shared<llvm::Regex>(result.Pattern);
+
+      } else if (value.split('-') ==
+                 std::make_pair(llvm::StringRef("no"), name)) {
+        result.Kind = CodeGenOptions::RemarkKind::RK_Disabled;
+        result.Pattern = "";
+        result.Regex = nullptr;
+      }
+    }
+  }
+  return result;
+}
+
 static void parseCodeGenArgs(Fortran::frontend::CodeGenOptions &opts,
                              llvm::opt::ArgList &args,
                              clang::DiagnosticsEngine &diags) {
   opts.OptimizationLevel = getOptimizationLevel(args, diags);
 
   if (args.hasFlag(clang::driver::options::OPT_fdebug_pass_manager,
                    clang::driver::options::OPT_fno_debug_pass_manager, false))
     opts.DebugPassManager = 1;
else
       opts.PrepareForThinLTO = true;
   }
 
   // -f[no-]save-optimization-record[=<format>]
   if (const llvm::opt::Arg *a =
           args.getLastArg(clang::driver::options::OPT_opt_record_file))
     opts.OptRecordFile = a->getValue();
 
+  // Specifies, using a regex, which successful optimization passes(middle and
+  // backend), to include in the final optimization record file generated. If
+  // not provided -fsave-optimization-record will include all passes.
+  if (const llvm::opt::Arg *a =
+          args.getLastArg(clang::driver::options::OPT_opt_record_passes))
+    opts.OptRecordPasses = a->getValue();
+
+  // Optimization file format. Defaults to yaml
   if (const llvm::opt::Arg *a =
           args.getLastArg(clang::driver::options::OPT_opt_record_format))
     opts.OptRecordFormat = a->getValue();
 
-  if (const llvm::opt::Arg *a =
-          args.getLastArg(clang::driver::options::OPT_opt_record_passes))
-    opts.OptRecordPasses = a->getValue();
+  // OptimizationRemark, OptimizationRemarkMissed and OptimizationRemarkAnalysis
+  // contain regex values used in optimizationRemarkHandler in
+  // FrontendActions.cpp to determine which remarks generated should be outputed
+  // to console.
+
+  // Get -Rpass option regex. If empty, "".*"" is used. From all successful
+  // optimization passes applied, the regex will return only pass names that
+  // match it.
+  opts.OptimizationRemark = parseOptimizationRemark(
+      diags, args, clang::driver::options::OPT_Rpass_EQ, "pass");
+
+  // Get -Rpass-missed option regex. If empty, "".*"" is used. From all
+  // optimization passes that failed to be applied, the regex will return only
+  // pass names that match it.
+  opts.OptimizationRemarkMissed = parseOptimizationRemark(
+      diags, args, clang::driver::options::OPT_Rpass_missed_EQ, "pass-missed");
+
+  // Given a pass, -Rpass-analysis shows when it determined whether or
+  // not to make a transformation.
+  opts.OptimizationRemarkAnalysis = parseOptimizationRemark(
+      diags, args, clang::driver::options::OPT_Rpass_analysis_EQ,
+      "pass-analysis");
 
   if (auto *a = args.getLastArg(clang::driver::options::OPT_save_temps_EQ))
     opts.SaveTempsDir = a->getValue();
 
   // -mrelocation-model option.
   if (const llvm::opt::Arg *a =
           args.getLastArg(clang::driver::options::OPT_mrelocation_model)) {
     llvm::StringRef modelName = a->getValue();
if (args.hasArg(clang::driver::options::OPT_flang_experimental_polymorphism)) {
     res.loweringOpts.setPolymorphicTypeImpl(true);
   }
 
   // -fno-ppc-native-vector-element-order
   if (args.hasArg(clang::driver::options::OPT_fno_ppc_native_vec_elem_order)) {
     res.loweringOpts.setNoPPCNativeVecElemOrder(true);
   }
 
+  // Preserve all the remark options requested, i.e. -Rpass, -Rpass-missed or
+  // -Rpass-analysis. This will be used later when processing and outputting the
+  // remarks generated by LLVM in ExecuteCompilerInvocation.cpp.
+  for (auto *a : args.filtered(clang::driver::options::OPT_R_Group))
+    res.getDiagnosticOpts().Remarks.push_back(a->getValue());
+
   success &= parseFrontendArgs(res.getFrontendOpts(), args, diags);
   parseTargetArgs(res.getTargetOpts(), args);
   parsePreprocessorArgs(res.getPreprocessorOpts(), args);
   parseCodeGenArgs(res.getCodeGenOpts(), args, diags);
   success &= parseDebugArgs(res.getCodeGenOpts(), args, diags);
   success &= parseSemaArgs(res, args, diags);
   success &= parseDialectArgs(res, args, diags);
   success &= parseDiagArgs(res, args, diags);

flang/lib/Frontend/FrontendActions.cpp

 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticFrontend.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Bitcode/BitcodeWriterPass.h"
+#include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/LLVMRemarkStreamer.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Object/OffloadBinary.h"
 #include "llvm/Passes/PassBuilder.h"
 #include "llvm/Passes/PassPlugin.h"
#include "llvm/Support/Extension.def"
 
   if (action == BackendActionTy::Backend_EmitBC)
     mpm.addPass(llvm::BitcodeWriterPass(os));
 
   // Run the passes.
   mpm.run(*llvmModule, mam);
 }
 
+// This class handles optimization remark messages requested if
+// any of -Rpass, -Rpass-analysis or -Rpass-missed flags were provided
+class BackendRemarkConsumer : public llvm::DiagnosticHandler {
+
+  const CodeGenOptions &codeGenOpts;
+  clang::DiagnosticsEngine &diags;
+
+public:
+  BackendRemarkConsumer(clang::DiagnosticsEngine &diags,
+                        const CodeGenOptions &codeGenOpts)
+      : codeGenOpts(codeGenOpts), diags(diags) {}
+
+  bool isAnalysisRemarkEnabled(llvm::StringRef passName) const override {
+    return codeGenOpts.OptimizationRemarkAnalysis.patternMatches(passName);
+  }
+  bool isMissedOptRemarkEnabled(llvm::StringRef passName) const override {
+    return codeGenOpts.OptimizationRemarkMissed.patternMatches(passName);
+  }
+  bool isPassedOptRemarkEnabled(llvm::StringRef passName) const override {
+    return codeGenOpts.OptimizationRemark.patternMatches(passName);
+  }
+
+  bool isAnyRemarkEnabled() const override {
+    return codeGenOpts.OptimizationRemarkAnalysis.hasValidPattern() ||
+           codeGenOpts.OptimizationRemarkMissed.hasValidPattern() ||
+           codeGenOpts.OptimizationRemark.hasValidPattern();
+  }
+
+  void
+  emitOptimizationMessage(const llvm::DiagnosticInfoOptimizationBase &diagInfo,
+                          unsigned diagID) {
+    // We only support warnings and remarks.
+    assert(diagInfo.getSeverity() == llvm::DS_Remark ||
+           diagInfo.getSeverity() == llvm::DS_Warning);
+
+    std::string msg;
+    llvm::raw_string_ostream msgStream(msg);
+    msgStream << diagInfo.getMsg();
+
+    // Emit message.
+    diags.Report(diagID) << clang::AddFlagValue(diagInfo.getPassName())
+                         << msgStream.str();
+  }
+
+  void optimizationRemarkHandler(
+      const llvm::DiagnosticInfoOptimizationBase &diagInfo) {
+    auto passName = diagInfo.getPassName();
+    if (diagInfo.isPassed()) {
+      if (codeGenOpts.OptimizationRemark.patternMatches(passName))
+        // Optimization remarks are active only if the -Rpass flag has a regular
+        // expression that matches the name of the pass name in \p d.
+        emitOptimizationMessage(
+            diagInfo, clang::diag::remark_fe_backend_optimization_remark);
+
+      return;
+    }
+
+    if (diagInfo.isMissed()) {
+      if (codeGenOpts.OptimizationRemarkMissed.patternMatches(passName))
+        // Missed optimization remarks are active only if the -Rpass-missed
+        // flag has a regular expression that matches the name of the pass
+        // name in \p d.
+        emitOptimizationMessage(
+            diagInfo,
+            clang::diag::remark_fe_backend_optimization_remark_missed);
+
+      return;
+    }
+
+    assert(diagInfo.isAnalysis() && "Unknown remark type");
+
+    bool shouldAlwaysPrint = false;
+    auto *ora = llvm::dyn_cast<llvm::OptimizationRemarkAnalysis>(&diagInfo);
+    if (ora)
+      shouldAlwaysPrint = ora->shouldAlwaysPrint();
+
+    if (shouldAlwaysPrint ||
+        codeGenOpts.OptimizationRemarkAnalysis.patternMatches(passName))
+      emitOptimizationMessage(
+          diagInfo,
+          clang::diag::remark_fe_backend_optimization_remark_analysis);
+  }
+
+  bool handleDiagnostics(const llvm::DiagnosticInfo &di) override {
+    switch (di.getKind()) {
+    case llvm::DK_OptimizationRemark:
+      optimizationRemarkHandler(llvm::cast<llvm::OptimizationRemark>(di));
+      break;
+    case llvm::DK_OptimizationRemarkMissed:
+      optimizationRemarkHandler(llvm::cast<llvm::OptimizationRemarkMissed>(di));
+      break;
+    case llvm::DK_OptimizationRemarkAnalysis:
+      optimizationRemarkHandler(
+          llvm::cast<llvm::OptimizationRemarkAnalysis>(di));
+      break;
+    default:
+      break;
+    }
+    return true;
+  }
+};
+
 void CodeGenAction::embedOffloadObjects() {
   CompilerInstance &ci = this->getInstance();
   const auto &cgOpts = ci.getInvocation().getCodeGenOpts();
 
   for (llvm::StringRef offloadObject : cgOpts.OffloadObjects) {
     llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> objectOrErr =
         llvm::MemoryBuffer::getFileOrSTDIN(offloadObject);
     if (std::error_code ec = objectOrErr.getError()) {
void CodeGenAction::executeAction() {
   // an assert for incompatible data layout when the code-generation happens.
   llvmModule->setTargetTriple(theTriple);
   llvmModule->setDataLayout(tm->createDataLayout());
 
   // Embed offload objects specified with -fembed-offload-object
   if (!codeGenOpts.OffloadObjects.empty())
     embedOffloadObjects();
 
+  BackendRemarkConsumer remarkConsumer(diags, codeGenOpts);
+
+  llvmModule->getContext().setDiagnosticHandler(
+      std::make_unique<BackendRemarkConsumer>(remarkConsumer));
+
   // write optimization-record
   llvm::Expected<std::unique_ptr<llvm::ToolOutputFile>> optRecordFileOrErr =
       setupLLVMOptimizationRemarks(
           llvmModule->getContext(), codeGenOpts.OptRecordFile,
           codeGenOpts.OptRecordPasses, codeGenOpts.OptRecordFormat,
           /*DiagnosticsWithHotness=*/false,
           /*DiagnosticsHotnessThreshold=*/0);
 

flang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

 
 #include "flang/Frontend/CompilerInstance.h"
 #include "flang/Frontend/FrontendActions.h"
 #include "flang/Frontend/FrontendPluginRegistry.h"
 
 #include "mlir/IR/AsmState.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/Pass/PassManager.h"
+#include "clang/Basic/DiagnosticFrontend.h"
 #include "clang/Driver/Options.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/BuryPointer.h"
 #include "llvm/Support/CommandLine.h"
 
 namespace Fortran::frontend {
 
case PluginAction: {
     ci.getDiagnostics().Report(diagID) << ci.getFrontendOpts().actionName;
     return nullptr;
   }
   }
 
   llvm_unreachable("Invalid program action!");
 }
 
+// Emit a warning and typo hint for unknown warning opts
+static void emitUnknownDiagWarning(clang::DiagnosticsEngine &diags,
+                                   clang::diag::Flavor flavor,
+                                   llvm::StringRef prefix,
+                                   llvm::StringRef opt) {
+  llvm::StringRef suggestion =
+      clang::DiagnosticIDs::getNearestOption(flavor, opt);
+  diags.Report(clang::diag::warn_unknown_diag_option)
+      << (flavor == clang::diag::Flavor::WarningOrError ? 0 : 1)
+      << (prefix.str() += std::string(opt)) << !suggestion.empty()
+      << (prefix.str() += std::string(suggestion));
+}
+
+// Remarks are ignored by default in Diagnostic.td, hence, we have to
+// enable them here before execution. Clang follows same idea using
+// ProcessWarningOptions in Warnings.cpp
+// This function is also responsible for emitting early warnings for
+// invalid -R options.
+static void
+updateDiagEngineForOptRemarks(clang::DiagnosticsEngine &diagsEng,
+                              const clang::DiagnosticOptions &opts) {
+  llvm::SmallVector<clang::diag::kind, 10> diags;
+  const llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> diagIDs =
+      diagsEng.getDiagnosticIDs();
+
+  for (unsigned i = 0; i < opts.Remarks.size(); i++) {
+    llvm::StringRef remarkOpt = opts.Remarks[i];
+    const auto flavor = clang::diag::Flavor::Remark;
+
+    // Check to see if this opt starts with "no-", if so, this is a
+    // negative form of the option.
+    bool isPositive = !remarkOpt.startswith("no-");
+    if (!isPositive)
+      remarkOpt = remarkOpt.substr(3);
+
+    // Just issue a warning when encountering an unrecognised remark option.
+    if (diagIDs->getDiagnosticsInGroup(flavor, remarkOpt, diags)) {
+      emitUnknownDiagWarning(diagsEng, flavor, isPositive ? "-R" : "-Rno-",
+                             remarkOpt);
+      continue;
+    }
+
+    diagsEng.setSeverityForGroup(flavor, remarkOpt,
+                                 isPositive ? clang::diag::Severity::Remark
+                                            : clang::diag::Severity::Ignored);
+  }
+}
+
 bool executeCompilerInvocation(CompilerInstance *flang) {
   // Honor -help.
   if (flang->getFrontendOpts().showHelp) {
     clang::driver::getDriverOptTable().printHelp(
         llvm::outs(), "flang-new -fc1 [options] file...",
         "LLVM 'Flang' Compiler",
         /*ShowHidden=*/false, /*ShowAllAliases=*/false,
         llvm::opt::Visibility(clang::driver::options::FC1Option));
bool executeCompilerInvocation(CompilerInstance *flang) {
   // If there were errors in processing arguments, don't do anything else.
   if (flang->getDiagnostics().hasErrorOccurred()) {
     return false;
   }
 
   // Honor color diagnostics.
   flang->getDiagnosticOpts().ShowColors = flang->getFrontendOpts().showColors;
 
+  updateDiagEngineForOptRemarks(flang->getDiagnostics(),
+                                flang->getDiagnosticOpts());
+
   // Create and execute the frontend action.
   std::unique_ptr<FrontendAction> act(createFrontendAction(*flang));
   if (!act)
     return false;
 
   bool success = flang->executeAction(*act);
   return success;
 }
 
 } // namespace Fortran::frontend

flang/test/Driver/optimization-remark.f90

+! This file tests the -Rpass family of flags (-Rpass, -Rpass-missed
+! and -Rpass-analysis)
+! loop-delete isn't enabled at O0 so we use at least O1
+
+! Check that we can override -Rpass= with -Rno-pass.
+! RUN: %flang_fc1 %s -O1 -Rpass -emit-llvm -o - 2>&1 | FileCheck %s --check-prefix=CHECK-REMARKS
+! RUN: %flang_fc1 %s -O1 -Rpass -Rno-pass -emit-llvm -o - 2>&1 | FileCheck %s --check-prefix=CHECK-NO-REMARKS
+
+! Check "unknown remark option" warning
+! RUN: %flang %s -O1 -R 2>&1 | FileCheck %s --check-prefix=CHECK-REMARKS-WARN
+
+! Check "unknown remark option" warning with suggestion
+! RUN: %flang %s -O1 -Rpas 2>&1 | FileCheck %s --check-prefix=CHECK-WARN-SUGGEST
+
+! Check -Rno-pass, -Rno-pass-analysis, -Rno-pass-missed nothing emitted
+! RUN: %flang %s -O1 -Rno-pass 2>&1 | FileCheck %s --allow-empty --check-prefix=CHECK-NO-REMARKS
+! RUN: %flang %s -O1 -Rno-pass-missed 2>&1 | FileCheck %s --allow-empty --check-prefix=CHECK-NO-REMARKS
+! RUN: %flang %s -O1 -Rno-pass-analysis 2>&1 | FileCheck %s --allow-empty --check-prefix=CHECK-NO-REMARKS
+
+! Check full -Rpass message is emitted
+! RUN: %flang %s -O1 -Rpass 2>&1 | FileCheck %s
+
+! Check full -Rpass-missed message is emitted
+! RUN: %flang %s -O1 -Rpass-missed 2>&1 | FileCheck %s --check-prefix=CHECK-REMARKS-MISSED
+
+! Check full -Rpass-analysis message is emitted
+! RUN: %flang %s -O1 -Rpass-analysis 2>&1 | FileCheck %s --check-prefix=CHECK-REMARKS-ANALYSIS
+
+! CHECK: remark: Loop deleted because it is invariant
+! CHECK-REMARKS-MISSED: remark: loop not vectorized
+! CHECK-REMARKS-ANALYSIS: remark: loop not vectorized: instruction cannot be vectorized
+! CHECK-REMARKS: remark:
+! CHECK-NO-REMARKS-NOT: remark:
+
+! CHECK-REMARKS-WARN: warning: unknown remark option '-R'
+! CHECK-WARN-SUGGEST: warning: unknown remark option '-Rpas'; did you mean '-Rpass'?
+
+program forttest
+    implicit none
+    real, dimension(1:50) :: aR1
+    integer :: n
+
+    do n = 1,50
+        aR1(n) = n * 1.34
+        print *, "hello"
+    end do
+
+    do n = 1,50
+        aR1(n) = n * 1.34
+    end do
+
+end program forttest