Index: source/Core/Mangled.cpp =================================================================== --- source/Core/Mangled.cpp +++ source/Core/Mangled.cpp @@ -95,10 +95,11 @@ 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; Index: source/Target/CPPLanguageRuntime.cpp =================================================================== --- source/Target/CPPLanguageRuntime.cpp +++ source/Target/CPPLanguageRuntime.cpp @@ -306,17 +306,14 @@ 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()' + 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()' - 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 { Index: source/Target/ThreadPlanStepInRange.cpp =================================================================== --- source/Target/ThreadPlanStepInRange.cpp +++ source/Target/ThreadPlanStepInRange.cpp @@ -375,7 +375,7 @@ 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; Index: test/functionalities/disassembly/TestDisassembleBreakpoint.py =================================================================== --- test/functionalities/disassembly/TestDisassembleBreakpoint.py +++ test/functionalities/disassembly/TestDisassembleBreakpoint.py @@ -53,7 +53,7 @@ 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 Index: test/functionalities/inline-stepping/TestInlineStepping.py =================================================================== --- test/functionalities/inline-stepping/TestInlineStepping.py +++ test/functionalities/inline-stepping/TestInlineStepping.py @@ -45,6 +45,21 @@ """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 @@ 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 @@ ["// 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 Index: test/functionalities/inline-stepping/calling.cpp =================================================================== --- test/functionalities/inline-stepping/calling.cpp +++ test/functionalities/inline-stepping/calling.cpp @@ -1,4 +1,6 @@ -#include +#include +#include +#include inline int inline_ref_1 (int &value) __attribute__((always_inline)); inline int inline_ref_2 (int &value) __attribute__((always_inline)); @@ -97,6 +99,18 @@ called_by_inline_trivial (); // At caller_by_inline_trivial in inline_trivial_2. } +template 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 @@ 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. }