|
|
#include "IRBuilder.h"
|
|
|
|
|
|
#include <iostream>
|
|
|
#include <assert.h>
|
|
|
#include <vector>
|
|
|
|
|
|
#define DEBUG
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
#define DBGLOG(text) std::cout << text << std::endl
|
|
|
#define DEBUG_OUTPUT ;
|
|
|
#endif
|
|
|
#ifndef DEBUG
|
|
|
#define DBGLOG(text)
|
|
|
#define DEBUG_OUTPUT std::cout << __LINE__ << std::endl
|
|
|
#endif
|
|
|
|
|
|
namespace SysYF
|
|
|
{
|
|
|
namespace IR
|
|
|
{
|
|
|
#define CONST_INT(num) ConstantInt::create(num, module)
|
|
|
#define CONST_FLOAT(num) ConstantFloat::create(num, module)
|
|
|
|
|
|
// You can define global variables here
|
|
|
// to store state
|
|
|
typedef struct
|
|
|
{
|
|
|
bool is_int;
|
|
|
int ival;
|
|
|
float fval;
|
|
|
} Oprand;
|
|
|
Oprand expr_cal_result; // 便于全局变量中表达式计算值中转
|
|
|
std::vector<Oprand> multi_arr_init;
|
|
|
class GlobalConst
|
|
|
{
|
|
|
public:
|
|
|
GlobalConst() {}
|
|
|
~GlobalConst() = default;
|
|
|
void add_int_const(std::string name, int val)
|
|
|
{
|
|
|
if (iconst_map.find(name) == iconst_map.end())
|
|
|
{ // 新加入的不是数组元素
|
|
|
std::vector<int> temp(1, val);
|
|
|
iconst_map.insert(std::make_pair(name, temp));
|
|
|
}
|
|
|
else // 新加入的是数组元素
|
|
|
iconst_map[name].push_back(val);
|
|
|
}
|
|
|
void add_float_const(std::string name, float val)
|
|
|
{
|
|
|
if (fconst_map.find(name) == fconst_map.end())
|
|
|
{ // 新加入的不是数组元素
|
|
|
std::vector<float> temp(1, val);
|
|
|
fconst_map.insert(std::make_pair(name, temp));
|
|
|
}
|
|
|
else // 新加入的是数组元素
|
|
|
fconst_map[name].push_back(val);
|
|
|
}
|
|
|
bool get_int_const(std::string name, int offset, int &val) // 若非数组则offset=0
|
|
|
{
|
|
|
if (iconst_map.find(name) != iconst_map.end())
|
|
|
{
|
|
|
val = iconst_map[name][offset];
|
|
|
return true;
|
|
|
}
|
|
|
else
|
|
|
return false;
|
|
|
}
|
|
|
bool get_float_const(std::string name, int offset, float &val)
|
|
|
{
|
|
|
if (fconst_map.find(name) != fconst_map.end())
|
|
|
{
|
|
|
val = fconst_map[name][offset];
|
|
|
return true;
|
|
|
}
|
|
|
else
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
private:
|
|
|
std::map<std::string, std::vector<int>> iconst_map;
|
|
|
std::map<std::string, std::vector<float>> fconst_map;
|
|
|
};
|
|
|
GlobalConst _const_table = GlobalConst();
|
|
|
|
|
|
std::vector<SysYF::Ptr<Type>> FuncParas;
|
|
|
SysYF::Ptr<Type> Para;
|
|
|
std::string name_;
|
|
|
std::vector<std::string> names;
|
|
|
|
|
|
int Ifnum = 0;
|
|
|
int ReturnNum = 0;
|
|
|
Ptr<AllocaInst> retAlloca;
|
|
|
SysYF::Ptr<SysYF::IR::BasicBlock> retbb;
|
|
|
|
|
|
/* enum Condtype
|
|
|
{
|
|
|
equal,
|
|
|
greater,
|
|
|
less,
|
|
|
ge,
|
|
|
le,
|
|
|
notequal
|
|
|
|
|
|
}condtype_; */
|
|
|
/* SysYF::Ptr<SysYF::IR::CmpInst> _cmp; */
|
|
|
// store temporary value
|
|
|
Ptr<Value> tmp_val = nullptr; // 存储需要全局处理的expr node
|
|
|
Ptr<Value> lhs_addr = nullptr;
|
|
|
Ptr<Function> func_parent; // 便于在创建新的bb时获得对应的func_parent
|
|
|
int bb_label_num = 0; // 全局控制bb标签编号
|
|
|
bool func_first_bb; // 处理一个func域里有多个{}，只创建一个scope
|
|
|
PtrVec<BasicBlock> break_point;
|
|
|
PtrVec<BasicBlock> continue_point; // 维护两个vector(栈)控制循环break和continue应跳转到的目标地址
|
|
|
// types
|
|
|
Ptr<Type> VOID_T;
|
|
|
Ptr<Type> INT1_T;
|
|
|
Ptr<Type> INT32_T;
|
|
|
Ptr<Type> FLOAT_T;
|
|
|
Ptr<Type> INT32PTR_T;
|
|
|
Ptr<Type> FLOATPTR_T;
|
|
|
|
|
|
void IRBuilder::visit(SyntaxTree::Assembly &node)
|
|
|
{
|
|
|
VOID_T = Type::get_void_type(module);
|
|
|
INT1_T = Type::get_int1_type(module);
|
|
|
INT32_T = Type::get_int32_type(module);
|
|
|
FLOAT_T = Type::get_float_type(module);
|
|
|
INT32PTR_T = Type::get_int32_ptr_type(module);
|
|
|
FLOATPTR_T = Type::get_float_ptr_type(module);
|
|
|
for (const auto &def : node.global_defs)
|
|
|
{
|
|
|
def->accept(*this);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// You need to fill them
|
|
|
|
|
|
void IRBuilder::visit(SyntaxTree::InitVal &node)
|
|
|
{
|
|
|
/* DBGLOG("Begin of Initval"); */
|
|
|
// 可能有一个或多个value需要初始化，elementList方便迭代accept
|
|
|
if (node.isExp)
|
|
|
{
|
|
|
node.expr->accept(*this);
|
|
|
multi_arr_init.push_back(expr_cal_result);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
for (auto item : node.elementList)
|
|
|
{
|
|
|
item->accept(*this);
|
|
|
}
|
|
|
}
|
|
|
/* DBGLOG("End of Initval"); */
|
|
|
}
|
|
|
|
|
|
void IRBuilder::visit(SyntaxTree::FuncDef &node)
|
|
|
{
|
|
|
/* DBGLOG("Begin of FuncDef"); */
|
|
|
Ptr<Type> RetType;
|
|
|
switch (node.ret_type)
|
|
|
{
|
|
|
case SysYF::SyntaxTree::Type::VOID:
|
|
|
RetType = VOID_T;
|
|
|
break;
|
|
|
case SysYF::SyntaxTree::Type::INT:
|
|
|
RetType = INT32_T;
|
|
|
break;
|
|
|
case SysYF::SyntaxTree::Type::FLOAT:
|
|
|
RetType = FLOAT_T;
|
|
|
break;
|
|
|
default:
|
|
|
break;
|
|
|
}
|
|
|
node.param_list->accept(*this);
|
|
|
auto FuncTY = FunctionType::create(RetType, FuncParas);
|
|
|
auto Func = Function::create(FuncTY, node.name, module);
|
|
|
func_parent = Func; // 标记当前func_parent（便于后续bb调用）
|
|
|
|
|
|
scope.push(node.name, Func);
|
|
|
scope.enter();
|
|
|
auto bb = BasicBlock::create(module, node.name + "_entry", Func);
|
|
|
builder->set_insert_point(bb);
|
|
|
func_first_bb = true; // 设置为第一次进入该func的bb{}
|
|
|
|
|
|
ReturnNum = 0;
|
|
|
|
|
|
if (RetType != VOID_T)
|
|
|
{
|
|
|
retAlloca = builder->create_alloca(RetType);
|
|
|
if (RetType == INT32_T)
|
|
|
builder->create_store(CONST_INT(0), retAlloca);
|
|
|
else if (RetType == FLOAT_T)
|
|
|
builder->create_store(CONST_FLOAT(0), retAlloca);
|
|
|
}
|
|
|
|
|
|
std::vector<SysYF::Ptr<Value>> args;
|
|
|
for (auto arg = Func->arg_begin(); arg != Func->arg_end(); arg++)
|
|
|
{
|
|
|
args.push_back(*arg);
|
|
|
}
|
|
|
for (size_t i = 0; i < names.size(); i++)
|
|
|
{
|
|
|
auto pAlloca = builder->create_alloca(FuncParas[i]);
|
|
|
builder->create_store(args[i], pAlloca);
|
|
|
scope.push(names[i], pAlloca);
|
|
|
}
|
|
|
|
|
|
retbb = BasicBlock::create(module, node.name + "_ret", Func);
|
|
|
|
|
|
node.body->accept(*this);
|
|
|
|
|
|
if (!builder->get_insert_block()->get_terminator())
|
|
|
builder->create_br(retbb);
|
|
|
|
|
|
builder->set_insert_point(retbb);
|
|
|
if (RetType == VOID_T)
|
|
|
{
|
|
|
builder->create_void_ret();
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
auto retLoad = builder->create_load(retAlloca);
|
|
|
builder->create_ret(retLoad);
|
|
|
}
|
|
|
/* builder->create_br(retbb); */
|
|
|
/* scope.exit(); */
|
|
|
/* DBGLOG("End of FuncDef"); */
|
|
|
}
|
|
|
|
|
|
void IRBuilder::visit(SyntaxTree::FuncFParamList &node)
|
|
|
{
|
|
|
FuncParas.clear();
|
|
|
names.clear();
|
|
|
for (auto &p : node.params)
|
|
|
{
|
|
|
p->accept(*this);
|
|
|
FuncParas.push_back(Para);
|
|
|
names.push_back(name_);
|
|
|
}
|
|
|
assert(FuncParas.size() == names.size());
|
|
|
}
|
|
|
|
|
|
void IRBuilder::visit(SyntaxTree::FuncParam &node)
|
|
|
{
|
|
|
name_ = node.name;
|
|
|
if (node.array_index.size())
|
|
|
{
|
|
|
// 数组
|
|
|
if (node.param_type == SysYF::SyntaxTree::Type::INT)
|
|
|
Para = INT32PTR_T;
|
|
|
else if (node.param_type == SysYF::SyntaxTree::Type::FLOAT)
|
|
|
Para = FLOATPTR_T;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
// 非数组
|
|
|
if (node.param_type == SysYF::SyntaxTree::Type::INT)
|
|
|
Para = INT32_T;
|
|
|
else if (node.param_type == SysYF::SyntaxTree::Type::FLOAT)
|
|
|
Para = FLOAT_T;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void IRBuilder::visit(SyntaxTree::VarDef &node)
|
|
|
{
|
|
|
/* DBGLOG("Begin of VarDef"); */
|
|
|
// 变量定义：判断是否是全局变量，判断是否是const，判断是否是数组类型
|
|
|
// 获取变量类型和变量名字，分配变量存储空间，若有需要初始化变量
|
|
|
Ptr<Type> vartype;
|
|
|
if (node.btype == SyntaxTree::Type::INT)
|
|
|
vartype = INT32_T;
|
|
|
else
|
|
|
vartype = FLOAT_T;
|
|
|
// if分级判断逻辑：全局or局部->数组or单变量->const of 非const（本次实验不涉及局部数组常量)->初始化or未初始化
|
|
|
if (scope.in_global()) // 全局变量
|
|
|
{
|
|
|
if (!node.array_length.empty()) // 数组类型
|
|
|
{
|
|
|
// 目前只考虑一维数组，多维数组需要处理vector类型的array_length得到各维度长度
|
|
|
std::vector<int> arr_len;
|
|
|
unsigned total_ = 1;
|
|
|
for (int i = 0; i < node.array_length.size(); i++)
|
|
|
{
|
|
|
node.array_length[i]->accept(*this);
|
|
|
arr_len.push_back(expr_cal_result.ival);
|
|
|
total_ *= expr_cal_result.ival;
|
|
|
}
|
|
|
Ptr<ArrayType> arr_type = ArrayType::create(vartype, total_);
|
|
|
if (node.is_inited)
|
|
|
{
|
|
|
PtrVec<Constant> init_val; // 待push_back,多维转线性排列
|
|
|
int last_dim = arr_len.back();
|
|
|
int line_idx = 0;
|
|
|
for (auto val : node.initializers->elementList) // 每一个val都是一个InitVal，可能是expr，也可能是elementlist
|
|
|
{
|
|
|
multi_arr_init.clear();
|
|
|
val->accept(*this);
|
|
|
for (int i = 0; i < multi_arr_init.size(); i++)
|
|
|
{
|
|
|
Oprand tmp = multi_arr_init[i];
|
|
|
if (vartype == INT32_T)
|
|
|
{
|
|
|
int temp = (tmp.is_int) ? tmp.ival : int(tmp.fval);
|
|
|
init_val.push_back(std::static_pointer_cast<Constant>(CONST_INT(temp)));
|
|
|
if (node.is_constant)
|
|
|
_const_table.add_int_const(node.name, temp);
|
|
|
}
|
|
|
else if (vartype == FLOAT_T)
|
|
|
{
|
|
|
float temp = (tmp.is_int) ? float(tmp.ival) : tmp.fval;
|
|
|
init_val.push_back(std::static_pointer_cast<Constant>(CONST_FLOAT(temp)));
|
|
|
if (node.is_constant)
|
|
|
_const_table.add_float_const(node.name, temp);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
}
|
|
|
// 全局变量剩余部分初始化为0
|
|
|
for (int i = init_val.size(); i < arr_len; i++)
|
|
|
{
|
|
|
if (vartype == INT32_T)
|
|
|
{
|
|
|
init_val.push_back(std::static_pointer_cast<Constant>(CONST_INT(0)));
|
|
|
if (node.is_constant)
|
|
|
_const_table.add_int_const(node.name, 0);
|
|
|
}
|
|
|
else if (vartype == FLOAT_T)
|
|
|
{
|
|
|
init_val.push_back(std::static_pointer_cast<Constant>(CONST_FLOAT(0)));
|
|
|
if (node.is_constant)
|
|
|
_const_table.add_float_const(node.name, 0.0f);
|
|
|
}
|
|
|
}
|
|
|
auto initializer = ConstantArray::create(arr_type, init_val);
|
|
|
auto Global_array = GlobalVariable::create(node.name, module, arr_type, node.is_constant, std::static_pointer_cast<Constant>(initializer));
|
|
|
scope.push(node.name, Global_array);
|
|
|
}
|
|
|
else // 未显式初始化，全为0
|
|
|
{
|
|
|
if (node.is_constant)
|
|
|
{
|
|
|
for (int i = 0; i < arr_len; i++)
|
|
|
{
|
|
|
if (vartype == INT32_T)
|
|
|
_const_table.add_int_const(node.name, 0);
|
|
|
else
|
|
|
_const_table.add_float_const(node.name, 0.0f);
|
|
|
}
|
|
|
}
|
|
|
auto initializer = ConstantZero::create(arr_type, module);
|
|
|
auto Global_array = GlobalVariable::create(node.name, module, arr_type, node.is_constant, std::static_pointer_cast<Constant>(initializer));
|
|
|
scope.push(node.name, Global_array);
|
|
|
}
|
|
|
}
|
|
|
else // 单变量
|
|
|
{
|
|
|
if (node.is_inited)
|
|
|
{ // 只能是Ptr<Expr>类型
|
|
|
node.initializers->expr->accept(*this);
|
|
|
Ptr<Constant> init_val;
|
|
|
if (vartype == INT32_T)
|
|
|
{
|
|
|
int temp = (expr_cal_result.is_int) ? expr_cal_result.ival : int(expr_cal_result.fval);
|
|
|
init_val = std::static_pointer_cast<Constant>(CONST_INT(temp));
|
|
|
if (node.is_constant)
|
|
|
_const_table.add_int_const(node.name, temp);
|
|
|
}
|
|
|
else if (vartype == FLOAT_T)
|
|
|
{
|
|
|
float temp = (expr_cal_result.is_int) ? float(expr_cal_result.ival) : expr_cal_result.fval;
|
|
|
init_val = std::static_pointer_cast<Constant>(CONST_FLOAT(temp));
|
|
|
if (node.is_constant)
|
|
|
_const_table.add_float_const(node.name, temp);
|
|
|
}
|
|
|
auto Global_val = GlobalVariable::create(node.name, module, vartype, node.is_constant, init_val);
|
|
|
scope.push(node.name, Global_val);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (node.is_constant)
|
|
|
{
|
|
|
if (vartype == INT32_T)
|
|
|
_const_table.add_int_const(node.name, 0);
|
|
|
else
|
|
|
_const_table.add_float_const(node.name, 0.0f);
|
|
|
}
|
|
|
auto init_val = ConstantZero::create(vartype, module);
|
|
|
auto Global_val = GlobalVariable::create(node.name, module, vartype, node.is_constant, std::static_pointer_cast<Constant>(init_val));
|
|
|
scope.push(node.name, Global_val);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else // 局部变量
|
|
|
{
|
|
|
if (!node.array_length.empty()) // 数组类型(不考虑const数组)
|
|
|
{
|
|
|
node.array_length[0]->accept(*this);
|
|
|
int arr_len = expr_cal_result.ival;
|
|
|
/* DBGLOG(arr_len); */
|
|
|
Ptr<ArrayType> arr_type = ArrayType::get(vartype, arr_len);
|
|
|
/* Ptr<PointerType> arr_type = PointerType::get(vartype); */
|
|
|
auto arr_val_alloca = builder->create_alloca(arr_type);
|
|
|
|
|
|
if (node.is_inited) // 若未显式初始化，则初始值未知
|
|
|
{
|
|
|
/* DBGLOG(node.initializers->elementList.size()); */
|
|
|
int arrIdx = 0; // gep类指令计算每个元素地址
|
|
|
for (auto val : node.initializers->elementList)
|
|
|
{
|
|
|
val->expr->accept(*this);
|
|
|
// 此时的类型转换IR指令为显式的
|
|
|
if (tmp_val->get_type() != vartype) // tmp_val为Ptr<Value>类型，便于生成类型转换IR
|
|
|
{
|
|
|
if (vartype == INT32_T)
|
|
|
tmp_val = builder->create_fptosi(tmp_val, INT32_T);
|
|
|
else
|
|
|
tmp_val = builder->create_sitofp(tmp_val, FLOAT_T);
|
|
|
}
|
|
|
// 根据初始化值store到对应的gep地址中
|
|
|
auto val_addr = builder->create_gep(arr_val_alloca, {CONST_INT(0), CONST_INT(arrIdx)});
|
|
|
builder->create_store(tmp_val, val_addr);
|
|
|
arrIdx++;
|
|
|
}
|
|
|
}
|
|
|
scope.push(node.name, arr_val_alloca);
|
|
|
}
|
|
|
else // 单变量， tmp_val便于发射类型转换ir，expr_cal_result便于维护常量表
|
|
|
{
|
|
|
auto var_alloca = builder->create_alloca(vartype);
|
|
|
if (node.is_inited)
|
|
|
{
|
|
|
node.initializers->expr->accept(*this);
|
|
|
if (tmp_val->get_type() != vartype)
|
|
|
{
|
|
|
if (vartype == INT32_T)
|
|
|
tmp_val = builder->create_fptosi(tmp_val, INT32_T);
|
|
|
else
|
|
|
tmp_val = builder->create_sitofp(tmp_val, FLOAT_T);
|
|
|
}
|
|
|
if (node.is_constant)
|
|
|
{
|
|
|
if (vartype == INT32_T)
|
|
|
{
|
|
|
int temp = (expr_cal_result.is_int) ? expr_cal_result.ival : int(expr_cal_result.fval);
|
|
|
_const_table.add_int_const(node.name, temp);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
float temp = (expr_cal_result.is_int) ? float(expr_cal_result.ival) : expr_cal_result.fval;
|
|
|
_const_table.add_float_const(node.name, temp);
|
|
|
}
|
|
|
}
|
|
|
builder->create_store(tmp_val, var_alloca);
|
|
|
}
|
|
|
scope.push(node.name, var_alloca);
|
|
|
}
|
|
|
}
|
|
|
/* DBGLOG("End of VarDef"); */
|
|
|
}
|
|
|
|
|
|
void IRBuilder::visit(SyntaxTree::LVal &node)
|
|
|
{
|
|
|
/* DBGLOG("Begin of LVal"); */
|
|
|
/* DBGLOG(node.name); */
|
|
|
if (scope.in_global()) // 在全局变量初始化时，InitVal 中的初始值为 Exp时可以引用左值变量
|
|
|
{
|
|
|
/* DBGLOG("Begin of LVal if"); */
|
|
|
int tmp1;
|
|
|
float tmp2;
|
|
|
int offset = 0;
|
|
|
if (!node.array_index.empty())
|
|
|
{
|
|
|
// 暂时只考虑一维数组
|
|
|
node.array_index[0]->accept(*this);
|
|
|
offset = expr_cal_result.ival;
|
|
|
}
|
|
|
if (_const_table.get_int_const(node.name, offset, tmp1))
|
|
|
{
|
|
|
expr_cal_result.is_int = true;
|
|
|
expr_cal_result.ival = tmp1;
|
|
|
}
|
|
|
else if (_const_table.get_float_const(node.name, offset, tmp2))
|
|
|
{
|
|
|
expr_cal_result.is_int = false;
|
|
|
expr_cal_result.fval = tmp2;
|
|
|
}
|
|
|
}
|
|
|
else // 并非处于全局域，左值为被赋值对象（store)或赋值对象(load)(函数调用的情形在funcall里处理)
|
|
|
{
|
|
|
/* DBGLOG("Begin of LVal else"); */
|
|
|
auto lval_addr = scope.find(node.name, false);
|
|
|
bool IsArray = false;
|
|
|
if (!node.array_index.empty()) // 数组左值, 需要先发射gep指令，再发射load指令
|
|
|
{
|
|
|
/* DBGLOG("array"); */
|
|
|
node.array_index[0]->accept(*this);
|
|
|
assert(lval_addr != nullptr);
|
|
|
/* DBGLOG(node.name);
|
|
|
DBGLOG(lval_addr->get_type()->get_type_id()); */
|
|
|
// DEBUG_OUTPUT;
|
|
|
|
|
|
if (lval_addr->get_type()->get_pointer_element_type()->is_array_type()) // 左值非指针
|
|
|
{
|
|
|
/* DBGLOG("In LVal array"); */ // a[4]
|
|
|
auto lval = builder->create_gep(lval_addr, {CONST_INT(0), tmp_val});
|
|
|
lhs_addr = lval;
|
|
|
tmp_val = builder->create_load(lval);
|
|
|
IsArray = true;
|
|
|
}
|
|
|
else // 左值是指针
|
|
|
{ //(*a)[4]
|
|
|
|
|
|
auto ptr = builder->create_load(lval_addr);
|
|
|
auto lval = builder->create_gep(ptr, {tmp_val}); // 没有CONST_INT(0)，基址是ptr
|
|
|
lhs_addr = lval;
|
|
|
tmp_val = builder->create_load(lval);
|
|
|
}
|
|
|
}
|
|
|
else if (lval_addr->get_type()->get_pointer_element_type()->is_pointer_type())
|
|
|
{ //*a
|
|
|
tmp_val = builder->create_load(lval_addr); // load得到的是指针值
|
|
|
lhs_addr = lval_addr;
|
|
|
}
|
|
|
else
|
|
|
{ // a
|
|
|
tmp_val = builder->create_load(lval_addr);
|
|
|
lhs_addr = lval_addr;
|
|
|
}
|
|
|
}
|
|
|
/* DBGLOG("End of LVal"); */
|
|
|
}
|
|
|
|
|
|
void IRBuilder::visit(SyntaxTree::AssignStmt &node)
|
|
|
{
|
|
|
/* DBGLOG("Begin of Assign");
|
|
|
*/
|
|
|
/* DBGLOG(node.target->name); */
|
|
|
node.target->accept(*this);
|
|
|
auto lhs = tmp_val;
|
|
|
auto lhs_addr_ = lhs_addr;
|
|
|
node.value->accept(*this);
|
|
|
auto rhs = tmp_val;
|
|
|
auto lhstype = lhs->get_type(); // 获左值类型
|
|
|
|
|
|
/* DBGLOG(lhstype->get_type_id()); */
|
|
|
auto rhstype = rhs->get_type();
|
|
|
/* DBGLOG(rhstype->get_type_id()); */
|
|
|
// 检查是否需要显式类型转换和符号扩展ir指令
|
|
|
if (rhstype == INT1_T)
|
|
|
{
|
|
|
rhs = builder->create_zext(rhs, INT32_T);
|
|
|
rhstype = INT32_T;
|
|
|
}
|
|
|
if (lhstype != rhstype)
|
|
|
{
|
|
|
if (lhstype == INT32_T)
|
|
|
rhs = builder->create_fptosi(rhs, INT32_T);
|
|
|
else
|
|
|
{
|
|
|
/* DBGLOG("create "); */
|
|
|
rhs = builder->create_sitofp(rhs, FLOAT_T);
|
|
|
}
|
|
|
}
|
|
|
builder->create_store(rhs, lhs_addr_);
|
|
|
/* DBGLOG("End of Assign"); */
|
|
|
}
|
|
|
|
|
|
void IRBuilder::visit(SyntaxTree::Literal &node)
|
|
|
{
|
|
|
/* DBGLOG("Begin of Literal"); */
|
|
|
if (node.literal_type == SyntaxTree::Type::INT)
|
|
|
{
|
|
|
tmp_val = CONST_INT(node.int_const);
|
|
|
expr_cal_result.is_int = true;
|
|
|
expr_cal_result.ival = node.int_const;
|
|
|
}
|
|
|
else if (node.literal_type == SyntaxTree::Type::FLOAT)
|
|
|
{
|
|
|
tmp_val = CONST_FLOAT(node.float_const);
|
|
|
expr_cal_result.is_int = false;
|
|
|
expr_cal_result.fval = node.float_const;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
// DBGLOG("error at literal");
|
|
|
}
|
|
|
|
|
|
/* DBGLOG("End of Literal"); */
|
|
|
}
|
|
|
|
|
|
void IRBuilder::visit(SyntaxTree::ReturnStmt &node)
|
|
|
{
|
|
|
/* DBGLOG("Begin of Return"); */
|
|
|
auto RetType = builder->get_insert_block()->get_parent()->get_return_type();
|
|
|
/* auto funName = builder->get_insert_block()->get_parent()->get_name();
|
|
|
char num_[10];
|
|
|
sprintf(num_, "%d", ReturnNum++); */
|
|
|
/* retbb = BasicBlock::create(module, funName + "_ret_" + num_, func_parent);
|
|
|
*/
|
|
|
if (!RetType->is_void_type())
|
|
|
{
|
|
|
node.ret->accept(*this);
|
|
|
auto tmpType = tmp_val->get_type();
|
|
|
/* builder->create_br(retbb);
|
|
|
builder->set_insert_point(retbb); */
|
|
|
if (tmpType != RetType)
|
|
|
{
|
|
|
if (RetType == FLOAT_T)
|
|
|
{
|
|
|
if (tmpType == INT1_T)
|
|
|
// INT1 to INT32
|
|
|
tmp_val = builder->create_zext(tmp_val, INT32_T);
|
|
|
// INT32 to FLOAT
|
|
|
tmp_val = builder->create_sitofp(tmp_val, FLOAT_T);
|
|
|
}
|
|
|
else if (RetType == INT32_T)
|
|
|
{
|
|
|
// INT1 to INT32
|
|
|
if (tmpType == INT1_T)
|
|
|
tmp_val = builder->create_zext(tmp_val, INT32_T);
|
|
|
else if (tmpType == FLOAT_T)
|
|
|
// FLOAT to INT32
|
|
|
tmp_val = builder->create_fptosi(tmp_val, INT32_T);
|
|
|
}
|
|
|
}
|
|
|
builder->create_store(tmp_val, retAlloca);
|
|
|
}
|
|
|
builder->create_br(retbb);
|
|
|
/* DBGLOG("End of Return"); */
|
|
|
}
|
|
|
|
|
|
void IRBuilder::visit(SyntaxTree::BlockStmt &node)
|
|
|
{
|
|
|
if (func_first_bb == true)
|
|
|
func_first_bb = false; // 后续不是firstbb
|
|
|
else
|
|
|
scope.enter();
|
|
|
for (auto stmt : node.body)
|
|
|
{
|
|
|
stmt->accept(*this);
|
|
|
}
|
|
|
scope.exit();
|
|
|
}
|
|
|
|
|
|
void IRBuilder::visit(SyntaxTree::EmptyStmt &node) {}
|
|
|
|
|
|
void IRBuilder::visit(SyntaxTree::ExprStmt &node)
|
|
|
{
|
|
|
node.exp->accept(*this);
|
|
|
}
|
|
|
|
|
|
void IRBuilder::visit(SyntaxTree::UnaryCondExpr &node)
|
|
|
{
|
|
|
// 返回icmp或/fcmp与0相比的结果到全局变量tmp_val,发射对应ir指令
|
|
|
node.rhs->accept(*this);
|
|
|
auto rhs = tmp_val;
|
|
|
auto rhstype = rhs->get_type();
|
|
|
if (node.op == SyntaxTree::UnaryCondOp::NOT) // 只有!非号需要处理，否则不形成UnaryCondExpr结点
|
|
|
{
|
|
|
if (rhstype->is_integer_type()) // 整型分1bit和32bit
|
|
|
{
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
{
|
|
|
auto zext = builder->create_zext(rhs, INT32_T);
|
|
|
tmp_val = builder->create_icmp_eq(CONST_INT(0), zext);
|
|
|
}
|
|
|
else
|
|
|
tmp_val = builder->create_icmp_eq(CONST_INT(0), rhs);
|
|
|
}
|
|
|
else if (rhstype->is_float_type())
|
|
|
tmp_val = builder->create_fcmp_eq(CONST_FLOAT(0), rhs);
|
|
|
else // rhs是指针类型
|
|
|
tmp_val = CONST_INT(true); // true 则为非零值
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void IRBuilder::visit(SyntaxTree::BinaryCondExpr &node)
|
|
|
{
|
|
|
Ptr<Value> lhs, rhs;
|
|
|
Ptr<Type> lhstype, rhstype;
|
|
|
if ((node.op != SyntaxTree::BinaryCondOp::LAND) && (node.op != SyntaxTree::BinaryCondOp::LOR))
|
|
|
{
|
|
|
node.lhs->accept(*this);
|
|
|
lhs = tmp_val;
|
|
|
lhstype = lhs->get_type();
|
|
|
node.rhs->accept(*this);
|
|
|
rhs = tmp_val;
|
|
|
rhstype = rhs->get_type();
|
|
|
}
|
|
|
|
|
|
switch (node.op)
|
|
|
{
|
|
|
case SyntaxTree::BinaryCondOp::LT:
|
|
|
if (lhstype->is_float_type() && rhstype->is_float_type())
|
|
|
{
|
|
|
tmp_val = builder->create_fcmp_lt(lhs, rhs);
|
|
|
}
|
|
|
else if (lhstype->is_integer_type() && rhstype->is_integer_type())
|
|
|
{
|
|
|
if (Type::is_eq_type(lhstype, INT1_T))
|
|
|
lhs = builder->create_zext(lhs, INT32_T);
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
rhs = builder->create_zext(rhs, INT32_T);
|
|
|
tmp_val = builder->create_icmp_lt(lhs, rhs);
|
|
|
}
|
|
|
else if (lhstype->is_float_type())
|
|
|
{
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
rhs = builder->create_zext(rhs, INT32_T);
|
|
|
rhs = builder->create_sitofp(rhs, FLOAT_T);
|
|
|
tmp_val = builder->create_fcmp_lt(lhs, rhs);
|
|
|
}
|
|
|
else if (rhstype->is_float_type())
|
|
|
{
|
|
|
if (Type::is_eq_type(lhstype, INT1_T))
|
|
|
lhs = builder->create_zext(lhs, INT32_T);
|
|
|
lhs = builder->create_sitofp(lhs, FLOAT_T);
|
|
|
tmp_val = builder->create_fcmp_lt(lhs, rhs);
|
|
|
}
|
|
|
break;
|
|
|
case SyntaxTree::BinaryCondOp::LTE:
|
|
|
if (lhstype->is_float_type() && rhstype->is_float_type())
|
|
|
{
|
|
|
tmp_val = builder->create_fcmp_le(lhs, rhs);
|
|
|
}
|
|
|
else if (lhstype->is_integer_type() && rhstype->is_integer_type())
|
|
|
{
|
|
|
if (Type::is_eq_type(lhstype, INT1_T))
|
|
|
lhs = builder->create_zext(lhs, INT32_T);
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
rhs = builder->create_zext(rhs, INT32_T);
|
|
|
tmp_val = builder->create_icmp_le(lhs, rhs);
|
|
|
}
|
|
|
else if (lhstype->is_float_type())
|
|
|
{
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
rhs = builder->create_zext(rhs, INT32_T);
|
|
|
rhs = builder->create_sitofp(rhs, FLOAT_T);
|
|
|
tmp_val = builder->create_fcmp_le(lhs, rhs);
|
|
|
}
|
|
|
else if (rhstype->is_float_type())
|
|
|
{
|
|
|
if (Type::is_eq_type(lhstype, INT1_T))
|
|
|
lhs = builder->create_zext(lhs, INT32_T);
|
|
|
lhs = builder->create_sitofp(lhs, FLOAT_T);
|
|
|
tmp_val = builder->create_fcmp_le(lhs, rhs);
|
|
|
}
|
|
|
break;
|
|
|
case SyntaxTree::BinaryCondOp::GT:
|
|
|
if (lhstype->is_float_type() && rhstype->is_float_type())
|
|
|
{
|
|
|
tmp_val = builder->create_fcmp_gt(lhs, rhs);
|
|
|
}
|
|
|
else if (lhstype->is_integer_type() && rhstype->is_integer_type())
|
|
|
{
|
|
|
if (Type::is_eq_type(lhstype, INT1_T))
|
|
|
lhs = builder->create_zext(lhs, INT32_T);
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
rhs = builder->create_zext(rhs, INT32_T);
|
|
|
tmp_val = builder->create_icmp_gt(lhs, rhs);
|
|
|
}
|
|
|
else if (lhstype->is_float_type())
|
|
|
{
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
rhs = builder->create_zext(rhs, INT32_T);
|
|
|
rhs = builder->create_sitofp(rhs, FLOAT_T);
|
|
|
tmp_val = builder->create_fcmp_gt(lhs, rhs);
|
|
|
}
|
|
|
else if (rhstype->is_float_type())
|
|
|
{
|
|
|
if (Type::is_eq_type(lhstype, INT1_T))
|
|
|
lhs = builder->create_zext(lhs, INT32_T);
|
|
|
lhs = builder->create_sitofp(lhs, FLOAT_T);
|
|
|
tmp_val = builder->create_fcmp_gt(lhs, rhs);
|
|
|
}
|
|
|
break;
|
|
|
case SyntaxTree::BinaryCondOp::GTE:
|
|
|
if (lhstype->is_float_type() && rhstype->is_float_type())
|
|
|
{
|
|
|
tmp_val = builder->create_fcmp_ge(lhs, rhs);
|
|
|
}
|
|
|
else if (lhstype->is_integer_type() && rhstype->is_integer_type())
|
|
|
{
|
|
|
if (Type::is_eq_type(lhstype, INT1_T))
|
|
|
lhs = builder->create_zext(lhs, INT32_T);
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
rhs = builder->create_zext(rhs, INT32_T);
|
|
|
tmp_val = builder->create_icmp_ge(lhs, rhs);
|
|
|
}
|
|
|
else if (lhstype->is_float_type())
|
|
|
{
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
rhs = builder->create_zext(rhs, INT32_T);
|
|
|
rhs = builder->create_sitofp(rhs, FLOAT_T);
|
|
|
tmp_val = builder->create_fcmp_ge(lhs, rhs);
|
|
|
}
|
|
|
else if (rhstype->is_float_type())
|
|
|
{
|
|
|
if (Type::is_eq_type(lhstype, INT1_T))
|
|
|
lhs = builder->create_zext(lhs, INT32_T);
|
|
|
lhs = builder->create_sitofp(lhs, FLOAT_T);
|
|
|
tmp_val = builder->create_fcmp_ge(lhs, rhs);
|
|
|
}
|
|
|
break;
|
|
|
case SyntaxTree::BinaryCondOp::EQ:
|
|
|
if (lhstype->is_float_type() && rhstype->is_float_type())
|
|
|
{
|
|
|
tmp_val = builder->create_fcmp_eq(lhs, rhs);
|
|
|
}
|
|
|
else if (lhstype->is_integer_type() && rhstype->is_integer_type())
|
|
|
{
|
|
|
if (Type::is_eq_type(lhstype, INT1_T))
|
|
|
lhs = builder->create_zext(lhs, INT32_T);
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
rhs = builder->create_zext(rhs, INT32_T);
|
|
|
tmp_val = builder->create_icmp_eq(lhs, rhs);
|
|
|
}
|
|
|
else if (lhstype->is_float_type())
|
|
|
{
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
rhs = builder->create_zext(rhs, INT32_T);
|
|
|
rhs = builder->create_sitofp(rhs, FLOAT_T);
|
|
|
tmp_val = builder->create_fcmp_eq(lhs, rhs);
|
|
|
}
|
|
|
else if (rhstype->is_float_type())
|
|
|
{
|
|
|
if (Type::is_eq_type(lhstype, INT1_T))
|
|
|
lhs = builder->create_zext(lhs, INT32_T);
|
|
|
lhs = builder->create_sitofp(lhs, FLOAT_T);
|
|
|
tmp_val = builder->create_fcmp_eq(lhs, rhs);
|
|
|
}
|
|
|
break;
|
|
|
case SyntaxTree::BinaryCondOp::NEQ:
|
|
|
if (lhstype->is_float_type() && rhstype->is_float_type())
|
|
|
{
|
|
|
tmp_val = builder->create_fcmp_ne(lhs, rhs);
|
|
|
}
|
|
|
else if (lhstype->is_integer_type() && rhstype->is_integer_type())
|
|
|
{
|
|
|
if (Type::is_eq_type(lhstype, INT1_T))
|
|
|
lhs = builder->create_zext(lhs, INT32_T);
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
rhs = builder->create_zext(rhs, INT32_T);
|
|
|
tmp_val = builder->create_icmp_ne(lhs, rhs);
|
|
|
}
|
|
|
else if (lhstype->is_float_type())
|
|
|
{
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
rhs = builder->create_zext(rhs, INT32_T);
|
|
|
rhs = builder->create_sitofp(rhs, FLOAT_T);
|
|
|
tmp_val = builder->create_fcmp_ne(lhs, rhs);
|
|
|
}
|
|
|
else if (rhstype->is_float_type())
|
|
|
{
|
|
|
if (Type::is_eq_type(lhstype, INT1_T))
|
|
|
lhs = builder->create_zext(lhs, INT32_T);
|
|
|
lhs = builder->create_sitofp(lhs, FLOAT_T);
|
|
|
tmp_val = builder->create_fcmp_ne(lhs, rhs);
|
|
|
}
|
|
|
break;
|
|
|
// 非常关键的控制流语句br(逻辑与/或)
|
|
|
case SyntaxTree::BinaryCondOp::LAND:
|
|
|
// lhs和rhs都应该是INT1_T
|
|
|
{
|
|
|
auto parent = func_parent;
|
|
|
char labelname[20];
|
|
|
sprintf(labelname, "true_bb_%d", bb_label_num++); // lhs&&rhs为true进入执行体
|
|
|
auto true_bb = BasicBlock::create(module, labelname, parent);
|
|
|
sprintf(labelname, "false_bb_%d", bb_label_num++); // lhs为false（应该就是after cond bb吧？也可能进入下一个cond bb）
|
|
|
auto false_bb = BasicBlock::create(module, labelname, parent);
|
|
|
sprintf(labelname, "next_bb_%d", bb_label_num++); // rhs判断域
|
|
|
auto next_bb = BasicBlock::create(module, labelname, parent);
|
|
|
sprintf(labelname, "after_bb_%d", bb_label_num++); //
|
|
|
auto after_bb = BasicBlock::create(module, labelname, parent);
|
|
|
|
|
|
auto result = builder->create_alloca(INT1_T);
|
|
|
node.lhs->accept(*this);
|
|
|
lhs = tmp_val;
|
|
|
lhstype = lhs->get_type();
|
|
|
if (Type::is_eq_type(lhstype, INT1_T))
|
|
|
{
|
|
|
builder->create_cond_br(lhs, next_bb, false_bb); // if true直接跳转到nextbb(rhs判断的bb)，否则跳转到falsebb
|
|
|
}
|
|
|
else if (Type::is_eq_type(lhstype, INT32_T))
|
|
|
{
|
|
|
tmp_val = builder->create_icmp_ne(lhs, CONST_INT(0)); // 类型为INT32_T而不是INT1_T就不能直接create_cond_br，先判断真假
|
|
|
builder->create_cond_br(lhs, next_bb, false_bb);
|
|
|
}
|
|
|
else if (Type::is_eq_type(lhstype, FLOAT_T))
|
|
|
{
|
|
|
tmp_val = builder->create_fcmp_ne(lhs, CONST_FLOAT(0)); // 类型为INT32_T而不是INT1_T就不能直接create_cond_br，先判断真假
|
|
|
builder->create_cond_br(tmp_val, next_bb, false_bb);
|
|
|
}
|
|
|
else // 为无条件跳转
|
|
|
{
|
|
|
builder->create_br(next_bb);
|
|
|
}
|
|
|
builder->set_insert_point(next_bb); // rhs判断域
|
|
|
|
|
|
node.rhs->accept(*this);
|
|
|
rhs = tmp_val;
|
|
|
rhstype = rhs->get_type();
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
{
|
|
|
builder->create_cond_br(rhs, true_bb, false_bb); // if true直接跳转到truebb，否则跳转到falsebb
|
|
|
}
|
|
|
else if (Type::is_eq_type(rhstype, INT32_T))
|
|
|
{
|
|
|
tmp_val = builder->create_icmp_ne(rhs, CONST_INT(0)); // 类型为INT32_T而不是INT1_T就不能直接create_cond_br，先判断真假
|
|
|
builder->create_cond_br(rhs, true_bb, false_bb);
|
|
|
}
|
|
|
else if (Type::is_eq_type(rhstype, FLOAT_T))
|
|
|
{
|
|
|
tmp_val = builder->create_fcmp_ne(rhs, CONST_FLOAT(0)); // 类型为INT32_T而不是INT1_T就不能直接create_cond_br，先判断真假
|
|
|
builder->create_cond_br(tmp_val, true_bb, false_bb);
|
|
|
}
|
|
|
else // 为无条件跳转
|
|
|
{
|
|
|
builder->create_br(true_bb);
|
|
|
}
|
|
|
|
|
|
builder->set_insert_point(true_bb); // cond_bb判断域结束，进入true_bb执行体内部
|
|
|
builder->create_store(CONST_INT(true), result);
|
|
|
builder->create_br(after_bb);
|
|
|
builder->set_insert_point(false_bb);
|
|
|
builder->create_store(CONST_INT(false), result);
|
|
|
builder->create_br(after_bb);
|
|
|
// true_bb和false_bb IR结束后都要无条件br到after_bb
|
|
|
builder->set_insert_point(after_bb);
|
|
|
tmp_val = builder->create_load(result);
|
|
|
break;
|
|
|
}
|
|
|
case SyntaxTree::BinaryCondOp::LOR:
|
|
|
// lhs和rhs都应该是INT1_T, 与LAND稍有区别（使用短路计算）
|
|
|
auto parent = func_parent;
|
|
|
char labelname[20];
|
|
|
sprintf(labelname, "ture_bb_%d", bb_label_num++); // lhs&&rhs为true进入执行体
|
|
|
auto true_bb = BasicBlock::create(module, labelname, parent);
|
|
|
sprintf(labelname, "false_bb_%d", bb_label_num++); // lhs为false（应该就是after cond bb吧？也可能进入下一个cond bb）
|
|
|
auto false_bb = BasicBlock::create(module, labelname, parent);
|
|
|
sprintf(labelname, "next_bb_%d", bb_label_num++); // rhs判断域
|
|
|
auto next_bb = BasicBlock::create(module, labelname, parent);
|
|
|
sprintf(labelname, "after_bb_%d", bb_label_num++); //
|
|
|
auto after_bb = BasicBlock::create(module, labelname, parent);
|
|
|
|
|
|
auto result = builder->create_alloca(INT1_T);
|
|
|
node.lhs->accept(*this);
|
|
|
lhs = tmp_val;
|
|
|
lhstype = lhs->get_type();
|
|
|
if (Type::is_eq_type(lhstype, INT1_T))
|
|
|
{
|
|
|
builder->create_cond_br(lhs, true_bb, next_bb); // if true直接跳转到turebb执行体内，否则跳转到nextbb(rhs判断域)
|
|
|
}
|
|
|
else if (Type::is_eq_type(lhstype, INT32_T))
|
|
|
{
|
|
|
tmp_val = builder->create_icmp_ne(lhs, CONST_INT(0)); // 类型为INT32_T而不是INT1_T就不能直接create_cond_br，先判断真假
|
|
|
builder->create_cond_br(tmp_val, true_bb, next_bb);
|
|
|
}
|
|
|
else if (Type::is_eq_type(lhstype, FLOAT_T))
|
|
|
{
|
|
|
tmp_val = builder->create_fcmp_ne(lhs, CONST_FLOAT(0)); // 类型为INT32_T而不是INT1_T就不能直接create_cond_br，先判断真假
|
|
|
builder->create_cond_br(tmp_val, true_bb, next_bb);
|
|
|
}
|
|
|
else // 为无条件跳转
|
|
|
{
|
|
|
builder->create_br(true_bb);
|
|
|
}
|
|
|
builder->set_insert_point(next_bb); // rhs判断域
|
|
|
node.rhs->accept(*this);
|
|
|
rhs = tmp_val;
|
|
|
rhstype = rhs->get_type();
|
|
|
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
{
|
|
|
builder->create_cond_br(rhs, true_bb, false_bb); // if true直接跳转到truebb，否则跳转到falsebb
|
|
|
}
|
|
|
else if (Type::is_eq_type(rhstype, INT32_T))
|
|
|
{
|
|
|
tmp_val = builder->create_icmp_ne(rhs, CONST_INT(0)); // 类型为INT32_T而不是INT1_T就不能直接create_cond_br，先判断真假
|
|
|
builder->create_cond_br(tmp_val, true_bb, false_bb);
|
|
|
}
|
|
|
else if (Type::is_eq_type(rhstype, FLOAT_T))
|
|
|
{
|
|
|
tmp_val = builder->create_fcmp_ne(rhs, CONST_FLOAT(0)); // 类型为INT32_T而不是INT1_T就不能直接create_cond_br，先判断真假
|
|
|
builder->create_cond_br(tmp_val, true_bb, false_bb);
|
|
|
}
|
|
|
else // 为无条件跳转
|
|
|
{
|
|
|
builder->create_br(true_bb);
|
|
|
}
|
|
|
|
|
|
builder->set_insert_point(true_bb); // cond_bb判断域结束，进入true_bb执行体内部
|
|
|
builder->create_store(CONST_INT(true), result);
|
|
|
builder->create_br(after_bb);
|
|
|
builder->set_insert_point(false_bb);
|
|
|
builder->create_store(CONST_INT(false), result);
|
|
|
builder->create_br(after_bb);
|
|
|
// true_bb和false_bb IR结束后都要无条件br到after_bb
|
|
|
builder->set_insert_point(after_bb);
|
|
|
tmp_val = builder->create_load(result);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void IRBuilder::visit(SyntaxTree::BinaryExpr &node)
|
|
|
{
|
|
|
if (scope.in_global()) // 需要计算全局变量声明中某些表达式
|
|
|
{
|
|
|
int lhs_ival, rhs_ival;
|
|
|
float lhs_fval, rhs_fval;
|
|
|
bool lhs_is_int, rhs_is_int;
|
|
|
node.lhs->accept(*this);
|
|
|
if (expr_cal_result.is_int)
|
|
|
lhs_ival = expr_cal_result.ival;
|
|
|
else
|
|
|
lhs_fval = expr_cal_result.fval;
|
|
|
lhs_is_int = expr_cal_result.is_int;
|
|
|
node.rhs->accept(*this);
|
|
|
if (expr_cal_result.is_int)
|
|
|
rhs_ival = expr_cal_result.ival;
|
|
|
else
|
|
|
rhs_fval = expr_cal_result.fval;
|
|
|
rhs_is_int = expr_cal_result.is_int;
|
|
|
switch (node.op)
|
|
|
{
|
|
|
case SyntaxTree::BinOp::PLUS:
|
|
|
if (lhs_is_int && rhs_is_int)
|
|
|
{
|
|
|
expr_cal_result.is_int = true;
|
|
|
expr_cal_result.ival = lhs_ival + rhs_ival;
|
|
|
}
|
|
|
else if (!lhs_is_int && rhs_is_int)
|
|
|
{
|
|
|
expr_cal_result.is_int = false;
|
|
|
expr_cal_result.fval = lhs_fval + rhs_ival;
|
|
|
}
|
|
|
else if (lhs_is_int && !rhs_is_int)
|
|
|
{
|
|
|
expr_cal_result.is_int = false;
|
|
|
expr_cal_result.fval = lhs_ival + rhs_fval;
|
|
|
}
|
|
|
else if (!lhs_is_int && !rhs_is_int)
|
|
|
{
|
|
|
expr_cal_result.is_int = false;
|
|
|
expr_cal_result.fval = lhs_fval + rhs_fval;
|
|
|
}
|
|
|
break;
|
|
|
case SyntaxTree::BinOp::MINUS:
|
|
|
if (lhs_is_int && rhs_is_int)
|
|
|
{
|
|
|
expr_cal_result.is_int = true;
|
|
|
expr_cal_result.ival = lhs_ival - rhs_ival;
|
|
|
}
|
|
|
else if (!lhs_is_int && rhs_is_int)
|
|
|
{
|
|
|
expr_cal_result.is_int = false;
|
|
|
expr_cal_result.fval = lhs_fval - rhs_ival;
|
|
|
}
|
|
|
else if (lhs_is_int && !rhs_is_int)
|
|
|
{
|
|
|
expr_cal_result.is_int = false;
|
|
|
expr_cal_result.fval = lhs_ival - rhs_fval;
|
|
|
}
|
|
|
else if (!lhs_is_int && !rhs_is_int)
|
|
|
{
|
|
|
expr_cal_result.is_int = false;
|
|
|
expr_cal_result.fval = lhs_fval - rhs_fval;
|
|
|
}
|
|
|
break;
|
|
|
case SyntaxTree::BinOp::MULTIPLY:
|
|
|
if (lhs_is_int && rhs_is_int)
|
|
|
{
|
|
|
expr_cal_result.is_int = true;
|
|
|
expr_cal_result.ival = lhs_ival * rhs_ival;
|
|
|
}
|
|
|
else if (!lhs_is_int && rhs_is_int)
|
|
|
{
|
|
|
expr_cal_result.is_int = false;
|
|
|
expr_cal_result.fval = lhs_fval * rhs_ival;
|
|
|
}
|
|
|
else if (lhs_is_int && !rhs_is_int)
|
|
|
{
|
|
|
expr_cal_result.is_int = false;
|
|
|
expr_cal_result.fval = lhs_ival * rhs_fval;
|
|
|
}
|
|
|
else if (!lhs_is_int && !rhs_is_int)
|
|
|
{
|
|
|
expr_cal_result.is_int = false;
|
|
|
expr_cal_result.fval = lhs_fval * rhs_fval;
|
|
|
}
|
|
|
break;
|
|
|
case SyntaxTree::BinOp::DIVIDE:
|
|
|
if (lhs_is_int && rhs_is_int)
|
|
|
{
|
|
|
expr_cal_result.is_int = true;
|
|
|
expr_cal_result.ival = lhs_ival / rhs_ival;
|
|
|
}
|
|
|
else if (!lhs_is_int && rhs_is_int)
|
|
|
{
|
|
|
expr_cal_result.is_int = false;
|
|
|
expr_cal_result.fval = lhs_fval / rhs_ival;
|
|
|
}
|
|
|
else if (lhs_is_int && !rhs_is_int)
|
|
|
{
|
|
|
expr_cal_result.is_int = false;
|
|
|
expr_cal_result.fval = lhs_ival / rhs_fval;
|
|
|
}
|
|
|
else if (!lhs_is_int && !rhs_is_int)
|
|
|
{
|
|
|
expr_cal_result.is_int = false;
|
|
|
expr_cal_result.fval = lhs_fval / rhs_fval;
|
|
|
}
|
|
|
break;
|
|
|
case SyntaxTree::BinOp::MODULO:
|
|
|
expr_cal_result.is_int = true;
|
|
|
if (lhs_is_int && rhs_is_int)
|
|
|
expr_cal_result.ival = lhs_ival % rhs_ival;
|
|
|
else if (!lhs_is_int && rhs_is_int)
|
|
|
expr_cal_result.fval = int(lhs_fval) % rhs_ival;
|
|
|
else if (lhs_is_int && !rhs_is_int)
|
|
|
expr_cal_result.fval = lhs_ival % int(rhs_fval);
|
|
|
else if (!lhs_is_int && !rhs_is_int)
|
|
|
expr_cal_result.fval = int(lhs_fval) % int(rhs_fval);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
else // 生成相应计算ir指令, 根据最终指令形式分为float、int和指针计算三种
|
|
|
{
|
|
|
node.lhs->accept(*this);
|
|
|
auto lhs = tmp_val;
|
|
|
auto lhstype = lhs->get_type();
|
|
|
node.rhs->accept(*this);
|
|
|
auto rhs = tmp_val;
|
|
|
auto rhstype = rhs->get_type();
|
|
|
switch (node.op)
|
|
|
{
|
|
|
case SyntaxTree::BinOp::PLUS:
|
|
|
if (Type::is_eq_type(lhstype, FLOAT_T) || Type::is_eq_type(rhstype, FLOAT_T))
|
|
|
{ // 目标ir为float加法
|
|
|
if (lhstype->is_integer_type()) // 类型不匹配
|
|
|
{
|
|
|
if (Type::is_eq_type(lhstype, INT1_T))
|
|
|
{
|
|
|
auto zext = builder->create_zext(lhs, INT32_T);
|
|
|
auto itof = builder->create_sitofp(zext, FLOAT_T);
|
|
|
tmp_val = builder->create_fadd(itof, rhs);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
auto itof = builder->create_sitofp(lhs, FLOAT_T);
|
|
|
tmp_val = builder->create_fadd(itof, rhs);
|
|
|
}
|
|
|
}
|
|
|
else if (rhstype->is_integer_type())
|
|
|
{
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
{
|
|
|
auto zext = builder->create_zext(rhs, INT32_T);
|
|
|
auto itof = builder->create_sitofp(zext, FLOAT_T);
|
|
|
tmp_val = builder->create_fadd(lhs, itof);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
auto itof = builder->create_sitofp(rhs, FLOAT_T);
|
|
|
tmp_val = builder->create_fadd(lhs, itof);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
tmp_val = builder->create_fadd(lhs, rhs);
|
|
|
}
|
|
|
else if (lhstype->is_integer_type() && rhstype->is_integer_type())
|
|
|
{ // 目标ir为32位加法
|
|
|
if (Type::is_eq_type(lhstype, INT1_T))
|
|
|
lhs = builder->create_zext(lhs, INT32_T);
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
rhs = builder->create_zext(rhs, INT32_T);
|
|
|
tmp_val = builder->create_iadd(lhs, rhs);
|
|
|
}
|
|
|
else
|
|
|
{ // 目标ir为指针计算（地址计算gep）
|
|
|
PtrVec<Value> ptr_idx; // 为适配多维数组或结构体的多个idx寻址,设置为vector类型
|
|
|
if (lhstype->is_pointer_type())
|
|
|
{
|
|
|
ptr_idx.push_back(rhs);
|
|
|
tmp_val = builder->create_gep(lhs, ptr_idx);
|
|
|
}
|
|
|
else if (rhstype->is_pointer_type())
|
|
|
{
|
|
|
ptr_idx.push_back(lhs);
|
|
|
tmp_val = builder->create_gep(rhs, ptr_idx);
|
|
|
}
|
|
|
}
|
|
|
break;
|
|
|
case SyntaxTree::BinOp::MINUS:
|
|
|
if (Type::is_eq_type(lhstype, FLOAT_T) || Type::is_eq_type(rhstype, FLOAT_T))
|
|
|
{ // 目标ir为float减法
|
|
|
if (lhstype->is_integer_type()) // 类型不匹配
|
|
|
{
|
|
|
if (Type::is_eq_type(lhstype, INT1_T))
|
|
|
{
|
|
|
auto zext = builder->create_zext(lhs, INT32_T);
|
|
|
auto itof = builder->create_sitofp(zext, FLOAT_T);
|
|
|
tmp_val = builder->create_fsub(itof, rhs);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
auto itof = builder->create_sitofp(lhs, FLOAT_T);
|
|
|
tmp_val = builder->create_fsub(itof, rhs);
|
|
|
}
|
|
|
}
|
|
|
else if (rhstype->is_integer_type())
|
|
|
{
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
{
|
|
|
auto zext = builder->create_zext(rhs, INT32_T);
|
|
|
auto itof = builder->create_sitofp(zext, FLOAT_T);
|
|
|
tmp_val = builder->create_fsub(lhs, itof);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
auto itof = builder->create_sitofp(rhs, FLOAT_T);
|
|
|
tmp_val = builder->create_fsub(lhs, itof);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
tmp_val = builder->create_fsub(lhs, rhs);
|
|
|
}
|
|
|
else if (lhstype->is_integer_type() && rhstype->is_integer_type())
|
|
|
{ // 目标ir为32位减法
|
|
|
if (Type::is_eq_type(lhstype, INT1_T))
|
|
|
lhs = builder->create_zext(lhs, INT32_T);
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
rhs = builder->create_zext(rhs, INT32_T);
|
|
|
tmp_val = builder->create_isub(lhs, rhs);
|
|
|
}
|
|
|
else
|
|
|
{ // 目标ir为指针计算（地址计算gep）， 只能lhs为指针类型
|
|
|
PtrVec<Value> ptr_idx; // 为适配多维数组或结构体的多个idx寻址,设置为vector类型
|
|
|
if (lhstype->is_pointer_type())
|
|
|
{
|
|
|
ptr_idx.push_back(rhs);
|
|
|
tmp_val = builder->create_gep(lhs, ptr_idx);
|
|
|
}
|
|
|
}
|
|
|
break;
|
|
|
case SyntaxTree::BinOp::MULTIPLY:
|
|
|
if (Type::is_eq_type(lhstype, FLOAT_T) || Type::is_eq_type(rhstype, FLOAT_T))
|
|
|
{ // 目标ir为float乘法
|
|
|
if (lhstype->is_integer_type()) // 类型不匹配
|
|
|
{
|
|
|
if (Type::is_eq_type(lhstype, INT1_T))
|
|
|
{
|
|
|
auto zext = builder->create_zext(lhs, INT32_T);
|
|
|
auto itof = builder->create_sitofp(zext, FLOAT_T);
|
|
|
tmp_val = builder->create_fmul(itof, rhs);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
auto itof = builder->create_sitofp(lhs, FLOAT_T);
|
|
|
tmp_val = builder->create_fmul(itof, rhs);
|
|
|
}
|
|
|
}
|
|
|
else if (rhstype->is_integer_type())
|
|
|
{
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
{
|
|
|
auto zext = builder->create_zext(rhs, INT32_T);
|
|
|
auto itof = builder->create_sitofp(zext, FLOAT_T);
|
|
|
tmp_val = builder->create_fmul(lhs, itof);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
auto itof = builder->create_sitofp(rhs, FLOAT_T);
|
|
|
tmp_val = builder->create_fmul(lhs, itof);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
tmp_val = builder->create_fmul(lhs, rhs);
|
|
|
}
|
|
|
else if (lhstype->is_integer_type() && rhstype->is_integer_type())
|
|
|
{ // 目标ir为32位乘法
|
|
|
if (Type::is_eq_type(lhstype, INT1_T))
|
|
|
lhs = builder->create_zext(lhs, INT32_T);
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
rhs = builder->create_zext(rhs, INT32_T);
|
|
|
tmp_val = builder->create_imul(lhs, rhs);
|
|
|
}
|
|
|
break;
|
|
|
case SyntaxTree::BinOp::DIVIDE:
|
|
|
if (Type::is_eq_type(lhstype, FLOAT_T) || Type::is_eq_type(rhstype, FLOAT_T))
|
|
|
{ // 目标ir为float除法
|
|
|
if (lhstype->is_integer_type()) // 类型不匹配
|
|
|
{
|
|
|
if (Type::is_eq_type(lhstype, INT1_T))
|
|
|
{
|
|
|
auto zext = builder->create_zext(lhs, INT32_T);
|
|
|
auto itof = builder->create_sitofp(zext, FLOAT_T);
|
|
|
tmp_val = builder->create_fdiv(itof, rhs);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
auto itof = builder->create_sitofp(lhs, FLOAT_T);
|
|
|
tmp_val = builder->create_fdiv(itof, rhs);
|
|
|
}
|
|
|
}
|
|
|
else if (rhstype->is_integer_type())
|
|
|
{
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
{
|
|
|
auto zext = builder->create_zext(rhs, INT32_T);
|
|
|
auto itof = builder->create_sitofp(zext, FLOAT_T);
|
|
|
tmp_val = builder->create_fdiv(lhs, itof);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
auto itof = builder->create_sitofp(rhs, FLOAT_T);
|
|
|
tmp_val = builder->create_fdiv(lhs, itof);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
tmp_val = builder->create_fdiv(lhs, rhs);
|
|
|
}
|
|
|
else if (lhstype->is_integer_type() && rhstype->is_integer_type())
|
|
|
{ // 目标ir为32位除法
|
|
|
if (Type::is_eq_type(lhstype, INT1_T))
|
|
|
lhs = builder->create_zext(lhs, INT32_T);
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
rhs = builder->create_zext(rhs, INT32_T);
|
|
|
tmp_val = builder->create_isdiv(lhs, rhs);
|
|
|
}
|
|
|
break;
|
|
|
case SyntaxTree::BinOp::MODULO: // 取模运算只能是int类型（不能通过ir将float类型转换，这是不合法的）
|
|
|
if (lhstype->is_integer_type() && rhstype->is_integer_type())
|
|
|
{ // 目标ir为32位取模
|
|
|
if (Type::is_eq_type(lhstype, INT1_T))
|
|
|
lhs = builder->create_zext(lhs, INT32_T);
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
rhs = builder->create_zext(rhs, INT32_T);
|
|
|
tmp_val = builder->create_isrem(lhs, rhs);
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void IRBuilder::visit(SyntaxTree::UnaryExpr &node)
|
|
|
{
|
|
|
if (scope.in_global()) // 需要计算全局变量声明中某些表达式
|
|
|
{ // 只有minus需要修改值，否则值和类型都不用修改
|
|
|
node.rhs->accept(*this);
|
|
|
if (expr_cal_result.is_int)
|
|
|
{
|
|
|
if (node.op == SyntaxTree::UnaryOp::MINUS)
|
|
|
expr_cal_result.ival = -expr_cal_result.ival;
|
|
|
else if (node.op == SyntaxTree::UnaryOp::MINUS)
|
|
|
expr_cal_result.fval = -expr_cal_result.fval;
|
|
|
}
|
|
|
}
|
|
|
else // 需要更新tmp_val
|
|
|
{
|
|
|
node.rhs->accept(*this);
|
|
|
auto rhs = tmp_val;
|
|
|
auto rhstype = rhs->get_type();
|
|
|
switch (node.op)
|
|
|
{
|
|
|
case SyntaxTree::UnaryOp::PLUS:
|
|
|
break;
|
|
|
case SyntaxTree::UnaryOp::MINUS:
|
|
|
if (rhstype->is_integer_type())
|
|
|
{
|
|
|
if (Type::is_eq_type(rhstype, INT1_T))
|
|
|
{
|
|
|
auto zext = builder->create_zext(rhs, INT32_T);
|
|
|
tmp_val = builder->create_isub(CONST_INT(0), zext);
|
|
|
}
|
|
|
else
|
|
|
tmp_val = builder->create_isub(CONST_INT(0), rhs);
|
|
|
}
|
|
|
else if (rhstype->is_float_type())
|
|
|
tmp_val = builder->create_fsub(CONST_FLOAT(0), rhs);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void IRBuilder::visit(SyntaxTree::FuncCallStmt &node)
|
|
|
{
|
|
|
auto Func = dynamic_pointer_cast<Function>(scope.find(node.name, true));
|
|
|
auto RetType = Func->get_return_type();
|
|
|
PtrVec<Value> param;
|
|
|
param.clear();
|
|
|
auto FuncPara = Func->get_args();
|
|
|
int idx = 0;
|
|
|
|
|
|
// DBGLOG("begin the funccall");
|
|
|
for (auto funp : FuncPara)
|
|
|
{
|
|
|
node.params[idx]->accept(*this);
|
|
|
auto tmpType = tmp_val->get_type();
|
|
|
auto ParaType = funp->get_type();
|
|
|
|
|
|
if (ParaType == tmpType)
|
|
|
param.push_back(tmp_val);
|
|
|
else if (ParaType == INT32_T)
|
|
|
{
|
|
|
switch (tmpType->get_type_id())
|
|
|
{
|
|
|
// INT1 to INT32
|
|
|
case SysYF::IR::Type::TypeID::IntegerTyID:
|
|
|
tmp_val = builder->create_zext(tmp_val, INT32_T);
|
|
|
param.push_back(tmp_val);
|
|
|
break;
|
|
|
// FLOAT to INT32
|
|
|
case SysYF::IR::Type::TypeID::FloatTyID:
|
|
|
tmp_val = builder->create_fptosi(tmp_val, INT32_T);
|
|
|
param.push_back(tmp_val);
|
|
|
break;
|
|
|
// other
|
|
|
default:
|
|
|
// DBGLOG("Error type to INT32_T");
|
|
|
// DBGLOG(tmpType->get_type_id());
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
else if (ParaType == FLOAT_T)
|
|
|
{
|
|
|
switch (tmpType->get_type_id())
|
|
|
{
|
|
|
// INT1/32 to FLOAT
|
|
|
case SysYF::IR::Type::TypeID::IntegerTyID:
|
|
|
if (tmpType == INT1_T)
|
|
|
tmp_val = builder->create_zext(tmp_val, INT32_T);
|
|
|
tmp_val = builder->create_sitofp(tmp_val, FLOAT_T);
|
|
|
param.push_back(tmp_val);
|
|
|
break;
|
|
|
// other
|
|
|
default:
|
|
|
// DBGLOG("Error type to FLOAT_T");
|
|
|
// DBGLOG(tmpType->get_type_id());
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
else if (ParaType->is_pointer_type())
|
|
|
{
|
|
|
if (tmpType->is_array_type())
|
|
|
{
|
|
|
// DBGLOG(tmpType->get_type_id());
|
|
|
// DBGLOG("debug 1");
|
|
|
auto Element_pointer = builder->create_gep(lhs_addr, {CONST_INT(0), CONST_INT(0)});
|
|
|
// DBGLOG("debug 2");
|
|
|
param.push_back(Element_pointer);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
// DBGLOG("ParaType == pointer");
|
|
|
// DBGLOG(tmpType->get_type_id());
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
// DBGLOG("Error ParaType");
|
|
|
// DBGLOG(ParaType->get_type_id());
|
|
|
// other
|
|
|
}
|
|
|
|
|
|
idx++;
|
|
|
}
|
|
|
|
|
|
if (RetType == VOID_T)
|
|
|
{
|
|
|
builder->create_call(Func, param);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
tmp_val = builder->create_call(Func, param);
|
|
|
}
|
|
|
// DBGLOG("end the funccall");
|
|
|
}
|
|
|
|
|
|
void IRBuilder::visit(SyntaxTree::IfStmt &node)
|
|
|
{
|
|
|
/* DBGLOG("begin the IF"); */
|
|
|
SysYF::Ptr<SysYF::IR::BasicBlock> bbTrue, bbAfter, bbFalse, bbCond;
|
|
|
auto ParentFunc = builder->get_insert_block()->get_parent();
|
|
|
char num[10];
|
|
|
// itoa(Ifnum, num, 10);
|
|
|
/* DBGLOG("before the sprintf"); */
|
|
|
sprintf(num, "%d", Ifnum++);
|
|
|
/* DBGLOG("after the sprintf"); */
|
|
|
/* std::string s = "if_cond_";
|
|
|
bbCond = BasicBlock::create(module, s + num, ParentFunc); */
|
|
|
std::string s = "if_true_";
|
|
|
bbTrue = BasicBlock::create(module, s + num, ParentFunc);
|
|
|
if (node.else_statement)
|
|
|
{
|
|
|
s = "if_false_";
|
|
|
bbFalse = BasicBlock::create(module, s + num, ParentFunc);
|
|
|
}
|
|
|
s = "after_if_";
|
|
|
bbAfter = BasicBlock::create(module, s + num, ParentFunc);
|
|
|
|
|
|
/* DBGLOG("before visit cond"); */
|
|
|
/* builder->create_br(bbCond); */
|
|
|
/* builder->set_insert_point(bbCond); */
|
|
|
node.cond_exp->accept(*this);
|
|
|
/* DBGLOG("after visit cond"); */
|
|
|
|
|
|
SysYF::Ptr<Value> _cmp;
|
|
|
auto condType = tmp_val->get_type();
|
|
|
if (condType == INT1_T)
|
|
|
_cmp = tmp_val;
|
|
|
else if (condType == INT32_T)
|
|
|
_cmp = builder->create_icmp_ne(tmp_val, CONST_INT(0));
|
|
|
else if (condType == FLOAT_T)
|
|
|
_cmp = builder->create_fcmp_ne(tmp_val, CONST_FLOAT(0));
|
|
|
else
|
|
|
{
|
|
|
}
|
|
|
/* DBGLOG("after Init cmp"); */
|
|
|
if (!_cmp)
|
|
|
builder->create_br(bbTrue);
|
|
|
else if (node.else_statement)
|
|
|
builder->create_cond_br(_cmp, bbTrue, bbFalse);
|
|
|
else
|
|
|
builder->create_cond_br(_cmp, bbTrue, bbAfter);
|
|
|
|
|
|
builder->set_insert_point(bbTrue);
|
|
|
/* DBGLOG("before visit if_stmt"); */
|
|
|
|
|
|
node.if_statement->accept(*this);
|
|
|
/* DBGLOG("after visit if_stmt"); */
|
|
|
|
|
|
if (!builder->get_insert_block()->get_terminator())
|
|
|
builder->create_br(bbAfter);
|
|
|
|
|
|
if (node.else_statement)
|
|
|
{
|
|
|
builder->set_insert_point(bbFalse);
|
|
|
/* DBGLOG("before visit else"); */
|
|
|
node.else_statement->accept(*this);
|
|
|
if (!builder->get_insert_block()->get_terminator())
|
|
|
builder->create_br(bbAfter);
|
|
|
}
|
|
|
|
|
|
builder->set_insert_point(bbAfter);
|
|
|
/* DBGLOG("end the IF"); */
|
|
|
}
|
|
|
|
|
|
void IRBuilder::visit(SyntaxTree::WhileStmt &node)
|
|
|
{
|
|
|
// 类比condexpr和ifstmt，需要创建bb label并控制跳转
|
|
|
char labelname[20];
|
|
|
auto parent = func_parent;
|
|
|
sprintf(labelname, "cond_bb_%d", bb_label_num++);
|
|
|
auto cond_bb = BasicBlock::create(module, labelname, parent);
|
|
|
sprintf(labelname, "true_bb_%d", bb_label_num++);
|
|
|
auto true_bb = BasicBlock::create(module, labelname, parent);
|
|
|
sprintf(labelname, "after_bb_%d", bb_label_num++);
|
|
|
auto after_bb = BasicBlock::create(module, labelname, parent);
|
|
|
|
|
|
break_point.push_back(after_bb); // break后直接跳转至afterbb（循环语句后紧接的bb）
|
|
|
continue_point.push_back(cond_bb); // continue后跳转至条件判断域condbb
|
|
|
|
|
|
builder->create_br(cond_bb); // 进入AST的whilrnode后先无条件进行一次条件判断
|
|
|
builder->set_insert_point(cond_bb);
|
|
|
node.cond_exp->accept(*this);
|
|
|
auto cond_judge = tmp_val;
|
|
|
auto cond_type = cond_judge->get_type();
|
|
|
// 只有当cond是INT1_T类型时才能直接生成cond_br, 否则要先判断cond是否为零值
|
|
|
if (Type::is_eq_type(cond_type, INT1_T))
|
|
|
{
|
|
|
builder->create_cond_br(cond_judge, true_bb, after_bb);
|
|
|
}
|
|
|
else if (Type::is_eq_type(cond_type, INT32_T))
|
|
|
{
|
|
|
cond_judge = builder->create_icmp_ne(cond_judge, CONST_INT(0));
|
|
|
builder->create_cond_br(cond_judge, true_bb, after_bb);
|
|
|
}
|
|
|
else if (Type::is_eq_type(cond_type, FLOAT_T))
|
|
|
{
|
|
|
cond_judge = builder->create_fcmp_ne(cond_judge, CONST_FLOAT(0));
|
|
|
builder->create_cond_br(cond_judge, true_bb, after_bb);
|
|
|
}
|
|
|
else // 说明能无条件跳转, while(1)
|
|
|
{
|
|
|
builder->create_br(true_bb);
|
|
|
}
|
|
|
|
|
|
builder->set_insert_point(true_bb); // 进入循环执行体内部生成IR
|
|
|
node.statement->accept(*this); // 访问循环体内部stmt, 自会生成IR
|
|
|
|
|
|
if (!(builder->get_insert_block()->get_terminator())) // ret与br都是Terminator Instructions也就是终止指令, 若没有则补充(while语句里没有)
|
|
|
builder->create_br(cond_bb);
|
|
|
|
|
|
builder->set_insert_point(after_bb);
|
|
|
// 离开前别忘了维护break和continue栈
|
|
|
break_point.pop_back();
|
|
|
continue_point.pop_back();
|
|
|
}
|
|
|
|
|
|
void IRBuilder::visit(SyntaxTree::BreakStmt &node)
|
|
|
{ // 控制跳转目的地址
|
|
|
char labelname[20];
|
|
|
auto parent = func_parent;
|
|
|
sprintf(labelname, "break_dest_%d", bb_label_num++);
|
|
|
auto break_dest_bb = BasicBlock::create(module, labelname, parent);
|
|
|
builder->create_br(break_point.back()); // 还不需要pop, while语句中会pop
|
|
|
builder->set_insert_point(break_dest_bb);
|
|
|
}
|
|
|
|
|
|
void IRBuilder::visit(SyntaxTree::ContinueStmt &node)
|
|
|
{ // 控制跳转目的地址
|
|
|
char labelname[20];
|
|
|
auto parent = func_parent;
|
|
|
sprintf(labelname, "cond_dest_%d", bb_label_num++);
|
|
|
auto cond_dest_bb = BasicBlock::create(module, labelname, parent);
|
|
|
builder->create_br(continue_point.back()); // 还不需要pop, while语句中会pop
|
|
|
builder->set_insert_point(cond_dest_bb);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
} |
