• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===- InstrumentationMap.cpp - XRay Instrumentation Map ------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // Implementation of the InstrumentationMap type for XRay sleds.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/XRay/InstrumentationMap.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/ObjectFile.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 <algorithm>
27 #include <cstddef>
28 #include <cstdint>
29 #include <system_error>
30 #include <vector>
31 
32 using namespace llvm;
33 using namespace xray;
34 
getFunctionId(uint64_t Addr) const35 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 None;
40 }
41 
getFunctionAddr(int32_t FuncId) const42 Optional<uint64_t> InstrumentationMap::getFunctionAddr(int32_t FuncId) const {
43   auto I = FunctionAddresses.find(FuncId);
44   if (I != FunctionAddresses.end())
45     return I->second;
46   return None;
47 }
48 
49 static Error
loadELF64(StringRef Filename,object::OwningBinary<object::ObjectFile> & ObjFile,InstrumentationMap::SledContainer & Sleds,InstrumentationMap::FunctionAddressMap & FunctionAddresses,InstrumentationMap::FunctionAddressReverseMap & FunctionIds)50 loadELF64(StringRef Filename, object::OwningBinary<object::ObjectFile> &ObjFile,
51           InstrumentationMap::SledContainer &Sleds,
52           InstrumentationMap::FunctionAddressMap &FunctionAddresses,
53           InstrumentationMap::FunctionAddressReverseMap &FunctionIds) {
54   InstrumentationMap Map;
55 
56   // Find the section named "xray_instr_map".
57   if (!ObjFile.getBinary()->isELF() ||
58       !(ObjFile.getBinary()->getArch() == Triple::x86_64 ||
59         ObjFile.getBinary()->getArch() == Triple::ppc64le))
60     return make_error<StringError>(
61         "File format not supported (only does ELF little endian 64-bit).",
62         std::make_error_code(std::errc::not_supported));
63 
64   StringRef Contents = "";
65   const auto &Sections = ObjFile.getBinary()->sections();
66   auto I = llvm::find_if(Sections, [&](object::SectionRef Section) {
67     StringRef Name = "";
68     if (Section.getName(Name))
69       return false;
70     return Name == "xray_instr_map";
71   });
72 
73   if (I == Sections.end())
74     return make_error<StringError>(
75         "Failed to find XRay instrumentation map.",
76         std::make_error_code(std::errc::executable_format_error));
77 
78   if (I->getContents(Contents))
79     return errorCodeToError(
80         std::make_error_code(std::errc::executable_format_error));
81 
82   // Copy the instrumentation map data into the Sleds data structure.
83   auto C = Contents.bytes_begin();
84   static constexpr size_t ELF64SledEntrySize = 32;
85 
86   if ((C - Contents.bytes_end()) % ELF64SledEntrySize != 0)
87     return make_error<StringError>(
88         Twine("Instrumentation map entries not evenly divisible by size of "
89               "an XRay sled entry in ELF64."),
90         std::make_error_code(std::errc::executable_format_error));
91 
92   int32_t FuncId = 1;
93   uint64_t CurFn = 0;
94   for (; C != Contents.bytes_end(); C += ELF64SledEntrySize) {
95     DataExtractor Extractor(
96         StringRef(reinterpret_cast<const char *>(C), ELF64SledEntrySize), true,
97         8);
98     Sleds.push_back({});
99     auto &Entry = Sleds.back();
100     uint32_t OffsetPtr = 0;
101     Entry.Address = Extractor.getU64(&OffsetPtr);
102     Entry.Function = Extractor.getU64(&OffsetPtr);
103     auto Kind = Extractor.getU8(&OffsetPtr);
104     static constexpr SledEntry::FunctionKinds Kinds[] = {
105         SledEntry::FunctionKinds::ENTRY, SledEntry::FunctionKinds::EXIT,
106         SledEntry::FunctionKinds::TAIL,
107         SledEntry::FunctionKinds::LOG_ARGS_ENTER,
108         SledEntry::FunctionKinds::CUSTOM_EVENT};
109     if (Kind >= sizeof(Kinds))
110       return errorCodeToError(
111           std::make_error_code(std::errc::executable_format_error));
112     Entry.Kind = Kinds[Kind];
113     Entry.AlwaysInstrument = Extractor.getU8(&OffsetPtr) != 0;
114 
115     // We do replicate the function id generation scheme implemented in the
116     // XRay runtime.
117     // FIXME: Figure out how to keep this consistent with the XRay runtime.
118     if (CurFn == 0) {
119       CurFn = Entry.Function;
120       FunctionAddresses[FuncId] = Entry.Function;
121       FunctionIds[Entry.Function] = FuncId;
122     }
123     if (Entry.Function != CurFn) {
124       ++FuncId;
125       CurFn = Entry.Function;
126       FunctionAddresses[FuncId] = Entry.Function;
127       FunctionIds[Entry.Function] = FuncId;
128     }
129   }
130   return Error::success();
131 }
132 
133 static Error
loadYAML(int Fd,size_t FileSize,StringRef Filename,InstrumentationMap::SledContainer & Sleds,InstrumentationMap::FunctionAddressMap & FunctionAddresses,InstrumentationMap::FunctionAddressReverseMap & FunctionIds)134 loadYAML(int Fd, size_t FileSize, StringRef Filename,
135          InstrumentationMap::SledContainer &Sleds,
136          InstrumentationMap::FunctionAddressMap &FunctionAddresses,
137          InstrumentationMap::FunctionAddressReverseMap &FunctionIds) {
138   std::error_code EC;
139   sys::fs::mapped_file_region MappedFile(
140       Fd, sys::fs::mapped_file_region::mapmode::readonly, FileSize, 0, EC);
141   if (EC)
142     return make_error<StringError>(
143         Twine("Failed memory-mapping file '") + Filename + "'.", EC);
144 
145   std::vector<YAMLXRaySledEntry> YAMLSleds;
146   yaml::Input In(StringRef(MappedFile.data(), MappedFile.size()));
147   In >> YAMLSleds;
148   if (In.error())
149     return make_error<StringError>(
150         Twine("Failed loading YAML document from '") + Filename + "'.",
151         In.error());
152 
153   Sleds.reserve(YAMLSleds.size());
154   for (const auto &Y : YAMLSleds) {
155     FunctionAddresses[Y.FuncId] = Y.Function;
156     FunctionIds[Y.Function] = Y.FuncId;
157     Sleds.push_back(
158         SledEntry{Y.Address, Y.Function, Y.Kind, Y.AlwaysInstrument});
159   }
160   return Error::success();
161 }
162 
163 // FIXME: Create error types that encapsulate a bit more information than what
164 // StringError instances contain.
165 Expected<InstrumentationMap>
loadInstrumentationMap(StringRef Filename)166 llvm::xray::loadInstrumentationMap(StringRef Filename) {
167   // At this point we assume the file is an object file -- and if that doesn't
168   // work, we treat it as YAML.
169   // FIXME: Extend to support non-ELF and non-x86_64 binaries.
170 
171   InstrumentationMap Map;
172   auto ObjectFileOrError = object::ObjectFile::createObjectFile(Filename);
173   if (!ObjectFileOrError) {
174     auto E = ObjectFileOrError.takeError();
175     // We try to load it as YAML if the ELF load didn't work.
176     int Fd;
177     if (sys::fs::openFileForRead(Filename, Fd))
178       return std::move(E);
179 
180     uint64_t FileSize;
181     if (sys::fs::file_size(Filename, FileSize))
182       return std::move(E);
183 
184     // If the file is empty, we return the original error.
185     if (FileSize == 0)
186       return std::move(E);
187 
188     // From this point on the errors will be only for the YAML parts, so we
189     // consume the errors at this point.
190     consumeError(std::move(E));
191     if (auto E = loadYAML(Fd, FileSize, Filename, Map.Sleds,
192                           Map.FunctionAddresses, Map.FunctionIds))
193       return std::move(E);
194   } else if (auto E = loadELF64(Filename, *ObjectFileOrError, Map.Sleds,
195                                 Map.FunctionAddresses, Map.FunctionIds)) {
196     return std::move(E);
197   }
198   return Map;
199 }
200