[lldb/API] Introduce SBProcess::ForceScriptedState method

[mib]

Summary

This patch introduces a new method to the SBProcess API called
ForceScriptedState. As the name suggests, this affordance will allow the
user to alter the private state of the scripted process programatically.

This is necessary to update the scripted process state when perform
interactive debugging.

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

[mib]

I landed this by mistake ...

[jingham]

The code seems fine, but I don't think "private state" is a concept that people who aren't intimately familiar with lldb are likely to understand. I think you could just leave out private and just say it changes the process state to the new state. That's all people using it really need to know.

[mib]

Remove private state occurrences as @jingham suggested.

[JDevlieghere]

LGTM

lldb/include/lldb/API/SBProcess.h

#endif
   ///
   /// \param [in] stop_id
   ///   The ID of the stop event to return.
   ///
   /// \return
   ///   The stop event corresponding to stop ID.
   lldb::SBEvent GetStopEventForStopID(uint32_t stop_id);
 
+  /// If the process is a scripted process, changes its state to the new state.
+  /// No-op otherwise.
+  ///
+  /// \param [in] new_state
+  ///   The new state that the scripted process should be set to.
+  ///
+  void ForceScriptedState(StateType new_state);
+
   size_t ReadMemory(addr_t addr, void *buf, size_t size, lldb::SBError &error);
 
   size_t WriteMemory(addr_t addr, const void *buf, size_t size,
                      lldb::SBError &error);
 
   size_t ReadCStringFromMemory(addr_t addr, void *char_buf, size_t size,
                                lldb::SBError &error);
 

lldb/include/lldb/Target/Process.h

void PruneThreadPlans();
   /// \return
   ///     The plugin if one is available for the specified feature;
   ///     otherwise, returns an empty shared pointer.
   lldb::StructuredDataPluginSP
   GetStructuredDataPlugin(ConstString type_name) const;
 
   virtual void *GetImplementation() { return nullptr; }
 
+  virtual void ForceScriptedState(lldb::StateType state) {}
+
 protected:
   friend class Trace;
 
   /// Construct with a shared pointer to a target, and the Process listener.
   /// Uses the Host UnixSignalsSP by default.
   Process(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp);
 
   /// Construct with a shared pointer to a target, the Process listener, and

lldb/source/API/SBProcess.cpp

std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     event_sp = process_sp->GetStopEventForStopID(stop_id);
     sb_event.reset(event_sp);
   }
 
   return sb_event;
 }
 
+void SBProcess::ForceScriptedState(StateType new_state) {
+  LLDB_INSTRUMENT_VA(this, new_state);
+
+  if (ProcessSP process_sp = GetSP()) {
+    std::lock_guard<std::recursive_mutex> guard(
+        process_sp->GetTarget().GetAPIMutex());
+    process_sp->ForceScriptedState(new_state);
+  }
+}
+
 StateType SBProcess::GetState() {
   LLDB_INSTRUMENT_VA(this);
 
   StateType ret_val = eStateInvalid;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());

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

public:
   GetLoadedDynamicLibrariesInfos() override;
 
   lldb_private::StructuredData::DictionarySP GetMetadata() override;
 
   void UpdateQueueListIfNeeded() override;
 
   void *GetImplementation() override;
 
+  void ForceScriptedState(lldb::StateType state) override {
+    SetPrivateState(state);
+  }
+
 protected:
   ScriptedProcess(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
                   const ScriptedMetadata &scripted_metadata, Status &error);
 
   Status DoStop();
 
   void Clear();