We were getting the wrong dynamic type if there were two classes with the same basename.

There's a bug in FindTypes, it ignores the exact flag if you pass a name that doesn't begin with
:: and pass eTypeClassAny for the type.

In this case we always know that the name we get from the vtable name is absolute so we can
work around the bug by prepending the "::".  This doesn't fix the FindTypes bug.

<rdar://problem/38010986>

llvm-svn: 326412

lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value-same-basename/Makefile

@@ -0,0 +1,5 @@
+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value-same-basename/TestDynamicValueSameBase.py

@@ -0,0 +1,62 @@
+"""
+Make sure if we have two classes with the same base name the
+dynamic value calculator doesn't confuse them
+"""
+
+from __future__ import print_function
+
+
+import os
+import time
+import re
+import lldb
+import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.lldbtest import *
+
+
+class RenameThisSampleTestTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    # If your test case doesn't stress debug info, the 
+    # set this to true.  That way it won't be run once for
+    # each debug info format.
+    NO_DEBUG_INFO_TESTCASE = True
+
+    def test_same_basename_this(self):
+        """Test that the we use the full name to resolve dynamic types."""
+        self.build()
+        self.main_source_file = lldb.SBFileSpec("main.cpp")
+        self.sample_test()
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+
+    def sample_test(self):
+        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
+                                   "Break here to get started", self.main_source_file) 
+
+        # Set breakpoints in the two class methods and run to them:
+        namesp_bkpt = target.BreakpointCreateBySourceRegex("namesp function did something.", self.main_source_file)
+        self.assertEqual(namesp_bkpt.GetNumLocations(), 1, "Namespace breakpoint invalid")
+
+        virtual_bkpt = target.BreakpointCreateBySourceRegex("Virtual function did something.", self.main_source_file)
+        self.assertEqual(virtual_bkpt.GetNumLocations(), 1, "Virtual breakpoint invalid")
+
+        threads = lldbutil.continue_to_breakpoint(process, namesp_bkpt)
+        self.assertEqual(len(threads), 1, "Didn't stop at namespace breakpoint")
+
+        frame = threads[0].frame[0]
+        namesp_this = frame.FindVariable("this", lldb.eDynamicCanRunTarget)
+        self.assertEqual(namesp_this.GetTypeName(), "namesp::Virtual *", "Didn't get the right dynamic type")
+
+        threads = lldbutil.continue_to_breakpoint(process, virtual_bkpt)
+        self.assertEqual(len(threads), 1, "Didn't stop at virtual breakpoint")
+
+        frame = threads[0].frame[0]
+        virtual_this = frame.FindVariable("this", lldb.eDynamicCanRunTarget)
+        self.assertEqual(virtual_this.GetTypeName(), "Virtual *", "Didn't get the right dynamic type")
+
+        
+

lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value-same-basename/main.cpp

@@ -0,0 +1,32 @@
+#include <stdio.h>
+
+namespace namesp
+{
+  class Virtual {
+  public:
+    virtual void doSomething() {
+      printf ("namesp function did something.\n");
+    }
+  }; 
+}
+
+class Virtual {
+  public:
+  virtual void doSomething() {
+    printf("Virtual function did something.\n");
+  }
+};
+
+int
+main()
+{
+  namesp::Virtual my_outer;
+  Virtual my_virtual;
+
+  // Break here to get started
+  my_outer.doSomething();
+  my_virtual.doSomething();
+
+  return 0;
+}
+    

lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp

@@ -83,6 +83,11 @@ TypeAndOrName ItaniumABILanguageRuntime::GetTypeInfoFromVTableAddress(
             // We are a C++ class, that's good.  Get the class name and look it
             // up:
             const char *class_name = name + strlen(vtable_demangled_prefix);
+            // We know the class name is absolute, so tell FindTypes that by
+            // prefixing it with the root namespace:
+            std::string lookup_name("::");
+            lookup_name.append(class_name);
+            
             type_info.SetName(class_name);
             const bool exact_match = true;
             TypeList class_types;
@@ -93,7 +98,7 @@ TypeAndOrName ItaniumABILanguageRuntime::GetTypeInfoFromVTableAddress(
             llvm::DenseSet<SymbolFile *> searched_symbol_files;
             if (sc.module_sp) {
               num_matches = sc.module_sp->FindTypes(
-                  sc, ConstString(class_name), exact_match, 1,
+                  sc, ConstString(lookup_name), exact_match, 1,
                   searched_symbol_files, class_types);
             }
 
@@ -102,7 +107,7 @@ TypeAndOrName ItaniumABILanguageRuntime::GetTypeInfoFromVTableAddress(
             // as possible
             if (num_matches == 0) {
               num_matches = target.GetImages().FindTypes(
-                  sc, ConstString(class_name), exact_match, UINT32_MAX,
+                  sc, ConstString(lookup_name), exact_match, UINT32_MAX,
                   searched_symbol_files, class_types);
             }