gh0s7/mysysy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[midend-Alias]针对sysy语言设计了保守和激进的别名优化策略，设计了通过接口设置选项，后续需要验证。保留了一些激进策略接口置空待后续增加。

Browse Source
This commit is contained in:
rain2133
2025-08-08 15:08:49 +08:00
parent a406e44df3
commit f17e44f8d4
2 changed files with 191 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
src/include/midend/Pass/Analysis/AliasAnalysis.h
View File

@@ -128,7 +128,7 @@ public:
* 打印别名分析结果 (调试用)
*/
void print() const;
void printStatics() const;
// ========== 内部方法 ==========
void addMemoryLocation(std::unique_ptr<MemoryLocation> location);
@@ -155,8 +155,9 @@ class SysYAliasAnalysisPass : public AnalysisPass {
public:
// 唯一的 Pass ID
static void *ID;
SysYAliasAnalysisPass() : AnalysisPass("SysYAliasAnalysis", Pass::Granularity::Function) {}
// 在这里开启激进分析策略
SysYAliasAnalysisPass() : AnalysisPass("SysYAliasAnalysis", Pass::Granularity::Function),
aggressiveParameterMode(false), parameterOptimizationEnabled(false) {}
// 实现 getPassID
void *getPassID() const override { return &ID; }
@@ -166,6 +167,25 @@ public:
// 获取分析结果
std::unique_ptr<AnalysisResultBase> getResult() override { return std::move(CurrentResult); }
// ========== 配置接口 ==========
/**
* 启用针对SysY评测的激进优化模式
* 在这种模式下，假设不同参数不会传入相同数组
*/
void enableSysYTestingMode() {
aggressiveParameterMode = true;
parameterOptimizationEnabled = true;
}
/**
* 使用保守的默认模式（适合通用场景）
*/
void useConservativeMode() {
aggressiveParameterMode = false;
parameterOptimizationEnabled = false;
}
private:
std::unique_ptr<AliasAnalysisResult> CurrentResult; // 当前函数的分析结果
@@ -198,12 +218,29 @@ private:
void optimizeParameterAnalysis(Function* F); // 优化参数分析
void optimizeArrayAccessAnalysis(Function* F); // 优化数组访问分析
// ========== 配置和策略控制 ==========
bool useAggressiveParameterAnalysis() const { return aggressiveParameterMode; }
bool enableParameterOptimization() const { return parameterOptimizationEnabled; }
void setAggressiveParameterMode(bool enable) { aggressiveParameterMode = enable; }
void setParameterOptimizationEnabled(bool enable) { parameterOptimizationEnabled = enable; }
// ========== 辅助优化方法 ==========
void optimizeConstantIndexAccesses(); // 优化常量索引访问
void optimizeSequentialAccesses(); // 优化顺序访问
// ========== 辅助方法 ==========
bool isConstantValue(Value* val); // 是否为常量
bool hasLoopVariableInIndices(const std::vector<Value*>& indices, Function* F);
int calculateConstantOffset(const std::vector<Value*>& indices);
void printStatistics() const; // 打印统计信息
private:
// ========== 配置选项 ==========
bool aggressiveParameterMode = false; // 激进的参数别名分析模式
bool parameterOptimizationEnabled = false; // 启用参数优化
};
} // namespace sysy

174
src/midend/Pass/Analysis/AliasAnalysis.cpp
View File

@@ -108,20 +108,20 @@ AliasAnalysisResult::Statistics AliasAnalysisResult::getStatistics() const {
return stats;
}
// void AliasAnalysisResult::print() const {
// std::cout << "=== Alias Analysis Results ===" << std::endl;
void AliasAnalysisResult::printStatics() const {
std::cout << "=== Alias Analysis Results ===" << std::endl;
// auto stats = getStatistics();
// std::cout << "Total queries: " << stats.totalQueries << std::endl;
// std::cout << "No alias: " << stats.noAlias << std::endl;
// std::cout << "Self alias: " << stats.selfAlias << std::endl;
// std::cout << "Possible alias: " << stats.possibleAlias << std::endl;
// std::cout << "Unknown alias: " << stats.unknownAlias << std::endl;
// std::cout << "Local arrays: " << stats.localArrays << std::endl;
// std::cout << "Function parameters: " << stats.functionParameters << std::endl;
// std::cout << "Global arrays: " << stats.globalArrays << std::endl;
// std::cout << "Constant accesses: " << stats.constantAccesses << std::endl;
// }
auto stats = getStatistics();
std::cout << "Total queries: " << stats.totalQueries << std::endl;
std::cout << "No alias: " << stats.noAlias << std::endl;
std::cout << "Self alias: " << stats.selfAlias << std::endl;
std::cout << "Possible alias: " << stats.possibleAlias << std::endl;
std::cout << "Unknown alias: " << stats.unknownAlias << std::endl;
std::cout << "Local arrays: " << stats.localArrays << std::endl;
std::cout << "Function parameters: " << stats.functionParameters << std::endl;
std::cout << "Global arrays: " << stats.globalArrays << std::endl;
std::cout << "Constant accesses: " << stats.constantAccesses << std::endl;
}
void AliasAnalysisResult::addMemoryLocation(std::unique_ptr<MemoryLocation> location) {
Value* ptr = location->accessPointer;
@@ -150,6 +150,7 @@ bool SysYAliasAnalysisPass::runOnFunction(Function *F, AnalysisManager &AM) {
if (DEBUG) {
CurrentResult->print();
CurrentResult->printStatics();
}
return false; // 分析遍不修改IR
@@ -360,31 +361,115 @@ AliasType SysYAliasAnalysisPass::compareLocalArrays(MemoryLocation* loc1, Memory
}
AliasType SysYAliasAnalysisPass::compareParameters(MemoryLocation* loc1, MemoryLocation* loc2) {
// 不同函数参数可能别名
return AliasType::POSSIBLE_ALIAS;
// SysY特化：可配置的数组参数别名策略
//
// SysY中数组参数的语法形式：
// void func(int a[], int b[]) - 一维数组参数
// void func(int a[][10], int b[]) - 多维数组参数
//
// 默认保守策略：不同数组参数可能别名（因为可能传入相同数组）
// func(arr, arr); // 传入同一个数组给两个参数
//
// 激进策略：假设不同数组参数不会传入相同数组（适用于评测环境）
// 在SysY评测中，这种情况很少出现
if (useAggressiveParameterAnalysis()) {
// 激进策略：不同数组参数假设不别名
return AliasType::NO_ALIAS;
} else {
// 保守策略：不同数组参数可能别名
return AliasType::POSSIBLE_ALIAS;
}
}
AliasType SysYAliasAnalysisPass::compareWithGlobal(MemoryLocation* loc1, MemoryLocation* loc2) {
// 涉及全局数组的访问，保守估计
// 涉及全局数组的访问，采用保守策略
// SysY中全局数组和其他内存位置的别名关系较复杂，保守处理
return AliasType::POSSIBLE_ALIAS;
}
AliasType SysYAliasAnalysisPass::compareMixedTypes(MemoryLocation* loc1, MemoryLocation* loc2) {
// 混合类型访问，保守估计
// 混合类型访问的别名分析
// 处理不同内存类型之间的别名关系
// SysY特化：局部数组与数组参数通常不别名
// 典型场景：
// void func(int p[]) { // p 是数组参数
// int local[10]; // local 是局部数组
// p[0] = local[0]; // 混合类型访问
// }
// 或多维数组：
// void func(int p[][10]) { // p 是多维数组参数
// int local[10]; // local 是局部数组
// p[i][0] = local[0]; // 混合类型访问
// }
// 局部数组与数组参数：在SysY中通常不别名
if ((loc1->isLocalArray && loc2->isFunctionParameter) ||
(loc1->isFunctionParameter && loc2->isLocalArray)) {
// 因为局部数组是栈上分配，而数组参数是传入的外部数组
return AliasType::NO_ALIAS;
}
// 如果是局部数组与全局数组或参数的混合访问，通常也不别名
if ((loc1->isLocalArray && loc2->isGlobalArray) ||
(loc1->isGlobalArray && loc2->isLocalArray) ||
(loc1->isFunctionParameter && loc2->isGlobalArray) ||
(loc1->isGlobalArray && loc2->isFunctionParameter)) {
// 局部数组与全局数组或参数：通常不别名
// 因为局部数组是栈上分配，而全局数组或参数是传入的外部数组
return AliasType::NO_ALIAS;
}
// 对于其他混合情况，保守估计
return AliasType::UNKNOWN_ALIAS;
}
void SysYAliasAnalysisPass::applySysYConstraints(Function* F) {
// 应用SysY语言特定的约束
// SysY没有指针运算，简化别名分析
// SysY语言特定的约束和优化
// 1. SysY没有指针运算，简化了别名分析
// 2. 数组传参时保持数组语义
// 3. 没有动态内存分配，所有数组要么是局部的要么是参数/全局
}
void SysYAliasAnalysisPass::optimizeParameterAnalysis(Function* F) {
// 优化参数别名分析
// 数组参数别名分析优化
// 为SysY评测环境提供可配置的优化策略
if (!enableParameterOptimization()) {
return; // 保持默认的保守策略
}
// 可选的参数优化：假设不同数组参数不会传入相同数组
// 典型的SysY函数调用：
// int arr1[10], arr2[20];
// func(arr1, arr2); // 传入不同数组
// 而不是：
// func(arr1, arr1); // 传入相同数组给两个参数
// 这在SysY评测中通常是安全的假设
auto& locationMap = CurrentResult->LocationMap;
for (auto it1 = locationMap.begin(); it1 != locationMap.end(); ++it1) {
for (auto it2 = std::next(it1); it2 != locationMap.end(); ++it2) {
MemoryLocation* loc1 = it1->second.get();
MemoryLocation* loc2 = it2->second.get();
// 如果两个都是数组参数且基指针不同，设为NO_ALIAS
if (loc1->isFunctionParameter && loc2->isFunctionParameter &&
loc1->basePointer != loc2->basePointer) {
CurrentResult->addAliasRelation(it1->first, it2->first, AliasType::NO_ALIAS);
}
}
}
}
void SysYAliasAnalysisPass::optimizeArrayAccessAnalysis(Function* F) {
// 优化数组访问别名分析
// 数组访问别名分析优化
// 基于SysY语言的特点进行简单优化
// 优化1：同一数组的不同常量索引访问确定无别名
optimizeConstantIndexAccesses();
// 优化2：识别简单的顺序访问模式
optimizeSequentialAccesses();
}
bool SysYAliasAnalysisPass::isConstantValue(Value* val) {
@@ -392,10 +477,11 @@ bool SysYAliasAnalysisPass::isConstantValue(Value* val) {
}
bool SysYAliasAnalysisPass::hasLoopVariableInIndices(const std::vector<Value*>& indices, Function* F) {
// 简化版本：检查索引是否包含循环变量
// 保守策略：所有非常量索引都视为可能的循环变量
// 这样可以避免复杂的循环分析依赖，保持分析的独立性
for (Value* index : indices) {
if (!isConstantValue(index)) {
return true; // 保守估计
return true; // 保守估计，确保正确性
}
}
return false;
@@ -421,4 +507,46 @@ void SysYAliasAnalysisPass::printStatistics() const {
}
}
void SysYAliasAnalysisPass::optimizeConstantIndexAccesses() {
// 优化常量索引访问的别名关系
// 对于相同基指针的访问，如果索引都是常量且不同，则确定无别名
auto& locationMap = CurrentResult->LocationMap;
std::vector<Value*> allPointers;
for (auto& pair : locationMap) {
allPointers.push_back(pair.first);
}
for (size_t i = 0; i < allPointers.size(); ++i) {
for (size_t j = i + 1; j < allPointers.size(); ++j) {
Value* ptr1 = allPointers[i];
Value* ptr2 = allPointers[j];
MemoryLocation* loc1 = locationMap[ptr1].get();
MemoryLocation* loc2 = locationMap[ptr2].get();
// 相同基指针且都有常量索引
if (loc1->basePointer == loc2->basePointer &&
loc1->hasConstantIndices && loc2->hasConstantIndices) {
// 比较常量偏移
if (loc1->constantOffset != loc2->constantOffset) {
// 不同的常量偏移，确定无别名
CurrentResult->addAliasRelation(ptr1, ptr2, AliasType::NO_ALIAS);
}
}
}
}
}
void SysYAliasAnalysisPass::optimizeSequentialAccesses() {
// 识别和优化顺序访问模式
// 这是一个简化的实现，主要用于识别数组的顺序遍历
// 在SysY中，大多数数组访问都是通过循环进行的
// 对于非常量索引的访问，我们采用保守策略，不进行过多优化
// 这样可以保持分析的简单性和正确性
// 未来如果需要更精确的分析，可以在这里添加更复杂的逻辑
}
} // namespace sysy