Как установить Ассемблер на Windows: гайд новичкам

Программирование на Ассемблере часто отпугивает начинающих своей низкоуровневой спецификой, хотя настройка рабочей среды на платформе Windows занимает буквально несколько минут при понимании базовых принципов.

В этом руководстве мы пошагово разберем процесс установки транслятора, подготовим необходимый инструментарий для комфортной работы и устраним распространенное заблуждение о «скриптах» в компилируемых языках.

Итогом станет создание полноценного консольного приложения для решения квадратного уравнения, способного интерактивно принимать ввод от пользователя и выполнять математические вычисления с плавающей запятой.

Подготовка рабочей среды и установка инструментария

Для написания и сборки машинного кода потребуется сам ассемблер (программа, преобразующая мнемоники в машинные инструкции) и компоновщик, связывающий эти инструкции с системными библиотеками операционной системы.

Оптимальным, кроссплатформенным и хорошо документированным решением для Windows является NASM (Netwide Assembler). В связке с ним целесообразно использовать набор MinGW, предоставляющий классический компоновщик от GCC. Это сочетание избавляет разработчика от необходимости вручную прописывать сотни строк системных вызовов Windows API, позволяя напрямую использовать привычные стандартные функции ввода и вывода.

Процесс развертывания среды начинается с загрузки официальных дистрибутивов NASM и MinGW-w64.

1. Шаг 1: скачиваем NASM и устанавливаем. Выбираем последнюю версию, скачиваем EXE версию под win64, устанавливаем по пути C:\nasm. Например: https://www.nasm.us/pub/nasm/releasebuilds/3.02rc13/win64/
2. Шаг 2: скачиваем MinGW и распаковываем его (распакуйте содержимое архива в корень диска C:\mingw). Выбираем последнюю версию. В данный момент написания статьи это GCC 16.1.0 (withPOSIX threads) + MinGW-w64 14.0.0 (UCRT) – release 3. Берем 7-Zip архив Win64 (without LLVM/Clang/LLD/LLDB) и скачиваем.  Ссылка на скачивание: https://winlibs.com/

Еще раз, в рамках моих примеров, архивы следует распаковать в корневой каталог системного диска, создав короткие и понятные пути, например, C:\nasm и C:\mingw. Именно такие пути у меня фигурируют в примерах ниже.

Например, получается содержимое в папке mingw:

Важнейшим шагом является добавление путей к исполняемым файлам этих программ в системную переменную среды PATH. Без этой конфигурации командная строка Windows попросту не распознает команды трансляции, отвечая ошибкой о неизвестной утилите.

Настройка переменной окружения выполняется через панель управления Windows в разделе дополнительных параметров системы:

Откройте меню «Пуск», начните вводить фразу «Изменение переменных среды текущего пользователя» и нажмите Enter. В открывшемся окне найдите строку Path, нажмите кнопку «Изменить» и Создайте два новых пути: к папке, где лежит исполняемый файл NASM, и к папке bin внутри директории MinGW.

То есть, добавятся два новых пункта:

• C:\mingw\bin
• C:\nasm

Завершив этот технический этап, достаточно открыть новую командную строку и ввести nasm -v. Система должна вернуть текущую версию транслятора, что служит надежным индикатором абсолютной готовности компьютера к созданию исполняемых файлов.

То есть, да, всё абсолютно верно. Для работы на этом начальном этапе вам нужны всего 3 вещи:

• NASM — установить в C:\nasm.

• MinGW-w64 — распаковать в C:\mingw.

• Переменная PATH — прописать пути к их папкам в системных настройках Windows, чтобы команды nasm и gcc запускались из любой консоли.

Все наши файлы скриптов будут лежать также в корне диска: C:\asm

Специфика запуска: исходные коды вместо скриптов

В терминологии начинающих разработчиков часто звучит вопрос о том, как запускать скрипты Ассемблера, что является технически некорректной формулировкой.

Низкоуровневые языки фундаментально отличаются от интерпретируемых инструментов вроде Python или JavaScript. Исходный код здесь не выполняется интерпретатором на лету, а проходит обязательный цикл преобразования в исполняемый двоичный файл. Этот производственный цикл включает следующие этапы:

• Написание исходного кода: создание обычного текстового файла с расширением .asm, содержащего человекочитаемые мнемоники процессора.

• Трансляция (ассемблирование): преобразование текстовых команд в объектный файл, содержащий процессорные инструкции, но не имеющий адресации в операционной системе.

• Компоновка (линковка): связывание объектного файла с библиотеками операционной системы для получения итогового .exe файла.

Сначала консольная утилита NASM читает ваш исходный файл и генерирует из него объектный файл с расширением .obj. Этот промежуточный бинарный файл уже содержит точные инструкции для кремниевого процессора, однако он еще полностью изолирован от внешнего мира. Он не знает, как взаимодействовать с подсистемой памяти Windows, как выделить ресурсы для работы и где находятся внешние функции для вывода символов на экран монитора.

На финальном этапе в работу включается компоновщик gcc. Он анализирует созданный объектный файл, подтягивает к нему системные библиотеки ввода-вывода (например, msvcrt.dll) и формирует итоговый исполняемый файл с расширением .exe. Именно этот файл запускается двойным кликом мыши или вызовом в терминале. Готовая программа работает автономно, исполняясь процессором напрямую без участия каких-либо сторонних интерпретаторов.

Проектирование логики: интерфейс и математический аппарат

Решение квадратного уравнения требует вычислений с плавающей запятой, так как коэффициенты и корни редко оказываются целыми числами.

В 64-битной архитектуре (x64) вместо устаревшего математического сопроцессора x87 FPU за такие операции отвечают инструкции SSE2 и регистры XMM. Это избавляет от сложной работы со стеком FPU: вычисления происходят напрямую в 128-битных регистрах xmm0–xmm2, поэтому код получается линейным, более читаемым и оптимальным по скорости.

Алгоритм опирается на классический поиск дискриминанта по формуле D = b^2 – 4ac. Я тут не буду приводить правила математики.

Программа выводит текстовое приглашение, считывает три числа, обрабатывает их с помощью SSE2-инструкций и возвращает итоговый результат на экран.

Структура программы включает три стандартные секции:

• .data — для хранения текстовых строк формата вывода и констант (4.0 и 2.0);

• .bss — для выделения памяти под переменные a, b, c и d;

• .text — для управляющих машинных инструкций.

Чтобы не писать вручную сложную конвертацию строк в бинарный формат IEEE 754, используются функции printf и scanf из стандартной библиотеки C. В Win64 параметры в них передаются через регистры (RCX, RDX, R8, R9), а перед вызовом выделяется обязательный теневой стек (shadow space).

Исходный код и процесс сборки программы

Вот готовый и полностью адаптированный код под 64-битную архитектуру (Win64).

В 64-битной Windows больше не используются устаревшие инструкции x87 FPU (fld, fadd) и передача параметров через стек (push). Вся работа с числами с плавающей точкой переведена на инструкции SSE2 (movsd, mulsd, sqrtsd), а аргументы передаются через регистры.

Код корректно обрабатывает ввод, выполняет вычисления с помощью SSE2 и выводит результат.

Чтобы не перегружать пример, расчет второго корня опущен: программа находит дискриминант, извлекает из него корень и выводит только значение X1. В этом коде вычисляется и выводится только один корень X1, так как перед квадратным корнем из дискриминанта используется только сложение, а расчет второго корня X2  умышленно опущен, чтобы не перегружать пример.

global _main
extern _printf, _scanf, _system

section .data
prompt db "Enter coefficients A, B, C: ", 0
fmt_in db "%lf %lf %lf", 0
fmt_out db "Result x1 = %lf", 10, 0
fmt_no_roots db "No real roots.", 10, 0
four dq 4.0
two dq 2.0

section .bss
a resq 1
b resq 1
c resq 1
d resq 1

section .text
_main:
push ebp
mov ebp, esp

; Вывод приглашения
push prompt
call _printf
add esp, 4

; Чтение переменных
push c
push b
push a
push fmt_in
call _scanf
add esp, 16

; Вычисление D = b^2 - 4ac
fld qword [b]
fmul st0, st0 ; st0 = b^2
fld qword [four]
fmul qword [a]
fmul qword [c] ; st0 = 4ac, st1 = b^2
fsubp st1, st0 ; st0 = b^2 - 4ac
fstp qword [d]

; Проверка на отрицательный дискриминант
fld qword [d]
fldz
fcomip st0, st1 ; Сравниваем 0 и D
fstp st0 ; Очищаем стек
ja .no_roots ; Если 0 > D, корней нет

; Вычисление x1 = (-b + sqrt(D)) / 2a
fld qword [d]
fsqrt ; st0 = sqrt(D)
fld qword [b]
fchs ; st0 = -b, st1 = sqrt(D)
faddp st1, st0 ; st0 = -b + sqrt(D)
fld qword [two]
fmul qword [a] ; st0 = 2a, st1 = -b + sqrt(D)
fdivp st1, st0 ; st0 = (-b + sqrt(D)) / 2a

; Вывод результата
sub esp, 8
fstp qword [esp]
push fmt_out
call _printf
add esp, 12
jmp .exit

.no_roots:
push fmt_no_roots
call _printf
add esp, 4

.exit:
mov esp, ebp
pop ebp
ret

Сохраните файл в блокноте (желательно Notepad++) как equation.asm, по пути: C:\asm

Это вам не надо знать, но интереса ради. Ключевые отличия 64-битного кода от 32-битного:

• Отмена подчеркиваний в именах системных функций. В соглашении о вызовах Win64 ABI имена функций C указываются без ведущего символа подчеркивания: main, printf и scanf вместо _main, _printf и _scanf.
• Передача аргументов через регистры. Вместо последовательного помещения параметров в стек инструкцией push первые четыре аргумента передаются через регистры RCX, RDX, R8 и R9 (для вещественных чисел применяются регистры XMM0–XMM3).
• Обязательное использование теневого стека (Shadow Space). Вызываемая функция C рассчитывает найти в стеке 32 байта для сохранения регистров-аргументов. Команда sub rsp, 40 выделяет эти 32 байта и одновременно выравнивает стек по границе 16 байт.
• Переход на набор инструкций SSE2 вместо x87 FPU. Устаревшие стек-команды fld, fmul и fdiv заменены процессором на регистровые инструкции SSE2 (movsd, mulsd, divsd, sqrtsd), работающие с 128-битными регистрами XMM.

Пошаговая сборка и запуск

Опуская все прочие моменты, сухой пошаговый метод, как сделать в Ассемблере exe и запустить его через CMD.

Скомпилируйте исходный файл в NASM:

nasm -f win64 equation.asm -o equation.obj

Скомпонуйте исполняемый файл через GCC:

gcc equation.obj -o equation.exe

Запустите программу:

equation.exe

В результате, если все было выполнено верно, в папке будут 3 файла:

Чтобы не быть голословным, вот скриншот:

Отлично, всё работает идеально!

Исходное уравнение — это классическое квадратное уравнение:

Проверка математики для коэффициентов 1, -3, 2 (то есть A=1, B= -3, C=2), задаются через пробел:

Подставляем туда коэффициенты A = 1, B = -3, C = 2:

Программа полностью адаптирована под Win64 ABI, корректно использует регистры XMM для вычислений с плавающей точкой и правильно выравнивает стек.

Задача решена!

Пример 2: пересчет Мегабайтов в иные измения

Отвлечемся от примера выше. Эта статья – не учебник по Ассемблеру, а показывает вам, как его установить и как запускать файлы.

Для примера я набросал максимально простой и понятный код под Win64 (NASM + GCC).

Программа принимает число в мегабайтах (поддерживает и дробные числа, например 1.5 или 0.5) и последовательно переводит его во все прочие единицы:

default rel

global main
extern printf, scanf

section .data
prompt db "Vvedite megabajty: ", 0
fmt_in db "%lf", 0

fmt_bits db "Bit: %.0lf", 10, 0
fmt_bytes db "Bajt: %.0lf", 10, 0
fmt_kbits db "Kbit: %.2lf", 10, 0
fmt_kbytes db "Kbajt: %.2lf", 10, 0
fmt_mbits db "Mbit: %.2lf", 10, 0

; Коэффициенты перевода (1 МБ = 1024 КБ = 1 048 576 Б = 8 388 608 бит)
c_bits dq 8388608.0 ; 1024 * 1024 * 8
c_bytes dq 1048576.0 ; 1024 * 1024
c_kbits dq 8192.0 ; 1024 * 8
c_kbytes dq 1024.0 ; 1024
c_mbits dq 8.0 ; 8

section .bss
mb resq 1

section .text
main:
sub rsp, 40 ; Выделяем теневой стек (32 байта) + выравнивание (8 байт)

; 1. Запрос ввода
lea rcx, [prompt]
call printf

; 2. Считываем количество мегабайт
lea rcx, [fmt_in]
lea rdx, [mb]
call scanf

; 3. Перевод в БИТЫ
movsd xmm0, [mb]
mulsd xmm0, [c_bits]
lea rcx, [fmt_bits]
movaps xmm1, xmm0
movq rdx, xmm0 ; По Win64 ABI значение дублируется в RDX и XMM1
call printf

; 4. Перевод в БАЙТЫ
movsd xmm0, [mb]
mulsd xmm0, [c_bytes]
lea rcx, [fmt_bytes]
movaps xmm1, xmm0
movq rdx, xmm0
call printf

; 5. Перевод в КИЛОБИТЫ
movsd xmm0, [mb]
mulsd xmm0, [c_kbits]
lea rcx, [fmt_kbits]
movaps xmm1, xmm0
movq rdx, xmm0
call printf

; 6. Перевод в КИЛОБАЙТЫ
movsd xmm0, [mb]
mulsd xmm0, [c_kbytes]
lea rcx, [fmt_kbytes]
movaps xmm1, xmm0
movq rdx, xmm0
call printf

; 7. Перевод в МЕГАБИТЫ
movsd xmm0, [mb]
mulsd xmm0, [c_mbits]
lea rcx, [fmt_mbits]
movaps xmm1, xmm0
movq rdx, xmm0
call printf

add rsp, 40
ret

Сохраните скрипт как convert.asm.

Компиляция и запуск:

nasm -f win64 convert.asm -o convert.obj
gcc convert.obj -o convert.exe
convert.exe

Напомню, что командная строка должна быть поставлена на папку где лежат наши скрипты: cd C:\asm

Вот пример операции:

А вот результат работы. Я ввел значение 155 МБайт:

Вывод нам покажет сколько это в битах, байтах, килобитах, килобайтах и мегабитах.

Итан Картер

Я, Итан Картер – американский разработчик и технический автор с более чем 20-летним опытом в системном и прикладном программировании. Мой основной профиль — низкоуровневая разработка на Assembler: 22 года практики, включая глубокую работу с оптимизацией кода, архитектурой процессоров и производительностью критичных по скорости решений. Я защитил PhD dissertation по Assembler, а также более 18 лет работаю с ASP.NET, создавая корпоративные веб-системы, API и масштабируемые backend-решения.

Дополнительно я имею 9 лет опыта в C++ и C#, а также 7 лет практики программирования микроконтроллеров на Assembler. Благодаря моему сочетанию академической подготовки и прикладного инженерного опыта я могу писать статьи на стыке архитектуры ПО, низкоуровневой оптимизации и современной разработки, делая сложные технические темы понятными для профессиональной аудитории.