[mlir] Fix various issues in TimerImpl.

[rdzhabarov]

Summary

More specifically:

1. Use variable after move.
2. steady_clock needs to be used for measuring time intervals, but not the system_clock.

mlir/lib/Support/Timing.cpp

 class TimerImpl {
 public:
   using ChildrenMap = llvm::MapVector<const void *, std::unique_ptr<TimerImpl>>;
   using AsyncChildrenMap = llvm::DenseMap<uint64_t, ChildrenMap>;
 
   TimerImpl(std::string &&name) : threadId(llvm::get_threadid()), name(name) {}
 
   /// Start the timer.
-  void start() { startTime = std::chrono::system_clock::now(); }
+  void start() { startTime = std::chrono::steady_clock::now(); }
 
   /// Stop the timer.
   void stop() {
-    auto newTime = std::chrono::system_clock::now() - startTime;
+    auto newTime = std::chrono::steady_clock::now() - startTime;
     wallTime += newTime;
     userTime += newTime;
   }
 
   /// Create a child timer nested within this one. Multiple calls to this
   /// function with the same unique identifier `id` will return the same child
   /// timer.
   ///
public:
   /// Merge multiple child timers into this timer.
   ///
   /// Children in `other` are added as children to this timer, or, if this timer
   /// already contains a child with the corresponding unique identifier, are
   /// merged into the existing child.
   void mergeChildren(ChildrenMap &&other) {
     if (children.empty()) {
       children = std::move(other);
-      for (auto &child : other)
+      for (auto &child : children)
         child.second->mergeAsyncChildren();
     } else {
       for (auto &child : other)
         mergeChild(child.first, std::move(child.second));
       other.clear();
     }
   }
 
void print(raw_ostream &os, DisplayMode displayMode) {
     for (auto &child : children)
       rest -= child.second->getTimeRecord();
     printTimeEntry(os, 0, "Rest", rest, total);
     printTimeEntry(os, 0, "Total", total, total);
     os.flush();
   }
 
   /// The last time instant at which the timer was started.
-  std::chrono::time_point<std::chrono::system_clock> startTime;
+  std::chrono::time_point<std::chrono::steady_clock> startTime;
 
   /// Accumulated wall time. If multiple threads of execution are merged into
   /// this timer, the wall time will hold the maximum wall time of each thread
   /// of execution.
   std::chrono::nanoseconds wallTime = std::chrono::nanoseconds(0);
 
   /// Accumulated user time. If multiple threads of execution are merged into
   /// this timer, each thread's user time is added here.