llvm/lib/XRay/InstrumentationMap.cpp

   1 //===- InstrumentationMap.cpp - XRay Instrumentation Map ------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // Implementation of the InstrumentationMap type for XRay sleds.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "llvm/XRay/InstrumentationMap.h"
  14 #include "llvm/ADT/DenseMap.h"
  15 #include "llvm/ADT/STLExtras.h"
  16 #include "llvm/ADT/StringRef.h"
  17 #include "llvm/ADT/Twine.h"
  18 #include "llvm/Object/Binary.h"
  19 #include "llvm/Object/ELFObjectFile.h"
  20 #include "llvm/Object/ObjectFile.h"
  21 #include "llvm/Object/RelocationResolver.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 "llvm/TargetParser/Triple.h"
  27 #include <algorithm>
  28 #include <cstddef>
  29 #include <cstdint>
  30 #include <system_error>
  31 #include <vector>
  32
  33 using namespace llvm;
  34 using namespace xray;
  35
  36 std::optional<int32_t> InstrumentationMap::getFunctionId(uint64_t Addr) const {
  37   auto I = FunctionIds.find(Addr);
  38   if (I != FunctionIds.end())
  39     return I->second;
  40   return std::nullopt;
  41 }
  42
  43 std::optional<uint64_t>
  44 InstrumentationMap::getFunctionAddr(int32_t FuncId) const {
  45   auto I = FunctionAddresses.find(FuncId);
  46   if (I != FunctionAddresses.end())
  47     return I->second;
  48   return std::nullopt;
  49 }
  50
  51 using RelocMap = DenseMap<uint64_t, uint64_t>;
  52
  53 static Error
  54 loadObj(StringRef Filename, object::OwningBinary<object::ObjectFile> &ObjFile,
  55         InstrumentationMap::SledContainer &Sleds,
  56         InstrumentationMap::FunctionAddressMap &FunctionAddresses,
  57         InstrumentationMap::FunctionAddressReverseMap &FunctionIds) {
  58   InstrumentationMap Map;
  59
  60   // Find the section named "xray_instr_map".
  61   if ((!ObjFile.getBinary()->isELF() && !ObjFile.getBinary()->isMachO()) ||
  62       !(ObjFile.getBinary()->getArch() == Triple::x86_64 ||
  63         ObjFile.getBinary()->getArch() == Triple::ppc64le ||
  64         ObjFile.getBinary()->getArch() == Triple::arm ||
  65         ObjFile.getBinary()->getArch() == Triple::aarch64))
  66     return make_error<StringError>(
  67         "File format not supported (only does ELF and Mach-O little endian "
  68         "64-bit).",
  69         std::make_error_code(std::errc::not_supported));
  70
  71   StringRef Contents = "";
  72   const auto &Sections = ObjFile.getBinary()->sections();
  73   uint64_t Address = 0;
  74   auto I = llvm::find_if(Sections, [&](object::SectionRef Section) {
  75     Expected<StringRef> NameOrErr = Section.getName();
  76     if (NameOrErr) {
  77       Address = Section.getAddress();
  78       return *NameOrErr == "xray_instr_map";
  79     }
  80     consumeError(NameOrErr.takeError());
  81     return false;
  82   });
  83
  84   if (I == Sections.end())
  85     return make_error<StringError>(
  86         "Failed to find XRay instrumentation map.",
  87         std::make_error_code(std::errc::executable_format_error));
  88
  89   if (Error E = I->getContents().moveInto(Contents))
  90     return E;
  91
  92   RelocMap Relocs;
  93   if (ObjFile.getBinary()->isELF()) {
  94     uint32_t RelativeRelocation = [](object::ObjectFile *ObjFile) {
  95       if (const auto *ELFObj = dyn_cast<object::ELF32LEObjectFile>(ObjFile))
  96         return ELFObj->getELFFile().getRelativeRelocationType();
  97       else if (const auto *ELFObj =
  98                    dyn_cast<object::ELF32BEObjectFile>(ObjFile))
  99         return ELFObj->getELFFile().getRelativeRelocationType();
 100       else if (const auto *ELFObj =
 101                    dyn_cast<object::ELF64LEObjectFile>(ObjFile))
 102         return ELFObj->getELFFile().getRelativeRelocationType();
 103       else if (const auto *ELFObj =
 104                    dyn_cast<object::ELF64BEObjectFile>(ObjFile))
 105         return ELFObj->getELFFile().getRelativeRelocationType();
 106       else
 107         return static_cast<uint32_t>(0);
 108     }(ObjFile.getBinary());
 109
 110     object::SupportsRelocation Supports;
 111     object::RelocationResolver Resolver;
 112     std::tie(Supports, Resolver) =
 113         object::getRelocationResolver(*ObjFile.getBinary());
 114
 115     for (const object::SectionRef &Section : Sections) {
 116       for (const object::RelocationRef &Reloc : Section.relocations()) {
 117         if (ObjFile.getBinary()->getArch() == Triple::arm) {
 118           if (Supports && Supports(Reloc.getType())) {
 119             Expected<uint64_t> ValueOrErr = Reloc.getSymbol()->getValue();
 120             if (!ValueOrErr)
 121               return ValueOrErr.takeError();
 122             Relocs.insert(
 123                 {Reloc.getOffset(),
 124                  object::resolveRelocation(Resolver, Reloc, *ValueOrErr, 0)});
 125           }
 126         } else if (Supports && Supports(Reloc.getType())) {
 127           auto AddendOrErr = object::ELFRelocationRef(Reloc).getAddend();
 128           auto A = AddendOrErr ? *AddendOrErr : 0;
 129           Expected<uint64_t> ValueOrErr = Reloc.getSymbol()->getValue();
 130           if (!ValueOrErr)
 131             // TODO: Test this error.
 132             return ValueOrErr.takeError();
 133           Relocs.insert(
 134               {Reloc.getOffset(),
 135                object::resolveRelocation(Resolver, Reloc, *ValueOrErr, A)});
 136         } else if (Reloc.getType() == RelativeRelocation) {
 137           if (auto AddendOrErr = object::ELFRelocationRef(Reloc).getAddend())
 138             Relocs.insert({Reloc.getOffset(), *AddendOrErr});
 139         }
 140       }
 141     }
 142   }
 143
 144   // Copy the instrumentation map data into the Sleds data structure.
 145   auto C = Contents.bytes_begin();
 146   bool Is32Bit = ObjFile.getBinary()->makeTriple().isArch32Bit();
 147   size_t ELFSledEntrySize = Is32Bit ? 16 : 32;
 148
 149   if ((C - Contents.bytes_end()) % ELFSledEntrySize != 0)
 150     return make_error<StringError>(
 151         Twine("Instrumentation map entries not evenly divisible by size of "
 152               "an XRay sled entry."),
 153         std::make_error_code(std::errc::executable_format_error));
 154
 155   auto RelocateOrElse = [&](uint64_t Offset, uint64_t Address) {
 156     if (!Address) {
 157       uint64_t A = I->getAddress() + C - Contents.bytes_begin() + Offset;
 158       RelocMap::const_iterator R = Relocs.find(A);
 159       if (R != Relocs.end())
 160         return R->second;
 161     }
 162     return Address;
 163   };
 164
 165   const int WordSize = Is32Bit ? 4 : 8;
 166   int32_t FuncId = 1;
 167   uint64_t CurFn = 0;
 168   for (; C != Contents.bytes_end(); C += ELFSledEntrySize) {
 169     DataExtractor Extractor(
 170         StringRef(reinterpret_cast<const char *>(C), ELFSledEntrySize), true,
 171         8);
 172     Sleds.push_back({});
 173     auto &Entry = Sleds.back();
 174     uint64_t OffsetPtr = 0;
 175     uint64_t AddrOff = OffsetPtr;
 176     if (Is32Bit)
 177       Entry.Address = RelocateOrElse(AddrOff, Extractor.getU32(&OffsetPtr));
 178     else
 179       Entry.Address = RelocateOrElse(AddrOff, Extractor.getU64(&OffsetPtr));
 180     uint64_t FuncOff = OffsetPtr;
 181     if (Is32Bit)
 182       Entry.Function = RelocateOrElse(FuncOff, Extractor.getU32(&OffsetPtr));
 183     else
 184       Entry.Function = RelocateOrElse(FuncOff, Extractor.getU64(&OffsetPtr));
 185     auto Kind = Extractor.getU8(&OffsetPtr);
 186     static constexpr SledEntry::FunctionKinds Kinds[] = {
 187         SledEntry::FunctionKinds::ENTRY, SledEntry::FunctionKinds::EXIT,
 188         SledEntry::FunctionKinds::TAIL,
 189         SledEntry::FunctionKinds::LOG_ARGS_ENTER,
 190         SledEntry::FunctionKinds::CUSTOM_EVENT};
 191     if (Kind >= std::size(Kinds))
 192       return errorCodeToError(
 193           std::make_error_code(std::errc::executable_format_error));
 194     Entry.Kind = Kinds[Kind];
 195     Entry.AlwaysInstrument = Extractor.getU8(&OffsetPtr) != 0;
 196     Entry.Version = Extractor.getU8(&OffsetPtr);
 197     if (Entry.Version >= 2) {
 198       Entry.Address += C - Contents.bytes_begin() + Address;
 199       Entry.Function += C - Contents.bytes_begin() + WordSize + Address;
 200     }
 201
 202     // We do replicate the function id generation scheme implemented in the
 203     // XRay runtime.
 204     // FIXME: Figure out how to keep this consistent with the XRay runtime.
 205     if (CurFn == 0) {
 206       CurFn = Entry.Function;
 207       FunctionAddresses[FuncId] = Entry.Function;
 208       FunctionIds[Entry.Function] = FuncId;
 209     }
 210     if (Entry.Function != CurFn) {
 211       ++FuncId;
 212       CurFn = Entry.Function;
 213       FunctionAddresses[FuncId] = Entry.Function;
 214       FunctionIds[Entry.Function] = FuncId;
 215     }
 216   }
 217   return Error::success();
 218 }
 219
 220 static Error
 221 loadYAML(sys::fs::file_t Fd, size_t FileSize, StringRef Filename,
 222          InstrumentationMap::SledContainer &Sleds,
 223          InstrumentationMap::FunctionAddressMap &FunctionAddresses,
 224          InstrumentationMap::FunctionAddressReverseMap &FunctionIds) {
 225   std::error_code EC;
 226   sys::fs::mapped_file_region MappedFile(
 227       Fd, sys::fs::mapped_file_region::mapmode::readonly, FileSize, 0, EC);
 228   sys::fs::closeFile(Fd);
 229   if (EC)
 230     return make_error<StringError>(
 231         Twine("Failed memory-mapping file '") + Filename + "'.", EC);
 232
 233   std::vector<YAMLXRaySledEntry> YAMLSleds;
 234   yaml::Input In(StringRef(MappedFile.data(), MappedFile.size()));
 235   In >> YAMLSleds;
 236   if (In.error())
 237     return make_error<StringError>(
 238         Twine("Failed loading YAML document from '") + Filename + "'.",
 239         In.error());
 240
 241   Sleds.reserve(YAMLSleds.size());
 242   for (const auto &Y : YAMLSleds) {
 243     FunctionAddresses[Y.FuncId] = Y.Function;
 244     FunctionIds[Y.Function] = Y.FuncId;
 245     Sleds.push_back(SledEntry{Y.Address, Y.Function, Y.Kind, Y.AlwaysInstrument,
 246                               Y.Version});
 247   }
 248   return Error::success();
 249 }
 250
 251 // FIXME: Create error types that encapsulate a bit more information than what
 252 // StringError instances contain.
 253 Expected<InstrumentationMap>
 254 llvm::xray::loadInstrumentationMap(StringRef Filename) {
 255   // At this point we assume the file is an object file -- and if that doesn't
 256   // work, we treat it as YAML.
 257   // FIXME: Extend to support non-ELF and non-x86_64 binaries.
 258
 259   InstrumentationMap Map;
 260   auto ObjectFileOrError = object::ObjectFile::createObjectFile(Filename);
 261   if (!ObjectFileOrError) {
 262     auto E = ObjectFileOrError.takeError();
 263     // We try to load it as YAML if the ELF load didn't work.
 264     Expected<sys::fs::file_t> FdOrErr =
 265         sys::fs::openNativeFileForRead(Filename);
 266     if (!FdOrErr) {
 267       // Report the ELF load error if YAML failed.
 268       consumeError(FdOrErr.takeError());
 269       return std::move(E);
 270     }
 271
 272     uint64_t FileSize;
 273     if (sys::fs::file_size(Filename, FileSize))
 274       return std::move(E);
 275
 276     // If the file is empty, we return the original error.
 277     if (FileSize == 0)
 278       return std::move(E);
 279
 280     // From this point on the errors will be only for the YAML parts, so we
 281     // consume the errors at this point.
 282     consumeError(std::move(E));
 283     if (auto E = loadYAML(*FdOrErr, FileSize, Filename, Map.Sleds,
 284                           Map.FunctionAddresses, Map.FunctionIds))
 285       return std::move(E);
 286   } else if (auto E = loadObj(Filename, *ObjectFileOrError, Map.Sleds,
 287                               Map.FunctionAddresses, Map.FunctionIds)) {
 288     return std::move(E);
 289   }
 290   return Map;
 291 }