NUDT-compiler
/
nudt-compiler-cpp
5
0
Fork 16
Code Issues Pull Requests Packages Projects Releases Wiki Activity

IR

Browse Source
the-little-apprentice 1 week ago
parent 29d1315410
commit b1c34228b1
3 changed files with 1021 additions and 239 deletions
Show Stats Download Patch File Download Diff File

846
include/ir/IR.h
Unescape View File

@ -1,318 +1,686 @@
// 当前只支撑 i32、i32*、void 以及最小的内存/算术指令，演示用。
//
// 当前已经实现：
// 1. 基础类型系统：void / i32 / i32*
// 2. Value 体系：Value / ConstantValue / ConstantInt / Function / BasicBlock / User / GlobalValue / Instruction
// 3. 最小指令集：Add / Alloca / Load / Store / Ret
// 4. BasicBlock / Function / Module 三层组织结构
// 5. IRBuilder：便捷创建常量和最小指令
// 6. def-use 关系的轻量实现：
// - Instruction 保存 operand 列表
// - Value 保存 uses
// - 支持 ReplaceAllUsesWith 的简化实现
//
// 当前尚未实现或只做了最小占位：
// 1. 完整类型系统：数组、函数类型、label 类型等
// 2. 更完整的指令系统：br / condbr / call / phi / gep 等
// 3. 更成熟的 Use 管理（例如 LLVM 风格的双向链式结构）
// 4. 更完整的 IR verifier 和优化基础设施
//
// 当前需要特别说明的两个简化点：
// 1. BasicBlock 虽然已经纳入 Value 体系，但其类型目前仍用 void 作为占位，
// 后续如果补 label type，可以再改成更合理的块标签类型。
// 2. ConstantValue 体系目前只实现了 ConstantInt，后续可以继续补 ConstantFloat、
// ConstantArray等更完整的常量种类。
//
// 建议的扩展顺序：
// 1. 先补更多指令和类型
// 2. 再补控制流相关 IR
// 3. 最后再考虑把 Value/User/Use 进一步抽象成更完整的框架
// IR_try.h (修正版)
#pragma once
#include "utils.h"
#include <iostream>
#include <iosfwd>
#include <memory>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <utility>
#include <type_traits>
#include <vector>
#include <map>
namespace ir {
class Type;
// 前向声明
class Value;
class User;
class ConstantValue;
class ConstantInt;
class GlobalValue;
class Instruction;
class BasicBlock;
class Function;
class Instruction;
class ConstantInt;
class ConstantFloat;
class ConstantI1;
class ConstantArrayValue;
class Type;
// Use 表示一个 Value 的一次使用记录。
// 当前实现设计：
// - value：被使用的值
// - user：使用该值的 User
// - operand_index：该值在 user 操作数列表中的位置
// -----------------------------------------------------------------------------
// Use
// -----------------------------------------------------------------------------
class Use {
public:
Use() = default;
Use(Value* value, User* user, size_t operand_index)
: value_(value), user_(user), operand_index_(operand_index) {}
Value* GetValue() const { return value_; }
User* GetUser() const { return user_; }
size_t GetOperandIndex() const { return operand_index_; }
void SetValue(Value* value) { value_ = value; }
void SetUser(User* user) { user_ = user; }
void SetOperandIndex(size_t operand_index) { operand_index_ = operand_index; }
private:
Value* value_ = nullptr;
User* user_ = nullptr;
size_t operand_index_ = 0;
public:
Use() = default;
Use(Value* value, User* user, size_t operand_index)
: value_(value), user_(user), operand_index_(operand_index) {}
Value* GetValue() const { return value_; }
User* GetUser() const { return user_; }
size_t GetOperandIndex() const { return operand_index_; }
void SetValue(Value* value) { value_ = value; }
void SetUser(User* user) { user_ = user; }
void SetOperandIndex(size_t operand_index) { operand_index_ = operand_index; }
private:
Value* value_ = nullptr;
User* user_ = nullptr;
size_t operand_index_ = 0;
};
// IR 上下文：集中管理类型、常量等共享资源，便于复用与扩展。
// -----------------------------------------------------------------------------
// Context
// -----------------------------------------------------------------------------
class Context {
public:
Context() = default;
~Context();
// 去重创建 i32 常量。
ConstantInt* GetConstInt(int v);
public:
Context() = default;
~Context();
std::string NextTemp();
ConstantInt* GetConstInt(int v);
std::string NextTemp();
private:
std::unordered_map<int, std::unique_ptr<ConstantInt>> const_ints_;
int temp_index_ = -1;
private:
std::unordered_map<int, std::unique_ptr<ConstantInt>> const_ints_;
int temp_index_ = -1;
};
// -----------------------------------------------------------------------------
// Type
// -----------------------------------------------------------------------------
class Type {
public:
enum class Kind { Void, Int32, PtrInt32 };
explicit Type(Kind k);
// 使用静态共享对象获取类型。
// 同一类型可直接比较返回值是否相等，例如：
// Type::GetInt32Type() == Type::GetInt32Type()
static const std::shared_ptr<Type>& GetVoidType();
static const std::shared_ptr<Type>& GetInt32Type();
static const std::shared_ptr<Type>& GetPtrInt32Type();
Kind GetKind() const;
bool IsVoid() const;
bool IsInt32() const;
bool IsPtrInt32() const;
private:
Kind kind_;
public:
enum class Kind { Void, Int1, Int32, Float, Label, Function, PtrInt32, Array };
explicit Type(Kind k);
static const std::shared_ptr<Type>& GetVoidType();
static const std::shared_ptr<Type>& GetInt1Type();
static const std::shared_ptr<Type>& GetInt32Type();
static const std::shared_ptr<Type>& GetFloatType();
static const std::shared_ptr<Type>& GetLabelType();
static const std::shared_ptr<Type>& GetFunctionType();
static const std::shared_ptr<Type>& GetBoolType();
static const std::shared_ptr<Type>& GetPtrInt32Type();
static const std::shared_ptr<Type>& GetArrayType();
Kind GetKind() const { return kind_; }
bool IsVoid() const { return kind_ == Kind::Void; }
bool IsInt1() const { return kind_ == Kind::Int1; }
bool IsInt32() const { return kind_ == Kind::Int32; }
bool IsFloat() const { return kind_ == Kind::Float; }
bool IsLabel() const { return kind_ == Kind::Label; }
bool IsFunction() const { return kind_ == Kind::Function; }
bool IsBool() const { return kind_ == Kind::Int1; } // 通常与 Int1 相同
bool IsPtrInt32() const { return kind_ == Kind::PtrInt32; }
bool IsArray() const { return kind_ == Kind::Array; }
int GetSize() const;
void Print(std::ostream& os) const;
template <typename T>
std::enable_if_t<std::is_base_of_v<Type, T>, T*> As() const {
return dynamic_cast<T*>(const_cast<Type*>(this));
}
private:
Kind kind_;
};
// -----------------------------------------------------------------------------
// Value
// -----------------------------------------------------------------------------
class Value {
public:
Value(std::shared_ptr<Type> ty, std::string name);
virtual ~Value() = default;
const std::shared_ptr<Type>& GetType() const;
const std::string& GetName() const;
void SetName(std::string n);
bool IsVoid() const;
bool IsInt32() const;
bool IsPtrInt32() const;
bool IsConstant() const;
bool IsInstruction() const;
bool IsUser() const;
bool IsFunction() const;
void AddUse(User* user, size_t operand_index);
void RemoveUse(User* user, size_t operand_index);
const std::vector<Use>& GetUses() const;
void ReplaceAllUsesWith(Value* new_value);
protected:
std::shared_ptr<Type> type_;
std::string name_;
std::vector<Use> uses_;
};
// ConstantValue 是常量体系的基类。
// 当前只实现了 ConstantInt，后续可继续扩展更多常量种类。
public:
Value(std::shared_ptr<Type> ty, std::string name);
virtual ~Value() = default;
const std::shared_ptr<Type>& GetType() const { return type_; }
const std::string& GetName() const { return name_; }
void SetName(std::string n) { name_ = std::move(n); }
bool IsVoid() const { return type_->IsVoid(); }
bool IsInt32() const { return type_->IsInt32(); }
bool IsPtrInt32() const { return type_->IsPtrInt32(); }
bool IsFloat() const { return type_->IsFloat(); }
bool IsBool() const { return type_->IsBool(); }
bool IsArray() const { return type_->IsArray(); }
bool IsLabel() const { return type_->IsLabel(); }
// 派生类身份判断（通过虚函数或枚举，这里使用虚函数）
virtual bool IsConstant() const { return false; }
virtual bool IsInstruction() const { return false; }
virtual bool IsUser() const { return false; }
virtual bool IsFunction() const { return false; }
void AddUse(User* user, size_t operand_index);
void RemoveUse(User* user, size_t operand_index);
const std::vector<Use>& GetUses() const { return uses_; }
void ReplaceAllUsesWith(Value* new_value);
void Print(std::ostream& os) const;
protected:
std::shared_ptr<Type> type_;
std::string name_;
std::vector<Use> uses_;
};
// -----------------------------------------------------------------------------
// isa / dyncast 辅助函数
// -----------------------------------------------------------------------------
template <typename T>
inline std::enable_if_t<std::is_base_of_v<Value, T>, bool> isa(const Value* value) {
return T::classof(value);
}
template <typename T>
inline std::enable_if_t<std::is_base_of_v<Value, T>, T*> dyncast(Value* value) {
return isa<T>(value) ? static_cast<T*>(value) : nullptr;
}
template <typename T>
inline std::enable_if_t<std::is_base_of_v<Value, T>, const T*> dyncast(const Value* value) {
return isa<T>(value) ? static_cast<const T*>(value) : nullptr;
}
// -----------------------------------------------------------------------------
// ConstantValue 系列
// -----------------------------------------------------------------------------
class ConstantValue : public Value {
public:
ConstantValue(std::shared_ptr<Type> ty, std::string name = "");
public:
ConstantValue(std::shared_ptr<Type> ty, std::string name = "");
bool IsConstant() const override final { return true; }
};
class ConstantInt : public ConstantValue {
public:
ConstantInt(std::shared_ptr<Type> ty, int v);
int GetValue() const { return value_; }
public:
ConstantInt(std::shared_ptr<Type> ty, int v);
int GetValue() const { return value_; }
static bool classof(const Value* v) { return v->IsConstant() && dynamic_cast<const ConstantInt*>(v) != nullptr; }
private:
int value_;
};
private:
int value_{};
class ConstantFloat : public ConstantValue {
public:
ConstantFloat(std::shared_ptr<Type> ty, float v);
float GetValue() const { return value_; }
static bool classof(const Value* v) { return v->IsConstant() && dynamic_cast<const ConstantFloat*>(v) != nullptr; }
private:
float value_;
};
// 后续还需要扩展更多指令类型。
enum class Opcode { Add, Sub, Mul, Alloca, Load, Store, Ret };
class ConstantI1 : public ConstantValue {
public:
ConstantI1(std::shared_ptr<Type> ty, bool v);
bool GetValue() const { return value_; }
static bool classof(const Value* v) { return v->IsConstant() && dynamic_cast<const ConstantI1*>(v) != nullptr; }
private:
bool value_;
};
// User 是所有“会使用其他 Value 作为输入”的 IR 对象的抽象基类。
// 当前实现中只有 Instruction 继承自 User。
class ConstantArrayValue : public Value {
public:
ConstantArrayValue(std::shared_ptr<Type> elemType,
const std::vector<Value*>& elements,
const std::vector<size_t>& dims,
const std::string& name = "");
const std::vector<Value*>& GetElements() const { return elements_; }
const std::vector<size_t>& GetDims() const { return dims_; }
void Print(std::ostream& os) const;
static bool classof(const Value* v) { return v->IsConstant() && dynamic_cast<const ConstantArrayValue*>(v) != nullptr; }
private:
std::vector<Value*> elements_;
std::vector<size_t> dims_;
};
// -----------------------------------------------------------------------------
// Opcode 枚举
// -----------------------------------------------------------------------------
enum class Opcode {
Add, Sub, Mul, Div, Rem, FAdd, FSub, FMul, FDiv, FRem,
And, Or, Xor, Shl, AShr, LShr,
ICmpEQ, ICmpNE, ICmpLT, ICmpGT, ICmpLE, ICmpGE,
FCmpEQ, FCmpNE, FCmpLT, FCmpGT, FCmpLE, FCmpGE,
Neg, Not, FNeg, FtoI, IToF,
Call, CondBr, Br, Return, Unreachable,
Alloca, Load, Store, Memset,
GetElementPtr, Phi, Zext
};
// -----------------------------------------------------------------------------
// User
// -----------------------------------------------------------------------------
class User : public Value {
public:
User(std::shared_ptr<Type> ty, std::string name);
size_t GetNumOperands() const;
Value* GetOperand(size_t index) const;
void SetOperand(size_t index, Value* value);
public:
User(std::shared_ptr<Type> ty, std::string name);
bool IsUser() const override final { return true; }
protected:
// 统一的 operand 入口。
void AddOperand(Value* value);
size_t GetNumOperands() const { return operands_.size(); }
Value* GetOperand(size_t index) const;
void SetOperand(size_t index, Value* value);
private:
std::vector<Value*> operands_;
void AddOperand(Value* value);
void AddOperands(const std::vector<Value*>& values);
void RemoveOperand(size_t index);
void ClearAllOperands();
protected:
std::vector<Use> operands_;
};
// GlobalValue 是全局值/全局变量体系的空壳占位类。
// 当前只补齐类层次，具体初始化器、打印和链接语义后续再补。
// -----------------------------------------------------------------------------
// GlobalValue
// -----------------------------------------------------------------------------
class GlobalValue : public User {
public:
GlobalValue(std::shared_ptr<Type> ty, std::string name);
public:
GlobalValue(std::shared_ptr<Type> type, const std::string& name,
bool isConst = false, Value* init = nullptr);
GlobalValue(std::shared_ptr<Type> type, const std::string& name,
const std::vector<Value*>& dims,
bool isConst = false, Value* init = nullptr);
bool IsConstant() const { return isConst_; }
bool HasInitializer() const { return init_ != nullptr; }
Value* GetInitializer() const { return init_; }
size_t GetNumDims() const { return dims_.size(); }
Value* GetDim(size_t i) const { return dims_[i]; }
void SetConstant(bool c) { isConst_ = c; }
void SetInitializer(Value* v) { init_ = v; }
static bool classof(const Value* v) { return v->IsUser() && dynamic_cast<const GlobalValue*>(v) != nullptr; }
private:
bool isConst_;
Value* init_;
std::vector<Value*> dims_;
};
// -----------------------------------------------------------------------------
// Instruction 及其子类
// -----------------------------------------------------------------------------
class Instruction : public User {
public:
Instruction(Opcode op, std::shared_ptr<Type> ty, std::string name = "");
Opcode GetOpcode() const;
bool IsTerminator() const;
BasicBlock* GetParent() const;
void SetParent(BasicBlock* parent);
public:
Instruction(Opcode op, std::shared_ptr<Type> ty,
BasicBlock* parent = nullptr, const std::string& name = "");
bool IsInstruction() const override final { return true; }
Opcode GetOpcode() const { return opcode_; }
bool IsTerminator() const {
return opcode_ == Opcode::Br || opcode_ == Opcode::CondBr ||
opcode_ == Opcode::Return || opcode_ == Opcode::Unreachable;
}
BasicBlock* GetParent() const { return parent_; }
void SetParent(BasicBlock* parent) { parent_ = parent; }
private:
Opcode opcode_;
BasicBlock* parent_ = nullptr;
static bool classof(const Value* v) { return v->IsInstruction(); }
private:
Opcode opcode_;
BasicBlock* parent_;
};
class BinaryInst : public Instruction {
public:
BinaryInst(Opcode op, std::shared_ptr<Type> ty, Value* lhs, Value* rhs,
std::string name);
Value* GetLhs() const;
Value* GetRhs() const;
public:
BinaryInst(Opcode op, std::shared_ptr<Type> ty, Value* lhs, Value* rhs,
BasicBlock* parent = nullptr, const std::string& name = "");
Value* GetLhs() const { return GetOperand(0); }
Value* GetRhs() const { return GetOperand(1); }
static bool classof(const Value* v) {
return Instruction::classof(v) && static_cast<const Instruction*>(v)->GetOpcode() >= Opcode::Add &&
static_cast<const Instruction*>(v)->GetOpcode() <= Opcode::FCmpGE;
}
};
class UnaryInst : public Instruction {
public:
UnaryInst(Opcode op, std::shared_ptr<Type> ty, Value* operand,
BasicBlock* parent = nullptr, const std::string& name = "");
Value* GetOprd() const { return GetOperand(0); }
static bool classof(const Value* v) {
return Instruction::classof(v) && static_cast<const Instruction*>(v)->GetOpcode() >= Opcode::Neg &&
static_cast<const Instruction*>(v)->GetOpcode() <= Opcode::IToF;
}
};
class ReturnInst : public Instruction {
public:
ReturnInst(std::shared_ptr<Type> void_ty, Value* val);
Value* GetValue() const;
public:
ReturnInst(Value* val = nullptr, BasicBlock* parent = nullptr);
bool HasReturnValue() const { return GetNumOperands() > 0; }
Value* GetReturnValue() const { return HasReturnValue() ? GetOperand(0) : nullptr; }
static bool classof(const Value* v) {
return Instruction::classof(v) && static_cast<const Instruction*>(v)->GetOpcode() == Opcode::Return;
}
};
class AllocaInst : public Instruction {
public:
AllocaInst(std::shared_ptr<Type> ptr_ty, std::string name);
public:
AllocaInst(std::shared_ptr<Type> elemType, BasicBlock* parent = nullptr,
const std::string& name = "");
AllocaInst(std::shared_ptr<Type> elemType, const std::vector<Value*>& dims,
BasicBlock* parent = nullptr, const std::string& name = "");
size_t GetNumDims() const { return dims_.size(); }
Value* GetDim(size_t i) const { return dims_[i]; }
static bool classof(const Value* v) {
return Instruction::classof(v) && static_cast<const Instruction*>(v)->GetOpcode() == Opcode::Alloca;
}
private:
std::vector<Value*> dims_;
};
class LoadInst : public Instruction {
public:
LoadInst(std::shared_ptr<Type> val_ty, Value* ptr, std::string name);
Value* GetPtr() const;
public:
LoadInst(Value* ptr, BasicBlock* parent = nullptr, const std::string& name = "");
Value* GetPtr() const { return GetOperand(0); }
static bool classof(const Value* v) {
return Instruction::classof(v) && static_cast<const Instruction*>(v)->GetOpcode() == Opcode::Load;
}
};
class StoreInst : public Instruction {
public:
StoreInst(std::shared_ptr<Type> void_ty, Value* val, Value* ptr);
Value* GetValue() const;
Value* GetPtr() const;
public:
StoreInst(Value* val, Value* ptr, BasicBlock* parent = nullptr);
Value* GetValue() const { return GetOperand(0); }
Value* GetPtr() const { return GetOperand(1); }
static bool classof(const Value* v) {
return Instruction::classof(v) && static_cast<const Instruction*>(v)->GetOpcode() == Opcode::Store;
}
};
class UncondBrInst : public Instruction {
public:
UncondBrInst(BasicBlock* dest, const std::vector<Value*>& args = {},
BasicBlock* parent = nullptr);
BasicBlock* GetDest() const { return dyncast<BasicBlock>(GetOperand(0)); }
std::vector<Value*> GetArguments() const {
std::vector<Value*> result;
for (size_t i = 1; i < GetNumOperands(); ++i)
result.push_back(GetOperand(i));
return result;
}
static bool classof(const Value* v) {
return Instruction::classof(v) && static_cast<const Instruction*>(v)->GetOpcode() == Opcode::Br;
}
};
class CondBrInst : public Instruction {
public:
CondBrInst(Value* cond, BasicBlock* thenBlock, BasicBlock* elseBlock,
const std::vector<Value*>& thenArgs = {},
const std::vector<Value*>& elseArgs = {},
BasicBlock* parent = nullptr);
Value* GetCondition() const { return GetOperand(0); }
BasicBlock* GetThenBlock() const { return dyncast<BasicBlock>(GetOperand(1)); }
BasicBlock* GetElseBlock() const { return dyncast<BasicBlock>(GetOperand(2)); }
std::vector<Value*> GetThenArguments() const {
std::vector<Value*> result;
size_t num = GetThenBlock()->GetNumArguments();
for (size_t i = 0; i < num; ++i)
result.push_back(GetOperand(3 + i));
return result;
}
std::vector<Value*> GetElseArguments() const {
std::vector<Value*> result;
size_t num = GetThenBlock()->GetNumArguments();
size_t start = 3 + num;
for (size_t i = 0; i < GetElseBlock()->GetNumArguments(); ++i)
result.push_back(GetOperand(start + i));
return result;
}
static bool classof(const Value* v) {
return Instruction::classof(v) && static_cast<const Instruction*>(v)->GetOpcode() == Opcode::CondBr;
}
};
class UnreachableInst : public Instruction {
public:
explicit UnreachableInst(BasicBlock* parent = nullptr);
static bool classof(const Value* v) {
return Instruction::classof(v) && static_cast<const Instruction*>(v)->GetOpcode() == Opcode::Unreachable;
}
};
// BasicBlock 已纳入 Value 体系，便于后续向更完整 IR 类图靠拢。
// 当前其类型仍使用 void 作为占位，后续可替换为专门的 label type。
class CallInst : public Instruction {
public:
CallInst(Function* callee, const std::vector<Value*>& args = {},
BasicBlock* parent = nullptr, const std::string& name = "");
Function* GetCallee() const { return dyncast<Function>(GetOperand(0)); }
std::vector<Value*> GetArguments() const {
std::vector<Value*> result;
for (size_t i = 1; i < GetNumOperands(); ++i)
result.push_back(GetOperand(i));
return result;
}
static bool classof(const Value* v) {
return Instruction::classof(v) && static_cast<const Instruction*>(v)->GetOpcode() == Opcode::Call;
}
};
class GetElementPtrInst : public Instruction {
public:
GetElementPtrInst(Value* ptr, const std::vector<Value*>& indices,
const std::vector<size_t>& dims = {},
const std::vector<size_t>& curDims = {},
BasicBlock* parent = nullptr, const std::string& name = "");
Value* GetPointer() const { return GetOperand(0); }
size_t GetNumIndices() const { return GetNumOperands() - 1; }
Value* GetIndex(size_t i) const { return GetOperand(i + 1); }
const std::vector<size_t>& GetDims() const { return dims_; }
const std::vector<size_t>& GetCurDims() const { return curDims_; }
static bool classof(const Value* v) {
return Instruction::classof(v) && static_cast<const Instruction*>(v)->GetOpcode() == Opcode::GetElementPtr;
}
private:
std::vector<size_t> dims_;
std::vector<size_t> curDims_;
};
class PhiInst : public Instruction {
public:
PhiInst(std::shared_ptr<Type> type, BasicBlock* parent = nullptr,
const std::string& name = "");
void AddIncoming(Value* value, BasicBlock* block);
int GetNumIncomings() const { return static_cast<int>(GetNumOperands() / 2); }
Value* GetIncomingValue(int i) const { return GetOperand(2 * i); }
BasicBlock* GetIncomingBlock(int i) const { return dyncast<BasicBlock>(GetOperand(2 * i + 1)); }
static bool classof(const Value* v) {
return Instruction::classof(v) && static_cast<const Instruction*>(v)->GetOpcode() == Opcode::Phi;
}
};
class ZextInst : public Instruction {
public:
ZextInst(Value* val, std::shared_ptr<Type> targetType,
BasicBlock* parent = nullptr, const std::string& name = "");
Value* GetValue() const { return GetOperand(0); }
static bool classof(const Value* v) {
return Instruction::classof(v) && static_cast<const Instruction*>(v)->GetOpcode() == Opcode::Zext;
}
};
class MemsetInst : public Instruction {
public:
MemsetInst(Value* dst, Value* val, Value* len, Value* isVolatile,
BasicBlock* parent = nullptr);
Value* GetDest() const { return GetOperand(0); }
Value* GetValue() const { return GetOperand(1); }
Value* GetLength() const { return GetOperand(2); }
Value* GetIsVolatile() const { return GetOperand(3); }
static bool classof(const Value* v) {
return Instruction::classof(v) && static_cast<const Instruction*>(v)->GetOpcode() == Opcode::Memset;
}
};
// -----------------------------------------------------------------------------
// BasicBlock
// -----------------------------------------------------------------------------
class BasicBlock : public Value {
public:
explicit BasicBlock(std::string name);
Function* GetParent() const;
void SetParent(Function* parent);
bool HasTerminator() const;
const std::vector<std::unique_ptr<Instruction>>& GetInstructions() const;
const std::vector<BasicBlock*>& GetPredecessors() const;
const std::vector<BasicBlock*>& GetSuccessors() const;
template <typename T, typename... Args>
T* Append(Args&&... args) {
if (HasTerminator()) {
throw std::runtime_error("BasicBlock 已有 terminator，不能继续追加指令: " +
name_);
public:
explicit BasicBlock(const std::string& name);
BasicBlock(Function* parent, const std::string& name);
Function* GetParent() const { return parent_; }
void SetParent(Function* parent) { parent_ = parent; }
bool HasTerminator() const;
const std::vector<std::unique_ptr<Instruction>>& GetInstructions() const { return instructions_; }
void AddPredecessor(BasicBlock* pred);
void AddSuccessor(BasicBlock* succ);
void RemovePredecessor(BasicBlock* pred);
void RemoveSuccessor(BasicBlock* succ);
const std::vector<BasicBlock*>& GetPredecessors() const { return predecessors_; }
const std::vector<BasicBlock*>& GetSuccessors() const { return successors_; }
template <typename T, typename... Args>
T* Append(Args&&... args) {
if (HasTerminator()) {
throw std::runtime_error("BasicBlock already has terminator");
}
auto inst = std::make_unique<T>(std::forward<Args>(args)...);
auto* ptr = inst.get();
ptr->SetParent(this);
instructions_.push_back(std::move(inst));
return ptr;
}
auto inst = std::make_unique<T>(std::forward<Args>(args)...);
auto* ptr = inst.get();
ptr->SetParent(this);
instructions_.push_back(std::move(inst));
return ptr;
}
private:
Function* parent_ = nullptr;
std::vector<std::unique_ptr<Instruction>> instructions_;
std::vector<BasicBlock*> predecessors_;
std::vector<BasicBlock*> successors_;
};
// Function 当前也采用了最小实现。
// 需要特别注意：由于项目里还没有单独的 FunctionType，
// Function 继承自 Value 后，其 type_ 目前只保存“返回类型”，
// 并不能完整表达“返回类型 + 形参列表”这一整套函数签名。
// 这对当前只支持 int main() 的最小 IR 足够，但后续若补普通函数、
// 形参和调用，通常需要引入专门的函数类型表示。
static bool classof(const Value* v) { return dynamic_cast<const BasicBlock*>(v) != nullptr; }
size_t GetNumArguments() const { return 0; } // 当前版本无参数
private:
Function* parent_;
std::vector<std::unique_ptr<Instruction>> instructions_;
std::vector<BasicBlock*> predecessors_;
std::vector<BasicBlock*> successors_;
};
// -----------------------------------------------------------------------------
// Function
// -----------------------------------------------------------------------------
class Function : public Value {
public:
// 当前构造函数接收的也是返回类型，而不是完整函数类型。
Function(std::string name, std::shared_ptr<Type> ret_type);
BasicBlock* CreateBlock(const std::string& name);
BasicBlock* GetEntry();
const BasicBlock* GetEntry() const;
const std::vector<std::unique_ptr<BasicBlock>>& GetBlocks() const;
public:
Function(std::string name, std::shared_ptr<Type> ret_type);
Function(std::string name, std::shared_ptr<Type> ret_type,
const std::vector<std::shared_ptr<Type>>& param_types);
bool IsFunction() const override final { return true; }
std::shared_ptr<Type> GetReturnType() const { return GetType(); }
const std::vector<std::shared_ptr<Type>>& GetParamTypes() const { return param_types_; }
private:
BasicBlock* entry_ = nullptr;
std::vector<std::unique_ptr<BasicBlock>> blocks_;
BasicBlock* GetEntryBlock() const { return entry_; }
void SetEntryBlock(BasicBlock* bb);
BasicBlock* CreateBlock(const std::string& name);
BasicBlock* AddBlock(std::unique_ptr<BasicBlock> block);
const std::vector<std::unique_ptr<BasicBlock>>& GetBlocks() const { return blocks_; }
static bool classof(const Value* v) { return v->IsFunction(); }
private:
std::vector<std::shared_ptr<Type>> param_types_;
BasicBlock* entry_;
std::vector<std::unique_ptr<BasicBlock>> blocks_;
};
// -----------------------------------------------------------------------------
// Module
// -----------------------------------------------------------------------------
class Module {
public:
Module() = default;
Context& GetContext();
const Context& GetContext() const;
// 创建函数时当前只显式传入返回类型，尚未接入完整的 FunctionType。
Function* CreateFunction(const std::string& name,
std::shared_ptr<Type> ret_type);
const std::vector<std::unique_ptr<Function>>& GetFunctions() const;
private:
Context context_;
std::vector<std::unique_ptr<Function>> functions_;
public:
Module() = default;
Context& GetContext() { return context_; }
const Context& GetContext() const { return context_; }
Function* CreateFunction(const std::string& name, std::shared_ptr<Type> ret_type);
Function* CreateFunction(const std::string& name, std::shared_ptr<Type> ret_type,
const std::vector<std::shared_ptr<Type>>& param_types);
Function* GetFunction(const std::string& name) const;
const std::vector<std::unique_ptr<Function>>& GetFunctions() const { return functions_; }
GlobalValue* CreateGlobalValue(const std::string& name, std::shared_ptr<Type> type,
bool isConst = false, Value* init = nullptr);
GlobalValue* GetGlobalValue(const std::string& name) const;
const std::vector<std::unique_ptr<GlobalValue>>& GetGlobalValues() const { return globals_; }
private:
Context context_;
std::vector<std::unique_ptr<Function>> functions_;
std::map<std::string, Function*> function_map_;
std::vector<std::unique_ptr<GlobalValue>> globals_;
std::map<std::string, GlobalValue*> global_map_;
};
// -----------------------------------------------------------------------------
// IRBuilder
// -----------------------------------------------------------------------------
class IRBuilder {
public:
IRBuilder(Context& ctx, BasicBlock* bb);
void SetInsertPoint(BasicBlock* bb);
BasicBlock* GetInsertBlock() const;
// 构造常量、二元运算、返回指令的最小集合。
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);
AllocaInst* CreateAllocaI32(const std::string& name);
LoadInst* CreateLoad(Value* ptr, const std::string& name);
StoreInst* CreateStore(Value* val, Value* ptr);
ReturnInst* CreateRet(Value* v);
private:
Context& ctx_;
BasicBlock* insert_block_;
public:
IRBuilder(Context& ctx, BasicBlock* bb);
void SetInsertPoint(BasicBlock* bb);
BasicBlock* GetInsertBlock() const { return insert_block_; }
ConstantInt* CreateConstInt(int v);
ConstantFloat* CreateConstFloat(float v);
ConstantI1* CreateConstBool(bool v);
ConstantArrayValue* CreateConstArray(std::shared_ptr<Type> elem_type,
const std::vector<Value*>& elements,
const std::vector<size_t>& dims,
const std::string& name = "");
BinaryInst* CreateBinary(Opcode op, Value* lhs, Value* rhs,
const std::string& name = "");
BinaryInst* CreateAdd(Value* lhs, Value* rhs, const std::string& name = "");
BinaryInst* CreateSub(Value* lhs, Value* rhs, const std::string& name = "");
BinaryInst* CreateMul(Value* lhs, Value* rhs, const std::string& name = "");
BinaryInst* CreateDiv(Value* lhs, Value* rhs, const std::string& name = "");
BinaryInst* CreateRem(Value* lhs, Value* rhs, const std::string& name = "");
BinaryInst* CreateAnd(Value* lhs, Value* rhs, const std::string& name = "");
BinaryInst* CreateOr(Value* lhs, Value* rhs, const std::string& name = "");
BinaryInst* CreateXor(Value* lhs, Value* rhs, const std::string& name = "");
BinaryInst* CreateShl(Value* lhs, Value* rhs, const std::string& name = "");
BinaryInst* CreateAShr(Value* lhs, Value* rhs, const std::string& name = "");
BinaryInst* CreateLShr(Value* lhs, Value* rhs, const std::string& name = "");
BinaryInst* CreateICmp(Opcode op, Value* lhs, Value* rhs, const std::string& name = "");
BinaryInst* CreateFCmp(Opcode op, Value* lhs, Value* rhs, const std::string& name = "");
UnaryInst* CreateNeg(Value* operand, const std::string& name = "");
UnaryInst* CreateNot(Value* operand, const std::string& name = "");
UnaryInst* CreateFNeg(Value* operand, const std::string& name = "");
UnaryInst* CreateFtoI(Value* operand, const std::string& name = "");
UnaryInst* CreateIToF(Value* operand, const std::string& name = "");
AllocaInst* CreateAlloca(std::shared_ptr<Type> elem_type, const std::string& name = "");
AllocaInst* CreateAllocaArray(std::shared_ptr<Type> elem_type, const std::vector<Value*>& dims,
const std::string& name = "");
LoadInst* CreateLoad(Value* ptr, const std::string& name = "");
StoreInst* CreateStore(Value* val, Value* ptr);
UncondBrInst* CreateBr(BasicBlock* dest, const std::vector<Value*>& args = {});
CondBrInst* CreateCondBr(Value* cond, BasicBlock* then_bb, BasicBlock* else_bb,
const std::vector<Value*>& then_args = {},
const std::vector<Value*>& else_args = {});
ReturnInst* CreateRet(Value* val = nullptr);
UnreachableInst* CreateUnreachable();
CallInst* CreateCall(Function* callee, const std::vector<Value*>& args,
const std::string& name = "");
GetElementPtrInst* CreateGEP(Value* ptr, const std::vector<Value*>& indices,
const std::vector<size_t>& dims = {},
const std::vector<size_t>& cur_dims = {},
const std::string& name = "");
PhiInst* CreatePhi(std::shared_ptr<Type> type, const std::string& name = "");
ZextInst* CreateZext(Value* val, std::shared_ptr<Type> target_type, const std::string& name = "");
MemsetInst* CreateMemset(Value* dst, Value* val, Value* len, Value* is_volatile);
private:
Context& ctx_;
BasicBlock* insert_block_;
};
// -----------------------------------------------------------------------------
// IRPrinter
// -----------------------------------------------------------------------------
class IRPrinter {
public:
void Print(const Module& module, std::ostream& os);
public:
void Print(const Module& module, std::ostream& os);
};
} // namespace ir
// -----------------------------------------------------------------------------
// 输出运算符重载
// -----------------------------------------------------------------------------
inline std::ostream& operator<<(std::ostream& os, const Type& type) {
type.Print(os);
return os;
}
inline std::ostream& operator<<(std::ostream& os, const Value& value) {
value.Print(os);
return os;
}
} // namespace ir

373
include/ir/IR_org.h
Unescape View File

@ -0,0 +1,373 @@
// 当前只支撑 i32、i32*、void 以及最小的内存/算术指令，演示用。
//
// 当前已经实现：
// 1. 基础类型系统：void / i32 / i32*
// 2. Value 体系：Value / ConstantValue / ConstantInt / Function / BasicBlock / User / GlobalValue / Instruction
// 3. 最小指令集：Add / Alloca / Load / Store / Ret
// 4. BasicBlock / Function / Module 三层组织结构
// 5. IRBuilder：便捷创建常量和最小指令
// 6. def-use 关系的轻量实现：
// - Instruction 保存 operand 列表
// - Value 保存 uses
// - 支持 ReplaceAllUsesWith 的简化实现
//
// 当前尚未实现或只做了最小占位：
// 1. 完整类型系统：数组、函数类型、label 类型等
// 2. 更完整的指令系统：br / condbr / call / phi / gep 等
// 3. 更成熟的 Use 管理（例如 LLVM 风格的双向链式结构）
// 4. 更完整的 IR verifier 和优化基础设施
//
// 当前需要特别说明的两个简化点：
// 1. BasicBlock 虽然已经纳入 Value 体系，但其类型目前仍用 void 作为占位，
// 后续如果补 label type，可以再改成更合理的块标签类型。
// 2. ConstantValue 体系目前只实现了 ConstantInt，后续可以继续补 ConstantFloat、
// ConstantArray等更完整的常量种类。
//
// 建议的扩展顺序：
// 1. 先补更多指令和类型
// 2. 再补控制流相关 IR
// 3. 最后再考虑把 Value/User/Use 进一步抽象成更完整的框架
#pragma once
#include <iosfwd>
#include <memory>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
namespace ir {
class Type;
class Value;
class User;
class ConstantValue;
class ConstantInt;
class GlobalValue;
class Instruction;
class BasicBlock;
class Function;
// Use 表示一个 Value 的一次使用记录。
// 当前实现设计：
// - value：被使用的值
// - user：使用该值的 User
// - operand_index：该值在 user 操作数列表中的位置
class Use {
public:
Use() = default;
Use(Value* value, User* user, size_t operand_index)
: value_(value), user_(user), operand_index_(operand_index) {}
Value* GetValue() const { return value_; }
User* GetUser() const { return user_; }
size_t GetOperandIndex() const { return operand_index_; }
void SetValue(Value* value) { value_ = value; }
void SetUser(User* user) { user_ = user; }
void SetOperandIndex(size_t operand_index) { operand_index_ = operand_index; }
private:
Value* value_ = nullptr;
User* user_ = nullptr;
size_t operand_index_ = 0;
};
// IR 上下文：集中管理类型、常量等共享资源，便于复用与扩展。
class Context {
public:
Context() = default;
~Context();
// 去重创建 i32 常量。
ConstantInt* GetConstInt(int v);
std::string NextTemp();
private:
std::unordered_map<int, std::unique_ptr<ConstantInt>> const_ints_;
int temp_index_ = -1;
};
class Type {
public:
enum class Kind { Void, Int1, Int32, Float, Label, Function, PtrInt32, Array };
explicit Type(Kind k);
// 静态工厂方法：返回对应类型的共享单例
static const std::shared_ptr<Type>& GetVoidType();
static const std::shared_ptr<Type>& GetInt1Type();
static const std::shared_ptr<Type>& GetInt32Type();
static const std::shared_ptr<Type>& GetFloatType();
static const std::shared_ptr<Type>& GetLabelType();
static const std::shared_ptr<Type>& GetFunctionType();
static const std::shared_ptr<Type>& GetBoolType();
static const std::shared_ptr<Type>& GetPtrInt32Type();
static const std::shared_ptr<Type>& GetArrayType();
Kind GetKind() const;
// 便捷类型判断
bool IsVoid() const;
bool IsInt1() const;
bool IsInt32() const;
bool IsFloat() const;
bool IsLabel() const;
bool IsFunction() const;
bool IsBool() const;
bool IsPtrInt32() const;
bool IsArray() const;
private:
Kind kind_;
};
class Value {
public:
Value(std::shared_ptr<Type> ty, std::string name);
virtual ~Value() = default;
const std::shared_ptr<Type>& GetType() const;
const std::string& GetName() const;
void SetName(std::string n);
bool IsVoid() const;
bool IsInt32() const;
bool IsPtrInt32() const;
bool IsConstant() const;
bool IsInstruction() const;
bool IsUser() const;
bool IsFunction() const;
void AddUse(User* user, size_t operand_index);
void RemoveUse(User* user, size_t operand_index);
const std::vector<Use>& GetUses() const;
void ReplaceAllUsesWith(Value* new_value);
protected:
std::shared_ptr<Type> type_;
std::string name_;
std::vector<Use> uses_;
};
// ConstantValue 是常量体系的基类。
// 当前只实现了 ConstantInt，后续可继续扩展更多常量种类。
class ConstantValue : public Value {
public:
ConstantValue(std::shared_ptr<Type> ty, std::string name = "");
};
class ConstantInt : public ConstantValue {
public:
ConstantInt(std::shared_ptr<Type> ty, int v);
int GetValue() const { return value_; }
private:
int value_{};
};
class ConstantFloat : public ConstantValue {
public:
ConstantFloat(std::shared_ptr<Type> ty, float v);
float GetValue() const { return value_; }
private:
float value_{};
};
class ConstantI1 : public ConstantValue {
public:
ConstantI1(std::shared_ptr<Type> ty, bool v);
int GetValue() const { return value_; }
private:
bool value_{};
};
class ConstantArrayValue : public Value {
public:
ConstantArrayValue()
};
//暂时先设计这些
enum class Opcode {
// 二元算术
Add,Sub,Mul,Div,Rem,FAdd,FSub,FMul,FDiv,FRem,
// 位运算
And,Or,Xor,Shl,AShr,LShr,
// 整数比较
ICmpEQ,ICmpNE,ICmpLT,ICmpGT,ICmpLE,ICmpGE,
// 浮点比较
FCmpEQ,FCmpNE,FCmpLT,FCmpGT,FCmpLE,FCmpGE,
// 一元运算
Neg,Not,FNeg,FtoI,IToF,
// 调用与终止
Call,CondBr,Br,Return,Unreachable,
// 内存操作
Alloca,Load,Store,Memset,
// 其他
GetElementPtr,Phi,Zext
};
// User 是所有“会使用其他 Value 作为输入”的 IR 对象的抽象基类。
// 当前实现中只有 Instruction 继承自 User。
class User : public Value {
public:
User(std::shared_ptr<Type> ty, std::string name);
size_t GetNumOperands() const;
Value* GetOperand(size_t index) const;
void SetOperand(size_t index, Value* value);
protected:
void AddOperand(Value* value);
private:
std::vector<Value*> operands_;
};
// GlobalValue 是全局值/全局变量体系的空壳占位类。
// 当前只补齐类层次，具体初始化器、打印和链接语义后续再补。
class GlobalValue : public User {
public:
GlobalValue(std::shared_ptr<Type> ty, std::string name);
};
class Instruction : public User {
public:
Instruction(Opcode op, std::shared_ptr<Type> ty, std::string name = "");
Opcode GetOpcode() const;
bool IsTerminator() const;
BasicBlock* GetParent() const;
void SetParent(BasicBlock* parent);
private:
Opcode opcode_;
BasicBlock* parent_ = nullptr;
};
class BinaryInst : public Instruction {
public:
BinaryInst(Opcode op, std::shared_ptr<Type> ty, Value* lhs, Value* rhs,
std::string name);
Value* GetLhs() const;
Value* GetRhs() const;
};
class ReturnInst : public Instruction {
public:
ReturnInst(std::shared_ptr<Type> void_ty, Value* val);
Value* GetValue() const;
};
class AllocaInst : public Instruction {
public:
AllocaInst(std::shared_ptr<Type> ptr_ty, std::string name);
};
class LoadInst : public Instruction {
public:
LoadInst(std::shared_ptr<Type> val_ty, Value* ptr, std::string name);
Value* GetPtr() const;
};
class StoreInst : public Instruction {
public:
StoreInst(std::shared_ptr<Type> void_ty, Value* val, Value* ptr);
Value* GetValue() const;
Value* GetPtr() const;
};
// BasicBlock 已纳入 Value 体系，便于后续向更完整 IR 类图靠拢。
// 当前其类型仍使用 void 作为占位，后续可替换为专门的 label type。
class BasicBlock : public Value {
public:
explicit BasicBlock(std::string name);
Function* GetParent() const;
void SetParent(Function* parent);
bool HasTerminator() const;
const std::vector<std::unique_ptr<Instruction>>& GetInstructions() const;
const std::vector<BasicBlock*>& GetPredecessors() const;
const std::vector<BasicBlock*>& GetSuccessors() const;
template <typename T, typename... Args>
T* Append(Args&&... args) {
if (HasTerminator()) {
throw std::runtime_error("BasicBlock 已有 terminator，不能继续追加指令: " +
name_);
}
auto inst = std::make_unique<T>(std::forward<Args>(args)...);
auto* ptr = inst.get();
ptr->SetParent(this);
instructions_.push_back(std::move(inst));
return ptr;
}
private:
Function* parent_ = nullptr;
std::vector<std::unique_ptr<Instruction>> instructions_;
std::vector<BasicBlock*> predecessors_;
std::vector<BasicBlock*> successors_;
};
// Function 当前也采用了最小实现。
// 需要特别注意：由于项目里还没有单独的 FunctionType，
// Function 继承自 Value 后，其 type_ 目前只保存“返回类型”，
// 并不能完整表达“返回类型 + 形参列表”这一整套函数签名。
// 这对当前只支持 int main() 的最小 IR 足够，但后续若补普通函数、
// 形参和调用，通常需要引入专门的函数类型表示。
class Function : public Value {
public:
// 当前构造函数接收的也是返回类型，而不是完整函数类型。
Function(std::string name, std::shared_ptr<Type> ret_type);
BasicBlock* CreateBlock(const std::string& name);
BasicBlock* GetEntry();
const BasicBlock* GetEntry() const;
const std::vector<std::unique_ptr<BasicBlock>>& GetBlocks() const;
private:
BasicBlock* entry_ = nullptr;
std::vector<std::unique_ptr<BasicBlock>> blocks_;
};
class Module {
public:
Module() = default;
Context& GetContext();
const Context& GetContext() const;
// 创建函数时当前只显式传入返回类型，尚未接入完整的 FunctionType。
Function* CreateFunction(const std::string& name,
std::shared_ptr<Type> ret_type);
const std::vector<std::unique_ptr<Function>>& GetFunctions() const;
private:
Context context_;
std::vector<std::unique_ptr<Function>> functions_;
};
class IRBuilder {
public:
IRBuilder(Context& ctx, BasicBlock* bb);
void SetInsertPoint(BasicBlock* bb);
BasicBlock* GetInsertBlock() const;
// 构造常量、二元运算、返回指令的最小集合。
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);
AllocaInst* CreateAllocaI32(const std::string& name);
LoadInst* CreateLoad(Value* ptr, const std::string& name);
StoreInst* CreateStore(Value* val, Value* ptr);
ReturnInst* CreateRet(Value* v);
private:
Context& ctx_;
BasicBlock* insert_block_;
};
class IRPrinter {
public:
void Print(const Module& module, std::ostream& os);
};
} // namespace ir

41
include/ir/utils.h
Unescape View File

@ -0,0 +1,41 @@
#pragma once
#include <iterator>
namespace ir {
template <typename IterT> struct range {
using iterator = IterT;
using value_type = typename std::iterator_traits<iterator>::value_type;
using reference = typename std::iterator_traits<iterator>::reference;
private:
iterator b;
iterator e;
public:
explicit range(iterator b, iterator e) : b(b), e(e) {}
iterator begin() { return b; }
iterator end() { return e; }
iterator begin() const { return b; }
iterator end() const { return e; }
auto size() const { return std::distance(b, e); }
auto empty() const { return b == e; }
};
//! create `range` object from iterator pair [begin, end)
template <typename IterT> range<IterT> make_range(IterT b, IterT e) {
return range<IterT>(b, e);
}
//! create `range` object from a container who has `begin()` and `end()` methods
template <typename ContainerT>
range<typename ContainerT::iterator> make_range(ContainerT &c) {
return make_range(c.begin(), c.end());
}
//! create `range` object from a container who has `begin()` and `end()` methods
template <typename ContainerT>
range<typename ContainerT::const_iterator> make_range(const ContainerT &c) {
return make_range(c.begin(), c.end());
}
} // namespace ir
Write Preview
Loading…
Cancel
Save