contrib/llvm/tools/clang/lib/Analysis/CallGraph.cpp

   1 //== CallGraph.cpp - AST-based Call graph  ----------------------*- 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 AST-based CallGraph.
  11 //
  12 //===----------------------------------------------------------------------===//
  13 #include "clang/Analysis/CallGraph.h"
  14
  15 #include "clang/AST/ASTContext.h"
  16 #include "clang/AST/Decl.h"
  17 #include "clang/AST/StmtVisitor.h"
  18
  19 #include "llvm/Support/GraphWriter.h"
  20
  21 using namespace clang;
  22
  23 namespace {
  24 /// A helper class, which walks the AST and locates all the call sites in the
  25 /// given function body.
  26 class CGBuilder : public StmtVisitor<CGBuilder> {
  27   CallGraph *G;
  28   const Decl *FD;
  29   CallGraphNode *CallerNode;
  30
  31 public:
  32   CGBuilder(CallGraph *g, const Decl *D, CallGraphNode *N)
  33     : G(g), FD(D), CallerNode(N) {}
  34
  35   void VisitStmt(Stmt *S) { VisitChildren(S); }
  36
  37   void VisitCallExpr(CallExpr *CE) {
  38     // TODO: We need to handle ObjC method calls as well.
  39     if (FunctionDecl *CalleeDecl = CE->getDirectCallee())
  40       if (G->includeInGraph(CalleeDecl)) {
  41         CallGraphNode *CalleeNode = G->getOrInsertNode(CalleeDecl);
  42         CallerNode->addCallee(CalleeNode, G);
  43       }
  44   }
  45
  46   void VisitChildren(Stmt *S) {
  47     for (Stmt::child_range I = S->children(); I; ++I)
  48       if (*I)
  49         static_cast<CGBuilder*>(this)->Visit(*I);
  50   }
  51 };
  52
  53 } // end anonymous namespace
  54
  55 CallGraph::CallGraph() {
  56   Root = getOrInsertNode(0);
  57 }
  58
  59 CallGraph::~CallGraph() {
  60   if (!FunctionMap.empty()) {
  61     for (FunctionMapTy::iterator I = FunctionMap.begin(), E = FunctionMap.end();
  62         I != E; ++I)
  63       delete I->second;
  64     FunctionMap.clear();
  65   }
  66 }
  67
  68 bool CallGraph::includeInGraph(const Decl *D) {
  69   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
  70     // We skip function template definitions, as their semantics is
  71     // only determined when they are instantiated.
  72     if (!FD->isThisDeclarationADefinition() ||
  73         FD->isDependentContext())
  74       return false;
  75
  76     IdentifierInfo *II = FD->getIdentifier();
  77     if (II && II->getName().startswith("__inline"))
  78       return false;
  79   }
  80
  81   if (const ObjCMethodDecl *ID = dyn_cast<ObjCMethodDecl>(D)) {
  82     if (!ID->isThisDeclarationADefinition())
  83       return false;
  84   }
  85
  86   return true;
  87 }
  88
  89 void CallGraph::addNodeForDecl(Decl* D, bool IsGlobal) {
  90   assert(D);
  91
  92   // Do nothing if the node already exists.
  93   if (FunctionMap.find(D) != FunctionMap.end())
  94     return;
  95
  96   // Allocate a new node, mark it as root, and process it's calls.
  97   CallGraphNode *Node = getOrInsertNode(D);
  98   if (IsGlobal)
  99     Root->addCallee(Node, this);
 100
 101   // Process all the calls by this function as well.
 102   CGBuilder builder(this, D, Node);
 103   if (Stmt *Body = D->getBody())
 104     builder.Visit(Body);
 105 }
 106
 107 CallGraphNode *CallGraph::getNode(const Decl *F) const {
 108   FunctionMapTy::const_iterator I = FunctionMap.find(F);
 109   if (I == FunctionMap.end()) return 0;
 110   return I->second;
 111 }
 112
 113 CallGraphNode *CallGraph::getOrInsertNode(Decl *F) {
 114   CallGraphNode *&Node = FunctionMap[F];
 115   if (Node)
 116     return Node;
 117
 118   Node = new CallGraphNode(F);
 119   // If not root, add to the parentless list.
 120   if (F != 0)
 121     ParentlessNodes.insert(Node);
 122   return Node;
 123 }
 124
 125 void CallGraph::print(raw_ostream &OS) const {
 126   OS << " --- Call graph Dump --- \n";
 127   for (const_iterator I = begin(), E = end(); I != E; ++I) {
 128     OS << "  Function: ";
 129     if (I->second == Root)
 130       OS << "< root >";
 131     else
 132       I->second->print(OS);
 133     OS << " calls: ";
 134     for (CallGraphNode::iterator CI = I->second->begin(),
 135         CE = I->second->end(); CI != CE; ++CI) {
 136       assert(*CI != Root && "No one can call the root node.");
 137       (*CI)->print(OS);
 138       OS << " ";
 139     }
 140     OS << '\n';
 141   }
 142   OS.flush();
 143 }
 144
 145 void CallGraph::dump() const {
 146   print(llvm::errs());
 147 }
 148
 149 void CallGraph::viewGraph() const {
 150   llvm::ViewGraph(this, "CallGraph");
 151 }
 152
 153 StringRef CallGraphNode::getName() const {
 154   if (const FunctionDecl *D = dyn_cast_or_null<FunctionDecl>(FD))
 155     if (const IdentifierInfo *II = D->getIdentifier())
 156       return II->getName();
 157     return "< >";
 158 }
 159
 160 void CallGraphNode::print(raw_ostream &os) const {
 161   os << getName();
 162 }
 163
 164 void CallGraphNode::dump() const {
 165   print(llvm::errs());
 166 }
 167
 168 namespace llvm {
 169
 170 template <>
 171 struct DOTGraphTraits<const CallGraph*> : public DefaultDOTGraphTraits {
 172
 173   DOTGraphTraits (bool isSimple=false) : DefaultDOTGraphTraits(isSimple) {}
 174
 175   static std::string getNodeLabel(const CallGraphNode *Node,
 176                                   const CallGraph *CG) {
 177     if (CG->getRoot() == Node) {
 178       return "< root >";
 179     }
 180     return Node->getName();
 181   }
 182
 183 };
 184 }