language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-08-04 20:28:02 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7

Remove unused args from lowlevel helpers

Browse source
This commit is contained in:
Brian Carroll 2023-11-05 23:45:29 +00:00
parent 84a230a2e5
commit 87ef10a4e5
No known key found for this signature in database
GPG key ID: 5C7B2EC4101703C0
2 changed files with 25 additions and 44 deletions
Download patch file Download diff file Expand all files Collapse all files

25
crates/compiler/gen_wasm/src/backend.rs
View file

@ -525,7 +525,6 @@ impl<'a, 'r> WasmBackend<'a, 'r> {
x => internal_error!("Higher-order wrapper: invalid return layout {:?}", x),
};
let mut n_inner_wasm_args = 0;
let ret_type_and_size = match inner_ret_layout.return_method() {
ReturnMethod::NoReturnValue => None,
ReturnMethod::Primitive(ty, size) => {
@ -537,7 +536,6 @@ impl<'a, 'r> WasmBackend<'a, 'r> {
ReturnMethod::WriteToPointerArg => {
// If the inner function writes to a return pointer, load its address
self.code_builder.get_local(heap_return_ptr_id);
n_inner_wasm_args += 1;
None
}
};
@ -559,7 +557,6 @@ impl<'a, 'r> WasmBackend<'a, 'r> {
}
// Load the argument pointer. If it's a primitive value, dereference it too.
n_inner_wasm_args += 1;
self.code_builder.get_local(LocalId(i as u32));
self.dereference_boxed_value(inner_layout);
}
@ -586,7 +583,6 @@ impl<'a, 'r> WasmBackend<'a, 'r> {
// Call the wrapped inner function
let inner_wasm_fn_index = self.fn_index_offset + inner_lookup_idx as u32;
let has_return_val = ret_type_and_size.is_some();
self.code_builder.call(inner_wasm_fn_index);
// If the inner function returns a primitive, store it to the address we loaded at the very beginning
@ -637,10 +633,8 @@ impl<'a, 'r> WasmBackend<'a, 'r> {
let closure_data_layout = wrapper_proc_layout.arguments[0];
let value_layout = wrapper_proc_layout.arguments[1];
let mut n_inner_args = 2;
if self.layout_interner.stack_size(closure_data_layout) > 0 {
self.code_builder.get_local(LocalId(0));
n_inner_args += 1;
}
let inner_layout = match self.layout_interner.get_repr(value_layout) {
@ -1017,7 +1011,7 @@ impl<'a, 'r> WasmBackend<'a, 'r> {
// push the allocation's alignment
self.code_builder.i32_const(alignment as i32);
self.call_host_fn_after_loading_args(bitcode::UTILS_FREE_DATA_PTR, 2, false);
self.call_host_fn_after_loading_args(bitcode::UTILS_FREE_DATA_PTR);
self.stmt(following);
}
@ -1047,7 +1041,7 @@ impl<'a, 'r> WasmBackend<'a, 'r> {
// load the pointer
self.storage.load_symbols(&mut self.code_builder, &[msg]);
self.code_builder.i32_const(tag as _);
self.call_host_fn_after_loading_args("roc_panic", 2, false);
self.call_host_fn_after_loading_args("roc_panic");
self.code_builder.unreachable_();
}
@ -1334,14 +1328,14 @@ impl<'a, 'r> WasmBackend<'a, 'r> {
} => {
let name = foreign_symbol.as_str();
let wasm_layout = WasmLayout::new(self.layout_interner, *ret_layout);
let (num_wasm_args, has_return_val) = self.storage.load_symbols_for_call(
self.storage.load_symbols_for_call(
self.env.arena,
&mut self.code_builder,
arguments,
ret_sym,
&wasm_layout,
);
self.call_host_fn_after_loading_args(name, num_wasm_args, has_return_val)
self.call_host_fn_after_loading_args(name)
}
}
}
@ -1364,7 +1358,7 @@ impl<'a, 'r> WasmBackend<'a, 'r> {
return self.expr_call_low_level(lowlevel, arguments, ret_sym, ret_layout, ret_storage);
}
let (num_wasm_args, has_return_val) = self.storage.load_symbols_for_call(
self.storage.load_symbols_for_call(
self.env.arena,
&mut self.code_builder,
arguments,
@ -1410,12 +1404,7 @@ impl<'a, 'r> WasmBackend<'a, 'r> {
}
/// Generate a call instruction to a host function or Zig builtin.
pub fn call_host_fn_after_loading_args(
&mut self,
name: &str,
num_wasm_args: usize,
has_return_val: bool,
) {
pub fn call_host_fn_after_loading_args(&mut self, name: &str) {
let (_, fn_index) = self
.host_lookup
.iter()
@ -2002,7 +1991,7 @@ impl<'a, 'r> WasmBackend<'a, 'r> {
self.code_builder.i32_const(alignment_bytes as i32);
// Call the foreign function. (Zig and C calling conventions are the same for this signature)
self.call_host_fn_after_loading_args("roc_alloc", 2, true);
self.call_host_fn_after_loading_args("roc_alloc");
// Save the allocation address to a temporary local variable
let local_id = self.storage.create_anonymous_local(ValueType::I32);

44
crates/compiler/gen_wasm/src/low_level.rs
View file

@ -134,19 +134,19 @@ impl<'a> LowLevelCall<'a> {
/// For numerical ops, this just pushes the arguments to the Wasm VM's value stack
/// It implements the calling convention used by Zig for both numbers and structs
/// Result is the type signature of the call
fn load_args(&self, backend: &mut WasmBackend<'a, '_>) -> (usize, bool) {
fn load_args(&self, backend: &mut WasmBackend<'a, '_>) {
backend.storage.load_symbols_for_call(
backend.env.arena,
&mut backend.code_builder,
self.arguments,
self.ret_symbol,
&WasmLayout::new(backend.layout_interner, self.ret_layout),
)
);
}
fn load_args_and_call_zig(&self, backend: &mut WasmBackend<'a, '_>, name: &'a str) {
let (num_wasm_args, has_return_val) = self.load_args(backend);
backend.call_host_fn_after_loading_args(name, num_wasm_args, has_return_val);
self.load_args(backend);
backend.call_host_fn_after_loading_args(name);
}
/// Wrap an integer that should have less than 32 bits, but is represented in Wasm as i32.
@ -255,7 +255,7 @@ impl<'a> LowLevelCall<'a> {
&WasmLayout::new(backend.layout_interner, self.ret_layout),
);
backend.code_builder.i32_const(UPDATE_MODE_IMMUTABLE);
backend.call_host_fn_after_loading_args(bitcode::STR_FROM_UTF8_RANGE, 5, false);
backend.call_host_fn_after_loading_args(bitcode::STR_FROM_UTF8_RANGE);
}
StrTrimStart => self.load_args_and_call_zig(backend, bitcode::STR_TRIM_START),
StrTrimEnd => self.load_args_and_call_zig(backend, bitcode::STR_TRIM_END),
@ -434,7 +434,7 @@ impl<'a> LowLevelCall<'a> {
}
// There is an in-place version of this but we don't use it for dev backends. No morphic_lib analysis.
backend.call_host_fn_after_loading_args(bitcode::LIST_REPLACE, 7, false);
backend.call_host_fn_after_loading_args(bitcode::LIST_REPLACE);
}
ListWithCapacity => {
// List.withCapacity : Nat -> List elem
@ -457,7 +457,7 @@ impl<'a> LowLevelCall<'a> {
backend.code_builder.i32_const(elem_align as i32);
backend.code_builder.i32_const(elem_width as i32);
backend.call_host_fn_after_loading_args(bitcode::LIST_WITH_CAPACITY, 4, false);
backend.call_host_fn_after_loading_args(bitcode::LIST_WITH_CAPACITY);
}
ListConcat => {
// List.concat : List elem, List elem -> List elem
@ -485,7 +485,7 @@ impl<'a> LowLevelCall<'a> {
backend.code_builder.i32_const(elem_align as i32);
backend.code_builder.i32_const(elem_width as i32);
backend.call_host_fn_after_loading_args(bitcode::LIST_CONCAT, 5, false);
backend.call_host_fn_after_loading_args(bitcode::LIST_CONCAT);
}
ListReserve => {
@ -526,7 +526,7 @@ impl<'a> LowLevelCall<'a> {
backend.code_builder.i32_const(UPDATE_MODE_IMMUTABLE);
backend.call_host_fn_after_loading_args(bitcode::LIST_RESERVE, 6, false);
backend.call_host_fn_after_loading_args(bitcode::LIST_RESERVE);
}
ListReleaseExcessCapacity => {
@ -561,11 +561,7 @@ impl<'a> LowLevelCall<'a> {
backend.code_builder.i32_const(UPDATE_MODE_IMMUTABLE);
backend.call_host_fn_after_loading_args(
bitcode::LIST_RELEASE_EXCESS_CAPACITY,
5,
false,
);
backend.call_host_fn_after_loading_args(bitcode::LIST_RELEASE_EXCESS_CAPACITY);
}
ListAppendUnsafe => {
@ -602,7 +598,7 @@ impl<'a> LowLevelCall<'a> {
backend.code_builder.i32_const(elem_width as i32);
backend.call_host_fn_after_loading_args(bitcode::LIST_APPEND_UNSAFE, 3, false);
backend.call_host_fn_after_loading_args(bitcode::LIST_APPEND_UNSAFE);
}
ListPrepend => {
// List.prepend : List elem, elem -> List elem
@ -642,7 +638,7 @@ impl<'a> LowLevelCall<'a> {
}
backend.code_builder.i32_const(elem_width as i32);
backend.call_host_fn_after_loading_args(bitcode::LIST_PREPEND, 5, false);
backend.call_host_fn_after_loading_args(bitcode::LIST_PREPEND);
}
ListSublist => {
// As a low-level, record is destructured
@ -692,7 +688,7 @@ impl<'a> LowLevelCall<'a> {
.load_symbols(&mut backend.code_builder, &[start, len]);
backend.code_builder.i32_const(dec_fn_ptr);
backend.call_host_fn_after_loading_args(bitcode::LIST_SUBLIST, 7, false);
backend.call_host_fn_after_loading_args(bitcode::LIST_SUBLIST);
}
ListDropAt => {
// List.dropAt : List elem, Nat -> List elem
@ -739,7 +735,7 @@ impl<'a> LowLevelCall<'a> {
.load_symbols(&mut backend.code_builder, &[drop_index]);
backend.code_builder.i32_const(dec_fn_ptr);
backend.call_host_fn_after_loading_args(bitcode::LIST_DROP_AT, 5, false);
backend.call_host_fn_after_loading_args(bitcode::LIST_DROP_AT);
}
ListSwap => {
// List.swap : List elem, Nat, Nat -> List elem
@ -777,7 +773,7 @@ impl<'a> LowLevelCall<'a> {
.load_symbols(&mut backend.code_builder, &[index_1, index_2]);
backend.code_builder.i32_const(UPDATE_MODE_IMMUTABLE);
backend.call_host_fn_after_loading_args(bitcode::LIST_SWAP, 7, false);
backend.call_host_fn_after_loading_args(bitcode::LIST_SWAP);
}
// Num
@ -2707,7 +2703,7 @@ pub fn call_higher_order_lowlevel<'a>(
cb.i32_const(alignment as i32);
cb.i32_const(element_width as i32);
backend.call_host_fn_after_loading_args(bitcode::LIST_SORT_WITH, 8, false);
backend.call_host_fn_after_loading_args(bitcode::LIST_SORT_WITH);
}
}
}
@ -2772,7 +2768,7 @@ fn list_map_n<'a>(
cb.i32_const(elem_ret_size as i32);
// If we have lists of different lengths, we may need to decrement
let num_wasm_args = if arg_elem_layouts.len() > 1 {
if arg_elem_layouts.len() > 1 {
for el in arg_elem_layouts.iter() {
// The dec function will be passed a pointer to the element within the list, not the element itself!
// Here we wrap the layout in a Struct to ensure we get the right code gen
@ -2783,13 +2779,9 @@ fn list_map_n<'a>(
let ptr = backend.get_fn_ptr(idx);
backend.code_builder.i32_const(ptr);
}
7 + arg_elem_layouts.len() * 3
} else {
9
};
let has_return_val = false;
backend.call_host_fn_after_loading_args(zig_fn_name, num_wasm_args, has_return_val);
backend.call_host_fn_after_loading_args(zig_fn_name);
}
fn ensure_symbol_is_in_memory<'a>(