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