AsmX G3 v30.0.0-rev1.0: мы взорвали четвёртую стену низкоуровневого программирования

17 декабря 2025 года. Три месяца интенсивной разработки, казавшиеся вечностью, позади — и мы на старте. Представьте, что мы запускаем Falcon Heavy в космос, но вместо топлива – чистый интеллект ^[1] и стремление к инновациям. AsmX G3 v30.0.0-rev1.0 – это не просто обновление. Это прорыв, разрывающий границы между ассемблером и высокоуровневыми языками, делающий низкоуровневое программирование доступным, мощным и вдохновляющим. Мы строим ракеты для разработчиков, которые выходят на орбиту производительности и надёжности. Да, в релиз-нотах было сказано «мы сделали совсем немного», но на деле проделана колоссальная работа: от перестройки ядра компилятора до интеграции передовых ISA-фич. Эта статья – ваш полёт по нововведениям AsmX G3 v30.0.0.

CLI и Supervisor: прорывные инновации

Одной из главных проблем современных ассемблеров всегда было масло и раскатывать их при сборке нескольких модулей: десяток запусков компилятора, Makefile или shell-скрипты, чтобы собрать хотя бы три файла. В AsmX G3 v30.0.0 это решено по-другому:

• --multiboot — первая в мире полноценная пакетная компиляция. Одна команда может собрать сразу несколько разных артефактов: загрузчик, ядро, драйверы, библиотеки и приложения. Например:

  asmx --multiboot --release --target amd64 --features all 
    --source boot.asmx      -o boot 
    --source kernel.asmx    -o vkernel 
    --source nvme_driver.asmx -o nvme.ko 
    --source libc.asmx      -o libc.so

  Внутри запускается Supervisor, который автоматически применяет общие флаги ко всем задачам. Каждый --source … -o … формирует независимый подзадачу: свой выходной файл, правильный режим компиляции и т.д. Если один файл упадёт — Supervisor не остановит всю сборку, а продолжит остальные (не надо «всё упало, начинай заново»). Это меняет парадигму: один инженер может собрать полностью рабочую микро-ОС с драйверами и userland одной командой. Ни один другой ассемблер в 2025 году такого не умеет.

• --multiclean — атомарная очистка всех артефактов. Достаточно одной команды:

  asmx --multiclean

  чтобы удалить все скомпилированные .o, .ko, .so и временные файлы, созданные любым предыдущим --multiboot. Больше не надо гадать «где здесь .ko» или делать grep. Это как cargo clean, но для сборки «с нуля» под «голое железо».

• Множественные групповые флаги. Раньше каждый запуск asmx мог принимать один исходник и один выход, и все флаги приходилось дублировать. Теперь парсер понимает повторяющиеся группы --source <файл> -o <имя>. Можно писать сразу:

  asmx --source file1.asmx -o out1.ko 
       --source file2.asmx -o out2.so 
       --source file3.asmx -o out3.bin 
       --release --target amd64 --features all

  — и все общие флаги --release, --target amd64, --features all автоматически применятся ко всем трём файлам. Это делает AsmX G3 первым ассемблером, которым реально удобно пользоваться в CI/CD без внешних обёрток.

Благодаря этим трём инновациям мы уменьшили количество запусков компилятора и скриптов с десятков до единицы, убрали риски рассинхронизации флагов и ручной чистки. Примерно так:

• Раньше: 10 запусков компилятора, 10 разных наборов флагов, риск несоответствия, ручная очистка, Makefile на сотни строк.

• Теперь: 1 запуск asmx, единый набор флагов, гарантированная консистентность, автоматический --multiclean, CI в 5 строк.

Именно поэтому в README проекта теперь гордо пишут:

# Собираем полностью рабочую систему одной командой:
asmx --multiboot --release --target amd64 --features all 
  --source boot.asmx      -o boot 
  --source kernel.asmx    -o vkernel 
  --source nvme_driver.asmx -o nvme.ko 
  --source libc.asmx      -o libc.so

# Удаляем всё, что создали:
asmx --multiclean

Это не просто «удобство» — это новая эра сборки для ассемблеров. Теперь писать на чистом ассемблере стало не сложнее, чем на Rust или Zig, но с нулевым оверхедом и полным контролем над железом. Никуда не нужны .plt/.got или внешние скрипты. Одним asmx мы собираем загрузчик, ядро, модуль ядра и библиотеку в один проход, а команда очистки одним махом удаляет всё.

Пакетирование: –package (только single mode)

Важно: создание дистрибутивных пакетов через --package (например, .deb) доступно только в обычном single-режиме — не в --multiboot. Это сделано преднамеренно: процесс упаковки требует однофайлового окружения и дополнительных пост-компиляционных шагов, которые нельзя атомарно применить к нескольким параллельным задачам.

CLI-флаги: правила и особенности

Ключевые флаги, которые важно знать:

• --source — работает только в режиме --multiboot. Указывает очередной исходный файл для пакетной сборки. Можно повторять ^[2] сколько угодно раз, каждый с последующим -o.

• -o, --objname — универсальный флаг для имени выходного файла. В обычном режиме применяется один раз; в --multiboot парой с каждым --source.

• --multiboot — включает пакетный режим. Активирует Supervisor и позволяет группировать --source + -o.

• --multiclean — режим очистки. Удаляет все артефакты, созданные любым вызовом --multiboot.

Это не просто «еще пара флагов». Это первый в индустрии ассемблер, который можно использовать как нормальный современный инструмент сборки, а не игрушку для энтузиастов. Именно за такие новшества этот релиз называют «взрывом 4-й стены низкоуровневого программирования»: писать на AsmX G3 теперь можно как на обычном языке с нулевыми оверхедами, но с полным контролем над железом.

Почему это инновация

• Универсальный билд: Ни один существующий в 2025 году ассемблер (NASM, FASM, GAS, YASM, clang -S и др.) не умеет собрать одновременно ELF, .ko, .so одной командой.

• Атомарная чистка: Ни у кого из них нет встроенного аналога --multiclean. Обычно нужно ручное удаление или скрипты.

• Простота CI: Нет необходимости писать огромные Makefile/Bazel. Раньше для ассемблера нужен скрипт на 200 строк — теперь достаточно 3–5 строк с asmx.

Секция данных: изменяемые переменные

До v30 все пользовательские переменные AsmX G3 по умолчанию попадали только в секцию .rodata (только для чтения). Это упрощало модель памяти ^[3], но сильно ограничивало возможности (нельзя было определить статическую переменную, которая меняется). В v30.0.0-rev1.0 введена полноценная поддержка секции .data:

• Теперь можно объявлять изменяемые переменные.

• Компилятор автоматически размещает их в .data.

• Все релокации и выравнивания учитываются без дополнительного вмешательства.

• Поведение ^[4] едино для статической библиотеки, модуля ядра и обычного ELF.

Это вроде небольшого изменения, но оно кардинально расширяет класс задач, доступных чистому AsmX G3. Больше не нужны хитрые хаки с внешними C-библиотеками ради одной переменной. Всё можно держать в чистом AsmX-коде. Теперь писать драйверы, библиотеки и рантайм-код на чистом языке стало реально.

Защита от повторного объявления

С добавлением .data введено строжайшее правило: одна переменная — одно имя. Если попытаться объявить переменную с именем, уже использованным ранее — AsmX G3 выдаст ошибку ^[5] компиляции. Раньше подобные ситуации могли тихо приводить к конфликтам символов при линковке. Теперь компилятор явно ругается на override. Такой подход приближает AsmX G3 к современным языкам, где управление пространством имён — не рекомендация, а требование.

Расширение ISA: базовые инструкции x86-64

В этом релизе мы значительно расширили поддержку фундаментального набора инструкций x86-64, без которых невозможна полноценная работа в long mode. Все перечисленные ниже инструкции теперь полностью распознаются парсером, кодируются корректно (с учётом REX-префиксов, операндных размеров и правил sign-/zero-extend) и проходят весь пайплайн компиляции и линковки.

Эти инструкции — минимально необходимый набор для корректного 64-битного кода (точка входа ядра, драйверы, системные библиотеки). Теперь AsmX G3 способен собрать полностью рабочий Linux kernel module без обращения к внешним ассемблерам. Все варианты протестированы на реальном железе (AMD Ryzen, Intel 12/13/14-го поколений) и в QEMU: проверены REX.W для movsxd и push r64, правильное поведение ^[6] push fs/gs и т.д.

Расширение ISA: продвинутые фичи в безопасности и виртуализации

AsmX G3 всегда был нацелен на железо, и в v30 мы «добавили суперчарджеров» к его инструкционной архитектуре. Мы интегрировали многочисленные современные ISA-фичи — инструменты для безопасности, виртуализации и производительности. Статус основных из них:

Эти фичи — не просто набор инструкций, а реальные элеваторы безопасности и производительности. Реализованные, например, IBT и SMAP сразу повышают защищённость систем. Частичные (Shadow Stack) позволяют получить фидбек и «полировать», а VMX на подходе — очередной хайлайт будущего. AsmX G3 v30.0.0 теперь может собрать производительную платформу с защитой против современных атак «из коробки».

Флаги расширений ISA: –features и –features all

AsmX G3 позволяет явно включать наборы ISA-расширений через флаг --features. Это двухуровневая система:

• --features vmx,smap — включает конкретные расширения (например, VMX и SMAP). При включении конкретного расширения компилятор знает про соответствующие инструкции и не будет выдавать ошибку unknown instruction при их использовании.

• --features all — включает все доступные расширения сразу.

Примеры:

# включить только VMX и SMAP
asmx main.asmx --release --target amd64 --features vmx,smap -o app

# включить все поддержанные расширения
asmx main.asmx --release --target amd64 --features all -o app

Используйте точечное включение (vmx,smap) для минимизации набора инструкций и более строгой валидации; --features all удобен для экспериментальных сборок и CI, когда нужен полный набор фич.

Просмотр доступных расширений: –features-list

Чтобы увидеть, какие ISA-расширения доступны для выбранной таргет-архитектуры, используйте --features-list. Это удобно для CI, диагностики и подготовки билдов под конкретное железо.

Пример:

$ asmx --features-list amd64
Process ID: 21142
Welcome, AsmX G3 (AsmX Generation 3)
i Linux (linux 6.17.9) amd64
Features (26 features / 42 instructions): shstk ibt cet smx rdtscp tsc smap pku wbnoinvd pconfig serialize ibhf wrmsrns msrlist pbndkb monitor monitorx rdpru mcommit invlpgb tsxldtrk lahf_lm sse1 sse2 vmx

Строка выдаёт перечень поддержанных расширений (и приближённую статистику). Перед сборкой для специфичного CPU рекомендуется запускать --features-list, чтобы корректно задать --features и избежать неожиданных ошибок компиляции.

Новые возможности языка AsmX G3

Мы продолжаем превращать «голый» ассемблер в язык, на котором приятно и продуктивно писать современные проекты. В v30 добавлено множество синтаксических и семантических улучшений, повышающих удобство и выразительность без потери контроля:

• Вызов функций без скобок: теперь @call my_function выглядит как обычная инструкция, без лишних макросоподобных артефактов. В будущем планируется поддержка нотации my_function(), а текущий вариант оставлен для совместимости.

• Статические функции: ключевое слово static (@fn static name() { ... }) делает функцию видимой только в рамках текущего модуля. Отлично подходит для внутренних хелперов драйверов и библиотек — ничего лишнего в глобальной таблице символов.

• Экспортируемые функции для .so: пометка share (@fn share name() { ... }) автоматически экспортирует функцию (попадает в .dynsym). Теперь не нужно вручную писать .globl: все функции с share сразу доступны из C-кода или других библиотек.

• Шестнадцатеричные/двоичные/восьмеричные литералы: парсер сразу понимает префиксы 0x, 0b, 0o без дополнительного нуля. Можно писать 0xDEADBEEF, 0b1101010, 0o755 без лишних «0х0DEADBEEF» и пр. Это привычно для Rust, Zig, Swift — теперь и для AsmX G3.

• Строковые литералы с полным набором escape-последовательностей: поддерживаются n, t, r, \, x00..xFF, uXXXX, UXXXXXXXX и др. В строках можно прямо вставлять управляющие символы или Unicode. Строки можно передавать в @syscall или помещать в секции .rodata без дополнительных обёрток. Пример:

  @section data {
      msg: str("Ошибка: x1b[31mfailedx1b[0mn")
  }

• Синтаксический сахар для syscall: инструкция @syscall упрощает системные вызовы. Например,

  @syscall($60, $0)              ;; эквивалент exit(0)
  @syscall($1, $1, &msg, $msg.len) ;; эквивалент write(1, msg, len)

  компилятор автоматически распределит аргументы по регистрах в соответствии с System V ABI (rdi, rsi, rdx, r10, r8, r9) и установит номер вызова в %rax. Это реальная инструкция AsmX G3 (не макрос), которая проходит весь парсинг и может использоваться внутри функций.

В итоге эти изменения дают ощущение, что вы пишете не на «голом» ассемблере, а на современном системном языке 2025 года:

• Меньше шума и шаблонов в коде (__share__, static, упрощённый @call).

• Меньше ошибок при вызове системных функций (@syscall вместо «разнести по регистрам вручную»).

• Чёткий механизм экспортирования/скрытия символов.

• Привычные литералы и нормальные строки.

• Возможность быстро собирать как статические, так и динамические библиотеки.

Все эти улучшения уже работают сегодня — без единого внешнего макроса, полностью на уровне парсера и кодогенератора AsmX G3.

Эволюция синтаксиса функций

Отдельно стоит отметить новую функциональную нотацию. Теперь описание функций близко к тому, как мы мысленно формулируем задачу:

• Скобки () теперь опциональны, если у функции нет аргументов (@fn foo вместо @fn foo()).

• Оператор -> для возвращаемого типа тоже опционален (вместо @fn foo()->long можно писать @fn foo long).

• Тело функции в {} всё ещё обязательно.

• Добавлены модификаторы static, share и их комбинации (например, @fn static share ...).

• Синтаксис унифицирован для кода ядра, библиотек и userland.

Возвращаемые типы (экспериментально): можно указывать тип результата после ->. Пока это лишь синтаксический сахар — полноценная механика ещё в разработке. Исключение — main(): для неё уже реализована бета-поддержка -> void. Например, допустимо писать:

@fn foo() -> u8 { 
    ; тело функции
    @mov $0, %rax
    @ret
}

@fn main() -> void {}

Это компилируется и проходит весь пайплайн. ⚠️ Важно: дженерики сейчас лишь на уровне парсера; их семантика и кодогенерация не реализованы и считаются нестабильными. Лучше пока их избегать.

Эти изменения могут показаться «малозначительными», но на деле они меняют восприятие ^[7] языка:

• AsmX G3 перестаёт быть «ассемблером с макросами». Появляется явная модель данных и функций. Код становится самодокументируемым, а компилятор начинает ловить ошибки на этапе компиляции, которые раньше ускользали в рантайм. Это фундамент, на котором строятся нормальные рантаймы, большие драйверы без хака, типовая система будущего и безопасный анализ/оптимизация.

Пример: создаём собственную shared-библиотеку

AsmX G3 v30.0.0-rev1.0 стал первым в мире ассемблером, позволяющим писать полноценные динамические библиотеки (.so) на чистом ассемблере и подключать их к C/C++/Rust/Go-приложениям через стандартный dlopen/LD_LIBRARY_PATH. Пошаговый пример:

1. Пишем библиотеку (libasmm.asmx):

   ;; Простая матбиблиотека + тестовый вывод
   @fn __share__ add() {        ;; long add(long a, long b)
     @mov %rdi, %rax
     @add %rsi, %rax
   }
   
   @fn __share__ sub() {        ;; long sub(long a, long b)
     @mov %rdi, %rax
     @sub %rsi, %rax
   }
   
   @section data {
     msg: str("My own libasmm.so loaded successfully!n")
   }
   
   @fn _local() {
     @mov $1, %rax
     @mov $1, %rdi
     @mov &msg, %rsi
     @mov $39, %rdx
     @syscall
   }
   
   @fn __share__ lc_print() {
     @call _local;
   }

   Обратите внимание ^[8]: @fn share экспортирует add, sub и lc_print. Локальная функция _local не экспортируется. Строковые литералы с n работают прямо «из коробки».

2. Компилируем в .so:

   asmx ./libasmm.asmx 
     --release 
     --target amd64 
     -o libasmm.so 
     --features all 
     --emergency-panic 
     --verbose-common 10

   Флаг --verbose-common 10 просто для подробностей сборки.

3. Пишем тест на C (libasmm_test.c):

   #include <stdio.h>
   extern long add(long a, long b);
   extern long sub(long a, long b);
   extern void lc_print(void);
   
   int main() {
       long a = 100, b = 20;
       printf("a = %ld, b = %ldn", a, b);
       printf("add -> %ld (ожидаем 120)n", add(a, b));
       printf("sub -> %ld (ожидаем 80)n",  sub(a, b));
       lc_print();  // печатает строку из ассемблера
       return 0;
   }

4. Компилируем и запускаем:

   gcc -Wall -O2 -o test_main libasmm_test.c -L. -lasmm
   LD_LIBRARY_PATH=. ./test_main

   Вывод:

   a = 100, b = 20
   add -> 120 (ожидаем 120)
   sub -> 80 (ожидаем 80)
   My own libasmm.so loaded successfully!

Почему это прорыв в 2025 году:

• Другие ассемблеры (NASM/FASM/GAS) требовали вручную писать .plt/.got или оборачивали код в C. У AsmX G3 всё генерируется автоматически.

• Нет понятия «экспортируемая функция» → нужно вручную выставлять global. AsmX G3: просто @fn share, и символ сразу в .dynsym.

• Отсутствуют нормальные строки и escape-последовательности. Теперь есть msg: str("... xFF u2665").

• Нет удобного syscall-инструментария. Мы добавили @syscall, который полностью проходит через парсер.

• Нужны скрипты или Makefile → AsmX G3 v30: одна команда asmx lib.asmx -o libxxx.so.

Теперь можно писать высокопроизводительные математические или криптографические библиотеки, драйверы и прочие модули полностью на AsmX G3 и подключать их в любой C/Rust/Go-проект как обычные .so. Это не просто «еще один способ собрать библиотеку» — это первый случай в истории, когда чистый ассемблер стал полноценным участником современной экосистемы динамических библиотек: без компромиссов по скорости и с максимальным удобством. Готовы заменить свои hand-written .S на чистый, читаемый AsmX G3?

Пример: собственный Linux kernel-модуль

AsmX G3 v30.0.0-rev1.0 стал первым в мире ассемблером, позволяющим писать реальные драйверы для Linux (.ko) без единой строки C. Весь необходимый функционал ядра (modinfo, vermagic, retpoline, секции init/exit) поддерживается. Полный пример минимального драйвера fireware.asmx:

;; fireware.asmx — минимальный Linux kernel module на AsmX G3

@section data {
  init_msg:      str("The init module started.n"),
  cleanup_msg:   str("The finish work of the kmod.n")
}

;; Секция modinfo — метаданные для modinfo/lsmod
@section modinfo {
  license:   str("GPL"),
  author:    str("AsmX Foundation"),
  version:   str("1.0.0"),
  name:      str("fireware"),
  retpoline: str("Y"),
  vermagic:  str("6.17.9-arch-1")   ;; должно совпадать с вашим ядром
}

;; Точка входа (insmod)
@fn __init fireware_init {
  @mov &init_msg, %rdi
  @call _printk
  @mov $0, %rax
}

;; Точка выхода (rmmod)
@fn __exit fireware_cleanup {
  @mov &cleanup_msg, %rdi
  @call _printk
}

Компиляция в модуль:

asmx ./fireware.asmx 
  --release 
  --target amd64 
  -o fireware.ko 
  --features all 
  --emergency-panic 
  --verbose-common 10

Загружаем и проверяем:

sudo insmod fireware.ko
sudo rmmod fireware.ko
sudo dmesg | tail -n 5

В dmesg увидим:

[12345.678901] The init module started.
[12356.789012] The finish work of the kmod.

И modinfo:

filename:       fireware.ko
license:        GPL
author:         AsmX Foundation
version:        1.0.0
name:           fireware
retpoline:      Y
vermagic:       6.17.9-arch-1 SMP preempt mod_unload

Почему это революция:

• В традиционном подходе для .ko нужен C-код и своя запись MODULE_LICENSE и прочие макросы. В AsmX G3 мы просто описываем секцию modinfo — и всё в одном месте.

• Раньше нужно было следить за vermagic и макросами MODULE_*. Теперь компилятор сам вставит вермагик, поддержит retpoline и другие требования ядра.

• Makefile + obj-m → единственная команда asmx driver.asmx -o mydriver.ko.

• Нет контроля над кодогенерацией на ассемблере → AsmX G3 даёт полный контроль и возможность экстремальной оптимизации.

Теперь вы можете написать, например, сетевой драйвер, криптоакселератор, minimal kprobe/tracer, свой планировщик задач или allocator, полностью на AsmX G3, и он загрузится в ядро Linux как обычный .ko. Это первый случай, когда разработчик ядра может практически отказаться от C — и при этом получить полностью валидный, production-ready драйвер. Готовы написать свой драйвер без единой строки C? Одна команда — и ваш код уже в ядре.

Заключение: не конец, а только начало

Мы не просто сделали «ещё один классный ассемблер». Мы создали язык, на котором в 2025–2026 годах можно писать всё: от загрузчика до высокопроизводительных криптографических библиотек и драйверов — и при этом не чувствовать себя в 90‑х. Сегодня AsmX G3 — это:

• Нулевой оверхед. Код компилируется в чистейший машинный, без скрытых накладных расходов.

• Полный контроль над железом. Мы интегрировали все современные инструкции безопасности, виртуализации и оптимизации.

• Современный синтаксис и инструментарий. Функции, строки, литералы — всё как в языках 2025 года.

• Сборка целой ОС одной командой. Ничего не нужно собирать отдельно или через Makefile.

• Поддержка новейших ISA-фич. IBT, SHSTK, TSX, SMAP, PKU и десятки других расширений.

И всё это — на чистом ассемблере. Четвёртая стена низкоуровневого программирования окончательно разрушена. Добро пожаловать в будущее системного кода — оно уже здесь, и называется AsmX G3 v30.0.0-rev1.0.

Готовы собрать свою микро-ОС, драйвер или криптобиблиотеку без единой строки C? Две команды — и ноль C, и полная система:

asmx --multiboot --release --target amd64 --features all 
  --source boot.asmx -o boot 
  --source kernel.asmx -o vkernel 
  --source driver.asmx -o mydriver.ko 
  --source libcrypto.asmx -o libcrypto.so

asmx --multiclean

Welcome to 2028!

• компилятор построен из 16 832 строк кода (.js, .ts, .cts)

• Git diff: 66 files changed, 10 608 insertions(+), 7 130 deletions(-)