newell
/
nac3
forked from M-Labs/nac3
1
0
Fork 0
Code Pull Requests Activity
nac3/nac3core/src/toplevel/builtins.rs

2095 lines
79 KiB
Rust
Raw Normal View History

nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
use super::*;
nac3core: list slice support
2022-01-09 19:55:17 +08:00
use crate::{
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
codegen::{
core: Add RangeValue and helper functions
2024-01-23 18:27:00 +08:00
classes::RangeValue,
core: Implement and expose {isinf,isnan}
2023-10-10 16:56:38 +08:00
expr::destructure_range,
core: Implement non-trivial builtin functions using IRRT
2023-11-06 12:57:23 +08:00
irrt::{
calculate_len_for_slice_range,
call_gamma,
call_gammaln,
call_isinf,
call_isnan,
call_j0,
},
core: Implement and expose {isinf,isnan}
2023-10-10 16:56:38 +08:00
stmt::exn_constructor,
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
},
nac3core: list slice support
2022-01-09 19:55:17 +08:00
symbol_resolver::SymbolValue,
core: Implement most ndarray-creation functions
2023-11-27 13:25:53 +08:00
toplevel::numpy::{
gen_ndarray_empty,
gen_ndarray_eye,
gen_ndarray_full,
gen_ndarray_ones,
gen_ndarray_zeros,
},
nac3core: list slice support
2022-01-09 19:55:17 +08:00
};
core: Add create_fn_by_* functions Used for abstracting the creation of function from different sources.
2023-10-10 14:56:16 +08:00
use inkwell::{
attributes::{Attribute, AttributeLoc},
types::{BasicType, BasicMetadataTypeEnum},
core: Implement ndarray constructor and numpy.empty
2023-11-17 17:30:27 +08:00
values::{BasicValue, BasicMetadataValueEnum},
core: Add create_fn_by_* functions Used for abstracting the creation of function from different sources.
2023-10-10 14:56:16 +08:00
FloatPredicate,
IntPredicate
};
core: Implement most ndarray-creation functions
2023-11-27 13:25:53 +08:00
use crate::toplevel::numpy::gen_ndarray_identity;
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
core: Infer builtins name list using builtin declaration list
2023-11-28 17:37:49 +08:00
type BuiltinInfo = Vec<(Arc<RwLock<TopLevelDef>>, Option<Stmt>)>;
nac3core: add ceil and floor
2021-12-01 03:23:58 +08:00
nac3artiq: support more builtin errors
2022-03-16 23:42:08 +08:00
pub fn get_exn_constructor(
name: &str,
class_id: usize,
cons_id: usize,
unifier: &mut Unifier,
primitives: &PrimitiveStore
)-> (TopLevelDef, TopLevelDef, Type, Type) {
let int32 = primitives.int32;
let int64 = primitives.int64;
let string = primitives.str;
let exception_fields = vec![
("__name__".into(), int32, true),
("__file__".into(), string, true),
("__line__".into(), int32, true),
("__col__".into(), int32, true),
("__func__".into(), string, true),
("__message__".into(), string, true),
("__param0__".into(), int64, true),
("__param1__".into(), int64, true),
("__param2__".into(), int64, true),
];
let exn_cons_args = vec![
FuncArg {
name: "msg".into(),
ty: string,
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
default_value: Some(SymbolValue::Str(String::new())),
nac3artiq: support more builtin errors
2022-03-16 23:42:08 +08:00
},
FuncArg { name: "param0".into(), ty: int64, default_value: Some(SymbolValue::I64(0)) },
FuncArg { name: "param1".into(), ty: int64, default_value: Some(SymbolValue::I64(0)) },
FuncArg { name: "param2".into(), ty: int64, default_value: Some(SymbolValue::I64(0)) },
];
let exn_type = unifier.add_ty(TypeEnum::TObj {
obj_id: DefinitionId(class_id),
fields: exception_fields.iter().map(|(a, b, c)| (*a, (*b, *c))).collect(),
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
params: HashMap::default(),
nac3artiq: support more builtin errors
2022-03-16 23:42:08 +08:00
});
let signature = unifier.add_ty(TypeEnum::TFunc(FunSignature {
args: exn_cons_args,
ret: exn_type,
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
vars: HashMap::default(),
nac3artiq: support more builtin errors
2022-03-16 23:42:08 +08:00
}));
let fun_def = TopLevelDef::Function {
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
name: format!("{name}.__init__"),
nac3artiq: support more builtin errors
2022-03-16 23:42:08 +08:00
simple_name: "__init__".into(),
signature,
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
var_id: Vec::default(),
instance_to_symbol: HashMap::default(),
instance_to_stmt: HashMap::default(),
nac3artiq: support more builtin errors
2022-03-16 23:42:08 +08:00
resolver: None,
codegen_callback: Some(Arc::new(GenCall::new(Box::new(exn_constructor)))),
loc: None,
};
let class_def = TopLevelDef::Class {
name: name.into(),
object_id: DefinitionId(class_id),
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
type_vars: Vec::default(),
nac3artiq: support more builtin errors
2022-03-16 23:42:08 +08:00
fields: exception_fields,
methods: vec![("__init__".into(), signature, DefinitionId(cons_id))],
ancestors: vec![
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
TypeAnnotation::CustomClass { id: DefinitionId(class_id), params: Vec::default() },
TypeAnnotation::CustomClass { id: DefinitionId(7), params: Vec::default() },
nac3artiq: support more builtin errors
2022-03-16 23:42:08 +08:00
],
constructor: Some(signature),
resolver: None,
loc: None,
};
(fun_def, class_def, signature, exn_type)
}
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
/// Creates a NumPy [`TopLevelDef`] function by code generation.
core: Add create_fn_by_* functions Used for abstracting the creation of function from different sources.
2023-10-10 14:56:16 +08:00
///
/// * `name`: The name of the implemented NumPy function.
/// * `ret_ty`: The return type of this function.
/// * `param_ty`: The parameters accepted by this function, represented by a tuple of the
/// [parameter type][Type] and the parameter symbol name.
/// * `codegen_callback`: A lambda generating LLVM IR for the implementation of this function.
fn create_fn_by_codegen(
primitives: &mut (PrimitiveStore, Unifier),
var_map: &HashMap<u32, Type>,
name: &'static str,
ret_ty: Type,
param_ty: &[(Type, &'static str)],
codegen_callback: GenCallCallback,
) -> Arc<RwLock<TopLevelDef>> {
Arc::new(RwLock::new(TopLevelDef::Function {
name: name.into(),
simple_name: name.into(),
signature: primitives.1.add_ty(TypeEnum::TFunc(FunSignature {
args: param_ty.iter().map(|p| FuncArg {
name: p.1.into(),
ty: p.0,
default_value: None,
}).collect(),
meta: Apply clippy suggested changes
2023-12-06 11:49:02 +08:00
ret: ret_ty,
core: Add create_fn_by_* functions Used for abstracting the creation of function from different sources.
2023-10-10 14:56:16 +08:00
vars: var_map.clone(),
})),
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
var_id: Vec::default(),
instance_to_symbol: HashMap::default(),
instance_to_stmt: HashMap::default(),
core: Add create_fn_by_* functions Used for abstracting the creation of function from different sources.
2023-10-10 14:56:16 +08:00
resolver: None,
codegen_callback: Some(Arc::new(GenCall::new(codegen_callback))),
loc: None,
}))
}
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
/// Creates a NumPy [`TopLevelDef`] function using an LLVM intrinsic.
core: Add create_fn_by_* functions Used for abstracting the creation of function from different sources.
2023-10-10 14:56:16 +08:00
///
/// * `name`: The name of the implemented NumPy function.
/// * `ret_ty`: The return type of this function.
/// * `param_ty`: The parameters accepted by this function, represented by a tuple of the
/// [parameter type][Type] and the parameter symbol name.
/// * `intrinsic_fn`: The fully-qualified name of the LLVM intrinsic function.
fn create_fn_by_intrinsic(
primitives: &mut (PrimitiveStore, Unifier),
var_map: &HashMap<u32, Type>,
name: &'static str,
ret_ty: Type,
params: &[(Type, &'static str)],
intrinsic_fn: &'static str,
) -> Arc<RwLock<TopLevelDef>> {
let param_tys = params.iter()
.map(|p| p.0)
.collect_vec();
create_fn_by_codegen(
primitives,
var_map,
name,
ret_ty,
params,
Box::new(move |ctx, _, fun, args, generator| {
let args_ty = fun.0.args.iter().map(|a| a.ty).collect_vec();
assert!(param_tys.iter().zip(&args_ty)
.all(|(expected, actual)| ctx.unifier.unioned(*expected, *actual)));
let args_val = args_ty.iter().zip_eq(args.iter())
.map(|(ty, arg)| {
arg.1.clone()
meta: Apply clippy suggested changes
2023-12-06 11:49:02 +08:00
.to_basic_value_enum(ctx, generator, *ty)
core: Add create_fn_by_* functions Used for abstracting the creation of function from different sources.
2023-10-10 14:56:16 +08:00
.unwrap()
})
.map_into::<BasicMetadataValueEnum>()
.collect_vec();
let intrinsic_fn = ctx.module.get_function(intrinsic_fn).unwrap_or_else(|| {
meta: Apply clippy suggested changes
2023-12-06 11:49:02 +08:00
let ret_llvm_ty = ctx.get_llvm_abi_type(generator, ret_ty);
core: Add create_fn_by_* functions Used for abstracting the creation of function from different sources.
2023-10-10 14:56:16 +08:00
let param_llvm_ty = param_tys.iter()
.map(|p| ctx.get_llvm_abi_type(generator, *p))
.map_into::<BasicMetadataTypeEnum>()
.collect_vec();
let fn_type = ret_llvm_ty.fn_type(param_llvm_ty.as_slice(), false);
ctx.module.add_function(intrinsic_fn, fn_type, None)
});
let call = ctx.builder
.build_call(intrinsic_fn, args_val.as_slice(), name);
let val = call.try_as_basic_value()
.left()
.unwrap();
Ok(val.into())
}),
)
}
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
/// Creates a unary NumPy [`TopLevelDef`] function using an extern function (e.g. from `libc` or
core: Add create_fn_by_* functions Used for abstracting the creation of function from different sources.
2023-10-10 14:56:16 +08:00
/// `libm`).
///
/// * `name`: The name of the implemented NumPy function.
/// * `ret_ty`: The return type of this function.
/// * `param_ty`: The parameters accepted by this function, represented by a tuple of the
/// [parameter type][Type] and the parameter symbol name.
/// * `extern_fn`: The fully-qualified name of the extern function used as the implementation.
/// * `attrs`: The list of attributes to apply to this function declaration. Note that `nounwind` is
/// already implied by the C ABI.
fn create_fn_by_extern(
primitives: &mut (PrimitiveStore, Unifier),
var_map: &HashMap<u32, Type>,
name: &'static str,
ret_ty: Type,
params: &[(Type, &'static str)],
extern_fn: &'static str,
attrs: &'static [&str],
) -> Arc<RwLock<TopLevelDef>> {
let param_tys = params.iter()
.map(|p| p.0)
.collect_vec();
create_fn_by_codegen(
primitives,
var_map,
name,
ret_ty,
params,
Box::new(move |ctx, _, fun, args, generator| {
let args_ty = fun.0.args.iter().map(|a| a.ty).collect_vec();
assert!(param_tys.iter().zip(&args_ty)
.all(|(expected, actual)| ctx.unifier.unioned(*expected, *actual)));
let args_val = args_ty.iter().zip_eq(args.iter())
.map(|(ty, arg)| {
arg.1.clone()
meta: Apply clippy suggested changes
2023-12-06 11:49:02 +08:00
.to_basic_value_enum(ctx, generator, *ty)
core: Add create_fn_by_* functions Used for abstracting the creation of function from different sources.
2023-10-10 14:56:16 +08:00
.unwrap()
})
.map_into::<BasicMetadataValueEnum>()
.collect_vec();
let intrinsic_fn = ctx.module.get_function(extern_fn).unwrap_or_else(|| {
meta: Apply clippy suggested changes
2023-12-06 11:49:02 +08:00
let ret_llvm_ty = ctx.get_llvm_abi_type(generator, ret_ty);
core: Add create_fn_by_* functions Used for abstracting the creation of function from different sources.
2023-10-10 14:56:16 +08:00
let param_llvm_ty = param_tys.iter()
.map(|p| ctx.get_llvm_abi_type(generator, *p))
.map_into::<BasicMetadataTypeEnum>()
.collect_vec();
let fn_type = ret_llvm_ty.fn_type(param_llvm_ty.as_slice(), false);
let func = ctx.module.add_function(extern_fn, fn_type, None);
func.add_attribute(
AttributeLoc::Function,
ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id("nounwind"), 0)
);
for attr in attrs {
func.add_attribute(
AttributeLoc::Function,
ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0)
);
}
func
});
let call = ctx.builder
.build_call(intrinsic_fn, &args_val, name);
let val = call.try_as_basic_value()
.left()
.unwrap();
Ok(val.into())
}),
)
}
consistent naming
2021-12-02 10:45:46 +08:00
pub fn get_builtins(primitives: &mut (PrimitiveStore, Unifier)) -> BuiltinInfo {
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
let int32 = primitives.0.int32;
let int64 = primitives.0.int64;
basic unsigned integer support
2022-03-05 03:45:09 +08:00
let uint32 = primitives.0.uint32;
let uint64 = primitives.0.uint64;
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
let float = primitives.0.float;
let boolean = primitives.0.bool;
let range = primitives.0.range;
let string = primitives.0.str;
core: Implement most ndarray-creation functions
2023-11-27 13:25:53 +08:00
let ndarray = {
let ndarray_ty = TypeEnum::ndarray(&mut primitives.1, None, None, &primitives.0);
primitives.1.add_ty(ndarray_ty)
};
core: Implement ndarray constructor and numpy.empty
2023-11-17 17:30:27 +08:00
let ndarray_float = {
let ndarray_ty_enum = TypeEnum::ndarray(&mut primitives.1, Some(float), None, &primitives.0);
primitives.1.add_ty(ndarray_ty_enum)
};
core: Implement most ndarray-creation functions
2023-11-27 13:25:53 +08:00
let ndarray_float_2d = {
let value = match primitives.0.size_t {
64 => SymbolValue::U64(2u64),
32 => SymbolValue::U32(2u32),
_ => unreachable!(),
};
let ndims = primitives.1.add_ty(TypeEnum::TLiteral {
values: vec![value],
loc: None,
});
primitives.1.add_ty(TypeEnum::TNDArray {
ty: float,
ndims,
})
};
core: Implement ndarray constructor and numpy.empty
2023-11-17 17:30:27 +08:00
let list_int32 = primitives.1.add_ty(TypeEnum::TList { ty: int32 });
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
let num_ty = primitives.1.get_fresh_var_with_range(
basic unsigned integer support
2022-03-05 03:45:09 +08:00
&[int32, int64, float, boolean, uint32, uint64],
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
Some("N".into()),
None,
);
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
let var_map: HashMap<_, _> = vec![(num_ty.1, num_ty.0)].into_iter().collect();
nac3core: added exception type and fixed primitive representation - Added `Exception` primitive type and some builtin exception types. Note that all exception types share the same layout, and should inherit from the base `Exception` type. There are some hacks in the toplevel module for handling exception types, we should revisit and fix them later. - Added new primitive types to concrete type module, otherwise there would be some weird type errors. - Changed the representation of strings to CSlice<u8>, instead of CString.
2022-02-12 21:09:23 +08:00
let exception_fields = vec![
("__name__".into(), int32, true),
("__file__".into(), string, true),
("__line__".into(), int32, true),
("__col__".into(), int32, true),
("__func__".into(), string, true),
("__message__".into(), string, true),
("__param0__".into(), int64, true),
("__param1__".into(), int64, true),
("__param2__".into(), int64, true),
];
nac3artiq: support more builtin errors
2022-03-16 23:42:08 +08:00
Option type support (#224) Co-authored-by: ychenfo <yc@m-labs.hk> Co-committed-by: ychenfo <yc@m-labs.hk>
2022-03-26 15:09:15 +08:00
// for Option, is_some and is_none share the same type: () -> bool,
// and they are methods under the same class `Option`
let (is_some_ty, unwrap_ty, (option_ty_var, option_ty_var_id)) =
if let TypeEnum::TObj { fields, params, .. } =
primitives.1.get_ty(primitives.0.option).as_ref()
{
(
*fields.get(&"is_some".into()).unwrap(),
*fields.get(&"unwrap".into()).unwrap(),
(*params.iter().next().unwrap().1, *params.iter().next().unwrap().0),
)
} else {
unreachable!()
};
fix compilation warning
2022-03-17 21:23:38 +08:00
let top_level_def_list = vec![
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
Arc::new(RwLock::new(TopLevelComposer::make_top_level_class_def(
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
0,
None,
"int32".into(),
None,
None,
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
))),
Arc::new(RwLock::new(TopLevelComposer::make_top_level_class_def(
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
1,
None,
"int64".into(),
None,
None,
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
))),
Arc::new(RwLock::new(TopLevelComposer::make_top_level_class_def(
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
2,
None,
"float".into(),
None,
None,
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
))),
Arc::new(RwLock::new(TopLevelComposer::make_top_level_class_def(
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
3,
None,
"bool".into(),
None,
None,
))),
Arc::new(RwLock::new(TopLevelComposer::make_top_level_class_def(
4,
None,
"none".into(),
None,
None,
))),
Arc::new(RwLock::new(TopLevelComposer::make_top_level_class_def(
5,
None,
"range".into(),
None,
None,
))),
Arc::new(RwLock::new(TopLevelComposer::make_top_level_class_def(
6,
None,
"str".into(),
None,
None,
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
))),
nac3core: added exception type and fixed primitive representation - Added `Exception` primitive type and some builtin exception types. Note that all exception types share the same layout, and should inherit from the base `Exception` type. There are some hacks in the toplevel module for handling exception types, we should revisit and fix them later. - Added new primitive types to concrete type module, otherwise there would be some weird type errors. - Changed the representation of strings to CSlice<u8>, instead of CString.
2022-02-12 21:09:23 +08:00
Arc::new(RwLock::new(TopLevelDef::Class {
name: "Exception".into(),
object_id: DefinitionId(7),
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
type_vars: Vec::default(),
nac3artiq: support more builtin errors
2022-03-16 23:42:08 +08:00
fields: exception_fields,
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
methods: Vec::default(),
nac3core: added exception type and fixed primitive representation - Added `Exception` primitive type and some builtin exception types. Note that all exception types share the same layout, and should inherit from the base `Exception` type. There are some hacks in the toplevel module for handling exception types, we should revisit and fix them later. - Added new primitive types to concrete type module, otherwise there would be some weird type errors. - Changed the representation of strings to CSlice<u8>, instead of CString.
2022-02-12 21:09:23 +08:00
ancestors: vec![],
constructor: None,
resolver: None,
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
loc: None,
nac3core: added exception type and fixed primitive representation - Added `Exception` primitive type and some builtin exception types. Note that all exception types share the same layout, and should inherit from the base `Exception` type. There are some hacks in the toplevel module for handling exception types, we should revisit and fix them later. - Added new primitive types to concrete type module, otherwise there would be some weird type errors. - Changed the representation of strings to CSlice<u8>, instead of CString.
2022-02-12 21:09:23 +08:00
})),
basic unsigned integer support
2022-03-05 03:45:09 +08:00
Arc::new(RwLock::new(TopLevelComposer::make_top_level_class_def(
8,
None,
"uint32".into(),
None,
None,
))),
Arc::new(RwLock::new(TopLevelComposer::make_top_level_class_def(
9,
None,
"uint64".into(),
None,
None,
))),
Option type support (#224) Co-authored-by: ychenfo <yc@m-labs.hk> Co-committed-by: ychenfo <yc@m-labs.hk>
2022-03-26 15:09:15 +08:00
Arc::new(RwLock::new({
TopLevelDef::Class {
name: "Option".into(),
object_id: DefinitionId(10),
type_vars: vec![option_ty_var],
fields: vec![],
methods: vec![
("is_some".into(), is_some_ty.0, DefinitionId(11)),
("is_none".into(), is_some_ty.0, DefinitionId(12)),
("unwrap".into(), unwrap_ty.0, DefinitionId(13)),
],
ancestors: vec![TypeAnnotation::CustomClass {
id: DefinitionId(10),
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
params: Vec::default(),
Option type support (#224) Co-authored-by: ychenfo <yc@m-labs.hk> Co-committed-by: ychenfo <yc@m-labs.hk>
2022-03-26 15:09:15 +08:00
}],
constructor: None,
resolver: None,
loc: None,
}
})),
Arc::new(RwLock::new(TopLevelDef::Function {
name: "Option.is_some".into(),
simple_name: "is_some".into(),
signature: is_some_ty.0,
var_id: vec![option_ty_var_id],
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
instance_to_symbol: HashMap::default(),
instance_to_stmt: HashMap::default(),
Option type support (#224) Co-authored-by: ychenfo <yc@m-labs.hk> Co-committed-by: ychenfo <yc@m-labs.hk>
2022-03-26 15:09:15 +08:00
resolver: None,
codegen_callback: Some(Arc::new(GenCall::new(Box::new(
|ctx, obj, _, _, generator| {
nac3core, artiq: to_basic_value_enum takes an argument indicating the expected type
2022-04-08 03:26:42 +08:00
let expect_ty = obj.clone().unwrap().0;
let obj_val = obj.unwrap().1.clone().to_basic_value_enum(
ctx,
generator,
expect_ty,
)?;
meta: Refactor to use more let-else bindings
2023-12-12 13:38:27 +08:00
let BasicValueEnum::PointerValue(ptr) = obj_val else {
Option type support (#224) Co-authored-by: ychenfo <yc@m-labs.hk> Co-committed-by: ychenfo <yc@m-labs.hk>
2022-03-26 15:09:15 +08:00
unreachable!("option must be ptr")
meta: Refactor to use more let-else bindings
2023-12-12 13:38:27 +08:00
};
Ok(Some(ctx.builder.build_is_not_null(ptr, "is_some").into()))
Option type support (#224) Co-authored-by: ychenfo <yc@m-labs.hk> Co-committed-by: ychenfo <yc@m-labs.hk>
2022-03-26 15:09:15 +08:00
},
)))),
loc: None,
})),
Arc::new(RwLock::new(TopLevelDef::Function {
name: "Option.is_none".into(),
simple_name: "is_none".into(),
signature: is_some_ty.0,
var_id: vec![option_ty_var_id],
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
instance_to_symbol: HashMap::default(),
instance_to_stmt: HashMap::default(),
Option type support (#224) Co-authored-by: ychenfo <yc@m-labs.hk> Co-committed-by: ychenfo <yc@m-labs.hk>
2022-03-26 15:09:15 +08:00
resolver: None,
codegen_callback: Some(Arc::new(GenCall::new(Box::new(
|ctx, obj, _, _, generator| {
nac3core, artiq: to_basic_value_enum takes an argument indicating the expected type
2022-04-08 03:26:42 +08:00
let expect_ty = obj.clone().unwrap().0;
let obj_val = obj.unwrap().1.clone().to_basic_value_enum(
ctx,
generator,
expect_ty,
)?;
meta: Refactor to use more let-else bindings
2023-12-12 13:38:27 +08:00
let BasicValueEnum::PointerValue(ptr) = obj_val else {
Option type support (#224) Co-authored-by: ychenfo <yc@m-labs.hk> Co-committed-by: ychenfo <yc@m-labs.hk>
2022-03-26 15:09:15 +08:00
unreachable!("option must be ptr")
meta: Refactor to use more let-else bindings
2023-12-12 13:38:27 +08:00
};
Ok(Some(ctx.builder.build_is_null(ptr, "is_none").into()))
Option type support (#224) Co-authored-by: ychenfo <yc@m-labs.hk> Co-committed-by: ychenfo <yc@m-labs.hk>
2022-03-26 15:09:15 +08:00
},
)))),
loc: None,
})),
Arc::new(RwLock::new(TopLevelDef::Function {
name: "Option.unwrap".into(),
simple_name: "unwrap".into(),
signature: unwrap_ty.0,
var_id: vec![option_ty_var_id],
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
instance_to_symbol: HashMap::default(),
instance_to_stmt: HashMap::default(),
Option type support (#224) Co-authored-by: ychenfo <yc@m-labs.hk> Co-committed-by: ychenfo <yc@m-labs.hk>
2022-03-26 15:09:15 +08:00
resolver: None,
codegen_callback: Some(Arc::new(GenCall::new(Box::new(
fix warnings
2022-03-26 18:52:08 +08:00
|_, _, _, _, _| {
Option type support (#224) Co-authored-by: ychenfo <yc@m-labs.hk> Co-committed-by: ychenfo <yc@m-labs.hk>
2022-03-26 15:09:15 +08:00
unreachable!("handled in gen_expr")
},
)))),
loc: None,
})),
core: Initial infrastructure for ndarray
2023-11-06 18:03:52 +08:00
{
let tvar = primitives.1.get_fresh_var(Some("T".into()), None);
let ndims = primitives.1.get_fresh_const_generic_var(primitives.0.uint64, Some("N".into()), None);
Arc::new(RwLock::new(TopLevelDef::Class {
name: "ndarray".into(),
object_id: DefinitionId(14),
type_vars: vec![tvar.0, ndims.0],
fields: Vec::default(),
methods: Vec::default(),
ancestors: Vec::default(),
constructor: None,
resolver: None,
loc: None,
}))
},
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
Arc::new(RwLock::new(TopLevelDef::Function {
name: "int32".into(),
simple_name: "int32".into(),
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
signature: primitives.1.add_ty(TypeEnum::TFunc(FunSignature {
args: vec![FuncArg { name: "n".into(), ty: num_ty.0, default_value: None }],
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
ret: int32,
vars: var_map.clone(),
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
})),
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
var_id: Vec::default(),
instance_to_symbol: HashMap::default(),
instance_to_stmt: HashMap::default(),
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
resolver: None,
codegen_callback: Some(Arc::new(GenCall::new(Box::new(
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
|ctx, _, fun, args, generator| {
core: Fix handling of float-to-int32 casts Out-of-bound conversions should be wrapped around.
2023-11-03 15:05:40 +08:00
let PrimitiveStore {
int32,
int64,
uint32,
uint64,
float,
bool: boolean,
..
} = ctx.primitives;
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
let arg_ty = fun.0.args[0].ty;
nac3core, artiq: to_basic_value_enum takes an argument indicating the expected type
2022-04-08 03:26:42 +08:00
let arg = args[0].1.clone().to_basic_value_enum(ctx, generator, arg_ty)?;
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
Ok(if ctx.unifier.unioned(arg_ty, boolean) {
Some(
ctx.builder
.build_int_z_extend(
arg.into_int_value(),
ctx.ctx.i32_type(),
"zext",
)
.into(),
)
nac3core: type conversion to/from uint
2022-03-05 23:23:32 +08:00
} else if ctx.unifier.unioned(arg_ty, int32)
|| ctx.unifier.unioned(arg_ty, uint32)
{
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
Some(arg)
nac3core: type conversion to/from uint
2022-03-05 23:23:32 +08:00
} else if ctx.unifier.unioned(arg_ty, int64)
|| ctx.unifier.unioned(arg_ty, uint64)
{
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
Some(
ctx.builder
.build_int_truncate(
arg.into_int_value(),
ctx.ctx.i32_type(),
"trunc",
)
.into(),
)
} else if ctx.unifier.unioned(arg_ty, float) {
core: Fix handling of float-to-int32 casts Out-of-bound conversions should be wrapped around.
2023-11-03 15:05:40 +08:00
let to_int64 = ctx
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
.builder
.build_float_to_signed_int(
arg.into_float_value(),
core: Fix handling of float-to-int32 casts Out-of-bound conversions should be wrapped around.
2023-11-03 15:05:40 +08:00
ctx.ctx.i64_type(),
"",
);
let val = ctx.builder
.build_int_truncate(
to_int64,
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
ctx.ctx.i32_type(),
core: Fix handling of float-to-int32 casts Out-of-bound conversions should be wrapped around.
2023-11-03 15:05:40 +08:00
"conv",
);
Some(val.into())
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
} else {
unreachable!()
})
},
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
)))),
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
loc: None,
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
})),
Arc::new(RwLock::new(TopLevelDef::Function {
name: "int64".into(),
simple_name: "int64".into(),
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
signature: primitives.1.add_ty(TypeEnum::TFunc(FunSignature {
args: vec![FuncArg { name: "n".into(), ty: num_ty.0, default_value: None }],
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
ret: int64,
vars: var_map.clone(),
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
})),
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
var_id: Vec::default(),
instance_to_symbol: HashMap::default(),
instance_to_stmt: HashMap::default(),
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
resolver: None,
codegen_callback: Some(Arc::new(GenCall::new(Box::new(
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
|ctx, _, fun, args, generator| {
core: Fix handling of float-to-int32 casts Out-of-bound conversions should be wrapped around.
2023-11-03 15:05:40 +08:00
let PrimitiveStore {
int32,
int64,
uint32,
uint64,
float,
bool: boolean,
..
} = ctx.primitives;
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
let arg_ty = fun.0.args[0].ty;
nac3core, artiq: to_basic_value_enum takes an argument indicating the expected type
2022-04-08 03:26:42 +08:00
let arg = args[0].1.clone().to_basic_value_enum(ctx, generator, arg_ty)?;
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
Ok(
nac3core: type conversion to/from uint
2022-03-05 23:23:32 +08:00
if ctx.unifier.unioned(arg_ty, boolean)
|| ctx.unifier.unioned(arg_ty, uint32)
{
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
Some(
ctx.builder
.build_int_z_extend(
arg.into_int_value(),
ctx.ctx.i64_type(),
"zext",
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
)
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
.into(),
)
nac3core: use signed extension to convert i32 to i64
2022-03-06 04:49:02 +08:00
} else if ctx.unifier.unioned(arg_ty, int32) {
Some(
ctx.builder
.build_int_s_extend(
arg.into_int_value(),
ctx.ctx.i64_type(),
"sext",
)
.into(),
)
nac3core: type conversion to/from uint
2022-03-05 23:23:32 +08:00
} else if ctx.unifier.unioned(arg_ty, int64)
|| ctx.unifier.unioned(arg_ty, uint64)
{
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
Some(arg)
} else if ctx.unifier.unioned(arg_ty, float) {
let val = ctx
.builder
.build_float_to_signed_int(
arg.into_float_value(),
ctx.ctx.i64_type(),
"fptosi",
)
.into();
Some(val)
} else {
unreachable!()
},
)
},
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
)))),
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
loc: None,
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
})),
basic unsigned integer support
2022-03-05 03:45:09 +08:00
Arc::new(RwLock::new(TopLevelDef::Function {
name: "uint32".into(),
simple_name: "uint32".into(),
signature: primitives.1.add_ty(TypeEnum::TFunc(FunSignature {
args: vec![FuncArg { name: "n".into(), ty: num_ty.0, default_value: None }],
ret: uint32,
vars: var_map.clone(),
})),
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
var_id: Vec::default(),
instance_to_symbol: HashMap::default(),
instance_to_stmt: HashMap::default(),
basic unsigned integer support
2022-03-05 03:45:09 +08:00
resolver: None,
codegen_callback: Some(Arc::new(GenCall::new(Box::new(
|ctx, _, fun, args, generator| {
core: Fix handling of float-to-int32 casts Out-of-bound conversions should be wrapped around.
2023-11-03 15:05:40 +08:00
let PrimitiveStore {
int32,
int64,
uint32,
uint64,
float,
bool: boolean,
..
} = ctx.primitives;
nac3core: type conversion to/from uint
2022-03-05 23:23:32 +08:00
let arg_ty = fun.0.args[0].ty;
nac3core, artiq: to_basic_value_enum takes an argument indicating the expected type
2022-04-08 03:26:42 +08:00
let arg = args[0].1.clone().to_basic_value_enum(ctx, generator, arg_ty)?;
nac3core: type conversion to/from uint
2022-03-05 23:23:32 +08:00
let res = if ctx.unifier.unioned(arg_ty, boolean) {
ctx.builder
.build_int_z_extend(arg.into_int_value(), ctx.ctx.i64_type(), "zext")
.into()
} else if ctx.unifier.unioned(arg_ty, int32)
|| ctx.unifier.unioned(arg_ty, uint32)
{
arg
} else if ctx.unifier.unioned(arg_ty, int64)
|| ctx.unifier.unioned(arg_ty, uint64)
{
ctx.builder
.build_int_truncate(arg.into_int_value(), ctx.ctx.i32_type(), "trunc")
.into()
} else if ctx.unifier.unioned(arg_ty, float) {
core: Fix conversion from float to unsigned types These conversions also need to wraparound.
2023-11-03 15:34:07 +08:00
let llvm_i32 = ctx.ctx.i32_type();
let llvm_i64 = ctx.ctx.i64_type();
let arg = arg.into_float_value();
let arg_gez = ctx.builder
.build_float_compare(FloatPredicate::OGE, arg, arg.get_type().const_zero(), "");
let to_int32 = ctx.builder
.build_float_to_signed_int(
arg,
llvm_i32,
""
);
let to_uint64 = ctx.builder
nac3core: type conversion to/from uint
2022-03-05 23:23:32 +08:00
.build_float_to_unsigned_int(
core: Fix conversion from float to unsigned types These conversions also need to wraparound.
2023-11-03 15:34:07 +08:00
arg,
llvm_i64,
""
);
let val = ctx.builder.build_select(
arg_gez,
ctx.builder.build_int_truncate(to_uint64, llvm_i32, ""),
to_int32,
"conv"
);
meta: Apply clippy suggested changes
2023-12-06 11:49:02 +08:00
val
nac3core: type conversion to/from uint
2022-03-05 23:23:32 +08:00
} else {
meta: Refactor to use more let-else bindings
2023-12-12 13:38:27 +08:00
unreachable!()
nac3core: type conversion to/from uint
2022-03-05 23:23:32 +08:00
};
Ok(Some(res))
basic unsigned integer support
2022-03-05 03:45:09 +08:00
},
)))),
loc: None,
})),
Arc::new(RwLock::new(TopLevelDef::Function {
name: "uint64".into(),
simple_name: "uint64".into(),
signature: primitives.1.add_ty(TypeEnum::TFunc(FunSignature {
args: vec![FuncArg { name: "n".into(), ty: num_ty.0, default_value: None }],
ret: uint64,
vars: var_map.clone(),
})),
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
var_id: Vec::default(),
instance_to_symbol: HashMap::default(),
instance_to_stmt: HashMap::default(),
basic unsigned integer support
2022-03-05 03:45:09 +08:00
resolver: None,
codegen_callback: Some(Arc::new(GenCall::new(Box::new(
|ctx, _, fun, args, generator| {
core: Fix handling of float-to-int32 casts Out-of-bound conversions should be wrapped around.
2023-11-03 15:05:40 +08:00
let PrimitiveStore {
int32,
int64,
uint32,
uint64,
float,
bool: boolean,
..
} = ctx.primitives;
nac3core: type conversion to/from uint
2022-03-05 23:23:32 +08:00
let arg_ty = fun.0.args[0].ty;
nac3core, artiq: to_basic_value_enum takes an argument indicating the expected type
2022-04-08 03:26:42 +08:00
let arg = args[0].1.clone().to_basic_value_enum(ctx, generator, arg_ty)?;
core: Fix int32-to-uint64 conversion This conversion should be sign-extended.
2023-11-03 15:55:16 +08:00
let res = if ctx.unifier.unioned(arg_ty, uint32)
nac3core: type conversion to/from uint
2022-03-05 23:23:32 +08:00
|| ctx.unifier.unioned(arg_ty, boolean)
{
ctx.builder
.build_int_z_extend(arg.into_int_value(), ctx.ctx.i64_type(), "zext")
.into()
core: Fix int32-to-uint64 conversion This conversion should be sign-extended.
2023-11-03 15:55:16 +08:00
} else if ctx.unifier.unioned(arg_ty, int32) {
ctx.builder
.build_int_s_extend(arg.into_int_value(), ctx.ctx.i64_type(), "sext")
.into()
nac3core: type conversion to/from uint
2022-03-05 23:23:32 +08:00
} else if ctx.unifier.unioned(arg_ty, int64)
|| ctx.unifier.unioned(arg_ty, uint64)
{
arg
} else if ctx.unifier.unioned(arg_ty, float) {
core: Fix conversion from float to unsigned types These conversions also need to wraparound.
2023-11-03 15:34:07 +08:00
let llvm_i64 = ctx.ctx.i64_type();
let arg = arg.into_float_value();
let arg_gez = ctx.builder
.build_float_compare(FloatPredicate::OGE, arg, arg.get_type().const_zero(), "");
let to_int64 = ctx.builder
.build_float_to_signed_int(
arg,
llvm_i64,
""
);
let to_uint64 = ctx.builder
nac3core: type conversion to/from uint
2022-03-05 23:23:32 +08:00
.build_float_to_unsigned_int(
core: Fix conversion from float to unsigned types These conversions also need to wraparound.
2023-11-03 15:34:07 +08:00
arg,
llvm_i64,
""
);
let val = ctx.builder.build_select(
arg_gez,
to_uint64,
to_int64,
"conv"
);
meta: Apply clippy suggested changes
2023-12-06 11:49:02 +08:00
val
nac3core: type conversion to/from uint
2022-03-05 23:23:32 +08:00
} else {
meta: Refactor to use more let-else bindings
2023-12-12 13:38:27 +08:00
unreachable!()
nac3core: type conversion to/from uint
2022-03-05 23:23:32 +08:00
};
Ok(Some(res))
basic unsigned integer support
2022-03-05 03:45:09 +08:00
},
)))),
loc: None,
})),
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
Arc::new(RwLock::new(TopLevelDef::Function {
name: "float".into(),
simple_name: "float".into(),
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
signature: primitives.1.add_ty(TypeEnum::TFunc(FunSignature {
args: vec![FuncArg { name: "n".into(), ty: num_ty.0, default_value: None }],
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
ret: float,
vars: var_map.clone(),
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
})),
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
var_id: Vec::default(),
instance_to_symbol: HashMap::default(),
instance_to_stmt: HashMap::default(),
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
resolver: None,
codegen_callback: Some(Arc::new(GenCall::new(Box::new(
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
|ctx, _, fun, args, generator| {
core: Fix conversion from float to unsigned types These conversions also need to wraparound.
2023-11-03 15:34:07 +08:00
let PrimitiveStore {
int32,
int64,
uint32,
uint64,
float,
bool: boolean,
..
} = ctx.primitives;
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
let arg_ty = fun.0.args[0].ty;
nac3core, artiq: to_basic_value_enum takes an argument indicating the expected type
2022-04-08 03:26:42 +08:00
let arg = args[0].1.clone().to_basic_value_enum(ctx, generator, arg_ty)?;
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
Ok(
core: Fix conversion from float to unsigned types These conversions also need to wraparound.
2023-11-03 15:34:07 +08:00
if [boolean, int32, int64].iter().any(|ty| ctx.unifier.unioned(arg_ty, *ty))
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
{
let arg = arg.into_int_value();
let val = ctx
.builder
.build_signed_int_to_float(arg, ctx.ctx.f64_type(), "sitofp")
.into();
Some(val)
core: Fix handling of float-to-int32 casts Out-of-bound conversions should be wrapped around.
2023-11-03 15:05:40 +08:00
} else if [uint32, uint64].iter().any(|ty| ctx.unifier.unioned(arg_ty, *ty)) {
let arg = arg.into_int_value();
let val = ctx
.builder
.build_unsigned_int_to_float(arg, ctx.ctx.f64_type(), "uitofp")
.into();
Some(val)
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
} else if ctx.unifier.unioned(arg_ty, float) {
Some(arg)
} else {
unreachable!()
},
)
},
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
)))),
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
loc: None,
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
})),
core: Implement ndarray constructor and numpy.empty
2023-11-17 17:30:27 +08:00
create_fn_by_codegen(
primitives,
&var_map,
"np_ndarray",
ndarray_float,
// We are using List[int32] here, as I don't know a way to specify an n-tuple bound on a
// type variable
&[(list_int32, "shape")],
Box::new(|ctx, obj, fun, args, generator| {
gen_ndarray_empty(ctx, obj, fun, args, generator)
.map(|val| Some(val.as_basic_value_enum()))
}),
),
create_fn_by_codegen(
primitives,
&var_map,
"np_empty",
ndarray_float,
// We are using List[int32] here, as I don't know a way to specify an n-tuple bound on a
// type variable
&[(list_int32, "shape")],
Box::new(|ctx, obj, fun, args, generator| {
gen_ndarray_empty(ctx, obj, fun, args, generator)
.map(|val| Some(val.as_basic_value_enum()))
}),
),
core: Implement most ndarray-creation functions
2023-11-27 13:25:53 +08:00
create_fn_by_codegen(
primitives,
&var_map,
"np_zeros",
ndarray_float,
// We are using List[int32] here, as I don't know a way to specify an n-tuple bound on a
// type variable
&[(list_int32, "shape")],
Box::new(|ctx, obj, fun, args, generator| {
gen_ndarray_zeros(ctx, obj, fun, args, generator)
.map(|val| Some(val.as_basic_value_enum()))
}),
),
create_fn_by_codegen(
primitives,
&var_map,
"np_ones",
ndarray_float,
// We are using List[int32] here, as I don't know a way to specify an n-tuple bound on a
// type variable
&[(list_int32, "shape")],
Box::new(|ctx, obj, fun, args, generator| {
gen_ndarray_ones(ctx, obj, fun, args, generator)
.map(|val| Some(val.as_basic_value_enum()))
}),
),
{
let tv = primitives.1.get_fresh_var(Some("T".into()), None).0;
create_fn_by_codegen(
primitives,
&var_map,
"np_full",
ndarray,
// We are using List[int32] here, as I don't know a way to specify an n-tuple bound on a
// type variable
&[(list_int32, "shape"), (tv, "fill_value")],
Box::new(|ctx, obj, fun, args, generator| {
gen_ndarray_full(ctx, obj, fun, args, generator)
.map(|val| Some(val.as_basic_value_enum()))
}),
)
},
Arc::new(RwLock::new(TopLevelDef::Function {
name: "np_eye".into(),
simple_name: "np_eye".into(),
signature: primitives.1.add_ty(TypeEnum::TFunc(FunSignature {
args: vec![
FuncArg { name: "N".into(), ty: int32, default_value: None },
// TODO(Derppening): Default values current do not work?
FuncArg {
name: "M".into(),
ty: int32,
default_value: Some(SymbolValue::OptionNone)
},
FuncArg { name: "k".into(), ty: int32, default_value: Some(SymbolValue::I32(0)) },
],
ret: ndarray_float_2d,
vars: var_map.clone(),
})),
var_id: Default::default(),
instance_to_symbol: Default::default(),
instance_to_stmt: Default::default(),
resolver: None,
codegen_callback: Some(Arc::new(GenCall::new(Box::new(
|ctx, obj, fun, args, generator| {
gen_ndarray_eye(ctx, obj, fun, args, generator)
.map(|val| Some(val.as_basic_value_enum()))
},
)))),
loc: None,
})),
create_fn_by_codegen(
primitives,
&var_map,
"np_identity",
ndarray_float_2d,
&[(int32, "n")],
Box::new(|ctx, obj, fun, args, generator| {
gen_ndarray_identity(ctx, obj, fun, args, generator)
.map(|val| Some(val.as_basic_value_enum()))
}),
),
core: Revert breaking changes to round-family functions These functions should return ints as the math.* functions do instead of following the convention of numpy.* functions.
2023-11-02 14:56:35 +08:00
create_fn_by_codegen(
primitives,
&var_map,
"round",
int32,
&[(float, "n")],
Box::new(|ctx, _, _, args, generator| {
let llvm_f64 = ctx.ctx.f64_type();
let llvm_i32 = ctx.ctx.i32_type();
let arg = args[0].1.clone()
.to_basic_value_enum(ctx, generator, ctx.primitives.float)?;
let intrinsic_fn = ctx.module.get_function("llvm.round.f64").unwrap_or_else(|| {
let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
ctx.module.add_function("llvm.round.f64", fn_type, None)
});
let val = ctx
.builder
.build_call(intrinsic_fn, &[arg.into()], "")
.try_as_basic_value()
.left()
.unwrap();
let val_toint = ctx.builder
.build_float_to_signed_int(val.into_float_value(), llvm_i32, "round");
Ok(Some(val_toint.into()))
}),
),
create_fn_by_codegen(
primitives,
&var_map,
"round64",
int64,
&[(float, "n")],
Box::new(|ctx, _, _, args, generator| {
let llvm_f64 = ctx.ctx.f64_type();
let llvm_i64 = ctx.ctx.i64_type();
let arg = args[0].1.clone()
.to_basic_value_enum(ctx, generator, ctx.primitives.float)?;
let intrinsic_fn = ctx.module.get_function("llvm.round.f64").unwrap_or_else(|| {
let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
ctx.module.add_function("llvm.round.f64", fn_type, None)
});
let val = ctx
.builder
.build_call(intrinsic_fn, &[arg.into()], "")
.try_as_basic_value()
.left()
.unwrap();
let val_toint = ctx.builder
.build_float_to_signed_int(val.into_float_value(), llvm_i64, "round");
Ok(Some(val_toint.into()))
}),
),
core: Add np_{round,floor,ceil} These functions are NumPy variants of round/floor/ceil, which returns floats instead of ints.
2023-11-23 13:45:07 +08:00
create_fn_by_codegen(
primitives,
&var_map,
"np_round",
float,
&[(float, "n")],
Box::new(|ctx, _, _, args, generator| {
let llvm_f64 = ctx.ctx.f64_type();
let arg = args[0].1.clone()
.to_basic_value_enum(ctx, generator, ctx.primitives.float)?;
let intrinsic_fn = ctx.module.get_function("llvm.roundeven.f64").unwrap_or_else(|| {
let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
ctx.module.add_function("llvm.roundeven.f64", fn_type, None)
});
let val = ctx
.builder
.build_call(intrinsic_fn, &[arg.into()], "")
.try_as_basic_value()
.left()
.unwrap();
meta: Apply clippy suggested changes
2023-12-06 11:49:02 +08:00
Ok(Some(val))
core: Add np_{round,floor,ceil} These functions are NumPy variants of round/floor/ceil, which returns floats instead of ints.
2023-11-23 13:45:07 +08:00
}),
),
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
Arc::new(RwLock::new(TopLevelDef::Function {
name: "range".into(),
simple_name: "range".into(),
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
signature: primitives.1.add_ty(TypeEnum::TFunc(FunSignature {
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
args: vec![
FuncArg { name: "start".into(), ty: int32, default_value: None },
FuncArg {
name: "stop".into(),
ty: int32,
// placeholder
default_value: Some(SymbolValue::I32(0)),
},
FuncArg {
name: "step".into(),
ty: int32,
default_value: Some(SymbolValue::I32(1)),
},
],
ret: range,
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
vars: HashMap::default(),
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
})),
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
var_id: Vec::default(),
instance_to_symbol: HashMap::default(),
instance_to_stmt: HashMap::default(),
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
resolver: None,
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
codegen_callback: Some(Arc::new(GenCall::new(Box::new(
|ctx, _, _, args, generator| {
let mut start = None;
let mut stop = None;
let mut step = None;
let int32 = ctx.ctx.i32_type();
let zero = int32.const_zero();
nac3core, artiq: to_basic_value_enum takes an argument indicating the expected type
2022-04-08 03:26:42 +08:00
let ty_i32 = ctx.primitives.int32;
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
for (i, arg) in args.iter().enumerate() {
if arg.0 == Some("start".into()) {
nac3core, artiq: to_basic_value_enum takes an argument indicating the expected type
2022-04-08 03:26:42 +08:00
start = Some(arg.1.clone().to_basic_value_enum(ctx, generator, ty_i32)?);
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
} else if arg.0 == Some("stop".into()) {
nac3core, artiq: to_basic_value_enum takes an argument indicating the expected type
2022-04-08 03:26:42 +08:00
stop = Some(arg.1.clone().to_basic_value_enum(ctx, generator, ty_i32)?);
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
} else if arg.0 == Some("step".into()) {
nac3core, artiq: to_basic_value_enum takes an argument indicating the expected type
2022-04-08 03:26:42 +08:00
step = Some(arg.1.clone().to_basic_value_enum(ctx, generator, ty_i32)?);
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
} else if i == 0 {
nac3core, artiq: to_basic_value_enum takes an argument indicating the expected type
2022-04-08 03:26:42 +08:00
start = Some(arg.1.clone().to_basic_value_enum(ctx, generator, ty_i32)?);
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
} else if i == 1 {
nac3core, artiq: to_basic_value_enum takes an argument indicating the expected type
2022-04-08 03:26:42 +08:00
stop = Some(arg.1.clone().to_basic_value_enum(ctx, generator, ty_i32)?);
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
} else if i == 2 {
nac3core, artiq: to_basic_value_enum takes an argument indicating the expected type
2022-04-08 03:26:42 +08:00
step = Some(arg.1.clone().to_basic_value_enum(ctx, generator, ty_i32)?);
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
}
}
nac3core: add bound check for list slice
2022-04-05 14:29:20 +08:00
let step = match step {
Some(step) => {
let step = step.into_int_value();
// assert step != 0, throw exception if not
let not_zero = ctx.builder.build_int_compare(
IntPredicate::NE,
step,
step.get_type().const_zero(),
"range_step_ne",
);
ctx.make_assert(
generator,
not_zero,
"0:ValueError",
"range() step must not be zero",
[None, None, None],
ctx.current_loc,
);
step
}
None => int32.const_int(1, false),
};
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
let stop = stop.unwrap_or_else(|| {
let v = start.unwrap();
start = None;
v
});
let start = start.unwrap_or_else(|| int32.const_zero().into());
let ty = int32.array_type(3);
core: Allocate more stack variables at the beginning of function All allocas for temporary objects are now placed in the beginning of the function. Allocas for on-temporary objects are not modified because these variables may appear in a loop and thus must be uniquely allocated by different allocas.
2023-10-03 18:02:45 +08:00
let ptr = generator.gen_var_alloc(ctx, ty.into(), Some("range")).unwrap();
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
unsafe {
let a = ctx.builder.build_in_bounds_gep(ptr, &[zero, zero], "start");
let b = ctx.builder.build_in_bounds_gep(
ptr,
&[zero, int32.const_int(1, false)],
"end",
);
let c = ctx.builder.build_in_bounds_gep(
ptr,
&[zero, int32.const_int(2, false)],
"step",
);
ctx.builder.build_store(a, start);
ctx.builder.build_store(b, stop);
ctx.builder.build_store(c, step);
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
}
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
Ok(Some(ptr.into()))
},
)))),
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
loc: None,
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
})),
Arc::new(RwLock::new(TopLevelDef::Function {
name: "str".into(),
simple_name: "str".into(),
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
signature: primitives.1.add_ty(TypeEnum::TFunc(FunSignature {
args: vec![FuncArg { name: "s".into(), ty: string, default_value: None }],
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
ret: string,
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
vars: HashMap::default(),
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
})),
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
var_id: Vec::default(),
instance_to_symbol: HashMap::default(),
instance_to_stmt: HashMap::default(),
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
resolver: None,
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
codegen_callback: Some(Arc::new(GenCall::new(Box::new(
nac3core, artiq: to_basic_value_enum takes an argument indicating the expected type
2022-04-08 03:26:42 +08:00
|ctx, _, fun, args, generator| {
let arg_ty = fun.0.args[0].ty;
Ok(Some(args[0].1.clone().to_basic_value_enum(ctx, generator, arg_ty)?))
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
},
)))),
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
loc: None,
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
})),
Arc::new(RwLock::new(TopLevelDef::Function {
name: "bool".into(),
simple_name: "bool".into(),
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
signature: primitives.1.add_ty(TypeEnum::TFunc(FunSignature {
args: vec![FuncArg { name: "n".into(), ty: num_ty.0, default_value: None }],
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
ret: primitives.0.bool,
nac3core: min builtin function
2022-03-08 21:50:28 +08:00
vars: var_map.clone(),
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
})),
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
var_id: Vec::default(),
instance_to_symbol: HashMap::default(),
instance_to_stmt: HashMap::default(),
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
resolver: None,
codegen_callback: Some(Arc::new(GenCall::new(Box::new(
nac3core: function codegen callback changes Added code generator argument to the callback, so it would be easier to write complicated codegen with that callback. To prepare for RPC codegen.
2022-02-12 21:00:12 +08:00
|ctx, _, fun, args, generator| {
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
let int32 = ctx.primitives.int32;
let int64 = ctx.primitives.int64;
let float = ctx.primitives.float;
let boolean = ctx.primitives.bool;
let arg_ty = fun.0.args[0].ty;
nac3core, artiq: to_basic_value_enum takes an argument indicating the expected type
2022-04-08 03:26:42 +08:00
let arg = args[0].1.clone().to_basic_value_enum(ctx, generator, arg_ty)?;
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
Ok(if ctx.unifier.unioned(arg_ty, boolean) {
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
Some(arg)
Merge branch 'master' into built_in_floor_ceil
2021-12-02 01:08:55 +08:00
} else if ctx.unifier.unioned(arg_ty, int32) {
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
Some(
ctx.builder
.build_int_compare(
IntPredicate::NE,
ctx.ctx.i32_type().const_zero(),
arg.into_int_value(),
"bool",
)
.into(),
)
Merge branch 'master' into built_in_floor_ceil
2021-12-02 01:08:55 +08:00
} else if ctx.unifier.unioned(arg_ty, int64) {
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
Some(
ctx.builder
.build_int_compare(
IntPredicate::NE,
ctx.ctx.i64_type().const_zero(),
arg.into_int_value(),
"bool",
)
.into(),
)
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
} else if ctx.unifier.unioned(arg_ty, float) {
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
let val = ctx
.builder
.build_float_compare(
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
// UEQ as bool(nan) is True
FloatPredicate::UEQ,
arg.into_float_value(),
ctx.ctx.f64_type().const_zero(),
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
"bool",
)
.into();
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
Some(val)
} else {
unreachable!()
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
})
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
},
)))),
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
loc: None,
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
})),
core: Revert breaking changes to round-family functions These functions should return ints as the math.* functions do instead of following the convention of numpy.* functions.
2023-11-02 14:56:35 +08:00
create_fn_by_codegen(
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
primitives,
&var_map,
"floor",
core: Revert breaking changes to round-family functions These functions should return ints as the math.* functions do instead of following the convention of numpy.* functions.
2023-11-02 14:56:35 +08:00
int32,
&[(float, "n")],
Box::new(|ctx, _, _, args, generator| {
let llvm_f64 = ctx.ctx.f64_type();
let llvm_i32 = ctx.ctx.i32_type();
let arg = args[0].1.clone()
.to_basic_value_enum(ctx, generator, ctx.primitives.float)?;
let intrinsic_fn = ctx.module.get_function("llvm.floor.f64").unwrap_or_else(|| {
let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
ctx.module.add_function("llvm.floor.f64", fn_type, None)
});
let val = ctx
.builder
.build_call(intrinsic_fn, &[arg.into()], "")
.try_as_basic_value()
.left()
.unwrap();
let val_toint = ctx.builder
.build_float_to_signed_int(val.into_float_value(), llvm_i32, "floor");
Ok(Some(val_toint.into()))
}),
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
),
core: Revert breaking changes to round-family functions These functions should return ints as the math.* functions do instead of following the convention of numpy.* functions.
2023-11-02 14:56:35 +08:00
create_fn_by_codegen(
primitives,
&var_map,
"floor64",
int64,
&[(float, "n")],
Box::new(|ctx, _, _, args, generator| {
let llvm_f64 = ctx.ctx.f64_type();
let llvm_i64 = ctx.ctx.i64_type();
let arg = args[0].1.clone()
.to_basic_value_enum(ctx, generator, ctx.primitives.float)?;
let intrinsic_fn = ctx.module.get_function("llvm.floor.f64").unwrap_or_else(|| {
let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
ctx.module.add_function("llvm.floor.f64", fn_type, None)
});
let val = ctx
.builder
.build_call(intrinsic_fn, &[arg.into()], "")
.try_as_basic_value()
.left()
.unwrap();
let val_toint = ctx.builder
.build_float_to_signed_int(val.into_float_value(), llvm_i64, "floor");
Ok(Some(val_toint.into()))
}),
),
core: Add np_{round,floor,ceil} These functions are NumPy variants of round/floor/ceil, which returns floats instead of ints.
2023-11-23 13:45:07 +08:00
create_fn_by_codegen(
primitives,
&var_map,
"np_floor",
float,
&[(float, "n")],
Box::new(|ctx, _, _, args, generator| {
let llvm_f64 = ctx.ctx.f64_type();
let arg = args[0].1.clone()
.to_basic_value_enum(ctx, generator, ctx.primitives.float)?;
let intrinsic_fn = ctx.module.get_function("llvm.floor.f64").unwrap_or_else(|| {
let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
ctx.module.add_function("llvm.floor.f64", fn_type, None)
});
let val = ctx
.builder
.build_call(intrinsic_fn, &[arg.into()], "")
.try_as_basic_value()
.left()
.unwrap();
meta: Apply clippy suggested changes
2023-12-06 11:49:02 +08:00
Ok(Some(val))
core: Add np_{round,floor,ceil} These functions are NumPy variants of round/floor/ceil, which returns floats instead of ints.
2023-11-23 13:45:07 +08:00
}),
),
core: Revert breaking changes to round-family functions These functions should return ints as the math.* functions do instead of following the convention of numpy.* functions.
2023-11-02 14:56:35 +08:00
create_fn_by_codegen(
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
primitives,
&var_map,
"ceil",
core: Revert breaking changes to round-family functions These functions should return ints as the math.* functions do instead of following the convention of numpy.* functions.
2023-11-02 14:56:35 +08:00
int32,
&[(float, "n")],
Box::new(|ctx, _, _, args, generator| {
let llvm_f64 = ctx.ctx.f64_type();
let llvm_i32 = ctx.ctx.i32_type();
let arg = args[0].1.clone()
.to_basic_value_enum(ctx, generator, ctx.primitives.float)?;
let intrinsic_fn = ctx.module.get_function("llvm.ceil.f64").unwrap_or_else(|| {
let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
ctx.module.add_function("llvm.ceil.f64", fn_type, None)
});
let val = ctx
.builder
.build_call(intrinsic_fn, &[arg.into()], "")
.try_as_basic_value()
.left()
.unwrap();
let val_toint = ctx.builder
.build_float_to_signed_int(val.into_float_value(), llvm_i32, "ceil");
Ok(Some(val_toint.into()))
}),
),
create_fn_by_codegen(
primitives,
&var_map,
"ceil64",
int64,
&[(float, "n")],
Box::new(|ctx, _, _, args, generator| {
let llvm_f64 = ctx.ctx.f64_type();
let llvm_i64 = ctx.ctx.i64_type();
let arg = args[0].1.clone()
.to_basic_value_enum(ctx, generator, ctx.primitives.float)?;
let intrinsic_fn = ctx.module.get_function("llvm.ceil.f64").unwrap_or_else(|| {
let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
ctx.module.add_function("llvm.ceil.f64", fn_type, None)
});
let val = ctx
.builder
.build_call(intrinsic_fn, &[arg.into()], "")
.try_as_basic_value()
.left()
.unwrap();
let val_toint = ctx.builder
.build_float_to_signed_int(val.into_float_value(), llvm_i64, "ceil");
Ok(Some(val_toint.into()))
}),
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
),
core: Add np_{round,floor,ceil} These functions are NumPy variants of round/floor/ceil, which returns floats instead of ints.
2023-11-23 13:45:07 +08:00
create_fn_by_codegen(
primitives,
&var_map,
"np_ceil",
float,
&[(float, "n")],
Box::new(|ctx, _, _, args, generator| {
let llvm_f64 = ctx.ctx.f64_type();
let arg = args[0].1.clone()
.to_basic_value_enum(ctx, generator, ctx.primitives.float)?;
let intrinsic_fn = ctx.module.get_function("llvm.ceil.f64").unwrap_or_else(|| {
let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
ctx.module.add_function("llvm.ceil.f64", fn_type, None)
});
let val = ctx
.builder
.build_call(intrinsic_fn, &[arg.into()], "")
.try_as_basic_value()
.left()
.unwrap();
meta: Apply clippy suggested changes
2023-12-06 11:49:02 +08:00
Ok(Some(val))
core: Add np_{round,floor,ceil} These functions are NumPy variants of round/floor/ceil, which returns floats instead of ints.
2023-11-23 13:45:07 +08:00
}),
),
nac3core: add len support for list and range
2021-12-09 01:14:28 +08:00
Arc::new(RwLock::new({
core: Initial infrastructure for ndarray
2023-11-06 18:03:52 +08:00
let tvar = primitives.1.get_fresh_var(Some("L".into()), None);
let list = primitives.1.add_ty(TypeEnum::TList { ty: tvar.0 });
let ndims = primitives.1.get_fresh_const_generic_var(primitives.0.uint64, Some("N".into()), None);
let ndarray = primitives.1.add_ty(TypeEnum::TNDArray { ty: tvar.0, ndims: ndims.0 });
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
let arg_ty = primitives.1.get_fresh_var_with_range(
core: Initial infrastructure for ndarray
2023-11-06 18:03:52 +08:00
&[list, ndarray, primitives.0.range],
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
Some("I".into()),
None,
);
nac3core: add len support for list and range
2021-12-09 01:14:28 +08:00
TopLevelDef::Function {
name: "len".into(),
simple_name: "len".into(),
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
signature: primitives.1.add_ty(TypeEnum::TFunc(FunSignature {
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
args: vec![FuncArg { name: "ls".into(), ty: arg_ty.0, default_value: None }],
return int32 in len(). Closes #141
2021-12-20 17:44:42 +08:00
ret: int32,
core: Initial infrastructure for ndarray
2023-11-06 18:03:52 +08:00
vars: vec![(tvar.1, tvar.0), (arg_ty.1, arg_ty.0)]
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
.into_iter()
.collect(),
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
})),
nac3core: fix len on range with step of different sign
2021-12-12 05:52:22 +08:00
var_id: vec![arg_ty.1],
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
instance_to_symbol: HashMap::default(),
instance_to_stmt: HashMap::default(),
nac3core: add len support for list and range
2021-12-09 01:14:28 +08:00
resolver: None,
codegen_callback: Some(Arc::new(GenCall::new(Box::new(
nac3core: function codegen callback changes Added code generator argument to the callback, so it would be easier to write complicated codegen with that callback. To prepare for RPC codegen.
2022-02-12 21:00:12 +08:00
|ctx, _, fun, args, generator| {
nac3core: add len support for list and range
2021-12-09 01:14:28 +08:00
let range_ty = ctx.primitives.range;
let arg_ty = fun.0.args[0].ty;
nac3core, artiq: to_basic_value_enum takes an argument indicating the expected type
2022-04-08 03:26:42 +08:00
let arg = args[0].1.clone().to_basic_value_enum(ctx, generator, arg_ty)?;
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
Ok(if ctx.unifier.unioned(arg_ty, range_ty) {
core: Add RangeValue and helper functions
2024-01-23 18:27:00 +08:00
let arg = RangeValue::from_ptr_val(arg.into_pointer_value(), Some("range"));
nac3core: add len support for list and range
2021-12-09 01:14:28 +08:00
let (start, end, step) = destructure_range(ctx, arg);
nac3core: add bound check for list slice
2022-04-05 14:29:20 +08:00
Some(calculate_len_for_slice_range(generator, ctx, start, end, step).into())
nac3core: add len support for list and range
2021-12-09 01:14:28 +08:00
} else {
core: Initial infrastructure for ndarray
2023-11-06 18:03:52 +08:00
match &*ctx.unifier.get_ty_immutable(arg_ty) {
TypeEnum::TList { .. } => {
let int32 = ctx.ctx.i32_type();
let zero = int32.const_zero();
let len = ctx
.build_gep_and_load(
arg.into_pointer_value(),
&[zero, int32.const_int(1, false)],
None,
)
.into_int_value();
if len.get_type().get_bit_width() == 32 {
Some(len.into())
} else {
Some(ctx.builder.build_int_truncate(len, int32, "len2i32").into())
}
}
core: Implement most ndarray-creation functions
2023-11-27 13:25:53 +08:00
TypeEnum::TNDArray { .. } => {
let llvm_i32 = ctx.ctx.i32_type();
let i32_zero = llvm_i32.const_zero();
let len = ctx.build_gep_and_load(
arg.into_pointer_value(),
&[i32_zero, i32_zero],
None,
).into_int_value();
if len.get_type().get_bit_width() != 32 {
Some(ctx.builder.build_int_truncate(len, llvm_i32, "len").into())
} else {
Some(len.into())
}
}
core: Initial infrastructure for ndarray
2023-11-06 18:03:52 +08:00
_ => unreachable!(),
fixed https://git.m-labs.hk/M-Labs/nac3/pulls/146
2021-12-27 22:50:36 +08:00
}
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
})
nac3core: add len support for list and range
2021-12-09 01:14:28 +08:00
},
)))),
nac3core: refactored for better error messages
2022-02-21 17:52:34 +08:00
loc: None,
nac3core: add len support for list and range
2021-12-09 01:14:28 +08:00
}
applied rustfmt and clippy auto fix
2022-02-21 18:27:46 +08:00
})),
nac3core: min builtin function
2022-03-08 21:50:28 +08:00
Arc::new(RwLock::new(TopLevelDef::Function {
name: "min".into(),
simple_name: "min".into(),
signature: primitives.1.add_ty(TypeEnum::TFunc(FunSignature {
args: vec![
FuncArg { name: "m".into(), ty: num_ty.0, default_value: None },
FuncArg { name: "n".into(), ty: num_ty.0, default_value: None },
],
ret: num_ty.0,
nac3core: max builtin function
2022-03-08 22:22:00 +08:00
vars: var_map.clone(),
nac3core: min builtin function
2022-03-08 21:50:28 +08:00
})),
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
var_id: Vec::default(),
instance_to_symbol: HashMap::default(),
instance_to_stmt: HashMap::default(),
nac3core: min builtin function
2022-03-08 21:50:28 +08:00
resolver: None,
codegen_callback: Some(Arc::new(GenCall::new(Box::new(
|ctx, _, fun, args, generator| {
let boolean = ctx.primitives.bool;
let int32 = ctx.primitives.int32;
let int64 = ctx.primitives.int64;
let uint32 = ctx.primitives.uint32;
let uint64 = ctx.primitives.uint64;
let float = ctx.primitives.float;
core: Use i8 for boolean variable allocation In LLVM, i1 represents a 1-byte integer with a single valid bit; The rest of the 7 upper bits are undefined. This causes problems when using these variables in memory operations (e.g. memcpy/memmove as needed by List slicing and assignment). We fix this by treating all local boolean variables as i8 so that they are well-defined for memory operations. Function ABIs will continue to use i1, as memory operations cannot be directly performed on function arguments or return types, instead they are always converted back into local boolean variables (which are i8s anyways). Fixes #315.
2023-09-20 13:34:50 +08:00
let llvm_i8 = ctx.ctx.i8_type().as_basic_type_enum();
nac3core: min builtin function
2022-03-08 21:50:28 +08:00
let llvm_i32 = ctx.ctx.i32_type().as_basic_type_enum();
let llvm_i64 = ctx.ctx.i64_type().as_basic_type_enum();
let llvm_f64 = ctx.ctx.f64_type().as_basic_type_enum();
let m_ty = fun.0.args[0].ty;
let n_ty = fun.0.args[1].ty;
nac3core, artiq: to_basic_value_enum takes an argument indicating the expected type
2022-04-08 03:26:42 +08:00
let m_val = args[0].1.clone().to_basic_value_enum(ctx, generator, m_ty)?;
let n_val = args[1].1.clone().to_basic_value_enum(ctx, generator, n_ty)?;
nac3core: min builtin function
2022-03-08 21:50:28 +08:00
let mut is_type = |a: Type, b: Type| ctx.unifier.unioned(a, b);
let (fun_name, arg_ty) = if is_type(m_ty, n_ty) && is_type(n_ty, boolean) {
core: Use i8 for boolean variable allocation In LLVM, i1 represents a 1-byte integer with a single valid bit; The rest of the 7 upper bits are undefined. This causes problems when using these variables in memory operations (e.g. memcpy/memmove as needed by List slicing and assignment). We fix this by treating all local boolean variables as i8 so that they are well-defined for memory operations. Function ABIs will continue to use i1, as memory operations cannot be directly performed on function arguments or return types, instead they are always converted back into local boolean variables (which are i8s anyways). Fixes #315.
2023-09-20 13:34:50 +08:00
("llvm.umin.i8", llvm_i8)
nac3core: min builtin function
2022-03-08 21:50:28 +08:00
} else if is_type(m_ty, n_ty) && is_type(n_ty, int32) {
("llvm.smin.i32", llvm_i32)
} else if is_type(m_ty, n_ty) && is_type(n_ty, int64) {
("llvm.smin.i64", llvm_i64)
} else if is_type(m_ty, n_ty) && is_type(n_ty, uint32) {
("llvm.umin.i32", llvm_i32)
} else if is_type(m_ty, n_ty) && is_type(n_ty, uint64) {
("llvm.umin.i64", llvm_i64)
} else if is_type(m_ty, n_ty) && is_type(n_ty, float) {
("llvm.minnum.f64", llvm_f64)
} else {
meta: Refactor to use more let-else bindings
2023-12-12 13:38:27 +08:00
unreachable!()
nac3core: min builtin function
2022-03-08 21:50:28 +08:00
};
let intrinsic = ctx.module.get_function(fun_name).unwrap_or_else(|| {
let fn_type = arg_ty.fn_type(&[arg_ty.into(), arg_ty.into()], false);
ctx.module.add_function(fun_name, fn_type, None)
});
let val = ctx
.builder
.build_call(intrinsic, &[m_val.into(), n_val.into()], "min")
.try_as_basic_value()
.left()
.unwrap();
Ok(val.into())
},
)))),
loc: None,
})),
nac3core: max builtin function
2022-03-08 22:22:00 +08:00
Arc::new(RwLock::new(TopLevelDef::Function {
name: "max".into(),
simple_name: "max".into(),
signature: primitives.1.add_ty(TypeEnum::TFunc(FunSignature {
args: vec![
FuncArg { name: "m".into(), ty: num_ty.0, default_value: None },
FuncArg { name: "n".into(), ty: num_ty.0, default_value: None },
],
ret: num_ty.0,
nac3core: abs builtin function
2022-03-08 23:02:25 +08:00
vars: var_map.clone(),
nac3core: max builtin function
2022-03-08 22:22:00 +08:00
})),
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
var_id: Vec::default(),
instance_to_symbol: HashMap::default(),
instance_to_stmt: HashMap::default(),
nac3core: max builtin function
2022-03-08 22:22:00 +08:00
resolver: None,
codegen_callback: Some(Arc::new(GenCall::new(Box::new(
|ctx, _, fun, args, generator| {
let boolean = ctx.primitives.bool;
let int32 = ctx.primitives.int32;
let int64 = ctx.primitives.int64;
let uint32 = ctx.primitives.uint32;
let uint64 = ctx.primitives.uint64;
let float = ctx.primitives.float;
core: Use i8 for boolean variable allocation In LLVM, i1 represents a 1-byte integer with a single valid bit; The rest of the 7 upper bits are undefined. This causes problems when using these variables in memory operations (e.g. memcpy/memmove as needed by List slicing and assignment). We fix this by treating all local boolean variables as i8 so that they are well-defined for memory operations. Function ABIs will continue to use i1, as memory operations cannot be directly performed on function arguments or return types, instead they are always converted back into local boolean variables (which are i8s anyways). Fixes #315.
2023-09-20 13:34:50 +08:00
let llvm_i8 = ctx.ctx.i8_type().as_basic_type_enum();
nac3core: max builtin function
2022-03-08 22:22:00 +08:00
let llvm_i32 = ctx.ctx.i32_type().as_basic_type_enum();
let llvm_i64 = ctx.ctx.i64_type().as_basic_type_enum();
let llvm_f64 = ctx.ctx.f64_type().as_basic_type_enum();
let m_ty = fun.0.args[0].ty;
let n_ty = fun.0.args[1].ty;
nac3core, artiq: to_basic_value_enum takes an argument indicating the expected type
2022-04-08 03:26:42 +08:00
let m_val = args[0].1.clone().to_basic_value_enum(ctx, generator, m_ty)?;
let n_val = args[1].1.clone().to_basic_value_enum(ctx, generator, n_ty)?;
nac3core: max builtin function
2022-03-08 22:22:00 +08:00
let mut is_type = |a: Type, b: Type| ctx.unifier.unioned(a, b);
let (fun_name, arg_ty) = if is_type(m_ty, n_ty) && is_type(n_ty, boolean) {
core: Use i8 for boolean variable allocation In LLVM, i1 represents a 1-byte integer with a single valid bit; The rest of the 7 upper bits are undefined. This causes problems when using these variables in memory operations (e.g. memcpy/memmove as needed by List slicing and assignment). We fix this by treating all local boolean variables as i8 so that they are well-defined for memory operations. Function ABIs will continue to use i1, as memory operations cannot be directly performed on function arguments or return types, instead they are always converted back into local boolean variables (which are i8s anyways). Fixes #315.
2023-09-20 13:34:50 +08:00
("llvm.umax.i8", llvm_i8)
nac3core: max builtin function
2022-03-08 22:22:00 +08:00
} else if is_type(m_ty, n_ty) && is_type(n_ty, int32) {
("llvm.smax.i32", llvm_i32)
} else if is_type(m_ty, n_ty) && is_type(n_ty, int64) {
("llvm.smax.i64", llvm_i64)
} else if is_type(m_ty, n_ty) && is_type(n_ty, uint32) {
("llvm.umax.i32", llvm_i32)
} else if is_type(m_ty, n_ty) && is_type(n_ty, uint64) {
("llvm.umax.i64", llvm_i64)
} else if is_type(m_ty, n_ty) && is_type(n_ty, float) {
("llvm.maxnum.f64", llvm_f64)
} else {
meta: Refactor to use more let-else bindings
2023-12-12 13:38:27 +08:00
unreachable!()
nac3core: max builtin function
2022-03-08 22:22:00 +08:00
};
let intrinsic = ctx.module.get_function(fun_name).unwrap_or_else(|| {
let fn_type = arg_ty.fn_type(&[arg_ty.into(), arg_ty.into()], false);
ctx.module.add_function(fun_name, fn_type, None)
});
let val = ctx
.builder
.build_call(intrinsic, &[m_val.into(), n_val.into()], "max")
.try_as_basic_value()
.left()
.unwrap();
Ok(val.into())
},
)))),
loc: None,
})),
nac3core: abs builtin function
2022-03-08 23:02:25 +08:00
Arc::new(RwLock::new(TopLevelDef::Function {
name: "abs".into(),
simple_name: "abs".into(),
signature: primitives.1.add_ty(TypeEnum::TFunc(FunSignature {
args: vec![FuncArg { name: "n".into(), ty: num_ty.0, default_value: None }],
ret: num_ty.0,
core: Add create_fn_by_* functions Used for abstracting the creation of function from different sources.
2023-10-10 14:56:16 +08:00
vars: var_map.clone(),
nac3core: abs builtin function
2022-03-08 23:02:25 +08:00
})),
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
var_id: Vec::default(),
instance_to_symbol: HashMap::default(),
instance_to_stmt: HashMap::default(),
nac3core: abs builtin function
2022-03-08 23:02:25 +08:00
resolver: None,
codegen_callback: Some(Arc::new(GenCall::new(Box::new(
|ctx, _, fun, args, generator| {
let boolean = ctx.primitives.bool;
let int32 = ctx.primitives.int32;
let int64 = ctx.primitives.int64;
let uint32 = ctx.primitives.uint32;
let uint64 = ctx.primitives.uint64;
let float = ctx.primitives.float;
let llvm_i1 = ctx.ctx.bool_type();
let llvm_i32 = ctx.ctx.i32_type().as_basic_type_enum();
let llvm_i64 = ctx.ctx.i64_type().as_basic_type_enum();
let llvm_f64 = ctx.ctx.f64_type().as_basic_type_enum();
let n_ty = fun.0.args[0].ty;
nac3core, artiq: to_basic_value_enum takes an argument indicating the expected type
2022-04-08 03:26:42 +08:00
let n_val = args[0].1.clone().to_basic_value_enum(ctx, generator, n_ty)?;
nac3core: abs builtin function
2022-03-08 23:02:25 +08:00
let mut is_type = |a: Type, b: Type| ctx.unifier.unioned(a, b);
let mut is_float = false;
let (fun_name, arg_ty) =
if is_type(n_ty, boolean) || is_type(n_ty, uint32) || is_type(n_ty, uint64)
{
return Ok(n_val.into());
} else if is_type(n_ty, int32) {
("llvm.abs.i32", llvm_i32)
} else if is_type(n_ty, int64) {
("llvm.abs.i64", llvm_i64)
} else if is_type(n_ty, float) {
is_float = true;
("llvm.fabs.f64", llvm_f64)
} else {
meta: Refactor to use more let-else bindings
2023-12-12 13:38:27 +08:00
unreachable!()
nac3core: abs builtin function
2022-03-08 23:02:25 +08:00
};
let intrinsic = ctx.module.get_function(fun_name).unwrap_or_else(|| {
let fn_type = if is_float {
arg_ty.fn_type(&[arg_ty.into()], false)
} else {
arg_ty.fn_type(&[arg_ty.into(), llvm_i1.into()], false)
};
ctx.module.add_function(fun_name, fn_type, None)
});
let val = ctx
.builder
.build_call(
intrinsic,
&if is_float {
vec![n_val.into()]
} else {
vec![n_val.into(), llvm_i1.const_int(0, false).into()]
},
"abs",
)
.try_as_basic_value()
.left()
.unwrap();
Ok(val.into())
},
)))),
loc: None,
})),
core: Implement and expose {isinf,isnan}
2023-10-10 16:56:38 +08:00
create_fn_by_codegen(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_isnan",
core: Implement and expose {isinf,isnan}
2023-10-10 16:56:38 +08:00
boolean,
&[(float, "x")],
Box::new(|ctx, _, fun, args, generator| {
let float = ctx.primitives.float;
let x_ty = fun.0.args[0].ty;
let x_val = args[0].1.clone()
.to_basic_value_enum(ctx, generator, x_ty)?;
assert!(ctx.unifier.unioned(x_ty, float));
let val = call_isnan(generator, ctx, x_val.into_float_value());
Ok(Some(val.into()))
}),
),
create_fn_by_codegen(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_isinf",
core: Implement and expose {isinf,isnan}
2023-10-10 16:56:38 +08:00
boolean,
&[(float, "x")],
Box::new(|ctx, _, fun, args, generator| {
let float = ctx.primitives.float;
let x_ty = fun.0.args[0].ty;
let x_val = args[0].1.clone()
.to_basic_value_enum(ctx, generator, x_ty)?;
assert!(ctx.unifier.unioned(x_ty, float));
let val = call_isinf(generator, ctx, x_val.into_float_value());
Ok(Some(val.into()))
}),
),
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
create_fn_by_intrinsic(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_sin",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
"llvm.sin.f64",
),
create_fn_by_intrinsic(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_cos",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
"llvm.cos.f64",
),
create_fn_by_intrinsic(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_exp",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
"llvm.exp.f64",
),
create_fn_by_intrinsic(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_exp2",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
"llvm.exp2.f64",
),
create_fn_by_intrinsic(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_log",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
"llvm.log.f64",
),
create_fn_by_intrinsic(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_log10",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
"llvm.log10.f64",
),
create_fn_by_intrinsic(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_log2",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
"llvm.log2.f64",
),
create_fn_by_intrinsic(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_fabs",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
"llvm.fabs.f64",
),
create_fn_by_intrinsic(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_sqrt",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
"llvm.sqrt.f64",
),
core: Replace rint implementation with LLVM intrinsic
2023-11-02 14:48:25 +08:00
create_fn_by_intrinsic(
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_rint",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
core: Replace rint implementation with LLVM intrinsic
2023-11-02 14:48:25 +08:00
"llvm.roundeven.f64",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
),
create_fn_by_extern(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_tan",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
"tan",
&[],
),
create_fn_by_extern(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_arcsin",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
"asin",
&[],
),
create_fn_by_extern(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_arccos",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
"acos",
&[],
),
create_fn_by_extern(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_arctan",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
"atan",
&[],
),
create_fn_by_extern(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_sinh",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
"sinh",
&[],
),
create_fn_by_extern(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_cosh",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
"cosh",
&[],
),
create_fn_by_extern(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_tanh",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
"tanh",
&[],
),
create_fn_by_extern(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_arcsinh",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
"asinh",
&[],
),
create_fn_by_extern(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_arccosh",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
"acosh",
&[],
),
create_fn_by_extern(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_arctanh",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
"atanh",
&[],
),
create_fn_by_extern(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_expm1",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
"expm1",
&[],
),
create_fn_by_extern(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_cbrt",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
"cbrt",
&["readnone", "willreturn"],
),
create_fn_by_extern(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"sp_spec_erf",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "z")],
"erf",
&[],
),
create_fn_by_extern(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"sp_spec_erfc",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
"erfc",
&[],
),
core: Rework gamma/gammaln to match SciPy behavior Matches behavior for infinities and NaNs.
2023-10-10 18:19:36 +08:00
create_fn_by_codegen(
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"sp_spec_gamma",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "z")],
core: Rework gamma/gammaln to match SciPy behavior Matches behavior for infinities and NaNs.
2023-10-10 18:19:36 +08:00
Box::new(|ctx, _, fun, args, generator| {
let float = ctx.primitives.float;
let z_ty = fun.0.args[0].ty;
let z_val = args[0].1.clone()
.to_basic_value_enum(ctx, generator, z_ty)?;
assert!(ctx.unifier.unioned(z_ty, float));
core: Implement non-trivial builtin functions using IRRT
2023-11-06 12:57:23 +08:00
Ok(Some(call_gamma(ctx, z_val.into_float_value()).into()))
}
)),
core: Rework gamma/gammaln to match SciPy behavior Matches behavior for infinities and NaNs.
2023-10-10 18:19:36 +08:00
create_fn_by_codegen(
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"sp_spec_gammaln",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
core: Rework gamma/gammaln to match SciPy behavior Matches behavior for infinities and NaNs.
2023-10-10 18:19:36 +08:00
Box::new(|ctx, _, fun, args, generator| {
let float = ctx.primitives.float;
core: Implement non-trivial builtin functions using IRRT
2023-11-06 12:57:23 +08:00
let z_ty = fun.0.args[0].ty;
let z_val = args[0].1.clone()
.to_basic_value_enum(ctx, generator, z_ty)?;
core: Rework gamma/gammaln to match SciPy behavior Matches behavior for infinities and NaNs.
2023-10-10 18:19:36 +08:00
core: Implement non-trivial builtin functions using IRRT
2023-11-06 12:57:23 +08:00
assert!(ctx.unifier.unioned(z_ty, float));
core: Rework gamma/gammaln to match SciPy behavior Matches behavior for infinities and NaNs.
2023-10-10 18:19:36 +08:00
core: Implement non-trivial builtin functions using IRRT
2023-11-06 12:57:23 +08:00
Ok(Some(call_gammaln(ctx, z_val.into_float_value()).into()))
core: Rework gamma/gammaln to match SciPy behavior Matches behavior for infinities and NaNs.
2023-10-10 18:19:36 +08:00
}),
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
),
core: Rework gamma/gammaln to match SciPy behavior Matches behavior for infinities and NaNs.
2023-10-10 18:19:36 +08:00
create_fn_by_codegen(
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"sp_spec_j0",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
core: Rework gamma/gammaln to match SciPy behavior Matches behavior for infinities and NaNs.
2023-10-10 18:19:36 +08:00
Box::new(|ctx, _, fun, args, generator| {
let float = ctx.primitives.float;
core: Implement non-trivial builtin functions using IRRT
2023-11-06 12:57:23 +08:00
let z_ty = fun.0.args[0].ty;
let z_val = args[0].1.clone()
.to_basic_value_enum(ctx, generator, z_ty)?;
core: Rework gamma/gammaln to match SciPy behavior Matches behavior for infinities and NaNs.
2023-10-10 18:19:36 +08:00
core: Implement non-trivial builtin functions using IRRT
2023-11-06 12:57:23 +08:00
assert!(ctx.unifier.unioned(z_ty, float));
core: Rework gamma/gammaln to match SciPy behavior Matches behavior for infinities and NaNs.
2023-10-10 18:19:36 +08:00
core: Implement non-trivial builtin functions using IRRT
2023-11-06 12:57:23 +08:00
Ok(Some(call_j0(ctx, z_val.into_float_value()).into()))
core: Rework gamma/gammaln to match SciPy behavior Matches behavior for infinities and NaNs.
2023-10-10 18:19:36 +08:00
}),
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
),
create_fn_by_extern(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"sp_spec_j1",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x")],
"j1",
&[],
),
// Not mapped: jv/yv, libm only supports integer orders.
create_fn_by_extern(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_arctan2",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x1"), (float, "x2")],
"atan2",
&[],
),
create_fn_by_intrinsic(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_copysign",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x1"), (float, "x2")],
"llvm.copysign.f64",
),
create_fn_by_intrinsic(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_fmax",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x1"), (float, "x2")],
"llvm.maxnum.f64",
),
create_fn_by_intrinsic(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_fmin",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x1"), (float, "x2")],
"llvm.minnum.f64",
),
create_fn_by_extern(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_ldexp",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x1"), (int32, "x2")],
"ldexp",
&[],
),
create_fn_by_extern(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_hypot",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x1"), (float, "x2")],
"hypot",
&[],
),
create_fn_by_extern(
primitives,
&var_map,
core: Prefix all NumPy/SciPy functions with np_/sp_spec
2023-11-23 13:32:08 +08:00
"np_nextafter",
core: Implement numpy and scipy functions
2023-10-06 17:48:31 +08:00
float,
&[(float, "x1"), (float, "x2")],
"nextafter",
&[],
),
Option type support (#224) Co-authored-by: ychenfo <yc@m-labs.hk> Co-committed-by: ychenfo <yc@m-labs.hk>
2022-03-26 15:09:15 +08:00
Arc::new(RwLock::new(TopLevelDef::Function {
name: "Some".into(),
simple_name: "Some".into(),
signature: primitives.1.add_ty(TypeEnum::TFunc(FunSignature {
args: vec![FuncArg { name: "n".into(), ty: option_ty_var, default_value: None }],
ret: primitives.0.option,
vars: HashMap::from([(option_ty_var_id, option_ty_var)]),
})),
var_id: vec![option_ty_var_id],
core: Apply clippy pedantic changes
2023-12-08 17:43:32 +08:00
instance_to_symbol: HashMap::default(),
instance_to_stmt: HashMap::default(),
Option type support (#224) Co-authored-by: ychenfo <yc@m-labs.hk> Co-committed-by: ychenfo <yc@m-labs.hk>
2022-03-26 15:09:15 +08:00
resolver: None,
codegen_callback: Some(Arc::new(GenCall::new(Box::new(
nac3core, artiq: to_basic_value_enum takes an argument indicating the expected type
2022-04-08 03:26:42 +08:00
|ctx, _, fun, args, generator| {
let arg_ty = fun.0.args[0].ty;
let arg_val = args[0].1.clone().to_basic_value_enum(ctx, generator, arg_ty)?;
core: Allocate more stack variables at the beginning of function All allocas for temporary objects are now placed in the beginning of the function. Allocas for on-temporary objects are not modified because these variables may appear in a loop and thus must be uniquely allocated by different allocas.
2023-10-03 18:02:45 +08:00
let alloca = generator.gen_var_alloc(ctx, arg_val.get_type(), Some("alloca_some")).unwrap();
Option type support (#224) Co-authored-by: ychenfo <yc@m-labs.hk> Co-committed-by: ychenfo <yc@m-labs.hk>
2022-03-26 15:09:15 +08:00
ctx.builder.build_store(alloca, arg_val);
Ok(Some(alloca.into()))
},
)))),
loc: None,
})),
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
];
nac3core: moved all builtin errors to nac3artiq code This remove the need for hard-coding those definition IDs.
2022-03-17 00:04:49 +08:00
meta: Remove redundant path prefixes
2023-10-26 13:52:40 +08:00
let ast_list: Vec<Option<Stmt<()>>> =
nac3core: move builtin definitions to another file
2021-12-01 02:52:00 +08:00
(0..top_level_def_list.len()).map(|_| None).collect();
core: Infer builtins name list using builtin declaration list
2023-11-28 17:37:49 +08:00
izip!(top_level_def_list, ast_list).collect_vec()
nac3core: fix len on range with step of different sign
2021-12-12 05:52:22 +08:00
}