← Back to branch summary

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

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/include/llvm/CodeGen/MachineSSAUpdater.h

  • 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/include/llvm/CodeGen/MachineSSAUpdater.h
 
1
//===-- MachineSSAUpdater.h - Unstructured SSA Update Tool ------*- 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 declares the MachineSSAUpdater class.
 
11
//
 
12
//===----------------------------------------------------------------------===//
 
13
 
 
14
#ifndef LLVM_CODEGEN_MACHINESSAUPDATER_H
 
15
#define LLVM_CODEGEN_MACHINESSAUPDATER_H
 
16
 
 
17
namespace llvm {
 
18
  class MachineBasicBlock;
 
19
  class MachineFunction;
 
20
  class MachineInstr;
 
21
  class MachineOperand;
 
22
  class MachineRegisterInfo;
 
23
  class TargetInstrInfo;
 
24
  class TargetRegisterClass;
 
25
  template<typename T> class SmallVectorImpl;
 
26
 
 
27
/// MachineSSAUpdater - This class updates SSA form for a set of virtual
 
28
/// registers defined in multiple blocks.  This is used when code duplication
 
29
/// or another unstructured transformation wants to rewrite a set of uses of one
 
30
/// vreg with uses of a set of vregs.
 
31
class MachineSSAUpdater {
 
32
  /// AvailableVals - This keeps track of which value to use on a per-block
 
33
  /// basis.  When we insert PHI nodes, we keep track of them here.
 
34
  //typedef DenseMap<MachineBasicBlock*, unsigned > AvailableValsTy;
 
35
  void *AV;
 
36
 
 
37
  /// IncomingPredInfo - We use this as scratch space when doing our recursive
 
38
  /// walk.  This should only be used in GetValueInBlockInternal, normally it
 
39
  /// should be empty.
 
40
  //std::vector<std::pair<MachineBasicBlock*, unsigned > > IncomingPredInfo;
 
41
  void *IPI;
 
42
 
 
43
  /// VR - Current virtual register whose uses are being updated.
 
44
  unsigned VR;
 
45
 
 
46
  /// VRC - Register class of the current virtual register.
 
47
  const TargetRegisterClass *VRC;
 
48
 
 
49
  /// InsertedPHIs - If this is non-null, the MachineSSAUpdater adds all PHI
 
50
  /// nodes that it creates to the vector.
 
51
  SmallVectorImpl<MachineInstr*> *InsertedPHIs;
 
52
 
 
53
  const TargetInstrInfo *TII;
 
54
  MachineRegisterInfo *MRI;
 
55
public:
 
56
  /// MachineSSAUpdater constructor.  If InsertedPHIs is specified, it will be
 
57
  /// filled in with all PHI Nodes created by rewriting.
 
58
  explicit MachineSSAUpdater(MachineFunction &MF,
 
59
                             SmallVectorImpl<MachineInstr*> *InsertedPHIs = 0);
 
60
  ~MachineSSAUpdater();
 
61
 
 
62
  /// Initialize - Reset this object to get ready for a new set of SSA
 
63
  /// updates.
 
64
  void Initialize(unsigned V);
 
65
 
 
66
  /// AddAvailableValue - Indicate that a rewritten value is available at the
 
67
  /// end of the specified block with the specified value.
 
68
  void AddAvailableValue(MachineBasicBlock *BB, unsigned V);
 
69
 
 
70
  /// HasValueForBlock - Return true if the MachineSSAUpdater already has a
 
71
  /// value for the specified block.
 
72
  bool HasValueForBlock(MachineBasicBlock *BB) const;
 
73
 
 
74
  /// GetValueAtEndOfBlock - Construct SSA form, materializing a value that is
 
75
  /// live at the end of the specified block.
 
76
  unsigned GetValueAtEndOfBlock(MachineBasicBlock *BB);
 
77
 
 
78
  /// GetValueInMiddleOfBlock - Construct SSA form, materializing a value that
 
79
  /// is live in the middle of the specified block.
 
80
  ///
 
81
  /// GetValueInMiddleOfBlock is the same as GetValueAtEndOfBlock except in one
 
82
  /// important case: if there is a definition of the rewritten value after the
 
83
  /// 'use' in BB.  Consider code like this:
 
84
  ///
 
85
  ///      X1 = ...
 
86
  ///   SomeBB:
 
87
  ///      use(X)
 
88
  ///      X2 = ...
 
89
  ///      br Cond, SomeBB, OutBB
 
90
  ///
 
91
  /// In this case, there are two values (X1 and X2) added to the AvailableVals
 
92
  /// set by the client of the rewriter, and those values are both live out of
 
93
  /// their respective blocks.  However, the use of X happens in the *middle* of
 
94
  /// a block.  Because of this, we need to insert a new PHI node in SomeBB to
 
95
  /// merge the appropriate values, and this value isn't live out of the block.
 
96
  ///
 
97
  unsigned GetValueInMiddleOfBlock(MachineBasicBlock *BB);
 
98
 
 
99
  /// RewriteUse - Rewrite a use of the symbolic value.  This handles PHI nodes,
 
100
  /// which use their value in the corresponding predecessor.  Note that this
 
101
  /// will not work if the use is supposed to be rewritten to a value defined in
 
102
  /// the same block as the use, but above it.  Any 'AddAvailableValue's added
 
103
  /// for the use's block will be considered to be below it.
 
104
  void RewriteUse(MachineOperand &U);
 
105
 
 
106
private:
 
107
  void ReplaceRegWith(unsigned OldReg, unsigned NewReg);
 
108
  unsigned GetValueAtEndOfBlockInternal(MachineBasicBlock *BB);
 
109
  void operator=(const MachineSSAUpdater&); // DO NOT IMPLEMENT
 
110
  MachineSSAUpdater(const MachineSSAUpdater&);     // DO NOT IMPLEMENT
 
111
};
 
112
 
 
113
} // End llvm namespace
 
114
 
 
115
#endif