[XRay][tools] Support new kinds of instrumentation map entries

[dberris]

Summary

When extracting the instrumentation map from a binary, we should be able
to recognize the new kinds of instrumentation sleds we've been emitting
with the compiler using -fxray-instrument. This change adds a test for
all the kinds of sleds we currently support (sans the tail-call sled,
which is a bit harder to force in a simple prebuilt input).

[kpw]

I've missed the opportunity to do something similar in the past, but it would be nice to have a txt file in the X86/Inputs directory that explains how the binary data was generated and how it's layed out.

Maybe you could even put this into the extract-all-sledtypes.txt comments.

lib/XRay/InstrumentationMap.cpp

104–108 ↗

(On Diff #111468)

It makes me sad that I couldn't find a good way to do this without duplicating the enum definitions.
Why can't the stdlib define something like:

template<underlying_t_value, enum_class_t>
struct is_enumerated {
    static const bool value = <whether there is a value in the enum class defined for underlying_t_value>;
};

Even exploring TMP necromancy didn't make it much better :(

[dberris]

Update comment in test on how the input is generated.

[dberris]

lib/XRay/InstrumentationMap.cpp

104–108 ↗

(On Diff #111468)

Yeah, unfortunately we're going to have to wait for static reflection in C++ to be able to "properly" do this.

llvm/trunk/include/llvm/XRay/InstrumentationMap.h

 /// Loads the instrumentation map from |Filename|. This auto-deduces the type of
 /// the instrumentation map.
 Expected<InstrumentationMap> loadInstrumentationMap(StringRef Filename);
 
 /// Represents an XRay instrumentation sled entry from an object file.
 struct SledEntry {
   /// Each entry here represents the kinds of supported instrumentation map
   /// entries.
-  enum class FunctionKinds { ENTRY, EXIT, TAIL };
+  enum class FunctionKinds { ENTRY, EXIT, TAIL, LOG_ARGS_ENTER, CUSTOM_EVENT };
 
   /// The address of the sled.
   uint64_t Address;
 
   /// The address of the function.
   uint64_t Function;
 
   /// The kind of sled.

 
 namespace yaml {
 
 template <> struct ScalarEnumerationTraits<xray::SledEntry::FunctionKinds> {
   static void enumeration(IO &IO, xray::SledEntry::FunctionKinds &Kind) {
     IO.enumCase(Kind, "function-enter", xray::SledEntry::FunctionKinds::ENTRY);
     IO.enumCase(Kind, "function-exit", xray::SledEntry::FunctionKinds::EXIT);
     IO.enumCase(Kind, "tail-exit", xray::SledEntry::FunctionKinds::TAIL);
+    IO.enumCase(Kind, "log-args-enter",
+                xray::SledEntry::FunctionKinds::LOG_ARGS_ENTER);
+    IO.enumCase(Kind, "custom-event",
+                xray::SledEntry::FunctionKinds::CUSTOM_EVENT);
   }
 };
 
 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);

llvm/trunk/lib/XRay/InstrumentationMap.cpp

for (; C != Contents.bytes_end(); C += ELF64SledEntrySize) {
     auto &Entry = Sleds.back();
     uint32_t OffsetPtr = 0;
     Entry.Address = Extractor.getU64(&OffsetPtr);
     Entry.Function = Extractor.getU64(&OffsetPtr);
     auto Kind = Extractor.getU8(&OffsetPtr);
     static constexpr SledEntry::FunctionKinds Kinds[] = {
         SledEntry::FunctionKinds::ENTRY, SledEntry::FunctionKinds::EXIT,
         SledEntry::FunctionKinds::TAIL,
-    };
+        SledEntry::FunctionKinds::LOG_ARGS_ENTER,
+        SledEntry::FunctionKinds::CUSTOM_EVENT};
     if (Kind >= sizeof(Kinds))
       return errorCodeToError(
           std::make_error_code(std::errc::executable_format_error));
     Entry.Kind = Kinds[Kind];
     Entry.AlwaysInstrument = Extractor.getU8(&OffsetPtr) != 0;
 
     // We do replicate the function id generation scheme implemented in the
     // XRay runtime.

llvm/trunk/test/tools/llvm-xray/X86/extract-all-sledtypes.txt

+# Test that we can extract all the sled types we know about. This is built with
+# a a file with functions always instrumented, and using the built-ins and
+# intrinsics supported by clang. Those are built with:
+#
+#   clang++ -c all-sleds.cc -o all-sleds.o -fpic -std=c++11 -fxray-instrument
+#
+# RUN: llvm-xray extract %S/Inputs/all-sleds.o -s | FileCheck %s
+# CHECK-DAG: {{kind:.function-enter}}
+# CHECK-DAG: {{kind:.function-exit}}
+# CHECK-DAG: {{kind:.custom-event}}
+# CHECK-DAG: {{kind:.log-args-enter}}