[lldb][LocateModuleCallback] Update SBFileSpec/SBModuleSpec

[splhack]

Summary

RFC https://discourse.llvm.org/t/rfc-python-callback-for-target-get-module/71580

SBFileSpec and SBModuleSpec will be used for locate module callback as Python
function arguments. This diff allows these things.

• Can be instantiated from SBPlatform.
• Can be passed to/from Python.
• Can be accessed for object offset and size.

[splhack]

rebase

[splhack]

Fix LLDB_INSTRUMENT_VA args

[splhack]

fix LLDB_INSTRUMENT_VA for SBModuleSpec constructor too

[splhack]

sync with D153734 and D153735 changes

lldb/bindings/python/python-swigsafecast.swig

return ScopedPythonObject<lldb::SBCommandReturnObject>(
       SWIGTYPE_p_lldb__SBCommandReturnObject);
 }
 
 ScopedPythonObject<lldb::SBEvent> SWIGBridge::ToSWIGWrapper(Event *event) {
   return ScopedPythonObject<lldb::SBEvent>(new lldb::SBEvent(event),
                                            SWIGTYPE_p_lldb__SBEvent);
 }
 
+PythonObject SWIGBridge::ToSWIGWrapper(
+    std::unique_ptr<lldb::SBFileSpec> file_spec_sb) {
+  return ToSWIGHelper(file_spec_sb.release(), SWIGTYPE_p_lldb__SBFileSpec);
+}
+
+PythonObject SWIGBridge::ToSWIGWrapper(
+    std::unique_ptr<lldb::SBModuleSpec> module_spec_sb) {
+  return ToSWIGHelper(module_spec_sb.release(), SWIGTYPE_p_lldb__SBModuleSpec);
+}
+
 } // namespace python
 } // namespace lldb_private

lldb/include/lldb/API/SBModuleSpec.h

public:
   void SetTriple(const char *triple);
 
   const uint8_t *GetUUIDBytes();
 
   size_t GetUUIDLength();
 
   bool SetUUIDBytes(const uint8_t *uuid, size_t uuid_len);
 
+  uint64_t GetObjectOffset();
+
+  void SetObjectOffset(uint64_t object_offset);
+
+  uint64_t GetObjectSize();
+
+  void SetObjectSize(uint64_t object_size);
+
   bool GetDescription(lldb::SBStream &description);
 
 private:
   friend class SBModuleSpecList;
   friend class SBModule;
+  friend class SBPlatform;
   friend class SBTarget;
 
+  SBModuleSpec(const lldb_private::ModuleSpec &module_spec);
+
   std::unique_ptr<lldb_private::ModuleSpec> m_opaque_up;
 };
 
 class SBModuleSpecList {
 public:
   SBModuleSpecList();
 
   SBModuleSpecList(const SBModuleSpecList &rhs);

lldb/source/API/SBModuleSpec.cpp

 }
 
 SBModuleSpec::SBModuleSpec(const SBModuleSpec &rhs) {
   LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_up = clone(rhs.m_opaque_up);
 }
 
+SBModuleSpec::SBModuleSpec(const lldb_private::ModuleSpec &module_spec)
+    : m_opaque_up(new lldb_private::ModuleSpec(module_spec)) {
+  LLDB_INSTRUMENT_VA(this, module_spec);
+}
+
 const SBModuleSpec &SBModuleSpec::operator=(const SBModuleSpec &rhs) {
   LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
   return *this;
 }
 

 
 bool SBModuleSpec::GetDescription(lldb::SBStream &description) {
   LLDB_INSTRUMENT_VA(this, description);
 
   m_opaque_up->Dump(description.ref());
   return true;
 }
 
+uint64_t SBModuleSpec::GetObjectOffset() {
+  LLDB_INSTRUMENT_VA(this);
+
+  return m_opaque_up->GetObjectOffset();
+}
+
+void SBModuleSpec::SetObjectOffset(uint64_t object_offset) {
+  LLDB_INSTRUMENT_VA(this, object_offset);
+
+  m_opaque_up->SetObjectOffset(object_offset);
+}
+
+uint64_t SBModuleSpec::GetObjectSize() {
+  LLDB_INSTRUMENT_VA(this);
+
+  return m_opaque_up->GetObjectSize();
+}
+
+void SBModuleSpec::SetObjectSize(uint64_t object_size) {
+  LLDB_INSTRUMENT_VA(this, object_size);
+
+  m_opaque_up->SetObjectSize(object_size);
+}
+
 SBModuleSpecList::SBModuleSpecList() : m_opaque_up(new ModuleSpecList()) {
   LLDB_INSTRUMENT_VA(this);
 }
 
 SBModuleSpecList::SBModuleSpecList(const SBModuleSpecList &rhs)
     : m_opaque_up(new ModuleSpecList(*rhs.m_opaque_up)) {
   LLDB_INSTRUMENT_VA(this, rhs);
 }

lldb/source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h

 #include "llvm/Support/Error.h"
 
 namespace lldb {
 class SBEvent;
 class SBCommandReturnObject;
 class SBValue;
 class SBStream;
 class SBStructuredData;
+class SBFileSpec;
+class SBModuleSpec;
 } // namespace lldb
 
 namespace lldb_private {
 namespace python {
 
 typedef struct swig_type_info swig_type_info;
 
 python::PythonObject ToSWIGHelper(void *obj, swig_type_info *info);
public:
 
   static PythonObject ToSWIGWrapper(lldb::ProcessAttachInfoSP attach_info_sp);
   static PythonObject ToSWIGWrapper(lldb::ProcessLaunchInfoSP launch_info_sp);
   static PythonObject ToSWIGWrapper(lldb::DataExtractorSP data_extractor_sp);
 
   static PythonObject ToSWIGWrapper(std::unique_ptr<lldb::SBStream> stream_sb);
   static PythonObject
   ToSWIGWrapper(std::unique_ptr<lldb::SBStructuredData> data_sb);
+  static PythonObject
+  ToSWIGWrapper(std::unique_ptr<lldb::SBFileSpec> file_spec_sb);
+  static PythonObject
+  ToSWIGWrapper(std::unique_ptr<lldb::SBModuleSpec> module_spec_sb);
 
   static python::ScopedPythonObject<lldb::SBCommandReturnObject>
   ToSWIGWrapper(CommandReturnObject &cmd_retobj);
   static python::ScopedPythonObject<lldb::SBEvent> ToSWIGWrapper(Event *event);
   // These prototypes are the Pythonic implementations of the required
   // callbacks. Although these are scripting-language specific, their definition
   // depends on the public API.
 

lldb/test/API/python_api/module_spec/TestModuleSpec.py

+"""
+Test some SBModuleSpec APIs.
+"""
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+
+
+class ModuleSpecAPIsTestCase(TestBase):
+    def test_object_offset_and_size(self):
+        module_spec = lldb.SBModuleSpec()
+        self.assertEqual(module_spec.GetObjectOffset(), 0)
+        self.assertEqual(module_spec.GetObjectSize(), 0)
+
+        module_spec.SetObjectOffset(4096)
+        self.assertEqual(module_spec.GetObjectOffset(), 4096)
+
+        module_spec.SetObjectSize(3600)
+        self.assertEqual(module_spec.GetObjectSize(), 3600)
+
+        module_spec.Clear()
+        self.assertEqual(module_spec.GetObjectOffset(), 0)
+        self.assertEqual(module_spec.GetObjectSize(), 0)