[lldb][Breakpoint] Prevent crash when resolving regex breakpoint on functions with asm declaration

[Michael137]

Summary

Currently, a function whose mangled name got
changed using an asm() statement on its
declaration will cause lldb to crash when
resolving restricted regex breakpoints.

The crash occurs because we previously assumed
that all functions in the SymbolContext will
cleanly demangle into a function name that we
can compare against the restrictions list.
However, with the asm() attribute applied
the mangled name may not conform to the
supported mangling schemes and we return
a nullptr.

The fix is to use the fallback parameter to
ConstString::AsCString().

Testing

• Added API test

[Michael137]

• Tweak test case

[Michael137]

• Skip Windows

[jingham]

LGTM. It's hard to prove a negative, but it might be worth checking the other uses of GetFunctionName and make sure we aren't making a similar mistake?

lldb/source/Breakpoint/BreakpointResolverFileRegex.cpp

if (!m_function_names.empty()) {
       std::vector<size_t> sc_to_remove;
       for (size_t i = 0; i < sc_list.GetSize(); i++) {
         SymbolContext sc_ctx;
         sc_list.GetContextAtIndex(i, sc_ctx);
         std::string name(
             sc_ctx
                 .GetFunctionName(
                     Mangled::NamePreference::ePreferDemangledWithoutArguments)
-                .AsCString());
-        if (!m_function_names.count(name)) {
+                .AsCString(""));
+
+        if (name.empty() || !m_function_names.count(name)) {
           sc_to_remove.push_back(i);
         }
       }
 
       if (!sc_to_remove.empty()) {
         std::vector<size_t>::reverse_iterator iter;
         std::vector<size_t>::reverse_iterator rend = sc_to_remove.rend();
         for (iter = sc_to_remove.rbegin(); iter != rend; iter++) {

lldb/test/API/functionalities/breakpoint/source_regexp_with_asm/Makefile

+CXX_SOURCES := main.cpp
+
+include Makefile.rules

lldb/test/API/functionalities/breakpoint/source_regexp_with_asm/TestSourceRegexBreakpointsWithAsm.py

+"""
+Test lldb breakpoint setting by source regular expression.
+"""
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestSourceRegexBreakpointsWithAsm(TestBase):
+
+    @skipIfWindows
+    def test_restrictions(self):
+        self.build()
+        self.source_regex_restrictions()
+
+    def source_regex_restrictions(self):
+        """ Test restricting source expressions to to functions with non-standard mangling."""
+        # Create a target by the debugger.
+        exe = self.getBuildArtifact("a.out")
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+
+        asm_tag = "NonStandardMangling"
+
+        # Sanity check that we can set breakpoint on non-standard mangled name
+        main_break = target.BreakpointCreateByName(asm_tag)
+
+        expected_num_locations = 1
+        num_locations = main_break.GetNumLocations()
+        self.assertEqual(
+            num_locations, expected_num_locations,
+            "We should have gotten %d matches, got %d." %
+            (expected_num_locations, num_locations))
+
+        # Check regex on asm tag restricted to function names
+        func_names = lldb.SBStringList()
+        func_names.AppendString('main')
+        func_names.AppendString('func')
+        func_names.AppendString('')
+        func_names.AppendString('NonStandardMangling')
+
+        main_break = target.BreakpointCreateBySourceRegex(
+            asm_tag, lldb.SBFileSpecList(), lldb.SBFileSpecList(), func_names)
+
+        expected_num_locations = 0
+        num_locations = main_break.GetNumLocations()
+        self.assertEqual(
+            num_locations, expected_num_locations,
+            "We should have gotten %d matches, got %d." %
+            (expected_num_locations, num_locations))

lldb/test/API/functionalities/breakpoint/source_regexp_with_asm/main.cpp

+int func_with_asm(void) asm("NonStandardMangling");
+
+int func_with_asm(void) { return 10; }
+
+int main() {
+  func_with_asm();
+  return 0;
+}