859 lines
34 KiB
C++
859 lines
34 KiB
C++
// LLVMIRGenerator.cpp
|
||
// TODO：类型转换及其检查
|
||
// TODO：sysy库函数处理
|
||
// TODO：数组处理
|
||
// TODO：对while、continue、break的测试
|
||
#include "LLVMIRGenerator_1.h"
|
||
#include <iomanip>
|
||
#include <stdexcept>
|
||
#include <sstream>
|
||
|
||
// namespace sysy {
|
||
|
||
std::string LLVMIRGenerator::generateIR(SysYParser::CompUnitContext* unit) {
|
||
// 初始化 SysY IR 模块
|
||
module = std::make_unique<sysy::Module>();
|
||
// 清空符号表和临时变量表
|
||
symbolTable.clear();
|
||
tmpTable.clear();
|
||
irSymbolTable.clear();
|
||
irTmpTable.clear();
|
||
tempCounter = 0;
|
||
globalVars.clear();
|
||
hasReturn = false;
|
||
loopStack = std::stack<LoopLabels>();
|
||
inFunction = false;
|
||
|
||
// 访问编译单元
|
||
visitCompUnit(unit);
|
||
return irStream.str();
|
||
}
|
||
|
||
std::string LLVMIRGenerator::getNextTemp() {
|
||
std::string ret = "%." + std::to_string(tempCounter++);
|
||
tmpTable[ret] = "void";
|
||
return ret;
|
||
}
|
||
|
||
std::string LLVMIRGenerator::getIRTempName() {
|
||
return "%" + std::to_string(tempCounter++);
|
||
}
|
||
|
||
std::string LLVMIRGenerator::getLLVMType(const std::string& type) {
|
||
if (type == "int") return "i32";
|
||
if (type == "float") return "float";
|
||
if (type.find("[]") != std::string::npos)
|
||
return getLLVMType(type.substr(0, type.size() - 2)) + "*";
|
||
return "i32";
|
||
}
|
||
|
||
sysy::Type* LLVMIRGenerator::getIRType(const std::string& type) {
|
||
if (type == "int") return sysy::Type::getIntType();
|
||
if (type == "float") return sysy::Type::getFloatType();
|
||
if (type == "void") return sysy::Type::getVoidType();
|
||
if (type.find("[]") != std::string::npos) {
|
||
std::string baseType = type.substr(0, type.size() - 2);
|
||
return sysy::Type::getPointerType(getIRType(baseType));
|
||
}
|
||
return sysy::Type::getIntType(); // 默认 int
|
||
}
|
||
|
||
void LLVMIRGenerator::setIRPosition(sysy::BasicBlock* block) {
|
||
currentIRBlock = block;
|
||
}
|
||
|
||
std::any LLVMIRGenerator::visitCompUnit(SysYParser::CompUnitContext* ctx) {
|
||
for (auto decl : ctx->decl()) {
|
||
decl->accept(this);
|
||
}
|
||
for (auto funcDef : ctx->funcDef()) {
|
||
inFunction = true;
|
||
funcDef->accept(this);
|
||
inFunction = false;
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
|
||
std::any LLVMIRGenerator::visitVarDecl(SysYParser::VarDeclContext* ctx) {
|
||
// TODO：数组初始化
|
||
std::string type = ctx->bType()->getText();
|
||
currentVarType = getLLVMType(type);
|
||
sysy::Type* irType = sysy::Type::getPointerType(getIRType(type));
|
||
|
||
for (auto varDef : ctx->varDef()) {
|
||
if (!inFunction) {
|
||
// 全局变量（文本 IR）
|
||
std::string varName = varDef->Ident()->getText();
|
||
std::string llvmType = getLLVMType(type);
|
||
std::string value = "0";
|
||
sysy::Value* initValue = nullptr;
|
||
|
||
if (varDef->ASSIGN()) {
|
||
value = std::any_cast<std::string>(varDef->initVal()->accept(this));
|
||
if (irTmpTable.find(value) != irTmpTable.end() && isa<sysy::ConstantValue>(irTmpTable[value])) {
|
||
initValue = irTmpTable[value];
|
||
}
|
||
}
|
||
|
||
if (llvmType == "float" && initValue) {
|
||
try {
|
||
double floatValue = std::stod(value);
|
||
uint64_t hexValue = reinterpret_cast<uint64_t&>(floatValue);
|
||
std::stringstream ss;
|
||
ss << "0x" << std::hex << std::uppercase << hexValue;
|
||
value = ss.str();
|
||
} catch (...) {
|
||
throw std::runtime_error("[ERR-Release-02]Invalid float literal: " + value);
|
||
}
|
||
}
|
||
irStream << "@" << varName << " = dso_local global " << llvmType << " " << value << ", align 4\n";
|
||
globalVars.push_back(varName);
|
||
|
||
// 全局变量（SysY IR）
|
||
auto globalValue = module->createGlobalValue(varName, irType, {}, initValue);
|
||
irSymbolTable[varName] = globalValue;
|
||
} else {
|
||
varDef->accept(this);
|
||
}
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
std::any LLVMIRGenerator::visitConstDecl(SysYParser::ConstDeclContext* ctx) {
|
||
// TODO：数组初始化
|
||
std::string type = ctx->bType()->getText();
|
||
currentVarType = getLLVMType(type);
|
||
sysy::Type* irType = sysy::Type::getPointerType(getIRType(type)); // 全局变量为指针类型
|
||
|
||
for (auto constDef : ctx->constDef()) {
|
||
std::string varName = constDef->Ident()->getText();
|
||
std::string llvmType = getLLVMType(type);
|
||
std::string value = "0";
|
||
sysy::Value* initValue = nullptr;
|
||
|
||
try {
|
||
value = std::any_cast<std::string>(constDef->constInitVal()->accept(this));
|
||
if (isa<sysy::ConstantValue>(irTmpTable[value])) {
|
||
initValue = irTmpTable[value];
|
||
}
|
||
} catch (...) {
|
||
throw std::runtime_error("Const value must be initialized upon definition.");
|
||
}
|
||
|
||
if (!inFunction) {
|
||
// 全局常量（文本 IR）
|
||
if (llvmType == "float") {
|
||
try {
|
||
double floatValue = std::stod(value);
|
||
uint64_t hexValue = reinterpret_cast<uint64_t&>(floatValue);
|
||
std::stringstream ss;
|
||
ss << "0x" << std::hex << std::uppercase << hexValue;
|
||
value = ss.str();
|
||
} catch (...) {
|
||
throw std::runtime_error("[ERR-Release-03]Invalid float literal: " + value);
|
||
}
|
||
}
|
||
irStream << "@" << varName << " = dso_local constant " << llvmType << " " << value << ", align 4\n";
|
||
globalVars.push_back(varName);
|
||
|
||
// 全局常量（SysY IR）
|
||
auto globalValue = module->createGlobalValue(varName, irType, {}, initValue);
|
||
irSymbolTable[varName] = globalValue;
|
||
} else {
|
||
// 局部常量（文本 IR）
|
||
std::string allocaName = getNextTemp();
|
||
if (llvmType == "float") {
|
||
try {
|
||
double floatValue = std::stod(value);
|
||
uint64_t hexValue = reinterpret_cast<uint64_t&>(floatValue);
|
||
std::stringstream ss;
|
||
ss << "0x" << std::hex << std::uppercase << hexValue;
|
||
value = ss.str();
|
||
} catch (...) {
|
||
throw std::runtime_error("Invalid float literal: " + value);
|
||
}
|
||
}
|
||
irStream << " " << allocaName << " = alloca " << llvmType << ", align 4\n";
|
||
irStream << " store " << llvmType << " " << value << ", " << llvmType
|
||
<< "* " << allocaName << ", align 4\n";
|
||
symbolTable[varName] = {allocaName, llvmType};
|
||
tmpTable[allocaName] = llvmType;
|
||
|
||
// 局部常量（SysY IR）TODO:这里可能有bug，AI在犯蠢
|
||
sysy::IRBuilder builder(currentIRBlock);
|
||
auto allocaInst = builder.createAllocaInst(irType, {}, varName);
|
||
builder.createStoreInst(initValue, allocaInst);
|
||
irSymbolTable[varName] = allocaInst;
|
||
irTmpTable[allocaName] = allocaInst;
|
||
}
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
std::any LLVMIRGenerator::visitVarDef(SysYParser::VarDefContext* ctx) {
|
||
// TODO：数组初始化
|
||
std::string varName = ctx->Ident()->getText();
|
||
std::string llvmType = currentVarType;
|
||
sysy::Type* irType = sysy::Type::getPointerType(getIRType(currentVarType == "i32" ? "int" : "float"));
|
||
std::string allocaName = getNextTemp();
|
||
|
||
// 局部变量（文本 IR）
|
||
irStream << " " << allocaName << " = alloca " << llvmType << ", align 4\n";
|
||
|
||
// 局部变量（SysY IR）
|
||
sysy::IRBuilder builder(currentIRBlock);
|
||
auto allocaInst = builder.createAllocaInst(irType, {}, varName);
|
||
sysy::Value* initValue = nullptr;
|
||
|
||
if (ctx->ASSIGN()) {
|
||
std::string value = std::any_cast<std::string>(ctx->initVal()->accept(this));
|
||
if (llvmType == "float") {
|
||
try {
|
||
double floatValue = std::stod(value);
|
||
uint64_t hexValue = reinterpret_cast<uint64_t&>(floatValue);
|
||
std::stringstream ss;
|
||
ss << "0x" << std::hex << std::uppercase << (hexValue & (0xffffffffUL << 32));
|
||
value = ss.str();
|
||
} catch (...) {
|
||
throw std::runtime_error("Invalid float literal: " + value);
|
||
}
|
||
}
|
||
irStream << " store " << llvmType << " " << value << ", " << llvmType
|
||
<< "* " << allocaName << ", align 4\n";
|
||
|
||
if (irTmpTable.find(value) != irTmpTable.end()) {
|
||
initValue = irTmpTable[value];
|
||
}
|
||
builder.createStoreInst(initValue, allocaInst);
|
||
}
|
||
|
||
symbolTable[varName] = {allocaName, llvmType};
|
||
tmpTable[allocaName] = llvmType;
|
||
irSymbolTable[varName] = allocaInst;//TODO:这里没看懂在干嘛
|
||
irTmpTable[allocaName] = allocaInst;//TODO:这里没看懂在干嘛
|
||
builder.createStoreInst(initValue, allocaInst);//TODO:这里没看懂在干嘛
|
||
return nullptr;
|
||
}
|
||
|
||
std::any LLVMIRGenerator::visitFuncDef(SysYParser::FuncDefContext* ctx) {
|
||
currentFunction = ctx->Ident()->getText();
|
||
currentReturnType = getLLVMType(ctx->funcType()->getText());
|
||
sysy::Type* irReturnType = getIRType(ctx->funcType()->getText());
|
||
std::vector<sysy::Type*> paramTypes;
|
||
|
||
// 清空符号表
|
||
symbolTable.clear();
|
||
tmpTable.clear();
|
||
irSymbolTable.clear();
|
||
irTmpTable.clear();
|
||
tempCounter = 0;
|
||
hasReturn = false;
|
||
|
||
// 处理函数参数（文本 IR 和 SysY IR）
|
||
if (ctx->funcFParams()) {
|
||
auto params = ctx->funcFParams()->funcFParam();
|
||
for (size_t i = 0; i < params.size(); ++i) {
|
||
std::string paramType = getLLVMType(params[i]->bType()->getText());
|
||
if (i > 0) irStream << ", ";
|
||
irStream << paramType << " noundef %" << i;
|
||
symbolTable[params[i]->Ident()->getText()] = {"%" + std::to_string(i), paramType};
|
||
tmpTable["%" + std::to_string(i)] = paramType;
|
||
paramTypes.push_back(getIRType(params[i]->bType()->getText()));
|
||
}
|
||
tempCounter += params.size();
|
||
}
|
||
tempCounter++;
|
||
|
||
// 文本 IR 函数定义
|
||
irStream << "define dso_local " << currentReturnType << " @" << currentFunction << "(";
|
||
irStream << ") #0 {\n";
|
||
|
||
// SysY IR 函数定义
|
||
sysy::Type* funcType = sysy::Type::getFunctionType(irReturnType, paramTypes);
|
||
currentIRFunction = module->createFunction(currentFunction, funcType);
|
||
setIRPosition(currentIRFunction->getEntryBlock());
|
||
|
||
// 处理函数参数分配
|
||
if (ctx->funcFParams()) {
|
||
auto params = ctx->funcFParams()->funcFParam();
|
||
for (size_t i = 0; i < params.size(); ++i) {
|
||
std::string varName = params[i]->Ident()->getText();
|
||
std::string llvmType = getLLVMType(params[i]->bType()->getText());
|
||
sysy::Type* irType = getIRType(params[i]->bType()->getText());
|
||
std::string allocaName = getNextTemp();
|
||
tmpTable[allocaName] = llvmType;
|
||
|
||
// 文本 IR 分配
|
||
irStream << " " << allocaName << " = alloca " << llvmType << ", align 4\n";
|
||
irStream << " store " << llvmType << " %" << i << ", " << llvmType
|
||
<< "* " << allocaName << ", align 4\n";
|
||
|
||
// SysY IR 分配
|
||
sysy::IRBuilder builder(currentIRBlock);
|
||
auto arg = currentIRBlock->createArgument(irType, varName);
|
||
auto allocaInst = builder.createAllocaInst(sysy::Type::getPointerType(irType), {}, varName);
|
||
builder.createStoreInst(arg, allocaInst);
|
||
symbolTable[varName] = {allocaName, llvmType};
|
||
irSymbolTable[varName] = allocaInst;
|
||
irTmpTable[allocaName] = allocaInst;
|
||
}
|
||
}
|
||
|
||
ctx->blockStmt()->accept(this);
|
||
|
||
if (!hasReturn) {
|
||
if (currentReturnType == "void") {
|
||
irStream << " ret void\n";
|
||
sysy::IRBuilder builder(currentIRBlock);
|
||
builder.createReturnInst();
|
||
} else {
|
||
irStream << " ret " << currentReturnType << " 0\n";
|
||
sysy::IRBuilder builder(currentIRBlock);
|
||
builder.createReturnInst(sysy::ConstantValue::get(0));
|
||
}
|
||
}
|
||
irStream << "}\n";
|
||
currentIRFunction = nullptr;
|
||
currentIRBlock = nullptr;
|
||
return nullptr;
|
||
}
|
||
|
||
std::any LLVMIRGenerator::visitBlockStmt(SysYParser::BlockStmtContext* ctx) {
|
||
for (auto item : ctx->blockItem()) {
|
||
item->accept(this);
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
std::any LLVMIRGenerator::visitAssignStmt(SysYParser::AssignStmtContext* ctx) {
|
||
std::string lhsAlloca = std::any_cast<std::string>(ctx->lValue()->accept(this));
|
||
std::string lhsType = symbolTable[ctx->lValue()->Ident()->getText()].second;
|
||
std::string rhs = std::any_cast<std::string>(ctx->exp()->accept(this));
|
||
sysy::Value* rhsValue = irTmpTable[rhs];
|
||
|
||
// 文本 IR
|
||
if (lhsType == "float") {
|
||
try {
|
||
double floatValue = std::stod(rhs);
|
||
uint64_t hexValue = reinterpret_cast<uint64_t&>(floatValue);
|
||
std::stringstream ss;
|
||
ss << "0x" << std::hex << std::uppercase << (hexValue & (0xffffffffUL << 32));
|
||
rhs = ss.str();
|
||
} catch (...) {
|
||
// 如果 rhs 不是字面量，假设已正确处理
|
||
throw std::runtime_error("Invalid float literal: " + rhs);
|
||
}
|
||
}
|
||
irStream << " store " << lhsType << " " << rhs << ", " << lhsType
|
||
<< "* " << lhsAlloca << ", align 4\n";
|
||
|
||
// SysY IR
|
||
sysy::IRBuilder builder(currentIRBlock);
|
||
builder.createStoreInst(rhsValue, irSymbolTable[ctx->lValue()->Ident()->getText()]);
|
||
return nullptr;
|
||
}
|
||
|
||
std::any LLVMIRGenerator::visitIfStmt(SysYParser::IfStmtContext* ctx) {
|
||
std::string cond = std::any_cast<std::string>(ctx->cond()->accept(this));
|
||
sysy::Value* condValue = irTmpTable[cond];
|
||
std::string trueLabel = "if.then." + std::to_string(tempCounter);
|
||
std::string falseLabel = "if.else." + std::to_string(tempCounter);
|
||
std::string mergeLabel = "if.end." + std::to_string(tempCounter++);
|
||
|
||
// SysY IR 基本块
|
||
sysy::BasicBlock* thenBlock = currentIRFunction->addBasicBlock(trueLabel);
|
||
sysy::BasicBlock* elseBlock = ctx->ELSE() ? currentIRFunction->addBasicBlock(falseLabel) : nullptr;
|
||
sysy::BasicBlock* mergeBlock = currentIRFunction->addBasicBlock(mergeLabel);
|
||
|
||
// 文本 IR
|
||
irStream << " br i1 " << cond << ", label %" << trueLabel << ", label %"
|
||
<< (ctx->ELSE() ? falseLabel : mergeLabel) << "\n";
|
||
|
||
// SysY IR 条件分支
|
||
sysy::IRBuilder builder(currentIRBlock);
|
||
builder.createCondBrInst(condValue, thenBlock, ctx->ELSE() ? elseBlock : mergeBlock, {}, {});
|
||
|
||
// 处理 then 分支
|
||
setIRPosition(thenBlock);
|
||
irStream << trueLabel << ":\n";
|
||
ctx->stmt(0)->accept(this);
|
||
irStream << " br label %" << mergeLabel << "\n";
|
||
builder.setPosition(thenBlock, thenBlock->end());
|
||
builder.createUncondBrInst(mergeBlock, {});
|
||
|
||
// 处理 else 分支
|
||
if (ctx->ELSE()) {
|
||
setIRPosition(elseBlock);
|
||
irStream << falseLabel << ":\n";
|
||
ctx->stmt(1)->accept(this);
|
||
irStream << " br label %" << mergeLabel << "\n";
|
||
builder.setPosition(elseBlock, elseBlock->end());
|
||
builder.createUncondBrInst(mergeBlock, {});
|
||
}
|
||
|
||
// 合并点
|
||
setIRPosition(mergeBlock);
|
||
irStream << mergeLabel << ":\n";
|
||
return nullptr;
|
||
}
|
||
|
||
std::any LLVMIRGenerator::visitWhileStmt(SysYParser::WhileStmtContext* ctx) {
|
||
std::string loopCond = "while.cond." + std::to_string(tempCounter);
|
||
std::string loopBody = "while.body." + std::to_string(tempCounter);
|
||
std::string loopEnd = "while.end." + std::to_string(tempCounter++);
|
||
|
||
// SysY IR 基本块
|
||
sysy::BasicBlock* condBlock = currentIRFunction->addBasicBlock(loopCond);
|
||
sysy::BasicBlock* bodyBlock = currentIRFunction->addBasicBlock(loopBody);
|
||
sysy::BasicBlock* endBlock = currentIRFunction->addBasicBlock(loopEnd);
|
||
|
||
loopStack.push({loopEnd, loopCond, endBlock, condBlock});
|
||
|
||
// 跳转到条件块
|
||
sysy::IRBuilder builder(currentIRBlock);
|
||
builder.createUncondBrInst(condBlock, {});
|
||
irStream << " br label %" << loopCond << "\n";
|
||
|
||
// 条件块
|
||
setIRPosition(condBlock);
|
||
irStream << loopCond << ":\n";
|
||
std::string cond = std::any_cast<std::string>(ctx->cond()->accept(this));
|
||
sysy::Value* condValue = irTmpTable[cond];
|
||
irStream << " br i1 " << cond << ", label %" << loopBody << ", label %" << loopEnd << "\n";
|
||
builder.setPosition(condBlock, condBlock->end());
|
||
builder.createCondBrInst(condValue, bodyBlock, endBlock, {}, {});
|
||
|
||
// 循环体
|
||
setIRPosition(bodyBlock);
|
||
irStream << loopBody << ":\n";
|
||
ctx->stmt()->accept(this);
|
||
irStream << " br label %" << loopCond << "\n";
|
||
builder.setPosition(bodyBlock, bodyBlock->end());
|
||
builder.createUncondBrInst(condBlock, {});
|
||
|
||
// 结束块
|
||
setIRPosition(endBlock);
|
||
irStream << loopEnd << ":\n";
|
||
loopStack.pop();
|
||
return nullptr;
|
||
}
|
||
|
||
std::any LLVMIRGenerator::visitBreakStmt(SysYParser::BreakStmtContext* ctx) {
|
||
if (loopStack.empty()) {
|
||
throw std::runtime_error("Break statement outside of a loop.");
|
||
}
|
||
irStream << " br label %" << loopStack.top().breakLabel << "\n";
|
||
sysy::IRBuilder builder(currentIRBlock);
|
||
builder.createUncondBrInst(loopStack.top().irBreakBlock, {});
|
||
return nullptr;
|
||
}
|
||
|
||
std::any LLVMIRGenerator::visitContinueStmt(SysYParser::ContinueStmtContext* ctx) {
|
||
if (loopStack.empty()) {
|
||
throw std::runtime_error("Continue statement outside of a loop.");
|
||
}
|
||
irStream << " br label %" << loopStack.top().continueLabel << "\n";
|
||
sysy::IRBuilder builder(currentIRBlock);
|
||
builder.createUncondBrInst(loopStack.top().irContinueBlock, {});
|
||
return nullptr;
|
||
}
|
||
|
||
std::any LLVMIRGenerator::visitReturnStmt(SysYParser::ReturnStmtContext* ctx) {
|
||
hasReturn = true;
|
||
sysy::IRBuilder builder(currentIRBlock);
|
||
if (ctx->exp()) {
|
||
std::string value = std::any_cast<std::string>(ctx->exp()->accept(this));
|
||
sysy::Value* irValue = irTmpTable[value];
|
||
irStream << " ret " << currentReturnType << " " << value << "\n";
|
||
builder.createReturnInst(irValue);
|
||
} else {
|
||
irStream << " ret void\n";
|
||
builder.createReturnInst();
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
std::any LLVMIRGenerator::visitLValue(SysYParser::LValueContext* ctx) {
|
||
std::string varName = ctx->Ident()->getText();
|
||
if (irSymbolTable.find(varName) == irSymbolTable.end()) {
|
||
throw std::runtime_error("Undefined variable: " + varName);
|
||
}
|
||
// 对于 LValue，返回分配的指针（文本 IR 和 SysY IR 一致）
|
||
return symbolTable[varName].first;
|
||
}
|
||
|
||
std::any LLVMIRGenerator::visitPrimExp(SysYParser::PrimExpContext* ctx) {
|
||
SysYParser::PrimaryExpContext* pExpCtx = ctx->primaryExp();
|
||
if (auto* lvalCtx = dynamic_cast<SysYParser::LValContext*>(pExpCtx)) {
|
||
std::string allocaPtr = std::any_cast<std::string>(lvalCtx->lValue()->accept(this));
|
||
std::string varName = lvalCtx->lValue()->Ident()->getText();
|
||
std::string type = symbolTable[varName].second;
|
||
std::string temp = getNextTemp();
|
||
sysy::Type* irType = getIRType(type == "i32" ? "int" : "float");
|
||
|
||
// 文本 IR
|
||
irStream << " " << temp << " = load " << type << ", " << type << "* " << allocaPtr << ", align 4\n";
|
||
tmpTable[temp] = type;
|
||
|
||
// SysY IR
|
||
sysy::IRBuilder builder(currentIRBlock);
|
||
auto loadInst = builder.createLoadInst(irSymbolTable[varName], {});
|
||
irTmpTable[temp] = loadInst;
|
||
return temp;
|
||
} else if (auto* expCtx = dynamic_cast<SysYParser::ParenExpContext*>(pExpCtx)) {
|
||
return expCtx->exp()->accept(this);
|
||
} else if (auto* strCtx = dynamic_cast<SysYParser::StrContext*>(pExpCtx)) {
|
||
return strCtx->string()->accept(this);
|
||
} else if (auto* numCtx = dynamic_cast<SysYParser::NumContext*>(pExpCtx)) {
|
||
return numCtx->number()->accept(this);
|
||
} else {
|
||
// 没有成功转换，说明 ctx->primaryExp() 不是 NumContext 或其他已知类型
|
||
// 可能是其他类型的表达式，或者是一个空的 PrimaryExpContext
|
||
std::cout << "Unknown primary expression type." << std::endl;
|
||
throw std::runtime_error("Unknown primary expression type.");
|
||
}
|
||
}
|
||
|
||
std::any LLVMIRGenerator::visitParenExp(SysYParser::ParenExpContext* ctx) {
|
||
return ctx->exp()->accept(this);
|
||
}
|
||
|
||
std::any LLVMIRGenerator::visitNumber(SysYParser::NumberContext* ctx) {
|
||
std::string value;
|
||
sysy::Value* irValue = nullptr;
|
||
if (ctx->ILITERAL()) {
|
||
value = ctx->ILITERAL()->getText();
|
||
irValue = sysy::ConstantValue::get(std::stoi(value));
|
||
} else if (ctx->FLITERAL()) {
|
||
value = ctx->FLITERAL()->getText();
|
||
irValue = sysy::ConstantValue::get(std::stof(value));
|
||
} else {
|
||
value = "";
|
||
}
|
||
std::string temp = getNextTemp();
|
||
tmpTable[temp] = ctx->ILITERAL() ? "i32" : "float";
|
||
irTmpTable[temp] = irValue;
|
||
return value;
|
||
}
|
||
|
||
std::any LLVMIRGenerator::visitString(SysYParser::StringContext* ctx) {
|
||
if (ctx->STRING()) {
|
||
std::string str = ctx->STRING()->getText();
|
||
str = str.substr(1, str.size() - 2);
|
||
std::string escapedStr;
|
||
for (char c : str) {
|
||
if (c == '\\') {
|
||
escapedStr += "\\\\";
|
||
} else if (c == '"') {
|
||
escapedStr += "\\\"";
|
||
} else {
|
||
escapedStr += c;
|
||
}
|
||
}
|
||
// TODO: SysY IR 暂不支持字符串常量，返回文本 IR 结果
|
||
return "\"" + escapedStr + "\"";
|
||
}
|
||
return ctx->STRING()->getText();
|
||
}
|
||
|
||
|
||
|
||
std::any LLVMIRGenerator::visitUnExp(SysYParser::UnExpContext* ctx) {
|
||
if (ctx->unaryOp()) {
|
||
std::string operand = std::any_cast<std::string>(ctx->unaryExp()->accept(this));
|
||
sysy::Value* irOperand = irTmpTable[operand];
|
||
std::string op = ctx->unaryOp()->getText();
|
||
std::string temp = getNextTemp();
|
||
std::string type = tmpTable[operand];
|
||
sysy::Type* irType = getIRType(type == "i32" ? "int" : "float");
|
||
tmpTable[temp] = type;
|
||
|
||
// 文本 IR
|
||
if (op == "-") {
|
||
irStream << " " << temp << " = sub " << type << " 0, " << operand << "\n";
|
||
} else if (op == "!") {
|
||
irStream << " " << temp << " = xor " << type << " " << operand << ", 1\n";
|
||
}
|
||
|
||
// SysY IR
|
||
sysy::IRBuilder builder(currentIRBlock);
|
||
sysy::Instruction::Kind kind = (op == "-") ? (type == "i32" ? sysy::Instruction::kNeg : sysy::Instruction::kFNeg)
|
||
: sysy::Instruction::kNot;
|
||
auto unaryInst = builder.createUnaryInst(kind, irType, irOperand, temp);
|
||
irTmpTable[temp] = unaryInst;
|
||
return temp;
|
||
}
|
||
return ctx->unaryExp()->accept(this);
|
||
}
|
||
|
||
std::any LLVMIRGenerator::visitCall(SysYParser::CallContext* ctx) {
|
||
std::string funcName = ctx->Ident()->getText();
|
||
std::vector<std::string> args;
|
||
std::vector<sysy::Value*> irArgs;
|
||
if (ctx->funcRParams()) {
|
||
for (auto argCtx : ctx->funcRParams()->exp()) {
|
||
std::string arg = std::any_cast<std::string>(argCtx->accept(this));
|
||
args.push_back(arg);
|
||
irArgs.push_back(irTmpTable[arg]);
|
||
}
|
||
}
|
||
std::string temp = getNextTemp();
|
||
std::string argList;
|
||
for (size_t i = 0; i < args.size(); ++i) {
|
||
if (i > 0) argList += ", ";
|
||
argList += tmpTable[args[i]] + " noundef " + args[i];
|
||
}
|
||
|
||
// 文本 IR
|
||
irStream << " " << temp << " = call " << currentReturnType << " @" << funcName << "(" << argList << ")\n";
|
||
tmpTable[temp] = currentReturnType;
|
||
|
||
// SysY IR
|
||
sysy::IRBuilder builder(currentIRBlock);
|
||
sysy::Function* callee = module->getFunction(funcName);
|
||
if (!callee) {
|
||
throw std::runtime_error("Undefined function: " + funcName);
|
||
}
|
||
auto callInst = builder.createCallInst(callee, irArgs, temp);
|
||
irTmpTable[temp] = callInst;
|
||
return temp;
|
||
}
|
||
|
||
std::any LLVMIRGenerator::visitMulExp(SysYParser::MulExpContext* ctx) {
|
||
auto unaryExps = ctx->unaryExp();
|
||
std::string left = std::any_cast<std::string>(unaryExps[0]->accept(this));
|
||
sysy::Value* irLeft = irTmpTable[left];
|
||
sysy::Type* irType = irLeft->getType();
|
||
|
||
for (size_t i = 1; i < unaryExps.size(); ++i) {
|
||
std::string right = std::any_cast<std::string>(unaryExps[i]->accept(this));
|
||
sysy::Value* irRight = irTmpTable[right];
|
||
std::string op = ctx->children[2 * i - 1]->getText();
|
||
std::string temp = getNextTemp();
|
||
std::string type = tmpTable[left];
|
||
tmpTable[temp] = type;
|
||
|
||
// 文本 IR
|
||
if (op == "*") {
|
||
irStream << " " << temp << " = mul nsw " << type << " " << left << ", " << right << "\n";
|
||
} else if (op == "/") {
|
||
irStream << " " << temp << " = sdiv " << type << " " << left << ", " << right << "\n";
|
||
} else if (op == "%") {
|
||
irStream << " " << temp << " = srem " << type << " " << left << ", " << right << "\n";
|
||
}
|
||
|
||
// SysY IR
|
||
sysy::IRBuilder builder(currentIRBlock);
|
||
sysy::Instruction::Kind kind;
|
||
if (type == "i32") {
|
||
if (op == "*") kind = sysy::Instruction::kMul;
|
||
else if (op == "/") kind = sysy::Instruction::kDiv;
|
||
else kind = sysy::Instruction::kRem;
|
||
} else {
|
||
if (op == "*") kind = sysy::Instruction::kFMul;
|
||
else if (op == "/") kind = sysy::Instruction::kFDiv;
|
||
else kind = sysy::Instruction::kFRem;
|
||
}
|
||
auto binaryInst = builder.createBinaryInst(kind, irType, irLeft, irRight, temp);
|
||
irTmpTable[temp] = binaryInst;
|
||
left = temp;
|
||
irLeft = binaryInst;
|
||
}
|
||
return left;
|
||
}
|
||
|
||
std::any LLVMIRGenerator::visitAddExp(SysYParser::AddExpContext* ctx) {
|
||
auto mulExps = ctx->mulExp();
|
||
std::string left = std::any_cast<std::string>(mulExps[0]->accept(this));
|
||
sysy::Value* irLeft = irTmpTable[left];
|
||
sysy::Type* irType = irLeft->getType();
|
||
|
||
for (size_t i = 1; i < mulExps.size(); ++i) {
|
||
std::string right = std::any_cast<std::string>(mulExps[i]->accept(this));
|
||
sysy::Value* irRight = irTmpTable[right];
|
||
std::string op = ctx->children[2 * i - 1]->getText();
|
||
std::string temp = getNextTemp();
|
||
std::string type = tmpTable[left];
|
||
tmpTable[temp] = type;
|
||
|
||
// 文本 IR
|
||
if (op == "+") {
|
||
irStream << " " << temp << " = add nsw " << type << " " << left << ", " << right << "\n";
|
||
} else if (op == "-") {
|
||
irStream << " " << temp << " = sub nsw " << type << " " << left << ", " << right << "\n";
|
||
}
|
||
|
||
// SysY IR
|
||
sysy::IRBuilder builder(currentIRBlock);
|
||
sysy::Instruction::Kind kind = (type == "i32") ? (op == "+" ? sysy::Instruction::kAdd : sysy::Instruction::kSub)
|
||
: (op == "+" ? sysy::Instruction::kFAdd : sysy::Instruction::kFSub);
|
||
auto binaryInst = builder.createBinaryInst(kind, irType, irLeft, irRight, temp);
|
||
irTmpTable[temp] = binaryInst;
|
||
left = temp;
|
||
irLeft = binaryInst;
|
||
}
|
||
return left;
|
||
}
|
||
|
||
std::any LLVMIRGenerator::visitRelExp(SysYParser::RelExpContext* ctx) {
|
||
auto addExps = ctx->addExp();
|
||
std::string left = std::any_cast<std::string>(addExps[0]->accept(this));
|
||
sysy::Value* irLeft = irTmpTable[left];
|
||
sysy::Type* irType = sysy::Type::getIntType(); // 比较结果为 i1
|
||
|
||
for (size_t i = 1; i < addExps.size(); ++i) {
|
||
std::string right = std::any_cast<std::string>(addExps[i]->accept(this));
|
||
sysy::Value* irRight = irTmpTable[right];
|
||
std::string op = ctx->children[2 * i - 1]->getText();
|
||
std::string temp = getNextTemp();
|
||
std::string type = tmpTable[left];
|
||
tmpTable[temp] = "i1";
|
||
|
||
// 文本 IR
|
||
if (op == "<") {
|
||
irStream << " " << temp << " = icmp slt " << type << " " << left << ", " << right << "\n";
|
||
} else if (op == ">") {
|
||
irStream << " " << temp << " = icmp sgt " << type << " " << left << ", " << right << "\n";
|
||
} else if (op == "<=") {
|
||
irStream << " " << temp << " = icmp sle " << type << " " << left << ", " << right << "\n";
|
||
} else if (op == ">=") {
|
||
irStream << " " << temp << " = icmp sge " << type << " " << left << ", " << right << "\n";
|
||
}
|
||
|
||
// SysY IR
|
||
sysy::IRBuilder builder(currentIRBlock);
|
||
sysy::Instruction::Kind kind;
|
||
if (type == "i32") {
|
||
if (op == "<") kind = sysy::Instruction::kICmpLT;
|
||
else if (op == ">") kind = sysy::Instruction::kICmpGT;
|
||
else if (op == "<=") kind = sysy::Instruction::kICmpLE;
|
||
else kind = sysy::Instruction::kICmpGE;
|
||
} else {
|
||
if (op == "<") kind = sysy::Instruction::kFCmpLT;
|
||
else if (op == ">") kind = sysy::Instruction::kFCmpGT;
|
||
else if (op == "<=") kind = sysy::Instruction::kFCmpLE;
|
||
else kind = sysy::Instruction::kFCmpGE;
|
||
}
|
||
auto cmpInst = builder.createBinaryInst(kind, irType, irLeft, irRight, temp);
|
||
irTmpTable[temp] = cmpInst;
|
||
left = temp;
|
||
irLeft = cmpInst;
|
||
}
|
||
return left;
|
||
}
|
||
|
||
std::any LLVMIRGenerator::visitEqExp(SysYParser::EqExpContext* ctx) {
|
||
auto relExps = ctx->relExp();
|
||
std::string left = std::any_cast<std::string>(relExps[0]->accept(this));
|
||
sysy::Value* irLeft = irTmpTable[left];
|
||
sysy::Type* irType = sysy::Type::getIntType(); // 比较结果为 i1
|
||
|
||
for (size_t i = 1; i < relExps.size(); ++i) {
|
||
std::string right = std::any_cast<std::string>(relExps[i]->accept(this));
|
||
sysy::Value* irRight = irTmpTable[right];
|
||
std::string op = ctx->children[2 * i - 1]->getText();
|
||
std::string temp = getNextTemp();
|
||
std::string type = tmpTable[left];
|
||
tmpTable[temp] = "i1";
|
||
|
||
// 文本 IR
|
||
if (op == "==") {
|
||
irStream << " " << temp << " = icmp eq " << type << " " << left << ", " << right << "\n";
|
||
} else if (op == "!=") {
|
||
irStream << " " << temp << " = icmp ne " << type << " " << left << ", " << right << "\n";
|
||
}
|
||
|
||
// SysY IR
|
||
sysy::IRBuilder builder(currentIRBlock);
|
||
sysy::Instruction::Kind kind = (type == "i32") ? (op == "==" ? sysy::Instruction::kICmpEQ : sysy::Instruction::kICmpNE)
|
||
: (op == "==" ? sysy::Instruction::kFCmpEQ : sysy::Instruction::kFCmpNE);
|
||
auto cmpInst = builder.createBinaryInst(kind, irType, irLeft, irRight, temp);
|
||
irTmpTable[temp] = cmpInst;
|
||
left = temp;
|
||
irLeft = cmpInst;
|
||
}
|
||
return left;
|
||
}
|
||
|
||
std::any LLVMIRGenerator::visitLAndExp(SysYParser::LAndExpContext* ctx) {
|
||
auto eqExps = ctx->eqExp();
|
||
std::string left = std::any_cast<std::string>(eqExps[0]->accept(this));
|
||
sysy::Value* irLeft = irTmpTable[left];
|
||
|
||
for (size_t i = 1; i < eqExps.size(); ++i) {
|
||
std::string falseLabel = "land.false." + std::to_string(tempCounter);
|
||
std::string endLabel = "land.end." + std::to_string(tempCounter++);
|
||
sysy::BasicBlock* falseBlock = currentIRFunction->addBasicBlock(falseLabel);
|
||
sysy::BasicBlock* endBlock = currentIRFunction->addBasicBlock(endLabel);
|
||
std::string temp = getNextTemp();
|
||
tmpTable[temp] = "i1";
|
||
|
||
// 文本 IR
|
||
irStream << " br i1 " << left << ", label %" << falseLabel << ", label %" << endLabel << "\n";
|
||
irStream << falseLabel << ":\n";
|
||
|
||
// SysY IR
|
||
sysy::IRBuilder builder(currentIRBlock);
|
||
builder.createCondBrInst(irLeft, falseBlock, endBlock, {}, {});
|
||
setIRPosition(falseBlock);
|
||
|
||
std::string right = std::any_cast<std::string>(eqExps[i]->accept(this));
|
||
sysy::Value* irRight = irTmpTable[right];
|
||
irStream << " " << temp << " = and i1 " << left << ", " << right << "\n";
|
||
irStream << " br label %" << endLabel << "\n";
|
||
irStream << endLabel << ":\n";
|
||
|
||
// SysY IR 逻辑与（通过基本块实现短路求值）
|
||
builder.setPosition(falseBlock, falseBlock->end());
|
||
auto andInst = builder.createBinaryInst(sysy::Instruction::kICmpEQ, sysy::Type::getIntType(), irLeft, irRight, temp);
|
||
builder.createUncondBrInst(endBlock, {});
|
||
irTmpTable[temp] = andInst;
|
||
left = temp;
|
||
irLeft = andInst;
|
||
setIRPosition(endBlock);
|
||
}
|
||
return left;
|
||
}
|
||
|
||
std::any LLVMIRGenerator::visitLOrExp(SysYParser::LOrExpContext* ctx) {
|
||
auto lAndExps = ctx->lAndExp();
|
||
std::string left = std::any_cast<std::string>(lAndExps[0]->accept(this));
|
||
sysy::Value* irLeft = irTmpTable[left];
|
||
|
||
for (size_t i = 1; i < lAndExps.size(); ++i) {
|
||
std::string trueLabel = "lor.true." + std::to_string(tempCounter);
|
||
std::string endLabel = "lor.end." + std::to_string(tempCounter++);
|
||
sysy::BasicBlock* trueBlock = currentIRFunction->addBasicBlock(trueLabel);
|
||
sysy::BasicBlock* endBlock = currentIRFunction->addBasicBlock(endLabel);
|
||
std::string temp = getNextTemp();
|
||
tmpTable[temp] = "i1";
|
||
|
||
// 文本 IR
|
||
irStream << " br i1 " << left << ", label %" << trueLabel << ", label %" << endLabel << "\n";
|
||
irStream << trueLabel << ":\n";
|
||
|
||
// SysY IR
|
||
sysy::IRBuilder builder(currentIRBlock);
|
||
builder.createCondBrInst(irLeft, trueBlock, endBlock, {}, {});
|
||
setIRPosition(trueBlock);
|
||
|
||
std::string right = std::any_cast<std::string>(lAndExps[i]->accept(this));
|
||
sysy::Value* irRight = irTmpTable[right];
|
||
irStream << " " << temp << " = or i1 " << left << ", " << right << "\n";
|
||
irStream << " br label %" << endLabel << "\n";
|
||
irStream << endLabel << ":\n";
|
||
|
||
// SysY IR 逻辑或（通过基本块实现短路求值）
|
||
builder.setPosition(trueBlock, trueBlock->end());
|
||
auto orInst = builder.createBinaryInst(sysy::Instruction::kICmpEQ, sysy::Type::getIntType(), irLeft, irRight, temp);
|
||
builder.createUncondBrInst(endBlock, {});
|
||
irTmpTable[temp] = orInst;
|
||
left = temp;
|
||
irLeft = orInst;
|
||
setIRPosition(endBlock);
|
||
}
|
||
return left;
|
||
}
|
||
|
||
// } // namespace sysy
|