[lldb] Fix gnu_libstdcpp's update methods

[wallace]

Summary

The variable.rst documentation says:

If it returns a value, and that value is True, LLDB will be allowed to cache the children and the children count it previously obtained, and will not return to the provider class to ask.  If nothing, None, or anything other than True is returned, LLDB will discard the cached information and ask. Regardless, whenever necessary LLDB will call update.

However, several update methods in gnu_libstdcpp.py were returning True,
which made lldb unaware of any changes in the corresponding objects.
This problem was visible by lldb-vscode in the following way:

• If a breakpoint is hit and there's a vector with the contents {1, 2}, it'll be displayed correctly.
• Then the user steps and the next stop contains the vector modified. The program changed it to {1, 2, 3}
• frame var then displays {1, 2} incorrectly, due to the caching caused

by the update method

It's worth mentioning that none of libcxx.py'd update methods return True. Same for LibCxxVector.cpp, which returns false.

Added a very simple test that fails without this fix.

lldb/examples/synthetic/gnu_libstdcpp.py

def update(self):
             self.node = impl.GetChildMemberWithName('_M_node')
             self.node_address = self.valobj.AddressOf().GetValueAsUnsigned(0)
             self.next = self.node.GetChildMemberWithName('_M_next')
             self.prev = self.node.GetChildMemberWithName('_M_prev')
             self.data_type = self.extract_type()
             self.data_size = self.data_type.GetByteSize()
         except:
             pass
+        return False
 
     def has_children(self):
         return True
 
 
 class StdVectorSynthProvider:
 
     class StdVectorImplementation(object):
class StdVectorImplementation(object):
                 # point in trying to fetch anything
                 if self.start.IsValid() and self.finish.IsValid(
                 ) and self.end.IsValid() and self.data_type.IsValid():
                     self.count = None
                 else:
                     self.count = 0
             except:
                 pass
-            return True
+            return False 
 
     class StdVBoolImplementation(object):
 
         def __init__(self, valobj, bool_type):
             self.valobj = valobj
             self.bool_type = bool_type
             self.valid = False
 
class StdVBoolImplementation(object):
                 self.m_start = m_impl.GetChildMemberWithName('_M_start')
                 self.m_finish = m_impl.GetChildMemberWithName('_M_finish')
                 self.start_p = self.m_start.GetChildMemberWithName('_M_p')
                 self.finish_p = self.m_finish.GetChildMemberWithName('_M_p')
                 self.offset = self.m_finish.GetChildMemberWithName('_M_offset')
                 self.valid = True
             except:
                 self.valid = False
-            return True
+            return False
 
     def __init__(self, valobj, dict):
         logger = lldb.formatters.Logger.Logger()
         first_template_arg_type = valobj.GetType().GetTemplateArgumentType(0)
         if str(first_template_arg_type.GetName()) == "bool":
             self.impl = self.StdVBoolImplementation(
                 valobj, first_template_arg_type)
         else:
def update(self):
                 self.data_type = rep_type.GetTypedefedType().GetTemplateArgumentType(1)
 
             # from libstdc++ implementation of _M_root for rbtree
             self.Mroot = self.Mheader.GetChildMemberWithName('_M_parent')
             self.data_size = self.data_type.GetByteSize()
             self.skip_size = self.Mheader.GetType().GetByteSize()
         except:
             pass
+        return False
 
     def num_children(self):
         logger = lldb.formatters.Logger.Logger()
         if self.count is None:
             self.count = self.num_children_impl()
         return self.count
 
     def num_children_impl(self):

lldb/test/API/tools/lldb-vscode/evaluate/TestVSCode_evaluate.py

def run_test_evaluate_expressions(self, context=None):
         program = self.getBuildArtifact("a.out")
         self.build_and_launch(program)
         source = "main.cpp"
         self.set_source_breakpoints(
             source,
             [
                 line_number(source, "// breakpoint 1"),
                 line_number(source, "// breakpoint 2"),
-                line_number(source, "// breakpoint 3")
+                line_number(source, "// breakpoint 3"),
+                line_number(source, "// breakpoint 4"),
+                line_number(source, "// breakpoint 5"),
+                line_number(source, "// breakpoint 6"),
+                line_number(source, "// breakpoint 7"),
             ]
         )
         self.continue_to_next_stop()
 
         # Expressions at breakpoint 1, which is in main
         self.assertEvaluate("var1", "20")
         self.assertEvaluate("var2", "21")
         self.assertEvaluate("static_int", "42")
def run_test_evaluate_expressions(self, context=None):
             self.assertEvaluate("foo_var", "44")
         else:
             self.assertEvaluateFailure("a_function")
             self.assertEvaluateFailure("a_function(1)")
             self.assertEvaluateFailure("var + 1")
             self.assertEvaluateFailure("foo_func")
             self.assertEvaluateFailure("foo_var")
 
+        # Now we check that values are updated after stepping
+        self.continue_to_next_stop()
+        self.assertEvaluate("my_vec", "size=2")
+        self.continue_to_next_stop()
+        self.assertEvaluate("my_vec", "size=3")
+
+        self.assertEvaluate("my_map", "size=2")
+        self.continue_to_next_stop()
+        self.assertEvaluate("my_map", "size=3")
+        
+        self.assertEvaluate("my_bool_vec", "size=1")
+        self.continue_to_next_stop()
+        self.assertEvaluate("my_bool_vec", "size=2")
+
     @skipIfWindows
     @skipIfRemote
     def test_generic_evaluate_expressions(self):
         # Tests context-less expression evaluations
         self.run_test_evaluate_expressions()
 
     @skipIfWindows
     @skipIfRemote

lldb/test/API/tools/lldb-vscode/evaluate/main.cpp

 #include "foo.h"
 
+#include <vector>
+#include <map>
+
 static int static_int = 42;
 
 int non_static_int = 43;
 
 int a_function(int var) {
   return var; // breakpoint 3
 }
 
int main(int argc, char const *argv[]) {
   int var3 = static_int; // breakpoint 1
   {
     int non_static_int = 10;
     int var2 = 2;
     int var3 = non_static_int; // breakpoint 2
   }
   a_function(var3);
   foo_func();
+
+  std::vector<int> my_vec;
+  my_vec.push_back(1);
+  my_vec.push_back(2);
+  my_vec.push_back(3); // breakpoint 4
+
+  std::map<int, int> my_map;
+  my_map[1] = 2;
+  my_map[2] = 3;
+  my_map[3] = 4; // breakpoint 5
+
+  std::vector<bool> my_bool_vec;
+  my_bool_vec.push_back(true);
+  my_bool_vec.push_back(false); // breakpoint 6
+  my_bool_vec.push_back(true); // breakpoint 7
+  
   return 0;
 }