lab5 publish

.gitignore

-build
+/build/
+.clangd
+compile_commands.json
+/.vscode/
+/.cache/
+test.c
+test
+*.s

Documentations/5-bonus/寄存器分配.md

+# 寄存器分配
+
+寄存器分配算法类型：
+
+1. 线性扫描
+    1. Poletto
+    2. lifetime hole
+    3. linear scan on SSA
+2. 图着色
+    1. Chaitin
+    2. Graph Coloring on SSA
+3. Other techniques
+    1. Rematerialization
+    2. pbqp
+
+# Linear Scan
+
+线性扫描由Poletto等人在1999年首次提出。
+
+线性扫描分配寄存器前需要
+
+1. 对基本块进行排序，给出一个线性序（Depth-First order较优）
+
+2. 决定变量的活跃区间（活跃变量分析）
+
+   [活跃区间的定义]
+
+   变量v的活跃区间为[i,j]表示在任意i'<i或者j'>j的指令，v均不为活跃变量。但在[i,j]内，可能有部分指令处，v也不为活跃变量。
+
+## Poletto
+
+Poletto版本的线性扫描不是在SSA形式上的，需要进行Phi指令消除（同Lab4）
+
+算法介绍如下：
+
+1.前置条件：给定R个可用寄存器和一个活跃区间列表（包含所有变量的活跃区间），该列表以起点（即[i,j]中的i）递增的顺序排列。
+
+2.伪代码：
+
+```C++
+//线性扫描算法
+LinearScan:
+    active <- {}
+    //维护有序列表active，存储当前在寄存器中的变量的活跃区间，按终点([i,j]中的j)递增顺序排列
+    for each live interval i, in order of increasing start point
+    //遍历所有变量的活跃区间
+        ExpireOldIntervals(i)
+        //移除所有过期的区间
+        if length(active) = R then //表示此时所有寄存器均不空闲
+            SpillAtInterval(i)
+            //溢出一个当前活跃区间
+        else //存在空闲的寄存器
+            register[i] <- a register removed from pool of free registers
+            //为变量i赋予一个空闲的寄存器
+            add i to active, sorted by incresing end point
+            //将i的活跃区间加入active，并排序
+
+//移除所有过期的区间：
+//过期区间：终点在新区间起点之前的区间
+ExpireOldIntervals(i):
+    for each interval j in active, in order of increasing end point
+     //遍历列表active
+        if endpoint[j] ≥ startpoint[i] then
+         //当找到一个未过期区间后退出循环
+            return
+        remove j from active
+        //在active中移除过期区间
+        add register[j] to pool of free registers
+        //释放过期区间对应的寄存器
+
+//溢出一个当前活跃区间：
+//决定要溢出哪个区间有多种选择方法，此处我们选择溢出终点最晚的区间（即列表active中最后的区间或者新区间)
+SpillAtInterval(i):
+    spill <- last interval in active
+    //spill初始化为active中最后的区间
+    //比较列表active中最后的区间和新区间
+    if endpoint[spill] > endpoint[i] then //溢出active中最后的区间
+        register[i] <- register[spill]
+        //spill的寄存器给新区间所代表的变量
+        location[spill] <- new stack location
+        remove spill from active
+        add i to active, sorted by increasing end point
+        //spill移出active，i加入active
+    else //溢出新区间
+        location[i] <- new stack location
+```
+
+3.算法复杂度分析：变量个数为V，寄存器个数为R。当查找列表方式为二分查找时，复杂度为$O(V\log R)$，为线性查找时，复杂度为$O(VR)$。
+
+
+
+更多介绍参考如下文章：
+
+[http://web.cs.ucla.edu/~palsberg/course/cs132/linearscan.pdf](http://web.cs.ucla.edu/~palsberg/course/cs132/linearscan.pdf)
+
+## Live Ranges with Lifetime Holes
+
+Poletto版本的活跃变量区间是一大块的，它没有考虑到区间的lifetime hole，即 "不需要变量值的区间"。
+
+以下两篇文章在非SSA形式上处理了带有hole的活跃变量区间
+
+[https://dl.acm.org/doi/10.1145/277650.277714](https://dl.acm.org/doi/10.1145/277650.277714)
+
+[https://dl.acm.org/doi/10.1145/1064979.1064998](https://dl.acm.org/doi/10.1145/1064979.1064998)
+
+## Linear Scan on SSA
+
+以上参考文献都在非SSA形式上工作，对于llvm ir，需要将phi指令手动转换成赋值语句，比较麻烦
+
+这篇文章在SSA形式上进行线性扫描
+
+[https://dl.acm.org/doi/10.1145/1772954.1772979](https://dl.acm.org/doi/10.1145/1772954.1772979)
+
+其简要思想即为在代码生成阶段进行phi resolution
+
+### 建议
+
+不进行Phi指令消除，对SSA form的IR进行最简易的线性扫描（Poletto），在emitting machine code时插入move指令
+
+# Graph Coloring
+
+图着色寄存器分配是解决寄存器分配的主要方法，其生成的代码质量较线性扫描更高，但是也更加耗时。
+
+在这种算法中，图的节点代表活跃变量区间，两个节点相连代表存在相互干扰的区间，即至少在一个程序点上同时存在的区间。然后，寄存器分配简化为图的着色问题，其中颜色（寄存器）被分配给节点，使得由边连接的两个节点不会得到相同的颜色。
+
+使用活跃变量分析，可以建立一个interference graph干扰图。干扰图是一个无向图，其中的节点是程序的变量，用来模拟哪些变量不能被分配到同一个寄存器。
+
+## Chaitin
+
+经典算法，伪代码见
+
+[https://dl.acm.org/doi/10.1145/872726.806984](https://dl.acm.org/doi/10.1145/872726.806984)
+
+## Graph Coloring on SSA
+
+SSA带来的特性能够简化图着色，参考
+
+[https://dl.acm.org/doi/10.1007/11688839_20](https://dl.acm.org/doi/10.1007/11688839_20)
+
+# Rematerialization
+
+Chaitin等人讨论了几个提高溢出代码质量的想法。他们指出，某些数值可以在一条指令中**重新计算**，而且所需的操作数总是可以用来计算的
+
+[https://dl.acm.org/doi/10.1145/143103.143143](https://dl.acm.org/doi/10.1145/143103.143143)
+
+## PBPQ
+
+LLVM的其中一个分配器，采用线性规划，参考
+
+[https://dl.acm.org/doi/10.1007/11860990_21](https://dl.acm.org/doi/10.1007/11860990_21)
+
+[https://dl.acm.org/doi/abs/10.1145/513829.513854](https://dl.acm.org/doi/abs/10.1145/513829.513854)

Documentations/5-bonus/评测脚本.md

+### 评测脚本
+
+性能测试脚本位于tests/5-bonus/test_time.py，在实现自己的汇编代码生成功能前，可以使用脚本的 `--clang`选项，用clang完成编译和汇编。
+下面用yourcmminus指代你完成的汇编代码生成项目。
+脚本会对yourcminus或clang生成的可执行文件的**输出结果**和**运行时间**进行测试，性能测试结果会写入同目录下test_result文件，脚本的`--console`选项用来控制是否同时将性能测试结果打印到控制台。
+
+**注**：默认要求yourcminus在生成汇编代码时使用的指令是`cminusfc file.cminus -mem2reg -S a.s`，你也可以根据你自己的实现更改脚本中的标有`###可修改###`的部分。
+
+下面是开启`-console`和`-clang`时的生成结果示例 :
+
+```bash
+$ python3 test_time.py --console --clang
+[1/13] 1-return.cminus: pass, costs 0.001559s
+[2/13] 10-float.cminus: pass, costs 0.001864s
+[3/13] 11-floatcall.cminus: pass, costs 0.001632s
+[4/13] 12-global.cminus: pass, costs 0.001614s
+[5/13] 13-complex.cminus: pass, costs 0.001423s
+[6/13] 2-calculate.cminus: pass, costs 0.001770s
+[7/13] 3-output.cminus: pass, costs 0.001356s
+[8/13] 4-if.cminus: pass, costs 0.001618s
+[9/13] 5-while.cminus: pass, costs 0.001637s
+[10/13] 6-array.cminus: pass, costs 0.002292s
+[11/13] 7-function.cminus: pass, costs 0.001389s
+[12/13] 8-store.cminus: pass, costs 0.001849s
+[13/13] 9-fibonacci.cminus: pass, costs 0.002904s
+0 tests failed
+total time is 0.022907666116952895s
+avg time is 0.0017621281628425304s
+13 tests finishes in time limit
+testcase                           clang                baseline
+1-return.cminus                  0.001559               0.000883
+10-float.cminus                  0.001864               0.001716
+11-floatcall.cminus              0.001632               0.001657
+12-global.cminus                 0.001614               0.001491
+13-complex.cminus                0.001423               0.001820
+2-calculate.cminus               0.001770               0.001738
+3-output.cminus                  0.001356               0.001946
+4-if.cminus                      0.001618               0.001651
+5-while.cminus                   0.001637               0.002021
+6-array.cminus                   0.002292               0.002570
+7-function.cminus                0.001389               0.001677
+8-store.cminus                   0.001849               0.001600
+9-fibonacci.cminus               0.002904               0.004012
+===============================================================
+```
+
+
+### 分数计算
+
++ 功能测试（40%）
+  从 IR 到龙芯汇编翻译,生成龙芯汇编代码,执行结果与预期结果一致。
+  得分为 通过测试用例数 / 总测试用例数 * 40
++ 性能测试（40%）
+  对于每个测试用例，将所有人的运行时间排序，得分为（总人数 - 排名 + 1) / 总人数 * 40，性能测试的分数将取所有测试用例的平均值。
++ 工作总结汇报（20%）
+  以 ppt 形式汇报，介绍项目的设计思想、学生自由发挥部分等内容。

README.md

@@ -5,26 +5,26 @@
 ## 目前已布置的实验
 
 * [lab1](./Documentations/1-parser/)
-  + DDL：2022-10-03 23:59:59 (UTC+8)
-  
+  + DDL：2021-10-06(~~10-03~~) 23:59:59 (UTC+8)
 * [lab2](./Documentations/2-ir-gen-warmup/)
-  + DDL：2022-10-23 23:59:59 (UTC+8)
-
+  + DDL：2021-10-22 23:59:59 (UTC+8)
 * [lab3](./Documentations/3-ir-gen/)
-  + DDL：2022-11-13 23:59:59 (UTC+8)
-
-* [lab4.1](./Documentations/4.1-ssa/)
-  + DDL：2022-11-27 23:59:59 (UTC+8)
-
-* [lab4.2](./Documentations/4.2-gvn/)
-  + DDL: 2023-01-14 23:59:59 (UTC+8)
-
+  + DDL: 2021-11-21 23:59:59 (UTC+8)
+* [lab4](./Documentations/4-ir-opt)
+  + DDL：
+    + **阶段一**：2021/11/29 23:59:59 (UTC+8)
+    + **阶段二**：2022/12/13 23:59:59 (UTC+8)
+* [lab5](./Documentations/5-bonus/)
+  + DDL:
+    + **建议报名期限**：2023/01/29
+    + **实验提交**：2023 年 3 月初，具体时间待定
+    + **答辩时间**：2023 年 3 月初，具体时间待定
 ## FAQ: How to merge upstream remote branches
 
 In brief, you need another alias for upstream repository (we assume you are now in your local copy of forked repository on Gitlab):
 
 ```shell
-$ git remote add upstream git@202.38.79.174:compiler_staff/2022fall-compiler_cminus.git
+$ git remote add upstream http://211.86.152.198:8080/staff/2021fall-compiler_cminus.git
 ```
 
 Then try to merge remote commits to your local repository:

include/codegen.hpp

+#ifndef CODEGEN_HPP
+#define CODEGEN_HPP
+
+#include "Module.h"
+#include "logging.hpp"
+
+using std::string;
+using std::vector;
+
+class CodeGen {
+  public:
+    CodeGen(Module *module) : m(module) {}
+
+    string print() {
+        string result;
+        for (auto line : output) {
+            if (line.find(":") == string::npos and line != "")
+                result += "\t"; // 添加缩进
+            result += line + "\n";
+        }
+        return result;
+    }
+
+    void run();
+
+  private:
+    Module *m;
+    vector<string> output;
+};
+
+#endif

src/CMakeLists.txt

@@ -2,5 +2,6 @@ add_subdirectory(parser)
 add_subdirectory(common)
 add_subdirectory(io)
 add_subdirectory(lightir)
-add_subdirectory(cminusfc)
 add_subdirectory(optimization)
+add_subdirectory(cminusfc)
+add_subdirectory(codegen)

src/cminusfc/CMakeLists.txt

@@ -6,15 +6,14 @@ add_executable(
 
 target_link_libraries(
     cminusfc
+    OP_lib
     IR_lib
     common
     syntax
-    OP_lib
+    codegen
 )
 
 install(
     TARGETS cminusfc
     RUNTIME DESTINATION bin
 )
-
-

src/cminusfc/cminusfc.cpp

+#include "ActiveVars.hpp"
+#include "ConstPropagation.hpp"
+#include "DeadCode.h"
 #include "Dominators.h"
 #include "GVN.h"
+#include "LoopInvHoist.hpp"
+#include "LoopSearch.hpp"
 #include "Mem2Reg.hpp"
 #include "PassManager.hpp"
 #include "cminusf_builder.hpp"
+#include "codegen.hpp"
 #include "logging.hpp"
 
 #include <fstream>
@@ -68,17 +74,13 @@ int main(int argc, char **argv) {
             std::cerr << argv[0] << ": input file " << input_path << " has unknown filetype!" << std::endl;
             return -1;
         } else {
-            if (input_path.substr(pos) != ".cminus") {
-                std::cerr << argv[0] << ": input file " << input_path << " has unknown filetype!" << std::endl;
-                return -1;
-            }
-            if (emit) {
-                target_path = input_path.substr(0, pos);
-            } else {
+            // if (input_path.substr(pos) != ".cminus") {
+            //     std::cerr << argv[0] << ": input file " << input_path << " has unknown filetype!" << std::endl;
+            //     return -1;
+            // }
             target_path = input_path.substr(0, pos);
         }
     }
-    }
 
     auto s = parse(input_path.c_str());
     auto a = AST(s);
@@ -93,13 +95,23 @@ int main(int argc, char **argv) {
     if (mem2reg) {
         PM.add_pass<Mem2Reg>(emit);
     }
-    if (gvn)
+    if (gvn) {
+        PM.add_pass<DeadCode>(false); // remove some undef
         PM.add_pass<GVN>(emit, dump_json);
+        PM.add_pass<DeadCode>(false); // delete unused instructions created by GVN
+    }
 
     PM.run();
 
     auto IR = m->print();
 
+    CodeGen codegen(m.get());
+    codegen.run();
+
+    std::ofstream target_file(target_path + ".s");
+    target_file << codegen.print();
+    target_file.close();
+
     std::ofstream output_stream;
     auto output_file = target_path + ".ll";
     output_stream.open(output_file, std::ios::out);
@@ -111,7 +123,7 @@ int main(int argc, char **argv) {
         std::string lib_path = " -L"s + argv[0];
         auto idx = lib_path.rfind('/');
         if (idx != std::string::npos)
-            lib_path.erase(idx);
+            lib_path.erase(lib_path.rfind('/'));
         else
             lib_path.clear();
         auto cmd_str = "clang -O0 -w -no-pie "s + target_path + ".ll -o " + target_path + lib_path + " -lcminus_io";

src/codegen/CMakeLists.txt

+add_library(codegen STATIC
+    codegen.cpp
+)
+
+target_link_libraries(common)

src/codegen/codegen.cpp

+#include "codegen.hpp"
+
+// $r0          $zero       constant 0
+// $r1          $ra         return address
+// $r2          $tp         thread pointer
+// $r3          $sp         stack pointer
+// $r4 - $r5    $a0 - $a1   argument, return value
+// $r6 - $r11   $a2 - $a7   argument
+// $r12 - $r20  $t0 - $t8   temporary
+// $r21                     saved
+// $r22         $fp         frame pointer
+// $r23 - $r31  $s0 - $s8   static
+
+class Reg {
+  public:
+    Reg(int index) : id(index) {}
+
+    int id;
+
+    string print() {
+        if (id == 0)
+            return "$zero";
+        if (id == 1)
+            return "$ra";
+        if (id == 2)
+            return "$tp";
+        if (id == 3)
+            return "$sp";
+        if (4 <= id and id <= 11)
+            return "$a" + std::to_string(id - 4);
+        if (12 <= id and id <= 20)
+            return "$t" + std::to_string(id - 12);
+        if (id == 22)
+            return "$fp";
+        assert(false);
+    }
+};
+
+void CodeGen::run() {
+    // TODO: implement
+    // 以下内容生成 int main() { return 0; } 的汇编代码
+
+    output.push_back(".text");
+    for (auto &func : m->get_functions())
+        if (not func.is_declaration()) {
+            output.push_back(".globl " + func.get_name());
+            output.push_back(".type " + func.get_name() + ", @function");
+            output.push_back(func.get_name() + ":");
+            output.push_back("addi.d $sp, $sp, -16");
+            output.push_back("st.d $ra, $sp, 8");
+            output.push_back("addi.d $fp, $sp, 16");
+
+            output.push_back("addi.w $a0, $zero, 0");
+            output.push_back("ld.d $ra, $sp, 8");
+            output.push_back("addi.d $sp, $sp, 16");
+            output.push_back("jr $ra");
+        }
+}

tests/5-bonus/test_time.py

+import os
+import sys
+import timeit
+import shutil
+import argparse
+import subprocess
+
+test_dir = os.path.dirname(os.path.abspath(__file__))  # 当前文件夹路径 tests/5-bonus
+cminus = os.path.join(test_dir, '../../build/cminus')  # ===可修改===
+testfile_dir = os.path.join(test_dir, './testcases')
+output_file_name = os.path.join(test_dir, './test_result')
+io = os.path.join(test_dir, '../../src/io/io.c')
+
+total_failed_count = 0
+
+
+class Outputer:
+    def __init__(self, console=False, filename="test_result") -> None:
+        self.console = console
+        self.fd = open(filename, "a")
+
+    def write(self, msg):
+        if self.console:
+            print(msg, end="")
+            sys.stdout.flush()
+        self.fd.write(msg)
+        self.fd.flush()
+
+    def __del__(self) -> None:
+        self.fd.close()
+
+
+def eval(console=False, test_dir=testfile_dir, use_clang=False):
+
+    output_file = Outputer(console, output_file_name)
+    failed_count = 0
+    succ_count = 0
+    total_time = 0
+
+    single_begin = timeit.default_timer()
+
+    testfiles = os.listdir(testfile_dir)
+    testfiles.sort()
+    # 过滤出以.cminus结尾的file
+    testfiles = filter(lambda s: s.endswith('.cminus'), testfiles)
+    testfiles = list(testfiles)
+
+    test_count = len(testfiles)
+
+    testtime = []
+
+    for count, file_name in enumerate(testfiles):
+        start_time = timeit.default_timer()
+
+        testtime.append(-1)
+
+        # 超时，跳过
+        if start_time - total_start > 30 * 60 or start_time - single_begin > 30 * 60:
+            output_file.write(f"[{count+1}/{test_count}] " + file_name + ': skipped due to exceeded total time limit\n')
+            continue
+        # 未超时
+        output_file.write(f"[{count+1}/{test_count}] " + file_name + ': ')
+        filepath = os.path.join(testfile_dir, file_name)
+        outpath = os.path.join(testfile_dir, file_name[:-7] + '.out')
+
+        ### 编译 ###
+        if not use_clang:
+            try:
+                # ===可修改===
+                compile_res = subprocess.run([cminus, filepath, '-mem2reg', '-S', 'a.s'],
+                                             stdout=subprocess.PIPE,
+                                             stderr=subprocess.PIPE,
+                                             timeout=300)
+            except subprocess.TimeoutExpired as _:
+                output_file.write('compile-1 timeout\n')
+                failed_count += 1
+                continue
+            except Exception:
+                output_file.write("compile-1 failed with an unexcept error\n")
+                failed_count += 1
+                continue
+
+            try:
+                compile_res = subprocess.run(['gcc', 'a.s', io, '-o', 'a.out'],
+                                             stdout=subprocess.PIPE,
+                                             stderr=subprocess.PIPE,
+                                             timeout=300)
+            except subprocess.TimeoutExpired as _:
+                output_file.write('compile-2 timeout\n')
+                failed_count += 1
+                continue
+            except Exception:
+                output_file.write("compile-2 failed with an unexcept error\n")
+                failed_count += 1
+                continue
+
+        else:
+            try:
+                cfilepath = filepath.replace(".cminus", ".c")
+                shutil.move(filepath, cfilepath)
+                compile_res = subprocess.run(["clang", cfilepath, io, "-o", "a.out"],
+                                             stdout=subprocess.PIPE,
+                                             stderr=subprocess.PIPE,
+                                             timeout=300)
+                shutil.move(cfilepath, filepath)
+            except subprocess.TimeoutExpired as _:
+                output_file.write('compile timeout\n')
+                failed_count += 1
+                continue
+            except Exception:
+                output_file.write("compile failed with an unexcept error\n")
+                failed_count += 1
+                continue
+
+        ### 运行 ###
+        try:
+            input_option = None
+            inpath = os.path.join(testfile_dir, file_name[:-7] + '.in')
+
+            if os.path.exists(inpath):  # testfile存在输入文件
+                with open(inpath, 'rb') as fin:
+                    input_option = fin.read()
+
+            # 记录运行时间
+            start = timeit.default_timer()
+            for i in range(10):
+                exe_res = subprocess.run(['./a.out'],
+                                         input=input_option,
+                                         stdout=subprocess.PIPE,
+                                         stderr=subprocess.PIPE,
+                                         timeout=100)
+            end = timeit.default_timer()
+
+        except subprocess.TimeoutExpired:
+            output_file.write("executable time limit exceeded\n")
+            failed_count += 1
+            continue
+        except Exception as _:
+            output_file.write('executable runtime error\n')
+            failed_count += 1
+            continue
+
+        # 输出
+        with open(outpath, 'r') as fout:
+            ref = fout.read().replace(' ', '').replace('\n', '')
+
+            try:
+                actual = exe_res.stdout.decode('utf-8').replace(' ', '').replace('\n', '').replace('\r', '') + str(
+                    exe_res.returncode)
+            except UnicodeDecodeError:
+                output_file.write('executable output illegal characters\n')
+                failed_count += 1
+                continue
+
+            if ref == actual or use_clang:
+                time = (end - start) / 10
+                total_time += time
+                output_file.write(f'pass, costs {time:.6f}s\n')
+                succ_count += 1
+                testtime[count] = time
+            else:
+                output_file.write('output is different from standard answer, this may be caused by wrong return code\n'
+                                  )  # 因为退出码也会作为输出的一部分，因此输出和答案不同可能是程序崩溃造成的
+                failed_count += 1
+
+    output_file.write(f"{failed_count} tests failed\n")
+    output_file.write(
+        f"total time is {total_time}s\navg time is {total_time/succ_count if succ_count>0 else 0}s\n{succ_count} tests finishes in time limit\n"
+    )
+
+    output_file.write('testcase')
+    output_file.write('\t\t\tyour_cminus')
+    for count, file_name in enumerate(testfiles):
+        output_file.write('{:<20}'.format(file_name))
+        output_file.write('\t\t %.6f' % testtime[count] if testtime[count] != -1 else '\t\t  None  ')
+
+    output_file.write("===================================================================\n")
+
+
+if __name__ == "__main__":
+    total_start = timeit.default_timer()
+
+    parser = argparse.ArgumentParser(description="functional test")
+
+    parser.add_argument("--console", action="store_true", help="specify whether to output the result to console")
+    parser.add_argument("--clang", action="store_true", help="estimate runtime when compile with clang")
+    args = parser.parse_args()
+
+    eval(args.console, testfile_dir, use_clang=args.clang)

tests/5-bonus/testcases/1-return.cminus

+int main(void) { return 111; }

tests/5-bonus/testcases/1-return.out

+111

tests/5-bonus/testcases/10-float.cminus

+int main(void) {
+    float a;
+    float b;
+    float c;
+
+    a = 1.1;
+    b = 1.5;
+    c = 1.2;
+
+    outputFloat(a * b + c);
+    return 0;
+}

tests/5-bonus/testcases/10-float.out

+2.850000
+0

tests/5-bonus/testcases/11-floatcall.cminus

+/* float function call */
+
+float mod(float x, float y) {
+    int div;
+    div = x / y;
+    return x - div * y;
+}
+
+int main(void) {
+    float a;
+    float b;
+
+    a = 11.2;
+    b = 2.2;
+
+    outputFloat(mod(a, b));
+    return 0;
+}

tests/5-bonus/testcases/11-floatcall.out

+0.200000
+0

tests/5-bonus/testcases/12-global.cminus

+int seed;
+
+int randomLCG(void) {
+    seed = seed * 1103515245 + 12345;
+    return seed;
+}
+
+int randBin(void) {
+    if (randomLCG() > 0)
+        return 1;
+    else
+        return 0;
+}
+
+/* random walk */
+int returnToZeroSteps(void) {
+    int x;
+    int steps;
+
+    x = 0;
+    steps = 0;
+
+    while (steps < 20) {
+        if (randBin())
+            x = x + 1;
+        else
+            x = x - 1;
+
+        steps = steps + 1;
+        if (x == 0)
+            return steps;
+    }
+    return 20;
+}
+
+int main(void) {
+    int i;
+    i = 0;
+
+    seed = 3407;
+
+    while (i < 20) {
+        output(returnToZeroSteps());
+        i = i + 1;
+    }
+    return 0;
+}

tests/5-bonus/testcases/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/5-bonus/testcases/13-complex.cminus

+/* 01 背包问题 */
+
+int n;
+int m;
+
+int w[5];
+int v[5];
+
+int dp[66]; /* dp[n * 11 + size] 表示前 n 个物品放入容量为 size 的背包中的最大价值，初始化为 -1 */
+
+int max(int a, int b) {
+    if (a > b)
+        return a;
+    else
+        return b;
+}
+
+/* 状态转移方程：
+   dp[n][size] = max(dp[n - 1][size], dp[n - 1][size - w[n]] + v[n])
+   边界条件：
+   dp[n][size <= 0] = 0
+   dp[0][size] = 0  */
+
+int knapsack(int n, int size) {
+    int result;
+    if (size <= 0)
+        return 0;
+    if (n == 0)
+        return 0;
+    if (dp[n * 11 + size] >= 0)
+        return dp[n * 11 + size];
+
+    if (size < w[n - 1])
+        result = knapsack(n - 1, size);
+    else
+        result = max(knapsack(n - 1, size), knapsack(n - 1, size - w[n - 1]) + v[n - 1]);
+
+    dp[n * 11 + size] = result;
+    return result;
+}
+
+int main(void) {
+    int i;
+    i = 0;
+
+    n = 5;
+    m = 10;
+    w[0] = 2;
+    w[1] = 2;
+    w[2] = 6;
+    w[3] = 5;
+    w[4] = 4;
+
+    v[0] = 6;
+    v[1] = 3;
+    v[2] = 5;
+    v[3] = 4;
+    v[4] = 6;
+
+    while (i < 66) {
+        dp[i] = 0-1;
+        i = i + 1;
+    }
+
+    output(knapsack(n, m));
+    return 0;
+}

tests/5-bonus/testcases/13-complex.out

+15
+0
\ No newline at end of file

tests/5-bonus/testcases/2-calculate.cminus

+int main(void) {
+    int a;
+    int b;
+    int c;
+
+    a = 23;
+    b = 25;
+    c = 4;
+
+    return a + b * c;
+}

tests/5-bonus/testcases/2-calculate.out

+123

tests/5-bonus/testcases/3-output.cminus

+int main(void) {
+    output(11);
+    output(22222);
+    return 0;
+}

tests/5-bonus/testcases/3-output.out

+11
+22222
+0

tests/5-bonus/testcases/4-if.cminus

+int main(void) {
+    int a;
+    int b;
+    int c;
+
+    a = 11;
+    b = 22;
+    c = 33;
+
+    /* max value */
+    if (a > b) {
+        if (a > c)
+            output(a);
+        else
+            output(c);
+    } else {
+        if (c < b)
+            output(b);
+        else
+            output(c);
+    }
+    return 0;
+}

tests/5-bonus/testcases/4-if.out

+33
+0

tests/5-bonus/testcases/5-while.cminus

+int main(void) {
+    int n;
+    int i;
+
+    n = 10;
+    i = 0;
+
+    while (i < n) {
+        output(i);
+        i = i + 1;
+    }
+
+    return 0;
+}

tests/5-bonus/testcases/5-while.out

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

tests/5-bonus/testcases/6-array.cminus

+int main(void) {
+    int a[10];
+    int i;
+
+    i = 0;
+    a[0] = 11;
+    a[4] = 22;
+    a[9] = 33;
+
+    output(a[0]);
+    output(a[4]);
+    output(a[9]);
+
+    return 0;
+}

tests/5-bonus/testcases/6-array.out

+11
+22
+33
+0

tests/5-bonus/testcases/7-function.cminus

+int min(int a, int b) {
+    if (a <= b)
+        return a;
+    else
+        return b;
+}
+
+int main(void) {
+    int a;
+    int b;
+    int c;
+
+    a = 11;
+    b = 22;
+    c = 33;
+
+    output(min(a, b));
+    output(min(b, c));
+    output(min(c, a));
+    return 0;
+}

tests/5-bonus/testcases/7-function.out

+11
+22
+11
+0

tests/5-bonus/testcases/8-store.cminus

+int store(int arr[], int index, int value) {
+    arr[index] = value;
+    return value;
+}
+
+int main(void) {
+    int a[10];
+    int i;
+    int sum;
+
+    i = 0;
+    while (i < 10) {
+        store(a, i, i * 2);
+        i = i + 1;
+    }
+
+    sum = 0;
+    i = 0;
+    while (i < 10) {
+        sum = sum + a[i];
+        i = i + 1;
+    }
+
+    output(sum);
+    return 0;
+}

tests/5-bonus/testcases/8-store.out

+90
+0

tests/5-bonus/testcases/9-fibonacci.cminus

+int fibonacci(int n) {
+    if (n == 0)
+        return 0;
+    else if (n == 1)
+        return 1;
+    else
+        return fibonacci(n - 1) + fibonacci(n - 2);
+}
+
+int main(void) {
+    int n;
+    int i;
+
+    n = 10;
+    i = 0;
+
+    while (i < n) {
+        output(fibonacci(i));
+        i = i + 1;
+    }
+
+    return 0;
+}

tests/5-bonus/testcases/9-fibonacci.out

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