← 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/ExecutionEngine/JITMemoryManager.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/ExecutionEngine/JITMemoryManager.h
 
1
//===-- JITMemoryManager.h - Interface JIT uses to Allocate Mem -*- 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 JITMemoryManagerInterface
 
11
//
 
12
//===----------------------------------------------------------------------===//
 
13
 
 
14
#ifndef LLVM_EXECUTION_ENGINE_JIT_MEMMANAGER_H
 
15
#define LLVM_EXECUTION_ENGINE_JIT_MEMMANAGER_H
 
16
 
 
17
#include "llvm/System/DataTypes.h"
 
18
#include <string>
 
19
 
 
20
namespace llvm {
 
21
 
 
22
  class Function;
 
23
  class GlobalValue;
 
24
 
 
25
/// JITMemoryManager - This interface is used by the JIT to allocate and manage
 
26
/// memory for the code generated by the JIT.  This can be reimplemented by
 
27
/// clients that have a strong desire to control how the layout of JIT'd memory
 
28
/// works.
 
29
class JITMemoryManager {
 
30
protected:
 
31
  bool HasGOT;
 
32
  bool SizeRequired;
 
33
public:
 
34
 
 
35
  JITMemoryManager() : HasGOT(false), SizeRequired(false) {}
 
36
  virtual ~JITMemoryManager();
 
37
  
 
38
  /// CreateDefaultMemManager - This is used to create the default
 
39
  /// JIT Memory Manager if the client does not provide one to the JIT.
 
40
  static JITMemoryManager *CreateDefaultMemManager();
 
41
  
 
42
  /// setMemoryWritable - When code generation is in progress,
 
43
  /// the code pages may need permissions changed.
 
44
  virtual void setMemoryWritable() = 0;
 
45
 
 
46
  /// setMemoryExecutable - When code generation is done and we're ready to
 
47
  /// start execution, the code pages may need permissions changed.
 
48
  virtual void setMemoryExecutable() = 0;
 
49
 
 
50
  /// setPoisonMemory - Setting this flag to true makes the memory manager
 
51
  /// garbage values over freed memory.  This is useful for testing and
 
52
  /// debugging, and is be turned on by default in debug mode.
 
53
  virtual void setPoisonMemory(bool poison) = 0;
 
54
 
 
55
  //===--------------------------------------------------------------------===//
 
56
  // Global Offset Table Management
 
57
  //===--------------------------------------------------------------------===//
 
58
 
 
59
  /// AllocateGOT - If the current table requires a Global Offset Table, this
 
60
  /// method is invoked to allocate it.  This method is required to set HasGOT
 
61
  /// to true.
 
62
  virtual void AllocateGOT() = 0;
 
63
  
 
64
  /// isManagingGOT - Return true if the AllocateGOT method is called.
 
65
  ///
 
66
  bool isManagingGOT() const {
 
67
    return HasGOT;
 
68
  }
 
69
  
 
70
  /// getGOTBase - If this is managing a Global Offset Table, this method should
 
71
  /// return a pointer to its base.
 
72
  virtual uint8_t *getGOTBase() const = 0;
 
73
  
 
74
  /// NeedsExactSize - If the memory manager requires to know the size of the
 
75
  /// objects to be emitted
 
76
  bool NeedsExactSize() const {
 
77
    return SizeRequired;
 
78
  }
 
79
 
 
80
  //===--------------------------------------------------------------------===//
 
81
  // Main Allocation Functions
 
82
  //===--------------------------------------------------------------------===//
 
83
 
 
84
  /// startFunctionBody - When we start JITing a function, the JIT calls this
 
85
  /// method to allocate a block of free RWX memory, which returns a pointer to
 
86
  /// it.  If the JIT wants to request a block of memory of at least a certain
 
87
  /// size, it passes that value as ActualSize, and this method returns a block
 
88
  /// with at least that much space.  If the JIT doesn't know ahead of time how
 
89
  /// much space it will need to emit the function, it passes 0 for the
 
90
  /// ActualSize.  In either case, this method is required to pass back the size
 
91
  /// of the allocated block through ActualSize.  The JIT will be careful to
 
92
  /// not write more than the returned ActualSize bytes of memory.
 
93
  virtual uint8_t *startFunctionBody(const Function *F,
 
94
                                     uintptr_t &ActualSize) = 0;
 
95
 
 
96
  /// allocateStub - This method is called by the JIT to allocate space for a
 
97
  /// function stub (used to handle limited branch displacements) while it is
 
98
  /// JIT compiling a function.  For example, if foo calls bar, and if bar
 
99
  /// either needs to be lazily compiled or is a native function that exists too
 
100
  /// far away from the call site to work, this method will be used to make a
 
101
  /// thunk for it.  The stub should be "close" to the current function body,
 
102
  /// but should not be included in the 'actualsize' returned by
 
103
  /// startFunctionBody.
 
104
  virtual uint8_t *allocateStub(const GlobalValue* F, unsigned StubSize,
 
105
                                unsigned Alignment) = 0;
 
106
  
 
107
  /// endFunctionBody - This method is called when the JIT is done codegen'ing
 
108
  /// the specified function.  At this point we know the size of the JIT
 
109
  /// compiled function.  This passes in FunctionStart (which was returned by
 
110
  /// the startFunctionBody method) and FunctionEnd which is a pointer to the 
 
111
  /// actual end of the function.  This method should mark the space allocated
 
112
  /// and remember where it is in case the client wants to deallocate it.
 
113
  virtual void endFunctionBody(const Function *F, uint8_t *FunctionStart,
 
114
                               uint8_t *FunctionEnd) = 0;
 
115
 
 
116
  /// allocateSpace - Allocate a memory block of the given size.  This method
 
117
  /// cannot be called between calls to startFunctionBody and endFunctionBody.
 
118
  virtual uint8_t *allocateSpace(intptr_t Size, unsigned Alignment) = 0;
 
119
 
 
120
  /// allocateGlobal - Allocate memory for a global.
 
121
  ///
 
122
  virtual uint8_t *allocateGlobal(uintptr_t Size, unsigned Alignment) = 0;
 
123
 
 
124
  /// deallocateFunctionBody - Free the specified function body.  The argument
 
125
  /// must be the return value from a call to startFunctionBody() that hasn't
 
126
  /// been deallocated yet.  This is never called when the JIT is currently
 
127
  /// emitting a function.
 
128
  virtual void deallocateFunctionBody(void *Body) = 0;
 
129
  
 
130
  /// startExceptionTable - When we finished JITing the function, if exception
 
131
  /// handling is set, we emit the exception table.
 
132
  virtual uint8_t* startExceptionTable(const Function* F,
 
133
                                       uintptr_t &ActualSize) = 0;
 
134
  
 
135
  /// endExceptionTable - This method is called when the JIT is done emitting
 
136
  /// the exception table.
 
137
  virtual void endExceptionTable(const Function *F, uint8_t *TableStart,
 
138
                                 uint8_t *TableEnd, uint8_t* FrameRegister) = 0;
 
139
 
 
140
  /// deallocateExceptionTable - Free the specified exception table's memory.
 
141
  /// The argument must be the return value from a call to startExceptionTable()
 
142
  /// that hasn't been deallocated yet.  This is never called when the JIT is
 
143
  /// currently emitting an exception table.
 
144
  virtual void deallocateExceptionTable(void *ET) = 0;
 
145
 
 
146
  /// CheckInvariants - For testing only.  Return true if all internal
 
147
  /// invariants are preserved, or return false and set ErrorStr to a helpful
 
148
  /// error message.
 
149
  virtual bool CheckInvariants(std::string &) {
 
150
    return true;
 
151
  }
 
152
 
 
153
  /// GetDefaultCodeSlabSize - For testing only.  Returns DefaultCodeSlabSize
 
154
  /// from DefaultJITMemoryManager.
 
155
  virtual size_t GetDefaultCodeSlabSize() {
 
156
    return 0;
 
157
  }
 
158
 
 
159
  /// GetDefaultDataSlabSize - For testing only.  Returns DefaultCodeSlabSize
 
160
  /// from DefaultJITMemoryManager.
 
161
  virtual size_t GetDefaultDataSlabSize() {
 
162
    return 0;
 
163
  }
 
164
 
 
165
  /// GetDefaultStubSlabSize - For testing only.  Returns DefaultCodeSlabSize
 
166
  /// from DefaultJITMemoryManager.
 
167
  virtual size_t GetDefaultStubSlabSize() {
 
168
    return 0;
 
169
  }
 
170
 
 
171
  /// GetNumCodeSlabs - For testing only.  Returns the number of MemoryBlocks
 
172
  /// allocated for code.
 
173
  virtual unsigned GetNumCodeSlabs() {
 
174
    return 0;
 
175
  }
 
176
 
 
177
  /// GetNumDataSlabs - For testing only.  Returns the number of MemoryBlocks
 
178
  /// allocated for data.
 
179
  virtual unsigned GetNumDataSlabs() {
 
180
    return 0;
 
181
  }
 
182
 
 
183
  /// GetNumStubSlabs - For testing only.  Returns the number of MemoryBlocks
 
184
  /// allocated for function stubs.
 
185
  virtual unsigned GetNumStubSlabs() {
 
186
    return 0;
 
187
  }
 
188
};
 
189
 
 
190
} // end namespace llvm.
 
191
 
 
192
#endif