blob: 42bfca36a20bc0fde9eb2b2d9b32de33cdb4bf09 [file] [log] [blame]
//===- InstrumentationMap.h - XRay Instrumentation Map ----------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Defines the interface for extracting the instrumentation map from an
// XRay-instrumented binary.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_XRAY_INSTRUMENTATION_MAP_H
#define LLVM_XRAY_INSTRUMENTATION_MAP_H
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/YAMLTraits.h"
#include <cstdint>
#include <unordered_map>
#include <vector>
namespace llvm {
namespace xray {
// Forward declare to make a friend.
class InstrumentationMap;
/// 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, 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.
FunctionKinds Kind;
/// Whether the sled was annotated to always be instrumented.
bool AlwaysInstrument;
};
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
/// associated with a particular object file.
///
class InstrumentationMap {
public:
using FunctionAddressMap = std::unordered_map<int32_t, uint64_t>;
using FunctionAddressReverseMap = std::unordered_map<uint64_t, int32_t>;
using SledContainer = std::vector<SledEntry>;
private:
SledContainer Sleds;
FunctionAddressMap FunctionAddresses;
FunctionAddressReverseMap FunctionIds;
friend Expected<InstrumentationMap> loadInstrumentationMap(StringRef);
public:
/// Provides a raw accessor to the unordered map of function addresses.
const FunctionAddressMap &getFunctionAddresses() { return FunctionAddresses; }
/// Returns an XRay computed function id, provided a function address.
Optional<int32_t> getFunctionId(uint64_t Addr) const;
/// Returns the function address for a function id.
Optional<uint64_t> getFunctionAddr(int32_t FuncId) const;
/// Provide read-only access to the entries of the instrumentation map.
const SledContainer &sleds() const { return Sleds; };
};
} // end namespace xray
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);
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