Fix for remote-linux test fails: use currently selected platform on target launch

[omjavaid]

Summary

This patch fixes a bug which was causing test failures on remote targets.

LLDB was select default platform instead of currently select target platform due to which following use case ended up launching a local debug server instead of spawning a server on currently connect + select platform.
file a.out
target select remote-linux
target connect connect://hostname:5432
run

on issuing run command lldb will launch the target with old platform pointer select by default on creating Target with command file a.out.

This patch fixes this behavior by updating the sp_platform to currently selected platform making sure we launch debugserver on the right platform.

This should fix all remote tests that issues a command sequence following a file command.

[tberghammer]

I agree that the current implementation is annoying with using the platform selected at target creation time, but changing the platform for a target after it is created might be dangerous because it can cache information from the platform.

target create a.out
breakpoint set -n printf
process launch
platform select remote-linux
platform connect ...
process launch # At this point I think the modules will be loaded and the breakpoints will be resolved to the wrong address

I don't know what is the best solution, but silently changing the platform of a target isn't sounds like the right approach

[clayborg]

The target should get the currently selected platform when the target is created as long as the architecture in the supplied executable is compatible with the currently selected platform. It the executable arch isn't compatible, a compatible platform will be auto selected. I don't believe this change is correct and probably should not be committed.

[clayborg]

So you must select the platform first:

target select remote-linux
file a.out
target connect connect://hostname:5432
run

[ted]

In D11129#203583, @tberghammer wrote:

I agree that the current implementation is annoying with using the platform selected at target creation time, but changing the platform for a target after it is created might be dangerous because it can cache information from the platform.

Platform select at target creation time is needed for non-native targets. If I load a standalone Hexagon executable while on Linux, the Platform needs to be switched to the Hexagon Simulator Platform. If I load a Hexagon Linux executable while on Windows, the Platform needs to be switched to the Linux platform.

The current logic should only switch Platforms to match the Target if the currently selected Platform isn't compatible.

source/Target/Target.cpp

Target::Launch (ProcessLaunchInfo &launch_info, Stream *stream)
     launch_info.GetFlags().Set (eLaunchFlagDebug);
     
     // Get the value of synchronous execution here.  If you wait till after you have started to
     // run, then you could have hit a breakpoint, whose command might switch the value, and
     // then you'll pick up that incorrect value.
     Debugger &debugger = GetDebugger();
     const bool synchronous_execution = debugger.GetCommandInterpreter().GetSynchronous ();
     
-    PlatformSP platform_sp (GetPlatform());
+    const auto platform_sp = GetDebugger ().GetPlatformList ().GetSelectedPlatform ();
     
     // Finalize the file actions, and if none were given, default to opening
     // up a pseudo terminal
     const bool default_to_use_pty = platform_sp ? platform_sp->IsHost() : false;
     if (log)
         log->Printf ("Target::%s have platform=%s, platform_sp->IsHost()=%s, default_to_use_pty=%s",
                      __FUNCTION__,
                      platform_sp ? "true" : "false",
if (!launch_info.GetArchitecture().IsValid())
         launch_info.GetArchitecture() = GetArchitecture();
 
     // If we're not already connected to the process, and if we have a platform that can launch a process for debugging, go ahead and do that here.
     if (state != eStateConnected && platform_sp && platform_sp->CanDebugProcess ())
     {
         if (log)
             log->Printf ("Target::%s asking the platform to debug the process", __FUNCTION__);
 
+        SetPlatform (platform_sp);
         // Get a weak pointer to the previous process if we have one
         ProcessWP process_wp;
         if (m_process_sp)
             process_wp = m_process_sp;
         m_process_sp = GetPlatform()->DebugProcess (launch_info,
                                                     debugger,
                                                     this,
                                                     error);