Add a new SBTarget::LoadCore() overload which surfaces errors if the load fails

[lemo]

Summary

There was no way to find out what's wrong if SBProcess SBTarget::LoadCore(const char *core_file) failed.
Additionally, the implementation was unconditionally setting sb_process, so it wasn't even possible to check if the return SBProcess is valid.

This change adds a new overload which surfaces the errors and also returns a valid SBProcess only if the core load succeeds:

SBProcess SBTarget::LoadCore(const char *core_file, SBError &error);

[lemo]

Adding test cases for the new overload.

[clayborg]

Remove extra spaces before ( and good to go.

scripts/interface/SBTarget.i

282

remove space before (

285

remove space before (

288

remove space before (

[lemo]

remove space before (

I'd be happy to make the change, but looking at the rest of the file it
seems that almost everything uses the opposite convention: Foo (...).

So, to make sure I'm making the right change, is this how it should look?

lldb::SBProcess
LoadCore(const char *core_file);

lldb::SBProcess
LoadCore(const char *core_file, lldb::SBError &error);

[lemo]

spaces removed :)

[amccarth]

lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/TestMiniDumpNew.py

78 ↗

(On Diff #150845)

Is it worth checking something more specific here? That the error indicates the file was not found?

[lemo]

The intention in the scope of this change is just to check that the new
overload is exposed correctly through the Python API.

In general, guaranteeing specific error codes (messages?) is likely
impractical:

1. It's not always easy to do the proper checks (ex. for 'file-not-found'

you'd actually get a null process, nothing more - see SBTarget::LoadCore()).

2. It's unlikely that many clients need or want to check for specific

errors.

3. Such a strict contract would be very fragile (ex. adding more specific

error condition detection would likely break the contract)

Perhaps ironically, I could take advantage of very specific error codes for
my scenario, but I don't think it's feasible. So for LoadCore() I'd like to
aim for more of a middle ground: accurate success/fail status + an
informative error content that can be used for diagnostics (logging) and
maybe as a weak hint.

What do you think?

[amccarth]

My motivation was not to check for different kinds of errors but to ensure that the error code detail doesn't get lost through the SWIG plumbing. SBErrors seem to be marshaled properly when used as return values, but this is the first one I've seen returned by reference. The test ensures that the success/fail result makes it, but not that the detail (e.g., the error string) survives the trip.

It's probably not a big deal.

[jingham]

SBTarget.Attach, and Launch take SBError references, and they are pretty well tested. So I don't think that's a concern here.

We don't use the text content of error messages programmatically in lldb.

If you wanted to make these errors actionable, the low level LoadCore could map the errors that are representable as such to the appropriate Posix error number. Then you could get the error value, and reason based on that. We do that in a bunch of places, but always either in explicitly Posix code - or with the Mach error flavor in Mach specific code. It would be a little weird to return Posix FNF on a Windows host, however...

But that's well outside the scope of this patch. And given we don't do that now, I agree with Leonard, we shouldn't require some form for the error text here.

include/lldb/API/SBTarget.h

public:
   lldb::SBProcess Launch(SBListener &listener, char const **argv,
                          char const **envp, const char *stdin_path,
                          const char *stdout_path, const char *stderr_path,
                          const char *working_directory,
                          uint32_t launch_flags, // See LaunchFlags
                          bool stop_at_entry, lldb::SBError &error);
 
   SBProcess LoadCore(const char *core_file);
+  SBProcess LoadCore(const char *core_file, lldb::SBError &error);
 
   //------------------------------------------------------------------
   /// Launch a new process with sensible defaults.
   ///
   /// @param[in] argv
   ///     The argument array.
   ///
   /// @param[in] envp
public:
 
   bool BreakpointDelete(break_id_t break_id);
 
   lldb::SBBreakpoint FindBreakpointByID(break_id_t break_id);
 
   // Finds all breakpoints by name, returning the list in bkpt_list.  Returns
   // false if the name is not a valid breakpoint name, true otherwise.
   bool FindBreakpointsByName(const char *name, SBBreakpointList &bkpt_list);
-  
   void GetBreakpointNames(SBStringList &names);
-  
   void DeleteBreakpointName(const char *name);
 
   bool EnableAllBreakpoints();
 
   bool DisableAllBreakpoints();
 
   bool DeleteAllBreakpoints();
 

packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/TestMiniDumpNew.py

def check_state(self):
             self.assertTrue(self.process.is_stopped)
             self.dbg.HandleCommand('c')
             self.assertTrue(self.process.is_stopped)
 
             # restore file handles
             self.dbg.SetOutputFileHandle(None, False)
             self.dbg.SetErrorFileHandle(None, False)
 
+    def test_loadcore_error_status(self):
+        """Test the SBTarget.LoadCore(core, error) overload."""
+        self.dbg.CreateTarget(None)
+        self.target = self.dbg.GetSelectedTarget()
+        error = lldb.SBError()
+        self.process = self.target.LoadCore("linux-x86_64.dmp", error)
+        self.assertTrue(self.process, PROCESS_IS_VALID)
+        self.assertTrue(error.Success())
+
+    def test_loadcore_error_status_failure(self):
+        """Test the SBTarget.LoadCore(core, error) overload."""
+        self.dbg.CreateTarget(None)
+        self.target = self.dbg.GetSelectedTarget()
+        error = lldb.SBError()
+        self.process = self.target.LoadCore("non-existent.dmp", error)
+        self.assertFalse(self.process, PROCESS_IS_VALID)
+        self.assertTrue(error.Fail())
+
     def test_process_info_in_minidump(self):
         """Test that lldb can read the process information from the Minidump."""
         # target create -c linux-x86_64.dmp
         self.dbg.CreateTarget(None)
         self.target = self.dbg.GetSelectedTarget()
         self.process = self.target.LoadCore("linux-x86_64.dmp")
         self.assertTrue(self.process, PROCESS_IS_VALID)
         self.assertEqual(self.process.GetNumThreads(), 1)

scripts/interface/SBTarget.i

public:
 
     //------------------------------------------------------------------
     // Destructor
     //------------------------------------------------------------------
     ~SBTarget();
 
     static const char *
     GetBroadcasterClassName ();
-    
     bool
     IsValid() const;
 
     static bool
     EventIsTargetEvent (const lldb::SBEvent &event);
 
     static lldb::SBTarget
     GetTargetFromEvent (const lldb::SBEvent &event);
public:
     /// are in \a envp. Standard input and output files can be
     /// optionally re-directed to \a stdin_path, \a stdout_path, and
     /// \a stderr_path.
     ///
     /// @param[in] listener
     ///     An optional listener that will receive all process events.
     ///     If \a listener is valid then \a listener will listen to all
     ///     process events. If not valid, then this target's debugger
-    ///     (SBTarget::GetDebugger()) will listen to all process events. 
+    ///     (SBTarget::GetDebugger()) will listen to all process events.
     ///
     /// @param[in] argv
     ///     The argument array.
     ///
     /// @param[in] envp
     ///     The environment array.
     ///
     /// @param[in] launch_flags
public:
     ///     The path to use when re-directing the STDERR of the new
     ///     process. If all stdXX_path arguments are NULL, a pseudo
     ///     terminal will be used.
     ///
     /// @param[in] working_directory
     ///     The working directory to have the child process run in
     ///
     /// @param[in] launch_flags
-    ///     Some launch options specified by logical OR'ing 
+    ///     Some launch options specified by logical OR'ing
     ///     lldb::LaunchFlags enumeration values together.
     ///
     /// @param[in] stop_at_entry
     ///     If false do not stop the inferior at the entry point.
     ///
     /// @param[out]
     ///     An error object. Contains the reason if there is some failure.
     ///
public:
     and redirect the standard output of the inferior to the /tmp/stdout.txt
     file. It does not specify a working directory so that the debug server
     will use its idea of what the current working directory is for the
     inferior. Also, we ask the debugger not to stop the inferior at the
     entry point. If no breakpoint is specified for the inferior, it should
     run to completion if no user interaction is required.
     ") Launch;
     lldb::SBProcess
-    Launch (SBListener &listener, 
+    Launch (SBListener &listener,
             char const **argv,
             char const **envp,
             const char *stdin_path,
             const char *stdout_path,
             const char *stderr_path,
             const char *working_directory,
             uint32_t launch_flags,   // See LaunchFlags
             bool stop_at_entry,
             lldb::SBError& error);
-            
     %feature("docstring", "
     //------------------------------------------------------------------
     /// Launch a new process with sensible defaults.
     ///
     /// @param[in] argv
     ///     The argument array.
     ///
     /// @param[in] envp
public:
     For example,
 
         process = target.LaunchSimple(['X', 'Y', 'Z'], None, os.getcwd())
 
     launches a new process by passing 'X', 'Y', 'Z' as the args to the
     executable.
     ") LaunchSimple;
     lldb::SBProcess
-    LaunchSimple (const char **argv, 
+    LaunchSimple (const char **argv,
                   const char **envp,
                   const char *working_directory);
-    
     lldb::SBProcess
     Launch (lldb::SBLaunchInfo &launch_info, lldb::SBError& error);
 
     %feature("docstring", "
     //------------------------------------------------------------------
     /// Load a core file
     ///
     /// @param[in] core_file
     ///     File path of the core dump.
     ///
+    /// @param[out] error
+    ///     An error explaining what went wrong if the operation fails.
+    ///     (Optional)
+    ///
     /// @return
     ///      A process object for the newly created core file.
     //------------------------------------------------------------------
 
     For example,
 
         process = target.LoadCore('./a.out.core')
 
     loads a new core file and returns the process object.
     ") LoadCore;
     lldb::SBProcess
-    LoadCore(const char *core_file);
-    
+    LoadCore (const char *core_file);
     lldb::SBProcess
-    Attach (lldb::SBAttachInfo &attach_info, lldb::SBError& error);
-    
+    LoadCore (const char *core_file, lldb::SBError &error);
+    lldb::SBProcess
+    Attach (lldb::SBAttachInfo &attach_info, lldb::SBError& error);
 
     %feature("docstring", "
     //------------------------------------------------------------------
     /// Attach to process with pid.
     ///
     /// @param[in] listener
     ///     An optional listener that will receive all process events.
     ///     If \a listener is valid then \a listener will listen to all
public:
     ///      A process object for the connected process.
     //------------------------------------------------------------------
     ") ConnectRemote;
     lldb::SBProcess
     ConnectRemote (SBListener &listener,
                    const char *url,
                    const char *plugin_name,
                    SBError& error);
-    
     lldb::SBFileSpec
     GetExecutable ();
 
     bool
     AddModule (lldb::SBModule &module);
 
     lldb::SBModule
     AddModule (const char *path,
public:
     lldb::SBDebugger
     GetDebugger() const;
 
     lldb::SBModule
     FindModule (const lldb::SBFileSpec &file_spec);
 
     lldb::ByteOrder
     GetByteOrder ();
-    
     uint32_t
     GetAddressByteSize();
-    
     const char *
     GetTriple ();
 
     %feature("docstring", "
     //------------------------------------------------------------------
     /// Architecture data byte width accessor
     ///
     /// @return
public:
     ///
     /// @param[in] name
     ///     The name of the function we are looking for.
     ///
     /// @param[in] name_type_mask
     ///     A logical OR of one or more FunctionNameType enum bits that
     ///     indicate what kind of names should be used when doing the
     ///     lookup. Bits include fully qualified names, base names,
-    ///     C++ methods, or ObjC selectors. 
+    ///     C++ methods, or ObjC selectors.
     ///     See FunctionNameType for more details.
     ///
     /// @return
-    ///     A lldb::SBSymbolContextList that gets filled in with all of 
+    ///     A lldb::SBSymbolContextList that gets filled in with all of
     ///     the symbol contexts for all the matches.
     //------------------------------------------------------------------
     ") FindFunctions;
     lldb::SBSymbolContextList
-    FindFunctions (const char *name, 
+    FindFunctions (const char *name,
                    uint32_t name_type_mask = lldb::eFunctionNameTypeAny);
-    
     lldb::SBType
     FindFirstType (const char* type);
-    
     lldb::SBTypeList
     FindTypes (const char* type);
 
     lldb::SBType
     GetBasicType(lldb::BasicType type);
 
     lldb::SBSourceManager
     GetSourceManager ();
public:
     /// @param[in] max_matches
     ///     Allow the number of matches to be limited to \a max_matches.
     ///
     /// @return
     ///     A list of matched variables in an SBValueList.
     //------------------------------------------------------------------
     ") FindGlobalVariables;
     lldb::SBValueList
-    FindGlobalVariables (const char *name, 
+    FindGlobalVariables (const char *name,
                          uint32_t max_matches);
 
      %feature("docstring", "
     //------------------------------------------------------------------
     /// Find the first global (or static) variable by name.
     ///
     /// @param[in] name
     ///     The name of the global or static variable we are looking
     ///     for.
     ///
     /// @return
     ///     An SBValue that gets filled in with the found variable (if any).
     //------------------------------------------------------------------
     ") FindFirstGlobalVariable;
     lldb::SBValue
     FindFirstGlobalVariable (const char* name);
 
-    
     lldb::SBValueList
     FindGlobalVariables(const char *name,
                         uint32_t max_matches,
                         MatchType matchtype);
 
     lldb::SBSymbolContextList
     FindGlobalFunctions(const char *name,
                         uint32_t max_matches,
public:
     ///     An SBAddress which will be valid if...
     //------------------------------------------------------------------
     ") ResolveFileAddress;
     lldb::SBAddress
     ResolveFileAddress (lldb::addr_t file_addr);
 
     lldb::SBAddress
     ResolveLoadAddress (lldb::addr_t vm_addr);
-              
     lldb::SBAddress
     ResolvePastLoadAddress (uint32_t stop_id, lldb::addr_t vm_addr);
 
     SBSymbolContext
-    ResolveSymbolContextForAddress (const SBAddress& addr, 
+    ResolveSymbolContextForAddress (const SBAddress& addr,
                                     uint32_t resolve_scope);
 
      %feature("docstring", "
     //------------------------------------------------------------------
-    /// Read target memory. If a target process is running then memory  
+    /// Read target memory. If a target process is running then memory
     /// is read from here. Otherwise the memory is read from the object
     /// files. For a target whose bytes are sized as a multiple of host
     /// bytes, the data read back will preserve the target's byte order.
     ///
     /// @param[in] addr
-    ///     A target address to read from. 
+    ///     A target address to read from.
     ///
     /// @param[out] buf
-    ///     The buffer to read memory into. 
+    ///     The buffer to read memory into.
     ///
     /// @param[in] size
     ///     The maximum number of host bytes to read in the buffer passed
     ///     into this call
     ///
     /// @param[out] error
     ///     Error information is written here if the memory read fails.
     ///
public:
 
     lldb::SBBreakpoint
     BreakpointCreateByLocation (const lldb::SBFileSpec &file_spec, uint32_t line);
 
     lldb::SBBreakpoint
     BreakpointCreateByLocation (const lldb::SBFileSpec &file_spec, uint32_t line, lldb::addr_t offset);
 
     lldb::SBBreakpoint
-    BreakpointCreateByLocation (const lldb::SBFileSpec &file_spec, uint32_t line, 
+    BreakpointCreateByLocation (const lldb::SBFileSpec &file_spec, uint32_t line,
                                 lldb::addr_t offset, SBFileSpecList &module_list);
 
     lldb::SBBreakpoint
     BreakpointCreateByName (const char *symbol_name, const char *module_name = NULL);
 
     lldb::SBBreakpoint
     BreakpointCreateByName (const char *symbol_name,
                             uint32_t func_name_type,           // Logical OR one or more FunctionNameType enum bits
-                            const SBFileSpecList &module_list, 
+                            const SBFileSpecList &module_list,
                             const SBFileSpecList &comp_unit_list);
 
     lldb::SBBreakpoint
     BreakpointCreateByName (const char *symbol_name,
                             uint32_t func_name_type,           // Logical OR one or more FunctionNameType enum bits
                             lldb::LanguageType symbol_language,
-                            const SBFileSpecList &module_list, 
+                            const SBFileSpecList &module_list,
                             const SBFileSpecList &comp_unit_list);
 
 %typemap(in) (const char **symbol_name, uint32_t num_names) {
   using namespace lldb_private;
   /* Check if is a list  */
   if (PythonList::Check($input)) {
     PythonList list(PyRefType::Borrowed, $input);
     $2 = list.GetSize();
BreakpointCreateByNames (const char **symbol_name,
                              const SBFileSpecList &comp_unit_list);
 
     lldb::SBBreakpoint
     BreakpointCreateByRegex (const char *symbol_name_regex, const char *module_name = NULL);
 
     lldb::SBBreakpoint
     BreakpointCreateByRegex (const char *symbol_name_regex,
                              lldb::LanguageType symbol_language,
-                             const SBFileSpecList &module_list, 
+                             const SBFileSpecList &module_list,
                              const SBFileSpecList &comp_unit_list);
 
     lldb::SBBreakpoint
     BreakpointCreateBySourceRegex (const char *source_regex, const lldb::SBFileSpec &source_file, const char *module_name = NULL);
 
     lldb::SBBreakpoint
     BreakpointCreateBySourceRegex (const char *source_regex, const lldb::SBFileSpecList &module_list, const lldb::SBFileSpecList &file_list);
 
//}
     GetBreakpointAtIndex (uint32_t idx) const;
 
     bool
     BreakpointDelete (break_id_t break_id);
 
     lldb::SBBreakpoint
     FindBreakpointByID (break_id_t break_id);
 
-  
     bool FindBreakpointsByName(const char *name, SBBreakpointList &bkpt_list);
 
     void DeleteBreakpointName(const char *name);
 
     void GetBreakpointNames(SBStringList &names);
 
     bool
     EnableAllBreakpoints ();
 
     bool
     DisableAllBreakpoints ();
 
     bool
     DeleteAllBreakpoints ();
 
      %feature("docstring", "
     //------------------------------------------------------------------
-    /// Read breakpoints from source_file and return the newly created 
+    /// Read breakpoints from source_file and return the newly created
     /// breakpoints in bkpt_list.
     ///
     /// @param[in] source_file
     ///    The file from which to read the breakpoints
-    /// 
+    ///
     /// @param[out] bkpt_list
     ///    A list of the newly created breakpoints.
     ///
     /// @return
     ///     An SBError detailing any errors in reading in the breakpoints.
     //------------------------------------------------------------------
     ") BreakpointsCreateFromFile;
     lldb::SBError
-    BreakpointsCreateFromFile(SBFileSpec &source_file, 
+    BreakpointsCreateFromFile(SBFileSpec &source_file,
                               SBBreakpointList &bkpt_list);
 
      %feature("docstring", "
     //------------------------------------------------------------------
-    /// Read breakpoints from source_file and return the newly created 
+    /// Read breakpoints from source_file and return the newly created
     /// breakpoints in bkpt_list.
     ///
     /// @param[in] source_file
     ///    The file from which to read the breakpoints
     ///
     /// @param[in] matching_names
     ///    Only read in breakpoints whose names match one of the names in this
     ///    list.
-    /// 
+    ///
     /// @param[out] bkpt_list
     ///    A list of the newly created breakpoints.
     ///
     /// @return
     ///     An SBError detailing any errors in reading in the breakpoints.
     //------------------------------------------------------------------
     ") BreakpointsCreateFromFile;
     lldb::SBError BreakpointsCreateFromFile(SBFileSpec &source_file,
                                           SBStringList &matching_names,
                                           SBBreakpointList &new_bps);
 
      %feature("docstring", "
     //------------------------------------------------------------------
     /// Write breakpoints to dest_file.
     ///
     /// @param[in] dest_file
     ///    The file to which to write the breakpoints.
     ///
     /// @return
     ///     An SBError detailing any errors in writing in the breakpoints.
     //------------------------------------------------------------------
     ") BreakpointsCreateFromFile;
     lldb::SBError
     BreakpointsWriteToFile(SBFileSpec &dest_file);
-      
      %feature("docstring", "
     //------------------------------------------------------------------
     /// Write breakpoints listed in bkpt_list to dest_file.
     ///
     /// @param[in] dest_file
     ///    The file to which to write the breakpoints.
     ///
     /// @param[in] bkpt_list
     ///    Only write breakpoints from this list.
     ///
     /// @param[in] append
     ///    If \btrue, append the breakpoints in bkpt_list to the others
     ///    serialized in dest_file.  If dest_file doesn't exist, then a new
     ///    file will be created and the breakpoints in bkpt_list written to it.
     ///
     /// @return
     ///     An SBError detailing any errors in writing in the breakpoints.
     //------------------------------------------------------------------
     ") BreakpointsCreateFromFile;
     lldb::SBError
-    BreakpointsWriteToFile(SBFileSpec &dest_file, 
+    BreakpointsWriteToFile(SBFileSpec &dest_file,
                            SBBreakpointList &bkpt_list,
                            bool append = false);
 
     uint32_t
     GetNumWatchpoints () const;
-    
     lldb::SBWatchpoint
     GetWatchpointAtIndex (uint32_t idx) const;
-    
     bool
     DeleteWatchpoint (lldb::watch_id_t watch_id);
-    
     lldb::SBWatchpoint
     FindWatchpointByID (lldb::watch_id_t watch_id);
-    
     bool
     EnableAllWatchpoints ();
-    
     bool
     DisableAllWatchpoints ();
-    
     bool
     DeleteAllWatchpoints ();
 
     lldb::SBWatchpoint
-    WatchAddress (lldb::addr_t addr, 
-                  size_t size, 
-                  bool read, 
+    WatchAddress (lldb::addr_t addr,
+                  size_t size,
+                  bool read,
                   bool write,
                   SBError &error);
-             
 
     lldb::SBBroadcaster
     GetBroadcaster () const;
-              
      %feature("docstring", "
     //------------------------------------------------------------------
     /// Create an SBValue with the given name by treating the memory starting at addr as an entity of type.
     ///
     /// @param[in] name
     ///     The name of the resultant SBValue
     ///
     /// @param[in] addr
     ///     The address of the start of the memory region to be used.
     ///
     /// @param[in] type
     ///     The type to use to interpret the memory starting at addr.
     ///
     /// @return
     ///     An SBValue of the given type, may be invalid if there was an error reading
     ///     the underlying memory.
     //------------------------------------------------------------------
     ") CreateValueFromAddress;
     lldb::SBValue
     CreateValueFromAddress (const char *name, lldb::SBAddress addr, lldb::SBType type);
 
     lldb::SBValue
     CreateValueFromData (const char *name, lldb::SBData data, lldb::SBType type);
-  
     lldb::SBValue
     CreateValueFromExpression (const char *name, const char* expr);
-              
     %feature("docstring", "
     Disassemble a specified number of instructions starting at an address.
     Parameters:
        base_addr       -- the address to start disassembly from
        count           -- the number of instructions to disassemble
        flavor_string   -- may be 'intel' or 'att' on x86 targets to specify that style of disassembly
-    Returns an SBInstructionList.") 
+    Returns an SBInstructionList.")
     ReadInstructions;
     lldb::SBInstructionList
-    ReadInstructions (lldb::SBAddress base_addr, uint32_t count);    
+    ReadInstructions (lldb::SBAddress base_addr, uint32_t count);
 
     lldb::SBInstructionList
     ReadInstructions (lldb::SBAddress base_addr, uint32_t count, const char *flavor_string);
 
     %feature("docstring", "
     Disassemble the bytes in a buffer and return them in an SBInstructionList.
     Parameters:
        base_addr -- used for symbolicating the offsets in the byte stream when disassembling
        buf       -- bytes to be disassembled
        size      -- (C++) size of the buffer
-    Returns an SBInstructionList.") 
+    Returns an SBInstructionList.")
     GetInstructions;
     lldb::SBInstructionList
     GetInstructions (lldb::SBAddress base_addr, const void *buf, size_t size);
 
     %feature("docstring", "
     Disassemble the bytes in a buffer and return them in an SBInstructionList, with a supplied flavor.
     Parameters:
        base_addr -- used for symbolicating the offsets in the byte stream when disassembling
        flavor    -- may be 'intel' or 'att' on x86 targets to specify that style of disassembly
        buf       -- bytes to be disassembled
        size      -- (C++) size of the buffer
-    Returns an SBInstructionList.") 
+    Returns an SBInstructionList.")
     GetInstructionsWithFlavor;
     lldb::SBInstructionList
     GetInstructionsWithFlavor (lldb::SBAddress base_addr, const char *flavor_string, const void *buf, size_t size);
-    
     lldb::SBSymbolContextList
     FindSymbols (const char *name, lldb::SymbolType type = eSymbolTypeAny);
 
     bool
     GetDescription (lldb::SBStream &description, lldb::DescriptionLevel description_level);
-    
     lldb::addr_t
     GetStackRedZoneSize();
 
     lldb::SBLaunchInfo
     GetLaunchInfo () const;
 
     void
     SetLaunchInfo (const lldb::SBLaunchInfo &launch_info);
//}
     lldb::SBValue
     EvaluateExpression (const char *expr, const lldb::SBExpressionOptions &options);
 
     %pythoncode %{
         class modules_access(object):
             '''A helper object that will lazily hand out lldb.SBModule objects for a target when supplied an index, or by full or partial path.'''
             def __init__(self, sbtarget):
                 self.sbtarget = sbtarget
-        
             def __len__(self):
                 if self.sbtarget:
                     return int(self.sbtarget.GetNumModules())
                 return 0
-        
             def __getitem__(self, key):
                 num_modules = self.sbtarget.GetNumModules()
                 if type(key) is int:
                     if key < num_modules:
                         return self.sbtarget.GetModuleAtIndex(key)
                 elif type(key) is str:
                     if key.find('/') == -1:
                         for idx in range(num_modules):
%pythoncode %{
                         module = self.sbtarget.GetModuleAtIndex(idx)
                         re_match = key.search(module.path.fullpath)
                         if re_match:
                             matching_modules.append(module)
                     return matching_modules
                 else:
                     print("error: unsupported item type: %s" % type(key))
                 return None
-        
         def get_modules_access_object(self):
             '''An accessor function that returns a modules_access() object which allows lazy module access from a lldb.SBTarget object.'''
             return self.modules_access (self)
-        
         def get_modules_array(self):
             '''An accessor function that returns a list() that contains all modules in a lldb.SBTarget object.'''
             modules = []
             for idx in range(self.GetNumModules()):
                 modules.append(self.GetModuleAtIndex(idx))
             return modules
 
         __swig_getmethods__["modules"] = get_modules_array
%pythoncode %{
         __swig_getmethods__["num_breakpoints"] = GetNumBreakpoints
         if _newclass: num_breakpoints = property(GetNumBreakpoints, None, doc='''A read only property that returns the number of breakpoints that this target has as an integer.''')
 
         __swig_getmethods__["num_watchpoints"] = GetNumWatchpoints
         if _newclass: num_watchpoints = property(GetNumWatchpoints, None, doc='''A read only property that returns the number of watchpoints that this target has as an integer.''')
 
         __swig_getmethods__["broadcaster"] = GetBroadcaster
         if _newclass: broadcaster = property(GetBroadcaster, None, doc='''A read only property that an lldb object that represents the broadcaster (lldb.SBBroadcaster) for this target.''')
-        
         __swig_getmethods__["byte_order"] = GetByteOrder
         if _newclass: byte_order = property(GetByteOrder, None, doc='''A read only property that returns an lldb enumeration value (lldb.eByteOrderLittle, lldb.eByteOrderBig, lldb.eByteOrderInvalid) that represents the byte order for this target.''')
-        
         __swig_getmethods__["addr_size"] = GetAddressByteSize
         if _newclass: addr_size = property(GetAddressByteSize, None, doc='''A read only property that returns the size in bytes of an address for this target.''')
-        
         __swig_getmethods__["triple"] = GetTriple
         if _newclass: triple = property(GetTriple, None, doc='''A read only property that returns the target triple (arch-vendor-os) for this target as a string.''')
 
         __swig_getmethods__["data_byte_size"] = GetDataByteSize
         if _newclass: data_byte_size = property(GetDataByteSize, None, doc='''A read only property that returns the size in host bytes of a byte in the data address space for this target.''')
 
         __swig_getmethods__["code_byte_size"] = GetCodeByteSize
         if _newclass: code_byte_size = property(GetCodeByteSize, None, doc='''A read only property that returns the size in host bytes of a byte in the code address space for this target.''')
 
         __swig_getmethods__["platform"] = GetPlatform
         if _newclass: platform = property(GetPlatform, None, doc='''A read only property that returns the platform associated with with this target.''')
     %}
 
 };
 
 } // namespace lldb

source/API/SBTarget.cpp

for (auto &Entry : target_sp->GetStatistics()) {
     i += 1;
   }
 
   data.m_impl_up->SetObjectSP(std::move(stats_up));
   return data;
 }
 
 SBProcess SBTarget::LoadCore(const char *core_file) {
+  lldb::SBError error; // Ignored
+  return LoadCore(core_file, error);
+}
+
+SBProcess SBTarget::LoadCore(const char *core_file, lldb::SBError &error) {
   SBProcess sb_process;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     FileSpec filespec(core_file, true);
     ProcessSP process_sp(target_sp->CreateProcess(
         target_sp->GetDebugger().GetListener(), "", &filespec));
     if (process_sp) {
-      process_sp->LoadCore();
+      error.SetError(process_sp->LoadCore());
+      if (error.Success())
         sb_process.SetSP(process_sp);
+    } else {
+      error.SetErrorString("Failed to create the process");
     }
+  } else {
+    error.SetErrorString("SBTarget is invalid");
   }
   return sb_process;
 }
 
 SBProcess SBTarget::LaunchSimple(char const **argv, char const **envp,
                                  const char *working_directory) {
   char *stdin_path = NULL;
   char *stdout_path = NULL;