From b6886cc95702fe5f865a6a1eb7ec456278e69fbe Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Sat, 1 Jul 2023 16:38:37 +0800
Subject: [PATCH] :sparkles: finish new codegen

---
 ast/nasal_new_codegen.cpp |  160 ++++--
 ast/nasal_new_codegen.h   |    2 +-
 ast/nasal_new_dbg.cpp     |  235 ++++++++
 ast/nasal_new_dbg.h       |   87 +++
 ast/nasal_new_main.cpp    |   34 +-
 ast/nasal_new_opcode.cpp  |   25 +
 ast/nasal_new_opcode.h    |   29 +-
 ast/nasal_new_vm.cpp      | 1129 +++++++++++++++++++++++++++++++++++++
 ast/nasal_new_vm.h        |  159 ++++++
 makefile                  |   10 +-
 10 files changed, 1773 insertions(+), 97 deletions(-)
 create mode 100644 ast/nasal_new_dbg.cpp
 create mode 100644 ast/nasal_new_dbg.h
 create mode 100644 ast/nasal_new_vm.cpp
 create mode 100644 ast/nasal_new_vm.h

diff --git a/ast/nasal_new_codegen.cpp b/ast/nasal_new_codegen.cpp
index 984b72a..ea80e20 100644
--- a/ast/nasal_new_codegen.cpp
+++ b/ast/nasal_new_codegen.cpp
@@ -1,8 +1,8 @@
 #include "nasal_new_codegen.h"
 
-bool codegen::check_memory_reachable(call_expr* node) {
-    if (node->get_first()->get_type()==expr_type::ast_call) {
-        const auto tmp=node->get_calls().back();
+bool codegen::check_memory_reachable(expr* node) {
+    if (node->get_type()==expr_type::ast_call) {
+        const auto tmp=((call_expr*)node)->get_calls().back();
         if (tmp->get_type()==expr_type::ast_callf) {
             die("bad left-value with function call", node->get_location());
             return false;
@@ -13,7 +13,7 @@ bool codegen::check_memory_reachable(call_expr* node) {
             die("bad left-value with subvec", node->get_location());
             return false;
         }
-    } else if (node->get_first()->get_type()!=expr_type::ast_id) {
+    } else if (node->get_type()!=expr_type::ast_id) {
         die("bad left-value", node->get_location());
         return false;
     }
@@ -441,40 +441,127 @@ void codegen::assignment_gen(assignment_expr* node) {
             gen(op_meq, 0, node->get_location().begin_line);
             break;
         case assignment_expr::assign_type::add_equal:
+            if (node->get_right()->get_type()!=expr_type::ast_num) {
+                calc_gen(node->get_right());
+            }
+            mcall((call_expr*)node->get_left());
+            if (node->get_right()->get_type()!=expr_type::ast_num) {
+                gen(op_addeq, 0, node->get_location().begin_line);
+            } else {
+                auto num = ((number_literal*)node->get_right())->get_number();
+                regist_num(num);
+                gen(op_addeqc, num_table[num], node->get_location().begin_line);
+            }
+            break;
         case assignment_expr::assign_type::sub_equal:
+            if (node->get_right()->get_type()!=expr_type::ast_num) {
+                calc_gen(node->get_right());
+            }
+            mcall((call_expr*)node->get_left());
+            if (node->get_right()->get_type()!=expr_type::ast_num) {
+                gen(op_subeq, 0, node->get_location().begin_line);
+            } else {
+                auto num = ((number_literal*)node->get_right())->get_number();
+                regist_num(num);
+                gen(op_subeqc, num_table[num], node->get_location().begin_line);
+            }
+            break;
         case assignment_expr::assign_type::mult_equal:
+            if (node->get_right()->get_type()!=expr_type::ast_num) {
+                calc_gen(node->get_right());
+            }
+            mcall((call_expr*)node->get_left());
+            if (node->get_right()->get_type()!=expr_type::ast_num) {
+                gen(op_muleq, 0, node->get_location().begin_line);
+            } else {
+                auto num = ((number_literal*)node->get_right())->get_number();
+                regist_num(num);
+                gen(op_muleqc, num_table[num], node->get_location().begin_line);
+            }
+            break;
         case assignment_expr::assign_type::div_equal:
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
             }
             mcall((call_expr*)node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
-                gen(node->get_type()-ast_addeq+op_addeq, 0, node->get_location().begin_line);
+                gen(op_diveq, 0, node->get_location().begin_line);
             } else {
                 auto num = ((number_literal*)node->get_right())->get_number();
                 regist_num(num);
-                gen(node->get_type()-ast_addeq+op_addeqc, num_table[num], node->get_location().begin_line);
+                gen(op_diveqc, num_table[num], node->get_location().begin_line);
             }
             break;
         case assignment_expr::assign_type::concat_equal:
-            if (node[1]->get_type()!=ast_str) {
-                calc_gen(node[1]);
-            } else {
-                regist_str(node[1].str());
+            if (node->get_right()->get_type()!=expr_type::ast_str) {
+                calc_gen(node->get_right());
             }
-            mcall(node[0]);
-            if (node[1]->get_type()!=ast_str) {
+            mcall((call_expr*)node->get_left());
+            if (node->get_right()->get_type()!=expr_type::ast_str) {
                 gen(op_lnkeq, 0, node->get_location().begin_line);
             } else {
-                gen(op_lnkeqc, str_table[node[1].str()], node->get_location().begin_line);
+                const auto& str = ((string_literal*)node->get_right())->get_content();
+                regist_str(str);
+                gen(op_lnkeqc, str_table[str], node->get_location().begin_line);
             }
             break;
         case assignment_expr::assign_type::bitwise_and_equal:
+            calc_gen(node->get_right());
+            mcall((call_expr*)node->get_left());
+            gen(op_btandeq, 0, node->get_location().begin_line);
+            break;
         case assignment_expr::assign_type::bitwise_or_equal:
+            calc_gen(node->get_right());
+            mcall((call_expr*)node->get_left());
+            gen(op_btoreq, 0, node->get_location().begin_line);
+            break;
         case assignment_expr::assign_type::bitwise_xor_equal:
             calc_gen(node->get_right());
             mcall((call_expr*)node->get_left());
-            gen(node->get_type()-ast_btandeq+op_btandeq, 0, node->get_location().begin_line);
+            gen(op_btxoreq, 0, node->get_location().begin_line);
+            break;
+    }
+}
+
+void codegen::assign_statement(assignment_expr* node) {
+    switch(node->get_assignment_type()) {
+        case assignment_expr::assign_type::equal:
+            if (node->get_left()->get_type()==expr_type::ast_id) {
+                calc_gen(node->get_right());
+                mcall_id((identifier*)node->get_left());
+                // only the first mcall_id can use load
+                if (code.back().op==op_mcalll) {
+                    code.back().op=op_loadl;
+                } else if (code.back().op==op_mupval) {
+                    code.back().op=op_loadu;
+                } else {
+                    code.back().op=op_loadg;
+                }
+            } else {
+                calc_gen(node);
+                if (code.back().op==op_meq) {
+                    code.back().num=1;
+                } else {
+                    gen(op_pop, 0, node->get_location().begin_line);
+                }
+            }
+            break;
+        case assignment_expr::assign_type::add_equal:
+        case assignment_expr::assign_type::sub_equal:
+        case assignment_expr::assign_type::mult_equal:
+        case assignment_expr::assign_type::div_equal:
+        case assignment_expr::assign_type::concat_equal:
+        case assignment_expr::assign_type::bitwise_and_equal:
+        case assignment_expr::assign_type::bitwise_or_equal:
+        case assignment_expr::assign_type::bitwise_xor_equal:
+            calc_gen(node);
+            if (op_addeq<=code.back().op && code.back().op<=op_btxoreq) {
+                code.back().num=1;
+            } else if (op_addeqc<=code.back().op && code.back().op<=op_lnkeqc) {
+                code.back().op=code.back().op-op_addeqc+op_addecp;
+            } else {
+                gen(op_pop, 0, node->get_location().begin_line);
+            }
             break;
     }
 }
@@ -624,50 +711,21 @@ void codegen::expr_gen(expr* node) {
     switch(node->get_type()) {
         case expr_type::ast_null:break;
         case expr_type::ast_def:
-            def_gen((definition_expr*)node);break;
+            def_gen((definition_expr*)node); break;
         case expr_type::ast_multi_assign:
-            multi_assign_gen((multi_assign*)node);break;
-        case expr_type::ast_nil:case expr_type::ast_num:case expr_type::ast_str:case expr_type::ast_bool:break;
-        case expr_type::ast_vec:case expr_type::ast_hash:case expr_type::ast_func:case expr_type::ast_call:
+            multi_assign_gen((multi_assign*)node); break;
+        case expr_type::ast_nil:case expr_type::ast_num:
+        case expr_type::ast_str:case expr_type::ast_bool:break;
+        case expr_type::ast_vec:case expr_type::ast_hash:
+        case expr_type::ast_func:case expr_type::ast_call:
         case expr_type::ast_unary:
         case expr_type::ast_binary:
         case expr_type::ast_ternary:
             calc_gen(node);
             gen(op_pop, 0, node->get_location().begin_line);
             break;
-        case expr_type::ast_equal:
-            if (node[0]->get_type()==expr_type::ast_id) {
-                calc_gen(node[1]);
-                mcall_id(node[0]);
-                // only the first mcall_id can use load
-                if (code.back().op==op_mcalll) {
-                    code.back().op=op_loadl;
-                } else if (code.back().op==op_mupval) {
-                    code.back().op=op_loadu;
-                } else {
-                    code.back().op=op_loadg;
-                }
-            } else {
-                calc_gen(node);
-                if (code.back().op==op_meq) {
-                    code.back().num=1;
-                } else {
-                    gen(op_pop, 0, node->get_location().begin_line);
-                }
-            }
-            break;
-        case expr_type::ast_addeq:case expr_type::ast_subeq:
-        case expr_type::ast_multeq:case expr_type::ast_diveq:case expr_type::ast_lnkeq:
-        case expr_type::ast_btandeq:case expr_type::ast_btoreq:case expr_type::ast_btxoreq:
-            calc_gen(node);
-            if (op_addeq<=code.back().op && code.back().op<=op_btxoreq) {
-                code.back().num=1;
-            } else if (op_addeqc<=code.back().op && code.back().op<=op_lnkeqc) {
-                code.back().op=code.back().op-op_addeqc+op_addecp;
-            } else {
-                gen(op_pop, 0, node->get_location().begin_line);
-            }
-            break;
+        case expr_type::ast_assign:
+            assign_statement((assignment_expr*)node); break;
     }
 }
 
diff --git a/ast/nasal_new_codegen.h b/ast/nasal_new_codegen.h
index 40fd3c6..bc398fa 100644
--- a/ast/nasal_new_codegen.h
+++ b/ast/nasal_new_codegen.h
@@ -40,7 +40,7 @@ private:
     // but in fact local scope also has less than STACK_DEPTH value
     std::list<std::unordered_map<std::string,i32>> local;
 
-    bool check_memory_reachable(call_expr*);
+    bool check_memory_reachable(expr*);
     void check_id_exist(identifier*);
     
     void die(const std::string& info, const span& loc) {
diff --git a/ast/nasal_new_dbg.cpp b/ast/nasal_new_dbg.cpp
new file mode 100644
index 0000000..182df43
--- /dev/null
+++ b/ast/nasal_new_dbg.cpp
@@ -0,0 +1,235 @@
+#include "nasal_new_dbg.h"
+
+std::vector<std::string> dbg::parse(const std::string& cmd) {
+    std::vector<std::string> res;
+    usize last=0;
+    usize pos=cmd.find(" ", 0);
+    while(pos!=std::string::npos) {
+        if (pos>last) {
+            res.push_back(cmd.substr(last, pos-last));
+        }
+        last=pos+1;
+        pos=cmd.find(" ", last);
+    }
+    if (last<cmd.length()) {
+        res.push_back(cmd.substr(last));
+    }
+    return res;
+}
+
+u16 dbg::file_index(const std::string& filename) const {
+    for(u16 i=0;i<fsize;++i) {
+        if (filename==files[i]) {
+            return i;
+        }
+    }
+    return 65535;
+}
+
+void dbg::err() {
+    std::cerr
+    <<"incorrect command\n"
+    <<"input \'h\' to get help\n";
+}
+
+void dbg::help() {
+    std::clog
+    <<"<option>\n"
+    <<"  h,   help      | get help\n"
+    <<"  bt,  backtrace | get function call trace\n"
+    <<"  c,   continue  | run program until break point or exit\n"
+    <<"  f,   file      | see all the compiled files\n"
+    <<"  g,   global    | see global values\n"
+    <<"  l,   local     | see local values\n"
+    <<"  u,   upval     | see upvalue\n"
+    <<"  r,   register  | show vm register detail\n"
+    <<"  a,   all       | show global,local and upvalue\n"
+    <<"  n,   next      | execute next bytecode\n"
+    <<"  q,   exit      | exit debugger\n"
+    <<"<option> <filename> <line>\n"
+    <<"  bk,  break     | set break point\n";
+}
+
+void dbg::list_file() const {
+    for(usize i=0; i<fsize; ++i) {
+        std::clog<<"["<<i<<"] "<<files[i]<<"\n";
+    }
+}
+
+void dbg::call_sort(const u64* arr) const {
+    typedef std::pair<u32,u64> op;
+    std::vector<op> opcall;
+    u64 total=0;
+    for(u32 i=0;i<op_ret+1;++i) {
+        total+=arr[i];
+        opcall.push_back({i, arr[i]});
+    }
+    std::sort(opcall.begin(), opcall.end(),
+        [](const op& a, const op& b) {return a.second>b.second;}
+    );
+    std::clog<<"\noperands call info (<1% ignored)\n";
+    for(auto& i:opcall) {
+        u64 rate=i.second*100/total;
+        if (!rate) {
+            break;
+        }
+        std::clog<<" "<<opname[i.first]<<" : "<<i.second<<" ("<<rate<<"%)\n";
+    }
+    std::clog<<" total  : "<<total<<'\n';
+}
+
+void dbg::step_info() {
+    u32 line=bytecode[ctx.pc].line==0?0:bytecode[ctx.pc].line-1;
+    u32 begin=(line>>3)==0?0:((line>>3)<<3);
+    u32 end=(1+(line>>3))<<3;
+    src.load(files[bytecode[ctx.pc].fidx]);
+    std::clog<<"\nsource code:\n";
+    for(u32 i=begin;i<end && i<src.size();++i) {
+        std::clog<<(i==line?back_white:reset)<<(i==line?"--> ":"    ")<<src[i]<<reset<<"\n";
+    }
+
+    begin=(ctx.pc>>3)==0?0:((ctx.pc>>3)<<3);
+    end=(1+(ctx.pc>>3))<<3;
+    codestream::set(cnum, cstr, files);
+    std::clog<<"next bytecode:\n";
+    for(u32 i=begin;i<end && bytecode[i].op!=op_exit;++i) {
+        std::clog
+        <<(i==ctx.pc?back_white:reset)
+        <<(i==ctx.pc?"--> ":"    ")
+        <<codestream(bytecode[i], i)
+        <<reset<<"\n";
+    }
+    stackinfo(10);
+}
+
+void dbg::interact() {
+    // special operand, end execution
+    if (bytecode[ctx.pc].op==op_exit) {
+        return;
+    }
+    
+    if ((bytecode[ctx.pc].fidx!=bk_fidx ||
+        bytecode[ctx.pc].line!=bk_line) && // break point
+        !next) {// next step
+        return;
+    }
+
+    next=false;
+    std::string cmd;
+    step_info();
+    while(true) {
+        std::clog<<">> ";
+        std::getline(std::cin, cmd);
+        auto res=parse(cmd);
+        if (res.size()==0) {
+            step_info();
+        } else if (res.size()==1) {
+            switch(get_cmd_type(res[0])) {
+                case dbg_cmd::cmd_help: help(); break;
+                case dbg_cmd::cmd_backtrace: traceback(); break;
+                case dbg_cmd::cmd_continue: return;
+                case dbg_cmd::cmd_list_file: list_file(); break;
+                case dbg_cmd::cmd_global: gstate(); break;
+                case dbg_cmd::cmd_local: lstate(); break;
+                case dbg_cmd::cmd_upval: ustate(); break;
+                case dbg_cmd::cmd_register: reginfo(); break;
+                case dbg_cmd::cmd_show_all: detail(); break;
+                case dbg_cmd::cmd_next: next=true; return;
+                case dbg_cmd::cmd_exit: std::exit(0);
+                default: err(); break;
+            }
+        } else if (res.size()==3 &&
+            get_cmd_type(res[0])==dbg_cmd::cmd_break_point) {
+            bk_fidx=file_index(res[1]);
+            if (bk_fidx==65535) {
+                std::clog<<"cannot find file named `"<<res[1]<<"`\n";
+                continue;
+            }
+            i32 tmp=atoi(res[2].c_str());
+            if (tmp<=0) {
+                std::clog<<"incorrect line number `"<<res[2]<<"`\n";
+            } else {
+                bk_line=tmp;
+            }
+        } else {
+            err();
+        }
+    }
+}
+
+void dbg::run(
+    const codegen& gen,
+    const linker& linker,
+    const std::vector<std::string>& argv) {
+    verbose=true;
+    fsize=linker.filelist().size();
+    init(gen.strs(), gen.nums(), gen.codes(), linker.filelist(), argv);
+    u64 count[op_ret+1]={0};
+    typedef void (dbg::*nafunc)();
+    const nafunc oprs[]={
+        nullptr,        &dbg::o_intg,
+        &dbg::o_intl,   &dbg::o_loadg,
+        &dbg::o_loadl,  &dbg::o_loadu,
+        &dbg::o_pnum,   &dbg::o_pnil,
+        &dbg::o_pstr,   &dbg::o_newv,
+        &dbg::o_newh,   &dbg::o_newf,
+        &dbg::o_happ,   &dbg::o_para,
+        &dbg::o_deft,   &dbg::o_dyn,
+        &dbg::o_lnot,   &dbg::o_usub,
+        &dbg::o_bnot,   &dbg::o_btor,
+        &dbg::o_btxor,  &dbg::o_btand,
+        &dbg::o_add,    &dbg::o_sub,
+        &dbg::o_mul,    &dbg::o_div,
+        &dbg::o_lnk,    &dbg::o_addc,
+        &dbg::o_subc,   &dbg::o_mulc,
+        &dbg::o_divc,   &dbg::o_lnkc,
+        &dbg::o_addeq,  &dbg::o_subeq,
+        &dbg::o_muleq,  &dbg::o_diveq,
+        &dbg::o_lnkeq,  &dbg::o_bandeq,
+        &dbg::o_boreq,  &dbg::o_bxoreq,
+        &dbg::o_addeqc, &dbg::o_subeqc,
+        &dbg::o_muleqc, &dbg::o_diveqc,
+        &dbg::o_lnkeqc, &dbg::o_addecp,
+        &dbg::o_subecp, &dbg::o_mulecp,
+        &dbg::o_divecp, &dbg::o_lnkecp,
+        &dbg::o_meq,    &dbg::o_eq,
+        &dbg::o_neq,    &dbg::o_less,
+        &dbg::o_leq,    &dbg::o_grt,
+        &dbg::o_geq,    &dbg::o_lessc,
+        &dbg::o_leqc,   &dbg::o_grtc,
+        &dbg::o_geqc,   &dbg::o_pop,
+        &dbg::o_jmp,    &dbg::o_jt,
+        &dbg::o_jf,     &dbg::o_cnt,
+        &dbg::o_findex, &dbg::o_feach,
+        &dbg::o_callg,  &dbg::o_calll,
+        &dbg::o_upval,  &dbg::o_callv,
+        &dbg::o_callvi, &dbg::o_callh,
+        &dbg::o_callfv, &dbg::o_callfh,
+        &dbg::o_callb,  &dbg::o_slcbeg,
+        &dbg::o_slcend, &dbg::o_slc,
+        &dbg::o_slc2,   &dbg::o_mcallg,
+        &dbg::o_mcalll, &dbg::o_mupval,
+        &dbg::o_mcallv, &dbg::o_mcallh,
+        &dbg::o_ret
+    };
+    std::vector<u32> code;
+    for(auto& i:gen.codes()) {
+        code.push_back(i.op);
+        imm.push_back(i.num);
+    }
+    while(oprs[code[ctx.pc]]) {
+        interact();
+        ++count[code[ctx.pc]];
+        (this->*oprs[code[ctx.pc]])();
+        if (ctx.top>=ctx.canary) {
+            die("stack overflow");
+        }
+        ++ctx.pc;
+    }
+
+    call_sort(count);
+    ngc.info();
+    ngc.clear();
+    imm.clear();
+    return;
+}
diff --git a/ast/nasal_new_dbg.h b/ast/nasal_new_dbg.h
new file mode 100644
index 0000000..d05bc25
--- /dev/null
+++ b/ast/nasal_new_dbg.h
@@ -0,0 +1,87 @@
+#pragma once
+
+#include "nasal_new_import.h"
+#include "nasal_new_err.h"
+#include "nasal_new_opcode.h"
+#include "nasal_new_vm.h"
+
+#include <cstring>
+#include <algorithm>
+#include <unordered_map>
+
+class dbg:public vm {
+private:
+    enum class dbg_cmd {
+        cmd_error,
+        cmd_help,
+        cmd_backtrace,
+        cmd_continue,
+        cmd_list_file,
+        cmd_global,
+        cmd_local,
+        cmd_upval,
+        cmd_register,
+        cmd_show_all,
+        cmd_next,
+        cmd_break_point,
+        cmd_exit
+    };
+
+private:
+    const std::unordered_map<std::string, dbg_cmd> command_table = {
+        {"h", dbg_cmd::cmd_help},
+        {"help", dbg_cmd::cmd_help},
+        {"bt", dbg_cmd::cmd_backtrace},
+        {"backtrace", dbg_cmd::cmd_backtrace},
+        {"c", dbg_cmd::cmd_continue},
+        {"continue", dbg_cmd::cmd_continue},
+        {"f", dbg_cmd::cmd_list_file},
+        {"file", dbg_cmd::cmd_list_file},
+        {"g", dbg_cmd::cmd_global},
+        {"global", dbg_cmd::cmd_global},
+        {"l", dbg_cmd::cmd_local},
+        {"local", dbg_cmd::cmd_local},
+        {"u", dbg_cmd::cmd_upval},
+        {"upval", dbg_cmd::cmd_upval},
+        {"r", dbg_cmd::cmd_register},
+        {"register", dbg_cmd::cmd_register},
+        {"a", dbg_cmd::cmd_show_all},
+        {"all", dbg_cmd::cmd_show_all},
+        {"n", dbg_cmd::cmd_next},
+        {"next", dbg_cmd::cmd_next},
+        {"bk", dbg_cmd::cmd_break_point},
+        {"break", dbg_cmd::cmd_break_point},
+        {"q", dbg_cmd::cmd_exit},
+        {"exit", dbg_cmd::cmd_exit}
+    };
+    dbg_cmd get_cmd_type(const std::string& cmd) const {
+        return command_table.count(cmd)?
+            command_table.at(cmd):dbg_cmd::cmd_error;
+    }
+
+private:
+    bool  next;
+    usize fsize;
+    u16   bk_fidx;
+    u32   bk_line;
+    error& src;
+
+    std::vector<std::string> parse(const std::string&);
+    u16 file_index(const std::string&) const;
+    void err();
+    void help();
+    void list_file() const;
+    void call_sort(const u64*) const;
+    void step_info();
+    void interact();
+public:
+    dbg(error& err):
+        next(false), fsize(0),
+        bk_fidx(0), bk_line(0),
+        src(err) {}
+    void run(
+        const codegen&,
+        const linker&,
+        const std::vector<std::string>&
+    );
+};
diff --git a/ast/nasal_new_main.cpp b/ast/nasal_new_main.cpp
index 1a2aeaf..94196ad 100644
--- a/ast/nasal_new_main.cpp
+++ b/ast/nasal_new_main.cpp
@@ -8,6 +8,9 @@
 #include "ast_dumper.h"
 #include "symbol_finder.h"
 #include "optimizer.h"
+#include "nasal_new_codegen.h"
+#include "nasal_new_vm.h"
+#include "nasal_new_dbg.h"
 
 #include <unordered_map>
 #include <thread>
@@ -73,8 +76,8 @@ void err() {
 void execute(
     const std::string& file,
     const std::vector<std::string>& argv,
-    const u32 cmd
-) {
+    const u32 cmd) {
+
     using clk=std::chrono::high_resolution_clock;
     const auto den=clk::duration::period::den;
 
@@ -82,8 +85,8 @@ void execute(
     lexer   lex(err);
     parse   parse(err);
     linker  ld(err);
-    // codegen gen(err);
-    // vm      ctx;
+    codegen gen(err);
+    vm      ctx;
 
     // lexer scans file to get tokens
     lex.scan(file).chkerr();
@@ -103,24 +106,19 @@ void execute(
     opt->do_optimization(parse.tree());
     delete opt;
 
-    auto finder = new symbol_finder;
-    for(const auto& symbol : finder->do_find(parse.tree())) {
-        std::cout << symbol << std::endl;
-    }
-
     // code generator gets parser's ast and import file list to generate code
-    // gen.compile(parse, ld).chkerr();
-    // if (cmd&VM_CODE) {
-    //     gen.print();
-    // }
+    gen.compile(parse, ld).chkerr();
+    if (cmd&VM_CODE) {
+        gen.print();
+    }
 
     // run
     auto start=clk::now();
-    // if (cmd&VM_DEBUG) {
-    //     dbg(err).run(gen, ld, argv);
-    // } else if (cmd&VM_TIME || cmd&VM_EXEC) {
-    //     ctx.run(gen, ld, argv, cmd&VM_DETAIL);
-    // }
+    if (cmd&VM_DEBUG) {
+        dbg(err).run(gen, ld, argv);
+    } else if (cmd&VM_TIME || cmd&VM_EXEC) {
+        ctx.run(gen, ld, argv, cmd&VM_DETAIL);
+    }
 
     // get running time
     if (cmd&VM_TIME) {
diff --git a/ast/nasal_new_opcode.cpp b/ast/nasal_new_opcode.cpp
index 6004308..d5f66b1 100644
--- a/ast/nasal_new_opcode.cpp
+++ b/ast/nasal_new_opcode.cpp
@@ -1,5 +1,30 @@
 #include "nasal_new_opcode.h"
 
+const char* opname[]={
+    "exit  ","intg  ","intl  ","loadg ",
+    "loadl ","loadu ","pnum  ","pnil  ",
+    "pstr  ","newv  ","newh  ","newf  ",
+    "happ  ","para  ","def   ","dyn   ",
+    "lnot  ","usub  ","bnot  ","btor  ",
+    "btxor ","btand ","add   ","sub   ",
+    "mult  ","div   ","lnk   ","addc  ",
+    "subc  ","multc ","divc  ","lnkc  ",
+    "addeq ","subeq ","muleq ","diveq ",
+    "lnkeq ","bandeq","boreq ","bxoreq",
+    "addeqc","subeqc","muleqc","diveqc",
+    "lnkeqc","addecp","subecp","mulecp",
+    "divecp","lnkecp","meq   ","eq    ",
+    "neq   ","less  ","leq   ","grt   ",
+    "geq   ","lessc ","leqc  ","grtc  ",
+    "geqc  ","pop   ","jmp   ","jt    ",
+    "jf    ","cnt   ","findx ","feach ",
+    "callg ","calll ","upval ","callv ",
+    "callvi","callh ","callfv","callfh",
+    "callb ","slcbeg","slcend","slc   ",
+    "slc2  ","mcallg","mcalll","mupval",
+    "mcallv","mcallh","ret   "
+};
+
 void codestream::set(
     const f64* numbuff,
     const std::string* strbuff,
diff --git a/ast/nasal_new_opcode.h b/ast/nasal_new_opcode.h
index c34d831..7b0e966 100644
--- a/ast/nasal_new_opcode.h
+++ b/ast/nasal_new_opcode.h
@@ -95,31 +95,6 @@ enum op_code_type:u8 {
     op_ret     // return
 };
 
-const char* opname[]={
-    "exit  ","intg  ","intl  ","loadg ",
-    "loadl ","loadu ","pnum  ","pnil  ",
-    "pstr  ","newv  ","newh  ","newf  ",
-    "happ  ","para  ","def   ","dyn   ",
-    "lnot  ","usub  ","bnot  ","btor  ",
-    "btxor ","btand ","add   ","sub   ",
-    "mult  ","div   ","lnk   ","addc  ",
-    "subc  ","multc ","divc  ","lnkc  ",
-    "addeq ","subeq ","muleq ","diveq ",
-    "lnkeq ","bandeq","boreq ","bxoreq",
-    "addeqc","subeqc","muleqc","diveqc",
-    "lnkeqc","addecp","subecp","mulecp",
-    "divecp","lnkecp","meq   ","eq    ",
-    "neq   ","less  ","leq   ","grt   ",
-    "geq   ","lessc ","leqc  ","grtc  ",
-    "geqc  ","pop   ","jmp   ","jt    ",
-    "jf    ","cnt   ","findx ","feach ",
-    "callg ","calll ","upval ","callv ",
-    "callvi","callh ","callfv","callfh",
-    "callb ","slcbeg","slcend","slc   ",
-    "slc2  ","mcallg","mcalll","mupval",
-    "mcallv","mcallh","ret   "
-};
-
 struct opcode {
     u8  op;   // opcode
     u16 fidx; // source code file index
@@ -143,4 +118,6 @@ public:
     void dump(std::ostream&) const;
 };
 
-std::ostream& operator<<(std::ostream&, const codestream&);
\ No newline at end of file
+std::ostream& operator<<(std::ostream&, const codestream&);
+
+extern const char* opname[];
\ No newline at end of file
diff --git a/ast/nasal_new_vm.cpp b/ast/nasal_new_vm.cpp
new file mode 100644
index 0000000..639712a
--- /dev/null
+++ b/ast/nasal_new_vm.cpp
@@ -0,0 +1,1129 @@
+#include "nasal_new_vm.h"
+
+void vm::init(
+    const std::vector<std::string>& strs,
+    const std::vector<f64>&    nums,
+    const std::vector<opcode>& code,
+    const std::vector<std::string>& filenames,
+    const std::vector<std::string>& argv
+) {
+    cnum=nums.data();
+    cstr=strs.data();
+    bytecode=code.data();
+    files=filenames.data();
+
+    /* set canary and program counter */
+    ctx.pc=0;
+    ctx.localr=ctx.memr=nullptr;
+    ctx.funcr=ctx.upvalr=nil;
+    ctx.canary=stack+STACK_DEPTH-1; // stack[STACK_DEPTH-1]
+    ctx.top=stack;
+    ctx.stack=stack;
+
+    /* clear main stack */
+    for(u32 i=0;i<STACK_DEPTH;++i) {
+        stack[i]=nil;
+    }
+
+    /* init gc */
+    ngc.init(strs,argv);
+}
+
+void vm::valinfo(var& val) {
+    const nas_val* p=val.val.gcobj;
+    switch(val.type) {
+        case vm_none: std::clog<<"| null |";break;
+        case vm_ret:  std::clog<<"| pc   | 0x"<<std::hex
+                               <<val.ret()<<std::dec;break;
+        case vm_addr: std::clog<<"| addr | 0x"<<std::hex
+                               <<(u64)val.addr()<<std::dec;break;
+        case vm_cnt:  std::clog<<"| cnt  | "<<val.cnt();break;
+        case vm_nil:  std::clog<<"| nil  |";break;
+        case vm_num:  std::clog<<"| num  | "<<val.num();break;
+        case vm_str:  std::clog<<"| str  | <0x"<<std::hex<<(u64)p
+                               <<"> "<<rawstr(val.str(),16)<<std::dec;break;
+        case vm_func: std::clog<<"| func | <0x"<<std::hex<<(u64)p
+                               <<"> entry:0x"<<val.func().entry
+                               <<std::dec;break;
+        case vm_upval:std::clog<<"| upval| <0x"<<std::hex<<(u64)p
+                               <<std::dec<<"> ["<<val.upval().size
+                               <<" val]";break;
+        case vm_vec:  std::clog<<"| vec  | <0x"<<std::hex<<(u64)p
+                               <<std::dec<<"> ["<<val.vec().size()
+                               <<" val]";break;
+        case vm_hash: std::clog<<"| hash | <0x"<<std::hex<<(u64)p
+                               <<std::dec<<"> {"<<val.hash().size()
+                               <<" val}";break;
+        case vm_obj:  std::clog<<"| obj  | <0x"<<std::hex<<(u64)p
+                               <<"> obj:0x"<<(u64)val.obj().ptr
+                               <<std::dec;break;
+        case vm_co:   std::clog<<"| co   | <0x"<<std::hex<<(u64)p
+                               <<std::dec<<"> coroutine";break;
+        default:      std::clog<<"| err  | <0x"<<std::hex<<(u64)p
+                               <<std::dec<<"> unknown object";break;
+    }
+    std::clog<<"\n";
+}
+
+void vm::traceback() {
+    /* bytecode[0].num is the global size */
+    var* bottom=ngc.rctx->stack==stack?stack+bytecode[0].num:ngc.rctx->stack;
+    var* ctx_top=ngc.rctx->stack==stack?ctx.top:ngc.rctx->top;
+    std::stack<u32> ret;
+    for(var* i=bottom;i<=ctx_top;++i) {
+        if (i->type==vm_ret && i->ret()!=0) {
+            ret.push(i->ret());
+        }
+    }
+    ret.push(ctx.pc); // store the position program crashed
+    std::clog<<"trace back ("<<(ngc.rctx->stack==stack?"main":"coroutine")<<")\n";
+    codestream::set(cnum, cstr, files);
+    for(u32 p=0,same=0,prev=0xffffffff;!ret.empty();prev=p,ret.pop()) {
+        if ((p=ret.top())==prev) {
+            ++same;
+            continue;
+        }
+        if (same) {
+            std::clog
+            <<"  0x"<<std::hex<<std::setw(6)<<std::setfill('0')
+            <<prev<<std::dec<<"     "<<same<<" same call(s)\n";
+        }
+        same=0;
+        std::clog<<"  "<<codestream(bytecode[p],p)<<"\n";
+    }
+    // the first called place has no same calls
+}
+
+void vm::stackinfo(const u32 limit=10) {
+    /* bytecode[0].num is the global size */
+    const u32 gsize=ngc.rctx->stack==stack?bytecode[0].num:0;
+    var* t=ctx.top;
+    var* bottom=ngc.rctx->stack+gsize;
+    std::clog<<"stack (0x"<<std::hex<<(u64)bottom<<std::dec
+             <<" <+"<<gsize<<">, limit "<<limit<<", total "
+             <<(t<bottom? 0:(i64)(t-bottom+1))<<")\n";
+    for(u32 i=0;i<limit && t>=bottom;++i,--t) {
+        std::clog<<"  0x"<<std::hex
+                 <<std::setw(6)<<std::setfill('0')
+                 <<(u64)(t-ngc.rctx->stack)<<std::dec
+                 <<"    ";
+        valinfo(t[0]);
+    }
+}
+
+void vm::reginfo() {
+    std::clog<<"registers ("<<(ngc.cort?"coroutine":"main")<<")\n"<<std::hex
+             <<"  [pc    ]    | pc   | 0x"<<ctx.pc<<"\n"
+             <<"  [global]    | addr | 0x"<<(u64)stack<<"\n"
+             <<"  [local ]    | addr | 0x"<<(u64)ctx.localr<<"\n"
+             <<"  [memr  ]    | addr | 0x"<<(u64)ctx.memr<<"\n"
+             <<"  [canary]    | addr | 0x"<<(u64)ctx.canary<<"\n"
+             <<"  [top   ]    | addr | 0x"<<(u64)ctx.top<<"\n"
+             <<std::dec;
+    std::clog<<"  [funcr ]    ";valinfo(ctx.funcr);
+    std::clog<<"  [upval ]    ";valinfo(ctx.upvalr);
+}
+
+void vm::gstate() {
+    if (!bytecode[0].num || stack[0].type==vm_none) { // bytecode[0].op is op_intg
+        return;
+    }
+    std::clog<<"global (0x"<<std::hex<<(u64)stack<<" <+0>)\n"<<std::dec;
+    for(u32 i=0;i<bytecode[0].num;++i) {
+        std::clog<<"  0x"<<std::hex<<std::setw(6)
+                 <<std::setfill('0')<<i<<std::dec
+                 <<"    ";
+        valinfo(stack[i]);
+    }
+}
+
+void vm::lstate() {
+    if (!ctx.localr || !ctx.funcr.func().lsize) {
+        return;
+    }
+    const u32 lsize=ctx.funcr.func().lsize;
+    std::clog<<"local (0x"<<std::hex<<(u64)ctx.localr
+             <<" <+"<<(u64)(ctx.localr-ngc.rctx->stack)<<">)\n"<<std::dec;
+    for(u32 i=0;i<lsize;++i) {
+        std::clog<<"  0x"<<std::hex<<std::setw(6)
+                 <<std::setfill('0')<<i<<std::dec
+                 <<"    ";
+        valinfo(ctx.localr[i]);
+    }
+}
+
+void vm::ustate() {
+    if (ctx.funcr.type==vm_nil || ctx.funcr.func().upval.empty()) {
+        return;
+    }
+    std::clog<<"upvalue\n";
+    auto& upval=ctx.funcr.func().upval;
+    for(u32 i=0;i<upval.size();++i) {
+        std::clog<<"  -> upval["<<i<<"]:\n";
+        auto& uv=upval[i].upval();
+        for(u32 j=0;j<uv.size;++j) {
+            std::clog<<"     0x"<<std::hex<<std::setw(6)
+                     <<std::setfill('0')<<j<<std::dec
+                     <<" ";
+            valinfo(uv[j]);
+        }
+    }
+}
+
+void vm::detail() {
+    reginfo();
+    gstate();
+    lstate();
+    ustate();
+}
+
+void vm::die(const std::string& str) {
+    std::cerr<<"[vm] error: "<<str<<"\n";
+    traceback();
+    stackinfo();
+
+    // show verbose crash info
+    if (verbose) {
+        detail();
+    }
+
+    if (ngc.rctx->stack==stack) { // in main context, exit directly
+        std::exit(1);
+    } else { // in coroutine, shut down the coroutine and return to main context
+        ctx.pc=0; // mark coroutine 'dead'
+        ngc.ctxreserve();
+        ctx.top[0]=nil;
+    }
+}
+
+inline bool vm::cond(var& val) {
+    if (val.type==vm_num) {
+        return val.num();
+    } else if (val.type==vm_str) {
+        const f64 num=str2num(val.str().c_str());
+        return std::isnan(num)? !val.str().empty():num;
+    }
+    return false;
+}
+
+void vm::o_intg() {
+    // global values store on stack
+    ctx.top+=imm[ctx.pc];
+    --ctx.top;// point to the top
+}
+
+void vm::o_intl() {
+    ctx.top[0].func().local.resize(imm[ctx.pc], nil);
+    ctx.top[0].func().lsize=imm[ctx.pc];
+}
+
+void vm::o_loadg() {
+    stack[imm[ctx.pc]]=(ctx.top--)[0];
+}
+
+void vm::o_loadl() {
+    ctx.localr[imm[ctx.pc]]=(ctx.top--)[0];
+}
+
+void vm::o_loadu() {
+    ctx.funcr.func().upval[(imm[ctx.pc]>>16)&0xffff]
+         .upval()[imm[ctx.pc]&0xffff]=(ctx.top--)[0];
+}
+
+void vm::o_pnum() {
+    (++ctx.top)[0]=var::num(cnum[imm[ctx.pc]]);
+}
+
+void vm::o_pnil() {
+    (++ctx.top)[0]=nil;
+}
+
+void vm::o_pstr() {
+    (++ctx.top)[0]=ngc.strs[imm[ctx.pc]];
+}
+
+void vm::o_newv() {
+    var newv=ngc.alloc(vm_vec);
+    auto& vec=newv.vec().elems;
+    vec.resize(imm[ctx.pc]);
+    // use top-=imm[pc]-1 here will cause error if imm[pc] is 0
+    ctx.top=ctx.top-imm[ctx.pc]+1;
+    for(u32 i=0;i<imm[ctx.pc];++i) {
+        vec[i]=ctx.top[i];
+    }
+    ctx.top[0]=newv;
+}
+
+void vm::o_newh() {
+    (++ctx.top)[0]=ngc.alloc(vm_hash);
+}
+
+void vm::o_newf() {
+    (++ctx.top)[0]=ngc.alloc(vm_func);
+    nas_func& func=ctx.top[0].func();
+    func.entry=imm[ctx.pc];
+    func.psize=1;
+
+    /* this means you create a new function in local scope */
+    if (ctx.localr) {
+        func.upval=ctx.funcr.func().upval;
+        // function created in the same local scope shares one closure
+        // so this size & stk setting has no problem
+        var upval=(ctx.upvalr.type==vm_nil)?ngc.alloc(vm_upval):ctx.upvalr;
+        upval.upval().size=ctx.funcr.func().lsize;
+        upval.upval().stk=ctx.localr;
+        func.upval.push_back(upval);
+        ctx.upvalr=upval;
+    }
+}
+
+void vm::o_happ() {
+    ctx.top[-1].hash().elems[cstr[imm[ctx.pc]]]=ctx.top[0];
+    --ctx.top;
+}
+
+void vm::o_para() {
+    nas_func& func=ctx.top[0].func();
+    // func->size has 1 place reserved for "me"
+    func.keys[imm[ctx.pc]]=func.psize;
+    func.local[func.psize++]=var::none();
+}
+
+void vm::o_deft() {
+    var val=ctx.top[0];
+    nas_func& func=(--ctx.top)[0].func();
+    // func->size has 1 place reserved for "me"
+    func.keys[imm[ctx.pc]]=func.psize;
+    func.local[func.psize++]=val;
+}
+
+void vm::o_dyn() {
+    ctx.top[0].func().dpara=imm[ctx.pc];
+}
+
+void vm::o_lnot() {
+    var val=ctx.top[0];
+    switch(val.type) {
+        case vm_nil:ctx.top[0]=one;break;
+        case vm_num:ctx.top[0]=val.num()?zero:one;break;
+        case vm_str:{
+            const f64 num=str2num(val.str().c_str());
+            if (std::isnan(num)) {
+                ctx.top[0]=var::num((f64)val.str().empty());
+            } else {
+                ctx.top[0]=num?zero:one;
+            }
+        } break;
+        default:{
+            die("incorrect value type");
+            return;
+        } break;
+    }
+}
+
+void vm::o_usub() {
+    ctx.top[0]=var::num(-ctx.top[0].tonum());
+}
+
+void vm::o_bnot() {
+    ctx.top[0]=var::num(~static_cast<int32_t>(ctx.top[0].num()));
+}
+
+void vm::o_btor() {
+    ctx.top[-1]=var::num(static_cast<int32_t>(ctx.top[-1].tonum())|static_cast<int32_t>(ctx.top[0].tonum()));
+    --ctx.top;
+}
+
+void vm::o_btxor() {
+    ctx.top[-1]=var::num(static_cast<int32_t>(ctx.top[-1].tonum())^static_cast<int32_t>(ctx.top[0].tonum()));
+    --ctx.top;
+}
+
+void vm::o_btand() {
+    ctx.top[-1]=var::num(static_cast<int32_t>(ctx.top[-1].tonum())&static_cast<int32_t>(ctx.top[0].tonum()));
+    --ctx.top;
+}
+
+#define op_calc(type)\
+    ctx.top[-1]=var::num(ctx.top[-1].tonum() type ctx.top[0].tonum());\
+    --ctx.top;
+
+void vm::o_add() {op_calc(+);}
+void vm::o_sub() {op_calc(-);}
+void vm::o_mul() {op_calc(*);}
+void vm::o_div() {op_calc(/);}
+void vm::o_lnk() {
+    ctx.top[-1]=ngc.newstr(ctx.top[-1].tostr()+ctx.top[0].tostr());
+    --ctx.top;
+}
+
+#define op_calc_const(type)\
+    ctx.top[0]=var::num(ctx.top[0].tonum() type cnum[imm[ctx.pc]]);
+
+void vm::o_addc() {op_calc_const(+);}
+void vm::o_subc() {op_calc_const(-);}
+void vm::o_mulc() {op_calc_const(*);}
+void vm::o_divc() {op_calc_const(/);}
+void vm::o_lnkc() {
+    ctx.top[0]=ngc.newstr(ctx.top[0].tostr()+cstr[imm[ctx.pc]]);
+}
+
+// top[0] stores the value of memr[0], to avoid being garbage-collected
+// so when the calculation ends, top-=1, then top-=imm[pc]
+// because this return value is meaningless if on stack when imm[pc]=1
+// like this: func{a+=c;}(); the result of 'a+c' will no be used later, imm[pc]=1
+// but if b+=a+=c; the result of 'a+c' will be used later, imm[pc]=0
+#define op_calc_eq(type)\
+    ctx.top[-1]=ctx.memr[0]=var::num(ctx.memr[0].tonum() type ctx.top[-1].tonum());\
+    ctx.memr=nullptr;\
+    ctx.top-=imm[ctx.pc]+1;
+
+void vm::o_addeq() {op_calc_eq(+);}
+void vm::o_subeq() {op_calc_eq(-);}
+void vm::o_muleq() {op_calc_eq(*);}
+void vm::o_diveq() {op_calc_eq(/);}
+void vm::o_lnkeq() {
+    ctx.top[-1]=ctx.memr[0]=ngc.newstr(ctx.memr[0].tostr()+ctx.top[-1].tostr());
+    ctx.memr=nullptr;
+    ctx.top-=imm[ctx.pc]+1;
+}
+
+void vm::o_bandeq() {
+    ctx.top[-1]=ctx.memr[0]=var::num(i32(ctx.memr[0].tonum())&i32(ctx.top[-1].tonum()));
+    ctx.memr=nullptr;
+    ctx.top-=imm[ctx.pc]+1;
+}
+
+void vm::o_boreq() {
+    ctx.top[-1]=ctx.memr[0]=var::num(i32(ctx.memr[0].tonum())|i32(ctx.top[-1].tonum()));
+    ctx.memr=nullptr;
+    ctx.top-=imm[ctx.pc]+1;
+}
+
+void vm::o_bxoreq() {
+    ctx.top[-1]=ctx.memr[0]=var::num(i32(ctx.memr[0].tonum())^i32(ctx.top[-1].tonum()));
+    ctx.memr=nullptr;
+    ctx.top-=imm[ctx.pc]+1;
+}
+
+// top[0] stores the value of memr[0], to avoid being garbage-collected
+// so when the calculation ends, top-=imm[pc]>>31
+// because this return value is meaningless if on stack when imm[pc]>>31=1
+// like this: func{a+=1;}(); the result of 'a+1' will no be used later, imm[pc]>>31=1
+// but if b+=a+=1; the result of 'a+1' will be used later, imm[pc]>>31=0
+#define op_calc_eq_const(type)\
+    ctx.top[0]=ctx.memr[0]=var::num(ctx.memr[0].tonum() type cnum[imm[ctx.pc]]);\
+    ctx.memr=nullptr;
+
+void vm::o_addeqc() {op_calc_eq_const(+);}
+void vm::o_subeqc() {op_calc_eq_const(-);}
+void vm::o_muleqc() {op_calc_eq_const(*);}
+void vm::o_diveqc() {op_calc_eq_const(/);}
+void vm::o_lnkeqc() {
+    ctx.top[0]=ctx.memr[0]=ngc.newstr(ctx.memr[0].tostr()+cstr[imm[ctx.pc]]);
+    ctx.memr=nullptr;
+}
+
+#define op_calc_eq_const_and_pop(type)\
+    ctx.top[0]=ctx.memr[0]=var::num(ctx.memr[0].tonum() type cnum[imm[ctx.pc]]);\
+    ctx.memr=nullptr;\
+    --ctx.top;
+
+void vm::o_addecp() {op_calc_eq_const_and_pop(+);}
+void vm::o_subecp() {op_calc_eq_const_and_pop(-);}
+void vm::o_mulecp() {op_calc_eq_const_and_pop(*);}
+void vm::o_divecp() {op_calc_eq_const_and_pop(/);}
+void vm::o_lnkecp() {
+    ctx.top[0]=ctx.memr[0]=ngc.newstr(ctx.memr[0].tostr()+cstr[imm[ctx.pc]]);
+    ctx.memr=nullptr;
+    --ctx.top;
+}
+
+void vm::o_meq() {
+    // pop old memr[0] and replace it
+    // the reason why we should get memr and push the old value on stack
+    // is that when lnkeq/lnkeqc is called, there will be
+    // a new gc object vm_str which is returned by gc::alloc
+    // this may cause gc, so we should temporarily put it on stack
+    ctx.memr[0]=ctx.top[-1];
+    ctx.memr=nullptr;
+    ctx.top-=imm[ctx.pc]+1;
+}
+
+void vm::o_eq() {
+    var val2=ctx.top[0];
+    var val1=(--ctx.top)[0];
+    if (val1.type==vm_nil && val2.type==vm_nil) {
+        ctx.top[0]=one;
+    } else if (val1.type==vm_str && val2.type==vm_str) {
+        ctx.top[0]=(val1.str()==val2.str())?one:zero;
+    } else if ((val1.type==vm_num || val2.type==vm_num)
+        && val1.type!=vm_nil && val2.type!=vm_nil) {
+        ctx.top[0]=(val1.tonum()==val2.tonum())?one:zero;
+    } else {
+        ctx.top[0]=(val1==val2)?one:zero;
+    }
+}
+
+void vm::o_neq() {
+    var val2=ctx.top[0];
+    var val1=(--ctx.top)[0];
+    if (val1.type==vm_nil && val2.type==vm_nil) {
+        ctx.top[0]=zero;
+    } else if (val1.type==vm_str && val2.type==vm_str) {
+        ctx.top[0]=(val1.str()!=val2.str())?one:zero;
+    } else if ((val1.type==vm_num || val2.type==vm_num)
+        && val1.type!=vm_nil && val2.type!=vm_nil) {
+        ctx.top[0]=(val1.tonum()!=val2.tonum())?one:zero;
+    } else {
+        ctx.top[0]=(val1!=val2)?one:zero;
+    }
+}
+
+#define op_cmp(type)\
+    --ctx.top;\
+    ctx.top[0]=(ctx.top[0].tonum() type ctx.top[1].tonum())?one:zero;
+
+void vm::o_less() {op_cmp(<);}
+void vm::o_leq() {op_cmp(<=);}
+void vm::o_grt() {op_cmp(>);}
+void vm::o_geq() {op_cmp(>=);}
+
+#define op_cmp_const(type)\
+    ctx.top[0]=(ctx.top[0].tonum() type cnum[imm[ctx.pc]])?one:zero;
+
+void vm::o_lessc() {op_cmp_const(<);}
+void vm::o_leqc() {op_cmp_const(<=);}
+void vm::o_grtc() {op_cmp_const(>);}
+void vm::o_geqc() {op_cmp_const(>=);}
+
+void vm::o_pop() {
+    --ctx.top;
+}
+
+void vm::o_jmp() {
+    ctx.pc=imm[ctx.pc]-1;
+}
+
+void vm::o_jt() {
+    // jump true needs to reserve the result on stack
+    // because conditional expression in nasal has return value
+    if (cond(ctx.top[0])) {
+        ctx.pc=imm[ctx.pc]-1;
+    }
+}
+
+void vm::o_jf() {
+    // jump false doesn't need to reserve result
+    if (!cond(ctx.top[0])) {
+        ctx.pc=imm[ctx.pc]-1;
+    }
+    --ctx.top;
+}
+
+void vm::o_cnt() {
+    if (ctx.top[0].type!=vm_vec) {
+        die("must use vector in forindex/foreach");
+        return;
+    }
+    (++ctx.top)[0]=var::cnt(-1);
+}
+
+void vm::o_findex() {
+    if ((usize)(++ctx.top[0].cnt())>=ctx.top[-1].vec().size()) {
+        ctx.pc=imm[ctx.pc]-1;
+        return;
+    }
+    ctx.top[1]=var::num(ctx.top[0].cnt());
+    ++ctx.top;
+}
+
+void vm::o_feach() {
+    auto& ref=ctx.top[-1].vec().elems;
+    if ((usize)(++ctx.top[0].cnt())>=ref.size()) {
+        ctx.pc=imm[ctx.pc]-1;
+        return;
+    }
+    ctx.top[1]=ref[ctx.top[0].cnt()];
+    ++ctx.top;
+}
+
+void vm::o_callg() {
+    // get main stack directly
+    (++ctx.top)[0]=stack[imm[ctx.pc]];
+}
+
+void vm::o_calll() {
+    (++ctx.top)[0]=ctx.localr[imm[ctx.pc]];
+}
+
+void vm::o_upval() {
+    (++ctx.top)[0]=ctx.funcr.func()
+        .upval[(imm[ctx.pc]>>16)&0xffff]
+        .upval()[imm[ctx.pc]&0xffff];
+}
+
+void vm::o_callv() {
+    var val=ctx.top[0];
+    var vec=(--ctx.top)[0];
+    if (vec.type==vm_vec) {
+        ctx.top[0]=vec.vec().get_val(val.tonum());
+        if (ctx.top[0].type==vm_none) {
+            die("out of range:"+std::to_string(val.tonum()));
+            return;
+        }
+    } else if (vec.type==vm_hash) {
+        if (val.type!=vm_str) {
+            die("must use string as the key");
+            return;
+        }
+        ctx.top[0]=vec.hash().get_val(val.str());
+        if (ctx.top[0].type==vm_none) {
+            die("cannot find member \""+val.str()+"\"");
+            return;
+        } else if (ctx.top[0].type==vm_func) {
+            ctx.top[0].func().local[0]=val; // 'me'
+        }
+    } else if (vec.type==vm_str) {
+        auto& str = vec.str();
+        i32 num = val.tonum();
+        i32 len = str.length();
+        if (num<-len || num>=len) {
+            die("out of range:"+std::to_string(val.tonum()));
+            return;
+        }
+        ctx.top[0]=var::num(f64((u8)str[num>=0? num:num+len]));
+    } else {
+        die("must call a vector/hash/string");
+        return;
+    }
+}
+
+void vm::o_callvi() {
+    var val=ctx.top[0];
+    if (val.type!=vm_vec) {
+        die("must use a vector");
+        return;
+    }
+    // cannot use operator[],because this may cause overflow
+    (++ctx.top)[0]=val.vec().get_val(imm[ctx.pc]);
+    if (ctx.top[0].type==vm_none) {
+        die("out of range:"+std::to_string(imm[ctx.pc]));
+        return;
+    }
+}
+
+void vm::o_callh() {
+    var val=ctx.top[0];
+    if (val.type!=vm_hash) {
+        die("must call a hash");
+        return;
+    }
+    ctx.top[0]=val.hash().get_val(cstr[imm[ctx.pc]]);
+    if (ctx.top[0].type==vm_none) {
+        die("member \""+cstr[imm[ctx.pc]]+"\" does not exist");
+        return;
+    } else if (ctx.top[0].type==vm_func) {
+        ctx.top[0].func().local[0]=val; // 'me'
+    }
+}
+
+void vm::o_callfv() {
+    u32 argc=imm[ctx.pc]; // arguments counter
+    var* local=ctx.top-argc+1; // arguments begin address
+    if (local[-1].type!=vm_func) {
+        die("must call a function");
+        return;
+    }
+    auto& func=local[-1].func();
+    var tmp=local[-1];
+    local[-1]=ctx.funcr;
+    ctx.funcr=tmp;
+    // top-argc+lsize(local) +1(old pc) +1(old localr) +1(old upvalr)
+    if (ctx.top-argc+func.lsize+3>=ctx.canary) {
+        die("stack overflow");
+        return;
+    }
+    // parameter size is func->psize-1, 1 is reserved for "me"
+    u32 psize=func.psize-1;
+    if (argc<psize && func.local[argc+1].type==vm_none) {
+        die("lack argument(s)");
+        return;
+    }
+
+    var dynamic=nil;
+    if (func.dpara>=0) { // load dynamic arguments
+        dynamic=ngc.alloc(vm_vec);
+        for(u32 i=psize;i<argc;++i) {
+            dynamic.vec().elems.push_back(local[i]);
+        }
+    }
+    // should reset stack top after allocating vector
+    // because this may cause gc
+    // then all the available values the vector needs
+    // are all outside the stack top and may be
+    // collected incorrectly
+    ctx.top=local+func.lsize;
+
+    u32 min_size=(std::min)(psize, argc); // avoid error in MSVC
+    for(u32 i=min_size;i>=1;--i) { // load arguments
+        local[i]=local[i-1];
+    }
+    local[0]=func.local[0];// load "me"
+    // load local scope & default arguments
+    for(u32 i=min_size+1;i<func.lsize;++i) {
+        local[i]=func.local[i];
+    }
+    if (func.dpara>=0) {
+        local[psize+1]=dynamic;
+    }
+
+    ctx.top[0]=ctx.upvalr;
+    (++ctx.top)[0]=var::addr(ctx.localr);
+    (++ctx.top)[0]=var::ret(ctx.pc);
+    ctx.pc=func.entry-1;
+    ctx.localr=local;
+    ctx.upvalr=nil;
+}
+
+void vm::o_callfh() {
+    auto& hash=ctx.top[0].hash().elems;
+    if (ctx.top[-1].type!=vm_func) {
+        die("must call a function");
+        return;
+    }
+    auto& func=ctx.top[-1].func();
+    var tmp=ctx.top[-1];
+    ctx.top[-1]=ctx.funcr;
+    ctx.funcr=tmp;
+
+    // top -1(hash) +lsize(local) +1(old pc) +1(old localr) +1(old upvalr)
+    if (ctx.top+func.lsize+2>=ctx.canary) {
+        die("stack overflow");
+        return;
+    }
+    if (func.dpara>=0) {
+        die("special call cannot use dynamic argument");
+        return;
+    }
+
+    var* local=ctx.top;
+    ctx.top+=func.lsize;
+    for(u32 i=0;i<func.lsize;++i) {
+        local[i]=func.local[i];
+    }
+    
+    for(auto& i:func.keys) {
+        auto& key=cstr[i.first];
+        if (hash.count(key)) {
+            local[i.second]=hash[key];
+        } else if (local[i.second].type==vm_none) {
+            die("lack argument(s): \""+key+"\"");
+            return;
+        }
+    }
+
+    ctx.top[0]=ctx.upvalr;
+    (++ctx.top)[0]=var::addr(ctx.localr);
+    (++ctx.top)[0]=var::ret(ctx.pc); // rewrite top with vm_ret
+    ctx.pc=func.entry-1;
+    ctx.localr=local;
+    ctx.upvalr=nil;
+}
+
+void vm::o_callb() {
+    // reserve place for builtin function return,
+    // this code is written for coroutine
+    (++ctx.top)[0]=nil;
+
+    // if running a builtin function about coroutine
+    // (top) will be set to another context.top, instead of main_context.top
+    var tmp=(*builtin[imm[ctx.pc]].func)(ctx.localr, ngc);
+
+    // so we use tmp variable to store this return value
+    // and set it to top[0] later
+    ctx.top[0]=tmp;
+
+    // if get none, this means errors occurred when calling this native function
+    if (ctx.top[0].type==vm_none) {
+        die("native function error");
+        return;
+    }
+}
+
+void vm::o_slcbeg() {
+    // +--------------+
+    // | slice_vector | <-- top[0]
+    // +--------------+
+    // | resource_vec | <-- top[-1]
+    // +--------------+
+    (++ctx.top)[0]=ngc.alloc(vm_vec);
+    if (ctx.top[-1].type!=vm_vec) {
+        die("must slice a vector");
+        return;
+    }
+}
+
+void vm::o_slcend() {
+    ctx.top[-1]=ctx.top[0];
+    --ctx.top;
+}
+
+void vm::o_slc() {
+    var val=(ctx.top--)[0];
+    var res=ctx.top[-1].vec().get_val(val.tonum());
+    if (res.type==vm_none) {
+        die("index "+std::to_string(val.tonum())+" out of range");
+        return;
+    }
+    ctx.top[0].vec().elems.push_back(res);
+}
+
+void vm::o_slc2() {
+    var val2=(ctx.top--)[0];
+    var val1=(ctx.top--)[0];
+    auto& ref=ctx.top[-1].vec().elems;
+    auto& aim=ctx.top[0].vec().elems;
+
+    u8 type1=val1.type,type2=val2.type;
+    i32 num1=val1.tonum();
+    i32 num2=val2.tonum();
+    i32 size=ref.size();
+    if (type1==vm_nil && type2==vm_nil) {
+        num1=0;
+        num2=size-1;
+    } else if (type1==vm_nil && type2!=vm_nil) {
+        num1=num2<0? -size:0;
+    } else if (type1!=vm_nil && type2==vm_nil) {
+        num2=num1<0? -1:size-1;
+    }
+
+    if (num1<-size || num1>=size || num2<-size || num2>=size) {
+        die("index "+std::to_string(num1)+":"+std::to_string(num2)+" out of range");
+        return;
+    } else if (num1<=num2) {
+        for(i32 i=num1;i<=num2;++i) {
+            aim.push_back(i>=0?ref[i]:ref[i+size]);
+        }
+    }
+}
+
+void vm::o_mcallg() {
+    ctx.memr=stack+imm[ctx.pc];
+    (++ctx.top)[0]=ctx.memr[0];
+    // push value in this memory space on stack
+    // to avoid being garbage collected
+}
+
+void vm::o_mcalll() {
+    ctx.memr=ctx.localr+imm[ctx.pc];
+    (++ctx.top)[0]=ctx.memr[0];
+    // push value in this memory space on stack
+    // to avoid being garbage collected
+}
+
+void vm::o_mupval() {
+    ctx.memr=&(ctx.funcr.func().upval[(imm[ctx.pc]>>16)&0xffff].upval()[imm[ctx.pc]&0xffff]);
+    (++ctx.top)[0]=ctx.memr[0];
+    // push value in this memory space on stack
+    // to avoid being garbage collected
+}
+
+void vm::o_mcallv() {
+    var val=ctx.top[0];     // index
+    var vec=(--ctx.top)[0]; // mcall vector, reserved on stack to avoid gc
+    if (vec.type==vm_vec) {
+        ctx.memr=vec.vec().get_mem(val.tonum());
+        if (!ctx.memr) {
+            die("index "+std::to_string(val.tonum())+" out of range");
+            return;
+        }
+    } else if (vec.type==vm_hash) { // do mcallh but use the mcallv way
+        if (val.type!=vm_str) {
+            die("key must be string");
+            return;
+        }
+        auto& ref = vec.hash();
+        auto& str = val.str();
+        ctx.memr = ref.get_mem(str);
+        if (!ctx.memr) {
+            ref.elems[str]=nil;
+            ctx.memr=ref.get_mem(str);
+        }
+    } else {
+        die("cannot get memory space in this type");
+        return;
+    }
+}
+
+void vm::o_mcallh() {
+    var hash=ctx.top[0]; // mcall hash, reserved on stack to avoid gc
+    if (hash.type!=vm_hash) {
+        die("must call a hash");
+        return;
+    }
+    auto& ref=hash.hash();
+    auto& str=cstr[imm[ctx.pc]];
+    ctx.memr=ref.get_mem(str);
+    if (!ctx.memr) { // create a new key
+        ref.elems[str]=nil;
+        ctx.memr=ref.get_mem(str);
+    }
+}
+
+void vm::o_ret() {
+/*  +-------------+
+*   | return value| <- top[0]
+*   +-------------+
+*   | old pc      | <- top[-1]
+*   +-------------+
+*   | old localr  | <- top[-2]
+*   +-------------+
+*   | old upvalr  | <- top[-3]
+*   +-------------+
+*   | local scope |
+*   +-------------+ <- local pointer stored in localr
+*   | old funcr   | <- old function stored in funcr
+*   +-------------+
+*/
+    var  ret  =ctx.top[0];
+    var* local=ctx.localr;
+    var  func =ctx.funcr;
+    var  up   =ctx.upvalr;
+
+    ctx.pc    =ctx.top[-1].ret();
+    ctx.localr=ctx.top[-2].addr();
+    ctx.upvalr=ctx.top[-3];
+
+    ctx.top=local-1;
+    ctx.funcr=ctx.top[0];
+    ctx.top[0]=ret; // rewrite func with returned value
+
+    if (up.type==vm_upval) { // synchronize upvalue
+        auto& upval=up.upval();
+        auto size=func.func().lsize;
+        upval.onstk=false;
+        upval.elems.resize(size);
+        for(u32 i=0;i<size;++i) {
+            upval.elems[i]=local[i];
+        }
+    }
+
+    // cannot use gc.cort to judge,
+    // because there maybe another function call inside but return here
+    // coroutine function ends with setting pc to 0
+    if (!ctx.pc) {
+        ngc.ctxreserve();
+    }
+}
+
+void vm::run(
+    const codegen& gen,
+    const linker& linker,
+    const std::vector<std::string>& argv,
+    const bool detail
+) {
+    verbose=detail;
+    init(gen.strs(), gen.nums(), gen.codes(), linker.filelist(), argv);
+#ifndef _MSC_VER
+    const void* oprs[]={
+        &&vmexit, &&intg,   &&intl,   &&loadg,
+        &&loadl,  &&loadu,  &&pnum,   &&pnil,
+        &&pstr,   &&newv,   &&newh,   &&newf,
+        &&happ,   &&para,   &&deft,   &&dyn,
+        &&lnot,   &&usub,   &&bnot,   &&btor,
+        &&btxor,  &&btand,  &&add,    &&sub,
+        &&mul,    &&div,    &&lnk,    &&addc,
+        &&subc,   &&mulc,   &&divc,   &&lnkc,
+        &&addeq,  &&subeq,  &&muleq,  &&diveq,
+        &&lnkeq,  &&bandeq, &&boreq,  &&bxoreq,
+        &&addeqc, &&subeqc, &&muleqc, &&diveqc,
+        &&lnkeqc, &&addecp, &&subecp, &&mulecp,
+        &&divecp, &&lnkecp, &&meq,    &&eq,
+        &&neq,    &&less,   &&leq,    &&grt,
+        &&geq,    &&lessc,  &&leqc,   &&grtc,
+        &&geqc,   &&pop,    &&jmp,    &&jt,
+        &&jf,     &&cnt,    &&findex, &&feach,
+        &&callg,  &&calll,  &&upval,  &&callv,
+        &&callvi, &&callh,  &&callfv, &&callfh,
+        &&callb,  &&slcbeg, &&slcend, &&slc,
+        &&slc2,   &&mcallg, &&mcalll, &&mupval,
+        &&mcallv, &&mcallh, &&ret
+    };
+    std::vector<const void*> code;
+    for(auto& i:gen.codes()) {
+        code.push_back(oprs[i.op]);
+        imm.push_back(i.num);
+    }
+    // goto the first operand
+    goto *code[ctx.pc];
+#else
+    typedef void (vm::*nafunc)();
+    const nafunc oprs[]={
+        nullptr,       &vm::o_intg,
+        &vm::o_intl,   &vm::o_loadg,
+        &vm::o_loadl,  &vm::o_loadu,
+        &vm::o_pnum,   &vm::o_pnil,
+        &vm::o_pstr,   &vm::o_newv,
+        &vm::o_newh,   &vm::o_newf,
+        &vm::o_happ,   &vm::o_para,
+        &vm::o_deft,   &vm::o_dyn,
+        &vm::o_lnot,   &vm::o_usub,
+        &vm::o_bnot,   &vm::o_btor,
+        &vm::o_btxor,  &vm::o_btand,
+        &vm::o_add,    &vm::o_sub,
+        &vm::o_mul,    &vm::o_div,
+        &vm::o_lnk,    &vm::o_addc,
+        &vm::o_subc,   &vm::o_mulc,
+        &vm::o_divc,   &vm::o_lnkc,
+        &vm::o_addeq,  &vm::o_subeq,
+        &vm::o_muleq,  &vm::o_diveq,
+        &vm::o_lnkeq,  &vm::o_bandeq,
+        &vm::o_boreq,  &vm::o_bxoreq,
+        &vm::o_addeqc, &vm::o_subeqc,
+        &vm::o_muleqc, &vm::o_diveqc,
+        &vm::o_lnkeqc, &vm::o_addecp,
+        &vm::o_subecp, &vm::o_mulecp,
+        &vm::o_divecp, &vm::o_lnkecp,
+        &vm::o_meq,    &vm::o_eq,
+        &vm::o_neq,    &vm::o_less,
+        &vm::o_leq,    &vm::o_grt,
+        &vm::o_geq,    &vm::o_lessc,
+        &vm::o_leqc,   &vm::o_grtc,
+        &vm::o_geqc,   &vm::o_pop,
+        &vm::o_jmp,    &vm::o_jt,
+        &vm::o_jf,     &vm::o_cnt,
+        &vm::o_findex, &vm::o_feach,
+        &vm::o_callg,  &vm::o_calll,
+        &vm::o_upval,  &vm::o_callv,
+        &vm::o_callvi, &vm::o_callh,
+        &vm::o_callfv, &vm::o_callfh,
+        &vm::o_callb,  &vm::o_slcbeg,
+        &vm::o_slcend, &vm::o_slc,
+        &vm::o_slc2,   &vm::o_mcallg,
+        &vm::o_mcalll, &vm::o_mupval,
+        &vm::o_mcallv, &vm::o_mcallh,
+        &vm::o_ret
+    };
+    std::vector<nafunc> code;
+    for(auto& i:gen.codes()) {
+        code.push_back(oprs[i.op]);
+        imm.push_back(i.num);
+    }
+    while(code[ctx.pc]) {
+        (this->*code[ctx.pc])();
+        if (ctx.top>=ctx.canary) {
+            die("stack overflow");
+        }
+        ++ctx.pc;
+    }
+#endif
+
+vmexit:
+    if (detail) {
+        ngc.info();
+    }
+    ngc.clear();
+    imm.clear();
+    return;
+
+#ifndef _MSC_VER
+// may cause stackoverflow
+#define exec_check(op) {\
+        op();\
+        if (ctx.top<ctx.canary)\
+            goto *code[++ctx.pc];\
+        die("stack overflow");\
+        goto *code[++ctx.pc];\
+    }
+// do not cause stackoverflow
+#define exec_nodie(op) {op();goto *code[++ctx.pc];}
+
+intg:   exec_nodie(o_intg  ); // +imm[pc] (detected at codegen)
+intl:   exec_nodie(o_intl  ); // -0
+loadg:  exec_nodie(o_loadg ); // -1
+loadl:  exec_nodie(o_loadl ); // -1
+loadu:  exec_nodie(o_loadu ); // -1
+pnum:   exec_check(o_pnum  ); // +1
+pnil:   exec_check(o_pnil  ); // +1
+pstr:   exec_check(o_pstr  ); // +1
+newv:   exec_check(o_newv  ); // +1-imm[pc]
+newh:   exec_check(o_newh  ); // +1
+newf:   exec_check(o_newf  ); // +1
+happ:   exec_nodie(o_happ  ); // -1
+para:   exec_nodie(o_para  ); // -0
+deft:   exec_nodie(o_deft  ); // -1
+dyn:    exec_nodie(o_dyn   ); // -0
+lnot:   exec_nodie(o_lnot  ); // -0
+usub:   exec_nodie(o_usub  ); // -0
+bnot:   exec_nodie(o_bnot  ); // -0
+btor:   exec_nodie(o_btor  ); // -1
+btxor:  exec_nodie(o_btxor ); // -1
+btand:  exec_nodie(o_btand ); // -1
+add:    exec_nodie(o_add   ); // -1
+sub:    exec_nodie(o_sub   ); // -1
+mul:    exec_nodie(o_mul   ); // -1
+div:    exec_nodie(o_div   ); // -1
+lnk:    exec_nodie(o_lnk   ); // -1
+addc:   exec_nodie(o_addc  ); // -0
+subc:   exec_nodie(o_subc  ); // -0
+mulc:   exec_nodie(o_mulc  ); // -0
+divc:   exec_nodie(o_divc  ); // -0
+lnkc:   exec_nodie(o_lnkc  ); // -0
+addeq:  exec_nodie(o_addeq ); // -1
+subeq:  exec_nodie(o_subeq ); // -1
+muleq:  exec_nodie(o_muleq ); // -1
+diveq:  exec_nodie(o_diveq ); // -1
+lnkeq:  exec_nodie(o_lnkeq ); // -1
+bandeq: exec_nodie(o_bandeq); // -1
+boreq:  exec_nodie(o_boreq ); // -1
+bxoreq: exec_nodie(o_bxoreq); // -1
+addeqc: exec_nodie(o_addeqc); // -0
+subeqc: exec_nodie(o_subeqc); // -0
+muleqc: exec_nodie(o_muleqc); // -0
+diveqc: exec_nodie(o_diveqc); // -0
+lnkeqc: exec_nodie(o_lnkeqc); // -0
+addecp: exec_nodie(o_addecp); // -1
+subecp: exec_nodie(o_subecp); // -1
+mulecp: exec_nodie(o_mulecp); // -1
+divecp: exec_nodie(o_divecp); // -1
+lnkecp: exec_nodie(o_lnkecp); // -1
+meq:    exec_nodie(o_meq   ); // -1
+eq:     exec_nodie(o_eq    ); // -1
+neq:    exec_nodie(o_neq   ); // -1
+less:   exec_nodie(o_less  ); // -1
+leq:    exec_nodie(o_leq   ); // -1
+grt:    exec_nodie(o_grt   ); // -1
+geq:    exec_nodie(o_geq   ); // -1
+lessc:  exec_nodie(o_lessc ); // -0
+leqc:   exec_nodie(o_leqc  ); // -0
+grtc:   exec_nodie(o_grtc  ); // -0
+geqc:   exec_nodie(o_geqc  ); // -0
+pop:    exec_nodie(o_pop   ); // -1
+jmp:    exec_nodie(o_jmp   ); // -0
+jt:     exec_nodie(o_jt    ); // -0
+jf:     exec_nodie(o_jf    ); // -1
+cnt:    exec_nodie(o_cnt   ); // -0
+findex: exec_check(o_findex); // +1
+feach:  exec_check(o_feach ); // +1
+callg:  exec_check(o_callg ); // +1
+calll:  exec_check(o_calll ); // +1
+upval:  exec_check(o_upval ); // +1
+callv:  exec_nodie(o_callv ); // -0
+callvi: exec_nodie(o_callvi); // -0
+callh:  exec_nodie(o_callh ); // -0
+callfv: exec_nodie(o_callfv); // check in the function
+callfh: exec_nodie(o_callfh); // check in the function
+callb:  exec_nodie(o_callb ); // -0
+slcbeg: exec_check(o_slcbeg); // +1
+slcend: exec_nodie(o_slcend); // -1
+slc:    exec_nodie(o_slc   ); // -1
+slc2:   exec_nodie(o_slc2  ); // -2
+mcallg: exec_check(o_mcallg); // +1
+mcalll: exec_check(o_mcalll); // +1
+mupval: exec_check(o_mupval); // +1
+mcallv: exec_nodie(o_mcallv); // -0
+mcallh: exec_nodie(o_mcallh); // -0
+ret:    exec_nodie(o_ret   ); // -2
+#endif
+}
diff --git a/ast/nasal_new_vm.h b/ast/nasal_new_vm.h
new file mode 100644
index 0000000..5c686fd
--- /dev/null
+++ b/ast/nasal_new_vm.h
@@ -0,0 +1,159 @@
+#pragma once
+
+#include <iomanip>
+#include <stack>
+
+#include "nasal_new_import.h"
+#include "nasal_new_gc.h"
+#include "nasal_new_codegen.h"
+
+#ifdef _MSC_VER
+#pragma warning (disable:4244)
+#pragma warning (disable:4267)
+#pragma warning (disable:4102)
+#endif
+
+class vm {
+protected:
+
+    /* registers and constants of vm */
+    context ctx;
+
+    /* constants */
+    const f64* cnum=nullptr;    // constant numbers
+    const std::string* cstr=nullptr; // constant symbols and strings
+    std::vector<u32> imm;       // immediate number table
+    
+    /* garbage collector */
+    gc ngc;
+
+    /* main stack */
+    var stack[STACK_DEPTH];
+
+    /* values used for debugger */
+    const std::string* files=nullptr;    // file name list
+    const opcode* bytecode=nullptr; // bytecode buffer address
+
+    /* vm initializing function */
+    void init(
+        const std::vector<std::string>&,
+        const std::vector<f64>&,
+        const std::vector<opcode>&,
+        const std::vector<std::string>&,
+        const std::vector<std::string>&);
+
+    /* debug functions */
+    bool verbose;
+    void valinfo(var&);
+    void traceback();
+    void stackinfo(const u32);
+    void reginfo();
+    void gstate();
+    void lstate();
+    void ustate();
+    void detail();
+    void die(const std::string&);
+
+    /* vm calculation functions*/
+    bool cond(var&);
+
+    /* vm operands */
+    void o_intg();
+    void o_intl();
+    void o_loadg();
+    void o_loadl();
+    void o_loadu();
+    void o_pnum();
+    void o_pnil();
+    void o_pstr();
+    void o_newv();
+    void o_newh();
+    void o_newf();
+    void o_happ();
+    void o_para();
+    void o_deft();
+    void o_dyn();
+    void o_lnot();
+    void o_usub();
+    void o_bnot();
+    void o_btor();
+    void o_btxor();
+    void o_btand();
+    void o_add();
+    void o_sub();
+    void o_mul();
+    void o_div();
+    void o_lnk();
+    void o_addc();
+    void o_subc();
+    void o_mulc();
+    void o_divc();
+    void o_lnkc();
+    void o_addeq();
+    void o_subeq();
+    void o_muleq();
+    void o_diveq();
+    void o_lnkeq();
+    void o_bandeq();
+    void o_boreq();
+    void o_bxoreq();
+    void o_addeqc();
+    void o_subeqc();
+    void o_muleqc();
+    void o_diveqc();
+    void o_lnkeqc();
+    void o_addecp();
+    void o_subecp();
+    void o_mulecp();
+    void o_divecp();
+    void o_lnkecp();
+    void o_meq();
+    void o_eq();
+    void o_neq();
+    void o_less();
+    void o_leq();
+    void o_grt();
+    void o_geq();
+    void o_lessc();
+    void o_leqc();
+    void o_grtc();
+    void o_geqc();
+    void o_pop();
+    void o_jmp();
+    void o_jt();
+    void o_jf();
+    void o_cnt();
+    void o_findex();
+    void o_feach();
+    void o_callg();
+    void o_calll();
+    void o_upval();
+    void o_callv();
+    void o_callvi();
+    void o_callh();
+    void o_callfv();
+    void o_callfh();
+    void o_callb();
+    void o_slcbeg();
+    void o_slcend();
+    void o_slc();
+    void o_slc2();
+    void o_mcallg();
+    void o_mcalll();
+    void o_mupval();
+    void o_mcallv();
+    void o_mcallh();
+    void o_ret();
+public:
+
+    /* constructor of vm instance */
+    vm(): ngc(&ctx), verbose(false) {}
+
+    /* execution entry */
+    void run(
+        const codegen&,
+        const linker&,
+        const std::vector<std::string>&,
+        const bool
+    );
+};
diff --git a/makefile b/makefile
index e8e9bbe..c6c5715 100644
--- a/makefile
+++ b/makefile
@@ -84,6 +84,8 @@ NASAL_NEW_AST=\
 	nasal_new_codegen.o\
 	nasal_new_opcode.o\
 	nasal_new_parse.o\
+	nasal_new_vm.o\
+	nasal_new_dbg.o\
 	optimizer.o\
 	symbol_finder.o\
 	ast_visitor.o\
@@ -120,7 +122,7 @@ nasal_new_builtin.o: ast/nasal_new_builtin.h ast/nasal_new_builtin.cpp
 	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_builtin.cpp -fno-exceptions -fPIC -o nasal_new_builtin.o -I .
 
 nasal_new_codegen.o: ast/nasal_new_codegen.h ast/nasal_new_codegen.cpp
-#	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_codegen.cpp -fno-exceptions -fPIC -o nasal_new_codegen.o -I .
+	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_codegen.cpp -fno-exceptions -fPIC -o nasal_new_codegen.o -I .
 
 nasal_new_opcode.o: ast/nasal_new_opcode.h ast/nasal_new_opcode.cpp
 	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_opcode.cpp -fno-exceptions -fPIC -o nasal_new_opcode.o -I .
@@ -140,6 +142,12 @@ ast_visitor.o: ast/nasal_new_ast.h ast/ast_visitor.h ast/ast_visitor.cpp
 ast_dumper.o: ast/nasal_new_ast.h ast/ast_visitor.h ast/ast_dumper.h ast/ast_dumper.cpp
 	$(CXX) -std=$(STD) -c -O3 ast/ast_dumper.cpp -fno-exceptions -fPIC -o ast_dumper.o -I .
 
+nasal_new_vm.o: ast/nasal_new_vm.h ast/nasal_new_vm.cpp
+	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_vm.cpp -fno-exceptions -fPIC -o nasal_new_vm.o -I .
+
+nasal_new_dbg.o: ast/nasal_new_dbg.h ast/nasal_new_dbg.cpp
+	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_dbg.cpp -fno-exceptions -fPIC -o nasal_new_dbg.o -I .
+
 .PHONY: nasal_new_clean
 nasal_new_clean:
 	rm $(NASAL_NEW_AST)
\ No newline at end of file