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