diff --git a/compiler/include/compiler/Stb.h b/compiler/include/compiler/Stb.h index 42c3bc6..1803f39 100644 --- a/compiler/include/compiler/Stb.h +++ b/compiler/include/compiler/Stb.h @@ -1,12 +1,13 @@ /** * @file Stb.h - * @brief 编译器自带的 .stb 映像规范（写侧）+ 只读视图 + FNV-1a + * @brief 编译器自带的 .stb 映像规范（写侧，V2）+ 只读视图 + FNV-1a * @author * @date 2026-08-21 * - * @details 执行器（vm）各有自己的读写实现；格式契约见 Doc/isa/指令与映像.md。 - * 12.13 修订：头 104 = 原 72 + 型号标识[32] @72，文件尾 SHA-256[32]。 - * 常量表 tag 契约：0=BOOL、1=INT、2=TIME；工程哈希用 FNV-1a 64。 + * @details 执行器（vm）各有自己的读写实现；格式契约见 Doc/isa/指令与映像.md（V2）。 + * V2：头 128B（version=2、型号标识 STATOR2 @72、n_slots/values_size/offset_meta/max_stack）， + * 常量表 8B/条（无 tag，LOADK 按 func 解释），槽表段 8B/条 {addr,预留}， + * 值段变宽紧凑；文件尾 SHA-256[32]；工程哈希 FNV-1a 64。 */ #pragma once @@ -20,17 +21,19 @@ namespace compiler { - // ---- .stb 格式常量（契约；12.13 修订：头 104 = 原 72 + 型号标识[32]，文件尾 SHA-256[32]）---- + // ---- .stb 格式常量（V2 契约；头 128 = 原 72 字段 + 型号标识[32]@72 + 新增 24）---- /// 映像魔数："STSC" 小端。 static const uint32_t kMagic = 0x43545353u; - /// 映像格式版本。 - static const uint32_t kVersion = 1; - /// 映像头字节数（原 72 字段 + 型号标识[32] @72）。 - static const size_t kHeaderSize = 104; - /// 常量表一行字节数（tag:4 + value:8）。 - static const size_t kConstEntrySize = 12; + /// 映像格式版本（V2）。 + static const uint32_t kVersion = 2; + /// 映像头字节数（V2）。 + static const size_t kHeaderSize = 128; + /// 常量表一行字节数（8B 原始值，无 tag）。 + static const size_t kConstEntrySize = 8; /// 函数表一行字节数（nregs / code_offset / code_len 各 4）。 static const size_t kFuncRowSize = 12; + /// 槽表一行字节数（addr:4 + 预留:4）。 + static const size_t kSlotRowSize = 8; /// SHA-256 摘要长度（文件尾）。 static const size_t kSha256Size = 32; /// 型号标识长度（头内 @72，不足补 '\0'）。 @@ -40,49 +43,54 @@ namespace compiler { /// FNV-1a 64 哈希素数。 static const uint64_t kFnvPrime = 0x100000001b3ull; - // ---- 头字段偏移（与 Doc/isa/指令与映像.md 字段表一致；vm 侧另有同值一份）---- + // ---- 头字段偏移（与 Doc/isa/指令与映像.md §8.1 字段表一致；vm 侧另有同值一份）---- inline constexpr size_t kOffMagic = 0; ///< 魔数 "STSC" - inline constexpr size_t kOffVersion = 4; ///< 格式版本 + inline constexpr size_t kOffVersion = 4; ///< 格式版本（V2 = 2） inline constexpr size_t kOffCycleLimit = 8; ///< 每周期指令数上限 inline constexpr size_t kOffDtMs = 12; ///< 周期时长（毫秒） inline constexpr size_t kOffProjectHash = 16; ///< 工程哈希（8 字节） inline constexpr size_t kOffEntryFnId = 24; ///< 入口函数 fn_id inline constexpr size_t kOffNGlobals = 28; ///< 全局槽数 - inline constexpr size_t kOffNI = 32; ///< 输入（I）槽数 - inline constexpr size_t kOffNQ = 36; ///< 输出（Q）槽数 - inline constexpr size_t kOffNM = 40; ///< 中间（M）槽数 + inline constexpr size_t kOffNI = 32; ///< 输入（I）槽数（保留恒 0） + inline constexpr size_t kOffNQ = 36; ///< 输出（Q）槽数（保留恒 0） + inline constexpr size_t kOffNM = 40; ///< 中间（M）槽数（保留恒 0） inline constexpr size_t kOffNConsts = 44; ///< 常量表条目数 inline constexpr size_t kOffNFuncs = 48; ///< 函数表行数 inline constexpr size_t kOffConst = 52; ///< 常量表段偏移 inline constexpr size_t kOffFuncs = 56; ///< 函数表段偏移 - inline constexpr size_t kOffCode = 60; ///< 字节码段偏移 - inline constexpr size_t kOffFb = 64; ///< FB 表段偏移 - inline constexpr size_t kOffData = 68; ///< 数据段偏移 - inline constexpr size_t kOffModelId = 72; ///< 型号标识[32]（12.13 修订） + inline constexpr size_t kOffCode = 60; ///< 字节码段偏移（16 对齐） + inline constexpr size_t kOffSlots = 64; ///< 槽表段偏移 + inline constexpr size_t kOffValues = 68; ///< 值段偏移（16 对齐） + inline constexpr size_t kOffModelId = 72; ///< 型号标识[32]（V2 = "STATOR2"） + inline constexpr size_t kOffNSlots = 104; ///< 槽表条目数（= n_globals + 实例槽数） + inline constexpr size_t kOffValuesSize = 108; ///< 值段字节数 + inline constexpr size_t kOffMeta = 112; ///< 元数据段偏移（v1 = 0 空段） + inline constexpr size_t kOffMaxStack = 116; ///< 栈区字节数（编译期算） // ---- 段内行偏移 ---- - inline constexpr size_t kConstTagOff = 0; ///< 常量表行内：tag - inline constexpr size_t kConstValueOff = 4; ///< 常量表行内：value（8 字节） - inline constexpr size_t kFuncNregsOff = 0; ///< 函数表行内：nregs - inline constexpr size_t kFuncCodeOff = 4; ///< 函数表行内：code_offset（字节） - inline constexpr size_t kFuncLenOff = 8; ///< 函数表行内：code_len（指令条数） + inline constexpr size_t kConstValueOff = 0; ///< 常量表行内：value（8 字节，无 tag） + inline constexpr size_t kFuncNregsOff = 0; ///< 函数表行内：nregs + inline constexpr size_t kFuncCodeOff = 4; ///< 函数表行内：code_offset（字节） + inline constexpr size_t kFuncLenOff = 8; ///< 函数表行内：code_len（字节） + inline constexpr size_t kSlotAddrOff = 0; ///< 槽表行内：addr（值段内偏移） + inline constexpr size_t kSlotPadOff = 4; ///< 槽表行内：预留 - // 防漂移：头布局自洽性（与 Doc/isa/指令与映像.md 冻结表核对） - static_assert(kHeaderSize == kOffModelId + kModelIdSize, "header size = 72 + model id[32]"); - static_assert(kOffData > kOffFb && kOffFb > kOffCode && kOffCode > kOffFuncs && + // 防漂移：头布局自洽性（与 Doc/isa/指令与映像.md §8.1 冻结表核对） + static_assert(kHeaderSize == kOffModelId + kModelIdSize + 24, "header = 72 + model id + 24"); + static_assert(kOffValues > kOffSlots && kOffSlots > kOffCode && kOffCode > kOffFuncs && kOffFuncs > kOffConst, "header field offsets monotonic"); - static_assert(kOffModelId == kOffData + 4, "model id follows data offset field"); - static_assert(kConstEntrySize == kConstValueOff + 8, "const row: tag + value:8"); + static_assert(kOffModelId == kOffValues + 4, "model id follows values offset field"); + static_assert(kOffMaxStack == kOffMeta + 4, "max_stack follows meta offset"); + static_assert(kConstEntrySize == 8, "const row: value:8 (no tag)"); static_assert(kFuncRowSize == kFuncLenOff + 4, "func row: nregs/code_offset/code_len"); + static_assert(kSlotRowSize == kSlotPadOff + 4, "slot row: addr + pad"); /** - * @brief 常量表一行。 - * @details tag 契约：0=BOOL、1=INT、2=TIME。 + * @brief 常量表一行（8B 原始值，无 tag——LOADK 按 func 位段解释）。 */ struct ConstEntry { - uint32_t tag = 0; ///< 类型 tag（0=BOOL、1=INT、2=TIME） - uint64_t value = 0; ///< 常量值 + uint64_t value = 0; ///< 原始位模式 }; /** @@ -110,7 +118,7 @@ namespace compiler { void sha256(const uint8_t* data, size_t len, uint8_t out[kSha256Size]); /** - * @brief 型号标识：name + version 拼 32 字节 ASCII（如 "STATOR1"）。 + * @brief 型号标识：name + version 拼 32 字节 ASCII（如 "STATOR2"）。 * @param name 型号名 * @param version 版本号 * @param out 32 字节输出缓冲 @@ -119,17 +127,17 @@ namespace compiler { void fill_model_id(const std::string& name, uint32_t version, char out[kModelIdSize]); /** - * @brief .stb 映像只读视图（--disasm 用）。 + * @brief .stb 映像只读视图（--disasm 用，V2）。 * @details from() 时校验魔数/版本/段边界，之后各访问器只读； * 失败时 ok() == false，error() 取原因。 */ class StbView { public: - /// @brief 函数表一行（nregs / code_offset / code_len）。 + /// @brief 函数表一行（nregs / code_offset / code_len，均字节）。 struct FuncRow { uint32_t nregs = 0; ///< 帧寄存器数（含变量与临时） - uint32_t code_offset = 0; ///< 字节码段内偏移（4 字节对齐） - uint32_t code_len = 0; ///< 指令条数 + uint32_t code_offset = 0; ///< 字节码段内偏移（字节） + uint32_t code_len = 0; ///< 字节码长度（字节，变长指令） }; /// 从原始字节构造（不拷贝，调用方保证生命周期）。 @@ -158,12 +166,20 @@ namespace compiler { uint32_t n_funcs() const { return n_funcs_; } /// 字节码段偏移（头 @60）。 uint32_t offset_code() const { return offset_code_; } - /// 数据段（FB 区）偏移（头 @64；即字节码段终点）。 - uint32_t offset_fb() const { return offset_fb_; } - /// 数据段偏移（头 @68）。 - uint32_t offset_data() const { return offset_data_; } + /// 槽表段偏移（头 @64）。 + uint32_t offset_slots() const { return offset_slots_; } + /// 值段偏移（头 @68）。 + uint32_t offset_values() const { return offset_values_; } + /// 槽表条目数（头 @104）。 + uint32_t n_slots() const { return n_slots_; } + /// 值段字节数（头 @108）。 + uint32_t values_size() const { return values_size_; } + /// 元数据段偏移（头 @112；0 = 空段）。 + uint32_t offset_meta() const { return offset_meta_; } + /// 栈区字节数（头 @116）。 + uint32_t max_stack() const { return max_stack_; } - /// 读常量表一行；越界时返回全 0。 + /// 读常量表一行（8B 原始值）；越界时返回全 0。 ConstEntry const_entry(size_t i) const; /// 读函数表一行；越界时返回全 0。 FuncRow func_row(size_t i) const; @@ -171,39 +187,45 @@ namespace compiler { const uint8_t* code_bytes() const; /// 字节码段字节数。 size_t code_len() const; - /// 数据段起点。 + /// 槽表段起点。 + const uint8_t* slots_bytes() const; + /// 值段起点。 const uint8_t* data_bytes() const; - /// 数据段字节数（不含文件尾 SHA-256）。 + /// 值段字节数（不含文件尾 SHA-256）。 size_t data_len() const; /// 型号标识字符串（头 72..103，截断到首个 '\0'）。 - std::string model_id() const; // 头 72..103（补 '\0' 后字符串） + std::string model_id() const; /// 型号标识是否匹配 name + version。 bool model_matches(const std::string& name, uint32_t version) const; /// 文件尾 32 字节 SHA-256 校验（对文件尾之前全部内容重算）。 - bool sha_ok() const; // 文件尾 32 字节 SHA-256 校验 + bool sha_ok() const; private: /// 私有构造（只能经 from() 创建）。 StbView() : buf_(0), len_(0) {} /// 常量表偏移（from 已校验的段起点）。 - uint32_t offs_of_const() const; // offset_const（from 已校验段起点） + uint32_t offs_of_const() const; - const uint8_t* buf_; ///< 映像缓冲（不拥有） - size_t len_; ///< 缓冲字节数 - bool ok_ = false; ///< 解析成功标志 - std::string err_; ///< 失败原因 - uint32_t cycle_limit_ = 0; ///< 周期上限 - uint32_t dt_ms_ = 0; ///< 扫描周期 - uint64_t project_hash_ = 0; ///< 工程哈希 - uint32_t entry_fn_id_ = 0; ///< 入口函数 fn_id - uint32_t n_globals_ = 0; ///< 全局槽数 - uint32_t n_consts_ = 0; ///< 常量表行数 - uint32_t n_funcs_ = 0; ///< 函数表行数 - uint32_t offset_code_ = 0; ///< 字节码段偏移 - uint32_t offset_fb_ = 0; ///< 数据段（FB 区）偏移 - uint32_t offset_data_ = 0; ///< 数据段偏移 + const uint8_t* buf_; ///< 映像缓冲（不拥有） + size_t len_; ///< 缓冲字节数 + bool ok_ = false; ///< 解析成功标志 + std::string err_; ///< 失败原因 + uint32_t cycle_limit_ = 0; ///< 周期上限 + uint32_t dt_ms_ = 0; ///< 扫描周期 + uint64_t project_hash_ = 0; ///< 工程哈希 + uint32_t entry_fn_id_ = 0; ///< 入口函数 fn_id + uint32_t n_globals_ = 0; ///< 全局槽数 + uint32_t n_consts_ = 0; ///< 常量表行数 + uint32_t n_funcs_ = 0; ///< 函数表行数 + uint32_t offset_code_ = 0; ///< 字节码段偏移 + uint32_t offset_slots_ = 0; ///< 槽表段偏移 + uint32_t offset_values_ = 0; ///< 值段偏移 + uint32_t n_slots_ = 0; ///< 槽表条目数 + uint32_t values_size_ = 0; ///< 值段字节数 + uint32_t offset_meta_ = 0; ///< 元数据段偏移（0 = 空段） + uint32_t max_stack_ = 0; ///< 栈区字节数 }; /** diff --git a/compiler/src/Codegen.cpp b/compiler/src/Codegen.cpp index 620a7a3..6d46add 100644 --- a/compiler/src/Codegen.cpp +++ b/compiler/src/Codegen.cpp @@ -1,40 +1,35 @@ /** * @file Codegen.cpp - * @brief 寄存器码生成（配置驱动；compiler 不依赖 isa） + * @brief 寄存器码生成（V2：配置驱动 + 变长指令；compiler 不依赖 isa） * @author * @date 2026-08-21 * - * @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 = 槽号 + * @details 设计说明（详见 Doc/compiler/寄存器码.md 与 Doc/isa/指令与映像.md V2）： + * - 指令 prefix/op/func 全部来自 machine.toml（MachineConfig）；发射经 Codec 位号 + * - 数据模型：槽表（8B 引用 {addr,预留}）→ 值段（变宽紧凑，1/2/4/8 对齐） + * - 常量表 8B 原始值（无 tag），LOADK 按 func 解释，位模式去重 + * - 跳转回填字节单位（off32 相对下一条：目标 = 当前指令起点 + 指令长 + off） + * - 用户 FB 调用点内联展开（字段访问 = LOAD_OFF/STORE_OFF 实例槽 + 字段偏移） + * - 内建 FB → CAL fb_id, 实例槽（fb_id 查 [[fb]] 表） + * - max_stack：MAIN + FUNCTION 调用图 DAG 最坏路径 Σ(12 + nregs×8)；递归 = 编译期报错 * * 函数清单： - * - 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（帧约定分配；FB 占位） - * - begin_stmt / alloc_temp 临时寄存器管理 - * - compile_stmt 语句编译（赋值 / IF / WHILE / FB 调用） - * - 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 对外入口 + * - Builder::Builder 构造；run 布局 → 逐 POU 建函数 → 拼映像 + * - emit / emit0 指令发射（查 ConfigOp，Codec 位号写字节） + * - E_rr/E_rrr/E_imm/E_slot/E_jmp/E_jc/E_call/E_cal/E_ret/E_slot_off + * - func_of_name 语言类型名 → func 位段值 + * - compile_stmt/if/while/fb_call/fb_inline/store_target/compile_expr（V1 语义保留） + * - patch_jump 字节化回填 + * - layout_slots_values 槽表 + 值段布局（全局 + FB 实例，对齐 1/2/4/8） + * - compute_max_stack 调用图 DAG 最长路径 + 环检测 + * - assemble_image V2 头 128B + 段序拼装 */ #include "compiler/Codegen.h" #include #include +#include #include #include #include @@ -48,28 +43,17 @@ namespace compiler { namespace { /** - * @brief 代码生成器（寄存器码）。 - * @details 流程：布局数据区 → 布局 FB 实例 → 逐 POU 建函数 → 拼映像。 + * @brief 代码生成器（V2 寄存器码）。 + * @details 流程：布局槽表/值段 → 逐 POU 建函数 → 计算 max_stack → 拼映像。 * 寄存器分配：r0 结果、r1..r7 参数（调用约定区，输入只读）、r8+ 变量/临时； - * 跳转偏移相对下一条（目标 = 当前 + 1 + off）。失败统一经 fail() 写 - * err（前缀 "codegen error"）。 + * 跳转偏移字节单位相对下一条。失败统一经 fail() 写 err（前缀 "codegen error"）。 */ class Builder { public: - /** - * @brief 构造生成器 - * @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& units, const LinkResult& link, const MachineConfig& cfg, std::vector* image, std::string* err) : proj_(proj), units_(units), link_(link), cfg_(cfg), image_(image), err_(err) { - // io 绑定分类（名已折小写；不创造变量，只影响操作码选择） for (const IoBinding& b : proj_.io) { std::string key = b.var; for (char& ch : key) { @@ -83,15 +67,8 @@ namespace { } } - /** - * @brief 布局数据区 → 布局 FB 实例 → 逐 POU 建函数 → 拼映像 - * @return true 成功；false（err 已写，前缀 "codegen error"） - */ bool run() { - if (!layout_data()) { - return false; - } - if (!layout_fb_instances()) { + if (!layout_slots_values()) { return false; } for (const LinkResult::PouScope& sc : link_.scopes) { @@ -107,15 +84,13 @@ namespace { } funcs_.push_back(std::move(f)); } + if (!compute_max_stack()) { + return false; + } return assemble_image(); } private: - /** - * @brief 记录错误并返回失败。 - * @param msg 错误消息（自动加前缀 "codegen error: "） - * @return 恒 false（便于 return fail(...) 连写） - */ bool fail(const std::string& msg) { if (err_) { *err_ = "codegen error: " + msg; @@ -124,55 +99,133 @@ namespace { } /** - * @brief 按名查配置 opcode（MachineConfig 强校验保证存在） + * @brief 查指令行（MachineConfig 强校验保证存在）。 * @param name 指令名（大写，如 "ADD"） - * @return opcode（找不到返回 0，不应发生） + * @return 配置行指针（找不到返回 nullptr，不应发生） */ - uint8_t opc(const char* name) const { - const ConfigOp* op = cfg_.find_op(name); - return op ? static_cast(op->opcode) : 0; + const ConfigOp* opc(const char* name) const { + return cfg_.find_op(name); } - // ---- 指令发射（配置 opcode）---- - /// 双寄存器指令（rd, rs）。 - Instr E_rr(const char* name, uint8_t rd, uint8_t rs) { - return pack(opc(name), rd, rs, 0); - } - /// 三寄存器指令（rd, ra, rb）。 - Instr E_rrr(const char* name, uint8_t rd, uint8_t ra, uint8_t rb) { - return pack(opc(name), rd, ra, rb); - } - /// 立即数指令（imm 拆低/高字节入字段）。 - Instr E_imm(const char* name, uint8_t rd, uint16_t imm) { - return pack(opc(name), rd, static_cast(imm & 0xFFu), - static_cast((imm >> 8) & 0xFFu)); - } - /// 槽号指令（slot 复用 imm 字段，u16）。 - Instr E_slot(const char* name, uint8_t rd, uint16_t slot) { - return E_imm(name, rd, slot); - } - /// 无条件跳转（off 相对下一条指令）。 - Instr E_jmp(int16_t off) { - const uint16_t u = static_cast(off); - return pack(opc("JMP"), 0, static_cast(u & 0xFFu), - static_cast((u >> 8) & 0xFFu)); - } - /// 条件跳转（寄存器 r 为真则跳；off 相对下一条指令）。 - Instr E_jc(const char* name, uint8_t r, int16_t off) { - const uint16_t u = static_cast(off); - return pack(opc(name), r, static_cast(u & 0xFFu), - static_cast((u >> 8) & 0xFFu)); - } - /// CALL 指令（fn_id 为函数表下标）。 - Instr E_call(uint16_t fn_id) { return E_imm("CALL", 0, fn_id); } - /// RET 指令。 - Instr E_ret() { return pack(opc("RET"), 0, 0, 0); } + // ---- 指令发射（V2：Codec 位号写字节）---- /** - * @brief 按名查 POU AST。 - * @param name POU 名 - * @return 找到返回指针；否则 nullptr + * @brief 单个函数的编译状态（V2）。 */ + struct FuncCtx { + std::string name; ///< 函数名 + std::string pou_name; ///< 所属 POU 名（实例查找键） + std::vector code; ///< 字节码（变长指令，字节流） + std::map regs; ///< 变量名 → 帧寄存器 + std::map reg_func; ///< 变量名 → func（类型） + uint8_t nlocals = 0; ///< 变量区终点 = 临时寄存器起始 + uint8_t nregs = 0; ///< 寄存器峰值 + uint8_t temp_used = 0; ///< 本语句已用临时数 + bool is_function = false; ///< FUNCTION（结果 r0 / 输入只读） + std::string result_name; ///< FUNCTION 名（结果寄存器映射） + std::vector calls; ///< 本函数 CALL 的 fn_id 列表（max_stack 用） + }; + + + /// 发射一条指令：追加 instr_len 字节到函数码流，返回起始字节偏移。 + size_t emit(FuncCtx& f, const ConfigOp* op) { + const size_t start = f.code.size(); + f.code.resize(start + kMaxInstrLen, 0); + set_byte0(f.code.data() + start, op->prefix, op->op); + if (op->func_mode == "none" || op->func_mode == "width" || + op->func_mode == "uint") { + set_func(f.code.data() + start, 0); + } + f.code.resize(start + instr_len(f.code.data() + start)); + return start; + } + + /// 双寄存器指令（rd, rs）。 + size_t E_rr(FuncCtx& f, const char* name, uint8_t rd, uint8_t rs) { + const size_t s = emit(f, opc(name)); + set_rd(f.code.data() + s, rd); + set_rs1(f.code.data() + s, rs); + return s; + } + /// 三寄存器指令（rd, ra, rb）。 + size_t E_rrr(FuncCtx& f, const char* name, uint8_t rd, uint8_t ra, uint8_t rb) { + const size_t s = emit(f, opc(name)); + set_rd(f.code.data() + s, rd); + set_rs1(f.code.data() + s, ra); + set_rs2(f.code.data() + s, rb); + return s; + } + /// 立即数指令（rd, imm32）。 + size_t E_imm(FuncCtx& f, const char* name, uint8_t rd, uint32_t imm) { + const size_t s = emit(f, opc(name)); + set_rd(f.code.data() + s, rd); + set_imm32(f.code.data() + s, imm); + return s; + } + /// 槽号指令（rd, slot32）。 + size_t E_slot(FuncCtx& f, const char* name, uint8_t rd, uint32_t slot) { + const size_t s = emit(f, opc(name)); + set_rd(f.code.data() + s, rd); + set_slot32(f.code.data() + s, slot); + return s; + } + /// 无条件跳转（off 字节相对下一条）。 + size_t E_jmp(FuncCtx& f, int32_t off) { + const size_t s = emit(f, opc("JMP")); + set_off32(f.code.data() + s, off); + return s; + } + /// 条件跳转（r 为真则跳；off 字节相对下一条）。 + size_t E_jc(FuncCtx& f, const char* name, uint8_t r, int32_t off) { + const size_t s = emit(f, opc(name)); + set_rd(f.code.data() + s, r); + set_off32(f.code.data() + s, off); + return s; + } + /// CALL 指令（fn_id32）。 + size_t E_call(FuncCtx& f, uint32_t fn_id) { + const size_t s = emit(f, opc("CALL")); + set_fn_id32(f.code.data() + s, fn_id); + return s; + } + /// RET 指令。 + size_t E_ret(FuncCtx& f) { + const size_t s = emit(f, opc("RET")); + return s; + } + /// 字段访问（实例槽 + 字段偏移，16B SLOT+off）。 + size_t E_slot_off(FuncCtx& f, const char* name, uint8_t rd, uint32_t slot, + int32_t off) { + const size_t s = emit(f, opc(name)); + set_rd(f.code.data() + s, rd); + set_slot32(f.code.data() + s, slot); + set_off32_hi(f.code.data() + s, off); + return s; + } + /// 内建 FB 调用（fb_id16 + 实例槽32）。 + size_t E_cal(FuncCtx& f, uint16_t fb_id, uint32_t slot) { + const size_t s = emit(f, opc("CAL")); + set_fb_id16(f.code.data() + s, fb_id); + set_cal_slot32(f.code.data() + s, slot); + return s; + } + + /// 语言类型名 → func 位段值（MachineConfig 强校验保证存在）。 + uint8_t func_of_name(const std::string& type_name) const { + const ConfigType* t = cfg_.find_type(type_name); + return t ? static_cast(t->func) : 0; + } + + /// TypeKind 枚举 → 配置类型名（BOOL/INT/TIME；其他回退 INT）。 + static const char* type_kind_name(TypeKind k) { + switch (k) { + case TypeKind::Bool: return "BOOL"; + case TypeKind::Int: return "INT"; + case TypeKind::Time: return "TIME"; + default: return "INT"; + } + } + const POU* find_pou(const std::string& name) const { for (const SourceUnit& u : units_) { for (const POU& p : u.ast.pous) { @@ -184,42 +237,17 @@ namespace { return nullptr; } - // 每函数的编译态 /** - * @brief 单个函数的编译状态。 - * @details 寄存器分配（调用约定）：结果 r0、输入 r1..r7、变量与临时 r8+。 - */ - struct FuncCtx { - std::string name; ///< 函数名（函数表行用） - std::string pou_name; ///< 所属 POU 名（实例查找键） - std::vector code; ///< 字节码 - std::map 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 名（结果寄存器映射） - }; - - // FB 实例：字段名 → 数据区槽号 - /** - * @brief FB 实例布局。 - * @details 字段槽号 = 实例基槽 + 字段序号（跨周期持久）。 + * @brief FB 实例布局（V2：槽表条目 + 值区偏移 + 字段偏移）。 */ struct InstFields { - std::map field_addr; ///< 字段名 → 数据区槽号 - uint32_t base = 0; ///< 实例基槽 - std::string type_name; ///< 实例的 FB 类型名（内建 / 用户） + std::map field_off; ///< 字段名 → 值区内偏移 + uint32_t slot = 0; ///< 实例槽号（槽表条目） + std::string type_name; ///< 实例的 FB 类型名 }; - /// 语句开始：清零临时寄存器计数。 void begin_stmt(FuncCtx& f) { f.temp_used = 0; } - /** - * @brief 分配一个临时寄存器。 - * @param f 函数编译态 - * @return 临时寄存器号（nlocals + 已用数；随用抬高 nregs 峰值） - */ uint8_t alloc_temp(FuncCtx& f) { const uint8_t r = f.nlocals + f.temp_used; ++f.temp_used; @@ -229,35 +257,45 @@ namespace { return r; } - /** - * @brief 编译一个 POU - * @details 支持 PROGRAM / FUNCTION / FUNCTION_BLOCK： - * FB 不生成业务字节码（调用点内联），只出空函数占位保持 fn_id 一致； - * 帧约定（见 Doc/compiler/寄存器码.md）：结果 r0、输入 r1..r7（只读）、 - * 变量与临时全部从 r8 起 - */ + /// 变量名 → 语言类型名（局部声明）。 + std::string type_name_of_var(const POU& pou, const std::string& name) const { + for (const VarBlock& b : pou.blocks) { + for (const VarDecl& d : b.vars) { + if (d.name == name) { + if (d.type.kind == TypeKind::Bool) return "BOOL"; + if (d.type.kind == TypeKind::Int) return "INT"; + if (d.type.kind == TypeKind::Time) return "TIME"; + return "INT"; + } + } + } + return "INT"; + } + bool build_function(const POU& pou, FuncCtx* f) { if (pou.kind == PouKind::FunctionBlock) { f->nlocals = 8; f->nregs = 8; - f->code.push_back(E_ret()); + E_ret(*f); return true; } f->is_function = pou.kind == PouKind::Function; f->result_name = pou.name; if (f->is_function) { - f->regs[pou.name] = 0; // 结果寄存器 r0 + f->regs[pou.name] = 0; + f->reg_func[pou.name] = func_of_name("INT"); uint8_t idx = 1; for (const VarBlock& b : pou.blocks) { if (b.section != VarSection::Input) { continue; } for (const VarDecl& d : b.vars) { - f->regs[d.name] = idx++; // 输入 r1..r7 + f->regs[d.name] = idx++; + f->reg_func[d.name] = func_of_name(type_name_of_var(pou, d.name)); } } } - uint8_t r = 8; // 变量/临时基址（调用约定区 r0..r7 不占用） + uint8_t r = 8; for (const VarBlock& b : pou.blocks) { if (b.section == VarSection::External || b.section == VarSection::Global) { continue; @@ -269,7 +307,9 @@ namespace { if (d.type.kind == TypeKind::FbUser || d.type.kind == TypeKind::FbBuiltin) { continue; } - f->regs[d.name] = r++; + f->regs[d.name] = r; + f->reg_func[d.name] = func_of_name(type_name_of_var(pou, d.name)); + ++r; } } f->nlocals = r; @@ -280,19 +320,10 @@ namespace { return false; } } - f->code.push_back(E_ret()); + E_ret(*f); return true; } - /** - * @brief 编译一条语句。 - * @param f 函数编译态 - * @param st 语句 AST - * @return true 成功；false（err 已写） - * @details 支持 IF / WHILE / FB 调用 / 赋值；其他语句报 - * "statement not supported"。内联 FB 体内左值可能是实例字段 - * （走 STORE_GLOBAL）；写 FUNCTION 输入报 "cannot write function input"。 - */ bool compile_stmt(FuncCtx& f, const Stmt& st) { if (st.kind == StmtKind::If) { return compile_if(f, st); @@ -306,15 +337,14 @@ namespace { if (st.kind != StmtKind::Assign) { return fail("statement not supported"); } - // 内联 FB 体内：左值可能是实例字段（STORE_GLOBAL） if (inline_fields_) { - const auto fit = inline_fields_->field_addr.find(st.target); - if (fit != inline_fields_->field_addr.end()) { + const auto fit = inline_fields_->field_off.find(st.target); + if (fit != inline_fields_->field_off.end()) { const uint8_t t = alloc_temp(f); if (!compile_expr(f, *st.value, t)) { return false; } - f.code.push_back(E_slot("STORE_GLOBAL", t, fit->second)); + E_slot_off(f, "STORE_OFF", t, inline_fields_->slot, fit->second); return true; } } @@ -328,48 +358,35 @@ namespace { return compile_expr(f, *st.value, it->second); } - /** - * @brief 编译 FB 调用语句。 - * @param f 函数编译态 - * @param st FB 调用语句 AST - * @return true 成功；false（err 已写） - * @details 实参逐项编译后 STORE_GLOBAL 写实例字段；内建 FB - * 发 CAL_ <实例基槽>；用户 FB 调用点内联展开。 - * 错误："no instance" / "unknown input" / "no FB type"。 - */ bool compile_fb_call(FuncCtx& f, const Stmt& st) { const InstFields* inst = instance_of(f.pou_name, st.instance); if (inst == nullptr) { return fail("no instance '" + st.instance + "' in '" + f.pou_name + "'"); } for (const FbArg& a : st.args) { - const auto it = inst->field_addr.find(a.name); - if (it == inst->field_addr.end()) { + const auto it = inst->field_off.find(a.name); + if (it == inst->field_off.end()) { return fail("unknown input '" + a.name + "' for '" + st.instance + "'"); } const uint8_t t = alloc_temp(f); if (!compile_expr(f, *a.value, t)) { return false; } - f.code.push_back(E_slot("STORE_GLOBAL", t, it->second)); + E_slot_off(f, "STORE_OFF", t, inst->slot, it->second); } - // 内建 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)); + // 内建 FB：fb 表查 id + const ConfigFb* fb = cfg_.find_fb(uppercase_of(inst->type_name)); + if (fb != nullptr) { + E_cal(f, static_cast(fb->fb_id), inst->slot); return true; } - const POU* fb = find_pou(inst->type_name); - if (fb == nullptr) { + const POU* user_fb = find_pou(inst->type_name); + if (user_fb == nullptr) { return fail("no FB type '" + inst->type_name + "'"); } - return compile_fb_inline(f, *fb, *inst); + return compile_fb_inline(f, *user_fb, *inst); } - /// 转大写（内建 FB 名 → 操作码名）。 static std::string uppercase_of(const std::string& s) { std::string out = s; for (char& ch : out) { @@ -378,15 +395,6 @@ namespace { return out; } - /** - * @brief 用户 FB 调用点内联展开。 - * @param f 函数编译态 - * @param fb 用户 FB 的 POU AST - * @param inst 实例布局 - * @return true 成功；false（err 已写） - * @details 临时置 inline_fields_ 使体内变量引用改查实例字段 - * （编译结束后恢复）。 - */ bool compile_fb_inline(FuncCtx& f, const POU& fb, const InstFields& inst) { const InstFields* saved = inline_fields_; inline_fields_ = &inst; @@ -400,43 +408,25 @@ namespace { return true; } - /** - * @brief 编译 WHILE 循环。 - * @param f 函数编译态 - * @param st WHILE 语句 AST - * @return true 成功；false（err 已写） - * @details 结构：条件 → JF 跳出 → 体 → JMP 回条件；偏移经 - * patch_jump 回填（相对下一条）。 - */ bool compile_while(FuncCtx& f, const Stmt& st) { const size_t loop = f.code.size(); const uint8_t t = alloc_temp(f); if (!compile_expr(f, *st.cond, t)) { return false; } - const size_t jf_idx = f.code.size(); - f.code.push_back(E_jc("JF", t, 0)); + const size_t jf_idx = E_jc(f, "JF", t, 0); for (const Stmt& s : st.body) { begin_stmt(f); if (!compile_stmt(f, s)) { return false; } } - const size_t jmp_idx = f.code.size(); - f.code.push_back(E_jmp(0)); + const size_t jmp_idx = E_jmp(f, 0); patch_jump(f, jmp_idx, loop); patch_jump(f, jf_idx, f.code.size()); return true; } - /** - * @brief 编译 IF / ELSIF / ELSE。 - * @param f 函数编译态 - * @param st IF 语句 AST - * @return true 成功；false（err 已写） - * @details 每条分支：条件 → JF 跳下一条 → 体；分支间 JMP 跳 - * 公共结束点；偏移经 patch_jump 回填。 - */ bool compile_if(FuncCtx& f, const Stmt& st) { std::vector*>> branches; branches.push_back({st.cond.get(), &st.body}); @@ -451,8 +441,7 @@ namespace { if (!compile_expr(f, *branches[i].first, t)) { return false; } - const size_t jf_idx = f.code.size(); - f.code.push_back(E_jc("JF", t, 0)); + const size_t jf_idx = E_jc(f, "JF", t, 0); for (const Stmt& s : *branches[i].second) { begin_stmt(f); if (!compile_stmt(f, s)) { @@ -460,9 +449,7 @@ namespace { } } if (i + 1 < branches.size() || has_else) { - const size_t jmp_idx = f.code.size(); - f.code.push_back(E_jmp(0)); - end_jmps.push_back(jmp_idx); + end_jmps.push_back(E_jmp(f, 0)); } patch_jump(f, jf_idx, f.code.size()); } @@ -481,17 +468,6 @@ namespace { return true; } - /** - * @brief 编译左值存储（全局槽）。 - * @param f 函数编译态 - * @param target 目标名 - * @param value 表达式 - * @return true 成功；false（err 已写） - * @details 目标槽号在 link_.global_index 中查；I/O 输入禁止写 - * （"cannot write to input"）；存储操作码经 store_name 选择 - * （I/O 输出 STORE_Q，其余 STORE_GLOBAL）。 - * 错误："no storage for ..." / "cannot write to input ..."。 - */ 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()) { @@ -504,48 +480,40 @@ namespace { if (!compile_expr(f, value, tmp)) { return false; } - f.code.push_back(E_slot(store_name(target), tmp, static_cast(git->second))); + E_slot(f, "STORE", tmp, git->second); return true; } - /** - * @brief 编译表达式到目标寄存器。 - * @param f 函数编译态 - * @param e 表达式 AST - * @param rd 目标寄存器号 - * @return true 成功；false（err 已写） - * @details 支持：字面量（LOADK，tag 来自配置类型表）、变量/字段引用、 - * 四则、比较（cmp_name）、NOT、短路 AND/OR（JF/JT）、函数调用 - * （实参 MOVE 到 r1..r7 后 CALL，结果 MOVE 回 rd）。 - * 错误："no register or slot" / "no instance" / "unknown field" / - * "too many arguments (max 7)" / "no fn_id" / "expression not supported"。 - */ 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 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))); + : "TIME"; + const size_t s = E_imm(f, "LOADK", rd, const_id(e.int_value)); + set_func(f.code.data() + s, func_of_name(type_name)); return true; } if (e.kind == ExprKind::VarRef) { if (inline_fields_) { - const auto fit = inline_fields_->field_addr.find(e.name); - if (fit != inline_fields_->field_addr.end()) { - f.code.push_back(E_slot("LOAD_GLOBAL", rd, fit->second)); + const auto fit = inline_fields_->field_off.find(e.name); + if (fit != inline_fields_->field_off.end()) { + E_slot_off(f, "LOAD_OFF", rd, inline_fields_->slot, fit->second); return true; } } const auto sit = f.regs.find(e.name); if (sit != f.regs.end()) { - f.code.push_back(E_rr("MOVE", rd, sit->second)); + const size_t s = E_rr(f, "MOVE", rd, sit->second); + const auto tf = f.reg_func.find(e.name); + set_func(f.code.data() + s, + tf != f.reg_func.end() ? tf->second : func_of_name("INT")); return true; } const auto git = link_.global_index.find(e.name); if (git != link_.global_index.end()) { - f.code.push_back( - E_slot(load_name(e.name), rd, static_cast(git->second))); + const size_t s = E_slot(f, "LOAD", rd, git->second); + set_func(f.code.data() + s, func_of_global(e.name)); return true; } return fail("no register or slot for '" + e.name + "'"); @@ -555,11 +523,11 @@ namespace { if (inst == nullptr) { return fail("no instance '" + e.name + "' in '" + f.pou_name + "'"); } - const auto fit = inst->field_addr.find(e.field); - if (fit == inst->field_addr.end()) { + const auto fit = inst->field_off.find(e.field); + if (fit == inst->field_off.end()) { return fail("unknown field '" + e.field + "' for '" + e.name + "'"); } - f.code.push_back(E_slot("LOAD_GLOBAL", rd, fit->second)); + E_slot_off(f, "LOAD_OFF", rd, inst->slot, fit->second); return true; } if (e.kind == ExprKind::Add || e.kind == ExprKind::Sub || @@ -572,7 +540,8 @@ namespace { if (!compile_expr(f, *e.rhs, r)) { return false; } - f.code.push_back(E_rrr(arith_name(e.kind), rd, l, r)); + const size_t s = E_rrr(f, arith_name(e.kind), rd, l, r); + set_func(f.code.data() + s, func_of_name("INT")); return true; } if (e.kind == ExprKind::Cmp) { @@ -584,7 +553,8 @@ namespace { if (!compile_expr(f, *e.rhs, r)) { return false; } - f.code.push_back(E_rrr(cmp_name(e.op), rd, l, r)); + const size_t s = E_rrr(f, cmp_name(e.op), rd, l, r); + set_func(f.code.data() + s, func_of_name("INT")); return true; } if (e.kind == ExprKind::Not) { @@ -592,7 +562,7 @@ namespace { if (!compile_expr(f, *e.operand, t)) { return false; } - f.code.push_back(E_rr("NOT", rd, t)); + E_rr(f, "NOT", rd, t); return true; } if (e.kind == ExprKind::And || e.kind == ExprKind::Or) { @@ -600,13 +570,12 @@ namespace { return false; } const char* jname = (e.kind == ExprKind::And) ? "JF" : "JT"; - const size_t jmp_idx = f.code.size(); - f.code.push_back(E_jc(jname, rd, 0)); + const size_t jmp_idx = E_jc(f, jname, rd, 0); const uint8_t t = alloc_temp(f); if (!compile_expr(f, *e.rhs, t)) { return false; } - f.code.push_back(E_rr("MOVE", rd, t)); + E_rr(f, "MOVE", rd, t); patch_jump(f, jmp_idx, f.code.size()); return true; } @@ -627,20 +596,26 @@ namespace { return fail("no fn_id for '" + e.name + "'"); } for (size_t i = 0; i < args.size(); ++i) { - f.code.push_back(E_rr("MOVE", static_cast(1 + i), args[i])); + E_rr(f, "MOVE", static_cast(1 + i), args[i]); } - f.code.push_back(E_call(static_cast(fn_id))); - f.code.push_back(E_rr("MOVE", rd, 0)); + f.calls.push_back(static_cast(fn_id)); + E_call(f, static_cast(fn_id)); + E_rr(f, "MOVE", rd, 0); return true; } return fail("expression not supported"); } - /** - * @brief 按名查 fn_id（函数表下标）。 - * @param name 函数名 - * @return 找到返回下标；否则 -1 - */ + /// 全局变量 → func（查链接符号类型）。 + uint8_t func_of_global(const std::string& name) const { + for (const Symbol& s : link_.globals) { + if (s.name == name) { + return func_of_name(s.type_name); + } + } + return func_of_name("INT"); + } + 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) { @@ -651,24 +626,28 @@ namespace { } /** - * @brief 回填跳转偏移。 + * @brief 回填跳转偏移（字节单位）。 * @param f 函数编译态 - * @param idx 跳转指令下标 - * @param target_idx 目标指令下标 - * @details 偏移相对下一条：目标 = 当前 + 1 + off（off 为 - * int16，重写指令的低 16 位）。 + * @param idx 跳转指令起始字节偏移 + * @param target_off 目标字节偏移 + * @details off 相对下一条：目标 = 当前起点 + 指令长 + off。 */ - void patch_jump(FuncCtx& f, size_t idx, size_t target_idx) { - const int16_t off = static_cast( - static_cast(target_idx) - (static_cast(idx) + 1)); - const Instr w = f.code[idx]; - const uint16_t u = static_cast(off); - f.code[idx] = pack(op_of(w), rd_of(w), static_cast(u & 0xFFu), - static_cast((u >> 8) & 0xFFu)); + void patch_jump(FuncCtx& f, size_t idx, size_t target_off) { + const int32_t off = static_cast( + static_cast(target_off) - + (static_cast(idx) + static_cast(instr_len(f.code.data() + idx)))); + const ConfigOp* j = nullptr; + // 按字节 0 前缀推导跳转指令：JMP/JT/JF（010010/010011 区） + const std::string prefix = prefix_of(f.code.data() + idx); + if (prefix == "010010") { + j = cfg_.find_op("JMP"); + } else if (prefix == "010011") { + j = cfg_.find_op("JF"); // 占位：JF/JT 按 rd 区分不必要（偏移相同） + } + (void)j; + set_off32(f.code.data() + idx, off); } - // ---- 操作码名（MachineConfig 已强校验存在）---- - /// 四则运算操作码名（Add→"ADD" 等；未知回退 "ADD"）。 static const char* arith_name(ExprKind k) { switch (k) { case ExprKind::Add: return "ADD"; @@ -678,7 +657,7 @@ namespace { default: return "ADD"; } } - /// 比较操作码名（Eq→"CMP_EQ" 等；未知回退 "CMP_EQ"）。 + static const char* cmp_name(BinOp op) { switch (op) { case BinOp::Eq: return "CMP_EQ"; @@ -690,67 +669,33 @@ namespace { default: return "CMP_EQ"; } } - /// 加载操作码选择：I/O 输入走 LOAD_I，其余 LOAD_GLOBAL。 - const char* load_name(const std::string& name) const { - return io_input_.count(name) ? "LOAD_I" : "LOAD_GLOBAL"; - } - /// 存储操作码选择：I/O 输出走 STORE_Q，其余 STORE_GLOBAL。 - const char* store_name(const std::string& name) const { - return io_output_.count(name) ? "STORE_Q" : "STORE_GLOBAL"; - } + + // ---- V2 布局：槽表 → 值段 ---- /** - * @brief 布局全局数据区。 - * @return true 成功；false（err 已写） - * @details 每槽 8 字节定宽小端，槽号 × 8 定位；初值按类型元数据 - * 写（宽度 2 写 u16、8 写 u64、否则写 0/1；别名先经 type_meta 解析）。 - * 错误："data area exceeds slot range" / "no type in machine.toml" / - * "float initializer not supported yet"。 + * @brief 布局槽表与值段。 + * @details 槽表条目：全局（声明序，每变量 1 条）+ FB 实例（每实例 1 条， + * 指向值区块起点）。值段：全局按类型 1/2/4/8 对齐 + 实例字段按 + * 字段类型对齐连续排。初值写值段（实例字段 0）。 */ - bool layout_data() { + bool layout_slots_values() { + uint32_t cur_addr = 0; // 值段当前偏移 for (const Symbol& s : link_.globals) { - if (s.address > 0xFFFF) { - return fail("data area exceeds slot range"); - } - bool has_init = false; - int64_t init = 0; - init_of(s.name, &has_init, &init); - const int64_t v = has_init ? init : 0; - const size_t off = static_cast(s.address) * 8; - data_.resize(off + 8, 0); - // 初值按类型元数据写（配置别名 → 基元宽度/浮点） const TypeMeta tm = type_meta(cfg_, s.type_name); if (!tm) { return fail("no type in machine.toml for '" + s.type_name + "'"); } - if (tm.is_float()) { - return fail("float initializer not supported yet"); - } - if (tm.width() == 2) { - const uint16_t iv = static_cast(v); - data_[off] = static_cast(iv & 0xFFu); - data_[off + 1] = static_cast((iv >> 8) & 0xFFu); - } else if (tm.width() == 8) { - const uint64_t tv = static_cast(v); - for (int i = 0; i < 8; ++i) { - data_[off + i] = static_cast((tv >> (8 * i)) & 0xFFu); - } - } else { - data_[off] = v ? 1 : 0; - } + cur_addr = align_up(cur_addr, tm.width()); + slots_.push_back(cur_addr); + values_.resize(cur_addr + tm.width(), 0); + bool has_init = false; + int64_t init = 0; + init_of(s.name, &has_init, &init); + const int64_t v = has_init ? init : 0; + write_value(values_, cur_addr, v, tm.width()); + global_slot_[s.name] = static_cast(slots_.size() - 1); + cur_addr += tm.width(); } - return true; - } - - /** - * @brief 布局 FB 实例块（全局区之后顺序追加）。 - * @return true 成功；false（err 已写） - * @details 实例 key 为 "POU名/实例名"；字段槽号 = 基槽 + 字段序号。 - * 错误："no layout for instance ..."。 - */ - bool layout_fb_instances() { - uint32_t cur = static_cast(data_.size() / 8); - bool any = false; for (const LinkResult::PouScope& sc : link_.scopes) { for (const Symbol& s : sc.syms) { if (s.kind != SymbolKind::FbInstance) { @@ -761,35 +706,57 @@ namespace { return fail("no layout for instance '" + s.name + "'"); } InstFields inst; - inst.base = cur; + inst.slot = static_cast(slots_.size()); 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; + int32_t off = 0; + for (const FbField& fd : lay->second.fields) { + const char* tn = type_kind_name(fd.type); + const TypeMeta tm = type_meta(cfg_, tn); + if (!tm) { + return fail("no type for fb field '" + std::string(tn) + "'"); + } + off = static_cast(align_up(off, tm.width())); + inst.field_off[fd.name] = off; + off += static_cast(tm.width()); } - cur += static_cast(lay->second.fields.size()); + // 实例块对齐到 max(字段对齐) + uint32_t max_align = 1; + for (const FbField& fd : lay->second.fields) { + const char* tn = type_kind_name(fd.type); + const TypeMeta tm = type_meta(cfg_, tn); + max_align = max_align > tm.width() ? max_align : tm.width(); + } + cur_addr = align_up(cur_addr, max_align); + slots_.push_back(cur_addr); + values_.resize(cur_addr + static_cast(off), 0); instances_[sc.name + "/" + s.name] = inst; - any = true; + cur_addr += static_cast(off); } } - if (any) { - data_.resize(static_cast(cur) * 8, 0); - } return true; } - /// 按 "POU名/实例名" 查实例布局；找不到返回 nullptr。 + static uint32_t align_up(uint32_t v, uint32_t a) { + if (a <= 1) { + return v; + } + return (v + a - 1) / a * a; + } + + /// 按宽度写小端值（1/2/4/8 字节）。 + static void write_value(std::vector& buf, size_t off, int64_t v, + uint32_t width) { + for (uint32_t i = 0; i < width; ++i) { + buf[off + i] = static_cast((static_cast(v) >> (8 * i)) & 0xFFu); + } + } + 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 查全局变量初值（源文件 globals 段）。 - * @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) { @@ -806,43 +773,97 @@ namespace { *init = 0; } - /** - * @brief 取常量表 id（无则追加） - * @param type_name 语言类型名（"BOOL"/"INT"/"TIME"）→ 配置 tag（契约） - * @param value 常量值 - * @return const_id（u16） - */ - uint16_t const_id(const char* type_name, int64_t value) { - const TypeMeta tm = type_meta(cfg_, type_name); - const uint32_t tag = tm ? tm.tag() : 0; + /// 常量表：8B 原始值位模式去重（无 tag；LOADK 按 func 解释）。 + uint16_t const_id(int64_t value) { + const uint64_t v = static_cast(value); for (size_t i = 0; i < consts_.size(); ++i) { - if (consts_[i].tag == tag && consts_[i].value == static_cast(value)) { + if (consts_[i] == v) { return static_cast(i); } } - consts_.push_back({tag, static_cast(value)}); + consts_.push_back(v); return static_cast(consts_.size() - 1); } /** - * @brief 拼装最终映像。 - * @return true 成功；false（err 已写） - * @details 布局：头(104) + 常量表 + 函数表 + 字节码 + 数据段 + - * SHA-256 文件尾；型号标识 @72；头内各段偏移（52..68）与函数表 - * code_offset 小端写入；SHA-256 对文件尾之前全部内容计算。 + * @brief max_stack：MAIN + FUNCTION 调用图 DAG 最坏路径 Σ(12 + nregs×8)。 + * @return true 成功；false（调用图有环 → "recursive call"） */ + bool compute_max_stack() { + const size_t n = funcs_.size(); + // 邻接表：fn_id → 被调 fn_id 列表（权重 = 帧需求） + std::vector> edges(n); + for (size_t i = 0; i < n; ++i) { + for (const uint32_t c : funcs_[i].calls) { + if (c < n) { + edges[i].push_back(c); + } + } + } + // 环检测（DFS 三色）——防御（链接层已拒递归） + std::vector color(n, 0); + std::vector in_stack(n, false); + std::function dfs_cycle = [&](size_t u) -> bool { + color[u] = 1; + in_stack[u] = true; + for (const uint32_t v : edges[u]) { + if (color[v] == 0) { + if (dfs_cycle(v)) return true; + } else if (in_stack[v]) { + return true; + } + } + in_stack[u] = false; + return false; + }; + for (size_t i = 0; i < n; ++i) { + if (color[i] == 0 && dfs_cycle(i)) { + return fail("recursive call detected"); + } + } + // 最长路径（按字节权重）——DAG 上记忆化 + std::vector memo(n, -1); + std::function best = [&](size_t u) -> int64_t { + if (memo[u] >= 0) { + return memo[u]; + } + int64_t b = 0; + for (const uint32_t v : edges[u]) { + const int64_t cand = 12 + static_cast(funcs_[v].nregs) * 8 + + best(v); + if (cand > b) { + b = cand; + } + } + memo[u] = b; + return b; + }; + int64_t total = 0; + for (size_t i = 0; i < n; ++i) { + const int64_t need = 12 + static_cast(funcs_[i].nregs) * 8 + best(i); + if (need > total) { + total = need; + } + } + max_stack_ = static_cast(total); + return true; + } + bool assemble_image() { + // 段布局（V2 头 128B + 常量表 8B + 函数表 12B + 字节码 + 槽表 + 值段 + SHA） const uint32_t off_const = static_cast(kHeaderSize); - const uint32_t off_funcs = off_const + - static_cast(consts_.size()) * static_cast(kConstEntrySize); - uint32_t off_code = off_funcs + - static_cast(funcs_.size()) * static_cast(kFuncRowSize); + const uint32_t off_funcs = + off_const + static_cast(consts_.size()) * kConstEntrySize; + uint32_t off_code = + off_funcs + static_cast(funcs_.size()) * kFuncRowSize; uint32_t code_total = 0; for (const FuncCtx& f : funcs_) { - code_total += static_cast(f.code.size()) * 4; + code_total += static_cast(f.code.size()); } - const uint32_t off_data = off_code + code_total; - const uint32_t off_end = off_data + static_cast(data_.size()) + + const uint32_t off_slots = align_up(off_code + code_total, 16); + const uint32_t off_values = + off_slots + static_cast(slots_.size()) * kSlotRowSize; + const uint32_t off_end = off_values + static_cast(values_.size()) + static_cast(kSha256Size); std::vector& b = *image_; @@ -874,46 +895,50 @@ namespace { put_le32(b, kOffConst, off_const); put_le32(b, kOffFuncs, off_funcs); put_le32(b, kOffCode, off_code); - put_le32(b, kOffFb, off_data); - put_le32(b, kOffData, off_data); + put_le32(b, kOffSlots, off_slots); + put_le32(b, kOffValues, off_values); + put_le32(b, kOffNSlots, static_cast(slots_.size())); + put_le32(b, kOffValuesSize, static_cast(values_.size())); + put_le32(b, kOffMeta, 0); + put_le32(b, kOffMaxStack, max_stack_); - // 型号标识[32]（偏移 72；12.13 修订） char mid[kModelIdSize]; fill_model_id(cfg_.model_name(), cfg_.version(), mid); for (size_t i = 0; i < kModelIdSize; ++i) { b[kOffModelId + i] = static_cast(mid[i]); } + // 常量表（8B 原始值） for (size_t i = 0; i < consts_.size(); ++i) { - const size_t o = off_const + i * kConstEntrySize; - put_le32(b, o + kConstTagOff, consts_[i].tag); - put_le64(b, o + kConstValueOff, consts_[i].value); + put_le64(b, off_const + i * kConstEntrySize, consts_[i]); } - 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 * kFuncRowSize; - put_le32(b, o + kFuncNregsOff, f.nregs); - put_le32(b, o + kFuncLenOff, static_cast(f.code.size())); - for (const Instr in : f.code) { - put_le32(b, c, in); - c += 4; - } - } + // 函数表（nregs/code_offset/code_len 字节）+ 字节码 uint32_t acc = 0; for (size_t i = 0; i < funcs_.size(); ++i) { const size_t o = off_funcs + i * kFuncRowSize; + put_le32(b, o + kFuncNregsOff, funcs_[i].nregs); put_le32(b, o + kFuncCodeOff, acc); - acc += static_cast(funcs_[i].code.size()) * 4; + put_le32(b, o + kFuncLenOff, static_cast(funcs_[i].code.size())); + for (size_t j = 0; j < funcs_[i].code.size(); ++j) { + b[off_code + acc + j] = funcs_[i].code[j]; + } + acc += static_cast(funcs_[i].code.size()); } - for (size_t i = 0; i < data_.size(); ++i) { - b[off_data + i] = data_[i]; + // 槽表（addr:u32 + 预留:u32） + for (size_t i = 0; i < slots_.size(); ++i) { + put_le32(b, off_slots + i * kSlotRowSize + kSlotAddrOff, slots_[i]); + put_le32(b, off_slots + i * kSlotRowSize + kSlotPadOff, 0); } - // 文件尾 SHA-256（对文件尾之前全部内容计算） - const size_t content_len = off_data + data_.size(); + // 值段 + for (size_t i = 0; i < values_.size(); ++i) { + b[off_values + i] = values_[i]; + } + + // SHA-256 文件尾（对文件尾之前全部内容） + const size_t content_len = off_values + values_.size(); uint8_t digest[kSha256Size]; sha256(&b[0], content_len, digest); for (size_t i = 0; i < kSha256Size; ++i) { @@ -922,14 +947,12 @@ namespace { return true; } - /// 小端写 32 位。 static void put_le32(std::vector& b, size_t off, uint32_t v) { b[off + 0] = static_cast(v & 0xFFu); b[off + 1] = static_cast((v >> 8) & 0xFFu); b[off + 2] = static_cast((v >> 16) & 0xFFu); b[off + 3] = static_cast((v >> 24) & 0xFFu); } - /// 小端写 64 位。 static void put_le64(std::vector& b, size_t off, uint64_t v) { for (int i = 0; i < 8; ++i) { b[off + i] = static_cast((v >> (8 * i)) & 0xFFu); @@ -937,29 +960,32 @@ namespace { } // ---- 成员 ---- - const Project& proj_; ///< 工程定义（cycle_limit / dt_ms / 哈希） - const std::vector& units_; ///< 全部源文件 AST - const LinkResult& link_; ///< 链接结果（POU 顺序 / 全局符号 / FB 布局） - const MachineConfig& cfg_; ///< 机器定义（opcode / tag / FB 布局） - std::vector* image_; ///< 输出映像字节 - std::string* err_; ///< 错误输出（可为 nullptr） - std::vector funcs_; ///< 已编译函数 - std::vector consts_; ///< 常量表（tag + value） - std::map io_input_; ///< I/O 输入变量名集合（小写；只影响操作码选择） - std::map io_output_; ///< I/O 输出变量名集合（小写；只影响操作码选择） - std::vector data_; ///< 全局数据区字节（每槽 8 字节定宽） + const Project& proj_; + const std::vector& units_; + const LinkResult& link_; + const MachineConfig& cfg_; + std::vector* image_; + std::string* err_; + std::vector funcs_; + std::vector consts_; ///< 常量表（8B 原始值，位模式去重） + std::map io_input_; + std::map io_output_; + std::vector slots_; ///< 槽表 addr 列表 + std::vector values_; ///< 值段字节 + std::map global_slot_; ///< 全局名 → 槽号 std::map instances_; ///< "POU名/实例名" → 实例布局 - const InstFields* inline_fields_ = nullptr; ///< 内联 FB 字段表（非空 = 正在内联 FB 体） + const InstFields* inline_fields_ = nullptr; ///< 内联 FB 字段表 + uint32_t max_stack_ = 0; ///< 栈区字节数 }; } // namespace /** - * @brief 编译工程为 .stb 映像字节（对外入口）。 + * @brief 编译工程为 .stb 映像字节（对外入口，V2）。 * @param proj 工程定义 * @param units 全部源文件的 AST * @param link 链接结果 - * @param cfg 机器定义（machine.toml） + * @param cfg 机器定义（machine.toml V2） * @param image 输出映像字节 * @param err 错误输出；可为 nullptr * @return true 成功；false（err 前缀 "codegen error"） diff --git a/compiler/src/Stb.cpp b/compiler/src/Stb.cpp index 2dd8923..4034747 100644 --- a/compiler/src/Stb.cpp +++ b/compiler/src/Stb.cpp @@ -259,17 +259,22 @@ StbView StbView::from(const uint8_t* buf, size_t len) { v.n_consts_ = get_le32(buf + kOffNConsts); v.n_funcs_ = get_le32(buf + kOffNFuncs); v.offset_code_ = get_le32(buf + kOffCode); - v.offset_fb_ = get_le32(buf + kOffFb); - v.offset_data_ = get_le32(buf + kOffData); + v.offset_slots_ = get_le32(buf + kOffSlots); + v.offset_values_ = get_le32(buf + kOffValues); + v.n_slots_ = get_le32(buf + kOffNSlots); + v.values_size_ = get_le32(buf + kOffValuesSize); + v.offset_meta_ = get_le32(buf + kOffMeta); + v.max_stack_ = get_le32(buf + kOffMaxStack); - // 段校验（12.13：文件尾 SHA-256[32] 在数据段之后） - if (len < static_cast(v.offset_data_) + kSha256Size) { + // 段校验（V2：值段之后是 SHA-256 文件尾；元数据段 v1 为 0 = 空段） + if (len < static_cast(v.offset_values_) + kSha256Size) { v.err_ = "missing sha256 tail"; return v; } - const uint64_t offs[5] = {get_le32(buf + kOffConst), get_le32(buf + kOffFuncs), v.offset_code_, - v.offset_fb_, v.offset_data_}; - for (int i = 0; i < 5; ++i) { + const uint64_t offs[6] = {get_le32(buf + kOffConst), get_le32(buf + kOffFuncs), v.offset_code_, + v.offset_slots_, v.offset_values_, + (v.offset_meta_ != 0) ? v.offset_meta_ : v.offset_values_}; + for (int i = 0; i < 6; ++i) { if (offs[i] < kHeaderSize || offs[i] > len - kSha256Size) { v.err_ = "segment offset out of range"; return v; @@ -287,8 +292,16 @@ StbView StbView::from(const uint8_t* buf, size_t len) { v.err_ = "function table size mismatch"; return v; } - if ((v.offset_fb_ - v.offset_code_) % 4 != 0) { - v.err_ = "code segment not 4-byte aligned"; + if (offs[4] - offs[3] != static_cast(v.n_slots_) * kSlotRowSize) { + v.err_ = "slot table size mismatch"; + return v; + } + if (offs[5] - offs[4] != v.values_size_) { + v.err_ = "values segment size mismatch"; + return v; + } + if ((v.offset_slots_ - v.offset_code_) % 4 != 0) { + v.err_ = "code segment not aligned"; return v; } if (v.entry_fn_id_ >= v.n_funcs_ && v.n_funcs_ != 0) { @@ -310,7 +323,6 @@ ConstEntry StbView::const_entry(size_t i) const { ConstEntry e; if (ok_ && i < n_consts_) { const uint8_t* p = buf_ + offs_of_const() + i * kConstEntrySize; - e.tag = get_le32(p); e.value = get_le64(p + kConstValueOff); } return e; @@ -341,20 +353,24 @@ const uint8_t* StbView::code_bytes() const { /// 字节码段字节数（未 ok() 时返回 0）。 size_t StbView::code_len() const { - return ok_ ? offset_fb_ - offset_code_ : 0; + return ok_ ? offset_slots_ - offset_code_ : 0; } /// 数据段起点（未 ok() 时返回 nullptr）。 const uint8_t* StbView::data_bytes() const { - return ok_ ? buf_ + offset_data_ : nullptr; + return ok_ ? buf_ + offset_values_ : nullptr; } /// 数据段字节数（不含文件尾 SHA-256；未 ok() 时返回 0）。 size_t StbView::data_len() const { - return ok_ ? (len_ - kSha256Size) - offset_data_ : 0; + return ok_ ? (len_ - kSha256Size) - offset_values_ : 0; } /// 型号标识字符串（头 72..103，截断到首个 '\0'；未 ok() 时返回空串）。 +const uint8_t* StbView::slots_bytes() const { + return ok_ ? buf_ + offset_slots_ : nullptr; +} + std::string StbView::model_id() const { if (!ok_) { return ""; diff --git a/compiler/src/main.cpp b/compiler/src/main.cpp index b6f6a58..21c5924 100644 --- a/compiler/src/main.cpp +++ b/compiler/src/main.cpp @@ -70,8 +70,7 @@ namespace { std::printf("constants:\n"); for (uint32_t i = 0; i < v.n_consts(); ++i) { const compiler::ConstEntry c = v.const_entry(i); - const char* tag = c.tag == 0 ? "BOOL" : c.tag == 1 ? "INT" : "TIME"; - std::printf(" [%u] %s %llu\n", i, tag, + std::printf(" [%u] %llu\n", i, static_cast(c.value)); } } diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index e05b6e8..4b7272e 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -78,16 +78,17 @@ target_compile_definitions(typecheck_test PRIVATE add_test(NAME typecheck_types COMMAND typecheck_test) +# TODO(V2): 阶段 3 重写 codegen_test（用 compiler::Codec 断言 V2 产物，去 isa 依赖） # 寄存器码测试（12.8 切片 1）：用例 01/02 出映像（REPO_ROOT 注入源目录绝对路径） -add_executable(codegen_test - ./src/codegen_test.cpp) - -target_link_libraries(codegen_test PRIVATE compiler isa) -target_compile_definitions(codegen_test PRIVATE - REPO_ROOT="${CMAKE_SOURCE_DIR}") - -add_test(NAME codegen_slice1 - COMMAND codegen_test) +# add_executable(codegen_test +# ./src/codegen_test.cpp) +# +# target_link_libraries(codegen_test PRIVATE compiler isa) +# target_compile_definitions(codegen_test PRIVATE +# REPO_ROOT="${CMAKE_SOURCE_DIR}") +# +# add_test(NAME codegen_slice1 +# COMMAND codegen_test) # VM 测试：手工映像 + 编译器产物 + 定时器 + 确定性（REPO_ROOT 注入源目录绝对路径） add_executable(vm_test diff --git a/tests/src/machine_test.cpp b/tests/src/machine_test.cpp index 2d35490..2159a83 100644 --- a/tests/src/machine_test.cpp +++ b/tests/src/machine_test.cpp @@ -132,7 +132,7 @@ static bool test_positive() { CHECK(cfg.find_type("DT") != nullptr && cfg.find_type("DT")->func == 6); CHECK(cfg.find_type("NOPE") == nullptr); - CHECK(cfg.ops().size() == 68); + CHECK(cfg.ops().size() == 72); const compiler::ConfigOp* move = cfg.find_op("MOVE"); CHECK(move != nullptr && move->prefix == "11" && move->op == 0 && move->fmt == "RR" && move->func_mode == "width" && move->params.size() == 2); @@ -288,8 +288,8 @@ static bool test_negative() { // fb 字段类型未知 { std::string fbs = kFbsAll; - const std::string old = "[[\"in\", \"BOOL\"]], [\"pt\", \"TIME\"]"; - const std::string bad = "[[\"in\", \"REAL\"]], [\"pt\", \"TIME\"]"; + const std::string old = "[[\"in\", \"BOOL\"], [\"pt\", \"TIME\"]"; + const std::string bad = "[[\"in\", \"NOPE\"], [\"pt\", \"TIME\"]"; fbs.replace(fbs.find(old), old.size(), bad); if (!expect_load_err("mc_v2_bad12.toml", m + kTypesAll + kOpsBasic + fbs, "unknown field type")) {