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

[tberghammer]

Summary

Improve C++ function name handling and step-in avoid regexp 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 getting 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 regexp ("^std::") would match any template
function returning an std object.

[clayborg]

Jim Ingham should be included as a reviewer. I am OK if he is OK with this.

[jingham]

I'm fine with this. It doesn't seem very useful to include the return type of templates in the name that the step-avoid regexp matches, especially since it would make the "no functions implemented in std::" regexp extremely tedious to try and write...

Jim

source/Core/Mangled.cpp

get_demangled_name_without_arguments (ConstString mangled, ConstString demangled)
     if (demangled && mangled_name_cstr && mangled_name_cstr[0])
     {
         if (mangled_name_cstr[0] == '_' && mangled_name_cstr[1] == 'Z' &&
             (mangled_name_cstr[2] != 'T' && // avoid virtual table, VTT structure, typeinfo structure, and typeinfo mangled_name
             mangled_name_cstr[2] != 'G' && // avoid guard variables
             mangled_name_cstr[2] != 'Z'))  // named local entities (if we eventually handle eSymbolTypeData, we will want this back)
         {
             CPPLanguageRuntime::MethodName cxx_method (demangled);
-            if (!cxx_method.GetBasename().empty() && !cxx_method.GetContext().empty())
+            if (!cxx_method.GetBasename().empty())
             {
-                std::string shortname = cxx_method.GetContext().str();
-                shortname += "::";
+                std::string shortname;
+                if (!cxx_method.GetContext().empty())
+                    shortname = cxx_method.GetContext().str() + "::";
                 shortname += cxx_method.GetBasename().str();
                 ConstString result(shortname.c_str());
                 g_most_recent_mangled_to_name_sans_args.first = mangled;
                 g_most_recent_mangled_to_name_sans_args.second = result;
                 return g_most_recent_mangled_to_name_sans_args.second;
             }
         }
     }

source/Target/CPPLanguageRuntime.cpp

//            printf ("   mangled = '%s'\n", mangled.GetCString());
                 if (basename_end > 0 && full[basename_end-1] == '>')
                 {
                     // TODO: handle template junk...
                     // Templated function
                     size_t template_start, template_end;
                     llvm::StringRef lt_gt("<>", 2);
                     if (ReverseFindMatchingChars (full, lt_gt, template_start, template_end, basename_end))
                     {
+                        // Check for templated functions that include return type like: 'void foo<Int>()'
+                        context_start = full.rfind(' ', template_start);
+                        if (context_start == llvm::StringRef::npos)
+                            context_start = 0;
+
                         context_end = full.rfind(':', template_start);
-                        if (context_end == llvm::StringRef::npos)
-                        {
-                            // Check for templated functions that include return type like:
-                            // 'void foo<Int>()'
-                            context_end = full.rfind(' ', template_start);
-                            if (context_end != llvm::StringRef::npos)
-                            {
-                                context_start = context_end;
-                            }
-                        }
+                        if (context_end == llvm::StringRef::npos || context_end < context_start)
+                            context_end = context_start;
                     }
                     else
                     {
                         context_end = full.rfind(':', basename_end);
                     }
                 }
                 else if (context_end == llvm::StringRef::npos)
                 {

source/Target/ThreadPlanStepInRange.cpp

ThreadPlanStepInRange::FrameMatchesAvoidCriteria ()
     if (avoid_regexp_to_use == NULL)
         avoid_regexp_to_use = GetThread().GetSymbolsToAvoidRegexp();
         
     if (avoid_regexp_to_use != NULL)
     {
         SymbolContext sc = frame->GetSymbolContext(eSymbolContextFunction|eSymbolContextBlock|eSymbolContextSymbol);
         if (sc.symbol != NULL)
         {
-            const char *frame_function_name = sc.GetFunctionName().GetCString();
+            const char *frame_function_name = sc.GetFunctionName(Mangled::ePreferDemangledWithoutArguments).GetCString();
             if (frame_function_name)
             {
                 size_t num_matches = 0;
                 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
                 if (log)
                     num_matches = 1;
                 
                 RegularExpression::Match regex_match(num_matches);

test/functionalities/disassembly/TestDisassembleBreakpoint.py

def disassemble_breakpoint (self):
             # TODO please add your arch here
             self.fail('unimplemented for arch = "{arch}"'.format(arch=self.getArchitecture()))
 
         # make sure that the software breakpoint has been removed
         for op in breakpoint_opcodes:
             self.assertFalse(op in disassembly)
 
         # make sure a few reasonable assembly instructions are here
-        self.expect(disassembly, exe=False, startstr = "a.out`sum(int, int)", substrs = instructions)
+        self.expect(disassembly, exe=False, startstr = "a.out`sum", substrs = instructions)
 
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()
 

test/functionalities/inline-stepping/TestInlineStepping.py

class TestInlineStepping(TestBase):
 
     @python_api_test
     @dwarf_test
     @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     def test_step_over_with_dwarf_and_python_api(self):
         """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().
         TestBase.setUp(self)
         # Find the line numbers that we will step to in main:
         self.main_source = "calling.cpp"
         self.source_lines = {}
         functions = ['caller_ref_1', 'caller_ref_2', 'inline_ref_1', 'inline_ref_2', 'called_by_inline_ref', 'caller_trivial_1', 'caller_trivial_2', 'inline_trivial_1', 'inline_trivial_2', 'called_by_inline_trivial' ]
         for name in functions:
def run_step_sequence(self, step_sequence):
         if self.platformIsDarwin():
             test_stack_depth = False
 
         for step_pattern in step_sequence:
             step_stop_line = line_number (self.main_source, step_pattern[0])
             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")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         break_1_in_main = target.BreakpointCreateBySourceRegex ('// Stop here and step over to set up stepping over.', self.main_source_spec)
def inline_stepping_step_over(self):
 
         self.thread = threads[0]
 
         step_sequence = [["// In caller_ref_1.", "into"],
                          ["// In caller_ref_2.", "into"],
                          ["// 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
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()

test/functionalities/inline-stepping/calling.cpp

-#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));
 
 int caller_ref_1 (int &value);
 int caller_ref_2 (int &value);
 
 int called_by_inline_ref (int &value);

 
 void
 inline_trivial_2 ()
 {
     inline_value += 1; // In 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)
 {
     
     inline_value = 0;    // Stop here and step over to set up stepping over.
 
     inline_trivial_1 ();    // At inline_trivial_1 called from main.
 
     caller_trivial_1();     // At first call of caller_trivial_1 in main.
     
     caller_trivial_1();     // At second call of caller_trivial_1 in main.
     
     caller_ref_1 (argc); // At first call of caller_ref_1 in main.
     
     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.
 }