add lab1 lab2 imp

.gitignore

+build/
+.cache/
\ No newline at end of file

CMakeLists.txt

@@ -52,4 +52,4 @@ set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR})
 include_directories(${PROJECT_SOURCE_DIR})
 include_directories(${PROJECT_BINARY_DIR})
 add_subdirectory(src)
-add_subdirectory(tests)
+# add_subdirectory(tests)

README.md

@@ -2,5 +2,5 @@
 
 本仓库为 USTC 编译原理和技术 2025 的课程实验仓库。在本学期的编译实验中，你们将构建一个从词法分析器开始到后端代码生成的JIANMU编译器。
 
-你们需要 fork 此 repo 到自己的仓库下，随后在自己的仓库中完成实验。
+本分支提供了直到 lab2 的助教代码实现，可以用于完成 lab3 phase2。
 

include/cminusfc/cminusf_builder.hpp

@@ -106,8 +106,11 @@ class CminusfBuilder : public ASTVisitor {
     std::unique_ptr<Module> module;
 
     struct {
+        // whether require lvalue
+        bool require_lvalue = false;
         // function that is being built
         Function *func = nullptr;
-        // TODO: you should add more fields to store state
+        // detect scope pre-enter (for elegance only)
+        bool pre_enter_scope = false;
     } context;
 };

src/cminusfc/cminusf_builder.cpp

+/*
+ * 声明：本代码为 2025 秋 中国科大编译原理（李诚）课程实验参考实现。
+ * 请不要以任何方式，将本代码上传到可以公开访问的站点或仓库
+ */
+
 #include "cminusf_builder.hpp"
 
 #define CONST_FP(num) ConstantFP::get((float)num, module.get())
@@ -11,6 +16,22 @@ Type *INT32PTR_T;
 Type *FLOAT_T;
 Type *FLOATPTR_T;
 
+bool promote(IRBuilder *builder, Value **l_val_p, Value **r_val_p) {
+    bool is_int = false;
+    auto &l_val = *l_val_p;
+    auto &r_val = *r_val_p;
+    if (l_val->get_type() == r_val->get_type()) {
+        is_int = l_val->get_type()->is_integer_type();
+    } else {
+        if (l_val->get_type()->is_integer_type()) {
+            l_val = builder->create_sitofp(l_val, FLOAT_T);
+        } else {
+            r_val = builder->create_sitofp(r_val, FLOAT_T);
+        }
+    }
+    return is_int;
+}
+
 /*
  * use CMinusfBuilder::Scope to construct scopes
  * scope.enter: enter a new scope
@@ -35,14 +56,51 @@ Value* CminusfBuilder::visit(ASTProgram &node) {
 }
 
 Value* CminusfBuilder::visit(ASTNum &node) {
-    // TODO: This function is empty now.
-    // Add some code here.
-    return nullptr;
+    if (node.type == TYPE_INT) {
+        return CONST_INT(node.i_val);
+    }
+    return CONST_FP(node.f_val);
 }
 
 Value* CminusfBuilder::visit(ASTVarDeclaration &node) {
-    // TODO: This function is empty now.
-    // Add some code here.
+    Type *var_type = nullptr;
+    if (node.type == TYPE_INT) {
+        var_type = module->get_int32_type();
+    } else {
+        var_type = module->get_float_type();
+    }
+
+    if (scope.in_global()) {
+        if (node.num == nullptr) {
+            auto *initializer = ConstantZero::get(var_type, module.get());
+            auto *var = GlobalVariable::create(node.id, module.get(), var_type,
+                                               false, initializer);
+            scope.push(node.id, var);
+        } else {
+            auto *array_type = ArrayType::get(var_type, node.num->i_val);
+            auto *initializer = ConstantZero::get(array_type, module.get());
+            auto *var = GlobalVariable::create(node.id, module.get(),
+                                               array_type, false, initializer);
+            scope.push(node.id, var);
+        }
+    } else {
+        if (node.num == nullptr) {
+            auto nowBB = builder->get_insert_block();
+            auto entryBB = context.func->get_entry_block();
+            builder->set_insert_point(entryBB);
+            auto *var = builder->create_alloca_begin(var_type);
+            builder->set_insert_point(nowBB);
+            scope.push(node.id, var);
+        } else {
+            auto nowBB = builder->get_insert_block();
+            auto entryBB = context.func->get_entry_block();
+            builder->set_insert_point(entryBB);
+            auto *array_type = ArrayType::get(var_type, node.num->i_val);
+            auto *var = builder->create_alloca_begin(array_type);
+            builder->set_insert_point(nowBB);
+            scope.push(node.id, var);
+        }
+    }
     return nullptr;
 }
 
@@ -58,7 +116,19 @@ Value* CminusfBuilder::visit(ASTFunDeclaration &node) {
         ret_type = VOID_T;
 
     for (auto &param : node.params) {
-        // TODO: Please accomplish param_types.
+        if (param->type == TYPE_INT) {
+            if (param->isarray) {
+                param_types.push_back(INT32PTR_T);
+            } else {
+                param_types.push_back(INT32_T);
+            }
+        } else {
+            if (param->isarray) {
+                param_types.push_back(FLOATPTR_T);
+            } else {
+                param_types.push_back(FLOAT_T);
+            }
+        }
     }
 
     fun_type = FunctionType::get(ret_type, param_types);
@@ -68,14 +138,34 @@ Value* CminusfBuilder::visit(ASTFunDeclaration &node) {
     auto funBB = BasicBlock::create(module.get(), "entry", func);
     builder->set_insert_point(funBB);
     scope.enter();
+    context.pre_enter_scope = true;
     std::vector<Value *> args;
     for (auto &arg : func->get_args()) {
         args.push_back(&arg);
     }
     for (unsigned int i = 0; i < node.params.size(); ++i) {
-        // TODO: You need to deal with params and store them in the scope.
+        if (node.params[i]->isarray) {
+            Value *array_alloc = nullptr;
+            if (node.params[i]->type == TYPE_INT) {
+                array_alloc = builder->create_alloca(INT32PTR_T);
+            } else {
+                array_alloc = builder->create_alloca(FLOATPTR_T);
+            }
+            builder->create_store(args[i], array_alloc);
+            scope.push(node.params[i]->id, array_alloc);
+        } else {
+            Value *alloc = nullptr;
+            if (node.params[i]->type == TYPE_INT) {
+                alloc = builder->create_alloca(INT32_T);
+            } else {
+                alloc = builder->create_alloca(FLOAT_T);
+            }
+            builder->create_store(args[i], alloc);
+            scope.push(node.params[i]->id, alloc);
+        }
     }
     node.compound_stmt->accept(*this);
+    // can't deal with return in both blocks
     if (not builder->get_insert_block()->is_terminated()) 
     {
         if (context.func->get_return_type()->is_void_type())
@@ -90,15 +180,16 @@ Value* CminusfBuilder::visit(ASTFunDeclaration &node) {
 }
 
 Value* CminusfBuilder::visit(ASTParam &node) {
-    // TODO: This function is empty now.
-    // Add some code here.
     return nullptr;
 }
 
 Value* CminusfBuilder::visit(ASTCompoundStmt &node) {
-    // TODO: This function is not complete.
-    // You may need to add some code here
-    // to deal with complex statements. 
+    bool need_exit_scope = !context.pre_enter_scope;
+    if (context.pre_enter_scope) {
+        context.pre_enter_scope = false;
+    } else {
+        scope.enter();
+    }
 
     for (auto &decl : node.local_declarations) {
         decl->accept(*this);
@@ -109,70 +200,321 @@ Value* CminusfBuilder::visit(ASTCompoundStmt &node) {
         if (builder->get_insert_block()->is_terminated())
             break;
     }
+
+    if (need_exit_scope) {
+        scope.exit();
+    }
     return nullptr;
 }
 
 Value* CminusfBuilder::visit(ASTExpressionStmt &node) {
-    // TODO: This function is empty now.
-    // Add some code here.
+    if (node.expression != nullptr) {
+        return node.expression->accept(*this);
+    }
     return nullptr;
 }
 
 Value* CminusfBuilder::visit(ASTSelectionStmt &node) {
-    // TODO: This function is empty now.
-    // Add some code here.
+    auto *ret_val = node.expression->accept(*this);
+    auto *trueBB = BasicBlock::create(module.get(), "", context.func);
+    BasicBlock *falseBB{};
+    auto *contBB = BasicBlock::create(module.get(), "", context.func);
+    Value *cond_val = nullptr;
+    if (ret_val->get_type()->is_integer_type()) {
+        cond_val = builder->create_icmp_ne(ret_val, CONST_INT(0));
+    } else {
+        cond_val = builder->create_fcmp_ne(ret_val, CONST_FP(0.));
+    }
+
+    if (node.else_statement == nullptr) {
+        builder->create_cond_br(cond_val, trueBB, contBB);
+    } else {
+        falseBB = BasicBlock::create(module.get(), "", context.func);
+        builder->create_cond_br(cond_val, trueBB, falseBB);
+    }
+    builder->set_insert_point(trueBB);
+    node.if_statement->accept(*this);
+
+    if (not builder->get_insert_block()->is_terminated()) {
+        builder->create_br(contBB);
+    }
+
+    if (node.else_statement == nullptr) {
+        // falseBB->erase_from_parent(); // did not clean up memory
+    } else {
+        builder->set_insert_point(falseBB);
+        node.else_statement->accept(*this);
+        if (not builder->get_insert_block()->is_terminated()) {
+            builder->create_br(contBB);
+        }
+    }
+
+    builder->set_insert_point(contBB);
     return nullptr;
 }
 
 Value* CminusfBuilder::visit(ASTIterationStmt &node) {
-    // TODO: This function is empty now.
-    // Add some code here.
+    auto *exprBB = BasicBlock::create(module.get(), "", context.func);
+    if (not builder->get_insert_block()->is_terminated()) {
+        builder->create_br(exprBB);
+    }
+    builder->set_insert_point(exprBB);
+
+    auto *ret_val = node.expression->accept(*this);
+    auto *trueBB = BasicBlock::create(module.get(), "", context.func);
+    auto *contBB = BasicBlock::create(module.get(), "", context.func);
+    Value *cond_val = nullptr;
+    if (ret_val->get_type()->is_integer_type()) {
+        cond_val = builder->create_icmp_ne(ret_val, CONST_INT(0));
+    } else {
+        cond_val = builder->create_fcmp_ne(ret_val, CONST_FP(0.));
+    }
+
+    builder->create_cond_br(cond_val, trueBB, contBB);
+    builder->set_insert_point(trueBB);
+    node.statement->accept(*this);
+    if (not builder->get_insert_block()->is_terminated()) {
+        builder->create_br(exprBB);
+    }
+    builder->set_insert_point(contBB);
+
     return nullptr;
 }
 
 Value* CminusfBuilder::visit(ASTReturnStmt &node) {
     if (node.expression == nullptr) {
         builder->create_void_ret();
-        return nullptr;
     } else {
-        // TODO: The given code is incomplete.
-        // You need to solve other return cases (e.g. return an integer).
+        auto *fun_ret_type =
+            context.func->get_function_type()->get_return_type();
+        auto *ret_val = node.expression->accept(*this);
+        if (fun_ret_type != ret_val->get_type()) {
+            if (fun_ret_type->is_integer_type()) {
+                ret_val = builder->create_fptosi(ret_val, INT32_T);
+            } else {
+                ret_val = builder->create_sitofp(ret_val, FLOAT_T);
             }
+        }
+
+        builder->create_ret(ret_val);
+    }
+
     return nullptr;
 }
 
 Value* CminusfBuilder::visit(ASTVar &node) {
-    // TODO: This function is empty now.
-    // Add some code here.
-    return nullptr;
+    auto *var = scope.find(node.id);
+    auto is_int =
+        var->get_type()->get_pointer_element_type()->is_integer_type();
+    auto is_float =
+        var->get_type()->get_pointer_element_type()->is_float_type();
+    auto is_ptr =
+        var->get_type()->get_pointer_element_type()->is_pointer_type();
+    bool should_return_lvalue = context.require_lvalue;
+    context.require_lvalue = false;
+    Value *ret_val = nullptr;
+    if (node.expression == nullptr) {
+        if (should_return_lvalue) {
+            ret_val = var;
+            context.require_lvalue = false;
+        } else {
+            if (is_int || is_float || is_ptr) {
+                ret_val = builder->create_load(var);
+            } else {
+                ret_val =
+                    builder->create_gep(var, {CONST_INT(0), CONST_INT(0)});
+            }
+        }
+    } else {
+        auto *val = node.expression->accept(*this);
+        Value *is_neg = nullptr;
+        auto *exceptBB = BasicBlock::create(module.get(), "", context.func);
+        auto *contBB = BasicBlock::create(module.get(), "", context.func);
+        if (val->get_type()->is_float_type()) {
+            val = builder->create_fptosi(val, INT32_T);
+        }
+
+        is_neg = builder->create_icmp_lt(val, CONST_INT(0));
+
+        builder->create_cond_br(is_neg, exceptBB, contBB);
+        builder->set_insert_point(exceptBB);
+        auto *neg_idx_except_fun = scope.find("neg_idx_except");
+        builder->create_call(dynamic_cast<Function *>(neg_idx_except_fun), {});
+        if (context.func->get_return_type()->is_void_type()) {
+            builder->create_void_ret();
+        } else if (context.func->get_return_type()->is_float_type()) {
+            builder->create_ret(CONST_FP(0.));
+        } else {
+            builder->create_ret(CONST_INT(0));
+        }
+
+        builder->set_insert_point(contBB);
+        Value *tmp_ptr = nullptr;
+        if (is_int || is_float) {
+            tmp_ptr = builder->create_gep(var, {val});
+        } else if (is_ptr) {
+            auto *array_load = builder->create_load(var);
+            tmp_ptr = builder->create_gep(array_load, {val});
+        } else {
+            tmp_ptr = builder->create_gep(var, {CONST_INT(0), val});
+        }
+        if (should_return_lvalue) {
+            ret_val = tmp_ptr;
+            context.require_lvalue = false;
+        } else {
+            ret_val = builder->create_load(tmp_ptr);
+        }
+    }
+    return ret_val;
 }
 
 Value* CminusfBuilder::visit(ASTAssignExpression &node) {
-    // TODO: This function is empty now.
-    // Add some code here.
-    return nullptr;
+    auto *expr_result = node.expression->accept(*this);
+    context.require_lvalue = true;
+    auto *var_addr = node.var->accept(*this);
+    if (var_addr->get_type()->get_pointer_element_type() !=
+        expr_result->get_type()) {
+        if (expr_result->get_type() == INT32_T) {
+            expr_result = builder->create_sitofp(expr_result, FLOAT_T);
+        } else {
+            expr_result = builder->create_fptosi(expr_result, INT32_T);
+        }
+    }
+    builder->create_store(expr_result, var_addr);
+    return expr_result;
 }
 
 Value* CminusfBuilder::visit(ASTSimpleExpression &node) {
-    // TODO: This function is empty now.
-    // Add some code here.
-    return nullptr;
+    if (node.additive_expression_r == nullptr) {
+        return node.additive_expression_l->accept(*this);
+    }
+
+    auto *l_val = node.additive_expression_l->accept(*this);
+    auto *r_val = node.additive_expression_r->accept(*this);
+    bool is_int = promote(&*builder, &l_val, &r_val);
+    Value *cmp = nullptr;
+    switch (node.op) {
+    case OP_LT:
+        if (is_int) {
+            cmp = builder->create_icmp_lt(l_val, r_val);
+        } else {
+            cmp = builder->create_fcmp_lt(l_val, r_val);
+        }
+        break;
+    case OP_LE:
+        if (is_int) {
+            cmp = builder->create_icmp_le(l_val, r_val);
+        } else {
+            cmp = builder->create_fcmp_le(l_val, r_val);
+        }
+        break;
+    case OP_GE:
+        if (is_int) {
+            cmp = builder->create_icmp_ge(l_val, r_val);
+        } else {
+            cmp = builder->create_fcmp_ge(l_val, r_val);
+        }
+        break;
+    case OP_GT:
+        if (is_int) {
+            cmp = builder->create_icmp_gt(l_val, r_val);
+        } else {
+            cmp = builder->create_fcmp_gt(l_val, r_val);
+        }
+        break;
+    case OP_EQ:
+        if (is_int) {
+            cmp = builder->create_icmp_eq(l_val, r_val);
+        } else {
+            cmp = builder->create_fcmp_eq(l_val, r_val);
+        }
+        break;
+    case OP_NEQ:
+        if (is_int) {
+            cmp = builder->create_icmp_ne(l_val, r_val);
+        } else {
+            cmp = builder->create_fcmp_ne(l_val, r_val);
+        }
+        break;
+    }
+
+    return builder->create_zext(cmp, INT32_T);
 }
 
 Value* CminusfBuilder::visit(ASTAdditiveExpression &node) {
-    // TODO: This function is empty now.
-    // Add some code here.
-    return nullptr;
+    if (node.additive_expression == nullptr) {
+        return node.term->accept(*this);
+    }
+
+    auto *l_val = node.additive_expression->accept(*this);
+    auto *r_val = node.term->accept(*this);
+    bool is_int = promote(&*builder, &l_val, &r_val);
+    Value *ret_val = nullptr;
+    switch (node.op) {
+    case OP_PLUS:
+        if (is_int) {
+            ret_val = builder->create_iadd(l_val, r_val);
+        } else {
+            ret_val = builder->create_fadd(l_val, r_val);
+        }
+        break;
+    case OP_MINUS:
+        if (is_int) {
+            ret_val = builder->create_isub(l_val, r_val);
+        } else {
+            ret_val = builder->create_fsub(l_val, r_val);
+        }
+        break;
+    }
+    return ret_val;
 }
 
 Value* CminusfBuilder::visit(ASTTerm &node) {
-    // TODO: This function is empty now.
-    // Add some code here.
-    return nullptr;
+    if (node.term == nullptr) {
+        return node.factor->accept(*this);
+    }
+
+    auto *l_val = node.term->accept(*this);
+    auto *r_val = node.factor->accept(*this);
+    bool is_int = promote(&*builder, &l_val, &r_val);
+
+    Value *ret_val = nullptr;
+    switch (node.op) {
+    case OP_MUL:
+        if (is_int) {
+            ret_val = builder->create_imul(l_val, r_val);
+        } else {
+            ret_val = builder->create_fmul(l_val, r_val);
+        }
+        break;
+    case OP_DIV:
+        if (is_int) {
+            ret_val = builder->create_isdiv(l_val, r_val);
+        } else {
+            ret_val = builder->create_fdiv(l_val, r_val);
+        }
+        break;
+    }
+    return ret_val;
 }
 
 Value* CminusfBuilder::visit(ASTCall &node) {
-    // TODO: This function is empty now.
-    // Add some code here.
-    return nullptr;
+    auto *func = dynamic_cast<Function *>(scope.find(node.id));
+    std::vector<Value *> args;
+    auto param_type = func->get_function_type()->param_begin();
+    for (auto &arg : node.args) {
+        auto *arg_val = arg->accept(*this);
+        if (!arg_val->get_type()->is_pointer_type() &&
+            *param_type != arg_val->get_type()) {
+            if (arg_val->get_type()->is_integer_type()) {
+                arg_val = builder->create_sitofp(arg_val, FLOAT_T);
+            } else {
+                arg_val = builder->create_fptosi(arg_val, INT32_T);
+            }
+        }
+        args.push_back(arg_val);
+        param_type++;
+    }
+
+    return builder->create_call(static_cast<Function *>(func), args);
 }

src/common/ast.cpp

@@ -96,17 +96,29 @@ ASTNode *AST::transform_node_iter(syntax_tree_node *n) {
     // id 字段填充
     node->id = n->children[1]->name;
 
-    /*
-        params 字段填充
-        注意这里的params是一个列表，每个元素都是一个ASTParam，需要flatten
-        params -> param-list | void
-        param-list -> param-list , param | param
-    */
-    // TODO: 1.fill in the fields of ASTFunDeclaration
-    // 1.1 flatten params
+    // flatten params
+    std::stack<syntax_tree_node *> s;
+    auto list_ptr = n->children[3]->children[0];
+    if (list_ptr->children_num != 0) {
+      if (list_ptr->children_num == 3) {
+        while (list_ptr->children_num == 3) {
+          s.push(list_ptr->children[2]);
+          list_ptr = list_ptr->children[0];
+        }
+      }
+      s.push(list_ptr->children[0]);
 
-    // 1.2 compound_stmt 字段填充
+      while (!s.empty()) {
+        auto child_node = static_cast<ASTParam *>(transform_node_iter(s.top()));
+        auto child_node_shared = std::shared_ptr<ASTParam>(child_node);
+        node->params.push_back(child_node_shared);
+        s.pop();
+      }
+    }
 
+    auto stmt_node =
+        static_cast<ASTCompoundStmt *>(transform_node_iter(n->children[5]));
+    node->compound_stmt = std::shared_ptr<ASTCompoundStmt>(stmt_node);
     return node;
   } else if (_STR_EQ(n->name, "param")) {
     // param -> type-specifier ID | type-specifier ID [ ]
@@ -123,19 +135,41 @@ ASTNode *AST::transform_node_iter(syntax_tree_node *n) {
     return node;
   } else if (_STR_EQ(n->name, "compound-stmt")) {
     auto node = new ASTCompoundStmt();
-    // TODO: 2.fill in the fields of ASTCompoundStmt
-    /*
-      文法表达式如下
-      compound-stmt -> { local-declarations statement-list }
-      local-declarations -> local-declarations var-declaration | empty
-      statement-list -> statement-list statement | empty
-    */
-    // local declarations
-    // 2.1 flatten local declarations
+    if (n->children[1]->children_num == 2) {
+      // flatten local declarations
+      auto list_ptr = n->children[1];
+      std::stack<syntax_tree_node *> s;
+      while (list_ptr->children_num == 2) {
+        s.push(list_ptr->children[1]);
+        list_ptr = list_ptr->children[0];
+      }
+
+      while (!s.empty()) {
+        auto decl_node =
+            static_cast<ASTVarDeclaration *>(transform_node_iter(s.top()));
+        auto decl_node_ptr = std::shared_ptr<ASTVarDeclaration>(decl_node);
+        node->local_declarations.push_back(decl_node_ptr);
+        s.pop();
+      }
+    }
 
-    // statement list
-    // 2.2 flatten statement-list
+    if (n->children[2]->children_num == 2) {
+      // flatten statement-list
+      auto list_ptr = n->children[2];
+      std::stack<syntax_tree_node *> s;
+      while (list_ptr->children_num == 2) {
+        s.push(list_ptr->children[1]);
+        list_ptr = list_ptr->children[0];
+      }
 
+      while (!s.empty()) {
+        auto stmt_node =
+            static_cast<ASTStatement *>(transform_node_iter(s.top()));
+        auto stmt_node_ptr = std::shared_ptr<ASTStatement>(stmt_node);
+        node->statement_list.push_back(stmt_node_ptr);
+        s.pop();
+      }
+    }
     return node;
   } else if (_STR_EQ(n->name, "statement")) {
     return transform_node_iter(n->children[0]);
@@ -151,18 +185,25 @@ ASTNode *AST::transform_node_iter(syntax_tree_node *n) {
     return node;
   } else if (_STR_EQ(n->name, "selection-stmt")) {
     auto node = new ASTSelectionStmt();
-    // TODO: 5.fill in the fields of ASTSelectionStmt
-    /*
-      selection-stmt -> if ( expression ) statement | if ( expression )
-      statement else statement ASTSelectionStmt的结构，需要填充的字段有
-      expression, if_statement, else_statement
-    */
-    // 5.1 expresstion
 
-    // 5.2 if statement
+    auto expr_node =
+        static_cast<ASTExpression *>(transform_node_iter(n->children[2]));
+    auto expr_node_ptr = std::shared_ptr<ASTExpression>(expr_node);
+    node->expression = expr_node_ptr;
+
+    auto if_stmt_node =
+        static_cast<ASTStatement *>(transform_node_iter(n->children[4]));
+    auto if_stmt_node_ptr = std::shared_ptr<ASTStatement>(if_stmt_node);
+    node->if_statement = if_stmt_node_ptr;
 
     // check whether this selection statement contains
-    // 5.3 else structure
+    // else structure
+    if (n->children_num == 7) {
+      auto else_stmt_node =
+          static_cast<ASTStatement *>(transform_node_iter(n->children[6]));
+      auto else_stmt_node_ptr = std::shared_ptr<ASTStatement>(else_stmt_node);
+      node->else_statement = else_stmt_node_ptr;
+    }
 
     return node;
   } else if (_STR_EQ(n->name, "iteration-stmt")) {
@@ -242,13 +283,20 @@ ASTNode *AST::transform_node_iter(syntax_tree_node *n) {
   } else if (_STR_EQ(n->name, "additive-expression")) {
     auto node = new ASTAdditiveExpression();
     if (n->children_num == 3) {
-      // TODO: 4.fill in the fields of ASTAdditiveExpression
-      /*
-        文法表达式如下
-        additive-expression -> additive-expression addop term | term 
-      */
-      // additive_expression, term, op
+      auto add_expr_node = static_cast<ASTAdditiveExpression *>(
+          transform_node_iter(n->children[0]));
+      node->additive_expression =
+          std::shared_ptr<ASTAdditiveExpression>(add_expr_node);
 
+      auto op_name = n->children[1]->children[0]->name;
+      if (_STR_EQ(op_name, "+"))
+        node->op = OP_PLUS;
+      else if (_STR_EQ(op_name, "-"))
+        node->op = OP_MINUS;
+
+      auto term_node =
+          static_cast<ASTTerm *>(transform_node_iter(n->children[2]));
+      node->term = std::shared_ptr<ASTTerm>(term_node);
     } else {
       auto term_node =
           static_cast<ASTTerm *>(transform_node_iter(n->children[0]));
@@ -287,19 +335,12 @@ ASTNode *AST::transform_node_iter(syntax_tree_node *n) {
       return transform_node_iter(n->children[i]);
     else {
       auto num_node = new ASTNum();
-      // TODO: 3.fill in the fields of ASTNum
-      /*
-        文法表达式如下
-        factor -> ( expression ) | var | call | integer | float
-        float -> FLOATPOINT
-        integer -> INTEGER
-      */
       if (_STR_EQ(name, "integer")) {
-        // 3.1
-
+        num_node->type = TYPE_INT;
+        num_node->i_val = std::stoi(n->children[i]->children[0]->name);
       } else if (_STR_EQ(name, "float")) {
-        // 3.2
-
+        num_node->type = TYPE_FLOAT;
+        num_node->f_val = std::stof(n->children[i]->children[0]->name);
       } else {
         _AST_NODE_ERROR_
       }

src/parser/lexical_analyzer.l

@@ -25,6 +25,9 @@ void pass_node(char *text){
  /* to do for students */
  /* two cases for you, pass_node will send flex's token to bison */
 \+ 	{pos_start = pos_end; pos_end += 1; pass_node(yytext); return ADD;}
+
+ /****请在此补全所有flex的模式与动作  end******/
+
 \-	{pos_start = pos_end; pos_end += 1; pass_node(yytext); return SUB;}
 \*	{pos_start = pos_end; pos_end += 1; pass_node(yytext); return MUL;}
 \/	{pos_start = pos_end; pos_end += 1; pass_node(yytext); return DIV;}
@@ -37,10 +40,31 @@ void pass_node(char *text){
 =	{pos_start = pos_end; pos_end += 1; pass_node(yytext); return ASSIGN;}
 ;	{pos_start = pos_end; pos_end += 1; pass_node(yytext); return SEMICOLON;}
 ,	{pos_start = pos_end; pos_end += 1; pass_node(yytext); return COMMA;}
- /* TODO: phase1. 请在这里补充其他的词法规则 */
+\(	{pos_start = pos_end; pos_end += 1; pass_node(yytext); return LPARENTHESE;}
+\)	{pos_start = pos_end; pos_end += 1; pass_node(yytext); return RPARENTHESE;}
+\[	{pos_start = pos_end; pos_end += 1; pass_node(yytext); return LBRACKET;}
+\]	{pos_start = pos_end; pos_end += 1; pass_node(yytext); return RBRACKET;}
+\{	{pos_start = pos_end; pos_end += 1; pass_node(yytext); return LBRACE;}
+\}	{pos_start = pos_end; pos_end += 1; pass_node(yytext); return RBRACE;}
+else	{pos_start = pos_end; pos_end += 4; pass_node(yytext); return ELSE;}
+if	{pos_start = pos_end; pos_end += 2; pass_node(yytext); return IF;}
+int	{pos_start = pos_end; pos_end += 3; pass_node(yytext); return INT;}
+float   {pos_start = pos_end; pos_end += 5; pass_node(yytext); return FLOAT;}
+return 	{pos_start = pos_end; pos_end += 6; pass_node(yytext); return RETURN;}
+void 	{pos_start = pos_end; pos_end += 4; pass_node(yytext); return VOID;}
+while 	{pos_start = pos_end; pos_end += 5; pass_node(yytext); return WHILE;}
+[a-zA-Z]+	{pos_start = pos_end; pos_end += strlen(yytext); pass_node(yytext); return IDENTIFIER;}
+[0-9]+	{pos_start = pos_end; pos_end += strlen(yytext); pass_node(yytext); return INTEGER;}
+[0-9]+\.[0-9]*|[0-9]*\.[0-9]+ { pos_start = pos_end; pos_end += strlen(yytext); pass_node(yytext); return FLOATPOINT;}
 
+\n 	{lines++; pos_start = 1; pos_end = 1;}
+[ \t] 	{pos_start = pos_end; pos_end += 1;}
+
+"/*"             { pos_start = pos_end; pos_end += 2; BEGIN(COMMENT); }
+<COMMENT>"*/"    { pos_start = pos_end; pos_end += 2; BEGIN(INITIAL); }
+<COMMENT>.  { pos_start = pos_end; pos_start += 1; }
+<COMMENT>\n { pos_start = 1; pos_end = 1; lines++; }
 
 . { pos_start = pos_end; pos_end++; return ERROR; }
 
- /****请在此补全所有flex的模式与动作  end******/
 %%

src/parser/syntax_analyzer.y

@@ -28,15 +28,11 @@ void yyerror(const char *s);
 syntax_tree_node *node(const char *node_name, int children_num, ...);
 %}
 
-/* Complete this definition.
-   Hint: See pass_node(), node(), and syntax_tree.h.
-         Use forward declaring. */
 %union {
      struct _syntax_tree_node * node;
 	 char * name;
 }
 
-/* Your tokens here. */
 %token <node> ERROR
 %token <node> ADD
 %token <node> SUB
@@ -76,7 +72,6 @@ syntax_tree_node *node(const char *node_name, int children_num, ...);
 %start program
 
 %%
-/* Your rules here. TA has completed many */
 
 program : 	declaration-list {$$ = node( "program", 1, $1); gt->root = $$;}
 		;
@@ -123,7 +118,90 @@ local-declarations 	: 	local-declarations var-declaration {$$ = node( "local-dec
 statement-list 	: 	statement-list statement {$$ = node( "statement-list", 2, $1, $2);}
 | 	{$$ = node( "statement-list",0);}
                     ;
-// TODO: phase1. 补充其他的文法产生式逻辑
+
+statement 	: 	expression-stmt {$$ = node( "statement", 1, $1);}
+            | 	compound-stmt {$$ = node( "statement", 1, $1);}
+			| 	selection-stmt {$$ = node( "statement", 1, $1);}
+			| 	iteration-stmt {$$ = node( "statement", 1, $1);}
+			| 	return-stmt {$$ = node( "statement", 1, $1);}
+			;
+
+expression-stmt : 	expression SEMICOLON {$$ = node( "expression-stmt", 2, $1, $2);}
+				| 	SEMICOLON {$$ = node( "expression-stmt", 1, $1);}
+				;
+
+selection-stmt 	: 	IF LPARENTHESE expression RPARENTHESE statement {$$ = node( "selection-stmt", 5, $1, $2, $3, $4, $5);}
+				| 	IF LPARENTHESE expression RPARENTHESE statement ELSE statement {$$ = node( "selection-stmt", 7, $1, $2, $3, $4, $5, $6, $7);}
+				;
+
+iteration-stmt 	: 	WHILE LPARENTHESE expression RPARENTHESE statement {$$ = node( "iteration-stmt", 5, $1, $2, $3, $4, $5);}
+				;
+
+return-stmt : 	RETURN SEMICOLON {$$ = node( "return-stmt", 2, $1, $2);}
+			| 	RETURN expression SEMICOLON {$$ = node( "return-stmt", 3, $1, $2, $3);}
+			;
+
+expression 	: 	var ASSIGN expression {$$ = node( "expression", 3, $1, $2, $3);}
+			| 	simple-expression {$$ = node( "expression", 1, $1);}
+			;
+
+var : 	IDENTIFIER {$$ = node( "var", 1, $1);}
+    | 	IDENTIFIER LBRACKET expression RBRACKET {$$ = node( "var", 4, $1, $2, $3, $4);}
+    ;
+
+simple-expression 	: 	additive-expression relop additive-expression {$$ = node( "simple-expression", 3, $1, $2, $3);}
+					| 	additive-expression {$$ = node( "simple-expression", 1, $1);}
+					;
+
+relop 	: 	LT {$$ = node( "relop", 1, $1);}
+		| 	LTE {$$ = node( "relop", 1, $1);}
+		| 	GT {$$ = node( "relop", 1, $1);}
+		| 	GTE {$$ = node( "relop", 1, $1);}
+		| 	EQ {$$ = node( "relop", 1, $1);}
+		| 	NEQ {$$ = node( "relop", 1, $1);}
+		;
+
+additive-expression : 	additive-expression addop term  {$$ = node( "additive-expression", 3, $1, $2, $3);}
+					| 	term {$$ = node( "additive-expression", 1, $1);}
+					;
+
+addop 	: 	ADD {$$ = node( "addop", 1, $1);}
+		|	SUB {$$ = node( "addop", 1, $1);}
+		;
+
+term 	: 	term mulop factor {$$ = node( "term", 3, $1, $2, $3);}
+		| 	factor {$$ = node( "term", 1, $1);}
+		;
+
+mulop 	: 	MUL {$$ = node( "mulop", 1, $1);}
+		|	DIV {$$ = node( "mulop", 1, $1);}
+		;
+
+factor 	: 	LPARENTHESE expression RPARENTHESE {$$ = node( "factor", 3, $1, $2, $3);}
+		|	var {$$ = node( "factor", 1, $1);}
+		|	call {$$ = node( "factor", 1, $1);}
+		|	integer {$$ = node( "factor", 1, $1);}
+		|	float {$$ = node( "factor", 1, $1);}
+		;
+
+integer 	: 	INTEGER {$$ = node( "integer", 1, $1);}
+		;
+
+float 	: 	FLOATPOINT {$$ = node( "float", 1, $1);}
+		;
+
+call 	: 	IDENTIFIER LPARENTHESE args RPARENTHESE {$$ = node( "call", 4, $1, $2, $3, $4);}
+		;
+
+args 	: 	arg-list {$$ = node( "args", 1, $1);}
+| 	{$$ = node( "args", 0);}
+		;
+
+arg-list 	: 	arg-list COMMA expression {$$ = node( "arg-list", 3, $1, $2, $3);}
+			| 	expression {$$ = node( "arg-list", 1, $1);}
+			;
+
+
 
 %%
 

tests/1-parser/.gitignore

+output_student_ast
\ No newline at end of file

tests/3-codegen/autogen/log.txt

-==========../../testcases_general/1-return.cminus==========
-0								0
-==========../../testcases_general/2-decl_int.cminus==========
-0								0
-==========../../testcases_general/3-decl_float.cminus==========
-0								0
-==========../../testcases_general/4-decl_int_array.cminus==========
-0								0
-==========../../testcases_general/5-decl_float_array.cminus==========
-0								0
-==========../../testcases_general/6-num_add_int.cminus==========
-210								210
-==========../../testcases_general/7-assign_int_var_local.cminus==========
-210								210
-==========../../testcases_general/8-assign_int_array_local.cminus==========
-210								210
-==========../../testcases_general/9-assign_cast.cminus==========
-5								5
-==========../../testcases_general/10-funcall.cminus==========
-0								0
-==========../../testcases_general/11-funcall_chain.cminus==========
-210								210
-==========../../testcases_general/12-funcall_recursion.cminus==========
-0								0
-==========../../testcases_general/13-if_stmt.cminus==========
-0								0
-==========../../testcases_general/14-while_stmt.cminus==========
-0								0
-==========../../testcases_general/15-if_while.cminus==========
-45								45
-==========../../testcases_general/16-if_chain.cminus==========
-3								3
-==========../../testcases_general/17-while_chain.cminus==========
-0								0
-==========../../testcases_general/18-global_var.cminus==========
-10								10
-==========../../testcases_general/19-global_local_var.cminus==========
-20								20
-==========../../testcases_general/20-gcd_array.cminus==========
-18								18
-==========../../testcases_general/21-comment.cminus==========
-0								0

tests/3-codegen/autogen/output/0-io.ll

-; ModuleID = 'cminus'
-source_filename = "/code/compiler/24.ta/tests/3-codegen/autogen/testcases/0-io.cminus"
-
-declare i32 @input()
-
-declare void @output(i32)
-
-declare void @outputFloat(float)
-
-declare void @neg_idx_except()
-
-define i32 @main() {
-label_entry:
-  %op0 = call i32 @input()
-  call void @output(i32 %op0)
-  ret i32 0
-}

tests/3-codegen/autogen/output/0-io.out

-1234
-0

tests/3-codegen/autogen/output/0-io.s

-	.text
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -32
-.main_label_entry:
-# %op0 = call i32 @input()
-	bl input
-	st.w $a0, $fp, -20
-# call void @output(i32 %op0)
-	ld.w $a0, $fp, -20
-	bl output
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 32
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/1-return.ll

-; ModuleID = 'cminus'
-source_filename = "/code/compiler/24.ta/tests/3-codegen/autogen/testcases/1-return.cminus"
-
-declare i32 @input()
-
-declare void @output(i32)
-
-declare void @outputFloat(float)
-
-declare void @neg_idx_except()
-
-define i32 @main() {
-label_entry:
-  call void @output(i32 111)
-  ret i32 111
-}

tests/3-codegen/autogen/output/1-return.out

-0

tests/3-codegen/autogen/output/1-return.s

-	.text
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -16
-.main_label_entry:
-# ret void
-	addi.w $a0, $zero, 0
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 16
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/10-float.ll

-; ModuleID = 'cminus'
-source_filename = "/code/compiler/24.ta/tests/3-codegen/autogen/testcases/10-float.cminus"
-
-declare i32 @input()
-
-declare void @output(i32)
-
-declare void @outputFloat(float)
-
-declare void @neg_idx_except()
-
-define i32 @main() {
-label_entry:
-  %op0 = alloca float
-  %op1 = alloca float
-  %op2 = alloca float
-  store float 0x3ff19999a0000000, float* %op0
-  store float 0x3ff8000000000000, float* %op1
-  store float 0x3ff3333340000000, float* %op2
-  %op3 = load float, float* %op0
-  %op4 = load float, float* %op1
-  %op5 = fmul float %op3, %op4
-  %op6 = load float, float* %op2
-  %op7 = fadd float %op5, %op6
-  call void @outputFloat(float %op7)
-  ret i32 0
-}

tests/3-codegen/autogen/output/10-float.out

-2.850000
-0

tests/3-codegen/autogen/output/10-float.s

-	.text
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -80
-.main_label_entry:
-# %op0 = alloca float
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# %op1 = alloca float
-	addi.d $t0, $fp, -40
-	st.d $t0, $fp, -36
-# %op2 = alloca float
-	addi.d $t0, $fp, -52
-	st.d $t0, $fp, -48
-# store float 0x3ff19999a0000000, float* %op0
-	ld.d $t0, $fp, -24
-	lu12i.w $t8, 260300
-	ori $t8, $t8, 3277
-	movgr2fr.w $ft0, $t8
-	fst.s $ft0, $t0, 0
-# store float 0x3ff8000000000000, float* %op1
-	ld.d $t0, $fp, -36
-	lu12i.w $t8, 261120
-	ori $t8, $t8, 0
-	movgr2fr.w $ft0, $t8
-	fst.s $ft0, $t0, 0
-# store float 0x3ff3333340000000, float* %op2
-	ld.d $t0, $fp, -48
-	lu12i.w $t8, 260505
-	ori $t8, $t8, 2458
-	movgr2fr.w $ft0, $t8
-	fst.s $ft0, $t0, 0
-# %op3 = load float, float* %op0
-	ld.d $t0, $fp, -24
-	fld.s $ft0, $t0, 0
-	fst.s $ft0, $fp, -56
-# %op4 = load float, float* %op1
-	ld.d $t0, $fp, -36
-	fld.s $ft0, $t0, 0
-	fst.s $ft0, $fp, -60
-# %op5 = fmul float %op3, %op4
-	fld.s $ft0, $fp, -56
-	fld.s $ft1, $fp, -60
-	fmul.s $ft2, $ft0, $ft1
-	fst.s $ft2, $fp, -64
-# %op6 = load float, float* %op2
-	ld.d $t0, $fp, -48
-	fld.s $ft0, $t0, 0
-	fst.s $ft0, $fp, -68
-# %op7 = fadd float %op5, %op6
-	fld.s $ft0, $fp, -64
-	fld.s $ft1, $fp, -68
-	fadd.s $ft2, $ft0, $ft1
-	fst.s $ft2, $fp, -72
-# call void @outputFloat(float %op7)
-	fld.s $fa0, $fp, -72
-	bl outputFloat
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 80
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/10-funcall.out

-0

tests/3-codegen/autogen/output/10-funcall.s

-	.text
-	.globl test
-	.type test, @function
-test:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -32
-	st.w $a0, $fp, -20
-.test_label_entry:
-# %op1 = alloca i32
-	addi.d $t0, $fp, -32
-	st.d $t0, $fp, -28
-# store i32 %arg0, i32* %op1
-	ld.d $t0, $fp, -28
-	ld.w $t1, $fp, -20
-	st.w $t1, $t0, 0
-# ret void
-	addi.w $a0, $zero, 0
-	b test_exit
-test_exit:
-	addi.d $sp, $sp, 32
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -32
-.main_label_entry:
-# %op0 = alloca i32
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# store i32 10, i32* %op0
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 10
-	st.w $t1, $t0, 0
-# %op1 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -32
-# call void @test(i32 %op1)
-	ld.w $a0, $fp, -32
-	bl test
-# ret void
-	addi.w $a0, $zero, 0
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 32
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/11-floatcall.ll

-; ModuleID = 'cminus'
-source_filename = "/code/compiler/24.ta/tests/3-codegen/autogen/testcases/11-floatcall.cminus"
-
-declare i32 @input()
-
-declare void @output(i32)
-
-declare void @outputFloat(float)
-
-declare void @neg_idx_except()
-
-define float @mod(float %arg0, float %arg1) {
-label_entry:
-  %op2 = alloca float
-  store float %arg0, float* %op2
-  %op3 = alloca float
-  store float %arg1, float* %op3
-  %op4 = alloca i32
-  %op5 = load float, float* %op2
-  %op6 = load float, float* %op3
-  %op7 = fdiv float %op5, %op6
-  %op8 = fptosi float %op7 to i32
-  store i32 %op8, i32* %op4
-  %op9 = load float, float* %op2
-  %op10 = load i32, i32* %op4
-  %op11 = load float, float* %op3
-  %op12 = sitofp i32 %op10 to float
-  %op13 = fmul float %op12, %op11
-  %op14 = fsub float %op9, %op13
-  ret float %op14
-}
-define i32 @main() {
-label_entry:
-  %op0 = alloca float
-  %op1 = alloca float
-  store float 0x4026666660000000, float* %op0
-  store float 0x40019999a0000000, float* %op1
-  %op2 = load float, float* %op0
-  %op3 = load float, float* %op1
-  %op4 = call float @mod(float %op2, float %op3)
-  call void @outputFloat(float %op4)
-  ret i32 0
-}

tests/3-codegen/autogen/output/11-floatcall.out

-0.200000
-0

tests/3-codegen/autogen/output/11-floatcall.s

-	.text
-	.globl mod
-	.type mod, @function
-mod:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -112
-	fst.s $fa0, $fp, -20
-	fst.s $fa1, $fp, -24
-.mod_label_entry:
-# %op2 = alloca float
-	addi.d $t0, $fp, -36
-	st.d $t0, $fp, -32
-# store float %arg0, float* %op2
-	ld.d $t0, $fp, -32
-	fld.s $ft0, $fp, -20
-	fst.s $ft0, $t0, 0
-# %op3 = alloca float
-	addi.d $t0, $fp, -48
-	st.d $t0, $fp, -44
-# store float %arg1, float* %op3
-	ld.d $t0, $fp, -44
-	fld.s $ft0, $fp, -24
-	fst.s $ft0, $t0, 0
-# %op4 = alloca i32
-	addi.d $t0, $fp, -60
-	st.d $t0, $fp, -56
-# %op5 = load float, float* %op2
-	ld.d $t0, $fp, -32
-	fld.s $ft0, $t0, 0
-	fst.s $ft0, $fp, -64
-# %op6 = load float, float* %op3
-	ld.d $t0, $fp, -44
-	fld.s $ft0, $t0, 0
-	fst.s $ft0, $fp, -68
-# %op7 = fdiv float %op5, %op6
-	fld.s $ft0, $fp, -64
-	fld.s $ft1, $fp, -68
-	fdiv.s $ft2, $ft0, $ft1
-	fst.s $ft2, $fp, -72
-# %op8 = fptosi float %op7 to i32
-	fld.s $ft0, $fp, -72
-	ftintrz.w.s $ft0, $ft0
-	movfr2gr.s $t0, $ft0
-	st.w $t0, $fp, -76
-# store i32 %op8, i32* %op4
-	ld.d $t0, $fp, -56
-	ld.w $t1, $fp, -76
-	st.w $t1, $t0, 0
-# %op9 = load float, float* %op2
-	ld.d $t0, $fp, -32
-	fld.s $ft0, $t0, 0
-	fst.s $ft0, $fp, -80
-# %op10 = load i32, i32* %op4
-	ld.d $t0, $fp, -56
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -84
-# %op11 = load float, float* %op3
-	ld.d $t0, $fp, -44
-	fld.s $ft0, $t0, 0
-	fst.s $ft0, $fp, -88
-# %op12 = sitofp i32 %op10 to float
-	ld.w $t0, $fp, -84
-	movgr2fr.w $ft0, $t0
-	ffint.s.w $ft0, $ft0
-	fst.s $ft0, $fp, -92
-# %op13 = fmul float %op12, %op11
-	fld.s $ft0, $fp, -92
-	fld.s $ft1, $fp, -88
-	fmul.s $ft2, $ft0, $ft1
-	fst.s $ft2, $fp, -96
-# %op14 = fsub float %op9, %op13
-	fld.s $ft0, $fp, -80
-	fld.s $ft1, $fp, -96
-	fsub.s $ft2, $ft0, $ft1
-	fst.s $ft2, $fp, -100
-# ret float %op14
-	fld.s $fa0, $fp, -100
-	b mod_exit
-mod_exit:
-	addi.d $sp, $sp, 112
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -64
-.main_label_entry:
-# %op0 = alloca float
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# %op1 = alloca float
-	addi.d $t0, $fp, -40
-	st.d $t0, $fp, -36
-# store float 0x4026666660000000, float* %op0
-	ld.d $t0, $fp, -24
-	lu12i.w $t8, 267059
-	ori $t8, $t8, 819
-	movgr2fr.w $ft0, $t8
-	fst.s $ft0, $t0, 0
-# store float 0x40019999a0000000, float* %op1
-	ld.d $t0, $fp, -36
-	lu12i.w $t8, 262348
-	ori $t8, $t8, 3277
-	movgr2fr.w $ft0, $t8
-	fst.s $ft0, $t0, 0
-# %op2 = load float, float* %op0
-	ld.d $t0, $fp, -24
-	fld.s $ft0, $t0, 0
-	fst.s $ft0, $fp, -44
-# %op3 = load float, float* %op1
-	ld.d $t0, $fp, -36
-	fld.s $ft0, $t0, 0
-	fst.s $ft0, $fp, -48
-# %op4 = call float @mod(float %op2, float %op3)
-	fld.s $fa0, $fp, -44
-	fld.s $fa1, $fp, -48
-	bl mod
-	fst.s $fa0, $fp, -52
-# call void @outputFloat(float %op4)
-	fld.s $fa0, $fp, -52
-	bl outputFloat
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 64
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/11-funcall_chain.out

-210

tests/3-codegen/autogen/output/11-funcall_chain.s

-	.text
-	.globl addone
-	.type addone, @function
-addone:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -48
-	st.w $a0, $fp, -20
-.addone_label_entry:
-# %op1 = alloca i32
-	addi.d $t0, $fp, -32
-	st.d $t0, $fp, -28
-# store i32 %arg0, i32* %op1
-	ld.d $t0, $fp, -28
-	ld.w $t1, $fp, -20
-	st.w $t1, $t0, 0
-# %op2 = load i32, i32* %op1
-	ld.d $t0, $fp, -28
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -36
-# %op3 = add i32 %op2, 1
-	ld.w $t0, $fp, -36
-	addi.w $t1, $zero, 1
-	add.w $t2, $t0, $t1
-	st.w $t2, $fp, -40
-# ret i32 %op3
-	ld.w $a0, $fp, -40
-	b addone_exit
-addone_exit:
-	addi.d $sp, $sp, 48
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -48
-.main_label_entry:
-# %op0 = alloca i32
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# %op1 = call i32 @addone(i32 1230)
-	addi.w $a0, $zero, 1230
-	bl addone
-	st.w $a0, $fp, -32
-# %op2 = call i32 @addone(i32 %op1)
-	ld.w $a0, $fp, -32
-	bl addone
-	st.w $a0, $fp, -36
-# %op3 = call i32 @addone(i32 %op2)
-	ld.w $a0, $fp, -36
-	bl addone
-	st.w $a0, $fp, -40
-# %op4 = call i32 @addone(i32 %op3)
-	ld.w $a0, $fp, -40
-	bl addone
-	st.w $a0, $fp, -44
-# store i32 %op4, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t1, $fp, -44
-	st.w $t1, $t0, 0
-# %op5 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -48
-# ret i32 %op5
-	ld.w $a0, $fp, -48
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 48
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/12-funcall_recursion.out

-0

tests/3-codegen/autogen/output/12-funcall_recursion.s

-	.text
-	.globl factorial
-	.type factorial, @function
-factorial:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -64
-	st.w $a0, $fp, -20
-.factorial_label_entry:
-# %op1 = alloca i32
-	addi.d $t0, $fp, -32
-	st.d $t0, $fp, -28
-# store i32 %arg0, i32* %op1
-	ld.d $t0, $fp, -28
-	ld.w $t1, $fp, -20
-	st.w $t1, $t0, 0
-# %op2 = load i32, i32* %op1
-	ld.d $t0, $fp, -28
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -36
-# %op3 = icmp eq i32 %op2, 0
-	ld.w $t0, $fp, -36
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltui $t2, $t2, 1
-	st.b $t2, $fp, -37
-# %op4 = zext i1 %op3 to i32
-	ld.b $t0, $fp, -37
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -41
-# %op5 = icmp ne i32 %op4, 0
-	ld.w $t0, $fp, -41
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -42
-# br i1 %op5, label %label6, label %label8
-	ld.b $t0, $fp, -42
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .factorial_label6
-	b .factorial_label8
-.factorial_label6:
-# ret i32 1
-	addi.w $a0, $zero, 1
-	b factorial_exit
-.factorial_label7:
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b factorial_exit
-.factorial_label8:
-# %op9 = load i32, i32* %op1
-	ld.d $t0, $fp, -28
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -46
-# %op10 = load i32, i32* %op1
-	ld.d $t0, $fp, -28
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -50
-# %op11 = sub i32 %op10, 1
-	ld.w $t0, $fp, -50
-	addi.w $t1, $zero, 1
-	sub.w $t2, $t0, $t1
-	st.w $t2, $fp, -54
-# %op12 = call i32 @factorial(i32 %op11)
-	ld.w $a0, $fp, -54
-	bl factorial
-	st.w $a0, $fp, -58
-# %op13 = mul i32 %op9, %op12
-	ld.w $t0, $fp, -46
-	ld.w $t1, $fp, -58
-	mul.w $t2, $t0, $t1
-	st.w $t2, $fp, -62
-# ret i32 %op13
-	ld.w $a0, $fp, -62
-	b factorial_exit
-factorial_exit:
-	addi.d $sp, $sp, 64
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -48
-.main_label_entry:
-# %op0 = alloca i32
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# %op1 = call i32 @factorial(i32 10)
-	addi.w $a0, $zero, 10
-	bl factorial
-	st.w $a0, $fp, -32
-# store i32 %op1, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t1, $fp, -32
-	st.w $t1, $t0, 0
-# %op2 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -36
-# ret i32 %op2
-	ld.w $a0, $fp, -36
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 48
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/12-global.ll

-; ModuleID = 'cminus'
-source_filename = "/code/compiler/24.ta/tests/3-codegen/autogen/testcases/12-global.cminus"
-
-@seed = global i32 zeroinitializer
-declare i32 @input()
-
-declare void @output(i32)
-
-declare void @outputFloat(float)
-
-declare void @neg_idx_except()
-
-define i32 @randomLCG() {
-label_entry:
-  %op0 = load i32, i32* @seed
-  %op1 = mul i32 %op0, 1103515245
-  %op2 = add i32 %op1, 12345
-  store i32 %op2, i32* @seed
-  %op3 = load i32, i32* @seed
-  ret i32 %op3
-}
-define i32 @randBin() {
-label_entry:
-  %op0 = call i32 @randomLCG()
-  %op1 = icmp sgt i32 %op0, 0
-  %op2 = zext i1 %op1 to i32
-  %op3 = icmp ne i32 %op2, 0
-  br i1 %op3, label %label4, label %label6
-label4:                                                ; preds = %label_entry
-  ret i32 1
-label5:
-  ret i32 0
-label6:                                                ; preds = %label_entry
-  ret i32 0
-}
-define i32 @returnToZeroSteps() {
-label_entry:
-  %op0 = alloca i32
-  %op1 = alloca i32
-  store i32 0, i32* %op0
-  store i32 0, i32* %op1
-  br label %label2
-label2:                                                ; preds = %label_entry, %label26
-  %op3 = load i32, i32* %op1
-  %op4 = icmp slt i32 %op3, 20
-  %op5 = zext i1 %op4 to i32
-  %op6 = icmp ne i32 %op5, 0
-  br i1 %op6, label %label7, label %label10
-label7:                                                ; preds = %label2
-  %op8 = call i32 @randBin()
-  %op9 = icmp ne i32 %op8, 0
-  br i1 %op9, label %label11, label %label21
-label10:                                                ; preds = %label2
-  ret i32 20
-label11:                                                ; preds = %label7
-  %op12 = load i32, i32* %op0
-  %op13 = add i32 %op12, 1
-  store i32 %op13, i32* %op0
-  br label %label14
-label14:                                                ; preds = %label11, %label21
-  %op15 = load i32, i32* %op1
-  %op16 = add i32 %op15, 1
-  store i32 %op16, i32* %op1
-  %op17 = load i32, i32* %op0
-  %op18 = icmp eq i32 %op17, 0
-  %op19 = zext i1 %op18 to i32
-  %op20 = icmp ne i32 %op19, 0
-  br i1 %op20, label %label24, label %label26
-label21:                                                ; preds = %label7
-  %op22 = load i32, i32* %op0
-  %op23 = sub i32 %op22, 1
-  store i32 %op23, i32* %op0
-  br label %label14
-label24:                                                ; preds = %label14
-  %op25 = load i32, i32* %op1
-  ret i32 %op25
-label26:                                                ; preds = %label14
-  br label %label2
-}
-define i32 @main() {
-label_entry:
-  %op0 = alloca i32
-  store i32 0, i32* %op0
-  store i32 3407, i32* @seed
-  br label %label1
-label1:                                                ; preds = %label_entry, %label6
-  %op2 = load i32, i32* %op0
-  %op3 = icmp slt i32 %op2, 20
-  %op4 = zext i1 %op3 to i32
-  %op5 = icmp ne i32 %op4, 0
-  br i1 %op5, label %label6, label %label10
-label6:                                                ; preds = %label1
-  %op7 = call i32 @returnToZeroSteps()
-  call void @output(i32 %op7)
-  %op8 = load i32, i32* %op0
-  %op9 = add i32 %op8, 1
-  store i32 %op9, i32* %op0
-  br label %label1
-label10:                                                ; preds = %label1
-  ret i32 0
-}

tests/3-codegen/autogen/output/12-global.out

-4
-2
-2
-4
-8
-2
-2
-2
-2
-2
-6
-2
-10
-8
-4
-2
-20
-2
-2
-8
-0

tests/3-codegen/autogen/output/12-global.s

-# Global variables
-	.text
-	.section .bss, "aw", @nobits
-	.globl seed
-	.type seed, @object
-	.size seed, 4
-seed:
-	.space 4
-	.text
-	.globl randomLCG
-	.type randomLCG, @function
-randomLCG:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -32
-.randomLCG_label_entry:
-# %op0 = load i32, i32* @seed
-	la.local $t0, seed
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -20
-# %op1 = mul i32 %op0, 1103515245
-	ld.w $t0, $fp, -20
-	lu12i.w $t1, 269412
-	ori $t1, $t1, 3693
-	mul.w $t2, $t0, $t1
-	st.w $t2, $fp, -24
-# %op2 = add i32 %op1, 12345
-	ld.w $t0, $fp, -24
-	lu12i.w $t1, 3
-	ori $t1, $t1, 57
-	add.w $t2, $t0, $t1
-	st.w $t2, $fp, -28
-# store i32 %op2, i32* @seed
-	la.local $t0, seed
-	ld.w $t1, $fp, -28
-	st.w $t1, $t0, 0
-# %op3 = load i32, i32* @seed
-	la.local $t0, seed
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -32
-# ret i32 %op3
-	ld.w $a0, $fp, -32
-	b randomLCG_exit
-randomLCG_exit:
-	addi.d $sp, $sp, 32
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra
-	.globl randBin
-	.type randBin, @function
-randBin:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -32
-.randBin_label_entry:
-# %op0 = call i32 @randomLCG()
-	bl randomLCG
-	st.w $a0, $fp, -20
-# %op1 = icmp sgt i32 %op0, 0
-	ld.w $t0, $fp, -20
-	addi.w $t1, $zero, 0
-	slt $t2, $t1, $t0
-	st.b $t2, $fp, -21
-# %op2 = zext i1 %op1 to i32
-	ld.b $t0, $fp, -21
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -25
-# %op3 = icmp ne i32 %op2, 0
-	ld.w $t0, $fp, -25
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -26
-# br i1 %op3, label %label4, label %label6
-	ld.b $t0, $fp, -26
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .randBin_label4
-	b .randBin_label6
-.randBin_label4:
-# ret i32 1
-	addi.w $a0, $zero, 1
-	b randBin_exit
-.randBin_label5:
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b randBin_exit
-.randBin_label6:
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b randBin_exit
-randBin_exit:
-	addi.d $sp, $sp, 32
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra
-	.globl returnToZeroSteps
-	.type returnToZeroSteps, @function
-returnToZeroSteps:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -96
-.returnToZeroSteps_label_entry:
-# %op0 = alloca i32
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# %op1 = alloca i32
-	addi.d $t0, $fp, -40
-	st.d $t0, $fp, -36
-# store i32 0, i32* %op0
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 0
-	st.w $t1, $t0, 0
-# store i32 0, i32* %op1
-	ld.d $t0, $fp, -36
-	addi.w $t1, $zero, 0
-	st.w $t1, $t0, 0
-# br label %label2
-	b .returnToZeroSteps_label2
-.returnToZeroSteps_label2:
-# %op3 = load i32, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -44
-# %op4 = icmp slt i32 %op3, 20
-	ld.w $t0, $fp, -44
-	addi.w $t1, $zero, 20
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -45
-# %op5 = zext i1 %op4 to i32
-	ld.b $t0, $fp, -45
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -49
-# %op6 = icmp ne i32 %op5, 0
-	ld.w $t0, $fp, -49
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -50
-# br i1 %op6, label %label7, label %label10
-	ld.b $t0, $fp, -50
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .returnToZeroSteps_label7
-	b .returnToZeroSteps_label10
-.returnToZeroSteps_label7:
-# %op8 = call i32 @randBin()
-	bl randBin
-	st.w $a0, $fp, -54
-# %op9 = icmp ne i32 %op8, 0
-	ld.w $t0, $fp, -54
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -55
-# br i1 %op9, label %label11, label %label21
-	ld.b $t0, $fp, -55
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .returnToZeroSteps_label11
-	b .returnToZeroSteps_label21
-.returnToZeroSteps_label10:
-# ret i32 20
-	addi.w $a0, $zero, 20
-	b returnToZeroSteps_exit
-.returnToZeroSteps_label11:
-# %op12 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -59
-# %op13 = add i32 %op12, 1
-	ld.w $t0, $fp, -59
-	addi.w $t1, $zero, 1
-	add.w $t2, $t0, $t1
-	st.w $t2, $fp, -63
-# store i32 %op13, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t1, $fp, -63
-	st.w $t1, $t0, 0
-# br label %label14
-	b .returnToZeroSteps_label14
-.returnToZeroSteps_label14:
-# %op15 = load i32, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -67
-# %op16 = add i32 %op15, 1
-	ld.w $t0, $fp, -67
-	addi.w $t1, $zero, 1
-	add.w $t2, $t0, $t1
-	st.w $t2, $fp, -71
-# store i32 %op16, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t1, $fp, -71
-	st.w $t1, $t0, 0
-# %op17 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -75
-# %op18 = icmp eq i32 %op17, 0
-	ld.w $t0, $fp, -75
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltui $t2, $t2, 1
-	st.b $t2, $fp, -76
-# %op19 = zext i1 %op18 to i32
-	ld.b $t0, $fp, -76
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -80
-# %op20 = icmp ne i32 %op19, 0
-	ld.w $t0, $fp, -80
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -81
-# br i1 %op20, label %label24, label %label26
-	ld.b $t0, $fp, -81
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .returnToZeroSteps_label24
-	b .returnToZeroSteps_label26
-.returnToZeroSteps_label21:
-# %op22 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -85
-# %op23 = sub i32 %op22, 1
-	ld.w $t0, $fp, -85
-	addi.w $t1, $zero, 1
-	sub.w $t2, $t0, $t1
-	st.w $t2, $fp, -89
-# store i32 %op23, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t1, $fp, -89
-	st.w $t1, $t0, 0
-# br label %label14
-	b .returnToZeroSteps_label14
-.returnToZeroSteps_label24:
-# %op25 = load i32, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -93
-# ret i32 %op25
-	ld.w $a0, $fp, -93
-	b returnToZeroSteps_exit
-.returnToZeroSteps_label26:
-# br label %label2
-	b .returnToZeroSteps_label2
-returnToZeroSteps_exit:
-	addi.d $sp, $sp, 96
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -64
-.main_label_entry:
-# %op0 = alloca i32
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# store i32 0, i32* %op0
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 0
-	st.w $t1, $t0, 0
-# store i32 3407, i32* @seed
-	la.local $t0, seed
-	lu12i.w $t1, 0
-	ori $t1, $t1, 3407
-	st.w $t1, $t0, 0
-# br label %label1
-	b .main_label1
-.main_label1:
-# %op2 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -32
-# %op3 = icmp slt i32 %op2, 20
-	ld.w $t0, $fp, -32
-	addi.w $t1, $zero, 20
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -33
-# %op4 = zext i1 %op3 to i32
-	ld.b $t0, $fp, -33
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -37
-# %op5 = icmp ne i32 %op4, 0
-	ld.w $t0, $fp, -37
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -38
-# br i1 %op5, label %label6, label %label10
-	ld.b $t0, $fp, -38
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label6
-	b .main_label10
-.main_label6:
-# %op7 = call i32 @returnToZeroSteps()
-	bl returnToZeroSteps
-	st.w $a0, $fp, -42
-# call void @output(i32 %op7)
-	ld.w $a0, $fp, -42
-	bl output
-# %op8 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -46
-# %op9 = add i32 %op8, 1
-	ld.w $t0, $fp, -46
-	addi.w $t1, $zero, 1
-	add.w $t2, $t0, $t1
-	st.w $t2, $fp, -50
-# store i32 %op9, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t1, $fp, -50
-	st.w $t1, $t0, 0
-# br label %label1
-	b .main_label1
-.main_label10:
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 64
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/13-complex.ll

-; ModuleID = 'cminus'
-source_filename = "/code/compiler/24.ta/tests/3-codegen/autogen/testcases/13-complex.cminus"
-
-@n = global i32 zeroinitializer
-@m = global i32 zeroinitializer
-@w = global [5 x i32] zeroinitializer
-@v = global [5 x i32] zeroinitializer
-@dp = global [66 x i32] zeroinitializer
-declare i32 @input()
-
-declare void @output(i32)
-
-declare void @outputFloat(float)
-
-declare void @neg_idx_except()
-
-define i32 @max(i32 %arg0, i32 %arg1) {
-label_entry:
-  %op2 = alloca i32
-  store i32 %arg0, i32* %op2
-  %op3 = alloca i32
-  store i32 %arg1, i32* %op3
-  %op4 = load i32, i32* %op2
-  %op5 = load i32, i32* %op3
-  %op6 = icmp sgt i32 %op4, %op5
-  %op7 = zext i1 %op6 to i32
-  %op8 = icmp ne i32 %op7, 0
-  br i1 %op8, label %label9, label %label12
-label9:                                                ; preds = %label_entry
-  %op10 = load i32, i32* %op2
-  ret i32 %op10
-label11:
-  ret i32 0
-label12:                                                ; preds = %label_entry
-  %op13 = load i32, i32* %op3
-  ret i32 %op13
-}
-define i32 @knapsack(i32 %arg0, i32 %arg1) {
-label_entry:
-  %op2 = alloca i32
-  store i32 %arg0, i32* %op2
-  %op3 = alloca i32
-  store i32 %arg1, i32* %op3
-  %op4 = alloca i32
-  %op5 = load i32, i32* %op3
-  %op6 = icmp sle i32 %op5, 0
-  %op7 = zext i1 %op6 to i32
-  %op8 = icmp ne i32 %op7, 0
-  br i1 %op8, label %label9, label %label10
-label9:                                                ; preds = %label_entry
-  ret i32 0
-label10:                                                ; preds = %label_entry
-  %op11 = load i32, i32* %op2
-  %op12 = icmp eq i32 %op11, 0
-  %op13 = zext i1 %op12 to i32
-  %op14 = icmp ne i32 %op13, 0
-  br i1 %op14, label %label15, label %label16
-label15:                                                ; preds = %label10
-  ret i32 0
-label16:                                                ; preds = %label10
-  %op17 = load i32, i32* %op2
-  %op18 = mul i32 %op17, 11
-  %op19 = load i32, i32* %op3
-  %op20 = add i32 %op18, %op19
-  %op21 = icmp slt i32 %op20, 0
-  br i1 %op21, label %label22, label %label23
-label22:                                                ; preds = %label16
-  call void @neg_idx_except()
-  ret i32 0
-label23:                                                ; preds = %label16
-  %op24 = getelementptr [66 x i32], [66 x i32]* @dp, i32 0, i32 %op20
-  %op25 = load i32, i32* %op24
-  %op26 = icmp sge i32 %op25, 0
-  %op27 = zext i1 %op26 to i32
-  %op28 = icmp ne i32 %op27, 0
-  br i1 %op28, label %label29, label %label35
-label29:                                                ; preds = %label23
-  %op30 = load i32, i32* %op2
-  %op31 = mul i32 %op30, 11
-  %op32 = load i32, i32* %op3
-  %op33 = add i32 %op31, %op32
-  %op34 = icmp slt i32 %op33, 0
-  br i1 %op34, label %label40, label %label41
-label35:                                                ; preds = %label23
-  %op36 = load i32, i32* %op3
-  %op37 = load i32, i32* %op2
-  %op38 = sub i32 %op37, 1
-  %op39 = icmp slt i32 %op38, 0
-  br i1 %op39, label %label44, label %label45
-label40:                                                ; preds = %label29
-  call void @neg_idx_except()
-  ret i32 0
-label41:                                                ; preds = %label29
-  %op42 = getelementptr [66 x i32], [66 x i32]* @dp, i32 0, i32 %op33
-  %op43 = load i32, i32* %op42
-  ret i32 %op43
-label44:                                                ; preds = %label35
-  call void @neg_idx_except()
-  ret i32 0
-label45:                                                ; preds = %label35
-  %op46 = getelementptr [5 x i32], [5 x i32]* @w, i32 0, i32 %op38
-  %op47 = load i32, i32* %op46
-  %op48 = icmp slt i32 %op36, %op47
-  %op49 = zext i1 %op48 to i32
-  %op50 = icmp ne i32 %op49, 0
-  br i1 %op50, label %label51, label %label63
-label51:                                                ; preds = %label45
-  %op52 = load i32, i32* %op2
-  %op53 = sub i32 %op52, 1
-  %op54 = load i32, i32* %op3
-  %op55 = call i32 @knapsack(i32 %op53, i32 %op54)
-  store i32 %op55, i32* %op4
-  br label %label56
-label56:                                                ; preds = %label51, %label84
-  %op57 = load i32, i32* %op4
-  %op58 = load i32, i32* %op2
-  %op59 = mul i32 %op58, 11
-  %op60 = load i32, i32* %op3
-  %op61 = add i32 %op59, %op60
-  %op62 = icmp slt i32 %op61, 0
-  br i1 %op62, label %label89, label %label90
-label63:                                                ; preds = %label45
-  %op64 = load i32, i32* %op2
-  %op65 = sub i32 %op64, 1
-  %op66 = load i32, i32* %op3
-  %op67 = call i32 @knapsack(i32 %op65, i32 %op66)
-  %op68 = load i32, i32* %op2
-  %op69 = sub i32 %op68, 1
-  %op70 = load i32, i32* %op3
-  %op71 = load i32, i32* %op2
-  %op72 = sub i32 %op71, 1
-  %op73 = icmp slt i32 %op72, 0
-  br i1 %op73, label %label74, label %label75
-label74:                                                ; preds = %label63
-  call void @neg_idx_except()
-  ret i32 0
-label75:                                                ; preds = %label63
-  %op76 = getelementptr [5 x i32], [5 x i32]* @w, i32 0, i32 %op72
-  %op77 = load i32, i32* %op76
-  %op78 = sub i32 %op70, %op77
-  %op79 = call i32 @knapsack(i32 %op69, i32 %op78)
-  %op80 = load i32, i32* %op2
-  %op81 = sub i32 %op80, 1
-  %op82 = icmp slt i32 %op81, 0
-  br i1 %op82, label %label83, label %label84
-label83:                                                ; preds = %label75
-  call void @neg_idx_except()
-  ret i32 0
-label84:                                                ; preds = %label75
-  %op85 = getelementptr [5 x i32], [5 x i32]* @v, i32 0, i32 %op81
-  %op86 = load i32, i32* %op85
-  %op87 = add i32 %op79, %op86
-  %op88 = call i32 @max(i32 %op67, i32 %op87)
-  store i32 %op88, i32* %op4
-  br label %label56
-label89:                                                ; preds = %label56
-  call void @neg_idx_except()
-  ret i32 0
-label90:                                                ; preds = %label56
-  %op91 = getelementptr [66 x i32], [66 x i32]* @dp, i32 0, i32 %op61
-  store i32 %op57, i32* %op91
-  %op92 = load i32, i32* %op4
-  ret i32 %op92
-}
-define i32 @main() {
-label_entry:
-  %op0 = alloca i32
-  store i32 0, i32* %op0
-  store i32 5, i32* @n
-  store i32 10, i32* @m
-  %op1 = icmp slt i32 0, 0
-  br i1 %op1, label %label2, label %label3
-label2:                                                ; preds = %label_entry
-  call void @neg_idx_except()
-  ret i32 0
-label3:                                                ; preds = %label_entry
-  %op4 = getelementptr [5 x i32], [5 x i32]* @w, i32 0, i32 0
-  store i32 2, i32* %op4
-  %op5 = icmp slt i32 1, 0
-  br i1 %op5, label %label6, label %label7
-label6:                                                ; preds = %label3
-  call void @neg_idx_except()
-  ret i32 0
-label7:                                                ; preds = %label3
-  %op8 = getelementptr [5 x i32], [5 x i32]* @w, i32 0, i32 1
-  store i32 2, i32* %op8
-  %op9 = icmp slt i32 2, 0
-  br i1 %op9, label %label10, label %label11
-label10:                                                ; preds = %label7
-  call void @neg_idx_except()
-  ret i32 0
-label11:                                                ; preds = %label7
-  %op12 = getelementptr [5 x i32], [5 x i32]* @w, i32 0, i32 2
-  store i32 6, i32* %op12
-  %op13 = icmp slt i32 3, 0
-  br i1 %op13, label %label14, label %label15
-label14:                                                ; preds = %label11
-  call void @neg_idx_except()
-  ret i32 0
-label15:                                                ; preds = %label11
-  %op16 = getelementptr [5 x i32], [5 x i32]* @w, i32 0, i32 3
-  store i32 5, i32* %op16
-  %op17 = icmp slt i32 4, 0
-  br i1 %op17, label %label18, label %label19
-label18:                                                ; preds = %label15
-  call void @neg_idx_except()
-  ret i32 0
-label19:                                                ; preds = %label15
-  %op20 = getelementptr [5 x i32], [5 x i32]* @w, i32 0, i32 4
-  store i32 4, i32* %op20
-  %op21 = icmp slt i32 0, 0
-  br i1 %op21, label %label22, label %label23
-label22:                                                ; preds = %label19
-  call void @neg_idx_except()
-  ret i32 0
-label23:                                                ; preds = %label19
-  %op24 = getelementptr [5 x i32], [5 x i32]* @v, i32 0, i32 0
-  store i32 6, i32* %op24
-  %op25 = icmp slt i32 1, 0
-  br i1 %op25, label %label26, label %label27
-label26:                                                ; preds = %label23
-  call void @neg_idx_except()
-  ret i32 0
-label27:                                                ; preds = %label23
-  %op28 = getelementptr [5 x i32], [5 x i32]* @v, i32 0, i32 1
-  store i32 3, i32* %op28
-  %op29 = icmp slt i32 2, 0
-  br i1 %op29, label %label30, label %label31
-label30:                                                ; preds = %label27
-  call void @neg_idx_except()
-  ret i32 0
-label31:                                                ; preds = %label27
-  %op32 = getelementptr [5 x i32], [5 x i32]* @v, i32 0, i32 2
-  store i32 5, i32* %op32
-  %op33 = icmp slt i32 3, 0
-  br i1 %op33, label %label34, label %label35
-label34:                                                ; preds = %label31
-  call void @neg_idx_except()
-  ret i32 0
-label35:                                                ; preds = %label31
-  %op36 = getelementptr [5 x i32], [5 x i32]* @v, i32 0, i32 3
-  store i32 4, i32* %op36
-  %op37 = icmp slt i32 4, 0
-  br i1 %op37, label %label38, label %label39
-label38:                                                ; preds = %label35
-  call void @neg_idx_except()
-  ret i32 0
-label39:                                                ; preds = %label35
-  %op40 = getelementptr [5 x i32], [5 x i32]* @v, i32 0, i32 4
-  store i32 6, i32* %op40
-  br label %label41
-label41:                                                ; preds = %label39, %label55
-  %op42 = load i32, i32* %op0
-  %op43 = icmp slt i32 %op42, 66
-  %op44 = zext i1 %op43 to i32
-  %op45 = icmp ne i32 %op44, 0
-  br i1 %op45, label %label46, label %label50
-label46:                                                ; preds = %label41
-  %op47 = sub i32 0, 1
-  %op48 = load i32, i32* %op0
-  %op49 = icmp slt i32 %op48, 0
-  br i1 %op49, label %label54, label %label55
-label50:                                                ; preds = %label41
-  %op51 = load i32, i32* @n
-  %op52 = load i32, i32* @m
-  %op53 = call i32 @knapsack(i32 %op51, i32 %op52)
-  call void @output(i32 %op53)
-  ret i32 0
-label54:                                                ; preds = %label46
-  call void @neg_idx_except()
-  ret i32 0
-label55:                                                ; preds = %label46
-  %op56 = getelementptr [66 x i32], [66 x i32]* @dp, i32 0, i32 %op48
-  store i32 %op47, i32* %op56
-  %op57 = load i32, i32* %op0
-  %op58 = add i32 %op57, 1
-  store i32 %op58, i32* %op0
-  br label %label41
-}

tests/3-codegen/autogen/output/13-complex.out

-15
-0

tests/3-codegen/autogen/output/13-complex.s

-# Global variables
-	.text
-	.section .bss, "aw", @nobits
-	.globl n
-	.type n, @object
-	.size n, 4
-n:
-	.space 4
-	.globl m
-	.type m, @object
-	.size m, 4
-m:
-	.space 4
-	.globl w
-	.type w, @object
-	.size w, 20
-w:
-	.space 20
-	.globl v
-	.type v, @object
-	.size v, 20
-v:
-	.space 20
-	.globl dp
-	.type dp, @object
-	.size dp, 264
-dp:
-	.space 264
-	.text
-	.globl max
-	.type max, @function
-max:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -80
-	st.w $a0, $fp, -20
-	st.w $a1, $fp, -24
-.max_label_entry:
-# %op2 = alloca i32
-	addi.d $t0, $fp, -36
-	st.d $t0, $fp, -32
-# store i32 %arg0, i32* %op2
-	ld.d $t0, $fp, -32
-	ld.w $t1, $fp, -20
-	st.w $t1, $t0, 0
-# %op3 = alloca i32
-	addi.d $t0, $fp, -48
-	st.d $t0, $fp, -44
-# store i32 %arg1, i32* %op3
-	ld.d $t0, $fp, -44
-	ld.w $t1, $fp, -24
-	st.w $t1, $t0, 0
-# %op4 = load i32, i32* %op2
-	ld.d $t0, $fp, -32
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -52
-# %op5 = load i32, i32* %op3
-	ld.d $t0, $fp, -44
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -56
-# %op6 = icmp sgt i32 %op4, %op5
-	ld.w $t0, $fp, -52
-	ld.w $t1, $fp, -56
-	slt $t2, $t1, $t0
-	st.b $t2, $fp, -57
-# %op7 = zext i1 %op6 to i32
-	ld.b $t0, $fp, -57
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -61
-# %op8 = icmp ne i32 %op7, 0
-	ld.w $t0, $fp, -61
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -62
-# br i1 %op8, label %label9, label %label12
-	ld.b $t0, $fp, -62
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .max_label9
-	b .max_label12
-.max_label9:
-# %op10 = load i32, i32* %op2
-	ld.d $t0, $fp, -32
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -66
-# ret i32 %op10
-	ld.w $a0, $fp, -66
-	b max_exit
-.max_label11:
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b max_exit
-.max_label12:
-# %op13 = load i32, i32* %op3
-	ld.d $t0, $fp, -44
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -70
-# ret i32 %op13
-	ld.w $a0, $fp, -70
-	b max_exit
-max_exit:
-	addi.d $sp, $sp, 80
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra
-	.globl knapsack
-	.type knapsack, @function
-knapsack:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -320
-	st.w $a0, $fp, -20
-	st.w $a1, $fp, -24
-.knapsack_label_entry:
-# %op2 = alloca i32
-	addi.d $t0, $fp, -36
-	st.d $t0, $fp, -32
-# store i32 %arg0, i32* %op2
-	ld.d $t0, $fp, -32
-	ld.w $t1, $fp, -20
-	st.w $t1, $t0, 0
-# %op3 = alloca i32
-	addi.d $t0, $fp, -48
-	st.d $t0, $fp, -44
-# store i32 %arg1, i32* %op3
-	ld.d $t0, $fp, -44
-	ld.w $t1, $fp, -24
-	st.w $t1, $t0, 0
-# %op4 = alloca i32
-	addi.d $t0, $fp, -60
-	st.d $t0, $fp, -56
-# %op5 = load i32, i32* %op3
-	ld.d $t0, $fp, -44
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -64
-# %op6 = icmp sle i32 %op5, 0
-	ld.w $t0, $fp, -64
-	addi.w $t1, $zero, 0
-	slt $t2, $t1, $t0
-	xori $t2, $t2, 1
-	st.b $t2, $fp, -65
-# %op7 = zext i1 %op6 to i32
-	ld.b $t0, $fp, -65
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -69
-# %op8 = icmp ne i32 %op7, 0
-	ld.w $t0, $fp, -69
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -70
-# br i1 %op8, label %label9, label %label10
-	ld.b $t0, $fp, -70
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .knapsack_label9
-	b .knapsack_label10
-.knapsack_label9:
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b knapsack_exit
-.knapsack_label10:
-# %op11 = load i32, i32* %op2
-	ld.d $t0, $fp, -32
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -74
-# %op12 = icmp eq i32 %op11, 0
-	ld.w $t0, $fp, -74
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltui $t2, $t2, 1
-	st.b $t2, $fp, -75
-# %op13 = zext i1 %op12 to i32
-	ld.b $t0, $fp, -75
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -79
-# %op14 = icmp ne i32 %op13, 0
-	ld.w $t0, $fp, -79
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -80
-# br i1 %op14, label %label15, label %label16
-	ld.b $t0, $fp, -80
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .knapsack_label15
-	b .knapsack_label16
-.knapsack_label15:
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b knapsack_exit
-.knapsack_label16:
-# %op17 = load i32, i32* %op2
-	ld.d $t0, $fp, -32
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -84
-# %op18 = mul i32 %op17, 11
-	ld.w $t0, $fp, -84
-	addi.w $t1, $zero, 11
-	mul.w $t2, $t0, $t1
-	st.w $t2, $fp, -88
-# %op19 = load i32, i32* %op3
-	ld.d $t0, $fp, -44
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -92
-# %op20 = add i32 %op18, %op19
-	ld.w $t0, $fp, -88
-	ld.w $t1, $fp, -92
-	add.w $t2, $t0, $t1
-	st.w $t2, $fp, -96
-# %op21 = icmp slt i32 %op20, 0
-	ld.w $t0, $fp, -96
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -97
-# br i1 %op21, label %label22, label %label23
-	ld.b $t0, $fp, -97
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .knapsack_label22
-	b .knapsack_label23
-.knapsack_label22:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b knapsack_exit
-.knapsack_label23:
-# %op24 = getelementptr [66 x i32], [66 x i32]* @dp, i32 0, i32 %op20
-	la.local $t0, dp
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 264
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	ld.w $t1, $fp, -96
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -105
-# %op25 = load i32, i32* %op24
-	ld.d $t0, $fp, -105
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -109
-# %op26 = icmp sge i32 %op25, 0
-	ld.w $t0, $fp, -109
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	xori $t2, $t2, 1
-	st.b $t2, $fp, -110
-# %op27 = zext i1 %op26 to i32
-	ld.b $t0, $fp, -110
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -114
-# %op28 = icmp ne i32 %op27, 0
-	ld.w $t0, $fp, -114
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -115
-# br i1 %op28, label %label29, label %label35
-	ld.b $t0, $fp, -115
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .knapsack_label29
-	b .knapsack_label35
-.knapsack_label29:
-# %op30 = load i32, i32* %op2
-	ld.d $t0, $fp, -32
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -119
-# %op31 = mul i32 %op30, 11
-	ld.w $t0, $fp, -119
-	addi.w $t1, $zero, 11
-	mul.w $t2, $t0, $t1
-	st.w $t2, $fp, -123
-# %op32 = load i32, i32* %op3
-	ld.d $t0, $fp, -44
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -127
-# %op33 = add i32 %op31, %op32
-	ld.w $t0, $fp, -123
-	ld.w $t1, $fp, -127
-	add.w $t2, $t0, $t1
-	st.w $t2, $fp, -131
-# %op34 = icmp slt i32 %op33, 0
-	ld.w $t0, $fp, -131
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -132
-# br i1 %op34, label %label40, label %label41
-	ld.b $t0, $fp, -132
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .knapsack_label40
-	b .knapsack_label41
-.knapsack_label35:
-# %op36 = load i32, i32* %op3
-	ld.d $t0, $fp, -44
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -136
-# %op37 = load i32, i32* %op2
-	ld.d $t0, $fp, -32
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -140
-# %op38 = sub i32 %op37, 1
-	ld.w $t0, $fp, -140
-	addi.w $t1, $zero, 1
-	sub.w $t2, $t0, $t1
-	st.w $t2, $fp, -144
-# %op39 = icmp slt i32 %op38, 0
-	ld.w $t0, $fp, -144
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -145
-# br i1 %op39, label %label44, label %label45
-	ld.b $t0, $fp, -145
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .knapsack_label44
-	b .knapsack_label45
-.knapsack_label40:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b knapsack_exit
-.knapsack_label41:
-# %op42 = getelementptr [66 x i32], [66 x i32]* @dp, i32 0, i32 %op33
-	la.local $t0, dp
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 264
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	ld.w $t1, $fp, -131
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -153
-# %op43 = load i32, i32* %op42
-	ld.d $t0, $fp, -153
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -157
-# ret i32 %op43
-	ld.w $a0, $fp, -157
-	b knapsack_exit
-.knapsack_label44:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b knapsack_exit
-.knapsack_label45:
-# %op46 = getelementptr [5 x i32], [5 x i32]* @w, i32 0, i32 %op38
-	la.local $t0, w
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 20
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	ld.w $t1, $fp, -144
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -165
-# %op47 = load i32, i32* %op46
-	ld.d $t0, $fp, -165
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -169
-# %op48 = icmp slt i32 %op36, %op47
-	ld.w $t0, $fp, -136
-	ld.w $t1, $fp, -169
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -170
-# %op49 = zext i1 %op48 to i32
-	ld.b $t0, $fp, -170
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -174
-# %op50 = icmp ne i32 %op49, 0
-	ld.w $t0, $fp, -174
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -175
-# br i1 %op50, label %label51, label %label63
-	ld.b $t0, $fp, -175
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .knapsack_label51
-	b .knapsack_label63
-.knapsack_label51:
-# %op52 = load i32, i32* %op2
-	ld.d $t0, $fp, -32
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -179
-# %op53 = sub i32 %op52, 1
-	ld.w $t0, $fp, -179
-	addi.w $t1, $zero, 1
-	sub.w $t2, $t0, $t1
-	st.w $t2, $fp, -183
-# %op54 = load i32, i32* %op3
-	ld.d $t0, $fp, -44
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -187
-# %op55 = call i32 @knapsack(i32 %op53, i32 %op54)
-	ld.w $a0, $fp, -183
-	ld.w $a1, $fp, -187
-	bl knapsack
-	st.w $a0, $fp, -191
-# store i32 %op55, i32* %op4
-	ld.d $t0, $fp, -56
-	ld.w $t1, $fp, -191
-	st.w $t1, $t0, 0
-# br label %label56
-	b .knapsack_label56
-.knapsack_label56:
-# %op57 = load i32, i32* %op4
-	ld.d $t0, $fp, -56
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -195
-# %op58 = load i32, i32* %op2
-	ld.d $t0, $fp, -32
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -199
-# %op59 = mul i32 %op58, 11
-	ld.w $t0, $fp, -199
-	addi.w $t1, $zero, 11
-	mul.w $t2, $t0, $t1
-	st.w $t2, $fp, -203
-# %op60 = load i32, i32* %op3
-	ld.d $t0, $fp, -44
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -207
-# %op61 = add i32 %op59, %op60
-	ld.w $t0, $fp, -203
-	ld.w $t1, $fp, -207
-	add.w $t2, $t0, $t1
-	st.w $t2, $fp, -211
-# %op62 = icmp slt i32 %op61, 0
-	ld.w $t0, $fp, -211
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -212
-# br i1 %op62, label %label89, label %label90
-	ld.b $t0, $fp, -212
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .knapsack_label89
-	b .knapsack_label90
-.knapsack_label63:
-# %op64 = load i32, i32* %op2
-	ld.d $t0, $fp, -32
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -216
-# %op65 = sub i32 %op64, 1
-	ld.w $t0, $fp, -216
-	addi.w $t1, $zero, 1
-	sub.w $t2, $t0, $t1
-	st.w $t2, $fp, -220
-# %op66 = load i32, i32* %op3
-	ld.d $t0, $fp, -44
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -224
-# %op67 = call i32 @knapsack(i32 %op65, i32 %op66)
-	ld.w $a0, $fp, -220
-	ld.w $a1, $fp, -224
-	bl knapsack
-	st.w $a0, $fp, -228
-# %op68 = load i32, i32* %op2
-	ld.d $t0, $fp, -32
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -232
-# %op69 = sub i32 %op68, 1
-	ld.w $t0, $fp, -232
-	addi.w $t1, $zero, 1
-	sub.w $t2, $t0, $t1
-	st.w $t2, $fp, -236
-# %op70 = load i32, i32* %op3
-	ld.d $t0, $fp, -44
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -240
-# %op71 = load i32, i32* %op2
-	ld.d $t0, $fp, -32
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -244
-# %op72 = sub i32 %op71, 1
-	ld.w $t0, $fp, -244
-	addi.w $t1, $zero, 1
-	sub.w $t2, $t0, $t1
-	st.w $t2, $fp, -248
-# %op73 = icmp slt i32 %op72, 0
-	ld.w $t0, $fp, -248
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -249
-# br i1 %op73, label %label74, label %label75
-	ld.b $t0, $fp, -249
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .knapsack_label74
-	b .knapsack_label75
-.knapsack_label74:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b knapsack_exit
-.knapsack_label75:
-# %op76 = getelementptr [5 x i32], [5 x i32]* @w, i32 0, i32 %op72
-	la.local $t0, w
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 20
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	ld.w $t1, $fp, -248
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -257
-# %op77 = load i32, i32* %op76
-	ld.d $t0, $fp, -257
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -261
-# %op78 = sub i32 %op70, %op77
-	ld.w $t0, $fp, -240
-	ld.w $t1, $fp, -261
-	sub.w $t2, $t0, $t1
-	st.w $t2, $fp, -265
-# %op79 = call i32 @knapsack(i32 %op69, i32 %op78)
-	ld.w $a0, $fp, -236
-	ld.w $a1, $fp, -265
-	bl knapsack
-	st.w $a0, $fp, -269
-# %op80 = load i32, i32* %op2
-	ld.d $t0, $fp, -32
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -273
-# %op81 = sub i32 %op80, 1
-	ld.w $t0, $fp, -273
-	addi.w $t1, $zero, 1
-	sub.w $t2, $t0, $t1
-	st.w $t2, $fp, -277
-# %op82 = icmp slt i32 %op81, 0
-	ld.w $t0, $fp, -277
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -278
-# br i1 %op82, label %label83, label %label84
-	ld.b $t0, $fp, -278
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .knapsack_label83
-	b .knapsack_label84
-.knapsack_label83:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b knapsack_exit
-.knapsack_label84:
-# %op85 = getelementptr [5 x i32], [5 x i32]* @v, i32 0, i32 %op81
-	la.local $t0, v
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 20
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	ld.w $t1, $fp, -277
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -286
-# %op86 = load i32, i32* %op85
-	ld.d $t0, $fp, -286
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -290
-# %op87 = add i32 %op79, %op86
-	ld.w $t0, $fp, -269
-	ld.w $t1, $fp, -290
-	add.w $t2, $t0, $t1
-	st.w $t2, $fp, -294
-# %op88 = call i32 @max(i32 %op67, i32 %op87)
-	ld.w $a0, $fp, -228
-	ld.w $a1, $fp, -294
-	bl max
-	st.w $a0, $fp, -298
-# store i32 %op88, i32* %op4
-	ld.d $t0, $fp, -56
-	ld.w $t1, $fp, -298
-	st.w $t1, $t0, 0
-# br label %label56
-	b .knapsack_label56
-.knapsack_label89:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b knapsack_exit
-.knapsack_label90:
-# %op91 = getelementptr [66 x i32], [66 x i32]* @dp, i32 0, i32 %op61
-	la.local $t0, dp
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 264
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	ld.w $t1, $fp, -211
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -306
-# store i32 %op57, i32* %op91
-	ld.d $t0, $fp, -306
-	ld.w $t1, $fp, -195
-	st.w $t1, $t0, 0
-# %op92 = load i32, i32* %op4
-	ld.d $t0, $fp, -56
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -310
-# ret i32 %op92
-	ld.w $a0, $fp, -310
-	b knapsack_exit
-knapsack_exit:
-	addi.d $sp, $sp, 320
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -176
-.main_label_entry:
-# %op0 = alloca i32
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# store i32 0, i32* %op0
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 0
-	st.w $t1, $t0, 0
-# store i32 5, i32* @n
-	la.local $t0, n
-	addi.w $t1, $zero, 5
-	st.w $t1, $t0, 0
-# store i32 10, i32* @m
-	la.local $t0, m
-	addi.w $t1, $zero, 10
-	st.w $t1, $t0, 0
-# %op1 = icmp slt i32 0, 0
-	addi.w $t0, $zero, 0
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -29
-# br i1 %op1, label %label2, label %label3
-	ld.b $t0, $fp, -29
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label2
-	b .main_label3
-.main_label2:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label3:
-# %op4 = getelementptr [5 x i32], [5 x i32]* @w, i32 0, i32 0
-	la.local $t0, w
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 20
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -37
-# store i32 2, i32* %op4
-	ld.d $t0, $fp, -37
-	addi.w $t1, $zero, 2
-	st.w $t1, $t0, 0
-# %op5 = icmp slt i32 1, 0
-	addi.w $t0, $zero, 1
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -38
-# br i1 %op5, label %label6, label %label7
-	ld.b $t0, $fp, -38
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label6
-	b .main_label7
-.main_label6:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label7:
-# %op8 = getelementptr [5 x i32], [5 x i32]* @w, i32 0, i32 1
-	la.local $t0, w
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 20
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	addi.w $t1, $zero, 1
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -46
-# store i32 2, i32* %op8
-	ld.d $t0, $fp, -46
-	addi.w $t1, $zero, 2
-	st.w $t1, $t0, 0
-# %op9 = icmp slt i32 2, 0
-	addi.w $t0, $zero, 2
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -47
-# br i1 %op9, label %label10, label %label11
-	ld.b $t0, $fp, -47
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label10
-	b .main_label11
-.main_label10:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label11:
-# %op12 = getelementptr [5 x i32], [5 x i32]* @w, i32 0, i32 2
-	la.local $t0, w
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 20
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	addi.w $t1, $zero, 2
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -55
-# store i32 6, i32* %op12
-	ld.d $t0, $fp, -55
-	addi.w $t1, $zero, 6
-	st.w $t1, $t0, 0
-# %op13 = icmp slt i32 3, 0
-	addi.w $t0, $zero, 3
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -56
-# br i1 %op13, label %label14, label %label15
-	ld.b $t0, $fp, -56
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label14
-	b .main_label15
-.main_label14:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label15:
-# %op16 = getelementptr [5 x i32], [5 x i32]* @w, i32 0, i32 3
-	la.local $t0, w
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 20
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	addi.w $t1, $zero, 3
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -64
-# store i32 5, i32* %op16
-	ld.d $t0, $fp, -64
-	addi.w $t1, $zero, 5
-	st.w $t1, $t0, 0
-# %op17 = icmp slt i32 4, 0
-	addi.w $t0, $zero, 4
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -65
-# br i1 %op17, label %label18, label %label19
-	ld.b $t0, $fp, -65
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label18
-	b .main_label19
-.main_label18:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label19:
-# %op20 = getelementptr [5 x i32], [5 x i32]* @w, i32 0, i32 4
-	la.local $t0, w
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 20
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	addi.w $t1, $zero, 4
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -73
-# store i32 4, i32* %op20
-	ld.d $t0, $fp, -73
-	addi.w $t1, $zero, 4
-	st.w $t1, $t0, 0
-# %op21 = icmp slt i32 0, 0
-	addi.w $t0, $zero, 0
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -74
-# br i1 %op21, label %label22, label %label23
-	ld.b $t0, $fp, -74
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label22
-	b .main_label23
-.main_label22:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label23:
-# %op24 = getelementptr [5 x i32], [5 x i32]* @v, i32 0, i32 0
-	la.local $t0, v
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 20
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -82
-# store i32 6, i32* %op24
-	ld.d $t0, $fp, -82
-	addi.w $t1, $zero, 6
-	st.w $t1, $t0, 0
-# %op25 = icmp slt i32 1, 0
-	addi.w $t0, $zero, 1
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -83
-# br i1 %op25, label %label26, label %label27
-	ld.b $t0, $fp, -83
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label26
-	b .main_label27
-.main_label26:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label27:
-# %op28 = getelementptr [5 x i32], [5 x i32]* @v, i32 0, i32 1
-	la.local $t0, v
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 20
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	addi.w $t1, $zero, 1
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -91
-# store i32 3, i32* %op28
-	ld.d $t0, $fp, -91
-	addi.w $t1, $zero, 3
-	st.w $t1, $t0, 0
-# %op29 = icmp slt i32 2, 0
-	addi.w $t0, $zero, 2
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -92
-# br i1 %op29, label %label30, label %label31
-	ld.b $t0, $fp, -92
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label30
-	b .main_label31
-.main_label30:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label31:
-# %op32 = getelementptr [5 x i32], [5 x i32]* @v, i32 0, i32 2
-	la.local $t0, v
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 20
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	addi.w $t1, $zero, 2
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -100
-# store i32 5, i32* %op32
-	ld.d $t0, $fp, -100
-	addi.w $t1, $zero, 5
-	st.w $t1, $t0, 0
-# %op33 = icmp slt i32 3, 0
-	addi.w $t0, $zero, 3
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -101
-# br i1 %op33, label %label34, label %label35
-	ld.b $t0, $fp, -101
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label34
-	b .main_label35
-.main_label34:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label35:
-# %op36 = getelementptr [5 x i32], [5 x i32]* @v, i32 0, i32 3
-	la.local $t0, v
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 20
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	addi.w $t1, $zero, 3
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -109
-# store i32 4, i32* %op36
-	ld.d $t0, $fp, -109
-	addi.w $t1, $zero, 4
-	st.w $t1, $t0, 0
-# %op37 = icmp slt i32 4, 0
-	addi.w $t0, $zero, 4
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -110
-# br i1 %op37, label %label38, label %label39
-	ld.b $t0, $fp, -110
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label38
-	b .main_label39
-.main_label38:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label39:
-# %op40 = getelementptr [5 x i32], [5 x i32]* @v, i32 0, i32 4
-	la.local $t0, v
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 20
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	addi.w $t1, $zero, 4
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -118
-# store i32 6, i32* %op40
-	ld.d $t0, $fp, -118
-	addi.w $t1, $zero, 6
-	st.w $t1, $t0, 0
-# br label %label41
-	b .main_label41
-.main_label41:
-# %op42 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -122
-# %op43 = icmp slt i32 %op42, 66
-	ld.w $t0, $fp, -122
-	addi.w $t1, $zero, 66
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -123
-# %op44 = zext i1 %op43 to i32
-	ld.b $t0, $fp, -123
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -127
-# %op45 = icmp ne i32 %op44, 0
-	ld.w $t0, $fp, -127
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -128
-# br i1 %op45, label %label46, label %label50
-	ld.b $t0, $fp, -128
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label46
-	b .main_label50
-.main_label46:
-# %op47 = sub i32 0, 1
-	addi.w $t0, $zero, 0
-	addi.w $t1, $zero, 1
-	sub.w $t2, $t0, $t1
-	st.w $t2, $fp, -132
-# %op48 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -136
-# %op49 = icmp slt i32 %op48, 0
-	ld.w $t0, $fp, -136
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -137
-# br i1 %op49, label %label54, label %label55
-	ld.b $t0, $fp, -137
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label54
-	b .main_label55
-.main_label50:
-# %op51 = load i32, i32* @n
-	la.local $t0, n
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -141
-# %op52 = load i32, i32* @m
-	la.local $t0, m
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -145
-# %op53 = call i32 @knapsack(i32 %op51, i32 %op52)
-	ld.w $a0, $fp, -141
-	ld.w $a1, $fp, -145
-	bl knapsack
-	st.w $a0, $fp, -149
-# call void @output(i32 %op53)
-	ld.w $a0, $fp, -149
-	bl output
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label54:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label55:
-# %op56 = getelementptr [66 x i32], [66 x i32]* @dp, i32 0, i32 %op48
-	la.local $t0, dp
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 264
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	ld.w $t1, $fp, -136
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -157
-# store i32 %op47, i32* %op56
-	ld.d $t0, $fp, -157
-	ld.w $t1, $fp, -132
-	st.w $t1, $t0, 0
-# %op57 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -161
-# %op58 = add i32 %op57, 1
-	ld.w $t0, $fp, -161
-	addi.w $t1, $zero, 1
-	add.w $t2, $t0, $t1
-	st.w $t2, $fp, -165
-# store i32 %op58, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t1, $fp, -165
-	st.w $t1, $t0, 0
-# br label %label41
-	b .main_label41
-main_exit:
-	addi.d $sp, $sp, 176
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/13-if_stmt.out

-0

tests/3-codegen/autogen/output/13-if_stmt.s

-	.text
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -48
-.main_label_entry:
-# %op0 = alloca i32
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# store i32 2, i32* %op0
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 2
-	st.w $t1, $t0, 0
-# %op1 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -32
-# %op2 = icmp ne i32 %op1, 0
-	ld.w $t0, $fp, -32
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -33
-# br i1 %op2, label %label3, label %label4
-	ld.b $t0, $fp, -33
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label3
-	b .main_label4
-.main_label3:
-# store i32 3, i32* %op0
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 3
-	st.w $t1, $t0, 0
-# br label %label4
-	b .main_label4
-.main_label4:
-# store i32 4, i32* %op0
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 4
-	st.w $t1, $t0, 0
-# ret void
-	addi.w $a0, $zero, 0
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 48
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/14-while_stmt.out

-0

tests/3-codegen/autogen/output/14-while_stmt.s

-	.text
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -48
-.main_label_entry:
-# %op0 = alloca i32
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# store i32 10, i32* %op0
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 10
-	st.w $t1, $t0, 0
-# br label %label1
-	b .main_label1
-.main_label1:
-# %op2 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -32
-# %op3 = icmp ne i32 %op2, 0
-	ld.w $t0, $fp, -32
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -33
-# br i1 %op3, label %label4, label %label7
-	ld.b $t0, $fp, -33
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label4
-	b .main_label7
-.main_label4:
-# %op5 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -37
-# %op6 = sub i32 %op5, 1
-	ld.w $t0, $fp, -37
-	addi.w $t1, $zero, 1
-	sub.w $t2, $t0, $t1
-	st.w $t2, $fp, -41
-# store i32 %op6, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t1, $fp, -41
-	st.w $t1, $t0, 0
-# br label %label1
-	b .main_label1
-.main_label7:
-# ret void
-	addi.w $a0, $zero, 0
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 48
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/15-if_while.out

-45

tests/3-codegen/autogen/output/15-if_while.s

-	.text
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -112
-.main_label_entry:
-# %op0 = alloca i32
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# %op1 = alloca i32
-	addi.d $t0, $fp, -40
-	st.d $t0, $fp, -36
-# %op2 = alloca i32
-	addi.d $t0, $fp, -52
-	st.d $t0, $fp, -48
-# store i32 0, i32* %op1
-	ld.d $t0, $fp, -36
-	addi.w $t1, $zero, 0
-	st.w $t1, $t0, 0
-# store i32 0, i32* %op2
-	ld.d $t0, $fp, -48
-	addi.w $t1, $zero, 0
-	st.w $t1, $t0, 0
-# store i32 10, i32* %op0
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 10
-	st.w $t1, $t0, 0
-# br label %label3
-	b .main_label3
-.main_label3:
-# %op4 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -56
-# %op5 = icmp ne i32 %op4, 0
-	ld.w $t0, $fp, -56
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -57
-# br i1 %op5, label %label6, label %label13
-	ld.b $t0, $fp, -57
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label6
-	b .main_label13
-.main_label6:
-# %op7 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -61
-# %op8 = sub i32 %op7, 1
-	ld.w $t0, $fp, -61
-	addi.w $t1, $zero, 1
-	sub.w $t2, $t0, $t1
-	st.w $t2, $fp, -65
-# store i32 %op8, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t1, $fp, -65
-	st.w $t1, $t0, 0
-# %op9 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -69
-# %op10 = icmp slt i32 %op9, 5
-	ld.w $t0, $fp, -69
-	addi.w $t1, $zero, 5
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -70
-# %op11 = zext i1 %op10 to i32
-	ld.b $t0, $fp, -70
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -74
-# %op12 = icmp ne i32 %op11, 0
-	ld.w $t0, $fp, -74
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -75
-# br i1 %op12, label %label17, label %label22
-	ld.b $t0, $fp, -75
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label17
-	b .main_label22
-.main_label13:
-# %op14 = load i32, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -79
-# %op15 = load i32, i32* %op2
-	ld.d $t0, $fp, -48
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -83
-# %op16 = add i32 %op14, %op15
-	ld.w $t0, $fp, -79
-	ld.w $t1, $fp, -83
-	add.w $t2, $t0, $t1
-	st.w $t2, $fp, -87
-# ret i32 %op16
-	ld.w $a0, $fp, -87
-	b main_exit
-.main_label17:
-# %op18 = load i32, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -91
-# %op19 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -95
-# %op20 = add i32 %op18, %op19
-	ld.w $t0, $fp, -91
-	ld.w $t1, $fp, -95
-	add.w $t2, $t0, $t1
-	st.w $t2, $fp, -99
-# store i32 %op20, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t1, $fp, -99
-	st.w $t1, $t0, 0
-# br label %label21
-	b .main_label21
-.main_label21:
-# br label %label3
-	b .main_label3
-.main_label22:
-# %op23 = load i32, i32* %op2
-	ld.d $t0, $fp, -48
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -103
-# %op24 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -107
-# %op25 = add i32 %op23, %op24
-	ld.w $t0, $fp, -103
-	ld.w $t1, $fp, -107
-	add.w $t2, $t0, $t1
-	st.w $t2, $fp, -111
-# store i32 %op25, i32* %op2
-	ld.d $t0, $fp, -48
-	ld.w $t1, $fp, -111
-	st.w $t1, $t0, 0
-# br label %label21
-	b .main_label21
-main_exit:
-	addi.d $sp, $sp, 112
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/16-if_chain.out

-3

tests/3-codegen/autogen/output/16-if_chain.s

-	.text
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -80
-.main_label_entry:
-# %op0 = alloca i32
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# %op1 = alloca i32
-	addi.d $t0, $fp, -40
-	st.d $t0, $fp, -36
-# %op2 = alloca i32
-	addi.d $t0, $fp, -52
-	st.d $t0, $fp, -48
-# store i32 0, i32* %op2
-	ld.d $t0, $fp, -48
-	addi.w $t1, $zero, 0
-	st.w $t1, $t0, 0
-# store i32 2, i32* %op0
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 2
-	st.w $t1, $t0, 0
-# store i32 1, i32* %op1
-	ld.d $t0, $fp, -36
-	addi.w $t1, $zero, 1
-	st.w $t1, $t0, 0
-# %op3 = load i32, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -56
-# %op4 = icmp ne i32 %op3, 0
-	ld.w $t0, $fp, -56
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -57
-# br i1 %op4, label %label5, label %label8
-	ld.b $t0, $fp, -57
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label5
-	b .main_label8
-.main_label5:
-# %op6 = load i32, i32* %op2
-	ld.d $t0, $fp, -48
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -61
-# %op7 = icmp ne i32 %op6, 0
-	ld.w $t0, $fp, -61
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -62
-# br i1 %op7, label %label10, label %label12
-	ld.b $t0, $fp, -62
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label10
-	b .main_label12
-.main_label8:
-# %op9 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -66
-# ret i32 %op9
-	ld.w $a0, $fp, -66
-	b main_exit
-.main_label10:
-# store i32 4, i32* %op0
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 4
-	st.w $t1, $t0, 0
-# br label %label11
-	b .main_label11
-.main_label11:
-# br label %label8
-	b .main_label8
-.main_label12:
-# store i32 3, i32* %op0
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 3
-	st.w $t1, $t0, 0
-# br label %label11
-	b .main_label11
-main_exit:
-	addi.d $sp, $sp, 80
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/17-while_chain.out

-0

tests/3-codegen/autogen/output/17-while_chain.s

-	.text
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -96
-.main_label_entry:
-# %op0 = alloca i32
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# %op1 = alloca i32
-	addi.d $t0, $fp, -40
-	st.d $t0, $fp, -36
-# store i32 10, i32* %op0
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 10
-	st.w $t1, $t0, 0
-# br label %label2
-	b .main_label2
-.main_label2:
-# %op3 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -44
-# %op4 = icmp ne i32 %op3, 0
-	ld.w $t0, $fp, -44
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -45
-# br i1 %op4, label %label5, label %label9
-	ld.b $t0, $fp, -45
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label5
-	b .main_label9
-.main_label5:
-# %op6 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -49
-# %op7 = sub i32 %op6, 1
-	ld.w $t0, $fp, -49
-	addi.w $t1, $zero, 1
-	sub.w $t2, $t0, $t1
-	st.w $t2, $fp, -53
-# store i32 %op7, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t1, $fp, -53
-	st.w $t1, $t0, 0
-# %op8 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -57
-# store i32 %op8, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t1, $fp, -57
-	st.w $t1, $t0, 0
-# br label %label13
-	b .main_label13
-.main_label9:
-# %op10 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -61
-# %op11 = load i32, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -65
-# %op12 = add i32 %op10, %op11
-	ld.w $t0, $fp, -61
-	ld.w $t1, $fp, -65
-	add.w $t2, $t0, $t1
-	st.w $t2, $fp, -69
-# ret i32 %op12
-	ld.w $a0, $fp, -69
-	b main_exit
-.main_label13:
-# %op14 = load i32, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -73
-# %op15 = icmp ne i32 %op14, 0
-	ld.w $t0, $fp, -73
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -74
-# br i1 %op15, label %label16, label %label19
-	ld.b $t0, $fp, -74
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label16
-	b .main_label19
-.main_label16:
-# %op17 = load i32, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -78
-# %op18 = sub i32 %op17, 1
-	ld.w $t0, $fp, -78
-	addi.w $t1, $zero, 1
-	sub.w $t2, $t0, $t1
-	st.w $t2, $fp, -82
-# store i32 %op18, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t1, $fp, -82
-	st.w $t1, $t0, 0
-# br label %label13
-	b .main_label13
-.main_label19:
-# br label %label2
-	b .main_label2
-main_exit:
-	addi.d $sp, $sp, 96
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/18-global_var.out

-10

tests/3-codegen/autogen/output/18-global_var.s

-# Global variables
-	.text
-	.section .bss, "aw", @nobits
-	.globl a
-	.type a, @object
-	.size a, 4
-a:
-	.space 4
-	.text
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -32
-.main_label_entry:
-# store i32 10, i32* @a
-	la.local $t0, a
-	addi.w $t1, $zero, 10
-	st.w $t1, $t0, 0
-# %op0 = load i32, i32* @a
-	la.local $t0, a
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -20
-# ret i32 %op0
-	ld.w $a0, $fp, -20
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 32
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/19-global_local_var.out

-20

tests/3-codegen/autogen/output/19-global_local_var.s

-# Global variables
-	.text
-	.section .bss, "aw", @nobits
-	.globl a
-	.type a, @object
-	.size a, 4
-a:
-	.space 4
-	.text
-	.globl GlobalAssign
-	.type GlobalAssign, @function
-GlobalAssign:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -16
-.GlobalAssign_label_entry:
-# store i32 10, i32* @a
-	la.local $t0, a
-	addi.w $t1, $zero, 10
-	st.w $t1, $t0, 0
-# ret void
-	addi.w $a0, $zero, 0
-	b GlobalAssign_exit
-GlobalAssign_exit:
-	addi.d $sp, $sp, 16
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -32
-.main_label_entry:
-# %op0 = alloca i32
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# call void @GlobalAssign()
-	bl GlobalAssign
-# store i32 20, i32* %op0
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 20
-	st.w $t1, $t0, 0
-# %op1 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -32
-# ret i32 %op1
-	ld.w $a0, $fp, -32
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 32
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/2-calculate.ll

-; ModuleID = 'cminus'
-source_filename = "/code/compiler/24.ta/tests/3-codegen/autogen/testcases/2-calculate.cminus"
-
-declare i32 @input()
-
-declare void @output(i32)
-
-declare void @outputFloat(float)
-
-declare void @neg_idx_except()
-
-define i32 @main() {
-label_entry:
-  %op0 = alloca i32
-  %op1 = alloca i32
-  %op2 = alloca i32
-  store i32 23, i32* %op0
-  store i32 25, i32* %op1
-  store i32 4, i32* %op2
-  %op3 = load i32, i32* %op0
-  %op4 = load i32, i32* %op1
-  %op5 = load i32, i32* %op2
-  %op6 = mul i32 %op4, %op5
-  %op7 = add i32 %op3, %op6
-  ret i32 %op7
-}

tests/3-codegen/autogen/output/2-calculate.out

-123

tests/3-codegen/autogen/output/2-calculate.s

-	.text
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -80
-.main_label_entry:
-# %op0 = alloca i32
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# %op1 = alloca i32
-	addi.d $t0, $fp, -40
-	st.d $t0, $fp, -36
-# %op2 = alloca i32
-	addi.d $t0, $fp, -52
-	st.d $t0, $fp, -48
-# store i32 23, i32* %op0
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 23
-	st.w $t1, $t0, 0
-# store i32 25, i32* %op1
-	ld.d $t0, $fp, -36
-	addi.w $t1, $zero, 25
-	st.w $t1, $t0, 0
-# store i32 4, i32* %op2
-	ld.d $t0, $fp, -48
-	addi.w $t1, $zero, 4
-	st.w $t1, $t0, 0
-# %op3 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -56
-# %op4 = load i32, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -60
-# %op5 = load i32, i32* %op2
-	ld.d $t0, $fp, -48
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -64
-# %op6 = mul i32 %op4, %op5
-	ld.w $t0, $fp, -60
-	ld.w $t1, $fp, -64
-	mul.w $t2, $t0, $t1
-	st.w $t2, $fp, -68
-# %op7 = add i32 %op3, %op6
-	ld.w $t0, $fp, -56
-	ld.w $t1, $fp, -68
-	add.w $t2, $t0, $t1
-	st.w $t2, $fp, -72
-# ret i32 %op7
-	ld.w $a0, $fp, -72
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 80
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/2-decl_int.out

-0

tests/3-codegen/autogen/output/2-decl_int.s

-	.text
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -32
-.main_label_entry:
-# %op0 = alloca i32
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# ret void
-	addi.w $a0, $zero, 0
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 32
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/20-gcd_array.out

-18

tests/3-codegen/autogen/output/20-gcd_array.s

-# Global variables
-	.text
-	.section .bss, "aw", @nobits
-	.globl x
-	.type x, @object
-	.size x, 4
-x:
-	.space 4
-	.globl y
-	.type y, @object
-	.size y, 4
-y:
-	.space 4
-	.text
-	.globl gcd
-	.type gcd, @function
-gcd:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -112
-	st.w $a0, $fp, -20
-	st.w $a1, $fp, -24
-.gcd_label_entry:
-# %op2 = alloca i32
-	addi.d $t0, $fp, -36
-	st.d $t0, $fp, -32
-# store i32 %arg0, i32* %op2
-	ld.d $t0, $fp, -32
-	ld.w $t1, $fp, -20
-	st.w $t1, $t0, 0
-# %op3 = alloca i32
-	addi.d $t0, $fp, -48
-	st.d $t0, $fp, -44
-# store i32 %arg1, i32* %op3
-	ld.d $t0, $fp, -44
-	ld.w $t1, $fp, -24
-	st.w $t1, $t0, 0
-# %op4 = load i32, i32* %op3
-	ld.d $t0, $fp, -44
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -52
-# %op5 = icmp eq i32 %op4, 0
-	ld.w $t0, $fp, -52
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltui $t2, $t2, 1
-	st.b $t2, $fp, -53
-# %op6 = zext i1 %op5 to i32
-	ld.b $t0, $fp, -53
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -57
-# %op7 = icmp ne i32 %op6, 0
-	ld.w $t0, $fp, -57
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -58
-# br i1 %op7, label %label8, label %label11
-	ld.b $t0, $fp, -58
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .gcd_label8
-	b .gcd_label11
-.gcd_label8:
-# %op9 = load i32, i32* %op2
-	ld.d $t0, $fp, -32
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -62
-# ret i32 %op9
-	ld.w $a0, $fp, -62
-	b gcd_exit
-.gcd_label10:
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b gcd_exit
-.gcd_label11:
-# %op12 = load i32, i32* %op3
-	ld.d $t0, $fp, -44
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -66
-# %op13 = load i32, i32* %op2
-	ld.d $t0, $fp, -32
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -70
-# %op14 = load i32, i32* %op2
-	ld.d $t0, $fp, -32
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -74
-# %op15 = load i32, i32* %op3
-	ld.d $t0, $fp, -44
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -78
-# %op16 = sdiv i32 %op14, %op15
-	ld.w $t0, $fp, -74
-	ld.w $t1, $fp, -78
-	div.w $t2, $t0, $t1
-	st.w $t2, $fp, -82
-# %op17 = load i32, i32* %op3
-	ld.d $t0, $fp, -44
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -86
-# %op18 = mul i32 %op16, %op17
-	ld.w $t0, $fp, -82
-	ld.w $t1, $fp, -86
-	mul.w $t2, $t0, $t1
-	st.w $t2, $fp, -90
-# %op19 = sub i32 %op13, %op18
-	ld.w $t0, $fp, -70
-	ld.w $t1, $fp, -90
-	sub.w $t2, $t0, $t1
-	st.w $t2, $fp, -94
-# %op20 = call i32 @gcd(i32 %op12, i32 %op19)
-	ld.w $a0, $fp, -66
-	ld.w $a1, $fp, -94
-	bl gcd
-	st.w $a0, $fp, -98
-# ret i32 %op20
-	ld.w $a0, $fp, -98
-	b gcd_exit
-gcd_exit:
-	addi.d $sp, $sp, 112
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra
-	.globl funArray
-	.type funArray, @function
-funArray:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -192
-	st.d $a0, $fp, -24
-	st.d $a1, $fp, -32
-.funArray_label_entry:
-# %op2 = alloca i32*
-	addi.d $t0, $fp, -48
-	st.d $t0, $fp, -40
-# store i32* %arg0, i32** %op2
-	ld.d $t0, $fp, -40
-	ld.d $t1, $fp, -24
-	st.d $t1, $t0, 0
-# %op3 = alloca i32*
-	addi.d $t0, $fp, -64
-	st.d $t0, $fp, -56
-# store i32* %arg1, i32** %op3
-	ld.d $t0, $fp, -56
-	ld.d $t1, $fp, -32
-	st.d $t1, $t0, 0
-# %op4 = alloca i32
-	addi.d $t0, $fp, -76
-	st.d $t0, $fp, -72
-# %op5 = alloca i32
-	addi.d $t0, $fp, -88
-	st.d $t0, $fp, -84
-# %op6 = alloca i32
-	addi.d $t0, $fp, -100
-	st.d $t0, $fp, -96
-# %op7 = icmp slt i32 0, 0
-	addi.w $t0, $zero, 0
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -101
-# br i1 %op7, label %label8, label %label9
-	ld.b $t0, $fp, -101
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .funArray_label8
-	b .funArray_label9
-.funArray_label8:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b funArray_exit
-.funArray_label9:
-# %op10 = load i32*, i32** %op2
-	ld.d $t0, $fp, -40
-	ld.d $t0, $t0, 0
-	st.d $t0, $fp, -109
-# %op11 = getelementptr i32, i32* %op10, i32 0
-	ld.d $t0, $fp, -109
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -117
-# %op12 = load i32, i32* %op11
-	ld.d $t0, $fp, -117
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -121
-# store i32 %op12, i32* %op4
-	ld.d $t0, $fp, -72
-	ld.w $t1, $fp, -121
-	st.w $t1, $t0, 0
-# %op13 = icmp slt i32 0, 0
-	addi.w $t0, $zero, 0
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -122
-# br i1 %op13, label %label14, label %label15
-	ld.b $t0, $fp, -122
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .funArray_label14
-	b .funArray_label15
-.funArray_label14:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b funArray_exit
-.funArray_label15:
-# %op16 = load i32*, i32** %op3
-	ld.d $t0, $fp, -56
-	ld.d $t0, $t0, 0
-	st.d $t0, $fp, -130
-# %op17 = getelementptr i32, i32* %op16, i32 0
-	ld.d $t0, $fp, -130
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -138
-# %op18 = load i32, i32* %op17
-	ld.d $t0, $fp, -138
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -142
-# store i32 %op18, i32* %op5
-	ld.d $t0, $fp, -84
-	ld.w $t1, $fp, -142
-	st.w $t1, $t0, 0
-# %op19 = load i32, i32* %op4
-	ld.d $t0, $fp, -72
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -146
-# %op20 = load i32, i32* %op5
-	ld.d $t0, $fp, -84
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -150
-# %op21 = icmp slt i32 %op19, %op20
-	ld.w $t0, $fp, -146
-	ld.w $t1, $fp, -150
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -151
-# %op22 = zext i1 %op21 to i32
-	ld.b $t0, $fp, -151
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -155
-# %op23 = icmp ne i32 %op22, 0
-	ld.w $t0, $fp, -155
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -156
-# br i1 %op23, label %label24, label %label28
-	ld.b $t0, $fp, -156
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .funArray_label24
-	b .funArray_label28
-.funArray_label24:
-# %op25 = load i32, i32* %op4
-	ld.d $t0, $fp, -72
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -160
-# store i32 %op25, i32* %op6
-	ld.d $t0, $fp, -96
-	ld.w $t1, $fp, -160
-	st.w $t1, $t0, 0
-# %op26 = load i32, i32* %op5
-	ld.d $t0, $fp, -84
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -164
-# store i32 %op26, i32* %op4
-	ld.d $t0, $fp, -72
-	ld.w $t1, $fp, -164
-	st.w $t1, $t0, 0
-# %op27 = load i32, i32* %op6
-	ld.d $t0, $fp, -96
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -168
-# store i32 %op27, i32* %op5
-	ld.d $t0, $fp, -84
-	ld.w $t1, $fp, -168
-	st.w $t1, $t0, 0
-# br label %label28
-	b .funArray_label28
-.funArray_label28:
-# %op29 = load i32, i32* %op4
-	ld.d $t0, $fp, -72
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -172
-# %op30 = load i32, i32* %op5
-	ld.d $t0, $fp, -84
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -176
-# %op31 = call i32 @gcd(i32 %op29, i32 %op30)
-	ld.w $a0, $fp, -172
-	ld.w $a1, $fp, -176
-	bl gcd
-	st.w $a0, $fp, -180
-# ret i32 %op31
-	ld.w $a0, $fp, -180
-	b funArray_exit
-funArray_exit:
-	addi.d $sp, $sp, 192
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -64
-.main_label_entry:
-# %op0 = icmp slt i32 0, 0
-	addi.w $t0, $zero, 0
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -17
-# br i1 %op0, label %label1, label %label2
-	ld.b $t0, $fp, -17
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label1
-	b .main_label2
-.main_label1:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label2:
-# %op3 = getelementptr [1 x i32], [1 x i32]* @x, i32 0, i32 0
-	la.local $t0, x
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -25
-# store i32 90, i32* %op3
-	ld.d $t0, $fp, -25
-	addi.w $t1, $zero, 90
-	st.w $t1, $t0, 0
-# %op4 = icmp slt i32 0, 0
-	addi.w $t0, $zero, 0
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -26
-# br i1 %op4, label %label5, label %label6
-	ld.b $t0, $fp, -26
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label5
-	b .main_label6
-.main_label5:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label6:
-# %op7 = getelementptr [1 x i32], [1 x i32]* @y, i32 0, i32 0
-	la.local $t0, y
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -34
-# store i32 18, i32* %op7
-	ld.d $t0, $fp, -34
-	addi.w $t1, $zero, 18
-	st.w $t1, $t0, 0
-# %op8 = getelementptr [1 x i32], [1 x i32]* @x, i32 0, i32 0
-	la.local $t0, x
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -42
-# %op9 = getelementptr [1 x i32], [1 x i32]* @y, i32 0, i32 0
-	la.local $t0, y
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -50
-# %op10 = call i32 @funArray(i32* %op8, i32* %op9)
-	ld.d $a0, $fp, -42
-	ld.d $a1, $fp, -50
-	bl funArray
-	st.w $a0, $fp, -54
-# ret i32 %op10
-	ld.w $a0, $fp, -54
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 64
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/21-comment.out

-0

tests/3-codegen/autogen/output/21-comment.s

-	.text
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -16
-.main_label_entry:
-# ret void
-	addi.w $a0, $zero, 0
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 16
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/3-decl_float.out

-0

tests/3-codegen/autogen/output/3-decl_float.s

-	.text
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -32
-.main_label_entry:
-# %op0 = alloca float
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# ret void
-	addi.w $a0, $zero, 0
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 32
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/3-output.ll

-; ModuleID = 'cminus'
-source_filename = "/code/compiler/24.ta/tests/3-codegen/autogen/testcases/3-output.cminus"
-
-declare i32 @input()
-
-declare void @output(i32)
-
-declare void @outputFloat(float)
-
-declare void @neg_idx_except()
-
-define i32 @main() {
-label_entry:
-  call void @output(i32 11)
-  call void @output(i32 22222)
-  ret i32 0
-}

tests/3-codegen/autogen/output/3-output.out

-11
-22222
-0

tests/3-codegen/autogen/output/3-output.s

-	.text
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -16
-.main_label_entry:
-# call void @output(i32 11)
-	addi.w $a0, $zero, 11
-	bl output
-# call void @output(i32 22222)
-	lu12i.w $a0, 5
-	ori $a0, $a0, 1742
-	bl output
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 16
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/4-decl_int_array.out

-0

tests/3-codegen/autogen/output/4-decl_int_array.s

-	.text
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -64
-.main_label_entry:
-# %op0 = alloca [10 x i32]
-	addi.d $t0, $fp, -64
-	st.d $t0, $fp, -24
-# ret void
-	addi.w $a0, $zero, 0
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 64
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/4-if.ll

-; ModuleID = 'cminus'
-source_filename = "/code/compiler/24.ta/tests/3-codegen/autogen/testcases/4-if.cminus"
-
-declare i32 @input()
-
-declare void @output(i32)
-
-declare void @outputFloat(float)
-
-declare void @neg_idx_except()
-
-define i32 @main() {
-label_entry:
-  %op0 = alloca i32
-  %op1 = alloca i32
-  %op2 = alloca i32
-  store i32 11, i32* %op0
-  store i32 22, i32* %op1
-  store i32 33, i32* %op2
-  %op3 = load i32, i32* %op0
-  %op4 = load i32, i32* %op1
-  %op5 = icmp sgt i32 %op3, %op4
-  %op6 = zext i1 %op5 to i32
-  %op7 = icmp ne i32 %op6, 0
-  br i1 %op7, label %label8, label %label15
-label8:                                                ; preds = %label_entry
-  %op9 = load i32, i32* %op0
-  %op10 = load i32, i32* %op2
-  %op11 = icmp sgt i32 %op9, %op10
-  %op12 = zext i1 %op11 to i32
-  %op13 = icmp ne i32 %op12, 0
-  br i1 %op13, label %label21, label %label24
-label14:                                                ; preds = %label23, %label28
-  ret i32 0
-label15:                                                ; preds = %label_entry
-  %op16 = load i32, i32* %op2
-  %op17 = load i32, i32* %op1
-  %op18 = icmp slt i32 %op16, %op17
-  %op19 = zext i1 %op18 to i32
-  %op20 = icmp ne i32 %op19, 0
-  br i1 %op20, label %label26, label %label29
-label21:                                                ; preds = %label8
-  %op22 = load i32, i32* %op0
-  call void @output(i32 %op22)
-  br label %label23
-label23:                                                ; preds = %label21, %label24
-  br label %label14
-label24:                                                ; preds = %label8
-  %op25 = load i32, i32* %op2
-  call void @output(i32 %op25)
-  br label %label23
-label26:                                                ; preds = %label15
-  %op27 = load i32, i32* %op1
-  call void @output(i32 %op27)
-  br label %label28
-label28:                                                ; preds = %label26, %label29
-  br label %label14
-label29:                                                ; preds = %label15
-  %op30 = load i32, i32* %op2
-  call void @output(i32 %op30)
-  br label %label28
-}

tests/3-codegen/autogen/output/4-if.out

-33
-0

tests/3-codegen/autogen/output/4-if.s

-	.text
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -112
-.main_label_entry:
-# %op0 = alloca i32
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# %op1 = alloca i32
-	addi.d $t0, $fp, -40
-	st.d $t0, $fp, -36
-# %op2 = alloca i32
-	addi.d $t0, $fp, -52
-	st.d $t0, $fp, -48
-# store i32 11, i32* %op0
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 11
-	st.w $t1, $t0, 0
-# store i32 22, i32* %op1
-	ld.d $t0, $fp, -36
-	addi.w $t1, $zero, 22
-	st.w $t1, $t0, 0
-# store i32 33, i32* %op2
-	ld.d $t0, $fp, -48
-	addi.w $t1, $zero, 33
-	st.w $t1, $t0, 0
-# %op3 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -56
-# %op4 = load i32, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -60
-# %op5 = icmp sgt i32 %op3, %op4
-	ld.w $t0, $fp, -56
-	ld.w $t1, $fp, -60
-	slt $t2, $t1, $t0
-	st.b $t2, $fp, -61
-# %op6 = zext i1 %op5 to i32
-	ld.b $t0, $fp, -61
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -65
-# %op7 = icmp ne i32 %op6, 0
-	ld.w $t0, $fp, -65
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -66
-# br i1 %op7, label %label8, label %label15
-	ld.b $t0, $fp, -66
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label8
-	b .main_label15
-.main_label8:
-# %op9 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -70
-# %op10 = load i32, i32* %op2
-	ld.d $t0, $fp, -48
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -74
-# %op11 = icmp sgt i32 %op9, %op10
-	ld.w $t0, $fp, -70
-	ld.w $t1, $fp, -74
-	slt $t2, $t1, $t0
-	st.b $t2, $fp, -75
-# %op12 = zext i1 %op11 to i32
-	ld.b $t0, $fp, -75
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -79
-# %op13 = icmp ne i32 %op12, 0
-	ld.w $t0, $fp, -79
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -80
-# br i1 %op13, label %label21, label %label24
-	ld.b $t0, $fp, -80
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label21
-	b .main_label24
-.main_label14:
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label15:
-# %op16 = load i32, i32* %op2
-	ld.d $t0, $fp, -48
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -84
-# %op17 = load i32, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -88
-# %op18 = icmp slt i32 %op16, %op17
-	ld.w $t0, $fp, -84
-	ld.w $t1, $fp, -88
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -89
-# %op19 = zext i1 %op18 to i32
-	ld.b $t0, $fp, -89
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -93
-# %op20 = icmp ne i32 %op19, 0
-	ld.w $t0, $fp, -93
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -94
-# br i1 %op20, label %label26, label %label29
-	ld.b $t0, $fp, -94
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label26
-	b .main_label29
-.main_label21:
-# %op22 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -98
-# call void @output(i32 %op22)
-	ld.w $a0, $fp, -98
-	bl output
-# br label %label23
-	b .main_label23
-.main_label23:
-# br label %label14
-	b .main_label14
-.main_label24:
-# %op25 = load i32, i32* %op2
-	ld.d $t0, $fp, -48
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -102
-# call void @output(i32 %op25)
-	ld.w $a0, $fp, -102
-	bl output
-# br label %label23
-	b .main_label23
-.main_label26:
-# %op27 = load i32, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -106
-# call void @output(i32 %op27)
-	ld.w $a0, $fp, -106
-	bl output
-# br label %label28
-	b .main_label28
-.main_label28:
-# br label %label14
-	b .main_label14
-.main_label29:
-# %op30 = load i32, i32* %op2
-	ld.d $t0, $fp, -48
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -110
-# call void @output(i32 %op30)
-	ld.w $a0, $fp, -110
-	bl output
-# br label %label28
-	b .main_label28
-main_exit:
-	addi.d $sp, $sp, 112
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/5-decl_float_array.out

-0

tests/3-codegen/autogen/output/5-decl_float_array.s

-	.text
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -64
-.main_label_entry:
-# %op0 = alloca [10 x float]
-	addi.d $t0, $fp, -64
-	st.d $t0, $fp, -24
-# ret void
-	addi.w $a0, $zero, 0
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 64
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/5-while.ll

-; ModuleID = 'cminus'
-source_filename = "/code/compiler/24.ta/tests/3-codegen/autogen/testcases/5-while.cminus"
-
-declare i32 @input()
-
-declare void @output(i32)
-
-declare void @outputFloat(float)
-
-declare void @neg_idx_except()
-
-define i32 @main() {
-label_entry:
-  %op0 = alloca i32
-  %op1 = alloca i32
-  store i32 10, i32* %op0
-  store i32 0, i32* %op1
-  br label %label2
-label2:                                                ; preds = %label_entry, %label8
-  %op3 = load i32, i32* %op1
-  %op4 = load i32, i32* %op0
-  %op5 = icmp slt i32 %op3, %op4
-  %op6 = zext i1 %op5 to i32
-  %op7 = icmp ne i32 %op6, 0
-  br i1 %op7, label %label8, label %label12
-label8:                                                ; preds = %label2
-  %op9 = load i32, i32* %op1
-  call void @output(i32 %op9)
-  %op10 = load i32, i32* %op1
-  %op11 = add i32 %op10, 1
-  store i32 %op11, i32* %op1
-  br label %label2
-label12:                                                ; preds = %label2
-  ret i32 0
-}

tests/3-codegen/autogen/output/5-while.out

-0
-1
-2
-3
-4
-5
-6
-7
-8
-9
-0

tests/3-codegen/autogen/output/5-while.s

-	.text
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -80
-.main_label_entry:
-# %op0 = alloca i32
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# %op1 = alloca i32
-	addi.d $t0, $fp, -40
-	st.d $t0, $fp, -36
-# store i32 10, i32* %op0
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 10
-	st.w $t1, $t0, 0
-# store i32 0, i32* %op1
-	ld.d $t0, $fp, -36
-	addi.w $t1, $zero, 0
-	st.w $t1, $t0, 0
-# br label %label2
-	b .main_label2
-.main_label2:
-# %op3 = load i32, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -44
-# %op4 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -48
-# %op5 = icmp slt i32 %op3, %op4
-	ld.w $t0, $fp, -44
-	ld.w $t1, $fp, -48
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -49
-# %op6 = zext i1 %op5 to i32
-	ld.b $t0, $fp, -49
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -53
-# %op7 = icmp ne i32 %op6, 0
-	ld.w $t0, $fp, -53
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -54
-# br i1 %op7, label %label8, label %label12
-	ld.b $t0, $fp, -54
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label8
-	b .main_label12
-.main_label8:
-# %op9 = load i32, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -58
-# call void @output(i32 %op9)
-	ld.w $a0, $fp, -58
-	bl output
-# %op10 = load i32, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -62
-# %op11 = add i32 %op10, 1
-	ld.w $t0, $fp, -62
-	addi.w $t1, $zero, 1
-	add.w $t2, $t0, $t1
-	st.w $t2, $fp, -66
-# store i32 %op11, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t1, $fp, -66
-	st.w $t1, $t0, 0
-# br label %label2
-	b .main_label2
-.main_label12:
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 80
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/6-array.ll

-; ModuleID = 'cminus'
-source_filename = "/code/compiler/24.ta/tests/3-codegen/autogen/testcases/6-array.cminus"
-
-declare i32 @input()
-
-declare void @output(i32)
-
-declare void @outputFloat(float)
-
-declare void @neg_idx_except()
-
-define i32 @main() {
-label_entry:
-  %op0 = alloca [10 x i32]
-  %op1 = alloca i32
-  store i32 0, i32* %op1
-  %op2 = icmp slt i32 0, 0
-  br i1 %op2, label %label3, label %label4
-label3:                                                ; preds = %label_entry
-  call void @neg_idx_except()
-  ret i32 0
-label4:                                                ; preds = %label_entry
-  %op5 = getelementptr [10 x i32], [10 x i32]* %op0, i32 0, i32 0
-  store i32 11, i32* %op5
-  %op6 = icmp slt i32 4, 0
-  br i1 %op6, label %label7, label %label8
-label7:                                                ; preds = %label4
-  call void @neg_idx_except()
-  ret i32 0
-label8:                                                ; preds = %label4
-  %op9 = getelementptr [10 x i32], [10 x i32]* %op0, i32 0, i32 4
-  store i32 22, i32* %op9
-  %op10 = icmp slt i32 9, 0
-  br i1 %op10, label %label11, label %label12
-label11:                                                ; preds = %label8
-  call void @neg_idx_except()
-  ret i32 0
-label12:                                                ; preds = %label8
-  %op13 = getelementptr [10 x i32], [10 x i32]* %op0, i32 0, i32 9
-  store i32 33, i32* %op13
-  %op14 = icmp slt i32 0, 0
-  br i1 %op14, label %label15, label %label16
-label15:                                                ; preds = %label12
-  call void @neg_idx_except()
-  ret i32 0
-label16:                                                ; preds = %label12
-  %op17 = getelementptr [10 x i32], [10 x i32]* %op0, i32 0, i32 0
-  %op18 = load i32, i32* %op17
-  call void @output(i32 %op18)
-  %op19 = icmp slt i32 4, 0
-  br i1 %op19, label %label20, label %label21
-label20:                                                ; preds = %label16
-  call void @neg_idx_except()
-  ret i32 0
-label21:                                                ; preds = %label16
-  %op22 = getelementptr [10 x i32], [10 x i32]* %op0, i32 0, i32 4
-  %op23 = load i32, i32* %op22
-  call void @output(i32 %op23)
-  %op24 = icmp slt i32 9, 0
-  br i1 %op24, label %label25, label %label26
-label25:                                                ; preds = %label21
-  call void @neg_idx_except()
-  ret i32 0
-label26:                                                ; preds = %label21
-  %op27 = getelementptr [10 x i32], [10 x i32]* %op0, i32 0, i32 9
-  %op28 = load i32, i32* %op27
-  call void @output(i32 %op28)
-  ret i32 0
-}

tests/3-codegen/autogen/output/6-array.out

-11
-22
-33
-0

tests/3-codegen/autogen/output/6-array.s

-	.text
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -144
-.main_label_entry:
-# %op0 = alloca [10 x i32]
-	addi.d $t0, $fp, -64
-	st.d $t0, $fp, -24
-# %op1 = alloca i32
-	addi.d $t0, $fp, -76
-	st.d $t0, $fp, -72
-# store i32 0, i32* %op1
-	ld.d $t0, $fp, -72
-	addi.w $t1, $zero, 0
-	st.w $t1, $t0, 0
-# %op2 = icmp slt i32 0, 0
-	addi.w $t0, $zero, 0
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -77
-# br i1 %op2, label %label3, label %label4
-	ld.b $t0, $fp, -77
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label3
-	b .main_label4
-.main_label3:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label4:
-# %op5 = getelementptr [10 x i32], [10 x i32]* %op0, i32 0, i32 0
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 40
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -85
-# store i32 11, i32* %op5
-	ld.d $t0, $fp, -85
-	addi.w $t1, $zero, 11
-	st.w $t1, $t0, 0
-# %op6 = icmp slt i32 4, 0
-	addi.w $t0, $zero, 4
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -86
-# br i1 %op6, label %label7, label %label8
-	ld.b $t0, $fp, -86
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label7
-	b .main_label8
-.main_label7:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label8:
-# %op9 = getelementptr [10 x i32], [10 x i32]* %op0, i32 0, i32 4
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 40
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	addi.w $t1, $zero, 4
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -94
-# store i32 22, i32* %op9
-	ld.d $t0, $fp, -94
-	addi.w $t1, $zero, 22
-	st.w $t1, $t0, 0
-# %op10 = icmp slt i32 9, 0
-	addi.w $t0, $zero, 9
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -95
-# br i1 %op10, label %label11, label %label12
-	ld.b $t0, $fp, -95
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label11
-	b .main_label12
-.main_label11:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label12:
-# %op13 = getelementptr [10 x i32], [10 x i32]* %op0, i32 0, i32 9
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 40
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	addi.w $t1, $zero, 9
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -103
-# store i32 33, i32* %op13
-	ld.d $t0, $fp, -103
-	addi.w $t1, $zero, 33
-	st.w $t1, $t0, 0
-# %op14 = icmp slt i32 0, 0
-	addi.w $t0, $zero, 0
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -104
-# br i1 %op14, label %label15, label %label16
-	ld.b $t0, $fp, -104
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label15
-	b .main_label16
-.main_label15:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label16:
-# %op17 = getelementptr [10 x i32], [10 x i32]* %op0, i32 0, i32 0
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 40
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -112
-# %op18 = load i32, i32* %op17
-	ld.d $t0, $fp, -112
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -116
-# call void @output(i32 %op18)
-	ld.w $a0, $fp, -116
-	bl output
-# %op19 = icmp slt i32 4, 0
-	addi.w $t0, $zero, 4
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -117
-# br i1 %op19, label %label20, label %label21
-	ld.b $t0, $fp, -117
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label20
-	b .main_label21
-.main_label20:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label21:
-# %op22 = getelementptr [10 x i32], [10 x i32]* %op0, i32 0, i32 4
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 40
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	addi.w $t1, $zero, 4
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -125
-# %op23 = load i32, i32* %op22
-	ld.d $t0, $fp, -125
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -129
-# call void @output(i32 %op23)
-	ld.w $a0, $fp, -129
-	bl output
-# %op24 = icmp slt i32 9, 0
-	addi.w $t0, $zero, 9
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -130
-# br i1 %op24, label %label25, label %label26
-	ld.b $t0, $fp, -130
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label25
-	b .main_label26
-.main_label25:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label26:
-# %op27 = getelementptr [10 x i32], [10 x i32]* %op0, i32 0, i32 9
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 40
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	addi.w $t1, $zero, 9
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -138
-# %op28 = load i32, i32* %op27
-	ld.d $t0, $fp, -138
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -142
-# call void @output(i32 %op28)
-	ld.w $a0, $fp, -142
-	bl output
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 144
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/6-num_add_int.out

-210

tests/3-codegen/autogen/output/6-num_add_int.s

-	.text
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -48
-.main_label_entry:
-# %op0 = alloca i32
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# %op1 = add i32 1000, 234
-	addi.w $t0, $zero, 1000
-	addi.w $t1, $zero, 234
-	add.w $t2, $t0, $t1
-	st.w $t2, $fp, -32
-# store i32 %op1, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t1, $fp, -32
-	st.w $t1, $t0, 0
-# %op2 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -36
-# ret i32 %op2
-	ld.w $a0, $fp, -36
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 48
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/7-assign_int_var_local.out

-210

tests/3-codegen/autogen/output/7-assign_int_var_local.s

-	.text
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -32
-.main_label_entry:
-# %op0 = alloca i32
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# store i32 1234, i32* %op0
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 1234
-	st.w $t1, $t0, 0
-# %op1 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -32
-# ret i32 %op1
-	ld.w $a0, $fp, -32
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 32
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/7-function.ll

-; ModuleID = 'cminus'
-source_filename = "/code/compiler/24.ta/tests/3-codegen/autogen/testcases/7-function.cminus"
-
-declare i32 @input()
-
-declare void @output(i32)
-
-declare void @outputFloat(float)
-
-declare void @neg_idx_except()
-
-define i32 @min(i32 %arg0, i32 %arg1) {
-label_entry:
-  %op2 = alloca i32
-  store i32 %arg0, i32* %op2
-  %op3 = alloca i32
-  store i32 %arg1, i32* %op3
-  %op4 = load i32, i32* %op2
-  %op5 = load i32, i32* %op3
-  %op6 = icmp sle i32 %op4, %op5
-  %op7 = zext i1 %op6 to i32
-  %op8 = icmp ne i32 %op7, 0
-  br i1 %op8, label %label9, label %label12
-label9:                                                ; preds = %label_entry
-  %op10 = load i32, i32* %op2
-  ret i32 %op10
-label11:
-  ret i32 0
-label12:                                                ; preds = %label_entry
-  %op13 = load i32, i32* %op3
-  ret i32 %op13
-}
-define i32 @main() {
-label_entry:
-  %op0 = alloca i32
-  %op1 = alloca i32
-  %op2 = alloca i32
-  store i32 11, i32* %op0
-  store i32 22, i32* %op1
-  store i32 33, i32* %op2
-  %op3 = load i32, i32* %op0
-  %op4 = load i32, i32* %op1
-  %op5 = call i32 @min(i32 %op3, i32 %op4)
-  call void @output(i32 %op5)
-  %op6 = load i32, i32* %op1
-  %op7 = load i32, i32* %op2
-  %op8 = call i32 @min(i32 %op6, i32 %op7)
-  call void @output(i32 %op8)
-  %op9 = load i32, i32* %op2
-  %op10 = load i32, i32* %op0
-  %op11 = call i32 @min(i32 %op9, i32 %op10)
-  call void @output(i32 %op11)
-  ret i32 0
-}

tests/3-codegen/autogen/output/7-function.out

-11
-22
-11
-0

tests/3-codegen/autogen/output/7-function.s

-	.text
-	.globl min
-	.type min, @function
-min:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -80
-	st.w $a0, $fp, -20
-	st.w $a1, $fp, -24
-.min_label_entry:
-# %op2 = alloca i32
-	addi.d $t0, $fp, -36
-	st.d $t0, $fp, -32
-# store i32 %arg0, i32* %op2
-	ld.d $t0, $fp, -32
-	ld.w $t1, $fp, -20
-	st.w $t1, $t0, 0
-# %op3 = alloca i32
-	addi.d $t0, $fp, -48
-	st.d $t0, $fp, -44
-# store i32 %arg1, i32* %op3
-	ld.d $t0, $fp, -44
-	ld.w $t1, $fp, -24
-	st.w $t1, $t0, 0
-# %op4 = load i32, i32* %op2
-	ld.d $t0, $fp, -32
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -52
-# %op5 = load i32, i32* %op3
-	ld.d $t0, $fp, -44
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -56
-# %op6 = icmp sle i32 %op4, %op5
-	ld.w $t0, $fp, -52
-	ld.w $t1, $fp, -56
-	slt $t2, $t1, $t0
-	xori $t2, $t2, 1
-	st.b $t2, $fp, -57
-# %op7 = zext i1 %op6 to i32
-	ld.b $t0, $fp, -57
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -61
-# %op8 = icmp ne i32 %op7, 0
-	ld.w $t0, $fp, -61
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -62
-# br i1 %op8, label %label9, label %label12
-	ld.b $t0, $fp, -62
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .min_label9
-	b .min_label12
-.min_label9:
-# %op10 = load i32, i32* %op2
-	ld.d $t0, $fp, -32
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -66
-# ret i32 %op10
-	ld.w $a0, $fp, -66
-	b min_exit
-.min_label11:
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b min_exit
-.min_label12:
-# %op13 = load i32, i32* %op3
-	ld.d $t0, $fp, -44
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -70
-# ret i32 %op13
-	ld.w $a0, $fp, -70
-	b min_exit
-min_exit:
-	addi.d $sp, $sp, 80
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -96
-.main_label_entry:
-# %op0 = alloca i32
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# %op1 = alloca i32
-	addi.d $t0, $fp, -40
-	st.d $t0, $fp, -36
-# %op2 = alloca i32
-	addi.d $t0, $fp, -52
-	st.d $t0, $fp, -48
-# store i32 11, i32* %op0
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 11
-	st.w $t1, $t0, 0
-# store i32 22, i32* %op1
-	ld.d $t0, $fp, -36
-	addi.w $t1, $zero, 22
-	st.w $t1, $t0, 0
-# store i32 33, i32* %op2
-	ld.d $t0, $fp, -48
-	addi.w $t1, $zero, 33
-	st.w $t1, $t0, 0
-# %op3 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -56
-# %op4 = load i32, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -60
-# %op5 = call i32 @min(i32 %op3, i32 %op4)
-	ld.w $a0, $fp, -56
-	ld.w $a1, $fp, -60
-	bl min
-	st.w $a0, $fp, -64
-# call void @output(i32 %op5)
-	ld.w $a0, $fp, -64
-	bl output
-# %op6 = load i32, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -68
-# %op7 = load i32, i32* %op2
-	ld.d $t0, $fp, -48
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -72
-# %op8 = call i32 @min(i32 %op6, i32 %op7)
-	ld.w $a0, $fp, -68
-	ld.w $a1, $fp, -72
-	bl min
-	st.w $a0, $fp, -76
-# call void @output(i32 %op8)
-	ld.w $a0, $fp, -76
-	bl output
-# %op9 = load i32, i32* %op2
-	ld.d $t0, $fp, -48
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -80
-# %op10 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -84
-# %op11 = call i32 @min(i32 %op9, i32 %op10)
-	ld.w $a0, $fp, -80
-	ld.w $a1, $fp, -84
-	bl min
-	st.w $a0, $fp, -88
-# call void @output(i32 %op11)
-	ld.w $a0, $fp, -88
-	bl output
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 96
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/8-assign_int_array_local.out

-210

tests/3-codegen/autogen/output/8-assign_int_array_local.s

-	.text
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -96
-.main_label_entry:
-# %op0 = alloca [10 x i32]
-	addi.d $t0, $fp, -64
-	st.d $t0, $fp, -24
-# %op1 = icmp slt i32 3, 0
-	addi.w $t0, $zero, 3
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -65
-# br i1 %op1, label %label2, label %label3
-	ld.b $t0, $fp, -65
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label2
-	b .main_label3
-.main_label2:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label3:
-# %op4 = getelementptr [10 x i32], [10 x i32]* %op0, i32 0, i32 3
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 40
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	addi.w $t1, $zero, 3
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -73
-# store i32 1234, i32* %op4
-	ld.d $t0, $fp, -73
-	addi.w $t1, $zero, 1234
-	st.w $t1, $t0, 0
-# %op5 = icmp slt i32 3, 0
-	addi.w $t0, $zero, 3
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -74
-# br i1 %op5, label %label6, label %label7
-	ld.b $t0, $fp, -74
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label6
-	b .main_label7
-.main_label6:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label7:
-# %op8 = getelementptr [10 x i32], [10 x i32]* %op0, i32 0, i32 3
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 40
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	addi.w $t1, $zero, 3
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -82
-# %op9 = load i32, i32* %op8
-	ld.d $t0, $fp, -82
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -86
-# ret i32 %op9
-	ld.w $a0, $fp, -86
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 96
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/8-store.ll

-; ModuleID = 'cminus'
-source_filename = "/code/compiler/24.ta/tests/3-codegen/autogen/testcases/8-store.cminus"
-
-declare i32 @input()
-
-declare void @output(i32)
-
-declare void @outputFloat(float)
-
-declare void @neg_idx_except()
-
-define i32 @store(i32* %arg0, i32 %arg1, i32 %arg2) {
-label_entry:
-  %op3 = alloca i32*
-  store i32* %arg0, i32** %op3
-  %op4 = alloca i32
-  store i32 %arg1, i32* %op4
-  %op5 = alloca i32
-  store i32 %arg2, i32* %op5
-  %op6 = load i32, i32* %op5
-  %op7 = load i32, i32* %op4
-  %op8 = icmp slt i32 %op7, 0
-  br i1 %op8, label %label9, label %label10
-label9:                                                ; preds = %label_entry
-  call void @neg_idx_except()
-  ret i32 0
-label10:                                                ; preds = %label_entry
-  %op11 = load i32*, i32** %op3
-  %op12 = getelementptr i32, i32* %op11, i32 %op7
-  store i32 %op6, i32* %op12
-  %op13 = load i32, i32* %op5
-  ret i32 %op13
-}
-define i32 @main() {
-label_entry:
-  %op0 = alloca [10 x i32]
-  %op1 = alloca i32
-  %op2 = alloca i32
-  store i32 0, i32* %op1
-  br label %label3
-label3:                                                ; preds = %label_entry, %label8
-  %op4 = load i32, i32* %op1
-  %op5 = icmp slt i32 %op4, 10
-  %op6 = zext i1 %op5 to i32
-  %op7 = icmp ne i32 %op6, 0
-  br i1 %op7, label %label8, label %label16
-label8:                                                ; preds = %label3
-  %op9 = getelementptr [10 x i32], [10 x i32]* %op0, i32 0, i32 0
-  %op10 = load i32, i32* %op1
-  %op11 = load i32, i32* %op1
-  %op12 = mul i32 %op11, 2
-  %op13 = call i32 @store(i32* %op9, i32 %op10, i32 %op12)
-  %op14 = load i32, i32* %op1
-  %op15 = add i32 %op14, 1
-  store i32 %op15, i32* %op1
-  br label %label3
-label16:                                                ; preds = %label3
-  store i32 0, i32* %op2
-  store i32 0, i32* %op1
-  br label %label17
-label17:                                                ; preds = %label16, %label29
-  %op18 = load i32, i32* %op1
-  %op19 = icmp slt i32 %op18, 10
-  %op20 = zext i1 %op19 to i32
-  %op21 = icmp ne i32 %op20, 0
-  br i1 %op21, label %label22, label %label26
-label22:                                                ; preds = %label17
-  %op23 = load i32, i32* %op2
-  %op24 = load i32, i32* %op1
-  %op25 = icmp slt i32 %op24, 0
-  br i1 %op25, label %label28, label %label29
-label26:                                                ; preds = %label17
-  %op27 = load i32, i32* %op2
-  call void @output(i32 %op27)
-  ret i32 0
-label28:                                                ; preds = %label22
-  call void @neg_idx_except()
-  ret i32 0
-label29:                                                ; preds = %label22
-  %op30 = getelementptr [10 x i32], [10 x i32]* %op0, i32 0, i32 %op24
-  %op31 = load i32, i32* %op30
-  %op32 = add i32 %op23, %op31
-  store i32 %op32, i32* %op2
-  %op33 = load i32, i32* %op1
-  %op34 = add i32 %op33, 1
-  store i32 %op34, i32* %op1
-  br label %label17
-}

tests/3-codegen/autogen/output/8-store.out

-90
-0

tests/3-codegen/autogen/output/8-store.s

-	.text
-	.globl store
-	.type store, @function
-store:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -112
-	st.d $a0, $fp, -24
-	st.w $a1, $fp, -28
-	st.w $a2, $fp, -32
-.store_label_entry:
-# %op3 = alloca i32*
-	addi.d $t0, $fp, -48
-	st.d $t0, $fp, -40
-# store i32* %arg0, i32** %op3
-	ld.d $t0, $fp, -40
-	ld.d $t1, $fp, -24
-	st.d $t1, $t0, 0
-# %op4 = alloca i32
-	addi.d $t0, $fp, -60
-	st.d $t0, $fp, -56
-# store i32 %arg1, i32* %op4
-	ld.d $t0, $fp, -56
-	ld.w $t1, $fp, -28
-	st.w $t1, $t0, 0
-# %op5 = alloca i32
-	addi.d $t0, $fp, -72
-	st.d $t0, $fp, -68
-# store i32 %arg2, i32* %op5
-	ld.d $t0, $fp, -68
-	ld.w $t1, $fp, -32
-	st.w $t1, $t0, 0
-# %op6 = load i32, i32* %op5
-	ld.d $t0, $fp, -68
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -76
-# %op7 = load i32, i32* %op4
-	ld.d $t0, $fp, -56
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -80
-# %op8 = icmp slt i32 %op7, 0
-	ld.w $t0, $fp, -80
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -81
-# br i1 %op8, label %label9, label %label10
-	ld.b $t0, $fp, -81
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .store_label9
-	b .store_label10
-.store_label9:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b store_exit
-.store_label10:
-# %op11 = load i32*, i32** %op3
-	ld.d $t0, $fp, -40
-	ld.d $t0, $t0, 0
-	st.d $t0, $fp, -89
-# %op12 = getelementptr i32, i32* %op11, i32 %op7
-	ld.d $t0, $fp, -89
-	ld.w $t1, $fp, -80
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -97
-# store i32 %op6, i32* %op12
-	ld.d $t0, $fp, -97
-	ld.w $t1, $fp, -76
-	st.w $t1, $t0, 0
-# %op13 = load i32, i32* %op5
-	ld.d $t0, $fp, -68
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -101
-# ret i32 %op13
-	ld.w $a0, $fp, -101
-	b store_exit
-store_exit:
-	addi.d $sp, $sp, 112
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -192
-.main_label_entry:
-# %op0 = alloca [10 x i32]
-	addi.d $t0, $fp, -64
-	st.d $t0, $fp, -24
-# %op1 = alloca i32
-	addi.d $t0, $fp, -76
-	st.d $t0, $fp, -72
-# %op2 = alloca i32
-	addi.d $t0, $fp, -88
-	st.d $t0, $fp, -84
-# store i32 0, i32* %op1
-	ld.d $t0, $fp, -72
-	addi.w $t1, $zero, 0
-	st.w $t1, $t0, 0
-# br label %label3
-	b .main_label3
-.main_label3:
-# %op4 = load i32, i32* %op1
-	ld.d $t0, $fp, -72
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -92
-# %op5 = icmp slt i32 %op4, 10
-	ld.w $t0, $fp, -92
-	addi.w $t1, $zero, 10
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -93
-# %op6 = zext i1 %op5 to i32
-	ld.b $t0, $fp, -93
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -97
-# %op7 = icmp ne i32 %op6, 0
-	ld.w $t0, $fp, -97
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -98
-# br i1 %op7, label %label8, label %label16
-	ld.b $t0, $fp, -98
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label8
-	b .main_label16
-.main_label8:
-# %op9 = getelementptr [10 x i32], [10 x i32]* %op0, i32 0, i32 0
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 40
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -106
-# %op10 = load i32, i32* %op1
-	ld.d $t0, $fp, -72
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -110
-# %op11 = load i32, i32* %op1
-	ld.d $t0, $fp, -72
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -114
-# %op12 = mul i32 %op11, 2
-	ld.w $t0, $fp, -114
-	addi.w $t1, $zero, 2
-	mul.w $t2, $t0, $t1
-	st.w $t2, $fp, -118
-# %op13 = call i32 @store(i32* %op9, i32 %op10, i32 %op12)
-	ld.d $a0, $fp, -106
-	ld.w $a1, $fp, -110
-	ld.w $a2, $fp, -118
-	bl store
-	st.w $a0, $fp, -122
-# %op14 = load i32, i32* %op1
-	ld.d $t0, $fp, -72
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -126
-# %op15 = add i32 %op14, 1
-	ld.w $t0, $fp, -126
-	addi.w $t1, $zero, 1
-	add.w $t2, $t0, $t1
-	st.w $t2, $fp, -130
-# store i32 %op15, i32* %op1
-	ld.d $t0, $fp, -72
-	ld.w $t1, $fp, -130
-	st.w $t1, $t0, 0
-# br label %label3
-	b .main_label3
-.main_label16:
-# store i32 0, i32* %op2
-	ld.d $t0, $fp, -84
-	addi.w $t1, $zero, 0
-	st.w $t1, $t0, 0
-# store i32 0, i32* %op1
-	ld.d $t0, $fp, -72
-	addi.w $t1, $zero, 0
-	st.w $t1, $t0, 0
-# br label %label17
-	b .main_label17
-.main_label17:
-# %op18 = load i32, i32* %op1
-	ld.d $t0, $fp, -72
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -134
-# %op19 = icmp slt i32 %op18, 10
-	ld.w $t0, $fp, -134
-	addi.w $t1, $zero, 10
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -135
-# %op20 = zext i1 %op19 to i32
-	ld.b $t0, $fp, -135
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -139
-# %op21 = icmp ne i32 %op20, 0
-	ld.w $t0, $fp, -139
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -140
-# br i1 %op21, label %label22, label %label26
-	ld.b $t0, $fp, -140
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label22
-	b .main_label26
-.main_label22:
-# %op23 = load i32, i32* %op2
-	ld.d $t0, $fp, -84
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -144
-# %op24 = load i32, i32* %op1
-	ld.d $t0, $fp, -72
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -148
-# %op25 = icmp slt i32 %op24, 0
-	ld.w $t0, $fp, -148
-	addi.w $t1, $zero, 0
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -149
-# br i1 %op25, label %label28, label %label29
-	ld.b $t0, $fp, -149
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label28
-	b .main_label29
-.main_label26:
-# %op27 = load i32, i32* %op2
-	ld.d $t0, $fp, -84
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -153
-# call void @output(i32 %op27)
-	ld.w $a0, $fp, -153
-	bl output
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label28:
-# call void @neg_idx_except()
-	bl neg_idx_except
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-.main_label29:
-# %op30 = getelementptr [10 x i32], [10 x i32]* %op0, i32 0, i32 %op24
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 0
-	addi.d $t2, $zero, 40
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	ld.w $t1, $fp, -148
-	addi.d $t2, $zero, 4
-	mul.d $t1, $t1, $t2
-	add.d $t0, $t0, $t1
-	st.d $t0, $fp, -161
-# %op31 = load i32, i32* %op30
-	ld.d $t0, $fp, -161
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -165
-# %op32 = add i32 %op23, %op31
-	ld.w $t0, $fp, -144
-	ld.w $t1, $fp, -165
-	add.w $t2, $t0, $t1
-	st.w $t2, $fp, -169
-# store i32 %op32, i32* %op2
-	ld.d $t0, $fp, -84
-	ld.w $t1, $fp, -169
-	st.w $t1, $t0, 0
-# %op33 = load i32, i32* %op1
-	ld.d $t0, $fp, -72
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -173
-# %op34 = add i32 %op33, 1
-	ld.w $t0, $fp, -173
-	addi.w $t1, $zero, 1
-	add.w $t2, $t0, $t1
-	st.w $t2, $fp, -177
-# store i32 %op34, i32* %op1
-	ld.d $t0, $fp, -72
-	ld.w $t1, $fp, -177
-	st.w $t1, $t0, 0
-# br label %label17
-	b .main_label17
-main_exit:
-	addi.d $sp, $sp, 192
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/9-assign_cast.out

-5

tests/3-codegen/autogen/output/9-assign_cast.s

-	.text
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -80
-.main_label_entry:
-# %op0 = alloca i32
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# %op1 = alloca i32
-	addi.d $t0, $fp, -40
-	st.d $t0, $fp, -36
-# %op2 = icmp slt i32 1, 3
-	addi.w $t0, $zero, 1
-	addi.w $t1, $zero, 3
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -41
-# %op3 = zext i1 %op2 to i32
-	ld.b $t0, $fp, -41
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -45
-# store i32 %op3, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t1, $fp, -45
-	st.w $t1, $t0, 0
-# %op4 = sitofp i32 2 to float
-	addi.w $t0, $zero, 2
-	movgr2fr.w $ft0, $t0
-	ffint.s.w $ft0, $ft0
-	fst.s $ft0, $fp, -49
-# %op5 = fadd float %op4, 0x4003333340000000
-	fld.s $ft0, $fp, -49
-	lu12i.w $t8, 262553
-	ori $t8, $t8, 2458
-	movgr2fr.w $ft1, $t8
-	fadd.s $ft2, $ft0, $ft1
-	fst.s $ft2, $fp, -53
-# %op6 = fptosi float %op5 to i32
-	fld.s $ft0, $fp, -53
-	ftintrz.w.s $ft0, $ft0
-	movfr2gr.s $t0, $ft0
-	st.w $t0, $fp, -57
-# store i32 %op6, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t1, $fp, -57
-	st.w $t1, $t0, 0
-# %op7 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -61
-# %op8 = load i32, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -65
-# %op9 = add i32 %op7, %op8
-	ld.w $t0, $fp, -61
-	ld.w $t1, $fp, -65
-	add.w $t2, $t0, $t1
-	st.w $t2, $fp, -69
-# ret i32 %op9
-	ld.w $a0, $fp, -69
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 80
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra

tests/3-codegen/autogen/output/9-fibonacci.ll

-; ModuleID = 'cminus'
-source_filename = "/code/compiler/24.ta/tests/3-codegen/autogen/testcases/9-fibonacci.cminus"
-
-declare i32 @input()
-
-declare void @output(i32)
-
-declare void @outputFloat(float)
-
-declare void @neg_idx_except()
-
-define i32 @fibonacci(i32 %arg0) {
-label_entry:
-  %op1 = alloca i32
-  store i32 %arg0, i32* %op1
-  %op2 = load i32, i32* %op1
-  %op3 = icmp eq i32 %op2, 0
-  %op4 = zext i1 %op3 to i32
-  %op5 = icmp ne i32 %op4, 0
-  br i1 %op5, label %label6, label %label8
-label6:                                                ; preds = %label_entry
-  ret i32 0
-label7:                                                ; preds = %label14
-  ret i32 0
-label8:                                                ; preds = %label_entry
-  %op9 = load i32, i32* %op1
-  %op10 = icmp eq i32 %op9, 1
-  %op11 = zext i1 %op10 to i32
-  %op12 = icmp ne i32 %op11, 0
-  br i1 %op12, label %label13, label %label15
-label13:                                                ; preds = %label8
-  ret i32 1
-label14:
-  br label %label7
-label15:                                                ; preds = %label8
-  %op16 = load i32, i32* %op1
-  %op17 = sub i32 %op16, 1
-  %op18 = call i32 @fibonacci(i32 %op17)
-  %op19 = load i32, i32* %op1
-  %op20 = sub i32 %op19, 2
-  %op21 = call i32 @fibonacci(i32 %op20)
-  %op22 = add i32 %op18, %op21
-  ret i32 %op22
-}
-define i32 @main() {
-label_entry:
-  %op0 = alloca i32
-  %op1 = alloca i32
-  store i32 10, i32* %op0
-  store i32 0, i32* %op1
-  br label %label2
-label2:                                                ; preds = %label_entry, %label8
-  %op3 = load i32, i32* %op1
-  %op4 = load i32, i32* %op0
-  %op5 = icmp slt i32 %op3, %op4
-  %op6 = zext i1 %op5 to i32
-  %op7 = icmp ne i32 %op6, 0
-  br i1 %op7, label %label8, label %label13
-label8:                                                ; preds = %label2
-  %op9 = load i32, i32* %op1
-  %op10 = call i32 @fibonacci(i32 %op9)
-  call void @output(i32 %op10)
-  %op11 = load i32, i32* %op1
-  %op12 = add i32 %op11, 1
-  store i32 %op12, i32* %op1
-  br label %label2
-label13:                                                ; preds = %label2
-  ret i32 0
-}

tests/3-codegen/autogen/output/9-fibonacci.out

-0
-1
-1
-2
-3
-5
-8
-13
-21
-34
-0

tests/3-codegen/autogen/output/9-fibonacci.s

-	.text
-	.globl fibonacci
-	.type fibonacci, @function
-fibonacci:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -80
-	st.w $a0, $fp, -20
-.fibonacci_label_entry:
-# %op1 = alloca i32
-	addi.d $t0, $fp, -32
-	st.d $t0, $fp, -28
-# store i32 %arg0, i32* %op1
-	ld.d $t0, $fp, -28
-	ld.w $t1, $fp, -20
-	st.w $t1, $t0, 0
-# %op2 = load i32, i32* %op1
-	ld.d $t0, $fp, -28
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -36
-# %op3 = icmp eq i32 %op2, 0
-	ld.w $t0, $fp, -36
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltui $t2, $t2, 1
-	st.b $t2, $fp, -37
-# %op4 = zext i1 %op3 to i32
-	ld.b $t0, $fp, -37
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -41
-# %op5 = icmp ne i32 %op4, 0
-	ld.w $t0, $fp, -41
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -42
-# br i1 %op5, label %label6, label %label8
-	ld.b $t0, $fp, -42
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .fibonacci_label6
-	b .fibonacci_label8
-.fibonacci_label6:
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b fibonacci_exit
-.fibonacci_label7:
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b fibonacci_exit
-.fibonacci_label8:
-# %op9 = load i32, i32* %op1
-	ld.d $t0, $fp, -28
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -46
-# %op10 = icmp eq i32 %op9, 1
-	ld.w $t0, $fp, -46
-	addi.w $t1, $zero, 1
-	xor $t2, $t0, $t1
-	sltui $t2, $t2, 1
-	st.b $t2, $fp, -47
-# %op11 = zext i1 %op10 to i32
-	ld.b $t0, $fp, -47
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -51
-# %op12 = icmp ne i32 %op11, 0
-	ld.w $t0, $fp, -51
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -52
-# br i1 %op12, label %label13, label %label15
-	ld.b $t0, $fp, -52
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .fibonacci_label13
-	b .fibonacci_label15
-.fibonacci_label13:
-# ret i32 1
-	addi.w $a0, $zero, 1
-	b fibonacci_exit
-.fibonacci_label14:
-# br label %label7
-	b .fibonacci_label7
-.fibonacci_label15:
-# %op16 = load i32, i32* %op1
-	ld.d $t0, $fp, -28
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -56
-# %op17 = sub i32 %op16, 1
-	ld.w $t0, $fp, -56
-	addi.w $t1, $zero, 1
-	sub.w $t2, $t0, $t1
-	st.w $t2, $fp, -60
-# %op18 = call i32 @fibonacci(i32 %op17)
-	ld.w $a0, $fp, -60
-	bl fibonacci
-	st.w $a0, $fp, -64
-# %op19 = load i32, i32* %op1
-	ld.d $t0, $fp, -28
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -68
-# %op20 = sub i32 %op19, 2
-	ld.w $t0, $fp, -68
-	addi.w $t1, $zero, 2
-	sub.w $t2, $t0, $t1
-	st.w $t2, $fp, -72
-# %op21 = call i32 @fibonacci(i32 %op20)
-	ld.w $a0, $fp, -72
-	bl fibonacci
-	st.w $a0, $fp, -76
-# %op22 = add i32 %op18, %op21
-	ld.w $t0, $fp, -64
-	ld.w $t1, $fp, -76
-	add.w $t2, $t0, $t1
-	st.w $t2, $fp, -80
-# ret i32 %op22
-	ld.w $a0, $fp, -80
-	b fibonacci_exit
-fibonacci_exit:
-	addi.d $sp, $sp, 80
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra
-	.globl main
-	.type main, @function
-main:
-	st.d $ra, $sp, -8
-	st.d $fp, $sp, -16
-	addi.d $fp, $sp, 0
-	addi.d $sp, $sp, -80
-.main_label_entry:
-# %op0 = alloca i32
-	addi.d $t0, $fp, -28
-	st.d $t0, $fp, -24
-# %op1 = alloca i32
-	addi.d $t0, $fp, -40
-	st.d $t0, $fp, -36
-# store i32 10, i32* %op0
-	ld.d $t0, $fp, -24
-	addi.w $t1, $zero, 10
-	st.w $t1, $t0, 0
-# store i32 0, i32* %op1
-	ld.d $t0, $fp, -36
-	addi.w $t1, $zero, 0
-	st.w $t1, $t0, 0
-# br label %label2
-	b .main_label2
-.main_label2:
-# %op3 = load i32, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -44
-# %op4 = load i32, i32* %op0
-	ld.d $t0, $fp, -24
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -48
-# %op5 = icmp slt i32 %op3, %op4
-	ld.w $t0, $fp, -44
-	ld.w $t1, $fp, -48
-	slt $t2, $t0, $t1
-	st.b $t2, $fp, -49
-# %op6 = zext i1 %op5 to i32
-	ld.b $t0, $fp, -49
-	bstrpick.w $t0, $t0, 0, 0
-	st.w $t0, $fp, -53
-# %op7 = icmp ne i32 %op6, 0
-	ld.w $t0, $fp, -53
-	addi.w $t1, $zero, 0
-	xor $t2, $t0, $t1
-	sltu $t2, $zero, $t2
-	st.b $t2, $fp, -54
-# br i1 %op7, label %label8, label %label13
-	ld.b $t0, $fp, -54
-	bstrpick.d $t0, $t0, 0, 0
-	bne $t0, $zero, .main_label8
-	b .main_label13
-.main_label8:
-# %op9 = load i32, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -58
-# %op10 = call i32 @fibonacci(i32 %op9)
-	ld.w $a0, $fp, -58
-	bl fibonacci
-	st.w $a0, $fp, -62
-# call void @output(i32 %op10)
-	ld.w $a0, $fp, -62
-	bl output
-# %op11 = load i32, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t0, $t0, 0
-	st.w $t0, $fp, -66
-# %op12 = add i32 %op11, 1
-	ld.w $t0, $fp, -66
-	addi.w $t1, $zero, 1
-	add.w $t2, $t0, $t1
-	st.w $t2, $fp, -70
-# store i32 %op12, i32* %op1
-	ld.d $t0, $fp, -36
-	ld.w $t1, $fp, -70
-	st.w $t1, $t0, 0
-# br label %label2
-	b .main_label2
-.main_label13:
-# ret i32 0
-	addi.w $a0, $zero, 0
-	b main_exit
-main_exit:
-	addi.d $sp, $sp, 80
-	ld.d $ra, $sp, -8
-	ld.d $fp, $sp, -16
-	jr $ra