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 an element at specified index as a constant.
2116  *
2117  * @see ConstantDataSequential::getElementAsConstant()
2118  */
2120 
2121 /**
2122  * Create a ConstantVector from values.
2123  *
2124  * @see llvm::ConstantVector::get()
2125  */
2126 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
2127 
2128 /**
2129  * @}
2130  */
2131 
2132 /**
2133  * @defgroup LLVMCCoreValueConstantExpressions Constant Expressions
2134  *
2135  * Functions in this group correspond to APIs on llvm::ConstantExpr.
2136  *
2137  * @see llvm::ConstantExpr.
2138  *
2139  * @{
2140  */
2149 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2150 LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2151 LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2152 LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2153 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2154 LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2155 LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2156 LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2157 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2158 LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2159 LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2160 LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2161 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2162 LLVMValueRef LLVMConstExactUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2163 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2164 LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2165 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2166 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2167 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2168 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2169 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2170 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2171 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2173  LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2175  LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2176 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2177 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2178 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
2181  LLVMValueRef *ConstantIndices,
2182  unsigned NumIndices),
2183  "Use LLVMConstGEP2 instead to support opaque pointers");
2185  LLVMValueRef *ConstantIndices, unsigned NumIndices);
2188  LLVMValueRef *ConstantIndices,
2189  unsigned NumIndices),
2190  "Use LLVMConstInBoundsGEP2 instead to support opaque pointers");
2192  LLVMValueRef *ConstantIndices,
2193  unsigned NumIndices);
2195 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
2196 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
2208  LLVMTypeRef ToType);
2210  LLVMTypeRef ToType);
2212  LLVMTypeRef ToType);
2214  LLVMTypeRef ToType);
2216  LLVMBool isSigned);
2218 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
2219  LLVMValueRef ConstantIfTrue,
2220  LLVMValueRef ConstantIfFalse);
2222  LLVMValueRef IndexConstant);
2224  LLVMValueRef ElementValueConstant,
2225  LLVMValueRef IndexConstant);
2227  LLVMValueRef VectorBConstant,
2228  LLVMValueRef MaskConstant);
2229 LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList,
2230  unsigned NumIdx);
2232  LLVMValueRef ElementValueConstant,
2233  unsigned *IdxList, unsigned NumIdx);
2235 
2236 /** Deprecated: Use LLVMGetInlineAsm instead. */
2238  const char *AsmString, const char *Constraints,
2239  LLVMBool HasSideEffects, LLVMBool IsAlignStack);
2240 
2241 /**
2242  * @}
2243  */
2244 
2245 /**
2246  * @defgroup LLVMCCoreValueConstantGlobals Global Values
2247  *
2248  * This group contains functions that operate on global values. Functions in
2249  * this group relate to functions in the llvm::GlobalValue class tree.
2250  *
2251  * @see llvm::GlobalValue
2252  *
2253  * @{
2254  */
2255 
2260 const char *LLVMGetSection(LLVMValueRef Global);
2261 void LLVMSetSection(LLVMValueRef Global, const char *Section);
2267 void LLVMSetUnnamedAddress(LLVMValueRef Global, LLVMUnnamedAddr UnnamedAddr);
2268 
2269 /**
2270  * Returns the "value type" of a global value. This differs from the formal
2271  * type of a global value which is always a pointer type.
2272  *
2273  * @see llvm::GlobalValue::getValueType()
2274  */
2276 
2277 /** Deprecated: Use LLVMGetUnnamedAddress instead. */
2279 /** Deprecated: Use LLVMSetUnnamedAddress instead. */
2280 void LLVMSetUnnamedAddr(LLVMValueRef Global, LLVMBool HasUnnamedAddr);
2281 
2282 /**
2283  * @defgroup LLVMCCoreValueWithAlignment Values with alignment
2284  *
2285  * Functions in this group only apply to values with alignment, i.e.
2286  * global variables, load and store instructions.
2287  */
2288 
2289 /**
2290  * Obtain the preferred alignment of the value.
2291  * @see llvm::AllocaInst::getAlignment()
2292  * @see llvm::LoadInst::getAlignment()
2293  * @see llvm::StoreInst::getAlignment()
2294  * @see llvm::AtomicRMWInst::setAlignment()
2295  * @see llvm::AtomicCmpXchgInst::setAlignment()
2296  * @see llvm::GlobalValue::getAlignment()
2297  */
2298 unsigned LLVMGetAlignment(LLVMValueRef V);
2299 
2300 /**
2301  * Set the preferred alignment of the value.
2302  * @see llvm::AllocaInst::setAlignment()
2303  * @see llvm::LoadInst::setAlignment()
2304  * @see llvm::StoreInst::setAlignment()
2305  * @see llvm::AtomicRMWInst::setAlignment()
2306  * @see llvm::AtomicCmpXchgInst::setAlignment()
2307  * @see llvm::GlobalValue::setAlignment()
2308  */
2309 void LLVMSetAlignment(LLVMValueRef V, unsigned Bytes);
2310 
2311 /**
2312  * Sets a metadata attachment, erasing the existing metadata attachment if
2313  * it already exists for the given kind.
2314  *
2315  * @see llvm::GlobalObject::setMetadata()
2316  */
2317 void LLVMGlobalSetMetadata(LLVMValueRef Global, unsigned Kind,
2318  LLVMMetadataRef MD);
2319 
2320 /**
2321  * Erases a metadata attachment of the given kind if it exists.
2322  *
2323  * @see llvm::GlobalObject::eraseMetadata()
2324  */
2325 void LLVMGlobalEraseMetadata(LLVMValueRef Global, unsigned Kind);
2326 
2327 /**
2328  * Removes all metadata attachments from this value.
2329  *
2330  * @see llvm::GlobalObject::clearMetadata()
2331  */
2333 
2334 /**
2335  * Retrieves an array of metadata entries representing the metadata attached to
2336  * this value. The caller is responsible for freeing this array by calling
2337  * \c LLVMDisposeValueMetadataEntries.
2338  *
2339  * @see llvm::GlobalObject::getAllMetadata()
2340  */
2342  size_t *NumEntries);
2343 
2344 /**
2345  * Destroys value metadata entries.
2346  */
2348 
2349 /**
2350  * Returns the kind of a value metadata entry at a specific index.
2351  */
2353  unsigned Index);
2354 
2355 /**
2356  * Returns the underlying metadata node of a value metadata entry at a
2357  * specific index.
2358  */
2361  unsigned Index);
2362 
2363 /**
2364  * @}
2365  */
2366 
2367 /**
2368  * @defgroup LLVMCoreValueConstantGlobalVariable Global Variables
2369  *
2370  * This group contains functions that operate on global variable values.
2371  *
2372  * @see llvm::GlobalVariable
2373  *
2374  * @{
2375  */
2378  const char *Name,
2379  unsigned AddressSpace);
2389 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal);
2396 
2397 /**
2398  * @}
2399  */
2400 
2401 /**
2402  * @defgroup LLVMCoreValueConstantGlobalAlias Global Aliases
2403  *
2404  * This group contains function that operate on global alias values.
2405  *
2406  * @see llvm::GlobalAlias
2407  *
2408  * @{
2409  */
2410 
2413  LLVMValueRef Aliasee, const char *Name),
2414  "Use LLVMAddAlias2 instead to support opaque pointers");
2415 
2416 /**
2417  * Add a GlobalAlias with the given value type, address space and aliasee.
2418  *
2419  * @see llvm::GlobalAlias::create()
2420  */
2422  unsigned AddrSpace, LLVMValueRef Aliasee,
2423  const char *Name);
2424 
2425 /**
2426  * Obtain a GlobalAlias value from a Module by its name.
2427  *
2428  * The returned value corresponds to a llvm::GlobalAlias value.
2429  *
2430  * @see llvm::Module::getNamedAlias()
2431  */
2433  const char *Name, size_t NameLen);
2434 
2435 /**
2436  * Obtain an iterator to the first GlobalAlias in a Module.
2437  *
2438  * @see llvm::Module::alias_begin()
2439  */
2441 
2442 /**
2443  * Obtain an iterator to the last GlobalAlias in a Module.
2444  *
2445  * @see llvm::Module::alias_end()
2446  */
2448 
2449 /**
2450  * Advance a GlobalAlias iterator to the next GlobalAlias.
2451  *
2452  * Returns NULL if the iterator was already at the end and there are no more
2453  * global aliases.
2454  */
2456 
2457 /**
2458  * Decrement a GlobalAlias iterator to the previous GlobalAlias.
2459  *
2460  * Returns NULL if the iterator was already at the beginning and there are
2461  * no previous global aliases.
2462  */
2464 
2465 /**
2466  * Retrieve the target value of an alias.
2467  */
2469 
2470 /**
2471  * Set the target value of an alias.
2472  */
2473 void LLVMAliasSetAliasee(LLVMValueRef Alias, LLVMValueRef Aliasee);
2474 
2475 /**
2476  * @}
2477  */
2478 
2479 /**
2480  * @defgroup LLVMCCoreValueFunction Function values
2481  *
2482  * Functions in this group operate on LLVMValueRef instances that
2483  * correspond to llvm::Function instances.
2484  *
2485  * @see llvm::Function
2486  *
2487  * @{
2488  */
2489 
2490 /**
2491  * Remove a function from its containing module and deletes it.
2492  *
2493  * @see llvm::Function::eraseFromParent()
2494  */
2496 
2497 /**
2498  * Check whether the given function has a personality function.
2499  *
2500  * @see llvm::Function::hasPersonalityFn()
2501  */
2503 
2504 /**
2505  * Obtain the personality function attached to the function.
2506  *
2507  * @see llvm::Function::getPersonalityFn()
2508  */
2510 
2511 /**
2512  * Set the personality function attached to the function.
2513  *
2514  * @see llvm::Function::setPersonalityFn()
2515  */
2516 void LLVMSetPersonalityFn(LLVMValueRef Fn, LLVMValueRef PersonalityFn);
2517 
2518 /**
2519  * Obtain the intrinsic ID number which matches the given function name.
2520  *
2521  * @see llvm::Function::lookupIntrinsicID()
2522  */
2523 unsigned LLVMLookupIntrinsicID(const char *Name, size_t NameLen);
2524 
2525 /**
2526  * Obtain the ID number from a function instance.
2527  *
2528  * @see llvm::Function::getIntrinsicID()
2529  */
2530 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
2531 
2532 /**
2533  * Create or insert the declaration of an intrinsic. For overloaded intrinsics,
2534  * parameter types must be provided to uniquely identify an overload.
2535  *
2536  * @see llvm::Intrinsic::getDeclaration()
2537  */
2539  unsigned ID,
2540  LLVMTypeRef *ParamTypes,
2541  size_t ParamCount);
2542 
2543 /**
2544  * Retrieves the type of an intrinsic. For overloaded intrinsics, parameter
2545  * types must be provided to uniquely identify an overload.
2546  *
2547  * @see llvm::Intrinsic::getType()
2548  */
2550  LLVMTypeRef *ParamTypes, size_t ParamCount);
2551 
2552 /**
2553  * Retrieves the name of an intrinsic.
2554  *
2555  * @see llvm::Intrinsic::getName()
2556  */
2557 const char *LLVMIntrinsicGetName(unsigned ID, size_t *NameLength);
2558 
2559 /** Deprecated: Use LLVMIntrinsicCopyOverloadedName2 instead. */
2560 const char *LLVMIntrinsicCopyOverloadedName(unsigned ID,
2561  LLVMTypeRef *ParamTypes,
2562  size_t ParamCount,
2563  size_t *NameLength);
2564 
2565 /**
2566  * Copies the name of an overloaded intrinsic identified by a given list of
2567  * parameter types.
2568  *
2569  * Unlike LLVMIntrinsicGetName, the caller is responsible for freeing the
2570  * returned string.
2571  *
2572  * This version also supports unnamed types.
2573  *
2574  * @see llvm::Intrinsic::getName()
2575  */
2577  LLVMTypeRef *ParamTypes,
2578  size_t ParamCount,
2579  size_t *NameLength);
2580 
2581 /**
2582  * Obtain if the intrinsic identified by the given ID is overloaded.
2583  *
2584  * @see llvm::Intrinsic::isOverloaded()
2585  */
2587 
2588 /**
2589  * Obtain the calling function of a function.
2590  *
2591  * The returned value corresponds to the LLVMCallConv enumeration.
2592  *
2593  * @see llvm::Function::getCallingConv()
2594  */
2596 
2597 /**
2598  * Set the calling convention of a function.
2599  *
2600  * @see llvm::Function::setCallingConv()
2601  *
2602  * @param Fn Function to operate on
2603  * @param CC LLVMCallConv to set calling convention to
2604  */
2605 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
2606 
2607 /**
2608  * Obtain the name of the garbage collector to use during code
2609  * generation.
2610  *
2611  * @see llvm::Function::getGC()
2612  */
2613 const char *LLVMGetGC(LLVMValueRef Fn);
2614 
2615 /**
2616  * Define the garbage collector to use during code generation.
2617  *
2618  * @see llvm::Function::setGC()
2619  */
2620 void LLVMSetGC(LLVMValueRef Fn, const char *Name);
2621 
2622 /**
2623  * Add an attribute to a function.
2624  *
2625  * @see llvm::Function::addAttribute()
2626  */
2633  LLVMAttributeIndex Idx,
2634  unsigned KindID);
2636  LLVMAttributeIndex Idx,
2637  const char *K, unsigned KLen);
2639  unsigned KindID);
2641  const char *K, unsigned KLen);
2642 
2643 /**
2644  * Add a target-dependent attribute to a function
2645  * @see llvm::AttrBuilder::addAttribute()
2646  */
2648  const char *V);
2649 
2650 /**
2651  * @defgroup LLVMCCoreValueFunctionParameters Function Parameters
2652  *
2653  * Functions in this group relate to arguments/parameters on functions.
2654  *
2655  * Functions in this group expect LLVMValueRef instances that correspond
2656  * to llvm::Function instances.
2657  *
2658  * @{
2659  */
2660 
2661 /**
2662  * Obtain the number of parameters in a function.
2663  *
2664  * @see llvm::Function::arg_size()
2665  */
2666 unsigned LLVMCountParams(LLVMValueRef Fn);
2667 
2668 /**
2669  * Obtain the parameters in a function.
2670  *
2671  * The takes a pointer to a pre-allocated array of LLVMValueRef that is
2672  * at least LLVMCountParams() long. This array will be filled with
2673  * LLVMValueRef instances which correspond to the parameters the
2674  * function receives. Each LLVMValueRef corresponds to a llvm::Argument
2675  * instance.
2676  *
2677  * @see llvm::Function::arg_begin()
2678  */
2679 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
2680 
2681 /**
2682  * Obtain the parameter at the specified index.
2683  *
2684  * Parameters are indexed from 0.
2685  *
2686  * @see llvm::Function::arg_begin()
2687  */
2689 
2690 /**
2691  * Obtain the function to which this argument belongs.
2692  *
2693  * Unlike other functions in this group, this one takes an LLVMValueRef
2694  * that corresponds to a llvm::Attribute.
2695  *
2696  * The returned LLVMValueRef is the llvm::Function to which this
2697  * argument belongs.
2698  */
2700 
2701 /**
2702  * Obtain the first parameter to a function.
2703  *
2704  * @see llvm::Function::arg_begin()
2705  */
2707 
2708 /**
2709  * Obtain the last parameter to a function.
2710  *
2711  * @see llvm::Function::arg_end()
2712  */
2714 
2715 /**
2716  * Obtain the next parameter to a function.
2717  *
2718  * This takes an LLVMValueRef obtained from LLVMGetFirstParam() (which is
2719  * actually a wrapped iterator) and obtains the next parameter from the
2720  * underlying iterator.
2721  */
2723 
2724 /**
2725  * Obtain the previous parameter to a function.
2726  *
2727  * This is the opposite of LLVMGetNextParam().
2728  */
2730 
2731 /**
2732  * Set the alignment for a function parameter.
2733  *
2734  * @see llvm::Argument::addAttr()
2735  * @see llvm::AttrBuilder::addAlignmentAttr()
2736  */
2738 
2739 /**
2740  * @}
2741  */
2742 
2743 /**
2744  * @defgroup LLVMCCoreValueGlobalIFunc IFuncs
2745  *
2746  * Functions in this group relate to indirect functions.
2747  *
2748  * Functions in this group expect LLVMValueRef instances that correspond
2749  * to llvm::GlobalIFunc instances.
2750  *
2751  * @{
2752  */
2753 
2754 /**
2755  * Add a global indirect function to a module under a specified name.
2756  *
2757  * @see llvm::GlobalIFunc::create()
2758  */
2760  const char *Name, size_t NameLen,
2761  LLVMTypeRef Ty, unsigned AddrSpace,
2762  LLVMValueRef Resolver);
2763 
2764 /**
2765  * Obtain a GlobalIFunc value from a Module by its name.
2766  *
2767  * The returned value corresponds to a llvm::GlobalIFunc value.
2768  *
2769  * @see llvm::Module::getNamedIFunc()
2770  */
2772  const char *Name, size_t NameLen);
2773 
2774 /**
2775  * Obtain an iterator to the first GlobalIFunc in a Module.
2776  *
2777  * @see llvm::Module::ifunc_begin()
2778  */
2780 
2781 /**
2782  * Obtain an iterator to the last GlobalIFunc in a Module.
2783  *
2784  * @see llvm::Module::ifunc_end()
2785  */
2787 
2788 /**
2789  * Advance a GlobalIFunc iterator to the next GlobalIFunc.
2790  *
2791  * Returns NULL if the iterator was already at the end and there are no more
2792  * global aliases.
2793  */
2795 
2796 /**
2797  * Decrement a GlobalIFunc iterator to the previous GlobalIFunc.
2798  *
2799  * Returns NULL if the iterator was already at the beginning and there are
2800  * no previous global aliases.
2801  */
2803 
2804 /**
2805  * Retrieves the resolver function associated with this indirect function, or
2806  * NULL if it doesn't not exist.
2807  *
2808  * @see llvm::GlobalIFunc::getResolver()
2809  */
2811 
2812 /**
2813  * Sets the resolver function associated with this indirect function.
2814  *
2815  * @see llvm::GlobalIFunc::setResolver()
2816  */
2818 
2819 /**
2820  * Remove a global indirect function from its parent module and delete it.
2821  *
2822  * @see llvm::GlobalIFunc::eraseFromParent()
2823  */
2825 
2826 /**
2827  * Remove a global indirect function from its parent module.
2828  *
2829  * This unlinks the global indirect function from its containing module but
2830  * keeps it alive.
2831  *
2832  * @see llvm::GlobalIFunc::removeFromParent()
2833  */
2835 
2836 /**
2837  * @}
2838  */
2839 
2840 /**
2841  * @}
2842  */
2843 
2844 /**
2845  * @}
2846  */
2847 
2848 /**
2849  * @}
2850  */
2851 
2852 /**
2853  * @defgroup LLVMCCoreValueMetadata Metadata
2854  *
2855  * @{
2856  */
2857 
2858 /**
2859  * Create an MDString value from a given string value.
2860  *
2861  * The MDString value does not take ownership of the given string, it remains
2862  * the responsibility of the caller to free it.
2863  *
2864  * @see llvm::MDString::get()
2865  */
2867  size_t SLen);
2868 
2869 /**
2870  * Create an MDNode value with the given array of operands.
2871  *
2872  * @see llvm::MDNode::get()
2873  */
2875  size_t Count);
2876 
2877 /**
2878  * Obtain a Metadata as a Value.
2879  */
2881 
2882 /**
2883  * Obtain a Value as a Metadata.
2884  */
2886 
2887 /**
2888  * Obtain the underlying string from a MDString value.
2889  *
2890  * @param V Instance to obtain string from.
2891  * @param Length Memory address which will hold length of returned string.
2892  * @return String data in MDString.
2893  */
2894 const char *LLVMGetMDString(LLVMValueRef V, unsigned *Length);
2895 
2896 /**
2897  * Obtain the number of operands from an MDNode value.
2898  *
2899  * @param V MDNode to get number of operands from.
2900  * @return Number of operands of the MDNode.
2901  */
2903 
2904 /**
2905  * Obtain the given MDNode's operands.
2906  *
2907  * The passed LLVMValueRef pointer should point to enough memory to hold all of
2908  * the operands of the given MDNode (see LLVMGetMDNodeNumOperands) as
2909  * LLVMValueRefs. This memory will be populated with the LLVMValueRefs of the
2910  * MDNode's operands.
2911  *
2912  * @param V MDNode to get the operands from.
2913  * @param Dest Destination array for operands.
2914  */
2916 
2917 /** Deprecated: Use LLVMMDStringInContext2 instead. */
2919  unsigned SLen);
2920 /** Deprecated: Use LLVMMDStringInContext2 instead. */
2921 LLVMValueRef LLVMMDString(const char *Str, unsigned SLen);
2922 /** Deprecated: Use LLVMMDNodeInContext2 instead. */
2924  unsigned Count);
2925 /** Deprecated: Use LLVMMDNodeInContext2 instead. */
2926 LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count);
2927 
2928 /**
2929  * @}
2930  */
2931 
2932 /**
2933  * @defgroup LLVMCCoreValueBasicBlock Basic Block
2934  *
2935  * A basic block represents a single entry single exit section of code.
2936  * Basic blocks contain a list of instructions which form the body of
2937  * the block.
2938  *
2939  * Basic blocks belong to functions. They have the type of label.
2940  *
2941  * Basic blocks are themselves values. However, the C API models them as
2942  * LLVMBasicBlockRef.
2943  *
2944  * @see llvm::BasicBlock
2945  *
2946  * @{
2947  */
2948 
2949 /**
2950  * Convert a basic block instance to a value type.
2951  */
2953 
2954 /**
2955  * Determine whether an LLVMValueRef is itself a basic block.
2956  */
2958 
2959 /**
2960  * Convert an LLVMValueRef to an LLVMBasicBlockRef instance.
2961  */
2963 
2964 /**
2965  * Obtain the string name of a basic block.
2966  */
2968 
2969 /**
2970  * Obtain the function to which a basic block belongs.
2971  *
2972  * @see llvm::BasicBlock::getParent()
2973  */
2975 
2976 /**
2977  * Obtain the terminator instruction for a basic block.
2978  *
2979  * If the basic block does not have a terminator (it is not well-formed
2980  * if it doesn't), then NULL is returned.
2981  *
2982  * The returned LLVMValueRef corresponds to an llvm::Instruction.
2983  *
2984  * @see llvm::BasicBlock::getTerminator()
2985  */
2987 
2988 /**
2989  * Obtain the number of basic blocks in a function.
2990  *
2991  * @param Fn Function value to operate on.
2992  */
2993 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
2994 
2995 /**
2996  * Obtain all of the basic blocks in a function.
2997  *
2998  * This operates on a function value. The BasicBlocks parameter is a
2999  * pointer to a pre-allocated array of LLVMBasicBlockRef of at least
3000  * LLVMCountBasicBlocks() in length. This array is populated with
3001  * LLVMBasicBlockRef instances.
3002  */
3003 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
3004 
3005 /**
3006  * Obtain the first basic block in a function.
3007  *
3008  * The returned basic block can be used as an iterator. You will likely
3009  * eventually call into LLVMGetNextBasicBlock() with it.
3010  *
3011  * @see llvm::Function::begin()
3012  */
3014 
3015 /**
3016  * Obtain the last basic block in a function.
3017  *
3018  * @see llvm::Function::end()
3019  */
3021 
3022 /**
3023  * Advance a basic block iterator.
3024  */
3026 
3027 /**
3028  * Go backwards in a basic block iterator.
3029  */
3031 
3032 /**
3033  * Obtain the basic block that corresponds to the entry point of a
3034  * function.
3035  *
3036  * @see llvm::Function::getEntryBlock()
3037  */
3039 
3040 /**
3041  * Insert the given basic block after the insertion point of the given builder.
3042  *
3043  * The insertion point must be valid.
3044  *
3045  * @see llvm::Function::BasicBlockListType::insertAfter()
3046  */
3049 
3050 /**
3051  * Append the given basic block to the basic block list of the given function.
3052  *
3053  * @see llvm::Function::BasicBlockListType::push_back()
3054  */
3057 
3058 /**
3059  * Create a new basic block without inserting it into a function.
3060  *
3061  * @see llvm::BasicBlock::Create()
3062  */
3064  const char *Name);
3065 
3066 /**
3067  * Append a basic block to the end of a function.
3068  *
3069  * @see llvm::BasicBlock::Create()
3070  */
3072  LLVMValueRef Fn,
3073  const char *Name);
3074 
3075 /**
3076  * Append a basic block to the end of a function using the global
3077  * context.
3078  *
3079  * @see llvm::BasicBlock::Create()
3080  */
3082 
3083 /**
3084  * Insert a basic block in a function before another basic block.
3085  *
3086  * The function to add to is determined by the function of the
3087  * passed basic block.
3088  *
3089  * @see llvm::BasicBlock::Create()
3090  */
3093  const char *Name);
3094 
3095 /**
3096  * Insert a basic block in a function using the global context.
3097  *
3098  * @see llvm::BasicBlock::Create()
3099  */
3101  const char *Name);
3102 
3103 /**
3104  * Remove a basic block from a function and delete it.
3105  *
3106  * This deletes the basic block from its containing function and deletes
3107  * the basic block itself.
3108  *
3109  * @see llvm::BasicBlock::eraseFromParent()
3110  */
3112 
3113 /**
3114  * Remove a basic block from a function.
3115  *
3116  * This deletes the basic block from its containing function but keep
3117  * the basic block alive.
3118  *
3119  * @see llvm::BasicBlock::removeFromParent()
3120  */
3122 
3123 /**
3124  * Move a basic block to before another one.
3125  *
3126  * @see llvm::BasicBlock::moveBefore()
3127  */
3129 
3130 /**
3131  * Move a basic block to after another one.
3132  *
3133  * @see llvm::BasicBlock::moveAfter()
3134  */
3136 
3137 /**
3138  * Obtain the first instruction in a basic block.
3139  *
3140  * The returned LLVMValueRef corresponds to a llvm::Instruction
3141  * instance.
3142  */
3144 
3145 /**
3146  * Obtain the last instruction in a basic block.
3147  *
3148  * The returned LLVMValueRef corresponds to an LLVM:Instruction.
3149  */
3151 
3152 /**
3153  * @}
3154  */
3155 
3156 /**
3157  * @defgroup LLVMCCoreValueInstruction Instructions
3158  *
3159  * Functions in this group relate to the inspection and manipulation of
3160  * individual instructions.
3161  *
3162  * In the C++ API, an instruction is modeled by llvm::Instruction. This
3163  * class has a large number of descendents. llvm::Instruction is a
3164  * llvm::Value and in the C API, instructions are modeled by
3165  * LLVMValueRef.
3166  *
3167  * This group also contains sub-groups which operate on specific
3168  * llvm::Instruction types, e.g. llvm::CallInst.
3169  *
3170  * @{
3171  */
3172 
3173 /**
3174  * Determine whether an instruction has any metadata attached.
3175  */
3176 int LLVMHasMetadata(LLVMValueRef Val);
3177 
3178 /**
3179  * Return metadata associated with an instruction value.
3180  */
3181 LLVMValueRef LLVMGetMetadata(LLVMValueRef Val, unsigned KindID);
3182 
3183 /**
3184  * Set metadata associated with an instruction value.
3185  */
3186 void LLVMSetMetadata(LLVMValueRef Val, unsigned KindID, LLVMValueRef Node);
3187 
3188 /**
3189  * Returns the metadata associated with an instruction value, but filters out
3190  * all the debug locations.
3191  *
3192  * @see llvm::Instruction::getAllMetadataOtherThanDebugLoc()
3193  */
3196  size_t *NumEntries);
3197 
3198 /**
3199  * Obtain the basic block to which an instruction belongs.
3200  *
3201  * @see llvm::Instruction::getParent()
3202  */
3204 
3205 /**
3206  * Obtain the instruction that occurs after the one specified.
3207  *
3208  * The next instruction will be from the same basic block.
3209  *
3210  * If this is the last instruction in a basic block, NULL will be
3211  * returned.
3212  */
3214 
3215 /**
3216  * Obtain the instruction that occurred before this one.
3217  *
3218  * If the instruction is the first instruction in a basic block, NULL
3219  * will be returned.
3220  */
3222 
3223 /**
3224  * Remove and delete an instruction.
3225  *
3226  * The instruction specified is removed from its containing building
3227  * block but is kept alive.
3228  *
3229  * @see llvm::Instruction::removeFromParent()
3230  */
3232 
3233 /**
3234  * Remove and delete an instruction.
3235  *
3236  * The instruction specified is removed from its containing building
3237  * block and then deleted.
3238  *
3239  * @see llvm::Instruction::eraseFromParent()
3240  */
3242 
3243 /**
3244  * Obtain the code opcode for an individual instruction.
3245  *
3246  * @see llvm::Instruction::getOpCode()
3247  */
3249 
3250 /**
3251  * Obtain the predicate of an instruction.
3252  *
3253  * This is only valid for instructions that correspond to llvm::ICmpInst
3254  * or llvm::ConstantExpr whose opcode is llvm::Instruction::ICmp.
3255  *
3256  * @see llvm::ICmpInst::getPredicate()
3257  */
3259 
3260 /**
3261  * Obtain the float predicate of an instruction.
3262  *
3263  * This is only valid for instructions that correspond to llvm::FCmpInst
3264  * or llvm::ConstantExpr whose opcode is llvm::Instruction::FCmp.
3265  *
3266  * @see llvm::FCmpInst::getPredicate()
3267  */
3269 
3270 /**
3271  * Create a copy of 'this' instruction that is identical in all ways
3272  * except the following:
3273  * * The instruction has no parent
3274  * * The instruction has no name
3275  *
3276  * @see llvm::Instruction::clone()
3277  */
3279 
3280 /**
3281  * Determine whether an instruction is a terminator. This routine is named to
3282  * be compatible with historical functions that did this by querying the
3283  * underlying C++ type.
3284  *
3285  * @see llvm::Instruction::isTerminator()
3286  */
3288 
3289 /**
3290  * @defgroup LLVMCCoreValueInstructionCall Call Sites and Invocations
3291  *
3292  * Functions in this group apply to instructions that refer to call
3293  * sites and invocations. These correspond to C++ types in the
3294  * llvm::CallInst class tree.
3295  *
3296  * @{
3297  */
3298 
3299 /**
3300  * Obtain the argument count for a call instruction.
3301  *
3302  * This expects an LLVMValueRef that corresponds to a llvm::CallInst,
3303  * llvm::InvokeInst, or llvm:FuncletPadInst.
3304  *
3305  * @see llvm::CallInst::getNumArgOperands()
3306  * @see llvm::InvokeInst::getNumArgOperands()
3307  * @see llvm::FuncletPadInst::getNumArgOperands()
3308  */
3309 unsigned LLVMGetNumArgOperands(LLVMValueRef Instr);
3310 
3311 /**
3312  * Set the calling convention for a call instruction.
3313  *
3314  * This expects an LLVMValueRef that corresponds to a llvm::CallInst or
3315  * llvm::InvokeInst.
3316  *
3317  * @see llvm::CallInst::setCallingConv()
3318  * @see llvm::InvokeInst::setCallingConv()
3319  */
3320 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC);
3321 
3322 /**
3323  * Obtain the calling convention for a call instruction.
3324  *
3325  * This is the opposite of LLVMSetInstructionCallConv(). Reads its
3326  * usage.
3327  *
3328  * @see LLVMSetInstructionCallConv()
3329  */
3331 
3333  unsigned Align);
3334 
3341  LLVMAttributeIndex Idx,
3342  unsigned KindID);
3344  LLVMAttributeIndex Idx,
3345  const char *K, unsigned KLen);
3347  unsigned KindID);
3349  const char *K, unsigned KLen);
3350 
3351 /**
3352  * Obtain the function type called by this instruction.
3353  *
3354  * @see llvm::CallBase::getFunctionType()
3355  */
3357 
3358 /**
3359  * Obtain the pointer to the function invoked by this instruction.
3360  *
3361  * This expects an LLVMValueRef that corresponds to a llvm::CallInst or
3362  * llvm::InvokeInst.
3363  *
3364  * @see llvm::CallInst::getCalledOperand()
3365  * @see llvm::InvokeInst::getCalledOperand()
3366  */
3368 
3369 /**
3370  * Obtain whether a call instruction is a tail call.
3371  *
3372  * This only works on llvm::CallInst instructions.
3373  *
3374  * @see llvm::CallInst::isTailCall()
3375  */
3377 
3378 /**
3379  * Set whether a call instruction is a tail call.
3380  *
3381  * This only works on llvm::CallInst instructions.
3382  *
3383  * @see llvm::CallInst::setTailCall()
3384  */
3385 void LLVMSetTailCall(LLVMValueRef CallInst, LLVMBool IsTailCall);
3386 
3387 /**
3388  * Return the normal destination basic block.
3389  *
3390  * This only works on llvm::InvokeInst instructions.
3391  *
3392  * @see llvm::InvokeInst::getNormalDest()
3393  */
3395 
3396 /**
3397  * Return the unwind destination basic block.
3398  *
3399  * Works on llvm::InvokeInst, llvm::CleanupReturnInst, and
3400  * llvm::CatchSwitchInst instructions.
3401  *
3402  * @see llvm::InvokeInst::getUnwindDest()
3403  * @see llvm::CleanupReturnInst::getUnwindDest()
3404  * @see llvm::CatchSwitchInst::getUnwindDest()
3405  */
3407 
3408 /**
3409  * Set the normal destination basic block.
3410  *
3411  * This only works on llvm::InvokeInst instructions.
3412  *
3413  * @see llvm::InvokeInst::setNormalDest()
3414  */
3416 
3417 /**
3418  * Set the unwind destination basic block.
3419  *
3420  * Works on llvm::InvokeInst, llvm::CleanupReturnInst, and
3421  * llvm::CatchSwitchInst instructions.
3422  *
3423  * @see llvm::InvokeInst::setUnwindDest()
3424  * @see llvm::CleanupReturnInst::setUnwindDest()
3425  * @see llvm::CatchSwitchInst::setUnwindDest()
3426  */
3428 
3429 /**
3430  * @}
3431  */
3432 
3433 /**
3434  * @defgroup LLVMCCoreValueInstructionTerminator Terminators
3435  *
3436  * Functions in this group only apply to instructions for which
3437  * LLVMIsATerminatorInst returns true.
3438  *
3439  * @{
3440  */
3441 
3442 /**
3443  * Return the number of successors that this terminator has.
3444  *
3445  * @see llvm::Instruction::getNumSuccessors
3446  */
3448 
3449 /**
3450  * Return the specified successor.
3451  *
3452  * @see llvm::Instruction::getSuccessor
3453  */
3455 
3456 /**
3457  * Update the specified successor to point at the provided block.
3458  *
3459  * @see llvm::Instruction::setSuccessor
3460  */
3462 
3463 /**
3464  * Return if a branch is conditional.
3465  *
3466  * This only works on llvm::BranchInst instructions.
3467  *
3468  * @see llvm::BranchInst::isConditional
3469  */
3471 
3472 /**
3473  * Return the condition of a branch instruction.
3474  *
3475  * This only works on llvm::BranchInst instructions.
3476  *
3477  * @see llvm::BranchInst::getCondition
3478  */
3480 
3481 /**
3482  * Set the condition of a branch instruction.
3483  *
3484  * This only works on llvm::BranchInst instructions.
3485  *
3486  * @see llvm::BranchInst::setCondition
3487  */
3489 
3490 /**
3491  * Obtain the default destination basic block of a switch instruction.
3492  *
3493  * This only works on llvm::SwitchInst instructions.
3494  *
3495  * @see llvm::SwitchInst::getDefaultDest()
3496  */
3498 
3499 /**
3500  * @}
3501  */
3502 
3503 /**
3504  * @defgroup LLVMCCoreValueInstructionAlloca Allocas
3505  *
3506  * Functions in this group only apply to instructions that map to
3507  * llvm::AllocaInst instances.
3508  *
3509  * @{
3510  */
3511 
3512 /**
3513  * Obtain the type that is being allocated by the alloca instruction.
3514  */
3516 
3517 /**
3518  * @}
3519  */
3520 
3521 /**
3522  * @defgroup LLVMCCoreValueInstructionGetElementPointer GEPs
3523  *
3524  * Functions in this group only apply to instructions that map to
3525  * llvm::GetElementPtrInst instances.
3526  *
3527  * @{
3528  */
3529 
3530 /**
3531  * Check whether the given GEP operator is inbounds.
3532  */
3534 
3535 /**
3536  * Set the given GEP instruction to be inbounds or not.
3537  */
3538 void LLVMSetIsInBounds(LLVMValueRef GEP, LLVMBool InBounds);
3539 
3540 /**
3541  * Get the source element type of the given GEP operator.
3542  */
3544 
3545 /**
3546  * @}
3547  */
3548 
3549 /**
3550  * @defgroup LLVMCCoreValueInstructionPHINode PHI Nodes
3551  *
3552  * Functions in this group only apply to instructions that map to
3553  * llvm::PHINode instances.
3554  *
3555  * @{
3556  */
3557 
3558 /**
3559  * Add an incoming value to the end of a PHI list.
3560  */
3561 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
3562  LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
3563 
3564 /**
3565  * Obtain the number of incoming basic blocks to a PHI node.
3566  */
3567 unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
3568 
3569 /**
3570  * Obtain an incoming value to a PHI node as an LLVMValueRef.
3571  */
3573 
3574 /**
3575  * Obtain an incoming value to a PHI node as an LLVMBasicBlockRef.
3576  */
3578 
3579 /**
3580  * @}
3581  */
3582 
3583 /**
3584  * @defgroup LLVMCCoreValueInstructionExtractValue ExtractValue
3585  * @defgroup LLVMCCoreValueInstructionInsertValue InsertValue
3586  *
3587  * Functions in this group only apply to instructions that map to
3588  * llvm::ExtractValue and llvm::InsertValue instances.
3589  *
3590  * @{
3591  */
3592 
3593 /**
3594  * Obtain the number of indices.
3595  * NB: This also works on GEP operators.
3596  */
3597 unsigned LLVMGetNumIndices(LLVMValueRef Inst);
3598 
3599 /**
3600  * Obtain the indices as an array.
3601  */
3602 const unsigned *LLVMGetIndices(LLVMValueRef Inst);
3603 
3604 /**
3605  * @}
3606  */
3607 
3608 /**
3609  * @}
3610  */
3611 
3612 /**
3613  * @}
3614  */
3615 
3616 /**
3617  * @defgroup LLVMCCoreInstructionBuilder Instruction Builders
3618  *
3619  * An instruction builder represents a point within a basic block and is
3620  * the exclusive means of building instructions using the C interface.
3621  *
3622  * @{
3623  */
3624 
3628  LLVMValueRef Instr);
3635  const char *Name);
3637 
3638 /* Metadata */
3639 
3640 /**
3641  * Get location information used by debugging information.
3642  *
3643  * @see llvm::IRBuilder::getCurrentDebugLocation()
3644  */
3646 
3647 /**
3648  * Set location information used by debugging information.
3649  *
3650  * To clear the location metadata of the given instruction, pass NULL to \p Loc.
3651  *
3652  * @see llvm::IRBuilder::SetCurrentDebugLocation()
3653  */
3655 
3656 /**
3657  * Attempts to set the debug location for the given instruction using the
3658  * current debug location for the given builder. If the builder has no current
3659  * debug location, this function is a no-op.
3660  *
3661  * @deprecated LLVMSetInstDebugLocation is deprecated in favor of the more general
3662  * LLVMAddMetadataToInst.
3663  *
3664  * @see llvm::IRBuilder::SetInstDebugLocation()
3665  */
3667 
3668 /**
3669  * Adds the metadata registered with the given builder to the given instruction.
3670  *
3671  * @see llvm::IRBuilder::AddMetadataToInst()
3672  */
3674 
3675 /**
3676  * Get the dafult floating-point math metadata for a given builder.
3677  *
3678  * @see llvm::IRBuilder::getDefaultFPMathTag()
3679  */
3681 
3682 /**
3683  * Set the default floating-point math metadata for the given builder.
3684  *
3685  * To clear the metadata, pass NULL to \p FPMathTag.
3686  *
3687  * @see llvm::IRBuilder::setDefaultFPMathTag()
3688  */
3690  LLVMMetadataRef FPMathTag);
3691 
3692 /**
3693  * Deprecated: Passing the NULL location will crash.
3694  * Use LLVMGetCurrentDebugLocation2 instead.
3695  */
3697 /**
3698  * Deprecated: Returning the NULL location will crash.
3699  * Use LLVMGetCurrentDebugLocation2 instead.
3700  */
3702 
3703 /* Terminators */
3707  unsigned N);
3712  LLVMBasicBlockRef Else, unsigned NumCases);
3714  unsigned NumDests);
3717  LLVMValueRef *Args, unsigned NumArgs,
3719  LLVMBasicBlockRef Catch, const char *Name),
3720  "Use LLVMBuildInvoke2 instead to support opaque pointers");
3722  LLVMValueRef *Args, unsigned NumArgs,
3724  const char *Name);
3726 
3727 /* Exception Handling */
3730  LLVMValueRef PersFn, unsigned NumClauses,
3731  const char *Name);
3737  LLVMValueRef *Args, unsigned NumArgs,
3738  const char *Name);
3740  LLVMValueRef *Args, unsigned NumArgs,
3741  const char *Name);
3743  LLVMBasicBlockRef UnwindBB,
3744  unsigned NumHandlers, const char *Name);
3745 
3746 /* Add a case to the switch instruction */
3747 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
3748  LLVMBasicBlockRef Dest);
3749 
3750 /* Add a destination to the indirectbr instruction */
3751 void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest);
3752 
3753 /* Get the number of clauses on the landingpad instruction */
3754 unsigned LLVMGetNumClauses(LLVMValueRef LandingPad);
3755 
3756 /* Get the value of the clause at index Idx on the landingpad instruction */
3757 LLVMValueRef LLVMGetClause(LLVMValueRef LandingPad, unsigned Idx);
3758 
3759 /* Add a catch or filter clause to the landingpad instruction */
3760 void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal);
3761 
3762 /* Get the 'cleanup' flag in the landingpad instruction */
3763 LLVMBool LLVMIsCleanup(LLVMValueRef LandingPad);
3764 
3765 /* Set the 'cleanup' flag in the landingpad instruction */
3766 void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val);
3767 
3768 /* Add a destination to the catchswitch instruction */
3769 void LLVMAddHandler(LLVMValueRef CatchSwitch, LLVMBasicBlockRef Dest);
3770 
3771 /* Get the number of handlers on the catchswitch instruction */
3772 unsigned LLVMGetNumHandlers(LLVMValueRef CatchSwitch);
3773 
3774 /**
3775  * Obtain the basic blocks acting as handlers for a catchswitch instruction.
3776  *
3777  * The Handlers parameter should point to a pre-allocated array of
3778  * LLVMBasicBlockRefs at least LLVMGetNumHandlers() large. On return, the
3779  * first LLVMGetNumHandlers() entries in the array will be populated
3780  * with LLVMBasicBlockRef instances.
3781  *
3782  * @param CatchSwitch The catchswitch instruction to operate on.
3783  * @param Handlers Memory address of an array to be filled with basic blocks.
3784  */
3785 void LLVMGetHandlers(LLVMValueRef CatchSwitch, LLVMBasicBlockRef *Handlers);
3786 
3787 /* Funclets */
3788 
3789 /* Get the number of funcletpad arguments. */
3790 LLVMValueRef LLVMGetArgOperand(LLVMValueRef Funclet, unsigned i);
3791 
3792 /* Set a funcletpad argument at the given index. */
3793 void LLVMSetArgOperand(LLVMValueRef Funclet, unsigned i, LLVMValueRef value);
3794 
3795 /**
3796  * Get the parent catchswitch instruction of a catchpad instruction.
3797  *
3798  * This only works on llvm::CatchPadInst instructions.
3799  *
3800  * @see llvm::CatchPadInst::getCatchSwitch()
3801  */
3803 
3804 /**
3805  * Set the parent catchswitch instruction of a catchpad instruction.
3806  *
3807  * This only works on llvm::CatchPadInst instructions.
3808  *
3809  * @see llvm::CatchPadInst::setCatchSwitch()
3810  */
3811 void LLVMSetParentCatchSwitch(LLVMValueRef CatchPad, LLVMValueRef CatchSwitch);
3812 
3813 /* Arithmetic */
3815  const char *Name);
3817  const char *Name);
3819  const char *Name);
3821  const char *Name);
3823  const char *Name);
3825  const char *Name);
3827  const char *Name);
3829  const char *Name);
3831  const char *Name);
3833  const char *Name);
3835  const char *Name);
3837  const char *Name);
3839  const char *Name);
3841  const char *Name);
3843  const char *Name);
3845  const char *Name);
3847  const char *Name);
3849  const char *Name);
3851  const char *Name);
3853  const char *Name);
3855  const char *Name);
3857  const char *Name);
3859  const char *Name);
3861  const char *Name);
3863  const char *Name);
3865  const char *Name);
3868  const char *Name);
3871  const char *Name);
3873  const char *Name);
3876 
3877 /* Memory */
3880  LLVMValueRef Val, const char *Name);
3881 
3882 /**
3883  * Creates and inserts a memset to the specified pointer and the
3884  * specified value.
3885  *
3886  * @see llvm::IRRBuilder::CreateMemSet()
3887  */
3889  LLVMValueRef Val, LLVMValueRef Len,
3890  unsigned Align);
3891 /**
3892  * Creates and inserts a memcpy between the specified pointers.
3893  *
3894  * @see llvm::IRRBuilder::CreateMemCpy()
3895  */
3897  LLVMValueRef Dst, unsigned DstAlign,
3898  LLVMValueRef Src, unsigned SrcAlign,
3899  LLVMValueRef Size);
3900 /**
3901  * Creates and inserts a memmove between the specified pointers.
3902  *
3903  * @see llvm::IRRBuilder::CreateMemMove()
3904  */
3906  LLVMValueRef Dst, unsigned DstAlign,
3907  LLVMValueRef Src, unsigned SrcAlign,
3908  LLVMValueRef Size);
3909 
3912  LLVMValueRef Val, const char *Name);
3916  const char *Name),
3917  "Use LLVMBuildLoad2 instead to support opaque pointers");
3919  LLVMValueRef PointerVal, const char *Name);
3923  LLVMValueRef *Indices, unsigned NumIndices,
3924  const char *Name),
3925  "Use LLVMBuildGEP2 instead to support opaque pointers");
3928  LLVMValueRef *Indices,
3929  unsigned NumIndices, const char *Name),
3930  "Use LLVMBuildInBoundsGEP2 instead to support opaque pointers");
3933  unsigned Idx, const char *Name),
3934  "Use LLVMBuildStructGEP2 instead to support opaque pointers");
3936  LLVMValueRef Pointer, LLVMValueRef *Indices,
3937  unsigned NumIndices, const char *Name);
3939  LLVMValueRef Pointer, LLVMValueRef *Indices,
3940  unsigned NumIndices, const char *Name);
3942  LLVMValueRef Pointer, unsigned Idx,
3943  const char *Name);
3945  const char *Name);
3947  const char *Name);
3948 LLVMBool LLVMGetVolatile(LLVMValueRef MemoryAccessInst);
3949 void LLVMSetVolatile(LLVMValueRef MemoryAccessInst, LLVMBool IsVolatile);
3950 LLVMBool LLVMGetWeak(LLVMValueRef CmpXchgInst);
3951 void LLVMSetWeak(LLVMValueRef CmpXchgInst, LLVMBool IsWeak);
3953 void LLVMSetOrdering(LLVMValueRef MemoryAccessInst, LLVMAtomicOrdering Ordering);
3955 void LLVMSetAtomicRMWBinOp(LLVMValueRef AtomicRMWInst, LLVMAtomicRMWBinOp BinOp);
3956 
3957 /* Casts */
3959  LLVMTypeRef DestTy, const char *Name);
3961  LLVMTypeRef DestTy, const char *Name);
3963  LLVMTypeRef DestTy, const char *Name);
3965  LLVMTypeRef DestTy, const char *Name);
3967  LLVMTypeRef DestTy, const char *Name);
3969  LLVMTypeRef DestTy, const char *Name);
3971  LLVMTypeRef DestTy, const char *Name);
3973  LLVMTypeRef DestTy, const char *Name);
3975  LLVMTypeRef DestTy, const char *Name);
3977  LLVMTypeRef DestTy, const char *Name);
3979  LLVMTypeRef DestTy, const char *Name);
3981  LLVMTypeRef DestTy, const char *Name);
3983  LLVMTypeRef DestTy, const char *Name);
3985  LLVMTypeRef DestTy, const char *Name);
3987  LLVMTypeRef DestTy, const char *Name);
3989  LLVMTypeRef DestTy, const char *Name);
3991  LLVMTypeRef DestTy, const char *Name);
3993  LLVMTypeRef DestTy, const char *Name);
3995  LLVMTypeRef DestTy, LLVMBool IsSigned,
3996  const char *Name);
3998  LLVMTypeRef DestTy, const char *Name);
3999 
4000 /** Deprecated: This cast is always signed. Use LLVMBuildIntCast2 instead. */
4002  LLVMTypeRef DestTy, const char *Name);
4003 
4005  LLVMTypeRef DestTy, LLVMBool DestIsSigned);
4006 
4007 /* Comparisons */
4010  const char *Name);
4013  const char *Name);
4014 
4015 /* Miscellaneous instructions */
4019  LLVMValueRef *Args, unsigned NumArgs,
4020  const char *Name),
4021  "Use LLVMBuildCall2 instead to support opaque pointers");
4023  LLVMValueRef *Args, unsigned NumArgs,
4024  const char *Name);
4027  const char *Name);
4029  const char *Name);
4031  LLVMValueRef Index, const char *Name);
4034  const char *Name);
4037  const char *Name);
4039  unsigned Index, const char *Name);
4041  LLVMValueRef EltVal, unsigned Index,
4042  const char *Name);
4044  const char *Name);
4045 
4047  const char *Name);
4049  const char *Name);
4052  LLVMValueRef RHS, const char *Name),
4053  "Use LLVMBuildPtrDiff2 instead to support opaque pointers");
4056  const char *Name);
4058  LLVMBool singleThread, const char *Name);
4060  LLVMValueRef PTR, LLVMValueRef Val,
4061  LLVMAtomicOrdering ordering,
4062  LLVMBool singleThread);
4064  LLVMValueRef Cmp, LLVMValueRef New,
4065  LLVMAtomicOrdering SuccessOrdering,
4066  LLVMAtomicOrdering FailureOrdering,
4068 
4069 /**
4070  * Get the number of elements in the mask of a ShuffleVector instruction.
4071  */
4072 unsigned LLVMGetNumMaskElements(LLVMValueRef ShuffleVectorInst);
4073 
4074 /**
4075  * \returns a constant that specifies that the result of a \c ShuffleVectorInst
4076  * is undefined.
4077  */
4078 int LLVMGetUndefMaskElem(void);
4079 
4080 /**
4081  * Get the mask value at position Elt in the mask of a ShuffleVector
4082  * instruction.
4083  *
4084  * \Returns the result of \c LLVMGetUndefMaskElem() if the mask value is undef
4085  * at that position.
4086  */
4087 int LLVMGetMaskValue(LLVMValueRef ShuffleVectorInst, unsigned Elt);
4088 
4091 
4094  LLVMAtomicOrdering Ordering);
4097  LLVMAtomicOrdering Ordering);
4098 
4099 /**
4100  * @}
4101  */
4102 
4103 /**
4104  * @defgroup LLVMCCoreModuleProvider Module Providers
4105  *
4106  * @{
4107  */
4108 
4109 /**
4110  * Changes the type of M so it can be passed to FunctionPassManagers and the
4111  * JIT. They take ModuleProviders for historical reasons.
4112  */
4115 
4116 /**
4117  * Destroys the module M.
4118  */
4120 
4121 /**
4122  * @}
4123  */
4124 
4125 /**
4126  * @defgroup LLVMCCoreMemoryBuffers Memory Buffers
4127  *
4128  * @{
4129  */
4130 
4132  LLVMMemoryBufferRef *OutMemBuf,
4133  char **OutMessage);
4135  char **OutMessage);
4137  size_t InputDataLength,
4138  const char *BufferName,
4139  LLVMBool RequiresNullTerminator);
4141  size_t InputDataLength,
4142  const char *BufferName);
4143 const char *LLVMGetBufferStart(LLVMMemoryBufferRef MemBuf);
4144 size_t LLVMGetBufferSize(LLVMMemoryBufferRef MemBuf);
4146 
4147 /**
4148  * @}
4149  */
4150 
4151 /**
4152  * @defgroup LLVMCCorePassRegistry Pass Registry
4153  * @ingroup LLVMCCore
4154  *
4155  * @{
4156  */
4157 
4158 /** Return the global pass registry, for use with initialization functions.
4159  @see llvm::PassRegistry::getPassRegistry */
4161 
4162 /**
4163  * @}
4164  */
4165 
4166 /**
4167  * @defgroup LLVMCCorePassManagers Pass Managers
4168  * @ingroup LLVMCCore
4169  *
4170  * @{
4171  */
4172 
4173 /** Constructs a new whole-module pass pipeline. This type of pipeline is
4174  suitable for link-time optimization and whole-module transformations.
4175  @see llvm::PassManager::PassManager */
4177 
4178 /** Constructs a new function-by-function pass pipeline over the module
4179  provider. It does not take ownership of the module provider. This type of
4180  pipeline is suitable for code generation and JIT compilation tasks.
4181  @see llvm::FunctionPassManager::FunctionPassManager */
4183 
4184 /** Deprecated: Use LLVMCreateFunctionPassManagerForModule instead. */
4186 
4187 /** Initializes, executes on the provided module, and finalizes all of the
4188  passes scheduled in the pass manager. Returns 1 if any of the passes
4189  modified the module, 0 otherwise.
4190  @see llvm::PassManager::run(Module&) */
4192 
4193 /** Initializes all of the function passes scheduled in the function pass
4194  manager. Returns 1 if any of the passes modified the module, 0 otherwise.
4195  @see llvm::FunctionPassManager::doInitialization */
4197 
4198 /** Executes all of the function passes scheduled in the function pass manager
4199  on the provided function. Returns 1 if any of the passes modified the
4200  function, false otherwise.
4201  @see llvm::FunctionPassManager::run(Function&) */
4203 
4204 /** Finalizes all of the function passes scheduled in the function pass
4205  manager. Returns 1 if any of the passes modified the module, 0 otherwise.
4206  @see llvm::FunctionPassManager::doFinalization */
4208 
4209 /** Frees the memory of a pass pipeline. For function pipelines, does not free
4210  the module provider.
4211  @see llvm::PassManagerBase::~PassManagerBase. */
4213 
4214 /**
4215  * @}
4216  */
4217 
4218 /**
4219  * @defgroup LLVMCCoreThreading Threading
4220  *
4221  * Handle the structures needed to make LLVM safe for multithreading.
4222  *
4223  * @{
4224  */
4225 
4226 /** Deprecated: Multi-threading can only be enabled/disabled with the compile
4227  time define LLVM_ENABLE_THREADS. This function always returns
4228  LLVMIsMultithreaded(). */
4230 
4231 /** Deprecated: Multi-threading can only be enabled/disabled with the compile
4232  time define LLVM_ENABLE_THREADS. */
4233 void LLVMStopMultithreaded(void);
4234 
4235 /** Check whether LLVM is executing in thread-safe mode or not.
4236  @see llvm::llvm_is_multithreaded */
4238 
4239 /**
4240  * @}
4241  */
4242 
4243 /**
4244  * @}
4245  */
4246 
4247 /**
4248  * @}
4249  */
4250 
4252 
4253 #endif /* LLVM_C_CORE_H */
llvm::Check::Size
@ Size
Definition: FileCheck.h:76
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:3485
LLVMSetCleanup
void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val)
Definition: Core.cpp:3341
LLVMBuildIsNotNull
LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val, const char *Name)
Definition: Core.cpp:4037
LLVMBuildPointerCast
LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:3913
LLVMGetInitializer
LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar)
Definition: Core.cpp:2215
LLVMBuildNUWMul
LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:3430
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:3722
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:2155
LLVMBuildFSub
LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:3415
LLVMConstantVectorValueKind
@ LLVMConstantVectorValueKind
Definition: Core.h:272
LLVMGetVolatile
LLVMBool LLVMGetVolatile(LLVMValueRef MemoryAccessInst)
Definition: Core.cpp:3763
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
LLVMMSP430INTRCallConv
@ LLVMMSP430INTRCallConv
Definition: Core.h:229
LLVMGetNextParam
LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg)
Obtain the next parameter to a function.
Definition: Core.cpp:2588
LLVMSetTailCall
void LLVMSetTailCall(LLVMValueRef CallInst, LLVMBool IsTailCall)
Set whether a call instruction is a tail call.
Definition: Core.cpp:2967
LLVMGhostLinkage
@ LLVMGhostLinkage
Obsolete.
Definition: Core.h:188
LLVMGetBasicBlockTerminator
LLVMValueRef LLVMGetBasicBlockTerminator(LLVMBasicBlockRef BB)
Obtain the terminator instruction for a basic block.
Definition: Core.cpp:2695
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:3793
LLVMBuildBr
LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest)
Definition: Core.cpp:3211
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:2620
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:4086
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:2330
LLVMSetPersonalityFn
void LLVMSetPersonalityFn(LLVMValueRef Fn, LLVMValueRef PersonalityFn)
Set the personality function attached to the function.
Definition: Core.cpp:2410
LLVMConstLShr
LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1695
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:4247
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:3617
LLVMGetPersonalityFn
LLVMValueRef LLVMGetPersonalityFn(LLVMValueRef Fn)
Obtain the personality function attached to the function.
Definition: Core.cpp:2406
LLVMExternalLinkage
@ LLVMExternalLinkage
Externally visible function.
Definition: Core.h:172
LLVMGetNamedGlobal
LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name)
Definition: Core.cpp:2175
LLVMEraseGlobalIFunc
void LLVMEraseGlobalIFunc(LLVMValueRef IFunc)
Remove a global indirect function from its parent module and delete it.
Definition: Core.cpp:2665
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:1564
LLVMBuildCatchRet
LLVMValueRef LLVMBuildCatchRet(LLVMBuilderRef B, LLVMValueRef CatchPad, LLVMBasicBlockRef BB)
Definition: Core.cpp:3299
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:3975
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:3105
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:3359
LLVMConstAShr
LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1700
LLVMSub
@ LLVMSub
Definition: Core.h:77
LLVMBuildLoad
LLVMValueRef LLVMBuildLoad(LLVMBuilderRef B, LLVMValueRef PointerVal, const char *Name)
Definition: Core.cpp:3603
LLVMGetParams
void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params)
Obtain the parameters in a function.
Definition: Core.cpp:2557
LLVMConstICmp
LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate, LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1676
LLVMSetThreadLocal
void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal)
Definition: Core.cpp:2231
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:2625
LLVMFPToSI
@ LLVMFPToSI
Definition: Core.h:107
LLVMBuildZExtOrBitCast
LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:3889
LLVMSetSuccessor
void LLVMSetSuccessor(LLVMValueRef Term, unsigned i, LLVMBasicBlockRef block)
Update the specified successor to point at the provided block.
Definition: Core.cpp:3009
LLVMGetAllocatedType
LLVMTypeRef LLVMGetAllocatedType(LLVMValueRef Alloca)
Obtain the type that is being allocated by the alloca instruction.
Definition: Core.cpp:3035
LLVMGeneralDynamicTLSModel
@ LLVMGeneralDynamicTLSModel
Definition: Core.h:329
LLVMAddCallSiteAttribute
void LLVMAddCallSiteAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, LLVMAttributeRef A)
Definition: Core.cpp:2909
LLVMAtomicRMWBinOpOr
@ LLVMAtomicRMWBinOpOr
OR a value and return the old one.
Definition: Core.h:368
LLVMConstSExt
LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Definition: Core.cpp:1746
LLVMBuildGEP2
LLVMValueRef LLVMBuildGEP2(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Pointer, LLVMValueRef *Indices, unsigned NumIndices, const char *Name)
Definition: Core.cpp:3715
LLVMBuildFreeze
LLVMValueRef LLVMBuildFreeze(LLVMBuilderRef, LLVMValueRef Val, const char *Name)
Definition: Core.cpp:4027
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:4243
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:4235
LLVMBuildIntCast2
LLVMValueRef LLVMBuildIntCast2(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, LLVMBool IsSigned, const char *Name)
Definition: Core.cpp:3918
LLVMGetIncomingValue
LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index)
Obtain an incoming value to a PHI node as an LLVMValueRef.
Definition: Core.cpp:3066
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:4206
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:3510
LLVMConstIntCast
LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType, LLVMBool isSigned)
Definition: Core.cpp:1831
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:2292
LLVMSExt
@ LLVMSExt
Definition: Core.h:105
LLVMGetPreviousGlobalAlias
LLVMValueRef LLVMGetPreviousGlobalAlias(LLVMValueRef GA)
Decrement a GlobalAlias iterator to the previous GlobalAlias.
Definition: Core.cpp:2338
LLVMGetNextInstruction
LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst)
Obtain the instruction that occurs after the one specified.
Definition: Core.cpp:2824
LLVMAtomicRMWBinOp
LLVMAtomicRMWBinOp
Definition: Core.h:362
LLVMConstZExt
LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Definition: Core.cpp:1751
LLVMInsertValue
@ LLVMInsertValue
Definition: Core.h:130
LLVMAddGlobal
LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name)
Definition: Core.cpp:2161
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:1602
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:4125
LLVMCreateModuleProviderForExistingModule
LLVMModuleProviderRef LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M)
Changes the type of M so it can be passed to FunctionPassManagers and the JIT.
Definition: Core.cpp:4141
LLVMBuildPtrDiff2
LLVMValueRef LLVMBuildPtrDiff2(LLVMBuilderRef, LLVMTypeRef ElemTy, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:4049
LLVMBlockAddress
LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB)
Definition: Core.cpp:1896
LLVMInsertIntoBuilderWithName
void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr, const char *Name)
Definition: Core.cpp:3142
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:2699
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:2709
LLVMShl
@ LLVMShl
Definition: Core.h:89
LLVMConstExtractElement
LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant, LLVMValueRef IndexConstant)
Definition: Core.cpp:1850
LLVMGetGlobalParent
LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global)
Definition: Core.cpp:1902
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:1656
LLVMDisposeBuilder
void LLVMDisposeBuilder(LLVMBuilderRef Builder)
Definition: Core.cpp:3147
LLVMInlineAsmDialectATT
@ LLVMInlineAsmDialectATT
Definition: Core.h:396
LLVMGetFirstParam
LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn)
Obtain the first parameter to a function.
Definition: Core.cpp:2572
LLVMVoidTypeInContext
LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C)
Create a void type in a context.
Definition: Core.cpp:839
LLVMIsExternallyInitialized
LLVMBool LLVMIsExternallyInitialized(LLVMValueRef GlobalVar)
Definition: Core.cpp:2282
LLVMGetGlobalPassRegistry
LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void)
Return the global pass registry, for use with initialization functions.
Definition: Core.cpp:4212
LLVMCreateBasicBlockInContext
LLVMBasicBlockRef LLVMCreateBasicBlockInContext(LLVMContextRef C, const char *Name)
Create a new basic block without inserting it into a function.
Definition: Core.cpp:2745
LLVMBuildSub
LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:3400
LLVMBuildSelect
LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If, LLVMValueRef Then, LLVMValueRef Else, const char *Name)
Definition: Core.cpp:3983
LLVMSetUnnamedAddr
void LLVMSetUnnamedAddr(LLVMValueRef Global, LLVMBool HasUnnamedAddr)
Deprecated: Use LLVMSetUnnamedAddress instead.
Definition: Core.cpp:2063
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:2943
LLVMGetNextGlobal
LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar)
Definition: Core.cpp:2195
LLVMBuildICmp
LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Definition: Core.cpp:3944
LLVMMemoryPhiValueKind
@ LLVMMemoryPhiValueKind
Definition: Core.h:262
LLVMGetSection
const char * LLVMGetSection(LLVMValueRef Global)
Definition: Core.cpp:2004
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:3593
LLVMValueAsBasicBlock
LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val)
Convert an LLVMValueRef to an LLVMBasicBlockRef instance.
Definition: Core.cpp:2683
LLVMConstBitCast
LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Definition: Core.cpp:1796
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:4067
LLVMConstFPToSI
LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Definition: Core.cpp:1781
LLVMGetLastInstruction
LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB)
Obtain the last instruction in a basic block.
Definition: Core.cpp:2816
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:1476
LLVMScalableVectorTypeKind
@ LLVMScalableVectorTypeKind
Scalable SIMD vector type.
Definition: Core.h:166
LLVMConstExactSDiv
LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1635
LLVMConstInlineAsm
LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty, const char *AsmString, const char *Constraints, LLVMBool HasSideEffects, LLVMBool IsAlignStack)
Deprecated: Use LLVMGetInlineAsm instead.
Definition: Core.cpp:1888
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:1553
LLVMGetPreviousFunction
LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn)
Decrement a Function iterator to the previous Function.
Definition: Core.cpp:2390
LLVMConstSDiv
LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1630
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:4042
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:2366
LLVMGetFirstUse
LLVMUseRef LLVMGetFirstUse(LLVMValueRef Val)
Obtain the first use of a value.
Definition: Core.cpp:1009
llvm::tgtok::Else
@ Else
Definition: TGLexer.h:75
LLVMResume
@ LLVMResume
Definition: Core.h:139
LLVMConstFMul
LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1614
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:2356
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:3612
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:3164
LLVMCreateBuilder
LLVMBuilderRef LLVMCreateBuilder(void)
Definition: Core.cpp:3109
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:3480
LLVMSetCmpXchgFailureOrdering
void LLVMSetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst, LLVMAtomicOrdering Ordering)
Definition: Core.cpp:4130
LLVMBuilderGetDefaultFPMathTag
LLVMMetadataRef LLVMBuilderGetDefaultFPMathTag(LLVMBuilderRef Builder)
Get the dafult floating-point math metadata for a given builder.
Definition: Core.cpp:3192
LLVMSetDLLStorageClass
void LLVMSetDLLStorageClass(LLVMValueRef Global, LLVMDLLStorageClass Class)
Definition: Core.cpp:2029
LLVMConstantStructValueKind
@ LLVMConstantStructValueKind
Definition: Core.h:271
LLVMGetLastParam
LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn)
Obtain the last parameter to a function.
Definition: Core.cpp:2580
LLVMBuildPtrToInt
LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:3869
LLVMAppendExistingBasicBlock
void LLVMAppendExistingBasicBlock(LLVMValueRef Fn, LLVMBasicBlockRef BB)
Append the given basic block to the basic block list of the given function.
Definition: Core.cpp:2759
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:4001
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:2135
LLVMBuildZExt
LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Definition: Core.cpp:3829
LLVMGetInstructionCallConv
unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr)
Obtain the calling convention for a call instruction.
Definition: Core.cpp:2892
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:1619
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::RISCVFenceField::R
@ R
Definition: RISCVBaseInfo.h:240
LLVMUDiv
@ LLVMUDiv
Definition: Core.h:81
LLVMUnnamedAddr
LLVMUnnamedAddr
Definition: Core.h:200
LLVMAddClause
void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal)
Definition: Core.cpp:3332
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:3045
LLVMSetVolatile
void LLVMSetVolatile(LLVMValueRef MemoryAccessInst, LLVMBool IsVolatile)
Definition: Core.cpp:3774
LLVMInsertBasicBlock
LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB, const char *Name)
Insert a basic block in a function using the global context.
Definition: Core.cpp:2781
LLVMRemoveGlobalIFunc
void LLVMRemoveGlobalIFunc(LLVMValueRef IFunc)
Remove a global indirect function from its parent module.
Definition: Core.cpp:2669
LLVMIsTailCall
LLVMBool LLVMIsTailCall(LLVMValueRef CallInst)
Obtain whether a call instruction is a tail call.
Definition: Core.cpp:2963
LLVMConstFDiv
LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Definition: Core.cpp:1641
LLVMAddAttributeAtIndex
void LLVMAddAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, LLVMAttributeRef A)
Add an attribute to a function.
Definition: Core.cpp:2501
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:2786
LLVMIsConstantString
LLVMBool LLVMIsConstantString(LLVMValueRef c)
Returns true if the specified constant is an array of i8.
Definition: Core.cpp:1452
LLVMFAdd
@ LLVMFAdd
Definition: Core.h:76
LLVMConstFNeg
LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal)
Definition: Core.cpp:1545
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:3814
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:2649
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:3995
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:3818
LLVMIsAtomicSingleThread
LLVMBool LLVMIsAtomicSingleThread(LLVMValueRef AtomicInst)
Definition: Core.cpp:4094
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:2483
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:1939
LLVMPointerTypeIsOpaque
LLVMBool LLVMPointerTypeIsOpaque(LLVMTypeRef Ty)
Determine whether a pointer is opaque.
Definition: Core.cpp:795
LLVMVAArg
@ LLVMVAArg
Definition: Core.h:125
LLVMGetICmpPredicate
LLVMIntPredicate LLVMGetICmpPredicate(LLVMValueRef Inst)
Obtain the predicate of an instruction.
Definition: Core.cpp:2848
LLVMInt128TypeInContext
LLVMTypeRef LLVMInt128TypeInContext(LLVMContextRef C)
Definition: Core.cpp:591
LLVMGetLastGlobal
LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M)
Definition: Core.cpp:2187