Fix "process load/unload" on android

[nitesh.jain]

Summary

To detect the correct function name based on the list of available symbols instead of based on the SDK version

[tberghammer]

source/Plugins/Platform/Android/PlatformAndroid.cpp

376–378 ↗

(On Diff #110142)

(nit): Formatting

384 ↗

(On Diff #110142)

Can we use "if (!strcmp(dl_open_name, "__dl_dlopen"))" instead?

I am slightly concerned that some applications will have an unused and broken dlopen shim what we would detect with this code. I think the risk of having a random function named __dl_dlopen is lower then that.

[clayborg]

source/Plugins/Platform/Android/PlatformAndroid.cpp

384 ↗

(On Diff #110142)

Shouldn't this if statement be looking for "__dl_dlopen" as the name in dl_open_name? Also you can avoid the strcmp and you can just do a pointer compare:

if (dl_open_name == dl_open_names[0])

[nitesh.jain]

Update diff as per suggestion

[nitesh.jain]

Fix Format.

[tberghammer]

Thanks for fixing it

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

protected:
 
   Status DownloadModuleSlice(const FileSpec &src_file_spec,
                              const uint64_t src_offset, const uint64_t src_size,
                              const FileSpec &dst_file_spec) override;
 
   Status DownloadSymbolFile(const lldb::ModuleSP &module_sp,
                             const FileSpec &dst_file_spec) override;
 
-  llvm::StringRef GetLibdlFunctionDeclarations() override;
+  llvm::StringRef
+  GetLibdlFunctionDeclarations(lldb_private::Process *process) override;
 
 private:
   AdbClient::SyncService *GetSyncService(Status &error);
 
   std::unique_ptr<AdbClient::SyncService> m_adb_sync_svc;
   std::string m_device_id;
   uint32_t m_sdk_version;
 
   DISALLOW_COPY_AND_ASSIGN(PlatformAndroid);
 };
 
 } // namespace platofor_android
 } // namespace lldb_private
 
 #endif // liblldb_PlatformAndroid_h_

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

 #include "lldb/Host/StringConvert.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/UriParser.h"
 
 // Project includes
 #include "AdbClient.h"
 #include "PlatformAndroid.h"
 #include "PlatformAndroidRemoteGDBServer.h"
+#include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::platform_android;
 using namespace std::chrono;
 
 static uint32_t g_initialize_count = 0;
 static const unsigned int g_android_default_cache_size =

 
 bool PlatformAndroid::GetRemoteOSVersion() {
   m_major_os_version = GetSdkVersion();
   m_minor_os_version = 0;
   m_update_os_version = 0;
   return m_major_os_version != 0;
 }
 
-llvm::StringRef PlatformAndroid::GetLibdlFunctionDeclarations() {
+llvm::StringRef
+PlatformAndroid::GetLibdlFunctionDeclarations(lldb_private::Process *process) {
+  SymbolContextList matching_symbols;
+  std::vector<const char *> dl_open_names = { "__dl_dlopen", "dlopen" };
+  const char *dl_open_name = nullptr;
+  Target &target = process->GetTarget();
+  for (auto name: dl_open_names) {
+    if (target.GetImages().FindFunctionSymbols(ConstString(name),
+                                               eFunctionNameTypeFull,
+                                               matching_symbols)) {
+       dl_open_name = name;
+       break;
+    }
+  }
   // Older platform versions have the dl function symbols mangled
-  if (GetSdkVersion() < 26)
+  if (dl_open_name == dl_open_names[0])
     return R"(
               extern "C" void* dlopen(const char*, int) asm("__dl_dlopen");
               extern "C" void* dlsym(void*, const char*) asm("__dl_dlsym");
               extern "C" int   dlclose(void*) asm("__dl_dlclose");
               extern "C" char* dlerror(void) asm("__dl_dlerror");
              )";
 
-  return PlatformPOSIX::GetLibdlFunctionDeclarations();
+  return PlatformPOSIX::GetLibdlFunctionDeclarations(process);
 }
 
 AdbClient::SyncService *PlatformAndroid::GetSyncService(Status &error) {
   if (m_adb_sync_svc && m_adb_sync_svc->IsConnected())
     return m_adb_sync_svc.get();
 
   AdbClient adb(m_device_id);
   m_adb_sync_svc = adb.GetSyncService(error);
   return (error.Success()) ? m_adb_sync_svc.get() : nullptr;
 }

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

protected:
   lldb::PlatformSP m_remote_platform_sp; // Allow multiple ways to connect to a
                                          // remote POSIX-compliant OS
 
   lldb_private::Status
   EvaluateLibdlExpression(lldb_private::Process *process, const char *expr_cstr,
                           llvm::StringRef expr_prefix,
                           lldb::ValueObjectSP &result_valobj_sp);
 
-  virtual llvm::StringRef GetLibdlFunctionDeclarations();
+  virtual
+  llvm::StringRef GetLibdlFunctionDeclarations(lldb_private::Process *process);
 
 private:
   DISALLOW_COPY_AND_ASSIGN(PlatformPOSIX);
 };
 
 #endif // liblldb_PlatformPOSIX_h_

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

expr.Printf(R"(
                    }
                    else
                    {
                        the_result.error_str = (const char *) 0x0;
                    }
                    the_result;
                   )",
               path);
-  llvm::StringRef prefix = GetLibdlFunctionDeclarations();
+  llvm::StringRef prefix = GetLibdlFunctionDeclarations(process);
   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())

 Status 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 Status("Invalid image token");
 
   StreamString expr;
   expr.Printf("dlclose((void *)0x%" PRIx64 ")", image_addr);
-  llvm::StringRef prefix = GetLibdlFunctionDeclarations();
+  llvm::StringRef prefix = GetLibdlFunctionDeclarations(process);
   lldb::ValueObjectSP result_valobj_sp;
   Status 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();
lldb::ProcessSP PlatformPOSIX::ConnectProcess(llvm::StringRef connect_url,
   if (m_remote_platform_sp)
     return m_remote_platform_sp->ConnectProcess(connect_url, plugin_name,
                                                 debugger, target, error);
 
   return Platform::ConnectProcess(connect_url, plugin_name, debugger, target,
                                   error);
 }
 
-llvm::StringRef PlatformPOSIX::GetLibdlFunctionDeclarations() {
+llvm::StringRef
+PlatformPOSIX::GetLibdlFunctionDeclarations(lldb_private::Process *process) {
   return R"(
               extern "C" void* dlopen(const char*, int);
               extern "C" void* dlsym(void*, const char*);
               extern "C" int   dlclose(void*);
               extern "C" char* dlerror(void);
              )";
 }