llvm-xray {convert,extract}: Add --demangle

[MaskRay]

Summary

No demangling may be a better default in the future.
Add --demangle for migration convenience.

[Enna1]

When D108019 is landed, add if (Demangle.getPosition() < NoDemangle.getPosition()) to xray-converter.cpp like xray-extract.cpp?

[MaskRay]

Yes. Depends on the order the patches land.

[MaskRay]

Ping

llvm/test/tools/llvm-xray/AArch64/extract-instrmap.test

 ## This test makes sure we can extract the instrumentation map from an
 ## XRay-instrumented PIE file.
 
 # RUN: yaml2obj %S/Inputs/elf64-pic.yaml -o %t.so
 # RUN: llvm-xray extract %t.so -s | FileCheck %s
+# RUN: llvm-xray extract %t.so --no-demangle --demangle -s | FileCheck %s
 
 # CHECK:      ---
 # CHECK-NEXT: - { id: 1, address: 0x420, function: 0x420, kind: function-enter, always-instrument: true, function-name: 'foo()' }
 # CHECK-NEXT: - { id: 1, address: 0x440, function: 0x420, kind: function-exit, always-instrument: true, function-name: 'foo()' }
 # CHECK-NEXT: - { id: 2, address: 0x464, function: 0x464, kind: function-enter, always-instrument: true, function-name: 'bar()' }
 # CHECK-NEXT: - { id: 2, address: 0x484, function: 0x464, kind: function-exit, always-instrument: true, function-name: 'bar()' }
 # CHECK-NEXT: - { id: 3, address: 0x4A8, function: 0x4A8, kind: function-enter, always-instrument: true, function-name: 'jar()' }
 # CHECK-NEXT: - { id: 3, address: 0x4C8, function: 0x4A8, kind: function-exit, always-instrument: true, function-name: 'jar()' }
 # CHECK-NEXT: ...
 
 # RUN: llvm-xray extract -s --no-demangle %t.so | FileCheck --check-prefix=MANGLED %s
+# RUN: llvm-xray extract -s --demangle --no-demangle %t.so | FileCheck --check-prefix=MANGLED %s
 
 # MANGLED:      ---
 # MANGLED-NEXT: - { id: 1, address: 0x420, function: 0x420, kind: function-enter, always-instrument: true, function-name: _Z3foov }
 # MANGLED-NEXT: - { id: 1, address: 0x440, function: 0x420, kind: function-exit, always-instrument: true, function-name: _Z3foov }
 # MANGLED-NEXT: - { id: 2, address: 0x464, function: 0x464, kind: function-enter, always-instrument: true, function-name: _Z3barv }
 # MANGLED-NEXT: - { id: 2, address: 0x484, function: 0x464, kind: function-exit, always-instrument: true, function-name: _Z3barv }
 # MANGLED-NEXT: - { id: 3, address: 0x4A8, function: 0x4A8, kind: function-enter, always-instrument: true, function-name: _Z3jarv }
 # MANGLED-NEXT: - { id: 3, address: 0x4C8, function: 0x4A8, kind: function-exit, always-instrument: true, function-name: _Z3jarv }
 # MANGLED-NEXT: ...

llvm/test/tools/llvm-xray/X86/convert-with-debug-syms.txt

-; RUN: llvm-xray convert -m %S/Inputs/elf64-sample-o2.bin -y %S/Inputs/naive-log-simple.xray -f yaml -o - 2>&1 | FileCheck %s
+; RUN: llvm-xray convert -m %S/Inputs/elf64-sample-o2.bin -y %S/Inputs/naive-log-simple.xray -f yaml 2>&1 | FileCheck %s
+; RUN: llvm-xray convert -m %S/Inputs/elf64-sample-o2.bin -y %S/Inputs/naive-log-simple.xray -f yaml --demangle 2>&1 | FileCheck %s
 
 ; CHECK:      ---
 ; CHECK-NEXT: header:
 ; CHECK-NEXT:   version:         1
 ; CHECK-NEXT:   type:            0
 ; CHECK-NEXT:   constant-tsc:    true
 ; CHECK-NEXT:   nonstop-tsc:     true
 ; CHECK-NEXT:   cycle-frequency: 2601000000

llvm/test/tools/llvm-xray/X86/extract-instrmap-pie.ll

 ; This test makes sure we can extract the instrumentation map from an
 ; XRay-instrumented PIE file.
 ;
 ; RUN: llvm-xray extract %S/Inputs/elf64-pie.bin -s | FileCheck %s
 
 ; CHECK:      ---
-; CHECK-NEXT: - { id: 1, address: 0x299C0, function: 0x299C0, kind: function-enter, always-instrument: true, function-name: {{.*foo.*}} }
-; CHECK-NEXT: - { id: 1, address: 0x299D0, function: 0x299C0, kind: function-exit, always-instrument: true, function-name: {{.*foo.*}} }
-; CHECK-NEXT: - { id: 2, address: 0x299E0, function: 0x299E0, kind: function-enter, always-instrument: true, function-name: {{.*bar.*}} }
-; CHECK-NEXT: - { id: 2, address: 0x299F6, function: 0x299E0, kind: function-exit, always-instrument: true, function-name: {{.*bar.*}} }
+; CHECK-NEXT: - { id: 1, address: 0x299C0, function: 0x299C0, kind: function-enter, always-instrument: true, function-name: 'foo()' }
+; CHECK-NEXT: - { id: 1, address: 0x299D0, function: 0x299C0, kind: function-exit, always-instrument: true, function-name: 'foo()' }
+; CHECK-NEXT: - { id: 2, address: 0x299E0, function: 0x299E0, kind: function-enter, always-instrument: true, function-name: 'bar()' }
+; CHECK-NEXT: - { id: 2, address: 0x299F6, function: 0x299E0, kind: function-exit, always-instrument: true, function-name: 'bar()' }
 ; CHECK-NEXT: ...

llvm/tools/llvm-xray/xray-converter.cpp

 static cl::alias ConvertSymbolize2("y", cl::aliasopt(ConvertSymbolize),
                                    cl::desc("Alias for -symbolize"));
 static cl::opt<bool>
     NoDemangle("no-demangle",
                cl::desc("determines whether to demangle function name "
                         "when symbolizing function ids from the input log"),
                cl::init(false), cl::sub(Convert));
 
+static cl::opt<bool> Demangle("demangle",
+                              cl::desc("demangle symbols (default)"),
+                              cl::sub(Convert));
+
 static cl::opt<std::string>
     ConvertInstrMap("instr_map",
                     cl::desc("binary with the instrumentation map, or "
                              "a separate instrumentation map"),
                     cl::value_desc("binary with xray_instr_map"),
                     cl::sub(Convert), cl::init(""));
 static cl::alias ConvertInstrMap2("m", cl::aliasopt(ConvertInstrMap),
                                   cl::desc("Alias for -instr_map"));
if (!InstrumentationMapOrError)
                                 ConvertInstrMap + "'",
                             std::make_error_code(std::errc::invalid_argument)),
                         InstrumentationMapOrError.takeError());
     Map = std::move(*InstrumentationMapOrError);
   }
 
   const auto &FunctionAddresses = Map.getFunctionAddresses();
   symbolize::LLVMSymbolizer::Options SymbolizerOpts;
-  if (NoDemangle)
+  if (Demangle.getPosition() < NoDemangle.getPosition())
     SymbolizerOpts.Demangle = false;
   symbolize::LLVMSymbolizer Symbolizer(SymbolizerOpts);
   llvm::xray::FuncIdConversionHelper FuncIdHelper(ConvertInstrMap, Symbolizer,
                                                   FunctionAddresses);
   llvm::xray::TraceConverter TC(FuncIdHelper, ConvertSymbolize);
   std::error_code EC;
   raw_fd_ostream OS(ConvertOutput, EC,
                     ConvertOutputFormat == ConvertFormats::BINARY

llvm/tools/llvm-xray/xray-extract.cpp

 static cl::alias ExtractOutput2("o", cl::aliasopt(ExtractOutput),
                                 cl::desc("Alias for -output"));
 static cl::opt<bool> ExtractSymbolize("symbolize", cl::value_desc("symbolize"),
                                       cl::init(false),
                                       cl::desc("symbolize functions"),
                                       cl::sub(Extract));
 static cl::alias ExtractSymbolize2("s", cl::aliasopt(ExtractSymbolize),
                                    cl::desc("alias for -symbolize"));
-static cl::opt<bool> ExtractNoDemangle("no-demangle",
-                                       cl::value_desc("no-demangle"),
-                                       cl::init(false),
-                                       cl::desc("don't demangle symbols"),
-                                       cl::sub(Extract));
+static cl::opt<bool> Demangle("demangle",
+                              cl::desc("demangle symbols (default)"),
+                              cl::sub(Extract));
+static cl::opt<bool> NoDemangle("no-demangle",
 
 namespace {
 
 void exportAsYAML(const InstrumentationMap &Map, raw_ostream &OS,
                   FuncIdConversionHelper &FH) {
   // First we translate the sleds into the YAMLXRaySledEntry objects in a deque.
   std::vector<YAMLXRaySledEntry> YAMLSleds;
   auto Sleds = Map.sleds();
static CommandRegistration Unused(&Extract, []() -> Error {
   std::error_code EC;
   raw_fd_ostream OS(ExtractOutput, EC, sys::fs::OpenFlags::OF_TextWithCRLF);
   if (EC)
     return make_error<StringError>(
         Twine("Cannot open file '") + ExtractOutput + "' for writing.", EC);
   const auto &FunctionAddresses =
       InstrumentationMapOrError->getFunctionAddresses();
   symbolize::LLVMSymbolizer::Options opts;
-  if (ExtractNoDemangle)
+  if (Demangle.getPosition() < NoDemangle.getPosition())
     opts.Demangle = false;
   symbolize::LLVMSymbolizer Symbolizer(opts);
   llvm::xray::FuncIdConversionHelper FuncIdHelper(ExtractInput, Symbolizer,
                                                   FunctionAddresses);
   exportAsYAML(*InstrumentationMapOrError, OS, FuncIdHelper);
   return Error::success();
 });