Fix "process load/unload" on android

[tberghammer]

Summary

Fix "process load/unload" on android

On android the symbols exposed by libdl (dlopen, dlclose, dlerror)
prefixed by "__dl_". This change moves the handling of process
load/unload to the platform object and override it for android to
handle the special prefix.

[srhines]

include/lldb/Target/Platform.h

872 ↗

(On Diff #30500)

Some platforms prefix the ... Let those platforms specify ...

[tberghammer]

Improve comment based on review

[tberghammer]

Friendly ping

[sivachandra]

I am not really familiar with this area. OK from my side, but you might want clayborg to take a look at this.

[clayborg]

We should add support to lldb::SBPlatform and lldb_private::Platform where we get the shared library extension from the platform and also fix the logic as noted in the inlined comments.

test/functionalities/load_unload/TestLoadUnload.py

201–204 ↗

(On Diff #30573)

It would be great to add something to lldb::SBPlatform and lldb_private::Platform that allows us to get the shared library extension from the platform:

class SBPlatform
{
    const char *
    GetSharedLibraryExtension();
};

Then this code can become:

dylibName = "libloadunload" + platform.GetSharedLibraryExtension()

206–209 ↗

(On Diff #30573)

This code should be:

if lldb.remote_platform:
    dylibPath = os.path.join(shlib_dir, dylibName)
else:
    dylibPath = dylibName

[clayborg]

The other alternative is to have lldb_private::Platform have a new function:

class Platform
{
    virtual uint32_t
    LoadImage (lldb_private::Process *process, const FileSpec &image_spec, Error &error);

    virtual Error
    UnLoadImage (lldb_private::Process *process, uint32_t image_token);
}

Then we move the current code from Process::LoadImage() and Process::UnLoadImage() into PlatformPOSIX, and have new versions for PlatformAndroid.

[clayborg]

The second platform route would probably be better because it would allow for Windows to load/unload images if we ever move to lldb-server on windows.

[tberghammer]

Address review comments

[tberghammer]

test/functionalities/load_unload/TestLoadUnload.py

201–204 ↗

(On Diff #30573)

It is a fairly unrelated change. Will create a separate CL for it

206–209 ↗

(On Diff #30573)

Done

[clayborg]

Looks fine.

[jingham]

It seems like an awful lot of logic is duplicated between the POSIX & Android versions of LoadImage when all that really changes is the name of the function you are calling. Is it possible to centralize this some more?

[labath]

In D11465#300581, @jingham wrote:

It seems like an awful lot of logic is duplicated between the POSIX & Android versions of LoadImage when all that really changes is the name of the function you are calling. Is it possible to centralize this some more?

We've been discussing this offline. I believe Tamas is working on resolving that.

[tberghammer]

In D11465#300606, @labath wrote:

In D11465#300581, @jingham wrote:

It seems like an awful lot of logic is duplicated between the POSIX & Android versions of LoadImage when all that really changes is the name of the function you are calling. Is it possible to centralize this some more?

We've been discussing this offline. I believe Tamas is working on resolving that.

I uploaded D15183 to fix the issue

[nitesh.jain]

lldb/trunk/source/Plugins/Platform/Android/PlatformAndroid.cpp

389

Hi Tamas,

When I run "process load libloadunload_a.so --install" its fail with error Couldn't lookup symbols: dl_dlerror, dl_dlopen.

Symbol table contains 13 entries:

Num:    Value  Size Type    Bind   Vis      Ndx Name
  0: 00000000     0 NOTYPE  LOCAL  DEFAULT  UND
  1: 00000304     5 FUNC    GLOBAL DEFAULT    5 android_dlopen_ext
  2: 00000309     5 FUNC    GLOBAL DEFAULT    5 android_get_LD_LIBRARY_PA
  3: 0000030e     5 FUNC    GLOBAL DEFAULT    5 android_update_LD_LIBRARY
  4: 00000313     5 FUNC    GLOBAL DEFAULT    5 dl_iterate_phdr
  5: 00000318     5 FUNC    GLOBAL DEFAULT    5 **dladdr**
  6: 0000031d     5 FUNC    GLOBAL DEFAULT    5 **dlclose**
  7: 00000322     5 FUNC    GLOBAL DEFAULT    5 **dlerror**
  8: 00000327     5 FUNC    GLOBAL DEFAULT    5 **dlopen**
  9: 0000032c     5 FUNC    GLOBAL DEFAULT    5 dlsym
 10: 00002000     0 NOTYPE  GLOBAL DEFAULT  ABS _edata
 11: 00002000     0 NOTYPE  GLOBAL DEFAULT  ABS __bss_start
 12: 00002000     0 NOTYPE  GLOBAL DEFAULT  ABS _end

The symbols are not prefix with "__dl_" . We are using SDK version 25 for MIP64r6 target.

generic_mips64:/ # getprop ro.build.version.sdk
25

Even we are not seeing prefix "__dl_" added to X86-64 dynamic symbol
Symbol table '.dynsym' contains 12 entries:

Num:    Value          Size Type    Bind   Vis      Ndx Name
  0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND
  1: 0000000000000442     6 FUNC    GLOBAL DEFAULT    7 dl_iterate_phdr@@LIBC
  2: 000000000000043c     6 FUNC    GLOBAL DEFAULT    7 android_dlopen_ext@@LIBC
  3: 000000000000044e     6 FUNC    GLOBAL DEFAULT    7 dlclose@@LIBC
  4: 0000000000000448     6 FUNC    GLOBAL DEFAULT    7 dladdr@@LIBC
  5: 000000000000045a     6 FUNC    GLOBAL DEFAULT    7 dlopen@@LIBC
  6: 0000000000000454     6 FUNC    GLOBAL DEFAULT    7 dlerror@@LIBC
  7: 0000000000000460     6 FUNC    GLOBAL DEFAULT    7 dlsym@@LIBC
  8: 0000000000002000     0 NOTYPE  GLOBAL DEFAULT  ABS _edata
  9: 0000000000002000     0 NOTYPE  GLOBAL DEFAULT  ABS __bss_start
 10: 0000000000002000     0 NOTYPE  GLOBAL DEFAULT  ABS _end
 11: 0000000000000000     0 OBJECT  GLOBAL DEFAULT  ABS LIBC

Symbol table '.symtab' contains 14 entries:

Num:    Value          Size Type    Bind   Vis      Ndx Name
  0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND
  1: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS tmp-platform.c
  2: 0000000000001ee0   288 OBJECT  LOCAL  HIDDEN    10 _DYNAMIC
  3: 0000000000000000     0 OBJECT  GLOBAL DEFAULT  ABS LIBC
  4: 0000000000000442     6 FUNC    GLOBAL DEFAULT    7 dl_iterate_phdr
  5: 000000000000043c     6 FUNC    GLOBAL DEFAULT    7 android_dlopen_ext
  6: 000000000000044e     6 FUNC    GLOBAL DEFAULT    7 dlclose
  7: 0000000000000448     6 FUNC    GLOBAL DEFAULT    7 dladdr
  8: 000000000000045a     6 FUNC    GLOBAL DEFAULT    7 dlopen

[tberghammer]

Hi Nitesh,

The way dlopen, dlclose and dl_phdr_iterate is implemented on android is pretty strange until (and including) SDK 25. The trick is that these functions are implemented inside "/system/bin/linker" with actual function names prefixed with "__dl_". The linker is doing some magic (creating a fake shared library entry at startup) to resolve these symbols when a library is loaded. This magic isn't understand by LLDB so it tries to lookup the symbols in the linker binary itself based on there actual function names. The actual libdl.so file located on the device isn't used for anything (it is there just for some compatibility reasons).

To help me investigate, can you do the followings and attach the output to this thread:

• Run "target modules list" in LLDB
• Run "target modules lookup -n dlopen" in LLDB
• Run "target modules lookup -n __dl_dlopen" in LLDB
• Download "/system/bin/linker" from the device and dump the ".symtab" section of it

Random guesses for what can cause the problem (will be able to more specific based on the above data):

• LLDB fails to detect or load "/system/bin/linker" in the shared library list
• /system/bin/linker doesn't contain a ".symtab" section (e.g. stripped)
• You are using a version of android what have an API 26 /system/bin/linker what had some changes breaking LLDB (Pavel fixed it but the fix only applies for API 26+)

[labath]

lldb/trunk/source/Plugins/Platform/Android/PlatformAndroid.cpp

389

Is it possible you are using a preview version of android sdk? These had the new dlopen symbols even though the official android sdk's still used the __dl_dlopen symbols?

[clayborg]

It would be nice to auto detect the names correctly?

lldb/trunk/source/Plugins/Platform/Android/PlatformAndroid.cpp

389

Maybe search for a symbol named "dl_open" first, then fall back to "dl_open" if that symbol is available, and supply as an argument for "expr.Printf(" by adding a "%s" in place of the "dl_dlopen? call? Then it can work for both?

const char *dl_open_func_name = nullptr;
SymbolContextList matching_symbols;
std::vector<const char *> dl_open_names = { "__dl_open", "dl_open" };
const char *dl_open_name = nullptr;
for (auto name: dl_open_names) {
  if (process->GetTarget().GetImages().FindFunctionSymbols(ConstString(name), eFunctionNameTypeFull, matching_symbols))
    dl_open_name = name;
    break;
  }
}

[nitesh.jain]

Hi Tamas,

Run "target modules list"

(lldb) target modules list
[ 0] E6A47987-0000-0000-0000-000000000000 /export/tmp/nin/LLVM/llvm/tools/lldb/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/multiset/a.out
[ 1] C2298D9F-41E0-1ED4-C9BF-D5B416CBE38F /home/nin/.lldb/module_cache/remote-android/.cache/C2298D9F-41E0-1ED4-C9BF-D5B416CBE38F/libstdc++.so
[ 2] D178E966-9342-8A56-CE34-35C9359886A4 /home/nin/.lldb/module_cache/remote-android/.cache/D178E966-9342-8A56-CE34-35C9359886A4/libm.so
[ 3] 6F226DD0-EFC1-AC63-647D-374F43AB9CC6 /home/nin/.lldb/module_cache/remote-android/.cache/6F226DD0-EFC1-AC63-647D-374F43AB9CC6/libc.so
[ 4] DF63F23A-2C91-BA01-EC7D-7CCA4FA1A55D /home/nin/.lldb/module_cache/remote-android/.cache/DF63F23A-2C91-BA01-EC7D-7CCA4FA1A55D/libdl.so
[ 5] 0466B0A0-00B3-88DA-55F1-1DA6D42D2C36 /home/nin/.lldb/module_cache/remote-android/.cache/0466B0A0-00B3-88DA-55F1-1DA6D42D2C36/ld-android.so
[ 6] 3FD33902-2A3B-6F33-0890-CDF6A434045E /home/nin/.lldb/module_cache/remote-android/.cache/3FD33902-2A3B-6F33-0890-CDF6A434045E/linker64
[ 7] D738489C-460B-25A5-B3B1-0D9BBC7CB8D6 /home/nin/.lldb/module_cache/remote-android/.cache/D738489C-460B-25A5-B3B1-0D9BBC7CB8D6/libnetd_client.so
[ 8] 84239230-A38E-687A-7EC5-FA40CD52D25F /home/nin/.lldb/module_cache/remote-android/.cache/84239230-A38E-687A-7EC5-FA40CD52D25F/libcutils.so
[ 9] 38725D15-41E9-AB20-70A0-16012C5B9DAD /home/nin/.lldb/module_cache/remote-android/.cache/38725D15-41E9-AB20-70A0-16012C5B9DAD/libc++.so
[ 10] 72DDCA8E-D724-7089-17EF-0703F4CA12E4 /home/nin/.lldb/module_cache/remote-android/.cache/72DDCA8E-D724-7089-17EF-0703F4CA12E4/liblog.so

Run "target modules lookup -n dlopen"

(lldb) target modules lookup -n dlopen
1 match found in /home/nin/.lldb/module_cache/remote-android/.cache/DF63F23A-2C91-BA01-EC7D-7CCA4FA1A55D/libdl.so:

Address: libdl.so[0x00000000000010a0] (libdl.so..text + 352)
Summary: libdl.so`dlopen

target modules lookup -n __dl_dlopen

(lldb) target modules lookup -n __dl_dlopen
(lldb)

I have attach the output of /system/bin/linker64.

linker_64.log588 KBDownload

.

[nitesh.jain]

The android version am using for testing is "O".

generic_mips64:/ # getprop ro.build.version.release
O

[tberghammer]

Thanks for all of the data. Based on this I think you are using a preview version of android O what reports SDK 25 but the linker works the way an SDK 26 system linker would do.

I think the proper fix for the problem is to do something like what Greg suggested to detect the correct function name based on the list of available symbols instead of based on the SDK version. I will try to create a CL to fix it in the next couple of days (unless you are happy to do it), but not sure when I will have time for that and it is a bit tricky to test it.

Until then you can try to do either update to a newer version of the system image what reports SDK 26 (and make sure you are using a sufficiently new LLDB) or locally hack the "PlatformAndroid::LoadImage" function to use the SDK 26 version in case of SDK 25 as well (possibly with a check for ro.build.version.release)

[nitesh.jain]

In D11465#826132, @tberghammer wrote:

Thanks for all of the data. Based on this I think you are using a preview version of android O what reports SDK 25 but the linker works the way an SDK 26 system linker would do.

I think the proper fix for the problem is to do something like what Greg suggested to detect the correct function name based on the list of available symbols instead of based on the SDK version. I will try to create a CL to fix it in the next couple of days (unless you are happy to do it), but not sure when I will have time for that and it is a bit tricky to test it.

Until then you can try to do either update to a newer version of the system image what reports SDK 26 (and make sure you are using a sufficiently new LLDB) or locally hack the "PlatformAndroid::LoadImage" function to use the SDK 26 version in case of SDK 25 as well (possibly with a check for ro.build.version.release)

Thanks. As suggested by Greg will submit a patch for that

lldb/trunk/include/lldb/Target/Platform.h

//                Error &error) = 0;
         //------------------------------------------------------------------
         /// Allow the platform to set preferred memory cache line size. If non-zero (and the user
         /// has not set cache line size explicitly), this value will be used as the cache line
         /// size for memory reads.
         //------------------------------------------------------------------
         virtual uint32_t
         GetDefaultMemoryCacheLineSize() { return 0; }
 
+        //------------------------------------------------------------------
+        /// Load a shared library into this process.
+        ///
+        /// Try and load a shared library into the current process. This
+        /// call might fail in the dynamic loader plug-in says it isn't safe
+        /// to try and load shared libraries at the moment.
+        ///
+        /// @param[in] process
+        ///     The process to load the image.
+        ///
+        /// @param[in] image_spec
+        ///     The image file spec that points to the shared library that
+        ///     you want to load.
+        ///
+        /// @param[out] error
+        ///     An error object that gets filled in with any errors that
+        ///     might occur when trying to load the shared library.
+        ///
+        /// @return
+        ///     A token that represents the shared library that can be
+        ///     later used to unload the shared library. A value of
+        ///     LLDB_INVALID_IMAGE_TOKEN will be returned if the shared
+        ///     library can't be opened.
+        //------------------------------------------------------------------
+        virtual uint32_t
+        LoadImage (lldb_private::Process* process,
+                   const lldb_private::FileSpec& image_spec,
+                   lldb_private::Error& error);
+
+        virtual Error
+        UnloadImage (lldb_private::Process* process, uint32_t image_token);
+
     protected:
         bool m_is_host;
-        // Set to true when we are able to actually set the OS version while 
+        // 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;
         bool m_system_arch_set_while_connected;
         ConstString m_sdk_sysroot; // the root location of where the SDK files are all located
         ConstString m_sdk_build;

lldb/trunk/include/lldb/Target/Process.h

public:
     ///     The address of the dynamic loader information, or
     ///     LLDB_INVALID_ADDRESS if this is not supported by this
     ///     interface.
     //------------------------------------------------------------------
     virtual lldb::addr_t
     GetImageInfoAddress ();
 
     //------------------------------------------------------------------
-    /// Load a shared library into this process.
-    ///
-    /// Try and load a shared library into the current process. This
-    /// call might fail in the dynamic loader plug-in says it isn't safe
-    /// to try and load shared libraries at the moment.
-    ///
-    /// @param[in] image_spec
-    ///     The image file spec that points to the shared library that
-    ///     you want to load.
-    ///
-    /// @param[out] error
-    ///     An error object that gets filled in with any errors that
-    ///     might occur when trying to load the shared library.
-    ///
-    /// @return
-    ///     A token that represents the shared library that can be
-    ///     later used to unload the shared library. A value of
-    ///     LLDB_INVALID_IMAGE_TOKEN will be returned if the shared
-    ///     library can't be opened.
-    //------------------------------------------------------------------
-    virtual uint32_t
-    LoadImage (const FileSpec &image_spec, Error &error);
-
-    virtual Error
-    UnloadImage (uint32_t image_token);
-
-    //------------------------------------------------------------------
     /// Called when the process is about to broadcast a public stop.
     ///
     /// There are public and private stops. Private stops are when the
     /// process is doing things like stepping and the client doesn't
     /// need to know about starts and stop that implement a thread plan.
     /// Single stepping over a source line in code might end up being
     /// implemented by one or more process starts and stops. Public stops
     /// are when clients will be notified that the process is stopped.

     ///     processes address space, LLDB_INVALID_ADDRESS otherwise.
     //------------------------------------------------------------------
     virtual Error
     GetFileLoadAddress(const FileSpec& file, bool& is_loaded, lldb::addr_t& load_addr)
     {
         return Error("Not supported");
     }
 
+    size_t
+    AddImageToken(lldb::addr_t image_ptr);
+
+    lldb::addr_t
+    GetImagePtrFromToken(size_t token) const;
+
+    void
+    ResetImageToken(size_t token);
+
 protected:
     void
     SetState (lldb::EventSP &event_sp);
 
     lldb::StateType
     GetPrivateState ();
 
     //------------------------------------------------------------------

lldb/trunk/packages/Python/lldbsuite/test/functionalities/load_unload/TestLoadUnload.py

def test_dyld_library_path(self):
             env_cmd_string += ":" + wd
         self.runCmd(env_cmd_string)
 
         # This time, the hidden library should be picked up.
         self.expect("run", substrs=["return", "12345"])
 
     @skipIfFreeBSD # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
     @skipUnlessListedRemote(['android'])
-    @expectedFailureAndroid # dlopen and dlclose prefixed with "__dl_" on android causing JIT compilation issues
     @skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently
     def test_lldb_process_load_and_unload_commands(self):
         """Test that lldb process load/unload command work correctly."""
 
         # Invoke the default build rule.
         self.build()
         self.copy_shlibs_to_remote()
 
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Break at main.c before the call to dlopen().
         # Use lldb's process load command to load the dylib, instead.
 
         lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         if lldb.remote_platform:
             shlib_dir = lldb.remote_platform.GetWorkingDirectory()
         else:
             shlib_dir = self.mydir
-        # 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 .* %s" % shlib_dir])
 
-        if lldb.remote_platform:
-            dylibName = os.path.join(shlib_dir, 'libloadunload_a.so')
-        elif self.platformIsDarwin():
+        if self.platformIsDarwin():
             dylibName = 'libloadunload_a.dylib'
         else:
             dylibName = 'libloadunload_a.so'
 
+        if lldb.remote_platform:
+            dylibPath = os.path.join(shlib_dir, dylibName)
+        else:
+            dylibPath = dylibName
+
+        # 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"])
+
         # Use lldb 'process load' to load the dylib.
-        self.expect("process load %s" % dylibName, "%s loaded correctly" % dylibName,
-            patterns = ['Loading "%s".*ok' % dylibName,
+        self.expect("process load %s" % dylibPath, "%s loaded correctly" % dylibPath,
+            patterns = ['Loading "%s".*ok' % dylibPath,
                         'Image [0-9]+ loaded'])
 
         # Search for and match the "Image ([0-9]+) loaded" pattern.
         output = self.res.GetOutput()
         pattern = re.compile("Image ([0-9]+) loaded")
         for l in output.split(os.linesep):
             #print("l:", l)
             match = pattern.search(l)
             if match:
                 break
         index = match.group(1)
 
         # Now we should have an entry for a_function.
         self.expect("image lookup -n a_function", "a_function should now exist",
-            patterns = ["1 match found .*%s" % shlib_dir])
+            patterns = ["1 match found .*%s" % dylibName])
 
         # Use lldb 'process unload' to unload the dylib.
         self.expect("process unload %s" % index, "%s unloaded correctly" % dylibName,
             patterns = ["Unloading .* with index %s.*ok" % index])
 
         self.runCmd("process continue")
 
     @skipIfFreeBSD # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support

lldb/trunk/source/API/SBProcess.cpp

 {
     ProcessSP process_sp(GetSP());
     if (process_sp)
     {
         Process::StopLocker stop_locker;
         if (stop_locker.TryLock(&process_sp->GetRunLock()))
         {
             Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
-            return process_sp->LoadImage (*sb_image_spec, sb_error.ref());
+            PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
+            return platform_sp->LoadImage (process_sp.get(), *sb_image_spec, sb_error.ref());
         }
         else
         {
             Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
             if (log)
                 log->Printf ("SBProcess(%p)::LoadImage() => error: process is running",
                              static_cast<void*>(process_sp.get()));
             sb_error.SetErrorString("process is running");
         }
     }
     return LLDB_INVALID_IMAGE_TOKEN;
 }
 
 lldb::SBError
 SBProcess::UnloadImage (uint32_t image_token)
 {
     lldb::SBError sb_error;
     ProcessSP process_sp(GetSP());
     if (process_sp)
     {
         Process::StopLocker stop_locker;
         if (stop_locker.TryLock(&process_sp->GetRunLock()))
         {
             Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
-            sb_error.SetError (process_sp->UnloadImage (image_token));
+            PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
+            sb_error.SetError (platform_sp->UnloadImage (process_sp.get(), image_token));
         }
         else
         {
             Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
             if (log)
                 log->Printf ("SBProcess(%p)::UnloadImage() => error: process is running",
                              static_cast<void*>(process_sp.get()));
             sb_error.SetErrorString("process is running");

lldb/trunk/source/Commands/CommandObjectProcess.cpp

DoExecute (Args& command, CommandReturnObject &result) override
 
         const size_t argc = command.GetArgumentCount();
         
         for (uint32_t i=0; i<argc; ++i)
         {
             Error error;
             const char *image_path = command.GetArgumentAtIndex(i);
             FileSpec image_spec (image_path, false);
-            process->GetTarget().GetPlatform()->ResolveRemotePath(image_spec, image_spec);
-            uint32_t image_token = process->LoadImage(image_spec, error);
+            PlatformSP platform = process->GetTarget().GetPlatform();
+            platform->ResolveRemotePath(image_spec, image_spec);
+            uint32_t image_token = platform->LoadImage(process, image_spec, error);
             if (image_token != LLDB_INVALID_IMAGE_TOKEN)
             {
                 result.AppendMessageWithFormat ("Loading \"%s\"...ok\nImage %u loaded.\n", image_path, image_token);  
                 result.SetStatus (eReturnStatusSuccessFinishResult);
             }
             else
             {
                 result.AppendErrorWithFormat ("failed to load '%s': %s", image_path, error.AsCString());
DoExecute (Args& command, CommandReturnObject &result) override
             if (image_token == LLDB_INVALID_IMAGE_TOKEN)
             {
                 result.AppendErrorWithFormat ("invalid image index argument '%s'", image_token_cstr);
                 result.SetStatus (eReturnStatusFailed);
                 break;
             }
             else
             {
-                Error error (process->UnloadImage(image_token));
+                Error error (process->GetTarget().GetPlatform()->UnloadImage(process, image_token));
                 if (error.Success())
                 {
                     result.AppendMessageWithFormat ("Unloading shared library with index %u...ok\n", image_token);  
                     result.SetStatus (eReturnStatusSuccessFinishResult);
                 }
                 else
                 {
                     result.AppendErrorWithFormat ("failed to unload image: %s", error.AsCString());

lldb/trunk/source/Plugins/Platform/Android/PlatformAndroid.h

public:
         GetRemoteOSVersion() override;
 
         Error
         DisconnectRemote () override;
 
         uint32_t
         GetDefaultMemoryCacheLineSize() override;
 
+        uint32_t
+        LoadImage (lldb_private::Process* process,
+                   const lldb_private::FileSpec& image_spec,
+                   lldb_private::Error& error) override;
+
+        lldb_private::Error
+        UnloadImage (lldb_private::Process* process, uint32_t image_token) override;
+
      protected:
         const char *
         GetCacheHostname () override;
 
         Error
         DownloadModuleSlice (const FileSpec &src_file_spec,
                              const uint64_t src_offset,
                              const uint64_t src_size,

lldb/trunk/source/Plugins/Platform/Android/PlatformAndroid.cpp

 //===-- PlatformAndroid.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Core/Scalar.h"
 #include "lldb/Core/Section.h"
+#include "lldb/Core/ValueObject.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/StringConvert.h"
 #include "Utility/UriParser.h"
 
 // Project includes
 #include "AdbClient.h"
 #include "PlatformAndroid.h"
 #include "PlatformAndroidRemoteGDBServer.h"

 bool
 PlatformAndroid::GetRemoteOSVersion ()
 {
     m_major_os_version = GetSdkVersion();
     m_minor_os_version = 0;
     m_update_os_version = 0;
     return m_major_os_version != 0;
 }
+
+uint32_t
+PlatformAndroid::LoadImage(lldb_private::Process* process, const FileSpec& image_spec, Error& error)
+{
+    char path[PATH_MAX];
+    image_spec.GetPath(path, sizeof(path));
+
+    StreamString expr;
+    expr.Printf(R"(
+                   struct __lldb_dlopen_result { void *image_ptr; const char *error_str; } the_result;
+                   the_result.image_ptr = __dl_dlopen ("%s", 2);
+                   if (the_result.image_ptr == (void*)0x0)
+                       the_result.error_str = __dl_dlerror();
+                   else
+                       the_result.error_str = (const char*)0x0;
+                   the_result;
+                  )",
+                  path);
+    const char *prefix = R"(
+                            extern "C" void* __dl_dlopen(const char* path, int mode);
+                            extern "C" const char *__dl_dlerror(void);
+                            )";
+    lldb::ValueObjectSP result_valobj_sp;
+    error = EvaluateLibdlExpression(process, expr.GetData(), prefix, result_valobj_sp);
+    if (error.Fail())
+        return LLDB_INVALID_IMAGE_TOKEN;
+
+    error = result_valobj_sp->GetError();
+    if (error.Fail())
+        return LLDB_INVALID_IMAGE_TOKEN;
+
+    Scalar scalar;
+    ValueObjectSP image_ptr_sp = result_valobj_sp->GetChildAtIndex(0, true);
+    if (!image_ptr_sp || !image_ptr_sp->ResolveValue(scalar))
+    {
+        error.SetErrorStringWithFormat("unable to load '%s'", path);
+        return LLDB_INVALID_IMAGE_TOKEN;
+    }
+
+    addr_t image_ptr = scalar.ULongLong(LLDB_INVALID_ADDRESS);
+    if (image_ptr != 0 && image_ptr != LLDB_INVALID_ADDRESS)
+        return process->AddImageToken(image_ptr);
+
+    if (image_ptr == 0)
+    {
+        ValueObjectSP error_str_sp = result_valobj_sp->GetChildAtIndex(1, true);
+        if (error_str_sp && error_str_sp->IsCStringContainer(true))
+        {
+            DataBufferSP buffer_sp(new DataBufferHeap(10240,0));
+            size_t num_chars = error_str_sp->ReadPointedString (buffer_sp, error, 10240).first;
+            if (error.Success() && num_chars > 0)
+                error.SetErrorStringWithFormat("dlopen error: %s", buffer_sp->GetBytes());
+            else
+                error.SetErrorStringWithFormat("dlopen failed for unknown reasons.");
+            return LLDB_INVALID_IMAGE_TOKEN;
+        }
+    }
+    error.SetErrorStringWithFormat("unable to load '%s'", path);
+    return LLDB_INVALID_IMAGE_TOKEN;
+}
+
+Error
+PlatformAndroid::UnloadImage (lldb_private::Process* process, uint32_t image_token)
+{
+    const addr_t image_addr = process->GetImagePtrFromToken(image_token);
+    if (image_addr == LLDB_INVALID_ADDRESS)
+        return Error("Invalid image token");
+
+    StreamString expr;
+    expr.Printf("__dl_dlclose((void*)0x%" PRIx64 ")", image_addr);
+    const char *prefix = "extern \"C\" int __dl_dlclose(void* handle);\n";
+    lldb::ValueObjectSP result_valobj_sp;
+    Error error = EvaluateLibdlExpression(process, expr.GetData(), prefix, result_valobj_sp);
+    if (error.Fail())
+        return error;
+
+    if (result_valobj_sp->GetError().Fail())
+        return result_valobj_sp->GetError();
+
+    Scalar scalar;
+    if (result_valobj_sp->ResolveValue(scalar))
+    {
+        if (scalar.UInt(1))
+            return Error("expression failed: \"%s\"", expr.GetData());
+        process->ResetImageToken(image_token);
+    }
+    return Error();
+}

lldb/trunk/source/Plugins/Platform/POSIX/PlatformPOSIX.h

public:
     CalculateTrapHandlerSymbolNames () override;
 
     lldb_private::Error
     ConnectRemote (lldb_private::Args& args) override;
 
     lldb_private::Error
     DisconnectRemote () override;
 
+    uint32_t
+    LoadImage (lldb_private::Process* process,
+               const lldb_private::FileSpec& image_spec,
+               lldb_private::Error& error) override;
+
+    lldb_private::Error
+    UnloadImage (lldb_private::Process* process, uint32_t image_token) override;
+
 protected:
     std::unique_ptr<lldb_private::OptionGroupOptions> m_options;
-        
     lldb::PlatformSP m_remote_platform_sp; // Allow multiple ways to connect to a remote POSIX-compliant OS
-    
+    lldb_private::Error
+    EvaluateLibdlExpression(lldb_private::Process* process,
+                            const char *expr_cstr,
+                            const char *expr_prefix,
+                            lldb::ValueObjectSP& result_valobj_sp);
+
 private:
     DISALLOW_COPY_AND_ASSIGN (PlatformPOSIX);
 };
 
 #endif // liblldb_PlatformPOSIX_h_

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

 // Other libraries and framework includes
 // Project includes
 
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/StreamString.h"
+#include "lldb/Core/ValueObject.h"
+#include "lldb/Expression/UserExpression.h"
 #include "lldb/Host/File.h"
 #include "lldb/Host/FileCache.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Target/DynamicLoader.h"
+#include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/ProcessLaunchInfo.h"
+#include "lldb/Target/Thread.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 
 //------------------------------------------------------------------
 /// Default Constructor
 //------------------------------------------------------------------
else
             error.SetErrorString ("the platform is not currently connected");
     }
     return process_sp;
 
 }
 
 void
 PlatformPOSIX::CalculateTrapHandlerSymbolNames ()
-{   
+{
     m_trap_handlers.push_back (ConstString ("_sigtramp"));
-}   
+}
+
+Error
+PlatformPOSIX::EvaluateLibdlExpression(lldb_private::Process* process,
+                                       const char* expr_cstr,
+                                       const char* expr_prefix,
+                                       lldb::ValueObjectSP& result_valobj_sp)
+{
+    DynamicLoader *loader = process->GetDynamicLoader();
+    if (loader)
+    {
+        Error error = loader->CanLoadImage();
+        if (error.Fail())
+            return error;
+    }
+
+    ThreadSP thread_sp(process->GetThreadList().GetSelectedThread());
+    if (!thread_sp)
+        return Error("Selected thread isn't valid");
+
+    StackFrameSP frame_sp(thread_sp->GetStackFrameAtIndex(0));
+    if (!frame_sp)
+        return Error("Frame 0 isn't valid");
+
+    ExecutionContext exe_ctx;
+    frame_sp->CalculateExecutionContext(exe_ctx);
+    EvaluateExpressionOptions expr_options;
+    expr_options.SetUnwindOnError(true);
+    expr_options.SetIgnoreBreakpoints(true);
+    expr_options.SetExecutionPolicy(eExecutionPolicyAlways);
+    expr_options.SetLanguage(eLanguageTypeC_plus_plus);
+
+    Error expr_error;
+    UserExpression::Evaluate(exe_ctx,
+                             expr_options,
+                             expr_cstr,
+                             expr_prefix,
+                             result_valobj_sp,
+                             expr_error);
+    if (result_valobj_sp->GetError().Fail())
+        return result_valobj_sp->GetError();
+    return Error();
+}
+
+uint32_t
+PlatformPOSIX::LoadImage(lldb_private::Process* process, const FileSpec& image_spec, Error& error)
+{
+    char path[PATH_MAX];
+    image_spec.GetPath(path, sizeof(path));
+
+    StreamString expr;
+    expr.Printf(R"(
+                   struct __lldb_dlopen_result { void *image_ptr; const char *error_str; } the_result;
+                   the_result.image_ptr = dlopen ("%s", 2);
+                   if (the_result.image_ptr == (void *) 0x0)
+                   {
+                       the_result.error_str = dlerror();
+                   }
+                   else
+                   {
+                       the_result.error_str = (const char *) 0x0;
+                   }
+                   the_result;
+                  )",
+                  path);
+    const char *prefix = R"(
+                            extern "C" void* dlopen (const char *path, int mode);
+                            extern "C" const char *dlerror (void);
+                            )";
+    lldb::ValueObjectSP result_valobj_sp;
+    error = EvaluateLibdlExpression(process, expr.GetData(), prefix, result_valobj_sp);
+    if (error.Fail())
+        return LLDB_INVALID_IMAGE_TOKEN;
+
+    error = result_valobj_sp->GetError();
+    if (error.Fail())
+        return LLDB_INVALID_IMAGE_TOKEN;
+
+    Scalar scalar;
+    ValueObjectSP image_ptr_sp = result_valobj_sp->GetChildAtIndex(0, true);
+    if (!image_ptr_sp || !image_ptr_sp->ResolveValue(scalar))
+    {
+        error.SetErrorStringWithFormat("unable to load '%s'", path);
+        return LLDB_INVALID_IMAGE_TOKEN;
+    }
+
+    addr_t image_ptr = scalar.ULongLong(LLDB_INVALID_ADDRESS);
+    if (image_ptr != 0 && image_ptr != LLDB_INVALID_ADDRESS)
+        return process->AddImageToken(image_ptr);
+
+    if (image_ptr == 0)
+    {
+        ValueObjectSP error_str_sp = result_valobj_sp->GetChildAtIndex(1, true);
+        if (error_str_sp && error_str_sp->IsCStringContainer(true))
+        {
+            DataBufferSP buffer_sp(new DataBufferHeap(10240,0));
+            size_t num_chars = error_str_sp->ReadPointedString (buffer_sp, error, 10240).first;
+            if (error.Success() && num_chars > 0)
+                error.SetErrorStringWithFormat("dlopen error: %s", buffer_sp->GetBytes());
+            else
+                error.SetErrorStringWithFormat("dlopen failed for unknown reasons.");
+            return LLDB_INVALID_IMAGE_TOKEN;
+        }
+    }
+    error.SetErrorStringWithFormat("unable to load '%s'", path);
+    return LLDB_INVALID_IMAGE_TOKEN;
+}
+
+Error
+PlatformPOSIX::UnloadImage (lldb_private::Process* process, uint32_t image_token)
+{
+    const addr_t image_addr = process->GetImagePtrFromToken(image_token);
+    if (image_addr == LLDB_INVALID_ADDRESS)
+        return Error("Invalid image token");
+
+    StreamString expr;
+    expr.Printf("dlclose((void *)0x%" PRIx64 ")", image_addr);
+    const char *prefix = "extern \"C\" int dlclose(void* handle);\n";
+    lldb::ValueObjectSP result_valobj_sp;
+    Error error = EvaluateLibdlExpression(process, expr.GetData(), prefix, result_valobj_sp);
+    if (error.Fail())
+        return error;
+
+    if (result_valobj_sp->GetError().Fail())
+        return result_valobj_sp->GetError();
+
+    Scalar scalar;
+    if (result_valobj_sp->ResolveValue(scalar))
+    {
+        if (scalar.UInt(1))
+            return Error("expression failed: \"%s\"", expr.GetData());
+        process->ResetImageToken(image_token);
+    }
+    return Error();
+}

lldb/trunk/source/Target/Platform.cpp

 
 const UnixSignalsSP &
 Platform::GetUnixSignals()
 {
     if (IsHost())
         return Host::GetUnixSignals();
     return GetRemoteUnixSignals();
 }
+
+uint32_t
+Platform::LoadImage(lldb_private::Process* process, const FileSpec& image_spec, Error& error)
+{
+    error.SetErrorString("LoadImage is not supported on the current platform");
+    return LLDB_INVALID_IMAGE_TOKEN;
+}
+
+Error
+Platform::UnloadImage(lldb_private::Process* process, uint32_t image_token)
+{
+    return Error("UnLoadImage is not supported on the current platform");
+}

lldb/trunk/source/Target/Process.cpp

 }
 
 addr_t
 Process::GetImageInfoAddress()
 {
     return LLDB_INVALID_ADDRESS;
 }
 
-//----------------------------------------------------------------------
-// LoadImage
-//
-// This function provides a default implementation that works for most
-// unix variants. Any Process subclasses that need to do shared library
-// loading differently should override LoadImage and UnloadImage and
-// do what is needed.
-//----------------------------------------------------------------------
-uint32_t
-Process::LoadImage (const FileSpec &image_spec, Error &error)
-{
-    if (m_finalizing)
-    {
-        error.SetErrorString("process is tearing itself down");
-        return LLDB_INVALID_IMAGE_TOKEN;
-    }
-
-    char path[PATH_MAX];
-    image_spec.GetPath(path, sizeof(path));
-
-    DynamicLoader *loader = GetDynamicLoader();
-    if (loader)
-    {
-        error = loader->CanLoadImage();
-        if (error.Fail())
-            return LLDB_INVALID_IMAGE_TOKEN;
-    }
-    
-    if (error.Success())
-    {
-        ThreadSP thread_sp(GetThreadList ().GetSelectedThread());
-        
-        if (thread_sp)
-        {
-            StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
-            
-            if (frame_sp)
-            {
-                ExecutionContext exe_ctx;
-                frame_sp->CalculateExecutionContext (exe_ctx);
-                EvaluateExpressionOptions expr_options;
-                expr_options.SetUnwindOnError(true);
-                expr_options.SetIgnoreBreakpoints(true);
-                expr_options.SetExecutionPolicy(eExecutionPolicyAlways);
-                expr_options.SetResultIsInternal(true);
-                expr_options.SetLanguage(eLanguageTypeC_plus_plus);
-                
-                StreamString expr;
-                expr.Printf(R"(
-                               struct __lldb_dlopen_result { void *image_ptr; const char *error_str; } the_result;
-                               the_result.image_ptr = dlopen ("%s", 2);
-                               if (the_result.image_ptr == (void *) 0x0)
-                               {
-                                   the_result.error_str = dlerror();
-                               }
-                               else
-                               {
-                                   the_result.error_str = (const char *) 0x0;
-                               }
-                               the_result;
-                              )",
-                              path);
-                const char *prefix = R"(
-                                        extern "C" void* dlopen (const char *path, int mode);
-                                        extern "C" const char *dlerror (void);
-                                        )";
-                lldb::ValueObjectSP result_valobj_sp;
-                Error expr_error;
-                UserExpression::Evaluate (exe_ctx,
-                                          expr_options,
-                                          expr.GetData(),
-                                          prefix,
-                                          result_valobj_sp,
-                                          expr_error);
-                if (expr_error.Success())
-                {
-                    error = result_valobj_sp->GetError();
-                    if (error.Success())
-                    {
-                        Scalar scalar;
-                        ValueObjectSP image_ptr_sp = result_valobj_sp->GetChildAtIndex(0, true);
-                        if (image_ptr_sp && image_ptr_sp->ResolveValue (scalar))
-                        {
-                            addr_t image_ptr = scalar.ULongLong(LLDB_INVALID_ADDRESS);
-                            if (image_ptr != 0 && image_ptr != LLDB_INVALID_ADDRESS)
-                            {
-                                uint32_t image_token = m_image_tokens.size();
-                                m_image_tokens.push_back (image_ptr);
-                                return image_token;
-                            }
-                            else if (image_ptr == 0)
-                            {
-                                ValueObjectSP error_str_sp = result_valobj_sp->GetChildAtIndex(1, true);
-                                if (error_str_sp)
-                                {
-                                    if (error_str_sp->IsCStringContainer(true))
-                                    {
-                                        DataBufferSP buffer_sp(new DataBufferHeap(10240,0));
-                                        size_t num_chars = error_str_sp->ReadPointedString (buffer_sp, error, 10240).first;
-                                        if (error.Success() && num_chars > 0)
-                                        {
-                                            error.Clear();
-                                            error.SetErrorStringWithFormat("dlopen error: %s", buffer_sp->GetBytes());
-                                        }
-                                        else
-                                        {
-                                            error.Clear();
-                                            error.SetErrorStringWithFormat("dlopen failed for unknown reasons.");
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                else
-                    error = expr_error;
-            }
-        }
-    }
-    if (!error.AsCString())
-        error.SetErrorStringWithFormat("unable to load '%s'", path);
-    return LLDB_INVALID_IMAGE_TOKEN;
-}
-
-//----------------------------------------------------------------------
-// UnloadImage
-//
-// This function provides a default implementation that works for most
-// unix variants. Any Process subclasses that need to do shared library
-// loading differently should override LoadImage and UnloadImage and
-// do what is needed.
-//----------------------------------------------------------------------
-Error
-Process::UnloadImage (uint32_t image_token)
-{
-    Error error;
-
-    if (m_finalizing)
-    {
-        error.SetErrorString("process is tearing itself down");
-        return error;
-    }
-
-    if (image_token < m_image_tokens.size())
-    {
-        const addr_t image_addr = m_image_tokens[image_token];
-        if (image_addr == LLDB_INVALID_ADDRESS)
-        {
-            error.SetErrorString("image already unloaded");
-        }
-        else
-        {
-            DynamicLoader *loader = GetDynamicLoader();
-            if (loader)
-                error = loader->CanLoadImage();
-            
-            if (error.Success())
-            {
-                ThreadSP thread_sp(GetThreadList ().GetSelectedThread());
-                
-                if (thread_sp)
-                {
-                    StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
-                    
-                    if (frame_sp)
-                    {
-                        ExecutionContext exe_ctx;
-                        frame_sp->CalculateExecutionContext (exe_ctx);
-                        EvaluateExpressionOptions expr_options;
-                        expr_options.SetUnwindOnError(true);
-                        expr_options.SetIgnoreBreakpoints(true);
-                        expr_options.SetExecutionPolicy(eExecutionPolicyAlways);
-                        expr_options.SetLanguage(eLanguageTypeC_plus_plus);
-                        
-                        StreamString expr;
-                        expr.Printf("dlclose ((void *)0x%" PRIx64 ")", image_addr);
-                        const char *prefix = "extern \"C\" int dlclose(void* handle);\n";
-                        lldb::ValueObjectSP result_valobj_sp;
-                        Error expr_error;
-                        UserExpression::Evaluate (exe_ctx,
-                                                  expr_options,
-                                                  expr.GetData(),
-                                                  prefix,
-                                                  result_valobj_sp,
-                                                  expr_error);
-                        if (result_valobj_sp->GetError().Success())
-                        {
-                            Scalar scalar;
-                            if (result_valobj_sp->ResolveValue (scalar))
-                            {
-                                if (scalar.UInt(1))
-                                {
-                                    error.SetErrorStringWithFormat("expression failed: \"%s\"", expr.GetData());
-                                }
-                                else
-                                {
-                                    m_image_tokens[image_token] = LLDB_INVALID_ADDRESS;
-                                }
-                            }
-                        }
-                        else
-                        {
-                            error = result_valobj_sp->GetError();
-                        }
-                    }
-                }
-            }
-        }
-    }
-    else
-    {
-        error.SetErrorString("invalid image token");
-    }
-    return error;
-}
-
 const lldb::ABISP &
 Process::GetABI()
 {
     if (!m_abi_sp)
         m_abi_sp = ABI::FindPlugin(GetTarget().GetArchitecture());
     return m_abi_sp;
 }
 

 bool
 Process::GetModuleSpec(const FileSpec& module_file_spec,
                        const ArchSpec& arch,
                        ModuleSpec& module_spec)
 {
     module_spec.Clear();
     return false;
 }
+
+size_t
+Process::AddImageToken(lldb::addr_t image_ptr)
+{
+    m_image_tokens.push_back(image_ptr);
+    return m_image_tokens.size() - 1;
+}
+
+lldb::addr_t
+Process::GetImagePtrFromToken(size_t token) const
+{
+    if (token < m_image_tokens.size())
+        return m_image_tokens[token];
+    return LLDB_INVALID_IMAGE_TOKEN;
+}
+
+void
+Process::ResetImageToken(size_t token)
+{
+    if (token < m_image_tokens.size())
+        m_image_tokens[token] = LLDB_INVALID_IMAGE_TOKEN;
+}
 No newline at end of file