← 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/User.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/User.h
 
1
//===-- llvm/User.h - User class definition ---------------------*- 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 class defines the interface that one who 'use's a Value must implement.
 
11
// Each instance of the Value class keeps track of what User's have handles
 
12
// to it.
 
13
//
 
14
//  * Instructions are the largest class of User's.
 
15
//  * Constants may be users of other constants (think arrays and stuff)
 
16
//
 
17
//===----------------------------------------------------------------------===//
 
18
 
 
19
#ifndef LLVM_USER_H
 
20
#define LLVM_USER_H
 
21
 
 
22
#include "llvm/Value.h"
 
23
 
 
24
namespace llvm {
 
25
 
 
26
/// OperandTraits - Compile-time customization of
 
27
/// operand-related allocators and accessors
 
28
/// for use of the User class
 
29
template <class>
 
30
struct OperandTraits;
 
31
 
 
32
class User;
 
33
 
 
34
/// OperandTraits<User> - specialization to User
 
35
template <>
 
36
struct OperandTraits<User> {
 
37
  static inline Use *op_begin(User*);
 
38
  static inline Use *op_end(User*);
 
39
  static inline unsigned operands(const User*);
 
40
  template <class U>
 
41
  struct Layout {
 
42
    typedef U overlay;
 
43
  };
 
44
};
 
45
 
 
46
class User : public Value {
 
47
  User(const User &);             // Do not implement
 
48
  void *operator new(size_t);     // Do not implement
 
49
  template <unsigned>
 
50
  friend struct HungoffOperandTraits;
 
51
protected:
 
52
  /// OperandList - This is a pointer to the array of Uses for this User.
 
53
  /// For nodes of fixed arity (e.g. a binary operator) this array will live
 
54
  /// prefixed to some derived class instance.  For nodes of resizable variable
 
55
  /// arity (e.g. PHINodes, SwitchInst etc.), this memory will be dynamically
 
56
  /// allocated and should be destroyed by the classes' virtual dtor.
 
57
  Use *OperandList;
 
58
 
 
59
  /// NumOperands - The number of values used by this User.
 
60
  ///
 
61
  unsigned NumOperands;
 
62
 
 
63
  void *operator new(size_t s, unsigned Us);
 
64
  void *operator new(size_t s, unsigned Us, bool Prefix);
 
65
  User(const Type *ty, unsigned vty, Use *OpList, unsigned NumOps)
 
66
    : Value(ty, vty), OperandList(OpList), NumOperands(NumOps) {}
 
67
  Use *allocHungoffUses(unsigned) const;
 
68
  void dropHungoffUses(Use *U) {
 
69
    if (OperandList == U) {
 
70
      OperandList = 0;
 
71
      NumOperands = 0;
 
72
    }
 
73
    Use::zap(U, U->getImpliedUser(), true);
 
74
  }
 
75
public:
 
76
  ~User() {
 
77
    if ((intptr_t(OperandList) & 1) == 0)
 
78
      Use::zap(OperandList, OperandList + NumOperands);
 
79
  }
 
80
  /// operator delete - free memory allocated for User and Use objects
 
81
  void operator delete(void *Usr);
 
82
  /// placement delete - required by std, but never called.
 
83
  void operator delete(void*, unsigned) {
 
84
    assert(0 && "Constructor throws?");
 
85
  }
 
86
  /// placement delete - required by std, but never called.
 
87
  void operator delete(void*, unsigned, bool) {
 
88
    assert(0 && "Constructor throws?");
 
89
  }
 
90
protected:
 
91
  template <int Idx, typename U> static Use &OpFrom(const U *that) {
 
92
    return Idx < 0
 
93
      ? OperandTraits<U>::op_end(const_cast<U*>(that))[Idx]
 
94
      : OperandTraits<U>::op_begin(const_cast<U*>(that))[Idx];
 
95
  }
 
96
  template <int Idx> Use &Op() {
 
97
    return OpFrom<Idx>(this);
 
98
  }
 
99
  template <int Idx> const Use &Op() const {
 
100
    return OpFrom<Idx>(this);
 
101
  }
 
102
public:
 
103
  Value *getOperand(unsigned i) const {
 
104
    assert(i < NumOperands && "getOperand() out of range!");
 
105
    return OperandList[i];
 
106
  }
 
107
  void setOperand(unsigned i, Value *Val) {
 
108
    assert(i < NumOperands && "setOperand() out of range!");
 
109
    assert((!isa<Constant>((const Value*)this) ||
 
110
            isa<GlobalValue>((const Value*)this)) &&
 
111
           "Cannot mutate a constant with setOperand!");
 
112
    OperandList[i] = Val;
 
113
  }
 
114
  const Use &getOperandUse(unsigned i) const {
 
115
    assert(i < NumOperands && "getOperand() out of range!");
 
116
    return OperandList[i];
 
117
  }
 
118
  Use &getOperandUse(unsigned i) {
 
119
    assert(i < NumOperands && "getOperand() out of range!");
 
120
    return OperandList[i];
 
121
  }
 
122
  
 
123
  unsigned getNumOperands() const { return NumOperands; }
 
124
 
 
125
  // ---------------------------------------------------------------------------
 
126
  // Operand Iterator interface...
 
127
  //
 
128
  typedef Use*       op_iterator;
 
129
  typedef const Use* const_op_iterator;
 
130
 
 
131
  inline op_iterator       op_begin()       { return OperandList; }
 
132
  inline const_op_iterator op_begin() const { return OperandList; }
 
133
  inline op_iterator       op_end()         { return OperandList+NumOperands; }
 
134
  inline const_op_iterator op_end()   const { return OperandList+NumOperands; }
 
135
 
 
136
  // dropAllReferences() - This function is in charge of "letting go" of all
 
137
  // objects that this User refers to.  This allows one to
 
138
  // 'delete' a whole class at a time, even though there may be circular
 
139
  // references...  First all references are dropped, and all use counts go to
 
140
  // zero.  Then everything is deleted for real.  Note that no operations are
 
141
  // valid on an object that has "dropped all references", except operator
 
142
  // delete.
 
143
  //
 
144
  void dropAllReferences() {
 
145
    for (op_iterator i = op_begin(), e = op_end(); i != e; ++i)
 
146
      i->set(0);
 
147
  }
 
148
 
 
149
  /// replaceUsesOfWith - Replaces all references to the "From" definition with
 
150
  /// references to the "To" definition.
 
151
  ///
 
152
  void replaceUsesOfWith(Value *From, Value *To);
 
153
 
 
154
  // Methods for support type inquiry through isa, cast, and dyn_cast:
 
155
  static inline bool classof(const User *) { return true; }
 
156
  static inline bool classof(const Value *V) {
 
157
    return isa<Instruction>(V) || isa<Constant>(V);
 
158
  }
 
159
};
 
160
 
 
161
inline Use *OperandTraits<User>::op_begin(User *U) {
 
162
  return U->op_begin();
 
163
}
 
164
 
 
165
inline Use *OperandTraits<User>::op_end(User *U) {
 
166
  return U->op_end();
 
167
}
 
168
 
 
169
inline unsigned OperandTraits<User>::operands(const User *U) {
 
170
  return U->getNumOperands();
 
171
}
 
172
 
 
173
template<> struct simplify_type<User::op_iterator> {
 
174
  typedef Value* SimpleType;
 
175
 
 
176
  static SimpleType getSimplifiedValue(const User::op_iterator &Val) {
 
177
    return static_cast<SimpleType>(Val->get());
 
178
  }
 
179
};
 
180
 
 
181
template<> struct simplify_type<const User::op_iterator>
 
182
  : public simplify_type<User::op_iterator> {};
 
183
 
 
184
template<> struct simplify_type<User::const_op_iterator> {
 
185
  typedef Value* SimpleType;
 
186
 
 
187
  static SimpleType getSimplifiedValue(const User::const_op_iterator &Val) {
 
188
    return static_cast<SimpleType>(Val->get());
 
189
  }
 
190
};
 
191
 
 
192
template<> struct simplify_type<const User::const_op_iterator>
 
193
  : public simplify_type<User::const_op_iterator> {};
 
194
 
 
195
 
 
196
// value_use_iterator::getOperandNo - Requires the definition of the User class.
 
197
template<typename UserTy>
 
198
unsigned value_use_iterator<UserTy>::getOperandNo() const {
 
199
  return U - U->getUser()->op_begin();
 
200
}
 
201
 
 
202
} // End llvm namespace
 
203
 
 
204
#endif