[lldb] Fix a 32 bit warning in ScriptedProcessInterface

[DavidSpickett]

Summary

../llvm-project/lldb/include/lldb/Interpreter/ScriptedProcessInterface.h:61:12:
warning: implicit conversion from 'unsigned long long' to 'size_t' (aka 'unsigned int')
changes value from 18446744073709551615 to 4294967295 [-Wconstant-conversion]
../llvm-project/lldb/source/Plugins/Process/scripted/ScriptedProcess.cpp:275:39:
warning: result of comparison of constant 18446744073709551615 with expression
of type 'size_t' (aka 'unsigned int') is always false [-Wtautological-constant-out-of-range-compare]

This happens because size_t on 32 bit is 32 bit, but LLDB_INVALID_OFFSET is
UINT64_MAX. Return lldb::offset_t instead, which is 64 bit everywhere.

DoWriteMemory still returns size_t but this is because every other
Process derived thing does that. As long as the failure check works I think
it should be fine.

[DavidSpickett]

This is pretty trivial but asking for review since I have no experience using this (and am not using it on 32 bit, just want to silence the warning).

[mib]

LGTM! Thanks!

lldb/include/lldb/Interpreter/ScriptedProcessInterface.h

public:
 
   virtual StructuredData::DictionarySP GetThreadsInfo() { return {}; }
 
   virtual lldb::DataExtractorSP
   ReadMemoryAtAddress(lldb::addr_t address, size_t size, Status &error) {
     return {};
   }
 
-  virtual size_t WriteMemoryAtAddress(lldb::addr_t addr,
+  virtual lldb::offset_t WriteMemoryAtAddress(lldb::addr_t addr,
                                               lldb::DataExtractorSP data_sp,
                                               Status &error) {
     return LLDB_INVALID_OFFSET;
   };
 
   virtual StructuredData::ArraySP GetLoadedImages() { return {}; }
 
   virtual lldb::pid_t GetProcessID() { return LLDB_INVALID_PROCESS_ID; }
 
   virtual bool IsAlive() { return true; }

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

 size_t ScriptedProcess::DoWriteMemory(lldb::addr_t vm_addr, const void *buf,
                                       size_t size, Status &error) {
   lldb::DataExtractorSP data_extractor_sp = std::make_shared<DataExtractor>(
       buf, size, GetByteOrder(), GetAddressByteSize());
 
   if (!data_extractor_sp || !data_extractor_sp->GetByteSize())
     return 0;
 
-  size_t bytes_written =
+  lldb::offset_t bytes_written =
       GetInterface().WriteMemoryAtAddress(vm_addr, data_extractor_sp, error);
 
   if (!bytes_written || bytes_written == LLDB_INVALID_OFFSET)
     return ScriptedInterface::ErrorWithMessage<size_t>(
         LLVM_PRETTY_FUNCTION, "Failed to copy write buffer to memory.", error);
 
   // FIXME: We should use the diagnostic system to report a warning if the
   // `bytes_written` is different from `size`.

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

public:
   GetMemoryRegionContainingAddress(lldb::addr_t address,
                                    Status &error) override;
 
   StructuredData::DictionarySP GetThreadsInfo() override;
 
   lldb::DataExtractorSP ReadMemoryAtAddress(lldb::addr_t address, size_t size,
                                             Status &error) override;
 
-  size_t WriteMemoryAtAddress(lldb::addr_t addr, lldb::DataExtractorSP data_sp,
+  lldb::offset_t WriteMemoryAtAddress(lldb::addr_t addr,
+                                      lldb::DataExtractorSP data_sp,
                                       Status &error) override;
 
   StructuredData::ArraySP GetLoadedImages() override;
 
   lldb::pid_t GetProcessID() override;
 
   bool IsAlive() override;
 
   std::optional<std::string> GetScriptedThreadPluginName() override;

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedProcessPythonInterface.cpp

lldb::DataExtractorSP ScriptedProcessPythonInterface::ReadMemoryAtAddress(
 
   // If there was an error on the python call, surface it to the user.
   if (py_error.Fail())
     error = py_error;
 
   return data_sp;
 }
 
-size_t ScriptedProcessPythonInterface::WriteMemoryAtAddress(
+lldb::offset_t ScriptedProcessPythonInterface::WriteMemoryAtAddress(
     lldb::addr_t addr, lldb::DataExtractorSP data_sp, Status &error) {
   Status py_error;
   StructuredData::ObjectSP obj =
       Dispatch("write_memory_at_address", py_error, addr, data_sp, error);
 
   if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, error))
     return LLDB_INVALID_OFFSET;