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 #define DEBUG_TYPE "AnalysisConsumer"
     15 
     16 #include "AnalysisConsumer.h"
     17 #include "clang/AST/ASTConsumer.h"
     18 #include "clang/AST/Decl.h"
     19 #include "clang/AST/DeclCXX.h"
     20 #include "clang/AST/DeclObjC.h"
     21 #include "clang/AST/ParentMap.h"
     22 #include "clang/AST/RecursiveASTVisitor.h"
     23 #include "clang/Analysis/CFG.h"
     24 #include "clang/Analysis/CallGraph.h"
     25 #include "clang/StaticAnalyzer/Frontend/CheckerRegistration.h"
     26 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
     27 #include "clang/StaticAnalyzer/Checkers/LocalCheckers.h"
     28 #include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
     29 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
     30 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
     31 #include "clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h"
     32 #include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
     33 
     34 #include "clang/Basic/FileManager.h"
     35 #include "clang/Basic/SourceManager.h"
     36 #include "clang/Frontend/AnalyzerOptions.h"
     37 #include "clang/Lex/Preprocessor.h"
     38 #include "llvm/Support/raw_ostream.h"
     39 #include "llvm/Support/Path.h"
     40 #include "llvm/Support/Program.h"
     41 #include "llvm/Support/Timer.h"
     42 #include "llvm/ADT/DepthFirstIterator.h"
     43 #include "llvm/ADT/OwningPtr.h"
     44 #include "llvm/ADT/SmallPtrSet.h"
     45 #include "llvm/ADT/Statistic.h"
     46 
     47 #include <queue>
     48 
     49 using namespace clang;
     50 using namespace ento;
     51 using llvm::SmallPtrSet;
     52 
     53 static ExplodedNode::Auditor* CreateUbiViz();
     54 
     55 STATISTIC(NumFunctionTopLevel, "The # of functions at top level.");
     56 STATISTIC(NumFunctionsAnalyzed, "The # of functions analysed (as top level).");
     57 STATISTIC(NumBlocksInAnalyzedFunctions,
     58                      "The # of basic blocks in the analyzed functions.");
     59 STATISTIC(PercentReachableBlocks, "The % of reachable basic blocks.");
     60 
     61 //===----------------------------------------------------------------------===//
     62 // Special PathDiagnosticConsumers.
     63 //===----------------------------------------------------------------------===//
     64 
     65 static PathDiagnosticConsumer*
     66 createPlistHTMLDiagnosticConsumer(const std::string& prefix,
     67                                 const Preprocessor &PP) {
     68   PathDiagnosticConsumer *PD =
     69     createHTMLDiagnosticConsumer(llvm::sys::path::parent_path(prefix), PP);
     70   return createPlistDiagnosticConsumer(prefix, PP, PD);
     71 }
     72 
     73 //===----------------------------------------------------------------------===//
     74 // AnalysisConsumer declaration.
     75 //===----------------------------------------------------------------------===//
     76 
     77 namespace {
     78 
     79 class AnalysisConsumer : public ASTConsumer,
     80                          public RecursiveASTVisitor<AnalysisConsumer> {
     81   enum AnalysisMode {
     82     ANALYSIS_SYNTAX,
     83     ANALYSIS_PATH,
     84     ANALYSIS_ALL
     85   };
     86 
     87   /// Mode of the analyzes while recursively visiting Decls.
     88   AnalysisMode RecVisitorMode;
     89   /// Bug Reporter to use while recursively visiting Decls.
     90   BugReporter *RecVisitorBR;
     91 
     92 public:
     93   ASTContext *Ctx;
     94   const Preprocessor &PP;
     95   const std::string OutDir;
     96   AnalyzerOptions Opts;
     97   ArrayRef<std::string> Plugins;
     98 
     99   /// \brief Stores the declarations from the local translation unit.
    100   /// Note, we pre-compute the local declarations at parse time as an
    101   /// optimization to make sure we do not deserialize everything from disk.
    102   /// The local declaration to all declarations ratio might be very small when
    103   /// working with a PCH file.
    104   SetOfDecls LocalTUDecls;
    105 
    106   // PD is owned by AnalysisManager.
    107   PathDiagnosticConsumer *PD;
    108 
    109   StoreManagerCreator CreateStoreMgr;
    110   ConstraintManagerCreator CreateConstraintMgr;
    111 
    112   OwningPtr<CheckerManager> checkerMgr;
    113   OwningPtr<AnalysisManager> Mgr;
    114 
    115   /// Time the analyzes time of each translation unit.
    116   static llvm::Timer* TUTotalTimer;
    117 
    118   /// The information about analyzed functions shared throughout the
    119   /// translation unit.
    120   FunctionSummariesTy FunctionSummaries;
    121 
    122   AnalysisConsumer(const Preprocessor& pp,
    123                    const std::string& outdir,
    124                    const AnalyzerOptions& opts,
    125                    ArrayRef<std::string> plugins)
    126     : RecVisitorMode(ANALYSIS_ALL), RecVisitorBR(0),
    127       Ctx(0), PP(pp), OutDir(outdir), Opts(opts), Plugins(plugins), PD(0) {
    128     DigestAnalyzerOptions();
    129     if (Opts.PrintStats) {
    130       llvm::EnableStatistics();
    131       TUTotalTimer = new llvm::Timer("Analyzer Total Time");
    132     }
    133   }
    134 
    135   ~AnalysisConsumer() {
    136     if (Opts.PrintStats)
    137       delete TUTotalTimer;
    138   }
    139 
    140   void DigestAnalyzerOptions() {
    141     // Create the PathDiagnosticConsumer.
    142     if (!OutDir.empty()) {
    143       switch (Opts.AnalysisDiagOpt) {
    144       default:
    145 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATEFN, AUTOCREATE) \
    146         case PD_##NAME: PD = CREATEFN(OutDir, PP); break;
    147 #include "clang/Frontend/Analyses.def"
    148       }
    149     } else if (Opts.AnalysisDiagOpt == PD_TEXT) {
    150       // Create the text client even without a specified output file since
    151       // it just uses diagnostic notes.
    152       PD = createTextPathDiagnosticConsumer("", PP);
    153     }
    154 
    155     // Create the analyzer component creators.
    156     switch (Opts.AnalysisStoreOpt) {
    157     default:
    158       llvm_unreachable("Unknown store manager.");
    159 #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATEFN)           \
    160       case NAME##Model: CreateStoreMgr = CREATEFN; break;
    161 #include "clang/Frontend/Analyses.def"
    162     }
    163 
    164     switch (Opts.AnalysisConstraintsOpt) {
    165     default:
    166       llvm_unreachable("Unknown store manager.");
    167 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATEFN)     \
    168       case NAME##Model: CreateConstraintMgr = CREATEFN; break;
    169 #include "clang/Frontend/Analyses.def"
    170     }
    171   }
    172 
    173   void DisplayFunction(const Decl *D, AnalysisMode Mode) {
    174     if (!Opts.AnalyzerDisplayProgress)
    175       return;
    176 
    177     SourceManager &SM = Mgr->getASTContext().getSourceManager();
    178     PresumedLoc Loc = SM.getPresumedLoc(D->getLocation());
    179     if (Loc.isValid()) {
    180       llvm::errs() << "ANALYZE";
    181       switch (Mode) {
    182         case ANALYSIS_SYNTAX: llvm::errs() << "(Syntax)"; break;
    183         case ANALYSIS_PATH: llvm::errs() << "(Path Sensitive)"; break;
    184         case ANALYSIS_ALL: break;
    185       };
    186       llvm::errs() << ": " << Loc.getFilename();
    187       if (isa<FunctionDecl>(D) || isa<ObjCMethodDecl>(D)) {
    188         const NamedDecl *ND = cast<NamedDecl>(D);
    189         llvm::errs() << ' ' << *ND << '\n';
    190       }
    191       else if (isa<BlockDecl>(D)) {
    192         llvm::errs() << ' ' << "block(line:" << Loc.getLine() << ",col:"
    193                      << Loc.getColumn() << '\n';
    194       }
    195       else if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
    196         Selector S = MD->getSelector();
    197         llvm::errs() << ' ' << S.getAsString();
    198       }
    199     }
    200   }
    201 
    202   virtual void Initialize(ASTContext &Context) {
    203     Ctx = &Context;
    204     checkerMgr.reset(createCheckerManager(Opts, PP.getLangOpts(), Plugins,
    205                                           PP.getDiagnostics()));
    206     Mgr.reset(new AnalysisManager(*Ctx, PP.getDiagnostics(),
    207                                   PP.getLangOpts(), PD,
    208                                   CreateStoreMgr, CreateConstraintMgr,
    209                                   checkerMgr.get(),
    210                                   Opts.MaxNodes, Opts.MaxLoop,
    211                                   Opts.VisualizeEGDot, Opts.VisualizeEGUbi,
    212                                   Opts.AnalysisPurgeOpt, Opts.EagerlyAssume,
    213                                   Opts.TrimGraph,
    214                                   Opts.UnoptimizedCFG, Opts.CFGAddImplicitDtors,
    215                                   Opts.CFGAddInitializers,
    216                                   Opts.EagerlyTrimEGraph,
    217                                   Opts.IPAMode,
    218                                   Opts.InlineMaxStackDepth,
    219                                   Opts.InlineMaxFunctionSize,
    220                                   Opts.InliningMode,
    221                                   Opts.NoRetryExhausted));
    222   }
    223 
    224   /// \brief Store the top level decls in the set to be processed later on.
    225   /// (Doing this pre-processing avoids deserialization of data from PCH.)
    226   virtual bool HandleTopLevelDecl(DeclGroupRef D);
    227   virtual void HandleTopLevelDeclInObjCContainer(DeclGroupRef D);
    228 
    229   virtual void HandleTranslationUnit(ASTContext &C);
    230 
    231   /// \brief Build the call graph for all the top level decls of this TU and
    232   /// use it to define the order in which the functions should be visited.
    233   void HandleDeclsGallGraph();
    234 
    235   /// \brief Run analyzes(syntax or path sensitive) on the given function.
    236   /// \param Mode - determines if we are requesting syntax only or path
    237   /// sensitive only analysis.
    238   /// \param VisitedCallees - The output parameter, which is populated with the
    239   /// set of functions which should be considered analyzed after analyzing the
    240   /// given root function.
    241   void HandleCode(Decl *D, AnalysisMode Mode,
    242                   SetOfConstDecls *VisitedCallees = 0);
    243 
    244   void RunPathSensitiveChecks(Decl *D, SetOfConstDecls *VisitedCallees);
    245   void ActionExprEngine(Decl *D, bool ObjCGCEnabled,
    246                         SetOfConstDecls *VisitedCallees);
    247 
    248   /// Visitors for the RecursiveASTVisitor.
    249 
    250   /// Handle callbacks for arbitrary Decls.
    251   bool VisitDecl(Decl *D) {
    252     checkerMgr->runCheckersOnASTDecl(D, *Mgr, *RecVisitorBR);
    253     return true;
    254   }
    255 
    256   bool VisitFunctionDecl(FunctionDecl *FD) {
    257     IdentifierInfo *II = FD->getIdentifier();
    258     if (II && II->getName().startswith("__inline"))
    259       return true;
    260 
    261     // We skip function template definitions, as their semantics is
    262     // only determined when they are instantiated.
    263     if (FD->isThisDeclarationADefinition() &&
    264         !FD->isDependentContext()) {
    265       HandleCode(FD, RecVisitorMode);
    266     }
    267     return true;
    268   }
    269 
    270   bool VisitObjCMethodDecl(ObjCMethodDecl *MD) {
    271     checkerMgr->runCheckersOnASTDecl(MD, *Mgr, *RecVisitorBR);
    272     if (MD->isThisDeclarationADefinition())
    273       HandleCode(MD, RecVisitorMode);
    274     return true;
    275   }
    276 
    277 private:
    278   void storeTopLevelDecls(DeclGroupRef DG);
    279 
    280   /// \brief Check if we should skip (not analyze) the given function.
    281   bool skipFunction(Decl *D);
    282 
    283 };
    284 } // end anonymous namespace
    285 
    286 
    287 //===----------------------------------------------------------------------===//
    288 // AnalysisConsumer implementation.
    289 //===----------------------------------------------------------------------===//
    290 llvm::Timer* AnalysisConsumer::TUTotalTimer = 0;
    291 
    292 bool AnalysisConsumer::HandleTopLevelDecl(DeclGroupRef DG) {
    293   storeTopLevelDecls(DG);
    294   return true;
    295 }
    296 
    297 void AnalysisConsumer::HandleTopLevelDeclInObjCContainer(DeclGroupRef DG) {
    298   storeTopLevelDecls(DG);
    299 }
    300 
    301 void AnalysisConsumer::storeTopLevelDecls(DeclGroupRef DG) {
    302   for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I) {
    303 
    304     // Skip ObjCMethodDecl, wait for the objc container to avoid
    305     // analyzing twice.
    306     if (isa<ObjCMethodDecl>(*I))
    307       continue;
    308 
    309     LocalTUDecls.insert(*I);
    310   }
    311 }
    312 
    313 void AnalysisConsumer::HandleDeclsGallGraph() {
    314   // Otherwise, use the Callgraph to derive the order.
    315   // Build the Call Graph.
    316   CallGraph CG;
    317   // Add all the top level declarations to the graph.
    318   for (SetOfDecls::iterator I = LocalTUDecls.begin(),
    319                             E = LocalTUDecls.end(); I != E; ++I)
    320     CG.addToCallGraph(*I);
    321 
    322   // Find the top level nodes - children of root + the unreachable (parentless)
    323   // nodes.
    324   llvm::SmallVector<CallGraphNode*, 24> TopLevelFunctions;
    325   for (CallGraph::nodes_iterator TI = CG.parentless_begin(),
    326                                  TE = CG.parentless_end(); TI != TE; ++TI) {
    327     TopLevelFunctions.push_back(*TI);
    328     NumFunctionTopLevel++;
    329   }
    330   CallGraphNode *Entry = CG.getRoot();
    331   for (CallGraphNode::iterator I = Entry->begin(),
    332                                E = Entry->end(); I != E; ++I) {
    333     TopLevelFunctions.push_back(*I);
    334     NumFunctionTopLevel++;
    335   }
    336 
    337   // Make sure the nodes are sorted in order reverse of their definition in the
    338   // translation unit. This step is very important for performance. It ensures
    339   // that we analyze the root functions before the externally available
    340   // subroutines.
    341   std::queue<CallGraphNode*> BFSQueue;
    342   for (llvm::SmallVector<CallGraphNode*, 24>::reverse_iterator
    343          TI = TopLevelFunctions.rbegin(), TE = TopLevelFunctions.rend();
    344          TI != TE; ++TI)
    345     BFSQueue.push(*TI);
    346 
    347   // BFS over all of the functions, while skipping the ones inlined into
    348   // the previously processed functions. Use external Visited set, which is
    349   // also modified when we inline a function.
    350   SmallPtrSet<CallGraphNode*,24> Visited;
    351   while(!BFSQueue.empty()) {
    352     CallGraphNode *N = BFSQueue.front();
    353     BFSQueue.pop();
    354 
    355     // Skip the functions which have been processed already or previously
    356     // inlined.
    357     if (Visited.count(N))
    358       continue;
    359 
    360     // Analyze the function.
    361     SetOfConstDecls VisitedCallees;
    362     Decl *D = N->getDecl();
    363     assert(D);
    364     HandleCode(D, ANALYSIS_PATH,
    365                (Mgr->InliningMode == All ? 0 : &VisitedCallees));
    366 
    367     // Add the visited callees to the global visited set.
    368     for (SetOfConstDecls::const_iterator I = VisitedCallees.begin(),
    369                                          E = VisitedCallees.end(); I != E; ++I){
    370       CallGraphNode *VN = CG.getNode(*I);
    371       if (VN)
    372         Visited.insert(VN);
    373     }
    374     Visited.insert(N);
    375 
    376     // Push the children into the queue.
    377     for (CallGraphNode::const_iterator CI = N->begin(),
    378                                        CE = N->end(); CI != CE; ++CI) {
    379       BFSQueue.push(*CI);
    380     }
    381   }
    382 }
    383 
    384 void AnalysisConsumer::HandleTranslationUnit(ASTContext &C) {
    385   // Don't run the actions if an error has occurred with parsing the file.
    386   DiagnosticsEngine &Diags = PP.getDiagnostics();
    387   if (Diags.hasErrorOccurred() || Diags.hasFatalErrorOccurred())
    388     return;
    389 
    390   {
    391     if (TUTotalTimer) TUTotalTimer->startTimer();
    392 
    393     // Introduce a scope to destroy BR before Mgr.
    394     BugReporter BR(*Mgr);
    395     TranslationUnitDecl *TU = C.getTranslationUnitDecl();
    396     checkerMgr->runCheckersOnASTDecl(TU, *Mgr, BR);
    397 
    398     // Run the AST-only checks using the order in which functions are defined.
    399     // If inlining is not turned on, use the simplest function order for path
    400     // sensitive analyzes as well.
    401     RecVisitorMode = (Mgr->shouldInlineCall() ? ANALYSIS_SYNTAX : ANALYSIS_ALL);
    402     RecVisitorBR = &BR;
    403 
    404     // Process all the top level declarations.
    405     for (SetOfDecls::iterator I = LocalTUDecls.begin(),
    406                               E = LocalTUDecls.end(); I != E; ++I)
    407       TraverseDecl(*I);
    408 
    409     if (Mgr->shouldInlineCall())
    410       HandleDeclsGallGraph();
    411 
    412     // After all decls handled, run checkers on the entire TranslationUnit.
    413     checkerMgr->runCheckersOnEndOfTranslationUnit(TU, *Mgr, BR);
    414 
    415     RecVisitorBR = 0;
    416   }
    417 
    418   // Explicitly destroy the PathDiagnosticConsumer.  This will flush its output.
    419   // FIXME: This should be replaced with something that doesn't rely on
    420   // side-effects in PathDiagnosticConsumer's destructor. This is required when
    421   // used with option -disable-free.
    422   Mgr.reset(NULL);
    423 
    424   if (TUTotalTimer) TUTotalTimer->stopTimer();
    425 
    426   // Count how many basic blocks we have not covered.
    427   NumBlocksInAnalyzedFunctions = FunctionSummaries.getTotalNumBasicBlocks();
    428   if (NumBlocksInAnalyzedFunctions > 0)
    429     PercentReachableBlocks =
    430       (FunctionSummaries.getTotalNumVisitedBasicBlocks() * 100) /
    431         NumBlocksInAnalyzedFunctions;
    432 
    433 }
    434 
    435 static void FindBlocks(DeclContext *D, SmallVectorImpl<Decl*> &WL) {
    436   if (BlockDecl *BD = dyn_cast<BlockDecl>(D))
    437     WL.push_back(BD);
    438 
    439   for (DeclContext::decl_iterator I = D->decls_begin(), E = D->decls_end();
    440        I!=E; ++I)
    441     if (DeclContext *DC = dyn_cast<DeclContext>(*I))
    442       FindBlocks(DC, WL);
    443 }
    444 
    445 static std::string getFunctionName(const Decl *D) {
    446   if (const ObjCMethodDecl *ID = dyn_cast<ObjCMethodDecl>(D)) {
    447     return ID->getSelector().getAsString();
    448   }
    449   if (const FunctionDecl *ND = dyn_cast<FunctionDecl>(D)) {
    450     IdentifierInfo *II = ND->getIdentifier();
    451     if (II)
    452       return II->getName();
    453   }
    454   return "";
    455 }
    456 
    457 bool AnalysisConsumer::skipFunction(Decl *D) {
    458   if (!Opts.AnalyzeSpecificFunction.empty() &&
    459       getFunctionName(D) != Opts.AnalyzeSpecificFunction)
    460     return true;
    461 
    462   // Don't run the actions on declarations in header files unless
    463   // otherwise specified.
    464   SourceManager &SM = Ctx->getSourceManager();
    465   SourceLocation SL = SM.getExpansionLoc(D->getLocation());
    466   if (!Opts.AnalyzeAll && !SM.isFromMainFile(SL))
    467     return true;
    468 
    469   return false;
    470 }
    471 
    472 void AnalysisConsumer::HandleCode(Decl *D, AnalysisMode Mode,
    473                                   SetOfConstDecls *VisitedCallees) {
    474   if (skipFunction(D))
    475     return;
    476 
    477   DisplayFunction(D, Mode);
    478 
    479   // Clear the AnalysisManager of old AnalysisDeclContexts.
    480   Mgr->ClearContexts();
    481 
    482   // Dispatch on the actions.
    483   SmallVector<Decl*, 10> WL;
    484   WL.push_back(D);
    485 
    486   if (D->hasBody() && Opts.AnalyzeNestedBlocks)
    487     FindBlocks(cast<DeclContext>(D), WL);
    488 
    489   BugReporter BR(*Mgr);
    490   for (SmallVectorImpl<Decl*>::iterator WI=WL.begin(), WE=WL.end();
    491        WI != WE; ++WI)
    492     if ((*WI)->hasBody()) {
    493       if (Mode != ANALYSIS_PATH)
    494         checkerMgr->runCheckersOnASTBody(*WI, *Mgr, BR);
    495       if (Mode != ANALYSIS_SYNTAX && checkerMgr->hasPathSensitiveCheckers()) {
    496         RunPathSensitiveChecks(*WI, VisitedCallees);
    497         NumFunctionsAnalyzed++;
    498       }
    499     }
    500 }
    501 
    502 //===----------------------------------------------------------------------===//
    503 // Path-sensitive checking.
    504 //===----------------------------------------------------------------------===//
    505 
    506 void AnalysisConsumer::ActionExprEngine(Decl *D, bool ObjCGCEnabled,
    507                                         SetOfConstDecls *VisitedCallees) {
    508   // Construct the analysis engine.  First check if the CFG is valid.
    509   // FIXME: Inter-procedural analysis will need to handle invalid CFGs.
    510   if (!Mgr->getCFG(D))
    511     return;
    512 
    513   ExprEngine Eng(*Mgr, ObjCGCEnabled, VisitedCallees, &FunctionSummaries);
    514 
    515   // Set the graph auditor.
    516   OwningPtr<ExplodedNode::Auditor> Auditor;
    517   if (Mgr->shouldVisualizeUbigraph()) {
    518     Auditor.reset(CreateUbiViz());
    519     ExplodedNode::SetAuditor(Auditor.get());
    520   }
    521 
    522   // Execute the worklist algorithm.
    523   Eng.ExecuteWorkList(Mgr->getAnalysisDeclContextManager().getStackFrame(D, 0),
    524                       Mgr->getMaxNodes());
    525 
    526   // Release the auditor (if any) so that it doesn't monitor the graph
    527   // created BugReporter.
    528   ExplodedNode::SetAuditor(0);
    529 
    530   // Visualize the exploded graph.
    531   if (Mgr->shouldVisualizeGraphviz())
    532     Eng.ViewGraph(Mgr->shouldTrimGraph());
    533 
    534   // Display warnings.
    535   Eng.getBugReporter().FlushReports();
    536 }
    537 
    538 void AnalysisConsumer::RunPathSensitiveChecks(Decl *D,
    539                                               SetOfConstDecls *Visited) {
    540 
    541   switch (Mgr->getLangOpts().getGC()) {
    542   case LangOptions::NonGC:
    543     ActionExprEngine(D, false, Visited);
    544     break;
    545 
    546   case LangOptions::GCOnly:
    547     ActionExprEngine(D, true, Visited);
    548     break;
    549 
    550   case LangOptions::HybridGC:
    551     ActionExprEngine(D, false, Visited);
    552     ActionExprEngine(D, true, Visited);
    553     break;
    554   }
    555 }
    556 
    557 //===----------------------------------------------------------------------===//
    558 // AnalysisConsumer creation.
    559 //===----------------------------------------------------------------------===//
    560 
    561 ASTConsumer* ento::CreateAnalysisConsumer(const Preprocessor& pp,
    562                                           const std::string& outDir,
    563                                           const AnalyzerOptions& opts,
    564                                           ArrayRef<std::string> plugins) {
    565   // Disable the effects of '-Werror' when using the AnalysisConsumer.
    566   pp.getDiagnostics().setWarningsAsErrors(false);
    567 
    568   return new AnalysisConsumer(pp, outDir, opts, plugins);
    569 }
    570 
    571 //===----------------------------------------------------------------------===//
    572 // Ubigraph Visualization.  FIXME: Move to separate file.
    573 //===----------------------------------------------------------------------===//
    574 
    575 namespace {
    576 
    577 class UbigraphViz : public ExplodedNode::Auditor {
    578   OwningPtr<raw_ostream> Out;
    579   llvm::sys::Path Dir, Filename;
    580   unsigned Cntr;
    581 
    582   typedef llvm::DenseMap<void*,unsigned> VMap;
    583   VMap M;
    584 
    585 public:
    586   UbigraphViz(raw_ostream *out, llvm::sys::Path& dir,
    587               llvm::sys::Path& filename);
    588 
    589   ~UbigraphViz();
    590 
    591   virtual void AddEdge(ExplodedNode *Src, ExplodedNode *Dst);
    592 };
    593 
    594 } // end anonymous namespace
    595 
    596 static ExplodedNode::Auditor* CreateUbiViz() {
    597   std::string ErrMsg;
    598 
    599   llvm::sys::Path Dir = llvm::sys::Path::GetTemporaryDirectory(&ErrMsg);
    600   if (!ErrMsg.empty())
    601     return 0;
    602 
    603   llvm::sys::Path Filename = Dir;
    604   Filename.appendComponent("llvm_ubi");
    605   Filename.makeUnique(true,&ErrMsg);
    606 
    607   if (!ErrMsg.empty())
    608     return 0;
    609 
    610   llvm::errs() << "Writing '" << Filename.str() << "'.\n";
    611 
    612   OwningPtr<llvm::raw_fd_ostream> Stream;
    613   Stream.reset(new llvm::raw_fd_ostream(Filename.c_str(), ErrMsg));
    614 
    615   if (!ErrMsg.empty())
    616     return 0;
    617 
    618   return new UbigraphViz(Stream.take(), Dir, Filename);
    619 }
    620 
    621 void UbigraphViz::AddEdge(ExplodedNode *Src, ExplodedNode *Dst) {
    622 
    623   assert (Src != Dst && "Self-edges are not allowed.");
    624 
    625   // Lookup the Src.  If it is a new node, it's a root.
    626   VMap::iterator SrcI= M.find(Src);
    627   unsigned SrcID;
    628 
    629   if (SrcI == M.end()) {
    630     M[Src] = SrcID = Cntr++;
    631     *Out << "('vertex', " << SrcID << ", ('color','#00ff00'))\n";
    632   }
    633   else
    634     SrcID = SrcI->second;
    635 
    636   // Lookup the Dst.
    637   VMap::iterator DstI= M.find(Dst);
    638   unsigned DstID;
    639 
    640   if (DstI == M.end()) {
    641     M[Dst] = DstID = Cntr++;
    642     *Out << "('vertex', " << DstID << ")\n";
    643   }
    644   else {
    645     // We have hit DstID before.  Change its style to reflect a cache hit.
    646     DstID = DstI->second;
    647     *Out << "('change_vertex_style', " << DstID << ", 1)\n";
    648   }
    649 
    650   // Add the edge.
    651   *Out << "('edge', " << SrcID << ", " << DstID
    652        << ", ('arrow','true'), ('oriented', 'true'))\n";
    653 }
    654 
    655 UbigraphViz::UbigraphViz(raw_ostream *out, llvm::sys::Path& dir,
    656                          llvm::sys::Path& filename)
    657   : Out(out), Dir(dir), Filename(filename), Cntr(0) {
    658 
    659   *Out << "('vertex_style_attribute', 0, ('shape', 'icosahedron'))\n";
    660   *Out << "('vertex_style', 1, 0, ('shape', 'sphere'), ('color', '#ffcc66'),"
    661           " ('size', '1.5'))\n";
    662 }
    663 
    664 UbigraphViz::~UbigraphViz() {
    665   Out.reset(0);
    666   llvm::errs() << "Running 'ubiviz' program... ";
    667   std::string ErrMsg;
    668   llvm::sys::Path Ubiviz = llvm::sys::Program::FindProgramByName("ubiviz");
    669   std::vector<const char*> args;
    670   args.push_back(Ubiviz.c_str());
    671   args.push_back(Filename.c_str());
    672   args.push_back(0);
    673 
    674   if (llvm::sys::Program::ExecuteAndWait(Ubiviz, &args[0],0,0,0,0,&ErrMsg)) {
    675     llvm::errs() << "Error viewing graph: " << ErrMsg << "\n";
    676   }
    677 
    678   // Delete the directory.
    679   Dir.eraseFromDisk(true);
    680 }
    681