← 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/CodeGen/JITCodeEmitter.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/CodeGen/JITCodeEmitter.h
 
1
//===-- llvm/CodeGen/JITCodeEmitter.h - Code emission ----------*- 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 an abstract interface that is used by the machine code
 
11
// emission framework to output the code.  This allows machine code emission to
 
12
// be separated from concerns such as resolution of call targets, and where the
 
13
// machine code will be written (memory or disk, f.e.).
 
14
//
 
15
//===----------------------------------------------------------------------===//
 
16
 
 
17
#ifndef LLVM_CODEGEN_JITCODEEMITTER_H
 
18
#define LLVM_CODEGEN_JITCODEEMITTER_H
 
19
 
 
20
#include <string>
 
21
#include "llvm/System/DataTypes.h"
 
22
#include "llvm/Support/MathExtras.h"
 
23
#include "llvm/CodeGen/MachineCodeEmitter.h"
 
24
 
 
25
using namespace std;
 
26
 
 
27
namespace llvm {
 
28
 
 
29
class MachineBasicBlock;
 
30
class MachineConstantPool;
 
31
class MachineJumpTableInfo;
 
32
class MachineFunction;
 
33
class MachineModuleInfo;
 
34
class MachineRelocation;
 
35
class Value;
 
36
class GlobalValue;
 
37
class Function;
 
38
 
 
39
/// JITCodeEmitter - This class defines two sorts of methods: those for
 
40
/// emitting the actual bytes of machine code, and those for emitting auxillary
 
41
/// structures, such as jump tables, relocations, etc.
 
42
///
 
43
/// Emission of machine code is complicated by the fact that we don't (in
 
44
/// general) know the size of the machine code that we're about to emit before
 
45
/// we emit it.  As such, we preallocate a certain amount of memory, and set the
 
46
/// BufferBegin/BufferEnd pointers to the start and end of the buffer.  As we
 
47
/// emit machine instructions, we advance the CurBufferPtr to indicate the
 
48
/// location of the next byte to emit.  In the case of a buffer overflow (we
 
49
/// need to emit more machine code than we have allocated space for), the
 
50
/// CurBufferPtr will saturate to BufferEnd and ignore stores.  Once the entire
 
51
/// function has been emitted, the overflow condition is checked, and if it has
 
52
/// occurred, more memory is allocated, and we reemit the code into it.
 
53
/// 
 
54
class JITCodeEmitter : public MachineCodeEmitter {
 
55
public:
 
56
  virtual ~JITCodeEmitter() {}
 
57
 
 
58
  /// startFunction - This callback is invoked when the specified function is
 
59
  /// about to be code generated.  This initializes the BufferBegin/End/Ptr
 
60
  /// fields.
 
61
  ///
 
62
  virtual void startFunction(MachineFunction &F) = 0;
 
63
 
 
64
  /// finishFunction - This callback is invoked when the specified function has
 
65
  /// finished code generation.  If a buffer overflow has occurred, this method
 
66
  /// returns true (the callee is required to try again), otherwise it returns
 
67
  /// false.
 
68
  ///
 
69
  virtual bool finishFunction(MachineFunction &F) = 0;
 
70
  
 
71
  /// allocIndirectGV - Allocates and fills storage for an indirect
 
72
  /// GlobalValue, and returns the address.
 
73
  virtual void *allocIndirectGV(const GlobalValue *GV,
 
74
                                const uint8_t *Buffer, size_t Size,
 
75
                                unsigned Alignment) = 0;
 
76
 
 
77
  /// emitByte - This callback is invoked when a byte needs to be written to the
 
78
  /// output stream.
 
79
  ///
 
80
  void emitByte(uint8_t B) {
 
81
    if (CurBufferPtr != BufferEnd)
 
82
      *CurBufferPtr++ = B;
 
83
  }
 
84
 
 
85
  /// emitWordLE - This callback is invoked when a 32-bit word needs to be
 
86
  /// written to the output stream in little-endian format.
 
87
  ///
 
88
  void emitWordLE(uint32_t W) {
 
89
    if (4 <= BufferEnd-CurBufferPtr) {
 
90
      *CurBufferPtr++ = (uint8_t)(W >>  0);
 
91
      *CurBufferPtr++ = (uint8_t)(W >>  8);
 
92
      *CurBufferPtr++ = (uint8_t)(W >> 16);
 
93
      *CurBufferPtr++ = (uint8_t)(W >> 24);
 
94
    } else {
 
95
      CurBufferPtr = BufferEnd;
 
96
    }
 
97
  }
 
98
  
 
99
  /// emitWordBE - This callback is invoked when a 32-bit word needs to be
 
100
  /// written to the output stream in big-endian format.
 
101
  ///
 
102
  void emitWordBE(uint32_t W) {
 
103
    if (4 <= BufferEnd-CurBufferPtr) {
 
104
      *CurBufferPtr++ = (uint8_t)(W >> 24);
 
105
      *CurBufferPtr++ = (uint8_t)(W >> 16);
 
106
      *CurBufferPtr++ = (uint8_t)(W >>  8);
 
107
      *CurBufferPtr++ = (uint8_t)(W >>  0);
 
108
    } else {
 
109
      CurBufferPtr = BufferEnd;
 
110
    }
 
111
  }
 
112
 
 
113
  /// emitDWordLE - This callback is invoked when a 64-bit word needs to be
 
114
  /// written to the output stream in little-endian format.
 
115
  ///
 
116
  void emitDWordLE(uint64_t W) {
 
117
    if (8 <= BufferEnd-CurBufferPtr) {
 
118
      *CurBufferPtr++ = (uint8_t)(W >>  0);
 
119
      *CurBufferPtr++ = (uint8_t)(W >>  8);
 
120
      *CurBufferPtr++ = (uint8_t)(W >> 16);
 
121
      *CurBufferPtr++ = (uint8_t)(W >> 24);
 
122
      *CurBufferPtr++ = (uint8_t)(W >> 32);
 
123
      *CurBufferPtr++ = (uint8_t)(W >> 40);
 
124
      *CurBufferPtr++ = (uint8_t)(W >> 48);
 
125
      *CurBufferPtr++ = (uint8_t)(W >> 56);
 
126
    } else {
 
127
      CurBufferPtr = BufferEnd;
 
128
    }
 
129
  }
 
130
  
 
131
  /// emitDWordBE - This callback is invoked when a 64-bit word needs to be
 
132
  /// written to the output stream in big-endian format.
 
133
  ///
 
134
  void emitDWordBE(uint64_t W) {
 
135
    if (8 <= BufferEnd-CurBufferPtr) {
 
136
      *CurBufferPtr++ = (uint8_t)(W >> 56);
 
137
      *CurBufferPtr++ = (uint8_t)(W >> 48);
 
138
      *CurBufferPtr++ = (uint8_t)(W >> 40);
 
139
      *CurBufferPtr++ = (uint8_t)(W >> 32);
 
140
      *CurBufferPtr++ = (uint8_t)(W >> 24);
 
141
      *CurBufferPtr++ = (uint8_t)(W >> 16);
 
142
      *CurBufferPtr++ = (uint8_t)(W >>  8);
 
143
      *CurBufferPtr++ = (uint8_t)(W >>  0);
 
144
    } else {
 
145
      CurBufferPtr = BufferEnd;
 
146
    }
 
147
  }
 
148
 
 
149
  /// emitAlignment - Move the CurBufferPtr pointer up to the specified
 
150
  /// alignment (saturated to BufferEnd of course).
 
151
  void emitAlignment(unsigned Alignment) {
 
152
    if (Alignment == 0) Alignment = 1;
 
153
    uint8_t *NewPtr = (uint8_t*)RoundUpToAlignment((uintptr_t)CurBufferPtr,
 
154
                                                   Alignment);
 
155
    CurBufferPtr = std::min(NewPtr, BufferEnd);
 
156
  }
 
157
 
 
158
  /// emitAlignmentWithFill - Similar to emitAlignment, except that the
 
159
  /// extra bytes are filled with the provided byte.
 
160
  void emitAlignmentWithFill(unsigned Alignment, uint8_t Fill) {
 
161
    if (Alignment == 0) Alignment = 1;
 
162
    uint8_t *NewPtr = (uint8_t*)RoundUpToAlignment((uintptr_t)CurBufferPtr,
 
163
                                                   Alignment);
 
164
    // Fail if we don't have room.
 
165
    if (NewPtr > BufferEnd) {
 
166
      CurBufferPtr = BufferEnd;
 
167
      return;
 
168
    }
 
169
    while (CurBufferPtr < NewPtr) {
 
170
      *CurBufferPtr++ = Fill;
 
171
    }
 
172
  }
 
173
 
 
174
  /// emitULEB128Bytes - This callback is invoked when a ULEB128 needs to be
 
175
  /// written to the output stream.
 
176
  void emitULEB128Bytes(uint64_t Value) {
 
177
    do {
 
178
      uint8_t Byte = Value & 0x7f;
 
179
      Value >>= 7;
 
180
      if (Value) Byte |= 0x80;
 
181
      emitByte(Byte);
 
182
    } while (Value);
 
183
  }
 
184
  
 
185
  /// emitSLEB128Bytes - This callback is invoked when a SLEB128 needs to be
 
186
  /// written to the output stream.
 
187
  void emitSLEB128Bytes(int64_t Value) {
 
188
    int32_t Sign = Value >> (8 * sizeof(Value) - 1);
 
189
    bool IsMore;
 
190
  
 
191
    do {
 
192
      uint8_t Byte = Value & 0x7f;
 
193
      Value >>= 7;
 
194
      IsMore = Value != Sign || ((Byte ^ Sign) & 0x40) != 0;
 
195
      if (IsMore) Byte |= 0x80;
 
196
      emitByte(Byte);
 
197
    } while (IsMore);
 
198
  }
 
199
 
 
200
  /// emitString - This callback is invoked when a String needs to be
 
201
  /// written to the output stream.
 
202
  void emitString(const std::string &String) {
 
203
    for (unsigned i = 0, N = static_cast<unsigned>(String.size());
 
204
         i < N; ++i) {
 
205
      uint8_t C = String[i];
 
206
      emitByte(C);
 
207
    }
 
208
    emitByte(0);
 
209
  }
 
210
  
 
211
  /// emitInt32 - Emit a int32 directive.
 
212
  void emitInt32(uint32_t Value) {
 
213
    if (4 <= BufferEnd-CurBufferPtr) {
 
214
      *((uint32_t*)CurBufferPtr) = Value;
 
215
      CurBufferPtr += 4;
 
216
    } else {
 
217
      CurBufferPtr = BufferEnd;
 
218
    }
 
219
  }
 
220
 
 
221
  /// emitInt64 - Emit a int64 directive.
 
222
  void emitInt64(uint64_t Value) {
 
223
    if (8 <= BufferEnd-CurBufferPtr) {
 
224
      *((uint64_t*)CurBufferPtr) = Value;
 
225
      CurBufferPtr += 8;
 
226
    } else {
 
227
      CurBufferPtr = BufferEnd;
 
228
    }
 
229
  }
 
230
  
 
231
  /// emitInt32At - Emit the Int32 Value in Addr.
 
232
  void emitInt32At(uintptr_t *Addr, uintptr_t Value) {
 
233
    if (Addr >= (uintptr_t*)BufferBegin && Addr < (uintptr_t*)BufferEnd)
 
234
      (*(uint32_t*)Addr) = (uint32_t)Value;
 
235
  }
 
236
  
 
237
  /// emitInt64At - Emit the Int64 Value in Addr.
 
238
  void emitInt64At(uintptr_t *Addr, uintptr_t Value) {
 
239
    if (Addr >= (uintptr_t*)BufferBegin && Addr < (uintptr_t*)BufferEnd)
 
240
      (*(uint64_t*)Addr) = (uint64_t)Value;
 
241
  }
 
242
  
 
243
  
 
244
  /// emitLabel - Emits a label
 
245
  virtual void emitLabel(uint64_t LabelID) = 0;
 
246
 
 
247
  /// allocateSpace - Allocate a block of space in the current output buffer,
 
248
  /// returning null (and setting conditions to indicate buffer overflow) on
 
249
  /// failure.  Alignment is the alignment in bytes of the buffer desired.
 
250
  virtual void *allocateSpace(uintptr_t Size, unsigned Alignment) {
 
251
    emitAlignment(Alignment);
 
252
    void *Result;
 
253
    
 
254
    // Check for buffer overflow.
 
255
    if (Size >= (uintptr_t)(BufferEnd-CurBufferPtr)) {
 
256
      CurBufferPtr = BufferEnd;
 
257
      Result = 0;
 
258
    } else {
 
259
      // Allocate the space.
 
260
      Result = CurBufferPtr;
 
261
      CurBufferPtr += Size;
 
262
    }
 
263
    
 
264
    return Result;
 
265
  }
 
266
 
 
267
  /// allocateGlobal - Allocate memory for a global.  Unlike allocateSpace,
 
268
  /// this method does not allocate memory in the current output buffer,
 
269
  /// because a global may live longer than the current function.
 
270
  virtual void *allocateGlobal(uintptr_t Size, unsigned Alignment) = 0;
 
271
 
 
272
  /// StartMachineBasicBlock - This should be called by the target when a new
 
273
  /// basic block is about to be emitted.  This way the MCE knows where the
 
274
  /// start of the block is, and can implement getMachineBasicBlockAddress.
 
275
  virtual void StartMachineBasicBlock(MachineBasicBlock *MBB) = 0;
 
276
  
 
277
  /// getCurrentPCValue - This returns the address that the next emitted byte
 
278
  /// will be output to.
 
279
  ///
 
280
  virtual uintptr_t getCurrentPCValue() const {
 
281
    return (uintptr_t)CurBufferPtr;
 
282
  }
 
283
 
 
284
  /// getCurrentPCOffset - Return the offset from the start of the emitted
 
285
  /// buffer that we are currently writing to.
 
286
  uintptr_t getCurrentPCOffset() const {
 
287
    return CurBufferPtr-BufferBegin;
 
288
  }
 
289
 
 
290
  /// earlyResolveAddresses - True if the code emitter can use symbol addresses 
 
291
  /// during code emission time. The JIT is capable of doing this because it
 
292
  /// creates jump tables or constant pools in memory on the fly while the
 
293
  /// object code emitters rely on a linker to have real addresses and should
 
294
  /// use relocations instead.
 
295
  bool earlyResolveAddresses() const { return true; }
 
296
 
 
297
  /// addRelocation - Whenever a relocatable address is needed, it should be
 
298
  /// noted with this interface.
 
299
  virtual void addRelocation(const MachineRelocation &MR) = 0;
 
300
  
 
301
  /// FIXME: These should all be handled with relocations!
 
302
  
 
303
  /// getConstantPoolEntryAddress - Return the address of the 'Index' entry in
 
304
  /// the constant pool that was last emitted with the emitConstantPool method.
 
305
  ///
 
306
  virtual uintptr_t getConstantPoolEntryAddress(unsigned Index) const = 0;
 
307
 
 
308
  /// getJumpTableEntryAddress - Return the address of the jump table with index
 
309
  /// 'Index' in the function that last called initJumpTableInfo.
 
310
  ///
 
311
  virtual uintptr_t getJumpTableEntryAddress(unsigned Index) const = 0;
 
312
  
 
313
  /// getMachineBasicBlockAddress - Return the address of the specified
 
314
  /// MachineBasicBlock, only usable after the label for the MBB has been
 
315
  /// emitted.
 
316
  ///
 
317
  virtual uintptr_t getMachineBasicBlockAddress(MachineBasicBlock *MBB) const= 0;
 
318
 
 
319
  /// getLabelAddress - Return the address of the specified LabelID, only usable
 
320
  /// after the LabelID has been emitted.
 
321
  ///
 
322
  virtual uintptr_t getLabelAddress(uint64_t LabelID) const = 0;
 
323
  
 
324
  /// Specifies the MachineModuleInfo object. This is used for exception handling
 
325
  /// purposes.
 
326
  virtual void setModuleInfo(MachineModuleInfo* Info) = 0;
 
327
};
 
328
 
 
329
} // End llvm namespace
 
330
 
 
331
#endif