← 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/Function.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/Function.h
 
1
//===-- llvm/Function.h - Class to represent a single function --*- 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 contains the declaration of the Function class, which represents a
 
11
// single function/procedure in LLVM.
 
12
//
 
13
// A function basically consists of a list of basic blocks, a list of arguments,
 
14
// and a symbol table.
 
15
//
 
16
//===----------------------------------------------------------------------===//
 
17
 
 
18
#ifndef LLVM_FUNCTION_H
 
19
#define LLVM_FUNCTION_H
 
20
 
 
21
#include "llvm/GlobalValue.h"
 
22
#include "llvm/CallingConv.h"
 
23
#include "llvm/BasicBlock.h"
 
24
#include "llvm/Argument.h"
 
25
#include "llvm/Attributes.h"
 
26
#include "llvm/Support/Compiler.h"
 
27
 
 
28
namespace llvm {
 
29
 
 
30
class FunctionType;
 
31
class LLVMContext;
 
32
 
 
33
// Traits for intrusive list of basic blocks...
 
34
template<> struct ilist_traits<BasicBlock>
 
35
  : public SymbolTableListTraits<BasicBlock, Function> {
 
36
 
 
37
  // createSentinel is used to get hold of the node that marks the end of the
 
38
  // list... (same trick used here as in ilist_traits<Instruction>)
 
39
  BasicBlock *createSentinel() const {
 
40
    return static_cast<BasicBlock*>(&Sentinel);
 
41
  }
 
42
  static void destroySentinel(BasicBlock*) {}
 
43
 
 
44
  BasicBlock *provideInitialHead() const { return createSentinel(); }
 
45
  BasicBlock *ensureHead(BasicBlock*) const { return createSentinel(); }
 
46
  static void noteHead(BasicBlock*, BasicBlock*) {}
 
47
 
 
48
  static ValueSymbolTable *getSymTab(Function *ItemParent);
 
49
private:
 
50
  mutable ilist_half_node<BasicBlock> Sentinel;
 
51
};
 
52
 
 
53
template<> struct ilist_traits<Argument>
 
54
  : public SymbolTableListTraits<Argument, Function> {
 
55
 
 
56
  Argument *createSentinel() const {
 
57
    return static_cast<Argument*>(&Sentinel);
 
58
  }
 
59
  static void destroySentinel(Argument*) {}
 
60
 
 
61
  Argument *provideInitialHead() const { return createSentinel(); }
 
62
  Argument *ensureHead(Argument*) const { return createSentinel(); }
 
63
  static void noteHead(Argument*, Argument*) {}
 
64
 
 
65
  static ValueSymbolTable *getSymTab(Function *ItemParent);
 
66
private:
 
67
  mutable ilist_half_node<Argument> Sentinel;
 
68
};
 
69
 
 
70
class Function : public GlobalValue,
 
71
                 public ilist_node<Function> {
 
72
public:
 
73
  typedef iplist<Argument> ArgumentListType;
 
74
  typedef iplist<BasicBlock> BasicBlockListType;
 
75
 
 
76
  // BasicBlock iterators...
 
77
  typedef BasicBlockListType::iterator iterator;
 
78
  typedef BasicBlockListType::const_iterator const_iterator;
 
79
 
 
80
  typedef ArgumentListType::iterator arg_iterator;
 
81
  typedef ArgumentListType::const_iterator const_arg_iterator;
 
82
 
 
83
private:
 
84
  // Important things that make up a function!
 
85
  BasicBlockListType  BasicBlocks;        ///< The basic blocks
 
86
  mutable ArgumentListType ArgumentList;  ///< The formal arguments
 
87
  ValueSymbolTable *SymTab;               ///< Symbol table of args/instructions
 
88
  AttrListPtr AttributeList;              ///< Parameter attributes
 
89
 
 
90
  // HasLazyArguments is stored in Value::SubclassData.
 
91
  /*bool HasLazyArguments;*/
 
92
                   
 
93
  // The Calling Convention is stored in Value::SubclassData.
 
94
  /*CallingConv::ID CallingConvention;*/
 
95
 
 
96
  friend class SymbolTableListTraits<Function, Module>;
 
97
 
 
98
  void setParent(Module *parent);
 
99
 
 
100
  /// hasLazyArguments/CheckLazyArguments - The argument list of a function is
 
101
  /// built on demand, so that the list isn't allocated until the first client
 
102
  /// needs it.  The hasLazyArguments predicate returns true if the arg list
 
103
  /// hasn't been set up yet.
 
104
  bool hasLazyArguments() const {
 
105
    return getSubclassDataFromValue() & 1;
 
106
  }
 
107
  void CheckLazyArguments() const {
 
108
    if (hasLazyArguments())
 
109
      BuildLazyArguments();
 
110
  }
 
111
  void BuildLazyArguments() const;
 
112
  
 
113
  Function(const Function&); // DO NOT IMPLEMENT
 
114
  void operator=(const Function&); // DO NOT IMPLEMENT
 
115
 
 
116
  /// Function ctor - If the (optional) Module argument is specified, the
 
117
  /// function is automatically inserted into the end of the function list for
 
118
  /// the module.
 
119
  ///
 
120
  Function(const FunctionType *Ty, LinkageTypes Linkage,
 
121
           const Twine &N = "", Module *M = 0);
 
122
 
 
123
public:
 
124
  static Function *Create(const FunctionType *Ty, LinkageTypes Linkage,
 
125
                          const Twine &N = "", Module *M = 0) {
 
126
    return new(0) Function(Ty, Linkage, N, M);
 
127
  }
 
128
 
 
129
  ~Function();
 
130
 
 
131
  const Type *getReturnType() const;           // Return the type of the ret val
 
132
  const FunctionType *getFunctionType() const; // Return the FunctionType for me
 
133
 
 
134
  /// getContext - Return a pointer to the LLVMContext associated with this 
 
135
  /// function, or NULL if this function is not bound to a context yet.
 
136
  LLVMContext &getContext() const;
 
137
 
 
138
  /// isVarArg - Return true if this function takes a variable number of
 
139
  /// arguments.
 
140
  bool isVarArg() const;
 
141
 
 
142
  /// isDeclaration - Is the body of this function unknown? (The basic block 
 
143
  /// list is empty if so.) This is true for function declarations, but not 
 
144
  /// true for function definitions.
 
145
  ///
 
146
  virtual bool isDeclaration() const { return BasicBlocks.empty(); }
 
147
 
 
148
  /// getIntrinsicID - This method returns the ID number of the specified
 
149
  /// function, or Intrinsic::not_intrinsic if the function is not an
 
150
  /// instrinsic, or if the pointer is null.  This value is always defined to be
 
151
  /// zero to allow easy checking for whether a function is intrinsic or not.
 
152
  /// The particular intrinsic functions which correspond to this value are
 
153
  /// defined in llvm/Intrinsics.h.
 
154
  ///
 
155
  unsigned getIntrinsicID() const ATTRIBUTE_READONLY;
 
156
  bool isIntrinsic() const { return getIntrinsicID() != 0; }
 
157
 
 
158
  /// getCallingConv()/setCallingConv(CC) - These method get and set the
 
159
  /// calling convention of this function.  The enum values for the known
 
160
  /// calling conventions are defined in CallingConv.h.
 
161
  CallingConv::ID getCallingConv() const {
 
162
    return static_cast<CallingConv::ID>(getSubclassDataFromValue() >> 1);
 
163
  }
 
164
  void setCallingConv(CallingConv::ID CC) {
 
165
    setValueSubclassData((getSubclassDataFromValue() & 1) |
 
166
                         (static_cast<unsigned>(CC) << 1));
 
167
  }
 
168
  
 
169
  /// getAttributes - Return the attribute list for this Function.
 
170
  ///
 
171
  const AttrListPtr &getAttributes() const { return AttributeList; }
 
172
 
 
173
  /// setAttributes - Set the attribute list for this Function.
 
174
  ///
 
175
  void setAttributes(const AttrListPtr &attrs) { AttributeList = attrs; }
 
176
 
 
177
  /// hasFnAttr - Return true if this function has the given attribute.
 
178
  bool hasFnAttr(Attributes N) const {
 
179
    // Function Attributes are stored at ~0 index 
 
180
    return AttributeList.paramHasAttr(~0U, N);
 
181
  }
 
182
 
 
183
  /// addFnAttr - Add function attributes to this function.
 
184
  ///
 
185
  void addFnAttr(Attributes N) { 
 
186
    // Function Attributes are stored at ~0 index 
 
187
    addAttribute(~0U, N);
 
188
  }
 
189
 
 
190
  /// removeFnAttr - Remove function attributes from this function.
 
191
  ///
 
192
  void removeFnAttr(Attributes N) {
 
193
    // Function Attributes are stored at ~0 index 
 
194
    removeAttribute(~0U, N);
 
195
  }
 
196
 
 
197
  /// hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm
 
198
  ///                             to use during code generation.
 
199
  bool hasGC() const;
 
200
  const char *getGC() const;
 
201
  void setGC(const char *Str);
 
202
  void clearGC();
 
203
 
 
204
  /// @brief Determine whether the function has the given attribute.
 
205
  bool paramHasAttr(unsigned i, Attributes attr) const {
 
206
    return AttributeList.paramHasAttr(i, attr);
 
207
  }
 
208
 
 
209
  /// addAttribute - adds the attribute to the list of attributes.
 
210
  void addAttribute(unsigned i, Attributes attr);
 
211
  
 
212
  /// removeAttribute - removes the attribute from the list of attributes.
 
213
  void removeAttribute(unsigned i, Attributes attr);
 
214
 
 
215
  /// @brief Extract the alignment for a call or parameter (0=unknown).
 
216
  unsigned getParamAlignment(unsigned i) const {
 
217
    return AttributeList.getParamAlignment(i);
 
218
  }
 
219
 
 
220
  /// @brief Determine if the function does not access memory.
 
221
  bool doesNotAccessMemory() const {
 
222
    return hasFnAttr(Attribute::ReadNone);
 
223
  }
 
224
  void setDoesNotAccessMemory(bool DoesNotAccessMemory = true) {
 
225
    if (DoesNotAccessMemory) addFnAttr(Attribute::ReadNone);
 
226
    else removeFnAttr(Attribute::ReadNone);
 
227
  }
 
228
 
 
229
  /// @brief Determine if the function does not access or only reads memory.
 
230
  bool onlyReadsMemory() const {
 
231
    return doesNotAccessMemory() || hasFnAttr(Attribute::ReadOnly);
 
232
  }
 
233
  void setOnlyReadsMemory(bool OnlyReadsMemory = true) {
 
234
    if (OnlyReadsMemory) addFnAttr(Attribute::ReadOnly);
 
235
    else removeFnAttr(Attribute::ReadOnly | Attribute::ReadNone);
 
236
  }
 
237
 
 
238
  /// @brief Determine if the function cannot return.
 
239
  bool doesNotReturn() const {
 
240
    return hasFnAttr(Attribute::NoReturn);
 
241
  }
 
242
  void setDoesNotReturn(bool DoesNotReturn = true) {
 
243
    if (DoesNotReturn) addFnAttr(Attribute::NoReturn);
 
244
    else removeFnAttr(Attribute::NoReturn);
 
245
  }
 
246
 
 
247
  /// @brief Determine if the function cannot unwind.
 
248
  bool doesNotThrow() const {
 
249
    return hasFnAttr(Attribute::NoUnwind);
 
250
  }
 
251
  void setDoesNotThrow(bool DoesNotThrow = true) {
 
252
    if (DoesNotThrow) addFnAttr(Attribute::NoUnwind);
 
253
    else removeFnAttr(Attribute::NoUnwind);
 
254
  }
 
255
 
 
256
  /// @brief Determine if the function returns a structure through first 
 
257
  /// pointer argument.
 
258
  bool hasStructRetAttr() const {
 
259
    return paramHasAttr(1, Attribute::StructRet);
 
260
  }
 
261
 
 
262
  /// @brief Determine if the parameter does not alias other parameters.
 
263
  /// @param n The parameter to check. 1 is the first parameter, 0 is the return
 
264
  bool doesNotAlias(unsigned n) const {
 
265
    return paramHasAttr(n, Attribute::NoAlias);
 
266
  }
 
267
  void setDoesNotAlias(unsigned n, bool DoesNotAlias = true) {
 
268
    if (DoesNotAlias) addAttribute(n, Attribute::NoAlias);
 
269
    else removeAttribute(n, Attribute::NoAlias);
 
270
  }
 
271
 
 
272
  /// @brief Determine if the parameter can be captured.
 
273
  /// @param n The parameter to check. 1 is the first parameter, 0 is the return
 
274
  bool doesNotCapture(unsigned n) const {
 
275
    return paramHasAttr(n, Attribute::NoCapture);
 
276
  }
 
277
  void setDoesNotCapture(unsigned n, bool DoesNotCapture = true) {
 
278
    if (DoesNotCapture) addAttribute(n, Attribute::NoCapture);
 
279
    else removeAttribute(n, Attribute::NoCapture);
 
280
  }
 
281
 
 
282
  /// copyAttributesFrom - copy all additional attributes (those not needed to
 
283
  /// create a Function) from the Function Src to this one.
 
284
  void copyAttributesFrom(const GlobalValue *Src);
 
285
 
 
286
  /// deleteBody - This method deletes the body of the function, and converts
 
287
  /// the linkage to external.
 
288
  ///
 
289
  void deleteBody() {
 
290
    dropAllReferences();
 
291
    setLinkage(ExternalLinkage);
 
292
  }
 
293
 
 
294
  /// removeFromParent - This method unlinks 'this' from the containing module,
 
295
  /// but does not delete it.
 
296
  ///
 
297
  virtual void removeFromParent();
 
298
 
 
299
  /// eraseFromParent - This method unlinks 'this' from the containing module
 
300
  /// and deletes it.
 
301
  ///
 
302
  virtual void eraseFromParent();
 
303
 
 
304
 
 
305
  /// Get the underlying elements of the Function... the basic block list is
 
306
  /// empty for external functions.
 
307
  ///
 
308
  const ArgumentListType &getArgumentList() const {
 
309
    CheckLazyArguments();
 
310
    return ArgumentList;
 
311
  }
 
312
  ArgumentListType &getArgumentList() {
 
313
    CheckLazyArguments();
 
314
    return ArgumentList;
 
315
  }
 
316
  static iplist<Argument> Function::*getSublistAccess(Argument*) {
 
317
    return &Function::ArgumentList;
 
318
  }
 
319
 
 
320
  const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; }
 
321
        BasicBlockListType &getBasicBlockList()       { return BasicBlocks; }
 
322
  static iplist<BasicBlock> Function::*getSublistAccess(BasicBlock*) {
 
323
    return &Function::BasicBlocks;
 
324
  }
 
325
 
 
326
  const BasicBlock       &getEntryBlock() const   { return front(); }
 
327
        BasicBlock       &getEntryBlock()         { return front(); }
 
328
 
 
329
  //===--------------------------------------------------------------------===//
 
330
  // Symbol Table Accessing functions...
 
331
 
 
332
  /// getSymbolTable() - Return the symbol table...
 
333
  ///
 
334
  inline       ValueSymbolTable &getValueSymbolTable()       { return *SymTab; }
 
335
  inline const ValueSymbolTable &getValueSymbolTable() const { return *SymTab; }
 
336
 
 
337
 
 
338
  //===--------------------------------------------------------------------===//
 
339
  // BasicBlock iterator forwarding functions
 
340
  //
 
341
  iterator                begin()       { return BasicBlocks.begin(); }
 
342
  const_iterator          begin() const { return BasicBlocks.begin(); }
 
343
  iterator                end  ()       { return BasicBlocks.end();   }
 
344
  const_iterator          end  () const { return BasicBlocks.end();   }
 
345
 
 
346
  size_t                   size() const { return BasicBlocks.size();  }
 
347
  bool                    empty() const { return BasicBlocks.empty(); }
 
348
  const BasicBlock       &front() const { return BasicBlocks.front(); }
 
349
        BasicBlock       &front()       { return BasicBlocks.front(); }
 
350
  const BasicBlock        &back() const { return BasicBlocks.back();  }
 
351
        BasicBlock        &back()       { return BasicBlocks.back();  }
 
352
 
 
353
  //===--------------------------------------------------------------------===//
 
354
  // Argument iterator forwarding functions
 
355
  //
 
356
  arg_iterator arg_begin() {
 
357
    CheckLazyArguments();
 
358
    return ArgumentList.begin();
 
359
  }
 
360
  const_arg_iterator arg_begin() const {
 
361
    CheckLazyArguments();
 
362
    return ArgumentList.begin();
 
363
  }
 
364
  arg_iterator arg_end() {
 
365
    CheckLazyArguments();
 
366
    return ArgumentList.end();
 
367
  }
 
368
  const_arg_iterator arg_end() const {
 
369
    CheckLazyArguments();
 
370
    return ArgumentList.end();
 
371
  }
 
372
 
 
373
  size_t arg_size() const;
 
374
  bool arg_empty() const;
 
375
 
 
376
  /// viewCFG - This function is meant for use from the debugger.  You can just
 
377
  /// say 'call F->viewCFG()' and a ghostview window should pop up from the
 
378
  /// program, displaying the CFG of the current function with the code for each
 
379
  /// basic block inside.  This depends on there being a 'dot' and 'gv' program
 
380
  /// in your path.
 
381
  ///
 
382
  void viewCFG() const;
 
383
 
 
384
  /// viewCFGOnly - This function is meant for use from the debugger.  It works
 
385
  /// just like viewCFG, but it does not include the contents of basic blocks
 
386
  /// into the nodes, just the label.  If you are only interested in the CFG
 
387
  /// this can make the graph smaller.
 
388
  ///
 
389
  void viewCFGOnly() const;
 
390
 
 
391
  /// Methods for support type inquiry through isa, cast, and dyn_cast:
 
392
  static inline bool classof(const Function *) { return true; }
 
393
  static inline bool classof(const Value *V) {
 
394
    return V->getValueID() == Value::FunctionVal;
 
395
  }
 
396
 
 
397
  /// dropAllReferences() - This method causes all the subinstructions to "let
 
398
  /// go" of all references that they are maintaining.  This allows one to
 
399
  /// 'delete' a whole module at a time, even though there may be circular
 
400
  /// references... first all references are dropped, and all use counts go to
 
401
  /// zero.  Then everything is deleted for real.  Note that no operations are
 
402
  /// valid on an object that has "dropped all references", except operator
 
403
  /// delete.
 
404
  ///
 
405
  /// Since no other object in the module can have references into the body of a
 
406
  /// function, dropping all references deletes the entire body of the function,
 
407
  /// including any contained basic blocks.
 
408
  ///
 
409
  void dropAllReferences();
 
410
 
 
411
  /// hasAddressTaken - returns true if there are any uses of this function
 
412
  /// other than direct calls or invokes to it.
 
413
  bool hasAddressTaken() const;
 
414
private:
 
415
  // Shadow Value::setValueSubclassData with a private forwarding method so that
 
416
  // subclasses cannot accidentally use it.
 
417
  void setValueSubclassData(unsigned short D) {
 
418
    Value::setValueSubclassData(D);
 
419
  }
 
420
};
 
421
 
 
422
inline ValueSymbolTable *
 
423
ilist_traits<BasicBlock>::getSymTab(Function *F) {
 
424
  return F ? &F->getValueSymbolTable() : 0;
 
425
}
 
426
 
 
427
inline ValueSymbolTable *
 
428
ilist_traits<Argument>::getSymTab(Function *F) {
 
429
  return F ? &F->getValueSymbolTable() : 0;
 
430
}
 
431
 
 
432
} // End llvm namespace
 
433
 
 
434
#endif