Demangling support in BacktraceScreen

Add support of demangling symbol names in the backtrace screen.

Two backends are supported: libiberty (GNU) and libdemangle (Solaris).

[The initial code for demangling support with libiberty was written by
Odric. Kang-Che expanded the code to support libdemangle. Benny provided
code reviewes and minor fixes.]

Co-authored-by: Kang-Che Sung <explorer09@gmail.com>
Co-authored-by: Benny Baumann <BenBE@geshi.org>

Author: 3 people

BacktraceScreen.c

@@ -34,34 +34,45 @@ in the source distribution for its full text.
 #if defined(HAVE_BACKTRACE_SCREEN)
 
 static const char* const BacktraceScreenFunctions[] = {
+#if defined(HAVE_DEMANGLING)
+   "Mangle  ",
+#endif
    "Full Path",
    "Refresh",
    "Done   ",
    NULL
 };
 
 static const char* const BacktraceScreenKeys[] = {
+#if defined(HAVE_DEMANGLING)
+   "F2",
+#endif
    "F3",
    "F5",
    "Esc",
    NULL
 };
 
 static const int BacktraceScreenEvents[] = {
+#if defined(HAVE_DEMANGLING)
+   KEY_F(2),
+#endif
    KEY_F(3),
    KEY_F(5),
    27,
 };
 
 typedef enum BacktraceScreenDisplayOptions_ {
-   SHOW_FULL_PATH_OBJECT = 1 << 0,
+   DEMANGLE_NAME_FUNCTION = 1 << 0,
+   SHOW_FULL_PATH_OBJECT = 1 << 1,
 } BacktraceScreenDisplayOptions;
 
 BacktraceFrameData* BacktraceFrameData_new(void) {
    BacktraceFrameData* this = AllocThis(BacktraceFrameData);
    this->address = 0;
    this->offset = 0;
    this->functionName = NULL;
+   this->demangleFunctionName = NULL;
    this->objectPath = NULL;
    this->index = 0;
    this->isSignalFrame = false;
@@ -71,6 +82,7 @@ BacktraceFrameData* BacktraceFrameData_new(void) {
 void BacktraceFrameData_delete(Object* object) {
    BacktraceFrameData* this = (BacktraceFrameData*)object;
    free(this->functionName);
+   free(this->demangleFunctionName);
    free(this->objectPath);
    free(this);
 }
@@ -79,6 +91,8 @@ static void BacktracePanel_displayHeader(BacktracePanel* this) {
    const BacktracePanelPrintingHelper* printingHelper = &this->printingHelper;
    const int displayOptions = this->displayOptions;
 
+   bool showDemangledNames = (displayOptions & DEMANGLE_NAME_FUNCTION) && printingHelper->hasDemangledNames;
+
    bool showFullPathObject = !!(displayOptions & SHOW_FULL_PATH_OBJECT);
    size_t maxObjLen = showFullPathObject ? printingHelper->maxObjPathLen : printingHelper->maxObjNameLen;
 
@@ -95,7 +109,7 @@ static void BacktracePanel_displayHeader(BacktracePanel* this) {
       (int)printingHelper->maxFrameNumLen, "#",
       (int)(printingHelper->maxAddrLen + strlen("0x")), "ADDRESS",
       (int)maxObjLen, "FILE",
-      "NAME"
+      (showDemangledNames ? "NAME (demangled)" : "NAME")
    );
 
    Panel_setHeader((Panel*)this, line);
@@ -112,12 +126,17 @@ static void BacktracePanel_makePrintingHelper(const BacktracePanel* this, Backtr
    unsigned int maxFrameNum = 0;
    size_t longestAddress = 0;
 
+   printingHelper->hasDemangledNames = false;
+
    for (int i = 0; i < Vector_size(lines); i++) {
       const BacktracePanelRow* row = (const BacktracePanelRow*)Vector_get(lines, i);
       if (row->type != BACKTRACE_PANEL_ROW_DATA_FRAME) {
          continue;
       }
 
+      if (row->data.frame->demangleFunctionName)
+         printingHelper->hasDemangledNames = true;
+
       if (row->data.frame->objectPath) {
          const char* objectName = getBasename(row->data.frame->objectPath);
          size_t objectNameLength = strlen(objectName);
@@ -193,6 +212,18 @@ static HandlerResult BacktracePanel_eventHandler(Panel* super, int ch) {
    HandlerResult result = IGNORED;
 
    switch (ch) {
+#if defined(HAVE_DEMANGLING)
+   case KEY_F(2):
+      *displayOptions ^= DEMANGLE_NAME_FUNCTION;
+
+      bool showDemangledNames = !!(*displayOptions & DEMANGLE_NAME_FUNCTION);
+      FunctionBar_setLabel(super->defaultBar, KEY_F(2), showDemangledNames ? "Mangle  " : "Demangle");
+
+      this->super.needsRedraw = true;
+      BacktracePanel_displayHeader(this);
+      break;
+#endif
+
    case 'p':
    case KEY_F(3):
       *displayOptions ^= SHOW_FULL_PATH_OBJECT;
@@ -222,9 +253,11 @@ BacktracePanel* BacktracePanel_new(Vector* processes, const Settings* settings)
    this->printingHelper.maxFrameNumLen = strlen("#");
    this->printingHelper.maxObjNameLen = strlen("FILE");
    this->printingHelper.maxObjPathLen = strlen("FILE");
+   this->printingHelper.hasDemangledNames = false;
 
    this->settings = settings;
    this->displayOptions =
+      DEMANGLE_NAME_FUNCTION |
       (settings->showProgramPath ? SHOW_FULL_PATH_OBJECT : 0) |
       0;
 
@@ -331,7 +364,12 @@ static void BacktracePanelRow_displayFrame(const Object* super, RichString* out)
 
    const BacktraceFrameData* frame = row->data.frame;
 
-   const char* functionName = frame->functionName ? frame->functionName : "???";
+   const char* functionName = "???";
+   if ((displayOptions & DEMANGLE_NAME_FUNCTION) && frame->demangleFunctionName) {
+      functionName = frame->demangleFunctionName;
+   } else if (frame->functionName) {
+      functionName = frame->functionName;
+   }
 
    char* completeFunctionName = NULL;
    xAsprintf(&completeFunctionName, "%s+0x%zx", functionName, frame->offset);

BacktraceScreen.h

@@ -22,6 +22,7 @@ typedef struct BacktraceFrameData_ {
    size_t address;
    size_t offset;
    char* functionName;
+   char* demangleFunctionName;
    char* objectPath;
    unsigned int index;
    bool isSignalFrame;
@@ -32,6 +33,7 @@ typedef struct BacktracePanelPrintingHelper_ {
    size_t maxFrameNumLen;
    size_t maxObjPathLen;
    size_t maxObjNameLen;
+   bool hasDemangledNames;
 } BacktracePanelPrintingHelper;
 
 typedef struct BacktracePanel_ {

Makefile.am

@@ -172,6 +172,11 @@ myhtopheaders += \
 myhtopsources += \
 	BacktraceScreen.c \
 	generic/UnwindPtrace.c
+
+if HAVE_DEMANGLING
+myhtopheaders += generic/Demangle.h
+myhtopsources += generic/Demangle.c
+endif
 endif
 
 # Linux

README.md

@@ -120,6 +120,12 @@ To install on the local system run `make install`. By default `make install` ins
     - default: *no*
     - possible values:
       - unwind-ptrace: use **libunwind-ptrace** to get backtraces
+  * `--enable-demangling`:
+    enable demangling support for backtraces
+    - default: *check*
+    - possible values:
+      - libiberty: use **libiberty** (GNU) to demangle function names
+      - libdemangle: use **libdemangle** (Solaris) to demangle function names
   * `--enable-static`:
     build a static htop binary; hwloc and delay accounting are not supported
     - default: *no*

generic/Demangle.c

@@ -0,0 +1,67 @@
+/*
+htop - generic/Demangle.c
+(C) 2025 htop dev team
+Released under the GNU GPLv2+, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "config.h" // IWYU pragma: keep
+
+#include "generic/Demangle.h"
+
+#include <stdbool.h> // IWYU pragma: keep
+#include <stddef.h> // IWYU pragma: keep
+#include <stdint.h> // IWYU pragma: keep
+#include <stdlib.h> // IWYU pragma: keep
+#include <string.h> // IWYU pragma: keep
+
+#include "generic/ProvideDemangle.h"
+
+
+#ifdef HAVE_DEMANGLING
+char* Demangle_demangle(const char* mangled) {
+# if defined(HAVE_LIBIBERTY_CPLUS_DEMANGLE)
+   // The default in htop is to show as many details from the mangled
+   // name as possible.
+   int options = DMGL_AUTO |
+      DMGL_TYPES |
+      DMGL_VERBOSE /* Includes "disambiguators" of Rust crates */ |
+      DMGL_PARAMS;
+
+   return cplus_demangle(mangled, options);
+# elif defined(HAVE_LIBDEMANGLE_CPLUS_DEMANGLE)
+   // The cplus_demangle() API from libdemangle is flawed. It does not
+   // provide us the required size of the buffer to store the demangled
+   // name, and it leaves the buffer content undefined if the specified
+   // buffer size is not big enough.
+
+   // No crash on allocation failure. This is for safety against
+   // incredibly long demangled names in untrustable programs.
+   static size_t bufSize = 128;
+   static char* buf;
+
+   while (true) {
+      if (!buf) {
+         buf = malloc(bufSize);
+         if (!buf)
+            return NULL;
+      }
+
+      int res = cplus_demangle(mangled, buf, bufSize);
+      if (res == 0)
+         break;
+      if (res != DEMANGLE_ESPACE || bufSize > SIZE_MAX / 2)
+         return NULL;
+
+      bufSize *= 2;
+      free(buf);
+      buf = NULL;
+   }
+
+   return strdup(buf);
+# else
+   (void)mangled;
+   return NULL;
+# endif
+}
+#endif /* HAVE_DEMANGLING */

generic/Demangle.h

@@ -0,0 +1,24 @@
+#ifndef HEADER_Demangle
+#define HEADER_Demangle
+/*
+htop - generic/Demangle.h
+(C) 2025 htop dev team
+Released under the GNU GPLv2+, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "Macros.h"
+
+
+#ifdef HAVE_DEMANGLING
+ATTR_NONNULL ATTR_MALLOC
+char* Demangle_demangle(const char* mangled);
+#else
+ATTR_NONNULL
+static inline char* Demangle_demangle(const char* mangled) {
+   (void)mangled;
+   return NULL;
+}
+#endif /* HAVE_DEMANGLING */
+
+#endif

generic/UnwindPtrace.c

@@ -23,6 +23,10 @@ in the source distribution for its full text.
 #include <libunwind.h>
 #endif
 
+#ifdef HAVE_DEMANGLING
+#include "generic/Demangle.h"
+#endif
+
 
 #ifdef HAVE_LIBUNWIND_PTRACE
 static int ptraceAttach(pid_t pid) {
@@ -120,6 +124,11 @@ void UnwindPtrace_makeBacktrace(Vector* frames, pid_t pid, char** error) {
       if (unw_get_proc_name(&cursor, buffer, sizeof(buffer), &offset) == 0) {
          frame->offset = offset;
          frame->functionName = xStrndup(buffer, sizeof(buffer));
+
+# if defined(HAVE_DEMANGLING)
+         char* demangledName = Demangle_demangle(frame->functionName);
+         frame->demangleFunctionName = demangledName;
+# endif
       }
       Vector_add(frames, (Object *)frame);
       index++;