contrib/llvm-project/llvm/tools/llvm-pdbutil/LinePrinter.cpp

   1 //===- LinePrinter.cpp ------------------------------------------*- C++ -*-===//
   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 "LinePrinter.h"
  10
  11 #include "llvm-pdbutil.h"
  12
  13 #include "llvm/ADT/STLExtras.h"
  14 #include "llvm/DebugInfo/MSF/MSFCommon.h"
  15 #include "llvm/DebugInfo/MSF/MappedBlockStream.h"
  16 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
  17 #include "llvm/DebugInfo/PDB/UDTLayout.h"
  18 #include "llvm/Support/BinaryStreamReader.h"
  19 #include "llvm/Support/Format.h"
  20 #include "llvm/Support/FormatAdapters.h"
  21 #include "llvm/Support/FormatVariadic.h"
  22 #include "llvm/Support/Regex.h"
  23
  24 #include <algorithm>
  25
  26 using namespace llvm;
  27 using namespace llvm::msf;
  28 using namespace llvm::pdb;
  29
  30 namespace {
  31 bool IsItemExcluded(llvm::StringRef Item,
  32                     std::list<llvm::Regex> &IncludeFilters,
  33                     std::list<llvm::Regex> &ExcludeFilters) {
  34   if (Item.empty())
  35     return false;
  36
  37   auto match_pred = [Item](llvm::Regex &R) { return R.match(Item); };
  38
  39   // Include takes priority over exclude.  If the user specified include
  40   // filters, and none of them include this item, them item is gone.
  41   if (!IncludeFilters.empty() && !any_of(IncludeFilters, match_pred))
  42     return true;
  43
  44   if (any_of(ExcludeFilters, match_pred))
  45     return true;
  46
  47   return false;
  48 }
  49 }
  50
  51 using namespace llvm;
  52
  53 LinePrinter::LinePrinter(int Indent, bool UseColor, llvm::raw_ostream &Stream)
  54     : OS(Stream), IndentSpaces(Indent), CurrentIndent(0), UseColor(UseColor) {
  55   SetFilters(ExcludeTypeFilters, opts::pretty::ExcludeTypes.begin(),
  56              opts::pretty::ExcludeTypes.end());
  57   SetFilters(ExcludeSymbolFilters, opts::pretty::ExcludeSymbols.begin(),
  58              opts::pretty::ExcludeSymbols.end());
  59   SetFilters(ExcludeCompilandFilters, opts::pretty::ExcludeCompilands.begin(),
  60              opts::pretty::ExcludeCompilands.end());
  61
  62   SetFilters(IncludeTypeFilters, opts::pretty::IncludeTypes.begin(),
  63              opts::pretty::IncludeTypes.end());
  64   SetFilters(IncludeSymbolFilters, opts::pretty::IncludeSymbols.begin(),
  65              opts::pretty::IncludeSymbols.end());
  66   SetFilters(IncludeCompilandFilters, opts::pretty::IncludeCompilands.begin(),
  67              opts::pretty::IncludeCompilands.end());
  68 }
  69
  70 void LinePrinter::Indent(uint32_t Amount) {
  71   if (Amount == 0)
  72     Amount = IndentSpaces;
  73   CurrentIndent += Amount;
  74 }
  75
  76 void LinePrinter::Unindent(uint32_t Amount) {
  77   if (Amount == 0)
  78     Amount = IndentSpaces;
  79   CurrentIndent = std::max<int>(0, CurrentIndent - Amount);
  80 }
  81
  82 void LinePrinter::NewLine() {
  83   OS << "\n";
  84   OS.indent(CurrentIndent);
  85 }
  86
  87 void LinePrinter::print(const Twine &T) { OS << T; }
  88
  89 void LinePrinter::printLine(const Twine &T) {
  90   NewLine();
  91   OS << T;
  92 }
  93
  94 bool LinePrinter::IsClassExcluded(const ClassLayout &Class) {
  95   if (IsTypeExcluded(Class.getName(), Class.getSize()))
  96     return true;
  97   if (Class.deepPaddingSize() < opts::pretty::PaddingThreshold)
  98     return true;
  99   return false;
 100 }
 101
 102 void LinePrinter::formatBinary(StringRef Label, ArrayRef<uint8_t> Data,
 103                                uint32_t StartOffset) {
 104   NewLine();
 105   OS << Label << " (";
 106   if (!Data.empty()) {
 107     OS << "\n";
 108     OS << format_bytes_with_ascii(Data, StartOffset, 32, 4,
 109                                   CurrentIndent + IndentSpaces, true);
 110     NewLine();
 111   }
 112   OS << ")";
 113 }
 114
 115 void LinePrinter::formatBinary(StringRef Label, ArrayRef<uint8_t> Data,
 116                                uint64_t Base, uint32_t StartOffset) {
 117   NewLine();
 118   OS << Label << " (";
 119   if (!Data.empty()) {
 120     OS << "\n";
 121     Base += StartOffset;
 122     OS << format_bytes_with_ascii(Data, Base, 32, 4,
 123                                   CurrentIndent + IndentSpaces, true);
 124     NewLine();
 125   }
 126   OS << ")";
 127 }
 128
 129 namespace {
 130 struct Run {
 131   Run() = default;
 132   explicit Run(uint32_t Block) : Block(Block) {}
 133   uint32_t Block = 0;
 134   uint32_t ByteLen = 0;
 135 };
 136 } // namespace
 137
 138 static std::vector<Run> computeBlockRuns(uint32_t BlockSize,
 139                                          const msf::MSFStreamLayout &Layout) {
 140   std::vector<Run> Runs;
 141   if (Layout.Length == 0)
 142     return Runs;
 143
 144   ArrayRef<support::ulittle32_t> Blocks = Layout.Blocks;
 145   assert(!Blocks.empty());
 146   uint32_t StreamBytesRemaining = Layout.Length;
 147   uint32_t CurrentBlock = Blocks[0];
 148   Runs.emplace_back(CurrentBlock);
 149   while (!Blocks.empty()) {
 150     Run *CurrentRun = &Runs.back();
 151     uint32_t NextBlock = Blocks.front();
 152     if (NextBlock < CurrentBlock || (NextBlock - CurrentBlock > 1)) {
 153       Runs.emplace_back(NextBlock);
 154       CurrentRun = &Runs.back();
 155     }
 156     uint32_t Used = std::min(BlockSize, StreamBytesRemaining);
 157     CurrentRun->ByteLen += Used;
 158     StreamBytesRemaining -= Used;
 159     CurrentBlock = NextBlock;
 160     Blocks = Blocks.drop_front();
 161   }
 162   return Runs;
 163 }
 164
 165 static std::pair<Run, uint32_t> findRun(uint32_t Offset, ArrayRef<Run> Runs) {
 166   for (const auto &R : Runs) {
 167     if (Offset < R.ByteLen)
 168       return std::make_pair(R, Offset);
 169     Offset -= R.ByteLen;
 170   }
 171   llvm_unreachable("Invalid offset!");
 172 }
 173
 174 void LinePrinter::formatMsfStreamData(StringRef Label, PDBFile &File,
 175                                       uint32_t StreamIdx,
 176                                       StringRef StreamPurpose, uint32_t Offset,
 177                                       uint32_t Size) {
 178   if (StreamIdx >= File.getNumStreams()) {
 179     formatLine("Stream {0}: Not present", StreamIdx);
 180     return;
 181   }
 182   if (Size + Offset > File.getStreamByteSize(StreamIdx)) {
 183     formatLine(
 184         "Stream {0}: Invalid offset and size, range out of stream bounds",
 185         StreamIdx);
 186     return;
 187   }
 188
 189   auto S = File.createIndexedStream(StreamIdx);
 190   if (!S) {
 191     NewLine();
 192     formatLine("Stream {0}: Not present", StreamIdx);
 193     return;
 194   }
 195
 196   uint32_t End =
 197       (Size == 0) ? S->getLength() : std::min(Offset + Size, S->getLength());
 198   Size = End - Offset;
 199
 200   formatLine("Stream {0}: {1} (dumping {2:N} / {3:N} bytes)", StreamIdx,
 201              StreamPurpose, Size, S->getLength());
 202   AutoIndent Indent(*this);
 203   BinaryStreamRef Slice(*S);
 204   BinarySubstreamRef Substream;
 205   Substream.Offset = Offset;
 206   Substream.StreamData = Slice.drop_front(Offset).keep_front(Size);
 207
 208   auto Layout = File.getStreamLayout(StreamIdx);
 209   formatMsfStreamData(Label, File, Layout, Substream);
 210 }
 211
 212 void LinePrinter::formatMsfStreamData(StringRef Label, PDBFile &File,
 213                                       const msf::MSFStreamLayout &Stream,
 214                                       BinarySubstreamRef Substream) {
 215   BinaryStreamReader Reader(Substream.StreamData);
 216
 217   auto Runs = computeBlockRuns(File.getBlockSize(), Stream);
 218
 219   NewLine();
 220   OS << Label << " (";
 221   while (Reader.bytesRemaining() > 0) {
 222     OS << "\n";
 223
 224     Run FoundRun;
 225     uint32_t RunOffset;
 226     std::tie(FoundRun, RunOffset) = findRun(Substream.Offset, Runs);
 227     assert(FoundRun.ByteLen >= RunOffset);
 228     uint32_t Len = FoundRun.ByteLen - RunOffset;
 229     Len = std::min(Len, Reader.bytesRemaining());
 230     uint64_t Base = FoundRun.Block * File.getBlockSize() + RunOffset;
 231     ArrayRef<uint8_t> Data;
 232     consumeError(Reader.readBytes(Data, Len));
 233     OS << format_bytes_with_ascii(Data, Base, 32, 4,
 234                                   CurrentIndent + IndentSpaces, true);
 235     if (Reader.bytesRemaining() > 0) {
 236       NewLine();
 237       OS << formatv("  {0}",
 238                     fmt_align("<discontinuity>", AlignStyle::Center, 114, '-'));
 239     }
 240     Substream.Offset += Len;
 241   }
 242   NewLine();
 243   OS << ")";
 244 }
 245
 246 void LinePrinter::formatMsfStreamBlocks(
 247     PDBFile &File, const msf::MSFStreamLayout &StreamLayout) {
 248   auto Blocks = makeArrayRef(StreamLayout.Blocks);
 249   uint32_t L = StreamLayout.Length;
 250
 251   while (L > 0) {
 252     NewLine();
 253     assert(!Blocks.empty());
 254     OS << formatv("Block {0} (\n", uint32_t(Blocks.front()));
 255     uint32_t UsedBytes = std::min(L, File.getBlockSize());
 256     ArrayRef<uint8_t> BlockData =
 257         cantFail(File.getBlockData(Blocks.front(), File.getBlockSize()));
 258     uint64_t BaseOffset = Blocks.front();
 259     BaseOffset *= File.getBlockSize();
 260     OS << format_bytes_with_ascii(BlockData, BaseOffset, 32, 4,
 261                                   CurrentIndent + IndentSpaces, true);
 262     NewLine();
 263     OS << ")";
 264     NewLine();
 265     L -= UsedBytes;
 266     Blocks = Blocks.drop_front();
 267   }
 268 }
 269
 270 bool LinePrinter::IsTypeExcluded(llvm::StringRef TypeName, uint32_t Size) {
 271   if (IsItemExcluded(TypeName, IncludeTypeFilters, ExcludeTypeFilters))
 272     return true;
 273   if (Size < opts::pretty::SizeThreshold)
 274     return true;
 275   return false;
 276 }
 277
 278 bool LinePrinter::IsSymbolExcluded(llvm::StringRef SymbolName) {
 279   return IsItemExcluded(SymbolName, IncludeSymbolFilters, ExcludeSymbolFilters);
 280 }
 281
 282 bool LinePrinter::IsCompilandExcluded(llvm::StringRef CompilandName) {
 283   return IsItemExcluded(CompilandName, IncludeCompilandFilters,
 284                         ExcludeCompilandFilters);
 285 }
 286
 287 WithColor::WithColor(LinePrinter &P, PDB_ColorItem C)
 288     : OS(P.OS), UseColor(P.hasColor()) {
 289   if (UseColor)
 290     applyColor(C);
 291 }
 292
 293 WithColor::~WithColor() {
 294   if (UseColor)
 295     OS.resetColor();
 296 }
 297
 298 void WithColor::applyColor(PDB_ColorItem C) {
 299   switch (C) {
 300   case PDB_ColorItem::None:
 301     OS.resetColor();
 302     return;
 303   case PDB_ColorItem::Comment:
 304     OS.changeColor(raw_ostream::GREEN, false);
 305     return;
 306   case PDB_ColorItem::Address:
 307     OS.changeColor(raw_ostream::YELLOW, /*bold=*/true);
 308     return;
 309   case PDB_ColorItem::Keyword:
 310     OS.changeColor(raw_ostream::MAGENTA, true);
 311     return;
 312   case PDB_ColorItem::Register:
 313   case PDB_ColorItem::Offset:
 314     OS.changeColor(raw_ostream::YELLOW, false);
 315     return;
 316   case PDB_ColorItem::Type:
 317     OS.changeColor(raw_ostream::CYAN, true);
 318     return;
 319   case PDB_ColorItem::Identifier:
 320     OS.changeColor(raw_ostream::CYAN, false);
 321     return;
 322   case PDB_ColorItem::Path:
 323     OS.changeColor(raw_ostream::CYAN, false);
 324     return;
 325   case PDB_ColorItem::Padding:
 326   case PDB_ColorItem::SectionHeader:
 327     OS.changeColor(raw_ostream::RED, true);
 328     return;
 329   case PDB_ColorItem::LiteralValue:
 330     OS.changeColor(raw_ostream::GREEN, true);
 331     return;
 332   }
 333 }