From febe78b6a429685a95a3a7b1365d05b31dfb9048 Mon Sep 17 00:00:00 2001 From: lyken Date: Wed, 14 Aug 2024 11:34:42 +0800 Subject: [PATCH] WIP: core/ndstrides: rename .value to .instance in *Object --- nac3core/src/codegen/expr.rs | 6 +- nac3core/src/codegen/numpy_new.rs | 32 ++++---- nac3core/src/codegen/object/list.rs | 8 +- nac3core/src/codegen/object/ndarray/array.rs | 16 ++-- .../src/codegen/object/ndarray/broadcast.rs | 6 +- .../src/codegen/object/ndarray/functions.rs | 73 ++++++++++--------- .../src/codegen/object/ndarray/indexing.rs | 4 +- .../src/codegen/object/ndarray/mapping.rs | 2 +- nac3core/src/codegen/object/ndarray/mod.rs | 58 ++++++++------- .../src/codegen/object/ndarray/nalgebra.rs | 1 + .../src/codegen/object/ndarray/product.rs | 12 +-- nac3core/src/codegen/object/ndarray/scalar.rs | 14 ++-- .../src/codegen/object/ndarray/shape_util.rs | 4 +- nac3core/src/toplevel/builtins.rs | 24 +++--- 14 files changed, 136 insertions(+), 124 deletions(-) diff --git a/nac3core/src/codegen/expr.rs b/nac3core/src/codegen/expr.rs index b5631fef..e65f3bbb 100644 --- a/nac3core/src/codegen/expr.rs +++ b/nac3core/src/codegen/expr.rs @@ -1570,16 +1570,16 @@ pub fn gen_binop_expr_with_values<'ctx, G: CodeGenerator>( gen_binop_expr_with_values( generator, ctx, - (&Some(left.dtype), left.value), + (&Some(left.dtype), left.instance), op, - (&Some(right.dtype), right.value), + (&Some(right.dtype), right.instance), ctx.current_loc, )? .unwrap() .to_basic_value_enum(ctx, generator, common_dtype) }, )?; - Ok(Some(ValueEnum::Dynamic(result.value.value.as_basic_value_enum()))) + Ok(Some(ValueEnum::Dynamic(result.instance.value.as_basic_value_enum()))) } } else { let left_ty_enum = ctx.unifier.get_ty_immutable(left_ty.unwrap()); diff --git a/nac3core/src/codegen/numpy_new.rs b/nac3core/src/codegen/numpy_new.rs index 5d259d98..e574980d 100644 --- a/nac3core/src/codegen/numpy_new.rs +++ b/nac3core/src/codegen/numpy_new.rs @@ -125,7 +125,7 @@ pub fn gen_ndarray_empty<'ctx>( let ndarray_ty = fun.0.ret; let ndarray = create_empty_ndarray(generator, ctx, ndarray_ty, shape, shape_ty); - Ok(ndarray.value.value.as_basic_value_enum()) + Ok(ndarray.instance.value.as_basic_value_enum()) } /// Generates LLVM IR for `np.zero`. @@ -150,7 +150,7 @@ pub fn gen_ndarray_zeros<'ctx>( let fill_value = ndarray_zero_value(generator, ctx, ndarray.dtype); ndarray.fill(generator, ctx, fill_value); - Ok(ndarray.value.value.as_basic_value_enum()) + Ok(ndarray.instance.value.as_basic_value_enum()) } /// Generates LLVM IR for `np.ones`. @@ -175,7 +175,7 @@ pub fn gen_ndarray_ones<'ctx>( let fill_value = ndarray_one_value(generator, ctx, ndarray.dtype); ndarray.fill(generator, ctx, fill_value); - Ok(ndarray.value.value.as_basic_value_enum()) + Ok(ndarray.instance.value.as_basic_value_enum()) } /// Generates LLVM IR for `np.full`. @@ -203,7 +203,7 @@ pub fn gen_ndarray_full<'ctx>( ndarray.fill(generator, ctx, fill_value); - Ok(ndarray.value.value.as_basic_value_enum()) + Ok(ndarray.instance.value.as_basic_value_enum()) } /// Generates LLVM IR for `np.broadcast_to`. @@ -252,7 +252,7 @@ pub fn gen_ndarray_broadcast_to<'ctx>( let broadcast_ndarray = in_ndarray.broadcast_to(generator, ctx, broadcast_ndims, broadcast_shape); - Ok(broadcast_ndarray.value.value.as_basic_value_enum()) + Ok(broadcast_ndarray.instance.value.as_basic_value_enum()) } /// Generates LLVM IR for `np.reshape`. @@ -288,7 +288,7 @@ pub fn gen_ndarray_reshape<'ctx>( let (_, new_shape) = parse_numpy_int_sequence(generator, ctx, shape, shape_ty); let reshaped_ndarray = in_ndarray.reshape_or_copy(generator, ctx, reshaped_ndims, new_shape); - Ok(reshaped_ndarray.value.value.as_basic_value_enum()) + Ok(reshaped_ndarray.instance.value.as_basic_value_enum()) } /// Generates LLVM IR for `np.arange`. @@ -324,7 +324,7 @@ pub fn gen_ndarray_arange<'ctx>( // `ndarray.shape[0] = input` let zero = sizet_model.const_0(generator, ctx.ctx); ndarray - .value + .instance .get(generator, ctx, |f| f.shape, "shape") .offset(generator, ctx, zero.value, "dim") .store(ctx, input); @@ -338,7 +338,7 @@ pub fn gen_ndarray_arange<'ctx>( Ok(()) })?; - Ok(ndarray.value.value.as_basic_value_enum()) + Ok(ndarray.instance.value.as_basic_value_enum()) } /// Generates LLVM IR for `np.size`. @@ -386,8 +386,10 @@ pub fn gen_ndarray_shape<'ctx>( for i in 0..ndarray.ndims { let i = sizet_model.constant(generator, ctx.ctx, i); - let dim = - ndarray.value.get(generator, ctx, |f| f.shape, "").ix(generator, ctx, i.value, "dim"); + let dim = ndarray + .instance + .get(generator, ctx, |f| f.shape, "") + .ix(generator, ctx, i.value, "dim"); let dim = dim.truncate(generator, ctx, Int32, "dim"); // TODO: keep using SizeT items.push((dim.value.as_basic_value_enum(), ctx.primitives.int32)); @@ -424,8 +426,10 @@ pub fn gen_ndarray_strides<'ctx>( for i in 0..ndarray.ndims { let i = sizet_model.constant(generator, ctx.ctx, i); - let dim = - ndarray.value.get(generator, ctx, |f| f.strides, "").ix(generator, ctx, i.value, "dim"); + let dim = ndarray + .instance + .get(generator, ctx, |f| f.strides, "") + .ix(generator, ctx, i.value, "dim"); let dim = dim.truncate(generator, ctx, Int32, "dim"); // TODO: keep using SizeT items.push((dim.value.as_basic_value_enum(), ctx.primitives.int32)); @@ -471,7 +475,7 @@ pub fn gen_ndarray_transpose<'ctx>( ndarray.transpose(generator, ctx, None) }; - Ok(transposed_ndarray.value.value.as_basic_value_enum()) + Ok(transposed_ndarray.instance.value.as_basic_value_enum()) } pub fn gen_ndarray_array<'ctx>( @@ -515,5 +519,5 @@ pub fn gen_ndarray_array<'ctx>( let ndarray = ndarray.atleast_nd(generator, ctx, output_ndims); debug_assert!(ctx.unifier.unioned(ndarray.dtype, dtype)); // Sanity check on `dtype` - Ok(ndarray.value.value.as_basic_value_enum()) + Ok(ndarray.instance.value.as_basic_value_enum()) } diff --git a/nac3core/src/codegen/object/list.rs b/nac3core/src/codegen/object/list.rs index 2b46487c..89b43650 100644 --- a/nac3core/src/codegen/object/list.rs +++ b/nac3core/src/codegen/object/list.rs @@ -10,7 +10,7 @@ use crate::{ pub struct ListObject<'ctx> { /// Typechecker type of the list items pub item_type: Type, - pub value: Ptr<'ctx, StructModel>>>, + pub instance: Ptr<'ctx, StructModel>>>, } impl<'ctx> ListObject<'ctx> { @@ -38,7 +38,7 @@ impl<'ctx> ListObject<'ctx> { // Create object let value = plist_model.check_value(generator, ctx.ctx, list_val).unwrap(); - ListObject { item_type, value } + ListObject { item_type, instance: value } } /// Get the `items` field as an opaque pointer. @@ -47,7 +47,7 @@ impl<'ctx> ListObject<'ctx> { generator: &mut G, ctx: &mut CodeGenContext<'ctx, '_>, ) -> Ptr<'ctx, IntModel> { - self.value.get(generator, ctx, |f| f.items, "items").pointer_cast( + self.instance.get(generator, ctx, |f| f.items, "items").pointer_cast( generator, ctx, IntModel(Byte), @@ -71,7 +71,7 @@ impl<'ctx> ListObject<'ctx> { opaque_list_ptr.set(ctx, |f| f.items, items); // Copy len - let len = self.value.get(generator, ctx, |f| f.len, "len"); + let len = self.instance.get(generator, ctx, |f| f.len, "len"); opaque_list_ptr.set(ctx, |f| f.len, len); opaque_list_ptr diff --git a/nac3core/src/codegen/object/ndarray/array.rs b/nac3core/src/codegen/object/ndarray/array.rs index 5eb70b35..7d03a355 100644 --- a/nac3core/src/codegen/object/ndarray/array.rs +++ b/nac3core/src/codegen/object/ndarray/array.rs @@ -54,7 +54,7 @@ impl<'ctx> NDArrayObject<'ctx> { ndarray.create_data(generator, ctx); // Copy all contents from the list. - call_nac3_array_write_list_to_array(generator, ctx, list_value, ndarray.value); + call_nac3_array_write_list_to_array(generator, ctx, list_value, ndarray.instance); ndarray } @@ -85,13 +85,13 @@ impl<'ctx> NDArrayObject<'ctx> { // Set data let data = list.get_opaque_items_ptr(generator, ctx); - ndarray.value.set(ctx, |f| f.data, data); + ndarray.instance.set(ctx, |f| f.data, data); // Set shape // dim = list->len; // shape[0] = dim; - let shape = ndarray.value.get(generator, ctx, |f| f.shape, "shape"); - let dim = list.value.get(generator, ctx, |f| f.len, "dim"); + let shape = ndarray.instance.get(generator, ctx, |f| f.shape, "shape"); + let dim = list.instance.get(generator, ctx, |f| f.len, "dim"); shape.offset(generator, ctx, zero.value, "pdim").store(ctx, dim); // Set strides, the `data` is contiguous @@ -119,11 +119,11 @@ impl<'ctx> NDArrayObject<'ctx> { |_generator, _ctx| Ok(copy.value), |generator, ctx| { let ndarray = NDArrayObject::from_np_array_list_copy(generator, ctx, list); - Ok(Some(ndarray.value.value)) + Ok(Some(ndarray.instance.value)) }, |generator, ctx| { let ndarray = NDArrayObject::from_np_array_list_try_no_copy(generator, ctx, list); - Ok(Some(ndarray.value.value)) + Ok(Some(ndarray.instance.value)) }, ) .unwrap() @@ -144,11 +144,11 @@ impl<'ctx> NDArrayObject<'ctx> { |_generator, _ctx| Ok(copy.value), |generator, ctx| { let ndarray = ndarray.make_clone(generator, ctx, "np_array_copied_ndarray"); // Force copy - Ok(Some(ndarray.value.value)) + Ok(Some(ndarray.instance.value)) }, |_generator, _ctx| { // No need to copy. Return `ndarray` itself. - Ok(Some(ndarray.value.value)) + Ok(Some(ndarray.instance.value)) }, ) .unwrap() diff --git a/nac3core/src/codegen/object/ndarray/broadcast.rs b/nac3core/src/codegen/object/ndarray/broadcast.rs index 89ad7a5c..ff4d92a4 100644 --- a/nac3core/src/codegen/object/ndarray/broadcast.rs +++ b/nac3core/src/codegen/object/ndarray/broadcast.rs @@ -49,7 +49,7 @@ impl<'ctx> NDArrayObject<'ctx> { ); broadcast_ndarray.copy_shape_from_array(generator, ctx, target_shape); - call_nac3_ndarray_broadcast_to(generator, ctx, self.value, broadcast_ndarray.value); + call_nac3_ndarray_broadcast_to(generator, ctx, self.instance, broadcast_ndarray.instance); broadcast_ndarray } } @@ -125,7 +125,9 @@ impl<'ctx> NDArrayObject<'ctx> { let shape_entries = ndarrays .iter() - .map(|ndarray| (ndarray.value.get(generator, ctx, |f| f.shape, "shape"), ndarray.ndims)) + .map(|ndarray| { + (ndarray.instance.get(generator, ctx, |f| f.shape, "shape"), ndarray.ndims) + }) .collect_vec(); broadcast_shapes(generator, ctx, &shape_entries, broadcast_ndims_int, broadcast_shape); diff --git a/nac3core/src/codegen/object/ndarray/functions.rs b/nac3core/src/codegen/object/ndarray/functions.rs index 69d35b21..5fa0e530 100644 --- a/nac3core/src/codegen/object/ndarray/functions.rs +++ b/nac3core/src/codegen/object/ndarray/functions.rs @@ -80,10 +80,10 @@ where let result = if ctx.unifier.unioned(scalar.dtype, ctx.primitives.float) { // Special handling for floats - let n = scalar.value.into_float_value(); + let n = scalar.instance.into_float_value(); handle_float(generator, ctx, n) } else if ctx.unifier.unioned_any(scalar.dtype, int_like(ctx)) { - let n = scalar.value.into_int_value(); + let n = scalar.instance.into_int_value(); if n.get_type().get_bit_width() <= ret_int_dtype_llvm.get_bit_width() { ctx.builder.build_int_z_extend(n, ret_int_dtype_llvm, "zext").unwrap() @@ -95,7 +95,7 @@ where }; assert_eq!(ret_int_dtype_llvm.get_bit_width(), result.get_type().get_bit_width()); // Sanity check - ScalarObject { value: result.into(), dtype: ret_int_dtype } + ScalarObject { instance: result.into(), dtype: ret_int_dtype } } impl<'ctx> ScalarObject<'ctx> { @@ -104,7 +104,7 @@ impl<'ctx> ScalarObject<'ctx> { /// Panic if the type is wrong. pub fn into_float64(&self, ctx: &mut CodeGenContext<'ctx, '_>) -> FloatValue<'ctx> { if ctx.unifier.unioned(self.dtype, ctx.primitives.float) { - self.value.into_float_value() // self.value must be a FloatValue + self.instance.into_float_value() // self.value must be a FloatValue } else { panic!("not a float type") } @@ -115,7 +115,7 @@ impl<'ctx> ScalarObject<'ctx> { /// Panic if the type is wrong. pub fn into_int32(&self, ctx: &mut CodeGenContext<'ctx, '_>) -> IntValue<'ctx> { if ctx.unifier.unioned(self.dtype, ctx.primitives.int32) { - let value = self.value.into_int_value(); + let value = self.instance.into_int_value(); debug_assert_eq!(value.get_type().get_bit_width(), 32); // Sanity check value } else { @@ -142,12 +142,12 @@ impl<'ctx> ScalarObject<'ctx> { let common_ty = lhs.dtype; let result = if ctx.unifier.unioned(common_ty, ctx.primitives.float) { - let lhs = lhs.value.into_float_value(); - let rhs = rhs.value.into_float_value(); + let lhs = lhs.instance.into_float_value(); + let rhs = rhs.instance.into_float_value(); ctx.builder.build_float_compare(float_predicate, lhs, rhs, name).unwrap() } else if ctx.unifier.unioned_any(common_ty, int_like(ctx)) { - let lhs = lhs.value.into_int_value(); - let rhs = rhs.value.into_int_value(); + let lhs = lhs.instance.into_int_value(); + let rhs = rhs.instance.into_int_value(); ctx.builder.build_int_compare(int_predicate, lhs, rhs, name).unwrap() } else { unsupported_type(ctx, [lhs.dtype, rhs.dtype]); @@ -266,14 +266,14 @@ impl<'ctx> ScalarObject<'ctx> { pub fn cast_to_bool(&self, ctx: &mut CodeGenContext<'ctx, '_>) -> Self { // TODO: Why is the original code being so lax about i1 and i8 for the returned int type? let result = if ctx.unifier.unioned(self.dtype, ctx.primitives.bool) { - self.value.into_int_value() + self.instance.into_int_value() } else if ctx.unifier.unioned_any(self.dtype, ints(ctx)) { - let n = self.value.into_int_value(); + let n = self.instance.into_int_value(); ctx.builder .build_int_compare(inkwell::IntPredicate::NE, n, n.get_type().const_zero(), "bool") .unwrap() } else if ctx.unifier.unioned(self.dtype, ctx.primitives.float) { - let n = self.value.into_float_value(); + let n = self.instance.into_float_value(); ctx.builder .build_float_compare(FloatPredicate::UNE, n, n.get_type().const_zero(), "bool") .unwrap() @@ -281,7 +281,7 @@ impl<'ctx> ScalarObject<'ctx> { unsupported_type(ctx, [self.dtype]) }; - ScalarObject { dtype: ctx.primitives.bool, value: result.as_basic_value_enum() } + ScalarObject { dtype: ctx.primitives.bool, instance: result.as_basic_value_enum() } } /// Invoke NAC3's builtin `float()`. @@ -290,21 +290,21 @@ impl<'ctx> ScalarObject<'ctx> { let llvm_f64 = ctx.ctx.f64_type(); let result: FloatValue<'_> = if ctx.unifier.unioned(self.dtype, ctx.primitives.float) { - self.value.into_float_value() + self.instance.into_float_value() } else if ctx .unifier .unioned_any(self.dtype, [signed_ints(ctx).as_slice(), &[ctx.primitives.bool]].concat()) { - let n = self.value.into_int_value(); + let n = self.instance.into_int_value(); ctx.builder.build_signed_int_to_float(n, llvm_f64, "sitofp").unwrap() } else if ctx.unifier.unioned_any(self.dtype, unsigned_ints(ctx)) { - let n = self.value.into_int_value(); + let n = self.instance.into_int_value(); ctx.builder.build_unsigned_int_to_float(n, llvm_f64, "uitofp").unwrap() } else { unsupported_type(ctx, [self.dtype]); }; - ScalarObject { value: result.as_basic_value_enum(), dtype: ctx.primitives.float } + ScalarObject { instance: result.as_basic_value_enum(), dtype: ctx.primitives.float } } /// Invoke NAC3's builtin `round()`. @@ -318,13 +318,13 @@ impl<'ctx> ScalarObject<'ctx> { let ret_int_dtype_llvm = ctx.get_llvm_type(generator, ret_int_dtype).into_int_type(); let result = if ctx.unifier.unioned(self.dtype, ctx.primitives.float) { - let n = self.value.into_float_value(); + let n = self.instance.into_float_value(); let n = llvm_intrinsics::call_float_round(ctx, n, None); ctx.builder.build_float_to_signed_int(n, ret_int_dtype_llvm, "round").unwrap() } else { unsupported_type(ctx, [self.dtype, ret_int_dtype]) }; - ScalarObject { dtype: ret_int_dtype, value: result.as_basic_value_enum() } + ScalarObject { dtype: ret_int_dtype, instance: result.as_basic_value_enum() } } /// Invoke NAC3's builtin `np_round()`. @@ -333,12 +333,12 @@ impl<'ctx> ScalarObject<'ctx> { #[must_use] pub fn np_round(&self, ctx: &mut CodeGenContext<'ctx, '_>) -> Self { let result = if ctx.unifier.unioned(self.dtype, ctx.primitives.float) { - let n = self.value.into_float_value(); + let n = self.instance.into_float_value(); llvm_intrinsics::call_float_rint(ctx, n, None) } else { unsupported_type(ctx, [self.dtype]) }; - ScalarObject { dtype: ctx.primitives.float, value: result.as_basic_value_enum() } + ScalarObject { dtype: ctx.primitives.float, instance: result.as_basic_value_enum() } } /// Invoke NAC3's builtin `min()` or `max()`. @@ -360,8 +360,8 @@ impl<'ctx> ScalarObject<'ctx> { MinOrMax::Max => llvm_intrinsics::call_float_maxnum, }; let result = - function(ctx, a.value.into_float_value(), b.value.into_float_value(), None); - ScalarObject { value: result.as_basic_value_enum(), dtype: ctx.primitives.float } + function(ctx, a.instance.into_float_value(), b.instance.into_float_value(), None); + ScalarObject { instance: result.as_basic_value_enum(), dtype: ctx.primitives.float } } else if ctx.unifier.unioned_any( common_dtype, [unsigned_ints(ctx).as_slice(), &[ctx.primitives.bool]].concat(), @@ -371,8 +371,9 @@ impl<'ctx> ScalarObject<'ctx> { MinOrMax::Min => llvm_intrinsics::call_int_umin, MinOrMax::Max => llvm_intrinsics::call_int_umax, }; - let result = function(ctx, a.value.into_int_value(), b.value.into_int_value(), None); - ScalarObject { value: result.as_basic_value_enum(), dtype: common_dtype } + let result = + function(ctx, a.instance.into_int_value(), b.instance.into_int_value(), None); + ScalarObject { instance: result.as_basic_value_enum(), dtype: common_dtype } } else { unsupported_type(ctx, [common_dtype]) } @@ -398,11 +399,11 @@ impl<'ctx> ScalarObject<'ctx> { FloorOrCeil::Floor => llvm_intrinsics::call_float_floor, FloorOrCeil::Ceil => llvm_intrinsics::call_float_ceil, }; - let n = self.value.into_float_value(); + let n = self.instance.into_float_value(); let n = function(ctx, n, None); let n = ctx.builder.build_float_to_signed_int(n, ret_int_dtype_llvm, "").unwrap(); - ScalarObject { dtype: ret_int_dtype, value: n.as_basic_value_enum() } + ScalarObject { dtype: ret_int_dtype, instance: n.as_basic_value_enum() } } else { unsupported_type(ctx, [self.dtype]) } @@ -418,9 +419,9 @@ impl<'ctx> ScalarObject<'ctx> { FloorOrCeil::Floor => llvm_intrinsics::call_float_floor, FloorOrCeil::Ceil => llvm_intrinsics::call_float_ceil, }; - let n = self.value.into_float_value(); + let n = self.instance.into_float_value(); let n = function(ctx, n, None); - ScalarObject { dtype: ctx.primitives.float, value: n.as_basic_value_enum() } + ScalarObject { dtype: ctx.primitives.float, instance: n.as_basic_value_enum() } } else { unsupported_type(ctx, [self.dtype]) } @@ -430,16 +431,16 @@ impl<'ctx> ScalarObject<'ctx> { #[must_use] pub fn abs(&self, ctx: &mut CodeGenContext<'ctx, '_>) -> Self { if ctx.unifier.unioned(self.dtype, ctx.primitives.float) { - let n = self.value.into_float_value(); + let n = self.instance.into_float_value(); let n = llvm_intrinsics::call_float_fabs(ctx, n, Some("abs")); - ScalarObject { value: n.into(), dtype: ctx.primitives.float } + ScalarObject { instance: n.into(), dtype: ctx.primitives.float } } else if ctx.unifier.unioned_any(self.dtype, ints(ctx)) { - let n = self.value.into_int_value(); + let n = self.instance.into_int_value(); let is_poisoned = ctx.ctx.bool_type().const_zero(); // is_poisoned = false let n = llvm_intrinsics::call_int_abs(ctx, n, is_poisoned, Some("abs")); - ScalarObject { value: n.into(), dtype: self.dtype } + ScalarObject { instance: n.into(), dtype: self.dtype } } else { unsupported_type(ctx, [self.dtype]) } @@ -481,7 +482,7 @@ impl<'ctx> NDArrayObject<'ctx> { pextremum_index.store(ctx, zero); let first_scalar = self.get_nth(generator, ctx, zero); - ctx.builder.build_store(pextremum, first_scalar.value).unwrap(); + ctx.builder.build_store(pextremum, first_scalar.instance).unwrap(); // Find extremum let start = sizet_model.const_1(generator, ctx.ctx); // Start on 1 @@ -494,7 +495,7 @@ impl<'ctx> NDArrayObject<'ctx> { let scalar = self.get_nth(generator, ctx, i); let old_extremum = ctx.builder.build_load(pextremum, "current_extremum").unwrap(); - let old_extremum = ScalarObject { dtype: self.dtype, value: old_extremum }; + let old_extremum = ScalarObject { dtype: self.dtype, instance: old_extremum }; let new_extremum = ScalarObject::min_or_max(ctx, kind, old_extremum, scalar); @@ -522,7 +523,7 @@ impl<'ctx> NDArrayObject<'ctx> { let extremum_index = pextremum_index.load(generator, ctx, "extremum_index"); let extremum = ctx.builder.build_load(pextremum, "extremum_value").unwrap(); - let extremum = ScalarObject { dtype: self.dtype, value: extremum }; + let extremum = ScalarObject { dtype: self.dtype, instance: extremum }; (extremum, extremum_index) } diff --git a/nac3core/src/codegen/object/ndarray/indexing.rs b/nac3core/src/codegen/object/ndarray/indexing.rs index 72ccf797..36e230f1 100644 --- a/nac3core/src/codegen/object/ndarray/indexing.rs +++ b/nac3core/src/codegen/object/ndarray/indexing.rs @@ -224,8 +224,8 @@ impl<'ctx> NDArrayObject<'ctx> { ctx, num_indexes, indexes, - self.value, - dst_ndarray.value, + self.instance, + dst_ndarray.instance, ); dst_ndarray diff --git a/nac3core/src/codegen/object/ndarray/mapping.rs b/nac3core/src/codegen/object/ndarray/mapping.rs index 234a56e7..f2633f32 100644 --- a/nac3core/src/codegen/object/ndarray/mapping.rs +++ b/nac3core/src/codegen/object/ndarray/mapping.rs @@ -137,7 +137,7 @@ impl<'ctx> ScalarOrNDArray<'ctx> { if let Some(scalars) = all_scalars { let i = sizet_model.const_0(generator, ctx.ctx); // Pass 0 as the index let scalar = - ScalarObject { value: mapping(generator, ctx, i, &scalars)?, dtype: ret_dtype }; + ScalarObject { instance: mapping(generator, ctx, i, &scalars)?, dtype: ret_dtype }; Ok(ScalarOrNDArray::Scalar(scalar)) } else { // Promote all input to ndarrays and map through them. diff --git a/nac3core/src/codegen/object/ndarray/mod.rs b/nac3core/src/codegen/object/ndarray/mod.rs index 2549c343..7c3d4896 100644 --- a/nac3core/src/codegen/object/ndarray/mod.rs +++ b/nac3core/src/codegen/object/ndarray/mod.rs @@ -40,7 +40,7 @@ use util::{call_memcpy_model, gen_for_model_auto}; pub struct NDArrayObject<'ctx> { pub dtype: Type, pub ndims: u64, - pub value: Ptr<'ctx, StructModel>, + pub instance: Ptr<'ctx, StructModel>, } impl<'ctx> NDArrayObject<'ctx> { @@ -67,7 +67,7 @@ impl<'ctx> NDArrayObject<'ctx> { ) -> Self { let pndarray_model = PtrModel(StructModel(NDArray)); let value = pndarray_model.check_value(generator, ctx.ctx, value).unwrap(); - NDArrayObject { dtype, ndims, value } + NDArrayObject { dtype, ndims, instance: value } } /// Create a [`SimpleNDArray`] from the contents of this ndarray. @@ -106,7 +106,7 @@ impl<'ctx> NDArrayObject<'ctx> { let ndims = self.get_ndims(generator, ctx.ctx); result.set(ctx, |f| f.ndims, ndims); - let shape = self.value.get(generator, ctx, |f| f.shape, "shape"); + let shape = self.instance.get(generator, ctx, |f| f.shape, "shape"); result.set(ctx, |f| f.shape, shape); // Set data, but we do things differently if this ndarray is contiguous. @@ -114,7 +114,7 @@ impl<'ctx> NDArrayObject<'ctx> { ctx.builder.build_conditional_branch(is_contiguous.value, then_bb, else_bb).unwrap(); // Inserting into then_bb; This ndarray is contiguous. - let data = self.value.get(generator, ctx, |f| f.data, ""); + let data = self.instance.get(generator, ctx, |f| f.data, ""); let data = data.pointer_cast(generator, ctx, item_model, ""); result.set(ctx, |f| f.data, data); ctx.builder.build_unconditional_branch(end_bb).unwrap(); @@ -123,7 +123,7 @@ impl<'ctx> NDArrayObject<'ctx> { // TODO: Reimplement this? This method does give us the contiguous `data`, but // this creates a few extra bytes of useless information because an entire NDArray // is allocated. Though this is super convenient. - let data = self.make_clone(generator, ctx, "").value.get(generator, ctx, |f| f.data, ""); + let data = self.make_clone(generator, ctx, "").instance.get(generator, ctx, |f| f.data, ""); let data = data.pointer_cast(generator, ctx, item_model, ""); result.set(ctx, |f| f.data, data); ctx.builder.build_unconditional_branch(end_bb).unwrap(); @@ -166,10 +166,10 @@ impl<'ctx> NDArrayObject<'ctx> { let data = simple_ndarray .get(generator, ctx, |f| f.data, "") .pointer_cast(generator, ctx, byte_model, "data"); - ndarray.value.set(ctx, |f| f.data, data); + ndarray.instance.set(ctx, |f| f.data, data); let shape = simple_ndarray.get(generator, ctx, |f| f.shape, "shape"); - ndarray.value.set(ctx, |f| f.shape, shape); + ndarray.instance.set(ctx, |f| f.shape, shape); // Set strides. We know `data` is contiguous. ndarray.update_strides_by_shape(generator, ctx); @@ -183,7 +183,7 @@ impl<'ctx> NDArrayObject<'ctx> { generator: &mut G, ctx: &mut CodeGenContext<'ctx, '_>, ) -> Int<'ctx, SizeT> { - call_nac3_ndarray_size(generator, ctx, self.value) + call_nac3_ndarray_size(generator, ctx, self.instance) } /// Get the `ndarray.nbytes` of this ndarray. @@ -192,7 +192,7 @@ impl<'ctx> NDArrayObject<'ctx> { generator: &mut G, ctx: &mut CodeGenContext<'ctx, '_>, ) -> Int<'ctx, SizeT> { - call_nac3_ndarray_nbytes(generator, ctx, self.value) + call_nac3_ndarray_nbytes(generator, ctx, self.instance) } /// Get the `len()` of this ndarray. @@ -201,7 +201,7 @@ impl<'ctx> NDArrayObject<'ctx> { generator: &mut G, ctx: &mut CodeGenContext<'ctx, '_>, ) -> Int<'ctx, SizeT> { - call_nac3_ndarray_len(generator, ctx, self.value) + call_nac3_ndarray_len(generator, ctx, self.instance) } /// Check if this ndarray is C-contiguous. @@ -212,7 +212,7 @@ impl<'ctx> NDArrayObject<'ctx> { generator: &mut G, ctx: &mut CodeGenContext<'ctx, '_>, ) -> Int<'ctx, Bool> { - call_nac3_ndarray_is_c_contiguous(generator, ctx, self.value) + call_nac3_ndarray_is_c_contiguous(generator, ctx, self.instance) } /// Get the pointer to the n-th (0-based) element. @@ -227,7 +227,7 @@ impl<'ctx> NDArrayObject<'ctx> { ) -> PointerValue<'ctx> { let elem_ty = ctx.get_llvm_type(generator, self.dtype); - let p = call_nac3_ndarray_get_nth_pelement(generator, ctx, self.value, nth); + let p = call_nac3_ndarray_get_nth_pelement(generator, ctx, self.instance, nth); ctx.builder .build_pointer_cast(p.value, elem_ty.ptr_type(AddressSpace::default()), name) .unwrap() @@ -242,7 +242,7 @@ impl<'ctx> NDArrayObject<'ctx> { ) -> ScalarObject<'ctx> { let p = self.get_nth_pointer(generator, ctx, nth, "value"); let value = ctx.builder.build_load(p, "value").unwrap(); - ScalarObject { dtype: self.dtype, value } + ScalarObject { dtype: self.dtype, instance: value } } /// Call [`call_nac3_ndarray_set_strides_by_shape`] on this ndarray to update `strides`. @@ -253,7 +253,7 @@ impl<'ctx> NDArrayObject<'ctx> { generator: &mut G, ctx: &mut CodeGenContext<'ctx, '_>, ) { - call_nac3_ndarray_set_strides_by_shape(generator, ctx, self.value); + call_nac3_ndarray_set_strides_by_shape(generator, ctx, self.instance); } /// Copy data from another ndarray. @@ -269,7 +269,7 @@ impl<'ctx> NDArrayObject<'ctx> { src: NDArrayObject<'ctx>, ) { assert!(ctx.unifier.unioned(self.dtype, src.dtype), "self and src dtype should match"); - call_nac3_ndarray_copy_data(generator, ctx, src.value, self.value); + call_nac3_ndarray_copy_data(generator, ctx, src.instance, self.instance); } /// Allocate an ndarray on the stack given its `ndims` and `dtype`. @@ -312,7 +312,7 @@ impl<'ctx> NDArrayObject<'ctx> { let strides = sizet_model.array_alloca(generator, ctx, ndims_val.value, "alloca_strides"); pndarray.set(ctx, |f| f.strides, strides); - NDArrayObject { dtype, ndims, value: pndarray } + NDArrayObject { dtype, ndims, instance: pndarray } } /// Convenience function. @@ -342,7 +342,7 @@ impl<'ctx> NDArrayObject<'ctx> { let clone = NDArrayObject::alloca_uninitialized(generator, ctx, self.dtype, self.ndims, name); - let shape = self.value.gep(ctx, |f| f.shape).load(generator, ctx, "shape"); + let shape = self.instance.gep(ctx, |f| f.shape).load(generator, ctx, "shape"); clone.copy_shape_from_array(generator, ctx, shape); clone.create_data(generator, ctx); clone.copy_data_from(generator, ctx, *self); @@ -412,7 +412,7 @@ impl<'ctx> NDArrayObject<'ctx> { let nbytes = self.nbytes(generator, ctx); let data = byte_model.array_alloca(generator, ctx, nbytes.value, "data"); - self.value.set(ctx, |f| f.data, data); + self.instance.set(ctx, |f| f.data, data); self.update_strides_by_shape(generator, ctx); } @@ -424,7 +424,7 @@ impl<'ctx> NDArrayObject<'ctx> { ctx: &mut CodeGenContext<'ctx, '_>, src_shape: Ptr<'ctx, IntModel>, ) { - let dst_shape = self.value.get(generator, ctx, |f| f.shape, "dst_shape"); + let dst_shape = self.instance.get(generator, ctx, |f| f.shape, "dst_shape"); let num_items = self.get_ndims(generator, ctx.ctx).value; call_memcpy_model(generator, ctx, dst_shape, src_shape, num_items); } @@ -438,7 +438,7 @@ impl<'ctx> NDArrayObject<'ctx> { src_ndarray: NDArrayObject<'ctx>, ) { assert_eq!(self.ndims, src_ndarray.ndims); - let src_shape = src_ndarray.value.get(generator, ctx, |f| f.shape, "src_shape"); + let src_shape = src_ndarray.instance.get(generator, ctx, |f| f.shape, "src_shape"); self.copy_shape_from_array(generator, ctx, src_shape); } @@ -449,7 +449,7 @@ impl<'ctx> NDArrayObject<'ctx> { ctx: &mut CodeGenContext<'ctx, '_>, src_strides: Ptr<'ctx, IntModel>, ) { - let dst_strides = self.value.get(generator, ctx, |f| f.strides, "dst_strides"); + let dst_strides = self.instance.get(generator, ctx, |f| f.strides, "dst_strides"); let num_items = self.get_ndims(generator, ctx.ctx).value; call_memcpy_model(generator, ctx, dst_strides, src_strides, num_items); } @@ -463,7 +463,7 @@ impl<'ctx> NDArrayObject<'ctx> { src_ndarray: NDArrayObject<'ctx>, ) { assert_eq!(self.ndims, src_ndarray.ndims); - let src_strides = src_ndarray.value.get(generator, ctx, |f| f.strides, "src_strides"); + let src_strides = src_ndarray.instance.get(generator, ctx, |f| f.strides, "src_strides"); self.copy_strides_from_array(generator, ctx, src_strides); } @@ -518,7 +518,7 @@ impl<'ctx> NDArrayObject<'ctx> { { self.foreach_pointer(generator, ctx, |generator, ctx, hooks, i, p| { let value = ctx.builder.build_load(p, "value").unwrap(); - let scalar = ScalarObject { dtype: self.dtype, value }; + let scalar = ScalarObject { dtype: self.dtype, instance: value }; body(generator, ctx, hooks, i, scalar) }) } @@ -606,7 +606,11 @@ impl<'ctx> NDArrayObject<'ctx> { // Inserting into then_bb: reshape is possible without copying ctx.builder.position_at_end(then_bb); dst_ndarray.update_strides_by_shape(generator, ctx); - dst_ndarray.value.set(ctx, |f| f.data, self.value.get(generator, ctx, |f| f.data, "data")); + dst_ndarray.instance.set( + ctx, + |f| f.data, + self.instance.get(generator, ctx, |f| f.data, "data"), + ); ctx.builder.build_unconditional_branch(end_bb).unwrap(); // Inserting into else_bb: reshape is impossible without copying @@ -672,8 +676,8 @@ impl<'ctx> NDArrayObject<'ctx> { call_nac3_ndarray_transpose( generator, ctx, - self.value, - transposed_ndarray.value, + self.instance, + transposed_ndarray.instance, num_axes, axes, ); @@ -694,7 +698,7 @@ impl<'ctx> NDArrayObject<'ctx> { let sizet_model = IntModel(SizeT); let ndarray_ndims = self.get_ndims(generator, ctx.ctx); - let ndarray_shape = self.value.get(generator, ctx, |f| f.shape, "shape"); + let ndarray_shape = self.instance.get(generator, ctx, |f| f.shape, "shape"); let output_ndims = sizet_model.constant(generator, ctx.ctx, out_ndims); let output_shape = out_shape; diff --git a/nac3core/src/codegen/object/ndarray/nalgebra.rs b/nac3core/src/codegen/object/ndarray/nalgebra.rs index e69de29b..8b137891 100644 --- a/nac3core/src/codegen/object/ndarray/nalgebra.rs +++ b/nac3core/src/codegen/object/ndarray/nalgebra.rs @@ -0,0 +1 @@ + diff --git a/nac3core/src/codegen/object/ndarray/product.rs b/nac3core/src/codegen/object/ndarray/product.rs index 0903494c..3a39d3a6 100644 --- a/nac3core/src/codegen/object/ndarray/product.rs +++ b/nac3core/src/codegen/object/ndarray/product.rs @@ -30,9 +30,9 @@ impl<'ctx> NDArrayObject<'ctx> { let final_ndims_int = max(a.ndims, b.ndims); let a_ndims = a.get_ndims(generator, ctx.ctx); - let a_shape = a.value.get(generator, ctx, |f| f.shape, "a_shape"); + let a_shape = a.instance.get(generator, ctx, |f| f.shape, "a_shape"); let b_ndims = b.get_ndims(generator, ctx.ctx); - let b_shape = b.value.get(generator, ctx, |f| f.shape, "b_shape"); + let b_shape = b.instance.get(generator, ctx, |f| f.shape, "b_shape"); let final_ndims = sizet_model.constant(generator, ctx.ctx, final_ndims_int); let new_a_shape = sizet_model.array_alloca(generator, ctx, final_ndims.value, "new_a_shape"); @@ -68,9 +68,9 @@ impl<'ctx> NDArrayObject<'ctx> { call_nac3_ndarray_float64_matmul_at_least_2d( generator, ctx, - new_a.value, - new_b.value, - dst.value, + new_a.instance, + new_b.instance, + dst.instance, ); dst @@ -147,7 +147,7 @@ impl<'ctx> NDArrayObject<'ctx> { } NDArrayOut::WriteToNDArray { ndarray: out_ndarray } => { // TODO: It is possible to check the shapes before computing the matmul to save resources. - let result_shape = result.value.get(generator, ctx, |f| f.shape, "result_shape"); + let result_shape = result.instance.get(generator, ctx, |f| f.shape, "result_shape"); out_ndarray.check_can_be_written_by_out(generator, ctx, result.ndims, result_shape); // TODO: We can just set `out_ndarray.data` to `result.data`. Should we? diff --git a/nac3core/src/codegen/object/ndarray/scalar.rs b/nac3core/src/codegen/object/ndarray/scalar.rs index 1a03a223..1d7a2cd5 100644 --- a/nac3core/src/codegen/object/ndarray/scalar.rs +++ b/nac3core/src/codegen/object/ndarray/scalar.rs @@ -15,7 +15,7 @@ use super::NDArrayObject; #[derive(Debug, Clone, Copy)] pub struct ScalarObject<'ctx> { pub dtype: Type, - pub value: BasicValueEnum<'ctx>, + pub instance: BasicValueEnum<'ctx>, } impl<'ctx> ScalarObject<'ctx> { @@ -31,13 +31,13 @@ impl<'ctx> ScalarObject<'ctx> { let pbyte_model = PtrModel(IntModel(Byte)); // We have to put the value on the stack to get a data pointer. - let data = ctx.builder.build_alloca(self.value.get_type(), "as_ndarray_scalar").unwrap(); - ctx.builder.build_store(data, self.value).unwrap(); + let data = ctx.builder.build_alloca(self.instance.get_type(), "as_ndarray_scalar").unwrap(); + ctx.builder.build_store(data, self.instance).unwrap(); let data = pbyte_model.pointer_cast(generator, ctx, data, "data"); let ndarray = NDArrayObject::alloca_uninitialized(generator, ctx, self.dtype, 0, "scalar_ndarray"); - ndarray.value.set(ctx, |f| f.data, data); + ndarray.instance.set(ctx, |f| f.data, data); ndarray } } @@ -54,8 +54,8 @@ impl<'ctx> ScalarOrNDArray<'ctx> { #[must_use] pub fn to_basic_value_enum(self) -> BasicValueEnum<'ctx> { match self { - ScalarOrNDArray::Scalar(scalar) => scalar.value, - ScalarOrNDArray::NDArray(ndarray) => ndarray.value.value.as_basic_value_enum(), + ScalarOrNDArray::Scalar(scalar) => scalar.instance, + ScalarOrNDArray::NDArray(ndarray) => ndarray.instance.value.as_basic_value_enum(), } } @@ -136,7 +136,7 @@ pub fn split_scalar_or_ndarray<'ctx, G: CodeGenerator + ?Sized>( ScalarOrNDArray::NDArray(ndarray) } _ => { - let scalar = ScalarObject { dtype: input_ty, value: input }; + let scalar = ScalarObject { dtype: input_ty, instance: input }; ScalarOrNDArray::Scalar(scalar) } } diff --git a/nac3core/src/codegen/object/ndarray/shape_util.rs b/nac3core/src/codegen/object/ndarray/shape_util.rs index fee3d1eb..756590c4 100644 --- a/nac3core/src/codegen/object/ndarray/shape_util.rs +++ b/nac3core/src/codegen/object/ndarray/shape_util.rs @@ -39,14 +39,14 @@ pub fn parse_numpy_int_sequence<'ctx, G: CodeGenerator + ?Sized>( let input_sequence = ListObject::from_value_and_type(generator, ctx, input_sequence, input_sequence_ty); - let len = input_sequence.value.gep(ctx, |f| f.len).load(generator, ctx, "len"); + let len = input_sequence.instance.gep(ctx, |f| f.len).load(generator, ctx, "len"); let result = sizet_model.array_alloca(generator, ctx, len.value, "int_sequence"); // Load all the `int32`s from the input_sequence, cast them to `SizeT`, and store them into `result` gen_for_model_auto(generator, ctx, zero, len, one, |generator, ctx, _hooks, i| { // Load the i-th int32 in the input sequence let int = input_sequence - .value + .instance .get(generator, ctx, |f| f.items, "int") .ix(generator, ctx, i.value, "int") .value diff --git a/nac3core/src/toplevel/builtins.rs b/nac3core/src/toplevel/builtins.rs index f1d1fdf3..5c1478da 100644 --- a/nac3core/src/toplevel/builtins.rs +++ b/nac3core/src/toplevel/builtins.rs @@ -1105,7 +1105,7 @@ impl<'a> BuiltinBuilder<'a> { PrimDef::FunBool => scalar.cast_to_bool(ctx), _ => unreachable!(), }; - Ok(result.value) + Ok(result.instance) }, )?; Ok(Some(result.to_basic_value_enum())) @@ -1166,7 +1166,7 @@ impl<'a> BuiltinBuilder<'a> { ctx, ret_int_dtype, |generator, ctx, _i, scalar| { - Ok(scalar.round(generator, ctx, ret_int_dtype).value) + Ok(scalar.round(generator, ctx, ret_int_dtype).instance) }, )?; Ok(Some(result.to_basic_value_enum())) @@ -1231,7 +1231,7 @@ impl<'a> BuiltinBuilder<'a> { ctx, int_sized, |generator, ctx, _i, scalar| { - Ok(scalar.floor_or_ceil(generator, ctx, kind, int_sized).value) + Ok(scalar.floor_or_ceil(generator, ctx, kind, int_sized).instance) }, )?; Ok(Some(result.to_basic_value_enum())) @@ -1631,7 +1631,7 @@ impl<'a> BuiltinBuilder<'a> { ctx.primitives.float, move |_generator, ctx, _i, scalar| { let result = scalar.np_floor_or_ceil(ctx, kind); - Ok(result.value) + Ok(result.instance) }, )?; Ok(Some(result.to_basic_value_enum())) @@ -1659,7 +1659,7 @@ impl<'a> BuiltinBuilder<'a> { ctx.primitives.float, |_generator, ctx, _i, scalar| { let result = scalar.np_round(ctx); - Ok(result.value) + Ok(result.instance) }, )?; Ok(Some(result.to_basic_value_enum())) @@ -1746,10 +1746,10 @@ impl<'a> BuiltinBuilder<'a> { _ => unreachable!(), }; - let m = ScalarObject { dtype: m_ty, value: m_val }; - let n = ScalarObject { dtype: n_ty, value: n_val }; + let m = ScalarObject { dtype: m_ty, instance: m_val }; + let n = ScalarObject { dtype: n_ty, instance: n_val }; let result = ScalarObject::min_or_max(ctx, kind, m, n); - Ok(Some(result.value)) + Ok(Some(result.instance)) }, )))), loc: None, @@ -1802,10 +1802,10 @@ impl<'a> BuiltinBuilder<'a> { .value .as_basic_value_enum(), PrimDef::FunNpMin => { - a.min_or_max(generator, ctx, MinOrMax::Min).value.as_basic_value_enum() + a.min_or_max(generator, ctx, MinOrMax::Min).instance.as_basic_value_enum() } PrimDef::FunNpMax => { - a.min_or_max(generator, ctx, MinOrMax::Max).value.as_basic_value_enum() + a.min_or_max(generator, ctx, MinOrMax::Max).instance.as_basic_value_enum() } _ => unreachable!(), }; @@ -1871,7 +1871,7 @@ impl<'a> BuiltinBuilder<'a> { let x2 = scalars[1]; let result = ScalarObject::min_or_max(ctx, kind, x1, x2); - Ok(result.value) + Ok(result.instance) }, )?; Ok(Some(result.to_basic_value_enum())) @@ -1912,7 +1912,7 @@ impl<'a> BuiltinBuilder<'a> { generator, ctx, num_ty.ty, - |_generator, ctx, _i, scalar| Ok(scalar.abs(ctx).value), + |_generator, ctx, _i, scalar| Ok(scalar.abs(ctx).instance), )?; Ok(Some(result.to_basic_value_enum())) },