IR设计

src/ir/BasicBlock.cpp

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

src/ir/Context.cpp

@@ -1,4 +1,45 @@
 // IR 上下文：
 // - 管理类型与常量的创建/复用
 // - 保存字符串常量、符号等公共资源（按需要扩展）
+#include "ir/IR.h"
 
+#include <sstream>
+
+namespace ir {
+
+Context& DefaultContext() {
+  static Context ctx;
+  return ctx;
+}
+
+Context::~Context() = default;
+
+const std::shared_ptr<Type>& Context::Void() {
+  if (!void_) {
+    void_ = std::make_shared<Type>(Type::Kind::Void);
+  }
+  return void_;
+}
+
+const std::shared_ptr<Type>& Context::Int32() {
+  if (!int32_) {
+    int32_ = std::make_shared<Type>(Type::Kind::Int32);
+  }
+  return int32_;
+}
+
+ConstantInt* Context::GetConstInt(int v) {
+  auto it = const_ints_.find(v);
+  if (it != const_ints_.end()) return it->second.get();
+  auto inserted =
+      const_ints_.emplace(v, std::make_unique<ConstantInt>(v)).first;
+  return inserted->second.get();
+}
+
+std::string Context::NextTemp() {
+  std::ostringstream oss;
+  oss << "%t" << temp_index_++;
+  return oss.str();
+}
+
+}  // namespace ir

src/ir/Function.cpp

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

src/ir/IR.h

@@ -0,0 +1,172 @@
+// 极简 IR 定义：当前只支撑 i32 和加法，演示用。
+// 可在此基础上扩展更多类型/指令
+#pragma once
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace ir {
+
+class Type;
+class ConstantInt;
+
+// IR 上下文：集中管理类型、常量等共享资源，便于复用与扩展。
+class Context {
+ public:
+  ~Context();
+  const std::shared_ptr<Type>& Void();
+  const std::shared_ptr<Type>& Int32();
+  // 去重创建 i32 常量。
+  ConstantInt* GetConstInt(int v);
+  // 生成临时名称，如 %t0、%t1 ...
+  std::string NextTemp();
+
+ private:
+  std::shared_ptr<Type> void_;
+  std::shared_ptr<Type> int32_;
+  std::unordered_map<int, std::unique_ptr<ConstantInt>> const_ints_;
+  int temp_index_ = 0;
+};
+
+Context& DefaultContext();
+
+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, 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:
+  // 允许显式指定返回类型，便于后续扩展多种函数签名。
+  Function(std::string name, std::shared_ptr<Type> ret_type);
+  BasicBlock* entry() { return entry_.get(); }
+  const BasicBlock* entry() const { return entry_.get(); }
+
+ private:
+  std::unique_ptr<BasicBlock> entry_;
+};
+
+class Module {
+ public:
+  // 创建函数时显式传入返回类型，便于在 IRGen 中根据 AST 选择类型。
+  Function* CreateFunction(const std::string& name,
+                           std::shared_ptr<Type> ret_type);
+  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

@@ -2,3 +2,29 @@
 // - 管理插入点（当前基本块/位置）
 // - 提供创建各类指令的便捷接口，降低 IRGen 复杂度
 
+#include "ir/IR.h"
+#include <stdexcept>
+
+namespace ir {
+
+ConstantInt* IRBuilder::CreateConstInt(int v) {
+  // 常量不需要挂在基本块里，由 Context 负责去重与生命周期。
+  return DefaultContext().GetConstInt(v);
+}
+
+BinaryInst* IRBuilder::CreateBinary(Opcode op, Value* lhs, Value* rhs,
+                                    const std::string& name) {
+  if (!insertBlock_) {
+    throw std::runtime_error("IRBuilder 未设置插入点");
+  }
+  return insertBlock_->Append<BinaryInst>(op, Type::Int32(), lhs, rhs, name);
+}
+
+ReturnInst* IRBuilder::CreateRet(Value* v) {
+  if (!insertBlock_) {
+    throw std::runtime_error("IRBuilder 未设置插入点");
+  }
+  return insertBlock_->Append<ReturnInst>(v);
+}
+
+}  // namespace ir

src/ir/IRPrinter.cpp

@@ -2,3 +2,68 @@
 // - 将 IR 打印为 .ll 风格的文本
 // - 支撑调试与测试对比（diff）
 
+#include "ir/IR.h"
+
+#include <iostream>
+#include <stdexcept>
+
+namespace ir {
+
+static const char* TypeToString(const Type& ty) {
+  switch (ty.kind()) {
+    case Type::Kind::Void:
+      return "void";
+    case Type::Kind::Int32:
+      return "i32";
+  }
+  throw std::runtime_error("未知类型");
+}
+
+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::Ret:
+      return "ret";
+  }
+  return "?";
+}
+
+void IRPrinter::Print(const Module& module) {
+  for (const auto& func : module.functions()) {
+    std::cout << "define " << TypeToString(*func->type()) << " @"
+              << 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: {
+          auto* bin = static_cast<const BinaryInst*>(inst);
+          std::cout << "  " << bin->name() << " = " << OpcodeToString(bin->opcode())
+                    << " " << TypeToString(*bin->lhs()->type()) << " "
+                    << bin->lhs()->name() << ", " << bin->rhs()->name() << "\n";
+          break;
+        }
+        case Opcode::Ret: {
+          auto* ret = static_cast<const ReturnInst*>(inst);
+          std::cout << "  ret " << TypeToString(*ret->value()->type()) << " "
+                    << ret->value()->name() << "\n";
+          break;
+        }
+      }
+    }
+    std::cout << "}\n";
+  }
+}
+
+}  // namespace ir

src/ir/Instruction.cpp

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

src/ir/Type.cpp

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

src/ir/Value.cpp

@@ -1,4 +1,12 @@
 // 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