src/SysYIRCFGOpt.cpp

@@ -463,9 +463,9 @@ bool SysYCFGOpt::SysYAddReturn(Function *func, IRBuilder* pBuilder) {
         pBuilder->setPosition(block.get(), block->end());
         // TODO: 如果int float函数缺少返回值是否需要报错
         if (func->getReturnType()->isInt()) {
-          pBuilder->createReturnInst(ConstantValue::get(0));
+          pBuilder->createReturnInst(ConstantInteger::get(0));
         } else if (func->getReturnType()->isFloat()) {
-          pBuilder->createReturnInst(ConstantValue::get(0.0F));
+          pBuilder->createReturnInst(ConstantFloating::get(0.0F));
         } else {
           pBuilder->createReturnInst();
         }

src/include/SysYIRPass.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include "IR.h"
+
+namespace sysy {
+
+// 前置声明
+class FunctionPass;
+class ModulePass;
+class AnalysisPass;
+class PassManager;
+
+// 抽象基类 Pass
+class Pass {
+public:
+    enum PassKind {
+        PK_Function,
+        PK_Module,
+        PK_Analysis
+    };
+
+    Pass(PassKind kind, const std::string& name) : Kind(kind), Name(name) {}
+    virtual ~Pass() = default;
+
+    PassKind getPassKind() const { return Kind; }
+    const std::string& getPassName() const { return Name; }
+
+    // 每个Pass需要实现此方法来执行其逻辑
+    // 具体的run方法将根据Pass类型在FunctionPass和ModulePass中定义
+protected:
+    PassKind Kind;
+    std::string Name;
+};
+
+// 针对函数的优化遍
+class FunctionPass : public Pass {
+public:
+    FunctionPass(const std::string& name) : Pass(PK_Function, name) {}
+    // 真正的优化逻辑将在此方法中实现
+    virtual bool runOnFunction(Function& F) = 0;
+};
+
+// 针对模块的优化遍
+class ModulePass : public Pass {
+public:
+    ModulePass(const std::string& name) : Pass(PK_Module, name) {}
+    // 真正的优化逻辑将在此方法中实现
+    virtual bool runOnModule(Module& M) = 0;
+};
+
+// 分析遍
+class AnalysisPass : public Pass {
+public:
+    AnalysisPass(const std::string& name) : Pass(PK_Analysis, name) {}
+    // 分析遍通常需要一个模块或函数作为输入，并计算出分析结果
+    // 具体分析结果的存储和访问方式需要设计
+};
+
+} // namespace sysy

src/include/SysYIRPassManager.h

@@ -0,0 +1,58 @@
+// PassManager.h
+#pragma once
+
+#include <vector>
+#include <memory>
+#include <typeindex> // For std::type_index
+#include <unordered_map>
+#include "SysYIRPass.h"
+#include "IR.h" // 假设你的IR.h定义了Module, Function等
+
+namespace sysy {
+
+class PassManager {
+public:
+	PassManager() = default;
+
+	// 添加一个FunctionPass
+	void addPass(std::unique_ptr<FunctionPass> pass) {
+		functionPasses.push_back(std::move(pass));
+	}
+
+	// 添加一个ModulePass
+	void addPass(std::unique_ptr<ModulePass> pass) {
+		modulePasses.push_back(std::move(pass));
+	}
+
+	// 添加一个AnalysisPass
+	template<typename T, typename... Args>
+	T* addAnalysisPass(Args&&... args) {
+		static_assert(std::is_base_of<AnalysisPass, T>::value, "T must derive from AnalysisPass");
+		auto analysis = std::make_unique<T>(std::forward<Args>(args)...);
+		T* rawPtr = analysis.get();
+		analysisPasses[std::type_index(typeid(T))] = std::move(analysis);
+		return rawPtr;
+	}
+
+	// 获取分析结果（用于其他Pass访问）
+	template<typename T>
+	T* getAnalysis() {
+		static_assert(std::is_base_of<AnalysisPass, T>::value, "T must derive from AnalysisPass");
+		auto it = analysisPasses.find(std::type_index(typeid(T)));
+		if (it != analysisPasses.end()) {
+			return static_cast<T*>(it->second.get());
+		}
+		return nullptr; // 或者抛出异常
+	}
+
+	// 运行所有注册的遍
+	void run(Module& M);
+
+private:
+	std::vector<std::unique_ptr<FunctionPass>> functionPasses;
+	std::vector<std::unique_ptr<ModulePass>> modulePasses;
+	std::unordered_map<std::type_index, std::unique_ptr<AnalysisPass>> analysisPasses;
+	// 未来可以添加AnalysisPass的缓存机制
+};
+
+} // namespace sysy