clang-tools 10.0.0

PPCallbacksTracker.cpp
Go to the documentation of this file.
1 //===--- PPCallbacksTracker.cpp - Preprocessor tracker -*--*---------------===//
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 /// \file
10 /// Implementations for preprocessor tracking.
11 ///
12 /// See the header for details.
13 ///
14 //===----------------------------------------------------------------------===//
15
16 #include "PPCallbacksTracker.h"
17 #include "clang/Lex/MacroArgs.h"
18 #include "llvm/Support/raw_ostream.h"
19
20 namespace clang {
21 namespace pp_trace {
22
23 // Get a "file:line:column" source location string.
24 static std::string getSourceLocationString(Preprocessor &PP,
25 SourceLocation Loc) {
26 if (Loc.isInvalid())
27 return std::string("(none)");
28
29 if (Loc.isFileID()) {
30 PresumedLoc PLoc = PP.getSourceManager().getPresumedLoc(Loc);
31
32 if (PLoc.isInvalid()) {
33 return std::string("(invalid)");
34 }
35
36 std::string Str;
37 llvm::raw_string_ostream SS(Str);
38
39 // The macro expansion and spelling pos is identical for file locs.
40 SS << "\"" << PLoc.getFilename() << ':' << PLoc.getLine() << ':'
41 << PLoc.getColumn() << "\"";
42
43 std::string Result = SS.str();
44
45 // YAML treats backslash as escape, so use forward slashes.
46 std::replace(Result.begin(), Result.end(), '\\', '/');
47
48 return Result;
49 }
50
51 return std::string("(nonfile)");
52 }
53
54 // Enum string tables.
55
56 // FileChangeReason strings.
57 static const char *const FileChangeReasonStrings[] = {
58 "EnterFile", "ExitFile", "SystemHeaderPragma", "RenameFile"
59 };
60
61 // CharacteristicKind strings.
62 static const char *const CharacteristicKindStrings[] = { "C_User", "C_System",
63 "C_ExternCSystem" };
64
65 // MacroDirective::Kind strings.
66 static const char *const MacroDirectiveKindStrings[] = {
67 "MD_Define","MD_Undefine", "MD_Visibility"
68 };
69
70 // PragmaIntroducerKind strings.
71 static const char *const PragmaIntroducerKindStrings[] = { "PIK_HashPragma",
72 "PIK__Pragma",
73 "PIK___pragma" };
74
75 // PragmaMessageKind strings.
76 static const char *const PragmaMessageKindStrings[] = {
77 "PMK_Message", "PMK_Warning", "PMK_Error"
78 };
79
80 // ConditionValueKind strings.
81 static const char *const ConditionValueKindStrings[] = {
82 "CVK_NotEvaluated", "CVK_False", "CVK_True"
83 };
84
85 // Mapping strings.
86 static const char *const MappingStrings[] = { "0", "MAP_IGNORE",
87 "MAP_REMARK", "MAP_WARNING",
88 "MAP_ERROR", "MAP_FATAL" };
89
90 // PPCallbacksTracker functions.
91
92 PPCallbacksTracker::PPCallbacksTracker(const FilterType &Filters,
93 std::vector<CallbackCall> &CallbackCalls,
94 Preprocessor &PP)
95 : CallbackCalls(CallbackCalls), Filters(Filters), PP(PP) {}
96
97 PPCallbacksTracker::~PPCallbacksTracker() {}
98
99 // Callback functions.
100
101 // Callback invoked whenever a source file is entered or exited.
102 void PPCallbacksTracker::FileChanged(SourceLocation Loc,
103 PPCallbacks::FileChangeReason Reason,
104 SrcMgr::CharacteristicKind FileType,
105 FileID PrevFID) {
106 beginCallback("FileChanged");
107 appendArgument("Loc", Loc);
108 appendArgument("Reason", Reason, FileChangeReasonStrings);
109 appendArgument("FileType", FileType, CharacteristicKindStrings);
110 appendArgument("PrevFID", PrevFID);
111 }
112
113 // Callback invoked whenever a source file is skipped as the result
114 // of header guard optimization.
115 void PPCallbacksTracker::FileSkipped(const FileEntryRef &SkippedFile,
116 const Token &FilenameTok,
117 SrcMgr::CharacteristicKind FileType) {
118 beginCallback("FileSkipped");
119 appendArgument("ParentFile", &SkippedFile.getFileEntry());
120 appendArgument("FilenameTok", FilenameTok);
121 appendArgument("FileType", FileType, CharacteristicKindStrings);
122 }
123
124 // Callback invoked whenever an inclusion directive results in a
125 // file-not-found error.
126 bool
127 PPCallbacksTracker::FileNotFound(llvm::StringRef FileName,
128 llvm::SmallVectorImpl<char> &RecoveryPath) {
129 beginCallback("FileNotFound");
130 appendFilePathArgument("FileName", FileName);
131 return false;
132 }
133
134 // Callback invoked whenever an inclusion directive of
135 // any kind (#include, #import, etc.) has been processed, regardless
136 // of whether the inclusion will actually result in an inclusion.
137 void PPCallbacksTracker::InclusionDirective(
138 SourceLocation HashLoc, const Token &IncludeTok, llvm::StringRef FileName,
139 bool IsAngled, CharSourceRange FilenameRange, const FileEntry *File,
140 llvm::StringRef SearchPath, llvm::StringRef RelativePath,
141 const Module *Imported, SrcMgr::CharacteristicKind FileType) {
142 beginCallback("InclusionDirective");
143 appendArgument("IncludeTok", IncludeTok);
144 appendFilePathArgument("FileName", FileName);
145 appendArgument("IsAngled", IsAngled);
146 appendArgument("FilenameRange", FilenameRange);
147 appendArgument("File", File);
148 appendFilePathArgument("SearchPath", SearchPath);
149 appendFilePathArgument("RelativePath", RelativePath);
150 appendArgument("Imported", Imported);
151 }
152
153 // Callback invoked whenever there was an explicit module-import
154 // syntax.
155 void PPCallbacksTracker::moduleImport(SourceLocation ImportLoc,
156 ModuleIdPath Path,
157 const Module *Imported) {
158 beginCallback("moduleImport");
159 appendArgument("ImportLoc", ImportLoc);
160 appendArgument("Path", Path);
161 appendArgument("Imported", Imported);
162 }
163
164 // Callback invoked when the end of the main file is reached.
165 // No subsequent callbacks will be made.
166 void PPCallbacksTracker::EndOfMainFile() { beginCallback("EndOfMainFile"); }
167
168 // Callback invoked when a #ident or #sccs directive is read.
169 void PPCallbacksTracker::Ident(SourceLocation Loc, llvm::StringRef Str) {
170 beginCallback("Ident");
171 appendArgument("Loc", Loc);
172 appendArgument("Str", Str);
173 }
174
175 // Callback invoked when start reading any pragma directive.
176 void PPCallbacksTracker::PragmaDirective(SourceLocation Loc,
177 PragmaIntroducerKind Introducer) {
178 beginCallback("PragmaDirective");
179 appendArgument("Loc", Loc);
180 appendArgument("Introducer", Introducer, PragmaIntroducerKindStrings);
181 }
182
183 // Callback invoked when a #pragma comment directive is read.
184 void PPCallbacksTracker::PragmaComment(SourceLocation Loc,
185 const IdentifierInfo *Kind,
186 llvm::StringRef Str) {
187 beginCallback("PragmaComment");
188 appendArgument("Loc", Loc);
189 appendArgument("Kind", Kind);
190 appendArgument("Str", Str);
191 }
192
193 // Callback invoked when a #pragma detect_mismatch directive is
194 // read.
195 void PPCallbacksTracker::PragmaDetectMismatch(SourceLocation Loc,
196 llvm::StringRef Name,
197 llvm::StringRef Value) {
198 beginCallback("PragmaDetectMismatch");
199 appendArgument("Loc", Loc);
200 appendArgument("Name", Name);
201 appendArgument("Value", Value);
202 }
203
204 // Callback invoked when a #pragma clang __debug directive is read.
205 void PPCallbacksTracker::PragmaDebug(SourceLocation Loc,
206 llvm::StringRef DebugType) {
207 beginCallback("PragmaDebug");
208 appendArgument("Loc", Loc);
209 appendArgument("DebugType", DebugType);
210 }
211
212 // Callback invoked when a #pragma message directive is read.
213 void PPCallbacksTracker::PragmaMessage(SourceLocation Loc,
214 llvm::StringRef Namespace,
215 PPCallbacks::PragmaMessageKind Kind,
216 llvm::StringRef Str) {
217 beginCallback("PragmaMessage");
218 appendArgument("Loc", Loc);
219 appendArgument("Namespace", Namespace);
220 appendArgument("Kind", Kind, PragmaMessageKindStrings);
221 appendArgument("Str", Str);
222 }
223
224 // Callback invoked when a #pragma gcc diagnostic push directive
225 // is read.
226 void PPCallbacksTracker::PragmaDiagnosticPush(SourceLocation Loc,
227 llvm::StringRef Namespace) {
228 beginCallback("PragmaDiagnosticPush");
229 appendArgument("Loc", Loc);
230 appendArgument("Namespace", Namespace);
231 }
232
233 // Callback invoked when a #pragma gcc diagnostic pop directive
234 // is read.
235 void PPCallbacksTracker::PragmaDiagnosticPop(SourceLocation Loc,
236 llvm::StringRef Namespace) {
237 beginCallback("PragmaDiagnosticPop");
238 appendArgument("Loc", Loc);
239 appendArgument("Namespace", Namespace);
240 }
241
242 // Callback invoked when a #pragma gcc diagnostic directive is read.
243 void PPCallbacksTracker::PragmaDiagnostic(SourceLocation Loc,
244 llvm::StringRef Namespace,
245 diag::Severity Mapping,
246 llvm::StringRef Str) {
247 beginCallback("PragmaDiagnostic");
248 appendArgument("Loc", Loc);
249 appendArgument("Namespace", Namespace);
250 appendArgument("Mapping", (unsigned)Mapping, MappingStrings);
251 appendArgument("Str", Str);
252 }
253
254 // Called when an OpenCL extension is either disabled or
255 // enabled with a pragma.
256 void PPCallbacksTracker::PragmaOpenCLExtension(SourceLocation NameLoc,
257 const IdentifierInfo *Name,
258 SourceLocation StateLoc,
259 unsigned State) {
260 beginCallback("PragmaOpenCLExtension");
261 appendArgument("NameLoc", NameLoc);
262 appendArgument("Name", Name);
263 appendArgument("StateLoc", StateLoc);
264 appendArgument("State", (int)State);
265 }
266
267 // Callback invoked when a #pragma warning directive is read.
268 void PPCallbacksTracker::PragmaWarning(SourceLocation Loc,
269 llvm::StringRef WarningSpec,
270 llvm::ArrayRef<int> Ids) {
271 beginCallback("PragmaWarning");
272 appendArgument("Loc", Loc);
273 appendArgument("WarningSpec", WarningSpec);
274
275 std::string Str;
276 llvm::raw_string_ostream SS(Str);
277 SS << "[";
278 for (int i = 0, e = Ids.size(); i != e; ++i) {
279 if (i)
280 SS << ", ";
281 SS << Ids[i];
282 }
283 SS << "]";
284 appendArgument("Ids", SS.str());
285 }
286
287 // Callback invoked when a #pragma warning(push) directive is read.
288 void PPCallbacksTracker::PragmaWarningPush(SourceLocation Loc, int Level) {
289 beginCallback("PragmaWarningPush");
290 appendArgument("Loc", Loc);
291 appendArgument("Level", Level);
292 }
293
294 // Callback invoked when a #pragma warning(pop) directive is read.
295 void PPCallbacksTracker::PragmaWarningPop(SourceLocation Loc) {
296 beginCallback("PragmaWarningPop");
297 appendArgument("Loc", Loc);
298 }
299
300 // Callback invoked when a #pragma execution_character_set(push) directive
301 // is read.
302 void PPCallbacksTracker::PragmaExecCharsetPush(SourceLocation Loc,
303 StringRef Str) {
304 beginCallback("PragmaExecCharsetPush");
305 appendArgument("Loc", Loc);
306 appendArgument("Charset", Str);
307 }
308
309 // Callback invoked when a #pragma execution_character_set(pop) directive
310 // is read.
311 void PPCallbacksTracker::PragmaExecCharsetPop(SourceLocation Loc) {
312 beginCallback("PragmaExecCharsetPop");
313 appendArgument("Loc", Loc);
314 }
315
316 // Called by Preprocessor::HandleMacroExpandedIdentifier when a
317 // macro invocation is found.
318 void PPCallbacksTracker::MacroExpands(const Token &MacroNameTok,
319 const MacroDefinition &MacroDefinition,
320 SourceRange Range,
321 const MacroArgs *Args) {
322 beginCallback("MacroExpands");
323 appendArgument("MacroNameTok", MacroNameTok);
324 appendArgument("MacroDefinition", MacroDefinition);
325 appendArgument("Range", Range);
326 appendArgument("Args", Args);
327 }
328
329 // Hook called whenever a macro definition is seen.
330 void PPCallbacksTracker::MacroDefined(const Token &MacroNameTok,
331 const MacroDirective *MacroDirective) {
332 beginCallback("MacroDefined");
333 appendArgument("MacroNameTok", MacroNameTok);
334 appendArgument("MacroDirective", MacroDirective);
335 }
336
337 // Hook called whenever a macro #undef is seen.
338 void PPCallbacksTracker::MacroUndefined(const Token &MacroNameTok,
339 const MacroDefinition &MacroDefinition,
340 const MacroDirective *Undef) {
341 beginCallback("MacroUndefined");
342 appendArgument("MacroNameTok", MacroNameTok);
343 appendArgument("MacroDefinition", MacroDefinition);
344 }
345
346 // Hook called whenever the 'defined' operator is seen.
347 void PPCallbacksTracker::Defined(const Token &MacroNameTok,
348 const MacroDefinition &MacroDefinition,
349 SourceRange Range) {
350 beginCallback("Defined");
351 appendArgument("MacroNameTok", MacroNameTok);
352 appendArgument("MacroDefinition", MacroDefinition);
353 appendArgument("Range", Range);
354 }
355
356 // Hook called when a source range is skipped.
357 void PPCallbacksTracker::SourceRangeSkipped(SourceRange Range,
358 SourceLocation EndifLoc) {
359 beginCallback("SourceRangeSkipped");
360 appendArgument("Range", SourceRange(Range.getBegin(), EndifLoc));
361 }
362
363 // Hook called whenever an #if is seen.
364 void PPCallbacksTracker::If(SourceLocation Loc, SourceRange ConditionRange,
365 ConditionValueKind ConditionValue) {
366 beginCallback("If");
367 appendArgument("Loc", Loc);
368 appendArgument("ConditionRange", ConditionRange);
369 appendArgument("ConditionValue", ConditionValue, ConditionValueKindStrings);
370 }
371
372 // Hook called whenever an #elif is seen.
373 void PPCallbacksTracker::Elif(SourceLocation Loc, SourceRange ConditionRange,
374 ConditionValueKind ConditionValue,
375 SourceLocation IfLoc) {
376 beginCallback("Elif");
377 appendArgument("Loc", Loc);
378 appendArgument("ConditionRange", ConditionRange);
379 appendArgument("ConditionValue", ConditionValue, ConditionValueKindStrings);
380 appendArgument("IfLoc", IfLoc);
381 }
382
383 // Hook called whenever an #ifdef is seen.
384 void PPCallbacksTracker::Ifdef(SourceLocation Loc, const Token &MacroNameTok,
385 const MacroDefinition &MacroDefinition) {
386 beginCallback("Ifdef");
387 appendArgument("Loc", Loc);
388 appendArgument("MacroNameTok", MacroNameTok);
389 appendArgument("MacroDefinition", MacroDefinition);
390 }
391
392 // Hook called whenever an #ifndef is seen.
393 void PPCallbacksTracker::Ifndef(SourceLocation Loc, const Token &MacroNameTok,
394 const MacroDefinition &MacroDefinition) {
395 beginCallback("Ifndef");
396 appendArgument("Loc", Loc);
397 appendArgument("MacroNameTok", MacroNameTok);
398 appendArgument("MacroDefinition", MacroDefinition);
399 }
400
401 // Hook called whenever an #else is seen.
402 void PPCallbacksTracker::Else(SourceLocation Loc, SourceLocation IfLoc) {
403 beginCallback("Else");
404 appendArgument("Loc", Loc);
405 appendArgument("IfLoc", IfLoc);
406 }
407
408 // Hook called whenever an #endif is seen.
409 void PPCallbacksTracker::Endif(SourceLocation Loc, SourceLocation IfLoc) {
410 beginCallback("Endif");
411 appendArgument("Loc", Loc);
412 appendArgument("IfLoc", IfLoc);
413 }
414
415 // Helper functions.
416
417 // Start a new callback.
418 void PPCallbacksTracker::beginCallback(const char *Name) {
419 auto R = CallbackIsEnabled.try_emplace(Name, false);
420 if (R.second) {
421 llvm::StringRef N(Name);
422 for (const std::pair<llvm::GlobPattern, bool> &Filter : Filters)
423 if (Filter.first.match(N))
424 R.first->second = Filter.second;
425 }
426 DisableTrace = !R.first->second;
427 if (DisableTrace)
428 return;
429 CallbackCalls.push_back(CallbackCall(Name));
430 }
431
432 // Append a bool argument to the top trace item.
433 void PPCallbacksTracker::appendArgument(const char *Name, bool Value) {
434 appendArgument(Name, (Value ? "true" : "false"));
435 }
436
437 // Append an int argument to the top trace item.
438 void PPCallbacksTracker::appendArgument(const char *Name, int Value) {
439 std::string Str;
440 llvm::raw_string_ostream SS(Str);
441 SS << Value;
442 appendArgument(Name, SS.str());
443 }
444
445 // Append a string argument to the top trace item.
446 void PPCallbacksTracker::appendArgument(const char *Name, const char *Value) {
447 if (DisableTrace)
448 return;
449 CallbackCalls.back().Arguments.push_back(Argument{Name, Value});
450 }
451
452 // Append a string object argument to the top trace item.
453 void PPCallbacksTracker::appendArgument(const char *Name,
454 llvm::StringRef Value) {
455 appendArgument(Name, Value.str());
456 }
457
458 // Append a string object argument to the top trace item.
459 void PPCallbacksTracker::appendArgument(const char *Name,
460 const std::string &Value) {
461 appendArgument(Name, Value.c_str());
462 }
463
464 // Append a token argument to the top trace item.
465 void PPCallbacksTracker::appendArgument(const char *Name, const Token &Value) {
466 appendArgument(Name, PP.getSpelling(Value));
467 }
468
469 // Append an enum argument to the top trace item.
470 void PPCallbacksTracker::appendArgument(const char *Name, int Value,
471 const char *const Strings[]) {
472 appendArgument(Name, Strings[Value]);
473 }
474
475 // Append a FileID argument to the top trace item.
476 void PPCallbacksTracker::appendArgument(const char *Name, FileID Value) {
477 if (Value.isInvalid()) {
478 appendArgument(Name, "(invalid)");
479 return;
480 }
481 const FileEntry *FileEntry = PP.getSourceManager().getFileEntryForID(Value);
482 if (!FileEntry) {
483 appendArgument(Name, "(getFileEntryForID failed)");
484 return;
485 }
486 appendFilePathArgument(Name, FileEntry->getName());
487 }
488
489 // Append a FileEntry argument to the top trace item.
490 void PPCallbacksTracker::appendArgument(const char *Name,
491 const FileEntry *Value) {
492 if (!Value) {
493 appendArgument(Name, "(null)");
494 return;
495 }
496 appendFilePathArgument(Name, Value->getName());
497 }
498
499 // Append a SourceLocation argument to the top trace item.
500 void PPCallbacksTracker::appendArgument(const char *Name,
501 SourceLocation Value) {
502 if (Value.isInvalid()) {
503 appendArgument(Name, "(invalid)");
504 return;
505 }
506 appendArgument(Name, getSourceLocationString(PP, Value).c_str());
507 }
508
509 // Append a SourceRange argument to the top trace item.
510 void PPCallbacksTracker::appendArgument(const char *Name, SourceRange Value) {
511 if (DisableTrace)
512 return;
513 if (Value.isInvalid()) {
514 appendArgument(Name, "(invalid)");
515 return;
516 }
517 std::string Str;
518 llvm::raw_string_ostream SS(Str);
519 SS << "[" << getSourceLocationString(PP, Value.getBegin()) << ", "
520 << getSourceLocationString(PP, Value.getEnd()) << "]";
521 appendArgument(Name, SS.str());
522 }
523
524 // Append a CharSourceRange argument to the top trace item.
525 void PPCallbacksTracker::appendArgument(const char *Name,
526 CharSourceRange Value) {
527 if (Value.isInvalid()) {
528 appendArgument(Name, "(invalid)");
529 return;
530 }
531 appendArgument(Name, getSourceString(Value).str().c_str());
532 }
533
534 // Append a SourceLocation argument to the top trace item.
535 void PPCallbacksTracker::appendArgument(const char *Name, ModuleIdPath Value) {
536 if (DisableTrace)
537 return;
538 std::string Str;
539 llvm::raw_string_ostream SS(Str);
540 SS << "[";
541 for (int I = 0, E = Value.size(); I != E; ++I) {
542 if (I)
543 SS << ", ";
544 SS << "{"
545 << "Name: " << Value[I].first->getName() << ", "
546 << "Loc: " << getSourceLocationString(PP, Value[I].second) << "}";
547 }
548 SS << "]";
549 appendArgument(Name, SS.str());
550 }
551
552 // Append an IdentifierInfo argument to the top trace item.
553 void PPCallbacksTracker::appendArgument(const char *Name,
554 const IdentifierInfo *Value) {
555 if (!Value) {
556 appendArgument(Name, "(null)");
557 return;
558 }
559 appendArgument(Name, Value->getName().str().c_str());
560 }
561
562 // Append a MacroDirective argument to the top trace item.
563 void PPCallbacksTracker::appendArgument(const char *Name,
564 const MacroDirective *Value) {
565 if (!Value) {
566 appendArgument(Name, "(null)");
567 return;
568 }
569 appendArgument(Name, MacroDirectiveKindStrings[Value->getKind()]);
570 }
571
572 // Append a MacroDefinition argument to the top trace item.
573 void PPCallbacksTracker::appendArgument(const char *Name,
574 const MacroDefinition &Value) {
575 std::string Str;
576 llvm::raw_string_ostream SS(Str);
577 SS << "[";
578 bool Any = false;
579 if (Value.getLocalDirective()) {
580 SS << "(local)";
581 Any = true;
582 }
583 for (auto *MM : Value.getModuleMacros()) {
584 if (Any) SS << ", ";
585 SS << MM->getOwningModule()->getFullModuleName();
586 }
587 SS << "]";
588 appendArgument(Name, SS.str());
589 }
590
591 // Append a MacroArgs argument to the top trace item.
592 void PPCallbacksTracker::appendArgument(const char *Name,
593 const MacroArgs *Value) {
594 if (!Value) {
595 appendArgument(Name, "(null)");
596 return;
597 }
598 std::string Str;
599 llvm::raw_string_ostream SS(Str);
600 SS << "[";
601
602 // Each argument is is a series of contiguous Tokens, terminated by a eof.
603 // Go through each argument printing tokens until we reach eof.
604 for (unsigned I = 0; I < Value->getNumMacroArguments(); ++I) {
605 const Token *Current = Value->getUnexpArgument(I);
606 if (I)
607 SS << ", ";
608 bool First = true;
609 while (Current->isNot(tok::eof)) {
610 if (!First)
611 SS << " ";
612 // We need to be careful here because the arguments might not be legal in
613 // YAML, so we use the token name for anything but identifiers and
614 // numeric literals.
615 if (Current->isAnyIdentifier() || Current->is(tok::numeric_constant)) {
616 SS << PP.getSpelling(*Current);
617 } else {
618 SS << "<" << Current->getName() << ">";
619 }
620 ++Current;
621 First = false;
622 }
623 }
624 SS << "]";
625 appendArgument(Name, SS.str());
626 }
627
628 // Append a Module argument to the top trace item.
629 void PPCallbacksTracker::appendArgument(const char *Name, const Module *Value) {
630 if (!Value) {
631 appendArgument(Name, "(null)");
632 return;
633 }
634 appendArgument(Name, Value->Name.c_str());
635 }
636
637 // Append a double-quoted argument to the top trace item.
638 void PPCallbacksTracker::appendQuotedArgument(const char *Name,
639 const std::string &Value) {
640 std::string Str;
641 llvm::raw_string_ostream SS(Str);
642 SS << "\"" << Value << "\"";
643 appendArgument(Name, SS.str());
644 }
645
646 // Append a double-quoted file path argument to the top trace item.
647 void PPCallbacksTracker::appendFilePathArgument(const char *Name,
648 llvm::StringRef Value) {
649 std::string Path(Value);
650 // YAML treats backslash as escape, so use forward slashes.
651 std::replace(Path.begin(), Path.end(), '\\', '/');
652 appendQuotedArgument(Name, Path);
653 }
654
655 // Get the raw source string of the range.
656 llvm::StringRef PPCallbacksTracker::getSourceString(CharSourceRange Range) {
657 const char *B = PP.getSourceManager().getCharacterData(Range.getBegin());
658 const char *E = PP.getSourceManager().getCharacterData(Range.getEnd());
659 return llvm::StringRef(B, E - B);
660 }
661
662 } // namespace pp_trace
663 } // namespace clang
Loc
SourceLocation Loc
&#39;#&#39; location in the include directive
Definition: IncludeOrderCheck.cpp:37
clang::pp_trace::PPCallbacksTracker::moduleImport
void moduleImport(SourceLocation ImportLoc, ModuleIdPath Path, const Module *Imported) override
Definition: PPCallbacksTracker.cpp:155
clang::pp_trace::PPCallbacksTracker::CallbackCalls
std::vector< CallbackCall > & CallbackCalls
Callback trace information.
Definition: PPCallbacksTracker.h:224
clang::pp_trace::PPCallbacksTracker::appendQuotedArgument
void appendQuotedArgument(const char *Name, const std::string &Value)
Append a double-quoted argument to the top trace item.
Definition: PPCallbacksTracker.cpp:638
clang::pp_trace::PPCallbacksTracker::PP
Preprocessor & PP
Definition: PPCallbacksTracker.h:235
clang::pp_trace::PPCallbacksTracker::FileSkipped
void FileSkipped(const FileEntryRef &SkippedFile, const Token &FilenameTok, SrcMgr::CharacteristicKind FileType) override
Definition: PPCallbacksTracker.cpp:115
clang::pp_trace::PPCallbacksTracker::MacroDefined
void MacroDefined(const Token &MacroNameTok, const MacroDirective *MD) override
Definition: PPCallbacksTracker.cpp:330
clang::pp_trace::PPCallbacksTracker::InclusionDirective
void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok, llvm::StringRef FileName, bool IsAngled, CharSourceRange FilenameRange, const FileEntry *File, llvm::StringRef SearchPath, llvm::StringRef RelativePath, const Module *Imported, SrcMgr::CharacteristicKind FileType) override
Definition: PPCallbacksTracker.cpp:137
clang::pp_trace::CharacteristicKindStrings
static const char *const CharacteristicKindStrings[]
Definition: PPCallbacksTracker.cpp:62
clang::pp_trace::FileChangeReasonStrings
static const char *const FileChangeReasonStrings[]
Definition: PPCallbacksTracker.cpp:57
clang::pp_trace::PPCallbacksTracker::SourceRangeSkipped
void SourceRangeSkipped(SourceRange Range, SourceLocation EndifLoc) override
Definition: PPCallbacksTracker.cpp:357
clang::pp_trace::PPCallbacksTracker::Filters
const FilterType & Filters
Definition: PPCallbacksTracker.h:227
Path
std::vector< HeaderHandle > Path
Definition: PreprocessorTracker.cpp:537
clang::pp_trace::PPCallbacksTracker::PragmaDetectMismatch
void PragmaDetectMismatch(SourceLocation Loc, llvm::StringRef Name, llvm::StringRef Value) override
Definition: PPCallbacksTracker.cpp:195
clang::clangd::replace
static std::string replace(llvm::StringRef Haystack, llvm::StringRef Needle, llvm::StringRef Repl)
Definition: TestIndex.cpp:30
clang::pp_trace::PPCallbacksTracker::PragmaExecCharsetPop
void PragmaExecCharsetPop(SourceLocation Loc) override
Definition: PPCallbacksTracker.cpp:311
Kind
BindArgumentKind Kind
Definition: AvoidBindCheck.cpp:57
clang::pp_trace::PPCallbacksTracker::getSourceString
llvm::StringRef getSourceString(CharSourceRange Range)
Get the raw source string of the range.
Definition: PPCallbacksTracker.cpp:656
clang::pp_trace::PPCallbacksTracker::Elif
void Elif(SourceLocation Loc, SourceRange ConditionRange, ConditionValueKind ConditionValue, SourceLocation IfLoc) override
Definition: PPCallbacksTracker.cpp:373
clang::pp_trace::PPCallbacksTracker::If
void If(SourceLocation Loc, SourceRange ConditionRange, ConditionValueKind ConditionValue) override
Definition: PPCallbacksTracker.cpp:364
clang::pp_trace::PragmaIntroducerKindStrings
static const char *const PragmaIntroducerKindStrings[]
Definition: PPCallbacksTracker.cpp:71
clang::pp_trace::PPCallbacksTracker::PragmaComment
void PragmaComment(SourceLocation Loc, const IdentifierInfo *Kind, llvm::StringRef Str) override
Definition: PPCallbacksTracker.cpp:184
clang::pp_trace::PPCallbacksTracker::DisableTrace
bool DisableTrace
Inhibit trace while this is set.
Definition: PPCallbacksTracker.h:233
clang::pp_trace::PPCallbacksTracker::Defined
void Defined(const Token &MacroNameTok, const MacroDefinition &MD, SourceRange Range) override
Definition: PPCallbacksTracker.cpp:347
clang::pp_trace::PPCallbacksTracker::Else
void Else(SourceLocation Loc, SourceLocation IfLoc) override
Definition: PPCallbacksTracker.cpp:402
clang::pp_trace::PPCallbacksTracker::PragmaMessage
void PragmaMessage(SourceLocation Loc, llvm::StringRef Namespace, PPCallbacks::PragmaMessageKind Kind, llvm::StringRef Str) override
Definition: PPCallbacksTracker.cpp:213
clang::pp_trace::CallbackCall
This class represents one callback call by name and an array of arguments.
Definition: PPCallbacksTracker.h:46
clang::pp_trace::PPCallbacksTracker::PragmaOpenCLExtension
void PragmaOpenCLExtension(SourceLocation NameLoc, const IdentifierInfo *Name, SourceLocation StateLoc, unsigned State) override
Definition: PPCallbacksTracker.cpp:256
clang::pp_trace::PPCallbacksTracker::MacroExpands
void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD, SourceRange Range, const MacroArgs *Args) override
Definition: PPCallbacksTracker.cpp:318
clang::pp_trace::PPCallbacksTracker::PPCallbacksTracker
PPCallbacksTracker(const FilterType &Filters, std::vector< CallbackCall > &CallbackCalls, Preprocessor &PP)
Note that all of the arguments are references, and owned by the caller.
Definition: PPCallbacksTracker.cpp:92
clang::pp_trace::PPCallbacksTracker::MacroUndefined
void MacroUndefined(const Token &MacroNameTok, const MacroDefinition &MD, const MacroDirective *Undef) override
Definition: PPCallbacksTracker.cpp:338
IsAngled
bool IsAngled
true if this was an include with angle brackets
Definition: IncludeOrderCheck.cpp:40
PPCallbacksTracker.h
Classes and definitions for preprocessor tracking.
clang::pp_trace::PPCallbacksTracker::PragmaWarning
void PragmaWarning(SourceLocation Loc, llvm::StringRef WarningSpec, llvm::ArrayRef< int > Ids) override
Definition: PPCallbacksTracker.cpp:268
Name
static constexpr llvm::StringLiteral Name
Definition: UppercaseLiteralSuffixCheck.cpp:27
clang::pp_trace::PPCallbacksTracker::beginCallback
void beginCallback(const char *Name)
Start a new callback.
Definition: PPCallbacksTracker.cpp:418
FileName
PathRef FileName
Definition: CodeComplete.cpp:1018
clang::pp_trace::PPCallbacksTracker::PragmaExecCharsetPush
void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str) override
Definition: PPCallbacksTracker.cpp:302
clang::pp_trace::PPCallbacksTracker::PragmaDebug
void PragmaDebug(SourceLocation Loc, llvm::StringRef DebugType) override
Definition: PPCallbacksTracker.cpp:205
clang::pp_trace::MacroDirectiveKindStrings
static const char *const MacroDirectiveKindStrings[]
Definition: PPCallbacksTracker.cpp:66
clang::pp_trace::ConditionValueKindStrings
static const char *const ConditionValueKindStrings[]
Definition: PPCallbacksTracker.cpp:81
clang::pp_trace::PPCallbacksTracker::appendArgument
void appendArgument(const char *Name, bool Value)
Append a bool argument to the top trace item.
Definition: PPCallbacksTracker.cpp:433
ConditionValue
clang::PPCallbacks::ConditionValueKind ConditionValue
Definition: PreprocessorTracker.cpp:672
clang::pp_trace::PPCallbacksTracker::PragmaWarningPush
void PragmaWarningPush(SourceLocation Loc, int Level) override
Definition: PPCallbacksTracker.cpp:288
Strings
std::vector< llvm::StringRef > Strings
Definition: Serialization.cpp:195
clang::pp_trace::PPCallbacksTracker::CallbackIsEnabled
llvm::StringMap< bool > CallbackIsEnabled
Definition: PPCallbacksTracker.h:230
clang::pp_trace::PragmaMessageKindStrings
static const char *const PragmaMessageKindStrings[]
Definition: PPCallbacksTracker.cpp:76
clang
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Definition: ApplyReplacements.h:27
clang::pp_trace::PPCallbacksTracker::PragmaDiagnostic
void PragmaDiagnostic(SourceLocation Loc, llvm::StringRef Namespace, diag::Severity mapping, llvm::StringRef Str) override
Definition: PPCallbacksTracker.cpp:243
clang::pp_trace::PPCallbacksTracker::Ifdef
void Ifdef(SourceLocation Loc, const Token &MacroNameTok, const MacroDefinition &MD) override
Definition: PPCallbacksTracker.cpp:384
clang::tidy::bugprone::PP
static Preprocessor * PP
Definition: BadSignalToKillThreadCheck.cpp:28
clang::pp_trace::getSourceLocationString
static std::string getSourceLocationString(Preprocessor &PP, SourceLocation Loc)
Definition: PPCallbacksTracker.cpp:24
Range
CharSourceRange Range
SourceRange for the file name.
Definition: IncludeOrderCheck.cpp:38
clang::pp_trace::PPCallbacksTracker::FileNotFound
bool FileNotFound(llvm::StringRef FileName, llvm::SmallVectorImpl< char > &RecoveryPath) override
Definition: PPCallbacksTracker.cpp:127
clang::pp_trace::MappingStrings
static const char *const MappingStrings[]
Definition: PPCallbacksTracker.cpp:86
clang::pp_trace::FilterType
std::vector< std::pair< llvm::GlobPattern, bool > > FilterType
Definition: PPCallbacksTracker.h:55
clang::pp_trace::PPCallbacksTracker::Endif
void Endif(SourceLocation Loc, SourceLocation IfLoc) override
Definition: PPCallbacksTracker.cpp:409
clang::pp_trace::PPCallbacksTracker::Ident
void Ident(SourceLocation Loc, llvm::StringRef str) override
Definition: PPCallbacksTracker.cpp:169
E
const Expr * E
Definition: AvoidBindCheck.cpp:82
clang::pp_trace::PPCallbacksTracker::appendFilePathArgument
void appendFilePathArgument(const char *Name, llvm::StringRef Value)
Append a double-quoted file path argument to the top trace item.
Definition: PPCallbacksTracker.cpp:647
clang::pp_trace::PPCallbacksTracker::FileChanged
void FileChanged(SourceLocation Loc, PPCallbacks::FileChangeReason Reason, SrcMgr::CharacteristicKind FileType, FileID PrevFID=FileID()) override
Definition: PPCallbacksTracker.cpp:102
clang::pp_trace::PPCallbacksTracker::EndOfMainFile
void EndOfMainFile() override
Definition: PPCallbacksTracker.cpp:166
clang::pp_trace::Argument
Definition: PPCallbacksTracker.h:39
clang::pp_trace::PPCallbacksTracker::PragmaDiagnosticPush
void PragmaDiagnosticPush(SourceLocation Loc, llvm::StringRef Namespace) override
Definition: PPCallbacksTracker.cpp:226
clang::pp_trace::PPCallbacksTracker::~PPCallbacksTracker
~PPCallbacksTracker() override
Definition: PPCallbacksTracker.cpp:97
clang::pp_trace::PPCallbacksTracker::PragmaDiagnosticPop
void PragmaDiagnosticPop(SourceLocation Loc, llvm::StringRef Namespace) override
Definition: PPCallbacksTracker.cpp:235
clang::pp_trace::PPCallbacksTracker::PragmaWarningPop
void PragmaWarningPop(SourceLocation Loc) override
Definition: PPCallbacksTracker.cpp:295
clang::pp_trace::PPCallbacksTracker::PragmaDirective
void PragmaDirective(SourceLocation Loc, PragmaIntroducerKind Introducer) override
Definition: PPCallbacksTracker.cpp:176
clang::pp_trace::PPCallbacksTracker::Ifndef
void Ifndef(SourceLocation Loc, const Token &MacroNameTok, const MacroDefinition &MD) override
Definition: PPCallbacksTracker.cpp:393