[analyzer] Extend operator overloading for ' - ' and ' + ' operators on llvm::TimeRecord

[RithikSharma]

Summary

This patch is an attempt to extend the operator overloading for ' - ' and ' + ' operators.

While implementing #D105565 (Print time taken to analyze each function), we realized that the ' - ' operator isn't overloaded on llvm::TimeRecord.

Previously:

CheckerEndTime -= CheckerStartTime;
DisplayTime(CheckerEndTime);

Now:

DisplayTime(CheckerEndTime - CheckerStartTime);

[NoQ]

Nice! Please add some reviewers based on git blame for Timer.h.

llvm/include/llvm/Support/Timer.h

69

Did you try the suggested canonical form from https://en.cppreference.com/w/cpp/language/operators? It's a bit shorter and they say it's more optimizer-friendly.

clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp

#include "clang/StaticAnalyzer/Core/Analyses.def"
     default:
       llvm_unreachable("Unknown constraint manager.");
 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATEFN)     \
       case NAME##Model: CreateConstraintMgr = CREATEFN; break;
 #include "clang/StaticAnalyzer/Core/Analyses.def"
     }
   }
 
-  void DisplayTime(llvm::TimeRecord &Time) {
+  void DisplayTime(llvm::TimeRecord Time) {
     if (!Opts->AnalyzerDisplayProgress) {
       return;
     }
     llvm::errs() << " : " << llvm::format("%1.1f", Time.getWallTime() * 1000)
                  << " ms\n";
   }
 
   void DisplayFunction(const Decl *D, AnalysisMode Mode,
if (Mode & AM_Syntax) {
     if (SyntaxCheckTimer) {
       CheckerStartTime = SyntaxCheckTimer->getTotalTime();
       SyntaxCheckTimer->startTimer();
     }
     checkerMgr->runCheckersOnASTBody(D, *Mgr, BR);
     if (SyntaxCheckTimer) {
       SyntaxCheckTimer->stopTimer();
       llvm::TimeRecord CheckerEndTime = SyntaxCheckTimer->getTotalTime();
-      CheckerEndTime -= CheckerStartTime;
-      DisplayTime(CheckerEndTime);
+      DisplayTime(CheckerEndTime - CheckerStartTime);
     }
   }
 
   BR.FlushReports();
 
   if ((Mode & AM_Path) && checkerMgr->hasPathSensitiveCheckers()) {
     RunPathSensitiveChecks(D, IMode, VisitedCallees);
     if (IMode != ExprEngine::Inline_Minimal)
if (ExprEngineTimer) {
     ExprEngineStartTime = ExprEngineTimer->getTotalTime();
     ExprEngineTimer->startTimer();
   }
   Eng.ExecuteWorkList(Mgr->getAnalysisDeclContextManager().getStackFrame(D),
                       Mgr->options.MaxNodesPerTopLevelFunction);
   if (ExprEngineTimer) {
     ExprEngineTimer->stopTimer();
     llvm::TimeRecord ExprEngineEndTime = ExprEngineTimer->getTotalTime();
-    ExprEngineEndTime -= ExprEngineStartTime;
-    DisplayTime(ExprEngineEndTime);
+    DisplayTime(ExprEngineEndTime - ExprEngineStartTime);
   }
 
   if (!Mgr->options.DumpExplodedGraphTo.empty())
     Eng.DumpGraph(Mgr->options.TrimGraph, Mgr->options.DumpExplodedGraphTo);
 
   // Visualize the exploded graph.
   if (Mgr->options.visualizeExplodedGraphWithGraphViz)
     Eng.ViewGraph(Mgr->options.TrimGraph);

llvm/include/llvm/Support/Timer.h

public:
   }
   void operator-=(const TimeRecord &RHS) {
     WallTime -= RHS.WallTime;
     UserTime -= RHS.UserTime;
     SystemTime -= RHS.SystemTime;
     MemUsed -= RHS.MemUsed;
     InstructionsExecuted -= RHS.InstructionsExecuted;
   }
+  TimeRecord operator-(const TimeRecord &RHS) {
+    TimeRecord TR(*this);
+    TR -= RHS;
+    return TR;
+  }
+  TimeRecord operator+(const TimeRecord &RHS) {
+    TimeRecord TR(*this);
+    TR += RHS;
+    return TR;
+  }
 
   /// Print the current time record to \p OS, with a breakdown showing
   /// contributions to the \p Total time record.
   void print(const TimeRecord &Total, raw_ostream &OS) const;
 };
 
 /// This class is used to track the amount of time spent between invocations of
 /// its startTimer()/stopTimer() methods.  Given appropriate OS support it can