[lldb] Add an overload to SetModuleLoadAddress that takes an unsigned value

Currently, SBTarget::SetModuleLoadAddress does not accept large slides
needed to load images in high memory. This function should always have
taken an unsigned as the slide, as it immediately passes it to
Target::SetSectionLoadAddress which takes an unsigned.

This patch adds an overload and exposes that to SWIG instead of the
signed variant. I've marked the signed variant as deprecated and added
check that the slide is positive.

rdar://101355155

Differential revision: https://reviews.llvm.org/D147482

(cherry picked from commit ea95da1)

Author: JDevlieghere

lldb/include/lldb/API/SBTarget.h

@@ -377,6 +377,30 @@ class LLDB_API SBTarget {
   ///     failure.
   lldb::SBError ClearSectionLoadAddress(lldb::SBSection section);
 
+#ifndef SWIG
+  /// Slide all file addresses for all module sections so that \a module
+  /// appears to loaded at these slide addresses.
+  ///
+  /// When you need all sections within a module to be loaded at a
+  /// rigid slide from the addresses found in the module object file,
+  /// this function will allow you to easily and quickly slide all
+  /// module sections.
+  ///
+  /// \param[in] module
+  ///     The module to load.
+  ///
+  /// \param[in] sections_offset
+  ///     An offset that will be applied to all section file addresses
+  ///     (the virtual addresses found in the object file itself).
+  ///
+  /// \return
+  ///     An error to indicate success, fail, and any reason for
+  ///     failure.
+  [[deprecated("Use SetModuleLoadAddress(lldb::SBModule, uint64_t)")]]
+  lldb::SBError SetModuleLoadAddress(lldb::SBModule module,
+                                     int64_t sections_offset);
+#endif
+
   /// Slide all file addresses for all module sections so that \a module
   /// appears to loaded at these slide addresses.
   ///
@@ -398,7 +422,7 @@ class LLDB_API SBTarget {
   LLDB_DEPRECATED_FIXME("Use SetModuleLoadAddress(lldb::SBModule, uint64_t)",
                         "SetModuleLoadAddress(lldb::SBModule, uint64_t)")
   lldb::SBError SetModuleLoadAddress(lldb::SBModule module,
-                                     int64_t sections_offset);
+                                     uint64_t sections_offset);
 
   /// Clear the section base load addresses for all sections in a module.
   ///

lldb/source/API/SBTarget.cpp

@@ -2206,6 +2206,18 @@ SBError SBTarget::SetModuleLoadAddress(lldb::SBModule module,
                                        int64_t slide_offset) {
   LLDB_INSTRUMENT_VA(this, module, slide_offset);
 
+  if (slide_offset < 0) {
+    SBError sb_error;
+    sb_error.SetErrorStringWithFormat("slide must be positive");
+    return sb_error;
+  }
+
+  return SetModuleLoadAddress(module, static_cast<uint64_t>(slide_offset));
+}
+
+SBError SBTarget::SetModuleLoadAddress(lldb::SBModule module,
+                                               uint64_t slide_offset) {
+
   SBError sb_error;
 
   TargetSP target_sp(GetSP());

lldb/test/API/functionalities/multiple-slides/TestMultipleSlides.py

@@ -53,7 +53,8 @@ def test_mulitple_slides(self):
         # In memory, we have something like
         #    0x1000 - 0x17ff  first[]
         #    0x1800 - 0x1fff  second[]
-        target.SetModuleLoadAddress(module, 0)
+        error = target.SetModuleLoadAddress(module, 0)
+        self.assertSuccess(error)
         self.expect("expression/d ((int*)&first)[0]", substrs=["= 5"])
         self.expect("expression/d ((int*)&second)[0]", substrs=["= 6"])
         self.assertEqual(
@@ -74,7 +75,8 @@ def test_mulitple_slides(self):
         # but if the original entries are still present in lldb,
         # the beginning address of second[] will get a load address
         # of 0x1800, instead of 0x17c0 (0x1800-64) as we need to get.
-        target.SetModuleLoadAddress(module, first_size - 64)
+        error = target.SetModuleLoadAddress(module, first_size - 64)
+        self.assertSuccess(error)
         self.expect("expression/d ((int*)&first)[0]", substrs=["= 5"])
         self.expect("expression/d ((int*)&second)[0]", substrs=["= 6"])
         self.assertNotEqual(
@@ -87,7 +89,8 @@ def test_mulitple_slides(self):
         )
 
         # Slide it back to the original vmaddr.
-        target.SetModuleLoadAddress(module, 0)
+        error = target.SetModuleLoadAddress(module, 0)
+        self.assertSuccess(error)
         self.expect("expression/d ((int*)&first)[0]", substrs=["= 5"])
         self.expect("expression/d ((int*)&second)[0]", substrs=["= 6"])
         self.assertEqual(
@@ -98,3 +101,7 @@ def test_mulitple_slides(self):
             second_sym.GetStartAddress().GetLoadAddress(target),
             second_sym.GetStartAddress().GetFileAddress(),
         )
+
+        # Make sure we can use a slide > INT64_MAX.
+        error = target.SetModuleLoadAddress(module, 0xFFFFFFFF12345678)
+        self.assertSuccess(error)