1 //===- FunctionInfo.cpp ---------------------------------------------------===// 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 #include "llvm/DebugInfo/GSYM/FunctionInfo.h" 10 #include "llvm/DebugInfo/GSYM/FileWriter.h" 11 #include "llvm/DebugInfo/GSYM/GsymReader.h" 12 #include "llvm/DebugInfo/GSYM/LineTable.h" 13 #include "llvm/DebugInfo/GSYM/InlineInfo.h" 14 #include "llvm/Support/DataExtractor.h" 15 #include <optional> 16 17 using namespace llvm; 18 using namespace gsym; 19 20 /// FunctionInfo information type that is used to encode the optional data 21 /// that is associated with a FunctionInfo object. 22 enum InfoType : uint32_t { 23 EndOfList = 0u, 24 LineTableInfo = 1u, 25 InlineInfo = 2u 26 }; 27 28 raw_ostream &llvm::gsym::operator<<(raw_ostream &OS, const FunctionInfo &FI) { 29 OS << FI.Range << ": " << "Name=" << HEX32(FI.Name) << '\n'; 30 if (FI.OptLineTable) 31 OS << FI.OptLineTable << '\n'; 32 if (FI.Inline) 33 OS << FI.Inline << '\n'; 34 return OS; 35 } 36 37 llvm::Expected<FunctionInfo> FunctionInfo::decode(DataExtractor &Data, 38 uint64_t BaseAddr) { 39 FunctionInfo FI; 40 uint64_t Offset = 0; 41 if (!Data.isValidOffsetForDataOfSize(Offset, 4)) 42 return createStringError(std::errc::io_error, 43 "0x%8.8" PRIx64 ": missing FunctionInfo Size", Offset); 44 FI.Range = {BaseAddr, BaseAddr + Data.getU32(&Offset)}; 45 if (!Data.isValidOffsetForDataOfSize(Offset, 4)) 46 return createStringError(std::errc::io_error, 47 "0x%8.8" PRIx64 ": missing FunctionInfo Name", Offset); 48 FI.Name = Data.getU32(&Offset); 49 if (FI.Name == 0) 50 return createStringError(std::errc::io_error, 51 "0x%8.8" PRIx64 ": invalid FunctionInfo Name value 0x%8.8x", 52 Offset - 4, FI.Name); 53 bool Done = false; 54 while (!Done) { 55 if (!Data.isValidOffsetForDataOfSize(Offset, 4)) 56 return createStringError(std::errc::io_error, 57 "0x%8.8" PRIx64 ": missing FunctionInfo InfoType value", Offset); 58 const uint32_t IT = Data.getU32(&Offset); 59 if (!Data.isValidOffsetForDataOfSize(Offset, 4)) 60 return createStringError(std::errc::io_error, 61 "0x%8.8" PRIx64 ": missing FunctionInfo InfoType length", Offset); 62 const uint32_t InfoLength = Data.getU32(&Offset); 63 if (!Data.isValidOffsetForDataOfSize(Offset, InfoLength)) 64 return createStringError(std::errc::io_error, 65 "0x%8.8" PRIx64 ": missing FunctionInfo data for InfoType %u", 66 Offset, IT); 67 DataExtractor InfoData(Data.getData().substr(Offset, InfoLength), 68 Data.isLittleEndian(), 69 Data.getAddressSize()); 70 switch (IT) { 71 case InfoType::EndOfList: 72 Done = true; 73 break; 74 75 case InfoType::LineTableInfo: 76 if (Expected<LineTable> LT = LineTable::decode(InfoData, BaseAddr)) 77 FI.OptLineTable = std::move(LT.get()); 78 else 79 return LT.takeError(); 80 break; 81 82 case InfoType::InlineInfo: 83 if (Expected<InlineInfo> II = InlineInfo::decode(InfoData, BaseAddr)) 84 FI.Inline = std::move(II.get()); 85 else 86 return II.takeError(); 87 break; 88 89 default: 90 return createStringError(std::errc::io_error, 91 "0x%8.8" PRIx64 ": unsupported InfoType %u", 92 Offset-8, IT); 93 } 94 Offset += InfoLength; 95 } 96 return std::move(FI); 97 } 98 99 uint64_t FunctionInfo::cacheEncoding() { 100 EncodingCache.clear(); 101 if (!isValid()) 102 return 0; 103 raw_svector_ostream OutStrm(EncodingCache); 104 FileWriter FW(OutStrm, llvm::endianness::native); 105 llvm::Expected<uint64_t> Result = encode(FW); 106 if (!Result) { 107 EncodingCache.clear(); 108 consumeError(Result.takeError()); 109 return 0; 110 } 111 return EncodingCache.size(); 112 } 113 114 llvm::Expected<uint64_t> FunctionInfo::encode(FileWriter &Out) const { 115 if (!isValid()) 116 return createStringError(std::errc::invalid_argument, 117 "attempted to encode invalid FunctionInfo object"); 118 // Align FunctionInfo data to a 4 byte alignment. 119 Out.alignTo(4); 120 const uint64_t FuncInfoOffset = Out.tell(); 121 // Check if we have already encoded this function info into EncodingCache. 122 // This will be non empty when creating segmented GSYM files as we need to 123 // precompute exactly how big FunctionInfo objects encode into so we can 124 // accurately make segments of a specific size. 125 if (!EncodingCache.empty() && 126 llvm::endianness::native == Out.getByteOrder()) { 127 // We already encoded this object, just write out the bytes. 128 Out.writeData(llvm::ArrayRef<uint8_t>((const uint8_t *)EncodingCache.data(), 129 EncodingCache.size())); 130 return FuncInfoOffset; 131 } 132 // Write the size in bytes of this function as a uint32_t. This can be zero 133 // if we just have a symbol from a symbol table and that symbol has no size. 134 Out.writeU32(size()); 135 // Write the name of this function as a uint32_t string table offset. 136 Out.writeU32(Name); 137 138 if (OptLineTable) { 139 Out.writeU32(InfoType::LineTableInfo); 140 // Write a uint32_t length as zero for now, we will fix this up after 141 // writing the LineTable out with the number of bytes that were written. 142 Out.writeU32(0); 143 const auto StartOffset = Out.tell(); 144 llvm::Error err = OptLineTable->encode(Out, Range.start()); 145 if (err) 146 return std::move(err); 147 const auto Length = Out.tell() - StartOffset; 148 if (Length > UINT32_MAX) 149 return createStringError(std::errc::invalid_argument, 150 "LineTable length is greater than UINT32_MAX"); 151 // Fixup the size of the LineTable data with the correct size. 152 Out.fixup32(static_cast<uint32_t>(Length), StartOffset - 4); 153 } 154 155 // Write out the inline function info if we have any and if it is valid. 156 if (Inline) { 157 Out.writeU32(InfoType::InlineInfo); 158 // Write a uint32_t length as zero for now, we will fix this up after 159 // writing the LineTable out with the number of bytes that were written. 160 Out.writeU32(0); 161 const auto StartOffset = Out.tell(); 162 llvm::Error err = Inline->encode(Out, Range.start()); 163 if (err) 164 return std::move(err); 165 const auto Length = Out.tell() - StartOffset; 166 if (Length > UINT32_MAX) 167 return createStringError(std::errc::invalid_argument, 168 "InlineInfo length is greater than UINT32_MAX"); 169 // Fixup the size of the InlineInfo data with the correct size. 170 Out.fixup32(static_cast<uint32_t>(Length), StartOffset - 4); 171 } 172 173 // Terminate the data chunks with and end of list with zero size 174 Out.writeU32(InfoType::EndOfList); 175 Out.writeU32(0); 176 return FuncInfoOffset; 177 } 178 179 180 llvm::Expected<LookupResult> FunctionInfo::lookup(DataExtractor &Data, 181 const GsymReader &GR, 182 uint64_t FuncAddr, 183 uint64_t Addr) { 184 LookupResult LR; 185 LR.LookupAddr = Addr; 186 uint64_t Offset = 0; 187 LR.FuncRange = {FuncAddr, FuncAddr + Data.getU32(&Offset)}; 188 uint32_t NameOffset = Data.getU32(&Offset); 189 // The "lookup" functions doesn't report errors as accurately as the "decode" 190 // function as it is meant to be fast. For more accurage errors we could call 191 // "decode". 192 if (!Data.isValidOffset(Offset)) 193 return createStringError(std::errc::io_error, 194 "FunctionInfo data is truncated"); 195 // This function will be called with the result of a binary search of the 196 // address table, we must still make sure the address does not fall into a 197 // gap between functions are after the last function. 198 if (LR.FuncRange.size() > 0 && !LR.FuncRange.contains(Addr)) 199 return createStringError(std::errc::io_error, 200 "address 0x%" PRIx64 " is not in GSYM", Addr); 201 202 if (NameOffset == 0) 203 return createStringError(std::errc::io_error, 204 "0x%8.8" PRIx64 ": invalid FunctionInfo Name value 0x00000000", 205 Offset - 4); 206 LR.FuncName = GR.getString(NameOffset); 207 bool Done = false; 208 std::optional<LineEntry> LineEntry; 209 std::optional<DataExtractor> InlineInfoData; 210 while (!Done) { 211 if (!Data.isValidOffsetForDataOfSize(Offset, 8)) 212 return createStringError(std::errc::io_error, 213 "FunctionInfo data is truncated"); 214 const uint32_t IT = Data.getU32(&Offset); 215 const uint32_t InfoLength = Data.getU32(&Offset); 216 const StringRef InfoBytes = Data.getData().substr(Offset, InfoLength); 217 if (InfoLength != InfoBytes.size()) 218 return createStringError(std::errc::io_error, 219 "FunctionInfo data is truncated"); 220 DataExtractor InfoData(InfoBytes, Data.isLittleEndian(), 221 Data.getAddressSize()); 222 switch (IT) { 223 case InfoType::EndOfList: 224 Done = true; 225 break; 226 227 case InfoType::LineTableInfo: 228 if (auto ExpectedLE = LineTable::lookup(InfoData, FuncAddr, Addr)) 229 LineEntry = ExpectedLE.get(); 230 else 231 return ExpectedLE.takeError(); 232 break; 233 234 case InfoType::InlineInfo: 235 // We will parse the inline info after our line table, but only if 236 // we have a line entry. 237 InlineInfoData = InfoData; 238 break; 239 240 default: 241 break; 242 } 243 Offset += InfoLength; 244 } 245 246 if (!LineEntry) { 247 // We don't have a valid line entry for our address, fill in our source 248 // location as best we can and return. 249 SourceLocation SrcLoc; 250 SrcLoc.Name = LR.FuncName; 251 SrcLoc.Offset = Addr - FuncAddr; 252 LR.Locations.push_back(SrcLoc); 253 return LR; 254 } 255 256 std::optional<FileEntry> LineEntryFile = GR.getFile(LineEntry->File); 257 if (!LineEntryFile) 258 return createStringError(std::errc::invalid_argument, 259 "failed to extract file[%" PRIu32 "]", 260 LineEntry->File); 261 262 SourceLocation SrcLoc; 263 SrcLoc.Name = LR.FuncName; 264 SrcLoc.Offset = Addr - FuncAddr; 265 SrcLoc.Dir = GR.getString(LineEntryFile->Dir); 266 SrcLoc.Base = GR.getString(LineEntryFile->Base); 267 SrcLoc.Line = LineEntry->Line; 268 LR.Locations.push_back(SrcLoc); 269 // If we don't have inline information, we are done. 270 if (!InlineInfoData) 271 return LR; 272 // We have inline information. Try to augment the lookup result with this 273 // data. 274 llvm::Error Err = InlineInfo::lookup(GR, *InlineInfoData, FuncAddr, Addr, 275 LR.Locations); 276 if (Err) 277 return std::move(Err); 278 return LR; 279 } 280