← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/lib/ExecutionEngine/JIT/JIT.cpp

  • 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/lib/ExecutionEngine/JIT/JIT.cpp
 
1
//===-- JIT.cpp - LLVM Just in Time Compiler ------------------------------===//
 
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 tool implements a just-in-time compiler for LLVM, allowing direct
 
11
// execution of LLVM bitcode in an efficient manner.
 
12
//
 
13
//===----------------------------------------------------------------------===//
 
14
 
 
15
#include "JIT.h"
 
16
#include "llvm/Constants.h"
 
17
#include "llvm/DerivedTypes.h"
 
18
#include "llvm/Function.h"
 
19
#include "llvm/GlobalVariable.h"
 
20
#include "llvm/Instructions.h"
 
21
#include "llvm/ADT/SmallPtrSet.h"
 
22
#include "llvm/CodeGen/JITCodeEmitter.h"
 
23
#include "llvm/CodeGen/MachineCodeInfo.h"
 
24
#include "llvm/ExecutionEngine/GenericValue.h"
 
25
#include "llvm/ExecutionEngine/JITEventListener.h"
 
26
#include "llvm/Target/TargetData.h"
 
27
#include "llvm/Target/TargetMachine.h"
 
28
#include "llvm/Target/TargetJITInfo.h"
 
29
#include "llvm/Support/Dwarf.h"
 
30
#include "llvm/Support/ErrorHandling.h"
 
31
#include "llvm/Support/ManagedStatic.h"
 
32
#include "llvm/Support/MutexGuard.h"
 
33
#include "llvm/System/DynamicLibrary.h"
 
34
#include "llvm/Config/config.h"
 
35
 
 
36
using namespace llvm;
 
37
 
 
38
#ifdef __APPLE__ 
 
39
// Apple gcc defaults to -fuse-cxa-atexit (i.e. calls __cxa_atexit instead
 
40
// of atexit). It passes the address of linker generated symbol __dso_handle
 
41
// to the function.
 
42
// This configuration change happened at version 5330.
 
43
# include <AvailabilityMacros.h>
 
44
# if defined(MAC_OS_X_VERSION_10_4) && \
 
45
     ((MAC_OS_X_VERSION_MIN_REQUIRED > MAC_OS_X_VERSION_10_4) || \
 
46
      (MAC_OS_X_VERSION_MIN_REQUIRED == MAC_OS_X_VERSION_10_4 && \
 
47
       __APPLE_CC__ >= 5330))
 
48
#  ifndef HAVE___DSO_HANDLE
 
49
#   define HAVE___DSO_HANDLE 1
 
50
#  endif
 
51
# endif
 
52
#endif
 
53
 
 
54
#if HAVE___DSO_HANDLE
 
55
extern void *__dso_handle __attribute__ ((__visibility__ ("hidden")));
 
56
#endif
 
57
 
 
58
namespace {
 
59
 
 
60
static struct RegisterJIT {
 
61
  RegisterJIT() { JIT::Register(); }
 
62
} JITRegistrator;
 
63
 
 
64
}
 
65
 
 
66
extern "C" void LLVMLinkInJIT() {
 
67
}
 
68
 
 
69
 
 
70
#if defined(__GNUC__) && !defined(__ARM__EABI__)
 
71
 
 
72
// libgcc defines the __register_frame function to dynamically register new
 
73
// dwarf frames for exception handling. This functionality is not portable
 
74
// across compilers and is only provided by GCC. We use the __register_frame
 
75
// function here so that code generated by the JIT cooperates with the unwinding
 
76
// runtime of libgcc. When JITting with exception handling enable, LLVM
 
77
// generates dwarf frames and registers it to libgcc with __register_frame.
 
78
//
 
79
// The __register_frame function works with Linux.
 
80
//
 
81
// Unfortunately, this functionality seems to be in libgcc after the unwinding
 
82
// library of libgcc for darwin was written. The code for darwin overwrites the
 
83
// value updated by __register_frame with a value fetched with "keymgr".
 
84
// "keymgr" is an obsolete functionality, which should be rewritten some day.
 
85
// In the meantime, since "keymgr" is on all libgccs shipped with apple-gcc, we
 
86
// need a workaround in LLVM which uses the "keymgr" to dynamically modify the
 
87
// values of an opaque key, used by libgcc to find dwarf tables.
 
88
 
 
89
extern "C" void __register_frame(void*);
 
90
 
 
91
#if defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED <= 1050
 
92
# define USE_KEYMGR 1
 
93
#else
 
94
# define USE_KEYMGR 0
 
95
#endif
 
96
 
 
97
#if USE_KEYMGR
 
98
 
 
99
namespace {
 
100
 
 
101
// LibgccObject - This is the structure defined in libgcc. There is no #include
 
102
// provided for this structure, so we also define it here. libgcc calls it
 
103
// "struct object". The structure is undocumented in libgcc.
 
104
struct LibgccObject {
 
105
  void *unused1;
 
106
  void *unused2;
 
107
  void *unused3;
 
108
  
 
109
  /// frame - Pointer to the exception table.
 
110
  void *frame;
 
111
  
 
112
  /// encoding -  The encoding of the object?
 
113
  union {
 
114
    struct {
 
115
      unsigned long sorted : 1;
 
116
      unsigned long from_array : 1;
 
117
      unsigned long mixed_encoding : 1;
 
118
      unsigned long encoding : 8;
 
119
      unsigned long count : 21; 
 
120
    } b;
 
121
    size_t i;
 
122
  } encoding;
 
123
  
 
124
  /// fde_end - libgcc defines this field only if some macro is defined. We
 
125
  /// include this field even if it may not there, to make libgcc happy.
 
126
  char *fde_end;
 
127
  
 
128
  /// next - At least we know it's a chained list!
 
129
  struct LibgccObject *next;
 
130
};
 
131
 
 
132
// "kemgr" stuff. Apparently, all frame tables are stored there.
 
133
extern "C" void _keymgr_set_and_unlock_processwide_ptr(int, void *);
 
134
extern "C" void *_keymgr_get_and_lock_processwide_ptr(int);
 
135
#define KEYMGR_GCC3_DW2_OBJ_LIST        302     /* Dwarf2 object list  */
 
136
 
 
137
/// LibgccObjectInfo - libgcc defines this struct as km_object_info. It
 
138
/// probably contains all dwarf tables that are loaded.
 
139
struct LibgccObjectInfo {
 
140
 
 
141
  /// seenObjects - LibgccObjects already parsed by the unwinding runtime.
 
142
  ///
 
143
  struct LibgccObject* seenObjects;
 
144
 
 
145
  /// unseenObjects - LibgccObjects not parsed yet by the unwinding runtime.
 
146
  ///
 
147
  struct LibgccObject* unseenObjects;
 
148
  
 
149
  unsigned unused[2];
 
150
};
 
151
 
 
152
/// darwin_register_frame - Since __register_frame does not work with darwin's
 
153
/// libgcc,we provide our own function, which "tricks" libgcc by modifying the
 
154
/// "Dwarf2 object list" key.
 
155
void DarwinRegisterFrame(void* FrameBegin) {
 
156
  // Get the key.
 
157
  LibgccObjectInfo* LOI = (struct LibgccObjectInfo*)
 
158
    _keymgr_get_and_lock_processwide_ptr(KEYMGR_GCC3_DW2_OBJ_LIST);
 
159
  assert(LOI && "This should be preallocated by the runtime");
 
160
  
 
161
  // Allocate a new LibgccObject to represent this frame. Deallocation of this
 
162
  // object may be impossible: since darwin code in libgcc was written after
 
163
  // the ability to dynamically register frames, things may crash if we
 
164
  // deallocate it.
 
165
  struct LibgccObject* ob = (struct LibgccObject*)
 
166
    malloc(sizeof(struct LibgccObject));
 
167
  
 
168
  // Do like libgcc for the values of the field.
 
169
  ob->unused1 = (void *)-1;
 
170
  ob->unused2 = 0;
 
171
  ob->unused3 = 0;
 
172
  ob->frame = FrameBegin;
 
173
  ob->encoding.i = 0; 
 
174
  ob->encoding.b.encoding = llvm::dwarf::DW_EH_PE_omit;
 
175
  
 
176
  // Put the info on both places, as libgcc uses the first or the second
 
177
  // field. Note that we rely on having two pointers here. If fde_end was a
 
178
  // char, things would get complicated.
 
179
  ob->fde_end = (char*)LOI->unseenObjects;
 
180
  ob->next = LOI->unseenObjects;
 
181
  
 
182
  // Update the key's unseenObjects list.
 
183
  LOI->unseenObjects = ob;
 
184
  
 
185
  // Finally update the "key". Apparently, libgcc requires it. 
 
186
  _keymgr_set_and_unlock_processwide_ptr(KEYMGR_GCC3_DW2_OBJ_LIST,
 
187
                                         LOI);
 
188
 
 
189
}
 
190
 
 
191
}
 
192
#endif // __APPLE__
 
193
#endif // __GNUC__
 
194
 
 
195
/// createJIT - This is the factory method for creating a JIT for the current
 
196
/// machine, it does not fall back to the interpreter.  This takes ownership
 
197
/// of the module.
 
198
ExecutionEngine *ExecutionEngine::createJIT(Module *M,
 
199
                                            std::string *ErrorStr,
 
200
                                            JITMemoryManager *JMM,
 
201
                                            CodeGenOpt::Level OptLevel,
 
202
                                            bool GVsWithCode,
 
203
                                            CodeModel::Model CMM) {
 
204
  // Use the defaults for extra parameters.  Users can use EngineBuilder to
 
205
  // set them.
 
206
  StringRef MArch = "";
 
207
  StringRef MCPU = "";
 
208
  SmallVector<std::string, 1> MAttrs;
 
209
  return JIT::createJIT(M, ErrorStr, JMM, OptLevel, GVsWithCode, CMM,
 
210
                        MArch, MCPU, MAttrs);
 
211
}
 
212
 
 
213
ExecutionEngine *JIT::createJIT(Module *M,
 
214
                                std::string *ErrorStr,
 
215
                                JITMemoryManager *JMM,
 
216
                                CodeGenOpt::Level OptLevel,
 
217
                                bool GVsWithCode,
 
218
                                CodeModel::Model CMM,
 
219
                                StringRef MArch,
 
220
                                StringRef MCPU,
 
221
                                const SmallVectorImpl<std::string>& MAttrs) {
 
222
  // Make sure we can resolve symbols in the program as well. The zero arg
 
223
  // to the function tells DynamicLibrary to load the program, not a library.
 
224
/* CLAMAV LOCAL: no dlopen */
 
225
//  if (sys::DynamicLibrary::LoadLibraryPermanently(0, ErrorStr))
 
226
//   return 0;
 
227
 
 
228
  // Pick a target either via -march or by guessing the native arch.
 
229
  TargetMachine *TM = JIT::selectTarget(M, MArch, MCPU, MAttrs, ErrorStr);
 
230
  if (!TM || (ErrorStr && ErrorStr->length() > 0)) return 0;
 
231
  TM->setCodeModel(CMM);
 
232
 
 
233
  // If the target supports JIT code generation, create a the JIT.
 
234
  if (TargetJITInfo *TJ = TM->getJITInfo()) {
 
235
    return new JIT(M, *TM, *TJ, JMM, OptLevel, GVsWithCode);
 
236
  } else {
 
237
    if (ErrorStr)
 
238
      *ErrorStr = "target does not support JIT code generation";
 
239
    return 0;
 
240
  }
 
241
}
 
242
 
 
243
namespace {
 
244
/// This class supports the global getPointerToNamedFunction(), which allows
 
245
/// bugpoint or gdb users to search for a function by name without any context.
 
246
class JitPool {
 
247
  SmallPtrSet<JIT*, 1> JITs;  // Optimize for process containing just 1 JIT.
 
248
  mutable sys::Mutex Lock;
 
249
public:
 
250
  void Add(JIT *jit) {
 
251
    MutexGuard guard(Lock);
 
252
    JITs.insert(jit);
 
253
  }
 
254
  void Remove(JIT *jit) {
 
255
    MutexGuard guard(Lock);
 
256
    JITs.erase(jit);
 
257
  }
 
258
  void *getPointerToNamedFunction(const char *Name) const {
 
259
    MutexGuard guard(Lock);
 
260
    assert(JITs.size() != 0 && "No Jit registered");
 
261
    //search function in every instance of JIT
 
262
    for (SmallPtrSet<JIT*, 1>::const_iterator Jit = JITs.begin(),
 
263
           end = JITs.end();
 
264
         Jit != end; ++Jit) {
 
265
      if (Function *F = (*Jit)->FindFunctionNamed(Name))
 
266
        return (*Jit)->getPointerToFunction(F);
 
267
    }
 
268
    // The function is not available : fallback on the first created (will
 
269
    // search in symbol of the current program/library)
 
270
    return (*JITs.begin())->getPointerToNamedFunction(Name);
 
271
  }
 
272
};
 
273
ManagedStatic<JitPool> AllJits;
 
274
}
 
275
extern "C" {
 
276
  // getPointerToNamedFunction - This function is used as a global wrapper to
 
277
  // JIT::getPointerToNamedFunction for the purpose of resolving symbols when
 
278
  // bugpoint is debugging the JIT. In that scenario, we are loading an .so and
 
279
  // need to resolve function(s) that are being mis-codegenerated, so we need to
 
280
  // resolve their addresses at runtime, and this is the way to do it.
 
281
  void *getPointerToNamedFunction(const char *Name) {
 
282
    return AllJits->getPointerToNamedFunction(Name);
 
283
  }
 
284
}
 
285
 
 
286
JIT::JIT(Module *M, TargetMachine &tm, TargetJITInfo &tji,
 
287
         JITMemoryManager *JMM, CodeGenOpt::Level OptLevel, bool GVsWithCode)
 
288
  : ExecutionEngine(M), TM(tm), TJI(tji), AllocateGVsWithCode(GVsWithCode),
 
289
    isAlreadyCodeGenerating(false) {
 
290
  setTargetData(TM.getTargetData());
 
291
 
 
292
  jitstate = new JITState(M);
 
293
 
 
294
  // Initialize JCE
 
295
  JCE = createEmitter(*this, JMM, TM);
 
296
 
 
297
  // Register in global list of all JITs.
 
298
  AllJits->Add(this);
 
299
 
 
300
  // Add target data
 
301
  MutexGuard locked(lock);
 
302
  FunctionPassManager &PM = jitstate->getPM(locked);
 
303
  PM.add(new TargetData(*TM.getTargetData()));
 
304
 
 
305
  // Turn the machine code intermediate representation into bytes in memory that
 
306
  // may be executed.
 
307
  if (TM.addPassesToEmitMachineCode(PM, *JCE, OptLevel)) {
 
308
    llvm_report_error("Target does not support machine code emission!");
 
309
  }
 
310
  
 
311
  // Register routine for informing unwinding runtime about new EH frames
 
312
#if defined(__GNUC__) && !defined(__ARM_EABI__)
 
313
#if USE_KEYMGR
 
314
  struct LibgccObjectInfo* LOI = (struct LibgccObjectInfo*)
 
315
    _keymgr_get_and_lock_processwide_ptr(KEYMGR_GCC3_DW2_OBJ_LIST);
 
316
  
 
317
  // The key is created on demand, and libgcc creates it the first time an
 
318
  // exception occurs. Since we need the key to register frames, we create
 
319
  // it now.
 
320
  if (!LOI)
 
321
    LOI = (LibgccObjectInfo*)calloc(sizeof(struct LibgccObjectInfo), 1); 
 
322
  _keymgr_set_and_unlock_processwide_ptr(KEYMGR_GCC3_DW2_OBJ_LIST, LOI);
 
323
  InstallExceptionTableRegister(DarwinRegisterFrame);
 
324
#else
 
325
  InstallExceptionTableRegister(__register_frame);
 
326
#endif // __APPLE__
 
327
#endif // __GNUC__
 
328
  
 
329
  // Initialize passes.
 
330
  PM.doInitialization();
 
331
}
 
332
 
 
333
JIT::~JIT() {
 
334
  AllJits->Remove(this);
 
335
  delete jitstate;
 
336
  delete JCE;
 
337
  delete &TM;
 
338
}
 
339
 
 
340
/// addModule - Add a new Module to the JIT.  If we previously removed the last
 
341
/// Module, we need re-initialize jitstate with a valid Module.
 
342
void JIT::addModule(Module *M) {
 
343
  MutexGuard locked(lock);
 
344
 
 
345
  if (Modules.empty()) {
 
346
    assert(!jitstate && "jitstate should be NULL if Modules vector is empty!");
 
347
 
 
348
    jitstate = new JITState(M);
 
349
 
 
350
    FunctionPassManager &PM = jitstate->getPM(locked);
 
351
    PM.add(new TargetData(*TM.getTargetData()));
 
352
 
 
353
    // Turn the machine code intermediate representation into bytes in memory
 
354
    // that may be executed.
 
355
    if (TM.addPassesToEmitMachineCode(PM, *JCE, CodeGenOpt::Default)) {
 
356
      llvm_report_error("Target does not support machine code emission!");
 
357
    }
 
358
    
 
359
    // Initialize passes.
 
360
    PM.doInitialization();
 
361
  }
 
362
  
 
363
  ExecutionEngine::addModule(M);
 
364
}
 
365
 
 
366
/// removeModule - If we are removing the last Module, invalidate the jitstate
 
367
/// since the PassManager it contains references a released Module.
 
368
bool JIT::removeModule(Module *M) {
 
369
  bool result = ExecutionEngine::removeModule(M);
 
370
  
 
371
  MutexGuard locked(lock);
 
372
  
 
373
  if (jitstate->getModule() == M) {
 
374
    delete jitstate;
 
375
    jitstate = 0;
 
376
  }
 
377
  
 
378
  if (!jitstate && !Modules.empty()) {
 
379
    jitstate = new JITState(Modules[0]);
 
380
 
 
381
    FunctionPassManager &PM = jitstate->getPM(locked);
 
382
    PM.add(new TargetData(*TM.getTargetData()));
 
383
    
 
384
    // Turn the machine code intermediate representation into bytes in memory
 
385
    // that may be executed.
 
386
    if (TM.addPassesToEmitMachineCode(PM, *JCE, CodeGenOpt::Default)) {
 
387
      llvm_report_error("Target does not support machine code emission!");
 
388
    }
 
389
    
 
390
    // Initialize passes.
 
391
    PM.doInitialization();
 
392
  }    
 
393
  return result;
 
394
}
 
395
 
 
396
/// run - Start execution with the specified function and arguments.
 
397
///
 
398
GenericValue JIT::runFunction(Function *F,
 
399
                              const std::vector<GenericValue> &ArgValues) {
 
400
  assert(F && "Function *F was null at entry to run()");
 
401
 
 
402
  void *FPtr = getPointerToFunction(F);
 
403
  assert(FPtr && "Pointer to fn's code was null after getPointerToFunction");
 
404
  const FunctionType *FTy = F->getFunctionType();
 
405
  const Type *RetTy = FTy->getReturnType();
 
406
 
 
407
  assert((FTy->getNumParams() == ArgValues.size() ||
 
408
          (FTy->isVarArg() && FTy->getNumParams() <= ArgValues.size())) &&
 
409
         "Wrong number of arguments passed into function!");
 
410
  assert(FTy->getNumParams() == ArgValues.size() &&
 
411
         "This doesn't support passing arguments through varargs (yet)!");
 
412
 
 
413
  // Handle some common cases first.  These cases correspond to common `main'
 
414
  // prototypes.
 
415
  if (RetTy->isIntegerTy(32) || RetTy->isVoidTy()) {
 
416
    switch (ArgValues.size()) {
 
417
    case 3:
 
418
      if (FTy->getParamType(0)->isIntegerTy(32) &&
 
419
          FTy->getParamType(1)->isPointerTy() &&
 
420
          FTy->getParamType(2)->isPointerTy()) {
 
421
        int (*PF)(int, char **, const char **) =
 
422
          (int(*)(int, char **, const char **))(intptr_t)FPtr;
 
423
 
 
424
        // Call the function.
 
425
        GenericValue rv;
 
426
        rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue(), 
 
427
                                 (char **)GVTOP(ArgValues[1]),
 
428
                                 (const char **)GVTOP(ArgValues[2])));
 
429
        return rv;
 
430
      }
 
431
      break;
 
432
    case 2:
 
433
      if (FTy->getParamType(0)->isIntegerTy(32) &&
 
434
          FTy->getParamType(1)->isPointerTy()) {
 
435
        int (*PF)(int, char **) = (int(*)(int, char **))(intptr_t)FPtr;
 
436
 
 
437
        // Call the function.
 
438
        GenericValue rv;
 
439
        rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue(), 
 
440
                                 (char **)GVTOP(ArgValues[1])));
 
441
        return rv;
 
442
      }
 
443
      break;
 
444
    case 1:
 
445
      if (FTy->getNumParams() == 1 &&
 
446
          FTy->getParamType(0)->isIntegerTy(32)) {
 
447
        GenericValue rv;
 
448
        int (*PF)(int) = (int(*)(int))(intptr_t)FPtr;
 
449
        rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue()));
 
450
        return rv;
 
451
      }
 
452
      break;
 
453
    }
 
454
  }
 
455
 
 
456
  // Handle cases where no arguments are passed first.
 
457
  if (ArgValues.empty()) {
 
458
    GenericValue rv;
 
459
    switch (RetTy->getTypeID()) {
 
460
    default: llvm_unreachable("Unknown return type for function call!");
 
461
    case Type::IntegerTyID: {
 
462
      unsigned BitWidth = cast<IntegerType>(RetTy)->getBitWidth();
 
463
      if (BitWidth == 1)
 
464
        rv.IntVal = APInt(BitWidth, ((bool(*)())(intptr_t)FPtr)());
 
465
      else if (BitWidth <= 8)
 
466
        rv.IntVal = APInt(BitWidth, ((char(*)())(intptr_t)FPtr)());
 
467
      else if (BitWidth <= 16)
 
468
        rv.IntVal = APInt(BitWidth, ((short(*)())(intptr_t)FPtr)());
 
469
      else if (BitWidth <= 32)
 
470
        rv.IntVal = APInt(BitWidth, ((int(*)())(intptr_t)FPtr)());
 
471
      else if (BitWidth <= 64)
 
472
        rv.IntVal = APInt(BitWidth, ((int64_t(*)())(intptr_t)FPtr)());
 
473
      else 
 
474
        llvm_unreachable("Integer types > 64 bits not supported");
 
475
      return rv;
 
476
    }
 
477
    case Type::VoidTyID:
 
478
      rv.IntVal = APInt(32, ((int(*)())(intptr_t)FPtr)());
 
479
      return rv;
 
480
    case Type::FloatTyID:
 
481
      rv.FloatVal = ((float(*)())(intptr_t)FPtr)();
 
482
      return rv;
 
483
    case Type::DoubleTyID:
 
484
      rv.DoubleVal = ((double(*)())(intptr_t)FPtr)();
 
485
      return rv;
 
486
    case Type::X86_FP80TyID:
 
487
    case Type::FP128TyID:
 
488
    case Type::PPC_FP128TyID:
 
489
      llvm_unreachable("long double not supported yet");
 
490
      return rv;
 
491
    case Type::PointerTyID:
 
492
      return PTOGV(((void*(*)())(intptr_t)FPtr)());
 
493
    }
 
494
  }
 
495
 
 
496
  // Okay, this is not one of our quick and easy cases.  Because we don't have a
 
497
  // full FFI, we have to codegen a nullary stub function that just calls the
 
498
  // function we are interested in, passing in constants for all of the
 
499
  // arguments.  Make this function and return.
 
500
 
 
501
  // First, create the function.
 
502
  FunctionType *STy=FunctionType::get(RetTy, false);
 
503
  Function *Stub = Function::Create(STy, Function::InternalLinkage, "",
 
504
                                    F->getParent());
 
505
 
 
506
  // Insert a basic block.
 
507
  BasicBlock *StubBB = BasicBlock::Create(F->getContext(), "", Stub);
 
508
 
 
509
  // Convert all of the GenericValue arguments over to constants.  Note that we
 
510
  // currently don't support varargs.
 
511
  SmallVector<Value*, 8> Args;
 
512
  for (unsigned i = 0, e = ArgValues.size(); i != e; ++i) {
 
513
    Constant *C = 0;
 
514
    const Type *ArgTy = FTy->getParamType(i);
 
515
    const GenericValue &AV = ArgValues[i];
 
516
    switch (ArgTy->getTypeID()) {
 
517
    default: llvm_unreachable("Unknown argument type for function call!");
 
518
    case Type::IntegerTyID:
 
519
        C = ConstantInt::get(F->getContext(), AV.IntVal);
 
520
        break;
 
521
    case Type::FloatTyID:
 
522
        C = ConstantFP::get(F->getContext(), APFloat(AV.FloatVal));
 
523
        break;
 
524
    case Type::DoubleTyID:
 
525
        C = ConstantFP::get(F->getContext(), APFloat(AV.DoubleVal));
 
526
        break;
 
527
    case Type::PPC_FP128TyID:
 
528
    case Type::X86_FP80TyID:
 
529
    case Type::FP128TyID:
 
530
        C = ConstantFP::get(F->getContext(), APFloat(AV.IntVal));
 
531
        break;
 
532
    case Type::PointerTyID:
 
533
      void *ArgPtr = GVTOP(AV);
 
534
      if (sizeof(void*) == 4)
 
535
        C = ConstantInt::get(Type::getInt32Ty(F->getContext()), 
 
536
                             (int)(intptr_t)ArgPtr);
 
537
      else
 
538
        C = ConstantInt::get(Type::getInt64Ty(F->getContext()),
 
539
                             (intptr_t)ArgPtr);
 
540
      // Cast the integer to pointer
 
541
      C = ConstantExpr::getIntToPtr(C, ArgTy);
 
542
      break;
 
543
    }
 
544
    Args.push_back(C);
 
545
  }
 
546
 
 
547
  CallInst *TheCall = CallInst::Create(F, Args.begin(), Args.end(),
 
548
                                       "", StubBB);
 
549
  TheCall->setCallingConv(F->getCallingConv());
 
550
  TheCall->setTailCall();
 
551
  if (!TheCall->getType()->isVoidTy())
 
552
    // Return result of the call.
 
553
    ReturnInst::Create(F->getContext(), TheCall, StubBB);
 
554
  else
 
555
    ReturnInst::Create(F->getContext(), StubBB);           // Just return void.
 
556
 
 
557
  // Finally, call our nullary stub function.
 
558
  GenericValue Result = runFunction(Stub, std::vector<GenericValue>());
 
559
  // Erase it, since no other function can have a reference to it.
 
560
  Stub->eraseFromParent();
 
561
  // And return the result.
 
562
  return Result;
 
563
}
 
564
 
 
565
void JIT::RegisterJITEventListener(JITEventListener *L) {
 
566
  if (L == NULL)
 
567
    return;
 
568
  MutexGuard locked(lock);
 
569
  EventListeners.push_back(L);
 
570
}
 
571
void JIT::UnregisterJITEventListener(JITEventListener *L) {
 
572
  if (L == NULL)
 
573
    return;
 
574
  MutexGuard locked(lock);
 
575
  std::vector<JITEventListener*>::reverse_iterator I=
 
576
      std::find(EventListeners.rbegin(), EventListeners.rend(), L);
 
577
  if (I != EventListeners.rend()) {
 
578
    std::swap(*I, EventListeners.back());
 
579
    EventListeners.pop_back();
 
580
  }
 
581
}
 
582
void JIT::NotifyFunctionEmitted(
 
583
    const Function &F,
 
584
    void *Code, size_t Size,
 
585
    const JITEvent_EmittedFunctionDetails &Details) {
 
586
  MutexGuard locked(lock);
 
587
  for (unsigned I = 0, S = EventListeners.size(); I < S; ++I) {
 
588
    EventListeners[I]->NotifyFunctionEmitted(F, Code, Size, Details);
 
589
  }
 
590
}
 
591
 
 
592
void JIT::NotifyFreeingMachineCode(void *OldPtr) {
 
593
  MutexGuard locked(lock);
 
594
  for (unsigned I = 0, S = EventListeners.size(); I < S; ++I) {
 
595
    EventListeners[I]->NotifyFreeingMachineCode(OldPtr);
 
596
  }
 
597
}
 
598
 
 
599
/// runJITOnFunction - Run the FunctionPassManager full of
 
600
/// just-in-time compilation passes on F, hopefully filling in
 
601
/// GlobalAddress[F] with the address of F's machine code.
 
602
///
 
603
void JIT::runJITOnFunction(Function *F, MachineCodeInfo *MCI) {
 
604
  MutexGuard locked(lock);
 
605
 
 
606
  class MCIListener : public JITEventListener {
 
607
    MachineCodeInfo *const MCI;
 
608
   public:
 
609
    MCIListener(MachineCodeInfo *mci) : MCI(mci) {}
 
610
    virtual void NotifyFunctionEmitted(const Function &,
 
611
                                       void *Code, size_t Size,
 
612
                                       const EmittedFunctionDetails &) {
 
613
      MCI->setAddress(Code);
 
614
      MCI->setSize(Size);
 
615
    }
 
616
  };
 
617
  MCIListener MCIL(MCI);
 
618
  if (MCI)
 
619
    RegisterJITEventListener(&MCIL);
 
620
 
 
621
  runJITOnFunctionUnlocked(F, locked);
 
622
 
 
623
  if (MCI)
 
624
    UnregisterJITEventListener(&MCIL);
 
625
}
 
626
 
 
627
void JIT::runJITOnFunctionUnlocked(Function *F, const MutexGuard &locked) {
 
628
  assert(!isAlreadyCodeGenerating && "Error: Recursive compilation detected!");
 
629
 
 
630
  // JIT the function
 
631
  isAlreadyCodeGenerating = true;
 
632
  jitstate->getPM(locked).run(*F);
 
633
  isAlreadyCodeGenerating = false;
 
634
 
 
635
  // If the function referred to another function that had not yet been
 
636
  // read from bitcode, and we are jitting non-lazily, emit it now.
 
637
  while (!jitstate->getPendingFunctions(locked).empty()) {
 
638
    Function *PF = jitstate->getPendingFunctions(locked).back();
 
639
    jitstate->getPendingFunctions(locked).pop_back();
 
640
 
 
641
    assert(!PF->hasAvailableExternallyLinkage() &&
 
642
           "Externally-defined function should not be in pending list.");
 
643
 
 
644
    // JIT the function
 
645
    isAlreadyCodeGenerating = true;
 
646
    jitstate->getPM(locked).run(*PF);
 
647
    isAlreadyCodeGenerating = false;
 
648
    
 
649
    // Now that the function has been jitted, ask the JITEmitter to rewrite
 
650
    // the stub with real address of the function.
 
651
    updateFunctionStub(PF);
 
652
  }
 
653
}
 
654
 
 
655
/// getPointerToFunction - This method is used to get the address of the
 
656
/// specified function, compiling it if neccesary.
 
657
///
 
658
void *JIT::getPointerToFunction(Function *F) {
 
659
 
 
660
  if (void *Addr = getPointerToGlobalIfAvailable(F))
 
661
    return Addr;   // Check if function already code gen'd
 
662
 
 
663
  MutexGuard locked(lock);
 
664
 
 
665
  // Now that this thread owns the lock, make sure we read in the function if it
 
666
  // exists in this Module.
 
667
  std::string ErrorMsg;
 
668
  if (F->Materialize(&ErrorMsg)) {
 
669
    llvm_report_error("Error reading function '" + F->getName()+
 
670
                      "' from bitcode file: " + ErrorMsg);
 
671
  }
 
672
 
 
673
  // ... and check if another thread has already code gen'd the function.
 
674
  if (void *Addr = getPointerToGlobalIfAvailable(F))
 
675
    return Addr;
 
676
 
 
677
  if (F->isDeclaration() || F->hasAvailableExternallyLinkage()) {
 
678
    bool AbortOnFailure = !F->hasExternalWeakLinkage();
 
679
    void *Addr = getPointerToNamedFunction(F->getName(), AbortOnFailure);
 
680
    addGlobalMapping(F, Addr);
 
681
    return Addr;
 
682
  }
 
683
 
 
684
  runJITOnFunctionUnlocked(F, locked);
 
685
 
 
686
  void *Addr = getPointerToGlobalIfAvailable(F);
 
687
  assert(Addr && "Code generation didn't add function to GlobalAddress table!");
 
688
  return Addr;
 
689
}
 
690
 
 
691
/// getOrEmitGlobalVariable - Return the address of the specified global
 
692
/// variable, possibly emitting it to memory if needed.  This is used by the
 
693
/// Emitter.
 
694
void *JIT::getOrEmitGlobalVariable(const GlobalVariable *GV) {
 
695
  MutexGuard locked(lock);
 
696
 
 
697
  void *Ptr = getPointerToGlobalIfAvailable(GV);
 
698
  if (Ptr) return Ptr;
 
699
 
 
700
  // If the global is external, just remember the address.
 
701
  if (GV->isDeclaration() || GV->hasAvailableExternallyLinkage()) {
 
702
#if HAVE___DSO_HANDLE
 
703
    if (GV->getName() == "__dso_handle")
 
704
      return (void*)&__dso_handle;
 
705
#endif
 
706
    Ptr = sys::DynamicLibrary::SearchForAddressOfSymbol(GV->getName());
 
707
    if (Ptr == 0) {
 
708
      llvm_report_error("Could not resolve external global address: "
 
709
                        +GV->getName());
 
710
    }
 
711
    addGlobalMapping(GV, Ptr);
 
712
  } else {
 
713
    // If the global hasn't been emitted to memory yet, allocate space and
 
714
    // emit it into memory.
 
715
    Ptr = getMemoryForGV(GV);
 
716
    addGlobalMapping(GV, Ptr);
 
717
    EmitGlobalVariable(GV);  // Initialize the variable.
 
718
  }
 
719
  return Ptr;
 
720
}
 
721
 
 
722
/// recompileAndRelinkFunction - This method is used to force a function
 
723
/// which has already been compiled, to be compiled again, possibly
 
724
/// after it has been modified. Then the entry to the old copy is overwritten
 
725
/// with a branch to the new copy. If there was no old copy, this acts
 
726
/// just like JIT::getPointerToFunction().
 
727
///
 
728
void *JIT::recompileAndRelinkFunction(Function *F) {
 
729
  void *OldAddr = getPointerToGlobalIfAvailable(F);
 
730
 
 
731
  // If it's not already compiled there is no reason to patch it up.
 
732
  if (OldAddr == 0) { return getPointerToFunction(F); }
 
733
 
 
734
  // Delete the old function mapping.
 
735
  addGlobalMapping(F, 0);
 
736
 
 
737
  // Recodegen the function
 
738
  runJITOnFunction(F);
 
739
 
 
740
  // Update state, forward the old function to the new function.
 
741
  void *Addr = getPointerToGlobalIfAvailable(F);
 
742
  assert(Addr && "Code generation didn't add function to GlobalAddress table!");
 
743
  TJI.replaceMachineCodeForFunction(OldAddr, Addr);
 
744
  return Addr;
 
745
}
 
746
 
 
747
/// getMemoryForGV - This method abstracts memory allocation of global
 
748
/// variable so that the JIT can allocate thread local variables depending
 
749
/// on the target.
 
750
///
 
751
char* JIT::getMemoryForGV(const GlobalVariable* GV) {
 
752
  char *Ptr;
 
753
 
 
754
  // GlobalVariable's which are not "constant" will cause trouble in a server
 
755
  // situation. It's returned in the same block of memory as code which may
 
756
  // not be writable.
 
757
  if (isGVCompilationDisabled() && !GV->isConstant()) {
 
758
    llvm_report_error("Compilation of non-internal GlobalValue is disabled!");
 
759
  }
 
760
 
 
761
  // Some applications require globals and code to live together, so they may
 
762
  // be allocated into the same buffer, but in general globals are allocated
 
763
  // through the memory manager which puts them near the code but not in the
 
764
  // same buffer.
 
765
  const Type *GlobalType = GV->getType()->getElementType();
 
766
  size_t S = getTargetData()->getTypeAllocSize(GlobalType);
 
767
  size_t A = getTargetData()->getPreferredAlignment(GV);
 
768
  if (GV->isThreadLocal()) {
 
769
    MutexGuard locked(lock);
 
770
    Ptr = TJI.allocateThreadLocalMemory(S);
 
771
  } else if (TJI.allocateSeparateGVMemory()) {
 
772
    if (A <= 8) {
 
773
      Ptr = (char*)malloc(S);
 
774
    } else {
 
775
      // Allocate S+A bytes of memory, then use an aligned pointer within that
 
776
      // space.
 
777
      Ptr = (char*)malloc(S+A);
 
778
      unsigned MisAligned = ((intptr_t)Ptr & (A-1));
 
779
      Ptr = Ptr + (MisAligned ? (A-MisAligned) : 0);
 
780
    }
 
781
  } else if (AllocateGVsWithCode) {
 
782
    Ptr = (char*)JCE->allocateSpace(S, A);
 
783
  } else {
 
784
    Ptr = (char*)JCE->allocateGlobal(S, A);
 
785
  }
 
786
  return Ptr;
 
787
}
 
788
 
 
789
void JIT::addPendingFunction(Function *F) {
 
790
  MutexGuard locked(lock);
 
791
  jitstate->getPendingFunctions(locked).push_back(F);
 
792
}
 
793
 
 
794
 
 
795
JITEventListener::~JITEventListener() {}