schala/src/llvm_wrap.rs

extern crate llvm_sys;

use self::llvm_sys::prelude::*;
use self::llvm_sys::core;
use std::ptr;
use std::ffi::CString;

pub fn create_context() -> LLVMContextRef {
    unsafe {
        core::LLVMContextCreate()
    }
}
pub fn module_create_with_name(name: &str) -> LLVMModuleRef {
    unsafe {
        let n = name.as_ptr() as *const _;
        core::LLVMModuleCreateWithName(n)
    }
}
pub fn CreateBuilderInContext(context: LLVMContextRef) -> LLVMBuilderRef {
    unsafe {
        core::LLVMCreateBuilderInContext(context)
    }
}

pub fn AppendBasicBlockInContext(context: LLVMContextRef, function: LLVMValueRef, name: &str) -> LLVMBasicBlockRef {
    let c_name = CString::new(name).unwrap();
    unsafe {
        core::LLVMAppendBasicBlockInContext(context, function, c_name.as_ptr())
    }
}

pub fn AddFunction(module: LLVMModuleRef, name: &str, function_type: LLVMTypeRef) ->  LLVMValueRef {
    let c_name = CString::new(name).unwrap();
    unsafe {
        core::LLVMAddFunction(module, c_name.as_ptr(), function_type)
    }
}

//NOTE this is incomplete
pub fn FunctionType(return_type: LLVMTypeRef, param_types: &[LLVMTypeRef], is_var_rag: bool) -> LLVMTypeRef {
    let len = param_types.len();
    unsafe {
        core::LLVMFunctionType(return_type, ptr::null_mut(), len as u32, if is_var_rag { 1 } else { 0 })
    }
}

pub fn VoidTypeInContext(context: LLVMContextRef) -> LLVMTypeRef {
    unsafe {
        core::LLVMVoidTypeInContext(context)
    }
}

pub fn DisposeBuilder(builder: LLVMBuilderRef) {
    unsafe {
        core::LLVMDisposeBuilder(builder)
    }
}

pub fn DisposeModule(module: LLVMModuleRef) {
    unsafe {
        core::LLVMDisposeModule(module)
    }
}

pub fn ContextDispose(context: LLVMContextRef) {
    unsafe {
        core::LLVMContextDispose(context)
    }
}

pub fn PositionBuilderAtEnd(builder: LLVMBuilderRef, basic_block: LLVMBasicBlockRef) {
    unsafe {
        core::LLVMPositionBuilderAtEnd(builder, basic_block)
    }
}

pub fn BuildRet(builder: LLVMBuilderRef, val: LLVMValueRef) -> LLVMValueRef {
    unsafe {
        core::LLVMBuildRet(builder, val)
    }
}

pub fn BuildRetVoid(builder: LLVMBuilderRef) -> LLVMValueRef {
    unsafe {
        core::LLVMBuildRetVoid(builder)
    }
}

pub fn DumpModule(module: LLVMModuleRef) {
    unsafe {
        core::LLVMDumpModule(module)
    }
}

pub fn Int64TypeInContext(context: LLVMContextRef) -> LLVMTypeRef {
    unsafe {
        core::LLVMInt64TypeInContext(context)
    }
}

pub fn ConstInt(int_type: LLVMTypeRef, n: u64, sign_extend: bool) -> LLVMValueRef {
    unsafe {
        core::LLVMConstInt(int_type, n, if sign_extend { 1 } else { 0 })
    }
}

pub fn BuildAdd(builder: LLVMBuilderRef, lhs: LLVMValueRef, rhs: LLVMValueRef, reg_name: &str) -> LLVMValueRef {
    let name = CString::new(reg_name).unwrap();
    unsafe {
        core::LLVMBuildAdd(builder, lhs, rhs, name.as_ptr())
    }
}

pub fn BuildSub(builder: LLVMBuilderRef, lhs: LLVMValueRef, rhs: LLVMValueRef, reg_name: &str) -> LLVMValueRef {
    let name = CString::new(reg_name).unwrap();
    unsafe {
        core::LLVMBuildSub(builder, lhs, rhs, name.as_ptr())
    }
}

pub fn BuildMul(builder: LLVMBuilderRef, lhs: LLVMValueRef, rhs: LLVMValueRef, reg_name: &str) -> LLVMValueRef {
    let name = CString::new(reg_name).unwrap();
    unsafe {
        core::LLVMBuildMul(builder, lhs, rhs, name.as_ptr())
    }
}

pub fn BuildUDiv(builder: LLVMBuilderRef, lhs: LLVMValueRef, rhs: LLVMValueRef, reg_name: &str) -> LLVMValueRef {
    let name = CString::new(reg_name).unwrap();
    unsafe {
        core::LLVMBuildUDiv(builder, lhs, rhs, name.as_ptr())
    }
}

pub fn BuildSRem(builder: LLVMBuilderRef, lhs: LLVMValueRef, rhs: LLVMValueRef, reg_name: &str) -> LLVMValueRef {
    let name = CString::new(reg_name).unwrap();
    unsafe {
        core::LLVMBuildSRem(builder, lhs, rhs, name.as_ptr())
    }
}