LLVM  4.0.0
Core.h
Go to the documentation of this file.
1 /*===-- llvm-c/Core.h - Core Library C Interface ------------------*- C -*-===*\
2 |* *|
3 |* The LLVM Compiler Infrastructure *|
4 |* *|
5 |* This file is distributed under the University of Illinois Open Source *|
6 |* License. See LICENSE.TXT for details. *|
7 |* *|
8 |*===----------------------------------------------------------------------===*|
9 |* *|
10 |* This header declares the C interface to libLLVMCore.a, which implements *|
11 |* the LLVM intermediate representation. *|
12 |* *|
13 \*===----------------------------------------------------------------------===*/
14 
15 #ifndef LLVM_C_CORE_H
16 #define LLVM_C_CORE_H
17 
18 #include "llvm-c/ErrorHandling.h"
19 #include "llvm-c/Types.h"
20 
21 #ifdef __cplusplus
22 extern "C" {
23 #endif
24 
25 /**
26  * @defgroup LLVMC LLVM-C: C interface to LLVM
27  *
28  * This module exposes parts of the LLVM library as a C API.
29  *
30  * @{
31  */
32 
33 /**
34  * @defgroup LLVMCTransforms Transforms
35  */
36 
37 /**
38  * @defgroup LLVMCCore Core
39  *
40  * This modules provide an interface to libLLVMCore, which implements
41  * the LLVM intermediate representation as well as other related types
42  * and utilities.
43  *
44  * Many exotic languages can interoperate with C code but have a harder time
45  * with C++ due to name mangling. So in addition to C, this interface enables
46  * tools written in such languages.
47  *
48  * @{
49  */
50 
51 /**
52  * @defgroup LLVMCCoreTypes Types and Enumerations
53  *
54  * @{
55  */
56 
57 typedef enum {
58  /* Terminator Instructions */
59  LLVMRet = 1,
60  LLVMBr = 2,
64  /* removed 6 due to API changes */
66 
67  /* Standard Binary Operators */
68  LLVMAdd = 8,
69  LLVMFAdd = 9,
70  LLVMSub = 10,
71  LLVMFSub = 11,
72  LLVMMul = 12,
73  LLVMFMul = 13,
74  LLVMUDiv = 14,
75  LLVMSDiv = 15,
76  LLVMFDiv = 16,
77  LLVMURem = 17,
78  LLVMSRem = 18,
79  LLVMFRem = 19,
80 
81  /* Logical Operators */
82  LLVMShl = 20,
83  LLVMLShr = 21,
84  LLVMAShr = 22,
85  LLVMAnd = 23,
86  LLVMOr = 24,
87  LLVMXor = 25,
88 
89  /* Memory Operators */
90  LLVMAlloca = 26,
91  LLVMLoad = 27,
92  LLVMStore = 28,
94 
95  /* Cast Operators */
96  LLVMTrunc = 30,
97  LLVMZExt = 31,
98  LLVMSExt = 32,
99  LLVMFPToUI = 33,
104  LLVMFPExt = 38,
109 
110  /* Other Operators */
111  LLVMICmp = 42,
112  LLVMFCmp = 43,
113  LLVMPHI = 44,
114  LLVMCall = 45,
118  LLVMVAArg = 49,
124 
125  /* Atomic operators */
126  LLVMFence = 55,
129 
130  /* Exception Handling Operators */
138 } LLVMOpcode;
139 
140 typedef enum {
141  LLVMVoidTypeKind, /**< type with no size */
142  LLVMHalfTypeKind, /**< 16 bit floating point type */
143  LLVMFloatTypeKind, /**< 32 bit floating point type */
144  LLVMDoubleTypeKind, /**< 64 bit floating point type */
145  LLVMX86_FP80TypeKind, /**< 80 bit floating point type (X87) */
146  LLVMFP128TypeKind, /**< 128 bit floating point type (112-bit mantissa)*/
147  LLVMPPC_FP128TypeKind, /**< 128 bit floating point type (two 64-bits) */
148  LLVMLabelTypeKind, /**< Labels */
149  LLVMIntegerTypeKind, /**< Arbitrary bit width integers */
150  LLVMFunctionTypeKind, /**< Functions */
151  LLVMStructTypeKind, /**< Structures */
152  LLVMArrayTypeKind, /**< Arrays */
153  LLVMPointerTypeKind, /**< Pointers */
154  LLVMVectorTypeKind, /**< SIMD 'packed' format, or other vector type */
155  LLVMMetadataTypeKind, /**< Metadata */
156  LLVMX86_MMXTypeKind, /**< X86 MMX */
157  LLVMTokenTypeKind /**< Tokens */
158 } LLVMTypeKind;
159 
160 typedef enum {
161  LLVMExternalLinkage, /**< Externally visible function */
163  LLVMLinkOnceAnyLinkage, /**< Keep one copy of function when linking (inline)*/
164  LLVMLinkOnceODRLinkage, /**< Same, but only replaced by something
165  equivalent. */
167  LLVMWeakAnyLinkage, /**< Keep one copy of function when linking (weak) */
168  LLVMWeakODRLinkage, /**< Same, but only replaced by something
169  equivalent. */
170  LLVMAppendingLinkage, /**< Special purpose, only applies to global arrays */
171  LLVMInternalLinkage, /**< Rename collisions when linking (static
172  functions) */
173  LLVMPrivateLinkage, /**< Like Internal, but omit from symbol table */
174  LLVMDLLImportLinkage, /**< Obsolete */
175  LLVMDLLExportLinkage, /**< Obsolete */
176  LLVMExternalWeakLinkage,/**< ExternalWeak linkage description */
177  LLVMGhostLinkage, /**< Obsolete */
178  LLVMCommonLinkage, /**< Tentative definitions */
179  LLVMLinkerPrivateLinkage, /**< Like Private, but linker removes. */
180  LLVMLinkerPrivateWeakLinkage /**< Like LinkerPrivate, but is weak. */
181 } LLVMLinkage;
182 
183 typedef enum {
184  LLVMDefaultVisibility, /**< The GV is visible */
185  LLVMHiddenVisibility, /**< The GV is hidden */
186  LLVMProtectedVisibility /**< The GV is protected */
188 
189 typedef enum {
191  LLVMDLLImportStorageClass = 1, /**< Function to be imported from DLL. */
192  LLVMDLLExportStorageClass = 2 /**< Function to be accessible from DLL. */
194 
195 typedef enum {
203 } LLVMCallConv;
204 
205 typedef enum {
211 
221 
230 
233 
235 } LLVMValueKind;
236 
237 typedef enum {
238  LLVMIntEQ = 32, /**< equal */
239  LLVMIntNE, /**< not equal */
240  LLVMIntUGT, /**< unsigned greater than */
241  LLVMIntUGE, /**< unsigned greater or equal */
242  LLVMIntULT, /**< unsigned less than */
243  LLVMIntULE, /**< unsigned less or equal */
244  LLVMIntSGT, /**< signed greater than */
245  LLVMIntSGE, /**< signed greater or equal */
246  LLVMIntSLT, /**< signed less than */
247  LLVMIntSLE /**< signed less or equal */
249 
250 typedef enum {
251  LLVMRealPredicateFalse, /**< Always false (always folded) */
252  LLVMRealOEQ, /**< True if ordered and equal */
253  LLVMRealOGT, /**< True if ordered and greater than */
254  LLVMRealOGE, /**< True if ordered and greater than or equal */
255  LLVMRealOLT, /**< True if ordered and less than */
256  LLVMRealOLE, /**< True if ordered and less than or equal */
257  LLVMRealONE, /**< True if ordered and operands are unequal */
258  LLVMRealORD, /**< True if ordered (no nans) */
259  LLVMRealUNO, /**< True if unordered: isnan(X) | isnan(Y) */
260  LLVMRealUEQ, /**< True if unordered or equal */
261  LLVMRealUGT, /**< True if unordered or greater than */
262  LLVMRealUGE, /**< True if unordered, greater than, or equal */
263  LLVMRealULT, /**< True if unordered or less than */
264  LLVMRealULE, /**< True if unordered, less than, or equal */
265  LLVMRealUNE, /**< True if unordered or not equal */
266  LLVMRealPredicateTrue /**< Always true (always folded) */
268 
269 typedef enum {
270  LLVMLandingPadCatch, /**< A catch clause */
271  LLVMLandingPadFilter /**< A filter clause */
273 
274 typedef enum {
281 
282 typedef enum {
283  LLVMAtomicOrderingNotAtomic = 0, /**< A load or store which is not atomic */
284  LLVMAtomicOrderingUnordered = 1, /**< Lowest level of atomicity, guarantees
285  somewhat sane results, lock free. */
286  LLVMAtomicOrderingMonotonic = 2, /**< guarantees that if you take all the
287  operations affecting a specific address,
288  a consistent ordering exists */
289  LLVMAtomicOrderingAcquire = 4, /**< Acquire provides a barrier of the sort
290  necessary to acquire a lock to access other
291  memory with normal loads and stores. */
292  LLVMAtomicOrderingRelease = 5, /**< Release is similar to Acquire, but with
293  a barrier of the sort necessary to release
294  a lock. */
295  LLVMAtomicOrderingAcquireRelease = 6, /**< provides both an Acquire and a
296  Release barrier (for fences and
297  operations which both read and write
298  memory). */
299  LLVMAtomicOrderingSequentiallyConsistent = 7 /**< provides Acquire semantics
300  for loads and Release
301  semantics for stores.
302  Additionally, it guarantees
303  that a total ordering exists
304  between all
305  SequentiallyConsistent
306  operations. */
308 
309 typedef enum {
310  LLVMAtomicRMWBinOpXchg, /**< Set the new value and return the one old */
311  LLVMAtomicRMWBinOpAdd, /**< Add a value and return the old one */
312  LLVMAtomicRMWBinOpSub, /**< Subtract a value and return the old one */
313  LLVMAtomicRMWBinOpAnd, /**< And a value and return the old one */
314  LLVMAtomicRMWBinOpNand, /**< Not-And a value and return the old one */
315  LLVMAtomicRMWBinOpOr, /**< OR a value and return the old one */
316  LLVMAtomicRMWBinOpXor, /**< Xor a value and return the old one */
317  LLVMAtomicRMWBinOpMax, /**< Sets the value if it's greater than the
318  original using a signed comparison and return
319  the old one */
320  LLVMAtomicRMWBinOpMin, /**< Sets the value if it's Smaller than the
321  original using a signed comparison and return
322  the old one */
323  LLVMAtomicRMWBinOpUMax, /**< Sets the value if it's greater than the
324  original using an unsigned comparison and return
325  the old one */
326  LLVMAtomicRMWBinOpUMin /**< Sets the value if it's greater than the
327  original using an unsigned comparison and return
328  the old one */
330 
331 typedef enum {
337 
338 /**
339  * Attribute index are either LLVMAttributeReturnIndex,
340  * LLVMAttributeFunctionIndex or a parameter number from 1 to N.
341  */
342 enum {
344  // ISO C restricts enumerator values to range of 'int'
345  // (4294967295 is too large)
346  // LLVMAttributeFunctionIndex = ~0U,
348 };
349 
350 typedef unsigned LLVMAttributeIndex;
351 
352 /**
353  * @}
354  */
355 
357 
358 /** Deallocate and destroy all ManagedStatic variables.
359  @see llvm::llvm_shutdown
360  @see ManagedStatic */
361 void LLVMShutdown(void);
362 
363 /*===-- Error handling ----------------------------------------------------===*/
364 
365 char *LLVMCreateMessage(const char *Message);
366 void LLVMDisposeMessage(char *Message);
367 
368 /**
369  * @defgroup LLVMCCoreContext Contexts
370  *
371  * Contexts are execution states for the core LLVM IR system.
372  *
373  * Most types are tied to a context instance. Multiple contexts can
374  * exist simultaneously. A single context is not thread safe. However,
375  * different contexts can execute on different threads simultaneously.
376  *
377  * @{
378  */
379 
381 typedef void (*LLVMYieldCallback)(LLVMContextRef, void *);
382 
383 /**
384  * Create a new context.
385  *
386  * Every call to this function should be paired with a call to
387  * LLVMContextDispose() or the context will leak memory.
388  */
389 LLVMContextRef LLVMContextCreate(void);
390 
391 /**
392  * Obtain the global context instance.
393  */
394 LLVMContextRef LLVMGetGlobalContext(void);
395 
396 /**
397  * Set the diagnostic handler for this context.
398  */
399 void LLVMContextSetDiagnosticHandler(LLVMContextRef C,
400  LLVMDiagnosticHandler Handler,
401  void *DiagnosticContext);
402 
403 /**
404  * Get the diagnostic handler of this context.
405  */
407 
408 /**
409  * Get the diagnostic context of this context.
410  */
411 void *LLVMContextGetDiagnosticContext(LLVMContextRef C);
412 
413 /**
414  * Set the yield callback function for this context.
415  *
416  * @see LLVMContext::setYieldCallback()
417  */
418 void LLVMContextSetYieldCallback(LLVMContextRef C, LLVMYieldCallback Callback,
419  void *OpaqueHandle);
420 
421 /**
422  * Destroy a context instance.
423  *
424  * This should be called for every call to LLVMContextCreate() or memory
425  * will be leaked.
426  */
427 void LLVMContextDispose(LLVMContextRef C);
428 
429 /**
430  * Return a string representation of the DiagnosticInfo. Use
431  * LLVMDisposeMessage to free the string.
432  *
433  * @see DiagnosticInfo::print()
434  */
435 char *LLVMGetDiagInfoDescription(LLVMDiagnosticInfoRef DI);
436 
437 /**
438  * Return an enum LLVMDiagnosticSeverity.
439  *
440  * @see DiagnosticInfo::getSeverity()
441  */
442 LLVMDiagnosticSeverity LLVMGetDiagInfoSeverity(LLVMDiagnosticInfoRef DI);
443 
444 unsigned LLVMGetMDKindIDInContext(LLVMContextRef C, const char *Name,
445  unsigned SLen);
446 unsigned LLVMGetMDKindID(const char *Name, unsigned SLen);
447 
448 /**
449  * Return an unique id given the name of a enum attribute,
450  * or 0 if no attribute by that name exists.
451  *
452  * See http://llvm.org/docs/LangRef.html#parameter-attributes
453  * and http://llvm.org/docs/LangRef.html#function-attributes
454  * for the list of available attributes.
455  *
456  * NB: Attribute names and/or id are subject to change without
457  * going through the C API deprecation cycle.
458  */
459 unsigned LLVMGetEnumAttributeKindForName(const char *Name, size_t SLen);
460 unsigned LLVMGetLastEnumAttributeKind(void);
461 
462 /**
463  * Create an enum attribute.
464  */
465 LLVMAttributeRef LLVMCreateEnumAttribute(LLVMContextRef C, unsigned KindID,
466  uint64_t Val);
467 
468 /**
469  * Get the unique id corresponding to the enum attribute
470  * passed as argument.
471  */
473 
474 /**
475  * Get the enum attribute's value. 0 is returned if none exists.
476  */
478 
479 /**
480  * Create a string attribute.
481  */
483  const char *K, unsigned KLength,
484  const char *V, unsigned VLength);
485 
486 /**
487  * Get the string attribute's kind.
488  */
489 const char *LLVMGetStringAttributeKind(LLVMAttributeRef A, unsigned *Length);
490 
491 /**
492  * Get the string attribute's value.
493  */
494 const char *LLVMGetStringAttributeValue(LLVMAttributeRef A, unsigned *Length);
495 
496 /**
497  * Check for the different types of attributes.
498  */
501 
502 /**
503  * @}
504  */
505 
506 /**
507  * @defgroup LLVMCCoreModule Modules
508  *
509  * Modules represent the top-level structure in an LLVM program. An LLVM
510  * module is effectively a translation unit or a collection of
511  * translation units merged together.
512  *
513  * @{
514  */
515 
516 /**
517  * Create a new, empty module in the global context.
518  *
519  * This is equivalent to calling LLVMModuleCreateWithNameInContext with
520  * LLVMGetGlobalContext() as the context parameter.
521  *
522  * Every invocation should be paired with LLVMDisposeModule() or memory
523  * will be leaked.
524  */
525 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
526 
527 /**
528  * Create a new, empty module in a specific context.
529  *
530  * Every invocation should be paired with LLVMDisposeModule() or memory
531  * will be leaked.
532  */
534  LLVMContextRef C);
535 /**
536  * Return an exact copy of the specified module.
537  */
539 
540 /**
541  * Destroy a module instance.
542  *
543  * This must be called for every created module or memory will be
544  * leaked.
545  */
547 
548 /**
549  * Obtain the identifier of a module.
550  *
551  * @param M Module to obtain identifier of
552  * @param Len Out parameter which holds the length of the returned string.
553  * @return The identifier of M.
554  * @see Module::getModuleIdentifier()
555  */
556 const char *LLVMGetModuleIdentifier(LLVMModuleRef M, size_t *Len);
557 
558 /**
559  * Set the identifier of a module to a string Ident with length Len.
560  *
561  * @param M The module to set identifier
562  * @param Ident The string to set M's identifier to
563  * @param Len Length of Ident
564  * @see Module::setModuleIdentifier()
565  */
566 void LLVMSetModuleIdentifier(LLVMModuleRef M, const char *Ident, size_t Len);
567 
568 /**
569  * Obtain the data layout for a module.
570  *
571  * @see Module::getDataLayoutStr()
572  *
573  * LLVMGetDataLayout is DEPRECATED, as the name is not only incorrect,
574  * but match the name of another method on the module. Prefer the use
575  * of LLVMGetDataLayoutStr, which is not ambiguous.
576  */
577 const char *LLVMGetDataLayoutStr(LLVMModuleRef M);
578 const char *LLVMGetDataLayout(LLVMModuleRef M);
579 
580 /**
581  * Set the data layout for a module.
582  *
583  * @see Module::setDataLayout()
584  */
585 void LLVMSetDataLayout(LLVMModuleRef M, const char *DataLayoutStr);
586 
587 /**
588  * Obtain the target triple for a module.
589  *
590  * @see Module::getTargetTriple()
591  */
592 const char *LLVMGetTarget(LLVMModuleRef M);
593 
594 /**
595  * Set the target triple for a module.
596  *
597  * @see Module::setTargetTriple()
598  */
599 void LLVMSetTarget(LLVMModuleRef M, const char *Triple);
600 
601 /**
602  * Dump a representation of a module to stderr.
603  *
604  * @see Module::dump()
605  */
607 
608 /**
609  * Print a representation of a module to a file. The ErrorMessage needs to be
610  * disposed with LLVMDisposeMessage. Returns 0 on success, 1 otherwise.
611  *
612  * @see Module::print()
613  */
614 LLVMBool LLVMPrintModuleToFile(LLVMModuleRef M, const char *Filename,
615  char **ErrorMessage);
616 
617 /**
618  * Return a string representation of the module. Use
619  * LLVMDisposeMessage to free the string.
620  *
621  * @see Module::print()
622  */
624 
625 /**
626  * Set inline assembly for a module.
627  *
628  * @see Module::setModuleInlineAsm()
629  */
630 void LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm);
631 
632 /**
633  * Obtain the context to which this module is associated.
634  *
635  * @see Module::getContext()
636  */
637 LLVMContextRef LLVMGetModuleContext(LLVMModuleRef M);
638 
639 /**
640  * Obtain a Type from a module by its registered name.
641  */
643 
644 /**
645  * Obtain the number of operands for named metadata in a module.
646  *
647  * @see llvm::Module::getNamedMetadata()
648  */
649 unsigned LLVMGetNamedMetadataNumOperands(LLVMModuleRef M, const char *Name);
650 
651 /**
652  * Obtain the named metadata operands for a module.
653  *
654  * The passed LLVMValueRef pointer should refer to an array of
655  * LLVMValueRef at least LLVMGetNamedMetadataNumOperands long. This
656  * array will be populated with the LLVMValueRef instances. Each
657  * instance corresponds to a llvm::MDNode.
658  *
659  * @see llvm::Module::getNamedMetadata()
660  * @see llvm::MDNode::getOperand()
661  */
663  LLVMValueRef *Dest);
664 
665 /**
666  * Add an operand to named metadata.
667  *
668  * @see llvm::Module::getNamedMetadata()
669  * @see llvm::MDNode::addOperand()
670  */
672  LLVMValueRef Val);
673 
674 /**
675  * Add a function to a module under a specified name.
676  *
677  * @see llvm::Function::Create()
678  */
680  LLVMTypeRef FunctionTy);
681 
682 /**
683  * Obtain a Function value from a Module by its name.
684  *
685  * The returned value corresponds to a llvm::Function value.
686  *
687  * @see llvm::Module::getFunction()
688  */
690 
691 /**
692  * Obtain an iterator to the first Function in a Module.
693  *
694  * @see llvm::Module::begin()
695  */
697 
698 /**
699  * Obtain an iterator to the last Function in a Module.
700  *
701  * @see llvm::Module::end()
702  */
704 
705 /**
706  * Advance a Function iterator to the next Function.
707  *
708  * Returns NULL if the iterator was already at the end and there are no more
709  * functions.
710  */
712 
713 /**
714  * Decrement a Function iterator to the previous Function.
715  *
716  * Returns NULL if the iterator was already at the beginning and there are
717  * no previous functions.
718  */
720 
721 /**
722  * @}
723  */
724 
725 /**
726  * @defgroup LLVMCCoreType Types
727  *
728  * Types represent the type of a value.
729  *
730  * Types are associated with a context instance. The context internally
731  * deduplicates types so there is only 1 instance of a specific type
732  * alive at a time. In other words, a unique type is shared among all
733  * consumers within a context.
734  *
735  * A Type in the C API corresponds to llvm::Type.
736  *
737  * Types have the following hierarchy:
738  *
739  * types:
740  * integer type
741  * real type
742  * function type
743  * sequence types:
744  * array type
745  * pointer type
746  * vector type
747  * void type
748  * label type
749  * opaque type
750  *
751  * @{
752  */
753 
754 /**
755  * Obtain the enumerated type of a Type instance.
756  *
757  * @see llvm::Type:getTypeID()
758  */
760 
761 /**
762  * Whether the type has a known size.
763  *
764  * Things that don't have a size are abstract types, labels, and void.a
765  *
766  * @see llvm::Type::isSized()
767  */
769 
770 /**
771  * Obtain the context to which this type instance is associated.
772  *
773  * @see llvm::Type::getContext()
774  */
775 LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty);
776 
777 /**
778  * Dump a representation of a type to stderr.
779  *
780  * @see llvm::Type::dump()
781  */
782 void LLVMDumpType(LLVMTypeRef Val);
783 
784 /**
785  * Return a string representation of the type. Use
786  * LLVMDisposeMessage to free the string.
787  *
788  * @see llvm::Type::print()
789  */
791 
792 /**
793  * @defgroup LLVMCCoreTypeInt Integer Types
794  *
795  * Functions in this section operate on integer types.
796  *
797  * @{
798  */
799 
800 /**
801  * Obtain an integer type from a context with specified bit width.
802  */
803 LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C);
804 LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C);
805 LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C);
806 LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C);
807 LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C);
808 LLVMTypeRef LLVMInt128TypeInContext(LLVMContextRef C);
809 LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits);
810 
811 /**
812  * Obtain an integer type from the global context with a specified bit
813  * width.
814  */
821 LLVMTypeRef LLVMIntType(unsigned NumBits);
822 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
823 
824 /**
825  * @}
826  */
827 
828 /**
829  * @defgroup LLVMCCoreTypeFloat Floating Point Types
830  *
831  * @{
832  */
833 
834 /**
835  * Obtain a 16-bit floating point type from a context.
836  */
837 LLVMTypeRef LLVMHalfTypeInContext(LLVMContextRef C);
838 
839 /**
840  * Obtain a 32-bit floating point type from a context.
841  */
842 LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C);
843 
844 /**
845  * Obtain a 64-bit floating point type from a context.
846  */
847 LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C);
848 
849 /**
850  * Obtain a 80-bit floating point type (X87) from a context.
851  */
852 LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C);
853 
854 /**
855  * Obtain a 128-bit floating point type (112-bit mantissa) from a
856  * context.
857  */
858 LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C);
859 
860 /**
861  * Obtain a 128-bit floating point type (two 64-bits) from a context.
862  */
863 LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C);
864 
865 /**
866  * Obtain a floating point type from the global context.
867  *
868  * These map to the functions in this group of the same name.
869  */
876 
877 /**
878  * @}
879  */
880 
881 /**
882  * @defgroup LLVMCCoreTypeFunction Function Types
883  *
884  * @{
885  */
886 
887 /**
888  * Obtain a function type consisting of a specified signature.
889  *
890  * The function is defined as a tuple of a return Type, a list of
891  * parameter types, and whether the function is variadic.
892  */
894  LLVMTypeRef *ParamTypes, unsigned ParamCount,
895  LLVMBool IsVarArg);
896 
897 /**
898  * Returns whether a function type is variadic.
899  */
901 
902 /**
903  * Obtain the Type this function Type returns.
904  */
906 
907 /**
908  * Obtain the number of parameters this function accepts.
909  */
910 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
911 
912 /**
913  * Obtain the types of a function's parameters.
914  *
915  * The Dest parameter should point to a pre-allocated array of
916  * LLVMTypeRef at least LLVMCountParamTypes() large. On return, the
917  * first LLVMCountParamTypes() entries in the array will be populated
918  * with LLVMTypeRef instances.
919  *
920  * @param FunctionTy The function type to operate on.
921  * @param Dest Memory address of an array to be filled with result.
922  */
923 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
924 
925 /**
926  * @}
927  */
928 
929 /**
930  * @defgroup LLVMCCoreTypeStruct Structure Types
931  *
932  * These functions relate to LLVMTypeRef instances.
933  *
934  * @see llvm::StructType
935  *
936  * @{
937  */
938 
939 /**
940  * Create a new structure type in a context.
941  *
942  * A structure is specified by a list of inner elements/types and
943  * whether these can be packed together.
944  *
945  * @see llvm::StructType::create()
946  */
947 LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes,
948  unsigned ElementCount, LLVMBool Packed);
949 
950 /**
951  * Create a new structure type in the global context.
952  *
953  * @see llvm::StructType::create()
954  */
955 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
956  LLVMBool Packed);
957 
958 /**
959  * Create an empty structure in a context having a specified name.
960  *
961  * @see llvm::StructType::create()
962  */
963 LLVMTypeRef LLVMStructCreateNamed(LLVMContextRef C, const char *Name);
964 
965 /**
966  * Obtain the name of a structure.
967  *
968  * @see llvm::StructType::getName()
969  */
970 const char *LLVMGetStructName(LLVMTypeRef Ty);
971 
972 /**
973  * Set the contents of a structure type.
974  *
975  * @see llvm::StructType::setBody()
976  */
977 void LLVMStructSetBody(LLVMTypeRef StructTy, LLVMTypeRef *ElementTypes,
978  unsigned ElementCount, LLVMBool Packed);
979 
980 /**
981  * Get the number of elements defined inside the structure.
982  *
983  * @see llvm::StructType::getNumElements()
984  */
985 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
986 
987 /**
988  * Get the elements within a structure.
989  *
990  * The function is passed the address of a pre-allocated array of
991  * LLVMTypeRef at least LLVMCountStructElementTypes() long. After
992  * invocation, this array will be populated with the structure's
993  * elements. The objects in the destination array will have a lifetime
994  * of the structure type itself, which is the lifetime of the context it
995  * is contained in.
996  */
998 
999 /**
1000  * Get the type of the element at a given index in the structure.
1001  *
1002  * @see llvm::StructType::getTypeAtIndex()
1003  */
1005 
1006 /**
1007  * Determine whether a structure is packed.
1008  *
1009  * @see llvm::StructType::isPacked()
1010  */
1012 
1013 /**
1014  * Determine whether a structure is opaque.
1015  *
1016  * @see llvm::StructType::isOpaque()
1017  */
1019 
1020 /**
1021  * @}
1022  */
1023 
1024 /**
1025  * @defgroup LLVMCCoreTypeSequential Sequential Types
1026  *
1027  * Sequential types represents "arrays" of types. This is a super class
1028  * for array, vector, and pointer types.
1029  *
1030  * @{
1031  */
1032 
1033 /**
1034  * Obtain the type of elements within a sequential type.
1035  *
1036  * This works on array, vector, and pointer types.
1037  *
1038  * @see llvm::SequentialType::getElementType()
1039  */
1041 
1042 /**
1043  * Create a fixed size array type that refers to a specific type.
1044  *
1045  * The created type will exist in the context that its element type
1046  * exists in.
1047  *
1048  * @see llvm::ArrayType::get()
1049  */
1050 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
1051 
1052 /**
1053  * Obtain the length of an array type.
1054  *
1055  * This only works on types that represent arrays.
1056  *
1057  * @see llvm::ArrayType::getNumElements()
1058  */
1059 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
1060 
1061 /**
1062  * Create a pointer type that points to a defined type.
1063  *
1064  * The created type will exist in the context that its pointee type
1065  * exists in.
1066  *
1067  * @see llvm::PointerType::get()
1068  */
1069 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace);
1070 
1071 /**
1072  * Obtain the address space of a pointer type.
1073  *
1074  * This only works on types that represent pointers.
1075  *
1076  * @see llvm::PointerType::getAddressSpace()
1077  */
1079 
1080 /**
1081  * Create a vector type that contains a defined type and has a specific
1082  * number of elements.
1083  *
1084  * The created type will exist in the context thats its element type
1085  * exists in.
1086  *
1087  * @see llvm::VectorType::get()
1088  */
1089 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
1090 
1091 /**
1092  * Obtain the number of elements in a vector type.
1093  *
1094  * This only works on types that represent vectors.
1095  *
1096  * @see llvm::VectorType::getNumElements()
1097  */
1098 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
1099 
1100 /**
1101  * @}
1102  */
1103 
1104 /**
1105  * @defgroup LLVMCCoreTypeOther Other Types
1106  *
1107  * @{
1108  */
1109 
1110 /**
1111  * Create a void type in a context.
1112  */
1113 LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C);
1114 
1115 /**
1116  * Create a label type in a context.
1117  */
1118 LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C);
1119 
1120 /**
1121  * Create a X86 MMX type in a context.
1122  */
1123 LLVMTypeRef LLVMX86MMXTypeInContext(LLVMContextRef C);
1124 
1125 /**
1126  * These are similar to the above functions except they operate on the
1127  * global context.
1128  */
1132 
1133 /**
1134  * @}
1135  */
1136 
1137 /**
1138  * @}
1139  */
1140 
1141 /**
1142  * @defgroup LLVMCCoreValues Values
1143  *
1144  * The bulk of LLVM's object model consists of values, which comprise a very
1145  * rich type hierarchy.
1146  *
1147  * LLVMValueRef essentially represents llvm::Value. There is a rich
1148  * hierarchy of classes within this type. Depending on the instance
1149  * obtained, not all APIs are available.
1150  *
1151  * Callers can determine the type of an LLVMValueRef by calling the
1152  * LLVMIsA* family of functions (e.g. LLVMIsAArgument()). These
1153  * functions are defined by a macro, so it isn't obvious which are
1154  * available by looking at the Doxygen source code. Instead, look at the
1155  * source definition of LLVM_FOR_EACH_VALUE_SUBCLASS and note the list
1156  * of value names given. These value names also correspond to classes in
1157  * the llvm::Value hierarchy.
1158  *
1159  * @{
1160  */
1161 
1162 #define LLVM_FOR_EACH_VALUE_SUBCLASS(macro) \
1163  macro(Argument) \
1164  macro(BasicBlock) \
1165  macro(InlineAsm) \
1166  macro(User) \
1167  macro(Constant) \
1168  macro(BlockAddress) \
1169  macro(ConstantAggregateZero) \
1170  macro(ConstantArray) \
1171  macro(ConstantDataSequential) \
1172  macro(ConstantDataArray) \
1173  macro(ConstantDataVector) \
1174  macro(ConstantExpr) \
1175  macro(ConstantFP) \
1176  macro(ConstantInt) \
1177  macro(ConstantPointerNull) \
1178  macro(ConstantStruct) \
1179  macro(ConstantTokenNone) \
1180  macro(ConstantVector) \
1181  macro(GlobalValue) \
1182  macro(GlobalAlias) \
1183  macro(GlobalObject) \
1184  macro(Function) \
1185  macro(GlobalVariable) \
1186  macro(UndefValue) \
1187  macro(Instruction) \
1188  macro(BinaryOperator) \
1189  macro(CallInst) \
1190  macro(IntrinsicInst) \
1191  macro(DbgInfoIntrinsic) \
1192  macro(DbgDeclareInst) \
1193  macro(MemIntrinsic) \
1194  macro(MemCpyInst) \
1195  macro(MemMoveInst) \
1196  macro(MemSetInst) \
1197  macro(CmpInst) \
1198  macro(FCmpInst) \
1199  macro(ICmpInst) \
1200  macro(ExtractElementInst) \
1201  macro(GetElementPtrInst) \
1202  macro(InsertElementInst) \
1203  macro(InsertValueInst) \
1204  macro(LandingPadInst) \
1205  macro(PHINode) \
1206  macro(SelectInst) \
1207  macro(ShuffleVectorInst) \
1208  macro(StoreInst) \
1209  macro(TerminatorInst) \
1210  macro(BranchInst) \
1211  macro(IndirectBrInst) \
1212  macro(InvokeInst) \
1213  macro(ReturnInst) \
1214  macro(SwitchInst) \
1215  macro(UnreachableInst) \
1216  macro(ResumeInst) \
1217  macro(CleanupReturnInst) \
1218  macro(CatchReturnInst) \
1219  macro(FuncletPadInst) \
1220  macro(CatchPadInst) \
1221  macro(CleanupPadInst) \
1222  macro(UnaryInstruction) \
1223  macro(AllocaInst) \
1224  macro(CastInst) \
1225  macro(AddrSpaceCastInst) \
1226  macro(BitCastInst) \
1227  macro(FPExtInst) \
1228  macro(FPToSIInst) \
1229  macro(FPToUIInst) \
1230  macro(FPTruncInst) \
1231  macro(IntToPtrInst) \
1232  macro(PtrToIntInst) \
1233  macro(SExtInst) \
1234  macro(SIToFPInst) \
1235  macro(TruncInst) \
1236  macro(UIToFPInst) \
1237  macro(ZExtInst) \
1238  macro(ExtractValueInst) \
1239  macro(LoadInst) \
1240  macro(VAArgInst)
1241 
1242 /**
1243  * @defgroup LLVMCCoreValueGeneral General APIs
1244  *
1245  * Functions in this section work on all LLVMValueRef instances,
1246  * regardless of their sub-type. They correspond to functions available
1247  * on llvm::Value.
1248  *
1249  * @{
1250  */
1251 
1252 /**
1253  * Obtain the type of a value.
1254  *
1255  * @see llvm::Value::getType()
1256  */
1258 
1259 /**
1260  * Obtain the enumerated type of a Value instance.
1261  *
1262  * @see llvm::Value::getValueID()
1263  */
1265 
1266 /**
1267  * Obtain the string name of a value.
1268  *
1269  * @see llvm::Value::getName()
1270  */
1271 const char *LLVMGetValueName(LLVMValueRef Val);
1272 
1273 /**
1274  * Set the string name of a value.
1275  *
1276  * @see llvm::Value::setName()
1277  */
1278 void LLVMSetValueName(LLVMValueRef Val, const char *Name);
1279 
1280 /**
1281  * Dump a representation of a value to stderr.
1282  *
1283  * @see llvm::Value::dump()
1284  */
1285 void LLVMDumpValue(LLVMValueRef Val);
1286 
1287 /**
1288  * Return a string representation of the value. Use
1289  * LLVMDisposeMessage to free the string.
1290  *
1291  * @see llvm::Value::print()
1292  */
1294 
1295 /**
1296  * Replace all uses of a value with another one.
1297  *
1298  * @see llvm::Value::replaceAllUsesWith()
1299  */
1300 void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal);
1301 
1302 /**
1303  * Determine whether the specified value instance is constant.
1304  */
1306 
1307 /**
1308  * Determine whether a value instance is undefined.
1309  */
1311 
1312 /**
1313  * Convert value instances between types.
1314  *
1315  * Internally, an LLVMValueRef is "pinned" to a specific type. This
1316  * series of functions allows you to cast an instance to a specific
1317  * type.
1318  *
1319  * If the cast is not valid for the specified type, NULL is returned.
1320  *
1321  * @see llvm::dyn_cast_or_null<>
1322  */
1323 #define LLVM_DECLARE_VALUE_CAST(name) \
1324  LLVMValueRef LLVMIsA##name(LLVMValueRef Val);
1326 
1329 
1330 /**
1331  * @}
1332  */
1333 
1334 /**
1335  * @defgroup LLVMCCoreValueUses Usage
1336  *
1337  * This module defines functions that allow you to inspect the uses of a
1338  * LLVMValueRef.
1339  *
1340  * It is possible to obtain an LLVMUseRef for any LLVMValueRef instance.
1341  * Each LLVMUseRef (which corresponds to a llvm::Use instance) holds a
1342  * llvm::User and llvm::Value.
1343  *
1344  * @{
1345  */
1346 
1347 /**
1348  * Obtain the first use of a value.
1349  *
1350  * Uses are obtained in an iterator fashion. First, call this function
1351  * to obtain a reference to the first use. Then, call LLVMGetNextUse()
1352  * on that instance and all subsequently obtained instances until
1353  * LLVMGetNextUse() returns NULL.
1354  *
1355  * @see llvm::Value::use_begin()
1356  */
1358 
1359 /**
1360  * Obtain the next use of a value.
1361  *
1362  * This effectively advances the iterator. It returns NULL if you are on
1363  * the final use and no more are available.
1364  */
1366 
1367 /**
1368  * Obtain the user value for a user.
1369  *
1370  * The returned value corresponds to a llvm::User type.
1371  *
1372  * @see llvm::Use::getUser()
1373  */
1375 
1376 /**
1377  * Obtain the value this use corresponds to.
1378  *
1379  * @see llvm::Use::get().
1380  */
1382 
1383 /**
1384  * @}
1385  */
1386 
1387 /**
1388  * @defgroup LLVMCCoreValueUser User value
1389  *
1390  * Function in this group pertain to LLVMValueRef instances that descent
1391  * from llvm::User. This includes constants, instructions, and
1392  * operators.
1393  *
1394  * @{
1395  */
1396 
1397 /**
1398  * Obtain an operand at a specific index in a llvm::User value.
1399  *
1400  * @see llvm::User::getOperand()
1401  */
1402 LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index);
1403 
1404 /**
1405  * Obtain the use of an operand at a specific index in a llvm::User value.
1406  *
1407  * @see llvm::User::getOperandUse()
1408  */
1409 LLVMUseRef LLVMGetOperandUse(LLVMValueRef Val, unsigned Index);
1410 
1411 /**
1412  * Set an operand at a specific index in a llvm::User value.
1413  *
1414  * @see llvm::User::setOperand()
1415  */
1416 void LLVMSetOperand(LLVMValueRef User, unsigned Index, LLVMValueRef Val);
1417 
1418 /**
1419  * Obtain the number of operands in a llvm::User value.
1420  *
1421  * @see llvm::User::getNumOperands()
1422  */
1424 
1425 /**
1426  * @}
1427  */
1428 
1429 /**
1430  * @defgroup LLVMCCoreValueConstant Constants
1431  *
1432  * This section contains APIs for interacting with LLVMValueRef that
1433  * correspond to llvm::Constant instances.
1434  *
1435  * These functions will work for any LLVMValueRef in the llvm::Constant
1436  * class hierarchy.
1437  *
1438  * @{
1439  */
1440 
1441 /**
1442  * Obtain a constant value referring to the null instance of a type.
1443  *
1444  * @see llvm::Constant::getNullValue()
1445  */
1446 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
1447 
1448 /**
1449  * Obtain a constant value referring to the instance of a type
1450  * consisting of all ones.
1451  *
1452  * This is only valid for integer types.
1453  *
1454  * @see llvm::Constant::getAllOnesValue()
1455  */
1457 
1458 /**
1459  * Obtain a constant value referring to an undefined value of a type.
1460  *
1461  * @see llvm::UndefValue::get()
1462  */
1464 
1465 /**
1466  * Determine whether a value instance is null.
1467  *
1468  * @see llvm::Constant::isNullValue()
1469  */
1471 
1472 /**
1473  * Obtain a constant that is a constant pointer pointing to NULL for a
1474  * specified type.
1475  */
1477 
1478 /**
1479  * @defgroup LLVMCCoreValueConstantScalar Scalar constants
1480  *
1481  * Functions in this group model LLVMValueRef instances that correspond
1482  * to constants referring to scalar types.
1483  *
1484  * For integer types, the LLVMTypeRef parameter should correspond to a
1485  * llvm::IntegerType instance and the returned LLVMValueRef will
1486  * correspond to a llvm::ConstantInt.
1487  *
1488  * For floating point types, the LLVMTypeRef returned corresponds to a
1489  * llvm::ConstantFP.
1490  *
1491  * @{
1492  */
1493 
1494 /**
1495  * Obtain a constant value for an integer type.
1496  *
1497  * The returned value corresponds to a llvm::ConstantInt.
1498  *
1499  * @see llvm::ConstantInt::get()
1500  *
1501  * @param IntTy Integer type to obtain value of.
1502  * @param N The value the returned instance should refer to.
1503  * @param SignExtend Whether to sign extend the produced value.
1504  */
1505 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
1506  LLVMBool SignExtend);
1507 
1508 /**
1509  * Obtain a constant value for an integer of arbitrary precision.
1510  *
1511  * @see llvm::ConstantInt::get()
1512  */
1514  unsigned NumWords,
1515  const uint64_t Words[]);
1516 
1517 /**
1518  * Obtain a constant value for an integer parsed from a string.
1519  *
1520  * A similar API, LLVMConstIntOfStringAndSize is also available. If the
1521  * string's length is available, it is preferred to call that function
1522  * instead.
1523  *
1524  * @see llvm::ConstantInt::get()
1525  */
1527  uint8_t Radix);
1528 
1529 /**
1530  * Obtain a constant value for an integer parsed from a string with
1531  * specified length.
1532  *
1533  * @see llvm::ConstantInt::get()
1534  */
1536  unsigned SLen, uint8_t Radix);
1537 
1538 /**
1539  * Obtain a constant value referring to a double floating point value.
1540  */
1541 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
1542 
1543 /**
1544  * Obtain a constant for a floating point value parsed from a string.
1545  *
1546  * A similar API, LLVMConstRealOfStringAndSize is also available. It
1547  * should be used if the input string's length is known.
1548  */
1550 
1551 /**
1552  * Obtain a constant for a floating point value parsed from a string.
1553  */
1555  unsigned SLen);
1556 
1557 /**
1558  * Obtain the zero extended value for an integer constant value.
1559  *
1560  * @see llvm::ConstantInt::getZExtValue()
1561  */
1562 unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal);
1563 
1564 /**
1565  * Obtain the sign extended value for an integer constant value.
1566  *
1567  * @see llvm::ConstantInt::getSExtValue()
1568  */
1569 long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal);
1570 
1571 /**
1572  * Obtain the double value for an floating point constant value.
1573  * losesInfo indicates if some precision was lost in the conversion.
1574  *
1575  * @see llvm::ConstantFP::getDoubleValue
1576  */
1577 double LLVMConstRealGetDouble(LLVMValueRef ConstantVal, LLVMBool *losesInfo);
1578 
1579 /**
1580  * @}
1581  */
1582 
1583 /**
1584  * @defgroup LLVMCCoreValueConstantComposite Composite Constants
1585  *
1586  * Functions in this group operate on composite constants.
1587  *
1588  * @{
1589  */
1590 
1591 /**
1592  * Create a ConstantDataSequential and initialize it with a string.
1593  *
1594  * @see llvm::ConstantDataArray::getString()
1595  */
1596 LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str,
1597  unsigned Length, LLVMBool DontNullTerminate);
1598 
1599 /**
1600  * Create a ConstantDataSequential with string content in the global context.
1601  *
1602  * This is the same as LLVMConstStringInContext except it operates on the
1603  * global context.
1604  *
1605  * @see LLVMConstStringInContext()
1606  * @see llvm::ConstantDataArray::getString()
1607  */
1608 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
1609  LLVMBool DontNullTerminate);
1610 
1611 /**
1612  * Returns true if the specified constant is an array of i8.
1613  *
1614  * @see ConstantDataSequential::getAsString()
1615  */
1617 
1618 /**
1619  * Get the given constant data sequential as a string.
1620  *
1621  * @see ConstantDataSequential::getAsString()
1622  */
1623 const char *LLVMGetAsString(LLVMValueRef c, size_t *Length);
1624 
1625 /**
1626  * Create an anonymous ConstantStruct with the specified values.
1627  *
1628  * @see llvm::ConstantStruct::getAnon()
1629  */
1630 LLVMValueRef LLVMConstStructInContext(LLVMContextRef C,
1631  LLVMValueRef *ConstantVals,
1632  unsigned Count, LLVMBool Packed);
1633 
1634 /**
1635  * Create a ConstantStruct in the global Context.
1636  *
1637  * This is the same as LLVMConstStructInContext except it operates on the
1638  * global Context.
1639  *
1640  * @see LLVMConstStructInContext()
1641  */
1642 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
1643  LLVMBool Packed);
1644 
1645 /**
1646  * Create a ConstantArray from values.
1647  *
1648  * @see llvm::ConstantArray::get()
1649  */
1651  LLVMValueRef *ConstantVals, unsigned Length);
1652 
1653 /**
1654  * Create a non-anonymous ConstantStruct from values.
1655  *
1656  * @see llvm::ConstantStruct::get()
1657  */
1659  LLVMValueRef *ConstantVals,
1660  unsigned Count);
1661 
1662 /**
1663  * Get an element at specified index as a constant.
1664  *
1665  * @see ConstantDataSequential::getElementAsConstant()
1666  */
1668 
1669 /**
1670  * Create a ConstantVector from values.
1671  *
1672  * @see llvm::ConstantVector::get()
1673  */
1674 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
1675 
1676 /**
1677  * @}
1678  */
1679 
1680 /**
1681  * @defgroup LLVMCCoreValueConstantExpressions Constant Expressions
1682  *
1683  * Functions in this group correspond to APIs on llvm::ConstantExpr.
1684  *
1685  * @see llvm::ConstantExpr.
1686  *
1687  * @{
1688  */
1697 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1698 LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1699 LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1700 LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1701 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1702 LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1703 LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1704 LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1705 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1706 LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1707 LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1708 LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1709 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1710 LLVMValueRef LLVMConstExactUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1711 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1712 LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1713 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1714 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1715 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1716 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1717 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1718 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1719 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1721  LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1723  LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1724 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1725 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1726 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
1728  LLVMValueRef *ConstantIndices, unsigned NumIndices);
1730  LLVMValueRef *ConstantIndices,
1731  unsigned NumIndices);
1733 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
1734 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
1746  LLVMTypeRef ToType);
1748  LLVMTypeRef ToType);
1750  LLVMTypeRef ToType);
1752  LLVMTypeRef ToType);
1754  LLVMBool isSigned);
1756 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
1757  LLVMValueRef ConstantIfTrue,
1758  LLVMValueRef ConstantIfFalse);
1760  LLVMValueRef IndexConstant);
1762  LLVMValueRef ElementValueConstant,
1763  LLVMValueRef IndexConstant);
1765  LLVMValueRef VectorBConstant,
1766  LLVMValueRef MaskConstant);
1767 LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList,
1768  unsigned NumIdx);
1770  LLVMValueRef ElementValueConstant,
1771  unsigned *IdxList, unsigned NumIdx);
1773  const char *AsmString, const char *Constraints,
1774  LLVMBool HasSideEffects, LLVMBool IsAlignStack);
1776 
1777 /**
1778  * @}
1779  */
1780 
1781 /**
1782  * @defgroup LLVMCCoreValueConstantGlobals Global Values
1783  *
1784  * This group contains functions that operate on global values. Functions in
1785  * this group relate to functions in the llvm::GlobalValue class tree.
1786  *
1787  * @see llvm::GlobalValue
1788  *
1789  * @{
1790  */
1791 
1795 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
1796 const char *LLVMGetSection(LLVMValueRef Global);
1797 void LLVMSetSection(LLVMValueRef Global, const char *Section);
1803 void LLVMSetUnnamedAddr(LLVMValueRef Global, LLVMBool HasUnnamedAddr);
1804 
1805 /**
1806  * @defgroup LLVMCCoreValueWithAlignment Values with alignment
1807  *
1808  * Functions in this group only apply to values with alignment, i.e.
1809  * global variables, load and store instructions.
1810  */
1811 
1812 /**
1813  * Obtain the preferred alignment of the value.
1814  * @see llvm::AllocaInst::getAlignment()
1815  * @see llvm::LoadInst::getAlignment()
1816  * @see llvm::StoreInst::getAlignment()
1817  * @see llvm::GlobalValue::getAlignment()
1818  */
1819 unsigned LLVMGetAlignment(LLVMValueRef V);
1820 
1821 /**
1822  * Set the preferred alignment of the value.
1823  * @see llvm::AllocaInst::setAlignment()
1824  * @see llvm::LoadInst::setAlignment()
1825  * @see llvm::StoreInst::setAlignment()
1826  * @see llvm::GlobalValue::setAlignment()
1827  */
1828 void LLVMSetAlignment(LLVMValueRef V, unsigned Bytes);
1829 
1830 /**
1831  * @}
1832  */
1833 
1834 /**
1835  * @defgroup LLVMCoreValueConstantGlobalVariable Global Variables
1836  *
1837  * This group contains functions that operate on global variable values.
1838  *
1839  * @see llvm::GlobalVariable
1840  *
1841  * @{
1842  */
1845  const char *Name,
1846  unsigned AddressSpace);
1852 void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
1854 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
1856 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal);
1858 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant);
1862 void LLVMSetExternallyInitialized(LLVMValueRef GlobalVar, LLVMBool IsExtInit);
1863 
1864 /**
1865  * @}
1866  */
1867 
1868 /**
1869  * @defgroup LLVMCoreValueConstantGlobalAlias Global Aliases
1870  *
1871  * This group contains function that operate on global alias values.
1872  *
1873  * @see llvm::GlobalAlias
1874  *
1875  * @{
1876  */
1878  const char *Name);
1879 
1880 /**
1881  * @}
1882  */
1883 
1884 /**
1885  * @defgroup LLVMCCoreValueFunction Function values
1886  *
1887  * Functions in this group operate on LLVMValueRef instances that
1888  * correspond to llvm::Function instances.
1889  *
1890  * @see llvm::Function
1891  *
1892  * @{
1893  */
1894 
1895 /**
1896  * Remove a function from its containing module and deletes it.
1897  *
1898  * @see llvm::Function::eraseFromParent()
1899  */
1901 
1902 /**
1903  * Check whether the given function has a personality function.
1904  *
1905  * @see llvm::Function::hasPersonalityFn()
1906  */
1908 
1909 /**
1910  * Obtain the personality function attached to the function.
1911  *
1912  * @see llvm::Function::getPersonalityFn()
1913  */
1915 
1916 /**
1917  * Set the personality function attached to the function.
1918  *
1919  * @see llvm::Function::setPersonalityFn()
1920  */
1921 void LLVMSetPersonalityFn(LLVMValueRef Fn, LLVMValueRef PersonalityFn);
1922 
1923 /**
1924  * Obtain the ID number from a function instance.
1925  *
1926  * @see llvm::Function::getIntrinsicID()
1927  */
1928 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
1929 
1930 /**
1931  * Obtain the calling function of a function.
1932  *
1933  * The returned value corresponds to the LLVMCallConv enumeration.
1934  *
1935  * @see llvm::Function::getCallingConv()
1936  */
1938 
1939 /**
1940  * Set the calling convention of a function.
1941  *
1942  * @see llvm::Function::setCallingConv()
1943  *
1944  * @param Fn Function to operate on
1945  * @param CC LLVMCallConv to set calling convention to
1946  */
1947 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
1948 
1949 /**
1950  * Obtain the name of the garbage collector to use during code
1951  * generation.
1952  *
1953  * @see llvm::Function::getGC()
1954  */
1955 const char *LLVMGetGC(LLVMValueRef Fn);
1956 
1957 /**
1958  * Define the garbage collector to use during code generation.
1959  *
1960  * @see llvm::Function::setGC()
1961  */
1962 void LLVMSetGC(LLVMValueRef Fn, const char *Name);
1963 
1964 /**
1965  * Add an attribute to a function.
1966  *
1967  * @see llvm::Function::addAttribute()
1968  */
1969 void LLVMAddAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
1971 unsigned LLVMGetAttributeCountAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx);
1972 void LLVMGetAttributesAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
1973  LLVMAttributeRef *Attrs);
1975  LLVMAttributeIndex Idx,
1976  unsigned KindID);
1978  LLVMAttributeIndex Idx,
1979  const char *K, unsigned KLen);
1980 void LLVMRemoveEnumAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
1981  unsigned KindID);
1982 void LLVMRemoveStringAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
1983  const char *K, unsigned KLen);
1984 
1985 /**
1986  * Add a target-dependent attribute to a function
1987  * @see llvm::AttrBuilder::addAttribute()
1988  */
1990  const char *V);
1991 
1992 /**
1993  * @defgroup LLVMCCoreValueFunctionParameters Function Parameters
1994  *
1995  * Functions in this group relate to arguments/parameters on functions.
1996  *
1997  * Functions in this group expect LLVMValueRef instances that correspond
1998  * to llvm::Function instances.
1999  *
2000  * @{
2001  */
2002 
2003 /**
2004  * Obtain the number of parameters in a function.
2005  *
2006  * @see llvm::Function::arg_size()
2007  */
2008 unsigned LLVMCountParams(LLVMValueRef Fn);
2009 
2010 /**
2011  * Obtain the parameters in a function.
2012  *
2013  * The takes a pointer to a pre-allocated array of LLVMValueRef that is
2014  * at least LLVMCountParams() long. This array will be filled with
2015  * LLVMValueRef instances which correspond to the parameters the
2016  * function receives. Each LLVMValueRef corresponds to a llvm::Argument
2017  * instance.
2018  *
2019  * @see llvm::Function::arg_begin()
2020  */
2021 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
2022 
2023 /**
2024  * Obtain the parameter at the specified index.
2025  *
2026  * Parameters are indexed from 0.
2027  *
2028  * @see llvm::Function::arg_begin()
2029  */
2030 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
2031 
2032 /**
2033  * Obtain the function to which this argument belongs.
2034  *
2035  * Unlike other functions in this group, this one takes an LLVMValueRef
2036  * that corresponds to a llvm::Attribute.
2037  *
2038  * The returned LLVMValueRef is the llvm::Function to which this
2039  * argument belongs.
2040  */
2042 
2043 /**
2044  * Obtain the first parameter to a function.
2045  *
2046  * @see llvm::Function::arg_begin()
2047  */
2049 
2050 /**
2051  * Obtain the last parameter to a function.
2052  *
2053  * @see llvm::Function::arg_end()
2054  */
2056 
2057 /**
2058  * Obtain the next parameter to a function.
2059  *
2060  * This takes an LLVMValueRef obtained from LLVMGetFirstParam() (which is
2061  * actually a wrapped iterator) and obtains the next parameter from the
2062  * underlying iterator.
2063  */
2065 
2066 /**
2067  * Obtain the previous parameter to a function.
2068  *
2069  * This is the opposite of LLVMGetNextParam().
2070  */
2072 
2073 /**
2074  * Set the alignment for a function parameter.
2075  *
2076  * @see llvm::Argument::addAttr()
2077  * @see llvm::AttrBuilder::addAlignmentAttr()
2078  */
2079 void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned Align);
2080 
2081 /**
2082  * @}
2083  */
2084 
2085 /**
2086  * @}
2087  */
2088 
2089 /**
2090  * @}
2091  */
2092 
2093 /**
2094  * @}
2095  */
2096 
2097 /**
2098  * @defgroup LLVMCCoreValueMetadata Metadata
2099  *
2100  * @{
2101  */
2102 
2103 /**
2104  * Obtain a MDString value from a context.
2105  *
2106  * The returned instance corresponds to the llvm::MDString class.
2107  *
2108  * The instance is specified by string data of a specified length. The
2109  * string content is copied, so the backing memory can be freed after
2110  * this function returns.
2111  */
2112 LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str,
2113  unsigned SLen);
2114 
2115 /**
2116  * Obtain a MDString value from the global context.
2117  */
2118 LLVMValueRef LLVMMDString(const char *Str, unsigned SLen);
2119 
2120 /**
2121  * Obtain a MDNode value from a context.
2122  *
2123  * The returned value corresponds to the llvm::MDNode class.
2124  */
2126  unsigned Count);
2127 
2128 /**
2129  * Obtain a MDNode value from the global context.
2130  */
2131 LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count);
2132 
2133 /**
2134  * Obtain the underlying string from a MDString value.
2135  *
2136  * @param V Instance to obtain string from.
2137  * @param Length Memory address which will hold length of returned string.
2138  * @return String data in MDString.
2139  */
2140 const char *LLVMGetMDString(LLVMValueRef V, unsigned *Length);
2141 
2142 /**
2143  * Obtain the number of operands from an MDNode value.
2144  *
2145  * @param V MDNode to get number of operands from.
2146  * @return Number of operands of the MDNode.
2147  */
2149 
2150 /**
2151  * Obtain the given MDNode's operands.
2152  *
2153  * The passed LLVMValueRef pointer should point to enough memory to hold all of
2154  * the operands of the given MDNode (see LLVMGetMDNodeNumOperands) as
2155  * LLVMValueRefs. This memory will be populated with the LLVMValueRefs of the
2156  * MDNode's operands.
2157  *
2158  * @param V MDNode to get the operands from.
2159  * @param Dest Destination array for operands.
2160  */
2162 
2163 /**
2164  * @}
2165  */
2166 
2167 /**
2168  * @defgroup LLVMCCoreValueBasicBlock Basic Block
2169  *
2170  * A basic block represents a single entry single exit section of code.
2171  * Basic blocks contain a list of instructions which form the body of
2172  * the block.
2173  *
2174  * Basic blocks belong to functions. They have the type of label.
2175  *
2176  * Basic blocks are themselves values. However, the C API models them as
2177  * LLVMBasicBlockRef.
2178  *
2179  * @see llvm::BasicBlock
2180  *
2181  * @{
2182  */
2183 
2184 /**
2185  * Convert a basic block instance to a value type.
2186  */
2188 
2189 /**
2190  * Determine whether an LLVMValueRef is itself a basic block.
2191  */
2193 
2194 /**
2195  * Convert an LLVMValueRef to an LLVMBasicBlockRef instance.
2196  */
2198 
2199 /**
2200  * Obtain the string name of a basic block.
2201  */
2203 
2204 /**
2205  * Obtain the function to which a basic block belongs.
2206  *
2207  * @see llvm::BasicBlock::getParent()
2208  */
2210 
2211 /**
2212  * Obtain the terminator instruction for a basic block.
2213  *
2214  * If the basic block does not have a terminator (it is not well-formed
2215  * if it doesn't), then NULL is returned.
2216  *
2217  * The returned LLVMValueRef corresponds to a llvm::TerminatorInst.
2218  *
2219  * @see llvm::BasicBlock::getTerminator()
2220  */
2222 
2223 /**
2224  * Obtain the number of basic blocks in a function.
2225  *
2226  * @param Fn Function value to operate on.
2227  */
2228 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
2229 
2230 /**
2231  * Obtain all of the basic blocks in a function.
2232  *
2233  * This operates on a function value. The BasicBlocks parameter is a
2234  * pointer to a pre-allocated array of LLVMBasicBlockRef of at least
2235  * LLVMCountBasicBlocks() in length. This array is populated with
2236  * LLVMBasicBlockRef instances.
2237  */
2238 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
2239 
2240 /**
2241  * Obtain the first basic block in a function.
2242  *
2243  * The returned basic block can be used as an iterator. You will likely
2244  * eventually call into LLVMGetNextBasicBlock() with it.
2245  *
2246  * @see llvm::Function::begin()
2247  */
2249 
2250 /**
2251  * Obtain the last basic block in a function.
2252  *
2253  * @see llvm::Function::end()
2254  */
2256 
2257 /**
2258  * Advance a basic block iterator.
2259  */
2261 
2262 /**
2263  * Go backwards in a basic block iterator.
2264  */
2266 
2267 /**
2268  * Obtain the basic block that corresponds to the entry point of a
2269  * function.
2270  *
2271  * @see llvm::Function::getEntryBlock()
2272  */
2274 
2275 /**
2276  * Append a basic block to the end of a function.
2277  *
2278  * @see llvm::BasicBlock::Create()
2279  */
2281  LLVMValueRef Fn,
2282  const char *Name);
2283 
2284 /**
2285  * Append a basic block to the end of a function using the global
2286  * context.
2287  *
2288  * @see llvm::BasicBlock::Create()
2289  */
2291 
2292 /**
2293  * Insert a basic block in a function before another basic block.
2294  *
2295  * The function to add to is determined by the function of the
2296  * passed basic block.
2297  *
2298  * @see llvm::BasicBlock::Create()
2299  */
2301  LLVMBasicBlockRef BB,
2302  const char *Name);
2303 
2304 /**
2305  * Insert a basic block in a function using the global context.
2306  *
2307  * @see llvm::BasicBlock::Create()
2308  */
2310  const char *Name);
2311 
2312 /**
2313  * Remove a basic block from a function and delete it.
2314  *
2315  * This deletes the basic block from its containing function and deletes
2316  * the basic block itself.
2317  *
2318  * @see llvm::BasicBlock::eraseFromParent()
2319  */
2321 
2322 /**
2323  * Remove a basic block from a function.
2324  *
2325  * This deletes the basic block from its containing function but keep
2326  * the basic block alive.
2327  *
2328  * @see llvm::BasicBlock::removeFromParent()
2329  */
2331 
2332 /**
2333  * Move a basic block to before another one.
2334  *
2335  * @see llvm::BasicBlock::moveBefore()
2336  */
2338 
2339 /**
2340  * Move a basic block to after another one.
2341  *
2342  * @see llvm::BasicBlock::moveAfter()
2343  */
2345 
2346 /**
2347  * Obtain the first instruction in a basic block.
2348  *
2349  * The returned LLVMValueRef corresponds to a llvm::Instruction
2350  * instance.
2351  */
2353 
2354 /**
2355  * Obtain the last instruction in a basic block.
2356  *
2357  * The returned LLVMValueRef corresponds to an LLVM:Instruction.
2358  */
2360 
2361 /**
2362  * @}
2363  */
2364 
2365 /**
2366  * @defgroup LLVMCCoreValueInstruction Instructions
2367  *
2368  * Functions in this group relate to the inspection and manipulation of
2369  * individual instructions.
2370  *
2371  * In the C++ API, an instruction is modeled by llvm::Instruction. This
2372  * class has a large number of descendents. llvm::Instruction is a
2373  * llvm::Value and in the C API, instructions are modeled by
2374  * LLVMValueRef.
2375  *
2376  * This group also contains sub-groups which operate on specific
2377  * llvm::Instruction types, e.g. llvm::CallInst.
2378  *
2379  * @{
2380  */
2381 
2382 /**
2383  * Determine whether an instruction has any metadata attached.
2384  */
2385 int LLVMHasMetadata(LLVMValueRef Val);
2386 
2387 /**
2388  * Return metadata associated with an instruction value.
2389  */
2390 LLVMValueRef LLVMGetMetadata(LLVMValueRef Val, unsigned KindID);
2391 
2392 /**
2393  * Set metadata associated with an instruction value.
2394  */
2395 void LLVMSetMetadata(LLVMValueRef Val, unsigned KindID, LLVMValueRef Node);
2396 
2397 /**
2398  * Obtain the basic block to which an instruction belongs.
2399  *
2400  * @see llvm::Instruction::getParent()
2401  */
2403 
2404 /**
2405  * Obtain the instruction that occurs after the one specified.
2406  *
2407  * The next instruction will be from the same basic block.
2408  *
2409  * If this is the last instruction in a basic block, NULL will be
2410  * returned.
2411  */
2413 
2414 /**
2415  * Obtain the instruction that occurred before this one.
2416  *
2417  * If the instruction is the first instruction in a basic block, NULL
2418  * will be returned.
2419  */
2421 
2422 /**
2423  * Remove and delete an instruction.
2424  *
2425  * The instruction specified is removed from its containing building
2426  * block but is kept alive.
2427  *
2428  * @see llvm::Instruction::removeFromParent()
2429  */
2431 
2432 /**
2433  * Remove and delete an instruction.
2434  *
2435  * The instruction specified is removed from its containing building
2436  * block and then deleted.
2437  *
2438  * @see llvm::Instruction::eraseFromParent()
2439  */
2441 
2442 /**
2443  * Obtain the code opcode for an individual instruction.
2444  *
2445  * @see llvm::Instruction::getOpCode()
2446  */
2448 
2449 /**
2450  * Obtain the predicate of an instruction.
2451  *
2452  * This is only valid for instructions that correspond to llvm::ICmpInst
2453  * or llvm::ConstantExpr whose opcode is llvm::Instruction::ICmp.
2454  *
2455  * @see llvm::ICmpInst::getPredicate()
2456  */
2458 
2459 /**
2460  * Obtain the float predicate of an instruction.
2461  *
2462  * This is only valid for instructions that correspond to llvm::FCmpInst
2463  * or llvm::ConstantExpr whose opcode is llvm::Instruction::FCmp.
2464  *
2465  * @see llvm::FCmpInst::getPredicate()
2466  */
2468 
2469 /**
2470  * Create a copy of 'this' instruction that is identical in all ways
2471  * except the following:
2472  * * The instruction has no parent
2473  * * The instruction has no name
2474  *
2475  * @see llvm::Instruction::clone()
2476  */
2478 
2479 /**
2480  * @defgroup LLVMCCoreValueInstructionCall Call Sites and Invocations
2481  *
2482  * Functions in this group apply to instructions that refer to call
2483  * sites and invocations. These correspond to C++ types in the
2484  * llvm::CallInst class tree.
2485  *
2486  * @{
2487  */
2488 
2489 /**
2490  * Obtain the argument count for a call instruction.
2491  *
2492  * This expects an LLVMValueRef that corresponds to a llvm::CallInst or
2493  * llvm::InvokeInst.
2494  *
2495  * @see llvm::CallInst::getNumArgOperands()
2496  * @see llvm::InvokeInst::getNumArgOperands()
2497  */
2498 unsigned LLVMGetNumArgOperands(LLVMValueRef Instr);
2499 
2500 /**
2501  * Set the calling convention for a call instruction.
2502  *
2503  * This expects an LLVMValueRef that corresponds to a llvm::CallInst or
2504  * llvm::InvokeInst.
2505  *
2506  * @see llvm::CallInst::setCallingConv()
2507  * @see llvm::InvokeInst::setCallingConv()
2508  */
2509 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC);
2510 
2511 /**
2512  * Obtain the calling convention for a call instruction.
2513  *
2514  * This is the opposite of LLVMSetInstructionCallConv(). Reads its
2515  * usage.
2516  *
2517  * @see LLVMSetInstructionCallConv()
2518  */
2520 
2521 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
2522  unsigned Align);
2523 
2524 void LLVMAddCallSiteAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
2525  LLVMAttributeRef A);
2526 unsigned LLVMGetCallSiteAttributeCount(LLVMValueRef C, LLVMAttributeIndex Idx);
2527 void LLVMGetCallSiteAttributes(LLVMValueRef C, LLVMAttributeIndex Idx,
2528  LLVMAttributeRef *Attrs);
2530  LLVMAttributeIndex Idx,
2531  unsigned KindID);
2533  LLVMAttributeIndex Idx,
2534  const char *K, unsigned KLen);
2535 void LLVMRemoveCallSiteEnumAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
2536  unsigned KindID);
2537 void LLVMRemoveCallSiteStringAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
2538  const char *K, unsigned KLen);
2539 
2540 /**
2541  * Obtain the pointer to the function invoked by this instruction.
2542  *
2543  * This expects an LLVMValueRef that corresponds to a llvm::CallInst or
2544  * llvm::InvokeInst.
2545  *
2546  * @see llvm::CallInst::getCalledValue()
2547  * @see llvm::InvokeInst::getCalledValue()
2548  */
2550 
2551 /**
2552  * Obtain whether a call instruction is a tail call.
2553  *
2554  * This only works on llvm::CallInst instructions.
2555  *
2556  * @see llvm::CallInst::isTailCall()
2557  */
2559 
2560 /**
2561  * Set whether a call instruction is a tail call.
2562  *
2563  * This only works on llvm::CallInst instructions.
2564  *
2565  * @see llvm::CallInst::setTailCall()
2566  */
2567 void LLVMSetTailCall(LLVMValueRef CallInst, LLVMBool IsTailCall);
2568 
2569 /**
2570  * Return the normal destination basic block.
2571  *
2572  * This only works on llvm::InvokeInst instructions.
2573  *
2574  * @see llvm::InvokeInst::getNormalDest()
2575  */
2577 
2578 /**
2579  * Return the unwind destination basic block.
2580  *
2581  * This only works on llvm::InvokeInst instructions.
2582  *
2583  * @see llvm::InvokeInst::getUnwindDest()
2584  */
2586 
2587 /**
2588  * Set the normal destination basic block.
2589  *
2590  * This only works on llvm::InvokeInst instructions.
2591  *
2592  * @see llvm::InvokeInst::setNormalDest()
2593  */
2595 
2596 /**
2597  * Set the unwind destination basic block.
2598  *
2599  * This only works on llvm::InvokeInst instructions.
2600  *
2601  * @see llvm::InvokeInst::setUnwindDest()
2602  */
2604 
2605 /**
2606  * @}
2607  */
2608 
2609 /**
2610  * @defgroup LLVMCCoreValueInstructionTerminator Terminators
2611  *
2612  * Functions in this group only apply to instructions that map to
2613  * llvm::TerminatorInst instances.
2614  *
2615  * @{
2616  */
2617 
2618 /**
2619  * Return the number of successors that this terminator has.
2620  *
2621  * @see llvm::TerminatorInst::getNumSuccessors
2622  */
2623 unsigned LLVMGetNumSuccessors(LLVMValueRef Term);
2624 
2625 /**
2626  * Return the specified successor.
2627  *
2628  * @see llvm::TerminatorInst::getSuccessor
2629  */
2631 
2632 /**
2633  * Update the specified successor to point at the provided block.
2634  *
2635  * @see llvm::TerminatorInst::setSuccessor
2636  */
2637 void LLVMSetSuccessor(LLVMValueRef Term, unsigned i, LLVMBasicBlockRef block);
2638 
2639 /**
2640  * Return if a branch is conditional.
2641  *
2642  * This only works on llvm::BranchInst instructions.
2643  *
2644  * @see llvm::BranchInst::isConditional
2645  */
2647 
2648 /**
2649  * Return the condition of a branch instruction.
2650  *
2651  * This only works on llvm::BranchInst instructions.
2652  *
2653  * @see llvm::BranchInst::getCondition
2654  */
2656 
2657 /**
2658  * Set the condition of a branch instruction.
2659  *
2660  * This only works on llvm::BranchInst instructions.
2661  *
2662  * @see llvm::BranchInst::setCondition
2663  */
2664 void LLVMSetCondition(LLVMValueRef Branch, LLVMValueRef Cond);
2665 
2666 /**
2667  * Obtain the default destination basic block of a switch instruction.
2668  *
2669  * This only works on llvm::SwitchInst instructions.
2670  *
2671  * @see llvm::SwitchInst::getDefaultDest()
2672  */
2674 
2675 /**
2676  * @}
2677  */
2678 
2679 /**
2680  * @defgroup LLVMCCoreValueInstructionAlloca Allocas
2681  *
2682  * Functions in this group only apply to instructions that map to
2683  * llvm::AllocaInst instances.
2684  *
2685  * @{
2686  */
2687 
2688 /**
2689  * Obtain the type that is being allocated by the alloca instruction.
2690  */
2692 
2693 /**
2694  * @}
2695  */
2696 
2697 /**
2698  * @defgroup LLVMCCoreValueInstructionGetElementPointer GEPs
2699  *
2700  * Functions in this group only apply to instructions that map to
2701  * llvm::GetElementPtrInst instances.
2702  *
2703  * @{
2704  */
2705 
2706 /**
2707  * Check whether the given GEP instruction is inbounds.
2708  */
2710 
2711 /**
2712  * Set the given GEP instruction to be inbounds or not.
2713  */
2714 void LLVMSetIsInBounds(LLVMValueRef GEP, LLVMBool InBounds);
2715 
2716 /**
2717  * @}
2718  */
2719 
2720 /**
2721  * @defgroup LLVMCCoreValueInstructionPHINode PHI Nodes
2722  *
2723  * Functions in this group only apply to instructions that map to
2724  * llvm::PHINode instances.
2725  *
2726  * @{
2727  */
2728 
2729 /**
2730  * Add an incoming value to the end of a PHI list.
2731  */
2732 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
2733  LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
2734 
2735 /**
2736  * Obtain the number of incoming basic blocks to a PHI node.
2737  */
2738 unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
2739 
2740 /**
2741  * Obtain an incoming value to a PHI node as an LLVMValueRef.
2742  */
2743 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
2744 
2745 /**
2746  * Obtain an incoming value to a PHI node as an LLVMBasicBlockRef.
2747  */
2748 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
2749 
2750 /**
2751  * @}
2752  */
2753 
2754 /**
2755  * @defgroup LLVMCCoreValueInstructionExtractValue ExtractValue
2756  * @defgroup LLVMCCoreValueInstructionInsertValue InsertValue
2757  *
2758  * Functions in this group only apply to instructions that map to
2759  * llvm::ExtractValue and llvm::InsertValue instances.
2760  *
2761  * @{
2762  */
2763 
2764 /**
2765  * Obtain the number of indices.
2766  * NB: This also works on GEP.
2767  */
2768 unsigned LLVMGetNumIndices(LLVMValueRef Inst);
2769 
2770 /**
2771  * Obtain the indices as an array.
2772  */
2773 const unsigned *LLVMGetIndices(LLVMValueRef Inst);
2774 
2775 /**
2776  * @}
2777  */
2778 
2779 /**
2780  * @}
2781  */
2782 
2783 /**
2784  * @}
2785  */
2786 
2787 /**
2788  * @defgroup LLVMCCoreInstructionBuilder Instruction Builders
2789  *
2790  * An instruction builder represents a point within a basic block and is
2791  * the exclusive means of building instructions using the C interface.
2792  *
2793  * @{
2794  */
2795 
2796 LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C);
2799  LLVMValueRef Instr);
2806  const char *Name);
2807 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
2808 
2809 /* Metadata */
2813 
2814 /* Terminators */
2816 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
2817 LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals,
2818  unsigned N);
2819 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
2822 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
2823  LLVMBasicBlockRef Else, unsigned NumCases);
2824 LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr,
2825  unsigned NumDests);
2826 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
2827  LLVMValueRef *Args, unsigned NumArgs,
2829  const char *Name);
2830 LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty,
2831  LLVMValueRef PersFn, unsigned NumClauses,
2832  const char *Name);
2833 LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn);
2834 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
2835 
2836 /* Add a case to the switch instruction */
2838  LLVMBasicBlockRef Dest);
2839 
2840 /* Add a destination to the indirectbr instruction */
2841 void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest);
2842 
2843 /* Get the number of clauses on the landingpad instruction */
2844 unsigned LLVMGetNumClauses(LLVMValueRef LandingPad);
2845 
2846 /* Get the value of the clause at idnex Idx on the landingpad instruction */
2847 LLVMValueRef LLVMGetClause(LLVMValueRef LandingPad, unsigned Idx);
2848 
2849 /* Add a catch or filter clause to the landingpad instruction */
2850 void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal);
2851 
2852 /* Get the 'cleanup' flag in the landingpad instruction */
2853 LLVMBool LLVMIsCleanup(LLVMValueRef LandingPad);
2854 
2855 /* Set the 'cleanup' flag in the landingpad instruction */
2856 void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val);
2857 
2858 /* Arithmetic */
2859 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2860  const char *Name);
2861 LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2862  const char *Name);
2863 LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2864  const char *Name);
2865 LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2866  const char *Name);
2867 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2868  const char *Name);
2869 LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2870  const char *Name);
2871 LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2872  const char *Name);
2873 LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2874  const char *Name);
2875 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2876  const char *Name);
2877 LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2878  const char *Name);
2879 LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2880  const char *Name);
2881 LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2882  const char *Name);
2883 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2884  const char *Name);
2885 LLVMValueRef LLVMBuildExactUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2886  const char *Name);
2887 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2888  const char *Name);
2889 LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2890  const char *Name);
2891 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2892  const char *Name);
2893 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2894  const char *Name);
2895 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2896  const char *Name);
2897 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2898  const char *Name);
2899 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2900  const char *Name);
2901 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2902  const char *Name);
2903 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2904  const char *Name);
2905 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2906  const char *Name);
2907 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2908  const char *Name);
2909 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
2910  const char *Name);
2911 LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op,
2912  LLVMValueRef LHS, LLVMValueRef RHS,
2913  const char *Name);
2914 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
2915 LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V,
2916  const char *Name);
2917 LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V,
2918  const char *Name);
2919 LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
2920 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
2921 
2922 /* Memory */
2923 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
2924 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
2925  LLVMValueRef Val, const char *Name);
2926 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
2927 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
2928  LLVMValueRef Val, const char *Name);
2929 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
2930 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
2931  const char *Name);
2933 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
2934  LLVMValueRef *Indices, unsigned NumIndices,
2935  const char *Name);
2936 LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
2937  LLVMValueRef *Indices, unsigned NumIndices,
2938  const char *Name);
2939 LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
2940  unsigned Idx, const char *Name);
2941 LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str,
2942  const char *Name);
2943 LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str,
2944  const char *Name);
2945 LLVMBool LLVMGetVolatile(LLVMValueRef MemoryAccessInst);
2946 void LLVMSetVolatile(LLVMValueRef MemoryAccessInst, LLVMBool IsVolatile);
2948 void LLVMSetOrdering(LLVMValueRef MemoryAccessInst, LLVMAtomicOrdering Ordering);
2949 
2950 /* Casts */
2951 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
2952  LLVMTypeRef DestTy, const char *Name);
2953 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
2954  LLVMTypeRef DestTy, const char *Name);
2955 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
2956  LLVMTypeRef DestTy, const char *Name);
2957 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
2958  LLVMTypeRef DestTy, const char *Name);
2959 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
2960  LLVMTypeRef DestTy, const char *Name);
2961 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
2962  LLVMTypeRef DestTy, const char *Name);
2963 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
2964  LLVMTypeRef DestTy, const char *Name);
2965 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
2966  LLVMTypeRef DestTy, const char *Name);
2967 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
2968  LLVMTypeRef DestTy, const char *Name);
2969 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
2970  LLVMTypeRef DestTy, const char *Name);
2971 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
2972  LLVMTypeRef DestTy, const char *Name);
2973 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
2974  LLVMTypeRef DestTy, const char *Name);
2976  LLVMTypeRef DestTy, const char *Name);
2978  LLVMTypeRef DestTy, const char *Name);
2980  LLVMTypeRef DestTy, const char *Name);
2982  LLVMTypeRef DestTy, const char *Name);
2983 LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val,
2984  LLVMTypeRef DestTy, const char *Name);
2985 LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val,
2986  LLVMTypeRef DestTy, const char *Name);
2987 LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val, /*Signed cast!*/
2988  LLVMTypeRef DestTy, const char *Name);
2989 LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val,
2990  LLVMTypeRef DestTy, const char *Name);
2991 
2992 /* Comparisons */
2993 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
2994  LLVMValueRef LHS, LLVMValueRef RHS,
2995  const char *Name);
2996 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
2997  LLVMValueRef LHS, LLVMValueRef RHS,
2998  const char *Name);
2999 
3000 /* Miscellaneous instructions */
3001 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
3002 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
3003  LLVMValueRef *Args, unsigned NumArgs,
3004  const char *Name);
3005 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
3006  LLVMValueRef Then, LLVMValueRef Else,
3007  const char *Name);
3009  const char *Name);
3010 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
3011  LLVMValueRef Index, const char *Name);
3012 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
3013  LLVMValueRef EltVal, LLVMValueRef Index,
3014  const char *Name);
3017  const char *Name);
3018 LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal,
3019  unsigned Index, const char *Name);
3020 LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal,
3021  LLVMValueRef EltVal, unsigned Index,
3022  const char *Name);
3023 
3024 LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val,
3025  const char *Name);
3026 LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val,
3027  const char *Name);
3028 LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS,
3029  LLVMValueRef RHS, const char *Name);
3030 LLVMValueRef LLVMBuildFence(LLVMBuilderRef B, LLVMAtomicOrdering ordering,
3031  LLVMBool singleThread, const char *Name);
3033  LLVMValueRef PTR, LLVMValueRef Val,
3034  LLVMAtomicOrdering ordering,
3035  LLVMBool singleThread);
3036 LLVMValueRef LLVMBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Ptr,
3037  LLVMValueRef Cmp, LLVMValueRef New,
3038  LLVMAtomicOrdering SuccessOrdering,
3039  LLVMAtomicOrdering FailureOrdering,
3041 
3043 void LLVMSetAtomicSingleThread(LLVMValueRef AtomicInst, LLVMBool SingleThread);
3044 
3047  LLVMAtomicOrdering Ordering);
3050  LLVMAtomicOrdering Ordering);
3051 
3052 /**
3053  * @}
3054  */
3055 
3056 /**
3057  * @defgroup LLVMCCoreModuleProvider Module Providers
3058  *
3059  * @{
3060  */
3061 
3062 /**
3063  * Changes the type of M so it can be passed to FunctionPassManagers and the
3064  * JIT. They take ModuleProviders for historical reasons.
3065  */
3068 
3069 /**
3070  * Destroys the module M.
3071  */
3073 
3074 /**
3075  * @}
3076  */
3077 
3078 /**
3079  * @defgroup LLVMCCoreMemoryBuffers Memory Buffers
3080  *
3081  * @{
3082  */
3083 
3085  LLVMMemoryBufferRef *OutMemBuf,
3086  char **OutMessage);
3088  char **OutMessage);
3090  size_t InputDataLength,
3091  const char *BufferName,
3092  LLVMBool RequiresNullTerminator);
3094  size_t InputDataLength,
3095  const char *BufferName);
3097 size_t LLVMGetBufferSize(LLVMMemoryBufferRef MemBuf);
3099 
3100 /**
3101  * @}
3102  */
3103 
3104 /**
3105  * @defgroup LLVMCCorePassRegistry Pass Registry
3106  *
3107  * @{
3108  */
3109 
3110 /** Return the global pass registry, for use with initialization functions.
3111  @see llvm::PassRegistry::getPassRegistry */
3113 
3114 /**
3115  * @}
3116  */
3117 
3118 /**
3119  * @defgroup LLVMCCorePassManagers Pass Managers
3120  *
3121  * @{
3122  */
3123 
3124 /** Constructs a new whole-module pass pipeline. This type of pipeline is
3125  suitable for link-time optimization and whole-module transformations.
3126  @see llvm::PassManager::PassManager */
3128 
3129 /** Constructs a new function-by-function pass pipeline over the module
3130  provider. It does not take ownership of the module provider. This type of
3131  pipeline is suitable for code generation and JIT compilation tasks.
3132  @see llvm::FunctionPassManager::FunctionPassManager */
3134 
3135 /** Deprecated: Use LLVMCreateFunctionPassManagerForModule instead. */
3137 
3138 /** Initializes, executes on the provided module, and finalizes all of the
3139  passes scheduled in the pass manager. Returns 1 if any of the passes
3140  modified the module, 0 otherwise.
3141  @see llvm::PassManager::run(Module&) */
3143 
3144 /** Initializes all of the function passes scheduled in the function pass
3145  manager. Returns 1 if any of the passes modified the module, 0 otherwise.
3146  @see llvm::FunctionPassManager::doInitialization */
3148 
3149 /** Executes all of the function passes scheduled in the function pass manager
3150  on the provided function. Returns 1 if any of the passes modified the
3151  function, false otherwise.
3152  @see llvm::FunctionPassManager::run(Function&) */
3154 
3155 /** Finalizes all of the function passes scheduled in in the function pass
3156  manager. Returns 1 if any of the passes modified the module, 0 otherwise.
3157  @see llvm::FunctionPassManager::doFinalization */
3159 
3160 /** Frees the memory of a pass pipeline. For function pipelines, does not free
3161  the module provider.
3162  @see llvm::PassManagerBase::~PassManagerBase. */
3164 
3165 /**
3166  * @}
3167  */
3168 
3169 /**
3170  * @defgroup LLVMCCoreThreading Threading
3171  *
3172  * Handle the structures needed to make LLVM safe for multithreading.
3173  *
3174  * @{
3175  */
3176 
3177 /** Deprecated: Multi-threading can only be enabled/disabled with the compile
3178  time define LLVM_ENABLE_THREADS. This function always returns
3179  LLVMIsMultithreaded(). */
3181 
3182 /** Deprecated: Multi-threading can only be enabled/disabled with the compile
3183  time define LLVM_ENABLE_THREADS. */
3184 void LLVMStopMultithreaded(void);
3185 
3186 /** Check whether LLVM is executing in thread-safe mode or not.
3187  @see llvm::llvm_is_multithreaded */
3189 
3190 /**
3191  * @}
3192  */
3193 
3194 /**
3195  * @}
3196  */
3197 
3198 /**
3199  * @}
3200  */
3201 
3202 #ifdef __cplusplus
3203 }
3204 #endif
3205 
3206 #endif /* LLVM_C_CORE_H */
MachineLoop * L
True if unordered or equal.
Definition: Core.h:260
LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1195
LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty, const char *AsmString, const char *Constraints, LLVMBool HasSideEffects, LLVMBool IsAlignStack)
Definition: Core.cpp:1427
Subtract a value and return the old one.
Definition: Core.h:312
const char * LLVMGetBufferStart(LLVMMemoryBufferRef MemBuf)
Definition: Core.cpp:3158
void LLVMDisposeBuilder(LLVMBuilderRef Builder)
Definition: Core.cpp:2395
unsigned LLVMGetMDNodeNumOperands(LLVMValueRef V)
Obtain the number of operands from an MDNode value.
Definition: Core.cpp:874
X86 MMX.
Definition: Core.h:156
LLVMValueRef LLVMConstNamedStruct(LLVMTypeRef StructTy, LLVMValueRef *ConstantVals, unsigned Count)
Create a non-anonymous ConstantStruct from values.
Definition: Core.cpp:1042
LLVMValueRef LLVMInstructionClone(LLVMValueRef Inst)
Create a copy of 'this' instruction that is identical in all ways except the following: ...
Definition: Core.cpp:2142
LLVMRealPredicate LLVMGetFCmpPredicate(LLVMValueRef Inst)
Obtain the float predicate of an instruction.
Definition: Core.cpp:2127
equal
Definition: Core.h:238
Definition: Core.h:69
LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C, LLVMBasicBlockRef BB, const char *Name)
Insert a basic block in a function before another basic block.
Definition: Core.cpp:2044
void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest)
Get the elements within a structure.
Definition: Core.cpp:543
void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params)
Obtain the parameters in a function.
Definition: Core.cpp:1905
LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar)
Definition: Core.cpp:1668
LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2933
void LLVMSetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst, LLVMAtomicOrdering Ordering)
Definition: Core.cpp:3090
unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy)
Obtain the address space of a pointer type.
Definition: Core.cpp:592
LLVMBool LLVMHasPersonalityFn(LLVMValueRef Fn)
Check whether the given function has a personality function.
Definition: Core.cpp:1801
The GV is protected.
Definition: Core.h:186
LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty, LLVMValueRef Val, const char *Name)
Definition: Core.cpp:2701
LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1231
LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:2831
LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn)
Obtain the basic block that corresponds to the entry point of a function.
Definition: Core.cpp:1998
LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M)
Obtain an iterator to the last Function in a Module.
Definition: Core.cpp:1773
LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Definition: Core.cpp:1337
Definition: Core.h:91
Not-And a value and return the old one.
Definition: Core.h:314
LLVMValueRef LLVMBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Ptr, LLVMValueRef Cmp, LLVMValueRef New, LLVMAtomicOrdering SuccessOrdering, LLVMAtomicOrdering FailureOrdering, LLVMBool SingleThread)
Definition: Core.cpp:3042
LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1179
Externally visible function.
Definition: Core.h:161
SI Whole Quad Mode
LLVMBool LLVMTypeIsSized(LLVMTypeRef Ty)
Whether the type has a known size.
Definition: Core.cpp:352
LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1190
void LLVMSetSection(LLVMValueRef Global, const char *Section)
Definition: Core.cpp:1546
True if unordered, less than, or equal.
Definition: Core.h:264
unsigned LLVMAttributeIndex
Definition: Core.h:350
The GV is visible.
Definition: Core.h:184
size_t i
True if unordered or less than.
Definition: Core.h:263
struct LLVMOpaqueModule * LLVMModuleRef
The top-level container for all other LLVM Intermediate Representation (IR) objects.
Definition: c/Types.h:62
LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRangeCopy(const char *InputData, size_t InputDataLength, const char *BufferName)
Definition: Core.cpp:3148
LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count)
Obtain a MDNode value from the global context.
Definition: Core.cpp:860
provides both an Acquire and a Release barrier (for fences and operations which both read and write m...
Definition: Core.h:295
const char * LLVMGetAsString(LLVMValueRef c, size_t *Length)
Get the given constant data sequential as a string.
Definition: Core.cpp:1016
LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index)
Obtain an incoming value to a PHI node as an LLVMValueRef.
Definition: Core.cpp:2318
Definition: Core.h:60
LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char *Text, uint8_t Radix)
Obtain a constant value for an integer parsed from a string.
struct LLVMOpaqueMemoryBuffer * LLVMMemoryBufferRef
LLVM uses a polymorphic type hierarchy which C cannot represent, therefore parameters must be passed ...
Definition: c/Types.h:49
void LLVMSetSuccessor(LLVMValueRef Term, unsigned i, LLVMBasicBlockRef block)
Update the specified successor to point at the provided block.
Definition: Core.cpp:2265
LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2513
LLVMBuilderRef LLVMCreateBuilder(void)
Definition: Core.cpp:2357
Obsolete.
Definition: Core.h:174
LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg)
Obtain the next parameter to a function.
Definition: Core.cpp:1939
unsigned greater or equal
Definition: Core.h:241
LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2523
LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer, unsigned Idx, const char *Name)
Definition: Core.cpp:2776
LLVMAttributeRef LLVMGetEnumAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, unsigned KindID)
Definition: Core.cpp:1862
LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name)
Definition: Core.cpp:1628
LLVMBool LLVMIsOpaqueStruct(LLVMTypeRef StructTy)
Determine whether a structure is opaque.
Definition: Core.cpp:559
LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRange(const char *InputData, size_t InputDataLength, const char *BufferName, LLVMBool RequiresNullTerminator)
Definition: Core.cpp:3137
LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn)
Obtain the first parameter to a function.
Definition: Core.cpp:1923
LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:2836
LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee, const char *Name)
Definition: Core.cpp:1745
LLVMAttributeRef LLVMCreateStringAttribute(LLVMContextRef C, const char *K, unsigned KLength, const char *V, unsigned VLength)
Create a string attribute.
Definition: Core.cpp:151
LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty)
Definition: Core.cpp:1084
LLVMBool LLVMHasUnnamedAddr(LLVMValueRef Global)
Definition: Core.cpp:1570
void LLVMStopMultithreaded(void)
Deprecated: Multi-threading can only be enabled/disabled with the compile time define LLVM_ENABLE_THR...
Definition: Core.cpp:3217
LLVMOpcode
Definition: Core.h:57
A catch clause.
Definition: Core.h:270
void LLVMSetValueName(LLVMValueRef Val, const char *Name)
Set the string name of a value.
Definition: Core.cpp:639
True if unordered or not equal.
Definition: Core.h:265
LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Definition: Core.cpp:1317
const char * LLVMGetGC(LLVMValueRef Fn)
Obtain the name of the garbage collector to use during code generation.
Definition: Core.cpp:1828
LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP)
Deprecated: Use LLVMCreateFunctionPassManagerForModule instead.
Definition: Core.cpp:3186
LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name)
Definition: Core.cpp:1614
LLVMTypeRef LLVMGetAllocatedType(LLVMValueRef Alloca)
Obtain the type that is being allocated by the alloca instruction.
Definition: Core.cpp:2291
LLVMTypeRef LLVMHalfType(void)
Obtain a floating point type from the global context.
Definition: Core.cpp:456
LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V)
Definition: Core.cpp:2424
LLVMAttributeRef LLVMCreateEnumAttribute(LLVMContextRef C, unsigned KindID, uint64_t Val)
Create an enum attribute.
Definition: Core.cpp:135
LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB)
Advance a basic block iterator.
Definition: Core.cpp:2018
LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(const char *Path, LLVMMemoryBufferRef *OutMemBuf, char **OutMessage)
Definition: Core.cpp:3112
char * LLVMCreateMessage(const char *Message)
Definition: Core.cpp:67
LLVMPassManagerRef LLVMCreatePassManager(void)
Constructs a new whole-module pass pipeline.
Definition: Core.cpp:3178
LLVMTypeRef LLVMFP128Type(void)
Definition: Core.cpp:468
LLVMValueRef LLVMGetClause(LLVMValueRef LandingPad, unsigned Idx)
Definition: Core.cpp:2494
True if ordered and greater than or equal.
Definition: Core.h:254
LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:2841
#define LLVM_FOR_EACH_VALUE_SUBCLASS(macro)
Definition: Core.h:1162
unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy)
Obtain the number of elements in a vector type.
Definition: Core.cpp:596
void(* LLVMDiagnosticHandler)(LLVMDiagnosticInfoRef, void *)
Definition: Core.h:380
LLVMDiagnosticSeverity LLVMGetDiagInfoSeverity(LLVMDiagnosticInfoRef DI)
Return an enum LLVMDiagnosticSeverity.
Definition: Core.cpp:192
Definition: Core.h:82
LLVMBool LLVMIsAtomicSingleThread(LLVMValueRef AtomicInst)
Definition: Core.cpp:3055
const char * LLVMGetDataLayoutStr(LLVMModuleRef M)
Obtain the data layout for a module.
Definition: Core.cpp:240
LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If, LLVMBasicBlockRef Then, LLVMBasicBlockRef Else)
Definition: Core.cpp:2437
Definition: Core.h:111
LLVMTypeRef LLVMX86MMXType(void)
Definition: Core.cpp:474
Definition: Core.h:98
LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name)
Definition: Core.cpp:2664
LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:2903
struct LLVMOpaquePassRegistry * LLVMPassRegistryRef
Definition: c/Types.h:103
unsigned LLVMGetNumArgOperands(LLVMValueRef Instr)
Obtain the argument count for a call instruction.
Definition: Core.cpp:2150
struct LLVMOpaqueBuilder * LLVMBuilderRef
Represents an LLVM basic block builder.
Definition: c/Types.h:90
LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2583
unsigned LLVMGetLastEnumAttributeKind(void)
Definition: Core.cpp:131
LLVMTypeRef LLVMX86FP80Type(void)
Definition: Core.cpp:465
LLVMUseRef LLVMGetFirstUse(LLVMValueRef Val)
Obtain the first use of a value.
Definition: Core.cpp:722
LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char *Text, unsigned SLen)
Obtain a constant for a floating point value parsed from a string.
void LLVMClearInsertionPosition(LLVMBuilderRef Builder)
Definition: Core.cpp:2382
LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar)
Definition: Core.cpp:1648
LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount)
Create a vector type that contains a defined type and has a specific number of elements.
Definition: Core.cpp:577
LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1221
unsigned LLVMGetMDKindIDInContext(LLVMContextRef C, const char *Name, unsigned SLen)
Definition: Core.cpp:115
LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void)
Return the global pass registry, for use with initialization functions.
Definition: Core.cpp:3172
LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:2909
LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2608
LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition, LLVMValueRef ConstantIfTrue, LLVMValueRef ConstantIfFalse)
Definition: Core.cpp:1383
LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Definition: Core.cpp:1282
LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val)
Determine whether an LLVMValueRef is itself a basic block.
Definition: Core.cpp:1968
LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes, unsigned ElementCount, LLVMBool Packed)
Create a new structure type in a context.
Definition: Core.cpp:508
Hexagon Common GEP
LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB, const char *Name)
Insert a basic block in a function using the global context.
Definition: Core.cpp:2051
int LLVMHasMetadata(LLVMValueRef Val)
Determine whether an instruction has any metadata attached.
Definition: Core.cpp:665
const char * LLVMGetSection(LLVMValueRef Global)
Definition: Core.cpp:1540
LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C)
Definition: Core.cpp:387
LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals, unsigned Count)
Obtain a MDNode value from a context.
Definition: Core.cpp:833
#define op(i)
LLVMValueRef LLVMBuildFence(LLVMBuilderRef B, LLVMAtomicOrdering ordering, LLVMBool singleThread, const char *Name)
Definition: Core.cpp:2753
LLVMAttributeRef LLVMGetStringAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, const char *K, unsigned KLen)
Definition: Core.cpp:1869
LLVMAtomicRMWBinOp
Definition: Core.h:309
LLVMValueRef LLVMConstAddrSpaceCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Definition: Core.cpp:1342
Lowest level of atomicity, guarantees somewhat sane results, lock free.
Definition: Core.h:284
void LLVMContextDispose(LLVMContextRef C)
Destroy a context instance.
Definition: Core.cpp:111
128 bit floating point type (112-bit mantissa)
Definition: Core.h:146
Definition: Core.h:85
void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant)
Definition: Core.cpp:1692
void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal)
Definition: Core.cpp:1684
void LLVMSetModuleIdentifier(LLVMModuleRef M, const char *Ident, size_t Len)
Set the identifier of a module to a string Ident with length Len.
Definition: Core.cpp:234
ExternalWeak linkage description.
Definition: Core.h:176
LLVMValueRef LLVMConstNull(LLVMTypeRef Ty)
Obtain a constant value referring to the null instance of a type.
Definition: Core.cpp:790
LLVMLandingPadClauseTy
Definition: Core.h:269
LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N)
Obtain a constant value referring to a double floating point value.
Definition: Core.cpp:949
LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:2915
LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM)
Initializes all of the function passes scheduled in the function pass manager.
Definition: Core.cpp:3195
void LLVMRemoveCallSiteStringAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, const char *K, unsigned KLen)
Definition: Core.cpp:2218
void LLVMSetOperand(LLVMValueRef User, unsigned Index, LLVMValueRef Val)
Set an operand at a specific index in a llvm::User value.
Definition: Core.cpp:776
long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal)
Obtain the sign extended value for an integer constant value.
Definition: Core.cpp:966
void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index, unsigned Align)
Definition: Core.cpp:2163
LLVMTypeRef LLVMStructGetTypeAtIndex(LLVMTypeRef StructTy, unsigned i)
Get the type of the element at a given index in the structure.
Definition: Core.cpp:550
LLVMOpcode LLVMGetInstructionOpcode(LLVMValueRef Inst)
Obtain the code opcode for an individual instruction.
Definition: Core.cpp:2136
LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C)
Obtain a 128-bit floating point type (112-bit mantissa) from a context.
Definition: Core.cpp:443
const char * LLVMGetStructName(LLVMTypeRef Ty)
Obtain the name of a structure.
Definition: Core.cpp:525
LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn)
Obtain the last basic block in a function.
Definition: Core.cpp:2010
Same, but only replaced by something equivalent.
Definition: Core.h:168
LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB)
Convert a basic block instance to a value type.
Definition: Core.cpp:1964
LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C)
Create a label type in a context.
Definition: Core.cpp:605
LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C)
Obtain a 64-bit floating point type from a context.
Definition: Core.cpp:437
LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size)
Create a ConstantVector from values.
Definition: Core.cpp:1051
Set the new value and return the one old.
Definition: Core.h:310
LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2588
void(* LLVMYieldCallback)(LLVMContextRef, void *)
Definition: Core.h:381
LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty)
Definition: Core.cpp:1088
LLVMBool LLVMIsNull(LLVMValueRef Val)
Determine whether a value instance is null.
Definition: Core.cpp:806
LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant, LLVMValueRef VectorBConstant, LLVMValueRef MaskConstant)
Definition: Core.cpp:1405
LLVMBasicBlockRef LLVMGetSwitchDefaultDest(LLVMValueRef SwitchInstr)
Obtain the default destination basic block of a switch instruction.
Definition: Core.cpp:2285
LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text)
Obtain a constant for a floating point value parsed from a string.
Definition: Core.cpp:953
LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals, unsigned N)
Definition: Core.cpp:2428
Sets the value if it's greater than the original using an unsigned comparison and return the old one...
Definition: Core.h:323
Add a value and return the old one.
Definition: Core.h:311
void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block, LLVMValueRef Instr)
Definition: Core.cpp:2361
LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C)
Definition: Core.cpp:384
unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn)
Obtain the calling function of a function.
Definition: Core.cpp:1819
LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType, LLVMBool isSigned)
Definition: Core.cpp:1372
LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1124
void LLVMSetDataLayout(LLVMModuleRef M, const char *DataLayoutStr)
Set the data layout for a module.
Definition: Core.cpp:248
LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1152
unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy)
Definition: Core.cpp:425
LLVMBool LLVMIsExternallyInitialized(LLVMValueRef GlobalVar)
Definition: Core.cpp:1735
Pointers.
Definition: Core.h:153
LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1260
LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB)
Obtain the function to which a basic block belongs.
Definition: Core.cpp:1980
void LLVMSetCondition(LLVMValueRef Branch, LLVMValueRef Cond)
Set the condition of a branch instruction.
Definition: Core.cpp:2279
LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn)
Obtain the last parameter to a function.
Definition: Core.cpp:1931
LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate, LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1236
LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty)
Obtain a constant value referring to an undefined value of a type.
Definition: Core.cpp:798
Rename collisions when linking (static functions)
Definition: Core.h:171
uint64_t LLVMGetEnumAttributeValue(LLVMAttributeRef A)
Get the enum attribute's value.
Definition: Core.cpp:144
LLVMBool LLVMIsCleanup(LLVMValueRef LandingPad)
Definition: Core.cpp:2503
not equal
Definition: Core.h:239
Arrays.
Definition: Core.h:152
void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz)
Definition: Core.cpp:1555
void LLVMSetNormalDest(LLVMValueRef InvokeInst, LLVMBasicBlockRef B)
Set the normal destination basic block.
Definition: Core.cpp:2247
LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Definition: Core.cpp:1287
void LLVMContextSetDiagnosticHandler(LLVMContextRef C, LLVMDiagnosticHandler Handler, void *DiagnosticContext)
Set the diagnostic handler for this context.
Definition: Core.cpp:86
LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar)
Definition: Core.cpp:1656
LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2518
LLVMBool LLVMIsStringAttribute(LLVMAttributeRef A)
Definition: Core.cpp:177
SIMD 'packed' format, or other vector type.
Definition: Core.h:154
LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB)
Obtain the first instruction in a basic block.
Definition: Core.cpp:2078
LLVMTypeRef LLVMFloatType(void)
Definition: Core.cpp:459
void LLVMDisposeMessage(char *Message)
Definition: Core.cpp:71
A load or store which is not atomic.
Definition: Core.h:283
LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Definition: Core.cpp:1378
LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2603
struct LLVMOpaqueType * LLVMTypeRef
Each value in the LLVM IR has a type, an LLVMTypeRef.
Definition: c/Types.h:69
True if ordered and operands are unequal.
Definition: Core.h:257
LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst)
Obtain the instruction that occurred before this one.
Definition: Core.cpp:2102
True if ordered and equal.
Definition: Core.h:252
void LLVMContextSetYieldCallback(LLVMContextRef C, LLVMYieldCallback Callback, void *OpaqueHandle)
Set the yield callback function for this context.
Definition: Core.cpp:104
signed greater than
Definition: Core.h:244
void LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos)
Move a basic block to before another one.
Definition: Core.cpp:2064
LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant, LLVMValueRef ElementValueConstant, LLVMValueRef IndexConstant)
Definition: Core.cpp:1397
void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest)
Obtain the types of a function's parameters.
Definition: Core.cpp:499
char * LLVMPrintModuleToString(LLVMModuleRef M)
Return a string representation of the module.
Definition: Core.cpp:286
#define F(x, y, z)
Definition: MD5.cpp:51
void LLVMDisposeModule(LLVMModuleRef M)
Destroy a module instance.
Definition: Core.cpp:224
void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst)
Definition: Core.cpp:2413
LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar)
Definition: Core.cpp:1688
LLVMValueRef LLVMConstStructInContext(LLVMContextRef C, LLVMValueRef *ConstantVals, unsigned Count, LLVMBool Packed)
Create an anonymous ConstantStruct with the specified values.
Definition: Core.cpp:1028
LLVMBool LLVMIsTailCall(LLVMValueRef CallInst)
Obtain whether a call instruction is a tail call.
Definition: Core.cpp:2229
LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB)
Definition: Core.cpp:1435
Definition: Core.h:83
LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Definition: Core.cpp:1348
LLVMValueKind
Definition: Core.h:205
LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal, LLVMValueRef *ConstantIndices, unsigned NumIndices)
Definition: Core.cpp:1265
struct LLVMOpaqueUse * LLVMUseRef
Used to get the users and usees of a Value.
Definition: c/Types.h:109
LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal, LLVMValueRef *ConstantIndices, unsigned NumIndices)
Definition: Core.cpp:1273
Keep one copy of function when linking (inline)
Definition: Core.h:163
LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2633
void LLVMDeleteFunction(LLVMValueRef Fn)
Remove a function from its containing module and deletes it.
Definition: Core.cpp:1797
void LLVMRemoveCallSiteEnumAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, unsigned KindID)
Definition: Core.cpp:2212
struct LLVMOpaqueContext * LLVMContextRef
The top-level container for all LLVM global data.
Definition: c/Types.h:54
LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2593
LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Definition: Core.cpp:1322
OR a value and return the old one.
Definition: Core.h:315
LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB)
Go backwards in a basic block iterator.
Definition: Core.cpp:2026
LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M)
Definition: Core.cpp:1632
void LLVMDumpModule(LLVMModuleRef M)
Dump a representation of a module to stderr.
Definition: Core.cpp:261
Function to be imported from DLL.
Definition: Core.h:191
unsigned LLVMCountIncoming(LLVMValueRef PhiNode)
Obtain the number of incoming basic blocks to a PHI node.
Definition: Core.cpp:2314
unsigned greater than
Definition: Core.h:240
LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:2920
LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C)
Obtain a 32-bit floating point type from a context.
Definition: Core.cpp:434
unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal)
Obtain the zero extended value for an integer constant value.
Definition: Core.cpp:962
Definition: Core.h:87
static GCRegistry::Add< OcamlGC > B("ocaml","ocaml 3.10-compatible GC")
void LLVMGetMDNodeOperands(LLVMValueRef V, LLVMValueRef *Dest)
Obtain the given MDNode's operands.
Definition: Core.cpp:881
LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1174
LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB)
Obtain the last instruction in a basic block.
Definition: Core.cpp:2086
LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2533
LLVMUseRef LLVMGetNextUse(LLVMUseRef U)
Obtain the next use of a value.
Definition: Core.cpp:730
LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name, LLVMTypeRef FunctionTy)
Add a function to a module under a specified name.
Definition: Core.cpp:1755
LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2528
Keep one copy of function when linking (weak)
Definition: Core.h:167
LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char *Text, unsigned SLen, uint8_t Radix)
Obtain a constant value for an integer parsed from a string with specified length.
unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy)
Obtain the number of parameters this function accepts.
Definition: Core.cpp:495
LLVMIntPredicate
Definition: Core.h:237
LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2543
struct LLVMOpaqueAttributeRef * LLVMAttributeRef
Used to represent an attributes.
Definition: c/Types.h:116
int Switch(int a)
Definition: Switch2Test.cpp:11
LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:2871
LLVMDiagnosticSeverity
Definition: Core.h:331
LLVMTypeRef LLVMStructCreateNamed(LLVMContextRef C, const char *Name)
Create an empty structure in a context having a specified name.
Definition: Core.cpp:520
LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N, LLVMBool SignExtend)
Obtain a constant value for an integer type.
Definition: Core.cpp:923
size_t LLVMGetBufferSize(LLVMMemoryBufferRef MemBuf)
Definition: Core.cpp:3162
LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2628
void LLVMSetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst, LLVMAtomicOrdering Ordering)
Definition: Core.cpp:3077
void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage)
Definition: Core.cpp:1478
Definition: Core.h:75
unsigned LLVMGetIntrinsicID(LLVMValueRef Fn)
Obtain the ID number from a function instance.
Definition: Core.cpp:1813
void LLVMAddTargetDependentFunctionAttr(LLVMValueRef Fn, const char *A, const char *V)
Add a target-dependent attribute to a function.
Definition: Core.cpp:1885
LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst)
Obtain the basic block to which an instruction belongs.
Definition: Core.cpp:2074
LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C)
Definition: Core.cpp:393
LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M)
Definition: Core.cpp:1640
const char * LLVMGetBasicBlockName(LLVMBasicBlockRef BB)
Obtain the string name of a basic block.
Definition: Core.cpp:1976
LLVMAttributeRef LLVMGetCallSiteStringAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, const char *K, unsigned KLen)
Definition: Core.cpp:2205
LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1113
unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy)
Obtain the length of an array type.
Definition: Core.cpp:588
void LLVMDisposePassManager(LLVMPassManagerRef PM)
Frees the memory of a pass pipeline.
Definition: Core.cpp:3207
LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val, const char *Name)
Definition: Core.cpp:3005
void LLVMSetVolatile(LLVMValueRef MemoryAccessInst, LLVMBool IsVolatile)
Definition: Core.cpp:2798
LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C)
Create a void type in a context.
Definition: Core.cpp:602
True if unordered, greater than, or equal.
Definition: Core.h:262
void LLVMSetUnnamedAddr(LLVMValueRef Global, LLVMBool HasUnnamedAddr)
Definition: Core.cpp:1574
LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1118
LLVMValueRef LLVMConstNSWNeg(LLVMValueRef ConstantVal)
Definition: Core.cpp:1096
void LLVMSetTarget(LLVMModuleRef M, const char *Triple)
Set the target triple for a module.
Definition: Core.cpp:257
LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn)
Obtain the first basic block in a function.
Definition: Core.cpp:2002
LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name)
Definition: Core.cpp:2659
void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L)
Definition: Core.cpp:2401
const unsigned * LLVMGetIndices(LLVMValueRef Inst)
Obtain the indices as an array.
Definition: Core.cpp:2340
signed less than
Definition: Core.h:246
void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block)
Definition: Core.cpp:2373
void LLVMStructSetBody(LLVMTypeRef StructTy, LLVMTypeRef *ElementTypes, unsigned ElementCount, LLVMBool Packed)
Set the contents of a structure type.
Definition: Core.cpp:533
LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2613
Function to be accessible from DLL.
Definition: Core.h:192
Acquire provides a barrier of the sort necessary to acquire a lock to access other memory with normal...
Definition: Core.h:289
LLVMTypeKind
Definition: Core.h:140
LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal, LLVMValueRef EltVal, LLVMValueRef Index, const char *Name)
Definition: Core.cpp:2979
LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name)
Definition: Core.cpp:2696
LLVMAtomicOrdering
Definition: Core.h:282
LLVMTypeRef LLVMInt32Type(void)
Definition: Core.cpp:412
void LLVMGetAttributesAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, LLVMAttributeRef *Attrs)
Definition: Core.cpp:1853
LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name)
Definition: Core.cpp:2949
LLVMValueRef LLVMIsAMDString(LLVMValueRef Val)
Definition: Core.cpp:714
Sets the value if it's greater than the original using an unsigned comparison and return the old one...
Definition: Core.h:326
LLVMValueRef LLVMGetMetadata(LLVMValueRef Val, unsigned KindID)
Return metadata associated with an instruction value.
Definition: Core.cpp:669
void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal)
Definition: Core.cpp:2498
unsigned LLVMCountBasicBlocks(LLVMValueRef Fn)
Obtain the number of basic blocks in a function.
Definition: Core.cpp:1988
LLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy)
Determine whether a structure is packed.
Definition: Core.cpp:555
void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal)
Replace all uses of a value with another one.
Definition: Core.cpp:661
LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:2846
LLVMBool LLVMStartMultithreaded(void)
Deprecated: Multi-threading can only be enabled/disabled with the compile time define LLVM_ENABLE_THR...
Definition: Core.cpp:3213
LLVMDiagnosticHandler LLVMContextGetDiagnosticHandler(LLVMContextRef C)
Get the diagnostic handler of this context.
Definition: Core.cpp:95
LLVMContextRef LLVMGetModuleContext(LLVMModuleRef M)
Obtain the context to which this module is associated.
Definition: Core.cpp:303
LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1201
True if unordered or greater than.
Definition: Core.h:261
#define LLVM_DECLARE_VALUE_CAST(name)
Convert value instances between types.
Definition: Core.h:1323
LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2538
LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name)
Obtain a Function value from a Module by its name.
Definition: Core.cpp:1761
LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal)
Definition: Core.cpp:1105
unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy)
Get the number of elements defined inside the structure.
Definition: Core.cpp:539
LLVMThreadLocalMode LLVMGetThreadLocalMode(LLVMValueRef GlobalVar)
Definition: Core.cpp:1696
Definition: Core.h:77
LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:2856
Definition: Core.h:114
char * LLVMPrintValueToString(LLVMValueRef Val)
Return a string representation of the value.
Definition: Core.cpp:647
LLVMModuleRef LLVMCloneModule(LLVMModuleRef M)
Return an exact copy of the specified module.
LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal, LLVMValueRef Index, const char *Name)
Definition: Core.cpp:2973
LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2568
void LLVMSetDLLStorageClass(LLVMValueRef Global, LLVMDLLStorageClass Class)
Definition: Core.cpp:1565
LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C)
Obtain a 128-bit floating point type (two 64-bits) from a context.
Definition: Core.cpp:446
80 bit floating point type (X87)
Definition: Core.h:145
LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:3015
Definition: Core.h:96
LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer, LLVMValueRef *Indices, unsigned NumIndices, const char *Name)
Definition: Core.cpp:2768
LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1168
LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList, unsigned NumIdx)
Definition: Core.cpp:1413
LLVMValueRef LLVMBuildExactUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2578
void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest)
Definition: Core.cpp:2486
LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1226
void LLVMInstructionEraseFromParent(LLVMValueRef Inst)
Remove and delete an instruction.
Definition: Core.cpp:2114
LLVMUseRef LLVMGetOperandUse(LLVMValueRef Val, unsigned Index)
Obtain the use of an operand at a specific index in a llvm::User value.
Definition: Core.cpp:771
void LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos)
Move a basic block to after another one.
Definition: Core.cpp:2068
LLVMValueRef LLVMGetUsedValue(LLVMUseRef U)
Obtain the value this use corresponds to.
Definition: Core.cpp:741
LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount)
Create a fixed size array type that refers to a specific type.
Definition: Core.cpp:569
Definition: Core.h:74
LLVMValueRef LLVMGetElementAsConstant(LLVMValueRef C, unsigned idx)
Get an element at specified index as a constant.
Definition: Core.cpp:1008
LLVMBool LLVMIsUndef(LLVMValueRef Val)
Determine whether a value instance is undefined.
Definition: Core.cpp:812
char * LLVMGetDiagInfoDescription(LLVMDiagnosticInfoRef DI)
Return a string representation of the DiagnosticInfo.
Definition: Core.cpp:181
void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned Align)
Set the alignment for a function parameter.
Definition: Core.cpp:1955
LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str, unsigned SLen)
Obtain a MDString value from a context.
Definition: Core.cpp:822
LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn)
Definition: Core.cpp:2473
LLVMValueRef LLVMConstString(const char *Str, unsigned Length, LLVMBool DontNullTerminate)
Create a ConstantDataSequential with string content in the global context.
Definition: Core.cpp:1002
LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits)
Definition: Core.cpp:399
Functions.
Definition: Core.h:150
LLVMBasicBlockRef LLVMGetSuccessor(LLVMValueRef Term, unsigned i)
Return the specified successor.
Definition: Core.cpp:2261
LLVMValueRef LLVMMDString(const char *Str, unsigned SLen)
Obtain a MDString value from the global context.
Definition: Core.cpp:829
LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1211
Definition: Core.h:76
LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef)
Definition: Core.cpp:2477
True if ordered and less than.
Definition: Core.h:255
LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn, LLVMValueRef *Args, unsigned NumArgs, LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch, const char *Name)
Definition: Core.cpp:2452
void LLVMShutdown(void)
Deallocate and destroy all ManagedStatic variables.
Definition: Core.cpp:61
LLVMTypeRef LLVMPPCFP128Type(void)
Definition: Core.cpp:471
LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Definition: Core.cpp:1332
And a value and return the old one.
Definition: Core.h:313
LLVMBool LLVMIsEnumAttribute(LLVMAttributeRef A)
Check for the different types of attributes.
Definition: Core.cpp:172
LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Definition: Core.cpp:1366
LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name)
Definition: Core.cpp:2668
LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder)
Definition: Core.cpp:2378
const char * LLVMGetTarget(LLVMModuleRef M)
Obtain the target triple for a module.
Definition: Core.cpp:253
LLVMTypeRef LLVMInt16Type(void)
Definition: Core.cpp:409
Sets the value if it's greater than the original using a signed comparison and return the old one...
Definition: Core.h:317
unsigned LLVMGetEnumAttributeKind(LLVMAttributeRef A)
Get the unique id corresponding to the enum attribute passed as argument.
Definition: Core.cpp:140
void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr)
Definition: Core.cpp:2368
void LLVMSetPersonalityFn(LLVMValueRef Fn, LLVMValueRef PersonalityFn)
Set the personality function attached to the function.
Definition: Core.cpp:1809
LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name)
Obtain a Type from a module by its registered name.
Definition: Core.cpp:563
LLVMValueRef LLVMGetPersonalityFn(LLVMValueRef Fn)
Obtain the personality function attached to the function.
Definition: Core.cpp:1805
unsigned LLVMGetNumClauses(LLVMValueRef LandingPad)
Definition: Core.cpp:2490
LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal)
Definition: Core.cpp:1080
Definition: Core.h:92
unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr)
Obtain the calling convention for a call instruction.
Definition: Core.cpp:2154
void LLVMDumpValue(LLVMValueRef Val)
Dump a representation of a value to stderr.
Definition: Core.cpp:643
LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1135
struct LLVMOpaqueModuleProvider * LLVMModuleProviderRef
Interface used to provide a module to JIT or interpreter.
Definition: c/Types.h:97
void LLVMGetNamedMetadataOperands(LLVMModuleRef M, const char *Name, LLVMValueRef *Dest)
Obtain the named metadata operands for a module.
Definition: Core.cpp:901
LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Definition: Core.cpp:1307
int LLVMBool
Definition: c/Types.h:29
int LLVMGetNumOperands(LLVMValueRef Val)
Obtain the number of operands in a llvm::User value.
Definition: Core.cpp:780
void * LLVMContextGetDiagnosticContext(LLVMContextRef C)
Get the diagnostic context of this context.
Definition: Core.cpp:100
unsigned LLVMGetCallSiteAttributeCount(LLVMValueRef C, LLVMAttributeIndex Idx)
Definition: Core.cpp:2179
LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer, LLVMValueRef *Indices, unsigned NumIndices, const char *Name)
Definition: Core.cpp:2761
LLVMValueRef LLVMAddGlobalInAddressSpace(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name, unsigned AddressSpace)
Definition: Core.cpp:1619
struct LLVMOpaqueDiagnosticInfo * LLVMDiagnosticInfoRef
Definition: c/Types.h:121
type with no size
Definition: Core.h:141
LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:2826
const char * LLVMGetDataLayout(LLVMModuleRef M)
Definition: Core.cpp:244
Like Private, but linker removes.
Definition: Core.h:179
LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index)
Obtain the parameter at the specified index.
Definition: Core.cpp:1912
LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str, unsigned Length, LLVMBool DontNullTerminate)
Create a ConstantDataSequential and initialize it with a string.
Definition: Core.cpp:993
LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1206
LLVMTypeRef LLVMVoidType(void)
These are similar to the above functions except they operate on the global context.
Definition: Core.cpp:609
LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn, LLVMValueRef *Args, unsigned NumArgs, const char *Name)
Definition: Core.cpp:2953
Definition: Core.h:71
LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C, LLVMValueRef Fn, const char *Name)
Append a basic block to the end of a function.
Definition: Core.cpp:2034
LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty)
Obtain the type of elements within a sequential type.
Definition: Core.cpp:581
LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name)
Definition: Core.cpp:2650
void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf)
Definition: Core.cpp:3166
LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:2851
void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC)
Set the calling convention of a function.
Definition: Core.cpp:1823
Like Internal, but omit from symbol table.
Definition: Core.h:173
void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks)
Obtain all of the basic blocks in a function.
Definition: Core.cpp:1992
Sets the value if it's Smaller than the original using a signed comparison and return the old one...
Definition: Core.h:320
LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty)
Obtain the context to which this type instance is associated.
Definition: Core.cpp:357
A filter clause.
Definition: Core.h:271
LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index)
Obtain an operand at a specific index in a llvm::User value.
Definition: Core.cpp:757
LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Definition: Core.cpp:1360
unsigned LLVMCountParams(LLVMValueRef Fn)
Obtain the number of parameters in a function.
Definition: Core.cpp:1899
LLVMModuleProviderRef LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M)
Changes the type of M so it can be passed to FunctionPassManagers and the JIT.
Definition: Core.cpp:3101
void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr)
Definition: Core.cpp:2386
LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:2926
LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef)
Definition: Core.cpp:2420
uint64_t * Vals
LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str, const char *Name)
Definition: Core.cpp:2781
LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty)
Obtain a constant that is a constant pointer pointing to NULL for a specified type.
Definition: Core.cpp:816
void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal)
Definition: Core.cpp:1675
LLVMThreadLocalMode
Definition: Core.h:274
LLVMVisibility LLVMGetVisibility(LLVMValueRef Global)
Definition: Core.cpp:1550
LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1146
void LLVMInitializeCore(LLVMPassRegistryRef R)
Definition: Core.cpp:57
True if ordered and greater than.
Definition: Core.h:253
LLVMContextRef LLVMContextCreate(void)
Create a new context.
Definition: Core.cpp:80
Labels.
Definition: Core.h:148
LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty)
Obtain the enumerated type of a Type instance.
Definition: Core.cpp:312
LLVMTypeRef LLVMTypeOf(LLVMValueRef Val)
Obtain the type of a value.
Definition: Core.cpp:620
LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty)
Obtain a constant value referring to the instance of a type consisting of all ones.
Definition: Core.cpp:794
LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Definition: Core.cpp:1297
LLVMValueRef LLVMGetCalledValue(LLVMValueRef Instr)
Obtain the pointer to the function invoked by this instruction.
Definition: Core.cpp:2223
LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant, LLVMValueRef ElementValueConstant, unsigned *IdxList, unsigned NumIdx)
Definition: Core.cpp:1419
LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2598
LLVMTypeRef LLVMLabelType(void)
Definition: Core.cpp:612
Definition: Core.h:97
Arbitrary bit width integers.
Definition: Core.h:149
LLVMValueRef LLVMGetCondition(LLVMValueRef Branch)
Return the condition of a branch instruction.
Definition: Core.cpp:2275
LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2940
struct LLVMOpaqueBasicBlock * LLVMBasicBlockRef
Represents a basic block of instructions in LLVM IR.
Definition: c/Types.h:83
Structures.
Definition: Core.h:151
LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst)
Obtain the instruction that occurs after the one specified.
Definition: Core.cpp:2094
Definition: Core.h:113
void LLVMDeleteGlobal(LLVMValueRef GlobalVar)
Definition: Core.cpp:1664
Xor a value and return the old one.
Definition: Core.h:316
Definition: Core.h:79
LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Definition: Core.cpp:1354
LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2638
LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2573
signed less or equal
Definition: Core.h:247
LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy)
Returns whether a function type is variadic.
Definition: Core.cpp:487
LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder)
Definition: Core.cpp:2407
LLVMLinkage
Definition: Core.h:160
unsigned LLVMGetNamedMetadataNumOperands(LLVMModuleRef M, const char *Name)
Obtain the number of operands for named metadata in a module.
Definition: Core.cpp:894
Definition: Core.h:86
void LLVMSetAtomicSingleThread(LLVMValueRef AtomicInst, LLVMBool SingleThread)
Definition: Core.cpp:3063
LLVMTypeRef LLVMDoubleType(void)
Definition: Core.cpp:462
32 bit floating point type
Definition: Core.h:143
LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal, LLVMValueRef EltVal, unsigned Index, const char *Name)
Definition: Core.cpp:2998
LLVMValueRef LLVMGetUser(LLVMUseRef U)
Obtain the user value for a user.
Definition: Core.cpp:737
LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Definition: Core.cpp:1302
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
unsigned less than
Definition: Core.h:242
provides Acquire semantics for loads and Release semantics for stores.
Definition: Core.h:299
struct LLVMOpaquePassManager * LLVMPassManagerRef
Definition: c/Types.h:100
LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount, LLVMBool Packed)
Create a new structure type in the global context.
Definition: Core.cpp:514
LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1, LLVMValueRef V2, LLVMValueRef Mask, const char *Name)
Definition: Core.cpp:2986
double LLVMConstRealGetDouble(LLVMValueRef ConstantVal, LLVMBool *losesInfo)
Obtain the double value for an floating point constant value.
Definition: Core.cpp:970
LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str, const char *Name)
Definition: Core.cpp:2786
void LLVMSetExternallyInitialized(LLVMValueRef GlobalVar, LLVMBool IsExtInit)
Definition: Core.cpp:1739
LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name)
Definition: Core.cpp:2674
LLVMValueRef LLVMIsAMDNode(LLVMValueRef Val)
Definition: Core.cpp:706
Same, but only replaced by something equivalent.
Definition: Core.h:164
True if ordered and less than or equal.
Definition: Core.h:256
LLVMAttributeRef LLVMGetCallSiteEnumAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, unsigned KindID)
Definition: Core.cpp:2198
LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal)
Definition: Core.cpp:2706
LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType, LLVMTypeRef *ParamTypes, unsigned ParamCount, LLVMBool IsVarArg)
Obtain a function type consisting of a specified signature.
Definition: Core.cpp:480
unsigned less or equal
Definition: Core.h:243
LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:2881
LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar)
Definition: Core.cpp:1680
Definition: Core.h:73
Maximum length of the test input If
LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Definition: Core.cpp:1327
LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M)
Initializes, executes on the provided module, and finalizes all of the passes scheduled in the pass m...
Definition: Core.cpp:3191
LLVMValueRef LLVMGetBasicBlockTerminator(LLVMBasicBlockRef BB)
Obtain the terminator instruction for a basic block.
Definition: Core.cpp:1984
Metadata.
Definition: Core.h:155
LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count, LLVMBool Packed)
Create a ConstantStruct in the global Context.
Definition: Core.cpp:1036
LLVMBool LLVMIsConstantString(LLVMValueRef c)
Returns true if the specified constant is an array of i8.
Definition: Core.cpp:1012
LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate, LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1243
LLVMTypeRef LLVMX86MMXTypeInContext(LLVMContextRef C)
Create a X86 MMX type in a context.
Definition: Core.cpp:449
LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1157
LLVMBool LLVMIsDeclaration(LLVMValueRef Global)
Definition: Core.cpp:1445
LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:2866
LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal)
Definition: Core.cpp:1092
void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues, LLVMBasicBlockRef *IncomingBlocks, unsigned Count)
Add an incoming value to the end of a PHI list.
Definition: Core.cpp:2307
LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal, unsigned Index, const char *Name)
Definition: Core.cpp:2993
LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2623
void LLVMRemoveBasicBlockFromParent(LLVMBasicBlockRef BB)
Remove a basic block from a function.
Definition: Core.cpp:2060
LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1130
LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1140
LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2553
void LLVMAddNamedMetadataOperand(LLVMModuleRef M, const char *Name, LLVMValueRef Val)
Add an operand to named metadata.
Definition: Core.cpp:911
Always false (always folded)
Definition: Core.h:251
LLVMBool LLVMIsInBounds(LLVMValueRef GEP)
Check whether the given GEP instruction is inbounds.
Definition: Core.cpp:2297
LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg)
Obtain the previous parameter to a function.
Definition: Core.cpp:1947
LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID)
Create a new, empty module in the global context.
Definition: Core.cpp:215
unsigned LLVMGetNumIndices(LLVMValueRef Inst)
Obtain the number of indices.
Definition: Core.cpp:2328
Obsolete.
Definition: Core.h:177
void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal, LLVMBasicBlockRef Dest)
Definition: Core.cpp:2481
Definition: Core.h:84
LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty, LLVMValueRef Val, const char *Name)
Definition: Core.cpp:2685
char * LLVMPrintTypeToString(LLVMTypeRef Val)
Return a string representation of the type.
Definition: Core.cpp:365
LLVMBool LLVMIsConditional(LLVMValueRef Branch)
Return if a branch is conditional.
Definition: Core.cpp:2271
void LLVMRemoveEnumAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, unsigned KindID)
Definition: Core.cpp:1875
Tentative definitions.
Definition: Core.h:178
LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:2876
LLVMValueRef LLVMConstIntOfArbitraryPrecision(LLVMTypeRef IntTy, unsigned NumWords, const uint64_t Words[])
Obtain a constant value for an integer of arbitrary precision.
Definition: Core.cpp:928
LLVMTypeRef LLVMInt64Type(void)
Definition: Core.cpp:415
16 bit floating point type
Definition: Core.h:142
LLVMVisibility
Definition: Core.h:183
unsigned LLVMGetEnumAttributeKindForName(const char *Name, size_t SLen)
Return an unique id given the name of a enum attribute, or 0 if no attribute by that name exists...
Definition: Core.cpp:127
LLVMTypeRef LLVMHalfTypeInContext(LLVMContextRef C)
Obtain a 16-bit floating point type from a context.
Definition: Core.cpp:431
LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name)
Append a basic block to the end of a function using the global context.
Definition: Core.cpp:2040
const char * LLVMGetStringAttributeValue(LLVMAttributeRef A, unsigned *Length)
Get the string attribute's value.
Definition: Core.cpp:165
guarantees that if you take all the operations affecting a specific address, a consistent ordering ex...
Definition: Core.h:286
LLVMTypeRef LLVMInt128TypeInContext(LLVMContextRef C)
Definition: Core.cpp:396
LLVMValueRef LLVMConstNUWNeg(LLVMValueRef ConstantVal)
Definition: Core.cpp:1100
LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B, LLVMAtomicRMWBinOp op, LLVMValueRef PTR, LLVMValueRef Val, LLVMAtomicOrdering ordering, LLVMBool singleThread)
Definition: Core.cpp:3020
void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB)
Remove a basic block from a function and delete it.
Definition: Core.cpp:2056
void * PointerTy
Definition: GenericValue.h:24
LLVMAtomicOrdering LLVMGetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst)
Definition: Core.cpp:3072
LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2618
unsigned LLVMGetNumSuccessors(LLVMValueRef Term)
Return the number of successors that this terminator has.
Definition: Core.cpp:2257
LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val, const char *Name)
Definition: Core.cpp:3010
unsigned LLVMGetMDKindID(const char *Name, unsigned SLen)
Definition: Core.cpp:120
const NodeList & List
Definition: RDFGraph.cpp:205
LLVMBool LLVMIsConstant(LLVMValueRef Val)
Determine whether the specified value instance is constant.
Definition: Core.cpp:802
#define N
LLVMBasicBlockRef LLVMGetUnwindDest(LLVMValueRef InvokeInst)
Return the unwind destination basic block.
Definition: Core.cpp:2243
LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2548
LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index)
Obtain an incoming value to a PHI node as an LLVMBasicBlockRef.
Definition: Core.cpp:2322
void LLVMSetUnwindDest(LLVMValueRef InvokeInst, LLVMBasicBlockRef B)
Set the unwind destination basic block.
Definition: Core.cpp:2251
LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C)
Obtain an integer type from a context with specified bit width.
Definition: Core.cpp:381
LLVMBool LLVMGetVolatile(LLVMValueRef MemoryAccessInst)
Definition: Core.cpp:2791
LLVMTypeRef LLVMInt1Type(void)
Obtain an integer type from the global context with a specified bit width.
Definition: Core.cpp:403
void LLVMGetCallSiteAttributes(LLVMValueRef C, LLVMAttributeIndex Idx, LLVMAttributeRef *Attrs)
Definition: Core.cpp:2188
LLVMTypeRef LLVMIntType(unsigned NumBits)
Definition: Core.cpp:421
void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC)
Set the calling convention for a call instruction.
Definition: Core.cpp:2158
LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M)
Constructs a new function-by-function pass pipeline over the module provider.
Definition: Core.cpp:3182
LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID, LLVMContextRef C)
Create a new, empty module in a specific context.
Definition: Core.cpp:219
LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V, LLVMBasicBlockRef Else, unsigned NumCases)
Definition: Core.cpp:2442
LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy, LLVMValueRef *ConstantVals, unsigned Length)
Create a ConstantArray from values.
Definition: Core.cpp:1022
128 bit floating point type (two 64-bits)
Definition: Core.h:147
LLVMCallConv
Definition: Core.h:195
void LLVMDumpType(LLVMTypeRef Val)
Dump a representation of a type to stderr.
Definition: Core.cpp:361
Definition: Core.h:78
LLVMTypeRef LLVMInt8Type(void)
Definition: Core.cpp:406
Special purpose, only applies to global arrays.
Definition: Core.h:170
signed greater or equal
Definition: Core.h:245
The GV is hidden.
Definition: Core.h:185
LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Definition: Core.cpp:1312
LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1255
const char * LLVMGetMDString(LLVMValueRef V, unsigned *Length)
Obtain the underlying string from a MDString value.
Definition: Core.cpp:864
LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM)
Finalizes all of the function passes scheduled in in the function pass manager.
Definition: Core.cpp:3203
LLVMIntPredicate LLVMGetICmpPredicate(LLVMValueRef Inst)
Obtain the predicate of an instruction.
Definition: Core.cpp:2118
void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val)
Definition: Core.cpp:2507
LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1250
LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2563
Like LinkerPrivate, but is weak.
Definition: Core.h:180
LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal)
Definition: Core.cpp:1109
LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef PersFn, unsigned NumClauses, const char *Name)
Definition: Core.cpp:2461
unsigned LLVMGetAttributeCountAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx)
Definition: Core.cpp:1846
LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M)
Obtain an iterator to the first Function in a Module.
Definition: Core.cpp:1765
LLVMBool LLVMPrintModuleToFile(LLVMModuleRef M, const char *Filename, char **ErrorMessage)
Print a representation of a module to a file.
Definition: Core.cpp:265
LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty, const char *Name)
Definition: Core.cpp:2968
void LLVMSetThreadLocalMode(LLVMValueRef GlobalVar, LLVMThreadLocalMode Mode)
Definition: Core.cpp:1713
Release is similar to Acquire, but with a barrier of the sort necessary to release a lock...
Definition: Core.h:292
Always true (always folded)
Definition: Core.h:266
LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C)
Definition: Core.cpp:2353
LLVMAtomicOrdering LLVMGetOrdering(LLVMValueRef MemoryAccessInst)
Definition: Core.cpp:2805
void LLVMSetMetadata(LLVMValueRef Val, unsigned KindID, LLVMValueRef Node)
Set metadata associated with an instruction value.
Definition: Core.cpp:691
LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst)
Obtain the function to which this argument belongs.
Definition: Core.cpp:1919
const char * LLVMGetValueName(LLVMValueRef Val)
Obtain the string name of a value.
Definition: Core.cpp:635
aarch64 promote const
LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:2897
LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest)
Definition: Core.cpp:2433
void LLVMAddCallSiteAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, LLVMAttributeRef A)
Definition: Core.cpp:2174
Definition: Core.h:72
LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:2891
LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf, char **OutMessage)
Definition: Core.cpp:3126
LLVMLinkage LLVMGetLinkage(LLVMValueRef Global)
Definition: Core.cpp:1449
LLVMDLLStorageClass
Definition: Core.h:189
LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val)
Convert an LLVMValueRef to an LLVMBasicBlockRef instance.
Definition: Core.cpp:1972
std::underlying_type< E >::type Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:81
LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn)
Decrement a Function iterator to the previous Function.
Definition: Core.cpp:1789
void LLVMSetOrdering(LLVMValueRef MemoryAccessInst, LLVMAtomicOrdering Ordering)
Definition: Core.cpp:2815
LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr, unsigned NumDests)
Definition: Core.cpp:2447
void LLVMSetGC(LLVMValueRef Fn, const char *Name)
Define the garbage collector to use during code generation.
Definition: Core.cpp:1833
LLVMDLLStorageClass LLVMGetDLLStorageClass(LLVMValueRef Global)
Definition: Core.cpp:1560
LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name)
Definition: Core.cpp:2654
LLVMValueRef LLVMConstExactUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1184
Obsolete.
Definition: Core.h:175
LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy)
Obtain the Type this function Type returns.
Definition: Core.cpp:491
Definition: Core.h:70
LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2558
LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr)
Definition: Core.cpp:2716
LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:2643
True if unordered: isnan(X) | isnan(Y)
Definition: Core.h:259
const char * LLVMGetModuleIdentifier(LLVMModuleRef M, size_t *Len)
Obtain the identifier of a module.
Definition: Core.cpp:228
LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Definition: Core.cpp:1292
LLVMBool LLVMIsMultithreaded(void)
Check whether LLVM is executing in thread-safe mode or not.
Definition: Core.cpp:3220
Definition: Core.h:59
LLVMContextRef LLVMGetGlobalContext(void)
Obtain the global context instance.
Definition: Core.cpp:84
LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1162
LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C)
Definition: Core.cpp:390
LLVMAtomicOrdering LLVMGetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst)
Definition: Core.cpp:3085
LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F)
Executes all of the function passes scheduled in the function pass manager on the provided function...
Definition: Core.cpp:3199
int * Ptr
64 bit floating point type
Definition: Core.h:144
AddressSpace
Definition: AVR.h:42
LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace)
Create a pointer type that points to a defined type.
Definition: Core.cpp:573
LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal, const char *Name)
Definition: Core.cpp:2711
void LLVMInstructionRemoveFromParent(LLVMValueRef Inst)
Remove and delete an instruction.
Definition: Core.cpp:2110
LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant, LLVMValueRef IndexConstant)
Definition: Core.cpp:1391
void LLVMSetTailCall(LLVMValueRef CallInst, LLVMBool IsTailCall)
Set whether a call instruction is a tail call.
Definition: Core.cpp:2233
void LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm)
Set inline assembly for a module.
Definition: Core.cpp:297
LLVMValueRef LLVMBuildAddrSpaceCast(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:2886
LLVMBasicBlockRef LLVMGetNormalDest(LLVMValueRef InvokeInst)
Return the normal destination basic block.
Definition: Core.cpp:2239
const char * LLVMGetStringAttributeKind(LLVMAttributeRef A, unsigned *Length)
Get the string attribute's kind.
Definition: Core.cpp:158
LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1216
static GCRegistry::Add< ErlangGC > A("erlang","erlang-compatible garbage collector")
unsigned LLVMGetAlignment(LLVMValueRef V)
Obtain the preferred alignment of the value.
Definition: Core.cpp:1582
Tokens.
Definition: Core.h:157
LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn)
Advance a Function iterator to the next Function.
Definition: Core.cpp:1781
void LLVMAddAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, LLVMAttributeRef A)
Add an attribute to a function.
Definition: Core.cpp:1841
Definition: Core.h:68
void LLVMDisposeModuleProvider(LLVMModuleProviderRef M)
Destroys the module M.
Definition: Core.cpp:3105
void LLVMRemoveStringAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, const char *K, unsigned KLen)
Definition: Core.cpp:1880
LLVMTypeRef LLVMInt128Type(void)
Definition: Core.cpp:418
LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If, LLVMValueRef Then, LLVMValueRef Else, const char *Name)
Definition: Core.cpp:2961
Definition: Core.h:112
LLVMRealPredicate
Definition: Core.h:250
LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C)
Obtain a 80-bit floating point type (X87) from a context.
Definition: Core.cpp:440
True if ordered (no nans)
Definition: Core.h:258
struct LLVMOpaqueValue * LLVMValueRef
Represents an individual value in LLVM IR.
Definition: c/Types.h:76
void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr, const char *Name)
Definition: Core.cpp:2390
LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:2861
void LLVMSetIsInBounds(LLVMValueRef GEP, LLVMBool InBounds)
Set the given GEP instruction to be inbounds or not.
Definition: Core.cpp:2301
void LLVMSetAlignment(LLVMValueRef V, unsigned Bytes)
Set the preferred alignment of the value.
Definition: Core.cpp:1597
LLVMValueKind LLVMGetValueKind(LLVMValueRef Val)
Obtain the enumerated type of a Value instance.
Definition: Core.cpp:624
LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global)
Definition: Core.cpp:1441