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