[midend-LoopAnalysis]移除基本循环特征分析中的向量化并行化内容，增加循环向量化并行化特征分析遍，TODO：构建循环优化遍验证分析遍正确性

src/include/midend/Pass/Analysis/Loop.h

@@ -1,21 +1,23 @@
 #pragma once
 
-#include "Dom.h"  // 包含 DominatorTreeAnalysisPass 的依赖
-#include "IR.h"   // 包含 IR 定义
-#include "Pass.h" // 包含 Pass 框架
+#include "Dom.h"
+#include "IR.h"
+#include "Pass.h"
 #include <algorithm>
 #include <functional>
 #include <map>
 #include <memory>
 #include <optional>
-#include <queue> // 用于循环体块的逆向遍历
+#include <queue>
 #include <set>
 #include <vector>
 
 namespace sysy {
 
-// 前向声明，防止循环引用
+// 前向声明
 class LoopAnalysisResult;
+class AliasAnalysisResult;
+class SideEffectAnalysisResult;
 
 /**
  * @brief 表示一个识别出的循环。
@@ -142,6 +144,24 @@ public:
     return false;
   }
 
+  /**
+   * 检查循环是否可能有副作用（基于副作用分析结果）
+   * 使用场景: 循环优化决策、并行化分析
+   */
+  bool mayHaveSideEffects(SideEffectAnalysisResult* sideEffectAnalysis) const;
+
+  /**
+   * 检查循环是否访问全局内存（基于别名分析结果）
+   * 使用场景: 并行化分析、缓存优化
+   */
+  bool accessesGlobalMemory(AliasAnalysisResult* aliasAnalysis) const;
+
+  /**
+   * 检查循环是否有可能的内存别名冲突
+   * 使用场景: 向量化分析、并行化决策
+   */
+  bool hasMemoryAliasConflicts(AliasAnalysisResult* aliasAnalysis) const;
+
   /**
    * 估算循环的"热度" (基于嵌套深度和大小)
    * 使用场景: 优化优先级、资源分配
@@ -191,14 +211,14 @@ public:
   };
 
 private:
-  // ========== 高频查询缓存 (必须缓存) ==========
+  // ========== 高频查询缓存 ==========
   mutable std::optional<std::vector<Loop*>> cachedInnermostLoops;
   mutable std::optional<std::vector<Loop*>> cachedOutermostLoops;
   mutable std::optional<int> cachedMaxDepth;
   mutable std::optional<size_t> cachedLoopCount;
   mutable std::map<int, std::vector<Loop*>> cachedLoopsByDepth;
   
-  // ========== 中频查询缓存 (选择性缓存) ==========
+  // ========== 中频查询缓存 ==========
   mutable std::map<BasicBlock*, Loop*> cachedInnermostContainingLoop;
   mutable std::map<Loop*, std::set<Loop*>> cachedAllNestedLoops; // 递归嵌套
   mutable std::map<BasicBlock*, std::vector<Loop*>> cachedAllContainingLoops;
@@ -264,7 +284,7 @@ private:
   }
 
 public:
-  // ========== 基础接口 (保持向后兼容，但增加缓存失效) ==========
+  // ========== 基础接口 ==========
 
   // 添加一个识别出的循环到结果中
   void addLoop(std::unique_ptr<Loop> loop) {
@@ -276,7 +296,7 @@ public:
   // 获取所有识别出的循环（unique_ptr 管理内存）
   const std::vector<std::unique_ptr<Loop>> &getAllLoops() const { return AllLoops; }
 
-  // ========== 高频查询接口 (缓存优化) ==========
+  // ========== 高频查询接口 ==========
   
   /**
    * 获取所有最内层循环 - 循环优化的主要目标
@@ -366,7 +386,7 @@ public:
   // 检查函数是否包含循环
   bool hasLoops() const { return !AllLoops.empty(); }
 
-  // ========== 中频查询接口 (选择性缓存) ==========
+  // ========== 中频查询接口 ==========
   
   /**
    * 获取包含指定基本块的最内层循环
@@ -429,11 +449,61 @@ public:
     return cachedAllNestedLoops[loop];
   }
 
-  // ========== 低频查询接口 (按需计算，不缓存) ==========
+  // ========== 利用别名和副作用分析的查询接口 ==========
+  
+  /**
+   * 获取所有纯循环（无副作用的循环）
+   * 并行化、循环优化
+   */
+  std::vector<Loop*> getPureLoops(SideEffectAnalysisResult* sideEffectAnalysis) const {
+    std::vector<Loop*> result;
+    if (!sideEffectAnalysis) return result;
+    
+    for (const auto& loop : AllLoops) {
+      if (!loop->mayHaveSideEffects(sideEffectAnalysis)) {
+        result.push_back(loop.get());
+      }
+    }
+    return result;
+  }
+  
+  /**
+   * 获取所有只访问局部内存的循环
+   * 缓存优化、局部性分析
+   */
+  std::vector<Loop*> getLocalMemoryLoops(AliasAnalysisResult* aliasAnalysis) const {
+    std::vector<Loop*> result;
+    if (!aliasAnalysis) return result;
+    
+    for (const auto& loop : AllLoops) {
+      if (!loop->accessesGlobalMemory(aliasAnalysis)) {
+        result.push_back(loop.get());
+      }
+    }
+    return result;
+  }
+  
+  /**
+   * 获取所有无内存别名冲突的循环
+   * 向量化、并行化
+   */
+  std::vector<Loop*> getNoAliasConflictLoops(AliasAnalysisResult* aliasAnalysis) const {
+    std::vector<Loop*> result;
+    if (!aliasAnalysis) return result;
+    
+    for (const auto& loop : AllLoops) {
+      if (!loop->hasMemoryAliasConflicts(aliasAnalysis)) {
+        result.push_back(loop.get());
+      }
+    }
+    return result;
+  }
+
+  // ========== 低频查询接口(不缓存) ==========
   
   /**
    * 检查两个循环是否有嵌套关系
-   * 使用场景: 循环间依赖分析
+   * 循环间依赖分析
    */
   bool isNestedLoop(Loop* inner, Loop* outer) const {
     if (inner == outer) return false;
@@ -448,7 +518,7 @@ public:
   
   /**
    * 获取两个循环的最近公共祖先循环
-   * 使用场景: 循环融合分析、优化范围确定
+   * 循环融合分析、优化范围确定
    */
   Loop* getLowestCommonAncestor(Loop* loop1, Loop* loop2) const {
     if (!loop1 || !loop2) return nullptr;
@@ -488,14 +558,14 @@ public:
   // ========== 缓存管理接口 ==========
   
   /**
-   * 手动失效缓存 (当IR结构改变时调用)
+   * 手动失效缓存 (可删除)
    */
   void invalidateQueryCache() const {
     invalidateCache();
   }
   
   /**
-   * 获取缓存统计信息 (用于性能调试)
+   * 获取缓存统计信息
    */
   CacheStats getCacheStats() const {
     CacheStats stats = {};
@@ -510,9 +580,6 @@ public:
     return stats;
   }
 
-  // --- 保留的内部接口 ---
-  // 注意：由于使用了缓存机制，不再需要手动维护最外层和最内层循环列表
-
   // 打印分析结果
   void print() const;
   void printBBSet(const std::string &prefix, const std::set<BasicBlock *> &s) const;
@@ -522,7 +589,6 @@ private:
   Function *AssociatedFunction;                // 结果关联的函数
   std::vector<std::unique_ptr<Loop>> AllLoops; // 所有识别出的循环
   std::map<BasicBlock *, Loop *> LoopMap;      // 循环头到 Loop* 的映射，方便查找
-  // 注意: 最外层和最内层循环列表已移除，现在通过缓存机制动态计算
 };
 
 /**