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

Annotate low-level usages

Browse source
This commit is contained in:
Richard Feldman 2020-06-21 21:05:57 -04:00
parent 52dfb75dc0
commit cad0a1421e
3 changed files with 75 additions and 89 deletions
Download patch file Download diff file Expand all files Collapse all files

30
compiler/gen/src/llvm/build.rs
View file

@ -1044,22 +1044,6 @@ fn call_with_args<'a, 'ctx, 'env>(
BasicValueEnum::IntValue(int_val)
}
Symbol::LIST_LEN => {
debug_assert!(args.len() == 1);
BasicValueEnum::IntValue(load_list_len(env.builder, args[0].0.into_struct_value()))
}
Symbol::LIST_IS_EMPTY => {
debug_assert!(args.len() == 1);
let list_struct = args[0].0.into_struct_value();
let builder = env.builder;
let list_len = load_list_len(builder, list_struct);
let zero = env.ptr_int().const_zero();
let answer = builder.build_int_compare(IntPredicate::EQ, list_len, zero, "is_zero");
BasicValueEnum::IntValue(answer)
}
Symbol::INT_REM_UNSAFE => {
debug_assert!(args.len() == 2);
@ -1446,12 +1430,24 @@ fn run_low_level<'a, 'ctx, 'env>(
match op {
ListLen => {
debug_assert!(args.len() == 1);
debug_assert_eq!(args.len(), 1);
let arg = build_expr(env, layout_ids, scope, parent, &args[0].0);
BasicValueEnum::IntValue(load_list_len(env.builder, arg.into_struct_value()))
}
ListIsEmpty => {
debug_assert_eq!(args.len(), 1);
let arg = build_expr(env, layout_ids, scope, parent, &args[0].0);
let list_struct = arg.into_struct_value();
let builder = env.builder;
let list_len = load_list_len(builder, list_struct);
let zero = env.ptr_int().const_zero();
let answer = builder.build_int_compare(IntPredicate::EQ, list_len, zero, "is_zero");
BasicValueEnum::IntValue(answer)
}
NumAdd | NumSub | NumMul | NumLt | NumLte | NumGt | NumGte => {
debug_assert_eq!(args.len(), 2);

1
compiler/module/src/low_level.rs
View file

@ -6,6 +6,7 @@ pub enum LowLevel {
ListLen,
ListGetUnsafe,
ListSetUnsafe,
ListIsEmpty,
NumAdd,
NumSub,
NumMul,

99
compiler/uniq/src/sharing.rs
View file

@ -1,8 +1,8 @@
use roc_can::expr::Expr;
use roc_collections::all::{ImMap, ImSet};
use roc_module::ident::Lowercase;
use roc_module::low_level::LowLevel;
use roc_module::symbol::Symbol;
use roc_region::all::Located;
use roc_types::subs::Variable;
// fake field names for container elements
@ -618,10 +618,16 @@ pub fn annotate_usage(expr: &Expr, usage: &mut VarUsage) {
annotate_usage(&loc_expr.value, usage);
}
Call(fun, loc_args, _) => {
if let Var(symbol) = fun.1.value {
match fun.1.value {
Var(symbol) => {
// call by name
special_case_builtins(usage, symbol, loc_args);
} else {
usage.register_unique(symbol);
for (_, arg) in loc_args {
annotate_usage(&arg.value, usage);
}
}
_ => {
// unknown call
annotate_usage(&fun.1.value, usage);
@ -630,13 +636,9 @@ pub fn annotate_usage(expr: &Expr, usage: &mut VarUsage) {
}
}
}
}
RunLowLevel { op, args, ret_var } => {
todo!(
"TODO implement UNIQ RunLowLevel for {:?}({:?}) -> {:?}",
op,
args,
ret_var
);
annotate_low_level_usage(usage, *op, args, *ret_var);
}
Closure(_, _, _, _, body) => {
annotate_usage(&body.0.value, usage);
@ -701,75 +703,62 @@ fn get_access_chain<'a>(expr: &'a Expr, chain: &mut Vec<Lowercase>) -> Option<&'
}
}
fn special_case_builtins(
fn annotate_low_level_usage(
usage: &mut VarUsage,
symbol: Symbol,
loc_args: &[(Variable, Located<Expr>)],
op: LowLevel,
args: &[(Variable, Expr)],
_ret_var: Variable,
) {
use Expr::Var;
use LowLevel::*;
use Mark::*;
use Usage::*;
match symbol {
Symbol::LIST_GET => {
debug_assert!(loc_args.len() == 2);
let loc_list = &loc_args[0].1;
let loc_index = &loc_args[1].1;
if let Var(list_var) = loc_list.value {
match op {
ListLen | ListIsEmpty | ListGetUnsafe => {
match &args[0].1 {
Var(list_var) => {
usage.register_with(
list_var,
&Access(Container::List, Seen, FieldAccess::list_access()),
*list_var,
&Access(Container::List, Seen, FieldAccess::list_seen()),
);
} else {
annotate_usage(&loc_list.value, usage);
}
annotate_usage(&loc_index.value, usage);
list => {
annotate_usage(list, usage);
}
}
Symbol::LIST_SET => {
debug_assert!(loc_args.len() == 3);
for (_, arg) in &args[1..] {
annotate_usage(arg, usage);
}
}
let loc_list = &loc_args[0].1;
let loc_index = &loc_args[1].1;
let loc_value = &loc_args[2].1;
if let Var(list_var) = loc_list.value {
ListSetUnsafe => {
match &args[0].1 {
Var(list_var) => {
usage.register_with(
list_var,
*list_var,
&Update(
Container::List,
ImSet::default(),
FieldAccess::list_update(),
),
);
} else {
annotate_usage(&loc_list.value, usage);
}
annotate_usage(&loc_index.value, usage);
annotate_usage(&loc_value.value, usage);
}
Symbol::LIST_IS_EMPTY | Symbol::LIST_LEN => {
debug_assert!(loc_args.len() == 1);
let loc_list = &loc_args[0].1;
if let Var(list_var) = loc_list.value {
usage.register_with(
list_var,
&Access(Container::List, Seen, FieldAccess::list_seen()),
);
} else {
annotate_usage(&loc_list.value, usage);
list => {
annotate_usage(list, usage);
}
}
_ => {
usage.register_unique(symbol);
for (_, arg) in &args[1..] {
annotate_usage(arg, usage);
}
}
for (_, arg) in loc_args {
annotate_usage(&arg.value, usage);
NumAdd | NumSub | NumMul | NumGt | NumGte | NumLt | NumLte | Eq | NotEq | And | Or
| Not => {
for (_, arg) in args {
annotate_usage(&arg, usage);
}
}
}