GitLab will be upgraded to the 12.10.14-ce.0 on 28 Sept 2020 at 2.00pm (AEDT) to 2.30pm (AEDT). During the update, GitLab and Mattermost services will not be available. If you have any concerns with this, please talk to us at N110 (b) CSIT building.

Commit 36bb9928 authored by qinsoon's avatar qinsoon

[wip] Handles (for client)

parent 04c10e0b
...@@ -503,7 +503,7 @@ impl Value { ...@@ -503,7 +503,7 @@ impl Value {
impl fmt::Display for Value { impl fmt::Display for Value {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self.v { match self.v {
Value_::SSAVar(id) => { Value_::SSAVar(_) => {
write!(f, "+({} %{})", self.ty, self.hdr) write!(f, "+({} %{})", self.ty, self.hdr)
}, },
Value_::Constant(ref c) => { Value_::Constant(ref c) => {
...@@ -559,7 +559,7 @@ impl fmt::Display for SSAVarEntry { ...@@ -559,7 +559,7 @@ impl fmt::Display for SSAVarEntry {
#[derive(Debug, Clone, PartialEq)] #[derive(Debug, Clone, PartialEq)]
pub enum Constant { pub enum Constant {
Int(usize), Int(u64),
Float(f32), Float(f32),
Double(f64), Double(f64),
IRef(Address), IRef(Address),
......
...@@ -36,10 +36,10 @@ ...@@ -36,10 +36,10 @@
//! implementation changes (using a special thread-local heap, for example). //! implementation changes (using a special thread-local heap, for example).
//! Moreover, a switch to, e.g. `P<'a, T>` would be easy and mostly automated. //! Moreover, a switch to, e.g. `P<'a, T>` would be easy and mostly automated.
use std::fmt::{self, Display, Debug}; //use std::fmt::{self, Display, Debug};
use std::hash::{Hash, Hasher}; //use std::hash::{Hash, Hasher};
use std::ops::Deref; //use std::ops::Deref;
use std::ops::DerefMut; //use std::ops::DerefMut;
use std::sync::Arc; use std::sync::Arc;
......
...@@ -11,7 +11,6 @@ use utils::string_utils; ...@@ -11,7 +11,6 @@ use utils::string_utils;
use ast::ptr::P; use ast::ptr::P;
use ast::ir::*; use ast::ir::*;
use ast::inst::*;
use std::collections::HashMap; use std::collections::HashMap;
use std::str; use std::str;
......
use ast::ptr::P; use ast::ptr::P;
use ast::ir::*; use ast::ir::*;
use ast::inst::*;
use vm::MachineCode; use vm::MachineCode;
......
...@@ -307,7 +307,7 @@ pub fn is_callee_saved(reg_id: MuID) -> bool { ...@@ -307,7 +307,7 @@ pub fn is_callee_saved(reg_id: MuID) -> bool {
pub fn is_valid_x86_imm(op: &P<Value>) -> bool { pub fn is_valid_x86_imm(op: &P<Value>) -> bool {
use std::u32; use std::u32;
match op.v { match op.v {
Value_::Constant(Constant::Int(val)) if val <= u32::MAX as usize => { Value_::Constant(Constant::Int(val)) if val <= u32::MAX as u64 => {
true true
}, },
_ => false _ => false
......
...@@ -8,7 +8,6 @@ use vm::bundle::*; ...@@ -8,7 +8,6 @@ use vm::bundle::*;
use std::mem; use std::mem;
use std::os::raw; use std::os::raw;
use std::cell::RefCell;
use std::collections::HashMap; use std::collections::HashMap;
use std::sync::Arc; use std::sync::Arc;
...@@ -74,23 +73,23 @@ impl MuVM { ...@@ -74,23 +73,23 @@ impl MuVM {
pub type MuArraySize = usize; pub type MuArraySize = usize;
pub type MuIntValue = P<Value>; pub type MuIntValue = MuValue;
pub type MuBundleNode = *mut MuBundle; pub type MuBundleNode = MuValue;
pub type MuChildNode = MuIRNode; pub type MuChildNode = MuValue;
pub type MuTypeNode = P<MuType>; pub type MuTypeNode = MuValue;
pub type MuFuncSigNode= P<MuFuncSig>; pub type MuFuncSigNode= MuValue;
pub type MuConstNode = P<Value>; pub type MuConstNode = MuValue;
pub type MuGlobalNode = P<Value>; pub type MuGlobalNode = MuValue;
pub type MuFuncNode = RefCell<MuFunction>; pub type MuFuncNode = MuValue;
pub type MuFuncVerNode= RefCell<MuFunctionVersion>; pub type MuFuncVerNode= MuValue;
pub type MuBBNode = P<Block>; pub type MuBBNode = MuValue;
pub type MuNorParamNode = P<Value>; pub type MuNorParamNode = MuValue;
pub type MuExcParamNode = P<Value>; pub type MuExcParamNode = MuValue;
pub type MuInstNode = P<TreeNode>; pub type MuInstNode = MuValue;
pub type MuInstResNode = P<TreeNode>; pub type MuInstResNode = MuValue;
pub type MuLocalVarNode = P<TreeNode>; pub type MuLocalVarNode = MuValue;
pub type MuVarNode = MuIRNode; pub type MuVarNode = MuValue;
pub type MuFlag = usize; pub type MuFlag = usize;
pub type MuDestKind = MuFlag; pub type MuDestKind = MuFlag;
...@@ -233,6 +232,7 @@ pub struct MuCtx { ...@@ -233,6 +232,7 @@ pub struct MuCtx {
struct MuCtxInternal { struct MuCtxInternal {
vm: Arc<VM>, vm: Arc<VM>,
cur_bundles: HashMap<MuID, MuBundle>
} }
impl MuCtx { impl MuCtx {
...@@ -251,14 +251,25 @@ impl MuCtx { ...@@ -251,14 +251,25 @@ impl MuCtx {
#[allow(unused_variables)] #[allow(unused_variables)]
pub fn new_bundle(ctx: &mut MuCtx) -> MuBundleNode { pub fn new_bundle(ctx: &mut MuCtx) -> MuBundleNode {
let bundle = Box::new(MuBundle::new()); let id = ctx.internal.vm.next_id();
let bundle = MuBundle::new(id);
Box::into_raw(bundle) ctx.internal.cur_bundles.insert(id, bundle);
handle_bundle(id)
}
fn get_bundle(&self, b: MuBundleNode) -> &MuBundle {
self.internal.cur_bundles.get(&b.id).unwrap()
}
fn get_bundle_mut(&mut self, b: MuBundleNode) -> &mut MuBundle {
self.internal.cur_bundles.get_mut(&b.id).unwrap()
} }
#[allow(unused_variables)] #[allow(unused_variables)]
pub fn load_bundle_from_node(ctx: &mut MuCtx, b: MuBundleNode) { pub fn load_bundle_from_node(ctx: &mut MuCtx, b: MuBundleNode) {
let bundle = unsafe{Box::from_raw(b)}; let bundle = ctx.get_bundle(b);
// load it // load it
unimplemented!() unimplemented!()
...@@ -266,24 +277,24 @@ impl MuCtx { ...@@ -266,24 +277,24 @@ impl MuCtx {
#[allow(unused_variables)] #[allow(unused_variables)]
pub fn abort_bundle_node(ctx: &mut MuCtx, b: MuBundleNode) { pub fn abort_bundle_node(ctx: &mut MuCtx, b: MuBundleNode) {
let bundle = unsafe{Box::from_raw(b)}; ctx.internal.cur_bundles.remove(&b.id);
} }
pub fn get_node(ctx: &mut MuCtx, b: MuBundleNode, id: MuID) -> MuChildNode { pub fn get_node(ctx: &mut MuCtx, b: MuBundleNode, id: MuID) -> MuChildNode {
let bundle = unsafe{b.as_mut()}.unwrap(); let bundle = ctx.get_bundle(b);
if bundle.type_defs.contains_key(&id) { if bundle.type_defs.contains_key(&id) {
MuIRNode::new(id, MuIRNodeKind::Type) handle_type(id)
} else if bundle.func_sigs.contains_key(&id) { } else if bundle.func_sigs.contains_key(&id) {
MuIRNode::new(id, MuIRNodeKind::FuncSig) handle_funcsig(id)
} else if bundle.constants.contains_key(&id) { } else if bundle.constants.contains_key(&id) {
MuIRNode::new(id, MuIRNodeKind::Var(MuVarNodeKind::Global(MuGlobalVarNodeKind::Const))) handle_const(id)
} else if bundle.globals.contains_key(&id) { } else if bundle.globals.contains_key(&id) {
MuIRNode::new(id, MuIRNodeKind::Var(MuVarNodeKind::Global(MuGlobalVarNodeKind::Global))) handle_global(id)
} else if bundle.func_defs.contains_key(&id) { } else if bundle.func_defs.contains_key(&id) {
MuIRNode::new(id, MuIRNodeKind::Var(MuVarNodeKind::Global(MuGlobalVarNodeKind::Func))) handle_func(id)
} else if bundle.func_decls.contains_key(&id) { } else if bundle.func_decls.contains_key(&id) {
MuIRNode::new(id, MuIRNodeKind::FuncVer) handle_funcver(id)
} else { } else {
panic!("expecting ID of a top level definition") panic!("expecting ID of a top level definition")
} }
...@@ -294,6 +305,120 @@ impl MuCtx { ...@@ -294,6 +305,120 @@ impl MuCtx {
node.id node.id
} }
fn next_id(&self) -> MuID {
self.internal.vm.next_id()
}
#[allow(unused_variables)]
pub fn set_name(ctx: &mut MuCtx, b: MuBundleNode, node: MuChildNode, name: MuName) {
// what can be 'set_name'?
unimplemented!()
}
pub fn new_int_type(ctx: &mut MuCtx, b: MuBundleNode, len: raw::c_int) -> MuTypeNode {
let id = ctx.next_id();
let ty = P(MuType::new(id, MuType_::Int(len as usize)));
ctx.get_bundle_mut(b).type_defs.insert(id, ty);
handle_type(id)
}
pub fn new_float_type(ctx: &mut MuCtx, b: MuBundleNode) -> MuTypeNode {
let id = ctx.next_id();
let ty = P(MuType::new(id, MuType_::Float));
ctx.get_bundle_mut(b).type_defs.insert(id, ty);
handle_type(id)
}
pub fn new_double_type(ctx: &mut MuCtx, b: MuBundleNode) -> MuTypeNode {
let id = ctx.next_id();
let ty = P(MuType::new(id, MuType_::Double));
ctx.get_bundle_mut(b).type_defs.insert(id, ty);
handle_type(id)
}
pub fn new_funcsig(ctx: &mut MuCtx, b: MuBundleNode,
paramtys: *const MuTypeNode, nparamtys: MuArraySize,
rettys: *const MuTypeNode, nrettys: MuArraySize) -> MuFuncSigNode {
let arg_tys = {
let mut ret = vec![];
let bundle = ctx.get_bundle(b);
for i in 0..nparamtys {
let ty_handle = unsafe{paramtys.offset(i as isize).as_ref()}.unwrap();
let ty = bundle.get_type(ty_handle).clone();
ret.push(ty);
}
ret
};
let ret_tys = {
let mut ret = vec![];
let bundle = ctx.get_bundle(b);
for i in 0..nrettys {
let ty_handle = unsafe{rettys.offset(i as isize).as_ref()}.unwrap();
let ty = bundle.get_type(ty_handle).clone();
ret.push(ty);
}
ret
};
let id = ctx.next_id();
let func_sig = P(MuFuncSig{
hdr: MuEntityHeader::unnamed(id),
ret_tys: ret_tys,
arg_tys: arg_tys
});
ctx.get_bundle_mut(b).func_sigs.insert(id, func_sig);
handle_funcsig(id)
}
pub fn new_const_int(ctx: &mut MuCtx, b: MuBundleNode, ty: MuTypeNode, value: u64) -> MuConstNode {
let id = ctx.next_id();
let val = P(Value{
hdr: MuEntityHeader::unnamed(id),
ty: ctx.get_bundle(b).get_type(&ty).clone(),
v: Value_::Constant(Constant::Int(value))
});
ctx.get_bundle_mut(b).constants.insert(id, val);
handle_const(id)
}
pub fn new_const_float(ctx: &mut MuCtx, b: MuBundleNode, ty: MuTypeNode, value: f32) -> MuConstNode {
let id = ctx.next_id();
let val = P(Value{
hdr: MuEntityHeader::unnamed(id),
ty: ctx.get_bundle(b).get_type(&ty).clone(),
v: Value_::Constant(Constant::Float(value))
});
ctx.get_bundle_mut(b).constants.insert(id, val);
handle_const(id)
}
pub fn new_const_double(ctx: &mut MuCtx, b: MuBundleNode, ty: MuTypeNode, value: f64) -> MuConstNode {
let id = ctx.next_id();
let val = P(Value{
hdr: MuEntityHeader::unnamed(id),
ty: ctx.get_bundle(b).get_type(&ty).clone(),
v: Value_::Constant(Constant::Double(value))
});
ctx.get_bundle_mut(b).constants.insert(id, val);
handle_const(id)
}
fn new(vm: Arc<VM>) -> MuCtx { fn new(vm: Arc<VM>) -> MuCtx {
MuCtx { MuCtx {
internal: Box::new(MuCtxInternal::new(vm)), internal: Box::new(MuCtxInternal::new(vm)),
...@@ -327,19 +452,19 @@ impl MuCtx { ...@@ -327,19 +452,19 @@ impl MuCtx {
get_node: api!(MuCtx::get_node), get_node: api!(MuCtx::get_node),
get_id : api!(MuCtx::get_id), get_id : api!(MuCtx::get_id),
set_name: unimplemented_api!(), set_name: api!(MuCtx::set_name),
// create types // create types
new_type_int : unimplemented_api!(), new_type_int : api!(MuCtx::new_int_type),
new_type_float : unimplemented_api!(), new_type_float : api!(MuCtx::new_float_type),
new_type_double: unimplemented_api!(), new_type_double: api!(MuCtx::new_double_type),
// ... a lot more // ... a lot more
new_funcsig: unimplemented_api!(), new_funcsig: api!(MuCtx::new_funcsig),
new_const_int : unimplemented_api!(), new_const_int : api!(MuCtx::new_const_int),
new_const_float : unimplemented_api!(), new_const_float : api!(MuCtx::new_const_float),
new_const_double: unimplemented_api!(), new_const_double: api!(MuCtx::new_const_double),
// ... a lot more // ... a lot more
new_global_cell : unimplemented_api!(), new_global_cell : unimplemented_api!(),
...@@ -418,7 +543,8 @@ impl MuCtx { ...@@ -418,7 +543,8 @@ impl MuCtx {
impl MuCtxInternal { impl MuCtxInternal {
fn new(vm: Arc<VM>) -> MuCtxInternal { fn new(vm: Arc<VM>) -> MuCtxInternal {
MuCtxInternal { MuCtxInternal {
vm: vm vm: vm,
cur_bundles: HashMap::new()
} }
} }
} }
\ No newline at end of file
use ast::ir::*; use ast::ir::*;
use ast::ptr::*; use ast::ptr::*;
use ast::types::*; use ast::types::*;
use vm::api::*;
use std::collections::HashMap; use std::collections::HashMap;
pub struct MuBundle { pub struct MuBundle {
pub id: MuID,
pub type_defs: HashMap<MuID, P<MuType>>, pub type_defs: HashMap<MuID, P<MuType>>,
pub func_sigs: HashMap<MuID, P<MuFuncSig>>, pub func_sigs: HashMap<MuID, P<MuFuncSig>>,
pub constants: HashMap<MuID, P<Value>>, pub constants: HashMap<MuID, P<Value>>,
...@@ -17,8 +20,10 @@ pub struct MuBundle { ...@@ -17,8 +20,10 @@ pub struct MuBundle {
} }
impl MuBundle { impl MuBundle {
pub fn new() -> MuBundle { pub fn new(id: MuID) -> MuBundle {
MuBundle { MuBundle {
id: id,
type_defs: HashMap::new(), type_defs: HashMap::new(),
func_sigs: HashMap::new(), func_sigs: HashMap::new(),
constants: HashMap::new(), constants: HashMap::new(),
...@@ -30,45 +35,103 @@ impl MuBundle { ...@@ -30,45 +35,103 @@ impl MuBundle {
// name_id_map: HashMap::new() // name_id_map: HashMap::new()
} }
} }
pub fn get_type(&self, ty: &MuTypeNode) -> &P<MuType> {
self.type_defs.get(&ty.id).unwrap()
}
} }
pub struct MuIRNode { #[derive(Copy, Clone, Debug)]
pub struct MuValue {
pub id: MuID, pub id: MuID,
pub v: MuIRNodeKind pub v: MuValueKind
} }
impl MuIRNode {
pub fn new(id: MuID, v: MuIRNodeKind) -> MuIRNode {
MuIRNode {
id: id,
v: v
}
}
}
pub enum MuIRNodeKind { #[derive(Copy, Clone, Debug)]
pub enum MuValueKind {
Int,
Float,
Double,
UPtr,
UFP,
// SeqValue
Struct,
Array,
Vector,
// GenRef
Ref,
IRef,
TagRef64,
FuncRef,
ThreadRef,
StackRef,
FCRef, // frame cursor ref
// GenRef->IR
Bundle,
// GenRef->IR->Child
Type, Type,
FuncSig, FuncSig,
Var(MuVarNodeKind),
FuncVer, FuncVer,
BB, BB,
Inst Inst,
}
// GenRef->IR->Child->Var->Global
pub enum MuVarNodeKind {
Global(MuGlobalVarNodeKind),
Local(MuLocalVarNodeKind)
}
pub enum MuGlobalVarNodeKind {
Const, Const,
Global, Global,
Func, Func,
ExpFunc ExpFunc,
}
// GenRef->IR->Child->Var->Local
pub enum MuLocalVarNodeKind {
NorParam, NorParam,
ExcParam, ExcParam,
MuInstRes InstRes,
} }
\ No newline at end of file
macro_rules! handle_constructor {
($fn_name: ident, $kind: ident) => {
pub fn $fn_name(id: MuID) -> MuValue {
MuValue{
id: id, v: MuValueKind::$kind
}
}
}
}
handle_constructor!(handle_int, Int);
handle_constructor!(handle_float, Float);
handle_constructor!(handle_double, Double);
handle_constructor!(handle_uptr, UPtr);
handle_constructor!(handle_ufp, UFP);
handle_constructor!(handle_struct, Struct);
handle_constructor!(handle_array, Array);
handle_constructor!(handle_vector, Vector);
handle_constructor!(handle_ref, Ref);
handle_constructor!(handle_iref, IRef);
handle_constructor!(handle_tagref64, TagRef64);
handle_constructor!(handle_funcref, FuncRef);
handle_constructor!(handle_threadref, ThreadRef);
handle_constructor!(handle_stackref, StackRef);
handle_constructor!(handle_fcref, FCRef);
handle_constructor!(handle_bundle, Bundle);
handle_constructor!(handle_type, Type);
handle_constructor!(handle_funcsig, FuncSig);
handle_constructor!(handle_funcver, FuncVer);
handle_constructor!(handle_bb, BB);
handle_constructor!(handle_inst, Inst);
handle_constructor!(handle_const, Const);
handle_constructor!(handle_global, Global);
handle_constructor!(handle_func, Func);
handle_constructor!(handle_expfunc, ExpFunc);
handle_constructor!(handle_norparam, NorParam);
handle_constructor!(handle_excparam, ExcParam);
handle_constructor!(handle_instres, InstRes);
\ No newline at end of file
...@@ -19,8 +19,8 @@ fn test_builder_factorial() { ...@@ -19,8 +19,8 @@ fn test_builder_factorial() {
} }
fn builder_factorial() { fn builder_factorial() {
let mvm = MuVM::new(); // let mvm = MuVM::new();
let mvm_ref = unsafe {mvm.as_mut()}.unwrap(); // let mvm_ref = unsafe {mvm.as_mut()}.unwrap();
let ctx = (mvm_ref.new_context)(mvm); // let ctx = (mvm_ref.new_context)(mvm);
let ctx_ref = unsafe {ctx.as_mut()}.unwrap(); // let ctx_ref = unsafe {ctx.as_mut()}.unwrap();
} }
...@@ -3,10 +3,8 @@ extern crate mu; ...@@ -3,10 +3,8 @@ extern crate mu;
use self::mu::ast::types::*; use self::mu::ast::types::*;
use self::mu::ast::ir::*; use self::mu::ast::ir::*;
use self::mu::ast::inst::*; use self::mu::ast::inst::*;
use self::mu::ast::ptr::*;
use self::mu::ast::op::*; use self::mu::ast::op::*;
use self::mu::vm::*; use self::mu::vm::*;
use self::mu::vm::api::*;
use std::cell::RefCell; use std::cell::RefCell;
use std::collections::HashMap; use std::collections::HashMap;
...@@ -33,24 +31,24 @@ pub fn sum() -> VM { ...@@ -33,24 +31,24 @@ pub fn sum() -> VM {
let vm = VM::new(); let vm = VM::new();
// .typedef @int_64 = int<64> // .typedef @int_64 = int<64>
let mut type_def_int64 = vm.declare_type(vm.next_id(), MuType_::int(64)); let type_def_int64 = vm.declare_type(vm.next_id(), MuType_::int(64));
vm.set_name(type_def_int64.as_entity(), "int_64"); vm.set_name(type_def_int64.as_entity(), "int_64");
let mut type_def_int1 = vm.declare_type(vm.next_id(), MuType_::int(1)); let type_def_int1 = vm.declare_type(vm.next_id(), MuType_::int(1));
vm.set_name(type_def_int1.as_entity(), "int_1"); vm.set_name(type_def_int1.as_entity(), "int_1");
// .const @int_64_0 <@int_64> = 0 // .const @int_64_0 <@int_64> = 0
// .const @int_64_1 <@int_64> = 1 // .const @int_64_1 <@int_64> = 1
let mut const_def_int64_0 = vm.declare_const(vm.next_id(), type_def_int64.clone(), Constant::Int(0)); let const_def_int64_0 = vm.declare_const(vm.next_id(), type_def_int64.clone(), Constant::Int(0));
vm.set_name(const_def_int64_0.as_entity(), "int64_0"); vm.set_name(const_def_int64_0.as_entity(), "int64_0");
let mut const_def_int64_1 = vm.declare_const(vm.next_id(), type_def_int64.clone(), Constant::Int(1)); let const_def_int64_1 = vm.declare_const(vm.next_id(), type_def_int64.clone(), Constant::Int(1));
vm.set_name(const_def_int64_1.as_entity(), "int64_1"); vm.set_name(const_def_int64_1.as_entity(), "int64_1");
// .funcsig @sum_sig = (@int_64) -> (@int_64) // .funcsig @sum_sig = (@int_64) -> (@int_64)
let mut sum_sig = vm.declare_func_sig(vm.next_id(), vec![type_def_int64.clone()], vec![type_def_int64.clone()]); let sum_sig = vm.declare_func_sig(vm.next_id(), vec![type_def_int64.clone()], vec![type_def_int64.clone()]);
vm.set_name(sum_sig.as_entity(), "sum_sig"); vm.set_name(sum_sig.as_entity(), "sum_sig");
// .funcdecl @sum <@sum_sig> // .funcdecl @sum <@sum_sig>
let mut func = MuFunction::new(vm.next_id(), sum_sig.clone()); let func = MuFunction::new(vm.next_id(), sum_sig.clone());
vm.set_name(func.as_entity(), "sum"); vm.set_name(func.as_entity(), "sum");
let func_id = func.id(); let func_id = func.id();
vm.declare_func(func); vm.declare_func(func);
...@@ -188,33 +186,33 @@ pub fn factorial() -> VM { ...@@ -188,33 +186,33 @@ pub fn factorial() -> VM {
// .typedef @void = void // .typedef @void = void
// .typedef @int_8 = int<8> // .typedef @int_8 = int<8>
// .typedef @int_32 = int<32> // .typedef @int_32 = int<32>
let mut type_def_int64 = vm.declare_type(vm.next_id(), MuType_::int(64)); let type_def_int64 = vm.declare_type(vm.next_id(), MuType_::int(64));
vm.set_name(type_def_int64.as_entity(), "int_64"); vm.set_name(type_def_int64.as_entity(), "int_64");
let mut type_def_int1 = vm.declare_type(vm.next_id(), MuType_::int(1)); let type_def_int1 = vm.declare_type(vm.next_id(), MuType_::int(1));
vm.set_name(type_def_int1.as_entity(), "int_1"); vm.set_name(type_def_int1.as_entity(), "int_1");
let mut type_def_float = vm.declare_type(vm.next_id(), MuType_::float()); let type_def_float = vm.declare_type(vm.next_id(), MuType_::float());
vm.set_name(type_def_float.as_entity(), "float"); vm.set_name(type_def_float.as_entity(), "float");
let mut type_def_double = vm.declare_type(vm.next_id(), MuType_::double()); let type_def_double = vm.declare_type(vm.next_id(), MuType_::double());
vm.set_name(type_def_double.as_entity(), "double"); vm.set_name(type_def_double.as_entity(), "double");
let mut type_def_void = vm.declare_type(vm.next_id(), MuType_::void()); let type_def_void = vm.declare_type(vm.next_id(), MuType_::void());
vm.set_name(type_def_void.as_entity(), "void"); vm.set_name(type_def_void.as_entity(), "void");
let mut type_def_int8 = vm.declare_type(vm.next_id(), MuType_::int(8)); let type_def_int8 = vm.declare_type(vm.next_id(), MuType_::int(8));
vm.set_name(type_def_int8.as_entity(), "int8"); vm.set_name(type_def_int8.as_entity(), "int8");
let mut type_def_int32 = vm.declare_type(vm.next_id(), MuType_::int(32)); let type_def_int32 = vm.declare_type(vm.next_id(), MuType_::int(32));
vm.set_name(type_def_int32.as_entity(), "int32"); vm.set_name(type_def_int32.as_entity(), "int32");
// .const @int_64_1 <@int_64> = 1 // .const @int_64_1 <@int_64> = 1
let mut const_def_int64_1 = vm.declare_const(vm.next_id(), type_def_int64.clone(), Constant::Int(1)); let const_def_int64_1 = vm.declare_const(vm.next_id(), type_def_int64.clone(), Constant::Int(1));
vm.set_name(const_def_int64_1.as_entity(), "int64_1"); vm.set_name(const_def_int64_1.as_entity(), "int64_1");
// .funcsig @fac_sig = (@int_64) -> (@int_64) // .funcsig @fac_sig = (@int_64) -> (@int_64)
let mut fac_sig = vm.declare_func_sig(vm.next_id(), vec![type_def_int64.clone()], vec![type_def_int64.clone()]); let fac_sig = vm.declare_func_sig(vm.next_id(), vec![type_def_int64.clone()], vec![type_def_int64.clone()]);
vm.set_name(fac_sig.as_entity(), "fac_sig"); vm.set_name(fac_sig.as_entity(), "fac_sig");
let mut type_def_funcref_fac = vm.declare_type(vm.next_id(), MuType_::funcref(fac_sig.clone())); let type_def_funcref_fac = vm.declare_type(vm.next_id(), MuType_::funcref(fac_sig.clone()));
vm.set_name(type_def_funcref_fac.as_entity(), "fac_sig"); vm.set_name(type_def_funcref_fac.as_entity(), "fac_sig");
// .funcdecl @fac <@fac_sig> // .funcdecl @fac <@fac_sig>
let mut func = MuFunction::new(vm.next_id(), fac_sig.clone()); let func = MuFunction::new(vm.next_id(), fac_sig.clone());
vm.set_name(func.as_entity(), "fac"); vm.set_name(func.as_entity(), "fac");
let func_id = func.id(); let func_id = func.id();
vm.declare_func(func);