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

source code of llvm/include/llvm-c/Core.h