From 5ba8601b39ffb991b519ca8df305d3e14cd87665 Mon Sep 17 00:00:00 2001 From: David Mak Date: Fri, 22 Mar 2024 16:57:36 +0800 Subject: [PATCH] core: Remove ArrayValue variants of functions These will be lowered and optimized away later anyways, and we have ArrayLikeAccessor now. --- nac3core/src/codegen/expr.rs | 9 ++++-- nac3core/src/codegen/irrt/mod.rs | 46 +------------------------- nac3core/src/codegen/numpy.rs | 55 +++++++++++--------------------- 3 files changed, 27 insertions(+), 83 deletions(-) diff --git a/nac3core/src/codegen/expr.rs b/nac3core/src/codegen/expr.rs index c110d0c6..ea8211a8 100644 --- a/nac3core/src/codegen/expr.rs +++ b/nac3core/src/codegen/expr.rs @@ -5,6 +5,7 @@ use crate::{ classes::{ ArrayLikeIndexer, ArrayLikeValue, + ArraySliceValue, ListValue, NDArrayValue, RangeValue, @@ -1265,12 +1266,14 @@ fn gen_ndarray_subscript_expr<'ctx, G: CodeGenerator>( } else { return Ok(None) }; + let index_addr = generator.gen_var_alloc(ctx, index.get_type().into(), None)?; + ctx.builder.build_store(index_addr, index).unwrap(); Ok(Some(v.data() .get( ctx, generator, - ctx.ctx.i32_type().const_array(&[index]), + ArraySliceValue::from_ptr_val(index_addr, llvm_usize.const_int(1, false), None), None, ) .into())) @@ -1286,6 +1289,8 @@ fn gen_ndarray_subscript_expr<'ctx, G: CodeGenerator>( } else { return Ok(None) }; + let index_addr = generator.gen_var_alloc(ctx, index.get_type().into(), None)?; + ctx.builder.build_store(index_addr, index).unwrap(); // Create a new array, remove the top dimension from the dimension-size-list, and copy the // elements over @@ -1340,7 +1345,7 @@ fn gen_ndarray_subscript_expr<'ctx, G: CodeGenerator>( let v_data_src_ptr = v.data().ptr_offset( ctx, generator, - ctx.ctx.i32_type().const_array(&[index]), + ArraySliceValue::from_ptr_val(index_addr, llvm_usize.const_int(1, false), None), None ); call_memcpy_generic( diff --git a/nac3core/src/codegen/irrt/mod.rs b/nac3core/src/codegen/irrt/mod.rs index 005de188..6da048fe 100644 --- a/nac3core/src/codegen/irrt/mod.rs +++ b/nac3core/src/codegen/irrt/mod.rs @@ -8,7 +8,6 @@ use super::{ ListValue, NDArrayValue, TypedArrayLikeAdapter, - UntypedArrayLikeMutator, }, CodeGenContext, CodeGenerator, @@ -19,7 +18,7 @@ use inkwell::{ memory_buffer::MemoryBuffer, module::Module, types::{BasicTypeEnum, IntType}, - values::{ArrayValue, BasicValueEnum, CallSiteValue, FloatValue, IntValue}, + values::{BasicValueEnum, CallSiteValue, FloatValue, IntValue}, AddressSpace, IntPredicate, }; use itertools::Either; @@ -784,47 +783,4 @@ pub fn call_ndarray_flatten_index<'ctx, G, Index>( ndarray, indices, ) -} -/// Generates a call to `__nac3_ndarray_flatten_index`. Returns the flattened index for the -/// multidimensional index. -/// -/// * `ndarray` - LLVM pointer to the `NDArray`. This value must be the LLVM representation of an -/// `NDArray`. -/// * `indices` - The multidimensional index to compute the flattened index for. -pub fn call_ndarray_flatten_index_const<'ctx, G: CodeGenerator + ?Sized>( - generator: &mut G, - ctx: &mut CodeGenContext<'ctx, '_>, - ndarray: NDArrayValue<'ctx>, - indices: ArrayValue<'ctx>, -) -> IntValue<'ctx> { - let llvm_usize = generator.get_size_type(ctx.ctx); - - let indices_size = indices.get_type().len(); - let indices_alloca = generator.gen_array_var_alloc( - ctx, - indices.get_type().get_element_type(), - llvm_usize.const_int(indices_size as u64, false), - None, - ).unwrap(); - for i in 0..indices_size { - let v = ctx.builder.build_extract_value(indices, i, "") - .unwrap() - .into_int_value(); - - unsafe { - indices_alloca.set_unchecked( - ctx, - generator, - ctx.ctx.i32_type().const_int(i as u64, false), - v.into(), - ); - } - } - - call_ndarray_flatten_index_impl( - generator, - ctx, - ndarray, - &indices_alloca, - ) } \ No newline at end of file diff --git a/nac3core/src/codegen/numpy.rs b/nac3core/src/codegen/numpy.rs index d90b4182..4cc84070 100644 --- a/nac3core/src/codegen/numpy.rs +++ b/nac3core/src/codegen/numpy.rs @@ -1,7 +1,7 @@ use inkwell::{ IntPredicate, types::BasicType, - values::{AggregateValueEnum, ArrayValue, BasicValueEnum, IntValue, PointerValue} + values::{BasicValueEnum, IntValue, PointerValue} }; use nac3parser::ast::StrRef; use crate::{ @@ -140,12 +140,12 @@ fn create_ndarray_dyn_shape<'ctx, 'a, G, V, LenFn, DataFn>( /// 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`]. +/// * `shape` - The shape of the `NDArray`, represented am array of [`IntValue`]s. fn create_ndarray_const_shape<'ctx, G: CodeGenerator + ?Sized>( generator: &mut G, ctx: &mut CodeGenContext<'ctx, '_>, elem_ty: Type, - shape: ArrayValue<'ctx> + shape: &[IntValue<'ctx>], ) -> Result, String> { let ndarray_ty = make_ndarray_ty(&mut ctx.unifier, &ctx.primitives, Some(elem_ty), None); @@ -156,14 +156,9 @@ fn create_ndarray_const_shape<'ctx, G: CodeGenerator + ?Sized>( 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(); - + for shape_dim in shape { let shape_dim_gez = ctx.builder - .build_int_compare(IntPredicate::SGE, shape_dim, llvm_usize.const_zero(), "") + .build_int_compare(IntPredicate::SGE, *shape_dim, llvm_usize.const_zero(), "") .unwrap(); ctx.make_assert( @@ -183,21 +178,20 @@ fn create_ndarray_const_shape<'ctx, G: CodeGenerator + ?Sized>( )?; let ndarray = NDArrayValue::from_ptr_val(ndarray, llvm_usize, None); - let num_dims = llvm_usize.const_int(shape.get_type().len() as u64, false); + let num_dims = llvm_usize.const_int(shape.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(); + for (i, shape_dim) in shape.iter().enumerate() { + let ndarray_dim = unsafe { + ndarray + .dim_sizes() + .ptr_offset_unchecked(ctx, generator, llvm_usize.const_int(i as u64, true), None) + }; - ctx.builder.build_store(ndarray_dim, shape_dim).unwrap(); + ctx.builder.build_store(ndarray_dim, *shape_dim).unwrap(); } let ndarray_num_elems = call_ndarray_calc_size( @@ -473,27 +467,16 @@ fn call_ndarray_eye_impl<'ctx, G: CodeGenerator + ?Sized>( ) -> Result, String> { let llvm_i32 = ctx.ctx.i32_type(); 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)?; + let ndarray = create_ndarray_const_shape( + generator, + ctx, + elem_ty, + &[nrows, ncols], + )?; ndarray_fill_indexed( generator,