← Back to branch summary

~ubuntu-branches/debian/sid/clamav/sid

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Andreas Cadhalpun, Andreas Cadhalpun, Sebastian Andrzej Siewior, Frans Spiesschaert
  • Date: 2014-10-15 06:50:20 UTC
  • mfrom: (1.3.13) (42.1.4 experimental)
  • Revision ID: package-import@ubuntu.com-20141015065020-0cpy1hdueggaw35s
Tags: 0.98.5~rc1+dfsg-1
http://bugs.debian.org/763634
[ Andreas Cadhalpun ]
* Import new upstream release candidate.
* Drop patches included upstream and update the others.
* Add 4 new symbols to libclamav6.symbols.
* Fix debian/copyright.
* Update lintian overrides.
* Update Standards-Version to 3.9.6 (no changes needed).
* Add Breaks and Replaces for old clamd package to clamdscan.
* Remove unnecessary shlibs:Depends from clamav-dbg.
* Add patches to support LLVM 3.5.

[ Sebastian Andrzej Siewior ]
* Add embedded copy of libmspack to be used as fallback, when libmspack-dev
  is not available.

[ Frans Spiesschaert ]
* Updated Dutch Debconf template translation (Closes: #763634)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/lib/ExecutionEngine/ExecutionEngineBindings.cpp
1
 
//===-- ExecutionEngineBindings.cpp - C bindings for EEs ------------------===//
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 C bindings for the ExecutionEngine library.
11
 
//
12
 
//===----------------------------------------------------------------------===//
13
 
 
14
 
#define DEBUG_TYPE "jit"
15
 
#include "llvm-c/ExecutionEngine.h"
16
 
#include "llvm/ExecutionEngine/GenericValue.h"
17
 
#include "llvm/ExecutionEngine/ExecutionEngine.h"
18
 
#include "llvm/Support/ErrorHandling.h"
19
 
#include <cstring>
20
 
 
21
 
using namespace llvm;
22
 
 
23
 
/*===-- Operations on generic values --------------------------------------===*/
24
 
 
25
 
LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty,
26
 
                                                unsigned long long N,
27
 
                                                LLVMBool IsSigned) {
28
 
  GenericValue *GenVal = new GenericValue();
29
 
  GenVal->IntVal = APInt(unwrap<IntegerType>(Ty)->getBitWidth(), N, IsSigned);
30
 
  return wrap(GenVal);
31
 
}
32
 
 
33
 
LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P) {
34
 
  GenericValue *GenVal = new GenericValue();
35
 
  GenVal->PointerVal = P;
36
 
  return wrap(GenVal);
37
 
}
38
 
 
39
 
LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef TyRef, double N) {
40
 
  GenericValue *GenVal = new GenericValue();
41
 
  switch (unwrap(TyRef)->getTypeID()) {
42
 
  case Type::FloatTyID:
43
 
    GenVal->FloatVal = N;
44
 
    break;
45
 
  case Type::DoubleTyID:
46
 
    GenVal->DoubleVal = N;
47
 
    break;
48
 
  default:
49
 
    llvm_unreachable("LLVMGenericValueToFloat supports only float and double.");
50
 
  }
51
 
  return wrap(GenVal);
52
 
}
53
 
 
54
 
unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef) {
55
 
  return unwrap(GenValRef)->IntVal.getBitWidth();
56
 
}
57
 
 
58
 
unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenValRef,
59
 
                                         LLVMBool IsSigned) {
60
 
  GenericValue *GenVal = unwrap(GenValRef);
61
 
  if (IsSigned)
62
 
    return GenVal->IntVal.getSExtValue();
63
 
  else
64
 
    return GenVal->IntVal.getZExtValue();
65
 
}
66
 
 
67
 
void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal) {
68
 
  return unwrap(GenVal)->PointerVal;
69
 
}
70
 
 
71
 
double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal) {
72
 
  switch (unwrap(TyRef)->getTypeID()) {
73
 
  case Type::FloatTyID:
74
 
    return unwrap(GenVal)->FloatVal;
75
 
  case Type::DoubleTyID:
76
 
    return unwrap(GenVal)->DoubleVal;
77
 
  default:
78
 
    llvm_unreachable("LLVMGenericValueToFloat supports only float and double.");
79
 
    break;
80
 
  }
81
 
  return 0; // Not reached
82
 
}
83
 
 
84
 
void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal) {
85
 
  delete unwrap(GenVal);
86
 
}
87
 
 
88
 
/*===-- Operations on execution engines -----------------------------------===*/
89
 
 
90
 
LLVMBool LLVMCreateExecutionEngineForModule(LLVMExecutionEngineRef *OutEE,
91
 
                                            LLVMModuleRef M,
92
 
                                            char **OutError) {
93
 
  std::string Error;
94
 
  EngineBuilder builder(unwrap(M));
95
 
  builder.setEngineKind(EngineKind::Either)
96
 
         .setErrorStr(&Error);
97
 
  if (ExecutionEngine *EE = builder.create()){
98
 
    *OutEE = wrap(EE);
99
 
    return 0;
100
 
  }
101
 
  *OutError = strdup(Error.c_str());
102
 
  return 1;
103
 
}
104
 
 
105
 
LLVMBool LLVMCreateInterpreterForModule(LLVMExecutionEngineRef *OutInterp,
106
 
                                        LLVMModuleRef M,
107
 
                                        char **OutError) {
108
 
  std::string Error;
109
 
  EngineBuilder builder(unwrap(M));
110
 
  builder.setEngineKind(EngineKind::Interpreter)
111
 
         .setErrorStr(&Error);
112
 
  if (ExecutionEngine *Interp = builder.create()) {
113
 
    *OutInterp = wrap(Interp);
114
 
    return 0;
115
 
  }
116
 
  *OutError = strdup(Error.c_str());
117
 
  return 1;
118
 
}
119
 
 
120
 
LLVMBool LLVMCreateJITCompilerForModule(LLVMExecutionEngineRef *OutJIT,
121
 
                                        LLVMModuleRef M,
122
 
                                        unsigned OptLevel,
123
 
                                        char **OutError) {
124
 
  std::string Error;
125
 
  EngineBuilder builder(unwrap(M));
126
 
  builder.setEngineKind(EngineKind::JIT)
127
 
         .setErrorStr(&Error)
128
 
         .setOptLevel((CodeGenOpt::Level)OptLevel);
129
 
  if (ExecutionEngine *JIT = builder.create()) {
130
 
    *OutJIT = wrap(JIT);
131
 
    return 0;
132
 
  }
133
 
  *OutError = strdup(Error.c_str());
134
 
  return 1;
135
 
}
136
 
 
137
 
LLVMBool LLVMCreateExecutionEngine(LLVMExecutionEngineRef *OutEE,
138
 
                                   LLVMModuleProviderRef MP,
139
 
                                   char **OutError) {
140
 
  /* The module provider is now actually a module. */
141
 
  return LLVMCreateExecutionEngineForModule(OutEE,
142
 
                                            reinterpret_cast<LLVMModuleRef>(MP),
143
 
                                            OutError);
144
 
}
145
 
 
146
 
LLVMBool LLVMCreateInterpreter(LLVMExecutionEngineRef *OutInterp,
147
 
                               LLVMModuleProviderRef MP,
148
 
                               char **OutError) {
149
 
  /* The module provider is now actually a module. */
150
 
  return LLVMCreateInterpreterForModule(OutInterp,
151
 
                                        reinterpret_cast<LLVMModuleRef>(MP),
152
 
                                        OutError);
153
 
}
154
 
 
155
 
LLVMBool LLVMCreateJITCompiler(LLVMExecutionEngineRef *OutJIT,
156
 
                               LLVMModuleProviderRef MP,
157
 
                               unsigned OptLevel,
158
 
                               char **OutError) {
159
 
  /* The module provider is now actually a module. */
160
 
  return LLVMCreateJITCompilerForModule(OutJIT,
161
 
                                        reinterpret_cast<LLVMModuleRef>(MP),
162
 
                                        OptLevel, OutError);
163
 
}
164
 
 
165
 
 
166
 
void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE) {
167
 
  delete unwrap(EE);
168
 
}
169
 
 
170
 
void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE) {
171
 
  unwrap(EE)->runStaticConstructorsDestructors(false);
172
 
}
173
 
 
174
 
void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE) {
175
 
  unwrap(EE)->runStaticConstructorsDestructors(true);
176
 
}
177
 
 
178
 
int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
179
 
                          unsigned ArgC, const char * const *ArgV,
180
 
                          const char * const *EnvP) {
181
 
  std::vector<std::string> ArgVec;
182
 
  for (unsigned I = 0; I != ArgC; ++I)
183
 
    ArgVec.push_back(ArgV[I]);
184
 
  
185
 
  return unwrap(EE)->runFunctionAsMain(unwrap<Function>(F), ArgVec, EnvP);
186
 
}
187
 
 
188
 
LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
189
 
                                    unsigned NumArgs,
190
 
                                    LLVMGenericValueRef *Args) {
191
 
  std::vector<GenericValue> ArgVec;
192
 
  ArgVec.reserve(NumArgs);
193
 
  for (unsigned I = 0; I != NumArgs; ++I)
194
 
    ArgVec.push_back(*unwrap(Args[I]));
195
 
  
196
 
  GenericValue *Result = new GenericValue();
197
 
  *Result = unwrap(EE)->runFunction(unwrap<Function>(F), ArgVec);
198
 
  return wrap(Result);
199
 
}
200
 
 
201
 
void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F) {
202
 
  unwrap(EE)->freeMachineCodeForFunction(unwrap<Function>(F));
203
 
}
204
 
 
205
 
void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M){
206
 
  unwrap(EE)->addModule(unwrap(M));
207
 
}
208
 
 
209
 
void LLVMAddModuleProvider(LLVMExecutionEngineRef EE, LLVMModuleProviderRef MP){
210
 
  /* The module provider is now actually a module. */
211
 
  LLVMAddModule(EE, reinterpret_cast<LLVMModuleRef>(MP));
212
 
}
213
 
 
214
 
LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M,
215
 
                          LLVMModuleRef *OutMod, char **OutError) {
216
 
  Module *Mod = unwrap(M);
217
 
  unwrap(EE)->removeModule(Mod);
218
 
  *OutMod = wrap(Mod);
219
 
  return 0;
220
 
}
221
 
 
222
 
LLVMBool LLVMRemoveModuleProvider(LLVMExecutionEngineRef EE,
223
 
                                  LLVMModuleProviderRef MP,
224
 
                                  LLVMModuleRef *OutMod, char **OutError) {
225
 
  /* The module provider is now actually a module. */
226
 
  return LLVMRemoveModule(EE, reinterpret_cast<LLVMModuleRef>(MP), OutMod,
227
 
                          OutError);
228
 
}
229
 
 
230
 
LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
231
 
                          LLVMValueRef *OutFn) {
232
 
  if (Function *F = unwrap(EE)->FindFunctionNamed(Name)) {
233
 
    *OutFn = wrap(F);
234
 
    return 0;
235
 
  }
236
 
  return 1;
237
 
}
238
 
 
239
 
void *LLVMRecompileAndRelinkFunction(LLVMExecutionEngineRef EE, LLVMValueRef Fn) {
240
 
  return unwrap(EE)->recompileAndRelinkFunction(unwrap<Function>(Fn));
241
 
}
242
 
 
243
 
LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE) {
244
 
  return wrap(unwrap(EE)->getTargetData());
245
 
}
246
 
 
247
 
void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
248
 
                          void* Addr) {
249
 
  unwrap(EE)->addGlobalMapping(unwrap<GlobalValue>(Global), Addr);
250
 
}
251
 
 
252
 
void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global) {
253
 
  return unwrap(EE)->getPointerToGlobal(unwrap<GlobalValue>(Global));
254
 
}