Home | History | Annotate | Download | only in Frontend 
      1 //===--- AnalysisConsumer.cpp - ASTConsumer for running Analyses ----------===//
      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 // "Meta" ASTConsumer for running different source analyses.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #include "AnalysisConsumer.h"
     15 #include "clang/AST/ASTConsumer.h"
     16 #include "clang/AST/Decl.h"
     17 #include "clang/AST/DeclCXX.h"
     18 #include "clang/AST/DeclObjC.h"
     19 #include "clang/AST/ParentMap.h"
     20 #include "clang/Analysis/CFG.h"
     21 #include "clang/StaticAnalyzer/Frontend/CheckerRegistration.h"
     22 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
     23 #include "clang/StaticAnalyzer/Checkers/LocalCheckers.h"
     24 #include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
     25 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
     26 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
     27 #include "clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h"
     28 #include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
     29 
     30 #include "clang/Basic/FileManager.h"
     31 #include "clang/Basic/SourceManager.h"
     32 #include "clang/Frontend/AnalyzerOptions.h"
     33 #include "clang/Lex/Preprocessor.h"
     34 #include "llvm/Support/raw_ostream.h"
     35 #include "llvm/Support/Path.h"
     36 #include "llvm/Support/Program.h"
     37 #include "llvm/ADT/OwningPtr.h"
     38 
     39 using namespace clang;
     40 using namespace ento;
     41 
     42 static ExplodedNode::Auditor* CreateUbiViz();
     43 
     44 //===----------------------------------------------------------------------===//
     45 // Special PathDiagnosticConsumers.
     46 //===----------------------------------------------------------------------===//
     47 
     48 static PathDiagnosticConsumer*
     49 createPlistHTMLDiagnosticConsumer(const std::string& prefix,
     50                                 const Preprocessor &PP) {
     51   PathDiagnosticConsumer *PD =
     52     createHTMLDiagnosticConsumer(llvm::sys::path::parent_path(prefix), PP);
     53   return createPlistDiagnosticConsumer(prefix, PP, PD);
     54 }
     55 
     56 //===----------------------------------------------------------------------===//
     57 // AnalysisConsumer declaration.
     58 //===----------------------------------------------------------------------===//
     59 
     60 namespace {
     61 
     62 class AnalysisConsumer : public ASTConsumer {
     63 public:
     64   ASTContext *Ctx;
     65   const Preprocessor &PP;
     66   const std::string OutDir;
     67   AnalyzerOptions Opts;
     68   ArrayRef<std::string> Plugins;
     69 
     70   // PD is owned by AnalysisManager.
     71   PathDiagnosticConsumer *PD;
     72 
     73   StoreManagerCreator CreateStoreMgr;
     74   ConstraintManagerCreator CreateConstraintMgr;
     75 
     76   llvm::OwningPtr<CheckerManager> checkerMgr;
     77   llvm::OwningPtr<AnalysisManager> Mgr;
     78 
     79   AnalysisConsumer(const Preprocessor& pp,
     80                    const std::string& outdir,
     81                    const AnalyzerOptions& opts,
     82                    ArrayRef<std::string> plugins)
     83     : Ctx(0), PP(pp), OutDir(outdir), Opts(opts), Plugins(plugins), PD(0) {
     84     DigestAnalyzerOptions();
     85   }
     86 
     87   void DigestAnalyzerOptions() {
     88     // Create the PathDiagnosticConsumer.
     89     if (!OutDir.empty()) {
     90       switch (Opts.AnalysisDiagOpt) {
     91       default:
     92 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATEFN, AUTOCREATE) \
     93         case PD_##NAME: PD = CREATEFN(OutDir, PP); break;
     94 #include "clang/Frontend/Analyses.def"
     95       }
     96     } else if (Opts.AnalysisDiagOpt == PD_TEXT) {
     97       // Create the text client even without a specified output file since
     98       // it just uses diagnostic notes.
     99       PD = createTextPathDiagnosticConsumer("", PP);
    100     }
    101 
    102     // Create the analyzer component creators.
    103     switch (Opts.AnalysisStoreOpt) {
    104     default:
    105       llvm_unreachable("Unknown store manager.");
    106 #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATEFN)           \
    107       case NAME##Model: CreateStoreMgr = CREATEFN; break;
    108 #include "clang/Frontend/Analyses.def"
    109     }
    110 
    111     switch (Opts.AnalysisConstraintsOpt) {
    112     default:
    113       llvm_unreachable("Unknown store manager.");
    114 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATEFN)     \
    115       case NAME##Model: CreateConstraintMgr = CREATEFN; break;
    116 #include "clang/Frontend/Analyses.def"
    117     }
    118   }
    119 
    120   void DisplayFunction(const Decl *D) {
    121     if (!Opts.AnalyzerDisplayProgress)
    122       return;
    123 
    124     SourceManager &SM = Mgr->getASTContext().getSourceManager();
    125     PresumedLoc Loc = SM.getPresumedLoc(D->getLocation());
    126     if (Loc.isValid()) {
    127       llvm::errs() << "ANALYZE: " << Loc.getFilename();
    128 
    129       if (isa<FunctionDecl>(D) || isa<ObjCMethodDecl>(D)) {
    130         const NamedDecl *ND = cast<NamedDecl>(D);
    131         llvm::errs() << ' ' << *ND << '\n';
    132       }
    133       else if (isa<BlockDecl>(D)) {
    134         llvm::errs() << ' ' << "block(line:" << Loc.getLine() << ",col:"
    135                      << Loc.getColumn() << '\n';
    136       }
    137       else if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
    138         Selector S = MD->getSelector();
    139         llvm::errs() << ' ' << S.getAsString();
    140       }
    141     }
    142   }
    143 
    144   virtual void Initialize(ASTContext &Context) {
    145     Ctx = &Context;
    146     checkerMgr.reset(createCheckerManager(Opts, PP.getLangOptions(), Plugins,
    147                                           PP.getDiagnostics()));
    148     Mgr.reset(new AnalysisManager(*Ctx, PP.getDiagnostics(),
    149                                   PP.getLangOptions(), PD,
    150                                   CreateStoreMgr, CreateConstraintMgr,
    151                                   checkerMgr.get(),
    152                                   /* Indexer */ 0,
    153                                   Opts.MaxNodes, Opts.MaxLoop,
    154                                   Opts.VisualizeEGDot, Opts.VisualizeEGUbi,
    155                                   Opts.AnalysisPurgeOpt, Opts.EagerlyAssume,
    156                                   Opts.TrimGraph, Opts.InlineCall,
    157                                   Opts.UnoptimizedCFG, Opts.CFGAddImplicitDtors,
    158                                   Opts.CFGAddInitializers,
    159                                   Opts.EagerlyTrimEGraph));
    160   }
    161 
    162   virtual void HandleTranslationUnit(ASTContext &C);
    163   void HandleDeclContext(ASTContext &C, DeclContext *dc);
    164   void HandleDeclContextDecl(ASTContext &C, Decl *D);
    165 
    166   void HandleCode(Decl *D);
    167 };
    168 } // end anonymous namespace
    169 
    170 //===----------------------------------------------------------------------===//
    171 // AnalysisConsumer implementation.
    172 //===----------------------------------------------------------------------===//
    173 
    174 void AnalysisConsumer::HandleDeclContext(ASTContext &C, DeclContext *dc) {
    175   for (DeclContext::decl_iterator I = dc->decls_begin(), E = dc->decls_end();
    176        I != E; ++I) {
    177     HandleDeclContextDecl(C, *I);
    178   }
    179 }
    180 
    181 void AnalysisConsumer::HandleDeclContextDecl(ASTContext &C, Decl *D) {
    182   { // Handle callbacks for arbitrary decls.
    183     BugReporter BR(*Mgr);
    184     checkerMgr->runCheckersOnASTDecl(D, *Mgr, BR);
    185   }
    186 
    187   switch (D->getKind()) {
    188     case Decl::Namespace: {
    189       HandleDeclContext(C, cast<NamespaceDecl>(D));
    190       break;
    191     }
    192     case Decl::CXXConstructor:
    193     case Decl::CXXDestructor:
    194     case Decl::CXXConversion:
    195     case Decl::CXXMethod:
    196     case Decl::Function: {
    197       FunctionDecl *FD = cast<FunctionDecl>(D);
    198       // We skip function template definitions, as their semantics is
    199       // only determined when they are instantiated.
    200       if (FD->isThisDeclarationADefinition() &&
    201           !FD->isDependentContext()) {
    202         if (!Opts.AnalyzeSpecificFunction.empty() &&
    203             FD->getDeclName().getAsString() != Opts.AnalyzeSpecificFunction)
    204           break;
    205         DisplayFunction(FD);
    206         HandleCode(FD);
    207       }
    208       break;
    209     }
    210 
    211     case Decl::ObjCCategoryImpl:
    212     case Decl::ObjCImplementation: {
    213       ObjCImplDecl *ID = cast<ObjCImplDecl>(D);
    214       HandleCode(ID);
    215 
    216       for (ObjCContainerDecl::method_iterator MI = ID->meth_begin(),
    217            ME = ID->meth_end(); MI != ME; ++MI) {
    218         BugReporter BR(*Mgr);
    219         checkerMgr->runCheckersOnASTDecl(*MI, *Mgr, BR);
    220 
    221         if ((*MI)->isThisDeclarationADefinition()) {
    222           if (!Opts.AnalyzeSpecificFunction.empty() &&
    223               Opts.AnalyzeSpecificFunction !=
    224                 (*MI)->getSelector().getAsString())
    225             continue;
    226           DisplayFunction(*MI);
    227           HandleCode(*MI);
    228         }
    229       }
    230       break;
    231     }
    232 
    233     default:
    234       break;
    235   }
    236 }
    237 
    238 void AnalysisConsumer::HandleTranslationUnit(ASTContext &C) {
    239   BugReporter BR(*Mgr);
    240   TranslationUnitDecl *TU = C.getTranslationUnitDecl();
    241   checkerMgr->runCheckersOnASTDecl(TU, *Mgr, BR);
    242   HandleDeclContext(C, TU);
    243 
    244   // After all decls handled, run checkers on the entire TranslationUnit.
    245   checkerMgr->runCheckersOnEndOfTranslationUnit(TU, *Mgr, BR);
    246 
    247   // Explicitly destroy the PathDiagnosticConsumer.  This will flush its output.
    248   // FIXME: This should be replaced with something that doesn't rely on
    249   // side-effects in PathDiagnosticConsumer's destructor. This is required when
    250   // used with option -disable-free.
    251   Mgr.reset(NULL);
    252 }
    253 
    254 static void FindBlocks(DeclContext *D, SmallVectorImpl<Decl*> &WL) {
    255   if (BlockDecl *BD = dyn_cast<BlockDecl>(D))
    256     WL.push_back(BD);
    257 
    258   for (DeclContext::decl_iterator I = D->decls_begin(), E = D->decls_end();
    259        I!=E; ++I)
    260     if (DeclContext *DC = dyn_cast<DeclContext>(*I))
    261       FindBlocks(DC, WL);
    262 }
    263 
    264 static void RunPathSensitiveChecks(AnalysisConsumer &C, AnalysisManager &mgr,
    265                                    Decl *D);
    266 
    267 void AnalysisConsumer::HandleCode(Decl *D) {
    268 
    269   // Don't run the actions if an error has occurred with parsing the file.
    270   DiagnosticsEngine &Diags = PP.getDiagnostics();
    271   if (Diags.hasErrorOccurred() || Diags.hasFatalErrorOccurred())
    272     return;
    273 
    274   // Don't run the actions on declarations in header files unless
    275   // otherwise specified.
    276   SourceManager &SM = Ctx->getSourceManager();
    277   SourceLocation SL = SM.getExpansionLoc(D->getLocation());
    278   if (!Opts.AnalyzeAll && !SM.isFromMainFile(SL))
    279     return;
    280 
    281   // Clear the AnalysisManager of old AnalysisContexts.
    282   Mgr->ClearContexts();
    283 
    284   // Dispatch on the actions.
    285   SmallVector<Decl*, 10> WL;
    286   WL.push_back(D);
    287 
    288   if (D->hasBody() && Opts.AnalyzeNestedBlocks)
    289     FindBlocks(cast<DeclContext>(D), WL);
    290 
    291   BugReporter BR(*Mgr);
    292   for (SmallVectorImpl<Decl*>::iterator WI=WL.begin(), WE=WL.end();
    293        WI != WE; ++WI)
    294     if ((*WI)->hasBody()) {
    295       checkerMgr->runCheckersOnASTBody(*WI, *Mgr, BR);
    296       if (checkerMgr->hasPathSensitiveCheckers())
    297         RunPathSensitiveChecks(*this, *Mgr, *WI);
    298     }
    299 }
    300 
    301 //===----------------------------------------------------------------------===//
    302 // Path-sensitive checking.
    303 //===----------------------------------------------------------------------===//
    304 
    305 static void ActionExprEngine(AnalysisConsumer &C, AnalysisManager &mgr,
    306                              Decl *D, bool ObjCGCEnabled) {
    307   // Construct the analysis engine.  First check if the CFG is valid.
    308   // FIXME: Inter-procedural analysis will need to handle invalid CFGs.
    309   if (!mgr.getCFG(D))
    310     return;
    311   ExprEngine Eng(mgr, ObjCGCEnabled);
    312 
    313   // Set the graph auditor.
    314   llvm::OwningPtr<ExplodedNode::Auditor> Auditor;
    315   if (mgr.shouldVisualizeUbigraph()) {
    316     Auditor.reset(CreateUbiViz());
    317     ExplodedNode::SetAuditor(Auditor.get());
    318   }
    319 
    320   // Execute the worklist algorithm.
    321   Eng.ExecuteWorkList(mgr.getStackFrame(D, 0), mgr.getMaxNodes());
    322 
    323   // Release the auditor (if any) so that it doesn't monitor the graph
    324   // created BugReporter.
    325   ExplodedNode::SetAuditor(0);
    326 
    327   // Visualize the exploded graph.
    328   if (mgr.shouldVisualizeGraphviz())
    329     Eng.ViewGraph(mgr.shouldTrimGraph());
    330 
    331   // Display warnings.
    332   Eng.getBugReporter().FlushReports();
    333 }
    334 
    335 static void RunPathSensitiveChecks(AnalysisConsumer &C, AnalysisManager &mgr,
    336                                    Decl *D) {
    337 
    338   switch (mgr.getLangOptions().getGC()) {
    339   default:
    340     llvm_unreachable("Invalid GC mode.");
    341   case LangOptions::NonGC:
    342     ActionExprEngine(C, mgr, D, false);
    343     break;
    344 
    345   case LangOptions::GCOnly:
    346     ActionExprEngine(C, mgr, D, true);
    347     break;
    348 
    349   case LangOptions::HybridGC:
    350     ActionExprEngine(C, mgr, D, false);
    351     ActionExprEngine(C, mgr, D, true);
    352     break;
    353   }
    354 }
    355 
    356 //===----------------------------------------------------------------------===//
    357 // AnalysisConsumer creation.
    358 //===----------------------------------------------------------------------===//
    359 
    360 ASTConsumer* ento::CreateAnalysisConsumer(const Preprocessor& pp,
    361                                           const std::string& outDir,
    362                                           const AnalyzerOptions& opts,
    363                                           ArrayRef<std::string> plugins) {
    364   // Disable the effects of '-Werror' when using the AnalysisConsumer.
    365   pp.getDiagnostics().setWarningsAsErrors(false);
    366 
    367   return new AnalysisConsumer(pp, outDir, opts, plugins);
    368 }
    369 
    370 //===----------------------------------------------------------------------===//
    371 // Ubigraph Visualization.  FIXME: Move to separate file.
    372 //===----------------------------------------------------------------------===//
    373 
    374 namespace {
    375 
    376 class UbigraphViz : public ExplodedNode::Auditor {
    377   llvm::OwningPtr<raw_ostream> Out;
    378   llvm::sys::Path Dir, Filename;
    379   unsigned Cntr;
    380 
    381   typedef llvm::DenseMap<void*,unsigned> VMap;
    382   VMap M;
    383 
    384 public:
    385   UbigraphViz(raw_ostream *out, llvm::sys::Path& dir,
    386               llvm::sys::Path& filename);
    387 
    388   ~UbigraphViz();
    389 
    390   virtual void AddEdge(ExplodedNode *Src, ExplodedNode *Dst);
    391 };
    392 
    393 } // end anonymous namespace
    394 
    395 static ExplodedNode::Auditor* CreateUbiViz() {
    396   std::string ErrMsg;
    397 
    398   llvm::sys::Path Dir = llvm::sys::Path::GetTemporaryDirectory(&ErrMsg);
    399   if (!ErrMsg.empty())
    400     return 0;
    401 
    402   llvm::sys::Path Filename = Dir;
    403   Filename.appendComponent("llvm_ubi");
    404   Filename.makeUnique(true,&ErrMsg);
    405 
    406   if (!ErrMsg.empty())
    407     return 0;
    408 
    409   llvm::errs() << "Writing '" << Filename.str() << "'.\n";
    410 
    411   llvm::OwningPtr<llvm::raw_fd_ostream> Stream;
    412   Stream.reset(new llvm::raw_fd_ostream(Filename.c_str(), ErrMsg));
    413 
    414   if (!ErrMsg.empty())
    415     return 0;
    416 
    417   return new UbigraphViz(Stream.take(), Dir, Filename);
    418 }
    419 
    420 void UbigraphViz::AddEdge(ExplodedNode *Src, ExplodedNode *Dst) {
    421 
    422   assert (Src != Dst && "Self-edges are not allowed.");
    423 
    424   // Lookup the Src.  If it is a new node, it's a root.
    425   VMap::iterator SrcI= M.find(Src);
    426   unsigned SrcID;
    427 
    428   if (SrcI == M.end()) {
    429     M[Src] = SrcID = Cntr++;
    430     *Out << "('vertex', " << SrcID << ", ('color','#00ff00'))\n";
    431   }
    432   else
    433     SrcID = SrcI->second;
    434 
    435   // Lookup the Dst.
    436   VMap::iterator DstI= M.find(Dst);
    437   unsigned DstID;
    438 
    439   if (DstI == M.end()) {
    440     M[Dst] = DstID = Cntr++;
    441     *Out << "('vertex', " << DstID << ")\n";
    442   }
    443   else {
    444     // We have hit DstID before.  Change its style to reflect a cache hit.
    445     DstID = DstI->second;
    446     *Out << "('change_vertex_style', " << DstID << ", 1)\n";
    447   }
    448 
    449   // Add the edge.
    450   *Out << "('edge', " << SrcID << ", " << DstID
    451        << ", ('arrow','true'), ('oriented', 'true'))\n";
    452 }
    453 
    454 UbigraphViz::UbigraphViz(raw_ostream *out, llvm::sys::Path& dir,
    455                          llvm::sys::Path& filename)
    456   : Out(out), Dir(dir), Filename(filename), Cntr(0) {
    457 
    458   *Out << "('vertex_style_attribute', 0, ('shape', 'icosahedron'))\n";
    459   *Out << "('vertex_style', 1, 0, ('shape', 'sphere'), ('color', '#ffcc66'),"
    460           " ('size', '1.5'))\n";
    461 }
    462 
    463 UbigraphViz::~UbigraphViz() {
    464   Out.reset(0);
    465   llvm::errs() << "Running 'ubiviz' program... ";
    466   std::string ErrMsg;
    467   llvm::sys::Path Ubiviz = llvm::sys::Program::FindProgramByName("ubiviz");
    468   std::vector<const char*> args;
    469   args.push_back(Ubiviz.c_str());
    470   args.push_back(Filename.c_str());
    471   args.push_back(0);
    472 
    473   if (llvm::sys::Program::ExecuteAndWait(Ubiviz, &args[0],0,0,0,0,&ErrMsg)) {
    474     llvm::errs() << "Error viewing graph: " << ErrMsg << "\n";
    475   }
    476 
    477   // Delete the directory.
    478   Dir.eraseFromDisk(true);
    479 }
    480