Make all the Function implementations different so the compiler won't share them.

Clang on ARM64 was making the three Function methods with identical bodies have
one implementation that was shared.  That threw off the count of breakpoints, since
we don't count as separate locations three functions with the same address.

I also cleaned up the test case while I was at it.

<rdar://problem/27001915>

llvm-svn: 279800

diff --git a/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/TestCPPBreakpointCommands.py b/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/TestCPPBreakpointCommands.py
index 0a1ac11..c8442bc 100644 (file)
--- a/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/TestCPPBreakpointCommands.py
+++ b/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/TestCPPBreakpointCommands.py
@@ -17,70 +17,68 @@ class CPPBreakpointCommandsTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureAll(oslist=["windows"])
-    def test(self):
+
+    def make_breakpoint(self, name, type, expected_num_locations):
+        bkpt = self.target.BreakpointCreateByName (name,
+                                                   type,
+                                                   self.a_out_module,
+                                                   self.nested_comp_unit)
+        num_locations = bkpt.GetNumLocations()
+        self.assertTrue (num_locations == expected_num_locations, 
+                         "Wrong number of locations for '%s', expected: %d got: %d"%(
+                         name, expected_num_locations, num_locations))
+        return bkpt
+
+    def test_cpp_breakpoint_cmds(self):
         """Test a sequence of breakpoint command add, list, and delete."""
         self.build()
+
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target from the debugger.
 
-        target = self.dbg.CreateTarget (exe)
-        self.assertTrue(target, VALID_TARGET)
+        self.target = self.dbg.CreateTarget (exe)
+        self.assertTrue(self.target, VALID_TARGET)
 
-        a_out_module = lldb.SBFileSpecList()
-        a_out_module.Append(lldb.SBFileSpec(exe))
+        self.a_out_module = lldb.SBFileSpecList()
+        self.a_out_module.Append(lldb.SBFileSpec(exe))
 
-        nested_comp_unit = lldb.SBFileSpecList()
-        nested_comp_unit.Append (lldb.SBFileSpec("nested.cpp"))
+        self.nested_comp_unit = lldb.SBFileSpecList()
+        self.nested_comp_unit.Append (lldb.SBFileSpec("nested.cpp"))
 
         # First provide ONLY the method name.  This should get everybody...
-        auto_break = target.BreakpointCreateByName ("Function",
-                                                    lldb.eFunctionNameTypeAuto,
-                                                    a_out_module,
-                                                    nested_comp_unit)
-        self.assertTrue (auto_break.GetNumLocations() == 5)
+        self.make_breakpoint("Function",
+                              lldb.eFunctionNameTypeAuto,
+                              5)
 
         # Now add the Baz class specifier.  This should get the version contained in Bar,
         # AND the one contained in ::
-        auto_break = target.BreakpointCreateByName ("Baz::Function",
-                                                    lldb.eFunctionNameTypeAuto,
-                                                    a_out_module,
-                                                    nested_comp_unit)
-        self.assertTrue (auto_break.GetNumLocations() == 2)
+        self.make_breakpoint("Baz::Function",
+                              lldb.eFunctionNameTypeAuto,
+                              2)
 
         # Then add the Bar::Baz specifier.  This should get the version contained in Bar only
-        auto_break = target.BreakpointCreateByName ("Bar::Baz::Function",
-                                                    lldb.eFunctionNameTypeAuto,
-                                                    a_out_module,
-                                                    nested_comp_unit)
-        self.assertTrue (auto_break.GetNumLocations() == 1)
-
-        plain_method_break = target.BreakpointCreateByName ("Function", 
-                                                            lldb.eFunctionNameTypeMethod,
-                                                            a_out_module,
-                                                            nested_comp_unit)
-        self.assertTrue (plain_method_break.GetNumLocations() == 3)
-
-        plain_method_break = target.BreakpointCreateByName ("Baz::Function", 
-                                                            lldb.eFunctionNameTypeMethod,
-                                                            a_out_module,
-                                                            nested_comp_unit)
-        self.assertTrue (plain_method_break.GetNumLocations() == 2)
-
-        plain_method_break = target.BreakpointCreateByName ("Bar::Baz::Function", 
-                                                            lldb.eFunctionNameTypeMethod,
-                                                            a_out_module,
-                                                            nested_comp_unit)
-        self.assertTrue (plain_method_break.GetNumLocations() == 1)
-
-        plain_method_break = target.BreakpointCreateByName ("Function", 
-                                                            lldb.eFunctionNameTypeBase,
-                                                            a_out_module,
-                                                            nested_comp_unit)
-        self.assertTrue (plain_method_break.GetNumLocations() == 2)
-
-        plain_method_break = target.BreakpointCreateByName ("Bar::Function", 
-                                                            lldb.eFunctionNameTypeBase,
-                                                            a_out_module,
-                                                            nested_comp_unit)
-        self.assertTrue (plain_method_break.GetNumLocations() == 1)
+        self.make_breakpoint("Bar::Baz::Function",
+                              lldb.eFunctionNameTypeAuto,
+                              1)
+
+        self.make_breakpoint("Function", 
+                             lldb.eFunctionNameTypeMethod,
+                              3)
+
+        self.make_breakpoint("Baz::Function", 
+                              lldb.eFunctionNameTypeMethod,
+                              2)
+
+        self.make_breakpoint("Bar::Baz::Function", 
+                             lldb.eFunctionNameTypeMethod,
+                             1)
+
+        self.make_breakpoint("Function", 
+                             lldb.eFunctionNameTypeBase,
+                             2)
+
+        self.make_breakpoint("Bar::Function", 
+                             lldb.eFunctionNameTypeBase,
+                             1)
+

diff --git a/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/nested.cpp b/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/nested.cpp
index 29d4b4c..7406496 100644 (file)
--- a/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/nested.cpp
+++ b/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/nested.cpp
@@ -11,7 +11,7 @@ namespace Foo
       int Function () 
       {
         printf ("%s returning: %d.\n", __FUNCTION__, m_value);
-        return m_value;
+        return m_value + 1;
       }
     private:
       int m_value;
@@ -24,7 +24,7 @@ namespace Foo
       int Function () 
       {
         printf ("%s returning: %d.\n", __FUNCTION__, m_value);
-        return m_value;
+        return m_value + 2;
       }
     private:
       int m_value;
@@ -34,7 +34,7 @@ namespace Foo
     int Function ()
     {
       printf ("%s returning: %d.\n", __FUNCTION__, bar_value);
-      return bar_value;
+      return bar_value + 3;
     }
   }
 }
@@ -46,7 +46,7 @@ public:
     int Function () 
     {
         printf ("%s returning: %d.\n", __FUNCTION__, m_value);
-        return m_value;
+        return m_value + 4;
     }
 private:
     int m_value;