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