inst_sel.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.

use ast::inst::*;
use ast::ir::*;
use ast::op;
use ast::op::*;
use ast::ptr::*;
use ast::types::*;
use runtime::entrypoints;
use runtime::entrypoints::RuntimeEntrypoint;
use runtime::mm;
use runtime::thread;
use runtime::ValueLocation;
use vm::VM;

use compiler::backend::x86_64;
use compiler::backend::x86_64::callconv;
use compiler::backend::x86_64::callconv::CallConvResult;
use compiler::backend::x86_64::*;
use compiler::backend::*;
use compiler::frame::Frame;
use compiler::machine_code::CompiledFunction;
use compiler::CompilerPass;
use compiler::PROLOGUE_BLOCK_NAME;

use utils::math;
use utils::{BitSize, ByteSize};
use utils::{POINTER_SIZE, WORD_SIZE};

use std::any::Any;
use std::collections::HashMap;
use std::collections::LinkedList;
use std::sync::Arc;

lazy_static! {
    /// struct<int32, int32, int32, int32>
    static ref LONG_4_TYPE : P<MuType> = P(
        MuType::new(new_internal_id(), MuType_::mustruct(Mu("long_4"),
        vec![UINT32_TYPE.clone(); 4]))
    );

    /// constant for converting unsigned integer to floating point
    static ref UITOFP_C0 : P<Value> = P(Value{
        hdr: MuEntityHeader::named(new_internal_id(), Mu("UITOFP_C0")),
        ty : LONG_4_TYPE.clone(),
        v  : Value_::Constant(Constant::List(vec![
            P(Value{
                hdr: MuEntityHeader::unnamed(new_internal_id()),
                ty: UINT32_TYPE.clone(),
                v : Value_::Constant(Constant::Int(1127219200u64))
            }),
            P(Value{
                hdr: MuEntityHeader::unnamed(new_internal_id()),
                ty: UINT32_TYPE.clone(),
                v : Value_::Constant(Constant::Int(1160773632u64))
            }),
            P(Value{
                hdr: MuEntityHeader::unnamed(new_internal_id()),
                ty: UINT32_TYPE.clone(),
                v : Value_::Constant(Constant::Int(0u64))
            }),
            P(Value{
                hdr: MuEntityHeader::unnamed(new_internal_id()),
                ty: UINT32_TYPE.clone(),
                v : Value_::Constant(Constant::Int(0u64))
            })
        ]))
    });

    /// struct<int64, int64>
    static ref QUAD_2_TYPE : P<MuType> = P(
        MuType::new(new_internal_id(), MuType_::mustruct(Mu("quad_2"),
        vec![UINT64_TYPE.clone(); 2]))
    );

    /// constant for converting unsigned integer to floating point
    static ref UITOFP_C1 : P<Value> = P(Value{
        hdr: MuEntityHeader::named(new_internal_id(), Mu("UITOFP_C1")),
        ty : QUAD_2_TYPE.clone(),
        v  : Value_::Constant(Constant::List(vec![
            P(Value{
                hdr: MuEntityHeader::unnamed(new_internal_id()),
                ty: UINT64_TYPE.clone(),
                v : Value_::Constant(Constant::Int(4841369599423283200u64))
            }),
            P(Value{
                hdr: MuEntityHeader::unnamed(new_internal_id()),
                ty: UINT64_TYPE.clone(),
                v : Value_::Constant(Constant::Int(4985484787499139072u64))
            })
        ]))
    });

    /// constant for converting double to unsigned integer
    static ref FPTOUI_C_DOUBLE : P<Value> = P(Value{
        hdr: MuEntityHeader::named(new_internal_id(), Mu("FPTOUI_C_DOUBLE")),
        ty : UINT64_TYPE.clone(),
        v  : Value_::Constant(Constant::Int(4890909195324358656u64))
    });

    /// constant for converting float to unsigned integer
    pub static ref FPTOUI_C_FLOAT : P<Value> = P(Value{
        hdr: MuEntityHeader::named(new_internal_id(), Mu("FPTOUI_C_FLOAT")),
        ty : UINT32_TYPE.clone(),
        v  : Value_::Constant(Constant::Int(1593835520u64))
    });
}

/// for some IR instructions, we need a call into runtime
/// for efficiency, we may emit runtime fastpath directly in assembly
//  FIXME: we should have a separate pass to rewrite the instruction into a
// fastpath (in IR),         and a call to slowpath, then instruction selection
// (see Issue#6)
const INLINE_FASTPATH: bool = false;

pub struct InstructionSelection {
    name: &'static str,
    /// backend code generator
    backend: Box<CodeGenerator>,

    // information about the function being compiled
    /// ID of current function version being compiled
    current_fv_id: MuID,
    /// name of current function version being compiled
    current_fv_name: MuName,
    /// signature of current function being compiled
    current_sig: Option<P<MuFuncSig>>,
    /// used to create a unique callsite ID for current function
    current_callsite_id: usize,
    /// frame for current function
    current_frame: Option<Frame>,
    /// block that is currently being compiled
    /// the block may be created during instruction selection
    current_block: Option<MuName>,
    /// IR block that is currently being compiled
    /// use this block name to trace some information at IR level
    current_block_in_ir: Option<MuName>,
    /// start location of current function
    current_func_start: Option<ValueLocation>,
    /// technically this is a map in that each Key is unique, but we will never
    /// try and add duplicate keys, or look things up, so a list of tuples
    /// is faster than a Map. A list of tuples, the first is the name of a
    /// callsite, the next is the callsite destination, the last is the
    /// size of arguments pushed on the stack
    current_callsites: LinkedList<(MuName, MuID, usize)>,
    // key: block id, val: block location
    current_exn_blocks: HashMap<MuID, MuName>,
    /// constants used in this function that are put to memory
    /// key: value id, val: constant value
    current_constants: HashMap<MuID, P<Value>>,
    /// constants used in this function that are put to memory
    /// key: value id, val: memory location
    current_constants_locs: HashMap<MuID, P<Value>>
}

impl<'a> InstructionSelection {
    #[cfg(feature = "aot")]
    pub fn new() -> InstructionSelection {
        InstructionSelection {
            name: "Instruction Selection (x64)",
            backend: Box::new(ASMCodeGen::new()),

            current_fv_id: 0,
            current_fv_name: Arc::new(String::new()),
            current_sig: None,
            current_callsite_id: 0,
            current_frame: None,
            // which block we are generating code for
            current_block: None,
            // it is possible the block is newly created in instruction
            // selection
            // but sometimes we want to know its control flow
            // so we need to track what block it is from the IR

            // FIXME: ideally we should not create new blocks in instruction
            // selection see Issue #6
            current_block_in_ir: None,
            current_func_start: None,
            current_callsites: LinkedList::new(),
            current_exn_blocks: HashMap::new(),

            current_constants: HashMap::new(),
            current_constants_locs: HashMap::new()
        }
    }

    #[cfg(feature = "jit")]
    pub fn new() -> InstructionSelection {
        unimplemented!()
    }

    //noinspection RsTypeCheck
    /// we use hand-written pattern matching rules for instruction selection
    /// for a pattern that can match several rules, the first rule met will be
    /// executed, and chosen.
    fn instruction_select(
        &mut self,
        node: &'a TreeNode,
        f_content: &FunctionContent,
        f_context: &mut FunctionContext,
        vm: &VM
    ) {
        trace!("instsel on node#{} {}", node.id(), node);

        match node.v {
            TreeNode_::Instruction(ref inst) => {
                match inst.v {
                    Instruction_::Branch2 {
                        cond,
                        ref true_dest,
                        ref false_dest,
                        ..
                    } => {
                        trace!("instsel on BRANCH2");
                        let (fallthrough_dest, branch_dest) =
                            (false_dest, true_dest);

                        let ref ops = inst.ops;
                        self.process_dest(
                            &ops,
                            fallthrough_dest,
                            f_content,
                            f_context,
                            vm
                        );
                        self.process_dest(
                            &ops,
                            branch_dest,
                            f_content,
                            f_context,
                            vm
                        );

                        let branch_target =
                            f_content.get_block(branch_dest.target.id()).name();

                        let ref cond = ops[cond];
                        if self.match_cmp_res(cond) {
                            // this branch2's cond is from a comparison result
                            trace!("emit cmp_res-branch2");
                            match self
                                .emit_cmp_res(cond, f_content, f_context, vm)
                            {
                                op::CmpOp::EQ => {
                                    self.backend.emit_je(branch_target)
                                }
                                op::CmpOp::NE => {
                                    self.backend.emit_jne(branch_target)
                                }
                                op::CmpOp::UGE => {
                                    self.backend.emit_jae(branch_target)
                                }
                                op::CmpOp::UGT => {
                                    self.backend.emit_ja(branch_target)
                                }
                                op::CmpOp::ULE => {
                                    self.backend.emit_jbe(branch_target)
                                }
                                op::CmpOp::ULT => {
                                    self.backend.emit_jb(branch_target)
                                }
                                op::CmpOp::SGE => {
                                    self.backend.emit_jge(branch_target)
                                }
                                op::CmpOp::SGT => {
                                    self.backend.emit_jg(branch_target)
                                }
                                op::CmpOp::SLE => {
                                    self.backend.emit_jle(branch_target)
                                }
                                op::CmpOp::SLT => {
                                    self.backend.emit_jl(branch_target)
                                }

                                // floating point
                                op::CmpOp::FOEQ | op::CmpOp::FUEQ => {
                                    self.backend.emit_je(branch_target)
                                }
                                op::CmpOp::FONE | op::CmpOp::FUNE => {
                                    self.backend.emit_jne(branch_target)
                                }
                                op::CmpOp::FOGT | op::CmpOp::FUGT => {
                                    self.backend.emit_ja(branch_target)
                                }
                                op::CmpOp::FOGE | op::CmpOp::FUGE => {
                                    self.backend.emit_jae(branch_target)
                                }
                                op::CmpOp::FOLT | op::CmpOp::FULT => {
                                    self.backend.emit_jb(branch_target)
                                }
                                op::CmpOp::FOLE | op::CmpOp::FULE => {
                                    self.backend.emit_jbe(branch_target)
                                }

                                _ => unimplemented!()
                            }
                        } else if self.match_ireg(cond) {
                            // this branch2 cond is a temporary with value, or
                            // an instruction that
                            // emits a temporary
                            trace!("emit ireg-branch2");

                            let cond_reg =
                                self.emit_ireg(cond, f_content, f_context, vm);

                            // emit: cmp cond_reg 1
                            self.backend.emit_cmp_imm_r(1, &cond_reg);
                            // emit: je #branch_dest
                            self.backend.emit_je(branch_target);
                        } else {
                            panic!("unexpected cond in BRANCH2: {}", cond)
                        }
                    }

                    Instruction_::Select {
                        cond,
                        true_val,
                        false_val
                    } => {
                        use ast::op::CmpOp::*;

                        trace!("instsel on SELECT");
                        let ref ops = inst.ops;

                        let ref cond = ops[cond];
                        let ref true_val = ops[true_val];
                        let ref false_val = ops[false_val];

                        // generate comparison
                        let cmpop = if self.match_cmp_res(cond) {
                            self.emit_cmp_res(cond, f_content, f_context, vm)
                        } else if self.match_ireg(cond) {
                            let tmp_cond =
                                self.emit_ireg(cond, f_content, f_context, vm);
                            // emit: cmp cond_reg 1
                            self.backend.emit_cmp_imm_r(1, &tmp_cond);

                            EQ
                        } else {
                            panic!("expected cond to be ireg, found {}", cond)
                        };

                        // emit code to move values
                        if self.match_ireg(true_val) {
                            // moving integers/pointers
                            let tmp_res = self.get_result_value(node);

                            // use cmov for 16/32/64bit integer
                            // use jcc  for 8 bit
                            // FIXME: could use 32bit register to implement 8bit
                            // select
                            match tmp_res.ty.get_int_length() {
                                // cmov
                                Some(len) if len > 8 => {
                                    let tmp_true = self.emit_ireg(
                                        true_val, f_content, f_context, vm
                                    );
                                    let tmp_false = self.emit_ireg(
                                        false_val, f_content, f_context, vm
                                    );

                                    // mov tmp_false -> tmp_res
                                    self.backend
                                        .emit_mov_r_r(&tmp_res, &tmp_false);

                                    match cmpop {
                                        EQ => self.backend.emit_cmove_r_r(
                                            &tmp_res, &tmp_true
                                        ),
                                        NE => self.backend.emit_cmovne_r_r(
                                            &tmp_res, &tmp_true
                                        ),
                                        SGE => self.backend.emit_cmovge_r_r(
                                            &tmp_res, &tmp_true
                                        ),
                                        SGT => self.backend.emit_cmovg_r_r(
                                            &tmp_res, &tmp_true
                                        ),
                                        SLE => self.backend.emit_cmovle_r_r(
                                            &tmp_res, &tmp_true
                                        ),
                                        SLT => self.backend.emit_cmovl_r_r(
                                            &tmp_res, &tmp_true
                                        ),
                                        UGE => self.backend.emit_cmovae_r_r(
                                            &tmp_res, &tmp_true
                                        ),
                                        UGT => self.backend.emit_cmova_r_r(
                                            &tmp_res, &tmp_true
                                        ),
                                        ULE => self.backend.emit_cmovbe_r_r(
                                            &tmp_res, &tmp_true
                                        ),
                                        ULT => self.backend.emit_cmovb_r_r(
                                            &tmp_res, &tmp_true
                                        ),

                                        FOEQ | FUEQ => {
                                            self.backend.emit_cmove_r_r(
                                                &tmp_res, &tmp_true
                                            )
                                        }
                                        FONE | FUNE => {
                                            self.backend.emit_cmovne_r_r(
                                                &tmp_res, &tmp_true
                                            )
                                        }
                                        FOGT | FUGT => {
                                            self.backend.emit_cmova_r_r(
                                                &tmp_res, &tmp_true
                                            )
                                        }
                                        FOGE | FUGE => {
                                            self.backend.emit_cmovae_r_r(
                                                &tmp_res, &tmp_true
                                            )
                                        }
                                        FOLT | FULT => {
                                            self.backend.emit_cmovb_r_r(
                                                &tmp_res, &tmp_true
                                            )
                                        }
                                        FOLE | FULE => {
                                            self.backend.emit_cmovbe_r_r(
                                                &tmp_res, &tmp_true
                                            )
                                        }

                                        // FFALSE/FTRUE unimplemented
                                        _ => unimplemented!()
                                    }
                                }
                                // jcc - for 8-bits integer
                                _ => {
                                    let blk_true = make_block_name(
                                        &node.name(),
                                        "select_true"
                                    );
                                    let blk_false = make_block_name(
                                        &node.name(),
                                        "select_false"
                                    );
                                    let blk_end = make_block_name(
                                        &node.name(),
                                        "select_end"
                                    );

                                    // jump to blk_true if true
                                    match cmpop {
                                        EQ => self
                                            .backend
                                            .emit_je(blk_true.clone()),
                                        NE => self
                                            .backend
                                            .emit_jne(blk_true.clone()),
                                        SGE => self
                                            .backend
                                            .emit_jge(blk_true.clone()),
                                        SGT => self
                                            .backend
                                            .emit_jg(blk_true.clone()),
                                        SLE => self
                                            .backend
                                            .emit_jle(blk_true.clone()),
                                        SLT => self
                                            .backend
                                            .emit_jl(blk_true.clone()),
                                        UGE => self
                                            .backend
                                            .emit_jae(blk_true.clone()),
                                        UGT => self
                                            .backend
                                            .emit_ja(blk_true.clone()),
                                        ULE => self
                                            .backend
                                            .emit_jbe(blk_true.clone()),
                                        ULT => self
                                            .backend
                                            .emit_jb(blk_true.clone()),

                                        FOEQ | FUEQ => self
                                            .backend
                                            .emit_je(blk_true.clone()),
                                        FONE | FUNE => self
                                            .backend
                                            .emit_jne(blk_true.clone()),
                                        FOGT | FUGT => self
                                            .backend
                                            .emit_ja(blk_true.clone()),
                                        FOGE | FUGE => self
                                            .backend
                                            .emit_jae(blk_true.clone()),
                                        FOLT | FULT => self
                                            .backend
                                            .emit_jb(blk_true.clone()),
                                        FOLE | FULE => self
                                            .backend
                                            .emit_jbe(blk_true.clone()),

                                        // FFALSE/FTRUE unimplemented
                                        _ => unimplemented!()
                                    }

                                    // finishing current block
                                    self.finish_block();

                                    // blk_false:
                                    self.start_block(blk_false.clone());
                                    // mov false result here
                                    self.emit_move_node_to_value(
                                        &tmp_res, &false_val, f_content,
                                        f_context, vm
                                    );
                                    // jmp to end
                                    self.backend.emit_jmp(blk_end.clone());
                                    // finishing current block
                                    self.finish_block();

                                    // blk_true:
                                    self.start_block(blk_true.clone());
                                    // mov true value -> result
                                    self.emit_move_node_to_value(
                                        &tmp_res, &true_val, f_content,
                                        f_context, vm
                                    );
                                    self.finish_block();

                                    // blk_end:
                                    self.start_block(blk_end.clone());
                                }
                            }
                        } else if self.match_fpreg(true_val) {
                            let tmp_res = self.get_result_value(node);

                            let blk_true =
                                make_block_name(&node.name(), "select_true");
                            let blk_false =
                                make_block_name(&node.name(), "select_false");
                            let blk_end =
                                make_block_name(&node.name(), "select_end");

                            // jump to blk_true if true
                            match cmpop {
                                EQ => self.backend.emit_je(blk_true.clone()),
                                NE => self.backend.emit_jne(blk_true.clone()),
                                SGE => self.backend.emit_jge(blk_true.clone()),
                                SGT => self.backend.emit_jg(blk_true.clone()),
                                SLE => self.backend.emit_jle(blk_true.clone()),
                                SLT => self.backend.emit_jl(blk_true.clone()),
                                UGE => self.backend.emit_jae(blk_true.clone()),
                                UGT => self.backend.emit_ja(blk_true.clone()),
                                ULE => self.backend.emit_jbe(blk_true.clone()),
                                ULT => self.backend.emit_jb(blk_true.clone()),

                                FOEQ | FUEQ => {
                                    self.backend.emit_je(blk_true.clone())
                                }
                                FONE | FUNE => {
                                    self.backend.emit_jne(blk_true.clone())
                                }
                                FOGT | FUGT => {
                                    self.backend.emit_ja(blk_true.clone())
                                }
                                FOGE | FUGE => {
                                    self.backend.emit_jae(blk_true.clone())
                                }
                                FOLT | FULT => {
                                    self.backend.emit_jb(blk_true.clone())
                                }
                                FOLE | FULE => {
                                    self.backend.emit_jbe(blk_true.clone())
                                }

                                _ => unimplemented!()
                            }

                            // finishing current block
                            self.finish_block();

                            // blk_false:
                            self.start_block(blk_false.clone());
                            // mov false result here
                            self.emit_move_node_to_value(
                                &tmp_res, &false_val, f_content, f_context, vm
                            );
                            // jmp to end
                            self.backend.emit_jmp(blk_end.clone());

                            // finishing current block
                            self.finish_block();

                            // blk_true:
                            self.start_block(blk_true.clone());
                            // mov true value -> result
                            self.emit_move_node_to_value(
                                &tmp_res, &true_val, f_content, f_context, vm
                            );
                            self.finish_block();

                            // blk_end:
                            self.start_block(blk_end.clone());
                        } else {
                            unimplemented!()
                        }
                    }

                    Instruction_::CmpOp(_, _, _) => {
                        use ast::op::CmpOp::*;
                        trace!("instsel on CMPOP");

                        let tmp_res = self.get_result_value(node);
                        assert!(tmp_res.ty.get_int_length().is_some());
                        assert!(tmp_res.ty.get_int_length().unwrap() == 1);

                        // set byte to result
                        match self.emit_cmp_res(node, f_content, f_context, vm)
                        {
                            EQ => self.backend.emit_sete_r(&tmp_res),
                            NE => self.backend.emit_setne_r(&tmp_res),
                            SGE => self.backend.emit_setge_r(&tmp_res),
                            SGT => self.backend.emit_setg_r(&tmp_res),
                            SLE => self.backend.emit_setle_r(&tmp_res),
                            SLT => self.backend.emit_setl_r(&tmp_res),
                            UGE => self.backend.emit_setae_r(&tmp_res),
                            UGT => self.backend.emit_seta_r(&tmp_res),
                            ULE => self.backend.emit_setbe_r(&tmp_res),
                            ULT => self.backend.emit_setb_r(&tmp_res),

                            FOEQ | FUEQ => self.backend.emit_sete_r(&tmp_res),
                            FONE | FUNE => self.backend.emit_setne_r(&tmp_res),
                            FOGT | FUGT => self.backend.emit_seta_r(&tmp_res),
                            FOGE | FUGE => self.backend.emit_setae_r(&tmp_res),
                            FOLT | FULT => self.backend.emit_setb_r(&tmp_res),
                            FOLE | FULE => self.backend.emit_setbe_r(&tmp_res),

                            // FFALSE/FTRUE
                            _ => unimplemented!()
                        }
                    }

                    Instruction_::Branch1(ref dest) => {
                        trace!("instsel on BRANCH1");
                        let ref ops = inst.ops;

                        self.process_dest(&ops, dest, f_content, f_context, vm);

                        let target =
                            f_content.get_block(dest.target.id()).name();
                        // jmp
                        self.backend.emit_jmp(target);
                    }

                    Instruction_::Switch {
                        cond,
                        ref default,
                        ref branches
                    } => {
                        trace!("instsel on SWITCH");
                        let ref ops = inst.ops;
                        let ref cond = ops[cond];

                        if self.match_ireg(cond) {
                            let tmp_cond =
                                self.emit_ireg(cond, f_content, f_context, vm);

                            // currently implementing switch as cascading
                            // conditional branch
                            // This is slow if there are many 'case' arms. We
                            // should consider using
                            // a switch table

                            // emit each branch
                            for &(case_op_index, ref case_dest) in branches {
                                let ref case_op = ops[case_op_index];

                                // process dest
                                self.process_dest(
                                    &ops, case_dest, f_content, f_context, vm
                                );

                                let target = f_content
                                    .get_block(case_dest.target.id())
                                    .name();

                                if self.match_iimm(case_op) {
                                    let imm = self.node_iimm_to_i32(case_op);

                                    // cmp case cond
                                    self.backend.emit_cmp_imm_r(imm, &tmp_cond);
                                    // je dest
                                    self.backend.emit_je(target);
                                } else if self.match_ireg(case_op) {
                                    let tmp_case_op = self.emit_ireg(
                                        case_op, f_content, f_context, vm
                                    );

                                    // cmp case cond
                                    self.backend
                                        .emit_cmp_r_r(&tmp_case_op, &tmp_cond);
                                    // je dest
                                    self.backend.emit_je(target);
                                } else {
                                    panic!(
                                        "expecting ireg cond to be either iimm or ireg: {}",
                                        cond
                                    );
                                }

                                self.finish_block();
                                let block_name = make_block_name(
                                    &node.name(),
                                    format!(
                                        "switch_not_met_case_{}",
                                        case_op_index
                                    )
                                    .as_str()
                                );
                                self.start_block(block_name);
                            }

                            // emit default
                            self.process_dest(
                                &ops, default, f_content, f_context, vm
                            );

                            let default_target =
                                f_content.get_block(default.target.id()).name();
                            self.backend.emit_jmp(default_target);
                        } else {
                            // other EQ-comparable types, e.g. floating point
                            unimplemented!()
                        }
                    }

                    Instruction_::ExprCall { ref data, is_abort } => {
                        trace!("instsel on EXPRCALL");

                        if is_abort {
                            // if any exception throws from the callee,
                            // we should abort execution, otherwise rethrow the
                            // exception
                            // FIXME: implement is_abort
                            unimplemented!()
                        }

                        self.emit_mu_call(
                            inst, // inst: &Instruction,
                            data, // calldata: &CallData,
                            None, // resumption: Option<&ResumptionData>,
                            node, // cur_node: &TreeNode,
                            f_content, f_context, vm
                        );
                    }

                    Instruction_::Call {
                        ref data,
                        ref resume
                    } => {
                        trace!("instsel on CALL");

                        self.emit_mu_call(
                            inst,
                            data,
                            Some(resume),
                            node,
                            f_content,
                            f_context,
                            vm
                        );
                    }

                    Instruction_::ExprCCall { ref data, is_abort } => {
                        trace!("instsel on EXPRCCALL");

                        if is_abort {
                            // if any exception throws from the callee,
                            // we should abort execution, otherwise rethrow the
                            // exception
                            // FIXME: implement is_abort
                            unimplemented!()
                        }

                        self.emit_c_call_ir(
                            inst, data, None, node, f_content, f_context, vm
                        );
                    }

                    Instruction_::CCall {
                        ref data,
                        ref resume
                    } => {
                        trace!("instsel on CCALL");

                        self.emit_c_call_ir(
                            inst,
                            data,
                            Some(resume),
                            node,
                            f_content,
                            f_context,
                            vm
                        );
                    }

                    Instruction_::Return(_) => {
                        trace!("instsel on RETURN");

                        self.emit_common_epilogue(
                            inst, f_content, f_context, vm
                        );

                        self.backend.emit_ret();
                    }

                    Instruction_::BinOp(op, op1, op2) => {
                        trace!("instsel on BINOP");

                        self.emit_binop(
                            node, inst, op, op1, op2, f_content, f_context, vm
                        );
                    }

                    Instruction_::BinOpWithStatus(op, status, op1, op2) => {
                        trace!("instsel on BINOP_STATUS");

                        self.emit_binop(
                            node, inst, op, op1, op2, f_content, f_context, vm
                        );

                        let values = inst.value.as_ref().unwrap();
                        let mut status_value_index = 1;

                        // status flags only works with int operations
                        if RegGroup::get_from_value(&values[0]) == RegGroup::GPR
                        {
                            // for mul, div, idiv, some of the flags may not
                            // generated
                            // from the computation, and we may need extra code
                            // to get the flags
                            // FIXME: See Issue#22

                            // negative flag
                            if status.flag_n {
                                let tmp_status =
                                    values[status_value_index].clone();
                                status_value_index += 1;

                                self.backend.emit_sets_r8(&tmp_status);
                            }

                            // zero flag
                            if status.flag_z {
                                let tmp_status =
                                    values[status_value_index].clone();
                                status_value_index += 1;

                                self.backend.emit_setz_r8(&tmp_status);
                            }

                            // unsigned overflow
                            if status.flag_c {
                                let tmp_status =
                                    values[status_value_index].clone();
                                status_value_index += 1;

                                match op {
                                    BinOp::Add | BinOp::Sub | BinOp::Mul => {
                                        self.backend.emit_setb_r8(&tmp_status);
                                    }
                                    _ => panic!("Only Add/Sub/Mul has #C flag")
                                }
                            }

                            // signed overflow
                            if status.flag_v {
                                let tmp_status =
                                    values[status_value_index].clone();

                                match op {
                                    BinOp::Add | BinOp::Sub | BinOp::Mul => {
                                        self.backend.emit_seto_r8(&tmp_status);
                                    }
                                    _ => panic!("Only Add/Sub/Mul has #V flag")
                                }
                            }
                        } else if RegGroup::get_from_value(&values[0])
                            == RegGroup::GPREX
                        {
                            unimplemented!()
                        } else {
                            panic!(
                                "only int operations allow binop status flags"
                            )
                        }
                    }

                    Instruction_::ConvOp {
                        operation,
                        ref from_ty,
                        ref to_ty,
                        operand
                    } => {
                        trace!("instsel on CONVOP");

                        let ref ops = inst.ops;
                        let ref op = ops[operand];

                        match operation {