[lldb/API] Add SetDataWithOwnership method to SBData

[mib]

Summary

This patch introduces a new method to SBData: SetDataWithOwnership.

Instead of referencing the pointer to the data, this method copies the
data buffer into lldb's heap memory.

This can prevent having the underlying DataExtractor object point to
freed/garbage-collected memory.

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

[JDevlieghere]

LGTM

lldb/bindings/interface/SBData.i

public:
     ReadRawData (lldb::SBError& error,
                  lldb::offset_t offset,
                  void *buf,
                  size_t size);
 
     void
     SetData (lldb::SBError& error, const void *buf, size_t size, lldb::ByteOrder endian, uint8_t addr_size);
 
+    void
+    SetDataWithOwnership (lldb::SBError& error, const void *buf, size_t size,
+                          lldb::ByteOrder endian, uint8_t addr_size);
+
     bool
     Append (const SBData& rhs);
 
     static lldb::SBData
     CreateDataFromCString (lldb::ByteOrder endian, uint32_t addr_byte_size, const char* data);
 
     // in the following CreateData*() and SetData*() prototypes, the two parameters array and array_len
     // should not be renamed or rearranged, because doing so will break the SWIG typemap

lldb/include/lldb/API/SBData.h

public:
   // it would be nice to have SetData(SBError, const void*, size_t) when
   // endianness and address size can be inferred from the existing
   // DataExtractor, but having two SetData() signatures triggers a SWIG bug
   // where the typemap isn't applied before resolving the overload, and thus
   // the right function never gets called
   void SetData(lldb::SBError &error, const void *buf, size_t size,
                lldb::ByteOrder endian, uint8_t addr_size);
 
+  void SetDataWithOwnership(lldb::SBError &error, const void *buf, size_t size,
+                            lldb::ByteOrder endian, uint8_t addr_size);
+
   // see SetData() for why we don't have Append(const void* buf, size_t size)
   bool Append(const SBData &rhs);
 
   static lldb::SBData CreateDataFromCString(lldb::ByteOrder endian,
                                             uint32_t addr_byte_size,
                                             const char *data);
 
   // in the following CreateData*() and SetData*() prototypes, the two

lldb/source/API/SBData.cpp

if (!m_opaque_sp.get())
     m_opaque_sp = std::make_shared<DataExtractor>(buf, size, endian, addr_size);
   else
   {
     m_opaque_sp->SetData(buf, size, endian);
     m_opaque_sp->SetAddressByteSize(addr_size);
   }
 }
 
+void SBData::SetDataWithOwnership(lldb::SBError &error, const void *buf,
+                                  size_t size, lldb::ByteOrder endian,
+                                  uint8_t addr_size) {
+  LLDB_RECORD_DUMMY(
+      void, SBData, SetData,
+      (lldb::SBError &, const void *, size_t, lldb::ByteOrder, uint8_t, bool),
+      error, buf, size, endian, addr_size, copy);
+
+  lldb::DataBufferSP buffer_sp = std::make_shared<DataBufferHeap>(buf, size);
+
+  if (!m_opaque_sp.get())
+    m_opaque_sp = std::make_shared<DataExtractor>(buf, size, endian, addr_size);
+  else {
+    m_opaque_sp->SetData(buffer_sp);
+    m_opaque_sp->SetByteOrder(endian);
+    m_opaque_sp->SetAddressByteSize(addr_size);
+  }
+}
+
 bool SBData::Append(const SBData &rhs) {
   LLDB_RECORD_METHOD(bool, SBData, Append, (const lldb::SBData &), rhs);
 
   bool value = false;
   if (m_opaque_sp.get() && rhs.m_opaque_sp.get())
     value = m_opaque_sp.get()->Append(*rhs.m_opaque_sp);
   return value;
 }

lldb/test/API/python_api/sbdata/TestSBData.py

def test_byte_order_and_address_byte_size(self):
         self.assertEqual(addr, 0x1122334455667788);
         data.SetData(error, addr_data, lldb.eByteOrderLittle, 4)
         addr = data.GetAddress(error, 0)
         self.assertEqual(addr, 0x44332211);
         data.SetData(error, addr_data, lldb.eByteOrderLittle, 8)
         addr = data.GetAddress(error, 0)
         self.assertEqual(addr, 0x8877665544332211);
 
+    def test_byte_order_and_address_byte_size_with_ownership(self):
+        """Test the SBData::SetDataWithOwnership() to ensure the byte order
+        and address byte size are obeyed even when source date is released"""
+        addr_data = b'\x11\x22\x33\x44\x55\x66\x77\x88'
+        error = lldb.SBError()
+        data = lldb.SBData()
+        data.SetDataWithOwnership(error, addr_data, lldb.eByteOrderBig, 8)
+        del addr_data
+        addr = data.GetAddress(error, 0)
+        self.assertEqual(addr, 0x1122334455667788);
+
     def test_with_run_command(self):
         """Test the SBData APIs."""
         self.build()
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(
             self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)