LinePrinter.cpp Source File (original) (raw)

26#include

28using namespace llvm;

32namespace {

34 std::listllvm::Regex &IncludeFilters,

35 std::listllvm::Regex &ExcludeFilters) {

37 return false;

39 auto match_pred = [Item](llvm::Regex &R) { return R.match(Item); };

43 if (!IncludeFilters.empty() && $any\_of$ (IncludeFilters, match_pred))

44 return true;

46 if (any_of(ExcludeFilters, match_pred))

47 return true;

49 return false;

50}

51}

53using namespace llvm;

57 : OS(Stream), IndentSpaces(Indent), CurrentIndent(0), UseColor(UseColor),

58 Filters(Filters) {

59 SetFilters(ExcludeTypeFilters, Filters.ExcludeTypes.begin(),

60 Filters.ExcludeTypes.end());

61 SetFilters(ExcludeSymbolFilters, Filters.ExcludeSymbols.begin(),

62 Filters.ExcludeSymbols.end());

63 SetFilters(ExcludeCompilandFilters, Filters.ExcludeCompilands.begin(),

64 Filters.ExcludeCompilands.end());

66 SetFilters(IncludeTypeFilters, Filters.IncludeTypes.begin(),

67 Filters.IncludeTypes.end());

68 SetFilters(IncludeSymbolFilters, Filters.IncludeSymbols.begin(),

69 Filters.IncludeSymbols.end());

70 SetFilters(IncludeCompilandFilters, Filters.IncludeCompilands.begin(),

71 Filters.IncludeCompilands.end());

72}

75 if (Amount == 0)

76 Amount = IndentSpaces;

77 CurrentIndent += Amount;

78}

81 if (Amount == 0)

82 Amount = IndentSpaces;

83 CurrentIndent = std::max(0, CurrentIndent - Amount);

84}

87 OS << "\n";

88 OS.indent(CurrentIndent);

89}

100 return true;

101 if (Class.deepPaddingSize() < Filters.PaddingThreshold)

102 return true;

103 return false;

104}

105

109 OS << Label << " (";

110 if ( Data .empty()) {

111 OS << "\n";

113 CurrentIndent + IndentSpaces, true);

115 }

116 OS << ")";

117}

118

122 OS << Label << " (";

123 if ( Data .empty()) {

124 OS << "\n";

125 Base += StartOffset;

127 CurrentIndent + IndentSpaces, true);

129 }

130 OS << ")";

131}

132

133namespace {

134struct Run {

135 Run() = default;

139};

140}

141

144 std::vector Runs;

145 if (Layout.Length == 0)

146 return Runs;

147

151 uint32_t CurrentBlock = Blocks[0];

152 Runs.emplace_back(CurrentBlock);

153 while (!Blocks.empty()) {

154 Run *CurrentRun = &Runs.back();

156 if (NextBlock < CurrentBlock || (NextBlock - CurrentBlock > 1)) {

157 Runs.emplace_back(NextBlock);

158 CurrentRun = &Runs.back();

159 }

161 std::min(static_cast<uint64_t>(BlockSize), StreamBytesRemaining);

162 CurrentRun->ByteLen += Used;

163 StreamBytesRemaining -= Used;

164 CurrentBlock = NextBlock;

166 }

167 return Runs;

168}

169

171 for (const auto &R : Runs) {

172 if (Offset < R.ByteLen)

173 return std::make_pair(R, Offset);

175 }

177}

178

183 if (StreamIdx >= File.getNumStreams()) {

184 formatLine("Stream {0}: Not present", StreamIdx);

185 return;

186 }

187 if (Size + Offset > File.getStreamByteSize(StreamIdx)) {

189 "Stream {0}: Invalid offset and size, range out of stream bounds",

190 StreamIdx);

191 return;

192 }

193

194 auto S = File.createIndexedStream(StreamIdx);

195 if (!S) {

197 formatLine("Stream {0}: Not present", StreamIdx);

198 return;

199 }

200

202 (Size == 0) ? S->getLength() : std::min(Offset + Size, S->getLength());

204

205 formatLine("Stream {0}: {1} (dumping {2:N} / {3:N} bytes)", StreamIdx,

206 StreamPurpose, Size, S->getLength());

212

213 auto Layout = File.getStreamLayout(StreamIdx);

215}

216

221

223

225 OS << Label << " (";

227 OS << "\n";

228

229 Run FoundRun;

231 std::tie(FoundRun, RunOffset) = findRun(Substream.Offset, Runs);

232 assert(FoundRun.ByteLen >= RunOffset);

233 uint64_t Len = FoundRun.ByteLen - RunOffset;

235 uint64_t Base = FoundRun.Block * File.getBlockSize() + RunOffset;

239 CurrentIndent + IndentSpaces, true);

244 }

245 Substream.Offset += Len;

246 }

248 OS << ")";

249}

250

255

256 while (L > 0) {

258 assert(!Blocks.empty());

259 OS << formatv("Block {0} (\n", uint32_t(Blocks.front()));

261 std::min(L, static_cast<uint64_t>(File.getBlockSize()));

263 cantFail(File.getBlockData(Blocks.front(), File.getBlockSize()));

264 uint64_t BaseOffset = Blocks.front();

265 BaseOffset *= File.getBlockSize();

267 CurrentIndent + IndentSpaces, true);

269 OS << ")";

271 L -= UsedBytes;

272 Blocks = Blocks.drop_front();

273 }

274}

275

277 if (IsItemExcluded(TypeName, IncludeTypeFilters, ExcludeTypeFilters))

278 return true;

279 if (Size < Filters.SizeThreshold)

280 return true;

281 return false;

282}

283

285 return IsItemExcluded(SymbolName, IncludeSymbolFilters, ExcludeSymbolFilters);

286}

287

289 return IsItemExcluded(CompilandName, IncludeCompilandFilters,

290 ExcludeCompilandFilters);

291}

292

294 : OS(P.OS), UseColor(P.hasColor()) {

295 if (UseColor)

296 applyColor(C);

297}

298

300 if (UseColor)

301 OS.resetColor();

302}

303

305 switch (C) {

308 return;

311 return;

314 return;

317 return;

321 return;

324 return;

327 return;

330 return;

334 return;

337 return;

338 }

339}

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

static std::pair< Run, uint64_t > findRun(uint64_t Offset, ArrayRef< Run > Runs)

Definition LinePrinter.cpp:170

static std::vector< Run > computeBlockRuns(uint32_t BlockSize, const msf::MSFStreamLayout &Layout)

Definition LinePrinter.cpp:142

static const int BlockSize

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

ArrayRef< T > drop_front(size_t N=1) const

Drop the first N elements of the array.

const T & front() const

front - Get the first element.

bool empty() const

empty - Check if the array is empty.

Provides read only access to a subclass of BinaryStream.

LLVM_ABI Error readBytes(ArrayRef< uint8_t > &Buffer, uint32_t Size)

Read Size bytes from the underlying stream at the current offset and and set Buffer to the resulting ...

uint64_t bytesRemaining() const

RefType drop_front(uint64_t N) const

Return a new BinaryStreamRef with the first N elements removed.

RefType keep_front(uint64_t N) const

Return a new BinaryStreamRef with only the first N elements remaining.

BinaryStreamRef is to BinaryStream what ArrayRef is to an Array.

StringRef - Represent a constant reference to a string, i.e.

constexpr bool empty() const

empty - Check if the string is empty.

Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...

Describes the layout of a stream in an MSF layout.

std::vector< support::ulittle32_t > Blocks

LLVM_ABI void print(const Twine &T)

Definition LinePrinter.cpp:91

LLVM_ABI void printLine(const Twine &T)

Definition LinePrinter.cpp:93

LLVM_ABI void Unindent(uint32_t Amount=0)

Definition LinePrinter.cpp:80

LLVM_ABI void NewLine()

Definition LinePrinter.cpp:86

LLVM_ABI void formatMsfStreamData(StringRef Label, PDBFile &File, uint32_t StreamIdx, StringRef StreamPurpose, uint64_t Offset, uint64_t Size)

Definition LinePrinter.cpp:179

LLVM_ABI bool IsSymbolExcluded(llvm::StringRef SymbolName)

Definition LinePrinter.cpp:284

LLVM_ABI LinePrinter(int Indent, bool UseColor, raw_ostream &Stream, const FilterOptions &Filters)

Definition LinePrinter.cpp:55

LLVM_ABI void formatMsfStreamBlocks(PDBFile &File, const msf::MSFStreamLayout &Stream)

Definition LinePrinter.cpp:251

void formatLine(const char *Fmt, Ts &&...Items)

LLVM_ABI void formatBinary(StringRef Label, ArrayRef< uint8_t > Data, uint64_t StartOffset)

Definition LinePrinter.cpp:106

LLVM_ABI bool IsTypeExcluded(llvm::StringRef TypeName, uint64_t Size)

Definition LinePrinter.cpp:276

LLVM_ABI bool IsClassExcluded(const ClassLayout &Class)

Definition LinePrinter.cpp:98

LLVM_ABI bool IsCompilandExcluded(llvm::StringRef CompilandName)

Definition LinePrinter.cpp:288

LLVM_ABI void Indent(uint32_t Amount=0)

Definition LinePrinter.cpp:74

LLVM_ABI ~WithColor()

Definition LinePrinter.cpp:299

LLVM_ABI WithColor(LinePrinter &P, PDB_ColorItem C)

Definition LinePrinter.cpp:293

This class implements an extremely fast bulk output stream that can only output to a stream.

virtual raw_ostream & changeColor(enum Colors Color, bool Bold=false, bool BG=false)

Changes the foreground color of text that will be output from this point forward.

virtual raw_ostream & resetColor()

Resets the colors to terminal defaults.

static constexpr Colors GREEN

static constexpr Colors RED

static constexpr Colors MAGENTA

static constexpr Colors YELLOW

static constexpr Colors CYAN

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

@ C

The default llvm calling convention, compatible with C.

This is an optimization pass for GlobalISel generic memory operations.

bool any_of(R &&range, UnaryPredicate P)

Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.

auto formatv(bool Validate, const char *Fmt, Ts &&...Vals)

void cantFail(Error Err, const char *Msg=nullptr)

Report a fatal error if Err is a failure value.

FormattedBytes format_bytes_with_ascii(ArrayRef< uint8_t > Bytes, std::optional< uint64_t > FirstByteOffset=std::nullopt, uint32_t NumPerLine=16, uint8_t ByteGroupSize=4, uint32_t IndentLevel=0, bool Upper=false)

ArrayRef(const T &OneElt) -> ArrayRef< T >

support::detail::AlignAdapter< T > fmt_align(T &&Item, AlignStyle Where, size_t Amount, char Fill=' ')

void consumeError(Error Err)

Consume a Error without doing anything.

BinaryStreamRef StreamData