Address reviewer comments. Remove code specific to -ftime-report= since that

is not supported right now anyway.

Add checks that will only print out timing streams if there is anything in them
to avoid empty lines.

Author: Tarun Prabhu

flang/include/flang/Frontend/CompilerInstance.h

@@ -279,7 +279,6 @@ class CompilerInstance {
   /// {
   /// @name Timing
   /// @{
-  bool isTimingEnabled() { return timingMgr.isEnabled(); }
   bool isTimingEnabled() const { return timingMgr.isEnabled(); }
 
   mlir::DefaultTimingManager &getTimingManager() { return timingMgr; }

flang/include/flang/Frontend/CompilerInvocation.h

@@ -148,10 +148,6 @@ class CompilerInvocation : public CompilerInvocationBase {
   /// is enabled.
   bool enableTimers;
 
-  /// Whether to report the timing of each run of an LLVM pass. Set when
-  /// -ftime-report=per-pass-run is enabled.
-  bool timeLLVMPassesPerRun;
-
 public:
   CompilerInvocation() = default;
 
@@ -234,9 +230,6 @@ class CompilerInvocation : public CompilerInvocationBase {
   bool getEnableTimers() { return enableTimers; }
   bool getEnableTimers() const { return enableTimers; }
 
-  bool getTimeLLVMPassesPerRun() { return timeLLVMPassesPerRun; }
-  bool getTimeLLVMPassesPerRun() const { return timeLLVMPassesPerRun; }
-
   /// 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

flang/lib/Frontend/CompilerInstance.cpp

@@ -178,7 +178,6 @@ bool CompilerInstance::executeAction(FrontendAction &act) {
     // Once the root cause of this is determined, we should enable this to have
     // behavior that is comparable to clang.
     // llvm::TimePassesIsEnabled = true;
-    // llvm::TimePassesPerRun = invoc.getTimeLLVMPassesPerRun();
 
     timingStreamMLIR = std::make_unique<Fortran::support::string_ostream>();
     timingStreamLLVM = std::make_unique<Fortran::support::string_ostream>();
@@ -218,11 +217,19 @@ bool CompilerInstance::executeAction(FrontendAction &act) {
     timingMgr.setOutput(
         Fortran::support::createTimingFormatterText(mlir::thread_safe_nulls()));
 
-    // This is deliberately done in "reverse" order and does not match the
-    // behavior of clang.
-    llvm::errs() << timingStreamCodeGen->str() << "\n";
-    llvm::errs() << timingStreamLLVM->str() << "\n";
-    llvm::errs() << timingStreamMLIR->str() << "\n";
+    // This prints the timings in "reverse" order, starting from code
+    // generation, followed by LLVM-IR optimizations, then MLIR optimizations
+    // and transformations and the frontend. If any of the steps are disabled,
+    // for instance because code generation was not performed, the strings
+    // will be empty.
+    if (!timingStreamCodeGen->str().empty())
+      llvm::errs() << timingStreamCodeGen->str() << "\n";
+
+    if (!timingStreamLLVM->str().empty())
+      llvm::errs() << timingStreamLLVM->str() << "\n";
+
+    if (!timingStreamMLIR->str().empty())
+      llvm::errs() << timingStreamMLIR->str() << "\n";
   }
 
   return !getDiagnostics().getClient()->getNumErrors();

flang/lib/Frontend/CompilerInvocation.cpp

@@ -1360,20 +1360,8 @@ bool CompilerInvocation::createFromArgs(
 
   // Process the timing-related options.
   if (const llvm::opt::Arg *a =
-          args.getLastArg(clang::driver::options::OPT_ftime_report,
-                          clang::driver::options::OPT_ftime_report_EQ)) {
+          args.getLastArg(clang::driver::options::OPT_ftime_report)) {
     invoc.enableTimers = true;
-    if (a->getOption().getID() == clang::driver::options::OPT_ftime_report_EQ) {
-      llvm::StringRef val = a->getValue();
-      if (val == "per-pass") {
-        invoc.timeLLVMPassesPerRun = false;
-      } else if (val == "per-pass-run") {
-        invoc.timeLLVMPassesPerRun = true;
-      } else {
-        diags.Report(clang::diag::err_drv_invalid_value)
-            << a->getAsString(args) << a->getValue();
-      }
-    }
   }
 
   invoc.setArgv0(argv0);