Allow SyntheticChildFrontEnd's to request that they always get an object, nor a reference or pointer

[jingham]

Summary

Some of the cxx synthetic child providers (for vector, set, multiset and bitset) were implicitly assuming that the object they received to format was an object, not a pointer or reference to an object, even though the pattern they used matched pointers and references.

Since that seems a handy simplification for the child provider, I added a flag to the provider flags to request that they always get an object, and made the generic front end runner code do the dereference before handing the ValueObject off to the provider.

Also added tests to all the failing formatters to ensure that they work with pointers and references.

[JDevlieghere]

LGTM with a nit for the test function name. Thanks Jim!

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/multiset/TestDataFormatterLibcxxMultiSet.py

30 ↗

(On Diff #155311)

Should we call this check_bitset? I had no idea what the ii here meant until I found the call that checks the variable with the same name. (and later we call it for a different variable names for the ref/ptr case.

[jingham]

Add an explanatory comment for the check_ii routine.

[jingham]

I didn't want to make check_ii sound general with a name like check_bitset. This isn't some general bitset check routine, it asserts the state of the particular bitset held in ii at a particular point in the program execution. The only reason to extract the test into a routine was to apply the exact same test for the contents of ii when it appeared as that object or as a reference to it. For that reason I'm not unhappy with the name, but I added a comment explaining what the routine does. Does that make it clearer?

[stella.stamenova]

It looks like a couple of the new tests don't have @add_test_categories(["libc++"]) and they are failing on Windows. Are they supposed to run and pass without libc++?

[jingham]

Nope, that was just an oversight. I'll fix it if you don't beat me to it...

[jingham]

I think r337058 should do. Sorry for the trouble.

[stella.stamenova]

Thanks for the quick fix!

lldb/trunk/include/lldb/DataFormatters/TypeSynthetic.h

public:
     Flags &SetNonCacheable(bool value = true) {
       if (value)
         m_flags |= lldb::eTypeOptionNonCacheable;
       else
         m_flags &= ~lldb::eTypeOptionNonCacheable;
       return *this;
     }
 
+    bool GetFrontEndWantsDereference() const {
+      return (m_flags & lldb::eTypeOptionFrontEndWantsDereference) ==
+             lldb::eTypeOptionFrontEndWantsDereference;
+    }
+
+    Flags &SetFrontEndWantsDereference(bool value = true) {
+      if (value)
+        m_flags |= lldb::eTypeOptionFrontEndWantsDereference;
+      else
+        m_flags &= ~lldb::eTypeOptionFrontEndWantsDereference;
+      return *this;
+    }
+
     uint32_t GetValue() { return m_flags; }
 
     void SetValue(uint32_t value) { m_flags = value; }
 
   private:
     uint32_t m_flags;
   };
 
   SyntheticChildren(const Flags &flags) : m_flags(flags) {}
 
   virtual ~SyntheticChildren() = default;
 
   bool Cascades() const { return m_flags.GetCascades(); }
 
   bool SkipsPointers() const { return m_flags.GetSkipPointers(); }
 
   bool SkipsReferences() const { return m_flags.GetSkipReferences(); }
 
   bool NonCacheable() const { return m_flags.GetNonCacheable(); }
   
+  bool WantsDereference() const { return m_flags.GetFrontEndWantsDereference();} 
+
   void SetCascades(bool value) { m_flags.SetCascades(value); }
 
   void SetSkipsPointers(bool value) { m_flags.SetSkipPointers(value); }
 
   void SetSkipsReferences(bool value) { m_flags.SetSkipReferences(value); }
 
   void SetNonCacheable(bool value) { m_flags.SetNonCacheable(value); }
 

lldb/trunk/include/lldb/lldb-enumerations.h

FLAGS_ENUM(TypeOptions){eTypeOptionNone = (0u),
                         eTypeOptionCascade = (1u << 0),
                         eTypeOptionSkipPointers = (1u << 1),
                         eTypeOptionSkipReferences = (1u << 2),
                         eTypeOptionHideChildren = (1u << 3),
                         eTypeOptionHideValue = (1u << 4),
                         eTypeOptionShowOneLiner = (1u << 5),
                         eTypeOptionHideNames = (1u << 6),
                         eTypeOptionNonCacheable = (1u << 7),
-                        eTypeOptionHideEmptyAggregates = (1u << 8)};
+                        eTypeOptionHideEmptyAggregates = (1u << 8),
+                        eTypeOptionFrontEndWantsDereference = (1u << 9)
+};
 
 //----------------------------------------------------------------------
 // This is the return value for frame comparisons.  If you are comparing frame
 // A to frame B the following cases arise: 1) When frame A pushes frame B (or a
 // frame that ends up pushing B) A is Older than B. 2) When frame A pushed
 // frame B (or if frame A is on the stack but B is not) A is Younger than B 3)
 // When frame A and frame B have the same StackID, they are Equal. 4) When
 // frame A and frame B have the same immediate parent frame, but are not equal,

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/bitset/TestDataFormatterLibcxxBitset.py

def check(self, name, size):
         self.assertTrue(var.IsValid())
         self.assertEqual(var.GetNumChildren(), size)
         for i in range(size):
             child = var.GetChildAtIndex(i)
             self.assertEqual(child.GetValueAsUnsigned(), self.primes[i],
                     "variable: %s, index: %d"%(name, size))
 
     @add_test_categories(["libc++"])
-    def test(self):
+    def test_value(self):
         """Test that std::bitset is displayed correctly"""
         self.build()
         lldbutil.run_to_source_breakpoint(self, '// break here',
                 lldb.SBFileSpec("main.cpp", False))
 
         self.check("empty", 0)
         self.check("small", 13)
         self.check("large", 200)
+
+    def test_ptr_and_ref(self):
+        """Test that ref and ptr to std::bitset is displayed correctly"""
+        self.build()
+        (_, process, _, bkpt) = lldbutil.run_to_source_breakpoint(self, 
+                'Check ref and ptr',
+                lldb.SBFileSpec("main.cpp", False))
+
+        self.check("ref", 13)
+        self.check("ptr", 13)
+
+        lldbutil.continue_to_breakpoint(process, bkpt)
+        
+        self.check("ref", 200)
+        self.check("ptr", 200)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/bitset/main.cpp

 #include <bitset>
+#include <stdio.h>
 
 template<std::size_t N>
 void fill(std::bitset<N> &b) {
   b.set();
   b[0] = b[1] = false;
   for (std::size_t i = 2; i < N; ++i) {
     for (std::size_t j = 2*i; j < N; j+=i)
       b[j] = false;
   }
 }
 
+template<std::size_t N>
+void by_ref_and_ptr(std::bitset<N> &ref, std::bitset<N> *ptr) {
+    // Check ref and ptr
+    return;
+}
+
 int main() {
   std::bitset<0> empty;
   std::bitset<13> small;
   fill(small);
   std::bitset<200> large;
   fill(large);
-  return 0; // break here
+  by_ref_and_ptr(small, &small); // break here
+  by_ref_and_ptr(large, &large);
+  return 0;
 }

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/multiset/TestDataFormatterLibcxxMultiSet.py

def setUp(self):
         ns = 'ndk' if lldbplatformutil.target_is_android() else ''
         self.namespace = 'std::__' + ns + '1'
 
     def getVariableType(self, name):
         var = self.frame().FindVariable(name)
         self.assertTrue(var.IsValid())
         return var.GetType().GetCanonicalType().GetName()
 
+    def check_ii(self, var_name):
+        """ This checks the value of the bitset stored in ii at the call to by_ref_and_ptr.
+            We use this to make sure we get the same values for ii when we look at the object
+            directly, and when we look at a reference to the object. """
+        self.expect(
+            "frame variable " + var_name,
+            substrs=["size=7",
+                     "[2] = 2",
+                     "[3] = 3",
+                     "[6] = 6"])
+        self.expect("frame variable " + var_name + "[2]", substrs=[" = 2"])
+        self.expect(
+            "p " + var_name,
+            substrs=[
+                "size=7",
+                "[2] = 2",
+                "[3] = 3",
+                "[6] = 6"])
+
     @add_test_categories(["libc++"])
     def test_with_run_command(self):
         """Test that that file and class static variables display correctly."""
         self.build()
-        self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
-
-        bkpt = self.target().FindBreakpointByID(
-            lldbutil.run_break_set_by_source_regexp(
-                self, "Set break point at this line."))
-
-        self.runCmd("run", RUN_SUCCEEDED)
-
-        # The stop reason of the thread should be breakpoint.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
-                    substrs=['stopped',
-                             'stop reason = breakpoint'])
+        (self.target, process, _, bkpt) = lldbutil.run_to_source_breakpoint(
+            self, "Set break point at this line.", lldb.SBFileSpec("main.cpp", False))
 
         # This is the function to remove the custom formats in order to have a
         # clean slate for the next test case.
         def cleanup():
             self.runCmd('type format clear', check=False)
             self.runCmd('type summary clear', check=False)
             self.runCmd('type filter clear', check=False)
             self.runCmd('type synth clear', check=False)
             self.runCmd(
                 "settings set target.max-children-count 256",
                 check=False)
 
         # Execute the cleanup function during test case tear down.
         self.addTearDownHook(cleanup)
 
         ii_type = self.getVariableType("ii")
         self.assertTrue(ii_type.startswith(self.namespace + "::multiset"),
                         "Type: " + ii_type)
 
         self.expect("frame variable ii", substrs=["size=0", "{}"])
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+        lldbutil.continue_to_breakpoint(process, bkpt)
         self.expect(
             "frame variable ii",
             substrs=[
                 "size=6",
                 "[0] = 0",
                 "[1] = 1",
                 "[2] = 2",
                 "[3] = 3",
                 "[4] = 4",
                 "[5] = 5"])
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
-        self.expect(
-            "frame variable ii",
-            substrs=[
-                "size=7",
-                "[2] = 2",
-                "[3] = 3",
-                "[6] = 6"])
-        self.expect(
-            "p ii",
-            substrs=[
-                "size=7",
-                "[2] = 2",
-                "[3] = 3",
-                "[6] = 6"])
-        self.expect("frame variable ii[2]", substrs=[" = 2"])
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+        lldbutil.continue_to_breakpoint(process, bkpt)
+
+        self.check_ii("ii")
+
+        lldbutil.continue_to_breakpoint(process, bkpt)
         self.expect("frame variable ii", substrs=["size=0", "{}"])
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+        lldbutil.continue_to_breakpoint(process, bkpt)
         self.expect("frame variable ii", substrs=["size=0", "{}"])
         ss_type = self.getVariableType("ss")
         self.assertTrue(ss_type.startswith(self.namespace + "::multiset"),
                         "Type: " + ss_type)
         self.expect("frame variable ss", substrs=["size=0", "{}"])
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+        lldbutil.continue_to_breakpoint(process, bkpt)
         self.expect(
             "frame variable ss",
             substrs=[
                 "size=2",
                 '[0] = "a"',
                 '[1] = "a very long string is right here"'])
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+        lldbutil.continue_to_breakpoint(process, bkpt)
         self.expect(
             "frame variable ss",
             substrs=[
                 "size=4",
                 '[2] = "b"',
                 '[3] = "c"',
                 '[0] = "a"',
                 '[1] = "a very long string is right here"'])
         self.expect(
             "p ss",
             substrs=[
                 "size=4",
                 '[2] = "b"',
                 '[3] = "c"',
                 '[0] = "a"',
                 '[1] = "a very long string is right here"'])
         self.expect("frame variable ss[2]", substrs=[' = "b"'])
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+        lldbutil.continue_to_breakpoint(process, bkpt)
         self.expect(
             "frame variable ss",
             substrs=[
                 "size=3",
                 '[0] = "a"',
                 '[1] = "a very long string is right here"',
                 '[2] = "c"'])
+
+    @add_test_categories(["libc++"])
+    def test_ref_and_ptr(self):
+        """Test that the data formatters work on ref and ptr."""
+        self.build()
+        (self.target, process, _, bkpt) = lldbutil.run_to_source_breakpoint(
+            self, "Stop here to check by ref and ptr.", 
+            lldb.SBFileSpec("main.cpp", False))
+        # The reference should print just like the value:
+        self.check_ii("ref")
+
+        self.expect("frame variable ptr",
+                    substrs=["ptr =", "size=7"])
+        self.expect("expr ptr",
+                    substrs=["size=7"])

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/multiset/main.cpp

int thefoo_rw(int arg = 1)
   if (arg < 0)
     arg = 0;
   if (!arg)
     arg = 1;
   g_the_foo += arg;
   return g_the_foo;
 }
 
+void by_ref_and_ptr(intset &ref, intset *ptr)
+{
+    // Stop here to check by ref and ptr
+    return;
+} 
+
 int main()
 {
     intset ii;
     thefoo_rw(1);  // Set break point at this line.
   
   ii.insert(0);
   ii.insert(1);
   ii.insert(2);
   ii.insert(3);
   ii.insert(4);
   ii.insert(5);
     thefoo_rw(1);  // Set break point at this line.
 
   ii.insert(6);
   thefoo_rw(1);  // Set break point at this line.
-    
+        by_ref_and_ptr(ii, &ii);
+
   ii.clear();
   thefoo_rw(1);  // Set break point at this line.
 
   stringset ss;
   thefoo_rw(1);  // Set break point at this line.
 
   ss.insert("a");
   ss.insert("a very long string is right here");

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/set/TestDataFormatterLibcxxSet.py

def setUp(self):
         ns = 'ndk' if lldbplatformutil.target_is_android() else ''
         self.namespace = 'std::__' + ns + '1'
 
     def getVariableType(self, name):
         var = self.frame().FindVariable(name)
         self.assertTrue(var.IsValid())
         return var.GetType().GetCanonicalType().GetName()
 
+    def check_ii(self, var_name):
+        """ This checks the value of the bitset stored in ii at the call to by_ref_and_ptr.
+            We use this to make sure we get the same values for ii when we look at the object
+            directly, and when we look at a reference to the object. """
+        self.expect(
+            "frame variable " + var_name,
+            substrs=["size=7",
+                     "[2] = 2",
+                     "[3] = 3",
+                     "[6] = 6"])
+        self.expect("frame variable " + var_name + "[2]", substrs=[" = 2"])
+        self.expect(
+            "p " + var_name,
+            substrs=[
+                "size=7",
+                "[2] = 2",
+                "[3] = 3",
+                "[6] = 6"])
+
     @add_test_categories(["libc++"])
     def test_with_run_command(self):
         """Test that that file and class static variables display correctly."""
         self.build()
-        self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
-
-        bkpt = self.target().FindBreakpointByID(
-            lldbutil.run_break_set_by_source_regexp(self, "Set break point at this line."))
-
-        self.runCmd("run", RUN_SUCCEEDED)
-
-        # The stop reason of the thread should be breakpoint.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
-                    substrs=['stopped',
-                             'stop reason = breakpoint'])
+        (self.target, process, _, bkpt) = lldbutil.run_to_source_breakpoint(
+            self, "Set break point at this line.", lldb.SBFileSpec("main.cpp", False))
 
         # This is the function to remove the custom formats in order to have a
         # clean slate for the next test case.
         def cleanup():
             self.runCmd('type format clear', check=False)
             self.runCmd('type summary clear', check=False)
             self.runCmd('type filter clear', check=False)
             self.runCmd('type synth clear', check=False)
             self.runCmd(
                 "settings set target.max-children-count 256",
                 check=False)
 
         # Execute the cleanup function during test case tear down.
         self.addTearDownHook(cleanup)
 
         ii_type = self.getVariableType("ii")
         self.assertTrue(ii_type.startswith(self.namespace + "::set"),
                         "Type: " + ii_type)
 
         self.expect("frame variable ii", substrs=["size=0", "{}"])
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+        lldbutil.continue_to_breakpoint(process, bkpt)
         self.expect(
             "frame variable ii",
             substrs=["size=6",
                      "[0] = 0",
                      "[1] = 1",
                      "[2] = 2",
                      "[3] = 3",
                      "[4] = 4",
                      "[5] = 5"])
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
-        self.expect(
-            "frame variable ii",
-            substrs=["size=7",
-                     "[2] = 2",
-                     "[3] = 3",
-                     "[6] = 6"])
-        self.expect("frame variable ii[2]", substrs=[" = 2"])
-        self.expect(
-            "p ii",
-            substrs=[
-                "size=7",
-                "[2] = 2",
-                "[3] = 3",
-                "[6] = 6"])
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+        lldbutil.continue_to_breakpoint(process, bkpt)
+        self.check_ii("ii")
+
+        lldbutil.continue_to_breakpoint(process, bkpt)
         self.expect("frame variable ii", substrs=["size=0", "{}"])
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+        lldbutil.continue_to_breakpoint(process, bkpt)
         self.expect("frame variable ii", substrs=["size=0", "{}"])
 
         ss_type = self.getVariableType("ss")
         self.assertTrue(ii_type.startswith(self.namespace + "::set"),
                         "Type: " + ss_type)
 
         self.expect("frame variable ss", substrs=["size=0", "{}"])
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+        lldbutil.continue_to_breakpoint(process, bkpt)
         self.expect(
             "frame variable ss",
             substrs=["size=2",
                      '[0] = "a"',
                      '[1] = "a very long string is right here"'])
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+        lldbutil.continue_to_breakpoint(process, bkpt)
         self.expect(
             "frame variable ss",
             substrs=["size=4",
                      '[2] = "b"',
                      '[3] = "c"',
                      '[0] = "a"',
                      '[1] = "a very long string is right here"'])
         self.expect(
             "p ss",
             substrs=["size=4",
                      '[2] = "b"',
                      '[3] = "c"',
                      '[0] = "a"',
                      '[1] = "a very long string is right here"'])
         self.expect("frame variable ss[2]", substrs=[' = "b"'])
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+        lldbutil.continue_to_breakpoint(process, bkpt)
         self.expect(
             "frame variable ss",
             substrs=["size=3",
                      '[0] = "a"',
                      '[1] = "a very long string is right here"',
                      '[2] = "c"'])
+
+    @add_test_categories(["libc++"])
+    def test_ref_and_ptr(self):
+        """Test that the data formatters work on ref and ptr."""
+        self.build()
+        (self.target, process, _, bkpt) = lldbutil.run_to_source_breakpoint(
+            self, "Stop here to check by ref and ptr.", 
+            lldb.SBFileSpec("main.cpp", False))
+        # The reference should print just like the value:
+        self.check_ii("ref")
+
+        self.expect("frame variable ptr",
+                    substrs=["ptr =", "size=7"])
+        self.expect("expr ptr",
+                    substrs=["size=7"])
+                    

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/set/main.cpp

int thefoo_rw(int arg = 1)
   if (arg < 0)
     arg = 0;
   if (!arg)
     arg = 1;
   g_the_foo += arg;
   return g_the_foo;
 }
 
+void by_ref_and_ptr(intset &ref, intset *ptr)
+{
+    // Stop here to check by ref and ptr
+    return;
+} 
+
 int main()
 {
     intset ii;
     thefoo_rw(1);  // Set break point at this line.
   
   ii.insert(0);
   ii.insert(1);
   ii.insert(2);
   ii.insert(3);
   ii.insert(4);
   ii.insert(5);
     thefoo_rw(1);  // Set break point at this line.
 
   ii.insert(6);
   thefoo_rw(1);  // Set break point at this line.
-    
+        by_ref_and_ptr(ii, &ii);
+
   ii.clear();
   thefoo_rw(1);  // Set break point at this line.
 
   stringset ss;
   thefoo_rw(1);  // Set break point at this line.
 
   ss.insert("a");
   ss.insert("a very long string is right here");

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/vector/TestDataFormatterLibcxxVector.py

 
 class LibcxxVectorDataFormatterTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @add_test_categories(["libc++"])
     @skipIf(debug_info="gmodules",
             bugnumber="https://bugs.llvm.org/show_bug.cgi?id=36048")
+
+    def check_numbers(self, var_name):
+        self.expect("frame variable " + var_name,
+                    substrs=[var_name + ' = size=7',
+                             '[0] = 1',
+                             '[1] = 12',
+                             '[2] = 123',
+                             '[3] = 1234',
+                             '[4] = 12345',
+                             '[5] = 123456',
+                             '[6] = 1234567',
+                             '}'])
+
+        self.expect("p " + var_name,
+                    substrs=['$', 'size=7',
+                             '[0] = 1',
+                             '[1] = 12',
+                             '[2] = 123',
+                             '[3] = 1234',
+                             '[4] = 12345',
+                             '[5] = 123456',
+                             '[6] = 1234567',
+                             '}'])
+
+        # check access-by-index
+        self.expect("frame variable " + var_name + "[0]",
+                    substrs=['1'])
+        self.expect("frame variable " + var_name + "[1]",
+                    substrs=['12'])
+        self.expect("frame variable " + var_name + "[2]",
+                    substrs=['123'])
+        self.expect("frame variable " + var_name + "[3]",
+                    substrs=['1234'])
+
     def test_with_run_command(self):
         """Test that that file and class static variables display correctly."""
         self.build()
-        self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
-
-        bkpt = self.target().FindBreakpointByID(
-            lldbutil.run_break_set_by_source_regexp(
-                self, "break here"))
-
-        self.runCmd("run", RUN_SUCCEEDED)
-
-        # The stop reason of the thread should be breakpoint.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
-                    substrs=['stopped',
-                             'stop reason = breakpoint'])
+        (self.target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
+            self, "break here", lldb.SBFileSpec("main.cpp", False))
 
         # This is the function to remove the custom formats in order to have a
         # clean slate for the next test case.
         def cleanup():
             self.runCmd('type format clear', check=False)
             self.runCmd('type summary clear', check=False)
             self.runCmd('type filter clear', check=False)
             self.runCmd('type synth clear', check=False)
             self.runCmd(
                 "settings set target.max-children-count 256",
                 check=False)
 
         # Execute the cleanup function during test case tear down.
         self.addTearDownHook(cleanup)
 
         # empty vectors (and storage pointers SHOULD BOTH BE NULL..)
         self.expect("frame variable numbers",
                     substrs=['numbers = size=0'])
 
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+        lldbutil.continue_to_breakpoint(process, bkpt)
 
         # first value added
         self.expect("frame variable numbers",
                     substrs=['numbers = size=1',
                              '[0] = 1',
                              '}'])
 
         # add some more data
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+        lldbutil.continue_to_breakpoint(process, bkpt)
 
         self.expect("frame variable numbers",
                     substrs=['numbers = size=4',
                              '[0] = 1',
                              '[1] = 12',
                              '[2] = 123',
                              '[3] = 1234',
                              '}'])
def test_with_run_command(self):
             "type summary add --summary-string \"item 0 is ${svar[0]}\" std::int_vect int_vect")
         self.expect('frame variable numbers',
                     substrs=['item 0 is 1'])
         # move on with synths
         self.runCmd("type summary delete std::int_vect")
         self.runCmd("type summary delete int_vect")
 
         # add some more data
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
-
-        self.expect("frame variable numbers",
-                    substrs=['numbers = size=7',
-                             '[0] = 1',
-                             '[1] = 12',
-                             '[2] = 123',
-                             '[3] = 1234',
-                             '[4] = 12345',
-                             '[5] = 123456',
-                             '[6] = 1234567',
-                             '}'])
-
-        self.expect("p numbers",
-                    substrs=['$', 'size=7',
-                             '[0] = 1',
-                             '[1] = 12',
-                             '[2] = 123',
-                             '[3] = 1234',
-                             '[4] = 12345',
-                             '[5] = 123456',
-                             '[6] = 1234567',
-                             '}'])
+        lldbutil.continue_to_breakpoint(process, bkpt)
 
-        # check access-by-index
-        self.expect("frame variable numbers[0]",
-                    substrs=['1'])
-        self.expect("frame variable numbers[1]",
-                    substrs=['12'])
-        self.expect("frame variable numbers[2]",
-                    substrs=['123'])
-        self.expect("frame variable numbers[3]",
-                    substrs=['1234'])
+        self.check_numbers("numbers")
 
         # clear out the vector and see that we do the right thing once again
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+        lldbutil.continue_to_breakpoint(process, bkpt)
 
         self.expect("frame variable numbers",
                     substrs=['numbers = size=0'])
 
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+        lldbutil.continue_to_breakpoint(process, bkpt)
 
         # first value added
         self.expect("frame variable numbers",
                     substrs=['numbers = size=1',
                              '[0] = 7',
                              '}'])
 
         # check if we can display strings
def test_with_run_command(self):
                              'smart'])
 
         self.expect("p strings",
                     substrs=['vector has 3 items',
                              'goofy',
                              'is',
                              'smart'])
 
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+        lldbutil.continue_to_breakpoint(process, bkpt)
 
         self.expect("frame variable strings",
                     substrs=['vector has 4 items'])
 
         # check access-by-index
         self.expect("frame variable strings[0]",
                     substrs=['goofy'])
         self.expect("frame variable strings[1]",
                     substrs=['is'])
 
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+        lldbutil.continue_to_breakpoint(process, bkpt)
 
         self.expect("frame variable strings",
                     substrs=['vector has 0 items'])
+
+    def test_ref_and_ptr(self):
+        """Test that that file and class static variables display correctly."""
+        self.build()
+        (self.target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
+            self, "Stop here to check by ref", lldb.SBFileSpec("main.cpp", False))
+
+        # The reference should display the same was as the value did
+        self.check_numbers("ref")
+
+        # The pointer should just show the right number of elements:
+        
+        self.expect("frame variable ptr", substrs=['ptr =', ' size=7'])
+
+        self.expect("p ptr", substrs=['$', 'size=7'])

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/vector/main.cpp

 #include <stdio.h>
 #include <string>
 #include <vector>
 typedef std::vector<int> int_vect;
 typedef std::vector<std::string> string_vect;
 
+template <class T>
+void by_ref_and_ptr(std::vector<T> &ref, std::vector<T> *ptr) {
+  // Stop here to check by ref
+  return;  
+}
+
 int main()
 {
     int_vect numbers;
     (numbers.push_back(1));  // break here
     (numbers.push_back(12));  // break here
     (numbers.push_back(123));
     (numbers.push_back(1234));
     (numbers.push_back(12345)); // break here
     (numbers.push_back(123456));
     (numbers.push_back(1234567));
+    by_ref_and_ptr(numbers, &numbers);
     
     printf("break here");
     numbers.clear();
     
     (numbers.push_back(7)); // break here
 
     string_vect strings;
     (strings.push_back(std::string("goofy")));

lldb/trunk/source/Core/ValueObjectSyntheticFilter.cpp

 
 uint64_t ValueObjectSynthetic::GetByteSize() { return m_parent->GetByteSize(); }
 
 lldb::ValueType ValueObjectSynthetic::GetValueType() const {
   return m_parent->GetValueType();
 }
 
 void ValueObjectSynthetic::CreateSynthFilter() {
-  m_synth_filter_ap = (m_synth_sp->GetFrontEnd(*m_parent));
+  ValueObject *valobj_for_frontend = m_parent;
+  if (m_synth_sp->WantsDereference())
+  {
+    CompilerType type = m_parent->GetCompilerType();
+    if (type.IsValid() && type.IsPointerOrReferenceType())
+    {
+      Status error;
+      lldb::ValueObjectSP deref_sp = m_parent->Dereference(error);
+      if (error.Success())
+        valobj_for_frontend = deref_sp.get();
+    }
+  }
+  m_synth_filter_ap = (m_synth_sp->GetFrontEnd(*valobj_for_frontend));
   if (!m_synth_filter_ap.get())
     m_synth_filter_ap = llvm::make_unique<DummySyntheticFrontEnd>(*m_parent);
 }
 
 bool ValueObjectSynthetic::UpdateValue() {
   Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS);
 
   SetValueIsValid(false);

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

cpp_category_sp->GetTypeSummariesContainer()->Add(
       ConstString("std::__ndk1::basic_string<wchar_t, "
                   "std::__ndk1::char_traits<wchar_t>, "
                   "std::__ndk1::allocator<wchar_t> >"),
       std_wstring_summary_sp);
 
   SyntheticChildren::Flags stl_synth_flags;
   stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(
       false);
+  SyntheticChildren::Flags stl_deref_flags = stl_synth_flags;
+  stl_deref_flags.SetFrontEndWantsDereference();
 
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxBitsetSyntheticFrontEndCreator,
       "libc++ std::bitset synthetic children",
-      ConstString("^std::__(ndk)?1::bitset<.+>(( )?&)?$"), stl_synth_flags,
+      ConstString("^std::__(ndk)?1::bitset<.+>(( )?&)?$"), stl_deref_flags,
       true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator,
       "libc++ std::vector synthetic children",
-      ConstString("^std::__(ndk)?1::vector<.+>(( )?&)?$"), stl_synth_flags,
+      ConstString("^std::__(ndk)?1::vector<.+>(( )?&)?$"), stl_deref_flags,
       true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxStdForwardListSyntheticFrontEndCreator,
       "libc++ std::forward_list synthetic children",
       ConstString("^std::__(ndk)?1::forward_list<.+>(( )?&)?$"),
       stl_synth_flags, true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator,
       "libc++ std::list synthetic children",
       ConstString("^std::__(ndk)?1::list<.+>(( )?&)?$"), stl_synth_flags, true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
       "libc++ std::map synthetic children",
       ConstString("^std::__(ndk)?1::map<.+> >(( )?&)?$"), stl_synth_flags,
       true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
       "libc++ std::set synthetic children",
-      ConstString("^std::__(ndk)?1::set<.+> >(( )?&)?$"), stl_synth_flags,
+      ConstString("^std::__(ndk)?1::set<.+> >(( )?&)?$"), stl_deref_flags,
       true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
       "libc++ std::multiset synthetic children",
-      ConstString("^std::__(ndk)?1::multiset<.+> >(( )?&)?$"), stl_synth_flags,
+      ConstString("^std::__(ndk)?1::multiset<.+> >(( )?&)?$"), stl_deref_flags,
       true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
       "libc++ std::multimap synthetic children",
       ConstString("^std::__(ndk)?1::multimap<.+> >(( )?&)?$"), stl_synth_flags,
       true);
   AddCXXSynthetic(