muirbuilder.rs

// Copyright 2017 The Australian National University
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// RTMU this file needs many additions

use super::common::*;
use ast::inst::*;
use ast::op::*;
use std;
use utils::bit_utils::bits_ones;
use utils::math::align_up;
use utils::LinkedHashMap;
use utils::LinkedHashSet;

pub static mut VALIDATE_IR: bool = true;

macro_rules! assert_ir {
    ($ cond : expr ) => [{if unsafe{VALIDATE_IR} {assert!($cond)} }];
    ($ cond : expr , $ ( $ arg : tt ) + ) => [{if unsafe{VALIDATE_IR} {assert!($cond, $($arg)+)} }];
}

pub struct MuIRBuilder {
    /// ref to MuVM
    mvm: *const MuVM,

    /// Point to the C-visible CMuIRBuilder so that `load` and `abort` can
    /// deallocate itself.
    pub c_struct: *mut CMuIRBuilder,

    /// Map IDs to names. Items are inserted during `gen_sym`. MuIRBuilder is
    /// supposed to be used by one thread, so there is no need for locking.
    /// Note: names generated by Zebu internally may also be added to this map
    id_name_map: HashMap<MuID, MuName>,
    /// This maps all names given by the client (using gen_sym) to ids
    name_id_map: HashMap<MuName, MuID>,
    /// The "transient bundle" includes everything being built here.
    bundle: TransientBundle
}

pub type IdBMap<T> = HashMap<MuID, Box<T>>;

/// A transient bundle, i.e. the bundle being built, but not yet loaded into the
/// MuVM.
#[derive(Default)]
pub struct TransientBundle {
    types: IdBMap<NodeType>,
    sigs: IdBMap<NodeFuncSig>,
    consts: IdBMap<NodeConst>,
    globals: IdBMap<NodeGlobalCell>,
    funcs: IdBMap<NodeFunc>,
    expfuncs: IdBMap<NodeExpFunc>,
    funcvers: IdBMap<NodeFuncVer>,
    bbs: IdBMap<NodeBB>,
    insts: IdBMap<NodeInst>,
    dest_clauses: IdBMap<NodeDestClause>,
    exc_clauses: IdBMap<NodeExcClause>,
    cs_clauses: IdBMap<NodeCurrentStackClause>,
    ns_clauses: IdBMap<NodeNewStackClause>,
    ka_clauses: IdBMap<NodeKeepaliveClause>
}

impl MuIRBuilder {
    pub fn new(mvm: *const MuVM) -> Box<MuIRBuilder> {
        Box::new(MuIRBuilder {
            mvm: mvm,
            c_struct: ptr::null_mut(),
            id_name_map: Default::default(),
            name_id_map: Default::default(),
            bundle: Default::default()
        })
    }

    #[inline(always)]
    fn get_mvm<'a, 'b>(&'a mut self) -> &'b MuVM {
        //self.mvm
        unsafe { &*self.mvm }
    }

    #[inline(always)]
    fn get_mvm_immutable<'a, 'b>(&'a self) -> &'b MuVM {
        unsafe { &*self.mvm }
    }

    #[inline(always)]
    fn get_vm<'a, 'b>(&'a mut self) -> &'b VM {
        &self.get_mvm().vm
    }

    #[inline(always)]
    fn next_id(&mut self) -> MuID {
        self.get_vm().next_id()
    }

    fn deallocate(&mut self) {
        let c_struct = self.c_struct;
        let b_ptr = self as *mut MuIRBuilder;
        debug!(
            "Deallocating MuIRBuilder {:?} and CMuIRBuilder {:?}...",
            b_ptr, c_struct
        );
        unsafe {
            Box::from_raw(c_struct);
            Box::from_raw(b_ptr);
        }
        trace!("Deallocation done!");
    }

    /// Get the Mu name of the `id`. This will consume the entry in the
    /// `id_name_map`. For this reason, this function is only called when
    /// the actual MuEntity that has this ID is created
    /// (such as `new_type_int`).
    fn consume_name_of(&mut self, id: MuID) -> Option<MuName> {
        self.id_name_map.remove(&id)
    }

    pub fn load(&mut self) {
        load_bundle(self);
        self.deallocate();
    }

    pub fn abort(&mut self) {
        info!("Aborting boot image building...");
        self.deallocate();
    }

    pub fn gen_sym(&mut self, name: Option<MuName>) -> MuID {
        let my_id = self.next_id();

        trace!("gen_sym({:?}) -> {}", name, my_id);

        match name {
            None => {}
            Some(the_name) => {
                let old_name = self.id_name_map.insert(my_id, the_name.clone());
                let old_id = self.name_id_map.insert(the_name, my_id);
                assert_ir!(old_id.is_none());
                debug_assert!(
                    old_name.is_none(),
                    "ID already exists: {}, new name: {}, old name: {}",
                    my_id,
                    self.id_name_map.get(&my_id).unwrap(),
                    old_name.unwrap()
                );
            }
        };

        my_id
    }

    pub fn new_type_int(&mut self, id: MuID, len: c_int) {
        self.bundle
            .types
            .insert(id, Box::new(NodeType::TypeInt { id: id, len: len }));
    }

    pub fn new_type_float(&mut self, id: MuID) {
        self.bundle
            .types
            .insert(id, Box::new(NodeType::TypeFloat { id: id }));
    }

    pub fn new_type_double(&mut self, id: MuID) {
        self.bundle
            .types
            .insert(id, Box::new(NodeType::TypeDouble { id: id }));
    }

    pub fn new_type_uptr(&mut self, id: MuID, ty: MuID) {
        self.bundle
            .types
            .insert(id, Box::new(NodeType::TypeUPtr { id: id, ty: ty }));
    }

    pub fn new_type_ufuncptr(&mut self, id: MuID, sig: MuID) {
        self.bundle
            .types
            .insert(id, Box::new(NodeType::TypeUFuncPtr { id: id, sig: sig }));
    }

    pub fn new_type_struct(&mut self, id: MuID, fieldtys: Vec<MuID>) {
        self.bundle.types.insert(
            id,
            Box::new(NodeType::TypeStruct {
                id: id,
                fieldtys: fieldtys
            })
        );
    }

    pub fn new_type_hybrid(
        &mut self,
        id: MuID,
        fixedtys: Vec<MuID>,
        varty: MuID
    ) {
        self.bundle.types.insert(
            id,
            Box::new(NodeType::TypeHybrid {
                id: id,
                fixedtys: fixedtys,
                varty: varty
            })
        );
    }

    pub fn new_type_array(&mut self, id: MuID, elemty: MuID, len: u64) {
        self.bundle.types.insert(
            id,
            Box::new(NodeType::TypeArray {
                id: id,
                elemty: elemty,
                len: len as usize
            })
        );
    }

    pub fn new_type_vector(&mut self, id: MuID, elemty: MuID, len: u64) {
        self.bundle.types.insert(
            id,
            Box::new(NodeType::TypeVector {
                id: id,
                elemty: elemty,
                len: len as usize
            })
        );
    }

    pub fn new_type_void(&mut self, id: MuID) {
        self.bundle
            .types
            .insert(id, Box::new(NodeType::TypeVoid { id: id }));
    }

    pub fn new_type_ref(&mut self, id: MuID, ty: MuID) {
        self.bundle
            .types
            .insert(id, Box::new(NodeType::TypeRef { id: id, ty: ty }));
    }

    pub fn new_type_iref(&mut self, id: MuID, ty: MuID) {
        self.bundle
            .types
            .insert(id, Box::new(NodeType::TypeIRef { id: id, ty: ty }));
    }

    pub fn new_type_weakref(&mut self, id: MuID, ty: MuID) {
        self.bundle
            .types
            .insert(id, Box::new(NodeType::TypeWeakRef { id: id, ty: ty }));
    }

    pub fn new_type_funcref(&mut self, id: MuID, sig: MuID) {
        self.bundle
            .types
            .insert(id, Box::new(NodeType::TypeFuncRef { id: id, sig: sig }));
    }

    pub fn new_type_tagref64(&mut self, id: MuID) {
        self.bundle
            .types
            .insert(id, Box::new(NodeType::TypeTagRef64 { id: id }));
    }

    pub fn new_type_threadref(&mut self, id: MuID) {
        self.bundle
            .types
            .insert(id, Box::new(NodeType::TypeThreadRef { id: id }));
    }

    pub fn new_type_stackref(&mut self, id: MuID) {
        self.bundle
            .types
            .insert(id, Box::new(NodeType::TypeStackRef { id: id }));
    }

    pub fn new_type_framecursorref(&mut self, id: MuID) {
        self.bundle
            .types
            .insert(id, Box::new(NodeType::TypeFrameCursorRef { id: id }));
    }

    pub fn new_type_irbuilderref(&mut self, id: MuID) {
        self.bundle
            .types
            .insert(id, Box::new(NodeType::TypeIRBuilderRef { id: id }));
    }

    pub fn new_type_regionref(&mut self, id: MuID) {
        self.bundle
            .types
            .insert(id, Box::new(NodeType::TypeRegionRef { id }));
    }

    pub fn new_type_attrref(&mut self, id: MuID) {
        self.bundle
            .types
            .insert(id, Box::new(NodeType::TypeAttrRef { id }));
    }

    pub fn new_type_timerref(&mut self, id: MuID) {
        self.bundle
            .types
            .insert(id, Box::new(NodeType::TypeTimerRef { id }));
    }

    pub fn new_type_futexref(&mut self, id: MuID) {
        self.bundle
            .types
            .insert(id, Box::new(NodeType::TypeFutexRef { id }));
    }

    pub fn new_funcsig(
        &mut self,
        id: MuID,
        paramtys: Vec<MuID>,
        rettys: Vec<MuID>
    ) {
        self.bundle.sigs.insert(
            id,
            Box::new(NodeFuncSig {
                id: id,
                paramtys: paramtys,
                rettys: rettys
            })
        );
    }

    pub fn new_const_int(&mut self, id: MuID, ty: MuID, value: u64) {
        self.bundle.consts.insert(
            id,
            Box::new(NodeConst::ConstInt {
                id: id,
                ty: ty,
                value: value
            })
        );
    }

    pub fn new_const_int_ex(&mut self, id: MuID, ty: MuID, values: &[u64]) {
        self.bundle.consts.insert(
            id,
            Box::new(NodeConst::ConstIntEx {
                id: id,
                ty: ty,
                value: values.to_vec()
            })
        );
    }

    pub fn new_const_float(&mut self, id: MuID, ty: MuID, value: f32) {
        self.bundle.consts.insert(
            id,
            Box::new(NodeConst::ConstFloat {
                id: id,
                ty: ty,
                value: value
            })
        );
    }

    pub fn new_const_double(&mut self, id: MuID, ty: MuID, value: f64) {
        self.bundle.consts.insert(
            id,
            Box::new(NodeConst::ConstDouble {
                id: id,
                ty: ty,
                value: value
            })
        );
    }

    pub fn new_const_null(&mut self, id: MuID, ty: MuID) {
        self.bundle
            .consts
            .insert(id, Box::new(NodeConst::ConstNull { id: id, ty: ty }));
    }

    pub fn new_const_seq(&mut self, id: MuID, ty: MuID, elems: Vec<MuID>) {
        self.bundle.consts.insert(
            id,
            Box::new(NodeConst::ConstSeq {
                id: id,
                ty: ty,
                elems: elems
            })
        );
    }

    pub fn new_const_extern(&mut self, id: MuID, ty: MuID, symbol: MuName) {
        self.bundle.consts.insert(
            id,
            Box::new(NodeConst::ConstExtern {
                id: id,
                ty: ty,
                symbol: symbol
            })
        );
    }

    pub fn new_global_cell(&mut self, id: MuID, ty: MuID) {
        self.bundle
            .globals
            .insert(id, Box::new(NodeGlobalCell { id: id, ty: ty }));
    }

    pub fn new_func(&mut self, id: MuID, sig: MuID) {
        self.bundle
            .funcs
            .insert(id, Box::new(NodeFunc { id: id, sig: sig }));
    }

    pub fn new_exp_func(
        &mut self,
        id: MuID,
        func: MuID,
        callconv: CMuCallConv,
        cookie: MuID
    ) {
        panic!("Not implemented")
    }

    pub fn new_func_ver(&mut self, id: MuID, func: MuID, bbs: Vec<MuID>) {
        self.bundle.funcvers.insert(
            id,
            Box::new(NodeFuncVer {
                id: id,
                func: func,
                bbs: bbs
            })
        );
    }

    pub fn new_bb(
        &mut self,
        id: MuID,
        nor_param_ids: Vec<MuID>,
        nor_param_types: Vec<MuID>,
        exc_param_id: Option<MuID>,
        insts: Vec<MuID>
    ) {
        self.bundle.bbs.insert(
            id,
            Box::new(NodeBB {
                id: id,
                nor_param_ids: nor_param_ids,
                nor_param_types: nor_param_types,
                exc_param_id: exc_param_id,
                insts: insts
            })
        );
    }

    pub fn new_dest_clause(&mut self, id: MuID, dest: MuID, vars: Vec<MuID>) {
        self.bundle.dest_clauses.insert(
            id,
            Box::new(NodeDestClause {
                id: id,
                dest: dest,
                vars: vars
            })
        );
    }

    pub fn new_exc_clause(&mut self, id: MuID, nor: MuID, exc: MuID) {
        self.bundle.exc_clauses.insert(
            id,
            Box::new(NodeExcClause {
                id: id,
                nor: nor,
                exc: exc
            })
        );
    }

    pub fn new_keepalive_clause(&mut self, id: MuID, vars: Vec<MuID>) {
        self.bundle
            .ka_clauses
            .insert(id, Box::new(NodeKeepaliveClause { id: id, vars: vars }));
    }

    pub fn new_csc_ret_with(&mut self, id: MuID, rettys: Vec<MuID>) {
        self.bundle.cs_clauses.insert(
            id,
            Box::new(NodeCurrentStackClause::RetWith {
                id: id,
                rettys: rettys
            })
        );
    }

    pub fn new_csc_kill_old(&mut self, id: MuID) {
        self.bundle
            .cs_clauses
            .insert(id, Box::new(NodeCurrentStackClause::KillOld { id: id }));
    }

    pub fn new_nsc_pass_values(
        &mut self,
        id: MuID,
        tys: Vec<MuID>,
        vars: Vec<MuID>
    ) {
        self.bundle.ns_clauses.insert(
            id,
            Box::new(NodeNewStackClause::PassValues {
                id: id,
                tys: tys,
                vars: vars
            })
        );
    }

    pub fn new_nsc_throw_exc(&mut self, id: MuID, exc: MuID) {
        self.bundle.ns_clauses.insert(
            id,
            Box::new(NodeNewStackClause::ThrowExc { id: id, exc: exc })
        );
    }

    #[inline(always)]
    fn add_inst(&mut self, id: MuID, inst: NodeInst) {
        self.bundle.insts.insert(id, Box::new(inst));
    }

    pub fn new_binop(
        &mut self,
        id: MuID,
        result_id: MuID,
        optr: CMuBinOptr,
        ty: MuID,
        opnd1: MuID,
        opnd2: MuID,
        exc_clause: Option<MuID>
    ) {
        trace!("new_binop");
        self.add_inst(
            id,
            NodeInst::NodeBinOp {
                id: id,
                result_id: result_id,
                status_result_ids: vec![],
                optr: optr,
                flags: 0,
                ty: ty,
                opnd1: opnd1,
                opnd2: opnd2,
                exc_clause: exc_clause
            }
        );
    }

    pub fn new_binop_with_status(
        &mut self,
        id: MuID,
        result_id: MuID,
        status_result_ids: Vec<MuID>,
        optr: CMuBinOptr,
        status_flags: CMuBinOpStatus,
        ty: MuID,
        opnd1: MuID,
        opnd2: MuID,
        exc_clause: Option<MuID>
    ) {
        trace!("new_binop_with_status");
        self.add_inst(
            id,
            NodeInst::NodeBinOp {
                id: id,
                result_id: result_id,
                status_result_ids: status_result_ids,
                optr: optr,
                flags: status_flags,
                ty: ty,
                opnd1: opnd1,
                opnd2: opnd2,
                exc_clause: exc_clause
            }
        )
    }

    pub fn new_cmp(
        &mut self,
        id: MuID,
        result_id: MuID,
        optr: CMuCmpOptr,
        ty: MuID,
        opnd1: MuID,
        opnd2: MuID
    ) {
        trace!("new_cmp");
        self.add_inst(
            id,
            NodeInst::NodeCmp {
                id: id,
                result_id: result_id,
                optr: optr,
                ty: ty,
                opnd1: opnd1,
                opnd2: opnd2
            }
        );
    }

    pub fn new_conv(
        &mut self,
        id: MuID,
        result_id: MuID,
        optr: CMuConvOptr,
        from_ty: MuID,
        to_ty: MuID,
        opnd: MuID
    ) {
        trace!("new_conv");
        self.add_inst(
            id,
            NodeInst::NodeConv {
                id: id,
                result_id: result_id,
                optr: optr,
                from_ty: from_ty,
                to_ty: to_ty,
                opnd: opnd
            }
        );
    }

    pub fn new_select(
        &mut self,
        id: MuID,
        result_id: MuID,
        cond_ty: MuID,
        opnd_ty: MuID,
        cond: MuID,
        if_true: MuID,
        if_false: MuID
    ) {
        trace!("new_select");
        self.add_inst(
            id,
            NodeInst::NodeSelect {
                id: id,
                result_id: result_id,
                cond_ty: cond_ty,
                opnd_ty: opnd_ty,
                cond: cond,
                if_true: if_true,
                if_false: if_false
            }
        );
    }

    pub fn new_branch(&mut self, id: MuID, dest: MuID) {
        trace!("muirbuilder.rs new_branch");
        self.add_inst(id, NodeInst::NodeBranch { id: id, dest: dest });
        trace!("muirbuilder.rs built new_branch");
    }

    pub fn new_branch2(
        &mut self,
        id: MuID,
        cond: MuID,
        if_true: MuID,
        if_false: MuID
    ) {
        trace!("new_branch2");
        self.add_inst(
            id,
            NodeInst::NodeBranch2 {
                id: id,
                cond: cond,
                if_true: if_true,
                if_false: if_false
            }
        );
    }

    pub fn new_switch(
        &mut self,
        id: MuID,
        opnd_ty: MuID,
        opnd: MuID,
        default_dest: MuID,
        cases: Vec<MuID>,
        dests: Vec<MuID>
    ) {
        trace!("new_switch");
        self.add_inst(
            id,
            NodeInst::NodeSwitch {
                id: id,
                opnd_ty: opnd_ty,
                opnd: opnd,
                default_dest: default_dest,
                cases: cases,
                dests: dests
            }
        );
    }

    pub fn new_call(
        &mut self,
        id: MuID,
        result_ids: Vec<MuID>,
        sig: MuID,
        callee: MuID,
        args: Vec<MuID>,
        exc_clause: Option<MuID>,
        keepalive_clause: Option<MuID>
    ) {
        trace!("new_call");
        self.add_inst(
            id,
            NodeInst::NodeCall {
                id: id,
                result_ids: result_ids,
                sig: sig,
                callee: callee,
                args: args,
                exc_clause: exc_clause,
                keepalive_clause: keepalive_clause
            }
        );
    }

    pub fn new_tailcall(
        &mut self,
        id: MuID,
        sig: MuID,
        callee: MuID,
        args: Vec<MuID>
    ) {
        trace!("new_tailcall");
        self.add_inst(
            id,
            NodeInst::NodeTailCall {
                id: id,
                sig: sig,
                callee: callee,
                args: args
            }
        );
    }

    pub fn new_ret(&mut self, id: MuID, rvs: Vec<MuID>) {
        trace!("new_ret");
        self.add_inst(id, NodeInst::NodeRet { id: id, rvs: rvs });
    }

    pub fn new_throw(&mut self, id: MuID, exc: MuID) {
        trace!("new_throw");
        self.add_inst(id, NodeInst::NodeThrow { id: id, exc: exc });
    }

    pub fn new_extractvalue(
        &mut self,
        id: MuID,
        result_id: MuID,
        strty: MuID,
        index: c_int,
        opnd: MuID
    ) {
        trace!("new_extractvalue");
        self.add_inst(
            id,
            NodeInst::NodeExtractValue {
                id: id,
                result_id: result_id,
                strty: strty,
                index: index,
                opnd: opnd
            }
        );
    }

    pub fn new_insertvalue(
        &mut self,
        id: MuID,
        result_id: MuID,
        strty: MuID,
        index: c_int,
        opnd: MuID,
        newval: MuID
    ) {
        trace!("new_insertvalue");
        self.add_inst(
            id,
            NodeInst::NodeInsertValue {
                id: id,
                result_id: result_id,
                strty: strty,
                index: index,
                opnd: opnd,
                newval: newval
            }
        );
    }

    pub fn new_extractelement(
        &mut self,
        id: MuID,
        result_id: MuID,
        seqty: MuID,
        indty: MuID,
        opnd: MuID,
        index: MuID
    ) {
        trace!("new_extractelement");
        self.add_inst(
            id,
            NodeInst::NodeExtractElement {
                id: id,
                result_id: result_id,
                seqty: seqty,
                indty: indty,
                opnd: opnd,
                index: index
            }
        );
    }

    pub fn new_insertelement(
        &mut self,
        id: MuID,
        result_id: MuID,
        seqty: MuID,
        indty: MuID,
        opnd: MuID,
        index: MuID,
        newval: MuID
    ) {
        trace!("new_insertelement");
        self.add_inst(
            id,
            NodeInst::NodeInsertElement {
                id: id,
                result_id: result_id,
                seqty: seqty,
                indty: indty,
                opnd: opnd,
                index: index,
                newval: newval
            }
        );
    }

    pub fn new_shufflevector(
        &mut self,
        id: MuID,
        result_id: MuID,
        vecty: MuID,
        maskty: MuID,
        vec1: MuID,
        vec2: MuID,
        mask: MuID
    ) {
        trace!("new_shufflevector");
        self.add_inst(
            id,
            NodeInst::NodeShuffleVector {
                id: id,
                result_id: result_id,
                vecty: vecty,
                maskty: maskty,
                vec1: vec1,
                vec2: vec2,
                mask: mask
            }
        );
    }

    pub fn new_new(
        &mut self,
        id: MuID,
        result_id: MuID,
        allocty: MuID,
        exc_clause: Option<MuID>
    ) {
        trace!("new_new");
        self.add_inst(
            id,
            NodeInst::NodeNew {
                id: id,
                result_id: result_id,
                allocty: allocty,
                exc_clause: exc_clause
            }
        );
    }

    pub fn new_newhybrid(
        &mut self,
        id: MuID,
        result_id: MuID,
        allocty: MuID,
        lenty: MuID,
        length: MuID,
        exc_clause: Option<MuID>
    ) {
        trace!("new_newhybrid");
        self.add_inst(
            id,
            NodeInst::NodeNewHybrid {
                id: id,
                result_id: result_id,
                allocty: allocty,
                lenty: lenty,
                length: length,
                exc_clause: exc_clause
            }
        );
    }

    pub fn new_alloca(
        &mut self,
        id: MuID,
        result_id: MuID,
        allocty: MuID,
        exc_clause: Option<MuID>
    ) {
        trace!("new_alloca");
        self.add_inst(
            id,
            NodeInst::NodeAlloca {
                id: id,
                result_id: result_id,
                allocty: allocty,
                exc_clause: exc_clause
            }
        );
    }

    pub fn new_allocahybrid(
        &mut self,
        id: MuID,
        result_id: MuID,
        allocty: MuID,
        lenty: MuID,
        length: MuID,
        exc_clause: Option<MuID>
    ) {
        trace!("new_allocahybrid");
        self.add_inst(
            id,
            NodeInst::NodeAllocaHybrid {
                id: id,
                result_id: result_id,
                allocty: allocty,
                lenty: lenty,
                length: length,
                exc_clause: exc_clause
            }
        );
    }

    pub fn new_getiref(
        &mut self,
        id: MuID,
        result_id: MuID,
        refty: MuID,
        opnd: MuID
    ) {
        trace!("new_getiref");
        self.add_inst(
            id,
            NodeInst::NodeGetIRef {
                id: id,
                result_id: result_id,
                refty: refty,
                opnd: opnd
            }
        );
    }

    pub fn new_getfieldiref(
        &mut self,
        id: MuID,
        result_id: MuID,
        is_ptr: bool,
        refty: MuID,
        index: c_int,
        opnd: MuID
    ) {
        trace!("new_getfieldiref");
        self.add_inst(
            id,
            NodeInst::NodeGetFieldIRef {
                id: id,
                result_id: result_id,
                is_ptr: is_ptr,
                refty: refty,
                index: index,
                opnd: opnd
            }
        );
    }

    pub fn new_getelemiref(
        &mut self,
        id: MuID,
        result_id: MuID,
        is_ptr: bool,
        refty: MuID,
        indty: MuID,
        opnd: MuID,
        index: MuID
    ) {
        trace!("new_getelemiref");
        self.add_inst(
            id,
            NodeInst::NodeGetElemIRef {
                id: id,
                result_id: result_id,
                is_ptr: is_ptr,
                refty: refty,
                indty: indty,
                opnd: opnd,
                index: index
            }
        );
    }

    pub fn new_shiftiref(
        &mut self,
        id: MuID,
        result_id: MuID,
        is_ptr: bool,
        refty: MuID,
        offty: MuID,
        opnd: MuID,
        offset: MuID
    ) {
        trace!("new_shiftiref");
        self.add_inst(
            id,
            NodeInst::NodeShiftIRef {
                id: id,
                result_id: result_id,
                is_ptr: is_ptr,
                refty: refty,
                offty: offty,
                opnd: opnd,
                offset: offset
            }
        );
    }

    pub fn new_getvarpartiref(
        &mut self,
        id: MuID,
        result_id: MuID,
        is_ptr: bool,
        refty: MuID,
        opnd: MuID
    ) {
        trace!("new_getvarpartiref");
        self.add_inst(
            id,
            NodeInst::NodeGetVarPartIRef {
                id: id,
                result_id: result_id,
                is_ptr: is_ptr,
                refty: refty,
                opnd: opnd
            }
        );
    }

    pub fn new_load(
        &mut self,
        id: MuID,
        result_id: MuID,
        is_ptr: bool,
        ord: CMuMemOrd,
        refty: MuID,
        loc: MuID,
        exc_clause: Option<MuID>
    ) {
        trace!("new_load");
        self.add_inst(
            id,
            NodeInst::NodeLoad {
                id: id,
                result_id: result_id,
                is_ptr: is_ptr,
                ord: ord,
                refty: refty,
                loc: loc,
                exc_clause: exc_clause
            }
        );
    }

    pub fn new_store(
        &mut self,
        id: MuID,
        is_ptr: bool,
        ord: CMuMemOrd,
        refty: MuID,
        loc: MuID,
        newval: MuID,
        exc_clause: Option<MuID>
    ) {
        trace!("new_store");
        self.add_inst(
            id,
            NodeInst::NodeStore {
                id: id,
                is_ptr: is_ptr,
                ord: ord,
                refty: refty,
                loc: loc,
                newval: newval,
                exc_clause: exc_clause
            }
        );
    }

    pub fn new_cmpxchg(
        &mut self,
        id: MuID,
        value_result_id: MuID,
        succ_result_id: MuID,
        is_ptr: bool,
        is_weak: bool,
        ord_succ: CMuMemOrd,
        ord_fail: CMuMemOrd,
        refty: MuID,
        loc: MuID,
        expected: MuID,
        desired: MuID,
        exc_clause: Option<MuID>
    ) {
        trace!("new_cmpxchg");
        self.add_inst(
            id,
            NodeInst::NodeCmpXchg {
                id: id,
                value_result_id: value_result_id,
                succ_result_id: succ_result_id,
                is_ptr: is_ptr,
                is_weak: is_weak,
                ord_succ: ord_succ,
                ord_fail: ord_fail,
                refty: refty,
                loc: loc,
                expected: expected,
                desired: desired,
                exc_clause: exc_clause
            }
        );
    }

    pub fn new_atomicrmw(
        &mut self,
        id: MuID,
        result_id: MuID,
        is_ptr: bool,
        ord: CMuMemOrd,
        optr: CMuAtomicRMWOptr,
        ref_ty: MuID,
        loc: MuID,
        opnd: MuID,
        exc_clause: Option<MuID>
    ) {
        trace!("new_atomicrmw");
        self.add_inst(
            id,
            NodeInst::NodeAtomicRMW {
                id: id,
                result_id: result_id,
                is_ptr: is_ptr,
                ord: ord,
                optr: optr,
                ref_ty: ref_ty,
                loc: loc,
                opnd: opnd,
                exc_clause: exc_clause
            }
        );
    }

    pub fn new_fence(&mut self, id: MuID, ord: CMuMemOrd) {
        trace!("new_fence");
        self.add_inst(id, NodeInst::NodeFence { id: id, ord: ord });
    }

    pub fn new_trap(
        &mut self,
        id: MuID,
        result_ids: Vec<MuID>,
        rettys: Vec<MuID>,
        exc_clause: Option<MuID>,
        keepalive_clause: Option<MuID>
    ) {
        trace!("new_trap");
        self.add_inst(
            id,
            NodeInst::NodeTrap {
                id: id,
                result_ids: result_ids,
                rettys: rettys,
                exc_clause: exc_clause,
                keepalive_clause: keepalive_clause
            }
        );
    }

    pub fn new_watchpoint(
        &mut self,
        id: MuID,
        wpid: CMuWPID,
        result_ids: Vec<MuID>,
        rettys: Vec<MuID>,
        dis: MuID,
        ena: MuID,
        exc: Option<MuID>,
        keepalive_clause: Option<MuID>
    ) {
        trace!("new_watchpoint");
        self.add_inst(
            id,
            NodeInst::NodeWatchPoint {
                id: id,
                wpid: wpid as MuID,
                result_ids: result_ids,
                rettys: rettys,
                dis: dis,
                ena: ena,
                exc: exc,
                keepalive_clause: keepalive_clause
            }
        );
    }

    pub fn new_wpbranch(
        &mut self,
        id: MuID,
        wpid: CMuWPID,
        dis: MuID,
        ena: MuID
    ) {
        trace!("new_wpbranch");