Improve C++ function name handling and step-in avoid regerxp handling

If the function is a template then the return type is part of the
function name. This CL fixes the parsing of these function names in
the case when the return type contains ':'.

The name of free functions in C++ don't have context part. Fix the
logic geting the function name without arguments out from a full
function name to handle this case.

Change the handling of step-in-avoid-regexp to match the value against
the function name without it's arguments and return value. This is
required because the default regex ("^std::") would match any template
function returning an std object.

Fifferential revision: http://reviews.llvm.org/D11461

llvm-svn: 243099

2 files changed, 65 insertions, 2 deletions

diff --git a/lldb/test/functionalities/inline-stepping/TestInlineStepping.py b/lldb/test/functionalities/inline-stepping/TestInlineStepping.py
index 9263395b20b..0137202964b 100644
--- a/lldb/test/functionalities/inline-stepping/TestInlineStepping.py
+++ b/lldb/test/functionalities/inline-stepping/TestInlineStepping.py
@@ -45,6 +45,21 @@ class TestInlineStepping(TestBase):
         """Test stepping over and into inlined functions."""
         self.buildDwarf()
         self.inline_stepping_step_over()
+    
+    @skipUnlessDarwin
+    @python_api_test
+    @dsym_test
+    def test_step_in_template_with_dsym_and_python_api(self):
+        """Test stepping in to templated functions."""
+        self.buildDsym()
+        self.step_in_template()
+
+    @python_api_test
+    @dwarf_test
+    def test_step_in_template_with_dwarf_and_python_api(self):
+        """Test stepping in to templated functions."""
+        self.buildDwarf()
+        self.step_in_template()
 
     def setUp(self):
         # Call super's setUp().
@@ -120,7 +135,6 @@ class TestInlineStepping(TestBase):
             target_line_entry.SetLine(step_stop_line)
             self.do_step (step_pattern[1], target_line_entry, test_stack_depth)
         
-
     def inline_stepping(self):
         """Use Python APIs to test stepping over and hitting breakpoints."""
         exe = os.path.join(os.getcwd(), "a.out")
@@ -245,8 +259,40 @@ class TestInlineStepping(TestBase):
                          ["// At increment in caller_ref_2.", "over"]]
         self.run_step_sequence (step_sequence)
 
+    def step_in_template(self):
+        """Use Python APIs to test stepping in to templated functions."""
+        exe = os.path.join(os.getcwd(), "a.out")
+
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+
+        break_1_in_main = target.BreakpointCreateBySourceRegex ('// Call max_value template', self.main_source_spec)
+        self.assertTrue(break_1_in_main, VALID_BREAKPOINT)
+        
+        break_2_in_main = target.BreakpointCreateBySourceRegex ('// Call max_value specialized', self.main_source_spec)
+        self.assertTrue(break_2_in_main, VALID_BREAKPOINT)
+
+        # Now launch the process, and do not stop at entry point.
+        self.process = target.LaunchSimple (None, None, self.get_process_working_directory())
+        self.assertTrue(self.process, PROCESS_IS_VALID)
+
+        # The stop reason of the thread should be breakpoint.
+        threads = lldbutil.get_threads_stopped_at_breakpoint (self.process, break_1_in_main)
+
+        if len(threads) != 1:
+            self.fail ("Failed to stop at first breakpoint in main.")
+
+        self.thread = threads[0]
+
+        step_sequence = [["// In max_value template", "into"]]
+        self.run_step_sequence(step_sequence)
         
+        threads = lldbutil.continue_to_breakpoint (self.process, break_2_in_main)
+        self.assertEqual(len(threads), 1, "Successfully ran to call site of second caller_trivial_1 call.")
+        self.thread = threads[0]
         
+        step_sequence = [["// In max_value specialized", "into"]]
+        self.run_step_sequence(step_sequence)
 
 if __name__ == '__main__':
     import atexit
diff --git a/lldb/test/functionalities/inline-stepping/calling.cpp b/lldb/test/functionalities/inline-stepping/calling.cpp
index e5a9570f253..9982fbf4273 100644
--- a/lldb/test/functionalities/inline-stepping/calling.cpp
+++ b/lldb/test/functionalities/inline-stepping/calling.cpp
@@ -1,4 +1,6 @@
-#include <stdio.h>
+#include <algorithm>
+#include <cstdio>
+#include <string>
 
 inline int inline_ref_1 (int &value) __attribute__((always_inline));
 inline int inline_ref_2 (int &value) __attribute__((always_inline));
@@ -97,6 +99,18 @@ inline_trivial_2 ()
     called_by_inline_trivial (); // At caller_by_inline_trivial in inline_trivial_2.
 }
 
+template<typename T> T
+max_value(const T& lhs, const T& rhs)
+{
+    return std::max(lhs, rhs); // In max_value template
+}
+
+template<> std::string
+max_value(const std::string& lhs, const std::string& rhs)
+{
+    return (lhs.size() > rhs.size()) ? lhs : rhs; // In max_value specialized
+}
+
 int
 main (int argc, char **argv)
 {
@@ -114,6 +128,9 @@ main (int argc, char **argv)
     caller_ref_1 (argc); // At second call of caller_ref_1 in main. 
     
     function_to_call (); // Make sure debug info for this function gets generated.
+    
+    max_value(123, 456);                                // Call max_value template
+    max_value(std::string("abc"), std::string("0022")); // Call max_value specialized
 
     return 0;            // About to return from main.
 }