[midend-Loop]循环分析构建，增加很多统计方法和循环信息方法

src/include/midend/IR.h

@@ -1375,6 +1375,17 @@ protected:
     auto is_same_ptr = [blockToRemove](const std::unique_ptr<BasicBlock> &ptr) { return ptr.get() == blockToRemove; };
     blocks.remove_if(is_same_ptr);
   }
+  BasicBlock* addBasicBlock(const std::string &name, BasicBlock *before) {
+    // 在指定的基本块之前添加一个新的基本块
+    auto it = std::find_if(blocks.begin(), blocks.end(),
+                           [before](const std::unique_ptr<BasicBlock> &ptr) { return ptr.get() == before; });
+    if (it != blocks.end()) {
+      blocks.emplace(it, new BasicBlock(this, name));
+      return it->get();  // 返回新添加的基本块指针
+    }
+    assert(false && "BasicBlock to insert before not found!"); 
+    return nullptr;  // 如果没有找到指定的基本块，则返回nullptr
+  }  ///< 添加一个新的基本块到某个基本块之前
   BasicBlock* addBasicBlock(const std::string &name = "") {
     blocks.emplace_back(new BasicBlock(this, name));
     return blocks.back().get();

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

@@ -19,13 +19,18 @@ class LoopAnalysisResult;
  * @brief 表示一个识别出的循环。
  */
 class Loop {
+private:
+  static int NextLoopID; // 静态变量用于分配唯一ID
+  int LoopID;
 public:
   // 构造函数：指定循环头
-  Loop(BasicBlock *header) : Header(header) {}
+  Loop(BasicBlock *header) : Header(header), LoopID(NextLoopID++) {}
 
   // 获取循环头
   BasicBlock *getHeader() const { return Header; }
 
+  // 获取循环的名称 （基于ID）
+  std::string getName() const { return "loop_" + std::to_string(LoopID); }
   // 获取循环体包含的所有基本块
   const std::set<BasicBlock *> &getBlocks() const { return LoopBlocks; }
 
@@ -50,8 +55,42 @@ public:
   // 判断当前循环是否是最内层循环 (没有嵌套子循环)
   bool isInnermost() const { return NestedLoops.empty(); }
 
-  // 判断当前循环是否是最外层循环 (没有父循环)
-  bool isOutermost() const { return ParentLoop == nullptr; }
+  // 获取循环的深度（从最外层开始计算）
+  int getLoopDepth() const { return Level + 1; }
+
+  // 获取循环体的大小（基本块数量）
+  size_t getLoopSize() const { return LoopBlocks.size(); }
+
+  // 检查循环是否有唯一的外部前驱（即是否有前置块）
+  bool hasUniquePreHeader() const { return PreHeader != nullptr; }
+
+  // 检查循环是否是最外层循环（没有父循环）
+  bool isOutermost() const { return getParentLoop() == nullptr; }
+
+  // 获取循环的所有出口（从循环内到循环外的基本块）
+  std::vector<BasicBlock*> getExitingBlocks() const {
+    std::vector<BasicBlock*> exitingBlocks;
+    for (BasicBlock* bb : LoopBlocks) {
+      for (BasicBlock* succ : bb->getSuccessors()) {
+        if (!contains(succ)) {
+          exitingBlocks.push_back(bb);
+          break; // 每个基本块只添加一次
+        }
+      }
+    }
+    return exitingBlocks;
+  }
+
+  // 判断循环是否是简单循环（只有一个回边）
+  bool isSimpleLoop() const {
+    int backEdgeCount = 0;
+    for (BasicBlock* pred : Header->getPredecessors()) {
+      if (contains(pred)) {
+        backEdgeCount++;
+      }
+    }
+    return backEdgeCount == 1;
+  }
 
   // --- 供 LoopAnalysisPass 内部调用的方法，用于构建 Loop 对象 ---
   void addBlock(BasicBlock *BB) { LoopBlocks.insert(BB); }
@@ -93,9 +132,36 @@ public:
   // 获取所有最外层循环
   const std::vector<Loop *> &getOutermostLoops() const { return OutermostLoops; }
 
-  // 获取所有最内层循环
   const std::vector<Loop *> &getInnermostLoops() const { return InnermostLoops; }
 
+  // 获取循环总数
+  size_t getLoopCount() const { return AllLoops.size(); }
+
+  // 获取最大循环嵌套深度
+  int getMaxLoopDepth() const {
+    int maxDepth = 0;
+    for (const auto& loop : AllLoops) {
+      if (loop->getLoopDepth() > maxDepth) {
+        maxDepth = loop->getLoopDepth();
+      }
+    }
+    return maxDepth;
+  }
+
+  // 获取指定深度的循环数量
+  size_t getLoopCountAtDepth(int depth) const {
+    size_t count = 0;
+    for (const auto& loop : AllLoops) {
+      if (loop->getLoopDepth() == depth) {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  // 检查函数是否包含循环
+  bool hasLoops() const { return !AllLoops.empty(); }
+
   // 通过循环头获取 Loop 对象
   Loop *getLoopForHeader(BasicBlock *header) const {
     auto it = LoopMap.find(header);
@@ -122,6 +188,11 @@ public:
   void clearOutermostLoops() { OutermostLoops.clear(); }
   void clearInnermostLoops() { InnermostLoops.clear(); }
 
+  // 打印分析结果
+  void print() const;
+  void printBBSet(const std::string &prefix, const std::set<BasicBlock *> &s) const;
+  void printLoopVector(const std::string &prefix, const std::vector<Loop *> &loops) const;
+
 private:
   Function *AssociatedFunction;                // 结果关联的函数
   std::vector<std::unique_ptr<Loop>> AllLoops; // 所有识别出的循环