Remove the old files
This commit is contained in:
parent
35efa78a56
commit
48ae533f33
@ -1,455 +0,0 @@
|
||||
use std::ffi::CString;
|
||||
use std::marker::PhantomData;
|
||||
use std::net::Incoming;
|
||||
use std::ptr::null_mut;
|
||||
|
||||
use llvm_sys::analysis::LLVMVerifyModule;
|
||||
use llvm_sys::target::{
|
||||
LLVM_InitializeAllAsmParsers, LLVM_InitializeAllAsmPrinters, LLVM_InitializeAllTargetInfos,
|
||||
LLVM_InitializeAllTargetMCs, LLVM_InitializeAllTargets, LLVMSetModuleDataLayout,
|
||||
};
|
||||
use llvm_sys::target_machine::{
|
||||
LLVMCodeGenFileType, LLVMCreateTargetDataLayout, LLVMCreateTargetMachine,
|
||||
LLVMGetDefaultTargetTriple, LLVMGetTargetFromTriple, LLVMTargetMachineEmitToFile,
|
||||
};
|
||||
use llvm_sys::{LLVMBuilder, LLVMContext, LLVMIntPredicate, core::*, prelude::*};
|
||||
use types::{BasicType, BasicValue, FunctionType, IntegerType, Value};
|
||||
use util::{ErrorMessageHolder, from_cstring, into_cstring};
|
||||
|
||||
pub mod test;
|
||||
pub mod types;
|
||||
mod util;
|
||||
|
||||
pub enum IntPredicate {
|
||||
SLT,
|
||||
SGT,
|
||||
|
||||
ULT,
|
||||
UGT,
|
||||
}
|
||||
|
||||
impl IntPredicate {
|
||||
pub fn as_llvm(&self) -> LLVMIntPredicate {
|
||||
match *self {
|
||||
Self::SLT => LLVMIntPredicate::LLVMIntSLT,
|
||||
Self::SGT => LLVMIntPredicate::LLVMIntSGT,
|
||||
Self::ULT => LLVMIntPredicate::LLVMIntULT,
|
||||
Self::UGT => LLVMIntPredicate::LLVMIntUGT,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Context {
|
||||
pub(crate) context_ref: *mut LLVMContext,
|
||||
pub(crate) builder_ref: *mut LLVMBuilder,
|
||||
}
|
||||
|
||||
impl Context {
|
||||
pub fn new() -> Context {
|
||||
unsafe {
|
||||
// Set up a context, module and builder in that context.
|
||||
let context = LLVMContextCreate();
|
||||
let builder = LLVMCreateBuilderInContext(context);
|
||||
|
||||
Context {
|
||||
context_ref: context,
|
||||
builder_ref: builder,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn type_i1<'a>(&'a self) -> IntegerType<'a> {
|
||||
IntegerType::in_context(&self, 1)
|
||||
}
|
||||
|
||||
pub fn type_i8<'a>(&'a self) -> IntegerType<'a> {
|
||||
IntegerType::in_context(&self, 8)
|
||||
}
|
||||
|
||||
pub fn type_i16<'a>(&'a self) -> IntegerType<'a> {
|
||||
IntegerType::in_context(&self, 16)
|
||||
}
|
||||
|
||||
pub fn type_i32<'a>(&'a self) -> IntegerType<'a> {
|
||||
IntegerType::in_context(&self, 32)
|
||||
}
|
||||
|
||||
pub fn module(&self, name: &str) -> Module {
|
||||
Module::with_name(self, name)
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Context {
|
||||
fn drop(&mut self) {
|
||||
// Clean up. Values created in the context mostly get cleaned up there.
|
||||
unsafe {
|
||||
LLVMDisposeBuilder(self.builder_ref);
|
||||
LLVMContextDispose(self.context_ref);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Module<'ctx> {
|
||||
context: &'ctx Context,
|
||||
module_ref: LLVMModuleRef,
|
||||
name: CString,
|
||||
}
|
||||
|
||||
impl<'ctx> Module<'ctx> {
|
||||
fn with_name(context: &'ctx Context, name: &str) -> Module<'ctx> {
|
||||
unsafe {
|
||||
let cstring_name = into_cstring(name);
|
||||
let module_ref =
|
||||
LLVMModuleCreateWithNameInContext(cstring_name.as_ptr(), context.context_ref);
|
||||
Module {
|
||||
context,
|
||||
module_ref,
|
||||
name: cstring_name,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn add_function(&'ctx self, fn_type: FunctionType<'ctx>, name: &str) -> Function<'ctx> {
|
||||
unsafe {
|
||||
let name_cstring = into_cstring(name);
|
||||
let function_ref =
|
||||
LLVMAddFunction(self.module_ref, name_cstring.as_ptr(), fn_type.llvm_type());
|
||||
Function {
|
||||
module: self,
|
||||
fn_type,
|
||||
name: name_cstring,
|
||||
fn_ref: function_ref,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn print_to_string(&self) -> Result<String, String> {
|
||||
unsafe {
|
||||
LLVM_InitializeAllTargets();
|
||||
LLVM_InitializeAllTargetInfos();
|
||||
LLVM_InitializeAllTargetMCs();
|
||||
LLVM_InitializeAllAsmParsers();
|
||||
LLVM_InitializeAllAsmPrinters();
|
||||
|
||||
let triple = LLVMGetDefaultTargetTriple();
|
||||
|
||||
let mut target: _ = null_mut();
|
||||
let mut err = ErrorMessageHolder::null();
|
||||
LLVMGetTargetFromTriple(triple, &mut target, err.borrow_mut());
|
||||
println!("{:?}, {:?}", from_cstring(triple), target);
|
||||
err.into_result().unwrap();
|
||||
|
||||
let target_machine = LLVMCreateTargetMachine(
|
||||
target,
|
||||
triple,
|
||||
c"generic".as_ptr(),
|
||||
c"".as_ptr(),
|
||||
llvm_sys::target_machine::LLVMCodeGenOptLevel::LLVMCodeGenLevelNone,
|
||||
llvm_sys::target_machine::LLVMRelocMode::LLVMRelocDefault,
|
||||
llvm_sys::target_machine::LLVMCodeModel::LLVMCodeModelDefault,
|
||||
);
|
||||
|
||||
let data_layout = LLVMCreateTargetDataLayout(target_machine);
|
||||
LLVMSetTarget(self.module_ref, triple);
|
||||
LLVMSetModuleDataLayout(self.module_ref, data_layout);
|
||||
|
||||
let mut err = ErrorMessageHolder::null();
|
||||
LLVMVerifyModule(
|
||||
self.module_ref,
|
||||
llvm_sys::analysis::LLVMVerifierFailureAction::LLVMPrintMessageAction,
|
||||
err.borrow_mut(),
|
||||
);
|
||||
err.into_result().unwrap();
|
||||
|
||||
let mut err = ErrorMessageHolder::null();
|
||||
LLVMTargetMachineEmitToFile(
|
||||
target_machine,
|
||||
self.module_ref,
|
||||
CString::new("hello.asm").unwrap().into_raw(),
|
||||
LLVMCodeGenFileType::LLVMAssemblyFile,
|
||||
err.borrow_mut(),
|
||||
);
|
||||
err.into_result().unwrap();
|
||||
|
||||
let mut err = ErrorMessageHolder::null();
|
||||
LLVMTargetMachineEmitToFile(
|
||||
target_machine,
|
||||
self.module_ref,
|
||||
CString::new("hello.o").unwrap().into_raw(),
|
||||
LLVMCodeGenFileType::LLVMObjectFile,
|
||||
err.borrow_mut(),
|
||||
);
|
||||
err.into_result().unwrap();
|
||||
|
||||
from_cstring(LLVMPrintModuleToString(self.module_ref)).ok_or("UTF-8 error".to_owned())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Drop for Module<'a> {
|
||||
fn drop(&mut self) {
|
||||
// Clean up. Values created in the context mostly get cleaned up there.
|
||||
unsafe {
|
||||
LLVMDisposeModule(self.module_ref);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct Function<'ctx> {
|
||||
module: &'ctx Module<'ctx>,
|
||||
name: CString,
|
||||
fn_type: FunctionType<'ctx>,
|
||||
fn_ref: LLVMValueRef,
|
||||
}
|
||||
|
||||
impl<'ctx> Function<'ctx> {
|
||||
pub fn block<T: Into<String>>(&'ctx self, name: T) -> BasicBlock<'ctx> {
|
||||
BasicBlock::in_function(&self, name.into())
|
||||
}
|
||||
|
||||
pub fn get_param<T: BasicValue<'ctx>>(
|
||||
&'ctx self,
|
||||
nth: usize,
|
||||
param_type: T::BaseType,
|
||||
) -> Result<T, String> {
|
||||
if let Some(actual_type) = self.fn_type.param_types.iter().nth(nth) {
|
||||
if param_type.llvm_type() != *actual_type {
|
||||
return Err(String::from("Wrong type"));
|
||||
}
|
||||
} else {
|
||||
return Err(String::from("nth too large"));
|
||||
}
|
||||
unsafe { Ok(T::from_llvm(LLVMGetParam(self.fn_ref, nth as u32))) }
|
||||
}
|
||||
}
|
||||
|
||||
pub struct BasicBlock<'ctx> {
|
||||
function: &'ctx Function<'ctx>,
|
||||
builder_ref: LLVMBuilderRef,
|
||||
name: String,
|
||||
blockref: LLVMBasicBlockRef,
|
||||
inserted: bool,
|
||||
}
|
||||
|
||||
impl<'ctx> BasicBlock<'ctx> {
|
||||
fn in_function(function: &'ctx Function<'ctx>, name: String) -> BasicBlock<'ctx> {
|
||||
unsafe {
|
||||
let block_name = into_cstring(name.clone());
|
||||
let block_ref = LLVMCreateBasicBlockInContext(
|
||||
function.module.context.context_ref,
|
||||
block_name.as_ptr(),
|
||||
);
|
||||
LLVMAppendExistingBasicBlock(function.fn_ref, block_ref);
|
||||
BasicBlock {
|
||||
function: function,
|
||||
builder_ref: function.module.context.builder_ref,
|
||||
name,
|
||||
blockref: block_ref,
|
||||
inserted: false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn integer_compare<T: BasicValue<'ctx>>(
|
||||
&self,
|
||||
lhs: &T,
|
||||
rhs: &T,
|
||||
comparison: &IntPredicate,
|
||||
name: &str,
|
||||
) -> Result<T, ()> {
|
||||
unsafe {
|
||||
LLVMPositionBuilderAtEnd(self.builder_ref, self.blockref);
|
||||
let value = LLVMBuildICmp(
|
||||
self.builder_ref,
|
||||
comparison.as_llvm(),
|
||||
lhs.llvm_value(),
|
||||
rhs.llvm_value(),
|
||||
into_cstring(name).as_ptr(),
|
||||
);
|
||||
|
||||
Ok(T::from_llvm(value))
|
||||
}
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn call<T: BasicValue<'ctx>>(
|
||||
&self,
|
||||
callee: &Function<'ctx>,
|
||||
params: Vec<Value<'ctx>>,
|
||||
name: &str,
|
||||
) -> Result<T, ()> {
|
||||
if params.len() != callee.fn_type.param_types.len() {
|
||||
return Err(()); // TODO invalid amount of parameters
|
||||
}
|
||||
for (t1, t2) in callee.fn_type.param_types.iter().zip(¶ms) {
|
||||
if t1 != &t2.llvm_type() {
|
||||
return Err(()); // TODO wrong types in parameters
|
||||
}
|
||||
}
|
||||
if !T::BaseType::is_type(callee.fn_type.return_type) {
|
||||
return Err(()); // TODO wrong return type
|
||||
}
|
||||
unsafe {
|
||||
let mut param_list: Vec<LLVMValueRef> = params.iter().map(|p| p.llvm_value()).collect();
|
||||
LLVMPositionBuilderAtEnd(self.builder_ref, self.blockref);
|
||||
let ret_val = LLVMBuildCall2(
|
||||
self.builder_ref,
|
||||
callee.fn_type.llvm_type(),
|
||||
callee.fn_ref,
|
||||
param_list.as_mut_ptr(),
|
||||
param_list.len() as u32,
|
||||
into_cstring(name).as_ptr(),
|
||||
);
|
||||
Ok(T::from_llvm(ret_val))
|
||||
}
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn add<T: BasicValue<'ctx>>(&self, lhs: &T, rhs: &T, name: &str) -> Result<T, ()> {
|
||||
if lhs.llvm_type() != rhs.llvm_type() {
|
||||
return Err(()); // TODO error
|
||||
}
|
||||
unsafe {
|
||||
LLVMPositionBuilderAtEnd(self.builder_ref, self.blockref);
|
||||
let add_value_ref = LLVMBuildAdd(
|
||||
self.builder_ref,
|
||||
lhs.llvm_value(),
|
||||
rhs.llvm_value(),
|
||||
into_cstring(name).as_ptr(),
|
||||
);
|
||||
Ok(T::from_llvm(add_value_ref))
|
||||
}
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn sub<T: BasicValue<'ctx>>(&self, lhs: &T, rhs: &T, name: &str) -> Result<T, ()> {
|
||||
dbg!(lhs, rhs);
|
||||
dbg!(lhs.llvm_type(), rhs.llvm_type());
|
||||
if lhs.llvm_type() != rhs.llvm_type() {
|
||||
return Err(()); // TODO error
|
||||
}
|
||||
unsafe {
|
||||
LLVMPositionBuilderAtEnd(self.builder_ref, self.blockref);
|
||||
let add_value_ref = LLVMBuildSub(
|
||||
self.builder_ref,
|
||||
lhs.llvm_value(),
|
||||
rhs.llvm_value(),
|
||||
into_cstring(name).as_ptr(),
|
||||
);
|
||||
Ok(T::from_llvm(add_value_ref))
|
||||
}
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn phi<PhiValue: BasicValue<'ctx>>(
|
||||
&self,
|
||||
phi_type: &PhiValue::BaseType,
|
||||
name: &str,
|
||||
) -> Result<PhiBuilder<'ctx, PhiValue>, ()> {
|
||||
unsafe {
|
||||
LLVMPositionBuilderAtEnd(self.builder_ref, self.blockref);
|
||||
let phi_node = LLVMBuildPhi(
|
||||
self.builder_ref,
|
||||
phi_type.llvm_type(),
|
||||
into_cstring(name).as_ptr(),
|
||||
);
|
||||
Ok(PhiBuilder::new(phi_node))
|
||||
}
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn br(&mut self, into: &BasicBlock<'ctx>) -> Result<(), ()> {
|
||||
self.try_insert()?;
|
||||
unsafe {
|
||||
LLVMPositionBuilderAtEnd(self.builder_ref, self.blockref);
|
||||
LLVMBuildBr(self.builder_ref, into.blockref);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn conditional_br<T: BasicValue<'ctx>>(
|
||||
&mut self,
|
||||
condition: &T,
|
||||
lhs: &BasicBlock<'ctx>,
|
||||
rhs: &BasicBlock<'ctx>,
|
||||
) -> Result<(), ()> {
|
||||
self.try_insert()?;
|
||||
unsafe {
|
||||
LLVMPositionBuilderAtEnd(self.builder_ref, self.blockref);
|
||||
LLVMBuildCondBr(
|
||||
self.builder_ref,
|
||||
condition.llvm_value(),
|
||||
lhs.blockref,
|
||||
rhs.blockref,
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn ret<T: BasicValue<'ctx>>(&mut self, return_value: &T) -> Result<(), ()> {
|
||||
if self.function.fn_type.return_type != return_value.llvm_type() {
|
||||
return Err(());
|
||||
}
|
||||
self.try_insert()?;
|
||||
|
||||
unsafe {
|
||||
LLVMPositionBuilderAtEnd(self.builder_ref, self.blockref);
|
||||
LLVMBuildRet(self.builder_ref, return_value.llvm_value());
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn try_insert(&mut self) -> Result<(), ()> {
|
||||
if self.inserted {
|
||||
return Err(());
|
||||
}
|
||||
self.inserted = true;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl<'ctx> Drop for BasicBlock<'ctx> {
|
||||
fn drop(&mut self) {
|
||||
if !self.inserted {
|
||||
unsafe {
|
||||
LLVMDeleteBasicBlock(self.blockref);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct PhiBuilder<'ctx, PhiValue: BasicValue<'ctx>> {
|
||||
phi_node: LLVMValueRef,
|
||||
phantom: PhantomData<&'ctx PhiValue>,
|
||||
}
|
||||
|
||||
impl<'ctx, PhiValue: BasicValue<'ctx>> PhiBuilder<'ctx, PhiValue> {
|
||||
fn new(phi_node: LLVMValueRef) -> PhiBuilder<'ctx, PhiValue> {
|
||||
PhiBuilder {
|
||||
phi_node,
|
||||
phantom: PhantomData,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn add_incoming(&self, value: &PhiValue, block: &BasicBlock<'ctx>) -> &Self {
|
||||
let mut values = vec![value.llvm_value()];
|
||||
let mut blocks = vec![block.blockref];
|
||||
unsafe {
|
||||
LLVMAddIncoming(
|
||||
self.phi_node,
|
||||
values.as_mut_ptr(),
|
||||
blocks.as_mut_ptr(),
|
||||
values.len() as u32,
|
||||
);
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
pub fn build(&self) -> PhiValue {
|
||||
unsafe { PhiValue::from_llvm(self.phi_node) }
|
||||
}
|
||||
}
|
||||
@ -1,336 +0,0 @@
|
||||
use std::{any::Any, marker::PhantomData, ptr::null_mut};
|
||||
|
||||
use llvm_sys::{
|
||||
LLVMTypeKind,
|
||||
core::*,
|
||||
prelude::{LLVMTypeRef, LLVMValueRef},
|
||||
};
|
||||
|
||||
use crate::{BasicBlock, Context, PhiBuilder};
|
||||
|
||||
pub trait BasicType<'ctx> {
|
||||
fn llvm_type(&self) -> LLVMTypeRef;
|
||||
|
||||
fn is_type(llvm_type: LLVMTypeRef) -> bool
|
||||
where
|
||||
Self: Sized;
|
||||
|
||||
unsafe fn from_llvm(context: &'ctx Context, llvm_type: LLVMTypeRef) -> Self
|
||||
where
|
||||
Self: Sized;
|
||||
|
||||
fn function_type(&self, params: Vec<TypeEnum>) -> FunctionType<'ctx> {
|
||||
unsafe {
|
||||
let mut typerefs: Vec<LLVMTypeRef> = params.iter().map(|b| b.llvm_type()).collect();
|
||||
let param_ptr = typerefs.as_mut_ptr();
|
||||
let param_len = typerefs.len();
|
||||
FunctionType {
|
||||
phantom: PhantomData,
|
||||
return_type: self.llvm_type(),
|
||||
param_types: typerefs,
|
||||
type_ref: LLVMFunctionType(self.llvm_type(), param_ptr, param_len as u32, 0),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn array_type(&'ctx self, length: u32) -> ArrayType<'ctx>
|
||||
where
|
||||
Self: Sized,
|
||||
{
|
||||
ArrayType {
|
||||
phantom: PhantomData,
|
||||
element_type: self.llvm_type(),
|
||||
length,
|
||||
type_ref: unsafe { LLVMArrayType(self.llvm_type(), length) },
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'ctx> PartialEq for &dyn BasicType<'ctx> {
|
||||
fn eq(&self, other: &Self) -> bool {
|
||||
self.llvm_type() == other.llvm_type()
|
||||
}
|
||||
}
|
||||
|
||||
impl<'ctx> PartialEq<LLVMTypeRef> for &dyn BasicType<'ctx> {
|
||||
fn eq(&self, other: &LLVMTypeRef) -> bool {
|
||||
self.llvm_type() == *other
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
pub struct IntegerType<'ctx> {
|
||||
context: &'ctx Context,
|
||||
type_ref: LLVMTypeRef,
|
||||
}
|
||||
|
||||
impl<'ctx> BasicType<'ctx> for IntegerType<'ctx> {
|
||||
fn llvm_type(&self) -> LLVMTypeRef {
|
||||
self.type_ref
|
||||
}
|
||||
|
||||
unsafe fn from_llvm(context: &'ctx Context, llvm_type: LLVMTypeRef) -> Self
|
||||
where
|
||||
Self: Sized,
|
||||
{
|
||||
IntegerType {
|
||||
context,
|
||||
type_ref: llvm_type,
|
||||
}
|
||||
}
|
||||
|
||||
fn is_type(llvm_type: LLVMTypeRef) -> bool {
|
||||
unsafe { LLVMGetTypeKind(llvm_type) == LLVMTypeKind::LLVMIntegerTypeKind }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'ctx> IntegerType<'ctx> {
|
||||
pub(crate) fn in_context(context: &Context, width: u32) -> IntegerType {
|
||||
let type_ref = unsafe {
|
||||
match width {
|
||||
128 => LLVMInt128TypeInContext(context.context_ref),
|
||||
64 => LLVMInt64TypeInContext(context.context_ref),
|
||||
32 => LLVMInt32TypeInContext(context.context_ref),
|
||||
16 => LLVMInt16TypeInContext(context.context_ref),
|
||||
8 => LLVMInt8TypeInContext(context.context_ref),
|
||||
1 => LLVMInt1TypeInContext(context.context_ref),
|
||||
_ => LLVMIntTypeInContext(context.context_ref, width),
|
||||
}
|
||||
};
|
||||
IntegerType { context, type_ref }
|
||||
}
|
||||
|
||||
pub fn from_signed(&self, value: i64) -> IntegerValue<'ctx> {
|
||||
self.from_const(value as u64, true)
|
||||
}
|
||||
|
||||
pub fn from_unsigned(&self, value: i64) -> IntegerValue<'ctx> {
|
||||
self.from_const(value as u64, false)
|
||||
}
|
||||
|
||||
fn from_const(&self, value: u64, sign: bool) -> IntegerValue<'ctx> {
|
||||
unsafe {
|
||||
IntegerValue::from_llvm(LLVMConstInt(
|
||||
self.type_ref,
|
||||
value,
|
||||
match sign {
|
||||
true => 1,
|
||||
false => 0,
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct FunctionType<'ctx> {
|
||||
phantom: PhantomData<&'ctx ()>,
|
||||
pub(crate) return_type: LLVMTypeRef,
|
||||
pub(crate) param_types: Vec<LLVMTypeRef>,
|
||||
type_ref: LLVMTypeRef,
|
||||
}
|
||||
|
||||
impl<'ctx> BasicType<'ctx> for FunctionType<'ctx> {
|
||||
fn llvm_type(&self) -> LLVMTypeRef {
|
||||
self.type_ref
|
||||
}
|
||||
|
||||
unsafe fn from_llvm(_context: &'ctx Context, fn_type: LLVMTypeRef) -> Self
|
||||
where
|
||||
Self: Sized,
|
||||
{
|
||||
unsafe {
|
||||
let param_count = LLVMCountParamTypes(fn_type);
|
||||
let param_types_ptr: *mut LLVMTypeRef = null_mut();
|
||||
LLVMGetParamTypes(fn_type, param_types_ptr);
|
||||
let param_types: Vec<LLVMTypeRef> =
|
||||
std::slice::from_raw_parts(param_types_ptr, param_count as usize)
|
||||
.iter()
|
||||
.map(|t| *t)
|
||||
.collect();
|
||||
FunctionType {
|
||||
phantom: PhantomData,
|
||||
return_type: LLVMGetReturnType(fn_type),
|
||||
param_types,
|
||||
type_ref: fn_type,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn is_type(llvm_type: LLVMTypeRef) -> bool {
|
||||
unsafe { LLVMGetTypeKind(llvm_type) == LLVMTypeKind::LLVMFunctionTypeKind }
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
pub struct ArrayType<'ctx> {
|
||||
phantom: PhantomData<&'ctx ()>,
|
||||
element_type: LLVMTypeRef,
|
||||
length: u32,
|
||||
type_ref: LLVMTypeRef,
|
||||
}
|
||||
|
||||
impl<'ctx> BasicType<'ctx> for ArrayType<'ctx> {
|
||||
fn llvm_type(&self) -> LLVMTypeRef {
|
||||
self.type_ref
|
||||
}
|
||||
|
||||
unsafe fn from_llvm(context: &'ctx Context, llvm_type: LLVMTypeRef) -> Self
|
||||
where
|
||||
Self: Sized,
|
||||
{
|
||||
unsafe {
|
||||
let length = LLVMGetArrayLength(llvm_type);
|
||||
todo!()
|
||||
}
|
||||
}
|
||||
|
||||
fn is_type(llvm_type: LLVMTypeRef) -> bool {
|
||||
unsafe { LLVMGetTypeKind(llvm_type) == LLVMTypeKind::LLVMArrayTypeKind }
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub enum TypeEnum<'ctx> {
|
||||
Integer(IntegerType<'ctx>),
|
||||
Array(ArrayType<'ctx>),
|
||||
Function(FunctionType<'ctx>),
|
||||
}
|
||||
|
||||
impl<'ctx> From<IntegerType<'ctx>> for TypeEnum<'ctx> {
|
||||
fn from(int: IntegerType<'ctx>) -> Self {
|
||||
TypeEnum::Integer(int)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'ctx> From<ArrayType<'ctx>> for TypeEnum<'ctx> {
|
||||
fn from(arr: ArrayType<'ctx>) -> Self {
|
||||
TypeEnum::Array(arr)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'ctx> From<FunctionType<'ctx>> for TypeEnum<'ctx> {
|
||||
fn from(func: FunctionType<'ctx>) -> Self {
|
||||
TypeEnum::Function(func)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'ctx> TypeEnum<'ctx> {
|
||||
fn inner_basic(&'ctx self) -> &'ctx dyn BasicType<'ctx> {
|
||||
match self {
|
||||
TypeEnum::Integer(integer_type) => integer_type,
|
||||
TypeEnum::Array(array_type) => array_type,
|
||||
TypeEnum::Function(function_type) => function_type,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'ctx> BasicType<'ctx> for TypeEnum<'ctx> {
|
||||
fn llvm_type(&self) -> LLVMTypeRef {
|
||||
self.inner_basic().llvm_type()
|
||||
}
|
||||
|
||||
fn is_type(llvm_type: LLVMTypeRef) -> bool
|
||||
where
|
||||
Self: Sized,
|
||||
{
|
||||
true
|
||||
}
|
||||
|
||||
unsafe fn from_llvm(context: &'ctx Context, llvm_type: LLVMTypeRef) -> Self
|
||||
where
|
||||
Self: Sized,
|
||||
{
|
||||
unsafe {
|
||||
match LLVMGetTypeKind(llvm_type) {
|
||||
LLVMTypeKind::LLVMIntegerTypeKind => {
|
||||
TypeEnum::Integer(IntegerType::from_llvm(context, llvm_type))
|
||||
}
|
||||
LLVMTypeKind::LLVMArrayTypeKind => {
|
||||
TypeEnum::Array(ArrayType::from_llvm(context, llvm_type))
|
||||
}
|
||||
LLVMTypeKind::LLVMFunctionTypeKind => {
|
||||
TypeEnum::Function(FunctionType::from_llvm(context, llvm_type))
|
||||
}
|
||||
_ => todo!(),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub trait BasicValue<'ctx>: std::fmt::Debug {
|
||||
type BaseType: BasicType<'ctx>;
|
||||
unsafe fn from_llvm(value: LLVMValueRef) -> Self
|
||||
where
|
||||
Self: Sized;
|
||||
fn llvm_value(&self) -> LLVMValueRef;
|
||||
fn llvm_type(&self) -> LLVMTypeRef;
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct IntegerValue<'ctx> {
|
||||
phantom: PhantomData<&'ctx ()>,
|
||||
pub(crate) value_ref: LLVMValueRef,
|
||||
}
|
||||
|
||||
impl<'ctx> BasicValue<'ctx> for IntegerValue<'ctx> {
|
||||
type BaseType = IntegerType<'ctx>;
|
||||
|
||||
unsafe fn from_llvm(value: LLVMValueRef) -> Self {
|
||||
IntegerValue {
|
||||
phantom: PhantomData,
|
||||
value_ref: value,
|
||||
}
|
||||
}
|
||||
|
||||
fn llvm_value(&self) -> LLVMValueRef {
|
||||
self.value_ref
|
||||
}
|
||||
|
||||
fn llvm_type(&self) -> LLVMTypeRef {
|
||||
unsafe { LLVMTypeOf(self.value_ref) }
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub enum Value<'ctx> {
|
||||
Integer(IntegerValue<'ctx>),
|
||||
}
|
||||
|
||||
impl<'ctx> BasicValue<'ctx> for Value<'ctx> {
|
||||
type BaseType = TypeEnum<'ctx>;
|
||||
|
||||
unsafe fn from_llvm(value: LLVMValueRef) -> Self
|
||||
where
|
||||
Self: Sized,
|
||||
{
|
||||
unsafe {
|
||||
use LLVMTypeKind::*;
|
||||
|
||||
let llvm_type = LLVMTypeOf(value);
|
||||
let type_kind = LLVMGetTypeKind(llvm_type);
|
||||
match type_kind {
|
||||
LLVMIntegerTypeKind => Value::Integer(IntegerValue::from_llvm(value)),
|
||||
_ => panic!("asd"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn llvm_value(&self) -> LLVMValueRef {
|
||||
match self {
|
||||
Self::Integer(i) => i.llvm_value(),
|
||||
}
|
||||
}
|
||||
|
||||
fn llvm_type(&self) -> LLVMTypeRef {
|
||||
match self {
|
||||
Self::Integer(i) => i.llvm_type(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'ctx> From<IntegerValue<'ctx>> for Value<'ctx> {
|
||||
fn from(value: IntegerValue<'ctx>) -> Self {
|
||||
Value::Integer(value)
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user