clang 24.0.0git
HTMLLogger.cpp
Go to the documentation of this file.
1//===-- HTMLLogger.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 implements the HTML logger. Given a directory dir/, we write
10// dir/0.html for the first analysis, etc.
11// These files contain a visualization that allows inspecting the CFG and the
12// state of the analysis at each point.
13// Static assets (HTMLLogger.js, HTMLLogger.css) and SVG graphs etc are embedded
14// so each output file is self-contained.
15//
16// VIEWS
17//
18// The timeline and function view are always shown. These allow selecting basic
19// blocks, statements within them, and processing iterations (BBs are visited
20// multiple times when e.g. loops are involved).
21// These are written directly into the HTML body.
22//
23// There are also listings of particular basic blocks, and dumps of the state
24// at particular analysis points (i.e. BB2 iteration 3 statement 2).
25// These are only shown when the relevant BB/analysis point is *selected*.
26//
27// DATA AND TEMPLATES
28//
29// The HTML proper is mostly static.
30// The analysis data is in a JSON object HTMLLoggerData which is embedded as
31// a <script> in the <head>.
32// This gets rendered into DOM by a simple template processor which substitutes
33// the data into <template> tags embedded in the HTML. (see inflate() in JS).
34//
35// SELECTION
36//
37// This is the only real interactive mechanism.
38//
39// At any given time, there are several named selections, e.g.:
40// bb: B2 (basic block 0 is selected)
41// elt: B2.4 (statement 4 is selected)
42// iter: B2:1 (iteration 1 of the basic block is selected)
43// hover: B3 (hovering over basic block 3)
44//
45// The selection is updated by mouse events: hover by moving the mouse and
46// others by clicking. Elements that are click targets generally have attributes
47// (id or data-foo) that define what they should select.
48// See watchSelection() in JS for the exact logic.
49//
50// When the "bb" selection is set to "B2":
51// - sections <section data-selection="bb"> get shown
52// - templates under such sections get re-rendered
53// - elements with class/id "B2" get class "bb-select"
54//
55//===----------------------------------------------------------------------===//
56
57#include "clang/Analysis/FlowSensitive/AdornedCFG.h"
58#include "clang/Analysis/FlowSensitive/DebugSupport.h"
59#include "clang/Analysis/FlowSensitive/Logger.h"
60#include "clang/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.h"
61#include "clang/Analysis/FlowSensitive/Value.h"
62#include "clang/Basic/SourceManager.h"
63#include "clang/Lex/Lexer.h"
64#include "llvm/ADT/DenseMap.h"
65#include "llvm/ADT/ScopeExit.h"
66#include "llvm/Support/Error.h"
67#include "llvm/Support/FormatVariadic.h"
68#include "llvm/Support/JSON.h"
69#include "llvm/Support/Path.h"
70#include "llvm/Support/Program.h"
71#include "llvm/Support/ScopedPrinter.h"
72#include "llvm/Support/raw_ostream.h"
73// Defines assets: HTMLLogger_{html_js,css}
74#include "HTMLLogger.inc"
75
76namespace clang::dataflow {
77namespace {
78
79// Render a graphviz graph specification to SVG using the `dot` tool.
80llvm::Expected<std::string> renderSVG(llvm::StringRef DotGraph);
81
82using StreamFactory = std::function<std::unique_ptr<llvm::raw_ostream>()>;
83
84// Recursively dumps Values/StorageLocations as JSON
85class ModelDumper {
86public:
87 ModelDumper(llvm::json::OStream &JOS, const Environment &Env)
88 : JOS(JOS), Env(Env) {}
89
90 void dump(Value &V) {
91 JOS.attribute("value_id", llvm::to_string(&V));
92 if (!Visited.insert(&V).second)
93 return;
94
95 JOS.attribute("kind", debugString(V.getKind()));
96
97 switch (V.getKind()) {
98 case Value::Kind::Integer:
99 case Value::Kind::TopBool:
100 case Value::Kind::AtomicBool:
101 case Value::Kind::FormulaBool:
102 break;
103 case Value::Kind::Pointer:
104 JOS.attributeObject(
105 "pointee", [&] { dump(cast<PointerValue>(V).getPointeeLoc()); });
106 break;
107 }
108
109 for (const auto& Prop : V.properties())
110 JOS.attributeObject(("p:" + Prop.first()).str(),
111 [&] { dump(*Prop.second); });
112
113 // Running the SAT solver is expensive, but knowing which booleans are
114 // guaranteed true/false here is valuable and hard to determine by hand.
115 if (auto *B = llvm::dyn_cast<BoolValue>(&V)) {
116 JOS.attribute("formula", llvm::to_string(B->formula()));
117 JOS.attribute("truth", Env.proves(B->formula()) ? "true"
118 : Env.proves(Env.arena().makeNot(B->formula()))
119 ? "false"
120 : "unknown");
121 }
122 }
123 void dump(const StorageLocation &L) {
124 JOS.attribute("location", llvm::to_string(&L));
125 if (!Visited.insert(&L).second)
126 return;
127
128 JOS.attribute("type", L.getType().getAsString());
129 if (!L.getType()->isRecordType())
130 if (auto *V = Env.getValue(L))
131 dump(*V);
132
133 if (auto *RLoc = dyn_cast<RecordStorageLocation>(&L)) {
134 for (const auto &Child : RLoc->children())
135 JOS.attributeObject("f:" + Child.first->getNameAsString(), [&] {
136 if (Child.second)
137 dump(*Child.second);
138 });
139
140 for (const auto &SyntheticField : RLoc->synthetic_fields())
141 JOS.attributeObject(("sf:" + SyntheticField.first()).str(),
142 [&] { dump(*SyntheticField.second); });
143 }
144 }
145
146 llvm::DenseSet<const void*> Visited;
147 llvm::json::OStream &JOS;
148 const Environment &Env;
149};
150
151class HTMLLogger : public Logger {
152 struct Iteration {
153 const CFGBlock *Block;
154 unsigned Iter;
155 bool PostVisit;
156 bool Converged;
157 };
158
159 StreamFactory Streams;
160 std::unique_ptr<llvm::raw_ostream> OS;
161 std::string JSON;
162 llvm::raw_string_ostream JStringStream{JSON};
163 llvm::json::OStream JOS{JStringStream, /*Indent=*/2};
164
165 const AdornedCFG *ACFG;
166 // Timeline of iterations of CFG block visitation.
167 std::vector<Iteration> Iters;
168 // Indexes in `Iters` of the iterations for each block.
169 llvm::DenseMap<const CFGBlock *, llvm::SmallVector<size_t>> BlockIters;
170 // For a given block ID, did the block converge (on the last iteration)?
171 llvm::BitVector BlockConverged;
172 // The messages logged in the current context but not yet written.
173 std::string ContextLogs;
174 // The number of elements we have visited within the current CFG block.
175 unsigned ElementIndex;
176
177public:
178 explicit HTMLLogger(StreamFactory Streams) : Streams(std::move(Streams)) {}
179 void beginAnalysis(const AdornedCFG &ACFG,
180 TypeErasedDataflowAnalysis &A) override {
181 OS = Streams();
182 this->ACFG = &ACFG;
183 *OS << llvm::StringRef(HTMLLogger_html).split("<?INJECT?>").first;
184
185 BlockConverged.resize(ACFG.getCFG().getNumBlockIDs());
186
187 const auto &D = ACFG.getDecl();
188 const auto &SM = A.getASTContext().getSourceManager();
189 *OS << "<title>";
190 if (const auto *ND = dyn_cast<NamedDecl>(&D))
191 *OS << ND->getNameAsString() << " at ";
192 *OS << SM.getFilename(D.getLocation()) << ":"
193 << SM.getSpellingLineNumber(D.getLocation());
194 *OS << "</title>\n";
195
196 *OS << "<style>" << HTMLLogger_css << "</style>\n";
197 *OS << "<script>" << HTMLLogger_js << "</script>\n";
198
199 writeCode();
200 JOS.objectBegin();
201 JOS.attributeBegin("states");
202 JOS.objectBegin();
203 }
204 // Between beginAnalysis() and endAnalysis() we write all the states for
205 // particular analysis points into the `timeline` array.
206 void endAnalysis() override {
207 JOS.objectEnd();
208 JOS.attributeEnd();
209
210 JOS.attributeArray("timeline", [&] {
211 for (const auto &E : Iters) {
212 JOS.object([&] {
213 JOS.attribute("block", blockID(E.Block->getBlockID()));
214 JOS.attribute("iter", E.Iter);
215 JOS.attribute("post_visit", E.PostVisit);
216 JOS.attribute("converged", E.Converged);
217 });
218 }
219 });
220 JOS.attributeObject("cfg", [&] {
221 for (const auto &E : BlockIters)
222 writeBlock(*E.first, E.second);
223 });
224
225 JOS.objectEnd();
226
227 writeCFG();
228
229 *OS << "<script>var HTMLLoggerData = \n";
230 *OS << JSON;
231 *OS << ";\n</script>\n";
232 *OS << llvm::StringRef(HTMLLogger_html).split("<?INJECT?>").second;
233 }
234
235 void enterBlock(const CFGBlock &B, bool PostVisit) override {
236 llvm::SmallVector<size_t> &BIter = BlockIters[&B];
237 unsigned IterNum = BIter.size() + 1;
238 BIter.push_back(Iters.size());
239 Iters.push_back({&B, IterNum, PostVisit, /*Converged=*/false});
240 if (!PostVisit)
241 BlockConverged[B.getBlockID()] = false;
242 ElementIndex = 0;
243 }
244 void enterElement(const CFGElement &E) override {
245 ++ElementIndex;
246 }
247
248 static std::string blockID(unsigned Block) {
249 return llvm::formatv("B{0}", Block);
250 }
251 static std::string eltID(unsigned Block, unsigned Element) {
252 return llvm::formatv("B{0}.{1}", Block, Element);
253 }
254 static std::string iterID(unsigned Block, unsigned Iter) {
255 return llvm::formatv("B{0}:{1}", Block, Iter);
256 }
257 static std::string elementIterID(unsigned Block, unsigned Iter,
258 unsigned Element) {
259 return llvm::formatv("B{0}:{1}_B{0}.{2}", Block, Iter, Element);
260 }
261
262 // Write the analysis state associated with a particular analysis point.
263 // FIXME: this dump is fairly opaque. We should show:
264 // - values associated with the current Stmt
265 // - values associated with its children
266 // - meaningful names for values
267 // - which boolean values are implied true/false by the flow condition
268 void recordState(TypeErasedDataflowAnalysisState &State) override {
269 unsigned Block = Iters.back().Block->getBlockID();
270 unsigned Iter = Iters.back().Iter;
271 bool PostVisit = Iters.back().PostVisit;
272 JOS.attributeObject(elementIterID(Block, Iter, ElementIndex), [&] {
273 JOS.attribute("block", blockID(Block));
274 JOS.attribute("iter", Iter);
275 JOS.attribute("post_visit", PostVisit);
276 JOS.attribute("element", ElementIndex);
277
278 // If this state immediately follows an Expr, show its built-in model.
279 if (ElementIndex > 0) {
280 auto S =
281 Iters.back().Block->Elements[ElementIndex - 1].getAs<CFGStmt>();
282 if (const Expr *E = S ? llvm::dyn_cast<Expr>(S->getStmt()) : nullptr) {
283 if (E->isPRValue()) {
284 if (!E->getType()->isRecordType())
285 if (auto *V = State.Env.getValue(*E))
286 JOS.attributeObject(
287 "value", [&] { ModelDumper(JOS, State.Env).dump(*V); });
288 } else {
289 if (auto *Loc = State.Env.getStorageLocation(*E))
290 JOS.attributeObject(
291 "value", [&] { ModelDumper(JOS, State.Env).dump(*Loc); });
292 }
293 }
294 }
295 if (!ContextLogs.empty()) {
296 JOS.attribute("logs", ContextLogs);
297 ContextLogs.clear();
298 }
299 {
300 std::string BuiltinLattice;
301 llvm::raw_string_ostream BuiltinLatticeS(BuiltinLattice);
302 State.Env.dump(BuiltinLatticeS);
303 JOS.attribute("builtinLattice", BuiltinLattice);
304 }
305 });
306 }
307 void blockConverged() override {
308 Iters.back().Converged = true;
309 BlockConverged[Iters.back().Block->getBlockID()] = true;
310 }
311
312 void logText(llvm::StringRef S) override {
313 ContextLogs.append(S.begin(), S.end());
314 ContextLogs.push_back('\n');
315 }
316
317private:
318 // Write the CFG block details.
319 // Currently this is just the list of elements in execution order.
320 // FIXME: an AST dump would be a useful view, too.
321 void writeBlock(const CFGBlock &B, llvm::ArrayRef<size_t> ItersForB) {
322 JOS.attributeObject(blockID(B.getBlockID()), [&] {
323 JOS.attributeArray("iters", [&] {
324 for (size_t IterIdx : ItersForB) {
325 const Iteration &Iter = Iters[IterIdx];
326 JOS.object([&] {
327 JOS.attribute("iter", Iter.Iter);
328 JOS.attribute("post_visit", Iter.PostVisit);
329 JOS.attribute("converged", Iter.Converged);
330 });
331 }
332 });
333 JOS.attributeArray("elements", [&] {
334 for (const auto &Elt : B.Elements) {
335 std::string Dump;
336 llvm::raw_string_ostream DumpS(Dump);
337 Elt.dumpToStream(DumpS);
338 JOS.value(Dump);
339 }
340 });
341 });
342 }
343
344 // Write the code of function being examined.
345 // We want to overlay the code with <span>s that mark which BB particular
346 // tokens are associated with, and even which BB element (so that clicking
347 // can select the right element).
348 void writeCode() {
349 const auto &AST = ACFG->getDecl().getASTContext();
350 bool Invalid = false;
351
352 // Extract the source code from the original file.
353 // Pretty-printing from the AST would probably be nicer (no macros or
354 // indentation to worry about), but we need the boundaries of particular
355 // AST nodes and the printer doesn't provide this.
356 auto Range = clang::Lexer::makeFileCharRange(
357 CharSourceRange::getTokenRange(ACFG->getDecl().getSourceRange()),
358 AST.getSourceManager(), AST.getLangOpts());
359 if (Range.isInvalid())
360 return;
361 llvm::StringRef Code = clang::Lexer::getSourceText(
362 Range, AST.getSourceManager(), AST.getLangOpts(), &Invalid);
363 if (Invalid)
364 return;
365
366 // TokenInfo stores the BB and set of elements that a token is part of.
367 struct TokenInfo {
368 enum : unsigned { Missing = static_cast<unsigned>(-1) };
369
370 // The basic block this is part of.
371 // This is the BB of the stmt with the smallest containing range.
372 unsigned BB = Missing;
373 unsigned BBPriority = 0;
374 // The most specific stmt this is part of (smallest range).
375 unsigned Elt = Missing;
376 unsigned EltPriority = 0;
377 // All stmts this is part of.
378 SmallVector<unsigned> Elts;
379
380 // Mark this token as being part of BB.Elt.
381 // RangeLen is the character length of the element's range, used to
382 // distinguish inner vs outer statements.
383 // For example in `a==0`, token "a" is part of the stmts "a" and "a==0".
384 // However "a" has a smaller range, so is more specific. Clicking on the
385 // token "a" should select the stmt "a".
386 void assign(unsigned BB, unsigned Elt, unsigned RangeLen) {
387 // A worse BB (larger range) => ignore.
388 if (this->BB != Missing && BB != this->BB && BBPriority <= RangeLen)
389 return;
390 if (BB != this->BB) {
391 this->BB = BB;
392 Elts.clear();
393 BBPriority = RangeLen;
394 }
395 BBPriority = std::min(BBPriority, RangeLen);
396 Elts.push_back(Elt);
397 if (this->Elt == Missing || EltPriority > RangeLen)
398 this->Elt = Elt;
399 }
400 bool operator==(const TokenInfo &Other) const {
401 return std::tie(BB, Elt, Elts) ==
402 std::tie(Other.BB, Other.Elt, Other.Elts);
403 }
404 // Write the attributes for the <span> on this token.
405 void write(llvm::raw_ostream &OS) const {
406 OS << "class='c";
407 if (BB != Missing)
408 OS << " " << blockID(BB);
409 for (unsigned Elt : Elts)
410 OS << " " << eltID(BB, Elt);
411 OS << "'";
412
413 if (Elt != Missing)
414 OS << " data-elt='" << eltID(BB, Elt) << "'";
415 if (BB != Missing)
416 OS << " data-bb='" << blockID(BB) << "'";
417 }
418 };
419
420 // Construct one TokenInfo per character in a flat array.
421 // This is inefficient (chars in a token all have the same info) but simple.
422 std::vector<TokenInfo> State(Code.size());
423 for (const auto *Block : ACFG->getCFG()) {
424 unsigned EltIndex = 0;
425 for (const auto& Elt : *Block) {
426 ++EltIndex;
427 if (const auto S = Elt.getAs<CFGStmt>()) {
428 auto EltRange = clang::Lexer::makeFileCharRange(
429 CharSourceRange::getTokenRange(S->getStmt()->getSourceRange()),
430 AST.getSourceManager(), AST.getLangOpts());
431 if (EltRange.isInvalid())
432 continue;
433 if (EltRange.getBegin() < Range.getBegin() ||
434 EltRange.getEnd() >= Range.getEnd() ||
435 EltRange.getEnd() < Range.getBegin() ||
436 EltRange.getEnd() >= Range.getEnd())
437 continue;
438 unsigned Off = EltRange.getBegin().getRawEncoding() -
439 Range.getBegin().getRawEncoding();
440 unsigned Len = EltRange.getEnd().getRawEncoding() -
441 EltRange.getBegin().getRawEncoding();
442 for (unsigned I = 0; I < Len; ++I)
443 State[Off + I].assign(Block->getBlockID(), EltIndex, Len);
444 }
445 }
446 }
447
448 // Finally, write the code with the correct <span>s.
449 unsigned Line =
450 AST.getSourceManager().getSpellingLineNumber(Range.getBegin());
451 *OS << "<template data-copy='code'>\n";
452 *OS << "<code class='filename'>";
453 llvm::printHTMLEscaped(
454 llvm::sys::path::filename(
455 AST.getSourceManager().getFilename(Range.getBegin())),
456 *OS);
457 *OS << "</code>";
458 *OS << "<code class='line' data-line='" << Line++ << "'>";
459 for (unsigned I = 0; I < Code.size(); ++I) {
460 // Don't actually write a <span> around each character, only break spans
461 // when the TokenInfo changes.
462 bool NeedOpen = I == 0 || !(State[I] == State[I-1]);
463 bool NeedClose = I + 1 == Code.size() || !(State[I] == State[I + 1]);
464 if (NeedOpen) {
465 *OS << "<span ";
466 State[I].write(*OS);
467 *OS << ">";
468 }
469 if (Code[I] == '\n')
470 *OS << "</code>\n<code class='line' data-line='" << Line++ << "'>";
471 else
472 llvm::printHTMLEscaped(Code.substr(I, 1), *OS);
473 if (NeedClose) *OS << "</span>";
474 }
475 *OS << "</code>\n";
476 *OS << "</template>";
477 }
478
479 // Write the CFG diagram, a graph of basic blocks.
480 // Laying out graphs is hard, so we construct a graphviz description and shell
481 // out to `dot` to turn it into an SVG.
482 void writeCFG() {
483 *OS << "<template data-copy='cfg'>\n";
484 if (auto SVG = renderSVG(buildCFGDot(ACFG->getCFG())))
485 *OS << *SVG;
486 else
487 *OS << "Can't draw CFG: " << toString(SVG.takeError());
488 *OS << "</template>\n";
489 }
490
491 // Produce a graphviz description of a CFG.
492 std::string buildCFGDot(const clang::CFG &CFG) {
493 std::string Graph;
494 llvm::raw_string_ostream GraphS(Graph);
495 // Graphviz likes to add unhelpful tooltips everywhere, " " suppresses.
496 GraphS << R"(digraph {
497 tooltip=" "
498 node[class=bb, shape=square, fontname="sans-serif", tooltip=" "]
499 edge[tooltip = " "]
500)";
501 for (unsigned I = 0; I < CFG.getNumBlockIDs(); ++I) {
502 std::string Name = blockID(I);
503 // Rightwards arrow, vertical line
504 const char *ConvergenceMarker = (const char *)u8"\\n\u2192\u007c";
505 if (BlockConverged[I])
506 Name += ConvergenceMarker;
507 GraphS << " " << blockID(I) << " [id=" << blockID(I) << " label=\""
508 << Name << "\"]\n";
509 }
510 for (const auto *Block : CFG) {
511 for (const auto &Succ : Block->succs()) {
512 if (Succ.getReachableBlock())
513 GraphS << " " << blockID(Block->getBlockID()) << " -> "
514 << blockID(Succ.getReachableBlock()->getBlockID()) << "\n";
515 }
516 }
517 GraphS << "}\n";
518 return Graph;
519 }
520};
521
522// Nothing interesting here, just subprocess/temp-file plumbing.
523llvm::Expected<std::string> renderSVG(llvm::StringRef DotGraph) {
524 std::string DotPath;
525 if (const auto *FromEnv = ::getenv("GRAPHVIZ_DOT"))
526 DotPath = FromEnv;
527 else {
528 auto FromPath = llvm::sys::findProgramByName("dot");
529 if (!FromPath)
530 return llvm::createStringError(FromPath.getError(),
531 "'dot' not found on PATH");
532 DotPath = FromPath.get();
533 }
534
535 // Create input and output files for `dot` subprocess.
536 // (We create the output file as empty, to reserve the temp filename).
537 llvm::SmallString<256> Input, Output;
538 int InputFD;
539 if (auto EC = llvm::sys::fs::createTemporaryFile("analysis", ".dot", InputFD,
540 Input))
541 return llvm::createStringError(EC, "failed to create `dot` temp input");
542 llvm::raw_fd_ostream(InputFD, /*shouldClose=*/true) << DotGraph;
543 llvm::scope_exit DeleteInput([&] { llvm::sys::fs::remove(Input); });
544 if (auto EC = llvm::sys::fs::createTemporaryFile("analysis", ".svg", Output))
545 return llvm::createStringError(EC, "failed to create `dot` temp output");
546 llvm::scope_exit DeleteOutput([&] { llvm::sys::fs::remove(Output); });
547
548 std::vector<std::optional<llvm::StringRef>> Redirects = {
549 Input, Output,
550 /*stderr=*/std::nullopt};
551 std::string ErrMsg;
552 int Code = llvm::sys::ExecuteAndWait(
553 DotPath, {"dot", "-Tsvg"}, /*Env=*/std::nullopt, Redirects,
554 /*SecondsToWait=*/0, /*MemoryLimit=*/0, &ErrMsg);
555 if (!ErrMsg.empty())
556 return llvm::createStringError(llvm::inconvertibleErrorCode(),
557 "'dot' failed: " + ErrMsg);
558 if (Code != 0)
559 return llvm::createStringError(llvm::inconvertibleErrorCode(),
560 "'dot' failed (" + llvm::Twine(Code) + ")");
561
562 auto Buf = llvm::MemoryBuffer::getFile(Output);
563 if (!Buf)
564 return llvm::createStringError(Buf.getError(), "Can't read `dot` output");
565
566 // Output has <?xml> prefix we don't want. Skip to <svg> tag.
567 llvm::StringRef Result = Buf.get()->getBuffer();
568 auto Pos = Result.find("<svg");
569 if (Pos == llvm::StringRef::npos)
570 return llvm::createStringError(llvm::inconvertibleErrorCode(),
571 "Can't find <svg> tag in `dot` output");
572 return Result.substr(Pos).str();
573}
574
575} // namespace
576
577std::unique_ptr<Logger>
578Logger::html(std::function<std::unique_ptr<llvm::raw_ostream>()> Streams) {
579 return std::make_unique<HTMLLogger>(std::move(Streams));
580}
581
582} // namespace clang::dataflow
V
#define V(N, I)
Definition ASTContext.h:3800
dump
static void dump(llvm::raw_ostream &OS, StringRef FunctionName, ArrayRef< CounterExpression > Expressions, ArrayRef< CounterMappingRegion > Regions)
Definition CoverageMappingGen.cpp:2436
toString
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
Definition SanitizerArgs.cpp:1364
SourceManager.h
Defines the SourceManager interface.
clang::CFG::getNumBlockIDs
unsigned getNumBlockIDs() const
Returns the total number of BlockIDs allocated (which start at 0).
Definition CFG.h:1464
clang::CharSourceRange::getTokenRange
static CharSourceRange getTokenRange(SourceRange R)
Definition SourceLocation.h:284
clang::Lexer::getSourceText
static StringRef getSourceText(CharSourceRange Range, const SourceManager &SM, const LangOptions &LangOpts, bool *Invalid=nullptr)
Returns a string for the source that the range encompasses.
Definition Lexer.cpp:1075
clang::Lexer::makeFileCharRange
static CharSourceRange makeFileCharRange(CharSourceRange Range, const SourceManager &SM, const LangOptions &LangOpts)
Accepts a range and returns a character range with file locations.
Definition Lexer.cpp:1006
clang::dataflow::Logger
A logger is notified as the analysis progresses.
Definition Logger.h:27
clang::dataflow::Logger::html
static std::unique_ptr< Logger > html(std::function< std::unique_ptr< llvm::raw_ostream >()>)
A logger that builds an HTML UI to inspect the analysis results.
Definition HTMLLogger.cpp:578
clang::dataflow
Dataflow Directional Tag Classes.
Definition AdornedCFG.h:29
clang::dataflow::debugString
llvm::StringRef debugString(Value::Kind Kind)
Returns a string representation of a value kind.
Definition DebugSupport.cpp:25
clang::ento::ObjKind::OS
@ OS
Indicates that the tracking object is a descendant of a referenced-counted OSObject,...
Definition RetainSummaryManager.h:51
clang::interp::Dump
bool Dump(InterpState &S)
Definition Interp.h:2141
clang::threadSafety::til::operator==
bool operator==(const ValueType &a, const ValueType &b)
Definition ThreadSafetyTIL.h:169
clang::ObjCSubstitutionContext::Result
@ Result
The result type of a method or function.
Definition TypeBase.h:906
clang::ShowColorsKind::Off
@ Off
Never emit colors regardless of the output stream.
Definition DiagnosticOptions.h:33
clang::cast
U cast(CodeGen::Address addr)
Definition Address.h:327
clang::ImplicitParamKind::Other
@ Other
Other implicit parameter.
Definition Decl.h:1774
std::function
int const char * function
Definition c++config.h:31
Generated on for clang by doxygen 1.14.0