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