Руководство по ассемблеру MASM для архитектуры Intel x86-64

Mikl___ · 1 ноя 2026 в 02:27

SIMD
Загрузка в регистры константных значений
Расширения SSE/AVX не поддерживают загрузку в регистры XMM/YMM константных значений, например, числовых литералов. В качестве решения мы, конечно, можно определить переменную с нужным значением и затем использовать одну из инструкций, например, movdqa для загрузки переменной в регистр XMM/YMM.

Код (ASM):

.data

num word 11

.code

main proc

movdqu xmm0, oword ptr num ; загружаем данные

ret

main endp

end

Но это не самый быстрый путь. В качестве альтернативы можно применять различные комбинации логических, арифметических операций и операций сравнения. Посмотрим возможные варианты.
Вначала загружаем в один регистр число 0. Для этого используем операцию XOR с помощью инструкции pxor:

1 pxor xmm0, xmm0 ; XMM0 = 0
Чтобы установить все биты в регистре XMM или YMM в 1, можно использовать инструкцию pcmpeqb

1 pcmpeqb xmm1, xmm1 ; XMM1 = -1
Так как любой регистр XMM или YMM равен самому себе, эта инструкция сохраняет 0FFh во всех байтах XMM1.
Например, чтобы получить 1, мы можем вычесть из 0 число -1:

1
2
3 pxor xmm0, xmm0
pcmpeqb xmm1, xmm1
psubb xmm0, xmm1 ; 0 - (-1) = 1
Здесь применяется вычитание байтов с помощью инструкции psubb, но аналогично можно применять инструкции psubw или psubd для получения 16- или 32-битного результата
Если необходимо получить другое число, то можно использовать, например, инструкцию pslld. Например, если вы хотите загрузить в регистр XMM0 значение 8080808080808080h, вы можете использовать следующую последовательность инструкций:

1
2
3
4 pxor xmm0, xmm0
pcmpeqb xmm1, xmm1
psubb xmm0, xmm1
pslld xmm0, 7 ; сдвигаем 01h на 4 разряда влево, получаем 80h в каждом байте
Сдвигая число в регистре на разное количество бит, можно получать различные значения.
Для загрузки 2n – 1 (когда все биты вплоть до n-го бита в числе равны 1) можно применять следующий способ:

1
2
3
4
5
6
7
8
9
10
11 ; для 16-битных дорожек
pcmpeqd xmm0, xmm0
psrlw xmm0, 16 - n ; Очищаем правые 16 - n бит в xmm0
; для 32-битных дорожек
pcmpeqd xmm0, xmm0
psrld xmm0, 32 - n ; Очищаем правые 32 - n бит в xmm0
; для 64-битных дорожек
pcmpeqd xmm0, xmm0
psrlq xmm0, 64 - n ; Очищаем правые 64 - n бит в xmm0
Подобным образом можно сдвигать влево:

1
2
3
4
5
6
7
8
9
10
11 ; для 16-битных дорожек
pcmpeqd xmm0, xmm0
psllw xmm0, n ; сбрасываем левые n бит в xmm0
; для 32-битных дорожек
pcmpeqd xmm0, xmm0
pslld xmm0, n ; сбрасываем левые n бит в xmm0
; для 64-битных дорожек
pcmpeqd xmm0, xmm0
psllq xmm0, n ; сбрасываем левые n бит в xmm0
Например, загрузим в XMM1 число 7:

Код (ASM):

pcmpeqd xmm1, xmm1

psrld xmm1, 32 - 3 ; XMM1 = 7

Здесь сдвигаем двойное слово (32-битное число) на 29 разрядов влево, то есть остается 3 разряда, которые равны 111 или 7 в десятичной.

Mikl___ · 1 ноя 2026 в 02:32

SIMD
Сохранение состояния регистров SSE/AVX
При работе с инструкциями расширений SSE/AVX нам может потребоваться сохранить значения регистров XMM/YMM. Рассмотрим на примере сохранения первых 6 регистров XMM/YMM:

Код (ASM):

.data

AVXSupport = 10000000h ; проверяем бит 28

.code

main proc

; Резервируем в стеке место для регистров AVX/SSE

; Для 6 регистров SSE необходимо только 96 байт

; Для 6 регистров AVX 196 байт

; Выделяем одно пространство для двух типов расширений - 196 байт

; Тогда SSE просто игнорируют дополнительные 64 байта

sub rsp, 192

; Определяем, доступны ли расширения AVX и соответственно регистры YMM

mov eax, 1

cpuid

and ecx, AVXSupport ; проверяем на поддержку AVX бит 28

jnz saveAVX ; если AVX доступно, переходим к метке preserveAVX

; Если поддержка расширений AVX отсутствует, сохраняет состояние регистров XMM0-XMM5

movdqu xmmword ptr [rsp + 00], xmm0

movdqu xmmword ptr [rsp + 16], xmm1

movdqu xmmword ptr [rsp + 32], xmm2

movdqu xmmword ptr [rsp + 48], xmm3

movdqu xmmword ptr [rsp + 64], xmm4

movdqu xmmword ptr [rsp + 80], xmm5

jmp afterSave

; сохраняем состояние регистров YMM0-YMM5

saveAVX:

vmovdqu ymmword ptr [rsp + 000], ymm0

vmovdqu ymmword ptr [rsp + 032], ymm1

vmovdqu ymmword ptr [rsp + 064], ymm2

vmovdqu ymmword ptr [rsp + 096], ymm3

vmovdqu ymmword ptr [rsp + 128], ymm4

vmovdqu ymmword ptr [rsp + 160], ymm5

afterSave: ; здесь какие-нибудь действия в программе

mov rax, 15 ; например, поместим в регистр RAX какое-нибудь число

; восстанавливаем значения регистров - в регистре ECX по прежнему значение для AVXSupport

; можно его использовать, чтобы заново не вызывать инструкцию cpuid

and ecx, AVXSupport ; проверяем на поддержку AVX бит 28

jnz restoreAVX ; если AVX доступно, переходим к метке restoreAVX

; если не доступно AVX, восстанавливаем регистры XMM

movdqu xmm0, xmmword ptr [rsp + 00]

movdqu xmm1, xmmword ptr [rsp + 16]

movdqu xmm2, xmmword ptr [rsp + 32]

movdqu xmm3, xmmword ptr [rsp + 48]

movdqu xmm4, xmmword ptr [rsp + 64]

movdqu xmm5, xmmword ptr [rsp + 80]

jmp exit

; восстанавливаем регистры YMM

restoreAVX:

vmovdqu ymm0, ymmword ptr [rsp + 000]

vmovdqu ymm1, ymmword ptr [rsp + 032]

vmovdqu ymm2, ymmword ptr [rsp + 064]

vmovdqu ymm3, ymmword ptr [rsp + 096]

vmovdqu ymm4, ymmword ptr [rsp + 128]

vmovdqu ymm5, ymmword ptr [rsp + 160]

exit:

add rsp, 192

ret

main endp

end

Как и в общем случае, проблема может заключаться в том, что мы можем не знать точно, какие именно расширения поддерживаются на текущей машине. Поэтому сначала с помощью инструкции cpuid проверяем наличие поддержки регистров YMM. Для этого к результату инструкции в регистре ECX применяем маску AVXSupport, которая выявляет установку 28 бита (который собственно и говорит о поддержке AVX):

Код (ASM):

mov eax, 1

cpuid

and ecx, AVXSupport ; проверяем на поддержку AVX бит 28

jnz saveAVX

Если бит установлен, соответственно после выполнения инструкции AND результат ненулевой, то переходим к метке saveAVX для сохранения состояния регистров YMM. Если бит не установлен, то сохраняем регистры XMM.
Для сохранения 6 регистров XMM нужно 16 байт * 6 = 96 байт. На сохранение 6 регистров YMM - 196 байт. В данном случае для простоты для обоих типов регистров в стеке выделяется 196 байт. Затем последовательно сохраняем регистры:

Код (ASM):

movdqu xmmword ptr [rsp + 00], xmm0

movdqu xmmword ptr [rsp + 16], xmm1

movdqu xmmword ptr [rsp + 32], xmm2

movdqu xmmword ptr [rsp + 48], xmm3

movdqu xmmword ptr [rsp + 64], xmm4

movdqu xmmword ptr [rsp + 80], xmm5

jmp afterSave

; сохраняем состояние регистров YMM0-YMM5

saveAVX:

vmovdqu ymmword ptr [rsp + 000], ymm0

vmovdqu ymmword ptr [rsp + 032], ymm1

vmovdqu ymmword ptr [rsp + 064], ymm2

vmovdqu ymmword ptr [rsp + 096], ymm3

vmovdqu ymmword ptr [rsp + 128], ymm4

vmovdqu ymmword ptr [rsp + 160], ymm5

При завершении программы аналогично восстанавливаем регистры.

Mikl___ · 1 ноя 2026 в 02:43

Строки
Операции со строками
Строки представляют набор значений, который хранится в непрерывной области памяти. Процессор x86-64 поддерживает работу с 4 типами строк: строки значений byte, строки из чисел word, строки из двойных слов и строки из четверных слов. Для работы с этим строками процессор x86-64 предоставляет ряд инструкций для копирования, сравнения, поиска в строке и ряд других инструкций, которые далее будут рассмотрены.
Строковые инструкции используют определенные регистры в качестве операндов:

RSI: хранит индекс значений исходной строки

RDI: хранит индекс значений целевой строки

RCX: счетчик значений

AL, AX, EAX и RAX

Флаги в регистре FLAGS

Копирование строк
Для копирования строк применяются следующие инструкции:

movsb: извлекает байт по адресу RSI, сохраняет его по адресу RDI, а затем увеличивает или уменьшает регистры RSI и RDI на 1.

movsw: выбирает слово по адресу RSI, сохраняет его по адресу RDI, а затем увеличивает или уменьшает RSI и RDI на 2.

movsd: извлекает двойное слово по адресу RSI, сохраняет его по адресу RDI, а затем увеличивает или уменьшает регистры RSI и RDI на 4.

movsq: извлекает четверное слово по адресу RSI, сохраняет его по адресу RDI, а затем увеличивает или уменьшает регистры RSI и RDI на 8.

Например, скопируем одну строку в другую:

Код (ASM):

.data

nums1 word 10, 11, 12, 13, 14, 15, 16, 17

nums2 word 8 dup (?)

.code

main proc

lea rsi, nums1

lea rdi, nums2

mov rcx, 8 ; 8 элементов в nums1

movsw

ret

main endp

end

Здесь копируем данные из nums1 в nums2. Для этого адрес исходной строки nums1 загружаем в RSI, а адрес целевой строки nums2 - в регистр RDI. В RCX помещаем количество элементов , которые надо скопировать. Важно, что речь идет о количестве элементов, а не байт. Так, в данном случае мы хотим скопировать все 8 элементов из nums1 в nums2, которые в целом занимают 16 байт. И для копирования слов выполняем инструкцию movsw.
Однако по умолчанию все инструкции копирования помещают только первый элемент исходной строки в целевую строку. Но нам то нужно в данном случае скопировать 8 чисел. Для повторения копирования применяется префикс rep
Префикс rep
Префикс rep (repeat повторять) указывается перед инструкцией, которая работает со строками. Так, если префикс rep присутствует, при выполнении инструкции movsb процессор проверяет RCX, чтобы увидеть, содержит ли этот регистр число 0. Если не содержит, то процессор перемещает байт из RSI в RDI и уменьшает значение в регистре RCX. Этот процесс повторяется до тех пор, пока RCX не станет равным 0. Если RCX содержит 0 при первоначальном выполнении, инструкция movsb не будет копировать байты данных.
Например, изменим предыдущую программу, применив rep:

Код (ASM):

.data

nums1 word 10, 11, 12, 13, 14, 15, 16, 17

nums2 word 8 dup (?)

.code

main proc

lea rsi, nums1

lea rdi, nums2

mov rcx, 8

rep movsw

movzx rax, nums2[4] ; проверяем 3-й элемент из nums2, он должен быть равен 12

ret

main endp

end

Префикс rep указывает процессору повторить эту операцию столько раз, сколько указано в регистре RCX.
Стоит отметить, что конкретно в случае выше процесс копирования не является оптимальным: нам надо скопировать 8 слов или 16 байт, и это количество кратно 8. На первый взгляд для копирования слов надо использовать инструкцию movsw, которая собственно и предназначена для копирования слов. Но для ассемблера в данном случае нет разницы - скопирует он 8 раз по 2 байта последовательно расположенные данные или скопирует теже данный 2 раза но по 8 байт. Поэтому в случае выше мы могли бы применить копирование по восьмеричным словам:

Код (ASM):

.data

nums1 word 10, 11, 12, 13, 14, 15, 16, 17

nums2 word 8 dup (?)

.code

main proc

lea rsi, nums1

lea rdi, nums2

mov rcx, 2 ; 8 слов - это два четверных слова

rep movsq ; копируем по четверному слову

movzx rax, nums2[4] ; проверяем 3-й элемент из nums2, он должен быть равен 12

ret

main endp

end

Если количество байто не кратно 8 или вообще нечетное, то для большей эффективности можно комбинровать копирование различных данных:

Код (ASM):

.data

nums1 word 10, 11, 12, 13, 14, 15, 16, 17, 18

nums2 word 9 dup (?)

.code

main proc

lea rsi, nums1

lea rdi, nums2

mov rcx, 2 ; 9 слов - это 2 четверных слова + 1 слово

rep movsq ; копируем по четверному слову

movsw ; копируем одно слово

movzx rax, nums2[8*2] ; RAX = 18

ret

main endp

end

В данном случае для копирования данных потребуется две инструкции movsq и одна инструкция movsw. Даная схема наиболее эффективна, если оба массива выровнены по границам четырех слов. Если подобного выравнивания нет, то можно переместить инструкции, которые копируют меньшее количество данных - в данном случае movsw до инструкции movsq, чтобы movsq работала с данными, выровненными по четырём словам:

Код (ASM):

.data

rnd1 dword 1

rnd2 word 2

nums1 word 10, 11, 12, 13, 14, 15, 16, 17, 18 ; не выровнено по четверным словам

nums2 word 9 dup (?)

.code

main proc

lea rsi, nums1

lea rdi, nums2

mov rcx, 2 ; 9 слов - это два четверных слова + 2 двойных слова

movsw ; копируем 1 слово

rep movsq ; копируем по четверному слову

movzx rax, nums2[6*2] ; RAX = 18

ret

main endp

end

Направление копирования
Флаг направления в регистре FLAGS управляет навправлением копирования элементво строк. Если флаг направления сброшен, процессор увеличивает RSI в RDI после обработки каждого элемента строки. Например, инструкции movs скопируют байт, слово, двойное слово или четверное слово из RSI в RDI, а затем увеличат RSI и RDI на 1, 2, 4 или 8 (соответственно). Если флаг направления установлен, x86-64 уменьшает RSI в RDI после обработки каждого элемента строки.
Для управления флагами направления применяются инструкции cld (сброс флага направления) и std (установка флага направления). Например, скопируем данные из одной строки в другую в противоположном направлении:

Код (ASM):

.data

nums1 word 10, 11, 12, 13, 14, 15, 16, 17

len = $ - nums1 ; размер массива

count = len / 2 ; количество элементов

elemSize = 2 ; размер одного элемента

nums2 word 8 dup (?)

.code

main proc

lea rsi, nums1

add rsi, len - elemSize ; указывает на последний элемент

lea rdi, nums2

add rdi, len - elemSize ; указывает на последний элемент

mov rcx, count; RCX = 8

std ; устанавливаем флаг направления

rep movsw

movzx rax, nums2[7 * elemSize] ; проверяем последний элемент, он должен быть равен 17

ret

main endp

end

Здесь регистры RSI и RDI перед копированием строки указывают на последний элемент строки. И при вызове инструкции movsw сначала копируются последниие элементы строки, потом предпоследние и так далее вплость до первого элемента.
Стоит отметить, что при работе с внешними API могут применяться определенные требования к флагам направления. Так, Microsoft ABI требует, чтобы флаг направления был сброшен при вызове функции, которая совместима с Microsoft ABI (например, функции C/C++ на Windows). Поэтому, если внутри процедуры на ассемблере требуется установить флаг направления, то после завершения использования флага его надо сбросить (в частности перед вызовом любого другого кода или возвратом из процедуры).
Копирование в обратном направлении может быть применяться, когда нам надо сдвинуть элементы строки. Например:

Код (ASM):

.data

nums1 word 0

nums2 word 10, 11, 12, 13, 14, 15, 16, 17

len = $ - nums2 ; размер массива

count = len / 2 ; количество элементов

elemSize = 2 ; размер одного элемента

.code

main proc

lea rsi, nums1

add rsi, len - elemSize ; указывает на предпоследний элемент nums2

lea rdi, nums2

add rdi, len - elemSize ; указывает на последний элемент

mov rcx, count; RCX = 8

std ; устанавливаем флаг направления

rep movsw

movzx rax, nums2[7*elemSize] ; проверяем 7-й (последний) элемент, он должен быть равен 16

ret

main endp

end

Здесь следует отметить одну особенность - поскольку данные в памяти будут располагаться последовательно, и за числом nums1 сразу будет идти nums2, то на уровне программы мы можем рассматривать nums1 не просто как одиночное число, но и как массив, который перекрывает nums2. Соответственно выражение nums1[7*elemSize] - аналогично обращению к 6-му элементу массива nums2 (nums1[6*elemSize]). И при установки источника копирования регистр RSI содержит адрес предпоследнего элемента в nums2:

Код (ASM):

lea rsi, nums1

add rsi, len - elemSize

Хотя в принципе мы могли бы использовать в качестве источника и массив nums2:

Код (ASM):

lea rsi, nums2

add rsi, len - 2 * elemSize ; указывает на предпоследний элемент

В итоге при копировании последний элемент nums1 (предпоследний элемент nums2) копируется в последний элемент nums2 и так далее:

Код (ASM):

0, 10, 11, 12, 13, 14, 15, 16, 17

0, 0, 10, 11, 12, 13, 14, 15, 16

Mikl___ · 1 ноя 2026 в 02:46

Строки
Сравнение строк
Для сравнения строк из различных типов чисел применяются инструкции

cmpsb: сравнивает строку байтов

cmpsw: сравнивает строку из слов

cmpsd: сравнивает строку из двойных слов

cmpsq: сравнивает строку из четверных слов

Процессор сравнивает значение, на которое ссылается регистр RDI, со значением, на которое указывает регистр RSI. RCX содержит количество элементов в исходной строке (не путать с количеством обрабатываемых байтов).
Вместе с этой инструкцией можно использовать ряд префиксов:

Префикс repe указывает повторять операцию до тех пор, пока сравнение равно, или до количества раз, указанного RCX (в основном применяется для сравнений символьных строк).

Префикс repne повторяет операцию, пока сравнение не равно, или до количества раз, указанного RCX

Без применения этих префиксов инструкции cmps вычитают значение в RDI из значения в RSI и обновляет флаги в соответствии с результатом. После сравнения двух чисел cmps увеличивает или уменьшает регистры RSI и RDI на 1, 2, 4 или 8 (для cmpsb, cmpsw, cmpsd и cmpsq соответственно). cmps увеличивает регистры RSI и RDI, если флаг направления сброшен, и уменьшает их, если флаг установлен. Например, сравненим равные по длине массивы:

Код (ASM):

.data

nums1 word 10, 11, 12, 13, 14, 15, 16, 17

nums2 word 10, 11, 12, 13, 14, 15, 16, 17

.code

main proc

lea rsi, nums1

lea rdi, nums2

mov rcx, 8 ; 8 слов

repe cmpsw ; сравниваем слова

jz equal

mov eax, 0 ; если строки не равны

jmp exit

equal:

mov eax, 1 ; если строки равны

exit:

ret

main endp

end

Здесь сравниваем два массива чисел. Если они равны, помещаем в EAX число 1, если не равны - число 0.
Если строки имеют или могут иметь разную длину, то задача немного усложняется. Две строки равны, когда их длины равны и элементы в соответствующих позициях равны. Если одна из строк меньше другой, но все ее элементы равны соответствующим символам второй строки (то есть первая строка является подстрокой второй строки), то мы можем считать что первая строка меньше второй.
В этом случае в регистр RCX помещается длина наименьшей строки. Далее обе строки сравниваются как и вобщем случае. И если они равны, сравниваются их длины.
Пример сравнения двух строк:

Код (ASM):

.data

str1 byte "Hello World", 0

str1_len = $ - str1 ; длина первой строки

str2 byte "Hello World", 0

str2_len = $ - str2 ; длина второй строки

.code

main proc

lea rsi, str1

lea rdi, str2

mov rcx, str1_len

cmp rcx, str2_len ; сравниваем длины строк

jbe compare ; если длина num1 равна или меньше

mov rcx, str2_len ; если длина num2 меньше

compare:

repe cmpsb ; сравниваем байты

jnz notequal ; если не равны

mov rcx, str1_len

cmp rcx, str2_len ; если равны, сравниваем длины строк

jnz notequal

mov eax, 1 ; если строки равны

jmp exit

notequal:

mov eax, 0 ; если строки не равны

exit:

ret

main endp

end

Строки символов обычно сравниваются в алфавитном порядке. Поскольку символы фактически представлены их числовами кодами, то сравнение символов выливается в сравнение их числовых кодов (в данном случае для простоты считаем, что символы в разных регистрах - это разные символы).
Сравнение больших чисел
Инструкции cmps удобны для сравнения очень больших чисел, которые выходят за пределы 64 бит. Например:

Код (ASM):

.data

num1 qword 0000000000000005h, ; младшие 64 бита

0000000000000002h ; старшие 64 бита

num2 qword 0000000000000005h, ; младшие 64 бита

0000000000000002h ; старшие 64 бита

.code

main proc

lea rsi, num1[8] ; загружаем адрес старших 64 битов

lea rdi, num2[8] ; загружаем адрес старших 64 битов

mov rcx, 2 ; сравниваем 2 qword - младшие и старшие 64 бита

std ; устанавливаем обратный порядок сравнения

repe cmpsq ; сравниваем qword

cld ; после сравнения сбрасываем флаг направления

jnz notequal

mov eax, 1 ; если строки равны

jmp exit

notequal:

mov eax, 0 ; если строки не равны

exit:

ret

main endp

end

Здесь сравниваются два 128-разрядных числа. Каждое число фактически представляет массив из двух чисел qword - младших и старших 64 битов. Общий алгоритм сравнения подобных чисел заключается в последовательном сравнении их соответствующих 64 разрядов. Если старшие 64 разряда не равны, то числа уже не равны. Если старшие 64 разряда равны, то сравниваются следующие 64 разряда и так далее.
Поскольку вначале массива, который представляет 128-разрядное число располагается младшие 64 бит, то нам надо сравнивать с конца. Для этого загражаем в регистры RSI и RDI старшие 64 разряды и устанавливаем флаг направления с помощью инструкции std. Для сравнения каждой 64-разрядной части применяем инструкцию cmpsq

Mikl___ · 1 ноя 2026 в 02:48

Строки
Поиск в строке
Для поиска определенного элемента в строке применяется следующий набор инструкций:

scasb: поиск в строке байтов

scasw: поиск в строке слов

scasd: поиск в строке двойных слов

scasq: поиск в строке четверных слов

Данные инструкции принимают только один операнд - строку, в которую помещается результат поиска и адрес которой загружается в регистр RDI. Строка для поиска загружается в регистре AL (scasb), AX (scasw), EAX (scasd) или RAX (scasq). Инструкции scas сравнивают значение в аккумуляторе (AL, AX, EAX или RAX) со значением, на которое указывает RDI, а затем увеличивает (или уменьшает) значение RDI на 1, 2, 4 или 8. В соответствии с результатом сравнения процессор устанавливает флаги. Так, если символ найден, то устанавливается флаг нуля, а регистр RDI указывает на символ, следующий за найденным.
При применении префикса repe инструкции scas просматривают строку в поисках элемента, не соответствующего значению в аккумуляторе. При использовании префикса repne scas сканирует строку в поисках первого элемента, равного значению в аккумуляторе. Регистр RCX в этом случае хранит количество элементов, а не байтов, которые необходимо обработать при сканировании.
Например, найдем индекс символа в строке:

Код (ASM):

.data

text byte "Hello", 0

len = $ - text ; длина первой строки

char byte 'l' ; символ для поиска

.code

main proc

lea rdi, text ; загружаем адрес переменной text

mov rsi, rdi ; копируем адрес в RSI для последующего поиска индекса

mov al, char ; в AL символ для поиска

mov rcx, len ; в RCX количество символов строки

repne scasb ; ищем байт

jz found ; если символ найден, устанавливается флаг нуля ZF

mov rax, -1 ; если символ не найден, в RAX число -1

jmp exit

found:

sub rdi, rsi ; если символ найден, получаем индекс следующего символа после найденного

dec rdi ; отнимает 1 байт - получем индекс найденного символа

mov rax, rdi ; в RAX индекс

exit:

ret

main endp

end

Здесь в строке "Hello" ищем символ "l". Для этого строку для поиска загружаем в RDI, а в AL - символ (байт), который будем искать.
Если при выполнении инструкции scas элемент был найден, то устанавливается флаг нуля. И мы можем это проверить и выполнить определенные действия. В данном случае, если символ найден, от значения в RDI (адрес следующего символа за найденным) отнимаем начальный адрес строки text (адрес первого символа строки text), который для удобства сохранили в регистр RSI и таким образом получаем расстояние в байтах между первым символом и следующим за найденным символом. Поскольку все элементы строки - байты, то это расстояние будет представлять индекс следующего символа за найденным. Соответственно, чтобы получить индекс найденного символа (а не следующего за ним), надо от этого расстояния отнять 1 (размер одного элемента в байтах). Например, при поиске символа "l" в строке "Hello" мы получим 2 - это индекс третьего символа.
Если символ не найден, то в регистр RAX помещаем -1.

Mikl___ · 1 ноя 2026 в 02:51

Строки
Сохранение и получение элементов строк
stos
Инструкция stosX сохраняет значение аккумулятора в месте, на которое указывает регистр RDI. После сохранения значения процессор увеличивает или уменьшает значение в RDI в зависимости от состояния флага направления. Данная инструкция имеет следующие формы:

stosb: сохраняет байт из регистра AL в место по адресу из регистра RDI

stosw: сохраняет слово из регистра AX в место по адресу из регистра RDI

stosd: сохраняет двойное слово из регистра EAX в место по адресу из регистра RDI

stosq: сохраняет четверное слово из регистра RAX в место по адресу из регистра RDI

Например, изменим изменим определенный элемент массива чисел word, сохранив в него число:

Код (ASM):

.data

numbers word 20, 21, 22, 23, 24, 25

len = $ - numbers ; длина строки

elemSize = 2 ; размер одного элемента

num word 33 ; число для сохранения

.code

main proc

lea rdi, numbers[2*elemsize] ; загружаем адрес третьего элемента массива numbers

xor rax, rax

mov ax, num ; загружаем слово для замены

stosw ; сохраняем по адресу в RDI слово num

mov ax, word ptr numbers[2 * elemSize] ; проверяем третий элемент массива numberss

ret

main endp

end

В данном случае сохраняем число word по адресу в RDI, который указывает на третий элемент в массиве numbers/
С префиксом rep этот процесс повторяется столько раз, сколько указано в регистре RCX.
Частое применение данной инструкции - инициализация массивов и строк некоторым значением. Например, если имеется массив, который надо заполнить числом 2, то можно использовать следующий код

Код (ASM):

.data

numbers word 20, 21, 22, 23, 24, 25

len = $ - numbers ; длина строки

elemSize = 2 ; размер одного элемента

count = len / elemSize ; количество элементов

num word 2 ; число для инициализации массива

.code

main proc

lea rdi, numbers

mov rcx, count ; количество обрабатываемых слов

xor rax, rax

mov ax, num

rep stosw

mov ax, word ptr numbers[2 * elemSize] ; проверяем третий элемент массива numberss

ret

main endp

end

lods
Инструкция lods копирует байт, слово, двойное слово или четверное слово, указанное RSI, в регистр AL, AX, EAX или RAX, после чего увеличивает или уменьшает значение регистра RSI на 1, 2, 4 или 8. Данная инструкция имеет следующие формы:

lodsb: сохраняет в регистр AL байт по адресу из регистра RSI

lodsw: сохраняет в регистр AX слово по адресу из регистра RSI

lodsd: сохраняет в регистр EAX двойное слово по адресу из регистра RSI

lodsq: сохраняет в регистр RAX четверное слово по адресу из регистра RSI

Например, загрузим в регистр AX третьее число из массива слов:

Код (ASM):

.data

numbers word 20, 21, 22, 23, 24, 25

elemSize = 2

.code

main proc

lea rsi, numbers[2*elemSize] ; адрес третьего числа

xor rax, rax

lodsw ; AX = 22

ret

main endp

end

Mikl___ · 1 ноя 2026 в 02:58

Макросы
Определение макросов
В ассемблере макрос представляет идентификатор, который ассемблер преобразует в дополнительный код. Макросы позволяют заменить длинные повторяющиеся последовательности код гораздо более короткими последовательностями. В каком-то смысле макросы MASM можно назвать процедурами/функциями времени компиляции.
Определение макроса в общем случае имеет следующую форму:
имя_макроса macro аргументы_макроса
код макроса
endm
Сначала идет объявление макроса - имя макроса, затем оператор macro и после указываются аргументы макроса. Аргументы необязательны, макрос может вообще не иметь аргументов. Завершается макрос оператором endm. Между объявлением макроса и endm располагается собственно код макроса.
Рассмотрим пример макроса, который складывает 128-разрядное число с 64-разрядным:

Код (ASM):

.data

num qword 0ffffffffffffffffh, ; младшие 64 бит

4 ; старшие 64 бит

.code

add128 macro

add rax, rbx

adc rdx, 0

endm

main proc

mov rax, num ; младшие 64 бит - в RAX

mov rdx, num[8] ; старшие 64 бит - в RDX

mov rbx, 3

add128 ; вставляем макрос

ret

main endp

end

В данном случае макрос называется add128:

Код (ASM):

add128 macro

add rax, rbx

adc rdx, 0

endm

Здесь подразумеваем, что 128-разрядное число располагается в регистрах RDX:RAX: младшие 64 битов в RAX, а старшие 64 битов - в RDX. Прибавляемое 64-битное число передается через регистр RBX. Работа макроса проста - складываем 64-битное число RBX с младшими 64 битами RAX и, если при этом устанавливается флаг переноса, прибавляем бит к старшим 64-битам в RDX.
Здесь 128-битное число представляет массив num из двух подчисел qword, которое загружается в RAX и RDX. Для вставки макроса в код применяется имя макроса. То есть макрос не вызывается в процессе выполнения, его код вставляется в место вызова макроса на этапе компиляции. То есть фактически мы получим программу:

Код (ASM):

.data

num qword 0ffffffffffffffffh, ; младшие 64 бит

4 ; старшие 64 бит

.code

main proc

mov rax, num ; младшие 64 бит - в RAX

mov rdx, num[8] ; старшие 64 бит - в RDX

mov rbx, 3

add rax, rbx

adc rdx, 0

ret

main endp

end

Макросы или функции?
В приведенном выше примере мы могли бы определить макрос сложения чисел в виде отдельной процедуры. И тут может возникнуть вопрос: что выбрать - макросы или функции? Минусом макросов является то, что их код вставляется в каждое место, где они используются. Что ведет к общему увеличению объема программы. С другой стороны, макросы позволяют избежать переходов и сохранений/восстановлений адреса следующей инструкции, что положительно влияет на производительность. Макросы немного быстрее, чем вызовы процедур, потому что вы не выполняете вызов и соответствующие инструкции ret. Кроме того, с макросами сам код становится чуть более читабельным. В общем случае рекомендуется применять макросы для коротких, критичных по времени частей программы. Тогда как процедуры применяются для более длинных блоков кода и когда время выполнения не так критично.

Mikl___ · 1 ноя 2026 в 03:18

Макросы
Параметры макроса
С помощью параметров макросы могут получать извне некоторые данные. Параметры указываются в объявлении макроса через запятую после слова macro:
имя_макроса macro параметр1, параметр2, ... параметрN
код макроса
endm
При вызове макроса после его имени указываются через запятую значения для параметров:
имя_макроса значение_параметра1, значение_параметра2, ... значение_параметраN
Например, определим макроса, который складывает 128-разрядное число с 64-разрядным и оба числа получает через параметры:

Код (ASM):

.data

num qword 0ffffffffffffffffh, ; младшие 64 бит

4 ; старшие 64 бит

.code

add128 macro l64, h64, number64

add l64, number64

adc h64, 0

endm

main proc

mov rax, num ; младшие 64 бит - в RAX

mov rdx, num[8] ; старшие 64 бит - в RDX

mov rbx, 3

add128 rax, rdx, rbx ; вставляем макрос

ret

main endp

end

В данном случае макрос называется add128 и принимает три параметра: l64 (младшие 64 бита 129-разрядного числа), h64 (старшие 64 бита 129-разрядного числа), number64 (прибавляемое число)

Код (ASM):

add128 macro l64, h64, number64

add l64, number64

adc h64, 0

endm

Внутри макроса проводим все арифметические операции с числами. При этом на момент написания макроса мы можем не знать, как конкретно будут передаваться эти числа - через какие регистры и т.д.
При вызове макроса в процедуре main передаем его параметрам значения по позиции:

Код (ASM):

add128 rax, rdx, rbx

То есть параметру l64 передается значение регистра RAX, параметру h64 - значение регистра RDX, а параметру number64 - регистр RBX.
В качестве значений для параметров мы можем передавать в макросы регистры (как в случае выше), переменные, константы, главное, чтобы они удовлетворяли требованиям инструкций, с которыми они используются.
Проверка параметров
Вполне может быть ситуация, когда по какой-то причине макросу будет передано меньшее количество значений, чем у него есть параметров. К примеру, если мы используем макрос, который написан не нами и к исходному коду которого у нас нет доступа. Например:

Код (ASM):

add128 rax, rdx

В этом случае при компиляции ассемблер может нам отобразить какую-то общую ошибку, что что-то не так с вызовом макроса. Мы можем проверить подобную ситуацию и настроить сообщение об ошибке, которое даст понимание, что именно не так. Для проверки параметров MASM предоставляет ряд специальных конструкций, которые аналогичны условной конструкции if:

ifnb arg: условие истинно, если значение для параметра не указано

ifdif arg1, arg2: условие истинно, если оба параметра различаются (учитывается регистр символов)

ifdifi arg1, arg2: условие истинно, если оба параметра различаются (регистр символов не учитывается)

ifidn arg1, arg2: условие истинно, если оба параметра идентичны (учитывается регистр символов)

ifidni arg2, arg2: условие истинно, если оба параметра идентичны (регистр символов не учитывается)

ifb arg: условие истинно, если значение для параметра не указано. Фактически является сокращением выражения ifidn <arg>, <>

В данном случае arg, arg1, arg2 - значения, которые передаются операторам if
Проверим наличие значения для параметра:

Код (ASM):

.data

num qword 0ffffffffffffffffh, ; младшие 64 бит

4 ; старшие 64 бит

.code

add128 macro l64, h64, number64

; проверяем наличие параметра number64

ifb <;number64>

.err <;add128 requires 3 operands>

endif

add l64, number64

adc h64, 0

endm

main proc

mov rax, num ; младшие 64 бит - в RAX

mov rdx, num[8] ; старшие 64 бит - в RDX

mov rbx, 3

add128 rax, rdx ; передаем только два значения

ret

main endp

end

В коде макроса с помощью выражения
ifb <;number64>
проверяем отсутствие значения для параметра number64. И если это значение отсутствует, выполняем выражение .err
.err <;add128 requires 3 operands>
Оператору .err в угловых скобках передается сообщение об ошибке, которое будет отображаться при компиляции при отстуствии значения для number64.
В качестве альтернативы проверки значения параметра мы можем использовать суффикс :req, который указывает, что параметр обязательный (required):

Код (ASM):

add128 macro l64:req, h64:req, number64:req

add l64, number64

adc h64, 0

endm

В этом случае, если параметру не будет передано значение, в процессе компиляции мы получим ошибку типа следующей:
hello.asm(14) : error A2125:missing macro argument
Другое решение проблемы отсутствующих параметров - установка для параметров значений по умолчанию:

Код (ASM):

.data

num qword 0ffffffffffffffffh, ; младшие 64 бит

4 ; старшие 64 бит

.code

add128 macro l64:=<;rax>, h64:=<rdx>, number64:=<0>

add l64, number64

adc h64, 0

endm

main proc

mov rax, num ; младшие 64 бит - в RAX

mov rdx, num[8] ; старшие 64 бит - в RDX

mov rbx, 3

add128 ; без аргументов

ret

main endp

end

Для установки значения по умолчанию с помощью оператора := параметру присваивается в угловых скобках значение по умолчанию. Например:
l64:=<;rax>
В данном случае, если параметру l64 не передано значения, то он берет значение из регистра RAX. Аналогичным образом можно установить конкретные значения. Например, для параметра number64 значение по умолчанию - число 0:
number64:=<;0>
Оператор opattr
Чтобы проверить, что именно представляет аргумент макроса, применяется оператор opattr:
opattr выражение
В качестве операнда он принимает некоторое выражение - это может быть и аргумент макроса, и какое-то более сложное по структуре выражение.
opattr возвращает целочисленное значение, которые представляет битовую маску и которое позволяет определить тип выражения:

Бит Значение
0 Выражение представляет метку
1 Выражение представляет перемещаемое значение
2 Выражение представляет константу
3 Выражение представляет прямую адресацию
4 Выражение представляет регистр
5 устравшее (выражение содержит неопределенный идентификатор)
6 Выражение представляет обращение к памяти стека
7 Выражение ссылается на внешний идентификатор
Применим оператор opattr:

Код (ASM):

.data

num qword 0ffffffffffffffffh, ; младшие 64 бит

4 ; старшие 64 бит

.code

add128 macro l64, h64, number64

; проверяем, что l64 и h64 - регистры

if (((opattr l64) and 10h) AND ((opattr h64) and 10h))

add l64, number64

adc h64, 0

else

.err <;the first two operands of add128 should be registers>

endif

endm

main proc

mov rax, num ; младшие 64 бит - в RAX

mov rdx, num[8] ; старшие 64 бит - в RDX

mov rbx, 3

add128 rax, 4, 3 ; второй параметр должен быть регистром, а не константой

ret

main endp

end

Здесь мы проверяем, что первые два параметра макроса - l64 и h64 являются регистрами. Если параметр - регистр, то выражение opattr l64 (как и opattr h64) возвратит байт, у которого установлен 4 бит. Чтобы проверить его установку, мы можем применить логическое умножение на 10h и ли число 16 в лесятичной системе
(opattr l64) and 10h
И если 4-й бит установлен, то выражение возвратит 1. Подобным образом проверяем и второй параметр макроса.
Если первые два параметра представляют регистры, то выполняем сложение, если нет - то генерируем ошибку с определенным сообщением.
Для проверки параметра можно использовать следующие маски:

0: неопределенный символ или некорректное выражение

34 / 22h: доступ к памяти в виде [reg + const]

36 / 24h: константа

37 / 25h: имя процедуры или метка с символом :

38 / 26h: выражение в виде offset var, где var - переменная из секции .data

42 / 2Ah: глобальный идентификатор (например, из секции .data)

43 / 2Bh: выражение доступа к памяти в виде [reg + label], где label представляет имя процедуры или метка

48 / 30h: регистр общего назначения, XMM, YMM, ZMM, ST, либо другой регистр специального назначения

98 / 62h: обращение к стеку в виде [rsp + xxx] и [rbp + xxx]

Подобным образом мы можем проверить и конктерный регистр:

Код (ASM):

add128 macro l64, h64, number64

; проверяем, представляет ли l64 регистр RAX

ifidn <;l64>, <rax>

; действия, если регистр - RAX

else

; действия, если регистр - не RAX

endif

endm

Mikl___ · 1 ноя 2026 в 03:21

Макросы
Метки в макросах
Если макросы используют метки, то при вызове макроса мы можем столкнуться с проблемами:

Код (ASM):

.code

equal macro op1, op2

cmp op1, op2

jz isEqual

mov rax, 0

jmp exit

isEqual:

mov rax, 1

exit:

endm

main proc

mov rcx, 2

mov rdx, 3

equal rcx, 2

equal rdx, 2

ret

main endp

end

Здесь макрос equal принимает два параметра и проверяет их на равенство. Если они равны осуществляется переход к метке isEqual, на которой в регистр RAX помещается число 1. Если числа не равны, в RAX помещается число 0, и происходит переход к метке exit.
Поскольку код макросов вставляется в место их вызова при компиляции, то мы получим ситуацию, что метки isEqual и exit будут определены два раза, что недопустимо, так как метка должна быть определена только один раз. Чтобы решить эту проблему, мы можем использовать локальные метки, которые задаются внутри макроса с помощью оператора local
local метка1, метка2, ... меткаN
Оператору local передаются через запятую идентификаторы, которые используются внутри макроса. Так, изменим предыдущий пример, используя локальные метки:

Код (ASM):

.code

equal macro op1, op2

local isEqual, exit ; объявляем локальные метки

cmp op1, op2

jz isEqual

mov rax, 0

jmp exit

isEqual:

mov rax, 1

exit:

endm

main proc

mov rcx, 2

mov rdx, 3

equal rcx, 2

equal rdx, 2

ret

main endp

end

Mikl___ · 1 ноя 2026 в 03:29

Макросы
Условная компиляция и циклы
Ассемблер MASM поддерживает условную компиляцию, которая позволяет при определенных условиях компилировать определенный код. Для этого применяется конструкция if:

Код (ASM):

if условие

текст

endif

После слова if указывается условие. В качестве условия может принимае Это должно быть константное выражение (константа или операция над константами) или вызов функции на этапе компиляции, результатом которого является целочисленное значение. Во время компиляции ассемблер оценивает это выражение. Если выражение оценивается как истинное (не равно нулю), MASM обрабатывает код, который идет до endif. Если выражение оценивается как ложное (равно нулю), MASM обрабатывает весь текст между if и соответствующим предложением endif, как если бы это был комментарий. Причем поскольку условие оценивается в момент сборки, то оно не должно вовлекать переменные, значение которых известно только во время выполнение, а не во время компиляции.
Конструкция if поддерживает необязательные выражения elseif и else, которые позволяют добавить альтернативные действия, если условие после if неверно:

Код (ASM):

if условие1

текст

elseif условие2

текст

else

текст

endif

Если условие после if оценивается как истинное, то MASM обрабатывает текст до выражения elseif. Затем он пропускает весь текст (то есть обрабатывает его как комментарий) до тех пор, пока не встретит предложение endif.
Если условие после if оценивается неверно, MASM пропускает весь текст, пока не встретит выражение elseif, else или endif.
Если встречается выражение elseif, MASM оценивает условие после elseif. Если оно верно, MASM обрабатывает текст между предложениями elseif и else (или до выражения endif, если выражение else отсутствует). Конструкция if может содержать множество выражений elseif. Если условие после elseif неверно, MASM пропускает связанный с ними текст и начинает обрабатывать текст в выражении else при его наличии.
Обычно условная компиляция применяется при необходимости разграничить компиляцию в зависимости от внешних условий. Например, в зависимости от процессора могут отличать возможности, которые нам предоставляются для создания программы. Так, если процессор не поддерживает 64-разрядные регистры, то соответственно мы не сможем их использовать. И тут мы могли бы применить условную компиляцию:

Код (ASM):

cpu64 = 1

.code

main proc

if cpu64

mov rax, 64

else

mov eax, 32

endif

ret

main endp

end

Здесь условие представлено константой cpu64. Будет считать, что если процессор - 64-разрядный, то для ее устанавливаем значение 1. Для простоты, если это условие равно 1, то используем 64-разрядный регистр RAX. Если условие равно 0 (то есть процессор 32-разрядный), то используем 32-разрядный регистр EAX.
Другое частое применение условной компиляции представляет тестирование или отладка, когда при тестировании и отладке выводится информация о состоянии регистров или переменных на консоль.
Циклические конструкции
Операторы MASM while..endm, for..endm и forc..endm предоставляют циклические конструкции, которые выполняются во время компиляции.
Оператор while указывает MASM многократно обрабатывать одну и ту же последовательность операторов во время сборки. Это удобно для построения таблиц данных, а также для обеспечения традиционной циклической структуры для программ времени компиляции. Этот оператор имеет следующий синтаксис:
while условие
код
endm
Если условие после while является неверным, MASM пропускает текст между выражениями while и endm (аналогично оператору if). Если выражение является истинным, MASM обработает операторы между выражениями while и endm, а затем повторяет этот процесс, пока истинно условие. Рассмотрим простейший пример:

Код (ASM):

.data

nums dword 1, 2, 3, 4

.code

i = 0

main proc

xor rax, rax

while i LT lengthof nums

add eax, nums[i * 4] ; константа i в качестве индекса

i = i + 1

endm

ret

main endp

end

Здесь оператор while проверяет условие i LT lengthof nums. Для определения условия применяется оператор LT (меньше чем), то есть, чтобы условие было истинным, левый операнд - значение константы i должно быть меньше правого операнда - lengthof nums. Константа i представляет своего рода индекс для обращения к элементам к числам в массиве nums. Правый операнд - lengthof nums с помощью оператора lengthof вычисляет количество элементов в массиве nums. Поскольку в массиве nums 4 элемента, то действия внутри конструкции while будут повторяться, покак значение константы i не окажется равным 4. Каждое повторение цикла называется итерацией, то есть в данном случае выполняться 4 итерации.
Для примера внутри конструкции while складываем каждое число из массива nums с содержимым регистра EAX и увеличиваем значение i на единицу. В итоге данная конструкция сработает 4 раза.
Стоит обратить внимание, что данный код срабатывает именно на этапе сборки, а не выполнения. И в итоге после сборки будет сгенерирован код:

Код (ASM):

.data

nums dword 1, 2, 3, 4

.code

i = 0

main proc

xor rax, rax

add eax, nums[0] ; константа i в качестве индекса

add eax, nums[1] ; константа i в качестве индекса

add eax, nums[2] ; константа i в качестве индекса

add eax, nums[3] ; константа i в качестве индекса

ret

main endp

end

Цикл for
Конструкция for имеют следующий синтаксис:

Код (ASM):

for идентификатор, <;arg1, arg2, ..., argN>

код

endm

Циклическая конструкция for повторяет код один раз для каждого из аргументов - от arg1 до argN, которые указываются внутри угловых скобок <...>. При каждом повторении цикла текущий аргумент присваивается идентификатору: на первой итерации цикла идентификатору присваивается значение arg1, на второй итерации — arg2 и так далее до последней итерации, когда установлено значение argN. Например, следующий цикл for сгенерирует код, который помещает в стек регистры RAX, RBX, RCX и RDX:

Код (ASM):

for reg, <;rax, rbx, rcx, rdx>

push reg

endm

Этот код фактически эквивалентен следующему коду:

Код (ASM):

push rax

push rbx

push rcx

push rdx[/COD]

Mikl___ · 1 ноя 2026 в 03:34

Макросы
Генерация таблиц для поиска
Одной и распространенных ситуаций применения макроконструкций представляет генерация таблиц для поиска. Например, нам нужен набор чисел типа byte от 1 до 100. В общем случае мы могли бы написать так:

Код (ASM):

.data

nums byte 1, 2, 3, 4, 5, 6, ....., 99, 100

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

Код (ASM):

.data

index = 1

last = 101

nums equ this byte

while index lt last

byte index

index = index + 1

endm

.code

main proc

xor rax, rax

mov al, nums ; al = 1

ret

main endp

end

Здесь чуть больше кода. Для хранения добавляемого в массив значения определена переменная index, а для хранения максимального значения - константа last. Для задания массива nums применяется следующая запись:
nums equ this byte
Цикл while на каждой итерации определяет в массиве nums один байт, который равен index, пока index не станет равным last. То есть в итоге мы опять же получим массив nums со 100 числами.

Код (ASM):

while index lt last

byte index

index = index + 1

endm

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

Код (ASM):

; макрос генерирует последовательность чисел от start до last

createRange macro start, last

index = start

while index lt last

byte index

index = index + 1

endm

endm

.data

character byte "y" ; символ для преобразования в верхний регистр

; Таблица для преобразования символов из нижнего регистра в верхний

table equ this byte

createRange 0, "a" ; на позиции 0-96 добавляем символьные коды от 0 до "a" не включая

createRange "A", "Z"+1 ; на позиции 97-122 добавляем символьные коды от "A" до "Z" включая

createRange "z"+1, 128 ; на позиции 123-127 добавляем оставшиеся символьные коды таблицы ASCII

.code

main proc

xor rax, rax

mov al, character ; AL = 121 - код символа y

lea rbx, table

xlat

mov character, al ; AL = 89 (код символа Y)

ret

main endp

end

Макрос createRange принимает два параметра - числовой код начального символа диапазона и числовой код конечного символа. Для генерации диапазона применяется цикл while. В секции .data с помощью этого макроса генерируем три поддиапазона:

Код (ASM):

createRange 0, "a" ; на позиции 0-96 добавляем символьные коды от 0 до "a" не включая

createRange "A", "Z"+1 ; на позиции 97-122 добавляем символьные коды от "A" до "Z" включая

createRange "z"+1, 128 ; на позиции 123-127 добавляем оставшиеся символьные коды таблицы ASCII

В общем случае по каждому индексу в таблице table будет располагать равный индексу числовой код символа (например, по индексу 10 - числовой код 10) за исключением диапазаона индексов 97-122, поскольку они представляют числовые коды символов в нижнем регистре. И на эти позиции мы повторно помещаем числовые коды символов в верхнем регистре - от "A" до "Z". Таким образом, мы получаем таблицу с числовыми кодами символов.
Для замены числового кода символа применяется инструкция xlat, которая фактически аналогична инструкции

Код (ASM):

mov al, [rbx + al * 1]

Эта инструкция использует текущее значение регистра AL в качестве индекса в массиве, базовый адрес которого находится в RBX. Она выбирает байт по этому индексу в массиве и копирует этот байт в регистр AL.

Mikl___ · 1 ноя 2026 в 05:27

Взаимодействие с кодом на C/C++
Первая программа на MASM/C
Ассемблер MASM позволяет использовать гибридный подход, при котором часть программы пишется на ассемблере, а часть - на С/С++. Это позволяет сократить и упростить программу. Например, определим файл app.c с кодом на языке C:
А в файле app.c определим следующий код:

Код (C++):

#include <stdio.h>

// подключаем внешнюю функцию hello из файла hello.asm

extern void hello(void);

int main()

{

printf("Hello starts\n");

hello();

printf("Hello ends\n");

}

Это обычная программа на языке С, в которой с помощью оператора extern подключаем некоторую внешнюю функцию hello, которая ничего не возвращает и не принимает никаких параметров. В функции main вызываем эту внешнюю функцию hello.
Теперь в той же папке определим файл hello.asm, который будет содержать следующий код на ассемблере:

Код (ASM):

.code

option casemap:none

; определяем процедуру hello

public hello

hello proc

ret ; возвращаемся в вызывающий код

hello endp

end

Секция .code здесь начинается с директивы option

Код (ASM):

option casemap:none

Директива option указывает MASM сделать все символы чувствительными к регистру. Это необходимо, потому что MASM по умолчанию нечувствителен к регистру и отображает все идентификаторы в верхнем регистре (поэтому hello() станет HELLO()). Но язык C чувствителен к регистру и рассматривает hello() и HELLO() как два разных идентификатора.
Далее идет определение функции hello. С помощью оператора public указываем, что функция hello будет видна вне исходного/объектного файла MASM:

Код (ASM):

public hello

Без этого оператора функция hello() была бы доступна только внутри текущего файла, и при компиляции компилятор не смог бы ее найти.
Затем между операторами hello proc и hello endp определяется функция hello, которая ничего не делает.
Скомпилируем оба файла - app.c и hello.asm в одну программу. Рассмотрим напримере ассемблера MASM64 и компилятора для Visual C++ в Visual Studio. Для компиляции откроем программу x64 Native Tools Command Prompt for VS 2022, которая устанавливается вместе с Visual Studio, и перейдем в ней к папке, где располагаются файлы. Затем выполним следующую команду

ml64 /c hello.asm

Опция /c говорит, что файл hello.asm надо только скомпилировать в объектный файл. И после этой команды в папке программы будет скомпилирован файл hello.obj:

**********************************************************************
** Visual Studio 2022 Developer Command Prompt v17.5.5
** Copyright (c) 2022 Microsoft Corporation
**********************************************************************
[vcvarsall.bat] Environment initialized for: 'x64'

C:\Program Files\Microsoft Visual Studio\2022\Community>cd c:\asm

c:\asm>ml64 /c hello.asm
Microsoft (R) Macro Assembler (x64) Version 14.35.32217.1
Copyright (C) Microsoft Corporation. All rights reserved.

Assembling: hello.asm

c:\asm>

Далее используем скомпилируем всю программу с помощью команды:

cl app.c hello.obj

В итоге будет скомпилирован файл app.exe, который мы можем запустить и который при запуске выполнит ассемблерную функцию hello:

c:\asm>cl app.c hello.obj
Microsoft (R) C/C++ Optimizing Compiler Version 19.35.32217.1 for x64
Copyright (C) Microsoft Corporation. All rights reserved.

app.c
Microsoft (R) Incremental Linker Version 14.35.32217.1
Copyright (C) Microsoft Corporation. All rights reserved.

/out:app.exe
app.obj
hello.obj

c:\asm>app
Hello starts
Hello ends

c:\asm>

Вывод строки на консоль
Программа на C может вызывать код из файла на ассемблере, так и код на ассемблере может вызывать функции языка С. Например, используем стандартную функцию printf() для вывода строки на консоль в программе на ассемблере. Для этого определим в файле hello.asm следующий код:

Код (ASM):

option casemap:none

.data

text byte "Hello, world!", 10, 0 ; определяем выводимые данные

.code

; подключаем определение функции printf() из C/C++

externdef printf:proc

; определяем процедуру hello

public hello

hello proc

sub rsp, 40 ; резервируем в стеке 40 байт

lea rcx, text ; в регистр rcx загружаем адрес строки text

call printf ; вызываем функцию printf

add rsp, 40 ; восстанавливаем значение в стеке

ret ; возвращаемся в вызывающий код

hello endp

end

Здесь для хранения данных определяем секцию .data

Код (ASM):

.data

text byte "Hello, world!", 10, 0 ; определяем выводимые данные

Здесь определена строка text, которая представляет набор байт. Причем предпоследний байт - представляет число 10 - это числовой код перевода строки. Последний байт - 0, так как строки в Си должны завершаться нулевым байтом.
Для использования функции printf подключаем ее с помощью директивы.

Код (ASM):

externdef printf:proc

Директива externdef имеет следующую форму

Код (ASM):

externdef symbol:type

Где symbol — это внешный идентификатор, который мы хотим определить - в данном случае функция printf. А type — тип этого идентификатора (для функций это тип proc).
Стоит отметить, что директива externdef должна применяться в секции .code
Функция printf() принимает как минимум один параметр - выводимую строку. Эта строка передается в функцию через регистр RCX. Для загрузки адреса строки в регистр rcx применяем инструкцию lea и затем вызываем функцию printf.

Код (ASM):

lea rcx, text

call printf

Снова сначала скомпилируем код ассемблера из файла hello.asm с помощью команды:

ml64 /c hello.asm

И скомпилируем файл app.c в файл приложения с помощью команды:

cl app.c hello.obj

После компиляции запустим файл app.exe:

c:\asm>ml64 /c hello.asm
Microsoft (R) Macro Assembler (x64) Version 14.35.32217.1
Copyright (C) Microsoft Corporation. All rights reserved.

Assembling: hello.asm

c:\asm>cl app.c hello.obj
Microsoft (R) C/C++ Optimizing Compiler Version 19.35.32217.1 for x64
Copyright (C) Microsoft Corporation. All rights reserved.

app.c
Microsoft (R) Incremental Linker Version 14.35.32217.1
Copyright (C) Microsoft Corporation. All rights reserved.

/out:app.exe
app.obj
hello.obj

c:\asm>app
Hello starts
Hello, world!
Hello ends

c:\asm>

Mikl___ · 1 ноя 2026 в 05:42

Взаимодействие с кодом на C/C++
Передача параметров из ассемблера в функцию C/C++
При обращении к функциями C/C++ в коде ассемблера необходимо следовать некоторым соглашениям, в соответствии с которыми работает данные функции. Используя MASM, нам следует следовать соглашениям Microsoft Windows ABI (Application Binary Interface). Рассмотрим основные принципы этих соглашений
Между базовыми типами в C/C++ и ассемблера применяются следующие соответствия:

С/С++ Размер
(в байтах) Ассемблер
char/signed char 1 sbyte
unsigned char 1 byte
short int 2 sword
short unsigned 2 word
int 4 sdword
unsigned (unsigned int) 4 dword
long / long int 4 sdword
unsigned long 4 dword
long long 8 sqword
unsigned long long 8 qword
float 4 real4
double 4 real8
указатель 8 qword
Также в плане использования регистров существуют следующие соглашения:

Вызывающий код передает первые четыре параметра в регистры. Для передачи в функцию первых четырех параметров (целочисленных) используются регистры RCX, RDX, R8 и R9 соответственно. Если параметры представляют числа с плавающей точкой, то они передаются через регистры XMM0, XMM1, XMM2 и XMM3.
Параметры начиная с 5-го передаются через стек. Так, 5-й параметр должен занимать в стеке место по адресу RSP+32, 6-й параметр - по адресу RSP+40 и так далее.
Если процедура имеет смешанные параметры - одновременно и целочисленные, и с плавающей запятой, то каждый параметр помещается в соответствующий его номеру регистр RCX/RDX/R8/R9 или XMM0/XMM1/XMM2/XMM3. Например, если у нас есть следующая функция C/C++

1 void someFunc(int a, double b, char *c, double d)
то параметры будут размещаться следуюшим образом

RCX a
XMM1 b
R8 c
XMM3 d

Параметры всегда представляют собой 8-байтовые значения.

Вызывающий код должен зарезервировать для параметров в стеке как минимум 32 байта, даже если параметров меньше четырех - это так называемое shadow storage или теневое хранилище. Условно можно сказать, что первый параметр занимает в стеке память по адресу RSP, второй - по адресу RSP+8, третий - RSP+16, четвертный - RSP+24. Но в реальности это хранидище можно использовать для своих целей, например, как место хранения локальных переменных

Указатель стека RSP должен быть выровнен по 16 байтам непосредственно перед тем, как инструкция call поместит адрес возврата в стек.

Регистры в Microsot Windows ABI делятся на две группы:

Volatile-регистры (изменяемые регистры) - они могут изменять свои значения, и функции/процедуре не нужно сохранять значения этих регистров при вызове другой функции/процедуры. Это такие регистры как RAX, RCX, RDX, R8, R9, R10 и R11, а также XMM0/YMM0 – XMM5/YMM5

Nonvolatile-регистры (неизменяемые регистры) - они должны сохранять информацию при вызове функций/процедур. Поэтому процедура/функция должна сохранять значения этих регистров во время вызова. Если процедура изменяет один из этих регистров, она должна сохранить значение регистра перед первой такой модификацией и восстановить значение регистра из сохраненного местоположения перед возвратом. Это такие регистры как RBX, RBP, RDI, RSI, RSP, R12, R13, R14 и R15, а также XMM6/YMM6 - XMM15/YMM16 (старшую половину регистра YMM6-YMM16 можно изменить)

Если функция возвращает целое число, то оно помещается в регистр RAX, если число с плавающей точкой - то в регистр XMM0.

Передача параметров из ассемблера в функцию C/C++
Например, возьмем функцию printf(). Через регистр RCX в функцию передается выводимая строка, а через остальные регистры передаются значения, которые передаются на место спецификаторов в строке, например, %s, %d и т.д. Рассмотрим передачу параметров в эту функцию. Пусть у нас определен файл hello.asm со следующим кодом:

Код (ASM):

option casemap:none

.data

user byte "Tom", 0 ; для спецификатора %s

age dword 38 ; для спецификатора %d

text byte "Name: %s Age: %d", 10, 0

.code

; подключаем определение функции printf() из C/C++

externdef printf:proc

; определяем процедуру hello

public hello

hello proc

sub rsp, 40 ; резервируем в стеке 40 байт

lea rcx, text ; в регистр rcx загружаем адрес строки text

lea rdx, user ; в регистр rdx загружаем адрес строки name

mov r8d, age ; в регистр r8 загружаем адрес переменной age

call printf ; вызываем функцию printf

add rsp, 40 ; восстанавливаем значение в стеке

ret ; возвращаемся в вызывающий код

hello endp

end

В секции данных определены три переменных. Прежде всего это строка text, которая содержит спецификаторы %s и %d. Поскольку все строки в С должны завершаться нулевым байтом, то последний байт этой строки - 0. Также для спецификатора %s определена строка user, а для спецификатора %d - переменная age.
В соответствие с требованиями Windows ABI, перед вызовом функции printf() резервируем в стеке 40 байт:

Код (ASM):

sub rsp, 40 ; резервируем в стеке 40 байт

Из них 32 байта - это так называемое shadow storage или теневое хранилище, необходимое для вызова любой функции С/С++, даже если она не имеет пароаметров. Но при вызове функции hello в стек уже помещается адрес возврата и таким образом 8 байт в нем занято. Соответственно получим 32 байта (shadows storage) + 8 байт (адрес возврата) = 40 байт - это значение НЕ выровнено по 16 байтам (то есть не кратно 16 байтам). Нам же в соответствии с Windows ABI обязательно надо иметь стек выровненным по 16 байтам - чтобы 4 младших бита в RSP имели значение 0. Поэтому к 32 байтам для выравнивания добавляем 8 байт.
Для передачи этих значений в качестве параметров в функцию printf сначала загружаем адрес строки text в регистр rcx:

Код (ASM):

lea rcx, text

В rdx загружаем адрес строки user для первого спецификатора - %s.

Код (ASM):

lea rdx, user

Значение для второго спецификатора - %d помещаем в регистр r8:

Код (ASM):

mov r8d, age

Стоит отметить, что поскольку age - 32-битное число, и для спецификатора %d требуется целое 32-битное число, то данные помещаем в младшие 32 бита регистра r8 - r8d. Кроме того, для этого используем инструкцию mov.
Для вызова ассемблерного кода определим файл app.c со следующим кодом на языке C:

Код (C):

#include <stdio.h>

extern void hello(void);

int main()

{

hello();

}

Сначала скомпилируем код ассемблера из файла hello.asm с помощью команды:

ml64 /c hello.asm

И скомпилируем файл app.c в файл приложения с помощью команды:

cl app.c hello.obj

После компиляции запустим файл app.exe:

c:\asm>ml64 /c hello.asm
Microsoft (R) Macro Assembler (x64) Version 14.36.32532.0
Copyright (C) Microsoft Corporation. All rights reserved.

Assembling: hello.asm

c:\asm>cl app.c hello.obj
Microsoft (R) C/C++ Optimizing Compiler Version 19.36.32532 for x64
Copyright (C) Microsoft Corporation. All rights reserved.

app.c
Microsoft (R) Incremental Linker Version 14.36.32532.0
Copyright (C) Microsoft Corporation. All rights reserved.

/out:app.exe
app.obj
hello.obj

c:\asm>app
Name: Tom Age: 38

c:\asm>

Передача параметров по ссылке
Если функция C/C++ принимает указатель, то, поскольку указатели в архитектуре x86-64 имеют размер 8 байт, соответствующий параметр тоже должен быть равен 8 байтам. В качестве указателя из кода на ассемблере можно передать адрес объекта, который вычисляется либо с помощью оператора offset, либо с помощью инструции lea. Например, определим в файле app.c следующую программу на С:

Код (C):

// подключаем внешнюю функцию calc из файла hello.asm

extern void calc(void);

void square(unsigned int* n)

{

*n = *n * *n;

}

int main(void)

{

calc();

}

Здесь определена функция square, которая принимает указатель на число типа unsigned int и возводит его в квадрат.
Основные действия разворачиваются в функции calc, которая подключается как внешняя функция на ассемблере. Определим ее в файле hello.asm:

Код (ASM):

option casemap:none

.data

number dword 5

text byte "number = %u", 10, 0

.code

externdef square:proc

externdef printf:proc

calc proc

sub rsp, 40

lea rcx, number

call square

lea rcx, text ; в регистр rcx загружаем адрес строки text

mov edx, number ; в регистр rdx загружаем адрес числа number

call printf ; вызываем функцию printf

add rsp, 40

ret

calc endp

end

Здесь данные, которые будут передаваться в функцию square, определены в виде переменной number. Перед вызовом функции square в регистр RCX помещаем адрес переменной number.

Код (ASM):

lea rcx,number

В качестве альтернативы можно было бы использовать оператор offset:

Код (ASM):

mov rcx, offset number

Но инструкция lea является более предпочтительной, потому что занимает меньше байт (7 против 10 у offset).
После выполнения функции square проверяем значение переменной number с помощью функции printf. Результат работы программы:

c:\asm>app
number = 25

Mikl___ · 1 ноя 2026 в 05:51

Взаимодействие с кодом на C/C++
Возвращение результата из процедуры ассемблера в код на C/C++
Мы можем вызывать как в коде ассемблера функции C/C++, так и в коде С/С++ процедуры ассемблера. А также передавать параметры и получать результаты.
Возвращение результата из ассемблера
Согласно Windows ABI, функции (процедуры) возвращают целые числа и значения указателей (которые умещаются в 64 бита) в регистре RAX. Поэтому, если какой-то код С/C++ ожидает, что процедура ассемблера вернет целочисленный результат, то код на ассемблере должен поместить целочисленный результат в регистр RAX перед возвратом из процедуры.
Например, определим следующий файл hello.asm

Код (ASM):

option casemap:none

.data

text byte "Hello Asm", 0

.code

; определяем процедуру hello

public hello

hello proc

lea rax, text ; в регистр rax загружаем адрес строки text

ret

hello endp

end

Здесь функция hello формально возвращает строку text. Фактически же это выражается в загрузке в регистр rax адрес строки text.
Также определим файл app.c, где получим строку и выведем ее на консоль:

Код (C):

#include <stdio.h>

extern char* hello(void);

int main()

{

char* message = hello();

printf(message);

}

Поскольку в регистр rax загружается адрес строки, то для C/C++ возвращаемым типом функции будет тип char*. Соответственно мы можем получить эту строку:

Код (C):

char* message = hello();

Скомпилируем и запустим программу

c:\asm>ml64 /c hello.asm
Microsoft (R) Macro Assembler (x64) Version 14.36.32532.0
Copyright (C) Microsoft Corporation. All rights reserved.

Assembling: hello.asm

c:\asm>cl app.c hello.obj
Microsoft (R) C/C++ Optimizing Compiler Version 19.36.32532 for x64
Copyright (C) Microsoft Corporation. All rights reserved.

app.c
Microsoft (R) Incremental Linker Version 14.36.32532.0
Copyright (C) Microsoft Corporation. All rights reserved.

/out:app.exe
app.obj
hello.obj

c:\asm>app
Hello Asm
c:\asm>

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

Код (ASM):

option casemap:none

.code

; определяем функцию sum

; мы ожидаем два параметра - два числа

; по соглашениям первые два параметра в регистрах RCX и RDX

; возвращаемое значение - в регистре RAX

public sum

sum proc

mov rax, rcx ; помещаем в rax первый параметр - из регистра rcx

add rax, rdx ; складываем со вторым параметром - из регистра rdx

ret

sum endp

end

Здесь определена процедура sum, которая должна складывать два числа и возращать их сумму. Согласно соглашениям первые два параметра передаются через регистры RCX и RDX, а результат помещается в регистр RAX. Поэтому функция sum получает из регистров RCX и RDX переданные значения и их сумму помещает в RAX.
Определим файл app.c, в котором вызовем данную процедуру и получим ее результат:

Код (C):

#include <stdio.h>

#define int64 unsigned long long

extern int64 sum(int64, int64);

int main()

{

int64 a = 5;

int64 b = 6;

int64 result = sum(a, b);

printf("result = %lld \n", result); // result = 11

}

Все параметры и результат у нас представляют беззнаковый 64-разрядный целочисленный тип, то есть unsigned long long, и для краткости для него определен псевдоним int64
В вызов функции sum передаются значения переменных a и b. В итоге значение переменной a будет помещено в регистр RCX, а значение переменной b - в регистр RDX. Значение из регистра RAX мы можем получить в качестве результата функции

Код (C):

int64 result = sum(a, b);

Результат работы программы:

c:\asm>ml64 /c hello.asm
Microsoft (R) Macro Assembler (x64) Version 14.36.32532.0
Copyright (C) Microsoft Corporation. All rights reserved.

Assembling: hello.asm

c:\asm>cl app.c hello.obj
Microsoft (R) C/C++ Optimizing Compiler Version 19.36.32532 for x64
Copyright (C) Microsoft Corporation. All rights reserved.

app.c
Microsoft (R) Incremental Linker Version 14.36.32532.0
Copyright (C) Microsoft Corporation. All rights reserved.

/out:app.exe
app.obj
hello.obj

c:\asm>app
result = 11

c:\asm>

Mikl___ · 1 ноя 2026 в 06:00

Взаимодействие с кодом на C/C++
Практически пример. Обработка консольного ввода
Благодаря взаимодействию с C/C++ мы можем получать в коде ассемблера ввод пользователя и обрабатывать его, используя встроенные функции C/C++. Рассмотрим, как это сделать. Для этого определим файл app.c со следующим кодом на языке C:

Код (C):

#include <stdio.h>

extern void hello(void);

int readLine(char *dest, int maxLen)

{

// fgets считывает одну строку и возвращает NULL, если произошла ошибка

char *result = fgets(dest, maxLen, stdin);

if(result != NULL)

{

// удаляем символ перевода строки в конце строки

int len = strlen(result);

if(len > 0)

{

dest[len - 1] = 0;

}

return len;

}

return -1; // если произошла ошибка

}

int main(void)

{

hello();

}

Здесь мы подключаем внешнюю функцию hello, которая не принимает никаких параметров и ничего не возвращает и которая будет определена в коде ассемблера.
Для считывания данных с консоли определяем функцию readLine, которая принимает буфер, в который считываются данные, и количество считываемых данных. Для непосредственного считывания строки с консоли эта функция использует встроенную функцию fgets. Если при считывании произошла ошибка, то fgets возвращает NULL. Если же считывание прошло удачно, то последний считанный байт будет представлять символ перевода строки, который мы заменяем нулевым байтом.
При успешном считывании функция readLine возвращает количество считанных символов, при неудачном считывании - число -1. Данный результат позволит внешнему коду определить, удачно ли завершилось считывание или нет.
Также определим файл hello.asm со следующим кодом на ассемблере

Код (ASM):

option casemap:none

maxLen equ 128 ; максимальное количество символов

.data

prompt byte "Enter your name: ", 0 ; приглашение к вводу строки

message byte "Hello %s!", 10, 0 ; выводимое сообщение

username byte maxLen dup (0) ; буфер для ввода данных

.code

externdef printf:proc ; подключаем функцию printf

externdef readLine:proc ; подключаем функцию readLine

public hello

hello proc

sub rsp, 40 ; устанавливаем стек

lea rcx, prompt ; загружаем преглашение к вводу

call printf ; вызываем функцию printf для отображения приглашения к вводу

; считаем строку с консоли

lea rcx, username ; в rcx - строка, в которую считываем данные

mov rdx, maxLen ; в rdx - максимальное количество считываемых символов

call readLine ; вызываем readLine для считывания строки

; выводим считанное значение с помощью функции printf

lea rcx, message ; в rcx - выводимая строка

lea rdx, username ; в rdx - значение для спецификатора %s

call printf ; выводим строку

add rsp, 40 ; восстанавливаем стек

ret ; возвращаемся в программу на С

hello endp

end

Смысл программы будет заключаться в том, что пользователь вводит с консоли свое имя, и консоль в ответ выводит приветствие. С помощью константы maxLen задается максимальное количество вводимых символов. В данном случае это 128 символов.
В секции данных определяем три переменных. Переменная prompt представляет текст-приглашение к вводу имени. Переменная message представляет финальное сообщение, в которое вместо спецификатора %s будет подставлятсья введенное имя. И переменная username представляет строку для ввода имени. Она имеет 128 символов и по умолчанию инициализирована нулями.
В секции кода прежде всего пдключаем функции printf и readLine из кода С:

Код (C):

externdef printf:proc

externdef readLine:proc

Далее определяется процедура hello. В ней вначале выводим приглашение вводу с помощью функции printf

Код (ASM):

lea rcx, prompt ; загружаем преглашение к вводу

call printf ; вызываем функцию printf для отображения приглашения к вводу

Далее вызываем функцию readLine и тем самым считываем строку с консоли - имя пользователя:

Код (ASM):

lea rcx, username ; в rcx - строка, в которую считываем данные

mov rdx, maxLen ; в rdx - максимальное количество считываемых символов

call readLine ; вызываем readLine для считывания строки

После ввода имени выводим его на консоль с помощью функции printf:

Код (ASM):

lea rcx, message ; в rcx - выводимая строка

lea rdx, username ; в rdx - значение для спецификатора %s

call printf ; выводим строку

Сначала скомпилируем код ассемблера из файла hello.asm с помощью команды:

ml64 /c hello.asm

И скомпилируем файл app.c в файл приложения с помощью команды:

cl app.c hello.obj

После компиляции запустим файл app.exe:

c:\asm>ml64 /c hello.asm
Microsoft (R) Macro Assembler (x64) Version 14.36.32532.0
Copyright (C) Microsoft Corporation. All rights reserved.

Assembling: hello.asm

c:\asm>cl app.c hello.obj
Microsoft (R) C/C++ Optimizing Compiler Version 19.36.32532 for x64
Copyright (C) Microsoft Corporation. All rights reserved.

app.c
Microsoft (R) Incremental Linker Version 14.36.32532.0
Copyright (C) Microsoft Corporation. All rights reserved.

/out:app.exe
app.obj
hello.obj

c:\asm>app
Enter your name: Mikl___
Hello Mikl___!

c:\asm>

Mikl___ · 1 ноя 2026 в 08:11

Взаимодействие с WinAPI
Запись в файл и вывод на консоль
WinAPI предоставляет множество различных функций для работы с файлами. Рассмотрим некоторые из них:

CreateFileA: открывает существующие файлы или создает новые

WriteFile: записывает данные в файл

ReadFile: считывает данные из файла

CloseHandle: закрывает файл

GetStdHandle: возвращает дескриптор одного из стандартных устройств ввода или вывода

GetLastError: возвращает код ошибки Windows, если ошибка возникает при выполнении любой из выше перечисленных функций.

За работу с файлами отвечает библиотека kernel32.lib
Запись в файл
Для записи в файл применяется функция WriteFile, которая имеет следующее определение на языке C++:

Код (C):

BOOL WriteFile(

[in] HANDLE hFile,

[in] LPCVOID lpBuffer,

[in] DWORD nNumberOfBytesToWrite,

[out, optional] LPDWORD lpNumberOfBytesWritten,

[in, out, optional] LPOVERLAPPED lpOverlapped

);

WriteFile имеет следующие аргументы:

hFile: дескриптор файла, передается через регистр RCX

lpBuffer: адрес буфера для записи, передается через регистр RDX

nNumberOfBytesToWrite: размер буфера, передается через регистр R8 (поскольку представляет тип dword и занимает 32 бита, то передайется в R8D)

lpNumberOfBytesWritten: адрес переменной типа dword для получения количества байтов, записанных в файл. Равно размеру буфера, если операция записи прошла успешно. Передается через регистр R9

lpOverlapped: обычно имеет значение NULL (0), передается через стек по адресу [rsp + 32]

После выполнения функция WriteFile помещает в регистр RAX ненулевое значение, если запись прошла успешно, и ноль, если произошла ошибка. Если произошла ошибка, можно вызвать другую функцию WinAPI - GetLastError, чтобы получить код ошибки.
Используем функцию WriteFile для записи (вывода) данных на консоль, а точнее в стандартный поток вывода:

Код (ASM):

includelib kernel32.lib ; подключаем библиотеку kernel32.lib

; подключаем функции WriteFile и GetStdHandle

extrn WriteFile: PROC

extrn GetStdHandle: PROC

.data

text byte "Hello METANIT.COM!" ; выводимая строка

len = $-text

bytesWritten dword ? ; количество записанных байтов

.code

main proc

sub rsp, 40 ; Для параметров функций WriteFile и GetStdHandle

mov rcx, -11 ; Аргумент для GetStdHandle - STD_OUTPUT

call GetStdHandle ; вызываем функцию GetStdHandle

mov rcx, rax ; Первый параметр WriteFile - в регистр RCX помещаем дескриптор файла - консоли

lea rdx, text ; Второй параметр WriteFile - загружаем указатель на строку в регистр RDX

mov r8d, len ; Третий параметр WriteFile - длина строки для записи в регистре R8D

lea r9, bytesWritten ; Четвертый параметр WriteFile - адрес для получения записанных байтов

mov qword ptr [rsp + 32], 0 ; Пятый параметр WriteFile

call WriteFile ; вызываем функцию WriteFile

test rax, rax ; проверяем на наличие ошибки

mov eax, bytesWritten ; если все нормально, помещаем в RAX количество записанных байтов

jnz exit

mov rax, -1 ; Возвращаем через RAX код ошибки

exit:

add rsp, 40

ret

main endp

end

Здесь функции GetStdHandle в качестве параметра через регистр RCX передается значение -11, которое указывает, что надо получить дескриптор стандартного вывода.
Полученный через регистр RAX дескриптор передаем функции WriteFile через регистр RCX. Через регистр RDX передается адрес выводимой строки - переменной text, а через регистр R8D - длина строки. В регистр R9 загружаем адрес переменной bytesWritten, через которую получим реальное число записанных байтов.
После выполнения функции WriteFile и соответственно вывода строки на консоль проверяем результат функции в регистре RAX - если он не равен 0 (то есть все прошло без ошибок), то в RAX помещаем количество записанных байтов. Если же произошла ошибка, то в RAX помещаем число -1, которое будет условно обозначать, что произошла ошибка.
Для абстрагирования от конкретной строки и упрощения вывода на консоль мы можем выделить все соответствующие действия в отдельную процедуру:

Код (ASM):

includelib kernel32.lib ; подключаем библиотеку kernel32.lib

; подключаем функции WriteFile и GetStdHandle

extrn WriteFile: PROC

extrn GetStdHandle: PROC

.data

text byte "Hello WASM.IN!" ; выводимая строка

len = $-text

stdout qword 0 ; дескриптор консольного вывода

stdoutSet byte 0 ; установлен ли дескриптор консольного вывода

.code

; Параметры:

; RSI - адрес строки

; RCX - длина строки

; RAX - дескриптор файла

; Результат - через RAX возвращаем количество записанных байтов

write proc

sub rsp, 56 ; 40 байт (5 параметров WriteLine) + 8 байт (bytesWritten) + 8 байт выравнивание

mov rdx, rsi ; Второй параметр - строка

mov r8, rcx ; Третий параметр - длина строки

mov rcx, rax ; Первый параметр WriteFile - в регистр RCX помещаем дескриптор файла - консольного вывода

lea r9, bytesWritten ; Четвертый параметр WriteFile - адрес для получения записанных байтов

mov qword ptr [rsp + 32], 0 ; Пятый параметр WriteFile

call WriteFile

test rax, rax ; проверяем на наличие ошибки

mov eax, bytesWritten ; если все нормально, помещаем в RAX количество записанных байтов

jnz exit

mov rax, -1 ; Возвращаем через RAX код ошибки

exit:

add rsp, 56

ret

bytesWritten equ [rsp+40]

write endp

; Процедура вывода произвольной строки на консоль

; Параметры

; RSI - адрес строки

; RCX - количество символов

; Результат - в RAX количество записанных байтов или -1, если произошла ошибка

writeToConsole proc

cmp stdoutSet, 1

jz writeData ; если дескриптор консольного вывода установлен

sub rsp, 32

push rcx ; сохраняем количество символов

mov rcx, -11 ; Аргумент для GetStdHandle - STD_OUTPUT

call GetStdHandle ; вызываем функцию GetStdHandle

pop rcx ; восстанавливаем RCX - количество символов

add rsp, 32

mov stdout, rax ; помещаем в stdout дескриптор консольного вывода

mov stdoutSet, 1 ; дескриптор консольного вывода установлен

writeData:

mov rax, stdout

call write

ret

writeToConsole endp

main proc

lea rsi, text ; загружаем адрес строки

mov rcx, len ; загружаем размер строки

call writeToConsole ; выводим строку на консоль

ret

main endp

end

Здесь запись разбита на две процедуры. Первая процедура - write собственно выполняет запись в файл. Через регистр RAX она получает дескриптор файла. Причем это может быть дескриптор консольного вывода, а может быть и дескриптор какого-то другого файла. Таким образом, мы абстрагируемся от консоли и опредлеяем универсальную функцию записи. Через регистр RSI она получает адрес строки, а через RCX - размер строки. Внутри функции устанавливаются все необходимые регистры и вызывается внешняя функция WriteFile. Результат функции - или количество записанных байтов, которое хранится в стеке по адресу rsp+40, либо -1, если произошла ошибка. В данном случае мы никак не обыгрываем данную ситуацию, но в принципе мы можем проверить результат данной процедуры для последующих действий, например, для вывода пользователю сообщения об ошибке и т.д.
Непосредственно для вывода данных на консоль определена функция writeToConsole. В ней получаем дескриптор консольного вывода с помощью вызова функции GetStdHandle и сохраняем в переменную stdout. Чтобы указать, что дескриптор стандартного вывода установлен, присваиваем переменной stdoutSet. Сравнивая ее значение, мы можем определить, был ли ранее получен дескриптор. Это позволит при повторном вызове процедуры writeToConsole избежать ненужных обращений к функции GetStdHandle. После получения дескриптора передаем его процедуре write и с ее помощью собственно выполняем запись.
Благодаря этому мы можем удобным образом многократно выполнять вывод на консоль строк. Например:

Код (ASM):

main proc

lea rsi, text1

mov rcx, len1

call writeToConsole ; выводим первую строку на консоль

lea rsi, text2

mov rcx, len2

call writeToConsole ; выводим вторую строку на консоль

ret

text1 byte "Hello WASM.IN!",10

len1 = $-text1

text2 byte "Hello Assembler!",10

len2 = $-text2

main endp

Вывод символов с переводом на новую строку
В примере выше, чтобы при выводе строк на консоль они не сливались, в конце строки определялся байт 10, который в таблице ASCII соответствует символу \n или символу перевода строки. Чтобы уйти от необходимости определять в конце каждой строки такой символ, можно его добавлять при выводе строки на консоль. Например:

Код (ASM):

includelib kernel32.lib ; подключаем библиотеку kernel32.lib

; подключаем функции WriteFile и GetStdHandle

extrn WriteFile: PROC

extrn GetStdHandle: PROC

.data

stdout qword 0 ; дескриптор консольного вывода

stdoutSet byte 0 ; установлен ли дескриптор консольного вывода

.code

; Параметры:

; RSI - адрес строки

; RCX - длина строки

; RAX - дескриптор файла

; Результат - через RAX возвращаем количество записанных байтов

write proc

sub rsp, 56

mov rdx, rsi ; Второй параметр - строка

mov r8, rcx ; Третий параметр - длина строки

mov rcx, rax ; Первый параметр WriteFile - в регистр RCX помещаем дескриптор файла - консольного вывода

lea r9, bytesWritten ; Четвертый параметр WriteFile - адрес для получения записанных байтов

mov qword ptr [rsp + 32], 0 ; Пятый параметр WriteFile

call WriteFile

test rax, rax ; проверяем на наличие ошибки

mov eax, bytesWritten ; если все нормально, помещаем в RAX количество записанных байтов

jnz exit

mov rax, -1 ; Возвращаем через RAX код ошибки

exit:

add rsp, 56

ret

bytesWritten equ [rsp+40]

write endp

; Процедура вывода строки на консоль

; Параметры

; RSI - адрес строки

; RCX - количество символов

; Результат - в RAX количество записанных байтов или -1, если произошла ошибка

writeToConsole proc

cmp stdoutSet, 1

jz writeData ; если дескриптор консольного вывода установлен

sub rsp, 32

push rcx ; сохраняем количество символов

mov rcx, -11 ; Аргумент для GetStdHandle - STD_OUTPUT

call GetStdHandle ; вызываем функцию GetStdHandle

pop rcx ; восстанавливаем RCX - количество символов

add rsp, 32

mov stdout, rax ; помещаем в stdout дескриптор консольного вывода

mov stdoutSet, 1 ; дескриптор консольного вывода установлен

writeData:

mov rax, stdout

call write

ret

writeToConsole endp

; Процедура вывода символов c переводом на новую строку

; Параметры

; RSI - адрес строки

; RCX - количество символов

writeLine proc

call writeToConsole ; записываем текст из RSI длиной RCX байт

lea rsi, crlf

mov rcx, 2

call writeToConsole ; после записи текста записываем перевод строки = \r\n

ret

crlf byte 10, 13 ; для перевода на новую строку

writeLine endp

main proc

lea rsi, text1

mov rcx, len1

call writeLine ; выводим первую строку на консоль

lea rsi, text2

mov rcx, len2

call writeLine ; выводим вторую строку на консоль

ret

text1 byte "Hello WASM.IN!"

len1 = $-text1

text2 byte "Hello Assembler!"

len2 = $-text2

main endp

end

Здесь добавлена процедура writeLine, которая принимает строку, выводит ее на консоль с помощью writeToConsole, а затем дополнительно выводит символы \r\n, которые хранятся в строке crlf.
Вывод строк с концевым символом
Для идентификации конца строки может использоваться, как в примере выше, размер строки. Но, например, язык C и ряд других языков использует другой подход - завершение строки специальным концевым символом - нулевым байтом. В качестве концевого символа не обязательно должен выступать нулевой байт. Но если коду на ассемблере предстоит работать с такими строками, то мы можем просто расчитать количество символов до подобного концевого символа и также обрабатывать строку

Код (ASM):

includelib kernel32.lib ; подключаем библиотеку kernel32.lib

; подключаем функции WriteFile и GetStdHandle

extrn WriteFile: PROC

extrn GetStdHandle: PROC

.data

stdout qword 0 ; дескриптор консольного вывода

stdoutSet byte 0 ; установлен ли дескриптор консольного вывода

.code

; Параметры:

; RSI - адрес строки

; RCX - длина строки

; RAX - дескриптор файла

; Результат - через RAX возвращаем количество записанных байтов

write proc

sub rsp, 56

mov rdx, rsi ; Второй параметр - строка

mov r8, rcx ; Третий параметр - длина строки

mov rcx, rax ; Первый параметр WriteFile - в регистр RCX помещаем дескриптор файла - консольного вывода

lea r9, bytesWritten ; Четвертый параметр WriteFile - адрес для получения записанных байтов

mov qword ptr [rsp + 32], 0 ; Пятый параметр WriteFile

call WriteFile

test rax, rax ; проверяем на наличие ошибки

mov eax, bytesWritten ; если все нормально, помещаем в RAX количество записанных байтов

jnz exit

mov rax, -1 ; Возвращаем через RAX код ошибки

exit:

add rsp, 56

ret

bytesWritten equ [rsp+40]

write endp

; Процедура вывода строки на консоль

; Параметры

; RSI - адрес строки

; RCX - количество символов

; Результат - в RAX количество записанных байтов или -1, если произошла ошибка

writeToConsole proc

cmp stdoutSet, 1

jz writeData ; если дескриптор консольного вывода установлен

sub rsp, 32

push rcx ; сохраняем количество символов

mov rcx, -11 ; Аргумент для GetStdHandle - STD_OUTPUT

call GetStdHandle ; вызываем функцию GetStdHandle

pop rcx ; восстанавливаем RCX - количество символов

add rsp, 32

mov stdout, rax ; помещаем в stdout дескриптор консольного вывода

mov stdoutSet, 1 ; дескриптор консольного вывода установлен

writeData:

mov rax, stdout

call write

ret

writeToConsole endp

; Процедура вывода символов c переводом на новую строку

; Параметры

; RSI - адрес строки

; RCX - количество символов

writeLine proc

call writeToConsole ; записываем текст из RSI длиной RCX байт

lea rsi, crlf

mov rcx, 2

call writeToConsole ; после записи текста записываем перевод строки = \r\n

ret

crlf byte 10, 13 ; для перевода на новую строку

writeLine endp

; Процедура вывода произвольной строки на консоль

; Параметры

; RSI - адрес строки

; Результат - в RAX количество записанных байтов или -1, если произошла ошибка

writeText proc

; вычисляем длину строки

mov rcx, -1 ; счетчик символов строки

calculateLen:

inc rcx

cmp byte ptr [rsi][rcx * 1], 0 ; пока не дойдем до нулевого байта

jne calculateLen

call writeLine

ret

writeText endp

main proc

lea rsi, text1

call writeText ; выводим первую строку на консоль

lea rsi, text2

call writeText ; выводим вторую строку на консоль

ret

text1 byte "Hello C/C++",0

text2 byte "Hello Assembler!",0

main endp

end

Здесь добавлена процедура writeText, которая получает извне через RSI строку и вычисляет ее длину, пока не встретит концевой символ - нулевой байт и затем вызывает процедуру writeLine:

Код (ASM):

; вычисляем длину строки

mov rcx, -1 ; счетчик символов строки

calculateLen:

inc rcx

cmp byte ptr [rsi][rcx * 1], 0 ; пока не дойдем до нулевого байта

jne calculateLen

call writeLine

В процедуре main при вызове writeText передаются строки с концевым нулевым байтом:

Код (ASM):

main proc

lea rsi, text1

call writeText ; выводим первую строку на консоль

lea rsi, text2

call writeText ; выводим вторую строку на консоль

ret

text1 byte "Hello C/C++",0

text2 byte "Hello Assembler!",0

main endp

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

Mikl___ · 1 ноя 2026 в 08:39

Взаимодействие с WinAPI
Считывание файла и ввод с консоли
Для считывания данных в WinAPI применяется функция ReadFile, которая имеет следующее определение на языке C++:

Код (C):

[TD]BOOL ReadFile(

[in] HANDLE hFile,

[out] LPVOID lpBuffer,

[in] DWORD nNumberOfBytesToRead,

[out, optional] LPDWORD lpNumberOfBytesRead,

[in, out, optional] LPOVERLAPPED lpOverlapped

);

Она принимает следующие параметры:

hFile: дескриптор файла для считывания, передается через регистр RCX

lpBuffer: буфер, который получает считываемые данные, передается через регистр RDX

nNumberOfBytesToRead: максимальное число байтов для чтения., передается через регистр R8

lpNumberOfBytesRead: адрес переменной, которая получает количество считанных байтов, передается через регистр R9

lpOverlapped: обычно имеет значение NULL (0), передается через стек по адресу [rsp + 32]

После выполнения функция ReadFile помещает в регистр RAX ненулевое значение, если запись прошла успешно, и ноль, если произошла ошибка.
Считаем данные с консоли и для этого определим следующую программу:

Код (ASM):

includelib kernel32.lib ; подключаем библиотеку kernel32.lib

; подключаем функции ReadFile и GetStdHandle

extrn GetStdHandle: PROC

extrn ReadFile: PROC

.data

buffer byte 200 dup (?) ; буфер для считывания данных

len = $ - buffer

bytesRead qword ? ; количество считанных данных

.code

main proc

sub rsp, 40 ; 32 байта (shadow storage) + 8 байт (5-й параметр функции ReadFile)

mov rcx, -10 ; Аргумент для GetStdHandle - STD_INPUT

call GetStdHandle ; вызываем функцию GetStdHandle

mov rcx, rax ; Первый параметр ReadFile - дескриптор файла

lea rdx, buffer ; Второй параметр ReadFile - адрес буфера

mov r8, len ;Третий параметр ReadFile - размер буфера

lea r9, bytesRead ; Четвертый параметр ReadFile - количество считанных байтов

mov qword ptr [rsp + 32], 0 ; Пятый параметр ReadFile - 0

call ReadFile ; вызов функции RaedFile

test rax, rax ; проверяем на ошибку

mov rax, bytesRead ; если ошибки нет, в RAX количество считанных байтов

jnz exit ; если в RAX ненулевое значение

mov rax, -1 ; помещаем условный код ошибки

exit:

add rsp, 40

ret

main endp

end

При считывании с консоли ввода пользователя нам надо получить дескриптор стандартного ввода. Для этого функции GetStdHandle число -10. После вызова этой функции в RAX будет дескриптор консольного ввода.
Полученный дескриптор передаем через регистр RCX в функцию ReadFile. Для считывания данных в RDX загружаем адрес переменной buffer, в которую будет считываться ввод пользователя. В регистр R8 помещается размер этого буфера. А в R9 загружается адрес переменной bytesRead для хранения реально считанных байтов, так как пользователь может ввести всего 1-2 символа, что будут меньше размера буфера.
После вызова функции ReadFile инструкцией test проверяем результат функции из регистра RAX. Если он не равен нулю (то есть функция ReadFile выполнена успешно), то в RAX помещаем количество реально считанных байтов. Если результат функции - 0, то в RAX помещаем условный код ошибки - число -1.
Пример компиляции и работы программы (в моем случае программа располагается в файле hello.asm):

c:\asm>ml64 hello.asm /link /entry:main
Microsoft (R) Macro Assembler (x64) Version 14.36.32532.0
Copyright (C) Microsoft Corporation. All rights reserved.
Assembling: hello.asm
Microsoft (R) Incremental Linker Version 14.36.32532.0
Copyright (C) Microsoft Corporation. All rights reserved.
/OUT:hello.exe
hello.obj
/entry:main
c:\asm>hello
hello
c:\asm>echo %ERRORLEVEL%
7
c:\asm>

В консольном выводе выше видно, что я ввожу текст "hello", однако реально считанное количество равно 7, поскольку при завершении ввода в строку добавляются символы "/r/n" (перевод каретки и перевод строки).
Мы можем пойти дальше и вынести считывание данных в отдельную процедуру, отделив от взаимодействия с консолью:

Код (ASM):

includelib kernel32.lib ; подключаем библиотеку kernel32.lib

; подключаем функции ReadFile и GetStdHandle

extrn GetStdHandle: PROC

extrn ReadFile: PROC

.data

buffer byte 200 dup (?) ; буфер дляссчитывания данных

len = $ - buffer

.code

; Процедура для считывания данных

; Параметры:

; RAX - дескриптор файла,

; RDI - буфер для считывания

; RCX - длина буфера

; Результат - в RAX количество записанных байтов или -1, если произошла ошибка

read proc

sub rsp, 56 ; 32 байта (shadow storage) + 8 байт (5-й параметр ReadFile) + 8 байт (bytesRead) + 8 байт (выравнивание)

mov r8, rcx ;Третий параметр ReadFile - размер буфера

mov rcx, rax ; Первый параметр ReadFile - дескриптор файла

mov rdx, rdi ; Второй параметр ReadFile - адрес буфера

lea r9, bytesRead ; Четвертый параметр ReadFile - количество считанных байтов

mov qword ptr [rsp + 32], 0 ; Пятый параметр ReadFile - 0

call ReadFile ; вызов функции RaedFile

test rax, rax ; проверяем на ошибку

mov eax, bytesRead ; если ошибки нет, в RAX количество считанных байтов

jnz exit ; если в RAX ненулевое значение

mov rax, -1 ; помещаем условный код ошибки

exit:

add rsp, 56

ret

bytesRead equ [rsp+40] ; область в стеке для хранения количества считанных байтов

read endp

; Процедура для считывания данных с консоли

; Параметры:

; RDI - буфер для считывания

; RCX - длина буфера

; Результат - в RAX количество записанных байтов или -1, если произошла ошибка

readFromConsole proc

sub rsp, 32

push rcx ; сохраняем количество символов

mov rcx, -10 ; Аргумент для GetStdHandle - STD_INPUT

call GetStdHandle ; вызываем функцию GetStdHandle

pop rcx

call read

add rsp, 32

ret

readFromConsole endp

main proc

lea rdi, buffer ; буфер для считывания данных

mov rcx, len ; размер буфера

call readFromConsole ; считываем данные с консоли

ret

main endp

end

В данном случае процедура считывания данных - read получает через регистр RAX дескриптор файла (в данном случае дескриптор стандартного ввода), через регистр RDI буфер для считывания данных и через RCX - максимальное количество считываемых символов. И также возвращает либо количество считанных символов, либо число -1 - условный код ошибки.
Процедура readFromConsole получает дескриптор консольного ввода и вызывает процедуру read для считывания с консоли.
Правда стоит отметить, что это не самый оптимальный способ ввода с клавиатуры - если нам предстоит несколько раз вводить данные с консоли, то каждый раз придется вызывать функцию GetStdHandle для получения дескриптора консольного ввода. Вместо этого мы можем сохранить дескриптор в переменной и затем многократно его использовать:

Код (ASM):

includelib kernel32.lib ; подключаем библиотеку kernel32.lib

; подключаем функции ReadFile и GetStdHandle

extrn GetStdHandle: proc

extrn ReadFile: proc

extrn WriteFile: proc

.data

buffer byte 200 dup (?) ; буфер для считывания данных

len = $ - buffer

stdin qword 0 ; для дескриптора консольного ввода

stdinSet byte 0 ; был ли установлен дескриптор консольного ввода

.code

; Процедура для считывания данных

; Параметры:

; RAX - дескриптор файла,

; RDI - буфер для считывания

; RCX - длина буфера

; Результат - в RAX количество записанных байтов или -1, если произошла ошибка

read proc

sub rsp, 56

mov r8, rcx ;Третий параметр ReadFile - размер буфера

mov rcx, rax ; Первый параметр ReadFile - дескриптор файла

mov rdx, rdi ; Второй параметр ReadFile - адрес буфера

lea r9, bytesRead ; Четвертый параметр ReadFile - количество считанных байтов

mov qword ptr [rsp + 32], 0 ; Пятый параметр ReadFile - 0

call ReadFile ; вызов функции RaedFile

test rax, rax ; проверяем на ошибку

mov eax, bytesRead ; если ошибки нет, в RAX количество считанных байтов

jnz exit ; если в RAX ненулевое значение

mov rax, -1 ; помещаем условный код ошибки

exit:

add rsp, 56

ret

bytesRead equ [rsp+40] ; область в стеке для хранения количества считанных байтов

read endp

; Процедура для считывания данных с консоли

; Параметры:

; RDI - буфер для считывания

; RCX - длина буфера

; Результат - в RAX количество записанных байтов или -1, если произошла ошибка

readFromConsole proc

cmp stdinSet, 1 ; если дескриптор стандартного ввода установлен

jz readData ; то переходим к считыванию данных

sub rsp, 32

push rcx ; сохраняем количество символов

mov rcx, -10 ; Аргумент для GetStdHandle - STD_INPUT

call GetStdHandle ; вызываем функцию GetStdHandle

mov stdin, rax ; сохраняем дескриптор стандартного ввода

mov stdinSet, 1

pop rcx

add rsp, 32

readData:

mov rax, stdin

call read

ret

readFromConsole endp

main proc

lea rdi, buffer ; буфер для считывания данных

mov rcx, len ; размер буфера

call readFromConsole ; считываем данные с консоли

ret

main endp

end

Здесь функция GetStdHandle вызывается один раз, после чего дескриптор консольного ввода сохраняется в переменной stdin и устанавливается переменная stdinSet. Далее используя этот дескриптор, можно многократно выводить данные на консоль.
Считывание одного символа
Нередко возникает задача считать один символ. Рассмотрим, как это сделать:

Код (ASM):

includelib kernel32.lib

extrn GetStdHandle: proc

extrn ReadFile: proc

.data

buffer byte 200 dup (?) ; буфер для считывания данных

len = $ - buffer

stdin qword 0 ; для хранения дескриптора консольного ввода

stdinSet byte 0 ; индикатор, что дескриптор консольного ввода установлен

.code

; Процедура для считывания данных

; Параметры:

; RAX - дескриптор файла,

; RDI - буфер для считывания

; RCX - длина буфера

; Результат - в RAX количество записанных байтов или -1, если произошла ошибка

read proc

sub rsp, 56

mov r8, rcx ;Третий параметр ReadFile - размер буфера

mov rcx, rax ; Первый параметр ReadFile - дескриптор файла

mov rdx, rdi ; Второй параметр ReadFile - адрес буфера

lea r9, bytesRead ; Четвертый параметр ReadFile - количество считанных байтов

mov qword ptr [rsp + 32], 0 ; Пятый параметр ReadFile - 0

call ReadFile ; вызов функции RaedFile

test rax, rax ; проверяем на ошибку

mov eax, bytesRead ; если ошибки нет, в RAX количество считанных байтов

jnz exit ; если в RAX ненулевое значение

mov rax, -1 ; помещаем условный код ошибки

exit:

add rsp, 56

ret

bytesRead equ [rsp+40] ; область в стеке для хранения количества считанных байтов

read endp

; Процедура для считывания данных с консоли

; Параметры:

; RDI - буфер для считывания

; RCX - длина буфера

; Результат - в RAX количество записанных байтов или -1, если произошла ошибка

readFromConsole proc

cmp stdinSet, 1 ; если дескриптор стандартного ввода установлен

jz readData ; то переходим к считыванию данных

sub rsp, 32

push rcx ; сохраняем количество символов

mov rcx, -10 ; Аргумент для GetStdHandle - STD_INPUT

call GetStdHandle ; вызываем функцию GetStdHandle

mov stdin, rax ; сохраняем дескриптор стандартного ввода

mov stdinSet, 1

pop rcx

add rsp, 32

readData:

mov rax, stdin

call read

ret

readFromConsole endp

; Процедура считывания одного символа с консоли

; Результат: в AL код считанного символа

readChar proc

sub rsp, 8 ; выделяем 8 байт для считывания символа

mov rdi, rsp ; в качестве буфера будет использоваться область в стеке

mov rcx, 1 ; считываем 1 байт

call readFromConsole

movzx rax, byte ptr [rsp] ; В RAX (точнее в AL) помещаем считанный символ

add rsp, 8

ret

readChar endp

main proc

call readChar ; считываем символ

ret

main endp

end

Здесь символ считывается процедурой readChar. Эта процедура выделяет в стеке 8 байт в качестве буфера для считывания данных (хотя в реальности нам достаточно 1 байта для хранения символа). Затем для считывания символа с консоли вызываем ранее рассмотренную процедуру readFromConsole. После выполнения процедуры помещаем символ из буфера (в стеке) в регистр AL. Пример работы программы:

c:\asm>hello.exe
A
c:\asm>echo %ERRORLEVEL%
65
c:\asm>

В данном случае был введен символ "A", соответственно в регистре AL был помещен код данного символа - число 65.
Удаление из ввода перевода строки
Как выше было указано, при вводе в буфер автоматически добавляются символы возврата каретки и перевода строки /r/n, которые имеют в такблице ASCII коды 13 и 10 соответственно. То есть мы вводим 2 символа, а в буфер записываются 4 символа. Это может быть не очень удобно. Кроме того, возможно, мы захотим, чтобы введенная строка заканчивалась каким-нибудь концевым признаком, например, нулевым байтом, как строки в языке C. Для этого мы можем использовать выше описанную процедуру для считывания символа - считывать по одному символу и проверять его код. Если код представляет обычный символ (не возврат каретки или перевод строки), то добавлять буфер. Возможная реализация:

Код (ASM):

includelib kernel32.lib ; подключаем библиотеку kernel32.lib

; подключаем функции ReadFile и GetStdHandle

extrn GetStdHandle: proc

extrn ReadFile: proc

.data

buffer byte 200 dup (?) ; буфер для считывания данных

len = $ - buffer

stdin qword 0 ; для хранения дескриптора консольного ввода

stdinSet byte 0 ; индикатор, что дескриптор консольного ввода установлен

.code

; Процедура для считывания данных

; Параметры:

; RAX - дескриптор файла,

; RDI - буфер для считывания

; RCX - длина буфера

; Результат - в RAX количество записанных байтов или -1, если произошла ошибка

read proc

sub rsp, 56

mov r8, rcx ;Третий параметр ReadFile - размер буфера

mov rcx, rax ; Первый параметр ReadFile - дескриптор файла

mov rdx, rdi ; Второй параметр ReadFile - адрес буфера

lea r9, bytesRead ; Четвертый параметр ReadFile - количество считанных байтов

mov qword ptr [rsp + 32], 0 ; Пятый параметр ReadFile - 0

call ReadFile ; вызов функции RaedFile

test rax, rax ; проверяем на ошибку

mov eax, bytesRead ; если ошибки нет, в RAX количество считанных байтов

jnz exit ; если в RAX ненулевое значение

mov rax, -1 ; помещаем условный код ошибки

exit:

add rsp, 56

ret

bytesRead equ [rsp+40] ; область в стеке для хранения количества считанных байтов

read endp

; Процедура для считывания данных с консоли

; Параметры:

; RDI - буфер для считывания

; RCX - длина буфера

; Результат - в RAX количество записанных байтов или -1, если произошла ошибка

readFromConsole proc

cmp stdinSet, 1 ; если дескриптор стандартного ввода установлен

jz readData ; то переходим к считыванию данных

sub rsp, 32

push rcx ; сохраняем количество символов

mov rcx, -10 ; Аргумент для GetStdHandle - STD_INPUT

call GetStdHandle ; вызываем функцию GetStdHandle

mov stdin, rax ; сохраняем дескриптор стандартного ввода

mov stdinSet, 1

pop rcx

add rsp, 32

readData:

mov rax, stdin

call read

ret

readFromConsole endp

; Процедура считывания одного символа с консоли

; Результат: в AL код считанного символа

readChar proc

push rcx

push rdi

sub rsp, 8 ; выделяем 8 байт для считывания символа

mov rdi, rsp ; в качестве буфера будет использоваться область в стеке

mov rcx, 1 ; считываем 1 байт

call readFromConsole

movzx rax, byte ptr [rsp] ; В RAX (точнее в AL) помещаем считанный символ

add rsp, 8

pop rdi

pop rcx

ret

readChar endp

; Процедура для считывания строки текста

; Параметры

; RDI - буфер для считывания данных

; RCX - размер буфера

; Результат: в RAX - количество считанных символов

readLine proc

xor rbx, rbx ; счетчик символов

test rcx, rcx ; проверяем, что размер буфера больше 0

je exit ; если размер буфера - 0, выходим из процедуры

dec rcx ; уменьшаем на 1, чтобы потом добавить нулевой байт

while_start:

cmp rbx, rcx ; проверяем, что буфер не заполнен

jz while_end ; если RBX = RCX, то выходим из цикла

call readChar ; если буфер не запонен, считываем 1 символ

test eax, eax ; проверяем, что был считан 1 символ

jz while_end ; если считано 0 симвлов, выходим из цикла

cmp al, 13 ; если нажата клавиша Enter (символ /r)

je while_end ; выходим из цикла

cmp al, 10 ; проверяем на перевод строки - символ /n

je while_end ; выходим из цикла

cmp al, 8 ; проверяем нажатие клавиша backspace

jne addChar ; если она не нажата, добавляем новый символ в буфер

; если нажата клавиша backspace, удаляем предыдущий символ

test rbx, rbx ; проверяем, что введено не 0 символов

jz while_start ; если в буфере нет символов, переходим к вводу нового символа

dec rbx ; если в буфере есть символы, уменьшаем счетчик - как бы сдвигаем ввод назад

jmp while_start ; и переходим к вводу нового символа

; Если обычный символ, добавляем символ в буфер

addChar:

mov [rdi][rbx], al ; сохраняем символ в буфер

inc rbx ; инкрементируем счетчик

jmp while_start ; переходим к вводу нового символа

; если пользователь нажал на ENTER, добавляем к строке нулевой байт

while_end:

mov byte ptr [rdi][rbx], 0

exit:

mov rax, rbx ; в RAX количество считанных символов

ret

readLine endp

main proc

lea rdi, buffer

mov rcx, len

call readLine

ret

main endp

end

Для считывания строки с консоли определена процедура readLine. Через RDI она получает буфер для считывания данных, а через RCX - размер буфера.
Вначале в этой процедуре устанавливается счетчик считанных символов - в регистре RBX, а также уменьшается на 1 значение в RCX, чтобы выделить место для нулевого байта. Кроме того, проверяем размер буфера, что он не равен 0:

Код (ASM):

xor rbx, rbx ; счетчик символов

test rcx, rcx ; проверяем, что размер буфера больше 0

je exit ; если размер буфера - 0, выходим из процедуры

dec rcx ; уменьшаем на 1, чтобы потом добавить нулевой байт

Затем в цикле проверяем количество считанных символов - если оно равно размеру буфера, то прекращаем считывание символов и выходим из цикла:

Код (ASM):

while_start:

cmp rbx, rcx ; проверяем, что буфер не заполнен

jz while_end ; если RBX = RCX, то выходим из цикла

call readChar ; если буфер не запонен, считываем 1 символ

test eax, eax ; проверяем, что был считан 1 символ

jz while_end ; если считано 0 симвлов, выходим из цикла

cmp al, 13 ; если нажата клавиша Enter (символ /r)

je while_end ; выходим из цикла

cmp al, 10 ; проверяем на перевод строки - символ /n

je while_end ; выходим из цикла

cmp al, 8 ; проверяем нажатие клавиша backspace

jne addChar ; если она не нажата, добавляем новый символ в буфер

Также проверяем нажатие на Enter, и в этом случае также выходим из цикла ввода символов.
Если нажата клавиша Backspace (то есть идет удаление введенного символа) и если ранее были уже введены символы, то уменьшаем счетчик символов в RBX на 1, то есть формально сдвигаемся в буфере для ввода нового символа на 1 байт назад:

Код (ASM):

test rbx, rbx ; проверяем, что введено не 0 символов

jz while_start ; если в буфере нет символов, переходим к вводу нового символа

dec rbx ; если в буфере есть символы, уменьшаем счетчик - как бы сдвигаем ввод назад

jmp while_start ; и переходим к вводу нового символа

Если введен обычный символ, то добавляем его в буфер, увеличиваем счетчик символов RBX и переходим к вводу нового символа

Код (ASM):

addChar:

mov [rdi][rbx], al ; сохраняем символ в буфер

inc rbx ; инкрементируем счетчик

jmp while_start ; переходим к вводу нового символа

Если мы достигли конца буфера или нажата клавиша Enter, то добавляем после последнего введенного символа нулевой байт, а количество введенных символов помещаем в регистр RAX - своего рода результат процедуры:

Код (ASM):

while_end:

mov byte ptr [rdi][rbx], 0

exit:

mov rax, rbx ; в RAX количество считанных символов

Пример работы программы:

c:\asm>hello
Hello
c:\asm>echo %ERRORLEVEL%
5
c:\asm>

Mikl___ · 1 ноя 2026 в 08:32

Взаимодействие с WinAPI
Практический пример. Обработка ввода
После ввода введенные данные мы можем обработать. Например, переведем введенную строку в верхний регистр:

Код (ASM):

includelib kernel32.lib ; подключаем библиотеку kernel32.lib

extrn GetStdHandle: proc

extrn ReadFile: proc

extrn WriteFile: proc

.data

buffer byte 200 dup (?) ; буфер для считывания данных

len = $ - buffer

.code

; Процедура для считывания данных

; Параметры:

; RAX - дескриптор файла,

; RDI - буфер для считывания

; RCX - длина буфера

; Результат - в RAX количество записанных байтов или -1, если произошла ошибка

read proc

sub rsp, 56 ; 32 (shadow storage) + 8 (5-й параметр ReadFile) + 8 (byttesRead) + 8 (выравнивание)

mov r8, rcx ;Третий параметр ReadFile - размер буфера

mov rcx, rax ; Первый параметр ReadFile - дескриптор файла

mov rdx, rdi ; Второй параметр ReadFile - адрес буфера

lea r9, bytesRead ; Четвертый параметр ReadFile - количество считанных байтов

mov qword ptr [rsp + 32], 0 ; Пятый параметр ReadFile - 0

call ReadFile ; вызов функции RaedFile

test rax, rax ; проверяем на ошибку

mov eax, bytesRead ; если ошибки нет, в RAX количество считанных байтов

jnz exit ; если в RAX ненулевое значение

mov rax, -1 ; помещаем условный код ошибки

exit:

add rsp, 56

ret

bytesRead equ [rsp+40] ; область в стеке для хранения количества считанных байтов

read endp

; Процедура для считывания данных с консоли

; Параметры:

; RDI - буфер для считывания

; RCX - длина буфера

; Результат - в RAX количество записанных байтов или -1, если произошла ошибка

readFromConsole proc

sub rsp, 32

push rcx ; сохраняем количество символов

mov rcx, -10 ; Аргумент для GetStdHandle - STD_INPUT

call GetStdHandle ; вызываем функцию GetStdHandle

pop rcx

call read

add rsp, 32

ret

readFromConsole endp

; Процедура перевода символов в верхний регистр

; Параметры:

; RSI - строка символов для перевода в верхний регистр

; RCX - количество символов

toUpper proc

push rcx ; изменяем rcx, поэтому сохраним его в стеке

while_start:

test rcx, rcx

jz while_end

dec rcx

cmp byte ptr [rsi + rcx], 122

ja while_start

cmp byte ptr [rsi + rcx], 97

jb while_start

and byte ptr [rsi + rcx], 011011111b ; преобразование к верхнему регистру

jmp while_start

while_end:

pop rcx

ret

toUpper endp

; Параметры:

; RSI - адрес строки

; RCX - длина строки

; RAX - дескриптор файла

; Результат - через RAX возвращаем количество записанных байтов

write proc

sub rsp, 56

mov rdx, rsi ; Второй параметр - строка

mov r8, rcx ; Третий параметр - длина строки

mov rcx, rax ; Первый параметр WriteFile - в регистр RCX помещаем дескриптор файла - консольного вывода

lea r9, bytesWritten ; Четвертый параметр WriteFile - адрес для получения записанных байтов

mov qword ptr [rsp + 32], 0 ; Пятый параметр WriteFile

call WriteFile

test rax, rax ; проверяем на наличие ошибки

mov eax, bytesWritten ; если все нормально, помещаем в RAX количество записанных байтов

jnz exit

mov rax, -1 ; Возвращаем через RAX код ошибки

exit:

add rsp, 56

ret

bytesWritten equ [rsp+40]

write endp

; Процедура вывода произвольной строки на консоль

; Параметры

; RSI - адрес строки

; RCX - количество символов

; Результат - в RAX количество записанных байтов или -1, если произошла ошибка

writeToConsole proc

sub rsp, 32

push rcx ; сохраняем количество символов

mov rcx, -11 ; Аргумент для GetStdHandle - STD_OUTPUT

call GetStdHandle ; вызываем функцию GetStdHandle

pop rcx ; восстанавливаем RCX - количество символов

call write

add rsp, 32

ret

writeToConsole endp

main proc

lea rdi, buffer ; буфер для считывания данных

mov rcx, len ; размер буфера

call readFromConsole ; считываем данные с консоли

lea rsi, buffer ; обрабатываемая строка

mov rcx, rax ; длина строки - из readFromConsole

call toUpper ; переводим строку в верхний регистр

call writeToConsole ; выводим преобразованную строку на консоль

ret

main endp

end

В данном случае все действия разбиты на процедуры. Процедура readFromConsole считывает данные в буфер, при этом в регистр RAX заносится количество считанных символов. Затем процедура toUpper переводит все символы в нижнем регистре в верхний регистр. И далее процедура writeToConsole выводит преобразованную строку на консоль.

Mikl___ · 1 ноя 2026 в 08:51

Взаимодействие с WinAPI
Создание, открытие и закрытие файла
Для создания файла в WinAPI можно использовать функцию CreateFileA. Она имеет следующий прототип на C++:

Код (C):

HANDLE CreateFileA(

[in] LPCSTR lpFileName,

[in] DWORD dwDesiredAccess,

[in] DWORD dwShareMode,

[in, optional] LPSECURITY_ATTRIBUTES lpSecurityAttributes,

[in] DWORD dwCreationDisposition,

[in] DWORD dwFlagsAndAttributes,

[in, optional] HANDLE hTemplateFile

);

Она принимает следующие параметры:

lpFileName: строка - имя файла для открытия, передается через регистр RCX

dwDesiredAccess: представляет 32-битное число и задает режим доступа (открытие на чтение, запись или на то и другое), передается через регистр RDX
Для создания и открытия файла на запись, устанавливаливается 30-й бит числа, а для чтения - 31-й бит. Примеры:

Открытие для записи: 040000000h

Открытие для чтения: 080000000h

Открытие для записи и чтения: 0C0000000h

Открытие для записи и дозаписи (если файл существует): 080000004h

dwShareMode: режим общего доступа, передается через регистр R8

lpSecurityAttributes: указатель на атрибуты безопасности, передается через регистр R9

dwCreationDisposition: флаг, который указывает, надо ли создавать новый файл или открывать уже существующий. Передается через стек по адресу [rsp + 32]
Возможные значения:

1: создавать новый, если только файл не существует, иначе открыть существующий

2: всегда создавать заново, даже если файл с таким именем существует

3: открыть существующий файл

4: всегда открывать файл. Если он не существует, то он создается

dwFlagsAndAttributes: атрибуты файла, передается через стек по адресу [rsp + 40]. В частности, для создания обычного файла без атрибутов пережается число 128.

hTemplateFile: шаблон дескриптора файла, передается через стек по адресу [rsp + 48]

После выполнения функция ReadFile помещает в регистр RAX ненулевое значение, если запись прошла успешно, и ноль, если произошла ошибка.
Полное описание функции можно прочитать в документации.
К примеру создадим в текущей папке файл "test.txt":

Код (ASM):

includelib kernel32.lib ; подключаем библиотеку kernel32.lib

; подключаем функцию CreateFileA

extrn CreateFileA: PROC

.data

filename byte "test.txt",0 ; имя файла

.code

main proc

sub rsp, 56

lea rcx, filename ; имя файла

mov rdx, 0C0000000h ; доступ на запись и чтение 1100 0000 0000 0000 0000 0000 0000 0000

xor r8, r8 ; Эксклюзивный доступ

xor r9, r9 ; атрибуты безопасности отсутствуют

mov r10, 2 ; Всегда создавать новый файл

mov [rsp + 32], r10

mov r10, 128 ; обычный файл без атрибутов

mov [rsp + 40], r10

mov [rsp + 48], r9 ; NULL - шаблон не используется

call CreateFileA

add rsp, 56

ret

main endp

end

В данном случае создаваемый файл будет называться "test.txt". Он будет доступен для чтения и для записи. Для чтения надо установить 31-й бит 32-разрядного числа, а для записи - 30-й бит, поэтому в регистр RDX помещаем число 1100 0000 0000 0000 0000 0000 0000 0000 или 0C0000000h в шестнадцатеричной системе.
Общий доступ к файлу нам не нужен, поэтому в регистр R8 помещаем число 0. Атрибуты безопасности в данном случае тоже не нужны, поэтому в регистр R9 также помещается число 0.
Чтобы файл создавался всегда, в стек по адресу [rsp + 32] помещаем число 2.
Файл будет создаваться обычный без каких-то атрибутов, поэтому по адресу [rsp + 40] в стек помещаем число 128.
Шаблон дескриптора файла тоже не важен, поэтому по адресу [rsp + 48] в стек помещается число 0.
После вызова функции CreateFileA будет создан файл "test.txt", а в регистр RAX при успешном открытии файла будет помещен дескриптор этого файла. В дальнейшем, используя данный дескриптор, мы можем записывать или считывать файл. Если же в процессе открытия произошла ошибка, то в RAX помещается число -1.
Если у нас уже есть файл, который мы хотим открыть для операций чтения-записи, то в стек по адресу [rsp + 32] передается число 3.
Закрытие файла
Для закрытия файла применяется функция CloseHandle со следующим прототипом на языке C++:

Код (C):

BOOL CloseHandle(

[in] HANDLE hObject

);

В качестве параметра ей передается через регистр RCX дескриптор закрываемого файла. Результатом функции является ненулевое значение, если закрытие завершилось удачно, и 0, если произошла ошибка. Например:

Код (ASM):

includelib kernel32.lib ; подключаем библиотеку kernel32.lib

extrn CreateFileA: proc

extrn CloseHandle: proc

.data

filename byte "test.txt",0 ; имя файла

.code

; Процедура открытия существующего файла

; Параметр - в RSI - имя файла

; Результат - в RAX - дескриптор открытого файла

openFile proc

sub rsp, 56

mov rcx, rsi ; имя файла

mov rdx, 0C0000000h ; доступ на запись и чтение

xor r8, r8 ; Эксклюзивный доступ

xor r9, r9 ; атрибуты безопасности отсутствуют

mov r10, 3 ; открыть существующий файл

mov [rsp + 32], r10

mov r10, 128 ; обычный файл без атрибутов

mov [rsp + 40], r10

mov [rsp + 48], r9 ; NULL - шаблон не используется

call CreateFileA

add rsp, 56

ret

openFile endp

; Процедура закрытия существующего файла

; Параметр - в RAX - дескриптор открытого файла

; Результат - в RAX - состояние операции (ошибка или нет)

closeFile proc

sub rsp, 40

mov rcx, rax ; В RCX помещаем дескриптор файла

call CloseHandle

add rsp, 40

ret

closeFile endp

main proc

lea rsi, filename

call openFile ; открываем файл

call closeFile ; закрываем файл

ret

main endp

end

Здесь открытие файла вынесено в процедуру openFile, а закрытие - в closeFile. Перед вызовом closeFile предполагается, что в регистре RAX содержится дескриптор файла, полученный после вызова openFile.
Получение ошибки
В процессе работы с файлами могут возникать ошибки. Чтобы идентифицировать их WinAPI предоставляет функцию GetLastError:

Код (C):

DWORD GetLastError();

Данная функция не принимает параметров, лишь возвращает код ошибки. Применим эту функцию:

Код (ASM):

includelib kernel32.lib ; подключаем библиотеку kernel32.lib

extrn CreateFileA: proc

extrn CloseHandle: proc

extrn GetLastError: proc

.data

filename byte "test.txt",0 ; имя файла

.code

; Процедура открытия существующего файла

; Параметр - в RSI - имя файла

; Результат - в RAX - дескриптор открытого файла

openFile proc

sub rsp, 56

mov rcx, rsi ; имя файла

mov rdx, 0C0000000h ; доступ на запись и чтение

xor r8, r8 ; Эксклюзивный доступ

xor r9, r9 ; атрибуты безопасности отсутствуют

mov r10, 3 ; открыть существующий файл

mov [rsp + 32], r10

mov r10, 128 ; обычный файл без атрибутов

mov [rsp + 40], r10

mov [rsp + 48], r9 ; NULL - шаблон не используется

call CreateFileA

add rsp, 56

ret

openFile endp

; Процедура закрытия существующего файла

; Параметр - в RAX - дескриптор открытого файла

; Результат - в RAX - состояние операции (ошибка или нет)

closeFile proc

sub rsp, 40

mov rcx, rax

call CloseHandle

add rsp, 40

ret

closeFile endp

; Процедура получения последней ошибки Windows

; Результат - в RAX код ошибки

getError proc

sub rsp, 40

call GetLastError

add rsp, 40

ret

getError endp

main proc

lea rsi, filename

call openFile ; открываем файл

mov rax, 0 ; помещаем в RAX некорректный дескриптор файла

call closeFile ; закрываем файл

call getError ; получаем последнюю ошибку

ret

main endp

end

Для имитации ошибки в процедуру closeFile передается некорректный дескриптор файла. Для получения ошибки после закрытия файла вызывается процедура getError, в которой получаем код ошибки. После выполнения программы с помощью команды echo %ERRORLEVEL% можно получить код ошибки, который хранится в RAX:

c:\asm>hello.exe
c:\asm>echo %ERRORLEVEL%
6
c:\asm>

Здесь видно, что код ошибки - 6. Что это значит? Мы можем обратиться к документации, в частности, свериться по списку ошибок - https://learn.microsoft.com/ru-ru/windows/win32/debug/system-error-codes--0-499-. И мы увидим, что 6 - это код ошибки "ERROR_INVALID_HANDLE", то есть передан некорректный дескриптор файла.

Mikl___ · 1 ноя 2026 в 08:53

Взаимодействие с WinAPI
Запись в текстовый файл
Для записи в файл мы можем использовать ранее рассмотренную функцию WriteFile, передавая ей дескриптор открытого файла. Например:

Код (ASM):

includelib kernel32.lib ; подключаем библиотеку kernel32.lib

extrn WriteFile: proc

extrn CreateFileA: proc

extrn CloseHandle: proc

.data

text byte "Hello METANIT.COM" ; тест для записи

textLen = $ - text ; длина текста

filename byte "test.txt",0 ; имя файла

.code

; Параметры:

; RSI - адрес строки

; RCX - длина строки

; RAX - дескриптор файла

; Результат - через RAX возвращаем количество записанных байтов

write proc

sub rsp, 56

mov rdx, rsi ; Второй параметр - строка

mov r8, rcx ; Третий параметр - длина строки

mov rcx, rax ; Первый параметр WriteFile - в регистр RCX помещаем дескриптор файла - консольного вывода

lea r9, bytesWritten ; Четвертый параметр WriteFile - адрес для получения записанных байтов

mov qword ptr [rsp + 32], 0 ; Пятый параметр WriteFile

call WriteFile

test rax, rax ; проверяем на наличие ошибки

mov eax, bytesWritten ; если все нормально, помещаем в RAX количество записанных байтов

jnz exit

mov rax, -1 ; Возвращаем через RAX код ошибки

exit:

add rsp, 56

ret

bytesWritten equ [rsp+40]

write endp

; Процедура открытия существующего файла

; Параметр - в RSI - имя файла

; Результат - в RAX - дескриптор открытого файла

openFile proc

sub rsp, 56

mov rcx, rsi ; имя файла

mov rdx, 080000004h ; доступ на запись и дозапись

xor r8, r8 ; Эксклюзивный доступ

xor r9, r9 ; атрибуты безопасности отсутствуют

mov r10, 1 ; открыть существующий файл, если он не существует - создать

mov [rsp + 32], r10

mov r10, 128 ; обычный файл без атрибутов

mov [rsp + 40], r10

mov [rsp + 48], r9 ; NULL - шаблон не используется

call CreateFileA

add rsp, 56

ret

openFile endp

; Процедура закрытия существующего файла

; Параметр - в RAX - дескриптор открытого файла

; Результат - в RAX - состояние операции (ошибка или нет)

closeFile proc

sub rsp, 40

mov rcx, rax ; В RCX помещаем дескриптор файла

call CloseHandle

add rsp, 40

ret

closeFile endp

main proc

lea rsi, filename

call openFile ; открываем файл

push rax ; сохраняем дескриптор файла

lea rsi, text ; записываемая строка

mov rcx, textLen ; длина записываемой строки

call write ; записываем строку

pop rax ; восстанавливаем дескриптор файла для закрытия файла

call closeFile ; закрываем файл

ret

main endp

end

Здесь запись в файл производится в процедуре write, которая через регистр RSI получает адрес записываемого текста, через RCX - количество записываемых символов, а через RAX - дескриптор файла. Если файл уже существует, то выполняется дозапись.
Обработка ошибок
При записи могут возникнуть ошибки. Так, в программе выше у нас несколько потенциальных ситуации возникновения ошибки - файл не будет открыт, запись не будет произведена, закрытие файла пройдет неудачно. В качестве примера рассмотрим обработку ошибки при открытии файла:

Код (ASM):

includelib kernel32.lib

extrn GetStdHandle: proc

extrn WriteFile: proc

extrn CreateFileA: proc

extrn CloseHandle: proc

.data

text byte "Hello METANIT.COM", 10 ; тест для записи

textLen = $ - text ; длина текста

filename byte "test.txt",0 ; имя файла

badOpenMsg byte "Unable to open file", 10

badOpenMsgLen = $ - badOpenMsg

goodWriteMsg byte "File has been written", 10

goodWriteMsgLen = $ - goodWriteMsg

stdout qword 0 ; дескриптор консольного вывода

stdoutSet byte 0 ; установлен ли дескриптор консольного вывода

.code

; Параметры:

; RSI - адрес строки

; RCX - длина строки

; RAX - дескриптор файла

; Результат - через RAX возвращаем количество записанных байтов

write proc

sub rsp, 56

mov rdx, rsi ; Второй параметр - строка

mov r8, rcx ; Третий параметр - длина строки

mov rcx, rax ; Первый параметр WriteFile - в регистр RCX помещаем дескриптор файла - консольного вывода

lea r9, bytesWritten ; Четвертый параметр WriteFile - адрес для получения записанных байтов

mov qword ptr [rsp + 32], 0 ; Пятый параметр WriteFile

call WriteFile

test rax, rax ; проверяем на наличие ошибки

mov eax, bytesWritten ; если все нормально, помещаем в RAX количество записанных байтов

jnz exit

mov rax, -1 ; Возвращаем через RAX код ошибки

exit:

add rsp, 56

ret

bytesWritten equ [rsp+40]

write endp

; Процедура вывода произвольной строки на консоль

; Параметры

; RSI - адрес строки

; RCX - количество символов

; Результат - в RAX количество записанных байтов или -1, если произошла ошибка

writeToConsole proc

cmp stdoutSet, 1

jz writeData ; если дескриптор консольного вывода установлен

sub rsp, 32

push rcx ; сохраняем количество символов

mov rcx, -11 ; Аргумент для GetStdHandle - STD_OUTPUT

call GetStdHandle ; вызываем функцию GetStdHandle

pop rcx ; восстанавливаем RCX - количество символов

add rsp, 32

mov stdout, rax ; помещаем в stdout дескриптор консольного вывода

mov stdoutSet, 1 ; дескриптор консольного вывода установлен

writeData:

mov rax, stdout

call write

ret

writeToConsole endp

; Процедура открытия существующего файла

; Параметр - в RSI - имя файла

; Результат - в RAX - дескриптор открытого файла

openFile proc

sub rsp, 56

mov rcx, rsi ; имя файла

mov rdx, 0B0000004h ; доступ на запись и чтение

xor r8, r8 ; Эксклюзивный доступ

xor r9, r9 ; атрибуты безопасности отсутствуют

mov r10, 4 ; открыть существующий файл, если он не существует - создать

mov [rsp + 32], r10

mov r10, 128 ; обычный файл без атрибутов

mov [rsp + 40], r10

mov [rsp + 48], r9 ; NULL - шаблон не используется

call CreateFileA

add rsp, 56

ret

openFile endp

; Процедура закрытия существующего файла

; Параметр - в RAX - дескриптор открытого файла

; Результат - в RAX - состояние операции (ошибка или нет)

closeFile proc

sub rsp, 40

mov rcx, rax ; В RCX помещаем дескриптор файла

call CloseHandle

add rsp, 40

ret

closeFile endp

main proc

lea rsi, filename

call openFile ; открываем файл

cmp eax, -1 ; если произошла ошибка открытия

je badOpen

push rax ; сохраняем дескриптор файла

lea rsi, text ; записываемая строка

mov rcx, textLen ; длина записываемой строки

call write ; записываем строку

pop rax ; восстанавливаем дескриптор файла для закрытия файла

call closeFile ; закрываем файл

lea rsi, goodWriteMsg

mov rcx, goodWriteMsgLen

call writeToConsole

jmp exit

badOpen: ; если не удалось открыть файл

lea rsi, badOpenMsg

mov rcx, badOpenMsgLen

call writeToConsole

exit:

ret

main endp

end

Здесь добавлена процедура writeToConsole для вывода диагностического сообщения на консоль. Если при открытии файла возникает проблема, соответственно в регистре EAX отказывается число -1, то переходим к метке badOpen для обработки этой ситуации. В коде выше в этом случае просто выводим сообщение. Если же запись в файл прошла успешно, выводим другое сообщение на консоль.

Бит	Значение
0	Выражение представляет метку
1	Выражение представляет перемещаемое значение
2	Выражение представляет константу
3	Выражение представляет прямую адресацию
4	Выражение представляет регистр
5	устравшее (выражение содержит неопределенный идентификатор)
6	Выражение представляет обращение к памяти стека
7	Выражение ссылается на внешний идентификатор

С/С++	Размер (в байтах)	Ассемблер
char/signed char	1	sbyte
unsigned char	1	byte
short int	2	sword
short unsigned	2	word
int	4	sdword
unsigned (unsigned int)	4	dword
long / long int	4	sdword
unsigned long	4	dword
long long	8	sqword
unsigned long long	8	qword
float	4	real4
double	4	real8
указатель	8	qword

Войти или зарегистрироваться

Руководство по ассемблеру MASM для архитектуры Intel x86-64

Mikl___ Супермодератор Команда форума

SIMD

Загрузка в регистры константных значений

Mikl___ Супермодератор Команда форума

SIMD

Сохранение состояния регистров SSE/AVX

Mikl___ Супермодератор Команда форума

Строки

Операции со строками

Mikl___ Супермодератор Команда форума

Строки

Сравнение строк

Mikl___ Супермодератор Команда форума

Строки

Поиск в строке

Mikl___ Супермодератор Команда форума

Строки

Сохранение и получение элементов строк

Mikl___ Супермодератор Команда форума

Макросы

Определение макросов

Mikl___ Супермодератор Команда форума

Макросы

Параметры макроса

Mikl___ Супермодератор Команда форума

Макросы

Метки в макросах

Mikl___ Супермодератор Команда форума

Макросы

Условная компиляция и циклы

Mikl___ Супермодератор Команда форума

Макросы

Генерация таблиц для поиска

Mikl___ Супермодератор Команда форума

Взаимодействие с кодом на C/C++

Первая программа на MASM/C

Mikl___ Супермодератор Команда форума

Взаимодействие с кодом на C/C++

Передача параметров из ассемблера в функцию C/C++

Mikl___ Супермодератор Команда форума

Взаимодействие с кодом на C/C++

Возвращение результата из процедуры ассемблера в код на C/C++

Mikl___ Супермодератор Команда форума

Взаимодействие с кодом на C/C++

Практически пример. Обработка консольного ввода

Mikl___ Супермодератор Команда форума

Взаимодействие с WinAPI

Запись в файл и вывод на консоль

Mikl___ Супермодератор Команда форума

Взаимодействие с WinAPI

Считывание файла и ввод с консоли

Mikl___ Супермодератор Команда форума

Взаимодействие с WinAPI

Практический пример. Обработка ввода

Mikl___ Супермодератор Команда форума

Взаимодействие с WinAPI

Создание, открытие и закрытие файла

Mikl___ Супермодератор Команда форума

Взаимодействие с WinAPI

Запись в текстовый файл

Быстрый поиск