--- a/include/llvm/Support/Timer.h	Tue Jan 26 22:56:36 2016 +0900
+++ b/include/llvm/Support/Timer.h	Fri Nov 25 19:14:25 2016 +0900
@@ -24,17 +24,17 @@
 class raw_ostream;
 
 class TimeRecord {
-  double WallTime;       // Wall clock time elapsed in seconds
-  double UserTime;       // User time elapsed
-  double SystemTime;     // System time elapsed
-  ssize_t MemUsed;       // Memory allocated (in bytes)
+  double WallTime;       ///< Wall clock time elapsed in seconds.
+  double UserTime;       ///< User time elapsed.
+  double SystemTime;     ///< System time elapsed.
+  ssize_t MemUsed;       ///< Memory allocated (in bytes).
 public:
   TimeRecord() : WallTime(0), UserTime(0), SystemTime(0), MemUsed(0) {}
 
-  /// getCurrentTime - Get the current time and memory usage.  If Start is true
-  /// we get the memory usage before the time, otherwise we get time before
-  /// memory usage.  This matters if the time to get the memory usage is
-  /// significant and shouldn't be counted as part of a duration.
+  /// Get the current time and memory usage.  If Start is true we get the memory
+  /// usage before the time, otherwise we get time before memory usage.  This
+  /// matters if the time to get the memory usage is significant and shouldn't
+  /// be counted as part of a duration.
   static TimeRecord getCurrentTime(bool Start = true);
 
   double getProcessTime() const { return UserTime + SystemTime; }
@@ -43,7 +43,6 @@
   double getWallTime() const { return WallTime; }
   ssize_t getMemUsed() const { return MemUsed; }
 
-  // operator< - Allow sorting.
   bool operator<(const TimeRecord &T) const {
     // Sort by Wall Time elapsed, as it is the only thing really accurate
     return WallTime < T.WallTime;
@@ -67,27 +66,32 @@
   void print(const TimeRecord &Total, raw_ostream &OS) const;
 };
 
-/// Timer - This class is used to track the amount of time spent between
-/// invocations of its startTimer()/stopTimer() methods.  Given appropriate OS
-/// support it can also keep track of the RSS of the program at various points.
-/// By default, the Timer will print the amount of time it has captured to
-/// standard error when the last timer is destroyed, otherwise it is printed
-/// when its TimerGroup is destroyed.  Timers do not print their information
-/// if they are never started.
-///
+/// This class is used to track the amount of time spent between invocations of
+/// its startTimer()/stopTimer() methods.  Given appropriate OS support it can
+/// also keep track of the RSS of the program at various points.  By default,
+/// the Timer will print the amount of time it has captured to standard error
+/// when the last timer is destroyed, otherwise it is printed when its
+/// TimerGroup is destroyed.  Timers do not print their information if they are
+/// never started.
 class Timer {
-  TimeRecord Time;       // The total time captured
-  TimeRecord StartTime;  // The time startTimer() was last called
-  std::string Name;      // The name of this time variable.
-  bool Running;          // Is the timer currently running?
-  bool Triggered;        // Has the timer ever been triggered?
-  TimerGroup *TG;        // The TimerGroup this Timer is in.
+  TimeRecord Time;          ///< The total time captured.
+  TimeRecord StartTime;     ///< The time startTimer() was last called.
+  std::string Name;         ///< The name of this time variable.
+  std::string Description;  ///< Description of this time variable.
+  bool Running;             ///< Is the timer currently running?
+  bool Triggered;           ///< Has the timer ever been triggered?
+  TimerGroup *TG = nullptr; ///< The TimerGroup this Timer is in.
 
-  Timer **Prev, *Next;   // Doubly linked list of timers in the group.
+  Timer **Prev;             ///< Pointer to \p Next of previous timer in group.
+  Timer *Next;              ///< Next timer in the group.
 public:
-  explicit Timer(StringRef N) : TG(nullptr) { init(N); }
-  Timer(StringRef N, TimerGroup &tg) : TG(nullptr) { init(N, tg); }
-  Timer(const Timer &RHS) : TG(nullptr) {
+  explicit Timer(StringRef Name, StringRef Description) {
+    init(Name, Description);
+  }
+  Timer(StringRef Name, StringRef Description, TimerGroup &tg) {
+    init(Name, Description, tg);
+  }
+  Timer(const Timer &RHS) {
     assert(!RHS.TG && "Can only copy uninitialized timers");
   }
   const Timer &operator=(const Timer &T) {
@@ -96,14 +100,18 @@
   }
   ~Timer();
 
-  // Create an uninitialized timer, client must use 'init'.
-  explicit Timer() : TG(nullptr) {}
-  void init(StringRef N);
-  void init(StringRef N, TimerGroup &tg);
+  /// Create an uninitialized timer, client must use 'init'.
+  explicit Timer() {}
+  void init(StringRef Name, StringRef Description);
+  void init(StringRef Name, StringRef Description, TimerGroup &tg);
 
   const std::string &getName() const { return Name; }
+  const std::string &getDescription() const { return Description; }
   bool isInitialized() const { return TG != nullptr; }
 
+  /// Check if the timer is currently running.
+  bool isRunning() const { return Running; }
+
   /// Check if startTimer() has ever been called on this timer.
   bool hasTriggered() const { return Triggered; }
 
@@ -129,7 +137,6 @@
 /// stopTimer() methods of the Timer class.  When the object is constructed, it
 /// starts the timer specified as its argument.  When it is destroyed, it stops
 /// the relevant timer.  This makes it easy to time a region of code.
-///
 class TimeRegion {
   Timer *T;
   TimeRegion(const TimeRegion &) = delete;
@@ -146,51 +153,77 @@
   }
 };
 
-/// NamedRegionTimer - This class is basically a combination of TimeRegion and
-/// Timer.  It allows you to declare a new timer, AND specify the region to
-/// time, all in one statement.  All timers with the same name are merged.  This
-/// is primarily used for debugging and for hunting performance problems.
-///
+/// This class is basically a combination of TimeRegion and Timer.  It allows
+/// you to declare a new timer, AND specify the region to time, all in one
+/// statement.  All timers with the same name are merged.  This is primarily
+/// used for debugging and for hunting performance problems.
 struct NamedRegionTimer : public TimeRegion {
-  explicit NamedRegionTimer(StringRef Name,
-                            bool Enabled = true);
-  explicit NamedRegionTimer(StringRef Name, StringRef GroupName,
-                            bool Enabled = true);
+  explicit NamedRegionTimer(StringRef Name, StringRef Description,
+                            StringRef GroupName,
+                            StringRef GroupDescription, bool Enabled = true);
 };
 
 /// The TimerGroup class is used to group together related timers into a single
 /// report that is printed when the TimerGroup is destroyed.  It is illegal to
 /// destroy a TimerGroup object before all of the Timers in it are gone.  A
 /// TimerGroup can be specified for a newly created timer in its constructor.
-///
 class TimerGroup {
+  struct PrintRecord {
+    TimeRecord Time;
+    std::string Name;
+    std::string Description;
+
+    PrintRecord(const PrintRecord &Other) = default;
+    PrintRecord(const TimeRecord &Time, const std::string &Name,
+                const std::string &Description)
+      : Time(Time), Name(Name), Description(Description) {}
+
+    bool operator <(const PrintRecord &Other) const {
+      return Time < Other.Time;
+    }
+  };
   std::string Name;
-  Timer *FirstTimer;   // First timer in the group.
-  std::vector<std::pair<TimeRecord, std::string>> TimersToPrint;
+  std::string Description;
+  Timer *FirstTimer = nullptr; ///< First timer in the group.
+  std::vector<PrintRecord> TimersToPrint;
 
-  TimerGroup **Prev, *Next; // Doubly linked list of TimerGroup's.
+  TimerGroup **Prev; ///< Pointer to Next field of previous timergroup in list.
+  TimerGroup *Next;  ///< Pointer to next timergroup in list.
   TimerGroup(const TimerGroup &TG) = delete;
   void operator=(const TimerGroup &TG) = delete;
 
 public:
-  explicit TimerGroup(StringRef name);
+  explicit TimerGroup(StringRef Name, StringRef Description);
   ~TimerGroup();
 
-  void setName(StringRef name) { Name.assign(name.begin(), name.end()); }
+  void setName(StringRef NewName, StringRef NewDescription) {
+    Name.assign(NewName.begin(), NewName.end());
+    Description.assign(NewDescription.begin(), NewDescription.end());
+  }
 
-  /// print - Print any started timers in this group and zero them.
+  /// Print any started timers in this group and zero them.
   void print(raw_ostream &OS);
 
-  /// printAll - This static method prints all timers and clears them all out.
+  /// This static method prints all timers and clears them all out.
   static void printAll(raw_ostream &OS);
 
+  /// Ensure global timer group lists are initialized. This function is mostly
+  /// used by the Statistic code to influence the construction and destruction
+  /// order of the global timer lists.
+  static void ConstructTimerLists();
 private:
   friend class Timer;
+  friend void PrintStatisticsJSON(raw_ostream &OS);
   void addTimer(Timer &T);
   void removeTimer(Timer &T);
+  void prepareToPrintList();
   void PrintQueuedTimers(raw_ostream &OS);
+  void printJSONValue(raw_ostream &OS, const PrintRecord &R,
+                      const char *suffix, double Value);
+  const char *printJSONValues(raw_ostream &OS, const char *delim);
+  static const char *printAllJSONValues(raw_ostream &OS, const char *delim);
 };
 
-} // End llvm namespace
+} // end namespace llvm
 
 #endif