LLVM 19.0.0git
InstrumentationMap.cpp
Go to the documentation of this file.
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
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"
23#include "llvm/Support/Error.h"
27#include <algorithm>
28#include <cstddef>
29#include <cstdint>
30#include <system_error>
31#include <vector>
32
33using namespace llvm;
34using namespace xray;
35
36std::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
43std::optional<uint64_t>
45 auto I = FunctionAddresses.find(FuncId);
46 if (I != FunctionAddresses.end())
47 return I->second;
48 return std::nullopt;
49}
50
52
53static Error
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::loongarch64 ||
64 ObjFile.getBinary()->getArch() == Triple::ppc64le ||
65 ObjFile.getBinary()->getArch() == Triple::arm ||
66 ObjFile.getBinary()->getArch() == Triple::aarch64))
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 else
108 return static_cast<uint32_t>(0);
109 }(ObjFile.getBinary());
110
113 std::tie(Supports, Resolver) =
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 else
180 Entry.Address = RelocateOrElse(AddrOff, Extractor.getU64(&OffsetPtr));
181 uint64_t FuncOff = OffsetPtr;
182 if (Is32Bit)
183 Entry.Function = RelocateOrElse(FuncOff, Extractor.getU32(&OffsetPtr));
184 else
185 Entry.Function = RelocateOrElse(FuncOff, Extractor.getU64(&OffsetPtr));
186 auto Kind = Extractor.getU8(&OffsetPtr);
187 static constexpr SledEntry::FunctionKinds Kinds[] = {
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 the
204 // 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 Error
222loadYAML(sys::fs::file_t Fd, size_t FileSize, StringRef Filename,
226 std::error_code EC;
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 what
253// StringError instances contain.
256 // At this point we assume the file is an object file -- and if that doesn't
257 // work, we treat it as YAML.
258 // FIXME: Extend to support non-ELF and non-x86_64 binaries.
259
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.
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 we
282 // 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}
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
This file defines the DenseMap class.
uint64_t Addr
static void getAddend(uint64_t &, const Elf_Rel_Impl< ELFT, false > &)
Definition: ELFObject.cpp:1626
static Error loadObj(StringRef Filename, object::OwningBinary< object::ObjectFile > &ObjFile, InstrumentationMap::SledContainer &Sleds, InstrumentationMap::FunctionAddressMap &FunctionAddresses, InstrumentationMap::FunctionAddressReverseMap &FunctionIds)
static Error loadYAML(sys::fs::file_t Fd, size_t FileSize, StringRef Filename, InstrumentationMap::SledContainer &Sleds, InstrumentationMap::FunctionAddressMap &FunctionAddresses, InstrumentationMap::FunctionAddressReverseMap &FunctionIds)
#define I(x, y, z)
Definition: MD5.cpp:58
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
Profile::FuncID FuncId
Definition: Profile.cpp:321
This file contains some templates that are useful if you are working with the STL at all.
uint32_t getU32(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint32_t value from *offset_ptr.
uint8_t getU8(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint8_t value from *offset_ptr.
uint64_t getU64(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint64_t value from *offset_ptr.
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:155
iterator end()
Definition: DenseMap.h:84
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:220
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:337
Tagged union holding either a T or a Error.
Definition: Error.h:481
Error takeError()
Take ownership of the stored error.
Definition: Error.h:608
Interface for looking up the initializer for a variable name, used by Init::resolveReferences.
Definition: Record.h:2213
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
const unsigned char * bytes_end() const
Definition: StringRef.h:118
const unsigned char * bytes_begin() const
Definition: StringRef.h:115
@ loongarch64
Definition: Triple.h:62
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
Expected< int64_t > getAddend() const
This class is the base class for all object file types.
Definition: ObjectFile.h:229
static Expected< OwningBinary< ObjectFile > > createObjectFile(StringRef ObjectPath)
Definition: ObjectFile.cpp:209
This is a value type class that represents a single relocation in the list of relocations in the obje...
Definition: ObjectFile.h:52
This is a value type class that represents a single section in the list of sections in the object fil...
Definition: ObjectFile.h:81
This class represents a memory mapped file.
Definition: FileSystem.h:1266
@ readonly
May only access map via const_data as read only.
Definition: FileSystem.h:1269
The InstrumentationMap represents the computed function id's and indicated function addresses from an...
std::unordered_map< int32_t, uint64_t > FunctionAddressMap
std::unordered_map< uint64_t, int32_t > FunctionAddressReverseMap
std::vector< SledEntry > SledContainer
std::optional< int32_t > getFunctionId(uint64_t Addr) const
Returns an XRay computed function id, provided a function address.
std::optional< uint64_t > getFunctionAddr(int32_t FuncId) const
Returns the function address for a function id.
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
uint64_t(*)(uint64_t Type, uint64_t Offset, uint64_t S, uint64_t LocData, int64_t Addend) RelocationResolver
bool(*)(uint64_t) SupportsRelocation
uint64_t resolveRelocation(RelocationResolver Resolver, const RelocationRef &R, uint64_t S, uint64_t LocData)
std::pair< SupportsRelocation, RelocationResolver > getRelocationResolver(const ObjectFile &Obj)
std::error_code closeFile(file_t &F)
Close the file object.
Expected< file_t > openNativeFileForRead(const Twine &Name, OpenFlags Flags=OF_None, SmallVectorImpl< char > *RealPath=nullptr)
Opens the file with the given name in a read-only mode, returning its open file descriptor.
std::error_code file_size(const Twine &Path, uint64_t &Result)
Get file size.
Definition: FileSystem.h:688
Expected< InstrumentationMap > loadInstrumentationMap(StringRef Filename)
Loads the instrumentation map from |Filename|.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1749
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
Definition: Error.cpp:111
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1069
Represents an XRay instrumentation sled entry from an object file.
FunctionKinds
Each entry here represents the kinds of supported instrumentation map entries.