1 //===- lib/DebugInfo/Symbolize/DIPrinter.cpp ------------------------------===//
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
7 //===----------------------------------------------------------------------===//
9 // This file defines the DIPrinter class, which is responsible for printing
10 // structures defined in DebugInfo/DIContext.h
12 //===----------------------------------------------------------------------===//
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"
32 std::unique_ptr<MemoryBuffer> MemBuf;
34 Optional<StringRef> load(StringRef FileName,
35 const Optional<StringRef> &EmbeddedSource) {
40 return EmbeddedSource;
42 ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
43 MemoryBuffer::getFile(FileName);
46 MemBuf = std::move(*BufOrErr);
47 return MemBuf->getBuffer();
51 Optional<StringRef> pruneSource(const Optional<StringRef> &Source) {
54 size_t FirstLinePos = StringRef::npos, Pos = 0;
55 for (int64_t L = 1; L <= LastLine; ++L, ++Pos) {
58 Pos = Source->find('\n', Pos);
59 if (Pos == StringRef::npos)
62 if (FirstLinePos == StringRef::npos)
64 return Source->substr(FirstLinePos, (Pos == StringRef::npos)
66 : Pos - FirstLinePos);
72 const int64_t FirstLine;
73 const int64_t LastLine;
74 const Optional<StringRef> PrunedSource;
77 StringRef FileName, int64_t Line, int Lines,
78 const Optional<StringRef> &EmbeddedSource = Optional<StringRef>(None))
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))) {}
84 void format(raw_ostream &OS) {
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.endswith("\r"))
94 String = String.drop_back(1);
95 OS << format_decimal(L, MaxLineNumberWidth);
100 OS << String << '\n';
101 if (PosEnd == StringRef::npos)
108 void PlainPrinterBase::printHeader(uint64_t Address) {
109 if (Config.PrintAddress) {
111 OS.write_hex(Address);
112 StringRef Delimiter = Config.Pretty ? ": " : "\n";
117 // Prints source code around in the FileName the Line.
118 void PlainPrinterBase::printContext(SourceCode SourceCode) {
119 SourceCode.format(OS);
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;
132 void LLVMPrinter::printSimpleLocation(StringRef Filename,
133 const DILineInfo &Info) {
134 OS << Filename << ':' << Info.Line << ':' << Info.Column << '\n';
136 SourceCode(Filename, Info.Line, Config.SourceContextLines, Info.Source));
139 void GNUPrinter::printSimpleLocation(StringRef Filename,
140 const DILineInfo &Info) {
141 OS << Filename << ':' << Info.Line;
142 if (Info.Discriminator)
143 OS << " (discriminator " << Info.Discriminator << ')';
146 SourceCode(Filename, Info.Line, Config.SourceContextLines, Info.Source));
149 void PlainPrinterBase::printVerbose(StringRef Filename,
150 const DILineInfo &Info) {
151 OS << " Filename: " << Filename << '\n';
152 if (Info.StartLine) {
153 OS << " Function start filename: " << Info.StartFileName << '\n';
154 OS << " Function start line: " << Info.StartLine << '\n';
156 printStartAddress(Info);
157 OS << " Line: " << Info.Line << '\n';
158 OS << " Column: " << Info.Column << '\n';
159 if (Info.Discriminator)
160 OS << " Discriminator: " << Info.Discriminator << '\n';
163 void LLVMPrinter::printStartAddress(const DILineInfo &Info) {
164 if (Info.StartAddress) {
165 OS << " Function start address: 0x";
166 OS.write_hex(*Info.StartAddress);
171 void LLVMPrinter::printFooter() { OS << '\n'; }
173 void PlainPrinterBase::print(const DILineInfo &Info, bool Inlined) {
174 printFunctionName(Info.FunctionName, Inlined);
175 StringRef Filename = Info.FileName;
176 if (Filename == DILineInfo::BadString)
177 Filename = DILineInfo::Addr2LineBadString;
179 printVerbose(Filename, Info);
181 printSimpleLocation(Filename, Info);
184 void PlainPrinterBase::print(const Request &Request, const DILineInfo &Info) {
185 printHeader(*Request.Address);
190 void PlainPrinterBase::print(const Request &Request,
191 const DIInliningInfo &Info) {
192 printHeader(*Request.Address);
193 uint32_t FramesNum = Info.getNumberOfFrames();
195 print(DILineInfo(), false);
197 for (uint32_t I = 0; I < FramesNum; ++I)
198 print(Info.getFrame(I), I > 0);
202 void PlainPrinterBase::print(const Request &Request, const DIGlobal &Global) {
203 printHeader(*Request.Address);
204 StringRef Name = Global.Name;
205 if (Name == DILineInfo::BadString)
206 Name = DILineInfo::Addr2LineBadString;
208 OS << Global.Start << " " << Global.Size << "\n";
209 if (Global.DeclFile.empty())
212 OS << Global.DeclFile << ":" << Global.DeclLine << "\n";
216 void PlainPrinterBase::print(const Request &Request,
217 const std::vector<DILocal> &Locals) {
218 printHeader(*Request.Address);
220 OS << DILineInfo::Addr2LineBadString << '\n';
222 for (const DILocal &L : Locals) {
223 if (L.FunctionName.empty())
224 OS << DILineInfo::Addr2LineBadString;
226 OS << L.FunctionName;
230 OS << DILineInfo::Addr2LineBadString;
235 if (L.DeclFile.empty())
236 OS << DILineInfo::Addr2LineBadString;
240 OS << ':' << L.DeclLine << '\n';
243 OS << *L.FrameOffset;
245 OS << DILineInfo::Addr2LineBadString;
251 OS << DILineInfo::Addr2LineBadString;
257 OS << DILineInfo::Addr2LineBadString;
263 void PlainPrinterBase::printInvalidCommand(const Request &Request,
265 OS << Command << '\n';
268 bool PlainPrinterBase::printError(const Request &Request,
269 const ErrorInfoBase &ErrorInfo,
270 StringRef ErrorBanner) {
274 // Print an empty struct too.
278 static std::string toHex(uint64_t V) {
279 return ("0x" + Twine::utohexstr(V)).str();
282 static json::Object toJSON(const Request &Request, StringRef ErrorMsg = "") {
283 json::Object Json({{"ModuleName", Request.ModuleName.str()}});
285 Json["Address"] = toHex(*Request.Address);
286 if (!ErrorMsg.empty())
287 Json["Error"] = json::Object({{"Message", ErrorMsg.str()}});
291 void JSONPrinter::print(const Request &Request, const DILineInfo &Info) {
292 DIInliningInfo InliningInfo;
293 InliningInfo.addFrame(Info);
294 print(Request, InliningInfo);
297 void JSONPrinter::print(const Request &Request, const DIInliningInfo &Info) {
299 for (uint32_t I = 0, N = Info.getNumberOfFrames(); I < N; ++I) {
300 const DILineInfo &LineInfo = Info.getFrame(I);
302 {{"FunctionName", LineInfo.FunctionName != DILineInfo::BadString
303 ? LineInfo.FunctionName
305 {"StartFileName", LineInfo.StartFileName != DILineInfo::BadString
306 ? LineInfo.StartFileName
308 {"StartLine", LineInfo.StartLine},
310 LineInfo.StartAddress ? toHex(*LineInfo.StartAddress) : ""},
312 LineInfo.FileName != DILineInfo::BadString ? LineInfo.FileName : ""},
313 {"Line", LineInfo.Line},
314 {"Column", LineInfo.Column},
315 {"Discriminator", LineInfo.Discriminator}});
316 SourceCode SourceCode(LineInfo.FileName, LineInfo.Line,
317 Config.SourceContextLines, LineInfo.Source);
318 std::string FormattedSource;
319 raw_string_ostream Stream(FormattedSource);
320 SourceCode.format(Stream);
321 if (!FormattedSource.empty())
322 Object["Source"] = std::move(FormattedSource);
323 Array.push_back(std::move(Object));
325 json::Object Json = toJSON(Request);
326 Json["Symbol"] = std::move(Array);
328 ObjectList->push_back(std::move(Json));
330 printJSON(std::move(Json));
333 void JSONPrinter::print(const Request &Request, const DIGlobal &Global) {
335 {{"Name", Global.Name != DILineInfo::BadString ? Global.Name : ""},
336 {"Start", toHex(Global.Start)},
337 {"Size", toHex(Global.Size)}});
338 json::Object Json = toJSON(Request);
339 Json["Data"] = std::move(Data);
341 ObjectList->push_back(std::move(Json));
343 printJSON(std::move(Json));
346 void JSONPrinter::print(const Request &Request,
347 const std::vector<DILocal> &Locals) {
349 for (const DILocal &Local : Locals) {
350 json::Object FrameObject(
351 {{"FunctionName", Local.FunctionName},
352 {"Name", Local.Name},
353 {"DeclFile", Local.DeclFile},
354 {"DeclLine", int64_t(Local.DeclLine)},
355 {"Size", Local.Size ? toHex(*Local.Size) : ""},
356 {"TagOffset", Local.TagOffset ? toHex(*Local.TagOffset) : ""}});
357 if (Local.FrameOffset)
358 FrameObject["FrameOffset"] = *Local.FrameOffset;
359 Frame.push_back(std::move(FrameObject));
361 json::Object Json = toJSON(Request);
362 Json["Frame"] = std::move(Frame);
364 ObjectList->push_back(std::move(Json));
366 printJSON(std::move(Json));
369 void JSONPrinter::printInvalidCommand(const Request &Request,
372 StringError("unable to parse arguments: " + Command,
373 std::make_error_code(std::errc::invalid_argument)),
377 bool JSONPrinter::printError(const Request &Request,
378 const ErrorInfoBase &ErrorInfo,
379 StringRef ErrorBanner) {
380 json::Object Json = toJSON(Request, ErrorInfo.message());
382 ObjectList->push_back(std::move(Json));
384 printJSON(std::move(Json));
388 void JSONPrinter::listBegin() {
390 ObjectList = std::make_unique<json::Array>();
393 void JSONPrinter::listEnd() {
395 printJSON(std::move(*ObjectList));
399 } // end namespace symbolize
400 } // end namespace llvm