可以处理生成加法的IR

src/ir/BasicBlock.cpp

@@ -1,4 +1 @@
-// IR 基本块：
-// - 保存指令序列
-// - 维护或可计算前驱/后继关系，用于 CFG 分析与优化
-
+#include "ir/IR.h"

src/ir/Context.cpp

@@ -1,4 +1 @@
-// IR 上下文：
-// - 管理类型与常量的创建/复用
-// - 保存字符串常量、符号等公共资源（按需要扩展）
-
+#include "ir/IR.h"

src/ir/Function.cpp

@@ -1,4 +1,15 @@
-// IR Function：
-// - 保存参数列表、基本块列表
-// - 记录函数属性/元信息（按需要扩展）
+#include "ir/IR.h"
 
+namespace ir {
+
+Function::Function(std::string name)
+    : Value(Type::Int32(), std::move(name)),
+      entry_(std::make_unique<BasicBlock>("entry")) {}
+
+void Function::EnsureEntry() {
+  if (!entry_) {
+    entry_ = std::make_unique<BasicBlock>("entry");
+  }
+}
+
+}  // namespace ir

src/ir/IR.h

@@ -0,0 +1,144 @@
+// 极简 IR 定义：足以表示 int 返回 a+b。
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace ir {
+
+class Type {
+ public:
+  enum class Kind { Void, Int32 };
+  explicit Type(Kind k) : kind_(k) {}
+  Kind kind() const { return kind_; }
+  static std::shared_ptr<Type> Void();
+  static std::shared_ptr<Type> Int32();
+
+ private:
+  Kind kind_;
+};
+
+class Value {
+ public:
+  Value(std::shared_ptr<Type> ty, std::string name)
+      : type_(std::move(ty)), name_(std::move(name)) {}
+  virtual ~Value() = default;
+  const std::shared_ptr<Type>& type() const { return type_; }
+  const std::string& name() const { return name_; }
+  void set_name(std::string n) { name_ = std::move(n); }
+
+ protected:
+  std::shared_ptr<Type> type_;
+  std::string name_;
+};
+
+class ConstantInt : public Value {
+ public:
+  explicit ConstantInt(int v);
+  int value() const { return value_; }
+
+ private:
+  int value_{};
+};
+
+enum class Opcode { Add, Sub, Mul, Div, Ret };
+
+class Instruction : public Value {
+ public:
+  Instruction(Opcode op, std::shared_ptr<Type> ty, std::string name = "")
+      : Value(std::move(ty), std::move(name)), opcode_(op) {}
+  Opcode opcode() const { return opcode_; }
+
+ private:
+  Opcode opcode_;
+};
+
+class BinaryInst : public Instruction {
+ public:
+  BinaryInst(Opcode op, std::shared_ptr<Type> ty, Value* lhs, Value* rhs,
+             std::string name);
+  Value* lhs() const { return lhs_; }
+  Value* rhs() const { return rhs_; }
+
+ private:
+  Value* lhs_;
+  Value* rhs_;
+};
+
+class ReturnInst : public Instruction {
+ public:
+  explicit ReturnInst(Value* val);
+  Value* value() const { return value_; }
+
+ private:
+  Value* value_;
+};
+
+class BasicBlock {
+ public:
+  explicit BasicBlock(std::string name) : name_(std::move(name)) {}
+  const std::string& name() const { return name_; }
+  const std::vector<std::unique_ptr<Instruction>>& instructions() const {
+    return instructions_;
+  }
+  template <typename T, typename... Args>
+  T* Append(Args&&... args) {
+    auto inst = std::make_unique<T>(std::forward<Args>(args)...);
+    auto* ptr = inst.get();
+    instructions_.push_back(std::move(inst));
+    return ptr;
+  }
+
+ private:
+  std::string name_;
+  std::vector<std::unique_ptr<Instruction>> instructions_;
+};
+
+class Function : public Value {
+ public:
+  explicit Function(std::string name);
+  BasicBlock* entry() { return entry_.get(); }
+  const BasicBlock* entry() const { return entry_.get(); }
+  void EnsureEntry();
+
+ private:
+  std::unique_ptr<BasicBlock> entry_;
+};
+
+class Module {
+ public:
+  Function* CreateFunction(const std::string& name);
+  const std::vector<std::unique_ptr<Function>>& functions() const {
+    return functions_;
+  }
+
+ private:
+  std::vector<std::unique_ptr<Function>> functions_;
+};
+
+class IRBuilder {
+ public:
+  explicit IRBuilder(BasicBlock* bb) : insertBlock_(bb) {}
+  void SetInsertPoint(BasicBlock* bb) { insertBlock_ = bb; }
+  BasicBlock* GetInsertBlock() const { return insertBlock_; }
+
+  ConstantInt* CreateConstInt(int v);
+  BinaryInst* CreateBinary(Opcode op, Value* lhs, Value* rhs,
+                           const std::string& name);
+  BinaryInst* CreateAdd(Value* lhs, Value* rhs, const std::string& name) {
+    return CreateBinary(Opcode::Add, lhs, rhs, name);
+  }
+  ReturnInst* CreateRet(Value* v);
+
+ private:
+  BasicBlock* insertBlock_;
+};
+
+class IRPrinter {
+ public:
+  void Print(const Module& module);
+};
+
+}  // namespace ir

src/ir/IRBuilder.cpp

@@ -1,4 +1,19 @@
-// IR 构建工具：
-// - 管理插入点（当前基本块/位置）
-// - 提供创建各类指令的便捷接口，降低 IRGen 复杂度
+#include "ir/IR.h"
 
+namespace ir {
+
+ConstantInt* IRBuilder::CreateConstInt(int v) {
+  // 常量不需要挂在基本块里，直接返回局部对象指针。
+  return new ConstantInt(v);
+}
+
+BinaryInst* IRBuilder::CreateBinary(Opcode op, Value* lhs, Value* rhs,
+                                    const std::string& name) {
+  return insertBlock_->Append<BinaryInst>(op, Type::Int32(), lhs, rhs, name);
+}
+
+ReturnInst* IRBuilder::CreateRet(Value* v) {
+  return insertBlock_->Append<ReturnInst>(v);
+}
+
+}  // namespace ir

src/ir/IRPrinter.cpp

@@ -1,4 +1,55 @@
-// IR 文本输出：
-// - 将 IR 打印为 .ll 风格的文本
-// - 支撑调试与测试对比（diff）
+#include "ir/IR.h"
 
+#include <iostream>
+
+namespace ir {
+
+static const char* OpcodeToString(Opcode op) {
+  switch (op) {
+    case Opcode::Add:
+      return "add";
+    case Opcode::Sub:
+      return "sub";
+    case Opcode::Mul:
+      return "mul";
+    case Opcode::Div:
+      return "div";
+    case Opcode::Ret:
+      return "ret";
+  }
+  return "?";
+}
+
+void IRPrinter::Print(const Module& module) {
+  for (const auto& func : module.functions()) {
+    std::cout << "define i32 @" << func->name() << "() {\n";
+    const auto* bb = func->entry();
+    if (!bb) {
+      std::cout << "}\n";
+      continue;
+    }
+    for (const auto& instPtr : bb->instructions()) {
+      const auto* inst = instPtr.get();
+      switch (inst->opcode()) {
+        case Opcode::Add:
+        case Opcode::Sub:
+        case Opcode::Mul:
+        case Opcode::Div: {
+          auto* bin = static_cast<const BinaryInst*>(inst);
+          std::cout << "  " << bin->name() << " = " << OpcodeToString(bin->opcode())
+                    << " " << bin->lhs()->name() << ", " << bin->rhs()->name()
+                    << "\n";
+          break;
+        }
+        case Opcode::Ret: {
+          auto* ret = static_cast<const ReturnInst*>(inst);
+          std::cout << "  ret " << ret->value()->name() << "\n";
+          break;
+        }
+      }
+    }
+    std::cout << "}\n";
+  }
+}
+
+}  // namespace ir

src/ir/Instruction.cpp

@@ -1,4 +1,12 @@
-// IR 指令体系：
-// - 二元运算/比较、load/store、call、br/condbr、ret、phi、alloca 等
-// - 指令操作数与结果类型管理，支持打印与优化
+#include "ir/IR.h"
 
+namespace ir {
+
+BinaryInst::BinaryInst(Opcode op, std::shared_ptr<Type> ty, Value* lhs,
+                       Value* rhs, std::string name)
+    : Instruction(op, std::move(ty), std::move(name)), lhs_(lhs), rhs_(rhs) {}
+
+ReturnInst::ReturnInst(Value* val)
+    : Instruction(Opcode::Ret, Type::Void(), ""), value_(val) {}
+
+}  // namespace ir

src/ir/Module.cpp

@@ -1,4 +1,10 @@
-// IR Module：
-// - 保存全局变量与函数列表
-// - 维护与目标相关的模块级信息（如需要）与符号表
+#include "ir/IR.h"
 
+namespace ir {
+
+Function* Module::CreateFunction(const std::string& name) {
+  functions_.push_back(std::make_unique<Function>(name));
+  return functions_.back().get();
+}
+
+}  // namespace ir

src/ir/Type.cpp

@@ -1,4 +1,16 @@
-// IR 类型系统：
-// - i32/f32/void、指针、数组、函数类型等
-// - 按 SysY 支持范围裁剪并逐步补齐
+// 极简类型系统：仅支持 void 与 i32。
+#include "ir/IR.h"
 
+namespace ir {
+
+std::shared_ptr<Type> Type::Void() {
+  static auto ty = std::make_shared<Type>(Kind::Void);
+  return ty;
+}
+
+std::shared_ptr<Type> Type::Int32() {
+  static auto ty = std::make_shared<Type>(Kind::Int32);
+  return ty;
+}
+
+}  // namespace ir

src/ir/Value.cpp

@@ -1,4 +1,9 @@
-// SSA 值体系抽象：
-// - 常量、参数、指令结果等统一为 Value
-// - 提供类型信息与使用/被使用关系（按需要实现）
+#include "ir/IR.h"
 
+namespace ir {
+
+ConstantInt::ConstantInt(int v) : Value(Type::Int32(), ""), value_(v) {
+  set_name(std::to_string(v));
+}
+
+}  // namespace ir

src/ir/analysis/DominatorTree.cpp

@@ -1,4 +1 @@
-// 支配树分析：
-// - 构建/查询 Dominator Tree 及相关关系
-// - 为 mem2reg、CFG 优化与循环分析提供基础能力
-
+#include <vector>

src/ir/analysis/LoopInfo.cpp

@@ -1,4 +1 @@
-// 循环分析：
-// - 识别循环结构与层级关系
-// - 为后续优化（可选）提供循环信息
-
+#include <vector>

src/ir/passes/CFGSimplify.cpp

@@ -1,4 +1 @@
-// CFG 简化：
-// - 删除不可达块、合并空块、简化分支等
-// - 改善 IR 结构，便于后续优化与后端生成
-
+#include <vector>

src/ir/passes/ConstFold.cpp

@@ -1,4 +1 @@
-// IR 常量折叠：
-// - 折叠可判定的常量表达式
-// - 简化常量控制流分支（按实现范围裁剪）
-
+#include <vector>

src/ir/passes/DCE.cpp

@@ -1,4 +1 @@
-// 死代码删除（DCE）：
-// - 删除无用指令与无用基本块
-// - 通常与 CFG 简化配合使用
-
+#include <vector>

src/ir/passes/Mem2Reg.cpp

@@ -1,4 +1 @@
-// Mem2Reg（SSA 构造）：
-// - 将局部变量的 alloca/load/store 提升为 SSA 形式
-// - 插入 PHI 并重写使用，依赖支配树等分析
-
+#include <vector>

src/ir/passes/PassManager.cpp

@@ -1,4 +1 @@
-// IR Pass 管理：
-// - 按优化级别组织优化 pipeline
-// - 统一运行 pass、统计与调试输出（按需要扩展）
-
+#include <vector>