LLVM API Documentation

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