[XRay][tools] Add option to llvm-xray extract to symbolize functions

[dberris]

Summary

This allows us to, if the symbol names are available in the binary, be
able to provide the function name in the YAML output.

[dblaikie]

Seems reasonable

include/llvm/XRay/InstrumentationMap.h

 };
 
 struct YAMLXRaySledEntry {
   int32_t FuncId;
   yaml::Hex64 Address;
   yaml::Hex64 Function;
   SledEntry::FunctionKinds Kind;
   bool AlwaysInstrument;
+  std::string FunctionName;
 };
 
 /// The InstrumentationMap represents the computed function id's and indicated
 /// function addresses from an object file (or a YAML file). This provides an
 /// interface to just the mapping between the function id, and the function
 /// address.
 ///
 /// We also provide raw access to the actual instrumentation map entries we find

 
 template <> struct MappingTraits<xray::YAMLXRaySledEntry> {
   static void mapping(IO &IO, xray::YAMLXRaySledEntry &Entry) {
     IO.mapRequired("id", Entry.FuncId);
     IO.mapRequired("address", Entry.Address);
     IO.mapRequired("function", Entry.Function);
     IO.mapRequired("kind", Entry.Kind);
     IO.mapRequired("always-instrument", Entry.AlwaysInstrument);
+    IO.mapOptional("function-name", Entry.FunctionName);
   }
 
   static constexpr bool flow = true;
 };
 
 } // end namespace yaml
 
 } // end namespace llvm
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(xray::YAMLXRaySledEntry)
 
 #endif // LLVM_XRAY_INSTRUMENTATION_MAP_H

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

+; This tests that we can extract the instrumentation map and symbolize the
+; function addresses.
+; RUN: llvm-xray extract %S/Inputs/elf64-example.bin -s | FileCheck %s
+
+; CHECK:      ---
+; CHECK-NEXT: - { id: 1, address: 0x000000000041C900, function: 0x000000000041C900, kind: function-enter, always-instrument: true, function-name: {{.*foo.*}} }
+; CHECK-NEXT: - { id: 1, address: 0x000000000041C912, function: 0x000000000041C900, kind: function-exit, always-instrument: true, function-name: {{.*foo.*}}  }
+; CHECK-NEXT: - { id: 2, address: 0x000000000041C930, function: 0x000000000041C930, kind: function-enter, always-instrument: true, function-name: {{.*bar.*}}  }
+; CHECK-NEXT: - { id: 2, address: 0x000000000041C946, function: 0x000000000041C930, kind: function-exit, always-instrument: true, function-name: {{.*bar.*}}  }
+; CHECK-NEXT: ...

tools/llvm-xray/xray-extract.cc

 //
 // FIXME: Support other XRay-instrumented binary formats other than ELF.
 //
 //===----------------------------------------------------------------------===//
 
 #include <type_traits>
 #include <utility>
 
+#include "func-id-helper.h"
 #include "xray-registry.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
static cl::opt<std::string> ExtractInput(cl::Positional,
                                          cl::sub(Extract));
 static cl::opt<std::string>
     ExtractOutput("output", cl::value_desc("output file"), cl::init("-"),
                   cl::desc("output file; use '-' for stdout"),
                   cl::sub(Extract));
 static cl::alias ExtractOutput2("o", cl::aliasopt(ExtractOutput),
                                 cl::desc("Alias for -output"),
                                 cl::sub(Extract));
+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"),
+                                   cl::sub(Extract));
 
 namespace {
 
-void exportAsYAML(const InstrumentationMap &Map, raw_ostream &OS) {
+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();
   YAMLSleds.reserve(std::distance(Sleds.begin(), Sleds.end()));
   for (const auto &Sled : Sleds) {
     auto FuncId = Map.getFunctionId(Sled.Function);
     if (!FuncId)
       return;
     YAMLSleds.push_back({*FuncId, Sled.Address, Sled.Function, Sled.Kind,
-                         Sled.AlwaysInstrument});
+                         Sled.AlwaysInstrument,
+                         ExtractSymbolize ? FH.SymbolOrNumber(*FuncId) : ""});
   }
   Output Out(OS, nullptr, 0);
   Out << YAMLSleds;
 }
 
 } // namespace
 
 static CommandRegistration Unused(&Extract, []() -> Error {
   auto InstrumentationMapOrError = loadInstrumentationMap(ExtractInput);
   if (!InstrumentationMapOrError)
     return joinErrors(make_error<StringError>(
                           Twine("Cannot extract instrumentation map from '") +
                               ExtractInput + "'.",
                           std::make_error_code(std::errc::invalid_argument)),
                       InstrumentationMapOrError.takeError());
 
   std::error_code EC;
   raw_fd_ostream OS(ExtractOutput, EC, sys::fs::OpenFlags::F_Text);
   if (EC)
     return make_error<StringError>(
         Twine("Cannot open file '") + ExtractOutput + "' for writing.", EC);
-  exportAsYAML(*InstrumentationMapOrError, OS);
+  const auto &FunctionAddresses =
+      InstrumentationMapOrError->getFunctionAddresses();
+  symbolize::LLVMSymbolizer::Options Opts(
+      symbolize::FunctionNameKind::LinkageName, true, true, false, "");
+  symbolize::LLVMSymbolizer Symbolizer(Opts);
+  llvm::xray::FuncIdConversionHelper FuncIdHelper(ExtractInput, Symbolizer,
+                                                  FunctionAddresses);
+  exportAsYAML(*InstrumentationMapOrError, OS, FuncIdHelper);
   return Error::success();
 });