chentianya/Interpreter
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

阶段 B 步骤 4：compiler 配置驱动化，去除 isa 依赖。

Browse Source 
- Project.h 自带 IoBinding；Stb.h/cpp：compiler 侧 .stb 规范（常量/ConstEntry/FNV/StbView/读写/sidecar）
- Codec.h/cpp：指令字 pack/字段/配置驱动 disasm（format 表驱动）
- Codegen：opcode 全查 MachineConfig（E_* 发射器）、常量 tag 查配置类型、初值按基元宽度写、
  映像拼装用 Stb 常量；codegen_project 增加 cfg 参数
- main.cpp：--machine <path>（编译/反汇编必填），--disasm 用 StbView+Codec
- CMake：compiler 不再链接 isa（仅 toml++ 私有）；测试补链 isa（自身断言用）
- 验证：20 用例字节不变（hash 0xc3fe4ae74ad45900 相同）、ctest 12/12、缺 --machine 报错退出
This commit is contained in:
Admin
2026-08-21 22:14:29 +08:00
parent 44b5ecd46d
commit 447a8d0119
15 changed files with 739 additions and 390 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/src/Codegen.cpp
+199 -336
View File
@@ -1,38 +1,32 @@
/**
* @file Codegen.cpp
* @brief 寄存器码生成（12.8，切片 7：+ FB 实例、内联展开、CAL_*）
* @brief 寄存器码生成（配置驱动；compiler 不依赖 isa）
* @author
* @date 2026-08-21
*
* @details 设计说明（详见 Doc/compiler/寄存器码.md）：
* - 切片 1~6：帧/字面量/MOVE/RET；全局数据区；短路 AND/OR；CMP 与 IF；WHILE 与四则；
* FUNCTION 与 CALL（调用约定 r0/r1..r7/r8+）。
* - 切片 7：FB 实例 → 数据区实例块（跨周期持久）；字段槽号 = 实例基槽 + 字段序号
* （编译期算死）；字段读写走 LOAD_GLOBAL / STORE_GLOBAL；
* 内建 TON/TOF/CTU → 实参写字段后 CAL_* <实例基槽>；
* 用户 FB → 调用点内联展开（实参写字段 → FB 体以实例字段为变量编译）
* - 方案 a（12.9 前置）：数据段**每槽 8 字节定宽**，指令 slot = 槽号（无映射）
* @details 设计说明（详见 Doc/compiler/寄存器码.md 与 Doc/isa/指令配置.md）：
* - 指令 opcode / 类型 tag / FB 布局全部来自 machine.toml（MachineConfig）
* - 帧/字面量/MOVE/RET；全局数据区；短路 AND/OR；CMP 与 IF；WHILE 与四则；
* FUNCTION 与 CALL（调用约定 r0/r1..r7/r8+）
* - FB 实例 → 数据区实例块（跨周期持久）；字段槽号 = 实例基槽 + 字段序号
* - 用户 FB 调用点内联展开；内建 FB → CAL_* <实例基槽>
* - 数据段每槽 8 字节定宽，指令 slot = 槽号
*
* 函数清单：
* - put_le32 / put_le64 小端写入映像缓冲
* - Builder::Builder （构造）存工程/源文件/链接结果/输出，收集 io 绑定分类
* - Builder::run 布局数据区（全局 + 实例）→ 逐 POU 建函数 → 拼映像
* - Builder::fail 组装 "codegen error: <msg>" 返回 false
* - Builder::Builder （构造）存工程/源文件/链接结果/机器配置/输出，收集 io 绑定
* - Builder::run 布局数据区 → 逐 POU 建函数 → 拼映像
* - Builder::fail / opc 错误 / 按名查配置 opcode
* - E_rr / E_rrr / E_imm / E_slot / E_jmp / E_jc / E_call / E_ret 指令发射（配置 opcode）
* - find_pou / find_fn_id 按名查 POU AST / fn_id
* - build_function 编译一个 POU（PROGRAM/FUNCTION/FB 骨架；帧约定分配）
* - begin_stmt / alloc_temp 临时寄存器：语句内递增、语句结束复用基址
* - build_function 编译一个 POU（帧约定分配；FB 占位）
* - begin_stmt / alloc_temp 临时寄存器管理
* - compile_stmt 语句编译（赋值 / IF / WHILE / FB 调用）
* - compile_if / compile_while IF 链 / WHILE 回环
* - compile_fb_call FB 调用：内建 CAL_* 或用户内联展开
* - compile_fb_inline 内联编译用户 FB 体（实例字段为变量）
* - store_target 赋值左值：STORE_* 到全局槽（或内联模式实例字段）
* - compile_expr 表达式编译到寄存器（含 Field 字段读）
* - cmp_op / arith_op / load_op / store_op 操作码选择
* - global_offset 槽号恒等（方案 a 无映射）
* - instance_of 实例 → 字段槽号表
* - patch_jump 回填跳转偏移（相对下一条指令）
* - layout_data / layout_fb_instances / init_of 数据区布局（8 字节定宽槽）
* - const_id 取常量表 id（无则追加）
* - compile_if / compile_while / compile_fb_call / compile_fb_inline
* - store_target / compile_expr 左值存储 / 表达式编译
* - arith_name / cmp_name / load_name / store_name 操作码名选择
* - patch_jump 回填跳转偏移（相对下一条）
* - layout_data / layout_fb_instances / instance_of / init_of
* - const_id 取常量表 id（tag 来自配置类型表）
* - assemble_image 拼头 + 常量表 + 函数表 + 字节码 + 数据段
* - codegen_project 对外入口
*/
@@ -45,31 +39,15 @@
#include <string>
#include <vector>
#include "isa/Encode.h"
#include "isa/Image.h"
#include "isa/Instr.h"
#include "isa/Types.h"
#include "compiler/Codec.h"
#include "compiler/MachineConfig.h"
#include "compiler/Stb.h"
namespace compiler {
namespace {
// ---- 小端写入（Image.cpp 内部实现不可见，这里自带最小版）----
void put_le32(std::vector<uint8_t>& b, size_t off, uint32_t v) {
b[off + 0] = static_cast<uint8_t>(v & 0xFFu);
b[off + 1] = static_cast<uint8_t>((v >> 8) & 0xFFu);
b[off + 2] = static_cast<uint8_t>((v >> 16) & 0xFFu);
b[off + 3] = static_cast<uint8_t>((v >> 24) & 0xFFu);
}
void put_le64(std::vector<uint8_t>& b, size_t off, uint64_t v) {
for (int i = 0; i < 8; ++i) {
b[off + i] = static_cast<uint8_t>((v >> (8 * i)) & 0xFFu);
}
}
/**
* @brief 代码生成器（切片 1）
* @brief 代码生成器
*/
class Builder {
public:
@@ -78,14 +56,16 @@ namespace {
* @param proj 工程定义（cycle_limit / dt_ms / 哈希用）
* @param units 全部源文件的 AST
* @param link 链接结果（POU 顺序 / 符号）
* @param cfg 机器定义（machine.toml 强校验后；指令 opcode / 类型 tag / FB 布局）
* @param image 输出映像字节
* @param err 错误输出；可为 nullptr（静默）
*/
Builder(const Project& proj, const std::vector<SourceUnit>& units,
const LinkResult& link, std::vector<uint8_t>* image, std::string* err)
: proj_(proj), units_(units), link_(link), image_(image), err_(err) {
const LinkResult& link, const MachineConfig& cfg,
std::vector<uint8_t>* image, std::string* err)
: proj_(proj), units_(units), link_(link), cfg_(cfg), image_(image), err_(err) {
// io 绑定分类（名已折小写；不创造变量，只影响操作码选择）
for (const isa::IoBinding& b : proj_.io) {
for (const IoBinding& b : proj_.io) {
std::string key = b.var;
for (char& ch : key) {
ch = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
@@ -100,7 +80,6 @@ namespace {
/**
* @brief 布局数据区 → 布局 FB 实例 → 逐 POU 建函数 → 拼映像
* @details 偏移先定（函数编译引用 global_offset / instance_of）
* @return true 成功；false（err 已写，前缀 "codegen error"）
*/
bool run() {
@@ -127,11 +106,6 @@ namespace {
}
private:
/**
* @brief 组装错误消息并返回 false
* @param msg 错误描述（不含前缀）
* @return 恒 false
*/
bool fail(const std::string& msg) {
if (err_) {
*err_ = "codegen error: " + msg;
@@ -140,10 +114,42 @@ namespace {
}
/**
* @brief 按名查 POU AST
* @param name POU 名（小写）
* @return POU 指针；未找到返回 nullptr
* @brief 按名查配置 opcode（MachineConfig 强校验保证存在）
* @param name 指令名（大写，如 "ADD"）
* @return opcode（找不到返回 0，不应发生）
*/
uint8_t opc(const char* name) const {
const ConfigOp* op = cfg_.find_op(name);
return op ? static_cast<uint8_t>(op->opcode) : 0;
}
// ---- 指令发射（配置 opcode）----
Instr E_rr(const char* name, uint8_t rd, uint8_t rs) {
return pack(opc(name), rd, rs, 0);
}
Instr E_rrr(const char* name, uint8_t rd, uint8_t ra, uint8_t rb) {
return pack(opc(name), rd, ra, rb);
}
Instr E_imm(const char* name, uint8_t rd, uint16_t imm) {
return pack(opc(name), rd, static_cast<uint8_t>(imm & 0xFFu),
static_cast<uint8_t>((imm >> 8) & 0xFFu));
}
Instr E_slot(const char* name, uint8_t rd, uint16_t slot) {
return E_imm(name, rd, slot);
}
Instr E_jmp(int16_t off) {
const uint16_t u = static_cast<uint16_t>(off);
return pack(opc("JMP"), 0, static_cast<uint8_t>(u & 0xFFu),
static_cast<uint8_t>((u >> 8) & 0xFFu));
}
Instr E_jc(const char* name, uint8_t r, int16_t off) {
const uint16_t u = static_cast<uint16_t>(off);
return pack(opc(name), r, static_cast<uint8_t>(u & 0xFFu),
static_cast<uint8_t>((u >> 8) & 0xFFu));
}
Instr E_call(uint16_t fn_id) { return E_imm("CALL", 0, fn_id); }
Instr E_ret() { return pack(opc("RET"), 0, 0, 0); }
const POU* find_pou(const std::string& name) const {
for (const SourceUnit& u : units_) {
for (const POU& p : u.ast.pous) {
@@ -159,33 +165,24 @@ namespace {
struct FuncCtx {
std::string name;
std::string pou_name; // 所属 POU 名（实例查找键）
std::vector<isa::Instr> code; // 字节码（函数表 code_offset 相对此段）
std::vector<Instr> code; // 字节码
std::map<std::string, uint8_t> regs; // 变量名 → 帧寄存器
uint8_t nlocals = 0; // 变量区终点 = 临时寄存器起始
uint8_t nregs = 0; // 峰值（变量 + 临时）
uint8_t temp_used = 0; // 本语句已用临时数（语句结束清零）
bool is_function = false; // FUNCTION（结果 r0 / 输入只读）
std::string result_name; // FUNCTION 名（结果寄存器映射）
uint8_t nlocals = 0; // 变量区终点 = 临时寄存器起始
uint8_t nregs = 0; // 峰值（变量 + 临时）
uint8_t temp_used = 0; // 本语句已用临时数（语句结束清零）
bool is_function = false; // FUNCTION（结果 r0 / 输入只读）
std::string result_name; // FUNCTION 名（结果寄存器映射）
};
// FB 实例：字段名 → 数据区字节地址
// FB 实例：字段名 → 数据区槽号
struct InstFields {
std::map<std::string, uint32_t> field_addr;
uint32_t base = 0;
std::string type_name; // 实例的 FB 类型名（内建 / 用户）
};
/**
* @brief 语句开始：临时寄存器基址复用
* @param f 当前函数
*/
void begin_stmt(FuncCtx& f) { f.temp_used = 0; }
/**
* @brief 分配一个临时寄存器（语句内递增）
* @param f 当前函数
* @return 临时寄存器号（可能更新 nregs 峰值）
*/
uint8_t alloc_temp(FuncCtx& f) {
const uint8_t r = f.nlocals + f.temp_used;
++f.temp_used;
@@ -201,16 +198,12 @@ namespace {
* FB 不生成业务字节码（调用点内联），只出空函数占位保持 fn_id 一致；
* 帧约定（见 Doc/compiler/寄存器码.md）：结果 r0、输入 r1..r7（只读）、
* 变量与临时全部从 r8 起
* @param pou POU AST
* @param f 输出函数编译态
* @return true 成功；false（err 已写）
*/
bool build_function(const POU& pou, FuncCtx* f) {
if (pou.kind == PouKind::FunctionBlock) {
// FB 内联展开（见 compile_fb_call），此处只占 fn_id
f->nlocals = 8;
f->nregs = 8;
f->code.push_back(isa::enc_ret());
f->code.push_back(E_ret());
return true;
}
f->is_function = pou.kind == PouKind::Function;
@@ -229,16 +222,13 @@ namespace {
}
uint8_t r = 8; // 变量/临时基址（调用约定区 r0..r7 不占用）
for (const VarBlock& b : pou.blocks) {
// External / Global 走数据区槽，不占帧寄存器
if (b.section == VarSection::External || b.section == VarSection::Global) {
continue;
}
// FUNCTION 输入已分配（r1..r7）
if (f->is_function && b.section == VarSection::Input) {
continue;
}
for (const VarDecl& d : b.vars) {
// FB 实例走数据区（layout_fb_instances），不占帧寄存器
if (d.type.kind == TypeKind::FbUser || d.type.kind == TypeKind::FbBuiltin) {
continue;
}
@@ -253,16 +243,10 @@ namespace {
return false;
}
}
f->code.push_back(isa::enc_ret());
f->code.push_back(E_ret());
return true;
}
/**
* @brief 编译一条语句（切片 4：赋值 / IF）
* @param f 当前函数
* @param st 语句 AST
* @return true 成功；false（err 已写）
*/
bool compile_stmt(FuncCtx& f, const Stmt& st) {
if (st.kind == StmtKind::If) {
return compile_if(f, st);
@@ -274,7 +258,7 @@ namespace {
return compile_fb_call(f, st);
}
if (st.kind != StmtKind::Assign) {
return fail("statement not supported in slice 7");
return fail("statement not supported");
}
// 内联 FB 体内：左值可能是实例字段（STORE_GLOBAL）
if (inline_fields_) {
@@ -284,32 +268,20 @@ namespace {
if (!compile_expr(f, *st.value, t)) {
return false;
}
f.code.push_back(isa::enc_slot(isa::Op::STORE_GLOBAL, t, fit->second));
f.code.push_back(E_slot("STORE_GLOBAL", t, fit->second));
return true;
}
}
const auto it = f.regs.find(st.target);
if (it == f.regs.end()) {
// 全局 / 外部左值 → STORE_* 到数据区
return store_target(f, st.target, *st.value);
}
// 函数输入只读（调用约定，见 Doc/compiler/寄存器码.md）
if (f.is_function && it->second >= 1 && it->second <= 7) {
return fail("cannot write function input '" + st.target + "'");
}
const uint8_t rd = it->second;
return compile_expr(f, *st.value, rd);
return compile_expr(f, *st.value, it->second);
}
/**
* @brief 编译 FB 调用
* @details 实参求值到临时 → STORE_GLOBAL 到实例字段；
* 内建 TON/TOF/CTU → CAL_* <实例偏移>；
* 用户 FB → compile_fb_inline 内联展开
* @param f 当前函数
* @param st FbCall 语句 AST
* @return true 成功；false（err 已写）
*/
bool compile_fb_call(FuncCtx& f, const Stmt& st) {
const InstFields* inst = instance_of(f.pou_name, st.instance);
if (inst == nullptr) {
@@ -324,22 +296,15 @@ namespace {
if (!compile_expr(f, *a.value, t)) {
return false;
}
f.code.push_back(isa::enc_slot(isa::Op::STORE_GLOBAL, t, it->second));
f.code.push_back(E_slot("STORE_GLOBAL", t, it->second));
}
if (inst->type_name == "ton" || inst->type_name == "tof" ||
inst->type_name == "tp" || inst->type_name == "ctu" ||
inst->type_name == "ctd" || inst->type_name == "ctud" ||
inst->type_name == "r_trig" || inst->type_name == "f_trig") {
const isa::Op op =
inst->type_name == "ton" ? isa::Op::CAL_TON
: inst->type_name == "tof" ? isa::Op::CAL_TOF
: inst->type_name == "tp" ? isa::Op::CAL_TP
: inst->type_name == "ctu" ? isa::Op::CAL_CTU
: inst->type_name == "ctd" ? isa::Op::CAL_CTD
: inst->type_name == "ctud" ? isa::Op::CAL_CTUD
: inst->type_name == "r_trig" ? isa::Op::CAL_R_TRIG
: isa::Op::CAL_F_TRIG;
f.code.push_back(isa::enc_slot(op, 0, inst->base));
// 内建 FB：配置里必须有对应 op 行（强校验保证）→ 直接查配置 opcode
const std::string& tn = inst->type_name;
if (cfg_.find_op("CAL_" + uppercase_of(tn)) != nullptr &&
(tn == "ton" || tn == "tof" || tn == "tp" || tn == "ctu" ||
tn == "ctd" || tn == "ctud" || tn == "r_trig" || tn == "f_trig")) {
const std::string opname = "CAL_" + uppercase_of(tn);
f.code.push_back(E_slot(opname.c_str(), 0, inst->base));
return true;
}
const POU* fb = find_pou(inst->type_name);
@@ -349,15 +314,14 @@ namespace {
return compile_fb_inline(f, *fb, *inst);
}
/**
* @brief 内联编译用户 FB 体
* @details 切到实例字段上下文（VarRef/赋值左值映射到字段地址）；
* 表达式临时与调用方共用 r8+；字段读写全走 LOAD/STORE_GLOBAL
* @param f 当前函数
* @param fb FB 类型 POU
* @param inst 本实例字段表
* @return true 成功；false（err 已写）
*/
static std::string uppercase_of(const std::string& s) {
std::string out = s;
for (char& ch : out) {
ch = static_cast<char>(std::toupper(static_cast<unsigned char>(ch)));
}
return out;
}
bool compile_fb_inline(FuncCtx& f, const POU& fb, const InstFields& inst) {
const InstFields* saved = inline_fields_;
inline_fields_ = &inst;
@@ -371,14 +335,6 @@ namespace {
return true;
}
/**
* @brief 编译 WHILE
* @details L_loop: <cond→t> JF t, L_end <body> JMP L_loop L_end:
* 条件 JF 与回环 JMP 双回填
* @param f 当前函数
* @param st WHILE 语句 AST
* @return true 成功；false（err 已写）
*/
bool compile_while(FuncCtx& f, const Stmt& st) {
const size_t loop = f.code.size();
const uint8_t t = alloc_temp(f);
@@ -386,7 +342,7 @@ namespace {
return false;
}
const size_t jf_idx = f.code.size();
f.code.push_back(isa::enc_jc(isa::Op::JF, t, 0)); // 假 → L_end
f.code.push_back(E_jc("JF", t, 0));
for (const Stmt& s : st.body) {
begin_stmt(f);
if (!compile_stmt(f, s)) {
@@ -394,29 +350,20 @@ namespace {
}
}
const size_t jmp_idx = f.code.size();
f.code.push_back(isa::enc_jmp(0)); // 回环
f.code.push_back(E_jmp(0));
patch_jump(f, jmp_idx, loop);
patch_jump(f, jf_idx, f.code.size());
return true;
}
/**
* @brief 编译 IF / ELSIF / ELSE
* @details 每分支：<cond→t> JF t, L_next → <body> → JMP L_end；
* 最后一个分支无 else 时 JF 直接落 L_end（不补 JMP）
* @param f 当前函数
* @param st IF 语句 AST
* @return true 成功；false（err 已写）
*/
bool compile_if(FuncCtx& f, const Stmt& st) {
// 条件链：IF 体 + ELSIF 各体；ELSE 体可选
std::vector<std::pair<const Expr*, const std::vector<Stmt>*>> branches;
branches.push_back({st.cond.get(), &st.body});
for (const IfBranch& b : st.elsifs) {
branches.push_back({b.cond.get(), &b.body});
}
const bool has_else = !st.else_body.empty();
std::vector<size_t> end_jmps; // 各分支尾部 JMP（回填到 L_end）
std::vector<size_t> end_jmps;
for (size_t i = 0; i < branches.size(); ++i) {
const uint8_t t = alloc_temp(f);
@@ -424,7 +371,7 @@ namespace {
return false;
}
const size_t jf_idx = f.code.size();
f.code.push_back(isa::enc_jc(isa::Op::JF, t, 0)); // 假 → 下一分支
f.code.push_back(E_jc("JF", t, 0));
for (const Stmt& s : *branches[i].second) {
begin_stmt(f);
if (!compile_stmt(f, s)) {
@@ -433,10 +380,10 @@ namespace {
}
if (i + 1 < branches.size() || has_else) {
const size_t jmp_idx = f.code.size();
f.code.push_back(isa::enc_jmp(0)); // 分支尾部 → L_end
f.code.push_back(E_jmp(0));
end_jmps.push_back(jmp_idx);
}
patch_jump(f, jf_idx, f.code.size()); // 回填 JF 到下一分支起点
patch_jump(f, jf_idx, f.code.size());
}
if (has_else) {
for (const Stmt& s : st.else_body) {
@@ -453,13 +400,6 @@ namespace {
return true;
}
/**
* @brief 赋值左值：帧寄存器直写或 STORE_* 到全局槽
* @param f 当前函数
* @param target 左值名（全局 / 外部）
* @param value 右值表达式
* @return true 成功；false（err 已写）
*/
bool store_target(FuncCtx& f, const std::string& target, const Expr& value) {
const auto git = link_.global_index.find(target);
if (git == link_.global_index.end()) {
@@ -472,49 +412,36 @@ namespace {
if (!compile_expr(f, value, tmp)) {
return false;
}
const uint16_t slot = global_offset(git->second);
f.code.push_back(isa::enc_slot(store_op(target), tmp, slot));
f.code.push_back(E_slot(store_name(target), tmp, static_cast<uint16_t>(git->second)));
return true;
}
/**
* @brief 表达式编译到目标寄存器
* @details 字面量 → LOADK；帧变量 → MOVE；全局/外部 → LOAD_*（io.input 用 LOAD_I）；
* NOT → 求值后 NOT rd, t；AND/OR → 短路跳转（JF/JT 跳过右侧）
* @param f 当前函数
* @param e 表达式 AST
* @param rd 目标寄存器
* @return true 成功；false（err 已写）
*/
bool compile_expr(FuncCtx& f, const Expr& e, uint8_t rd) {
if (e.kind == ExprKind::LitBool || e.kind == ExprKind::LitInt ||
e.kind == ExprKind::LitTime) {
const isa::types::TypeTag tag =
e.kind == ExprKind::LitBool ? isa::types::Bool
: e.kind == ExprKind::LitInt ? isa::types::Int
: isa::types::Time;
f.code.push_back(
isa::enc_imm(isa::Op::LOADK, rd, const_id(tag, e.int_value)));
const char* type_name = e.kind == ExprKind::LitBool ? "BOOL"
: e.kind == ExprKind::LitInt ? "INT"
: "TIME";
f.code.push_back(E_imm("LOADK", rd, const_id(type_name, e.int_value)));
return true;
}
if (e.kind == ExprKind::VarRef) {
// 内联 FB 体内：字段优先（实例字段为变量）
if (inline_fields_) {
const auto fit = inline_fields_->field_addr.find(e.name);
if (fit != inline_fields_->field_addr.end()) {
f.code.push_back(isa::enc_slot(isa::Op::LOAD_GLOBAL, rd, fit->second));
f.code.push_back(E_slot("LOAD_GLOBAL", rd, fit->second));
return true;
}
}
const auto sit = f.regs.find(e.name);
if (sit != f.regs.end()) {
f.code.push_back(isa::enc_rr(isa::Op::MOVE, rd, sit->second));
f.code.push_back(E_rr("MOVE", rd, sit->second));
return true;
}
const auto git = link_.global_index.find(e.name);
if (git != link_.global_index.end()) {
const uint16_t slot = global_offset(git->second);
f.code.push_back(isa::enc_slot(load_op(e.name), rd, slot));
f.code.push_back(
E_slot(load_name(e.name), rd, static_cast<uint16_t>(git->second)));
return true;
}
return fail("no register or slot for '" + e.name + "'");
@@ -528,7 +455,7 @@ namespace {
if (fit == inst->field_addr.end()) {
return fail("unknown field '" + e.field + "' for '" + e.name + "'");
}
f.code.push_back(isa::enc_slot(isa::Op::LOAD_GLOBAL, rd, fit->second));
f.code.push_back(E_slot("LOAD_GLOBAL", rd, fit->second));
return true;
}
if (e.kind == ExprKind::Add || e.kind == ExprKind::Sub ||
@@ -541,7 +468,7 @@ namespace {
if (!compile_expr(f, *e.rhs, r)) {
return false;
}
f.code.push_back(isa::enc_rrr(arith_op(e.kind), rd, l, r));
f.code.push_back(E_rrr(arith_name(e.kind), rd, l, r));
return true;
}
if (e.kind == ExprKind::Cmp) {
@@ -553,7 +480,7 @@ namespace {
if (!compile_expr(f, *e.rhs, r)) {
return false;
}
f.code.push_back(isa::enc_rrr(cmp_op(e.op), rd, l, r));
f.code.push_back(E_rrr(cmp_name(e.op), rd, l, r));
return true;
}
if (e.kind == ExprKind::Not) {
@@ -561,27 +488,25 @@ namespace {
if (!compile_expr(f, *e.operand, t)) {
return false;
}
f.code.push_back(isa::enc_rr(isa::Op::NOT, rd, t));
f.code.push_back(E_rr("NOT", rd, t));
return true;
}
if (e.kind == ExprKind::And || e.kind == ExprKind::Or) {
// 短路：左侧结果在 rd；AND 为假 / OR 为真时跳过右侧
if (!compile_expr(f, *e.lhs, rd)) {
return false;
}
const isa::Op jop = (e.kind == ExprKind::And) ? isa::Op::JF : isa::Op::JT;
const char* jname = (e.kind == ExprKind::And) ? "JF" : "JT";
const size_t jmp_idx = f.code.size();
f.code.push_back(isa::enc_jc(jop, rd, 0)); // 偏移留洞，稍后回填
f.code.push_back(E_jc(jname, rd, 0));
const uint8_t t = alloc_temp(f);
if (!compile_expr(f, *e.rhs, t)) {
return false;
}
f.code.push_back(isa::enc_rr(isa::Op::MOVE, rd, t));
f.code.push_back(E_rr("MOVE", rd, t));
patch_jump(f, jmp_idx, f.code.size());
return true;
}
if (e.kind == ExprKind::Call) {
// 调用约定：实参求值到 r8+ 临时 → MOVE 到 r1..r7 → CALL → 结果 r0
if (e.args.size() > 7) {
return fail("too many arguments (max 7)");
}
@@ -598,21 +523,15 @@ namespace {
return fail("no fn_id for '" + e.name + "'");
}
for (size_t i = 0; i < args.size(); ++i) {
f.code.push_back(
isa::enc_rr(isa::Op::MOVE, static_cast<uint8_t>(1 + i), args[i]));
f.code.push_back(E_rr("MOVE", static_cast<uint8_t>(1 + i), args[i]));
}
f.code.push_back(isa::enc_call(static_cast<uint16_t>(fn_id)));
f.code.push_back(isa::enc_rr(isa::Op::MOVE, rd, 0));
f.code.push_back(E_call(static_cast<uint16_t>(fn_id)));
f.code.push_back(E_rr("MOVE", rd, 0));
return true;
}
return fail("expression not supported in slice 6");
return fail("expression not supported");
}
/**
* @brief 按名查 fn_id（POU 收集序下标）
* @param name POU 名（小写）
* @return fn_id；未找到返回 -1
*/
int find_fn_id(const std::string& name) const {
for (size_t i = 0; i < link_.scopes.size(); ++i) {
if (link_.scopes[i].name == name) {
@@ -622,87 +541,43 @@ namespace {
return -1;
}
/**
* @brief 回填跳转偏移（相对下一条指令）
* @param f 当前函数
* @param idx 跳转指令下标（占位）
* @param target_idx 目标指令下标
*/
void patch_jump(FuncCtx& f, size_t idx, size_t target_idx) {
const int16_t off = static_cast<int16_t>(
static_cast<int64_t>(target_idx) - (static_cast<int64_t>(idx) + 1));
const isa::Instr w = f.code[idx];
f.code[idx] = isa::pack(isa::op(w), isa::rd(w),
static_cast<uint8_t>(static_cast<uint16_t>(off) & 0xFFu),
static_cast<uint8_t>((static_cast<uint16_t>(off) >> 8) & 0xFFu));
const Instr w = f.code[idx];
const uint16_t u = static_cast<uint16_t>(off);
f.code[idx] = pack(op_of(w), rd_of(w), static_cast<uint8_t>(u & 0xFFu),
static_cast<uint8_t>((u >> 8) & 0xFFu));
}
/**
* @brief 算术运算 → 操作码
* @param k 表达式种类（Add/Sub/Mul/Div）
* @return 对应操作码
*/
isa::Op arith_op(ExprKind k) const {
// ---- 操作码名（MachineConfig 已强校验存在）----
static const char* arith_name(ExprKind k) {
switch (k) {
case ExprKind::Add: return isa::Op::ADD;
case ExprKind::Sub: return isa::Op::SUB;
case ExprKind::Mul: return isa::Op::MUL;
case ExprKind::Div: return isa::Op::DIV;
default: return isa::Op::ADD;
case ExprKind::Add: return "ADD";
case ExprKind::Sub: return "SUB";
case ExprKind::Mul: return "MUL";
case ExprKind::Div: return "DIV";
default: return "ADD";
}
}
/**
* @brief 比较符 → CMP_xx 操作码
* @param op 比较运算
* @return 对应操作码（CMP_EQ / CMP_NE / CMP_LT / CMP_LE / CMP_GT / CMP_GE）
*/
isa::Op cmp_op(BinOp op) const {
static const char* cmp_name(BinOp op) {
switch (op) {
case BinOp::Eq: return isa::Op::CMP_EQ;
case BinOp::Ne: return isa::Op::CMP_NE;
case BinOp::Lt: return isa::Op::CMP_LT;
case BinOp::Le: return isa::Op::CMP_LE;
case BinOp::Gt: return isa::Op::CMP_GT;
case BinOp::Ge: return isa::Op::CMP_GE;
default: return isa::Op::CMP_EQ; // Add/Sub/Mul/Div 不经此函数
case BinOp::Eq: return "CMP_EQ";
case BinOp::Ne: return "CMP_NE";
case BinOp::Lt: return "CMP_LT";
case BinOp::Le: return "CMP_LE";
case BinOp::Gt: return "CMP_GT";
case BinOp::Ge: return "CMP_GE";
default: return "CMP_EQ";
}
}
/**
* @brief 按 io 绑定选读取操作码
* @param name 变量名（小写）
* @return io.input 绑定 → LOAD_I；否则 LOAD_GLOBAL
*/
isa::Op load_op(const std::string& name) const {
return io_input_.count(name) ? isa::Op::LOAD_I : isa::Op::LOAD_GLOBAL;
const char* load_name(const std::string& name) const {
return io_input_.count(name) ? "LOAD_I" : "LOAD_GLOBAL";
}
const char* store_name(const std::string& name) const {
return io_output_.count(name) ? "STORE_Q" : "STORE_GLOBAL";
}
/**
* @brief 按 io 绑定选写入操作码
* @param name 变量名（小写）
* @return io.output 绑定 → STORE_Q；否则 STORE_GLOBAL
*/
isa::Op store_op(const std::string& name) const {
return io_output_.count(name) ? isa::Op::STORE_Q : isa::Op::STORE_GLOBAL;
}
/**
* @brief 逻辑槽号（符号表 address）即指令 slot（方案 a：8 字节定宽，无映射）
* @param slot 全局逻辑槽号
* @return 同值（u16 可容，layout_data 已校验）
*/
uint16_t global_offset(uint32_t slot) const {
return static_cast<uint16_t>(slot);
}
/**
* @brief 布局全局数据区：每槽 8 字节定宽（方案 a）
* @details 槽号 = 符号表 address（声明序，12.6）；
* BOOL 用低 1 字节、INT 用低 2 字节（小端）、TIME 全 8 字节；
* 初值取自 GVL 声明的 has_init（无则 0）
* @return true 成功；false（槽号越界，err 已写）
*/
bool layout_data() {
for (const Symbol& s : link_.globals) {
if (s.address > 0xFFFF) {
@@ -714,30 +589,33 @@ namespace {
const int64_t v = has_init ? init : 0;
const size_t off = static_cast<size_t>(s.address) * 8;
data_.resize(off + 8, 0);
if (s.type_name == "int") {
// 初值按基元宽度写（类型元数据来自配置别名 → base）
const ConfigType* ct = cfg_.find_type(uppercase_of(s.type_name));
if (ct == nullptr) {
return fail("no type in machine.toml for '" + s.type_name + "'");
}
const PrimType* prim = MachineConfig::find_prim(ct->base);
if (prim == nullptr) {
return fail("no prim '" + ct->base + "' for type '" + ct->name + "'");
}
if (prim->width == 2 && !prim->is_float) {
const uint16_t iv = static_cast<uint16_t>(v);
data_[off] = static_cast<uint8_t>(iv & 0xFFu);
data_[off + 1] = static_cast<uint8_t>((iv >> 8) & 0xFFu);
} else if (s.type_name == "time") {
} else if (prim->width >= 8 && !prim->is_float) {
const uint64_t tv = static_cast<uint64_t>(v);
for (int i = 0; i < 8; ++i) {
data_[off + i] = static_cast<uint8_t>((tv >> (8 * i)) & 0xFFu);
}
} else { // bool
} else {
data_[off] = v ? 1 : 0;
}
}
return true;
}
/**
* @brief 布局 FB 实例块：数据区全局之后，按 POU 收集序 / 实例声明序
* @details 每实例：字段按布局段序各占一槽（8 字节定宽），
* 字段地址 = 实例基槽 + 字段序号；实例基槽 = 累计槽数
* @return true 成功；false（err 已写）
*/
bool layout_fb_instances() {
uint32_t cur = static_cast<uint32_t>(data_.size() / 8); // 槽号起点
uint32_t cur = static_cast<uint32_t>(data_.size() / 8);
bool any = false;
for (const LinkResult::PouScope& sc : link_.scopes) {
for (const Symbol& s : sc.syms) {
@@ -749,7 +627,7 @@ namespace {
return fail("no layout for instance '" + s.name + "'");
}
InstFields inst;
inst.base = cur; // 实例基槽（CAL_* 操作数）
inst.base = cur;
inst.type_name = s.type_name;
for (size_t i = 0; i < lay->second.fields.size(); ++i) {
inst.field_addr[lay->second.fields[i].name] = cur + i;
@@ -759,31 +637,18 @@ namespace {
any = true;
}
}
// 仅在有实例时把数据区补到实例区终点（无实例则保持全局区原样）
if (any) {
data_.resize(static_cast<size_t>(cur) * 8, 0);
}
return true;
}
/**
* @brief 按 POU + 实例名查实例字段表
* @param pou POU 名
* @param name 实例名
* @return 实例字段表指针；未找到返回 nullptr
*/
const InstFields* instance_of(const std::string& pou,
const std::string& name) const {
const auto it = instances_.find(pou + "/" + name);
return it == instances_.end() ? nullptr : &it->second;
}
/**
* @brief 查全局声明的初值（AST；gvl 文件顶层段，声明序 = 槽号序）
* @param name 全局名（小写）
* @param has_init 输出是否有初值
* @param init 输出初值
*/
void init_of(const std::string& name, bool* has_init, int64_t* init) const {
for (const SourceUnit& u : units_) {
for (const VarBlock& b : u.ast.globals) {
@@ -802,11 +667,13 @@ namespace {
/**
* @brief 取常量表 id（无则追加）
* @param tag 类型标记（BOOL/INT/TIME）
* @param type_name 语言类型名（"BOOL"/"INT"/"TIME"）→ 配置 tag（契约）
* @param value 常量值
* @return const_id（u16）
*/
uint16_t const_id(isa::types::TypeTag tag, int64_t value) {
uint16_t const_id(const char* type_name, int64_t value) {
const ConfigType* ct = cfg_.find_type(type_name);
const uint32_t tag = ct ? ct->tag : 0;
for (size_t i = 0; i < consts_.size(); ++i) {
if (consts_[i].tag == tag && consts_[i].value == static_cast<uint64_t>(value)) {
return static_cast<uint16_t>(i);
@@ -816,18 +683,12 @@ namespace {
return static_cast<uint16_t>(consts_.size() - 1);
}
/**
* @brief 拼映像：头 + 常量表 + 函数表 + 字节码 + 数据段
* @details 段序：const → funcs → code → fb（空）→ data；
* 数据段放全局初值（layout_data 已生成字节）
* @return true 成功；false（err 已写）
*/
bool assemble_image() {
const uint32_t off_const = isa::kHeaderSize;
const uint32_t off_const = static_cast<uint32_t>(kHeaderSize);
const uint32_t off_funcs = off_const +
static_cast<uint32_t>(consts_.size()) * isa::kConstEntrySize;
static_cast<uint32_t>(consts_.size()) * static_cast<uint32_t>(kConstEntrySize);
uint32_t off_code = off_funcs +
static_cast<uint32_t>(funcs_.size()) * isa::kFuncRowSize;
static_cast<uint32_t>(funcs_.size()) * static_cast<uint32_t>(kFuncRowSize);
uint32_t code_total = 0;
for (const FuncCtx& f : funcs_) {
code_total += static_cast<uint32_t>(f.code.size()) * 4;
@@ -837,12 +698,12 @@ namespace {
std::vector<uint8_t>& b = *image_;
b.assign(off_end, 0);
put_le32(b, 0, isa::kMagic);
put_le32(b, 4, isa::kVersion);
put_le32(b, 0, kMagic);
put_le32(b, 4, kVersion);
put_le32(b, 8, proj_.cycle_limit);
put_le32(b, 12, proj_.dt_ms);
uint64_t hash = isa::kFnvBasis;
uint64_t hash = kFnvBasis;
if (!compute_project_hash(proj_, &hash, err_)) {
return false;
}
@@ -855,80 +716,82 @@ namespace {
}
}
put_le32(b, 24, entry);
put_le32(b, 28, static_cast<uint32_t>(link_.globals.size())); // n_globals
put_le32(b, 32, 0); // n_i
put_le32(b, 36, 0); // n_q
put_le32(b, 40, 0); // n_m
put_le32(b, 28, static_cast<uint32_t>(link_.globals.size()));
put_le32(b, 32, 0);
put_le32(b, 36, 0);
put_le32(b, 40, 0);
put_le32(b, 44, static_cast<uint32_t>(consts_.size()));
put_le32(b, 48, static_cast<uint32_t>(funcs_.size()));
put_le32(b, 52, off_const);
put_le32(b, 56, off_funcs);
put_le32(b, 60, off_code);
put_le32(b, 64, off_data); // offset_fb（空，与数据段起点相同）
put_le32(b, 68, off_data); // offset_data
put_le32(b, 64, off_data);
put_le32(b, 68, off_data);
for (size_t i = 0; i < consts_.size(); ++i) {
const size_t o = off_const + i * isa::kConstEntrySize;
put_le32(b, o, static_cast<uint32_t>(consts_[i].tag));
const size_t o = off_const + i * kConstEntrySize;
put_le32(b, o, consts_[i].tag);
put_le64(b, o + 4, consts_[i].value);
}
uint32_t c = off_code;
for (size_t i = 0; i < funcs_.size(); ++i) {
const FuncCtx& f = funcs_[i];
const size_t o = off_funcs + i * isa::kFuncRowSize;
const size_t o = off_funcs + i * kFuncRowSize;
put_le32(b, o, f.nregs);
put_le32(b, o + 8, static_cast<uint32_t>(f.code.size()));
for (const isa::Instr in : f.code) {
for (const Instr in : f.code) {
put_le32(b, c, in);
c += 4;
}
}
// code_offset 回填（相对字节码段起点）
uint32_t acc = 0;
for (size_t i = 0; i < funcs_.size(); ++i) {
const size_t o = off_funcs + i * isa::kFuncRowSize;
const size_t o = off_funcs + i * kFuncRowSize;
put_le32(b, o + 4, acc);
acc += static_cast<uint32_t>(funcs_[i].code.size()) * 4;
}
// 数据段：全局初值字节
for (size_t i = 0; i < data_.size(); ++i) {
b[off_data + i] = data_[i];
}
return true;
}
static void put_le32(std::vector<uint8_t>& b, size_t off, uint32_t v) {
b[off + 0] = static_cast<uint8_t>(v & 0xFFu);
b[off + 1] = static_cast<uint8_t>((v >> 8) & 0xFFu);
b[off + 2] = static_cast<uint8_t>((v >> 16) & 0xFFu);
b[off + 3] = static_cast<uint8_t>((v >> 24) & 0xFFu);
}
static void put_le64(std::vector<uint8_t>& b, size_t off, uint64_t v) {
for (int i = 0; i < 8; ++i) {
b[off + i] = static_cast<uint8_t>((v >> (8 * i)) & 0xFFu);
}
}
// ---- 成员 ----
const Project& proj_;
const std::vector<SourceUnit>& units_;
const LinkResult& link_;
const MachineConfig& cfg_;
std::vector<uint8_t>* image_;
std::string* err_;
std::vector<FuncCtx> funcs_;
std::vector<isa::ConstEntry> consts_;
std::map<std::string, bool> io_input_; // io.input 绑定名（小写）
std::map<std::string, bool> io_output_; // io.output 绑定名（小写）
std::vector<uint8_t> data_; // 数据区（8 字节定宽槽：全局 + FB 实例块）
std::map<std::string, InstFields> instances_; // "POU/实例名" → 字段槽号
const InstFields* inline_fields_ = nullptr; // 内联 FB 体字段上下文（可空）
std::vector<ConstEntry> consts_;
std::map<std::string, bool> io_input_;
std::map<std::string, bool> io_output_;
std::vector<uint8_t> data_;
std::map<std::string, InstFields> instances_;
const InstFields* inline_fields_ = nullptr;
};
} // namespace
/**
* @brief 编译工程为 .stb 映像字节（对外入口）
* @param proj 工程定义
* @param units 全部源文件的 AST
* @param link 链接结果（在类型检查成功后调用）
* @param image 输出映像字节
* @param err 错误输出；可为 nullptr（静默）
* @return true 成功；false 失败（err 前缀 "codegen error"）
*/
bool codegen_project(const Project& proj, const std::vector<SourceUnit>& units,
const LinkResult& link, std::vector<uint8_t>* image,
std::string* err) {
Builder b(proj, units, link, image, err);
const LinkResult& link, const MachineConfig& cfg,
std::vector<uint8_t>* image, std::string* err) {
Builder b(proj, units, link, cfg, image, err);
return b.run();
}