← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/include/llvm/Analysis/ProfileInfo.h

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-03-12 11:30:04 UTC
  • mfrom: (0.41.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100312113004-b0fop4bkycszdd0z
Tags: 0.96~rc1+dfsg-0ubuntu1
https://launchpad.net/bugs/537636
* New upstream RC - FFE (LP: #537636):
  - Add OfficialDatabaseOnly option to clamav-base.postinst.in
  - Add LocalSocketGroup option to clamav-base.postinst.in
  - Add LocalSocketMode option to clamav-base.postinst.in
  - Add CrossFilesystems option to clamav-base.postinst.in
  - Add ClamukoScannerCount option to clamav-base.postinst.in
  - Add BytecodeSecurity opiton to clamav-base.postinst.in
  - Add DetectionStatsHostID option to clamav-freshclam.postinst.in
  - Add Bytecode option to clamav-freshclam.postinst.in
  - Add MilterSocketGroup option to clamav-milter.postinst.in
  - Add MilterSocketMode option to clamav-milter.postinst.in
  - Add ReportHostname option to clamav-milter.postinst.in
  - Bump libclamav SO version to 6.1.0 in libclamav6.install
  - Drop clamdmon from clamav.examples (no longer shipped by upstream)
  - Drop libclamav.a from libclamav-dev.install (not built by upstream)
  - Update SO version for lintian override for libclamav6
  - Add new Bytecode Testing Tool, usr/bin/clambc, to clamav.install
  - Add build-depends on python and python-setuptools for new test suite
  - Update debian/copyright for the embedded copy of llvm (using the system
    llvm is not currently feasible)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/include/llvm/Analysis/ProfileInfo.h
 
1
//===- llvm/Analysis/ProfileInfo.h - Profile Info Interface -----*- 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 generic ProfileInfo interface, which is used as the
 
11
// common interface used by all clients of profiling information, and
 
12
// implemented either by making static guestimations, or by actually reading in
 
13
// profiling information gathered by running the program.
 
14
//
 
15
// Note that to be useful, all profile-based optimizations should preserve
 
16
// ProfileInfo, which requires that they notify it when changes to the CFG are
 
17
// made. (This is not implemented yet.)
 
18
//
 
19
//===----------------------------------------------------------------------===//
 
20
 
 
21
#ifndef LLVM_ANALYSIS_PROFILEINFO_H
 
22
#define LLVM_ANALYSIS_PROFILEINFO_H
 
23
 
 
24
#include "llvm/Support/Debug.h"
 
25
#include "llvm/Support/Format.h"
 
26
#include "llvm/Support/raw_ostream.h"
 
27
#include <cassert>
 
28
#include <string>
 
29
#include <map>
 
30
#include <set>
 
31
 
 
32
namespace llvm {
 
33
  class Pass;
 
34
  class raw_ostream;
 
35
 
 
36
  class BasicBlock;
 
37
  class Function;
 
38
  class MachineBasicBlock;
 
39
  class MachineFunction;
 
40
 
 
41
  // Helper for dumping edges to dbgs().
 
42
  raw_ostream& operator<<(raw_ostream &O, std::pair<const BasicBlock *, const BasicBlock *> E);
 
43
  raw_ostream& operator<<(raw_ostream &O, std::pair<const MachineBasicBlock *, const MachineBasicBlock *> E);
 
44
 
 
45
  raw_ostream& operator<<(raw_ostream &O, const BasicBlock *BB);
 
46
  raw_ostream& operator<<(raw_ostream &O, const MachineBasicBlock *MBB);
 
47
 
 
48
  raw_ostream& operator<<(raw_ostream &O, const Function *F);
 
49
  raw_ostream& operator<<(raw_ostream &O, const MachineFunction *MF);
 
50
 
 
51
  /// ProfileInfo Class - This class holds and maintains profiling
 
52
  /// information for some unit of code.
 
53
  template<class FType, class BType>
 
54
  class ProfileInfoT {
 
55
  public:
 
56
    // Types for handling profiling information.
 
57
    typedef std::pair<const BType*, const BType*> Edge;
 
58
    typedef std::pair<Edge, double> EdgeWeight;
 
59
    typedef std::map<Edge, double> EdgeWeights;
 
60
    typedef std::map<const BType*, double> BlockCounts;
 
61
    typedef std::map<const BType*, const BType*> Path;
 
62
 
 
63
  protected:
 
64
    // EdgeInformation - Count the number of times a transition between two
 
65
    // blocks is executed. As a special case, we also hold an edge from the
 
66
    // null BasicBlock to the entry block to indicate how many times the
 
67
    // function was entered.
 
68
    std::map<const FType*, EdgeWeights> EdgeInformation;
 
69
 
 
70
    // BlockInformation - Count the number of times a block is executed.
 
71
    std::map<const FType*, BlockCounts> BlockInformation;
 
72
 
 
73
    // FunctionInformation - Count the number of times a function is executed.
 
74
    std::map<const FType*, double> FunctionInformation;
 
75
 
 
76
    ProfileInfoT<MachineFunction, MachineBasicBlock> *MachineProfile;
 
77
  public:
 
78
    static char ID; // Class identification, replacement for typeinfo
 
79
    ProfileInfoT();
 
80
    ~ProfileInfoT();  // We want to be subclassed
 
81
 
 
82
    // MissingValue - The value that is returned for execution counts in case
 
83
    // no value is available.
 
84
    static const double MissingValue;
 
85
 
 
86
    // getFunction() - Returns the Function for an Edge, checking for validity.
 
87
    static const FType* getFunction(Edge e) {
 
88
      if (e.first) {
 
89
        return e.first->getParent();
 
90
      } else if (e.second) {
 
91
        return e.second->getParent();
 
92
      }
 
93
      assert(0 && "Invalid ProfileInfo::Edge");
 
94
      return (const FType*)0;
 
95
    }
 
96
 
 
97
    // getEdge() - Creates an Edge from two BasicBlocks.
 
98
    static Edge getEdge(const BType *Src, const BType *Dest) {
 
99
      return std::make_pair(Src, Dest);
 
100
    }
 
101
 
 
102
    //===------------------------------------------------------------------===//
 
103
    /// Profile Information Queries
 
104
    ///
 
105
    double getExecutionCount(const FType *F);
 
106
 
 
107
    double getExecutionCount(const BType *BB);
 
108
 
 
109
    void setExecutionCount(const BType *BB, double w);
 
110
 
 
111
    void addExecutionCount(const BType *BB, double w);
 
112
 
 
113
    double getEdgeWeight(Edge e) const {
 
114
      typename std::map<const FType*, EdgeWeights>::const_iterator J =
 
115
        EdgeInformation.find(getFunction(e));
 
116
      if (J == EdgeInformation.end()) return MissingValue;
 
117
 
 
118
      typename EdgeWeights::const_iterator I = J->second.find(e);
 
119
      if (I == J->second.end()) return MissingValue;
 
120
 
 
121
      return I->second;
 
122
    }
 
123
 
 
124
    void setEdgeWeight(Edge e, double w) {
 
125
      DEBUG_WITH_TYPE("profile-info",
 
126
            dbgs() << "Creating Edge " << e
 
127
                   << " (weight: " << format("%.20g",w) << ")\n");
 
128
      EdgeInformation[getFunction(e)][e] = w;
 
129
    }
 
130
 
 
131
    void addEdgeWeight(Edge e, double w);
 
132
 
 
133
    EdgeWeights &getEdgeWeights (const FType *F) {
 
134
      return EdgeInformation[F];
 
135
    }
 
136
 
 
137
    //===------------------------------------------------------------------===//
 
138
    /// Analysis Update Methods
 
139
    ///
 
140
    void removeBlock(const BType *BB);
 
141
 
 
142
    void removeEdge(Edge e);
 
143
 
 
144
    void replaceEdge(const Edge &, const Edge &);
 
145
 
 
146
    enum GetPathMode {
 
147
      GetPathToExit = 1,
 
148
      GetPathToValue = 2,
 
149
      GetPathToDest = 4,
 
150
      GetPathWithNewEdges = 8
 
151
    };
 
152
 
 
153
    const BType *GetPath(const BType *Src, const BType *Dest,
 
154
                              Path &P, unsigned Mode);
 
155
 
 
156
    void divertFlow(const Edge &, const Edge &);
 
157
 
 
158
    void splitEdge(const BType *FirstBB, const BType *SecondBB,
 
159
                   const BType *NewBB, bool MergeIdenticalEdges = false);
 
160
 
 
161
    void splitBlock(const BType *Old, const BType* New);
 
162
 
 
163
    void splitBlock(const BType *BB, const BType* NewBB,
 
164
                    BType *const *Preds, unsigned NumPreds);
 
165
 
 
166
    void replaceAllUses(const BType *RmBB, const BType *DestBB);
 
167
 
 
168
    void transfer(const FType *Old, const FType *New);
 
169
 
 
170
    void repair(const FType *F);
 
171
 
 
172
    void dump(FType *F = 0, bool real = true) {
 
173
      dbgs() << "**** This is ProfileInfo " << this << " speaking:\n";
 
174
      if (!real) {
 
175
        typename std::set<const FType*> Functions;
 
176
 
 
177
        dbgs() << "Functions: \n";
 
178
        if (F) {
 
179
          dbgs() << F << "@" << format("%p", F) << ": " << format("%.20g",getExecutionCount(F)) << "\n";
 
180
          Functions.insert(F);
 
181
        } else {
 
182
          for (typename std::map<const FType*, double>::iterator fi = FunctionInformation.begin(),
 
183
               fe = FunctionInformation.end(); fi != fe; ++fi) {
 
184
            dbgs() << fi->first << "@" << format("%p",fi->first) << ": " << format("%.20g",fi->second) << "\n";
 
185
            Functions.insert(fi->first);
 
186
          }
 
187
        }
 
188
 
 
189
        for (typename std::set<const FType*>::iterator FI = Functions.begin(), FE = Functions.end();
 
190
             FI != FE; ++FI) {
 
191
          const FType *F = *FI;
 
192
          typename std::map<const FType*, BlockCounts>::iterator bwi = BlockInformation.find(F);
 
193
          dbgs() << "BasicBlocks for Function " << F << ":\n";
 
194
          for (typename BlockCounts::const_iterator bi = bwi->second.begin(), be = bwi->second.end(); bi != be; ++bi) {
 
195
            dbgs() << bi->first << "@" << format("%p", bi->first) << ": " << format("%.20g",bi->second) << "\n";
 
196
          }
 
197
        }
 
198
 
 
199
        for (typename std::set<const FType*>::iterator FI = Functions.begin(), FE = Functions.end();
 
200
             FI != FE; ++FI) {
 
201
          typename std::map<const FType*, EdgeWeights>::iterator ei = EdgeInformation.find(*FI);
 
202
          dbgs() << "Edges for Function " << ei->first << ":\n";
 
203
          for (typename EdgeWeights::iterator ewi = ei->second.begin(), ewe = ei->second.end(); 
 
204
               ewi != ewe; ++ewi) {
 
205
            dbgs() << ewi->first << ": " << format("%.20g",ewi->second) << "\n";
 
206
          }
 
207
        }
 
208
      } else {
 
209
        assert(F && "No function given, this is not supported!");
 
210
        dbgs() << "Functions: \n";
 
211
        dbgs() << F << "@" << format("%p", F) << ": " << format("%.20g",getExecutionCount(F)) << "\n";
 
212
 
 
213
        dbgs() << "BasicBlocks for Function " << F << ":\n";
 
214
        for (typename FType::const_iterator BI = F->begin(), BE = F->end();
 
215
             BI != BE; ++BI) {
 
216
          const BType *BB = &(*BI);
 
217
          dbgs() << BB << "@" << format("%p", BB) << ": " << format("%.20g",getExecutionCount(BB)) << "\n";
 
218
        }
 
219
      }
 
220
      dbgs() << "**** ProfileInfo " << this << ", over and out.\n";
 
221
    }
 
222
 
 
223
    bool CalculateMissingEdge(const BType *BB, Edge &removed, bool assumeEmptyExit = false);
 
224
 
 
225
    bool EstimateMissingEdges(const BType *BB);
 
226
 
 
227
    ProfileInfoT<MachineFunction, MachineBasicBlock> *MI() {
 
228
      if (MachineProfile == 0)
 
229
        MachineProfile = new ProfileInfoT<MachineFunction, MachineBasicBlock>();
 
230
      return MachineProfile;
 
231
    }
 
232
 
 
233
    bool hasMI() const {
 
234
      return (MachineProfile != 0);
 
235
    }
 
236
  };
 
237
 
 
238
  typedef ProfileInfoT<Function, BasicBlock> ProfileInfo;
 
239
  typedef ProfileInfoT<MachineFunction, MachineBasicBlock> MachineProfileInfo;
 
240
 
 
241
  /// createProfileLoaderPass - This function returns a Pass that loads the
 
242
  /// profiling information for the module from the specified filename, making
 
243
  /// it available to the optimizers.
 
244
  Pass *createProfileLoaderPass(const std::string &Filename);
 
245
 
 
246
} // End llvm namespace
 
247
 
 
248
#endif