contrib/llvm/tools/clang/lib/StaticAnalyzer/Core/PlistDiagnostics.cpp

   1 //===--- PlistDiagnostics.cpp - Plist Diagnostics for Paths -----*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file defines the PlistDiagnostics object.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/Basic/FileManager.h"
  15 #include "clang/Basic/PlistSupport.h"
  16 #include "clang/Basic/SourceManager.h"
  17 #include "clang/Basic/Version.h"
  18 #include "clang/Lex/Preprocessor.h"
  19 #include "clang/Rewrite/Core/HTMLRewrite.h"
  20 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
  21 #include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
  22 #include "clang/StaticAnalyzer/Core/IssueHash.h"
  23 #include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
  24 #include "llvm/ADT/Statistic.h"
  25 #include "llvm/ADT/SmallVector.h"
  26 #include "llvm/Support/Casting.h"
  27 using namespace clang;
  28 using namespace ento;
  29 using namespace markup;
  30
  31 namespace {
  32   class PlistDiagnostics : public PathDiagnosticConsumer {
  33     const std::string OutputFile;
  34     const LangOptions &LangOpts;
  35     const bool SupportsCrossFileDiagnostics;
  36     const bool SerializeStatistics;
  37   public:
  38     PlistDiagnostics(AnalyzerOptions &AnalyzerOpts,
  39                      const std::string& prefix,
  40                      const LangOptions &LangOpts,
  41                      bool supportsMultipleFiles);
  42
  43     ~PlistDiagnostics() override {}
  44
  45     void FlushDiagnosticsImpl(std::vector<const PathDiagnostic *> &Diags,
  46                               FilesMade *filesMade) override;
  47
  48     StringRef getName() const override {
  49       return "PlistDiagnostics";
  50     }
  51
  52     PathGenerationScheme getGenerationScheme() const override {
  53       return Extensive;
  54     }
  55     bool supportsLogicalOpControlFlow() const override { return true; }
  56     bool supportsCrossFileDiagnostics() const override {
  57       return SupportsCrossFileDiagnostics;
  58     }
  59   };
  60 } // end anonymous namespace
  61
  62 PlistDiagnostics::PlistDiagnostics(AnalyzerOptions &AnalyzerOpts,
  63                                    const std::string& output,
  64                                    const LangOptions &LO,
  65                                    bool supportsMultipleFiles)
  66   : OutputFile(output),
  67     LangOpts(LO),
  68     SupportsCrossFileDiagnostics(supportsMultipleFiles),
  69     SerializeStatistics(AnalyzerOpts.shouldSerializeStats()) {}
  70
  71 void ento::createPlistDiagnosticConsumer(AnalyzerOptions &AnalyzerOpts,
  72                                          PathDiagnosticConsumers &C,
  73                                          const std::string& s,
  74                                          const Preprocessor &PP) {
  75   C.push_back(new PlistDiagnostics(AnalyzerOpts, s,
  76                                    PP.getLangOpts(), false));
  77 }
  78
  79 void ento::createPlistMultiFileDiagnosticConsumer(AnalyzerOptions &AnalyzerOpts,
  80                                                   PathDiagnosticConsumers &C,
  81                                                   const std::string &s,
  82                                                   const Preprocessor &PP) {
  83   C.push_back(new PlistDiagnostics(AnalyzerOpts, s,
  84                                    PP.getLangOpts(), true));
  85 }
  86
  87 static void EmitRanges(raw_ostream &o,
  88                        const ArrayRef<SourceRange> Ranges,
  89                        const FIDMap& FM,
  90                        const SourceManager &SM,
  91                        const LangOptions &LangOpts,
  92                        unsigned indent) {
  93
  94   if (Ranges.empty())
  95     return;
  96
  97   Indent(o, indent) << "<key>ranges</key>\n";
  98   Indent(o, indent) << "<array>\n";
  99   ++indent;
 100   for (auto &R : Ranges)
 101     EmitRange(o, SM,
 102               Lexer::getAsCharRange(SM.getExpansionRange(R), SM, LangOpts),
 103               FM, indent + 1);
 104   --indent;
 105   Indent(o, indent) << "</array>\n";
 106 }
 107
 108 static void EmitMessage(raw_ostream &o, StringRef Message, unsigned indent) {
 109   // Output the text.
 110   assert(!Message.empty());
 111   Indent(o, indent) << "<key>extended_message</key>\n";
 112   Indent(o, indent);
 113   EmitString(o, Message) << '\n';
 114
 115   // Output the short text.
 116   // FIXME: Really use a short string.
 117   Indent(o, indent) << "<key>message</key>\n";
 118   Indent(o, indent);
 119   EmitString(o, Message) << '\n';
 120 }
 121
 122 static void ReportControlFlow(raw_ostream &o,
 123                               const PathDiagnosticControlFlowPiece& P,
 124                               const FIDMap& FM,
 125                               const SourceManager &SM,
 126                               const LangOptions &LangOpts,
 127                               unsigned indent) {
 128
 129   Indent(o, indent) << "<dict>\n";
 130   ++indent;
 131
 132   Indent(o, indent) << "<key>kind</key><string>control</string>\n";
 133
 134   // Emit edges.
 135   Indent(o, indent) << "<key>edges</key>\n";
 136   ++indent;
 137   Indent(o, indent) << "<array>\n";
 138   ++indent;
 139   for (PathDiagnosticControlFlowPiece::const_iterator I=P.begin(), E=P.end();
 140        I!=E; ++I) {
 141     Indent(o, indent) << "<dict>\n";
 142     ++indent;
 143
 144     // Make the ranges of the start and end point self-consistent with adjacent edges
 145     // by forcing to use only the beginning of the range.  This simplifies the layout
 146     // logic for clients.
 147     Indent(o, indent) << "<key>start</key>\n";
 148     SourceRange StartEdge(
 149         SM.getExpansionLoc(I->getStart().asRange().getBegin()));
 150     EmitRange(o, SM, Lexer::getAsCharRange(StartEdge, SM, LangOpts), FM,
 151               indent + 1);
 152
 153     Indent(o, indent) << "<key>end</key>\n";
 154     SourceRange EndEdge(SM.getExpansionLoc(I->getEnd().asRange().getBegin()));
 155     EmitRange(o, SM, Lexer::getAsCharRange(EndEdge, SM, LangOpts), FM,
 156               indent + 1);
 157
 158     --indent;
 159     Indent(o, indent) << "</dict>\n";
 160   }
 161   --indent;
 162   Indent(o, indent) << "</array>\n";
 163   --indent;
 164
 165   // Output any helper text.
 166   const auto &s = P.getString();
 167   if (!s.empty()) {
 168     Indent(o, indent) << "<key>alternate</key>";
 169     EmitString(o, s) << '\n';
 170   }
 171
 172   --indent;
 173   Indent(o, indent) << "</dict>\n";
 174 }
 175
 176 static void ReportEvent(raw_ostream &o, const PathDiagnosticEventPiece& P,
 177                         const FIDMap& FM,
 178                         const SourceManager &SM,
 179                         const LangOptions &LangOpts,
 180                         unsigned indent,
 181                         unsigned depth,
 182                         bool isKeyEvent = false) {
 183
 184   Indent(o, indent) << "<dict>\n";
 185   ++indent;
 186
 187   Indent(o, indent) << "<key>kind</key><string>event</string>\n";
 188
 189   if (isKeyEvent) {
 190     Indent(o, indent) << "<key>key_event</key><true/>\n";
 191   }
 192
 193   // Output the location.
 194   FullSourceLoc L = P.getLocation().asLocation();
 195
 196   Indent(o, indent) << "<key>location</key>\n";
 197   EmitLocation(o, SM, L, FM, indent);
 198
 199   // Output the ranges (if any).
 200   ArrayRef<SourceRange> Ranges = P.getRanges();
 201   EmitRanges(o, Ranges, FM, SM, LangOpts, indent);
 202
 203   // Output the call depth.
 204   Indent(o, indent) << "<key>depth</key>";
 205   EmitInteger(o, depth) << '\n';
 206
 207   // Output the text.
 208   EmitMessage(o, P.getString(), indent);
 209
 210   // Finish up.
 211   --indent;
 212   Indent(o, indent); o << "</dict>\n";
 213 }
 214
 215 static void ReportPiece(raw_ostream &o,
 216                         const PathDiagnosticPiece &P,
 217                         const FIDMap& FM, const SourceManager &SM,
 218                         const LangOptions &LangOpts,
 219                         unsigned indent,
 220                         unsigned depth,
 221                         bool includeControlFlow,
 222                         bool isKeyEvent = false);
 223
 224 static void ReportCall(raw_ostream &o,
 225                        const PathDiagnosticCallPiece &P,
 226                        const FIDMap& FM, const SourceManager &SM,
 227                        const LangOptions &LangOpts,
 228                        unsigned indent,
 229                        unsigned depth) {
 230
 231   if (auto callEnter = P.getCallEnterEvent())
 232     ReportPiece(o, *callEnter, FM, SM, LangOpts, indent, depth, true,
 233                 P.isLastInMainSourceFile());
 234
 235
 236   ++depth;
 237
 238   if (auto callEnterWithinCaller = P.getCallEnterWithinCallerEvent())
 239     ReportPiece(o, *callEnterWithinCaller, FM, SM, LangOpts,
 240                 indent, depth, true);
 241
 242   for (PathPieces::const_iterator I = P.path.begin(), E = P.path.end();I!=E;++I)
 243     ReportPiece(o, **I, FM, SM, LangOpts, indent, depth, true);
 244
 245   --depth;
 246
 247   if (auto callExit = P.getCallExitEvent())
 248     ReportPiece(o, *callExit, FM, SM, LangOpts, indent, depth, true);
 249 }
 250
 251 static void ReportMacro(raw_ostream &o,
 252                         const PathDiagnosticMacroPiece& P,
 253                         const FIDMap& FM, const SourceManager &SM,
 254                         const LangOptions &LangOpts,
 255                         unsigned indent,
 256                         unsigned depth) {
 257
 258   for (PathPieces::const_iterator I = P.subPieces.begin(), E=P.subPieces.end();
 259        I!=E; ++I) {
 260     ReportPiece(o, **I, FM, SM, LangOpts, indent, depth, false);
 261   }
 262 }
 263
 264 static void ReportNote(raw_ostream &o, const PathDiagnosticNotePiece& P,
 265                         const FIDMap& FM,
 266                         const SourceManager &SM,
 267                         const LangOptions &LangOpts,
 268                         unsigned indent,
 269                         unsigned depth) {
 270
 271   Indent(o, indent) << "<dict>\n";
 272   ++indent;
 273
 274   // Output the location.
 275   FullSourceLoc L = P.getLocation().asLocation();
 276
 277   Indent(o, indent) << "<key>location</key>\n";
 278   EmitLocation(o, SM, L, FM, indent);
 279
 280   // Output the ranges (if any).
 281   ArrayRef<SourceRange> Ranges = P.getRanges();
 282   EmitRanges(o, Ranges, FM, SM, LangOpts, indent);
 283
 284   // Output the text.
 285   EmitMessage(o, P.getString(), indent);
 286
 287   // Finish up.
 288   --indent;
 289   Indent(o, indent); o << "</dict>\n";
 290 }
 291
 292 static void ReportDiag(raw_ostream &o, const PathDiagnosticPiece& P,
 293                        const FIDMap& FM, const SourceManager &SM,
 294                        const LangOptions &LangOpts) {
 295   ReportPiece(o, P, FM, SM, LangOpts, 4, 0, true);
 296 }
 297
 298 static void ReportPiece(raw_ostream &o,
 299                         const PathDiagnosticPiece &P,
 300                         const FIDMap& FM, const SourceManager &SM,
 301                         const LangOptions &LangOpts,
 302                         unsigned indent,
 303                         unsigned depth,
 304                         bool includeControlFlow,
 305                         bool isKeyEvent) {
 306   switch (P.getKind()) {
 307     case PathDiagnosticPiece::ControlFlow:
 308       if (includeControlFlow)
 309         ReportControlFlow(o, cast<PathDiagnosticControlFlowPiece>(P), FM, SM,
 310                           LangOpts, indent);
 311       break;
 312     case PathDiagnosticPiece::Call:
 313       ReportCall(o, cast<PathDiagnosticCallPiece>(P), FM, SM, LangOpts,
 314                  indent, depth);
 315       break;
 316     case PathDiagnosticPiece::Event:
 317       ReportEvent(o, cast<PathDiagnosticEventPiece>(P), FM, SM, LangOpts,
 318                   indent, depth, isKeyEvent);
 319       break;
 320     case PathDiagnosticPiece::Macro:
 321       ReportMacro(o, cast<PathDiagnosticMacroPiece>(P), FM, SM, LangOpts,
 322                   indent, depth);
 323       break;
 324     case PathDiagnosticPiece::Note:
 325       ReportNote(o, cast<PathDiagnosticNotePiece>(P), FM, SM, LangOpts,
 326                   indent, depth);
 327       break;
 328   }
 329 }
 330
 331 void PlistDiagnostics::FlushDiagnosticsImpl(
 332                                     std::vector<const PathDiagnostic *> &Diags,
 333                                     FilesMade *filesMade) {
 334   // Build up a set of FIDs that we use by scanning the locations and
 335   // ranges of the diagnostics.
 336   FIDMap FM;
 337   SmallVector<FileID, 10> Fids;
 338   const SourceManager* SM = nullptr;
 339
 340   if (!Diags.empty())
 341     SM = &Diags.front()->path.front()->getLocation().getManager();
 342
 343   auto AddPieceFID = [&FM, &Fids, SM](const PathDiagnosticPiece &Piece) {
 344     AddFID(FM, Fids, *SM, Piece.getLocation().asLocation());
 345     ArrayRef<SourceRange> Ranges = Piece.getRanges();
 346     for (const SourceRange &Range : Ranges) {
 347       AddFID(FM, Fids, *SM, Range.getBegin());
 348       AddFID(FM, Fids, *SM, Range.getEnd());
 349     }
 350   };
 351
 352   for (const PathDiagnostic *D : Diags) {
 353
 354     SmallVector<const PathPieces *, 5> WorkList;
 355     WorkList.push_back(&D->path);
 356
 357     while (!WorkList.empty()) {
 358       const PathPieces &Path = *WorkList.pop_back_val();
 359
 360       for (const auto &Iter : Path) {
 361         const PathDiagnosticPiece &Piece = *Iter;
 362         AddPieceFID(Piece);
 363
 364         if (const PathDiagnosticCallPiece *Call =
 365                 dyn_cast<PathDiagnosticCallPiece>(&Piece)) {
 366           if (auto CallEnterWithin = Call->getCallEnterWithinCallerEvent())
 367             AddPieceFID(*CallEnterWithin);
 368
 369           if (auto CallEnterEvent = Call->getCallEnterEvent())
 370             AddPieceFID(*CallEnterEvent);
 371
 372           WorkList.push_back(&Call->path);
 373         } else if (const PathDiagnosticMacroPiece *Macro =
 374                        dyn_cast<PathDiagnosticMacroPiece>(&Piece)) {
 375           WorkList.push_back(&Macro->subPieces);
 376         }
 377       }
 378     }
 379   }
 380
 381   // Open the file.
 382   std::error_code EC;
 383   llvm::raw_fd_ostream o(OutputFile, EC, llvm::sys::fs::F_Text);
 384   if (EC) {
 385     llvm::errs() << "warning: could not create file: " << EC.message() << '\n';
 386     return;
 387   }
 388
 389   EmitPlistHeader(o);
 390
 391   // Write the root object: a <dict> containing...
 392   //  - "clang_version", the string representation of clang version
 393   //  - "files", an <array> mapping from FIDs to file names
 394   //  - "diagnostics", an <array> containing the path diagnostics
 395   o << "<dict>\n" <<
 396        " <key>clang_version</key>\n";
 397   EmitString(o, getClangFullVersion()) << '\n';
 398   o << " <key>files</key>\n"
 399        " <array>\n";
 400
 401   for (FileID FID : Fids)
 402     EmitString(o << "  ", SM->getFileEntryForID(FID)->getName()) << '\n';
 403
 404   o << " </array>\n"
 405        " <key>diagnostics</key>\n"
 406        " <array>\n";
 407
 408   for (std::vector<const PathDiagnostic*>::iterator DI=Diags.begin(),
 409        DE = Diags.end(); DI!=DE; ++DI) {
 410
 411     o << "  <dict>\n";
 412
 413     const PathDiagnostic *D = *DI;
 414     const PathPieces &PP = D->path;
 415
 416     assert(std::is_partitioned(
 417              PP.begin(), PP.end(),
 418              [](const std::shared_ptr<PathDiagnosticPiece> &E)
 419                { return E->getKind() == PathDiagnosticPiece::Note; }) &&
 420            "PathDiagnostic is not partitioned so that notes precede the rest");
 421
 422     PathPieces::const_iterator FirstNonNote = std::partition_point(
 423         PP.begin(), PP.end(),
 424         [](const std::shared_ptr<PathDiagnosticPiece> &E)
 425           { return E->getKind() == PathDiagnosticPiece::Note; });
 426
 427     PathPieces::const_iterator I = PP.begin();
 428
 429     if (FirstNonNote != PP.begin()) {
 430       o << "   <key>notes</key>\n"
 431            "   <array>\n";
 432
 433       for (; I != FirstNonNote; ++I)
 434         ReportDiag(o, **I, FM, *SM, LangOpts);
 435
 436       o << "   </array>\n";
 437     }
 438
 439     o << "   <key>path</key>\n";
 440
 441     o << "   <array>\n";
 442
 443     for (PathPieces::const_iterator E = PP.end(); I != E; ++I)
 444       ReportDiag(o, **I, FM, *SM, LangOpts);
 445
 446     o << "   </array>\n";
 447
 448     // Output the bug type and bug category.
 449     o << "   <key>description</key>";
 450     EmitString(o, D->getShortDescription()) << '\n';
 451     o << "   <key>category</key>";
 452     EmitString(o, D->getCategory()) << '\n';
 453     o << "   <key>type</key>";
 454     EmitString(o, D->getBugType()) << '\n';
 455     o << "   <key>check_name</key>";
 456     EmitString(o, D->getCheckName()) << '\n';
 457
 458     o << "   <!-- This hash is experimental and going to change! -->\n";
 459     o << "   <key>issue_hash_content_of_line_in_context</key>";
 460     PathDiagnosticLocation UPDLoc = D->getUniqueingLoc();
 461     FullSourceLoc L(SM->getExpansionLoc(UPDLoc.isValid()
 462                                             ? UPDLoc.asLocation()
 463                                             : D->getLocation().asLocation()),
 464                     *SM);
 465     const Decl *DeclWithIssue = D->getDeclWithIssue();
 466     EmitString(o, GetIssueHash(*SM, L, D->getCheckName(), D->getBugType(),
 467                                DeclWithIssue, LangOpts))
 468         << '\n';
 469
 470     // Output information about the semantic context where
 471     // the issue occurred.
 472     if (const Decl *DeclWithIssue = D->getDeclWithIssue()) {
 473       // FIXME: handle blocks, which have no name.
 474       if (const NamedDecl *ND = dyn_cast<NamedDecl>(DeclWithIssue)) {
 475         StringRef declKind;
 476         switch (ND->getKind()) {
 477           case Decl::CXXRecord:
 478             declKind = "C++ class";
 479             break;
 480           case Decl::CXXMethod:
 481             declKind = "C++ method";
 482             break;
 483           case Decl::ObjCMethod:
 484             declKind = "Objective-C method";
 485             break;
 486           case Decl::Function:
 487             declKind = "function";
 488             break;
 489           default:
 490             break;
 491         }
 492         if (!declKind.empty()) {
 493           const std::string &declName = ND->getDeclName().getAsString();
 494           o << "  <key>issue_context_kind</key>";
 495           EmitString(o, declKind) << '\n';
 496           o << "  <key>issue_context</key>";
 497           EmitString(o, declName) << '\n';
 498         }
 499
 500         // Output the bug hash for issue unique-ing. Currently, it's just an
 501         // offset from the beginning of the function.
 502         if (const Stmt *Body = DeclWithIssue->getBody()) {
 503
 504           // If the bug uniqueing location exists, use it for the hash.
 505           // For example, this ensures that two leaks reported on the same line
 506           // will have different issue_hashes and that the hash will identify
 507           // the leak location even after code is added between the allocation
 508           // site and the end of scope (leak report location).
 509           if (UPDLoc.isValid()) {
 510             FullSourceLoc UFunL(SM->getExpansionLoc(
 511               D->getUniqueingDecl()->getBody()->getLocStart()), *SM);
 512             o << "  <key>issue_hash_function_offset</key><string>"
 513               << L.getExpansionLineNumber() - UFunL.getExpansionLineNumber()
 514               << "</string>\n";
 515
 516           // Otherwise, use the location on which the bug is reported.
 517           } else {
 518             FullSourceLoc FunL(SM->getExpansionLoc(Body->getLocStart()), *SM);
 519             o << "  <key>issue_hash_function_offset</key><string>"
 520               << L.getExpansionLineNumber() - FunL.getExpansionLineNumber()
 521               << "</string>\n";
 522           }
 523
 524         }
 525       }
 526     }
 527
 528     // Output the location of the bug.
 529     o << "  <key>location</key>\n";
 530     EmitLocation(o, *SM, D->getLocation().asLocation(), FM, 2);
 531
 532     // Output the diagnostic to the sub-diagnostic client, if any.
 533     if (!filesMade->empty()) {
 534       StringRef lastName;
 535       PDFileEntry::ConsumerFiles *files = filesMade->getFiles(*D);
 536       if (files) {
 537         for (PDFileEntry::ConsumerFiles::const_iterator CI = files->begin(),
 538                 CE = files->end(); CI != CE; ++CI) {
 539           StringRef newName = CI->first;
 540           if (newName != lastName) {
 541             if (!lastName.empty()) {
 542               o << "  </array>\n";
 543             }
 544             lastName = newName;
 545             o <<  "  <key>" << lastName << "_files</key>\n";
 546             o << "  <array>\n";
 547           }
 548           o << "   <string>" << CI->second << "</string>\n";
 549         }
 550         o << "  </array>\n";
 551       }
 552     }
 553
 554     // Close up the entry.
 555     o << "  </dict>\n";
 556   }
 557
 558   o << " </array>\n";
 559
 560   if (llvm::AreStatisticsEnabled() && SerializeStatistics) {
 561     o << " <key>statistics</key>\n";
 562     std::string stats;
 563     llvm::raw_string_ostream os(stats);
 564     llvm::PrintStatisticsJSON(os);
 565     os.flush();
 566     EmitString(o, html::EscapeText(stats)) << '\n';
 567   }
 568
 569   // Finish.
 570   o << "</dict>\n</plist>";
 571 }