← Back to branch summary

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

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/include/llvm-c/Core.h

  • Committer: Package Import Robot
  • Author(s): Scott Kitterman, Sebastian Andrzej Siewior, Andreas Cadhalpun, Scott Kitterman, Javier Fernández-Sanguino
  • Date: 2015-01-28 00:25:13 UTC
  • mfrom: (1.3.15)
  • Revision ID: package-import@ubuntu.com-20150128002513-4apvvjyr1213db8x
Tags: 0.98.6+dfsg-1
http://bugs.debian.org/774686
http://bugs.debian.org/767350
http://bugs.debian.org/775400
http://bugs.debian.org/767353
http://bugs.debian.org/773563
[ Sebastian Andrzej Siewior ]
* update "fix-ssize_t-size_t-off_t-printf-modifier", include of misc.h was
  missing but was pulled in via the systemd patch.
* Don't leak return codes from libmspack to clamav API. (Closes: #774686).

[ Andreas Cadhalpun ]
* Add patch to avoid emitting incremental progress messages when not
  outputting to a terminal. (Closes: #767350)
* Update lintian-overrides for unused-file-paragraph-in-dep5-copyright.
* clamav-base.postinst: always chown /var/log/clamav and /var/lib/clamav
  to clamav:clamav, not only on fresh installations. (Closes: #775400)
* Adapt the clamav-daemon and clamav-freshclam logrotate scripts,
  so that they correctly work under systemd.
* Move the PidFile variable from the clamd/freshclam configuration files
  to the init scripts. This makes the init scripts more robust against
  misconfiguration and avoids error messages with systemd. (Closes: #767353)
* debian/copyright: drop files from Files-Excluded only present in github
  tarballs
* Drop Workaround-a-bug-in-libc-on-Hurd.patch, because hurd got fixed.
  (see #752237)
* debian/rules: Remove useless --with-system-tommath --without-included-ltdl
  configure options.

[ Scott Kitterman ]
* Stop stripping llvm when repacking the tarball as the system llvm on some
  releases is too old to use
* New upstream bugfix release
  - Library shared object revisions.
  - Includes a patch from Sebastian Andrzej Siewior making ClamAV pid files
    compatible with systemd.
  - Fix a heap out of bounds condition with crafted Yoda's crypter files.
    This issue was discovered by Felix Groebert of the Google Security Team.
  - Fix a heap out of bounds condition with crafted mew packer files. This
    issue was discovered by Felix Groebert of the Google Security Team.
  - Fix a heap out of bounds condition with crafted upx packer files. This
    issue was discovered by Kevin Szkudlapski of Quarkslab.
  - Fix a heap out of bounds condition with crafted upack packer files. This
    issue was discovered by Sebastian Andrzej Siewior. CVE-2014-9328.
  - Compensate a crash due to incorrect compiler optimization when handling
    crafted petite packer files. This issue was discovered by Sebastian
    Andrzej Siewior.
* Update lintian override for embedded zlib to match new so version

[ Javier Fernández-Sanguino ]
* Updated Spanish Debconf template translation (Closes: #773563)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/include/llvm-c/Core.h
 
1
/*===-- llvm-c/Core.h - Core Library C Interface ------------------*- 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 libLLVMCore.a, which implements    *|
 
11
|* the LLVM intermediate representation.                                      *|
 
12
|*                                                                            *|
 
13
|* LLVM uses a polymorphic type hierarchy which C cannot represent, therefore *|
 
14
|* parameters must be passed as base types. Despite the declared types, most  *|
 
15
|* of the functions provided operate only on branches of the type hierarchy.  *|
 
16
|* The declared parameter names are descriptive and specify which type is     *|
 
17
|* required. Additionally, each type hierarchy is documented along with the   *|
 
18
|* functions that operate upon it. For more detail, refer to LLVM's C++ code. *|
 
19
|* If in doubt, refer to Core.cpp, which performs paramter downcasts in the   *|
 
20
|* form unwrap<RequiredType>(Param).                                          *|
 
21
|*                                                                            *|
 
22
|* Many exotic languages can interoperate with C code but have a harder time  *|
 
23
|* with C++ due to name mangling. So in addition to C, this interface enables *|
 
24
|* tools written in such languages.                                           *|
 
25
|*                                                                            *|
 
26
|* When included into a C++ source file, also declares 'wrap' and 'unwrap'    *|
 
27
|* helpers to perform opaque reference<-->pointer conversions. These helpers  *|
 
28
|* are shorter and more tightly typed than writing the casts by hand when     *|
 
29
|* authoring bindings. In assert builds, they will do runtime type checking.  *|
 
30
|*                                                                            *|
 
31
\*===----------------------------------------------------------------------===*/
 
32
 
 
33
#ifndef LLVM_C_CORE_H
 
34
#define LLVM_C_CORE_H
 
35
 
 
36
#include "llvm/System/DataTypes.h"
 
37
 
 
38
#ifdef __cplusplus
 
39
 
 
40
/* Need these includes to support the LLVM 'cast' template for the C++ 'wrap' 
 
41
   and 'unwrap' conversion functions. */
 
42
#include "llvm/Module.h"
 
43
#include "llvm/Support/IRBuilder.h"
 
44
 
 
45
extern "C" {
 
46
#endif
 
47
 
 
48
 
 
49
typedef int LLVMBool;
 
50
 
 
51
/* Opaque types. */
 
52
 
 
53
/**
 
54
 * The top-level container for all LLVM global data.  See the LLVMContext class.
 
55
 */
 
56
typedef struct LLVMOpaqueContext *LLVMContextRef;
 
57
 
 
58
/**
 
59
 * The top-level container for all other LLVM Intermediate Representation (IR)
 
60
 * objects. See the llvm::Module class.
 
61
 */
 
62
typedef struct LLVMOpaqueModule *LLVMModuleRef;
 
63
 
 
64
/**
 
65
 * Each value in the LLVM IR has a type, an LLVMTypeRef. See the llvm::Type
 
66
 * class.
 
67
 */
 
68
typedef struct LLVMOpaqueType *LLVMTypeRef;
 
69
 
 
70
/**
 
71
 * When building recursive types using LLVMRefineType, LLVMTypeRef values may
 
72
 * become invalid; use LLVMTypeHandleRef to resolve this problem. See the
 
73
 * llvm::AbstractTypeHolder class.
 
74
 */
 
75
typedef struct LLVMOpaqueTypeHandle *LLVMTypeHandleRef;
 
76
 
 
77
typedef struct LLVMOpaqueValue *LLVMValueRef;
 
78
typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef;
 
79
typedef struct LLVMOpaqueBuilder *LLVMBuilderRef;
 
80
 
 
81
/* Interface used to provide a module to JIT or interpreter.  This is now just a
 
82
 * synonym for llvm::Module, but we have to keep using the different type to
 
83
 * keep binary compatibility.
 
84
 */
 
85
typedef struct LLVMOpaqueModuleProvider *LLVMModuleProviderRef;
 
86
 
 
87
/* Used to provide a module to JIT or interpreter.
 
88
 * See the llvm::MemoryBuffer class.
 
89
 */
 
90
typedef struct LLVMOpaqueMemoryBuffer *LLVMMemoryBufferRef;
 
91
 
 
92
/** See the llvm::PassManagerBase class. */
 
93
typedef struct LLVMOpaquePassManager *LLVMPassManagerRef;
 
94
 
 
95
/** Used to get the users and usees of a Value. See the llvm::Use class. */
 
96
typedef struct LLVMOpaqueUse *LLVMUseRef;
 
97
 
 
98
typedef enum {
 
99
    LLVMZExtAttribute       = 1<<0,
 
100
    LLVMSExtAttribute       = 1<<1,
 
101
    LLVMNoReturnAttribute   = 1<<2,
 
102
    LLVMInRegAttribute      = 1<<3,
 
103
    LLVMStructRetAttribute  = 1<<4,
 
104
    LLVMNoUnwindAttribute   = 1<<5,
 
105
    LLVMNoAliasAttribute    = 1<<6,
 
106
    LLVMByValAttribute      = 1<<7,
 
107
    LLVMNestAttribute       = 1<<8,
 
108
    LLVMReadNoneAttribute   = 1<<9,
 
109
    LLVMReadOnlyAttribute   = 1<<10,
 
110
    LLVMNoInlineAttribute   = 1<<11,
 
111
    LLVMAlwaysInlineAttribute    = 1<<12,
 
112
    LLVMOptimizeForSizeAttribute = 1<<13,
 
113
    LLVMStackProtectAttribute    = 1<<14,
 
114
    LLVMStackProtectReqAttribute = 1<<15,
 
115
    LLVMAlignment = 31<<16,
 
116
    LLVMNoCaptureAttribute  = 1<<21,
 
117
    LLVMNoRedZoneAttribute  = 1<<22,
 
118
    LLVMNoImplicitFloatAttribute = 1<<23,
 
119
    LLVMNakedAttribute      = 1<<24,
 
120
    LLVMInlineHintAttribute = 1<<25,
 
121
    LLVMStackAlignment = 7<<26
 
122
} LLVMAttribute;
 
123
 
 
124
typedef enum {
 
125
  /* Terminator Instructions */
 
126
  LLVMRet            = 1,
 
127
  LLVMBr             = 2,
 
128
  LLVMSwitch         = 3,
 
129
  LLVMIndirectBr     = 4,
 
130
  LLVMInvoke         = 5,
 
131
  LLVMUnwind         = 6,
 
132
  LLVMUnreachable    = 7,
 
133
 
 
134
  /* Standard Binary Operators */
 
135
  LLVMAdd            = 8,
 
136
  LLVMFAdd           = 9,
 
137
  LLVMSub            = 10,
 
138
  LLVMFSub           = 11,
 
139
  LLVMMul            = 12,
 
140
  LLVMFMul           = 13,
 
141
  LLVMUDiv           = 14,
 
142
  LLVMSDiv           = 15,
 
143
  LLVMFDiv           = 16,
 
144
  LLVMURem           = 17,
 
145
  LLVMSRem           = 18,
 
146
  LLVMFRem           = 19,
 
147
 
 
148
  /* Logical Operators */
 
149
  LLVMShl            = 20,
 
150
  LLVMLShr           = 21,
 
151
  LLVMAShr           = 22,
 
152
  LLVMAnd            = 23,
 
153
  LLVMOr             = 24,
 
154
  LLVMXor            = 25,
 
155
 
 
156
  /* Memory Operators */
 
157
  LLVMAlloca         = 26,
 
158
  LLVMLoad           = 27,
 
159
  LLVMStore          = 28,
 
160
  LLVMGetElementPtr  = 29,
 
161
 
 
162
  /* Cast Operators */
 
163
  LLVMTrunc          = 30,
 
164
  LLVMZExt           = 31,
 
165
  LLVMSExt           = 32,
 
166
  LLVMFPToUI         = 33,
 
167
  LLVMFPToSI         = 34,
 
168
  LLVMUIToFP         = 35,
 
169
  LLVMSIToFP         = 36,
 
170
  LLVMFPTrunc        = 37,
 
171
  LLVMFPExt          = 38,
 
172
  LLVMPtrToInt       = 39,
 
173
  LLVMIntToPtr       = 40,
 
174
  LLVMBitCast        = 41,
 
175
 
 
176
  /* Other Operators */
 
177
  LLVMICmp           = 42,
 
178
  LLVMFCmp           = 43,
 
179
  LLVMPHI            = 44,
 
180
  LLVMCall           = 45,
 
181
  LLVMSelect         = 46,
 
182
  /* UserOp1 */
 
183
  /* UserOp2 */
 
184
  LLVMVAArg          = 49,
 
185
  LLVMExtractElement = 50,
 
186
  LLVMInsertElement  = 51,
 
187
  LLVMShuffleVector  = 52,
 
188
  LLVMExtractValue   = 53,
 
189
  LLVMInsertValue    = 54
 
190
} LLVMOpcode;
 
191
 
 
192
typedef enum {
 
193
  LLVMVoidTypeKind,        /**< type with no size */
 
194
  LLVMFloatTypeKind,       /**< 32 bit floating point type */
 
195
  LLVMDoubleTypeKind,      /**< 64 bit floating point type */
 
196
  LLVMX86_FP80TypeKind,    /**< 80 bit floating point type (X87) */
 
197
  LLVMFP128TypeKind,       /**< 128 bit floating point type (112-bit mantissa)*/
 
198
  LLVMPPC_FP128TypeKind,   /**< 128 bit floating point type (two 64-bits) */
 
199
  LLVMLabelTypeKind,       /**< Labels */
 
200
  LLVMIntegerTypeKind,     /**< Arbitrary bit width integers */
 
201
  LLVMFunctionTypeKind,    /**< Functions */
 
202
  LLVMStructTypeKind,      /**< Structures */
 
203
  LLVMArrayTypeKind,       /**< Arrays */
 
204
  LLVMPointerTypeKind,     /**< Pointers */
 
205
  LLVMOpaqueTypeKind,      /**< Opaque: type with unknown structure */
 
206
  LLVMVectorTypeKind,      /**< SIMD 'packed' format, or other vector type */
 
207
  LLVMMetadataTypeKind     /**< Metadata */
 
208
} LLVMTypeKind;
 
209
 
 
210
typedef enum {
 
211
  LLVMExternalLinkage,    /**< Externally visible function */
 
212
  LLVMAvailableExternallyLinkage,
 
213
  LLVMLinkOnceAnyLinkage, /**< Keep one copy of function when linking (inline)*/
 
214
  LLVMLinkOnceODRLinkage, /**< Same, but only replaced by something
 
215
                            equivalent. */
 
216
  LLVMWeakAnyLinkage,     /**< Keep one copy of function when linking (weak) */
 
217
  LLVMWeakODRLinkage,     /**< Same, but only replaced by something
 
218
                            equivalent. */
 
219
  LLVMAppendingLinkage,   /**< Special purpose, only applies to global arrays */
 
220
  LLVMInternalLinkage,    /**< Rename collisions when linking (static
 
221
                               functions) */
 
222
  LLVMPrivateLinkage,     /**< Like Internal, but omit from symbol table */
 
223
  LLVMDLLImportLinkage,   /**< Function to be imported from DLL */
 
224
  LLVMDLLExportLinkage,   /**< Function to be accessible from DLL */
 
225
  LLVMExternalWeakLinkage,/**< ExternalWeak linkage description */
 
226
  LLVMGhostLinkage,       /**< Obsolete */
 
227
  LLVMCommonLinkage,      /**< Tentative definitions */
 
228
  LLVMLinkerPrivateLinkage, /**< Like Private, but linker removes. */
 
229
  LLVMLinkerPrivateWeakLinkage, /**< Like LinkerPrivate, but is weak. */
 
230
  LLVMLinkerPrivateWeakDefAutoLinkage /**< Like LinkerPrivateWeak, but possibly
 
231
                                           hidden. */
 
232
} LLVMLinkage;
 
233
 
 
234
typedef enum {
 
235
  LLVMDefaultVisibility,  /**< The GV is visible */
 
236
  LLVMHiddenVisibility,   /**< The GV is hidden */
 
237
  LLVMProtectedVisibility /**< The GV is protected */
 
238
} LLVMVisibility;
 
239
 
 
240
typedef enum {
 
241
  LLVMCCallConv           = 0,
 
242
  LLVMFastCallConv        = 8,
 
243
  LLVMColdCallConv        = 9,
 
244
  LLVMX86StdcallCallConv  = 64,
 
245
  LLVMX86FastcallCallConv = 65
 
246
} LLVMCallConv;
 
247
 
 
248
typedef enum {
 
249
  LLVMIntEQ = 32, /**< equal */
 
250
  LLVMIntNE,      /**< not equal */
 
251
  LLVMIntUGT,     /**< unsigned greater than */
 
252
  LLVMIntUGE,     /**< unsigned greater or equal */
 
253
  LLVMIntULT,     /**< unsigned less than */
 
254
  LLVMIntULE,     /**< unsigned less or equal */
 
255
  LLVMIntSGT,     /**< signed greater than */
 
256
  LLVMIntSGE,     /**< signed greater or equal */
 
257
  LLVMIntSLT,     /**< signed less than */
 
258
  LLVMIntSLE      /**< signed less or equal */
 
259
} LLVMIntPredicate;
 
260
 
 
261
typedef enum {
 
262
  LLVMRealPredicateFalse, /**< Always false (always folded) */
 
263
  LLVMRealOEQ,            /**< True if ordered and equal */
 
264
  LLVMRealOGT,            /**< True if ordered and greater than */
 
265
  LLVMRealOGE,            /**< True if ordered and greater than or equal */
 
266
  LLVMRealOLT,            /**< True if ordered and less than */
 
267
  LLVMRealOLE,            /**< True if ordered and less than or equal */
 
268
  LLVMRealONE,            /**< True if ordered and operands are unequal */
 
269
  LLVMRealORD,            /**< True if ordered (no nans) */
 
270
  LLVMRealUNO,            /**< True if unordered: isnan(X) | isnan(Y) */
 
271
  LLVMRealUEQ,            /**< True if unordered or equal */
 
272
  LLVMRealUGT,            /**< True if unordered or greater than */
 
273
  LLVMRealUGE,            /**< True if unordered, greater than, or equal */
 
274
  LLVMRealULT,            /**< True if unordered or less than */
 
275
  LLVMRealULE,            /**< True if unordered, less than, or equal */
 
276
  LLVMRealUNE,            /**< True if unordered or not equal */
 
277
  LLVMRealPredicateTrue   /**< Always true (always folded) */
 
278
} LLVMRealPredicate;
 
279
 
 
280
 
 
281
/*===-- Error handling ----------------------------------------------------===*/
 
282
 
 
283
void LLVMDisposeMessage(char *Message);
 
284
 
 
285
 
 
286
/*===-- Contexts ----------------------------------------------------------===*/
 
287
 
 
288
/* Create and destroy contexts. */
 
289
LLVMContextRef LLVMContextCreate(void);
 
290
LLVMContextRef LLVMGetGlobalContext(void);
 
291
void LLVMContextDispose(LLVMContextRef C);
 
292
 
 
293
unsigned LLVMGetMDKindIDInContext(LLVMContextRef C, const char* Name,
 
294
                                  unsigned SLen);
 
295
unsigned LLVMGetMDKindID(const char* Name, unsigned SLen);
 
296
 
 
297
/*===-- Modules -----------------------------------------------------------===*/
 
298
 
 
299
/* Create and destroy modules. */ 
 
300
/** See llvm::Module::Module. */
 
301
LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
 
302
LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID,
 
303
                                                LLVMContextRef C);
 
304
 
 
305
/** See llvm::Module::~Module. */
 
306
void LLVMDisposeModule(LLVMModuleRef M);
 
307
 
 
308
/** Data layout. See Module::getDataLayout. */
 
309
const char *LLVMGetDataLayout(LLVMModuleRef M);
 
310
void LLVMSetDataLayout(LLVMModuleRef M, const char *Triple);
 
311
 
 
312
/** Target triple. See Module::getTargetTriple. */
 
313
const char *LLVMGetTarget(LLVMModuleRef M);
 
314
void LLVMSetTarget(LLVMModuleRef M, const char *Triple);
 
315
 
 
316
/** See Module::addTypeName. */
 
317
LLVMBool LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty);
 
318
void LLVMDeleteTypeName(LLVMModuleRef M, const char *Name);
 
319
LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name);
 
320
 
 
321
/** See Module::dump. */
 
322
void LLVMDumpModule(LLVMModuleRef M);
 
323
 
 
324
/** See Module::setModuleInlineAsm. */
 
325
void LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm);
 
326
 
 
327
/*===-- Types -------------------------------------------------------------===*/
 
328
 
 
329
/* LLVM types conform to the following hierarchy:
 
330
 * 
 
331
 *   types:
 
332
 *     integer type
 
333
 *     real type
 
334
 *     function type
 
335
 *     sequence types:
 
336
 *       array type
 
337
 *       pointer type
 
338
 *       vector type
 
339
 *     void type
 
340
 *     label type
 
341
 *     opaque type
 
342
 */
 
343
 
 
344
/** See llvm::LLVMTypeKind::getTypeID. */
 
345
LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
 
346
 
 
347
/** See llvm::LLVMType::getContext. */
 
348
LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty);
 
349
 
 
350
/* Operations on integer types */
 
351
LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C);
 
352
LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C);
 
353
LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C);
 
354
LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C);
 
355
LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C);
 
356
LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits);
 
357
 
 
358
LLVMTypeRef LLVMInt1Type(void);
 
359
LLVMTypeRef LLVMInt8Type(void);
 
360
LLVMTypeRef LLVMInt16Type(void);
 
361
LLVMTypeRef LLVMInt32Type(void);
 
362
LLVMTypeRef LLVMInt64Type(void);
 
363
LLVMTypeRef LLVMIntType(unsigned NumBits);
 
364
unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
 
365
 
 
366
/* Operations on real types */
 
367
LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C);
 
368
LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C);
 
369
LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C);
 
370
LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C);
 
371
LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C);
 
372
 
 
373
LLVMTypeRef LLVMFloatType(void);
 
374
LLVMTypeRef LLVMDoubleType(void);
 
375
LLVMTypeRef LLVMX86FP80Type(void);
 
376
LLVMTypeRef LLVMFP128Type(void);
 
377
LLVMTypeRef LLVMPPCFP128Type(void);
 
378
 
 
379
/* Operations on function types */
 
380
LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
 
381
                             LLVMTypeRef *ParamTypes, unsigned ParamCount,
 
382
                             LLVMBool IsVarArg);
 
383
LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
 
384
LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
 
385
unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
 
386
void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
 
387
 
 
388
/* Operations on struct types */
 
389
LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes,
 
390
                                    unsigned ElementCount, LLVMBool Packed);
 
391
LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
 
392
                           LLVMBool Packed);
 
393
unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
 
394
void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
 
395
LLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy);
 
396
 
 
397
/* Operations on array, pointer, and vector types (sequence types) */
 
398
LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
 
399
LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace);
 
400
LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
 
401
 
 
402
LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
 
403
unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
 
404
unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy);
 
405
unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
 
406
 
 
407
/* Operations on other types */
 
408
LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C);
 
409
LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C);
 
410
LLVMTypeRef LLVMOpaqueTypeInContext(LLVMContextRef C);
 
411
 
 
412
LLVMTypeRef LLVMVoidType(void);
 
413
LLVMTypeRef LLVMLabelType(void);
 
414
LLVMTypeRef LLVMOpaqueType(void);
 
415
 
 
416
/* Operations on type handles */
 
417
LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy);
 
418
void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy);
 
419
LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle);
 
420
void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle);
 
421
 
 
422
 
 
423
/*===-- Values ------------------------------------------------------------===*/
 
424
 
 
425
/* The bulk of LLVM's object model consists of values, which comprise a very
 
426
 * rich type hierarchy.
 
427
 */
 
428
 
 
429
#define LLVM_FOR_EACH_VALUE_SUBCLASS(macro) \
 
430
  macro(Argument)                           \
 
431
  macro(BasicBlock)                         \
 
432
  macro(InlineAsm)                          \
 
433
  macro(User)                               \
 
434
    macro(Constant)                         \
 
435
      macro(ConstantAggregateZero)          \
 
436
      macro(ConstantArray)                  \
 
437
      macro(ConstantExpr)                   \
 
438
      macro(ConstantFP)                     \
 
439
      macro(ConstantInt)                    \
 
440
      macro(ConstantPointerNull)            \
 
441
      macro(ConstantStruct)                 \
 
442
      macro(ConstantVector)                 \
 
443
      macro(GlobalValue)                    \
 
444
        macro(Function)                     \
 
445
        macro(GlobalAlias)                  \
 
446
        macro(GlobalVariable)               \
 
447
      macro(UndefValue)                     \
 
448
    macro(Instruction)                      \
 
449
      macro(BinaryOperator)                 \
 
450
      macro(CallInst)                       \
 
451
        macro(IntrinsicInst)                \
 
452
          macro(DbgInfoIntrinsic)           \
 
453
            macro(DbgDeclareInst)           \
 
454
          macro(EHSelectorInst)             \
 
455
          macro(MemIntrinsic)               \
 
456
            macro(MemCpyInst)               \
 
457
            macro(MemMoveInst)              \
 
458
            macro(MemSetInst)               \
 
459
      macro(CmpInst)                        \
 
460
      macro(FCmpInst)                       \
 
461
      macro(ICmpInst)                       \
 
462
      macro(ExtractElementInst)             \
 
463
      macro(GetElementPtrInst)              \
 
464
      macro(InsertElementInst)              \
 
465
      macro(InsertValueInst)                \
 
466
      macro(PHINode)                        \
 
467
      macro(SelectInst)                     \
 
468
      macro(ShuffleVectorInst)              \
 
469
      macro(StoreInst)                      \
 
470
      macro(TerminatorInst)                 \
 
471
        macro(BranchInst)                   \
 
472
        macro(InvokeInst)                   \
 
473
        macro(ReturnInst)                   \
 
474
        macro(SwitchInst)                   \
 
475
        macro(UnreachableInst)              \
 
476
        macro(UnwindInst)                   \
 
477
    macro(UnaryInstruction)                 \
 
478
      macro(AllocaInst)                     \
 
479
      macro(CastInst)                       \
 
480
        macro(BitCastInst)                  \
 
481
        macro(FPExtInst)                    \
 
482
        macro(FPToSIInst)                   \
 
483
        macro(FPToUIInst)                   \
 
484
        macro(FPTruncInst)                  \
 
485
        macro(IntToPtrInst)                 \
 
486
        macro(PtrToIntInst)                 \
 
487
        macro(SExtInst)                     \
 
488
        macro(SIToFPInst)                   \
 
489
        macro(TruncInst)                    \
 
490
        macro(UIToFPInst)                   \
 
491
        macro(ZExtInst)                     \
 
492
      macro(ExtractValueInst)               \
 
493
      macro(LoadInst)                       \
 
494
      macro(VAArgInst)
 
495
 
 
496
/* Operations on all values */
 
497
LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
 
498
const char *LLVMGetValueName(LLVMValueRef Val);
 
499
void LLVMSetValueName(LLVMValueRef Val, const char *Name);
 
500
void LLVMDumpValue(LLVMValueRef Val);
 
501
void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal);
 
502
int LLVMHasMetadata(LLVMValueRef Val);
 
503
LLVMValueRef LLVMGetMetadata(LLVMValueRef Val, unsigned KindID);
 
504
void LLVMSetMetadata(LLVMValueRef Val, unsigned KindID, LLVMValueRef Node);
 
505
 
 
506
/* Conversion functions. Return the input value if it is an instance of the
 
507
   specified class, otherwise NULL. See llvm::dyn_cast_or_null<>. */
 
508
#define LLVM_DECLARE_VALUE_CAST(name) \
 
509
  LLVMValueRef LLVMIsA##name(LLVMValueRef Val);
 
510
LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST)
 
511
 
 
512
/* Operations on Uses */
 
513
LLVMUseRef LLVMGetFirstUse(LLVMValueRef Val);
 
514
LLVMUseRef LLVMGetNextUse(LLVMUseRef U);
 
515
LLVMValueRef LLVMGetUser(LLVMUseRef U);
 
516
LLVMValueRef LLVMGetUsedValue(LLVMUseRef U);
 
517
 
 
518
/* Operations on Users */
 
519
LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index);
 
520
void LLVMSetOperand(LLVMValueRef User, unsigned Index, LLVMValueRef Val);
 
521
int LLVMGetNumOperands(LLVMValueRef Val);
 
522
 
 
523
/* Operations on constants of any type */
 
524
LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
 
525
LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */
 
526
LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
 
527
LLVMBool LLVMIsConstant(LLVMValueRef Val);
 
528
LLVMBool LLVMIsNull(LLVMValueRef Val);
 
529
LLVMBool LLVMIsUndef(LLVMValueRef Val);
 
530
LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty);
 
531
 
 
532
/* Operations on metadata */
 
533
LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str,
 
534
                                   unsigned SLen);
 
535
LLVMValueRef LLVMMDString(const char *Str, unsigned SLen);
 
536
LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals,
 
537
                                 unsigned Count);
 
538
LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count);
 
539
 
 
540
/* Operations on scalar constants */
 
541
LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
 
542
                          LLVMBool SignExtend);
 
543
LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char *Text,
 
544
                                  uint8_t Radix);
 
545
LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char *Text,
 
546
                                         unsigned SLen, uint8_t Radix);
 
547
LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
 
548
LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text);
 
549
LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char *Text,
 
550
                                          unsigned SLen);
 
551
unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal);
 
552
long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal);
 
553
 
 
554
 
 
555
/* Operations on composite constants */
 
556
LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str,
 
557
                                      unsigned Length, LLVMBool DontNullTerminate);
 
558
LLVMValueRef LLVMConstStructInContext(LLVMContextRef C, 
 
559
                                      LLVMValueRef *ConstantVals,
 
560
                                      unsigned Count, LLVMBool Packed);
 
561
 
 
562
LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
 
563
                             LLVMBool DontNullTerminate);
 
564
LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
 
565
                            LLVMValueRef *ConstantVals, unsigned Length);
 
566
LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
 
567
                             LLVMBool Packed);
 
568
LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
 
569
 
 
570
/* Constant expressions */
 
571
LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal);
 
572
LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty);
 
573
LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
 
574
LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
 
575
LLVMValueRef LLVMConstNSWNeg(LLVMValueRef ConstantVal);
 
576
LLVMValueRef LLVMConstNUWNeg(LLVMValueRef ConstantVal);
 
577
LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal);
 
578
LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
 
579
LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
580
LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
581
LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
582
LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
583
LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
584
LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
585
LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
586
LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
587
LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
588
LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
589
LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
590
LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
591
LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
592
LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
593
LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
594
LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
595
LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
596
LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
597
LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
598
LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
599
LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
600
LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
601
LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
 
602
                           LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
603
LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
 
604
                           LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
605
LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
606
LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
607
LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 
608
LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
 
609
                          LLVMValueRef *ConstantIndices, unsigned NumIndices);
 
610
LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal,
 
611
                                  LLVMValueRef *ConstantIndices,
 
612
                                  unsigned NumIndices);
 
613
LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 
614
LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 
615
LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 
616
LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 
617
LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 
618
LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 
619
LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 
620
LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 
621
LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 
622
LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 
623
LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 
624
LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 
625
LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal,
 
626
                                    LLVMTypeRef ToType);
 
627
LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal,
 
628
                                    LLVMTypeRef ToType);
 
629
LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal,
 
630
                                     LLVMTypeRef ToType);
 
631
LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal,
 
632
                                  LLVMTypeRef ToType);
 
633
LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType,
 
634
                              LLVMBool isSigned);
 
635
LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 
636
LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
 
637
                             LLVMValueRef ConstantIfTrue,
 
638
                             LLVMValueRef ConstantIfFalse);
 
639
LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
 
640
                                     LLVMValueRef IndexConstant);
 
641
LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
 
642
                                    LLVMValueRef ElementValueConstant,
 
643
                                    LLVMValueRef IndexConstant);
 
644
LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
 
645
                                    LLVMValueRef VectorBConstant,
 
646
                                    LLVMValueRef MaskConstant);
 
647
LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList,
 
648
                                   unsigned NumIdx);
 
649
LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant,
 
650
                                  LLVMValueRef ElementValueConstant,
 
651
                                  unsigned *IdxList, unsigned NumIdx);
 
652
LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty,
 
653
                                const char *AsmString, const char *Constraints,
 
654
                                LLVMBool HasSideEffects, LLVMBool IsAlignStack);
 
655
LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB);
 
656
 
 
657
/* Operations on global variables, functions, and aliases (globals) */
 
658
LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global);
 
659
LLVMBool LLVMIsDeclaration(LLVMValueRef Global);
 
660
LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
 
661
void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
 
662
const char *LLVMGetSection(LLVMValueRef Global);
 
663
void LLVMSetSection(LLVMValueRef Global, const char *Section);
 
664
LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
 
665
void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
 
666
unsigned LLVMGetAlignment(LLVMValueRef Global);
 
667
void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
 
668
 
 
669
/* Operations on global variables */
 
670
LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
 
671
LLVMValueRef LLVMAddGlobalInAddressSpace(LLVMModuleRef M, LLVMTypeRef Ty,
 
672
                                         const char *Name,
 
673
                                         unsigned AddressSpace);
 
674
LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
 
675
LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M);
 
676
LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M);
 
677
LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar);
 
678
LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar);
 
679
void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
 
680
LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
 
681
void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
 
682
LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar);
 
683
void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal);
 
684
LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
 
685
void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant);
 
686
 
 
687
/* Operations on aliases */
 
688
LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee,
 
689
                          const char *Name);
 
690
 
 
691
/* Operations on functions */
 
692
LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
 
693
                             LLVMTypeRef FunctionTy);
 
694
LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
 
695
LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M);
 
696
LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M);
 
697
LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn);
 
698
LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn);
 
699
void LLVMDeleteFunction(LLVMValueRef Fn);
 
700
unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
 
701
unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
 
702
void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
 
703
const char *LLVMGetGC(LLVMValueRef Fn);
 
704
void LLVMSetGC(LLVMValueRef Fn, const char *Name);
 
705
void LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
 
706
LLVMAttribute LLVMGetFunctionAttr(LLVMValueRef Fn);
 
707
void LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
 
708
 
 
709
/* Operations on parameters */
 
710
unsigned LLVMCountParams(LLVMValueRef Fn);
 
711
void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
 
712
LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
 
713
LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst);
 
714
LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn);
 
715
LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn);
 
716
LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg);
 
717
LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg);
 
718
void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA);
 
719
void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA);
 
720
LLVMAttribute LLVMGetAttribute(LLVMValueRef Arg);
 
721
void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align);
 
722
 
 
723
/* Operations on basic blocks */
 
724
LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB);
 
725
LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val);
 
726
LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
 
727
LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB);
 
728
unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
 
729
void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
 
730
LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn);
 
731
LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn);
 
732
LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB);
 
733
LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB);
 
734
LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
 
735
 
 
736
LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C,
 
737
                                                LLVMValueRef Fn,
 
738
                                                const char *Name);
 
739
LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C,
 
740
                                                LLVMBasicBlockRef BB,
 
741
                                                const char *Name);
 
742
 
 
743
LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
 
744
LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
 
745
                                       const char *Name);
 
746
void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
 
747
 
 
748
void LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos);
 
749
void LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos);
 
750
 
 
751
/* Operations on instructions */
 
752
LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst);
 
753
LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB);
 
754
LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB);
 
755
LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst);
 
756
LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst);
 
757
 
 
758
/* Operations on call sites */
 
759
void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC);
 
760
unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr);
 
761
void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, LLVMAttribute);
 
762
void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index, 
 
763
                              LLVMAttribute);
 
764
void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index, 
 
765
                                unsigned align);
 
766
 
 
767
/* Operations on call instructions (only) */
 
768
LLVMBool LLVMIsTailCall(LLVMValueRef CallInst);
 
769
void LLVMSetTailCall(LLVMValueRef CallInst, LLVMBool IsTailCall);
 
770
 
 
771
/* Operations on phi nodes */
 
772
void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
 
773
                     LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
 
774
unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
 
775
LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
 
776
LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
 
777
 
 
778
/*===-- Instruction builders ----------------------------------------------===*/
 
779
 
 
780
/* An instruction builder represents a point within a basic block, and is the
 
781
 * exclusive means of building instructions using the C interface.
 
782
 */
 
783
 
 
784
LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C);
 
785
LLVMBuilderRef LLVMCreateBuilder(void);
 
786
void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
 
787
                         LLVMValueRef Instr);
 
788
void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
 
789
void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
 
790
LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder);
 
791
void LLVMClearInsertionPosition(LLVMBuilderRef Builder);
 
792
void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr);
 
793
void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr,
 
794
                                   const char *Name);
 
795
void LLVMDisposeBuilder(LLVMBuilderRef Builder);
 
796
 
 
797
/* Metadata */
 
798
void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L);
 
799
LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder);
 
800
void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst);
 
801
 
 
802
/* Terminators */
 
803
LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
 
804
LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
 
805
LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals,
 
806
                                   unsigned N);
 
807
LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
 
808
LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
 
809
                             LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
 
810
LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
 
811
                             LLVMBasicBlockRef Else, unsigned NumCases);
 
812
LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr,
 
813
                                 unsigned NumDests);
 
814
LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
 
815
                             LLVMValueRef *Args, unsigned NumArgs,
 
816
                             LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
 
817
                             const char *Name);
 
818
LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
 
819
LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
 
820
 
 
821
/* Add a case to the switch instruction */
 
822
void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
 
823
                 LLVMBasicBlockRef Dest);
 
824
 
 
825
/* Add a destination to the indirectbr instruction */
 
826
void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest);
 
827
 
 
828
/* Arithmetic */
 
829
LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
830
                          const char *Name);
 
831
LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
832
                             const char *Name);
 
833
LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
834
                             const char *Name);
 
835
LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
836
                           const char *Name);
 
837
LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
838
                          const char *Name);
 
839
LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
840
                             const char *Name);
 
841
LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
842
                             const char *Name);
 
843
LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
844
                           const char *Name);
 
845
LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
846
                          const char *Name);
 
847
LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
848
                             const char *Name);
 
849
LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
850
                             const char *Name);
 
851
LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
852
                           const char *Name);
 
853
LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
854
                           const char *Name);
 
855
LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
856
                           const char *Name);
 
857
LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
858
                                const char *Name);
 
859
LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
860
                           const char *Name);
 
861
LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
862
                           const char *Name);
 
863
LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
864
                           const char *Name);
 
865
LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
866
                           const char *Name);
 
867
LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
868
                           const char *Name);
 
869
LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
870
                           const char *Name);
 
871
LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
872
                           const char *Name);
 
873
LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
874
                          const char *Name);
 
875
LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
876
                          const char *Name);
 
877
LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 
878
                          const char *Name);
 
879
LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op,
 
880
                            LLVMValueRef LHS, LLVMValueRef RHS,
 
881
                            const char *Name);
 
882
LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
 
883
LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V,
 
884
                             const char *Name);
 
885
LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V,
 
886
                             const char *Name);
 
887
LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
 
888
LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
 
889
 
 
890
/* Memory */
 
891
LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
 
892
LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
 
893
                                  LLVMValueRef Val, const char *Name);
 
894
LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
 
895
LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
 
896
                                  LLVMValueRef Val, const char *Name);
 
897
LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
 
898
LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
 
899
                           const char *Name);
 
900
LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
 
901
LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
 
902
                          LLVMValueRef *Indices, unsigned NumIndices,
 
903
                          const char *Name);
 
904
LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
 
905
                                  LLVMValueRef *Indices, unsigned NumIndices,
 
906
                                  const char *Name);
 
907
LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
 
908
                                unsigned Idx, const char *Name);
 
909
LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str,
 
910
                                   const char *Name);
 
911
LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str,
 
912
                                      const char *Name);
 
913
 
 
914
/* Casts */
 
915
LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
 
916
                            LLVMTypeRef DestTy, const char *Name);
 
917
LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
 
918
                           LLVMTypeRef DestTy, const char *Name);
 
919
LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
 
920
                           LLVMTypeRef DestTy, const char *Name);
 
921
LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
 
922
                             LLVMTypeRef DestTy, const char *Name);
 
923
LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
 
924
                             LLVMTypeRef DestTy, const char *Name);
 
925
LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
 
926
                             LLVMTypeRef DestTy, const char *Name);
 
927
LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
 
928
                             LLVMTypeRef DestTy, const char *Name);
 
929
LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
 
930
                              LLVMTypeRef DestTy, const char *Name);
 
931
LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
 
932
                            LLVMTypeRef DestTy, const char *Name);
 
933
LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
 
934
                               LLVMTypeRef DestTy, const char *Name);
 
935
LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
 
936
                               LLVMTypeRef DestTy, const char *Name);
 
937
LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
 
938
                              LLVMTypeRef DestTy, const char *Name);
 
939
LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
 
940
                                    LLVMTypeRef DestTy, const char *Name);
 
941
LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
 
942
                                    LLVMTypeRef DestTy, const char *Name);
 
943
LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
 
944
                                     LLVMTypeRef DestTy, const char *Name);
 
945
LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val,
 
946
                           LLVMTypeRef DestTy, const char *Name);
 
947
LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val,
 
948
                                  LLVMTypeRef DestTy, const char *Name);
 
949
LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val, /*Signed cast!*/
 
950
                              LLVMTypeRef DestTy, const char *Name);
 
951
LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val,
 
952
                             LLVMTypeRef DestTy, const char *Name);
 
953
 
 
954
/* Comparisons */
 
955
LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
 
956
                           LLVMValueRef LHS, LLVMValueRef RHS,
 
957
                           const char *Name);
 
958
LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
 
959
                           LLVMValueRef LHS, LLVMValueRef RHS,
 
960
                           const char *Name);
 
961
 
 
962
/* Miscellaneous instructions */
 
963
LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
 
964
LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
 
965
                           LLVMValueRef *Args, unsigned NumArgs,
 
966
                           const char *Name);
 
967
LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
 
968
                             LLVMValueRef Then, LLVMValueRef Else,
 
969
                             const char *Name);
 
970
LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
 
971
                            const char *Name);
 
972
LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
 
973
                                     LLVMValueRef Index, const char *Name);
 
974
LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
 
975
                                    LLVMValueRef EltVal, LLVMValueRef Index,
 
976
                                    const char *Name);
 
977
LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
 
978
                                    LLVMValueRef V2, LLVMValueRef Mask,
 
979
                                    const char *Name);
 
980
LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal,
 
981
                                   unsigned Index, const char *Name);
 
982
LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal,
 
983
                                  LLVMValueRef EltVal, unsigned Index,
 
984
                                  const char *Name);
 
985
 
 
986
LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val,
 
987
                             const char *Name);
 
988
LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val,
 
989
                                const char *Name);
 
990
LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS,
 
991
                              LLVMValueRef RHS, const char *Name);
 
992
 
 
993
 
 
994
/*===-- Module providers --------------------------------------------------===*/
 
995
 
 
996
/* Changes the type of M so it can be passed to FunctionPassManagers and the
 
997
 * JIT.  They take ModuleProviders for historical reasons.
 
998
 */
 
999
LLVMModuleProviderRef
 
1000
LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
 
1001
 
 
1002
/* Destroys the module M.
 
1003
 */
 
1004
void LLVMDisposeModuleProvider(LLVMModuleProviderRef M);
 
1005
 
 
1006
 
 
1007
/*===-- Memory buffers ----------------------------------------------------===*/
 
1008
 
 
1009
LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
 
1010
                                                  LLVMMemoryBufferRef *OutMemBuf,
 
1011
                                                  char **OutMessage);
 
1012
LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
 
1013
                                         char **OutMessage);
 
1014
void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
 
1015
 
 
1016
 
 
1017
/*===-- Pass Managers -----------------------------------------------------===*/
 
1018
 
 
1019
/** Constructs a new whole-module pass pipeline. This type of pipeline is
 
1020
    suitable for link-time optimization and whole-module transformations.
 
1021
    See llvm::PassManager::PassManager. */
 
1022
LLVMPassManagerRef LLVMCreatePassManager(void);
 
1023
 
 
1024
/** Constructs a new function-by-function pass pipeline over the module
 
1025
    provider. It does not take ownership of the module provider. This type of
 
1026
    pipeline is suitable for code generation and JIT compilation tasks.
 
1027
    See llvm::FunctionPassManager::FunctionPassManager. */
 
1028
LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M);
 
1029
 
 
1030
/** Deprecated: Use LLVMCreateFunctionPassManagerForModule instead. */
 
1031
LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP);
 
1032
 
 
1033
/** Initializes, executes on the provided module, and finalizes all of the
 
1034
    passes scheduled in the pass manager. Returns 1 if any of the passes
 
1035
    modified the module, 0 otherwise. See llvm::PassManager::run(Module&). */
 
1036
LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M);
 
1037
 
 
1038
/** Initializes all of the function passes scheduled in the function pass
 
1039
    manager. Returns 1 if any of the passes modified the module, 0 otherwise.
 
1040
    See llvm::FunctionPassManager::doInitialization. */
 
1041
LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM);
 
1042
 
 
1043
/** Executes all of the function passes scheduled in the function pass manager
 
1044
    on the provided function. Returns 1 if any of the passes modified the
 
1045
    function, false otherwise.
 
1046
    See llvm::FunctionPassManager::run(Function&). */
 
1047
LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F);
 
1048
 
 
1049
/** Finalizes all of the function passes scheduled in in the function pass
 
1050
    manager. Returns 1 if any of the passes modified the module, 0 otherwise.
 
1051
    See llvm::FunctionPassManager::doFinalization. */
 
1052
LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM);
 
1053
 
 
1054
/** Frees the memory of a pass pipeline. For function pipelines, does not free
 
1055
    the module provider.
 
1056
    See llvm::PassManagerBase::~PassManagerBase. */
 
1057
void LLVMDisposePassManager(LLVMPassManagerRef PM);
 
1058
 
 
1059
 
 
1060
#ifdef __cplusplus
 
1061
}
 
1062
 
 
1063
namespace llvm {
 
1064
  class MemoryBuffer;
 
1065
  class PassManagerBase;
 
1066
  
 
1067
  #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)   \
 
1068
    inline ty *unwrap(ref P) {                          \
 
1069
      return reinterpret_cast<ty*>(P);                  \
 
1070
    }                                                   \
 
1071
                                                        \
 
1072
    inline ref wrap(const ty *P) {                      \
 
1073
      return reinterpret_cast<ref>(const_cast<ty*>(P)); \
 
1074
    }
 
1075
  
 
1076
  #define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref)  \
 
1077
    DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)         \
 
1078
                                                        \
 
1079
    template<typename T>                                \
 
1080
    inline T *unwrap(ref P) {                           \
 
1081
      return cast<T>(unwrap(P));                        \
 
1082
    }
 
1083
  
 
1084
  #define DEFINE_STDCXX_CONVERSION_FUNCTIONS(ty, ref)   \
 
1085
    DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)         \
 
1086
                                                        \
 
1087
    template<typename T>                                \
 
1088
    inline T *unwrap(ref P) {                           \
 
1089
      T *Q = (T*)unwrap(P);                             \
 
1090
      assert(Q && "Invalid cast!");                     \
 
1091
      return Q;                                         \
 
1092
    }
 
1093
  
 
1094
  DEFINE_ISA_CONVERSION_FUNCTIONS   (Type,               LLVMTypeRef          )
 
1095
  DEFINE_ISA_CONVERSION_FUNCTIONS   (Value,              LLVMValueRef         )
 
1096
  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module,             LLVMModuleRef        )
 
1097
  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock,         LLVMBasicBlockRef    )
 
1098
  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>,        LLVMBuilderRef       )
 
1099
  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(PATypeHolder,       LLVMTypeHandleRef    )
 
1100
  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer,       LLVMMemoryBufferRef  )
 
1101
  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMContext,        LLVMContextRef       )
 
1102
  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Use,                LLVMUseRef           )
 
1103
  DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBase,    LLVMPassManagerRef   )
 
1104
  /* LLVMModuleProviderRef exists for historical reasons, but now just holds a
 
1105
   * Module.
 
1106
   */
 
1107
  inline Module *unwrap(LLVMModuleProviderRef MP) {
 
1108
    return reinterpret_cast<Module*>(MP);
 
1109
  }
 
1110
  
 
1111
  #undef DEFINE_STDCXX_CONVERSION_FUNCTIONS
 
1112
  #undef DEFINE_ISA_CONVERSION_FUNCTIONS
 
1113
  #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS
 
1114
 
 
1115
  /* Specialized opaque context conversions.
 
1116
   */
 
1117
  inline LLVMContext **unwrap(LLVMContextRef* Tys) {
 
1118
    return reinterpret_cast<LLVMContext**>(Tys);
 
1119
  }
 
1120
  
 
1121
  inline LLVMContextRef *wrap(const LLVMContext **Tys) {
 
1122
    return reinterpret_cast<LLVMContextRef*>(const_cast<LLVMContext**>(Tys));
 
1123
  }
 
1124
  
 
1125
  /* Specialized opaque type conversions.
 
1126
   */
 
1127
  inline Type **unwrap(LLVMTypeRef* Tys) {
 
1128
    return reinterpret_cast<Type**>(Tys);
 
1129
  }
 
1130
  
 
1131
  inline LLVMTypeRef *wrap(const Type **Tys) {
 
1132
    return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
 
1133
  }
 
1134
  
 
1135
  /* Specialized opaque value conversions.
 
1136
   */ 
 
1137
  inline Value **unwrap(LLVMValueRef *Vals) {
 
1138
    return reinterpret_cast<Value**>(Vals);
 
1139
  }
 
1140
  
 
1141
  template<typename T>
 
1142
  inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
 
1143
    #if DEBUG
 
1144
    for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I)
 
1145
      cast<T>(*I);
 
1146
    #endif
 
1147
    return reinterpret_cast<T**>(Vals);
 
1148
  }
 
1149
  
 
1150
  inline LLVMValueRef *wrap(const Value **Vals) {
 
1151
    return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
 
1152
  }
 
1153
}
 
1154
 
 
1155
#endif /* !defined(__cplusplus) */
 
1156
 
 
1157
#endif /* !defined(LLVM_C_CORE_H) */