[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/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:

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

+class MyClass {
+public:
+  MyClass() {}
+  void foo();
+};
+
+void MyClass::foo() {
+  return; // Set break point at this line.
+}
+
+int main() {
+  MyClass mc;
+  mc.foo();
+  return 0;
+}

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: {{.*}}MyClass::foo(
+set set frame-format "frame #${frame.index}: {${function.mangled-name}}\n"
+frame info
+# CHECK: frame #0: _ZN7MyClass3fooEv
+c
+q