← Back to branch summary

~ubuntu-branches/ubuntu/maverick/clamav/maverick-backports

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/lib/Analysis/PostDominators.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Stephen Gran, Stephen Gran, Michael Tautschnig
  • Date: 2010-04-26 21:41:18 UTC
  • mfrom: (2.1.6 squeeze)
  • Revision ID: james.westby@ubuntu.com-20100426214118-i6lo606wnh7ywfj6
Tags: 0.96+dfsg-4
http://bugs.debian.org/579271
http://bugs.debian.org/579068
[ Stephen Gran ]
* Fixed typo in clamav-milter's postinst

[ Michael Tautschnig ]
* Fixed typo in clamav-freshclam's postinst (closes: #579271)
* Debconf translation updates
  - Portuguese (closes: #579068)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/lib/Analysis/PostDominators.cpp
 
1
//===- PostDominators.cpp - Post-Dominator Calculation --------------------===//
 
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 implements the post-dominator construction algorithms.
 
11
//
 
12
//===----------------------------------------------------------------------===//
 
13
 
 
14
#define DEBUG_TYPE "postdomtree"
 
15
 
 
16
#include "llvm/Analysis/PostDominators.h"
 
17
#include "llvm/Instructions.h"
 
18
#include "llvm/Support/CFG.h"
 
19
#include "llvm/Support/Debug.h"
 
20
#include "llvm/ADT/DepthFirstIterator.h"
 
21
#include "llvm/ADT/SetOperations.h"
 
22
#include "llvm/Analysis/DominatorInternals.h"
 
23
using namespace llvm;
 
24
 
 
25
//===----------------------------------------------------------------------===//
 
26
//  PostDominatorTree Implementation
 
27
//===----------------------------------------------------------------------===//
 
28
 
 
29
char PostDominatorTree::ID = 0;
 
30
char PostDominanceFrontier::ID = 0;
 
31
static RegisterPass<PostDominatorTree>
 
32
F("postdomtree", "Post-Dominator Tree Construction", true, true);
 
33
 
 
34
bool PostDominatorTree::runOnFunction(Function &F) {
 
35
  DT->recalculate(F);
 
36
  DEBUG(DT->print(dbgs()));
 
37
  return false;
 
38
}
 
39
 
 
40
PostDominatorTree::~PostDominatorTree() {
 
41
  delete DT;
 
42
}
 
43
 
 
44
void PostDominatorTree::print(raw_ostream &OS, const Module *) const {
 
45
  DT->print(OS);
 
46
}
 
47
 
 
48
 
 
49
FunctionPass* llvm::createPostDomTree() {
 
50
  return new PostDominatorTree();
 
51
}
 
52
 
 
53
//===----------------------------------------------------------------------===//
 
54
//  PostDominanceFrontier Implementation
 
55
//===----------------------------------------------------------------------===//
 
56
 
 
57
static RegisterPass<PostDominanceFrontier>
 
58
H("postdomfrontier", "Post-Dominance Frontier Construction", true, true);
 
59
 
 
60
const DominanceFrontier::DomSetType &
 
61
PostDominanceFrontier::calculate(const PostDominatorTree &DT,
 
62
                                 const DomTreeNode *Node) {
 
63
  // Loop over CFG successors to calculate DFlocal[Node]
 
64
  BasicBlock *BB = Node->getBlock();
 
65
  DomSetType &S = Frontiers[BB];       // The new set to fill in...
 
66
  if (getRoots().empty()) return S;
 
67
 
 
68
  if (BB)
 
69
    for (pred_iterator SI = pred_begin(BB), SE = pred_end(BB);
 
70
         SI != SE; ++SI) {
 
71
      // Does Node immediately dominate this predecessor?
 
72
      DomTreeNode *SINode = DT[*SI];
 
73
      if (SINode && SINode->getIDom() != Node)
 
74
        S.insert(*SI);
 
75
    }
 
76
 
 
77
  // At this point, S is DFlocal.  Now we union in DFup's of our children...
 
78
  // Loop through and visit the nodes that Node immediately dominates (Node's
 
79
  // children in the IDomTree)
 
80
  //
 
81
  for (DomTreeNode::const_iterator
 
82
         NI = Node->begin(), NE = Node->end(); NI != NE; ++NI) {
 
83
    DomTreeNode *IDominee = *NI;
 
84
    const DomSetType &ChildDF = calculate(DT, IDominee);
 
85
 
 
86
    DomSetType::const_iterator CDFI = ChildDF.begin(), CDFE = ChildDF.end();
 
87
    for (; CDFI != CDFE; ++CDFI) {
 
88
      if (!DT.properlyDominates(Node, DT[*CDFI]))
 
89
        S.insert(*CDFI);
 
90
    }
 
91
  }
 
92
 
 
93
  return S;
 
94
}
 
95
 
 
96
FunctionPass* llvm::createPostDomFrontier() {
 
97
  return new PostDominanceFrontier();
 
98
}