1//===-- SourcePrinter.cpp - source interleaving utilities ----------------===//
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 implements the LiveVariablePrinter and SourcePrinter classes to
10// keep track of DWARF info as the current address is updated, and print out the
11// source file line and variable liveness as needed.
12//
13//===----------------------------------------------------------------------===//
14
15#include "SourcePrinter.h"
16#include "llvm-objdump.h"
17#include "llvm/ADT/SmallSet.h"
18#include "llvm/ADT/StringSet.h"
19#include "llvm/DebugInfo/DWARF/DWARFExpression.h"
20#include "llvm/DebugInfo/Symbolize/SymbolizableModule.h"
21#include "llvm/MC/MCSubtargetInfo.h"
22#include "llvm/Support/FormatVariadic.h"
23
24#define DEBUG_TYPE "objdump"
25
26namespace llvm {
27namespace objdump {
28
29bool LiveVariable::liveAtAddress(object::SectionedAddress Addr) {
30 if (LocExpr.Range == std::nullopt)
31 return false;
32 return LocExpr.Range->SectionIndex == Addr.SectionIndex &&
33 LocExpr.Range->LowPC <= Addr.Address &&
34 LocExpr.Range->HighPC > Addr.Address;
35}
36
37void LiveVariable::print(raw_ostream &OS, const MCRegisterInfo &MRI) const {
38 DataExtractor Data({LocExpr.Expr.data(), LocExpr.Expr.size()},
39 Unit->getContext().isLittleEndian(), 0);
40 DWARFExpression Expression(Data, Unit->getAddressByteSize());
41
42 auto GetRegName = [&MRI, &OS](uint64_t DwarfRegNum, bool IsEH) -> StringRef {
43 if (std::optional<unsigned> LLVMRegNum =
44 MRI.getLLVMRegNum(RegNum: DwarfRegNum, isEH: IsEH))
45 if (const char *RegName = MRI.getName(RegNo: *LLVMRegNum))
46 return StringRef(RegName);
47 OS << "<unknown register " << DwarfRegNum << ">";
48 return {};
49 };
50
51 Expression.printCompact(OS, GetNameForDWARFReg: GetRegName);
52}
53
54void LiveVariablePrinter::addVariable(DWARFDie FuncDie, DWARFDie VarDie) {
55 uint64_t FuncLowPC, FuncHighPC, SectionIndex;
56 FuncDie.getLowAndHighPC(LowPC&: FuncLowPC, HighPC&: FuncHighPC, SectionIndex);
57 const char *VarName = VarDie.getName(Kind: DINameKind::ShortName);
58 DWARFUnit *U = VarDie.getDwarfUnit();
59
60 Expected<DWARFLocationExpressionsVector> Locs =
61 VarDie.getLocations(Attr: dwarf::DW_AT_location);
62 if (!Locs) {
63 // If the variable doesn't have any locations, just ignore it. We don't
64 // report an error or warning here as that could be noisy on optimised
65 // code.
66 consumeError(Err: Locs.takeError());
67 return;
68 }
69
70 for (const DWARFLocationExpression &LocExpr : *Locs) {
71 if (LocExpr.Range) {
72 LiveVariables.emplace_back(args: LocExpr, args&: VarName, args&: U, args&: FuncDie);
73 } else {
74 // If the LocExpr does not have an associated range, it is valid for
75 // the whole of the function.
76 // TODO: technically it is not valid for any range covered by another
77 // LocExpr, does that happen in reality?
78 DWARFLocationExpression WholeFuncExpr{
79 .Range: DWARFAddressRange(FuncLowPC, FuncHighPC, SectionIndex), .Expr: LocExpr.Expr};
80 LiveVariables.emplace_back(args&: WholeFuncExpr, args&: VarName, args&: U, args&: FuncDie);
81 }
82 }
83}
84
85void LiveVariablePrinter::addFunction(DWARFDie D) {
86 for (const DWARFDie &Child : D.children()) {
87 if (Child.getTag() == dwarf::DW_TAG_variable ||
88 Child.getTag() == dwarf::DW_TAG_formal_parameter)
89 addVariable(FuncDie: D, VarDie: Child);
90 else
91 addFunction(D: Child);
92 }
93}
94
95// Get the column number (in characters) at which the first live variable
96// line should be printed.
97unsigned LiveVariablePrinter::getIndentLevel() const {
98 return DbgIndent + getInstStartColumn(STI);
99}
100
101// Indent to the first live-range column to the right of the currently
102// printed line, and return the index of that column.
103// TODO: formatted_raw_ostream uses "column" to mean a number of characters
104// since the last \n, and we use it to mean the number of slots in which we
105// put live variable lines. Pick a less overloaded word.
106unsigned LiveVariablePrinter::moveToFirstVarColumn(formatted_raw_ostream &OS) {
107 // Logical column number: column zero is the first column we print in, each
108 // logical column is 2 physical columns wide.
109 unsigned FirstUnprintedLogicalColumn =
110 std::max(a: (int)(OS.getColumn() - getIndentLevel() + 1) / 2, b: 0);
111 // Physical column number: the actual column number in characters, with
112 // zero being the left-most side of the screen.
113 unsigned FirstUnprintedPhysicalColumn =
114 getIndentLevel() + FirstUnprintedLogicalColumn * 2;
115
116 if (FirstUnprintedPhysicalColumn > OS.getColumn())
117 OS.PadToColumn(NewCol: FirstUnprintedPhysicalColumn);
118
119 return FirstUnprintedLogicalColumn;
120}
121
122unsigned LiveVariablePrinter::findFreeColumn() {
123 for (unsigned ColIdx = 0; ColIdx < ActiveCols.size(); ++ColIdx)
124 if (!ActiveCols[ColIdx].isActive())
125 return ColIdx;
126
127 size_t OldSize = ActiveCols.size();
128 ActiveCols.grow(n: std::max<size_t>(a: OldSize * 2, b: 1));
129 return OldSize;
130}
131
132void LiveVariablePrinter::dump() const {
133 for (const LiveVariable &LV : LiveVariables) {
134 dbgs() << LV.VarName << " @ " << LV.LocExpr.Range << ": ";
135 LV.print(OS&: dbgs(), MRI);
136 dbgs() << "\n";
137 }
138}
139
140void LiveVariablePrinter::addCompileUnit(DWARFDie D) {
141 if (D.getTag() == dwarf::DW_TAG_subprogram)
142 addFunction(D);
143 else
144 for (const DWARFDie &Child : D.children())
145 addFunction(D: Child);
146}
147
148/// Update to match the state of the instruction between ThisAddr and
149/// NextAddr. In the common case, any live range active at ThisAddr is
150/// live-in to the instruction, and any live range active at NextAddr is
151/// live-out of the instruction. If IncludeDefinedVars is false, then live
152/// ranges starting at NextAddr will be ignored.
153void LiveVariablePrinter::update(object::SectionedAddress ThisAddr,
154 object::SectionedAddress NextAddr,
155 bool IncludeDefinedVars) {
156 // First, check variables which have already been assigned a column, so
157 // that we don't change their order.
158 SmallSet<unsigned, 8> CheckedVarIdxs;
159 for (unsigned ColIdx = 0, End = ActiveCols.size(); ColIdx < End; ++ColIdx) {
160 if (!ActiveCols[ColIdx].isActive())
161 continue;
162 CheckedVarIdxs.insert(V: ActiveCols[ColIdx].VarIdx);
163 LiveVariable &LV = LiveVariables[ActiveCols[ColIdx].VarIdx];
164 ActiveCols[ColIdx].LiveIn = LV.liveAtAddress(Addr: ThisAddr);
165 ActiveCols[ColIdx].LiveOut = LV.liveAtAddress(Addr: NextAddr);
166 LLVM_DEBUG(dbgs() << "pass 1, " << ThisAddr.Address << "-"
167 << NextAddr.Address << ", " << LV.VarName << ", Col "
168 << ColIdx << ": LiveIn=" << ActiveCols[ColIdx].LiveIn
169 << ", LiveOut=" << ActiveCols[ColIdx].LiveOut << "\n");
170
171 if (!ActiveCols[ColIdx].LiveIn && !ActiveCols[ColIdx].LiveOut)
172 ActiveCols[ColIdx].VarIdx = Column::NullVarIdx;
173 }
174
175 // Next, look for variables which don't already have a column, but which
176 // are now live.
177 if (IncludeDefinedVars) {
178 for (unsigned VarIdx = 0, End = LiveVariables.size(); VarIdx < End;
179 ++VarIdx) {
180 if (CheckedVarIdxs.count(V: VarIdx))
181 continue;
182 LiveVariable &LV = LiveVariables[VarIdx];
183 bool LiveIn = LV.liveAtAddress(Addr: ThisAddr);
184 bool LiveOut = LV.liveAtAddress(Addr: NextAddr);
185 if (!LiveIn && !LiveOut)
186 continue;
187
188 unsigned ColIdx = findFreeColumn();
189 LLVM_DEBUG(dbgs() << "pass 2, " << ThisAddr.Address << "-"
190 << NextAddr.Address << ", " << LV.VarName << ", Col "
191 << ColIdx << ": LiveIn=" << LiveIn
192 << ", LiveOut=" << LiveOut << "\n");
193 ActiveCols[ColIdx].VarIdx = VarIdx;
194 ActiveCols[ColIdx].LiveIn = LiveIn;
195 ActiveCols[ColIdx].LiveOut = LiveOut;
196 ActiveCols[ColIdx].MustDrawLabel = true;
197 }
198 }
199}
200
201enum class LineChar {
202 RangeStart,
203 RangeMid,
204 RangeEnd,
205 LabelVert,
206 LabelCornerNew,
207 LabelCornerActive,
208 LabelHoriz,
209};
210const char *LiveVariablePrinter::getLineChar(LineChar C) const {
211 bool IsASCII = DbgVariables == DVASCII;
212 switch (C) {
213 case LineChar::RangeStart:
214 return IsASCII ? "^" : (const char *)u8"\u2548";
215 case LineChar::RangeMid:
216 return IsASCII ? "|" : (const char *)u8"\u2503";
217 case LineChar::RangeEnd:
218 return IsASCII ? "v" : (const char *)u8"\u253b";
219 case LineChar::LabelVert:
220 return IsASCII ? "|" : (const char *)u8"\u2502";
221 case LineChar::LabelCornerNew:
222 return IsASCII ? "/" : (const char *)u8"\u250c";
223 case LineChar::LabelCornerActive:
224 return IsASCII ? "|" : (const char *)u8"\u2520";
225 case LineChar::LabelHoriz:
226 return IsASCII ? "-" : (const char *)u8"\u2500";
227 }
228 llvm_unreachable("Unhandled LineChar enum");
229}
230
231/// Print live ranges to the right of an existing line. This assumes the
232/// line is not an instruction, so doesn't start or end any live ranges, so
233/// we only need to print active ranges or empty columns. If AfterInst is
234/// true, this is being printed after the last instruction fed to update(),
235/// otherwise this is being printed before it.
236void LiveVariablePrinter::printAfterOtherLine(formatted_raw_ostream &OS,
237 bool AfterInst) {
238 if (ActiveCols.size()) {
239 unsigned FirstUnprintedColumn = moveToFirstVarColumn(OS);
240 for (size_t ColIdx = FirstUnprintedColumn, End = ActiveCols.size();
241 ColIdx < End; ++ColIdx) {
242 if (ActiveCols[ColIdx].isActive()) {
243 if ((AfterInst && ActiveCols[ColIdx].LiveOut) ||
244 (!AfterInst && ActiveCols[ColIdx].LiveIn))
245 OS << getLineChar(C: LineChar::RangeMid);
246 else if (!AfterInst && ActiveCols[ColIdx].LiveOut)
247 OS << getLineChar(C: LineChar::LabelVert);
248 else
249 OS << " ";
250 }
251 OS << " ";
252 }
253 }
254 OS << "\n";
255}
256
257/// Print any live variable range info needed to the right of a
258/// non-instruction line of disassembly. This is where we print the variable
259/// names and expressions, with thin line-drawing characters connecting them
260/// to the live range which starts at the next instruction. If MustPrint is
261/// true, we have to print at least one line (with the continuation of any
262/// already-active live ranges) because something has already been printed
263/// earlier on this line.
264void LiveVariablePrinter::printBetweenInsts(formatted_raw_ostream &OS,
265 bool MustPrint) {
266 bool PrintedSomething = false;
267 for (unsigned ColIdx = 0, End = ActiveCols.size(); ColIdx < End; ++ColIdx) {
268 if (ActiveCols[ColIdx].isActive() && ActiveCols[ColIdx].MustDrawLabel) {
269 // First we need to print the live range markers for any active
270 // columns to the left of this one.
271 OS.PadToColumn(NewCol: getIndentLevel());
272 for (unsigned ColIdx2 = 0; ColIdx2 < ColIdx; ++ColIdx2) {
273 if (ActiveCols[ColIdx2].isActive()) {
274 if (ActiveCols[ColIdx2].MustDrawLabel && !ActiveCols[ColIdx2].LiveIn)
275 OS << getLineChar(C: LineChar::LabelVert) << " ";
276 else
277 OS << getLineChar(C: LineChar::RangeMid) << " ";
278 } else
279 OS << " ";
280 }
281
282 // Then print the variable name and location of the new live range,
283 // with box drawing characters joining it to the live range line.
284 OS << getLineChar(C: ActiveCols[ColIdx].LiveIn ? LineChar::LabelCornerActive
285 : LineChar::LabelCornerNew)
286 << getLineChar(C: LineChar::LabelHoriz) << " ";
287 WithColor(OS, raw_ostream::GREEN)
288 << LiveVariables[ActiveCols[ColIdx].VarIdx].VarName;
289 OS << " = ";
290 {
291 WithColor ExprColor(OS, raw_ostream::CYAN);
292 LiveVariables[ActiveCols[ColIdx].VarIdx].print(OS, MRI);
293 }
294
295 // If there are any columns to the right of the expression we just
296 // printed, then continue their live range lines.
297 unsigned FirstUnprintedColumn = moveToFirstVarColumn(OS);
298 for (unsigned ColIdx2 = FirstUnprintedColumn, End = ActiveCols.size();
299 ColIdx2 < End; ++ColIdx2) {
300 if (ActiveCols[ColIdx2].isActive() && ActiveCols[ColIdx2].LiveIn)
301 OS << getLineChar(C: LineChar::RangeMid) << " ";
302 else
303 OS << " ";
304 }
305
306 OS << "\n";
307 PrintedSomething = true;
308 }
309 }
310
311 for (unsigned ColIdx = 0, End = ActiveCols.size(); ColIdx < End; ++ColIdx)
312 if (ActiveCols[ColIdx].isActive())
313 ActiveCols[ColIdx].MustDrawLabel = false;
314
315 // If we must print something (because we printed a line/column number),
316 // but don't have any new variables to print, then print a line which
317 // just continues any existing live ranges.
318 if (MustPrint && !PrintedSomething)
319 printAfterOtherLine(OS, AfterInst: false);
320}
321
322/// Print the live variable ranges to the right of a disassembled instruction.
323void LiveVariablePrinter::printAfterInst(formatted_raw_ostream &OS) {
324 if (!ActiveCols.size())
325 return;
326 unsigned FirstUnprintedColumn = moveToFirstVarColumn(OS);
327 for (unsigned ColIdx = FirstUnprintedColumn, End = ActiveCols.size();
328 ColIdx < End; ++ColIdx) {
329 if (!ActiveCols[ColIdx].isActive())
330 OS << " ";
331 else if (ActiveCols[ColIdx].LiveIn && ActiveCols[ColIdx].LiveOut)
332 OS << getLineChar(C: LineChar::RangeMid) << " ";
333 else if (ActiveCols[ColIdx].LiveOut)
334 OS << getLineChar(C: LineChar::RangeStart) << " ";
335 else if (ActiveCols[ColIdx].LiveIn)
336 OS << getLineChar(C: LineChar::RangeEnd) << " ";
337 else
338 llvm_unreachable("var must be live in or out!");
339 }
340}
341
342bool SourcePrinter::cacheSource(const DILineInfo &LineInfo) {
343 std::unique_ptr<MemoryBuffer> Buffer;
344 if (LineInfo.Source) {
345 Buffer = MemoryBuffer::getMemBuffer(InputData: *LineInfo.Source);
346 } else {
347 auto BufferOrError = MemoryBuffer::getFile(Filename: LineInfo.FileName);
348 if (!BufferOrError) {
349 if (MissingSources.insert(key: LineInfo.FileName).second)
350 reportWarning(Message: "failed to find source " + LineInfo.FileName,
351 File: Obj->getFileName());
352 return false;
353 }
354 Buffer = std::move(*BufferOrError);
355 }
356 // Chomp the file to get lines
357 const char *BufferStart = Buffer->getBufferStart(),
358 *BufferEnd = Buffer->getBufferEnd();
359 std::vector<StringRef> &Lines = LineCache[LineInfo.FileName];
360 const char *Start = BufferStart;
361 for (const char *I = BufferStart; I != BufferEnd; ++I)
362 if (*I == '\n') {
363 Lines.emplace_back(args&: Start, args: I - Start - (BufferStart < I && I[-1] == '\r'));
364 Start = I + 1;
365 }
366 if (Start < BufferEnd)
367 Lines.emplace_back(args&: Start, args: BufferEnd - Start);
368 SourceCache[LineInfo.FileName] = std::move(Buffer);
369 return true;
370}
371
372void SourcePrinter::printSourceLine(formatted_raw_ostream &OS,
373 object::SectionedAddress Address,
374 StringRef ObjectFilename,
375 LiveVariablePrinter &LVP,
376 StringRef Delimiter) {
377 if (!Symbolizer)
378 return;
379
380 DILineInfo LineInfo = DILineInfo();
381 Expected<DILineInfo> ExpectedLineInfo =
382 Symbolizer->symbolizeCode(Obj: *Obj, ModuleOffset: Address);
383 std::string ErrorMessage;
384 if (ExpectedLineInfo) {
385 LineInfo = *ExpectedLineInfo;
386 } else if (!WarnedInvalidDebugInfo) {
387 WarnedInvalidDebugInfo = true;
388 // TODO Untested.
389 reportWarning(Message: "failed to parse debug information: " +
390 toString(E: ExpectedLineInfo.takeError()),
391 File: ObjectFilename);
392 }
393
394 if (!objdump::Prefix.empty() &&
395 sys::path::is_absolute_gnu(path: LineInfo.FileName)) {
396 // FileName has at least one character since is_absolute_gnu is false for
397 // an empty string.
398 assert(!LineInfo.FileName.empty());
399 if (PrefixStrip > 0) {
400 uint32_t Level = 0;
401 auto StrippedNameStart = LineInfo.FileName.begin();
402
403 // Path.h iterator skips extra separators. Therefore it cannot be used
404 // here to keep compatibility with GNU Objdump.
405 for (auto Pos = StrippedNameStart + 1, End = LineInfo.FileName.end();
406 Pos != End && Level < PrefixStrip; ++Pos) {
407 if (sys::path::is_separator(value: *Pos)) {
408 StrippedNameStart = Pos;
409 ++Level;
410 }
411 }
412
413 LineInfo.FileName =
414 std::string(StrippedNameStart, LineInfo.FileName.end());
415 }
416
417 SmallString<128> FilePath;
418 sys::path::append(path&: FilePath, a: Prefix, b: LineInfo.FileName);
419
420 LineInfo.FileName = std::string(FilePath);
421 }
422
423 if (PrintLines)
424 printLines(OS, LineInfo, Delimiter, LVP);
425 if (PrintSource)
426 printSources(OS, LineInfo, ObjectFilename, Delimiter, LVP);
427 OldLineInfo = LineInfo;
428}
429
430void SourcePrinter::printLines(formatted_raw_ostream &OS,
431 const DILineInfo &LineInfo, StringRef Delimiter,
432 LiveVariablePrinter &LVP) {
433 bool PrintFunctionName = LineInfo.FunctionName != DILineInfo::BadString &&
434 LineInfo.FunctionName != OldLineInfo.FunctionName;
435 if (PrintFunctionName) {
436 OS << Delimiter << LineInfo.FunctionName;
437 // If demangling is successful, FunctionName will end with "()". Print it
438 // only if demangling did not run or was unsuccessful.
439 if (!StringRef(LineInfo.FunctionName).ends_with(Suffix: "()"))
440 OS << "()";
441 OS << ":\n";
442 }
443 if (LineInfo.FileName != DILineInfo::BadString && LineInfo.Line != 0 &&
444 (OldLineInfo.Line != LineInfo.Line ||
445 OldLineInfo.FileName != LineInfo.FileName || PrintFunctionName)) {
446 OS << Delimiter << LineInfo.FileName << ":" << LineInfo.Line;
447 LVP.printBetweenInsts(OS, MustPrint: true);
448 }
449}
450
451// Get the source line text for LineInfo:
452// - use LineInfo::LineSource if available;
453// - use LineCache if LineInfo::Source otherwise.
454StringRef SourcePrinter::getLine(const DILineInfo &LineInfo,
455 StringRef ObjectFilename) {
456 if (LineInfo.LineSource)
457 return LineInfo.LineSource.value();
458
459 if (SourceCache.find(x: LineInfo.FileName) == SourceCache.end())
460 if (!cacheSource(LineInfo))
461 return {};
462
463 auto LineBuffer = LineCache.find(x: LineInfo.FileName);
464 if (LineBuffer == LineCache.end())
465 return {};
466
467 if (LineInfo.Line > LineBuffer->second.size()) {
468 reportWarning(
469 Message: formatv(Fmt: "debug info line number {0} exceeds the number of lines in {1}",
470 Vals: LineInfo.Line, Vals: LineInfo.FileName),
471 File: ObjectFilename);
472 return {};
473 }
474
475 // Vector begins at 0, line numbers are non-zero
476 return LineBuffer->second[LineInfo.Line - 1];
477}
478
479void SourcePrinter::printSources(formatted_raw_ostream &OS,
480 const DILineInfo &LineInfo,
481 StringRef ObjectFilename, StringRef Delimiter,
482 LiveVariablePrinter &LVP) {
483 if (LineInfo.FileName == DILineInfo::BadString || LineInfo.Line == 0 ||
484 (OldLineInfo.Line == LineInfo.Line &&
485 OldLineInfo.FileName == LineInfo.FileName))
486 return;
487
488 StringRef Line = getLine(LineInfo, ObjectFilename);
489 if (!Line.empty()) {
490 OS << Delimiter << Line;
491 LVP.printBetweenInsts(OS, MustPrint: true);
492 }
493}
494
495SourcePrinter::SourcePrinter(const object::ObjectFile *Obj,
496 StringRef DefaultArch)
497 : Obj(Obj) {
498 symbolize::LLVMSymbolizer::Options SymbolizerOpts;
499 SymbolizerOpts.PrintFunctions =
500 DILineInfoSpecifier::FunctionNameKind::LinkageName;
501 SymbolizerOpts.Demangle = Demangle;
502 SymbolizerOpts.DefaultArch = std::string(DefaultArch);
503 Symbolizer.reset(p: new symbolize::LLVMSymbolizer(SymbolizerOpts));
504}
505
506} // namespace objdump
507} // namespace llvm
508

source code of llvm/tools/llvm-objdump/SourcePrinter.cpp