1 //===- InstrumentationMap.cpp - XRay Instrumentation Map ------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Implementation of the InstrumentationMap type for XRay sleds.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/XRay/InstrumentationMap.h"
15 #include "llvm/ADT/DenseMap.h"
16 #include "llvm/ADT/None.h"
17 #include "llvm/ADT/STLExtras.h"
18 #include "llvm/ADT/StringRef.h"
19 #include "llvm/ADT/Triple.h"
20 #include "llvm/ADT/Twine.h"
21 #include "llvm/Object/Binary.h"
22 #include "llvm/Object/ELFObjectFile.h"
23 #include "llvm/Object/ObjectFile.h"
24 #include "llvm/Support/DataExtractor.h"
25 #include "llvm/Support/Error.h"
26 #include "llvm/Support/FileSystem.h"
27 #include "llvm/Support/YAMLTraits.h"
31 #include <system_error>
37 Optional<int32_t> InstrumentationMap::getFunctionId(uint64_t Addr) const {
38 auto I = FunctionIds.find(Addr);
39 if (I != FunctionIds.end())
44 Optional<uint64_t> InstrumentationMap::getFunctionAddr(int32_t FuncId) const {
45 auto I = FunctionAddresses.find(FuncId);
46 if (I != FunctionAddresses.end())
51 using RelocMap = DenseMap<uint64_t, uint64_t>;
54 loadObj(StringRef Filename, object::OwningBinary<object::ObjectFile> &ObjFile,
55 InstrumentationMap::SledContainer &Sleds,
56 InstrumentationMap::FunctionAddressMap &FunctionAddresses,
57 InstrumentationMap::FunctionAddressReverseMap &FunctionIds) {
58 InstrumentationMap Map;
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 return make_error<StringError>(
65 "File format not supported (only does ELF and Mach-O little endian 64-bit).",
66 std::make_error_code(std::errc::not_supported));
68 StringRef Contents = "";
69 const auto &Sections = ObjFile.getBinary()->sections();
70 auto I = llvm::find_if(Sections, [&](object::SectionRef Section) {
72 if (Section.getName(Name))
74 return Name == "xray_instr_map";
77 if (I == Sections.end())
78 return make_error<StringError>(
79 "Failed to find XRay instrumentation map.",
80 std::make_error_code(std::errc::executable_format_error));
82 if (I->getContents(Contents))
83 return errorCodeToError(
84 std::make_error_code(std::errc::executable_format_error));
87 if (ObjFile.getBinary()->isELF()) {
88 uint32_t RelativeRelocation = [](object::ObjectFile *ObjFile) {
89 if (const auto *ELFObj = dyn_cast<object::ELF32LEObjectFile>(ObjFile))
90 return ELFObj->getELFFile()->getRelativeRelocationType();
91 else if (const auto *ELFObj = dyn_cast<object::ELF32BEObjectFile>(ObjFile))
92 return ELFObj->getELFFile()->getRelativeRelocationType();
93 else if (const auto *ELFObj = dyn_cast<object::ELF64LEObjectFile>(ObjFile))
94 return ELFObj->getELFFile()->getRelativeRelocationType();
95 else if (const auto *ELFObj = dyn_cast<object::ELF64BEObjectFile>(ObjFile))
96 return ELFObj->getELFFile()->getRelativeRelocationType();
98 return static_cast<uint32_t>(0);
99 }(ObjFile.getBinary());
101 for (const object::SectionRef &Section : Sections) {
102 for (const object::RelocationRef &Reloc : Section.relocations()) {
103 if (Reloc.getType() != RelativeRelocation)
105 if (auto AddendOrErr = object::ELFRelocationRef(Reloc).getAddend())
106 Relocs.insert({Reloc.getOffset(), *AddendOrErr});
111 // Copy the instrumentation map data into the Sleds data structure.
112 auto C = Contents.bytes_begin();
113 static constexpr size_t ELF64SledEntrySize = 32;
115 if ((C - Contents.bytes_end()) % ELF64SledEntrySize != 0)
116 return make_error<StringError>(
117 Twine("Instrumentation map entries not evenly divisible by size of "
118 "an XRay sled entry in ELF64."),
119 std::make_error_code(std::errc::executable_format_error));
121 auto RelocateOrElse = [&](uint32_t Offset, uint64_t Address) {
123 uint64_t A = I->getAddress() + C - Contents.bytes_begin() + Offset;
124 RelocMap::const_iterator R = Relocs.find(A);
125 if (R != Relocs.end())
133 for (; C != Contents.bytes_end(); C += ELF64SledEntrySize) {
134 DataExtractor Extractor(
135 StringRef(reinterpret_cast<const char *>(C), ELF64SledEntrySize), true,
138 auto &Entry = Sleds.back();
139 uint32_t OffsetPtr = 0;
140 uint32_t AddrOff = OffsetPtr;
141 Entry.Address = RelocateOrElse(AddrOff, Extractor.getU64(&OffsetPtr));
142 uint32_t FuncOff = OffsetPtr;
143 Entry.Function = RelocateOrElse(FuncOff, Extractor.getU64(&OffsetPtr));
144 auto Kind = Extractor.getU8(&OffsetPtr);
145 static constexpr SledEntry::FunctionKinds Kinds[] = {
146 SledEntry::FunctionKinds::ENTRY, SledEntry::FunctionKinds::EXIT,
147 SledEntry::FunctionKinds::TAIL,
148 SledEntry::FunctionKinds::LOG_ARGS_ENTER,
149 SledEntry::FunctionKinds::CUSTOM_EVENT};
150 if (Kind >= sizeof(Kinds))
151 return errorCodeToError(
152 std::make_error_code(std::errc::executable_format_error));
153 Entry.Kind = Kinds[Kind];
154 Entry.AlwaysInstrument = Extractor.getU8(&OffsetPtr) != 0;
156 // We do replicate the function id generation scheme implemented in the
158 // FIXME: Figure out how to keep this consistent with the XRay runtime.
160 CurFn = Entry.Function;
161 FunctionAddresses[FuncId] = Entry.Function;
162 FunctionIds[Entry.Function] = FuncId;
164 if (Entry.Function != CurFn) {
166 CurFn = Entry.Function;
167 FunctionAddresses[FuncId] = Entry.Function;
168 FunctionIds[Entry.Function] = FuncId;
171 return Error::success();
175 loadYAML(int Fd, size_t FileSize, StringRef Filename,
176 InstrumentationMap::SledContainer &Sleds,
177 InstrumentationMap::FunctionAddressMap &FunctionAddresses,
178 InstrumentationMap::FunctionAddressReverseMap &FunctionIds) {
180 sys::fs::mapped_file_region MappedFile(
181 Fd, sys::fs::mapped_file_region::mapmode::readonly, FileSize, 0, EC);
183 return make_error<StringError>(
184 Twine("Failed memory-mapping file '") + Filename + "'.", EC);
186 std::vector<YAMLXRaySledEntry> YAMLSleds;
187 yaml::Input In(StringRef(MappedFile.data(), MappedFile.size()));
190 return make_error<StringError>(
191 Twine("Failed loading YAML document from '") + Filename + "'.",
194 Sleds.reserve(YAMLSleds.size());
195 for (const auto &Y : YAMLSleds) {
196 FunctionAddresses[Y.FuncId] = Y.Function;
197 FunctionIds[Y.Function] = Y.FuncId;
199 SledEntry{Y.Address, Y.Function, Y.Kind, Y.AlwaysInstrument});
201 return Error::success();
204 // FIXME: Create error types that encapsulate a bit more information than what
205 // StringError instances contain.
206 Expected<InstrumentationMap>
207 llvm::xray::loadInstrumentationMap(StringRef Filename) {
208 // At this point we assume the file is an object file -- and if that doesn't
209 // work, we treat it as YAML.
210 // FIXME: Extend to support non-ELF and non-x86_64 binaries.
212 InstrumentationMap Map;
213 auto ObjectFileOrError = object::ObjectFile::createObjectFile(Filename);
214 if (!ObjectFileOrError) {
215 auto E = ObjectFileOrError.takeError();
216 // We try to load it as YAML if the ELF load didn't work.
218 if (sys::fs::openFileForRead(Filename, Fd))
222 if (sys::fs::file_size(Filename, FileSize))
225 // If the file is empty, we return the original error.
229 // From this point on the errors will be only for the YAML parts, so we
230 // consume the errors at this point.
231 consumeError(std::move(E));
232 if (auto E = loadYAML(Fd, FileSize, Filename, Map.Sleds,
233 Map.FunctionAddresses, Map.FunctionIds))
235 } else if (auto E = loadObj(Filename, *ObjectFileOrError, Map.Sleds,
236 Map.FunctionAddresses, Map.FunctionIds)) {