The nc macros take a real carry in, they do not seed it themselves

They used to write the carry cell themselves -- set_0 inside clb_add_nc, set_1
inside clb_inc_nc / clb_neg_nc / clb_sub_nc -- which made the parameter a lie: a
cell the caller passes and the callee overwrites is not a carry input, it is a
scratch cell wearing a carry's name.  It also ruled out the thing a carry is for:
multi byte arithmetic.  The carry out of the low byte could not be handed to the
high byte, because the high byte's call would zero (or one) it first.

Now the macros only read it, and the caller decides:

    clb_add_nc A B S Ci     S = A + B + Ci      Ci = 0 plain add, or chained
    clb_inc_nc A S Ci       S = A + Ci          Ci = 1 gives A + 1
    clb_neg_nc A S Ci       S = ~A + Ci         Ci = 1 gives -A, Ci = 0 gives ~A
    clb_sub_nc A B S Ci     S = A + ~B + Ci     Ci = 1 gives A - B, Ci = 0 A-B-1

which also turns the negate into two operations for free: two's complement
negation at Ci=1 and the ones' complement (~A) at Ci=0.  The second one has its
own driver and test now (drv/raw_not_nc_byte.r8asm).

The drivers set the bit explicitly before the call, which is where that
instruction belongs -- the tapes end up the same length as before (688/430/468/725
instead of 693/433/471/730: one setup instruction moved out of the macro).

All nine byte level operations still pass, and the docs (AGENTS.md, README.md and
the four file headers) now state the carry in contract instead of describing a
constant.
This commit is contained in:
dsh committed 2026-11-07 09:12:47 +08:00
1 parent 5f0ce78861
commit 026ad82455
12 files changed
+132 -47

No files matched your search

+26 -17
View File
@@ -59,7 +59,7 @@ r8forge asm/test.r8asm # 应 exit 0,1666 字符,7
r8forge_synth_test examples/full_add.r8asm # all eight combinations ok
r8forge verify_clb_bit_add_nc.r8asm # 4 cell 加法切片(进位进->出)
r8forge verify_clb_bit_inc_nc.r8asm # 3 cell 自增切片,进位同样进->出
r8forge_byte_op_test # 字节级库:65536×4 + 512 全过,0.5 秒
r8forge_byte_op_test # 字节级库:9 个操作穷举,0.7 秒
r8forge_macro_docs_test # asm/ 里每个宏的注释格式
```
@@ -109,7 +109,7 @@ void rot8_rnz(rot8_iter *iter) { if ((*(iter->mem_now) & 1) == 1) { ... } }
## 字节级运算(一个 cell 一个字节)
结论:**库里的字节级宏是对的,穷举全过**。`r8forge_byte_op_test` 实测(0.5 秒):
结论:**库里的字节级宏是对的,穷举全过**。`r8forge_byte_op_test` 实测(0.7 秒):
| 宏 | 驱动 | 纸带 | 结果 |
|---|---|---|---|
@@ -118,26 +118,33 @@ void rot8_rnz(rot8_iter *iter) { if ((*(iter->mem_now) & 1) == 1) { ... } }
| `raw_or` | `drv/raw_or_byte.r8asm` | 575 字符 | **65536/65536** |
| `raw_xor` | `drv/raw_xor_byte.r8asm` | 463 字符 | **65536/65536** |
| `raw_inc`(a+进位) | `drv/raw_inc_byte.r8asm` | 1214 字符 | **512/512** |
| **`clb_add_nc`(a+b,4 cell)** | `drv/raw_add_nc_byte.r8asm` | **693 字符** | **65536/65536** |
| **`clb_inc_nc`(a+1,3 cell)** | `drv/raw_inc_nc_byte.r8asm` | **433 字符** | **256/256** |
| **`clb_neg_nc`(-a,补码,3 cell)** | `drv/raw_neg_nc_byte.r8asm` | **471 字符** | **256/256** |
| **`clb_sub_nc`(a-b,4 cell)** | `drv/raw_sub_nc_byte.r8asm` | **730 字符** | **65536/65536** |
| **`clb_add_nc`(a+b+进位,4 cell)** | `drv/raw_add_nc_byte.r8asm` | **688 字符** | **65536/65536** |
| **`clb_inc_nc`(a+进位,3 cell)** | `drv/raw_inc_nc_byte.r8asm` | **430 字符** | **256/256** |
| **`clb_neg_nc`(~a+进位,3 cell)** | `drv/raw_neg_nc_byte.r8asm` | **468 字符** | **256/256**(取负) |
| 同上,进位 0 | `drv/raw_not_nc_byte.r8asm` | **467 字符** | **256/256**(反码 `~a`) |
| **`clb_sub_nc`(a-b,4 cell)** | `drv/raw_sub_nc_byte.r8asm` | **725 字符** | **65536/65536** |
| `asm/fibonacci.r8asm` | — | 8761 字符 | 跑出 `1 1 2 3 5 8 13 21 34 55`,和文件注释一致 |
`raw_*` 保留操作数(A、B 原样还回来),`clb_*_nc` 把 A、B 吃干净 —— 所以后者能省掉
`Co` 和 `tmp`:**4 cell 加法、3 cell 自增/取负**。两者都用轮转驱动,差别只在
"操作数要不要还回去"。`clb_inc_nc` 的关键是把进位 cell 先置 **1**(那个 1 就是"加 1"),
加法那版才是置 0。
`Co` 和 `tmp`:**4 cell 加法/减法、3 cell 自增/取负**。两者都用轮转驱动,差别只在
"操作数要不要还回去"。
**`clb_*_nc` 的进位 cell 是真正的进位输入**:宏自己**不动**它的初值(曾经写错过 ——
加法里 `set_0`、自增里 `set_1`,那就不是输入了,而且把多字节串接堵死了)。
调用者给 0 就是普通运算,给 1 就是"自带 +1"的那种,或者把上一字节的进位输出接过来串。
### 补码
`-A = ~A + 1`、`A - B = A + ~B + 1`,所以取负/减法都是"取反 + 加法/自增",进位 cell
的初值就是那个 +1:
`-A = ~A + 1`、`A - B = A + ~B + 1`,所以取负/减法都是"取反 + 加法/自增",
那个 +1 由调用者通过进位输入给:
| 宏 | 做法 | 进位输出 |
|---|---|---|
| `clb_neg_nc A S Ci` | 每轮 `flb` 取反 A 的最低位,再 `clb_bit_inc_nc` | 只有 A 原本是 0 时是 1(`-0 = 0` 但确实进了位) |
| `clb_sub_nc A B S Ci` | 每轮 `flb` 取反 B 的最低位,再 `clb_bit_add_nc` | **没有借位**:A >= B 时 1,否则 0 —— 顺带就是无符号比较 |
| 宏 | 做法 | Ci=1 | Ci=0 |
|---|---|---|---|
| `clb_neg_nc A S Ci` | 每轮 `flb` 取反 A 的最低位,再 `clb_bit_inc_nc` | `-A`(补码取负) | `~A`(反码) |
| `clb_sub_nc A B S Ci` | 每轮 `flb` 取反 B 的最低位,再 `clb_bit_add_nc` | `A - B` | `A - B - 1` |
`clb_sub_nc` 的进位输出是**没有借位**(`A >= B` 时为 1),所以它顺带就是无符号比较;
`clb_neg_nc` 的进位输出只在 `A` 原本是 0 时为 1(`-0 = 0` 但确实进了位)。
取反必须发生在切片**外面**:想让 `%synth` 自己取反(表 `S=~A^Ci`、进位 `~A&Ci`,3 参数)
报 `no program up to 8 layers`。原因是模型只会"牺牲一个 cell → 条件翻转别的 cell",
@@ -190,8 +197,10 @@ A=0 时整块跳过、S 只能留在 0,而取反要求 A=0 时 S=1 —— "无
| 库里的 7 个位运算块(and/or/xor/inc/add) | 合成版比手写短:`asm/test.r8asm` 1714 → 1666 字符 |
| `clb_bit_add_nc`(4 cell 忽略进位切片) | flat 代价 **27**,完整全加器切片是 38;8/8 组合正确 |
| `clb_bit_inc_nc`(3 cell 自增切片) | 表 `0 4 4 2 0 4 4 2`(3 参数)缓存里就有,4 blocks;纸带 54 字符,4/4 组合正确 |
| `clb_add_nc`(4 cell 字节加法) | 693 字符,65536 组合全对;比 6 cell 的 `raw_add` 少 2 个 cell、短 954 字符 |
| `clb_inc_nc`(3 cell 字节自增) | 433 字符,256 组合全对;比 5 cell 的 `raw_inc` 少 2 个 cell |
| `clb_add_nc`(4 cell 字节加法) | 688 字符,65536 组合全对;比 6 cell 的 `raw_add` 少 2 个 cell、短 959 字符 |
| `clb_inc_nc`(3 cell 字节自增/加 0-1) | 430 字符,256 组合全对;比 5 cell 的 `raw_inc` 少 2 个 cell |
| `clb_neg_nc`(3 cell 取负/取反) | 468 / 467 字符,各 256 组合全对(Ci=1 取负、Ci=0 反码) |
| `clb_sub_nc`(4 cell 减法) | 725 字符,65536 组合全对;进位输出顺带是无符号比较(A >= B) |
| `bit_raw_add`(6 cell 全加器切片) | 保留 A、B;字节级 `raw_add` 1647 字符,65536 组合全对 |
| `raw_and` / `raw_or` / `raw_xor` / `raw_inc` | 639 / 575 / 463 / 1214 字符,各 65536(inc 512)全对 |
| `asm/fibonacci.r8asm` | 8761 字符,跑出 10 项斐波那契,和注释一致 |
+22 -1
View File
@@ -211,17 +211,38 @@ output Co
`raw_add` 把 A、B、S 各当一个**字节**:每轮把当前最低位送进 4~6 cell 的位级切片,
然后把整个字节 `ror` 一格,8 轮走完。`raw_and` / `raw_or` / `raw_xor` / `raw_inc` 同理。
`r8forge_byte_op_test` 在 ROT-8 虚拟机上把每种输入都跑一遍(0.5 秒):
`r8forge_byte_op_test` 在 ROT-8 虚拟机上把每种输入都跑一遍(0.7 秒):
```
raw_xor: 463 characters all 65536 combinations ok
raw_or: 575 characters all 65536 combinations ok
raw_and: 639 characters all 65536 combinations ok
clb_sub_nc: 725 characters all 65536 combinations ok
clb_neg_nc (carry 0): 467 all 256 combinations ok ~A
clb_neg_nc: 468 characters all 256 combinations ok -A
clb_inc_nc: 430 characters all 256 combinations ok
clb_add_nc: 688 characters all 65536 combinations ok
raw_inc: 1214 characters all 512 combinations ok
raw_add: 1647 characters all 65536 combinations ok
byte level library ok
```
### 省 cell 的那一族:`clb_*_nc`
`raw_add` 要 6 个 cell(A、B、进位、S、进位输出、草稿)是因为它**保留** A、B。
如果调用者不在乎操作数被吃掉,4 个 cell 就够:
| 宏 | 含义 | cell | 纸带 |
|---|---|---|---|
| `clb_add_nc A B S Ci` | `S = A + B + Ci` | 4 | 688 |
| `clb_inc_nc A S Ci` | `S = A + Ci`(`Ci=1` 就是自增) | 3 | 430 |
| `clb_neg_nc A S Ci` | `S = ~A + Ci`(`Ci=1` → `-A`,`Ci=0` → `~A`) | 3 | 468 |
| `clb_sub_nc A B S Ci` | `S = A + ~B + Ci`(`Ci=1` → `A-B`) | 4 | 725 |
**进位 cell 是真正的进位输入**:宏不动它的初值,由调用者给。所以可以串 —— 上一字节的
进位输出直接接到下一字节的进位输入,多字节加法/减法/取负都能这么拼。
`clb_sub_nc` 的进位输出是"没有借位"(`A >= B` 时为 1),顺带就是无符号比较。
`asm/fibonacci.r8asm` 也是这条路上的:8761 字符,跑出 `1 1 2 3 5 8 13 21 34 55`。
### 一个坑:`biz`/`rnz` 看的是最低位
+4 -6
View File
@@ -44,15 +44,13 @@
; %3: Cell S
; %4: CellBit Ci
;
; 字节级加法:A + B -> S,进位进->出。每轮把 A、B 的当前最低位喂进 clb_bit_add_nc,
; 和写进 S 的最低位,然后 A、B、S 各 ror 一格。A、B 结束为 0,
; Ci 在最后一轮之后就是整个加法的进位输出。
; 字节级加法:S = A + B + Ci。进位 cell 是**真正的进位输入** —— 调用者决定初值
; (普通加法给 0;多字节串起来时给上一字节的进位输出),宏只负责把它变成进位输出。
; 每轮把 A、B 的当前最低位喂进 clb_bit_add_nc,和写进 S 的最低位,
; 然后 A、B、S 各 ror 一格。A、B 结束为 0。
%macro clb_add_nc 4
.anchor before_clb_add_nc
.tp %4
set_0
%rep _CELL_SIZE
clb_bit_add_nc %1 %2 %4 %3
.tp %1
+3 -5
View File
@@ -39,14 +39,12 @@
; %2: Cell S
; %3: CellBit Ci
;
; 字节级自增:A + 1 -> S,A 被吃干净。进位 cell 先置 **1** —— 那个 1 就是"加 1",
; 所以这里不能像加法那样清零。最后一轮之后 Ci 是进位输出。
; 字节级"加一个 0/1":S = A + Ci,A 被吃干净。进位 cell 是**真正的进位输入** ——
; 要自增就由调用者先 `set_1`(那一位就是"加 1"),要加 0 就 `set_0`。
; 宏自己不碰初值,所以多字节可以串起来:上一字节的进位输出直接当下一字节的进位输入。
%macro clb_inc_nc 3
.anchor before_clb_inc_nc
.tp %3
set_1
%rep _CELL_SIZE
clb_bit_inc_nc %1 %3 %2
.tp %1
+4 -5
View File
@@ -26,14 +26,13 @@
; %2: Cell S
; %3: CellBit Ci
;
; 字节级补码取负:S = -A(mod 256)。进位 cell 先置 **1** —— 那个 1 就是 +1。
; A 被吃干净。最后一轮之后 Ci 为 1 只有一种情况:A 原本是 0(0 的负数还是 0,但"有进位")。
; 字节级取负/取反:S = ~A + Ci。进位 cell 是**真正的进位输入**,宏自己不动初值:
; Ci = 1 -> S = -A(补码取负)
; Ci = 0 -> S = ~A(反码,逐位取反)
; A 被吃干净。不硬置初值的另一个好处:多字节取负也能串(进位接进位)。
%macro clb_neg_nc 3
.anchor before_clb_neg_nc
.tp %3
set_1
%rep _CELL_SIZE
clb_bit_neg_nc %1 %3 %2
.tp %1
+5 -6
View File
@@ -25,15 +25,14 @@
; %3: Cell S
; %4: CellBit Ci
;
; 字节级补码减法:S = A - B(mod 256),A、B 都被吃干净。
; 最后一轮之后 Ci 的意义是"没有借位":A >= B 时 Ci = 1,否则 0 —— 所以它顺带就是
; 一个无符号比较(A >= B)。
; 字节级减法:S = A + ~B + Ci。进位 cell 是**真正的进位输入**,宏自己不动初值:
; Ci = 1 -> S = A - B(补码减法)
; Ci = 0 -> S = A - B - 1
; A、B 都被吃干净。最后一轮之后 Ci 是"没有借位"(A >= B 时为 1)—— 顺带就是无符号比较,
; 而且多字节减法可以把这一位直接接到下一字节的进位输入。
%macro clb_sub_nc 4
.anchor before_clb_sub_nc
.tp %4
set_1
%rep _CELL_SIZE
clb_bit_sub_nc %1 %2 %4 %3
.tp %1
+7 -1
View File
@@ -1,15 +1,21 @@
%include "asm/raw_add_nc.r8asm"
; clb_add_nc 的字节级驱动:操作数直接放在 A、B 里,不预置任何常量。
; clb_add_nc 的字节级驱动:操作数直接放在 A、B 里。
;
; r8forge_derive drv/raw_add_nc_byte.r8asm -2 0=5 2=3
;
; out 依次是 A、B、S、Ci。和 raw_add 的驱动不同,A、B 是被吃掉的(结束为 0)。
;
; 进位 cell 是真正的进位输入,这里先清零 = 普通加法。要多字节串接就把上一字节的
; 进位输出接在这个 cell 上,别再清它。
.var A 0
.var Ci 1
.var B 2
.var S 4
.tp Ci
set_0
clb_add_nc A B S Ci
output A
+5 -1
View File
@@ -1,14 +1,18 @@
%include "asm/raw_inc_nc.r8asm"
; clb_inc_nc 的字节级驱动。A 被吃掉,S = A + 1,Ci 是进位输出。
; clb_inc_nc 的字节级驱动。A 被吃掉,S = A + Ci。
;
; r8forge_derive drv/raw_inc_nc_byte.r8asm -2 0=255
;
; 自增就是"加一个 1",所以进位输入先置 1(宏自己不碰这一位)。
; out 依次是 A、S、Ci。
.var A 0
.var Ci 1
.var S 2
.tp Ci
set_1
clb_inc_nc A S Ci
output A
+7 -2
View File
@@ -1,14 +1,19 @@
%include "asm/raw_neg_nc.r8asm"
; clb_neg_nc 的字节级驱动。A 被吃掉,S = -A(补码),Ci 只在 A 原本是 0 时为 1。
; clb_neg_nc 的字节级驱动(S = ~A + Ci)。A 被吃掉。
;
; r8forge_derive drv/raw_neg_nc_byte.r8asm -2 0=1
; r8forge_derive drv/raw_neg_nc_byte.r8asm -2 0=1 # ci=1:取负,得 255
;
; 补码取负 = ~A + 1,所以进位输入置 1。这个 cell 是真正的进位输入,
; 置 0 的话同一个宏算的是逐位取反(~A,见 drv/raw_not_nc_byte.r8asm)。
; out 依次是 A、S、Ci。
.var A 0
.var Ci 1
.var S 2
.tp Ci
set_1
clb_neg_nc A S Ci
output A
+19
View File
@@ -0,0 +1,19 @@
%include "asm/raw_neg_nc.r8asm"
; clb_neg_nc 的另一个用法:进位输入置 0,算的就是逐位取反(~A,反码)。
;
; r8forge_derive drv/raw_not_nc_byte.r8asm -2 0=5 # 得 250
;
; out 依次是 A、S、Ci。
.var A 0
.var Ci 1
.var S 2
.tp Ci
set_0
clb_neg_nc A S Ci
output A
output S
output Ci
+6 -3
View File
@@ -1,16 +1,19 @@
%include "asm/raw_sub_nc.r8asm"
; clb_sub_nc 的字节级驱动。A、B 都被吃掉,S = A - B(补码),
; Ci = 1 表示没有借位(A >= B)。
; clb_sub_nc 的字节级驱动。A、B 都被吃掉,S = A + ~B + Ci。
;
; r8forge_derive drv/raw_sub_nc_byte.r8asm -2 0=5 2=3
; r8forge_derive drv/raw_sub_nc_byte.r8asm -2 0=5 2=3 # ci=1:A-B
;
; A - B = A + ~B + 1,所以进位输入置 1。输出里 Ci = 1 表示没有借位(A >= B)。
; out 依次是 A、B、S、Ci。
.var A 0
.var Ci 1
.var B 2
.var S 4
.tp Ci
set_1
clb_sub_nc A B S Ci
output A
+24
View File
@@ -293,6 +293,29 @@ int test_sub_nc(const std::string &file) {
return bad;
}
// Same macro with its carry in at 0 is the ones' complement: S = ~A.
int test_not_nc(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "clb_neg_nc (carry 0): " << tape.size() << " characters\n";
int bad = 0;
for (int a = 0; a < 256; a++) {
machine m;
m.cells[0] = uint8_t(a); // A
m.run(tape, 100'000);
const int inv = (~a) & 0xff;
const bool ok = m.finished && m.out.size() == 3 && m.out[0] == 0 &&
m.out[1] == inv && m.out[2] == 0;
if (!ok) {
bad++;
if (bad <= 3)
report("clb_neg_nc/0", a, 0, m, "0 " + std::to_string(inv) + " 0");
}
}
std::cout << " " << (bad ? "FAILED" : "all 256 combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
} // namespace
int main(int argc, char **argv) {
@@ -306,6 +329,7 @@ int main(int argc, char **argv) {
test_add_nc(drv + "raw_add_nc_byte.r8asm") +
test_inc_nc(drv + "raw_inc_nc_byte.r8asm") +
test_neg_nc(drv + "raw_neg_nc_byte.r8asm") +
test_not_nc(drv + "raw_not_nc_byte.r8asm") +
test_sub_nc(drv + "raw_sub_nc_byte.r8asm");
std::cout << (bad ? "FAILED\n" : "byte level library ok\n");
return bad ? 1 : 0;