[llvm-cxxfilt] Split and demangle stdin input

[mattd]

Summary

Originally, llvm-cxxfilt would treat a line as a single mangled item to be demangled.
If a mangled name appears in the middle of that string, that name would not be demangled.

GNU c++filt splits and demangles every word in a string that is piped to it via stdin.
Prior to this patch llvm-cxxfilt would never split strings piped to it.
This patch replicates the GNU behavior and splits strings that are piped to it via stdin.

This fixes PR39990

[jhenderson]

llvm/test/tools/llvm-cxxfilt/types.test

2 ↗

(On Diff #183917)

You probably don't need this test, as it doesn't test any different functionality than the first test.

llvm/tools/llvm-cxxfilt/llvm-cxxfilt.cpp

9–11 ↗

(On Diff #183917)

I'm not sure you need (some of) these headers, even if you use them, by my understanding of the coding guidelines, because e.g. CommandLine.h includes them: https://llvm.org/docs/CodingStandards.html#include-as-little-as-possible

85 ↗

(On Diff #183917)

Mangled should be a StringRef.

[compnerd]

This actually breaks the compatibility with the existing tools. The quoted string is supposed to be interpreted as a *single* entry. I think that if you want to support something like this, it should be a separate flag for this behaviour.

[jhenderson]

In D57350#1375540, @compnerd wrote:

This actually breaks the compatibility with the existing tools. The quoted string is supposed to be interpreted as a *single* entry. I think that if you want to support something like this, it should be a separate flag for this behaviour.

Which tools are you referring to? This matches GNU c++filt behaviour for some cases at least:

C:\Work>c++filt "abc _Z3foov def"
abc _Z3foov def

C:\Work>c++filt
abc _Z3foov def // stdin
abc foo() def

C:\Work>nm bar.elf | c++filt
0000000000000000 t foo()

It looks like the behaviour is different depending on whether this is fed in via stdin or via the command-line.

[mattd]

In D57350#1375540, @compnerd wrote:

This actually breaks the compatibility with the existing tools. The quoted string is supposed to be interpreted as a *single* entry. I think that if you want to support something like this, it should be a separate flag for this behaviour.

That's a fair point. I'll respin the patch with a flag. Thanks for taking a look.

llvm/test/tools/llvm-cxxfilt/types.test

2 ↗

(On Diff #183917)

You are correct, this test is similar to the earlier test, but I wanted to the added functionality against the '-t' option as well.

[mattd]

llvm/tools/llvm-cxxfilt/llvm-cxxfilt.cpp

9–11 ↗

(On Diff #183917)

I can indirectly include SmallVector and StringRef. I'll still need to include StringExtras.

[mattd]

I've updated the patch to replicate GNU's c++filt behavior. This patch now only splits strings that are passed via stdin. It does not split strings that are passed as arguments to llvm-cxxfilt via command line.

[jhenderson]

This essentially looks good to me, aside from the extra test suggestion. I'm away for a week after today, so I won't be able to respond to further review issues until I'm back. I'm happy for this to land once @compnerd is.

llvm/test/tools/llvm-cxxfilt/simple.test

2–3 ↗

(On Diff #185865)

It may be worth adding a test to show that reading this from the command-line doesn't cause it to be demangled.

[compnerd]

LG with the additional test suggestion

llvm/trunk/test/tools/llvm-cxxfilt/simple.test

 RUN: llvm-cxxfilt _Z1fi abc | FileCheck %s
+RUN: echo "Mangled _Z1fi and _Z3foov in string." | llvm-cxxfilt \
+RUN:   | FileCheck %s --check-prefix=CHECK-STRING
+RUN: llvm-cxxfilt "CLI remains mangled _Z1fi" \
+RUN:   | FileCheck %s --check-prefix=CHECK-MANGLED
 
 CHECK: f(int)
 CHECK-NEXT: abc
+CHECK-STRING: Mangled f(int) and foo() in string.
+CHECK-MANGLED: CLI remains mangled _Z1fi

llvm/trunk/test/tools/llvm-cxxfilt/types.test

 RUN: llvm-cxxfilt -t f i | FileCheck %s
+RUN: echo "f i" | llvm-cxxfilt -t | FileCheck %s --check-prefix="CHECK-STRING"
 
 CHECK: float
 CHECK-NEXT: int
-
+CHECK-STRING: float int

llvm/trunk/tools/llvm-cxxfilt/llvm-cxxfilt.cpp

 //===-- llvm-c++filt.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/Demangle/Demangle.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdlib>
 #include <iostream>
 
 using namespace llvm;
Types("types",
           cl::desc("attempt to demangle types as well as function names"),
           cl::init(false));
 static cl::alias TypesShort("t", cl::desc("alias for --types"),
                             cl::aliasopt(Types));
 
 static cl::list<std::string>
 Decorated(cl::Positional, cl::desc("<mangled>"), cl::ZeroOrMore);
 
-static void demangle(llvm::raw_ostream &OS, const std::string &Mangled) {
+static std::string demangle(llvm::raw_ostream &OS, const std::string &Mangled) {
   int Status;
 
   const char *Decorated = Mangled.c_str();
   if (StripUnderscore)
     if (Decorated[0] == '_')
       ++Decorated;
   size_t DecoratedLength = strlen(Decorated);
 
   char *Undecorated = nullptr;
 
   if (Types || ((DecoratedLength >= 2 && strncmp(Decorated, "_Z", 2) == 0) ||
                 (DecoratedLength >= 4 && strncmp(Decorated, "___Z", 4) == 0)))
     Undecorated = itaniumDemangle(Decorated, nullptr, nullptr, &Status);
 
   if (!Undecorated &&
       (DecoratedLength > 6 && strncmp(Decorated, "__imp_", 6) == 0)) {
     OS << "import thunk for ";
     Undecorated = itaniumDemangle(Decorated + 6, nullptr, nullptr, &Status);
   }
 
-  OS << (Undecorated ? Undecorated : Mangled) << '\n';
-  OS.flush();
-
+  std::string Result(Undecorated ? Undecorated : Mangled);
   free(Undecorated);
+  return Result;
+}
+
+// If 'Split' is true, then 'Mangled' is broken into individual words and each
+// word is demangled.  Otherwise, the entire string is treated as a single
+// mangled item.  The result is output to 'OS'.
+static void demangleLine(llvm::raw_ostream &OS, StringRef Mangled, bool Split) {
+  std::string Result;
+  if (Split) {
+    SmallVector<StringRef, 16> Words;
+    SplitString(Mangled, Words);
+    for (auto Word : Words)
+      Result += demangle(OS, Word) + ' ';
+    // Remove the trailing space character.
+    if (Result.back() == ' ')
+      Result.pop_back();
+  } else
+    Result = demangle(OS, Mangled);
+  OS << Result << '\n';
+  OS.flush();
 }
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
 
   cl::ParseCommandLineOptions(argc, argv, "llvm symbol undecoration tool\n");
 
   if (Decorated.empty())
     for (std::string Mangled; std::getline(std::cin, Mangled);)
-      demangle(llvm::outs(), Mangled);
+      demangleLine(llvm::outs(), Mangled, true);
   else
     for (const auto &Symbol : Decorated)
-      demangle(llvm::outs(), Symbol);
+      demangleLine(llvm::outs(), Symbol, false);
 
   return EXIT_SUCCESS;
 }