language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-10-01 07:41:12 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Merge branch 'trunk' into gen-dev/mem

Browse source
This commit is contained in:
Brendan Hansknecht 2021-09-05 21:31:05 -07:00 • committed by GitHub
commit 08aa3d31d4
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
32 changed files with 652 additions and 428 deletions
Download patch file Download diff file Expand all files Collapse all files

30
Cargo.lock generated
View file

@ -2570,6 +2570,12 @@ dependencies = [
"syn 1.0.72",
]
[[package]]
name = "parity-wasm"
version = "0.42.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "be5e13c266502aadf83426d87d81a0f5d1ef45b8027f5a471c360abfe4bfae92"
[[package]]
name = "parking_lot"
version = "0.11.1"
@ -3642,6 +3648,29 @@ dependencies = [
"tokio",
]
[[package]]
name = "roc_gen_wasm"
version = "0.1.0"
dependencies = [
"bumpalo",
"indoc 0.3.6",
"libc",
"parity-wasm",
"pretty_assertions 0.5.1",
"roc_builtins",
"roc_can",
"roc_collections",
"roc_load",
"roc_module",
"roc_mono",
"roc_std",
"roc_types",
"target-lexicon",
"tempfile",
"wasmer",
"wasmer-wasi",
]
[[package]]
name = "roc_ident"
version = "0.1.0"
@ -4348,6 +4377,7 @@ dependencies = [
"roc_collections",
"roc_constrain",
"roc_gen_llvm",
"roc_gen_wasm",
"roc_load",
"roc_module",
"roc_mono",

1
Cargo.toml
View file

@ -20,6 +20,7 @@ members = [
"compiler/load",
"compiler/gen_llvm",
"compiler/gen_dev",
"compiler/gen_wasm",
"compiler/build",
"compiler/arena_pool",
"compiler/test_gen",

4
Earthfile
View file

@ -75,6 +75,10 @@ test-rust:
RUN echo "4" | cargo run --release examples/benchmarks/NQueens.roc
RUN --mount=type=cache,target=$SCCACHE_DIR \
cargo test --release && sccache --show-stats
# run i386 (32-bit linux) cli tests
RUN echo "4" | cargo run --release -- --backend=x86_32 examples/benchmarks/NQueens.roc
RUN --mount=type=cache,target=$SCCACHE_DIR \
cargo test --release --test cli_run i386 --features="i386-cli-run" && sccache --show-stats
verify-no-git-changes:
FROM +test-rust

3
cli/Cargo.toml
View file

@ -16,7 +16,8 @@ bench = false
[features]
default = ["target-x86", "llvm", "editor"]
wasm-cli-run = []
wasm32-cli-run = []
i386-cli-run = []
# This is a separate feature because when we generate docs on Netlify,
# it doesn't have LLVM installed. (Also, it doesn't need to do code gen.)

51
cli/tests/cli_run.rs
View file

@ -108,7 +108,7 @@ mod cli_run {
assert!(out.status.success());
}
#[cfg(feature = "wasm-cli-run")]
#[cfg(feature = "wasm32-cli-run")]
fn check_wasm_output_with_stdin(
file: &Path,
stdin: &[&str],
@ -117,7 +117,7 @@ mod cli_run {
expected_ending: &str,
) {
let mut flags = flags.to_vec();
flags.push("--backend=wasm");
flags.push("--backend=wasm32");
let compile_out = run_roc(&[&["build", file.to_str().unwrap()], flags.as_slice()].concat());
if !compile_out.stderr.is_empty() {
@ -315,8 +315,8 @@ mod cli_run {
)*
#[cfg(feature = "wasm-cli-run")]
mod wasm {
#[cfg(feature = "wasm32-cli-run")]
mod wasm32 {
use super::*;
$(
#[test]
@ -354,6 +354,47 @@ mod cli_run {
)*
}
#[cfg(feature = "i386-cli-run")]
mod i386 {
use super::*;
$(
#[test]
#[cfg_attr(not(debug_assertions), serial(benchmark))]
fn $test_name() {
let benchmark = $benchmark;
let file_name = examples_dir("benchmarks").join(benchmark.filename);
// TODO fix QuicksortApp and then remove this!
match benchmark.filename {
"QuicksortApp.roc" => {
eprintln!("WARNING: skipping testing benchmark {} because the test is broken right now!", benchmark.filename);
return;
}
_ => {}
}
// Check with and without optimizations
check_output_with_stdin(
&file_name,
benchmark.stdin,
benchmark.executable_filename,
&["--backend=x86_32"],
benchmark.expected_ending,
benchmark.use_valgrind,
);
check_output_with_stdin(
&file_name,
benchmark.stdin,
benchmark.executable_filename,
&["--backend=x86_32", "--optimize"],
benchmark.expected_ending,
benchmark.use_valgrind,
);
}
)*
}
#[test]
#[cfg(not(debug_assertions))]
fn all_benchmarks_have_tests() {
@ -562,7 +603,7 @@ mod cli_run {
}
}
#[cfg(feature = "wasm-cli-run")]
#[cfg(feature = "wasm32-cli-run")]
fn run_with_wasmer(wasm_path: &std::path::Path, stdin: &[&str]) -> String {
use std::io::Write;
use wasmer::{Instance, Module, Store};

2
compiler/build/src/link.rs
View file

@ -262,7 +262,7 @@ pub fn rebuild_host(target: &Triple, host_input_path: &Path) {
&emit_bin,
zig_host_src.to_str().unwrap(),
zig_str_path.to_str().unwrap(),
"i386-linux-gnu",
"i386-linux-musl",
)
}
_ => panic!("Unsupported architecture {:?}", target.architecture),

8
compiler/builtins/bitcode/src/utils.zig
View file

@ -208,13 +208,7 @@ pub fn unsafeReallocate(
new_length: usize,
element_width: usize,
) [*]u8 {
const align_width: usize = blk: {
if (alignment > 8) {
break :blk (2 * @sizeOf(usize));
} else {
break :blk @sizeOf(usize);
}
};
const align_width: usize = std.math.max(alignment, @sizeOf(usize));
const old_width = align_width + old_length * element_width;
const new_width = align_width + new_length * element_width;

10
compiler/gen_dev/src/lib.rs
View file

@ -8,7 +8,9 @@ use roc_collections::all::{MutMap, MutSet};
use roc_module::ident::{ModuleName, TagName};
use roc_module::low_level::LowLevel;
use roc_module::symbol::{Interns, Symbol};
use roc_mono::ir::{BranchInfo, CallType, Expr, JoinPointId, Literal, Proc, Stmt};
use roc_mono::ir::{
BranchInfo, CallType, Expr, JoinPointId, ListLiteralElement, Literal, Proc, Stmt,
};
use roc_mono::layout::{Builtin, Layout, LayoutIds};
use target_lexicon::Triple;
@ -150,7 +152,7 @@ where
match expr {
Expr::Literal(lit) => {
if self.env().lazy_literals {
self.literal_map().insert(*sym, lit.clone());
self.literal_map().insert(*sym, *lit);
} else {
self.load_literal(sym, lit)?;
}
@ -618,10 +620,12 @@ where
owning_symbol.insert(*sym, *structure);
}
Expr::Array { elems, .. } => {
for sym in *elems {
for elem in *elems {
if let ListLiteralElement::Symbol(sym) = elem {
self.set_last_seen(*sym, stmt, &owning_symbol);
}
}
}
Expr::Reuse {
symbol,
arguments,

155
compiler/gen_llvm/src/llvm/build.rs
View file

@ -51,7 +51,10 @@ use roc_builtins::bitcode;
use roc_collections::all::{ImMap, MutMap, MutSet};
use roc_module::low_level::LowLevel;
use roc_module::symbol::{Interns, ModuleId, Symbol};
use roc_mono::ir::{BranchInfo, CallType, EntryPoint, JoinPointId, ModifyRc, OptLevel, ProcLayout};
use roc_mono::ir::{
BranchInfo, CallType, EntryPoint, JoinPointId, ListLiteralElement, ModifyRc, OptLevel,
ProcLayout,
};
use roc_mono::layout::{Builtin, LambdaSet, Layout, LayoutIds, UnionLayout};
use target_lexicon::{Architecture, OperatingSystem, Triple};
@ -2157,57 +2160,141 @@ fn list_literal<'a, 'ctx, 'env>(
env: &Env<'a, 'ctx, 'env>,
scope: &Scope<'a, 'ctx>,
elem_layout: &Layout<'a>,
elems: &&[Symbol],
elems: &[ListLiteralElement],
) -> BasicValueEnum<'ctx> {
let ctx = env.context;
let builder = env.builder;
let len_u64 = elems.len() as u64;
let element_type = basic_type_from_layout(env, elem_layout);
let ptr = {
let len_type = env.ptr_int();
let len = len_type.const_int(len_u64, false);
let list_length = elems.len();
let list_length_intval = env.ptr_int().const_int(list_length as _, false);
allocate_list(env, elem_layout, len)
};
if element_type.is_int_type() {
let element_type = element_type.into_int_type();
let element_width = elem_layout.stack_size(env.ptr_bytes);
let size = list_length * element_width as usize;
let alignment = elem_layout
.alignment_bytes(env.ptr_bytes)
.max(env.ptr_bytes);
let mut is_all_constant = true;
let zero_elements = (env.ptr_bytes as f64 / element_width as f64).ceil() as usize;
// runtime-evaluated elements
let mut runtime_evaluated_elements = Vec::with_capacity_in(list_length, env.arena);
// set up a global that contains all the literal elements of the array
// any variables or expressions are represented as `undef`
let global = {
let mut global_elements = Vec::with_capacity_in(list_length, env.arena);
// insert NULL bytes for the refcount
// these elements are (dropped again if the list contains non-constants)
for _ in 0..zero_elements {
global_elements.push(element_type.const_zero());
}
// Copy the elements from the list literal into the array
for (index, symbol) in elems.iter().enumerate() {
for (index, element) in elems.iter().enumerate() {
match element {
ListLiteralElement::Literal(literal) => {
let val = build_exp_literal(env, elem_layout, literal);
global_elements.push(val.into_int_value());
}
ListLiteralElement::Symbol(symbol) => {
let val = load_symbol(scope, symbol);
let intval = val.into_int_value();
if intval.is_const() {
global_elements.push(intval);
} else {
is_all_constant = false;
runtime_evaluated_elements.push((index, val));
global_elements.push(element_type.get_undef());
}
}
};
}
let const_elements = if is_all_constant {
global_elements.into_bump_slice()
} else {
&global_elements[zero_elements..]
};
// use None for the address space (e.g. Const does not work)
let typ = element_type.array_type(const_elements.len() as u32);
let global = env.module.add_global(typ, None, "roc__list_literal");
global.set_constant(true);
global.set_alignment(alignment);
global.set_unnamed_addr(true);
global.set_linkage(inkwell::module::Linkage::Private);
global.set_initializer(&element_type.const_array(const_elements));
global.as_pointer_value()
};
if is_all_constant {
// all elements are constants, so we can use the memory in the constants section directly
// here we make a pointer to the first actual element (skipping the 0 bytes that
// represent the refcount)
let zero = env.ptr_int().const_zero();
let offset = env.ptr_int().const_int(zero_elements as _, false);
let ptr = unsafe {
env.builder
.build_in_bounds_gep(global, &[zero, offset], "first_element_pointer")
};
super::build_list::store_list(env, ptr, list_length_intval)
} else {
// some of our elements are non-constant, so we must allocate space on the heap
let ptr = allocate_list(env, elem_layout, list_length_intval);
// then, copy the relevant segment from the constant section into the heap
env.builder
.build_memcpy(
ptr,
alignment,
global,
alignment,
env.ptr_int().const_int(size as _, false),
)
.unwrap();
// then replace the `undef`s with the values that we evaluate at runtime
for (index, val) in runtime_evaluated_elements {
let index_val = ctx.i64_type().const_int(index as u64, false);
let elem_ptr = unsafe { builder.build_in_bounds_gep(ptr, &[index_val], "index") };
builder.build_store(elem_ptr, val);
}
let u8_ptr_type = ctx.i8_type().ptr_type(AddressSpace::Generic);
let generic_ptr = builder.build_bitcast(ptr, u8_ptr_type, "to_generic_ptr");
super::build_list::store_list(env, ptr, list_length_intval)
}
} else {
let ptr = allocate_list(env, elem_layout, list_length_intval);
let struct_type = super::convert::zig_list_type(env);
let len = BasicValueEnum::IntValue(env.ptr_int().const_int(len_u64, false));
let mut struct_val;
// Copy the elements from the list literal into the array
for (index, element) in elems.iter().enumerate() {
let val = match element {
ListLiteralElement::Literal(literal) => {
build_exp_literal(env, elem_layout, literal)
}
ListLiteralElement::Symbol(symbol) => load_symbol(scope, symbol),
};
let index_val = ctx.i64_type().const_int(index as u64, false);
let elem_ptr = unsafe { builder.build_in_bounds_gep(ptr, &[index_val], "index") };
// Store the pointer
struct_val = builder
.build_insert_value(
struct_type.get_undef(),
generic_ptr,
Builtin::WRAPPER_PTR,
"insert_ptr_list_literal",
)
.unwrap();
builder.build_store(elem_ptr, val);
}
// Store the length
struct_val = builder
.build_insert_value(struct_val, len, Builtin::WRAPPER_LEN, "insert_len")
.unwrap();
// Bitcast to an array of raw bytes
builder.build_bitcast(
struct_val.into_struct_value(),
super::convert::zig_list_type(env),
"cast_collection",
)
super::build_list::store_list(env, ptr, list_length_intval)
}
}
fn decrement_with_size_check<'a, 'ctx, 'env>(

29
compiler/gen_wasm/Cargo.toml Normal file
View file

@ -0,0 +1,29 @@
[package]
name = "roc_gen_wasm"
version = "0.1.0"
edition = "2018"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
roc_collections = { path = "../collections" }
roc_module = { path = "../module" }
roc_mono = { path = "../mono" }
bumpalo = { version = "3.6.1", features = ["collections"] }
parity-wasm = "0.42"
roc_std = { path = "../../roc_std" }
wasmer = "2.0.0"
wasmer-wasi = "2.0.0"
[dev-dependencies]
roc_can = { path = "../can" }
roc_builtins = { path = "../builtins" }
roc_load = { path = "../load" }
roc_types = { path = "../types" }
roc_module = { path = "../module" }
indoc = "0.3.3"
pretty_assertions = "0.5.1"
libc = "0.2"
target-lexicon = "0.12.2"
tempfile = "3.1.0"

210
compiler/gen_wasm/src/from_wasm32_memory.rs Normal file
View file

@ -0,0 +1,210 @@
use roc_std::{RocDec, RocList, RocOrder, RocStr};
pub trait FromWasm32Memory: Sized {
const SIZE_OF_WASM: usize;
const ALIGN_OF_WASM: usize;
const ACTUAL_WIDTH: usize = if (Self::SIZE_OF_WASM % Self::ALIGN_OF_WASM) == 0 {
Self::SIZE_OF_WASM
} else {
Self::SIZE_OF_WASM + (Self::ALIGN_OF_WASM - (Self::SIZE_OF_WASM % Self::ALIGN_OF_WASM))
};
fn decode(memory: &wasmer::Memory, offset: u32) -> Self;
}
macro_rules! from_wasm_memory_primitive_decode {
($type_name:ident) => {
const SIZE_OF_WASM: usize = core::mem::size_of::<$type_name>();
const ALIGN_OF_WASM: usize = core::mem::align_of::<$type_name>();
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
use core::mem::MaybeUninit;
let mut output: MaybeUninit<Self> = MaybeUninit::uninit();
let width = std::mem::size_of::<Self>();
let ptr = output.as_mut_ptr();
let raw_ptr = ptr as *mut u8;
let slice = unsafe { std::slice::from_raw_parts_mut(raw_ptr, width) };
let ptr: wasmer::WasmPtr<u8, wasmer::Array> = wasmer::WasmPtr::new(offset as u32);
let foobar = (ptr.deref(memory, 0, width as u32)).unwrap();
let wasm_slice = unsafe { std::mem::transmute(foobar) };
slice.copy_from_slice(wasm_slice);
unsafe { output.assume_init() }
}
};
}
macro_rules! from_wasm_memory_primitive {
($($type_name:ident ,)+) => {
$(
impl FromWasm32Memory for $type_name {
from_wasm_memory_primitive_decode!($type_name);
}
)*
}
}
from_wasm_memory_primitive!(
u8, i8, u16, i16, u32, i32, u64, i64, u128, i128, f32, f64, bool, RocDec, RocOrder,
);
impl FromWasm32Memory for () {
const SIZE_OF_WASM: usize = 0;
const ALIGN_OF_WASM: usize = 0;
fn decode(_: &wasmer::Memory, _: u32) -> Self {}
}
impl FromWasm32Memory for RocStr {
const SIZE_OF_WASM: usize = 8;
const ALIGN_OF_WASM: usize = 4;
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
let bytes = <u64 as FromWasm32Memory>::decode(memory, offset);
let length = (bytes >> 32) as u32;
let elements = bytes as u32;
if length == 0 {
RocStr::default()
} else if (length as i32) < 0 {
// this is a small string
let last_byte = bytes.to_ne_bytes()[7];
let actual_length = (last_byte ^ 0b1000_0000) as usize;
let slice = &bytes.to_ne_bytes()[..actual_length as usize];
RocStr::from_slice(slice)
} else {
// this is a big string
let ptr: wasmer::WasmPtr<u8, wasmer::Array> = wasmer::WasmPtr::new(elements);
let foobar = (ptr.deref(memory, 0, length)).unwrap();
let wasm_slice = unsafe { std::mem::transmute(foobar) };
RocStr::from_slice(wasm_slice)
}
}
}
impl<T: FromWasm32Memory + Clone> FromWasm32Memory for RocList<T> {
const SIZE_OF_WASM: usize = 8;
const ALIGN_OF_WASM: usize = 4;
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
let bytes = <u64 as FromWasm32Memory>::decode(memory, offset);
let length = (bytes >> 32) as u32;
let elements = bytes as u32;
let mut items = Vec::with_capacity(length as usize);
for i in 0..length {
let item = <T as FromWasm32Memory>::decode(
memory,
elements + i * <T as FromWasm32Memory>::SIZE_OF_WASM as u32,
);
items.push(item);
}
RocList::from_slice(&items)
}
}
impl<T: FromWasm32Memory> FromWasm32Memory for &'_ T {
const SIZE_OF_WASM: usize = 4;
const ALIGN_OF_WASM: usize = 4;
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
let elements = <u32 as FromWasm32Memory>::decode(memory, offset);
let actual = <T as FromWasm32Memory>::decode(memory, elements);
let b = Box::new(actual);
std::boxed::Box::<T>::leak(b)
}
}
impl<T: FromWasm32Memory + Clone, const N: usize> FromWasm32Memory for [T; N] {
const SIZE_OF_WASM: usize = N * T::SIZE_OF_WASM;
const ALIGN_OF_WASM: usize = T::ALIGN_OF_WASM;
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
let ptr: wasmer::WasmPtr<u8, wasmer::Array> = wasmer::WasmPtr::new(offset);
let width = <T as FromWasm32Memory>::SIZE_OF_WASM as u32 * N as u32;
let foobar = (ptr.deref(memory, 0, width)).unwrap();
let wasm_slice: &[T; N] = unsafe { &*(foobar as *const _ as *const [T; N]) };
wasm_slice.clone()
}
}
impl FromWasm32Memory for usize {
const SIZE_OF_WASM: usize = 4;
const ALIGN_OF_WASM: usize = 4;
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
<u32 as FromWasm32Memory>::decode(memory, offset) as usize
}
}
impl<T: FromWasm32Memory, U: FromWasm32Memory> FromWasm32Memory for (T, U) {
const SIZE_OF_WASM: usize = T::SIZE_OF_WASM + U::SIZE_OF_WASM;
const ALIGN_OF_WASM: usize = max2(T::SIZE_OF_WASM, U::SIZE_OF_WASM);
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
debug_assert!(
T::ALIGN_OF_WASM >= U::ALIGN_OF_WASM,
"this function does not handle alignment"
);
let t = <T as FromWasm32Memory>::decode(memory, offset);
let u = <U as FromWasm32Memory>::decode(memory, offset + T::ACTUAL_WIDTH as u32);
(t, u)
}
}
const fn max2(a: usize, b: usize) -> usize {
if a > b {
a
} else {
b
}
}
const fn max3(a: usize, b: usize, c: usize) -> usize {
max2(max2(a, b), c)
}
impl<T: FromWasm32Memory, U: FromWasm32Memory, V: FromWasm32Memory> FromWasm32Memory for (T, U, V) {
const SIZE_OF_WASM: usize = T::SIZE_OF_WASM + U::SIZE_OF_WASM + V::SIZE_OF_WASM;
const ALIGN_OF_WASM: usize = max3(T::SIZE_OF_WASM, U::SIZE_OF_WASM, V::SIZE_OF_WASM);
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
debug_assert!(
T::ALIGN_OF_WASM >= U::ALIGN_OF_WASM,
"this function does not handle alignment"
);
debug_assert!(
U::ALIGN_OF_WASM >= V::ALIGN_OF_WASM,
"this function does not handle alignment"
);
let t = <T as FromWasm32Memory>::decode(memory, offset);
let u = <U as FromWasm32Memory>::decode(memory, offset + T::ACTUAL_WIDTH as u32);
let v = <V as FromWasm32Memory>::decode(
memory,
offset + T::ACTUAL_WIDTH as u32 + U::ACTUAL_WIDTH as u32,
);
(t, u, v)
}
}

1
compiler/gen_wasm/src/lib.rs Normal file
View file

@ -0,0 +1 @@
pub mod from_wasm32_memory;

10
compiler/mono/src/alias_analysis.rs
View file

@ -9,7 +9,7 @@ use roc_module::low_level::LowLevel;
use roc_module::symbol::Symbol;
use std::convert::TryFrom;
use crate::ir::{Call, CallType, Expr, Literal, ModifyRc, Proc, Stmt};
use crate::ir::{Call, CallType, Expr, ListLiteralElement, Literal, ModifyRc, Proc, Stmt};
use crate::layout::{Builtin, Layout, ListLayout, UnionLayout};
// just using one module for now
@ -1118,8 +1118,12 @@ fn expr_spec<'a>(
let mut bag = builder.add_get_tuple_field(block, list, LIST_BAG_INDEX)?;
for symbol in elems.iter() {
let value_id = env.symbols[symbol];
for element in elems.iter() {
let value_id = if let ListLiteralElement::Symbol(symbol) = element {
env.symbols[symbol]
} else {
builder.add_make_tuple(block, &[]).unwrap()
};
bag = builder.add_bag_insert(block, bag, value_id)?;
}

10
compiler/mono/src/borrow.rs
View file

@ -740,7 +740,15 @@ impl<'a> BorrowInfState<'a> {
use Expr::*;
match e {
Tag { arguments: xs, .. } | Struct(xs) | Array { elems: xs, .. } => {
Array { elems: xs, .. } => {
let xs = Vec::from_iter_in(xs.iter().filter_map(|e| e.to_symbol()), self.arena);
self.own_var(z);
// if the used symbol is an argument to the current function,
// the function must take it as an owned parameter
self.own_args_if_param(&xs);
}
Tag { arguments: xs, .. } | Struct(xs) => {
self.own_var(z);
// if the used symbol is an argument to the current function,

23
compiler/mono/src/inc_dec.rs
View file

@ -95,11 +95,11 @@ pub fn occurring_variables_expr(expr: &Expr<'_>, result: &mut MutSet<Symbol>) {
Call(call) => occurring_variables_call(call, result),
Tag { arguments, .. }
| Struct(arguments)
| Array {
Array {
elems: arguments, ..
} => {
} => result.extend(arguments.iter().filter_map(|e| e.to_symbol())),
Tag { arguments, .. } | Struct(arguments) => {
result.extend(arguments.iter().copied());
}
Reuse {
@ -733,15 +733,22 @@ impl<'a> Context<'a> {
live_vars.remove(&z);
let new_b = match v {
Reuse { arguments: ys, .. }
| Tag { arguments: ys, .. }
| Struct(ys)
| Array { elems: ys, .. } => self.add_inc_before_consume_all(
Reuse { arguments: ys, .. } | Tag { arguments: ys, .. } | Struct(ys) => self
.add_inc_before_consume_all(
ys,
self.arena.alloc(Stmt::Let(z, v, l, b)),
b_live_vars,
),
Array { elems, .. } => {
let ys = Vec::from_iter_in(elems.iter().filter_map(|e| e.to_symbol()), self.arena);
self.add_inc_before_consume_all(
&ys,
self.arena.alloc(Stmt::Let(z, v, l, b)),
b_live_vars,
)
}
Call(crate::ir::Call {
call_type,
arguments,

113
compiler/mono/src/ir.rs
View file

@ -1020,7 +1020,7 @@ impl ModifyRc {
}
}
#[derive(Clone, Debug, PartialEq)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum Literal<'a> {
// Literals
Int(i128),
@ -1038,6 +1038,21 @@ pub enum Literal<'a> {
Byte(u8),
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ListLiteralElement<'a> {
Literal(Literal<'a>),
Symbol(Symbol),
}
impl<'a> ListLiteralElement<'a> {
pub fn to_symbol(&self) -> Option<Symbol> {
match self {
Self::Symbol(s) => Some(*s),
_ => None,
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Call<'a> {
pub call_type: CallType<'a>,
@ -1177,7 +1192,7 @@ pub enum Expr<'a> {
Array {
elem_layout: Layout<'a>,
elems: &'a [Symbol],
elems: &'a [ListLiteralElement<'a>],
},
EmptyArray,
@ -1317,7 +1332,10 @@ impl<'a> Expr<'a> {
.append(alloc.text("}"))
}
Array { elems, .. } => {
let it = elems.iter().map(|s| symbol_to_doc(alloc, *s));
let it = elems.iter().map(|e| match e {
ListLiteralElement::Literal(l) => l.to_doc(alloc),
ListLiteralElement::Symbol(s) => symbol_to_doc(alloc, *s),
});
alloc
.text("Array [")
@ -2728,6 +2746,63 @@ macro_rules! match_on_closure_argument {
}};
}
fn try_make_literal<'a>(
env: &mut Env<'a, '_>,
can_expr: &roc_can::expr::Expr,
) -> Option<Literal<'a>> {
use roc_can::expr::Expr::*;
match can_expr {
Int(_, precision, _, int) => {
match num_argument_to_int_or_float(env.subs, env.ptr_bytes, *precision, false) {
IntOrFloat::SignedIntType(_) | IntOrFloat::UnsignedIntType(_) => {
Some(Literal::Int(*int))
}
_ => unreachable!("unexpected float precision for integer"),
}
}
Float(_, precision, float_str, float) => {
match num_argument_to_int_or_float(env.subs, env.ptr_bytes, *precision, true) {
IntOrFloat::BinaryFloatType(_) => Some(Literal::Float(*float)),
IntOrFloat::DecimalFloatType => {
let dec = match RocDec::from_str(float_str) {
Some(d) => d,
None => panic!("Invalid decimal for float literal = {}. TODO: Make this a nice, user-friendly error message", float_str),
};
Some(Literal::Decimal(dec))
}
_ => unreachable!("unexpected float precision for integer"),
}
}
// TODO investigate lifetime trouble
// Str(string) => Some(Literal::Str(env.arena.alloc(string))),
Num(var, num_str, num) => {
// first figure out what kind of number this is
match num_argument_to_int_or_float(env.subs, env.ptr_bytes, *var, false) {
IntOrFloat::SignedIntType(_) | IntOrFloat::UnsignedIntType(_) => {
Some(Literal::Int((*num).into()))
}
IntOrFloat::BinaryFloatType(_) => Some(Literal::Float(*num as f64)),
IntOrFloat::DecimalFloatType => {
let dec = match RocDec::from_str(num_str) {
Some(d) => d,
None => panic!(
r"Invalid decimal for float literal = {}. TODO: Make this a nice, user-friendly error message",
num_str
),
};
Some(Literal::Decimal(dec))
}
}
}
_ => None,
}
}
pub fn with_hole<'a>(
env: &mut Env<'a, '_>,
can_expr: roc_can::expr::Expr,
@ -3423,8 +3498,20 @@ pub fn with_hole<'a>(
loc_elems,
} => {
let mut arg_symbols = Vec::with_capacity_in(loc_elems.len(), env.arena);
for arg_expr in loc_elems.iter() {
arg_symbols.push(possible_reuse_symbol(env, procs, &arg_expr.value));
let mut elements = Vec::with_capacity_in(loc_elems.len(), env.arena);
let mut symbol_exprs = Vec::with_capacity_in(loc_elems.len(), env.arena);
for arg_expr in loc_elems.into_iter() {
if let Some(literal) = try_make_literal(env, &arg_expr.value) {
elements.push(ListLiteralElement::Literal(literal));
} else {
let symbol = possible_reuse_symbol(env, procs, &arg_expr.value);
elements.push(ListLiteralElement::Symbol(symbol));
arg_symbols.push(symbol);
symbol_exprs.push(arg_expr);
}
}
let arg_symbols = arg_symbols.into_bump_slice();
@ -3434,7 +3521,7 @@ pub fn with_hole<'a>(
let expr = Expr::Array {
elem_layout,
elems: arg_symbols,
elems: elements.into_bump_slice(),
};
let stmt = Stmt::Let(
@ -3444,7 +3531,7 @@ pub fn with_hole<'a>(
hole,
);
let iter = loc_elems
let iter = symbol_exprs
.into_iter()
.rev()
.map(|e| (elem_var, e))
@ -5485,11 +5572,17 @@ fn substitute_in_expr<'a>(
} => {
let mut did_change = false;
let new_args = Vec::from_iter_in(
args.iter().map(|s| match substitute(subs, *s) {
None => *s,
args.iter().map(|e| {
if let ListLiteralElement::Symbol(s) = e {
match substitute(subs, *s) {
None => ListLiteralElement::Symbol(*s),
Some(s) => {
did_change = true;
s
ListLiteralElement::Symbol(s)
}
}
} else {
*e
}
}),
arena,

16
compiler/mono/src/reset_reuse.rs
View file

@ -1,5 +1,5 @@
use crate::inc_dec::{collect_stmt, occurring_variables_expr, JPLiveVarMap, LiveVarSet};
use crate::ir::{BranchInfo, Call, Expr, Proc, Stmt};
use crate::ir::{BranchInfo, Call, Expr, ListLiteralElement, Proc, Stmt};
use crate::layout::{Layout, UnionLayout};
use bumpalo::collections::Vec;
use bumpalo::Bump;
@ -564,8 +564,18 @@ fn has_live_var_expr<'a>(expr: &'a Expr<'a>, needle: Symbol) -> bool {
match expr {
Expr::Literal(_) => false,
Expr::Call(call) => has_live_var_call(call, needle),
Expr::Array { elems: fields, .. }
| Expr::Tag {
Expr::Array { elems: fields, .. } => {
for element in fields.iter() {
if let ListLiteralElement::Symbol(s) = element {
if *s == needle {
return true;
}
}
}
false
}
Expr::Tag {
arguments: fields, ..
}
| Expr::Struct(fields) => fields.iter().any(|s| *s == needle),

1
compiler/test_gen/Cargo.toml
View file

@ -23,6 +23,7 @@ roc_can = { path = "../can" }
roc_parse = { path = "../parse" }
roc_build = { path = "../build" }
roc_std = { path = "../../roc_std" }
roc_gen_wasm = { path = "../gen_wasm" }
im = "14" # im and im-rc should always have the same version!
im-rc = "14" # im and im-rc should always have the same version!
bumpalo = { version = "3.6.1", features = ["collections"] }

276
compiler/test_gen/src/helpers/eval.rs
View file

@ -6,9 +6,9 @@ use roc_can::builtins::builtin_defs_map;
use roc_can::def::Def;
use roc_collections::all::{MutMap, MutSet};
use roc_gen_llvm::llvm::externs::add_default_roc_externs;
use roc_gen_wasm::from_wasm32_memory::FromWasm32Memory;
use roc_module::symbol::Symbol;
use roc_mono::ir::OptLevel;
use roc_std::{RocDec, RocList, RocOrder, RocStr};
use roc_types::subs::VarStore;
use target_lexicon::Triple;
@ -366,29 +366,6 @@ pub fn helper_wasm<'a>(
use std::process::Command;
// Command::new("/opt/wasi-sdk/bin/clang")
/*
Command::new("zig")
.current_dir(dir_path)
.args(&[
"cc",
"/home/folkertdev/roc/wasm/libmain.a",
test_a_path.to_str().unwrap(),
"-target",
"wasm32-wasi",
"-o",
test_wasm_path.to_str().unwrap(),
"--sysroot=/opt/wasi-sdk/share/wasi-sysroot/",
"-Xlinker", "--export-dynamic",
// "-Xlinker", "--allow-undefined"
// "--global-cache-dir",
// zig_global_cache_path.to_str().unwrap(),
])
.status()
.unwrap();
*/
Command::new("/home/folkertdev/Downloads/zig-linux-x86_64-0.9.0-dev.848+d5ef5da59/zig")
.current_dir(dir_path)
.args(&[
@ -405,24 +382,6 @@ pub fn helper_wasm<'a>(
.status()
.unwrap();
/*
Command::new("/home/folkertdev/Downloads/zig-linux-x86_64-0.9.0-dev.848+d5ef5da59/zig")
.current_dir(dir_path)
.args(&[
"build-lib",
"/home/folkertdev/roc/wasm/libmain.a",
test_a_path.to_str().unwrap(),
"-target",
"wasm32-wasi",
"-dynamic",
"-lc",
// "--global-cache-dir",
// zig_global_cache_path.to_str().unwrap(),
])
.status()
.unwrap();
*/
// now, do wasmer stuff
use wasmer::{Function, Instance, Module, Store};
@ -500,7 +459,7 @@ fn fake_wasm_main_function(_: u32, _: u32) -> u32 {
#[allow(dead_code)]
pub fn assert_wasm_evals_to_help<T>(src: &str, ignore_problems: bool) -> Result<T, String>
where
T: FromWasmMemory,
T: FromWasm32Memory,
{
let arena = bumpalo::Bump::new();
let context = inkwell::context::Context::create();
@ -534,7 +493,7 @@ where
_ => panic!(),
};
let output = <T as crate::helpers::eval::FromWasmMemory>::decode(
let output = <T as crate::helpers::eval::FromWasm32Memory>::decode(
memory,
// skip the RocCallResult tag id
address as u32 + 8,
@ -643,232 +602,3 @@ macro_rules! assert_non_opt_evals_to {
$crate::assert_llvm_evals_to!($src, $expected, $ty, $transform);
}};
}
pub trait FromWasmMemory: Sized {
const SIZE_OF_WASM: usize;
const ALIGN_OF_WASM: usize;
const ACTUAL_WIDTH: usize = if (Self::SIZE_OF_WASM % Self::ALIGN_OF_WASM) == 0 {
Self::SIZE_OF_WASM
} else {
Self::SIZE_OF_WASM + (Self::ALIGN_OF_WASM - (Self::SIZE_OF_WASM % Self::ALIGN_OF_WASM))
};
fn decode(memory: &wasmer::Memory, offset: u32) -> Self;
}
macro_rules! from_wasm_memory_primitive_decode {
($type_name:ident) => {
const SIZE_OF_WASM: usize = core::mem::size_of::<$type_name>();
const ALIGN_OF_WASM: usize = core::mem::align_of::<$type_name>();
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
use core::mem::MaybeUninit;
let mut output: MaybeUninit<Self> = MaybeUninit::uninit();
let width = std::mem::size_of::<Self>();
let ptr = output.as_mut_ptr();
let raw_ptr = ptr as *mut u8;
let slice = unsafe { std::slice::from_raw_parts_mut(raw_ptr, width) };
let ptr: wasmer::WasmPtr<u8, wasmer::Array> = wasmer::WasmPtr::new(offset as u32);
let foobar = (ptr.deref(memory, 0, width as u32)).unwrap();
let wasm_slice = unsafe { std::mem::transmute(foobar) };
slice.copy_from_slice(wasm_slice);
unsafe { output.assume_init() }
}
};
}
macro_rules! from_wasm_memory_primitive {
($($type_name:ident ,)+) => {
$(
impl FromWasmMemory for $type_name {
from_wasm_memory_primitive_decode!($type_name);
}
)*
}
}
from_wasm_memory_primitive!(
u8, i8, u16, i16, u32, i32, u64, i64, u128, i128, f32, f64, bool, RocDec, RocOrder,
);
impl FromWasmMemory for () {
const SIZE_OF_WASM: usize = 0;
const ALIGN_OF_WASM: usize = 0;
fn decode(_: &wasmer::Memory, _: u32) -> Self {}
}
impl FromWasmMemory for RocStr {
const SIZE_OF_WASM: usize = 8;
const ALIGN_OF_WASM: usize = 4;
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
let bytes = <u64 as FromWasmMemory>::decode(memory, offset);
let length = (bytes >> 32) as u32;
let elements = bytes as u32;
if length == 0 {
RocStr::default()
} else if (length as i32) < 0 {
// this is a small string
let last_byte = bytes.to_ne_bytes()[7];
let actual_length = (last_byte ^ 0b1000_0000) as usize;
let slice = &bytes.to_ne_bytes()[..actual_length as usize];
RocStr::from_slice(slice)
} else {
// this is a big string
let ptr: wasmer::WasmPtr<u8, wasmer::Array> = wasmer::WasmPtr::new(elements);
let foobar = (ptr.deref(memory, 0, length)).unwrap();
let wasm_slice = unsafe { std::mem::transmute(foobar) };
RocStr::from_slice(wasm_slice)
}
}
}
impl<T: FromWasmMemory + Clone> FromWasmMemory for RocList<T> {
const SIZE_OF_WASM: usize = 8;
const ALIGN_OF_WASM: usize = 4;
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
let bytes = <u64 as FromWasmMemory>::decode(memory, offset);
let length = (bytes >> 32) as u32;
let elements = bytes as u32;
let mut items = Vec::with_capacity(length as usize);
for i in 0..length {
let item = <T as FromWasmMemory>::decode(
memory,
elements + i * <T as FromWasmMemory>::SIZE_OF_WASM as u32,
);
items.push(item);
}
RocList::from_slice(&items)
}
}
impl<T: FromWasmMemory + Clone> FromWasmMemory for &'_ [T] {
const SIZE_OF_WASM: usize = 8;
const ALIGN_OF_WASM: usize = 4;
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
let bytes = <u64 as FromWasmMemory>::decode(memory, offset);
let length = (bytes >> 32) as u32;
let elements = bytes as u32;
let ptr: wasmer::WasmPtr<u8, wasmer::Array> = wasmer::WasmPtr::new(elements);
let width = <T as FromWasmMemory>::SIZE_OF_WASM as u32 * length;
let foobar = (ptr.deref(memory, 0, width)).unwrap();
let wasm_slice =
unsafe { std::slice::from_raw_parts(foobar as *const _ as *const _, length as usize) };
wasm_slice
}
}
impl<T: FromWasmMemory> FromWasmMemory for &'_ T {
const SIZE_OF_WASM: usize = 4;
const ALIGN_OF_WASM: usize = 4;
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
let elements = <u32 as FromWasmMemory>::decode(memory, offset);
let actual = <T as FromWasmMemory>::decode(memory, elements);
let b = Box::new(actual);
std::boxed::Box::<T>::leak(b)
}
}
impl<T: FromWasmMemory + Clone, const N: usize> FromWasmMemory for [T; N] {
const SIZE_OF_WASM: usize = N * T::SIZE_OF_WASM;
const ALIGN_OF_WASM: usize = T::ALIGN_OF_WASM;
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
let ptr: wasmer::WasmPtr<u8, wasmer::Array> = wasmer::WasmPtr::new(offset);
let width = <T as FromWasmMemory>::SIZE_OF_WASM as u32 * N as u32;
let foobar = (ptr.deref(memory, 0, width)).unwrap();
let wasm_slice: &[T; N] = unsafe { &*(foobar as *const _ as *const [T; N]) };
wasm_slice.clone()
}
}
impl FromWasmMemory for usize {
const SIZE_OF_WASM: usize = 4;
const ALIGN_OF_WASM: usize = 4;
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
<u32 as FromWasmMemory>::decode(memory, offset) as usize
}
}
impl<T: FromWasmMemory, U: FromWasmMemory> FromWasmMemory for (T, U) {
const SIZE_OF_WASM: usize = T::SIZE_OF_WASM + U::SIZE_OF_WASM;
const ALIGN_OF_WASM: usize = max2(T::SIZE_OF_WASM, U::SIZE_OF_WASM);
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
assert!(
T::ALIGN_OF_WASM >= U::ALIGN_OF_WASM,
"this function does not handle alignment"
);
let t = <T as FromWasmMemory>::decode(memory, offset);
let u = <U as FromWasmMemory>::decode(memory, offset + T::ACTUAL_WIDTH as u32);
(t, u)
}
}
const fn max2(a: usize, b: usize) -> usize {
if a > b {
a
} else {
b
}
}
const fn max3(a: usize, b: usize, c: usize) -> usize {
max2(max2(a, b), c)
}
impl<T: FromWasmMemory, U: FromWasmMemory, V: FromWasmMemory> FromWasmMemory for (T, U, V) {
const SIZE_OF_WASM: usize = T::SIZE_OF_WASM + U::SIZE_OF_WASM + V::SIZE_OF_WASM;
const ALIGN_OF_WASM: usize = max3(T::SIZE_OF_WASM, U::SIZE_OF_WASM, V::SIZE_OF_WASM);
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
assert!(
T::ALIGN_OF_WASM >= U::ALIGN_OF_WASM,
"this function does not handle alignment"
);
assert!(
U::ALIGN_OF_WASM >= V::ALIGN_OF_WASM,
"this function does not handle alignment"
);
let t = <T as FromWasmMemory>::decode(memory, offset);
let u = <U as FromWasmMemory>::decode(memory, offset + T::ACTUAL_WIDTH as u32);
let v = <V as FromWasmMemory>::decode(
memory,
offset + T::ACTUAL_WIDTH as u32 + U::ACTUAL_WIDTH as u32,
);
(t, u, v)
}
}

10
compiler/test_mono/generated/fst.txt
View file

@ -3,14 +3,8 @@ procedure Test.1 (Test.2, Test.3):
ret Test.2;
procedure Test.0 ():
let Test.11 = 1i64;
let Test.12 = 2i64;
let Test.13 = 3i64;
let Test.5 = Array [Test.11, Test.12, Test.13];
let Test.8 = 3i64;
let Test.9 = 2i64;
let Test.10 = 1i64;
let Test.6 = Array [Test.8, Test.9, Test.10];
let Test.5 = Array [1i64, 2i64, 3i64];
let Test.6 = Array [3i64, 2i64, 1i64];
let Test.4 = CallByName Test.1 Test.5 Test.6;
dec Test.6;
dec Test.5;

4
compiler/test_mono/generated/ir_int_add.txt
View file

@ -7,9 +7,7 @@ procedure Num.24 (#Attr.2, #Attr.3):
ret Test.5;
procedure Test.0 ():
let Test.11 = 1i64;
let Test.12 = 2i64;
let Test.1 = Array [Test.11, Test.12];
let Test.1 = Array [1i64, 2i64];
let Test.9 = 5i64;
let Test.10 = 4i64;
let Test.7 = CallByName Num.24 Test.9 Test.10;

5
compiler/test_mono/generated/let_with_record_pattern_list.txt
View file

@ -1,8 +1,5 @@
procedure Test.0 ():
let Test.6 = 1i64;
let Test.7 = 3i64;
let Test.8 = 4i64;
let Test.4 = Array [Test.6, Test.7, Test.8];
let Test.4 = Array [1i64, 3i64, 4i64];
let Test.5 = 3.14f64;
let Test.3 = Struct {Test.4, Test.5};
let Test.1 = StructAtIndex 0 Test.3;

3
compiler/test_mono/generated/list_append.txt
View file

@ -3,8 +3,7 @@ procedure List.5 (#Attr.2, #Attr.3):
ret Test.4;
procedure Test.0 ():
let Test.5 = 1i64;
let Test.2 = Array [Test.5];
let Test.2 = Array [1i64];
let Test.3 = 2i64;
let Test.1 = CallByName List.5 Test.2 Test.3;
ret Test.1;

4
compiler/test_mono/generated/list_append_closure.txt
View file

@ -8,8 +8,6 @@ procedure Test.1 (Test.2):
ret Test.5;
procedure Test.0 ():
let Test.8 = 1i64;
let Test.9 = 2i64;
let Test.4 = Array [Test.8, Test.9];
let Test.4 = Array [1i64, 2i64];
let Test.3 = CallByName Test.1 Test.4;
ret Test.3;

31
compiler/test_mono/generated/list_cannot_update_inplace.txt
View file

@ -1,9 +1,9 @@
procedure List.4 (#Attr.2, #Attr.3, #Attr.4):
let Test.22 = lowlevel ListLen #Attr.2;
let Test.20 = lowlevel NumLt #Attr.3 Test.22;
if Test.20 then
let Test.21 = lowlevel ListSet #Attr.2 #Attr.3 #Attr.4;
ret Test.21;
let Test.19 = lowlevel ListLen #Attr.2;
let Test.17 = lowlevel NumLt #Attr.3 Test.19;
if Test.17 then
let Test.18 = lowlevel ListSet #Attr.2 #Attr.3 #Attr.4;
ret Test.18;
else
ret #Attr.2;
@ -16,23 +16,20 @@ procedure Num.24 (#Attr.2, #Attr.3):
ret Test.7;
procedure Test.1 ():
let Test.11 = 1i64;
let Test.12 = 2i64;
let Test.13 = 3i64;
let Test.10 = Array [Test.11, Test.12, Test.13];
let Test.10 = Array [1i64, 2i64, 3i64];
ret Test.10;
procedure Test.2 (Test.3):
let Test.17 = 0i64;
let Test.18 = 0i64;
let Test.16 = CallByName List.4 Test.3 Test.17 Test.18;
ret Test.16;
let Test.14 = 0i64;
let Test.15 = 0i64;
let Test.13 = CallByName List.4 Test.3 Test.14 Test.15;
ret Test.13;
procedure Test.0 ():
let Test.15 = CallByName Test.1;
let Test.14 = CallByName Test.2 Test.15;
let Test.5 = CallByName List.7 Test.14;
dec Test.14;
let Test.12 = CallByName Test.1;
let Test.11 = CallByName Test.2 Test.12;
let Test.5 = CallByName List.7 Test.11;
dec Test.11;
let Test.8 = CallByName Test.1;
let Test.6 = CallByName List.7 Test.8;
dec Test.8;

5
compiler/test_mono/generated/list_get.txt
View file

@ -11,10 +11,7 @@ procedure List.3 (#Attr.2, #Attr.3):
ret Test.8;
procedure Test.1 (Test.2):
let Test.14 = 1i64;
let Test.15 = 2i64;
let Test.16 = 3i64;
let Test.6 = Array [Test.14, Test.15, Test.16];
let Test.6 = Array [1i64, 2i64, 3i64];
let Test.7 = 0i64;
let Test.5 = CallByName List.3 Test.6 Test.7;
dec Test.6;

8
compiler/test_mono/generated/list_len.txt
View file

@ -11,12 +11,8 @@ procedure Num.24 (#Attr.2, #Attr.3):
ret Test.6;
procedure Test.0 ():
let Test.10 = 1i64;
let Test.11 = 2i64;
let Test.12 = 3i64;
let Test.1 = Array [Test.10, Test.11, Test.12];
let Test.9 = 1f64;
let Test.2 = Array [Test.9];
let Test.1 = Array [1i64, 2i64, 3i64];
let Test.2 = Array [1f64];
let Test.4 = CallByName List.7 Test.1;
dec Test.1;
let Test.5 = CallByName List.7 Test.2;

5
compiler/test_mono/generated/list_pass_to_function.txt
View file

@ -14,9 +14,6 @@ procedure Test.2 (Test.3):
ret Test.5;
procedure Test.0 ():
let Test.12 = 1i64;
let Test.13 = 2i64;
let Test.14 = 3i64;
let Test.1 = Array [Test.12, Test.13, Test.14];
let Test.1 = Array [1i64, 2i64, 3i64];
let Test.4 = CallByName Test.2 Test.1;
ret Test.4;

5
compiler/test_mono/generated/mk_pair_of.txt
View file

@ -4,9 +4,6 @@ procedure Test.1 (Test.2):
ret Test.6;
procedure Test.0 ():
let Test.7 = 1i64;
let Test.8 = 2i64;
let Test.9 = 3i64;
let Test.5 = Array [Test.7, Test.8, Test.9];
let Test.5 = Array [1i64, 2i64, 3i64];
let Test.4 = CallByName Test.1 Test.5;
ret Test.4;

4
compiler/test_mono/generated/quicksort_swap.txt
View file

@ -56,8 +56,6 @@ procedure Test.1 (Test.2):
jump Test.26;
procedure Test.0 ():
let Test.39 = 1i64;
let Test.40 = 2i64;
let Test.7 = Array [Test.39, Test.40];
let Test.7 = Array [1i64, 2i64];
let Test.6 = CallByName Test.1 Test.7;
ret Test.6;

3
compiler/test_mono/generated/rigids.txt
View file

@ -54,7 +54,6 @@ procedure Test.1 (Test.2, Test.3, Test.4):
procedure Test.0 ():
let Test.10 = 0i64;
let Test.11 = 0i64;
let Test.40 = 1i64;
let Test.12 = Array [Test.40];
let Test.12 = Array [1i64];
let Test.9 = CallByName Test.1 Test.10 Test.11 Test.12;
ret Test.9;

8
examples/benchmarks/platform/host.zig
View file

@ -40,7 +40,7 @@ export fn roc_alloc(size: usize, alignment: u32) callconv(.C) ?*c_void {
if (DEBUG) {
var ptr = malloc(size);
const stdout = std.io.getStdOut().writer();
stdout.print("alloc: {d} (alignment {d})\n", .{ ptr, alignment }) catch unreachable;
stdout.print("alloc: {d} (alignment {d}, size {d})\n", .{ ptr, alignment, size }) catch unreachable;
return ptr;
} else {
return malloc(size);
@ -48,8 +48,10 @@ export fn roc_alloc(size: usize, alignment: u32) callconv(.C) ?*c_void {
}
export fn roc_realloc(c_ptr: *c_void, new_size: usize, old_size: usize, alignment: u32) callconv(.C) ?*c_void {
_ = old_size;
_ = alignment;
if (DEBUG) {
const stdout = std.io.getStdOut().writer();
stdout.print("realloc: {d} (alignment {d}, old_size {d})\n", .{ c_ptr, alignment, old_size }) catch unreachable;
}
return realloc(@alignCast(@alignOf(Align), @ptrCast([*]u8, c_ptr)), new_size);
}