Add auto source map deduce count statistics

[yinghuitan]

Summary

This patch adds auto source map deduce count as a target level statistics.
This will help telemetry to track how many debug sessions benefit from this feature.

[yinghuitan]

rebase and trigger linter

lldb/include/lldb/Target/PathMappingList.h

public:
   ~PathMappingList();
 
   const PathMappingList &operator=(const PathMappingList &rhs);
 
   void Append(llvm::StringRef path, llvm::StringRef replacement, bool notify);
 
   void Append(const PathMappingList &rhs, bool notify);
 
-  void AppendUnique(llvm::StringRef path, llvm::StringRef replacement,
+  /// Append <path, replacement> pair without duplication.
+  /// \return whether appending suceeds without duplication or not.
+  bool AppendUnique(llvm::StringRef path, llvm::StringRef replacement,
                     bool notify);
 
   void Clear(bool notify);
 
   // By default, dump all pairs.
   void Dump(Stream *s, int pair_index = -1);
 
   llvm::json::Value ToJSON();

lldb/include/lldb/Target/Statistics.h

 /// A class that represents statistics for a since lldb_private::Target.
 class TargetStats {
 public:
   llvm::json::Value ToJSON(Target &target);
 
   void SetLaunchOrAttachTime();
   void SetFirstPrivateStopTime();
   void SetFirstPublicStopTime();
+  void IncreaseSourceMapDeduceCount();
 
   StatsDuration &GetCreateTime() { return m_create_time; }
   StatsSuccessFail &GetExpressionStats() { return m_expr_eval; }
   StatsSuccessFail &GetFrameVariableStats() { return m_frame_var; }
 
 protected:
   StatsDuration m_create_time;
   llvm::Optional<StatsTimepoint> m_launch_or_attach_time;
   llvm::Optional<StatsTimepoint> m_first_private_stop_time;
   llvm::Optional<StatsTimepoint> m_first_public_stop_time;
   StatsSuccessFail m_expr_eval{"expressionEvaluation"};
   StatsSuccessFail m_frame_var{"frameVariable"};
   std::vector<intptr_t> m_module_identifiers;
+  uint32_t m_source_map_deduce_count = 0;
   void CollectStats(Target &target);
 };
 
 class DebuggerStats {
 public:
   static void SetCollectingStats(bool enable) { g_collecting_stats = enable; }
   static bool GetCollectingStats() { return g_collecting_stats; }
 

lldb/source/Breakpoint/BreakpointResolverFileLine.cpp

if (new_mapping_from_opt) {
         new_mapping_from = ".";
         llvm::sys::path::append(new_mapping_to, new_mapping_to_opt.getValue());
       }
     }
 
     if (!new_mapping_from.empty() && !new_mapping_to.empty()) {
       LLDB_LOG(log, "generating auto source map from {0} to {1}",
                new_mapping_from, new_mapping_to);
-      target.GetSourcePathMap().AppendUnique(new_mapping_from, new_mapping_to,
-                                             /*notify*/ true);
+      if (target.GetSourcePathMap().AppendUnique(new_mapping_from,
+                                                 new_mapping_to,
+                                                 /*notify*/ true))
+        target.GetStatistics().IncreaseSourceMapDeduceCount();
     }
   }
 }
 
 Searcher::CallbackReturn BreakpointResolverFileLine::SearchCallback(
     SearchFilter &filter, SymbolContext &context, Address *addr) {
   SymbolContextList sc_list;
 

lldb/source/Target/PathMappingList.cpp

if (!rhs.m_pairs.empty()) {
     const_iterator pos, end = rhs.m_pairs.end();
     for (pos = rhs.m_pairs.begin(); pos != end; ++pos)
       m_pairs.push_back(*pos);
     if (notify && m_callback)
       m_callback(*this, m_callback_baton);
   }
 }
 
-void PathMappingList::AppendUnique(llvm::StringRef path,
+bool PathMappingList::AppendUnique(llvm::StringRef path,
                                    llvm::StringRef replacement, bool notify) {
   auto normalized_path = NormalizePath(path);
   auto normalized_replacement = NormalizePath(replacement);
   for (const auto &pair : m_pairs) {
     if (pair.first.GetStringRef().equals(normalized_path) &&
         pair.second.GetStringRef().equals(normalized_replacement))
-      return;
+      return false;
   }
   Append(path, replacement, notify);
+  return true;
 }
 
 void PathMappingList::Insert(llvm::StringRef path, llvm::StringRef replacement,
                              uint32_t index, bool notify) {
   ++m_mod_id;
   iterator insert_iter;
   if (index >= m_pairs.size())
     insert_iter = m_pairs.end();

lldb/source/Target/Statistics.cpp

if (unix_signals_sp)
       target_metrics_json.try_emplace("signals",
                                       unix_signals_sp->GetHitCountStatistics());
     uint32_t stop_id = process_sp->GetStopID();
     target_metrics_json.try_emplace("stopCount", stop_id);
   }
   target_metrics_json.try_emplace("breakpoints", std::move(breakpoints_array));
   target_metrics_json.try_emplace("totalBreakpointResolveTime",
                                   totalBreakpointResolveTime);
+  target_metrics_json.try_emplace("sourceMapDeduceCount", m_source_map_deduce_count);
 
   return target_metrics_json;
 }
 
 void TargetStats::SetLaunchOrAttachTime() {
   m_launch_or_attach_time = StatsClock::now();
   m_first_private_stop_time = llvm::None;
 }

 void TargetStats::SetFirstPublicStopTime() {
   // Launching and attaching has many paths depending on if synchronous mode
   // was used or if we are stopping at the entry point or not. Only set the
   // first stop time if it hasn't already been set.
   if (!m_first_public_stop_time)
     m_first_public_stop_time = StatsClock::now();
 }
 
+void TargetStats::IncreaseSourceMapDeduceCount() {
+  ++m_source_map_deduce_count;
+}
+
 bool DebuggerStats::g_collecting_stats = false;
 
 llvm::json::Value DebuggerStats::ReportStatistics(Debugger &debugger,
                                                   Target *target) {
   json::Array json_targets;
   json::Array json_modules;
   double symtab_parse_time = 0.0;
   double symtab_index_time = 0.0;

lldb/test/API/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py

def get_source_map_json(self):
         return json.loads(stream.GetData())
 
     def verify_source_map_entry_pair(self, entry, original, replacement):
         self.assertEquals(entry[0], original,
             "source map entry 'original' does not match")
         self.assertEquals(entry[1], replacement,
             "source map entry 'replacement' does not match")
 
+    def verify_source_map_deduce_statistics(self, target, expected_count):
+        stream = lldb.SBStream()
+        res = target.GetStatistics().GetAsJSON(stream)
+        self.assertTrue(res.Success())
+        debug_stats = json.loads(stream.GetData())
+        self.assertEqual('targets' in debug_stats, True,
+                'Make sure the "targets" key in in target.GetStatistics()')
+        target_stats = debug_stats['targets'][0]
+        self.assertNotEqual(target_stats, None)
+        self.assertEqual(target_stats['sourceMapDeduceCount'], expected_count)
+
+
     @skipIf(oslist=["windows"])
     @no_debug_info_test
     def test_breakpoints_auto_source_map_relative(self):
         """
             Test that with target.auto-source-map-relative settings.
 
             The "relative.yaml" contains a line table that is:
 
def test_breakpoints_auto_source_map_relative(self):
 
         # Create a target with the object file we just created from YAML
         target = self.dbg.CreateTarget(obj_path)
         # We now have debug information with line table paths that start are
         # "./a/b/c/main.cpp".
 
         source_map_json = self.get_source_map_json()
         self.assertEquals(len(source_map_json), 0, "source map should be empty initially")
+        self.verify_source_map_deduce_statistics(target, 0)
 
         # Verify auto deduced source map when file path in debug info
         # is a suffix of request breakpoint file path
         path = "/x/y/a/b/c/main.cpp"
         bp = target.BreakpointCreateByLocation(path, 2)
         self.assertTrue(bp.GetNumLocations() > 0,
                 'Couldn\'t resolve breakpoint using full path "%s" in executate "%s" with '
                 'debug info that has relative path with matching suffix' % (path, self.getBuildArtifact("a.out")))
 
         source_map_json = self.get_source_map_json()
         self.assertEquals(len(source_map_json), 1, "source map should not be empty")
         self.verify_source_map_entry_pair(source_map_json[0], ".", "/x/y")
+        self.verify_source_map_deduce_statistics(target, 1)
 
         # Reset source map.
         self.runCmd("settings clear target.source-map")
 
         # Verify source map will not auto deduced when file path of request breakpoint
         # equals the file path in debug info.
         path = "a/b/c/main.cpp"
         bp = target.BreakpointCreateByLocation(path, 2)
         self.assertTrue(bp.GetNumLocations() > 0,
                 'Couldn\'t resolve breakpoint using full path "%s" in executate "%s" with '
                 'debug info that has relative path with matching suffix' % (path, self.getBuildArtifact("a.out")))
 
         source_map_json = self.get_source_map_json()
         self.assertEquals(len(source_map_json), 0, "source map should not be deduced")