← Back to branch summary

~ubuntu-branches/ubuntu/feisty/clamav/feisty

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/include/llvm/PassManager.h

  • Committer: Bazaar Package Importer
  • Author(s): Kees Cook
  • Date: 2007-02-20 10:33:44 UTC
  • mto: This revision was merged to the branch mainline in revision 16.
  • Revision ID: james.westby@ubuntu.com-20070220103344-zgcu2psnx9d98fpa
Tags: upstream-0.90
Import upstream version 0.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/include/llvm/PassManager.h
1
 
//===- llvm/PassManager.h - Container for Passes ----------------*- 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 PassManager class.  This class is used to hold,
11
 
// maintain, and optimize execution of Passes.  The PassManager class ensures
12
 
// that analysis results are available before a pass runs, and that Pass's are
13
 
// destroyed when the PassManager is destroyed.
14
 
//
15
 
//===----------------------------------------------------------------------===//
16
 
 
17
 
#ifndef LLVM_PASSMANAGER_H
18
 
#define LLVM_PASSMANAGER_H
19
 
 
20
 
#include "llvm/Pass.h"
21
 
 
22
 
namespace llvm {
23
 
 
24
 
class Pass;
25
 
class Module;
26
 
 
27
 
class PassManagerImpl;
28
 
class FunctionPassManagerImpl;
29
 
 
30
 
/// PassManagerBase - An abstract interface to allow code to add passes to
31
 
/// a pass manager without having to hard-code what kind of pass manager
32
 
/// it is.
33
 
class PassManagerBase {
34
 
public:
35
 
  virtual ~PassManagerBase();
36
 
 
37
 
  /// add - Add a pass to the queue of passes to run.  This passes ownership of
38
 
  /// the Pass to the PassManager.  When the PassManager is destroyed, the pass
39
 
  /// will be destroyed as well, so there is no need to delete the pass.  This
40
 
  /// implies that all passes MUST be allocated with 'new'.
41
 
  virtual void add(Pass *P) = 0;
42
 
};
43
 
 
44
 
/// PassManager manages ModulePassManagers
45
 
class PassManager : public PassManagerBase {
46
 
public:
47
 
 
48
 
  PassManager();
49
 
  ~PassManager();
50
 
 
51
 
  /// add - Add a pass to the queue of passes to run.  This passes ownership of
52
 
  /// the Pass to the PassManager.  When the PassManager is destroyed, the pass
53
 
  /// will be destroyed as well, so there is no need to delete the pass.  This
54
 
  /// implies that all passes MUST be allocated with 'new'.
55
 
  void add(Pass *P);
56
 
 
57
 
  /// run - Execute all of the passes scheduled for execution.  Keep track of
58
 
  /// whether any of the passes modifies the module, and if so, return true.
59
 
  bool run(Module &M);
60
 
 
61
 
private:
62
 
  /// addImpl - Add a pass to the queue of passes to run, without
63
 
  /// checking whether to add a printer pass.
64
 
  void addImpl(Pass *P);
65
 
 
66
 
  /// PassManagerImpl_New is the actual class. PassManager is just the 
67
 
  /// wraper to publish simple pass manager interface
68
 
  PassManagerImpl *PM;
69
 
};
70
 
 
71
 
/// FunctionPassManager manages FunctionPasses and BasicBlockPassManagers.
72
 
class FunctionPassManager : public PassManagerBase {
73
 
public:
74
 
  /// FunctionPassManager ctor - This initializes the pass manager.  It needs,
75
 
  /// but does not take ownership of, the specified Module.
76
 
  explicit FunctionPassManager(Module *M);
77
 
  ~FunctionPassManager();
78
 
 
79
 
  /// add - Add a pass to the queue of passes to run.  This passes
80
 
  /// ownership of the Pass to the PassManager.  When the
81
 
  /// PassManager_X is destroyed, the pass will be destroyed as well, so
82
 
  /// there is no need to delete the pass. (TODO delete passes.)
83
 
  /// This implies that all passes MUST be allocated with 'new'.
84
 
  void add(Pass *P);
85
 
 
86
 
  /// run - Execute all of the passes scheduled for execution.  Keep
87
 
  /// track of whether any of the passes modifies the function, and if
88
 
  /// so, return true.
89
 
  ///
90
 
  bool run(Function &F);
91
 
  
92
 
  /// doInitialization - Run all of the initializers for the function passes.
93
 
  ///
94
 
  bool doInitialization();
95
 
  
96
 
  /// doFinalization - Run all of the finalizers for the function passes.
97
 
  ///
98
 
  bool doFinalization();
99
 
  
100
 
private:
101
 
  /// addImpl - Add a pass to the queue of passes to run, without
102
 
  /// checking whether to add a printer pass.
103
 
  void addImpl(Pass *P);
104
 
 
105
 
  FunctionPassManagerImpl *FPM;
106
 
  Module *M;
107
 
};
108
 
 
109
 
} // End llvm namespace
110
 
 
111
 
#endif