Update tuple/list/deque data formatters to work with newest libc++

[labath]

Summary

A couple of members of these data structures have been renamed in recent
months. This makes sure they still work with the latest libc++ version.

[jingham]

This looks fine. Some day it would be nice to devise some markup in the STL that could be used to generate these formatters so we don't have to track them by hand, but that's a much longer term project.

lldb/trunk/examples/synthetic/libcxx.py

def get_child_at_index(self, index):
         try:
             i, j = divmod(self.start + index, self.block_size)
             return self.first.CreateValueFromExpression(
                 '[' + str(index) + ']', '*(*(%s + %d) + %d)' %
                 (self.first.get_expr_path(), i, j))
         except:
             return None
 
+    def _get_value_of_compressed_pair(self, pair):
+        value = pair.GetChildMemberWithName("__value_")
+        if not value.IsValid():
+            # pre-r300140 member name
+            value = pair.GetChildMemberWithName("__first_")
+        return value.GetValueAsUnsigned(0)
+
     def update(self):
         logger = lldb.formatters.Logger.Logger()
         try:
             # A deque is effectively a two-dim array, with fixed width.
             # 'map' contains pointers to the rows of this array. The
             # full memory area allocated by the deque is delimited
             # by 'first' and 'end_cap'. However, only a subset of this
             # memory contains valid data since a deque may have some slack
             # at the front and back in order to have O(1) insertion at
             # both ends. The rows in active use are delimited by
             # 'begin' and 'end'.
             #
             # To find the elements that are actually constructed, the 'start'
             # variable tells which element in this NxM array is the 0th
             # one, and the 'size' element gives the number of elements
             # in the deque.
-            count = self.valobj.GetChildMemberWithName(
-                '__size_').GetChildMemberWithName('__first_').GetValueAsUnsigned(0)
+            count = self._get_value_of_compressed_pair(
+                    self.valobj.GetChildMemberWithName('__size_'))
             # give up now if we cant access memory reliably
             if self.block_size < 0:
                 logger.write("block_size < 0")
                 return
             map_ = self.valobj.GetChildMemberWithName('__map_')
             start = self.valobj.GetChildMemberWithName(
                 '__start_').GetValueAsUnsigned(0)
             first = map_.GetChildMemberWithName('__first_')
             map_first = first.GetValueAsUnsigned(0)
             map_begin = map_.GetChildMemberWithName(
                 '__begin_').GetValueAsUnsigned(0)
             map_end = map_.GetChildMemberWithName(
                 '__end_').GetValueAsUnsigned(0)
-            map_endcap = map_.GetChildMemberWithName(
-                '__end_cap_').GetChildMemberWithName('__first_').GetValueAsUnsigned(0)
+            map_endcap = self._get_value_of_compressed_pair(
+                    map_.GetChildMemberWithName( '__end_cap_'))
             # check consistency
             if not map_first <= map_begin <= map_end <= map_endcap:
                 logger.write("map pointers are not monotonic")
                 return
             total_rows, junk = divmod(
                 map_endcap - map_first, self.pointer_size)
             if junk:
                 logger.write("endcap-first doesnt align correctly")

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxxList.cpp

ValueObjectSP ForwardListFrontEnd::GetChildAtIndex(size_t idx) {
   if (error.Fail())
     return nullptr;
 
   return CreateValueObjectFromData(llvm::formatv("[{0}]", idx).str(), data,
                                    m_backend.GetExecutionContextRef(),
                                    m_element_type);
 }
 
+static ValueObjectSP GetValueOfCompressedPair(ValueObject &pair) {
+  ValueObjectSP value = pair.GetChildMemberWithName(ConstString("__value_"), true);
+  if (! value) {
+    // pre-r300140 member name
+    value = pair.GetChildMemberWithName(ConstString("__first_"), true);
+  }
+  return value;
+}
+
 bool ForwardListFrontEnd::Update() {
   AbstractListFrontEnd::Update();
 
   Status err;
   ValueObjectSP backend_addr(m_backend.AddressOf(err));
   if (err.Fail() || !backend_addr)
     return false;
 
   ValueObjectSP impl_sp(
       m_backend.GetChildMemberWithName(ConstString("__before_begin_"), true));
   if (!impl_sp)
     return false;
-  impl_sp = impl_sp->GetChildMemberWithName(ConstString("__first_"), true);
+  impl_sp = GetValueOfCompressedPair(*impl_sp);
   if (!impl_sp)
     return false;
   m_head = impl_sp->GetChildMemberWithName(ConstString("__next_"), true).get();
   return false;
 }
 
 ListFrontEnd::ListFrontEnd(lldb::ValueObjectSP valobj_sp)
     : AbstractListFrontEnd(*valobj_sp), m_node_address(), m_tail(nullptr) {
   if (valobj_sp)
     Update();
 }
 
 size_t ListFrontEnd::CalculateNumChildren() {
   if (m_count != UINT32_MAX)
     return m_count;
   if (!m_head || !m_tail || m_node_address == 0)
     return 0;
   ValueObjectSP size_alloc(
       m_backend.GetChildMemberWithName(ConstString("__size_alloc_"), true));
   if (size_alloc) {
-    ValueObjectSP first(
-        size_alloc->GetChildMemberWithName(ConstString("__first_"), true));
-    if (first) {
-      m_count = first->GetValueAsUnsigned(UINT32_MAX);
+    ValueObjectSP value = GetValueOfCompressedPair(*size_alloc);
+    if (value) {
+      m_count = value->GetValueAsUnsigned(UINT32_MAX);
     }
   }
   if (m_count != UINT32_MAX) {
     return m_count;
   } else {
     uint64_t next_val = m_head->GetValueAsUnsigned(0);
     uint64_t prev_val = m_tail->GetValueAsUnsigned(0);
     if (next_val == 0 || prev_val == 0)

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxxTuple.cpp

 private:
   std::vector<ValueObjectSP> m_elements;
   ValueObjectSP m_base_sp;
 };
 }
 
 bool TupleFrontEnd::Update() {
   m_elements.clear();
+  m_base_sp = m_backend.GetChildMemberWithName(ConstString("__base_"), true);
+  if (! m_base_sp) {
+    // Pre r304382 name of the base element.
     m_base_sp = m_backend.GetChildMemberWithName(ConstString("base_"), true);
+  }
   if (! m_base_sp)
     return false;
   m_elements.assign(m_base_sp->GetCompilerType().GetNumDirectBaseClasses(),
                     ValueObjectSP());
   return false;
 }
 
 ValueObjectSP TupleFrontEnd::GetChildAtIndex(size_t idx) {