← 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-c/ExecutionEngine.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-c/ExecutionEngine.h
 
1
/*===-- llvm-c/ExecutionEngine.h - ExecutionEngine Lib C Iface --*- 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 header declares the C interface to libLLVMExecutionEngine.o, which    *|
 
11
|* implements various analyses of the LLVM IR.                                *|
 
12
|*                                                                            *|
 
13
|* Many exotic languages can interoperate with C code but have a harder time  *|
 
14
|* with C++ due to name mangling. So in addition to C, this interface enables *|
 
15
|* tools written in such languages.                                           *|
 
16
|*                                                                            *|
 
17
\*===----------------------------------------------------------------------===*/
 
18
 
 
19
#ifndef LLVM_C_EXECUTIONENGINE_H
 
20
#define LLVM_C_EXECUTIONENGINE_H
 
21
 
 
22
#include "llvm-c/Core.h"
 
23
#include "llvm-c/Target.h"
 
24
 
 
25
#ifdef __cplusplus
 
26
extern "C" {
 
27
#endif
 
28
 
 
29
void LLVMLinkInJIT(void);
 
30
void LLVMLinkInInterpreter(void);
 
31
 
 
32
typedef struct LLVMOpaqueGenericValue *LLVMGenericValueRef;
 
33
typedef struct LLVMOpaqueExecutionEngine *LLVMExecutionEngineRef;
 
34
 
 
35
/*===-- Operations on generic values --------------------------------------===*/
 
36
 
 
37
LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty,
 
38
                                                unsigned long long N,
 
39
                                                LLVMBool IsSigned);
 
40
 
 
41
LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P);
 
42
 
 
43
LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef Ty, double N);
 
44
 
 
45
unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef);
 
46
 
 
47
unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenVal,
 
48
                                         LLVMBool IsSigned);
 
49
 
 
50
void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal);
 
51
 
 
52
double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal);
 
53
 
 
54
void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal);
 
55
 
 
56
/*===-- Operations on execution engines -----------------------------------===*/
 
57
 
 
58
LLVMBool LLVMCreateExecutionEngineForModule(LLVMExecutionEngineRef *OutEE,
 
59
                                            LLVMModuleRef M,
 
60
                                            char **OutError);
 
61
 
 
62
LLVMBool LLVMCreateInterpreterForModule(LLVMExecutionEngineRef *OutInterp,
 
63
                                        LLVMModuleRef M,
 
64
                                        char **OutError);
 
65
 
 
66
LLVMBool LLVMCreateJITCompilerForModule(LLVMExecutionEngineRef *OutJIT,
 
67
                                        LLVMModuleRef M,
 
68
                                        unsigned OptLevel,
 
69
                                        char **OutError);
 
70
 
 
71
/** Deprecated: Use LLVMCreateExecutionEngineForModule instead. */
 
72
LLVMBool LLVMCreateExecutionEngine(LLVMExecutionEngineRef *OutEE,
 
73
                                   LLVMModuleProviderRef MP,
 
74
                                   char **OutError);
 
75
 
 
76
/** Deprecated: Use LLVMCreateInterpreterForModule instead. */
 
77
LLVMBool LLVMCreateInterpreter(LLVMExecutionEngineRef *OutInterp,
 
78
                               LLVMModuleProviderRef MP,
 
79
                               char **OutError);
 
80
 
 
81
/** Deprecated: Use LLVMCreateJITCompilerForModule instead. */
 
82
LLVMBool LLVMCreateJITCompiler(LLVMExecutionEngineRef *OutJIT,
 
83
                               LLVMModuleProviderRef MP,
 
84
                               unsigned OptLevel,
 
85
                               char **OutError);
 
86
 
 
87
void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE);
 
88
 
 
89
void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE);
 
90
 
 
91
void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE);
 
92
 
 
93
int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
 
94
                          unsigned ArgC, const char * const *ArgV,
 
95
                          const char * const *EnvP);
 
96
 
 
97
LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
 
98
                                    unsigned NumArgs,
 
99
                                    LLVMGenericValueRef *Args);
 
100
 
 
101
void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F);
 
102
 
 
103
void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M);
 
104
 
 
105
/** Deprecated: Use LLVMAddModule instead. */
 
106
void LLVMAddModuleProvider(LLVMExecutionEngineRef EE, LLVMModuleProviderRef MP);
 
107
 
 
108
LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M,
 
109
                          LLVMModuleRef *OutMod, char **OutError);
 
110
 
 
111
/** Deprecated: Use LLVMRemoveModule instead. */
 
112
LLVMBool LLVMRemoveModuleProvider(LLVMExecutionEngineRef EE,
 
113
                                  LLVMModuleProviderRef MP,
 
114
                                  LLVMModuleRef *OutMod, char **OutError);
 
115
 
 
116
LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
 
117
                          LLVMValueRef *OutFn);
 
118
 
 
119
LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE);
 
120
 
 
121
void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
 
122
                          void* Addr);
 
123
 
 
124
void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global);
 
125
 
 
126
#ifdef __cplusplus
 
127
}
 
128
 
 
129
namespace llvm {
 
130
  struct GenericValue;
 
131
  class ExecutionEngine;
 
132
  
 
133
  #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)   \
 
134
    inline ty *unwrap(ref P) {                          \
 
135
      return reinterpret_cast<ty*>(P);                  \
 
136
    }                                                   \
 
137
                                                        \
 
138
    inline ref wrap(const ty *P) {                      \
 
139
      return reinterpret_cast<ref>(const_cast<ty*>(P)); \
 
140
    }
 
141
  
 
142
  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(GenericValue,    LLVMGenericValueRef   )
 
143
  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ExecutionEngine, LLVMExecutionEngineRef)
 
144
  
 
145
  #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS
 
146
}
 
147
  
 
148
#endif /* defined(__cplusplus) */
 
149
 
 
150
#endif