From 76a0374b252c24bf2b2f571b252a3822698c1c33 Mon Sep 17 00:00:00 2001 From: Gordon Henriksen Date: Tue, 18 Sep 2007 03:18:57 +0000 Subject: C bindings for libLLVMCore.a and libLLVMBitWriter.a. - The naming prefix is LLVM. - All types are represented using opaque references. - Functions are not named LLVM{Type}{Method}; the names became unreadable goop. Instead, they are named LLVM{ImperativeSentence}. - Where an attribute only appears once in the class hierarchy (e.g., linkage only applies to values; parameter types only apply to function types), the class is omitted from identifiers for brevity. Tastes like methods. - Strings are C strings or string/length tuples on a case-by-case basis. - APIs which give the caller ownership of an object are not mapped (removeFromParent, certain constructor overloads). This keeps keep memory management as simple as possible. For each library with bindings: llvm-c/.h - Declares the bindings. lib//.cpp - Implements the bindings. So just link with the library of your choice and use the C header instead of the C++ one. llvm-svn: 42077 --- llvm/lib/VMCore/Core.cpp | 322 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 322 insertions(+) create mode 100644 llvm/lib/VMCore/Core.cpp (limited to 'llvm/lib/VMCore/Core.cpp') diff --git a/llvm/lib/VMCore/Core.cpp b/llvm/lib/VMCore/Core.cpp new file mode 100644 index 00000000000..297027fd314 --- /dev/null +++ b/llvm/lib/VMCore/Core.cpp @@ -0,0 +1,322 @@ +//===-- 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 +#include +#include + +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(unwrap(Ty)->getTypeID()); +} + +void LLVMRefineAbstractType(LLVMTypeRef AbstractType, LLVMTypeRef ConcreteType){ + DerivedType *Ty = unwrap(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(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 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(FunctionTy)->isVarArg(); +} + +LLVMTypeRef LLVMGetFunctionReturnType(LLVMTypeRef FunctionTy) { + return wrap(unwrap(FunctionTy)->getReturnType()); +} + +unsigned LLVMGetFunctionParamCount(LLVMTypeRef FunctionTy) { + return unwrap(FunctionTy)->getNumParams(); +} + +void LLVMGetFunctionParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest) { + FunctionType *Ty = unwrap(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 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(StructTy)->getNumElements(); +} + +void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest) { + StructType *Ty = unwrap(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(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(Ty)->getElementType()); +} + +unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy) { + return unwrap(ArrayTy)->getNumElements(); +} + +unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy) { + return unwrap(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(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(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(ConstantVals, Length), + Length)); +} + +LLVMValueRef LLVMGetStructConstant(LLVMValueRef *ConstantVals, unsigned Count, + int Packed) { + return wrap(ConstantStruct::get(unwrap(ConstantVals, Count), + Count, Packed != 0)); +} + +LLVMValueRef LLVMGetVectorConstant(LLVMValueRef *ScalarConstantVals, + unsigned Size) { + return wrap(ConstantVector::get(unwrap(ScalarConstantVals, Size), + Size)); +} + +/*--.. Operations on global variables, functions, and aliases (globals) ....--*/ + +int LLVMIsDeclaration(LLVMValueRef Global) { + return unwrap(Global)->isDeclaration(); +} + +LLVMLinkage LLVMGetLinkage(LLVMValueRef Global) { + return static_cast(unwrap(Global)->getLinkage()); +} + +void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage) { + unwrap(Global) + ->setLinkage(static_cast(Linkage)); +} + +const char *LLVMGetSection(LLVMValueRef Global) { + return unwrap(Global)->getSection().c_str(); +} + +void LLVMSetSection(LLVMValueRef Global, const char *Section) { + unwrap(Global)->setSection(Section); +} + +LLVMVisibility LLVMGetVisibility(LLVMValueRef Global) { + return static_cast( + unwrap(Global)->getVisibility()); +} + +void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz) { + unwrap(Global) + ->setVisibility(static_cast(Viz)); +} + +unsigned LLVMGetAlignment(LLVMValueRef Global) { + return unwrap(Global)->getAlignment(); +} + +void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes) { + unwrap(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(GlobalVar)->eraseFromParent(); +} + +int LLVMHasInitializer(LLVMValueRef GlobalVar) { + return unwrap(GlobalVar)->hasInitializer(); +} + +LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar) { + return wrap(unwrap(GlobalVar)->getInitializer()); +} + +void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal) { + unwrap(GlobalVar) + ->setInitializer(unwrap(ConstantVal)); +} + +int LLVMIsThreadLocal(LLVMValueRef GlobalVar) { + return unwrap(GlobalVar)->isThreadLocal(); +} + +void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal) { + unwrap(GlobalVar)->setThreadLocal(IsThreadLocal != 0); +} + -- cgit v1.2.3