[lldb/Plugins] Add ability to fetch crash information on crashed processes

[mib]

Summary

Currently, in macOS, when a process crashes, lldb halts inside the
implementation disassembly without yielding any useful information.
The only way to get more information is to detach from the process, then wait
for ReportCrash to generate a report, find the report, then see what error
message was included in it. Instead of waiting for this to happen, lldb could
locate the error_string and make it available to the user.

This patch addresses this issue by enabling the user to fetch extended
crash information for crashed processes using process status --verbose.

Depending on the platform, this will try to gather different crash information
into an structured data dictionnary. This dictionnary is generic and extensible,
as it contains an array for each different type of crash information.

On Darwin Platforms, lldb will iterate over each of the target's images,
extract their __crash_info section and generated a StructuredData::Array
containing, in each entry, the module spec, its UUID, the crash messages
and the abort cause. The array will be inserted into the platform's
m_extended_crash_info dictionnary and FetchExtendedCrashInformation will
return its JSON representation like this:

{
  "crash-info annotations": [
    {
      "abort-cause": 0,
      "image": "/usr/lib/system/libsystem_malloc.dylib",
      "message": "main(76483,0x1000cedc0) malloc: *** error for object 0x1003040a0: pointer being freed was not allocated",
      "message2": "",
      "uuid": "5747D0C9-900D-3306-8D70-1E2EA4B7E821"
    },
    ...
  ],
  ...
}

This crash information can also be fetched using the SB API or lldb-rpc protocol
using SBTarget::GetExtendedCrashInformation().

rdar://37736535

Signed-off-by: Med Ismail Bennani <[e-mail]>

[mib]

Run clang-format

[teemperor]

I have some comments (beside my usual documentation spam). But otherwise looks good to me.

lldb/bindings/interface/SBProcess.i

196 ↗

(On Diff #244793)

documentation.

lldb/include/lldb/Target/Process.h

1333

Documentation pls

2635

Why make this a typedef'd anonymous struct?

Also maybe link to what struct this is mapping to (I assume this layout is somewhere on disk). That would also explain the mysterious type comments behind.

2646

documentation :p

2655

If this would return StructuredData then the structs above could be hidden in the implementation. Just a suggestion.

(Also documentation)

lldb/packages/Python/lldbsuite/test/commands/process/crash-info/TestProcessCrashInfo.py

5 ↗

(On Diff #244793)

You don't need that if you don't use print in your test.

19 ↗

(On Diff #244793)

I think I removed that comment from most tests, so you can also remove it here (it really doesn't tell me anything that isn't obvious).

64 ↗

(On Diff #244793)

self.assertIn and you'll get a nice error message when this fails.

lldb/source/Commands/CommandObjectProcess.cpp

1557

I think there should be a the before the process'

1565

If you don't accept arguments you should check that there are no arguments or otherwise throw an error. Currently process crash-info banana doesn't give an error.

1581

Shouldn't that have a return (otherwise this dereferences the pointer below).

lldb/source/Target/Process.cpp

1133 ↗

(On Diff #244793)

You can omit .AsCString(). when doing LLDB_LOG

1184 ↗

(On Diff #244793)

.back() ?

1190 ↗

(On Diff #244793)

early exit/

1197 ↗

(On Diff #244793)

.back()

[labath]

All of this code you're adding to Process.cpp is extremely specific to one platform's notion of "crash info". This should be factored out so that macos-specific details live inside some macos class. (In the current setup, it's probably easiest to put it in PlatformDarwin, or some subclass thereof).

[mib]

Moved implementation from Process to Platform / PlatformDarwin and made it more generic and extensive so other platforms could also use it.
Added documentation and addressed comments.

[JDevlieghere]

lldb/include/lldb/Target/Platform.h

838

I had a hard time understanding this sentence. Is the crash information type the key of the entry or the values in the array?

882

I find it suspicious that this member is stored here but not used. Does it need to be stored in the first place? Given the FetchExtendedCrashInformation I'd expect these dictionaries to be different per target?

lldb/source/Commands/CommandObjectPlatform.cpp

1520 ↗

(On Diff #245424)

This comment is useless.

1521 ↗

(On Diff #245424)

As I've said in other reviews I really dislike the #pragma mark. It's fine if the file already uses them but I really don't want to encourage new ones being added.

1541 ↗

(On Diff #245424)

Shouldn't you update the return status? Same below.

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

1514

The braces are inconsistent with the single-line ifs below. Why not wrap this log statement in the if check below?

if (!annotations)
    LLDB_LOG(log, "Couldn't extract crash information annotations")
else
    m_extended_crash_info->AddItem("crash-info annotations", annotations);

If you want the log statement to stay close to the ExtractCrashInfoAnnotations call (which I think you should), you could move the !m_extended_crash_info check up.

1596

braces

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.h

93

Assuming the header defines this struct, why not do

#ifdef HAVE_CRASHREPORTERCLIENT_H 
#include <CrashReporterClient.h> 
#else 
struct CrashInfoAnnotations {
  ...
}
#endif

124

The log is a singleton, why pass it around?

[JDevlieghere]

This looks like a great feature, I see myself using this a lot in the future. Thanks for working on this!

[mib]

lldb/include/lldb/Target/Platform.h

838

As I was trying to explain it on the diff summary, the "crash information type" (i.e. `crash-info annotations) is the key of the dictionary entry and the value is a dictionary array that contains all the entries for that specific crash information type

882

I did that so other platforms just need to implement FetchExtendedCrashInformation and also to make sure the SBAPI method keeps the same behaviour regardless of the platform.

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.h

93

The struct have a different name in the header (which is not a big deal), but I don't see the point of including the header if I give the structure definition below it.

I put the header comment following @teemperor's feedback (https://reviews.llvm.org/D74657#inline-679127) but maybe I could get rid of it ?

[mib]

In D74657#1883019, @JDevlieghere wrote:

This looks like a great feature, I see myself using this a lot in the future. Thanks for working on this!

Appreciated it!

[JDevlieghere]

lldb/include/lldb/Target/Platform.h

838

Would you mind updating the comment to explain it that way?

882

I'm not sure I understand how that answers my questions. The SB API calls FetchExtendedCrashInformation, what does it care about the member? Why not return a new DictionarySP every time?

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.h

93

I'll leave it up to your discretion, but I'd either specify the struct myself and say it's defined in CrashReporterClient.h, or alternatively put the ifdefs in the code and include the header and typedef it if the header is available, and use the custom struct otherwise, which means we still have the layout and type info Raphael asked about.

[mib]

Update documentation.
Address Jonas' comments.

[labath]

This looks a bit better, but my the purpose of my previous command was not to move the location of the cli command itself -- I think it was ok just where it was. The fact that the part of the functionality is implemented in the Platform class does not mean the cli command has to be there.

lldb/source/Commands/CommandObjectPlatform.cpp

1574–1577 ↗

(On Diff #245528)

I am not sure if this command really belongs here. If definitely doesn't fit the description "Commands to query, launch and attach to processes on the current platform.", and if you look at the subcommands, you see that these are all things that you do *before* you get an actual running process. "crash-info" is the exact opposite -- it only makes sense *after* you have a process.

The "process" (where you had it originally) command tree contains commands for interaction with a running process (although it also overlaps these commands somewhat :/). This command is pretty similar to "process status" so I think it makes sense for it to be next to it (in fact, it is so similar, that I'd consider putting this under some "verbose" switch of process status).

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.h

93

I don't think it makes sense to include the system definition if you're going to provide the alternative -- either you support both cross and native scenarios (in which case you can use the hand-rolled version everywhere), or you just support the native one (and you just use the system version). That said, if the struct contains pointer members, I am not sure if you can actually use the native struct like that. What if the process you're debugging is 32-bit ?

And whatever you do, please don't include a system header in the middle of a class.

[mib]

lldb/source/Commands/CommandObjectPlatform.cpp

1574–1577 ↗

(On Diff #245528)

I misunderstood your request. I'm moving it under "process status --verbose".

[mib]

Moved invocation to process status --verbose.
Removed macOS' CrashReporterClient header.

[JDevlieghere]

A few small nits inline, but this LGTM if Pavel is on board.

lldb/source/Commands/CommandObjectProcess.cpp

1260

Please use single quotes like we do for other command objects.

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

1541

You can move this out of the loop

[labath]

In D74657#1885361, @JDevlieghere wrote:

A few small nits inline, but this LGTM if Pavel is on board.

We're getting close, but I still see some room for improvement. :)

lldb/bindings/interface/SBPlatform.i

195–198 ↗

(On Diff #245721)

If we keep the this way, then the user will have to remember to get the correct platform in order to ask it for the crash info. That's not the end of the world, but it might be better if this was a method on the SBTarget class, which would automatically consult the target's current platform.

lldb/source/Commands/CommandObjectProcess.cpp

1288–1291

So, this will print an error if we don't get a crash information for _any_ reason (process did not crash, platform does not support crash info, ...), is that right?

That seems overly aggressive. I think this should be more nuanced. Maybe if FetchExtendedCrashInformation returned Expected<StructuredDataSP>, then you could do something like

• if the result is an error => something really went wrong => print the error message
• nullptr => not an error, but we also didn't get anything => don't print anything
• an actual dictionary => hurray => print the crash info

Then the default implementation can return nullptr, and in PlatformDarwin you can precisely decide what treatment does a certain situation deserve (e.g. whether not being able to find the __crash_info section is an error or just "nothing").

1294

Should you maybe print some kind of a header to make it clear that what follows is the crash information?

lldb/test/API/functionalities/process_crash_info/TestProcessCrashInfo.py

38

Besides the "positive" test, I think it would be also good to have some tests for the "negative" cases. E.g. a case where the process did not crash, or when we have not even launched it yet.

[mib]

Addressed Pavel's comments.
Add "negative" tests.

[mib]

Removed old revision artifacts
Renamed test_on_launch to test_before_launch

[JDevlieghere]

LGTM'ing for Pavel by proxy as discussed on IRC.

[labath]

A couple of more comments from me. The two on the test are minor, but I think it would be good to resolve the one about the SB method placement soon, before this thing starts having users.

lldb/bindings/interface/SBTarget.i

952–957

I know it was my idea to have this on the SBTarget class, but I think we should move this once more :/. I mean, this is definitely better than the SBPlatform class (which is what I was really trying to say before), but I think SBProcess would be even better here. The SBTarget methods are things that (more or less) make sense even when you don't have an actual process around. However, "crash info" (I think) only makes sense once you have an actual process, and so it would make sense to have it somewhere near SBProcess::GetState/GetDescription. It would also be more symmetric with the CLI interface for this, which lives under the "process" command tree.

The internal interfaces might also be better off passing a Process object (instead of Target) around, but that is not as important..

Sorry. :(

lldb/test/API/functionalities/process_crash_info/TestProcessCrashInfo.py

20

We have a line_number utility function to avoid hardcoding line numbers like this.

65–82

I'm hoping that these two tests can actually run (and pass) on non-darwin systems too...

[mib]

Addressed Pavel's request in D75049

lldb/bindings/interface/SBTarget.i

#endif
     GetStackRedZoneSize();
 
     lldb::SBLaunchInfo
     GetLaunchInfo () const;
 
     void
     SetLaunchInfo (const lldb::SBLaunchInfo &launch_info);
 
+    %feature("autodoc", "
+    Returns the platform's process extended crash information.") GetExtendedCrashInformation;
+    lldb::SBStructuredData
+    GetExtendedCrashInformation ();
+
+
     void SetCollectingStats(bool v);
 
     bool GetCollectingStats();
 
     lldb::SBStructuredData GetStatistics();
 
     bool
     operator == (const lldb::SBTarget &rhs) const;

lldb/include/lldb/API/SBTarget.h

lldb::SBValue EvaluateExpression(const char *expr,
                                    const SBExpressionOptions &options);
 
   lldb::addr_t GetStackRedZoneSize();
 
   lldb::SBLaunchInfo GetLaunchInfo() const;
 
   void SetLaunchInfo(const lldb::SBLaunchInfo &launch_info);
 
+  SBStructuredData GetExtendedCrashInformation();
+
 protected:
   friend class SBAddress;
   friend class SBBlock;
   friend class SBBreakpointList;
   friend class SBBreakpointNameImpl;
   friend class SBDebugger;
   friend class SBExecutionContext;
   friend class SBFunction;
   friend class SBInstruction;
   friend class SBModule;
+  friend class SBPlatform;
   friend class SBProcess;
   friend class SBSection;
   friend class SBSourceManager;
   friend class SBSymbol;
   friend class SBValue;
   friend class SBVariablesOptions;
 
   // Constructors are private, use static Target::Create function to create an

lldb/include/lldb/Target/Platform.h

 
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Host/File.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/Timeout.h"
 #include "lldb/Utility/UserIDResolver.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-public.h"
 #include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 
public:
   ///     If an error occurred during the connect then this object will
   ///     contain the error message.
   ///
   /// \return
   ///     The number of processes we are successfully connected to.
   virtual size_t ConnectToWaitingProcesses(lldb_private::Debugger &debugger,
                                            lldb_private::Status &error);
 
+  /// Gather all of crash informations into a structured data dictionnary.
+  ///
+  /// If the platform have a crashed process with crash information entries,
+  /// gather all the entries into an structured data dictionnary or return a
+  /// nullptr. This dictionnary is generic and extensible, as it contains an
+  /// array for each different type of crash information.
+  ///
+  /// \param[in] target
+  ///     The target running the crashed process.
+  ///
+  /// \return
+  ///     A structured data dictionnary containing at each entry, the crash
+  ///     information type as the entry key and the matching  an array as the
+  ///     entry value. \b nullptr if not implemented or  if the process has no
+  ///     crash information entry. \b error if an error occured.
+  virtual llvm::Expected<StructuredData::DictionarySP>
+  FetchExtendedCrashInformation(lldb_private::Target &target) {
+    return nullptr;
+  }
+
 protected:
   bool m_is_host;
   // Set to true when we are able to actually set the OS version while being
   // connected. For remote platforms, we might set the version ahead of time
   // before we actually connect and this version might change when we actually
   // connect to a remote platform. For the host platform this will be set to
   // the once we call HostInfo::GetOSVersion().
   bool m_os_version_set_while_connected;
protected:
   std::string m_rsync_prefix;
   bool m_supports_ssh;
   std::string m_ssh_opts;
   bool m_ignores_remote_hostname;
   std::string m_local_cache_directory;
   std::vector<ConstString> m_trap_handlers;
   bool m_calculated_trap_handlers;
   const std::unique_ptr<ModuleCache> m_module_cache;
 
   /// Ask the Platform subclass to fill in the list of trap handler names
   ///
   /// For most Unix user process environments, this will be a single function
   /// name, _sigtramp.  More specialized environments may have additional
   /// handler names.  The unwinder code needs to know when a trap handler is
   /// on the stack because the unwind rules for the frame that caused the trap
   /// are different.
   ///

lldb/include/lldb/Target/Process.h

/// \see Process::Notifications
   ///     passed as LLDB_INVALID_ADDRESS.
   ///
   /// \param [in] image_count
   ///     The number of shared libraries that are present in this process, if
   ///     that is appropriate for this platofrm  Else this may be passed as
   ///     LLDB_INVALID_ADDRESS.
   ///
   /// \return
-  ///     A StructureDataSP object which, if non-empty, will contain the
+  ///     A StructuredDataSP object which, if non-empty, will contain the
   ///     information the DynamicLoader needs to get the initial scan of
   ///     solibs resolved.
   virtual lldb_private::StructuredData::ObjectSP
   GetLoadedDynamicLibrariesInfos(lldb::addr_t image_list_address,
                                  lldb::addr_t image_count) {
     return StructuredData::ObjectSP();
   }
 
public:
   ///
   /// \return
   ///     The textual description of why the process exited, or nullptr
   ///     if there is no description available.
   const char *GetExitDescription();
 
   virtual void DidExit() {}
 
   /// Get the Modification ID of the process.
   ///
   /// \return
   ///     The modification ID of the process.
   ProcessModID GetModID() const { return m_mod_id; }
 
   const ProcessModID &GetModIDRef() const { return m_mod_id; }
 
   uint32_t GetStopID() const { return m_mod_id.GetStopID(); }
struct PreResumeCallbackAndBaton {
     bool operator== (const PreResumeCallbackAndBaton &rhs) {
       return callback == rhs.callback && baton == rhs.baton;
     }
   };
 
   using StructuredDataPluginMap =
       std::map<ConstString, lldb::StructuredDataPluginSP>;
 
   // Member variables
   std::weak_ptr<Target> m_target_wp; ///< The target that owns this process.
   ThreadSafeValue<lldb::StateType> m_public_state;
   ThreadSafeValue<lldb::StateType>
       m_private_state;                     // The actual state of our process
   Broadcaster m_private_state_broadcaster; // This broadcaster feeds state
                                            // changed events into the private
                                            // state thread's listener.
   Broadcaster m_private_state_control_broadcaster; // This is the control
                                                    // broadcaster, used to
                                                    // pause, resume & stop the
                                                    // private state thread.
   lldb::ListenerSP m_private_state_listener_sp; // This is the listener for the
                                                 // private state thread.
   HostThread m_private_state_thread; ///< Thread ID for the thread that watches
                                      ///internal state events
   ProcessModID m_mod_id; ///< Tracks the state of the process over stops and
                          ///other alterations.
   uint32_t m_process_unique_id; ///< Each lldb_private::Process class that is
                                 ///created gets a unique integer ID that
                                 ///increments with each new instance
   uint32_t m_thread_index_id;   ///< Each thread is created with a 1 based index
                                 ///that won't get re-used.
   std::map<uint64_t, uint32_t> m_thread_id_to_index_id_map;
   int m_exit_status; ///< The exit status of the process, or -1 if not set.
   std::string m_exit_string; ///< A textual description of why a process exited.
   std::mutex m_exit_status_mutex; ///< Mutex so m_exit_status m_exit_string can
                                   ///be safely accessed from multiple threads
   std::recursive_mutex m_thread_mutex;

lldb/source/API/SBTarget.cpp

void SBTarget::SetLaunchInfo(const lldb::SBLaunchInfo &launch_info) {
   LLDB_RECORD_METHOD(void, SBTarget, SetLaunchInfo,
                      (const lldb::SBLaunchInfo &), launch_info);
 
   TargetSP target_sp(GetSP());
   if (target_sp)
     m_opaque_sp->SetProcessLaunchInfo(launch_info.ref());
 }
 
+SBStructuredData SBTarget::GetExtendedCrashInformation() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBTarget,
+                             GetExtendedCrashInformation);
+  SBStructuredData data;
+  TargetSP target_sp(GetSP());
+  if (!target_sp)
+    return LLDB_RECORD_RESULT(data);
+
+  PlatformSP platform_sp = target_sp->GetPlatform();
+
+  if (!target_sp)
+    return LLDB_RECORD_RESULT(data);
+
+  auto expected_data =
+      platform_sp->FetchExtendedCrashInformation(*target_sp.get());
+
+  if (!expected_data)
+    return LLDB_RECORD_RESULT(data);
+
+  StructuredData::ObjectSP fetched_data = *expected_data;
+  data.m_impl_up->SetObjectSP(fetched_data);
+  return LLDB_RECORD_RESULT(data);
+}
+
 namespace lldb_private {
 namespace repro {
 
 template <>
 void RegisterMethods<SBTarget>(Registry &R) {
   LLDB_REGISTER_CONSTRUCTOR(SBTarget, ());
   LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &));
   LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &));
void RegisterMethods<SBTarget>(Registry &R) {
   LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
                        (const char *));
   LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
                        (const char *, const lldb::SBExpressionOptions &));
   LLDB_REGISTER_METHOD(lldb::addr_t, SBTarget, GetStackRedZoneSize, ());
   LLDB_REGISTER_METHOD_CONST(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo, ());
   LLDB_REGISTER_METHOD(void, SBTarget, SetLaunchInfo,
                        (const lldb::SBLaunchInfo &));
+  LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTarget,
+                       GetExtendedCrashInformation, ());
   LLDB_REGISTER_METHOD(
       size_t, SBTarget, ReadMemory,
       (const lldb::SBAddress, void *, size_t, lldb::SBError &));
   LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions,
                        (lldb::SBAddress, const void *, size_t));
   LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget,
                        GetInstructionsWithFlavor,
                        (lldb::SBAddress, const char *, const void *, size_t));

lldb/source/Commands/CommandObjectProcess.cpp

bool DoExecute(Args &command, CommandReturnObject &result) override {
     }
 
     return result.Succeeded();
   }
 };
 
 // CommandObjectProcessStatus
 #pragma mark CommandObjectProcessStatus
+#define LLDB_OPTIONS_process_status
+#include "CommandOptions.inc"
 
 class CommandObjectProcessStatus : public CommandObjectParsed {
 public:
   CommandObjectProcessStatus(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "process status",
             "Show status and stop location for the current target process.",
             "process status",
-            eCommandRequiresProcess | eCommandTryTargetAPILock) {}
+            eCommandRequiresProcess | eCommandTryTargetAPILock),
+        m_options() {}
 
   ~CommandObjectProcessStatus() override = default;
 
+  Options *GetOptions() override { return &m_options; }
+
+  class CommandOptions : public Options {
+  public:
+    CommandOptions() : Options(), m_verbose(false) {}
+
+    ~CommandOptions() override = default;
+
+    Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
+                          ExecutionContext *execution_context) override {
+      const int short_option = m_getopt_table[option_idx].val;
+
+      switch (short_option) {
+      case 'v':
+        m_verbose = true;
+        break;
+      default:
+        llvm_unreachable("Unimplemented option");
+      }
+
+      return {};
+    }
+
+    void OptionParsingStarting(ExecutionContext *execution_context) override {
+      m_verbose = false;
+    }
+
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return llvm::makeArrayRef(g_process_status_options);
+    }
+
+    // Instance variables to hold the values for command options.
+    bool m_verbose;
+  };
+
+protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Stream &strm = result.GetOutputStream();
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
+
+    if (command.GetArgumentCount()) {
+      result.AppendError("'process status' takes no arguments");
+      result.SetStatus(eReturnStatusFailed);
+      return result.Succeeded();
+    }
+
     // No need to check "process" for validity as eCommandRequiresProcess
     // ensures it is valid
     Process *process = m_exe_ctx.GetProcessPtr();
     const bool only_threads_with_stop_reason = true;
     const uint32_t start_frame = 0;
     const uint32_t num_frames = 1;
     const uint32_t num_frames_with_source = 1;
     const bool stop_format = true;
     process->GetStatus(strm);
     process->GetThreadStatus(strm, only_threads_with_stop_reason, start_frame,
                              num_frames, num_frames_with_source, stop_format);
+
+    if (m_options.m_verbose) {
+      PlatformSP platform_sp = process->GetTarget().GetPlatform();
+      if (!platform_sp) {
+        result.AppendError("Couldn'retrieve the target's platform");
+        result.SetStatus(eReturnStatusFailed);
+        return result.Succeeded();
+      }
+
+      auto expected_crash_info =
+          platform_sp->FetchExtendedCrashInformation(process->GetTarget());
+
+      if (!expected_crash_info) {
+        result.AppendError(llvm::toString(expected_crash_info.takeError()));
+        result.SetStatus(eReturnStatusFailed);
         return result.Succeeded();
       }
+
+      StructuredData::DictionarySP crash_info_sp = *expected_crash_info;
+
+      if (crash_info_sp) {
+        strm.PutCString("Extended Crash Information:\n");
+        crash_info_sp->Dump(strm);
+      }
+    }
+
+    return result.Succeeded();
+  }
+
+private:
+  CommandOptions m_options;
 };
 
 // CommandObjectProcessHandle
 #define LLDB_OPTIONS_process_handle
 #include "CommandOptions.inc"
 
 #pragma mark CommandObjectProcessHandle
 

 
 // CommandObjectMultiwordProcess
 
 CommandObjectMultiwordProcess::CommandObjectMultiwordProcess(
     CommandInterpreter &interpreter)
     : CommandObjectMultiword(
           interpreter, "process",
           "Commands for interacting with processes on the current platform.",
           "process <subcommand> [<subcommand-options>]") {
   LoadSubCommand("attach",
                  CommandObjectSP(new CommandObjectProcessAttach(interpreter)));
   LoadSubCommand("launch",
                  CommandObjectSP(new CommandObjectProcessLaunch(interpreter)));
   LoadSubCommand("continue", CommandObjectSP(new CommandObjectProcessContinue(
                                  interpreter)));
   LoadSubCommand("connect",
                  CommandObjectSP(new CommandObjectProcessConnect(interpreter)));
   LoadSubCommand("detach",
                  CommandObjectSP(new CommandObjectProcessDetach(interpreter)));
   LoadSubCommand("load",
                  CommandObjectSP(new CommandObjectProcessLoad(interpreter)));
   LoadSubCommand("unload",
                  CommandObjectSP(new CommandObjectProcessUnload(interpreter)));
   LoadSubCommand("signal",
                  CommandObjectSP(new CommandObjectProcessSignal(interpreter)));
   LoadSubCommand("handle",
                  CommandObjectSP(new CommandObjectProcessHandle(interpreter)));
   LoadSubCommand("status",
                  CommandObjectSP(new CommandObjectProcessStatus(interpreter)));
   LoadSubCommand("interrupt", CommandObjectSP(new CommandObjectProcessInterrupt(
                                   interpreter)));
   LoadSubCommand("kill",
                  CommandObjectSP(new CommandObjectProcessKill(interpreter)));
   LoadSubCommand("plugin",
                  CommandObjectSP(new CommandObjectProcessPlugin(interpreter)));
   LoadSubCommand("save-core", CommandObjectSP(new CommandObjectProcessSaveCore(
                                   interpreter)));
 }
 
 CommandObjectMultiwordProcess::~CommandObjectMultiwordProcess() = default;

lldb/source/Commands/Options.td

def process_handle_stop : Option<"stop", "s">, Group<1>, Arg<"Boolean">,
     "received.">;
   def process_handle_notify : Option<"notify", "n">, Group<1>, Arg<"Boolean">,
     Desc<"Whether or not the debugger should notify the user if the signal is "
     "received.">;
   def process_handle_pass : Option<"pass", "p">, Group<1>, Arg<"Boolean">,
     Desc<"Whether or not the signal should be passed to the process.">;
 }
 
+let Command = "process status" in {
+  def process_status_verbose : Option<"verbose", "v">, Group<1>,
+    Desc<"Show verbose process status including extended crash information.">;
+}
+
 let Command = "script import" in {
   def script_import_allow_reload : Option<"allow-reload", "r">, Group<1>,
     Desc<"Allow the script to be loaded even if it was already loaded before. "
     "This argument exists for backwards compatibility, but reloading is always "
     "allowed, whether you specify it or not.">;
 }
 
 let Command = "script add" in {

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.h

 //===-- PlatformDarwin.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_PLATFORM_MACOSX_PLATFORMDARWIN_H
 #define LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMDARWIN_H
 
 #include "Plugins/Platform/POSIX/PlatformPOSIX.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/StructuredData.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/FileSystem.h"
 
 #include <string>
 #include <tuple>
 
 class PlatformDarwin : public PlatformPOSIX {
 public:
public:
   ParseVersionBuildDir(llvm::StringRef str);
 
   enum SDKType : unsigned {
     MacOSX = 0,
     iPhoneSimulator,
     iPhoneOS,
   };
 
+  llvm::Expected<lldb_private::StructuredData::DictionarySP>
+  FetchExtendedCrashInformation(lldb_private::Target &target) override;
+
 protected:
+  struct CrashInfoAnnotations {
+    uint64_t version;          // unsigned long
+    uint64_t message;          // char *
+    uint64_t signature_string; // char *
+    uint64_t backtrace;        // char *
+    uint64_t message2;         // char *
+    uint64_t thread;           // uint64_t
+    uint64_t dialog_mode;      // unsigned int
+    uint64_t abort_cause;      // unsigned int
+  };
+
+  /// Extract the `__crash_info` annotations from each of of the target's
+  /// modules.
+  ///
+  /// If the platform have a crashed processes with a `__crash_info` section,
+  /// extract the section to gather the messages annotations and the abort
+  /// cause.
+  ///
+  /// \param[in] target
+  ///     The target running the crashed process.
+  ///
+  /// \return
+  ///     A  structured data array containing at each entry in each entry, the
+  ///     module spec, its UUID, the crash messages and the abort cause.
+  ///     \b nullptr if process has no crash information annotations.
+  lldb_private::StructuredData::ArraySP
+  ExtractCrashInfoAnnotations(lldb_private::Target &target);
+
   void ReadLibdispatchOffsetsAddress(lldb_private::Process *process);
 
   void ReadLibdispatchOffsets(lldb_private::Process *process);
 
   virtual lldb_private::Status GetSharedModuleWithLocalCache(
       const lldb_private::ModuleSpec &module_spec, lldb::ModuleSP &module_sp,
       const lldb_private::FileSpecList *module_search_paths_ptr,
       lldb::ModuleSP *old_module_sp_ptr, bool *did_create_ptr);
 
   static bool SDKSupportsModules(SDKType sdk_type, llvm::VersionTuple version);
 
   static bool SDKSupportsModules(SDKType desired_type,
                                  const lldb_private::FileSpec &sdk_path);

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

 #include <memory>
 #include <mutex>
 
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/BreakpointSite.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
+#include "lldb/Core/Section.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/XML.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Symbol/LocateSymbolFile.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
if (build_str.consume_front("(")) {
       size_t pos = build_str.find(')');
       build = build_str.slice(0, pos);
     }
   }
 
   return std::make_tuple(version, build);
 }
 
+llvm::Expected<StructuredData::DictionarySP>
+PlatformDarwin::FetchExtendedCrashInformation(lldb_private::Target &target) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+  StructuredData::ArraySP annotations = ExtractCrashInfoAnnotations(target);
+
+  if (!annotations || !annotations->GetSize()) {
+    LLDB_LOG(log, "Couldn't extract crash information annotations");
+    return nullptr;
+  }
+
+  StructuredData::DictionarySP extended_crash_info =
+      std::make_shared<StructuredData::Dictionary>();
+
+  extended_crash_info->AddItem("crash-info annotations", annotations);
+
+  return extended_crash_info;
+}
+
+StructuredData::ArraySP
+PlatformDarwin::ExtractCrashInfoAnnotations(Target &target) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+  ConstString section_name("__crash_info");
+  ProcessSP process_sp = target.GetProcessSP();
+  StructuredData::ArraySP array_sp = std::make_shared<StructuredData::Array>();
+
+  for (ModuleSP module : target.GetImages().Modules()) {
+    SectionList *sections = module->GetSectionList();
+
+    std::string module_name = module->GetSpecificationDescription();
+
+    // The DYDL module is skipped since it's always loaded when running the
+    // binary.
+    if (module_name == "/usr/lib/dyld")
+      continue;
+
+    if (!sections) {
+      LLDB_LOG(log, "Module {0} doesn't have any section!", module_name);
+      continue;
+    }
+
+    SectionSP crash_info = sections->FindSectionByName(section_name);
+    if (!crash_info) {
+      LLDB_LOG(log, "Module {0} doesn't have section {1}!", module_name,
+               section_name);
+      continue;
+    }
+
+    addr_t load_addr = crash_info->GetLoadBaseAddress(&target);
+
+    if (load_addr == LLDB_INVALID_ADDRESS) {
+      LLDB_LOG(log, "Module {0} has an invalid '{1}' section load address: {2}",
+               module_name, section_name, load_addr);
+      continue;
+    }
+
+    Status error;
+    CrashInfoAnnotations annotations;
+    size_t expected_size = sizeof(CrashInfoAnnotations);
+    size_t bytes_read = process_sp->ReadMemoryFromInferior(
+        load_addr, &annotations, expected_size, error);
+
+    if (expected_size != bytes_read || error.Fail()) {
+      LLDB_LOG(log, "Failed to read {0} section from memory in module {1}: {2}",
+               section_name, module_name, error);
+      continue;
+    }
+
+    // initial support added for version 5
+    if (annotations.version < 5) {
+      LLDB_LOG(log,
+               "Annotation version lower than 5 unsupported! Module {0} has "
+               "version {1} instead.",
+               module_name, annotations.version);
+      continue;
+    }
+
+    if (!annotations.message) {
+      LLDB_LOG(log, "No message available for module {0}.", module_name);
+      continue;
+    }
+
+    std::string message;
+    bytes_read =
+        process_sp->ReadCStringFromMemory(annotations.message, message, error);
+
+    if (message.empty() || bytes_read != message.size() || error.Fail()) {
+      LLDB_LOG(log, "Failed to read the message from memory in module {0}: {1}",
+               module_name, error);
+      continue;
+    }
+
+    // Remove trailing newline from message
+    if (message.back() == '\n')
+      message.pop_back();
+
+    if (!annotations.message2)
+      LLDB_LOG(log, "No message2 available for module {0}.", module_name);
+
+    std::string message2;
+    bytes_read = process_sp->ReadCStringFromMemory(annotations.message2,
+                                                   message2, error);
+
+    if (!message2.empty() && bytes_read == message2.size() && error.Success())
+      if (message2.back() == '\n')
+        message2.pop_back();
+
+    StructuredData::DictionarySP entry_sp =
+        std::make_shared<StructuredData::Dictionary>();
+
+    entry_sp->AddStringItem("image", module->GetFileSpec().GetPath(false));
+    entry_sp->AddStringItem("uuid", module->GetUUID().GetAsString());
+    entry_sp->AddStringItem("message", message);
+    entry_sp->AddStringItem("message2", message2);
+    entry_sp->AddIntegerItem("abort-cause", annotations.abort_cause);
+
+    array_sp->AddItem(entry_sp);
+  }
+
+  return array_sp;
+}
+
 void PlatformDarwin::AddClangModuleCompilationOptionsForSDKType(
     Target *target, std::vector<std::string> &options, SDKType sdk_type) {
   const std::vector<std::string> apple_arguments = {
       "-x",       "objective-c++", "-fobjc-arc",
       "-fblocks", "-D_ISO646_H",   "-D__ISO646_H",
       "-fgnuc-version=4.2.1"};
 
   options.insert(options.end(), apple_arguments.begin(), apple_arguments.end());

lldb/test/API/functionalities/process_crash_info/Makefile

+C_SOURCES := main.c
+
+include Makefile.rules
+

lldb/test/API/functionalities/process_crash_info/TestProcessCrashInfo.py

+"""
+Test lldb process crash info.
+"""
+
+import os
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class PlatformProcessCrashInfoTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        TestBase.setUp(self)
+        self.runCmd("settings set auto-confirm true")
+        self.source = "main.c"
+        self.line = 3
+
+    def tearDown(self):
+        self.runCmd("settings clear auto-confirm")
+        TestBase.tearDown(self)
+
+    @skipUnlessDarwin
+    def test_cli(self):
+        """Test that `process status --verbose` fetches the extended crash
+        information dictionnary from the command-line properly."""
+        self.build()
+        exe = self.getBuildArtifact("a.out")
+        self.expect("file " + exe,
+                    patterns=["Current executable set to .*a.out"])
+
+        self.expect('process launch',
+                    patterns=["Process .* launched: .*a.out"])
+
+        self.expect('process status --verbose',
+                    patterns=["\"message\".*pointer being freed was not allocated"])
+
+
+    @skipUnlessDarwin
+    def test_api(self):
+        """Test that lldb can fetch a crashed process' extended crash information
+        dictionnary from the api properly."""
+        self.build()
+        target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+        self.assertTrue(target, VALID_TARGET)
+
+        target.LaunchSimple(None, None, os.getcwd())
+
+        stream = lldb.SBStream()
+        self.assertTrue(stream)
+
+        crash_info = target.GetExtendedCrashInformation()
+
+        error = crash_info.GetAsJSON(stream)
+
+        self.assertTrue(error.Success())
+
+        self.assertTrue(crash_info.IsValid())
+
+        self.assertIn("pointer being freed was not allocated", stream.GetData())
+
+    @skipUnlessDarwin
+    def test_before_launch(self):
+        """Test that lldb doesn't fetch the extended crash information
+        dictionnary from if the process wasn't launched yet."""
+        self.build()
+        target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+        self.assertTrue(target, VALID_TARGET)
+
+        stream = lldb.SBStream()
+        self.assertTrue(stream)
+
+        crash_info = target.GetExtendedCrashInformation()
+
+        error = crash_info.GetAsJSON(stream)
+        self.assertFalse(error.Success())
+        self.assertIn("No structured data.", error.GetCString())
+
+    @skipUnlessDarwin
+    def test_on_sane_process(self):
+        """Test that lldb doesn't fetch the extended crash information
+        dictionnary from a 'sane' stopped process."""
+        self.build()
+        target, _, _, _ = lldbutil.run_to_line_breakpoint(self, lldb.SBFileSpec(self.source),
+                                        self.line)
+
+        stream = lldb.SBStream()
+        self.assertTrue(stream)
+
+        crash_info = target.GetExtendedCrashInformation()
+
+        error = crash_info.GetAsJSON(stream)
+        self.assertFalse(error.Success())
+        self.assertIn("No structured data.", error.GetCString())

lldb/test/API/functionalities/process_crash_info/main.c

+#include <stdlib.h>
+int main() {
+  int *var = malloc(sizeof(int));
+  free(var);
+  free(var);
+  return 0;
+}