1 //===- lib/DebugInfo/Symbolize/DIPrinter.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 // This file defines the DIPrinter class, which is responsible for printing 10 // structures defined in DebugInfo/DIContext.h 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/DebugInfo/Symbolize/DIPrinter.h" 15 #include "llvm/ADT/StringRef.h" 16 #include "llvm/DebugInfo/DIContext.h" 17 #include "llvm/Support/ErrorOr.h" 18 #include "llvm/Support/Format.h" 19 #include "llvm/Support/MemoryBuffer.h" 20 #include "llvm/Support/raw_ostream.h" 21 #include <algorithm> 22 #include <cmath> 23 #include <cstddef> 24 #include <cstdint> 25 #include <memory> 26 #include <string> 27 28 namespace llvm { 29 namespace symbolize { 30 31 class SourceCode { 32 std::unique_ptr<MemoryBuffer> MemBuf; 33 34 std::optional<StringRef> 35 load(StringRef FileName, const std::optional<StringRef> &EmbeddedSource) { 36 if (Lines <= 0) 37 return std::nullopt; 38 39 if (EmbeddedSource) 40 return EmbeddedSource; 41 else { 42 ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr = 43 MemoryBuffer::getFile(FileName); 44 if (!BufOrErr) 45 return std::nullopt; 46 MemBuf = std::move(*BufOrErr); 47 return MemBuf->getBuffer(); 48 } 49 } 50 51 std::optional<StringRef> pruneSource(const std::optional<StringRef> &Source) { 52 if (!Source) 53 return std::nullopt; 54 size_t FirstLinePos = StringRef::npos, Pos = 0; 55 for (int64_t L = 1; L <= LastLine; ++L, ++Pos) { 56 if (L == FirstLine) 57 FirstLinePos = Pos; 58 Pos = Source->find('\n', Pos); 59 if (Pos == StringRef::npos) 60 break; 61 } 62 if (FirstLinePos == StringRef::npos) 63 return std::nullopt; 64 return Source->substr(FirstLinePos, (Pos == StringRef::npos) 65 ? StringRef::npos 66 : Pos - FirstLinePos); 67 } 68 69 public: 70 const int64_t Line; 71 const int Lines; 72 const int64_t FirstLine; 73 const int64_t LastLine; 74 const std::optional<StringRef> PrunedSource; 75 76 SourceCode(StringRef FileName, int64_t Line, int Lines, 77 const std::optional<StringRef> &EmbeddedSource = 78 std::optional<StringRef>()) 79 : Line(Line), Lines(Lines), 80 FirstLine(std::max(static_cast<int64_t>(1), Line - Lines / 2)), 81 LastLine(FirstLine + Lines - 1), 82 PrunedSource(pruneSource(load(FileName, EmbeddedSource))) {} 83 84 void format(raw_ostream &OS) { 85 if (!PrunedSource) 86 return; 87 size_t MaxLineNumberWidth = std::ceil(std::log10(LastLine)); 88 int64_t L = FirstLine; 89 for (size_t Pos = 0; Pos < PrunedSource->size(); ++L) { 90 size_t PosEnd = PrunedSource->find('\n', Pos); 91 StringRef String = PrunedSource->substr( 92 Pos, (PosEnd == StringRef::npos) ? StringRef::npos : (PosEnd - Pos)); 93 if (String.ends_with("\r")) 94 String = String.drop_back(1); 95 OS << format_decimal(L, MaxLineNumberWidth); 96 if (L == Line) 97 OS << " >: "; 98 else 99 OS << " : "; 100 OS << String << '\n'; 101 if (PosEnd == StringRef::npos) 102 break; 103 Pos = PosEnd + 1; 104 } 105 } 106 }; 107 108 void PlainPrinterBase::printHeader(std::optional<uint64_t> Address) { 109 if (Address.has_value() && Config.PrintAddress) { 110 OS << "0x"; 111 OS.write_hex(*Address); 112 StringRef Delimiter = Config.Pretty ? ": " : "\n"; 113 OS << Delimiter; 114 } 115 } 116 117 // Prints source code around in the FileName the Line. 118 void PlainPrinterBase::printContext(SourceCode SourceCode) { 119 SourceCode.format(OS); 120 } 121 122 void PlainPrinterBase::printFunctionName(StringRef FunctionName, bool Inlined) { 123 if (Config.PrintFunctions) { 124 if (FunctionName == DILineInfo::BadString) 125 FunctionName = DILineInfo::Addr2LineBadString; 126 StringRef Delimiter = Config.Pretty ? " at " : "\n"; 127 StringRef Prefix = (Config.Pretty && Inlined) ? " (inlined by) " : ""; 128 OS << Prefix << FunctionName << Delimiter; 129 } 130 } 131 132 void LLVMPrinter::printSimpleLocation(StringRef Filename, 133 const DILineInfo &Info) { 134 OS << Filename << ':' << Info.Line << ':' << Info.Column; 135 if (Info.IsApproximateLine) 136 OS << " " << Info.ApproxString; 137 OS << "\n"; 138 printContext( 139 SourceCode(Filename, Info.Line, Config.SourceContextLines, Info.Source)); 140 } 141 142 void GNUPrinter::printSimpleLocation(StringRef Filename, 143 const DILineInfo &Info) { 144 OS << Filename << ':' << Info.Line; 145 if (Info.IsApproximateLine) 146 OS << " " << Info.ApproxString; 147 if (Info.Discriminator) 148 OS << " (discriminator " << Info.Discriminator << ')'; 149 OS << '\n'; 150 printContext( 151 SourceCode(Filename, Info.Line, Config.SourceContextLines, Info.Source)); 152 } 153 154 void PlainPrinterBase::printVerbose(StringRef Filename, 155 const DILineInfo &Info) { 156 OS << " Filename: " << Filename << '\n'; 157 if (Info.StartLine) { 158 OS << " Function start filename: " << Info.StartFileName << '\n'; 159 OS << " Function start line: " << Info.StartLine << '\n'; 160 } 161 printStartAddress(Info); 162 OS << " Line: " << Info.Line << '\n'; 163 OS << " Column: " << Info.Column << '\n'; 164 if (Info.Discriminator) 165 OS << " Discriminator: " << Info.Discriminator << '\n'; 166 if (Info.IsApproximateLine) 167 OS << " Approximate: true" << '\n'; 168 } 169 170 void LLVMPrinter::printStartAddress(const DILineInfo &Info) { 171 if (Info.StartAddress) { 172 OS << " Function start address: 0x"; 173 OS.write_hex(*Info.StartAddress); 174 OS << '\n'; 175 } 176 } 177 178 void LLVMPrinter::printFooter() { OS << '\n'; } 179 180 void PlainPrinterBase::print(const DILineInfo &Info, bool Inlined) { 181 printFunctionName(Info.FunctionName, Inlined); 182 StringRef Filename = Info.FileName; 183 if (Filename == DILineInfo::BadString) 184 Filename = DILineInfo::Addr2LineBadString; 185 if (Config.Verbose) 186 printVerbose(Filename, Info); 187 else 188 printSimpleLocation(Filename, Info); 189 } 190 191 void PlainPrinterBase::print(const Request &Request, const DILineInfo &Info) { 192 printHeader(Request.Address); 193 print(Info, false); 194 printFooter(); 195 } 196 197 void PlainPrinterBase::print(const Request &Request, 198 const DIInliningInfo &Info) { 199 printHeader(*Request.Address); 200 uint32_t FramesNum = Info.getNumberOfFrames(); 201 if (FramesNum == 0) 202 print(DILineInfo(), false); 203 else 204 for (uint32_t I = 0; I < FramesNum; ++I) 205 print(Info.getFrame(I), I > 0); 206 printFooter(); 207 } 208 209 void PlainPrinterBase::print(const Request &Request, const DIGlobal &Global) { 210 printHeader(*Request.Address); 211 StringRef Name = Global.Name; 212 if (Name == DILineInfo::BadString) 213 Name = DILineInfo::Addr2LineBadString; 214 OS << Name << "\n"; 215 OS << Global.Start << " " << Global.Size << "\n"; 216 if (Global.DeclFile.empty()) 217 OS << "??:?\n"; 218 else 219 OS << Global.DeclFile << ":" << Global.DeclLine << "\n"; 220 printFooter(); 221 } 222 223 void PlainPrinterBase::print(const Request &Request, 224 const std::vector<DILocal> &Locals) { 225 printHeader(*Request.Address); 226 if (Locals.empty()) 227 OS << DILineInfo::Addr2LineBadString << '\n'; 228 else 229 for (const DILocal &L : Locals) { 230 if (L.FunctionName.empty()) 231 OS << DILineInfo::Addr2LineBadString; 232 else 233 OS << L.FunctionName; 234 OS << '\n'; 235 236 if (L.Name.empty()) 237 OS << DILineInfo::Addr2LineBadString; 238 else 239 OS << L.Name; 240 OS << '\n'; 241 242 if (L.DeclFile.empty()) 243 OS << DILineInfo::Addr2LineBadString; 244 else 245 OS << L.DeclFile; 246 247 OS << ':' << L.DeclLine << '\n'; 248 249 if (L.FrameOffset) 250 OS << *L.FrameOffset; 251 else 252 OS << DILineInfo::Addr2LineBadString; 253 OS << ' '; 254 255 if (L.Size) 256 OS << *L.Size; 257 else 258 OS << DILineInfo::Addr2LineBadString; 259 OS << ' '; 260 261 if (L.TagOffset) 262 OS << *L.TagOffset; 263 else 264 OS << DILineInfo::Addr2LineBadString; 265 OS << '\n'; 266 } 267 printFooter(); 268 } 269 270 void PlainPrinterBase::print(const Request &Request, 271 const std::vector<DILineInfo> &Locations) { 272 if (Locations.empty()) { 273 print(Request, DILineInfo()); 274 } else { 275 for (const DILineInfo &L : Locations) 276 print(L, false); 277 printFooter(); 278 } 279 } 280 281 bool PlainPrinterBase::printError(const Request &Request, 282 const ErrorInfoBase &ErrorInfo) { 283 ErrHandler(ErrorInfo, Request.ModuleName); 284 // Print an empty struct too. 285 return true; 286 } 287 288 static std::string toHex(uint64_t V) { 289 return ("0x" + Twine::utohexstr(V)).str(); 290 } 291 292 static json::Object toJSON(const Request &Request, StringRef ErrorMsg = "") { 293 json::Object Json({{"ModuleName", Request.ModuleName.str()}}); 294 if (!Request.Symbol.empty()) 295 Json["SymName"] = Request.Symbol.str(); 296 if (Request.Address) 297 Json["Address"] = toHex(*Request.Address); 298 if (!ErrorMsg.empty()) 299 Json["Error"] = json::Object({{"Message", ErrorMsg.str()}}); 300 return Json; 301 } 302 303 static json::Object toJSON(const DILineInfo &LineInfo) { 304 json::Object Obj = json::Object( 305 {{"FunctionName", LineInfo.FunctionName != DILineInfo::BadString 306 ? LineInfo.FunctionName 307 : ""}, 308 {"StartFileName", LineInfo.StartFileName != DILineInfo::BadString 309 ? LineInfo.StartFileName 310 : ""}, 311 {"StartLine", LineInfo.StartLine}, 312 {"StartAddress", 313 LineInfo.StartAddress ? toHex(*LineInfo.StartAddress) : ""}, 314 {"FileName", 315 LineInfo.FileName != DILineInfo::BadString ? LineInfo.FileName : ""}, 316 {"Line", LineInfo.Line}, 317 {"Column", LineInfo.Column}, 318 {"Discriminator", LineInfo.Discriminator}}); 319 if (LineInfo.IsApproximateLine) 320 Obj.insert({"Approximate", LineInfo.IsApproximateLine}); 321 return Obj; 322 } 323 324 void JSONPrinter::print(const Request &Request, const DILineInfo &Info) { 325 DIInliningInfo InliningInfo; 326 InliningInfo.addFrame(Info); 327 print(Request, InliningInfo); 328 } 329 330 void JSONPrinter::print(const Request &Request, const DIInliningInfo &Info) { 331 json::Array Array; 332 for (uint32_t I = 0, N = Info.getNumberOfFrames(); I < N; ++I) { 333 const DILineInfo &LineInfo = Info.getFrame(I); 334 json::Object Object = toJSON(LineInfo); 335 SourceCode SourceCode(LineInfo.FileName, LineInfo.Line, 336 Config.SourceContextLines, LineInfo.Source); 337 std::string FormattedSource; 338 raw_string_ostream Stream(FormattedSource); 339 SourceCode.format(Stream); 340 if (!FormattedSource.empty()) 341 Object["Source"] = std::move(FormattedSource); 342 Array.push_back(std::move(Object)); 343 } 344 json::Object Json = toJSON(Request); 345 Json["Symbol"] = std::move(Array); 346 if (ObjectList) 347 ObjectList->push_back(std::move(Json)); 348 else 349 printJSON(std::move(Json)); 350 } 351 352 void JSONPrinter::print(const Request &Request, const DIGlobal &Global) { 353 json::Object Data( 354 {{"Name", Global.Name != DILineInfo::BadString ? Global.Name : ""}, 355 {"Start", toHex(Global.Start)}, 356 {"Size", toHex(Global.Size)}}); 357 json::Object Json = toJSON(Request); 358 Json["Data"] = std::move(Data); 359 if (ObjectList) 360 ObjectList->push_back(std::move(Json)); 361 else 362 printJSON(std::move(Json)); 363 } 364 365 void JSONPrinter::print(const Request &Request, 366 const std::vector<DILocal> &Locals) { 367 json::Array Frame; 368 for (const DILocal &Local : Locals) { 369 json::Object FrameObject( 370 {{"FunctionName", Local.FunctionName}, 371 {"Name", Local.Name}, 372 {"DeclFile", Local.DeclFile}, 373 {"DeclLine", int64_t(Local.DeclLine)}, 374 {"Size", Local.Size ? toHex(*Local.Size) : ""}, 375 {"TagOffset", Local.TagOffset ? toHex(*Local.TagOffset) : ""}}); 376 if (Local.FrameOffset) 377 FrameObject["FrameOffset"] = *Local.FrameOffset; 378 Frame.push_back(std::move(FrameObject)); 379 } 380 json::Object Json = toJSON(Request); 381 Json["Frame"] = std::move(Frame); 382 if (ObjectList) 383 ObjectList->push_back(std::move(Json)); 384 else 385 printJSON(std::move(Json)); 386 } 387 388 void JSONPrinter::print(const Request &Request, 389 const std::vector<DILineInfo> &Locations) { 390 json::Array Definitions; 391 for (const DILineInfo &L : Locations) 392 Definitions.push_back(toJSON(L)); 393 json::Object Json = toJSON(Request); 394 Json["Loc"] = std::move(Definitions); 395 if (ObjectList) 396 ObjectList->push_back(std::move(Json)); 397 else 398 printJSON(std::move(Json)); 399 } 400 401 bool JSONPrinter::printError(const Request &Request, 402 const ErrorInfoBase &ErrorInfo) { 403 json::Object Json = toJSON(Request, ErrorInfo.message()); 404 if (ObjectList) 405 ObjectList->push_back(std::move(Json)); 406 else 407 printJSON(std::move(Json)); 408 return false; 409 } 410 411 void JSONPrinter::listBegin() { 412 assert(!ObjectList); 413 ObjectList = std::make_unique<json::Array>(); 414 } 415 416 void JSONPrinter::listEnd() { 417 assert(ObjectList); 418 printJSON(std::move(*ObjectList)); 419 ObjectList.reset(); 420 } 421 422 } // end namespace symbolize 423 } // end namespace llvm 424