|
|
#include "irgen/IRGen.h"
|
|
|
|
|
|
#include <cmath>
|
|
|
#include <limits>
|
|
|
#include <stdexcept>
|
|
|
|
|
|
#include "SysYParser.h"
|
|
|
#include "ir/IR.h"
|
|
|
#include "utils/Log.h"
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
int ParseIntLiteral(const std::string& text) {
|
|
|
size_t parsed = 0;
|
|
|
long long value = std::stoll(text, &parsed, 0);
|
|
|
if (parsed != text.size()) {
|
|
|
throw std::runtime_error(FormatError("irgen", "非法整数字面量: " + text));
|
|
|
}
|
|
|
if (value < std::numeric_limits<int>::min() ||
|
|
|
value > std::numeric_limits<int>::max()) {
|
|
|
throw std::runtime_error(FormatError("irgen", "整数字面量越界: " + text));
|
|
|
}
|
|
|
return static_cast<int>(value);
|
|
|
}
|
|
|
|
|
|
double ParseFloatLiteral(const std::string& text) {
|
|
|
if (text.find("0x") == 0 || text.find("0X") == 0) {
|
|
|
// 手动解析十六进制浮点数常量
|
|
|
// 格式: 0x[hex_digits][.[hex_digits]][p|P[+|-][decimal_digits]]
|
|
|
std::string hex_part;
|
|
|
std::string exp_part;
|
|
|
size_t p_pos = text.find_first_of("pP");
|
|
|
|
|
|
if (p_pos != std::string::npos) {
|
|
|
hex_part = text.substr(0, p_pos);
|
|
|
exp_part = text.substr(p_pos + 1);
|
|
|
} else {
|
|
|
hex_part = text;
|
|
|
exp_part = "0";
|
|
|
}
|
|
|
|
|
|
// 解析十六进制部分
|
|
|
double mantissa = 0.0;
|
|
|
double frac = 0.0;
|
|
|
double frac_divisor = 1.0;
|
|
|
bool in_frac = false;
|
|
|
|
|
|
for (size_t i = 2; i < hex_part.size(); i++) {
|
|
|
char c = hex_part[i];
|
|
|
if (c == '.') {
|
|
|
in_frac = true;
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
int digit;
|
|
|
if (c >= '0' && c <= '9') {
|
|
|
digit = c - '0';
|
|
|
} else if (c >= 'a' && c <= 'f') {
|
|
|
digit = 10 + (c - 'a');
|
|
|
} else if (c >= 'A' && c <= 'F') {
|
|
|
digit = 10 + (c - 'A');
|
|
|
} else {
|
|
|
throw std::runtime_error(FormatError("irgen", "非法浮点字面量: " + text));
|
|
|
}
|
|
|
|
|
|
if (in_frac) {
|
|
|
frac_divisor *= 16.0;
|
|
|
frac += digit / frac_divisor;
|
|
|
} else {
|
|
|
mantissa = mantissa * 16.0 + digit;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
mantissa += frac;
|
|
|
|
|
|
// 解析指数部分
|
|
|
int exponent = 0;
|
|
|
if (!exp_part.empty()) {
|
|
|
try {
|
|
|
exponent = std::stoi(exp_part);
|
|
|
} catch (...) {
|
|
|
throw std::runtime_error(FormatError("irgen", "非法浮点字面量: " + text));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return mantissa * std::pow(2.0, exponent);
|
|
|
} else {
|
|
|
// 解析十进制浮点数常量
|
|
|
char* end = nullptr;
|
|
|
double value = std::strtod(text.c_str(), &end);
|
|
|
if (end == text.c_str()) {
|
|
|
throw std::runtime_error(FormatError("irgen", "非法浮点字面量: " + text));
|
|
|
}
|
|
|
if (static_cast<size_t>(end - text.c_str()) != text.size()) {
|
|
|
throw std::runtime_error(FormatError("irgen", "非法浮点字面量: " + text));
|
|
|
}
|
|
|
return value;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void CollectInitExprs(SysYParser::InitValContext* init,
|
|
|
std::vector<SysYParser::ExpContext*>& out,
|
|
|
const std::vector<int>& dims,
|
|
|
size_t dim_idx = 0) {
|
|
|
if (!init) {
|
|
|
return;
|
|
|
}
|
|
|
if (init->exp()) {
|
|
|
out.push_back(init->exp());
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 计算当前维度的大小
|
|
|
size_t current_dim_size = 1;
|
|
|
for (size_t i = dim_idx; i < dims.size(); ++i) {
|
|
|
current_dim_size *= dims[i];
|
|
|
}
|
|
|
|
|
|
size_t start_pos = out.size();
|
|
|
auto nested_inits = init->initVal();
|
|
|
|
|
|
if (dims.empty()) {
|
|
|
// 标量，直接处理
|
|
|
for (auto* nested : nested_inits) {
|
|
|
CollectInitExprs(nested, out, dims, dim_idx);
|
|
|
}
|
|
|
} else if (dim_idx < dims.size() - 1) {
|
|
|
// 多维数组，递归处理每个子数组
|
|
|
size_t sub_dim_size = 1;
|
|
|
for (size_t i = dim_idx + 1; i < dims.size(); ++i) {
|
|
|
sub_dim_size *= dims[i];
|
|
|
}
|
|
|
|
|
|
for (auto* nested : nested_inits) {
|
|
|
if (out.size() >= start_pos + current_dim_size) {
|
|
|
break;
|
|
|
}
|
|
|
CollectInitExprs(nested, out, dims, dim_idx + 1);
|
|
|
}
|
|
|
} else {
|
|
|
// 一维数组，直接展平所有初始化表达式
|
|
|
for (auto* nested : nested_inits) {
|
|
|
if (out.size() >= start_pos + current_dim_size) {
|
|
|
break;
|
|
|
}
|
|
|
CollectInitExprs(nested, out, dims, dim_idx);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 确保不超过当前维度的大小
|
|
|
if (out.size() > start_pos + current_dim_size) {
|
|
|
// 截断超出的部分
|
|
|
out.resize(start_pos + current_dim_size);
|
|
|
}
|
|
|
|
|
|
// 补齐到当前维度大小
|
|
|
while (out.size() < start_pos + current_dim_size) {
|
|
|
out.push_back(nullptr);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void CollectConstInitExprs(SysYParser::ConstInitValContext* init,
|
|
|
std::vector<SysYParser::ConstExpContext*>& out,
|
|
|
const std::vector<int>& dims,
|
|
|
size_t dim_idx = 0) {
|
|
|
if (!init) {
|
|
|
return;
|
|
|
}
|
|
|
if (init->constExp()) {
|
|
|
out.push_back(init->constExp());
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 计算当前维度的大小
|
|
|
size_t current_dim_size = 1;
|
|
|
for (size_t i = dim_idx; i < dims.size(); ++i) {
|
|
|
current_dim_size *= dims[i];
|
|
|
}
|
|
|
|
|
|
size_t start_pos = out.size();
|
|
|
auto nested_inits = init->constInitVal();
|
|
|
|
|
|
if (dims.empty()) {
|
|
|
// 标量，直接处理
|
|
|
for (auto* nested : nested_inits) {
|
|
|
CollectConstInitExprs(nested, out, dims, dim_idx);
|
|
|
}
|
|
|
} else if (dim_idx < dims.size() - 1) {
|
|
|
// 多维数组，递归处理每个子数组
|
|
|
size_t sub_dim_size = 1;
|
|
|
for (size_t i = dim_idx + 1; i < dims.size(); ++i) {
|
|
|
sub_dim_size *= dims[i];
|
|
|
}
|
|
|
|
|
|
for (auto* nested : nested_inits) {
|
|
|
if (out.size() >= start_pos + current_dim_size) {
|
|
|
break;
|
|
|
}
|
|
|
CollectConstInitExprs(nested, out, dims, dim_idx + 1);
|
|
|
}
|
|
|
} else {
|
|
|
// 一维数组，直接展平所有初始化表达式
|
|
|
for (auto* nested : nested_inits) {
|
|
|
if (out.size() >= start_pos + current_dim_size) {
|
|
|
break;
|
|
|
}
|
|
|
CollectConstInitExprs(nested, out, dims, dim_idx);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 确保不超过当前维度的大小
|
|
|
if (out.size() > start_pos + current_dim_size) {
|
|
|
// 截断超出的部分
|
|
|
out.resize(start_pos + current_dim_size);
|
|
|
}
|
|
|
|
|
|
// 补齐到当前维度大小
|
|
|
while (out.size() < start_pos + current_dim_size) {
|
|
|
out.push_back(nullptr);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
} // namespace
|
|
|
|
|
|
ir::AllocaInst* IRGenImpl::CreateEntryBlockAlloca(std::shared_ptr<ir::Type> elem_ty,
|
|
|
const std::string& name,
|
|
|
ir::Value* count) {
|
|
|
if (!func_ || func_->GetBlocks().empty()) {
|
|
|
throw std::runtime_error(FormatError("irgen", "无法在入口块分配栈空间：函数未定义或无基本块"));
|
|
|
}
|
|
|
|
|
|
auto* entry_block = func_->GetBlocks().front().get();
|
|
|
|
|
|
auto* alloca = entry_block->InsertAlloca<ir::AllocaInst>(elem_ty, name, count);
|
|
|
|
|
|
return alloca;
|
|
|
}
|
|
|
|
|
|
std::shared_ptr<ir::Type> IRGenImpl::ResolveBType(
|
|
|
SysYParser::BTypeContext* btype) const {
|
|
|
if (!btype) {
|
|
|
throw std::runtime_error(FormatError("irgen", "缺少基础类型"));
|
|
|
}
|
|
|
if (btype->Int()) {
|
|
|
return ir::Type::GetInt32Type();
|
|
|
}
|
|
|
if (btype->Float()) {
|
|
|
return ir::Type::GetFloat32Type();
|
|
|
}
|
|
|
throw std::runtime_error(FormatError("irgen", "当前仅支持 int/float 类型"));
|
|
|
}
|
|
|
|
|
|
std::any IRGenImpl::visitBlock(SysYParser::BlockContext* ctx) {
|
|
|
if (!ctx) {
|
|
|
throw std::runtime_error(FormatError("irgen", "缺少语句块"));
|
|
|
}
|
|
|
|
|
|
// 进入新的作用域，保存当前常量映射状态
|
|
|
const_value_history_.push_back(const_value_map_);
|
|
|
local_const_stack_.emplace_back();
|
|
|
|
|
|
bool terminated = false;
|
|
|
for (auto* item : ctx->blockItem()) {
|
|
|
if (item) {
|
|
|
if (VisitBlockItemResult(*item) == BlockFlow::Terminated) {
|
|
|
// 当前语法要求 return 为块内最后一条语句；命中后可停止生成。
|
|
|
terminated = true;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 退出作用域，恢复常量映射状态
|
|
|
const_value_map_ = const_value_history_.back();
|
|
|
const_value_history_.pop_back();
|
|
|
local_const_stack_.pop_back();
|
|
|
|
|
|
return terminated ? BlockFlow::Terminated : BlockFlow::Continue;
|
|
|
}
|
|
|
|
|
|
IRGenImpl::BlockFlow IRGenImpl::VisitBlockItemResult(
|
|
|
SysYParser::BlockItemContext& item) {
|
|
|
return std::any_cast<BlockFlow>(item.accept(this));
|
|
|
}
|
|
|
|
|
|
std::any IRGenImpl::visitBlockItem(SysYParser::BlockItemContext* ctx) {
|
|
|
if (!ctx) {
|
|
|
throw std::runtime_error(FormatError("irgen", "缺少块内项"));
|
|
|
}
|
|
|
if (ctx->decl()) {
|
|
|
ctx->decl()->accept(this);
|
|
|
return BlockFlow::Continue;
|
|
|
}
|
|
|
if (ctx->stmt()) {
|
|
|
return ctx->stmt()->accept(this);
|
|
|
}
|
|
|
throw std::runtime_error(FormatError("irgen", "暂不支持的语句或声明"));
|
|
|
}
|
|
|
|
|
|
// 变量声明的 IR 生成目前也是最小实现：
|
|
|
// - 先检查声明的基础类型，当前仅支持局部 int；
|
|
|
// - 再把 Decl 中的变量定义交给 visitVarDef 继续处理。
|
|
|
//
|
|
|
// 和更完整的版本相比，这里还没有：
|
|
|
// - 一个 Decl 中多个变量定义的顺序处理；
|
|
|
// - const、数组、全局变量等不同声明形态；
|
|
|
// - 更丰富的类型系统。
|
|
|
std::any IRGenImpl::visitDecl(SysYParser::DeclContext* ctx) {
|
|
|
if (!ctx) {
|
|
|
throw std::runtime_error(FormatError("irgen", "缺少变量声明"));
|
|
|
}
|
|
|
if (ctx->constDecl()) {
|
|
|
auto* const_decl = ctx->constDecl();
|
|
|
if (!const_decl || !const_decl->bType()) {
|
|
|
throw std::runtime_error(FormatError("irgen", "非法常量声明"));
|
|
|
}
|
|
|
auto elem_ty = ResolveBType(const_decl->bType());
|
|
|
const bool is_float = elem_ty->IsFloat32();
|
|
|
for (auto* def : const_decl->constDef()) {
|
|
|
if (!def || !def->Ident()) {
|
|
|
continue;
|
|
|
}
|
|
|
const std::string name = def->Ident()->getText();
|
|
|
if (def->constExp().empty()) {
|
|
|
if (!is_float && def->constInitVal() && def->constInitVal()->constExp()) {
|
|
|
int const_value = EvalConstIntExpr(*def->constInitVal()->constExp());
|
|
|
if (!func_) {
|
|
|
// 只对全局整型常量进行常量折叠
|
|
|
const_value_map_[name] = const_value;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (func_) {
|
|
|
// 局部常量：分配栈空间
|
|
|
auto* slot = builder_.CreateAlloca(elem_ty, module_.GetContext().NextTemp());
|
|
|
const_storage_map_[def] = slot;
|
|
|
ir::Value* init_elem = nullptr;
|
|
|
if (def->constInitVal() && def->constInitVal()->constExp()) {
|
|
|
init_elem = CastValueTo(
|
|
|
std::any_cast<ir::Value*>(def->constInitVal()->constExp()->accept(this)),
|
|
|
elem_ty);
|
|
|
} else {
|
|
|
init_elem = is_float ? static_cast<ir::Value*>(builder_.CreateConstFloat(0.0))
|
|
|
: static_cast<ir::Value*>(builder_.CreateConstInt(0));
|
|
|
}
|
|
|
builder_.CreateStore(init_elem, slot);
|
|
|
} else {
|
|
|
// 全局常量：创建全局变量
|
|
|
if (is_float) {
|
|
|
double init_value = 0.0;
|
|
|
if (def->constInitVal() && def->constInitVal()->constExp()) {
|
|
|
init_value = EvalConstFloatExpr(*def->constInitVal()->constExp());
|
|
|
}
|
|
|
auto* global = module_.CreateGlobalF32(name, init_value);
|
|
|
const_global_storage_map_[def] = global;
|
|
|
} else {
|
|
|
int init_value = 0;
|
|
|
if (def->constInitVal() && def->constInitVal()->constExp()) {
|
|
|
init_value = EvalConstIntExpr(*def->constInitVal()->constExp());
|
|
|
}
|
|
|
auto* global = module_.CreateGlobalI32(name, init_value);
|
|
|
const_global_storage_map_[def] = global;
|
|
|
}
|
|
|
}
|
|
|
continue;
|
|
|
}
|
|
|
auto extents = EvalArrayExtents(def->constExp());
|
|
|
size_t total_extent = 1;
|
|
|
for (int extent : extents) {
|
|
|
total_extent *= static_cast<size_t>(extent);
|
|
|
}
|
|
|
const_array_extents_map_[def] = extents;
|
|
|
|
|
|
if (!func_) {
|
|
|
std::vector<SysYParser::ConstExpContext*> init_exprs;
|
|
|
bool has_init = false;
|
|
|
if (def->constInitVal()) {
|
|
|
has_init = true;
|
|
|
CollectConstInitExprs(def->constInitVal(), init_exprs, extents);
|
|
|
if (init_exprs.size() > total_extent) {
|
|
|
throw std::runtime_error(FormatError("irgen", "数组初始化元素过多"));
|
|
|
}
|
|
|
}
|
|
|
std::vector<int> init_values;
|
|
|
std::vector<double> init_float_values;
|
|
|
if (is_float) {
|
|
|
if (has_init) {
|
|
|
init_float_values.reserve(total_extent);
|
|
|
for (size_t index = 0; index < total_extent; ++index) {
|
|
|
if (index < init_exprs.size() && init_exprs[index] && init_exprs[index]->addExp()) {
|
|
|
double value = 0.0;
|
|
|
auto* cf = dynamic_cast<ir::ConstantFloat*>(CastValueTo(
|
|
|
std::any_cast<ir::Value*>(init_exprs[index]->addExp()->accept(this)),
|
|
|
ir::Type::GetFloat32Type()));
|
|
|
if (cf) {
|
|
|
value = cf->GetValue();
|
|
|
}
|
|
|
init_float_values.push_back(value);
|
|
|
} else {
|
|
|
init_float_values.push_back(0.0);
|
|
|
}
|
|
|
}
|
|
|
size_t trailing_zeros = 0;
|
|
|
while (trailing_zeros < init_float_values.size() && init_float_values[init_float_values.size() - 1 - trailing_zeros] == 0.0) {
|
|
|
trailing_zeros++;
|
|
|
}
|
|
|
if (trailing_zeros > 0) {
|
|
|
init_float_values.resize(init_float_values.size() - trailing_zeros);
|
|
|
}
|
|
|
auto* global = module_.CreateGlobalArrayF32(name, total_extent, init_float_values);
|
|
|
const_global_storage_map_[def] = global;
|
|
|
} else {
|
|
|
auto* global = module_.CreateGlobalArrayF32(name, total_extent, {});
|
|
|
const_global_storage_map_[def] = global;
|
|
|
}
|
|
|
} else {
|
|
|
if (has_init) {
|
|
|
init_values.reserve(total_extent);
|
|
|
for (size_t index = 0; index < total_extent; ++index) {
|
|
|
if (index < init_exprs.size() && init_exprs[index] && init_exprs[index]->addExp()) {
|
|
|
int value = 0;
|
|
|
auto* ci = dynamic_cast<ir::ConstantInt*>(CastValueTo(
|
|
|
std::any_cast<ir::Value*>(init_exprs[index]->addExp()->accept(this)),
|
|
|
ir::Type::GetInt32Type()));
|
|
|
if (ci) {
|
|
|
value = ci->GetValue();
|
|
|
}
|
|
|
init_values.push_back(value);
|
|
|
} else {
|
|
|
init_values.push_back(0);
|
|
|
}
|
|
|
}
|
|
|
size_t trailing_zeros = 0;
|
|
|
while (trailing_zeros < init_values.size() && init_values[init_values.size() - 1 - trailing_zeros] == 0) {
|
|
|
trailing_zeros++;
|
|
|
}
|
|
|
if (trailing_zeros > 0) {
|
|
|
init_values.resize(init_values.size() - trailing_zeros);
|
|
|
}
|
|
|
auto* global = module_.CreateGlobalArrayI32(name, total_extent, init_values);
|
|
|
const_global_storage_map_[def] = global;
|
|
|
} else {
|
|
|
auto* global = module_.CreateGlobalArrayI32(name, total_extent, {});
|
|
|
const_global_storage_map_[def] = global;
|
|
|
}
|
|
|
}
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
auto* slot =
|
|
|
builder_.CreateAlloca(elem_ty, module_.GetContext().NextTemp(),
|
|
|
builder_.CreateConstInt(static_cast<int>(total_extent)));
|
|
|
const_storage_map_[def] = slot;
|
|
|
|
|
|
std::vector<SysYParser::ConstExpContext*> init_exprs;
|
|
|
CollectConstInitExprs(def->constInitVal(), init_exprs, extents);
|
|
|
if (init_exprs.size() > total_extent) {
|
|
|
throw std::runtime_error(FormatError("irgen", "数组初始化元素过多"));
|
|
|
}
|
|
|
for (size_t index = 0; index < total_extent; ++index) {
|
|
|
auto* idx = builder_.CreateConstInt(static_cast<int>(index));
|
|
|
auto* ptr = builder_.CreateGEP(slot, idx, module_.GetContext().NextTemp());
|
|
|
ir::Value* init_elem = nullptr;
|
|
|
if (index < init_exprs.size() && init_exprs[index] && init_exprs[index]->addExp()) {
|
|
|
init_elem = CastValueTo(
|
|
|
std::any_cast<ir::Value*>(init_exprs[index]->addExp()->accept(this)),
|
|
|
elem_ty);
|
|
|
} else {
|
|
|
init_elem = is_float ? static_cast<ir::Value*>(builder_.CreateConstFloat(0.0))
|
|
|
: static_cast<ir::Value*>(builder_.CreateConstInt(0));
|
|
|
}
|
|
|
builder_.CreateStore(init_elem, ptr);
|
|
|
}
|
|
|
}
|
|
|
return {};
|
|
|
}
|
|
|
if (!ctx->varDecl()) {
|
|
|
throw std::runtime_error(FormatError("irgen", "当前不支持 const 声明"));
|
|
|
}
|
|
|
ctx->varDecl()->accept(this);
|
|
|
return {};
|
|
|
}
|
|
|
|
|
|
std::any IRGenImpl::visitVarDecl(SysYParser::VarDeclContext* ctx) {
|
|
|
if (!ctx) {
|
|
|
throw std::runtime_error(FormatError("irgen", "非法变量声明"));
|
|
|
}
|
|
|
if (!ctx->bType() || (!ctx->bType()->Int() && !ctx->bType()->Float())) {
|
|
|
throw std::runtime_error(
|
|
|
FormatError("irgen", "当前仅支持局部 int/float 变量声明"));
|
|
|
}
|
|
|
const auto& defs = ctx->varDef();
|
|
|
if (defs.empty()) {
|
|
|
throw std::runtime_error(FormatError("irgen", "非法变量声明"));
|
|
|
}
|
|
|
for (auto* def : defs) {
|
|
|
if (!def) {
|
|
|
throw std::runtime_error(FormatError("irgen", "非法变量声明"));
|
|
|
}
|
|
|
def->accept(this);
|
|
|
}
|
|
|
return {};
|
|
|
}
|
|
|
|
|
|
|
|
|
// 当前仍是教学用的最小版本，因此这里只支持：
|
|
|
// - 局部 int 变量；
|
|
|
// - 标量初始化；
|
|
|
// - 一个 VarDef 对应一个槽位。
|
|
|
std::any IRGenImpl::visitVarDef(SysYParser::VarDefContext* ctx) {
|
|
|
if (!ctx) {
|
|
|
throw std::runtime_error(FormatError("irgen", "缺少变量定义"));
|
|
|
}
|
|
|
if (!ctx->Ident()) {
|
|
|
throw std::runtime_error(FormatError("irgen", "变量声明缺少名称"));
|
|
|
}
|
|
|
const std::string name = ctx->Ident()->getText();
|
|
|
auto* var_decl = dynamic_cast<SysYParser::VarDeclContext*>(ctx->parent);
|
|
|
auto elem_ty = ResolveBType(var_decl ? var_decl->bType() : nullptr);
|
|
|
const bool is_float = elem_ty->IsFloat32();
|
|
|
|
|
|
if (name.empty()) {
|
|
|
throw std::runtime_error(FormatError("irgen", "变量声明缺少名称"));
|
|
|
}
|
|
|
|
|
|
const bool is_array = !ctx->constExp().empty();
|
|
|
std::vector<int> extents;
|
|
|
size_t total_extent = 1;
|
|
|
if (is_array) {
|
|
|
extents = EvalArrayExtents(ctx->constExp());
|
|
|
for (int extent : extents) {
|
|
|
total_extent *= static_cast<size_t>(extent);
|
|
|
}
|
|
|
array_extents_map_[ctx] = extents;
|
|
|
}
|
|
|
|
|
|
if (!func_) {
|
|
|
if (global_storage_map_.find(ctx) != global_storage_map_.end()) {
|
|
|
throw std::runtime_error(FormatError("irgen", "声明重复生成全局变量"));
|
|
|
}
|
|
|
if (is_array) {
|
|
|
std::vector<SysYParser::ExpContext*> init_exprs;
|
|
|
bool has_init = false;
|
|
|
if (auto* init_value = ctx->initVal()) {
|
|
|
has_init = true;
|
|
|
CollectInitExprs(init_value, init_exprs, extents);
|
|
|
if (init_exprs.size() > total_extent) {
|
|
|
throw std::runtime_error(FormatError("irgen", "数组初始化元素过多"));
|
|
|
}
|
|
|
}
|
|
|
std::vector<int> init_values;
|
|
|
std::vector<double> init_float_values;
|
|
|
if (is_float) {
|
|
|
if (has_init) {
|
|
|
init_float_values.reserve(total_extent);
|
|
|
for (size_t index = 0; index < total_extent; ++index) {
|
|
|
if (index < init_exprs.size() && init_exprs[index]) {
|
|
|
double value = 0.0;
|
|
|
auto* folded = EvalExpr(*init_exprs[index]);
|
|
|
auto* cf = dynamic_cast<ir::ConstantFloat*>(CastValueTo(folded, ir::Type::GetFloat32Type()));
|
|
|
if (cf) {
|
|
|
value = cf->GetValue();
|
|
|
}
|
|
|
init_float_values.push_back(value);
|
|
|
} else {
|
|
|
init_float_values.push_back(0.0);
|
|
|
}
|
|
|
}
|
|
|
size_t trailing_zeros = 0;
|
|
|
while (trailing_zeros < init_float_values.size() && init_float_values[init_float_values.size() - 1 - trailing_zeros] == 0.0) {
|
|
|
trailing_zeros++;
|
|
|
}
|
|
|
if (trailing_zeros > 0) {
|
|
|
init_float_values.resize(init_float_values.size() - trailing_zeros);
|
|
|
}
|
|
|
auto* global = module_.CreateGlobalArrayF32(name, total_extent, init_float_values);
|
|
|
global_storage_map_[ctx] = global;
|
|
|
} else {
|
|
|
auto* global = module_.CreateGlobalArrayF32(name, total_extent, {});
|
|
|
global_storage_map_[ctx] = global;
|
|
|
}
|
|
|
} else {
|
|
|
if (has_init) {
|
|
|
init_values.reserve(total_extent);
|
|
|
for (size_t index = 0; index < total_extent; ++index) {
|
|
|
if (index < init_exprs.size() && init_exprs[index]) {
|
|
|
int value = 0;
|
|
|
auto* folded = EvalExpr(*init_exprs[index]);
|
|
|
auto* ci = dynamic_cast<ir::ConstantInt*>(CastValueTo(folded, ir::Type::GetInt32Type()));
|
|
|
if (ci) {
|
|
|
value = ci->GetValue();
|
|
|
}
|
|
|
init_values.push_back(value);
|
|
|
} else {
|
|
|
init_values.push_back(0);
|
|
|
}
|
|
|
}
|
|
|
size_t trailing_zeros = 0;
|
|
|
while (trailing_zeros < init_values.size() && init_values[init_values.size() - 1 - trailing_zeros] == 0) {
|
|
|
trailing_zeros++;
|
|
|
}
|
|
|
if (trailing_zeros > 0) {
|
|
|
init_values.resize(init_values.size() - trailing_zeros);
|
|
|
}
|
|
|
auto* global = module_.CreateGlobalArrayI32(name, total_extent, init_values);
|
|
|
global_storage_map_[ctx] = global;
|
|
|
} else {
|
|
|
auto* global = module_.CreateGlobalArrayI32(name, total_extent, {});
|
|
|
global_storage_map_[ctx] = global;
|
|
|
}
|
|
|
}
|
|
|
return {};
|
|
|
}
|
|
|
|
|
|
int init = 0;
|
|
|
double init_float = 0.0;
|
|
|
if (auto* init_value = ctx->initVal()) {
|
|
|
if (!init_value->exp()) {
|
|
|
throw std::runtime_error(FormatError("irgen", "当前不支持聚合初始化"));
|
|
|
}
|
|
|
auto* folded = EvalExpr(*init_value->exp());
|
|
|
if (is_float) {
|
|
|
auto* cf = dynamic_cast<ir::ConstantFloat*>(CastValueTo(folded, ir::Type::GetFloat32Type()));
|
|
|
if (!cf) {
|
|
|
throw std::runtime_error(
|
|
|
FormatError("irgen", "全局浮点初始化必须是常量表达式"));
|
|
|
}
|
|
|
init_float = cf->GetValue();
|
|
|
} else {
|
|
|
auto* ci = dynamic_cast<ir::ConstantInt*>(CastValueTo(folded, ir::Type::GetInt32Type()));
|
|
|
if (!ci) {
|
|
|
throw std::runtime_error(
|
|
|
FormatError("irgen", "全局整型初始化必须是常量表达式"));
|
|
|
}
|
|
|
init = ci->GetValue();
|
|
|
}
|
|
|
}
|
|
|
auto* global =
|
|
|
is_float ? module_.CreateGlobalF32(name, init_float)
|
|
|
: module_.CreateGlobalI32(name, init);
|
|
|
global_storage_map_[ctx] = global;
|
|
|
return {};
|
|
|
}
|
|
|
|
|
|
// 检查是否已经在当前作用域中声明
|
|
|
if (storage_map_.find(ctx) != storage_map_.end()) {
|
|
|
throw std::runtime_error(FormatError("irgen", "声明重复生成存储槽位"));
|
|
|
}
|
|
|
ir::Value* count = nullptr;
|
|
|
if (is_array) {
|
|
|
count = builder_.CreateConstInt(static_cast<int>(total_extent));
|
|
|
}
|
|
|
auto* slot = CreateEntryBlockAlloca(elem_ty, module_.GetContext().NextTemp(), count);
|
|
|
storage_map_[ctx] = slot;
|
|
|
|
|
|
if (is_array) {
|
|
|
std::vector<SysYParser::ExpContext*> init_exprs;
|
|
|
if (auto* init_value = ctx->initVal()) {
|
|
|
CollectInitExprs(init_value, init_exprs, extents);
|
|
|
if (init_exprs.size() > total_extent) {
|
|
|
throw std::runtime_error(FormatError("irgen", "数组初始化元素过多"));
|
|
|
}
|
|
|
|
|
|
// 对于小数组（<=10000元素），直接生成完整初始化
|
|
|
if (total_extent <= 10000) {
|
|
|
for (size_t index = 0; index < total_extent; ++index) {
|
|
|
auto* idx = builder_.CreateConstInt(static_cast<int>(index));
|
|
|
auto* ptr = builder_.CreateGEP(slot, idx, module_.GetContext().NextTemp());
|
|
|
ir::Value* init_elem = nullptr;
|
|
|
if (index < init_exprs.size() && init_exprs[index]) {
|
|
|
init_elem = CastValueTo(EvalExpr(*init_exprs[index]), elem_ty);
|
|
|
} else {
|
|
|
init_elem = is_float ? static_cast<ir::Value*>(builder_.CreateConstFloat(0.0))
|
|
|
: static_cast<ir::Value*>(builder_.CreateConstInt(0));
|
|
|
}
|
|
|
builder_.CreateStore(init_elem, ptr);
|
|
|
}
|
|
|
} else {
|
|
|
// 对于大数组，生成循环初始化零，然后初始化非零元素
|
|
|
auto* func = builder_.GetInsertBlock()->GetParent();
|
|
|
auto* loop_cond = func->CreateBlock("zero.init.cond");
|
|
|
auto* loop_body = func->CreateBlock("zero.init.body");
|
|
|
auto* loop_end = func->CreateBlock("zero.init.end");
|
|
|
|
|
|
auto* counter = builder_.CreateAlloca(ir::Type::GetInt32Type(), module_.GetContext().NextTemp());
|
|
|
builder_.CreateStore(builder_.CreateConstInt(0), counter);
|
|
|
|
|
|
builder_.CreateBr(loop_cond);
|
|
|
|
|
|
builder_.SetInsertPoint(loop_cond);
|
|
|
auto* counter_val = builder_.CreateLoad(counter, module_.GetContext().NextTemp());
|
|
|
auto* cond = builder_.CreateICmp(ir::Opcode::Lt, counter_val,
|
|
|
builder_.CreateConstInt(static_cast<int>(total_extent)),
|
|
|
module_.GetContext().NextTemp());
|
|
|
builder_.CreateCondBr(cond, loop_body, loop_end);
|
|
|
|
|
|
builder_.SetInsertPoint(loop_body);
|
|
|
auto* idx = builder_.CreateLoad(counter, module_.GetContext().NextTemp());
|
|
|
auto* ptr = builder_.CreateGEP(slot, idx, module_.GetContext().NextTemp());
|
|
|
auto* zero = is_float ? static_cast<ir::Value*>(builder_.CreateConstFloat(0.0))
|
|
|
: static_cast<ir::Value*>(builder_.CreateConstInt(0));
|
|
|
builder_.CreateStore(zero, ptr);
|
|
|
|
|
|
auto* new_counter = builder_.CreateAdd(builder_.CreateLoad(counter, module_.GetContext().NextTemp()),
|
|
|
builder_.CreateConstInt(1),
|
|
|
module_.GetContext().NextTemp());
|
|
|
builder_.CreateStore(new_counter, counter);
|
|
|
builder_.CreateBr(loop_cond);
|
|
|
|
|
|
builder_.SetInsertPoint(loop_end);
|
|
|
|
|
|
// 初始化非零元素
|
|
|
for (size_t index = 0; index < init_exprs.size(); ++index) {
|
|
|
if (init_exprs[index]) {
|
|
|
auto* idx = builder_.CreateConstInt(static_cast<int>(index));
|
|
|
auto* ptr = builder_.CreateGEP(slot, idx, module_.GetContext().NextTemp());
|
|
|
ir::Value* init_elem = CastValueTo(EvalExpr(*init_exprs[index]), elem_ty);
|
|
|
builder_.CreateStore(init_elem, ptr);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
// 如果没有初始化列表，不生成任何初始化代码（局部变量默认不初始化）
|
|
|
return {};
|
|
|
}
|
|
|
|
|
|
ir::Value* init = nullptr;
|
|
|
if (auto* init_value = ctx->initVal()) {
|
|
|
if (!init_value->exp()) {
|
|
|
throw std::runtime_error(FormatError("irgen", "当前不支持聚合初始化"));
|
|
|
}
|
|
|
init = CastValueTo(EvalExpr(*init_value->exp()), elem_ty);
|
|
|
} else {
|
|
|
init = is_float ? static_cast<ir::Value*>(builder_.CreateConstFloat(0.0))
|
|
|
: static_cast<ir::Value*>(builder_.CreateConstInt(0));
|
|
|
}
|
|
|
builder_.CreateStore(init, slot);
|
|
|
return {};
|
|
|
} |
