Compare commits
7 Commits
f7fbc629aa
...
eb8faaece6
Author | SHA1 | Date |
---|---|---|
David Mak | eb8faaece6 | |
David Mak | 2c4bf3ce59 | |
David Mak | e980f19c93 | |
David Mak | cfbc37c1ed | |
David Mak | 50264e8750 | |
David Mak | 1b77e62901 | |
David Mak | fd44ee6887 |
|
@ -21,7 +21,7 @@ fn main() {
|
||||||
match env::var("PROFILE").as_deref() {
|
match env::var("PROFILE").as_deref() {
|
||||||
Ok("debug") => "-O0",
|
Ok("debug") => "-O0",
|
||||||
Ok("release") => "-O3",
|
Ok("release") => "-O3",
|
||||||
flavor => panic!("Unknown or missing build flavor {:?}", flavor),
|
flavor => panic!("Unknown or missing build flavor {flavor:?}"),
|
||||||
},
|
},
|
||||||
"-emit-llvm",
|
"-emit-llvm",
|
||||||
"-S",
|
"-S",
|
||||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -2,7 +2,14 @@ use std::{collections::HashMap, convert::TryInto, iter::once, iter::zip};
|
||||||
|
|
||||||
use crate::{
|
use crate::{
|
||||||
codegen::{
|
codegen::{
|
||||||
classes::{ListValue, NDArrayValue, RangeValue},
|
classes::{
|
||||||
|
ArrayLikeIndexer,
|
||||||
|
ArrayLikeValue,
|
||||||
|
ListValue,
|
||||||
|
NDArrayValue,
|
||||||
|
RangeValue,
|
||||||
|
UntypedArrayLikeAccessor,
|
||||||
|
},
|
||||||
concrete_type::{ConcreteFuncArg, ConcreteTypeEnum, ConcreteTypeStore},
|
concrete_type::{ConcreteFuncArg, ConcreteTypeEnum, ConcreteTypeStore},
|
||||||
gen_in_range_check,
|
gen_in_range_check,
|
||||||
get_llvm_type,
|
get_llvm_type,
|
||||||
|
@ -103,9 +110,9 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
|
||||||
index
|
index
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn gen_symbol_val(
|
pub fn gen_symbol_val<G: CodeGenerator + ?Sized>(
|
||||||
&mut self,
|
&mut self,
|
||||||
generator: &mut dyn CodeGenerator,
|
generator: &mut G,
|
||||||
val: &SymbolValue,
|
val: &SymbolValue,
|
||||||
ty: Type,
|
ty: Type,
|
||||||
) -> BasicValueEnum<'ctx> {
|
) -> BasicValueEnum<'ctx> {
|
||||||
|
@ -174,9 +181,9 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
|
||||||
}
|
}
|
||||||
|
|
||||||
/// See [`get_llvm_type`].
|
/// See [`get_llvm_type`].
|
||||||
pub fn get_llvm_type(
|
pub fn get_llvm_type<G: CodeGenerator + ?Sized>(
|
||||||
&mut self,
|
&mut self,
|
||||||
generator: &mut dyn CodeGenerator,
|
generator: &mut G,
|
||||||
ty: Type,
|
ty: Type,
|
||||||
) -> BasicTypeEnum<'ctx> {
|
) -> BasicTypeEnum<'ctx> {
|
||||||
get_llvm_type(
|
get_llvm_type(
|
||||||
|
@ -191,9 +198,9 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
|
||||||
}
|
}
|
||||||
|
|
||||||
/// See [`get_llvm_abi_type`].
|
/// See [`get_llvm_abi_type`].
|
||||||
pub fn get_llvm_abi_type(
|
pub fn get_llvm_abi_type<G: CodeGenerator + ?Sized>(
|
||||||
&mut self,
|
&mut self,
|
||||||
generator: &mut dyn CodeGenerator,
|
generator: &mut G,
|
||||||
ty: Type,
|
ty: Type,
|
||||||
) -> BasicTypeEnum<'ctx> {
|
) -> BasicTypeEnum<'ctx> {
|
||||||
get_llvm_abi_type(
|
get_llvm_abi_type(
|
||||||
|
@ -209,9 +216,9 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Generates an LLVM variable for a [constant value][value] with a given [type][ty].
|
/// Generates an LLVM variable for a [constant value][value] with a given [type][ty].
|
||||||
pub fn gen_const(
|
pub fn gen_const<G: CodeGenerator + ?Sized>(
|
||||||
&mut self,
|
&mut self,
|
||||||
generator: &mut dyn CodeGenerator,
|
generator: &mut G,
|
||||||
value: &Constant,
|
value: &Constant,
|
||||||
ty: Type,
|
ty: Type,
|
||||||
) -> Option<BasicValueEnum<'ctx>> {
|
) -> Option<BasicValueEnum<'ctx>> {
|
||||||
|
@ -291,9 +298,9 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Generates a binary operation `op` between two integral operands `lhs` and `rhs`.
|
/// Generates a binary operation `op` between two integral operands `lhs` and `rhs`.
|
||||||
pub fn gen_int_ops(
|
pub fn gen_int_ops<G: CodeGenerator + ?Sized>(
|
||||||
&mut self,
|
&mut self,
|
||||||
generator: &mut dyn CodeGenerator,
|
generator: &mut G,
|
||||||
op: &Operator,
|
op: &Operator,
|
||||||
lhs: BasicValueEnum<'ctx>,
|
lhs: BasicValueEnum<'ctx>,
|
||||||
rhs: BasicValueEnum<'ctx>,
|
rhs: BasicValueEnum<'ctx>,
|
||||||
|
@ -492,17 +499,21 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Helper function for generating a LLVM variable storing a [String].
|
/// Helper function for generating a LLVM variable storing a [String].
|
||||||
pub fn gen_string<S: Into<String>>(
|
pub fn gen_string<G, S>(
|
||||||
&mut self,
|
&mut self,
|
||||||
generator: &mut dyn CodeGenerator,
|
generator: &mut G,
|
||||||
s: S,
|
s: S,
|
||||||
) -> BasicValueEnum<'ctx> {
|
) -> BasicValueEnum<'ctx>
|
||||||
|
where
|
||||||
|
G: CodeGenerator + ?Sized,
|
||||||
|
S: Into<String>,
|
||||||
|
{
|
||||||
self.gen_const(generator, &Constant::Str(s.into()), self.primitives.str).unwrap()
|
self.gen_const(generator, &Constant::Str(s.into()), self.primitives.str).unwrap()
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn raise_exn(
|
pub fn raise_exn<G: CodeGenerator + ?Sized>(
|
||||||
&mut self,
|
&mut self,
|
||||||
generator: &mut dyn CodeGenerator,
|
generator: &mut G,
|
||||||
name: &str,
|
name: &str,
|
||||||
msg: BasicValueEnum<'ctx>,
|
msg: BasicValueEnum<'ctx>,
|
||||||
params: [Option<IntValue<'ctx>>; 3],
|
params: [Option<IntValue<'ctx>>; 3],
|
||||||
|
@ -546,9 +557,9 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
|
||||||
gen_raise(generator, self, Some(&zelf.into()), loc);
|
gen_raise(generator, self, Some(&zelf.into()), loc);
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn make_assert(
|
pub fn make_assert<G: CodeGenerator + ?Sized>(
|
||||||
&mut self,
|
&mut self,
|
||||||
generator: &mut dyn CodeGenerator,
|
generator: &mut G,
|
||||||
cond: IntValue<'ctx>,
|
cond: IntValue<'ctx>,
|
||||||
err_name: &str,
|
err_name: &str,
|
||||||
err_msg: &str,
|
err_msg: &str,
|
||||||
|
@ -559,9 +570,9 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
|
||||||
self.make_assert_impl(generator, cond, err_name, err_msg, params, loc);
|
self.make_assert_impl(generator, cond, err_name, err_msg, params, loc);
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn make_assert_impl(
|
pub fn make_assert_impl<G: CodeGenerator + ?Sized>(
|
||||||
&mut self,
|
&mut self,
|
||||||
generator: &mut dyn CodeGenerator,
|
generator: &mut G,
|
||||||
cond: IntValue<'ctx>,
|
cond: IntValue<'ctx>,
|
||||||
err_name: &str,
|
err_name: &str,
|
||||||
err_msg: BasicValueEnum<'ctx>,
|
err_msg: BasicValueEnum<'ctx>,
|
||||||
|
@ -878,7 +889,7 @@ pub fn destructure_range<'ctx>(
|
||||||
/// Returns an instance of [`PointerValue`] pointing to the List structure. The List structure is
|
/// Returns an instance of [`PointerValue`] pointing to the List structure. The List structure is
|
||||||
/// defined as `type { ty*, size_t }` in LLVM, where the first element stores the pointer to the
|
/// defined as `type { ty*, size_t }` in LLVM, where the first element stores the pointer to the
|
||||||
/// data, and the second element stores the size of the List.
|
/// data, and the second element stores the size of the List.
|
||||||
pub fn allocate_list<'ctx, G: CodeGenerator>(
|
pub fn allocate_list<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
generator: &mut G,
|
generator: &mut G,
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
ty: BasicTypeEnum<'ctx>,
|
ty: BasicTypeEnum<'ctx>,
|
||||||
|
@ -978,7 +989,7 @@ pub fn gen_comprehension<'ctx, G: CodeGenerator>(
|
||||||
list_alloc_size.into_int_value(),
|
list_alloc_size.into_int_value(),
|
||||||
Some("listcomp.addr")
|
Some("listcomp.addr")
|
||||||
);
|
);
|
||||||
list_content = list.data().as_ptr_value(ctx);
|
list_content = list.data().base_ptr(ctx, generator);
|
||||||
|
|
||||||
let i = generator.gen_store_target(ctx, target, Some("i.addr"))?.unwrap();
|
let i = generator.gen_store_target(ctx, target, Some("i.addr"))?.unwrap();
|
||||||
ctx.builder
|
ctx.builder
|
||||||
|
@ -1011,7 +1022,7 @@ pub fn gen_comprehension<'ctx, G: CodeGenerator>(
|
||||||
)
|
)
|
||||||
.into_int_value();
|
.into_int_value();
|
||||||
list = allocate_list(generator, ctx, elem_ty, length, Some("listcomp"));
|
list = allocate_list(generator, ctx, elem_ty, length, Some("listcomp"));
|
||||||
list_content = list.data().as_ptr_value(ctx);
|
list_content = list.data().base_ptr(ctx, generator);
|
||||||
let counter = generator.gen_var_alloc(ctx, size_t.into(), Some("counter.addr"))?;
|
let counter = generator.gen_var_alloc(ctx, size_t.into(), Some("counter.addr"))?;
|
||||||
// counter = -1
|
// counter = -1
|
||||||
ctx.builder.build_store(counter, size_t.const_int(u64::MAX, true)).unwrap();
|
ctx.builder.build_store(counter, size_t.const_int(u64::MAX, true)).unwrap();
|
||||||
|
@ -1256,7 +1267,7 @@ fn gen_ndarray_subscript_expr<'ctx, G: CodeGenerator>(
|
||||||
};
|
};
|
||||||
|
|
||||||
Ok(Some(v.data()
|
Ok(Some(v.data()
|
||||||
.get_const(
|
.get(
|
||||||
ctx,
|
ctx,
|
||||||
generator,
|
generator,
|
||||||
ctx.ctx.i32_type().const_array(&[index]),
|
ctx.ctx.i32_type().const_array(&[index]),
|
||||||
|
@ -1300,15 +1311,17 @@ fn gen_ndarray_subscript_expr<'ctx, G: CodeGenerator>(
|
||||||
ndarray.create_dim_sizes(ctx, llvm_usize, ndarray_num_dims);
|
ndarray.create_dim_sizes(ctx, llvm_usize, ndarray_num_dims);
|
||||||
|
|
||||||
let ndarray_num_dims = ndarray.load_ndims(ctx);
|
let ndarray_num_dims = ndarray.load_ndims(ctx);
|
||||||
let v_dims_src_ptr = v.dim_sizes().ptr_offset(
|
let v_dims_src_ptr = unsafe {
|
||||||
ctx,
|
v.dim_sizes().ptr_offset_unchecked(
|
||||||
generator,
|
ctx,
|
||||||
llvm_usize.const_int(1, false),
|
generator,
|
||||||
None,
|
llvm_usize.const_int(1, false),
|
||||||
);
|
None,
|
||||||
|
)
|
||||||
|
};
|
||||||
call_memcpy_generic(
|
call_memcpy_generic(
|
||||||
ctx,
|
ctx,
|
||||||
ndarray.dim_sizes().as_ptr_value(ctx),
|
ndarray.dim_sizes().base_ptr(ctx, generator),
|
||||||
v_dims_src_ptr,
|
v_dims_src_ptr,
|
||||||
ctx.builder
|
ctx.builder
|
||||||
.build_int_mul(ndarray_num_dims, llvm_usize.size_of(), "")
|
.build_int_mul(ndarray_num_dims, llvm_usize.size_of(), "")
|
||||||
|
@ -1320,12 +1333,11 @@ fn gen_ndarray_subscript_expr<'ctx, G: CodeGenerator>(
|
||||||
let ndarray_num_elems = call_ndarray_calc_size(
|
let ndarray_num_elems = call_ndarray_calc_size(
|
||||||
generator,
|
generator,
|
||||||
ctx,
|
ctx,
|
||||||
ndarray.load_ndims(ctx),
|
&ndarray.dim_sizes().as_slice_value(ctx, generator),
|
||||||
ndarray.dim_sizes().as_ptr_value(ctx),
|
|
||||||
);
|
);
|
||||||
ndarray.create_data(ctx, llvm_ndarray_data_t, ndarray_num_elems);
|
ndarray.create_data(ctx, llvm_ndarray_data_t, ndarray_num_elems);
|
||||||
|
|
||||||
let v_data_src_ptr = v.data().ptr_offset_const(
|
let v_data_src_ptr = v.data().ptr_offset(
|
||||||
ctx,
|
ctx,
|
||||||
generator,
|
generator,
|
||||||
ctx.ctx.i32_type().const_array(&[index]),
|
ctx.ctx.i32_type().const_array(&[index]),
|
||||||
|
@ -1333,7 +1345,7 @@ fn gen_ndarray_subscript_expr<'ctx, G: CodeGenerator>(
|
||||||
);
|
);
|
||||||
call_memcpy_generic(
|
call_memcpy_generic(
|
||||||
ctx,
|
ctx,
|
||||||
ndarray.data().as_ptr_value(ctx),
|
ndarray.data().base_ptr(ctx, generator),
|
||||||
v_data_src_ptr,
|
v_data_src_ptr,
|
||||||
ctx.builder
|
ctx.builder
|
||||||
.build_int_mul(ndarray_num_elems, llvm_ndarray_data_t.size_of().unwrap(), "")
|
.build_int_mul(ndarray_num_elems, llvm_ndarray_data_t.size_of().unwrap(), "")
|
||||||
|
|
|
@ -1,5 +1,5 @@
|
||||||
use crate::{
|
use crate::{
|
||||||
codegen::{expr::*, stmt::*, bool_to_i1, bool_to_i8, CodeGenContext},
|
codegen::{classes::ArraySliceValue, expr::*, stmt::*, bool_to_i1, bool_to_i8, CodeGenContext},
|
||||||
symbol_resolver::ValueEnum,
|
symbol_resolver::ValueEnum,
|
||||||
toplevel::{DefinitionId, TopLevelDef},
|
toplevel::{DefinitionId, TopLevelDef},
|
||||||
typecheck::typedef::{FunSignature, Type},
|
typecheck::typedef::{FunSignature, Type},
|
||||||
|
@ -99,8 +99,8 @@ pub trait CodeGenerator {
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
ty: BasicTypeEnum<'ctx>,
|
ty: BasicTypeEnum<'ctx>,
|
||||||
size: IntValue<'ctx>,
|
size: IntValue<'ctx>,
|
||||||
name: Option<&str>,
|
name: Option<&'ctx str>,
|
||||||
) -> Result<PointerValue<'ctx>, String> {
|
) -> Result<ArraySliceValue<'ctx>, String> {
|
||||||
gen_array_var(ctx, ty, size, name)
|
gen_array_var(ctx, ty, size, name)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -1,7 +1,7 @@
|
||||||
use crate::typecheck::typedef::Type;
|
use crate::typecheck::typedef::Type;
|
||||||
|
|
||||||
use super::{
|
use super::{
|
||||||
classes::{ListValue, NDArrayValue},
|
classes::{ArrayLikeIndexer, ArrayLikeValue, ListValue, NDArrayValue, UntypedArrayLikeMutator},
|
||||||
CodeGenContext,
|
CodeGenContext,
|
||||||
CodeGenerator,
|
CodeGenerator,
|
||||||
};
|
};
|
||||||
|
@ -39,8 +39,8 @@ pub fn load_irrt(ctx: &Context) -> Module {
|
||||||
|
|
||||||
// repeated squaring method adapted from GNU Scientific Library:
|
// repeated squaring method adapted from GNU Scientific Library:
|
||||||
// https://git.savannah.gnu.org/cgit/gsl.git/tree/sys/pow_int.c
|
// https://git.savannah.gnu.org/cgit/gsl.git/tree/sys/pow_int.c
|
||||||
pub fn integer_power<'ctx>(
|
pub fn integer_power<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
generator: &mut dyn CodeGenerator,
|
generator: &mut G,
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
base: IntValue<'ctx>,
|
base: IntValue<'ctx>,
|
||||||
exp: IntValue<'ctx>,
|
exp: IntValue<'ctx>,
|
||||||
|
@ -81,8 +81,8 @@ pub fn integer_power<'ctx>(
|
||||||
.unwrap()
|
.unwrap()
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn calculate_len_for_slice_range<'ctx>(
|
pub fn calculate_len_for_slice_range<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
generator: &mut dyn CodeGenerator,
|
generator: &mut G,
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
start: IntValue<'ctx>,
|
start: IntValue<'ctx>,
|
||||||
end: IntValue<'ctx>,
|
end: IntValue<'ctx>,
|
||||||
|
@ -303,8 +303,8 @@ pub fn handle_slice_index_bound<'ctx, G: CodeGenerator>(
|
||||||
/// This function handles 'end' **inclusively**.
|
/// This function handles 'end' **inclusively**.
|
||||||
/// Order of tuples `assign_idx` and `value_idx` is ('start', 'end', 'step').
|
/// Order of tuples `assign_idx` and `value_idx` is ('start', 'end', 'step').
|
||||||
/// Negative index should be handled before entering this function
|
/// Negative index should be handled before entering this function
|
||||||
pub fn list_slice_assignment<'ctx>(
|
pub fn list_slice_assignment<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
generator: &mut dyn CodeGenerator,
|
generator: &mut G,
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
ty: BasicTypeEnum<'ctx>,
|
ty: BasicTypeEnum<'ctx>,
|
||||||
dest_arr: ListValue<'ctx>,
|
dest_arr: ListValue<'ctx>,
|
||||||
|
@ -338,7 +338,7 @@ pub fn list_slice_assignment<'ctx>(
|
||||||
|
|
||||||
let zero = int32.const_zero();
|
let zero = int32.const_zero();
|
||||||
let one = int32.const_int(1, false);
|
let one = int32.const_int(1, false);
|
||||||
let dest_arr_ptr = dest_arr.data().as_ptr_value(ctx);
|
let dest_arr_ptr = dest_arr.data().base_ptr(ctx, generator);
|
||||||
let dest_arr_ptr = ctx.builder.build_pointer_cast(
|
let dest_arr_ptr = ctx.builder.build_pointer_cast(
|
||||||
dest_arr_ptr,
|
dest_arr_ptr,
|
||||||
elem_ptr_type,
|
elem_ptr_type,
|
||||||
|
@ -346,7 +346,7 @@ pub fn list_slice_assignment<'ctx>(
|
||||||
).unwrap();
|
).unwrap();
|
||||||
let dest_len = dest_arr.load_size(ctx, Some("dest.len"));
|
let dest_len = dest_arr.load_size(ctx, Some("dest.len"));
|
||||||
let dest_len = ctx.builder.build_int_truncate_or_bit_cast(dest_len, int32, "srclen32").unwrap();
|
let dest_len = ctx.builder.build_int_truncate_or_bit_cast(dest_len, int32, "srclen32").unwrap();
|
||||||
let src_arr_ptr = src_arr.data().as_ptr_value(ctx);
|
let src_arr_ptr = src_arr.data().base_ptr(ctx, generator);
|
||||||
let src_arr_ptr = ctx.builder.build_pointer_cast(
|
let src_arr_ptr = ctx.builder.build_pointer_cast(
|
||||||
src_arr_ptr,
|
src_arr_ptr,
|
||||||
elem_ptr_type,
|
elem_ptr_type,
|
||||||
|
@ -468,8 +468,8 @@ pub fn list_slice_assignment<'ctx>(
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Generates a call to `isinf` in IR. Returns an `i1` representing the result.
|
/// Generates a call to `isinf` in IR. Returns an `i1` representing the result.
|
||||||
pub fn call_isinf<'ctx>(
|
pub fn call_isinf<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
generator: &mut dyn CodeGenerator,
|
generator: &mut G,
|
||||||
ctx: &CodeGenContext<'ctx, '_>,
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
v: FloatValue<'ctx>,
|
v: FloatValue<'ctx>,
|
||||||
) -> IntValue<'ctx> {
|
) -> IntValue<'ctx> {
|
||||||
|
@ -489,8 +489,8 @@ pub fn call_isinf<'ctx>(
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Generates a call to `isnan` in IR. Returns an `i1` representing the result.
|
/// Generates a call to `isnan` in IR. Returns an `i1` representing the result.
|
||||||
pub fn call_isnan<'ctx>(
|
pub fn call_isnan<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
generator: &mut dyn CodeGenerator,
|
generator: &mut G,
|
||||||
ctx: &CodeGenContext<'ctx, '_>,
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
v: FloatValue<'ctx>,
|
v: FloatValue<'ctx>,
|
||||||
) -> IntValue<'ctx> {
|
) -> IntValue<'ctx> {
|
||||||
|
@ -574,12 +574,14 @@ pub fn call_j0<'ctx>(
|
||||||
///
|
///
|
||||||
/// * `num_dims` - An [`IntValue`] containing the number of dimensions.
|
/// * `num_dims` - An [`IntValue`] containing the number of dimensions.
|
||||||
/// * `dims` - A [`PointerValue`] to an array containing the size of each dimension.
|
/// * `dims` - A [`PointerValue`] to an array containing the size of each dimension.
|
||||||
pub fn call_ndarray_calc_size<'ctx>(
|
pub fn call_ndarray_calc_size<'ctx, G, Dims>(
|
||||||
generator: &dyn CodeGenerator,
|
generator: &G,
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
num_dims: IntValue<'ctx>,
|
dims: &Dims,
|
||||||
dims: PointerValue<'ctx>,
|
) -> IntValue<'ctx>
|
||||||
) -> IntValue<'ctx> {
|
where
|
||||||
|
G: CodeGenerator + ?Sized,
|
||||||
|
Dims: ArrayLikeIndexer<'ctx>, {
|
||||||
let llvm_i64 = ctx.ctx.i64_type();
|
let llvm_i64 = ctx.ctx.i64_type();
|
||||||
let llvm_usize = generator.get_size_type(ctx.ctx);
|
let llvm_usize = generator.get_size_type(ctx.ctx);
|
||||||
|
|
||||||
|
@ -606,8 +608,8 @@ pub fn call_ndarray_calc_size<'ctx>(
|
||||||
.build_call(
|
.build_call(
|
||||||
ndarray_calc_size_fn,
|
ndarray_calc_size_fn,
|
||||||
&[
|
&[
|
||||||
dims.into(),
|
dims.base_ptr(ctx, generator).into(),
|
||||||
num_dims.into(),
|
dims.size(ctx, generator).into(),
|
||||||
],
|
],
|
||||||
"",
|
"",
|
||||||
)
|
)
|
||||||
|
@ -622,8 +624,8 @@ pub fn call_ndarray_calc_size<'ctx>(
|
||||||
/// * `index` - The index to compute the multidimensional index for.
|
/// * `index` - The index to compute the multidimensional index for.
|
||||||
/// * `ndarray` - LLVM pointer to the `NDArray`. This value must be the LLVM representation of an
|
/// * `ndarray` - LLVM pointer to the `NDArray`. This value must be the LLVM representation of an
|
||||||
/// `NDArray`.
|
/// `NDArray`.
|
||||||
pub fn call_ndarray_calc_nd_indices<'ctx>(
|
pub fn call_ndarray_calc_nd_indices<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
generator: &dyn CodeGenerator,
|
generator: &G,
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
index: IntValue<'ctx>,
|
index: IntValue<'ctx>,
|
||||||
ndarray: NDArrayValue<'ctx>,
|
ndarray: NDArrayValue<'ctx>,
|
||||||
|
@ -666,7 +668,7 @@ pub fn call_ndarray_calc_nd_indices<'ctx>(
|
||||||
ndarray_calc_nd_indices_fn,
|
ndarray_calc_nd_indices_fn,
|
||||||
&[
|
&[
|
||||||
index.into(),
|
index.into(),
|
||||||
ndarray_dims.as_ptr_value(ctx).into(),
|
ndarray_dims.base_ptr(ctx, generator).into(),
|
||||||
ndarray_num_dims.into(),
|
ndarray_num_dims.into(),
|
||||||
indices.into(),
|
indices.into(),
|
||||||
],
|
],
|
||||||
|
@ -677,13 +679,15 @@ pub fn call_ndarray_calc_nd_indices<'ctx>(
|
||||||
indices
|
indices
|
||||||
}
|
}
|
||||||
|
|
||||||
fn call_ndarray_flatten_index_impl<'ctx>(
|
fn call_ndarray_flatten_index_impl<'ctx, G, Indices>(
|
||||||
generator: &dyn CodeGenerator,
|
generator: &G,
|
||||||
ctx: &CodeGenContext<'ctx, '_>,
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
ndarray: NDArrayValue<'ctx>,
|
ndarray: NDArrayValue<'ctx>,
|
||||||
indices: PointerValue<'ctx>,
|
indices: &Indices,
|
||||||
indices_size: IntValue<'ctx>,
|
) -> IntValue<'ctx>
|
||||||
) -> IntValue<'ctx> {
|
where
|
||||||
|
G: CodeGenerator + ?Sized,
|
||||||
|
Indices: ArrayLikeIndexer<'ctx>, {
|
||||||
let llvm_i32 = ctx.ctx.i32_type();
|
let llvm_i32 = ctx.ctx.i32_type();
|
||||||
let llvm_usize = generator.get_size_type(ctx.ctx);
|
let llvm_usize = generator.get_size_type(ctx.ctx);
|
||||||
|
|
||||||
|
@ -691,14 +695,14 @@ fn call_ndarray_flatten_index_impl<'ctx>(
|
||||||
let llvm_pusize = llvm_usize.ptr_type(AddressSpace::default());
|
let llvm_pusize = llvm_usize.ptr_type(AddressSpace::default());
|
||||||
|
|
||||||
debug_assert_eq!(
|
debug_assert_eq!(
|
||||||
IntType::try_from(indices.get_type().get_element_type())
|
IntType::try_from(indices.element_type(ctx, generator))
|
||||||
.map(IntType::get_bit_width)
|
.map(IntType::get_bit_width)
|
||||||
.unwrap_or_default(),
|
.unwrap_or_default(),
|
||||||
llvm_i32.get_bit_width(),
|
llvm_i32.get_bit_width(),
|
||||||
"Expected i32 value for argument `indices` to `call_ndarray_flatten_index_impl`"
|
"Expected i32 value for argument `indices` to `call_ndarray_flatten_index_impl`"
|
||||||
);
|
);
|
||||||
debug_assert_eq!(
|
debug_assert_eq!(
|
||||||
indices_size.get_type().get_bit_width(),
|
indices.size(ctx, generator).get_type().get_bit_width(),
|
||||||
llvm_usize.get_bit_width(),
|
llvm_usize.get_bit_width(),
|
||||||
"Expected usize integer value for argument `indices_size` to `call_ndarray_flatten_index_impl`"
|
"Expected usize integer value for argument `indices_size` to `call_ndarray_flatten_index_impl`"
|
||||||
);
|
);
|
||||||
|
@ -729,10 +733,10 @@ fn call_ndarray_flatten_index_impl<'ctx>(
|
||||||
.build_call(
|
.build_call(
|
||||||
ndarray_flatten_index_fn,
|
ndarray_flatten_index_fn,
|
||||||
&[
|
&[
|
||||||
ndarray_dims.as_ptr_value(ctx).into(),
|
ndarray_dims.base_ptr(ctx, generator).into(),
|
||||||
ndarray_num_dims.into(),
|
ndarray_num_dims.into(),
|
||||||
indices.into(),
|
indices.base_ptr(ctx, generator).into(),
|
||||||
indices_size.into(),
|
indices.size(ctx, generator).into(),
|
||||||
],
|
],
|
||||||
"",
|
"",
|
||||||
)
|
)
|
||||||
|
@ -750,21 +754,21 @@ fn call_ndarray_flatten_index_impl<'ctx>(
|
||||||
/// * `ndarray` - LLVM pointer to the `NDArray`. This value must be the LLVM representation of an
|
/// * `ndarray` - LLVM pointer to the `NDArray`. This value must be the LLVM representation of an
|
||||||
/// `NDArray`.
|
/// `NDArray`.
|
||||||
/// * `indices` - The multidimensional index to compute the flattened index for.
|
/// * `indices` - The multidimensional index to compute the flattened index for.
|
||||||
pub fn call_ndarray_flatten_index<'ctx>(
|
pub fn call_ndarray_flatten_index<'ctx, G, Index>(
|
||||||
generator: &dyn CodeGenerator,
|
generator: &mut G,
|
||||||
ctx: &CodeGenContext<'ctx, '_>,
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
ndarray: NDArrayValue<'ctx>,
|
ndarray: NDArrayValue<'ctx>,
|
||||||
indices: ListValue<'ctx>,
|
indices: &Index,
|
||||||
) -> IntValue<'ctx> {
|
) -> IntValue<'ctx>
|
||||||
let indices_size = indices.load_size(ctx, None);
|
where
|
||||||
let indices_data = indices.data();
|
G: CodeGenerator + ?Sized,
|
||||||
|
Index: ArrayLikeIndexer<'ctx>, {
|
||||||
|
|
||||||
call_ndarray_flatten_index_impl(
|
call_ndarray_flatten_index_impl(
|
||||||
generator,
|
generator,
|
||||||
ctx,
|
ctx,
|
||||||
ndarray,
|
ndarray,
|
||||||
indices_data.as_ptr_value(ctx),
|
indices,
|
||||||
indices_size,
|
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
/// Generates a call to `__nac3_ndarray_flatten_index`. Returns the flattened index for the
|
/// Generates a call to `__nac3_ndarray_flatten_index`. Returns the flattened index for the
|
||||||
|
@ -773,8 +777,8 @@ pub fn call_ndarray_flatten_index<'ctx>(
|
||||||
/// * `ndarray` - LLVM pointer to the `NDArray`. This value must be the LLVM representation of an
|
/// * `ndarray` - LLVM pointer to the `NDArray`. This value must be the LLVM representation of an
|
||||||
/// `NDArray`.
|
/// `NDArray`.
|
||||||
/// * `indices` - The multidimensional index to compute the flattened index for.
|
/// * `indices` - The multidimensional index to compute the flattened index for.
|
||||||
pub fn call_ndarray_flatten_index_const<'ctx>(
|
pub fn call_ndarray_flatten_index_const<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
generator: &mut dyn CodeGenerator,
|
generator: &mut G,
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
ndarray: NDArrayValue<'ctx>,
|
ndarray: NDArrayValue<'ctx>,
|
||||||
indices: ArrayValue<'ctx>,
|
indices: ArrayValue<'ctx>,
|
||||||
|
@ -786,27 +790,27 @@ pub fn call_ndarray_flatten_index_const<'ctx>(
|
||||||
ctx,
|
ctx,
|
||||||
indices.get_type().get_element_type(),
|
indices.get_type().get_element_type(),
|
||||||
llvm_usize.const_int(indices_size as u64, false),
|
llvm_usize.const_int(indices_size as u64, false),
|
||||||
None
|
None,
|
||||||
).unwrap();
|
).unwrap();
|
||||||
for i in 0..indices_size {
|
for i in 0..indices_size {
|
||||||
let v = ctx.builder.build_extract_value(indices, i, "")
|
let v = ctx.builder.build_extract_value(indices, i, "")
|
||||||
.unwrap()
|
.unwrap()
|
||||||
.into_int_value();
|
.into_int_value();
|
||||||
let elem_ptr = unsafe {
|
|
||||||
ctx.builder.build_in_bounds_gep(
|
unsafe {
|
||||||
indices_alloca,
|
indices_alloca.set_unchecked(
|
||||||
&[ctx.ctx.i32_type().const_int(i as u64, false)],
|
ctx,
|
||||||
""
|
generator,
|
||||||
)
|
ctx.ctx.i32_type().const_int(i as u64, false),
|
||||||
}.unwrap();
|
v.into(),
|
||||||
ctx.builder.build_store(elem_ptr, v).unwrap();
|
);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
call_ndarray_flatten_index_impl(
|
call_ndarray_flatten_index_impl(
|
||||||
generator,
|
generator,
|
||||||
ctx,
|
ctx,
|
||||||
ndarray,
|
ndarray,
|
||||||
indices_alloca,
|
&indices_alloca,
|
||||||
llvm_usize.const_int(indices_size as u64, false),
|
|
||||||
)
|
)
|
||||||
}
|
}
|
|
@ -45,6 +45,7 @@ pub mod expr;
|
||||||
mod generator;
|
mod generator;
|
||||||
pub mod irrt;
|
pub mod irrt;
|
||||||
pub mod llvm_intrinsics;
|
pub mod llvm_intrinsics;
|
||||||
|
pub mod numpy;
|
||||||
pub mod stmt;
|
pub mod stmt;
|
||||||
|
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
|
@ -415,10 +416,10 @@ pub struct CodeGenTask {
|
||||||
/// This function is used to obtain the in-memory representation of `ty`, e.g. a `bool` variable
|
/// This function is used to obtain the in-memory representation of `ty`, e.g. a `bool` variable
|
||||||
/// would be represented by an `i8`.
|
/// would be represented by an `i8`.
|
||||||
#[allow(clippy::too_many_arguments)]
|
#[allow(clippy::too_many_arguments)]
|
||||||
fn get_llvm_type<'ctx>(
|
fn get_llvm_type<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
ctx: &'ctx Context,
|
ctx: &'ctx Context,
|
||||||
module: &Module<'ctx>,
|
module: &Module<'ctx>,
|
||||||
generator: &mut dyn CodeGenerator,
|
generator: &mut G,
|
||||||
unifier: &mut Unifier,
|
unifier: &mut Unifier,
|
||||||
top_level: &TopLevelContext,
|
top_level: &TopLevelContext,
|
||||||
type_cache: &mut HashMap<Type, BasicTypeEnum<'ctx>>,
|
type_cache: &mut HashMap<Type, BasicTypeEnum<'ctx>>,
|
||||||
|
@ -553,10 +554,10 @@ fn get_llvm_type<'ctx>(
|
||||||
/// be byte-aligned for the variable to be addressable in memory, whereas there is no such
|
/// be byte-aligned for the variable to be addressable in memory, whereas there is no such
|
||||||
/// restriction for ABI representations.
|
/// restriction for ABI representations.
|
||||||
#[allow(clippy::too_many_arguments)]
|
#[allow(clippy::too_many_arguments)]
|
||||||
fn get_llvm_abi_type<'ctx>(
|
fn get_llvm_abi_type<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
ctx: &'ctx Context,
|
ctx: &'ctx Context,
|
||||||
module: &Module<'ctx>,
|
module: &Module<'ctx>,
|
||||||
generator: &mut dyn CodeGenerator,
|
generator: &mut G,
|
||||||
unifier: &mut Unifier,
|
unifier: &mut Unifier,
|
||||||
top_level: &TopLevelContext,
|
top_level: &TopLevelContext,
|
||||||
type_cache: &mut HashMap<Type, BasicTypeEnum<'ctx>>,
|
type_cache: &mut HashMap<Type, BasicTypeEnum<'ctx>>,
|
||||||
|
|
|
@ -0,0 +1,837 @@
|
||||||
|
use inkwell::{
|
||||||
|
IntPredicate,
|
||||||
|
types::BasicType,
|
||||||
|
values::{AggregateValueEnum, ArrayValue, BasicValueEnum, IntValue, PointerValue}
|
||||||
|
};
|
||||||
|
use nac3parser::ast::StrRef;
|
||||||
|
use crate::{
|
||||||
|
codegen::{
|
||||||
|
classes::{
|
||||||
|
ArrayLikeIndexer,
|
||||||
|
ArrayLikeValue,
|
||||||
|
ListValue,
|
||||||
|
NDArrayValue,
|
||||||
|
TypedArrayLikeAccessor,
|
||||||
|
UntypedArrayLikeAccessor,
|
||||||
|
},
|
||||||
|
CodeGenContext,
|
||||||
|
CodeGenerator,
|
||||||
|
irrt::{
|
||||||
|
call_ndarray_calc_nd_indices,
|
||||||
|
call_ndarray_calc_size,
|
||||||
|
},
|
||||||
|
llvm_intrinsics::call_memcpy_generic,
|
||||||
|
stmt::gen_for_callback_incrementing,
|
||||||
|
},
|
||||||
|
symbol_resolver::ValueEnum,
|
||||||
|
toplevel::{
|
||||||
|
DefinitionId,
|
||||||
|
numpy::{make_ndarray_ty, unpack_ndarray_tvars},
|
||||||
|
},
|
||||||
|
typecheck::typedef::{FunSignature, Type},
|
||||||
|
};
|
||||||
|
|
||||||
|
/// Creates an `NDArray` instance from a dynamic shape.
|
||||||
|
///
|
||||||
|
/// * `elem_ty` - The element type of the `NDArray`.
|
||||||
|
/// * `shape` - The shape of the `NDArray`.
|
||||||
|
/// * `shape_len_fn` - A function that retrieves the number of dimensions from `shape`.
|
||||||
|
/// * `shape_data_fn` - A function that retrieves the size of a dimension from `shape`.
|
||||||
|
fn create_ndarray_dyn_shape<'ctx, 'a, G, V, LenFn, DataFn>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, 'a>,
|
||||||
|
elem_ty: Type,
|
||||||
|
shape: &V,
|
||||||
|
shape_len_fn: LenFn,
|
||||||
|
shape_data_fn: DataFn,
|
||||||
|
) -> Result<NDArrayValue<'ctx>, String>
|
||||||
|
where
|
||||||
|
G: CodeGenerator + ?Sized,
|
||||||
|
LenFn: Fn(&mut G, &mut CodeGenContext<'ctx, 'a>, &V) -> Result<IntValue<'ctx>, String>,
|
||||||
|
DataFn: Fn(&mut G, &mut CodeGenContext<'ctx, 'a>, &V, IntValue<'ctx>) -> Result<IntValue<'ctx>, String>,
|
||||||
|
{
|
||||||
|
let ndarray_ty = make_ndarray_ty(&mut ctx.unifier, &ctx.primitives, Some(elem_ty), None);
|
||||||
|
|
||||||
|
let llvm_usize = generator.get_size_type(ctx.ctx);
|
||||||
|
|
||||||
|
let llvm_pndarray_t = ctx.get_llvm_type(generator, ndarray_ty).into_pointer_type();
|
||||||
|
let llvm_ndarray_t = llvm_pndarray_t.get_element_type().into_struct_type();
|
||||||
|
let llvm_ndarray_data_t = ctx.get_llvm_type(generator, elem_ty).as_basic_type_enum();
|
||||||
|
assert!(llvm_ndarray_data_t.is_sized());
|
||||||
|
|
||||||
|
// Assert that all dimensions are non-negative
|
||||||
|
let shape_len = shape_len_fn(generator, ctx, shape)?;
|
||||||
|
gen_for_callback_incrementing(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
llvm_usize.const_zero(),
|
||||||
|
(shape_len, false),
|
||||||
|
|generator, ctx, i| {
|
||||||
|
let shape_dim = shape_data_fn(generator, ctx, shape, i)?;
|
||||||
|
debug_assert!(shape_dim.get_type().get_bit_width() <= llvm_usize.get_bit_width());
|
||||||
|
|
||||||
|
let shape_dim_gez = ctx.builder
|
||||||
|
.build_int_compare(IntPredicate::SGE, shape_dim, shape_dim.get_type().const_zero(), "")
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
ctx.make_assert(
|
||||||
|
generator,
|
||||||
|
shape_dim_gez,
|
||||||
|
"0:ValueError",
|
||||||
|
"negative dimensions not supported",
|
||||||
|
[None, None, None],
|
||||||
|
ctx.current_loc,
|
||||||
|
);
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
},
|
||||||
|
llvm_usize.const_int(1, false),
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let ndarray = generator.gen_var_alloc(
|
||||||
|
ctx,
|
||||||
|
llvm_ndarray_t.into(),
|
||||||
|
None,
|
||||||
|
)?;
|
||||||
|
let ndarray = NDArrayValue::from_ptr_val(ndarray, llvm_usize, None);
|
||||||
|
|
||||||
|
let num_dims = shape_len_fn(generator, ctx, shape)?;
|
||||||
|
ndarray.store_ndims(ctx, generator, num_dims);
|
||||||
|
|
||||||
|
let ndarray_num_dims = ndarray.load_ndims(ctx);
|
||||||
|
ndarray.create_dim_sizes(ctx, llvm_usize, ndarray_num_dims);
|
||||||
|
|
||||||
|
// Copy the dimension sizes from shape to ndarray.dims
|
||||||
|
let shape_len = shape_len_fn(generator, ctx, shape)?;
|
||||||
|
gen_for_callback_incrementing(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
llvm_usize.const_zero(),
|
||||||
|
(shape_len, false),
|
||||||
|
|generator, ctx, i| {
|
||||||
|
let shape_dim = shape_data_fn(generator, ctx, shape, i)?;
|
||||||
|
debug_assert!(shape_dim.get_type().get_bit_width() <= llvm_usize.get_bit_width());
|
||||||
|
let shape_dim = ctx.builder
|
||||||
|
.build_int_z_extend(shape_dim, llvm_usize, "")
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
let ndarray_pdim = unsafe {
|
||||||
|
ndarray.dim_sizes().ptr_offset_unchecked(ctx, generator, i, None)
|
||||||
|
};
|
||||||
|
|
||||||
|
ctx.builder.build_store(ndarray_pdim, shape_dim).unwrap();
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
},
|
||||||
|
llvm_usize.const_int(1, false),
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let ndarray_num_elems = call_ndarray_calc_size(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
&ndarray.dim_sizes().as_slice_value(ctx, generator),
|
||||||
|
);
|
||||||
|
ndarray.create_data(ctx, llvm_ndarray_data_t, ndarray_num_elems);
|
||||||
|
|
||||||
|
Ok(ndarray)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Creates an `NDArray` instance from a constant shape.
|
||||||
|
///
|
||||||
|
/// * `elem_ty` - The element type of the `NDArray`.
|
||||||
|
/// * `shape` - The shape of the `NDArray`, represented as an LLVM [`ArrayValue`].
|
||||||
|
fn create_ndarray_const_shape<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
elem_ty: Type,
|
||||||
|
shape: ArrayValue<'ctx>
|
||||||
|
) -> Result<NDArrayValue<'ctx>, String> {
|
||||||
|
let ndarray_ty = make_ndarray_ty(&mut ctx.unifier, &ctx.primitives, Some(elem_ty), None);
|
||||||
|
|
||||||
|
let llvm_usize = generator.get_size_type(ctx.ctx);
|
||||||
|
|
||||||
|
let llvm_pndarray_t = ctx.get_llvm_type(generator, ndarray_ty).into_pointer_type();
|
||||||
|
let llvm_ndarray_t = llvm_pndarray_t.get_element_type().into_struct_type();
|
||||||
|
let llvm_ndarray_data_t = ctx.get_llvm_type(generator, elem_ty).as_basic_type_enum();
|
||||||
|
assert!(llvm_ndarray_data_t.is_sized());
|
||||||
|
|
||||||
|
for i in 0..shape.get_type().len() {
|
||||||
|
let shape_dim = ctx.builder
|
||||||
|
.build_extract_value(shape, i, "")
|
||||||
|
.map(BasicValueEnum::into_int_value)
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
let shape_dim_gez = ctx.builder
|
||||||
|
.build_int_compare(IntPredicate::SGE, shape_dim, llvm_usize.const_zero(), "")
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
ctx.make_assert(
|
||||||
|
generator,
|
||||||
|
shape_dim_gez,
|
||||||
|
"0:ValueError",
|
||||||
|
"negative dimensions not supported",
|
||||||
|
[None, None, None],
|
||||||
|
ctx.current_loc,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
let ndarray = generator.gen_var_alloc(
|
||||||
|
ctx,
|
||||||
|
llvm_ndarray_t.into(),
|
||||||
|
None,
|
||||||
|
)?;
|
||||||
|
let ndarray = NDArrayValue::from_ptr_val(ndarray, llvm_usize, None);
|
||||||
|
|
||||||
|
let num_dims = llvm_usize.const_int(shape.get_type().len() as u64, false);
|
||||||
|
ndarray.store_ndims(ctx, generator, num_dims);
|
||||||
|
|
||||||
|
let ndarray_num_dims = ndarray.load_ndims(ctx);
|
||||||
|
ndarray.create_dim_sizes(ctx, llvm_usize, ndarray_num_dims);
|
||||||
|
|
||||||
|
for i in 0..shape.get_type().len() {
|
||||||
|
let ndarray_dim = ndarray
|
||||||
|
.dim_sizes()
|
||||||
|
.ptr_offset(ctx, generator, llvm_usize.const_int(i as u64, true), None);
|
||||||
|
let shape_dim = ctx.builder.build_extract_value(shape, i, "")
|
||||||
|
.map(BasicValueEnum::into_int_value)
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
ctx.builder.build_store(ndarray_dim, shape_dim).unwrap();
|
||||||
|
}
|
||||||
|
|
||||||
|
let ndarray_num_elems = call_ndarray_calc_size(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
&ndarray.dim_sizes().as_slice_value(ctx, generator),
|
||||||
|
);
|
||||||
|
ndarray.create_data(ctx, llvm_ndarray_data_t, ndarray_num_elems);
|
||||||
|
|
||||||
|
Ok(ndarray)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn ndarray_zero_value<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
elem_ty: Type,
|
||||||
|
) -> BasicValueEnum<'ctx> {
|
||||||
|
if [ctx.primitives.int32, ctx.primitives.uint32].iter().any(|ty| ctx.unifier.unioned(elem_ty, *ty)) {
|
||||||
|
ctx.ctx.i32_type().const_zero().into()
|
||||||
|
} else if [ctx.primitives.int64, ctx.primitives.uint64].iter().any(|ty| ctx.unifier.unioned(elem_ty, *ty)) {
|
||||||
|
ctx.ctx.i64_type().const_zero().into()
|
||||||
|
} else if ctx.unifier.unioned(elem_ty, ctx.primitives.float) {
|
||||||
|
ctx.ctx.f64_type().const_zero().into()
|
||||||
|
} else if ctx.unifier.unioned(elem_ty, ctx.primitives.bool) {
|
||||||
|
ctx.ctx.bool_type().const_zero().into()
|
||||||
|
} else if ctx.unifier.unioned(elem_ty, ctx.primitives.str) {
|
||||||
|
ctx.gen_string(generator, "")
|
||||||
|
} else {
|
||||||
|
unreachable!()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn ndarray_one_value<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
elem_ty: Type,
|
||||||
|
) -> BasicValueEnum<'ctx> {
|
||||||
|
if [ctx.primitives.int32, ctx.primitives.uint32].iter().any(|ty| ctx.unifier.unioned(elem_ty, *ty)) {
|
||||||
|
let is_signed = ctx.unifier.unioned(elem_ty, ctx.primitives.int32);
|
||||||
|
ctx.ctx.i32_type().const_int(1, is_signed).into()
|
||||||
|
} else if [ctx.primitives.int64, ctx.primitives.uint64].iter().any(|ty| ctx.unifier.unioned(elem_ty, *ty)) {
|
||||||
|
let is_signed = ctx.unifier.unioned(elem_ty, ctx.primitives.int64);
|
||||||
|
ctx.ctx.i64_type().const_int(1, is_signed).into()
|
||||||
|
} else if ctx.unifier.unioned(elem_ty, ctx.primitives.float) {
|
||||||
|
ctx.ctx.f64_type().const_float(1.0).into()
|
||||||
|
} else if ctx.unifier.unioned(elem_ty, ctx.primitives.bool) {
|
||||||
|
ctx.ctx.bool_type().const_int(1, false).into()
|
||||||
|
} else if ctx.unifier.unioned(elem_ty, ctx.primitives.str) {
|
||||||
|
ctx.gen_string(generator, "1")
|
||||||
|
} else {
|
||||||
|
unreachable!()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// LLVM-typed implementation for generating the implementation for constructing an `NDArray`.
|
||||||
|
///
|
||||||
|
/// * `elem_ty` - The element type of the `NDArray`.
|
||||||
|
/// * `shape` - The `shape` parameter used to construct the `NDArray`.
|
||||||
|
fn call_ndarray_empty_impl<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
elem_ty: Type,
|
||||||
|
shape: ListValue<'ctx>,
|
||||||
|
) -> Result<NDArrayValue<'ctx>, String> {
|
||||||
|
create_ndarray_dyn_shape(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
elem_ty,
|
||||||
|
&shape,
|
||||||
|
|_, ctx, shape| {
|
||||||
|
Ok(shape.load_size(ctx, None))
|
||||||
|
},
|
||||||
|
|generator, ctx, shape, idx| {
|
||||||
|
Ok(shape.data().get(ctx, generator, idx, None).into_int_value())
|
||||||
|
},
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Generates LLVM IR for populating the entire `NDArray` using a lambda with its flattened index as
|
||||||
|
/// its input.
|
||||||
|
fn ndarray_fill_flattened<'ctx, 'a, G, ValueFn>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, 'a>,
|
||||||
|
ndarray: NDArrayValue<'ctx>,
|
||||||
|
value_fn: ValueFn,
|
||||||
|
) -> Result<(), String>
|
||||||
|
where
|
||||||
|
G: CodeGenerator + ?Sized,
|
||||||
|
ValueFn: Fn(&mut G, &mut CodeGenContext<'ctx, 'a>, IntValue<'ctx>) -> Result<BasicValueEnum<'ctx>, String>,
|
||||||
|
{
|
||||||
|
let llvm_usize = generator.get_size_type(ctx.ctx);
|
||||||
|
|
||||||
|
let ndarray_num_elems = call_ndarray_calc_size(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
&ndarray.dim_sizes().as_slice_value(ctx, generator),
|
||||||
|
);
|
||||||
|
|
||||||
|
gen_for_callback_incrementing(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
llvm_usize.const_zero(),
|
||||||
|
(ndarray_num_elems, false),
|
||||||
|
|generator, ctx, i| {
|
||||||
|
let elem = unsafe {
|
||||||
|
ndarray.data().ptr_offset_unchecked(ctx, generator, i, None)
|
||||||
|
};
|
||||||
|
|
||||||
|
let value = value_fn(generator, ctx, i)?;
|
||||||
|
ctx.builder.build_store(elem, value).unwrap();
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
},
|
||||||
|
llvm_usize.const_int(1, false),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Generates LLVM IR for populating the entire `NDArray` using a lambda with the dimension-indices
|
||||||
|
/// as its input.
|
||||||
|
fn ndarray_fill_indexed<'ctx, G, ValueFn>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
ndarray: NDArrayValue<'ctx>,
|
||||||
|
value_fn: ValueFn,
|
||||||
|
) -> Result<(), String>
|
||||||
|
where
|
||||||
|
G: CodeGenerator + ?Sized,
|
||||||
|
ValueFn: Fn(&mut G, &mut CodeGenContext<'ctx, '_>, PointerValue<'ctx>) -> Result<BasicValueEnum<'ctx>, String>,
|
||||||
|
{
|
||||||
|
ndarray_fill_flattened(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
ndarray,
|
||||||
|
|generator, ctx, idx| {
|
||||||
|
let indices = call_ndarray_calc_nd_indices(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
idx,
|
||||||
|
ndarray,
|
||||||
|
);
|
||||||
|
|
||||||
|
value_fn(generator, ctx, indices)
|
||||||
|
}
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// LLVM-typed implementation for generating the implementation for `ndarray.zeros`.
|
||||||
|
///
|
||||||
|
/// * `elem_ty` - The element type of the `NDArray`.
|
||||||
|
/// * `shape` - The `shape` parameter used to construct the `NDArray`.
|
||||||
|
fn call_ndarray_zeros_impl<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
elem_ty: Type,
|
||||||
|
shape: ListValue<'ctx>,
|
||||||
|
) -> Result<NDArrayValue<'ctx>, String> {
|
||||||
|
let supported_types = [
|
||||||
|
ctx.primitives.int32,
|
||||||
|
ctx.primitives.int64,
|
||||||
|
ctx.primitives.uint32,
|
||||||
|
ctx.primitives.uint64,
|
||||||
|
ctx.primitives.float,
|
||||||
|
ctx.primitives.bool,
|
||||||
|
ctx.primitives.str,
|
||||||
|
];
|
||||||
|
assert!(supported_types.iter().any(|supported_ty| ctx.unifier.unioned(*supported_ty, elem_ty)));
|
||||||
|
|
||||||
|
let ndarray = call_ndarray_empty_impl(generator, ctx, elem_ty, shape)?;
|
||||||
|
ndarray_fill_flattened(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
ndarray,
|
||||||
|
|generator, ctx, _| {
|
||||||
|
let value = ndarray_zero_value(generator, ctx, elem_ty);
|
||||||
|
|
||||||
|
Ok(value)
|
||||||
|
}
|
||||||
|
)?;
|
||||||
|
|
||||||
|
Ok(ndarray)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// LLVM-typed implementation for generating the implementation for `ndarray.ones`.
|
||||||
|
///
|
||||||
|
/// * `elem_ty` - The element type of the `NDArray`.
|
||||||
|
/// * `shape` - The `shape` parameter used to construct the `NDArray`.
|
||||||
|
fn call_ndarray_ones_impl<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
elem_ty: Type,
|
||||||
|
shape: ListValue<'ctx>,
|
||||||
|
) -> Result<NDArrayValue<'ctx>, String> {
|
||||||
|
let supported_types = [
|
||||||
|
ctx.primitives.int32,
|
||||||
|
ctx.primitives.int64,
|
||||||
|
ctx.primitives.uint32,
|
||||||
|
ctx.primitives.uint64,
|
||||||
|
ctx.primitives.float,
|
||||||
|
ctx.primitives.bool,
|
||||||
|
ctx.primitives.str,
|
||||||
|
];
|
||||||
|
assert!(supported_types.iter().any(|supported_ty| ctx.unifier.unioned(*supported_ty, elem_ty)));
|
||||||
|
|
||||||
|
let ndarray = call_ndarray_empty_impl(generator, ctx, elem_ty, shape)?;
|
||||||
|
ndarray_fill_flattened(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
ndarray,
|
||||||
|
|generator, ctx, _| {
|
||||||
|
let value = ndarray_one_value(generator, ctx, elem_ty);
|
||||||
|
|
||||||
|
Ok(value)
|
||||||
|
}
|
||||||
|
)?;
|
||||||
|
|
||||||
|
Ok(ndarray)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// LLVM-typed implementation for generating the implementation for `ndarray.full`.
|
||||||
|
///
|
||||||
|
/// * `elem_ty` - The element type of the `NDArray`.
|
||||||
|
/// * `shape` - The `shape` parameter used to construct the `NDArray`.
|
||||||
|
fn call_ndarray_full_impl<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
elem_ty: Type,
|
||||||
|
shape: ListValue<'ctx>,
|
||||||
|
fill_value: BasicValueEnum<'ctx>,
|
||||||
|
) -> Result<NDArrayValue<'ctx>, String> {
|
||||||
|
let ndarray = call_ndarray_empty_impl(generator, ctx, elem_ty, shape)?;
|
||||||
|
ndarray_fill_flattened(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
ndarray,
|
||||||
|
|generator, ctx, _| {
|
||||||
|
let value = if fill_value.is_pointer_value() {
|
||||||
|
let llvm_i1 = ctx.ctx.bool_type();
|
||||||
|
|
||||||
|
let copy = generator.gen_var_alloc(ctx, fill_value.get_type(), None)?;
|
||||||
|
|
||||||
|
call_memcpy_generic(
|
||||||
|
ctx,
|
||||||
|
copy,
|
||||||
|
fill_value.into_pointer_value(),
|
||||||
|
fill_value.get_type().size_of().map(Into::into).unwrap(),
|
||||||
|
llvm_i1.const_zero(),
|
||||||
|
);
|
||||||
|
|
||||||
|
copy.into()
|
||||||
|
} else if fill_value.is_int_value() || fill_value.is_float_value() {
|
||||||
|
fill_value
|
||||||
|
} else {
|
||||||
|
unreachable!()
|
||||||
|
};
|
||||||
|
|
||||||
|
Ok(value)
|
||||||
|
}
|
||||||
|
)?;
|
||||||
|
|
||||||
|
Ok(ndarray)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// LLVM-typed implementation for generating the implementation for `ndarray.eye`.
|
||||||
|
///
|
||||||
|
/// * `elem_ty` - The element type of the `NDArray`.
|
||||||
|
fn call_ndarray_eye_impl<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
elem_ty: Type,
|
||||||
|
nrows: IntValue<'ctx>,
|
||||||
|
ncols: IntValue<'ctx>,
|
||||||
|
offset: IntValue<'ctx>,
|
||||||
|
) -> Result<NDArrayValue<'ctx>, String> {
|
||||||
|
let llvm_usize = generator.get_size_type(ctx.ctx);
|
||||||
|
let llvm_usize_2 = llvm_usize.array_type(2);
|
||||||
|
|
||||||
|
let shape_addr = generator.gen_var_alloc(ctx, llvm_usize_2.into(), None)?;
|
||||||
|
|
||||||
|
let shape = ctx.builder.build_load(shape_addr, "")
|
||||||
|
.map(BasicValueEnum::into_array_value)
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
let nrows = ctx.builder.build_int_z_extend_or_bit_cast(nrows, llvm_usize, "").unwrap();
|
||||||
|
let shape = ctx.builder
|
||||||
|
.build_insert_value(shape, nrows, 0, "")
|
||||||
|
.map(AggregateValueEnum::into_array_value)
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
let ncols = ctx.builder.build_int_z_extend_or_bit_cast(ncols, llvm_usize, "").unwrap();
|
||||||
|
let shape = ctx.builder
|
||||||
|
.build_insert_value(shape, ncols, 1, "")
|
||||||
|
.map(AggregateValueEnum::into_array_value)
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
let ndarray = create_ndarray_const_shape(generator, ctx, elem_ty, shape)?;
|
||||||
|
|
||||||
|
ndarray_fill_indexed(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
ndarray,
|
||||||
|
|generator, ctx, indices| {
|
||||||
|
let row = ctx.build_gep_and_load(
|
||||||
|
indices,
|
||||||
|
&[llvm_usize.const_int(0, false)],
|
||||||
|
None,
|
||||||
|
).into_int_value();
|
||||||
|
let col = ctx.build_gep_and_load(
|
||||||
|
indices,
|
||||||
|
&[llvm_usize.const_int(1, false)],
|
||||||
|
None,
|
||||||
|
).into_int_value();
|
||||||
|
|
||||||
|
let col_with_offset = ctx.builder
|
||||||
|
.build_int_add(
|
||||||
|
col,
|
||||||
|
ctx.builder.build_int_s_extend_or_bit_cast(offset, llvm_usize, "").unwrap(),
|
||||||
|
"",
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
let is_on_diag = ctx.builder
|
||||||
|
.build_int_compare(IntPredicate::EQ, row, col_with_offset, "")
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
let zero = ndarray_zero_value(generator, ctx, elem_ty);
|
||||||
|
let one = ndarray_one_value(generator, ctx, elem_ty);
|
||||||
|
|
||||||
|
let value = ctx.builder.build_select(is_on_diag, one, zero, "").unwrap();
|
||||||
|
|
||||||
|
Ok(value)
|
||||||
|
},
|
||||||
|
)?;
|
||||||
|
|
||||||
|
Ok(ndarray)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// LLVM-typed implementation for generating the implementation for `ndarray.copy`.
|
||||||
|
///
|
||||||
|
/// * `elem_ty` - The element type of the `NDArray`.
|
||||||
|
fn ndarray_copy_impl<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
elem_ty: Type,
|
||||||
|
this: NDArrayValue<'ctx>,
|
||||||
|
) -> Result<NDArrayValue<'ctx>, String> {
|
||||||
|
let llvm_i1 = ctx.ctx.bool_type();
|
||||||
|
|
||||||
|
let ndarray = create_ndarray_dyn_shape(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
elem_ty,
|
||||||
|
&this,
|
||||||
|
|_, ctx, shape| {
|
||||||
|
Ok(shape.load_ndims(ctx))
|
||||||
|
},
|
||||||
|
|generator, ctx, shape, idx| {
|
||||||
|
unsafe { Ok(shape.dim_sizes().get_typed_unchecked(ctx, generator, idx, None)) }
|
||||||
|
},
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let len = call_ndarray_calc_size(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
&ndarray.dim_sizes().as_slice_value(ctx, generator),
|
||||||
|
);
|
||||||
|
let sizeof_ty = ctx.get_llvm_type(generator, elem_ty);
|
||||||
|
let len_bytes = ctx.builder
|
||||||
|
.build_int_mul(
|
||||||
|
len,
|
||||||
|
sizeof_ty.size_of().unwrap(),
|
||||||
|
"",
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
call_memcpy_generic(
|
||||||
|
ctx,
|
||||||
|
ndarray.data().base_ptr(ctx, generator),
|
||||||
|
this.data().base_ptr(ctx, generator),
|
||||||
|
len_bytes,
|
||||||
|
llvm_i1.const_zero(),
|
||||||
|
);
|
||||||
|
|
||||||
|
Ok(ndarray)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Generates LLVM IR for `ndarray.empty`.
|
||||||
|
pub fn gen_ndarray_empty<'ctx>(
|
||||||
|
context: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
obj: &Option<(Type, ValueEnum<'ctx>)>,
|
||||||
|
fun: (&FunSignature, DefinitionId),
|
||||||
|
args: &[(Option<StrRef>, ValueEnum<'ctx>)],
|
||||||
|
generator: &mut dyn CodeGenerator,
|
||||||
|
) -> Result<PointerValue<'ctx>, String> {
|
||||||
|
assert!(obj.is_none());
|
||||||
|
assert_eq!(args.len(), 1);
|
||||||
|
|
||||||
|
let llvm_usize = generator.get_size_type(context.ctx);
|
||||||
|
let shape_ty = fun.0.args[0].ty;
|
||||||
|
let shape_arg = args[0].1.clone()
|
||||||
|
.to_basic_value_enum(context, generator, shape_ty)?;
|
||||||
|
|
||||||
|
call_ndarray_empty_impl(
|
||||||
|
generator,
|
||||||
|
context,
|
||||||
|
context.primitives.float,
|
||||||
|
ListValue::from_ptr_val(shape_arg.into_pointer_value(), llvm_usize, None),
|
||||||
|
).map(NDArrayValue::into)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Generates LLVM IR for `ndarray.zeros`.
|
||||||
|
pub fn gen_ndarray_zeros<'ctx>(
|
||||||
|
context: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
obj: &Option<(Type, ValueEnum<'ctx>)>,
|
||||||
|
fun: (&FunSignature, DefinitionId),
|
||||||
|
args: &[(Option<StrRef>, ValueEnum<'ctx>)],
|
||||||
|
generator: &mut dyn CodeGenerator,
|
||||||
|
) -> Result<PointerValue<'ctx>, String> {
|
||||||
|
assert!(obj.is_none());
|
||||||
|
assert_eq!(args.len(), 1);
|
||||||
|
|
||||||
|
let llvm_usize = generator.get_size_type(context.ctx);
|
||||||
|
let shape_ty = fun.0.args[0].ty;
|
||||||
|
let shape_arg = args[0].1.clone()
|
||||||
|
.to_basic_value_enum(context, generator, shape_ty)?;
|
||||||
|
|
||||||
|
call_ndarray_zeros_impl(
|
||||||
|
generator,
|
||||||
|
context,
|
||||||
|
context.primitives.float,
|
||||||
|
ListValue::from_ptr_val(shape_arg.into_pointer_value(), llvm_usize, None),
|
||||||
|
).map(NDArrayValue::into)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Generates LLVM IR for `ndarray.ones`.
|
||||||
|
pub fn gen_ndarray_ones<'ctx>(
|
||||||
|
context: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
obj: &Option<(Type, ValueEnum<'ctx>)>,
|
||||||
|
fun: (&FunSignature, DefinitionId),
|
||||||
|
args: &[(Option<StrRef>, ValueEnum<'ctx>)],
|
||||||
|
generator: &mut dyn CodeGenerator,
|
||||||
|
) -> Result<PointerValue<'ctx>, String> {
|
||||||
|
assert!(obj.is_none());
|
||||||
|
assert_eq!(args.len(), 1);
|
||||||
|
|
||||||
|
let llvm_usize = generator.get_size_type(context.ctx);
|
||||||
|
let shape_ty = fun.0.args[0].ty;
|
||||||
|
let shape_arg = args[0].1.clone()
|
||||||
|
.to_basic_value_enum(context, generator, shape_ty)?;
|
||||||
|
|
||||||
|
call_ndarray_ones_impl(
|
||||||
|
generator,
|
||||||
|
context,
|
||||||
|
context.primitives.float,
|
||||||
|
ListValue::from_ptr_val(shape_arg.into_pointer_value(), llvm_usize, None),
|
||||||
|
).map(NDArrayValue::into)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Generates LLVM IR for `ndarray.full`.
|
||||||
|
pub fn gen_ndarray_full<'ctx>(
|
||||||
|
context: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
obj: &Option<(Type, ValueEnum<'ctx>)>,
|
||||||
|
fun: (&FunSignature, DefinitionId),
|
||||||
|
args: &[(Option<StrRef>, ValueEnum<'ctx>)],
|
||||||
|
generator: &mut dyn CodeGenerator,
|
||||||
|
) -> Result<PointerValue<'ctx>, String> {
|
||||||
|
assert!(obj.is_none());
|
||||||
|
assert_eq!(args.len(), 2);
|
||||||
|
|
||||||
|
let llvm_usize = generator.get_size_type(context.ctx);
|
||||||
|
let shape_ty = fun.0.args[0].ty;
|
||||||
|
let shape_arg = args[0].1.clone()
|
||||||
|
.to_basic_value_enum(context, generator, shape_ty)?;
|
||||||
|
let fill_value_ty = fun.0.args[1].ty;
|
||||||
|
let fill_value_arg = args[1].1.clone()
|
||||||
|
.to_basic_value_enum(context, generator, fill_value_ty)?;
|
||||||
|
|
||||||
|
call_ndarray_full_impl(
|
||||||
|
generator,
|
||||||
|
context,
|
||||||
|
fill_value_ty,
|
||||||
|
ListValue::from_ptr_val(shape_arg.into_pointer_value(), llvm_usize, None),
|
||||||
|
fill_value_arg,
|
||||||
|
).map(NDArrayValue::into)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Generates LLVM IR for `ndarray.eye`.
|
||||||
|
pub fn gen_ndarray_eye<'ctx>(
|
||||||
|
context: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
obj: &Option<(Type, ValueEnum<'ctx>)>,
|
||||||
|
fun: (&FunSignature, DefinitionId),
|
||||||
|
args: &[(Option<StrRef>, ValueEnum<'ctx>)],
|
||||||
|
generator: &mut dyn CodeGenerator,
|
||||||
|
) -> Result<PointerValue<'ctx>, String> {
|
||||||
|
assert!(obj.is_none());
|
||||||
|
assert!(matches!(args.len(), 1..=3));
|
||||||
|
|
||||||
|
let nrows_ty = fun.0.args[0].ty;
|
||||||
|
let nrows_arg = args[0].1.clone()
|
||||||
|
.to_basic_value_enum(context, generator, nrows_ty)?;
|
||||||
|
|
||||||
|
let ncols_ty = fun.0.args[1].ty;
|
||||||
|
let ncols_arg = args.iter()
|
||||||
|
.find(|arg| arg.0.is_some_and(|name| name == fun.0.args[1].name))
|
||||||
|
.map(|arg| arg.1.clone().to_basic_value_enum(context, generator, ncols_ty))
|
||||||
|
.unwrap_or_else(|| {
|
||||||
|
args[0].1.clone().to_basic_value_enum(context, generator, nrows_ty)
|
||||||
|
})?;
|
||||||
|
|
||||||
|
let offset_ty = fun.0.args[2].ty;
|
||||||
|
let offset_arg = args.iter()
|
||||||
|
.find(|arg| arg.0.is_some_and(|name| name == fun.0.args[2].name))
|
||||||
|
.map(|arg| arg.1.clone().to_basic_value_enum(context, generator, offset_ty))
|
||||||
|
.unwrap_or_else(|| {
|
||||||
|
Ok(context.gen_symbol_val(
|
||||||
|
generator,
|
||||||
|
fun.0.args[2].default_value.as_ref().unwrap(),
|
||||||
|
offset_ty
|
||||||
|
))
|
||||||
|
})?;
|
||||||
|
|
||||||
|
call_ndarray_eye_impl(
|
||||||
|
generator,
|
||||||
|
context,
|
||||||
|
context.primitives.float,
|
||||||
|
nrows_arg.into_int_value(),
|
||||||
|
ncols_arg.into_int_value(),
|
||||||
|
offset_arg.into_int_value(),
|
||||||
|
).map(NDArrayValue::into)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Generates LLVM IR for `ndarray.identity`.
|
||||||
|
pub fn gen_ndarray_identity<'ctx>(
|
||||||
|
context: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
obj: &Option<(Type, ValueEnum<'ctx>)>,
|
||||||
|
fun: (&FunSignature, DefinitionId),
|
||||||
|
args: &[(Option<StrRef>, ValueEnum<'ctx>)],
|
||||||
|
generator: &mut dyn CodeGenerator,
|
||||||
|
) -> Result<PointerValue<'ctx>, String> {
|
||||||
|
assert!(obj.is_none());
|
||||||
|
assert_eq!(args.len(), 1);
|
||||||
|
|
||||||
|
let llvm_usize = generator.get_size_type(context.ctx);
|
||||||
|
|
||||||
|
let n_ty = fun.0.args[0].ty;
|
||||||
|
let n_arg = args[0].1.clone()
|
||||||
|
.to_basic_value_enum(context, generator, n_ty)?;
|
||||||
|
|
||||||
|
call_ndarray_eye_impl(
|
||||||
|
generator,
|
||||||
|
context,
|
||||||
|
context.primitives.float,
|
||||||
|
n_arg.into_int_value(),
|
||||||
|
n_arg.into_int_value(),
|
||||||
|
llvm_usize.const_zero(),
|
||||||
|
).map(NDArrayValue::into)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Generates LLVM IR for `ndarray.copy`.
|
||||||
|
pub fn gen_ndarray_copy<'ctx>(
|
||||||
|
context: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
obj: &Option<(Type, ValueEnum<'ctx>)>,
|
||||||
|
_fun: (&FunSignature, DefinitionId),
|
||||||
|
args: &[(Option<StrRef>, ValueEnum<'ctx>)],
|
||||||
|
generator: &mut dyn CodeGenerator,
|
||||||
|
) -> Result<PointerValue<'ctx>, String> {
|
||||||
|
assert!(obj.is_some());
|
||||||
|
assert!(args.is_empty());
|
||||||
|
|
||||||
|
let llvm_usize = generator.get_size_type(context.ctx);
|
||||||
|
|
||||||
|
let this_ty = obj.as_ref().unwrap().0;
|
||||||
|
let (this_elem_ty, _) = unpack_ndarray_tvars(&mut context.unifier, this_ty);
|
||||||
|
let this_arg = obj
|
||||||
|
.as_ref()
|
||||||
|
.unwrap()
|
||||||
|
.1
|
||||||
|
.clone()
|
||||||
|
.to_basic_value_enum(context, generator, this_ty)?;
|
||||||
|
|
||||||
|
ndarray_copy_impl(
|
||||||
|
generator,
|
||||||
|
context,
|
||||||
|
this_elem_ty,
|
||||||
|
NDArrayValue::from_ptr_val(this_arg.into_pointer_value(), llvm_usize, None),
|
||||||
|
).map(NDArrayValue::into)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Generates LLVM IR for `ndarray.fill`.
|
||||||
|
pub fn gen_ndarray_fill<'ctx>(
|
||||||
|
context: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
obj: &Option<(Type, ValueEnum<'ctx>)>,
|
||||||
|
fun: (&FunSignature, DefinitionId),
|
||||||
|
args: &[(Option<StrRef>, ValueEnum<'ctx>)],
|
||||||
|
generator: &mut dyn CodeGenerator,
|
||||||
|
) -> Result<(), String> {
|
||||||
|
assert!(obj.is_some());
|
||||||
|
assert_eq!(args.len(), 1);
|
||||||
|
|
||||||
|
let llvm_usize = generator.get_size_type(context.ctx);
|
||||||
|
|
||||||
|
let this_ty = obj.as_ref().unwrap().0;
|
||||||
|
let this_arg = obj.as_ref().unwrap().1.clone()
|
||||||
|
.to_basic_value_enum(context, generator, this_ty)?
|
||||||
|
.into_pointer_value();
|
||||||
|
let value_ty = fun.0.args[0].ty;
|
||||||
|
let value_arg = args[0].1.clone()
|
||||||
|
.to_basic_value_enum(context, generator, value_ty)?;
|
||||||
|
|
||||||
|
ndarray_fill_flattened(
|
||||||
|
generator,
|
||||||
|
context,
|
||||||
|
NDArrayValue::from_ptr_val(this_arg, llvm_usize, None),
|
||||||
|
|generator, ctx, _| {
|
||||||
|
let value = if value_arg.is_pointer_value() {
|
||||||
|
let llvm_i1 = ctx.ctx.bool_type();
|
||||||
|
|
||||||
|
let copy = generator.gen_var_alloc(ctx, value_arg.get_type(), None)?;
|
||||||
|
|
||||||
|
call_memcpy_generic(
|
||||||
|
ctx,
|
||||||
|
copy,
|
||||||
|
value_arg.into_pointer_value(),
|
||||||
|
value_arg.get_type().size_of().map(Into::into).unwrap(),
|
||||||
|
llvm_i1.const_zero(),
|
||||||
|
);
|
||||||
|
|
||||||
|
copy.into()
|
||||||
|
} else if value_arg.is_int_value() || value_arg.is_float_value() {
|
||||||
|
value_arg
|
||||||
|
} else {
|
||||||
|
unreachable!()
|
||||||
|
};
|
||||||
|
|
||||||
|
Ok(value)
|
||||||
|
}
|
||||||
|
)?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
|
@ -6,7 +6,7 @@ use super::{
|
||||||
};
|
};
|
||||||
use crate::{
|
use crate::{
|
||||||
codegen::{
|
codegen::{
|
||||||
classes::{ListValue, RangeValue},
|
classes::{ArrayLikeIndexer, ArraySliceValue, ListValue, RangeValue},
|
||||||
expr::gen_binop_expr,
|
expr::gen_binop_expr,
|
||||||
gen_in_range_check,
|
gen_in_range_check,
|
||||||
},
|
},
|
||||||
|
@ -65,8 +65,8 @@ pub fn gen_array_var<'ctx, 'a, T: BasicType<'ctx>>(
|
||||||
ctx: &mut CodeGenContext<'ctx, 'a>,
|
ctx: &mut CodeGenContext<'ctx, 'a>,
|
||||||
ty: T,
|
ty: T,
|
||||||
size: IntValue<'ctx>,
|
size: IntValue<'ctx>,
|
||||||
name: Option<&str>,
|
name: Option<&'ctx str>,
|
||||||
) -> Result<PointerValue<'ctx>, String> {
|
) -> Result<ArraySliceValue<'ctx>, String> {
|
||||||
// Restore debug location
|
// Restore debug location
|
||||||
let di_loc = ctx.debug_info.0.create_debug_location(
|
let di_loc = ctx.debug_info.0.create_debug_location(
|
||||||
ctx.ctx,
|
ctx.ctx,
|
||||||
|
@ -84,6 +84,7 @@ pub fn gen_array_var<'ctx, 'a, T: BasicType<'ctx>>(
|
||||||
ctx.builder.set_current_debug_location(di_loc);
|
ctx.builder.set_current_debug_location(di_loc);
|
||||||
|
|
||||||
let ptr = ctx.builder.build_array_alloca(ty, size, name.unwrap_or("")).unwrap();
|
let ptr = ctx.builder.build_array_alloca(ty, size, name.unwrap_or("")).unwrap();
|
||||||
|
let ptr = ArraySliceValue::from_ptr_val(ptr, size, name);
|
||||||
|
|
||||||
ctx.builder.position_at_end(current);
|
ctx.builder.position_at_end(current);
|
||||||
ctx.builder.set_current_debug_location(di_loc);
|
ctx.builder.set_current_debug_location(di_loc);
|
||||||
|
@ -478,8 +479,8 @@ pub fn gen_for<G: CodeGenerator>(
|
||||||
/// executing. The result value must be an `i1` indicating if the loop should continue.
|
/// executing. The result value must be an `i1` indicating if the loop should continue.
|
||||||
/// * `body` - A lambda containing IR statements within the loop body.
|
/// * `body` - A lambda containing IR statements within the loop body.
|
||||||
/// * `update` - A lambda containing IR statements updating loop variables.
|
/// * `update` - A lambda containing IR statements updating loop variables.
|
||||||
pub fn gen_for_callback<'ctx, 'a, I, InitFn, CondFn, BodyFn, UpdateFn>(
|
pub fn gen_for_callback<'ctx, 'a, G, I, InitFn, CondFn, BodyFn, UpdateFn>(
|
||||||
generator: &mut dyn CodeGenerator,
|
generator: &mut G,
|
||||||
ctx: &mut CodeGenContext<'ctx, 'a>,
|
ctx: &mut CodeGenContext<'ctx, 'a>,
|
||||||
init: InitFn,
|
init: InitFn,
|
||||||
cond: CondFn,
|
cond: CondFn,
|
||||||
|
@ -487,11 +488,12 @@ pub fn gen_for_callback<'ctx, 'a, I, InitFn, CondFn, BodyFn, UpdateFn>(
|
||||||
update: UpdateFn,
|
update: UpdateFn,
|
||||||
) -> Result<(), String>
|
) -> Result<(), String>
|
||||||
where
|
where
|
||||||
|
G: CodeGenerator + ?Sized,
|
||||||
I: Clone,
|
I: Clone,
|
||||||
InitFn: FnOnce(&mut dyn CodeGenerator, &mut CodeGenContext<'ctx, 'a>) -> Result<I, String>,
|
InitFn: FnOnce(&mut G, &mut CodeGenContext<'ctx, 'a>) -> Result<I, String>,
|
||||||
CondFn: FnOnce(&mut dyn CodeGenerator, &mut CodeGenContext<'ctx, 'a>, I) -> Result<IntValue<'ctx>, String>,
|
CondFn: FnOnce(&mut G, &mut CodeGenContext<'ctx, 'a>, I) -> Result<IntValue<'ctx>, String>,
|
||||||
BodyFn: FnOnce(&mut dyn CodeGenerator, &mut CodeGenContext<'ctx, 'a>, I) -> Result<(), String>,
|
BodyFn: FnOnce(&mut G, &mut CodeGenContext<'ctx, 'a>, I) -> Result<(), String>,
|
||||||
UpdateFn: FnOnce(&mut dyn CodeGenerator, &mut CodeGenContext<'ctx, 'a>, I) -> Result<(), String>,
|
UpdateFn: FnOnce(&mut G, &mut CodeGenContext<'ctx, 'a>, I) -> Result<(), String>,
|
||||||
{
|
{
|
||||||
let current = ctx.builder.get_insert_block().and_then(BasicBlock::get_parent).unwrap();
|
let current = ctx.builder.get_insert_block().and_then(BasicBlock::get_parent).unwrap();
|
||||||
let init_bb = ctx.ctx.append_basic_block(current, "for.init");
|
let init_bb = ctx.ctx.append_basic_block(current, "for.init");
|
||||||
|
@ -536,6 +538,85 @@ pub fn gen_for_callback<'ctx, 'a, I, InitFn, CondFn, BodyFn, UpdateFn>(
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Generates a C-style monotonically-increasing `for` construct using lambdas, similar to the
|
||||||
|
/// following C code:
|
||||||
|
///
|
||||||
|
/// ```c
|
||||||
|
/// for (int x = init_val; x /* < or <= ; see `max_val` */ max_val; x += incr_val) {
|
||||||
|
/// body(x);
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
///
|
||||||
|
/// * `init_val` - The initial value of the loop variable. The type of this value will also be used
|
||||||
|
/// as the type of the loop variable.
|
||||||
|
/// * `max_val` - A tuple containing the maximum value of the loop variable, and whether the maximum
|
||||||
|
/// value should be treated as inclusive (as opposed to exclusive).
|
||||||
|
/// * `body` - A lambda containing IR statements within the loop body.
|
||||||
|
/// * `incr_val` - The value to increment the loop variable on each iteration.
|
||||||
|
pub fn gen_for_callback_incrementing<'ctx, 'a, G, BodyFn>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, 'a>,
|
||||||
|
init_val: IntValue<'ctx>,
|
||||||
|
max_val: (IntValue<'ctx>, bool),
|
||||||
|
body: BodyFn,
|
||||||
|
incr_val: IntValue<'ctx>,
|
||||||
|
) -> Result<(), String>
|
||||||
|
where
|
||||||
|
G: CodeGenerator + ?Sized,
|
||||||
|
BodyFn: FnOnce(&mut G, &mut CodeGenContext<'ctx, 'a>, IntValue<'ctx>) -> Result<(), String>,
|
||||||
|
{
|
||||||
|
let init_val_t = init_val.get_type();
|
||||||
|
|
||||||
|
gen_for_callback(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
|generator, ctx| {
|
||||||
|
let i_addr = generator.gen_var_alloc(ctx, init_val_t.into(), None)?;
|
||||||
|
ctx.builder.build_store(i_addr, init_val).unwrap();
|
||||||
|
|
||||||
|
Ok(i_addr)
|
||||||
|
},
|
||||||
|
|_, ctx, i_addr| {
|
||||||
|
let cmp_op = if max_val.1 {
|
||||||
|
IntPredicate::ULE
|
||||||
|
} else {
|
||||||
|
IntPredicate::ULT
|
||||||
|
};
|
||||||
|
|
||||||
|
let i = ctx.builder
|
||||||
|
.build_load(i_addr, "")
|
||||||
|
.map(BasicValueEnum::into_int_value)
|
||||||
|
.unwrap();
|
||||||
|
let max_val = ctx.builder
|
||||||
|
.build_int_z_extend_or_bit_cast(max_val.0, init_val_t, "")
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
Ok(ctx.builder.build_int_compare(cmp_op, i, max_val, "").unwrap())
|
||||||
|
},
|
||||||
|
|generator, ctx, i_addr| {
|
||||||
|
let i = ctx.builder
|
||||||
|
.build_load(i_addr, "")
|
||||||
|
.map(BasicValueEnum::into_int_value)
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
body(generator, ctx, i)
|
||||||
|
},
|
||||||
|
|_, ctx, i_addr| {
|
||||||
|
let i = ctx.builder
|
||||||
|
.build_load(i_addr, "")
|
||||||
|
.map(BasicValueEnum::into_int_value)
|
||||||
|
.unwrap();
|
||||||
|
let incr_val = ctx.builder
|
||||||
|
.build_int_z_extend_or_bit_cast(incr_val, init_val_t, "")
|
||||||
|
.unwrap();
|
||||||
|
let i = ctx.builder.build_int_add(i, incr_val, "").unwrap();
|
||||||
|
ctx.builder.build_store(i_addr, i).unwrap();
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
},
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
/// See [`CodeGenerator::gen_while`].
|
/// See [`CodeGenerator::gen_while`].
|
||||||
pub fn gen_while<G: CodeGenerator>(
|
pub fn gen_while<G: CodeGenerator>(
|
||||||
generator: &mut G,
|
generator: &mut G,
|
||||||
|
@ -701,8 +782,8 @@ pub fn final_proxy<'ctx>(
|
||||||
|
|
||||||
/// Inserts the declaration of the builtin function with the specified `symbol` name, and returns
|
/// Inserts the declaration of the builtin function with the specified `symbol` name, and returns
|
||||||
/// the function.
|
/// the function.
|
||||||
pub fn get_builtins<'ctx>(
|
pub fn get_builtins<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
generator: &mut dyn CodeGenerator,
|
generator: &mut G,
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
symbol: &str,
|
symbol: &str,
|
||||||
) -> FunctionValue<'ctx> {
|
) -> FunctionValue<'ctx> {
|
||||||
|
@ -795,8 +876,8 @@ pub fn exn_constructor<'ctx>(
|
||||||
///
|
///
|
||||||
/// * `exception` - The exception thrown by the `raise` statement.
|
/// * `exception` - The exception thrown by the `raise` statement.
|
||||||
/// * `loc` - The location where the exception is raised from.
|
/// * `loc` - The location where the exception is raised from.
|
||||||
pub fn gen_raise<'ctx>(
|
pub fn gen_raise<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
generator: &mut dyn CodeGenerator,
|
generator: &mut G,
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
exception: Option<&BasicValueEnum<'ctx>>,
|
exception: Option<&BasicValueEnum<'ctx>>,
|
||||||
loc: Location,
|
loc: Location,
|
||||||
|
|
|
@ -5,11 +5,14 @@ use crate::{
|
||||||
expr::destructure_range,
|
expr::destructure_range,
|
||||||
irrt::*,
|
irrt::*,
|
||||||
llvm_intrinsics::*,
|
llvm_intrinsics::*,
|
||||||
|
numpy::*,
|
||||||
stmt::exn_constructor,
|
stmt::exn_constructor,
|
||||||
},
|
},
|
||||||
symbol_resolver::SymbolValue,
|
symbol_resolver::SymbolValue,
|
||||||
toplevel::helper::PRIMITIVE_DEF_IDS,
|
toplevel::{
|
||||||
toplevel::numpy::*,
|
helper::PRIMITIVE_DEF_IDS,
|
||||||
|
numpy::make_ndarray_ty,
|
||||||
|
},
|
||||||
typecheck::typedef::VarMap,
|
typecheck::typedef::VarMap,
|
||||||
};
|
};
|
||||||
use inkwell::{
|
use inkwell::{
|
||||||
|
|
|
@ -1,24 +1,9 @@
|
||||||
use inkwell::{IntPredicate, types::BasicType, values::{BasicValueEnum, PointerValue}};
|
|
||||||
use inkwell::values::{AggregateValueEnum, ArrayValue, IntValue};
|
|
||||||
use itertools::Itertools;
|
use itertools::Itertools;
|
||||||
use nac3parser::ast::StrRef;
|
|
||||||
use crate::{
|
use crate::{
|
||||||
codegen::{
|
toplevel::helper::PRIMITIVE_DEF_IDS,
|
||||||
classes::{ListValue, NDArrayValue},
|
|
||||||
CodeGenContext,
|
|
||||||
CodeGenerator,
|
|
||||||
irrt::{
|
|
||||||
call_ndarray_calc_nd_indices,
|
|
||||||
call_ndarray_calc_size,
|
|
||||||
},
|
|
||||||
llvm_intrinsics::call_memcpy_generic,
|
|
||||||
stmt::gen_for_callback
|
|
||||||
},
|
|
||||||
symbol_resolver::ValueEnum,
|
|
||||||
toplevel::{DefinitionId, helper::PRIMITIVE_DEF_IDS},
|
|
||||||
typecheck::{
|
typecheck::{
|
||||||
type_inferencer::PrimitiveStore,
|
type_inferencer::PrimitiveStore,
|
||||||
typedef::{FunSignature, Type, TypeEnum, Unifier, VarMap},
|
typedef::{Type, TypeEnum, Unifier, VarMap},
|
||||||
},
|
},
|
||||||
};
|
};
|
||||||
|
|
||||||
|
@ -76,885 +61,3 @@ pub fn unpack_ndarray_tvars(
|
||||||
.collect_tuple()
|
.collect_tuple()
|
||||||
.unwrap()
|
.unwrap()
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Creates an `NDArray` instance from a dynamic shape.
|
|
||||||
///
|
|
||||||
/// * `elem_ty` - The element type of the `NDArray`.
|
|
||||||
/// * `shape` - The shape of the `NDArray`.
|
|
||||||
/// * `shape_len_fn` - A function that retrieves the number of dimensions from `shape`.
|
|
||||||
/// * `shape_data_fn` - A function that retrieves the size of a dimension from `shape`.
|
|
||||||
fn create_ndarray_dyn_shape<'ctx, 'a, V, LenFn, DataFn>(
|
|
||||||
generator: &mut dyn CodeGenerator,
|
|
||||||
ctx: &mut CodeGenContext<'ctx, 'a>,
|
|
||||||
elem_ty: Type,
|
|
||||||
shape: &V,
|
|
||||||
shape_len_fn: LenFn,
|
|
||||||
shape_data_fn: DataFn,
|
|
||||||
) -> Result<NDArrayValue<'ctx>, String>
|
|
||||||
where
|
|
||||||
LenFn: Fn(&mut dyn CodeGenerator, &mut CodeGenContext<'ctx, 'a>, &V) -> Result<IntValue<'ctx>, String>,
|
|
||||||
DataFn: Fn(&mut dyn CodeGenerator, &mut CodeGenContext<'ctx, 'a>, &V, IntValue<'ctx>) -> Result<IntValue<'ctx>, String>,
|
|
||||||
{
|
|
||||||
let ndarray_ty = make_ndarray_ty(&mut ctx.unifier, &ctx.primitives, Some(elem_ty), None);
|
|
||||||
|
|
||||||
let llvm_usize = generator.get_size_type(ctx.ctx);
|
|
||||||
|
|
||||||
let llvm_pndarray_t = ctx.get_llvm_type(generator, ndarray_ty).into_pointer_type();
|
|
||||||
let llvm_ndarray_t = llvm_pndarray_t.get_element_type().into_struct_type();
|
|
||||||
let llvm_ndarray_data_t = ctx.get_llvm_type(generator, elem_ty).as_basic_type_enum();
|
|
||||||
assert!(llvm_ndarray_data_t.is_sized());
|
|
||||||
|
|
||||||
// Assert that all dimensions are non-negative
|
|
||||||
gen_for_callback(
|
|
||||||
generator,
|
|
||||||
ctx,
|
|
||||||
|generator, ctx| {
|
|
||||||
let i = generator.gen_var_alloc(ctx, llvm_usize.into(), None)?;
|
|
||||||
ctx.builder.build_store(i, llvm_usize.const_zero()).unwrap();
|
|
||||||
|
|
||||||
Ok(i)
|
|
||||||
},
|
|
||||||
|generator, ctx, i_addr| {
|
|
||||||
let i = ctx.builder
|
|
||||||
.build_load(i_addr, "")
|
|
||||||
.map(BasicValueEnum::into_int_value)
|
|
||||||
.unwrap();
|
|
||||||
let shape_len = shape_len_fn(generator, ctx, shape)?;
|
|
||||||
debug_assert!(shape_len.get_type().get_bit_width() <= llvm_usize.get_bit_width());
|
|
||||||
|
|
||||||
Ok(ctx.builder.build_int_compare(IntPredicate::ULT, i, shape_len, "").unwrap())
|
|
||||||
},
|
|
||||||
|generator, ctx, i_addr| {
|
|
||||||
let i = ctx.builder
|
|
||||||
.build_load(i_addr, "")
|
|
||||||
.map(BasicValueEnum::into_int_value)
|
|
||||||
.unwrap();
|
|
||||||
let shape_dim = shape_data_fn(generator, ctx, shape, i)?;
|
|
||||||
debug_assert!(shape_dim.get_type().get_bit_width() <= llvm_usize.get_bit_width());
|
|
||||||
|
|
||||||
let shape_dim_gez = ctx.builder
|
|
||||||
.build_int_compare(IntPredicate::SGE, shape_dim, shape_dim.get_type().const_zero(), "")
|
|
||||||
.unwrap();
|
|
||||||
|
|
||||||
ctx.make_assert(
|
|
||||||
generator,
|
|
||||||
shape_dim_gez,
|
|
||||||
"0:ValueError",
|
|
||||||
"negative dimensions not supported",
|
|
||||||
[None, None, None],
|
|
||||||
ctx.current_loc,
|
|
||||||
);
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
},
|
|
||||||
|_, ctx, i_addr| {
|
|
||||||
let i = ctx.builder
|
|
||||||
.build_load(i_addr, "")
|
|
||||||
.map(BasicValueEnum::into_int_value)
|
|
||||||
.unwrap();
|
|
||||||
let i = ctx.builder.build_int_add(i, llvm_usize.const_int(1, true), "").unwrap();
|
|
||||||
ctx.builder.build_store(i_addr, i).unwrap();
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
},
|
|
||||||
)?;
|
|
||||||
|
|
||||||
let ndarray = generator.gen_var_alloc(
|
|
||||||
ctx,
|
|
||||||
llvm_ndarray_t.into(),
|
|
||||||
None,
|
|
||||||
)?;
|
|
||||||
let ndarray = NDArrayValue::from_ptr_val(ndarray, llvm_usize, None);
|
|
||||||
|
|
||||||
let num_dims = shape_len_fn(generator, ctx, shape)?;
|
|
||||||
ndarray.store_ndims(ctx, generator, num_dims);
|
|
||||||
|
|
||||||
let ndarray_num_dims = ndarray.load_ndims(ctx);
|
|
||||||
ndarray.create_dim_sizes(ctx, llvm_usize, ndarray_num_dims);
|
|
||||||
|
|
||||||
// Copy the dimension sizes from shape to ndarray.dims
|
|
||||||
gen_for_callback(
|
|
||||||
generator,
|
|
||||||
ctx,
|
|
||||||
|generator, ctx| {
|
|
||||||
let i = generator.gen_var_alloc(ctx, llvm_usize.into(), None)?;
|
|
||||||
ctx.builder.build_store(i, llvm_usize.const_zero()).unwrap();
|
|
||||||
|
|
||||||
Ok(i)
|
|
||||||
},
|
|
||||||
|generator, ctx, i_addr| {
|
|
||||||
let i = ctx.builder
|
|
||||||
.build_load(i_addr, "")
|
|
||||||
.map(BasicValueEnum::into_int_value)
|
|
||||||
.unwrap();
|
|
||||||
let shape_len = shape_len_fn(generator, ctx, shape)?;
|
|
||||||
debug_assert!(shape_len.get_type().get_bit_width() <= llvm_usize.get_bit_width());
|
|
||||||
|
|
||||||
Ok(ctx.builder.build_int_compare(IntPredicate::ULT, i, shape_len, "").unwrap())
|
|
||||||
},
|
|
||||||
|generator, ctx, i_addr| {
|
|
||||||
let i = ctx.builder
|
|
||||||
.build_load(i_addr, "")
|
|
||||||
.map(BasicValueEnum::into_int_value)
|
|
||||||
.unwrap();
|
|
||||||
let shape_dim = shape_data_fn(generator, ctx, shape, i)?;
|
|
||||||
debug_assert!(shape_dim.get_type().get_bit_width() <= llvm_usize.get_bit_width());
|
|
||||||
let shape_dim = ctx.builder
|
|
||||||
.build_int_z_extend(shape_dim, llvm_usize, "")
|
|
||||||
.unwrap();
|
|
||||||
|
|
||||||
let ndarray_pdim = ndarray.dim_sizes().ptr_offset(ctx, generator, i, None);
|
|
||||||
|
|
||||||
ctx.builder.build_store(ndarray_pdim, shape_dim).unwrap();
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
},
|
|
||||||
|_, ctx, i_addr| {
|
|
||||||
let i = ctx.builder
|
|
||||||
.build_load(i_addr, "")
|
|
||||||
.map(BasicValueEnum::into_int_value)
|
|
||||||
.unwrap();
|
|
||||||
let i = ctx.builder.build_int_add(i, llvm_usize.const_int(1, true), "").unwrap();
|
|
||||||
ctx.builder.build_store(i_addr, i).unwrap();
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
},
|
|
||||||
)?;
|
|
||||||
|
|
||||||
let ndarray_num_elems = call_ndarray_calc_size(
|
|
||||||
generator,
|
|
||||||
ctx,
|
|
||||||
ndarray.load_ndims(ctx),
|
|
||||||
ndarray.dim_sizes().as_ptr_value(ctx),
|
|
||||||
);
|
|
||||||
ndarray.create_data(ctx, llvm_ndarray_data_t, ndarray_num_elems);
|
|
||||||
|
|
||||||
Ok(ndarray)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Creates an `NDArray` instance from a constant shape.
|
|
||||||
///
|
|
||||||
/// * `elem_ty` - The element type of the `NDArray`.
|
|
||||||
/// * `shape` - The shape of the `NDArray`, represented as an LLVM [`ArrayValue`].
|
|
||||||
fn create_ndarray_const_shape<'ctx>(
|
|
||||||
generator: &mut dyn CodeGenerator,
|
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
|
||||||
elem_ty: Type,
|
|
||||||
shape: ArrayValue<'ctx>
|
|
||||||
) -> Result<NDArrayValue<'ctx>, String> {
|
|
||||||
let ndarray_ty = make_ndarray_ty(&mut ctx.unifier, &ctx.primitives, Some(elem_ty), None);
|
|
||||||
|
|
||||||
let llvm_usize = generator.get_size_type(ctx.ctx);
|
|
||||||
|
|
||||||
let llvm_pndarray_t = ctx.get_llvm_type(generator, ndarray_ty).into_pointer_type();
|
|
||||||
let llvm_ndarray_t = llvm_pndarray_t.get_element_type().into_struct_type();
|
|
||||||
let llvm_ndarray_data_t = ctx.get_llvm_type(generator, elem_ty).as_basic_type_enum();
|
|
||||||
assert!(llvm_ndarray_data_t.is_sized());
|
|
||||||
|
|
||||||
for i in 0..shape.get_type().len() {
|
|
||||||
let shape_dim = ctx.builder
|
|
||||||
.build_extract_value(shape, i, "")
|
|
||||||
.map(BasicValueEnum::into_int_value)
|
|
||||||
.unwrap();
|
|
||||||
|
|
||||||
let shape_dim_gez = ctx.builder
|
|
||||||
.build_int_compare(IntPredicate::SGE, shape_dim, llvm_usize.const_zero(), "")
|
|
||||||
.unwrap();
|
|
||||||
|
|
||||||
ctx.make_assert(
|
|
||||||
generator,
|
|
||||||
shape_dim_gez,
|
|
||||||
"0:ValueError",
|
|
||||||
"negative dimensions not supported",
|
|
||||||
[None, None, None],
|
|
||||||
ctx.current_loc,
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
let ndarray = generator.gen_var_alloc(
|
|
||||||
ctx,
|
|
||||||
llvm_ndarray_t.into(),
|
|
||||||
None,
|
|
||||||
)?;
|
|
||||||
let ndarray = NDArrayValue::from_ptr_val(ndarray, llvm_usize, None);
|
|
||||||
|
|
||||||
let num_dims = llvm_usize.const_int(shape.get_type().len() as u64, false);
|
|
||||||
ndarray.store_ndims(ctx, generator, num_dims);
|
|
||||||
|
|
||||||
let ndarray_num_dims = ndarray.load_ndims(ctx);
|
|
||||||
ndarray.create_dim_sizes(ctx, llvm_usize, ndarray_num_dims);
|
|
||||||
|
|
||||||
for i in 0..shape.get_type().len() {
|
|
||||||
let ndarray_dim = ndarray
|
|
||||||
.dim_sizes()
|
|
||||||
.ptr_offset(ctx, generator, llvm_usize.const_int(i as u64, true), None);
|
|
||||||
let shape_dim = ctx.builder.build_extract_value(shape, i, "")
|
|
||||||
.map(BasicValueEnum::into_int_value)
|
|
||||||
.unwrap();
|
|
||||||
|
|
||||||
ctx.builder.build_store(ndarray_dim, shape_dim).unwrap();
|
|
||||||
}
|
|
||||||
|
|
||||||
let ndarray_dims = ndarray.dim_sizes().as_ptr_value(ctx);
|
|
||||||
let ndarray_num_elems = call_ndarray_calc_size(
|
|
||||||
generator,
|
|
||||||
ctx,
|
|
||||||
ndarray.load_ndims(ctx),
|
|
||||||
ndarray_dims,
|
|
||||||
);
|
|
||||||
ndarray.create_data(ctx, llvm_ndarray_data_t, ndarray_num_elems);
|
|
||||||
|
|
||||||
Ok(ndarray)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn ndarray_zero_value<'ctx>(
|
|
||||||
generator: &mut dyn CodeGenerator,
|
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
|
||||||
elem_ty: Type,
|
|
||||||
) -> BasicValueEnum<'ctx> {
|
|
||||||
if [ctx.primitives.int32, ctx.primitives.uint32].iter().any(|ty| ctx.unifier.unioned(elem_ty, *ty)) {
|
|
||||||
ctx.ctx.i32_type().const_zero().into()
|
|
||||||
} else if [ctx.primitives.int64, ctx.primitives.uint64].iter().any(|ty| ctx.unifier.unioned(elem_ty, *ty)) {
|
|
||||||
ctx.ctx.i64_type().const_zero().into()
|
|
||||||
} else if ctx.unifier.unioned(elem_ty, ctx.primitives.float) {
|
|
||||||
ctx.ctx.f64_type().const_zero().into()
|
|
||||||
} else if ctx.unifier.unioned(elem_ty, ctx.primitives.bool) {
|
|
||||||
ctx.ctx.bool_type().const_zero().into()
|
|
||||||
} else if ctx.unifier.unioned(elem_ty, ctx.primitives.str) {
|
|
||||||
ctx.gen_string(generator, "")
|
|
||||||
} else {
|
|
||||||
unreachable!()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn ndarray_one_value<'ctx>(
|
|
||||||
generator: &mut dyn CodeGenerator,
|
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
|
||||||
elem_ty: Type,
|
|
||||||
) -> BasicValueEnum<'ctx> {
|
|
||||||
if [ctx.primitives.int32, ctx.primitives.uint32].iter().any(|ty| ctx.unifier.unioned(elem_ty, *ty)) {
|
|
||||||
let is_signed = ctx.unifier.unioned(elem_ty, ctx.primitives.int32);
|
|
||||||
ctx.ctx.i32_type().const_int(1, is_signed).into()
|
|
||||||
} else if [ctx.primitives.int64, ctx.primitives.uint64].iter().any(|ty| ctx.unifier.unioned(elem_ty, *ty)) {
|
|
||||||
let is_signed = ctx.unifier.unioned(elem_ty, ctx.primitives.int64);
|
|
||||||
ctx.ctx.i64_type().const_int(1, is_signed).into()
|
|
||||||
} else if ctx.unifier.unioned(elem_ty, ctx.primitives.float) {
|
|
||||||
ctx.ctx.f64_type().const_float(1.0).into()
|
|
||||||
} else if ctx.unifier.unioned(elem_ty, ctx.primitives.bool) {
|
|
||||||
ctx.ctx.bool_type().const_int(1, false).into()
|
|
||||||
} else if ctx.unifier.unioned(elem_ty, ctx.primitives.str) {
|
|
||||||
ctx.gen_string(generator, "1")
|
|
||||||
} else {
|
|
||||||
unreachable!()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// LLVM-typed implementation for generating the implementation for constructing an `NDArray`.
|
|
||||||
///
|
|
||||||
/// * `elem_ty` - The element type of the `NDArray`.
|
|
||||||
/// * `shape` - The `shape` parameter used to construct the `NDArray`.
|
|
||||||
fn call_ndarray_empty_impl<'ctx>(
|
|
||||||
generator: &mut dyn CodeGenerator,
|
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
|
||||||
elem_ty: Type,
|
|
||||||
shape: ListValue<'ctx>,
|
|
||||||
) -> Result<NDArrayValue<'ctx>, String> {
|
|
||||||
create_ndarray_dyn_shape(
|
|
||||||
generator,
|
|
||||||
ctx,
|
|
||||||
elem_ty,
|
|
||||||
&shape,
|
|
||||||
|_, ctx, shape| {
|
|
||||||
Ok(shape.load_size(ctx, None))
|
|
||||||
},
|
|
||||||
|generator, ctx, shape, idx| {
|
|
||||||
Ok(shape.data().get(ctx, generator, idx, None).into_int_value())
|
|
||||||
},
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Generates LLVM IR for populating the entire `NDArray` using a lambda with its flattened index as
|
|
||||||
/// its input.
|
|
||||||
fn ndarray_fill_flattened<'ctx, 'a, ValueFn>(
|
|
||||||
generator: &mut dyn CodeGenerator,
|
|
||||||
ctx: &mut CodeGenContext<'ctx, 'a>,
|
|
||||||
ndarray: NDArrayValue<'ctx>,
|
|
||||||
value_fn: ValueFn,
|
|
||||||
) -> Result<(), String>
|
|
||||||
where
|
|
||||||
ValueFn: Fn(&mut dyn CodeGenerator, &mut CodeGenContext<'ctx, 'a>, IntValue<'ctx>) -> Result<BasicValueEnum<'ctx>, String>,
|
|
||||||
{
|
|
||||||
let llvm_usize = generator.get_size_type(ctx.ctx);
|
|
||||||
|
|
||||||
let ndarray_num_elems = call_ndarray_calc_size(
|
|
||||||
generator,
|
|
||||||
ctx,
|
|
||||||
ndarray.load_ndims(ctx),
|
|
||||||
ndarray.dim_sizes().as_ptr_value(ctx),
|
|
||||||
);
|
|
||||||
|
|
||||||
gen_for_callback(
|
|
||||||
generator,
|
|
||||||
ctx,
|
|
||||||
|generator, ctx| {
|
|
||||||
let i = generator.gen_var_alloc(ctx, llvm_usize.into(), None)?;
|
|
||||||
ctx.builder.build_store(i, llvm_usize.const_zero()).unwrap();
|
|
||||||
|
|
||||||
Ok(i)
|
|
||||||
},
|
|
||||||
|_, ctx, i_addr| {
|
|
||||||
let i = ctx.builder
|
|
||||||
.build_load(i_addr, "")
|
|
||||||
.map(BasicValueEnum::into_int_value)
|
|
||||||
.unwrap();
|
|
||||||
|
|
||||||
Ok(ctx.builder.build_int_compare(IntPredicate::ULT, i, ndarray_num_elems, "").unwrap())
|
|
||||||
},
|
|
||||||
|generator, ctx, i_addr| {
|
|
||||||
let i = ctx.builder
|
|
||||||
.build_load(i_addr, "")
|
|
||||||
.map(BasicValueEnum::into_int_value)
|
|
||||||
.unwrap();
|
|
||||||
let elem = unsafe {
|
|
||||||
ndarray.data().ptr_to_data_flattened_unchecked(ctx, i, None)
|
|
||||||
};
|
|
||||||
|
|
||||||
let value = value_fn(generator, ctx, i)?;
|
|
||||||
ctx.builder.build_store(elem, value).unwrap();
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
},
|
|
||||||
|_, ctx, i_addr| {
|
|
||||||
let i = ctx.builder
|
|
||||||
.build_load(i_addr, "")
|
|
||||||
.map(BasicValueEnum::into_int_value)
|
|
||||||
.unwrap();
|
|
||||||
let i = ctx.builder.build_int_add(i, llvm_usize.const_int(1, true), "").unwrap();
|
|
||||||
ctx.builder.build_store(i_addr, i).unwrap();
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
},
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Generates LLVM IR for populating the entire `NDArray` using a lambda with the dimension-indices
|
|
||||||
/// as its input.
|
|
||||||
fn ndarray_fill_indexed<'ctx, ValueFn>(
|
|
||||||
generator: &mut dyn CodeGenerator,
|
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
|
||||||
ndarray: NDArrayValue<'ctx>,
|
|
||||||
value_fn: ValueFn,
|
|
||||||
) -> Result<(), String>
|
|
||||||
where
|
|
||||||
ValueFn: Fn(&mut dyn CodeGenerator, &mut CodeGenContext<'ctx, '_>, PointerValue<'ctx>) -> Result<BasicValueEnum<'ctx>, String>,
|
|
||||||
{
|
|
||||||
ndarray_fill_flattened(
|
|
||||||
generator,
|
|
||||||
ctx,
|
|
||||||
ndarray,
|
|
||||||
|generator, ctx, idx| {
|
|
||||||
let indices = call_ndarray_calc_nd_indices(
|
|
||||||
generator,
|
|
||||||
ctx,
|
|
||||||
idx,
|
|
||||||
ndarray,
|
|
||||||
);
|
|
||||||
|
|
||||||
value_fn(generator, ctx, indices)
|
|
||||||
}
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// LLVM-typed implementation for generating the implementation for `ndarray.zeros`.
|
|
||||||
///
|
|
||||||
/// * `elem_ty` - The element type of the `NDArray`.
|
|
||||||
/// * `shape` - The `shape` parameter used to construct the `NDArray`.
|
|
||||||
fn call_ndarray_zeros_impl<'ctx>(
|
|
||||||
generator: &mut dyn CodeGenerator,
|
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
|
||||||
elem_ty: Type,
|
|
||||||
shape: ListValue<'ctx>,
|
|
||||||
) -> Result<NDArrayValue<'ctx>, String> {
|
|
||||||
let supported_types = [
|
|
||||||
ctx.primitives.int32,
|
|
||||||
ctx.primitives.int64,
|
|
||||||
ctx.primitives.uint32,
|
|
||||||
ctx.primitives.uint64,
|
|
||||||
ctx.primitives.float,
|
|
||||||
ctx.primitives.bool,
|
|
||||||
ctx.primitives.str,
|
|
||||||
];
|
|
||||||
assert!(supported_types.iter().any(|supported_ty| ctx.unifier.unioned(*supported_ty, elem_ty)));
|
|
||||||
|
|
||||||
let ndarray = call_ndarray_empty_impl(generator, ctx, elem_ty, shape)?;
|
|
||||||
ndarray_fill_flattened(
|
|
||||||
generator,
|
|
||||||
ctx,
|
|
||||||
ndarray,
|
|
||||||
|generator, ctx, _| {
|
|
||||||
let value = ndarray_zero_value(generator, ctx, elem_ty);
|
|
||||||
|
|
||||||
Ok(value)
|
|
||||||
}
|
|
||||||
)?;
|
|
||||||
|
|
||||||
Ok(ndarray)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// LLVM-typed implementation for generating the implementation for `ndarray.ones`.
|
|
||||||
///
|
|
||||||
/// * `elem_ty` - The element type of the `NDArray`.
|
|
||||||
/// * `shape` - The `shape` parameter used to construct the `NDArray`.
|
|
||||||
fn call_ndarray_ones_impl<'ctx>(
|
|
||||||
generator: &mut dyn CodeGenerator,
|
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
|
||||||
elem_ty: Type,
|
|
||||||
shape: ListValue<'ctx>,
|
|
||||||
) -> Result<NDArrayValue<'ctx>, String> {
|
|
||||||
let supported_types = [
|
|
||||||
ctx.primitives.int32,
|
|
||||||
ctx.primitives.int64,
|
|
||||||
ctx.primitives.uint32,
|
|
||||||
ctx.primitives.uint64,
|
|
||||||
ctx.primitives.float,
|
|
||||||
ctx.primitives.bool,
|
|
||||||
ctx.primitives.str,
|
|
||||||
];
|
|
||||||
assert!(supported_types.iter().any(|supported_ty| ctx.unifier.unioned(*supported_ty, elem_ty)));
|
|
||||||
|
|
||||||
let ndarray = call_ndarray_empty_impl(generator, ctx, elem_ty, shape)?;
|
|
||||||
ndarray_fill_flattened(
|
|
||||||
generator,
|
|
||||||
ctx,
|
|
||||||
ndarray,
|
|
||||||
|generator, ctx, _| {
|
|
||||||
let value = ndarray_one_value(generator, ctx, elem_ty);
|
|
||||||
|
|
||||||
Ok(value)
|
|
||||||
}
|
|
||||||
)?;
|
|
||||||
|
|
||||||
Ok(ndarray)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// LLVM-typed implementation for generating the implementation for `ndarray.full`.
|
|
||||||
///
|
|
||||||
/// * `elem_ty` - The element type of the `NDArray`.
|
|
||||||
/// * `shape` - The `shape` parameter used to construct the `NDArray`.
|
|
||||||
fn call_ndarray_full_impl<'ctx>(
|
|
||||||
generator: &mut dyn CodeGenerator,
|
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
|
||||||
elem_ty: Type,
|
|
||||||
shape: ListValue<'ctx>,
|
|
||||||
fill_value: BasicValueEnum<'ctx>,
|
|
||||||
) -> Result<NDArrayValue<'ctx>, String> {
|
|
||||||
let ndarray = call_ndarray_empty_impl(generator, ctx, elem_ty, shape)?;
|
|
||||||
ndarray_fill_flattened(
|
|
||||||
generator,
|
|
||||||
ctx,
|
|
||||||
ndarray,
|
|
||||||
|generator, ctx, _| {
|
|
||||||
let value = if fill_value.is_pointer_value() {
|
|
||||||
let llvm_i1 = ctx.ctx.bool_type();
|
|
||||||
|
|
||||||
let copy = generator.gen_var_alloc(ctx, fill_value.get_type(), None)?;
|
|
||||||
|
|
||||||
call_memcpy_generic(
|
|
||||||
ctx,
|
|
||||||
copy,
|
|
||||||
fill_value.into_pointer_value(),
|
|
||||||
fill_value.get_type().size_of().map(Into::into).unwrap(),
|
|
||||||
llvm_i1.const_zero(),
|
|
||||||
);
|
|
||||||
|
|
||||||
copy.into()
|
|
||||||
} else if fill_value.is_int_value() || fill_value.is_float_value() {
|
|
||||||
fill_value
|
|
||||||
} else {
|
|
||||||
unreachable!()
|
|
||||||
};
|
|
||||||
|
|
||||||
Ok(value)
|
|
||||||
}
|
|
||||||
)?;
|
|
||||||
|
|
||||||
Ok(ndarray)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// LLVM-typed implementation for generating the implementation for `ndarray.eye`.
|
|
||||||
///
|
|
||||||
/// * `elem_ty` - The element type of the `NDArray`.
|
|
||||||
fn call_ndarray_eye_impl<'ctx>(
|
|
||||||
generator: &mut dyn CodeGenerator,
|
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
|
||||||
elem_ty: Type,
|
|
||||||
nrows: IntValue<'ctx>,
|
|
||||||
ncols: IntValue<'ctx>,
|
|
||||||
offset: IntValue<'ctx>,
|
|
||||||
) -> Result<NDArrayValue<'ctx>, String> {
|
|
||||||
let llvm_usize = generator.get_size_type(ctx.ctx);
|
|
||||||
let llvm_usize_2 = llvm_usize.array_type(2);
|
|
||||||
|
|
||||||
let shape_addr = generator.gen_var_alloc(ctx, llvm_usize_2.into(), None)?;
|
|
||||||
|
|
||||||
let shape = ctx.builder.build_load(shape_addr, "")
|
|
||||||
.map(BasicValueEnum::into_array_value)
|
|
||||||
.unwrap();
|
|
||||||
|
|
||||||
let nrows = ctx.builder.build_int_z_extend_or_bit_cast(nrows, llvm_usize, "").unwrap();
|
|
||||||
let shape = ctx.builder
|
|
||||||
.build_insert_value(shape, nrows, 0, "")
|
|
||||||
.map(AggregateValueEnum::into_array_value)
|
|
||||||
.unwrap();
|
|
||||||
|
|
||||||
let ncols = ctx.builder.build_int_z_extend_or_bit_cast(ncols, llvm_usize, "").unwrap();
|
|
||||||
let shape = ctx.builder
|
|
||||||
.build_insert_value(shape, ncols, 1, "")
|
|
||||||
.map(AggregateValueEnum::into_array_value)
|
|
||||||
.unwrap();
|
|
||||||
|
|
||||||
let ndarray = create_ndarray_const_shape(generator, ctx, elem_ty, shape)?;
|
|
||||||
|
|
||||||
ndarray_fill_indexed(
|
|
||||||
generator,
|
|
||||||
ctx,
|
|
||||||
ndarray,
|
|
||||||
|generator, ctx, indices| {
|
|
||||||
let row = ctx.build_gep_and_load(
|
|
||||||
indices,
|
|
||||||
&[llvm_usize.const_int(0, false)],
|
|
||||||
None,
|
|
||||||
).into_int_value();
|
|
||||||
let col = ctx.build_gep_and_load(
|
|
||||||
indices,
|
|
||||||
&[llvm_usize.const_int(1, false)],
|
|
||||||
None,
|
|
||||||
).into_int_value();
|
|
||||||
|
|
||||||
let col_with_offset = ctx.builder
|
|
||||||
.build_int_add(
|
|
||||||
col,
|
|
||||||
ctx.builder.build_int_s_extend_or_bit_cast(offset, llvm_usize, "").unwrap(),
|
|
||||||
"",
|
|
||||||
)
|
|
||||||
.unwrap();
|
|
||||||
let is_on_diag = ctx.builder
|
|
||||||
.build_int_compare(IntPredicate::EQ, row, col_with_offset, "")
|
|
||||||
.unwrap();
|
|
||||||
|
|
||||||
let zero = ndarray_zero_value(generator, ctx, elem_ty);
|
|
||||||
let one = ndarray_one_value(generator, ctx, elem_ty);
|
|
||||||
|
|
||||||
let value = ctx.builder.build_select(is_on_diag, one, zero, "").unwrap();
|
|
||||||
|
|
||||||
Ok(value)
|
|
||||||
},
|
|
||||||
)?;
|
|
||||||
|
|
||||||
Ok(ndarray)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// LLVM-typed implementation for generating the implementation for `ndarray.copy`.
|
|
||||||
///
|
|
||||||
/// * `elem_ty` - The element type of the `NDArray`.
|
|
||||||
fn ndarray_copy_impl<'ctx>(
|
|
||||||
generator: &mut dyn CodeGenerator,
|
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
|
||||||
elem_ty: Type,
|
|
||||||
this: NDArrayValue<'ctx>,
|
|
||||||
) -> Result<NDArrayValue<'ctx>, String> {
|
|
||||||
let llvm_i1 = ctx.ctx.bool_type();
|
|
||||||
|
|
||||||
let ndarray = create_ndarray_dyn_shape(
|
|
||||||
generator,
|
|
||||||
ctx,
|
|
||||||
elem_ty,
|
|
||||||
&this,
|
|
||||||
|_, ctx, shape| {
|
|
||||||
Ok(shape.load_ndims(ctx))
|
|
||||||
},
|
|
||||||
|generator, ctx, shape, idx| {
|
|
||||||
Ok(shape.dim_sizes().get(ctx, generator, idx, None))
|
|
||||||
},
|
|
||||||
)?;
|
|
||||||
|
|
||||||
let len = call_ndarray_calc_size(
|
|
||||||
generator,
|
|
||||||
ctx,
|
|
||||||
ndarray.load_ndims(ctx),
|
|
||||||
ndarray.dim_sizes().as_ptr_value(ctx),
|
|
||||||
);
|
|
||||||
let sizeof_ty = ctx.get_llvm_type(generator, elem_ty);
|
|
||||||
let len_bytes = ctx.builder
|
|
||||||
.build_int_mul(
|
|
||||||
len,
|
|
||||||
sizeof_ty.size_of().unwrap(),
|
|
||||||
"",
|
|
||||||
)
|
|
||||||
.unwrap();
|
|
||||||
|
|
||||||
call_memcpy_generic(
|
|
||||||
ctx,
|
|
||||||
ndarray.data().as_ptr_value(ctx),
|
|
||||||
this.data().as_ptr_value(ctx),
|
|
||||||
len_bytes,
|
|
||||||
llvm_i1.const_zero(),
|
|
||||||
);
|
|
||||||
|
|
||||||
Ok(ndarray)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Generates LLVM IR for `ndarray.empty`.
|
|
||||||
pub fn gen_ndarray_empty<'ctx>(
|
|
||||||
context: &mut CodeGenContext<'ctx, '_>,
|
|
||||||
obj: &Option<(Type, ValueEnum<'ctx>)>,
|
|
||||||
fun: (&FunSignature, DefinitionId),
|
|
||||||
args: &[(Option<StrRef>, ValueEnum<'ctx>)],
|
|
||||||
generator: &mut dyn CodeGenerator,
|
|
||||||
) -> Result<PointerValue<'ctx>, String> {
|
|
||||||
assert!(obj.is_none());
|
|
||||||
assert_eq!(args.len(), 1);
|
|
||||||
|
|
||||||
let llvm_usize = generator.get_size_type(context.ctx);
|
|
||||||
let shape_ty = fun.0.args[0].ty;
|
|
||||||
let shape_arg = args[0].1.clone()
|
|
||||||
.to_basic_value_enum(context, generator, shape_ty)?;
|
|
||||||
|
|
||||||
call_ndarray_empty_impl(
|
|
||||||
generator,
|
|
||||||
context,
|
|
||||||
context.primitives.float,
|
|
||||||
ListValue::from_ptr_val(shape_arg.into_pointer_value(), llvm_usize, None),
|
|
||||||
).map(NDArrayValue::into)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Generates LLVM IR for `ndarray.zeros`.
|
|
||||||
pub fn gen_ndarray_zeros<'ctx>(
|
|
||||||
context: &mut CodeGenContext<'ctx, '_>,
|
|
||||||
obj: &Option<(Type, ValueEnum<'ctx>)>,
|
|
||||||
fun: (&FunSignature, DefinitionId),
|
|
||||||
args: &[(Option<StrRef>, ValueEnum<'ctx>)],
|
|
||||||
generator: &mut dyn CodeGenerator,
|
|
||||||
) -> Result<PointerValue<'ctx>, String> {
|
|
||||||
assert!(obj.is_none());
|
|
||||||
assert_eq!(args.len(), 1);
|
|
||||||
|
|
||||||
let llvm_usize = generator.get_size_type(context.ctx);
|
|
||||||
let shape_ty = fun.0.args[0].ty;
|
|
||||||
let shape_arg = args[0].1.clone()
|
|
||||||
.to_basic_value_enum(context, generator, shape_ty)?;
|
|
||||||
|
|
||||||
call_ndarray_zeros_impl(
|
|
||||||
generator,
|
|
||||||
context,
|
|
||||||
context.primitives.float,
|
|
||||||
ListValue::from_ptr_val(shape_arg.into_pointer_value(), llvm_usize, None),
|
|
||||||
).map(NDArrayValue::into)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Generates LLVM IR for `ndarray.ones`.
|
|
||||||
pub fn gen_ndarray_ones<'ctx>(
|
|
||||||
context: &mut CodeGenContext<'ctx, '_>,
|
|
||||||
obj: &Option<(Type, ValueEnum<'ctx>)>,
|
|
||||||
fun: (&FunSignature, DefinitionId),
|
|
||||||
args: &[(Option<StrRef>, ValueEnum<'ctx>)],
|
|
||||||
generator: &mut dyn CodeGenerator,
|
|
||||||
) -> Result<PointerValue<'ctx>, String> {
|
|
||||||
assert!(obj.is_none());
|
|
||||||
assert_eq!(args.len(), 1);
|
|
||||||
|
|
||||||
let llvm_usize = generator.get_size_type(context.ctx);
|
|
||||||
let shape_ty = fun.0.args[0].ty;
|
|
||||||
let shape_arg = args[0].1.clone()
|
|
||||||
.to_basic_value_enum(context, generator, shape_ty)?;
|
|
||||||
|
|
||||||
call_ndarray_ones_impl(
|
|
||||||
generator,
|
|
||||||
context,
|
|
||||||
context.primitives.float,
|
|
||||||
ListValue::from_ptr_val(shape_arg.into_pointer_value(), llvm_usize, None),
|
|
||||||
).map(NDArrayValue::into)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Generates LLVM IR for `ndarray.full`.
|
|
||||||
pub fn gen_ndarray_full<'ctx>(
|
|
||||||
context: &mut CodeGenContext<'ctx, '_>,
|
|
||||||
obj: &Option<(Type, ValueEnum<'ctx>)>,
|
|
||||||
fun: (&FunSignature, DefinitionId),
|
|
||||||
args: &[(Option<StrRef>, ValueEnum<'ctx>)],
|
|
||||||
generator: &mut dyn CodeGenerator,
|
|
||||||
) -> Result<PointerValue<'ctx>, String> {
|
|
||||||
assert!(obj.is_none());
|
|
||||||
assert_eq!(args.len(), 2);
|
|
||||||
|
|
||||||
let llvm_usize = generator.get_size_type(context.ctx);
|
|
||||||
let shape_ty = fun.0.args[0].ty;
|
|
||||||
let shape_arg = args[0].1.clone()
|
|
||||||
.to_basic_value_enum(context, generator, shape_ty)?;
|
|
||||||
let fill_value_ty = fun.0.args[1].ty;
|
|
||||||
let fill_value_arg = args[1].1.clone()
|
|
||||||
.to_basic_value_enum(context, generator, fill_value_ty)?;
|
|
||||||
|
|
||||||
call_ndarray_full_impl(
|
|
||||||
generator,
|
|
||||||
context,
|
|
||||||
fill_value_ty,
|
|
||||||
ListValue::from_ptr_val(shape_arg.into_pointer_value(), llvm_usize, None),
|
|
||||||
fill_value_arg,
|
|
||||||
).map(NDArrayValue::into)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Generates LLVM IR for `ndarray.eye`.
|
|
||||||
pub fn gen_ndarray_eye<'ctx>(
|
|
||||||
context: &mut CodeGenContext<'ctx, '_>,
|
|
||||||
obj: &Option<(Type, ValueEnum<'ctx>)>,
|
|
||||||
fun: (&FunSignature, DefinitionId),
|
|
||||||
args: &[(Option<StrRef>, ValueEnum<'ctx>)],
|
|
||||||
generator: &mut dyn CodeGenerator,
|
|
||||||
) -> Result<PointerValue<'ctx>, String> {
|
|
||||||
assert!(obj.is_none());
|
|
||||||
assert!(matches!(args.len(), 1..=3));
|
|
||||||
|
|
||||||
let nrows_ty = fun.0.args[0].ty;
|
|
||||||
let nrows_arg = args[0].1.clone()
|
|
||||||
.to_basic_value_enum(context, generator, nrows_ty)?;
|
|
||||||
|
|
||||||
let ncols_ty = fun.0.args[1].ty;
|
|
||||||
let ncols_arg = args.iter()
|
|
||||||
.find(|arg| arg.0.is_some_and(|name| name == fun.0.args[1].name))
|
|
||||||
.map(|arg| arg.1.clone().to_basic_value_enum(context, generator, ncols_ty))
|
|
||||||
.unwrap_or_else(|| {
|
|
||||||
args[0].1.clone().to_basic_value_enum(context, generator, nrows_ty)
|
|
||||||
})?;
|
|
||||||
|
|
||||||
let offset_ty = fun.0.args[2].ty;
|
|
||||||
let offset_arg = args.iter()
|
|
||||||
.find(|arg| arg.0.is_some_and(|name| name == fun.0.args[2].name))
|
|
||||||
.map(|arg| arg.1.clone().to_basic_value_enum(context, generator, offset_ty))
|
|
||||||
.unwrap_or_else(|| {
|
|
||||||
Ok(context.gen_symbol_val(
|
|
||||||
generator,
|
|
||||||
fun.0.args[2].default_value.as_ref().unwrap(),
|
|
||||||
offset_ty
|
|
||||||
))
|
|
||||||
})?;
|
|
||||||
|
|
||||||
call_ndarray_eye_impl(
|
|
||||||
generator,
|
|
||||||
context,
|
|
||||||
context.primitives.float,
|
|
||||||
nrows_arg.into_int_value(),
|
|
||||||
ncols_arg.into_int_value(),
|
|
||||||
offset_arg.into_int_value(),
|
|
||||||
).map(NDArrayValue::into)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Generates LLVM IR for `ndarray.identity`.
|
|
||||||
pub fn gen_ndarray_identity<'ctx>(
|
|
||||||
context: &mut CodeGenContext<'ctx, '_>,
|
|
||||||
obj: &Option<(Type, ValueEnum<'ctx>)>,
|
|
||||||
fun: (&FunSignature, DefinitionId),
|
|
||||||
args: &[(Option<StrRef>, ValueEnum<'ctx>)],
|
|
||||||
generator: &mut dyn CodeGenerator,
|
|
||||||
) -> Result<PointerValue<'ctx>, String> {
|
|
||||||
assert!(obj.is_none());
|
|
||||||
assert_eq!(args.len(), 1);
|
|
||||||
|
|
||||||
let llvm_usize = generator.get_size_type(context.ctx);
|
|
||||||
|
|
||||||
let n_ty = fun.0.args[0].ty;
|
|
||||||
let n_arg = args[0].1.clone()
|
|
||||||
.to_basic_value_enum(context, generator, n_ty)?;
|
|
||||||
|
|
||||||
call_ndarray_eye_impl(
|
|
||||||
generator,
|
|
||||||
context,
|
|
||||||
context.primitives.float,
|
|
||||||
n_arg.into_int_value(),
|
|
||||||
n_arg.into_int_value(),
|
|
||||||
llvm_usize.const_zero(),
|
|
||||||
).map(NDArrayValue::into)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Generates LLVM IR for `ndarray.copy`.
|
|
||||||
pub fn gen_ndarray_copy<'ctx>(
|
|
||||||
context: &mut CodeGenContext<'ctx, '_>,
|
|
||||||
obj: &Option<(Type, ValueEnum<'ctx>)>,
|
|
||||||
_fun: (&FunSignature, DefinitionId),
|
|
||||||
args: &[(Option<StrRef>, ValueEnum<'ctx>)],
|
|
||||||
generator: &mut dyn CodeGenerator,
|
|
||||||
) -> Result<PointerValue<'ctx>, String> {
|
|
||||||
assert!(obj.is_some());
|
|
||||||
assert!(args.is_empty());
|
|
||||||
|
|
||||||
let llvm_usize = generator.get_size_type(context.ctx);
|
|
||||||
|
|
||||||
let this_ty = obj.as_ref().unwrap().0;
|
|
||||||
let (this_elem_ty, _) = unpack_ndarray_tvars(&mut context.unifier, this_ty);
|
|
||||||
let this_arg = obj
|
|
||||||
.as_ref()
|
|
||||||
.unwrap()
|
|
||||||
.1
|
|
||||||
.clone()
|
|
||||||
.to_basic_value_enum(context, generator, this_ty)?;
|
|
||||||
|
|
||||||
ndarray_copy_impl(
|
|
||||||
generator,
|
|
||||||
context,
|
|
||||||
this_elem_ty,
|
|
||||||
NDArrayValue::from_ptr_val(this_arg.into_pointer_value(), llvm_usize, None),
|
|
||||||
).map(NDArrayValue::into)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Generates LLVM IR for `ndarray.fill`.
|
|
||||||
pub fn gen_ndarray_fill<'ctx>(
|
|
||||||
context: &mut CodeGenContext<'ctx, '_>,
|
|
||||||
obj: &Option<(Type, ValueEnum<'ctx>)>,
|
|
||||||
fun: (&FunSignature, DefinitionId),
|
|
||||||
args: &[(Option<StrRef>, ValueEnum<'ctx>)],
|
|
||||||
generator: &mut dyn CodeGenerator,
|
|
||||||
) -> Result<(), String> {
|
|
||||||
assert!(obj.is_some());
|
|
||||||
assert_eq!(args.len(), 1);
|
|
||||||
|
|
||||||
let llvm_usize = generator.get_size_type(context.ctx);
|
|
||||||
|
|
||||||
let this_ty = obj.as_ref().unwrap().0;
|
|
||||||
let this_arg = obj.as_ref().unwrap().1.clone()
|
|
||||||
.to_basic_value_enum(context, generator, this_ty)?
|
|
||||||
.into_pointer_value();
|
|
||||||
let value_ty = fun.0.args[0].ty;
|
|
||||||
let value_arg = args[0].1.clone()
|
|
||||||
.to_basic_value_enum(context, generator, value_ty)?;
|
|
||||||
|
|
||||||
ndarray_fill_flattened(
|
|
||||||
generator,
|
|
||||||
context,
|
|
||||||
NDArrayValue::from_ptr_val(this_arg, llvm_usize, None),
|
|
||||||
|generator, ctx, _| {
|
|
||||||
let value = if value_arg.is_pointer_value() {
|
|
||||||
let llvm_i1 = ctx.ctx.bool_type();
|
|
||||||
|
|
||||||
let copy = generator.gen_var_alloc(ctx, value_arg.get_type(), None)?;
|
|
||||||
|
|
||||||
call_memcpy_generic(
|
|
||||||
ctx,
|
|
||||||
copy,
|
|
||||||
value_arg.into_pointer_value(),
|
|
||||||
value_arg.get_type().size_of().map(Into::into).unwrap(),
|
|
||||||
llvm_i1.const_zero(),
|
|
||||||
);
|
|
||||||
|
|
||||||
copy.into()
|
|
||||||
} else if value_arg.is_int_value() || value_arg.is_float_value() {
|
|
||||||
value_arg
|
|
||||||
} else {
|
|
||||||
unreachable!()
|
|
||||||
};
|
|
||||||
|
|
||||||
Ok(value)
|
|
||||||
}
|
|
||||||
)?;
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
|
@ -699,7 +699,7 @@ impl Unifier {
|
||||||
self.set_a_to_b(a, x);
|
self.set_a_to_b(a, x);
|
||||||
}
|
}
|
||||||
(TVar { fields: Some(fields), range, is_const_generic: false, .. }, TTuple { ty }) => {
|
(TVar { fields: Some(fields), range, is_const_generic: false, .. }, TTuple { ty }) => {
|
||||||
let len = ty.len() as i32;
|
let len = i32::try_from(ty.len()).unwrap();
|
||||||
for (k, v) in fields {
|
for (k, v) in fields {
|
||||||
match *k {
|
match *k {
|
||||||
RecordKey::Int(i) => {
|
RecordKey::Int(i) => {
|
||||||
|
|
|
@ -74,7 +74,8 @@ impl SymbolResolver for Resolver {
|
||||||
if let Some(id) = str_store.get(s) {
|
if let Some(id) = str_store.get(s) {
|
||||||
*id
|
*id
|
||||||
} else {
|
} else {
|
||||||
let id = str_store.len() as i32;
|
let id = i32::try_from(str_store.len())
|
||||||
|
.expect("Symbol resolver string store size exceeds max capacity (i32::MAX)");
|
||||||
str_store.insert(s.to_string(), id);
|
str_store.insert(s.to_string(), id);
|
||||||
id
|
id
|
||||||
}
|
}
|
||||||
|
|
|
@ -247,6 +247,8 @@ fn handle_assignment_pattern(
|
||||||
}
|
}
|
||||||
|
|
||||||
fn main() {
|
fn main() {
|
||||||
|
const SIZE_T: u32 = usize::BITS;
|
||||||
|
|
||||||
let cli = CommandLineArgs::parse();
|
let cli = CommandLineArgs::parse();
|
||||||
let CommandLineArgs {
|
let CommandLineArgs {
|
||||||
file_name,
|
file_name,
|
||||||
|
@ -287,7 +289,6 @@ fn main() {
|
||||||
// The default behavior for -O<n> where n>3 defaults to O3 for both Clang and GCC
|
// The default behavior for -O<n> where n>3 defaults to O3 for both Clang and GCC
|
||||||
_ => OptimizationLevel::Aggressive,
|
_ => OptimizationLevel::Aggressive,
|
||||||
};
|
};
|
||||||
const SIZE_T: u32 = 64;
|
|
||||||
|
|
||||||
let program = match fs::read_to_string(file_name.clone()) {
|
let program = match fs::read_to_string(file_name.clone()) {
|
||||||
Ok(program) => program,
|
Ok(program) => program,
|
||||||
|
|
Loading…
Reference in New Issue