[formatters] Add a deque formatter for libstdcpp and fix the libcxx one

[wallace]

Summary

This adds the formatter for libstdcpp's deque as a python
implementation. It adds comprehensive tests for the two different
storage strategies deque uses. Besides that, this fixes a couple of bugs
in the libcxx implementation. Finally, both implementation run against
the same tests.

This is a minor improvement on top of Danil Stefaniuc's formatter.

[danilashtefan]

lldb/examples/synthetic/gnu_libstdcpp.py

60

This method does not currently work. I simply tried to calculate the size from start and finish pointers. When it did not, I investigated further and this was my founding:

This is when we get the iterator value this comes out:

`_Deque_iterator(const _Deque_iterator& __x) noexcept

169 	       : _M_cur(__x._M_cur), _M_first(__x._M_first),
170 		 _M_last(__x._M_last), _M_node(__x._M_node) { }`

And when it++ is done this is what happens behind:

operator++()

189       {
190    ++_M_cur;
191    if (_M_cur == _M_last)
192      {
193        _M_set_node(_M_node + 1);
194        _M_cur = _M_first;
195      }
196    return *this;
197        }

[danilashtefan]

When I mocked the num_children to return 4, formatter works for any structure with size <= 4. here is the example:

std::deque<int> d;
 d.push_front(7);
 d.push_front(5);   
 d.push_front(13);
 d.push_front(25);

(std::deque<int, std::allocator<int> >) $0 = size=4 {

[0] = 25
[1] = 13
[2] = 5
[3] = 7

}

[wallace]

discussed offline how to traverse each individual subarray. This might make it impossible to reuse it for queue and stack

lldb/examples/synthetic/gnu_libstdcpp.py

13

remove

22

remove

31

don't forget to always return False

60

discussed offline how to handle this

[danilashtefan]

Hi Walter :)

I added the size determination here. The commented out set_node node method should switch the nodes, but, unfortunately, after numerous of tries, I did not succeed. The prints are left only for a draft PR and I will delete them in the final diff update, thank you!

[danilashtefan]

Unified tests added

[danilashtefan]

As we discussed offline, I add the print tests, since SBValue.GetValue() doesn't work for complex structures

[labath]

In D114008#3153211, @danilashtefan wrote:

As we discussed offline, I add the print tests, since SBValue.GetValue() doesn't work for complex structures

There are different ways you can do that depending on what you want to test precisely. You can (programatically, using loops?) construct nested ValueCheck structures and pass that to the expect_var_path .

Or you can, issue a bunch of smaller expect_var_path commands targetting individual subobjects, again using loops (expect_var_path("myobj[%d]"%i, ...).

[danilashtefan]

Hi @labath, Thank you so much for your comment and correction. The initial version of the test was the following, with array of ValueCheck objects:

`def check(self, var_name, size):

var = self.findVariable(var_name)
self.assertEqual(var.GetNumChildren(), size)
children = []
for i in range(100):
    children.insert(0,ValueCheck(value={i, i + 1, i + 2}))
    children.append(ValueCheck(value={-i, -(i + 1), -(i + 2)}))
self.expect_var_path(var_name, type=self.getVariableType(var_name), children=children)`

However, the following error pops up in the expected_var_path: AssertionError: {99, 100, 101} != None : Checking child with index 0:. The reason is that child.GetValue()that is invoked inside gives None in case it is a complex structure. This is why me and @wallace decided to go with a printing test.

If I did not get you right, I would be glad if you could describe your solution more, so I can implement it. Many thanks!

[labath]

You need to construct issue appropriately nested ValueCheck objects. Something like this:

children.insert(0,ValueCheck(children=[ValueCheck(value=i), ValueCheck(value=i+1), ValueCheck(i + 2)])

If that doesn't work then that's probably a bug in the ValueCheck matching implementation, as it was definitely written with that mind.

[wallace]

Fix the few issues in Danil's implementation

[wallace]

committed as 2ea3c8a50add5436cf939d59c3235408ca0255c1

lldb/examples/synthetic/gnu_libstdcpp.py

 from __future__ import division
 import re
 import lldb.formatters.Logger
 
 # C++ STL formatters for LLDB
 # These formatters are based upon the version of the GNU libstdc++
 # as it ships with Mac OS X 10.6.8 thru 10.8.0
 # You are encouraged to look at the STL implementation for your platform
 # before relying on these formatters to do the right thing for your setup
 
+class StdDequeSynthProvider:
+    def __init__(self, valobj, dict):
+        self.valobj = valobj
+        self.count = None
+
+    def update(self):
+        # preemptively setting this to None - we might end up changing our mind
+        # later
+        self.count = None
+        try:
+            self.impl = self.valobj.GetChildMemberWithName('_M_impl')
+            self.start  = self.impl.GetChildMemberWithName("_M_start")
+            self.start_cur = self.start.GetChildMemberWithName('_M_cur')
+            self.start_cur_val = self.start_cur.GetValueAsUnsigned(0)
+            self.start_first = self.start.GetChildMemberWithName('_M_first')
+            self.start_last = self.start.GetChildMemberWithName('_M_last')
+            self.start_node = self.start.GetChildMemberWithName("_M_node")
+            self.start_node_val = self.start_node.GetValueAsUnsigned(0)
+            self.finish = self.impl.GetChildMemberWithName("_M_finish")
+            self.finish_cur = self.finish.GetChildMemberWithName('_M_cur')
+            self.finish_last = self.finish.GetChildMemberWithName('_M_last')
+            self.finish_first = self.finish.GetChildMemberWithName('_M_first')
+            self.finish_node = self.finish.GetChildMemberWithName('_M_node')
+            self.data_type = self.valobj.GetType().GetUnqualifiedType().GetTemplateArgumentType(0)
+            self.data_size = self.data_type.GetByteSize()
+        except:
+            pass
+        return False
+
+    def get_child_index(self, name):
+        try:
+            return int(name.lstrip('[').rstrip(']'))
+        except:
+            return -1
+
+    # def set_node(self):
+    #     try:
+    #         self.start_node = self.start.GetChildMemberWithName("_M_node")
+    #         print("Self_node: " + str(self.start_node))
+    #         self.start_node_data = self.start_node.GetData()
+    #         print("Self_node_data: " + str(self.start_node_data))
+    #         self.start_node_data = self.start_node_data + 8
+    #         print("Next self_node_data: " + str(self.start_node_data))
+    #     except:
+    #         print("Cannot set node")
+    #         return None
+         
+        
+
+    def get_child_at_index(self, index):
+        logger = lldb.formatters.Logger.Logger()
+        logger >> "Being asked to fetch child[" + str(index) + "]"
+        if index < 0:
+            return None
+        if index >= self.num_children():
+            return None
+        try:
+            offset = index * self.data_size
+            # # while offset > 0:
+            # while self.start_cur_val != self.start_last.GetValueAsUnsigned(0):
+            #     self.start_cur_val = self.start_cur_val + self.data_size
+            # print("Reached end")
+            return self.start_cur.CreateChildAtOffset( '[' + str(index) + ']', offset, self.data_type)
+            # self.set_node()
+            return 0
+            
+        except:
+            print("Cannot get chid")
+            logger >> "Cannot get child"
+            return None
+
+    
+    def num_children(self):
+        if self.count is None:
+            self.count = self.num_children_impl()
+        return self.count
+    
+    def num_children_impl(self):
+        logger = lldb.formatters.Logger.Logger()
+        start_node = self.start.GetChildMemberWithName('_M_node')
+        start_node_val = start_node.GetValueAsUnsigned(0)
+        start_last_val = self.start_last.GetValueAsUnsigned(0)
+        start_cur_val = self.start_cur.GetValueAsUnsigned(0)
+        finish_node = self.finish.GetChildMemberWithName('_M_node')
+        finish_node_val = finish_node.GetValueAsUnsigned(0)
+        finish_cur_val = self.finish_cur.GetValueAsUnsigned(0)
+        finish_first_val = self.finish_first.GetValueAsUnsigned(0)
+
+        
+        node_size = start_node.GetType().GetByteSize()
+        print("Node size: " + str(node_size))
+
+        try:
+           size = (512 / self.data_size) * ((finish_node_val - start_node_val)//int(node_size) - int(finish_node_val != 0)) \
+                  + (finish_cur_val - finish_first_val)//self.data_size \
+                  + (start_last_val - start_cur_val)//self.data_size
+           return size 
+        except:
+            logger >> "Could not determine the size"
+            return 0
+        
+
 
 class AbstractListSynthProvider:
     def __init__(self, valobj, dict, has_prev):
         '''
         :param valobj: The value object of the list
         :param dict: A dict with metadata provided by LLDB
         :param has_prev: Whether the list supports a 'prev' pointer besides a 'next' one
         '''

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
           stl_deref_flags,
           "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
       RegularExpression("^std::multiset<.+> >(( )?&)?$"),
       SyntheticChildrenSP(new ScriptedSyntheticChildren(
           stl_deref_flags,
           "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
+      RegularExpression("^std::deque<.+>(( )?&)?$"),
+      SyntheticChildrenSP(new ScriptedSyntheticChildren(
+          stl_deref_flags,
+          "lldb.formatters.cpp.gnu_libstdcpp.StdDequeSynthProvider")));
+  cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
       RegularExpression("^std::(__cxx11::)?list<.+>(( )?&)?$"),
       SyntheticChildrenSP(new ScriptedSyntheticChildren(
           stl_synth_flags,
           "lldb.formatters.cpp.gnu_libstdcpp.StdListSynthProvider")));
   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
       RegularExpression("^std::(__cxx11::)?forward_list<.+>(( )?&)?$"),
       SyntheticChildrenSP(new ScriptedSyntheticChildren(
           stl_synth_flags,
cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
       RegularExpression("^std::map<.+> >(( )?&)?$"),
       TypeSummaryImplSP(
           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
       RegularExpression("^std::set<.+> >(( )?&)?$"),
       TypeSummaryImplSP(
           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
+      RegularExpression("^std::deque<.+>(( )?&)?$"),
+      TypeSummaryImplSP(
+          new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
+  cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
       RegularExpression("^std::multimap<.+> >(( )?&)?$"),
       TypeSummaryImplSP(
           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
       RegularExpression("^std::multiset<.+> >(( )?&)?$"),
       TypeSummaryImplSP(
           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(