[FormatEntity] Add mangled function name support

[mib]

Summary

Add function.mangled-name key for FormatEntity to show the mangled
function names in backtraces.

rdar://54088244

Signed-off-by: Med Ismail Bennani <[e-mail]>

[jasonmolenda]

lldb/test/Shell/Settings/TestFrameFormatMangling.test

10

Is this mangled name going to be the same on windows?

[JDevlieghere]

lldb/include/lldb/Target/Language.h

146 ↗

(On Diff #232973)

eNameMangled?

lldb/source/Core/FormatEntity.cpp

1754

Let's be consistent with the braces. Either all single-line statements should have them, or none.

1782

Early return?

1800

This looks odd, are you missing a closing brace?

lldb/test/Shell/Settings/Inputs/main.cpp

10

This looks not clang formatted. I'm pretty sure I added a .clang-format file for the shell tests that should match the one used by LLDB but without the 80 col limit.

lldb/test/Shell/Settings/TestFrameFormatMangling.test

8

Can we simplify the format? For example, I don't think the color matters here.

[mib]

Mark test as unsupported for windows.
Run clang-format.

[xiaobai]

lldb/test/Shell/Settings/Inputs/main.cpp

96

nit: comment unneeded.

lldb/test/Shell/Settings/TestFrameFormatMangling.test

10

This will definitely be different on windows, so this will fail.

[jingham]

If you make the frame format such that it is easy to pull the mangled & demangled names out of the format output (e.g. #${function.mangled-name}# ???${function.name}) then you could check that the two names are different, and for extra credit you could use "lang c++ demangle" to demangle it and match it against the regular mangled name...

[labath]

No opinion on the code, but I think the test needs to be cleaned up _a lot_.

lldb/test/Shell/Settings/Inputs/main.cpp

2

This file is about 70 lines longer than necessary to test this functionality, and it contains a #include statement in the middle of the file which is completely bogus

lldb/test/Shell/Settings/TestFrameFormatMangling.test

3

The -std argument doesn't seem relevant here.

4

-x not needed

[mib]

Remove unnecessary Language FunctionNameRepresention changes.
Rewrote test file. Refactored frame-format FormatEntity.

[JDevlieghere]

lldb/source/Core/FormatEntity.cpp

1763

No else after return

1768

You can write this as

if(Block *inline_block = sc->block->GetContainingInlinedBlock()) {

1771

Same here

lldb/test/Shell/Settings/Inputs/main.cpp

2

Tests don't need the license header

14

This tests seems way to complex for what you are testing. Unless another test is reusing this please make it as simple as possible.

lldb/test/Shell/Settings/TestFrameFormatMangling.test

11

If you're going to regex match the frame PC, why not remove it from the frame format?

[mib]

This comment was removed by mib.

[mib]

Simplifying the test.

[mib]

Run clang-format.

[JDevlieghere]

LGTM!

lldb/docs/use/formatting.rst

 | ``frame.reg.NAME``                                | Access to any platform specific register by name (replace ``NAME`` with the name of the desired register).                                                                                                                                                                                  |
 +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``function.name``                                 | The name of the current function or symbol.                                                                                                                                                                                                                                                 |
 +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``function.name-with-args``                       | The name of the current function with arguments and values or the symbol name.                                                                                                                                                                                                              |
 +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``function.name-without-args``                    | The name of the current function without arguments and values (used to include a function name in-line in the ``disassembly-format``)                                                                                                                                                       |
 +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| ``function.mangled-name``                         | The mangled name of the current function or symbol.                                                                                                                                                                                                                                         |
++---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``function.pc-offset``                            | The program counter offset within the current function or symbol                                                                                                                                                                                                                            |
 +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``function.addr-offset``                          | The offset in bytes of the current function, formatted as " + dddd"                                                                                                                                                                                                                         |
 +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``function.concrete-only-addr-offset-no-padding`` | Similar to ``function.addr-offset`` except that there are no spaces in the output (e.g. "+dddd") and the offset is computed from the nearest concrete function -- inlined functions are not included                                                                                        |
 +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``function.changed``                              | Will evaluate to true when the line being formatted is a different symbol context from the previous line (may be used in ``disassembly-format`` to print the new function name on a line by itself at the start of a new function).  Inlined functions are not considered for this variable |
 +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

lldb/include/lldb/Core/FormatEntity.h

enum class Type {
       FrameIsArtificial,
       ScriptFrame,
       FunctionID,
       FunctionDidChange,
       FunctionInitialFunction,
       FunctionName,
       FunctionNameWithArgs,
       FunctionNameNoArgs,
+      FunctionMangledName,
       FunctionAddrOffset,
       FunctionAddrOffsetConcrete,
       FunctionLineOffset,
       FunctionPCOffset,
       FunctionInitial,
       FunctionChanged,
       FunctionIsOptimized,
       LineEntryFile,

lldb/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjNSException.py

def test_nsexception_with_run_command(self):
         """Test formatters for NSException."""
         self.appkit_tester_impl(self.nsexception_data_formatter_commands)
 
     def nsexception_data_formatter_commands(self):
         self.expect(
             'frame variable except0 except1 except2 except3',
             substrs=[
                 '(NSException *) except0 = ',
-                'name: @"TheGuyWhoHasNoName" - reason: @"cuz it\'s funny"',
+                '@"First"',
                 '(NSException *) except1 = ',
-                'name: @"TheGuyWhoHasNoName~1" - reason: @"cuz it\'s funny"',
+                '@"Second"',
                 '(NSException *) except2 = ',
-                'name: @"TheGuyWhoHasNoName`2" - reason: @"cuz it\'s funny"',
+                ' @"Third"',
                 '(NSException *) except3 = ',
-                'name: @"TheGuyWhoHasNoName/3" - reason: @"cuz it\'s funny"'
+                ' @"Fourth"'
             ])

lldb/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-objc/main.m

NSString *hebrew = [NSString stringWithString:@"לילה טוב"];
 
       NSURL *nsurl0;
 
       for (NSBundle* bundle in bundles)
       {
           nsurl0 = [bundle bundleURL];
       }
 
-      NSException* except0 = [[NSException alloc] initWithName:@"TheGuyWhoHasNoName" reason:@"cuz it's funny" userInfo:nil];
-      NSException* except1 = [[NSException alloc] initWithName:@"TheGuyWhoHasNoName~1" reason:@"cuz it's funny" userInfo:nil];
-      NSException* except2 = [[NSException alloc] initWithName:@"TheGuyWhoHasNoName`2" reason:@"cuz it's funny" userInfo:nil];
-      NSException* except3 = [[NSException alloc] initWithName:@"TheGuyWhoHasNoName/3" reason:@"cuz it's funny" userInfo:nil];
+      NSException* except0 = [[NSException alloc] initWithName:@"TheGuyWhoHasNoName" reason:@"First" userInfo:nil];
+      NSException* except1 = [[NSException alloc] initWithName:@"TheGuyWhoHasNoName~1" reason:@"Second" userInfo:nil];
+      NSException* except2 = [[NSException alloc] initWithName:@"TheGuyWhoHasNoName`2" reason:@"Third" userInfo:nil];
+      NSException* except3 = [[NSException alloc] initWithName:@"TheGuyWhoHasNoName/3" reason:@"Fourth" userInfo:nil];
 
       NSURL *nsurl = [[NSURL alloc] initWithString:@"http://www.foo.bar"];
       NSURL *nsurl2 = [NSURL URLWithString:@"page.html" relativeToURL:nsurl];
       NSURL *nsurl3 = [NSURL URLWithString:@"?whatever" relativeToURL:nsurl2];
     
     NSDate *date1 = [NSDate dateWithNaturalLanguageString:@"6pm April 10, 1985"];
     NSDate *date2 = [NSDate dateWithNaturalLanguageString:@"12am January 1, 2011"];
     NSDate *date3 = [NSDate date];

lldb/packages/Python/lldbsuite/test/lang/objc/exceptions/TestObjCExceptions.py

def test_objc_exceptions_at_throw(self):
         launch_info = lldb.SBLaunchInfo(["a.out", "0"])
         lldbutil.run_to_name_breakpoint(self, "objc_exception_throw", launch_info=launch_info)
 
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped', 'stop reason = breakpoint'])
 
         self.expect('thread exception', substrs=[
                 '(NSException *) exception = ',
-                'name: "ThrownException" - reason: "SomeReason"',
+                '"SomeReason"',
             ])
 
         target = self.dbg.GetSelectedTarget()
         thread = target.GetProcess().GetSelectedThread()
         frame = thread.GetSelectedFrame()
 
         opts = lldb.SBVariablesOptions()
         opts.SetIncludeRecognizedArguments(True)
def test_objc_exceptions_at_throw(self):
         # No exception being currently thrown/caught at this point
         self.assertFalse(thread.GetCurrentException().IsValid())
         self.assertFalse(thread.GetCurrentExceptionBacktrace().IsValid())
 
         self.expect(
             'frame variable e1',
             substrs=[
                 '(NSException *) e1 = ',
-                'name: "ExceptionName" - reason: "SomeReason"'
+                '"SomeReason"'
             ])
 
         self.expect(
             'frame variable --dynamic-type no-run-target *e1',
             substrs=[
                 '(NSException) *e1 = ',
                 'name = ', '"ExceptionName"',
                 'reason = ', '"SomeReason"',
                 'userInfo = ', '1 key/value pair',
                 'reserved = ', 'nil',
             ])
 
         e1 = frame.FindVariable("e1")
         self.assertTrue(e1)
         self.assertEqual(e1.type.name, "NSException *")
-        self.assertEqual(e1.GetSummary(), 'name: "ExceptionName" - reason: "SomeReason"')
+        self.assertEqual(e1.GetSummary(), '"SomeReason"')
         self.assertEqual(e1.GetChildMemberWithName("name").description, "ExceptionName")
         self.assertEqual(e1.GetChildMemberWithName("reason").description, "SomeReason")
         userInfo = e1.GetChildMemberWithName("userInfo").dynamic
         self.assertEqual(userInfo.summary, "1 key/value pair")
         self.assertEqual(userInfo.GetChildAtIndex(0).GetChildAtIndex(0).description, "some_key")
         self.assertEqual(userInfo.GetChildAtIndex(0).GetChildAtIndex(1).description, "some_value")
         self.assertEqual(e1.GetChildMemberWithName("reserved").description, "<nil>")
 
         self.expect(
             'frame variable e2',
             substrs=[
                 '(NSException *) e2 = ',
-                'name: "ThrownException" - reason: "SomeReason"'
+                '"SomeReason"'
             ])
 
         self.expect(
             'frame variable --dynamic-type no-run-target *e2',
             substrs=[
                 '(NSException) *e2 = ',
                 'name = ', '"ThrownException"',
                 'reason = ', '"SomeReason"',
                 'userInfo = ', '1 key/value pair',
                 'reserved = ',
             ])
 
         e2 = frame.FindVariable("e2")
         self.assertTrue(e2)
         self.assertEqual(e2.type.name, "NSException *")
-        self.assertEqual(e2.GetSummary(), 'name: "ThrownException" - reason: "SomeReason"')
+        self.assertEqual(e2.GetSummary(), '"SomeReason"')
         self.assertEqual(e2.GetChildMemberWithName("name").description, "ThrownException")
         self.assertEqual(e2.GetChildMemberWithName("reason").description, "SomeReason")
         userInfo = e2.GetChildMemberWithName("userInfo").dynamic
         self.assertEqual(userInfo.summary, "1 key/value pair")
         self.assertEqual(userInfo.GetChildAtIndex(0).GetChildAtIndex(0).description, "some_key")
         self.assertEqual(userInfo.GetChildAtIndex(0).GetChildAtIndex(1).description, "some_value")
         reserved = e2.GetChildMemberWithName("reserved").dynamic
         self.assertGreater(reserved.num_children, 0)
def test_objc_exceptions_at_abort(self):
         self.runCmd("run 0")
 
         # We should be stopped at pthread_kill because of an unhandled exception
         self.expect("thread list",
             substrs=['stopped', 'stop reason = signal SIGABRT'])
 
         self.expect('thread exception', substrs=[
                 '(NSException *) exception = ',
-                'name: "ThrownException" - reason: "SomeReason"',
+                '"SomeReason"',
                 'libobjc.A.dylib`objc_exception_throw',
                 'a.out`foo', 'at main.mm:24',
                 'a.out`rethrow', 'at main.mm:35',
                 'a.out`main',
             ])
 
         process = self.dbg.GetSelectedTarget().process
         thread = process.GetSelectedThread()

lldb/source/Core/FormatEntity.cpp

static FormatEntity::Entry::Definition g_frame_child_entries[] = {
     ENTRY("is-artificial", FrameIsArtificial),
 };
 
 static FormatEntity::Entry::Definition g_function_child_entries[] = {
     ENTRY("id", FunctionID),
     ENTRY("name", FunctionName),
     ENTRY("name-without-args", FunctionNameNoArgs),
     ENTRY("name-with-args", FunctionNameWithArgs),
+    ENTRY("mangled-name", FunctionMangledName),
     ENTRY("addr-offset", FunctionAddrOffset),
     ENTRY("concrete-only-addr-offset-no-padding", FunctionAddrOffsetConcrete),
     ENTRY("line-offset", FunctionLineOffset),
     ENTRY("pc-offset", FunctionPCOffset),
     ENTRY("initial-function", FunctionInitial),
     ENTRY("changed", FunctionChanged),
     ENTRY("is-optimized", FunctionIsOptimized)};
 
switch (t) {
     ENUM_TO_CSTR(FrameIsArtificial);
     ENUM_TO_CSTR(ScriptFrame);
     ENUM_TO_CSTR(FunctionID);
     ENUM_TO_CSTR(FunctionDidChange);
     ENUM_TO_CSTR(FunctionInitialFunction);
     ENUM_TO_CSTR(FunctionName);
     ENUM_TO_CSTR(FunctionNameWithArgs);
     ENUM_TO_CSTR(FunctionNameNoArgs);
+    ENUM_TO_CSTR(FunctionMangledName);
     ENUM_TO_CSTR(FunctionAddrOffset);
     ENUM_TO_CSTR(FunctionAddrOffsetConcrete);
     ENUM_TO_CSTR(FunctionLineOffset);
     ENUM_TO_CSTR(FunctionPCOffset);
     ENUM_TO_CSTR(FunctionInitial);
     ENUM_TO_CSTR(FunctionChanged);
     ENUM_TO_CSTR(FunctionIsOptimized);
     ENUM_TO_CSTR(LineEntryFile);
if (language_plugin_handled) {
           s.PutCString(cstr);
           return true;
         }
       }
     }
   }
     return false;
 
+  case Entry::Type::FunctionMangledName: {
+    const char *name = nullptr;
+    if (sc->symbol)
+      name = sc->symbol->GetMangled()
+                 .GetName(sc->symbol->GetLanguage(), Mangled::ePreferMangled)
+                 .AsCString();
+    else if (sc->function)
+      name = sc->function->GetMangled()
+                 .GetName(sc->symbol->GetLanguage(), Mangled::ePreferMangled)
+                 .AsCString();
+
+    if (!name)
+      return false;
+    s.PutCString(name);
+
+    if (Block *inline_block = sc->block->GetContainingInlinedBlock()) {
+        if (const InlineFunctionInfo *inline_info = sc->block->GetInlinedFunctionInfo()) {
+          s.PutCString(" [inlined] ");
+          inline_info->GetName(sc->function->GetLanguage()).Dump(&s);
+        }
+    }
+    return true;
+  }
+
   case Entry::Type::FunctionAddrOffset:
     if (addr) {
       if (DumpAddressOffsetFromFunction(s, sc, exe_ctx, *addr, false, false,
                                         false))
         return true;
     }
     return false;
 
   case Entry::Type::FunctionAddrOffsetConcrete:
     if (addr) {
       if (DumpAddressOffsetFromFunction(s, sc, exe_ctx, *addr, true, true,
                                         true))
         return true;
     }
     return false;
 
   case Entry::Type::FunctionLineOffset:
     return (DumpAddressOffsetFromFunction(s, sc, exe_ctx,
                                           sc->line_entry.range.GetBaseAddress(),
                                           false, false, false));
 
   case Entry::Type::FunctionPCOffset:
     if (exe_ctx) {
       StackFrame *frame = exe_ctx->GetFramePtr();
       if (frame) {
         if (DumpAddressOffsetFromFunction(s, sc, exe_ctx,
                                           frame->GetFrameCodeAddress(), false,
                                           false, false))
           return true;
       }
     }
     return false;
 
   case Entry::Type::FunctionChanged:
     return function_changed;

lldb/source/Plugins/Language/ObjC/NSException.cpp

*reserved_sp = ValueObject::CreateValueObjectFromData(
         "reserved", reserved_isw.GetAsData(process_sp->GetByteOrder()),
         valobj.GetExecutionContextRef(), voidstar);
 
   return true;
 }
 
 bool lldb_private::formatters::NSException_SummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
-  lldb::ValueObjectSP name_sp;
   lldb::ValueObjectSP reason_sp;
-  if (!ExtractFields(valobj, &name_sp, &reason_sp, nullptr, nullptr))
+  if (!ExtractFields(valobj, nullptr, &reason_sp, nullptr, nullptr))
     return false;
 
-  if (!name_sp || !reason_sp)
+  if (!reason_sp) {
+    stream.Printf("No reason");
     return false;
+  }
 
-  StreamString name_str_summary;
   StreamString reason_str_summary;
-  if (NSStringSummaryProvider(*name_sp, name_str_summary, options) &&
-      NSStringSummaryProvider(*reason_sp, reason_str_summary, options) &&
-      !name_str_summary.Empty() && !reason_str_summary.Empty()) {
-    stream.Printf("name: %s - reason: %s", name_str_summary.GetData(),
-                  reason_str_summary.GetData());
+  if (NSStringSummaryProvider(*reason_sp, reason_str_summary, options) &&
+      !reason_str_summary.Empty()) {
+    stream.Printf("%s", reason_str_summary.GetData());
     return true;
   } else
     return false;
 }
 
 class NSExceptionSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 public:
   NSExceptionSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)

lldb/test/Shell/Settings/Inputs/main.cpp

+class Increment {
+public:
+  Increment(int value) { Increment::value += value; }
+
+  const int GetValue();
+
+private:
+  static int value;
+};
+
+int Increment::value = 40;
+
+const int Increment::GetValue() {
+  return value; // Set break point at this line.
+}
+
+int main() {
+  Increment i(2);
+  const int new_val = i.GetValue();
+  return new_val;
+}

lldb/test/Shell/Settings/TestFrameFormatMangling.test

+# UNSUPPORTED: system-windows
+# RUN: %clangxx_host -g -O0 %S/Inputs/main.cpp -o %t.out
+# RUN: %lldb -b -s %s %t.out | FileCheck %s
+br set -p "Set break"
+run
+frame info
+# CHECK: frame #0: {{.*}}Increment::GetValue(
+set set frame-format "frame #${frame.index}: {${function.mangled-name}}\n"
+frame info
+# CHECK: frame #0: _ZN9Increment8GetValueEv
+c
+q