1402 lines
52 KiB
C++
1402 lines
52 KiB
C++
#include "SCCP.h"
|
||
#include "Dom.h"
|
||
#include "Liveness.h"
|
||
#include "SideEffectAnalysis.h"
|
||
#include <algorithm>
|
||
#include <cassert>
|
||
#include <cmath> // For std::fmod, std::fabs
|
||
#include <limits> // For std::numeric_limits
|
||
#include <set> // For std::set in isKnownPureFunction
|
||
|
||
namespace sysy {
|
||
|
||
// Pass ID for SCCP
|
||
void *SCCP::ID = (void *)&SCCP::ID;
|
||
|
||
// SCCPContext methods
|
||
SSAPValue SCCPContext::Meet(const SSAPValue &a, const SSAPValue &b) {
|
||
if (a.state == LatticeVal::Bottom || b.state == LatticeVal::Bottom) {
|
||
return SSAPValue(LatticeVal::Bottom);
|
||
}
|
||
if (a.state == LatticeVal::Top) {
|
||
return b;
|
||
}
|
||
if (b.state == LatticeVal::Top) {
|
||
return a;
|
||
}
|
||
// Both are constants
|
||
if (a.constant_type != b.constant_type) {
|
||
return SSAPValue(LatticeVal::Bottom); // 不同类型的常量，结果为 Bottom
|
||
}
|
||
if (a.constantVal == b.constantVal) {
|
||
return a; // 相同常量
|
||
}
|
||
return SSAPValue(LatticeVal::Bottom); // 相同类型但值不同，结果为 Bottom
|
||
}
|
||
|
||
SSAPValue SCCPContext::GetValueState(Value *v) {
|
||
if (auto constVal = dynamic_cast<ConstantValue *>(v)) {
|
||
// 特殊处理 UndefinedValue：将其视为 Bottom
|
||
if (dynamic_cast<UndefinedValue *>(constVal)) {
|
||
return SSAPValue(LatticeVal::Bottom);
|
||
}
|
||
// 处理常规的 ConstantInteger 和 ConstantFloating
|
||
if (constVal->getType()->isInt()) {
|
||
return SSAPValue(constVal->getInt());
|
||
} else if (constVal->getType()->isFloat()) {
|
||
return SSAPValue(constVal->getFloat());
|
||
} else {
|
||
// 对于其他 ConstantValue 类型（例如，ConstantArray 等），
|
||
// 如果它们的具体值不能用于标量常量传播，则保守地视为 Bottom。
|
||
return SSAPValue(LatticeVal::Bottom);
|
||
}
|
||
}
|
||
if (valueState.count(v)) {
|
||
return valueState[v];
|
||
}
|
||
return SSAPValue(); // 默认初始化为 Top
|
||
}
|
||
|
||
void SCCPContext::UpdateState(Value *v, SSAPValue newState) {
|
||
SSAPValue oldState = GetValueState(v);
|
||
if (newState != oldState) {
|
||
if (DEBUG) {
|
||
std::cout << "Updating state for " << v->getName() << " from (";
|
||
if (oldState.state == LatticeVal::Top)
|
||
std::cout << "Top";
|
||
else if (oldState.state == LatticeVal::Constant) {
|
||
if (oldState.constant_type == ValueType::Integer)
|
||
std::cout << "Const<int>(" << std::get<int>(oldState.constantVal) << ")";
|
||
else
|
||
std::cout << "Const<float>(" << std::get<float>(oldState.constantVal) << ")";
|
||
} else
|
||
std::cout << "Bottom";
|
||
std::cout << ") to (";
|
||
if (newState.state == LatticeVal::Top)
|
||
std::cout << "Top";
|
||
else if (newState.state == LatticeVal::Constant) {
|
||
if (newState.constant_type == ValueType::Integer)
|
||
std::cout << "Const<int>(" << std::get<int>(newState.constantVal) << ")";
|
||
else
|
||
std::cout << "Const<float>(" << std::get<float>(newState.constantVal) << ")";
|
||
} else
|
||
std::cout << "Bottom";
|
||
std::cout << ")" << std::endl;
|
||
}
|
||
|
||
valueState[v] = newState;
|
||
// 如果状态发生变化，将所有使用者添加到指令工作列表
|
||
for (auto &use_ptr : v->getUses()) {
|
||
if (auto userInst = dynamic_cast<Instruction *>(use_ptr->getUser())) {
|
||
instWorkList.push(userInst);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void SCCPContext::AddEdgeToWorkList(BasicBlock *fromBB, BasicBlock *toBB) {
|
||
// 检查边是否已经访问过，防止重复处理
|
||
if (visitedCFGEdges.count({fromBB, toBB})) {
|
||
return;
|
||
}
|
||
visitedCFGEdges.insert({fromBB, toBB});
|
||
|
||
if (DEBUG) {
|
||
std::cout << "Adding edge to worklist: " << fromBB->getName() << " -> " << toBB->getName() << std::endl;
|
||
}
|
||
edgeWorkList.push({fromBB, toBB});
|
||
}
|
||
|
||
void SCCPContext::MarkBlockExecutable(BasicBlock *block) {
|
||
if (executableBlocks.insert(block).second) { // insert 返回 pair，second 为 true 表示插入成功
|
||
if (DEBUG) {
|
||
std::cout << "Marking block " << block->getName() << " as executable." << std::endl;
|
||
}
|
||
// 将新可执行块中的所有指令添加到指令工作列表
|
||
for (auto &inst_ptr : block->getInstructions()) {
|
||
instWorkList.push(inst_ptr.get());
|
||
}
|
||
}
|
||
}
|
||
|
||
// 辅助函数：对二元操作进行常量折叠
|
||
SSAPValue SCCPContext::ComputeConstant(BinaryInst *binaryInst, SSAPValue lhsVal, SSAPValue rhsVal) {
|
||
// 确保操作数是常量
|
||
if (lhsVal.state != LatticeVal::Constant || rhsVal.state != LatticeVal::Constant) {
|
||
return SSAPValue(LatticeVal::Bottom); // 如果不是常量，则不能折叠
|
||
}
|
||
|
||
// 处理整数运算 (kAdd, kSub, kMul, kDiv, kRem, kICmp*, kAnd, kOr)
|
||
if (lhsVal.constant_type == ValueType::Integer && rhsVal.constant_type == ValueType::Integer) {
|
||
int lhs = std::get<int>(lhsVal.constantVal);
|
||
int rhs = std::get<int>(rhsVal.constantVal);
|
||
int result = 0;
|
||
|
||
switch (binaryInst->getKind()) {
|
||
case Instruction::kAdd:
|
||
result = lhs + rhs;
|
||
break;
|
||
case Instruction::kSub:
|
||
result = lhs - rhs;
|
||
break;
|
||
case Instruction::kMul:
|
||
result = lhs * rhs;
|
||
break;
|
||
case Instruction::kDiv:
|
||
if (rhs == 0)
|
||
return SSAPValue(LatticeVal::Bottom); // 除零
|
||
result = lhs / rhs;
|
||
break;
|
||
case Instruction::kRem:
|
||
if (rhs == 0)
|
||
return SSAPValue(LatticeVal::Bottom); // 模零
|
||
result = lhs % rhs;
|
||
break;
|
||
case Instruction::kICmpEQ:
|
||
result = (lhs == rhs);
|
||
break;
|
||
case Instruction::kICmpNE:
|
||
result = (lhs != rhs);
|
||
break;
|
||
case Instruction::kICmpLT:
|
||
result = (lhs < rhs);
|
||
break;
|
||
case Instruction::kICmpGT:
|
||
result = (lhs > rhs);
|
||
break;
|
||
case Instruction::kICmpLE:
|
||
result = (lhs <= rhs);
|
||
break;
|
||
case Instruction::kICmpGE:
|
||
result = (lhs >= rhs);
|
||
break;
|
||
case Instruction::kAnd:
|
||
result = (lhs && rhs);
|
||
break;
|
||
case Instruction::kOr:
|
||
result = (lhs || rhs);
|
||
break;
|
||
default:
|
||
return SSAPValue(LatticeVal::Bottom); // 未知或不匹配的二元操作
|
||
}
|
||
return SSAPValue(result);
|
||
}
|
||
// 处理浮点运算 (kFAdd, kFSub, kFMul, kFDiv, kFCmp*)
|
||
else if (lhsVal.constant_type == ValueType::Float && rhsVal.constant_type == ValueType::Float) {
|
||
float lhs = std::get<float>(lhsVal.constantVal);
|
||
float rhs = std::get<float>(rhsVal.constantVal);
|
||
float f_result = 0.0f;
|
||
int i_result = 0; // For comparison results
|
||
|
||
switch (binaryInst->getKind()) {
|
||
case Instruction::kFAdd:
|
||
f_result = lhs + rhs;
|
||
break;
|
||
case Instruction::kFSub:
|
||
f_result = lhs - rhs;
|
||
break;
|
||
case Instruction::kFMul:
|
||
f_result = lhs * rhs;
|
||
break;
|
||
case Instruction::kFDiv:
|
||
if (rhs == 0.0f)
|
||
return SSAPValue(LatticeVal::Bottom); // 除零
|
||
f_result = lhs / rhs;
|
||
break;
|
||
// kRem 不支持浮点数，但如果你的 IR 定义了浮点模运算，需要使用 std::fmod
|
||
case Instruction::kFCmpEQ:
|
||
i_result = (lhs == rhs);
|
||
return SSAPValue(i_result);
|
||
case Instruction::kFCmpNE:
|
||
i_result = (lhs != rhs);
|
||
return SSAPValue(i_result);
|
||
case Instruction::kFCmpLT:
|
||
i_result = (lhs < rhs);
|
||
return SSAPValue(i_result);
|
||
case Instruction::kFCmpGT:
|
||
i_result = (lhs > rhs);
|
||
return SSAPValue(i_result);
|
||
case Instruction::kFCmpLE:
|
||
i_result = (lhs <= rhs);
|
||
return SSAPValue(i_result);
|
||
case Instruction::kFCmpGE:
|
||
i_result = (lhs >= rhs);
|
||
return SSAPValue(i_result);
|
||
default:
|
||
return SSAPValue(LatticeVal::Bottom); // 未知或不匹配的浮点二元操作
|
||
}
|
||
return SSAPValue(f_result);
|
||
}
|
||
|
||
return SSAPValue(LatticeVal::Bottom); // 类型不匹配或不支持的类型组合
|
||
}
|
||
|
||
// 辅助函数：对一元操作进行常量折叠
|
||
SSAPValue SCCPContext::ComputeConstant(UnaryInst *unaryInst, SSAPValue operandVal) {
|
||
if (operandVal.state != LatticeVal::Constant) {
|
||
return SSAPValue(LatticeVal::Bottom);
|
||
}
|
||
|
||
if (operandVal.constant_type == ValueType::Integer) {
|
||
int val = std::get<int>(operandVal.constantVal);
|
||
switch (unaryInst->getKind()) {
|
||
case Instruction::kAdd:
|
||
return SSAPValue(val);
|
||
case Instruction::kNeg:
|
||
return SSAPValue(-val);
|
||
case Instruction::kNot:
|
||
return SSAPValue(!val);
|
||
default:
|
||
return SSAPValue(LatticeVal::Bottom);
|
||
}
|
||
} else if (operandVal.constant_type == ValueType::Float) {
|
||
float val = std::get<float>(operandVal.constantVal);
|
||
switch (unaryInst->getKind()) {
|
||
case Instruction::kAdd:
|
||
return SSAPValue(val);
|
||
case Instruction::kFNeg:
|
||
return SSAPValue(-val);
|
||
case Instruction::kFNot:
|
||
return SSAPValue(static_cast<int>(val == 0.0f)); // 浮点数非，0.0f 为真，其他为假
|
||
default:
|
||
return SSAPValue(LatticeVal::Bottom);
|
||
}
|
||
}
|
||
return SSAPValue(LatticeVal::Bottom);
|
||
}
|
||
|
||
// 辅助函数：检查是否为已知的纯函数
|
||
bool SCCPContext::isKnownPureFunction(const std::string &funcName) const {
|
||
// SysY中一些已知的纯函数（不修改全局状态，结果只依赖参数）
|
||
static const std::set<std::string> knownPureFunctions = {
|
||
// 数学函数（如果有的话）
|
||
// "abs", "fabs", "sqrt", "sin", "cos"
|
||
// SysY标准中基本没有纯函数，大多数都有I/O副作用
|
||
};
|
||
|
||
return knownPureFunctions.find(funcName) != knownPureFunctions.end();
|
||
}
|
||
|
||
// 辅助函数：计算纯函数的常量结果
|
||
SSAPValue SCCPContext::computePureFunctionResult(CallInst *call, const std::vector<SSAPValue> &argValues) {
|
||
Function *calledFunc = call->getCallee();
|
||
if (!calledFunc) {
|
||
return SSAPValue(LatticeVal::Bottom);
|
||
}
|
||
|
||
std::string funcName = calledFunc->getName();
|
||
|
||
// 目前SysY中没有标准的纯函数，这里预留扩展空间
|
||
// 未来可以添加数学函数的常量折叠
|
||
/*
|
||
if (funcName == "abs" && argValues.size() == 1) {
|
||
if (argValues[0].constant_type == ValueType::Integer) {
|
||
int val = std::get<int>(argValues[0].constantVal);
|
||
return SSAPValue(std::abs(val));
|
||
}
|
||
}
|
||
*/
|
||
|
||
return SSAPValue(LatticeVal::Bottom);
|
||
}
|
||
|
||
// 辅助函数：查找存储到指定位置的常量值
|
||
SSAPValue SCCPContext::findStoredConstantValue(Value *ptr, BasicBlock *currentBB) {
|
||
if (!aliasAnalysis) {
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: No alias analysis available" << std::endl;
|
||
}
|
||
return SSAPValue(LatticeVal::Bottom);
|
||
}
|
||
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Searching for stored constant value for ptr" << std::endl;
|
||
}
|
||
|
||
// 从当前块的指令列表末尾向前查找最近的Store
|
||
std::vector<Instruction*> instructions;
|
||
for (auto it = currentBB->begin(); it != currentBB->end(); ++it) {
|
||
instructions.push_back(it->get());
|
||
}
|
||
|
||
for (int i = instructions.size() - 1; i >= 0; --i) {
|
||
Instruction *prevInst = instructions[i];
|
||
|
||
if (prevInst->isStore()) {
|
||
StoreInst *storeInst = static_cast<StoreInst *>(prevInst);
|
||
Value *storePtr = storeInst->getPointer();
|
||
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Checking store instruction" << std::endl;
|
||
}
|
||
|
||
// 使用别名分析检查Store是否针对相同的内存位置
|
||
auto aliasResult = aliasAnalysis->queryAlias(ptr, storePtr);
|
||
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Alias result: " << (int)aliasResult << std::endl;
|
||
}
|
||
|
||
if (aliasResult == AliasType::SELF_ALIAS) {
|
||
// 找到了对相同位置的Store，获取存储的值
|
||
Value *storedValue = storeInst->getValue();
|
||
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Found matching store, checking value type" << std::endl;
|
||
}
|
||
|
||
// 检查存储的值是否为常量
|
||
if (auto constInt = dynamic_cast<ConstantInteger *>(storedValue)) {
|
||
int val = std::get<int>(constInt->getVal());
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Found constant integer value: " << val << std::endl;
|
||
}
|
||
return SSAPValue(val);
|
||
} else if (auto constFloat = dynamic_cast<ConstantFloating *>(storedValue)) {
|
||
float val = std::get<float>(constFloat->getVal());
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Found constant float value: " << val << std::endl;
|
||
}
|
||
return SSAPValue(val);
|
||
} else {
|
||
// 存储的值不是常量，检查其SCCP状态
|
||
SSAPValue storedState = GetValueState(storedValue);
|
||
if (storedState.state == LatticeVal::Constant) {
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Found SCCP constant value" << std::endl;
|
||
}
|
||
return storedState;
|
||
} else {
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Stored value is not constant" << std::endl;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 找到了最近的Store但不是常量，停止查找
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Found non-constant store, stopping search" << std::endl;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: No constant value found" << std::endl;
|
||
}
|
||
return SSAPValue(LatticeVal::Bottom);
|
||
}
|
||
|
||
// 辅助函数：动态检查数组访问是否为常量索引（考虑SCCP状态）
|
||
bool SCCPContext::hasRuntimeConstantAccess(Value *ptr) {
|
||
if (auto gep = dynamic_cast<GetElementPtrInst *>(ptr)) {
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Checking runtime constant access for GEP instruction" << std::endl;
|
||
}
|
||
|
||
// 检查所有索引是否为常量或SCCP传播的常量
|
||
bool allConstantIndices = true;
|
||
for (auto indexUse : gep->getIndices()) {
|
||
Value* index = indexUse->getValue();
|
||
|
||
// 首先检查是否为编译时常量
|
||
if (auto constInt = dynamic_cast<ConstantInteger *>(index)) {
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Index is compile-time constant integer: " << std::get<int>(constInt->getVal()) << std::endl;
|
||
}
|
||
continue;
|
||
}
|
||
if (auto constFloat = dynamic_cast<ConstantFloating *>(index)) {
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Index is compile-time constant float: " << std::get<float>(constFloat->getVal()) << std::endl;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
// 检查是否为SCCP传播的常量
|
||
SSAPValue indexState = GetValueState(index);
|
||
if (indexState.state == LatticeVal::Constant) {
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Index is SCCP constant: ";
|
||
if (indexState.constant_type == ValueType::Integer) {
|
||
std::cout << std::get<int>(indexState.constantVal);
|
||
} else {
|
||
std::cout << std::get<float>(indexState.constantVal);
|
||
}
|
||
std::cout << std::endl;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
// 如果任何一个索引不是常量，返回false
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Index is not constant, access is not constant" << std::endl;
|
||
}
|
||
allConstantIndices = false;
|
||
break;
|
||
}
|
||
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: hasRuntimeConstantAccess result: " << (allConstantIndices ? "true" : "false") << std::endl;
|
||
}
|
||
return allConstantIndices;
|
||
}
|
||
|
||
// 对于非GEP指令，回退到别名分析的静态结果
|
||
if (aliasAnalysis) {
|
||
return aliasAnalysis->hasConstantAccess(ptr);
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
// 辅助函数：处理单条指令
|
||
void SCCPContext::ProcessInstruction(Instruction *inst) {
|
||
SSAPValue oldState = GetValueState(inst);
|
||
SSAPValue newState;
|
||
|
||
if (!executableBlocks.count(inst->getParent())) {
|
||
// 如果指令所在的块不可执行，其值应保持 Top
|
||
// 除非它之前已经是 Bottom，因为 Bottom 是单调的
|
||
if (oldState.state != LatticeVal::Bottom) {
|
||
newState = SSAPValue(); // Top
|
||
} else {
|
||
newState = oldState; // 保持 Bottom
|
||
}
|
||
UpdateState(inst, newState);
|
||
return; // 不处理不可达块中的指令的实际值
|
||
}
|
||
|
||
if(DEBUG) {
|
||
std::cout << "Processing instruction: " << inst->getName() << " in block " << inst->getParent()->getName() << std::endl;
|
||
std::cout << "Old state: ";
|
||
if (oldState.state == LatticeVal::Top) {
|
||
std::cout << "Top";
|
||
} else if (oldState.state == LatticeVal::Constant) {
|
||
if (oldState.constant_type == ValueType::Integer) {
|
||
std::cout << "Const<int>(" << std::get<int>(oldState.constantVal) << ")";
|
||
} else {
|
||
std::cout << "Const<float>(" << std::get<float>(oldState.constantVal) << ")";
|
||
}
|
||
} else {
|
||
std::cout << "Bottom";
|
||
}
|
||
}
|
||
|
||
switch (inst->getKind()) {
|
||
case Instruction::kAdd:
|
||
case Instruction::kSub:
|
||
case Instruction::kMul:
|
||
case Instruction::kDiv:
|
||
case Instruction::kRem:
|
||
case Instruction::kICmpEQ:
|
||
case Instruction::kICmpNE:
|
||
case Instruction::kICmpLT:
|
||
case Instruction::kICmpGT:
|
||
case Instruction::kICmpLE:
|
||
case Instruction::kICmpGE:
|
||
case Instruction::kFAdd:
|
||
case Instruction::kFSub:
|
||
case Instruction::kFMul:
|
||
case Instruction::kFDiv:
|
||
case Instruction::kFCmpEQ:
|
||
case Instruction::kFCmpNE:
|
||
case Instruction::kFCmpLT:
|
||
case Instruction::kFCmpGT:
|
||
case Instruction::kFCmpLE:
|
||
case Instruction::kFCmpGE:
|
||
case Instruction::kAnd:
|
||
case Instruction::kOr: {
|
||
BinaryInst *binaryInst = static_cast<BinaryInst *>(inst);
|
||
SSAPValue lhs = GetValueState(binaryInst->getOperand(0));
|
||
SSAPValue rhs = GetValueState(binaryInst->getOperand(1));
|
||
// 如果任一操作数是 Bottom，结果就是 Bottom
|
||
if (lhs.state == LatticeVal::Bottom || rhs.state == LatticeVal::Bottom) {
|
||
newState = SSAPValue(LatticeVal::Bottom);
|
||
} else if (lhs.state == LatticeVal::Top || rhs.state == LatticeVal::Top) {
|
||
newState = SSAPValue(); // Top
|
||
} else { // 都是常量
|
||
newState = ComputeConstant(binaryInst, lhs, rhs);
|
||
}
|
||
break;
|
||
}
|
||
case Instruction::kNeg:
|
||
case Instruction::kNot:
|
||
case Instruction::kFNeg:
|
||
case Instruction::kFNot: {
|
||
UnaryInst *unaryInst = static_cast<UnaryInst *>(inst);
|
||
SSAPValue operand = GetValueState(unaryInst->getOperand());
|
||
if (operand.state == LatticeVal::Bottom) {
|
||
newState = SSAPValue(LatticeVal::Bottom);
|
||
} else if (operand.state == LatticeVal::Top) {
|
||
newState = SSAPValue(); // Top
|
||
} else { // 是常量
|
||
newState = ComputeConstant(unaryInst, operand);
|
||
}
|
||
break;
|
||
}
|
||
// 直接处理类型转换指令
|
||
case Instruction::kFtoI: {
|
||
SSAPValue operand = GetValueState(inst->getOperand(0));
|
||
if (operand.state == LatticeVal::Constant && operand.constant_type == ValueType::Float) {
|
||
newState = SSAPValue(static_cast<int>(std::get<float>(operand.constantVal)));
|
||
} else if (operand.state == LatticeVal::Bottom) {
|
||
newState = SSAPValue(LatticeVal::Bottom);
|
||
} else { // Top
|
||
newState = SSAPValue();
|
||
}
|
||
break;
|
||
}
|
||
case Instruction::kItoF: {
|
||
SSAPValue operand = GetValueState(inst->getOperand(0));
|
||
if (operand.state == LatticeVal::Constant && operand.constant_type == ValueType::Integer) {
|
||
newState = SSAPValue(static_cast<float>(std::get<int>(operand.constantVal)));
|
||
} else if (operand.state == LatticeVal::Bottom) {
|
||
newState = SSAPValue(LatticeVal::Bottom);
|
||
} else { // Top
|
||
newState = SSAPValue();
|
||
}
|
||
break;
|
||
}
|
||
case Instruction::kBitFtoI: {
|
||
SSAPValue operand = GetValueState(inst->getOperand(0));
|
||
if (operand.state == LatticeVal::Constant && operand.constant_type == ValueType::Float) {
|
||
float fval = std::get<float>(operand.constantVal);
|
||
newState = SSAPValue(*reinterpret_cast<int *>(&fval));
|
||
} else if (operand.state == LatticeVal::Bottom) {
|
||
newState = SSAPValue(LatticeVal::Bottom);
|
||
} else { // Top
|
||
newState = SSAPValue();
|
||
}
|
||
break;
|
||
}
|
||
case Instruction::kBitItoF: {
|
||
SSAPValue operand = GetValueState(inst->getOperand(0));
|
||
if (operand.state == LatticeVal::Constant && operand.constant_type == ValueType::Integer) {
|
||
int ival = std::get<int>(operand.constantVal);
|
||
newState = SSAPValue(*reinterpret_cast<float *>(&ival));
|
||
} else if (operand.state == LatticeVal::Bottom) {
|
||
newState = SSAPValue(LatticeVal::Bottom);
|
||
} else { // Top
|
||
newState = SSAPValue();
|
||
}
|
||
break;
|
||
}
|
||
case Instruction::kLoad: {
|
||
// 使用别名分析和副作用分析改进Load指令的处理
|
||
Value *ptr = inst->getOperand(0);
|
||
|
||
// 首先检查是否是全局常量
|
||
if (auto globalVal = dynamic_cast<GlobalValue *>(ptr)) {
|
||
// 如果 GlobalValue 有初始化器，并且它是常量，我们可以传播
|
||
// TODO: 检查全局变量的初始化器进行常量传播
|
||
newState = SSAPValue(LatticeVal::Bottom);
|
||
} else if (aliasAnalysis && sideEffectAnalysis) {
|
||
// 使用别名分析和副作用分析进行更精确的Load分析
|
||
if (aliasAnalysis->isLocalArray(ptr) && (aliasAnalysis->hasConstantAccess(ptr) || hasRuntimeConstantAccess(ptr))) {
|
||
// 对于局部数组的常量索引访问，检查是否有影响该位置的Store
|
||
bool mayBeModified = false;
|
||
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Analyzing local array with constant access for modification" << std::endl;
|
||
}
|
||
|
||
// 遍历指令所在块之前的所有指令，查找可能修改该内存位置的Store
|
||
BasicBlock *currentBB = inst->getParent();
|
||
auto instPos = currentBB->findInstIterator(inst);
|
||
|
||
SSAPValue foundConstantValue = SSAPValue(LatticeVal::Bottom);
|
||
bool hasFoundDefinitiveStore = false;
|
||
|
||
for (auto it = currentBB->begin(); it != instPos; ++it) {
|
||
Instruction *prevInst = it->get();
|
||
|
||
if (prevInst->isStore()) {
|
||
StoreInst *storeInst = static_cast<StoreInst *>(prevInst);
|
||
Value *storePtr = storeInst->getPointer();
|
||
|
||
// 使用别名分析判断Store是否可能影响当前Load
|
||
auto aliasResult = aliasAnalysis->queryAlias(ptr, storePtr);
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Checking store with alias result: " << (int)aliasResult << std::endl;
|
||
}
|
||
|
||
if (aliasResult == AliasType::SELF_ALIAS) {
|
||
// 找到对相同位置的精确Store
|
||
Value *storedValue = storeInst->getValue();
|
||
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Found exact store to same location, checking value" << std::endl;
|
||
}
|
||
|
||
// 检查存储的值是否为常量
|
||
if (auto constInt = dynamic_cast<ConstantInteger *>(storedValue)) {
|
||
int val = std::get<int>(constInt->getVal());
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Store contains constant integer: " << val << std::endl;
|
||
}
|
||
foundConstantValue = SSAPValue(val);
|
||
hasFoundDefinitiveStore = true;
|
||
// 继续遍历，查找是否有更后面的Store覆盖这个值
|
||
} else if (auto constFloat = dynamic_cast<ConstantFloating *>(storedValue)) {
|
||
float val = std::get<float>(constFloat->getVal());
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Store contains constant float: " << val << std::endl;
|
||
}
|
||
foundConstantValue = SSAPValue(val);
|
||
hasFoundDefinitiveStore = true;
|
||
} else {
|
||
// 存储的值不是编译时常量，检查其SCCP状态
|
||
SSAPValue storedState = GetValueState(storedValue);
|
||
if (storedState.state == LatticeVal::Constant) {
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Store contains SCCP constant" << std::endl;
|
||
}
|
||
foundConstantValue = storedState;
|
||
hasFoundDefinitiveStore = true;
|
||
} else {
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Store contains non-constant value" << std::endl;
|
||
}
|
||
// 非常量Store覆盖了之前的常量，无法传播
|
||
foundConstantValue = SSAPValue(LatticeVal::Bottom);
|
||
hasFoundDefinitiveStore = true;
|
||
}
|
||
}
|
||
} else if (aliasResult != AliasType::NO_ALIAS) {
|
||
// 可能有别名，但不确定
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Found store with uncertain alias, stopping propagation" << std::endl;
|
||
}
|
||
mayBeModified = true;
|
||
break;
|
||
}
|
||
} else if (prevInst->isCall()) {
|
||
// 检查函数调用是否可能修改该内存位置
|
||
if (sideEffectAnalysis->mayModifyMemory(prevInst)) {
|
||
// 进一步检查是否可能影响局部数组
|
||
if (!aliasAnalysis->isLocalArray(ptr) ||
|
||
sideEffectAnalysis->mayModifyGlobal(prevInst)) {
|
||
mayBeModified = true;
|
||
break;
|
||
}
|
||
}
|
||
} else if (prevInst->isMemset()) {
|
||
// Memset指令可能影响内存，但只有在它在相关Store之前时才阻止常量传播
|
||
MemsetInst *memsetInst = static_cast<MemsetInst *>(prevInst);
|
||
Value *memsetPtr = memsetInst->getOperand(0);
|
||
|
||
auto aliasResult = aliasAnalysis->queryAlias(ptr, memsetPtr);
|
||
if (aliasResult != AliasType::NO_ALIAS) {
|
||
// Memset可能影响这个位置，但我们继续查找是否有Store覆盖了memset
|
||
// 不立即设置mayBeModified = true，让后续的Store有机会覆盖
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Found memset that may affect location, but continuing to check for overwriting stores" << std::endl;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: mayBeModified = " << (mayBeModified ? "true" : "false") << std::endl;
|
||
std::cout << "SCCP: hasFoundDefinitiveStore = " << (hasFoundDefinitiveStore ? "true" : "false") << std::endl;
|
||
}
|
||
|
||
if (!mayBeModified) {
|
||
if (hasFoundDefinitiveStore && foundConstantValue.state == LatticeVal::Constant) {
|
||
// 直接使用找到的常量值
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Using found constant value from store analysis: ";
|
||
if (foundConstantValue.constant_type == ValueType::Integer) {
|
||
std::cout << std::get<int>(foundConstantValue.constantVal);
|
||
} else {
|
||
std::cout << std::get<float>(foundConstantValue.constantVal);
|
||
}
|
||
std::cout << std::endl;
|
||
}
|
||
newState = foundConstantValue;
|
||
} else {
|
||
// 如果没有发现修改该位置的指令，尝试用旧方法找到对应的Store值
|
||
SSAPValue constantValue = findStoredConstantValue(ptr, inst->getParent());
|
||
if (constantValue.state == LatticeVal::Constant) {
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Found constant value for array load using fallback method: ";
|
||
if (constantValue.constant_type == ValueType::Integer) {
|
||
std::cout << std::get<int>(constantValue.constantVal);
|
||
} else {
|
||
std::cout << std::get<float>(constantValue.constantVal);
|
||
}
|
||
std::cout << std::endl;
|
||
}
|
||
newState = constantValue;
|
||
} else {
|
||
newState = SSAPValue(LatticeVal::Bottom);
|
||
}
|
||
}
|
||
} else {
|
||
newState = SSAPValue(LatticeVal::Bottom);
|
||
}
|
||
} else {
|
||
// 非局部数组或非常量访问，保守处理
|
||
newState = SSAPValue(LatticeVal::Bottom);
|
||
}
|
||
} else {
|
||
// 没有分析信息时保守处理
|
||
newState = SSAPValue(LatticeVal::Bottom);
|
||
}
|
||
|
||
if (DEBUG && aliasAnalysis && sideEffectAnalysis) {
|
||
std::cout << "SCCP: Load instruction analysis - "
|
||
<< (aliasAnalysis->isLocalArray(ptr) ? "local array" : "other")
|
||
<< ", static constant access: "
|
||
<< (aliasAnalysis->hasConstantAccess(ptr) ? "yes" : "no")
|
||
<< ", runtime constant access: "
|
||
<< (hasRuntimeConstantAccess(ptr) ? "yes" : "no") << std::endl;
|
||
}
|
||
break;
|
||
}
|
||
case Instruction::kStore:
|
||
// Store 指令不产生值，其 SSAPValue 不重要
|
||
newState = SSAPValue(); // 保持 Top
|
||
break;
|
||
case Instruction::kCall: {
|
||
// 使用副作用分析改进Call指令处理
|
||
CallInst *callInst = static_cast<CallInst *>(inst);
|
||
|
||
if (sideEffectAnalysis) {
|
||
const auto &sideEffect = sideEffectAnalysis->getInstructionSideEffect(callInst);
|
||
|
||
// 检查是否为纯函数且所有参数都是常量
|
||
if (sideEffect.isPure && sideEffect.type == SideEffectType::NO_SIDE_EFFECT) {
|
||
// 对于纯函数，检查所有参数是否都是常量
|
||
bool allArgsConstant = true;
|
||
std::vector<SSAPValue> argValues;
|
||
|
||
for (unsigned i = 0; i < callInst->getNumOperands() - 1; ++i) { // 减1排除函数本身
|
||
SSAPValue argVal = GetValueState(callInst->getOperand(i));
|
||
argValues.push_back(argVal);
|
||
if (argVal.state != LatticeVal::Constant) {
|
||
allArgsConstant = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (allArgsConstant) {
|
||
// 对于参数全为常量的纯函数，可以尝试常量折叠
|
||
// 但由于实际执行函数比较复杂，这里先标记为可优化
|
||
// TODO: 实现具体的纯函数常量折叠
|
||
Function *calledFunc = callInst->getCallee();
|
||
if (calledFunc && isKnownPureFunction(calledFunc->getName())) {
|
||
// 对已知的纯函数进行常量计算
|
||
newState = computePureFunctionResult(callInst, argValues);
|
||
} else {
|
||
newState = SSAPValue(LatticeVal::Bottom);
|
||
}
|
||
} else {
|
||
// 参数不全是常量，但函数无副作用
|
||
newState = SSAPValue(LatticeVal::Bottom);
|
||
}
|
||
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Pure function call with "
|
||
<< (allArgsConstant ? "constant" : "non-constant") << " arguments" << std::endl;
|
||
}
|
||
} else {
|
||
// 有副作用的函数调用，保守处理
|
||
newState = SSAPValue(LatticeVal::Bottom);
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Function call with side effects" << std::endl;
|
||
}
|
||
}
|
||
} else {
|
||
// 没有副作用分析时，保守处理所有Call
|
||
newState = SSAPValue(LatticeVal::Bottom);
|
||
}
|
||
break;
|
||
}
|
||
case Instruction::kGetElementPtr: {
|
||
// GEP 指令计算地址，通常其结果值（地址指向的内容）是 Bottom
|
||
// 除非所有索引和基指针都是常量，指向一个确定常量值的内存位置
|
||
bool all_ops_constant = true;
|
||
for (unsigned i = 0; i < inst->getNumOperands(); ++i) {
|
||
if (GetValueState(inst->getOperand(i)).state != LatticeVal::Constant) {
|
||
all_ops_constant = false;
|
||
break;
|
||
}
|
||
}
|
||
// 即使地址是常量，地址处的内容通常不是。所以通常是 Bottom
|
||
newState = SSAPValue(LatticeVal::Bottom);
|
||
break;
|
||
}
|
||
case Instruction::kPhi: {
|
||
PhiInst *phi = static_cast<PhiInst *>(inst);
|
||
if(DEBUG) {
|
||
std::cout << "Processing Phi node: " << phi->getName() << std::endl;
|
||
}
|
||
// 标准SCCP的phi节点处理：
|
||
// 只考虑可执行前驱，但要保证单调性
|
||
SSAPValue currentPhiState = GetValueState(phi);
|
||
SSAPValue phiResult = SSAPValue(); // 初始为 Top
|
||
bool hasAnyExecutablePred = false;
|
||
|
||
for (unsigned i = 0; i < phi->getNumIncomingValues(); ++i) {
|
||
BasicBlock *incomingBlock = phi->getIncomingBlock(i);
|
||
|
||
if (executableBlocks.count(incomingBlock)) {
|
||
hasAnyExecutablePred = true;
|
||
Value *incomingVal = phi->getIncomingValue(i);
|
||
SSAPValue incomingState = GetValueState(incomingVal);
|
||
if(DEBUG) {
|
||
std::cout << " Incoming from block " << incomingBlock->getName()
|
||
<< " with value " << incomingVal->getName() << " state: ";
|
||
if (incomingState.state == LatticeVal::Top)
|
||
std::cout << "Top";
|
||
else if (incomingState.state == LatticeVal::Constant) {
|
||
if (incomingState.constant_type == ValueType::Integer)
|
||
std::cout << "Const<int>(" << std::get<int>(incomingState.constantVal) << ")";
|
||
else
|
||
std::cout << "Const<float>(" << std::get<float>(incomingState.constantVal) << ")";
|
||
} else
|
||
std::cout << "Bottom";
|
||
std::cout << std::endl;
|
||
}
|
||
phiResult = Meet(phiResult, incomingState);
|
||
|
||
if (phiResult.state == LatticeVal::Bottom) {
|
||
break; // 提前退出优化
|
||
}
|
||
}
|
||
// 不可执行前驱暂时被忽略
|
||
// 这是标准SCCP的做法，依赖于单调性保证正确性
|
||
}
|
||
|
||
if (!hasAnyExecutablePred) {
|
||
// 没有可执行前驱，保持Top状态
|
||
newState = SSAPValue();
|
||
} else {
|
||
// 关键修复：使用严格的单调性
|
||
// 确保phi的值只能从Top -> Constant -> Bottom单向变化
|
||
if (currentPhiState.state == LatticeVal::Top) {
|
||
// 从Top状态，可以变为任何计算结果
|
||
newState = phiResult;
|
||
} else if (currentPhiState.state == LatticeVal::Constant) {
|
||
// 从Constant状态，只能保持相同常量或变为Bottom
|
||
if (phiResult.state == LatticeVal::Constant &&
|
||
currentPhiState.constantVal == phiResult.constantVal &&
|
||
currentPhiState.constant_type == phiResult.constant_type) {
|
||
// 保持相同的常量
|
||
newState = currentPhiState;
|
||
} else {
|
||
// 不同的值，必须变为Bottom
|
||
newState = SSAPValue(LatticeVal::Bottom);
|
||
}
|
||
} else {
|
||
// 已经是Bottom，保持Bottom
|
||
newState = currentPhiState;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case Instruction::kAlloca: // 对应 kAlloca
|
||
// Alloca 分配内存，返回一个指针，其内容是 Bottom
|
||
newState = SSAPValue(LatticeVal::Bottom);
|
||
break;
|
||
case Instruction::kBr: // 对应 kBr
|
||
case Instruction::kCondBr: // 对应 kCondBr
|
||
case Instruction::kReturn: // 对应 kReturn
|
||
case Instruction::kUnreachable: // 对应 kUnreachable
|
||
// 终结符指令不产生值
|
||
newState = SSAPValue(); // 保持 Top
|
||
break;
|
||
case Instruction::kMemset:
|
||
// Memset 不产生值，但有副作用，不进行常量传播
|
||
newState = SSAPValue(LatticeVal::Bottom);
|
||
break;
|
||
default:
|
||
if (DEBUG) {
|
||
std::cout << "Unimplemented instruction kind in SCCP: " << inst->getKind() << std::endl;
|
||
}
|
||
newState = SSAPValue(LatticeVal::Bottom); // 未知指令保守处理为 Bottom
|
||
break;
|
||
}
|
||
UpdateState(inst, newState);
|
||
|
||
// 特殊处理终结符指令，影响 CFG 边的可达性
|
||
if (inst->isTerminator()) {
|
||
if (inst->isBranch()) {
|
||
|
||
if (inst->isCondBr()) { // 使用 kCondBr
|
||
CondBrInst *branchInst = static_cast<CondBrInst *>(inst);
|
||
SSAPValue condVal = GetValueState(branchInst->getOperand(0));
|
||
if (condVal.state == LatticeVal::Constant) {
|
||
bool condition_is_true = false;
|
||
if (condVal.constant_type == ValueType::Integer) {
|
||
condition_is_true = (std::get<int>(condVal.constantVal) != 0);
|
||
} else if (condVal.constant_type == ValueType::Float) {
|
||
condition_is_true = (std::get<float>(condVal.constantVal) != 0.0f);
|
||
}
|
||
|
||
if (condition_is_true) {
|
||
AddEdgeToWorkList(branchInst->getParent(), branchInst->getThenBlock());
|
||
} else {
|
||
AddEdgeToWorkList(branchInst->getParent(), branchInst->getElseBlock());
|
||
}
|
||
} else { // 条件是 Top 或 Bottom，两条路径都可能
|
||
AddEdgeToWorkList(branchInst->getParent(), branchInst->getThenBlock());
|
||
AddEdgeToWorkList(branchInst->getParent(), branchInst->getElseBlock());
|
||
}
|
||
} else { // 无条件分支 (kBr)
|
||
UncondBrInst *branchInst = static_cast<UncondBrInst *>(inst);
|
||
AddEdgeToWorkList(branchInst->getParent(), branchInst->getBlock());
|
||
}
|
||
}
|
||
}
|
||
|
||
if (DEBUG) {
|
||
std::cout << "New state: ";
|
||
if (newState.state == LatticeVal::Top) {
|
||
std::cout << "Top";
|
||
} else if (newState.state == LatticeVal::Constant) {
|
||
if (newState.constant_type == ValueType::Integer) {
|
||
std::cout << "Const<int>(" << std::get<int>(newState.constantVal) << ")";
|
||
} else {
|
||
std::cout << "Const<float>(" << std::get<float>(newState.constantVal) << ")";
|
||
}
|
||
} else {
|
||
std::cout << "Bottom";
|
||
}
|
||
std::cout << std::endl;
|
||
}
|
||
}
|
||
|
||
// 辅助函数：处理单条控制流边
|
||
void SCCPContext::ProcessEdge(const std::pair<BasicBlock *, BasicBlock *> &edge) {
|
||
BasicBlock *fromBB = edge.first;
|
||
BasicBlock *toBB = edge.second;
|
||
|
||
// 检查目标块是否已经可执行
|
||
bool wasAlreadyExecutable = executableBlocks.count(toBB) > 0;
|
||
|
||
// 标记目标块为可执行（如果还不是的话）
|
||
MarkBlockExecutable(toBB);
|
||
|
||
// 如果目标块之前就已经可执行，那么需要重新处理其中的phi节点
|
||
// 因为现在有新的前驱变为可执行，phi节点的值可能需要更新
|
||
if (wasAlreadyExecutable) {
|
||
for (auto &inst_ptr : toBB->getInstructions()) {
|
||
if (dynamic_cast<PhiInst *>(inst_ptr.get())) {
|
||
instWorkList.push(inst_ptr.get());
|
||
}
|
||
}
|
||
}
|
||
// 如果目标块是新变为可执行的，MarkBlockExecutable已经添加了所有指令
|
||
}
|
||
|
||
// 阶段1: 常量传播与折叠
|
||
bool SCCPContext::PropagateConstants(Function *func) {
|
||
bool changed = false;
|
||
|
||
// 初始化：所有值 Top，所有块不可执行
|
||
for (auto &bb_ptr : func->getBasicBlocks()) {
|
||
executableBlocks.erase(bb_ptr.get());
|
||
for (auto &inst_ptr : bb_ptr->getInstructions()) {
|
||
valueState[inst_ptr.get()] = SSAPValue(); // Top
|
||
}
|
||
}
|
||
|
||
// 初始化函数参数为Bottom（因为它们在编译时是未知的）
|
||
for (auto arg : func->getArguments()) {
|
||
valueState[arg] = SSAPValue(LatticeVal::Bottom);
|
||
if (DEBUG) {
|
||
std::cout << "Initializing function argument " << arg->getName() << " to Bottom" << std::endl;
|
||
}
|
||
}
|
||
|
||
// 标记入口块为可执行
|
||
if (!func->getBasicBlocks().empty()) {
|
||
MarkBlockExecutable(func->getEntryBlock());
|
||
}
|
||
|
||
// 主循环：标准的SCCP工作列表算法
|
||
// 交替处理边工作列表和指令工作列表直到不动点
|
||
while (!instWorkList.empty() || !edgeWorkList.empty()) {
|
||
// 处理所有待处理的CFG边
|
||
while (!edgeWorkList.empty()) {
|
||
ProcessEdge(edgeWorkList.front());
|
||
edgeWorkList.pop();
|
||
}
|
||
|
||
// 处理所有待处理的指令
|
||
while (!instWorkList.empty()) {
|
||
Instruction *inst = instWorkList.front();
|
||
instWorkList.pop();
|
||
ProcessInstruction(inst);
|
||
}
|
||
}
|
||
|
||
// 应用常量替换和死代码消除
|
||
std::vector<Instruction *> instsToDelete;
|
||
for (auto &bb_ptr : func->getBasicBlocks()) {
|
||
BasicBlock *bb = bb_ptr.get();
|
||
if (!executableBlocks.count(bb)) {
|
||
// 整个块是死块，标记所有指令删除
|
||
for (auto &inst_ptr : bb->getInstructions()) {
|
||
instsToDelete.push_back(inst_ptr.get());
|
||
}
|
||
changed = true;
|
||
continue;
|
||
}
|
||
for (auto it = bb->begin(); it != bb->end();) {
|
||
Instruction *inst = it->get();
|
||
SSAPValue ssaPVal = GetValueState(inst);
|
||
|
||
if (ssaPVal.state == LatticeVal::Constant) {
|
||
ConstantValue *constVal = nullptr;
|
||
if (ssaPVal.constant_type == ValueType::Integer) {
|
||
constVal = ConstantInteger::get(std::get<int>(ssaPVal.constantVal));
|
||
} else if (ssaPVal.constant_type == ValueType::Float) {
|
||
constVal = ConstantFloating::get(std::get<float>(ssaPVal.constantVal));
|
||
} else {
|
||
constVal = UndefinedValue::get(inst->getType()); // 不应发生
|
||
}
|
||
|
||
if (DEBUG) {
|
||
std::cout << "Replacing " << inst->getName() << " with constant ";
|
||
if (ssaPVal.constant_type == ValueType::Integer)
|
||
std::cout << std::get<int>(ssaPVal.constantVal);
|
||
else
|
||
std::cout << std::get<float>(ssaPVal.constantVal);
|
||
std::cout << std::endl;
|
||
}
|
||
inst->replaceAllUsesWith(constVal);
|
||
instsToDelete.push_back(inst);
|
||
++it;
|
||
changed = true;
|
||
} else {
|
||
// 如果操作数是常量，直接替换为常量值（常量折叠）
|
||
for (unsigned i = 0; i < inst->getNumOperands(); ++i) {
|
||
Value *operand = inst->getOperand(i);
|
||
SSAPValue opVal = GetValueState(operand);
|
||
if (opVal.state == LatticeVal::Constant) {
|
||
ConstantValue *constOp = nullptr;
|
||
if (opVal.constant_type == ValueType::Integer) {
|
||
constOp = ConstantInteger::get(std::get<int>(opVal.constantVal));
|
||
} else if (opVal.constant_type == ValueType::Float) {
|
||
constOp = ConstantFloating::get(std::get<float>(opVal.constantVal));
|
||
} else {
|
||
constOp = UndefinedValue::get(operand->getType());
|
||
}
|
||
|
||
if (constOp != operand) {
|
||
inst->setOperand(i, constOp);
|
||
changed = true;
|
||
}
|
||
}
|
||
}
|
||
++it;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 实际删除指令
|
||
// TODO: 删除的逻辑需要考虑修改
|
||
for (Instruction *inst : instsToDelete) {
|
||
// 在尝试删除之前，先检查指令是否仍然附加到其父基本块。
|
||
// 如果它已经没有父块，可能说明它已被其他方式处理或已处于无效状态。
|
||
if (inst->getParent() != nullptr) {
|
||
// 调用负责完整删除的函数，该函数应负责清除uses并将其从父块中移除。
|
||
SysYIROptUtils::usedelete(inst);
|
||
}
|
||
else {
|
||
// 指令已不属于任何父块，无需再次删除。
|
||
if (DEBUG) {
|
||
std::cerr << "Info: Instruction " << inst->getName() << " was already detached or is not in a parent block." << std::endl;
|
||
}
|
||
}
|
||
}
|
||
return changed;
|
||
}
|
||
|
||
// 阶段2: 控制流简化
|
||
bool SCCPContext::SimplifyControlFlow(Function *func) {
|
||
bool changed = false;
|
||
|
||
// 重新确定可达块，因为 PropagateConstants 可能改变了分支条件
|
||
std::unordered_set<BasicBlock *> newReachableBlocks = FindReachableBlocks(func);
|
||
|
||
// 移除不可达块
|
||
std::vector<BasicBlock *> blocksToDelete;
|
||
for (auto &bb_ptr : func->getBasicBlocks()) {
|
||
if (bb_ptr.get() == func->getEntryBlock())
|
||
continue; // 入口块不能删除
|
||
if (newReachableBlocks.find(bb_ptr.get()) == newReachableBlocks.end()) {
|
||
blocksToDelete.push_back(bb_ptr.get());
|
||
changed = true;
|
||
}
|
||
}
|
||
for (BasicBlock *bb : blocksToDelete) {
|
||
RemoveDeadBlock(bb, func);
|
||
}
|
||
|
||
// 简化分支指令
|
||
for (auto &bb_ptr : func->getBasicBlocks()) {
|
||
BasicBlock *bb = bb_ptr.get();
|
||
if (!newReachableBlocks.count(bb))
|
||
continue; // 只处理可达块
|
||
|
||
Instruction *terminator = bb->terminator()->get();
|
||
if (terminator->isBranch()) {
|
||
|
||
if (terminator->isCondBr()) { // 检查是否是条件分支 (kCondBr)
|
||
CondBrInst *branchInst = static_cast<CondBrInst *>(terminator);
|
||
SSAPValue condVal = GetValueState(branchInst->getOperand(0));
|
||
if (condVal.state == LatticeVal::Constant) {
|
||
bool condition_is_true = false;
|
||
if (condVal.constant_type == ValueType::Integer) {
|
||
condition_is_true = (std::get<int>(condVal.constantVal) != 0);
|
||
} else if (condVal.constant_type == ValueType::Float) {
|
||
condition_is_true = (std::get<float>(condVal.constantVal) != 0.0f);
|
||
}
|
||
SimplifyBranch(branchInst, condition_is_true);
|
||
changed = true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return changed;
|
||
}
|
||
|
||
// 查找所有可达的基本块 (基于常量条件)
|
||
std::unordered_set<BasicBlock *> SCCPContext::FindReachableBlocks(Function *func) {
|
||
std::unordered_set<BasicBlock *> reachable;
|
||
std::queue<BasicBlock *> q;
|
||
|
||
if (func->getEntryBlock()) {
|
||
q.push(func->getEntryBlock());
|
||
reachable.insert(func->getEntryBlock());
|
||
}
|
||
|
||
while (!q.empty()) {
|
||
BasicBlock *currentBB = q.front();
|
||
q.pop();
|
||
|
||
Instruction *terminator = currentBB->terminator()->get();
|
||
if (!terminator)
|
||
continue;
|
||
|
||
if (terminator->isBranch()) {
|
||
if (terminator->isCondBr()) { // 检查是否是条件分支 (kCondBr)
|
||
CondBrInst *branchInst = static_cast<CondBrInst *>(terminator);
|
||
SSAPValue condVal = GetValueState(branchInst->getOperand(0));
|
||
if (condVal.state == LatticeVal::Constant) {
|
||
bool condition_is_true = false;
|
||
if (condVal.constant_type == ValueType::Integer) {
|
||
condition_is_true = (std::get<int>(condVal.constantVal) != 0);
|
||
} else if (condVal.constant_type == ValueType::Float) {
|
||
condition_is_true = (std::get<float>(condVal.constantVal) != 0.0f);
|
||
}
|
||
|
||
if (condition_is_true) {
|
||
BasicBlock *trueBlock = branchInst->getThenBlock();
|
||
if (reachable.find(trueBlock) == reachable.end()) {
|
||
reachable.insert(trueBlock);
|
||
q.push(trueBlock);
|
||
}
|
||
} else {
|
||
BasicBlock *falseBlock = branchInst->getElseBlock();
|
||
if (reachable.find(falseBlock) == reachable.end()) {
|
||
reachable.insert(falseBlock);
|
||
q.push(falseBlock);
|
||
}
|
||
}
|
||
} else { // 条件是 Top 或 Bottom，两条路径都可达
|
||
for (auto succ : branchInst->getSuccessors()) {
|
||
if (reachable.find(succ) == reachable.end()) {
|
||
reachable.insert(succ);
|
||
q.push(succ);
|
||
}
|
||
}
|
||
}
|
||
} else { // 无条件分支 (kBr)
|
||
UncondBrInst *branchInst = static_cast<UncondBrInst *>(terminator);
|
||
BasicBlock *targetBlock = branchInst->getBlock();
|
||
if (reachable.find(targetBlock) == reachable.end()) {
|
||
reachable.insert(targetBlock);
|
||
q.push(targetBlock);
|
||
}
|
||
}
|
||
} else if (terminator->isReturn() || terminator->isUnreachable()) {
|
||
// ReturnInst 没有后继，不需要处理
|
||
// UnreachableInst 也没有后继，不需要处理
|
||
}
|
||
}
|
||
return reachable;
|
||
}
|
||
|
||
// 移除死块
|
||
void SCCPContext::RemoveDeadBlock(BasicBlock *bb, Function *func) {
|
||
if (DEBUG) {
|
||
std::cout << "Removing dead block: " << bb->getName() << std::endl;
|
||
}
|
||
// 首先更新其所有前驱的终结指令，移除指向死块的边
|
||
std::vector<BasicBlock *> preds_to_update;
|
||
for (auto &pred : bb->getPredecessors()) {
|
||
if (pred != nullptr) { // 检查是否为空指针
|
||
preds_to_update.push_back(pred);
|
||
}
|
||
}
|
||
for (BasicBlock *pred : preds_to_update) {
|
||
if (executableBlocks.count(pred)) {
|
||
UpdateTerminator(pred, bb);
|
||
}
|
||
}
|
||
|
||
// 移除其后继的 Phi 节点的入边
|
||
std::vector<BasicBlock *> succs_to_update;
|
||
for (auto succ : bb->getSuccessors()) {
|
||
succs_to_update.push_back(succ);
|
||
}
|
||
for (BasicBlock *succ : succs_to_update) {
|
||
RemovePhiIncoming(succ, bb);
|
||
succ->removePredecessor(bb);
|
||
}
|
||
|
||
func->removeBasicBlock(bb); // 从函数中移除基本块
|
||
}
|
||
|
||
// 简化分支（将条件分支替换为无条件分支）
|
||
void SCCPContext::SimplifyBranch(CondBrInst *brInst, bool condVal) {
|
||
BasicBlock *parentBB = brInst->getParent();
|
||
BasicBlock *trueBlock = brInst->getThenBlock();
|
||
BasicBlock *falseBlock = brInst->getElseBlock();
|
||
|
||
if (DEBUG) {
|
||
std::cout << "Simplifying branch in " << parentBB->getName() << ": cond is " << (condVal ? "true" : "false")
|
||
<< std::endl;
|
||
}
|
||
|
||
builder->setPosition(parentBB, parentBB->findInstIterator(brInst));
|
||
if (condVal) { // 条件为真，跳转到真分支
|
||
builder->createUncondBrInst(trueBlock); // 插入无条件分支 kBr
|
||
SysYIROptUtils::usedelete(brInst); // 移除旧的条件分支指令
|
||
parentBB->removeSuccessor(falseBlock);
|
||
falseBlock->removePredecessor(parentBB);
|
||
RemovePhiIncoming(falseBlock, parentBB);
|
||
} else { // 条件为假，跳转到假分支
|
||
builder->createUncondBrInst(falseBlock); // 插入无条件分支 kBr
|
||
SysYIROptUtils::usedelete(brInst); // 移除旧的条件分支指令
|
||
parentBB->removeSuccessor(trueBlock);
|
||
trueBlock->removePredecessor(parentBB);
|
||
RemovePhiIncoming(trueBlock, parentBB);
|
||
}
|
||
}
|
||
|
||
// 更新前驱块的终结指令（当一个后继块被移除时）
|
||
void SCCPContext::UpdateTerminator(BasicBlock *predBB, BasicBlock *removedSucc) {
|
||
Instruction *terminator = predBB->terminator()->get();
|
||
if (!terminator)
|
||
return;
|
||
|
||
if (terminator->isBranch()) {
|
||
if (terminator->isCondBr()) { // 如果是条件分支
|
||
CondBrInst *branchInst = static_cast<CondBrInst *>(terminator);
|
||
if (branchInst->getThenBlock() == removedSucc) {
|
||
if (DEBUG) {
|
||
std::cout << "Updating cond br in " << predBB->getName() << ": True block (" << removedSucc->getName()
|
||
<< ") removed. Converting to Br to " << branchInst->getElseBlock()->getName() << std::endl;
|
||
}
|
||
builder->setPosition(predBB, predBB->findInstIterator(branchInst));
|
||
builder->createUncondBrInst(branchInst->getElseBlock());
|
||
SysYIROptUtils::usedelete(branchInst);
|
||
predBB->removeSuccessor(removedSucc);
|
||
} else if (branchInst->getElseBlock() == removedSucc) {
|
||
if (DEBUG) {
|
||
std::cout << "Updating cond br in " << predBB->getName() << ": False block (" << removedSucc->getName()
|
||
<< ") removed. Converting to Br to " << branchInst->getThenBlock()->getName() << std::endl;
|
||
}
|
||
builder->setPosition(predBB, predBB->findInstIterator(branchInst));
|
||
builder->createUncondBrInst(branchInst->getThenBlock());
|
||
SysYIROptUtils::usedelete(branchInst);
|
||
predBB->removeSuccessor(removedSucc);
|
||
}
|
||
} else { // 无条件分支 (kBr)
|
||
UncondBrInst *branchInst = static_cast<UncondBrInst *>(terminator);
|
||
if (branchInst->getBlock() == removedSucc) {
|
||
if (DEBUG) {
|
||
std::cout << "Updating unconditional br in " << predBB->getName() << ": Target block ("
|
||
<< removedSucc->getName() << ") removed. Replacing with Unreachable." << std::endl;
|
||
}
|
||
SysYIROptUtils::usedelete(branchInst);
|
||
predBB->removeSuccessor(removedSucc);
|
||
builder->setPosition(predBB, predBB->end());
|
||
builder->createUnreachableInst();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 移除 Phi 节点的入边（当其前驱块被移除时）
|
||
void SCCPContext::RemovePhiIncoming(BasicBlock *phiParentBB, BasicBlock *removedPred) { // 修正 removedPred 类型
|
||
std::vector<Instruction *> insts_to_check;
|
||
for (auto &inst_ptr : phiParentBB->getInstructions()) {
|
||
insts_to_check.push_back(inst_ptr.get());
|
||
}
|
||
|
||
for (Instruction *inst : insts_to_check) {
|
||
if (auto phi = dynamic_cast<PhiInst *>(inst)) {
|
||
phi->removeIncomingBlock(removedPred);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 运行 SCCP 优化
|
||
void SCCPContext::run(Function *func, AnalysisManager &AM) {
|
||
bool changed_constant_propagation = PropagateConstants(func);
|
||
bool changed_control_flow = SimplifyControlFlow(func);
|
||
|
||
// 如果任何一个阶段修改了 IR，标记分析结果为失效
|
||
bool changed = changed_constant_propagation || changed_control_flow;
|
||
changed |= SysYIROptUtils::eliminateRedundantPhisInFunction(func);
|
||
}
|
||
|
||
// SCCP Pass methods
|
||
bool SCCP::runOnFunction(Function *F, AnalysisManager &AM) {
|
||
if (DEBUG) {
|
||
std::cout << "Running SCCP on function: " << F->getName() << std::endl;
|
||
}
|
||
|
||
SCCPContext context(builder);
|
||
|
||
// 获取别名分析结果
|
||
if (auto *aliasResult = AM.getAnalysisResult<AliasAnalysisResult, SysYAliasAnalysisPass>(F)) {
|
||
context.setAliasAnalysis(aliasResult);
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Using alias analysis results" << std::endl;
|
||
}
|
||
}
|
||
|
||
// 获取副作用分析结果（Module级别）
|
||
if (auto *sideEffectResult = AM.getAnalysisResult<SideEffectAnalysisResult, SysYSideEffectAnalysisPass>()) {
|
||
context.setSideEffectAnalysis(sideEffectResult);
|
||
if (DEBUG) {
|
||
std::cout << "SCCP: Using side effect analysis results" << std::endl;
|
||
}
|
||
}
|
||
|
||
context.run(F, AM);
|
||
return true;
|
||
}
|
||
|
||
void SCCP::getAnalysisUsage(std::set<void *> &analysisDependencies, std::set<void *> &analysisInvalidations) const {
|
||
// 声明依赖别名分析和副作用分析
|
||
analysisDependencies.insert(&SysYAliasAnalysisPass::ID);
|
||
analysisDependencies.insert(&SysYSideEffectAnalysisPass::ID);
|
||
|
||
// analysisInvalidations.insert(nullptr); // 表示使所有默认分析失效
|
||
analysisInvalidations.insert(&DominatorTreeAnalysisPass::ID); // 支配树可能受影响
|
||
analysisInvalidations.insert(&LivenessAnalysisPass::ID); // 活跃性分析很可能失效
|
||
}
|
||
|
||
} // namespace sysy
|