湖南大学编译原理实验三cminus_compiler-2021-fall

最新推荐文章于 2024-01-26 16:51:30 发布
最新推荐文章于 2024-01-26 16:51:30 发布
阅读量1k 收藏 5
点赞数
分类专栏： # 编译原理 文章标签： c++ linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45890970/article/details/123792234
版权

湖南大学编译原理实验三cminus_compiler-2021-fall

Lab3 实验文档

0. 前言

本次实验作为Lab4的前驱实验，独立于Lab1、Lab2。
本次实验的目的是让大家熟悉Lab4所需要的相关知识: LLVM IR、 LightIR（LLVM IR的轻量级C++接口）和 Visitor Pattern（访问者模式）。
在开始实验之前，如果你使用的不是助教提供的虚拟机镜像，请根据之前的环境准备确保LLVM的版本为10.0.1，且PATH环境变量配置正确。可以通过lli --version命令是否可以输出10.0.1的版本信息来验证。

主要工作

  1. 第一部分: 了解LLVM IR。通过clang生成的.ll，了解LLVM IR与c代码的对应关系。完成1.3
  2. 第二部分: 了解LightIR。通过助教提供的c++例子，了解LightIR的c++接口及实现。完成2.3
  3. 第三部分: 理解Visitor Pattern。
  4. 实验报告：在report.md中回答3个问题。

1. LLVM IR部分

1.1 LLVM IR介绍

根据维基百科的介绍，LLVM是一个自由软件项目，它是一种编译器基础设施，以C++写成，包含一系列模块化的编译器组件和工具链，用来开发编译器前端和后端。IR的全称是Intermediate Representation，即中间表示。LLVM IR是一种类似于汇编的底层语言。
LLVM IR的具体指令可以参考Reference Manual。但是你会发现其内容庞杂。虽然助教认为，高效地查阅官方文档及手册是非常必要的一项技能，但是由于其手册过于复杂，因此助教筛选了后续实验中将要用到的子集，总结为了精简的IR Reference手册。
作为一开始的参考，你可以先阅读其中IR Features和IR Format两节，后续有需要再反复参考。实验的最后，你需要在report.md中回答问题3。

1.2 gcd例子: 利用clang生成的.ll

阅读tests/lab3/ta_gcd/gcd_array.c。
根据clang -S -emit-llvm gcd_array.c指令，你可以得到对应的gcd_array.ll文件.你需要结合gcd_array.c阅读gcd_array.ll，理解其中每条LLVM IR指令与c代码的对应情况。
通过lli gcd_array.ll; echo $?指令，你可以测试gcd_array.ll执行结果的正确性。其中，

  • lli会运行*.ll文件
  • $?的内容是上一条命令所返回的结果，而echo $?可以将其输出到终端中

后续你会经常用到这两条指令。

1.3 你的提交1: 手动编写.ll

助教提供了四个简单的c程序，分别是tests/lab3/c_cases/目录下的assign.c、fun.c、if.c和while.c.你需要在tests/lab3/stu_ll/目录中，手工完成自己的assign_hand.ll、fun_hand.ll、if_handf.ll和while_hand.ll，以实现与上述四个C程序相同的逻辑功能.你需要添加必要的注释..ll文件的注释是以";"开头的。
必要的情况下，你可以参考clang -S -emit-llvm的输出，但是你提交的结果必须避免同此输出一字不差。
助教会用lli检查你结果的正确性，并用肉眼检查你的注释。

2. LightIR部分

2.1 LightIR - LLVM IR的C++接口

由于LLVM IR官方的C++接口的文档同样过于冗长，助教提供了LightIR这一C++接口库。你需要阅读LightIR核心类的介绍。
lab4部分会要求大家通过LightIR根据AST构建生成LLVM IR。所以你需要仔细阅读文档了解其接口的设计。

2.2 gcd例子: 利用LightIR + cpp 生成.ll

为了让大家更直观地感受并学会LightIR接口的使用，助教提供了tests/lab3/ta_gcd/gcd_array_generator.cpp。该cpp程序会生成与gcd_array.c逻辑相同的LLVM IR文件。助教提供了非常详尽的注释，一定要好好利用！
该程序的编译与运行请参考4.2节。

2.3 你的提交2: 利用LightIR + cpp编写生成.ll的程序

你需要在tests/lab3/stu_cpp/目录中，编写assign_generator.cpp、fun_generator.cpp、if_generator.cpp和while_generator.cpp，以生成与1.3节的四个C程序相同逻辑功能的.ll文件。你需要添加必要的注释。你需要在report.md中回答问题1。

3. Lab4的准备

3.1 了解Visitor Pattern

Visitor Pattern(访问者模式)是一种在LLVM项目源码中被广泛使用的设计模式。在遍历某个数据结构（比如树）时，如果我们需要对每个节点做一些额外的特定操作，Visitor Pattern就是个不错的思路。
Visitor Pattern是为了解决稳定的数据结构和易变的操作耦合问题而产生的一种设计模式。解决方法就是在被访问的类里面加一个对外提供接待访问者的接口，其关键在于在数据基础类里面有一个方法接受访问者，将自身引用传入访问者。这里举一个应用实例来帮助理解访问者模式: 您在朋友家做客，您是访问者；朋友接受您的访问，您通过朋友的描述，然后对朋友的描述做出一个判断，这就是访问者模式。
有关 Visitor Pattern 的含义、模式和特点，有梯子的同学可参考维基百科。
下面的例子可以清晰地展示Visitor Pattern的运作方式。这是助教编写的计算表达式 4 * 2 - 2 / 4 + 5 结果的C++程序。
其中较为重要的一点原则在于，C++中对函数重载特性的支持。在代码treeVisitor.visit(node)中，根据node对象具体类型的不同，编译器会在visit(AddSubNode& node)、visit(NumberNode& node)、visit(MulDivNode& node)三者中，选择对应的实现进行调用。你需要理解下面这个例子中tree是如何被遍历的。请在report.md中回答问题2。

例子:简单的表达式计算 - visitor.cpp 
#include <iostream>
#include <vector>

class TreeVisitor;  // Forward declare TreeVisitor

class Node {  // Parent class for the elements (AddSubNode, NumberNode and
              // MulDivNode)
 public:
  // This function accepts an object of any class derived from
  // TreeVisitor and must be implemented in all derived classes
  virtual int accept(TreeVisitor& treeVisitor) = 0;
};

// Forward declare specific elements (nodes) to be dispatched
class AddSubNode;
class NumberNode;
class MulDivNode;

class TreeVisitor {  // Declares the interface for the treeVisitor
 public:
  // Declare overloads for each kind of a node to dispatch
  virtual int visit(AddSubNode& node) = 0;
  virtual int visit(NumberNode& node) = 0;
  virtual int visit(MulDivNode& node) = 0;
};

class AddSubNode : public Node {  // Specific element class #1
 public:
  // Resolved at runtime, it calls the treeVisitor's overloaded function,
  // corresponding to AddSubNode.
  int accept(TreeVisitor& treeVisitor) override {
    return treeVisitor.visit(*this);
  }
  Node& leftNode;
  Node& rightNode;
  std::string op;
  AddSubNode(Node& left, Node& right, std::string op): leftNode(left), rightNode(right), op(op){}
};

class NumberNode : public Node {  // Specific element class #2
 public:
  // Resolved at runtime, it calls the treeVisitor's overloaded function,
  // corresponding to NumberNode.
  int accept(TreeVisitor& treeVisitor) override {
    return treeVisitor.visit(*this);
  }
  int number;
  NumberNode(int number){
    this->number = number;
  }
};

class MulDivNode : public Node {  // Specific element class #3
 public:
  // Resolved at runtime, it calls the treeVisitor's overloaded function,
  // corresponding to MulDivNode.
  int accept(TreeVisitor& treeVisitor) override {
    return treeVisitor.visit(*this);
  }
  Node& leftNode;
  Node& rightNode;
  std::string op;
  MulDivNode(Node& left, Node& right, std::string op): leftNode(left), rightNode(right), op(op){}
};

class TreeVisitorCalculator : public TreeVisitor {  // Implements triggering of all
                                                // kind of elements (nodes)
 public:
  int visit(AddSubNode& node) override {
    auto right = node.rightNode.accept(*this);
    auto left = node.leftNode.accept(*this);
    if (node.op == "add") {
      return left + right;
    } 
    else {
      return left - right;
    }
  }

  int visit(NumberNode& node) override {
    return node.number;
  }

  int visit(MulDivNode& node) override {
    auto left = node.leftNode.accept(*this);
    auto right = node.rightNode.accept(*this);
    if (node.op == "mul") {
      return left * right;
    } 
    else {
      return left / right;
    }
  }
};

int main() {
  // construct the expression nodes and the tree
  // the expression: 4 * 2 - 2 / 4 + 5
  auto numberA = NumberNode(4);
  auto numberB = NumberNode(2);
  auto exprC = MulDivNode(numberA, numberB, "mul");
  auto exprD = MulDivNode(numberB, numberA, "div");
  auto exprE = AddSubNode(exprC, exprD, "sub");
  auto numberF = NumberNode(5);
  auto exprRoot = AddSubNode(exprE, numberF, "add");

  TreeVisitorCalculator treeVisitor;
  // traverse the tree and calculate
  int result = treeVisitor.visit(exprRoot);
  std::cout << "4 * 2 - 2 / 4 + 5 evaluates: " << result << std::endl;
  return 0;
}

该文件的执行结果如下:

$ g++ visitor.cpp -std=c++14; ./a.out
4 * 2 - 2 / 4 + 5 evaluates: 13

4. 实验要求

4.1 目录结构

除了下面指明你所要修改或提交的文件，其他文件请勿修改。

.
├── CMakeLists.txt
├── Documentations
│   ├── ...
|   ├── common                          <- LightIR 相关文档
│   └── lab3
│       └── README.md                   <- lab3实验文档说明（你在这里）
├── include                             <- 实验所需的头文件
│   ├── ...
│   ├── lightir
├── README.md
├── Reports
│   ├── ...
│   └── lab3
│       └── report.md                   <- lab3所需提交的实验报告，含3个问题（你要交）
├── src
│   ├── ...
│   └── lightir
└── tests
    ├── CMakeLists.txt
    ├── ...
    └── lab3                            <- lab3文件夹
        ├── c_cases                     <- 4个c程序
        │   ├── assign.c
        │   ├── fun.c
        │   ├── if.c
        │   └── while.c
        ├── CMakeLists.txt              <- 你在2.3节需要去掉注释（我们不收，你要改）
        ├── stu_cpp                     <- lab3所需提交的cpp目录（你要交）
        │   ├── assign_generator.cpp
        │   ├── fun_generator.cpp
        │   ├── if_generator.cpp
        │   └── while_generator.cpp
        ├── stu_ll                      <- lab3所需提交的.ll目录（你要交）
        │   ├── assign_hand.ll
        │   ├── fun_hand.ll
        │   ├── if_hand.ll
        │   └── while_hand.ll
        └── ta_gcd
            ├── gcd_array.c
            └── gcd_array_generator.cpp <- 助教提供的生成gcd_array.ll的cpp

4.2 编译、运行和验证

  • 编译与运行
    在 ${WORKSPACE}/build/ 下执行:
    # 如果存在 CMakeCache.txt 要先删除
# rm CMakeCache.txt
cmake ..
make
make install
    你可以得到对应gcd_array_generator.cpp的可执行文件。
    在完成2.3时，在${WORKSPACE}/tests/lab3/CMakeLists.txt中去掉对应的注释，再在${WORKSPACE}/build/下执行cmake ..与make指令，即可得到对应的可执行文件。
  • 验证
    本次试验测试案例只有${WORKSPACE}/tests/lab3/c_cases中的4个样例。请大家自行验证。
    助教会执行你们的代码，并使用 diff 命令进行验证。

实验报告

问题1: cpp与.ll的对应

请描述你的cpp代码片段和.ll的每个BasicBlock的对应关系。描述中请附上两者代码。

assign

(1)如下是assign_generator.cpp中的内容

#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("Assign code");
  auto builder = new IRBuilder(nullptr, module); //该类提供了独立的接口创建各种 IR 指令
  Type *Int32Type = Type::get_int32_type(module);

  // main函数
  auto mainFun = Function::create(FunctionType::get(Int32Type, {}),"main", module);
  auto bb = BasicBlock::create(module, "entry", mainFun);
  builder->set_insert_point(bb);

  auto retAlloca = builder->create_alloca(Int32Type);  //分配一个保存返回值的内容


  auto *arrayType = ArrayType::get(Int32Type, 10);  //数组类型，参数依次是数组元素的类型Int32Type,数组元素个数10
  auto a=builder->create_alloca(arrayType);  //数组a[10]

  auto a0GEP = builder->create_gep(a, {CONST_INT(0), CONST_INT(0)}); //获取a[0]的地址
  builder->create_store(CONST_INT(10), a0GEP);  //将整数10写入a[0]的地址
  auto a0Load = builder->create_load(a0GEP);  //读取a[0]
  auto m=builder->create_imul(a0Load,CONST_INT(2)); //a[0]*2

  auto a1GEP = builder->create_gep(a, {CONST_INT(0), CONST_INT(1)});  //获取a[1]的地址
  builder->create_store(m, a1GEP); //将a[0]*2写入a[1]的地址
  auto a1Load = builder->create_load(a1GEP); //获取a[1]的值

  builder->create_store(a1Load, retAlloca); //将a[1]的值写入retAlloca地址中
  auto retLoad=builder->create_load(retAlloca); //读取retAlloca地址的值
  builder->create_ret(retLoad);  //创建ret指令，即返回

  std::cout << module->print();
  delete module;
  return 0;
}

（2）在build目录下执行命令make生成可执行文件stu_assign_generator。执行命令./stu_assign_generator >assign.ll，,如下是生成的assign.ll中的内容

define i32 @main() {
label_entry:
  %op0 = alloca i32
  %op1 = alloca [10 x i32]
  %op2 = getelementptr [10 x i32], [10 x i32]* %op1, i32 0, i32 0
  store i32 10, i32* %op2
  %op3 = load i32, i32* %op2
  %op4 = mul i32 %op3, 2
  %op5 = getelementptr [10 x i32], [10 x i32]* %op1, i32 0, i32 1
  store i32 %op4, i32* %op5
  %op6 = load i32, i32* %op5
  store i32 %op6, i32* %op0
  %op7 = load i32, i32* %op0
  ret i32 %op7
}

(3)只有一个basicblock,对应关系为：

auto bb = BasicBlock::create(module, "entry", mainFun);对应标签main函数中的label_entry。

fun

(1)如下是fun_generator.cpp中的内容

#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("fun code");
  auto builder = new IRBuilder(nullptr, module); //该类提供了独立的接口创建各种 IR 指令
  Type *Int32Type = Type::get_int32_type(module);
  
  //函数callee
  std::vector<Type *> Ints(1, Int32Type); // 函数参数类型的vector
  auto calleeFunTy = FunctionType::get(Int32Type, Ints); //通过返回值类型与参数类型列表得到函数类型
  auto calleeFun = Function::create(calleeFunTy,"callee", module);   // 由函数类型得到函数
  
  auto bb = BasicBlock::create(module, "entry", calleeFun);
  builder->set_insert_point(bb);                 // 一个BB的开始,将当前插入指令点的位置设在bb

  auto aAlloca = builder->create_alloca(Int32Type);  // 在内存中分配参数a的位置
 
  std::vector<Value *> args;  // 获取函数的形参,通过Function中的iterator
  for (auto arg = calleeFun->arg_begin(); arg != calleeFun->arg_end(); arg++) {
    args.push_back(*arg);   // * 号运算符是从迭代器中取出迭代器当前指向的元素
  }
  builder->create_store(args[0], aAlloca);  // 将参数a store下来
  auto aLoad=builder->create_load(aAlloca); //获取参数a的值
  auto m=builder->create_imul(aLoad,CONST_INT(2)); //a*2
  
  auto retAlloca = builder->create_alloca(Int32Type);  //分配一个保存返回值的内容
  builder->create_store(m, retAlloca); //将m的值写入retAlloca地址中
  auto retLoad=builder->create_load(retAlloca); //读取retAlloca地址的值
  builder->create_ret(retLoad);  //创建ret指令，即返回

  // main函数
  auto mainFun = Function::create(FunctionType::get(Int32Type, {}),"main", module);
  bb = BasicBlock::create(module, "entry", mainFun); //创建BasicBlock
  builder->set_insert_point(bb);  //将当前插入指令点的位置设在bb
  
  auto cs= builder->create_alloca(Int32Type); // 在内存中分配参数cs的位置
  builder->create_store(CONST_INT(110), cs);  //将整数10写入cs的地址
  auto csLoad = builder->create_load(cs);  //读取cs
  auto call = builder->create_call(calleeFun, {csLoad}); //创建call指令
  builder->create_ret(call); //创建ret指令,返回

  std::cout << module->print();
  delete module;
  return 0;
}

(2)在build目录下执行命令make生成可执行文件stu_fun_generator。执行命令./stu_fun_generator >fun.ll，,如下是生成的fun.ll中的内容

define i32 @callee(i32 %arg0) {
label_entry:
  %op1 = alloca i32
  store i32 %arg0, i32* %op1
  %op2 = load i32, i32* %op1
  %op3 = mul i32 %op2, 2
  %op4 = alloca i32
  store i32 %op3, i32* %op4
  %op5 = load i32, i32* %op4
  ret i32 %op5
}
define i32 @main() {
label_entry:
  %op0 = alloca i32
  store i32 110, i32* %op0
  %op1 = load i32, i32* %op0
  %op2 = call i32 @callee(i32 %op1)
  ret i32 %op2
}

(3)有两个basicblock,对应关系为：

  • auto bb = BasicBlock::create(module, "entry", calleeFun);对应 callee 函数中的标签label_entry。
  • bb = BasicBlock::create(module, "entry", mainFun);对应main函数中的标签label_entry。

if

（1）如下是if_generator.cpp中的内容

#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("if code");
  auto builder = new IRBuilder(nullptr, module); //该类提供了独立的接口创建各种 IR 指令
  Type *Int32Type = Type::get_int32_type(module);
  Type *FloatType = Type::get_float_type(module);
  
  // main函数
  auto mainFun = Function::create(FunctionType::get(Int32Type, {}),"main", module);
  auto bb = BasicBlock::create(module, "entry", mainFun); //创建BasicBlock
  builder->set_insert_point(bb);  //将当前插入指令点的位置设在bb
  
  auto retAlloca = builder->create_alloca(Int32Type);   // 在内存中分配返回值的位置
  
  auto aAlloca=builder->create_alloca(FloatType); //在内存中分配参数a的位置
  builder->create_store(CONST_FP(5.555), aAlloca);  //将常数5.555写入a的地址
  auto aLoad = builder->create_load(aAlloca);  //读取a
  
  auto cmp = builder->create_fcmp_gt(aLoad, CONST_FP(1.000));  //判断a是否大于1
  auto trueBB = BasicBlock::create(module, "trueBB", mainFun);    // true分支
  auto falseBB = BasicBlock::create(module, "falseBB", mainFun);  // false分支
  auto retBB = BasicBlock::create(module, "", mainFun);  // return分支,提前create,以便true分支可以br
  auto br = builder->create_cond_br(cmp, trueBB, falseBB);  // 条件BR
  
  builder->set_insert_point(trueBB);  // if true; 分支的开始需要SetInsertPoint设置
  builder->create_store(CONST_INT(233), retAlloca); //将整数233存储到返回值的地址中
  builder->create_br(retBB);  // br retBB
  
  builder->set_insert_point(falseBB);  // if false
  builder->create_store(CONST_INT(0), retAlloca);  //将整数0存储到返回值的地址中
  builder->create_br(retBB);  // br retBB

  builder->set_insert_point(retBB);  // ret分支
  auto retLoad = builder->create_load(retAlloca);  //获取返回值地址中值
  builder->create_ret(retLoad);  //创建ret指令,返回

  std::cout << module->print();
  delete module;
  return 0;
}

(2)在build目录下执行命令make生成可执行文件stu_if_generator。执行命令./stu_if_generator >if.ll，,如下是生成的if.ll中的内容

define i32 @main() {
label_entry:
  %op0 = alloca i32
  %op1 = alloca float
  store float 0x40163851e0000000, float* %op1
  %op2 = load float, float* %op1
  %op3 = fcmp ugt float %op2,0x3ff0000000000000
  br i1 %op3, label %label_trueBB, label %label_falseBB
label_trueBB:                                                ; preds = %label_entry
  store i32 233, i32* %op0
  br label %label4
label_falseBB:                                                ; preds = %label_entry
  store i32 0, i32* %op0
  br label %label4
label4:                                                ; preds = %label_trueBB, %label_falseBB
  %op5 = load i32, i32* %op0
  ret i32 %op5
}

(3)有4个basicblock,对应关系为：

  • auto bb = BasicBlock::create(module, "entry", mainFun);对应main函数中的标签label_entry
  • auto trueBB = BasicBlock::create(module, "trueBB", mainFun);对应标签label_trueBB
  • auto falseBB = BasicBlock::create(module, "falseBB", mainFun);对应标签label_falseBB
  • auto retBB = BasicBlock::create(module, "", mainFun);对应标签label4

while

(1)如下是while_generator.cpp中的内容

#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("while code");
  auto builder = new IRBuilder(nullptr, module); //该类提供了独立的接口创建各种 IR 指令
  Type *Int32Type = Type::get_int32_type(module);

  // main函数
  auto mainFun = Function::create(FunctionType::get(Int32Type, {}),"main", module);
  auto bb = BasicBlock::create(module, "entry", mainFun); //创建BasicBlock
  builder->set_insert_point(bb);  //将当前插入指令点的位置设在bb
  
  auto retAlloca = builder->create_alloca(Int32Type);   // 在内存中分配返回值的位置
  
  auto aAlloca=builder->create_alloca(Int32Type); //在内存中分配参数a的位置
  auto iAlloca=builder->create_alloca(Int32Type); //在内存中分配参数i的位置
  
  builder->create_store(CONST_INT(10), aAlloca);  //将10写入a的地址
  builder->create_store(CONST_INT(0), iAlloca);  //将0写入i的地址
  
  
  auto condBB = BasicBlock::create(module, "condBB", mainFun);  // cond分支,用于while循环的判断
  auto trueBB = BasicBlock::create(module, "trueBB", mainFun);    // true分支,条件为真时
  auto retBB = BasicBlock::create(module, "retBB", mainFun);  // ret分支,当循环条件不满足时
  builder->create_br(condBB); 
  
  builder->set_insert_point(condBB); // cond分支判断条件，分支的开始需要SetInsertPoint设置
  auto iLoad = builder->create_load(iAlloca);  //获取i地址中的值
  auto cmp = builder->create_icmp_lt(iLoad, CONST_INT(10));  //判断i是否小于10
  auto br = builder->create_cond_br(cmp, trueBB, retBB);  // 条件BR
   
  builder->set_insert_point(trueBB);  // if true; 
  auto aLoad = builder->create_load(aAlloca);  //从a地址读取a
  iLoad = builder->create_load(iAlloca);  //从i地址读取i
  auto add1=builder->create_iadd(iLoad,CONST_INT(1)); //进行i+1
  builder->create_store(add1, iAlloca); //把i+1的值写入i的地址
  iLoad = builder->create_load(iAlloca); //从i地址读取i
  auto add2=builder->create_iadd(iLoad,aLoad);//进行i+a
  builder->create_store(add2, aAlloca); //把i+a的值写入a的地址
  builder->create_br(condBB);  // br condBB
  
  builder->set_insert_point(retBB);  // ret分支
  aLoad = builder->create_load(aAlloca);  //从a地址读取a
  builder->create_store(aLoad,retAlloca ); //把a的值写入返回值的地址
  auto retLoad = builder->create_load(retAlloca);  //获取返回值地址中值
  builder->create_ret(retLoad);  //创建ret指令,返回

  std::cout << module->print();
  delete module;
  return 0;
}

(2)在build目录下执行命令make生成可执行文件stu_while_generator。执行命令./stu_while_generator >while.ll，,如下是生成的while.ll中的内容

define i32 @main() {
label_entry:
  %op0 = alloca i32
  %op1 = alloca i32
  %op2 = alloca i32
  store i32 10, i32* %op1
  store i32 0, i32* %op2
  br label %label_condBB
label_condBB:                                                ; preds = %label_entry, %label_trueBB
  %op3 = load i32, i32* %op2
  %op4 = icmp slt i32 %op3, 10
  br i1 %op4, label %label_trueBB, label %label_retBB
label_trueBB:                                                ; preds = %label_condBB
  %op5 = load i32, i32* %op1
  %op6 = load i32, i32* %op2
  %op7 = add i32 %op6, 1
  store i32 %op7, i32* %op2
  %op8 = load i32, i32* %op2
  %op9 = add i32 %op8, %op5
  store i32 %op9, i32* %op1
  br label %label_condBB
label_retBB:                                                ; preds = %label_condBB
  %op10 = load i32, i32* %op1
  store i32 %op10, i32* %op0
  %op11 = load i32, i32* %op0
  ret i32 %op11
}

(3)有4个basicblock,对应关系为：

  • auto bb = BasicBlock::create(module, "entry", mainFun);对应main函数中的标签label_entry
  • auto condBB = BasicBlock::create(module, "condBB", mainFun);对应标签label_condBB
  • auto trueBB = BasicBlock::create(module, "trueBB", mainFun);对应标签label_trueBB
  • auto retBB = BasicBlock::create(module, "retBB", mainFun);对应标签label_retBB

问题2: Visitor Pattern

请指出visitor.cpp中，treeVisitor.visit(exprRoot)执行时，以下几个Node的遍历序列:numberA、numberB、exprC、exprD、exprE、numberF、exprRoot。
序列请按如下格式指明： exprRoot->numberF->exprE->numberA->exprD

答：遍历的树如下所示。从三个visit方法可以看出,遍历序列为：
exprRoot->numberF->exprE->exprD->numberB->numberA->exprC->numberA->exprB

输入图片说明

问题3: getelementptr

请给出IR.md中提到的两种getelementptr用法的区别,并稍加解释:

  • %2 = getelementptr [10 x i32], [10 x i32]* %1, i32 0, i32 %0
  • %2 = getelementptr i32, i32* %1 i32 %0

答 ：getelementptr指令用于获取聚合数据结构的子元素的地址。它仅执行地址计算，不访问内存。

  • 第一种方法：数组在C中会分割指针，但在LLVM IR中,它只能确定数组类型的大小然后强制转换为指针，但不会分割它们。%1是我们的基址，有两个索引0和%0。因为它是数组，但是我们是通过指针访问它，所以我们需要两个索引：第一个用于分割指针(因为用的指针是[10 x i32]，但是我们返回的是一个i32的，所以需要分割)，第二个用于索引数组本身（即偏移量）。该方法适用的数组为int nums[] = {1, 2, 3};或者int a[10]，例如在assign.ll中定义数组a[10]后获取a[0],a[1]用的是这个方式。
define i32 @main() {
label_entry:
  %op0 = alloca i32
  %op1 = alloca [10 x i32]
  %op2 = getelementptr [10 x i32], [10 x i32]* %op1, i32 0, i32 0
  store i32 10, i32* %op2
  %op3 = load i32, i32* %op2
  %op4 = mul i32 %op3, 2
  %op5 = getelementptr [10 x i32], [10 x i32]* %op1, i32 0, i32 1
  store i32 %op4, i32* %op5
  %op6 = load i32, i32* %op5
  store i32 %op6, i32* %op0
  %op7 = load i32, i32* %op0
  ret i32 %op7
}
  • 第二种方法：%1做为我们的基址地址，%0做为我们的索引（偏移量），并把计算出来的地址给%2。该方法适用的数组为int *nums = {1, 2, 3};

实验难点

描述在实验中遇到的问题、分析和解决方案

  1. 实验过程中需要先看懂助教所给的样例，把gcd_array.c中的内容分别和gcd_array.ll和gcd_array_generator.cpp对应起来，然后再查看一些LLVM IR的相关资料才能较顺利地完成。
  2. 在填写if_hand.ll文件时，有一句C语句是float a = 5.555;即要给浮点数a赋值为5.555，样例gcd_array.c并没有使用浮点数类型，所以就模仿整数赋值方式，得到了如下语句store float 5.555, float* %1。但是编译运行时报错了，后面查找资料后才知道不能这样写，因为5.555转化成二进制是无限循环的（只能近似表示），而编译器只接受精确的小数，所以需要换一种表示，即store float 0x40163851E0000000, float* %1。
  3. 在回答第三个问题的过程中，即思考两种getelementptr用法的区别时，查阅了大量的英文文档，才弄明白真正的区别。
焦妮敲代码
关注
专栏目录
CMinus_Compiler.rar_cminus_cminus 编译器_cminus编译原理_cminus编译器
09-24
下载并解压"CMinus_Compiler.rar"后，你可以通过VC++环境编译并运行源代码。然后，你可以逐步调试和修改代码，以观察不同阶段的变化，加深对编译器原理的理解。 总之，CMinus 编译器是一个优秀的教学工具，可以帮助...
HNU编译原理实验三cminus_compiler-2022-fall
jzb的博客
12-28 1647
实验难度再次提升，不过会一个就可以做其他部分，很多都是相同的，个人认为更难的还是配置环境部分，真的会折磨死人。
编译实验lab5：中间代码生成（未完待续）
kaikai_2021的博客
11-04 650
编译技术实验 SysY 北航 中间代码生成 LLVM
编译原理实验四
12-15 2118
HNU编译原理实验四
LLVM IR格式的基本介绍
weixin_43854617的博客
11-03 1239
LLVM IR是连接前端和后端的桥梁，它使得LLVM可以解析多种源语言，并为多个目标生成代码。
湖南大学编译原理实验三：词法分析（TINY语言）
Moyu-42的博客
12-06 930
代码链接：编译原理实验三 文章目录实验三 语法分析程序（一）学习经典的语法分析器（1学时）一、实验目的二、实验任务三、实验内容（二）实现一门语言的语法分析器（3学时）一、实验目的二、实验任务三、实验内容实验步骤学习经典的语法分析器（TINY）实现一门语言的语法分析器（TINY）语言确定BNF文法到EBNF文法的转换抽象语法树结构语法分析器LL(1)语法分析器的实现基础数据存储方式解析产生式NULLABLE集合计算FIRST集合计算FOLLOW集合计算FIRST_S集合计算产生预测分析表parse语法分析生成
Linux ll 文件详解
qq_31304765的博客
07-20 1008
CMinus_Compiler:你好
03-28
CMinus_Compiler是一个基于Python实现的简易C-减小（C-Minus）语言的编译器。这个项目可能是一个教学工具或编程练习，用于帮助学习者理解编译器的工作原理和构建过程。C-Minus是一种简化版的C语言，通常在计算机科学...
基于C++的湖南大学2021年秋季编译原理课程实验设计源码
最新发布
10-05
该项目是湖南大学信息科学与工程学院2021年秋季编译原理课程实验设计的源码，采用C++作为主要编程语言，同时融入了C、Python和Shell等辅助语言。项目文件总计220个，其中包含58个Cminus源文件、23个C++源文件、20个...
CMinus-Compiler.rar_cminus
09-19
CMinus编译器，以其独特的命名"CMinus-Compiler.rar_cminus"，是用C语言实现的一个简单C语言变体的编译器。这个项目旨在帮助开发者和学生了解编译器的工作原理，特别是词法分析和语法解析这两个关键步骤。在深入探讨...
C语言 设计模式之访问者模式
08-31
主要介绍了C语言 设计模式之访问者模式的相关资料,需要的朋友可以参考下
编译原理实验四 编译器自动生成工具
12-20
在本实验中，我们将深入探讨“编译原理”，这是一个计算机科学的重要领域，主要涉及将高级编程语言转换为机器可理解的二进制代码的过程。实验的主题是“编译器自动生成工具”，它包括了FLEX和BISON这两个关键工具，...
湖南大学编译原理实验一：词法分析(TINY)
Moyu-42的博客
11-28 980
由于这部分的代码我也是抄的，可以参考给出的 tiny_tm 文件夹中 scan.c 文件的逻辑，所以我这里就不贴啥了，需要代码的可以去 实验1
HNU_编译原理_实验4（2021级）
蟑螂恶霸的博客
01-26 1092
在C++中创建LLVM IR常量的宏。用于创建常量浮点值，指定类型的零常量，创建常量整数，获取整数和浮点数类型。这些宏用于简化在 LLVM IR 中创建常量整数以及获取整数和浮点数类型的操作。CONST_FP用于创建常量浮点值；CONST_ZERO用于创建指定类型的零常量。用于创建一个常量整数。num是传递给宏的整数值。使用 LLVM 提供的函数来创建一个常量整数。(int)num是将传递的参数num强制转换为整数类型。是获取 LLVM 模块的指针，该模块是用于构建 LLVM IR 的基本结构。
湖南大学编译原理实验五：语义分析器
Moyu-42的博客
12-29 3498
说在前面 实验四哪里去了？ : 我也不会写，所以我也是抄的 Q：实验五是我自己写的吗？ : 不是。因为我之前写的Tiny，但是到了这个实验，没有Tiny可以写了，所以不得不写C-，但我不可能再把之前的实验做一遍，所以抄了别人之前实验的代码。这次的语义分析器也是借鉴了其完整的C-编译器的部分，进行了相应的修改。 ...
【LLVM】基本文件格式和 CFG 生成指令
weixin_45651194的博客
03-08 1165
指令将字节码转为汇编代码，llc 是 llvm 的后端，所谓后端指的是与某种指令集相关的部分，如 ARM、x86 等。clang 是 llvm 的前端，若我们需要得到 llvm 字节码，之后再对字节码做一些操作，可以用。一般 C 语言编译器（ gcc 或 clang ）执行后直接将源码。这种方式产生的 dot 文件在 /tmp/…这种方式产生的 dot 文件在当前目录下，但为隐藏文件，需要。以上方式产生的都是内部 CFG（intra CFG）。若需要将字节码转为文本，使用。变为可执行二进制文件。
LLVM12第三章之语义分析
qq_42909352的博客
12-17 267
基于llvm的Calc语义分析
HNU_编译原理_实验3（2021级）
蟑螂恶霸的博客
01-26 911
编译原理 lab3 实验报告
HNU-编译原理-实验4-cminus-f语言（由AST生成IR）
wolf的博客
01-16 1256
1. 阅读[cminus-f 的语义规则](../common/cminusf.md)，助教将按照语义实现程度进行评分 2. 阅读[LightIR 核心类介绍](../common/LightIR.md) 3. 阅读实验框架，理解如何使用框架以及注意事项 4. 修改 `src/cminusfc/cminusf_builder.cpp` 来实现自动 IR 产生的算法，使得它能正确编译任何合法的 cminus-f 程序 5. 在 `report.md` 中解释该设计，遇到的困难和解决方案
2023秋季编译原理实验报告及Cminus编译器解析
压缩包文件名称列表中的“cminus_compiler-2023-fall-master”可能是指一个与C语言密切相关的编译器项目，Cminus是C语言的一个简化版本，它可能被用作教学目的来帮助学生更好地理解编译原理。项目的名称“cminus_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

焦妮敲代码

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值