contrib/llvm/lib/XRay/InstrumentationMap.cpp

   1 //===- InstrumentationMap.cpp - XRay Instrumentation Map ------------------===//
   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 // Implementation of the InstrumentationMap type for XRay sleds.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/XRay/InstrumentationMap.h"
  15 #include "llvm/ADT/None.h"
  16 #include "llvm/ADT/STLExtras.h"
  17 #include "llvm/ADT/StringRef.h"
  18 #include "llvm/ADT/Triple.h"
  19 #include "llvm/ADT/Twine.h"
  20 #include "llvm/Object/Binary.h"
  21 #include "llvm/Object/ObjectFile.h"
  22 #include "llvm/Support/DataExtractor.h"
  23 #include "llvm/Support/Error.h"
  24 #include "llvm/Support/FileSystem.h"
  25 #include "llvm/Support/YAMLTraits.h"
  26 #include <algorithm>
  27 #include <cstddef>
  28 #include <cstdint>
  29 #include <system_error>
  30 #include <vector>
  31
  32 using namespace llvm;
  33 using namespace xray;
  34
  35 Optional<int32_t> InstrumentationMap::getFunctionId(uint64_t Addr) const {
  36   auto I = FunctionIds.find(Addr);
  37   if (I != FunctionIds.end())
  38     return I->second;
  39   return None;
  40 }
  41
  42 Optional<uint64_t> InstrumentationMap::getFunctionAddr(int32_t FuncId) const {
  43   auto I = FunctionAddresses.find(FuncId);
  44   if (I != FunctionAddresses.end())
  45     return I->second;
  46   return None;
  47 }
  48
  49 static Error
  50 loadELF64(StringRef Filename, object::OwningBinary<object::ObjectFile> &ObjFile,
  51           InstrumentationMap::SledContainer &Sleds,
  52           InstrumentationMap::FunctionAddressMap &FunctionAddresses,
  53           InstrumentationMap::FunctionAddressReverseMap &FunctionIds) {
  54   InstrumentationMap Map;
  55
  56   // Find the section named "xray_instr_map".
  57   if (!ObjFile.getBinary()->isELF() ||
  58       !(ObjFile.getBinary()->getArch() == Triple::x86_64 ||
  59         ObjFile.getBinary()->getArch() == Triple::ppc64le))
  60     return make_error<StringError>(
  61         "File format not supported (only does ELF little endian 64-bit).",
  62         std::make_error_code(std::errc::not_supported));
  63
  64   StringRef Contents = "";
  65   const auto &Sections = ObjFile.getBinary()->sections();
  66   auto I = llvm::find_if(Sections, [&](object::SectionRef Section) {
  67     StringRef Name = "";
  68     if (Section.getName(Name))
  69       return false;
  70     return Name == "xray_instr_map";
  71   });
  72
  73   if (I == Sections.end())
  74     return make_error<StringError>(
  75         "Failed to find XRay instrumentation map.",
  76         std::make_error_code(std::errc::executable_format_error));
  77
  78   if (I->getContents(Contents))
  79     return errorCodeToError(
  80         std::make_error_code(std::errc::executable_format_error));
  81
  82   // Copy the instrumentation map data into the Sleds data structure.
  83   auto C = Contents.bytes_begin();
  84   static constexpr size_t ELF64SledEntrySize = 32;
  85
  86   if ((C - Contents.bytes_end()) % ELF64SledEntrySize != 0)
  87     return make_error<StringError>(
  88         Twine("Instrumentation map entries not evenly divisible by size of "
  89               "an XRay sled entry in ELF64."),
  90         std::make_error_code(std::errc::executable_format_error));
  91
  92   int32_t FuncId = 1;
  93   uint64_t CurFn = 0;
  94   for (; C != Contents.bytes_end(); C += ELF64SledEntrySize) {
  95     DataExtractor Extractor(
  96         StringRef(reinterpret_cast<const char *>(C), ELF64SledEntrySize), true,
  97         8);
  98     Sleds.push_back({});
  99     auto &Entry = Sleds.back();
 100     uint32_t OffsetPtr = 0;
 101     Entry.Address = Extractor.getU64(&OffsetPtr);
 102     Entry.Function = Extractor.getU64(&OffsetPtr);
 103     auto Kind = Extractor.getU8(&OffsetPtr);
 104     static constexpr SledEntry::FunctionKinds Kinds[] = {
 105         SledEntry::FunctionKinds::ENTRY, SledEntry::FunctionKinds::EXIT,
 106         SledEntry::FunctionKinds::TAIL,
 107         SledEntry::FunctionKinds::LOG_ARGS_ENTER,
 108         SledEntry::FunctionKinds::CUSTOM_EVENT};
 109     if (Kind >= sizeof(Kinds))
 110       return errorCodeToError(
 111           std::make_error_code(std::errc::executable_format_error));
 112     Entry.Kind = Kinds[Kind];
 113     Entry.AlwaysInstrument = Extractor.getU8(&OffsetPtr) != 0;
 114
 115     // We do replicate the function id generation scheme implemented in the
 116     // XRay runtime.
 117     // FIXME: Figure out how to keep this consistent with the XRay runtime.
 118     if (CurFn == 0) {
 119       CurFn = Entry.Function;
 120       FunctionAddresses[FuncId] = Entry.Function;
 121       FunctionIds[Entry.Function] = FuncId;
 122     }
 123     if (Entry.Function != CurFn) {
 124       ++FuncId;
 125       CurFn = Entry.Function;
 126       FunctionAddresses[FuncId] = Entry.Function;
 127       FunctionIds[Entry.Function] = FuncId;
 128     }
 129   }
 130   return Error::success();
 131 }
 132
 133 static Error
 134 loadYAML(int Fd, size_t FileSize, StringRef Filename,
 135          InstrumentationMap::SledContainer &Sleds,
 136          InstrumentationMap::FunctionAddressMap &FunctionAddresses,
 137          InstrumentationMap::FunctionAddressReverseMap &FunctionIds) {
 138   std::error_code EC;
 139   sys::fs::mapped_file_region MappedFile(
 140       Fd, sys::fs::mapped_file_region::mapmode::readonly, FileSize, 0, EC);
 141   if (EC)
 142     return make_error<StringError>(
 143         Twine("Failed memory-mapping file '") + Filename + "'.", EC);
 144
 145   std::vector<YAMLXRaySledEntry> YAMLSleds;
 146   yaml::Input In(StringRef(MappedFile.data(), MappedFile.size()));
 147   In >> YAMLSleds;
 148   if (In.error())
 149     return make_error<StringError>(
 150         Twine("Failed loading YAML document from '") + Filename + "'.",
 151         In.error());
 152
 153   Sleds.reserve(YAMLSleds.size());
 154   for (const auto &Y : YAMLSleds) {
 155     FunctionAddresses[Y.FuncId] = Y.Function;
 156     FunctionIds[Y.Function] = Y.FuncId;
 157     Sleds.push_back(
 158         SledEntry{Y.Address, Y.Function, Y.Kind, Y.AlwaysInstrument});
 159   }
 160   return Error::success();
 161 }
 162
 163 // FIXME: Create error types that encapsulate a bit more information than what
 164 // StringError instances contain.
 165 Expected<InstrumentationMap>
 166 llvm::xray::loadInstrumentationMap(StringRef Filename) {
 167   // At this point we assume the file is an object file -- and if that doesn't
 168   // work, we treat it as YAML.
 169   // FIXME: Extend to support non-ELF and non-x86_64 binaries.
 170
 171   InstrumentationMap Map;
 172   auto ObjectFileOrError = object::ObjectFile::createObjectFile(Filename);
 173   if (!ObjectFileOrError) {
 174     auto E = ObjectFileOrError.takeError();
 175     // We try to load it as YAML if the ELF load didn't work.
 176     int Fd;
 177     if (sys::fs::openFileForRead(Filename, Fd))
 178       return std::move(E);
 179
 180     uint64_t FileSize;
 181     if (sys::fs::file_size(Filename, FileSize))
 182       return std::move(E);
 183
 184     // If the file is empty, we return the original error.
 185     if (FileSize == 0)
 186       return std::move(E);
 187
 188     // From this point on the errors will be only for the YAML parts, so we
 189     // consume the errors at this point.
 190     consumeError(std::move(E));
 191     if (auto E = loadYAML(Fd, FileSize, Filename, Map.Sleds,
 192                           Map.FunctionAddresses, Map.FunctionIds))
 193       return std::move(E);
 194   } else if (auto E = loadELF64(Filename, *ObjectFileOrError, Map.Sleds,
 195                                 Map.FunctionAddresses, Map.FunctionIds)) {
 196     return std::move(E);
 197   }
 198   return Map;
 199 }