🌭 plan9-kencc-linux: кросс-тулчейн Plan9 (cc/as/ld) + EFI-болванка

- build_arch.sh / build_al.sh: сборка kencc-компиляторов, ассемблеров,
  линкеров всех арок (5/6/8/v/q/k) на Linux-хосте через plan9port.
- патчи под musl/gcc: sbrk->mmap, round/log2->p9*, Runemask, swcmp const,
  -fcommon, machcap/omachcap, /sys рантайм-файлы. Подробно в PATCHES.md.
- bin/: готовые 8c 6c 5c vc qc kc + 6a 6l (Linux/musl x86_64).
- efi/: болваночный bootx64.efi (PE32+) тем же тулчейном (6a+6c+6l+dd),
  референс — 9legacy nboot/efi; ESP-образ через mkesp.py.

Co-Authored-By: Claude Opus 4.8 <[email protected]>

21 files changed, 595 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..65f10ac
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,15 @@
+# зависимости, которые тянутся скриптами
+deps/
+efi/nboot.diff
+efi/pe64.s
+efi/pe64min.s
+efi/efi.h
+efi/mem.h
+# артефакты сборки
+build/
+*.o
+*.6 *.5 *.8 *.v *.q *.k
+*.out
+efi/bootx64.efi
+efi/*.img
+y.tab.*
diff --git a/NOTICE b/NOTICE
new file mode 100644
index 0000000..d00feff
--- /dev/null
+++ b/NOTICE
@@ -0,0 +1,22 @@
+plan9-kencc-linux — авторство и лицензии
+========================================
+
+Наш код (сборочные скрипты, efi/hello.c, efi/efi_build.sh, efi/mkesp.py,
+efi/fetch_ref.sh, документация) — свободно используйте.
+
+Собирается из стороннего кода, который НЕ входит в репозиторий, а тянется
+скриптами:
+
+* Компиляторы/ассемблеры/линкеры Plan 9 (kencc) и системные заголовки —
+  из дерева исходников Plan 9 (plan9foundation / совместимого).
+  Оригинальные лицензии Plan 9 (MIT-style, ранее Lucent Public License).
+
+* Тулчейн-обвязка lib9/libbio/libmach и 9c/9l/9ar/yacc — plan9port
+  (https://github.com/9fans/plan9port), лицензии plan9port.
+
+* Референсный EFI-загрузчик (pe64.s, efi.h, mem.h) — 9legacy, nboot/efi
+  (http://9legacy.org/9legacy/patch/nboot.diff). Тянется efi/fetch_ref.sh,
+  в репозитории НЕ хранится. Лицензия — как у соответствующего кода Plan 9.
+
+Готовые бинари в bin/ собраны из вышеуказанных исходников нашими скриптами
+и наследуют их лицензии.
diff --git a/PATCHES.md b/PATCHES.md
new file mode 100644
index 0000000..f8b20aa
--- /dev/null
+++ b/PATCHES.md
@@ -0,0 +1,58 @@
+# Патчи под сборку kencc на Linux-хосте
+
+Все правки автоматически накладываются `scripts/build_arch.sh` и `build_al.sh`
+на свежие копии исходников (оригинальное дерево не трогается). Ниже — что и зачем.
+
+## 1. `round` / `log2` → `p9round` / `p9log2`
+`cc/` определяет свои `round()` и `log2()`, конфликтующие по типу с прототипами
+из musl `math.h`. Переименовываем определения и вызовы во всех файлах (и в
+сгенерённом `y.tab.c`). Файлы: `cc/dcl.c`, `cc/pgen.c`, `cc/sub.c`, `cc/cc.h`,
+`Xc/swt.c`, `Xc/cgen.c`.
+
+## 2. Порядок и единичность `#include "y.tab.h"`
+`y.tab.h` (генерит yacc) использует тип `Node`, объявленный в `cc.h`, и не имеет
+include-guard. Значит: включать строго ПОСЛЕ `cc.h` и ровно один раз (иначе
+конфликт переопределения `YYSTYPE`/`yylval`). В свежем `lex.c` порядок уже
+верный — правка нужна была только при ручной возне.
+
+## 3. Плоская раскладка include
+Исходники ссылаются на соседние каталоги: `#include "../cc/cc.h"`,
+`"../6c/6.out.h"`, `"../8l/elf.h"`, extension-less `"compat"`, `"macbody"`,
+`"lexbody"`. Складываем всё в один каталог сборки и срезаем `../*/` из include.
+Extension-less файлы копируем явно.
+
+## 4. `Runemask`
+Плановская libc-константа `Runemask` (маска 21-битной руны) есть в родной Plan9,
+но НЕ в plan9port. Добавляем `#define Runemask 0x1FFFFF` в `lex.c`.
+
+## 5. Прототип `swcmp` → `const`
+`swcmp` — компаратор для `qsort`. У musl сигнатура `int(const void*, const void*)`,
+а плановский прототип в `gc.h` — `int(void*, void*)`. Приводим прототип к `const`.
+
+## 6. `-fcommon`
+Старый код держит tentative-дефиниции глобалов (напр. `hintabsize` в нескольких
+`.c` через общий `gc.h`). Современный gcc по умолчанию `-fno-common` и ругается на
+multiple definition. Компилируем с `-fcommon` (как раньше).
+
+## 7. `mysbrk`: `sbrk()` → `mmap()`  ← ключевой
+Hunk-аллокатор kencc берёт память через `mysbrk` → `sbrk()`. На musl `sbrk()`
+возвращает `-1` (не поддерживается совместно с malloc), из-за чего `gethunk()`
+падал в «out of memory» → `exits`, причём диагностика уходила в неинициализированный
+Bio-буфер и терялась (компилятор молча выходил с кодом 1). Заменяем тело `mysbrk`
+на анонимный `mmap`. Без этого патча компиляторы линкуются, но не компилируют.
+
+## 8. Дубликат `machcap` / `omachcap`
+`cc/omachcap.c` (старый machcap) и `Xc/machcap.c` (новый) оба определяют `machcap`.
+В родной сборке `omachcap.o` дремлет в архиве `cc.a` и не тянется. У нас — линкуем
+плоско, поэтому: если у арки есть свой `machcap.o` (6c/8c/qc) — выкидываем
+`omachcap.o`; если нет (5c/vc/kc) — `omachcap.o` и предоставляет `machcap`.
+
+## 9. Плановские рантайм-файлы вон
+Файлы вроде `Xc/sys.c` тянут `#include "/sys/src/libc/9syscall/sys.h"` — это
+рантайм ОС, не часть компилятора, и в `OFILES` mkfile их нет. Выкидываем любые
+`.c` с include по абсолютному `/sys/...`.
+
+## 10. Авторитетность `cc/` при конфликте имён (kc)
+У `kc` завалялся собственный устаревший `bits.c`, использующий уже вырезанный из
+plan9port форматный тип `Fconv`. Копируем `cc/`-файлы ПОСЛЕ арочных, чтобы общий
+`cc/bits.c` (новый fmt API) побеждал.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..ba80bb4
--- /dev/null
+++ b/README.md
@@ -0,0 +1,75 @@
+# plan9-kencc-linux
+
+Кросс-сборка **компиляторов / ассемблеров / линкеров Plan 9 (kencc)** для всех
+архитектур **с Linux-хоста**, плюс болваночное **UEFI-приложение** (PE32+),
+собранное этим же тулчейном. Ничего юниксового в цепочке сборки самих `.efi`.
+
+Собрано и проверено на Linux/musl. Пилилось телеграм-ботом (Claude) по заказу
+чата ancap.in.ua.
+
+## Что внутри
+```
+bin/                 готовые бинари: 8c 6c 5c vc qc kc (компиляторы) + 6a 6l
+scripts/
+  setup.sh           клонирует plan9foundation + plan9port, собирает plan9port
+  build_arch.sh <X>  собирает C-компилятор арки X (5|6|8|v|q|k)
+  build_al.sh  <Xa|Xl> собирает ассемблер/линкер
+  build_all.sh       собирает весь кросс-кит
+efi/
+  hello.c            сам EFI-апп (наш код)
+  fetch_ref.sh       тянет pe64.s/efi.h/mem.h из 9legacy (nboot/efi)
+  efi_build.sh       6a+6c+6l -> dd -> bootx64.efi (PE32+)
+  mkesp.py           заворачивает .efi в загрузочный ESP (FAT16)
+patches/             патчи по каждой правке (документация)
+PATCHES.md           почему каждый патч нужен
+```
+
+## Идея
+Фронтенд-компилятора Plan 9 (`cc/`) + кодогенераторы арок (`5c`,`6c`,`8c`,`vc`,`qc`,`kc`)
+пишутся на Plan 9 C и рассчитаны на родную сборку в Plan 9. Мы собираем их на Linux,
+компилируя **plan9port**-овским `9c`/`9l` (они дают `lib9`/`libbio`/`libmach` и
+дружат с хостовым gcc/musl). Всё, что мешает, лечится небольшими патчами (см. `PATCHES.md`).
+
+| арка | комп | ассемблер | линкер |
+|------|------|-----------|--------|
+| 386   | 8c | 8a | 8l |
+| amd64 | 6c | 6a | 6l |
+| arm   | 5c | 5a | 5l |
+| mips  | vc | va | vl |
+| power | qc | qa | ql |
+| sparc | kc | ka | kl |
+
+## Быстрый старт
+```sh
+# 1. зависимости (plan9foundation + plan9port)
+bash scripts/setup.sh
+export PLAN9SRC=$PWD/deps/plan9foundation
+export PLAN9PORT=$PWD/deps/plan9port
+# (опц. musl: export MUSL_ENV=/path/to/env.sh)
+
+# 2. собрать всё
+bash scripts/build_all.sh          # -> build/*/{6c,6a,6l,...}
+
+# 3. один компилятор
+bash scripts/build_arch.sh 6        # -> build/6c/6c
+
+# 4. проверить
+echo 'int f(void){return 42;}' > t.c
+build/6c/6c t.c && ls t.6           # объектник Plan9 .6
+```
+
+## EFI-болванка
+```sh
+cd efi
+./fetch_ref.sh                       # pe64.s/efi.h/mem.h из 9legacy
+PLAN9SRC=$PWD/../deps/plan9foundation ./efi_build.sh
+# -> bootx64.efi : PE32+ x64 EFI_APPLICATION
+python3 mkesp.py bootx64.efi esp.img # -> загрузочный ESP (/EFI/BOOT/BOOTX64.EFI)
+# запуск:  qemu-system-x86_64 -bios OVMF.fd -drive format=raw,file=esp.img
+```
+
+## Готовые бинари
+В `bin/` лежат уже собранные компиляторы/асм/линкер (Linux/musl x86_64).
+Под свой хост пересобери скриптами — байт-в-байт воспроизводимо.
+
+Лицензии и авторство исходников — см. `NOTICE`.
diff --git a/bin/5c b/bin/5c
new file mode 100755
index 0000000..c1e6fcf
--- /dev/null
+++ b/bin/5c
diff --git a/bin/6a b/bin/6a
new file mode 100755
index 0000000..122bd1d
--- /dev/null
+++ b/bin/6a
diff --git a/bin/6c b/bin/6c
new file mode 100755
index 0000000..dfa9c13
--- /dev/null
+++ b/bin/6c
diff --git a/bin/6l b/bin/6l
new file mode 100755
index 0000000..ee75a69
--- /dev/null
+++ b/bin/6l
diff --git a/bin/8c b/bin/8c
new file mode 100755
index 0000000..c178f5f
--- /dev/null
+++ b/bin/8c
diff --git a/bin/kc b/bin/kc
new file mode 100755
index 0000000..1e44e92
--- /dev/null
+++ b/bin/kc
diff --git a/bin/qc b/bin/qc
new file mode 100755
index 0000000..8980901
--- /dev/null
+++ b/bin/qc
diff --git a/bin/vc b/bin/vc
new file mode 100755
index 0000000..574f14c
--- /dev/null
+++ b/bin/vc
diff --git a/efi/README.md b/efi/README.md
new file mode 100644
index 0000000..fa1cdd1
--- /dev/null
+++ b/efi/README.md
@@ -0,0 +1,35 @@
+# efi — болваночный UEFI-апп на портированном тулчейне Plan 9
+
+Минимальное `bootx64.efi` (amd64, формат **PE32+**), собранное **только**
+портированными Plan 9 kencc `6a`/`6c`/`6l` — без юниксовых компиляторов/линкеров.
+
+## Цепочка
+| шаг | утилита | что делает |
+|-----|---------|-----------|
+| 1 | **6a** | ассемблирует `pe64min.s` — DOS/PE32+ заголовок + entry + `eficall` |
+| 2 | **6c** | компилирует `hello.c` (плановские `<u.h>` и т.д.) |
+| 3 | **6l** | линкует свободностоящий образ по `-T0x8000` |
+| 4 | `dd skip=40` | срезает 40-байтный plan9 a.out заголовок → обнажает PE32+ |
+
+`pe64.s` кладёт DOS+PE32+ заголовки первыми в текст-сегмент; линкер раскладывает
+образ от `IMAGEBASE`, а `dd` срезает плановский заголовок — остаётся чистый PE,
+который прошивка грузит из `/EFI/BOOT/BOOTX64.EFI`.
+
+## Сборка
+```sh
+./fetch_ref.sh                              # pe64.s/efi.h/mem.h из 9legacy
+PLAN9SRC=.../plan9foundation ./efi_build.sh # -> bootx64.efi
+python3 mkesp.py bootx64.efi esp.img        # -> загрузочный ESP (FAT16)
+qemu-system-x86_64 -bios OVMF.fd -drive format=raw,file=esp.img
+```
+
+## Что своё, что референс
+* `hello.c`, `efi_build.sh`, `mkesp.py`, `fetch_ref.sh` — наш код.
+* `pe64.s`, `efi.h`, `mem.h` — из 9legacy `nboot/efi` (тянутся, не хранятся).
+  Для болванки от `pe64.s` берём только заголовки+entry+`eficall` (`head -162`);
+  машинерию загрузки ядра (`jump`/`_warp32`/`_gdt`) отбрасываем — ей тут нечего делать.
+
+## Проверка
+`MZ` + `PE\0\0` + Machine `0x8664` + Magic `0x20B` (PE32+) + Subsystem `10`
+(EFI_APPLICATION). `mkesp.py` дополнительно сам обходит FAT обратно и сверяет
+`/EFI/BOOT/BOOTX64.EFI` байт-в-байт с исходным `.efi`.
diff --git a/efi/efi_build.sh b/efi/efi_build.sh
new file mode 100644
index 0000000..51f0ff9
--- /dev/null
+++ b/efi/efi_build.sh
@@ -0,0 +1,32 @@
+#!/bin/bash
+# Собирает болваночный bootx64.efi (PE32+) ПОРТИРОВАННЫМ тулчейном 6a/6c/6l.
+# Предварительно: ./fetch_ref.sh  (достаёт pe64.s/efi.h/mem.h из 9legacy).
+# Требует: BINDIR с 6a/6c/6l (по умолч. ../bin) и PLAN9SRC (плановские include).
+set -e
+cd "$(dirname "$0")"
+BINDIR="${BINDIR:-$PWD/../bin}"
+: "${PLAN9SRC:?export PLAN9SRC — нужны плановские include (amd64/include, sys/include)}"
+IMAGEBASE=0x8000
+export objtype=amd64
+
+[ -f pe64.s ] || { echo "нет pe64.s — сначала ./fetch_ref.sh"; exit 1; }
+# минимальный pe64: MZ+PE заголовки + entry + eficall (без загрузчика ядра)
+head -162 pe64.s > pe64min.s
+
+rm -f *.6 *.out bootx64.efi
+echo "1) 6a  pe64min.s";  "$BINDIR/6a" -DIMAGEBASE=$IMAGEBASE pe64min.s
+echo "2) 6c  hello.c";    "$BINDIR/6c" -I"$PLAN9SRC/amd64/include" -I"$PLAN9SRC/sys/include" hello.c
+echo "3) 6l  link";       "$BINDIR/6l" -l -s -R1 -T$IMAGEBASE -o bootx64.out pe64min.6 hello.6
+echo "4) dd  strip 40b (plan9 a.out header) -> PE32+"
+dd if=bootx64.out bs=1 skip=40 of=bootx64.efi 2>/dev/null
+
+echo "bootx64.efi: $(ls -la bootx64.efi | awk '{print $5}') байт"
+python3 - <<'PY'
+d=open('bootx64.efi','rb').read(); po=int.from_bytes(d[0x3c:0x40],'little'); o=po+24
+ok = d[:2]==b'MZ' and d[po:po+4]==b'PE\x00\x00' \
+     and int.from_bytes(d[po+4:po+6],'little')==0x8664 \
+     and int.from_bytes(d[o:o+2],'little')==0x20b \
+     and int.from_bytes(d[o+68:o+70],'little')==10
+print("PE32+ x64 EFI_APPLICATION:", "OK" if ok else "BAD")
+PY
+echo "ESP-образ:  python3 mkesp.py bootx64.efi esp.img"
diff --git a/efi/fetch_ref.sh b/efi/fetch_ref.sh
new file mode 100644
index 0000000..67b726b
--- /dev/null
+++ b/efi/fetch_ref.sh
@@ -0,0 +1,24 @@
+#!/bin/bash
+# Тянет из 9legacy референсный EFI-загрузчик (nboot/efi) и достаёт из него
+# pe64.s (PE32+ обёртка), efi.h и mem.h. Это НЕ наш код — это Plan9/9legacy,
+# поэтому качаем, а не храним в репе. Наш код — hello.c/efi_build.sh/mkesp.py.
+set -e
+cd "$(dirname "$0")"
+echo ">> качаю 9legacy nboot.diff ..."
+python3 -c "import urllib.request; urllib.request.urlretrieve('http://9legacy.org/9legacy/patch/nboot.diff','nboot.diff')"
+python3 - <<'PY'
+import re
+d=open('nboot.diff').read().splitlines()
+want={'pe64.s','efi.h','mem.h'}; cur=None; buf=[]; out={}
+for l in d:
+    m=re.match(r'^\+\+\+ .*/nboot/efi/(\S+)', l)
+    if m:
+        if cur: out[cur]='\n'.join(buf)
+        cur=m.group(1) if m.group(1) in want else None; buf=[]; continue
+    if cur is not None:
+        if l.startswith('--- '): out[cur]='\n'.join(buf); cur=None; continue
+        if l.startswith('+'): buf.append(l[1:])
+if cur: out[cur]='\n'.join(buf)
+for k,v in sorted(out.items()): open(k,'w').write(v); print('   извлёк', k, f'({len(v.splitlines())} строк)')
+PY
+echo ">> готово: pe64.s efi.h mem.h (референс 9legacy)"
diff --git a/efi/hello.c b/efi/hello.c
new file mode 100644
index 0000000..35cd86d
--- /dev/null
+++ b/efi/hello.c
@@ -0,0 +1,52 @@
+/*
+ * Болваночный EFI-апп для amd64 (bootx64.efi), PE32+.
+ * Собирается ПОРТИРОВАННЫМ тулчейном Plan9 (6c/6a/6l) на Linux/musl:
+ *   PE-заголовок и entry -> pe64.s (ассемблер 6a), из 9legacy nboot/efi.
+ *   Печать -> UEFI SIMPLE_TEXT_OUTPUT_PROTOCOL (efi.h из 9legacy).
+ * Контракт входа задаёт pe64.s: reloc кладёт SystemTable, прыгает на efimain(ih, st).
+ */
+#include <u.h>
+#include "efi.h"
+
+/* глобалы, которых ждёт контракт (как в референсном efi.c) */
+EFI_HANDLE IH;
+EFI_SYSTEM_TABLE *ST;
+
+/* вызов EFI-функции по MS-x64 ABI — реализован в pe64.s */
+extern uintptr eficall(void *fn, ...);
+
+/* печать ASCII-строки через ConOut (конверт в UTF-16, \n -> \r\n) */
+static void
+eputs(char *s)
+{
+	CHAR16 w[2];
+
+	w[1] = 0;
+	for(; *s; s++){
+		if(*s == '\n'){
+			w[0] = '\r';
+			eficall(ST->ConOut->OutputString, ST->ConOut, w);
+		}
+		w[0] = (uchar)*s;
+		eficall(ST->ConOut->OutputString, ST->ConOut, w);
+	}
+}
+
+void
+efimain(EFI_HANDLE ih, EFI_SYSTEM_TABLE *st)
+{
+	IH = ih;
+	ST = st;
+
+	eputs("\n");
+	eputs("+--------------------------------------------------+\n");
+	eputs("|  Hello from a Plan 9 kencc EFI application        |\n");
+	eputs("|  compiler/assembler/linker: 6c / 6a / 6l         |\n");
+	eputs("|  cross-built on Linux/musl, wrapped as PE32+     |\n");
+	eputs("+--------------------------------------------------+\n");
+	eputs("\nefimain reached OK. Idling via BootServices->Stall.\n");
+
+	/* болванка: просто крутимся, чтобы прошивка не считала нас упавшими */
+	for(;;)
+		eficall(ST->BootServices->Stall, (UINTN)1000000);
+}
diff --git a/efi/mkesp.py b/efi/mkesp.py
new file mode 100644
index 0000000..d9ab581
--- /dev/null
+++ b/efi/mkesp.py
@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+# Собирает загрузочный ESP-образ (FAT16) c /EFI/BOOT/BOOTX64.EFI.
+# Без mtools/mkfs — вручную по спецификации FAT, плюс самопроверка (обход обратно).
+import struct, sys, os, math
+
+EFI = sys.argv[1] if len(sys.argv)>1 else "/data/work/chat_-1002129270612/plan9/build/efi/bootx64.efi"
+OUT = sys.argv[2] if len(sys.argv)>2 else "/data/work/chat_-1002129270612/plan9/build/efi/esp.img"
+data = open(EFI,"rb").read()
+
+BPS=512; SPC=1; RSVD=1; NFAT=2; ROOTENT=512; TOT=8192
+rootsecs=(ROOTENT*32+BPS-1)//BPS
+tmp1=TOT-(RSVD+rootsecs); tmp2=256*SPC+NFAT
+FATSZ=(tmp1+tmp2-1)//tmp2
+first_data=RSVD+NFAT*FATSZ+rootsecs
+nclus=(TOT-first_data)//SPC
+assert nclus>4085, f"стало бы FAT12 ({nclus} кластеров)"
+
+img=bytearray(TOT*BPS)
+# --- boot sector / BPB ---
+bs=img
+bs[0:3]=b'\xEB\x3C\x90'; bs[3:11]=b'MSWIN4.1'
+struct.pack_into('<H',bs,11,BPS); bs[13]=SPC
+struct.pack_into('<H',bs,14,RSVD); bs[16]=NFAT
+struct.pack_into('<H',bs,17,ROOTENT); struct.pack_into('<H',bs,19,TOT)
+bs[21]=0xF8; struct.pack_into('<H',bs,22,FATSZ)
+struct.pack_into('<H',bs,24,32); struct.pack_into('<H',bs,26,8)
+bs[36]=0x80; bs[38]=0x29; struct.pack_into('<I',bs,39,0x12345678)
+bs[43:54]=b'PLAN9 EFI  '; bs[54:62]=b'FAT16   '
+bs[510]=0x55; bs[511]=0xAA
+
+# --- распределение кластеров ---
+def nclus_for(n): return max(1,(n+BPS*SPC-1)//(BPS*SPC))
+# EFI(dir)=cl2, BOOT(dir)=cl3, файл=cl4..
+efi_cl=2; boot_cl=3; file_cl=4
+file_ncl=nclus_for(len(data))
+chain={efi_cl:[0xFFFF], boot_cl:[0xFFFF]}
+file_clusters=list(range(file_cl,file_cl+file_ncl))
+
+FAT=[0]*(nclus+2)
+FAT[0]=0xFFF8; FAT[1]=0xFFFF
+FAT[efi_cl]=0xFFFF; FAT[boot_cl]=0xFFFF
+for i,c in enumerate(file_clusters):
+    FAT[c]=0xFFFF if i==len(file_clusters)-1 else file_clusters[i+1]
+
+def wfat():
+    raw=bytearray(FATSZ*BPS)
+    for i,v in enumerate(FAT):
+        if i*2+2<=len(raw): struct.pack_into('<H',raw,i*2,v&0xFFFF)
+    for k in range(NFAT):
+        off=(RSVD+k*FATSZ)*BPS; img[off:off+len(raw)]=raw
+wfat()
+
+def dirent(name,ext,attr,clus,size):
+    e=bytearray(32)
+    e[0:11]=(name.ljust(8)[:8]+ext.ljust(3)[:3]).encode('ascii').upper()
+    e[11]=attr
+    struct.pack_into('<H',e,26,clus&0xFFFF)
+    struct.pack_into('<I',e,28,size)
+    return e
+
+def clus_off(c): return (first_data+(c-2)*SPC)*BPS
+
+# root dir: EFI (dir -> cl2)
+root_off=(RSVD+NFAT*FATSZ)*BPS
+img[root_off:root_off+32]=dirent("EFI","",0x10,efi_cl,0)
+# EFI dir (cl2): '.', '..', BOOT(dir->cl3)
+o=clus_off(efi_cl)
+img[o:o+32]=dirent(".","",0x10,efi_cl,0)
+img[o+32:o+64]=dirent("..","",0x10,0,0)
+img[o+64:o+96]=dirent("BOOT","",0x10,boot_cl,0)
+# BOOT dir (cl3): '.', '..', BOOTX64.EFI(file->cl4)
+o=clus_off(boot_cl)
+img[o:o+32]=dirent(".","",0x10,boot_cl,0)
+img[o+32:o+64]=dirent("..","",0x10,efi_cl,0)
+img[o+64:o+96]=dirent("BOOTX64","EFI",0x20,file_cl,len(data))
+# данные файла
+for i,c in enumerate(file_clusters):
+    chunk=data[i*BPS*SPC:(i+1)*BPS*SPC]
+    off=clus_off(c); img[off:off+len(chunk)]=chunk
+
+open(OUT,"wb").write(img)
+
+# --- САМОПРОВЕРКА: обойти FAT и достать /EFI/BOOT/BOOTX64.EFI ---
+im=open(OUT,"rb").read()
+def rd(a,n): return im[a:a+n]
+def fat(c): return struct.unpack_from('<H',im,(RSVD*BPS)+c*2)[0]
+def readdir(off):
+    ents={}
+    for i in range(0,BPS,32):
+        e=im[off+i:off+i+32]
+        if e[0] in (0,0xE5): continue
+        nm=e[0:8].decode().strip(); ex=e[8:11].decode().strip()
+        cl=struct.unpack_from('<H',e,26)[0]; sz=struct.unpack_from('<I',e,28)[0]
+        key=nm+('.'+ex if ex else '')
+        ents[key]=(cl,sz,e[11])
+    return ents
+root=readdir((RSVD+NFAT*FATSZ)*BPS)
+efi=readdir(clus_off(root['EFI'][0]))
+boot=readdir(clus_off(efi['BOOT'][0]))
+cl,sz,_=boot['BOOTX64.EFI']
+out=bytearray()
+while cl<0xFFF8:
+    out+=im[clus_off(cl):clus_off(cl)+BPS*SPC]; cl=fat(cl)
+out=out[:sz]
+ok = bytes(out)==data
+print(f"ESP: {OUT}  {len(im)} байт  (FAT16, {nclus} кластеров, FATSz={FATSZ})")
+print(f"путь /EFI/BOOT/BOOTX64.EFI: {sz} байт")
+print("самопроверка (обход FAT == оригинал):", "OK" if ok else "FAIL")
diff --git a/scripts/build_al.sh b/scripts/build_al.sh
new file mode 100644
index 0000000..750f9e0
--- /dev/null
+++ b/scripts/build_al.sh
@@ -0,0 +1,57 @@
+#!/bin/bash
+# Собирает Plan9 ассемблер (Xa) или линкер (Xl) на Linux-хосте.
+# Использование:  PLAN9SRC=... PLAN9PORT=...  build_al.sh 6a    |    build_al.sh 6l
+set -e
+T="$1"; [ -z "$T" ] && { echo "usage: $0 <напр. 6a|6l|8a|8l>"; exit 1; }
+X="${T:0:1}"; K="${T:1:1}"
+
+: "${PLAN9SRC:?укажи PLAN9SRC}"; : "${PLAN9PORT:?укажи PLAN9PORT}"
+[ -n "$MUSL_ENV" ] && . "$MUSL_ENV"
+export PLAN9="$PLAN9PORT"; export PATH="$PLAN9/bin:$PATH"
+SRC="$PLAN9SRC/sys/src/cmd"
+OUT="${OUT:-$PWD/build}"; B="$OUT/$T"
+
+rm -rf "$B"; mkdir -p "$B"; cd "$B"
+cp "$SRC/$T"/* "$B"/ 2>/dev/null || true
+cp "$SRC/${X}c"/*.h "$B"/ 2>/dev/null || true       # X.out.h
+cp "$SRC"/cc/compat "$SRC"/cc/macbody "$SRC"/cc/lexbody "$SRC"/cc/cc.h "$B"/ 2>/dev/null || true
+if [ "$K" = "l" ]; then                              # линкеру: имена опкодов + общий ELF-вывод
+  cp "$SRC/${X}c"/enam.c "$B"/ 2>/dev/null || true
+  cp "$SRC"/8l/elf.c "$SRC"/8l/elf.h "$B"/ 2>/dev/null || true
+fi
+
+# ---- патчи (те же, что и для компиляторов) ----
+for c in *.c; do grep -qE '#include[ \t]*[<"]/sys/' "$c" 2>/dev/null && { echo "  пропуск: $c"; rm -f "$c"; }; done
+sed -i 's|"\.\./[a-zA-Z0-9]*/|"|g' *.c *.h 2>/dev/null || true
+sed -i -E 's/\bround\b/p9round/g; s/\blog2\b/p9log2/g' *.c *.h compat macbody lexbody 2>/dev/null || true
+python3 - <<'PY'
+import glob,re
+pat=re.compile(r'\{\s*return\s+sbrk\s*\(\s*(\w+)\s*\)\s*;\s*\}')
+mm='''{
+\tvoid *p;
+\tp = mmap(0, %s, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
+\tif(p == MAP_FAILED) return (void*)-1;
+\treturn p;
+}'''
+for f in glob.glob('*')+['compat']:
+    try: s=open(f).read()
+    except: continue
+    if 'sbrk(' in s and 'mmap' not in s:
+        m=pat.search(s)
+        if m:
+            s2=pat.sub(mm%m.group(1), s, count=1)
+            if '#include <sys/mman.h>' not in s2: s2='#include <sys/mman.h>\n'+s2
+            open(f,'w').write(s2); print("  mmap-патч:",f)
+PY
+[ -f a.y ] && { yacc -d a.y; sed -i -E 's/\bround\b/p9round/g; s/\blog2\b/p9log2/g' y.tab.c 2>/dev/null || true; }
+
+ok=0; fail=0; errf=""; rm -f *.o
+for f in *.c; do
+  if 9c -fcommon -I. "$f" >/tmp/al_$$ 2>&1; then ok=$((ok+1)); else fail=$((fail+1)); [ -z "$errf" ] && errf="$f" && cp /tmp/al_$$ /tmp/alf_$$; fi
+done
+echo "[$T] компиляция: OK=$ok FAIL=$fail"
+[ "$fail" != 0 ] && { echo "первая ошибка ($errf):"; head -10 /tmp/alf_$$; exit 2; }
+
+if [ "$K" = "l" ]; then EXTRA="-lmach"; else EXTRA=""; fi   # линкеру нужен libmach
+9l -o "$T" *.o $EXTRA
+echo "[$T] бинарь: $(ls -la $T | awk '{print $5}') байт  ->  $B/$T"
diff --git a/scripts/build_all.sh b/scripts/build_all.sh
new file mode 100644
index 0000000..7f058aa
--- /dev/null
+++ b/scripts/build_all.sh
@@ -0,0 +1,19 @@
+#!/bin/bash
+# Собирает ВЕСЬ кросс-кит: C-компиляторы + ассемблеры + линкеры всех арок.
+# Требует экспортированных PLAN9SRC и PLAN9PORT (см. setup.sh).
+set -e
+here="$(cd "$(dirname "$0")" && pwd)"
+: "${PLAN9SRC:?export PLAN9SRC (см. scripts/setup.sh)}"
+: "${PLAN9PORT:?export PLAN9PORT (см. scripts/setup.sh)}"
+export OUT="${OUT:-$PWD/build}"
+
+echo "=== C-компиляторы ==="
+for X in 5 6 8 v q k; do bash "$here/build_arch.sh" $X; done
+echo "=== ассемблеры ==="
+for X in 5 6 8 v q k; do bash "$here/build_al.sh" ${X}a || echo "  (${X}a — пропущен/ошибка)"; done
+echo "=== линкеры ==="
+for X in 5 6 8 v q k; do bash "$here/build_al.sh" ${X}l || echo "  (${X}l — пропущен/ошибка)"; done
+
+echo
+echo "=== собранные бинари ($OUT) ==="
+find "$OUT" -maxdepth 2 -type f -perm -u+x \( -name '[0-9kvq][cal]' \) -printf '%f  %s байт\n' 2>/dev/null | sort
diff --git a/scripts/build_arch.sh b/scripts/build_arch.sh
new file mode 100644
index 0000000..3cdc4fb
--- /dev/null
+++ b/scripts/build_arch.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+# Собирает Plan9 kencc C-компилятор для арки X (5,6,8,v,q,k) на Linux-хосте.
+# Использование:  PLAN9SRC=.../plan9foundation PLAN9PORT=.../plan9port  build_arch.sh 6
+# Опц.: MUSL_ENV=.../env.sh (активатор musl-тулчейна), OUT=каталог сборки.
+set -e
+X="$1"; [ -z "$X" ] && { echo "usage: $0 <arch: 5|6|8|v|q|k>"; exit 1; }
+A="${X}c"
+
+: "${PLAN9SRC:?укажи PLAN9SRC — дерево исходников plan9 (plan9foundation)}"
+: "${PLAN9PORT:?укажи PLAN9PORT — собранный plan9port (bin/9c,9l,9ar,yacc + lib/)}"
+[ -n "$MUSL_ENV" ] && . "$MUSL_ENV"
+export PLAN9="$PLAN9PORT"; export PATH="$PLAN9/bin:$PATH"
+SRC="$PLAN9SRC/sys/src/cmd"
+OUT="${OUT:-$PWD/build}"
+B="$OUT/$A"
+
+rm -rf "$B"; mkdir -p "$B"; cd "$B"
+# кодоген арки СНАЧАЛА, потом фронтенд cc/ — cc/ авторитетен при совпадении имён
+# (у kc свой устаревший bits.c с Fconv — берём cc/bits.c)
+cp "$SRC/$A"/*.c "$SRC/$A"/*.h "$B"/
+cp "$SRC"/cc/*.c "$SRC"/cc/*.h "$B"/
+cp "$SRC"/cc/compat "$SRC"/cc/macbody "$SRC"/cc/lexbody "$B"/ 2>/dev/null || true
+
+# ---- ПАТЧИ под линукс-хост ----
+# 0) выкинуть плановские рантайм-файлы (тянут /sys/... хедеры, не часть компилятора)
+for c in *.c; do grep -qE '#include[ \t]*[<"]/sys/' "$c" 2>/dev/null && { echo "  пропуск рантайм: $c"; rm -f "$c"; }; done
+# 1) плоская раскладка: убрать относительные ../cc/ ../Xc/
+sed -i "s|\"\.\./cc/|\"|g; s|\"\.\./${A}/|\"|g" *.c *.h 2>/dev/null || true
+# 2) round/log2 конфликтуют с musl math.h -> p9round/p9log2
+sed -i -E 's/\bround\b/p9round/g; s/\blog2\b/p9log2/g' *.c *.h compat macbody lexbody 2>/dev/null || true
+# 3) Runemask нет в plan9port
+grep -q 'define Runemask' lex.c || sed -i '/#include[ \t]*"y.tab.h"/a #ifndef Runemask\n#define Runemask 0x1FFFFF\n#endif' lex.c
+# 3b) прототип swcmp -> const (musl qsort-компаратор)
+sed -i 's/swcmp(void\*, *void\*)/swcmp(const void*, const void*)/' gc.h *.h 2>/dev/null || true
+# 4) mysbrk: sbrk() на musl отдаёт -1 -> mmap
+python3 - "$B/compat" <<'PY'
+import sys
+p=sys.argv[1]; s=open(p).read()
+old='void*\nmysbrk(ulong size)\n{\n\treturn sbrk(size);\n}'
+new='''#include <sys/mman.h>
+void*
+mysbrk(ulong size)
+{
+\tvoid *p;
+\tp = mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
+\tif(p == MAP_FAILED) return (void*)-1;
+\treturn p;
+}'''
+if old in s: open(p,'w').write(s.replace(old,new)); print("  mmap-патч: ок")
+else: print("  mmap-патч: паттерн не найден")
+PY
+
+# ---- yacc: cc.y -> y.tab.c / y.tab.h ----
+yacc -d cc.y 2>/dev/null || yacc -d "$SRC/cc/cc.y"
+sed -i -E 's/\bround\b/p9round/g; s/\blog2\b/p9log2/g' y.tab.c 2>/dev/null || true
+
+# ---- компиляция (-fcommon: tentative-глобалы под gcc -fno-common) ----
+ok=0; fail=0; errf=""; rm -f *.o
+for f in *.c; do
+  if 9c -fcommon -I. "$f" >/tmp/ba_$$ 2>&1; then ok=$((ok+1)); else fail=$((fail+1)); [ -z "$errf" ] && errf="$f" && cp /tmp/ba_$$ /tmp/baf_$$; fi
+done
+echo "[$A] компиляция: OK=$ok FAIL=$fail"
+[ "$fail" != 0 ] && { echo "первая ошибка ($errf):"; head -8 /tmp/baf_$$; exit 2; }
+
+# ---- линковка: свой machcap.o -> выкинуть omachcap.o; иначе omachcap и есть machcap ----
+if [ -f machcap.o ]; then LINK=$(ls *.o | grep -v '^omachcap.o$'); else LINK=$(ls *.o); fi
+9l -o "$A" $LINK
+echo "[$A] бинарь: $(ls -la $A | awk '{print $5}') байт  ->  $B/$A"
diff --git a/scripts/setup.sh b/scripts/setup.sh
new file mode 100644
index 0000000..2d693f0
--- /dev/null
+++ b/scripts/setup.sh
@@ -0,0 +1,30 @@
+#!/bin/bash
+# Готовит зависимости для сборки тулчейна: исходники plan9 + собранный plan9port.
+# Требуется: git, gcc/clang, make, yacc (или plan9port-овский). Каталоги кладутся
+# рядом со скриптом (или в $DEPS). После — экспортни PLAN9SRC/PLAN9PORT (печатает в конце).
+set -e
+DEPS="${DEPS:-$PWD/deps}"
+mkdir -p "$DEPS"; cd "$DEPS"
+
+# 1) дерево исходников plan9 (plan9foundation — тут живут cc/ и Xc/Xa/Xl)
+if [ ! -d plan9foundation ]; then
+  echo ">> клонирую plan9foundation ..."
+  git clone --depth 1 https://github.com/plan9foundation/plan9.git plan9foundation \
+    || git clone --depth 1 https://git.9front.org/plan9front/plan9front plan9foundation
+fi
+
+# 2) plan9port (даёт 9c/9l/9ar/yacc + lib9/libbio/libmach — ими и собираем kencc)
+if [ ! -d plan9port ]; then
+  echo ">> клонирую plan9port ..."
+  git clone --depth 1 https://github.com/9fans/plan9port.git plan9port
+fi
+if [ ! -x plan9port/bin/9c ]; then
+  echo ">> собираю plan9port (может занять пару минут) ..."
+  ( cd plan9port && ./INSTALL -b )   # -b: только собрать, без установки в систему
+fi
+
+echo
+echo "Готово. Экспортни:"
+echo "  export PLAN9SRC=$DEPS/plan9foundation"
+echo "  export PLAN9PORT=$DEPS/plan9port"
+echo "  # если используешь musl-тулчейн: export MUSL_ENV=/path/to/env.sh"