--- /dev/null
+/*===-- llvm-c/BitWriter.h - BitWriter Library C Interface ------*- C++ -*-===*\
+|* *|
+|* The LLVM Compiler Infrastructure *|
+|* *|
+|* This file was developed by Gordon Henriksen and is distributed under the *|
+|* University of Illinois Open Source License. See LICENSE.TXT for details. *|
+|* *|
+|*===----------------------------------------------------------------------===*|
+|* *|
+|* This header declares the C interface to libLLVMBitWriter.a, which *|
+|* implements output of the LLVM bitcode format. *|
+|* *|
+|* Many exotic languages can interoperate with C code but have a harder time *|
+|* with C++ due to name mangling. So in addition to C, this interface enables *|
+|* tools written in such languages. *|
+|* *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_C_BITCODEWRITER_H
+#define LLVM_C_BITCODEWRITER_H
+
+#include "llvm-c/Core.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*===-- Operations on modules ---------------------------------------------===*/
+
+/* Writes a module to an open file descriptor. Returns 0 on success. */
+int LLVMWriteBitcodeToFileHandle(LLVMModuleRef M, int Handle);
+
+/* Writes a module to the specified path. Returns 0 on success. */
+int LLVMWriteBitcodeToFile(LLVMModuleRef M, const char *Path);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+/*===-- llvm-c/Core.h - Core Library C Interface ------------------*- C -*-===*\
+|* *|
+|* The LLVM Compiler Infrastructure *|
+|* *|
+|* This file was developed by Gordon Henriksen and is distributed under the *|
+|* University of Illinois Open Source License. See LICENSE.TXT for details. *|
+|* *|
+|*===----------------------------------------------------------------------===*|
+|* *|
+|* This header declares the C interface to libLLVMCore.a, which implements *|
+|* the LLVM intermediate representation. *|
+|* *|
+|* LLVM uses a polymorphic type hierarchy which C cannot represent, therefore *|
+|* parameters must be passed as base types. Despite the declared types, most *|
+|* of the functions provided operate only on branches of the type hierarchy. *|
+|* The declared parameter names are descriptive and specify which type is *|
+|* required. Additionally, each type hierarchy is documented along with the *|
+|* functions that operate upon it. For more detail, refer to LLVM's C++ code. *|
+|* If in doubt, refer to Core.cpp, which performs paramter downcasts in the *|
+|* form unwrap<RequiredType>(Param). *|
+|* *|
+|* Many exotic languages can interoperate with C code but have a harder time *|
+|* with C++ due to name mangling. So in addition to C, this interface enables *|
+|* tools written in such languages. *|
+|* *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_C_CORE_H
+#define LLVM_C_CORE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* Opaque types. */
+typedef struct LLVMOpaqueModule *LLVMModuleRef;
+typedef struct LLVMOpaqueType *LLVMTypeRef;
+typedef struct LLVMOpaqueValue *LLVMValueRef;
+
+typedef enum {
+ LLVMVoidTypeKind = 0, /* type with no size */
+ LLVMFloatTypeKind, /* 32 bit floating point type */
+ LLVMDoubleTypeKind, /* 64 bit floating point type */
+ LLVMX86_FP80TypeKind, /* 80 bit floating point type (X87) */
+ LLVMFP128TypeKind, /* 128 bit floating point type (112-bit mantissa) */
+ LLVMPPC_FP128TypeKind, /* 128 bit floating point type (two 64-bits) */
+ LLVMLabelTypeKind, /* Labels */
+ LLVMIntegerTypeKind, /* Arbitrary bit width integers */
+ LLVMFunctionTypeKind, /* Functions */
+ LLVMStructTypeKind, /* Structures */
+ LLVMArrayTypeKind, /* Arrays */
+ LLVMPointerTypeKind, /* Pointers */
+ LLVMOpaqueTypeKind, /* Opaque: type with unknown structure */
+ LLVMVectorTypeKind /* SIMD 'packed' format, or other vector type */
+} LLVMTypeKind;
+
+typedef enum {
+ LLVMExternalLinkage = 0,/* Externally visible function */
+ LLVMLinkOnceLinkage, /* Keep one copy of function when linking (inline) */
+ LLVMWeakLinkage, /* Keep one copy of function when linking (weak) */
+ LLVMAppendingLinkage, /* Special purpose, only applies to global arrays */
+ LLVMInternalLinkage, /* Rename collisions when linking (static functions)*/
+ LLVMDLLImportLinkage, /* Function to be imported from DLL */
+ LLVMDLLExportLinkage, /* Function to be accessible from DLL */
+ LLVMExternalWeakLinkage,/* ExternalWeak linkage description */
+ LLVMGhostLinkage /* Stand-in functions for streaming fns from bitcode*/
+} LLVMLinkage;
+
+typedef enum {
+ LLVMDefaultVisibility = 0, /* The GV is visible */
+ LLVMHiddenVisibility, /* The GV is hidden */
+ LLVMProtectedVisibility /* The GV is protected */
+} LLVMVisibility;
+
+
+/*===-- Modules -----------------------------------------------------------===*/
+
+/* Create and destroy modules. */
+LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
+void LLVMDisposeModule(LLVMModuleRef M);
+
+/* Same as Module::addTypeName. */
+int LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty);
+int LLVMDeleteTypeName(LLVMModuleRef M, const char *Name);
+
+
+/*===-- Types --------------------------------------------------------------===*/
+
+/* LLVM types conform to the following hierarchy:
+ *
+ * types:
+ * integer type
+ * real type
+ * function type
+ * sequence types:
+ * array type
+ * pointer type
+ * vector type
+ * void type
+ * label type
+ * opaque type
+ */
+
+LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
+void LLVMRefineAbstractType(LLVMTypeRef AbstractType, LLVMTypeRef ConcreteType);
+
+/* Operations on integer types */
+LLVMTypeRef LLVMInt1Type();
+LLVMTypeRef LLVMInt8Type();
+LLVMTypeRef LLVMInt16Type();
+LLVMTypeRef LLVMInt32Type();
+LLVMTypeRef LLVMInt64Type();
+LLVMTypeRef LLVMCreateIntegerType(unsigned NumBits);
+unsigned LLVMGetIntegerTypeWidth(LLVMTypeRef IntegerTy);
+
+/* Operations on real types */
+LLVMTypeRef LLVMFloatType();
+LLVMTypeRef LLVMDoubleType();
+LLVMTypeRef LLVMX86FP80Type();
+LLVMTypeRef LLVMFP128Type();
+LLVMTypeRef LLVMPPCFP128Type();
+
+/* Operations on function types */
+LLVMTypeRef LLVMCreateFunctionType(LLVMTypeRef ReturnType,
+ LLVMTypeRef *ParamTypes, unsigned ParamCount,
+ int IsVarArg);
+int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
+LLVMTypeRef LLVMGetFunctionReturnType(LLVMTypeRef FunctionTy);
+unsigned LLVMGetFunctionParamCount(LLVMTypeRef FunctionTy);
+void LLVMGetFunctionParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
+
+/* Operations on struct types */
+LLVMTypeRef LLVMCreateStructType(LLVMTypeRef *ElementTypes,
+ unsigned ElementCount, int Packed);
+unsigned LLVMGetStructElementCount(LLVMTypeRef StructTy);
+void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
+int LLVMIsPackedStruct(LLVMTypeRef StructTy);
+
+/* Operations on array, pointer, and vector types (sequence types) */
+LLVMTypeRef LLVMCreateArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
+LLVMTypeRef LLVMCreatePointerType(LLVMTypeRef ElementType);
+LLVMTypeRef LLVMCreateVectorType(LLVMTypeRef ElementType,unsigned ElementCount);
+
+LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
+unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
+unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
+
+/* Operations on other types */
+LLVMTypeRef LLVMVoidType();
+LLVMTypeRef LLVMLabelType();
+LLVMTypeRef LLVMCreateOpaqueType();
+
+
+/*===-- Values ------------------------------------------------------------===*/
+
+/* The bulk of LLVM's object model consists of values, which comprise a very
+ * rich type hierarchy.
+ *
+ * values:
+ * constants:
+ * scalar constants
+ * composite contants
+ * globals:
+ * global variable
+ * function
+ * alias
+ */
+
+/* Operations on all values */
+LLVMTypeRef LLVMGetTypeOfValue(LLVMValueRef Val);
+const char *LLVMGetValueName(LLVMValueRef Val);
+void LLVMSetValueName(LLVMValueRef Val, const char *Name);
+
+/* Operations on constants of any type */
+LLVMValueRef LLVMGetNull(LLVMTypeRef Ty); /* all zeroes */
+LLVMValueRef LLVMGetAllOnes(LLVMTypeRef Ty); /* only for int/vector */
+LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
+int LLVMIsNull(LLVMValueRef Val);
+
+/* Operations on scalar constants */
+LLVMValueRef LLVMGetIntConstant(LLVMTypeRef IntTy, unsigned long long N,
+ int SignExtend);
+LLVMValueRef LLVMGetRealConstant(LLVMTypeRef RealTy, double N);
+
+/* Operations on composite constants */
+LLVMValueRef LLVMGetStringConstant(const char *Str, unsigned Length,
+ int DontNullTerminate);
+LLVMValueRef LLVMGetArrayConstant(LLVMTypeRef ArrayTy,
+ LLVMValueRef *ConstantVals, unsigned Length);
+LLVMValueRef LLVMGetStructConstant(LLVMValueRef *ConstantVals, unsigned Count,
+ int packed);
+LLVMValueRef LLVMGetVectorConstant(LLVMValueRef *ScalarConstantVals,
+ unsigned Size);
+
+/* Operations on global variables, functions, and aliases (globals) */
+int LLVMIsDeclaration(LLVMValueRef Global);
+LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
+void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
+const char *LLVMGetSection(LLVMValueRef Global);
+void LLVMSetSection(LLVMValueRef Global, const char *Section);
+LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
+void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
+unsigned LLVMGetAlignment(LLVMValueRef Global);
+void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
+
+/* Operations on global variables */
+LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
+void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
+int LLVMHasInitializer(LLVMValueRef GlobalVar);
+LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
+void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
+int LLVMIsThreadLocal(LLVMValueRef GlobalVar);
+void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+//===-- Support/CHelpers.h - Utilities for writing C bindings -------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// These opaque reference<-->pointer conversions are shorter and more tightly
+// typed than writing the casts by hand in C bindings. In assert builds, they
+// will do type checking.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_CHELPERS_H
+#define LLVM_SUPPORT_CHELPERS_H
+
+#include "llvm/Module.h"
+#include "llvm/Type.h"
+#include "llvm/Value.h"
+
+typedef struct LLVMOpaqueModule *LLVMModuleRef;
+typedef struct LLVMOpaqueType *LLVMTypeRef;
+typedef struct LLVMOpaqueValue *LLVMValueRef;
+
+namespace llvm {
+ /// Opaque module conversions
+ ///
+ inline Module *unwrap(LLVMModuleRef M) {
+ return reinterpret_cast<Module*>(M);
+ }
+
+ inline LLVMModuleRef wrap(Module *M) {
+ return reinterpret_cast<LLVMModuleRef>(M);
+ }
+
+ /// Opaque type conversions
+ ///
+ inline Type *unwrap(LLVMTypeRef Ty) {
+ return reinterpret_cast<Type*>(Ty);
+ }
+
+ template<typename T>
+ inline T *unwrap(LLVMTypeRef Ty) {
+ return cast<T>(unwrap(Ty));
+ }
+
+ inline Type **unwrap(LLVMTypeRef* Tys) {
+ return reinterpret_cast<Type**>(Tys);
+ }
+
+ inline LLVMTypeRef wrap(const Type *Ty) {
+ return reinterpret_cast<LLVMTypeRef>(const_cast<Type*>(Ty));
+ }
+
+ inline LLVMTypeRef *wrap(const Type **Tys) {
+ return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
+ }
+
+ /// Opaque value conversions
+ ///
+ inline Value *unwrap(LLVMValueRef Val) {
+ return reinterpret_cast<Value*>(Val);
+ }
+
+ template<typename T>
+ inline T *unwrap(LLVMValueRef Val) {
+ return cast<T>(unwrap(Val));
+ }
+
+ inline Value **unwrap(LLVMValueRef *Vals) {
+ return reinterpret_cast<Value**>(Vals);
+ }
+
+ template<typename T>
+ inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
+ #if DEBUG
+ for (LLVMValueRef *I = Vals, E = Vals + Length; I != E; ++I)
+ cast<T>(*I);
+ #endif
+ return reinterpret_cast<T**>(Vals);
+ }
+
+ inline LLVMValueRef wrap(const Value *Val) {
+ return reinterpret_cast<LLVMValueRef>(const_cast<Value*>(Val));
+ }
+
+ inline LLVMValueRef *wrap(const Value **Vals) {
+ return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
+ }
+}
+
+#endif
--- /dev/null
+//===-- BitWriter.cpp -----------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm-c/BitWriter.h"
+#include "llvm/CHelpers.h"
+#include "llvm/Bitcode/ReaderWriter.h"
+#include <fstream>
+
+using namespace llvm;
+
+
+/*===-- Operations on modules ---------------------------------------------===*/
+
+int LLVMWriteBitcodeToFile(LLVMModuleRef M, const char *Path) {
+ std::ofstream OS(Path);
+
+ if (!OS.fail())
+ WriteBitcodeToFile(unwrap(M), OS);
+
+ if (OS.fail())
+ return -1;
+
+ return 0;
+}
+
+#ifdef __GNUC__
+#include <ext/stdio_filebuf.h>
+
+// FIXME: Control this with configure? Provide some portable abstraction in
+// libSystem? As is, the user will just get a linker error if they use this on
+// non-GCC. Some C++ stdlibs even have ofstream::ofstream(int fd).
+int LLVMWriteBitcodeToFileHandle(LLVMModuleRef M, int FileHandle) {
+ __gnu_cxx::stdio_filebuf<char> Buffer(FileHandle, std::ios_base::out);
+ std::ostream OS(&Buffer);
+
+ if (!OS.fail())
+ WriteBitcodeToFile(unwrap(M), OS);
+
+ if (OS.fail())
+ return -1;
+
+ return 0;
+}
+
+#endif
--- /dev/null
+//===-- Core.cpp ----------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by Gordon Henriksen and is distributed under the
+// University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the C bindings for libLLVMCore.a, which implements
+// the LLVM intermediate representation.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm-c/Core.h"
+#include "llvm/Bitcode/ReaderWriter.h"
+#include "llvm/CHelpers.h"
+#include "llvm/Constants.h"
+#include "llvm/DerivedTypes.h"
+#include "llvm/GlobalVariable.h"
+#include <ostream>
+#include <fstream>
+#include <cassert>
+
+using namespace llvm;
+
+
+/*===-- Operations on modules ---------------------------------------------===*/
+
+LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID) {
+ return wrap(new Module(ModuleID));
+}
+
+void LLVMDisposeModule(LLVMModuleRef M) {
+ delete unwrap(M);
+}
+
+int LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty) {
+ return unwrap(M)->addTypeName(Name, unwrap(Ty));
+}
+
+
+/*===-- Operations on types -----------------------------------------------===*/
+
+/*--.. Operations on all types (mostly) ....................................--*/
+
+LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty) {
+ return static_cast<LLVMTypeKind>(unwrap(Ty)->getTypeID());
+}
+
+void LLVMRefineAbstractType(LLVMTypeRef AbstractType, LLVMTypeRef ConcreteType){
+ DerivedType *Ty = unwrap<DerivedType>(AbstractType);
+ Ty->refineAbstractTypeTo(unwrap(ConcreteType));
+}
+
+/*--.. Operations on integer types .........................................--*/
+
+LLVMTypeRef LLVMInt1Type() { return (LLVMTypeRef) Type::Int1Ty; }
+LLVMTypeRef LLVMInt8Type() { return (LLVMTypeRef) Type::Int8Ty; }
+LLVMTypeRef LLVMInt16Type() { return (LLVMTypeRef) Type::Int16Ty; }
+LLVMTypeRef LLVMInt32Type() { return (LLVMTypeRef) Type::Int32Ty; }
+LLVMTypeRef LLVMInt64Type() { return (LLVMTypeRef) Type::Int64Ty; }
+
+LLVMTypeRef LLVMCreateIntegerType(unsigned NumBits) {
+ return wrap(IntegerType::get(NumBits));
+}
+
+unsigned LLVMGetIntegerTypeWidth(LLVMTypeRef IntegerTy) {
+ return unwrap<IntegerType>(IntegerTy)->getBitWidth();
+}
+
+/*--.. Operations on real types ............................................--*/
+
+LLVMTypeRef LLVMFloatType() { return (LLVMTypeRef) Type::FloatTy; }
+LLVMTypeRef LLVMDoubleType() { return (LLVMTypeRef) Type::DoubleTy; }
+LLVMTypeRef LLVMX86FP80Type() { return (LLVMTypeRef) Type::X86_FP80Ty; }
+LLVMTypeRef LLVMFP128Type() { return (LLVMTypeRef) Type::FP128Ty; }
+LLVMTypeRef LLVMPPCFP128Type() { return (LLVMTypeRef) Type::PPC_FP128Ty; }
+
+/*--.. Operations on function types ........................................--*/
+
+LLVMTypeRef LLVMCreateFunctionType(LLVMTypeRef ReturnType,
+ LLVMTypeRef *ParamTypes, unsigned ParamCount,
+ int IsVarArg) {
+ std::vector<const Type*> Tys;
+ for (LLVMTypeRef *I = ParamTypes, *E = ParamTypes + ParamCount; I != E; ++I)
+ Tys.push_back(unwrap(*I));
+
+ return wrap(FunctionType::get(unwrap(ReturnType), Tys, IsVarArg != 0));
+}
+
+int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy) {
+ return unwrap<FunctionType>(FunctionTy)->isVarArg();
+}
+
+LLVMTypeRef LLVMGetFunctionReturnType(LLVMTypeRef FunctionTy) {
+ return wrap(unwrap<FunctionType>(FunctionTy)->getReturnType());
+}
+
+unsigned LLVMGetFunctionParamCount(LLVMTypeRef FunctionTy) {
+ return unwrap<FunctionType>(FunctionTy)->getNumParams();
+}
+
+void LLVMGetFunctionParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest) {
+ FunctionType *Ty = unwrap<FunctionType>(FunctionTy);
+ for (FunctionType::param_iterator I = Ty->param_begin(),
+ E = Ty->param_end(); I != E; ++I)
+ *Dest++ = wrap(*I);
+}
+
+/*--.. Operations on struct types ..........................................--*/
+
+LLVMTypeRef LLVMCreateStructType(LLVMTypeRef *ElementTypes,
+ unsigned ElementCount, int Packed) {
+ std::vector<const Type*> Tys;
+ for (LLVMTypeRef *I = ElementTypes,
+ *E = ElementTypes + ElementCount; I != E; ++I)
+ Tys.push_back(unwrap(*I));
+
+ return wrap(StructType::get(Tys, Packed != 0));
+}
+
+unsigned LLVMGetStructElementCount(LLVMTypeRef StructTy) {
+ return unwrap<StructType>(StructTy)->getNumElements();
+}
+
+void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest) {
+ StructType *Ty = unwrap<StructType>(StructTy);
+ for (FunctionType::param_iterator I = Ty->element_begin(),
+ E = Ty->element_end(); I != E; ++I)
+ *Dest++ = wrap(*I);
+}
+
+int LLVMIsPackedStruct(LLVMTypeRef StructTy) {
+ return unwrap<StructType>(StructTy)->isPacked();
+}
+
+/*--.. Operations on array, pointer, and vector types (sequence types) .....--*/
+
+LLVMTypeRef LLVMCreateArrayType(LLVMTypeRef ElementType, unsigned ElementCount){
+ return wrap(ArrayType::get(unwrap(ElementType), ElementCount));
+}
+
+LLVMTypeRef LLVMCreatePointerType(LLVMTypeRef ElementType) {
+ return wrap(PointerType::get(unwrap(ElementType)));
+}
+
+LLVMTypeRef LLVMCreateVectorType(LLVMTypeRef ElementType,unsigned ElementCount){
+ return wrap(VectorType::get(unwrap(ElementType), ElementCount));
+}
+
+LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty) {
+ return wrap(unwrap<SequentialType>(Ty)->getElementType());
+}
+
+unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy) {
+ return unwrap<ArrayType>(ArrayTy)->getNumElements();
+}
+
+unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy) {
+ return unwrap<VectorType>(VectorTy)->getNumElements();
+}
+
+/*--.. Operations on other types ...........................................--*/
+
+LLVMTypeRef LLVMVoidType() { return (LLVMTypeRef) Type::VoidTy; }
+LLVMTypeRef LLVMLabelType() { return (LLVMTypeRef) Type::LabelTy; }
+
+LLVMTypeRef LLVMCreateOpaqueType() {
+ return wrap(llvm::OpaqueType::get());
+}
+
+
+/*===-- Operations on values ----------------------------------------------===*/
+
+/*--.. Operations on all values ............................................--*/
+
+LLVMTypeRef LLVMGetTypeOfValue(LLVMValueRef Val) {
+ return wrap(unwrap(Val)->getType());
+}
+
+const char *LLVMGetValueName(LLVMValueRef Val) {
+ return unwrap(Val)->getNameStart();
+}
+
+void LLVMSetValueName(LLVMValueRef Val, const char *Name) {
+ unwrap(Val)->setName(Name);
+}
+
+/*--.. Operations on constants of any type .................................--*/
+
+LLVMValueRef LLVMGetNull(LLVMTypeRef Ty) {
+ return wrap(Constant::getNullValue(unwrap(Ty)));
+}
+
+LLVMValueRef LLVMGetAllOnes(LLVMTypeRef Ty) {
+ return wrap(Constant::getAllOnesValue(unwrap(Ty)));
+}
+
+LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty) {
+ return wrap(UndefValue::get(unwrap(Ty)));
+}
+
+int LLVMIsNull(LLVMValueRef Val) {
+ if (Constant *C = dyn_cast<Constant>(unwrap(Val)))
+ return C->isNullValue();
+ return false;
+}
+
+/*--.. Operations on scalar constants ......................................--*/
+
+LLVMValueRef LLVMGetIntConstant(LLVMTypeRef IntTy, unsigned long long N,
+ int SignExtend) {
+ return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), N, SignExtend != 0));
+}
+
+LLVMValueRef LLVMGetRealConstant(LLVMTypeRef RealTy, double N) {
+ return wrap(ConstantFP::get(unwrap(RealTy), APFloat(N)));
+}
+
+/*--.. Operations on composite constants ...................................--*/
+
+LLVMValueRef LLVMGetStringConstant(const char *Str, unsigned Length,
+ int DontNullTerminate) {
+ /* Inverted the sense of AddNull because ', 0)' is a
+ better mnemonic for null termination than ', 1)'. */
+ return wrap(ConstantArray::get(std::string(Str, Length),
+ DontNullTerminate == 0));
+}
+
+LLVMValueRef LLVMGetArrayConstant(LLVMTypeRef ElementTy,
+ LLVMValueRef *ConstantVals, unsigned Length) {
+ return wrap(ConstantArray::get(ArrayType::get(unwrap(ElementTy), Length),
+ unwrap<Constant>(ConstantVals, Length),
+ Length));
+}
+
+LLVMValueRef LLVMGetStructConstant(LLVMValueRef *ConstantVals, unsigned Count,
+ int Packed) {
+ return wrap(ConstantStruct::get(unwrap<Constant>(ConstantVals, Count),
+ Count, Packed != 0));
+}
+
+LLVMValueRef LLVMGetVectorConstant(LLVMValueRef *ScalarConstantVals,
+ unsigned Size) {
+ return wrap(ConstantVector::get(unwrap<Constant>(ScalarConstantVals, Size),
+ Size));
+}
+
+/*--.. Operations on global variables, functions, and aliases (globals) ....--*/
+
+int LLVMIsDeclaration(LLVMValueRef Global) {
+ return unwrap<GlobalValue>(Global)->isDeclaration();
+}
+
+LLVMLinkage LLVMGetLinkage(LLVMValueRef Global) {
+ return static_cast<LLVMLinkage>(unwrap<GlobalValue>(Global)->getLinkage());
+}
+
+void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage) {
+ unwrap<GlobalValue>(Global)
+ ->setLinkage(static_cast<GlobalValue::LinkageTypes>(Linkage));
+}
+
+const char *LLVMGetSection(LLVMValueRef Global) {
+ return unwrap<GlobalValue>(Global)->getSection().c_str();
+}
+
+void LLVMSetSection(LLVMValueRef Global, const char *Section) {
+ unwrap<GlobalValue>(Global)->setSection(Section);
+}
+
+LLVMVisibility LLVMGetVisibility(LLVMValueRef Global) {
+ return static_cast<LLVMVisibility>(
+ unwrap<GlobalValue>(Global)->getVisibility());
+}
+
+void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz) {
+ unwrap<GlobalValue>(Global)
+ ->setVisibility(static_cast<GlobalValue::VisibilityTypes>(Viz));
+}
+
+unsigned LLVMGetAlignment(LLVMValueRef Global) {
+ return unwrap<GlobalValue>(Global)->getAlignment();
+}
+
+void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes) {
+ unwrap<GlobalValue>(Global)->setAlignment(Bytes);
+}
+
+/*--.. Operations on global variables ......................................--*/
+
+LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name) {
+ return wrap(new GlobalVariable(unwrap(Ty), false,
+ GlobalValue::ExternalLinkage, 0, Name, unwrap(M)));
+}
+
+void LLVMDeleteGlobal(LLVMValueRef GlobalVar) {
+ unwrap<GlobalVariable>(GlobalVar)->eraseFromParent();
+}
+
+int LLVMHasInitializer(LLVMValueRef GlobalVar) {
+ return unwrap<GlobalVariable>(GlobalVar)->hasInitializer();
+}
+
+LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar) {
+ return wrap(unwrap<GlobalVariable>(GlobalVar)->getInitializer());
+}
+
+void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal) {
+ unwrap<GlobalVariable>(GlobalVar)
+ ->setInitializer(unwrap<Constant>(ConstantVal));
+}
+
+int LLVMIsThreadLocal(LLVMValueRef GlobalVar) {
+ return unwrap<GlobalVariable>(GlobalVar)->isThreadLocal();
+}
+
+void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal) {
+ unwrap<GlobalVariable>(GlobalVar)->setThreadLocal(IsThreadLocal != 0);
+}
+
projects / oota-llvm.git / commitdiff