Fix "process load" on new android targets

[labath]

Summary

On older android targets, we needed a dlopen rename workaround to get
"process load" working. Since API 25 this is not required as the targets
have a proper libdl so with the function names one would expect.

To make this work I've had to remove the const qualifier from the
GetLibdlFunctionDeclarations function (as now the declarations can
depend on the connected target). Since I was already modifying the
prototype (and the lower levels were already converted to StringRef) I
took the oportunity to convert this function as well.

[labath]

The sdk version I used here is incorrect. Shelve this until we can get the right version here.

source/Plugins/Platform/Android/PlatformAndroid.h

protected:
 
   Error DownloadModuleSlice(const FileSpec &src_file_spec,
                             const uint64_t src_offset, const uint64_t src_size,
                             const FileSpec &dst_file_spec) override;
 
   Error DownloadSymbolFile(const lldb::ModuleSP &module_sp,
                            const FileSpec &dst_file_spec) override;
 
-  const char *GetLibdlFunctionDeclarations() const override;
+  llvm::StringRef GetLibdlFunctionDeclarations() override;
 
 private:
   AdbClient::SyncService *GetSyncService(Error &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_

source/Plugins/Platform/Android/PlatformAndroid.cpp

 
 bool PlatformAndroid::GetRemoteOSVersion() {
   m_major_os_version = GetSdkVersion();
   m_minor_os_version = 0;
   m_update_os_version = 0;
   return m_major_os_version != 0;
 }
 
-const char *PlatformAndroid::GetLibdlFunctionDeclarations() const {
+llvm::StringRef PlatformAndroid::GetLibdlFunctionDeclarations() {
+  // Older platform versions have the dl function symbols mangled
+  if (GetSdkVersion() < 25)
     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();
 }
 
 AdbClient::SyncService *PlatformAndroid::GetSyncService(Error &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;
 }

source/Plugins/Platform/POSIX/PlatformPOSIX.h

protected:
   std::map<lldb_private::CommandInterpreter *,
            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,
+                          llvm::StringRef expr_prefix,
                           lldb::ValueObjectSP &result_valobj_sp);
 
-  virtual const char *GetLibdlFunctionDeclarations() const;
+  virtual llvm::StringRef GetLibdlFunctionDeclarations();
 
 private:
   DISALLOW_COPY_AND_ASSIGN(PlatformPOSIX);
 };
 
 #endif // liblldb_PlatformPOSIX_h_

source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

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

 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 = GetLibdlFunctionDeclarations();
+  llvm::StringRef prefix = GetLibdlFunctionDeclarations();
   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();
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);
 }
 
-const char *PlatformPOSIX::GetLibdlFunctionDeclarations() const {
+llvm::StringRef PlatformPOSIX::GetLibdlFunctionDeclarations() {
   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);
              )";
 }