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