mirror of
https://github.com/roc-lang/roc.git
synced 2025-09-29 06:44:46 +00:00
1992 lines
67 KiB
Rust
1992 lines
67 KiB
Rust
use crate::llvm::build::{build_num_binop, Env, InPlace};
|
|
use crate::llvm::compare::build_eq;
|
|
use crate::llvm::convert::{basic_type_from_layout, collection, get_ptr_type, ptr_int};
|
|
use inkwell::builder::Builder;
|
|
use inkwell::context::Context;
|
|
use inkwell::types::{BasicTypeEnum, PointerType};
|
|
use inkwell::values::{BasicValueEnum, FunctionValue, IntValue, PointerValue, StructValue};
|
|
use inkwell::{AddressSpace, IntPredicate};
|
|
use roc_mono::layout::{Builtin, Layout, MemoryMode};
|
|
|
|
/// List.single : a -> List a
|
|
pub fn list_single<'a, 'ctx, 'env>(
|
|
env: &Env<'a, 'ctx, 'env>,
|
|
inplace: InPlace,
|
|
elem: BasicValueEnum<'ctx>,
|
|
elem_layout: &Layout<'a>,
|
|
) -> BasicValueEnum<'ctx> {
|
|
let builder = env.builder;
|
|
let ctx = env.context;
|
|
|
|
// allocate a list of size 1 on the heap
|
|
let size = ctx.i64_type().const_int(1, false);
|
|
|
|
let ptr = allocate_list(env, inplace, elem_layout, size);
|
|
|
|
// Put the element into the list
|
|
let elem_ptr = unsafe {
|
|
builder.build_in_bounds_gep(
|
|
ptr,
|
|
&[ctx.i64_type().const_int(
|
|
// 0 as in 0 index of our new list
|
|
0 as u64, false,
|
|
)],
|
|
"index",
|
|
)
|
|
};
|
|
|
|
builder.build_store(elem_ptr, elem);
|
|
|
|
store_list(env, ptr, env.ptr_int().const_int(1, false))
|
|
}
|
|
|
|
/// List.repeat : Int, elem -> List elem
|
|
pub fn list_repeat<'a, 'ctx, 'env>(
|
|
env: &Env<'a, 'ctx, 'env>,
|
|
inplace: InPlace,
|
|
parent: FunctionValue<'ctx>,
|
|
list_len: IntValue<'ctx>,
|
|
elem: BasicValueEnum<'ctx>,
|
|
elem_layout: &Layout<'a>,
|
|
) -> BasicValueEnum<'ctx> {
|
|
let builder = env.builder;
|
|
let ctx = env.context;
|
|
|
|
// list_len > 0
|
|
// We have to do a loop below, continuously adding the `elem`
|
|
// to the output list `List elem` until we have reached the
|
|
// number of repeats. This `comparison` is used to check
|
|
// if we need to do any looping; because if we dont, then we
|
|
// dont need to allocate memory for the index or the check
|
|
// if index != 0
|
|
let comparison = builder.build_int_compare(
|
|
IntPredicate::UGT,
|
|
list_len,
|
|
ctx.i64_type().const_int(0, false),
|
|
"atleastzero",
|
|
);
|
|
|
|
let build_then = || {
|
|
// Allocate space for the new array that we'll copy into.
|
|
let list_ptr = allocate_list(env, inplace, elem_layout, list_len);
|
|
// TODO check if malloc returned null; if so, runtime error for OOM!
|
|
|
|
let index_name = "#index";
|
|
let start_alloca = builder.build_alloca(ctx.i64_type(), index_name);
|
|
|
|
// Start at the last element in the list.
|
|
let last_elem_index = builder.build_int_sub(
|
|
list_len,
|
|
ctx.i64_type().const_int(1, false),
|
|
"lastelemindex",
|
|
);
|
|
builder.build_store(start_alloca, last_elem_index);
|
|
|
|
let loop_bb = ctx.append_basic_block(parent, "loop");
|
|
builder.build_unconditional_branch(loop_bb);
|
|
builder.position_at_end(loop_bb);
|
|
|
|
// #index = #index - 1
|
|
let curr_index = builder
|
|
.build_load(start_alloca, index_name)
|
|
.into_int_value();
|
|
let next_index =
|
|
builder.build_int_sub(curr_index, ctx.i64_type().const_int(1, false), "nextindex");
|
|
|
|
builder.build_store(start_alloca, next_index);
|
|
let elem_ptr =
|
|
unsafe { builder.build_in_bounds_gep(list_ptr, &[curr_index], "load_index") };
|
|
|
|
// Mutate the new array in-place to change the element.
|
|
builder.build_store(elem_ptr, elem);
|
|
|
|
// #index != 0
|
|
let end_cond = builder.build_int_compare(
|
|
IntPredicate::NE,
|
|
ctx.i64_type().const_int(0, false),
|
|
curr_index,
|
|
"loopcond",
|
|
);
|
|
|
|
let after_bb = ctx.append_basic_block(parent, "afterloop");
|
|
|
|
builder.build_conditional_branch(end_cond, loop_bb, after_bb);
|
|
builder.position_at_end(after_bb);
|
|
|
|
store_list(env, list_ptr, list_len)
|
|
};
|
|
|
|
let build_else = || empty_polymorphic_list(env);
|
|
|
|
let struct_type = collection(ctx, env.ptr_bytes);
|
|
|
|
build_basic_phi2(
|
|
env,
|
|
parent,
|
|
comparison,
|
|
build_then,
|
|
build_else,
|
|
BasicTypeEnum::StructType(struct_type),
|
|
)
|
|
}
|
|
|
|
/// List.prepend List elem, elem -> List elem
|
|
pub fn list_prepend<'a, 'ctx, 'env>(
|
|
env: &Env<'a, 'ctx, 'env>,
|
|
inplace: InPlace,
|
|
original_wrapper: StructValue<'ctx>,
|
|
elem: BasicValueEnum<'ctx>,
|
|
elem_layout: &Layout<'a>,
|
|
) -> BasicValueEnum<'ctx> {
|
|
let builder = env.builder;
|
|
let ctx = env.context;
|
|
|
|
// Load the usize length from the wrapper.
|
|
let len = list_len(builder, original_wrapper);
|
|
let elem_type = basic_type_from_layout(env.arena, ctx, elem_layout, env.ptr_bytes);
|
|
let ptr_type = get_ptr_type(&elem_type, AddressSpace::Generic);
|
|
let list_ptr = load_list_ptr(builder, original_wrapper, ptr_type);
|
|
|
|
// The output list length, which is the old list length + 1
|
|
let new_list_len = env.builder.build_int_add(
|
|
ctx.i64_type().const_int(1 as u64, false),
|
|
len,
|
|
"new_list_length",
|
|
);
|
|
|
|
// Allocate space for the new array that we'll copy into.
|
|
let clone_ptr = allocate_list(env, inplace, elem_layout, new_list_len);
|
|
|
|
builder.build_store(clone_ptr, elem);
|
|
|
|
let index_1_ptr = unsafe {
|
|
builder.build_in_bounds_gep(
|
|
clone_ptr,
|
|
&[ctx.i64_type().const_int(1 as u64, false)],
|
|
"load_index",
|
|
)
|
|
};
|
|
|
|
// Calculate the number of bytes we'll need to allocate.
|
|
let elem_bytes = env
|
|
.ptr_int()
|
|
.const_int(elem_layout.stack_size(env.ptr_bytes) as u64, false);
|
|
|
|
// This is the size of the list coming in, before we have added an element
|
|
// to the beginning.
|
|
let list_size = env
|
|
.builder
|
|
.build_int_mul(elem_bytes, len, "mul_old_len_by_elem_bytes");
|
|
|
|
let ptr_bytes = env.ptr_bytes;
|
|
|
|
if elem_layout.safe_to_memcpy() {
|
|
// Copy the bytes from the original array into the new
|
|
// one we just malloc'd.
|
|
//
|
|
// TODO how do we decide when to do the small memcpy vs the normal one?
|
|
builder
|
|
.build_memcpy(index_1_ptr, ptr_bytes, list_ptr, ptr_bytes, list_size)
|
|
.unwrap();
|
|
} else {
|
|
panic!("TODO Cranelift currently only knows how to clone list elements that are Copy.");
|
|
}
|
|
|
|
store_list(env, clone_ptr, new_list_len)
|
|
}
|
|
|
|
/// List.join : List (List elem) -> List elem
|
|
pub fn list_join<'a, 'ctx, 'env>(
|
|
env: &Env<'a, 'ctx, 'env>,
|
|
inplace: InPlace,
|
|
parent: FunctionValue<'ctx>,
|
|
outer_list: BasicValueEnum<'ctx>,
|
|
outer_list_layout: &Layout<'a>,
|
|
) -> BasicValueEnum<'ctx> {
|
|
// List.join is implemented as follows:
|
|
// 1. loop over every list to sum the list lengths
|
|
// 2. using the sum of all the list lengths, allocate an output list of
|
|
// that size.
|
|
// 3. loop over every list, for every list, loop over every element
|
|
// putting it into the output list
|
|
|
|
match outer_list_layout {
|
|
// If the input list is empty, or if it is a list of empty lists
|
|
// then simply return an empty list
|
|
Layout::Builtin(Builtin::EmptyList)
|
|
| Layout::Builtin(Builtin::List(_, Layout::Builtin(Builtin::EmptyList))) => empty_list(env),
|
|
Layout::Builtin(Builtin::List(_, Layout::Builtin(Builtin::List(_, elem_layout)))) => {
|
|
let inner_list_layout =
|
|
Layout::Builtin(Builtin::List(MemoryMode::Refcounted, elem_layout));
|
|
|
|
let builder = env.builder;
|
|
let ctx = env.context;
|
|
|
|
let elem_type = basic_type_from_layout(env.arena, ctx, elem_layout, env.ptr_bytes);
|
|
let elem_ptr_type = get_ptr_type(&elem_type, AddressSpace::Generic);
|
|
|
|
let inner_list_type =
|
|
basic_type_from_layout(env.arena, ctx, &inner_list_layout, env.ptr_bytes);
|
|
|
|
let outer_list_wrapper = outer_list.into_struct_value();
|
|
let outer_list_len = list_len(builder, outer_list_wrapper);
|
|
let outer_list_ptr = {
|
|
let elem_ptr_type = get_ptr_type(&inner_list_type, AddressSpace::Generic);
|
|
|
|
load_list_ptr(builder, outer_list_wrapper, elem_ptr_type)
|
|
};
|
|
|
|
// outer_list_len > 0
|
|
// We do this check to avoid allocating memory. If the input
|
|
// list is empty, then we can just return an empty list.
|
|
let comparison = list_is_not_empty(env, outer_list_len);
|
|
|
|
let build_then = || {
|
|
let list_len_sum_name = "#listslengthsum";
|
|
let list_len_sum_alloca = builder.build_alloca(ctx.i64_type(), list_len_sum_name);
|
|
|
|
builder.build_store(list_len_sum_alloca, ctx.i64_type().const_int(0, false));
|
|
|
|
// List Sum Loop
|
|
let sum_loop = |_, inner_list: BasicValueEnum<'ctx>| {
|
|
let inner_list_len = list_len(builder, inner_list.into_struct_value());
|
|
|
|
let next_list_sum = builder.build_int_add(
|
|
builder
|
|
.build_load(list_len_sum_alloca, list_len_sum_name)
|
|
.into_int_value(),
|
|
inner_list_len,
|
|
"nextlistsum",
|
|
);
|
|
|
|
builder.build_store(list_len_sum_alloca, next_list_sum);
|
|
};
|
|
|
|
incrementing_elem_loop(
|
|
builder,
|
|
ctx,
|
|
parent,
|
|
outer_list_ptr,
|
|
outer_list_len,
|
|
"#sum_index",
|
|
sum_loop,
|
|
);
|
|
|
|
let final_list_sum = builder
|
|
.build_load(list_len_sum_alloca, list_len_sum_name)
|
|
.into_int_value();
|
|
|
|
let final_list_ptr = allocate_list(env, inplace, elem_layout, final_list_sum);
|
|
|
|
let dest_elem_ptr_alloca = builder.build_alloca(elem_ptr_type, "dest_elem");
|
|
|
|
builder.build_store(dest_elem_ptr_alloca, final_list_ptr);
|
|
|
|
// Inner List Loop
|
|
let inner_list_loop = |_, inner_list: BasicValueEnum<'ctx>| {
|
|
let inner_list_wrapper = inner_list.into_struct_value();
|
|
|
|
let inner_list_len = list_len(builder, inner_list_wrapper);
|
|
|
|
// inner_list_len > 0
|
|
let inner_list_comparison = list_is_not_empty(env, inner_list_len);
|
|
|
|
let inner_list_non_empty_block =
|
|
ctx.append_basic_block(parent, "inner_list_non_empty");
|
|
let after_inner_list_non_empty_block =
|
|
ctx.append_basic_block(parent, "branchcont");
|
|
|
|
builder.build_conditional_branch(
|
|
inner_list_comparison,
|
|
inner_list_non_empty_block,
|
|
after_inner_list_non_empty_block,
|
|
);
|
|
builder.position_at_end(inner_list_non_empty_block);
|
|
|
|
let inner_list_ptr = load_list_ptr(builder, inner_list_wrapper, elem_ptr_type);
|
|
|
|
// Element Inserting Loop
|
|
let inner_elem_loop = |_, src_elem| {
|
|
// TODO clone src_elem
|
|
|
|
let curr_dest_elem_ptr = builder
|
|
.build_load(dest_elem_ptr_alloca, "load_dest_elem_ptr")
|
|
.into_pointer_value();
|
|
|
|
builder.build_store(curr_dest_elem_ptr, src_elem);
|
|
|
|
let inc_dest_elem_ptr = BasicValueEnum::PointerValue(unsafe {
|
|
builder.build_in_bounds_gep(
|
|
curr_dest_elem_ptr,
|
|
&[env.ptr_int().const_int(1 as u64, false)],
|
|
"increment_dest_elem",
|
|
)
|
|
});
|
|
|
|
builder.build_store(dest_elem_ptr_alloca, inc_dest_elem_ptr);
|
|
};
|
|
|
|
incrementing_elem_loop(
|
|
builder,
|
|
ctx,
|
|
parent,
|
|
inner_list_ptr,
|
|
inner_list_len,
|
|
"#inner_index",
|
|
inner_elem_loop,
|
|
);
|
|
|
|
builder.build_unconditional_branch(after_inner_list_non_empty_block);
|
|
builder.position_at_end(after_inner_list_non_empty_block);
|
|
};
|
|
|
|
incrementing_elem_loop(
|
|
builder,
|
|
ctx,
|
|
parent,
|
|
outer_list_ptr,
|
|
outer_list_len,
|
|
"#inner_list_index",
|
|
inner_list_loop,
|
|
);
|
|
|
|
store_list(env, final_list_ptr, final_list_sum)
|
|
};
|
|
|
|
let build_else = || empty_list(env);
|
|
|
|
let struct_type = collection(ctx, env.ptr_bytes);
|
|
|
|
build_basic_phi2(
|
|
env,
|
|
parent,
|
|
comparison,
|
|
build_then,
|
|
build_else,
|
|
BasicTypeEnum::StructType(struct_type),
|
|
)
|
|
}
|
|
|
|
_ => {
|
|
unreachable!("Invalid List layout for List.join {:?}", outer_list_layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// List.reverse : List elem -> List elem
|
|
pub fn list_reverse_help<'a, 'ctx, 'env>(
|
|
env: &Env<'a, 'ctx, 'env>,
|
|
parent: FunctionValue<'ctx>,
|
|
inplace: InPlace,
|
|
length: IntValue<'ctx>,
|
|
source_ptr: PointerValue<'ctx>,
|
|
dest_ptr: PointerValue<'ctx>,
|
|
) {
|
|
let builder = env.builder;
|
|
let ctx = env.context;
|
|
|
|
// constant 1i64
|
|
let one = ctx.i64_type().const_int(1, false);
|
|
|
|
let low_alloca = builder.build_alloca(ctx.i64_type(), "low");
|
|
let high_alloca = builder.build_alloca(ctx.i64_type(), "high");
|
|
|
|
let high_val = builder.build_int_sub(length, one, "subtract 1");
|
|
|
|
builder.build_store(low_alloca, ctx.i64_type().const_zero());
|
|
builder.build_store(high_alloca, high_val);
|
|
|
|
// while (high > low)
|
|
let condition_bb = ctx.append_basic_block(parent, "condition");
|
|
builder.build_unconditional_branch(condition_bb);
|
|
builder.position_at_end(condition_bb);
|
|
|
|
let high = builder.build_load(high_alloca, "high").into_int_value();
|
|
let low = builder.build_load(low_alloca, "low").into_int_value();
|
|
|
|
// if updating in-place, then the "middle element" can be left untouched
|
|
// otherwise, the middle element needs to be copied over from the source to the target
|
|
let predicate = match inplace {
|
|
InPlace::InPlace => IntPredicate::SGT,
|
|
InPlace::Clone => IntPredicate::SGE,
|
|
};
|
|
|
|
let condition = builder.build_int_compare(predicate, high, low, "loopcond");
|
|
|
|
let body_bb = ctx.append_basic_block(parent, "body");
|
|
let cont_bb = ctx.append_basic_block(parent, "cont");
|
|
builder.build_conditional_branch(condition, body_bb, cont_bb);
|
|
|
|
// loop body
|
|
builder.position_at_end(body_bb);
|
|
|
|
// assumption: calculating pointer offsets for both the source and target is
|
|
|
|
let mut low_ptr = unsafe { builder.build_in_bounds_gep(source_ptr, &[low], "low_ptr") };
|
|
let mut high_ptr = unsafe { builder.build_in_bounds_gep(source_ptr, &[high], "high_ptr") };
|
|
|
|
// TODO use memmove?
|
|
let low_value = builder.build_load(low_ptr, "load_low");
|
|
let high_value = builder.build_load(high_ptr, "load_high");
|
|
|
|
// swap the two values
|
|
if let InPlace::Clone = inplace {
|
|
low_ptr = unsafe { builder.build_in_bounds_gep(dest_ptr, &[low], "low_ptr") };
|
|
high_ptr = unsafe { builder.build_in_bounds_gep(dest_ptr, &[high], "high_ptr") };
|
|
}
|
|
|
|
builder.build_store(high_ptr, low_value);
|
|
builder.build_store(low_ptr, high_value);
|
|
|
|
builder.build_store(low_alloca, builder.build_int_add(low, one, "increment"));
|
|
builder.build_store(high_alloca, builder.build_int_sub(high, one, "decrement"));
|
|
|
|
builder.build_unconditional_branch(condition_bb);
|
|
|
|
// continuation
|
|
builder.position_at_end(cont_bb);
|
|
}
|
|
|
|
/// List.reverse : List elem -> List elem
|
|
pub fn list_reverse<'a, 'ctx, 'env>(
|
|
env: &Env<'a, 'ctx, 'env>,
|
|
parent: FunctionValue<'ctx>,
|
|
output_inplace: InPlace,
|
|
list: BasicValueEnum<'ctx>,
|
|
list_layout: &Layout<'a>,
|
|
) -> BasicValueEnum<'ctx> {
|
|
use inkwell::types::BasicType;
|
|
|
|
let builder = env.builder;
|
|
let ctx = env.context;
|
|
|
|
let wrapper_struct = list.into_struct_value();
|
|
let (input_inplace, element_layout) = match list_layout.clone() {
|
|
Layout::Builtin(Builtin::EmptyList) => (
|
|
InPlace::InPlace,
|
|
// this pointer will never actually be dereferenced
|
|
Layout::Builtin(Builtin::Int64),
|
|
),
|
|
Layout::Builtin(Builtin::List(memory_mode, elem_layout)) => (
|
|
match memory_mode {
|
|
MemoryMode::Unique => InPlace::InPlace,
|
|
MemoryMode::Refcounted => InPlace::Clone,
|
|
},
|
|
elem_layout.clone(),
|
|
),
|
|
|
|
_ => unreachable!("Invalid layout {:?} in List.reverse", list_layout),
|
|
};
|
|
|
|
let list_type = basic_type_from_layout(env.arena, env.context, &element_layout, env.ptr_bytes);
|
|
let ptr_type = list_type.ptr_type(AddressSpace::Generic);
|
|
|
|
let list_ptr = load_list_ptr(builder, wrapper_struct, ptr_type);
|
|
let length = list_len(builder, list.into_struct_value());
|
|
|
|
match input_inplace {
|
|
InPlace::InPlace => {
|
|
list_reverse_help(env, parent, input_inplace, length, list_ptr, list_ptr);
|
|
|
|
list
|
|
}
|
|
|
|
InPlace::Clone => {
|
|
let len_0_block = ctx.append_basic_block(parent, "len_0_block");
|
|
let len_1_block = ctx.append_basic_block(parent, "len_1_block");
|
|
let len_n_block = ctx.append_basic_block(parent, "len_n_block");
|
|
let cont_block = ctx.append_basic_block(parent, "cont_block");
|
|
|
|
let one = ctx.i64_type().const_int(1, false);
|
|
let zero = ctx.i64_type().const_zero();
|
|
|
|
let result = builder.build_alloca(ptr_type, "result");
|
|
|
|
builder.build_switch(
|
|
length,
|
|
len_n_block,
|
|
&[(zero, len_0_block), (one, len_1_block)],
|
|
);
|
|
|
|
// build block for length 0
|
|
{
|
|
builder.position_at_end(len_0_block);
|
|
|
|
// store NULL pointer there
|
|
builder.build_store(result, ptr_type.const_zero());
|
|
builder.build_unconditional_branch(cont_block);
|
|
}
|
|
|
|
// build block for length 1
|
|
{
|
|
builder.position_at_end(len_1_block);
|
|
|
|
let new_list_ptr = clone_list(env, output_inplace, &element_layout, one, list_ptr);
|
|
|
|
builder.build_store(result, new_list_ptr);
|
|
builder.build_unconditional_branch(cont_block);
|
|
}
|
|
|
|
// build block for length > 1
|
|
{
|
|
builder.position_at_end(len_n_block);
|
|
|
|
let new_list_ptr = allocate_list(env, output_inplace, &element_layout, length);
|
|
|
|
list_reverse_help(env, parent, InPlace::Clone, length, list_ptr, new_list_ptr);
|
|
|
|
// store new list pointer there
|
|
builder.build_store(result, new_list_ptr);
|
|
builder.build_unconditional_branch(cont_block);
|
|
}
|
|
|
|
builder.position_at_end(cont_block);
|
|
let new_list_ptr = builder.build_load(result, "result").into_pointer_value();
|
|
|
|
store_list(env, new_list_ptr, length)
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn list_get_unsafe<'a, 'ctx, 'env>(
|
|
env: &Env<'a, 'ctx, 'env>,
|
|
list_layout: &Layout<'a>,
|
|
elem_index: IntValue<'ctx>,
|
|
wrapper_struct: StructValue<'ctx>,
|
|
) -> BasicValueEnum<'ctx> {
|
|
let builder = env.builder;
|
|
|
|
match list_layout {
|
|
Layout::Builtin(Builtin::List(_, elem_layout)) => {
|
|
let ctx = env.context;
|
|
let elem_type = basic_type_from_layout(env.arena, ctx, elem_layout, env.ptr_bytes);
|
|
let ptr_type = get_ptr_type(&elem_type, AddressSpace::Generic);
|
|
// Load the pointer to the array data
|
|
let array_data_ptr = load_list_ptr(builder, wrapper_struct, ptr_type);
|
|
|
|
// Assume the bounds have already been checked earlier
|
|
// (e.g. by List.get or List.first, which wrap List.#getUnsafe)
|
|
let elem_ptr =
|
|
unsafe { builder.build_in_bounds_gep(array_data_ptr, &[elem_index], "elem") };
|
|
|
|
builder.build_load(elem_ptr, "List.get")
|
|
}
|
|
_ => {
|
|
unreachable!(
|
|
"Invalid List layout for ListGetUnsafe operation: {:?}",
|
|
list_layout
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// List.append : List elem, elem -> List elem
|
|
pub fn list_append<'a, 'ctx, 'env>(
|
|
env: &Env<'a, 'ctx, 'env>,
|
|
inplace: InPlace,
|
|
original_wrapper: StructValue<'ctx>,
|
|
elem: BasicValueEnum<'ctx>,
|
|
elem_layout: &Layout<'a>,
|
|
) -> BasicValueEnum<'ctx> {
|
|
let builder = env.builder;
|
|
let ctx = env.context;
|
|
|
|
// Load the usize length from the wrapper.
|
|
let list_len = list_len(builder, original_wrapper);
|
|
let elem_type = basic_type_from_layout(env.arena, ctx, elem_layout, env.ptr_bytes);
|
|
let ptr_type = get_ptr_type(&elem_type, AddressSpace::Generic);
|
|
|
|
let list_ptr = load_list_ptr(builder, original_wrapper, ptr_type);
|
|
|
|
// The output list length, which is the old list length + 1
|
|
let new_list_len = env.builder.build_int_add(
|
|
ctx.i64_type().const_int(1 as u64, false),
|
|
list_len,
|
|
"new_list_length",
|
|
);
|
|
|
|
let ptr_bytes = env.ptr_bytes;
|
|
|
|
// Calculate the number of bytes we'll need to allocate.
|
|
let elem_bytes = env
|
|
.ptr_int()
|
|
.const_int(elem_layout.stack_size(env.ptr_bytes) as u64, false);
|
|
|
|
// This is the size of the list coming in, before we have added an element
|
|
// to the end.
|
|
let list_size = env
|
|
.builder
|
|
.build_int_mul(elem_bytes, list_len, "mul_old_len_by_elem_bytes");
|
|
|
|
// Allocate space for the new array that we'll copy into.
|
|
let clone_ptr = allocate_list(env, inplace, elem_layout, new_list_len);
|
|
|
|
// TODO check if malloc returned null; if so, runtime error for OOM!
|
|
|
|
if elem_layout.safe_to_memcpy() {
|
|
// Copy the bytes from the original array into the new
|
|
// one we just malloc'd.
|
|
//
|
|
// TODO how do we decide when to do the small memcpy vs the normal one?
|
|
builder
|
|
.build_memcpy(clone_ptr, ptr_bytes, list_ptr, ptr_bytes, list_size)
|
|
.unwrap();
|
|
} else {
|
|
panic!("TODO Cranelift currently only knows how to clone list elements that are Copy.");
|
|
}
|
|
|
|
let elem_ptr = unsafe { builder.build_in_bounds_gep(clone_ptr, &[list_len], "load_index") };
|
|
|
|
builder.build_store(elem_ptr, elem);
|
|
|
|
store_list(env, clone_ptr, new_list_len)
|
|
}
|
|
|
|
/// List.set : List elem, Int, elem -> List elem
|
|
pub fn list_set<'a, 'ctx, 'env>(
|
|
parent: FunctionValue<'ctx>,
|
|
args: &[(BasicValueEnum<'ctx>, &'a Layout<'a>)],
|
|
env: &Env<'a, 'ctx, 'env>,
|
|
input_inplace: InPlace,
|
|
output_inplace: InPlace,
|
|
) -> BasicValueEnum<'ctx> {
|
|
let builder = env.builder;
|
|
|
|
debug_assert_eq!(args.len(), 3);
|
|
|
|
let original_wrapper = args[0].0.into_struct_value();
|
|
let elem_index = args[1].0.into_int_value();
|
|
|
|
// Load the usize length from the wrapper. We need it for bounds checking.
|
|
let list_len = list_len(builder, original_wrapper);
|
|
|
|
// Bounds check: only proceed if index < length.
|
|
// Otherwise, return the list unaltered.
|
|
let comparison = bounds_check_comparison(builder, elem_index, list_len);
|
|
|
|
// If the index is in bounds, clone and mutate in place.
|
|
let build_then = || {
|
|
let (elem, elem_layout) = args[2];
|
|
let ctx = env.context;
|
|
let elem_type = basic_type_from_layout(env.arena, ctx, elem_layout, env.ptr_bytes);
|
|
let ptr_type = get_ptr_type(&elem_type, AddressSpace::Generic);
|
|
|
|
let (new_wrapper, array_data_ptr) = match input_inplace {
|
|
InPlace::InPlace => (
|
|
original_wrapper,
|
|
load_list_ptr(builder, original_wrapper, ptr_type),
|
|
),
|
|
InPlace::Clone => clone_nonempty_list(
|
|
env,
|
|
output_inplace,
|
|
list_len,
|
|
load_list_ptr(builder, original_wrapper, ptr_type),
|
|
elem_layout,
|
|
),
|
|
};
|
|
|
|
// If we got here, we passed the bounds check, so this is an in-bounds GEP
|
|
let elem_ptr =
|
|
unsafe { builder.build_in_bounds_gep(array_data_ptr, &[elem_index], "load_index") };
|
|
|
|
// Mutate the new array in-place to change the element.
|
|
builder.build_store(elem_ptr, elem);
|
|
|
|
BasicValueEnum::StructValue(new_wrapper)
|
|
};
|
|
|
|
// If the index was out of bounds, return the original list unaltered.
|
|
let build_else = || BasicValueEnum::StructValue(original_wrapper);
|
|
let ret_type = original_wrapper.get_type();
|
|
|
|
build_basic_phi2(
|
|
env,
|
|
parent,
|
|
comparison,
|
|
build_then,
|
|
build_else,
|
|
ret_type.into(),
|
|
)
|
|
}
|
|
|
|
fn bounds_check_comparison<'ctx>(
|
|
builder: &Builder<'ctx>,
|
|
elem_index: IntValue<'ctx>,
|
|
len: IntValue<'ctx>,
|
|
) -> IntValue<'ctx> {
|
|
// Note: Check for index < length as the "true" condition,
|
|
// to avoid misprediction. (In practice this should usually pass,
|
|
// and CPUs generally default to predicting that a forward jump
|
|
// shouldn't be taken; that is, they predict "else" won't be taken.)
|
|
builder.build_int_compare(IntPredicate::ULT, elem_index, len, "bounds_check")
|
|
}
|
|
|
|
/// List.len : List elem -> Int
|
|
pub fn list_len<'ctx>(
|
|
builder: &Builder<'ctx>,
|
|
wrapper_struct: StructValue<'ctx>,
|
|
) -> IntValue<'ctx> {
|
|
builder
|
|
.build_extract_value(wrapper_struct, Builtin::WRAPPER_LEN, "list_len")
|
|
.unwrap()
|
|
.into_int_value()
|
|
}
|
|
|
|
/// List.sum : List (Num a) -> Num a
|
|
pub fn list_sum<'a, 'ctx, 'env>(
|
|
env: &Env<'a, 'ctx, 'env>,
|
|
parent: FunctionValue<'ctx>,
|
|
list: BasicValueEnum<'ctx>,
|
|
default_layout: &Layout<'a>,
|
|
) -> BasicValueEnum<'ctx> {
|
|
let ctx = env.context;
|
|
let builder = env.builder;
|
|
|
|
let list_wrapper = list.into_struct_value();
|
|
let len = list_len(env.builder, list_wrapper);
|
|
|
|
let accum_type = basic_type_from_layout(env.arena, ctx, default_layout, env.ptr_bytes);
|
|
let accum_alloca = builder.build_alloca(accum_type, "alloca_walk_right_accum");
|
|
|
|
let default: BasicValueEnum = match accum_type {
|
|
BasicTypeEnum::IntType(int_type) => int_type.const_zero().into(),
|
|
BasicTypeEnum::FloatType(float_type) => float_type.const_zero().into(),
|
|
_ => unreachable!(""),
|
|
};
|
|
|
|
builder.build_store(accum_alloca, default);
|
|
|
|
let then_block = ctx.append_basic_block(parent, "then");
|
|
let cont_block = ctx.append_basic_block(parent, "branchcont");
|
|
|
|
let condition = builder.build_int_compare(
|
|
IntPredicate::UGT,
|
|
len,
|
|
ctx.i64_type().const_zero(),
|
|
"list_non_empty",
|
|
);
|
|
|
|
builder.build_conditional_branch(condition, then_block, cont_block);
|
|
|
|
builder.position_at_end(then_block);
|
|
|
|
let elem_ptr_type = get_ptr_type(&accum_type, AddressSpace::Generic);
|
|
let list_ptr = load_list_ptr(builder, list_wrapper, elem_ptr_type);
|
|
|
|
let walk_right_loop = |_, elem: BasicValueEnum<'ctx>| {
|
|
// load current accumulator
|
|
let current = builder.build_load(accum_alloca, "retrieve_accum");
|
|
|
|
let new_current = build_num_binop(
|
|
env,
|
|
parent,
|
|
current,
|
|
default_layout,
|
|
elem,
|
|
default_layout,
|
|
roc_module::low_level::LowLevel::NumAdd,
|
|
);
|
|
|
|
builder.build_store(accum_alloca, new_current);
|
|
};
|
|
|
|
incrementing_elem_loop(
|
|
builder,
|
|
ctx,
|
|
parent,
|
|
list_ptr,
|
|
len,
|
|
"#index",
|
|
walk_right_loop,
|
|
);
|
|
|
|
builder.build_unconditional_branch(cont_block);
|
|
|
|
builder.position_at_end(cont_block);
|
|
|
|
builder.build_load(accum_alloca, "load_final_acum")
|
|
}
|
|
|
|
/// List.walkRight : List elem, (elem -> accum -> accum), accum -> accum
|
|
#[allow(clippy::too_many_arguments)]
|
|
pub fn list_walk_right<'a, 'ctx, 'env>(
|
|
env: &Env<'a, 'ctx, 'env>,
|
|
parent: FunctionValue<'ctx>,
|
|
list: BasicValueEnum<'ctx>,
|
|
list_layout: &Layout<'a>,
|
|
func: BasicValueEnum<'ctx>,
|
|
func_layout: &Layout<'a>,
|
|
default: BasicValueEnum<'ctx>,
|
|
default_layout: &Layout<'a>,
|
|
) -> BasicValueEnum<'ctx> {
|
|
let ctx = env.context;
|
|
let builder = env.builder;
|
|
|
|
let list_wrapper = list.into_struct_value();
|
|
let len = list_len(env.builder, list_wrapper);
|
|
|
|
let accum_type = basic_type_from_layout(env.arena, ctx, default_layout, env.ptr_bytes);
|
|
let accum_alloca = builder.build_alloca(accum_type, "alloca_walk_right_accum");
|
|
builder.build_store(accum_alloca, default);
|
|
|
|
let then_block = ctx.append_basic_block(parent, "then");
|
|
let cont_block = ctx.append_basic_block(parent, "branchcont");
|
|
|
|
let condition = builder.build_int_compare(
|
|
IntPredicate::UGT,
|
|
len,
|
|
ctx.i64_type().const_zero(),
|
|
"list_non_empty",
|
|
);
|
|
|
|
builder.build_conditional_branch(condition, then_block, cont_block);
|
|
|
|
builder.position_at_end(then_block);
|
|
|
|
match (func, func_layout) {
|
|
(BasicValueEnum::PointerValue(func_ptr), Layout::FunctionPointer(_, _)) => {
|
|
let elem_layout = match list_layout {
|
|
Layout::Builtin(Builtin::List(_, layout)) => layout,
|
|
_ => unreachable!("can only fold over a list"),
|
|
};
|
|
|
|
let elem_type = basic_type_from_layout(env.arena, ctx, elem_layout, env.ptr_bytes);
|
|
let elem_ptr_type = get_ptr_type(&elem_type, AddressSpace::Generic);
|
|
|
|
let list_ptr = load_list_ptr(builder, list_wrapper, elem_ptr_type);
|
|
|
|
let walk_right_loop = |_, elem: BasicValueEnum<'ctx>| {
|
|
// load current accumulator
|
|
let current = builder.build_load(accum_alloca, "retrieve_accum");
|
|
|
|
let call_site_value =
|
|
builder.build_call(func_ptr, &[elem, current], "#walk_right_func");
|
|
|
|
// set the calling convention explicitly for this call
|
|
call_site_value.set_call_convention(crate::llvm::build::FAST_CALL_CONV);
|
|
|
|
let new_current = call_site_value
|
|
.try_as_basic_value()
|
|
.left()
|
|
.unwrap_or_else(|| panic!("LLVM error: Invalid call by pointer."));
|
|
|
|
builder.build_store(accum_alloca, new_current);
|
|
};
|
|
|
|
incrementing_elem_loop(
|
|
builder,
|
|
ctx,
|
|
parent,
|
|
list_ptr,
|
|
len,
|
|
"#index",
|
|
walk_right_loop,
|
|
);
|
|
}
|
|
|
|
_ => {
|
|
unreachable!(
|
|
"Invalid function basic value enum or layout for List.keepIf : {:?}",
|
|
(func, func_layout)
|
|
);
|
|
}
|
|
}
|
|
|
|
builder.build_unconditional_branch(cont_block);
|
|
|
|
builder.position_at_end(cont_block);
|
|
|
|
builder.build_load(accum_alloca, "load_final_acum")
|
|
}
|
|
|
|
/// List.contains : List elem, elem -> Bool
|
|
pub fn list_contains<'a, 'ctx, 'env>(
|
|
env: &Env<'a, 'ctx, 'env>,
|
|
parent: FunctionValue<'ctx>,
|
|
elem: BasicValueEnum<'ctx>,
|
|
elem_layout: &Layout<'a>,
|
|
list: BasicValueEnum<'ctx>,
|
|
list_layout: &Layout<'a>,
|
|
) -> BasicValueEnum<'ctx> {
|
|
use inkwell::types::BasicType;
|
|
|
|
let builder = env.builder;
|
|
|
|
let wrapper_struct = list.into_struct_value();
|
|
let list_elem_layout = match &list_layout {
|
|
// this pointer will never actually be dereferenced
|
|
Layout::Builtin(Builtin::EmptyList) => &Layout::Builtin(Builtin::Int64),
|
|
Layout::Builtin(Builtin::List(_, element_layout)) => element_layout,
|
|
_ => unreachable!("Invalid layout {:?} in List.contains", list_layout),
|
|
};
|
|
|
|
let list_elem_type =
|
|
basic_type_from_layout(env.arena, env.context, list_elem_layout, env.ptr_bytes);
|
|
|
|
let list_ptr = load_list_ptr(
|
|
builder,
|
|
wrapper_struct,
|
|
list_elem_type.ptr_type(AddressSpace::Generic),
|
|
);
|
|
|
|
let length = list_len(builder, list.into_struct_value());
|
|
|
|
list_contains_help(
|
|
env,
|
|
parent,
|
|
length,
|
|
list_ptr,
|
|
list_elem_layout,
|
|
elem,
|
|
elem_layout,
|
|
)
|
|
}
|
|
|
|
pub fn list_contains_help<'a, 'ctx, 'env>(
|
|
env: &Env<'a, 'ctx, 'env>,
|
|
parent: FunctionValue<'ctx>,
|
|
length: IntValue<'ctx>,
|
|
source_ptr: PointerValue<'ctx>,
|
|
list_elem_layout: &Layout<'a>,
|
|
elem: BasicValueEnum<'ctx>,
|
|
elem_layout: &Layout<'a>,
|
|
) -> BasicValueEnum<'ctx> {
|
|
let builder = env.builder;
|
|
let ctx = env.context;
|
|
|
|
let bool_alloca = builder.build_alloca(ctx.bool_type(), "bool_alloca");
|
|
let index_alloca = builder.build_alloca(ctx.i64_type(), "index_alloca");
|
|
let next_free_index_alloca = builder.build_alloca(ctx.i64_type(), "next_free_index_alloca");
|
|
|
|
builder.build_store(bool_alloca, ctx.bool_type().const_zero());
|
|
builder.build_store(index_alloca, ctx.i64_type().const_zero());
|
|
builder.build_store(next_free_index_alloca, ctx.i64_type().const_zero());
|
|
|
|
let condition_bb = ctx.append_basic_block(parent, "condition");
|
|
builder.build_unconditional_branch(condition_bb);
|
|
builder.position_at_end(condition_bb);
|
|
|
|
let index = builder.build_load(index_alloca, "index").into_int_value();
|
|
|
|
let condition = builder.build_int_compare(IntPredicate::SGT, length, index, "loopcond");
|
|
|
|
let body_bb = ctx.append_basic_block(parent, "body");
|
|
let cont_bb = ctx.append_basic_block(parent, "cont");
|
|
builder.build_conditional_branch(condition, body_bb, cont_bb);
|
|
|
|
// loop body
|
|
builder.position_at_end(body_bb);
|
|
|
|
let current_elem_ptr = unsafe { builder.build_in_bounds_gep(source_ptr, &[index], "elem_ptr") };
|
|
|
|
let current_elem = builder.build_load(current_elem_ptr, "load_elem");
|
|
|
|
let has_found = build_eq(env, current_elem, elem, list_elem_layout, elem_layout);
|
|
|
|
builder.build_store(bool_alloca, has_found.into_int_value());
|
|
|
|
let one = ctx.i64_type().const_int(1, false);
|
|
|
|
let next_free_index = builder
|
|
.build_load(next_free_index_alloca, "load_next_free")
|
|
.into_int_value();
|
|
|
|
builder.build_store(
|
|
next_free_index_alloca,
|
|
builder.build_int_add(next_free_index, one, "incremented_next_free_index"),
|
|
);
|
|
|
|
builder.build_store(
|
|
index_alloca,
|
|
builder.build_int_add(index, one, "incremented_index"),
|
|
);
|
|
|
|
builder.build_conditional_branch(has_found.into_int_value(), cont_bb, condition_bb);
|
|
|
|
// continuation
|
|
builder.position_at_end(cont_bb);
|
|
|
|
builder.build_load(bool_alloca, "answer")
|
|
}
|
|
|
|
/// List.keepIf : List elem, (elem -> Bool) -> List elem
|
|
pub fn list_keep_if<'a, 'ctx, 'env>(
|
|
env: &Env<'a, 'ctx, 'env>,
|
|
output_inplace: InPlace,
|
|
parent: FunctionValue<'ctx>,
|
|
func: BasicValueEnum<'ctx>,
|
|
func_layout: &Layout<'a>,
|
|
list: BasicValueEnum<'ctx>,
|
|
list_layout: &Layout<'a>,
|
|
) -> BasicValueEnum<'ctx> {
|
|
use inkwell::types::BasicType;
|
|
|
|
let builder = env.builder;
|
|
let ctx = env.context;
|
|
|
|
let wrapper_struct = list.into_struct_value();
|
|
let (input_inplace, element_layout) = match list_layout.clone() {
|
|
Layout::Builtin(Builtin::EmptyList) => (
|
|
InPlace::InPlace,
|
|
// this pointer will never actually be dereferenced
|
|
Layout::Builtin(Builtin::Int64),
|
|
),
|
|
Layout::Builtin(Builtin::List(memory_mode, elem_layout)) => (
|
|
match memory_mode {
|
|
MemoryMode::Unique => InPlace::InPlace,
|
|
MemoryMode::Refcounted => InPlace::Clone,
|
|
},
|
|
elem_layout.clone(),
|
|
),
|
|
|
|
_ => unreachable!("Invalid layout {:?} in List.keepIf", list_layout),
|
|
};
|
|
|
|
let list_type = basic_type_from_layout(env.arena, env.context, &list_layout, env.ptr_bytes);
|
|
let elem_type = basic_type_from_layout(env.arena, env.context, &element_layout, env.ptr_bytes);
|
|
let ptr_type = elem_type.ptr_type(AddressSpace::Generic);
|
|
|
|
let list_ptr = load_list_ptr(builder, wrapper_struct, ptr_type);
|
|
let length = list_len(builder, list.into_struct_value());
|
|
|
|
let zero = ctx.i64_type().const_zero();
|
|
|
|
match input_inplace {
|
|
InPlace::InPlace => {
|
|
let new_length = list_keep_if_help(
|
|
env,
|
|
input_inplace,
|
|
parent,
|
|
length,
|
|
list_ptr,
|
|
list_ptr,
|
|
func,
|
|
func_layout,
|
|
);
|
|
|
|
store_list(env, list_ptr, new_length)
|
|
}
|
|
InPlace::Clone => {
|
|
let len_0_block = ctx.append_basic_block(parent, "len_0_block");
|
|
let len_n_block = ctx.append_basic_block(parent, "len_n_block");
|
|
let cont_block = ctx.append_basic_block(parent, "cont_block");
|
|
|
|
let result = builder.build_alloca(list_type, "result");
|
|
|
|
builder.build_switch(length, len_n_block, &[(zero, len_0_block)]);
|
|
|
|
// build block for length 0
|
|
{
|
|
builder.position_at_end(len_0_block);
|
|
|
|
let new_list = store_list(env, ptr_type.const_zero(), zero);
|
|
|
|
builder.build_store(result, new_list);
|
|
builder.build_unconditional_branch(cont_block);
|
|
}
|
|
|
|
// build block for length > 0
|
|
{
|
|
builder.position_at_end(len_n_block);
|
|
|
|
let new_list_ptr = allocate_list(env, output_inplace, &element_layout, length);
|
|
|
|
let new_length = list_keep_if_help(
|
|
env,
|
|
InPlace::Clone,
|
|
parent,
|
|
length,
|
|
list_ptr,
|
|
new_list_ptr,
|
|
func,
|
|
func_layout,
|
|
);
|
|
|
|
// store new list pointer there
|
|
let new_list = store_list(env, new_list_ptr, new_length);
|
|
|
|
builder.build_store(result, new_list);
|
|
builder.build_unconditional_branch(cont_block);
|
|
}
|
|
|
|
builder.position_at_end(cont_block);
|
|
|
|
builder.build_load(result, "load_result")
|
|
}
|
|
}
|
|
}
|
|
|
|
#[allow(clippy::too_many_arguments)]
|
|
pub fn list_keep_if_help<'a, 'ctx, 'env>(
|
|
env: &Env<'a, 'ctx, 'env>,
|
|
_inplace: InPlace,
|
|
parent: FunctionValue<'ctx>,
|
|
length: IntValue<'ctx>,
|
|
source_ptr: PointerValue<'ctx>,
|
|
dest_ptr: PointerValue<'ctx>,
|
|
func: BasicValueEnum<'ctx>,
|
|
func_layout: &Layout<'a>,
|
|
) -> IntValue<'ctx> {
|
|
match (func, func_layout) {
|
|
(
|
|
BasicValueEnum::PointerValue(func_ptr),
|
|
Layout::FunctionPointer(_, Layout::Builtin(Builtin::Int1)),
|
|
) => {
|
|
let builder = env.builder;
|
|
let ctx = env.context;
|
|
|
|
let index_alloca = builder.build_alloca(ctx.i64_type(), "index_alloca");
|
|
let next_free_index_alloca =
|
|
builder.build_alloca(ctx.i64_type(), "next_free_index_alloca");
|
|
|
|
builder.build_store(index_alloca, ctx.i64_type().const_zero());
|
|
builder.build_store(next_free_index_alloca, ctx.i64_type().const_zero());
|
|
|
|
// while (length > next_index)
|
|
let condition_bb = ctx.append_basic_block(parent, "condition");
|
|
builder.build_unconditional_branch(condition_bb);
|
|
builder.position_at_end(condition_bb);
|
|
|
|
let index = builder.build_load(index_alloca, "index").into_int_value();
|
|
|
|
let condition = builder.build_int_compare(IntPredicate::SGT, length, index, "loopcond");
|
|
|
|
let body_bb = ctx.append_basic_block(parent, "body");
|
|
let cont_bb = ctx.append_basic_block(parent, "cont");
|
|
builder.build_conditional_branch(condition, body_bb, cont_bb);
|
|
|
|
// loop body
|
|
builder.position_at_end(body_bb);
|
|
|
|
let elem_ptr = unsafe { builder.build_in_bounds_gep(source_ptr, &[index], "elem_ptr") };
|
|
|
|
let elem = builder.build_load(elem_ptr, "load_elem");
|
|
|
|
let call_site_value =
|
|
builder.build_call(func_ptr, env.arena.alloc([elem]), "#keep_if_insert_func");
|
|
|
|
// set the calling convention explicitly for this call
|
|
call_site_value.set_call_convention(crate::llvm::build::FAST_CALL_CONV);
|
|
|
|
let should_keep = call_site_value
|
|
.try_as_basic_value()
|
|
.left()
|
|
.unwrap_or_else(|| panic!("LLVM error: Invalid call by pointer."))
|
|
.into_int_value();
|
|
|
|
let filter_pass_bb = ctx.append_basic_block(parent, "loop");
|
|
let after_filter_pass_bb = ctx.append_basic_block(parent, "after_loop");
|
|
|
|
let one = ctx.i64_type().const_int(1, false);
|
|
|
|
builder.build_conditional_branch(should_keep, filter_pass_bb, after_filter_pass_bb);
|
|
builder.position_at_end(filter_pass_bb);
|
|
|
|
let next_free_index = builder
|
|
.build_load(next_free_index_alloca, "load_next_free")
|
|
.into_int_value();
|
|
|
|
// TODO if next_free_index equals index, and we are mutating in place,
|
|
// then maybe we should not write this value back into memory
|
|
let dest_elem_ptr = unsafe {
|
|
builder.build_in_bounds_gep(dest_ptr, &[next_free_index], "dest_elem_ptr")
|
|
};
|
|
|
|
builder.build_store(dest_elem_ptr, elem);
|
|
|
|
builder.build_store(
|
|
next_free_index_alloca,
|
|
builder.build_int_add(next_free_index, one, "incremented_next_free_index"),
|
|
);
|
|
|
|
builder.build_unconditional_branch(after_filter_pass_bb);
|
|
builder.position_at_end(after_filter_pass_bb);
|
|
|
|
builder.build_store(
|
|
index_alloca,
|
|
builder.build_int_add(index, one, "incremented_index"),
|
|
);
|
|
|
|
builder.build_unconditional_branch(condition_bb);
|
|
|
|
// continuation
|
|
builder.position_at_end(cont_bb);
|
|
|
|
builder
|
|
.build_load(next_free_index_alloca, "new_length")
|
|
.into_int_value()
|
|
}
|
|
_ => unreachable!(
|
|
"Invalid function basic value enum or layout for List.keepIf : {:?}",
|
|
(func, func_layout)
|
|
),
|
|
}
|
|
}
|
|
|
|
/// List.map : List before, (before -> after) -> List after
|
|
pub fn list_map<'a, 'ctx, 'env>(
|
|
env: &Env<'a, 'ctx, 'env>,
|
|
inplace: InPlace,
|
|
parent: FunctionValue<'ctx>,
|
|
func: BasicValueEnum<'ctx>,
|
|
func_layout: &Layout<'a>,
|
|
list: BasicValueEnum<'ctx>,
|
|
list_layout: &Layout<'a>,
|
|
) -> BasicValueEnum<'ctx> {
|
|
match (func, func_layout) {
|
|
(BasicValueEnum::PointerValue(func_ptr), Layout::FunctionPointer(_, ret_elem_layout)) => {
|
|
let non_empty_fn = |elem_layout: &Layout<'a>,
|
|
len: IntValue<'ctx>,
|
|
list_wrapper: StructValue<'ctx>| {
|
|
let ctx = env.context;
|
|
let builder = env.builder;
|
|
|
|
let ret_list_ptr = allocate_list(env, inplace, ret_elem_layout, len);
|
|
|
|
let elem_type = basic_type_from_layout(env.arena, ctx, elem_layout, env.ptr_bytes);
|
|
let ptr_type = get_ptr_type(&elem_type, AddressSpace::Generic);
|
|
|
|
let list_ptr = load_list_ptr(builder, list_wrapper, ptr_type);
|
|
|
|
let list_loop = |index, before_elem| {
|
|
let call_site_value =
|
|
builder.build_call(func_ptr, env.arena.alloc([before_elem]), "map_func");
|
|
|
|
// set the calling convention explicitly for this call
|
|
call_site_value.set_call_convention(crate::llvm::build::FAST_CALL_CONV);
|
|
|
|
let after_elem = call_site_value
|
|
.try_as_basic_value()
|
|
.left()
|
|
.unwrap_or_else(|| panic!("LLVM error: Invalid call by pointer."));
|
|
|
|
// The pointer to the element in the mapped-over list
|
|
let after_elem_ptr = unsafe {
|
|
builder.build_in_bounds_gep(ret_list_ptr, &[index], "load_index_after_list")
|
|
};
|
|
|
|
// Mutate the new array in-place to change the element.
|
|
builder.build_store(after_elem_ptr, after_elem);
|
|
};
|
|
|
|
incrementing_elem_loop(builder, ctx, parent, list_ptr, len, "#index", list_loop);
|
|
|
|
store_list(env, ret_list_ptr, len)
|
|
};
|
|
|
|
if_list_is_not_empty(env, parent, non_empty_fn, list, list_layout, "List.map")
|
|
}
|
|
_ => {
|
|
unreachable!(
|
|
"Invalid function basic value enum or layout for List.map : {:?}",
|
|
(func, func_layout)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// List.concat : List elem, List elem -> List elem
|
|
pub fn list_concat<'a, 'ctx, 'env>(
|
|
env: &Env<'a, 'ctx, 'env>,
|
|
inplace: InPlace,
|
|
parent: FunctionValue<'ctx>,
|
|
first_list: BasicValueEnum<'ctx>,
|
|
second_list: BasicValueEnum<'ctx>,
|
|
list_layout: &Layout<'a>,
|
|
) -> BasicValueEnum<'ctx> {
|
|
let builder = env.builder;
|
|
let ctx = env.context;
|
|
|
|
let second_list_wrapper = second_list.into_struct_value();
|
|
|
|
let second_list_len = list_len(builder, second_list_wrapper);
|
|
|
|
// We only match on the first lists layout
|
|
// because the first and second input lists
|
|
// necessarily have the same layout
|
|
match list_layout {
|
|
Layout::Builtin(Builtin::EmptyList) => empty_list(env),
|
|
Layout::Builtin(Builtin::List(_, elem_layout)) => {
|
|
let first_list_wrapper = first_list.into_struct_value();
|
|
|
|
let first_list_len = list_len(builder, first_list_wrapper);
|
|
|
|
// first_list_len > 0
|
|
// We do this check to avoid allocating memory. If the first input
|
|
// list is empty, then we can just return the second list cloned
|
|
let first_list_length_comparison = list_is_not_empty(env, first_list_len);
|
|
|
|
let if_first_list_is_empty = || {
|
|
// second_list_len > 0
|
|
// We do this check to avoid allocating memory. If the second input
|
|
// list is empty, then we can just return an empty list
|
|
let second_list_length_comparison = list_is_not_empty(env, second_list_len);
|
|
|
|
let build_second_list_then = || {
|
|
let elem_type =
|
|
basic_type_from_layout(env.arena, ctx, elem_layout, env.ptr_bytes);
|
|
let ptr_type = get_ptr_type(&elem_type, AddressSpace::Generic);
|
|
|
|
let (new_wrapper, _) = clone_nonempty_list(
|
|
env,
|
|
inplace,
|
|
second_list_len,
|
|
load_list_ptr(builder, second_list_wrapper, ptr_type),
|
|
elem_layout,
|
|
);
|
|
|
|
BasicValueEnum::StructValue(new_wrapper)
|
|
};
|
|
|
|
let build_second_list_else = || empty_list(env);
|
|
|
|
build_basic_phi2(
|
|
env,
|
|
parent,
|
|
second_list_length_comparison,
|
|
build_second_list_then,
|
|
build_second_list_else,
|
|
BasicTypeEnum::StructType(collection(ctx, env.ptr_bytes)),
|
|
)
|
|
};
|
|
|
|
let if_first_list_is_not_empty = || {
|
|
let elem_type = basic_type_from_layout(env.arena, ctx, elem_layout, env.ptr_bytes);
|
|
let ptr_type = get_ptr_type(&elem_type, AddressSpace::Generic);
|
|
|
|
let if_second_list_is_empty = || {
|
|
let (new_wrapper, _) = clone_nonempty_list(
|
|
env,
|
|
inplace,
|
|
first_list_len,
|
|
load_list_ptr(builder, first_list_wrapper, ptr_type),
|
|
elem_layout,
|
|
);
|
|
|
|
BasicValueEnum::StructValue(new_wrapper)
|
|
};
|
|
|
|
// second_list_len > 0
|
|
// We do this check to avoid allocating memory. If the second input
|
|
// list is empty, then we can just return the first list cloned
|
|
let second_list_length_comparison = list_is_not_empty(env, second_list_len);
|
|
|
|
let if_second_list_is_not_empty = || {
|
|
let combined_list_len =
|
|
builder.build_int_add(first_list_len, second_list_len, "add_list_lengths");
|
|
|
|
let combined_list_ptr =
|
|
allocate_list(env, inplace, elem_layout, combined_list_len);
|
|
|
|
let first_list_ptr = load_list_ptr(builder, first_list_wrapper, ptr_type);
|
|
|
|
// FIRST LOOP
|
|
// TODO when the element type supports it, replace FIRST_LOOP with a memcpy!
|
|
let first_loop = |first_index, first_list_elem| {
|
|
// The pointer to the element in the combined list
|
|
let combined_list_elem_ptr = unsafe {
|
|
builder.build_in_bounds_gep(
|
|
combined_list_ptr,
|
|
&[first_index],
|
|
"load_index_combined_list",
|
|
)
|
|
};
|
|
|
|
// Mutate the new array in-place to change the element.
|
|
builder.build_store(combined_list_elem_ptr, first_list_elem);
|
|
};
|
|
|
|
let index_name = "#index";
|
|
|
|
let index_alloca = incrementing_elem_loop(
|
|
builder,
|
|
ctx,
|
|
parent,
|
|
first_list_ptr,
|
|
first_list_len,
|
|
index_name,
|
|
first_loop,
|
|
);
|
|
|
|
// Reset the index variable to 0
|
|
builder.build_store(index_alloca, ctx.i64_type().const_int(0, false));
|
|
|
|
let second_list_ptr = load_list_ptr(builder, second_list_wrapper, ptr_type);
|
|
|
|
// SECOND LOOP
|
|
// TODO when the element type supports it, replace SECOND_LOOP with a memcpy!
|
|
let second_loop = |second_index, second_list_elem| {
|
|
// The pointer to the element in the combined list.
|
|
// Note that the pointer does not start at the index
|
|
// 0, it starts at the index of first_list_len. In that
|
|
// sense it is "offset".
|
|
let offset_combined_list_elem_ptr = unsafe {
|
|
builder.build_in_bounds_gep(
|
|
combined_list_ptr,
|
|
&[first_list_len],
|
|
"elem",
|
|
)
|
|
};
|
|
|
|
// The pointer to the element from the second list
|
|
// in the combined list
|
|
let combined_list_elem_ptr = unsafe {
|
|
builder.build_in_bounds_gep(
|
|
offset_combined_list_elem_ptr,
|
|
&[second_index],
|
|
"load_index_combined_list",
|
|
)
|
|
};
|
|
|
|
// Mutate the new array in-place to change the element.
|
|
builder.build_store(combined_list_elem_ptr, second_list_elem);
|
|
};
|
|
|
|
incrementing_elem_loop(
|
|
builder,
|
|
ctx,
|
|
parent,
|
|
second_list_ptr,
|
|
second_list_len,
|
|
index_name,
|
|
second_loop,
|
|
);
|
|
|
|
store_list(env, combined_list_ptr, combined_list_len)
|
|
};
|
|
|
|
build_basic_phi2(
|
|
env,
|
|
parent,
|
|
second_list_length_comparison,
|
|
if_second_list_is_not_empty,
|
|
if_second_list_is_empty,
|
|
BasicTypeEnum::StructType(collection(ctx, env.ptr_bytes)),
|
|
)
|
|
};
|
|
|
|
build_basic_phi2(
|
|
env,
|
|
parent,
|
|
first_list_length_comparison,
|
|
if_first_list_is_not_empty,
|
|
if_first_list_is_empty,
|
|
BasicTypeEnum::StructType(collection(ctx, env.ptr_bytes)),
|
|
)
|
|
}
|
|
_ => {
|
|
unreachable!(
|
|
"Invalid List layout for first list in List.concat : {:?}",
|
|
list_layout
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn decrementing_elem_loop<'ctx, LoopFn>(
|
|
builder: &Builder<'ctx>,
|
|
ctx: &'ctx Context,
|
|
parent: FunctionValue<'ctx>,
|
|
ptr: PointerValue<'ctx>,
|
|
len: IntValue<'ctx>,
|
|
index_name: &str,
|
|
mut loop_fn: LoopFn,
|
|
) -> PointerValue<'ctx>
|
|
where
|
|
LoopFn: FnMut(IntValue<'ctx>, BasicValueEnum<'ctx>),
|
|
{
|
|
decrementing_index_loop(builder, ctx, parent, len, index_name, |index| {
|
|
// The pointer to the element in the list
|
|
let elem_ptr = unsafe { builder.build_in_bounds_gep(ptr, &[index], "load_index") };
|
|
|
|
let elem = builder.build_load(elem_ptr, "get_elem");
|
|
|
|
loop_fn(index, elem);
|
|
})
|
|
}
|
|
|
|
// a for-loop from the back to the front
|
|
fn decrementing_index_loop<'ctx, LoopFn>(
|
|
builder: &Builder<'ctx>,
|
|
ctx: &'ctx Context,
|
|
parent: FunctionValue<'ctx>,
|
|
end: IntValue<'ctx>,
|
|
index_name: &str,
|
|
mut loop_fn: LoopFn,
|
|
) -> PointerValue<'ctx>
|
|
where
|
|
LoopFn: FnMut(IntValue<'ctx>),
|
|
{
|
|
// constant 1i64
|
|
let one = ctx.i64_type().const_int(1, false);
|
|
|
|
// allocate a stack slot for the current index
|
|
let index_alloca = builder.build_alloca(ctx.i64_type(), index_name);
|
|
|
|
// we assume `end` is the length of the list
|
|
// the final index is therefore `end - 1`
|
|
let end_index = builder.build_int_sub(end, one, "end_index");
|
|
builder.build_store(index_alloca, end_index);
|
|
|
|
let loop_bb = ctx.append_basic_block(parent, "loop");
|
|
builder.build_unconditional_branch(loop_bb);
|
|
builder.position_at_end(loop_bb);
|
|
|
|
let current_index = builder
|
|
.build_load(index_alloca, index_name)
|
|
.into_int_value();
|
|
let next_index = builder.build_int_sub(current_index, one, "nextindex");
|
|
|
|
builder.build_store(index_alloca, next_index);
|
|
|
|
// The body of the loop
|
|
loop_fn(current_index);
|
|
|
|
// #index >= 0
|
|
let condition = builder.build_int_compare(
|
|
IntPredicate::UGE,
|
|
next_index,
|
|
ctx.i64_type().const_zero(),
|
|
"bounds_check",
|
|
);
|
|
|
|
let after_loop_bb = ctx.append_basic_block(parent, "after_outer_loop");
|
|
|
|
builder.build_conditional_branch(condition, loop_bb, after_loop_bb);
|
|
builder.position_at_end(after_loop_bb);
|
|
|
|
index_alloca
|
|
}
|
|
|
|
pub fn incrementing_elem_loop<'ctx, LoopFn>(
|
|
builder: &Builder<'ctx>,
|
|
ctx: &'ctx Context,
|
|
parent: FunctionValue<'ctx>,
|
|
ptr: PointerValue<'ctx>,
|
|
len: IntValue<'ctx>,
|
|
index_name: &str,
|
|
mut loop_fn: LoopFn,
|
|
) -> PointerValue<'ctx>
|
|
where
|
|
LoopFn: FnMut(IntValue<'ctx>, BasicValueEnum<'ctx>),
|
|
{
|
|
incrementing_index_loop(builder, ctx, parent, len, index_name, |index| {
|
|
// The pointer to the element in the list
|
|
let elem_ptr = unsafe { builder.build_in_bounds_gep(ptr, &[index], "load_index") };
|
|
|
|
let elem = builder.build_load(elem_ptr, "get_elem");
|
|
|
|
loop_fn(index, elem);
|
|
})
|
|
}
|
|
|
|
// This helper simulates a basic for loop, where
|
|
// and index increments up from 0 to some end value
|
|
pub fn incrementing_index_loop<'ctx, LoopFn>(
|
|
builder: &Builder<'ctx>,
|
|
ctx: &'ctx Context,
|
|
parent: FunctionValue<'ctx>,
|
|
end: IntValue<'ctx>,
|
|
index_name: &str,
|
|
mut loop_fn: LoopFn,
|
|
) -> PointerValue<'ctx>
|
|
where
|
|
LoopFn: FnMut(IntValue<'ctx>),
|
|
{
|
|
// constant 1i64
|
|
let one = ctx.i64_type().const_int(1, false);
|
|
|
|
// allocate a stack slot for the current index
|
|
let index_alloca = builder.build_alloca(ctx.i64_type(), index_name);
|
|
builder.build_store(index_alloca, ctx.i64_type().const_zero());
|
|
|
|
let loop_bb = ctx.append_basic_block(parent, "loop");
|
|
builder.build_unconditional_branch(loop_bb);
|
|
builder.position_at_end(loop_bb);
|
|
|
|
let curr_index = builder
|
|
.build_load(index_alloca, index_name)
|
|
.into_int_value();
|
|
let next_index = builder.build_int_add(curr_index, one, "nextindex");
|
|
|
|
builder.build_store(index_alloca, next_index);
|
|
|
|
// The body of the loop
|
|
loop_fn(curr_index);
|
|
|
|
// #index < end
|
|
let loop_end_cond = bounds_check_comparison(builder, next_index, end);
|
|
|
|
let after_loop_bb = ctx.append_basic_block(parent, "after_outer_loop");
|
|
|
|
builder.build_conditional_branch(loop_end_cond, loop_bb, after_loop_bb);
|
|
builder.position_at_end(after_loop_bb);
|
|
|
|
index_alloca
|
|
}
|
|
|
|
// This function checks if the list is empty, and
|
|
// if it is, it returns an empty list, and if not
|
|
// it runs whatever code is passed in under `build_non_empty`
|
|
// This is the avoid allocating memory if the list is empty.
|
|
fn if_list_is_not_empty<'a, 'ctx, 'env, 'b, NonEmptyFn>(
|
|
env: &Env<'a, 'ctx, 'env>,
|
|
parent: FunctionValue<'ctx>,
|
|
mut build_non_empty: NonEmptyFn,
|
|
list: BasicValueEnum<'ctx>,
|
|
list_layout: &Layout<'a>,
|
|
list_fn_name: &str,
|
|
) -> BasicValueEnum<'ctx>
|
|
where
|
|
NonEmptyFn: FnMut(&Layout<'a>, IntValue<'ctx>, StructValue<'ctx>) -> BasicValueEnum<'ctx>,
|
|
{
|
|
match list_layout {
|
|
Layout::Builtin(Builtin::EmptyList) => empty_list(env),
|
|
|
|
Layout::Builtin(Builtin::List(_, elem_layout)) => {
|
|
let builder = env.builder;
|
|
let ctx = env.context;
|
|
|
|
let wrapper_struct = list.into_struct_value();
|
|
|
|
let len = list_len(builder, wrapper_struct);
|
|
|
|
// list_len > 0
|
|
let comparison = builder.build_int_compare(
|
|
IntPredicate::UGT,
|
|
len,
|
|
ctx.i64_type().const_int(0, false),
|
|
"greaterthanzero",
|
|
);
|
|
|
|
let build_empty = || empty_list(env);
|
|
|
|
let struct_type = collection(ctx, env.ptr_bytes);
|
|
|
|
build_basic_phi2(
|
|
env,
|
|
parent,
|
|
comparison,
|
|
|| build_non_empty(elem_layout, len, wrapper_struct),
|
|
build_empty,
|
|
BasicTypeEnum::StructType(struct_type),
|
|
)
|
|
}
|
|
_ => {
|
|
unreachable!("Invalid List layout for {} {:?}", list_fn_name, list_layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn build_basic_phi2<'a, 'ctx, 'env, PassFn, FailFn>(
|
|
env: &Env<'a, 'ctx, 'env>,
|
|
parent: FunctionValue<'ctx>,
|
|
comparison: IntValue<'ctx>,
|
|
mut build_pass: PassFn,
|
|
mut build_fail: FailFn,
|
|
ret_type: BasicTypeEnum<'ctx>,
|
|
) -> BasicValueEnum<'ctx>
|
|
where
|
|
PassFn: FnMut() -> BasicValueEnum<'ctx>,
|
|
FailFn: FnMut() -> BasicValueEnum<'ctx>,
|
|
{
|
|
let builder = env.builder;
|
|
let context = env.context;
|
|
|
|
// build blocks
|
|
let then_block = context.append_basic_block(parent, "then");
|
|
let else_block = context.append_basic_block(parent, "else");
|
|
let cont_block = context.append_basic_block(parent, "branchcont");
|
|
|
|
builder.build_conditional_branch(comparison, then_block, else_block);
|
|
|
|
// build then block
|
|
builder.position_at_end(then_block);
|
|
let then_val = build_pass();
|
|
builder.build_unconditional_branch(cont_block);
|
|
|
|
let then_block = builder.get_insert_block().unwrap();
|
|
|
|
// build else block
|
|
builder.position_at_end(else_block);
|
|
let else_val = build_fail();
|
|
builder.build_unconditional_branch(cont_block);
|
|
|
|
let else_block = builder.get_insert_block().unwrap();
|
|
|
|
// emit merge block
|
|
builder.position_at_end(cont_block);
|
|
|
|
let phi = builder.build_phi(ret_type, "branch");
|
|
|
|
phi.add_incoming(&[(&then_val, then_block), (&else_val, else_block)]);
|
|
|
|
phi.as_basic_value()
|
|
}
|
|
|
|
pub fn empty_polymorphic_list<'a, 'ctx, 'env>(env: &Env<'a, 'ctx, 'env>) -> BasicValueEnum<'ctx> {
|
|
let ctx = env.context;
|
|
|
|
let struct_type = collection(ctx, env.ptr_bytes);
|
|
|
|
// The pointer should be null (aka zero) and the length should be zero,
|
|
// so the whole struct should be a const_zero
|
|
BasicValueEnum::StructValue(struct_type.const_zero())
|
|
}
|
|
|
|
// TODO investigate: does this cause problems when the layout is known? this value is now not refcounted!
|
|
pub fn empty_list<'a, 'ctx, 'env>(env: &Env<'a, 'ctx, 'env>) -> BasicValueEnum<'ctx> {
|
|
let ctx = env.context;
|
|
|
|
let struct_type = collection(ctx, env.ptr_bytes);
|
|
|
|
// The pointer should be null (aka zero) and the length should be zero,
|
|
// so the whole struct should be a const_zero
|
|
BasicValueEnum::StructValue(struct_type.const_zero())
|
|
}
|
|
|
|
pub fn list_is_not_empty<'ctx>(env: &Env<'_, 'ctx, '_>, len: IntValue<'ctx>) -> IntValue<'ctx> {
|
|
env.builder.build_int_compare(
|
|
IntPredicate::UGT,
|
|
len,
|
|
env.ptr_int().const_zero(),
|
|
"list_len_is_nonzero",
|
|
)
|
|
}
|
|
|
|
pub fn load_list<'ctx>(
|
|
builder: &Builder<'ctx>,
|
|
wrapper_struct: StructValue<'ctx>,
|
|
ptr_type: PointerType<'ctx>,
|
|
) -> (IntValue<'ctx>, PointerValue<'ctx>) {
|
|
let ptr_as_int = builder
|
|
.build_extract_value(wrapper_struct, Builtin::WRAPPER_PTR, "read_list_ptr")
|
|
.unwrap()
|
|
.into_int_value();
|
|
|
|
let ptr = builder.build_int_to_ptr(ptr_as_int, ptr_type, "list_cast_ptr");
|
|
|
|
let length = builder
|
|
.build_extract_value(wrapper_struct, Builtin::WRAPPER_LEN, "list_len")
|
|
.unwrap()
|
|
.into_int_value();
|
|
|
|
(length, ptr)
|
|
}
|
|
|
|
pub fn load_list_ptr<'ctx>(
|
|
builder: &Builder<'ctx>,
|
|
wrapper_struct: StructValue<'ctx>,
|
|
ptr_type: PointerType<'ctx>,
|
|
) -> PointerValue<'ctx> {
|
|
let ptr_as_int = builder
|
|
.build_extract_value(wrapper_struct, Builtin::WRAPPER_PTR, "read_list_ptr")
|
|
.unwrap()
|
|
.into_int_value();
|
|
|
|
builder.build_int_to_ptr(ptr_as_int, ptr_type, "list_cast_ptr")
|
|
}
|
|
|
|
pub fn clone_nonempty_list<'a, 'ctx, 'env>(
|
|
env: &Env<'a, 'ctx, 'env>,
|
|
inplace: InPlace,
|
|
list_len: IntValue<'ctx>,
|
|
elems_ptr: PointerValue<'ctx>,
|
|
elem_layout: &Layout<'_>,
|
|
) -> (StructValue<'ctx>, PointerValue<'ctx>) {
|
|
let builder = env.builder;
|
|
let ctx = env.context;
|
|
let ptr_bytes = env.ptr_bytes;
|
|
|
|
// Calculate the number of bytes we'll need to allocate.
|
|
let elem_bytes = env
|
|
.ptr_int()
|
|
.const_int(elem_layout.stack_size(env.ptr_bytes) as u64, false);
|
|
let size = env
|
|
.builder
|
|
.build_int_mul(elem_bytes, list_len, "clone_mul_len_by_elem_bytes");
|
|
|
|
// Allocate space for the new array that we'll copy into.
|
|
let clone_ptr = allocate_list(env, inplace, elem_layout, list_len);
|
|
|
|
let int_type = ptr_int(ctx, ptr_bytes);
|
|
let ptr_as_int = builder.build_ptr_to_int(clone_ptr, int_type, "list_cast_ptr");
|
|
|
|
// TODO check if malloc returned null; if so, runtime error for OOM!
|
|
|
|
// Either memcpy or deep clone the array elements
|
|
if elem_layout.safe_to_memcpy() {
|
|
// Copy the bytes from the original array into the new
|
|
// one we just malloc'd.
|
|
//
|
|
// TODO how do we decide when to do the small memcpy vs the normal one?
|
|
builder
|
|
.build_memcpy(clone_ptr, ptr_bytes, elems_ptr, ptr_bytes, size)
|
|
.unwrap();
|
|
} else {
|
|
panic!("TODO Cranelift currently only knows how to clone list elements that are Copy.");
|
|
}
|
|
|
|
// Create a fresh wrapper struct for the newly populated array
|
|
let struct_type = collection(ctx, env.ptr_bytes);
|
|
let mut struct_val;
|
|
|
|
// Store the pointer
|
|
struct_val = builder
|
|
.build_insert_value(
|
|
struct_type.get_undef(),
|
|
ptr_as_int,
|
|
Builtin::WRAPPER_PTR,
|
|
"insert_ptr",
|
|
)
|
|
.unwrap();
|
|
|
|
// Store the length
|
|
struct_val = builder
|
|
.build_insert_value(struct_val, list_len, Builtin::WRAPPER_LEN, "insert_len")
|
|
.unwrap();
|
|
|
|
let answer = builder
|
|
.build_bitcast(
|
|
struct_val.into_struct_value(),
|
|
collection(ctx, ptr_bytes),
|
|
"cast_collection",
|
|
)
|
|
.into_struct_value();
|
|
|
|
(answer, clone_ptr)
|
|
}
|
|
|
|
pub fn clone_list<'a, 'ctx, 'env>(
|
|
env: &Env<'a, 'ctx, 'env>,
|
|
output_inplace: InPlace,
|
|
elem_layout: &Layout<'a>,
|
|
length: IntValue<'ctx>,
|
|
old_ptr: PointerValue<'ctx>,
|
|
) -> PointerValue<'ctx> {
|
|
let builder = env.builder;
|
|
let ptr_bytes = env.ptr_bytes;
|
|
|
|
// allocate new empty list (with refcount 1)
|
|
let new_ptr = allocate_list(env, output_inplace, elem_layout, length);
|
|
|
|
let stack_size = elem_layout.stack_size(env.ptr_bytes);
|
|
let bytes = builder.build_int_mul(
|
|
length,
|
|
env.context.i64_type().const_int(stack_size as u64, false),
|
|
"size_in_bytes",
|
|
);
|
|
|
|
// copy old elements in
|
|
builder
|
|
.build_memcpy(new_ptr, ptr_bytes, old_ptr, ptr_bytes, bytes)
|
|
.unwrap();
|
|
|
|
new_ptr
|
|
}
|
|
|
|
pub fn allocate_list<'a, 'ctx, 'env>(
|
|
env: &Env<'a, 'ctx, 'env>,
|
|
inplace: InPlace,
|
|
elem_layout: &Layout<'a>,
|
|
length: IntValue<'ctx>,
|
|
) -> PointerValue<'ctx> {
|
|
let builder = env.builder;
|
|
let ctx = env.context;
|
|
|
|
let elem_type = basic_type_from_layout(env.arena, ctx, elem_layout, env.ptr_bytes);
|
|
let elem_bytes = elem_layout.stack_size(env.ptr_bytes) as u64;
|
|
|
|
let len_type = env.ptr_int();
|
|
// bytes per element
|
|
let bytes_len = len_type.const_int(elem_bytes, false);
|
|
let offset = (env.ptr_bytes as u64).max(elem_bytes);
|
|
|
|
let ptr = {
|
|
let len = builder.build_int_mul(bytes_len, length, "data_length");
|
|
let len =
|
|
builder.build_int_add(len, len_type.const_int(offset, false), "add_refcount_space");
|
|
|
|
env.builder
|
|
.build_array_malloc(ctx.i8_type(), len, "create_list_ptr")
|
|
.unwrap()
|
|
|
|
// TODO check if malloc returned null; if so, runtime error for OOM!
|
|
};
|
|
|
|
// We must return a pointer to the first element:
|
|
let ptr_bytes = env.ptr_bytes;
|
|
let int_type = ptr_int(ctx, ptr_bytes);
|
|
let ptr_as_int = builder.build_ptr_to_int(ptr, int_type, "list_cast_ptr");
|
|
let incremented = builder.build_int_add(
|
|
ptr_as_int,
|
|
ctx.i64_type().const_int(offset, false),
|
|
"increment_list_ptr",
|
|
);
|
|
|
|
let ptr_type = get_ptr_type(&elem_type, AddressSpace::Generic);
|
|
let list_element_ptr = builder.build_int_to_ptr(incremented, ptr_type, "list_cast_ptr");
|
|
|
|
// subtract ptr_size, to access the refcount
|
|
let refcount_ptr = builder.build_int_sub(
|
|
incremented,
|
|
ctx.i64_type().const_int(env.ptr_bytes as u64, false),
|
|
"refcount_ptr",
|
|
);
|
|
|
|
let refcount_ptr = builder.build_int_to_ptr(
|
|
refcount_ptr,
|
|
int_type.ptr_type(AddressSpace::Generic),
|
|
"make ptr",
|
|
);
|
|
|
|
let ref_count_one = match inplace {
|
|
InPlace::InPlace => length,
|
|
InPlace::Clone => {
|
|
// the refcount of a new list is initially 1
|
|
// we assume that the list is indeed used (dead variables are eliminated)
|
|
crate::llvm::refcounting::refcount_1(ctx, env.ptr_bytes)
|
|
}
|
|
};
|
|
|
|
builder.build_store(refcount_ptr, ref_count_one);
|
|
|
|
list_element_ptr
|
|
}
|
|
|
|
pub fn store_list<'a, 'ctx, 'env>(
|
|
env: &Env<'a, 'ctx, 'env>,
|
|
list_ptr: PointerValue<'ctx>,
|
|
len: IntValue<'ctx>,
|
|
) -> BasicValueEnum<'ctx> {
|
|
let ctx = env.context;
|
|
let builder = env.builder;
|
|
|
|
let ptr_bytes = env.ptr_bytes;
|
|
let int_type = ptr_int(ctx, ptr_bytes);
|
|
let ptr_as_int = builder.build_ptr_to_int(list_ptr, int_type, "list_cast_ptr");
|
|
let struct_type = collection(ctx, ptr_bytes);
|
|
|
|
let mut struct_val;
|
|
|
|
// Store the pointer
|
|
struct_val = builder
|
|
.build_insert_value(
|
|
struct_type.get_undef(),
|
|
ptr_as_int,
|
|
Builtin::WRAPPER_PTR,
|
|
"insert_ptr",
|
|
)
|
|
.unwrap();
|
|
|
|
// Store the length
|
|
struct_val = builder
|
|
.build_insert_value(struct_val, len, Builtin::WRAPPER_LEN, "insert_len")
|
|
.unwrap();
|
|
|
|
builder.build_bitcast(
|
|
struct_val.into_struct_value(),
|
|
collection(ctx, ptr_bytes),
|
|
"cast_collection",
|
|
)
|
|
}
|