Home | History | Annotate | Download | only in XRay 
      1 //===- InstrumentationMap.h - XRay Instrumentation Map ----------*- C++ -*-===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // Defines the interface for extracting the instrumentation map from an
     11 // XRay-instrumented binary.
     12 //
     13 //===----------------------------------------------------------------------===//
     14 
     15 #ifndef LLVM_XRAY_INSTRUMENTATION_MAP_H
     16 #define LLVM_XRAY_INSTRUMENTATION_MAP_H
     17 
     18 #include "llvm/ADT/Optional.h"
     19 #include "llvm/ADT/StringRef.h"
     20 #include "llvm/Support/Error.h"
     21 #include "llvm/Support/YAMLTraits.h"
     22 #include <cstdint>
     23 #include <unordered_map>
     24 #include <vector>
     25 
     26 namespace llvm {
     27 
     28 namespace xray {
     29 
     30 // Forward declare to make a friend.
     31 class InstrumentationMap;
     32 
     33 /// Loads the instrumentation map from |Filename|. This auto-deduces the type of
     34 /// the instrumentation map.
     35 Expected<InstrumentationMap> loadInstrumentationMap(StringRef Filename);
     36 
     37 /// Represents an XRay instrumentation sled entry from an object file.
     38 struct SledEntry {
     39   /// Each entry here represents the kinds of supported instrumentation map
     40   /// entries.
     41   enum class FunctionKinds { ENTRY, EXIT, TAIL, LOG_ARGS_ENTER, CUSTOM_EVENT };
     42 
     43   /// The address of the sled.
     44   uint64_t Address;
     45 
     46   /// The address of the function.
     47   uint64_t Function;
     48 
     49   /// The kind of sled.
     50   FunctionKinds Kind;
     51 
     52   /// Whether the sled was annotated to always be instrumented.
     53   bool AlwaysInstrument;
     54 };
     55 
     56 struct YAMLXRaySledEntry {
     57   int32_t FuncId;
     58   yaml::Hex64 Address;
     59   yaml::Hex64 Function;
     60   SledEntry::FunctionKinds Kind;
     61   bool AlwaysInstrument;
     62   std::string FunctionName;
     63 };
     64 
     65 /// The InstrumentationMap represents the computed function id's and indicated
     66 /// function addresses from an object file (or a YAML file). This provides an
     67 /// interface to just the mapping between the function id, and the function
     68 /// address.
     69 ///
     70 /// We also provide raw access to the actual instrumentation map entries we find
     71 /// associated with a particular object file.
     72 ///
     73 class InstrumentationMap {
     74 public:
     75   using FunctionAddressMap = std::unordered_map<int32_t, uint64_t>;
     76   using FunctionAddressReverseMap = std::unordered_map<uint64_t, int32_t>;
     77   using SledContainer = std::vector<SledEntry>;
     78 
     79 private:
     80   SledContainer Sleds;
     81   FunctionAddressMap FunctionAddresses;
     82   FunctionAddressReverseMap FunctionIds;
     83 
     84   friend Expected<InstrumentationMap> loadInstrumentationMap(StringRef);
     85 
     86 public:
     87   /// Provides a raw accessor to the unordered map of function addresses.
     88   const FunctionAddressMap &getFunctionAddresses() { return FunctionAddresses; }
     89 
     90   /// Returns an XRay computed function id, provided a function address.
     91   Optional<int32_t> getFunctionId(uint64_t Addr) const;
     92 
     93   /// Returns the function address for a function id.
     94   Optional<uint64_t> getFunctionAddr(int32_t FuncId) const;
     95 
     96   /// Provide read-only access to the entries of the instrumentation map.
     97   const SledContainer &sleds() const { return Sleds; };
     98 };
     99 
    100 } // end namespace xray
    101 
    102 namespace yaml {
    103 
    104 template <> struct ScalarEnumerationTraits<xray::SledEntry::FunctionKinds> {
    105   static void enumeration(IO &IO, xray::SledEntry::FunctionKinds &Kind) {
    106     IO.enumCase(Kind, "function-enter", xray::SledEntry::FunctionKinds::ENTRY);
    107     IO.enumCase(Kind, "function-exit", xray::SledEntry::FunctionKinds::EXIT);
    108     IO.enumCase(Kind, "tail-exit", xray::SledEntry::FunctionKinds::TAIL);
    109     IO.enumCase(Kind, "log-args-enter",
    110                 xray::SledEntry::FunctionKinds::LOG_ARGS_ENTER);
    111     IO.enumCase(Kind, "custom-event",
    112                 xray::SledEntry::FunctionKinds::CUSTOM_EVENT);
    113   }
    114 };
    115 
    116 template <> struct MappingTraits<xray::YAMLXRaySledEntry> {
    117   static void mapping(IO &IO, xray::YAMLXRaySledEntry &Entry) {
    118     IO.mapRequired("id", Entry.FuncId);
    119     IO.mapRequired("address", Entry.Address);
    120     IO.mapRequired("function", Entry.Function);
    121     IO.mapRequired("kind", Entry.Kind);
    122     IO.mapRequired("always-instrument", Entry.AlwaysInstrument);
    123     IO.mapOptional("function-name", Entry.FunctionName);
    124   }
    125 
    126   static constexpr bool flow = true;
    127 };
    128 
    129 } // end namespace yaml
    130 
    131 } // end namespace llvm
    132 
    133 LLVM_YAML_IS_SEQUENCE_VECTOR(xray::YAMLXRaySledEntry)
    134 
    135 #endif // LLVM_XRAY_INSTRUMENTATION_MAP_H
    136