JCNC/SCompiler
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

修改名词

Browse Source
This commit is contained in:
Luke 2025-05-07 17:24:41 +08:00
parent 11159d783d
commit f741bdaa3a
20 changed files with 147 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/main/java/org/jcnc/snow/compiler/backend/RegisterAllocator.java
View File

@ -5,21 +5,21 @@ package org.jcnc.snow.compiler.backend;
import org.jcnc.snow.compiler.ir.core.IRFunction;
import org.jcnc.snow.compiler.ir.core.IRInstruction;
import org.jcnc.snow.compiler.ir.core.IRValue;
import org.jcnc.snow.compiler.ir.value.VirtualRegister;
import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
import java.util.HashMap;
import java.util.Map;
/** 线性扫描寄存器分配（演示级） */
public final class RegisterAllocator {
private final Map<VirtualRegister,Integer> map = new HashMap<>();
private final Map<IRVirtualRegister,Integer> map = new HashMap<>();
public Map<VirtualRegister,Integer> allocate(IRFunction fn){
public Map<IRVirtualRegister,Integer> allocate(IRFunction fn){
int next = 0;
for (IRInstruction i : fn.body()){
if(i.dest()!=null && !map.containsKey(i.dest())) map.put(i.dest(), next++);
for(IRValue v : i.operands())
if(v instanceof VirtualRegister r && !map.containsKey(r)) map.put(r, next++);
if(v instanceof IRVirtualRegister r && !map.containsKey(r)) map.put(r, next++);
}
return map;
}

28
src/main/java/org/jcnc/snow/compiler/backend/VMCodeGenerator.java
View File

@ -2,9 +2,9 @@ package org.jcnc.snow.compiler.backend;
import org.jcnc.snow.compiler.ir.core.IRFunction;
import org.jcnc.snow.compiler.ir.core.IRInstruction;
import org.jcnc.snow.compiler.ir.instr.*;
import org.jcnc.snow.compiler.ir.value.Constant;
import org.jcnc.snow.compiler.ir.value.VirtualRegister;
import org.jcnc.snow.compiler.ir.instruction.*;
import org.jcnc.snow.compiler.ir.value.IRConstant;
import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
import org.jcnc.snow.vm.engine.VMOpCode;
import java.lang.reflect.Field;
@ -18,12 +18,12 @@ import java.util.Map;
*/
public final class VMCodeGenerator {
private final Map<VirtualRegister,Integer> slotMap;
private final Map<IRVirtualRegister,Integer> slotMap;
private final List<String> code = new ArrayList<>();
private String currentFnName; // ← 当前正在生成的函数名
public VMCodeGenerator(Map<VirtualRegister,Integer> slotMap){
public VMCodeGenerator(Map<IRVirtualRegister,Integer> slotMap){
this.slotMap = slotMap;
}
@ -34,8 +34,8 @@ public final class VMCodeGenerator {
for (IRInstruction inst : fn.body()) {
switch (inst) {
case LoadConstInstruction c -> genLoadConst(c);
case BinOpInstruction b -> genBinOp(b);
case UnaryOpInstruction u -> genUnary(u);
case BinaryOperationInstruction b -> genBinOp(b);
case UnaryOperationInstruction u -> genUnary(u);
case ReturnInstruction r -> genRet(r);
default -> throw new IllegalStateException("Unsupported IR: "+inst);
}
@ -47,14 +47,14 @@ public final class VMCodeGenerator {
/* ───────────── 指令生成 ───────────── */
private void genLoadConst(LoadConstInstruction c){
Constant k = (Constant)c.operands().get(0);
IRConstant k = (IRConstant)c.operands().get(0);
emit(op("I_PUSH"), k.value().toString());
emit(op("I_STORE"), slot(c.dest())+"");
}
private void genBinOp(BinOpInstruction b){
emit(op("I_LOAD"), slot((VirtualRegister)b.operands().get(0))+"");
emit(op("I_LOAD"), slot((VirtualRegister)b.operands().get(1))+"");
private void genBinOp(BinaryOperationInstruction b){
emit(op("I_LOAD"), slot((IRVirtualRegister)b.operands().get(0))+"");
emit(op("I_LOAD"), slot((IRVirtualRegister)b.operands().get(1))+"");
String opcode = switch (b.op()){
case ADD_I32 -> "I_ADD";
@ -67,8 +67,8 @@ public final class VMCodeGenerator {
emit(op("I_STORE"), slot(b.dest())+"");
}
private void genUnary(UnaryOpInstruction u){
emit(op("I_LOAD"), slot((VirtualRegister)u.operands().get(0))+"");
private void genUnary(UnaryOperationInstruction u){
emit(op("I_LOAD"), slot((IRVirtualRegister)u.operands().get(0))+"");
String opcode = switch (u.op()){
case NEG_I32 -> "I_NEG";
@ -97,7 +97,7 @@ public final class VMCodeGenerator {
/* ───────────── 工具函数 ───────────── */
private int slot(VirtualRegister r){
private int slot(IRVirtualRegister r){
Integer s = slotMap.get(r);
if (s == null) throw new IllegalStateException("Register "+r+" 未映射槽位");
return s;

4
src/main/java/org/jcnc/snow/compiler/cli/SnowCompiler.java
View File

@ -2,7 +2,7 @@ package org.jcnc.snow.compiler.cli;
import org.jcnc.snow.compiler.backend.RegisterAllocator;
import org.jcnc.snow.compiler.backend.VMCodeGenerator;
import org.jcnc.snow.compiler.ir.builder.ProgramBuilder;
import org.jcnc.snow.compiler.ir.builder.IRProgramBuilder;
import org.jcnc.snow.compiler.ir.core.IRFunction;
import org.jcnc.snow.compiler.ir.core.IRProgram;
import org.jcnc.snow.compiler.lexer.core.LexerEngine;
@ -55,7 +55,7 @@ public class SnowCompiler {
SemanticAnalyzerRunner.runSemanticAnalysis(ast, false);
/* 4. AST → IRProgram */
IRProgram program = new ProgramBuilder().buildProgram(ast);
IRProgram program = new IRProgramBuilder().buildProgram(ast);
System.out.println("=== IR ===");
System.out.println(program);

30
src/main/java/org/jcnc/snow/compiler/ir/builder/ExpressionBuilder.java
View File

@ -1,7 +1,7 @@
package org.jcnc.snow.compiler.ir.builder;
import org.jcnc.snow.compiler.ir.core.IROp;
import org.jcnc.snow.compiler.ir.value.VirtualRegister;
import org.jcnc.snow.compiler.ir.core.IROpCode;
import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
import org.jcnc.snow.compiler.parser.ast.BinaryExpressionNode;
import org.jcnc.snow.compiler.parser.ast.IdentifierNode;
import org.jcnc.snow.compiler.parser.ast.NumberLiteralNode;
@ -23,15 +23,15 @@ public class ExpressionBuilder {
/**
* 操作符到 IR 操作码的映射表
*/
private static final Map<String, IROp> OP_MAP = Map.of(
"+", IROp.ADD_I32,
"-", IROp.SUB_I32,
"*", IROp.MUL_I32,
"/", IROp.DIV_I32
private static final Map<String, IROpCode> OP_MAP = Map.of(
"+", IROpCode.ADD_I32,
"-", IROpCode.SUB_I32,
"*", IROpCode.MUL_I32,
"/", IROpCode.DIV_I32
);
/**
* 当前 IR 构建上下文，包含 IRFunction 和 Scope
* 当前 IR 构建上下文，包含 IRFunction 和 IRBuilderScope
*/
private final IRContext ctx;
@ -51,17 +51,17 @@ public class ExpressionBuilder {
* @return 存放表达式计算结果的虚拟寄存器
* @throws IllegalStateException 若遇到不支持的表达式节点或未定义变量
*/
public VirtualRegister build(ExpressionNode expr) {
public IRVirtualRegister build(ExpressionNode expr) {
// 处理数字常量
if (expr instanceof NumberLiteralNode(String value)) {
int v = Integer.parseInt(value);
// 生成加载常量指令并返回结果寄存器
return InstrFactory.loadConst(ctx, v);
return InstructionFactory.loadConst(ctx, v);
}
// 处理变量引用
if (expr instanceof IdentifierNode(String name)) {
// 从作用域查找已声明的寄存器
VirtualRegister vr = ctx.getScope().lookup(name);
IRVirtualRegister vr = ctx.getScope().lookup(name);
if (vr == null) {
throw new IllegalStateException("未定义的变量: " + name);
}
@ -70,15 +70,15 @@ public class ExpressionBuilder {
// 处理二元表达式
if (expr instanceof BinaryExpressionNode(ExpressionNode left, String operator, ExpressionNode right)) {
// 递归构建左、右子表达式
VirtualRegister l = build(left);
VirtualRegister r = build(right);
IRVirtualRegister l = build(left);
IRVirtualRegister r = build(right);
// 根据操作符获取 IR 操作码
IROp op = OP_MAP.get(operator);
IROpCode op = OP_MAP.get(operator);
if (op == null) {
throw new IllegalStateException("不支持的运算符: " + operator);
}
// 生成二元运算指令并返回结果寄存器
return InstrFactory.binOp(ctx, op, l, r);
return InstructionFactory.binOp(ctx, op, l, r);
}
// 其他表达式类型暂不支持
throw new IllegalStateException(

20
src/main/java/org/jcnc/snow/compiler/ir/builder/Scope.java → src/main/java/org/jcnc/snow/compiler/ir/builder/IRBuilderScope.java
View File

@ -1,13 +1,13 @@
package org.jcnc.snow.compiler.ir.builder;
import org.jcnc.snow.compiler.ir.core.IRFunction;
import org.jcnc.snow.compiler.ir.value.VirtualRegister;
import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
import java.util.HashMap;
import java.util.Map;
/**
* Scope 用于管理单个函数的变量名与虚拟寄存器的映射。
* IRBuilderScope 用于管理单个函数的变量名与虚拟寄存器的映射。
*
* <p>功能：
* <ul>
@ -16,10 +16,10 @@ import java.util.Map;
* <li>根据变量名查找对应的虚拟寄存器。</li>
* </ul>
*/
final class Scope {
final class IRBuilderScope {
/** 存储变量名到 VirtualRegister 的映射 */
private final Map<String, VirtualRegister> vars = new HashMap<>();
/** 存储变量名到 IRVirtualRegister 的映射 */
private final Map<String, IRVirtualRegister> vars = new HashMap<>();
/**
* 当前作用域所属的 IRFunction，用于分配新的寄存器。
@ -41,7 +41,7 @@ final class Scope {
* @param name 变量名
*/
void declare(String name) {
VirtualRegister reg = fn.newRegister();
IRVirtualRegister reg = fn.newRegister();
vars.put(name, reg);
}
@ -51,7 +51,7 @@ final class Scope {
* @param name 变量名
* @param reg 对应的虚拟寄存器
*/
void declare(String name, VirtualRegister reg) {
void declare(String name, IRVirtualRegister reg) {
vars.put(name, reg);
}
@ -61,7 +61,7 @@ final class Scope {
* @param name 变量名
* @param reg 新的虚拟寄存器
*/
void put(String name, VirtualRegister reg) {
void put(String name, IRVirtualRegister reg) {
vars.put(name, reg);
}
@ -69,9 +69,9 @@ final class Scope {
* 根据变量名查找其对应的虚拟寄存器。
*
* @param name 变量名
* @return 对应的 VirtualRegister，若未声明则返回 null
* @return 对应的 IRVirtualRegister，若未声明则返回 null
*/
VirtualRegister lookup(String name) {
IRVirtualRegister lookup(String name) {
return vars.get(name);
}
}

23
src/main/java/org/jcnc/snow/compiler/ir/builder/IRContext.java
View File

@ -2,11 +2,10 @@ package org.jcnc.snow.compiler.ir.builder;
import org.jcnc.snow.compiler.ir.core.IRFunction;
import org.jcnc.snow.compiler.ir.core.IRInstruction;
import org.jcnc.snow.compiler.parser.ast.*;
import org.jcnc.snow.compiler.ir.value.VirtualRegister;
import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
/**
* IRContext 封装了当前函数的 IRFunction 实例和作用域管理（Scope），
* IRContext 封装了当前函数的 IRFunction 实例和作用域管理（IRBuilderScope），
* 并提供分配寄存器和添加 IR 指令的便利方法。
*
* <p>主要功能：
@ -25,7 +24,7 @@ public class IRContext {
/**
* 管理变量和寄存器映射的作用域
*/
private final Scope scope;
private final IRBuilderScope IRBuilderScope;
/**
* 构造 IRContext，并绑定要构建的 IRFunction。
@ -34,9 +33,9 @@ public class IRContext {
*/
public IRContext(IRFunction function) {
this.function = function;
this.scope = new Scope();
this.IRBuilderScope = new IRBuilderScope();
// 将 IRFunction 与作用域关联，以便指令生成时使用
this.scope.attachFunction(function);
this.IRBuilderScope.attachFunction(function);
}
/**
@ -51,19 +50,19 @@ public class IRContext {
/**
* 获取当前作用域，用于变量声明和查找。
*
* @return 作用域对象 Scope
* @return 作用域对象 IRBuilderScope
*/
/* 包内可见：仅在 builder 包内部使用 Scope */
Scope getScope() {
return scope;
/* 包内可见：仅在 builder 包内部使用 IRBuilderScope */
IRBuilderScope getScope() {
return IRBuilderScope;
}
/**
* 分配一个新的虚拟寄存器。
*
* @return 新分配的 VirtualRegister 对象
* @return 新分配的 IRVirtualRegister 对象
*/
public VirtualRegister newRegister() {
public IRVirtualRegister newRegister() {
return function.newRegister();
}

4
src/main/java/org/jcnc/snow/compiler/ir/builder/ProgramBuilder.java → src/main/java/org/jcnc/snow/compiler/ir/builder/IRProgramBuilder.java
View File

@ -10,7 +10,7 @@ import org.jcnc.snow.compiler.parser.ast.base.StatementNode;
import java.util.List;
/**
* ProgramBuilder 用于将 AST 根节点列表构建为 IRProgram。
* IRProgramBuilder 用于将 AST 根节点列表构建为 IRProgram。
*
* <p>功能：
* <ul>
@ -19,7 +19,7 @@ import java.util.List;
* <li>对脚本式顶层语句自动包装为特殊的 _start 函数。</li>
* </ul>
*/
public final class ProgramBuilder {
public final class IRProgramBuilder {
/**
* 构建一个完整的 IRProgram。

36
src/main/java/org/jcnc/snow/compiler/ir/builder/InstrFactory.java → src/main/java/org/jcnc/snow/compiler/ir/builder/InstructionFactory.java
View File

@ -1,23 +1,23 @@
package org.jcnc.snow.compiler.ir.builder;
import org.jcnc.snow.compiler.ir.core.IROp;
import org.jcnc.snow.compiler.ir.instr.BinOpInstruction;
import org.jcnc.snow.compiler.ir.instr.LoadConstInstruction;
import org.jcnc.snow.compiler.ir.instr.ReturnInstruction;
import org.jcnc.snow.compiler.ir.value.Constant;
import org.jcnc.snow.compiler.ir.value.VirtualRegister;
import org.jcnc.snow.compiler.ir.core.IROpCode;
import org.jcnc.snow.compiler.ir.instruction.BinaryOperationInstruction;
import org.jcnc.snow.compiler.ir.instruction.LoadConstInstruction;
import org.jcnc.snow.compiler.ir.instruction.ReturnInstruction;
import org.jcnc.snow.compiler.ir.value.IRConstant;
import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
/**
* InstrFactory 统一管理 IR 指令的创建，并自动将生成的指令添加到上下文中。
* InstructionFactory 统一管理 IR 指令的创建，并自动将生成的指令添加到上下文中。
*
* <p>提供的功能包括：
* <ul>
* <li>生成加载常量指令（LoadConstInstruction）；</li>
* <li>生成二元运算指令（BinOpInstruction）；</li>
* <li>生成二元运算指令（BinaryOperationInstruction）；</li>
* <li>生成返回指令（ReturnInstruction），支持有返回值和无返回值两种情况；</li>
* </ul>
*/
public class InstrFactory {
public class InstructionFactory {
/**
* 生成加载整数常量的指令，并返回对应的结果寄存器。
@ -26,9 +26,9 @@ public class InstrFactory {
* @param value 要加载的整数值
* @return 存放常量的虚拟寄存器
*/
public static VirtualRegister loadConst(IRContext ctx, int value) {
VirtualRegister vr = ctx.newRegister();
LoadConstInstruction instr = new LoadConstInstruction(vr, new Constant(value));
public static IRVirtualRegister loadConst(IRContext ctx, int value) {
IRVirtualRegister vr = ctx.newRegister();
LoadConstInstruction instr = new LoadConstInstruction(vr, new IRConstant(value));
ctx.addInstruction(instr);
return vr;
}
@ -42,11 +42,11 @@ public class InstrFactory {
* @param right 右操作数寄存器
* @return 存放运算结果的虚拟寄存器
*/
public static VirtualRegister binOp(IRContext ctx, IROp op,
VirtualRegister left,
VirtualRegister right) {
VirtualRegister dest = ctx.newRegister();
BinOpInstruction instr = new BinOpInstruction(op, dest, left, right);
public static IRVirtualRegister binOp(IRContext ctx, IROpCode op,
IRVirtualRegister left,
IRVirtualRegister right) {
IRVirtualRegister dest = ctx.newRegister();
BinaryOperationInstruction instr = new BinaryOperationInstruction(op, dest, left, right);
ctx.addInstruction(instr);
return dest;
}
@ -57,7 +57,7 @@ public class InstrFactory {
* @param ctx 当前 IR 构建上下文
* @param value 需要返回的虚拟寄存器
*/
public static void ret(IRContext ctx, VirtualRegister value) {
public static void ret(IRContext ctx, IRVirtualRegister value) {
ctx.addInstruction(new ReturnInstruction(value));
}

12
src/main/java/org/jcnc/snow/compiler/ir/builder/StatementBuilder.java
View File

@ -1,6 +1,6 @@
package org.jcnc.snow.compiler.ir.builder;
import org.jcnc.snow.compiler.ir.value.VirtualRegister;
import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
import org.jcnc.snow.compiler.parser.ast.AssignmentNode;
import org.jcnc.snow.compiler.parser.ast.DeclarationNode;
import org.jcnc.snow.compiler.parser.ast.ExpressionStatementNode;
@ -26,7 +26,7 @@ public class StatementBuilder {
return;
}
if (stmt instanceof AssignmentNode an) {
VirtualRegister vr = exprBuilder.build(an.value());
IRVirtualRegister vr = exprBuilder.build(an.value());
if (ctx.getScope().lookup(an.variable()) == null) {
ctx.getScope().declare(an.variable(), vr);
} else {
@ -36,7 +36,7 @@ public class StatementBuilder {
}
if (stmt instanceof DeclarationNode dn) {
if (dn.getInitializer().isPresent()) {
VirtualRegister init = exprBuilder.build(dn.getInitializer().get());
IRVirtualRegister init = exprBuilder.build(dn.getInitializer().get());
ctx.getScope().declare(dn.getName(), init);
} else {
ctx.getScope().declare(dn.getName());
@ -45,10 +45,10 @@ public class StatementBuilder {
}
if (stmt instanceof ReturnNode rn) {
if (rn.getExpression().isPresent()) {
VirtualRegister vr = exprBuilder.build(rn.getExpression().get());
InstrFactory.ret(ctx, vr);
IRVirtualRegister vr = exprBuilder.build(rn.getExpression().get());
InstructionFactory.ret(ctx, vr);
} else {
InstrFactory.retVoid(ctx);
InstructionFactory.retVoid(ctx);
}
return;
}

6
src/main/java/org/jcnc/snow/compiler/ir/core/IRFunction.java
View File

@ -1,6 +1,6 @@
package org.jcnc.snow.compiler.ir.core;
import org.jcnc.snow.compiler.ir.value.VirtualRegister;
import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
import java.util.ArrayList;
import java.util.List;
@ -35,8 +35,8 @@ public class IRFunction {
*
* @return 新建的虚拟寄存器
*/
public VirtualRegister newRegister() {
return new VirtualRegister(regCounter++);
public IRVirtualRegister newRegister() {
return new IRVirtualRegister(regCounter++);
}
/**

8
src/main/java/org/jcnc/snow/compiler/ir/core/IRInstruction.java
View File

@ -1,6 +1,6 @@
package org.jcnc.snow.compiler.ir.core;
import org.jcnc.snow.compiler.ir.value.VirtualRegister;
import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
import java.util.List;
@ -23,9 +23,9 @@ public abstract class IRInstruction {
* 获取指令的操作符。
* 例如：ADD_I32、CONST、RET 等。
*
* @return 操作符枚举值（IROp）
* @return 操作符枚举值（IROpCode）
*/
public abstract IROp op();
public abstract IROpCode op();
/**
* 获取指令的目标寄存器（若有的话）。
@ -35,7 +35,7 @@ public abstract class IRInstruction {
*
* @return 目标寄存器或 null
*/
public VirtualRegister dest() {
public IRVirtualRegister dest() {
return null;
}

8
src/main/java/org/jcnc/snow/compiler/ir/core/IROp.java → src/main/java/org/jcnc/snow/compiler/ir/core/IROpCode.java
View File

@ -1,12 +1,12 @@
package org.jcnc.snow.compiler.ir.core;
/**
* IROp —— IR 层支持的操作码（Opcode）枚举类型。
* IROpCode —— IR 层支持的操作码（Opcode）枚举类型。
* <p>
* 每种操作码代表一条基本指令的种类，供 IRInstruction 使用。
* 可以根据编译器需求继续扩展。
*/
public enum IROp {
public enum IROpCode {
/* ───── 算术运算 ───── */
/** 整型加法（32位） */
@ -52,7 +52,7 @@ public enum IROp {
/** 存储到内存（Store） */
STORE,
/** 加载常量（Constant） */
/** 加载常量（IRConstant） */
CONST,
/* ───── 控制流 ───── */
@ -63,7 +63,7 @@ public enum IROp {
/** 条件跳转（Jump if zero），若条件为 0 则跳转 */
JUMP_IF_ZERO,
/** 标签（Label），跳转目标位置 */
/** 标签（IRLabel），跳转目标位置 */
LABEL,
/* ───── 函数调用相关 ───── */

14
src/main/java/org/jcnc/snow/compiler/ir/core/IRValue.java
View File

@ -1,20 +1,20 @@
package org.jcnc.snow.compiler.ir.core;
import org.jcnc.snow.compiler.ir.value.Constant;
import org.jcnc.snow.compiler.ir.value.Label;
import org.jcnc.snow.compiler.ir.value.VirtualRegister;
import org.jcnc.snow.compiler.ir.value.IRConstant;
import org.jcnc.snow.compiler.ir.value.IRLabel;
import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
/**
* IRValue —— 表示在中间表示（IR）系统中能作为操作数使用的基本单位。
* <p>
* 包括：
* • VirtualRegister（虚拟寄存器）
* • Constant（常量）
* • Label（跳转标签）
* • IRVirtualRegister（虚拟寄存器）
* • IRConstant（常量）
* • IRLabel（跳转标签）
* <p>
* 本接口使用 sealed 限定，明确列出所有允许实现它的子类型，
* 保证类型安全，并便于在编译时做穷尽检查。
*/
public sealed interface IRValue
permits VirtualRegister, Constant, Label {
permits IRVirtualRegister, IRConstant, IRLabel {
}

18
src/main/java/org/jcnc/snow/compiler/ir/instr/BinOpInstruction.java → src/main/java/org/jcnc/snow/compiler/ir/instruction/BinaryOperationInstruction.java
View File

@ -1,9 +1,9 @@
package org.jcnc.snow.compiler.ir.instr;
package org.jcnc.snow.compiler.ir.instruction;
import org.jcnc.snow.compiler.ir.core.IRInstruction;
import org.jcnc.snow.compiler.ir.core.IROp;
import org.jcnc.snow.compiler.ir.core.IROpCode;
import org.jcnc.snow.compiler.ir.core.IRValue;
import org.jcnc.snow.compiler.ir.value.VirtualRegister;
import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
import java.util.List;
@ -12,12 +12,12 @@ import java.util.List;
* 格式为：dest = lhs (OP) rhs
* 其中 dest 是结果寄存器，lhs 和 rhs 是操作数，OP 是操作符（如加法、减法等）。
*/
public final class BinOpInstruction extends IRInstruction {
public final class BinaryOperationInstruction extends IRInstruction {
// 二元操作符，例如加法、减法、乘法、除法等
private final IROp op;
private final IROpCode op;
// 存放运算结果的虚拟寄存器
private final VirtualRegister dest;
private final IRVirtualRegister dest;
// 左操作数
private final IRValue lhs;
@ -33,7 +33,7 @@ public final class BinOpInstruction extends IRInstruction {
* @param lhs 左侧操作数
* @param rhs 右侧操作数
*/
public BinOpInstruction(IROp op, VirtualRegister dest, IRValue lhs, IRValue rhs) {
public BinaryOperationInstruction(IROpCode op, IRVirtualRegister dest, IRValue lhs, IRValue rhs) {
this.op = op;
this.dest = dest;
this.lhs = lhs;
@ -46,7 +46,7 @@ public final class BinOpInstruction extends IRInstruction {
* @return 操作符
*/
@Override
public IROp op() {
public IROpCode op() {
return op;
}
@ -56,7 +56,7 @@ public final class BinOpInstruction extends IRInstruction {
* @return 目标寄存器
*/
@Override
public VirtualRegister dest() {
public IRVirtualRegister dest() {
return dest;
}

24
src/main/java/org/jcnc/snow/compiler/ir/instr/LoadConstInstruction.java → src/main/java/org/jcnc/snow/compiler/ir/instruction/LoadConstInstruction.java
View File

@ -1,24 +1,24 @@
package org.jcnc.snow.compiler.ir.instr;
package org.jcnc.snow.compiler.ir.instruction;
import org.jcnc.snow.compiler.ir.core.IRInstruction;
import org.jcnc.snow.compiler.ir.core.IROp;
import org.jcnc.snow.compiler.ir.core.IROpCode;
import org.jcnc.snow.compiler.ir.core.IRValue;
import org.jcnc.snow.compiler.ir.value.Constant;
import org.jcnc.snow.compiler.ir.value.VirtualRegister;
import org.jcnc.snow.compiler.ir.value.IRConstant;
import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
import java.util.List;
/**
* 表示常量加载指令（Load Constant Instruction）。
* 表示常量加载指令（Load IRConstant Instruction）。
* 格式为：dest = CONST k
* 其中 dest 是结果寄存器，k 是要加载的常量值。
*/
public final class LoadConstInstruction extends IRInstruction {
// 要加载的常量值
private final Constant k;
private final IRConstant k;
// 存放常量的目标虚拟寄存器
private final VirtualRegister dest;
private final IRVirtualRegister dest;
/**
* 构造函数，创建一个常量加载指令实例。
@ -26,7 +26,7 @@ public final class LoadConstInstruction extends IRInstruction {
* @param dest 目标寄存器，用于存放常量
* @param k 要加载的常量值
*/
public LoadConstInstruction(VirtualRegister dest, Constant k) {
public LoadConstInstruction(IRVirtualRegister dest, IRConstant k) {
this.dest = dest;
this.k = k;
}
@ -34,11 +34,11 @@ public final class LoadConstInstruction extends IRInstruction {
/**
* 获取此指令的操作符，恒为 CONST。
*
* @return 操作符 IROp.CONST
* @return 操作符 IROpCode.CONST
*/
@Override
public IROp op() {
return IROp.CONST;
public IROpCode op() {
return IROpCode.CONST;
}
/**
@ -47,7 +47,7 @@ public final class LoadConstInstruction extends IRInstruction {
* @return 目标虚拟寄存器
*/
@Override
public VirtualRegister dest() {
public IRVirtualRegister dest() {
return dest;
}

18
src/main/java/org/jcnc/snow/compiler/ir/instr/ReturnInstruction.java → src/main/java/org/jcnc/snow/compiler/ir/instruction/ReturnInstruction.java
View File

@ -1,9 +1,9 @@
package org.jcnc.snow.compiler.ir.instr;
package org.jcnc.snow.compiler.ir.instruction;
import org.jcnc.snow.compiler.ir.core.IRInstruction;
import org.jcnc.snow.compiler.ir.core.IROp;
import org.jcnc.snow.compiler.ir.core.IROpCode;
import org.jcnc.snow.compiler.ir.core.IRValue;
import org.jcnc.snow.compiler.ir.value.VirtualRegister;
import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
import java.util.List;
@ -16,25 +16,25 @@ import java.util.List;
*/
public final class ReturnInstruction extends IRInstruction {
// 返回值对应的虚拟寄存器，如果是 void 返回则为 null
private final VirtualRegister value;
private final IRVirtualRegister value;
/**
* 构造函数，创建一个返回指令实例。
*
* @param value 要返回的虚拟寄存器，如果是 void 返回则传入 null
*/
public ReturnInstruction(VirtualRegister value) {
public ReturnInstruction(IRVirtualRegister value) {
this.value = value;
}
/**
* 获取此指令的操作符，恒为 RET。
*
* @return 操作符 IROp.RET
* @return 操作符 IROpCode.RET
*/
@Override
public IROp op() {
return IROp.RET;
public IROpCode op() {
return IROpCode.RET;
}
/**
@ -54,7 +54,7 @@ public final class ReturnInstruction extends IRInstruction {
*
* @return 返回值寄存器，或 null（表示 void 返回）
*/
public VirtualRegister value() {
public IRVirtualRegister value() {
return value;
}

18
src/main/java/org/jcnc/snow/compiler/ir/instr/UnaryOpInstruction.java → src/main/java/org/jcnc/snow/compiler/ir/instruction/UnaryOperationInstruction.java
View File

@ -1,9 +1,9 @@
package org.jcnc.snow.compiler.ir.instr;
package org.jcnc.snow.compiler.ir.instruction;
import org.jcnc.snow.compiler.ir.core.IRInstruction;
import org.jcnc.snow.compiler.ir.core.IROp;
import org.jcnc.snow.compiler.ir.core.IROpCode;
import org.jcnc.snow.compiler.ir.core.IRValue;
import org.jcnc.snow.compiler.ir.value.VirtualRegister;
import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
import java.util.List;
@ -15,12 +15,12 @@ import java.util.List;
* - OP：一元操作符（如取负、按位取反等）
* - val：操作数
*/
public final class UnaryOpInstruction extends IRInstruction {
public final class UnaryOperationInstruction extends IRInstruction {
// 一元操作符，例如 NEG（取负）、NOT（逻辑非）等
private final IROp op;
private final IROpCode op;
// 运算结果存放的目标虚拟寄存器
private final VirtualRegister dest;
private final IRVirtualRegister dest;
// 一元运算的操作数
private final IRValue val;
@ -32,7 +32,7 @@ public final class UnaryOpInstruction extends IRInstruction {
* @param dest 结果存放的目标寄存器
* @param val 操作数
*/
public UnaryOpInstruction(IROp op, VirtualRegister dest, IRValue val) {
public UnaryOperationInstruction(IROpCode op, IRVirtualRegister dest, IRValue val) {
this.op = op;
this.dest = dest;
this.val = val;
@ -44,7 +44,7 @@ public final class UnaryOpInstruction extends IRInstruction {
* @return 一元操作符
*/
@Override
public IROp op() {
public IROpCode op() {
return op;
}
@ -54,7 +54,7 @@ public final class UnaryOpInstruction extends IRInstruction {
* @return 目标虚拟寄存器
*/
@Override
public VirtualRegister dest() {
public IRVirtualRegister dest() {
return dest;
}

4
src/main/java/org/jcnc/snow/compiler/ir/value/Constant.java → src/main/java/org/jcnc/snow/compiler/ir/value/IRConstant.java
View File

@ -3,11 +3,11 @@ package org.jcnc.snow.compiler.ir.value;
import org.jcnc.snow.compiler.ir.core.IRValue;
/**
* Constant 类 —— 表示一个常量值（例如整数常量、字符串常量等）。
* IRConstant 类 —— 表示一个常量值（例如整数常量、字符串常量等）。
* <p>
* 在中间表示（IR）中，常量通常是不可变的、直接使用的值，而不是寄存器或临时变量。
*/
public record Constant(Object value) implements IRValue {
public record IRConstant(Object value) implements IRValue {
/**
* 将常量值转换为字符串表示。

6
src/main/java/org/jcnc/snow/compiler/ir/value/Label.java → src/main/java/org/jcnc/snow/compiler/ir/value/IRLabel.java
View File

@ -3,14 +3,14 @@ package org.jcnc.snow.compiler.ir.value;
import org.jcnc.snow.compiler.ir.core.IRValue;
/**
* Label —— 表示 IR 中的跳转目标标签。
* IRLabel —— 表示 IR 中的跳转目标标签。
*
* 在中间表示（IR）中，控制流指令（如 JUMP、JUMP_IF_ZERO）需要依赖标签来指定跳转位置。
* 本类通过名字（字符串）唯一标识一个标签。
*
* Label 也是一种 IRValue，因此可以作为指令的操作数。
* IRLabel 也是一种 IRValue，因此可以作为指令的操作数。
*/
public record Label(String name) implements IRValue {
public record IRLabel(String name) implements IRValue {
/**
* 将标签转换为字符串形式。

6
src/main/java/org/jcnc/snow/compiler/ir/value/VirtualRegister.java → src/main/java/org/jcnc/snow/compiler/ir/value/IRVirtualRegister.java
View File

@ -3,7 +3,7 @@ package org.jcnc.snow.compiler.ir.value;
import org.jcnc.snow.compiler.ir.core.IRValue;
/**
* VirtualRegister —— 表示一个 SSA（静态单赋值）虚拟寄存器。
* IRVirtualRegister —— 表示一个 SSA（静态单赋值）虚拟寄存器。
* <p>
* 在中间表示（IR）中，每个中间值都存储在一个虚拟寄存器中。
* <p>
@ -11,9 +11,9 @@ import org.jcnc.snow.compiler.ir.core.IRValue;
* - 每个寄存器都有唯一的 id（通常由 IRBuilder 自动分配）
* - 遵循 SSA 形式，即每个寄存器只被赋值一次
* <p>
* VirtualRegister 也是一种 IRValue，可以作为指令的操作数。
* IRVirtualRegister 也是一种 IRValue，可以作为指令的操作数。
*/
public record VirtualRegister(int id) implements IRValue {
public record IRVirtualRegister(int id) implements IRValue {
/**
* 将虚拟寄存器转换为字符串形式。