Compare commits
32 Commits
master
...
ndstrides-
Author | SHA1 | Date |
---|---|---|
|
d222236492 | |
|
13715dbda9 | |
|
7910de10a1 | |
|
6edc3f895b | |
|
a40cdde8d2 | |
|
853fa39537 | |
|
b6a1880226 | |
|
d1c75c7444 | |
|
58c5bc56b9 | |
|
ddc0e44c61 | |
|
549536f72c | |
|
40c42b571a | |
|
92e7103ec7 | |
|
9bc5e96dba | |
|
78639b1030 | |
|
9723c17e24 | |
|
d1c7a8ee50 | |
|
e0524c19eb | |
|
32822f9052 | |
|
6283036815 | |
|
f167f5f215 | |
|
baf8ee2b3d | |
|
d68760447f | |
|
fdd194ee2a | |
|
5fca81c68e | |
|
0562e9a385 | |
|
36af473816 | |
|
7c7e1b3ab8 | |
|
dbcfc9538a | |
|
5c4ba09e2f | |
|
eb34b99ee9 | |
|
d397b9ceaa |
|
@ -3,4 +3,10 @@
|
||||||
#include "irrt/list.hpp"
|
#include "irrt/list.hpp"
|
||||||
#include "irrt/math.hpp"
|
#include "irrt/math.hpp"
|
||||||
#include "irrt/ndarray.hpp"
|
#include "irrt/ndarray.hpp"
|
||||||
|
#include "irrt/range.hpp"
|
||||||
#include "irrt/slice.hpp"
|
#include "irrt/slice.hpp"
|
||||||
|
#include "irrt/ndarray/basic.hpp"
|
||||||
|
#include "irrt/ndarray/def.hpp"
|
||||||
|
#include "irrt/ndarray/iter.hpp"
|
||||||
|
#include "irrt/ndarray/indexing.hpp"
|
||||||
|
#include "irrt/ndarray/array.hpp"
|
|
@ -55,11 +55,14 @@ void _raise_exception_helper(ExceptionId id,
|
||||||
int64_t param2) {
|
int64_t param2) {
|
||||||
Exception<SizeT> e = {
|
Exception<SizeT> e = {
|
||||||
.id = id,
|
.id = id,
|
||||||
.filename = {.base = reinterpret_cast<const uint8_t*>(filename), .len = __builtin_strlen(filename)},
|
.filename = {.base = reinterpret_cast<uint8_t*>(const_cast<char*>(filename)),
|
||||||
|
.len = static_cast<int32_t>(__builtin_strlen(filename))},
|
||||||
.line = line,
|
.line = line,
|
||||||
.column = 0,
|
.column = 0,
|
||||||
.function = {.base = reinterpret_cast<const uint8_t*>(function), .len = __builtin_strlen(function)},
|
.function = {.base = reinterpret_cast<uint8_t*>(const_cast<char*>(function)),
|
||||||
.msg = {.base = reinterpret_cast<const uint8_t*>(msg), .len = __builtin_strlen(msg)},
|
.len = static_cast<int32_t>(__builtin_strlen(function))},
|
||||||
|
.msg = {.base = reinterpret_cast<uint8_t*>(const_cast<char*>(msg)),
|
||||||
|
.len = static_cast<int32_t>(__builtin_strlen(msg))},
|
||||||
};
|
};
|
||||||
e.params[0] = param0;
|
e.params[0] = param0;
|
||||||
e.params[1] = param1;
|
e.params[1] = param1;
|
||||||
|
|
|
@ -8,6 +8,6 @@ using int64_t = _BitInt(64);
|
||||||
using uint64_t = unsigned _BitInt(64);
|
using uint64_t = unsigned _BitInt(64);
|
||||||
|
|
||||||
// NDArray indices are always `uint32_t`.
|
// NDArray indices are always `uint32_t`.
|
||||||
using NDIndex = uint32_t;
|
using NDIndexInt = uint32_t;
|
||||||
// The type of an index or a value describing the length of a range/slice is always `int32_t`.
|
// The type of an index or a value describing the length of a range/slice is always `int32_t`.
|
||||||
using SliceIndex = int32_t;
|
using SliceIndex = int32_t;
|
|
@ -2,6 +2,21 @@
|
||||||
|
|
||||||
#include "irrt/int_types.hpp"
|
#include "irrt/int_types.hpp"
|
||||||
#include "irrt/math_util.hpp"
|
#include "irrt/math_util.hpp"
|
||||||
|
#include "irrt/slice.hpp"
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
/**
|
||||||
|
* @brief A list in NAC3.
|
||||||
|
*
|
||||||
|
* The `items` field is opaque. You must rely on external contexts to
|
||||||
|
* know how to interpret it.
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
struct List {
|
||||||
|
uint8_t* items;
|
||||||
|
SizeT len;
|
||||||
|
};
|
||||||
|
} // namespace
|
||||||
|
|
||||||
extern "C" {
|
extern "C" {
|
||||||
// Handle list assignment and dropping part of the list when
|
// Handle list assignment and dropping part of the list when
|
||||||
|
|
|
@ -2,6 +2,8 @@
|
||||||
|
|
||||||
#include "irrt/int_types.hpp"
|
#include "irrt/int_types.hpp"
|
||||||
|
|
||||||
|
// TODO: To be deleted since NDArray with strides is done.
|
||||||
|
|
||||||
namespace {
|
namespace {
|
||||||
template<typename SizeT>
|
template<typename SizeT>
|
||||||
SizeT __nac3_ndarray_calc_size_impl(const SizeT* list_data, SizeT list_len, SizeT begin_idx, SizeT end_idx) {
|
SizeT __nac3_ndarray_calc_size_impl(const SizeT* list_data, SizeT list_len, SizeT begin_idx, SizeT end_idx) {
|
||||||
|
@ -17,7 +19,7 @@ SizeT __nac3_ndarray_calc_size_impl(const SizeT* list_data, SizeT list_len, Size
|
||||||
}
|
}
|
||||||
|
|
||||||
template<typename SizeT>
|
template<typename SizeT>
|
||||||
void __nac3_ndarray_calc_nd_indices_impl(SizeT index, const SizeT* dims, SizeT num_dims, NDIndex* idxs) {
|
void __nac3_ndarray_calc_nd_indices_impl(SizeT index, const SizeT* dims, SizeT num_dims, NDIndexInt* idxs) {
|
||||||
SizeT stride = 1;
|
SizeT stride = 1;
|
||||||
for (SizeT dim = 0; dim < num_dims; dim++) {
|
for (SizeT dim = 0; dim < num_dims; dim++) {
|
||||||
SizeT i = num_dims - dim - 1;
|
SizeT i = num_dims - dim - 1;
|
||||||
|
@ -28,7 +30,10 @@ void __nac3_ndarray_calc_nd_indices_impl(SizeT index, const SizeT* dims, SizeT n
|
||||||
}
|
}
|
||||||
|
|
||||||
template<typename SizeT>
|
template<typename SizeT>
|
||||||
SizeT __nac3_ndarray_flatten_index_impl(const SizeT* dims, SizeT num_dims, const NDIndex* indices, SizeT num_indices) {
|
SizeT __nac3_ndarray_flatten_index_impl(const SizeT* dims,
|
||||||
|
SizeT num_dims,
|
||||||
|
const NDIndexInt* indices,
|
||||||
|
SizeT num_indices) {
|
||||||
SizeT idx = 0;
|
SizeT idx = 0;
|
||||||
SizeT stride = 1;
|
SizeT stride = 1;
|
||||||
for (SizeT i = 0; i < num_dims; ++i) {
|
for (SizeT i = 0; i < num_dims; ++i) {
|
||||||
|
@ -75,8 +80,8 @@ void __nac3_ndarray_calc_broadcast_impl(const SizeT* lhs_dims,
|
||||||
template<typename SizeT>
|
template<typename SizeT>
|
||||||
void __nac3_ndarray_calc_broadcast_idx_impl(const SizeT* src_dims,
|
void __nac3_ndarray_calc_broadcast_idx_impl(const SizeT* src_dims,
|
||||||
SizeT src_ndims,
|
SizeT src_ndims,
|
||||||
const NDIndex* in_idx,
|
const NDIndexInt* in_idx,
|
||||||
NDIndex* out_idx) {
|
NDIndexInt* out_idx) {
|
||||||
for (SizeT i = 0; i < src_ndims; ++i) {
|
for (SizeT i = 0; i < src_ndims; ++i) {
|
||||||
SizeT src_i = src_ndims - i - 1;
|
SizeT src_i = src_ndims - i - 1;
|
||||||
out_idx[src_i] = src_dims[src_i] == 1 ? 0 : in_idx[src_i];
|
out_idx[src_i] = src_dims[src_i] == 1 ? 0 : in_idx[src_i];
|
||||||
|
@ -94,21 +99,23 @@ __nac3_ndarray_calc_size64(const uint64_t* list_data, uint64_t list_len, uint64_
|
||||||
return __nac3_ndarray_calc_size_impl(list_data, list_len, begin_idx, end_idx);
|
return __nac3_ndarray_calc_size_impl(list_data, list_len, begin_idx, end_idx);
|
||||||
}
|
}
|
||||||
|
|
||||||
void __nac3_ndarray_calc_nd_indices(uint32_t index, const uint32_t* dims, uint32_t num_dims, NDIndex* idxs) {
|
void __nac3_ndarray_calc_nd_indices(uint32_t index, const uint32_t* dims, uint32_t num_dims, NDIndexInt* idxs) {
|
||||||
__nac3_ndarray_calc_nd_indices_impl(index, dims, num_dims, idxs);
|
__nac3_ndarray_calc_nd_indices_impl(index, dims, num_dims, idxs);
|
||||||
}
|
}
|
||||||
|
|
||||||
void __nac3_ndarray_calc_nd_indices64(uint64_t index, const uint64_t* dims, uint64_t num_dims, NDIndex* idxs) {
|
void __nac3_ndarray_calc_nd_indices64(uint64_t index, const uint64_t* dims, uint64_t num_dims, NDIndexInt* idxs) {
|
||||||
__nac3_ndarray_calc_nd_indices_impl(index, dims, num_dims, idxs);
|
__nac3_ndarray_calc_nd_indices_impl(index, dims, num_dims, idxs);
|
||||||
}
|
}
|
||||||
|
|
||||||
uint32_t
|
uint32_t
|
||||||
__nac3_ndarray_flatten_index(const uint32_t* dims, uint32_t num_dims, const NDIndex* indices, uint32_t num_indices) {
|
__nac3_ndarray_flatten_index(const uint32_t* dims, uint32_t num_dims, const NDIndexInt* indices, uint32_t num_indices) {
|
||||||
return __nac3_ndarray_flatten_index_impl(dims, num_dims, indices, num_indices);
|
return __nac3_ndarray_flatten_index_impl(dims, num_dims, indices, num_indices);
|
||||||
}
|
}
|
||||||
|
|
||||||
uint64_t
|
uint64_t __nac3_ndarray_flatten_index64(const uint64_t* dims,
|
||||||
__nac3_ndarray_flatten_index64(const uint64_t* dims, uint64_t num_dims, const NDIndex* indices, uint64_t num_indices) {
|
uint64_t num_dims,
|
||||||
|
const NDIndexInt* indices,
|
||||||
|
uint64_t num_indices) {
|
||||||
return __nac3_ndarray_flatten_index_impl(dims, num_dims, indices, num_indices);
|
return __nac3_ndarray_flatten_index_impl(dims, num_dims, indices, num_indices);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -130,15 +137,15 @@ void __nac3_ndarray_calc_broadcast64(const uint64_t* lhs_dims,
|
||||||
|
|
||||||
void __nac3_ndarray_calc_broadcast_idx(const uint32_t* src_dims,
|
void __nac3_ndarray_calc_broadcast_idx(const uint32_t* src_dims,
|
||||||
uint32_t src_ndims,
|
uint32_t src_ndims,
|
||||||
const NDIndex* in_idx,
|
const NDIndexInt* in_idx,
|
||||||
NDIndex* out_idx) {
|
NDIndexInt* out_idx) {
|
||||||
__nac3_ndarray_calc_broadcast_idx_impl(src_dims, src_ndims, in_idx, out_idx);
|
__nac3_ndarray_calc_broadcast_idx_impl(src_dims, src_ndims, in_idx, out_idx);
|
||||||
}
|
}
|
||||||
|
|
||||||
void __nac3_ndarray_calc_broadcast_idx64(const uint64_t* src_dims,
|
void __nac3_ndarray_calc_broadcast_idx64(const uint64_t* src_dims,
|
||||||
uint64_t src_ndims,
|
uint64_t src_ndims,
|
||||||
const NDIndex* in_idx,
|
const NDIndexInt* in_idx,
|
||||||
NDIndex* out_idx) {
|
NDIndexInt* out_idx) {
|
||||||
__nac3_ndarray_calc_broadcast_idx_impl(src_dims, src_ndims, in_idx, out_idx);
|
__nac3_ndarray_calc_broadcast_idx_impl(src_dims, src_ndims, in_idx, out_idx);
|
||||||
}
|
}
|
||||||
}
|
}
|
|
@ -0,0 +1,134 @@
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include "irrt/debug.hpp"
|
||||||
|
#include "irrt/exception.hpp"
|
||||||
|
#include "irrt/int_types.hpp"
|
||||||
|
#include "irrt/list.hpp"
|
||||||
|
#include "irrt/ndarray/basic.hpp"
|
||||||
|
#include "irrt/ndarray/def.hpp"
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
namespace ndarray {
|
||||||
|
namespace array {
|
||||||
|
/**
|
||||||
|
* @brief In the context of `np.array(<list>)`, deduce the ndarray's shape produced by `<list>` and raise
|
||||||
|
* an exception if there is anything wrong with `<shape>` (e.g., inconsistent dimensions `np.array([[1.0, 2.0],
|
||||||
|
* [3.0]])`)
|
||||||
|
*
|
||||||
|
* If this function finds no issues with `<list>`, the deduced shape is written to `shape`. The caller has the
|
||||||
|
* responsibility to allocate `[SizeT; ndims]` for `shape`. The caller must also initialize `shape` with `-1`s because
|
||||||
|
* of implementation details.
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
void set_and_validate_list_shape_helper(SizeT axis, List<SizeT>* list, SizeT ndims, SizeT* shape) {
|
||||||
|
if (shape[axis] == -1) {
|
||||||
|
// Dimension is unspecified. Set it.
|
||||||
|
shape[axis] = list->len;
|
||||||
|
} else {
|
||||||
|
// Dimension is specified. Check.
|
||||||
|
if (shape[axis] != list->len) {
|
||||||
|
// Mismatch, throw an error.
|
||||||
|
// NOTE: NumPy's error message is more complex and needs more PARAMS to display.
|
||||||
|
raise_exception(SizeT, EXN_VALUE_ERROR,
|
||||||
|
"The requested array has an inhomogenous shape "
|
||||||
|
"after {0} dimension(s).",
|
||||||
|
axis, shape[axis], list->len);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (axis + 1 == ndims) {
|
||||||
|
// `list` has type `list[ItemType]`
|
||||||
|
// Do nothing
|
||||||
|
} else {
|
||||||
|
// `list` has type `list[list[...]]`
|
||||||
|
List<SizeT>** lists = (List<SizeT>**)(list->items);
|
||||||
|
for (SizeT i = 0; i < list->len; i++) {
|
||||||
|
set_and_validate_list_shape_helper<SizeT>(axis + 1, lists[i], ndims, shape);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief See `set_and_validate_list_shape_helper`.
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
void set_and_validate_list_shape(List<SizeT>* list, SizeT ndims, SizeT* shape) {
|
||||||
|
for (SizeT axis = 0; axis < ndims; axis++) {
|
||||||
|
shape[axis] = -1; // Sentinel to say this dimension is unspecified.
|
||||||
|
}
|
||||||
|
set_and_validate_list_shape_helper<SizeT>(0, list, ndims, shape);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief In the context of `np.array(<list>)`, copied the contents stored in `list` to `ndarray`.
|
||||||
|
*
|
||||||
|
* `list` is assumed to be "legal". (i.e., no inconsistent dimensions)
|
||||||
|
*
|
||||||
|
* # Notes on `ndarray`
|
||||||
|
* The caller is responsible for allocating space for `ndarray`.
|
||||||
|
* Here is what this function expects from `ndarray` when called:
|
||||||
|
* - `ndarray->data` has to be allocated, contiguous, and may contain uninitialized values.
|
||||||
|
* - `ndarray->itemsize` has to be initialized.
|
||||||
|
* - `ndarray->ndims` has to be initialized.
|
||||||
|
* - `ndarray->shape` has to be initialized.
|
||||||
|
* - `ndarray->strides` is ignored, but note that `ndarray->data` is contiguous.
|
||||||
|
* When this function call ends:
|
||||||
|
* - `ndarray->data` is written with contents from `<list>`.
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
void write_list_to_array_helper(SizeT axis, SizeT* index, List<SizeT>* list, NDArray<SizeT>* ndarray) {
|
||||||
|
debug_assert_eq(SizeT, list->len, ndarray->shape[axis]);
|
||||||
|
if (IRRT_DEBUG_ASSERT_BOOL) {
|
||||||
|
if (!ndarray::basic::is_c_contiguous(ndarray)) {
|
||||||
|
raise_debug_assert(SizeT, "ndarray is not C-contiguous", ndarray->strides[0], ndarray->strides[1],
|
||||||
|
NO_PARAM);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (axis + 1 == ndarray->ndims) {
|
||||||
|
// `list` has type `list[scalar]`
|
||||||
|
// `ndarray` is contiguous, so we can do this, and this is fast.
|
||||||
|
uint8_t* dst = ndarray->data + (ndarray->itemsize * (*index));
|
||||||
|
__builtin_memcpy(dst, list->items, ndarray->itemsize * list->len);
|
||||||
|
*index += list->len;
|
||||||
|
} else {
|
||||||
|
// `list` has type `list[list[...]]`
|
||||||
|
List<SizeT>** lists = (List<SizeT>**)(list->items);
|
||||||
|
|
||||||
|
for (SizeT i = 0; i < list->len; i++) {
|
||||||
|
write_list_to_array_helper<SizeT>(axis + 1, index, lists[i], ndarray);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief See `write_list_to_array_helper`.
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
void write_list_to_array(List<SizeT>* list, NDArray<SizeT>* ndarray) {
|
||||||
|
SizeT index = 0;
|
||||||
|
write_list_to_array_helper<SizeT>((SizeT)0, &index, list, ndarray);
|
||||||
|
}
|
||||||
|
} // namespace array
|
||||||
|
} // namespace ndarray
|
||||||
|
} // namespace
|
||||||
|
|
||||||
|
extern "C" {
|
||||||
|
using namespace ndarray::array;
|
||||||
|
|
||||||
|
void __nac3_ndarray_array_set_and_validate_list_shape(List<int32_t>* list, int32_t ndims, int32_t* shape) {
|
||||||
|
set_and_validate_list_shape(list, ndims, shape);
|
||||||
|
}
|
||||||
|
|
||||||
|
void __nac3_ndarray_array_set_and_validate_list_shape64(List<int64_t>* list, int64_t ndims, int64_t* shape) {
|
||||||
|
set_and_validate_list_shape(list, ndims, shape);
|
||||||
|
}
|
||||||
|
|
||||||
|
void __nac3_ndarray_array_write_list_to_array(List<int32_t>* list, NDArray<int32_t>* ndarray) {
|
||||||
|
write_list_to_array(list, ndarray);
|
||||||
|
}
|
||||||
|
|
||||||
|
void __nac3_ndarray_array_write_list_to_array64(List<int64_t>* list, NDArray<int64_t>* ndarray) {
|
||||||
|
write_list_to_array(list, ndarray);
|
||||||
|
}
|
||||||
|
}
|
|
@ -0,0 +1,341 @@
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include "irrt/debug.hpp"
|
||||||
|
#include "irrt/exception.hpp"
|
||||||
|
#include "irrt/int_types.hpp"
|
||||||
|
#include "irrt/ndarray/def.hpp"
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
namespace ndarray {
|
||||||
|
namespace basic {
|
||||||
|
/**
|
||||||
|
* @brief Assert that `shape` does not contain negative dimensions.
|
||||||
|
*
|
||||||
|
* @param ndims Number of dimensions in `shape`
|
||||||
|
* @param shape The shape to check on
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
void assert_shape_no_negative(SizeT ndims, const SizeT* shape) {
|
||||||
|
for (SizeT axis = 0; axis < ndims; axis++) {
|
||||||
|
if (shape[axis] < 0) {
|
||||||
|
raise_exception(SizeT, EXN_VALUE_ERROR,
|
||||||
|
"negative dimensions are not allowed; axis {0} "
|
||||||
|
"has dimension {1}",
|
||||||
|
axis, shape[axis], NO_PARAM);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Assert that two shapes are the same in the context of writing output to an ndarray.
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
void assert_output_shape_same(SizeT ndarray_ndims,
|
||||||
|
const SizeT* ndarray_shape,
|
||||||
|
SizeT output_ndims,
|
||||||
|
const SizeT* output_shape) {
|
||||||
|
if (ndarray_ndims != output_ndims) {
|
||||||
|
// There is no corresponding NumPy error message like this.
|
||||||
|
raise_exception(SizeT, EXN_VALUE_ERROR, "Cannot write output of ndims {0} to an ndarray with ndims {1}",
|
||||||
|
output_ndims, ndarray_ndims, NO_PARAM);
|
||||||
|
}
|
||||||
|
|
||||||
|
for (SizeT axis = 0; axis < ndarray_ndims; axis++) {
|
||||||
|
if (ndarray_shape[axis] != output_shape[axis]) {
|
||||||
|
// There is no corresponding NumPy error message like this.
|
||||||
|
raise_exception(SizeT, EXN_VALUE_ERROR,
|
||||||
|
"Mismatched dimensions on axis {0}, output has "
|
||||||
|
"dimension {1}, but destination ndarray has dimension {2}.",
|
||||||
|
axis, output_shape[axis], ndarray_shape[axis]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Return the number of elements of an ndarray given its shape.
|
||||||
|
*
|
||||||
|
* @param ndims Number of dimensions in `shape`
|
||||||
|
* @param shape The shape of the ndarray
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
SizeT calc_size_from_shape(SizeT ndims, const SizeT* shape) {
|
||||||
|
SizeT size = 1;
|
||||||
|
for (SizeT axis = 0; axis < ndims; axis++)
|
||||||
|
size *= shape[axis];
|
||||||
|
return size;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Compute the array indices of the `nth` (0-based) element of an ndarray given only its shape.
|
||||||
|
*
|
||||||
|
* @param ndims Number of elements in `shape` and `indices`
|
||||||
|
* @param shape The shape of the ndarray
|
||||||
|
* @param indices The returned indices indexing the ndarray with shape `shape`.
|
||||||
|
* @param nth The index of the element of interest.
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
void set_indices_by_nth(SizeT ndims, const SizeT* shape, SizeT* indices, SizeT nth) {
|
||||||
|
for (SizeT i = 0; i < ndims; i++) {
|
||||||
|
SizeT axis = ndims - i - 1;
|
||||||
|
SizeT dim = shape[axis];
|
||||||
|
|
||||||
|
indices[axis] = nth % dim;
|
||||||
|
nth /= dim;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Return the number of elements of an `ndarray`
|
||||||
|
*
|
||||||
|
* This function corresponds to `<an_ndarray>.size`
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
SizeT size(const NDArray<SizeT>* ndarray) {
|
||||||
|
return calc_size_from_shape(ndarray->ndims, ndarray->shape);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Return of the number of its content of an `ndarray`.
|
||||||
|
*
|
||||||
|
* This function corresponds to `<an_ndarray>.nbytes`.
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
SizeT nbytes(const NDArray<SizeT>* ndarray) {
|
||||||
|
return size(ndarray) * ndarray->itemsize;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Get the `len()` of an ndarray, and asserts that `ndarray` is a sized object.
|
||||||
|
*
|
||||||
|
* This function corresponds to `<an_ndarray>.__len__`.
|
||||||
|
*
|
||||||
|
* @param dst_length The length.
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
SizeT len(const NDArray<SizeT>* ndarray) {
|
||||||
|
// numpy prohibits `__len__` on unsized objects
|
||||||
|
if (ndarray->ndims == 0) {
|
||||||
|
raise_exception(SizeT, EXN_TYPE_ERROR, "len() of unsized object", NO_PARAM, NO_PARAM, NO_PARAM);
|
||||||
|
} else {
|
||||||
|
return ndarray->shape[0];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Return a boolean indicating if `ndarray` is (C-)contiguous.
|
||||||
|
*
|
||||||
|
* You may want to see ndarray's rules for C-contiguity:
|
||||||
|
* https://github.com/numpy/numpy/blob/df256d0d2f3bc6833699529824781c58f9c6e697/numpy/core/src/multiarray/flagsobject.c#L95C1-L99C45
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
bool is_c_contiguous(const NDArray<SizeT>* ndarray) {
|
||||||
|
// References:
|
||||||
|
// - tinynumpy's implementation:
|
||||||
|
// https://github.com/wadetb/tinynumpy/blob/0d23d22e07062ffab2afa287374c7b366eebdda1/tinynumpy/tinynumpy.py#L102
|
||||||
|
// - ndarray's flags["C_CONTIGUOUS"]:
|
||||||
|
// https://numpy.org/doc/stable/reference/generated/numpy.ndarray.flags.html#numpy.ndarray.flags
|
||||||
|
// - ndarray's rules for C-contiguity:
|
||||||
|
// https://github.com/numpy/numpy/blob/df256d0d2f3bc6833699529824781c58f9c6e697/numpy/core/src/multiarray/flagsobject.c#L95C1-L99C45
|
||||||
|
|
||||||
|
// From
|
||||||
|
// https://github.com/numpy/numpy/blob/df256d0d2f3bc6833699529824781c58f9c6e697/numpy/core/src/multiarray/flagsobject.c#L95C1-L99C45:
|
||||||
|
//
|
||||||
|
// The traditional rule is that for an array to be flagged as C contiguous,
|
||||||
|
// the following must hold:
|
||||||
|
//
|
||||||
|
// strides[-1] == itemsize
|
||||||
|
// strides[i] == shape[i+1] * strides[i + 1]
|
||||||
|
// [...]
|
||||||
|
// According to these rules, a 0- or 1-dimensional array is either both
|
||||||
|
// C- and F-contiguous, or neither; and an array with 2+ dimensions
|
||||||
|
// can be C- or F- contiguous, or neither, but not both. Though there
|
||||||
|
// there are exceptions for arrays with zero or one item, in the first
|
||||||
|
// case the check is relaxed up to and including the first dimension
|
||||||
|
// with shape[i] == 0. In the second case `strides == itemsize` will
|
||||||
|
// can be true for all dimensions and both flags are set.
|
||||||
|
|
||||||
|
if (ndarray->ndims == 0) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (ndarray->strides[ndarray->ndims - 1] != ndarray->itemsize) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (SizeT i = 1; i < ndarray->ndims; i++) {
|
||||||
|
SizeT axis_i = ndarray->ndims - i - 1;
|
||||||
|
if (ndarray->strides[axis_i] != ndarray->shape[axis_i + 1] * ndarray->strides[axis_i + 1]) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Return the pointer to the element indexed by `indices` along the ndarray's axes.
|
||||||
|
*
|
||||||
|
* This function does no bound check.
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
uint8_t* get_pelement_by_indices(const NDArray<SizeT>* ndarray, const SizeT* indices) {
|
||||||
|
uint8_t* element = ndarray->data;
|
||||||
|
for (SizeT dim_i = 0; dim_i < ndarray->ndims; dim_i++)
|
||||||
|
element += indices[dim_i] * ndarray->strides[dim_i];
|
||||||
|
return element;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Return the pointer to the nth (0-based) element of `ndarray` in flattened view.
|
||||||
|
*
|
||||||
|
* This function does no bound check.
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
uint8_t* get_nth_pelement(const NDArray<SizeT>* ndarray, SizeT nth) {
|
||||||
|
uint8_t* element = ndarray->data;
|
||||||
|
for (SizeT i = 0; i < ndarray->ndims; i++) {
|
||||||
|
SizeT axis = ndarray->ndims - i - 1;
|
||||||
|
SizeT dim = ndarray->shape[axis];
|
||||||
|
element += ndarray->strides[axis] * (nth % dim);
|
||||||
|
nth /= dim;
|
||||||
|
}
|
||||||
|
return element;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Update the strides of an ndarray given an ndarray `shape` to be contiguous.
|
||||||
|
*
|
||||||
|
* You might want to read https://ajcr.net/stride-guide-part-1/.
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
void set_strides_by_shape(NDArray<SizeT>* ndarray) {
|
||||||
|
SizeT stride_product = 1;
|
||||||
|
for (SizeT i = 0; i < ndarray->ndims; i++) {
|
||||||
|
SizeT axis = ndarray->ndims - i - 1;
|
||||||
|
ndarray->strides[axis] = stride_product * ndarray->itemsize;
|
||||||
|
stride_product *= ndarray->shape[axis];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Set an element in `ndarray`.
|
||||||
|
*
|
||||||
|
* @param pelement Pointer to the element in `ndarray` to be set.
|
||||||
|
* @param pvalue Pointer to the value `pelement` will be set to.
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
void set_pelement_value(NDArray<SizeT>* ndarray, uint8_t* pelement, const uint8_t* pvalue) {
|
||||||
|
__builtin_memcpy(pelement, pvalue, ndarray->itemsize);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Copy data from one ndarray to another of the exact same size and itemsize.
|
||||||
|
*
|
||||||
|
* Both ndarrays will be viewed in their flatten views when copying the elements.
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
void copy_data(const NDArray<SizeT>* src_ndarray, NDArray<SizeT>* dst_ndarray) {
|
||||||
|
// TODO: Make this faster with memcpy when we see a contiguous segment.
|
||||||
|
// TODO: Handle overlapping.
|
||||||
|
|
||||||
|
debug_assert_eq(SizeT, src_ndarray->itemsize, dst_ndarray->itemsize);
|
||||||
|
|
||||||
|
for (SizeT i = 0; i < size(src_ndarray); i++) {
|
||||||
|
auto src_element = ndarray::basic::get_nth_pelement(src_ndarray, i);
|
||||||
|
auto dst_element = ndarray::basic::get_nth_pelement(dst_ndarray, i);
|
||||||
|
ndarray::basic::set_pelement_value(dst_ndarray, dst_element, src_element);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} // namespace basic
|
||||||
|
} // namespace ndarray
|
||||||
|
} // namespace
|
||||||
|
|
||||||
|
extern "C" {
|
||||||
|
using namespace ndarray::basic;
|
||||||
|
|
||||||
|
void __nac3_ndarray_util_assert_shape_no_negative(int32_t ndims, int32_t* shape) {
|
||||||
|
assert_shape_no_negative(ndims, shape);
|
||||||
|
}
|
||||||
|
|
||||||
|
void __nac3_ndarray_util_assert_shape_no_negative64(int64_t ndims, int64_t* shape) {
|
||||||
|
assert_shape_no_negative(ndims, shape);
|
||||||
|
}
|
||||||
|
|
||||||
|
void __nac3_ndarray_util_assert_output_shape_same(int32_t ndarray_ndims,
|
||||||
|
const int32_t* ndarray_shape,
|
||||||
|
int32_t output_ndims,
|
||||||
|
const int32_t* output_shape) {
|
||||||
|
assert_output_shape_same(ndarray_ndims, ndarray_shape, output_ndims, output_shape);
|
||||||
|
}
|
||||||
|
|
||||||
|
void __nac3_ndarray_util_assert_output_shape_same64(int64_t ndarray_ndims,
|
||||||
|
const int64_t* ndarray_shape,
|
||||||
|
int64_t output_ndims,
|
||||||
|
const int64_t* output_shape) {
|
||||||
|
assert_output_shape_same(ndarray_ndims, ndarray_shape, output_ndims, output_shape);
|
||||||
|
}
|
||||||
|
|
||||||
|
uint32_t __nac3_ndarray_size(NDArray<int32_t>* ndarray) {
|
||||||
|
return size(ndarray);
|
||||||
|
}
|
||||||
|
|
||||||
|
uint64_t __nac3_ndarray_size64(NDArray<int64_t>* ndarray) {
|
||||||
|
return size(ndarray);
|
||||||
|
}
|
||||||
|
|
||||||
|
uint32_t __nac3_ndarray_nbytes(NDArray<int32_t>* ndarray) {
|
||||||
|
return nbytes(ndarray);
|
||||||
|
}
|
||||||
|
|
||||||
|
uint64_t __nac3_ndarray_nbytes64(NDArray<int64_t>* ndarray) {
|
||||||
|
return nbytes(ndarray);
|
||||||
|
}
|
||||||
|
|
||||||
|
int32_t __nac3_ndarray_len(NDArray<int32_t>* ndarray) {
|
||||||
|
return len(ndarray);
|
||||||
|
}
|
||||||
|
|
||||||
|
int64_t __nac3_ndarray_len64(NDArray<int64_t>* ndarray) {
|
||||||
|
return len(ndarray);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool __nac3_ndarray_is_c_contiguous(NDArray<int32_t>* ndarray) {
|
||||||
|
return is_c_contiguous(ndarray);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool __nac3_ndarray_is_c_contiguous64(NDArray<int64_t>* ndarray) {
|
||||||
|
return is_c_contiguous(ndarray);
|
||||||
|
}
|
||||||
|
|
||||||
|
uint8_t* __nac3_ndarray_get_nth_pelement(const NDArray<int32_t>* ndarray, int32_t nth) {
|
||||||
|
return get_nth_pelement(ndarray, nth);
|
||||||
|
}
|
||||||
|
|
||||||
|
uint8_t* __nac3_ndarray_get_nth_pelement64(const NDArray<int64_t>* ndarray, int64_t nth) {
|
||||||
|
return get_nth_pelement(ndarray, nth);
|
||||||
|
}
|
||||||
|
|
||||||
|
uint8_t* __nac3_ndarray_get_pelement_by_indices(const NDArray<int32_t>* ndarray, int32_t* indices) {
|
||||||
|
return get_pelement_by_indices(ndarray, indices);
|
||||||
|
}
|
||||||
|
|
||||||
|
uint8_t* __nac3_ndarray_get_pelement_by_indices64(const NDArray<int64_t>* ndarray, int64_t* indices) {
|
||||||
|
return get_pelement_by_indices(ndarray, indices);
|
||||||
|
}
|
||||||
|
|
||||||
|
void __nac3_ndarray_set_strides_by_shape(NDArray<int32_t>* ndarray) {
|
||||||
|
set_strides_by_shape(ndarray);
|
||||||
|
}
|
||||||
|
|
||||||
|
void __nac3_ndarray_set_strides_by_shape64(NDArray<int64_t>* ndarray) {
|
||||||
|
set_strides_by_shape(ndarray);
|
||||||
|
}
|
||||||
|
|
||||||
|
void __nac3_ndarray_copy_data(NDArray<int32_t>* src_ndarray, NDArray<int32_t>* dst_ndarray) {
|
||||||
|
copy_data(src_ndarray, dst_ndarray);
|
||||||
|
}
|
||||||
|
|
||||||
|
void __nac3_ndarray_copy_data64(NDArray<int64_t>* src_ndarray, NDArray<int64_t>* dst_ndarray) {
|
||||||
|
copy_data(src_ndarray, dst_ndarray);
|
||||||
|
}
|
||||||
|
}
|
|
@ -0,0 +1,45 @@
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include "irrt/int_types.hpp"
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
/**
|
||||||
|
* @brief The NDArray object
|
||||||
|
*
|
||||||
|
* Official numpy implementation:
|
||||||
|
* https://github.com/numpy/numpy/blob/735a477f0bc2b5b84d0e72d92f224bde78d4e069/doc/source/reference/c-api/types-and-structures.rst
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
struct NDArray {
|
||||||
|
/**
|
||||||
|
* @brief The underlying data this `ndarray` is pointing to.
|
||||||
|
*/
|
||||||
|
uint8_t* data;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief The number of bytes of a single element in `data`.
|
||||||
|
*/
|
||||||
|
SizeT itemsize;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief The number of dimensions of this shape.
|
||||||
|
*/
|
||||||
|
SizeT ndims;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief The NDArray shape, with length equal to `ndims`.
|
||||||
|
*
|
||||||
|
* Note that it may contain 0.
|
||||||
|
*/
|
||||||
|
SizeT* shape;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Array strides, with length equal to `ndims`
|
||||||
|
*
|
||||||
|
* The stride values are in units of bytes, not number of elements.
|
||||||
|
*
|
||||||
|
* Note that `strides` can have negative values or contain 0.
|
||||||
|
*/
|
||||||
|
SizeT* strides;
|
||||||
|
};
|
||||||
|
} // namespace
|
|
@ -0,0 +1,220 @@
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include "irrt/exception.hpp"
|
||||||
|
#include "irrt/int_types.hpp"
|
||||||
|
#include "irrt/ndarray/basic.hpp"
|
||||||
|
#include "irrt/ndarray/def.hpp"
|
||||||
|
#include "irrt/range.hpp"
|
||||||
|
#include "irrt/slice.hpp"
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
typedef uint8_t NDIndexType;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief A single element index
|
||||||
|
*
|
||||||
|
* `data` points to a `int32_t`.
|
||||||
|
*/
|
||||||
|
const NDIndexType ND_INDEX_TYPE_SINGLE_ELEMENT = 0;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief A slice index
|
||||||
|
*
|
||||||
|
* `data` points to a `Slice<int32_t>`.
|
||||||
|
*/
|
||||||
|
const NDIndexType ND_INDEX_TYPE_SLICE = 1;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief `np.newaxis` / `None`
|
||||||
|
*
|
||||||
|
* `data` is unused.
|
||||||
|
*/
|
||||||
|
const NDIndexType ND_INDEX_TYPE_NEWAXIS = 2;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief `Ellipsis` / `...`
|
||||||
|
*
|
||||||
|
* `data` is unused.
|
||||||
|
*/
|
||||||
|
const NDIndexType ND_INDEX_TYPE_ELLIPSIS = 3;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief An index used in ndarray indexing
|
||||||
|
*
|
||||||
|
* That is:
|
||||||
|
* ```
|
||||||
|
* my_ndarray[::-1, 3, ..., np.newaxis]
|
||||||
|
* ^^^^ ^ ^^^ ^^^^^^^^^^ each of these is represented by an NDIndex.
|
||||||
|
* ```
|
||||||
|
*/
|
||||||
|
struct NDIndex {
|
||||||
|
/**
|
||||||
|
* @brief Enum tag to specify the type of index.
|
||||||
|
*
|
||||||
|
* Please see the comment of each enum constant.
|
||||||
|
*/
|
||||||
|
NDIndexType type;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief The accompanying data associated with `type`.
|
||||||
|
*
|
||||||
|
* Please see the comment of each enum constant.
|
||||||
|
*/
|
||||||
|
uint8_t* data;
|
||||||
|
};
|
||||||
|
} // namespace
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
namespace ndarray {
|
||||||
|
namespace indexing {
|
||||||
|
/**
|
||||||
|
* @brief Perform ndarray "basic indexing" (https://numpy.org/doc/stable/user/basics.indexing.html#basic-indexing)
|
||||||
|
*
|
||||||
|
* This function is very similar to performing `dst_ndarray = src_ndarray[indices]` in Python.
|
||||||
|
*
|
||||||
|
* This function also does proper assertions on `indices` to check for out of bounds access and more.
|
||||||
|
*
|
||||||
|
* # Notes on `dst_ndarray`
|
||||||
|
* The caller is responsible for allocating space for the resulting ndarray.
|
||||||
|
* Here is what this function expects from `dst_ndarray` when called:
|
||||||
|
* - `dst_ndarray->data` does not have to be initialized.
|
||||||
|
* - `dst_ndarray->itemsize` does not have to be initialized.
|
||||||
|
* - `dst_ndarray->ndims` must be initialized, and it must be equal to the expected `ndims` of the `dst_ndarray` after
|
||||||
|
* indexing `src_ndarray` with `indices`.
|
||||||
|
* - `dst_ndarray->shape` must be allocated, through it can contain uninitialized values.
|
||||||
|
* - `dst_ndarray->strides` must be allocated, through it can contain uninitialized values.
|
||||||
|
* When this function call ends:
|
||||||
|
* - `dst_ndarray->data` is set to `src_ndarray->data`.
|
||||||
|
* - `dst_ndarray->itemsize` is set to `src_ndarray->itemsize`.
|
||||||
|
* - `dst_ndarray->ndims` is unchanged.
|
||||||
|
* - `dst_ndarray->shape` is updated according to how `src_ndarray` is indexed.
|
||||||
|
* - `dst_ndarray->strides` is updated accordingly by how ndarray indexing works.
|
||||||
|
*
|
||||||
|
* @param indices indices to index `src_ndarray`, ordered in the same way you would write them in Python.
|
||||||
|
* @param src_ndarray The NDArray to be indexed.
|
||||||
|
* @param dst_ndarray The resulting NDArray after indexing. Further details in the comments above,
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
void index(SizeT num_indices, const NDIndex* indices, const NDArray<SizeT>* src_ndarray, NDArray<SizeT>* dst_ndarray) {
|
||||||
|
// Validate `indices`.
|
||||||
|
|
||||||
|
// Expected value of `dst_ndarray->ndims`.
|
||||||
|
SizeT expected_dst_ndims = src_ndarray->ndims;
|
||||||
|
// To check for "too many indices for array: array is ?-dimensional, but ? were indexed"
|
||||||
|
SizeT num_indexed = 0;
|
||||||
|
// There may be ellipsis `...` in `indices`. There can only be 0 or 1 ellipsis.
|
||||||
|
SizeT num_ellipsis = 0;
|
||||||
|
|
||||||
|
for (SizeT i = 0; i < num_indices; i++) {
|
||||||
|
if (indices[i].type == ND_INDEX_TYPE_SINGLE_ELEMENT) {
|
||||||
|
expected_dst_ndims--;
|
||||||
|
num_indexed++;
|
||||||
|
} else if (indices[i].type == ND_INDEX_TYPE_SLICE) {
|
||||||
|
num_indexed++;
|
||||||
|
} else if (indices[i].type == ND_INDEX_TYPE_NEWAXIS) {
|
||||||
|
expected_dst_ndims++;
|
||||||
|
} else if (indices[i].type == ND_INDEX_TYPE_ELLIPSIS) {
|
||||||
|
num_ellipsis++;
|
||||||
|
if (num_ellipsis > 1) {
|
||||||
|
raise_exception(SizeT, EXN_INDEX_ERROR, "an index can only have a single ellipsis ('...')", NO_PARAM,
|
||||||
|
NO_PARAM, NO_PARAM);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
__builtin_unreachable();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
debug_assert_eq(SizeT, expected_dst_ndims, dst_ndarray->ndims);
|
||||||
|
|
||||||
|
if (src_ndarray->ndims - num_indexed < 0) {
|
||||||
|
raise_exception(SizeT, EXN_INDEX_ERROR,
|
||||||
|
"too many indices for array: array is {0}-dimensional, "
|
||||||
|
"but {1} were indexed",
|
||||||
|
src_ndarray->ndims, num_indices, NO_PARAM);
|
||||||
|
}
|
||||||
|
|
||||||
|
dst_ndarray->data = src_ndarray->data;
|
||||||
|
dst_ndarray->itemsize = src_ndarray->itemsize;
|
||||||
|
|
||||||
|
// Reference code:
|
||||||
|
// https://github.com/wadetb/tinynumpy/blob/0d23d22e07062ffab2afa287374c7b366eebdda1/tinynumpy/tinynumpy.py#L652
|
||||||
|
SizeT src_axis = 0;
|
||||||
|
SizeT dst_axis = 0;
|
||||||
|
|
||||||
|
for (int32_t i = 0; i < num_indices; i++) {
|
||||||
|
const NDIndex* index = &indices[i];
|
||||||
|
if (index->type == ND_INDEX_TYPE_SINGLE_ELEMENT) {
|
||||||
|
SizeT input = (SizeT) * ((int32_t*)index->data);
|
||||||
|
|
||||||
|
SizeT k = slice::resolve_index_in_length(src_ndarray->shape[src_axis], input);
|
||||||
|
if (k == -1) {
|
||||||
|
raise_exception(SizeT, EXN_INDEX_ERROR,
|
||||||
|
"index {0} is out of bounds for axis {1} "
|
||||||
|
"with size {2}",
|
||||||
|
input, src_axis, src_ndarray->shape[src_axis]);
|
||||||
|
}
|
||||||
|
|
||||||
|
dst_ndarray->data += k * src_ndarray->strides[src_axis];
|
||||||
|
|
||||||
|
src_axis++;
|
||||||
|
} else if (index->type == ND_INDEX_TYPE_SLICE) {
|
||||||
|
Slice<int32_t>* slice = (Slice<int32_t>*)index->data;
|
||||||
|
|
||||||
|
Range<int32_t> range = slice->indices_checked<SizeT>(src_ndarray->shape[src_axis]);
|
||||||
|
|
||||||
|
dst_ndarray->data += (SizeT)range.start * src_ndarray->strides[src_axis];
|
||||||
|
dst_ndarray->strides[dst_axis] = ((SizeT)range.step) * src_ndarray->strides[src_axis];
|
||||||
|
dst_ndarray->shape[dst_axis] = (SizeT)range.len<SizeT>();
|
||||||
|
|
||||||
|
dst_axis++;
|
||||||
|
src_axis++;
|
||||||
|
} else if (index->type == ND_INDEX_TYPE_NEWAXIS) {
|
||||||
|
dst_ndarray->strides[dst_axis] = 0;
|
||||||
|
dst_ndarray->shape[dst_axis] = 1;
|
||||||
|
|
||||||
|
dst_axis++;
|
||||||
|
} else if (index->type == ND_INDEX_TYPE_ELLIPSIS) {
|
||||||
|
// The number of ':' entries this '...' implies.
|
||||||
|
SizeT ellipsis_size = src_ndarray->ndims - num_indexed;
|
||||||
|
|
||||||
|
for (SizeT j = 0; j < ellipsis_size; j++) {
|
||||||
|
dst_ndarray->strides[dst_axis] = src_ndarray->strides[src_axis];
|
||||||
|
dst_ndarray->shape[dst_axis] = src_ndarray->shape[src_axis];
|
||||||
|
|
||||||
|
dst_axis++;
|
||||||
|
src_axis++;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
__builtin_unreachable();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for (; dst_axis < dst_ndarray->ndims; dst_axis++, src_axis++) {
|
||||||
|
dst_ndarray->shape[dst_axis] = src_ndarray->shape[src_axis];
|
||||||
|
dst_ndarray->strides[dst_axis] = src_ndarray->strides[src_axis];
|
||||||
|
}
|
||||||
|
|
||||||
|
debug_assert_eq(SizeT, src_ndarray->ndims, src_axis);
|
||||||
|
debug_assert_eq(SizeT, dst_ndarray->ndims, dst_axis);
|
||||||
|
}
|
||||||
|
} // namespace indexing
|
||||||
|
} // namespace ndarray
|
||||||
|
} // namespace
|
||||||
|
|
||||||
|
extern "C" {
|
||||||
|
using namespace ndarray::indexing;
|
||||||
|
|
||||||
|
void __nac3_ndarray_index(int32_t num_indices,
|
||||||
|
NDIndex* indices,
|
||||||
|
NDArray<int32_t>* src_ndarray,
|
||||||
|
NDArray<int32_t>* dst_ndarray) {
|
||||||
|
index(num_indices, indices, src_ndarray, dst_ndarray);
|
||||||
|
}
|
||||||
|
|
||||||
|
void __nac3_ndarray_index64(int64_t num_indices,
|
||||||
|
NDIndex* indices,
|
||||||
|
NDArray<int64_t>* src_ndarray,
|
||||||
|
NDArray<int64_t>* dst_ndarray) {
|
||||||
|
index(num_indices, indices, src_ndarray, dst_ndarray);
|
||||||
|
}
|
||||||
|
}
|
|
@ -0,0 +1,146 @@
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include "irrt/int_types.hpp"
|
||||||
|
#include "irrt/ndarray/def.hpp"
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
/**
|
||||||
|
* @brief Helper struct to enumerate through an ndarray *efficiently*.
|
||||||
|
*
|
||||||
|
* Example usage (in pseudo-code):
|
||||||
|
* ```
|
||||||
|
* // Suppose my_ndarray has been initialized, with shape [2, 3] and dtype `double`
|
||||||
|
* NDIter nditer;
|
||||||
|
* nditer.initialize(my_ndarray);
|
||||||
|
* while (nditer.has_element()) {
|
||||||
|
* // This body is run 6 (= my_ndarray.size) times.
|
||||||
|
*
|
||||||
|
* // [0, 0] -> [0, 1] -> [0, 2] -> [1, 0] -> [1, 1] -> [1, 2] -> end
|
||||||
|
* print(nditer.indices);
|
||||||
|
*
|
||||||
|
* // 0 -> 1 -> 2 -> 3 -> 4 -> 5
|
||||||
|
* print(nditer.nth);
|
||||||
|
*
|
||||||
|
* // <1st element> -> <2nd element> -> ... -> <6th element> -> end
|
||||||
|
* print(*((double *) nditer.element))
|
||||||
|
*
|
||||||
|
* nditer.next(); // Go to next element.
|
||||||
|
* }
|
||||||
|
* ```
|
||||||
|
*
|
||||||
|
* Interesting cases:
|
||||||
|
* - If `my_ndarray.ndims` == 0, there is one iteration.
|
||||||
|
* - If `my_ndarray.shape` contains zeroes, there are no iterations.
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
struct NDIter {
|
||||||
|
// Information about the ndarray being iterated over.
|
||||||
|
SizeT ndims;
|
||||||
|
SizeT* shape;
|
||||||
|
SizeT* strides;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief The current indices.
|
||||||
|
*
|
||||||
|
* Must be allocated by the caller.
|
||||||
|
*/
|
||||||
|
SizeT* indices;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief The nth (0-based) index of the current indices.
|
||||||
|
*
|
||||||
|
* Initially this is 0.
|
||||||
|
*/
|
||||||
|
SizeT nth;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Pointer to the current element.
|
||||||
|
*
|
||||||
|
* Initially this points to first element of the ndarray.
|
||||||
|
*/
|
||||||
|
uint8_t* element;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Cache for the product of shape.
|
||||||
|
*
|
||||||
|
* Could be 0 if `shape` has 0s in it.
|
||||||
|
*/
|
||||||
|
SizeT size;
|
||||||
|
|
||||||
|
void initialize(SizeT ndims, SizeT* shape, SizeT* strides, uint8_t* element, SizeT* indices) {
|
||||||
|
this->ndims = ndims;
|
||||||
|
this->shape = shape;
|
||||||
|
this->strides = strides;
|
||||||
|
|
||||||
|
this->indices = indices;
|
||||||
|
this->element = element;
|
||||||
|
|
||||||
|
// Compute size
|
||||||
|
this->size = 1;
|
||||||
|
for (SizeT i = 0; i < ndims; i++) {
|
||||||
|
this->size *= shape[i];
|
||||||
|
}
|
||||||
|
|
||||||
|
// `indices` starts on all 0s.
|
||||||
|
for (SizeT axis = 0; axis < ndims; axis++)
|
||||||
|
indices[axis] = 0;
|
||||||
|
nth = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
void initialize_by_ndarray(NDArray<SizeT>* ndarray, SizeT* indices) {
|
||||||
|
// NOTE: ndarray->data is pointing to the first element, and `NDIter`'s `element` should also point to the first
|
||||||
|
// element as well.
|
||||||
|
this->initialize(ndarray->ndims, ndarray->shape, ndarray->strides, ndarray->data, indices);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Is the current iteration valid?
|
||||||
|
// If true, then `element`, `indices` and `nth` contain details about the current element.
|
||||||
|
bool has_element() { return nth < size; }
|
||||||
|
|
||||||
|
// Go to the next element.
|
||||||
|
void next() {
|
||||||
|
for (SizeT i = 0; i < ndims; i++) {
|
||||||
|
SizeT axis = ndims - i - 1;
|
||||||
|
indices[axis]++;
|
||||||
|
if (indices[axis] >= shape[axis]) {
|
||||||
|
indices[axis] = 0;
|
||||||
|
|
||||||
|
// TODO: There is something called backstrides to speedup iteration.
|
||||||
|
// See https://ajcr.net/stride-guide-part-1/, and
|
||||||
|
// https://docs.scipy.org/doc/numpy-1.13.0/reference/c-api.types-and-structures.html#c.PyArrayIterObject.PyArrayIterObject.backstrides.
|
||||||
|
element -= strides[axis] * (shape[axis] - 1);
|
||||||
|
} else {
|
||||||
|
element += strides[axis];
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
nth++;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
} // namespace
|
||||||
|
|
||||||
|
extern "C" {
|
||||||
|
void __nac3_nditer_initialize(NDIter<int32_t>* iter, NDArray<int32_t>* ndarray, int32_t* indices) {
|
||||||
|
iter->initialize_by_ndarray(ndarray, indices);
|
||||||
|
}
|
||||||
|
|
||||||
|
void __nac3_nditer_initialize64(NDIter<int64_t>* iter, NDArray<int64_t>* ndarray, int64_t* indices) {
|
||||||
|
iter->initialize_by_ndarray(ndarray, indices);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool __nac3_nditer_has_element(NDIter<int32_t>* iter) {
|
||||||
|
return iter->has_element();
|
||||||
|
}
|
||||||
|
|
||||||
|
bool __nac3_nditer_has_element64(NDIter<int64_t>* iter) {
|
||||||
|
return iter->has_element();
|
||||||
|
}
|
||||||
|
|
||||||
|
void __nac3_nditer_next(NDIter<int32_t>* iter) {
|
||||||
|
iter->next();
|
||||||
|
}
|
||||||
|
|
||||||
|
void __nac3_nditer_next64(NDIter<int64_t>* iter) {
|
||||||
|
iter->next();
|
||||||
|
}
|
||||||
|
}
|
|
@ -0,0 +1,47 @@
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include "irrt/debug.hpp"
|
||||||
|
#include "irrt/int_types.hpp"
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
namespace range {
|
||||||
|
template<typename T>
|
||||||
|
T len(T start, T stop, T step) {
|
||||||
|
// Reference:
|
||||||
|
// https://github.com/python/cpython/blob/9dbd12375561a393eaec4b21ee4ac568a407cdb0/Objects/rangeobject.c#L933
|
||||||
|
if (step > 0 && start < stop)
|
||||||
|
return 1 + (stop - 1 - start) / step;
|
||||||
|
else if (step < 0 && start > stop)
|
||||||
|
return 1 + (start - 1 - stop) / (-step);
|
||||||
|
else
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
} // namespace range
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief A Python range.
|
||||||
|
*/
|
||||||
|
template<typename T>
|
||||||
|
struct Range {
|
||||||
|
T start;
|
||||||
|
T stop;
|
||||||
|
T step;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Calculate the `len()` of this range.
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
T len() {
|
||||||
|
debug_assert(SizeT, step != 0);
|
||||||
|
return range::len(start, stop, step);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
} // namespace
|
||||||
|
|
||||||
|
extern "C" {
|
||||||
|
using namespace range;
|
||||||
|
|
||||||
|
SliceIndex __nac3_range_slice_len(const SliceIndex start, const SliceIndex end, const SliceIndex step) {
|
||||||
|
return len(start, end, step);
|
||||||
|
}
|
||||||
|
}
|
|
@ -1,6 +1,145 @@
|
||||||
#pragma once
|
#pragma once
|
||||||
|
|
||||||
|
#include "irrt/debug.hpp"
|
||||||
|
#include "irrt/exception.hpp"
|
||||||
#include "irrt/int_types.hpp"
|
#include "irrt/int_types.hpp"
|
||||||
|
#include "irrt/math_util.hpp"
|
||||||
|
#include "irrt/range.hpp"
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
namespace slice {
|
||||||
|
/**
|
||||||
|
* @brief Resolve a possibly negative index in a list of a known length.
|
||||||
|
*
|
||||||
|
* Returns -1 if the resolved index is out of the list's bounds.
|
||||||
|
*/
|
||||||
|
template<typename T>
|
||||||
|
T resolve_index_in_length(T length, T index) {
|
||||||
|
T resolved = index < 0 ? length + index : index;
|
||||||
|
if (0 <= resolved && resolved < length) {
|
||||||
|
return resolved;
|
||||||
|
} else {
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Resolve a slice as a range.
|
||||||
|
*
|
||||||
|
* This is equivalent to `range(*slice(start, stop, step).indices(length))` in Python.
|
||||||
|
*/
|
||||||
|
template<typename T>
|
||||||
|
void indices(bool start_defined,
|
||||||
|
T start,
|
||||||
|
bool stop_defined,
|
||||||
|
T stop,
|
||||||
|
bool step_defined,
|
||||||
|
T step,
|
||||||
|
T length,
|
||||||
|
T* range_start,
|
||||||
|
T* range_stop,
|
||||||
|
T* range_step) {
|
||||||
|
// Reference: https://github.com/python/cpython/blob/main/Objects/sliceobject.c#L388
|
||||||
|
*range_step = step_defined ? step : 1;
|
||||||
|
bool step_is_negative = *range_step < 0;
|
||||||
|
|
||||||
|
T lower, upper;
|
||||||
|
if (step_is_negative) {
|
||||||
|
lower = -1;
|
||||||
|
upper = length - 1;
|
||||||
|
} else {
|
||||||
|
lower = 0;
|
||||||
|
upper = length;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (start_defined) {
|
||||||
|
*range_start = start < 0 ? max(lower, start + length) : min(upper, start);
|
||||||
|
} else {
|
||||||
|
*range_start = step_is_negative ? upper : lower;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (stop_defined) {
|
||||||
|
*range_stop = stop < 0 ? max(lower, stop + length) : min(upper, stop);
|
||||||
|
} else {
|
||||||
|
*range_stop = step_is_negative ? lower : upper;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} // namespace slice
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief A Python-like slice with **unresolved** indices.
|
||||||
|
*/
|
||||||
|
template<typename T>
|
||||||
|
struct Slice {
|
||||||
|
bool start_defined;
|
||||||
|
T start;
|
||||||
|
|
||||||
|
bool stop_defined;
|
||||||
|
T stop;
|
||||||
|
|
||||||
|
bool step_defined;
|
||||||
|
T step;
|
||||||
|
|
||||||
|
Slice() { this->reset(); }
|
||||||
|
|
||||||
|
void reset() {
|
||||||
|
this->start_defined = false;
|
||||||
|
this->stop_defined = false;
|
||||||
|
this->step_defined = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_start(T start) {
|
||||||
|
this->start_defined = true;
|
||||||
|
this->start = start;
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_stop(T stop) {
|
||||||
|
this->stop_defined = true;
|
||||||
|
this->stop = stop;
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_step(T step) {
|
||||||
|
this->step_defined = true;
|
||||||
|
this->step = step;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Resolve this slice as a range.
|
||||||
|
*
|
||||||
|
* In Python, this would be `range(*slice(start, stop, step).indices(length))`.
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
Range<T> indices(T length) {
|
||||||
|
// Reference:
|
||||||
|
// https://github.com/python/cpython/blob/main/Objects/sliceobject.c#L388
|
||||||
|
debug_assert(SizeT, length >= 0);
|
||||||
|
|
||||||
|
Range<T> result;
|
||||||
|
slice::indices(start_defined, start, stop_defined, stop, step_defined, step, length, &result.start,
|
||||||
|
&result.stop, &result.step);
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Like `.indices()` but with assertions.
|
||||||
|
*/
|
||||||
|
template<typename SizeT>
|
||||||
|
Range<T> indices_checked(T length) {
|
||||||
|
// TODO: Switch to `SizeT length`
|
||||||
|
|
||||||
|
if (length < 0) {
|
||||||
|
raise_exception(SizeT, EXN_VALUE_ERROR, "length should not be negative, got {0}", length, NO_PARAM,
|
||||||
|
NO_PARAM);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (this->step_defined && this->step == 0) {
|
||||||
|
raise_exception(SizeT, EXN_VALUE_ERROR, "slice step cannot be zero", NO_PARAM, NO_PARAM, NO_PARAM);
|
||||||
|
}
|
||||||
|
|
||||||
|
return this->indices<SizeT>(length);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
} // namespace
|
||||||
|
|
||||||
extern "C" {
|
extern "C" {
|
||||||
SliceIndex __nac3_slice_index_bound(SliceIndex i, const SliceIndex len) {
|
SliceIndex __nac3_slice_index_bound(SliceIndex i, const SliceIndex len) {
|
||||||
|
@ -14,15 +153,4 @@ SliceIndex __nac3_slice_index_bound(SliceIndex i, const SliceIndex len) {
|
||||||
}
|
}
|
||||||
return i;
|
return i;
|
||||||
}
|
}
|
||||||
|
|
||||||
SliceIndex __nac3_range_slice_len(const SliceIndex start, const SliceIndex end, const SliceIndex step) {
|
|
||||||
SliceIndex diff = end - start;
|
|
||||||
if (diff > 0 && step > 0) {
|
|
||||||
return ((diff - 1) / step) + 1;
|
|
||||||
} else if (diff < 0 && step < 0) {
|
|
||||||
return ((diff + 1) / step) + 1;
|
|
||||||
} else {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
}
|
|
@ -4,8 +4,7 @@ use inkwell::{FloatPredicate, IntPredicate, OptimizationLevel};
|
||||||
use itertools::Itertools;
|
use itertools::Itertools;
|
||||||
|
|
||||||
use crate::codegen::classes::{
|
use crate::codegen::classes::{
|
||||||
ArrayLikeValue, NDArrayValue, ProxyValue, RangeValue, TypedArrayLikeAccessor,
|
NDArrayValue, ProxyValue, RangeValue, UntypedArrayLikeAccessor, UntypedArrayLikeMutator,
|
||||||
UntypedArrayLikeAccessor, UntypedArrayLikeMutator,
|
|
||||||
};
|
};
|
||||||
use crate::codegen::expr::destructure_range;
|
use crate::codegen::expr::destructure_range;
|
||||||
use crate::codegen::irrt::calculate_len_for_slice_range;
|
use crate::codegen::irrt::calculate_len_for_slice_range;
|
||||||
|
@ -17,6 +16,12 @@ use crate::toplevel::helper::PrimDef;
|
||||||
use crate::toplevel::numpy::unpack_ndarray_var_tys;
|
use crate::toplevel::numpy::unpack_ndarray_var_tys;
|
||||||
use crate::typecheck::typedef::{Type, TypeEnum};
|
use crate::typecheck::typedef::{Type, TypeEnum};
|
||||||
|
|
||||||
|
use super::model::*;
|
||||||
|
use super::object::any::AnyObject;
|
||||||
|
use super::object::list::ListObject;
|
||||||
|
use super::object::ndarray::NDArrayObject;
|
||||||
|
use super::object::tuple::TupleObject;
|
||||||
|
|
||||||
/// Shorthand for [`unreachable!()`] when a type of argument is not supported.
|
/// Shorthand for [`unreachable!()`] when a type of argument is not supported.
|
||||||
///
|
///
|
||||||
/// The generated message will contain the function name and the name of the unsupported type.
|
/// The generated message will contain the function name and the name of the unsupported type.
|
||||||
|
@ -34,58 +39,33 @@ pub fn call_len<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
n: (Type, BasicValueEnum<'ctx>),
|
n: (Type, BasicValueEnum<'ctx>),
|
||||||
) -> Result<IntValue<'ctx>, String> {
|
) -> Result<IntValue<'ctx>, String> {
|
||||||
let llvm_i32 = ctx.ctx.i32_type();
|
|
||||||
let range_ty = ctx.primitives.range;
|
|
||||||
let (arg_ty, arg) = n;
|
let (arg_ty, arg) = n;
|
||||||
|
Ok(if ctx.unifier.unioned(arg_ty, ctx.primitives.range) {
|
||||||
Ok(if ctx.unifier.unioned(arg_ty, range_ty) {
|
|
||||||
let arg = RangeValue::from_ptr_val(arg.into_pointer_value(), Some("range"));
|
let arg = RangeValue::from_ptr_val(arg.into_pointer_value(), Some("range"));
|
||||||
let (start, end, step) = destructure_range(ctx, arg);
|
let (start, end, step) = destructure_range(ctx, arg);
|
||||||
calculate_len_for_slice_range(generator, ctx, start, end, step)
|
calculate_len_for_slice_range(generator, ctx, start, end, step)
|
||||||
} else {
|
} else {
|
||||||
match &*ctx.unifier.get_ty_immutable(arg_ty) {
|
let arg = AnyObject { ty: arg_ty, value: arg };
|
||||||
TypeEnum::TTuple { ty, .. } => llvm_i32.const_int(ty.len() as u64, false),
|
let len: Instance<'ctx, Int<Int32>> = match &*ctx.unifier.get_ty(arg_ty) {
|
||||||
TypeEnum::TObj { obj_id, .. } if *obj_id == PrimDef::List.id() => {
|
TypeEnum::TTuple { .. } => {
|
||||||
let zero = llvm_i32.const_zero();
|
let tuple = TupleObject::from_object(ctx, arg);
|
||||||
let len = ctx
|
tuple.len(generator, ctx).truncate_or_bit_cast(generator, ctx, Int32)
|
||||||
.build_gep_and_load(
|
|
||||||
arg.into_pointer_value(),
|
|
||||||
&[zero, llvm_i32.const_int(1, false)],
|
|
||||||
None,
|
|
||||||
)
|
|
||||||
.into_int_value();
|
|
||||||
ctx.builder.build_int_truncate_or_bit_cast(len, llvm_i32, "len").unwrap()
|
|
||||||
}
|
}
|
||||||
TypeEnum::TObj { obj_id, .. } if *obj_id == PrimDef::NDArray.id() => {
|
TypeEnum::TObj { obj_id, .. }
|
||||||
let llvm_usize = generator.get_size_type(ctx.ctx);
|
if *obj_id == ctx.primitives.ndarray.obj_id(&ctx.unifier).unwrap() =>
|
||||||
|
{
|
||||||
let arg = NDArrayValue::from_ptr_val(arg.into_pointer_value(), llvm_usize, None);
|
let ndarray = NDArrayObject::from_object(generator, ctx, arg);
|
||||||
|
ndarray.len(generator, ctx).truncate_or_bit_cast(generator, ctx, Int32)
|
||||||
let ndims = arg.dim_sizes().size(ctx, generator);
|
}
|
||||||
ctx.make_assert(
|
TypeEnum::TObj { obj_id, .. }
|
||||||
generator,
|
if *obj_id == ctx.primitives.list.obj_id(&ctx.unifier).unwrap() =>
|
||||||
ctx.builder
|
{
|
||||||
.build_int_compare(IntPredicate::NE, ndims, llvm_usize.const_zero(), "")
|
let list = ListObject::from_object(generator, ctx, arg);
|
||||||
.unwrap(),
|
list.len(generator, ctx).truncate_or_bit_cast(generator, ctx, Int32)
|
||||||
"0:TypeError",
|
}
|
||||||
"len() of unsized object",
|
_ => unsupported_type(ctx, "len", &[arg_ty]),
|
||||||
[None, None, None],
|
|
||||||
ctx.current_loc,
|
|
||||||
);
|
|
||||||
|
|
||||||
let len = unsafe {
|
|
||||||
arg.dim_sizes().get_typed_unchecked(
|
|
||||||
ctx,
|
|
||||||
generator,
|
|
||||||
&llvm_usize.const_zero(),
|
|
||||||
None,
|
|
||||||
)
|
|
||||||
};
|
};
|
||||||
|
len.value
|
||||||
ctx.builder.build_int_truncate_or_bit_cast(len, llvm_i32, "len").unwrap()
|
|
||||||
}
|
|
||||||
_ => codegen_unreachable!(ctx),
|
|
||||||
}
|
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -2,7 +2,7 @@ use crate::{
|
||||||
codegen::{
|
codegen::{
|
||||||
classes::{
|
classes::{
|
||||||
ArrayLikeIndexer, ArrayLikeValue, ListType, ListValue, NDArrayValue, ProxyType,
|
ArrayLikeIndexer, ArrayLikeValue, ListType, ListValue, NDArrayValue, ProxyType,
|
||||||
ProxyValue, RangeValue, TypedArrayLikeAccessor, UntypedArrayLikeAccessor,
|
ProxyValue, RangeValue, UntypedArrayLikeAccessor,
|
||||||
},
|
},
|
||||||
concrete_type::{ConcreteFuncArg, ConcreteTypeEnum, ConcreteTypeStore},
|
concrete_type::{ConcreteFuncArg, ConcreteTypeEnum, ConcreteTypeStore},
|
||||||
gen_in_range_check, get_llvm_abi_type, get_llvm_type, get_va_count_arg_name,
|
gen_in_range_check, get_llvm_abi_type, get_llvm_type, get_va_count_arg_name,
|
||||||
|
@ -20,11 +20,7 @@ use crate::{
|
||||||
CodeGenContext, CodeGenTask, CodeGenerator,
|
CodeGenContext, CodeGenTask, CodeGenerator,
|
||||||
},
|
},
|
||||||
symbol_resolver::{SymbolValue, ValueEnum},
|
symbol_resolver::{SymbolValue, ValueEnum},
|
||||||
toplevel::{
|
toplevel::{helper::PrimDef, numpy::unpack_ndarray_var_tys, DefinitionId, TopLevelDef},
|
||||||
helper::PrimDef,
|
|
||||||
numpy::{make_ndarray_ty, unpack_ndarray_var_tys},
|
|
||||||
DefinitionId, TopLevelDef,
|
|
||||||
},
|
|
||||||
typecheck::{
|
typecheck::{
|
||||||
magic_methods::{Binop, BinopVariant, HasOpInfo},
|
magic_methods::{Binop, BinopVariant, HasOpInfo},
|
||||||
typedef::{FunSignature, FuncArg, Type, TypeEnum, TypeVarId, Unifier, VarMap},
|
typedef::{FunSignature, FuncArg, Type, TypeEnum, TypeVarId, Unifier, VarMap},
|
||||||
|
@ -45,6 +41,11 @@ use std::cmp::min;
|
||||||
use std::iter::{repeat, repeat_with};
|
use std::iter::{repeat, repeat_with};
|
||||||
use std::{collections::HashMap, convert::TryInto, iter::once, iter::zip};
|
use std::{collections::HashMap, convert::TryInto, iter::once, iter::zip};
|
||||||
|
|
||||||
|
use super::object::{
|
||||||
|
any::AnyObject,
|
||||||
|
ndarray::{indexing::util::gen_ndarray_subscript_ndindices, NDArrayObject},
|
||||||
|
};
|
||||||
|
|
||||||
pub fn get_subst_key(
|
pub fn get_subst_key(
|
||||||
unifier: &mut Unifier,
|
unifier: &mut Unifier,
|
||||||
obj: Option<Type>,
|
obj: Option<Type>,
|
||||||
|
@ -2498,338 +2499,6 @@ pub fn gen_cmpop_expr<'ctx, G: CodeGenerator>(
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Generates code for a subscript expression on an `ndarray`.
|
|
||||||
///
|
|
||||||
/// * `ty` - The `Type` of the `NDArray` elements.
|
|
||||||
/// * `ndims` - The `Type` of the `NDArray` number-of-dimensions `Literal`.
|
|
||||||
/// * `v` - The `NDArray` value.
|
|
||||||
/// * `slice` - The slice expression used to subscript into the `ndarray`.
|
|
||||||
fn gen_ndarray_subscript_expr<'ctx, G: CodeGenerator>(
|
|
||||||
generator: &mut G,
|
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
|
||||||
ty: Type,
|
|
||||||
ndims: Type,
|
|
||||||
v: NDArrayValue<'ctx>,
|
|
||||||
slice: &Expr<Option<Type>>,
|
|
||||||
) -> Result<Option<ValueEnum<'ctx>>, String> {
|
|
||||||
let llvm_i1 = ctx.ctx.bool_type();
|
|
||||||
let llvm_i32 = ctx.ctx.i32_type();
|
|
||||||
let llvm_usize = generator.get_size_type(ctx.ctx);
|
|
||||||
|
|
||||||
let TypeEnum::TLiteral { values, .. } = &*ctx.unifier.get_ty_immutable(ndims) else {
|
|
||||||
codegen_unreachable!(ctx)
|
|
||||||
};
|
|
||||||
|
|
||||||
let ndims = values
|
|
||||||
.iter()
|
|
||||||
.map(|ndim| u64::try_from(ndim.clone()).map_err(|()| ndim.clone()))
|
|
||||||
.collect::<Result<Vec<_>, _>>()
|
|
||||||
.map_err(|val| {
|
|
||||||
format!(
|
|
||||||
"Expected non-negative literal for ndarray.ndims, got {}",
|
|
||||||
i128::try_from(val).unwrap()
|
|
||||||
)
|
|
||||||
})?;
|
|
||||||
|
|
||||||
assert!(!ndims.is_empty());
|
|
||||||
|
|
||||||
// The number of dimensions subscripted by the index expression.
|
|
||||||
// Slicing a ndarray will yield the same number of dimensions, whereas indexing into a
|
|
||||||
// dimension will remove a dimension.
|
|
||||||
let subscripted_dims = match &slice.node {
|
|
||||||
ExprKind::Tuple { elts, .. } => elts.iter().fold(0, |acc, value_subexpr| {
|
|
||||||
if let ExprKind::Slice { .. } = &value_subexpr.node {
|
|
||||||
acc
|
|
||||||
} else {
|
|
||||||
acc + 1
|
|
||||||
}
|
|
||||||
}),
|
|
||||||
|
|
||||||
ExprKind::Slice { .. } => 0,
|
|
||||||
_ => 1,
|
|
||||||
};
|
|
||||||
|
|
||||||
let ndarray_ndims_ty = ctx.unifier.get_fresh_literal(
|
|
||||||
ndims.iter().map(|v| SymbolValue::U64(v - subscripted_dims)).collect(),
|
|
||||||
None,
|
|
||||||
);
|
|
||||||
let ndarray_ty =
|
|
||||||
make_ndarray_ty(&mut ctx.unifier, &ctx.primitives, Some(ty), Some(ndarray_ndims_ty));
|
|
||||||
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, ty).as_basic_type_enum();
|
|
||||||
let sizeof_elem = llvm_ndarray_data_t.size_of().unwrap();
|
|
||||||
|
|
||||||
// Check that len is non-zero
|
|
||||||
let len = v.load_ndims(ctx);
|
|
||||||
ctx.make_assert(
|
|
||||||
generator,
|
|
||||||
ctx.builder.build_int_compare(IntPredicate::SGT, len, llvm_usize.const_zero(), "").unwrap(),
|
|
||||||
"0:IndexError",
|
|
||||||
"too many indices for array: array is {0}-dimensional but 1 were indexed",
|
|
||||||
[Some(len), None, None],
|
|
||||||
slice.location,
|
|
||||||
);
|
|
||||||
|
|
||||||
// Normalizes a possibly-negative index to its corresponding positive index
|
|
||||||
let normalize_index = |generator: &mut G,
|
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
|
||||||
index: IntValue<'ctx>,
|
|
||||||
dim: u64| {
|
|
||||||
gen_if_else_expr_callback(
|
|
||||||
generator,
|
|
||||||
ctx,
|
|
||||||
|_, ctx| {
|
|
||||||
Ok(ctx
|
|
||||||
.builder
|
|
||||||
.build_int_compare(IntPredicate::SGE, index, index.get_type().const_zero(), "")
|
|
||||||
.unwrap())
|
|
||||||
},
|
|
||||||
|_, _| Ok(Some(index)),
|
|
||||||
|generator, ctx| {
|
|
||||||
let llvm_i32 = ctx.ctx.i32_type();
|
|
||||||
|
|
||||||
let len = unsafe {
|
|
||||||
v.dim_sizes().get_typed_unchecked(
|
|
||||||
ctx,
|
|
||||||
generator,
|
|
||||||
&llvm_usize.const_int(dim, true),
|
|
||||||
None,
|
|
||||||
)
|
|
||||||
};
|
|
||||||
|
|
||||||
let index = ctx
|
|
||||||
.builder
|
|
||||||
.build_int_add(
|
|
||||||
len,
|
|
||||||
ctx.builder.build_int_s_extend(index, llvm_usize, "").unwrap(),
|
|
||||||
"",
|
|
||||||
)
|
|
||||||
.unwrap();
|
|
||||||
|
|
||||||
Ok(Some(ctx.builder.build_int_truncate(index, llvm_i32, "").unwrap()))
|
|
||||||
},
|
|
||||||
)
|
|
||||||
.map(|v| v.map(BasicValueEnum::into_int_value))
|
|
||||||
};
|
|
||||||
|
|
||||||
// Converts a slice expression into a slice-range tuple
|
|
||||||
let expr_to_slice = |generator: &mut G,
|
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
|
||||||
node: &ExprKind<Option<Type>>,
|
|
||||||
dim: u64| {
|
|
||||||
match node {
|
|
||||||
ExprKind::Constant { value: Constant::Int(v), .. } => {
|
|
||||||
let Some(index) =
|
|
||||||
normalize_index(generator, ctx, llvm_i32.const_int(*v as u64, true), dim)?
|
|
||||||
else {
|
|
||||||
return Ok(None);
|
|
||||||
};
|
|
||||||
|
|
||||||
Ok(Some((index, index, llvm_i32.const_int(1, true))))
|
|
||||||
}
|
|
||||||
|
|
||||||
ExprKind::Slice { lower, upper, step } => {
|
|
||||||
let dim_sz = unsafe {
|
|
||||||
v.dim_sizes().get_typed_unchecked(
|
|
||||||
ctx,
|
|
||||||
generator,
|
|
||||||
&llvm_usize.const_int(dim, false),
|
|
||||||
None,
|
|
||||||
)
|
|
||||||
};
|
|
||||||
|
|
||||||
handle_slice_indices(lower, upper, step, ctx, generator, dim_sz)
|
|
||||||
}
|
|
||||||
|
|
||||||
_ => {
|
|
||||||
let Some(index) = generator.gen_expr(ctx, slice)? else { return Ok(None) };
|
|
||||||
let index = index
|
|
||||||
.to_basic_value_enum(ctx, generator, slice.custom.unwrap())?
|
|
||||||
.into_int_value();
|
|
||||||
let Some(index) = normalize_index(generator, ctx, index, dim)? else {
|
|
||||||
return Ok(None);
|
|
||||||
};
|
|
||||||
|
|
||||||
Ok(Some((index, index, llvm_i32.const_int(1, true))))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
let make_indices_arr = |generator: &mut G,
|
|
||||||
ctx: &mut CodeGenContext<'ctx, '_>|
|
|
||||||
-> Result<_, String> {
|
|
||||||
Ok(if let ExprKind::Tuple { elts, .. } = &slice.node {
|
|
||||||
let llvm_int_ty = ctx.get_llvm_type(generator, elts[0].custom.unwrap());
|
|
||||||
let index_addr = generator.gen_array_var_alloc(
|
|
||||||
ctx,
|
|
||||||
llvm_int_ty,
|
|
||||||
llvm_usize.const_int(elts.len() as u64, false),
|
|
||||||
None,
|
|
||||||
)?;
|
|
||||||
|
|
||||||
for (i, elt) in elts.iter().enumerate() {
|
|
||||||
let Some(index) = generator.gen_expr(ctx, elt)? else {
|
|
||||||
return Ok(None);
|
|
||||||
};
|
|
||||||
|
|
||||||
let index = index
|
|
||||||
.to_basic_value_enum(ctx, generator, elt.custom.unwrap())?
|
|
||||||
.into_int_value();
|
|
||||||
let Some(index) = normalize_index(generator, ctx, index, 0)? else {
|
|
||||||
return Ok(None);
|
|
||||||
};
|
|
||||||
|
|
||||||
let store_ptr = unsafe {
|
|
||||||
index_addr.ptr_offset_unchecked(
|
|
||||||
ctx,
|
|
||||||
generator,
|
|
||||||
&llvm_usize.const_int(i as u64, false),
|
|
||||||
None,
|
|
||||||
)
|
|
||||||
};
|
|
||||||
ctx.builder.build_store(store_ptr, index).unwrap();
|
|
||||||
}
|
|
||||||
|
|
||||||
Some(index_addr)
|
|
||||||
} else if let Some(index) = generator.gen_expr(ctx, slice)? {
|
|
||||||
let llvm_int_ty = ctx.get_llvm_type(generator, slice.custom.unwrap());
|
|
||||||
let index_addr = generator.gen_array_var_alloc(
|
|
||||||
ctx,
|
|
||||||
llvm_int_ty,
|
|
||||||
llvm_usize.const_int(1u64, false),
|
|
||||||
None,
|
|
||||||
)?;
|
|
||||||
|
|
||||||
let index =
|
|
||||||
index.to_basic_value_enum(ctx, generator, slice.custom.unwrap())?.into_int_value();
|
|
||||||
let Some(index) = normalize_index(generator, ctx, index, 0)? else { return Ok(None) };
|
|
||||||
|
|
||||||
let store_ptr = unsafe {
|
|
||||||
index_addr.ptr_offset_unchecked(ctx, generator, &llvm_usize.const_zero(), None)
|
|
||||||
};
|
|
||||||
ctx.builder.build_store(store_ptr, index).unwrap();
|
|
||||||
|
|
||||||
Some(index_addr)
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
})
|
|
||||||
};
|
|
||||||
|
|
||||||
Ok(Some(if ndims.len() == 1 && ndims[0] - subscripted_dims == 0 {
|
|
||||||
let Some(index_addr) = make_indices_arr(generator, ctx)? else { return Ok(None) };
|
|
||||||
|
|
||||||
v.data().get(ctx, generator, &index_addr, None).into()
|
|
||||||
} else {
|
|
||||||
match &slice.node {
|
|
||||||
ExprKind::Tuple { elts, .. } => {
|
|
||||||
let slices = elts
|
|
||||||
.iter()
|
|
||||||
.enumerate()
|
|
||||||
.map(|(dim, elt)| expr_to_slice(generator, ctx, &elt.node, dim as u64))
|
|
||||||
.take_while_inclusive(|slice| slice.as_ref().is_ok_and(Option::is_some))
|
|
||||||
.collect::<Result<Vec<_>, _>>()?;
|
|
||||||
if slices.len() < elts.len() {
|
|
||||||
return Ok(None);
|
|
||||||
}
|
|
||||||
|
|
||||||
let slices = slices.into_iter().map(Option::unwrap).collect_vec();
|
|
||||||
|
|
||||||
numpy::ndarray_sliced_copy(generator, ctx, ty, v, &slices)?.as_base_value().into()
|
|
||||||
}
|
|
||||||
|
|
||||||
ExprKind::Slice { .. } => {
|
|
||||||
let Some(slice) = expr_to_slice(generator, ctx, &slice.node, 0)? else {
|
|
||||||
return Ok(None);
|
|
||||||
};
|
|
||||||
|
|
||||||
numpy::ndarray_sliced_copy(generator, ctx, ty, v, &[slice])?.as_base_value().into()
|
|
||||||
}
|
|
||||||
|
|
||||||
_ => {
|
|
||||||
// Accessing an element from a multi-dimensional `ndarray`
|
|
||||||
|
|
||||||
let Some(index_addr) = make_indices_arr(generator, ctx)? else { return Ok(None) };
|
|
||||||
|
|
||||||
// Create a new array, remove the top dimension from the dimension-size-list, and copy the
|
|
||||||
// elements over
|
|
||||||
let subscripted_ndarray =
|
|
||||||
generator.gen_var_alloc(ctx, llvm_ndarray_t.into(), None)?;
|
|
||||||
let ndarray = NDArrayValue::from_ptr_val(subscripted_ndarray, llvm_usize, None);
|
|
||||||
|
|
||||||
let num_dims = v.load_ndims(ctx);
|
|
||||||
ndarray.store_ndims(
|
|
||||||
ctx,
|
|
||||||
generator,
|
|
||||||
ctx.builder
|
|
||||||
.build_int_sub(num_dims, llvm_usize.const_int(1, false), "")
|
|
||||||
.unwrap(),
|
|
||||||
);
|
|
||||||
|
|
||||||
let ndarray_num_dims = ndarray.load_ndims(ctx);
|
|
||||||
ndarray.create_dim_sizes(ctx, llvm_usize, ndarray_num_dims);
|
|
||||||
|
|
||||||
let ndarray_num_dims = ctx
|
|
||||||
.builder
|
|
||||||
.build_int_z_extend_or_bit_cast(
|
|
||||||
ndarray.load_ndims(ctx),
|
|
||||||
llvm_usize.size_of().get_type(),
|
|
||||||
"",
|
|
||||||
)
|
|
||||||
.unwrap();
|
|
||||||
let v_dims_src_ptr = unsafe {
|
|
||||||
v.dim_sizes().ptr_offset_unchecked(
|
|
||||||
ctx,
|
|
||||||
generator,
|
|
||||||
&llvm_usize.const_int(1, false),
|
|
||||||
None,
|
|
||||||
)
|
|
||||||
};
|
|
||||||
call_memcpy_generic(
|
|
||||||
ctx,
|
|
||||||
ndarray.dim_sizes().base_ptr(ctx, generator),
|
|
||||||
v_dims_src_ptr,
|
|
||||||
ctx.builder
|
|
||||||
.build_int_mul(ndarray_num_dims, llvm_usize.size_of(), "")
|
|
||||||
.map(Into::into)
|
|
||||||
.unwrap(),
|
|
||||||
llvm_i1.const_zero(),
|
|
||||||
);
|
|
||||||
|
|
||||||
let ndarray_num_elems = call_ndarray_calc_size(
|
|
||||||
generator,
|
|
||||||
ctx,
|
|
||||||
&ndarray.dim_sizes().as_slice_value(ctx, generator),
|
|
||||||
(None, None),
|
|
||||||
);
|
|
||||||
let ndarray_num_elems = ctx
|
|
||||||
.builder
|
|
||||||
.build_int_z_extend_or_bit_cast(ndarray_num_elems, sizeof_elem.get_type(), "")
|
|
||||||
.unwrap();
|
|
||||||
ndarray.create_data(ctx, llvm_ndarray_data_t, ndarray_num_elems);
|
|
||||||
|
|
||||||
let v_data_src_ptr = v.data().ptr_offset(ctx, generator, &index_addr, None);
|
|
||||||
call_memcpy_generic(
|
|
||||||
ctx,
|
|
||||||
ndarray.data().base_ptr(ctx, generator),
|
|
||||||
v_data_src_ptr,
|
|
||||||
ctx.builder
|
|
||||||
.build_int_mul(
|
|
||||||
ndarray_num_elems,
|
|
||||||
llvm_ndarray_data_t.size_of().unwrap(),
|
|
||||||
"",
|
|
||||||
)
|
|
||||||
.map(Into::into)
|
|
||||||
.unwrap(),
|
|
||||||
llvm_i1.const_zero(),
|
|
||||||
);
|
|
||||||
|
|
||||||
ndarray.as_base_value().into()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}))
|
|
||||||
}
|
|
||||||
|
|
||||||
/// See [`CodeGenerator::gen_expr`].
|
/// See [`CodeGenerator::gen_expr`].
|
||||||
pub fn gen_expr<'ctx, G: CodeGenerator>(
|
pub fn gen_expr<'ctx, G: CodeGenerator>(
|
||||||
generator: &mut G,
|
generator: &mut G,
|
||||||
|
@ -3462,18 +3131,26 @@ pub fn gen_expr<'ctx, G: CodeGenerator>(
|
||||||
v.data().get(ctx, generator, &index, None).into()
|
v.data().get(ctx, generator, &index, None).into()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
TypeEnum::TObj { obj_id, params, .. } if *obj_id == PrimDef::NDArray.id() => {
|
TypeEnum::TObj { obj_id, .. } if *obj_id == PrimDef::NDArray.id() => {
|
||||||
let (ty, ndims) = params.iter().map(|(_, ty)| ty).collect_tuple().unwrap();
|
let Some(ndarray) = generator.gen_expr(ctx, value)? else {
|
||||||
|
|
||||||
let v = if let Some(v) = generator.gen_expr(ctx, value)? {
|
|
||||||
v.to_basic_value_enum(ctx, generator, value.custom.unwrap())?
|
|
||||||
.into_pointer_value()
|
|
||||||
} else {
|
|
||||||
return Ok(None);
|
return Ok(None);
|
||||||
};
|
};
|
||||||
let v = NDArrayValue::from_ptr_val(v, usize, None);
|
|
||||||
|
|
||||||
return gen_ndarray_subscript_expr(generator, ctx, *ty, *ndims, v, slice);
|
let ndarray_ty = value.custom.unwrap();
|
||||||
|
let ndarray = ndarray.to_basic_value_enum(ctx, generator, ndarray_ty)?;
|
||||||
|
|
||||||
|
let ndarray = NDArrayObject::from_object(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
AnyObject { ty: ndarray_ty, value: ndarray },
|
||||||
|
);
|
||||||
|
|
||||||
|
let indices = gen_ndarray_subscript_ndindices(generator, ctx, slice)?;
|
||||||
|
let result = ndarray
|
||||||
|
.index(generator, ctx, &indices)
|
||||||
|
.split_unsized(generator, ctx)
|
||||||
|
.to_basic_value_enum();
|
||||||
|
return Ok(Some(ValueEnum::Dynamic(result)));
|
||||||
}
|
}
|
||||||
TypeEnum::TTuple { .. } => {
|
TypeEnum::TTuple { .. } => {
|
||||||
let index: u32 =
|
let index: u32 =
|
||||||
|
|
|
@ -7,9 +7,15 @@ use super::{
|
||||||
},
|
},
|
||||||
llvm_intrinsics,
|
llvm_intrinsics,
|
||||||
macros::codegen_unreachable,
|
macros::codegen_unreachable,
|
||||||
|
model::*,
|
||||||
|
object::{
|
||||||
|
list::List,
|
||||||
|
ndarray::{indexing::NDIndex, nditer::NDIter, NDArray},
|
||||||
|
},
|
||||||
stmt::gen_for_callback_incrementing,
|
stmt::gen_for_callback_incrementing,
|
||||||
CodeGenContext, CodeGenerator,
|
CodeGenContext, CodeGenerator,
|
||||||
};
|
};
|
||||||
|
use function::FnCall;
|
||||||
use inkwell::{
|
use inkwell::{
|
||||||
attributes::{Attribute, AttributeLoc},
|
attributes::{Attribute, AttributeLoc},
|
||||||
context::Context,
|
context::Context,
|
||||||
|
@ -949,3 +955,209 @@ pub fn call_ndarray_calc_broadcast_index<
|
||||||
Box::new(|_, v| v.into()),
|
Box::new(|_, v| v.into()),
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// When [`TypeContext::size_type`] is 32-bits, the function name is "{fn_name}".
|
||||||
|
// When [`TypeContext::size_type`] is 64-bits, the function name is "{fn_name}64".
|
||||||
|
#[must_use]
|
||||||
|
pub fn get_sizet_dependent_function_name<G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'_, '_>,
|
||||||
|
name: &str,
|
||||||
|
) -> String {
|
||||||
|
let mut name = name.to_owned();
|
||||||
|
match generator.get_size_type(ctx.ctx).get_bit_width() {
|
||||||
|
32 => {}
|
||||||
|
64 => name.push_str("64"),
|
||||||
|
bit_width => {
|
||||||
|
panic!("Unsupported int type bit width {bit_width}, must be either 32-bits or 64-bits")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
name
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn call_nac3_ndarray_util_assert_shape_no_negative<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
ndims: Instance<'ctx, Int<SizeT>>,
|
||||||
|
shape: Instance<'ctx, Ptr<Int<SizeT>>>,
|
||||||
|
) {
|
||||||
|
let name = get_sizet_dependent_function_name(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
"__nac3_ndarray_util_assert_shape_no_negative",
|
||||||
|
);
|
||||||
|
FnCall::builder(generator, ctx, &name).arg(ndims).arg(shape).returning_void();
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn call_nac3_ndarray_util_assert_output_shape_same<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
ndarray_ndims: Instance<'ctx, Int<SizeT>>,
|
||||||
|
ndarray_shape: Instance<'ctx, Ptr<Int<SizeT>>>,
|
||||||
|
output_ndims: Instance<'ctx, Int<SizeT>>,
|
||||||
|
output_shape: Instance<'ctx, Ptr<Int<SizeT>>>,
|
||||||
|
) {
|
||||||
|
let name = get_sizet_dependent_function_name(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
"__nac3_ndarray_util_assert_output_shape_same",
|
||||||
|
);
|
||||||
|
FnCall::builder(generator, ctx, &name)
|
||||||
|
.arg(ndarray_ndims)
|
||||||
|
.arg(ndarray_shape)
|
||||||
|
.arg(output_ndims)
|
||||||
|
.arg(output_shape)
|
||||||
|
.returning_void();
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn call_nac3_ndarray_size<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
|
||||||
|
) -> Instance<'ctx, Int<SizeT>> {
|
||||||
|
let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_size");
|
||||||
|
FnCall::builder(generator, ctx, &name).arg(ndarray).returning_auto("size")
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn call_nac3_ndarray_nbytes<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
|
||||||
|
) -> Instance<'ctx, Int<SizeT>> {
|
||||||
|
let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_nbytes");
|
||||||
|
FnCall::builder(generator, ctx, &name).arg(ndarray).returning_auto("nbytes")
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn call_nac3_ndarray_len<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
|
||||||
|
) -> Instance<'ctx, Int<SizeT>> {
|
||||||
|
let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_len");
|
||||||
|
FnCall::builder(generator, ctx, &name).arg(ndarray).returning_auto("len")
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn call_nac3_ndarray_is_c_contiguous<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
|
||||||
|
) -> Instance<'ctx, Int<Bool>> {
|
||||||
|
let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_is_c_contiguous");
|
||||||
|
FnCall::builder(generator, ctx, &name).arg(ndarray).returning_auto("is_c_contiguous")
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn call_nac3_ndarray_get_nth_pelement<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
|
||||||
|
index: Instance<'ctx, Int<SizeT>>,
|
||||||
|
) -> Instance<'ctx, Ptr<Int<Byte>>> {
|
||||||
|
let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_get_nth_pelement");
|
||||||
|
FnCall::builder(generator, ctx, &name).arg(ndarray).arg(index).returning_auto("pelement")
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn call_nac3_ndarray_get_pelement_by_indices<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
|
||||||
|
indices: Instance<'ctx, Ptr<Int<SizeT>>>,
|
||||||
|
) -> Instance<'ctx, Ptr<Int<Byte>>> {
|
||||||
|
let name =
|
||||||
|
get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_get_pelement_by_indices");
|
||||||
|
FnCall::builder(generator, ctx, &name).arg(ndarray).arg(indices).returning_auto("pelement")
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn call_nac3_ndarray_set_strides_by_shape<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
|
||||||
|
) {
|
||||||
|
let name =
|
||||||
|
get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_set_strides_by_shape");
|
||||||
|
FnCall::builder(generator, ctx, &name).arg(ndarray).returning_void();
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn call_nac3_ndarray_copy_data<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
src_ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
|
||||||
|
dst_ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
|
||||||
|
) {
|
||||||
|
let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_copy_data");
|
||||||
|
FnCall::builder(generator, ctx, &name).arg(src_ndarray).arg(dst_ndarray).returning_void();
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn call_nac3_nditer_initialize<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
iter: Instance<'ctx, Ptr<Struct<NDIter>>>,
|
||||||
|
ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
|
||||||
|
indices: Instance<'ctx, Ptr<Int<SizeT>>>,
|
||||||
|
) {
|
||||||
|
let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_nditer_initialize");
|
||||||
|
FnCall::builder(generator, ctx, &name).arg(iter).arg(ndarray).arg(indices).returning_void();
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn call_nac3_nditer_has_element<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
iter: Instance<'ctx, Ptr<Struct<NDIter>>>,
|
||||||
|
) -> Instance<'ctx, Int<Bool>> {
|
||||||
|
let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_nditer_has_element");
|
||||||
|
FnCall::builder(generator, ctx, &name).arg(iter).returning_auto("has_element")
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn call_nac3_nditer_next<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
iter: Instance<'ctx, Ptr<Struct<NDIter>>>,
|
||||||
|
) {
|
||||||
|
let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_nditer_next");
|
||||||
|
FnCall::builder(generator, ctx, &name).arg(iter).returning_void();
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn call_nac3_ndarray_index<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
num_indices: Instance<'ctx, Int<SizeT>>,
|
||||||
|
indices: Instance<'ctx, Ptr<Struct<NDIndex>>>,
|
||||||
|
src_ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
|
||||||
|
dst_ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
|
||||||
|
) {
|
||||||
|
let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_index");
|
||||||
|
FnCall::builder(generator, ctx, &name)
|
||||||
|
.arg(num_indices)
|
||||||
|
.arg(indices)
|
||||||
|
.arg(src_ndarray)
|
||||||
|
.arg(dst_ndarray)
|
||||||
|
.returning_void();
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn call_nac3_ndarray_array_set_and_validate_list_shape<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
list: Instance<'ctx, Ptr<Struct<List<Int<Byte>>>>>,
|
||||||
|
ndims: Instance<'ctx, Int<SizeT>>,
|
||||||
|
shape: Instance<'ctx, Ptr<Int<SizeT>>>,
|
||||||
|
) {
|
||||||
|
let name = get_sizet_dependent_function_name(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
"__nac3_ndarray_array_set_and_validate_list_shape",
|
||||||
|
);
|
||||||
|
FnCall::builder(generator, ctx, &name).arg(list).arg(ndims).arg(shape).returning_void();
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn call_nac3_ndarray_array_write_list_to_array<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
list: Instance<'ctx, Ptr<Struct<List<Int<Byte>>>>>,
|
||||||
|
ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
|
||||||
|
) {
|
||||||
|
let name = get_sizet_dependent_function_name(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
"__nac3_ndarray_array_write_list_to_array",
|
||||||
|
);
|
||||||
|
FnCall::builder(generator, ctx, &name).arg(list).arg(ndarray).returning_void();
|
||||||
|
}
|
||||||
|
|
|
@ -1,7 +1,7 @@
|
||||||
use crate::{
|
use crate::{
|
||||||
codegen::classes::{ListType, NDArrayType, ProxyType, RangeType},
|
codegen::classes::{ListType, ProxyType, RangeType},
|
||||||
symbol_resolver::{StaticValue, SymbolResolver},
|
symbol_resolver::{StaticValue, SymbolResolver},
|
||||||
toplevel::{helper::PrimDef, numpy::unpack_ndarray_var_tys, TopLevelContext, TopLevelDef},
|
toplevel::{helper::PrimDef, TopLevelContext, TopLevelDef},
|
||||||
typecheck::{
|
typecheck::{
|
||||||
type_inferencer::{CodeLocation, PrimitiveStore},
|
type_inferencer::{CodeLocation, PrimitiveStore},
|
||||||
typedef::{CallId, FuncArg, Type, TypeEnum, Unifier},
|
typedef::{CallId, FuncArg, Type, TypeEnum, Unifier},
|
||||||
|
@ -24,7 +24,9 @@ use inkwell::{
|
||||||
AddressSpace, IntPredicate, OptimizationLevel,
|
AddressSpace, IntPredicate, OptimizationLevel,
|
||||||
};
|
};
|
||||||
use itertools::Itertools;
|
use itertools::Itertools;
|
||||||
|
use model::*;
|
||||||
use nac3parser::ast::{Location, Stmt, StrRef};
|
use nac3parser::ast::{Location, Stmt, StrRef};
|
||||||
|
use object::ndarray::NDArray;
|
||||||
use parking_lot::{Condvar, Mutex};
|
use parking_lot::{Condvar, Mutex};
|
||||||
use std::collections::{HashMap, HashSet};
|
use std::collections::{HashMap, HashSet};
|
||||||
use std::sync::{
|
use std::sync::{
|
||||||
|
@ -41,7 +43,9 @@ pub mod extern_fns;
|
||||||
mod generator;
|
mod generator;
|
||||||
pub mod irrt;
|
pub mod irrt;
|
||||||
pub mod llvm_intrinsics;
|
pub mod llvm_intrinsics;
|
||||||
|
pub mod model;
|
||||||
pub mod numpy;
|
pub mod numpy;
|
||||||
|
pub mod object;
|
||||||
pub mod stmt;
|
pub mod stmt;
|
||||||
|
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
|
@ -505,12 +509,7 @@ fn get_llvm_type<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
}
|
}
|
||||||
|
|
||||||
TObj { obj_id, .. } if *obj_id == PrimDef::NDArray.id() => {
|
TObj { obj_id, .. } if *obj_id == PrimDef::NDArray.id() => {
|
||||||
let (dtype, _) = unpack_ndarray_var_tys(unifier, ty);
|
Ptr(Struct(NDArray)).llvm_type(generator, ctx).as_basic_type_enum()
|
||||||
let element_type = get_llvm_type(
|
|
||||||
ctx, module, generator, unifier, top_level, type_cache, dtype,
|
|
||||||
);
|
|
||||||
|
|
||||||
NDArrayType::new(generator, ctx, element_type).as_base_type().into()
|
|
||||||
}
|
}
|
||||||
|
|
||||||
_ => unreachable!(
|
_ => unreachable!(
|
||||||
|
|
|
@ -0,0 +1,42 @@
|
||||||
|
use inkwell::{
|
||||||
|
context::Context,
|
||||||
|
types::{BasicType, BasicTypeEnum},
|
||||||
|
values::BasicValueEnum,
|
||||||
|
};
|
||||||
|
|
||||||
|
use crate::codegen::CodeGenerator;
|
||||||
|
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
/// A [`Model`] of any [`BasicTypeEnum`].
|
||||||
|
///
|
||||||
|
/// Use this when it is infeasible to use model abstractions.
|
||||||
|
#[derive(Debug, Clone, Copy)]
|
||||||
|
pub struct Any<'ctx>(pub BasicTypeEnum<'ctx>);
|
||||||
|
|
||||||
|
impl<'ctx> Model<'ctx> for Any<'ctx> {
|
||||||
|
type Value = BasicValueEnum<'ctx>;
|
||||||
|
type Type = BasicTypeEnum<'ctx>;
|
||||||
|
|
||||||
|
fn llvm_type<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
_generator: &G,
|
||||||
|
_ctx: &'ctx Context,
|
||||||
|
) -> Self::Type {
|
||||||
|
self.0
|
||||||
|
}
|
||||||
|
|
||||||
|
fn check_type<T: BasicType<'ctx>, G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
_generator: &mut G,
|
||||||
|
_ctx: &'ctx Context,
|
||||||
|
ty: T,
|
||||||
|
) -> Result<(), ModelError> {
|
||||||
|
let ty = ty.as_basic_type_enum();
|
||||||
|
if ty == self.0 {
|
||||||
|
Ok(())
|
||||||
|
} else {
|
||||||
|
Err(ModelError(format!("Expecting {}, but got {}", self.0, ty)))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
|
@ -0,0 +1,147 @@
|
||||||
|
use std::fmt;
|
||||||
|
|
||||||
|
use inkwell::{
|
||||||
|
context::Context,
|
||||||
|
types::{ArrayType, BasicType, BasicTypeEnum},
|
||||||
|
values::{ArrayValue, IntValue},
|
||||||
|
};
|
||||||
|
|
||||||
|
use crate::codegen::{CodeGenContext, CodeGenerator};
|
||||||
|
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
/// Trait for Rust structs identifying length values for [`Array`].
|
||||||
|
pub trait ArrayLen: fmt::Debug + Clone + Copy {
|
||||||
|
fn length(&self) -> u32;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A statically known length.
|
||||||
|
#[derive(Debug, Clone, Copy, Default)]
|
||||||
|
pub struct Len<const N: u32>;
|
||||||
|
|
||||||
|
/// A dynamically known length.
|
||||||
|
#[derive(Debug, Clone, Copy)]
|
||||||
|
pub struct AnyLen(pub u32);
|
||||||
|
|
||||||
|
impl<const N: u32> ArrayLen for Len<N> {
|
||||||
|
fn length(&self) -> u32 {
|
||||||
|
N
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl ArrayLen for AnyLen {
|
||||||
|
fn length(&self) -> u32 {
|
||||||
|
self.0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A Model for an [`ArrayType`].
|
||||||
|
///
|
||||||
|
/// `Len` should be of a [`LenKind`] and `Item` should be a of [`Model`].
|
||||||
|
#[derive(Debug, Clone, Copy, Default)]
|
||||||
|
pub struct Array<Len, Item> {
|
||||||
|
/// Length of this array.
|
||||||
|
pub len: Len,
|
||||||
|
/// [`Model`] of the array items.
|
||||||
|
pub item: Item,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx, Len: ArrayLen, Item: Model<'ctx>> Model<'ctx> for Array<Len, Item> {
|
||||||
|
type Value = ArrayValue<'ctx>;
|
||||||
|
type Type = ArrayType<'ctx>;
|
||||||
|
|
||||||
|
fn llvm_type<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
) -> Self::Type {
|
||||||
|
self.item.llvm_type(generator, ctx).array_type(self.len.length())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn check_type<T: BasicType<'ctx>, G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
ty: T,
|
||||||
|
) -> Result<(), ModelError> {
|
||||||
|
let ty = ty.as_basic_type_enum();
|
||||||
|
let BasicTypeEnum::ArrayType(ty) = ty else {
|
||||||
|
return Err(ModelError(format!("Expecting ArrayType, but got {ty:?}")));
|
||||||
|
};
|
||||||
|
|
||||||
|
if ty.len() != self.len.length() {
|
||||||
|
return Err(ModelError(format!(
|
||||||
|
"Expecting ArrayType with size {}, but got an ArrayType with size {}",
|
||||||
|
ty.len(),
|
||||||
|
self.len.length()
|
||||||
|
)));
|
||||||
|
}
|
||||||
|
|
||||||
|
self.item
|
||||||
|
.check_type(generator, ctx, ty.get_element_type())
|
||||||
|
.map_err(|err| err.under_context("an ArrayType"))?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx, Len: ArrayLen, Item: Model<'ctx>> Instance<'ctx, Ptr<Array<Len, Item>>> {
|
||||||
|
/// Get the pointer to the `i`-th (0-based) array element.
|
||||||
|
pub fn gep(
|
||||||
|
&self,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
i: IntValue<'ctx>,
|
||||||
|
) -> Instance<'ctx, Ptr<Item>> {
|
||||||
|
let zero = ctx.ctx.i32_type().const_zero();
|
||||||
|
let ptr = unsafe { ctx.builder.build_in_bounds_gep(self.value, &[zero, i], "").unwrap() };
|
||||||
|
|
||||||
|
unsafe { Ptr(self.model.0.item).believe_value(ptr) }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Like `gep` but `i` is a constant.
|
||||||
|
pub fn gep_const(&self, ctx: &CodeGenContext<'ctx, '_>, i: u64) -> Instance<'ctx, Ptr<Item>> {
|
||||||
|
assert!(
|
||||||
|
i < u64::from(self.model.0.len.length()),
|
||||||
|
"Index {i} is out of bounds. Array length = {}",
|
||||||
|
self.model.0.len.length()
|
||||||
|
);
|
||||||
|
|
||||||
|
let i = ctx.ctx.i32_type().const_int(i, false);
|
||||||
|
self.gep(ctx, i)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convenience function equivalent to `.gep(...).load(...)`.
|
||||||
|
pub fn get<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
i: IntValue<'ctx>,
|
||||||
|
) -> Instance<'ctx, Item> {
|
||||||
|
self.gep(ctx, i).load(generator, ctx)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Like `get` but `i` is a constant.
|
||||||
|
pub fn get_const<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
i: u64,
|
||||||
|
) -> Instance<'ctx, Item> {
|
||||||
|
self.gep_const(ctx, i).load(generator, ctx)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convenience function equivalent to `.gep(...).store(...)`.
|
||||||
|
pub fn set(
|
||||||
|
&self,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
i: IntValue<'ctx>,
|
||||||
|
value: Instance<'ctx, Item>,
|
||||||
|
) {
|
||||||
|
self.gep(ctx, i).store(ctx, value);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Like `set` but `i` is a constant.
|
||||||
|
pub fn set_const(&self, ctx: &CodeGenContext<'ctx, '_>, i: u64, value: Instance<'ctx, Item>) {
|
||||||
|
self.gep_const(ctx, i).store(ctx, value);
|
||||||
|
}
|
||||||
|
}
|
|
@ -0,0 +1,207 @@
|
||||||
|
use std::fmt;
|
||||||
|
|
||||||
|
use inkwell::{context::Context, types::*, values::*};
|
||||||
|
use itertools::Itertools;
|
||||||
|
|
||||||
|
use super::*;
|
||||||
|
use crate::codegen::{CodeGenContext, CodeGenerator};
|
||||||
|
|
||||||
|
/// A error type for reporting any [`Model`]-related error (e.g., a [`BasicType`] mismatch).
|
||||||
|
#[derive(Debug, Clone)]
|
||||||
|
pub struct ModelError(pub String);
|
||||||
|
|
||||||
|
impl ModelError {
|
||||||
|
/// Append a context message to the error.
|
||||||
|
pub(super) fn under_context(mut self, context: &str) -> Self {
|
||||||
|
self.0.push_str(" ... in ");
|
||||||
|
self.0.push_str(context);
|
||||||
|
self
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Trait for Rust structs identifying [`BasicType`]s in the context of a known [`CodeGenerator`] and [`CodeGenContext`].
|
||||||
|
///
|
||||||
|
/// For instance,
|
||||||
|
/// - [`Int<Int32>`] identifies an [`IntType`] with 32-bits.
|
||||||
|
/// - [`Int<SizeT>`] identifies an [`IntType`] with bit-width [`CodeGenerator::get_size_type`].
|
||||||
|
/// - [`Ptr<Int<SizeT>>`] identifies a [`PointerType`] that points to an [`IntType`] with bit-width [`CodeGenerator::get_size_type`].
|
||||||
|
/// - [`Int<AnyInt>`] identifies an [`IntType`] with bit-width of whatever is set in the [`AnyInt`] object.
|
||||||
|
/// - [`Any`] identifies a [`BasicType`] set in the [`Any`] object itself.
|
||||||
|
///
|
||||||
|
/// You can get the [`BasicType`] out of a model with [`Model::get_type`].
|
||||||
|
///
|
||||||
|
/// Furthermore, [`Instance<'ctx, M>`] is a simple structure that carries a [`BasicValue`] with [`BasicType`] identified by model `M`.
|
||||||
|
///
|
||||||
|
/// The main purpose of this abstraction is to have a more Rust type-safe way to use Inkwell and give type-hints for programmers.
|
||||||
|
///
|
||||||
|
/// ### Notes on `Default` trait
|
||||||
|
///
|
||||||
|
/// For some models like [`Int<Int32>`] or [`Int<SizeT>`], they have a [`Default`] trait since just by looking at their types, it is possible
|
||||||
|
/// to tell the [`BasicType`]s they are identifying.
|
||||||
|
///
|
||||||
|
/// This can be used to create strongly-typed interfaces accepting only values of a specific [`BasicType`] without having to worry about
|
||||||
|
/// writing debug assertions to check, for example, if the programmer has passed in an [`IntValue`] with the wrong bit-width.
|
||||||
|
/// ```ignore
|
||||||
|
/// fn give_me_i32_and_get_a_size_t_back<'ctx>(i32: Instance<'ctx, Int<Int32>>) -> Instance<'ctx, Int<SizeT>> {
|
||||||
|
/// // code...
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
///
|
||||||
|
/// ### Notes on converting between Inkwell and model/ge.
|
||||||
|
///
|
||||||
|
/// Suppose you have an [`IntValue`], and you want to pass it into a function that takes a [`Instance<'ctx, Int<Int32>>`]. You can do use
|
||||||
|
/// [`Model::check_value`] or [`Model::believe_value`].
|
||||||
|
/// ```ignore
|
||||||
|
/// let my_value: IntValue<'ctx>;
|
||||||
|
///
|
||||||
|
/// let my_value = Int(Int32).check_value(my_value).unwrap(); // Panics if `my_value` is not 32-bit with a descriptive error message.
|
||||||
|
///
|
||||||
|
/// // or, if you are absolutely certain that `my_value` is 32-bit and doing extra checks is a waste of time:
|
||||||
|
/// let my_value = Int(Int32).believe_value(my_value);
|
||||||
|
/// ```
|
||||||
|
pub trait Model<'ctx>: fmt::Debug + Clone + Copy {
|
||||||
|
/// The [`BasicType`] *variant* this model is identifying.
|
||||||
|
type Type: BasicType<'ctx>;
|
||||||
|
|
||||||
|
/// The [`BasicValue`] type of the [`BasicType`] of this model.
|
||||||
|
type Value: BasicValue<'ctx> + TryFrom<BasicValueEnum<'ctx>>;
|
||||||
|
|
||||||
|
/// Return the [`BasicType`] of this model.
|
||||||
|
#[must_use]
|
||||||
|
fn llvm_type<G: CodeGenerator + ?Sized>(&self, generator: &G, ctx: &'ctx Context)
|
||||||
|
-> Self::Type;
|
||||||
|
|
||||||
|
/// Get the number of bytes of the [`BasicType`] of this model.
|
||||||
|
fn size_of<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
) -> IntValue<'ctx> {
|
||||||
|
self.llvm_type(generator, ctx).size_of().unwrap()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Check if a [`BasicType`] matches the [`BasicType`] of this model.
|
||||||
|
fn check_type<T: BasicType<'ctx>, G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
ty: T,
|
||||||
|
) -> Result<(), ModelError>;
|
||||||
|
|
||||||
|
/// Create an instance from a value.
|
||||||
|
///
|
||||||
|
/// # Safety
|
||||||
|
///
|
||||||
|
/// Caller must make sure the type of `value` and the type of this `model` are equivalent.
|
||||||
|
#[must_use]
|
||||||
|
unsafe fn believe_value(&self, value: Self::Value) -> Instance<'ctx, Self> {
|
||||||
|
Instance { model: *self, value }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Check if a [`BasicValue`]'s type is equivalent to the type of this model.
|
||||||
|
/// Wrap the [`BasicValue`] into an [`Instance`] if it is.
|
||||||
|
fn check_value<V: BasicValue<'ctx>, G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
value: V,
|
||||||
|
) -> Result<Instance<'ctx, Self>, ModelError> {
|
||||||
|
let value = value.as_basic_value_enum();
|
||||||
|
self.check_type(generator, ctx, value.get_type())
|
||||||
|
.map_err(|err| err.under_context(format!("the value {value:?}").as_str()))?;
|
||||||
|
|
||||||
|
let Ok(value) = Self::Value::try_from(value) else {
|
||||||
|
unreachable!("check_type() has bad implementation")
|
||||||
|
};
|
||||||
|
unsafe { Ok(self.believe_value(value)) }
|
||||||
|
}
|
||||||
|
|
||||||
|
// Allocate a value on the stack and return its pointer.
|
||||||
|
fn alloca<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
) -> Instance<'ctx, Ptr<Self>> {
|
||||||
|
let p = ctx.builder.build_alloca(self.llvm_type(generator, ctx.ctx), "").unwrap();
|
||||||
|
unsafe { Ptr(*self).believe_value(p) }
|
||||||
|
}
|
||||||
|
|
||||||
|
// Allocate an array on the stack and return its pointer.
|
||||||
|
fn array_alloca<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
len: IntValue<'ctx>,
|
||||||
|
) -> Instance<'ctx, Ptr<Self>> {
|
||||||
|
let p =
|
||||||
|
ctx.builder.build_array_alloca(self.llvm_type(generator, ctx.ctx), len, "").unwrap();
|
||||||
|
unsafe { Ptr(*self).believe_value(p) }
|
||||||
|
}
|
||||||
|
|
||||||
|
fn var_alloca<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
name: Option<&str>,
|
||||||
|
) -> Result<Instance<'ctx, Ptr<Self>>, String> {
|
||||||
|
let ty = self.llvm_type(generator, ctx.ctx).as_basic_type_enum();
|
||||||
|
let p = generator.gen_var_alloc(ctx, ty, name)?;
|
||||||
|
unsafe { Ok(Ptr(*self).believe_value(p)) }
|
||||||
|
}
|
||||||
|
|
||||||
|
fn array_var_alloca<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
len: IntValue<'ctx>,
|
||||||
|
name: Option<&'ctx str>,
|
||||||
|
) -> Result<Instance<'ctx, Ptr<Self>>, String> {
|
||||||
|
// TODO: Remove ArraySliceValue
|
||||||
|
let ty = self.llvm_type(generator, ctx.ctx).as_basic_type_enum();
|
||||||
|
let p = generator.gen_array_var_alloc(ctx, ty, len, name)?;
|
||||||
|
unsafe { Ok(Ptr(*self).believe_value(PointerValue::from(p))) }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Allocate a constant array.
|
||||||
|
fn const_array<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
values: &[Instance<'ctx, Self>],
|
||||||
|
) -> Instance<'ctx, Array<AnyLen, Self>> {
|
||||||
|
macro_rules! make {
|
||||||
|
($t:expr, $into_value:expr) => {
|
||||||
|
$t.const_array(
|
||||||
|
&values
|
||||||
|
.iter()
|
||||||
|
.map(|x| $into_value(x.value.as_basic_value_enum()))
|
||||||
|
.collect_vec(),
|
||||||
|
)
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
let value = match self.llvm_type(generator, ctx).as_basic_type_enum() {
|
||||||
|
BasicTypeEnum::ArrayType(t) => make!(t, BasicValueEnum::into_array_value),
|
||||||
|
BasicTypeEnum::IntType(t) => make!(t, BasicValueEnum::into_int_value),
|
||||||
|
BasicTypeEnum::FloatType(t) => make!(t, BasicValueEnum::into_float_value),
|
||||||
|
BasicTypeEnum::PointerType(t) => make!(t, BasicValueEnum::into_pointer_value),
|
||||||
|
BasicTypeEnum::StructType(t) => make!(t, BasicValueEnum::into_struct_value),
|
||||||
|
BasicTypeEnum::VectorType(t) => make!(t, BasicValueEnum::into_vector_value),
|
||||||
|
};
|
||||||
|
|
||||||
|
Array { len: AnyLen(values.len() as u32), item: *self }
|
||||||
|
.check_value(generator, ctx, value)
|
||||||
|
.unwrap()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, Clone, Copy)]
|
||||||
|
pub struct Instance<'ctx, M: Model<'ctx>> {
|
||||||
|
/// The model of this instance.
|
||||||
|
pub model: M,
|
||||||
|
|
||||||
|
/// The value of this instance.
|
||||||
|
///
|
||||||
|
/// It is guaranteed the [`BasicType`] of `value` is consistent with that of `model`.
|
||||||
|
pub value: M::Value,
|
||||||
|
}
|
|
@ -0,0 +1,94 @@
|
||||||
|
use std::fmt;
|
||||||
|
|
||||||
|
use inkwell::{
|
||||||
|
context::Context,
|
||||||
|
types::{BasicType, FloatType},
|
||||||
|
values::FloatValue,
|
||||||
|
};
|
||||||
|
|
||||||
|
use crate::codegen::CodeGenerator;
|
||||||
|
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
pub trait FloatKind<'ctx>: fmt::Debug + Clone + Copy {
|
||||||
|
fn get_float_type<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
) -> FloatType<'ctx>;
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, Clone, Copy, Default)]
|
||||||
|
pub struct Float32;
|
||||||
|
#[derive(Debug, Clone, Copy, Default)]
|
||||||
|
pub struct Float64;
|
||||||
|
|
||||||
|
impl<'ctx> FloatKind<'ctx> for Float32 {
|
||||||
|
fn get_float_type<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
_generator: &G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
) -> FloatType<'ctx> {
|
||||||
|
ctx.f32_type()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx> FloatKind<'ctx> for Float64 {
|
||||||
|
fn get_float_type<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
_generator: &G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
) -> FloatType<'ctx> {
|
||||||
|
ctx.f64_type()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, Clone, Copy)]
|
||||||
|
pub struct AnyFloat<'ctx>(FloatType<'ctx>);
|
||||||
|
|
||||||
|
impl<'ctx> FloatKind<'ctx> for AnyFloat<'ctx> {
|
||||||
|
fn get_float_type<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
_generator: &G,
|
||||||
|
_ctx: &'ctx Context,
|
||||||
|
) -> FloatType<'ctx> {
|
||||||
|
self.0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, Clone, Copy, Default)]
|
||||||
|
pub struct Float<N>(pub N);
|
||||||
|
|
||||||
|
impl<'ctx, N: FloatKind<'ctx>> Model<'ctx> for Float<N> {
|
||||||
|
type Value = FloatValue<'ctx>;
|
||||||
|
type Type = FloatType<'ctx>;
|
||||||
|
|
||||||
|
fn llvm_type<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
) -> Self::Type {
|
||||||
|
self.0.get_float_type(generator, ctx)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn check_type<T: BasicType<'ctx>, G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
ty: T,
|
||||||
|
) -> Result<(), ModelError> {
|
||||||
|
let ty = ty.as_basic_type_enum();
|
||||||
|
let Ok(ty) = FloatType::try_from(ty) else {
|
||||||
|
return Err(ModelError(format!("Expecting FloatType, but got {ty:?}")));
|
||||||
|
};
|
||||||
|
|
||||||
|
let exp_ty = self.0.get_float_type(generator, ctx);
|
||||||
|
|
||||||
|
// TODO: Inkwell does not have get_bit_width for FloatType?
|
||||||
|
if ty != exp_ty {
|
||||||
|
return Err(ModelError(format!("Expecting {exp_ty:?}, but got {ty:?}")));
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
|
@ -0,0 +1,122 @@
|
||||||
|
use inkwell::{
|
||||||
|
attributes::{Attribute, AttributeLoc},
|
||||||
|
types::{BasicMetadataTypeEnum, BasicType, FunctionType},
|
||||||
|
values::{AnyValue, BasicMetadataValueEnum, BasicValue, BasicValueEnum, CallSiteValue},
|
||||||
|
};
|
||||||
|
use itertools::Itertools;
|
||||||
|
|
||||||
|
use crate::codegen::{CodeGenContext, CodeGenerator};
|
||||||
|
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
#[derive(Debug, Clone, Copy)]
|
||||||
|
struct Arg<'ctx> {
|
||||||
|
ty: BasicMetadataTypeEnum<'ctx>,
|
||||||
|
val: BasicMetadataValueEnum<'ctx>,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A convenience structure to construct & call an LLVM function.
|
||||||
|
///
|
||||||
|
/// ### Usage
|
||||||
|
///
|
||||||
|
/// The syntax is like this:
|
||||||
|
/// ```ignore
|
||||||
|
/// let result = CallFunction::begin("my_function_name")
|
||||||
|
/// .attrs(...)
|
||||||
|
/// .arg(arg1)
|
||||||
|
/// .arg(arg2)
|
||||||
|
/// .arg(arg3)
|
||||||
|
/// .returning("my_function_result", Int32);
|
||||||
|
/// ```
|
||||||
|
///
|
||||||
|
/// The function `my_function_name` is called when `.returning()` (or its variants) is called, returning
|
||||||
|
/// the result as an `Instance<'ctx, Int<Int32>>`.
|
||||||
|
///
|
||||||
|
/// If `my_function_name` has not been declared in `ctx.module`, once `.returning()` is called, a function
|
||||||
|
/// declaration of `my_function_name` is added to `ctx.module`, where the [`FunctionType`] is deduced from
|
||||||
|
/// the argument types and returning type.
|
||||||
|
pub struct FnCall<'ctx, 'a, 'b, 'c, 'd, G: CodeGenerator + ?Sized> {
|
||||||
|
generator: &'d mut G,
|
||||||
|
ctx: &'b CodeGenContext<'ctx, 'a>,
|
||||||
|
/// Function name
|
||||||
|
name: &'c str,
|
||||||
|
/// Call arguments
|
||||||
|
args: Vec<Arg<'ctx>>,
|
||||||
|
/// LLVM function Attributes
|
||||||
|
attrs: Vec<&'static str>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx, 'a, 'b, 'c, 'd, G: CodeGenerator + ?Sized> FnCall<'ctx, 'a, 'b, 'c, 'd, G> {
|
||||||
|
pub fn builder(generator: &'d mut G, ctx: &'b CodeGenContext<'ctx, 'a>, name: &'c str) -> Self {
|
||||||
|
FnCall { generator, ctx, name, args: Vec::new(), attrs: Vec::new() }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Push a list of LLVM function attributes to the function declaration.
|
||||||
|
#[must_use]
|
||||||
|
pub fn attrs(mut self, attrs: Vec<&'static str>) -> Self {
|
||||||
|
self.attrs = attrs;
|
||||||
|
self
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Push a call argument to the function call.
|
||||||
|
#[allow(clippy::needless_pass_by_value)]
|
||||||
|
#[must_use]
|
||||||
|
pub fn arg<M: Model<'ctx>>(mut self, arg: Instance<'ctx, M>) -> Self {
|
||||||
|
let arg = Arg {
|
||||||
|
ty: arg.model.llvm_type(self.generator, self.ctx.ctx).as_basic_type_enum().into(),
|
||||||
|
val: arg.value.as_basic_value_enum().into(),
|
||||||
|
};
|
||||||
|
self.args.push(arg);
|
||||||
|
self
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Call the function and expect the function to return a value of type of `return_model`.
|
||||||
|
#[must_use]
|
||||||
|
pub fn returning<M: Model<'ctx>>(self, name: &str, return_model: M) -> Instance<'ctx, M> {
|
||||||
|
let ret_ty = return_model.llvm_type(self.generator, self.ctx.ctx);
|
||||||
|
|
||||||
|
let ret = self.call(|tys| ret_ty.fn_type(tys, false), name);
|
||||||
|
let ret = BasicValueEnum::try_from(ret.as_any_value_enum()).unwrap(); // Must work
|
||||||
|
let ret = return_model.check_value(self.generator, self.ctx.ctx, ret).unwrap(); // Must work
|
||||||
|
ret
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Like [`CallFunction::returning_`] but `return_model` is automatically inferred.
|
||||||
|
#[must_use]
|
||||||
|
pub fn returning_auto<M: Model<'ctx> + Default>(self, name: &str) -> Instance<'ctx, M> {
|
||||||
|
self.returning(name, M::default())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Call the function and expect the function to return a void-type.
|
||||||
|
pub fn returning_void(self) {
|
||||||
|
let ret_ty = self.ctx.ctx.void_type();
|
||||||
|
|
||||||
|
let _ = self.call(|tys| ret_ty.fn_type(tys, false), "");
|
||||||
|
}
|
||||||
|
|
||||||
|
fn call<F>(&self, make_fn_type: F, return_value_name: &str) -> CallSiteValue<'ctx>
|
||||||
|
where
|
||||||
|
F: FnOnce(&[BasicMetadataTypeEnum<'ctx>]) -> FunctionType<'ctx>,
|
||||||
|
{
|
||||||
|
// Get the LLVM function.
|
||||||
|
let func = self.ctx.module.get_function(self.name).unwrap_or_else(|| {
|
||||||
|
// Declare the function if it doesn't exist.
|
||||||
|
let tys = self.args.iter().map(|arg| arg.ty).collect_vec();
|
||||||
|
|
||||||
|
let func_type = make_fn_type(&tys);
|
||||||
|
let func = self.ctx.module.add_function(self.name, func_type, None);
|
||||||
|
|
||||||
|
for attr in &self.attrs {
|
||||||
|
func.add_attribute(
|
||||||
|
AttributeLoc::Function,
|
||||||
|
self.ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
func
|
||||||
|
});
|
||||||
|
|
||||||
|
let vals = self.args.iter().map(|arg| arg.val).collect_vec();
|
||||||
|
self.ctx.builder.build_call(func, &vals, return_value_name).unwrap()
|
||||||
|
}
|
||||||
|
}
|
|
@ -0,0 +1,422 @@
|
||||||
|
use std::{cmp::Ordering, fmt};
|
||||||
|
|
||||||
|
use inkwell::{
|
||||||
|
context::Context,
|
||||||
|
types::{BasicType, IntType},
|
||||||
|
values::IntValue,
|
||||||
|
IntPredicate,
|
||||||
|
};
|
||||||
|
|
||||||
|
use crate::codegen::{CodeGenContext, CodeGenerator};
|
||||||
|
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
pub trait IntKind<'ctx>: fmt::Debug + Clone + Copy {
|
||||||
|
fn get_int_type<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
) -> IntType<'ctx>;
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, Clone, Copy, Default)]
|
||||||
|
pub struct Bool;
|
||||||
|
#[derive(Debug, Clone, Copy, Default)]
|
||||||
|
pub struct Byte;
|
||||||
|
#[derive(Debug, Clone, Copy, Default)]
|
||||||
|
pub struct Int32;
|
||||||
|
#[derive(Debug, Clone, Copy, Default)]
|
||||||
|
pub struct Int64;
|
||||||
|
#[derive(Debug, Clone, Copy, Default)]
|
||||||
|
pub struct SizeT;
|
||||||
|
|
||||||
|
impl<'ctx> IntKind<'ctx> for Bool {
|
||||||
|
fn get_int_type<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
_generator: &G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
) -> IntType<'ctx> {
|
||||||
|
ctx.bool_type()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx> IntKind<'ctx> for Byte {
|
||||||
|
fn get_int_type<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
_generator: &G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
) -> IntType<'ctx> {
|
||||||
|
ctx.i8_type()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx> IntKind<'ctx> for Int32 {
|
||||||
|
fn get_int_type<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
_generator: &G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
) -> IntType<'ctx> {
|
||||||
|
ctx.i32_type()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx> IntKind<'ctx> for Int64 {
|
||||||
|
fn get_int_type<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
_generator: &G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
) -> IntType<'ctx> {
|
||||||
|
ctx.i64_type()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx> IntKind<'ctx> for SizeT {
|
||||||
|
fn get_int_type<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
) -> IntType<'ctx> {
|
||||||
|
generator.get_size_type(ctx)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, Clone, Copy)]
|
||||||
|
pub struct AnyInt<'ctx>(pub IntType<'ctx>);
|
||||||
|
|
||||||
|
impl<'ctx> IntKind<'ctx> for AnyInt<'ctx> {
|
||||||
|
fn get_int_type<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
_generator: &G,
|
||||||
|
_ctx: &'ctx Context,
|
||||||
|
) -> IntType<'ctx> {
|
||||||
|
self.0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, Clone, Copy, Default)]
|
||||||
|
pub struct Int<N>(pub N);
|
||||||
|
|
||||||
|
impl<'ctx, N: IntKind<'ctx>> Model<'ctx> for Int<N> {
|
||||||
|
type Value = IntValue<'ctx>;
|
||||||
|
type Type = IntType<'ctx>;
|
||||||
|
|
||||||
|
fn llvm_type<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
) -> Self::Type {
|
||||||
|
self.0.get_int_type(generator, ctx)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn check_type<T: BasicType<'ctx>, G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
ty: T,
|
||||||
|
) -> Result<(), ModelError> {
|
||||||
|
let ty = ty.as_basic_type_enum();
|
||||||
|
let Ok(ty) = IntType::try_from(ty) else {
|
||||||
|
return Err(ModelError(format!("Expecting IntType, but got {ty:?}")));
|
||||||
|
};
|
||||||
|
|
||||||
|
let exp_ty = self.0.get_int_type(generator, ctx);
|
||||||
|
if ty.get_bit_width() != exp_ty.get_bit_width() {
|
||||||
|
return Err(ModelError(format!(
|
||||||
|
"Expecting IntType to have {} bit(s), but got {} bit(s)",
|
||||||
|
exp_ty.get_bit_width(),
|
||||||
|
ty.get_bit_width()
|
||||||
|
)));
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx, N: IntKind<'ctx>> Int<N> {
|
||||||
|
pub fn const_int<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
value: u64,
|
||||||
|
sign_extend: bool,
|
||||||
|
) -> Instance<'ctx, Self> {
|
||||||
|
let value = self.llvm_type(generator, ctx).const_int(value, sign_extend);
|
||||||
|
unsafe { self.believe_value(value) }
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn const_0<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
) -> Instance<'ctx, Self> {
|
||||||
|
let value = self.llvm_type(generator, ctx).const_zero();
|
||||||
|
unsafe { self.believe_value(value) }
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn const_1<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
) -> Instance<'ctx, Self> {
|
||||||
|
self.const_int(generator, ctx, 1, false)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn const_all_ones<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
) -> Instance<'ctx, Self> {
|
||||||
|
let value = self.llvm_type(generator, ctx).const_all_ones();
|
||||||
|
unsafe { self.believe_value(value) }
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn s_extend_or_bit_cast<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
value: IntValue<'ctx>,
|
||||||
|
) -> Instance<'ctx, Self> {
|
||||||
|
assert!(
|
||||||
|
value.get_type().get_bit_width()
|
||||||
|
<= self.0.get_int_type(generator, ctx.ctx).get_bit_width()
|
||||||
|
);
|
||||||
|
let value = ctx
|
||||||
|
.builder
|
||||||
|
.build_int_s_extend_or_bit_cast(value, self.llvm_type(generator, ctx.ctx), "")
|
||||||
|
.unwrap();
|
||||||
|
unsafe { self.believe_value(value) }
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn s_extend<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
value: IntValue<'ctx>,
|
||||||
|
) -> Instance<'ctx, Self> {
|
||||||
|
assert!(
|
||||||
|
value.get_type().get_bit_width()
|
||||||
|
< self.0.get_int_type(generator, ctx.ctx).get_bit_width()
|
||||||
|
);
|
||||||
|
let value =
|
||||||
|
ctx.builder.build_int_s_extend(value, self.llvm_type(generator, ctx.ctx), "").unwrap();
|
||||||
|
unsafe { self.believe_value(value) }
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn z_extend_or_bit_cast<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
value: IntValue<'ctx>,
|
||||||
|
) -> Instance<'ctx, Self> {
|
||||||
|
assert!(
|
||||||
|
value.get_type().get_bit_width()
|
||||||
|
<= self.0.get_int_type(generator, ctx.ctx).get_bit_width()
|
||||||
|
);
|
||||||
|
let value = ctx
|
||||||
|
.builder
|
||||||
|
.build_int_z_extend_or_bit_cast(value, self.llvm_type(generator, ctx.ctx), "")
|
||||||
|
.unwrap();
|
||||||
|
unsafe { self.believe_value(value) }
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn z_extend<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
value: IntValue<'ctx>,
|
||||||
|
) -> Instance<'ctx, Self> {
|
||||||
|
assert!(
|
||||||
|
value.get_type().get_bit_width()
|
||||||
|
< self.0.get_int_type(generator, ctx.ctx).get_bit_width()
|
||||||
|
);
|
||||||
|
let value =
|
||||||
|
ctx.builder.build_int_z_extend(value, self.llvm_type(generator, ctx.ctx), "").unwrap();
|
||||||
|
unsafe { self.believe_value(value) }
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn truncate_or_bit_cast<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
value: IntValue<'ctx>,
|
||||||
|
) -> Instance<'ctx, Self> {
|
||||||
|
assert!(
|
||||||
|
value.get_type().get_bit_width()
|
||||||
|
>= self.0.get_int_type(generator, ctx.ctx).get_bit_width()
|
||||||
|
);
|
||||||
|
let value = ctx
|
||||||
|
.builder
|
||||||
|
.build_int_truncate_or_bit_cast(value, self.llvm_type(generator, ctx.ctx), "")
|
||||||
|
.unwrap();
|
||||||
|
unsafe { self.believe_value(value) }
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn truncate<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
value: IntValue<'ctx>,
|
||||||
|
) -> Instance<'ctx, Self> {
|
||||||
|
assert!(
|
||||||
|
value.get_type().get_bit_width()
|
||||||
|
> self.0.get_int_type(generator, ctx.ctx).get_bit_width()
|
||||||
|
);
|
||||||
|
let value =
|
||||||
|
ctx.builder.build_int_truncate(value, self.llvm_type(generator, ctx.ctx), "").unwrap();
|
||||||
|
unsafe { self.believe_value(value) }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// `sext` or `trunc` an int to this model's int type. Does nothing if equal bit-widths.
|
||||||
|
pub fn s_extend_or_truncate<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
value: IntValue<'ctx>,
|
||||||
|
) -> Instance<'ctx, Self> {
|
||||||
|
let their_width = value.get_type().get_bit_width();
|
||||||
|
let our_width = self.0.get_int_type(generator, ctx.ctx).get_bit_width();
|
||||||
|
match their_width.cmp(&our_width) {
|
||||||
|
Ordering::Less => self.s_extend(generator, ctx, value),
|
||||||
|
Ordering::Equal => unsafe { self.believe_value(value) },
|
||||||
|
Ordering::Greater => self.truncate(generator, ctx, value),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// `zext` or `trunc` an int to this model's int type. Does nothing if equal bit-widths.
|
||||||
|
pub fn z_extend_or_truncate<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
value: IntValue<'ctx>,
|
||||||
|
) -> Instance<'ctx, Self> {
|
||||||
|
let their_width = value.get_type().get_bit_width();
|
||||||
|
let our_width = self.0.get_int_type(generator, ctx.ctx).get_bit_width();
|
||||||
|
match their_width.cmp(&our_width) {
|
||||||
|
Ordering::Less => self.z_extend(generator, ctx, value),
|
||||||
|
Ordering::Equal => unsafe { self.believe_value(value) },
|
||||||
|
Ordering::Greater => self.truncate(generator, ctx, value),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Int<Bool> {
|
||||||
|
#[must_use]
|
||||||
|
pub fn const_false<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
) -> Instance<'ctx, Self> {
|
||||||
|
self.const_int(generator, ctx, 0, false)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[must_use]
|
||||||
|
pub fn const_true<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
) -> Instance<'ctx, Self> {
|
||||||
|
self.const_int(generator, ctx, 1, false)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx, N: IntKind<'ctx>> Instance<'ctx, Int<N>> {
|
||||||
|
pub fn s_extend_or_bit_cast<NewN: IntKind<'ctx>, G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
to_int_kind: NewN,
|
||||||
|
) -> Instance<'ctx, Int<NewN>> {
|
||||||
|
Int(to_int_kind).s_extend_or_bit_cast(generator, ctx, self.value)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn s_extend<NewN: IntKind<'ctx>, G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
to_int_kind: NewN,
|
||||||
|
) -> Instance<'ctx, Int<NewN>> {
|
||||||
|
Int(to_int_kind).s_extend(generator, ctx, self.value)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn z_extend_or_bit_cast<NewN: IntKind<'ctx>, G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
to_int_kind: NewN,
|
||||||
|
) -> Instance<'ctx, Int<NewN>> {
|
||||||
|
Int(to_int_kind).z_extend_or_bit_cast(generator, ctx, self.value)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn z_extend<NewN: IntKind<'ctx>, G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
to_int_kind: NewN,
|
||||||
|
) -> Instance<'ctx, Int<NewN>> {
|
||||||
|
Int(to_int_kind).z_extend(generator, ctx, self.value)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn truncate_or_bit_cast<NewN: IntKind<'ctx>, G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
to_int_kind: NewN,
|
||||||
|
) -> Instance<'ctx, Int<NewN>> {
|
||||||
|
Int(to_int_kind).truncate_or_bit_cast(generator, ctx, self.value)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn truncate<NewN: IntKind<'ctx>, G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
to_int_kind: NewN,
|
||||||
|
) -> Instance<'ctx, Int<NewN>> {
|
||||||
|
Int(to_int_kind).truncate(generator, ctx, self.value)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn s_extend_or_truncate<NewN: IntKind<'ctx>, G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
to_int_kind: NewN,
|
||||||
|
) -> Instance<'ctx, Int<NewN>> {
|
||||||
|
Int(to_int_kind).s_extend_or_truncate(generator, ctx, self.value)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn z_extend_or_truncate<NewN: IntKind<'ctx>, G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
to_int_kind: NewN,
|
||||||
|
) -> Instance<'ctx, Int<NewN>> {
|
||||||
|
Int(to_int_kind).z_extend_or_truncate(generator, ctx, self.value)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[must_use]
|
||||||
|
pub fn add(&self, ctx: &CodeGenContext<'ctx, '_>, other: Self) -> Self {
|
||||||
|
let value = ctx.builder.build_int_add(self.value, other.value, "").unwrap();
|
||||||
|
unsafe { self.model.believe_value(value) }
|
||||||
|
}
|
||||||
|
|
||||||
|
#[must_use]
|
||||||
|
pub fn sub(&self, ctx: &CodeGenContext<'ctx, '_>, other: Self) -> Self {
|
||||||
|
let value = ctx.builder.build_int_sub(self.value, other.value, "").unwrap();
|
||||||
|
unsafe { self.model.believe_value(value) }
|
||||||
|
}
|
||||||
|
|
||||||
|
#[must_use]
|
||||||
|
pub fn mul(&self, ctx: &CodeGenContext<'ctx, '_>, other: Self) -> Self {
|
||||||
|
let value = ctx.builder.build_int_mul(self.value, other.value, "").unwrap();
|
||||||
|
unsafe { self.model.believe_value(value) }
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn compare(
|
||||||
|
&self,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
op: IntPredicate,
|
||||||
|
other: Self,
|
||||||
|
) -> Instance<'ctx, Int<Bool>> {
|
||||||
|
let value = ctx.builder.build_int_compare(op, self.value, other.value, "").unwrap();
|
||||||
|
unsafe { Int(Bool).believe_value(value) }
|
||||||
|
}
|
||||||
|
}
|
|
@ -0,0 +1,17 @@
|
||||||
|
mod any;
|
||||||
|
mod array;
|
||||||
|
mod core;
|
||||||
|
mod float;
|
||||||
|
pub mod function;
|
||||||
|
mod int;
|
||||||
|
mod ptr;
|
||||||
|
mod structure;
|
||||||
|
pub mod util;
|
||||||
|
|
||||||
|
pub use any::*;
|
||||||
|
pub use array::*;
|
||||||
|
pub use core::*;
|
||||||
|
pub use float::*;
|
||||||
|
pub use int::*;
|
||||||
|
pub use ptr::*;
|
||||||
|
pub use structure::*;
|
|
@ -0,0 +1,223 @@
|
||||||
|
use inkwell::{
|
||||||
|
context::Context,
|
||||||
|
types::{BasicType, BasicTypeEnum, PointerType},
|
||||||
|
values::{IntValue, PointerValue},
|
||||||
|
AddressSpace,
|
||||||
|
};
|
||||||
|
|
||||||
|
use crate::codegen::{llvm_intrinsics::call_memcpy_generic, CodeGenContext, CodeGenerator};
|
||||||
|
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
/// A model for [`PointerType`].
|
||||||
|
///
|
||||||
|
/// `Item` is the element type this pointer is pointing to, and should be of a [`Model`].
|
||||||
|
///
|
||||||
|
// TODO: LLVM 15: `Item` is a Rust type-hint for the LLVM type of value the `.store()/.load()` family
|
||||||
|
// of functions return. If a truly opaque pointer is needed, tell the programmer to use `OpaquePtr`.
|
||||||
|
#[derive(Debug, Clone, Copy, Default)]
|
||||||
|
pub struct Ptr<Item>(pub Item);
|
||||||
|
|
||||||
|
/// An opaque pointer. Like [`Ptr`] but without any Rust type-hints about its element type.
|
||||||
|
///
|
||||||
|
/// `.load()/.store()` is not available for [`Instance`]s of opaque pointers.
|
||||||
|
pub type OpaquePtr = Ptr<()>;
|
||||||
|
|
||||||
|
// TODO: LLVM 15: `Item: Model<'ctx>` don't even need to be a model anymore. It will only be
|
||||||
|
// a type-hint for the `.load()/.store()` functions for the `pointee_ty`.
|
||||||
|
//
|
||||||
|
// See https://thedan64.github.io/inkwell/inkwell/builder/struct.Builder.html#method.build_load.
|
||||||
|
impl<'ctx, Item: Model<'ctx>> Model<'ctx> for Ptr<Item> {
|
||||||
|
type Value = PointerValue<'ctx>;
|
||||||
|
type Type = PointerType<'ctx>;
|
||||||
|
|
||||||
|
fn llvm_type<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
) -> Self::Type {
|
||||||
|
// TODO: LLVM 15: ctx.ptr_type(AddressSpace::default())
|
||||||
|
self.0.llvm_type(generator, ctx).ptr_type(AddressSpace::default())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn check_type<T: BasicType<'ctx>, G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
ty: T,
|
||||||
|
) -> Result<(), ModelError> {
|
||||||
|
let ty = ty.as_basic_type_enum();
|
||||||
|
let Ok(ty) = PointerType::try_from(ty) else {
|
||||||
|
return Err(ModelError(format!("Expecting PointerType, but got {ty:?}")));
|
||||||
|
};
|
||||||
|
|
||||||
|
let elem_ty = ty.get_element_type();
|
||||||
|
let Ok(elem_ty) = BasicTypeEnum::try_from(elem_ty) else {
|
||||||
|
return Err(ModelError(format!(
|
||||||
|
"Expecting pointer element type to be a BasicTypeEnum, but got {elem_ty:?}"
|
||||||
|
)));
|
||||||
|
};
|
||||||
|
|
||||||
|
// TODO: inkwell `get_element_type()` will be deprecated.
|
||||||
|
// Remove the check for `get_element_type()` when the time comes.
|
||||||
|
self.0
|
||||||
|
.check_type(generator, ctx, elem_ty)
|
||||||
|
.map_err(|err| err.under_context("a PointerType"))?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx, Item: Model<'ctx>> Ptr<Item> {
|
||||||
|
/// Return a ***constant*** nullptr.
|
||||||
|
pub fn nullptr<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
) -> Instance<'ctx, Ptr<Item>> {
|
||||||
|
let ptr = self.llvm_type(generator, ctx).const_null();
|
||||||
|
unsafe { self.believe_value(ptr) }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Cast a pointer into this model with [`inkwell::builder::Builder::build_pointer_cast`]
|
||||||
|
pub fn pointer_cast<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
ptr: PointerValue<'ctx>,
|
||||||
|
) -> Instance<'ctx, Ptr<Item>> {
|
||||||
|
// TODO: LLVM 15: Write in an impl where `Item` does not have to be `Model<'ctx>`.
|
||||||
|
// TODO: LLVM 15: This function will only have to be:
|
||||||
|
// ```
|
||||||
|
// return self.believe_value(ptr);
|
||||||
|
// ```
|
||||||
|
let t = self.llvm_type(generator, ctx.ctx);
|
||||||
|
let ptr = ctx.builder.build_pointer_cast(ptr, t, "").unwrap();
|
||||||
|
unsafe { self.believe_value(ptr) }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx, Item: Model<'ctx>> Instance<'ctx, Ptr<Item>> {
|
||||||
|
/// Offset the pointer by [`inkwell::builder::Builder::build_in_bounds_gep`].
|
||||||
|
#[must_use]
|
||||||
|
pub fn offset(
|
||||||
|
&self,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
offset: IntValue<'ctx>,
|
||||||
|
) -> Instance<'ctx, Ptr<Item>> {
|
||||||
|
let p = unsafe { ctx.builder.build_in_bounds_gep(self.value, &[offset], "").unwrap() };
|
||||||
|
unsafe { self.model.believe_value(p) }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Offset the pointer by [`inkwell::builder::Builder::build_in_bounds_gep`] by a constant offset.
|
||||||
|
#[must_use]
|
||||||
|
pub fn offset_const(
|
||||||
|
&self,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
offset: i64,
|
||||||
|
) -> Instance<'ctx, Ptr<Item>> {
|
||||||
|
let offset = ctx.ctx.i32_type().const_int(offset as u64, true);
|
||||||
|
self.offset(ctx, offset)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn set_index(
|
||||||
|
&self,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
index: IntValue<'ctx>,
|
||||||
|
value: Instance<'ctx, Item>,
|
||||||
|
) {
|
||||||
|
self.offset(ctx, index).store(ctx, value);
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn set_index_const(
|
||||||
|
&self,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
index: i64,
|
||||||
|
value: Instance<'ctx, Item>,
|
||||||
|
) {
|
||||||
|
self.offset_const(ctx, index).store(ctx, value);
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn get_index<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
index: IntValue<'ctx>,
|
||||||
|
) -> Instance<'ctx, Item> {
|
||||||
|
self.offset(ctx, index).load(generator, ctx)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn get_index_const<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
index: i64,
|
||||||
|
) -> Instance<'ctx, Item> {
|
||||||
|
self.offset_const(ctx, index).load(generator, ctx)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Load the value with [`inkwell::builder::Builder::build_load`].
|
||||||
|
pub fn load<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
) -> Instance<'ctx, Item> {
|
||||||
|
let value = ctx.builder.build_load(self.value, "").unwrap();
|
||||||
|
self.model.0.check_value(generator, ctx.ctx, value).unwrap() // If unwrap() panics, there is a logic error.
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Store a value with [`inkwell::builder::Builder::build_store`].
|
||||||
|
pub fn store(&self, ctx: &CodeGenContext<'ctx, '_>, value: Instance<'ctx, Item>) {
|
||||||
|
ctx.builder.build_store(self.value, value.value).unwrap();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Return a casted pointer of element type `NewElement` with [`inkwell::builder::Builder::build_pointer_cast`].
|
||||||
|
pub fn pointer_cast<NewItem: Model<'ctx>, G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
new_item: NewItem,
|
||||||
|
) -> Instance<'ctx, Ptr<NewItem>> {
|
||||||
|
// TODO: LLVM 15: Write in an impl where `Item` does not have to be `Model<'ctx>`.
|
||||||
|
Ptr(new_item).pointer_cast(generator, ctx, self.value)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Cast this pointer to `uint8_t*`
|
||||||
|
pub fn cast_to_pi8<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
) -> Instance<'ctx, Ptr<Int<Byte>>> {
|
||||||
|
Ptr(Int(Byte)).pointer_cast(generator, ctx, self.value)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Check if the pointer is null with [`inkwell::builder::Builder::build_is_null`].
|
||||||
|
pub fn is_null(&self, ctx: &CodeGenContext<'ctx, '_>) -> Instance<'ctx, Int<Bool>> {
|
||||||
|
let value = ctx.builder.build_is_null(self.value, "").unwrap();
|
||||||
|
unsafe { Int(Bool).believe_value(value) }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Check if the pointer is not null with [`inkwell::builder::Builder::build_is_not_null`].
|
||||||
|
pub fn is_not_null(&self, ctx: &CodeGenContext<'ctx, '_>) -> Instance<'ctx, Int<Bool>> {
|
||||||
|
let value = ctx.builder.build_is_not_null(self.value, "").unwrap();
|
||||||
|
unsafe { Int(Bool).believe_value(value) }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// `memcpy` from another pointer.
|
||||||
|
pub fn copy_from<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
source: Self,
|
||||||
|
num_items: IntValue<'ctx>,
|
||||||
|
) {
|
||||||
|
// Force extend `num_items` and `itemsize` to `i64` so their types would match.
|
||||||
|
let itemsize = self.model.size_of(generator, ctx.ctx);
|
||||||
|
let itemsize = Int(SizeT).z_extend_or_truncate(generator, ctx, itemsize);
|
||||||
|
let num_items = Int(SizeT).z_extend_or_truncate(generator, ctx, num_items);
|
||||||
|
let totalsize = itemsize.mul(ctx, num_items);
|
||||||
|
|
||||||
|
let is_volatile = ctx.ctx.bool_type().const_zero(); // is_volatile = false
|
||||||
|
call_memcpy_generic(ctx, self.value, source.value, totalsize.value, is_volatile);
|
||||||
|
}
|
||||||
|
}
|
|
@ -0,0 +1,364 @@
|
||||||
|
use std::fmt;
|
||||||
|
|
||||||
|
use inkwell::{
|
||||||
|
context::Context,
|
||||||
|
types::{BasicType, BasicTypeEnum, StructType},
|
||||||
|
values::{BasicValueEnum, StructValue},
|
||||||
|
};
|
||||||
|
|
||||||
|
use crate::codegen::{CodeGenContext, CodeGenerator};
|
||||||
|
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
/// A traveral that traverses a Rust `struct` that is used to declare an LLVM's struct's field types.
|
||||||
|
pub trait FieldTraversal<'ctx> {
|
||||||
|
/// Output type of [`FieldTraversal::add`].
|
||||||
|
type Output<M>;
|
||||||
|
|
||||||
|
/// Traverse through the type of a declared field and do something with it.
|
||||||
|
///
|
||||||
|
/// * `name` - The cosmetic name of the LLVM field. Used for debugging.
|
||||||
|
/// * `model` - The [`Model`] representing the LLVM type of this field.
|
||||||
|
fn add<M: Model<'ctx>>(&mut self, name: &'static str, model: M) -> Self::Output<M>;
|
||||||
|
|
||||||
|
/// Like [`FieldTraversal::add`] but [`Model`] is automatically inferred from its [`Default`] trait.
|
||||||
|
fn add_auto<M: Model<'ctx> + Default>(&mut self, name: &'static str) -> Self::Output<M> {
|
||||||
|
self.add(name, M::default())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Descriptor of an LLVM struct field.
|
||||||
|
#[derive(Debug, Clone, Copy)]
|
||||||
|
pub struct GepField<M> {
|
||||||
|
/// The GEP index of this field. This is the index to use with `build_gep`.
|
||||||
|
pub gep_index: u32,
|
||||||
|
/// The cosmetic name of this field.
|
||||||
|
pub name: &'static str,
|
||||||
|
/// The [`Model`] of this field's type.
|
||||||
|
pub model: M,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A traversal to calculate the GEP index of fields.
|
||||||
|
pub struct GepFieldTraversal {
|
||||||
|
/// The current GEP index.
|
||||||
|
gep_index_counter: u32,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx> FieldTraversal<'ctx> for GepFieldTraversal {
|
||||||
|
type Output<M> = GepField<M>;
|
||||||
|
|
||||||
|
fn add<M: Model<'ctx>>(&mut self, name: &'static str, model: M) -> Self::Output<M> {
|
||||||
|
let gep_index = self.gep_index_counter;
|
||||||
|
self.gep_index_counter += 1;
|
||||||
|
Self::Output { gep_index, name, model }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A traversal to collect the field types of a struct.
|
||||||
|
///
|
||||||
|
/// This is used to collect field types and construct the LLVM struct type with [`Context::struct_type`].
|
||||||
|
struct TypeFieldTraversal<'ctx, 'a, G: CodeGenerator + ?Sized> {
|
||||||
|
generator: &'a G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
/// The collected field types so far in exact order.
|
||||||
|
field_types: Vec<BasicTypeEnum<'ctx>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx, 'a, G: CodeGenerator + ?Sized> FieldTraversal<'ctx> for TypeFieldTraversal<'ctx, 'a, G> {
|
||||||
|
type Output<M> = (); // Checking types return nothing.
|
||||||
|
|
||||||
|
fn add<M: Model<'ctx>>(&mut self, _name: &'static str, model: M) -> Self::Output<M> {
|
||||||
|
let t = model.llvm_type(self.generator, self.ctx).as_basic_type_enum();
|
||||||
|
self.field_types.push(t);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A traversal to check the types of fields.
|
||||||
|
struct CheckTypeFieldTraversal<'ctx, 'a, G: CodeGenerator + ?Sized> {
|
||||||
|
generator: &'a mut G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
/// The current GEP index, so we can tell the index of the field we are checking
|
||||||
|
/// and report the GEP index.
|
||||||
|
gep_index_counter: u32,
|
||||||
|
/// The [`StructType`] to check.
|
||||||
|
scrutinee: StructType<'ctx>,
|
||||||
|
/// The list of collected errors so far.
|
||||||
|
errors: Vec<ModelError>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx, 'a, G: CodeGenerator + ?Sized> FieldTraversal<'ctx>
|
||||||
|
for CheckTypeFieldTraversal<'ctx, 'a, G>
|
||||||
|
{
|
||||||
|
type Output<M> = (); // Checking types return nothing.
|
||||||
|
|
||||||
|
fn add<M: Model<'ctx>>(&mut self, name: &'static str, model: M) -> Self::Output<M> {
|
||||||
|
let gep_index = self.gep_index_counter;
|
||||||
|
self.gep_index_counter += 1;
|
||||||
|
|
||||||
|
if let Some(t) = self.scrutinee.get_field_type_at_index(gep_index) {
|
||||||
|
if let Err(err) = model.check_type(self.generator, self.ctx, t) {
|
||||||
|
self.errors
|
||||||
|
.push(err.under_context(format!("field #{gep_index} '{name}'").as_str()));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// Otherwise, it will be caught by Struct's `check_type`.
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A trait for Rust structs identifying LLVM structures.
|
||||||
|
///
|
||||||
|
/// ### Example
|
||||||
|
///
|
||||||
|
/// Suppose you want to define this structure:
|
||||||
|
/// ```c
|
||||||
|
/// template <typename T>
|
||||||
|
/// struct ContiguousNDArray {
|
||||||
|
/// size_t ndims;
|
||||||
|
/// size_t* shape;
|
||||||
|
/// T* data;
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
///
|
||||||
|
/// This is how it should be done:
|
||||||
|
/// ```ignore
|
||||||
|
/// pub struct ContiguousNDArrayFields<'ctx, F: FieldTraversal<'ctx>, Item: Model<'ctx>> {
|
||||||
|
/// pub ndims: F::Out<Int<SizeT>>,
|
||||||
|
/// pub shape: F::Out<Ptr<Int<SizeT>>>,
|
||||||
|
/// pub data: F::Out<Ptr<Item>>,
|
||||||
|
/// }
|
||||||
|
///
|
||||||
|
/// /// An ndarray without strides and non-opaque `data` field in NAC3.
|
||||||
|
/// #[derive(Debug, Clone, Copy)]
|
||||||
|
/// pub struct ContiguousNDArray<M> {
|
||||||
|
/// /// [`Model`] of the items.
|
||||||
|
/// pub item: M,
|
||||||
|
/// }
|
||||||
|
///
|
||||||
|
/// impl<'ctx, Item: Model<'ctx>> StructKind<'ctx> for ContiguousNDArray<Item> {
|
||||||
|
/// type Fields<F: FieldTraversal<'ctx>> = ContiguousNDArrayFields<'ctx, F, Item>;
|
||||||
|
///
|
||||||
|
/// fn traverse_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F> {
|
||||||
|
/// // The order of `traversal.add*` is important
|
||||||
|
/// Self::Fields {
|
||||||
|
/// ndims: traversal.add_auto("ndims"),
|
||||||
|
/// shape: traversal.add_auto("shape"),
|
||||||
|
/// data: traversal.add("data", Ptr(self.item)),
|
||||||
|
/// }
|
||||||
|
/// }
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
///
|
||||||
|
/// The [`FieldTraversal`] here is a mechanism to allow the fields of `ContiguousNDArrayFields` to be
|
||||||
|
/// traversed to do useful work such as:
|
||||||
|
///
|
||||||
|
/// - To create the [`StructType`] of `ContiguousNDArray` by collecting [`BasicType`]s of the fields.
|
||||||
|
/// - To enable the `.gep(ctx, |f| f.ndims).store(ctx, ...)` syntax.
|
||||||
|
///
|
||||||
|
/// Suppose now that you have defined `ContiguousNDArray` and you want to allocate a `ContiguousNDArray`
|
||||||
|
/// with dtype `float64` in LLVM, this is how you do it:
|
||||||
|
/// ```ignore
|
||||||
|
/// type F64NDArray = Struct<ContiguousNDArray<Float<Float64>>>; // Type alias for leaner documentation
|
||||||
|
/// let model: F64NDArray = Struct(ContigousNDArray { item: Float(Float64) });
|
||||||
|
/// let ndarray: Instance<'ctx, Ptr<F64NDArray>> = model.alloca(generator, ctx);
|
||||||
|
/// ```
|
||||||
|
///
|
||||||
|
/// ...and here is how you may manipulate/access `ndarray`:
|
||||||
|
///
|
||||||
|
/// (NOTE: some arguments have been omitted)
|
||||||
|
///
|
||||||
|
/// ```ignore
|
||||||
|
/// // Get `&ndarray->data`
|
||||||
|
/// ndarray.gep(|f| f.data); // type: Instance<'ctx, Ptr<Float<Float64>>>
|
||||||
|
///
|
||||||
|
/// // Get `ndarray->ndims`
|
||||||
|
/// ndarray.get(|f| f.ndims); // type: Instance<'ctx, Int<SizeT>>
|
||||||
|
///
|
||||||
|
/// // Get `&ndarray->ndims`
|
||||||
|
/// ndarray.gep(|f| f.ndims); // type: Instance<'ctx, Ptr<Int<SizeT>>>
|
||||||
|
///
|
||||||
|
/// // Get `ndarray->shape[0]`
|
||||||
|
/// ndarray.get(|f| f.shape).get_index_const(0); // Instance<'ctx, Int<SizeT>>
|
||||||
|
///
|
||||||
|
/// // Get `&ndarray->shape[2]`
|
||||||
|
/// ndarray.get(|f| f.shape).offset_const(2); // Instance<'ctx, Ptr<Int<SizeT>>>
|
||||||
|
///
|
||||||
|
/// // Do `ndarray->ndims = 3;`
|
||||||
|
/// let num_3 = Int(SizeT).const_int(3);
|
||||||
|
/// ndarray.set(|f| f.ndims, num_3);
|
||||||
|
/// ```
|
||||||
|
pub trait StructKind<'ctx>: fmt::Debug + Clone + Copy {
|
||||||
|
/// The associated fields of this struct.
|
||||||
|
type Fields<F: FieldTraversal<'ctx>>;
|
||||||
|
|
||||||
|
/// Traverse through all fields of this [`StructKind`].
|
||||||
|
///
|
||||||
|
/// Only used internally in this module for implementing other components.
|
||||||
|
fn iter_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F>;
|
||||||
|
|
||||||
|
/// Get a convenience structure to get a struct field's GEP index through its corresponding Rust field.
|
||||||
|
///
|
||||||
|
/// Only used internally in this module for implementing other components.
|
||||||
|
fn fields(&self) -> Self::Fields<GepFieldTraversal> {
|
||||||
|
self.iter_fields(&mut GepFieldTraversal { gep_index_counter: 0 })
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the LLVM [`StructType`] of this [`StructKind`].
|
||||||
|
fn get_struct_type<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
) -> StructType<'ctx> {
|
||||||
|
let mut traversal = TypeFieldTraversal { generator, ctx, field_types: Vec::new() };
|
||||||
|
self.iter_fields(&mut traversal);
|
||||||
|
|
||||||
|
ctx.struct_type(&traversal.field_types, false)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A model for LLVM struct.
|
||||||
|
///
|
||||||
|
/// `S` should be of a [`StructKind`].
|
||||||
|
#[derive(Debug, Clone, Copy, Default)]
|
||||||
|
pub struct Struct<S>(pub S);
|
||||||
|
|
||||||
|
impl<'ctx, S: StructKind<'ctx>> Struct<S> {
|
||||||
|
/// Create a constant struct value from its fields.
|
||||||
|
///
|
||||||
|
/// This function also validates `fields` and panic when there is something wrong.
|
||||||
|
pub fn const_struct<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
fields: &[BasicValueEnum<'ctx>],
|
||||||
|
) -> Instance<'ctx, Self> {
|
||||||
|
// NOTE: There *could* have been a functor `F<M> = Instance<'ctx, M>` for `S::Fields<F>`
|
||||||
|
// to create a more user-friendly interface, but Rust's type system is not sophisticated enough
|
||||||
|
// and if you try doing that Rust would force you put lifetimes everywhere.
|
||||||
|
let val = ctx.const_struct(fields, false);
|
||||||
|
self.check_value(generator, ctx, val).unwrap()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx, S: StructKind<'ctx>> Model<'ctx> for Struct<S> {
|
||||||
|
type Value = StructValue<'ctx>;
|
||||||
|
type Type = StructType<'ctx>;
|
||||||
|
|
||||||
|
fn llvm_type<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
) -> Self::Type {
|
||||||
|
self.0.get_struct_type(generator, ctx)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn check_type<T: BasicType<'ctx>, G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
ty: T,
|
||||||
|
) -> Result<(), ModelError> {
|
||||||
|
let ty = ty.as_basic_type_enum();
|
||||||
|
let Ok(ty) = StructType::try_from(ty) else {
|
||||||
|
return Err(ModelError(format!("Expecting StructType, but got {ty:?}")));
|
||||||
|
};
|
||||||
|
|
||||||
|
// Check each field individually.
|
||||||
|
let mut traversal = CheckTypeFieldTraversal {
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
gep_index_counter: 0,
|
||||||
|
errors: Vec::new(),
|
||||||
|
scrutinee: ty,
|
||||||
|
};
|
||||||
|
self.0.iter_fields(&mut traversal);
|
||||||
|
|
||||||
|
// Check the number of fields.
|
||||||
|
let exp_num_fields = traversal.gep_index_counter;
|
||||||
|
let got_num_fields = u32::try_from(ty.get_field_types().len()).unwrap();
|
||||||
|
if exp_num_fields != got_num_fields {
|
||||||
|
return Err(ModelError(format!(
|
||||||
|
"Expecting StructType with {exp_num_fields} field(s), but got {got_num_fields}"
|
||||||
|
)));
|
||||||
|
}
|
||||||
|
|
||||||
|
if !traversal.errors.is_empty() {
|
||||||
|
// Currently, only the first error is reported.
|
||||||
|
return Err(traversal.errors[0].clone());
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx, S: StructKind<'ctx>> Instance<'ctx, Struct<S>> {
|
||||||
|
/// Get a field with [`StructValue::get_field_at_index`].
|
||||||
|
pub fn get_field<G: CodeGenerator + ?Sized, M, GetField>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
get_field: GetField,
|
||||||
|
) -> Instance<'ctx, M>
|
||||||
|
where
|
||||||
|
M: Model<'ctx>,
|
||||||
|
GetField: FnOnce(S::Fields<GepFieldTraversal>) -> GepField<M>,
|
||||||
|
{
|
||||||
|
let field = get_field(self.model.0.fields());
|
||||||
|
let val = self.value.get_field_at_index(field.gep_index).unwrap();
|
||||||
|
field.model.check_value(generator, ctx, val).unwrap()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx, S: StructKind<'ctx>> Instance<'ctx, Ptr<Struct<S>>> {
|
||||||
|
/// Get a pointer to a field with [`Builder::build_in_bounds_gep`].
|
||||||
|
pub fn gep<M, GetField>(
|
||||||
|
&self,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
get_field: GetField,
|
||||||
|
) -> Instance<'ctx, Ptr<M>>
|
||||||
|
where
|
||||||
|
M: Model<'ctx>,
|
||||||
|
GetField: FnOnce(S::Fields<GepFieldTraversal>) -> GepField<M>,
|
||||||
|
{
|
||||||
|
let field = get_field(self.model.0 .0.fields());
|
||||||
|
let llvm_i32 = ctx.ctx.i32_type();
|
||||||
|
|
||||||
|
let ptr = unsafe {
|
||||||
|
ctx.builder
|
||||||
|
.build_in_bounds_gep(
|
||||||
|
self.value,
|
||||||
|
&[llvm_i32.const_zero(), llvm_i32.const_int(u64::from(field.gep_index), false)],
|
||||||
|
field.name,
|
||||||
|
)
|
||||||
|
.unwrap()
|
||||||
|
};
|
||||||
|
|
||||||
|
unsafe { Ptr(field.model).believe_value(ptr) }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convenience function equivalent to `.gep(...).load(...)`.
|
||||||
|
pub fn get<M, GetField, G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
get_field: GetField,
|
||||||
|
) -> Instance<'ctx, M>
|
||||||
|
where
|
||||||
|
M: Model<'ctx>,
|
||||||
|
GetField: FnOnce(S::Fields<GepFieldTraversal>) -> GepField<M>,
|
||||||
|
{
|
||||||
|
self.gep(ctx, get_field).load(generator, ctx)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convenience function equivalent to `.gep(...).store(...)`.
|
||||||
|
pub fn set<M, GetField>(
|
||||||
|
&self,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
get_field: GetField,
|
||||||
|
value: Instance<'ctx, M>,
|
||||||
|
) where
|
||||||
|
M: Model<'ctx>,
|
||||||
|
GetField: FnOnce(S::Fields<GepFieldTraversal>) -> GepField<M>,
|
||||||
|
{
|
||||||
|
self.gep(ctx, get_field).store(ctx, value);
|
||||||
|
}
|
||||||
|
}
|
|
@ -0,0 +1,42 @@
|
||||||
|
use crate::codegen::{
|
||||||
|
stmt::{gen_for_callback_incrementing, BreakContinueHooks},
|
||||||
|
CodeGenContext, CodeGenerator,
|
||||||
|
};
|
||||||
|
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
/// Like [`gen_for_callback_incrementing`] with [`Model`] abstractions.
|
||||||
|
///
|
||||||
|
/// `stop` is not included.
|
||||||
|
pub fn gen_for_model<'ctx, 'a, G, F, N>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, 'a>,
|
||||||
|
start: Instance<'ctx, Int<N>>,
|
||||||
|
stop: Instance<'ctx, Int<N>>,
|
||||||
|
step: Instance<'ctx, Int<N>>,
|
||||||
|
body: F,
|
||||||
|
) -> Result<(), String>
|
||||||
|
where
|
||||||
|
G: CodeGenerator + ?Sized,
|
||||||
|
F: FnOnce(
|
||||||
|
&mut G,
|
||||||
|
&mut CodeGenContext<'ctx, 'a>,
|
||||||
|
BreakContinueHooks<'ctx>,
|
||||||
|
Instance<'ctx, Int<N>>,
|
||||||
|
) -> Result<(), String>,
|
||||||
|
N: IntKind<'ctx> + Default,
|
||||||
|
{
|
||||||
|
let int_model = Int(N::default());
|
||||||
|
gen_for_callback_incrementing(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
None,
|
||||||
|
start.value,
|
||||||
|
(stop.value, false),
|
||||||
|
|g, ctx, hooks, i| {
|
||||||
|
let i = unsafe { int_model.believe_value(i) };
|
||||||
|
body(g, ctx, hooks, i)
|
||||||
|
},
|
||||||
|
step.value,
|
||||||
|
)
|
||||||
|
}
|
|
@ -13,18 +13,23 @@ use crate::{
|
||||||
},
|
},
|
||||||
llvm_intrinsics::{self, call_memcpy_generic},
|
llvm_intrinsics::{self, call_memcpy_generic},
|
||||||
macros::codegen_unreachable,
|
macros::codegen_unreachable,
|
||||||
|
model::*,
|
||||||
|
object::{
|
||||||
|
any::AnyObject,
|
||||||
|
ndarray::{shape_util::parse_numpy_int_sequence, NDArrayObject},
|
||||||
|
},
|
||||||
stmt::{gen_for_callback_incrementing, gen_for_range_callback, gen_if_else_expr_callback},
|
stmt::{gen_for_callback_incrementing, gen_for_range_callback, gen_if_else_expr_callback},
|
||||||
CodeGenContext, CodeGenerator,
|
CodeGenContext, CodeGenerator,
|
||||||
},
|
},
|
||||||
symbol_resolver::ValueEnum,
|
symbol_resolver::ValueEnum,
|
||||||
toplevel::{
|
toplevel::{
|
||||||
helper::PrimDef,
|
helper::extract_ndims,
|
||||||
numpy::{make_ndarray_ty, unpack_ndarray_var_tys},
|
numpy::{make_ndarray_ty, unpack_ndarray_var_tys},
|
||||||
DefinitionId,
|
DefinitionId,
|
||||||
},
|
},
|
||||||
typecheck::{
|
typecheck::{
|
||||||
magic_methods::Binop,
|
magic_methods::Binop,
|
||||||
typedef::{FunSignature, Type, TypeEnum},
|
typedef::{FunSignature, Type},
|
||||||
},
|
},
|
||||||
};
|
};
|
||||||
use inkwell::{
|
use inkwell::{
|
||||||
|
@ -1743,8 +1748,13 @@ pub fn gen_ndarray_empty<'ctx>(
|
||||||
let shape_ty = fun.0.args[0].ty;
|
let shape_ty = fun.0.args[0].ty;
|
||||||
let shape_arg = args[0].1.clone().to_basic_value_enum(context, generator, shape_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, shape_arg)
|
let (dtype, ndims) = unpack_ndarray_var_tys(&mut context.unifier, fun.0.ret);
|
||||||
.map(NDArrayValue::into)
|
let ndims = extract_ndims(&context.unifier, ndims);
|
||||||
|
|
||||||
|
let shape = AnyObject { value: shape_arg, ty: shape_ty };
|
||||||
|
let (_, shape) = parse_numpy_int_sequence(generator, context, shape);
|
||||||
|
let ndarray = NDArrayObject::make_np_empty(generator, context, dtype, ndims, shape);
|
||||||
|
Ok(ndarray.instance.value)
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Generates LLVM IR for `ndarray.zeros`.
|
/// Generates LLVM IR for `ndarray.zeros`.
|
||||||
|
@ -1761,8 +1771,13 @@ pub fn gen_ndarray_zeros<'ctx>(
|
||||||
let shape_ty = fun.0.args[0].ty;
|
let shape_ty = fun.0.args[0].ty;
|
||||||
let shape_arg = args[0].1.clone().to_basic_value_enum(context, generator, shape_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, shape_arg)
|
let (dtype, ndims) = unpack_ndarray_var_tys(&mut context.unifier, fun.0.ret);
|
||||||
.map(NDArrayValue::into)
|
let ndims = extract_ndims(&context.unifier, ndims);
|
||||||
|
|
||||||
|
let shape = AnyObject { value: shape_arg, ty: shape_ty };
|
||||||
|
let (_, shape) = parse_numpy_int_sequence(generator, context, shape);
|
||||||
|
let ndarray = NDArrayObject::make_np_zeros(generator, context, dtype, ndims, shape);
|
||||||
|
Ok(ndarray.instance.value)
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Generates LLVM IR for `ndarray.ones`.
|
/// Generates LLVM IR for `ndarray.ones`.
|
||||||
|
@ -1779,8 +1794,13 @@ pub fn gen_ndarray_ones<'ctx>(
|
||||||
let shape_ty = fun.0.args[0].ty;
|
let shape_ty = fun.0.args[0].ty;
|
||||||
let shape_arg = args[0].1.clone().to_basic_value_enum(context, generator, shape_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, shape_arg)
|
let (dtype, ndims) = unpack_ndarray_var_tys(&mut context.unifier, fun.0.ret);
|
||||||
.map(NDArrayValue::into)
|
let ndims = extract_ndims(&context.unifier, ndims);
|
||||||
|
|
||||||
|
let shape = AnyObject { value: shape_arg, ty: shape_ty };
|
||||||
|
let (_, shape) = parse_numpy_int_sequence(generator, context, shape);
|
||||||
|
let ndarray = NDArrayObject::make_np_ones(generator, context, dtype, ndims, shape);
|
||||||
|
Ok(ndarray.instance.value)
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Generates LLVM IR for `ndarray.full`.
|
/// Generates LLVM IR for `ndarray.full`.
|
||||||
|
@ -1800,8 +1820,14 @@ pub fn gen_ndarray_full<'ctx>(
|
||||||
let fill_value_arg =
|
let fill_value_arg =
|
||||||
args[1].1.clone().to_basic_value_enum(context, generator, fill_value_ty)?;
|
args[1].1.clone().to_basic_value_enum(context, generator, fill_value_ty)?;
|
||||||
|
|
||||||
call_ndarray_full_impl(generator, context, fill_value_ty, shape_arg, fill_value_arg)
|
let (dtype, ndims) = unpack_ndarray_var_tys(&mut context.unifier, fun.0.ret);
|
||||||
.map(NDArrayValue::into)
|
let ndims = extract_ndims(&context.unifier, ndims);
|
||||||
|
|
||||||
|
let shape = AnyObject { value: shape_arg, ty: shape_ty };
|
||||||
|
let (_, shape) = parse_numpy_int_sequence(generator, context, shape);
|
||||||
|
let ndarray =
|
||||||
|
NDArrayObject::make_np_full(generator, context, dtype, ndims, shape, fill_value_arg);
|
||||||
|
Ok(ndarray.instance.value)
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn gen_ndarray_array<'ctx>(
|
pub fn gen_ndarray_array<'ctx>(
|
||||||
|
@ -1815,26 +1841,6 @@ pub fn gen_ndarray_array<'ctx>(
|
||||||
assert!(matches!(args.len(), 1..=3));
|
assert!(matches!(args.len(), 1..=3));
|
||||||
|
|
||||||
let obj_ty = fun.0.args[0].ty;
|
let obj_ty = fun.0.args[0].ty;
|
||||||
let obj_elem_ty = match &*context.unifier.get_ty(obj_ty) {
|
|
||||||
TypeEnum::TObj { obj_id, .. } if *obj_id == PrimDef::NDArray.id() => {
|
|
||||||
unpack_ndarray_var_tys(&mut context.unifier, obj_ty).0
|
|
||||||
}
|
|
||||||
|
|
||||||
TypeEnum::TObj { obj_id, params, .. } if *obj_id == PrimDef::List.id() => {
|
|
||||||
let mut ty = *params.iter().next().unwrap().1;
|
|
||||||
while let TypeEnum::TObj { obj_id, params, .. } = &*context.unifier.get_ty_immutable(ty)
|
|
||||||
{
|
|
||||||
if *obj_id != PrimDef::List.id() {
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
ty = *params.iter().next().unwrap().1;
|
|
||||||
}
|
|
||||||
ty
|
|
||||||
}
|
|
||||||
|
|
||||||
_ => obj_ty,
|
|
||||||
};
|
|
||||||
let obj_arg = args[0].1.clone().to_basic_value_enum(context, generator, obj_ty)?;
|
let obj_arg = args[0].1.clone().to_basic_value_enum(context, generator, obj_ty)?;
|
||||||
|
|
||||||
let copy_arg = if let Some(arg) =
|
let copy_arg = if let Some(arg) =
|
||||||
|
@ -1850,28 +1856,18 @@ pub fn gen_ndarray_array<'ctx>(
|
||||||
)
|
)
|
||||||
};
|
};
|
||||||
|
|
||||||
let ndmin_arg = if let Some(arg) =
|
// The ndmin argument is ignored. We can simply force the ndarray's number of dimensions to be
|
||||||
args.iter().find(|arg| arg.0.is_some_and(|name| name == fun.0.args[2].name))
|
// the `ndims` of the function return type.
|
||||||
{
|
let (_, ndims) = unpack_ndarray_var_tys(&mut context.unifier, fun.0.ret);
|
||||||
let ndmin_ty = fun.0.args[2].ty;
|
let ndims = extract_ndims(&context.unifier, ndims);
|
||||||
arg.1.clone().to_basic_value_enum(context, generator, ndmin_ty)?
|
|
||||||
} else {
|
|
||||||
context.gen_symbol_val(
|
|
||||||
generator,
|
|
||||||
fun.0.args[2].default_value.as_ref().unwrap(),
|
|
||||||
fun.0.args[2].ty,
|
|
||||||
)
|
|
||||||
};
|
|
||||||
|
|
||||||
call_ndarray_array_impl(
|
let object = AnyObject { value: obj_arg, ty: obj_ty };
|
||||||
generator,
|
// NAC3 booleans are i8.
|
||||||
context,
|
let copy = Int(Bool).truncate(generator, context, copy_arg.into_int_value());
|
||||||
obj_elem_ty,
|
let ndarray = NDArrayObject::make_np_array(generator, context, object, copy)
|
||||||
obj_arg,
|
.atleast_nd(generator, context, ndims);
|
||||||
copy_arg.into_int_value(),
|
|
||||||
ndmin_arg.into_int_value(),
|
Ok(ndarray.instance.value)
|
||||||
)
|
|
||||||
.map(NDArrayValue::into)
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Generates LLVM IR for `ndarray.eye`.
|
/// Generates LLVM IR for `ndarray.eye`.
|
||||||
|
|
|
@ -0,0 +1,12 @@
|
||||||
|
use inkwell::values::BasicValueEnum;
|
||||||
|
|
||||||
|
use crate::typecheck::typedef::Type;
|
||||||
|
|
||||||
|
/// A NAC3 LLVM Python object of any type.
|
||||||
|
#[derive(Debug, Clone, Copy)]
|
||||||
|
pub struct AnyObject<'ctx> {
|
||||||
|
/// Typechecker type of the object.
|
||||||
|
pub ty: Type,
|
||||||
|
/// LLVM value of the object.
|
||||||
|
pub value: BasicValueEnum<'ctx>,
|
||||||
|
}
|
|
@ -0,0 +1,87 @@
|
||||||
|
use crate::{
|
||||||
|
codegen::{model::*, CodeGenContext, CodeGenerator},
|
||||||
|
typecheck::typedef::{iter_type_vars, Type, TypeEnum},
|
||||||
|
};
|
||||||
|
|
||||||
|
use super::any::AnyObject;
|
||||||
|
|
||||||
|
/// Fields of [`List`]
|
||||||
|
pub struct ListFields<'ctx, F: FieldTraversal<'ctx>, Item: Model<'ctx>> {
|
||||||
|
/// Array pointer to content
|
||||||
|
pub items: F::Output<Ptr<Item>>,
|
||||||
|
/// Number of items in the array
|
||||||
|
pub len: F::Output<Int<SizeT>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A list in NAC3.
|
||||||
|
#[derive(Debug, Clone, Copy, Default)]
|
||||||
|
pub struct List<Item> {
|
||||||
|
/// Model of the list items
|
||||||
|
pub item: Item,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx, Item: Model<'ctx>> StructKind<'ctx> for List<Item> {
|
||||||
|
type Fields<F: FieldTraversal<'ctx>> = ListFields<'ctx, F, Item>;
|
||||||
|
|
||||||
|
fn iter_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F> {
|
||||||
|
Self::Fields {
|
||||||
|
items: traversal.add("items", Ptr(self.item)),
|
||||||
|
len: traversal.add_auto("len"),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx, Item: Model<'ctx>> Instance<'ctx, Ptr<Struct<List<Item>>>> {
|
||||||
|
/// Cast the items pointer to `uint8_t*`.
|
||||||
|
pub fn with_pi8_items<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
) -> Instance<'ctx, Ptr<Struct<List<Int<Byte>>>>> {
|
||||||
|
self.pointer_cast(generator, ctx, Struct(List { item: Int(Byte) }))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A NAC3 Python List object.
|
||||||
|
#[derive(Debug, Clone, Copy)]
|
||||||
|
pub struct ListObject<'ctx> {
|
||||||
|
/// Typechecker type of the list items
|
||||||
|
pub item_type: Type,
|
||||||
|
pub instance: Instance<'ctx, Ptr<Struct<List<Any<'ctx>>>>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx> ListObject<'ctx> {
|
||||||
|
/// Create a [`ListObject`] from an LLVM value and its typechecker [`Type`].
|
||||||
|
pub fn from_object<G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
object: AnyObject<'ctx>,
|
||||||
|
) -> Self {
|
||||||
|
// Check typechecker type and extract `item_type`
|
||||||
|
let item_type = match &*ctx.unifier.get_ty(object.ty) {
|
||||||
|
TypeEnum::TObj { obj_id, params, .. }
|
||||||
|
if *obj_id == ctx.primitives.list.obj_id(&ctx.unifier).unwrap() =>
|
||||||
|
{
|
||||||
|
iter_type_vars(params).next().unwrap().ty // Extract `item_type`
|
||||||
|
}
|
||||||
|
_ => {
|
||||||
|
panic!("Expecting type to be a list, but got {}", ctx.unifier.stringify(object.ty))
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
let plist = Ptr(Struct(List { item: Any(ctx.get_llvm_type(generator, item_type)) }));
|
||||||
|
|
||||||
|
// Create object
|
||||||
|
let value = plist.check_value(generator, ctx.ctx, object.value).unwrap();
|
||||||
|
ListObject { item_type, instance: value }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the `len()` of this list.
|
||||||
|
pub fn len<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
) -> Instance<'ctx, Int<SizeT>> {
|
||||||
|
self.instance.get(generator, ctx, |f| f.len)
|
||||||
|
}
|
||||||
|
}
|
|
@ -0,0 +1,5 @@
|
||||||
|
pub mod any;
|
||||||
|
pub mod list;
|
||||||
|
pub mod ndarray;
|
||||||
|
pub mod tuple;
|
||||||
|
pub mod utils;
|
|
@ -0,0 +1,184 @@
|
||||||
|
use super::NDArrayObject;
|
||||||
|
use crate::{
|
||||||
|
codegen::{
|
||||||
|
irrt::{
|
||||||
|
call_nac3_ndarray_array_set_and_validate_list_shape,
|
||||||
|
call_nac3_ndarray_array_write_list_to_array,
|
||||||
|
},
|
||||||
|
model::*,
|
||||||
|
object::{any::AnyObject, list::ListObject},
|
||||||
|
stmt::gen_if_else_expr_callback,
|
||||||
|
CodeGenContext, CodeGenerator,
|
||||||
|
},
|
||||||
|
toplevel::helper::{arraylike_flatten_element_type, arraylike_get_ndims},
|
||||||
|
typecheck::typedef::{Type, TypeEnum},
|
||||||
|
};
|
||||||
|
|
||||||
|
/// Get the expected `dtype` and `ndims` of the ndarray returned by `np_array(list)`.
|
||||||
|
fn get_list_object_dtype_and_ndims<'ctx>(
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
list: ListObject<'ctx>,
|
||||||
|
) -> (Type, u64) {
|
||||||
|
let dtype = arraylike_flatten_element_type(&mut ctx.unifier, list.item_type);
|
||||||
|
|
||||||
|
let ndims = arraylike_get_ndims(&mut ctx.unifier, list.item_type);
|
||||||
|
let ndims = ndims + 1; // To count `list` itself.
|
||||||
|
|
||||||
|
(dtype, ndims)
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx> NDArrayObject<'ctx> {
|
||||||
|
/// Implementation of `np_array(<list>, copy=True)`
|
||||||
|
fn make_np_array_list_copy_true_impl<G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
list: ListObject<'ctx>,
|
||||||
|
) -> Self {
|
||||||
|
let (dtype, ndims_int) = get_list_object_dtype_and_ndims(ctx, list);
|
||||||
|
let list_value = list.instance.with_pi8_items(generator, ctx);
|
||||||
|
|
||||||
|
// Validate `list` has a consistent shape.
|
||||||
|
// Raise an exception if `list` is something abnormal like `[[1, 2], [3]]`.
|
||||||
|
// If `list` has a consistent shape, deduce the shape and write it to `shape`.
|
||||||
|
let ndims = Int(SizeT).const_int(generator, ctx.ctx, ndims_int, false);
|
||||||
|
let shape = Int(SizeT).array_alloca(generator, ctx, ndims.value);
|
||||||
|
call_nac3_ndarray_array_set_and_validate_list_shape(
|
||||||
|
generator, ctx, list_value, ndims, shape,
|
||||||
|
);
|
||||||
|
|
||||||
|
let ndarray = NDArrayObject::alloca(generator, ctx, dtype, ndims_int);
|
||||||
|
ndarray.copy_shape_from_array(generator, ctx, shape);
|
||||||
|
ndarray.create_data(generator, ctx);
|
||||||
|
|
||||||
|
// Copy all contents from the list.
|
||||||
|
call_nac3_ndarray_array_write_list_to_array(generator, ctx, list_value, ndarray.instance);
|
||||||
|
|
||||||
|
ndarray
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Implementation of `np_array(<list>, copy=None)`
|
||||||
|
fn make_np_array_list_copy_none_impl<G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
list: ListObject<'ctx>,
|
||||||
|
) -> Self {
|
||||||
|
// np_array without copying is only possible `list` is not nested.
|
||||||
|
//
|
||||||
|
// If `list` is `list[T]`, we can create an ndarray with `data` set
|
||||||
|
// to the array pointer of `list`.
|
||||||
|
//
|
||||||
|
// If `list` is `list[list[T]]` or worse, copy.
|
||||||
|
|
||||||
|
let (dtype, ndims) = get_list_object_dtype_and_ndims(ctx, list);
|
||||||
|
if ndims == 1 {
|
||||||
|
// `list` is not nested
|
||||||
|
let ndarray = NDArrayObject::alloca(generator, ctx, dtype, 1);
|
||||||
|
|
||||||
|
// Set data
|
||||||
|
let data = list.instance.get(generator, ctx, |f| f.items).cast_to_pi8(generator, ctx);
|
||||||
|
ndarray.instance.set(ctx, |f| f.data, data);
|
||||||
|
|
||||||
|
// ndarray->shape[0] = list->len;
|
||||||
|
let shape = ndarray.instance.get(generator, ctx, |f| f.shape);
|
||||||
|
let list_len = list.instance.get(generator, ctx, |f| f.len);
|
||||||
|
shape.set_index_const(ctx, 0, list_len);
|
||||||
|
|
||||||
|
// Set strides, the `data` is contiguous
|
||||||
|
ndarray.set_strides_contiguous(generator, ctx);
|
||||||
|
|
||||||
|
ndarray
|
||||||
|
} else {
|
||||||
|
// `list` is nested, copy
|
||||||
|
NDArrayObject::make_np_array_list_copy_true_impl(generator, ctx, list)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Implementation of `np_array(<list>, copy=copy)`
|
||||||
|
fn make_np_array_list_impl<G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
list: ListObject<'ctx>,
|
||||||
|
copy: Instance<'ctx, Int<Bool>>,
|
||||||
|
) -> Self {
|
||||||
|
let (dtype, ndims) = get_list_object_dtype_and_ndims(ctx, list);
|
||||||
|
|
||||||
|
let ndarray = gen_if_else_expr_callback(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
|_generator, _ctx| Ok(copy.value),
|
||||||
|
|generator, ctx| {
|
||||||
|
let ndarray =
|
||||||
|
NDArrayObject::make_np_array_list_copy_true_impl(generator, ctx, list);
|
||||||
|
Ok(Some(ndarray.instance.value))
|
||||||
|
},
|
||||||
|
|generator, ctx| {
|
||||||
|
let ndarray =
|
||||||
|
NDArrayObject::make_np_array_list_copy_none_impl(generator, ctx, list);
|
||||||
|
Ok(Some(ndarray.instance.value))
|
||||||
|
},
|
||||||
|
)
|
||||||
|
.unwrap()
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
NDArrayObject::from_value_and_unpacked_types(generator, ctx, ndarray, dtype, ndims)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Implementation of `np_array(<ndarray>, copy=copy)`.
|
||||||
|
pub fn make_np_array_ndarray_impl<G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
ndarray: NDArrayObject<'ctx>,
|
||||||
|
copy: Instance<'ctx, Int<Bool>>,
|
||||||
|
) -> Self {
|
||||||
|
let ndarray_val = gen_if_else_expr_callback(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
|_generator, _ctx| Ok(copy.value),
|
||||||
|
|generator, ctx| {
|
||||||
|
let ndarray = ndarray.make_copy(generator, ctx); // Force copy
|
||||||
|
Ok(Some(ndarray.instance.value))
|
||||||
|
},
|
||||||
|
|_generator, _ctx| {
|
||||||
|
// No need to copy. Return `ndarray` itself.
|
||||||
|
Ok(Some(ndarray.instance.value))
|
||||||
|
},
|
||||||
|
)
|
||||||
|
.unwrap()
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
NDArrayObject::from_value_and_unpacked_types(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
ndarray_val,
|
||||||
|
ndarray.dtype,
|
||||||
|
ndarray.ndims,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Create a new ndarray like `np.array()`.
|
||||||
|
///
|
||||||
|
/// NOTE: The `ndmin` argument is not here. You may want to
|
||||||
|
/// do [`NDArrayObject::atleast_nd`] to achieve that.
|
||||||
|
pub fn make_np_array<G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
object: AnyObject<'ctx>,
|
||||||
|
copy: Instance<'ctx, Int<Bool>>,
|
||||||
|
) -> Self {
|
||||||
|
match &*ctx.unifier.get_ty(object.ty) {
|
||||||
|
TypeEnum::TObj { obj_id, .. }
|
||||||
|
if *obj_id == ctx.primitives.list.obj_id(&ctx.unifier).unwrap() =>
|
||||||
|
{
|
||||||
|
let list = ListObject::from_object(generator, ctx, object);
|
||||||
|
NDArrayObject::make_np_array_list_impl(generator, ctx, list, copy)
|
||||||
|
}
|
||||||
|
TypeEnum::TObj { obj_id, .. }
|
||||||
|
if *obj_id == ctx.primitives.ndarray.obj_id(&ctx.unifier).unwrap() =>
|
||||||
|
{
|
||||||
|
let ndarray = NDArrayObject::from_object(generator, ctx, object);
|
||||||
|
NDArrayObject::make_np_array_ndarray_impl(generator, ctx, ndarray, copy)
|
||||||
|
}
|
||||||
|
_ => panic!("Unrecognized object type: {}", ctx.unifier.stringify(object.ty)), // Typechecker ensures this
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
|
@ -0,0 +1,126 @@
|
||||||
|
use inkwell::values::BasicValueEnum;
|
||||||
|
|
||||||
|
use crate::{
|
||||||
|
codegen::{
|
||||||
|
irrt::call_nac3_ndarray_util_assert_shape_no_negative, model::*, CodeGenContext,
|
||||||
|
CodeGenerator,
|
||||||
|
},
|
||||||
|
typecheck::typedef::Type,
|
||||||
|
};
|
||||||
|
|
||||||
|
use super::NDArrayObject;
|
||||||
|
|
||||||
|
/// Get the zero value in `np.zeros()` of a `dtype`.
|
||||||
|
fn ndarray_zero_value<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
dtype: Type,
|
||||||
|
) -> BasicValueEnum<'ctx> {
|
||||||
|
if [ctx.primitives.int32, ctx.primitives.uint32]
|
||||||
|
.iter()
|
||||||
|
.any(|ty| ctx.unifier.unioned(dtype, *ty))
|
||||||
|
{
|
||||||
|
ctx.ctx.i32_type().const_zero().into()
|
||||||
|
} else if [ctx.primitives.int64, ctx.primitives.uint64]
|
||||||
|
.iter()
|
||||||
|
.any(|ty| ctx.unifier.unioned(dtype, *ty))
|
||||||
|
{
|
||||||
|
ctx.ctx.i64_type().const_zero().into()
|
||||||
|
} else if ctx.unifier.unioned(dtype, ctx.primitives.float) {
|
||||||
|
ctx.ctx.f64_type().const_zero().into()
|
||||||
|
} else if ctx.unifier.unioned(dtype, ctx.primitives.bool) {
|
||||||
|
ctx.ctx.bool_type().const_zero().into()
|
||||||
|
} else if ctx.unifier.unioned(dtype, ctx.primitives.str) {
|
||||||
|
ctx.gen_string(generator, "").into()
|
||||||
|
} else {
|
||||||
|
panic!("unrecognized dtype: {}", ctx.unifier.stringify(dtype));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the one value in `np.ones()` of a `dtype`.
|
||||||
|
fn ndarray_one_value<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
dtype: Type,
|
||||||
|
) -> BasicValueEnum<'ctx> {
|
||||||
|
if [ctx.primitives.int32, ctx.primitives.uint32]
|
||||||
|
.iter()
|
||||||
|
.any(|ty| ctx.unifier.unioned(dtype, *ty))
|
||||||
|
{
|
||||||
|
let is_signed = ctx.unifier.unioned(dtype, 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(dtype, *ty))
|
||||||
|
{
|
||||||
|
let is_signed = ctx.unifier.unioned(dtype, ctx.primitives.int64);
|
||||||
|
ctx.ctx.i64_type().const_int(1, is_signed).into()
|
||||||
|
} else if ctx.unifier.unioned(dtype, ctx.primitives.float) {
|
||||||
|
ctx.ctx.f64_type().const_float(1.0).into()
|
||||||
|
} else if ctx.unifier.unioned(dtype, ctx.primitives.bool) {
|
||||||
|
ctx.ctx.bool_type().const_int(1, false).into()
|
||||||
|
} else if ctx.unifier.unioned(dtype, ctx.primitives.str) {
|
||||||
|
ctx.gen_string(generator, "1").into()
|
||||||
|
} else {
|
||||||
|
panic!("unrecognized dtype: {}", ctx.unifier.stringify(dtype));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx> NDArrayObject<'ctx> {
|
||||||
|
/// Create an ndarray like `np.empty`.
|
||||||
|
pub fn make_np_empty<G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
dtype: Type,
|
||||||
|
ndims: u64,
|
||||||
|
shape: Instance<'ctx, Ptr<Int<SizeT>>>,
|
||||||
|
) -> Self {
|
||||||
|
// Validate `shape`
|
||||||
|
let ndims_llvm = Int(SizeT).const_int(generator, ctx.ctx, ndims, false);
|
||||||
|
call_nac3_ndarray_util_assert_shape_no_negative(generator, ctx, ndims_llvm, shape);
|
||||||
|
|
||||||
|
let ndarray = NDArrayObject::alloca(generator, ctx, dtype, ndims);
|
||||||
|
ndarray.copy_shape_from_array(generator, ctx, shape);
|
||||||
|
ndarray.create_data(generator, ctx);
|
||||||
|
|
||||||
|
ndarray
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Create an ndarray like `np.full`.
|
||||||
|
pub fn make_np_full<G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
dtype: Type,
|
||||||
|
ndims: u64,
|
||||||
|
shape: Instance<'ctx, Ptr<Int<SizeT>>>,
|
||||||
|
fill_value: BasicValueEnum<'ctx>,
|
||||||
|
) -> Self {
|
||||||
|
let ndarray = NDArrayObject::make_np_empty(generator, ctx, dtype, ndims, shape);
|
||||||
|
ndarray.fill(generator, ctx, fill_value);
|
||||||
|
ndarray
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Create an ndarray like `np.zero`.
|
||||||
|
pub fn make_np_zeros<G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
dtype: Type,
|
||||||
|
ndims: u64,
|
||||||
|
shape: Instance<'ctx, Ptr<Int<SizeT>>>,
|
||||||
|
) -> Self {
|
||||||
|
let fill_value = ndarray_zero_value(generator, ctx, dtype);
|
||||||
|
NDArrayObject::make_np_full(generator, ctx, dtype, ndims, shape, fill_value)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Create an ndarray like `np.ones`.
|
||||||
|
pub fn make_np_ones<G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
dtype: Type,
|
||||||
|
ndims: u64,
|
||||||
|
shape: Instance<'ctx, Ptr<Int<SizeT>>>,
|
||||||
|
) -> Self {
|
||||||
|
let fill_value = ndarray_one_value(generator, ctx, dtype);
|
||||||
|
NDArrayObject::make_np_full(generator, ctx, dtype, ndims, shape, fill_value)
|
||||||
|
}
|
||||||
|
}
|
|
@ -0,0 +1,227 @@
|
||||||
|
use crate::codegen::{
|
||||||
|
irrt::call_nac3_ndarray_index,
|
||||||
|
model::*,
|
||||||
|
object::utils::slice::{RustSlice, Slice},
|
||||||
|
CodeGenContext, CodeGenerator,
|
||||||
|
};
|
||||||
|
|
||||||
|
use super::NDArrayObject;
|
||||||
|
|
||||||
|
pub type NDIndexType = Byte;
|
||||||
|
|
||||||
|
/// Fields of [`NDIndex`]
|
||||||
|
#[derive(Debug, Clone, Copy)]
|
||||||
|
pub struct NDIndexFields<'ctx, F: FieldTraversal<'ctx>> {
|
||||||
|
pub type_: F::Output<Int<NDIndexType>>,
|
||||||
|
pub data: F::Output<Ptr<Int<Byte>>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// An IRRT representation of an ndarray subscript index.
|
||||||
|
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
|
||||||
|
pub struct NDIndex;
|
||||||
|
|
||||||
|
impl<'ctx> StructKind<'ctx> for NDIndex {
|
||||||
|
type Fields<F: FieldTraversal<'ctx>> = NDIndexFields<'ctx, F>;
|
||||||
|
|
||||||
|
fn iter_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F> {
|
||||||
|
Self::Fields { type_: traversal.add_auto("type"), data: traversal.add_auto("data") }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// A convenience enum representing a [`NDIndex`].
|
||||||
|
#[derive(Debug, Clone)]
|
||||||
|
pub enum RustNDIndex<'ctx> {
|
||||||
|
SingleElement(Instance<'ctx, Int<Int32>>),
|
||||||
|
Slice(RustSlice<'ctx, Int32>),
|
||||||
|
NewAxis,
|
||||||
|
Ellipsis,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx> RustNDIndex<'ctx> {
|
||||||
|
/// Get the value to set `NDIndex::type` for this variant.
|
||||||
|
fn get_type_id(&self) -> u64 {
|
||||||
|
// Defined in IRRT, must be in sync
|
||||||
|
match self {
|
||||||
|
RustNDIndex::SingleElement(_) => 0,
|
||||||
|
RustNDIndex::Slice(_) => 1,
|
||||||
|
RustNDIndex::NewAxis => 2,
|
||||||
|
RustNDIndex::Ellipsis => 3,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Serialize this [`RustNDIndex`] by writing it into an LLVM [`NDIndex`].
|
||||||
|
fn write_to_ndindex<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
dst_ndindex_ptr: Instance<'ctx, Ptr<Struct<NDIndex>>>,
|
||||||
|
) {
|
||||||
|
// Set `dst_ndindex_ptr->type`
|
||||||
|
dst_ndindex_ptr.gep(ctx, |f| f.type_).store(
|
||||||
|
ctx,
|
||||||
|
Int(NDIndexType::default()).const_int(generator, ctx.ctx, self.get_type_id(), false),
|
||||||
|
);
|
||||||
|
|
||||||
|
// Set `dst_ndindex_ptr->data`
|
||||||
|
match self {
|
||||||
|
RustNDIndex::SingleElement(in_index) => {
|
||||||
|
let index_ptr = Int(Int32).alloca(generator, ctx);
|
||||||
|
index_ptr.store(ctx, *in_index);
|
||||||
|
|
||||||
|
dst_ndindex_ptr
|
||||||
|
.gep(ctx, |f| f.data)
|
||||||
|
.store(ctx, index_ptr.pointer_cast(generator, ctx, Int(Byte)));
|
||||||
|
}
|
||||||
|
RustNDIndex::Slice(in_rust_slice) => {
|
||||||
|
let user_slice_ptr = Struct(Slice(Int32)).alloca(generator, ctx);
|
||||||
|
in_rust_slice.write_to_slice(generator, ctx, user_slice_ptr);
|
||||||
|
|
||||||
|
dst_ndindex_ptr
|
||||||
|
.gep(ctx, |f| f.data)
|
||||||
|
.store(ctx, user_slice_ptr.pointer_cast(generator, ctx, Int(Byte)));
|
||||||
|
}
|
||||||
|
RustNDIndex::NewAxis | RustNDIndex::Ellipsis => {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Serialize a list of `RustNDIndex` as a newly allocated LLVM array of `NDIndex`.
|
||||||
|
pub fn make_ndindices<G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
in_ndindices: &[RustNDIndex<'ctx>],
|
||||||
|
) -> (Instance<'ctx, Int<SizeT>>, Instance<'ctx, Ptr<Struct<NDIndex>>>) {
|
||||||
|
let ndindex_model = Struct(NDIndex);
|
||||||
|
|
||||||
|
// Allocate the LLVM ndindices.
|
||||||
|
let num_ndindices =
|
||||||
|
Int(SizeT).const_int(generator, ctx.ctx, in_ndindices.len() as u64, false);
|
||||||
|
let ndindices = ndindex_model.array_alloca(generator, ctx, num_ndindices.value);
|
||||||
|
|
||||||
|
// Initialize all of them.
|
||||||
|
for (i, in_ndindex) in in_ndindices.iter().enumerate() {
|
||||||
|
let pndindex = ndindices.offset_const(ctx, i64::try_from(i).unwrap());
|
||||||
|
in_ndindex.write_to_ndindex(generator, ctx, pndindex);
|
||||||
|
}
|
||||||
|
|
||||||
|
(num_ndindices, ndindices)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx> NDArrayObject<'ctx> {
|
||||||
|
/// Get the expected `ndims` after indexing with `indices`.
|
||||||
|
#[must_use]
|
||||||
|
fn deduce_ndims_after_indexing_with(&self, indices: &[RustNDIndex<'ctx>]) -> u64 {
|
||||||
|
let mut ndims = self.ndims;
|
||||||
|
for index in indices {
|
||||||
|
match index {
|
||||||
|
RustNDIndex::SingleElement(_) => {
|
||||||
|
ndims -= 1; // Single elements decrements ndims
|
||||||
|
}
|
||||||
|
RustNDIndex::NewAxis => {
|
||||||
|
ndims += 1; // `np.newaxis` / `none` adds a new axis
|
||||||
|
}
|
||||||
|
RustNDIndex::Ellipsis | RustNDIndex::Slice(_) => {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ndims
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Index into the ndarray, and return a newly-allocated view on this ndarray.
|
||||||
|
///
|
||||||
|
/// This function behaves like NumPy's ndarray indexing, but if the indices index
|
||||||
|
/// into a single element, an unsized ndarray is returned.
|
||||||
|
#[must_use]
|
||||||
|
pub fn index<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
indices: &[RustNDIndex<'ctx>],
|
||||||
|
) -> Self {
|
||||||
|
let dst_ndims = self.deduce_ndims_after_indexing_with(indices);
|
||||||
|
let dst_ndarray = NDArrayObject::alloca(generator, ctx, self.dtype, dst_ndims);
|
||||||
|
|
||||||
|
let (num_indices, indices) = RustNDIndex::make_ndindices(generator, ctx, indices);
|
||||||
|
call_nac3_ndarray_index(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
num_indices,
|
||||||
|
indices,
|
||||||
|
self.instance,
|
||||||
|
dst_ndarray.instance,
|
||||||
|
);
|
||||||
|
|
||||||
|
dst_ndarray
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub mod util {
|
||||||
|
use itertools::Itertools;
|
||||||
|
use nac3parser::ast::{Expr, ExprKind};
|
||||||
|
|
||||||
|
use crate::{
|
||||||
|
codegen::{model::*, object::utils::slice::util::gen_slice, CodeGenContext, CodeGenerator},
|
||||||
|
typecheck::typedef::Type,
|
||||||
|
};
|
||||||
|
|
||||||
|
use super::RustNDIndex;
|
||||||
|
|
||||||
|
/// Generate LLVM code to transform an ndarray subscript expression to
|
||||||
|
/// its list of [`RustNDIndex`]
|
||||||
|
///
|
||||||
|
/// i.e.,
|
||||||
|
/// ```python
|
||||||
|
/// my_ndarray[::3, 1, :2:]
|
||||||
|
/// ^^^^^^^^^^^ Then these into a three `RustNDIndex`es
|
||||||
|
/// ```
|
||||||
|
pub fn gen_ndarray_subscript_ndindices<'ctx, G: CodeGenerator>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
subscript: &Expr<Option<Type>>,
|
||||||
|
) -> Result<Vec<RustNDIndex<'ctx>>, String> {
|
||||||
|
// TODO: Support https://numpy.org/doc/stable/user/basics.indexing.html#dimensional-indexing-tools
|
||||||
|
|
||||||
|
// Annoying notes about `slice`
|
||||||
|
// - `my_array[5]`
|
||||||
|
// - slice is a `Constant`
|
||||||
|
// - `my_array[:5]`
|
||||||
|
// - slice is a `Slice`
|
||||||
|
// - `my_array[:]`
|
||||||
|
// - slice is a `Slice`, but lower upper step would all be `Option::None`
|
||||||
|
// - `my_array[:, :]`
|
||||||
|
// - slice is now a `Tuple` of two `Slice`-s
|
||||||
|
//
|
||||||
|
// In summary:
|
||||||
|
// - when there is a comma "," within [], `slice` will be a `Tuple` of the entries.
|
||||||
|
// - when there is not comma "," within [] (i.e., just a single entry), `slice` will be that entry itself.
|
||||||
|
//
|
||||||
|
// So we first "flatten" out the slice expression
|
||||||
|
let index_exprs = match &subscript.node {
|
||||||
|
ExprKind::Tuple { elts, .. } => elts.iter().collect_vec(),
|
||||||
|
_ => vec![subscript],
|
||||||
|
};
|
||||||
|
|
||||||
|
// Process all index expressions
|
||||||
|
let mut rust_ndindices: Vec<RustNDIndex> = Vec::with_capacity(index_exprs.len()); // Not using iterators here because `?` is used here.
|
||||||
|
for index_expr in index_exprs {
|
||||||
|
// NOTE: Currently nac3core's slices do not have an object representation,
|
||||||
|
// so the code/implementation looks awkward - we have to do pattern matching on the expression
|
||||||
|
let ndindex = if let ExprKind::Slice { lower, upper, step } = &index_expr.node {
|
||||||
|
// Handle slices
|
||||||
|
let slice = gen_slice(generator, ctx, lower, upper, step)?;
|
||||||
|
RustNDIndex::Slice(slice)
|
||||||
|
} else {
|
||||||
|
// Treat and handle everything else as a single element index.
|
||||||
|
let index = generator.gen_expr(ctx, index_expr)?.unwrap().to_basic_value_enum(
|
||||||
|
ctx,
|
||||||
|
generator,
|
||||||
|
ctx.primitives.int32, // Must be int32, this checks for illegal values
|
||||||
|
)?;
|
||||||
|
let index = Int(Int32).check_value(generator, ctx.ctx, index).unwrap();
|
||||||
|
|
||||||
|
RustNDIndex::SingleElement(index)
|
||||||
|
};
|
||||||
|
rust_ndindices.push(ndindex);
|
||||||
|
}
|
||||||
|
Ok(rust_ndindices)
|
||||||
|
}
|
||||||
|
}
|
|
@ -0,0 +1,446 @@
|
||||||
|
pub mod array;
|
||||||
|
pub mod factory;
|
||||||
|
pub mod indexing;
|
||||||
|
pub mod nditer;
|
||||||
|
pub mod shape_util;
|
||||||
|
pub mod view;
|
||||||
|
|
||||||
|
use inkwell::{
|
||||||
|
context::Context,
|
||||||
|
types::BasicType,
|
||||||
|
values::{BasicValue, BasicValueEnum, PointerValue},
|
||||||
|
AddressSpace,
|
||||||
|
};
|
||||||
|
|
||||||
|
use crate::{
|
||||||
|
codegen::{
|
||||||
|
irrt::{
|
||||||
|
call_nac3_ndarray_copy_data, call_nac3_ndarray_get_nth_pelement,
|
||||||
|
call_nac3_ndarray_get_pelement_by_indices, call_nac3_ndarray_is_c_contiguous,
|
||||||
|
call_nac3_ndarray_len, call_nac3_ndarray_nbytes,
|
||||||
|
call_nac3_ndarray_set_strides_by_shape, call_nac3_ndarray_size,
|
||||||
|
},
|
||||||
|
model::*,
|
||||||
|
CodeGenContext, CodeGenerator,
|
||||||
|
},
|
||||||
|
toplevel::{helper::extract_ndims, numpy::unpack_ndarray_var_tys},
|
||||||
|
typecheck::typedef::Type,
|
||||||
|
};
|
||||||
|
|
||||||
|
use super::any::AnyObject;
|
||||||
|
|
||||||
|
/// Fields of [`NDArray`]
|
||||||
|
pub struct NDArrayFields<'ctx, F: FieldTraversal<'ctx>> {
|
||||||
|
pub data: F::Output<Ptr<Int<Byte>>>,
|
||||||
|
pub itemsize: F::Output<Int<SizeT>>,
|
||||||
|
pub ndims: F::Output<Int<SizeT>>,
|
||||||
|
pub shape: F::Output<Ptr<Int<SizeT>>>,
|
||||||
|
pub strides: F::Output<Ptr<Int<SizeT>>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A strided ndarray in NAC3.
|
||||||
|
///
|
||||||
|
/// See IRRT implementation for details about its fields.
|
||||||
|
#[derive(Debug, Clone, Copy, Default)]
|
||||||
|
pub struct NDArray;
|
||||||
|
|
||||||
|
impl<'ctx> StructKind<'ctx> for NDArray {
|
||||||
|
type Fields<F: FieldTraversal<'ctx>> = NDArrayFields<'ctx, F>;
|
||||||
|
|
||||||
|
fn iter_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F> {
|
||||||
|
Self::Fields {
|
||||||
|
data: traversal.add_auto("data"),
|
||||||
|
itemsize: traversal.add_auto("itemsize"),
|
||||||
|
ndims: traversal.add_auto("ndims"),
|
||||||
|
shape: traversal.add_auto("shape"),
|
||||||
|
strides: traversal.add_auto("strides"),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A NAC3 Python ndarray object.
|
||||||
|
#[derive(Debug, Clone, Copy)]
|
||||||
|
pub struct NDArrayObject<'ctx> {
|
||||||
|
pub dtype: Type,
|
||||||
|
pub ndims: u64,
|
||||||
|
pub instance: Instance<'ctx, Ptr<Struct<NDArray>>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx> NDArrayObject<'ctx> {
|
||||||
|
/// Attempt to convert an [`AnyObject`] into an [`NDArrayObject`].
|
||||||
|
pub fn from_object<G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
object: AnyObject<'ctx>,
|
||||||
|
) -> NDArrayObject<'ctx> {
|
||||||
|
let (dtype, ndims) = unpack_ndarray_var_tys(&mut ctx.unifier, object.ty);
|
||||||
|
let ndims = extract_ndims(&ctx.unifier, ndims);
|
||||||
|
Self::from_value_and_unpacked_types(generator, ctx, object.value, dtype, ndims)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Like [`NDArrayObject::from_object`] but you directly supply the ndarray's
|
||||||
|
/// `dtype` and `ndims`.
|
||||||
|
pub fn from_value_and_unpacked_types<V: BasicValue<'ctx>, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
value: V,
|
||||||
|
dtype: Type,
|
||||||
|
ndims: u64,
|
||||||
|
) -> Self {
|
||||||
|
let value = Ptr(Struct(NDArray)).check_value(generator, ctx.ctx, value).unwrap();
|
||||||
|
NDArrayObject { dtype, ndims, instance: value }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get this ndarray's `ndims` as an LLVM constant.
|
||||||
|
pub fn ndims_llvm<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &'ctx Context,
|
||||||
|
) -> Instance<'ctx, Int<SizeT>> {
|
||||||
|
Int(SizeT).const_int(generator, ctx, self.ndims, false)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Allocate an ndarray on the stack given its `ndims` and `dtype`.
|
||||||
|
///
|
||||||
|
/// `shape` and `strides` will be automatically allocated onto the stack.
|
||||||
|
///
|
||||||
|
/// The returned ndarray's content will be:
|
||||||
|
/// - `data`: uninitialized.
|
||||||
|
/// - `itemsize`: set to the `sizeof()` of `dtype`.
|
||||||
|
/// - `ndims`: set to the value of `ndims`.
|
||||||
|
/// - `shape`: allocated with an array of length `ndims` with uninitialized values.
|
||||||
|
/// - `strides`: allocated with an array of length `ndims` with uninitialized values.
|
||||||
|
pub fn alloca<G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
dtype: Type,
|
||||||
|
ndims: u64,
|
||||||
|
) -> Self {
|
||||||
|
let ndarray = Struct(NDArray).alloca(generator, ctx);
|
||||||
|
|
||||||
|
let itemsize = ctx.get_llvm_type(generator, dtype).size_of().unwrap();
|
||||||
|
let itemsize = Int(SizeT).z_extend_or_truncate(generator, ctx, itemsize);
|
||||||
|
ndarray.set(ctx, |f| f.itemsize, itemsize);
|
||||||
|
|
||||||
|
let ndims_val = Int(SizeT).const_int(generator, ctx.ctx, ndims, false);
|
||||||
|
ndarray.set(ctx, |f| f.ndims, ndims_val);
|
||||||
|
|
||||||
|
let shape = Int(SizeT).array_alloca(generator, ctx, ndims_val.value);
|
||||||
|
ndarray.set(ctx, |f| f.shape, shape);
|
||||||
|
|
||||||
|
let strides = Int(SizeT).array_alloca(generator, ctx, ndims_val.value);
|
||||||
|
ndarray.set(ctx, |f| f.strides, strides);
|
||||||
|
|
||||||
|
NDArrayObject { dtype, ndims, instance: ndarray }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convenience function. Allocate an [`NDArrayObject`] with a statically known shape.
|
||||||
|
///
|
||||||
|
/// The returned [`NDArrayObject`]'s `data` and `strides` are uninitialized.
|
||||||
|
pub fn alloca_constant_shape<G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
dtype: Type,
|
||||||
|
shape: &[u64],
|
||||||
|
) -> Self {
|
||||||
|
let ndarray = NDArrayObject::alloca(generator, ctx, dtype, shape.len() as u64);
|
||||||
|
|
||||||
|
// Write shape
|
||||||
|
let dst_shape = ndarray.instance.get(generator, ctx, |f| f.shape);
|
||||||
|
for (i, dim) in shape.iter().enumerate() {
|
||||||
|
let dim = Int(SizeT).const_int(generator, ctx.ctx, *dim, false);
|
||||||
|
dst_shape.offset_const(ctx, i64::try_from(i).unwrap()).store(ctx, dim);
|
||||||
|
}
|
||||||
|
|
||||||
|
ndarray
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convenience function. Allocate an [`NDArrayObject`] with a dynamically known shape.
|
||||||
|
///
|
||||||
|
/// The returned [`NDArrayObject`]'s `data` and `strides` are uninitialized.
|
||||||
|
pub fn alloca_dynamic_shape<G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
dtype: Type,
|
||||||
|
shape: &[Instance<'ctx, Int<SizeT>>],
|
||||||
|
) -> Self {
|
||||||
|
let ndarray = NDArrayObject::alloca(generator, ctx, dtype, shape.len() as u64);
|
||||||
|
|
||||||
|
// Write shape
|
||||||
|
let dst_shape = ndarray.instance.get(generator, ctx, |f| f.shape);
|
||||||
|
for (i, dim) in shape.iter().enumerate() {
|
||||||
|
dst_shape.offset_const(ctx, i64::try_from(i).unwrap()).store(ctx, *dim);
|
||||||
|
}
|
||||||
|
|
||||||
|
ndarray
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Initialize an ndarray's `data` by allocating a buffer on the stack.
|
||||||
|
/// The allocated data buffer is considered to be *owned* by the ndarray.
|
||||||
|
///
|
||||||
|
/// `strides` of the ndarray will also be updated with `set_strides_by_shape`.
|
||||||
|
///
|
||||||
|
/// `shape` and `itemsize` of the ndarray ***must*** be initialized first.
|
||||||
|
pub fn create_data<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
) {
|
||||||
|
let nbytes = self.nbytes(generator, ctx);
|
||||||
|
|
||||||
|
let data = Int(Byte).array_alloca(generator, ctx, nbytes.value);
|
||||||
|
self.instance.set(ctx, |f| f.data, data);
|
||||||
|
|
||||||
|
self.set_strides_contiguous(generator, ctx);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Copy shape dimensions from an array.
|
||||||
|
pub fn copy_shape_from_array<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
shape: Instance<'ctx, Ptr<Int<SizeT>>>,
|
||||||
|
) {
|
||||||
|
let num_items = self.ndims_llvm(generator, ctx.ctx).value;
|
||||||
|
self.instance.get(generator, ctx, |f| f.shape).copy_from(generator, ctx, shape, num_items);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Copy shape dimensions from an ndarray.
|
||||||
|
/// Panics if `ndims` mismatches.
|
||||||
|
pub fn copy_shape_from_ndarray<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
src_ndarray: NDArrayObject<'ctx>,
|
||||||
|
) {
|
||||||
|
assert_eq!(self.ndims, src_ndarray.ndims);
|
||||||
|
let src_shape = src_ndarray.instance.get(generator, ctx, |f| f.shape);
|
||||||
|
self.copy_shape_from_array(generator, ctx, src_shape);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Copy strides dimensions from an array.
|
||||||
|
pub fn copy_strides_from_array<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
strides: Instance<'ctx, Ptr<Int<SizeT>>>,
|
||||||
|
) {
|
||||||
|
let num_items = self.ndims_llvm(generator, ctx.ctx).value;
|
||||||
|
self.instance
|
||||||
|
.get(generator, ctx, |f| f.strides)
|
||||||
|
.copy_from(generator, ctx, strides, num_items);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Copy strides dimensions from an ndarray.
|
||||||
|
/// Panics if `ndims` mismatches.
|
||||||
|
pub fn copy_strides_from_ndarray<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
src_ndarray: NDArrayObject<'ctx>,
|
||||||
|
) {
|
||||||
|
assert_eq!(self.ndims, src_ndarray.ndims);
|
||||||
|
let src_strides = src_ndarray.instance.get(generator, ctx, |f| f.strides);
|
||||||
|
self.copy_strides_from_array(generator, ctx, src_strides);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the `np.size()` of this ndarray.
|
||||||
|
pub fn size<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
) -> Instance<'ctx, Int<SizeT>> {
|
||||||
|
call_nac3_ndarray_size(generator, ctx, self.instance)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the `ndarray.nbytes` of this ndarray.
|
||||||
|
pub fn nbytes<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
) -> Instance<'ctx, Int<SizeT>> {
|
||||||
|
call_nac3_ndarray_nbytes(generator, ctx, self.instance)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the `len()` of this ndarray.
|
||||||
|
pub fn len<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
) -> Instance<'ctx, Int<SizeT>> {
|
||||||
|
call_nac3_ndarray_len(generator, ctx, self.instance)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Check if this ndarray is C-contiguous.
|
||||||
|
///
|
||||||
|
/// See NumPy's `flags["C_CONTIGUOUS"]`: <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.flags.html#numpy.ndarray.flags>
|
||||||
|
pub fn is_c_contiguous<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
) -> Instance<'ctx, Int<Bool>> {
|
||||||
|
call_nac3_ndarray_is_c_contiguous(generator, ctx, self.instance)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the pointer to the n-th (0-based) element.
|
||||||
|
///
|
||||||
|
/// The returned pointer has the element type of the LLVM type of this ndarray's `dtype`.
|
||||||
|
pub fn get_nth_pelement<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
nth: Instance<'ctx, Int<SizeT>>,
|
||||||
|
) -> PointerValue<'ctx> {
|
||||||
|
let elem_ty = ctx.get_llvm_type(generator, self.dtype);
|
||||||
|
|
||||||
|
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()), "")
|
||||||
|
.unwrap()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the n-th (0-based) scalar.
|
||||||
|
pub fn get_nth_scalar<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
nth: Instance<'ctx, Int<SizeT>>,
|
||||||
|
) -> AnyObject<'ctx> {
|
||||||
|
let ptr = self.get_nth_pelement(generator, ctx, nth);
|
||||||
|
let value = ctx.builder.build_load(ptr, "").unwrap();
|
||||||
|
AnyObject { ty: self.dtype, value }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the pointer to the element indexed by `indices`.
|
||||||
|
///
|
||||||
|
/// The returned pointer has the element type of the LLVM type of this ndarray's `dtype`.
|
||||||
|
pub fn get_pelement_by_indices<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
indices: Instance<'ctx, Ptr<Int<SizeT>>>,
|
||||||
|
) -> PointerValue<'ctx> {
|
||||||
|
let elem_ty = ctx.get_llvm_type(generator, self.dtype);
|
||||||
|
|
||||||
|
let p = call_nac3_ndarray_get_pelement_by_indices(generator, ctx, self.instance, indices);
|
||||||
|
ctx.builder
|
||||||
|
.build_pointer_cast(p.value, elem_ty.ptr_type(AddressSpace::default()), "")
|
||||||
|
.unwrap()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the scalar indexed by `indices`.
|
||||||
|
pub fn get_scalar_by_indices<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
indices: Instance<'ctx, Ptr<Int<SizeT>>>,
|
||||||
|
) -> AnyObject<'ctx> {
|
||||||
|
let ptr = self.get_pelement_by_indices(generator, ctx, indices);
|
||||||
|
let value = ctx.builder.build_load(ptr, "").unwrap();
|
||||||
|
AnyObject { ty: self.dtype, value }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Call [`call_nac3_ndarray_set_strides_by_shape`] on this ndarray to update `strides`.
|
||||||
|
///
|
||||||
|
/// Update the ndarray's strides to make the ndarray contiguous.
|
||||||
|
pub fn set_strides_contiguous<G: CodeGenerator + ?Sized>(
|
||||||
|
self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
) {
|
||||||
|
call_nac3_ndarray_set_strides_by_shape(generator, ctx, self.instance);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Clone/Copy this ndarray - Allocate a new ndarray with the same shape as this ndarray and copy the contents over.
|
||||||
|
///
|
||||||
|
/// The new ndarray will own its data and will be C-contiguous.
|
||||||
|
#[must_use]
|
||||||
|
pub fn make_copy<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
) -> Self {
|
||||||
|
let clone = NDArrayObject::alloca(generator, ctx, self.dtype, self.ndims);
|
||||||
|
|
||||||
|
let shape = self.instance.gep(ctx, |f| f.shape).load(generator, ctx);
|
||||||
|
clone.copy_shape_from_array(generator, ctx, shape);
|
||||||
|
clone.create_data(generator, ctx);
|
||||||
|
clone.copy_data_from(generator, ctx, *self);
|
||||||
|
clone
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Copy data from another ndarray.
|
||||||
|
///
|
||||||
|
/// This ndarray and `src` is that their `np.size()` should be the same. Their shapes
|
||||||
|
/// do not matter. The copying order is determined by how their flattened views look.
|
||||||
|
///
|
||||||
|
/// Panics if the `dtype`s of ndarrays are different.
|
||||||
|
pub fn copy_data_from<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'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.instance, self.instance);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns true if this ndarray is unsized - `ndims == 0` and only contains a scalar.
|
||||||
|
#[must_use]
|
||||||
|
pub fn is_unsized(&self) -> bool {
|
||||||
|
self.ndims == 0
|
||||||
|
}
|
||||||
|
|
||||||
|
/// If this ndarray is unsized, return its sole value as an [`AnyObject`].
|
||||||
|
/// Otherwise, do nothing and return the ndarray itself.
|
||||||
|
pub fn split_unsized<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
) -> ScalarOrNDArray<'ctx> {
|
||||||
|
if self.is_unsized() {
|
||||||
|
// NOTE: `np.size(self) == 0` here is never possible.
|
||||||
|
let zero = Int(SizeT).const_0(generator, ctx.ctx);
|
||||||
|
let value = self.get_nth_scalar(generator, ctx, zero).value;
|
||||||
|
|
||||||
|
ScalarOrNDArray::Scalar(AnyObject { ty: self.dtype, value })
|
||||||
|
} else {
|
||||||
|
ScalarOrNDArray::NDArray(*self)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Fill the ndarray with a scalar.
|
||||||
|
///
|
||||||
|
/// `fill_value` must have the same LLVM type as the `dtype` of this ndarray.
|
||||||
|
pub fn fill<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
value: BasicValueEnum<'ctx>,
|
||||||
|
) {
|
||||||
|
self.foreach(generator, ctx, |generator, ctx, _hooks, nditer| {
|
||||||
|
let p = nditer.get_pointer(generator, ctx);
|
||||||
|
ctx.builder.build_store(p, value).unwrap();
|
||||||
|
Ok(())
|
||||||
|
})
|
||||||
|
.unwrap();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A convenience enum for implementing functions that acts on scalars or ndarrays or both.
|
||||||
|
#[derive(Debug, Clone, Copy)]
|
||||||
|
pub enum ScalarOrNDArray<'ctx> {
|
||||||
|
Scalar(AnyObject<'ctx>),
|
||||||
|
NDArray(NDArrayObject<'ctx>),
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx> ScalarOrNDArray<'ctx> {
|
||||||
|
/// Get the underlying [`BasicValueEnum<'ctx>`] of this [`ScalarOrNDArray`].
|
||||||
|
#[must_use]
|
||||||
|
pub fn to_basic_value_enum(self) -> BasicValueEnum<'ctx> {
|
||||||
|
match self {
|
||||||
|
ScalarOrNDArray::Scalar(scalar) => scalar.value,
|
||||||
|
ScalarOrNDArray::NDArray(ndarray) => ndarray.instance.value.as_basic_value_enum(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
|
@ -0,0 +1,179 @@
|
||||||
|
use inkwell::{types::BasicType, values::PointerValue, AddressSpace};
|
||||||
|
|
||||||
|
use crate::codegen::{
|
||||||
|
irrt::{call_nac3_nditer_has_element, call_nac3_nditer_initialize, call_nac3_nditer_next},
|
||||||
|
model::*,
|
||||||
|
object::any::AnyObject,
|
||||||
|
stmt::{gen_for_callback, BreakContinueHooks},
|
||||||
|
CodeGenContext, CodeGenerator,
|
||||||
|
};
|
||||||
|
|
||||||
|
use super::NDArrayObject;
|
||||||
|
|
||||||
|
/// Fields of [`NDIter`]
|
||||||
|
pub struct NDIterFields<'ctx, F: FieldTraversal<'ctx>> {
|
||||||
|
pub ndims: F::Output<Int<SizeT>>,
|
||||||
|
pub shape: F::Output<Ptr<Int<SizeT>>>,
|
||||||
|
pub strides: F::Output<Ptr<Int<SizeT>>>,
|
||||||
|
|
||||||
|
pub indices: F::Output<Ptr<Int<SizeT>>>,
|
||||||
|
pub nth: F::Output<Int<SizeT>>,
|
||||||
|
pub element: F::Output<Ptr<Int<Byte>>>,
|
||||||
|
|
||||||
|
pub size: F::Output<Int<SizeT>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// An IRRT helper structure used to iterate through an ndarray.
|
||||||
|
#[derive(Debug, Clone, Copy, Default)]
|
||||||
|
pub struct NDIter;
|
||||||
|
|
||||||
|
impl<'ctx> StructKind<'ctx> for NDIter {
|
||||||
|
type Fields<F: FieldTraversal<'ctx>> = NDIterFields<'ctx, F>;
|
||||||
|
|
||||||
|
fn iter_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F> {
|
||||||
|
Self::Fields {
|
||||||
|
ndims: traversal.add_auto("ndims"),
|
||||||
|
shape: traversal.add_auto("shape"),
|
||||||
|
strides: traversal.add_auto("strides"),
|
||||||
|
|
||||||
|
indices: traversal.add_auto("indices"),
|
||||||
|
nth: traversal.add_auto("nth"),
|
||||||
|
element: traversal.add_auto("element"),
|
||||||
|
|
||||||
|
size: traversal.add_auto("size"),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A helper structure with a convenient interface to interact with [`NDIter`].
|
||||||
|
#[derive(Debug, Clone)]
|
||||||
|
pub struct NDIterHandle<'ctx> {
|
||||||
|
instance: Instance<'ctx, Ptr<Struct<NDIter>>>,
|
||||||
|
/// The ndarray this [`NDIter`] to iterating over.
|
||||||
|
ndarray: NDArrayObject<'ctx>,
|
||||||
|
/// The current indices of [`NDIter`].
|
||||||
|
indices: Instance<'ctx, Ptr<Int<SizeT>>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx> NDIterHandle<'ctx> {
|
||||||
|
/// Allocate an [`NDIter`] that iterates through an ndarray.
|
||||||
|
pub fn new<G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
ndarray: NDArrayObject<'ctx>,
|
||||||
|
) -> Self {
|
||||||
|
let nditer = Struct(NDIter).alloca(generator, ctx);
|
||||||
|
let ndims = ndarray.ndims_llvm(generator, ctx.ctx);
|
||||||
|
|
||||||
|
// The caller has the responsibility to allocate 'indices' for `NDIter`.
|
||||||
|
let indices = Int(SizeT).array_alloca(generator, ctx, ndims.value);
|
||||||
|
call_nac3_nditer_initialize(generator, ctx, nditer, ndarray.instance, indices);
|
||||||
|
|
||||||
|
NDIterHandle { ndarray, instance: nditer, indices }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Is the current iteration valid?
|
||||||
|
///
|
||||||
|
/// If true, then `element`, `indices` and `nth` contain details about the current element.
|
||||||
|
///
|
||||||
|
/// If `ndarray` is unsized, this returns true only for the first iteration.
|
||||||
|
/// If `ndarray` is 0-sized, this always returns false.
|
||||||
|
#[must_use]
|
||||||
|
pub fn has_element<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
) -> Instance<'ctx, Int<Bool>> {
|
||||||
|
call_nac3_nditer_has_element(generator, ctx, self.instance)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Go to the next element. If `has_element()` is false, then this has undefined behavior.
|
||||||
|
///
|
||||||
|
/// If `ndarray` is unsized, this can only be called once.
|
||||||
|
/// If `ndarray` is 0-sized, this can never be called.
|
||||||
|
pub fn next<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
) {
|
||||||
|
call_nac3_nditer_next(generator, ctx, self.instance);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get pointer to the current element.
|
||||||
|
#[must_use]
|
||||||
|
pub fn get_pointer<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
) -> PointerValue<'ctx> {
|
||||||
|
let elem_ty = ctx.get_llvm_type(generator, self.ndarray.dtype);
|
||||||
|
|
||||||
|
let p = self.instance.get(generator, ctx, |f| f.element);
|
||||||
|
ctx.builder
|
||||||
|
.build_pointer_cast(p.value, elem_ty.ptr_type(AddressSpace::default()), "element")
|
||||||
|
.unwrap()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the value of the current element.
|
||||||
|
#[must_use]
|
||||||
|
pub fn get_scalar<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
) -> AnyObject<'ctx> {
|
||||||
|
let p = self.get_pointer(generator, ctx);
|
||||||
|
let value = ctx.builder.build_load(p, "value").unwrap();
|
||||||
|
AnyObject { ty: self.ndarray.dtype, value }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the index of the current element if this ndarray were a flat ndarray.
|
||||||
|
#[must_use]
|
||||||
|
pub fn get_index<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
) -> Instance<'ctx, Int<SizeT>> {
|
||||||
|
self.instance.get(generator, ctx, |f| f.nth)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the indices of the current element.
|
||||||
|
#[must_use]
|
||||||
|
pub fn get_indices(&self) -> Instance<'ctx, Ptr<Int<SizeT>>> {
|
||||||
|
self.indices
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx> NDArrayObject<'ctx> {
|
||||||
|
/// Iterate through every element in the ndarray.
|
||||||
|
///
|
||||||
|
/// `body` has access to [`BreakContinueHooks`] to short-circuit and [`NDIterHandle`] to
|
||||||
|
/// get properties of the current iteration (e.g., the current element, indices, etc.)
|
||||||
|
pub fn foreach<'a, G, F>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, 'a>,
|
||||||
|
body: F,
|
||||||
|
) -> Result<(), String>
|
||||||
|
where
|
||||||
|
G: CodeGenerator + ?Sized,
|
||||||
|
F: FnOnce(
|
||||||
|
&mut G,
|
||||||
|
&mut CodeGenContext<'ctx, 'a>,
|
||||||
|
BreakContinueHooks<'ctx>,
|
||||||
|
NDIterHandle<'ctx>,
|
||||||
|
) -> Result<(), String>,
|
||||||
|
{
|
||||||
|
gen_for_callback(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
Some("ndarray_foreach"),
|
||||||
|
|generator, ctx| Ok(NDIterHandle::new(generator, ctx, *self)),
|
||||||
|
|generator, ctx, nditer| Ok(nditer.has_element(generator, ctx).value),
|
||||||
|
|generator, ctx, hooks, nditer| body(generator, ctx, hooks, nditer),
|
||||||
|
|generator, ctx, nditer| {
|
||||||
|
nditer.next(generator, ctx);
|
||||||
|
Ok(())
|
||||||
|
},
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
|
@ -0,0 +1,105 @@
|
||||||
|
use util::gen_for_model;
|
||||||
|
|
||||||
|
use crate::{
|
||||||
|
codegen::{
|
||||||
|
model::*,
|
||||||
|
object::{any::AnyObject, list::ListObject, tuple::TupleObject},
|
||||||
|
CodeGenContext, CodeGenerator,
|
||||||
|
},
|
||||||
|
typecheck::typedef::TypeEnum,
|
||||||
|
};
|
||||||
|
|
||||||
|
/// Parse a NumPy-like "int sequence" input and return the int sequence as an array and its length.
|
||||||
|
///
|
||||||
|
/// * `sequence` - The `sequence` parameter.
|
||||||
|
/// * `sequence_ty` - The typechecker type of `sequence`
|
||||||
|
///
|
||||||
|
/// The `sequence` argument type may only be one of the following:
|
||||||
|
/// 1. A list of `int32`; e.g., `np.empty([600, 800, 3])`
|
||||||
|
/// 2. A tuple of `int32`; e.g., `np.empty((600, 800, 3))`
|
||||||
|
/// 3. A scalar `int32`; e.g., `np.empty(3)`, this is functionally equivalent to `np.empty([3])`
|
||||||
|
///
|
||||||
|
/// All `int32` values will be sign-extended to `SizeT`.
|
||||||
|
pub fn parse_numpy_int_sequence<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
input_sequence: AnyObject<'ctx>,
|
||||||
|
) -> (Instance<'ctx, Int<SizeT>>, Instance<'ctx, Ptr<Int<SizeT>>>) {
|
||||||
|
let zero = Int(SizeT).const_0(generator, ctx.ctx);
|
||||||
|
let one = Int(SizeT).const_1(generator, ctx.ctx);
|
||||||
|
|
||||||
|
// The result `list` to return.
|
||||||
|
match &*ctx.unifier.get_ty(input_sequence.ty) {
|
||||||
|
TypeEnum::TObj { obj_id, .. }
|
||||||
|
if *obj_id == ctx.primitives.list.obj_id(&ctx.unifier).unwrap() =>
|
||||||
|
{
|
||||||
|
// 1. A list of `int32`; e.g., `np.empty([600, 800, 3])`
|
||||||
|
|
||||||
|
// Check `input_sequence`
|
||||||
|
let input_sequence = ListObject::from_object(generator, ctx, input_sequence);
|
||||||
|
|
||||||
|
let len = input_sequence.instance.get(generator, ctx, |f| f.len);
|
||||||
|
let result = Int(SizeT).array_alloca(generator, ctx, len.value);
|
||||||
|
|
||||||
|
// Load all the `int32`s from the input_sequence, cast them to `SizeT`, and store them into `result`
|
||||||
|
gen_for_model(generator, ctx, zero, len, one, |generator, ctx, _hooks, i| {
|
||||||
|
// Load the i-th int32 in the input sequence
|
||||||
|
let int = input_sequence
|
||||||
|
.instance
|
||||||
|
.get(generator, ctx, |f| f.items)
|
||||||
|
.get_index(generator, ctx, i.value)
|
||||||
|
.value
|
||||||
|
.into_int_value();
|
||||||
|
|
||||||
|
// Cast to SizeT
|
||||||
|
let int = Int(SizeT).s_extend_or_bit_cast(generator, ctx, int);
|
||||||
|
|
||||||
|
// Store
|
||||||
|
result.set_index(ctx, i.value, int);
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
})
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
(len, result)
|
||||||
|
}
|
||||||
|
TypeEnum::TTuple { .. } => {
|
||||||
|
// 2. A tuple of ints; e.g., `np.empty((600, 800, 3))`
|
||||||
|
|
||||||
|
let input_sequence = TupleObject::from_object(ctx, input_sequence);
|
||||||
|
|
||||||
|
let len = input_sequence.len(generator, ctx);
|
||||||
|
|
||||||
|
let result = Int(SizeT).array_alloca(generator, ctx, len.value);
|
||||||
|
|
||||||
|
for i in 0..input_sequence.num_elements() {
|
||||||
|
// Get the i-th element off of the tuple and load it into `result`.
|
||||||
|
let int = input_sequence.index(ctx, i).value.into_int_value();
|
||||||
|
let int = Int(SizeT).s_extend_or_bit_cast(generator, ctx, int);
|
||||||
|
|
||||||
|
result.set_index_const(ctx, i64::try_from(i).unwrap(), int);
|
||||||
|
}
|
||||||
|
|
||||||
|
(len, result)
|
||||||
|
}
|
||||||
|
TypeEnum::TObj { obj_id, .. }
|
||||||
|
if *obj_id == ctx.primitives.int32.obj_id(&ctx.unifier).unwrap() =>
|
||||||
|
{
|
||||||
|
// 3. A scalar int; e.g., `np.empty(3)`, this is functionally equivalent to `np.empty([3])`
|
||||||
|
let input_int = input_sequence.value.into_int_value();
|
||||||
|
|
||||||
|
let len = Int(SizeT).const_1(generator, ctx.ctx);
|
||||||
|
let result = Int(SizeT).array_alloca(generator, ctx, len.value);
|
||||||
|
let int = Int(SizeT).s_extend_or_bit_cast(generator, ctx, input_int);
|
||||||
|
|
||||||
|
// Storing into result[0]
|
||||||
|
result.store(ctx, int);
|
||||||
|
|
||||||
|
(len, result)
|
||||||
|
}
|
||||||
|
_ => panic!(
|
||||||
|
"encountered unknown sequence type: {}",
|
||||||
|
ctx.unifier.stringify(input_sequence.ty)
|
||||||
|
),
|
||||||
|
}
|
||||||
|
}
|
|
@ -0,0 +1,29 @@
|
||||||
|
use crate::codegen::{CodeGenContext, CodeGenerator};
|
||||||
|
|
||||||
|
use super::{indexing::RustNDIndex, NDArrayObject};
|
||||||
|
|
||||||
|
impl<'ctx> NDArrayObject<'ctx> {
|
||||||
|
/// Make sure the ndarray is at least `ndmin`-dimensional.
|
||||||
|
///
|
||||||
|
/// If this ndarray's `ndims` is less than `ndmin`, a view is created on this with 1s prepended to the shape.
|
||||||
|
/// If this ndarray's `ndims` is not less than `ndmin`, this function does nothing and return this ndarray.
|
||||||
|
#[must_use]
|
||||||
|
pub fn atleast_nd<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
ndmin: u64,
|
||||||
|
) -> Self {
|
||||||
|
if self.ndims < ndmin {
|
||||||
|
// Extend the dimensions with np.newaxis.
|
||||||
|
let mut indices = vec![];
|
||||||
|
for _ in self.ndims..ndmin {
|
||||||
|
indices.push(RustNDIndex::NewAxis);
|
||||||
|
}
|
||||||
|
indices.push(RustNDIndex::Ellipsis);
|
||||||
|
self.index(generator, ctx, &indices)
|
||||||
|
} else {
|
||||||
|
*self
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
|
@ -0,0 +1,99 @@
|
||||||
|
use inkwell::values::StructValue;
|
||||||
|
use itertools::Itertools;
|
||||||
|
|
||||||
|
use crate::{
|
||||||
|
codegen::{model::*, CodeGenContext, CodeGenerator},
|
||||||
|
typecheck::typedef::{Type, TypeEnum},
|
||||||
|
};
|
||||||
|
|
||||||
|
use super::any::AnyObject;
|
||||||
|
|
||||||
|
/// A NAC3 tuple object.
|
||||||
|
///
|
||||||
|
/// NOTE: This struct has no copy trait.
|
||||||
|
#[derive(Debug, Clone)]
|
||||||
|
pub struct TupleObject<'ctx> {
|
||||||
|
/// The type of the tuple.
|
||||||
|
pub tys: Vec<Type>,
|
||||||
|
/// The underlying LLVM struct value of this tuple.
|
||||||
|
pub value: StructValue<'ctx>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx> TupleObject<'ctx> {
|
||||||
|
pub fn from_object(ctx: &mut CodeGenContext<'ctx, '_>, object: AnyObject<'ctx>) -> Self {
|
||||||
|
// TODO: Keep `is_vararg_ctx` from TTuple?
|
||||||
|
|
||||||
|
// Sanity check on object type.
|
||||||
|
let TypeEnum::TTuple { ty: tys, .. } = &*ctx.unifier.get_ty(object.ty) else {
|
||||||
|
panic!(
|
||||||
|
"Expected type to be a TypeEnum::TTuple, got {}",
|
||||||
|
ctx.unifier.stringify(object.ty)
|
||||||
|
);
|
||||||
|
};
|
||||||
|
|
||||||
|
// Check number of fields
|
||||||
|
let value = object.value.into_struct_value();
|
||||||
|
let value_num_fields = value.get_type().count_fields() as usize;
|
||||||
|
assert!(
|
||||||
|
value_num_fields == tys.len(),
|
||||||
|
"Tuple type has {} item(s), but the LLVM struct value has {} field(s)",
|
||||||
|
tys.len(),
|
||||||
|
value_num_fields
|
||||||
|
);
|
||||||
|
|
||||||
|
TupleObject { tys: tys.clone(), value }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convenience function. Create a [`TupleObject`] from an iterator of objects.
|
||||||
|
pub fn from_objects<I, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
objects: I,
|
||||||
|
) -> Self
|
||||||
|
where
|
||||||
|
I: IntoIterator<Item = AnyObject<'ctx>>,
|
||||||
|
{
|
||||||
|
let (values, tys): (Vec<_>, Vec<_>) =
|
||||||
|
objects.into_iter().map(|object| (object.value, object.ty)).unzip();
|
||||||
|
|
||||||
|
let llvm_tys = tys.iter().map(|ty| ctx.get_llvm_type(generator, *ty)).collect_vec();
|
||||||
|
let llvm_tuple_ty = ctx.ctx.struct_type(&llvm_tys, false);
|
||||||
|
|
||||||
|
let pllvm_tuple = ctx.builder.build_alloca(llvm_tuple_ty, "tuple").unwrap();
|
||||||
|
for (i, val) in values.into_iter().enumerate() {
|
||||||
|
let pval = ctx.builder.build_struct_gep(pllvm_tuple, i as u32, "value").unwrap();
|
||||||
|
ctx.builder.build_store(pval, val).unwrap();
|
||||||
|
}
|
||||||
|
|
||||||
|
let value = ctx.builder.build_load(pllvm_tuple, "").unwrap().into_struct_value();
|
||||||
|
TupleObject { tys, value }
|
||||||
|
}
|
||||||
|
|
||||||
|
#[must_use]
|
||||||
|
pub fn num_elements(&self) -> usize {
|
||||||
|
self.tys.len()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the `len()` of this tuple.
|
||||||
|
#[must_use]
|
||||||
|
pub fn len<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
) -> Instance<'ctx, Int<SizeT>> {
|
||||||
|
Int(SizeT).const_int(generator, ctx.ctx, self.num_elements() as u64, false)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the `i`-th (0-based) object in this tuple.
|
||||||
|
pub fn index(&self, ctx: &mut CodeGenContext<'ctx, '_>, i: usize) -> AnyObject<'ctx> {
|
||||||
|
assert!(
|
||||||
|
i < self.num_elements(),
|
||||||
|
"Tuple object with length {} have index {i}",
|
||||||
|
self.num_elements()
|
||||||
|
);
|
||||||
|
|
||||||
|
let value = ctx.builder.build_extract_value(self.value, i as u32, "tuple[{i}]").unwrap();
|
||||||
|
let ty = self.tys[i];
|
||||||
|
AnyObject { ty, value }
|
||||||
|
}
|
||||||
|
}
|
|
@ -0,0 +1 @@
|
||||||
|
pub mod slice;
|
|
@ -0,0 +1,125 @@
|
||||||
|
use crate::codegen::{model::*, CodeGenContext, CodeGenerator};
|
||||||
|
|
||||||
|
/// Fields of [`Slice`]
|
||||||
|
#[derive(Debug, Clone)]
|
||||||
|
pub struct SliceFields<'ctx, F: FieldTraversal<'ctx>, N: IntKind<'ctx>> {
|
||||||
|
pub start_defined: F::Output<Int<Bool>>,
|
||||||
|
pub start: F::Output<Int<N>>,
|
||||||
|
pub stop_defined: F::Output<Int<Bool>>,
|
||||||
|
pub stop: F::Output<Int<N>>,
|
||||||
|
pub step_defined: F::Output<Int<Bool>>,
|
||||||
|
pub step: F::Output<Int<N>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// An IRRT representation of an (unresolved) slice.
|
||||||
|
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
|
||||||
|
pub struct Slice<N>(pub N);
|
||||||
|
|
||||||
|
impl<'ctx, N: IntKind<'ctx>> StructKind<'ctx> for Slice<N> {
|
||||||
|
type Fields<F: FieldTraversal<'ctx>> = SliceFields<'ctx, F, N>;
|
||||||
|
|
||||||
|
fn iter_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F> {
|
||||||
|
Self::Fields {
|
||||||
|
start_defined: traversal.add_auto("start_defined"),
|
||||||
|
start: traversal.add("start", Int(self.0)),
|
||||||
|
stop_defined: traversal.add_auto("stop_defined"),
|
||||||
|
stop: traversal.add("stop", Int(self.0)),
|
||||||
|
step_defined: traversal.add_auto("step_defined"),
|
||||||
|
step: traversal.add("step", Int(self.0)),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A Rust structure that has [`Slice`] utilities and looks like a [`Slice`] but
|
||||||
|
/// `start`, `stop` and `step` are held by LLVM registers only and possibly
|
||||||
|
/// [`Option::None`] if unspecified.
|
||||||
|
#[derive(Debug, Clone)]
|
||||||
|
pub struct RustSlice<'ctx, N: IntKind<'ctx>> {
|
||||||
|
// It is possible that `start`, `stop`, and `step` are all `None`.
|
||||||
|
// We need to know the `int_kind` even when that is the case.
|
||||||
|
pub int_kind: N,
|
||||||
|
pub start: Option<Instance<'ctx, Int<N>>>,
|
||||||
|
pub stop: Option<Instance<'ctx, Int<N>>>,
|
||||||
|
pub step: Option<Instance<'ctx, Int<N>>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'ctx, N: IntKind<'ctx>> RustSlice<'ctx, N> {
|
||||||
|
/// Write the contents to an LLVM [`Slice`].
|
||||||
|
pub fn write_to_slice<G: CodeGenerator + ?Sized>(
|
||||||
|
&self,
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &CodeGenContext<'ctx, '_>,
|
||||||
|
dst_slice_ptr: Instance<'ctx, Ptr<Struct<Slice<N>>>>,
|
||||||
|
) {
|
||||||
|
let false_ = Int(Bool).const_false(generator, ctx.ctx);
|
||||||
|
let true_ = Int(Bool).const_true(generator, ctx.ctx);
|
||||||
|
|
||||||
|
match self.start {
|
||||||
|
Some(start) => {
|
||||||
|
dst_slice_ptr.gep(ctx, |f| f.start_defined).store(ctx, true_);
|
||||||
|
dst_slice_ptr.gep(ctx, |f| f.start).store(ctx, start);
|
||||||
|
}
|
||||||
|
None => dst_slice_ptr.gep(ctx, |f| f.start_defined).store(ctx, false_),
|
||||||
|
}
|
||||||
|
|
||||||
|
match self.stop {
|
||||||
|
Some(stop) => {
|
||||||
|
dst_slice_ptr.gep(ctx, |f| f.stop_defined).store(ctx, true_);
|
||||||
|
dst_slice_ptr.gep(ctx, |f| f.stop).store(ctx, stop);
|
||||||
|
}
|
||||||
|
None => dst_slice_ptr.gep(ctx, |f| f.stop_defined).store(ctx, false_),
|
||||||
|
}
|
||||||
|
|
||||||
|
match self.step {
|
||||||
|
Some(step) => {
|
||||||
|
dst_slice_ptr.gep(ctx, |f| f.step_defined).store(ctx, true_);
|
||||||
|
dst_slice_ptr.gep(ctx, |f| f.step).store(ctx, step);
|
||||||
|
}
|
||||||
|
None => dst_slice_ptr.gep(ctx, |f| f.step_defined).store(ctx, false_),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub mod util {
|
||||||
|
use nac3parser::ast::Expr;
|
||||||
|
|
||||||
|
use crate::{
|
||||||
|
codegen::{model::*, CodeGenContext, CodeGenerator},
|
||||||
|
typecheck::typedef::Type,
|
||||||
|
};
|
||||||
|
|
||||||
|
use super::RustSlice;
|
||||||
|
|
||||||
|
/// Generate LLVM IR for an [`ExprKind::Slice`] and convert it into a [`RustSlice`].
|
||||||
|
#[allow(clippy::type_complexity)]
|
||||||
|
pub fn gen_slice<'ctx, G: CodeGenerator>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
lower: &Option<Box<Expr<Option<Type>>>>,
|
||||||
|
upper: &Option<Box<Expr<Option<Type>>>>,
|
||||||
|
step: &Option<Box<Expr<Option<Type>>>>,
|
||||||
|
) -> Result<RustSlice<'ctx, Int32>, String> {
|
||||||
|
let mut help = |value_expr: &Option<Box<Expr<Option<Type>>>>| -> Result<_, String> {
|
||||||
|
Ok(match value_expr {
|
||||||
|
None => None,
|
||||||
|
Some(value_expr) => {
|
||||||
|
let value_expr = generator
|
||||||
|
.gen_expr(ctx, value_expr)?
|
||||||
|
.unwrap()
|
||||||
|
.to_basic_value_enum(ctx, generator, ctx.primitives.int32)?;
|
||||||
|
|
||||||
|
let value_expr =
|
||||||
|
Int(Int32).check_value(generator, ctx.ctx, value_expr).unwrap();
|
||||||
|
|
||||||
|
Some(value_expr)
|
||||||
|
}
|
||||||
|
})
|
||||||
|
};
|
||||||
|
|
||||||
|
let start = help(lower)?;
|
||||||
|
let stop = help(upper)?;
|
||||||
|
let step = help(step)?;
|
||||||
|
|
||||||
|
Ok(RustSlice { int_kind: Int32, start, stop, step })
|
||||||
|
}
|
||||||
|
}
|
|
@ -1118,3 +1118,23 @@ pub fn arraylike_get_ndims(unifier: &mut Unifier, ty: Type) -> u64 {
|
||||||
_ => 0,
|
_ => 0,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Extract an ndarray's `ndims` [type][`Type`] in `u64`. Panic if not possible.
|
||||||
|
/// The `ndims` must only contain 1 value.
|
||||||
|
#[must_use]
|
||||||
|
pub fn extract_ndims(unifier: &Unifier, ndims_ty: Type) -> u64 {
|
||||||
|
let ndims_ty_enum = unifier.get_ty_immutable(ndims_ty);
|
||||||
|
let TypeEnum::TLiteral { values, .. } = &*ndims_ty_enum else {
|
||||||
|
panic!("ndims_ty should be a TLiteral");
|
||||||
|
};
|
||||||
|
|
||||||
|
assert_eq!(values.len(), 1, "ndims_ty TLiteral should only contain 1 value");
|
||||||
|
|
||||||
|
let ndims = values[0].clone();
|
||||||
|
u64::try_from(ndims).unwrap()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Return an ndarray's `ndims` as a typechecker [`Type`] from its `u64` value.
|
||||||
|
pub fn create_ndims(unifier: &mut Unifier, ndims: u64) -> Type {
|
||||||
|
unifier.get_fresh_literal(vec![SymbolValue::U64(ndims)], None)
|
||||||
|
}
|
||||||
|
|
Loading…
Reference in New Issue