[lldb] Duplicate Target::Launch resuming logic into CommandObjectPlatformProcessLaunch

[kastiglione]

Summary

Fix platform process launch on macOS where it fails for lack of auto-resuming support.

This change reproduces the resuming logic found in Target::Launch.

This issue was identified by @DavidSpickett in D153636. This change relies on the tests
added in that PR. Thanks David.

[jingham]

The fact that you had to duplicate code from Target::Launch means the various paths to Launching a process aren't properly factored out. However, that seems like a lot just to get Dave's fix for "platform process launch" working, so this LGTM as a short-term patch.

[DavidSpickett]

lldb/source/Commands/CommandObjectPlatform.cpp

1232

This assert fails on Linux. Is it necessary or should I look into why it's null here on Linux?

WaitForProcessToStop on down either checks that the pointer is non null before use, or substitutes in another (presumably non-null) hijacker.

[DavidSpickett]

Thanks for testing and fixing this.

[DavidSpickett]

lldb/source/Commands/CommandObjectPlatform.cpp

1232

To clarify, fails while running the tests in https://reviews.llvm.org/D153636.

[kastiglione]

lldb/source/Commands/CommandObjectPlatform.cpp

1232

I included it to follow (copy) Target::Launch. I don't know for fact that it's needed, so +1 to removing the assert if needed for Linux.

lldb/source/Commands/CommandObjectPlatform.cpp

 #include "lldb/Interpreter/OptionGroupFile.h"
 #include "lldb/Interpreter/OptionGroupPlatform.h"
 #include "lldb/Interpreter/OptionGroupPythonClassWithDict.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/ScriptedMetadata.h"
+#include "lldb/Utility/State.h"
 
 #include "llvm/ADT/SmallString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static mode_t ParsePermissionString(const char *) = delete;
 
if (platform_sp) {
       if (m_options.launch_info.GetExecutableFile()) {
         Debugger &debugger = GetDebugger();
 
         if (argc == 0)
           target->GetRunArguments(m_options.launch_info.GetArguments());
 
         ProcessSP process_sp(platform_sp->DebugProcess(
             m_options.launch_info, debugger, *target, error));
+
+        if (!process_sp && error.Success()) {
+          result.AppendError("failed to launch or debug process");
+          return false;
+        } else if (!error.Success()) {
+          result.AppendError(error.AsCString());
+          return false;
+        }
+
+        const bool synchronous_execution =
+            debugger.GetCommandInterpreter().GetSynchronous();
+        auto launch_info = m_options.launch_info;
+        bool rebroadcast_first_stop =
+            !synchronous_execution &&
+            launch_info.GetFlags().Test(eLaunchFlagStopAtEntry);
+
+        assert(launch_info.GetHijackListener());
+
+        EventSP first_stop_event_sp;
+        StateType state = process_sp->WaitForProcessToStop(
+            std::nullopt, &first_stop_event_sp, rebroadcast_first_stop,
+            launch_info.GetHijackListener());
+        process_sp->RestoreProcessEvents();
+
+        if (rebroadcast_first_stop) {
+          assert(first_stop_event_sp);
+          process_sp->BroadcastEvent(first_stop_event_sp);
+          return true;
+        }
+
+        switch (state) {
+        case eStateStopped: {
+          if (launch_info.GetFlags().Test(eLaunchFlagStopAtEntry))
+            break;
+          if (synchronous_execution) {
+            // Now we have handled the stop-from-attach, and we are just
+            // switching to a synchronous resume.  So we should switch to the
+            // SyncResume hijacker.
+            process_sp->ResumeSynchronous(&result.GetOutputStream());
+          } else {
+            error = process_sp->Resume();
+            if (!error.Success()) {
+              result.AppendErrorWithFormat(
+                  "process resume at entry point failed: %s",
+                  error.AsCString());
+            }
+          }
+        } break;
+        default:
+          result.AppendErrorWithFormat(
+              "initial process state wasn't stopped: %s",
+              StateAsCString(state));
+          break;
+        }
+
         if (process_sp && process_sp->IsAlive()) {
           result.SetStatus(eReturnStatusSuccessFinishNoResult);
           return true;
         }
-
-        if (error.Success())
-          result.AppendError("process launch failed");
-        else
-          result.AppendError(error.AsCString());
       } else {
         result.AppendError("'platform process launch' uses the current target "
                            "file and arguments, or the executable and its "
                            "arguments can be specified in this command");
         return false;
       }
     } else {
       result.AppendError("no platform is selected\n");