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/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
  15 #include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
  16 #include "clang/Basic/SourceManager.h"
  17 #include "clang/Basic/FileManager.h"
  18 #include "clang/Lex/Preprocessor.h"
  19 #include "llvm/Support/raw_ostream.h"
  20 #include "llvm/Support/Casting.h"
  21 #include "llvm/ADT/DenseMap.h"
  22 #include "llvm/ADT/SmallVector.h"
  23 using namespace clang;
  24 using namespace ento;
  25
  26 typedef llvm::DenseMap<FileID, unsigned> FIDMap;
  27
  28 namespace {
  29 struct CompareDiagnostics {
  30   // Compare if 'X' is "<" than 'Y'.
  31   bool operator()(const PathDiagnostic *X, const PathDiagnostic *Y) const {
  32     // First compare by location
  33     const FullSourceLoc &XLoc = X->getLocation().asLocation();
  34     const FullSourceLoc &YLoc = Y->getLocation().asLocation();
  35     if (XLoc < YLoc)
  36       return true;
  37     if (XLoc != YLoc)
  38       return false;
  39
  40     // Next, compare by bug type.
  41     StringRef XBugType = X->getBugType();
  42     StringRef YBugType = Y->getBugType();
  43     if (XBugType < YBugType)
  44       return true;
  45     if (XBugType != YBugType)
  46       return false;
  47
  48     // Next, compare by bug description.
  49     StringRef XDesc = X->getDescription();
  50     StringRef YDesc = Y->getDescription();
  51     if (XDesc < YDesc)
  52       return true;
  53     if (XDesc != YDesc)
  54       return false;
  55
  56     // FIXME: Further refine by comparing PathDiagnosticPieces?
  57     return false;
  58   }
  59 };
  60 }
  61
  62 namespace {
  63   class PlistDiagnostics : public PathDiagnosticConsumer {
  64     std::vector<const PathDiagnostic*> BatchedDiags;
  65     const std::string OutputFile;
  66     const LangOptions &LangOpts;
  67     llvm::OwningPtr<PathDiagnosticConsumer> SubPD;
  68     bool flushed;
  69   public:
  70     PlistDiagnostics(const std::string& prefix, const LangOptions &LangOpts,
  71                      PathDiagnosticConsumer *subPD);
  72
  73     ~PlistDiagnostics() { FlushDiagnostics(NULL); }
  74
  75     void FlushDiagnostics(SmallVectorImpl<std::string> *FilesMade);
  76
  77     void HandlePathDiagnosticImpl(const PathDiagnostic* D);
  78
  79     virtual StringRef getName() const {
  80       return "PlistDiagnostics";
  81     }
  82
  83     PathGenerationScheme getGenerationScheme() const;
  84     bool supportsLogicalOpControlFlow() const { return true; }
  85     bool supportsAllBlockEdges() const { return true; }
  86     virtual bool useVerboseDescription() const { return false; }
  87   };
  88 } // end anonymous namespace
  89
  90 PlistDiagnostics::PlistDiagnostics(const std::string& output,
  91                                    const LangOptions &LO,
  92                                    PathDiagnosticConsumer *subPD)
  93   : OutputFile(output), LangOpts(LO), SubPD(subPD), flushed(false) {}
  94
  95 PathDiagnosticConsumer*
  96 ento::createPlistDiagnosticConsumer(const std::string& s, const Preprocessor &PP,
  97                                   PathDiagnosticConsumer *subPD) {
  98   return new PlistDiagnostics(s, PP.getLangOptions(), subPD);
  99 }
 100
 101 PathDiagnosticConsumer::PathGenerationScheme
 102 PlistDiagnostics::getGenerationScheme() const {
 103   if (const PathDiagnosticConsumer *PD = SubPD.get())
 104     return PD->getGenerationScheme();
 105
 106   return Extensive;
 107 }
 108
 109 static void AddFID(FIDMap &FIDs, SmallVectorImpl<FileID> &V,
 110                    const SourceManager* SM, SourceLocation L) {
 111
 112   FileID FID = SM->getFileID(SM->getExpansionLoc(L));
 113   FIDMap::iterator I = FIDs.find(FID);
 114   if (I != FIDs.end()) return;
 115   FIDs[FID] = V.size();
 116   V.push_back(FID);
 117 }
 118
 119 static unsigned GetFID(const FIDMap& FIDs, const SourceManager &SM,
 120                        SourceLocation L) {
 121   FileID FID = SM.getFileID(SM.getExpansionLoc(L));
 122   FIDMap::const_iterator I = FIDs.find(FID);
 123   assert(I != FIDs.end());
 124   return I->second;
 125 }
 126
 127 static raw_ostream &Indent(raw_ostream &o, const unsigned indent) {
 128   for (unsigned i = 0; i < indent; ++i) o << ' ';
 129   return o;
 130 }
 131
 132 static void EmitLocation(raw_ostream &o, const SourceManager &SM,
 133                          const LangOptions &LangOpts,
 134                          SourceLocation L, const FIDMap &FM,
 135                          unsigned indent, bool extend = false) {
 136
 137   FullSourceLoc Loc(SM.getExpansionLoc(L), const_cast<SourceManager&>(SM));
 138
 139   // Add in the length of the token, so that we cover multi-char tokens.
 140   unsigned offset =
 141     extend ? Lexer::MeasureTokenLength(Loc, SM, LangOpts) - 1 : 0;
 142
 143   Indent(o, indent) << "<dict>\n";
 144   Indent(o, indent) << " <key>line</key><integer>"
 145                     << Loc.getExpansionLineNumber() << "</integer>\n";
 146   Indent(o, indent) << " <key>col</key><integer>"
 147                     << Loc.getExpansionColumnNumber() + offset << "</integer>\n";
 148   Indent(o, indent) << " <key>file</key><integer>"
 149                     << GetFID(FM, SM, Loc) << "</integer>\n";
 150   Indent(o, indent) << "</dict>\n";
 151 }
 152
 153 static void EmitLocation(raw_ostream &o, const SourceManager &SM,
 154                          const LangOptions &LangOpts,
 155                          const PathDiagnosticLocation &L, const FIDMap& FM,
 156                          unsigned indent, bool extend = false) {
 157   EmitLocation(o, SM, LangOpts, L.asLocation(), FM, indent, extend);
 158 }
 159
 160 static void EmitRange(raw_ostream &o, const SourceManager &SM,
 161                       const LangOptions &LangOpts,
 162                       PathDiagnosticRange R, const FIDMap &FM,
 163                       unsigned indent) {
 164   Indent(o, indent) << "<array>\n";
 165   EmitLocation(o, SM, LangOpts, R.getBegin(), FM, indent+1);
 166   EmitLocation(o, SM, LangOpts, R.getEnd(), FM, indent+1, !R.isPoint);
 167   Indent(o, indent) << "</array>\n";
 168 }
 169
 170 static raw_ostream &EmitString(raw_ostream &o,
 171                                      const std::string& s) {
 172   o << "<string>";
 173   for (std::string::const_iterator I=s.begin(), E=s.end(); I!=E; ++I) {
 174     char c = *I;
 175     switch (c) {
 176     default:   o << c; break;
 177     case '&':  o << "&amp;"; break;
 178     case '<':  o << "&lt;"; break;
 179     case '>':  o << "&gt;"; break;
 180     case '\'': o << "&apos;"; break;
 181     case '\"': o << "&quot;"; break;
 182     }
 183   }
 184   o << "</string>";
 185   return o;
 186 }
 187
 188 static void ReportControlFlow(raw_ostream &o,
 189                               const PathDiagnosticControlFlowPiece& P,
 190                               const FIDMap& FM,
 191                               const SourceManager &SM,
 192                               const LangOptions &LangOpts,
 193                               unsigned indent) {
 194
 195   Indent(o, indent) << "<dict>\n";
 196   ++indent;
 197
 198   Indent(o, indent) << "<key>kind</key><string>control</string>\n";
 199
 200   // Emit edges.
 201   Indent(o, indent) << "<key>edges</key>\n";
 202   ++indent;
 203   Indent(o, indent) << "<array>\n";
 204   ++indent;
 205   for (PathDiagnosticControlFlowPiece::const_iterator I=P.begin(), E=P.end();
 206        I!=E; ++I) {
 207     Indent(o, indent) << "<dict>\n";
 208     ++indent;
 209     Indent(o, indent) << "<key>start</key>\n";
 210     EmitRange(o, SM, LangOpts, I->getStart().asRange(), FM, indent+1);
 211     Indent(o, indent) << "<key>end</key>\n";
 212     EmitRange(o, SM, LangOpts, I->getEnd().asRange(), FM, indent+1);
 213     --indent;
 214     Indent(o, indent) << "</dict>\n";
 215   }
 216   --indent;
 217   Indent(o, indent) << "</array>\n";
 218   --indent;
 219
 220   // Output any helper text.
 221   const std::string& s = P.getString();
 222   if (!s.empty()) {
 223     Indent(o, indent) << "<key>alternate</key>";
 224     EmitString(o, s) << '\n';
 225   }
 226
 227   --indent;
 228   Indent(o, indent) << "</dict>\n";
 229 }
 230
 231 static void ReportEvent(raw_ostream &o, const PathDiagnosticPiece& P,
 232                         const FIDMap& FM,
 233                         const SourceManager &SM,
 234                         const LangOptions &LangOpts,
 235                         unsigned indent) {
 236
 237   Indent(o, indent) << "<dict>\n";
 238   ++indent;
 239
 240   Indent(o, indent) << "<key>kind</key><string>event</string>\n";
 241
 242   // Output the location.
 243   FullSourceLoc L = P.getLocation().asLocation();
 244
 245   Indent(o, indent) << "<key>location</key>\n";
 246   EmitLocation(o, SM, LangOpts, L, FM, indent);
 247
 248   // Output the ranges (if any).
 249   PathDiagnosticPiece::range_iterator RI = P.ranges_begin(),
 250   RE = P.ranges_end();
 251
 252   if (RI != RE) {
 253     Indent(o, indent) << "<key>ranges</key>\n";
 254     Indent(o, indent) << "<array>\n";
 255     ++indent;
 256     for (; RI != RE; ++RI)
 257       EmitRange(o, SM, LangOpts, *RI, FM, indent+1);
 258     --indent;
 259     Indent(o, indent) << "</array>\n";
 260   }
 261
 262   // Output the text.
 263   assert(!P.getString().empty());
 264   Indent(o, indent) << "<key>extended_message</key>\n";
 265   Indent(o, indent);
 266   EmitString(o, P.getString()) << '\n';
 267
 268   // Output the short text.
 269   // FIXME: Really use a short string.
 270   Indent(o, indent) << "<key>message</key>\n";
 271   EmitString(o, P.getString()) << '\n';
 272
 273   // Finish up.
 274   --indent;
 275   Indent(o, indent); o << "</dict>\n";
 276 }
 277
 278 static void ReportMacro(raw_ostream &o,
 279                         const PathDiagnosticMacroPiece& P,
 280                         const FIDMap& FM, const SourceManager &SM,
 281                         const LangOptions &LangOpts,
 282                         unsigned indent) {
 283
 284   for (PathDiagnosticMacroPiece::const_iterator I=P.begin(), E=P.end();
 285        I!=E; ++I) {
 286
 287     switch ((*I)->getKind()) {
 288     default:
 289       break;
 290     case PathDiagnosticPiece::Event:
 291       ReportEvent(o, cast<PathDiagnosticEventPiece>(**I), FM, SM, LangOpts,
 292                   indent);
 293       break;
 294     case PathDiagnosticPiece::Macro:
 295       ReportMacro(o, cast<PathDiagnosticMacroPiece>(**I), FM, SM, LangOpts,
 296                   indent);
 297       break;
 298     }
 299   }
 300 }
 301
 302 static void ReportDiag(raw_ostream &o, const PathDiagnosticPiece& P,
 303                        const FIDMap& FM, const SourceManager &SM,
 304                        const LangOptions &LangOpts) {
 305
 306   unsigned indent = 4;
 307
 308   switch (P.getKind()) {
 309   case PathDiagnosticPiece::ControlFlow:
 310     ReportControlFlow(o, cast<PathDiagnosticControlFlowPiece>(P), FM, SM,
 311                       LangOpts, indent);
 312     break;
 313   case PathDiagnosticPiece::Event:
 314     ReportEvent(o, cast<PathDiagnosticEventPiece>(P), FM, SM, LangOpts,
 315                 indent);
 316     break;
 317   case PathDiagnosticPiece::Macro:
 318     ReportMacro(o, cast<PathDiagnosticMacroPiece>(P), FM, SM, LangOpts,
 319                 indent);
 320     break;
 321   }
 322 }
 323
 324 void PlistDiagnostics::HandlePathDiagnosticImpl(const PathDiagnostic* D) {
 325   if (!D)
 326     return;
 327
 328   if (D->empty()) {
 329     delete D;
 330     return;
 331   }
 332
 333   // We need to flatten the locations (convert Stmt* to locations) because
 334   // the referenced statements may be freed by the time the diagnostics
 335   // are emitted.
 336   const_cast<PathDiagnostic*>(D)->flattenLocations();
 337   BatchedDiags.push_back(D);
 338 }
 339
 340 void PlistDiagnostics::FlushDiagnostics(SmallVectorImpl<std::string>
 341                                         *FilesMade) {
 342
 343   if (flushed)
 344     return;
 345
 346   flushed = true;
 347
 348   // Sort the diagnostics so that they are always emitted in a deterministic
 349   // order.
 350   if (!BatchedDiags.empty())
 351     std::sort(BatchedDiags.begin(), BatchedDiags.end(), CompareDiagnostics());
 352
 353   // Build up a set of FIDs that we use by scanning the locations and
 354   // ranges of the diagnostics.
 355   FIDMap FM;
 356   SmallVector<FileID, 10> Fids;
 357   const SourceManager* SM = 0;
 358
 359   if (!BatchedDiags.empty())
 360     SM = &(*BatchedDiags.begin())->begin()->getLocation().getManager();
 361
 362   for (std::vector<const PathDiagnostic*>::iterator DI = BatchedDiags.begin(),
 363        DE = BatchedDiags.end(); DI != DE; ++DI) {
 364
 365     const PathDiagnostic *D = *DI;
 366
 367     for (PathDiagnostic::const_iterator I=D->begin(), E=D->end(); I!=E; ++I) {
 368       AddFID(FM, Fids, SM, I->getLocation().asLocation());
 369
 370       for (PathDiagnosticPiece::range_iterator RI=I->ranges_begin(),
 371            RE=I->ranges_end(); RI!=RE; ++RI) {
 372         AddFID(FM, Fids, SM, RI->getBegin());
 373         AddFID(FM, Fids, SM, RI->getEnd());
 374       }
 375     }
 376   }
 377
 378   // Open the file.
 379   std::string ErrMsg;
 380   llvm::raw_fd_ostream o(OutputFile.c_str(), ErrMsg);
 381   if (!ErrMsg.empty()) {
 382     llvm::errs() << "warning: could not creat file: " << OutputFile << '\n';
 383     return;
 384   }
 385
 386   // Write the plist header.
 387   o << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
 388   "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\" "
 389   "\"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
 390   "<plist version=\"1.0\">\n";
 391
 392   // Write the root object: a <dict> containing...
 393   //  - "files", an <array> mapping from FIDs to file names
 394   //  - "diagnostics", an <array> containing the path diagnostics
 395   o << "<dict>\n"
 396        " <key>files</key>\n"
 397        " <array>\n";
 398
 399   for (SmallVectorImpl<FileID>::iterator I=Fids.begin(), E=Fids.end();
 400        I!=E; ++I) {
 401     o << "  ";
 402     EmitString(o, SM->getFileEntryForID(*I)->getName()) << '\n';
 403   }
 404
 405   o << " </array>\n"
 406        " <key>diagnostics</key>\n"
 407        " <array>\n";
 408
 409   for (std::vector<const PathDiagnostic*>::iterator DI=BatchedDiags.begin(),
 410        DE = BatchedDiags.end(); DI!=DE; ++DI) {
 411
 412     o << "  <dict>\n"
 413          "   <key>path</key>\n";
 414
 415     const PathDiagnostic *D = *DI;
 416     // Create an owning smart pointer for 'D' just so that we auto-free it
 417     // when we exit this method.
 418     llvm::OwningPtr<PathDiagnostic> OwnedD(const_cast<PathDiagnostic*>(D));
 419
 420     o << "   <array>\n";
 421
 422     for (PathDiagnostic::const_iterator I=D->begin(), E=D->end(); I != E; ++I)
 423       ReportDiag(o, *I, FM, *SM, LangOpts);
 424
 425     o << "   </array>\n";
 426
 427     // Output the bug type and bug category.
 428     o << "   <key>description</key>";
 429     EmitString(o, D->getDescription()) << '\n';
 430     o << "   <key>category</key>";
 431     EmitString(o, D->getCategory()) << '\n';
 432     o << "   <key>type</key>";
 433     EmitString(o, D->getBugType()) << '\n';
 434
 435     // Output the location of the bug.
 436     o << "  <key>location</key>\n";
 437     EmitLocation(o, *SM, LangOpts, D->getLocation(), FM, 2);
 438
 439     // Output the diagnostic to the sub-diagnostic client, if any.
 440     if (SubPD) {
 441       SubPD->HandlePathDiagnostic(OwnedD.take());
 442       SmallVector<std::string, 1> SubFilesMade;
 443       SubPD->FlushDiagnostics(SubFilesMade);
 444
 445       if (!SubFilesMade.empty()) {
 446         o << "  <key>" << SubPD->getName() << "_files</key>\n";
 447         o << "  <array>\n";
 448         for (size_t i = 0, n = SubFilesMade.size(); i < n ; ++i)
 449           o << "   <string>" << SubFilesMade[i] << "</string>\n";
 450         o << "  </array>\n";
 451       }
 452     }
 453
 454     // Close up the entry.
 455     o << "  </dict>\n";
 456   }
 457
 458   o << " </array>\n";
 459
 460   // Finish.
 461   o << "</dict>\n</plist>";
 462
 463   if (FilesMade)
 464     FilesMade->push_back(OutputFile);
 465
 466   BatchedDiags.clear();
 467 }