[lldb] Fix assertion when ScriptedProcess have no pid after launch

[mib]

Summary

This patch should fix an assertion that causes some test failures:
https://ci.swift.org/view/LLDB/job/llvm-org-lldb-release-debuginfo/3587/console

This was caused by the changes introduces in 88f409194d5a where we
replaced DidLaunch by DidResume in the ScriptedProcess class.

However, by the time we resume the process, the pid should be already
set. To address this, this patch brings back DidLaunch which will
initialize the ScriptedProcess pid with a placeholder value. That value
will be updated in DidResume to the final pid.

Note, this 2 stage PID initialization is necessary sometimes, when the
scripted process gets stopped at entry (launch) and gets assigned an
object that contains the PID value. In this case, we need to update the
PID when we resume the process after we've stopped at entry.

This also replaces the default scripted process id to an arbitrary
number (42) since the current value (0) is considered invalid.

Signed-off-by: Med Ismail Bennani <[e-mail]>

lldb/examples/python/scripted_process/crashlog_scripted_process.py

def read_memory_at_address(self, addr: int, size: int, error: lldb.SBError) -> lldb.SBData:
         # NOTE: CrashLogs don't contain any memory.
         return lldb.SBData()
 
     def get_loaded_images(self):
         # TODO: Iterate over corefile_target modules and build a data structure
         # from it.
         return self.loaded_images
 
-    def get_process_id(self) -> int:
-        return self.pid
-
     def should_stop(self) -> bool:
         return True
 
     def is_alive(self) -> bool:
         return True
 
     def get_scripted_thread_plugin(self):
         return CrashLogScriptedThread.__module__ + "." + CrashLogScriptedThread.__name__

lldb/examples/python/scripted_process/scripted_process.py

def __init__(self, exe_ctx, args):
                 self.arch = triple.split('-')[0]
             self.dbg = target.GetDebugger()
         if isinstance(args, lldb.SBStructuredData) and args.IsValid():
             self.args = args
         self.threads = {}
         self.loaded_images = []
         self.metadata = {}
         self.capabilities = {}
+        self.pid = 42
 
     def get_capabilities(self):
         """ Get a dictionary containing the process capabilities.
 
         Returns:
             Dict[str:bool]: The dictionary of capability, with the capability
             name as the key and a boolean flag as the value.
             The dictionary can be empty.
def get_loaded_images(self):
         return self.loaded_images
 
     def get_process_id(self):
         """ Get the scripted process identifier.
 
         Returns:
             int: The scripted process identifier.
         """
-        return 0
+        return self.pid
 
     def launch(self):
         """ Simulate the scripted process launch.
 
         Returns:
             lldb.SBError: An `lldb.SBError` with error code 0.
         """
         return lldb.SBError()

lldb/source/Plugins/Process/scripted/ScriptedProcess.h

public:
   DynamicLoader *GetDynamicLoader() override { return nullptr; }
 
   llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
 
   Status DoLoadCore() override;
 
   Status DoLaunch(Module *exe_module, ProcessLaunchInfo &launch_info) override;
 
+  void DidLaunch() override;
+
   void DidResume() override;
 
   Status DoResume() override;
 
   Status DoAttachToProcessWithID(lldb::pid_t pid,
                                  const ProcessAttachInfo &attach_info) override;
 
   Status

lldb/source/Plugins/Process/scripted/ScriptedProcess.cpp

Status ScriptedProcess::DoLaunch(Module *exe_module,
   //  if (state != eStateInvalid) {
   //    SetPrivateState(state);
 
   SetPrivateState(eStateStopped);
 
   return {};
 }
 
+void ScriptedProcess::DidLaunch() { m_pid = GetInterface().GetProcessID(); }
+
 void ScriptedProcess::DidResume() {
+  // Update the PID again, in case the user provided a placeholder pid at launch
   m_pid = GetInterface().GetProcessID();
   GetLoadedDynamicLibrariesInfos();
 }
 
 Status ScriptedProcess::DoResume() {
   Log *log = GetLog(LLDBLog::Process);
   // FIXME: Fetch data from thread.
   const StateType thread_resume_state = eStateRunning;