1 //===--- PlistDiagnostics.cpp - Plist Diagnostics for Paths -----*- 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 // This file defines the PlistDiagnostics object. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "clang/Analysis/IssueHash.h" 14 #include "clang/Analysis/MacroExpansionContext.h" 15 #include "clang/Analysis/PathDiagnostic.h" 16 #include "clang/Basic/FileManager.h" 17 #include "clang/Basic/PlistSupport.h" 18 #include "clang/Basic/SourceManager.h" 19 #include "clang/Basic/Version.h" 20 #include "clang/CrossTU/CrossTranslationUnit.h" 21 #include "clang/Frontend/ASTUnit.h" 22 #include "clang/Lex/Preprocessor.h" 23 #include "clang/Lex/TokenConcatenation.h" 24 #include "clang/Rewrite/Core/HTMLRewrite.h" 25 #include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h" 26 #include "llvm/ADT/SmallPtrSet.h" 27 #include "llvm/ADT/SmallVector.h" 28 #include "llvm/ADT/Statistic.h" 29 #include "llvm/Support/Casting.h" 30 #include <memory> 31 #include <optional> 32 33 using namespace clang; 34 using namespace ento; 35 using namespace markup; 36 37 //===----------------------------------------------------------------------===// 38 // Declarations of helper classes and functions for emitting bug reports in 39 // plist format. 40 //===----------------------------------------------------------------------===// 41 42 namespace { 43 class PlistDiagnostics : public PathDiagnosticConsumer { 44 PathDiagnosticConsumerOptions DiagOpts; 45 const std::string OutputFile; 46 const Preprocessor &PP; 47 const cross_tu::CrossTranslationUnitContext &CTU; 48 const MacroExpansionContext &MacroExpansions; 49 const bool SupportsCrossFileDiagnostics; 50 51 void printBugPath(llvm::raw_ostream &o, const FIDMap &FM, 52 const PathPieces &Path); 53 54 public: 55 PlistDiagnostics(PathDiagnosticConsumerOptions DiagOpts, 56 const std::string &OutputFile, const Preprocessor &PP, 57 const cross_tu::CrossTranslationUnitContext &CTU, 58 const MacroExpansionContext &MacroExpansions, 59 bool supportsMultipleFiles); 60 61 ~PlistDiagnostics() override {} 62 63 void FlushDiagnosticsImpl(std::vector<const PathDiagnostic *> &Diags, 64 FilesMade *filesMade) override; 65 66 StringRef getName() const override { 67 return "PlistDiagnostics"; 68 } 69 70 PathGenerationScheme getGenerationScheme() const override { 71 return Extensive; 72 } 73 bool supportsLogicalOpControlFlow() const override { return true; } 74 bool supportsCrossFileDiagnostics() const override { 75 return SupportsCrossFileDiagnostics; 76 } 77 }; 78 } // end anonymous namespace 79 80 namespace { 81 82 /// A helper class for emitting a single report. 83 class PlistPrinter { 84 const FIDMap& FM; 85 const Preprocessor &PP; 86 const cross_tu::CrossTranslationUnitContext &CTU; 87 const MacroExpansionContext &MacroExpansions; 88 llvm::SmallVector<const PathDiagnosticMacroPiece *, 0> MacroPieces; 89 90 public: 91 PlistPrinter(const FIDMap &FM, const Preprocessor &PP, 92 const cross_tu::CrossTranslationUnitContext &CTU, 93 const MacroExpansionContext &MacroExpansions) 94 : FM(FM), PP(PP), CTU(CTU), MacroExpansions(MacroExpansions) {} 95 96 void ReportDiag(raw_ostream &o, const PathDiagnosticPiece& P) { 97 ReportPiece(o, P, /*indent*/ 4, /*depth*/ 0, /*includeControlFlow*/ true); 98 } 99 100 /// Print the expansions of the collected macro pieces. 101 /// 102 /// Each time ReportDiag is called on a PathDiagnosticMacroPiece (or, if one 103 /// is found through a call piece, etc), it's subpieces are reported, and the 104 /// piece itself is collected. Call this function after the entire bugpath 105 /// was reported. 106 void ReportMacroExpansions(raw_ostream &o, unsigned indent); 107 108 private: 109 void ReportPiece(raw_ostream &o, const PathDiagnosticPiece &P, 110 unsigned indent, unsigned depth, bool includeControlFlow, 111 bool isKeyEvent = false) { 112 switch (P.getKind()) { 113 case PathDiagnosticPiece::ControlFlow: 114 if (includeControlFlow) 115 ReportControlFlow(o, cast<PathDiagnosticControlFlowPiece>(P), indent); 116 break; 117 case PathDiagnosticPiece::Call: 118 ReportCall(o, cast<PathDiagnosticCallPiece>(P), indent, 119 depth); 120 break; 121 case PathDiagnosticPiece::Event: 122 ReportEvent(o, cast<PathDiagnosticEventPiece>(P), indent, depth, 123 isKeyEvent); 124 break; 125 case PathDiagnosticPiece::Macro: 126 ReportMacroSubPieces(o, cast<PathDiagnosticMacroPiece>(P), indent, 127 depth); 128 break; 129 case PathDiagnosticPiece::Note: 130 ReportNote(o, cast<PathDiagnosticNotePiece>(P), indent); 131 break; 132 case PathDiagnosticPiece::PopUp: 133 ReportPopUp(o, cast<PathDiagnosticPopUpPiece>(P), indent); 134 break; 135 } 136 } 137 138 void EmitRanges(raw_ostream &o, const ArrayRef<SourceRange> Ranges, 139 unsigned indent); 140 void EmitMessage(raw_ostream &o, StringRef Message, unsigned indent); 141 void EmitFixits(raw_ostream &o, ArrayRef<FixItHint> fixits, unsigned indent); 142 143 void ReportControlFlow(raw_ostream &o, 144 const PathDiagnosticControlFlowPiece& P, 145 unsigned indent); 146 void ReportEvent(raw_ostream &o, const PathDiagnosticEventPiece& P, 147 unsigned indent, unsigned depth, bool isKeyEvent = false); 148 void ReportCall(raw_ostream &o, const PathDiagnosticCallPiece &P, 149 unsigned indent, unsigned depth); 150 void ReportMacroSubPieces(raw_ostream &o, const PathDiagnosticMacroPiece& P, 151 unsigned indent, unsigned depth); 152 void ReportNote(raw_ostream &o, const PathDiagnosticNotePiece& P, 153 unsigned indent); 154 155 void ReportPopUp(raw_ostream &o, const PathDiagnosticPopUpPiece &P, 156 unsigned indent); 157 }; 158 159 } // end of anonymous namespace 160 161 /// Print coverage information to output stream @c o. 162 /// May modify the used list of files @c Fids by inserting new ones. 163 static void printCoverage(const PathDiagnostic *D, 164 unsigned InputIndentLevel, 165 SmallVectorImpl<FileID> &Fids, 166 FIDMap &FM, 167 llvm::raw_fd_ostream &o); 168 169 static std::optional<StringRef> getExpandedMacro( 170 SourceLocation MacroLoc, const cross_tu::CrossTranslationUnitContext &CTU, 171 const MacroExpansionContext &MacroExpansions, const SourceManager &SM); 172 173 //===----------------------------------------------------------------------===// 174 // Methods of PlistPrinter. 175 //===----------------------------------------------------------------------===// 176 177 void PlistPrinter::EmitRanges(raw_ostream &o, 178 const ArrayRef<SourceRange> Ranges, 179 unsigned indent) { 180 181 if (Ranges.empty()) 182 return; 183 184 Indent(o, indent) << "<key>ranges</key>\n"; 185 Indent(o, indent) << "<array>\n"; 186 ++indent; 187 188 const SourceManager &SM = PP.getSourceManager(); 189 const LangOptions &LangOpts = PP.getLangOpts(); 190 191 for (auto &R : Ranges) 192 EmitRange(o, SM, 193 Lexer::getAsCharRange(SM.getExpansionRange(R), SM, LangOpts), 194 FM, indent + 1); 195 --indent; 196 Indent(o, indent) << "</array>\n"; 197 } 198 199 void PlistPrinter::EmitMessage(raw_ostream &o, StringRef Message, 200 unsigned indent) { 201 // Output the text. 202 assert(!Message.empty()); 203 Indent(o, indent) << "<key>extended_message</key>\n"; 204 Indent(o, indent); 205 EmitString(o, Message) << '\n'; 206 207 // Output the short text. 208 // FIXME: Really use a short string. 209 Indent(o, indent) << "<key>message</key>\n"; 210 Indent(o, indent); 211 EmitString(o, Message) << '\n'; 212 } 213 214 void PlistPrinter::EmitFixits(raw_ostream &o, ArrayRef<FixItHint> fixits, 215 unsigned indent) { 216 if (fixits.size() == 0) 217 return; 218 219 const SourceManager &SM = PP.getSourceManager(); 220 const LangOptions &LangOpts = PP.getLangOpts(); 221 222 Indent(o, indent) << "<key>fixits</key>\n"; 223 Indent(o, indent) << "<array>\n"; 224 for (const auto &fixit : fixits) { 225 assert(!fixit.isNull()); 226 // FIXME: Add support for InsertFromRange and BeforePreviousInsertion. 227 assert(!fixit.InsertFromRange.isValid() && "Not implemented yet!"); 228 assert(!fixit.BeforePreviousInsertions && "Not implemented yet!"); 229 Indent(o, indent) << " <dict>\n"; 230 Indent(o, indent) << " <key>remove_range</key>\n"; 231 EmitRange(o, SM, Lexer::getAsCharRange(fixit.RemoveRange, SM, LangOpts), 232 FM, indent + 2); 233 Indent(o, indent) << " <key>insert_string</key>"; 234 EmitString(o, fixit.CodeToInsert); 235 o << "\n"; 236 Indent(o, indent) << " </dict>\n"; 237 } 238 Indent(o, indent) << "</array>\n"; 239 } 240 241 void PlistPrinter::ReportControlFlow(raw_ostream &o, 242 const PathDiagnosticControlFlowPiece& P, 243 unsigned indent) { 244 245 const SourceManager &SM = PP.getSourceManager(); 246 const LangOptions &LangOpts = PP.getLangOpts(); 247 248 Indent(o, indent) << "<dict>\n"; 249 ++indent; 250 251 Indent(o, indent) << "<key>kind</key><string>control</string>\n"; 252 253 // Emit edges. 254 Indent(o, indent) << "<key>edges</key>\n"; 255 ++indent; 256 Indent(o, indent) << "<array>\n"; 257 ++indent; 258 for (PathDiagnosticControlFlowPiece::const_iterator I=P.begin(), E=P.end(); 259 I!=E; ++I) { 260 Indent(o, indent) << "<dict>\n"; 261 ++indent; 262 263 // Make the ranges of the start and end point self-consistent with adjacent edges 264 // by forcing to use only the beginning of the range. This simplifies the layout 265 // logic for clients. 266 Indent(o, indent) << "<key>start</key>\n"; 267 SourceRange StartEdge( 268 SM.getExpansionLoc(I->getStart().asRange().getBegin())); 269 EmitRange(o, SM, Lexer::getAsCharRange(StartEdge, SM, LangOpts), FM, 270 indent + 1); 271 272 Indent(o, indent) << "<key>end</key>\n"; 273 SourceRange EndEdge(SM.getExpansionLoc(I->getEnd().asRange().getBegin())); 274 EmitRange(o, SM, Lexer::getAsCharRange(EndEdge, SM, LangOpts), FM, 275 indent + 1); 276 277 --indent; 278 Indent(o, indent) << "</dict>\n"; 279 } 280 --indent; 281 Indent(o, indent) << "</array>\n"; 282 --indent; 283 284 // Output any helper text. 285 const auto &s = P.getString(); 286 if (!s.empty()) { 287 Indent(o, indent) << "<key>alternate</key>"; 288 EmitString(o, s) << '\n'; 289 } 290 291 assert(P.getFixits().size() == 0 && 292 "Fixits on constrol flow pieces are not implemented yet!"); 293 294 --indent; 295 Indent(o, indent) << "</dict>\n"; 296 } 297 298 void PlistPrinter::ReportEvent(raw_ostream &o, const PathDiagnosticEventPiece& P, 299 unsigned indent, unsigned depth, 300 bool isKeyEvent) { 301 302 const SourceManager &SM = PP.getSourceManager(); 303 304 Indent(o, indent) << "<dict>\n"; 305 ++indent; 306 307 Indent(o, indent) << "<key>kind</key><string>event</string>\n"; 308 309 if (isKeyEvent) { 310 Indent(o, indent) << "<key>key_event</key><true/>\n"; 311 } 312 313 // Output the location. 314 FullSourceLoc L = P.getLocation().asLocation(); 315 316 Indent(o, indent) << "<key>location</key>\n"; 317 EmitLocation(o, SM, L, FM, indent); 318 319 // Output the ranges (if any). 320 ArrayRef<SourceRange> Ranges = P.getRanges(); 321 EmitRanges(o, Ranges, indent); 322 323 // Output the call depth. 324 Indent(o, indent) << "<key>depth</key>"; 325 EmitInteger(o, depth) << '\n'; 326 327 // Output the text. 328 EmitMessage(o, P.getString(), indent); 329 330 // Output the fixits. 331 EmitFixits(o, P.getFixits(), indent); 332 333 // Finish up. 334 --indent; 335 Indent(o, indent); o << "</dict>\n"; 336 } 337 338 void PlistPrinter::ReportCall(raw_ostream &o, const PathDiagnosticCallPiece &P, 339 unsigned indent, 340 unsigned depth) { 341 342 if (auto callEnter = P.getCallEnterEvent()) 343 ReportPiece(o, *callEnter, indent, depth, /*includeControlFlow*/ true, 344 P.isLastInMainSourceFile()); 345 346 347 ++depth; 348 349 if (auto callEnterWithinCaller = P.getCallEnterWithinCallerEvent()) 350 ReportPiece(o, *callEnterWithinCaller, indent, depth, 351 /*includeControlFlow*/ true); 352 353 for (PathPieces::const_iterator I = P.path.begin(), E = P.path.end();I!=E;++I) 354 ReportPiece(o, **I, indent, depth, /*includeControlFlow*/ true); 355 356 --depth; 357 358 if (auto callExit = P.getCallExitEvent()) 359 ReportPiece(o, *callExit, indent, depth, /*includeControlFlow*/ true); 360 361 assert(P.getFixits().size() == 0 && 362 "Fixits on call pieces are not implemented yet!"); 363 } 364 365 void PlistPrinter::ReportMacroSubPieces(raw_ostream &o, 366 const PathDiagnosticMacroPiece& P, 367 unsigned indent, unsigned depth) { 368 MacroPieces.push_back(&P); 369 370 for (const auto &SubPiece : P.subPieces) { 371 ReportPiece(o, *SubPiece, indent, depth, /*includeControlFlow*/ false); 372 } 373 374 assert(P.getFixits().size() == 0 && 375 "Fixits on constrol flow pieces are not implemented yet!"); 376 } 377 378 void PlistPrinter::ReportMacroExpansions(raw_ostream &o, unsigned indent) { 379 380 for (const PathDiagnosticMacroPiece *P : MacroPieces) { 381 const SourceManager &SM = PP.getSourceManager(); 382 383 SourceLocation MacroExpansionLoc = 384 P->getLocation().asLocation().getExpansionLoc(); 385 386 const std::optional<StringRef> MacroName = 387 MacroExpansions.getOriginalText(MacroExpansionLoc); 388 const std::optional<StringRef> ExpansionText = 389 getExpandedMacro(MacroExpansionLoc, CTU, MacroExpansions, SM); 390 391 if (!MacroName || !ExpansionText) 392 continue; 393 394 Indent(o, indent) << "<dict>\n"; 395 ++indent; 396 397 // Output the location. 398 FullSourceLoc L = P->getLocation().asLocation(); 399 400 Indent(o, indent) << "<key>location</key>\n"; 401 EmitLocation(o, SM, L, FM, indent); 402 403 // Output the ranges (if any). 404 ArrayRef<SourceRange> Ranges = P->getRanges(); 405 EmitRanges(o, Ranges, indent); 406 407 // Output the macro name. 408 Indent(o, indent) << "<key>name</key>"; 409 EmitString(o, *MacroName) << '\n'; 410 411 // Output what it expands into. 412 Indent(o, indent) << "<key>expansion</key>"; 413 EmitString(o, *ExpansionText) << '\n'; 414 415 // Finish up. 416 --indent; 417 Indent(o, indent); 418 o << "</dict>\n"; 419 } 420 } 421 422 void PlistPrinter::ReportNote(raw_ostream &o, const PathDiagnosticNotePiece& P, 423 unsigned indent) { 424 425 const SourceManager &SM = PP.getSourceManager(); 426 427 Indent(o, indent) << "<dict>\n"; 428 ++indent; 429 430 // Output the location. 431 FullSourceLoc L = P.getLocation().asLocation(); 432 433 Indent(o, indent) << "<key>location</key>\n"; 434 EmitLocation(o, SM, L, FM, indent); 435 436 // Output the ranges (if any). 437 ArrayRef<SourceRange> Ranges = P.getRanges(); 438 EmitRanges(o, Ranges, indent); 439 440 // Output the text. 441 EmitMessage(o, P.getString(), indent); 442 443 // Output the fixits. 444 EmitFixits(o, P.getFixits(), indent); 445 446 // Finish up. 447 --indent; 448 Indent(o, indent); o << "</dict>\n"; 449 } 450 451 void PlistPrinter::ReportPopUp(raw_ostream &o, 452 const PathDiagnosticPopUpPiece &P, 453 unsigned indent) { 454 const SourceManager &SM = PP.getSourceManager(); 455 456 Indent(o, indent) << "<dict>\n"; 457 ++indent; 458 459 Indent(o, indent) << "<key>kind</key><string>pop-up</string>\n"; 460 461 // Output the location. 462 FullSourceLoc L = P.getLocation().asLocation(); 463 464 Indent(o, indent) << "<key>location</key>\n"; 465 EmitLocation(o, SM, L, FM, indent); 466 467 // Output the ranges (if any). 468 ArrayRef<SourceRange> Ranges = P.getRanges(); 469 EmitRanges(o, Ranges, indent); 470 471 // Output the text. 472 EmitMessage(o, P.getString(), indent); 473 474 assert(P.getFixits().size() == 0 && 475 "Fixits on pop-up pieces are not implemented yet!"); 476 477 // Finish up. 478 --indent; 479 Indent(o, indent) << "</dict>\n"; 480 } 481 482 //===----------------------------------------------------------------------===// 483 // Static function definitions. 484 //===----------------------------------------------------------------------===// 485 486 /// Print coverage information to output stream @c o. 487 /// May modify the used list of files @c Fids by inserting new ones. 488 static void printCoverage(const PathDiagnostic *D, 489 unsigned InputIndentLevel, 490 SmallVectorImpl<FileID> &Fids, 491 FIDMap &FM, 492 llvm::raw_fd_ostream &o) { 493 unsigned IndentLevel = InputIndentLevel; 494 495 Indent(o, IndentLevel) << "<key>ExecutedLines</key>\n"; 496 Indent(o, IndentLevel) << "<dict>\n"; 497 IndentLevel++; 498 499 // Mapping from file IDs to executed lines. 500 const FilesToLineNumsMap &ExecutedLines = D->getExecutedLines(); 501 for (const auto &[FID, Lines] : ExecutedLines) { 502 unsigned FileKey = AddFID(FM, Fids, FID); 503 Indent(o, IndentLevel) << "<key>" << FileKey << "</key>\n"; 504 Indent(o, IndentLevel) << "<array>\n"; 505 IndentLevel++; 506 for (unsigned LineNo : Lines) { 507 Indent(o, IndentLevel); 508 EmitInteger(o, LineNo) << "\n"; 509 } 510 IndentLevel--; 511 Indent(o, IndentLevel) << "</array>\n"; 512 } 513 IndentLevel--; 514 Indent(o, IndentLevel) << "</dict>\n"; 515 516 assert(IndentLevel == InputIndentLevel); 517 } 518 519 //===----------------------------------------------------------------------===// 520 // Methods of PlistDiagnostics. 521 //===----------------------------------------------------------------------===// 522 523 PlistDiagnostics::PlistDiagnostics( 524 PathDiagnosticConsumerOptions DiagOpts, const std::string &output, 525 const Preprocessor &PP, const cross_tu::CrossTranslationUnitContext &CTU, 526 const MacroExpansionContext &MacroExpansions, bool supportsMultipleFiles) 527 : DiagOpts(std::move(DiagOpts)), OutputFile(output), PP(PP), CTU(CTU), 528 MacroExpansions(MacroExpansions), 529 SupportsCrossFileDiagnostics(supportsMultipleFiles) { 530 // FIXME: Will be used by a later planned change. 531 (void)this->CTU; 532 } 533 534 void ento::createPlistDiagnosticConsumer( 535 PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C, 536 const std::string &OutputFile, const Preprocessor &PP, 537 const cross_tu::CrossTranslationUnitContext &CTU, 538 const MacroExpansionContext &MacroExpansions) { 539 540 // TODO: Emit an error here. 541 if (OutputFile.empty()) 542 return; 543 544 C.push_back(new PlistDiagnostics(DiagOpts, OutputFile, PP, CTU, 545 MacroExpansions, 546 /*supportsMultipleFiles=*/false)); 547 createTextMinimalPathDiagnosticConsumer(std::move(DiagOpts), C, OutputFile, 548 PP, CTU, MacroExpansions); 549 } 550 551 void ento::createPlistMultiFileDiagnosticConsumer( 552 PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C, 553 const std::string &OutputFile, const Preprocessor &PP, 554 const cross_tu::CrossTranslationUnitContext &CTU, 555 const MacroExpansionContext &MacroExpansions) { 556 557 // TODO: Emit an error here. 558 if (OutputFile.empty()) 559 return; 560 561 C.push_back(new PlistDiagnostics(DiagOpts, OutputFile, PP, CTU, 562 MacroExpansions, 563 /*supportsMultipleFiles=*/true)); 564 createTextMinimalPathDiagnosticConsumer(std::move(DiagOpts), C, OutputFile, 565 PP, CTU, MacroExpansions); 566 } 567 568 void PlistDiagnostics::printBugPath(llvm::raw_ostream &o, const FIDMap &FM, 569 const PathPieces &Path) { 570 PlistPrinter Printer(FM, PP, CTU, MacroExpansions); 571 assert(std::is_partitioned(Path.begin(), Path.end(), 572 [](const PathDiagnosticPieceRef &E) { 573 return E->getKind() == PathDiagnosticPiece::Note; 574 }) && 575 "PathDiagnostic is not partitioned so that notes precede the rest"); 576 577 PathPieces::const_iterator FirstNonNote = std::partition_point( 578 Path.begin(), Path.end(), [](const PathDiagnosticPieceRef &E) { 579 return E->getKind() == PathDiagnosticPiece::Note; 580 }); 581 582 PathPieces::const_iterator I = Path.begin(); 583 584 if (FirstNonNote != Path.begin()) { 585 o << " <key>notes</key>\n" 586 " <array>\n"; 587 588 for (; I != FirstNonNote; ++I) 589 Printer.ReportDiag(o, **I); 590 591 o << " </array>\n"; 592 } 593 594 o << " <key>path</key>\n"; 595 596 o << " <array>\n"; 597 598 for (const auto &Piece : llvm::make_range(I, Path.end())) 599 Printer.ReportDiag(o, *Piece); 600 601 o << " </array>\n"; 602 603 if (!DiagOpts.ShouldDisplayMacroExpansions) 604 return; 605 606 o << " <key>macro_expansions</key>\n" 607 " <array>\n"; 608 Printer.ReportMacroExpansions(o, /* indent */ 4); 609 o << " </array>\n"; 610 } 611 612 void PlistDiagnostics::FlushDiagnosticsImpl( 613 std::vector<const PathDiagnostic *> &Diags, 614 FilesMade *filesMade) { 615 // Build up a set of FIDs that we use by scanning the locations and 616 // ranges of the diagnostics. 617 FIDMap FM; 618 SmallVector<FileID, 10> Fids; 619 const SourceManager& SM = PP.getSourceManager(); 620 const LangOptions &LangOpts = PP.getLangOpts(); 621 622 auto AddPieceFID = [&FM, &Fids, &SM](const PathDiagnosticPiece &Piece) { 623 AddFID(FM, Fids, SM, Piece.getLocation().asLocation()); 624 ArrayRef<SourceRange> Ranges = Piece.getRanges(); 625 for (const SourceRange &Range : Ranges) { 626 AddFID(FM, Fids, SM, Range.getBegin()); 627 AddFID(FM, Fids, SM, Range.getEnd()); 628 } 629 }; 630 631 for (const PathDiagnostic *D : Diags) { 632 633 SmallVector<const PathPieces *, 5> WorkList; 634 WorkList.push_back(&D->path); 635 636 while (!WorkList.empty()) { 637 const PathPieces &Path = *WorkList.pop_back_val(); 638 639 for (const auto &Iter : Path) { 640 const PathDiagnosticPiece &Piece = *Iter; 641 AddPieceFID(Piece); 642 643 if (const PathDiagnosticCallPiece *Call = 644 dyn_cast<PathDiagnosticCallPiece>(&Piece)) { 645 if (auto CallEnterWithin = Call->getCallEnterWithinCallerEvent()) 646 AddPieceFID(*CallEnterWithin); 647 648 if (auto CallEnterEvent = Call->getCallEnterEvent()) 649 AddPieceFID(*CallEnterEvent); 650 651 WorkList.push_back(&Call->path); 652 } else if (const PathDiagnosticMacroPiece *Macro = 653 dyn_cast<PathDiagnosticMacroPiece>(&Piece)) { 654 WorkList.push_back(&Macro->subPieces); 655 } 656 } 657 } 658 } 659 660 // Open the file. 661 std::error_code EC; 662 llvm::raw_fd_ostream o(OutputFile, EC, llvm::sys::fs::OF_TextWithCRLF); 663 if (EC) { 664 llvm::errs() << "warning: could not create file: " << EC.message() << '\n'; 665 return; 666 } 667 668 EmitPlistHeader(o); 669 670 // Write the root object: a <dict> containing... 671 // - "clang_version", the string representation of clang version 672 // - "files", an <array> mapping from FIDs to file names 673 // - "diagnostics", an <array> containing the path diagnostics 674 o << "<dict>\n" << 675 " <key>clang_version</key>\n"; 676 EmitString(o, getClangFullVersion()) << '\n'; 677 o << " <key>diagnostics</key>\n" 678 " <array>\n"; 679 680 for (std::vector<const PathDiagnostic*>::iterator DI=Diags.begin(), 681 DE = Diags.end(); DI!=DE; ++DI) { 682 683 o << " <dict>\n"; 684 685 const PathDiagnostic *D = *DI; 686 printBugPath(o, FM, D->path); 687 688 // Output the bug type and bug category. 689 o << " <key>description</key>"; 690 EmitString(o, D->getShortDescription()) << '\n'; 691 o << " <key>category</key>"; 692 EmitString(o, D->getCategory()) << '\n'; 693 o << " <key>type</key>"; 694 EmitString(o, D->getBugType()) << '\n'; 695 o << " <key>check_name</key>"; 696 EmitString(o, D->getCheckerName()) << '\n'; 697 698 o << " <!-- This hash is experimental and going to change! -->\n"; 699 o << " <key>issue_hash_content_of_line_in_context</key>"; 700 PathDiagnosticLocation UPDLoc = D->getUniqueingLoc(); 701 FullSourceLoc L(SM.getExpansionLoc(UPDLoc.isValid() 702 ? UPDLoc.asLocation() 703 : D->getLocation().asLocation()), 704 SM); 705 const Decl *DeclWithIssue = D->getDeclWithIssue(); 706 EmitString(o, getIssueHash(L, D->getCheckerName(), D->getBugType(), 707 DeclWithIssue, LangOpts)) 708 << '\n'; 709 710 // Output information about the semantic context where 711 // the issue occurred. 712 if (const Decl *DeclWithIssue = D->getDeclWithIssue()) { 713 // FIXME: handle blocks, which have no name. 714 if (const NamedDecl *ND = dyn_cast<NamedDecl>(DeclWithIssue)) { 715 StringRef declKind; 716 switch (ND->getKind()) { 717 case Decl::CXXRecord: 718 declKind = "C++ class"; 719 break; 720 case Decl::CXXMethod: 721 declKind = "C++ method"; 722 break; 723 case Decl::ObjCMethod: 724 declKind = "Objective-C method"; 725 break; 726 case Decl::Function: 727 declKind = "function"; 728 break; 729 default: 730 break; 731 } 732 if (!declKind.empty()) { 733 const std::string &declName = ND->getDeclName().getAsString(); 734 o << " <key>issue_context_kind</key>"; 735 EmitString(o, declKind) << '\n'; 736 o << " <key>issue_context</key>"; 737 EmitString(o, declName) << '\n'; 738 } 739 740 // Output the bug hash for issue unique-ing. Currently, it's just an 741 // offset from the beginning of the function. 742 if (const Stmt *Body = DeclWithIssue->getBody()) { 743 744 // If the bug uniqueing location exists, use it for the hash. 745 // For example, this ensures that two leaks reported on the same line 746 // will have different issue_hashes and that the hash will identify 747 // the leak location even after code is added between the allocation 748 // site and the end of scope (leak report location). 749 if (UPDLoc.isValid()) { 750 FullSourceLoc UFunL( 751 SM.getExpansionLoc( 752 D->getUniqueingDecl()->getBody()->getBeginLoc()), 753 SM); 754 o << " <key>issue_hash_function_offset</key><string>" 755 << L.getExpansionLineNumber() - UFunL.getExpansionLineNumber() 756 << "</string>\n"; 757 758 // Otherwise, use the location on which the bug is reported. 759 } else { 760 FullSourceLoc FunL(SM.getExpansionLoc(Body->getBeginLoc()), SM); 761 o << " <key>issue_hash_function_offset</key><string>" 762 << L.getExpansionLineNumber() - FunL.getExpansionLineNumber() 763 << "</string>\n"; 764 } 765 766 } 767 } 768 } 769 770 // Output the location of the bug. 771 o << " <key>location</key>\n"; 772 EmitLocation(o, SM, D->getLocation().asLocation(), FM, 2); 773 774 // Output the diagnostic to the sub-diagnostic client, if any. 775 if (!filesMade->empty()) { 776 StringRef lastName; 777 PDFileEntry::ConsumerFiles *files = filesMade->getFiles(*D); 778 if (files) { 779 for (PDFileEntry::ConsumerFiles::const_iterator CI = files->begin(), 780 CE = files->end(); CI != CE; ++CI) { 781 StringRef newName = CI->first; 782 if (newName != lastName) { 783 if (!lastName.empty()) { 784 o << " </array>\n"; 785 } 786 lastName = newName; 787 o << " <key>" << lastName << "_files</key>\n"; 788 o << " <array>\n"; 789 } 790 o << " <string>" << CI->second << "</string>\n"; 791 } 792 o << " </array>\n"; 793 } 794 } 795 796 printCoverage(D, /*IndentLevel=*/2, Fids, FM, o); 797 798 // Close up the entry. 799 o << " </dict>\n"; 800 } 801 802 o << " </array>\n"; 803 804 o << " <key>files</key>\n" 805 " <array>\n"; 806 for (FileID FID : Fids) 807 EmitString(o << " ", SM.getFileEntryForID(FID)->getName()) << '\n'; 808 o << " </array>\n"; 809 810 if (llvm::AreStatisticsEnabled() && DiagOpts.ShouldSerializeStats) { 811 o << " <key>statistics</key>\n"; 812 std::string stats; 813 llvm::raw_string_ostream os(stats); 814 llvm::PrintStatisticsJSON(os); 815 os.flush(); 816 EmitString(o, html::EscapeText(stats)) << '\n'; 817 } 818 819 // Finish. 820 o << "</dict>\n</plist>\n"; 821 } 822 823 //===----------------------------------------------------------------------===// 824 // Definitions of helper functions and methods for expanding macros. 825 //===----------------------------------------------------------------------===// 826 827 static std::optional<StringRef> 828 getExpandedMacro(SourceLocation MacroExpansionLoc, 829 const cross_tu::CrossTranslationUnitContext &CTU, 830 const MacroExpansionContext &MacroExpansions, 831 const SourceManager &SM) { 832 if (auto CTUMacroExpCtx = 833 CTU.getMacroExpansionContextForSourceLocation(MacroExpansionLoc)) { 834 return CTUMacroExpCtx->getExpandedText(MacroExpansionLoc); 835 } 836 return MacroExpansions.getExpandedText(MacroExpansionLoc); 837 } 838