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 { #[derive(Copy, Clone, Debug)]
pub fn new(id: MuID, v: MuIRNodeKind) -> MuIRNode { pub enum MuValueKind {
MuIRNode { Int,
id: id, Float,
v: v Double,
} UPtr,
} UFP,
}
// SeqValue
Struct,
Array,
Vector,
// GenRef
Ref,
IRef,
TagRef64,
FuncRef,
ThreadRef,
StackRef,
FCRef, // frame cursor ref
pub enum MuIRNodeKind { // GenRef->IR
Bundle,
// GenRef->IR->Child
Type, Type,
FuncSig, FuncSig,
Var(MuVarNodeKind),
FuncVer, FuncVer,
BB, BB,
Inst Inst,
}
pub enum MuVarNodeKind { // GenRef->IR->Child->Var->Global
Global(MuGlobalVarNodeKind),
Local(MuLocalVarNodeKind)
}
pub enum MuGlobalVarNodeKind {
Const, Const,
Global, Global,
Func, Func,
ExpFunc ExpFunc,
}
pub enum MuLocalVarNodeKind { // GenRef->IR->Child->Var->Local
NorParam, NorParam,
ExcParam, ExcParam,
MuInstRes InstRes,
}
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); vm.declare_func(func);
...@@ -358,28 +356,28 @@ pub fn global_access() -> VM { ...@@ -358,28 +356,28 @@ pub fn global_access() -> VM {