pmnz9w5y3
/
SysYF_LLVM_IR
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add task3 correct file

Browse Source
main
stivenkingsberg 1 year ago
parent 7f12bcaf02
commit b919258ffc
1 changed files with 283 additions and 92 deletions
Show Stats Download Patch File Download Diff File

343
src/SysYFIRBuilder/IRBuilder.cpp
Unescape View File

@ -25,7 +25,8 @@ namespace SysYF
std::map<SyntaxTree::Type, Ptr<Type>> type_map; // 把类型转换成类型指针 std::map<SyntaxTree::Type, Ptr<Type>> type_map; // 把类型转换成类型指针
// store temporary value // store temporary value
Ptr<Value> tmp_val = nullptr; Ptr<Value> tmp_val = nullptr;
vector<Ptr<Value>> init_list; vector<SysYF::Ptr<Constant>> init_list;
Ptr<Type> array_init_type;
// types // types
Ptr<Type> VOID_T; Ptr<Type> VOID_T;
Ptr<Type> INT1_T; Ptr<Type> INT1_T;
@ -33,10 +34,51 @@ namespace SysYF
Ptr<Type> FLOAT_T; Ptr<Type> FLOAT_T;
Ptr<Type> INT32PTR_T; Ptr<Type> INT32PTR_T;
Ptr<Type> FLOATPTR_T; Ptr<Type> FLOATPTR_T;
#define get_true_type(left_type, right) \
if (!scope.in_global()) \
{ \
if (left_type == INT32_T && right->get_type() == FLOAT_T) \
{ \
right = builder->create_fptosi(right, INT32_T); \
} \
else if (left_type == INT32_T && right->get_type() == INT1_T) \
{ \
right = builder->create_zext(right, INT32_T); \
} \
else if (left_type == INT1_T && right->get_type() == FLOAT_T) \
{ \
right = builder->create_fcmp_ne(right, CONST_FLOAT(0)); \
} \
else if (left_type == INT1_T && right->get_type() == INT32_T) \
{ \
right = builder->create_icmp_ne(right, CONST_INT(0)); \
} \
else if (left_type == FLOAT_T && right->get_type() == INT32_T) \
{ \
right = builder->create_sitofp(right, FLOAT_T); \
} \
else if (left_type == FLOAT_T && right->get_type() == INT1_T) \
{ \
right = builder->create_zext(right, FLOAT_T); \
} \
} \
else \
{ \
if (left_type == FLOAT_T && right->get_type() != FLOAT_T) \
{ \
right = CONST_FLOAT(static_cast<float>(dynamic_pointer_cast<ConstantInt>(right)->get_value())); \
} \
else if (left_type == INT32_T && right->get_type() != INT32_T) \
{ \
right = CONST_INT(static_cast<int>(dynamic_pointer_cast<ConstantFloat>(right)->get_value())); \
} \
}
#define LVal_to_RVal(lval) \ #define LVal_to_RVal(lval) \
if(lval->get_type()==INT32PTR_T || lval->get_type()==FLOATPTR_T){\ if (lval->get_type() == INT32PTR_T || lval->get_type() == FLOATPTR_T) \
lval=builder->create_load(lval);\ { \
auto middle = lval; \
lval = builder->create_load(middle); \
} }
void IRBuilder::visit(SyntaxTree::Assembly &node) void IRBuilder::visit(SyntaxTree::Assembly &node)
@ -74,7 +116,16 @@ namespace SysYF
{ {
node.expr->accept(*this); // 有可能是计算表达式，也有可能是赋值语句 node.expr->accept(*this); // 有可能是计算表达式，也有可能是赋值语句
LVal_to_RVal(tmp_val); LVal_to_RVal(tmp_val);
init_list.push_back(tmp_val); // 把tmp_val放到init_list里面 get_true_type(array_init_type, tmp_val);
// 把tmp_val放到init_list里面
if (array_init_type == INT32_T)
{
init_list.push_back(dynamic_pointer_cast<ConstantInt>(tmp_val));
}
else
{
init_list.push_back(dynamic_pointer_cast<ConstantFloat>(tmp_val));
}
} }
} // init values } // init values
@ -123,11 +174,20 @@ namespace SysYF
switch (node.ret_type) switch (node.ret_type)
{ {
case SyntaxTree::Type::VOID: case SyntaxTree::Type::VOID:
{
builder->create_void_ret(); builder->create_void_ret();
break;
}
case SyntaxTree::Type::INT: case SyntaxTree::Type::INT:
{
builder->create_ret(CONST_INT(0)); builder->create_ret(CONST_INT(0));
break;
}
case SyntaxTree::Type::FLOAT: case SyntaxTree::Type::FLOAT:
{
builder->create_ret(CONST_FLOAT(0)); builder->create_ret(CONST_FLOAT(0));
break;
}
default: default:
break; break;
} }
@ -183,17 +243,52 @@ namespace SysYF
{ {
if (scope.in_global()) // 如果是全局变量 if (scope.in_global()) // 如果是全局变量
{ {
auto global_var = GlobalVariable::create(var_name, module, var_type, is_const, ConstantZero::create(var_type, module)); if (is_const)
{
if (is_initialized) if (is_initialized)
{ {
init_val->accept(*this); init_val->accept(*this);
LVal_to_RVal(tmp_val); LVal_to_RVal(tmp_val);
builder->create_store(tmp_val, global_var); get_true_type(var_type, tmp_val);
if (var_type == INT32_T)
{
auto global_var = GlobalVariable::create(var_name, module, var_type, true, dynamic_pointer_cast<ConstantInt>(tmp_val));
scope.push(var_name, global_var);
} }
else if (is_const) // 说明是const，但是没有初始化 else
{
auto global_var = GlobalVariable::create(var_name, module, var_type, true, dynamic_pointer_cast<ConstantFloat>(tmp_val));
scope.push(var_name, global_var);
}
}
else
cout << "const variable must be initialized" << endl; cout << "const variable must be initialized" << endl;
}
else
{
if (is_initialized)
{
init_val->accept(*this);
LVal_to_RVal(tmp_val);
get_true_type(var_type, tmp_val);
if (var_type == INT32_T)
{
auto global_var = GlobalVariable::create(var_name, module, var_type, false, dynamic_pointer_cast<ConstantInt>(tmp_val));
scope.push(var_name, global_var);
}
else
{
auto global_var = GlobalVariable::create(var_name, module, var_type, false, dynamic_pointer_cast<ConstantFloat>(tmp_val));
scope.push(var_name, global_var); scope.push(var_name, global_var);
} }
}
else
{
auto global_var = GlobalVariable::create(var_name, module, var_type, false, ConstantZero::create(var_type, module));
scope.push(var_name, global_var);
}
}
}
else // 如果是局部变量 else // 如果是局部变量
{ {
auto var = builder->create_alloca(var_type); auto var = builder->create_alloca(var_type);
@ -201,7 +296,8 @@ namespace SysYF
{ {
init_val->accept(*this); init_val->accept(*this);
LVal_to_RVal(tmp_val); LVal_to_RVal(tmp_val);
builder->create_store(tmp_val , var); get_true_type(var_type, tmp_val);
builder->create_store(tmp_val, var);
} }
else if (is_const) // 说明是const，但是没有初始化 else if (is_const) // 说明是const，但是没有初始化
cout << "const variable must be initialized" << endl; cout << "const variable must be initialized" << endl;
@ -210,31 +306,58 @@ namespace SysYF
} }
else // 数组 else // 数组
{ {
auto arrayType = ArrayType::get(var_type, length.size()); for (const auto &exp : length)
{
exp->accept(*this);
}
auto array_len = dynamic_pointer_cast<ConstantInt>(tmp_val)->get_value();
auto arrayType = ArrayType::get(var_type, array_len);
array_init_type = var_type;
if (scope.in_global()) // 如果是全局变量 if (scope.in_global()) // 如果是全局变量
{ {
auto global_array = GlobalVariable::create(var_name, module, arrayType, is_const, ConstantZero::create(var_type, module)); if (is_const)
{
if (is_initialized) if (is_initialized)
{ {
init_list.clear(); // 清空init_list init_list.clear(); // 清空init_list
init_val->accept(*this); // 把init_val里面的值放到init_list里面 init_val->accept(*this); // 把init_val里面的值放到init_list里面
while (init_list.size() < length.size()) // 如果init_list的长度小于length的长度，就把init_list其他的值补上0 while (static_cast<int>(init_list.size()) < array_len) // 如果init_list的长度小于length的长度，就把init_list其他的值补上0
{ {
init_list.push_back(ConstantZero::create(type_map[node.btype], module)); init_list.push_back(ConstantZero::create(type_map[node.btype], module));
} }
// initilize auto array_initializer = ConstantArray::create(arrayType, init_list);
for (auto i = 0; i < static_cast<int>(init_list.size()); i++) auto global_var = GlobalVariable::create(var_name, module, arrayType, true, array_initializer);
scope.push(var_name, global_var);
}
else
cout << "const variable must be initialized" << endl;
}
else
{ {
auto GEP = builder->create_gep(global_array, {CONST_INT(0), CONST_INT(i)}); if (is_initialized)
builder->create_store(init_list[i], GEP); {
init_list.clear(); // 清空init_list
init_val->accept(*this); // 把init_val里面的值放到init_list里面
while (static_cast<int>(init_list.size()) < array_len) // 如果init_list的长度小于length的长度，就把init_list其他的值补上0
{
init_list.push_back(ConstantZero::create(type_map[node.btype], module));
}
auto array_initializer = ConstantArray::create(arrayType, init_list);
auto global_var = GlobalVariable::create(var_name, module, arrayType, false, array_initializer);
scope.push(var_name, global_var);
}
else
{
init_list.clear();
while (init_list.size() < length.size()) // 如果init_list的长度小于length的长度，就把init_list其他的值补上0
{
init_list.push_back(ConstantZero::create(type_map[node.btype], module));
}
auto array_initializer = ConstantArray::create(arrayType, init_list);
auto global_var = GlobalVariable::create(var_name, module, arrayType, false, array_initializer);
scope.push(var_name, global_var);
} }
} }
else if (is_const) // 说明是const，但是没有初始化
cout << "const variable must be initialized" << endl;
scope.push(var_name, global_array);
} }
else else
{ {
@ -262,27 +385,67 @@ namespace SysYF
} }
} }
} }
// int c;
// c = 1.8;
void IRBuilder::visit(SyntaxTree::LVal &node) void IRBuilder::visit(SyntaxTree::LVal &node)
{ {
auto name = node.name; auto name = node.name;
auto index = node.array_index; auto index = node.array_index;
auto lval = scope.find(name, false); auto lval = scope.find(name, false);
if (lval) if (lval)
{
if (scope.in_global())
{
auto global_var = dynamic_pointer_cast<GlobalVariable>(lval);
if (global_var->is_const())
{
if (index.empty()) //
{
tmp_val = global_var->get_init();
}
else
{
for (const auto &exp : index)
{
exp->accept(*this);
}
auto GEP = dynamic_pointer_cast<ConstantInt>(tmp_val);
tmp_val = dynamic_pointer_cast<ConstantArray>(global_var->get_init())->get_element_value(GEP->get_value());
}
}
else
{
if (index.empty())
{
tmp_val = global_var->get_init();
}
else
{
for (const auto &exp : index)
{
exp->accept(*this);
}
auto GEP = dynamic_pointer_cast<ConstantInt>(tmp_val);
tmp_val = dynamic_pointer_cast<ConstantArray>(global_var->get_init())->get_element_value(GEP->get_value());
}
}
}
else
{ {
if (!index.empty()) if (!index.empty())
{ {
for (const auto &exp : index) for (const auto &exp : index)
{ {
exp->accept(*this); exp->accept(*this);
auto tmp = tmp_val;
auto GEP = builder->create_gep(lval, {tmp});
lval = GEP;
} }
auto tmp = tmp_val;
auto GEP = builder->create_gep(lval, {CONST_INT(0), tmp});
tmp_val = (GEP);
} }
else else
{ // 从符号表中取出的是字面值 { // 从符号表中取出的是字面值
tmp_val = lval; tmp_val = (lval);
}
} }
} }
else else
@ -294,12 +457,11 @@ namespace SysYF
void IRBuilder::visit(SyntaxTree::AssignStmt &node) void IRBuilder::visit(SyntaxTree::AssignStmt &node)
{ {
node.target->accept(*this); node.target->accept(*this);
auto target = builder->create_load(tmp_val);//? auto target = tmp_val; //?Const_int(1).get_type() == INT32_T
auto name = target->get_name(); node.value->accept(*this); //?
node.value->accept(*this);//?
LVal_to_RVal(tmp_val); LVal_to_RVal(tmp_val);
auto value = tmp_val; auto value = tmp_val;
get_true_type(target->get_type(), value);
builder->create_store(value, target); builder->create_store(value, target);
} }
@ -309,9 +471,15 @@ namespace SysYF
switch (type) switch (type)
{ {
case SyntaxTree::Type::INT: case SyntaxTree::Type::INT:
{
tmp_val = CONST_INT(node.int_const); tmp_val = CONST_INT(node.int_const);
break;
}
case SyntaxTree::Type::FLOAT: case SyntaxTree::Type::FLOAT:
{
tmp_val = CONST_FLOAT(node.float_const); tmp_val = CONST_FLOAT(node.float_const);
break;
}
default: default:
break; break;
} }
@ -327,11 +495,11 @@ namespace SysYF
auto value_type = tmp_val->get_type(); auto value_type = tmp_val->get_type();
auto ret_type = module->get_functions().back()->get_return_type(); auto ret_type = module->get_functions().back()->get_return_type();
// 类型检查 // 类型检查
if(ret_type == INT32_T) if (ret_type == INT32_T)
{ {
if(value_type == FLOAT_T) if (value_type == FLOAT_T)
tmp_val = builder->create_fptosi(tmp_val, INT32_T); tmp_val = builder->create_fptosi(tmp_val, INT32_T);
else if(value_type == INT1_T) else if (value_type == INT1_T)
tmp_val = builder->create_zext(tmp_val, INT32_T); tmp_val = builder->create_zext(tmp_val, INT32_T);
} }
auto value = tmp_val; auto value = tmp_val;
@ -359,7 +527,6 @@ namespace SysYF
void IRBuilder::visit(SyntaxTree::EmptyStmt &node) void IRBuilder::visit(SyntaxTree::EmptyStmt &node)
{ {
node.accept(*this);
} }
void IRBuilder::visit(SyntaxTree::ExprStmt &node) void IRBuilder::visit(SyntaxTree::ExprStmt &node)
@ -375,13 +542,13 @@ namespace SysYF
// 整数 // 整数
if (rhs->get_type() == INT32_T) if (rhs->get_type() == INT32_T)
{ {
auto UnaryCondExpr = builder->create_icmp_eq(rhs, CONST_INT(0)); tmp_val = builder->create_icmp_eq(rhs, CONST_INT(0));
scope.push("CondExpr", UnaryCondExpr); // scope.push("CondExpr", UnaryCondExpr);
} }
else else
{ {
auto UnaryCondExpr = builder->create_fcmp_eq(rhs, CONST_FLOAT(0)); tmp_val = builder->create_fcmp_eq(rhs, CONST_FLOAT(0));
scope.push("CondExpr", UnaryCondExpr); // scope.push("CondExpr", UnaryCondExpr);
} }
} }
@ -448,32 +615,32 @@ namespace SysYF
if (lhs_type == INT1_T && rhs_type == INT32_T) if (lhs_type == INT1_T && rhs_type == INT32_T)
{ {
lhs = dynamic_pointer_cast<SysYF::IR::LoadInst>(builder->create_zext(lhs, INT32_T)); lhs = builder->create_zext(lhs, INT32_T);
} }
else if (lhs_type == INT1_T && rhs_type == FLOAT_T) else if (lhs_type == INT1_T && rhs_type == FLOAT_T)
{ {
lhs = dynamic_pointer_cast<SysYF::IR::LoadInst>(builder->create_zext(lhs, FLOAT_T)); lhs = (builder->create_zext(lhs, FLOAT_T));
} }
else if (lhs_type == INT32_T && rhs_type == INT1_T) else if (lhs_type == INT32_T && rhs_type == INT1_T)
{ {
rhs = dynamic_pointer_cast<SysYF::IR::LoadInst>(builder->create_zext(rhs, INT32_T)); rhs = (builder->create_zext(rhs, INT32_T));
} }
else if (lhs_type == FLOAT_T && rhs_type == INT1_T) else if (lhs_type == FLOAT_T && rhs_type == INT1_T)
{ {
rhs = dynamic_pointer_cast<SysYF::IR::LoadInst>(builder->create_zext(rhs, FLOAT_T)); rhs = (builder->create_zext(rhs, FLOAT_T));
} }
else if (lhs_type == FLOAT_T && rhs_type == INT32_T) else if (lhs_type == FLOAT_T && rhs_type == INT32_T)
{ {
rhs = dynamic_pointer_cast<SysYF::IR::LoadInst>(builder->create_sitofp(rhs, FLOAT_T)); rhs = (builder->create_sitofp(rhs, FLOAT_T));
} }
else if (lhs_type == INT32_T && rhs_type == FLOAT_T) else if (lhs_type == INT32_T && rhs_type == FLOAT_T)
{ {
lhs = dynamic_pointer_cast<SysYF::IR::LoadInst>(builder->create_sitofp(lhs, FLOAT_T)); lhs = (builder->create_sitofp(lhs, FLOAT_T));
} }
else if (lhs_type == INT1_T && rhs_type == INT1_T) else if (lhs_type == INT1_T && rhs_type == INT1_T)
{ {
lhs = dynamic_pointer_cast<SysYF::IR::LoadInst>(builder->create_zext(lhs, INT32_T)); lhs = (builder->create_zext(lhs, INT32_T));
rhs = dynamic_pointer_cast<SysYF::IR::LoadInst>(builder->create_zext(rhs, INT32_T)); rhs = (builder->create_zext(rhs, INT32_T));
} }
// 整数 // 整数
if (rhs->get_type() == INT32_T) if (rhs->get_type() == INT32_T)
@ -506,6 +673,12 @@ namespace SysYF
case SysYF::SyntaxTree::BinaryCondOp::EQ: case SysYF::SyntaxTree::BinaryCondOp::EQ:
{ {
tmp_val = builder->create_icmp_eq(lhs, rhs); tmp_val = builder->create_icmp_eq(lhs, rhs);
break;
}
case SysYF::SyntaxTree::BinaryCondOp::NEQ:
{
tmp_val = builder->create_icmp_ne(lhs, rhs);
break;
} }
default: default:
break; break;
@ -541,6 +714,12 @@ namespace SysYF
case SysYF::SyntaxTree::BinaryCondOp::EQ: case SysYF::SyntaxTree::BinaryCondOp::EQ:
{ {
tmp_val = builder->create_fcmp_eq(lhs, rhs); tmp_val = builder->create_fcmp_eq(lhs, rhs);
break;
}
case SysYF::SyntaxTree::BinaryCondOp::NEQ:
{
tmp_val = builder->create_icmp_ne(lhs, rhs);
break;
} }
default: default:
break; break;
@ -553,25 +732,26 @@ namespace SysYF
{ {
// 整数 // 整数
node.rhs->accept(*this); node.rhs->accept(*this);
LVal_to_RVal(tmp_val);
auto rhs = tmp_val; auto rhs = tmp_val;
LVal_to_RVal(rhs);
auto rhs_type = rhs->get_type(); auto rhs_type = rhs->get_type();
node.lhs->accept(*this); node.lhs->accept(*this);
LVal_to_RVal(tmp_val);
auto lhs = tmp_val; auto lhs = tmp_val;
LVal_to_RVal(lhs);
auto lhs_type = lhs->get_type(); auto lhs_type = lhs->get_type();
if (lhs_type == FLOAT_T && rhs_type == INT32_T) if (lhs_type == FLOAT_T && rhs_type == INT32_T)
{ {
rhs = dynamic_pointer_cast<SysYF::IR::LoadInst>(builder->create_sitofp(rhs, FLOAT_T)); rhs = builder->create_sitofp(rhs, FLOAT_T);
} }
else if (lhs_type == INT32_T && rhs_type == FLOAT_T) else if (lhs_type == INT32_T && rhs_type == FLOAT_T)
{ {
lhs = dynamic_pointer_cast<SysYF::IR::LoadInst>(builder->create_sitofp(lhs, FLOAT_T)); lhs = builder->create_sitofp(lhs, FLOAT_T);
} }
auto expr_type = lhs->get_type(); auto expr_type = lhs->get_type();
// 计算出可以直接计算的值 // 计算出可以直接计算的值
if ((dynamic_pointer_cast<ConstantFloat>(lhs) || dynamic_pointer_cast<ConstantFloat>(lhs)) && (dynamic_pointer_cast<ConstantFloat>(rhs) || dynamic_pointer_cast<ConstantFloat>(rhs))) if (((dynamic_pointer_cast<ConstantFloat>(lhs) || dynamic_pointer_cast<ConstantFloat>(lhs)) && (dynamic_pointer_cast<ConstantFloat>(rhs) || dynamic_pointer_cast<ConstantFloat>(rhs))) || scope.in_global())
{ // 简单字面量计算 { // 简单字面量计算
int lhs_int; int lhs_int;
int rhs_int; int rhs_int;
@ -643,60 +823,60 @@ namespace SysYF
} }
return; return;
} }
if (lhs_type == INT32_T) else if (expr_type == INT32_T)
{ {
switch (node.op) switch (node.op)
{ {
case SyntaxTree::BinOp::PLUS: case SyntaxTree::BinOp::PLUS:
{ {
builder->create_iadd(lhs, rhs); tmp_val = builder->create_iadd(lhs, rhs);
break; break;
} }
case SyntaxTree::BinOp::MINUS: case SyntaxTree::BinOp::MINUS:
{ {
builder->create_isub(lhs, rhs); tmp_val = builder->create_isub(lhs, rhs);
break; break;
} }
case SyntaxTree::BinOp::MULTIPLY: case SyntaxTree::BinOp::MULTIPLY:
{ {
builder->create_imul(lhs, rhs); tmp_val = builder->create_imul(lhs, rhs);
break; break;
} }
case SyntaxTree::BinOp::DIVIDE: case SyntaxTree::BinOp::DIVIDE:
{ {
builder->create_isdiv(lhs, rhs); tmp_val = builder->create_isdiv(lhs, rhs);
break; break;
} }
case SyntaxTree::BinOp::MODULO: case SyntaxTree::BinOp::MODULO:
{ {
builder->create_isrem(lhs, rhs); tmp_val = builder->create_isrem(lhs, rhs);
break; break;
} }
} }
} }
else if (lhs_type == FLOAT_T) else if (expr_type == FLOAT_T)
{ {
switch (node.op) switch (node.op)
{ {
case SyntaxTree::BinOp::PLUS: case SyntaxTree::BinOp::PLUS:
{ {
builder->create_fadd(lhs, rhs); tmp_val = builder->create_fadd(lhs, rhs);
break; break;
} }
case SyntaxTree::BinOp::MINUS: case SyntaxTree::BinOp::MINUS:
{ {
builder->create_fsub(lhs, rhs); tmp_val = builder->create_fsub(lhs, rhs);
break; break;
} }
case SyntaxTree::BinOp::MULTIPLY: case SyntaxTree::BinOp::MULTIPLY:
{ {
builder->create_fmul(lhs, rhs); tmp_val = builder->create_fmul(lhs, rhs);
break; break;
} }
case SyntaxTree::BinOp::DIVIDE: case SyntaxTree::BinOp::DIVIDE:
{ {
builder->create_fdiv(lhs, rhs); tmp_val = builder->create_fdiv(lhs, rhs);
break; break;
} }
case SyntaxTree::BinOp::MODULO: case SyntaxTree::BinOp::MODULO:
@ -760,12 +940,12 @@ namespace SysYF
{ {
case SyntaxTree::UnaryOp::PLUS: case SyntaxTree::UnaryOp::PLUS:
{ {
builder->create_iadd(rhs, CONST_INT(0)); tmp_val = builder->create_iadd(rhs, CONST_INT(0));
break; break;
} }
case SyntaxTree::UnaryOp::MINUS: case SyntaxTree::UnaryOp::MINUS:
{ {
builder->create_isub(CONST_INT(0), rhs); tmp_val = builder->create_isub(CONST_INT(0), rhs);
break; break;
} }
} }
@ -776,12 +956,12 @@ namespace SysYF
{ {
case SyntaxTree::UnaryOp::PLUS: case SyntaxTree::UnaryOp::PLUS:
{ {
builder->create_fadd(rhs, CONST_FLOAT(0)); tmp_val = builder->create_fadd(rhs, CONST_FLOAT(0));
break; break;
} }
case SyntaxTree::UnaryOp::MINUS: case SyntaxTree::UnaryOp::MINUS:
{ {
builder->create_fsub(CONST_FLOAT(0), rhs); tmp_val = builder->create_fsub(CONST_FLOAT(0), rhs);
break; break;
} }
} }
@ -826,12 +1006,16 @@ namespace SysYF
{ {
tmp_val = builder->create_fptosi(value, INT32_T); tmp_val = builder->create_fptosi(value, INT32_T);
} }
else
{
tmp_val = value;
}
} }
args.push_back(tmp_val); args.push_back(tmp_val);
} }
builder->create_call(func, args); tmp_val = builder->create_call(func, args);
} }
} }
@ -873,31 +1057,38 @@ namespace SysYF
auto falseBB = BasicBlock::create(module, "falseBB_while", auto falseBB = BasicBlock::create(module, "falseBB_while",
module->get_functions().back()); module->get_functions().back());
scope.push("condBB", condBB); scope.push("condBB_while", condBB);
scope.push("trueBB", trueBB); scope.push("trueBB_while", trueBB);
scope.push("falseBB", falseBB); scope.push("falseBB_while", falseBB);
builder->create_br(condBB); builder->create_br(condBB);
builder->set_insert_point(condBB);
node.cond_exp->accept(*this); node.cond_exp->accept(*this);
LVal_to_RVal(tmp_val); LVal_to_RVal(tmp_val);
auto cond = tmp_val; auto cond = tmp_val;
builder->create_cond_br(cond, trueBB, falseBB); builder->create_cond_br(cond, trueBB, falseBB);
auto cond_val = tmp_val; builder->set_insert_point(trueBB);
node.statement->accept(*this);
builder->create_br(condBB);
builder->set_insert_point(falseBB);
// auto cond_val = tmp_val;
scope.exit(); scope.exit();
} }
void IRBuilder::visit(SyntaxTree::BreakStmt &node) void IRBuilder::visit(SyntaxTree::BreakStmt &node)
{ {
node.accept(*this); auto falseBB = scope.find("falseBB_while", 0);
auto falseBB = scope.find("falseBB", 0);
builder->create_br(dynamic_pointer_cast<SysYF::IR::BasicBlock>(falseBB)); builder->create_br(dynamic_pointer_cast<SysYF::IR::BasicBlock>(falseBB));
} }
void IRBuilder::visit(SyntaxTree::ContinueStmt &node) void IRBuilder::visit(SyntaxTree::ContinueStmt &node)
{ {
node.accept(*this); auto condBB = scope.find("condBB_while", 0);
auto condBB = scope.find("condBB", 0);
builder->create_br(dynamic_pointer_cast<SysYF::IR::BasicBlock>(condBB)); builder->create_br(dynamic_pointer_cast<SysYF::IR::BasicBlock>(condBB));
} }
} }

Write Preview
Loading…
Cancel
Save