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/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.out

-15
-0

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
-}