init IR Lab for H class

CMakeLists.txt

@@ -0,0 +1,39 @@
+project(SysYCompiler)
+
+cmake_minimum_required(VERSION 3.5)
+
+set(CMAKE_CXX_STANDARD 17)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -Wall -g -pedantic")
+
+# include generated files in project environment
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include/ASTBuilder)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include/ASTPrinter)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include/ErrorReporter)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include/Grammar)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include/SysYIR)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include/SysYBuilder)
+
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/src/ASTBuilder)
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/src/ASTPrinter)
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/src/ErrorReporter)
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/src/Grammar)
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/src/SysYIR)
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/src/SysYBuilder)
+
+add_executable(
+  SysYCompiler
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/main.cpp
+)
+
+target_link_libraries(
+  SysYCompiler
+  SysYBuilder
+  IRLib
+  Driver
+  ASTPrinter
+  ErrReporter
+)

README.md

@@ -1 +1,116 @@
- Init README.md
+# PW6 实验文档
+本实验由黄庄湫、吴毓辰助教设计
+- [PW6 实验文档](#pw6-实验文档)
+  - [0. 前言](#0-前言)
+    - [主要工作](#主要工作)
+  - [1. 实验要求](#1-实验要求)
+    - [1.1 目录结构](#11-目录结构)
+    - [1.2 提交要求和评分标准](#12-提交要求和评分标准)
+## 0. 前言
+
+本次实验分为3关，前2关是个人实验，第3关为组队实验。**本次实验请务必使用git提交**。    
+本次实验的目的是让大家熟悉生成中间代码所需要的相关知识: LLVM IR、 SysY IR（LLVM IR的轻量级C++接口），并实际实现一个IR Builder。
+在开始实验之前，请确保LLVM的版本不低于10.0.1，且PATH环境变量配置正确。可以通过`lli --version`命令是否可以输出10.0.1的版本信息来验证。
+
+### 主要工作
+
+1. 第一部分: 了解LLVM IR。通过clang生成的.ll，了解LLVM IR与c代码的对应关系。相应文档见[phase1.md](./doc/phase1.md)
+2. 第二部分: 了解SysY IR。通过助教提供的c++例子，了解SysY IR的c++接口及实现。相应文档见[phase2.md](./doc/phase2.md)
+3. 第三部分: 使用SysY IR，实现一个IR Builder，使其可以通过抽象语法树生成LLVM兼容的IR代码。相应文档见[phase3.md](./doc/phase3.md)
+4. 实验报告：在[report.md](./report.md)中撰写报告。
+
+## 1. 实验要求
+
+### 1.1 目录结构
+除了下面指明你所要修改或提交的文件，其他文件请勿修改。
+``` log
+.
+├── CMakeLists.txt
+├── README.md                           <- PW6实验文档说明（你在这里）
+├── contribution.md                     <- PW6所需提交的组员贡献（队长提交即可）
+├── report.md                           <- PW6所需提交的实验报告
+├── doc
+│   ├── AST.md
+│   ├── phase1.md
+│   ├── phase2.md
+│   ├── phase3.md
+|   └── SysYIR.md                       <- SysY IR 相关文档
+├── include                             <- 实验所需的头文件
+│   ├── ...
+│   └── SysYIR
+├── src
+│   ├── ...
+│   ├── SysYIR
+│   └── SysYBuilder
+|       ├── CMakeLists.txt
+|       └── SysYBuilder.cpp             <- 第三部分你需要修改的文件
+└── SysYF_Student
+    ├── CMakeLists.txt
+    ├── SysYF_Task1
+    |   ├── student_ll                  <- PW6所需提交的.ll目录（第一部分）
+    |   |   ├── assign_hand.ll
+    |   │   ├── fun_hand.ll
+    |   │   ├── if_hand.ll
+    |   │   └── while_hand.ll
+    |   ├── student_sy
+    |   |   ├── assign.sy
+    |   │   ├── fun.sy
+    |   │   ├── if.sy
+    |   │   └── while.sy
+    |   └── ta_demo
+    |       └── go_upstairs.c
+    ├── SysYF_Task2
+    |   ├── student_cpp                 <- PW6所需提交的.cpp目录（第二部分）
+    |   |   ├── CMakeLists.txt
+    |   |   ├── assign_gen.cpp
+    |   │   ├── fun_gen.cpp
+    |   │   ├── if_gen.cpp
+    |   │   └── while_gen.cpp
+    |   ├── student_sy
+    |   |   ├── assign.sy
+    |   │   ├── fun.sy
+    |   │   ├── if.sy
+    |   │   └── while.sy
+    |   └── ta_demo
+    |       |── CMakeLists.txt
+    |       |── go_upstairs.sy
+    |       └── go_upstairs_gen.cpp     <- 助教提供的打印go_upstairs.ll的cpp
+    └── SysYF_Task3
+        └── Test_H
+            ├── test_H.py               <- PW6第三部分评测脚本
+            └── Easy_H                  <- 测试样例文件夹
+```
+
+### 1.2 提交要求和评分标准
+* 提交要求  
+  本实验的提交要求分为两部分: 实验部分的文件和报告。
+  * 实验部分:
+    * 需要完成 `./SysYF_Student/SysYF_Task1/student_ll`目录下的4个文件
+    * 需要完成 `./SysYF_Student/SysYF_Task2/student_cpp`目录下的4个文件
+    * 需要完成 `./src/SysYBuilder/SysYBuilder.cpp`
+    * 需要在 `./report.md` 中撰写实验报告
+      * 实验报告内容包括:
+        * 实验要求、问题回答、实验设计、实验难点及解决方案、实验总结、实验反馈、组间交流(具体参考[report.md](./report.md))
+        * 本次实验报告**参与**评分标准.
+  * 提交规范: 
+    * 不破坏目录结构(`report.md`如果需要放图片，请放在`./report_figs/`下)
+    * 不上传临时文件(凡是自动生成的文件和临时文件请不要上传)
+* **组队实验要求**
+  * 由队长在 `contribution.md` 中解释每位队员的贡献，并说明贡献比例
+  * 组队实验意味着合作，但是小组间的交流是受限的，且**严格禁止**代码的共享。除此之外，如果小组和其它组进行了交流，必须在 `report.md` 中记录交流的小组和你们之间交流内容
+* 评分标准: 本次实验分为3部分, 请注意前两部分为个人实验, 第三部分为组队实验, 个人实验需要各自完成, 组队实验的代码和报告我们只检查组长的仓库
+  * **禁止执行恶意代码，违者本次实验0分处理**
+  * 第一部分10分: `.ll`运行结果正确(1个2分, 注释共2分)
+  * 第二部分20分: `.cpp`运行结果正确(1个5分)
+  * 第三部分70分: 该部分成绩由5部分组成(团队代码得分, 实验报告得分, 迟交天数, 组员贡献比, 组长奖励加分)
+* 实验检查
+  * 线上: 助教会在educoder上检查前两部分, 该部分是每个人需要独自完成的
+  * 线下: 线下检查只检查第三部分, 组长带组员到负责组长的助教处检查
+* 迟交规定
+  * 迟交需要邮件通知助教: 
+    * 邮箱: huangzq@mail.ustc.edu.cn
+    * 邮件主题: PW6迟交-学号
+    * 内容: 包括迟交原因、最后版本commitID、迟交时间等
+* 关于抄袭和雷同
+  经过助教和老师判定属于作业抄袭或雷同情况，所有参与方一律零分，不接受任何解释和反驳。
+如有任何问题，欢迎提issue进行批判指正。

SysYF_Student/SysYF_Task1/student_sy/assign_test.sy

@@ -0,0 +1,6 @@
+int main(){
+    float b = 1.8;
+    int a[2] = {2};
+    a[1] = a[0] * b;
+    return a[1];
+}

SysYF_Student/SysYF_Task1/student_sy/func_test.sy

@@ -0,0 +1,12 @@
+int a,b,c;
+
+int add(int a,int b){
+    c=a+b;
+    return (c-1);
+}
+
+int main(){
+    a=3;
+    b=2;
+    return c + add(a,b);
+}

SysYF_Student/SysYF_Task1/student_sy/if_test.sy

@@ -0,0 +1,9 @@
+int a;
+
+int main(){
+	a = 10;
+	if( a>0 ){
+		return a;
+	}
+	return 0;
+}

SysYF_Student/SysYF_Task1/student_sy/while_test.sy

@@ -0,0 +1,11 @@
+int a;
+int b;
+int main(){
+	b=0;
+	a=3;
+	while(a>0){	
+		b = b+a;
+		a = a-1;
+	}
+	return b;
+}	

SysYF_Student/SysYF_Task1/ta_demo/go_upstairs.c

@@ -0,0 +1,28 @@
+int num[2] = {4, 8};
+int x[1];
+int n;
+int tmp = 1;
+
+int climbStairs(int n) {
+    if(n < 4)
+        return n;
+    int dp[10];
+    dp[0] = 0;
+    dp[1] = 1;
+    dp[2] = 2;
+    int i;
+    i = 3;
+    while(i<n+1){
+        dp[i] = dp[i-1] + dp[i-2];
+        i = i + 1;
+    }
+    return dp[n];
+}
+
+int main(){
+    int res;
+    n=num[0];
+    x[0] = num[tmp];
+    res = climbStairs(n + tmp);
+    return res - x[0];
+}

SysYF_Student/SysYF_Task2/CMakeLists.txt

@@ -0,0 +1,17 @@
+project(SysYF_Task2)
+
+cmake_minimum_required(VERSION 3.5)
+
+set(CMAKE_CXX_STANDARD 17)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -Wall -g -pedantic")
+
+set(SYSYF_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+
+# include generated files in project environment
+include_directories(${SYSYF_SOURCE_DIR}include/SysYIR)
+add_subdirectory(${SYSYF_SOURCE_DIR}src/SysYIR src/SysYIR)
+
+add_subdirectory(ta_demo)
+add_subdirectory(student_cpp)

SysYF_Student/SysYF_Task2/student_cpp/CMakeLists.txt

@@ -0,0 +1,36 @@
+add_executable(
+    assign_generator
+    assign_gen.cpp
+)
+target_link_libraries(
+  assign_generator
+  IRLib
+)
+
+add_executable(
+  func_generator
+  func_gen.cpp
+)
+target_link_libraries(
+  func_generator
+  IRLib
+)
+
+add_executable(
+  if_generator
+  if_gen.cpp
+)
+target_link_libraries(
+  if_generator
+  IRLib
+)
+
+add_executable(
+  while_generator
+  while_gen.cpp
+)
+target_link_libraries(
+    while_generator
+  IRLib
+)
+  

SysYF_Student/SysYF_Task2/student_cpp/assign_gen.cpp

@@ -0,0 +1,3 @@
+int main(){
+    return 0;
+}

SysYF_Student/SysYF_Task2/student_cpp/func_gen.cpp

@@ -0,0 +1,3 @@
+int main(){
+    return 0;
+}

SysYF_Student/SysYF_Task2/student_cpp/if_gen.cpp

@@ -0,0 +1,3 @@
+int main(){
+    return 0;
+}

SysYF_Student/SysYF_Task2/student_cpp/while_gen.cpp

@@ -0,0 +1,3 @@
+int main(){
+    return 0;
+}

SysYF_Student/SysYF_Task2/student_sy/assign_test.sy

@@ -0,0 +1,6 @@
+int main(){
+    float b = 1.8;
+    int a[2] = {2};
+    a[1] = a[0] * b;
+    return a[1];
+}

SysYF_Student/SysYF_Task2/student_sy/func_test.sy

@@ -0,0 +1,12 @@
+int a,b,c;
+
+int add(int a,int b){
+    c=a+b;
+    return (c-1);
+}
+
+int main(){
+    a=3;
+    b=2;
+    return c + add(a,b);
+}

SysYF_Student/SysYF_Task2/student_sy/if_test.sy

@@ -0,0 +1,9 @@
+int a;
+
+int main(){
+	a = 10;
+	if( a>0 ){
+		return a;
+	}
+	return 0;
+}

SysYF_Student/SysYF_Task2/student_sy/while_test.sy

@@ -0,0 +1,11 @@
+int a;
+int b;
+int main(){
+	b=0;
+	a=3;
+	while(a>0){	
+		b = b+a;
+		a = a-1;
+	}
+	return b;
+}	

SysYF_Student/SysYF_Task2/ta_demo/CMakeLists.txt

@@ -0,0 +1,8 @@
+add_executable(
+    go_upstairs_generator
+    go_upstairs_gen.cpp
+)
+target_link_libraries(
+    go_upstairs_generator
+    IRLib
+)

SysYF_Student/SysYF_Task2/ta_demo/go_upstairs.sy

@@ -0,0 +1,28 @@
+int num[2] = {4, 8};
+int x[1];
+int n;
+int tmp = 1;
+
+int climbStairs(int n) {
+    if(n < 4)
+        return n;
+    int dp[10];
+    dp[0] = 0;
+    dp[1] = 1;
+    dp[2] = 2;
+    int i;
+    i = 3;
+    while(i<n+1){
+        dp[i] = dp[i-1] + dp[i-2];
+        i = i + 1;
+    }
+    return dp[n];
+}
+
+int main(){
+    int res;
+    n=num[0];
+    x[0] = num[tmp];
+    res = climbStairs(n + tmp);
+    return res - x[0];
+}

SysYF_Student/SysYF_Task2/ta_demo/go_upstairs_gen.cpp

@@ -0,0 +1,194 @@
+#include "BasicBlock.h"
+#include "Constant.h"
+#include "Function.h"
+#include "IRBuilder.h"
+#include "Module.h"
+#include "Type.h"
+
+#include <iostream>
+#include <memory>
+
+#ifdef DEBUG  // 用于调试信息,大家可以在编译过程中通过" -DDEBUG"来开启这一选项
+#define DEBUG_OUTPUT std::cout << __LINE__ << std::endl;  // 输出行号的简单示例
+#else
+#define DEBUG_OUTPUT
+#endif
+
+#define CONST_INT(num) \
+    ConstantInt::get(num, module)
+
+#define CONST_FP(num) \
+    ConstantFP::get(num, module) // 得到常数值的表示,方便后面多次用到
+
+int main() {
+  auto module = new Module("SysY code");  // module name是什么无关紧要
+  auto builder = new IRBuilder(nullptr, module);
+  Type *Int32Type = Type::get_int32_type(module);
+
+  // 全局数组,num,x
+  auto *arrayType_num = ArrayType::get(Int32Type, 2);
+  auto *arrayType_x = ArrayType::get(Int32Type, 1);
+  auto zero_initializer = ConstantZero::get(Int32Type, module);
+  std::vector<Constant *> init_val;
+  init_val.push_back(CONST_INT(4));
+  init_val.push_back(CONST_INT(8));
+  auto num_initializer = ConstantArray::get(arrayType_num, init_val);
+  auto num = GlobalVariable::create("num", module, arrayType_num, false, num_initializer);//          是否是常量定义，初始化常量(ConstantZero类)
+  auto x = GlobalVariable::create("x", module, arrayType_x, false, zero_initializer);// 参数解释：  名字name，所属module，全局变量类型type，
+
+  auto n = GlobalVariable::create("n", module, Int32Type, false, zero_initializer);
+  auto tmp = GlobalVariable::create("tmp", module, Int32Type, false, CONST_INT(1));
+
+  // climbStairs函数
+  // 函数参数类型的vector
+  std::vector<Type *> Ints(1, Int32Type);
+
+  //通过返回值类型与参数类型列表得到函数类型
+  auto climbStairsFunTy = FunctionType::get(Int32Type, Ints);
+
+  // 由函数类型得到函数
+  auto climbStairsFun = Function::create(climbStairsFunTy,
+                                 "climbStairs", module);
+
+  // BB的名字在生成中无所谓,但是可以方便阅读
+  auto bb = BasicBlock::create(module, "entry", climbStairsFun);
+  
+  builder->set_insert_point(bb);                        // 一个BB的开始,将当前插入指令点的位置设在bb
+  
+  auto retAlloca = builder->create_alloca(Int32Type);   // 在内存中分配返回值的位置
+  auto nAlloca = builder->create_alloca(Int32Type);     // 在内存中分配参数n的位置
+
+  std::vector<Value *> args;  // 获取climbStairs函数的形参,通过Function中的iterator
+  for (auto arg = climbStairsFun->arg_begin(); arg != climbStairsFun->arg_end(); arg++) {
+    args.push_back(*arg);   // * 号运算符是从迭代器中取出迭代器当前指向的元素
+  }
+
+  builder->create_store(args[0], nAlloca);  // store参数n
+
+  auto retBB = BasicBlock::create(
+      module, "", climbStairsFun);  // return分支,提前create,以便true分支可以br
+
+  auto nLoad = builder->create_load(nAlloca);           // 将参数n load上来
+  auto icmp = builder->create_icmp_lt(nLoad, CONST_INT(4));  // n和4的比较,注意ICMPLT
+
+  auto trueBB = BasicBlock::create(module, "trueBB_if", climbStairsFun);    // true分支
+  auto falseBB = BasicBlock::create(module, "falseBB_if", climbStairsFun);  // false分支
+
+  builder->create_cond_br(icmp, trueBB, falseBB);  // 条件BR
+  DEBUG_OUTPUT // 我调试的时候故意留下来的,以醒目地提醒你这个调试用的宏定义方法
+  builder->set_insert_point(trueBB);  // if true; 分支的开始需要SetInsertPoint设置
+  nLoad = builder->create_load(nAlloca);
+  builder->create_store(nLoad, retAlloca);
+  builder->create_br(retBB);  // br retBB
+
+  builder->set_insert_point(falseBB);  // if false
+  auto *arrayType_dp = ArrayType::get(Int32Type, 10);
+  auto dpAlloca = builder->create_alloca(arrayType_dp);
+
+  auto dp0Gep = builder->create_gep(dpAlloca, {CONST_INT(0), CONST_INT(0)});
+  builder->create_store(CONST_INT(0), dp0Gep);
+
+  auto dp1Gep = builder->create_gep(dpAlloca, {CONST_INT(0), CONST_INT(1)});
+  builder->create_store(CONST_INT(1), dp1Gep);
+
+  auto dp2Gep = builder->create_gep(dpAlloca, {CONST_INT(0), CONST_INT(2)});
+  builder->create_store(CONST_INT(2), dp2Gep);
+
+  auto iAlloca = builder->create_alloca(Int32Type);
+  builder->create_store(CONST_INT(3), iAlloca);
+
+  auto condBB = BasicBlock::create(module, "condBB_while", climbStairsFun);  // 条件BB
+  trueBB = BasicBlock::create(module, "trueBB_while", climbStairsFun);    // true分支
+  falseBB = BasicBlock::create(module, "falseBB_while", climbStairsFun);  // false分支
+
+  builder->create_br(condBB);
+
+  builder->set_insert_point(condBB);
+
+  auto iLoad = builder->create_load(iAlloca);
+  nLoad = builder->create_load(nAlloca);
+  auto add = builder->create_iadd(nLoad, CONST_INT(1));
+
+  icmp = builder->create_icmp_lt(iLoad, add);
+  builder->create_cond_br(icmp, trueBB, falseBB);
+
+  builder->set_insert_point(trueBB);
+
+  iLoad = builder->create_load(iAlloca);
+  auto sub = builder->create_isub(iLoad, CONST_INT(1));
+  auto dpGep = builder->create_gep(dpAlloca, {CONST_INT(0), sub});
+  auto dp1Load = builder->create_load(dpGep);
+
+  iLoad = builder->create_load(iAlloca);
+  sub = builder->create_isub(iLoad, CONST_INT(2));
+  dpGep = builder->create_gep(dpAlloca, {CONST_INT(0), sub});
+  auto dp2Load = builder->create_load(dpGep);
+
+  add = builder->create_iadd(dp1Load, dp2Load);
+  iLoad = builder->create_load(iAlloca);
+  dpGep = builder->create_gep(dpAlloca, {CONST_INT(0), iLoad});
+  builder->create_store(add, dpGep);
+
+  iLoad = builder->create_load(iAlloca);
+  add = builder->create_iadd(iLoad, CONST_INT(1));
+  builder->create_store(add, iAlloca);
+
+  builder->create_br(condBB);
+
+  builder->set_insert_point(falseBB);
+  nLoad = builder->create_load(nAlloca);
+  dpGep = builder->create_gep(dpAlloca, {CONST_INT(0), nLoad});
+  auto dpLoad = builder->create_load(dpGep);
+  builder->create_store(dpLoad, retAlloca);
+  builder->create_br(retBB);
+
+  builder->set_insert_point(retBB);  // ret分支
+  auto retLoad = builder->create_load(retAlloca);
+  builder->create_ret(retLoad);
+
+  // main函数
+  auto mainFun = Function::create(FunctionType::get(Int32Type, {}),
+                                  "main", module);
+  bb = BasicBlock::create(module, "entry", mainFun);
+  // BasicBlock的名字在生成中无所谓,但是可以方便阅读
+  builder->set_insert_point(bb);
+
+  retAlloca = builder->create_alloca(Int32Type);
+  auto resAlloca = builder->create_alloca(Int32Type);
+
+  auto num0Gep = builder->create_gep(num, {CONST_INT(0), CONST_INT(0)});  // GEP: 这里为什么是{0, 0}呢? (实验报告相关)
+  auto num0Load = builder->create_load(num0Gep);
+  builder->create_store(num0Load, n);
+
+  auto tmpLoad = builder->create_load(tmp);
+  auto numGep = builder->create_gep(num, {CONST_INT(0), tmpLoad});
+  auto numLoad = builder->create_load(numGep);
+  auto x0Gep = builder->create_gep(x, {CONST_INT(0), CONST_INT(0)});
+  builder->create_store(numLoad, x0Gep);
+
+  nLoad = builder->create_load(n);
+  tmpLoad = builder->create_load(tmp);
+  add = builder->create_iadd(nLoad, tmpLoad);
+  auto call = builder->create_call(climbStairsFun, {add});           // 为什么这里传的是{add}呢?
+  builder->create_store(call, resAlloca);
+
+  auto resLoad = builder->create_load(resAlloca);
+  x0Gep = builder->create_gep(x, {CONST_INT(0), CONST_INT(0)});
+  auto x0Load = builder->create_load(x0Gep);
+  sub = builder->create_isub(resLoad, x0Load);
+  builder->create_store(sub, retAlloca);
+  retLoad = builder->create_load(retAlloca);
+  builder->create_ret(retLoad);
+  // 给这么多注释了,但是可能你们还是会弄很多bug
+  // 所以强烈建议配置AutoComplete,效率会大大提高!
+  // 别人配了AutoComplete,只花1小时coding
+  // 你没有配AutoComplete,找method花5小时,debug花5小时,肯定哭唧唧!
+  // 最后,如果猜不到某个IR指令对应的C++的函数,建议把指令翻译成英语然后在method列表中搜索一下
+  // 最后的最后,这个例子只涉及到了一点基本的指令生成,
+  // 对于额外的指令,包括数组,在之后的实验中可能需要大家好好搜索一下思考一下,
+  // 还有涉及到的C++语法,可以在gitlab上发issue提问或者向大家提供指导
+  // 对于这个例子里的代码风格/用法,如果有好的建议也欢迎提出!
+  std::cout << module->print();
+  delete module;
+  return 0;
+}

SysYF_Student/SysYF_Task3/Test_H/Easy_H/01_main.out

@@ -0,0 +1 @@
+0

SysYF_Student/SysYF_Task3/Test_H/Easy_H/01_main.sy

@@ -0,0 +1,3 @@
+int main(){
+	return 0;
+}

SysYF_Student/SysYF_Task3/Test_H/Easy_H/02_var_defn.out

@@ -0,0 +1 @@
+29

SysYF_Student/SysYF_Task3/Test_H/Easy_H/02_var_defn.sy

@@ -0,0 +1,8 @@
+int a,b;
+
+int main(){
+    a=10;
+    b=5;
+    int c=a*2+b*1.1+3.6;
+    return c;
+}

SysYF_Student/SysYF_Task3/Test_H/Easy_H/03_empty_stmt.out

@@ -0,0 +1 @@
+21

SysYF_Student/SysYF_Task3/Test_H/Easy_H/03_empty_stmt.sy

@@ -0,0 +1,5 @@
+int main() {
+  int a = 10;
+  ;
+  return a * 2 + 1;
+}

SysYF_Student/SysYF_Task3/Test_H/Easy_H/04_arr_defn.out

@@ -0,0 +1 @@
+0

SysYF_Student/SysYF_Task3/Test_H/Easy_H/04_arr_defn.sy

@@ -0,0 +1,4 @@
+int a[10];
+int main(){
+	return 0;
+}

SysYF_Student/SysYF_Task3/Test_H/Easy_H/05_arr_assign.out

@@ -0,0 +1 @@
+0

SysYF_Student/SysYF_Task3/Test_H/Easy_H/05_arr_assign.sy

@@ -0,0 +1,5 @@
+int a[10];
+int main(){
+	a[0]=1;
+	return 0;
+}

SysYF_Student/SysYF_Task3/Test_H/Easy_H/06_const_defn.out

@@ -0,0 +1 @@
+4

SysYF_Student/SysYF_Task3/Test_H/Easy_H/06_const_defn.sy

@@ -0,0 +1,5 @@
+const int x=4;
+
+int main(){
+    return x;
+}

SysYF_Student/SysYF_Task3/Test_H/Easy_H/07_const_array_defn.out

@@ -0,0 +1 @@
+8

SysYF_Student/SysYF_Task3/Test_H/Easy_H/07_const_array_defn.sy

@@ -0,0 +1,7 @@
+const int a[5]={0,1,2,3,4};
+const int b = 3;
+float c = a[b + 1];
+
+int main(){
+    return a[4] + c;
+}

SysYF_Student/SysYF_Task3/Test_H/Easy_H/08_var_defn_func.out

@@ -0,0 +1 @@
+4

SysYF_Student/SysYF_Task3/Test_H/Easy_H/08_var_defn_func.sy

@@ -0,0 +1,8 @@
+int defn(){
+    return 4;
+}
+
+int main(){
+    int a=defn();
+    return a;
+}

SysYF_Student/SysYF_Task3/Test_H/Easy_H/09_void_func.out

@@ -0,0 +1 @@
+5

SysYF_Student/SysYF_Task3/Test_H/Easy_H/09_void_func.sy

@@ -0,0 +1,13 @@
+int a,b,c;
+
+void add(int a,int b){
+    c=a+b;
+    return;
+}
+
+int main(){
+    a=3;
+    b=2;
+    add(a,b);
+    return c;
+}

SysYF_Student/SysYF_Task3/Test_H/Easy_H/10_if.out

@@ -0,0 +1 @@
+1

SysYF_Student/SysYF_Task3/Test_H/Easy_H/10_if.sy

@@ -0,0 +1,9 @@
+int a;
+
+int main(){
+	a = 10;
+	if( a>0 ){
+		return 1;
+	}
+	return 0;
+}

SysYF_Student/SysYF_Task3/Test_H/Easy_H/11_if_else.out

@@ -0,0 +1 @@
+1

SysYF_Student/SysYF_Task3/Test_H/Easy_H/11_if_else.sy

@@ -0,0 +1,10 @@
+int a;
+int main(){
+	a = 10;
+	if( a>0 ){
+		return 1;
+	}
+	else{
+		return 0;
+	}
+}

SysYF_Student/SysYF_Task3/Test_H/Easy_H/12_while.out

@@ -0,0 +1 @@
+6

SysYF_Student/SysYF_Task3/Test_H/Easy_H/12_while.sy

@@ -0,0 +1,11 @@
+int a;
+int b;
+int main(){
+	b=0;
+	a=3;
+	while(a>0){	
+		b = b+a;
+		a = a-1;
+	}
+	return b;
+}	

SysYF_Student/SysYF_Task3/Test_H/Easy_H/13_break.out

@@ -0,0 +1 @@
+5

SysYF_Student/SysYF_Task3/Test_H/Easy_H/13_break.sy

@@ -0,0 +1,9 @@
+int main(){
+    int a=10;
+    while(a>0){
+        a=a-1;
+        if(a==5)
+            break;
+    }
+    return a;
+}

SysYF_Student/SysYF_Task3/Test_H/Easy_H/14_continue.out

@@ -0,0 +1 @@
+5

SysYF_Student/SysYF_Task3/Test_H/Easy_H/14_continue.sy

@@ -0,0 +1,11 @@
+int main(){
+    int a=10;
+    while(a>0){
+        if(a>5){
+            a=a-1;
+            continue;
+        }
+        return a;
+    }
+    return a;
+}

SysYF_Student/SysYF_Task3/Test_H/Easy_H/15_getint.in

@@ -0,0 +1 @@
+10

SysYF_Student/SysYF_Task3/Test_H/Easy_H/15_getint.out

@@ -0,0 +1 @@
+10

SysYF_Student/SysYF_Task3/Test_H/Easy_H/15_getint.sy

@@ -0,0 +1,5 @@
+int main(){
+	int a;
+	a = getint();
+	return a;
+}

SysYF_Student/SysYF_Task3/Test_H/Easy_H/16_func_test.out

@@ -0,0 +1 @@
+5

SysYF_Student/SysYF_Task3/Test_H/Easy_H/16_func_test.sy

@@ -0,0 +1,23 @@
+int a;
+
+int myFunc(int a, int b, int c) {
+	a = 2;
+	{
+		int c;
+		c = 0;
+		if (c != 0) {
+			return 0;
+		}
+	}
+	while (b > 0) {
+		b = b - 1;
+	}
+	return (a)+(b);
+}
+
+int main() {
+	a = (3);
+	int b;
+	b = myFunc(1, 2, 1);
+	return ((a+b));
+}

SysYF_Student/SysYF_Task3/Test_H/Easy_H/17_equal.in

@@ -0,0 +1 @@
+3 2

SysYF_Student/SysYF_Task3/Test_H/Easy_H/17_equal.out

@@ -0,0 +1 @@
+0

SysYF_Student/SysYF_Task3/Test_H/Easy_H/17_equal.sy

@@ -0,0 +1,12 @@
+int a;
+int b;
+int main(){
+	a = getint();
+	b = getint();
+	if ( a == b ){
+		return 1;
+	}
+	else{
+		return 0;
+	}
+}

SysYF_Student/SysYF_Task3/Test_H/Easy_H/18_scope.out

@@ -0,0 +1 @@
+8

SysYF_Student/SysYF_Task3/Test_H/Easy_H/18_scope.sy

@@ -0,0 +1,17 @@
+const int a = 5;
+int b;
+
+int my_sum(int x, float y){
+    b = a + x - y;
+    return b;
+}
+
+int main(){
+    int a = 7;
+    {
+        const float a = 3.3;
+        my_sum(a, a);
+    }
+    my_sum(a, b);
+    return b;
+}

SysYF_Student/SysYF_Task3/Test_H/Easy_H/19_gcd.in

@@ -0,0 +1,2 @@
+4
+20

SysYF_Student/SysYF_Task3/Test_H/Easy_H/19_gcd.out

@@ -0,0 +1 @@
+4

SysYF_Student/SysYF_Task3/Test_H/Easy_H/19_gcd.sy

@@ -0,0 +1,34 @@
+int n;
+
+int gcd(int m,int n)
+{ 
+    int t;
+    int r;
+
+    if(m<n) { t=m;m=n;n=t; }
+
+    r=m%n;
+
+    while(r!=0)
+    {
+        m=n;   
+        n=r;   
+        r=m%n;  
+    }
+
+  return n;
+
+}
+
+int main()
+{
+    //newline=10;
+    int i;
+    int m;
+    //m = 1478;
+    //int t;
+    i=getint();
+    m=getint();
+    
+    return gcd(i,m);
+}

SysYF_Student/SysYF_Task3/Test_H/Easy_H/20_hanoi.in

@@ -0,0 +1,5 @@
+4
+4
+7
+3
+9

SysYF_Student/SysYF_Task3/Test_H/Easy_H/20_hanoi.out

@@ -0,0 +1,5 @@
+1 2, 1 3, 2 3, 1 2, 3 1, 3 2, 1 2, 1 3, 2 3, 2 1, 3 1, 2 3, 1 2, 1 3, 2 3, 
+1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 1 2, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 2 3, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 1 2, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 3 1, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 1 2, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 2 3, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 3 1, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 2 3, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 1 2, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 2 3, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 
+1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 
+1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 1 2, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 2 3, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 1 2, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 3 1, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 1 2, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 2 3, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 3 1, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 2 3, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 1 2, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 2 3, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 1 2, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 3 1, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 1 2, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 3 1, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 2 3, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 3 1, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 1 2, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 2 3, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 1 2, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 3 1, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 1 2, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 2 3, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 3 1, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 2 3, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 1 2, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 2 3, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 3 1, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 1 2, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 3 1, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 2 3, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 3 1, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 2 3, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 1 2, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 2 3, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 1 2, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 3 1, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 1 2, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 2 3, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 3 1, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 2 3, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 1 2, 3 2, 3 1, 2 1, 3 2, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 2 1, 3 2, 3 1, 2 1, 2 3, 1 3, 1 2, 3 2, 1 3, 2 1, 2 3, 1 3, 
+0

SysYF_Student/SysYF_Task3/Test_H/Easy_H/20_hanoi.sy

@@ -0,0 +1,27 @@
+
+void move(int x, int y)
+{
+    putint(x); putch(32); putint(y); putch(44); putch(32);
+}
+
+void hanoi(int n, int one, int two, int three)
+{
+    if (n == 1)
+        move(one, three);
+    else {
+        hanoi(n - 1, one, three, two);
+        move(one, three);
+        hanoi(n - 1, two, one, three);
+    }
+}
+
+int main()
+{
+    int n = getint();
+    while (n > 0) {
+        hanoi(getint(), 1, 2, 3);
+        putch(10);
+        n = n - 1;
+    }
+    return 0;
+}

SysYF_Student/SysYF_Task3/Test_H/test_H.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+import subprocess
+import os
+
+IRBuild_ptn = '"{}" "-emit-ir" "-o" "{}" "{}"'
+ExeGen_ptn = '"clang" "{}" "-o" "{}" "{}" "../../../lib/lib.c"'
+Exe_ptn = '"{}"'
+
+def eval(EXE_PATH, TEST_BASE_PATH, optimization):
+    print('===========TEST START===========')
+    print('now in {}'.format(TEST_BASE_PATH))
+    dir_succ = True
+    for case in testcases:
+        print('Case %s:' % case, end='')
+        TEST_PATH = TEST_BASE_PATH + case
+        SY_PATH = TEST_BASE_PATH + case + '.sy'
+        LL_PATH = TEST_BASE_PATH + case + '.ll'
+        INPUT_PATH = TEST_BASE_PATH + case + '.in'
+        OUTPUT_PATH = TEST_BASE_PATH + case + '.out'
+        need_input = testcases[case]
+
+        IRBuild_result = subprocess.run(IRBuild_ptn.format(EXE_PATH, LL_PATH, SY_PATH), shell=True, stderr=subprocess.PIPE)
+        if IRBuild_result.returncode == 0:
+            input_option = None
+            if need_input:
+                with open(INPUT_PATH, "rb") as fin:
+                    input_option = fin.read()
+
+            try:
+                subprocess.run(ExeGen_ptn.format(optimization, TEST_PATH, LL_PATH), shell=True, stderr=subprocess.PIPE)
+                result = subprocess.run(Exe_ptn.format(TEST_PATH), shell=True, input=input_option, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                out = result.stdout.split(b'\n')
+                if result.returncode != b'':
+                    out.append(str(result.returncode).encode())
+                for i in range(len(out)-1, -1, -1):
+                    out[i] = out[i].strip(b'\r')
+                    if out[i] == b'':
+                        out.remove(b'')
+                case_succ = True
+                with open(OUTPUT_PATH, "rb") as fout:
+                    i = 0
+                    for line in fout.readlines():
+                        line = line.strip(b'\r').strip(b'\n')
+                        if line == '':
+                            continue
+                        if out[i] != line:
+                            dir_succ = False
+                            case_succ = False
+                        i = i + 1
+                    if case_succ:
+                        print('\t\033[32mPass\033[0m')
+                    else:
+                        print('\t\033[31mWrong Answer\033[0m')
+            except Exception as _:
+                dir_succ = False
+                print(_, end='')
+                print('\t\033[31mCodeGen or CodeExecute Fail\033[0m')
+            finally:
+                subprocess.call(["rm", "-rf", TEST_PATH, TEST_PATH])
+                subprocess.call(["rm", "-rf", TEST_PATH, TEST_PATH + ".o"])
+                subprocess.call(["rm", "-rf", TEST_PATH, TEST_PATH + ".ll"])
+
+        else:
+            dir_succ = False
+            print('\t\033[31mIRBuild Fail\033[0m')
+    if dir_succ:
+        print('\t\033[32mSuccess\033[0m in dir {}'.format(TEST_BASE_PATH))
+    else:
+        print('\t\033[31mFail\033[0m in dir {}'.format(TEST_BASE_PATH))
+
+    print('============TEST END============')
+
+
+if __name__ == "__main__":
+
+    # you can only modify this to add your testcase
+    TEST_DIRS = [
+                './Easy_H/',
+                ]
+    # you can only modify this to add your testcase
+
+    optimization = "-O0"     # -O0 -O1 -O2 -O3 -O4(currently = -O3) -Ofast
+    for TEST_BASE_PATH in TEST_DIRS:
+        testcases = {}  # { name: need_input }
+        EXE_PATH = os.path.abspath('../../../build/SysYCompiler')
+        testcase_list = list(map(lambda x: x.split('.'), os.listdir(TEST_BASE_PATH)))
+        testcase_list.sort()
+        for i in range(len(testcase_list)-1, -1, -1):
+            if len(testcase_list[i]) == 1:
+                testcase_list.remove(testcase_list[i])
+        for i in range(len(testcase_list)):
+            testcases[testcase_list[i][0]] = False
+        for i in range(len(testcase_list)):
+            testcases[testcase_list[i][0]] = testcases[testcase_list[i][0]] | (testcase_list[i][1] == 'in')
+        eval(EXE_PATH, TEST_BASE_PATH, optimization=optimization)

contribution.md

@@ -0,0 +1,17 @@
+# 组员贡献
+
+## 贡献详述
+
+### 组员1 张三
+
+### 组员2 李四
+
+### 组员3 王五
+
+## 评定结果
+
+| 组员姓名 | 贡献百分比 |
+| :-----: | :-------: |
+|   张三   |    xx%    |
+|   李四   |    xx%    |
+|   王五   |    xx%    |

doc/AST.md

@@ -0,0 +1,473 @@
+# AST
+
+**源码链接：**
+
+[SyntaxTree.h](../include/SyntaxTree.h)
+
+[SyntaxTree.cpp](../src/SyntaxTree.cpp)
+
+
+## 目录
+
+[Ptr](#ptr)
+
+[PtrLst](#ptrlist)
+
+[Position](#position)
+
+[Type](#type)
+
+[Binop](#binop)
+
+[UnaryOp](#unaryOp)
+
+[UnaryCondOp](#unarycondop)
+
+[BinaryCondOp](#binarycondop)
+
+[Node](#node)
+
+[Assembly](#assembly)
+
+[InitVal](#initval)
+
+[GlobalDef](#globaldef)
+
+[FuncDef](#funcdef)
+
+[VarDef](#vardef)
+
+[Stmt](#stmt)
+
+[AssignStmt](#assignstmt)
+
+[ReturnStmt](#returnstmt)
+
+[BlockStmt](#blockstmt)
+
+[EmptyStmt](#emptystmt)
+
+[ExprStmt](#exprstmt)
+
+[Expr](#expr)
+
+[CondExpr](#condexpr)
+
+[AddExpr](#addexpr)
+
+[UnaryCondExpr](#unarycondexpr)
+
+[BinaryCondExpr](#binarycondexpr)
+
+[BinaryExpr](#binaryexpr)
+
+[UnaryExpr](#unaryexpr)
+
+[LVal](#lval)
+
+[Literal](#literal)
+
+[FuncCallStmt](#funccallstmt)
+
+[FuncParam](#funcparam)
+
+[FuncFParamList](#funcfparamlist)
+
+[IfStmt](#ifstmt)
+
+[WhileStmt](#whilestmt)
+
+[BreakStmt](#breakstmt)
+
+[ContinueStmt](#continuestmt)
+
+[Visitor](#visitor)
+
+## Ptr
+
+AST中使用的指针类型。实际上是`std::shared_ptr`
+
+## PtrList
+
+存放[Ptr](#ptr)的list，实际上是`std::vector<Ptr>`
+
+## Position
+
+该节点代表的语法结构在源文件的位置信息，实际上是`yy::location`。由bison/flex自动生成。
+
+## Type
+包含SysY语言支持的数据类型：`Type::INT`以及`Type::VOID`。
+
+多出的`Type::STRING`类型用作系统调用的参数类型，`Type::BOOL`作为条件表达式类型。
+
+## Binop
+
+双目算术表达式的操作符。包含
+
+`Binop::PLUS` 加
+
+`Binop::MINUS`减
+
+`Binop::MULTIPLY`乘
+
+`Binop::DIVIDE`除
+
+`Binop::MODULO`模
+
+## UnaryOp
+
+单目算术表达式操作符，包含
+
+`UnaryOp::PLUS`正
+
+`UnaryOp::MINUS`负
+
+
+## UnaryCondOp
+
+单目条件表达式操作符，包含
+
+`UnaryCondOp::NOT`非
+
+## BinaryCondOp
+
+双目条件表达式操作符，包含
+
+`BinaryCondOp::LT`小于
+
+`BinaryCondOp::LTE`小于等于
+
+`BinaryCondOp::GT`大于
+
+`BinaryCondOp::GTE`大于等于
+
+`BinaryCondOp::EQ`等于等于
+
+`BinaryCondOp::NEQ`不等于
+
+`BinaryCondOp::LAND`逻辑与
+
+`BinaryCondOp::LOR`逻辑或
+
+## Node
+
+语法树所有结点的基类，
+
+`Node::loc`是其在对应源文件的位置信息。类型为[Position](#position)
+
+`virtual void Node::accept(Visitor &visitor)`为虚函数，用于访问者模式，接受一个[Visitor](#visitor)。需要进行重写。
+
+## Assembly
+
+AST的根结点
+
+[PtrList](#ptrlist)<[GlobalDef](#globaldef)> `Assembly::global_defs`存放所有[GlobalDef](#globaldef)指针。
+
+## InitVal
+
+代表初值的结点。该结点为嵌套定义。以下类型的变量初值均可表示：
+
+```c++
+int a = 1 + 1;
+int b[2] = {1,2};
+int c[2][2] = {{1,2},{3,4}}
+...
+```
+
+`bool InitVal::isExp`
+
+为真时初值为[Expr](#expr)类型。为假时代表以`{...}`的形式进行赋初值
+eg
+```c++
+int a = 3 + 1;//isExp=true
+int c[2][2] = {{1,2},{3,4}};//isExp=false
+```
+所有`InitVal`结点最底层一定是[Expr](#expr)类型。也即`isExp`为true
+
+[PtrList](#ptrlist)<[InitVal](#initval)> `InitVal::elementList`
+
+当`isExp`为false时该域才有意义。是包含`{}`中其余`InitVal`结点指针的列表。
+
+[Ptr](#ptr)<[Expr](#expr)> `InitVal::expr`
+
+当`isExp`为true时该域才有意义。一个初值表达式的指针。
+
+## GlobalDef
+
+所有def结点的基类
+
+## FuncDef
+
+代表函数定义。
+
+[Type](#type) `FuncDef::ret_type`。
+
+函数的返回值类型
+
+[Ptr](#ptr)<[FuncFParamList](#funcfparamlist)> `FuncDef::param_list`。
+
+函数的形参指针
+
+`std::string FuncDef::name` 
+
+函数名
+
+[Ptr](#ptr)<[BlockStmt](#blockstmt)> `FuncDef::body` 
+
+函数体指针
+
+## VarDef
+
+代表变量定义
+
+`bool VarDef::is_constant` 
+
+是否为常量
+
+[Type](#type) `VarDef::btype` 
+
+变量类型(在sysY中只能是int)
+
+`std::string VarDef::name`
+
+变量名
+
+`bool VarDef::is_inited`
+
+是否初始化
+
+[PtrList](#ptrlist)<[Expr](#expr)>  `VarDef::array_length`
+
+若为数组，则是存放各维长度表达式指针的列表，否则为空
+
+[Ptr](#ptr)<[InitVal](#initval)> `VarDef::initializers`
+
+若初始化，则是指向初值定义的指针
+
+## Stmt
+
+所有statement的基类
+
+## AssignStmt
+
+表示如下类型的语句:
+```c++
+target = value
+```
+
+即赋值型语句
+
+[Ptr](#ptr)<[Lval](#lval)> `AssignStmt::target` 
+
+赋值表达式的左值指针
+
+[Ptr](#ptr)<[Expr](#expr)> `AssignStmt::value`
+
+赋值表达式右边表达式指针
+
+## ReturnStmt
+
+代表return 语句
+
+[Ptr](#ptr)<[Expr](#expr)> `ReturnStmt::ret`
+
+return 语句返回的表达式指针。空指针代表void return
+
+## BlockStmt
+
+代表使用`{}`括起来的stmt。
+
+[PtrList](#ptrlist)<[Stmt](#stmt)> `BlockStmt::body`
+
+该block中所有stmt指针的列表
+
+## EmptyStmt
+
+空语句
+
+## ExprStmt
+
+表达式语句
+
+[Ptr](#ptr)<[Expr](#exp)> `ExprStmt::exp`
+
+表达式语句对应表达式的指针
+
+## Expr
+
+所有表达式的基类
+
+## CondExpr
+
+所有条件表达式的基类
+
+## AddExpr
+
+所有算术表达式的基类
+
+## UnaryCondExpr
+
+单目条件表达式
+
+`UnaryCondOp UnaryCondExpr::op` 
+
+操作符
+
+[Ptr](#ptr)<[Expr](#expr)> `UnaryCondExpr::rhs`
+
+操作符右端表达式指针
+
+## BinaryCondExpr
+
+双目条件表达式
+
+`BinaryCondOp BinaryCondExpr::op` 
+
+操作符
+
+[Ptr](#ptr)<[Expr](#expr)> `BinaryCondExpr::lhs, rhs`
+
+操作符左右两端表达式指针
+
+## BinaryExpr
+
+双目算术表达式
+
+`BinOp BinaryExpr::op` 
+
+操作符
+
+[Ptr](#ptr)<[Expr](#expr)> `BinaryExpr::lhs, rhs`
+
+操作符左右两端表达式指针
+
+## UnaryExpr
+
+单目算术表达式
+
+`UnaryOp UnaryExpr::op` 
+
+操作符
+
+[Ptr](#ptr)<[Expr](#expr)> `UnaryExpr::rhs`
+
+操作符右端表达式指针
+
+## LVal
+
+左值表达式
+
+`std::string Lval::name` 
+
+变量名
+
+[PtrList](#ptrlist)<[Expr](#expr)> `LVal::array_index`
+
+数组索引的指针列表。若不是数组，则为空
+
+## Literal
+
+语义值类型，包含整数和字符串
+
+`bool Literal::is_int`
+
+是否为整形
+
+`int Literal::int_const`
+
+整数语义值
+
+`std::string Literal::str`
+
+字符串语义值(未处理转义)
+
+## FuncCallStmt
+
+函数调用
+
+`std::string FuncCallStmt::name` 
+
+被调用的函数名
+
+[PtrList](#ptrlist)<[Expr](#expr)> `FuncCallStmt::params`
+
+存放函数实参表达式指针的列表
+
+## FuncParam
+
+单个函数形参
+
+`std::string FuncParam::name` 
+
+形参名
+
+[Type](#type) `FuncParam::param_type` 
+
+形参类型
+
+[PtrList](#ptrlist)<[Expr](#expr)> `FuncParam::array_index`
+
+形参的数组维度列表，存放每一维的表达式指针。若非数组则为空
+
+## FuncFParamList
+
+存放一个函数的所有形参
+
+[PtrList](#ptrlist)<[FuncParam](#funcparam)> `FuncFParamList::params`
+
+存放所有形参指针的列表
+
+## IfStmt
+
+表示如下结构:
+```c++
+if(cond_exp)
+    if_stmt
+或
+if(cond_exp)
+    if_stmt
+else
+    else_stmt
+```
+
+[Ptr](#ptr)<[Expr](#expr)> `IfStmt::cond_exp`
+
+cond_exp的指针
+
+[Ptr](#ptr)<[Stmt](#stmt)> `IfStmt::if_statement`
+
+if_stmt的指针
+
+[Ptr](#ptr)<[Stmt](#stmt)> `IfStmt::else_statement`
+
+else_stmt的指针(若无else，则为空)
+
+
+## WhileStmt
+
+表示如下结构
+```c++
+while(cond_exp)
+    stmt
+```
+
+[Ptr](#ptr)<[Expr](#expr)> `WhileStmt::cond_exp`
+
+cond_exp的指针
+
+[Ptr](#ptr)<[Stmt](#stmt)> `WhileStmt::statement`
+
+stmt的指针
+
+
+## BreakStmt
+
+表示一个break语句
+
+## ContinueStmt
+
+表示一个continue语句
+
+## Visitor
+
+访问者模式的基类，用于访问AST。需要重写其中的visit函数。

doc/SysYIR.md

@@ -0,0 +1,624 @@
+# SysY IR
+
+- [SysY IR](#sysy-ir)
+  - [IR](#ir)
+    - [IR Features](#ir-features)
+    - [IR Format](#ir-format)
+    - [Instruction](#instruction)
+      - [Terminator Instructions](#terminator-instructions)
+        - [Ret](#ret)
+        - [Br](#br)
+      - [Standard binary operators](#standard-binary-operators)
+        - [Add FAdd](#add-fadd)
+        - [Sub FSub](#sub-fsub)
+        - [Mul FMul](#mul-fmul)
+        - [SDiv FDiv](#sdiv-fdiv)
+        - [SRem](#srem)
+      - [Memory operators](#memory-operators)
+        - [Alloca](#alloca)
+        - [Load](#load)
+        - [Store](#store)
+      - [CastInst](#castinst)
+        - [ZExt](#zext)
+        - [FpToSi](#fptosi)
+        - [SiToFp](#sitofp)
+      - [Other operators](#other-operators)
+        - [ICmp FCmp](#icmp-fcmp)
+        - [Call](#call)
+        - [GetElementPtr](#getelementptr)
+  - [C++ APIs](#c-apis)
+    - [核心类概念图](#核心类概念图)
+    - [BasicBlock](#basicblock)
+    - [Constant](#constant)
+    - [Function](#function)
+    - [GlobalVariable](#globalvariable)
+    - [IRBuilder](#irbuilder)
+    - [Instruction](#instruction-1)
+    - [Module](#module)
+    - [Type](#type)
+    - [User](#user)
+    - [Value](#value)
+    - [总结](#总结)
+
+## IR
+
+### IR Features
+- 采用 3 地址的方式 
+  - 区别于 X86 汇编的目标和源寄存器共用的模式： ADD EAX, EBX 
+  - %2 = add i32 %0, %1
+- SSA 形式 + 无限寄存器
+  - 每个变量都只被赋值一次 
+  - 容易确定操作间的依赖关系，便于优化分析
+- 强类型系统
+  - 每个 Value 都具备自身的类型， 
+  - IR类型系统：
+    - `i1`：1位宽的整数类型
+    - `i32`：32位宽的整数类型
+    - `float`：单精度浮点数类型
+    - `pointer`：指针类型
+      - 例如：`i32*, [10 x i32*]`
+    - `label` bb的标识符类型
+    - `functiontype`函数类型，包括函数返回值类型与参数类型（下述文档未提及）
+
+### IR Format
+以下面的`easy.c`与`easy.ll`为例进行说明。  
+通过命令`clang -S -emit-llvm easy.c`可以得到对应的`easy.ll`如下（助教增加了额外的注释）。`.ll`文件中注释以`;`开头。  
+
+- `easy.c`: 
+  ``` c
+  int main(){
+    int a;
+    int b;
+    a = 1;
+    b = 2;
+    if(a < b)
+      b = 3;
+    return a + b;
+  }
+  ```
+- `easy.ll`:
+  ``` c
+  ; 注释: .ll文件中注释以';'开头
+  ; ModuleID = 'easy.c'                                
+  source_filename = "easy.c"  
+  ; 注释: target的开始
+  target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+  target triple = "x86_64-unknown-linux-gnu"
+  ; 注释: target的结束
+  
+  ; 注释: 全局main函数的定义
+  ; Function Attrs: noinline nounwind optnone uwtable
+  define dso_local i32 @main() #0 {
+  ; 注释: 第一个基本块的开始
+    %1 = alloca i32, align 4
+    %2 = alloca i32, align 4
+    %3 = alloca i32, align 4
+    store i32 0, i32* %1, align 4
+    store i32 1, i32* %2, align 4
+    store i32 2, i32* %3, align 4
+    %4 = load i32, i32* %2, align 4
+    %5 = load i32, i32* %3, align 4
+    %6 = icmp slt i32 %4, %5
+    br i1 %6, label %7, label %8
+  ; 注释: 第一个基本块的结束
+
+  ; 注释: 第二个基本块的开始
+  7:                                                ; preds = %0
+    store i32 3, i32* %3, align 4
+    br label %8
+  ; 注释: 第二个基本块的结束
+  
+  ; 注释: 第三个基本块的开始
+  8:                                                ; preds = %7, %0
+    %9 = load i32, i32* %2, align 4
+    %10 = load i32, i32* %3, align 4
+    %11 = add nsw i32 %9, %10
+    ret i32 %11                                     ; 注释: 返回语句
+  ; 注释: 第三个基本块的结束
+  }
+  
+  attributes #0 = { noinline nounwind optnone uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+  
+  !llvm.module.flags = !{!0}
+  !llvm.ident = !{!1}
+  
+  !0 = !{i32 1, !"wchar_size", i32 4}
+  !1 = !{!"clang version 10.0.1 "}
+  ```
+其中，每个program由1个或多个module组成，module之间由LLVM Linker合并。  
+每个module组成如下：
+- Target Information：
+  ``` c
+  target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+  target triple = "x86_64-unknown-linux-gnu"
+  ```
+- Global Symbols: main函数的定义
+- Others:尾部其他信息  
+
+每个函数的组成如下：
+- 头部：函数返回值类型，函数名，函数参数
+- 一个或多个基本块：
+  - 每个基本块又有Label和Instruction组成。
+    ``` c
+    8:                                                ; preds = %7, %0
+      %9 = load i32, i32* %2, align 4
+      %10 = load i32, i32* %3, align 4
+      %11 = add nsw i32 %9, %10
+      ret i32 %11  
+    ```
+    这个例子中，`8`就是Label。  
+    `%9 = load i32, i32* %2, align 4`中的`%9`是目的操作数，`load`是指令助记符，`i32`是`int32`的类型，`i32*`是指向`int32`的地址类型，`%2`是源操作数，`align 4`表示对齐。
+### Instruction
+#### Terminator Instructions
+**注**：ret与br都是Terminator Instructions也就是终止指令，在llvm基本块的定义里，基本块是单进单出的，因此只能有一条终止指令（ret或br）。当一个基本块有两条终止指令，clang 在做解析会认为第一个终结指令是此基本块的结束，并会开启一个新的匿名的基本块（并占用了下一个编号）。
+##### Ret 
+- 格式
+  - `ret <type> <value>`
+  - `ret void`
+- 例子：
+  - `ret i32 %0`
+  - `ret void`
+- 概念：` ret`指令用于将控制流（以及可选的值）从函数返回给调用者。`ret`指令有两种形式：一种返回值，然后终结函数，另一种仅终结函数。
+  
+##### Br 
+- 格式：
+  - `br i1 <cond>, label <iftrue>, label <iffalse>`
+  - `br label <dest>`
+- 例子：
+  - `br i1 %cond label %truebb label %falsebb`
+  - `br label %bb`
+- 概念：`br`指令用于使控制流转移到当前功能中的另一个基本块。 该指令有两种形式，分别对应于条件分支和无条件分支。
+    
+#### Standard binary operators
+##### Add FAdd
+- 格式：
+  - `<result> = add <type> <op1>, <op2>`
+  - `<result> = fadd <type> <op1>, <op2>`
+- 例子：
+  - `%2 = add i32 %1, %0` 
+  - `%2 = fadd float %1, %0` 
+- 概念：`add`指令返回其两个`i32`类型的操作数之和，返回值为`i32`类型，`fadd`指令返回其两个`float`类型的操作数之和，返回值为`float`类型
+  
+##### Sub FSub
+- 格式与例子与`add`，`fadd`类似
+- 概念：`sub`指令返回其两个`i32`类型的操作数之差，返回值为`i32`类型，`fsub`指令返回其两个`float`类型的操作数之差，返回值为`float`类型
+
+##### Mul FMul
+- 格式与例子与`add`，`fadd`类似
+- 概念：`mul`指令返回其两个`i32`类型的操作数之积，返回值为`i32`类型，`fmul`指令返回其两个`float`类型的操作数之积，返回值为`float`类型
+
+##### SDiv FDiv
+- 格式与例子与`add`，`fadd`类似
+- 概念：`sdiv`指令返回其两个`i32`类型的操作数之商，返回值为`i32`类型，`fdiv`指令返回其两个`float`类型的操作数之商，返回值为`float`类型
+
+##### SRem
+- 格式与例子与`add`类似
+- 概念：`srem`指令返回其两个`i32`类型的操作数之模，返回值为`i32`类型
+
+#### Memory operators
+##### Alloca
+- 格式：`<result> = alloca <type>`
+- 例子：
+  - `%ptr = alloca i32`	
+  - `%ptr = alloca [10 x i32]`
+- 概念： `alloca`指令在当前执行函数的堆栈帧上分配内存，当该函数返回其调用者时将自动释放该内存。 始终在地址空间中为数据布局中指示的分配资源分配对象
+
+##### Load
+- 格式：`<result> = load <type>, <type>* <pointer>`
+- 例子：`%val = load i32, i32* %ptr`
+- 概念：`load`指令用于从内存中读取。
+
+##### Store
+- 格式：`store <type> <value>, <type>* <pointer>`
+- 例子：`store i32 3, i32* %ptr`
+- 概念：`store`指令用于写入内存
+
+#### CastInst
+##### ZExt    
+- 格式：`<result> = zext <type> <value> to <type2>`
+- 例子：`%1 = zext i1 %0 to i32`
+- 概念：`zext`指令将其操作数**零**扩展为`type2`类型。
+
+##### FpToSi
+- 概念：`fptosi`指令将浮点值转换为`type2`（整数）类型。
+- 格式：`<result> = fptosi <type> <value> to <type2>`
+- 例子：`%Y = fptosi float 1.0E-247 to i32`
+
+##### SiToFp
+- 格式：`<result> = sitofp <type> <value> to <type2>`
+- 例子：`%X = sitofp i32 257 to float`
+- 概念：`sitofp`指令将有符号整数转换为`type2`（浮点数）类型。
+
+#### Other operators
+##### ICmp FCmp
+- 格式：
+  - `<result> = icmp <cond> <type> <op1>, <op2>`
+    - `<cond> = eq | ne | sgt | sge | slt | sle`
+  - `<result> = fcmp <cond> <type> <op1>, <op2>`
+    - `<cond> = eq | ne | ugt | uge | ult | ule`
+- 例子：`i1 %2 = icmp sge i32 %0, %1`
+- 概念：`icmp`指令根据两个整数的比较返回布尔值，`fcmp`指令根据两个浮点数的比较返回布尔值。
+
+##### Call
+- 格式：
+  - `<result> = call <return ty> <func name>(<function args>) `
+- 例子：
+  - `%0 = call i32 @func( i32 %1, i32* %0)`
+  - `call @func( i32 %arg)`
+- 概念：`call`指令用于使控制流转移到指定的函数，其传入参数绑定到指定的值。 在被调用函数中执行`ret`指令后，控制流程将在函数调用后继续执行该指令，并且该函数的返回值绑定到`result`参数。
+
+##### GetElementPtr
+- 格式：`<result> = getelementptr <type>, <type>* <ptrval> [, <type> <idx>]`
+- 例子：
+  - `%2 = getelementptr [10 x i32], [10 x i32]* %1, i32 0, i32 %0` 
+  - `%2 = getelementptr i32, i32* %1 i32 %0` 
+- 参数解释：第一个参数是计算基础类型，第二第三个参数表示索引开始的指针类型及指针，`[]`表示可重复参数，里面表示的数组索引的偏移类型及偏移值。（思考指针类型为`[10 x i32]`指针和`i32`指针`getelementptr`用法的不同）
+- 概念：`getelementptr`指令用于获取数组结构的元素的地址。 它仅执行地址计算，并且不访问内存。
+
+## C++ APIs
+
+### 核心类概念图
+
+to make
+
+### BasicBlock
+- 继承：从[value](#value)继承
+
+- 含义：基本块，是一个是单入单出的代码块，该类维护了一个指令链表，基本块本身属于 Value, 类型是 \<label\>，会被分支指令调用
+
+- 成员：
+  
+  - instr_list_：指令链表
+  - pre_basic_blocks_： bb前驱集合
+  - succ_basic_blocks_：bb后继集合
+  
+- API: 
+
+  ```c++
+  static BasicBlock *create(Module *m, const std::string &name , Function *parent )
+  // 创建并返回BB块，参数分别是BB块所属的Module，name是其名字默认为空，BB块所属的Function
+  Function *get_parent();
+  // 返回BB块所属的函数
+  Module *get_module();
+  // 返回BB块所属的Module
+  Instruction *get_terminator();
+  // 返回BB块的终止指令(ret|br)若BB块最后一条指令不是终止指令返回null
+  void add_instruction(Instruction *instr);
+  // 将instr指令添加到此BB块指令链表结尾，调用IRBuilder里来创建函数会自动调用此方法
+  void add_instr_begin(Instruction *instr);
+  // 将instr指令添加到此BB块指令链表开头
+  void delete_instr(Instruction *instr);
+  // 将instr指令从BB块指令链表中移除，同时调用api维护好instr的操作数的use链表。
+  bool empty();
+  // BB块中为空返回true
+  int get_num_of_instr();
+  // 返回BB块中指令的数目
+  std::list<Instruction *> &get_instructions();
+  //返回BB块的指令链表
+  void erase_from_parent();
+  // 将此BB块从所属函数的bb链表中移除
+      
+  /****************api about cfg****************/
+  std::list<BasicBlock *> &get_pre_basic_blocks() // 返回前驱快集合
+  std::list<BasicBlock *> &get_succ_basic_blocks() // 返回后继块集合
+  void add_pre_basic_block(BasicBlock *bb) // 添加前驱块
+  void add_succ_basic_block(BasicBlock *bb) // 添加后继块
+  void remove_pre_basic_block(BasicBlock *bb) // 移除前驱块
+  void remove_succ_basic_block(BasicBlock *bb) // 移除后继块
+  /****************api about cfg****************/
+  
+  ```
+  
+  
+### Constant
+- 继承：从[User](#user)继承
+- 含义：常数，各种类型常量的基类
+- 子类：
+  - ConstantInt：
+    - 含义：int类型的常数
+    
+    - 成员：
+      
+      - val_：常数值
+      
+    - API：
+    
+      ```cpp
+      int get_value() // 返回该常数类型中存的常数值
+      static int get_value(ConstantInt *const_val)// 返回该常数类型const_val中存的常数值
+      static ConstantInt *get(int val, Module *m) // 以val值来创建常数类
+      static ConstantInt *get(bool val, Module *m) // 以val值来创建bool常数类
+      ```
+    
+  - ConstantFP:
+    - 含义：float类型的常数
+    
+    - 成员：
+      
+      - val_：常数值
+      
+    - API：
+    
+      ```cpp
+      static ConstantFP *get(float val, Module *m) // 以val值创建并返回浮点数常量类
+      float get_value() // 返回该常数类型中存的常数值
+      ```
+    
+  - ConstantZero：
+    
+    - 含义：用于全局变量初始化的常量0值。
+    
+    - API：
+    
+      ```cpp
+      static ConstantZero *get(Type *ty, Module *m);// 创建并返回ConstantZero常量类
+      ```
+    
+  - ConstantArray
+
+    - 含义：数组类型的常数
+    - 成员：
+        - const_array_：数组常量值
+
+    - API：cminus语法不需要数组常量的支持（本次实验不需要用到），在此不过多解释。感兴趣可以自行查看源代码。
+### Function
+- 继承：从[Value](#value)继承
+
+- 含义：函数，该类描述 LLVM 的一个简单过程，维护基本块表，格式化参数表
+
+- 成员：
+  - basic_blocks_：基本块列表
+  - arguments_：形参列表
+  - parent_：函数属于的module
+  
+- API：
+
+  ```cpp
+  static Function *create(FunctionType *ty, const std::string &name, Module *parent);
+  // 创建并返回Function，参数依次是待创建函数类型ty，函数名字name(不可为空)，函数所属的Module
+  FunctionType *get_function_type() const;
+  // 返回此函数类的函数类型
+  Type *get_return_type() const;
+  // 返回此函数类型的返回值类型
+  void add_basic_block(BasicBlock *bb);
+  // 将bb添加至Function的bb链表上（调用bb里的创建函数时会自动调用此函数挂在function的bb链表上）
+  unsigned get_num_of_args() const;
+  // 得到函数形参数数量
+  unsigned get_num_basic_blocks() const;
+  // 得到函数基本块数量
+  Module *get_parent() const;
+  // 得到函数所属的Module
+  std::list<Argument *>::iterator arg_begin() 
+  // 得到函数形参的list的起始迭代器
+  std::list<Argument *>::iterator arg_end() 
+  // 得到函数形参的list的终止迭代器
+  void remove(BasicBlock* bb) 
+  // 从函数的bb链表中删除一个bb
+  std::list<BasicBlock *> &get_basic_blocks() 
+  // 返回函数bb链表
+  std::list<Argument *> &get_args() 
+  // 返回函数的形参链表
+  void set_instr_name();
+  // 给函数中未命名的基本块和指令命名
+  ```
+
+  
+
+- 相关类：
+  - Argument：
+    - 含义：参数
+    
+    - 成员：
+      - arg_no_：参数序号
+      - parent_：参数属于哪个函数
+      
+    - API
+    
+      ```cpp
+      Function *get_parent() // 返回参数的所属函数
+      unsigned get_arg_no() const // 返回参数在所在函数的第几个参数
+      ```
+### GlobalVariable
+- 继承：从[User](#user)继承
+- 含义：全局变量，该类用于表示全局变量，是 GlobalValue 的子类，根据地址来访问
+- 成员：
+  - is_const：是否为常量
+  - init_val_：初始值
+- API：由于cminusf语义要求所有的全局变量都默认初始化为0，故`GlobalVariable`中成员和API再构造CminusFBuilder用不到
+### IRBuilder
+- 含义：生成IR的辅助类，该类提供了独立的接口创建各种 IR 指令，并将它们插入基本块中, 该辅助类不做任何类型检查。
+
+- API：
+
+  ```cpp
+  BasicBlock *get_insert_block()// 返回正在插入指令的BB
+  void set_insert_point(BasicBlock *bb)// 设置当前需要插入指令的bb
+  Instruction *create_[instr_type]()// 创建instr_type(具体名字参考IRBuilder.h代码)的指令并对应插入到正在插入的BB块，这种类型的指令看函数名字和参数名字和IR文档是一一对应的。
+  ```
+
+  
+### Instruction
+- 继承：从[User](#user)继承
+- 含义：指令，该类是所有 LLVM 指令的基类，主要维护指令的操作码（指令类别），指令所属的基本块，指令的操作数个数信息
+- 成员：
+  - parent_：指令所属的BasicBlock
+  - op_id_：指令的类型id
+  - num_ops_指令的操作数个数
+- 子类：
+  - BinaryInst：双目运算指令包括add、sub、mul、div
+  - 其他子类和前述文档中提到的指令一一对应，不在此赘述。
+- API：所有指令的创建都要通过IRBuilder进行，不需要关注Instruction类的实现细节，（**注**：不通过IRBuilder来创建指令，而直接调用指令子类的创建方法未经助教完善的测试）
+### Module
+- 含义：一个编译单元，在此源语言的意义下是一个文件
+
+- 成员：
+  - function_list_：函数链表，记录了这个编译单元的所有函数
+  - global_list_：全局变量链表
+  - instr_id2string_：通过指令类型id得到其打印的string
+  - module_name_, source_file_name：未使用
+  - 从module中能取到的基本类型
+  
+- API：
+
+  ```cpp
+  Type *get_void_type(); 
+  // 得到IR中的void类型其他类型可以用类似的API得到(推荐取得类型采用lab3助教提供的方法Type::get())
+  void add_function(Function *f);
+  // 将f挂在module的function链表上，在function被创建的时候会自动调用此方法来添加function
+  void add_global_variable(GlobalVariable* g);
+  // 将g挂在module的GlobalVariable链表上，在GlobalVariable被创建的时候会自动调用此方法来添加GlobalVariable
+  std::list<GlobalVariable *> get_global_variable();
+  // 获取全局变量列表
+  std::string get_instr_op_name( Instruction::OpID instr )；
+  // 获取instr对应的指令名(打印ir时调用)
+  void set_print_name();
+  // 设置打印ir的指令与bb名字；
+  ```
+  
+  
+### Type
+- 含义：IR的类型，该类是所有类型的超类
+
+- 成员：
+  
+  - tid_：枚举类型，表示type的类型（包含VoidType、LabelType、FloatType、Int1、Int32、ArrayType、PointerType）
+  
+- 子类：
+  - IntegerType
+    - 含义：int 类型
+    
+    - 成员：
+      
+      - num_bits：长度（i1或者i32）
+      
+    - API：
+    
+      ```cpp
+      unsigned get_num_bits();// 返回int的位数
+      ```
+  - FloatType
+    
+    - 含义：float 类型
+  - FunctionType
+    - 含义：函数类型
+    
+    - 成员：
+      - result_：返回值类型
+      - args_：参数类型列表
+      
+    - API：
+    
+      ```cpp
+      static FunctionType *get(Type *result, std::vector<Type*> params);
+      // 返回函数类型，参数依次是返回值类型result，形参类型列表params
+      unsigned get_num_of_args() const;
+      // 返回形参个数
+      Type *get_param_type(unsigned i) const;
+      // 返回第i个形参的类型
+      std::vector<Type *>::iterator param_begin() 
+      // 返回形参类型列表的起始迭代器
+      std::vector<Type *>::iterator param_end() 
+      // 返回形参类型列表的终止迭代器    
+      Type *get_return_type() const;
+      // 返回函数类型中的返回值类型
+      ```
+  - ArrayType
+    - 含义：数组类型
+    
+    - 成员：
+      - contained_：数组成员的类型
+      - num_elements_：数组维数
+      
+    - API：
+    
+      ```cpp
+      static ArrayType *get(Type *contained, unsigned num_elements)
+      // 返回数组类型，参数依次是 数组元素的类型contained，数组元素个数num_elements
+      Type *get_element_type() const 
+      // 返回数组元素类型
+      unsigned get_num_of_elements() const
+      // 返回数组元素个数
+      ```
+  - PointerType
+    - 含义：指针类型
+    
+    - 成员：
+      
+      - contained_：指针指向的类型
+      
+    - API：
+    
+      ```cpp
+      Type *get_element_type() const { return contained_; }
+      // 返回指针指向的类型
+      static PointerType *get(Type *contained);
+      // 创建指向contained类型的指针类型
+      Type *get_pointer_element_type()
+      // 对于pointertype而言返回指针指向的类型，其他则返回nullptr
+      ```
+  
+- API:
+
+  ```cpp
+  bool is_void_type()// 判断是否是void类型其他类型有类似API请查看Type.h
+  static Type *get_void_type(Module *m);// 得到void类型
+  Type *get_pointer_element_type();// 若是PointerType则返回指向的类型，若不是则返回nullptr。
+  Type *get_array_element_type();// 若是ArrayType则返回指向的类型，若不是则返回nullptr。
+  ```
+  
+  
+### User
+- 继承：从[value](#value)继承
+
+- 含义：使用者，提供一个操作数表，表中每个操作数都直接指向一个 Value, 提供了 use-def 信息，它本身是 Value 的子类， Value 类会维护一个该数据使用者的列表，提供def-use信息。简单来说操作数表表示我用了谁，该数据使用者列表表示谁用了我。这两个表在后续的**优化实验**会比较重要请务必理解。
+
+- 成员：
+  - operands_：参数列表，表示这个使用者所用到的参数
+  - num_ops_：表示该使用者使用的参数的个数
+  
+- API：
+
+  ```cpp
+  Value *get_operand(unsigned i) const;
+  // 从user的操作数链表中取出第i个操作数
+  void set_operand(unsigned i, Value *v);
+  // 将user的第i个操作数设为v
+  void add_operand(Value *v);
+  // 将v挂到User的操作数链表上
+  unsigned get_num_operand() const;
+  // 得到操作数链表的大小
+  void remove_use_of_ops();
+  // 从User的操作数链表中的所有操作数处的use_list_ 移除该User;
+  void remove_operands(int index1,int index2);
+  // 移除操作数链表中索引为index1-index2的操作数，例如想删除第0个操作数：remove_operands(0,0)
+  ```
+
+
+
+
+### Value 
+- 含义：最基础的类，代表一个操作数，代表一个可能用于指令操作数的带类型数据
+
+- 成员：
+  - use_list_：记录了所有使用该操作数的指令的列表
+  - name_：名字
+  - type_：类型，一个type类，表示操作数的类型
+  
+- API：
+
+  ```cpp
+  Type *get_type() const //返回这个操作数的类型
+  std::list<Use> &get_use_list() // 返回value的使用者链表
+  void add_use(Value *val, unsigned arg_no = 0);
+  // 添加val至this的使用者链表上
+  void replace_all_use_with(Value *new_val);
+  // 将this在所有的地方用new_val替代，并且维护好use_def与def_use链表
+  void remove_use(Value *val);
+  // 将val从this的use_list_中移除
+  ```
+
+
+
+### 总结
+
+助教在接口文档里筛选了可能会需要用到的接口，如果对API有问题的请移步issue讨论，本次`SysY IR`接口由助教自行设计实现，并做了大量测试，如有对助教的实现方法有异议或者建议的也请移步issue讨论，**请不要直接修改助教的代码，若因修改助教代码造成后续实验仓库合并的冲突请自行解决**。

doc/phase1.md

@@ -0,0 +1,33 @@
+# IR实验阶段一
+本实验由黄庄湫、吴毓辰助教设计
+
+## 前言
+本次实验的目的是让大家熟悉阶段三所需相关知识:   
+LLVM IR
+
+## 任务描述
+[了解LLVM IR](#llvm-ir介绍)  
+[通过clang生成的.ll，了解LLVM IR与c代码的对应关系](#例子-利用clang生成的ll)  
+[根据c程序手写.ll文件实现相同功能](#你需要做-手动编写ll)  
+
+## 实验内容
+### LLVM IR介绍
+根据[维基百科](https://zh.wikipedia.org/zh-cn/LLVM)的介绍，LLVM是一个自由软件项目，它是一种编译器基础设施，以C++写成，包含一系列模块化的编译器组件和工具链，用来开发编译器前端和后端。IR的全称是Intermediate Representation，即中间表示。LLVM IR是一种类似于汇编的底层语言。  
+LLVM IR的具体指令可以参考[Reference Manual](http://llvm.org/docs/LangRef.html)。但是你会发现其内容庞杂。虽然助教认为，高效地查阅官方文档及手册是非常必要的一项技能，但是由于其手册过于复杂，因此助教筛选了后续实验中将要用到的子集，总结为了[精简的IR Reference手册](./SysYIR.md)。  
+作为一开始的参考，你可以先阅读其中`IR Features`和`IR Format`两节，后续有需要再反复参考。  
+
+### 例子: 利用clang生成的.ll
+阅读`SysYF_Student/SysYF_Task1/ta_demo/go_upstairs.c`  
+在对应文件夹内输入`clang -S -emit-llvm go_upstairs.c`指令，你可以得到对应的`go_upstairs.ll`  
+你需要结合`go_upstairs.c`阅读`go_upstairs.ll`，理解其中每条LLVM IR指令与c代码的对应情况。  
+通过`lli go_upstairs.ll; echo $?`指令，你可以测试`go_upstairs.ll`执行结果的正确性。  
+
+### 你需要做: 手动编写.ll
+助教在`SysYF_Student/SysYF_Task1/student_sy/`内提供了四个简单的sy程序：assign_test.sy，func_test.sy，if_test.sy，while_test.sy  
+你需要在`SysYF_Student/SysYF_Task1/student_ll/`内手工完成自己的assign_test.ll，func_test.ll，if_test.ll，while_test.ll文件，以实现与上述C程序相同的逻辑功能。你需要添加必要的注释，`.ll`文件的注释是以`;`开头的  
+必要的情况下，你可以参考`clang -S -emit-llvm`的输出，但是你提交的结果必须避免同此输出一字不差  
+注：`.sy`文件是我们定义的语言文件，`clang`无法直接识别  
+
+### 运行.ll文件
+- `lli`会运行`*.ll`文件
+- `$?`的内容是上一条命令所返回的结果，而`echo $?`可以将其输出到终端中 

doc/phase2.md

@@ -0,0 +1,37 @@
+# IR实验阶段二
+本实验由黄庄湫、吴毓辰助教设计
+
+## 前言
+本次实验的目的是让大家熟悉阶段三所需相关知识:   
+SysY IR（由助教编写的LLVM IR的轻量级C++接口）。  
+
+## 任务描述
+[了解SysY IR](#sysy-ir---llvm-ir的c接口)  
+[通过助教提供的C++例子，了解SysY IR的C++接口及实现](#例子-利用sysy-ir--cpp-生成ll)  
+[根据c程序手写C++文件调用SysY IR的API生成相同功能的.ll文件](#你需要做-利用sysy-ir--c编写生成ll的程序)
+
+## 实验内容
+### SysY IR - LLVM IR的C++接口
+由于LLVM IR官方的C++接口的文档同样过于冗长，助教提供了SysY IR这一C++接口库。你需要阅读[SysY IR核心类的介绍](./SysYIR.md)。  
+本关会要求大家通过SysY IR根据AST构建生成LLVM IR。所以你需要仔细阅读文档了解其接口的设计。
+
+### 例子: 利用SysY IR + C++ 生成.ll
+为了让大家更直观地感受并学会LightIR接口的使用，助教提供了`SysYF_Student/SysYF_Task2/ta_demo/go_upstairs_gen.cpp`。  
+该C++程序会生成与go_upstairs.c逻辑相同的LLVM IR文件。助教提供了详尽的注释，一定要好好利用！  
+
+### 你需要做: 利用SysY IR + C++编写生成.ll的程序
+你需要在`SysYF_Student/SysYF_Task2/student_cpp/`文件夹中，调用SysY IR接口，编写自己的assign_gen.cpp，func_gen.cpp，if_gen.cpp，while_gen.cpp程序，以生成与phase1的四个sy程序相同逻辑功能的`.ll`文件。
+
+### 编译、运行和验证
+在 `SysYF_Student/SysYF_Task2/build/` 下执行:
+``` shell
+# 如果存在 CMakeCache.txt 要先删除
+# rm CMakeCache.txt
+cmake ..
+make
+```
+你可以得到对应`gcd_array_generator.cpp`的可执行文件。  
+``` shell
+./go_upstairs_generator
+```
+即可执行所得到的可执行文件, 打印出与go_upstairs.c逻辑相同的LLVM IR代码

doc/phase3.md

@@ -0,0 +1,80 @@
+# IR实验阶段三
+本实验由黄庄湫、吴毓辰助教设计
+
+## 前言
+本次实验我们要使用访问者模式来实现 IR 自动生成。  
+对于产生的IR， 我们可以调用 clang 生成可执行文件，这样一个初级的 SysYF 编译器就完成啦！  
+
+## 任务描述
+
+阅读[SysYF 的语义规则](../SysYF语言定义.pdf)，注意本次实验必做部分语言可能与前几次实验有不同  
+阅读[SysY IR 核心类介绍](./SysYIR.md)  
+阅读[实验框架](#实验框架)，理解如何使用框架以及注意事项  
+
+修改 `src/SysYBuilder/SysYBuilder.cpp` 来实现自动 IR 产生的算法，使得它能正确编译任何合法的 SysYF 程序
+注: 本次实验不需要实现多维数组
+
+## 实验框架
+
+本次实验使用了由C++编写的 SysY IR 来生成 LLVM IR。为了便于大家进行实验，该框架自动完成了语法树到 C++ 上的抽象语法树的转换。
+
+在SysYBuilder.hpp中，我们还定义了一个用于存储作用域的类`Scope`。它的作用是辅助我们在遍历语法树时，管理不同作用域中的变量。它提供了以下接口：
+```cpp
+// 进入一个新的作用域
+void enter();
+// 退出一个作用域
+void exit();
+// 往当前作用域插入新的名字->值映射
+bool push(std::string name, Value *val);
+// 根据名字，以及是否为函数的bool值寻找到对应值
+// isfunc 为 true 时为寻找函数，否则为寻找其他变量对应的值
+// 思考：将函数单独处理的目的
+Value* find(std::string name, bool isfunc);
+// 判断当前是否在全局作用域内
+bool in_global();
+```
+你们需要根据语义合理调用`enter`与`exit`，并且在变量声明和使用时正确调用`push`与`find`。在类`SysYfBuilder`中，有一个`Scope`类型的成员变量`scope`，它在初始化时已经将特殊函数加入了作用域中。因此，你们在进行名字查找时不需要顾虑是否需要对特殊函数进行特殊操作。
+
+## 运行与调试
+
+### 运行 SysYCompiler
+
+```sh
+mkdir build
+cd build
+cmake ..
+make
+```
+
+编译后会产生 `SysYCompiler` 程序，它能将`.sy`文件输出为LLVM IR，可以利用clang将IR编译成二进制文件。
+
+当需要对 `.sy` 文件测试时，可以这样使用：
+
+```sh
+SysYCompiler test.sy -emit-ir -o test.ll
+```
+
+### 自动测试
+
+助教提供了自动评测脚本, 在`SysYF_Student/SysYF_Task3/Test_H/`目录下执行`python3 test_H.py`, 即可得到评测信息
+
+### Bonus
+
+对于学有余力的小组, 我们提供了Bonus环节, 若小组能完成Bonus部分, 将会有额外加分(仅针对本次实验的团队代码得分, 并且分数不能超过该部分得分上限)
+
+Bonus部分说明如下:
+   - H班:
+      - 多维数组
+   - 网安班:
+      - 将一维数组指针作为参数
+      - 逻辑运算(\&\&, \|\|, \!), 重点考察短路计算
+      - 多维数组
+
+Bonus部分得分标准: 每个部分单独给分, 每个部分需要通过全部对应测例并在线下检查时给助教讲清思路才能得分
+
+若小组完成了Bonus部分, 需在线下检查时向助教提出, 并让助教当场检查. 若在统一线下检查过后自行找助教检查, 该Bonus不算分
+
+### 备注
+
+测试样例并不止公开的20个样例, 助教准备了许多隐藏测例来考验大家:), 隐藏测例并不会放在平台上
+平台上第三部分的分数并不具有参考性, 第三部分的分数由助教线下检查后确定

include/ASTBuilder/SyntaxTree.h

@@ -0,0 +1,333 @@
+#ifndef _SYSY_SYNTAX_TREE_H_
+#define _SYSY_SYNTAX_TREE_H_
+
+#include <vector>
+#include <memory>
+#include <string>
+
+#include "location.hh"
+
+namespace SyntaxTree
+{
+// Use unique postd::stringtype to reference stored objects
+template <typename T>
+using Ptr = std::shared_ptr<T>;
+
+// List of reference of type
+template <typename T>
+using PtrList = std::vector<Ptr<T>>;
+
+using Position = yy::location;
+
+// Enumerations
+enum class Type
+{
+    INT = 0,
+    VOID,
+    STRING,
+    BOOL,
+    FLOAT
+};
+
+enum class BinOp
+{
+    PLUS = 0,
+    MINUS,
+    MULTIPLY,
+    DIVIDE,
+    MODULO
+};
+
+enum class UnaryOp
+{
+    PLUS = 0,
+    MINUS
+};
+
+enum class UnaryCondOp
+{
+    NOT = 0
+};
+
+enum class BinaryCondOp
+{
+    LT = 0,
+    LTE,
+    GT,
+    GTE,
+    EQ,
+    NEQ,
+    LAND,
+    LOR
+};
+
+// Forward declaration
+struct Node;
+struct Assembly;
+struct GlobalDef;
+struct FuncDef;
+
+struct Expr;
+struct CondExpr;
+struct AddExpr;
+struct BinaryExpr;
+struct BinaryCondExpr;
+struct UnaryCondExpr;
+struct UnaryExpr;
+struct LVal;
+struct Literal;
+
+struct Stmt;
+struct VarDef;
+struct AssignStmt;
+struct FuncCallStmt;
+struct ReturnStmt;
+struct BlockStmt;
+struct EmptyStmt;
+struct ExprStmt;
+
+struct FuncParam;
+struct FuncFParamList;
+
+struct IfStmt;
+struct WhileStmt;
+struct BreakStmt;
+struct ContinueStmt;
+struct InitVal;
+
+class Visitor;
+
+// Virtual base of all kinds of syntax tree nodes.
+struct Node
+{
+    Position loc;
+    // Used in Visitor. Irrelevant to syntax tree generation.
+    virtual void accept(Visitor &visitor) = 0;
+};
+
+//node for initial value
+struct InitVal: Node{
+    bool isExp;
+    PtrList<InitVal> elementList;
+    //std::vector<Ptr<InitVal>> elementList;
+    Ptr<Expr> expr;
+    void accept(Visitor &visitor) final;
+};
+
+// Root node of an ordinary syntax tree.
+struct Assembly : Node
+{
+    PtrList<GlobalDef> global_defs;
+    void accept(Visitor &visitor) final;
+};
+
+// Virtual base of global definitions, function or variable one.
+struct GlobalDef : virtual Node
+{
+    void accept(Visitor &visitor) override = 0;
+};
+
+// Function definition.
+struct FuncDef : GlobalDef
+{
+    Type ret_type;
+    Ptr<FuncFParamList> param_list;
+    std::string name;
+    Ptr<BlockStmt> body;
+    void accept(Visitor &visitor) final;
+};
+
+// Virtual base for statements.
+struct Stmt : virtual Node
+{
+    void accept(Visitor &visitor) override = 0;
+};
+
+// Variable definition. Multiple of this would be both a statement and a global definition; however, itself only
+// represents a single variable definition.
+struct VarDef : Stmt, GlobalDef
+{
+    bool is_constant;
+    Type btype;
+    std::string name;
+    bool is_inited; // This is used to verify `{}`
+    PtrList<Expr> array_length; // empty for non-array variables
+    Ptr<InitVal> initializers;
+    void accept(Visitor &visitor) final;
+};
+
+// Assignment statement.
+struct AssignStmt : Stmt
+{
+    Ptr<LVal> target;
+    Ptr<Expr> value;
+    void accept(Visitor &visitor) final;
+};
+
+// Return statement.
+struct ReturnStmt : Stmt
+{
+    Ptr<Expr> ret;  // nullptr for void return
+    void accept(Visitor &visitor) final;
+};
+
+// BlockStmt statement.
+struct BlockStmt : Stmt
+{
+    PtrList<Stmt> body;
+    void accept(Visitor &visitor) final;
+};
+
+// Empty statement (aka a single ';').
+struct EmptyStmt : Stmt
+{
+    void accept(Visitor &visitor) final;
+};
+
+struct ExprStmt : Stmt
+{
+    Ptr<Expr> exp;
+    void accept(Visitor &visitor) final;
+};
+
+// Virtual base of expressions.
+struct Expr : Node
+{
+    void accept(Visitor &visitor) override = 0;
+};
+
+struct CondExpr : Expr
+{
+    void accept(Visitor &visitor) override = 0;
+};
+
+struct AddExpr : Expr
+{
+    void accept(Visitor &visitor) override = 0;
+};
+
+
+struct UnaryCondExpr : CondExpr{
+    UnaryCondOp op;
+    Ptr<Expr> rhs;
+    void accept(Visitor &visitor) final;
+};
+
+struct BinaryCondExpr : CondExpr{
+    BinaryCondOp op;
+    Ptr<Expr> lhs,rhs;
+    void accept(Visitor &visitor) final;
+};
+
+// Expression like `lhs op rhs`.
+struct BinaryExpr : AddExpr
+{
+    BinOp op;
+    Ptr<Expr> lhs, rhs;
+    void accept(Visitor &visitor) final;
+};
+
+// Expression like `op rhs`.
+struct UnaryExpr : AddExpr
+{
+    UnaryOp op;
+    Ptr<Expr> rhs;
+    void accept(Visitor &visitor) final;
+};
+
+// Expression like `ident` or `ident[exp]`.
+struct LVal : AddExpr
+{
+    std::string name;
+    PtrList<Expr> array_index; // nullptr if not indexed as array
+    void accept(Visitor &visitor) final;
+};
+
+// Expression constructed by a literal number.
+struct Literal : AddExpr
+{
+    Type literal_type;
+    int int_const;
+    // std::string str;
+    double float_const;
+    void accept(Visitor &visitor) final;
+};
+
+// Function call statement.
+struct FuncCallStmt : AddExpr
+{
+    std::string name;
+    PtrList<Expr> params;
+    void accept(Visitor &visitor) final;
+};
+
+struct FuncParam : Node
+{
+    std::string name;
+    Type param_type;
+    PtrList<Expr> array_index; // nullptr if not indexed as array
+    void accept(Visitor &visitor) final;
+};
+
+struct FuncFParamList : Node
+{
+    PtrList<FuncParam> params;
+    void accept(Visitor &visitor) final;
+};
+
+struct IfStmt : Stmt
+{
+    Ptr<Expr> cond_exp;
+    Ptr<Stmt> if_statement;
+    Ptr<Stmt> else_statement;
+    void accept(Visitor &visitor) final;
+};
+
+struct WhileStmt : Stmt
+{
+    Ptr<Expr> cond_exp;
+    Ptr<Stmt> statement;
+    void accept(Visitor &visitor) final;
+};
+
+struct BreakStmt : Stmt
+{
+    void accept(Visitor &visitor) final;
+};
+
+struct ContinueStmt : Stmt
+{
+    void accept(Visitor &visitor) final;
+};
+
+// Visitor base type
+class Visitor
+{
+public:
+    virtual void visit(Assembly &node) = 0;
+    virtual void visit(FuncDef &node) = 0;
+    virtual void visit(BinaryExpr &node) = 0;
+    virtual void visit(UnaryExpr &node) = 0;
+    virtual void visit(LVal &node) = 0;
+    virtual void visit(Literal &node) = 0;
+    virtual void visit(ReturnStmt &node) = 0;
+    virtual void visit(VarDef &node) = 0;
+    virtual void visit(AssignStmt &node) = 0;
+    virtual void visit(FuncCallStmt &node) = 0;
+    virtual void visit(BlockStmt &node) = 0;
+    virtual void visit(EmptyStmt &node) = 0;
+    virtual void visit(ExprStmt &node) = 0;
+    virtual void visit(FuncParam &node) = 0;
+    virtual void visit(FuncFParamList &node) = 0;
+    virtual void visit(IfStmt &node) = 0;
+    virtual void visit(WhileStmt &node) = 0;
+    virtual void visit(BreakStmt &node) = 0;
+    virtual void visit(ContinueStmt &node) = 0;
+    virtual void visit(UnaryCondExpr &node) = 0;
+    virtual void visit(BinaryCondExpr &node) = 0;
+    virtual void visit(InitVal &node) = 0;
+};
+} 
+// end namespace SyntaxTree
+
+#endif // _SYSY_SYNTAX_TREE_H_

include/ASTPrinter/SyntaxTreePrinter.h

@@ -0,0 +1,36 @@
+#ifndef _SYSY_SYNTAX_TREE_PRINTER_H_
+#define _SYSY_SYNTAX_TREE_PRINTER_H_
+
+#include "SyntaxTree.h"
+
+class SyntaxTreePrinter : public SyntaxTree::Visitor
+{
+public:
+    virtual void visit(SyntaxTree::Assembly &node) override;
+    virtual void visit(SyntaxTree::FuncDef &node) override;
+    virtual void visit(SyntaxTree::BinaryExpr &node) override;
+    virtual void visit(SyntaxTree::UnaryExpr &node) override;
+    virtual void visit(SyntaxTree::LVal &node) override;
+    virtual void visit(SyntaxTree::Literal &node) override;
+    virtual void visit(SyntaxTree::ReturnStmt &node) override;
+    virtual void visit(SyntaxTree::VarDef &node) override;
+    virtual void visit(SyntaxTree::AssignStmt &node) override;
+    virtual void visit(SyntaxTree::FuncCallStmt &node) override;
+    virtual void visit(SyntaxTree::BlockStmt &node) override;
+    virtual void visit(SyntaxTree::EmptyStmt &node) override;
+    virtual void visit(SyntaxTree::ExprStmt &node) override;
+    virtual void visit(SyntaxTree::FuncParam &node) override;
+    virtual void visit(SyntaxTree::FuncFParamList &node) override;
+    virtual void visit(SyntaxTree::BinaryCondExpr &node) override;
+    virtual void visit(SyntaxTree::UnaryCondExpr &node) override;
+    virtual void visit(SyntaxTree::IfStmt &node) override;
+    virtual void visit(SyntaxTree::WhileStmt &node) override;
+    virtual void visit(SyntaxTree::BreakStmt &node) override;
+    virtual void visit(SyntaxTree::ContinueStmt &node) override;
+    virtual void visit(SyntaxTree::InitVal &node) override;
+    void print_indent();
+private:
+    int indent = 0;
+};
+
+#endif  // _SYSY_SYNTAX_TREE_PRINTER_H_

include/ErrorReporter/ErrorReporter.h

@@ -0,0 +1,27 @@
+
+#ifndef _SYSY_ERROR_REPORTER_H_
+#define _SYSY_ERROR_REPORTER_H_
+
+#include <iostream>
+#include <deque>
+#include <unordered_map>
+#include <vector>
+#include "SyntaxTree.h"
+
+class ErrorReporter
+{
+public:
+    using Position = SyntaxTree::Position;
+    explicit ErrorReporter(std::ostream &error_stream);
+
+    void error(Position pos, const std::string &msg);
+    void warn(Position pos, const std::string &msg);
+
+protected:
+    virtual void report(Position pos, const std::string &msg, const std::string &prefix);
+
+private:
+    std::ostream &err;
+};
+
+#endif  // _SYSY_ERROR_REPORTER_H_

include/Grammar/FlexLexer.h

@@ -0,0 +1,225 @@
+// -*-C++-*-
+// FlexLexer.h -- define interfaces for lexical analyzer classes generated
+// by flex
+
+// Copyright (c) 1993 The Regents of the University of California.
+// All rights reserved.
+//
+// This code is derived from software contributed to Berkeley by
+// Kent Williams and Tom Epperly.
+//
+//  Redistribution and use in source and binary forms, with or without
+//  modification, are permitted provided that the following conditions
+//  are met:
+
+//  1. Redistributions of source code must retain the above copyright
+//  notice, this list of conditions and the following disclaimer.
+//  2. Redistributions in binary form must reproduce the above copyright
+//  notice, this list of conditions and the following disclaimer in the
+//  documentation and/or other materials provided with the distribution.
+
+//  Neither the name of the University nor the names of its contributors
+//  may be used to endorse or promote products derived from this software
+//  without specific prior written permission.
+
+//  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+//  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+//  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+//  PURPOSE.
+
+// This file defines FlexLexer, an abstract class which specifies the
+// external interface provided to flex C++ lexer objects, and yyFlexLexer,
+// which defines a particular lexer class.
+//
+// If you want to create multiple lexer classes, you use the -P flag
+// to rename each yyFlexLexer to some other xxFlexLexer.  You then
+// include <FlexLexer.h> in your other sources once per lexer class:
+//
+//	#undef yyFlexLexer
+//	#define yyFlexLexer xxFlexLexer
+//	#include <FlexLexer.h>
+//
+//	#undef yyFlexLexer
+//	#define yyFlexLexer zzFlexLexer
+//	#include <FlexLexer.h>
+//	...
+
+#ifndef __FLEX_LEXER_H
+// Never included before - need to define base class.
+#define __FLEX_LEXER_H
+
+#include <iostream>
+#  ifndef FLEX_STD
+#    define FLEX_STD std::
+#  endif
+
+extern "C++" {
+
+struct yy_buffer_state;
+typedef int yy_state_type;
+
+class FlexLexer {
+public:
+	virtual ~FlexLexer()	{ }
+
+	const char* YYText() const	{ return yytext; }
+	int YYLeng()	const	{ return yyleng; }
+
+	virtual void
+		yy_switch_to_buffer( struct yy_buffer_state* new_buffer ) = 0;
+	virtual struct yy_buffer_state*
+		yy_create_buffer( FLEX_STD istream* s, int size ) = 0;
+	virtual struct yy_buffer_state*
+		yy_create_buffer( FLEX_STD istream& s, int size ) = 0;
+	virtual void yy_delete_buffer( struct yy_buffer_state* b ) = 0;
+	virtual void yyrestart( FLEX_STD istream* s ) = 0;	
+	virtual void yyrestart( FLEX_STD istream& s ) = 0;
+
+	virtual int yylex() = 0;
+
+	// Call yylex with new input/output sources.
+	int yylex( FLEX_STD istream& new_in, FLEX_STD ostream& new_out )
+	{
+		switch_streams( new_in, new_out );
+		return yylex();
+	}
+	
+	int yylex( FLEX_STD istream* new_in, FLEX_STD ostream* new_out = 0)
+	{
+		switch_streams( new_in, new_out );
+		return yylex();
+	}
+
+	// Switch to new input/output streams.  A nil stream pointer
+	// indicates "keep the current one".
+	virtual void switch_streams( FLEX_STD istream* new_in,
+					FLEX_STD ostream* new_out ) = 0;
+	virtual void switch_streams( FLEX_STD istream& new_in,
+					FLEX_STD ostream& new_out ) = 0;
+
+	int lineno() const		{ return yylineno; }
+
+	int debug() const		{ return yy_flex_debug; }
+	void set_debug( int flag )	{ yy_flex_debug = flag; }
+
+protected:
+	char* yytext;
+	int yyleng;
+	int yylineno;		// only maintained if you use %option yylineno
+	int yy_flex_debug;	// only has effect with -d or "%option debug"
+};
+
+}
+#endif // FLEXLEXER_H
+
+#if defined(yyFlexLexer) || ! defined(yyFlexLexerOnce)
+// Either this is the first time through (yyFlexLexerOnce not defined),
+// or this is a repeated include to define a different flavor of
+// yyFlexLexer, as discussed in the flex manual.
+#define yyFlexLexerOnce
+
+extern "C++" {
+
+class yyFlexLexer : public FlexLexer {
+public:
+	// arg_yyin and arg_yyout default to the cin and cout, but we
+	// only make that assignment when initializing in yylex().
+	yyFlexLexer( FLEX_STD istream& arg_yyin, FLEX_STD ostream& arg_yyout );
+	yyFlexLexer( FLEX_STD istream* arg_yyin = 0, FLEX_STD ostream* arg_yyout = 0 );
+private:
+	void ctor_common();
+
+public:
+
+	virtual ~yyFlexLexer();
+
+	void yy_switch_to_buffer( struct yy_buffer_state* new_buffer );
+	struct yy_buffer_state* yy_create_buffer( FLEX_STD istream* s, int size );	
+	struct yy_buffer_state* yy_create_buffer( FLEX_STD istream& s, int size );
+	void yy_delete_buffer( struct yy_buffer_state* b );
+	void yyrestart( FLEX_STD istream* s );
+	void yyrestart( FLEX_STD istream& s );
+
+	void yypush_buffer_state( struct yy_buffer_state* new_buffer );
+	void yypop_buffer_state();
+
+	virtual int yylex();
+	virtual void switch_streams( FLEX_STD istream& new_in, FLEX_STD ostream& new_out );
+	virtual void switch_streams( FLEX_STD istream* new_in = 0, FLEX_STD ostream* new_out = 0 );
+	virtual int yywrap();
+
+protected:
+	virtual int LexerInput( char* buf, int max_size );
+	virtual void LexerOutput( const char* buf, int size );
+	virtual void LexerError( const char* msg );
+
+	void yyunput( int c, char* buf_ptr );
+	int yyinput();
+
+	void yy_load_buffer_state();
+	void yy_init_buffer( struct yy_buffer_state* b, FLEX_STD istream& s );
+	void yy_flush_buffer( struct yy_buffer_state* b );
+
+	int yy_start_stack_ptr;
+	int yy_start_stack_depth;
+	int* yy_start_stack;
+
+	void yy_push_state( int new_state );
+	void yy_pop_state();
+	int yy_top_state();
+
+	yy_state_type yy_get_previous_state();
+	yy_state_type yy_try_NUL_trans( yy_state_type current_state );
+	int yy_get_next_buffer();
+
+	FLEX_STD istream yyin;	// input source for default LexerInput
+	FLEX_STD ostream yyout;	// output sink for default LexerOutput
+
+	// yy_hold_char holds the character lost when yytext is formed.
+	char yy_hold_char;
+
+	// Number of characters read into yy_ch_buf.
+	int yy_n_chars;
+
+	// Points to current character in buffer.
+	char* yy_c_buf_p;
+
+	int yy_init;		// whether we need to initialize
+	int yy_start;		// start state number
+
+	// Flag which is used to allow yywrap()'s to do buffer switches
+	// instead of setting up a fresh yyin.  A bit of a hack ...
+	int yy_did_buffer_switch_on_eof;
+
+
+	size_t yy_buffer_stack_top; /**< index of top of stack. */
+	size_t yy_buffer_stack_max; /**< capacity of stack. */
+	struct yy_buffer_state ** yy_buffer_stack; /**< Stack as an array. */
+	void yyensure_buffer_stack(void);
+
+	// The following are not always needed, but may be depending
+	// on use of certain flex features (like REJECT or yymore()).
+
+	yy_state_type yy_last_accepting_state;
+	char* yy_last_accepting_cpos;
+
+	yy_state_type* yy_state_buf;
+	yy_state_type* yy_state_ptr;
+
+	char* yy_full_match;
+	int* yy_full_state;
+	int yy_full_lp;
+
+	int yy_lp;
+	int yy_looking_for_trail_begin;
+
+	int yy_more_flag;
+	int yy_more_len;
+	int yy_more_offset;
+	int yy_prev_more_offset;
+};
+
+}
+
+#endif // yyFlexLexer || ! yyFlexLexerOnce
+

include/Grammar/SysYDriver.h

@@ -0,0 +1,50 @@
+#ifndef _SYSY_DRIVER_H_
+#define _SYSY_DRIVER_H_
+
+#include <fstream>
+#include <string>
+#include <map>
+
+// Generated by bison:
+#include "SysYParser.h"
+
+#include "SysYFlexLexer.h"
+
+// Conducting the whole scanning and parsing of SysY.
+class SysYDriver
+{
+public:
+    SysYDriver();
+    virtual ~SysYDriver();
+    
+    std::map<std::string, int> variables;
+    
+    int result;
+    
+    // SysY lexer
+    SysYFlexLexer lexer;
+
+    std::ifstream instream;
+
+    // Handling the SysY scanner.
+    void scan_begin();
+    void scan_end();
+    bool trace_scanning;
+    
+    // Run the parser on file F.
+    // Return 0 on success.
+    SyntaxTree::Node* parse(const std::string& f);
+    // The name of the file being parsed.
+    // Used later to pass the file name to the location tracker.
+    std::string file;
+    // Whether parser traces should be generated.
+    bool trace_parsing;
+
+    // Error handling.
+    void error(const yy::location& l, const std::string& m);
+    void error(const std::string& m);
+
+    SyntaxTree::Node* root = nullptr;
+};
+
+#endif // _SYSY_DRIVER_H_

include/Grammar/SysYFlexLexer.h

@@ -0,0 +1,37 @@
+#ifndef _SYSY_FLEX_LEXER_H_
+#define _SYSY_FLEX_LEXER_H_
+
+#ifndef YY_DECL
+#define YY_DECL                                                         \
+    yy::SysYParser::symbol_type SysYFlexLexer::yylex(SysYDriver& driver)
+#endif
+
+// We need this for yyFlexLexer. If we don't #undef yyFlexLexer, the
+// preprocessor chokes on the line `#define yyFlexLexer yyFlexLexer`
+// in `FlexLexer.h`:
+#undef yyFlexLexer
+#include <FlexLexer.h>
+
+// We need this for the yy::SysYParser::symbol_type:
+#include "SysYParser.h"
+
+// We need this for the yy::location type:
+#include "location.hh"
+
+class SysYFlexLexer : public yyFlexLexer {
+public:
+    // Use the superclass's constructor:
+    using yyFlexLexer::yyFlexLexer;
+
+    // Provide the interface to `yylex`; `flex` will emit the
+    // definition into `SysYScanner.cpp`:
+    yy::SysYParser::symbol_type yylex(SysYDriver& driver);
+
+    // This seems like a reasonable place to put the location object
+    // rather than it being static (in the sense of having internal
+    // linkage at translation unit scope, not in the sense of being a
+    // class variable):
+    yy::location loc;
+};
+
+#endif // _SYSY_FLEX_LEXER_H_

include/Grammar/location.hh

@@ -0,0 +1,304 @@
+// A Bison parser, made by GNU Bison 3.7.6.
+
+// Locations for Bison parsers in C++
+
+// Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+// As a special exception, you may create a larger work that contains
+// part or all of the Bison parser skeleton and distribute that work
+// under terms of your choice, so long as that work isn't itself a
+// parser generator using the skeleton or a modified version thereof
+// as a parser skeleton.  Alternatively, if you modify or redistribute
+// the parser skeleton itself, you may (at your option) remove this
+// special exception, which will cause the skeleton and the resulting
+// Bison output files to be licensed under the GNU General Public
+// License without this special exception.
+
+// This special exception was added by the Free Software Foundation in
+// version 2.2 of Bison.
+
+/**
+ ** \file /home/hzq/SysYF_IR_Lab/2021_sysycompiler_ir_lab/build/location.hh
+ ** Define the yy::location class.
+ */
+
+#ifndef YY_YY_HOME_HZQ_SYSYF_IR_LAB_2021_SYSYCOMPILER_IR_LAB_BUILD_LOCATION_HH_INCLUDED
+# define YY_YY_HOME_HZQ_SYSYF_IR_LAB_2021_SYSYCOMPILER_IR_LAB_BUILD_LOCATION_HH_INCLUDED
+
+# include <iostream>
+# include <string>
+
+# ifndef YY_NULLPTR
+#  if defined __cplusplus
+#   if 201103L <= __cplusplus
+#    define YY_NULLPTR nullptr
+#   else
+#    define YY_NULLPTR 0
+#   endif
+#  else
+#   define YY_NULLPTR ((void*)0)
+#  endif
+# endif
+
+namespace yy {
+#line 58 "/home/hzq/SysYF_IR_Lab/2021_sysycompiler_ir_lab/build/location.hh"
+
+  /// A point in a source file.
+  class position
+  {
+  public:
+    /// Type for file name.
+    typedef const std::string filename_type;
+    /// Type for line and column numbers.
+    typedef int counter_type;
+
+    /// Construct a position.
+    explicit position (filename_type* f = YY_NULLPTR,
+                       counter_type l = 1,
+                       counter_type c = 1)
+      : filename (f)
+      , line (l)
+      , column (c)
+    {}
+
+
+    /// Initialization.
+    void initialize (filename_type* fn = YY_NULLPTR,
+                     counter_type l = 1,
+                     counter_type c = 1)
+    {
+      filename = fn;
+      line = l;
+      column = c;
+    }
+
+    /** \name Line and Column related manipulators
+     ** \{ */
+    /// (line related) Advance to the COUNT next lines.
+    void lines (counter_type count = 1)
+    {
+      if (count)
+        {
+          column = 1;
+          line = add_ (line, count, 1);
+        }
+    }
+
+    /// (column related) Advance to the COUNT next columns.
+    void columns (counter_type count = 1)
+    {
+      column = add_ (column, count, 1);
+    }
+    /** \} */
+
+    /// File name to which this position refers.
+    filename_type* filename;
+    /// Current line number.
+    counter_type line;
+    /// Current column number.
+    counter_type column;
+
+  private:
+    /// Compute max (min, lhs+rhs).
+    static counter_type add_ (counter_type lhs, counter_type rhs, counter_type min)
+    {
+      return lhs + rhs < min ? min : lhs + rhs;
+    }
+  };
+
+  /// Add \a width columns, in place.
+  inline position&
+  operator+= (position& res, position::counter_type width)
+  {
+    res.columns (width);
+    return res;
+  }
+
+  /// Add \a width columns.
+  inline position
+  operator+ (position res, position::counter_type width)
+  {
+    return res += width;
+  }
+
+  /// Subtract \a width columns, in place.
+  inline position&
+  operator-= (position& res, position::counter_type width)
+  {
+    return res += -width;
+  }
+
+  /// Subtract \a width columns.
+  inline position
+  operator- (position res, position::counter_type width)
+  {
+    return res -= width;
+  }
+
+  /** \brief Intercept output stream redirection.
+   ** \param ostr the destination output stream
+   ** \param pos a reference to the position to redirect
+   */
+  template <typename YYChar>
+  std::basic_ostream<YYChar>&
+  operator<< (std::basic_ostream<YYChar>& ostr, const position& pos)
+  {
+    if (pos.filename)
+      ostr << *pos.filename << ':';
+    return ostr << pos.line << '.' << pos.column;
+  }
+
+  /// Two points in a source file.
+  class location
+  {
+  public:
+    /// Type for file name.
+    typedef position::filename_type filename_type;
+    /// Type for line and column numbers.
+    typedef position::counter_type counter_type;
+
+    /// Construct a location from \a b to \a e.
+    location (const position& b, const position& e)
+      : begin (b)
+      , end (e)
+    {}
+
+    /// Construct a 0-width location in \a p.
+    explicit location (const position& p = position ())
+      : begin (p)
+      , end (p)
+    {}
+
+    /// Construct a 0-width location in \a f, \a l, \a c.
+    explicit location (filename_type* f,
+                       counter_type l = 1,
+                       counter_type c = 1)
+      : begin (f, l, c)
+      , end (f, l, c)
+    {}
+
+
+    /// Initialization.
+    void initialize (filename_type* f = YY_NULLPTR,
+                     counter_type l = 1,
+                     counter_type c = 1)
+    {
+      begin.initialize (f, l, c);
+      end = begin;
+    }
+
+    /** \name Line and Column related manipulators
+     ** \{ */
+  public:
+    /// Reset initial location to final location.
+    void step ()
+    {
+      begin = end;
+    }
+
+    /// Extend the current location to the COUNT next columns.
+    void columns (counter_type count = 1)
+    {
+      end += count;
+    }
+
+    /// Extend the current location to the COUNT next lines.
+    void lines (counter_type count = 1)
+    {
+      end.lines (count);
+    }
+    /** \} */
+
+
+  public:
+    /// Beginning of the located region.
+    position begin;
+    /// End of the located region.
+    position end;
+  };
+
+  /// Join two locations, in place.
+  inline location&
+  operator+= (location& res, const location& end)
+  {
+    res.end = end.end;
+    return res;
+  }
+
+  /// Join two locations.
+  inline location
+  operator+ (location res, const location& end)
+  {
+    return res += end;
+  }
+
+  /// Add \a width columns to the end position, in place.
+  inline location&
+  operator+= (location& res, location::counter_type width)
+  {
+    res.columns (width);
+    return res;
+  }
+
+  /// Add \a width columns to the end position.
+  inline location
+  operator+ (location res, location::counter_type width)
+  {
+    return res += width;
+  }
+
+  /// Subtract \a width columns to the end position, in place.
+  inline location&
+  operator-= (location& res, location::counter_type width)
+  {
+    return res += -width;
+  }
+
+  /// Subtract \a width columns to the end position.
+  inline location
+  operator- (location res, location::counter_type width)
+  {
+    return res -= width;
+  }
+
+  /** \brief Intercept output stream redirection.
+   ** \param ostr the destination output stream
+   ** \param loc a reference to the location to redirect
+   **
+   ** Avoid duplicate information.
+   */
+  template <typename YYChar>
+  std::basic_ostream<YYChar>&
+  operator<< (std::basic_ostream<YYChar>& ostr, const location& loc)
+  {
+    location::counter_type end_col
+      = 0 < loc.end.column ? loc.end.column - 1 : 0;
+    ostr << loc.begin;
+    if (loc.end.filename
+        && (!loc.begin.filename
+            || *loc.begin.filename != *loc.end.filename))
+      ostr << '-' << loc.end.filename << ':' << loc.end.line << '.' << end_col;
+    else if (loc.begin.line < loc.end.line)
+      ostr << '-' << loc.end.line << '.' << end_col;
+    else if (loc.begin.column < end_col)
+      ostr << '-' << end_col;
+    return ostr;
+  }
+
+} // yy
+#line 303 "/home/hzq/SysYF_IR_Lab/2021_sysycompiler_ir_lab/build/location.hh"
+
+#endif // !YY_YY_HOME_HZQ_SYSYF_IR_LAB_2021_SYSYCOMPILER_IR_LAB_BUILD_LOCATION_HH_INCLUDED

include/Grammar/position.hh

@@ -0,0 +1,11 @@
+// A Bison parser, made by GNU Bison 3.7.6.
+
+// Starting with Bison 3.2, this file is useless: the structure it
+// used to define is now defined in "location.hh".
+//
+// To get rid of this file:
+// 1. add '%require "3.2"' (or newer) to your grammar file
+// 2. remove references to this file from your build system
+// 3. if you used to include it, include "location.hh" instead.
+
+#include "location.hh"

include/Grammar/stack.hh

@@ -0,0 +1,8 @@
+// A Bison parser, made by GNU Bison 3.7.6.
+
+// Starting with Bison 3.2, this file is useless: the structure it
+// used to define is now defined with the parser itself.
+//
+// To get rid of this file:
+// 1. add '%require "3.2"' (or newer) to your grammar file
+// 2. remove references to this file from your build system.

include/SysYBuilder/SysYBuilder.hpp

@@ -0,0 +1,217 @@
+#ifndef _SYSY_IR_BUILDER_HPP_
+#define _SYSY_IR_BUILDER_HPP_
+#include "BasicBlock.h"
+#include "Constant.h"
+#include "Function.h"
+#include "IRBuilder.h"
+#include "Module.h"
+#include "Type.h"
+#include <map>
+#include "SyntaxTree.h"
+
+
+class Scope {
+public:
+    // enter a new scope
+    void enter() {
+        name2var.push_back({});
+        name2func.push_back({});
+    }
+
+    // exit a scope
+    void exit() {
+        name2var.pop_back();
+        name2func.pop_back();
+    }
+
+    bool in_global() {
+        return name2var.size() == 1;
+    }
+
+    // push a name to scope
+    // return true if successful
+    // return false if this name already exits
+    // but func name could be same with variable name
+    bool push(std::string name, Value *val) {
+        bool result;
+        if (dynamic_cast<Function *>(val)){
+            result = (name2func[name2func.size() - 1].insert({name, val})).second;
+        }
+        else{
+            result = (name2var[name2var.size() - 1].insert({name, val})).second;
+        }
+        return result;
+    }
+
+    Value* find(std::string name, bool isfunc) {
+        if (isfunc){
+            for (auto s = name2func.rbegin(); s!= name2func.rend();s++) {
+                auto iter = s->find(name);
+                if (iter != s->end()) {
+                    return iter->second;
+                }
+            }
+        }
+        else{
+            for (auto s = name2var.rbegin(); s!= name2var.rend();s++) {
+                auto iter = s->find(name);
+                if (iter != s->end()) {
+                    return iter->second;
+                }
+            }
+        }
+        return nullptr;
+    }
+
+
+private:
+    std::vector<std::map<std::string, Value *>> name2var;
+    std::vector<std::map<std::string, Value *>> name2func;
+};
+
+class SysYBuilder: public SyntaxTree::Visitor
+{
+private:
+    virtual void visit(SyntaxTree::InitVal &) override final;
+    virtual void visit(SyntaxTree::Assembly &) override final;
+    virtual void visit(SyntaxTree::FuncDef &) override final;
+    virtual void visit(SyntaxTree::VarDef &) override final;
+    virtual void visit(SyntaxTree::AssignStmt &) override final;
+    virtual void visit(SyntaxTree::ReturnStmt &) override final;
+    virtual void visit(SyntaxTree::BlockStmt &) override final;
+    virtual void visit(SyntaxTree::EmptyStmt &) override final;
+    virtual void visit(SyntaxTree::ExprStmt &) override final;
+    virtual void visit(SyntaxTree::UnaryCondExpr &) override final;
+    virtual void visit(SyntaxTree::BinaryCondExpr &) override final;
+    virtual void visit(SyntaxTree::BinaryExpr &) override final;
+    virtual void visit(SyntaxTree::UnaryExpr &) override final;
+    virtual void visit(SyntaxTree::LVal &) override final;
+    virtual void visit(SyntaxTree::Literal &) override final;
+    virtual void visit(SyntaxTree::FuncCallStmt &) override final;
+    virtual void visit(SyntaxTree::FuncParam &) override final;
+    virtual void visit(SyntaxTree::FuncFParamList &) override final;
+    virtual void visit(SyntaxTree::IfStmt &) override final;
+    virtual void visit(SyntaxTree::WhileStmt &) override final;
+    virtual void visit(SyntaxTree::BreakStmt &) override final;
+    virtual void visit(SyntaxTree::ContinueStmt &) override final;
+
+    IRBuilder *builder;
+    Scope scope;
+    std::unique_ptr<Module> module;
+public:
+    SysYBuilder(){
+        module = std::unique_ptr<Module>(new Module("SysY code"));
+        builder = new IRBuilder(nullptr, module.get());
+        auto TyVoid = Type::get_void_type(module.get());
+        auto TyInt32 = Type::get_int32_type(module.get());
+        auto TyInt32Ptr = Type::get_int32_ptr_type(module.get());
+        auto TyFloat = Type::get_float_type(module.get());
+        auto TyFloatPtr = Type::get_float_ptr_type(module.get());
+
+        auto input_type = FunctionType::get(TyInt32, {});
+        auto get_int =
+            Function::create(
+                    input_type,
+                    "get_int",
+                    module.get());
+
+        input_type = FunctionType::get(TyFloat, {});
+        auto get_float =
+            Function::create(
+                    input_type,
+                    "get_float",
+                    module.get());
+
+        input_type = FunctionType::get(TyInt32, {});
+        auto get_char =
+            Function::create(
+                    input_type,
+                    "get_char",
+                    module.get());
+
+        std::vector<Type *> input_params;
+        std::vector<Type *>().swap(input_params);
+        input_params.push_back(TyInt32Ptr);
+        input_type = FunctionType::get(TyInt32, input_params);
+        auto get_int_array =
+            Function::create(
+                    input_type,
+                    "get_int_array",
+                    module.get());
+
+        std::vector<Type *>().swap(input_params);
+        input_params.push_back(TyFloatPtr);
+        input_type = FunctionType::get(TyInt32, input_params);
+        auto get_float_array =
+            Function::create(
+                    input_type,
+                    "get_float_array",
+                    module.get());
+
+        std::vector<Type *> output_params;
+        std::vector<Type *>().swap(output_params);
+        output_params.push_back(TyInt32);
+        auto output_type = FunctionType::get(TyVoid, output_params);
+        auto put_int =
+            Function::create(
+                    output_type,
+                    "put_int",
+                    module.get());
+
+        std::vector<Type *>().swap(output_params);
+        output_params.push_back(TyFloat);
+        output_type = FunctionType::get(TyVoid, output_params);
+        auto put_float =
+            Function::create(
+                    output_type,
+                    "put_float",
+                    module.get());
+
+        std::vector<Type *>().swap(output_params);
+        output_params.push_back(TyInt32);
+        output_type = FunctionType::get(TyVoid, output_params);
+        auto put_char =
+            Function::create(
+                    output_type,
+                    "put_char",
+                    module.get());
+
+        std::vector<Type *>().swap(output_params);
+        output_params.push_back(TyInt32);
+        output_params.push_back(TyInt32Ptr);
+        output_type = FunctionType::get(TyVoid, output_params);
+        auto put_int_array =
+            Function::create(
+                    output_type,
+                    "put_int_array",
+                    module.get());
+
+        std::vector<Type *>().swap(output_params);
+        output_params.push_back(TyInt32);
+        output_params.push_back(TyFloatPtr);
+        output_type = FunctionType::get(TyVoid, output_params);
+        auto put_float_array =
+            Function::create(
+                    output_type,
+                    "put_float_array",
+                    module.get());
+
+        scope.enter();
+        scope.push("getint", get_int);
+        scope.push("getfloat", get_float);
+        scope.push("getch", get_char);
+        scope.push("getarray", get_int_array);
+        scope.push("get_float_array", get_float_array);
+        scope.push("putint", put_int);
+        scope.push("putfloat", put_float);
+        scope.push("putch", put_char);
+        scope.push("putarray", put_int_array);
+        scope.push("putfloatarray", put_float_array);
+    }
+    std::unique_ptr<Module> getModule() {
+        return std::move(module);
+    }
+};
+
+
+#endif // _SYSY_IR_BUILDER_HPP_

include/SysYIR/BasicBlock.h

@@ -0,0 +1,77 @@
+#ifndef _SYSY_BASICBLOCK_H_
+#define _SYSY_BASICBLOCK_H_
+
+#include "Value.h"
+#include "Instruction.h"
+#include "Module.h"
+#include "Function.h"
+
+#include <list>
+#include <set>
+#include <string>
+
+class Function;
+class Instruction;
+class Module;
+
+class BasicBlock : public Value
+{
+public:
+    static BasicBlock *create(Module *m, const std::string &name ,
+                            Function *parent ) {
+        auto prefix = name.empty() ? "" : "label_";
+        return new BasicBlock(m, prefix + name, parent);
+    }
+
+    // return parent, or null if none.
+    Function *get_parent() { return parent_; }
+    
+    Module *get_module();
+
+    /****************api about cfg****************/
+
+    std::list<BasicBlock *> &get_pre_basic_blocks() { return pre_bbs_; }
+    std::list<BasicBlock *> &get_succ_basic_blocks() { return succ_bbs_; }
+    void add_pre_basic_block(BasicBlock *bb) { pre_bbs_.push_back(bb); }
+    void add_succ_basic_block(BasicBlock *bb) { succ_bbs_.push_back(bb); }
+
+    void remove_pre_basic_block(BasicBlock *bb) { pre_bbs_.remove(bb); }
+    void remove_succ_basic_block(BasicBlock *bb) { succ_bbs_.remove(bb); }
+
+    /****************api about cfg****************/
+
+    /// Returns the terminator instruction if the block is well formed or null
+    /// if the block is not well formed.
+    const Instruction *get_terminator() const;
+    Instruction *get_terminator() {
+        return const_cast<Instruction *>(
+            static_cast<const BasicBlock *>(this)->get_terminator());
+    }
+    
+    void add_instruction(Instruction *instr);
+    void add_instruction(std::list<Instruction *>::iterator instr_pos, Instruction *instr);
+    void add_instr_begin(Instruction *instr);
+
+    std::list<Instruction *>::iterator find_instruction(Instruction *instr);
+
+    void delete_instr(Instruction *instr);
+
+    bool empty() { return instr_list_.empty(); }
+
+    int get_num_of_instr() { return instr_list_.size(); }
+    std::list<Instruction *> &get_instructions() { return instr_list_; }
+    
+    void erase_from_parent();
+    
+    virtual std::string print() override;
+
+private:
+    explicit BasicBlock(Module *m, const std::string &name ,
+                        Function *parent );
+    std::list<BasicBlock *> pre_bbs_;
+    std::list<BasicBlock *> succ_bbs_;
+    std::list<Instruction *> instr_list_;
+    Function *parent_;
+};
+
+#endif // _SYSY_BASICBLOCK_H_

include/SysYIR/Constant.h

@@ -0,0 +1,75 @@
+#ifndef _SYSY_CONSTANT_H_
+#define _SYSY_CONSTANT_H_
+#include "User.h"
+#include "Value.h"
+#include "Type.h"
+
+class Constant : public User
+{
+private:
+    // int value;
+public:
+    Constant(Type *ty, const std::string &name = "", unsigned num_ops = 0)
+        : User(ty, name, num_ops) {}
+    ~Constant() = default;
+};
+
+class ConstantInt : public Constant
+{
+private:
+    int value_;
+    ConstantInt(Type* ty,int val) 
+        : Constant(ty,"",0),value_(val) {}
+public:
+    
+    static int get_value(ConstantInt *const_val) { return const_val->value_; }
+    int get_value() { return value_; }
+    static ConstantInt *get(int val, Module *m);
+    static ConstantInt *get(bool val, Module *m);
+    virtual std::string print() override;
+};
+
+class ConstantFloat : public Constant
+{
+private:
+    float value_;
+    ConstantFloat(Type* ty,float val) 
+        : Constant(ty,"",0),value_(val) {}
+public:
+    
+    static float get_value(ConstantFloat *const_val) { return const_val->value_; }
+    float get_value() { return value_; }
+    static ConstantFloat *get(float val, Module *m);
+    virtual std::string print() override;
+};
+
+class ConstantArray : public Constant
+{
+private:
+    std::vector<Constant*> const_array;
+
+    ConstantArray(ArrayType *ty, const std::vector<Constant*> &val);
+public:
+    
+    ~ConstantArray()=default;
+
+    Constant* get_element_value(int index);
+
+    unsigned get_size_of_array() { return const_array.size(); } 
+
+    static ConstantArray *get(ArrayType *ty, const std::vector<Constant*> &val);
+
+    virtual std::string print() override;
+};
+
+class ConstantZero : public Constant 
+{
+private:
+    ConstantZero(Type *ty)
+        : Constant(ty,"",0) {}
+public:
+    static ConstantZero *get(Type *ty, Module *m);
+    virtual std::string print() override;
+};
+
+#endif //_SYSY_CONSTANT_H_

include/SysYIR/Function.h

@@ -0,0 +1,101 @@
+#ifndef _SYSY_FUNCTION_H_
+#define _SYSY_FUNCTION_H_
+
+#include <iterator>
+#include <list>
+#include <cstddef>
+#include <map>
+#ifdef DEBUG
+#include <cassert>
+#endif
+#include <set>
+
+#include "User.h"
+#include "Module.h"
+#include "BasicBlock.h"
+#include "Type.h"
+
+class Module;
+class Argument;
+class BasicBlock;
+class Type;
+class FunctionType;
+
+class Function : public Value
+{
+public:
+    Function(FunctionType *ty, const std::string &name, Module *parent);
+    ~Function();
+    static Function *create(FunctionType *ty, const std::string &name, Module *parent);
+
+    FunctionType *get_function_type() const;
+
+    Type *get_return_type() const;
+
+    void add_basic_block(BasicBlock *bb);
+
+    unsigned get_num_of_args() const;
+    unsigned get_num_basic_blocks() const;
+    
+    Module *get_parent() const;
+
+    std::list<Argument *>::iterator arg_begin() { return arguments_.begin(); }
+    std::list<Argument *>::iterator arg_end() { return arguments_.end(); }
+    
+    void remove(BasicBlock* bb);
+    BasicBlock *get_entry_block() { return *basic_blocks_.begin(); }
+
+    std::list<BasicBlock *> &get_basic_blocks() { return basic_blocks_; }
+    std::list<Argument *> &get_args() { return arguments_; }
+    std::vector<std::set<Value *>> &get_vreg_set(){ return vreg_set_;}
+    
+    bool is_declaration() { return basic_blocks_.empty(); }
+    void set_unused_reg_num(std::set<int>& set){unused_reg_num_ = set;}
+    std::set<int>& get_unused_reg_num(){return unused_reg_num_;}
+
+    void set_instr_name();
+    std::string print();
+
+private:
+    void build_args();
+
+private:
+    std::list<BasicBlock *> basic_blocks_;    // basic blocks
+    std::list<Argument *> arguments_;         // arguments
+    std::vector<std::set<Value *>> vreg_set_;
+    Module *parent_;
+    std::set<int> unused_reg_num_;
+    unsigned seq_cnt_;
+    // unsigned num_args_;
+    // We don't need this, all value inside function should be unnamed
+    // std::map<std::string, Value*> sym_table_;   // Symbol table of args/instructions
+};
+
+// Argument of Function, does not contain actual value
+class Argument : public Value
+{
+public:
+    /// Argument constructor.
+    explicit Argument(Type *ty, const std::string &name = "", Function *f = nullptr,
+                    unsigned arg_no = 0)
+        : Value(ty, name), parent_(f), arg_no_(arg_no) {}
+    ~Argument() {}
+
+    inline const Function *get_parent() const { return parent_; }
+    inline       Function *get_parent()       { return parent_; }
+
+    /// For example in "void foo(int a, float b)" a is 0 and b is 1.
+    unsigned get_arg_no() const {
+#ifdef DEBUG
+        assert(parent_ && "can't get number of unparented arg");
+#endif
+        return arg_no_;
+    }
+
+    virtual std::string print() override ;
+private:
+    Function *parent_;
+    unsigned arg_no_;  // argument No.
+};
+
+#endif // _SYSY_FUNCTION_H_

include/SysYIR/GlobalVariable.h

@@ -0,0 +1,22 @@
+#ifndef _SYSY_GLOBALVARIABLE_H_
+#define _SYSY_GLOBALVARIABLE_H_
+
+#include "Module.h"
+#include "User.h"
+#include "Constant.h"
+
+class GlobalVariable : public User
+{
+private:
+    bool is_const_ ;
+    Constant* init_val_;
+    GlobalVariable(std::string name, Module *m, Type* ty, bool is_const, Constant* init = nullptr);
+public:
+    static GlobalVariable *create(std::string name, Module *m, Type* ty, bool is_const, 
+                                Constant* init );
+
+    Constant *get_init() { return init_val_; }
+    bool is_const() { return is_const_; }
+    std::string print();
+};
+#endif //_SYSY_GLOBALVARIABLE_H_

include/SysYIR/IRBuilder.h

@@ -0,0 +1,75 @@
+#ifndef _SYSY_IRBUILDER_H_
+#define _SYSY_IRBUILDER_H_
+
+#include "BasicBlock.h"
+#include "Instruction.h"
+#include "Value.h"
+
+class IRBuilder {
+private:
+    BasicBlock *BB_; 
+    Module *m_;
+public:
+    IRBuilder(BasicBlock *bb, Module *m) : BB_(bb), m_(m) {};
+    ~IRBuilder() = default;
+    Module *get_module(){return m_;}
+    BasicBlock *get_insert_block() { return this->BB_; }
+    void set_insert_point(BasicBlock *bb) { this->BB_ = bb; } //在某个基本块中插入指令
+    BinaryInst *create_iadd( Value *lhs, Value *rhs){ return BinaryInst::create_add( lhs, rhs, this->BB_, m_);}   //创建加法指令（以及其他算术指令）
+    BinaryInst *create_isub( Value *lhs, Value *rhs){ return BinaryInst::create_sub( lhs, rhs, this->BB_, m_);}
+    BinaryInst *create_imul( Value *lhs, Value *rhs){ return BinaryInst::create_mul( lhs, rhs, this->BB_, m_);}
+    BinaryInst *create_isdiv( Value *lhs, Value *rhs){ return BinaryInst::create_sdiv( lhs, rhs, this->BB_, m_);}
+    BinaryInst *create_isrem( Value *lhs, Value *rhs){ return BinaryInst::create_srem( lhs, rhs, this->BB_, m_);}
+
+    CmpInst *create_icmp_eq( Value *lhs, Value *rhs){ return CmpInst::create_cmp(CmpInst::EQ, lhs, rhs, this->BB_, m_); }
+    CmpInst *create_icmp_ne( Value *lhs, Value *rhs){ return CmpInst::create_cmp(CmpInst::NE, lhs, rhs, this->BB_, m_); }
+    CmpInst *create_icmp_gt( Value *lhs, Value *rhs){ return CmpInst::create_cmp(CmpInst::GT, lhs, rhs, this->BB_, m_); }
+    CmpInst *create_icmp_ge( Value *lhs, Value *rhs){ return CmpInst::create_cmp(CmpInst::GE, lhs, rhs, this->BB_, m_); }
+    CmpInst *create_icmp_lt( Value *lhs, Value *rhs){ return CmpInst::create_cmp(CmpInst::LT, lhs, rhs, this->BB_, m_); }
+    CmpInst *create_icmp_le( Value *lhs, Value *rhs){ return CmpInst::create_cmp(CmpInst::LE, lhs, rhs, this->BB_, m_); }
+
+    BinaryInst *create_fadd( Value *lhs, Value *rhs){ return BinaryInst::create_fadd( lhs, rhs, this->BB_, m_);}
+    BinaryInst *create_fsub( Value *lhs, Value *rhs){ return BinaryInst::create_fsub( lhs, rhs, this->BB_, m_);}
+    BinaryInst *create_fmul( Value *lhs, Value *rhs){ return BinaryInst::create_fmul( lhs, rhs, this->BB_, m_);}
+    BinaryInst *create_fdiv( Value *lhs, Value *rhs){ return BinaryInst::create_fdiv( lhs, rhs, this->BB_, m_);}
+    
+    FCmpInst *create_fcmp_eq( Value *lhs, Value *rhs){ return FCmpInst::create_fcmp(FCmpInst::EQ, lhs, rhs, this->BB_, m_); }
+    FCmpInst *create_fcmp_ne( Value *lhs, Value *rhs){ return FCmpInst::create_fcmp(FCmpInst::NE, lhs, rhs, this->BB_, m_); }
+    FCmpInst *create_fcmp_gt( Value *lhs, Value *rhs){ return FCmpInst::create_fcmp(FCmpInst::GT, lhs, rhs, this->BB_, m_); }
+    FCmpInst *create_fcmp_ge( Value *lhs, Value *rhs){ return FCmpInst::create_fcmp(FCmpInst::GE, lhs, rhs, this->BB_, m_); }
+    FCmpInst *create_fcmp_lt( Value *lhs, Value *rhs){ return FCmpInst::create_fcmp(FCmpInst::LT, lhs, rhs, this->BB_, m_); }
+    FCmpInst *create_fcmp_le( Value *lhs, Value *rhs){ return FCmpInst::create_fcmp(FCmpInst::LE, lhs, rhs, this->BB_, m_); }
+
+    CallInst *create_call(Value *func, std::vector<Value *> args)
+    {
+#ifdef DEBUG
+        assert( dynamic_cast<Function *>(func) && "func must be Function * type");
+#endif
+        return CallInst::create(static_cast<Function *>(func) ,args, this->BB_); 
+    }
+    
+    BranchInst *create_br(BasicBlock *if_true){ return BranchInst::create_br(if_true, this->BB_); }
+    BranchInst *create_cond_br(Value *cond, BasicBlock *if_true, BasicBlock *if_false){ return BranchInst::create_cond_br(cond, if_true, if_false,this->BB_); }
+    
+    ReturnInst *create_ret(Value *val) { return ReturnInst::create_ret(val,this->BB_); }
+    ReturnInst *create_void_ret() { return ReturnInst::create_void_ret(this->BB_); }
+
+    GetElementPtrInst *create_gep(Value *ptr, std::vector<Value *> idxs) { return GetElementPtrInst::create_gep(ptr, idxs, this->BB_); }
+
+    StoreInst *create_store(Value *val, Value *ptr) { return StoreInst::create_store(val, ptr, this->BB_ ); }
+    LoadInst * create_load(Type *ty, Value *ptr) { return LoadInst::create_load(ty, ptr, this->BB_); }
+    LoadInst * create_load(Value *ptr) 
+    {
+#ifdef DEBUG
+        assert( ptr->get_type()->is_pointer_type() && "ptr must be pointer type" );
+#endif
+        return LoadInst::create_load(ptr->get_type()->get_pointer_element_type(), ptr, this->BB_); 
+    }
+
+    AllocaInst *create_alloca(Type *ty) { return AllocaInst::create_alloca(ty, this->BB_); }
+    ZextInst *create_zext(Value *val, Type *ty) { return ZextInst::create_zext(val, ty, this->BB_); }
+    FpToSiInst *create_fptosi(Value *val, Type *ty) { return FpToSiInst::create_fptosi(val, ty, this->BB_); }
+    SiToFpInst *create_sitofp(Value *val, Type *ty) { return SiToFpInst::create_sitofp(val, ty, this->BB_); }
+};
+
+#endif // _SYSY_IRBUILDER_H_

include/SysYIR/IRprinter.h

@@ -0,0 +1,13 @@
+#include "Value.h"
+#include "Module.h"
+#include "Function.h"
+#include "GlobalVariable.h"
+#include "Constant.h"
+#include "BasicBlock.h"
+#include "Instruction.h"
+#include "User.h"
+#include "Type.h"
+
+std::string print_as_op( Value *v, bool print_ty );
+std::string print_cmp_type( CmpInst::CmpOp op);
+std::string print_fcmp_type( FCmpInst::CmpOp op);

include/SysYIR/Instruction.h

@@ -0,0 +1,405 @@
+#ifndef _SYSY_INSTRUCTION_H_
+#define _SYSY_INSTRUCTION_H_
+
+#include "User.h"
+#include "Type.h"
+#include "Constant.h"
+#include "BasicBlock.h"
+
+class BasicBlock;
+class Function;
+
+class Instruction : public User
+{
+public:
+    enum OpID
+    {
+        // Terminator Instructions
+        ret,
+        br,
+        // Standard binary operators
+        add,
+        sub,
+        mul,
+        sdiv,
+        srem,
+        // Float binaru opeartors
+        fadd,
+        fsub,
+        fmul,
+        fdiv,
+        // Memory operators
+        alloca,
+        load,
+        store,
+        // Other operators
+        cmp,
+        fcmp,
+        phi,
+        call,
+        getelementptr, 
+        // Zero extend
+        zext,
+        // type cast bewteen float and singed integer
+        fptosi,
+        sitofp,
+    };
+    // create instruction, auto insert to bb
+    // ty here is result type
+    Instruction(Type *ty, OpID id, unsigned num_ops,
+                BasicBlock *parent);
+    Instruction(Type *ty, OpID id, unsigned num_ops);
+    inline const BasicBlock *get_parent() const { return parent_; }
+    inline BasicBlock *get_parent() { return parent_; }
+    void set_parent(BasicBlock *parent) { this->parent_ = parent; }
+    // Return the function this instruction belongs to.
+    Function *get_function();
+    Module *get_module();
+
+    OpID get_instr_type() { return op_id_; }
+    std::string get_instr_op_name() {
+        switch (op_id_)
+        {
+            case ret: return "ret"; break;
+            case br: return "br"; break;
+            case add: return "add"; break;
+            case sub: return "sub"; break;
+            case mul: return "mul"; break;
+            case sdiv: return "sdiv"; break;
+            case srem: return "srem"; break;
+            case fadd: return "fadd"; break;
+            case fsub: return "fsub"; break;
+            case fmul: return "fmul"; break;
+            case fdiv: return "fdiv"; break;
+            case alloca: return "alloca"; break;
+            case load: return "load"; break;
+            case store: return "store"; break;
+            case cmp: return "cmp"; break;
+            case fcmp: return "fcmp"; break;
+            case phi: return "phi"; break;
+            case call: return "call"; break;
+            case getelementptr: return "getelementptr"; break;
+            case zext: return "zext"; break;
+            case fptosi: return "fptosi"; break;
+            case sitofp: return "sitofp"; break;
+        
+        default: return ""; break;
+        }
+    }
+
+
+
+    bool is_void() { return ((op_id_ == ret) || (op_id_ == br) || (op_id_ == store) || (op_id_ == call && this->get_type()->is_void_type())); }
+
+    bool is_phi() { return op_id_ == phi; }
+    bool is_store() { return op_id_ == store; }
+    bool is_alloca() { return op_id_ == alloca; }
+    bool is_ret() { return op_id_ == ret; }
+    bool is_load() { return op_id_ == load; }
+    bool is_br() { return op_id_ == br; }
+
+    bool is_add() { return op_id_ == add; }
+    bool is_sub() { return op_id_ == sub; }
+    bool is_mul() { return op_id_ == mul; }
+    bool is_div() { return op_id_ == sdiv; }
+    bool is_rem() { return op_id_ == srem; }
+
+    bool is_fadd() { return op_id_ == fadd; }
+    bool is_fsub() { return op_id_ == fsub; }
+    bool is_fmul() { return op_id_ == fmul; }
+    bool is_fdiv() { return op_id_ == fdiv; }
+
+    bool is_cmp() { return op_id_ == cmp; }
+    bool is_fcmp() { return op_id_ == fcmp; }
+
+    bool is_call() { return op_id_ == call; }
+    bool is_gep() { return op_id_ == getelementptr; }
+    bool is_zext() { return op_id_ == zext; }
+    bool is_fptosi() { return op_id_ == fptosi; }
+    bool is_sitofp() { return op_id_ == sitofp; }
+
+    bool isBinary()
+    {
+        return (is_add() || is_sub() || is_mul() || is_div() || is_rem() || 
+                is_fadd() || is_fsub() || is_fmul() || is_fdiv()) && 
+                (get_num_operand() == 2);
+    }
+
+    bool isTerminator() { return is_br() || is_ret(); }
+
+    void set_id(int id){id_ = id;}
+    int get_id() const{return id_;}
+
+private:
+    BasicBlock *parent_;
+    OpID op_id_;
+    int id_;
+    unsigned num_ops_;
+};
+
+class BinaryInst : public Instruction
+{
+private:
+    BinaryInst(Type *ty, OpID id, Value *v1, Value *v2,
+               BasicBlock *bb);
+
+public:
+    static BinaryInst *create_add(Value *v1, Value *v2, BasicBlock *bb, Module *m);
+    static BinaryInst *create_sub(Value *v1, Value *v2, BasicBlock *bb, Module *m);
+    static BinaryInst *create_mul(Value *v1, Value *v2, BasicBlock *bb, Module *m);
+    static BinaryInst *create_sdiv(Value *v1, Value *v2, BasicBlock *bb, Module *m);
+    static BinaryInst *create_srem(Value *v1, Value *v2, BasicBlock *bb, Module *m);
+    static BinaryInst *create_fadd(Value *v1, Value *v2, BasicBlock *bb, Module *m);
+    static BinaryInst *create_fsub(Value *v1, Value *v2, BasicBlock *bb, Module *m);
+    static BinaryInst *create_fmul(Value *v1, Value *v2, BasicBlock *bb, Module *m);
+    static BinaryInst *create_fdiv(Value *v1, Value *v2, BasicBlock *bb, Module *m);
+
+    virtual std::string print() override;
+
+private:
+    void assertValid();
+};
+
+class CmpInst : public Instruction
+{
+public:
+    enum CmpOp
+    {
+        EQ, // ==
+        NE, // !=
+        GT, // >
+        GE, // >=
+        LT, // <
+        LE  // <=
+    };
+
+private:
+    CmpInst(Type *ty, CmpOp op, Value *lhs, Value *rhs,
+            BasicBlock *bb);
+
+public:
+    static CmpInst *create_cmp(CmpOp op, Value *lhs, Value *rhs,
+                               BasicBlock *bb, Module *m);
+
+    CmpOp get_cmp_op() { return cmp_op_; }
+
+    virtual std::string print() override;
+
+private:
+    CmpOp cmp_op_;
+
+    void assertValid();
+};
+
+class FCmpInst : public Instruction
+{
+public:
+    enum CmpOp
+    {
+        EQ, // ==
+        NE, // !=
+        GT, // >
+        GE, // >=
+        LT, // <
+        LE  // <=
+    };
+
+private:
+    FCmpInst(Type *ty, CmpOp op, Value *lhs, Value *rhs,
+            BasicBlock *bb);
+
+public:
+    static FCmpInst *create_fcmp(CmpOp op, Value *lhs, Value *rhs,
+                               BasicBlock *bb, Module *m);
+
+    CmpOp get_cmp_op() { return cmp_op_; }
+
+    virtual std::string print() override;
+
+private:
+    CmpOp cmp_op_;
+
+    void assertValid();
+};
+
+class CallInst : public Instruction
+{
+protected:
+    CallInst(Function *func, std::vector<Value *> args, BasicBlock *bb);
+    CallInst(Type *ret_ty, std::vector<Value *> args, BasicBlock *bb);
+
+public:
+    static CallInst *create(Function *func, std::vector<Value *> args, BasicBlock *bb);
+    FunctionType *get_function_type() const;
+
+    virtual std::string print() override;
+
+};
+
+class BranchInst : public Instruction
+{
+private:
+    BranchInst(Value *cond, BasicBlock *if_true, BasicBlock *if_false,
+               BasicBlock *bb);
+    BranchInst(Value *cond, BasicBlock *bb);
+    BranchInst(BasicBlock *if_true, BasicBlock *bb);
+    BranchInst(BasicBlock *bb);
+
+public:
+    static BranchInst *create_cond_br(Value *cond, BasicBlock *if_true, BasicBlock *if_false,
+                                      BasicBlock *bb);
+    static BranchInst *create_br(BasicBlock *if_true, BasicBlock *bb);
+
+    bool is_cond_br() const;
+
+    virtual std::string print() override;
+
+};
+
+class ReturnInst : public Instruction
+{
+private:
+    ReturnInst(Value *val, BasicBlock *bb);
+    ReturnInst(BasicBlock *bb);
+
+public:
+    static ReturnInst *create_ret(Value *val, BasicBlock *bb);
+    static ReturnInst *create_void_ret(BasicBlock *bb);
+    bool is_void_ret() const;
+
+    virtual std::string print() override;
+
+};
+
+class GetElementPtrInst : public Instruction
+{
+private:
+    GetElementPtrInst(Value *ptr, std::vector<Value *> idxs, BasicBlock *bb);
+
+public:
+    static Type *get_element_type(Value *ptr, std::vector<Value *> idxs);
+    static GetElementPtrInst *create_gep(Value *ptr, std::vector<Value *> idxs, BasicBlock *bb);
+    Type *get_element_type() const;
+
+    virtual std::string print() override;
+
+private:
+    Type *element_ty_;
+};
+
+class StoreInst : public Instruction
+{
+private:
+    StoreInst(Value *val, Value *ptr, BasicBlock *bb);
+
+public:
+    static StoreInst *create_store(Value *val, Value *ptr, BasicBlock *bb);
+
+    Value *get_rval() { return this->get_operand(0); }
+    Value *get_lval() { return this->get_operand(1); }
+
+    virtual std::string print() override;
+
+};
+
+class LoadInst : public Instruction
+{
+private:
+    LoadInst(Type *ty, Value *ptr, BasicBlock *bb);
+
+public:
+    static LoadInst *create_load(Type *ty, Value *ptr, BasicBlock *bb);
+    Value *get_lval() { return this->get_operand(0); }
+
+    Type *get_load_type() const;
+
+    virtual std::string print() override;
+
+};
+
+class AllocaInst : public Instruction
+{
+private:
+    AllocaInst(Type *ty, BasicBlock *bb);
+
+public:
+    static AllocaInst *create_alloca(Type *ty, BasicBlock *bb);
+
+    Type *get_alloca_type() const;
+
+    virtual std::string print() override;
+
+private:
+    Type *alloca_ty_;
+};
+
+class ZextInst : public Instruction
+{
+private:
+    ZextInst(OpID op, Value *val, Type *ty, BasicBlock *bb);
+
+public:
+    static ZextInst *create_zext(Value *val, Type *ty, BasicBlock *bb);
+
+    Type *get_dest_type() const;
+
+    virtual std::string print() override;
+
+private:
+    Type *dest_ty_;
+};
+
+class FpToSiInst : public Instruction
+{
+private:
+    FpToSiInst(OpID op, Value *val, Type *ty, BasicBlock *bb);
+
+public:
+    static FpToSiInst *create_fptosi(Value *val, Type *ty, BasicBlock *bb);
+
+    Type *get_dest_type() const;
+
+    virtual std::string print() override;
+
+private:
+    Type *dest_ty_;
+};
+
+class SiToFpInst : public Instruction
+{
+private:
+    SiToFpInst(OpID op, Value *val, Type *ty, BasicBlock *bb);
+
+public:
+    static SiToFpInst *create_sitofp(Value *val, Type *ty, BasicBlock *bb);
+
+    Type *get_dest_type() const;
+
+    virtual std::string print() override;
+
+private:
+    Type *dest_ty_;
+};
+
+class PhiInst : public Instruction
+{
+private:
+    PhiInst(OpID op, std::vector<Value *> vals, std::vector<BasicBlock *> val_bbs, Type *ty, BasicBlock *bb);
+
+public:
+    static PhiInst *create_phi(Type *ty, BasicBlock *bb);
+    Value *get_lval() { return l_val_; }
+    void set_lval(Value *l_val) { l_val_ = l_val; }
+    void add_phi_pair_operand(Value *val, Value *pre_bb)
+    {
+        this->add_operand(val);
+        this->add_operand(pre_bb);
+    }
+    virtual std::string print() override;
+
+private:
+    Value *l_val_;
+
+};
+
+#endif // _SYSY_INSTRUCTION_H_

include/SysYIR/Module.h

@@ -0,0 +1,61 @@
+#ifndef _SYSY_MODULE_H_
+#define _SYSY_MODULE_H_
+
+#include <string>
+#include <list>
+#include <map>
+
+#include "Type.h"
+#include "GlobalVariable.h"
+#include "Value.h"
+#include "Function.h"
+
+class GlobalVariable;
+
+class Module
+{
+public:
+    explicit Module(std::string name);
+    ~Module();
+    
+    Type *get_void_type();
+    Type *get_label_type();
+    IntegerType *get_int1_type();
+    IntegerType *get_int32_type();
+    FloatType *get_float_type();
+    PointerType *get_int32_ptr_type();
+    PointerType *get_float_ptr_type();
+
+    PointerType *get_pointer_type(Type *contained);
+    ArrayType *get_array_type(Type *contained, unsigned num_elements);
+
+    void add_function(Function *f);
+    std::list<Function* > &get_functions();
+    void add_global_variable(GlobalVariable* g);
+    std::list<GlobalVariable *> &get_global_variable();
+    std::string get_instr_op_name( Instruction::OpID instr ) { return instr_id2string_[instr]; }
+    void set_print_name();
+    void set_file_name(std::string name){source_file_name_ = name;}
+    std::string get_file_name(){return source_file_name_;}
+    virtual std::string print();
+private:
+    std::list<GlobalVariable *> global_list_;   // The Global Variables in the module
+    std::list<Function *> function_list_;       // The Functions in the module
+    std::map<std::string, Value*> value_sym_;   // Symbol table for values
+    std::map<Instruction::OpID, std::string> instr_id2string_;   // Instruction from opid to string 
+    
+    std::string module_name_;         // Human readable identifier for the module
+    std::string source_file_name_;    // Original source file name for module, for test and debug
+
+private:
+    IntegerType *int1_ty_;
+    IntegerType *int32_ty_;
+    FloatType *float32_ty_;
+    Type *label_ty_;
+    Type *void_ty_;    
+    
+    std::map<Type *, PointerType *> pointer_map_;
+    std::map<std::pair<Type *,int >, ArrayType *> array_map_; 
+};
+
+#endif // _SYSY_MODULE_H_

include/SysYIR/Type.h

@@ -0,0 +1,146 @@
+#ifndef _SYSY_TYPE_H_
+#define _SYSY_TYPE_H_
+
+#include <vector>
+#include <iostream>
+
+class Module;
+class IntegerType;
+class FloatType;
+class FunctionType;
+class ArrayType;
+class PointerType;
+
+class Type
+{
+public:
+    enum TypeID {
+        VoidTyID,         // Void
+        LabelTyID,        // Labels, e.g., BasicBlock
+        IntegerTyID,      // Integers, include 32 bits and 1 bit
+        FloatTyID,        // Floats, only 32 bits
+        FunctionTyID,     // Functions
+        ArrayTyID,        // Arrays
+        PointerTyID,      // Pointer
+    };
+
+    explicit Type(TypeID tid, Module *m);
+    ~Type() = default;
+
+    TypeID get_type_id() const { return tid_; }
+
+    bool is_void_type() const { return get_type_id() == VoidTyID; }
+    
+    bool is_label_type() const { return get_type_id() == LabelTyID; }
+
+    bool is_integer_type() const { return get_type_id() == IntegerTyID; }
+
+    bool is_float_type() const { return get_type_id() == FloatTyID; }
+        
+    bool is_function_type() const { return get_type_id() == FunctionTyID; }
+
+    bool is_array_type() const { return get_type_id() == ArrayTyID; }
+
+    bool is_pointer_type() const { return get_type_id() == PointerTyID; }
+
+    static bool is_eq_type(Type *ty1, Type *ty2);
+
+    static Type *get_void_type(Module *m);
+
+    static Type *get_label_type(Module *m);
+
+    static IntegerType *get_int1_type(Module *m);
+
+    static IntegerType *get_int32_type(Module *m);
+
+    static FloatType *get_float_type(Module *m);
+
+    static PointerType *get_int32_ptr_type(Module *m);
+
+    static PointerType *get_float_ptr_type(Module *m);
+
+    static PointerType *get_pointer_type(Type *contained);
+
+    static ArrayType *get_array_type(Type *contained, unsigned num_elements);
+
+    Type *get_pointer_element_type();
+
+    Type *get_array_element_type();
+
+    int get_size();
+    
+    Module *get_module();
+
+    std::string print();
+
+private:
+    TypeID tid_;
+    Module *m_;
+};
+
+class IntegerType : public Type {
+public:
+    explicit IntegerType(unsigned num_bits ,Module *m);
+
+    static IntegerType *get(unsigned num_bits, Module *m );
+
+    unsigned get_num_bits();
+private:
+    unsigned num_bits_;
+};
+
+class FloatType : public Type {
+public:
+    FloatType(Module *m);
+    static FloatType *get(Module *m );
+};
+
+class FunctionType : public Type {
+public:
+    FunctionType(Type *result, std::vector<Type *> params);
+
+    static bool is_valid_return_type(Type *ty);
+    static bool is_valid_argument_type(Type *ty);
+
+    static FunctionType *get(Type *result,
+                            std::vector<Type*> params);
+
+    unsigned get_num_of_args() const;
+
+    Type *get_param_type(unsigned i) const;
+    std::vector<Type *>::iterator param_begin() { return args_.begin(); }
+    std::vector<Type *>::iterator param_end() { return args_.end(); }
+    Type *get_return_type() const;
+private:
+    Type *result_;
+    std::vector<Type *> args_;
+};
+
+class ArrayType : public Type {
+public:
+    ArrayType(Type *contained, unsigned num_elements);
+
+    static bool is_valid_element_type(Type *ty);
+
+    static ArrayType *get(Type *contained, unsigned num_elements);
+
+    Type *get_element_type() const { return contained_; }
+    unsigned get_num_of_elements() const { return num_elements_; }
+
+private:
+    Type *contained_;   // The element type of the array.
+    unsigned num_elements_;  // Number of elements in the array.
+};
+
+class PointerType : public Type {
+public:
+    PointerType(Type *contained);
+    Type *get_element_type() const { return contained_; }
+
+    static PointerType *get(Type *contained);
+
+private:
+    Type *contained_;   // The element type of the ptr.
+};
+
+#endif // _SYSY_TYPE_H_

include/SysYIR/User.h

@@ -0,0 +1,34 @@
+#ifndef _SYSY_USER_H_
+#define _SYSY_USER_H_
+
+#include "Value.h"
+#include <vector>
+// #include <memory>
+
+class User : public Value
+{
+public:
+    User(Type *ty, const std::string &name = "", unsigned num_ops = 0);
+    ~User() = default;
+
+    std::vector<Value *>& get_operands();
+
+    // start from 0
+    Value *get_operand(unsigned i) const;
+
+    // start from 0
+    void set_operand(unsigned i, Value *v);
+    void add_operand( Value *v);
+
+    unsigned get_num_operand() const;
+
+    void remove_use_of_ops();
+    void remove_operands(int index1,int index2);
+
+private:
+    // std::unique_ptr< std::list<Value *> > operands_;   // operands of this value
+    std::vector<Value *> operands_;   // operands of this value
+    unsigned num_ops_;
+};
+
+#endif // _SYSY_USER_H_

include/SysYIR/Value.h

@@ -0,0 +1,50 @@
+#ifndef _SYSY_VALUE_H_
+#define _SYSY_VALUE_H_
+
+#include <string>
+#include <list>
+#include <iostream>
+
+class Type;
+class Value;
+
+struct Use
+{
+    Value *val_;
+    unsigned arg_no_;     // the no. of operand, e.g., func(a, b), a is 0, b is 1
+    Use(Value *val, unsigned no) : val_(val), arg_no_(no) {}
+};
+
+class Value
+{
+public:
+    explicit Value(Type *ty, const std::string &name = "");
+    ~Value() = default;
+
+    Type *get_type() const { return type_; }
+
+    std::list<Use> &get_use_list() { return use_list_; }
+
+    void add_use(Value *val, unsigned arg_no = 0);
+
+    bool set_name(std::string name) { 
+        if (name_ == "")
+        {
+            name_=name;
+            return true;
+        }   
+        return false; 
+    }
+    std::string get_name() const;
+
+    void replace_all_use_with(Value *new_val);
+    void remove_use(Value *val);
+
+    virtual std::string print() = 0;
+private:
+    Type *type_;
+    std::list<Use> use_list_;   // who use this value
+    std::string name_;    // should we put name field here ?
+};
+
+#endif // _SYSY_VALUE_H_

lib/lib.c

@@ -0,0 +1,30 @@
+#include<stdio.h>
+/* Input & output functions */
+int get_int(){int t; scanf("%d",&t); return t; }
+int get_float(){float t; scanf("%f",&t); return t; }
+int get_char(){char c; scanf("%c",&c); return (int)c; }
+int get_int_array(int a[]){
+  int n;
+  scanf("%d",&n);
+  for(int i=0;i<n;i++)scanf("%d",&a[i]);
+  return n;
+}
+int get_float_array(float a[]){
+  int n;
+  scanf("%d",&n);
+  for(int i=0;i<n;i++)scanf("%f",&a[i]);
+  return n;
+}
+void put_int(int a){ printf("%d",a); }
+void put_float(float a){ printf("%f",a); }
+void put_char(int a){ printf("%c",a); }
+void put_int_array(int n, int a[]){
+  printf("%d:",n);
+  for(int i=0;i<n;i++)printf(" %d",a[i]);
+  printf("\n");
+}
+void put_float_array(int n, float a[]){
+  printf("%d:",n);
+  for(int i=0;i<n;i++)printf(" %f",a[i]);
+  printf("\n");
+}

report.md

@@ -0,0 +1,19 @@
+# PW6 实验报告
+
+学号1 姓名1 学号2 姓名2 学号3 姓名3
+
+## 问题回答
+
+请给出`SysYIR.md`中提到的两种getelementptr用法的区别, 并解释原因:
+  - `%2 = getelementptr [10 x i32], [10 x i32]* %1, i32 0, i32 %0` 
+  - `%2 = getelementptr i32, i32* %1, i32 %0` 
+
+## 实验设计
+
+## 实验难点及解决方案
+
+## 实验总结
+
+## 实验反馈
+
+## 组间交流