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

Use shorter notation for enums in lowlevel module

Browse source
This commit is contained in:
Brian Carroll 2021-11-10 10:47:01 +00:00
parent ec03b7b12a
commit 6421ff07a5
1 changed files with 35 additions and 35 deletions
Download patch file Download diff file Expand all files Collapse all files

70
compiler/gen_wasm/src/low_level.rs
View file

@ -1,10 +1,10 @@
use roc_builtins::bitcode::{self, FloatWidth}; use roc_builtins::bitcode::{self, FloatWidth};
use roc_module::low_level::LowLevel; use roc_module::low_level::{LowLevel, LowLevel::*};
use roc_module::symbol::Symbol; use roc_module::symbol::Symbol;
use crate::layout::WasmLayout; use crate::layout::WasmLayout;
use crate::storage::Storage; use crate::storage::Storage;
use crate::wasm_module::{CodeBuilder, ValueType}; use crate::wasm_module::{CodeBuilder, ValueType::*};
pub enum LowlevelBuildResult { pub enum LowlevelBuildResult {
WasmInstructions, WasmInstructions,
@ -24,56 +24,56 @@ pub fn build_call_low_level<'a>(
let panic_ret_type = || panic!("Invalid return layout for {:?}: {:?}", lowlevel, ret_layout); let panic_ret_type = || panic!("Invalid return layout for {:?}: {:?}", lowlevel, ret_layout);
match lowlevel { match lowlevel {
LowLevel::NumAdd => match ret_layout.value_type() { NumAdd => match ret_layout.value_type() {
ValueType::I32 => code_builder.i32_add(), I32 => code_builder.i32_add(),
ValueType::I64 => code_builder.i64_add(), I64 => code_builder.i64_add(),
ValueType::F32 => code_builder.f32_add(), F32 => code_builder.f32_add(),
ValueType::F64 => code_builder.f64_add(), F64 => code_builder.f64_add(),
}, },
LowLevel::NumSub => match ret_layout.value_type() { NumSub => match ret_layout.value_type() {
ValueType::I32 => code_builder.i32_sub(), I32 => code_builder.i32_sub(),
ValueType::I64 => code_builder.i64_sub(), I64 => code_builder.i64_sub(),
ValueType::F32 => code_builder.f32_sub(), F32 => code_builder.f32_sub(),
ValueType::F64 => code_builder.f64_sub(), F64 => code_builder.f64_sub(),
}, },
LowLevel::NumMul => match ret_layout.value_type() { NumMul => match ret_layout.value_type() {
ValueType::I32 => code_builder.i32_mul(), I32 => code_builder.i32_mul(),
ValueType::I64 => code_builder.i64_mul(), I64 => code_builder.i64_mul(),
ValueType::F32 => code_builder.f32_mul(), F32 => code_builder.f32_mul(),
ValueType::F64 => code_builder.f64_mul(), F64 => code_builder.f64_mul(),
}, },
LowLevel::NumGt => match storage.get(&args[0]).value_type() { NumGt => match storage.get(&args[0]).value_type() {
ValueType::I32 => code_builder.i32_gt_s(), I32 => code_builder.i32_gt_s(),
ValueType::I64 => code_builder.i64_gt_s(), I64 => code_builder.i64_gt_s(),
ValueType::F32 => code_builder.f32_gt(), F32 => code_builder.f32_gt(),
ValueType::F64 => code_builder.f64_gt(), F64 => code_builder.f64_gt(),
}, },
LowLevel::Eq => match storage.get(&args[0]).value_type() { Eq => match storage.get(&args[0]).value_type() {
ValueType::I32 => code_builder.i32_eq(), I32 => code_builder.i32_eq(),
ValueType::I64 => code_builder.i64_eq(), I64 => code_builder.i64_eq(),
ValueType::F32 => code_builder.f32_eq(), F32 => code_builder.f32_eq(),
ValueType::F64 => code_builder.f64_eq(), F64 => code_builder.f64_eq(),
}, },
LowLevel::NumNeg => match ret_layout.value_type() { NumNeg => match ret_layout.value_type() {
// TODO: it would be better to subtract the arg from zero. // TODO: it would be better to subtract the arg from zero.
// But we'd need to insert the zero constant *before* the argument // But we'd need to insert the zero constant *before* the argument
// in the VM stack, and we don't have a good way to do that yet! // in the VM stack, and we don't have a good way to do that yet!
// Before solving this one case, let's see what other issues we run into. // Before solving this one case, let's see what other issues we run into.
ValueType::I32 => { I32 => {
code_builder.i32_const(-1); code_builder.i32_const(-1);
code_builder.i32_mul(); code_builder.i32_mul();
} }
ValueType::I64 => { I64 => {
code_builder.i64_const(-1); code_builder.i64_const(-1);
code_builder.i64_mul(); code_builder.i64_mul();
} }
ValueType::F32 => code_builder.f32_neg(), F32 => code_builder.f32_neg(),
ValueType::F64 => code_builder.f64_neg(), F64 => code_builder.f64_neg(),
}, },
LowLevel::NumAtan => { NumAtan => {
let name: &'static str = match ret_layout.value_type() { let name: &'static str = match ret_layout.value_type() {
ValueType::F32 => &bitcode::NUM_ATAN[FloatWidth::F32], F32 => &bitcode::NUM_ATAN[FloatWidth::F32],
ValueType::F64 => &bitcode::NUM_ATAN[FloatWidth::F64], F64 => &bitcode::NUM_ATAN[FloatWidth::F64],
_ => panic_ret_type(), _ => panic_ret_type(),
}; };
return BuiltinCall(name); return BuiltinCall(name);