[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

1482 ↗

(On Diff #244793)

I think there should be a the before the process'

1490 ↗

(On Diff #244793)

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.

1506 ↗

(On Diff #244793)

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?

881

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

This comment is useless.

1521

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

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

881

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?

881

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

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

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 ↗

(On Diff #245721)

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

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 ↗

(On Diff #245721)

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 ↗

(On Diff #245721)

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

37 ↗

(On Diff #245721)

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 ↗

(On Diff #245985)

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 ↗

(On Diff #245985)

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

65–82 ↗

(On Diff #245985)

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/SBPlatform.i

public:
     GetFilePermissions (const char *path);
 
     lldb::SBError
     SetFilePermissions (const char *path, uint32_t file_permissions);
 
     lldb::SBUnixSignals
     GetUnixSignals();
 
+    %feature("autodoc", "
+    Returns the platform's process extended crash information.") GetExtendedCrashInformation;
+    lldb::SBStructuredData
+    GetExtendedCrashInformation (lldb::SBTarget& target);
+
 };
 
 } // namespace lldb

lldb/include/lldb/API/SBPlatform.h

 //===-- SBPlatform.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_API_SBPLATFORM_H
 #define LLDB_API_SBPLATFORM_H
 
 #include "lldb/API/SBDefines.h"
+#include "lldb/API/SBStructuredData.h"
 
 #include <functional>
 
 struct PlatformConnectOptions;
 struct PlatformShellCommand;
 
 namespace lldb {
 
MakeDirectory(const char *path,
                 uint32_t file_permissions = eFilePermissionsDirectoryDefault);
 
   uint32_t GetFilePermissions(const char *path);
 
   SBError SetFilePermissions(const char *path, uint32_t file_permissions);
 
   SBUnixSignals GetUnixSignals() const;
 
+  SBStructuredData GetExtendedCrashInformation(SBTarget &target);
+
 protected:
   friend class SBDebugger;
   friend class SBTarget;
 
   lldb::PlatformSP GetSP() const;
 
   void SetSP(const lldb::PlatformSP &platform_sp);
 

lldb/include/lldb/API/SBStructuredData.h

public:
   /// \return
   ///     Returns the byte size needed to completely write the string value at
   ///     \a dst in all cases.
   size_t GetStringValue(char *dst, size_t dst_len) const;
 
 protected:
   friend class SBTraceOptions;
   friend class SBDebugger;
+  friend class SBPlatform;
   friend class SBTarget;
   friend class SBThread;
   friend class SBThreadPlan;
   friend class SBBreakpoint;
   friend class SBBreakpointLocation;
   friend class SBBreakpointName;
 
   StructuredDataImplUP m_impl_up;
 };
 } // namespace lldb
 
 #endif // LLDB_API_SBSTRUCTUREDDATA_H

lldb/include/lldb/API/SBTarget.h

protected:
   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 processes 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 an array for
+  ///     each different crash information type. Or a nullptr if the process has
+  ///     no crash information entry.
+  virtual 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;
+  StructuredData::DictionarySP m_extended_crash_info;
 
   /// 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/SBPlatform.cpp

 //===-- SBPlatform.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/API/SBPlatform.h"
 #include "SBReproducerPrivate.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBLaunchInfo.h"
+#include "lldb/API/SBTarget.h"
 #include "lldb/API/SBUnixSignals.h"
+#include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Host/File.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/Status.h"
 
 #include "llvm/Support/FileSystem.h"
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBUnixSignals, SBPlatform,
                                    GetUnixSignals);
 
   if (auto platform_sp = GetSP())
     return LLDB_RECORD_RESULT(SBUnixSignals{platform_sp});
 
   return LLDB_RECORD_RESULT(SBUnixSignals());
 }
 
+SBStructuredData SBPlatform::GetExtendedCrashInformation(SBTarget &target) {
+  LLDB_RECORD_METHOD(lldb::SBStructuredData, SBPlatform,
+                     GetExtendedCrashInformation, (lldb::SBTarget &), target);
+
+  SBStructuredData data;
+  PlatformSP platform_sp(GetSP());
+  if (!platform_sp)
+    return LLDB_RECORD_RESULT(data);
+
+  StructuredData::ObjectSP fetched_data =
+      platform_sp->FetchExtendedCrashInformation(*target.GetSP().get());
+  data.m_impl_up->SetObjectSP(fetched_data);
+  return LLDB_RECORD_RESULT(data);
+}
+
 namespace lldb_private {
 namespace repro {
 
 template <>
 void RegisterMethods<SBPlatformConnectOptions>(Registry &R) {
   LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions, (const char *));
   LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions,
                             (const lldb::SBPlatformConnectOptions &));
void RegisterMethods<SBPlatform>(Registry &R) {
   LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, MakeDirectory,
                        (const char *, uint32_t));
   LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetFilePermissions,
                        (const char *));
   LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, SetFilePermissions,
                        (const char *, uint32_t));
   LLDB_REGISTER_METHOD_CONST(lldb::SBUnixSignals, SBPlatform, GetUnixSignals,
                              ());
+  LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBPlatform,
+                       GetExtendedCrashInformation, (lldb::SBTarget &));
 }
 
 }
 }

lldb/source/Commands/CommandObjectPlatform.cpp

public:
   }
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
   CommandOptions m_options;
 };
 
+// CommandObjectPlatformProcessCrashInfo
+#pragma mark CommandObjectPlatformProcessCrashInfo
+
+class CommandObjectPlatformProcessCrashInfo : public CommandObjectParsed {
+public:
+  CommandObjectPlatformProcessCrashInfo(CommandInterpreter &interpreter)
+      : CommandObjectParsed(interpreter, "platform process crash-info",
+                            "Fetch the platform's process crash information",
+                            "process crash-info",
+                            eCommandRequiresProcess |
+                                eCommandTryTargetAPILock) {}
+
+  ~CommandObjectPlatformProcessCrashInfo() override = default;
+
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    Stream &strm = result.GetOutputStream();
+    result.SetStatus(eReturnStatusSuccessFinishNoResult);
+
+    PlatformSP platform_sp(
+        GetDebugger().GetPlatformList().GetSelectedPlatform());
+    if (!platform_sp) {
+      result.AppendError("Couldn'retrieve the selected platform");
+      return result.Succeeded();
+    }
+
+    if (command.GetArgumentCount()) {
+      result.AppendError("`process crash-info` takes no arguments");
+      return result.Succeeded();
+    }
+
+    // No need to check "process" for validity as eCommandRequiresProcess
+    // ensures it is valid
+    Target &target = GetSelectedTarget();
+    ProcessSP process_sp = target.GetProcessSP();
+
+    StructuredData::ObjectSP crash_info_sp =
+        platform_sp->FetchExtendedCrashInformation(target);
+
+    if (!crash_info_sp) {
+      result.AppendError("Couldn't fetch the crash information");
+      return result.Succeeded();
+    }
+
+    crash_info_sp->Dump(strm);
+
+    return result.Succeeded();
+  }
+};
+
 class CommandObjectPlatformProcess : public CommandObjectMultiword {
 public:
   // Constructors and Destructors
   CommandObjectPlatformProcess(CommandInterpreter &interpreter)
-      : CommandObjectMultiword(interpreter, "platform process",
-                               "Commands to query, launch and attach to "
-                               "processes on the current platform.",
-                               "platform process [attach|launch|list] ...") {
+      : CommandObjectMultiword(
+            interpreter, "platform process",
+            "platform process [attach|launch|list|crash-info] ...") {
     LoadSubCommand(
         "attach",
         CommandObjectSP(new CommandObjectPlatformProcessAttach(interpreter)));
     LoadSubCommand(
         "launch",
         CommandObjectSP(new CommandObjectPlatformProcessLaunch(interpreter)));
     LoadSubCommand("info", CommandObjectSP(new CommandObjectPlatformProcessInfo(
                                interpreter)));
     LoadSubCommand("list", CommandObjectSP(new CommandObjectPlatformProcessList(
                                interpreter)));
+    LoadSubCommand("crash-info",
+                   CommandObjectSP(
+                       new CommandObjectPlatformProcessCrashInfo(interpreter)));
   }
 
   ~CommandObjectPlatformProcess() override = default;
 
 private:
   // For CommandObjectPlatform only
   DISALLOW_COPY_AND_ASSIGN(CommandObjectPlatformProcess);
 };

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,
   };
 
+  lldb_private::StructuredData::DictionarySP
+  FetchExtendedCrashInformation(lldb_private::Target &target) override;
+
 protected:
+  // This struct should only be available in macOS but could be used on other
+  // platforms. #ifdef HAVE_CRASHREPORTERCLIENT_H #include
+  // <CrashReporterClient.h> #endif
+  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.
+  /// \param[in] log
+  ///     The log pointer initialized with the right logging channel
+  ///
+  /// \return
+  ///     A structured data array containing at each entry in each entry, the
+  ///     module spec, its UUID, the crash messages and the abort cause. Or a
+  ///     nullptr if the process has no crash information entry.
+  lldb_private::StructuredData::ArraySP
+  ExtractCrashInfoAnnotations(lldb_private::Target &target,
+                              lldb_private::Log *log);
+
   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);

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);
 }
 
+StructuredData::DictionarySP
+PlatformDarwin::FetchExtendedCrashInformation(lldb_private::Target &target) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+  StructuredData::ArraySP annotations =
+      ExtractCrashInfoAnnotations(target, log);
+
+  if (!annotations) {
+    LLDB_LOG(log, "Couldn't extract crash information annotations");
+  }
+
+  if (!m_extended_crash_info)
+    m_extended_crash_info = std::make_shared<StructuredData::Dictionary>();
+
+  if (annotations)
+    m_extended_crash_info->AddItem("crash-info annotations", annotations);
+
+  return m_extended_crash_info;
+}
+
+StructuredData::ArraySP
+PlatformDarwin::ExtractCrashInfoAnnotations(Target &target, Log *log) {
+  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();
+
+    if (!sections) {
+      LLDB_LOG(log, "Module {0} doesn't have any section!", module_name);
+      continue;
+    }
+
+    ConstString section_name("__crash_info");
+    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/source/Target/Platform.cpp

 Platform::Platform(bool is_host)
     : m_is_host(is_host), m_os_version_set_while_connected(false),
       m_system_arch_set_while_connected(false), m_sdk_sysroot(), m_sdk_build(),
       m_working_dir(), m_remote_url(), m_name(), m_system_arch(), m_mutex(),
       m_max_uid_name_len(0), m_max_gid_name_len(0), m_supports_rsync(false),
       m_rsync_opts(), m_rsync_prefix(), m_supports_ssh(false), m_ssh_opts(),
       m_ignores_remote_hostname(false), m_trap_handlers(),
       m_calculated_trap_handlers(false),
-      m_module_cache(std::make_unique<ModuleCache>()) {
+      m_module_cache(std::make_unique<ModuleCache>()),
+      m_extended_crash_info(nullptr) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
   LLDB_LOGF(log, "%p Platform::Platform()", static_cast<void *>(this));
 }
 
 /// Destructor.
 ///
 /// The destructor is virtual since this class is designed to be
 /// inherited from by the plug-in instance.

lldb/test/API/commands/platform/process/crash-info/Makefile

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

lldb/test/API/commands/platform/process/crash-info/TestPlatformProcessCrashInfo.py

+"""
+Test lldb platform 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")
+
+    def tearDown(self):
+        self.runCmd("settings clear auto-confirm")
+        TestBase.tearDown(self)
+
+    @skipUnlessDarwin
+    def test_cli(self):
+        """Test that platform process crash-info fetches the extended crash
+        information array 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('platform process crash-info',
+                    patterns=["\"message\".*pointer being freed was not allocated"])
+
+
+    @skipUnlessDarwin
+    def test_api(self):
+        """Test that platform process crash-info fetches the extended crash
+        information array 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())
+
+        platform = target.GetPlatform()
+
+        stream = lldb.SBStream()
+        self.assertTrue(stream)
+
+        crash_info = platform.GetExtendedCrashInformation(target)
+
+        error = crash_info.GetAsJSON(stream)
+
+        self.assertTrue(error.Success())
+
+        self.assertTrue(crash_info.IsValid())
+
+        self.assertIn("pointer being freed was not allocated", stream.GetData())

lldb/test/API/commands/platform/process/crash-info/main.c

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