Fix error reporting for "process load" and add a test for it.

[jingham]

Summary

We weren't reporting errors (like file not found) from "process load", because when you just passed one string and no paths, the utility function didn't actually gather the error. Fix that and add a test.

The only weak part of the patch is that the error string comes from the platform plugin so I don't actually know what it is going to look like. So I tested that we don't produce the "unknown error" string instead. That's not really API, it's just what the only current implementation produces when it couldn't get the error. If we get a second implementation, we'll either just ensure it produces the same string or extract that somewhere and set it as the generic error. But that seemed overkill for this patch.

[JDevlieghere]

LGTM

lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

void * __lldb_dlopen_wrapper (const char *name,
                                 char *buffer,
                                 __lldb_dlopen_result *result_ptr)
   {
     // This is the case where the name is the full path:
     if (!path_strings) {
       result_ptr->image_ptr = dlopen(name, RTLD_LAZY);
       if (result_ptr->image_ptr)
         result_ptr->error_str = nullptr;
+      else
+        result_ptr->error_str = dlerror();
       return nullptr;
     }
     
     // This is the case where we have a list of paths:
     size_t name_len = strlen(name);
     while (path_strings && path_strings[0] != '\0') {
       size_t path_len = strlen(path_strings);
       memcpy((void *) buffer, (void *) path_strings, path_len);

lldb/test/API/functionalities/load_unload/TestLoadUnload.py

def run_lldb_process_load_and_unload_commands(self):
         dylibName = ctx.shlib_prefix + 'loadunload_a.' + ctx.shlib_extension
         localDylibPath = self.getBuildArtifact(dylibName)
         if lldb.remote_platform:
             wd = lldb.remote_platform.GetWorkingDirectory()
             remoteDylibPath = lldbutil.join_remote_paths(wd, dylibName)
         else:
             remoteDylibPath = localDylibPath
 
+        # First make sure that we get some kind of error if process load fails.
+        # We print some error even if the load fails, which isn't formalized.
+        # The only plugin at present (Posix) that supports this says "unknown reasons".
+        # If another plugin shows up, let's require it uses "unknown error" as well.
+        non_existant_shlib = "/NoSuchDir/NoSuchSubdir/ReallyNo/NotAFile"
+        self.expect("process load %s"%(non_existant_shlib), error=True, matching=False,
+                    patterns=["unknown reasons"])
+        
+
         # Make sure that a_function does not exist at this point.
         self.expect(
             "image lookup -n a_function",
             "a_function should not exist yet",
             error=True,
             matching=False,
             patterns=["1 match found"])
 

lldb/test/API/functionalities/load_using_paths/TestLoadUsingPaths.py

def test_load_using_paths(self):
         paths.AppendString(self.wd)
         paths.AppendString(os.path.join(self.wd, "no_such_dir"))
 
         out_spec = lldb.SBFileSpec()
 
         # First try with no correct directories on the path, and make sure that doesn't blow up:
         token = process.LoadImageUsingPaths(lib_spec, paths, out_spec, error)
         self.assertEqual(token, lldb.LLDB_INVALID_IMAGE_TOKEN, "Only looked on the provided path.")
+        # Make sure we got some error back in this case.  Since we don't actually know what
+        # the error will look like, let's look for the absence of "unknown reasons".
+        error_str = error.description
+        self.assertNotEqual(len(error_str), 0, "Got an empty error string")
+        self.assertNotIn("unknown reasons", error_str, "Error string had unknown reasons")
         
         # Now add the correct dir to the paths list and try again:
         paths.AppendString(self.hidden_dir)
         token = process.LoadImageUsingPaths(lib_spec, paths, out_spec, error)
 
         self.assertNotEqual(token, lldb.LLDB_INVALID_IMAGE_TOKEN, "Got a valid token")
         self.assertEqual(out_spec, lldb.SBFileSpec(self.hidden_lib), "Found the expected library")
 
         # Make sure this really is in the image list:
def test_load_using_paths(self):
         out_spec = lldb.SBFileSpec()
         token = process.LoadImageUsingPaths(relative_spec, paths, out_spec, error)
 
         self.assertNotEqual(token, lldb.LLDB_INVALID_IMAGE_TOKEN, "Got a valid token with included empty path")
         self.assertEqual(out_spec, lldb.SBFileSpec(self.hidden_lib), "Found the expected library with included empty path")
 
         process.UnloadImage(token)
 
-
-
         # Finally, passing in an absolute path should work like the basename:
         # This should NOT work because we've taken hidden_dir off the paths:
         abs_spec = lldb.SBFileSpec(os.path.join(self.hidden_dir, self.lib_name))
 
         token = process.LoadImageUsingPaths(lib_spec, paths, out_spec, error)
         self.assertEqual(token, lldb.LLDB_INVALID_IMAGE_TOKEN, "Only looked on the provided path.")
 
         # But it should work when we add the dir:
         # Now add the correct dir to the paths list and try again:
         paths.AppendString(self.hidden_dir)
         token = process.LoadImageUsingPaths(lib_spec, paths, out_spec, error)
 
         self.assertNotEqual(token, lldb.LLDB_INVALID_IMAGE_TOKEN, "Got a valid token")
         self.assertEqual(out_spec, lldb.SBFileSpec(self.hidden_lib), "Found the expected library")
-
-