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 35 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 42 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 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 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> 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
