Add a new command "target metrics".

[clayborg]

Summary

The new target metrics command will report internal timings and information that can be used to track performance in LLDB. The information can also be used to help reproduce the debug session and exact breakpoint state if the appropriate options are used. This allows users to report performance issues or bugs where breakpoints were not resolved and LLDB engineers can use this information to track the issue.

The command emits JSON so that the structured data can be used to report timings to databases for performance tracking.

(lldb) target metrics
{

"firstStopTime": 0.33988644499999998,
"launchOrAttachTime": 0.31808012899999999,
"targetCreateTime": 31.168737819,
"totalBreakpointResolveTime": 6.6650758780000006,
"totalDebugInfoIndexTime": 0,
"totalDebugInfoParseTime": 4.2728297900000118,
"totalDebugInfoSize": 6581323413,
"totalSymbolTableIndexTime": 17.815137097000008,
"totalSymbolTableParseTime": 12.261250563000004

}

With no options we report some timings at the top level:

"launchOrAttachTime" is the time it takes from the time launch or attach is started, to when we hit our first private eStateStopped state
"firstStopTime" is the time it takes to stop at our first public stop. This time only has meaning if you run your program to a known breakpoint and want to compare timings with new versions of LLDB. This is because your program might not stop at a breakpoint right away unless a targetted breakpoint has been set for measuring.
"targetCreateTime" is the time it takes to set the main executable in the target and all dependent shared libraries. This time will include the symbol preloading if symbol preloading is enabled. This time can help is measure how long it takes to parse the symbol tables, index the symbol tables, and index the debug info along with any debug info parsing that might be required.
"totalBreakpointResolveTime" is the time it took to resolve any breakpoints that were set. If you specify the "--breakpoints" or "-b" option, you can get a breakdown of resolve time on a per breakpoint level.
"totalDebugInfoIndexTime" is the time it took to index the debug information for all current modules in the target.
"totalDebugInfoParseTime" is the time it took to parse the debug information for all current modules in the target.
"totalDebugInfoSize" is the sum of all debug information sections from all object files in the module.
"totalSymbolTableIndexTime" is the time it took to parse the symbol tables for each object file in all modules.
"totalSymbolTableParseTime" is the time it took to index the symbol tables for each object file in all modules.

Adding the "--modules" options will include a top level "modules" array that contains full details on each module, breaking down the debug info parse/index times and size, symbol table parse/index times along with enough info to identify the module (path, triple, uuid).

(lldb) target metrics --modules
...

"modules": [
  {
    "debugInfoIndexTime": 0,
    "debugInfoParseTime": 0.054413763000000004,
    "debugInfoSize": 18118626,
    "path": "/Users/gclayton/Documents/src/lldb/main/Debug/bin/lldb",
    "symbolTableIndexTime": 0.22065103899999999,
    "symbolTableParseTime": 0.138976874,
    "triple": "x86_64-apple-macosx11.0.0",
    "uuid": "F59B8D3F-67B1-35EC-A1AA-E0ABB5CB3601"
  },
  {
    "debugInfoIndexTime": 0,
    "debugInfoParseTime": 0,
    "debugInfoSize": 0,
    "path": "/usr/lib/dyld",
    "symbolTableIndexTime": 0.01367178,
    "symbolTableParseTime": 0.0093677970000000006,
    "triple": "x86_64-apple-macosx11.6.0",
    "uuid": "0CC19410-FD43-39AE-A32A-50273F8303A4"
  },
  {
    "debugInfoIndexTime": 0,
    "debugInfoParseTime": 4.2184160270000115,
    "debugInfoSize": 6563204787,
    "path": "/Users/gclayton/Documents/src/lldb/main/Debug/bin/LLDB.framework/Versions/A/LLDB",
    "symbolTableIndexTime": 17.112896844000002,
    "symbolTableParseTime": 11.240680348,
    "triple": "x86_64-apple-macosx11.0.0",
    "uuid": "CB1763B7-BB3D-38A1-AB32-237E59244745"
  },

Adding the "--breakpoints option will include details on all breakpoints including the breakpoint ID, individual resolve time, and "details" which contains the serialized breakpoint settings that were already built into each breakpoint, so we can know the exact details of how a breakpoint was set.

(lldb) target metrics --breakpoints
{

"breakpoints": [
  {
    "details": {...},
    "id": 1,
    "resolveTime": 2.2936575110000001
  }

Adding the "--locations" options will dump the details of all resolved breakpoint locations withing each breakpoint:

(lldb) target metrics --locations
{

"breakpoints": [
  {
    ...,
    "locations": [
      {
        "enabled": true,
        "fileAddress": 15783486,
        "hardward": false,
        "hitCount": 0,
        "id": 1,
        "indirect": false,
        "loadAddress": 4319532606,
        "reexported": false,
        "resolved": true,
        "symbolContext": {
          "compUnit": "/Users/gclayton/Documents/src/lldb/main/llvm-project/lldb/source/Target/Target.cpp",
          "function": "lldb_private::Target::Target(lldb_private::Debugger&, lldb_private::ArchSpec const&, std::__1::shared_ptr<lldb_private::Platform> const&, bool)",
          "module": "CB1763B7-BB3D-38A1-AB32-237E59244745",
          "sourceColumn": 1,
          "sourceFile": "/Users/gclayton/Documents/src/lldb/main/llvm-project/lldb/source/Target/Target.cpp",
          "sourceLine": 123,
          "symbol": "lldb_private::Target::Target(lldb_private::Debugger&, lldb_private::ArchSpec const&, std::__1::shared_ptr<lldb_private::Platform> const&, bool)"
        }
      },
      {
        "enabled": true,
        "fileAddress": 15787038,
        "hardward": false,
        "hitCount": 0,
        "id": 2,
        "indirect": false,
        "loadAddress": 4319536158,
        "reexported": false,
        "resolved": true,
        "symbolContext": {
          "compUnit": "/Users/gclayton/Documents/src/lldb/main/llvm-project/lldb/source/Target/Target.cpp",
          "function": "lldb_private::Target::Target(lldb_private::Debugger&, lldb_private::ArchSpec const&, std::__1::shared_ptr<lldb_private::Platform> const&, bool)",
          "module": "CB1763B7-BB3D-38A1-AB32-237E59244745",
          "sourceColumn": 1,
          "sourceFile": "/Users/gclayton/Documents/src/lldb/main/llvm-project/lldb/source/Target/Target.cpp",
          "sourceLine": 123,
          "symbol": "lldb_private::Target::Target(lldb_private::Debugger&, lldb_private::ArchSpec const&, std::__1::shared_ptr<lldb_private::Platform> const&, bool)"
        }
      }
    ],
    "resolveTime": 4.3714183670000004

[labath]

I have a feeling that there's a lot of overlap between this and the "statistics" command. As a user, I don't think I would be able to tell the difference between these two things.

Having two systems which do vaguely similar things does not seem like a good idea. Have you considered unifying them? Or maybe just deleting the old one, if its not used (I don't think it has gotten any improvements since it was initially introduced)?

[teemperor]

+Vedant who had/has some plans with the statistics command at some point IIRC.

FWIW, I wanted to throw away the current statistics implementation for quite a while but I didn't have anything to replace it with. If we can replace it with this then that would be nice.

lldb/include/lldb/Core/Module.h

941

Could the double and uint64_t here/below be a typedef to some unit? typedef double Seconds/typedef uint64_t ByteCount or something along those lines. Would make the unit we're expecting more obvious and I can easily find all the related code.

lldb/test/API/commands/target/metrics/TestTargetMetrics.py

89 ↗

(On Diff #376126)

We stopped using assertTrue unless there is really no better assert* alternative as it doesn't produce any error diagnostics on failure. There's a good overview of the replacement methods here which all print nice errors.

199 ↗

(On Diff #376126)

This and the following line can be just target = self.createTestTarget() (here and in the rest of the test).

lldb/test/API/commands/target/metrics/main.cpp

2 ↗

(On Diff #376126)

Unused function?

[labath]

lldb/include/lldb/Core/Module.h

941

*cough* *cough* std::chrono *cough* *cough*

[teemperor]

lldb/include/lldb/Core/Module.h

941

Yeah I didn't want to bring std::chrono in just yet but that would be the next logical step. FWIW, ElapsedTime::Duration already seems to be pretty much what we would want here, so we could just use that?

[JDevlieghere]

In D110804#3032741, @labath wrote:

I have a feeling that there's a lot of overlap between this and the "statistics" command. As a user, I don't think I would be able to tell the difference between these two things.

Having two systems which do vaguely similar things does not seem like a good idea. Have you considered unifying them? Or maybe just deleting the old one, if its not used (I don't think it has gotten any improvements since it was initially introduced)?

+1 on unifying the two.

In D110804#3032881, @teemperor wrote:

+Vedant who had/has some plans with the statistics command at some point IIRC.

FWIW, I wanted to throw away the current statistics implementation for quite a while but I didn't have anything to replace it with. If we can replace it with this then that would be nice.

We have (short term) plans to start using the statistics to collect more data. Vedant created some patches last year that I've rebased but haven't landed yet. I'll try to get these up on Phabricator ASAP. They're not that invasive, expect maybe the decision to move the statistics above the debugger level. That's something we need to capture things like how many lldb_asserts we've hit in a release build, as well as other metrics that span multiple debuggers (a common use case in Xcode). We're mostly interested in capturing how often something happens as opposed to how long something took (like in this patch) but I think there's room for both in the unified solution.

[clayborg]

In D110804#3032741, @labath wrote:

I have a feeling that there's a lot of overlap between this and the "statistics" command. As a user, I don't think I would be able to tell the difference between these two things.

Having two systems which do vaguely similar things does not seem like a good idea. Have you considered unifying them? Or maybe just deleting the old one, if its not used (I don't think it has gotten any improvements since it was initially introduced)?

I would be willing to take over the "statistics" command, but as it is written, it has to be enabled and disabled which I didn't like so I didn't want to have to worry about that. If we were to take over the "statistics" multiword command we would need to keep old "statistics enable" and "statistics disable" and make them no-ops and then add a JSON output. I started off this way, but it felt like a hack. And to be honest the statistics command doesn't do much. It also isn't placed correctly as I feel "target statistics" would be a better place and I would be fine renaming "metrics" to "statistics", but that would also be confusing to have two commands with the same name in different places.

[clayborg]

Changes:

• Swithed from using "double" to using ElapsedTime::Duration
• Stop using assertTrue in tests, and use better assertXXX methods

[clayborg]

lldb/include/lldb/Core/Module.h

941

I can switch to ElapsedTime::Duration

[clayborg]

I would like to get a consensus on if we should move this functionality to "statistics" or not. The reasons that I didn't do it were:

• "statistics" as a top level method doesn't really do what I wanted here, which was "target statistics", or stats that are related only to the current target. I am not all that interested in overall stats over all targets
• I didn't want to have to make a human readable and JSON output
• the "statistics enable"/"statistics disable" didn't seem to make sense as they were coded in top of tree. Maybe enabling and disabling makes more sense when more info is gathered in hidden patches that have not been upstreamed?

[JDevlieghere]

In D110804#3034878, @clayborg wrote:

I would like to get a consensus on if we should move this functionality to "statistics" or not. The reasons that I didn't do it were:

• "statistics" as a top level method doesn't really do what I wanted here, which was "target statistics", or stats that are related only to the current target. I am not all that interested in overall stats over all targets

How about we keep the statistics as a top-level entity (even above the debugger) and then have have the equivalent of metrics per debugger and per target? You can define different metrics at different levels. The commands could remain as is, where target metrics (or target statistics) dumps the metrics for the current target and the old statistics dumps the JSON for everything hierarchically.

• I didn't want to have to make a human readable and JSON output

I'm not interested in human readable output either. For our purposes JSON only is fine. If we considered removing the statistics altogether I don't think anyone will miss the current human readable output?

• the "statistics enable"/"statistics disable" didn't seem to make sense as they were coded in top of tree. Maybe enabling and disabling makes more sense when more info is gathered in hidden patches that have not been upstreamed?

I see two potential use cases for enabling/disabling statistics:

• The most obvious one being a way to work around a bug or performance overhead caused by collecting the statistics.
• The data that's being collected could serve as the basis for something like anonymous analytics. Enabling/disabling the statistics could be a way to opt-in or out from this data being automatically collected and shared.

[jingham]

In D110804#3034878, @clayborg wrote:

I would like to get a consensus on if we should move this functionality to "statistics" or not. The reasons that I didn't do it were:

• "statistics" as a top level method doesn't really do what I wanted here, which was "target statistics", or stats that are related only to the current target. I am not all that interested in overall stats over all targets

It seems confusing to have two ways to gather internal statistics (well three really because we also still have "log timers"). So it does seem good to gather at least the two obviously similar ones in one place.

We have loads of commands that operate on the "currently selected target" even though they aren't in the target hierarchy. So having the target specific parts of the statistics gathering do that as well is in line with many other commands. I don't think that's a problem. It might even be nice to have a --target-id so that if I wanted statistics on several of the targets I have loaded, I could do it with one command rather than having to issue the command over and over.

On a side note, I'm not sure it's really correct to limit the statistics to only one target, at least for any symbol or debug info parsing information. Since all the parsing goes on in the modules in the global shared cache, if you did have two targets running in one lldb session, then parsing module A will formally have to have been done on behalf of both targets, but will be triggered by only one or the other target. If the target that triggered parsing of A is not the current target, will the time to parse that get dropped? The work had to be done, and was only accounted to the other target by a timing accident.

• I didn't want to have to make a human readable and JSON output

We have a pretty printer for StructuredData objects which are trivial to make from JSON, so a human-readable version should be easy to knock together. That will do for the first pass, and since we seem to be leaning to JSON as a format for various data gathering, if we want to make the output better we could improve the pretty printer, and add header names to our JSON, etc. But we can do that incrementally

• the "statistics enable"/"statistics disable" didn't seem to make sense as they were coded in top of tree. Maybe enabling and disabling makes more sense when more info is gathered in hidden patches that have not been upstreamed?

If we are confident that gathering statistics really does have and always will have negligible performance impact, then we can drop the "enable" and "disable". I don't know that we can promise we'll never want to gather something that's a bit costly. And there are folks who run lldb in environments where they would rather we not spend time & memory on anything we don't absolutely have to.

So unless it's somehow prohibitively hard to disable gathering statistics, my feeling is we should offer that option.

[clayborg]

Ok, so how does this sound:

• This new command will replace the existing "statistics dump" command and emit JSON only by default
• The "statistics enable/disable" will stay in place and allow expensive metric gathering to be enabled/disabled if needed. If the gathering is really cheap for certain metrics, then nothing needs to happen for "statistics enable/disable"
• By default we will emit stats for the current target, and options can be added in the future to enable dumping for all targets and for debugger level stuff

Let me know if this sounds ok to everyone!?

[jingham]

In D110804#3035052, @clayborg wrote:

Ok, so how does this sound:

• This new command will replace the existing "statistics dump" command and emit JSON only by default
• The "statistics enable/disable" will stay in place and allow expensive metric gathering to be enabled/disabled if needed. If the gathering is really cheap for certain metrics, then nothing needs to happen for "statistics enable/disable"
• By default we will emit stats for the current target, and options can be added in the future to enable dumping for all targets and for debugger level stuff

Let me know if this sounds ok to everyone!?

This sounds fine to me.

I would mildly argue for adding the --target-id to start with. That should be super-cheap to implement since you just have to look up the target in the debugger. The reason I think it's a little important is that it is the way that you tell that the statistics you are dumping are debugger-wide or target specific. If --breakpoints supports the --target-id, then I know right away it's a target specific statistic, etc... So having this in place from the start will help somebody else who comes along to add some debugger-wide stats.

But I am not insisting on this.

[JDevlieghere]

In D110804#3033689, @JDevlieghere wrote:

We have (short term) plans to start using the statistics to collect more data. Vedant created some patches last year that I've rebased but haven't landed yet. I'll try to get these up on Phabricator ASAP.

D110893 & D110895

[clayborg]

Changes:

• Removed "target metrics" and took over "statistics dump"
• Hooked old statistics into for expression evaluation and frame variable success and fails into this patch
• No more textual output for "statistics dump", it is now JSON.
• "statistics enable" and "statistics disable" are still valid commands, but they don't enable or disable anything since all stats currently gathered are very cheap to gather:

[clayborg]

In D110804#3035276, @JDevlieghere wrote:

In D110804#3033689, @JDevlieghere wrote:

We have (short term) plans to start using the statistics to collect more data. Vedant created some patches last year that I've rebased but haven't landed yet. I'll try to get these up on Phabricator ASAP.

D110893 & D110895

See what I did in this patch. I think all of the functionality and splitting the stats out into a separate class are taken care of by this patch. Let me know if it works.

[JDevlieghere]

Thanks Greg! Following Pavel's suggestion in D110893, could you split up this patch into smaller ones? I think that will make it a lot easier to review and discuss.

[clayborg]

In D110804#3037504, @JDevlieghere wrote:

Thanks Greg! Following Pavel's suggestion in D110893, could you split up this patch into smaller ones? I think that will make it a lot easier to review and discuss.

Will do

[clayborg]

I have broken out the target only settings to make this patch smaller into: https://reviews.llvm.org/D111686

[wallace]

is this going to be abandoned?

[clayborg]

This was submitted as a series of patches that updated "statistics dump" to emit JSON:

https://reviews.llvm.org/D111686
https://reviews.llvm.org/D112279
https://reviews.llvm.org/D112501
https://reviews.llvm.org/D112683
https://reviews.llvm.org/D112587

lldb/include/lldb/Breakpoint/Breakpoint.h

 #include "lldb/Breakpoint/BreakpointID.h"
 #include "lldb/Breakpoint/BreakpointLocationCollection.h"
 #include "lldb/Breakpoint/BreakpointLocationList.h"
 #include "lldb/Breakpoint/BreakpointName.h"
 #include "lldb/Breakpoint/BreakpointOptions.h"
 #include "lldb/Breakpoint/Stoppoint.h"
 #include "lldb/Breakpoint/StoppointHitCounter.h"
 #include "lldb/Core/SearchFilter.h"
+#include "lldb/Utility/ElapsedTime.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/StringList.h"
 #include "lldb/Utility/StructuredData.h"
 
 namespace lldb_private {
 
 /// \class Breakpoint Breakpoint.h "lldb/Breakpoint/Breakpoint.h" Class that
 /// manages logical breakpoint setting.
bool AllowDelete() const {
     return GetPermissions().GetAllowDelete();
   }
 
   // This one should only be used by Target to copy breakpoints from target to
   // target - primarily from the dummy target to prime new targets.
   static lldb::BreakpointSP CopyFromBreakpoint(lldb::TargetSP new_target,
       const Breakpoint &bp_to_copy_from);
 
+  /// Get statistics associated with this breakpoint in JSON format.
+  llvm::json::Value GetStatistics(const StatsDumpOptions &options);
+
+  /// Get the time it took to resolve all locations in this breakpoint.
+  ElapsedTime::Duration GetResolveTime() const { return m_resolve_time; }
+
 protected:
   friend class Target;
   // Protected Methods
 
   /// Constructors and Destructors
   /// Only the Target can make a breakpoint, and it owns the breakpoint
   /// lifespans. The constructor takes a filter and a resolver.  Up in Target
   /// there are convenience variants that make breakpoints for some common
private:
 
   /// Number of times this breakpoint has been hit. This is kept separately
   /// from the locations hit counts, since locations can go away when their
   /// backing library gets unloaded, and we would lose hit counts.
   StoppointHitCounter m_hit_counter;
 
   BreakpointName::Permissions m_permissions;
 
+  ElapsedTime::Duration m_resolve_time{0.0};
+
   void SendBreakpointChangedEvent(lldb::BreakpointEventType eventKind);
 
   void SendBreakpointChangedEvent(BreakpointEventData *data);
 
   Breakpoint(const Breakpoint &) = delete;
   const Breakpoint &operator=(const Breakpoint &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_BREAKPOINT_BREAKPOINT_H

lldb/include/lldb/Breakpoint/BreakpointLocation.h

 #include <mutex>
 
 #include "lldb/Breakpoint/BreakpointOptions.h"
 #include "lldb/Breakpoint/StoppointHitCounter.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Utility/UserID.h"
 #include "lldb/lldb-private.h"
 
+#include "llvm/Support/JSON.h"
+
 namespace lldb_private {
 
 /// \class BreakpointLocation BreakpointLocation.h
 /// "lldb/Breakpoint/BreakpointLocation.h" Class that manages one unique (by
 /// address) instance of a logical breakpoint.
 
 /// General Outline:
 /// A breakpoint location is defined by the breakpoint that produces it,
public:
   ///
   /// \param[in] context
   ///    Described the breakpoint event.
   ///
   /// \return
   ///     \b true if the target should stop at this breakpoint and \b
   ///     false not.
   bool InvokeCallback(StoppointCallbackContext *context);
-  
   /// Report whether the callback for this location is synchronous or not.
   ///
   /// \return
   ///     \b true if the callback is synchronous and \b false if not.
   bool IsCallbackSynchronous();
 
   /// Returns whether we should resolve Indirect functions in setting the
   /// breakpoint site for this location.
public:
   ///
   /// \return
   ///     \b true or \b false as given in the description above.
   bool EquivalentToLocation(BreakpointLocation &location);
 
   /// Returns the breakpoint location ID.
   lldb::break_id_t GetID() const { return m_loc_id; }
 
+  /// Returns the breakpoint location metrics as JSON.
+  llvm::json::Value GetMetrics(const StatsDumpOptions &options);
+
 protected:
   friend class BreakpointSite;
   friend class BreakpointLocationList;
   friend class Process;
   friend class StopInfoBreakpoint;
 
   /// Set the breakpoint site for this location to \a bp_site_sp.
   ///

lldb/include/lldb/Core/FileSpecList.h

 //===-- FileSpecList.h ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_CORE_FILESPECLIST_H
 #define LLDB_CORE_FILESPECLIST_H
 #if defined(__cplusplus)
 
 #include "lldb/Utility/FileSpec.h"
-
+#include "llvm/Support/JSON.h"
 #include <vector>
 
 #include <cstddef>
 
 namespace lldb_private {
 class Stream;
 
 /// \class FileSpecList FileSpecList.h "lldb/Core/FileSpecList.h"
public:
   }
 
   static size_t GetFilesMatchingPartialPath(const char *path, bool dir_okay,
                                             FileSpecList &matches);
 
   const_iterator begin() const { return m_files.begin(); }
   const_iterator end() const { return m_files.end(); }
 
+  llvm::json::Value ToJSON() const;
+
 protected:
   collection m_files; ///< A collection of FileSpec objects.
 };
 
 } // namespace lldb_private
 
 #endif // #if defined(__cplusplus)
 #endif // LLDB_CORE_FILESPECLIST_H

lldb/include/lldb/Core/Module.h

 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContextScope.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/PathMappingList.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/ElapsedTime.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Status.h"
-#include "lldb/Utility/XcodeSDK.h"
 #include "lldb/Utility/UUID.h"
+#include "lldb/Utility/XcodeSDK.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-types.h"
 
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Chrono.h"
protected:
     /// names we are looking for
     lldb::FunctionNameType m_name_type_mask = lldb::eFunctionNameTypeNone;
 
     ///< If \b true, then demangled names that match will need to contain
     ///< "m_name" in order to be considered a match
     bool m_match_name_after_lookup = false;
   };
 
+  /// Get the symbol table parse time metric.
+  ///
+  /// The value is returned as a reference to allow it to be updated by the
+  /// ElapsedTime
+  ElapsedTime::Duration &GetSymtabParseTime() { return m_symtab_parse_time; }
+  ElapsedTime::Duration &GetSymtabNamesTime() { return m_symtab_names_time; }
+
+  uint64_t GetDebugInfoSize();
+
 protected:
   // Member Variables
   mutable std::recursive_mutex m_mutex; ///< A mutex to keep this object happy
                                         ///in multi-threaded environments.
 
   /// The modification time for this module when it was created.
   llvm::sys::TimePoint<> m_mod_time;
 
protected:
   FileSpec m_symfile_spec;   ///< If this path is valid, then this is the file
                              ///that _will_ be used as the symbol file for this
                              ///module
   ConstString m_object_name; ///< The name an object within this module that is
                              ///selected, or empty of the module is represented
                              ///by \a m_file.
   uint64_t m_object_offset = 0;
   llvm::sys::TimePoint<> m_object_mod_time;
+  /// We store a symbol table parse time duration here because we might have
+  /// an object file and a symbol file which both have symbol tables. The parse
+  /// time for the symbol tables can be aggregated here.
+  ElapsedTime::Duration m_symtab_parse_time{0.0};
+  /// We store a symbol named index time duration here because we might have
+  /// an object file and a symbol file which both have symbol tables. The parse
+  /// time for the symbol tables can be aggregated here.
+  ElapsedTime::Duration m_symtab_names_time{0.0};
 
   /// DataBuffer containing the module image, if it was provided at
   /// construction time. Otherwise the data will be retrieved by mapping
   /// one of the FileSpec members above.
   lldb::DataBufferSP m_data_sp;
 
   lldb::ObjectFileSP m_objfile_sp; ///< A shared pointer to the object file
                                    ///parser for this module as it may or may

lldb/include/lldb/Core/Section.h

public:
   bool DeleteSection(size_t idx);
 
   lldb::SectionSP GetSectionAtIndex(size_t idx) const;
 
   size_t Slide(lldb::addr_t slide_amount, bool slide_children);
 
   void Clear() { m_sections.clear(); }
 
+  /// Get the debug information size from all sections that contain debug
+  /// information. Symbol tables are not considered part of the debug
+  /// information for this call, just known sections that contain debug
+  /// information.
+  uint64_t GetDebugInfoSize() const;
+
 protected:
   collection m_sections;
 };
 
 class Section : public std::enable_shared_from_this<Section>,
                 public ModuleChild,
                 public UserID,
                 public Flags {
public:
   const char *GetTypeAsCString() const;
 
   lldb::SectionSP GetParent() const { return m_parent_wp.lock(); }
 
   bool IsThreadSpecific() const { return m_thread_specific; }
 
   void SetIsThreadSpecific(bool b) { m_thread_specific = b; }
 
+  /// Returns true if this section contains debug information. Symbol tables
+  /// are not considered debug information since some symbols might contain
+  /// debug information (STABS, COFF) but not all symbols do, so to keep this
+  /// fast and simple only sections that contains only debug information should
+  /// return true.
+  bool ContainsOnlyDebugInfo() const;
+
   /// Get the permissions as OR'ed bits from lldb::Permissions
   uint32_t GetPermissions() const;
 
   /// Set the permissions using bits OR'ed from lldb::Permissions
   void SetPermissions(uint32_t permissions);
 
   ObjectFile *GetObjectFile() { return m_obj_file; }
   const ObjectFile *GetObjectFile() const { return m_obj_file; }

lldb/include/lldb/Symbol/SymbolContext.h

 #include <string>
 #include <vector>
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Mangled.h"
 #include "lldb/Symbol/LineEntry.h"
 #include "lldb/Utility/Iterable.h"
 #include "lldb/lldb-private.h"
+#include "llvm/Support/JSON.h"
 
 namespace lldb_private {
 
 class SymbolContextScope;
 
 /// \class SymbolContext SymbolContext.h "lldb/Symbol/SymbolContext.h" Defines
 /// a symbol context baton that can be handed other debug core functions.
 ///
public:
   /// \return
   ///     \b true if this SymbolContext specifies a block contained in an
   ///     inlined block.  If this returns \b true, \a next_frame_sc and
   ///     \a inlined_frame_addr will be filled in correctly.
   bool GetParentOfInlinedScope(const Address &curr_frame_pc,
                                SymbolContext &next_frame_sc,
                                Address &inlined_frame_addr) const;
 
+  llvm::json::Value ToJSON() const;
+
   // Member variables
   lldb::TargetSP target_sp; ///< The Target for a given query
   lldb::ModuleSP module_sp; ///< The Module for a given query
   CompileUnit *comp_unit = nullptr; ///< The CompileUnit for a given query
   Function *function = nullptr;     ///< The Function for a given query
   Block *block = nullptr;           ///< The Block for a given query
   LineEntry line_entry;     ///< The LineEntry for a given query
   Symbol *symbol = nullptr; ///< The Symbol for a given query

lldb/include/lldb/Symbol/SymbolFile.h

 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/SourceModule.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/TypeSystem.h"
+#include "lldb/Utility/ElapsedTime.h"
 #include "lldb/Utility/XcodeSDK.h"
 #include "lldb/lldb-private.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/Support/Errc.h"
 
 #include <mutex>
 
 #if defined(LLDB_CONFIGURATION_DEBUG)
public:
   /// function.
   virtual llvm::Expected<lldb::addr_t> GetParameterStackSize(Symbol &symbol) {
     return llvm::createStringError(make_error_code(llvm::errc::not_supported),
                                    "Operation not supported.");
   }
 
   virtual void Dump(Stream &s);
 
+  /// Metrics gathering functions
+
+  /// Return the size in bytes of all debug information in the symbol file.
+  ///
+  /// If the debug information is contained in sections of an ObjectFile, then
+  /// this call should add the size of all sections that contain debug
+  /// information. Symbols the symbol tables are not considered debug
+  /// information for this call to make it easy and quick for this number to be
+  /// calculated. If the symbol file is all debug information, the size of the
+  /// entire file should be returned.
+  virtual uint64_t GetDebugInfoSize() = 0;
+
+  /// Return the time taken to parse the debug information.
+  ///
+  /// \returns llvm::None if no information has been parsed or if there is
+  /// no computational cost to parsing the debug information.
+  virtual ElapsedTime::Duration GetDebugInfoParseTime() {
+    return ElapsedTime::Duration(0.0);
+  }
+
+  /// Return the time it took to index the debug information in the object
+  /// file.
+  ///
+  /// \returns llvm::None if the file doesn't need to be indexed or if it
+  /// hasn't been indexed yet, or a valid duration if it has.
+  virtual ElapsedTime::Duration GetDebugInfoIndexTime() {
+    return ElapsedTime::Duration(0.0);
+  }
+
 protected:
   void AssertModuleLock();
   virtual uint32_t CalculateNumCompileUnits() = 0;
   virtual lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t idx) = 0;
   virtual TypeList &GetTypeList() { return m_type_list; }
 
   void SetCompileUnitAtIndex(uint32_t idx, const lldb::CompUnitSP &cu_sp);
 

lldb/include/lldb/Target/PathMappingList.h

 //===-- PathMappingList.h ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_TARGET_PATHMAPPINGLIST_H
 #define LLDB_TARGET_PATHMAPPINGLIST_H
 
-#include <map>
-#include <vector>
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Status.h"
+#include "llvm/Support/JSON.h"
+#include <map>
+#include <vector>
 
 namespace lldb_private {
 
 class PathMappingList {
 public:
   typedef void (*ChangedCallback)(const PathMappingList &path_list,
                                   void *baton);
 
public:
   /// \return
   ///     The newly remapped filespec that is guaranteed to exist.
   llvm::Optional<FileSpec> FindFile(const FileSpec &orig_spec) const;
 
   uint32_t FindIndexForPath(ConstString path) const;
 
   uint32_t GetModificationID() const { return m_mod_id; }
 
+  /// Return the path mappings as a JSON array.
+  ///
+  /// The array contains arrays of path mapping paths as strings.
+  llvm::json::Value ToJSON() const;
+
 protected:
   typedef std::pair<ConstString, ConstString> pair;
   typedef std::vector<pair> collection;
   typedef collection::iterator iterator;
   typedef collection::const_iterator const_iterator;
 
   iterator FindIteratorForPath(ConstString path);
 

lldb/include/lldb/Target/Process.h

if (this != &rhs) {
       m_stop_id = rhs.m_stop_id;
       m_memory_id = rhs.m_memory_id;
     }
     return *this;
   }
 
   ~ProcessModID() = default;
 
-  void BumpStopID() {
-    m_stop_id++;
+  uint32_t BumpStopID() {
+    const uint32_t prev_stop_id = m_stop_id++;
     if (!IsLastResumeForUserExpression())
       m_last_natural_stop_id++;
+    return prev_stop_id;
   }
 
   void BumpMemoryID() { m_memory_id++; }
 
   void BumpResumeID() {
     m_resume_id++;
     if (m_running_user_expression > 0)
       m_last_user_expression_resume = m_resume_id;

lldb/include/lldb/Target/Statistics.h

+//===-- Statistics.h --------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_TARGET_STATISTICS_H
+#define LLDB_TARGET_STATISTICS_H
+
+#include <chrono>
+#include <vector>
+
+#include "lldb/Utility/ElapsedTime.h"
+#include "lldb/Utility/Stream.h"
+#include "lldb/lldb-forward.h"
+#include "llvm/Support/JSON.h"
+
+namespace lldb_private {
+
+struct SuccessFailStats {
+  void Notify(bool success);
+
+  llvm::json::Value ToJSON() const;
+
+  uint32_t successes = 0;
+  uint32_t failures = 0;
+};
+
+struct StatsDumpOptions {
+  bool dump_modules = false;
+  bool dump_breakpoints = false;
+  bool dump_breakpoint_locations = false;
+  bool dump_settings = false;
+
+  /// Set all dump options to true.
+  void SetAll() {
+    dump_modules = true;
+    dump_breakpoints = true;
+    dump_breakpoint_locations = true;
+    dump_settings = true;
+  }
+};
+
+struct ModuleStats {
+  llvm::json::Value ToJSON() const;
+
+  std::string path;
+  std::string uuid;
+  std::string triple;
+  uint64_t debug_info_size = 0;
+  double debug_parse_time = 0.0;
+  double debug_index_time = 0.0;
+  double symtab_parse_time = 0.0;
+  double symtab_names_time = 0.0;
+};
+
+class TargetStats {
+public:
+  llvm::json::Value ToJSON(Target &target, const StatsDumpOptions &options);
+
+  void CollectModuleStats(Target &target);
+
+  void SetLaunchOrAttachTime();
+
+  void SetFirstPrivateStopTime();
+
+  void SetFirstPublicStopTime();
+
+  ElapsedTime::Duration &GetCreateTime() { return create_time; }
+
+  void NotifyExprEval(bool success) { return m_expr_eval.Notify(success); }
+  void NotifyFrameVar(bool success) { return m_frame_var.Notify(success); }
+  void SetCollectingStats(bool v) { m_collecting_stats = v; }
+  bool GetCollectingStats() { return m_collecting_stats; }
+
+protected:
+  // Collecting stats can be set to true to collect stats that are expensive
+  // to collect. By default all stats that are cheap to collect are enabled.
+  // This settings is here to maintain compatibility with "statistics enable"
+  // and "statistics disable".
+  bool m_collecting_stats = false;
+  std::vector<ModuleStats> m_modules;
+  ElapsedTime::Duration create_time{0.0};
+  llvm::Optional<std::chrono::steady_clock::time_point> launch_or_attach_time;
+  llvm::Optional<std::chrono::steady_clock::time_point> first_private_stop_time;
+  llvm::Optional<std::chrono::steady_clock::time_point> first_public_stop_time;
+  SuccessFailStats m_expr_eval;
+  SuccessFailStats m_frame_var;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_TARGET_STATISTICS_H

lldb/include/lldb/Target/Target.h

 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Expression/Expression.h"
 #include "lldb/Host/ProcessLaunchInfo.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/ExecutionContextScope.h"
 #include "lldb/Target/PathMappingList.h"
 #include "lldb/Target/SectionLoadHistory.h"
+#include "lldb/Target/Statistics.h"
 #include "lldb/Target/ThreadSpec.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Timeout.h"
 #include "lldb/lldb-public.h"
 
 namespace lldb_private {
protected:
   /// Stores the frame recognizers of this target.
   lldb::StackFrameRecognizerManagerUP m_frame_recognizer_manager_up;
 
   static void ImageSearchPathsChanged(const PathMappingList &path_list,
                                       void *baton);
 
   // Utilities for `statistics` command.
 private:
-  std::vector<uint32_t> m_stats_storage;
-  bool m_collecting_stats = false;
+  // Target metrics storage.
+  TargetStats m_stats;
 
 public:
-  void SetCollectingStats(bool v) { m_collecting_stats = v; }
-
-  bool GetCollectingStats() { return m_collecting_stats; }
-
-  void IncrementStats(lldb_private::StatisticKind key) {
-    if (!GetCollectingStats())
-      return;
-    lldbassert(key < lldb_private::StatisticKind::StatisticMax &&
-               "invalid statistics!");
-    m_stats_storage[key] += 1;
-  }
+  /// Get metrics associated with this target in JSON format.
+  ///
+  /// Target metrics help measure timings and information that is contained in
+  /// a target. These are designed to help measure performance of a debug
+  /// session as well as represent the current state of the target, like
+  /// information on the currently modules, currently set breakpoints and more.
+  ///
+  /// \param [in] modules
+  ///     If true, include an array of metrics for each module loaded in the
+  ///     target.
+  //
+  /// \return
+  ///     Returns a JSON value that contains all target metrics.
+  llvm::json::Value ReportStatistics(const StatsDumpOptions &options);
 
-  std::vector<uint32_t> GetStatistics() { return m_stats_storage; }
+  TargetStats &GetStatistics() { return m_stats; }
 
 private:
   /// Construct with optional file and arch.
   ///
   /// This member is private. Clients must use
   /// TargetList::CreateTarget(const FileSpec*, const ArchSpec*)
   /// so all targets can be tracked from the central target list.
   ///

lldb/include/lldb/Utility/ElapsedTime.h

+//===-- ElapsedTime.h -------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_UTILITY_ELAPSEDTIME_H
+#define LLDB_UTILITY_ELAPSEDTIME_H
+
+#include <chrono>
+namespace lldb_private {
+
+/// A class that measures elapsed time.
+///
+/// This class is designed to help gather timing metrics within LLDB where
+/// objects have optional Duration variables that get updated with elapsed
+/// times. This helps LLDB measure metrics for many things that are then
+/// reported in LLDB commands.
+///
+/// Objects that need to measure elapsed times should have a variable with of
+/// type "ElapsedTime::Duration m_time_xxx;" which can then be used in the
+/// constructor of this class inside a scope that wants to measure something:
+///
+///   ElapsedTime elapsed(m_time_xxx);
+///   // Do some work
+///
+/// This class will update the m_time_xxx variable with the elapsed time when
+/// the object goes out of scope. The "m_time_xxx" variable will be incremented
+/// when the class goes out of scope. This allows a variable to measure
+/// something that might happen in stages at different times, like resolving a
+/// breakpoint each time a new shared library is loaded.
+class ElapsedTime {
+public:
+  using Clock = std::chrono::high_resolution_clock;
+  using Duration = std::chrono::duration<double>;
+  using Timepoint = std::chrono::time_point<Clock>;
+  /// Set to the start time when the object is created.
+  Timepoint m_start_time;
+  /// The elapsed time in seconds to update when this object goes out of scope.
+  ElapsedTime::Duration &m_elapsed_time;
+
+public:
+  ElapsedTime(ElapsedTime::Duration &opt_time) : m_elapsed_time(opt_time) {
+    m_start_time = Clock::now();
+  }
+  ~ElapsedTime() {
+    Duration elapsed = Clock::now() - m_start_time;
+    m_elapsed_time += elapsed;
+  }
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_UTILITY_ELAPSEDTIME_H

lldb/include/lldb/lldb-forward.h

 class LineTable;
 class Listener;
 class Log;
 class Mangled;
 class Materializer;
 class MemoryHistory;
 class MemoryRegionInfo;
 class MemoryRegionInfos;
+struct StatsDumpOptions;
 class Module;
 class ModuleList;
 class ModuleSpec;
 class ModuleSpecList;
 class ObjectContainer;
 class ObjectFile;
 class ObjectFileJITDelegate;
 class OperatingSystem;

lldb/packages/Python/lldbsuite/test/lldbtest.py

def makeBuildDir(self):
         if os.path.isdir(bdir):
             shutil.rmtree(bdir)
         lldbutil.mkdir_p(bdir)
 
     def getBuildArtifact(self, name="a.out"):
         """Return absolute path to an artifact in the test's build directory."""
         return os.path.join(self.getBuildDir(), name)
 
+    def getShlibBuildArtifact(self, DYLIB_NAME):
+        """Return absolute path to a shared library artifact given the library
+           name as it is known from the Makefile in DYLIB_NAME.
+
+           Each platform has different prefixes and extensions for shared
+           librairies when they get built by the Makefile. This function
+           allows tests to specify the DYLIB_NAME from the Makefile and it
+           will return the correct path for the built shared library in the
+           build artifacts directory
+        """
+        ctx = self.platformContext
+        dylibName = ctx.shlib_prefix + DYLIB_NAME + '.' + ctx.shlib_extension
+        return self.getBuildArtifact(dylibName)
+
     def getSourcePath(self, name):
         """Return absolute path to a file in the test's source directory."""
         return os.path.join(self.getSourceDir(), name)
 
     def getReproducerArtifact(self, name):
         lldbutil.mkdir_p(self.getReproducerDir())
         return os.path.join(self.getReproducerDir(), name)
 

lldb/source/API/SBTarget.cpp

 
 SBStructuredData SBTarget::GetStatistics() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBTarget, GetStatistics);
 
   SBStructuredData data;
   TargetSP target_sp(GetSP());
   if (!target_sp)
     return LLDB_RECORD_RESULT(data);
-
-  auto stats_up = std::make_unique<StructuredData::Dictionary>();
-  int i = 0;
-  for (auto &Entry : target_sp->GetStatistics()) {
-    std::string Desc = lldb_private::GetStatDescription(
-        static_cast<lldb_private::StatisticKind>(i));
-    stats_up->AddIntegerItem(Desc, Entry);
-    i += 1;
-  }
-
-  data.m_impl_up->SetObjectSP(std::move(stats_up));
+  std::string json_text;
+  llvm::raw_string_ostream stream(json_text);
+  llvm::json::Value json = target_sp->ReportStatistics(StatsDumpOptions());
+  stream << json;
+  data.m_impl_up->SetObjectSP(StructuredData::ParseJSON(stream.str()));
   return LLDB_RECORD_RESULT(data);
 }
 
 void SBTarget::SetCollectingStats(bool v) {
   LLDB_RECORD_METHOD(void, SBTarget, SetCollectingStats, (bool), v);
 
   TargetSP target_sp(GetSP());
   if (!target_sp)
     return;
-  return target_sp->SetCollectingStats(v);
+  return target_sp->GetStatistics().SetCollectingStats(v);
 }
 
 bool SBTarget::GetCollectingStats() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, GetCollectingStats);
 
   TargetSP target_sp(GetSP());
   if (!target_sp)
     return false;
-  return target_sp->GetCollectingStats();
+  return target_sp->GetStatistics().GetCollectingStats();
 }
 
 SBProcess SBTarget::LoadCore(const char *core_file) {
   LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *),
                      core_file);
 
   lldb::SBError error; // Ignored
   return LLDB_RECORD_RESULT(LoadCore(core_file, error));

lldb/source/Breakpoint/Breakpoint.cpp

 #include "lldb/Breakpoint/BreakpointPrecondition.h"
 #include "lldb/Breakpoint/BreakpointResolver.h"
 #include "lldb/Breakpoint/BreakpointResolverFileLine.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/SearchFilter.h"
 #include "lldb/Core/Section.h"
-#include "lldb/Target/SectionLoadList.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
+#include "lldb/Utility/Timer.h"
 
 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace llvm;
 
 ConstString Breakpoint::GetEventIdentifier() {
BreakpointSP Breakpoint::CopyFromBreakpoint(TargetSP new_target,
 
   BreakpointSP bp(new Breakpoint(*new_target, bp_to_copy_from));
   // Now go through and copy the filter & resolver:
   bp->m_resolver_sp = bp_to_copy_from.m_resolver_sp->CopyForBreakpoint(bp);
   bp->m_filter_sp = bp_to_copy_from.m_filter_sp->CreateCopy(new_target);
   return bp;
 }
 
+json::Value Breakpoint::GetStatistics(const StatsDumpOptions &options) {
+  json::Object bp;
+  bp.try_emplace("id", GetID());
+  if (!m_name_list.empty()) {
+    json::Array names;
+    for (const auto &name : m_name_list)
+      names.emplace_back(name);
+    bp.try_emplace("names", std::move(names));
+  }
+  if (options.dump_breakpoint_locations) {
+    json::Array locations;
+    const size_t num_locs = m_locations.GetSize();
+    for (size_t i = 0; i < num_locs; ++i) {
+      BreakpointLocationSP loc_sp = GetLocationAtIndex(i);
+      if (!loc_sp)
+        continue;
+      locations.emplace_back(loc_sp->GetMetrics(options));
+    }
+    bp.try_emplace("locations", std::move(locations));
+  }
+
+  if (m_resolve_time.count() > 0.0)
+    bp.try_emplace("resolveTime", m_resolve_time.count());
+  StructuredData::ObjectSP bp_data_sp = SerializeToStructuredData();
+  if (bp_data_sp) {
+    std::string buffer;
+    llvm::raw_string_ostream ss(buffer);
+    json::OStream json_os(ss);
+    bp_data_sp->Serialize(json_os);
+    if (llvm::Expected<llvm::json::Value> expected_value =
+            llvm::json::parse(ss.str()))
+      bp.try_emplace("details", std::move(*expected_value));
+    else
+      llvm::consumeError(expected_value.takeError());
+  }
+  return json::Value(std::move(bp));
+}
+
 // Serialization
 StructuredData::ObjectSP Breakpoint::SerializeToStructuredData() {
   // Serialize the resolver:
   StructuredData::DictionarySP breakpoint_dict_sp(
       new StructuredData::Dictionary());
   StructuredData::DictionarySP breakpoint_contents_sp(
       new StructuredData::Dictionary());
 
bool Breakpoint::InvokeCallback(StoppointCallbackContext *context,
   return m_options.InvokeCallback(context, GetID(), bp_loc_id);
 }
 
 BreakpointOptions &Breakpoint::GetOptions() { return m_options; }
 
 const BreakpointOptions &Breakpoint::GetOptions() const { return m_options; }
 
 void Breakpoint::ResolveBreakpoint() {
-  if (m_resolver_sp)
+  if (m_resolver_sp) {
+    ElapsedTime elapsed(m_resolve_time);
     m_resolver_sp->ResolveBreakpoint(*m_filter_sp);
   }
+}
 
 void Breakpoint::ResolveBreakpointInModules(
     ModuleList &module_list, BreakpointLocationCollection &new_locations) {
+  ElapsedTime elapsed(m_resolve_time);
   m_locations.StartRecordingNewLocations(new_locations);
-
   m_resolver_sp->ResolveBreakpointInModules(*m_filter_sp, module_list);
-
   m_locations.StopRecordingNewLocations();
 }
 
 void Breakpoint::ResolveBreakpointInModules(ModuleList &module_list,
                                             bool send_event) {
   if (m_resolver_sp) {
+    ElapsedTime elapsed(m_resolve_time);
     // If this is not an internal breakpoint, set up to record the new
     // locations, then dispatch an event with the new locations.
     if (!IsInternal() && send_event) {
       BreakpointEventData *new_locations_event = new BreakpointEventData(
           eBreakpointEventTypeLocationsAdded, shared_from_this());
 
       ResolveBreakpointInModules(
           module_list, new_locations_event->GetBreakpointLocationCollection());
for (ModuleSP module_sp : module_list.Modules()) {
         // If the section for this location was deleted, that means it's Module
         // has gone away but somebody forgot to tell us. Let's clean it up
         // here.
         Address section_addr(break_loc_sp->GetAddress());
         if (section_addr.SectionWasDeleted()) {
           locations_with_no_section.Add(break_loc_sp);
           continue;
         }
-          
         if (!break_loc_sp->IsEnabled())
           continue;
-        
         SectionSP section_sp(section_addr.GetSection());
-        
         // If we don't have a Section, that means this location is a raw
         // address that we haven't resolved to a section yet.  So we'll have to
         // look in all the new modules to resolve this location. Otherwise, if
         // it was set in this module, re-resolve it here.
         if (section_sp && section_sp->GetModule() == module_sp) {
           if (!seen)
             seen = true;
 
           if (!break_loc_sp->ResolveBreakpointSite()) {
             LLDB_LOGF(log,
                       "Warning: could not set breakpoint site for "
                       "breakpoint location %d of breakpoint %d.\n",
                       break_loc_sp->GetID(), GetID());
           }
         }
       }
-      
       size_t num_to_delete = locations_with_no_section.GetSize();
-      
       for (size_t i = 0; i < num_to_delete; i++)
         m_locations.RemoveLocation(locations_with_no_section.GetByIndex(i));
 
       if (!seen)
         new_modules.AppendIfNeeded(module_sp);
     }
 
     if (new_modules.GetSize() > 0) {

lldb/source/Breakpoint/BreakpointLocation.cpp

 void BreakpointLocation::SwapLocation(BreakpointLocationSP swap_from) {
   m_address = swap_from->m_address;
   m_should_resolve_indirect_functions =
       swap_from->m_should_resolve_indirect_functions;
   m_is_reexported = swap_from->m_is_reexported;
   m_is_indirect = swap_from->m_is_indirect;
   m_user_expression_sp.reset();
 }
+
+llvm::json::Value
+BreakpointLocation::GetMetrics(const StatsDumpOptions &options) {
+
+  llvm::json::Object loc_json;
+
+  const bool is_resolved = IsResolved();
+  const bool is_hardware = is_resolved && m_bp_site_sp->IsHardware();
+  loc_json.try_emplace("id", GetID());
+  loc_json.try_emplace("resolved", is_resolved);
+  loc_json.try_emplace("hardward", is_hardware);
+  loc_json.try_emplace("reexported", IsReExported());
+  loc_json.try_emplace("indirect", IsIndirect());
+  loc_json.try_emplace("enabled", IsEnabled());
+
+  if (m_address.IsSectionOffset()) {
+    SymbolContext sc;
+    m_address.CalculateSymbolContext(&sc);
+    loc_json.try_emplace("symbolContext", sc.ToJSON());
+  }
+
+  const addr_t load_addr = GetLoadAddress();
+  if (load_addr != LLDB_INVALID_ADDRESS)
+    loc_json.try_emplace("loadAddress", (int64_t)load_addr);
+  const addr_t file_addr = m_address.GetFileAddress();
+  if (file_addr != LLDB_INVALID_ADDRESS)
+    loc_json.try_emplace("fileAddress", (int64_t)file_addr);
+  loc_json.try_emplace("hitCount", (int64_t)GetHitCount());
+  return llvm::json::Value(std::move(loc_json));
+}

lldb/source/Commands/CommandObjectExpression.cpp

if (!m_fixed_expression.empty() && target.GetEnableNotifyAboutFixIts()) {
         // Add in any options that might have been in the original command:
         fixed_command.append(std::string(args.GetArgStringWithDelimiter()));
         fixed_command.append(m_fixed_expression);
       } else
         fixed_command.append(m_fixed_expression);
       history.AppendString(fixed_command);
     }
     // Increment statistics to record this expression evaluation success.
-    target.IncrementStats(StatisticKind::ExpressionSuccessful);
+    target.GetStatistics().NotifyExprEval(true);
     return true;
   }
 
   // Increment statistics to record this expression evaluation failure.
-  target.IncrementStats(StatisticKind::ExpressionFailure);
+  target.GetStatistics().NotifyExprEval(false);
   result.SetStatus(eReturnStatusFailed);
   return false;
 }

lldb/source/Commands/CommandObjectFrame.cpp

bool DoExecute(Args &command, CommandReturnObject &result) override {
     if (m_interpreter.TruncationWarningNecessary()) {
       result.GetOutputStream().Printf(m_interpreter.TruncationWarningText(),
                                       m_cmd_name.c_str());
       m_interpreter.TruncationWarningGiven();
     }
 
     // Increment statistics.
     bool res = result.Succeeded();
-    Target &target = GetSelectedOrDummyTarget();
-    if (res)
-      target.IncrementStats(StatisticKind::FrameVarSuccess);
-    else
-      target.IncrementStats(StatisticKind::FrameVarFailure);
+    GetSelectedOrDummyTarget().GetStatistics().NotifyFrameVar(res);
     return res;
   }
 
   OptionGroupOptions m_option_group;
   OptionGroupVariable m_option_variable;
   OptionGroupFormat m_option_format;
   OptionGroupValueObjectDisplay m_varobj_options;
 };

lldb/source/Commands/CommandObjectStats.cpp

 //===-- CommandObjectStats.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "CommandObjectStats.h"
+#include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 class CommandObjectStatsEnable : public CommandObjectParsed {
 public:
   CommandObjectStatsEnable(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "enable",
                             "Enable statistics collection", nullptr,
                             eCommandProcessMustBePaused) {}
 
   ~CommandObjectStatsEnable() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target &target = GetSelectedOrDummyTarget();
 
-    if (target.GetCollectingStats()) {
+    if (target.GetStatistics().GetCollectingStats()) {
       result.AppendError("statistics already enabled");
       return false;
     }
 
-    target.SetCollectingStats(true);
+    target.GetStatistics().SetCollectingStats(true);
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return true;
   }
 };
 
 class CommandObjectStatsDisable : public CommandObjectParsed {
 public:
   CommandObjectStatsDisable(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "disable",
                             "Disable statistics collection", nullptr,
                             eCommandProcessMustBePaused) {}
 
   ~CommandObjectStatsDisable() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target &target = GetSelectedOrDummyTarget();
 
-    if (!target.GetCollectingStats()) {
+    if (!target.GetStatistics().GetCollectingStats()) {
       result.AppendError("need to enable statistics before disabling them");
       return false;
     }
 
-    target.SetCollectingStats(false);
+    target.GetStatistics().SetCollectingStats(false);
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return true;
   }
 };
 
+#define LLDB_OPTIONS_statistics_dump
+#include "CommandOptions.inc"
+
 class CommandObjectStatsDump : public CommandObjectParsed {
 public:
+  class CommandOptions : public Options {
+  public:
+    CommandOptions() : Options() { OptionParsingStarting(nullptr); }
+
+    Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
+                          ExecutionContext *execution_context) override {
+      Status error;
+      const int short_option = m_getopt_table[option_idx].val;
+
+      switch (short_option) {
+      case 'a':
+        m_metric_options.SetAll();
+        break;
+      case 'b':
+        m_metric_options.dump_breakpoints = true;
+        break;
+      case 'l':
+        m_metric_options.dump_breakpoint_locations = true;
+        break;
+      case 'm':
+        m_metric_options.dump_modules = true;
+        break;
+      case 's':
+        m_metric_options.dump_settings = true;
+        break;
+      default:
+        llvm_unreachable("Unimplemented option");
+      }
+      return error;
+    }
+
+    void OptionParsingStarting(ExecutionContext *execution_context) override {
+      m_metric_options = StatsDumpOptions();
+    }
+
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return llvm::makeArrayRef(g_statistics_dump_options);
+    }
+
+    StatsDumpOptions m_metric_options;
+  };
+
   CommandObjectStatsDump(CommandInterpreter &interpreter)
-      : CommandObjectParsed(interpreter, "dump", "Dump statistics results",
-                            nullptr, eCommandProcessMustBePaused) {}
+      : CommandObjectParsed(
+            interpreter, "statistics dump", "Dump metrics in JSON format",
+            "statistics dump [<options>]", eCommandRequiresTarget),
+        m_options() {}
 
   ~CommandObjectStatsDump() override = default;
 
+  Options *GetOptions() override { return &m_options; }
+
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target &target = GetSelectedOrDummyTarget();
-
-    uint32_t i = 0;
-    for (auto &stat : target.GetStatistics()) {
-      result.AppendMessageWithFormat(
-          "%s : %u\n",
-          lldb_private::GetStatDescription(
-              static_cast<lldb_private::StatisticKind>(i))
-              .c_str(),
-          stat);
-      i += 1;
-    }
+    Target &target = m_exe_ctx.GetTargetRef();
+    result.AppendMessageWithFormatv(
+        "{0:2}", target.ReportStatistics(m_options.m_metric_options));
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return true;
   }
+
+  CommandOptions m_options;
 };
 
 CommandObjectStats::CommandObjectStats(CommandInterpreter &interpreter)
     : CommandObjectMultiword(interpreter, "statistics",
                              "Print statistics about a debugging session",
                              "statistics <subcommand> [<subcommand-options>]") {
   LoadSubCommand("enable",
                  CommandObjectSP(new CommandObjectStatsEnable(interpreter)));
   LoadSubCommand("disable",
                  CommandObjectSP(new CommandObjectStatsDisable(interpreter)));
   LoadSubCommand("dump",
                  CommandObjectSP(new CommandObjectStatsDump(interpreter)));
 }
 
 CommandObjectStats::~CommandObjectStats() = default;

lldb/source/Commands/Options.td

let Command = "trace dump" in {
   def trace_dump_verbose : Option<"verbose", "v">, Group<1>,
     Desc<"Show verbose trace information.">;
 }
 
 let Command = "trace schema" in {
   def trace_schema_verbose : Option<"verbose", "v">, Group<1>,
     Desc<"Show verbose trace schema logging for debugging the plug-in.">;
 }
+
+let Command = "statistics dump" in {
+  def statistics_dump_modules: Option<"modules", "m">, Group<1>,
+    Desc<"Include metrics for each module in the target.">;
+  def statistics_dump_breakpoints: Option<"breakpoints", "b">, Group<1>,
+    Desc<"Include metrics for each breakpoint in the target.">;
+  def statistics_dump_locations: Option<"locations", "l">, Group<1>,
+    Desc<"Include metrics for each breakpoint location in each breakpoint.">;
+  def statistics_dump_settings: Option<"settings", "s">, Group<1>,
+    Desc<"Include important target settings in metrics.">;
+  def statistics_dump_all: Option<"all", "a">, Group<1>,
+    Desc<"Include all metrics in the target.">;
+}

lldb/source/Core/FileSpecList.cpp

 // Return the number of files in the file spec list.
 size_t FileSpecList::GetSize() const { return m_files.size(); }
 
 size_t FileSpecList::GetFilesMatchingPartialPath(const char *path,
                                                  bool dir_okay,
                                                  FileSpecList &matches) {
   return 0;
 }
+
+llvm::json::Value FileSpecList::ToJSON() const {
+  llvm::json::Array files;
+  for (const auto &file : m_files)
+    files.emplace_back(file.GetPath());
+  return llvm::json::Value(std::move(files));
+}

lldb/source/Core/Module.cpp

 bool Module::GetIsDynamicLinkEditor() {
   ObjectFile *obj_file = GetObjectFile();
 
   if (obj_file)
     return obj_file->GetIsDynamicLinkEditor();
 
   return false;
 }
+
+uint64_t Module::GetDebugInfoSize() {
+  SymbolFile *symbols = GetSymbolFile();
+  if (symbols)
+    return symbols->GetDebugInfoSize();
+  return 0;
+}

lldb/source/Core/Section.cpp

const char *Section::GetTypeAsCString() const {
   case eSectionTypeDWARFGNUDebugAltLink:
     return "dwarf-gnu-debugaltlink";
   case eSectionTypeOther:
     return "regular";
   }
   return "unknown";
 }
 
+bool Section::ContainsOnlyDebugInfo() const {
+  switch (m_type) {
+  case eSectionTypeInvalid:
+  case eSectionTypeCode:
+  case eSectionTypeContainer:
+  case eSectionTypeData:
+  case eSectionTypeDataCString:
+  case eSectionTypeDataCStringPointers:
+  case eSectionTypeDataSymbolAddress:
+  case eSectionTypeData4:
+  case eSectionTypeData8:
+  case eSectionTypeData16:
+  case eSectionTypeDataPointers:
+  case eSectionTypeZeroFill:
+  case eSectionTypeDataObjCMessageRefs:
+  case eSectionTypeDataObjCCFStrings:
+  case eSectionTypeELFSymbolTable:
+  case eSectionTypeELFDynamicSymbols:
+  case eSectionTypeELFRelocationEntries:
+  case eSectionTypeELFDynamicLinkInfo:
+  case eSectionTypeEHFrame:
+  case eSectionTypeARMexidx:
+  case eSectionTypeARMextab:
+  case eSectionTypeCompactUnwind:
+  case eSectionTypeGoSymtab:
+  case eSectionTypeAbsoluteAddress:
+  case eSectionTypeOther:
+    return false;
+
+  case eSectionTypeDebug:
+  case eSectionTypeDWARFDebugAbbrev:
+  case eSectionTypeDWARFDebugAbbrevDwo:
+  case eSectionTypeDWARFDebugAddr:
+  case eSectionTypeDWARFDebugAranges:
+  case eSectionTypeDWARFDebugCuIndex:
+  case eSectionTypeDWARFDebugTuIndex:
+  case eSectionTypeDWARFDebugFrame:
+  case eSectionTypeDWARFDebugInfo:
+  case eSectionTypeDWARFDebugInfoDwo:
+  case eSectionTypeDWARFDebugLine:
+  case eSectionTypeDWARFDebugLineStr:
+  case eSectionTypeDWARFDebugLoc:
+  case eSectionTypeDWARFDebugLocDwo:
+  case eSectionTypeDWARFDebugLocLists:
+  case eSectionTypeDWARFDebugLocListsDwo:
+  case eSectionTypeDWARFDebugMacInfo:
+  case eSectionTypeDWARFDebugMacro:
+  case eSectionTypeDWARFDebugPubNames:
+  case eSectionTypeDWARFDebugPubTypes:
+  case eSectionTypeDWARFDebugRanges:
+  case eSectionTypeDWARFDebugRngLists:
+  case eSectionTypeDWARFDebugRngListsDwo:
+  case eSectionTypeDWARFDebugStr:
+  case eSectionTypeDWARFDebugStrDwo:
+  case eSectionTypeDWARFDebugStrOffsets:
+  case eSectionTypeDWARFDebugStrOffsetsDwo:
+  case eSectionTypeDWARFDebugTypes:
+  case eSectionTypeDWARFDebugTypesDwo:
+  case eSectionTypeDWARFDebugNames:
+  case eSectionTypeDWARFAppleNames:
+  case eSectionTypeDWARFAppleTypes:
+  case eSectionTypeDWARFAppleNamespaces:
+  case eSectionTypeDWARFAppleObjC:
+  case eSectionTypeDWARFGNUDebugAltLink:
+    return true;
+  }
+  return false;
+}
+
 Section::Section(const ModuleSP &module_sp, ObjectFile *obj_file,
                  user_id_t sect_id, ConstString name,
                  SectionType sect_type, addr_t file_addr, addr_t byte_size,
                  lldb::offset_t file_offset, lldb::offset_t file_size,
                  uint32_t log2align, uint32_t flags,
                  uint32_t target_byte_size /*=1*/)
     : ModuleChild(module_sp), UserID(sect_id), Flags(flags),
       m_obj_file(obj_file), m_type(sect_type), m_parent_wp(), m_name(name),
size_t SectionList::Slide(addr_t slide_amount, bool slide_children) {
   size_t count = 0;
   const_iterator pos, end = m_sections.end();
   for (pos = m_sections.begin(); pos != end; ++pos) {
     if ((*pos)->Slide(slide_amount, slide_children))
       ++count;
   }
   return count;
 }
+
+uint64_t SectionList::GetDebugInfoSize() const {
+  uint64_t debug_info_size = 0;
+  for (const auto &section : m_sections) {
+    const SectionList &sub_sections = section->GetChildren();
+    if (sub_sections.GetSize() > 0)
+      debug_info_size += sub_sections.GetDebugInfoSize();
+    else if (section->ContainsOnlyDebugInfo())
+      debug_info_size += section->GetFileSize();
+  }
+  return debug_info_size;
+}

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

unsigned ObjectFileELF::RelocateDebugSections(const ELFSectionHeader *rel_hdr,
   return 0;
 }
 
 Symtab *ObjectFileELF::GetSymtab() {
   ModuleSP module_sp(GetModule());
   if (!module_sp)
     return nullptr;
 
-  Progress progress(llvm::formatv("Parsing symbol table for {0}",
-                                  m_file.GetFilename().AsCString("<Unknown>")));
-
   // We always want to use the main object file so we (hopefully) only have one
   // cached copy of our symtab, dynamic sections, etc.
   ObjectFile *module_obj_file = module_sp->GetObjectFile();
   if (module_obj_file && module_obj_file != this)
     return module_obj_file->GetSymtab();
 
   if (m_symtab_up == nullptr) {
+    Progress progress(
+        llvm::formatv("Parsing symbol table for {0}",
+                      m_file.GetFilename().AsCString("<Unknown>")));
+    ElapsedTime elapsed(module_sp->GetSymtabParseTime());
     SectionList *section_list = module_sp->GetSectionList();
     if (!section_list)
       return nullptr;
 
     uint64_t symbol_id = 0;
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 
     // Sharable objects and dynamic executables usually have 2 distinct symbol

lldb/source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp

uint32_t ObjectFileJIT::GetAddressByteSize() const {
   return m_data.GetAddressByteSize();
 }
 
 Symtab *ObjectFileJIT::GetSymtab() {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_symtab_up == nullptr) {
+      ElapsedTime elapsed(module_sp->GetSymtabParseTime());
       m_symtab_up = std::make_unique<Symtab>(this);
       std::lock_guard<std::recursive_mutex> symtab_guard(
           m_symtab_up->GetMutex());
       ObjectFileJITDelegateSP delegate_sp(m_delegate_wp.lock());
       if (delegate_sp)
         delegate_sp->PopulateSymtab(this, *m_symtab_up);
       // TODO: get symbols from delegate
       m_symtab_up->Finalize();

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

AddressClass ObjectFileMachO::GetAddressClass(lldb::addr_t file_addr) {
   return AddressClass::eUnknown;
 }
 
 Symtab *ObjectFileMachO::GetSymtab() {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_symtab_up == nullptr) {
+      // Aggregate the symbol table parse time into the module in case we have
+      // one object file for the module and one for the debug information, both
+      // of which can have symbol tables that might get parsed.
+      ElapsedTime elapsed(module_sp->GetSymtabParseTime());
       m_symtab_up = std::make_unique<Symtab>(this);
       std::lock_guard<std::recursive_mutex> symtab_guard(
           m_symtab_up->GetMutex());
       ParseSymtab();
       m_symtab_up->Finalize();
     }
   }
   return m_symtab_up.get();

 enum { DebugSymbols = true, NonDebugSymbols = false };
 
 size_t ObjectFileMachO::ParseSymtab() {
   LLDB_SCOPED_TIMERF("ObjectFileMachO::ParseSymtab () module = %s",
                      m_file.GetFilename().AsCString(""));
   ModuleSP module_sp(GetModule());
   if (!module_sp)
     return 0;
-
   Progress progress(llvm::formatv("Parsing symbol table for {0}",
                                   m_file.GetFilename().AsCString("<Unknown>")));
 
   llvm::MachO::symtab_command symtab_load_command = {0, 0, 0, 0, 0, 0};
   llvm::MachO::linkedit_data_command function_starts_load_command = {0, 0, 0, 0};
   llvm::MachO::linkedit_data_command exports_trie_load_command = {0, 0, 0, 0};
   llvm::MachO::dyld_info_command dyld_info = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   // The data element of type bool indicates that this entry is thumb
if (process && m_header.filetype != llvm::MachO::MH_OBJECT &&
 
     nlist_data.SetData(m_data, symtab_load_command.symoff,
                        nlist_data_byte_size);
     strtab_data.SetData(m_data, symtab_load_command.stroff,
                         strtab_data_byte_size);
 
     // We shouldn't have exports data from both the LC_DYLD_INFO command
     // AND the LC_DYLD_EXPORTS_TRIE command in the same binary:
-    lldbassert(!((dyld_info.export_size > 0) 
-                 && (exports_trie_load_command.datasize > 0)));
+    lldbassert(!((dyld_info.export_size > 0) &&
+                 (exports_trie_load_command.datasize > 0)));
     if (dyld_info.export_size > 0) {
       dyld_trie_data.SetData(m_data, dyld_info.export_off,
                              dyld_info.export_size);
     } else if (exports_trie_load_command.datasize > 0) {
       dyld_trie_data.SetData(m_data, exports_trie_load_command.dataoff,
                              exports_trie_load_command.datasize);
     }
 

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

 }
 
 // GetNListSymtab
 Symtab *ObjectFilePECOFF::GetSymtab() {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_symtab_up == nullptr) {
+      ElapsedTime elapsed(module_sp->GetSymtabParseTime());
       SectionList *sect_list = GetSectionList();
       m_symtab_up = std::make_unique<Symtab>(this);
       std::lock_guard<std::recursive_mutex> guard(m_symtab_up->GetMutex());
 
       const uint32_t num_syms = m_coff_header.nsyms;
 
       if (m_file && num_syms > 0 && m_coff_header.symoff > 0) {
         const uint32_t symbol_size = 18;

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h

public:
   // Constructors and Destructors
   SymbolFileBreakpad(lldb::ObjectFileSP objfile_sp)
       : SymbolFile(std::move(objfile_sp)) {}
 
   ~SymbolFileBreakpad() override = default;
 
   uint32_t CalculateAbilities() override;
 
+  uint64_t GetDebugInfoSize() override;
+
   void InitializeObject() override {}
 
   // Compile Unit function calls
 
   lldb::LanguageType ParseLanguage(CompileUnit &comp_unit) override {
     return lldb::eLanguageTypeUnknown;
   }
 

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp

 
 uint32_t SymbolFileBreakpad::CalculateAbilities() {
   if (!m_objfile_sp || !llvm::isa<ObjectFileBreakpad>(*m_objfile_sp))
     return 0;
 
   return CompileUnits | Functions | LineTables;
 }
 
+uint64_t SymbolFileBreakpad::GetDebugInfoSize() {
+  // Breakpad files are all debug info.
+  return m_objfile_sp->GetByteSize();
+}
+
 uint32_t SymbolFileBreakpad::CalculateNumCompileUnits() {
   ParseCUData();
   return m_cu_data->GetSize();
 }
 
 CompUnitSP SymbolFileBreakpad::ParseCompileUnitAtIndex(uint32_t index) {
   if (index >= m_cu_data->GetSize())
     return nullptr;

lldb/source/Plugins/SymbolFile/DWARF/DWARFIndex.h

 //===-- DWARFIndex.h -------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFINDEX_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFINDEX_H
 
 #include "Plugins/SymbolFile/DWARF/DIERef.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDIE.h"
 #include "Plugins/SymbolFile/DWARF/DWARFFormValue.h"
+#include "lldb/Utility/ElapsedTime.h"
 
 class DWARFDeclContext;
 class DWARFDIE;
 
 namespace lldb_private {
 class DWARFIndex {
 public:
   DWARFIndex(Module &module) : m_module(module) {}
GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                uint32_t name_type_mask,
                llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
   virtual void
   GetFunctions(const RegularExpression &regex,
                llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
 
   virtual void Dump(Stream &s) = 0;
 
+  ElapsedTime::Duration GetIndexTime() { return m_index_time; }
+
 protected:
   Module &m_module;
+  ElapsedTime::Duration m_index_time{0.0};
 
   /// Helper function implementing common logic for processing function dies. If
   /// the function given by "ref" matches search criteria given by
   /// "parent_decl_ctx" and "name_type_mask", it is inserted into the "dies"
   /// vector.
   bool ProcessFunctionDIE(llvm::StringRef name, DIERef ref,
                           SymbolFileDWARF &dwarf,
                           const CompilerDeclContext &parent_decl_ctx,

lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

void DWARFUnit::ExtractUnitDIENoDwoIfNeeded() {
     llvm::sys::ScopedReader lock(m_first_die_mutex);
     if (m_first_die)
       return; // Already parsed
   }
   llvm::sys::ScopedWriter lock(m_first_die_mutex);
   if (m_first_die)
     return; // Already parsed
 
+  ElapsedTime elapsed(m_dwarf.GetDebugInfoParseTimeRef());
   LLDB_SCOPED_TIMERF("%8.8x: DWARFUnit::ExtractUnitDIENoDwoIfNeeded()",
                      GetOffset());
 
   // Set the offset to that of the first DIE and calculate the start of the
   // next compilation unit header.
   lldb::offset_t offset = GetFirstDIEOffset();
 
   // We are in our compile unit, parse starting at the offset we were told to
DWARFUnit::ScopedExtractDIEs &DWARFUnit::ScopedExtractDIEs::operator=(
   m_clear_dies = rhs.m_clear_dies;
   return *this;
 }
 
 // Parses a compile unit and indexes its DIEs, m_die_array_mutex must be
 // held R/W and m_die_array must be empty.
 void DWARFUnit::ExtractDIEsRWLocked() {
   llvm::sys::ScopedWriter first_die_lock(m_first_die_mutex);
-
+  ElapsedTime elapsed(m_dwarf.GetDebugInfoParseTimeRef());
   LLDB_SCOPED_TIMERF("%8.8x: DWARFUnit::ExtractDIEsIfNeeded()", GetOffset());
 
   // Set the offset to that of the first DIE and calculate the start of the
   // next compilation unit header.
   lldb::offset_t offset = GetFirstDIEOffset();
   lldb::offset_t next_cu_offset = GetNextUnitOffset();
 
   DWARFDebugInfoEntry die;

lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp

 
 void ManualDWARFIndex::Index() {
   if (!m_dwarf)
     return;
 
   SymbolFileDWARF &main_dwarf = *m_dwarf;
   m_dwarf = nullptr;
 
+  ElapsedTime elapsed(m_index_time);
   LLDB_SCOPED_TIMERF("%p", static_cast<void *>(&main_dwarf));
 
   DWARFDebugInfo &main_info = main_dwarf.DebugInfo();
   SymbolFileDWARFDwo *dwp_dwarf = main_dwarf.GetDwpSymbolFile().get();
   DWARFDebugInfo *dwp_info = dwp_dwarf ? &dwp_dwarf->DebugInfo() : nullptr;
 
   std::vector<DWARFUnit *> units_to_index;
   units_to_index.reserve(main_info.GetNumUnits() +

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

 #include "llvm/Support/Threading.h"
 
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/Core/dwarf.h"
 #include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/ElapsedTime.h"
 #include "lldb/Utility/Flags.h"
 #include "lldb/Utility/RangeMap.h"
 #include "lldb/lldb-private.h"
 
 #include "DWARFContext.h"
 #include "DWARFDataExtractor.h"
 #include "DWARFDefines.h"
 #include "DWARFIndex.h"
public:
   static DWARFDeclContext GetDWARFDeclContext(const DWARFDIE &die);
 
   static lldb::LanguageType LanguageTypeFromDWARF(uint64_t val);
 
   static lldb::LanguageType GetLanguage(DWARFUnit &unit);
   /// Same as GetLanguage() but reports all C++ versions as C++ (no version).
   static lldb::LanguageType GetLanguageFamily(DWARFUnit &unit);
 
+  uint64_t GetDebugInfoSize() override;
+  lldb_private::ElapsedTime::Duration GetDebugInfoParseTime() override {
+    return m_parse_time;
+  }
+  lldb_private::ElapsedTime::Duration GetDebugInfoIndexTime() override;
+
+  lldb_private::ElapsedTime::Duration &GetDebugInfoParseTimeRef() {
+    return m_parse_time;
+  }
+
 protected:
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *>
       DIEToTypePtr;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::VariableSP>
       DIEToVariableSP;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *,
                          lldb::opaque_compiler_type_t>
       DIEToClangType;
protected:
   UniqueDWARFASTTypeMap m_unique_ast_type_map;
   DIEToTypePtr m_die_to_type;
   DIEToVariableSP m_die_to_variable_sp;
   DIEToClangType m_forward_decl_die_to_clang_type;
   ClangTypeToDIE m_forward_decl_clang_type_to_die;
   llvm::DenseMap<dw_offset_t, lldb_private::FileSpecList>
       m_type_unit_support_files;
   std::vector<uint32_t> m_lldb_cu_to_dwarf_unit;
+  lldb_private::ElapsedTime::Duration m_parse_time{0.0};
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_SYMBOLFILEDWARF_H

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 bool SymbolFileDWARF::ParseSupportFiles(DWARFUnit &dwarf_cu,
                                         const ModuleSP &module,
                                         FileSpecList &support_files) {
 
   dw_offset_t offset = dwarf_cu.GetLineTableOffset();
   if (offset == DW_INVALID_OFFSET)
     return false;
 
+  ElapsedTime elapsed(m_parse_time);
   llvm::DWARFDebugLine::Prologue prologue;
   if (!ParseLLVMLineTablePrologue(m_context, prologue, offset,
                                   dwarf_cu.GetOffset()))
     return false;
 
   support_files = ParseSupportFilesFromPrologue(
       module, prologue, dwarf_cu.GetPathStyle(),
       dwarf_cu.GetCompilationDirectory().GetCString());
if (iter_bool.second) {
     llvm::DWARFContext &ctx = m_context.GetAsLLVM();
     llvm::DWARFDebugLine::Prologue prologue;
     auto report = [](llvm::Error error) {
       Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
       LLDB_LOG_ERROR(log, std::move(error),
                      "SymbolFileDWARF::GetTypeUnitSupportFiles failed to parse "
                      "the line table prologue");
     };
+    ElapsedTime elapsed(m_parse_time);
     llvm::Error error = prologue.parse(data, &line_table_offset, report, ctx);
     if (error) {
       report(std::move(error));
     } else {
       list = ParseSupportFilesFromPrologue(GetObjectFile()->GetModule(),
                                            prologue, tu.GetPathStyle());
     }
   }
bool SymbolFileDWARF::ParseLineTable(CompileUnit &comp_unit) {
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (!dwarf_cu)
     return false;
 
   dw_offset_t offset = dwarf_cu->GetLineTableOffset();
   if (offset == DW_INVALID_OFFSET)
     return false;
 
+  ElapsedTime elapsed(m_parse_time);
   llvm::DWARFDebugLine line;
   const llvm::DWARFDebugLine::LineTable *line_table =
       ParseLLVMLineTable(m_context, line, offset, dwarf_cu->GetOffset());
 
   if (!line_table)
     return false;
 
   // FIXME: Rather than parsing the whole line table and then copying it over

 }
 
 lldb_private::DebugMacrosSP
 SymbolFileDWARF::ParseDebugMacros(lldb::offset_t *offset) {
   auto iter = m_debug_macros_map.find(*offset);
   if (iter != m_debug_macros_map.end())
     return iter->second;
 
+  ElapsedTime elapsed(m_parse_time);
   const DWARFDataExtractor &debug_macro_data = m_context.getOrLoadMacroData();
   if (debug_macro_data.GetByteSize() == 0)
     return DebugMacrosSP();
 
   lldb_private::DebugMacrosSP debug_macros_sp(new lldb_private::DebugMacros());
   m_debug_macros_map[*offset] = debug_macros_sp;
 
   const DWARFDebugMacroHeader &header =

 }
 
 LanguageType SymbolFileDWARF::GetLanguageFamily(DWARFUnit &unit) {
   auto lang = (llvm::dwarf::SourceLanguage)unit.GetDWARFLanguageType();
   if (llvm::dwarf::isCPlusPlus(lang))
     lang = DW_LANG_C_plus_plus;
   return LanguageTypeFromDWARF(lang);
 }
+
+uint64_t SymbolFileDWARF::GetDebugInfoSize() {
+  ModuleSP module_sp(m_objfile_sp->GetModule());
+  if (!module_sp)
+    return 0;
+  const SectionList *section_list = module_sp->GetSectionList();
+  if (section_list)
+    return section_list->GetDebugInfoSize();
+  return 0;
+}
+
+ElapsedTime::Duration SymbolFileDWARF::GetDebugInfoIndexTime() {
+  if (m_index)
+    return m_index->GetIndexTime();
+  return ElapsedTime::Duration();
+}

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

 //===-- SymbolFileDWARFDebugMap.h ------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_SYMBOLFILEDWARFDEBUGMAP_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_SYMBOLFILEDWARFDEBUGMAP_H
 
 #include "lldb/Symbol/SymbolFile.h"
+#include "lldb/Utility/ElapsedTime.h"
 #include "lldb/Utility/RangeMap.h"
 #include "llvm/Support/Chrono.h"
 #include <bitset>
 #include <map>
 #include <vector>
 
 #include "UniqueDWARFASTType.h"
 
public:
   std::vector<std::unique_ptr<lldb_private::CallEdge>>
   ParseCallEdgesInFunction(lldb_private::UserID func_id) override;
 
   void DumpClangAST(lldb_private::Stream &s) override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
+  uint64_t GetDebugInfoSize() override;
+  lldb_private::ElapsedTime::Duration GetDebugInfoParseTime() override;
+  lldb_private::ElapsedTime::Duration GetDebugInfoIndexTime() override;
+
 protected:
   enum { kHaveInitializedOSOs = (1 << 0), kNumFlags };
 
   friend class DebugMapModule;
   friend class DWARFASTParserClang;
   friend class DWARFCompileUnit;
   friend class SymbolFileDWARF;
   struct OSOInfo {

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

if (compile_unit_info) {
                                      entry->GetRangeEnd());
           num_line_entries_added++;
         }
       }
     }
   }
   return num_line_entries_added;
 }
+
+uint64_t SymbolFileDWARFDebugMap::GetDebugInfoSize() {
+  uint64_t debug_info_size = 0;
+  ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
+    ObjectFile *oso_objfile = oso_dwarf->GetObjectFile();
+    if (!oso_objfile)
+      return false; // Keep iterating
+    ModuleSP module_sp = oso_objfile->GetModule();
+    if (!module_sp)
+      return false; // Keep iterating
+    SectionList *section_list = module_sp->GetSectionList();
+    if (section_list)
+      debug_info_size += section_list->GetDebugInfoSize();
+    return false; // Keep iterating
+  });
+  return debug_info_size;
+}
+
+ElapsedTime::Duration SymbolFileDWARFDebugMap::GetDebugInfoParseTime() {
+  ElapsedTime::Duration elapsed(0.0);
+  ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
+    ObjectFile *oso_objfile = oso_dwarf->GetObjectFile();
+    if (oso_objfile) {
+      ModuleSP module_sp = oso_objfile->GetModule();
+      if (module_sp) {
+        SymbolFile *symfile = module_sp->GetSymbolFile();
+        if (symfile)
+          elapsed += symfile->GetDebugInfoParseTime();
+      }
+    }
+    return false; // Keep iterating
+  });
+  return elapsed;
+}
+
+ElapsedTime::Duration SymbolFileDWARFDebugMap::GetDebugInfoIndexTime() {
+  ElapsedTime::Duration elapsed(0.0);
+  ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
+    ObjectFile *oso_objfile = oso_dwarf->GetObjectFile();
+    if (oso_objfile) {
+      ModuleSP module_sp = oso_objfile->GetModule();
+      if (module_sp) {
+        SymbolFile *symfile = module_sp->GetSymbolFile();
+        if (symfile)
+          elapsed += symfile->GetDebugInfoIndexTime();
+      }
+    }
+    return false; // Keep iterating
+  });
+  return elapsed;
+}

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

public:
 
   // Constructors and Destructors
   SymbolFileNativePDB(lldb::ObjectFileSP objfile_sp);
 
   ~SymbolFileNativePDB() override;
 
   uint32_t CalculateAbilities() override;
 
+  uint64_t GetDebugInfoSize() override;
+
   void InitializeObject() override;
 
   // Compile Unit function calls
 
   void
   ParseDeclsForContext(lldb_private::CompilerDeclContext decl_ctx) override;
 
   lldb::LanguageType

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

uint32_t SymbolFileNativePDB::CalculateAbilities() {
   // stripped and not stripped.
   abilities = kAllAbilities;
 
   if (m_index->dbi().isStripped())
     abilities &= ~(Blocks | LocalVariables);
   return abilities;
 }
 
+uint64_t SymbolFileNativePDB::GetDebugInfoSize() {
+  // PDB files are a separate file that contains all debug info.
+  return m_index->pdb().getFileSize();
+}
+
 void SymbolFileNativePDB::InitializeObject() {
   m_obj_load_address = m_objfile_sp->GetModule()
                            ->GetObjectFile()
                            ->GetBaseAddress()
                            .GetFileAddress();
   m_index->SetLoadAddress(m_obj_load_address);
   m_index->ParseSectionContribs();
 

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

public:
 
   // Constructors and Destructors
   SymbolFilePDB(lldb::ObjectFileSP objfile_sp);
 
   ~SymbolFilePDB() override;
 
   uint32_t CalculateAbilities() override;
 
+  uint64_t GetDebugInfoSize() override;
+
   void InitializeObject() override;
 
   // Compile Unit function calls
 
   lldb::LanguageType
   ParseLanguage(lldb_private::CompileUnit &comp_unit) override;
 
   size_t ParseFunctions(lldb_private::CompileUnit &comp_unit) override;

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

while (auto LexParent = m_session_up->getSymbolById(LexParentId)) {
       if (LexParent->getSymTag() == PDB_SymType::Compiland)
         return LexParentId;
       LexParentId = LexParent->getRawSymbol().getLexicalParentId();
     }
   }
 
   return 0;
 }
+
+uint64_t SymbolFilePDB::GetDebugInfoSize() {
+  // TODO: implement this
+  return 0;
+}

lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h

public:
 
   static const char *GetPluginDescriptionStatic();
 
   static lldb_private::SymbolFile *
   CreateInstance(lldb::ObjectFileSP objfile_sp);
 
   uint32_t CalculateAbilities() override;
 
+  uint64_t GetDebugInfoSize() override;
+
   // Compile Unit function calls
   lldb::LanguageType
   ParseLanguage(lldb_private::CompileUnit &comp_unit) override;
 
   size_t ParseFunctions(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseLineTable(lldb_private::CompileUnit &comp_unit) override;
 

lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp

if (symtab) {
                                        m_objc_class_name_to_index);
         m_objc_class_name_to_index.Sort();
       }
     }
   }
   return abilities;
 }
 
+uint64_t SymbolFileSymtab::GetDebugInfoSize() {
+  // This call isn't expected to look at symbols and figure out which ones are
+  // debug info or not, it is just to report sections full of debug info, so
+  // we should return 0 here.
+  return 0;
+}
+
 uint32_t SymbolFileSymtab::CalculateNumCompileUnits() {
   // If we don't have any source file symbols we will just have one compile
   // unit for the entire object file
   if (m_source_indexes.empty())
     return 0;
 
   // If we have any source file symbols we will logically organize the object
   // symbols using these.

lldb/source/Symbol/SymbolContext.cpp

if (module) {
     } else if (target_symbol) {
       return target_symbol;
     }
   }
 
   return nullptr; // no error; we just didn't find anything
 }
 
+llvm::json::Value SymbolContext::ToJSON() const {
+  llvm::json::Object json;
+  if (module_sp)
+    json.try_emplace("module", module_sp->GetUUID().GetAsString());
+  if (comp_unit)
+    json.try_emplace("compUnit", comp_unit->GetPrimaryFile().GetPath());
+  if (function && function->GetName())
+    json.try_emplace("function", function->GetName().AsCString());
+  if (line_entry.file)
+    json.try_emplace("sourceFile", line_entry.file.GetPath());
+  if (line_entry.file != line_entry.original_file && line_entry.original_file)
+    json.try_emplace("origSourceFile", line_entry.original_file.GetPath());
+  json.try_emplace("sourceLine", (int64_t)line_entry.line);
+  if (line_entry.column)
+    json.try_emplace("sourceColumn", (int64_t)line_entry.column);
+  if (symbol)
+    json.try_emplace("symbol", symbol->GetName().AsCString("<unknown>"));
+  return llvm::json::Value(std::move(json));
+}
+
 //
 //  SymbolContextSpecifier
 //
 
 SymbolContextSpecifier::SymbolContextSpecifier(const TargetSP &target_sp)
     : m_target_sp(target_sp), m_module_spec(), m_module_sp(), m_file_spec_up(),
       m_start_line(0), m_end_line(0), m_function_spec(), m_class_name(),
       m_address_range_up(), m_type(eNothingSpecified) {}

lldb/source/Symbol/Symtab.cpp

static bool lldb_skip_name(llvm::StringRef mangled,
   }
   llvm_unreachable("unknown scheme!");
 }
 
 void Symtab::InitNameIndexes() {
   // Protected function, no need to lock mutex...
   if (!m_name_indexes_computed) {
     m_name_indexes_computed = true;
+    ElapsedTime elapsed(m_objfile->GetModule()->GetSymtabNamesTime());
     LLDB_SCOPED_TIMER();
 
     // Collect all loaded language plugins.
     std::vector<Language *> languages;
     Language::ForEach([&languages](Language *l) {
       languages.push_back(l);
       return true;
     });

lldb/source/Target/CMakeLists.txt

add_lldb_library(lldbTarget
   RegisterNumber.cpp
   RemoteAwarePlatform.cpp
   SectionLoadHistory.cpp
   SectionLoadList.cpp
   StackFrame.cpp
   StackFrameList.cpp
   StackFrameRecognizer.cpp
   StackID.cpp
+  Statistics.cpp
   StopInfo.cpp
   StructuredDataPlugin.cpp
   SystemRuntime.cpp
   Target.cpp
   TargetList.cpp
   Thread.cpp
   ThreadCollection.cpp
   ThreadList.cpp

lldb/source/Target/PathMappingList.cpp

uint32_t PathMappingList::FindIndexForPath(ConstString orig_path) const {
   const_iterator end = m_pairs.end();
 
   for (pos = begin; pos != end; ++pos) {
     if (pos->first == path)
       return std::distance(begin, pos);
   }
   return UINT32_MAX;
 }
+
+llvm::json::Value PathMappingList::ToJSON() const {
+  llvm::json::Array mappings;
+  for (const auto &pair : m_pairs) {
+    llvm::json::Array mapping;
+    mapping.emplace_back(pair.first.GetCString());
+    mapping.emplace_back(pair.second.GetCString());
+    mappings.emplace_back(std::move(mapping));
+  }
+  return llvm::json::Value(std::move(mappings));
+}

lldb/source/Target/Process.cpp

uint32_t Process::AssignIndexIDToThread(uint64_t thread_id) {
   return result;
 }
 
 StateType Process::GetState() {
   return m_public_state.GetValue();
 }
 
 void Process::SetPublicState(StateType new_state, bool restarted) {
+  const bool new_state_is_stopped = StateIsStoppedState(new_state, false);
+  if (new_state_is_stopped) {
+    // This will only set the time if the public stop time has no value, so
+    // it is ok to call this multiple times. With a public stop we can't look
+    // at the stop ID because many private stops might have happened, so we
+    // can't check for a stop ID of zero. This allows the "statistics" command
+    // to dump the time it takes to reach somewhere in your code, like a
+    // breakpoint you set.
+    GetTarget().GetStatistics().SetFirstPublicStopTime();
+  }
+
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_STATE |
                                                   LIBLLDB_LOG_PROCESS));
   LLDB_LOGF(log, "Process::SetPublicState (state = %s, restarted = %i)",
             StateAsCString(new_state), restarted);
   const StateType old_state = m_public_state.GetValue();
   m_public_state.SetValue(new_state);
 
   // On the transition from Run to Stopped, we unlock the writer end of the run
   // lock.  The lock gets locked in Resume, which is the public API to tell the
   // program to run.
   if (!StateChangedIsExternallyHijacked()) {
     if (new_state == eStateDetached) {
       LLDB_LOGF(log,
                 "Process::SetPublicState (%s) -- unlocking run lock for detach",
                 StateAsCString(new_state));
       m_public_run_lock.SetStopped();
     } else {
       const bool old_state_is_stopped = StateIsStoppedState(old_state, false);
-      const bool new_state_is_stopped = StateIsStoppedState(new_state, false);
       if ((old_state_is_stopped != new_state_is_stopped)) {
         if (new_state_is_stopped && !restarted) {
           LLDB_LOGF(log, "Process::SetPublicState (%s) -- unlocking run lock",
                     StateAsCString(new_state));
           m_public_run_lock.SetStopped();
         }
       }
     }
if (StateIsStoppedState(new_state, false)) {
       // identify which threads are stopping or create a special thread list
       // containing only threads which actually stopped.
       //
       // The process plugin is responsible for managing the actual behavior of
       // the threads and should have stopped any threads that are going to stop
       // before we get here.
       m_thread_list.DidStop();
 
-      m_mod_id.BumpStopID();
+      if (m_mod_id.BumpStopID() == 0)
+        GetTarget().GetStatistics().SetFirstPrivateStopTime();
+
       if (!m_mod_id.IsLastResumeForUserExpression())
         m_mod_id.SetStopEventForLastNaturalStopID(event_sp);
       m_memory_cache.Clear();
       LLDB_LOGF(log, "Process::SetPrivateState (%s) stop_id = %u",
                 StateAsCString(new_state), m_mod_id.GetStopID());
     }
 
     m_private_state_broadcaster.BroadcastEvent(event_sp);

lldb/source/Target/Statistics.cpp

+//===-- Statistics.cpp ----------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Target/Statistics.h"
+
+#include "lldb/Core/Module.h"
+#include "lldb/Symbol/SymbolFile.h"
+#include "lldb/Target/Target.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace llvm;
+
+static void EmplaceSafeString(llvm::json::Object &obj, llvm::StringRef key,
+                              const std::string &str) {
+  if (str.empty())
+    return;
+  if (LLVM_LIKELY(llvm::json::isUTF8(str)))
+    obj.try_emplace(key, str);
+  else
+    obj.try_emplace(key, llvm::json::fixUTF8(str));
+}
+
+void SuccessFailStats::Notify(bool success) {
+  if (success)
+    ++successes;
+  else
+    ++failures;
+}
+
+json::Value SuccessFailStats::ToJSON() const {
+  return json::Value(json::Object{
+      {"successes", successes},
+      {"failures", failures},
+  });
+}
+
+void TargetStats::CollectModuleStats(Target &target) {
+  m_modules.clear();
+  for (ModuleSP module_sp : target.GetImages().Modules()) {
+    ModuleStats module;
+    module.path = module_sp->GetFileSpec().GetPath();
+    module.uuid = module_sp->GetUUID().GetAsString();
+    module.triple = module_sp->GetArchitecture().GetTriple().str();
+    SymbolFile *sym_file = module_sp->GetSymbolFile();
+    if (sym_file) {
+      module.debug_index_time = sym_file->GetDebugInfoIndexTime().count();
+      module.debug_parse_time = sym_file->GetDebugInfoParseTime().count();
+    }
+    module.symtab_parse_time = module_sp->GetSymtabParseTime().count();
+    module.symtab_names_time = module_sp->GetSymtabNamesTime().count();
+    module.debug_info_size = module_sp->GetDebugInfoSize();
+    m_modules.push_back(std::move(module));
+  }
+}
+
+static double elapsed(const std::chrono::steady_clock::time_point &start,
+                      const std::chrono::steady_clock::time_point &end) {
+  std::chrono::duration<double> elapsed =
+      end.time_since_epoch() - start.time_since_epoch();
+  return elapsed.count();
+}
+
+json::Value TargetStats::ToJSON(Target &target,
+                                const StatsDumpOptions &options) {
+  CollectModuleStats(target);
+
+  uint64_t debug_info_size = 0;
+  double debug_parse_time = 0.0;
+  double debug_index_time = 0.0;
+  double symtab_parse_time = 0.0;
+  double symtab_names_time = 0.0;
+
+  json::Array modules;
+  for (const auto &module : m_modules) {
+    modules.push_back(module.ToJSON());
+    debug_info_size += module.debug_info_size;
+    debug_parse_time += module.debug_parse_time;
+    debug_index_time += module.debug_index_time;
+    symtab_parse_time += module.symtab_parse_time;
+    symtab_names_time += module.symtab_names_time;
+  }
+
+  json::Array breakpoints_array;
+  std::unique_lock<std::recursive_mutex> lock;
+  target.GetBreakpointList().GetListMutex(lock);
+
+  const BreakpointList &breakpoints = target.GetBreakpointList();
+  size_t num_breakpoints = breakpoints.GetSize();
+  double totalBreakpointResolveTime = 0;
+  for (size_t i = 0; i < num_breakpoints; i++) {
+    Breakpoint *bp = breakpoints.GetBreakpointAtIndex(i).get();
+    if (options.dump_breakpoints || options.dump_breakpoint_locations)
+      breakpoints_array.push_back(bp->GetStatistics(options));
+    totalBreakpointResolveTime += bp->GetResolveTime().count();
+  }
+
+  // Include settings that can change how executables, sources and breakpoints
+  // can be resolved.
+  json::Object settings;
+  if (options.dump_settings) {
+    settings.try_emplace("target.arg0", target.GetArg0());
+    Args target_args;
+    json::Array run_args;
+    target.GetRunArguments(target_args);
+    for (const auto &arg : target_args.entries())
+      run_args.emplace_back(arg.c_str());
+    settings.try_emplace("target.run-args", std::move(run_args));
+    settings.try_emplace("target.source-map",
+                         target.GetSourcePathMap().ToJSON());
+    settings.try_emplace("target.exec-search-paths",
+                         target.GetExecutableSearchPaths().ToJSON());
+    settings.try_emplace("target.debug-file-search-paths",
+                         target.GetDebugFileSearchPaths().ToJSON());
+    settings.try_emplace("target.clang-module-search-paths",
+                         target.GetClangModuleSearchPaths().ToJSON());
+    settings.try_emplace("target.preload-symbols", target.GetPreloadSymbols());
+    const char *strategy = nullptr;
+    switch (target.GetInlineStrategy()) {
+    case eInlineBreakpointsNever:
+      strategy = "never";
+      break;
+    case eInlineBreakpointsHeaders:
+      strategy = "headers";
+      break;
+    case eInlineBreakpointsAlways:
+      strategy = "always";
+      break;
+    }
+    settings.try_emplace("target.inline-breakpoint-strategy", strategy);
+    settings.try_emplace("target.skip-prologue", target.GetSkipPrologue());
+  }
+
+  json::Object target_metrics_json{
+      {"totalDebugInfoSize", (int64_t)debug_info_size},
+      {"totalDebugInfoParseTime", debug_parse_time},
+      {"totalDebugInfoIndexTime", debug_index_time},
+      {"totalSymbolTableParseTime", symtab_parse_time},
+      {"totalSymbolTableIndexTime", symtab_names_time},
+      {"totalBreakpointResolveTime", totalBreakpointResolveTime},
+      {"expressionEvaluation", m_expr_eval.ToJSON()},
+      {"frameVariable", m_frame_var.ToJSON()},
+  };
+  if (options.dump_breakpoints || options.dump_breakpoint_locations)
+    target_metrics_json.try_emplace("breakpoints",
+                                    std::move(breakpoints_array));
+  if (options.dump_modules)
+    target_metrics_json.try_emplace("modules", std::move(modules));
+  if (options.dump_settings)
+    target_metrics_json.try_emplace("settings", std::move(settings));
+  if (launch_or_attach_time.hasValue() && first_private_stop_time.hasValue()) {
+    double elapsed_time =
+        elapsed(*launch_or_attach_time, *first_private_stop_time);
+    target_metrics_json.try_emplace("launchOrAttachTime", elapsed_time);
+  }
+  if (launch_or_attach_time.hasValue() && first_public_stop_time.hasValue()) {
+    double elapsed_time =
+        elapsed(*launch_or_attach_time, *first_public_stop_time);
+    target_metrics_json.try_emplace("firstStopTime", elapsed_time);
+  }
+  target_metrics_json.try_emplace("targetCreateTime", create_time.count());
+
+  return target_metrics_json;
+}
+
+void TargetStats::SetLaunchOrAttachTime() {
+  launch_or_attach_time = std::chrono::steady_clock::now();
+  first_private_stop_time = llvm::None;
+}
+
+void TargetStats::SetFirstPrivateStopTime() {
+  // 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 (!first_private_stop_time.hasValue())
+    first_private_stop_time = std::chrono::steady_clock::now();
+}
+
+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 (!first_public_stop_time.hasValue())
+    first_public_stop_time = std::chrono::steady_clock::now();
+}
+
+json::Value ModuleStats::ToJSON() const {
+  json::Object module;
+  EmplaceSafeString(module, "path", path);
+  EmplaceSafeString(module, "uuid", uuid);
+  EmplaceSafeString(module, "triple", triple);
+  module.try_emplace("debugInfoParseTime", debug_parse_time);
+  module.try_emplace("debugInfoIndexTime", debug_index_time);
+  module.try_emplace("symbolTableParseTime", symtab_parse_time);
+  module.try_emplace("symbolTableIndexTime", symtab_names_time);
+  module.try_emplace("debugInfoSize", (int64_t)debug_info_size);
+  return module;
+}

lldb/source/Target/Target.cpp

: TargetProperties(this),
       Broadcaster(debugger.GetBroadcasterManager(),
                   Target::GetStaticBroadcasterClass().AsCString()),
       ExecutionContextScope(), m_debugger(debugger), m_platform_sp(platform_sp),
       m_mutex(), m_arch(target_arch), m_images(this), m_section_load_history(),
       m_breakpoint_list(false), m_internal_breakpoint_list(true),
       m_watchpoint_list(), m_process_sp(), m_search_filter_sp(),
       m_image_search_paths(ImageSearchPathsChanged, this),
       m_source_manager_up(), m_stop_hooks(), m_stop_hook_next_id(0),
-      m_latest_stop_hook_id(0),
-      m_valid(true), m_suppress_stop_hooks(false),
+      m_latest_stop_hook_id(0), m_valid(true), m_suppress_stop_hooks(false),
       m_is_dummy_target(is_dummy_target),
       m_frame_recognizer_manager_up(
-          std::make_unique<StackFrameRecognizerManager>()),
-      m_stats_storage(static_cast<int>(StatisticKind::StatisticMax))
-
-{
+          std::make_unique<StackFrameRecognizerManager>()) {
   SetEventName(eBroadcastBitBreakpointChanged, "breakpoint-changed");
   SetEventName(eBroadcastBitModulesLoaded, "modules-loaded");
   SetEventName(eBroadcastBitModulesUnloaded, "modules-unloaded");
   SetEventName(eBroadcastBitWatchpointChanged, "watchpoint-changed");
   SetEventName(eBroadcastBitSymbolsLoaded, "symbols-loaded");
 
   CheckInWithManager();
 

 }
 
 void Target::SetExecutableModule(ModuleSP &executable_sp,
                                  LoadDependentFiles load_dependent_files) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_TARGET));
   ClearModules(false);
 
   if (executable_sp) {
+    ElapsedTime elapsed(m_stats.GetCreateTime());
     LLDB_SCOPED_TIMERF("Target::SetExecutableModule (executable = '%s')",
                        executable_sp->GetFileSpec().GetPath().c_str());
 
     const bool notify = true;
     m_images.Append(executable_sp,
                     notify); // The first image is our executable file
 
     // If we haven't set an architecture yet, reset our architecture based on
else
     stop_id = m_section_load_history.GetLastStopID();
   return m_section_load_history.SetSectionUnloaded(stop_id, section_sp,
                                                    load_addr);
 }
 
 void Target::ClearAllLoadedSections() { m_section_load_history.Clear(); }
 
 Status Target::Launch(ProcessLaunchInfo &launch_info, Stream *stream) {
+  m_stats.SetLaunchOrAttachTime();
   Status error;
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_TARGET));
 
   LLDB_LOGF(log, "Target::%s() called for %s", __FUNCTION__,
             launch_info.GetExecutableFile().GetPath().c_str());
 
   StateType state = eStateInvalid;
 

 
 llvm::Expected<TraceSP> Target::GetTraceOrCreate() {
   if (m_trace_sp)
     return m_trace_sp;
   return CreateTrace();
 }
 
 Status Target::Attach(ProcessAttachInfo &attach_info, Stream *stream) {
+  m_stats.SetLaunchOrAttachTime();
   auto state = eStateInvalid;
   auto process_sp = GetProcessSP();
   if (process_sp) {
     state = process_sp->GetState();
     if (process_sp->IsAlive() && state != eStateConnected) {
       if (state == eStateAttaching)
         return Status("process attach is in progress");
       return Status("a process is already being debugged");

 }
 
 std::recursive_mutex &Target::GetAPIMutex() {
   if (GetProcessSP() && GetProcessSP()->CurrentThreadIsPrivateStateThread())
     return m_private_mutex;
   else
     return m_mutex;
 }
+
+/// Get metrics associated with this target in JSON format.
+llvm::json::Value Target::ReportStatistics(const StatsDumpOptions &options) {
+  m_stats.CollectModuleStats(*this);
+  return m_stats.ToJSON(*this, options);
+}

lldb/test/API/commands/statistics/basic/TestStats.py

 import lldb
+import json
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class TestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def test(self):
+    def setUp(self):
+        TestBase.setUp(self)
         self.build()
-        lldbutil.run_to_source_breakpoint(self, "// break here", lldb.SBFileSpec("main.c"))
 
-        self.expect("statistics disable", substrs=['need to enable statistics before disabling'], error=True)
+    NO_DEBUG_INFO_TESTCASE = True
+
+    def test_enable_disable(self):
+        """
+        Test "statistics disable" and "statistics enable". These don't do
+        anything anymore for cheap to gather statistics. In the future if
+        statistics are expensive to gather, we can enable the feature inside
+        of LLDB and test that enabling and disabling stops expesive information
+        from being gathered.
+        """
+        target = self.createTestTarget()
 
-        # 'expression' should change the statistics.
+        self.expect("statistics disable", substrs=['need to enable statistics before disabling'], error=True)
         self.expect("statistics enable")
         self.expect("statistics enable", substrs=['already enabled'], error=True)
-        self.expect("expr patatino", substrs=['27'])
         self.expect("statistics disable")
-        self.expect("statistics dump", substrs=['expr evaluation successes : 1\n',
-                                                'expr evaluation failures : 0\n'])
+        self.expect("statistics disable", substrs=['need to enable statistics before disabling'], error=True)
 
-        self.expect("statistics enable")
-        # Doesn't parse.
+    def verify_key_in_dict(self, key, d, description):
+        self.assertEqual(key in d, True,
+            'make sure key "%s" is in dictionary %s' % (key, description))
+
+    def verify_key_not_in_dict(self, key, d, description):
+        self.assertEqual(key in d, False,
+            'make sure key "%s" is in dictionary %s' % (key, description))
+
+    def verify_keys(self, dict, description, keys_exist, keys_missing=None):
+        """
+            Verify that all keys in "keys_exist" list are top level items in
+            "dict", and that all keys in "keys_missing" do not exist as top
+            level items in "dict".
+        """
+        if keys_exist:
+            for key in keys_exist:
+                self.verify_key_in_dict(key, dict, description)
+        if keys_missing:
+            for key in keys_missing:
+                self.verify_key_not_in_dict(key, dict, description)
+
+    def verify_success_fail_count(self, stats, key, num_successes, num_fails):
+        self.verify_key_in_dict(key, stats, 'stats["%s"]' % (key))
+        success_fail_dict = stats[key]
+        self.assertEqual(success_fail_dict['successes'], num_successes,
+                         'make sure success count')
+        self.assertEqual(success_fail_dict['failures'], num_fails,
+                         'make sure success count')
+
+    def get_stats(self, options=None, log_path=None):
+        """
+            Get the output of the "statistics dump" with optional extra options
+            and return the JSON as a python dictionary.
+        """
+        if log_path is not None:
+            f = open(log_path, 'w')
+        else:
+            f = None
+        return_obj = lldb.SBCommandReturnObject()
+        command = "statistics dump "
+        if options is not None:
+            command += options
+        if f is not None:
+            f.write('(lldb) %s' % (command))
+        self.ci.HandleCommand(command, return_obj, False)
+        metrics_json = return_obj.GetOutput()
+        if f:
+            f.write(metrics_json)
+        return json.loads(metrics_json)
+
+    def test_expressions_frame_var_counts(self):
+        lldbutil.run_to_source_breakpoint(self, "// break here",
+                                          lldb.SBFileSpec("main.c"))
+
+        self.expect("expr patatino", substrs=['27'])
+        stats = self.get_stats()
+        self.verify_success_fail_count(stats, 'expressionEvaluation', 1, 0)
         self.expect("expr doesnt_exist", error=True,
                     substrs=["undeclared identifier 'doesnt_exist'"])
         # Doesn't successfully execute.
         self.expect("expr int *i = nullptr; *i", error=True)
         # Interpret an integer as an array with 3 elements is also a failure.
         self.expect("expr -Z 3 -- 1", error=True,
                     substrs=["expression cannot be used with --element-count"])
-        self.expect("statistics disable")
         # We should have gotten 3 new failures and the previous success.
-        self.expect("statistics dump", substrs=['expr evaluation successes : 1\n',
-                                                'expr evaluation failures : 3\n'])
-
-        # 'frame var' with disabled statistics shouldn't change stats.
-        self.expect("frame var", substrs=['27'])
+        stats = self.get_stats()
+        self.verify_success_fail_count(stats, 'expressionEvaluation', 1, 3)
 
         self.expect("statistics enable")
         # 'frame var' with enabled statistics will change stats.
         self.expect("frame var", substrs=['27'])
-        self.expect("statistics disable")
-        self.expect("statistics dump", substrs=['frame var successes : 1\n',
-                                                'frame var failures : 0\n'])
+        stats = self.get_stats()
+        self.verify_success_fail_count(stats, 'frameVariable', 1, 0)
+
+    def find_module_in_metrics(self, path, stats):
+        modules = stats['modules']
+        for module in modules:
+            if module['path'] == path:
+                return module
+        return None
+
+    def test_default_no_run(self):
+        """Test "statistics dump" without running the target.
+
+        When we don't run the target, we expect to not see any 'firstStopTime'
+        or 'launchOrAttachTime' top level keys that measure the launch or
+        attach of the target.
+
+        Output expected to be something like:
+
+        (lldb) statistics dump
+        {
+          "targetCreateTime": 0.26566899599999999,
+          "totalBreakpointResolveTime": 0.0031409419999999999,
+          "totalDebugInfoIndexTime": 0,
+          "totalDebugInfoParseTime": 0,
+          "totalDebugInfoSize": 2193,
+          "totalSymbolTableIndexTime": 0.056834488000000009,
+          "totalSymbolTableParseTime": 0.093979421999999979
+        }
+
+        """
+        target = self.createTestTarget()
+        stats = self.get_stats(log_path="/tmp/test_default_no_run.txt")
+        keys_exist = [
+            'expressionEvaluation',
+            'frameVariable',
+            'targetCreateTime',
+            'totalBreakpointResolveTime',
+            'totalDebugInfoIndexTime',
+            'totalDebugInfoParseTime',
+            'totalDebugInfoSize',
+            'totalSymbolTableIndexTime',
+            'totalSymbolTableParseTime',
+        ]
+        keys_missing = [
+            'firstStopTime',
+            'launchOrAttachTime',
+            'breakpoints',
+            'modules',
+            'settings'
+        ]
+        self.verify_keys(stats, '"stats"', keys_exist, keys_missing)
+        self.assertGreater(stats['targetCreateTime'], 0.0)
+        self.assertEqual(stats['totalBreakpointResolveTime'], 0.0)
+        self.assertGreater(stats['totalDebugInfoSize'], 0)
+        self.assertGreater(stats['totalSymbolTableIndexTime'], 0.0)
+        self.assertGreater(stats['totalSymbolTableParseTime'], 0.0)
+
+    def test_default_with_run(self):
+        """Test "statistics dump" when running the target to a breakpoint.
+
+        When we run the target, we expect to see 'launchOrAttachTime' and
+        'firstStopTime' top level keys.
+
+        Output expected to be something like:
+
+        (lldb) statistics dump
+        {
+          "targetCreateTime": 0.26566899599999999,
+          "totalBreakpointResolveTime": 0.0031409419999999999,
+          "totalDebugInfoIndexTime": 0,
+          "totalDebugInfoParseTime": 0,
+          "totalDebugInfoSize": 2193,
+          "totalSymbolTableIndexTime": 0.056834488000000009,
+          "totalSymbolTableParseTime": 0.093979421999999979
+        }
+
+        """
+        target = self.createTestTarget()
+        lldbutil.run_to_source_breakpoint(self, "// break here",
+                                          lldb.SBFileSpec("main.c"))
+        stats = self.get_stats(log_path="/tmp/test_default_no_run.txt")
+        keys_exist = [
+            'expressionEvaluation',
+            'firstStopTime',
+            'frameVariable',
+            'launchOrAttachTime',
+            'targetCreateTime',
+            'totalBreakpointResolveTime',
+            'totalDebugInfoIndexTime',
+            'totalDebugInfoParseTime',
+            'totalDebugInfoSize',
+            'totalSymbolTableIndexTime',
+            'totalSymbolTableParseTime',
+        ]
+        keys_missing = [
+            'breakpoints',
+            'modules',
+            'settings'
+        ]
+        self.verify_keys(stats, '"stats"', keys_exist, keys_missing)
+        self.assertGreater(stats['firstStopTime'], 0.0)
+        self.assertGreater(stats['launchOrAttachTime'], 0.0)
+        self.assertGreater(stats['targetCreateTime'], 0.0)
+        self.assertGreater(stats['totalBreakpointResolveTime'], 0.0)
+        self.assertGreater(stats['totalDebugInfoSize'], 0)
+        self.assertGreater(stats['totalSymbolTableIndexTime'], 0.0)
+        self.assertGreater(stats['totalSymbolTableParseTime'], 0.0)
+
+    def test_modules(self):
+        """Test "statistics dump --modules"
+
+        Output expected to be something like:
+
+        (lldb) statistics dump --modules
+        {
+          "targetCreateTime": 0.26566899599999999,
+          "totalBreakpointResolveTime": 0.0031409419999999999,
+          "totalDebugInfoIndexTime": 0,
+          "totalDebugInfoParseTime": 0.00037288300000000001,
+          "totalDebugInfoSize": 2193,
+          "totalSymbolTableIndexTime": 0.056834488000000009,
+          "totalSymbolTableParseTime": 0.093979421999999979,
+          "modules": [
+            {
+              "debugInfoIndexTime": 0,
+              "debugInfoParseTime": 0,
+              "debugInfoSize": 1139,
+              "path": "/.../TestStats.test_modules/a.out",
+              "symbolTableIndexTime": 2.3816e-05,
+              "symbolTableParseTime": 0.000163747,
+              "triple": "x86_64-apple-macosx11.0.0",
+              "uuid": "10531B95-4DF4-3FFE-9D51-549DD17435E2"
+            },
+            {
+              "debugInfoIndexTime": 0,
+              "debugInfoParseTime": 0,
+              "debugInfoSize": 1054,
+              "path": "/.../TestStats.test_modules/libload_a.dylib",
+              "symbolTableIndexTime": 2.7852999999999999e-05,
+              "symbolTableParseTime": 0.000110246,
+              "triple": "x86_64-apple-macosx11.0.0",
+              "uuid": "F0974CDE-309A-3837-9593-385ABDC93803"
+            },
+          ]
+        }
+
+        """
+        exe = self.getBuildArtifact("a.out")
+        target = self.createTestTarget(file_path=exe)
+        stats = self.get_stats(options="--modules",
+                               log_path="/tmp/test_default_no_run.txt")
+        keys_exist = [
+            'targetCreateTime',
+            'totalBreakpointResolveTime',
+            'totalDebugInfoIndexTime',
+            'totalDebugInfoParseTime',
+            'totalDebugInfoSize',
+            'totalSymbolTableIndexTime',
+            'totalSymbolTableParseTime',
+            'modules',
+        ]
+        keys_missing = [
+            'breakpoints',
+            'settings'
+        ]
+        self.verify_keys(stats, '"stats"', keys_exist, keys_missing)
+        exe_module = self.find_module_in_metrics(exe, stats)
+        module_keys = [
+            'debugInfoIndexTime',
+            'debugInfoParseTime',
+            'debugInfoSize',
+            'path',
+            'symbolTableIndexTime',
+            'symbolTableParseTime',
+            'triple',
+            'uuid',
+        ]
+        self.assertNotEqual(exe_module, None)
+        self.verify_keys(exe_module, 'module dict for "%s"' % (exe),
+                                 module_keys)
+
+    def test_breakpoints(self):
+        """Test "statistics dump --breakpoints"
+
+        Output expected to be something like:
+
+        (lldb) statistics dump --breakpoints
+        {
+          "targetCreateTime": 0.26566899599999999,
+          "totalBreakpointResolveTime": 0.0031409419999999999,
+          "totalDebugInfoIndexTime": 0,
+          "totalDebugInfoParseTime": 0.00037288300000000001,
+          "totalDebugInfoSize": 2193,
+          "totalSymbolTableIndexTime": 0.056834488000000009,
+          "totalSymbolTableParseTime": 0.093979421999999979
+          "breakpoints": [
+              {
+                "details": {...}.
+                "id": 1,
+                "resolveTime": 0.0029114369999999998
+              },
+            ]
+        }
+
+        """
+        target = self.createTestTarget()
+        self.runCmd("b main.cpp:7")
+        self.runCmd("b a_function")
+        stats = self.get_stats(options="--breakpoints")
+        keys_exist = [
+            'targetCreateTime',
+            'totalBreakpointResolveTime',
+            'totalDebugInfoIndexTime',
+            'totalDebugInfoParseTime',
+            'totalDebugInfoSize',
+            'totalSymbolTableIndexTime',
+            'totalSymbolTableParseTime',
+            'breakpoints',
+        ]
+        keys_missing = [
+            'modules',
+            'settings'
+        ]
+        self.verify_keys(stats, '"stats"', keys_exist, keys_missing)
+        self.assertGreater(stats['totalBreakpointResolveTime'], 0.0)
+        self.assertGreater(stats['totalDebugInfoParseTime'], 0.0)
+        breakpoints = stats['breakpoints']
+        bp_keys_exist = [
+            'details',
+            'id',
+            'resolveTime'
+        ]
+        bk_keys_missing = [
+            'locations'
+        ]
+        for breakpoint in breakpoints:
+            self.verify_keys(breakpoint, 'stats["breakpoints"]',
+                                     bp_keys_exist, bk_keys_missing)
+
+    def test_locations(self):
+        """Test "statistics dump --locations"
+
+        Output expected to be something like:
+
+        (lldb) statistics dump --locations
+        {
+          "targetCreateTime": 0.26566899599999999,
+          "totalBreakpointResolveTime": 0.0031409419999999999,
+          "totalDebugInfoIndexTime": 0,
+          "totalDebugInfoParseTime": 0.00037288300000000001,
+          "totalDebugInfoSize": 2193,
+          "totalSymbolTableIndexTime": 0.056834488000000009,
+          "totalSymbolTableParseTime": 0.093979421999999979
+          "breakpoints": [
+              {
+                "details": {...}.
+                "id": 1,
+                "locations": [...],
+                "resolveTime": 0.0029114369999999998
+              },
+            ]
+          }
+
+        """
+        target = self.createTestTarget()
+        self.runCmd("b main.cpp:7")
+        self.runCmd("b a_function")
+        stats = self.get_stats(options="--locations")
+        keys_exist = [
+            'targetCreateTime',
+            'totalBreakpointResolveTime',
+            'totalDebugInfoIndexTime',
+            'totalDebugInfoParseTime',
+            'totalDebugInfoSize',
+            'totalSymbolTableIndexTime',
+            'totalSymbolTableParseTime',
+            'breakpoints',
+        ]
+        keys_missing = [
+            'modules',
+            'settings'
+        ]
+        self.verify_keys(stats, '"stats"', keys_exist, keys_missing)
+        self.assertGreater(stats['totalBreakpointResolveTime'], 0.0)
+        self.assertGreater(stats['totalDebugInfoParseTime'], 0.0)
+        breakpoints = stats['breakpoints']
+        bp_keys_exist = [
+            'details',
+            'id',
+            'resolveTime',
+            'locations'
+        ]
+        for breakpoint in breakpoints:
+            self.verify_keys(breakpoint, 'stats["breakpoints"]',
+                                     bp_keys_exist, None)
+
+    def test_settings(self):
+        """Test "statistics dump --settings"
+
+        Output expected to be something like:
+
+        (lldb) statistics dump --settings
+        {
+          "targetCreateTime": 0.26566899599999999,
+          "totalBreakpointResolveTime": 0.0031409419999999999,
+          "totalDebugInfoIndexTime": 0,
+          "totalDebugInfoParseTime": 0.00037288300000000001,
+          "totalDebugInfoSize": 2193,
+          "totalSymbolTableIndexTime": 0.056834488000000009,
+          "totalSymbolTableParseTime": 0.093979421999999979
+          "settings": {
+            "target.arg0": "/.../commands/target/metrics/TestStats.test_settings/a.out",
+            "target.clang-module-search-paths": [],
+            "target.debug-file-search-paths": [],
+            "target.exec-search-paths": [
+              "/.../commands/target/metrics/TestStats.test_settings"
+            ],
+            "target.inline-breakpoint-strategy": "always",
+            "target.preload-symbols": true,
+            "target.run-args": [],
+            "target.skip-prologue": true,
+            "target.source-map": []
+            },
+          }
+
+        """
+        target = self.createTestTarget()
+        stats = self.get_stats(options="--settings")
+        keys_exist = [
+            'targetCreateTime',
+            'totalBreakpointResolveTime',
+            'totalDebugInfoIndexTime',
+            'totalDebugInfoParseTime',
+            'totalDebugInfoSize',
+            'totalSymbolTableIndexTime',
+            'totalSymbolTableParseTime',
+            'settings'
+        ]
+        keys_missing = [
+            'breakpoints',
+            'modules',
+        ]
+        self.verify_keys(stats, '"stats"', keys_exist, keys_missing)
+        settings = stats['settings']
+        settings_keys_exist = [
+            "target.arg0",
+            "target.clang-module-search-paths",
+            "target.debug-file-search-paths",
+            "target.exec-search-paths",
+            "target.inline-breakpoint-strategy",
+            "target.preload-symbols",
+            "target.run-args",
+            "target.skip-prologue",
+            "target.source-map",
+        ]
+        self.verify_keys(settings, 'stats["settings"]', settings_keys_exist)

lldb/test/API/functionalities/stats_api/TestStatisticsAPI.py

 # Test the SBAPI for GetStatistics()
 
 import json
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestStatsAPI(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
+    NO_DEBUG_INFO_TESTCASE = True
+
     def test_stats_api(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
         target = self.dbg.CreateTarget(exe)
 
         # Test enabling/disabling stats
         self.assertFalse(target.GetCollectingStats())
         target.SetCollectingStats(True)
         self.assertTrue(target.GetCollectingStats())
         target.SetCollectingStats(False)
         self.assertFalse(target.GetCollectingStats())
 
         # Test the function to get the statistics in JSON'ish.
         stats = target.GetStatistics()
         stream = lldb.SBStream()
         res = stats.GetAsJSON(stream)
-        stats_json = sorted(json.loads(stream.GetData()))
-        self.assertEqual(len(stats_json), 4)
-        self.assertIn("Number of expr evaluation failures", stats_json)
-        self.assertIn("Number of expr evaluation successes", stats_json)
-        self.assertIn("Number of frame var failures", stats_json)
-        self.assertIn("Number of frame var successes", stats_json)
+        stats_json = json.loads(stream.GetData())
+        self.assertEqual('expressionEvaluation' in stats_json, True,
+                'Make sure the "expressionEvaluation" key in in target.GetStatistics()')
+        self.assertEqual('frameVariable' in stats_json, True,
+                'Make sure the "frameVariable" key in in target.GetStatistics()')
+        expressionEvaluation = stats_json['expressionEvaluation']
+        self.assertEqual('successes' in expressionEvaluation, True,
+                'Make sure the "successes" key in in "expressionEvaluation" dictionary"')
+        self.assertEqual('failures' in expressionEvaluation, True,
+                'Make sure the "failures" key in in "expressionEvaluation" dictionary"')
+        frameVariable = stats_json['frameVariable']
+        self.assertEqual('successes' in frameVariable, True,
+                'Make sure the "successes" key in in "frameVariable" dictionary"')
+        self.assertEqual('failures' in frameVariable, True,
+                'Make sure the "failures" key in in "frameVariable" dictionary"')