1/*===-- llvm-c/Core.h - Core Library C Interface ------------------*- C -*-===*\
2|* *|
3|* Part of the LLVM Project, under the Apache License v2.0 with LLVM *|
4|* Exceptions. *|
5|* See https://llvm.org/LICENSE.txt for license information. *|
6|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception *|
7|* *|
8|*===----------------------------------------------------------------------===*|
9|* *|
10|* This header declares the C interface to libLLVMCore.a, which implements *|
11|* the LLVM intermediate representation. *|
12|* *|
13\*===----------------------------------------------------------------------===*/
14
15#ifndef LLVM_C_CORE_H
16#define LLVM_C_CORE_H
17
18#include "llvm-c/ErrorHandling.h"
19#include "llvm-c/ExternC.h"
20#include "llvm-c/Types.h"
21
22LLVM_C_EXTERN_C_BEGIN
23
24/**
25 * @defgroup LLVMC LLVM-C: C interface to LLVM
26 *
27 * This module exposes parts of the LLVM library as a C API.
28 *
29 * @{
30 */
31
32/**
33 * @defgroup LLVMCTransforms Transforms
34 */
35
36/**
37 * @defgroup LLVMCCore Core
38 *
39 * This modules provide an interface to libLLVMCore, which implements
40 * the LLVM intermediate representation as well as other related types
41 * and utilities.
42 *
43 * Many exotic languages can interoperate with C code but have a harder time
44 * with C++ due to name mangling. So in addition to C, this interface enables
45 * tools written in such languages.
46 *
47 * @{
48 */
49
50/**
51 * @defgroup LLVMCCoreTypes Types and Enumerations
52 *
53 * @{
54 */
55
56/// External users depend on the following values being stable. It is not safe
57/// to reorder them.
58typedef enum {
59 /* Terminator Instructions */
60 LLVMRet = 1,
61 LLVMBr = 2,
62 LLVMSwitch = 3,
63 LLVMIndirectBr = 4,
64 LLVMInvoke = 5,
65 /* removed 6 due to API changes */
66 LLVMUnreachable = 7,
67 LLVMCallBr = 67,
68
69 /* Standard Unary Operators */
70 LLVMFNeg = 66,
71
72 /* Standard Binary Operators */
73 LLVMAdd = 8,
74 LLVMFAdd = 9,
75 LLVMSub = 10,
76 LLVMFSub = 11,
77 LLVMMul = 12,
78 LLVMFMul = 13,
79 LLVMUDiv = 14,
80 LLVMSDiv = 15,
81 LLVMFDiv = 16,
82 LLVMURem = 17,
83 LLVMSRem = 18,
84 LLVMFRem = 19,
85
86 /* Logical Operators */
87 LLVMShl = 20,
88 LLVMLShr = 21,
89 LLVMAShr = 22,
90 LLVMAnd = 23,
91 LLVMOr = 24,
92 LLVMXor = 25,
93
94 /* Memory Operators */
95 LLVMAlloca = 26,
96 LLVMLoad = 27,
97 LLVMStore = 28,
98 LLVMGetElementPtr = 29,
99
100 /* Cast Operators */
101 LLVMTrunc = 30,
102 LLVMZExt = 31,
103 LLVMSExt = 32,
104 LLVMFPToUI = 33,
105 LLVMFPToSI = 34,
106 LLVMUIToFP = 35,
107 LLVMSIToFP = 36,
108 LLVMFPTrunc = 37,
109 LLVMFPExt = 38,
110 LLVMPtrToInt = 39,
111 LLVMIntToPtr = 40,
112 LLVMBitCast = 41,
113 LLVMAddrSpaceCast = 60,
114
115 /* Other Operators */
116 LLVMICmp = 42,
117 LLVMFCmp = 43,
118 LLVMPHI = 44,
119 LLVMCall = 45,
120 LLVMSelect = 46,
121 LLVMUserOp1 = 47,
122 LLVMUserOp2 = 48,
123 LLVMVAArg = 49,
124 LLVMExtractElement = 50,
125 LLVMInsertElement = 51,
126 LLVMShuffleVector = 52,
127 LLVMExtractValue = 53,
128 LLVMInsertValue = 54,
129 LLVMFreeze = 68,
130
131 /* Atomic operators */
132 LLVMFence = 55,
133 LLVMAtomicCmpXchg = 56,
134 LLVMAtomicRMW = 57,
135
136 /* Exception Handling Operators */
137 LLVMResume = 58,
138 LLVMLandingPad = 59,
139 LLVMCleanupRet = 61,
140 LLVMCatchRet = 62,
141 LLVMCatchPad = 63,
142 LLVMCleanupPad = 64,
143 LLVMCatchSwitch = 65
144} LLVMOpcode;
145
146typedef enum {
147 LLVMVoidTypeKind, /**< type with no size */
148 LLVMHalfTypeKind, /**< 16 bit floating point type */
149 LLVMFloatTypeKind, /**< 32 bit floating point type */
150 LLVMDoubleTypeKind, /**< 64 bit floating point type */
151 LLVMX86_FP80TypeKind, /**< 80 bit floating point type (X87) */
152 LLVMFP128TypeKind, /**< 128 bit floating point type (112-bit mantissa)*/
153 LLVMPPC_FP128TypeKind, /**< 128 bit floating point type (two 64-bits) */
154 LLVMLabelTypeKind, /**< Labels */
155 LLVMIntegerTypeKind, /**< Arbitrary bit width integers */
156 LLVMFunctionTypeKind, /**< Functions */
157 LLVMStructTypeKind, /**< Structures */
158 LLVMArrayTypeKind, /**< Arrays */
159 LLVMPointerTypeKind, /**< Pointers */
160 LLVMVectorTypeKind, /**< Fixed width SIMD vector type */
161 LLVMMetadataTypeKind, /**< Metadata */
162 LLVMX86_MMXTypeKind, /**< X86 MMX */
163 LLVMTokenTypeKind, /**< Tokens */
164 LLVMScalableVectorTypeKind, /**< Scalable SIMD vector type */
165 LLVMBFloatTypeKind, /**< 16 bit brain floating point type */
166 LLVMX86_AMXTypeKind /**< X86 AMX */
167} LLVMTypeKind;
168
169typedef enum {
170 LLVMExternalLinkage, /**< Externally visible function */
171 LLVMAvailableExternallyLinkage,
172 LLVMLinkOnceAnyLinkage, /**< Keep one copy of function when linking (inline)*/
173 LLVMLinkOnceODRLinkage, /**< Same, but only replaced by something
174 equivalent. */
175 LLVMLinkOnceODRAutoHideLinkage, /**< Obsolete */
176 LLVMWeakAnyLinkage, /**< Keep one copy of function when linking (weak) */
177 LLVMWeakODRLinkage, /**< Same, but only replaced by something
178 equivalent. */
179 LLVMAppendingLinkage, /**< Special purpose, only applies to global arrays */
180 LLVMInternalLinkage, /**< Rename collisions when linking (static
181 functions) */
182 LLVMPrivateLinkage, /**< Like Internal, but omit from symbol table */
183 LLVMDLLImportLinkage, /**< Obsolete */
184 LLVMDLLExportLinkage, /**< Obsolete */
185 LLVMExternalWeakLinkage,/**< ExternalWeak linkage description */
186 LLVMGhostLinkage, /**< Obsolete */
187 LLVMCommonLinkage, /**< Tentative definitions */
188 LLVMLinkerPrivateLinkage, /**< Like Private, but linker removes. */
189 LLVMLinkerPrivateWeakLinkage /**< Like LinkerPrivate, but is weak. */
190} LLVMLinkage;
191
192typedef enum {
193 LLVMDefaultVisibility, /**< The GV is visible */
194 LLVMHiddenVisibility, /**< The GV is hidden */
195 LLVMProtectedVisibility /**< The GV is protected */
196} LLVMVisibility;
197
198typedef enum {
199 LLVMNoUnnamedAddr, /**< Address of the GV is significant. */
200 LLVMLocalUnnamedAddr, /**< Address of the GV is locally insignificant. */
201 LLVMGlobalUnnamedAddr /**< Address of the GV is globally insignificant. */
202} LLVMUnnamedAddr;
203
204typedef enum {
205 LLVMDefaultStorageClass = 0,
206 LLVMDLLImportStorageClass = 1, /**< Function to be imported from DLL. */
207 LLVMDLLExportStorageClass = 2 /**< Function to be accessible from DLL. */
208} LLVMDLLStorageClass;
209
210typedef enum {
211 LLVMCCallConv = 0,
212 LLVMFastCallConv = 8,
213 LLVMColdCallConv = 9,
214 LLVMGHCCallConv = 10,
215 LLVMHiPECallConv = 11,
216 LLVMWebKitJSCallConv = 12,
217 LLVMAnyRegCallConv = 13,
218 LLVMPreserveMostCallConv = 14,
219 LLVMPreserveAllCallConv = 15,
220 LLVMSwiftCallConv = 16,
221 LLVMCXXFASTTLSCallConv = 17,
222 LLVMX86StdcallCallConv = 64,
223 LLVMX86FastcallCallConv = 65,
224 LLVMARMAPCSCallConv = 66,
225 LLVMARMAAPCSCallConv = 67,
226 LLVMARMAAPCSVFPCallConv = 68,
227 LLVMMSP430INTRCallConv = 69,
228 LLVMX86ThisCallCallConv = 70,
229 LLVMPTXKernelCallConv = 71,
230 LLVMPTXDeviceCallConv = 72,
231 LLVMSPIRFUNCCallConv = 75,
232 LLVMSPIRKERNELCallConv = 76,
233 LLVMIntelOCLBICallConv = 77,
234 LLVMX8664SysVCallConv = 78,
235 LLVMWin64CallConv = 79,
236 LLVMX86VectorCallCallConv = 80,
237 LLVMHHVMCallConv = 81,
238 LLVMHHVMCCallConv = 82,
239 LLVMX86INTRCallConv = 83,
240 LLVMAVRINTRCallConv = 84,
241 LLVMAVRSIGNALCallConv = 85,
242 LLVMAVRBUILTINCallConv = 86,
243 LLVMAMDGPUVSCallConv = 87,
244 LLVMAMDGPUGSCallConv = 88,
245 LLVMAMDGPUPSCallConv = 89,
246 LLVMAMDGPUCSCallConv = 90,
247 LLVMAMDGPUKERNELCallConv = 91,
248 LLVMX86RegCallCallConv = 92,
249 LLVMAMDGPUHSCallConv = 93,
250 LLVMMSP430BUILTINCallConv = 94,
251 LLVMAMDGPULSCallConv = 95,
252 LLVMAMDGPUESCallConv = 96
253} LLVMCallConv;
254
255typedef enum {
256 LLVMArgumentValueKind,
257 LLVMBasicBlockValueKind,
258 LLVMMemoryUseValueKind,
259 LLVMMemoryDefValueKind,
260 LLVMMemoryPhiValueKind,
261
262 LLVMFunctionValueKind,
263 LLVMGlobalAliasValueKind,
264 LLVMGlobalIFuncValueKind,
265 LLVMGlobalVariableValueKind,
266 LLVMBlockAddressValueKind,
267 LLVMConstantExprValueKind,
268 LLVMConstantArrayValueKind,
269 LLVMConstantStructValueKind,
270 LLVMConstantVectorValueKind,
271
272 LLVMUndefValueValueKind,
273 LLVMConstantAggregateZeroValueKind,
274 LLVMConstantDataArrayValueKind,
275 LLVMConstantDataVectorValueKind,
276 LLVMConstantIntValueKind,
277 LLVMConstantFPValueKind,
278 LLVMConstantPointerNullValueKind,
279 LLVMConstantTokenNoneValueKind,
280
281 LLVMMetadataAsValueValueKind,
282 LLVMInlineAsmValueKind,
283
284 LLVMInstructionValueKind,
285 LLVMPoisonValueValueKind
286} LLVMValueKind;
287
288typedef enum {
289 LLVMIntEQ = 32, /**< equal */
290 LLVMIntNE, /**< not equal */
291 LLVMIntUGT, /**< unsigned greater than */
292 LLVMIntUGE, /**< unsigned greater or equal */
293 LLVMIntULT, /**< unsigned less than */
294 LLVMIntULE, /**< unsigned less or equal */
295 LLVMIntSGT, /**< signed greater than */
296 LLVMIntSGE, /**< signed greater or equal */
297 LLVMIntSLT, /**< signed less than */
298 LLVMIntSLE /**< signed less or equal */
299} LLVMIntPredicate;
300
301typedef enum {
302 LLVMRealPredicateFalse, /**< Always false (always folded) */
303 LLVMRealOEQ, /**< True if ordered and equal */
304 LLVMRealOGT, /**< True if ordered and greater than */
305 LLVMRealOGE, /**< True if ordered and greater than or equal */
306 LLVMRealOLT, /**< True if ordered and less than */
307 LLVMRealOLE, /**< True if ordered and less than or equal */
308 LLVMRealONE, /**< True if ordered and operands are unequal */
309 LLVMRealORD, /**< True if ordered (no nans) */
310 LLVMRealUNO, /**< True if unordered: isnan(X) | isnan(Y) */
311 LLVMRealUEQ, /**< True if unordered or equal */
312 LLVMRealUGT, /**< True if unordered or greater than */
313 LLVMRealUGE, /**< True if unordered, greater than, or equal */
314 LLVMRealULT, /**< True if unordered or less than */
315 LLVMRealULE, /**< True if unordered, less than, or equal */
316 LLVMRealUNE, /**< True if unordered or not equal */
317 LLVMRealPredicateTrue /**< Always true (always folded) */
318} LLVMRealPredicate;
319
320typedef enum {
321 LLVMLandingPadCatch, /**< A catch clause */
322 LLVMLandingPadFilter /**< A filter clause */
323} LLVMLandingPadClauseTy;
324
325typedef enum {
326 LLVMNotThreadLocal = 0,
327 LLVMGeneralDynamicTLSModel,
328 LLVMLocalDynamicTLSModel,
329 LLVMInitialExecTLSModel,
330 LLVMLocalExecTLSModel
331} LLVMThreadLocalMode;
332
333typedef enum {
334 LLVMAtomicOrderingNotAtomic = 0, /**< A load or store which is not atomic */
335 LLVMAtomicOrderingUnordered = 1, /**< Lowest level of atomicity, guarantees
336 somewhat sane results, lock free. */
337 LLVMAtomicOrderingMonotonic = 2, /**< guarantees that if you take all the
338 operations affecting a specific address,
339 a consistent ordering exists */
340 LLVMAtomicOrderingAcquire = 4, /**< Acquire provides a barrier of the sort
341 necessary to acquire a lock to access other
342 memory with normal loads and stores. */
343 LLVMAtomicOrderingRelease = 5, /**< Release is similar to Acquire, but with
344 a barrier of the sort necessary to release
345 a lock. */
346 LLVMAtomicOrderingAcquireRelease = 6, /**< provides both an Acquire and a
347 Release barrier (for fences and
348 operations which both read and write
349 memory). */
350 LLVMAtomicOrderingSequentiallyConsistent = 7 /**< provides Acquire semantics
351 for loads and Release
352 semantics for stores.
353 Additionally, it guarantees
354 that a total ordering exists
355 between all
356 SequentiallyConsistent
357 operations. */
358} LLVMAtomicOrdering;
359
360typedef enum {
361 LLVMAtomicRMWBinOpXchg, /**< Set the new value and return the one old */
362 LLVMAtomicRMWBinOpAdd, /**< Add a value and return the old one */
363 LLVMAtomicRMWBinOpSub, /**< Subtract a value and return the old one */
364 LLVMAtomicRMWBinOpAnd, /**< And a value and return the old one */
365 LLVMAtomicRMWBinOpNand, /**< Not-And a value and return the old one */
366 LLVMAtomicRMWBinOpOr, /**< OR a value and return the old one */
367 LLVMAtomicRMWBinOpXor, /**< Xor a value and return the old one */
368 LLVMAtomicRMWBinOpMax, /**< Sets the value if it's greater than the
369 original using a signed comparison and return
370 the old one */
371 LLVMAtomicRMWBinOpMin, /**< Sets the value if it's Smaller than the
372 original using a signed comparison and return
373 the old one */
374 LLVMAtomicRMWBinOpUMax, /**< Sets the value if it's greater than the
375 original using an unsigned comparison and return
376 the old one */
377 LLVMAtomicRMWBinOpUMin, /**< Sets the value if it's greater than the
378 original using an unsigned comparison and return
379 the old one */
380 LLVMAtomicRMWBinOpFAdd, /**< Add a floating point value and return the
381 old one */
382 LLVMAtomicRMWBinOpFSub /**< Subtract a floating point value and return the
383 old one */
384} LLVMAtomicRMWBinOp;
385
386typedef enum {
387 LLVMDSError,
388 LLVMDSWarning,
389 LLVMDSRemark,
390 LLVMDSNote
391} LLVMDiagnosticSeverity;
392
393typedef enum {
394 LLVMInlineAsmDialectATT,
395 LLVMInlineAsmDialectIntel
396} LLVMInlineAsmDialect;
397
398typedef enum {
399 /**
400 * Emits an error if two values disagree, otherwise the resulting value is
401 * that of the operands.
402 *
403 * @see Module::ModFlagBehavior::Error
404 */
405 LLVMModuleFlagBehaviorError,
406 /**
407 * Emits a warning if two values disagree. The result value will be the
408 * operand for the flag from the first module being linked.
409 *
410 * @see Module::ModFlagBehavior::Warning
411 */
412 LLVMModuleFlagBehaviorWarning,
413 /**
414 * Adds a requirement that another module flag be present and have a
415 * specified value after linking is performed. The value must be a metadata
416 * pair, where the first element of the pair is the ID of the module flag
417 * to be restricted, and the second element of the pair is the value the
418 * module flag should be restricted to. This behavior can be used to
419 * restrict the allowable results (via triggering of an error) of linking
420 * IDs with the **Override** behavior.
421 *
422 * @see Module::ModFlagBehavior::Require
423 */
424 LLVMModuleFlagBehaviorRequire,
425 /**
426 * Uses the specified value, regardless of the behavior or value of the
427 * other module. If both modules specify **Override**, but the values
428 * differ, an error will be emitted.
429 *
430 * @see Module::ModFlagBehavior::Override
431 */
432 LLVMModuleFlagBehaviorOverride,
433 /**
434 * Appends the two values, which are required to be metadata nodes.
435 *
436 * @see Module::ModFlagBehavior::Append
437 */
438 LLVMModuleFlagBehaviorAppend,
439 /**
440 * Appends the two values, which are required to be metadata
441 * nodes. However, duplicate entries in the second list are dropped
442 * during the append operation.
443 *
444 * @see Module::ModFlagBehavior::AppendUnique
445 */
446 LLVMModuleFlagBehaviorAppendUnique,
447} LLVMModuleFlagBehavior;
448
449/**
450 * Attribute index are either LLVMAttributeReturnIndex,
451 * LLVMAttributeFunctionIndex or a parameter number from 1 to N.
452 */
453enum {
454 LLVMAttributeReturnIndex = 0U,
455 // ISO C restricts enumerator values to range of 'int'
456 // (4294967295 is too large)
457 // LLVMAttributeFunctionIndex = ~0U,
458 LLVMAttributeFunctionIndex = -1,
459};
460
461typedef unsigned LLVMAttributeIndex;
462
463/**
464 * @}
465 */
466
467void LLVMInitializeCore(LLVMPassRegistryRef R);
468
469/** Deallocate and destroy all ManagedStatic variables.
470 @see llvm::llvm_shutdown
471 @see ManagedStatic */
472void LLVMShutdown(void);
473
474/*===-- Error handling ----------------------------------------------------===*/
475
476char *LLVMCreateMessage(const char *Message);
477void LLVMDisposeMessage(char *Message);
478
479/**
480 * @defgroup LLVMCCoreContext Contexts
481 *
482 * Contexts are execution states for the core LLVM IR system.
483 *
484 * Most types are tied to a context instance. Multiple contexts can
485 * exist simultaneously. A single context is not thread safe. However,
486 * different contexts can execute on different threads simultaneously.
487 *
488 * @{
489 */
490
491typedef void (*LLVMDiagnosticHandler)(LLVMDiagnosticInfoRef, void *);
492typedef void (*LLVMYieldCallback)(LLVMContextRef, void *);
493
494/**
495 * Create a new context.
496 *
497 * Every call to this function should be paired with a call to
498 * LLVMContextDispose() or the context will leak memory.
499 */
500LLVMContextRef LLVMContextCreate(void);
501
502/**
503 * Obtain the global context instance.
504 */
505LLVMContextRef LLVMGetGlobalContext(void);
506
507/**
508 * Set the diagnostic handler for this context.
509 */
510void LLVMContextSetDiagnosticHandler(LLVMContextRef C,
511 LLVMDiagnosticHandler Handler,
512 void *DiagnosticContext);
513
514/**
515 * Get the diagnostic handler of this context.
516 */
517LLVMDiagnosticHandler LLVMContextGetDiagnosticHandler(LLVMContextRef C);
518
519/**
520 * Get the diagnostic context of this context.
521 */
522void *LLVMContextGetDiagnosticContext(LLVMContextRef C);
523
524/**
525 * Set the yield callback function for this context.
526 *
527 * @see LLVMContext::setYieldCallback()
528 */
529void LLVMContextSetYieldCallback(LLVMContextRef C, LLVMYieldCallback Callback,
530 void *OpaqueHandle);
531
532/**
533 * Retrieve whether the given context is set to discard all value names.
534 *
535 * @see LLVMContext::shouldDiscardValueNames()
536 */
537LLVMBool LLVMContextShouldDiscardValueNames(LLVMContextRef C);
538
539/**
540 * Set whether the given context discards all value names.
541 *
542 * If true, only the names of GlobalValue objects will be available in the IR.
543 * This can be used to save memory and runtime, especially in release mode.
544 *
545 * @see LLVMContext::setDiscardValueNames()
546 */
547void LLVMContextSetDiscardValueNames(LLVMContextRef C, LLVMBool Discard);
548
549/**
550 * Destroy a context instance.
551 *
552 * This should be called for every call to LLVMContextCreate() or memory
553 * will be leaked.
554 */
555void LLVMContextDispose(LLVMContextRef C);
556
557/**
558 * Return a string representation of the DiagnosticInfo. Use
559 * LLVMDisposeMessage to free the string.
560 *
561 * @see DiagnosticInfo::print()
562 */
563char *LLVMGetDiagInfoDescription(LLVMDiagnosticInfoRef DI);
564
565/**
566 * Return an enum LLVMDiagnosticSeverity.
567 *
568 * @see DiagnosticInfo::getSeverity()
569 */
570LLVMDiagnosticSeverity LLVMGetDiagInfoSeverity(LLVMDiagnosticInfoRef DI);
571
572unsigned LLVMGetMDKindIDInContext(LLVMContextRef C, const char *Name,
573 unsigned SLen);
574unsigned LLVMGetMDKindID(const char *Name, unsigned SLen);
575
576/**
577 * Return an unique id given the name of a enum attribute,
578 * or 0 if no attribute by that name exists.
579 *
580 * See http://llvm.org/docs/LangRef.html#parameter-attributes
581 * and http://llvm.org/docs/LangRef.html#function-attributes
582 * for the list of available attributes.
583 *
584 * NB: Attribute names and/or id are subject to change without
585 * going through the C API deprecation cycle.
586 */
587unsigned LLVMGetEnumAttributeKindForName(const char *Name, size_t SLen);
588unsigned LLVMGetLastEnumAttributeKind(void);
589
590/**
591 * Create an enum attribute.
592 */
593LLVMAttributeRef LLVMCreateEnumAttribute(LLVMContextRef C, unsigned KindID,
594 uint64_t Val);
595
596/**
597 * Get the unique id corresponding to the enum attribute
598 * passed as argument.
599 */
600unsigned LLVMGetEnumAttributeKind(LLVMAttributeRef A);
601
602/**
603 * Get the enum attribute's value. 0 is returned if none exists.
604 */
605uint64_t LLVMGetEnumAttributeValue(LLVMAttributeRef A);
606
607/**
608 * Create a type attribute
609 */
610LLVMAttributeRef LLVMCreateTypeAttribute(LLVMContextRef C, unsigned KindID,
611 LLVMTypeRef type_ref);
612
613/**
614 * Get the type attribute's value.
615 */
616LLVMTypeRef LLVMGetTypeAttributeValue(LLVMAttributeRef A);
617
618/**
619 * Create a string attribute.
620 */
621LLVMAttributeRef LLVMCreateStringAttribute(LLVMContextRef C,
622 const char *K, unsigned KLength,
623 const char *V, unsigned VLength);
624
625/**
626 * Get the string attribute's kind.
627 */
628const char *LLVMGetStringAttributeKind(LLVMAttributeRef A, unsigned *Length);
629
630/**
631 * Get the string attribute's value.
632 */
633const char *LLVMGetStringAttributeValue(LLVMAttributeRef A, unsigned *Length);
634
635/**
636 * Check for the different types of attributes.
637 */
638LLVMBool LLVMIsEnumAttribute(LLVMAttributeRef A);
639LLVMBool LLVMIsStringAttribute(LLVMAttributeRef A);
640LLVMBool LLVMIsTypeAttribute(LLVMAttributeRef A);
641
642/**
643 * Obtain a Type from a context by its registered name.
644 */
645LLVMTypeRef LLVMGetTypeByName2(LLVMContextRef C, const char *Name);
646
647/**
648 * @}
649 */
650
651/**
652 * @defgroup LLVMCCoreModule Modules
653 *
654 * Modules represent the top-level structure in an LLVM program. An LLVM
655 * module is effectively a translation unit or a collection of
656 * translation units merged together.
657 *
658 * @{
659 */
660
661/**
662 * Create a new, empty module in the global context.
663 *
664 * This is equivalent to calling LLVMModuleCreateWithNameInContext with
665 * LLVMGetGlobalContext() as the context parameter.
666 *
667 * Every invocation should be paired with LLVMDisposeModule() or memory
668 * will be leaked.
669 */
670LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
671
672/**
673 * Create a new, empty module in a specific context.
674 *
675 * Every invocation should be paired with LLVMDisposeModule() or memory
676 * will be leaked.
677 */
678LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID,
679 LLVMContextRef C);
680/**
681 * Return an exact copy of the specified module.
682 */
683LLVMModuleRef LLVMCloneModule(LLVMModuleRef M);
684
685/**
686 * Destroy a module instance.
687 *
688 * This must be called for every created module or memory will be
689 * leaked.
690 */
691void LLVMDisposeModule(LLVMModuleRef M);
692
693/**
694 * Obtain the identifier of a module.
695 *
696 * @param M Module to obtain identifier of
697 * @param Len Out parameter which holds the length of the returned string.
698 * @return The identifier of M.
699 * @see Module::getModuleIdentifier()
700 */
701const char *LLVMGetModuleIdentifier(LLVMModuleRef M, size_t *Len);
702
703/**
704 * Set the identifier of a module to a string Ident with length Len.
705 *
706 * @param M The module to set identifier
707 * @param Ident The string to set M's identifier to
708 * @param Len Length of Ident
709 * @see Module::setModuleIdentifier()
710 */
711void LLVMSetModuleIdentifier(LLVMModuleRef M, const char *Ident, size_t Len);
712
713/**
714 * Obtain the module's original source file name.
715 *
716 * @param M Module to obtain the name of
717 * @param Len Out parameter which holds the length of the returned string
718 * @return The original source file name of M
719 * @see Module::getSourceFileName()
720 */
721const char *LLVMGetSourceFileName(LLVMModuleRef M, size_t *Len);
722
723/**
724 * Set the original source file name of a module to a string Name with length
725 * Len.
726 *
727 * @param M The module to set the source file name of
728 * @param Name The string to set M's source file name to
729 * @param Len Length of Name
730 * @see Module::setSourceFileName()
731 */
732void LLVMSetSourceFileName(LLVMModuleRef M, const char *Name, size_t Len);
733
734/**
735 * Obtain the data layout for a module.
736 *
737 * @see Module::getDataLayoutStr()
738 *
739 * LLVMGetDataLayout is DEPRECATED, as the name is not only incorrect,
740 * but match the name of another method on the module. Prefer the use
741 * of LLVMGetDataLayoutStr, which is not ambiguous.
742 */
743const char *LLVMGetDataLayoutStr(LLVMModuleRef M);
744const char *LLVMGetDataLayout(LLVMModuleRef M);
745
746/**
747 * Set the data layout for a module.
748 *
749 * @see Module::setDataLayout()
750 */
751void LLVMSetDataLayout(LLVMModuleRef M, const char *DataLayoutStr);
752
753/**
754 * Obtain the target triple for a module.
755 *
756 * @see Module::getTargetTriple()
757 */
758const char *LLVMGetTarget(LLVMModuleRef M);
759
760/**
761 * Set the target triple for a module.
762 *
763 * @see Module::setTargetTriple()
764 */
765void LLVMSetTarget(LLVMModuleRef M, const char *Triple);
766
767/**
768 * Returns the module flags as an array of flag-key-value triples. The caller
769 * is responsible for freeing this array by calling
770 * \c LLVMDisposeModuleFlagsMetadata.
771 *
772 * @see Module::getModuleFlagsMetadata()
773 */
774LLVMModuleFlagEntry *LLVMCopyModuleFlagsMetadata(LLVMModuleRef M, size_t *Len);
775
776/**
777 * Destroys module flags metadata entries.
778 */
779void LLVMDisposeModuleFlagsMetadata(LLVMModuleFlagEntry *Entries);
780
781/**
782 * Returns the flag behavior for a module flag entry at a specific index.
783 *
784 * @see Module::ModuleFlagEntry::Behavior
785 */
786LLVMModuleFlagBehavior
787LLVMModuleFlagEntriesGetFlagBehavior(LLVMModuleFlagEntry *Entries,
788 unsigned Index);
789
790/**
791 * Returns the key for a module flag entry at a specific index.
792 *
793 * @see Module::ModuleFlagEntry::Key
794 */
795const char *LLVMModuleFlagEntriesGetKey(LLVMModuleFlagEntry *Entries,
796 unsigned Index, size_t *Len);
797
798/**
799 * Returns the metadata for a module flag entry at a specific index.
800 *
801 * @see Module::ModuleFlagEntry::Val
802 */
803LLVMMetadataRef LLVMModuleFlagEntriesGetMetadata(LLVMModuleFlagEntry *Entries,
804 unsigned Index);
805
806/**
807 * Add a module-level flag to the module-level flags metadata if it doesn't
808 * already exist.
809 *
810 * @see Module::getModuleFlag()
811 */
812LLVMMetadataRef LLVMGetModuleFlag(LLVMModuleRef M,
813 const char *Key, size_t KeyLen);
814
815/**
816 * Add a module-level flag to the module-level flags metadata if it doesn't
817 * already exist.
818 *
819 * @see Module::addModuleFlag()
820 */
821void LLVMAddModuleFlag(LLVMModuleRef M, LLVMModuleFlagBehavior Behavior,
822 const char *Key, size_t KeyLen,
823 LLVMMetadataRef Val);
824
825/**
826 * Dump a representation of a module to stderr.
827 *
828 * @see Module::dump()
829 */
830void LLVMDumpModule(LLVMModuleRef M);
831
832/**
833 * Print a representation of a module to a file. The ErrorMessage needs to be
834 * disposed with LLVMDisposeMessage. Returns 0 on success, 1 otherwise.
835 *
836 * @see Module::print()
837 */
838LLVMBool LLVMPrintModuleToFile(LLVMModuleRef M, const char *Filename,
839 char **ErrorMessage);
840
841/**
842 * Return a string representation of the module. Use
843 * LLVMDisposeMessage to free the string.
844 *
845 * @see Module::print()
846 */
847char *LLVMPrintModuleToString(LLVMModuleRef M);
848
849/**
850 * Get inline assembly for a module.
851 *
852 * @see Module::getModuleInlineAsm()
853 */
854const char *LLVMGetModuleInlineAsm(LLVMModuleRef M, size_t *Len);
855
856/**
857 * Set inline assembly for a module.
858 *
859 * @see Module::setModuleInlineAsm()
860 */
861void LLVMSetModuleInlineAsm2(LLVMModuleRef M, const char *Asm, size_t Len);
862
863/**
864 * Append inline assembly to a module.
865 *
866 * @see Module::appendModuleInlineAsm()
867 */
868void LLVMAppendModuleInlineAsm(LLVMModuleRef M, const char *Asm, size_t Len);
869
870/**
871 * Create the specified uniqued inline asm string.
872 *
873 * @see InlineAsm::get()
874 */
875LLVMValueRef LLVMGetInlineAsm(LLVMTypeRef Ty,
876 char *AsmString, size_t AsmStringSize,
877 char *Constraints, size_t ConstraintsSize,
878 LLVMBool HasSideEffects, LLVMBool IsAlignStack,
879 LLVMInlineAsmDialect Dialect);
880
881/**
882 * Obtain the context to which this module is associated.
883 *
884 * @see Module::getContext()
885 */
886LLVMContextRef LLVMGetModuleContext(LLVMModuleRef M);
887
888/** Deprecated: Use LLVMGetTypeByName2 instead. */
889LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name);
890
891/**
892 * Obtain an iterator to the first NamedMDNode in a Module.
893 *
894 * @see llvm::Module::named_metadata_begin()
895 */
896LLVMNamedMDNodeRef LLVMGetFirstNamedMetadata(LLVMModuleRef M);
897
898/**
899 * Obtain an iterator to the last NamedMDNode in a Module.
900 *
901 * @see llvm::Module::named_metadata_end()
902 */
903LLVMNamedMDNodeRef LLVMGetLastNamedMetadata(LLVMModuleRef M);
904
905/**
906 * Advance a NamedMDNode iterator to the next NamedMDNode.
907 *
908 * Returns NULL if the iterator was already at the end and there are no more
909 * named metadata nodes.
910 */
911LLVMNamedMDNodeRef LLVMGetNextNamedMetadata(LLVMNamedMDNodeRef NamedMDNode);
912
913/**
914 * Decrement a NamedMDNode iterator to the previous NamedMDNode.
915 *
916 * Returns NULL if the iterator was already at the beginning and there are
917 * no previous named metadata nodes.
918 */
919LLVMNamedMDNodeRef LLVMGetPreviousNamedMetadata(LLVMNamedMDNodeRef NamedMDNode);
920
921/**
922 * Retrieve a NamedMDNode with the given name, returning NULL if no such
923 * node exists.
924 *
925 * @see llvm::Module::getNamedMetadata()
926 */
927LLVMNamedMDNodeRef LLVMGetNamedMetadata(LLVMModuleRef M,
928 const char *Name, size_t NameLen);
929
930/**
931 * Retrieve a NamedMDNode with the given name, creating a new node if no such
932 * node exists.
933 *
934 * @see llvm::Module::getOrInsertNamedMetadata()
935 */
936LLVMNamedMDNodeRef LLVMGetOrInsertNamedMetadata(LLVMModuleRef M,
937 const char *Name,
938 size_t NameLen);
939
940/**
941 * Retrieve the name of a NamedMDNode.
942 *
943 * @see llvm::NamedMDNode::getName()
944 */
945const char *LLVMGetNamedMetadataName(LLVMNamedMDNodeRef NamedMD,
946 size_t *NameLen);
947
948/**
949 * Obtain the number of operands for named metadata in a module.
950 *
951 * @see llvm::Module::getNamedMetadata()
952 */
953unsigned LLVMGetNamedMetadataNumOperands(LLVMModuleRef M, const char *Name);
954
955/**
956 * Obtain the named metadata operands for a module.
957 *
958 * The passed LLVMValueRef pointer should refer to an array of
959 * LLVMValueRef at least LLVMGetNamedMetadataNumOperands long. This
960 * array will be populated with the LLVMValueRef instances. Each
961 * instance corresponds to a llvm::MDNode.
962 *
963 * @see llvm::Module::getNamedMetadata()
964 * @see llvm::MDNode::getOperand()
965 */
966void LLVMGetNamedMetadataOperands(LLVMModuleRef M, const char *Name,
967 LLVMValueRef *Dest);
968
969/**
970 * Add an operand to named metadata.
971 *
972 * @see llvm::Module::getNamedMetadata()
973 * @see llvm::MDNode::addOperand()
974 */
975void LLVMAddNamedMetadataOperand(LLVMModuleRef M, const char *Name,
976 LLVMValueRef Val);
977
978/**
979 * Return the directory of the debug location for this value, which must be
980 * an llvm::Instruction, llvm::GlobalVariable, or llvm::Function.
981 *
982 * @see llvm::Instruction::getDebugLoc()
983 * @see llvm::GlobalVariable::getDebugInfo()
984 * @see llvm::Function::getSubprogram()
985 */
986const char *LLVMGetDebugLocDirectory(LLVMValueRef Val, unsigned *Length);
987
988/**
989 * Return the filename of the debug location for this value, which must be
990 * an llvm::Instruction, llvm::GlobalVariable, or llvm::Function.
991 *
992 * @see llvm::Instruction::getDebugLoc()
993 * @see llvm::GlobalVariable::getDebugInfo()
994 * @see llvm::Function::getSubprogram()
995 */
996const char *LLVMGetDebugLocFilename(LLVMValueRef Val, unsigned *Length);
997
998/**
999 * Return the line number of the debug location for this value, which must be
1000 * an llvm::Instruction, llvm::GlobalVariable, or llvm::Function.
1001 *
1002 * @see llvm::Instruction::getDebugLoc()
1003 * @see llvm::GlobalVariable::getDebugInfo()
1004 * @see llvm::Function::getSubprogram()
1005 */
1006unsigned LLVMGetDebugLocLine(LLVMValueRef Val);
1007
1008/**
1009 * Return the column number of the debug location for this value, which must be
1010 * an llvm::Instruction.
1011 *
1012 * @see llvm::Instruction::getDebugLoc()
1013 */
1014unsigned LLVMGetDebugLocColumn(LLVMValueRef Val);
1015
1016/**
1017 * Add a function to a module under a specified name.
1018 *
1019 * @see llvm::Function::Create()
1020 */
1021LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
1022 LLVMTypeRef FunctionTy);
1023
1024/**
1025 * Obtain a Function value from a Module by its name.
1026 *
1027 * The returned value corresponds to a llvm::Function value.
1028 *
1029 * @see llvm::Module::getFunction()
1030 */
1031LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
1032
1033/**
1034 * Obtain an iterator to the first Function in a Module.
1035 *
1036 * @see llvm::Module::begin()
1037 */
1038LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M);
1039
1040/**
1041 * Obtain an iterator to the last Function in a Module.
1042 *
1043 * @see llvm::Module::end()
1044 */
1045LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M);
1046
1047/**
1048 * Advance a Function iterator to the next Function.
1049 *
1050 * Returns NULL if the iterator was already at the end and there are no more
1051 * functions.
1052 */
1053LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn);
1054
1055/**
1056 * Decrement a Function iterator to the previous Function.
1057 *
1058 * Returns NULL if the iterator was already at the beginning and there are
1059 * no previous functions.
1060 */
1061LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn);
1062
1063/** Deprecated: Use LLVMSetModuleInlineAsm2 instead. */
1064void LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm);
1065
1066/**
1067 * @}
1068 */
1069
1070/**
1071 * @defgroup LLVMCCoreType Types
1072 *
1073 * Types represent the type of a value.
1074 *
1075 * Types are associated with a context instance. The context internally
1076 * deduplicates types so there is only 1 instance of a specific type
1077 * alive at a time. In other words, a unique type is shared among all
1078 * consumers within a context.
1079 *
1080 * A Type in the C API corresponds to llvm::Type.
1081 *
1082 * Types have the following hierarchy:
1083 *
1084 * types:
1085 * integer type
1086 * real type
1087 * function type
1088 * sequence types:
1089 * array type
1090 * pointer type
1091 * vector type
1092 * void type
1093 * label type
1094 * opaque type
1095 *
1096 * @{
1097 */
1098
1099/**
1100 * Obtain the enumerated type of a Type instance.
1101 *
1102 * @see llvm::Type:getTypeID()
1103 */
1104LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
1105
1106/**
1107 * Whether the type has a known size.
1108 *
1109 * Things that don't have a size are abstract types, labels, and void.a
1110 *
1111 * @see llvm::Type::isSized()
1112 */
1113LLVMBool LLVMTypeIsSized(LLVMTypeRef Ty);
1114
1115/**
1116 * Obtain the context to which this type instance is associated.
1117 *
1118 * @see llvm::Type::getContext()
1119 */
1120LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty);
1121
1122/**
1123 * Dump a representation of a type to stderr.
1124 *
1125 * @see llvm::Type::dump()
1126 */
1127void LLVMDumpType(LLVMTypeRef Val);
1128
1129/**
1130 * Return a string representation of the type. Use
1131 * LLVMDisposeMessage to free the string.
1132 *
1133 * @see llvm::Type::print()
1134 */
1135char *LLVMPrintTypeToString(LLVMTypeRef Val);
1136
1137/**
1138 * @defgroup LLVMCCoreTypeInt Integer Types
1139 *
1140 * Functions in this section operate on integer types.
1141 *
1142 * @{
1143 */
1144
1145/**
1146 * Obtain an integer type from a context with specified bit width.
1147 */
1148LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C);
1149LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C);
1150LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C);
1151LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C);
1152LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C);
1153LLVMTypeRef LLVMInt128TypeInContext(LLVMContextRef C);
1154LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits);
1155
1156/**
1157 * Obtain an integer type from the global context with a specified bit
1158 * width.
1159 */
1160LLVMTypeRef LLVMInt1Type(void);
1161LLVMTypeRef LLVMInt8Type(void);
1162LLVMTypeRef LLVMInt16Type(void);
1163LLVMTypeRef LLVMInt32Type(void);
1164LLVMTypeRef LLVMInt64Type(void);
1165LLVMTypeRef LLVMInt128Type(void);
1166LLVMTypeRef LLVMIntType(unsigned NumBits);
1167unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
1168
1169/**
1170 * @}
1171 */
1172
1173/**
1174 * @defgroup LLVMCCoreTypeFloat Floating Point Types
1175 *
1176 * @{
1177 */
1178
1179/**
1180 * Obtain a 16-bit floating point type from a context.
1181 */
1182LLVMTypeRef LLVMHalfTypeInContext(LLVMContextRef C);
1183
1184/**
1185 * Obtain a 16-bit brain floating point type from a context.
1186 */
1187LLVMTypeRef LLVMBFloatTypeInContext(LLVMContextRef C);
1188
1189/**
1190 * Obtain a 32-bit floating point type from a context.
1191 */
1192LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C);
1193
1194/**
1195 * Obtain a 64-bit floating point type from a context.
1196 */
1197LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C);
1198
1199/**
1200 * Obtain a 80-bit floating point type (X87) from a context.
1201 */
1202LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C);
1203
1204/**
1205 * Obtain a 128-bit floating point type (112-bit mantissa) from a
1206 * context.
1207 */
1208LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C);
1209
1210/**
1211 * Obtain a 128-bit floating point type (two 64-bits) from a context.
1212 */
1213LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C);
1214
1215/**
1216 * Obtain a floating point type from the global context.
1217 *
1218 * These map to the functions in this group of the same name.
1219 */
1220LLVMTypeRef LLVMHalfType(void);
1221LLVMTypeRef LLVMBFloatType(void);
1222LLVMTypeRef LLVMFloatType(void);
1223LLVMTypeRef LLVMDoubleType(void);
1224LLVMTypeRef LLVMX86FP80Type(void);
1225LLVMTypeRef LLVMFP128Type(void);
1226LLVMTypeRef LLVMPPCFP128Type(void);
1227
1228/**
1229 * @}
1230 */
1231
1232/**
1233 * @defgroup LLVMCCoreTypeFunction Function Types
1234 *
1235 * @{
1236 */
1237
1238/**
1239 * Obtain a function type consisting of a specified signature.
1240 *
1241 * The function is defined as a tuple of a return Type, a list of
1242 * parameter types, and whether the function is variadic.
1243 */
1244LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
1245 LLVMTypeRef *ParamTypes, unsigned ParamCount,
1246 LLVMBool IsVarArg);
1247
1248/**
1249 * Returns whether a function type is variadic.
1250 */
1251LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
1252
1253/**
1254 * Obtain the Type this function Type returns.
1255 */
1256LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
1257
1258/**
1259 * Obtain the number of parameters this function accepts.
1260 */
1261unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
1262
1263/**
1264 * Obtain the types of a function's parameters.
1265 *
1266 * The Dest parameter should point to a pre-allocated array of
1267 * LLVMTypeRef at least LLVMCountParamTypes() large. On return, the
1268 * first LLVMCountParamTypes() entries in the array will be populated
1269 * with LLVMTypeRef instances.
1270 *
1271 * @param FunctionTy The function type to operate on.
1272 * @param Dest Memory address of an array to be filled with result.
1273 */
1274void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
1275
1276/**
1277 * @}
1278 */
1279
1280/**
1281 * @defgroup LLVMCCoreTypeStruct Structure Types
1282 *
1283 * These functions relate to LLVMTypeRef instances.
1284 *
1285 * @see llvm::StructType
1286 *
1287 * @{
1288 */
1289
1290/**
1291 * Create a new structure type in a context.
1292 *
1293 * A structure is specified by a list of inner elements/types and
1294 * whether these can be packed together.
1295 *
1296 * @see llvm::StructType::create()
1297 */
1298LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes,
1299 unsigned ElementCount, LLVMBool Packed);
1300
1301/**
1302 * Create a new structure type in the global context.
1303 *
1304 * @see llvm::StructType::create()
1305 */
1306LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
1307 LLVMBool Packed);
1308
1309/**
1310 * Create an empty structure in a context having a specified name.
1311 *
1312 * @see llvm::StructType::create()
1313 */
1314LLVMTypeRef LLVMStructCreateNamed(LLVMContextRef C, const char *Name);
1315
1316/**
1317 * Obtain the name of a structure.
1318 *
1319 * @see llvm::StructType::getName()
1320 */
1321const char *LLVMGetStructName(LLVMTypeRef Ty);
1322
1323/**
1324 * Set the contents of a structure type.
1325 *
1326 * @see llvm::StructType::setBody()
1327 */
1328void LLVMStructSetBody(LLVMTypeRef StructTy, LLVMTypeRef *ElementTypes,
1329 unsigned ElementCount, LLVMBool Packed);
1330
1331/**
1332 * Get the number of elements defined inside the structure.
1333 *
1334 * @see llvm::StructType::getNumElements()
1335 */
1336unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
1337
1338/**
1339 * Get the elements within a structure.
1340 *
1341 * The function is passed the address of a pre-allocated array of
1342 * LLVMTypeRef at least LLVMCountStructElementTypes() long. After
1343 * invocation, this array will be populated with the structure's
1344 * elements. The objects in the destination array will have a lifetime
1345 * of the structure type itself, which is the lifetime of the context it
1346 * is contained in.
1347 */
1348void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
1349
1350/**
1351 * Get the type of the element at a given index in the structure.
1352 *
1353 * @see llvm::StructType::getTypeAtIndex()
1354 */
1355LLVMTypeRef LLVMStructGetTypeAtIndex(LLVMTypeRef StructTy, unsigned i);
1356
1357/**
1358 * Determine whether a structure is packed.
1359 *
1360 * @see llvm::StructType::isPacked()
1361 */
1362LLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy);
1363
1364/**
1365 * Determine whether a structure is opaque.
1366 *
1367 * @see llvm::StructType::isOpaque()
1368 */
1369LLVMBool LLVMIsOpaqueStruct(LLVMTypeRef StructTy);
1370
1371/**
1372 * Determine whether a structure is literal.
1373 *
1374 * @see llvm::StructType::isLiteral()
1375 */
1376LLVMBool LLVMIsLiteralStruct(LLVMTypeRef StructTy);
1377
1378/**
1379 * @}
1380 */
1381
1382/**
1383 * @defgroup LLVMCCoreTypeSequential Sequential Types
1384 *
1385 * Sequential types represents "arrays" of types. This is a super class
1386 * for array, vector, and pointer types.
1387 *
1388 * @{
1389 */
1390
1391/**
1392 * Obtain the type of elements within a sequential type.
1393 *
1394 * This works on array, vector, and pointer types.
1395 *
1396 * @see llvm::SequentialType::getElementType()
1397 */
1398LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
1399
1400/**
1401 * Returns type's subtypes
1402 *
1403 * @see llvm::Type::subtypes()
1404 */
1405void LLVMGetSubtypes(LLVMTypeRef Tp, LLVMTypeRef *Arr);
1406
1407/**
1408 * Return the number of types in the derived type.
1409 *
1410 * @see llvm::Type::getNumContainedTypes()
1411 */
1412unsigned LLVMGetNumContainedTypes(LLVMTypeRef Tp);
1413
1414/**
1415 * Create a fixed size array type that refers to a specific type.
1416 *
1417 * The created type will exist in the context that its element type
1418 * exists in.
1419 *
1420 * @see llvm::ArrayType::get()
1421 */
1422LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
1423
1424/**
1425 * Obtain the length of an array type.
1426 *
1427 * This only works on types that represent arrays.
1428 *
1429 * @see llvm::ArrayType::getNumElements()
1430 */
1431unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
1432
1433/**
1434 * Create a pointer type that points to a defined type.
1435 *
1436 * The created type will exist in the context that its pointee type
1437 * exists in.
1438 *
1439 * @see llvm::PointerType::get()
1440 */
1441LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace);
1442
1443/**
1444 * Obtain the address space of a pointer type.
1445 *
1446 * This only works on types that represent pointers.
1447 *
1448 * @see llvm::PointerType::getAddressSpace()
1449 */
1450unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy);
1451
1452/**
1453 * Create a vector type that contains a defined type and has a specific
1454 * number of elements.
1455 *
1456 * The created type will exist in the context thats its element type
1457 * exists in.
1458 *
1459 * @see llvm::VectorType::get()
1460 */
1461LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
1462
1463/**
1464 * Create a vector type that contains a defined type and has a scalable
1465 * number of elements.
1466 *
1467 * The created type will exist in the context thats its element type
1468 * exists in.
1469 *
1470 * @see llvm::ScalableVectorType::get()
1471 */
1472LLVMTypeRef LLVMScalableVectorType(LLVMTypeRef ElementType,
1473 unsigned ElementCount);
1474
1475/**
1476 * Obtain the (possibly scalable) number of elements in a vector type.
1477 *
1478 * This only works on types that represent vectors (fixed or scalable).
1479 *
1480 * @see llvm::VectorType::getNumElements()
1481 */
1482unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
1483
1484/**
1485 * @}
1486 */
1487
1488/**
1489 * @defgroup LLVMCCoreTypeOther Other Types
1490 *
1491 * @{
1492 */
1493
1494/**
1495 * Create a void type in a context.
1496 */
1497LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C);
1498
1499/**
1500 * Create a label type in a context.
1501 */
1502LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C);
1503
1504/**
1505 * Create a X86 MMX type in a context.
1506 */
1507LLVMTypeRef LLVMX86MMXTypeInContext(LLVMContextRef C);
1508
1509/**
1510 * Create a X86 AMX type in a context.
1511 */
1512LLVMTypeRef LLVMX86AMXTypeInContext(LLVMContextRef C);
1513
1514/**
1515 * Create a token type in a context.
1516 */
1517LLVMTypeRef LLVMTokenTypeInContext(LLVMContextRef C);
1518
1519/**
1520 * Create a metadata type in a context.
1521 */
1522LLVMTypeRef LLVMMetadataTypeInContext(LLVMContextRef C);
1523
1524/**
1525 * These are similar to the above functions except they operate on the
1526 * global context.
1527 */
1528LLVMTypeRef LLVMVoidType(void);
1529LLVMTypeRef LLVMLabelType(void);
1530LLVMTypeRef LLVMX86MMXType(void);
1531LLVMTypeRef LLVMX86AMXType(void);
1532
1533/**
1534 * @}
1535 */
1536
1537/**
1538 * @}
1539 */
1540
1541/**
1542 * @defgroup LLVMCCoreValues Values
1543 *
1544 * The bulk of LLVM's object model consists of values, which comprise a very
1545 * rich type hierarchy.
1546 *
1547 * LLVMValueRef essentially represents llvm::Value. There is a rich
1548 * hierarchy of classes within this type. Depending on the instance
1549 * obtained, not all APIs are available.
1550 *
1551 * Callers can determine the type of an LLVMValueRef by calling the
1552 * LLVMIsA* family of functions (e.g. LLVMIsAArgument()). These
1553 * functions are defined by a macro, so it isn't obvious which are
1554 * available by looking at the Doxygen source code. Instead, look at the
1555 * source definition of LLVM_FOR_EACH_VALUE_SUBCLASS and note the list
1556 * of value names given. These value names also correspond to classes in
1557 * the llvm::Value hierarchy.
1558 *
1559 * @{
1560 */
1561
1562#define LLVM_FOR_EACH_VALUE_SUBCLASS(macro) \
1563 macro(Argument) \
1564 macro(BasicBlock) \
1565 macro(InlineAsm) \
1566 macro(User) \
1567 macro(Constant) \
1568 macro(BlockAddress) \
1569 macro(ConstantAggregateZero) \
1570 macro(ConstantArray) \
1571 macro(ConstantDataSequential) \
1572 macro(ConstantDataArray) \
1573 macro(ConstantDataVector) \
1574 macro(ConstantExpr) \
1575 macro(ConstantFP) \
1576 macro(ConstantInt) \
1577 macro(ConstantPointerNull) \
1578 macro(ConstantStruct) \
1579 macro(ConstantTokenNone) \
1580 macro(ConstantVector) \
1581 macro(GlobalValue) \
1582 macro(GlobalAlias) \
1583 macro(GlobalIFunc) \
1584 macro(GlobalObject) \
1585 macro(Function) \
1586 macro(GlobalVariable) \
1587 macro(UndefValue) \
1588 macro(PoisonValue) \
1589 macro(Instruction) \
1590 macro(UnaryOperator) \
1591 macro(BinaryOperator) \
1592 macro(CallInst) \
1593 macro(IntrinsicInst) \
1594 macro(DbgInfoIntrinsic) \
1595 macro(DbgVariableIntrinsic) \
1596 macro(DbgDeclareInst) \
1597 macro(DbgLabelInst) \
1598 macro(MemIntrinsic) \
1599 macro(MemCpyInst) \
1600 macro(MemMoveInst) \
1601 macro(MemSetInst) \
1602 macro(CmpInst) \
1603 macro(FCmpInst) \
1604 macro(ICmpInst) \
1605 macro(ExtractElementInst) \
1606 macro(GetElementPtrInst) \
1607 macro(InsertElementInst) \
1608 macro(InsertValueInst) \
1609 macro(LandingPadInst) \
1610 macro(PHINode) \
1611 macro(SelectInst) \
1612 macro(ShuffleVectorInst) \
1613 macro(StoreInst) \
1614 macro(BranchInst) \
1615 macro(IndirectBrInst) \
1616 macro(InvokeInst) \
1617 macro(ReturnInst) \
1618 macro(SwitchInst) \
1619 macro(UnreachableInst) \
1620 macro(ResumeInst) \
1621 macro(CleanupReturnInst) \
1622 macro(CatchReturnInst) \
1623 macro(CatchSwitchInst) \
1624 macro(CallBrInst) \
1625 macro(FuncletPadInst) \
1626 macro(CatchPadInst) \
1627 macro(CleanupPadInst) \
1628 macro(UnaryInstruction) \
1629 macro(AllocaInst) \
1630 macro(CastInst) \
1631 macro(AddrSpaceCastInst) \
1632 macro(BitCastInst) \
1633 macro(FPExtInst) \
1634 macro(FPToSIInst) \
1635 macro(FPToUIInst) \
1636 macro(FPTruncInst) \
1637 macro(IntToPtrInst) \
1638 macro(PtrToIntInst) \
1639 macro(SExtInst) \
1640 macro(SIToFPInst) \
1641 macro(TruncInst) \
1642 macro(UIToFPInst) \
1643 macro(ZExtInst) \
1644 macro(ExtractValueInst) \
1645 macro(LoadInst) \
1646 macro(VAArgInst) \
1647 macro(FreezeInst) \
1648 macro(AtomicCmpXchgInst) \
1649 macro(AtomicRMWInst) \
1650 macro(FenceInst)
1651
1652/**
1653 * @defgroup LLVMCCoreValueGeneral General APIs
1654 *
1655 * Functions in this section work on all LLVMValueRef instances,
1656 * regardless of their sub-type. They correspond to functions available
1657 * on llvm::Value.
1658 *
1659 * @{
1660 */
1661
1662/**
1663 * Obtain the type of a value.
1664 *
1665 * @see llvm::Value::getType()
1666 */
1667LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
1668
1669/**
1670 * Obtain the enumerated type of a Value instance.
1671 *
1672 * @see llvm::Value::getValueID()
1673 */
1674LLVMValueKind LLVMGetValueKind(LLVMValueRef Val);
1675
1676/**
1677 * Obtain the string name of a value.
1678 *
1679 * @see llvm::Value::getName()
1680 */
1681const char *LLVMGetValueName2(LLVMValueRef Val, size_t *Length);
1682
1683/**
1684 * Set the string name of a value.
1685 *
1686 * @see llvm::Value::setName()
1687 */
1688void LLVMSetValueName2(LLVMValueRef Val, const char *Name, size_t NameLen);
1689
1690/**
1691 * Dump a representation of a value to stderr.
1692 *
1693 * @see llvm::Value::dump()
1694 */
1695void LLVMDumpValue(LLVMValueRef Val);
1696
1697/**
1698 * Return a string representation of the value. Use
1699 * LLVMDisposeMessage to free the string.
1700 *
1701 * @see llvm::Value::print()
1702 */
1703char *LLVMPrintValueToString(LLVMValueRef Val);
1704
1705/**
1706 * Replace all uses of a value with another one.
1707 *
1708 * @see llvm::Value::replaceAllUsesWith()
1709 */
1710void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal);
1711
1712/**
1713 * Determine whether the specified value instance is constant.
1714 */
1715LLVMBool LLVMIsConstant(LLVMValueRef Val);
1716
1717/**
1718 * Determine whether a value instance is undefined.
1719 */
1720LLVMBool LLVMIsUndef(LLVMValueRef Val);
1721
1722/**
1723 * Determine whether a value instance is poisonous.
1724 */
1725LLVMBool LLVMIsPoison(LLVMValueRef Val);
1726
1727/**
1728 * Convert value instances between types.
1729 *
1730 * Internally, an LLVMValueRef is "pinned" to a specific type. This
1731 * series of functions allows you to cast an instance to a specific
1732 * type.
1733 *
1734 * If the cast is not valid for the specified type, NULL is returned.
1735 *
1736 * @see llvm::dyn_cast_or_null<>
1737 */
1738#define LLVM_DECLARE_VALUE_CAST(name) \
1739 LLVMValueRef LLVMIsA##name(LLVMValueRef Val);
1740LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST)
1741
1742LLVMValueRef LLVMIsAMDNode(LLVMValueRef Val);
1743LLVMValueRef LLVMIsAMDString(LLVMValueRef Val);
1744
1745/** Deprecated: Use LLVMGetValueName2 instead. */
1746const char *LLVMGetValueName(LLVMValueRef Val);
1747/** Deprecated: Use LLVMSetValueName2 instead. */
1748void LLVMSetValueName(LLVMValueRef Val, const char *Name);
1749
1750/**
1751 * @}
1752 */
1753
1754/**
1755 * @defgroup LLVMCCoreValueUses Usage
1756 *
1757 * This module defines functions that allow you to inspect the uses of a
1758 * LLVMValueRef.
1759 *
1760 * It is possible to obtain an LLVMUseRef for any LLVMValueRef instance.
1761 * Each LLVMUseRef (which corresponds to a llvm::Use instance) holds a
1762 * llvm::User and llvm::Value.
1763 *
1764 * @{
1765 */
1766
1767/**
1768 * Obtain the first use of a value.
1769 *
1770 * Uses are obtained in an iterator fashion. First, call this function
1771 * to obtain a reference to the first use. Then, call LLVMGetNextUse()
1772 * on that instance and all subsequently obtained instances until
1773 * LLVMGetNextUse() returns NULL.
1774 *
1775 * @see llvm::Value::use_begin()
1776 */
1777LLVMUseRef LLVMGetFirstUse(LLVMValueRef Val);
1778
1779/**
1780 * Obtain the next use of a value.
1781 *
1782 * This effectively advances the iterator. It returns NULL if you are on
1783 * the final use and no more are available.
1784 */
1785LLVMUseRef LLVMGetNextUse(LLVMUseRef U);
1786
1787/**
1788 * Obtain the user value for a user.
1789 *
1790 * The returned value corresponds to a llvm::User type.
1791 *
1792 * @see llvm::Use::getUser()
1793 */
1794LLVMValueRef LLVMGetUser(LLVMUseRef U);
1795
1796/**
1797 * Obtain the value this use corresponds to.
1798 *
1799 * @see llvm::Use::get().
1800 */
1801LLVMValueRef LLVMGetUsedValue(LLVMUseRef U);
1802
1803/**
1804 * @}
1805 */
1806
1807/**
1808 * @defgroup LLVMCCoreValueUser User value
1809 *
1810 * Function in this group pertain to LLVMValueRef instances that descent
1811 * from llvm::User. This includes constants, instructions, and
1812 * operators.
1813 *
1814 * @{
1815 */
1816
1817/**
1818 * Obtain an operand at a specific index in a llvm::User value.
1819 *
1820 * @see llvm::User::getOperand()
1821 */
1822LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index);
1823
1824/**
1825 * Obtain the use of an operand at a specific index in a llvm::User value.
1826 *
1827 * @see llvm::User::getOperandUse()
1828 */
1829LLVMUseRef LLVMGetOperandUse(LLVMValueRef Val, unsigned Index);
1830
1831/**
1832 * Set an operand at a specific index in a llvm::User value.
1833 *
1834 * @see llvm::User::setOperand()
1835 */
1836void LLVMSetOperand(LLVMValueRef User, unsigned Index, LLVMValueRef Val);
1837
1838/**
1839 * Obtain the number of operands in a llvm::User value.
1840 *
1841 * @see llvm::User::getNumOperands()
1842 */
1843int LLVMGetNumOperands(LLVMValueRef Val);
1844
1845/**
1846 * @}
1847 */
1848
1849/**
1850 * @defgroup LLVMCCoreValueConstant Constants
1851 *
1852 * This section contains APIs for interacting with LLVMValueRef that
1853 * correspond to llvm::Constant instances.
1854 *
1855 * These functions will work for any LLVMValueRef in the llvm::Constant
1856 * class hierarchy.
1857 *
1858 * @{
1859 */
1860
1861/**
1862 * Obtain a constant value referring to the null instance of a type.
1863 *
1864 * @see llvm::Constant::getNullValue()
1865 */
1866LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
1867
1868/**
1869 * Obtain a constant value referring to the instance of a type
1870 * consisting of all ones.
1871 *
1872 * This is only valid for integer types.
1873 *
1874 * @see llvm::Constant::getAllOnesValue()
1875 */
1876LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty);
1877
1878/**
1879 * Obtain a constant value referring to an undefined value of a type.
1880 *
1881 * @see llvm::UndefValue::get()
1882 */
1883LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
1884
1885/**
1886 * Obtain a constant value referring to a poison value of a type.
1887 *
1888 * @see llvm::PoisonValue::get()
1889 */
1890LLVMValueRef LLVMGetPoison(LLVMTypeRef Ty);
1891
1892/**
1893 * Determine whether a value instance is null.
1894 *
1895 * @see llvm::Constant::isNullValue()
1896 */
1897LLVMBool LLVMIsNull(LLVMValueRef Val);
1898
1899/**
1900 * Obtain a constant that is a constant pointer pointing to NULL for a
1901 * specified type.
1902 */
1903LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty);
1904
1905/**
1906 * @defgroup LLVMCCoreValueConstantScalar Scalar constants
1907 *
1908 * Functions in this group model LLVMValueRef instances that correspond
1909 * to constants referring to scalar types.
1910 *
1911 * For integer types, the LLVMTypeRef parameter should correspond to a
1912 * llvm::IntegerType instance and the returned LLVMValueRef will
1913 * correspond to a llvm::ConstantInt.
1914 *
1915 * For floating point types, the LLVMTypeRef returned corresponds to a
1916 * llvm::ConstantFP.
1917 *
1918 * @{
1919 */
1920
1921/**
1922 * Obtain a constant value for an integer type.
1923 *
1924 * The returned value corresponds to a llvm::ConstantInt.
1925 *
1926 * @see llvm::ConstantInt::get()
1927 *
1928 * @param IntTy Integer type to obtain value of.
1929 * @param N The value the returned instance should refer to.
1930 * @param SignExtend Whether to sign extend the produced value.
1931 */
1932LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
1933 LLVMBool SignExtend);
1934
1935/**
1936 * Obtain a constant value for an integer of arbitrary precision.
1937 *
1938 * @see llvm::ConstantInt::get()
1939 */
1940LLVMValueRef LLVMConstIntOfArbitraryPrecision(LLVMTypeRef IntTy,
1941 unsigned NumWords,
1942 const uint64_t Words[]);
1943
1944/**
1945 * Obtain a constant value for an integer parsed from a string.
1946 *
1947 * A similar API, LLVMConstIntOfStringAndSize is also available. If the
1948 * string's length is available, it is preferred to call that function
1949 * instead.
1950 *
1951 * @see llvm::ConstantInt::get()
1952 */
1953LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char *Text,
1954 uint8_t Radix);
1955
1956/**
1957 * Obtain a constant value for an integer parsed from a string with
1958 * specified length.
1959 *
1960 * @see llvm::ConstantInt::get()
1961 */
1962LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char *Text,
1963 unsigned SLen, uint8_t Radix);
1964
1965/**
1966 * Obtain a constant value referring to a double floating point value.
1967 */
1968LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
1969
1970/**
1971 * Obtain a constant for a floating point value parsed from a string.
1972 *
1973 * A similar API, LLVMConstRealOfStringAndSize is also available. It
1974 * should be used if the input string's length is known.
1975 */
1976LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text);
1977
1978/**
1979 * Obtain a constant for a floating point value parsed from a string.
1980 */
1981LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char *Text,
1982 unsigned SLen);
1983
1984/**
1985 * Obtain the zero extended value for an integer constant value.
1986 *
1987 * @see llvm::ConstantInt::getZExtValue()
1988 */
1989unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal);
1990
1991/**
1992 * Obtain the sign extended value for an integer constant value.
1993 *
1994 * @see llvm::ConstantInt::getSExtValue()
1995 */
1996long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal);
1997
1998/**
1999 * Obtain the double value for an floating point constant value.
2000 * losesInfo indicates if some precision was lost in the conversion.
2001 *
2002 * @see llvm::ConstantFP::getDoubleValue
2003 */
2004double LLVMConstRealGetDouble(LLVMValueRef ConstantVal, LLVMBool *losesInfo);
2005
2006/**
2007 * @}
2008 */
2009
2010/**
2011 * @defgroup LLVMCCoreValueConstantComposite Composite Constants
2012 *
2013 * Functions in this group operate on composite constants.
2014 *
2015 * @{
2016 */
2017
2018/**
2019 * Create a ConstantDataSequential and initialize it with a string.
2020 *
2021 * @see llvm::ConstantDataArray::getString()
2022 */
2023LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str,
2024 unsigned Length, LLVMBool DontNullTerminate);
2025
2026/**
2027 * Create a ConstantDataSequential with string content in the global context.
2028 *
2029 * This is the same as LLVMConstStringInContext except it operates on the
2030 * global context.
2031 *
2032 * @see LLVMConstStringInContext()
2033 * @see llvm::ConstantDataArray::getString()
2034 */
2035LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
2036 LLVMBool DontNullTerminate);
2037
2038/**
2039 * Returns true if the specified constant is an array of i8.
2040 *
2041 * @see ConstantDataSequential::getAsString()
2042 */
2043LLVMBool LLVMIsConstantString(LLVMValueRef c);
2044
2045/**
2046 * Get the given constant data sequential as a string.
2047 *
2048 * @see ConstantDataSequential::getAsString()
2049 */
2050const char *LLVMGetAsString(LLVMValueRef c, size_t *Length);
2051
2052/**
2053 * Create an anonymous ConstantStruct with the specified values.
2054 *
2055 * @see llvm::ConstantStruct::getAnon()
2056 */
2057LLVMValueRef LLVMConstStructInContext(LLVMContextRef C,
2058 LLVMValueRef *ConstantVals,
2059 unsigned Count, LLVMBool Packed);
2060
2061/**
2062 * Create a ConstantStruct in the global Context.
2063 *
2064 * This is the same as LLVMConstStructInContext except it operates on the
2065 * global Context.
2066 *
2067 * @see LLVMConstStructInContext()
2068 */
2069LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
2070 LLVMBool Packed);
2071
2072/**
2073 * Create a ConstantArray from values.
2074 *
2075 * @see llvm::ConstantArray::get()
2076 */
2077LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
2078 LLVMValueRef *ConstantVals, unsigned Length);
2079
2080/**
2081 * Create a non-anonymous ConstantStruct from values.
2082 *
2083 * @see llvm::ConstantStruct::get()
2084 */
2085LLVMValueRef LLVMConstNamedStruct(LLVMTypeRef StructTy,
2086 LLVMValueRef *ConstantVals,
2087 unsigned Count);
2088
2089/**
2090 * Get an element at specified index as a constant.
2091 *
2092 * @see ConstantDataSequential::getElementAsConstant()
2093 */
2094LLVMValueRef LLVMGetElementAsConstant(LLVMValueRef C, unsigned idx);
2095
2096/**
2097 * Create a ConstantVector from values.
2098 *
2099 * @see llvm::ConstantVector::get()
2100 */
2101LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
2102
2103/**
2104 * @}
2105 */
2106
2107/**
2108 * @defgroup LLVMCCoreValueConstantExpressions Constant Expressions
2109 *
2110 * Functions in this group correspond to APIs on llvm::ConstantExpr.
2111 *
2112 * @see llvm::ConstantExpr.
2113 *
2114 * @{
2115 */
2116LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal);
2117LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty);
2118LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
2119LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
2120LLVMValueRef LLVMConstNSWNeg(LLVMValueRef ConstantVal);
2121LLVMValueRef LLVMConstNUWNeg(LLVMValueRef ConstantVal);
2122LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal);
2123LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
2124LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2125LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2126LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2127LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2128LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2129LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2130LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2131LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2132LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2133LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2134LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2135LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2136LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2137LLVMValueRef LLVMConstExactUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2138LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2139LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2140LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2141LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2142LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2143LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2144LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2145LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2146LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2147LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
2148 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2149LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
2150 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2151LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2152LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2153LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2154LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
2155 LLVMValueRef *ConstantIndices, unsigned NumIndices);
2156LLVMValueRef LLVMConstGEP2(LLVMTypeRef Ty, LLVMValueRef ConstantVal,
2157 LLVMValueRef *ConstantIndices, unsigned NumIndices);
2158LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal,
2159 LLVMValueRef *ConstantIndices,
2160 unsigned NumIndices);
2161LLVMValueRef LLVMConstInBoundsGEP2(LLVMTypeRef Ty, LLVMValueRef ConstantVal,
2162 LLVMValueRef *ConstantIndices,
2163 unsigned NumIndices);
2164LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
2165LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
2166LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
2167LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
2168LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
2169LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
2170LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
2171LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
2172LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
2173LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
2174LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
2175LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
2176LLVMValueRef LLVMConstAddrSpaceCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
2177LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal,
2178 LLVMTypeRef ToType);
2179LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal,
2180 LLVMTypeRef ToType);
2181LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal,
2182 LLVMTypeRef ToType);
2183LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal,
2184 LLVMTypeRef ToType);
2185LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType,
2186 LLVMBool isSigned);
2187LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
2188LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
2189 LLVMValueRef ConstantIfTrue,
2190 LLVMValueRef ConstantIfFalse);
2191LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
2192 LLVMValueRef IndexConstant);
2193LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
2194 LLVMValueRef ElementValueConstant,
2195 LLVMValueRef IndexConstant);
2196LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
2197 LLVMValueRef VectorBConstant,
2198 LLVMValueRef MaskConstant);
2199LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList,
2200 unsigned NumIdx);
2201LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant,
2202 LLVMValueRef ElementValueConstant,
2203 unsigned *IdxList, unsigned NumIdx);
2204LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB);
2205
2206/** Deprecated: Use LLVMGetInlineAsm instead. */
2207LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty,
2208 const char *AsmString, const char *Constraints,
2209 LLVMBool HasSideEffects, LLVMBool IsAlignStack);
2210
2211/**
2212 * @}
2213 */
2214
2215/**
2216 * @defgroup LLVMCCoreValueConstantGlobals Global Values
2217 *
2218 * This group contains functions that operate on global values. Functions in
2219 * this group relate to functions in the llvm::GlobalValue class tree.
2220 *
2221 * @see llvm::GlobalValue
2222 *
2223 * @{
2224 */
2225
2226LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global);
2227LLVMBool LLVMIsDeclaration(LLVMValueRef Global);
2228LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
2229void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
2230const char *LLVMGetSection(LLVMValueRef Global);
2231void LLVMSetSection(LLVMValueRef Global, const char *Section);
2232LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
2233void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
2234LLVMDLLStorageClass LLVMGetDLLStorageClass(LLVMValueRef Global);
2235void LLVMSetDLLStorageClass(LLVMValueRef Global, LLVMDLLStorageClass Class);
2236LLVMUnnamedAddr LLVMGetUnnamedAddress(LLVMValueRef Global);
2237void LLVMSetUnnamedAddress(LLVMValueRef Global, LLVMUnnamedAddr UnnamedAddr);
2238
2239/**
2240 * Returns the "value type" of a global value. This differs from the formal
2241 * type of a global value which is always a pointer type.
2242 *
2243 * @see llvm::GlobalValue::getValueType()
2244 */
2245LLVMTypeRef LLVMGlobalGetValueType(LLVMValueRef Global);
2246
2247/** Deprecated: Use LLVMGetUnnamedAddress instead. */
2248LLVMBool LLVMHasUnnamedAddr(LLVMValueRef Global);
2249/** Deprecated: Use LLVMSetUnnamedAddress instead. */
2250void LLVMSetUnnamedAddr(LLVMValueRef Global, LLVMBool HasUnnamedAddr);
2251
2252/**
2253 * @defgroup LLVMCCoreValueWithAlignment Values with alignment
2254 *
2255 * Functions in this group only apply to values with alignment, i.e.
2256 * global variables, load and store instructions.
2257 */
2258
2259/**
2260 * Obtain the preferred alignment of the value.
2261 * @see llvm::AllocaInst::getAlignment()
2262 * @see llvm::LoadInst::getAlignment()
2263 * @see llvm::StoreInst::getAlignment()
2264 * @see llvm::AtomicRMWInst::setAlignment()
2265 * @see llvm::AtomicCmpXchgInst::setAlignment()
2266 * @see llvm::GlobalValue::getAlignment()
2267 */
2268unsigned LLVMGetAlignment(LLVMValueRef V);
2269
2270/**
2271 * Set the preferred alignment of the value.
2272 * @see llvm::AllocaInst::setAlignment()
2273 * @see llvm::LoadInst::setAlignment()
2274 * @see llvm::StoreInst::setAlignment()
2275 * @see llvm::AtomicRMWInst::setAlignment()
2276 * @see llvm::AtomicCmpXchgInst::setAlignment()
2277 * @see llvm::GlobalValue::setAlignment()
2278 */
2279void LLVMSetAlignment(LLVMValueRef V, unsigned Bytes);
2280
2281/**
2282 * Sets a metadata attachment, erasing the existing metadata attachment if
2283 * it already exists for the given kind.
2284 *
2285 * @see llvm::GlobalObject::setMetadata()
2286 */
2287void LLVMGlobalSetMetadata(LLVMValueRef Global, unsigned Kind,
2288 LLVMMetadataRef MD);
2289
2290/**
2291 * Erases a metadata attachment of the given kind if it exists.
2292 *
2293 * @see llvm::GlobalObject::eraseMetadata()
2294 */
2295void LLVMGlobalEraseMetadata(LLVMValueRef Global, unsigned Kind);
2296
2297/**
2298 * Removes all metadata attachments from this value.
2299 *
2300 * @see llvm::GlobalObject::clearMetadata()
2301 */
2302void LLVMGlobalClearMetadata(LLVMValueRef Global);
2303
2304/**
2305 * Retrieves an array of metadata entries representing the metadata attached to
2306 * this value. The caller is responsible for freeing this array by calling
2307 * \c LLVMDisposeValueMetadataEntries.
2308 *
2309 * @see llvm::GlobalObject::getAllMetadata()
2310 */
2311LLVMValueMetadataEntry *LLVMGlobalCopyAllMetadata(LLVMValueRef Value,
2312 size_t *NumEntries);
2313
2314/**
2315 * Destroys value metadata entries.
2316 */
2317void LLVMDisposeValueMetadataEntries(LLVMValueMetadataEntry *Entries);
2318
2319/**
2320 * Returns the kind of a value metadata entry at a specific index.
2321 */
2322unsigned LLVMValueMetadataEntriesGetKind(LLVMValueMetadataEntry *Entries,
2323 unsigned Index);
2324
2325/**
2326 * Returns the underlying metadata node of a value metadata entry at a
2327 * specific index.
2328 */
2329LLVMMetadataRef
2330LLVMValueMetadataEntriesGetMetadata(LLVMValueMetadataEntry *Entries,
2331 unsigned Index);
2332
2333/**
2334 * @}
2335 */
2336
2337/**
2338 * @defgroup LLVMCoreValueConstantGlobalVariable Global Variables
2339 *
2340 * This group contains functions that operate on global variable values.
2341 *
2342 * @see llvm::GlobalVariable
2343 *
2344 * @{
2345 */
2346LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
2347LLVMValueRef LLVMAddGlobalInAddressSpace(LLVMModuleRef M, LLVMTypeRef Ty,
2348 const char *Name,
2349 unsigned AddressSpace);
2350LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
2351LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M);
2352LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M);
2353LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar);
2354LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar);
2355void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
2356LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
2357void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
2358LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar);
2359void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal);
2360LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
2361void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant);
2362LLVMThreadLocalMode LLVMGetThreadLocalMode(LLVMValueRef GlobalVar);
2363void LLVMSetThreadLocalMode(LLVMValueRef GlobalVar, LLVMThreadLocalMode Mode);
2364LLVMBool LLVMIsExternallyInitialized(LLVMValueRef GlobalVar);
2365void LLVMSetExternallyInitialized(LLVMValueRef GlobalVar, LLVMBool IsExtInit);
2366
2367/**
2368 * @}
2369 */
2370
2371/**
2372 * @defgroup LLVMCoreValueConstantGlobalAlias Global Aliases
2373 *
2374 * This group contains function that operate on global alias values.
2375 *
2376 * @see llvm::GlobalAlias
2377 *
2378 * @{
2379 */
2380LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee,
2381 const char *Name);
2382
2383/**
2384 * Obtain a GlobalAlias value from a Module by its name.
2385 *
2386 * The returned value corresponds to a llvm::GlobalAlias value.
2387 *
2388 * @see llvm::Module::getNamedAlias()
2389 */
2390LLVMValueRef LLVMGetNamedGlobalAlias(LLVMModuleRef M,
2391 const char *Name, size_t NameLen);
2392
2393/**
2394 * Obtain an iterator to the first GlobalAlias in a Module.
2395 *
2396 * @see llvm::Module::alias_begin()
2397 */
2398LLVMValueRef LLVMGetFirstGlobalAlias(LLVMModuleRef M);
2399
2400/**
2401 * Obtain an iterator to the last GlobalAlias in a Module.
2402 *
2403 * @see llvm::Module::alias_end()
2404 */
2405LLVMValueRef LLVMGetLastGlobalAlias(LLVMModuleRef M);
2406
2407/**
2408 * Advance a GlobalAlias iterator to the next GlobalAlias.
2409 *
2410 * Returns NULL if the iterator was already at the end and there are no more
2411 * global aliases.
2412 */
2413LLVMValueRef LLVMGetNextGlobalAlias(LLVMValueRef GA);
2414
2415/**
2416 * Decrement a GlobalAlias iterator to the previous GlobalAlias.
2417 *
2418 * Returns NULL if the iterator was already at the beginning and there are
2419 * no previous global aliases.
2420 */
2421LLVMValueRef LLVMGetPreviousGlobalAlias(LLVMValueRef GA);
2422
2423/**
2424 * Retrieve the target value of an alias.
2425 */
2426LLVMValueRef LLVMAliasGetAliasee(LLVMValueRef Alias);
2427
2428/**
2429 * Set the target value of an alias.
2430 */
2431void LLVMAliasSetAliasee(LLVMValueRef Alias, LLVMValueRef Aliasee);
2432
2433/**
2434 * @}
2435 */
2436
2437/**
2438 * @defgroup LLVMCCoreValueFunction Function values
2439 *
2440 * Functions in this group operate on LLVMValueRef instances that
2441 * correspond to llvm::Function instances.
2442 *
2443 * @see llvm::Function
2444 *
2445 * @{
2446 */
2447
2448/**
2449 * Remove a function from its containing module and deletes it.
2450 *
2451 * @see llvm::Function::eraseFromParent()
2452 */
2453void LLVMDeleteFunction(LLVMValueRef Fn);
2454
2455/**
2456 * Check whether the given function has a personality function.
2457 *
2458 * @see llvm::Function::hasPersonalityFn()
2459 */
2460LLVMBool LLVMHasPersonalityFn(LLVMValueRef Fn);
2461
2462/**
2463 * Obtain the personality function attached to the function.
2464 *
2465 * @see llvm::Function::getPersonalityFn()
2466 */
2467LLVMValueRef LLVMGetPersonalityFn(LLVMValueRef Fn);
2468
2469/**
2470 * Set the personality function attached to the function.
2471 *
2472 * @see llvm::Function::setPersonalityFn()
2473 */
2474void LLVMSetPersonalityFn(LLVMValueRef Fn, LLVMValueRef PersonalityFn);
2475
2476/**
2477 * Obtain the intrinsic ID number which matches the given function name.
2478 *
2479 * @see llvm::Function::lookupIntrinsicID()
2480 */
2481unsigned LLVMLookupIntrinsicID(const char *Name, size_t NameLen);
2482
2483/**
2484 * Obtain the ID number from a function instance.
2485 *
2486 * @see llvm::Function::getIntrinsicID()
2487 */
2488unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
2489
2490/**
2491 * Create or insert the declaration of an intrinsic. For overloaded intrinsics,
2492 * parameter types must be provided to uniquely identify an overload.
2493 *
2494 * @see llvm::Intrinsic::getDeclaration()
2495 */
2496LLVMValueRef LLVMGetIntrinsicDeclaration(LLVMModuleRef Mod,
2497 unsigned ID,
2498 LLVMTypeRef *ParamTypes,
2499 size_t ParamCount);
2500
2501/**
2502 * Retrieves the type of an intrinsic. For overloaded intrinsics, parameter
2503 * types must be provided to uniquely identify an overload.
2504 *
2505 * @see llvm::Intrinsic::getType()
2506 */
2507LLVMTypeRef LLVMIntrinsicGetType(LLVMContextRef Ctx, unsigned ID,
2508 LLVMTypeRef *ParamTypes, size_t ParamCount);
2509
2510/**
2511 * Retrieves the name of an intrinsic.
2512 *
2513 * @see llvm::Intrinsic::getName()
2514 */
2515const char *LLVMIntrinsicGetName(unsigned ID, size_t *NameLength);
2516
2517/**
2518 * Copies the name of an overloaded intrinsic identified by a given list of
2519 * parameter types.
2520 *
2521 * Unlike LLVMIntrinsicGetName, the caller is responsible for freeing the
2522 * returned string.
2523 *
2524 * @see llvm::Intrinsic::getName()
2525 */
2526const char *LLVMIntrinsicCopyOverloadedName(unsigned ID,
2527 LLVMTypeRef *ParamTypes,
2528 size_t ParamCount,
2529 size_t *NameLength);
2530
2531/**
2532 * Obtain if the intrinsic identified by the given ID is overloaded.
2533 *
2534 * @see llvm::Intrinsic::isOverloaded()
2535 */
2536LLVMBool LLVMIntrinsicIsOverloaded(unsigned ID);
2537
2538/**
2539 * Obtain the calling function of a function.
2540 *
2541 * The returned value corresponds to the LLVMCallConv enumeration.
2542 *
2543 * @see llvm::Function::getCallingConv()
2544 */
2545unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
2546
2547/**
2548 * Set the calling convention of a function.
2549 *
2550 * @see llvm::Function::setCallingConv()
2551 *
2552 * @param Fn Function to operate on
2553 * @param CC LLVMCallConv to set calling convention to
2554 */
2555void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
2556
2557/**
2558 * Obtain the name of the garbage collector to use during code
2559 * generation.
2560 *
2561 * @see llvm::Function::getGC()
2562 */
2563const char *LLVMGetGC(LLVMValueRef Fn);
2564
2565/**
2566 * Define the garbage collector to use during code generation.
2567 *
2568 * @see llvm::Function::setGC()
2569 */
2570void LLVMSetGC(LLVMValueRef Fn, const char *Name);
2571
2572/**
2573 * Add an attribute to a function.
2574 *
2575 * @see llvm::Function::addAttribute()
2576 */
2577void LLVMAddAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
2578 LLVMAttributeRef A);
2579unsigned LLVMGetAttributeCountAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx);
2580void LLVMGetAttributesAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
2581 LLVMAttributeRef *Attrs);
2582LLVMAttributeRef LLVMGetEnumAttributeAtIndex(LLVMValueRef F,
2583 LLVMAttributeIndex Idx,
2584 unsigned KindID);
2585LLVMAttributeRef LLVMGetStringAttributeAtIndex(LLVMValueRef F,
2586 LLVMAttributeIndex Idx,
2587 const char *K, unsigned KLen);
2588void LLVMRemoveEnumAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
2589 unsigned KindID);
2590void LLVMRemoveStringAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
2591 const char *K, unsigned KLen);
2592
2593/**
2594 * Add a target-dependent attribute to a function
2595 * @see llvm::AttrBuilder::addAttribute()
2596 */
2597void LLVMAddTargetDependentFunctionAttr(LLVMValueRef Fn, const char *A,
2598 const char *V);
2599
2600/**
2601 * @defgroup LLVMCCoreValueFunctionParameters Function Parameters
2602 *
2603 * Functions in this group relate to arguments/parameters on functions.
2604 *
2605 * Functions in this group expect LLVMValueRef instances that correspond
2606 * to llvm::Function instances.
2607 *
2608 * @{
2609 */
2610
2611/**
2612 * Obtain the number of parameters in a function.
2613 *
2614 * @see llvm::Function::arg_size()
2615 */
2616unsigned LLVMCountParams(LLVMValueRef Fn);
2617
2618/**
2619 * Obtain the parameters in a function.
2620 *
2621 * The takes a pointer to a pre-allocated array of LLVMValueRef that is
2622 * at least LLVMCountParams() long. This array will be filled with
2623 * LLVMValueRef instances which correspond to the parameters the
2624 * function receives. Each LLVMValueRef corresponds to a llvm::Argument
2625 * instance.
2626 *
2627 * @see llvm::Function::arg_begin()
2628 */
2629void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
2630
2631/**
2632 * Obtain the parameter at the specified index.
2633 *
2634 * Parameters are indexed from 0.
2635 *
2636 * @see llvm::Function::arg_begin()
2637 */
2638LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
2639
2640/**
2641 * Obtain the function to which this argument belongs.
2642 *
2643 * Unlike other functions in this group, this one takes an LLVMValueRef
2644 * that corresponds to a llvm::Attribute.
2645 *
2646 * The returned LLVMValueRef is the llvm::Function to which this
2647 * argument belongs.
2648 */
2649LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst);
2650
2651/**
2652 * Obtain the first parameter to a function.
2653 *
2654 * @see llvm::Function::arg_begin()
2655 */
2656LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn);
2657
2658/**
2659 * Obtain the last parameter to a function.
2660 *
2661 * @see llvm::Function::arg_end()
2662 */
2663LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn);
2664
2665/**
2666 * Obtain the next parameter to a function.
2667 *
2668 * This takes an LLVMValueRef obtained from LLVMGetFirstParam() (which is
2669 * actually a wrapped iterator) and obtains the next parameter from the
2670 * underlying iterator.
2671 */
2672LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg);
2673
2674/**
2675 * Obtain the previous parameter to a function.
2676 *
2677 * This is the opposite of LLVMGetNextParam().
2678 */
2679LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg);
2680
2681/**
2682 * Set the alignment for a function parameter.
2683 *
2684 * @see llvm::Argument::addAttr()
2685 * @see llvm::AttrBuilder::addAlignmentAttr()
2686 */
2687void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned Align);
2688
2689/**
2690 * @}
2691 */
2692
2693/**
2694 * @defgroup LLVMCCoreValueGlobalIFunc IFuncs
2695 *
2696 * Functions in this group relate to indirect functions.
2697 *
2698 * Functions in this group expect LLVMValueRef instances that correspond
2699 * to llvm::GlobalIFunc instances.
2700 *
2701 * @{
2702 */
2703
2704/**
2705 * Add a global indirect function to a module under a specified name.
2706 *
2707 * @see llvm::GlobalIFunc::create()
2708 */
2709LLVMValueRef LLVMAddGlobalIFunc(LLVMModuleRef M,
2710 const char *Name, size_t NameLen,
2711 LLVMTypeRef Ty, unsigned AddrSpace,
2712 LLVMValueRef Resolver);
2713
2714/**
2715 * Obtain a GlobalIFunc value from a Module by its name.
2716 *
2717 * The returned value corresponds to a llvm::GlobalIFunc value.
2718 *
2719 * @see llvm::Module::getNamedIFunc()
2720 */
2721LLVMValueRef LLVMGetNamedGlobalIFunc(LLVMModuleRef M,
2722 const char *Name, size_t NameLen);
2723
2724/**
2725 * Obtain an iterator to the first GlobalIFunc in a Module.
2726 *
2727 * @see llvm::Module::ifunc_begin()
2728 */
2729LLVMValueRef LLVMGetFirstGlobalIFunc(LLVMModuleRef M);
2730
2731/**
2732 * Obtain an iterator to the last GlobalIFunc in a Module.
2733 *
2734 * @see llvm::Module::ifunc_end()
2735 */
2736LLVMValueRef LLVMGetLastGlobalIFunc(LLVMModuleRef M);
2737
2738/**
2739 * Advance a GlobalIFunc iterator to the next GlobalIFunc.
2740 *
2741 * Returns NULL if the iterator was already at the end and there are no more
2742 * global aliases.
2743 */
2744LLVMValueRef LLVMGetNextGlobalIFunc(LLVMValueRef IFunc);
2745
2746/**
2747 * Decrement a GlobalIFunc iterator to the previous GlobalIFunc.
2748 *
2749 * Returns NULL if the iterator was already at the beginning and there are
2750 * no previous global aliases.
2751 */
2752LLVMValueRef LLVMGetPreviousGlobalIFunc(LLVMValueRef IFunc);
2753
2754/**
2755 * Retrieves the resolver function associated with this indirect function, or
2756 * NULL if it doesn't not exist.
2757 *
2758 * @see llvm::GlobalIFunc::getResolver()
2759 */
2760LLVMValueRef LLVMGetGlobalIFuncResolver(LLVMValueRef IFunc);
2761
2762/**
2763 * Sets the resolver function associated with this indirect function.
2764 *
2765 * @see llvm::GlobalIFunc::setResolver()
2766 */
2767void LLVMSetGlobalIFuncResolver(LLVMValueRef IFunc, LLVMValueRef Resolver);
2768
2769/**
2770 * Remove a global indirect function from its parent module and delete it.
2771 *
2772 * @see llvm::GlobalIFunc::eraseFromParent()
2773 */
2774void LLVMEraseGlobalIFunc(LLVMValueRef IFunc);
2775
2776/**
2777 * Remove a global indirect function from its parent module.
2778 *
2779 * This unlinks the global indirect function from its containing module but
2780 * keeps it alive.
2781 *
2782 * @see llvm::GlobalIFunc::removeFromParent()
2783 */
2784void LLVMRemoveGlobalIFunc(LLVMValueRef IFunc);
2785
2786/**
2787 * @}
2788 */
2789
2790/**
2791 * @}
2792 */
2793
2794/**
2795 * @}
2796 */
2797
2798/**
2799 * @}
2800 */
2801
2802/**
2803 * @defgroup LLVMCCoreValueMetadata Metadata
2804 *
2805 * @{
2806 */
2807
2808/**
2809 * Create an MDString value from a given string value.
2810 *
2811 * The MDString value does not take ownership of the given string, it remains
2812 * the responsibility of the caller to free it.
2813 *
2814 * @see llvm::MDString::get()
2815 */
2816LLVMMetadataRef LLVMMDStringInContext2(LLVMContextRef C, const char *Str,
2817 size_t SLen);
2818
2819/**
2820 * Create an MDNode value with the given array of operands.
2821 *
2822 * @see llvm::MDNode::get()
2823 */
2824LLVMMetadataRef LLVMMDNodeInContext2(LLVMContextRef C, LLVMMetadataRef *MDs,
2825 size_t Count);
2826
2827/**
2828 * Obtain a Metadata as a Value.
2829 */
2830LLVMValueRef LLVMMetadataAsValue(LLVMContextRef C, LLVMMetadataRef MD);
2831
2832/**
2833 * Obtain a Value as a Metadata.
2834 */
2835LLVMMetadataRef LLVMValueAsMetadata(LLVMValueRef Val);
2836
2837/**
2838 * Obtain the underlying string from a MDString value.
2839 *
2840 * @param V Instance to obtain string from.
2841 * @param Length Memory address which will hold length of returned string.
2842 * @return String data in MDString.
2843 */
2844const char *LLVMGetMDString(LLVMValueRef V, unsigned *Length);
2845
2846/**
2847 * Obtain the number of operands from an MDNode value.
2848 *
2849 * @param V MDNode to get number of operands from.
2850 * @return Number of operands of the MDNode.
2851 */
2852unsigned LLVMGetMDNodeNumOperands(LLVMValueRef V);
2853
2854/**
2855 * Obtain the given MDNode's operands.
2856 *
2857 * The passed LLVMValueRef pointer should point to enough memory to hold all of
2858 * the operands of the given MDNode (see LLVMGetMDNodeNumOperands) as
2859 * LLVMValueRefs. This memory will be populated with the LLVMValueRefs of the
2860 * MDNode's operands.
2861 *
2862 * @param V MDNode to get the operands from.
2863 * @param Dest Destination array for operands.
2864 */
2865void LLVMGetMDNodeOperands(LLVMValueRef V, LLVMValueRef *Dest);
2866
2867/** Deprecated: Use LLVMMDStringInContext2 instead. */
2868LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str,
2869 unsigned SLen);
2870/** Deprecated: Use LLVMMDStringInContext2 instead. */
2871LLVMValueRef LLVMMDString(const char *Str, unsigned SLen);
2872/** Deprecated: Use LLVMMDNodeInContext2 instead. */
2873LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals,
2874 unsigned Count);
2875/** Deprecated: Use LLVMMDNodeInContext2 instead. */
2876LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count);
2877
2878/**
2879 * @}
2880 */
2881
2882/**
2883 * @defgroup LLVMCCoreValueBasicBlock Basic Block
2884 *
2885 * A basic block represents a single entry single exit section of code.
2886 * Basic blocks contain a list of instructions which form the body of
2887 * the block.
2888 *
2889 * Basic blocks belong to functions. They have the type of label.
2890 *
2891 * Basic blocks are themselves values. However, the C API models them as
2892 * LLVMBasicBlockRef.
2893 *
2894 * @see llvm::BasicBlock
2895 *
2896 * @{
2897 */
2898
2899/**
2900 * Convert a basic block instance to a value type.
2901 */
2902LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB);
2903
2904/**
2905 * Determine whether an LLVMValueRef is itself a basic block.
2906 */
2907LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val);
2908
2909/**
2910 * Convert an LLVMValueRef to an LLVMBasicBlockRef instance.
2911 */
2912LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
2913
2914/**
2915 * Obtain the string name of a basic block.
2916 */
2917const char *LLVMGetBasicBlockName(LLVMBasicBlockRef BB);
2918
2919/**
2920 * Obtain the function to which a basic block belongs.
2921 *
2922 * @see llvm::BasicBlock::getParent()
2923 */
2924LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB);
2925
2926/**
2927 * Obtain the terminator instruction for a basic block.
2928 *
2929 * If the basic block does not have a terminator (it is not well-formed
2930 * if it doesn't), then NULL is returned.
2931 *
2932 * The returned LLVMValueRef corresponds to an llvm::Instruction.
2933 *
2934 * @see llvm::BasicBlock::getTerminator()
2935 */
2936LLVMValueRef LLVMGetBasicBlockTerminator(LLVMBasicBlockRef BB);
2937
2938/**
2939 * Obtain the number of basic blocks in a function.
2940 *
2941 * @param Fn Function value to operate on.
2942 */
2943unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
2944
2945/**
2946 * Obtain all of the basic blocks in a function.
2947 *
2948 * This operates on a function value. The BasicBlocks parameter is a
2949 * pointer to a pre-allocated array of LLVMBasicBlockRef of at least
2950 * LLVMCountBasicBlocks() in length. This array is populated with
2951 * LLVMBasicBlockRef instances.
2952 */
2953void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
2954
2955/**
2956 * Obtain the first basic block in a function.
2957 *
2958 * The returned basic block can be used as an iterator. You will likely
2959 * eventually call into LLVMGetNextBasicBlock() with it.
2960 *
2961 * @see llvm::Function::begin()
2962 */
2963LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn);
2964
2965/**
2966 * Obtain the last basic block in a function.
2967 *
2968 * @see llvm::Function::end()
2969 */
2970LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn);
2971
2972/**
2973 * Advance a basic block iterator.
2974 */
2975LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB);
2976
2977/**
2978 * Go backwards in a basic block iterator.
2979 */
2980LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB);
2981
2982/**
2983 * Obtain the basic block that corresponds to the entry point of a
2984 * function.
2985 *
2986 * @see llvm::Function::getEntryBlock()
2987 */
2988LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
2989
2990/**
2991 * Insert the given basic block after the insertion point of the given builder.
2992 *
2993 * The insertion point must be valid.
2994 *
2995 * @see llvm::Function::BasicBlockListType::insertAfter()
2996 */
2997void LLVMInsertExistingBasicBlockAfterInsertBlock(LLVMBuilderRef Builder,
2998 LLVMBasicBlockRef BB);
2999
3000/**
3001 * Append the given basic block to the basic block list of the given function.
3002 *
3003 * @see llvm::Function::BasicBlockListType::push_back()
3004 */
3005void LLVMAppendExistingBasicBlock(LLVMValueRef Fn,
3006 LLVMBasicBlockRef BB);
3007
3008/**
3009 * Create a new basic block without inserting it into a function.
3010 *
3011 * @see llvm::BasicBlock::Create()
3012 */
3013LLVMBasicBlockRef LLVMCreateBasicBlockInContext(LLVMContextRef C,
3014 const char *Name);
3015
3016/**
3017 * Append a basic block to the end of a function.
3018 *
3019 * @see llvm::BasicBlock::Create()
3020 */
3021LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C,
3022 LLVMValueRef Fn,
3023 const char *Name);
3024
3025/**
3026 * Append a basic block to the end of a function using the global
3027 * context.
3028 *
3029 * @see llvm::BasicBlock::Create()
3030 */
3031LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
3032
3033/**
3034 * Insert a basic block in a function before another basic block.
3035 *
3036 * The function to add to is determined by the function of the
3037 * passed basic block.
3038 *
3039 * @see llvm::BasicBlock::Create()
3040 */
3041LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C,
3042 LLVMBasicBlockRef BB,
3043 const char *Name);
3044
3045/**
3046 * Insert a basic block in a function using the global context.
3047 *
3048 * @see llvm::BasicBlock::Create()
3049 */
3050LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
3051 const char *Name);
3052
3053/**
3054 * Remove a basic block from a function and delete it.
3055 *
3056 * This deletes the basic block from its containing function and deletes
3057 * the basic block itself.
3058 *
3059 * @see llvm::BasicBlock::eraseFromParent()
3060 */
3061void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
3062
3063/**
3064 * Remove a basic block from a function.
3065 *
3066 * This deletes the basic block from its containing function but keep
3067 * the basic block alive.
3068 *
3069 * @see llvm::BasicBlock::removeFromParent()
3070 */
3071void LLVMRemoveBasicBlockFromParent(LLVMBasicBlockRef BB);
3072
3073/**
3074 * Move a basic block to before another one.
3075 *
3076 * @see llvm::BasicBlock::moveBefore()
3077 */
3078void LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos);
3079
3080/**
3081 * Move a basic block to after another one.
3082 *
3083 * @see llvm::BasicBlock::moveAfter()
3084 */
3085void LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos);
3086
3087/**
3088 * Obtain the first instruction in a basic block.
3089 *
3090 * The returned LLVMValueRef corresponds to a llvm::Instruction
3091 * instance.
3092 */
3093LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB);
3094
3095/**
3096 * Obtain the last instruction in a basic block.
3097 *
3098 * The returned LLVMValueRef corresponds to an LLVM:Instruction.
3099 */
3100LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB);
3101
3102/**
3103 * @}
3104 */
3105
3106/**
3107 * @defgroup LLVMCCoreValueInstruction Instructions
3108 *
3109 * Functions in this group relate to the inspection and manipulation of
3110 * individual instructions.
3111 *
3112 * In the C++ API, an instruction is modeled by llvm::Instruction. This
3113 * class has a large number of descendents. llvm::Instruction is a
3114 * llvm::Value and in the C API, instructions are modeled by
3115 * LLVMValueRef.
3116 *
3117 * This group also contains sub-groups which operate on specific
3118 * llvm::Instruction types, e.g. llvm::CallInst.
3119 *
3120 * @{
3121 */
3122
3123/**
3124 * Determine whether an instruction has any metadata attached.
3125 */
3126int LLVMHasMetadata(LLVMValueRef Val);
3127
3128/**
3129 * Return metadata associated with an instruction value.
3130 */
3131LLVMValueRef LLVMGetMetadata(LLVMValueRef Val, unsigned KindID);
3132
3133/**
3134 * Set metadata associated with an instruction value.
3135 */
3136void LLVMSetMetadata(LLVMValueRef Val, unsigned KindID, LLVMValueRef Node);
3137
3138/**
3139 * Returns the metadata associated with an instruction value, but filters out
3140 * all the debug locations.
3141 *
3142 * @see llvm::Instruction::getAllMetadataOtherThanDebugLoc()
3143 */
3144LLVMValueMetadataEntry *
3145LLVMInstructionGetAllMetadataOtherThanDebugLoc(LLVMValueRef Instr,
3146 size_t *NumEntries);
3147
3148/**
3149 * Obtain the basic block to which an instruction belongs.
3150 *
3151 * @see llvm::Instruction::getParent()
3152 */
3153LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst);
3154
3155/**
3156 * Obtain the instruction that occurs after the one specified.
3157 *
3158 * The next instruction will be from the same basic block.
3159 *
3160 * If this is the last instruction in a basic block, NULL will be
3161 * returned.
3162 */
3163LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst);
3164
3165/**
3166 * Obtain the instruction that occurred before this one.
3167 *
3168 * If the instruction is the first instruction in a basic block, NULL
3169 * will be returned.
3170 */
3171LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst);
3172
3173/**
3174 * Remove and delete an instruction.
3175 *
3176 * The instruction specified is removed from its containing building
3177 * block but is kept alive.
3178 *
3179 * @see llvm::Instruction::removeFromParent()
3180 */
3181void LLVMInstructionRemoveFromParent(LLVMValueRef Inst);
3182
3183/**
3184 * Remove and delete an instruction.
3185 *
3186 * The instruction specified is removed from its containing building
3187 * block and then deleted.
3188 *
3189 * @see llvm::Instruction::eraseFromParent()
3190 */
3191void LLVMInstructionEraseFromParent(LLVMValueRef Inst);
3192
3193/**
3194 * Obtain the code opcode for an individual instruction.
3195 *
3196 * @see llvm::Instruction::getOpCode()
3197 */
3198LLVMOpcode LLVMGetInstructionOpcode(LLVMValueRef Inst);
3199
3200/**
3201 * Obtain the predicate of an instruction.
3202 *
3203 * This is only valid for instructions that correspond to llvm::ICmpInst
3204 * or llvm::ConstantExpr whose opcode is llvm::Instruction::ICmp.
3205 *
3206 * @see llvm::ICmpInst::getPredicate()
3207 */
3208LLVMIntPredicate LLVMGetICmpPredicate(LLVMValueRef Inst);
3209
3210/**
3211 * Obtain the float predicate of an instruction.
3212 *
3213 * This is only valid for instructions that correspond to llvm::FCmpInst
3214 * or llvm::ConstantExpr whose opcode is llvm::Instruction::FCmp.
3215 *
3216 * @see llvm::FCmpInst::getPredicate()
3217 */
3218LLVMRealPredicate LLVMGetFCmpPredicate(LLVMValueRef Inst);
3219
3220/**
3221 * Create a copy of 'this' instruction that is identical in all ways
3222 * except the following:
3223 * * The instruction has no parent
3224 * * The instruction has no name
3225 *
3226 * @see llvm::Instruction::clone()
3227 */
3228LLVMValueRef LLVMInstructionClone(LLVMValueRef Inst);
3229
3230/**
3231 * Determine whether an instruction is a terminator. This routine is named to
3232 * be compatible with historical functions that did this by querying the
3233 * underlying C++ type.
3234 *
3235 * @see llvm::Instruction::isTerminator()
3236 */
3237LLVMValueRef LLVMIsATerminatorInst(LLVMValueRef Inst);
3238
3239/**
3240 * @defgroup LLVMCCoreValueInstructionCall Call Sites and Invocations
3241 *
3242 * Functions in this group apply to instructions that refer to call
3243 * sites and invocations. These correspond to C++ types in the
3244 * llvm::CallInst class tree.
3245 *
3246 * @{
3247 */
3248
3249/**
3250 * Obtain the argument count for a call instruction.
3251 *
3252 * This expects an LLVMValueRef that corresponds to a llvm::CallInst,
3253 * llvm::InvokeInst, or llvm:FuncletPadInst.
3254 *
3255 * @see llvm::CallInst::getNumArgOperands()
3256 * @see llvm::InvokeInst::getNumArgOperands()
3257 * @see llvm::FuncletPadInst::getNumArgOperands()
3258 */
3259unsigned LLVMGetNumArgOperands(LLVMValueRef Instr);
3260
3261/**
3262 * Set the calling convention for a call instruction.
3263 *
3264 * This expects an LLVMValueRef that corresponds to a llvm::CallInst or
3265 * llvm::InvokeInst.
3266 *
3267 * @see llvm::CallInst::setCallingConv()
3268 * @see llvm::InvokeInst::setCallingConv()
3269 */
3270void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC);
3271
3272/**
3273 * Obtain the calling convention for a call instruction.
3274 *
3275 * This is the opposite of LLVMSetInstructionCallConv(). Reads its
3276 * usage.
3277 *
3278 * @see LLVMSetInstructionCallConv()
3279 */
3280unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr);
3281
3282void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
3283 unsigned Align);
3284
3285void LLVMAddCallSiteAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
3286 LLVMAttributeRef A);
3287unsigned LLVMGetCallSiteAttributeCount(LLVMValueRef C, LLVMAttributeIndex Idx);
3288void LLVMGetCallSiteAttributes(LLVMValueRef C, LLVMAttributeIndex Idx,
3289 LLVMAttributeRef *Attrs);
3290LLVMAttributeRef LLVMGetCallSiteEnumAttribute(LLVMValueRef C,
3291 LLVMAttributeIndex Idx,
3292 unsigned KindID);
3293LLVMAttributeRef LLVMGetCallSiteStringAttribute(LLVMValueRef C,
3294 LLVMAttributeIndex Idx,
3295 const char *K, unsigned KLen);
3296void LLVMRemoveCallSiteEnumAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
3297 unsigned KindID);
3298void LLVMRemoveCallSiteStringAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
3299 const char *K, unsigned KLen);
3300
3301/**
3302 * Obtain the function type called by this instruction.
3303 *
3304 * @see llvm::CallBase::getFunctionType()
3305 */
3306LLVMTypeRef LLVMGetCalledFunctionType(LLVMValueRef C);
3307
3308/**
3309 * Obtain the pointer to the function invoked by this instruction.
3310 *
3311 * This expects an LLVMValueRef that corresponds to a llvm::CallInst or
3312 * llvm::InvokeInst.
3313 *
3314 * @see llvm::CallInst::getCalledOperand()
3315 * @see llvm::InvokeInst::getCalledOperand()
3316 */
3317LLVMValueRef LLVMGetCalledValue(LLVMValueRef Instr);
3318
3319/**
3320 * Obtain whether a call instruction is a tail call.
3321 *
3322 * This only works on llvm::CallInst instructions.
3323 *
3324 * @see llvm::CallInst::isTailCall()
3325 */
3326LLVMBool LLVMIsTailCall(LLVMValueRef CallInst);
3327
3328/**
3329 * Set whether a call instruction is a tail call.
3330 *
3331 * This only works on llvm::CallInst instructions.
3332 *
3333 * @see llvm::CallInst::setTailCall()
3334 */
3335void LLVMSetTailCall(LLVMValueRef CallInst, LLVMBool IsTailCall);
3336
3337/**
3338 * Return the normal destination basic block.
3339 *
3340 * This only works on llvm::InvokeInst instructions.
3341 *
3342 * @see llvm::InvokeInst::getNormalDest()
3343 */
3344LLVMBasicBlockRef LLVMGetNormalDest(LLVMValueRef InvokeInst);
3345
3346/**
3347 * Return the unwind destination basic block.
3348 *
3349 * Works on llvm::InvokeInst, llvm::CleanupReturnInst, and
3350 * llvm::CatchSwitchInst instructions.
3351 *
3352 * @see llvm::InvokeInst::getUnwindDest()
3353 * @see llvm::CleanupReturnInst::getUnwindDest()
3354 * @see llvm::CatchSwitchInst::getUnwindDest()
3355 */
3356LLVMBasicBlockRef LLVMGetUnwindDest(LLVMValueRef InvokeInst);
3357
3358/**
3359 * Set the normal destination basic block.
3360 *
3361 * This only works on llvm::InvokeInst instructions.
3362 *
3363 * @see llvm::InvokeInst::setNormalDest()
3364 */
3365void LLVMSetNormalDest(LLVMValueRef InvokeInst, LLVMBasicBlockRef B);
3366
3367/**
3368 * Set the unwind destination basic block.
3369 *
3370 * Works on llvm::InvokeInst, llvm::CleanupReturnInst, and
3371 * llvm::CatchSwitchInst instructions.
3372 *
3373 * @see llvm::InvokeInst::setUnwindDest()
3374 * @see llvm::CleanupReturnInst::setUnwindDest()
3375 * @see llvm::CatchSwitchInst::setUnwindDest()
3376 */
3377void LLVMSetUnwindDest(LLVMValueRef InvokeInst, LLVMBasicBlockRef B);
3378
3379/**
3380 * @}
3381 */
3382
3383/**
3384 * @defgroup LLVMCCoreValueInstructionTerminator Terminators
3385 *
3386 * Functions in this group only apply to instructions for which
3387 * LLVMIsATerminatorInst returns true.
3388 *
3389 * @{
3390 */
3391
3392/**
3393 * Return the number of successors that this terminator has.
3394 *
3395 * @see llvm::Instruction::getNumSuccessors
3396 */
3397unsigned LLVMGetNumSuccessors(LLVMValueRef Term);
3398
3399/**
3400 * Return the specified successor.
3401 *
3402 * @see llvm::Instruction::getSuccessor
3403 */
3404LLVMBasicBlockRef LLVMGetSuccessor(LLVMValueRef Term, unsigned i);
3405
3406/**
3407 * Update the specified successor to point at the provided block.
3408 *
3409 * @see llvm::Instruction::setSuccessor
3410 */
3411void LLVMSetSuccessor(LLVMValueRef Term, unsigned i, LLVMBasicBlockRef block);
3412
3413/**
3414 * Return if a branch is conditional.
3415 *
3416 * This only works on llvm::BranchInst instructions.
3417 *
3418 * @see llvm::BranchInst::isConditional
3419 */
3420LLVMBool LLVMIsConditional(LLVMValueRef Branch);
3421
3422/**
3423 * Return the condition of a branch instruction.
3424 *
3425 * This only works on llvm::BranchInst instructions.
3426 *
3427 * @see llvm::BranchInst::getCondition
3428 */
3429LLVMValueRef LLVMGetCondition(LLVMValueRef Branch);
3430
3431/**
3432 * Set the condition of a branch instruction.
3433 *
3434 * This only works on llvm::BranchInst instructions.
3435 *
3436 * @see llvm::BranchInst::setCondition
3437 */
3438void LLVMSetCondition(LLVMValueRef Branch, LLVMValueRef Cond);
3439
3440/**
3441 * Obtain the default destination basic block of a switch instruction.
3442 *
3443 * This only works on llvm::SwitchInst instructions.
3444 *
3445 * @see llvm::SwitchInst::getDefaultDest()
3446 */
3447LLVMBasicBlockRef LLVMGetSwitchDefaultDest(LLVMValueRef SwitchInstr);
3448
3449/**
3450 * @}
3451 */
3452
3453/**
3454 * @defgroup LLVMCCoreValueInstructionAlloca Allocas
3455 *
3456 * Functions in this group only apply to instructions that map to
3457 * llvm::AllocaInst instances.
3458 *
3459 * @{
3460 */
3461
3462/**
3463 * Obtain the type that is being allocated by the alloca instruction.
3464 */
3465LLVMTypeRef LLVMGetAllocatedType(LLVMValueRef Alloca);
3466
3467/**
3468 * @}
3469 */
3470
3471/**
3472 * @defgroup LLVMCCoreValueInstructionGetElementPointer GEPs
3473 *
3474 * Functions in this group only apply to instructions that map to
3475 * llvm::GetElementPtrInst instances.
3476 *
3477 * @{
3478 */
3479
3480/**
3481 * Check whether the given GEP instruction is inbounds.
3482 */
3483LLVMBool LLVMIsInBounds(LLVMValueRef GEP);
3484
3485/**
3486 * Set the given GEP instruction to be inbounds or not.
3487 */
3488void LLVMSetIsInBounds(LLVMValueRef GEP, LLVMBool InBounds);
3489
3490/**
3491 * @}
3492 */
3493
3494/**
3495 * @defgroup LLVMCCoreValueInstructionPHINode PHI Nodes
3496 *
3497 * Functions in this group only apply to instructions that map to
3498 * llvm::PHINode instances.
3499 *
3500 * @{
3501 */
3502
3503/**
3504 * Add an incoming value to the end of a PHI list.
3505 */
3506void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
3507 LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
3508
3509/**
3510 * Obtain the number of incoming basic blocks to a PHI node.
3511 */
3512unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
3513
3514/**
3515 * Obtain an incoming value to a PHI node as an LLVMValueRef.
3516 */
3517LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
3518
3519/**
3520 * Obtain an incoming value to a PHI node as an LLVMBasicBlockRef.
3521 */
3522LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
3523
3524/**
3525 * @}
3526 */
3527
3528/**
3529 * @defgroup LLVMCCoreValueInstructionExtractValue ExtractValue
3530 * @defgroup LLVMCCoreValueInstructionInsertValue InsertValue
3531 *
3532 * Functions in this group only apply to instructions that map to
3533 * llvm::ExtractValue and llvm::InsertValue instances.
3534 *
3535 * @{
3536 */
3537
3538/**
3539 * Obtain the number of indices.
3540 * NB: This also works on GEP.
3541 */
3542unsigned LLVMGetNumIndices(LLVMValueRef Inst);
3543
3544/**
3545 * Obtain the indices as an array.
3546 */
3547const unsigned *LLVMGetIndices(LLVMValueRef Inst);
3548
3549/**
3550 * @}
3551 */
3552
3553/**
3554 * @}
3555 */
3556
3557/**
3558 * @}
3559 */
3560
3561/**
3562 * @defgroup LLVMCCoreInstructionBuilder Instruction Builders
3563 *
3564 * An instruction builder represents a point within a basic block and is
3565 * the exclusive means of building instructions using the C interface.
3566 *
3567 * @{
3568 */
3569
3570LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C);
3571LLVMBuilderRef LLVMCreateBuilder(void);
3572void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
3573 LLVMValueRef Instr);
3574void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
3575void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
3576LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder);
3577void LLVMClearInsertionPosition(LLVMBuilderRef Builder);
3578void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr);
3579void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr,
3580 const char *Name);
3581void LLVMDisposeBuilder(LLVMBuilderRef Builder);
3582
3583/* Metadata */
3584
3585/**
3586 * Get location information used by debugging information.
3587 *
3588 * @see llvm::IRBuilder::getCurrentDebugLocation()
3589 */
3590LLVMMetadataRef LLVMGetCurrentDebugLocation2(LLVMBuilderRef Builder);
3591
3592/**
3593 * Set location information used by debugging information.
3594 *
3595 * To clear the location metadata of the given instruction, pass NULL to \p Loc.
3596 *
3597 * @see llvm::IRBuilder::SetCurrentDebugLocation()
3598 */
3599void LLVMSetCurrentDebugLocation2(LLVMBuilderRef Builder, LLVMMetadataRef Loc);
3600
3601/**
3602 * Attempts to set the debug location for the given instruction using the
3603 * current debug location for the given builder. If the builder has no current
3604 * debug location, this function is a no-op.
3605 *
3606 * @see llvm::IRBuilder::SetInstDebugLocation()
3607 */
3608void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst);
3609
3610/**
3611 * Get the dafult floating-point math metadata for a given builder.
3612 *
3613 * @see llvm::IRBuilder::getDefaultFPMathTag()
3614 */
3615LLVMMetadataRef LLVMBuilderGetDefaultFPMathTag(LLVMBuilderRef Builder);
3616
3617/**
3618 * Set the default floating-point math metadata for the given builder.
3619 *
3620 * To clear the metadata, pass NULL to \p FPMathTag.
3621 *
3622 * @see llvm::IRBuilder::setDefaultFPMathTag()
3623 */
3624void LLVMBuilderSetDefaultFPMathTag(LLVMBuilderRef Builder,
3625 LLVMMetadataRef FPMathTag);
3626
3627/**
3628 * Deprecated: Passing the NULL location will crash.
3629 * Use LLVMGetCurrentDebugLocation2 instead.
3630 */
3631void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L);
3632/**
3633 * Deprecated: Returning the NULL location will crash.
3634 * Use LLVMGetCurrentDebugLocation2 instead.
3635 */
3636LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder);
3637
3638/* Terminators */
3639LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
3640LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
3641LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals,
3642 unsigned N);
3643LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
3644LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
3645 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
3646LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
3647 LLVMBasicBlockRef Else, unsigned NumCases);
3648LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr,
3649 unsigned NumDests);
3650// LLVMBuildInvoke is deprecated in favor of LLVMBuildInvoke2, in preparation
3651// for opaque pointer types.
3652LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
3653 LLVMValueRef *Args, unsigned NumArgs,
3654 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
3655 const char *Name);
3656LLVMValueRef LLVMBuildInvoke2(LLVMBuilderRef, LLVMTypeRef Ty, LLVMValueRef Fn,
3657 LLVMValueRef *Args, unsigned NumArgs,
3658 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
3659 const char *Name);
3660LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
3661
3662/* Exception Handling */
3663LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn);
3664LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty,
3665 LLVMValueRef PersFn, unsigned NumClauses,
3666 const char *Name);
3667LLVMValueRef LLVMBuildCleanupRet(LLVMBuilderRef B, LLVMValueRef CatchPad,
3668 LLVMBasicBlockRef BB);
3669LLVMValueRef LLVMBuildCatchRet(LLVMBuilderRef B, LLVMValueRef CatchPad,
3670 LLVMBasicBlockRef BB);
3671LLVMValueRef LLVMBuildCatchPad(LLVMBuilderRef B, LLVMValueRef ParentPad,
3672 LLVMValueRef *Args, unsigned NumArgs,
3673 const char *Name);
3674LLVMValueRef LLVMBuildCleanupPad(LLVMBuilderRef B, LLVMValueRef ParentPad,
3675 LLVMValueRef *Args, unsigned NumArgs,
3676 const char *Name);
3677LLVMValueRef LLVMBuildCatchSwitch(LLVMBuilderRef B, LLVMValueRef ParentPad,
3678 LLVMBasicBlockRef UnwindBB,
3679 unsigned NumHandlers, const char *Name);
3680
3681/* Add a case to the switch instruction */
3682void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
3683 LLVMBasicBlockRef Dest);
3684
3685/* Add a destination to the indirectbr instruction */
3686void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest);
3687
3688/* Get the number of clauses on the landingpad instruction */
3689unsigned LLVMGetNumClauses(LLVMValueRef LandingPad);
3690
3691/* Get the value of the clause at index Idx on the landingpad instruction */
3692LLVMValueRef LLVMGetClause(LLVMValueRef LandingPad, unsigned Idx);
3693
3694/* Add a catch or filter clause to the landingpad instruction */
3695void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal);
3696
3697/* Get the 'cleanup' flag in the landingpad instruction */
3698LLVMBool LLVMIsCleanup(LLVMValueRef LandingPad);
3699
3700/* Set the 'cleanup' flag in the landingpad instruction */
3701void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val);
3702
3703/* Add a destination to the catchswitch instruction */
3704void LLVMAddHandler(LLVMValueRef CatchSwitch, LLVMBasicBlockRef Dest);
3705
3706/* Get the number of handlers on the catchswitch instruction */
3707unsigned LLVMGetNumHandlers(LLVMValueRef CatchSwitch);
3708
3709/**
3710 * Obtain the basic blocks acting as handlers for a catchswitch instruction.
3711 *
3712 * The Handlers parameter should point to a pre-allocated array of
3713 * LLVMBasicBlockRefs at least LLVMGetNumHandlers() large. On return, the
3714 * first LLVMGetNumHandlers() entries in the array will be populated
3715 * with LLVMBasicBlockRef instances.
3716 *
3717 * @param CatchSwitch The catchswitch instruction to operate on.
3718 * @param Handlers Memory address of an array to be filled with basic blocks.
3719 */
3720void LLVMGetHandlers(LLVMValueRef CatchSwitch, LLVMBasicBlockRef *Handlers);
3721
3722/* Funclets */
3723
3724/* Get the number of funcletpad arguments. */
3725LLVMValueRef LLVMGetArgOperand(LLVMValueRef Funclet, unsigned i);
3726
3727/* Set a funcletpad argument at the given index. */
3728void LLVMSetArgOperand(LLVMValueRef Funclet, unsigned i, LLVMValueRef value);
3729
3730/**
3731 * Get the parent catchswitch instruction of a catchpad instruction.
3732 *
3733 * This only works on llvm::CatchPadInst instructions.
3734 *
3735 * @see llvm::CatchPadInst::getCatchSwitch()
3736 */
3737LLVMValueRef LLVMGetParentCatchSwitch(LLVMValueRef CatchPad);
3738
3739/**
3740 * Set the parent catchswitch instruction of a catchpad instruction.
3741 *
3742 * This only works on llvm::CatchPadInst instructions.
3743 *
3744 * @see llvm::CatchPadInst::setCatchSwitch()
3745 */
3746void LLVMSetParentCatchSwitch(LLVMValueRef CatchPad, LLVMValueRef CatchSwitch);
3747
3748/* Arithmetic */
3749LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3750 const char *Name);
3751LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3752 const char *Name);
3753LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3754 const char *Name);
3755LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3756 const char *Name);
3757LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3758 const char *Name);
3759LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3760 const char *Name);
3761LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3762 const char *Name);
3763LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3764 const char *Name);
3765LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3766 const char *Name);
3767LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3768 const char *Name);
3769LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3770 const char *Name);
3771LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3772 const char *Name);
3773LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3774 const char *Name);
3775LLVMValueRef LLVMBuildExactUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3776 const char *Name);
3777LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3778 const char *Name);
3779LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3780 const char *Name);
3781LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3782 const char *Name);
3783LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3784 const char *Name);
3785LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3786 const char *Name);
3787LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3788 const char *Name);
3789LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3790 const char *Name);
3791LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3792 const char *Name);
3793LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3794 const char *Name);
3795LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3796 const char *Name);
3797LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3798 const char *Name);
3799LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
3800 const char *Name);
3801LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op,
3802 LLVMValueRef LHS, LLVMValueRef RHS,
3803 const char *Name);
3804LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
3805LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V,
3806 const char *Name);
3807LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V,
3808 const char *Name);
3809LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
3810LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
3811
3812/* Memory */
3813LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
3814LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
3815 LLVMValueRef Val, const char *Name);
3816
3817/**
3818 * Creates and inserts a memset to the specified pointer and the
3819 * specified value.
3820 *
3821 * @see llvm::IRRBuilder::CreateMemSet()
3822 */
3823LLVMValueRef LLVMBuildMemSet(LLVMBuilderRef B, LLVMValueRef Ptr,
3824 LLVMValueRef Val, LLVMValueRef Len,
3825 unsigned Align);
3826/**
3827 * Creates and inserts a memcpy between the specified pointers.
3828 *
3829 * @see llvm::IRRBuilder::CreateMemCpy()
3830 */
3831LLVMValueRef LLVMBuildMemCpy(LLVMBuilderRef B,
3832 LLVMValueRef Dst, unsigned DstAlign,
3833 LLVMValueRef Src, unsigned SrcAlign,
3834 LLVMValueRef Size);
3835/**
3836 * Creates and inserts a memmove between the specified pointers.
3837 *
3838 * @see llvm::IRRBuilder::CreateMemMove()
3839 */
3840LLVMValueRef LLVMBuildMemMove(LLVMBuilderRef B,
3841 LLVMValueRef Dst, unsigned DstAlign,
3842 LLVMValueRef Src, unsigned SrcAlign,
3843 LLVMValueRef Size);
3844
3845LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
3846LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
3847 LLVMValueRef Val, const char *Name);
3848LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
3849// LLVMBuildLoad is deprecated in favor of LLVMBuildLoad2, in preparation for
3850// opaque pointer types.
3851LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
3852 const char *Name);
3853LLVMValueRef LLVMBuildLoad2(LLVMBuilderRef, LLVMTypeRef Ty,
3854 LLVMValueRef PointerVal, const char *Name);
3855LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
3856// LLVMBuildGEP, LLVMBuildInBoundsGEP, and LLVMBuildStructGEP are deprecated in
3857// favor of LLVMBuild*GEP2, in preparation for opaque pointer types.
3858LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
3859 LLVMValueRef *Indices, unsigned NumIndices,
3860 const char *Name);
3861LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
3862 LLVMValueRef *Indices, unsigned NumIndices,
3863 const char *Name);
3864LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
3865 unsigned Idx, const char *Name);
3866LLVMValueRef LLVMBuildGEP2(LLVMBuilderRef B, LLVMTypeRef Ty,
3867 LLVMValueRef Pointer, LLVMValueRef *Indices,
3868 unsigned NumIndices, const char *Name);
3869LLVMValueRef LLVMBuildInBoundsGEP2(LLVMBuilderRef B, LLVMTypeRef Ty,
3870 LLVMValueRef Pointer, LLVMValueRef *Indices,
3871 unsigned NumIndices, const char *Name);
3872LLVMValueRef LLVMBuildStructGEP2(LLVMBuilderRef B, LLVMTypeRef Ty,
3873 LLVMValueRef Pointer, unsigned Idx,
3874 const char *Name);
3875LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str,
3876 const char *Name);
3877LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str,
3878 const char *Name);
3879LLVMBool LLVMGetVolatile(LLVMValueRef MemoryAccessInst);
3880void LLVMSetVolatile(LLVMValueRef MemoryAccessInst, LLVMBool IsVolatile);
3881LLVMBool LLVMGetWeak(LLVMValueRef CmpXchgInst);
3882void LLVMSetWeak(LLVMValueRef CmpXchgInst, LLVMBool IsWeak);
3883LLVMAtomicOrdering LLVMGetOrdering(LLVMValueRef MemoryAccessInst);
3884void LLVMSetOrdering(LLVMValueRef MemoryAccessInst, LLVMAtomicOrdering Ordering);
3885LLVMAtomicRMWBinOp LLVMGetAtomicRMWBinOp(LLVMValueRef AtomicRMWInst);
3886void LLVMSetAtomicRMWBinOp(LLVMValueRef AtomicRMWInst, LLVMAtomicRMWBinOp BinOp);
3887
3888/* Casts */
3889LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
3890 LLVMTypeRef DestTy, const char *Name);
3891LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
3892 LLVMTypeRef DestTy, const char *Name);
3893LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
3894 LLVMTypeRef DestTy, const char *Name);
3895LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
3896 LLVMTypeRef DestTy, const char *Name);
3897LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
3898 LLVMTypeRef DestTy, const char *Name);
3899LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
3900 LLVMTypeRef DestTy, const char *Name);
3901LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
3902 LLVMTypeRef DestTy, const char *Name);
3903LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
3904 LLVMTypeRef DestTy, const char *Name);
3905LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
3906 LLVMTypeRef DestTy, const char *Name);
3907LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
3908 LLVMTypeRef DestTy, const char *Name);
3909LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
3910 LLVMTypeRef DestTy, const char *Name);
3911LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
3912 LLVMTypeRef DestTy, const char *Name);
3913LLVMValueRef LLVMBuildAddrSpaceCast(LLVMBuilderRef, LLVMValueRef Val,
3914 LLVMTypeRef DestTy, const char *Name);
3915LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
3916 LLVMTypeRef DestTy, const char *Name);
3917LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
3918 LLVMTypeRef DestTy, const char *Name);
3919LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
3920 LLVMTypeRef DestTy, const char *Name);
3921LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val,
3922 LLVMTypeRef DestTy, const char *Name);
3923LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val,
3924 LLVMTypeRef DestTy, const char *Name);
3925LLVMValueRef LLVMBuildIntCast2(LLVMBuilderRef, LLVMValueRef Val,
3926 LLVMTypeRef DestTy, LLVMBool IsSigned,
3927 const char *Name);
3928LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val,
3929 LLVMTypeRef DestTy, const char *Name);
3930
3931/** Deprecated: This cast is always signed. Use LLVMBuildIntCast2 instead. */
3932LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val, /*Signed cast!*/
3933 LLVMTypeRef DestTy, const char *Name);
3934
3935/* Comparisons */
3936LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
3937 LLVMValueRef LHS, LLVMValueRef RHS,
3938 const char *Name);
3939LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
3940 LLVMValueRef LHS, LLVMValueRef RHS,
3941 const char *Name);
3942
3943/* Miscellaneous instructions */
3944LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
3945// LLVMBuildCall is deprecated in favor of LLVMBuildCall2, in preparation for
3946// opaque pointer types.
3947LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
3948 LLVMValueRef *Args, unsigned NumArgs,
3949 const char *Name);
3950LLVMValueRef LLVMBuildCall2(LLVMBuilderRef, LLVMTypeRef, LLVMValueRef Fn,
3951 LLVMValueRef *Args, unsigned NumArgs,
3952 const char *Name);
3953LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
3954 LLVMValueRef Then, LLVMValueRef Else,
3955 const char *Name);
3956LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
3957 const char *Name);
3958LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
3959 LLVMValueRef Index, const char *Name);
3960LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
3961 LLVMValueRef EltVal, LLVMValueRef Index,
3962 const char *Name);
3963LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
3964 LLVMValueRef V2, LLVMValueRef Mask,
3965 const char *Name);
3966LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal,
3967 unsigned Index, const char *Name);
3968LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal,
3969 LLVMValueRef EltVal, unsigned Index,
3970 const char *Name);
3971LLVMValueRef LLVMBuildFreeze(LLVMBuilderRef, LLVMValueRef Val,
3972 const char *Name);
3973
3974LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val,
3975 const char *Name);
3976LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val,
3977 const char *Name);
3978LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS,
3979 LLVMValueRef RHS, const char *Name);
3980LLVMValueRef LLVMBuildFence(LLVMBuilderRef B, LLVMAtomicOrdering ordering,
3981 LLVMBool singleThread, const char *Name);
3982LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B, LLVMAtomicRMWBinOp op,
3983 LLVMValueRef PTR, LLVMValueRef Val,
3984 LLVMAtomicOrdering ordering,
3985 LLVMBool singleThread);
3986LLVMValueRef LLVMBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Ptr,
3987 LLVMValueRef Cmp, LLVMValueRef New,
3988 LLVMAtomicOrdering SuccessOrdering,
3989 LLVMAtomicOrdering FailureOrdering,
3990 LLVMBool SingleThread);
3991
3992/**
3993 * Get the number of elements in the mask of a ShuffleVector instruction.
3994 */
3995unsigned LLVMGetNumMaskElements(LLVMValueRef ShuffleVectorInst);
3996
3997/**
3998 * \returns a constant that specifies that the result of a \c ShuffleVectorInst
3999 * is undefined.
4000 */
4001int LLVMGetUndefMaskElem(void);
4002
4003/**
4004 * Get the mask value at position Elt in the mask of a ShuffleVector
4005 * instruction.
4006 *
4007 * \Returns the result of \c LLVMGetUndefMaskElem() if the mask value is undef
4008 * at that position.
4009 */
4010int LLVMGetMaskValue(LLVMValueRef ShuffleVectorInst, unsigned Elt);
4011
4012LLVMBool LLVMIsAtomicSingleThread(LLVMValueRef AtomicInst);
4013void LLVMSetAtomicSingleThread(LLVMValueRef AtomicInst, LLVMBool SingleThread);
4014
4015LLVMAtomicOrdering LLVMGetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst);
4016void LLVMSetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst,
4017 LLVMAtomicOrdering Ordering);
4018LLVMAtomicOrdering LLVMGetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst);
4019void LLVMSetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst,
4020 LLVMAtomicOrdering Ordering);
4021
4022/**
4023 * @}
4024 */
4025
4026/**
4027 * @defgroup LLVMCCoreModuleProvider Module Providers
4028 *
4029 * @{
4030 */
4031
4032/**
4033 * Changes the type of M so it can be passed to FunctionPassManagers and the
4034 * JIT. They take ModuleProviders for historical reasons.
4035 */
4036LLVMModuleProviderRef
4037LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
4038
4039/**
4040 * Destroys the module M.
4041 */
4042void LLVMDisposeModuleProvider(LLVMModuleProviderRef M);
4043
4044/**
4045 * @}
4046 */
4047
4048/**
4049 * @defgroup LLVMCCoreMemoryBuffers Memory Buffers
4050 *
4051 * @{
4052 */
4053
4054LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
4055 LLVMMemoryBufferRef *OutMemBuf,
4056 char **OutMessage);
4057LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
4058 char **OutMessage);
4059LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRange(const char *InputData,
4060 size_t InputDataLength,
4061 const char *BufferName,
4062 LLVMBool RequiresNullTerminator);
4063LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRangeCopy(const char *InputData,
4064 size_t InputDataLength,
4065 const char *BufferName);
4066const char *LLVMGetBufferStart(LLVMMemoryBufferRef MemBuf);
4067size_t LLVMGetBufferSize(LLVMMemoryBufferRef MemBuf);
4068void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
4069
4070/**
4071 * @}
4072 */
4073
4074/**
4075 * @defgroup LLVMCCorePassRegistry Pass Registry
4076 *
4077 * @{
4078 */
4079
4080/** Return the global pass registry, for use with initialization functions.
4081 @see llvm::PassRegistry::getPassRegistry */
4082LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void);
4083
4084/**
4085 * @}
4086 */
4087
4088/**
4089 * @defgroup LLVMCCorePassManagers Pass Managers
4090 *
4091 * @{
4092 */
4093
4094/** Constructs a new whole-module pass pipeline. This type of pipeline is
4095 suitable for link-time optimization and whole-module transformations.
4096 @see llvm::PassManager::PassManager */
4097LLVMPassManagerRef LLVMCreatePassManager(void);
4098
4099/** Constructs a new function-by-function pass pipeline over the module
4100 provider. It does not take ownership of the module provider. This type of
4101 pipeline is suitable for code generation and JIT compilation tasks.
4102 @see llvm::FunctionPassManager::FunctionPassManager */
4103LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M);
4104
4105/** Deprecated: Use LLVMCreateFunctionPassManagerForModule instead. */
4106LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP);
4107
4108/** Initializes, executes on the provided module, and finalizes all of the
4109 passes scheduled in the pass manager. Returns 1 if any of the passes
4110 modified the module, 0 otherwise.
4111 @see llvm::PassManager::run(Module&) */
4112LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M);
4113
4114/** Initializes all of the function passes scheduled in the function pass
4115 manager. Returns 1 if any of the passes modified the module, 0 otherwise.
4116 @see llvm::FunctionPassManager::doInitialization */
4117LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM);
4118
4119/** Executes all of the function passes scheduled in the function pass manager
4120 on the provided function. Returns 1 if any of the passes modified the
4121 function, false otherwise.
4122 @see llvm::FunctionPassManager::run(Function&) */
4123LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F);
4124
4125/** Finalizes all of the function passes scheduled in the function pass
4126 manager. Returns 1 if any of the passes modified the module, 0 otherwise.
4127 @see llvm::FunctionPassManager::doFinalization */
4128LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM);
4129
4130/** Frees the memory of a pass pipeline. For function pipelines, does not free
4131 the module provider.
4132 @see llvm::PassManagerBase::~PassManagerBase. */
4133void LLVMDisposePassManager(LLVMPassManagerRef PM);
4134
4135/**
4136 * @}
4137 */
4138
4139/**
4140 * @defgroup LLVMCCoreThreading Threading
4141 *
4142 * Handle the structures needed to make LLVM safe for multithreading.
4143 *
4144 * @{
4145 */
4146
4147/** Deprecated: Multi-threading can only be enabled/disabled with the compile
4148 time define LLVM_ENABLE_THREADS. This function always returns
4149 LLVMIsMultithreaded(). */
4150LLVMBool LLVMStartMultithreaded(void);
4151
4152/** Deprecated: Multi-threading can only be enabled/disabled with the compile
4153 time define LLVM_ENABLE_THREADS. */
4154void LLVMStopMultithreaded(void);
4155
4156/** Check whether LLVM is executing in thread-safe mode or not.
4157 @see llvm::llvm_is_multithreaded */
4158LLVMBool LLVMIsMultithreaded(void);
4159
4160/**
4161 * @}
4162 */
4163
4164/**
4165 * @}
4166 */
4167
4168/**
4169 * @}
4170 */
4171
4172LLVM_C_EXTERN_C_END
4173
4174#endif /* LLVM_C_CORE_H */
4175