[lldb] Accept negative indexes in __getitem__

[kastiglione]

Summary

To the Python bindings, add support for Python-like indexing with negative indexes.

While was using script, I tried to access a thread's bottom frame with thread.frame[-1], but that failed. This change updates the __getitem__ implementations to support negative indexes as one would expect in Python.

[mib]

This is nice although I wish there was a builtin way to do it. LGTM with a test :)

[kastiglione]

I wondered what to do about tests. Should I pick one of these to test? Just
doesn't seem worth tests for each…

[mib]

In D143282#4103165, @kastiglione wrote:

I wondered what to do about tests. Should I pick one of these to test? Just
doesn't seem worth tests for each…

Yeah, that sounds good to me :)

[bulbazord]

A simple test would be what you did in your commit summary, trying to get thread.frame[-1] and verifying that it's the correct frame. LGTM with a test.

[kastiglione]

Add a couple tests

lldb/bindings/interface/SBBreakpoint.i

%pythoncode %{
                 self.sbbreakpoint = sbbreakpoint
 
             def __len__(self):
                 if self.sbbreakpoint:
                     return int(self.sbbreakpoint.GetNumLocations())
                 return 0
 
             def __getitem__(self, key):
-                if type(key) is int and key < len(self):
+                if isinstance(key, int):
+                    count = len(self)
+                    if -count <= key < count:
+                        key %= count
                         return self.sbbreakpoint.GetLocationAtIndex(key)
                 return None
 
         def get_locations_access_object(self):
             '''An accessor function that returns a locations_access() object which allows lazy location access from a lldb.SBBreakpoint object.'''
             return self.locations_access (self)
 
         def get_breakpoint_location_list(self):
             '''An accessor function that returns a list() that contains all locations in a lldb.SBBreakpoint object.'''

lldb/bindings/interface/SBInstructionList.i

%pythoncode %{
         def __len__(self):
             '''Access len of the instruction list.'''
             return int(self.GetSize())
 
         def __getitem__(self, key):
             '''Access instructions by integer index for array access or by lldb.SBAddress to find an instruction that matches a section offset address object.'''
             if type(key) is int:
                 # Find an instruction by index
-                if key < len(self):
+                count = len(self)
+                if -count <= key < count:
+                    key %= count
                     return self.GetInstructionAtIndex(key)
             elif type(key) is SBAddress:
                 # Find an instruction using a lldb.SBAddress object
                 lookup_file_addr = key.file_addr
                 closest_inst = None
                 for idx in range(self.GetSize()):
                     inst = self.GetInstructionAtIndex(idx)
                     inst_file_addr = inst.addr.file_addr

lldb/bindings/interface/SBModule.i

%pythoncode %{
             def __len__(self):
                 if self.sbmodule:
                     return int(self.sbmodule.GetNumSymbols())
                 return 0
 
             def __getitem__(self, key):
                 count = len(self)
                 if type(key) is int:
-                    if key < count:
+                    if -count <= key < count:
+                        key %= count
                         return self.sbmodule.GetSymbolAtIndex(key)
                 elif type(key) is str:
                     matches = []
                     sc_list = self.sbmodule.FindSymbols(key)
                     for sc in sc_list:
                         symbol = sc.symbol
                         if symbol:
                             matches.append(symbol)
%pythoncode %{
             def __len__(self):
                 if self.sbmodule:
                     return int(self.sbmodule.GetNumSections())
                 return 0
 
             def __getitem__(self, key):
                 count = len(self)
                 if type(key) is int:
-                    if key < count:
+                    if -count <= key < count:
+                        key %= count
                         return self.sbmodule.GetSectionAtIndex(key)
                 elif type(key) is str:
                     for idx in range(count):
                         section = self.sbmodule.GetSectionAtIndex(idx)
                         if section.name == key:
                             return section
                 elif isinstance(key, self.re_compile_type):
                     matches = []
%pythoncode %{
             def __len__(self):
                 if self.sbmodule:
                     return int(self.sbmodule.GetNumCompileUnits())
                 return 0
 
             def __getitem__(self, key):
                 count = len(self)
                 if type(key) is int:
-                    if key < count:
+                    if -count <= key < count:
+                        key %= count
                         return self.sbmodule.GetCompileUnitAtIndex(key)
                 elif type(key) is str:
                     is_full_path = key[0] == '/'
                     for idx in range(count):
                         comp_unit = self.sbmodule.GetCompileUnitAtIndex(idx)
                         if is_full_path:
                             if comp_unit.file.fullpath == key:
                                 return comp_unit

lldb/bindings/interface/SBProcess.i

%pythoncode %{
                 self.sbprocess = sbprocess
 
             def __len__(self):
                 if self.sbprocess:
                     return int(self.sbprocess.GetNumThreads())
                 return 0
 
             def __getitem__(self, key):
-                if type(key) is int and key < len(self):
+                if isinstance(key, int):
+                    count = len(self)
+                    if -count <= key < count:
+                        key %= count
                         return self.sbprocess.GetThreadAtIndex(key)
                 return None
 
         def get_threads_access_object(self):
             '''An accessor function that returns a modules_access() object which allows lazy thread access from a lldb.SBProcess object.'''
             return self.threads_access (self)
 
         def get_process_thread_list(self):
             '''An accessor function that returns a list() that contains all threads in a lldb.SBProcess object.'''

lldb/bindings/interface/SBSymbolContextList.i

%pythoncode %{
             object.'''
             return lldb_iter(self, 'GetSize', 'GetContextAtIndex')
 
         def __len__(self):
             return int(self.GetSize())
 
         def __getitem__(self, key):
             count = len(self)
-            if type(key) is int:
-                if key < count:
+            if isinstance(key, int):
+                if -count <= key < count:
+                    key %= count
                     return self.GetContextAtIndex(key)
                 else:
                     raise IndexError
             raise TypeError
 
         def get_module_array(self):
             a = []
             for i in range(len(self)):

lldb/bindings/interface/SBTarget.i

%pythoncode %{
             def __len__(self):
                 if self.sbtarget:
                     return int(self.sbtarget.GetNumModules())
                 return 0
 
             def __getitem__(self, key):
                 num_modules = self.sbtarget.GetNumModules()
                 if type(key) is int:
-                    if key < num_modules:
+                    if -num_modules <= key < num_modules:
+                        key %= num_modules
                         return self.sbtarget.GetModuleAtIndex(key)
                 elif type(key) is str:
                     if key.find('/') == -1:
                         for idx in range(num_modules):
                             module = self.sbtarget.GetModuleAtIndex(idx)
                             if module.file.basename == key:
                                 return module
                     else:

lldb/bindings/interface/SBThread.i

%pythoncode %{
                 self.sbthread = sbthread
 
             def __len__(self):
                 if self.sbthread:
                     return int(self.sbthread.GetNumFrames())
                 return 0
 
             def __getitem__(self, key):
-                if type(key) is int and key < self.sbthread.GetNumFrames():
+                if isinstance(key, int):
+                    count = len(self)
+                    if -count <= key < count:
+                        key %= count
                         return self.sbthread.GetFrameAtIndex(key)
                 return None
 
         def get_frames_access_object(self):
             '''An accessor function that returns a frames_access() object which allows lazy frame access from a lldb.SBThread object.'''
             return self.frames_access (self)
 
         def get_thread_frames(self):
             '''An accessor function that returns a list() that contains all frames in a lldb.SBThread object.'''

lldb/bindings/interface/SBTypeCategory.i

#ifdef SWIGPYTHON
                 def __len__(self):
                     if self.sbcategory and self.get_count_function:
                         return int(self.get_count_function(self.sbcategory))
                     return 0
 
                 def __getitem__(self, key):
                     num_items = len(self)
                     if type(key) is int:
-                        if key < num_items:
+                        if -num_items <= key < num_items:
+                            key %= num_items
                             return self.get_at_index_function(self.sbcategory,key)
                     elif type(key) is str:
                         return self.get_by_name_function(self.sbcategory,SBTypeNameSpecifier(key))
                     elif isinstance(key,self.regex_type):
                         return self.get_by_name_function(self.sbcategory,SBTypeNameSpecifier(key.pattern,True))
                     else:
                         print("error: unsupported item type: %s" % type(key))
                     return None

lldb/bindings/interface/SBTypeEnumMember.i

%pythoncode %{
 
         def __len__(self):
             '''Return the number of members in a lldb.SBTypeEnumMemberList object.'''
             return self.GetSize()
 
         def __getitem__(self, key):
           num_elements = self.GetSize()
           if type(key) is int:
-              if key < num_elements:
+              if -num_elements <= key < num_elements:
+                  key %= num_elements
                   return self.GetTypeEnumMemberAtIndex(key)
           elif type(key) is str:
               for idx in range(num_elements):
                   item = self.GetTypeEnumMemberAtIndex(idx)
                   if item.name == key:
                       return item
           return None
     %}
 #endif
 
 private:
     std::unique_ptr<lldb_private::TypeEnumMemberListImpl> m_opaque_ap;
 };
 
 } // namespace lldb

lldb/bindings/interface/SBValue.i

%pythoncode %{
                 self.sbvalue = sbvalue
 
             def __len__(self):
                 if self.sbvalue:
                     return int(self.sbvalue.GetNumChildren())
                 return 0
 
             def __getitem__(self, key):
-                if type(key) is int and key < len(self):
+                if isinstance(key, int):
+                    count = len(self)
+                    if -count <= key < count:
+                        key %= count
                         return self.sbvalue.GetChildAtIndex(key)
                 return None
 
         def get_child_access_object(self):
             '''An accessor function that returns a children_access() object which allows lazy member variable access from a lldb.SBValue object.'''
             return self.children_access (self)
 
         def get_value_child_list(self):
             '''An accessor function that returns a list() that contains all children in a lldb.SBValue object.'''

lldb/bindings/interface/SBValueList.i

%pythoncode %{
             return int(self.GetSize())
 
         def __getitem__(self, key):
             count = len(self)
             #------------------------------------------------------------
             # Access with "int" to get Nth item in the list
             #------------------------------------------------------------
             if type(key) is int:
-                if key < count:
+                if -count <= key < count:
+                    key %= count
                     return self.GetValueAtIndex(key)
             #------------------------------------------------------------
             # Access with "str" to get values by name
             #------------------------------------------------------------
             elif type(key) is str:
                 matches = []
                 for idx in range(count):
                     value = self.GetValueAtIndex(idx)

lldb/test/API/python_api/breakpoint/TestBreakpointAPI.py

def test_target_delete(self):
         breakpoint = target.BreakpointCreateByName('AFunction', 'a.out')
         self.trace("breakpoint:", breakpoint)
         self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
         location = breakpoint.GetLocationAtIndex(0)
         self.assertTrue(location.IsValid())
 
+        # Test negative index access.
+        self.assertTrue(breakpoint.location[-1].IsValid())
+
         # Make sure the breakpoint's target is right:
         self.assertEqual(target, breakpoint.GetTarget(), "Breakpoint reports its target correctly")
         
         self.assertTrue(self.dbg.DeleteTarget(target))
         self.assertFalse(breakpoint.IsValid())
         self.assertFalse(location.IsValid())

lldb/test/API/python_api/thread/TestThreadAPI.py

class ThreadAPITestCase(TestBase):
     def test_step_over_3_times(self):
         """Test Python SBThread.StepOver() API."""
         # We build a different executable than the default build() does.
         d = {'CXX_SOURCES': 'main2.cpp', 'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         self.step_over_3_times(self.exe_name)
 
+    def test_negative_indexing(self):
+        """Test SBThread.frame with negative indexes."""
+        self.build()
+        self.validate_negative_indexing()
+
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number within main.cpp to break inside main().
         self.break_line = line_number(
             "main.cpp", "// Set break point at this line and check variable 'my_char'.")
         # Find the line numbers within main2.cpp for
         # step_out_of_malloc_into_function_b() and step_over_3_times().
def run_to_address(self, exe_name):
         thread.StepOver()
         self.runCmd("thread backtrace")
 
         # Now ask SBThread to run to the address 'start_addr' we got earlier, which
         # corresponds to self.step_out_of_malloc line entry's start address.
         thread.RunToAddress(start_addr)
         self.runCmd("process status")
         #self.runCmd("thread backtrace")
+
+    def validate_negative_indexing(self):
+        exe = self.getBuildArtifact("a.out")
+
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+
+        breakpoint = target.BreakpointCreateByLocation(
+            "main.cpp", self.break_line)
+        self.assertTrue(breakpoint, VALID_BREAKPOINT)
+        self.runCmd("breakpoint list")
+
+        # Launch the process, and do not stop at the entry point.
+        process = target.LaunchSimple(
+            None, None, self.get_process_working_directory())
+
+        thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertTrue(
+            thread.IsValid(),
+            "There should be a thread stopped due to breakpoint")
+        self.runCmd("process status")
+
+        pos_range = range(thread.num_frames)
+        neg_range = range(thread.num_frames, 0, -1)
+        for pos, neg in zip(pos_range, neg_range):
+            self.assertEqual(thread.frame[pos].idx, thread.frame[-neg].idx)