← Back to branch summary

~ubuntu-branches/debian/sid/clamav/sid

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Andreas Cadhalpun, Andreas Cadhalpun, Sebastian Andrzej Siewior, Frans Spiesschaert
  • Date: 2014-10-15 06:50:20 UTC
  • mfrom: (1.3.13) (42.1.4 experimental)
  • Revision ID: package-import@ubuntu.com-20141015065020-0cpy1hdueggaw35s
Tags: 0.98.5~rc1+dfsg-1
http://bugs.debian.org/763634
[ Andreas Cadhalpun ]
* Import new upstream release candidate.
* Drop patches included upstream and update the others.
* Add 4 new symbols to libclamav6.symbols.
* Fix debian/copyright.
* Update lintian overrides.
* Update Standards-Version to 3.9.6 (no changes needed).
* Add Breaks and Replaces for old clamd package to clamdscan.
* Remove unnecessary shlibs:Depends from clamav-dbg.
* Add patches to support LLVM 3.5.

[ Sebastian Andrzej Siewior ]
* Add embedded copy of libmspack to be used as fallback, when libmspack-dev
  is not available.

[ Frans Spiesschaert ]
* Updated Dutch Debconf template translation (Closes: #763634)

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
 
INITIALIZE_PASS(PostDominatorTree, "postdomtree",
32
 
                "Post-Dominator Tree Construction", true, true);
33
 
 
34
 
bool PostDominatorTree::runOnFunction(Function &F) {
35
 
  DT->recalculate(F);
36
 
  return false;
37
 
}
38
 
 
39
 
PostDominatorTree::~PostDominatorTree() {
40
 
  delete DT;
41
 
}
42
 
 
43
 
void PostDominatorTree::print(raw_ostream &OS, const Module *) const {
44
 
  DT->print(OS);
45
 
}
46
 
 
47
 
 
48
 
FunctionPass* llvm::createPostDomTree() {
49
 
  return new PostDominatorTree();
50
 
}
51
 
 
52
 
//===----------------------------------------------------------------------===//
53
 
//  PostDominanceFrontier Implementation
54
 
//===----------------------------------------------------------------------===//
55
 
 
56
 
INITIALIZE_PASS(PostDominanceFrontier, "postdomfrontier",
57
 
                "Post-Dominance Frontier Construction", true, true);
58
 
 
59
 
const DominanceFrontier::DomSetType &
60
 
PostDominanceFrontier::calculate(const PostDominatorTree &DT,
61
 
                                 const DomTreeNode *Node) {
62
 
  // Loop over CFG successors to calculate DFlocal[Node]
63
 
  BasicBlock *BB = Node->getBlock();
64
 
  DomSetType &S = Frontiers[BB];       // The new set to fill in...
65
 
  if (getRoots().empty()) return S;
66
 
 
67
 
  if (BB)
68
 
    for (pred_iterator SI = pred_begin(BB), SE = pred_end(BB);
69
 
         SI != SE; ++SI) {
70
 
      BasicBlock *P = *SI;
71
 
      // Does Node immediately dominate this predecessor?
72
 
      DomTreeNode *SINode = DT[P];
73
 
      if (SINode && SINode->getIDom() != Node)
74
 
        S.insert(P);
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
 
}